Fix #392: Cmd+A selects a focused field's text or the type being edited

Select All (Cmd/Ctrl+A) now follows the keyboard, as in Illustrator:

- macOS menu bar: the system menu takes Cmd+A/X/C/V before the window
  sees them, so a focused panel, dialog or search field got the document
  command. `menus::invoke_from_system_menu` (used by `NativeMenu::poll`)
  hands Select All, Cut, Copy and Paste to a focused text field as the
  events its keys would send; clicks on those menu items follow the same
  rule. Other commands, and these with no field focused, run as before.
- Type tool: `select.all` itself selects all of the text being edited
  while the Type tool edits (returns {editing, start, end}), so the menu,
  the shortcut, the control channel and headless MCP (`press_key`) agree.
  The UI's own Select All interception and the Type tool's hard-wired
  Cmd+A are gone; Cmd+A reaches it through the Select All shortcut.
- Windows, Linux and the web already left Cmd+A to a focused field; now
  covered by headless app-frame tests (field, Type tool, canvas).

Docs: docs/mcp.md (Select All while editing type), ROADMAP. Not yet:
Select All across threaded frames (one frame's text is selected).

Co-Authored-By: Claude Opus 5.5 <[email protected]>

ROADMAP.md

@@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob
 
 This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands.
 
-_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374) and PDF/`.ai` import keeping strokes live and hidden and nested layers (#372) and per-corner Live Corners (#381); see [Honest assessment](#honest-assessment-2026-10-05))._
+_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374), PDF/`.ai` import keeping strokes live and hidden and nested layers (#372), per-corner Live Corners (#381) and SVG type opening at the size it draws at (#396); see [Honest assessment](#honest-assessment-2026-10-05))._
 
 ## Where we are
 
@@ -42,7 +42,7 @@ since 2026-10-01.
 | **Bundled content:** brush, symbol, style and swatch libraries | ~30% | Ours are original and generated in code, and far fewer than Illustrator ships; brush and symbol libraries are still missing |
 | **Performance** | unverified | Multithreaded, off-thread rendering and caches are in place. The last budget run (2026-10-01, loaded machine) measured 290 ms for a 50k-path fit against a 16 ms budget. Re-run `vectorcraft-cli perf` on an idle machine |
 | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA |
-| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); hybrid-graphics laptops render on the power-saving GPU by default (#306); web drops land in the document they were dropped on (#359); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
+| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work, and Finder opens every readable format with the macOS app (#295, #354); hybrid-graphics laptops render on the power-saving GPU by default (#306); web drops land in the document they were dropped on (#359); a web page that loses its WebGPU device or WebGL context restarts its graphics with the same documents (#369); Windows/Linux packaging and accessibility are pending; an experimental, unsupported Windows 7 x64 OpenGL build exists (community-contributed, not verified by maintainers) |
 | **Agent automation** | beyond Illustrator | Every command, gesture and dialog is drivable over MCP, the CLI and the control channel |
 
 ### Where we're lacking (in priority order)
@@ -105,6 +105,7 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - Four brightness themes, persistent preferences.
   - Dialogs open with their first field focused and its value selected: type a value and press Enter (Move, Rotate, Scale…). Number fields in panels and dialogs step with Up/Down (Shift: ten, Ctrl/Cmd: a tenth of their unit), applied at once.
   - Tab shows and hides the panels (in the Type tool it types a tab) without moving the keyboard focus onto a field, so the next shortcut or letter still works; in dialogs and panel fields it moves between fields.
+  - Cmd/Ctrl+A follows the keyboard: in a panel, dialog or search field it selects the field's text, while the Type tool edits it selects all of that text (also `select.all` over MCP), and only otherwise every object. On macOS the menu bar's Select All, Cut, Copy and Paste (keys or clicks) act on a focused field too. Not yet: Select All across threaded frames (one frame's text is selected).
   - On Windows and Linux the app bar is the window's title bar (its own minimize, maximize and close buttons, drag to move, edges to resize), with the dragon app icon as the brand mark; dialogs and menus size to their content. As on a native menu bar, once one menu is open, moving the pointer onto another title opens that one.
 - **Tools:**
   - **Selection:** Selection, Direct/Group Selection, Magic Wand, Lasso. Dragging a path segment with Direct Selection bends it when it's curved (its anchors stay) and moves its two anchors when it's straight, one undo step; the fill, Shift or Alt still pick the whole path (Alt-drag copies it).
@@ -145,11 +146,11 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 - **Fonts:** a font is found by any of its names (family and style in every language of its name table, legacy family/style pairs, PostScript name), so documents from other apps open with the font they name; Find Font and `text.fonts` say for each font whether it was found exactly, by another name, substituted or missing, and how many glyphs are missing. PDF and `.ai` import brings Japanese text back as live type: CID fonts without a ToUnicode map read through the standard CMaps, vertical columns (WMode 1) as vertical type, letter spacing as tracking; a glyph is live type only when the installed font (in the closest style of its family) draws the same glyph, and text in a font that isn't installed comes in as live type shown in the fallback font until the font is installed (exports that draw it — PDF, EPS, EMF/WMF, raster, SVG outlines or embedded fonts — warn that they wrote the fallback font; `textAs: outlines` keeps the PDF's embedded glyphs).
 - **Files (M4):**
   - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash (browser tabs hold their copies with Web Locks too, so a background tab's copies are never taken for a crash's, and a tab repairs copies another removed when it resumes: #367), background save and export.
-  - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units; PDF and PDF-compatible `.ai` in and out (layers, with hidden ones kept hidden with their art and nested ones as sublayers; strokes kept live, a fill and a stroke of one outline as one object; masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, an `.ai`'s white page under its layers left out rather than coming in as art, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3). CMYK images keep their ink amounts from PDF import (and from placed CMYK TIFFs) to PDF export: a CMYK JPEG passes through unchanged, others stay CMYK (DeviceCMYK, or ICC-based CMYK in PDF/X-3/X-4) unless the Output settings convert them; the canvas shows them through the working CMYK profile (#320).
+  - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units (SVG type under a transform or `viewBox` scale opens at the size it draws at, the scale moved into its size, leading, baseline shift and strokes, a stretch, skew or rotation kept as its transform: #396); PDF and PDF-compatible `.ai` in and out (layers, with hidden ones kept hidden with their art and nested ones as sublayers; strokes kept live, a fill and a stroke of one outline as one object; masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, an `.ai`'s white page under its layers left out rather than coming in as art, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3). CMYK images keep their ink amounts from PDF import (and from placed CMYK TIFFs) to PDF export: a CMYK JPEG passes through unchanged, others stay CMYK (DeviceCMYK, or ICC-based CMYK in PDF/X-3/X-4) unless the Output settings convert them; the canvas shows them through the working CMYK profile (#320).
   - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs Illustrator's AGM/CoolType prologs (resource categories, `resourceforall`, `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters, `cshow`, metadata skipped with `flushfile`), so Illustrator 30 EPS files open as vectors, and falls back to its palette TIFF preview. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole).
   - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours.
 - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped.
-- **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so the desktop app asks for the power-saving GPU by default (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306). Preferences › Performance › Graphics Processor (`gpuPreference`) or `WGPU_POWER_PREF` picks the discrete one; Help › About and `ui.inspect` name the adapter in use.
+- **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so the desktop app asks for the power-saving GPU by default (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306). Preferences › Performance › Graphics Processor (`gpuPreference`) or `WGPU_POWER_PREF` picks the discrete one; Help › About and `ui.inspect` name the adapter in use. When the browser drops the page's WebGPU device or WebGL context, the web build writes recovery copies, starts again on new graphics with the same app and uploads its textures again; if it can't, it removes the stale canvas and says to reload, which offers the copies back. The desktop app writes the copies and says to restart (#369).
 - **Tests and robustness:** ~2,840 automated tests: model-based property tests, a junk-parameter sweep over every command, import fuzzing (SVG, PDF, libraries), golden renders, and MCP end-to-end tests over stdio. Shipped code never panics (workspace lints and a rollback safety net; see `docs/development.md`).
 
 ## Milestones and estimates

apps/vectorcraft-web/src/web.rs

@@ -1,12 +1,14 @@
-//! The browser shell: web `Services`, drag-and-drop, and the eframe web runner.
+//! The browser shell: web `Services`, drag-and-drop, the eframe web runner, and starting again
+//! with new graphics when the page loses them (#369).
 
-use std::cell::Cell;
+use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 
 use vectorcraft_engine::Session;
 use vectorcraft_engine::cmd::fileio;
-use vectorcraft_engine::cmd::recovery::{Hold, RecoveryStore};
+use vectorcraft_engine::cmd::recovery::{self, Hold, RecoveryStore};
+use vectorcraft_ui_egui::graphics::GraphicsLoss;
 use vectorcraft_ui_egui::place::{DropTarget, PlaceArrival, PlaceInbox};
 use vectorcraft_ui_egui::print::{PrintJob, PrintService, Printer};
 use vectorcraft_ui_egui::{Services, VectorcraftApp};
@@ -23,58 +25,123 @@ type DragPos = Rc<Cell<Option<(f32, f32, bool)>>>;
 const CANVAS_ID: &str = "vectorcraft_canvas";
 const LOADING_ID: &str = "vectorcraft_loading";
 
+/// How many times the page starts again with new graphics after losing them before it gives up
+/// (a GPU that keeps failing).
+const MAX_RESTARTS: u32 = 3;
+
+/// What the page keeps while the app runs, across graphics restarts.
+#[derive(Clone)]
+struct Host {
+    runner: eframe::WebRunner,
+    inbox: Inbox,
+    place_inbox: PlaceInbox,
+    drag: DragPos,
+    /// The page's Web Locks for Data Recovery, started once before the first frame: a graphics
+    /// restart keeps them, so the tab stays the owner of its recovery area.
+    locks: Option<WebLocks>,
+    /// Graphics restarts so far.
+    restarts: u32,
+}
+
 pub fn start() {
     eframe::WebLogger::init(log::LevelFilter::Info).ok();
-    wasm_bindgen_futures::spawn_local(async {
-        let Some(document) = web_sys::window().and_then(|w| w.document()) else {
-            log::error!("no document");
-            return;
-        };
-        let Some(canvas) = document.get_element_by_id(CANVAS_ID).and_then(|e| e.dyn_into::<web_sys::HtmlCanvasElement>().ok()) else {
-            log::error!("missing <canvas id=\"{CANVAS_ID}\">");
-            return;
-        };
-        let drag = track_drag(&canvas);
+    let Some(canvas) = element(CANVAS_ID).and_then(|e| e.dyn_into::<web_sys::HtmlCanvasElement>().ok()) else {
+        log::error!("missing <canvas id=\"{CANVAS_ID}\">");
+        return;
+    };
+    wasm_bindgen_futures::spawn_local(async move {
         // Before the first frame, which looks for copies a crash left behind.
         let locks = WebLocks::start(RECOVERY_PREFIX).await;
-        let mut options = eframe::WebOptions::default();
-        if query().contains("webgl")
-            && let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup
-        {
-            create.instance_descriptor.backends = eframe::wgpu::Backends::GL;
-        }
-        let result = eframe::WebRunner::new()
-            .start(
-                canvas,
-                options,
-                Box::new(move |cc| {
-                    if let Some(rs) = &cc.wgpu_render_state {
-                        log::info!("vectorcraft-web: wgpu backend {:?}", rs.adapter.get_info().backend);
+        let host = Host {
+            runner: eframe::WebRunner::new(),
+            inbox: Arc::default(),
+            place_inbox: Arc::default(),
+            drag: DragPos::default(),
+            locks,
+            restarts: 0,
+        };
+        run(host, canvas, None).await;
+    });
+}
+
+/// An app whose graphics were lost, on its way to new ones.
+struct Moving {
+    app: VectorcraftApp,
+    /// Its unsaved changes are kept in recovery copies ([`VectorcraftApp::graphics_lost`]).
+    kept: bool,
+}
+
+/// Run the app on `canvas`: the `moving` one when starting again after losing the graphics, else
+/// a new one.
+async fn run(host: Host, canvas: web_sys::HtmlCanvasElement, moving: Option<Moving>) {
+    track_drag(&canvas, &host.drag);
+    let kept = moving.as_ref().map(|m| m.kept);
+    // The app until the new runner takes it (still here if starting fails before).
+    let slot = Rc::new(RefCell::new(moving.map(|m| m.app)));
+    let (runner, taken, page) = (host.runner.clone(), slot.clone(), canvas.clone());
+    let result = runner
+        .start(
+            canvas,
+            web_options(),
+            Box::new(move |cc| {
+                let ctx = &cc.egui_ctx;
+                let loss = GraphicsLoss::default();
+                watch_canvas(&page, &loss, ctx);
+                if let Some(rs) = &cc.wgpu_render_state {
+                    log::info!("vectorcraft-web: wgpu backend {:?}", rs.adapter.get_info().backend);
+                    let (loss, ctx) = (loss.clone(), ctx.clone());
+                    rs.device.set_device_lost_callback(move |reason, msg| loss.report(&ctx, format!("{reason:?}: {msg}")));
+                }
+                let services = services(host.inbox.clone(), host.place_inbox.clone(), ctx.clone(), host.locks.clone());
+                let app = match taken.borrow_mut().take() {
+                    Some(mut app) => {
+                        // The old services asked the old context for frames.
+                        app.services = services;
+                        app.status("The graphics were lost and have been restarted");
+                        app
                     }
-                    let inbox: Inbox = Arc::default();
-                    let place_inbox: PlaceInbox = Arc::default();
-                    let app = VectorcraftApp::new(Session::new(), services(inbox.clone(), place_inbox.clone(), cc.egui_ctx.clone(), locks));
-                    Ok(Box::new(WebShell { app, inbox, place_inbox, drag }))
-                }),
-            )
-            .await;
-        if let Some(el) = document.get_element_by_id(LOADING_ID) {
-            match result {
-                Ok(()) => el.remove(),
-                Err(e) => el.set_inner_html(&format!("<p>VectorCraft failed to start: {e:?}</p><p>A browser with WebGPU or WebGL2 is required.</p>")),
+                    None => VectorcraftApp::new(Session::new(), services),
+                };
+                Ok(Box::new(WebShell { app: Some(app), host, canvas: page, loss }))
+            }),
+        )
+        .await;
+    match (result, kept) {
+        (Ok(()), _) => {
+            if let Some(el) = element(LOADING_ID) {
+                el.remove();
             }
         }
-    });
+        (Err(e), None) => notice(&[&format!("VectorCraft failed to start: {}", js_err(e)), "A browser with WebGPU or WebGL2 is required."]),
+        (Err(e), Some(kept)) => {
+            log::error!("vectorcraft-web: couldn't restart the graphics: {}", js_err(e));
+            give_up(slot.borrow_mut().take(), kept);
+        }
+    }
+}
+
+/// The runner's options: wgpu (WebGPU where available, else WebGL2; `?webgl` forces WebGL2).
+fn web_options() -> eframe::WebOptions {
+    let mut options = eframe::WebOptions::default();
+    if query().contains("webgl")
+        && let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup
+    {
+        create.instance_descriptor.backends = eframe::wgpu::Backends::GL;
+    }
+    options
 }
 
 fn query() -> String {
     web_sys::window().and_then(|w| w.location().search().ok()).unwrap_or_default()
 }
 
-/// Follow file drags over the canvas: drag events carry the pointer position, which egui doesn't
-/// get during a drag.
-fn track_drag(canvas: &web_sys::HtmlCanvasElement) -> DragPos {
-    let pos = DragPos::default();
+fn element(id: &str) -> Option<web_sys::Element> {
+    web_sys::window()?.document()?.get_element_by_id(id)
+}
+
+/// Follow file drags over `canvas` into `pos`: drag events carry the pointer position, which egui
+/// doesn't get during a drag.
+fn track_drag(canvas: &web_sys::HtmlCanvasElement, pos: &DragPos) {
     let p = pos.clone();
     let on_drag = wasm_bindgen::closure::Closure::<dyn FnMut(web_sys::DragEvent)>::new(move |e: web_sys::DragEvent| {
         p.set(Some((e.offset_x() as f32, e.offset_y() as f32, e.shift_key())));
@@ -84,29 +151,123 @@ fn track_drag(canvas: &web_sys::HtmlCanvasElement) -> DragPos {
             log::error!("couldn't follow {kind} events: {e:?}");
         }
     }
-    // The listener lives as long as the page.
+    // The listener lives as long as the canvas.
     on_drag.forget();
-    pos
+}
+
+/// Report the loss of `canvas`'s WebGL context to `loss` (WebGPU devices report theirs through
+/// wgpu).
+fn watch_canvas(canvas: &web_sys::HtmlCanvasElement, loss: &GraphicsLoss, ctx: &egui::Context) {
+    let (loss, ctx) = (loss.clone(), ctx.clone());
+    let on_lost = wasm_bindgen::closure::Closure::<dyn FnMut(web_sys::Event)>::new(move |_: web_sys::Event| {
+        loss.report(&ctx, "the WebGL context was lost");
+    });
+    if let Err(e) = canvas.add_event_listener_with_callback("webglcontextlost", on_lost.as_ref().unchecked_ref()) {
+        log::error!("couldn't watch for a lost WebGL context: {e:?}");
+    }
+    // The listener lives as long as the canvas.
+    on_lost.forget();
+}
+
+/// A new canvas in place of `old`, whose graphics were lost (a canvas whose WebGL context is lost
+/// can't get another).
+fn fresh_canvas(old: &web_sys::HtmlCanvasElement) -> Result<web_sys::HtmlCanvasElement, String> {
+    let new: web_sys::HtmlCanvasElement = old.clone_node().map_err(js_err)?.dyn_into().map_err(|_| "not a canvas")?;
+    old.replace_with_with_node_1(&new).map_err(js_err)?;
+    Ok(new)
+}
+
+/// The graphics are lost for good: the dead canvas goes (it would show a stale picture), the app
+/// (if still here) lets go of its recovery copies so the reloaded page offers them at once, and
+/// the page says what to do.
+fn give_up(app: Option<VectorcraftApp>, kept: bool) {
+    if let Some(mut app) = app {
+        recovery::leave(&mut app.session);
+    }
+    if let Some(canvas) = element(CANVAS_ID) {
+        canvas.remove();
+    }
+    notice(&[
+        "The graphics were lost and couldn't be restarted.",
+        if kept {
+            "Your unsaved changes are kept in this browser: reload the page to get them back."
+        } else {
+            "Reload the page to go on (changes not saved yet may be lost)."
+        },
+    ]);
+}
+
+/// Show `lines` in the middle of the page (where the loading message was).
+fn notice(lines: &[&str]) {
+    let Some(document) = web_sys::window().and_then(|w| w.document()) else { return };
+    let el = match document.get_element_by_id(LOADING_ID) {
+        Some(el) => el,
+        None => {
+            let Ok(el) = document.create_element("div") else { return };
+            el.set_id(LOADING_ID);
+            let Some(body) = document.body() else { return };
+            if let Err(e) = body.append_child(&el) {
+                log::error!("couldn't show a message: {e:?}");
+            }
+            el
+        }
+    };
+    el.set_text_content(None);
+    for line in lines {
+        if let Ok(p) = document.create_element("p") {
+            p.set_text_content(Some(line));
+            // Best effort: the log has the message too.
+            el.append_child(&p).ok();
+        }
+    }
 }
 
 /// Wraps the app to read dropped files asynchronously (browsers can't read them synchronously)
 /// and feed them through the inboxes: placed where they were dropped on the canvas, else opened.
+/// When the graphics are lost it hands the app to a new runner on a new canvas.
 struct WebShell {
-    app: VectorcraftApp,
-    inbox: Inbox,
-    place_inbox: PlaceInbox,
-    drag: DragPos,
+    /// `None` once handed on.
+    app: Option<VectorcraftApp>,
+    host: Host,
+    canvas: web_sys::HtmlCanvasElement,
+    loss: GraphicsLoss,
+}
+
+impl WebShell {
+    /// The graphics were lost (`why`): keep recovery copies, then start again on a new canvas
+    /// with the same app once this frame is over (the runner is busy with it until then).
+    fn restart(&mut self, why: &str) {
+        let Some(mut app) = self.app.take() else { return };
+        let kept = app.graphics_lost(why);
+        let mut host = self.host.clone();
+        host.restarts += 1;
+        let canvas =
+            if host.restarts > MAX_RESTARTS { Err(format!("the graphics were lost {MAX_RESTARTS} times")) } else { fresh_canvas(&self.canvas) };
+        match canvas {
+            Ok(canvas) => wasm_bindgen_futures::spawn_local(run(host, canvas, Some(Moving { app, kept }))),
+            Err(e) => {
+                log::error!("vectorcraft-web: giving up on the graphics: {e}");
+                let runner = host.runner;
+                wasm_bindgen_futures::spawn_local(async move { runner.destroy() });
+                give_up(Some(app), kept);
+            }
+        }
+    }
 }
 
 impl eframe::App for WebShell {
     fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        if let Some(why) = self.loss.take() {
+            self.restart(&why);
+        }
+        let Some(app) = &mut self.app else { return };
         let dropped = ctx.input_mut(|i| std::mem::take(&mut i.raw.dropped_files));
         if !dropped.is_empty() {
-            let at = self.drag.take();
+            let at = self.host.drag.take();
             let z = ctx.zoom_factor();
-            let target = self.app.drop_target(at.map(|(x, y, _)| egui::pos2(x / z, y / z)), at.is_some_and(|a| a.2));
+            let target = app.drop_target(at.map(|(x, y, _)| egui::pos2(x / z, y / z)), at.is_some_and(|a| a.2));
             for f in dropped {
-                let (inbox, place_inbox, ctx) = (self.inbox.clone(), self.place_inbox.clone(), ctx.clone());
+                let (inbox, place_inbox, ctx) = (self.host.inbox.clone(), self.host.place_inbox.clone(), ctx.clone());
                 wasm_bindgen_futures::spawn_local(async move {
                     let name = f.path().file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "dropped".into());
                     match f.bytes_async().await {
@@ -124,15 +285,19 @@ impl eframe::App for WebShell {
                 });
             }
         }
-        self.app.logic(ctx);
+        app.logic(ctx);
     }
 
     fn raw_input_hook(&mut self, _ctx: &egui::Context, raw: &mut egui::RawInput) {
-        self.app.raw_input_hook(raw);
+        if let Some(app) = &mut self.app {
+            app.raw_input_hook(raw);
+        }
     }
 
     fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
-        self.app.ui(ui);
+        if let Some(app) = &mut self.app {
+            app.ui(ui);
+        }
     }
 }
 

apps/vectorcraft/src/main.rs

@@ -25,45 +25,69 @@ mod window;
 
 use vectorcraft_engine::Session;
 use vectorcraft_engine::cmd::fileio;
+use vectorcraft_ui_egui::graphics::GraphicsLoss;
 use vectorcraft_ui_egui::{FilePick, Services, VectorcraftApp};
 
-struct App(VectorcraftApp, #[cfg(target_os = "macos")] Option<native_menu::NativeMenu>);
+struct App {
+    app: VectorcraftApp,
+    /// Reported by wgpu when the window's graphics device is lost (a driver reset).
+    graphics_loss: GraphicsLoss,
+    /// The graphics device was lost and the unsaved changes are kept for Data Recovery.
+    graphics_lost: bool,
+    #[cfg(target_os = "macos")]
+    menu: Option<native_menu::NativeMenu>,
+}
 
 impl eframe::App for App {
     fn logic(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
+        if let Some(why) = self.graphics_loss.take() {
+            // eframe can't give a window a new device: the user saves and starts again.
+            self.graphics_lost = self.app.graphics_lost(&why);
+            self.app.status(if self.graphics_lost {
+                "The graphics device was lost: unsaved changes are kept for Data Recovery. Save your documents and restart VectorCraft"
+            } else {
+                "The graphics device was lost: save your documents and restart VectorCraft"
+            });
+        }
+        if self.graphics_lost && ctx.input(|i| i.viewport().close_requested()) {
+            // The window can't show the Save Changes question: it closes, and the next launch
+            // offers the changes back.
+            vectorcraft_ui_egui::background::wait_all(&mut self.app);
+            return;
+        }
         #[cfg(target_os = "macos")]
         {
-            if self.1.is_none() && std::env::var_os("VECTORCRAFT_NO_NATIVE_MENU").is_none() {
-                self.1 = Some(native_menu::NativeMenu::install(&mut self.0));
+            if self.menu.is_none() && std::env::var_os("VECTORCRAFT_NO_NATIVE_MENU").is_none() {
+                self.menu = Some(native_menu::NativeMenu::install(&mut self.app));
             }
-            if let Some(m) = &mut self.1 {
-                m.poll(&mut self.0);
+            if let Some(m) = &mut self.menu {
+                m.poll(&mut self.app, ctx);
             }
-            open_files(&mut self.0, open_documents::take());
+            open_files(&mut self.app, open_documents::take());
         }
-        self.0.logic(ctx);
-        window::track(ctx, &mut self.0.ui.window);
-        if self.0.ui.status == "quit" {
+        self.app.logic(ctx);
+        window::track(ctx, &mut self.app.ui.window);
+        if self.app.ui.status == "quit" {
             ctx.send_viewport_cmd(egui::ViewportCommand::Close);
         }
     }
     fn raw_input_hook(&mut self, _ctx: &egui::Context, raw: &mut egui::RawInput) {
-        self.0.raw_input_hook(raw);
+        self.app.raw_input_hook(raw);
     }
     fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
-        self.0.ui(ui);
+        self.app.ui(ui);
         #[cfg(target_os = "macos")]
-        if self.0.take_ime_discard() {
+        if self.app.take_ime_discard() {
             discard_marked_text();
         }
     }
     #[cfg(not(feature = "windows7"))]
     fn on_exit(&mut self) {
-        save_prefs(&self.0);
+        save_prefs(&self.app);
     }
     #[cfg(feature = "windows7")]
     fn on_exit(&mut self, _gl: Option<&eframe::glow::Context>) {
-        save_prefs(&self.0);
+        save_prefs(&self.app);
     }
 }
 
@@ -363,11 +387,14 @@ fn main() -> eframe::Result {
                 let recovery = prefs_path().and_then(|p| Some(p.parent()?.join("Data Recovery").to_string_lossy().to_string()));
                 app.session.recovery.set_default_folder(recovery);
             }
+            let graphics_loss = GraphicsLoss::default();
             #[cfg(feature = "wgpu")]
             if let Some(rs) = &cc.wgpu_render_state {
                 let summary = adapter_summary(&rs.adapter.get_info());
                 log::info!("vectorcraft: rendering with {summary} (power preference {power:?})");
                 app.graphics_adapter = Some(summary);
+                let (loss, ctx) = (graphics_loss.clone(), cc.egui_ctx.clone());
+                rs.device.set_device_lost_callback(move |reason, msg| loss.report(&ctx, format!("{reason:?}: {msg}")));
             }
             #[cfg(feature = "windows7")]
             {
@@ -382,11 +409,13 @@ fn main() -> eframe::Result {
             #[cfg(target_os = "macos")]
             open_documents::set_ui(&cc.egui_ctx);
             open_files(&mut app, files);
-            Ok(Box::new(App(
+            Ok(Box::new(App {
                 app,
+                graphics_loss,
+                graphics_lost: false,
                 #[cfg(target_os = "macos")]
-                None,
-            )))
+                menu: None,
+            }))
         }),
     )
 }

apps/vectorcraft/src/native_menu.rs

@@ -33,7 +33,7 @@ pub struct NativeMenu {
 }
 
 /// Accelerator for a shortcut like "Cmd+Shift+]" (modifier-less shortcuts stay in the app so they
-/// don't steal keys from text fields).
+/// don't steal keys from text fields; a focused field still gets Cmd+A/X/C/V, see [`NativeMenu::poll`]).
 fn accel(sc: &str) -> Option<Accelerator> {
     if !(sc.contains("Cmd") || sc.contains("Ctrl") || sc.contains("Alt") || sc.starts_with('F')) {
         return None;
@@ -72,12 +72,13 @@ impl NativeMenu {
         }
     }
 
-    /// Dispatch clicked items and refresh state.
-    pub fn poll(&mut self, app: &mut VectorcraftApp) {
+    /// Dispatch chosen items (a focused text field takes Select All and the clipboard) and refresh
+    /// state.
+    pub fn poll(&mut self, app: &mut VectorcraftApp, ctx: &egui::Context) {
         while let Ok(ev) = MenuEvent::receiver().try_recv() {
             if let Some((cmd, params, _, _)) = self.items.get(ev.id.as_ref()) {
                 let p = if params.is_null() { serde_json::json!({}) } else { params.clone() };
-                menus::invoke(app, cmd, p);
+                menus::invoke_from_system_menu(app, ctx, cmd, p);
             }
         }
         let now = vectorcraft_ui_egui::now_ms();

crates/engine/src/cmd/recovery.rs

@@ -487,6 +487,22 @@ pub fn release(s: &mut Session) {
     store.remove_area(&area);
 }
 
+/// Let go of this session's area but leave its copies, as a crash would, so the next app started
+/// offers them at once instead of waiting for the heartbeat to go stale: for an app that can't go
+/// on (the web page lost its graphics and has to be reloaded). Its documents keep no copies.
+pub fn leave(s: &mut Session) {
+    for st in &mut s.docs {
+        st.recovery = None;
+    }
+    let Some(Own { store, area, hold, beats }) = s.recovery.own.take() else { return };
+    if beats {
+        // Best effort: if the heartbeat stays, the copies are offered once it is stale.
+        let _ = store.remove(&format!("{area}/{BEAT}"));
+    }
+    // The lock or announcement goes too.
+    drop(hold);
+}
+
 /// A document's recovery copy: its entry and the document it holds.
 #[derive(Clone, Debug)]
 pub struct RecoveryCopy {

crates/engine/src/cmd/select.rs

@@ -9,7 +9,15 @@ use super::*;
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
-        cmd!("select.all", "All", ["Select"], Some("Cmd+A"), "{}", has_doc, all),
+        cmd!(
+            "select.all",
+            "All",
+            ["Select"],
+            Some("Cmd+A"),
+            "{} → {count}; while the Type tool edits text, all of that text instead → {editing, start, end} (byte offsets)",
+            has_doc,
+            all
+        ),
         cmd!("select.allOnArtboard", "All on Active Artboard", ["Select"], Some("Cmd+Alt+A"), "{artboard?: index}", has_doc, all_on_artboard),
         cmd!("select.none", "Deselect", ["Select"], Some("Cmd+Shift+A"), "{}", has_doc, none),
         cmd!("select.reselect", "Reselect", ["Select"], Some("Cmd+6"), "{}", has_doc, reselect),
@@ -107,6 +115,18 @@ fn selectable(d: &Document, iso: Option<NodeId>) -> Vec<NodeId> {
 }
 
 fn all(s: &mut Session, _: &Value) -> Result<Value> {
+    // While the Type tool edits text, Select All takes all of that text and leaves the art
+    // selection as it is (Illustrator: text cursor in a text object).
+    if s.tool_wants_text() {
+        s.set_tool_option("selectAll", &json!(true));
+        let editing = s.tool_options()["editing"].clone();
+        let id = editing.as_u64().map(NodeId);
+        let end = id.and_then(|id| match &s.doc().ok()?.doc.node(id)?.kind {
+            NodeKind::Text(t) => Some(t.plain_text().len()),
+            _ => None,
+        });
+        return Ok(json!({ "editing": editing, "start": 0, "end": end.unwrap_or(0) }));
+    }
     let st = s.doc()?;
     let ids = selectable(&st.doc, st.isolation);
     s.select(|_, sel| sel.set(ids.iter().copied()))?;

crates/engine/src/tests_recovery.rs

@@ -269,6 +269,23 @@ fn announced_areas_stay_held_while_their_app_is_paused() {
     assert!(offered(&mut c).is_empty());
 }
 
+#[test]
+fn an_app_that_leaves_has_its_copies_offered_at_once() {
+    for store in [MemoryStore::without_locks(), MemoryStore::announcing(), MemoryStore::default()] {
+        let store = Arc::new(store);
+        let mut a = session_in(&store);
+        a.execute("file.recovery.save", &json!({})).unwrap();
+        let mut b = relaunch(&store);
+        assert!(offered(&mut b).is_empty(), "A still runs");
+        // A can't go on (its page lost its graphics): its copies stay, for the next app at once.
+        cmd::recovery::leave(&mut a);
+        assert!(a.doc().unwrap().recovery.is_none());
+        assert_eq!(copies(store.as_ref()), ["Untitled-1-1"]);
+        assert_eq!(offered(&mut b), ["Untitled-1"]);
+        assert_eq!(restored(b.execute("file.recovery.restore", &json!({})).unwrap()), 1);
+    }
+}
+
 #[test]
 fn folder_areas_are_locked_by_running_apps() {
     let dir = std::env::temp_dir().join(format!("vc-recovery-locks-{}", std::process::id()));

crates/engine/src/tests_textedit.rs

@@ -310,15 +310,18 @@ fn character_panel_flow_styles_the_selected_range_while_editing() {
 fn select_all_and_cut_like_ui() {
     let mut s = session();
     let v = ViewInfo::default();
+    s.execute("shape.rectangle", &json!({"x": 300, "y": 300, "width": 10, "height": 10})).unwrap();
     let id = text(&mut s, "abc def");
     s.select_tool("type", v).unwrap();
     let t = obj(&s, id);
     let p = t.xf * Point::new(2.0, -5.0);
     click(&mut s, p.x, p.y);
-    s.set_tool_option("selectAll", &json!(true));
-    let o = s.tool_options();
-    let len = obj(&s, id).plain_text().len() as u64;
-    let r = s.execute("text.getRange", &json!({"id": o["editing"], "start": o["start"], "end": o["end"].as_u64().unwrap().min(len)})).unwrap();
+    // Select All while editing takes the text, not the art (the rectangle stays unselected).
+    assert!(s.tool_wants_text());
+    let o = s.execute("select.all", &json!({})).unwrap();
+    assert_eq!(o, json!({"editing": id.0, "start": 0, "end": 7}));
+    assert_eq!(s.doc().unwrap().selection.objects, [id]);
+    let r = s.execute("text.getRange", &json!({"id": o["editing"], "start": o["start"], "end": o["end"]})).unwrap();
     assert_eq!(r["text"], json!("abc def"));
     s.set_tool_option("copy", &r["runs"]);
     key(&mut s, ToolKey::Delete, Mods::default());
@@ -326,6 +329,10 @@ fn select_all_and_cut_like_ui() {
     s.tool_text("abc def", v).unwrap();
     s.tool_text("abc def", v).unwrap();
     assert_eq!(obj(&s, id).plain_text(), "abc defabc def");
+    // Not editing: Select All selects the art again.
+    key(&mut s, ToolKey::Escape, Mods::default());
+    assert!(!s.tool_wants_text());
+    assert_eq!(s.execute("select.all", &json!({})).unwrap(), json!({"count": 2}));
 }
 
 #[test]

crates/mcp/src/tests_distortkeys.rs

@@ -1,5 +1,6 @@
 //! `press_key` with the Width and Puppet Warp tools: Delete and Backspace reach the selected width
-//! point or pin, and clear the selected art when the tool has nothing selected.
+//! point or pin, and clear the selected art when the tool has nothing selected. Cmd+A while the
+//! Type tool edits selects the text, not the art.
 
 use serde_json::{Value, json};
 
@@ -64,3 +65,15 @@ fn delete_and_backspace_reach_the_puppet_warp_tool() {
         assert!(!exists(&h, id), "{key} cleared the art");
     }
 }
+
+#[test]
+fn cmd_a_while_the_type_tool_edits_selects_the_text() {
+    let mut h = session();
+    run(&mut h, "shape.rectangle", json!({"x": 300, "y": 300, "width": 20, "height": 20}));
+    let id = run(&mut h, "text.create", json!({"x": 100, "y": 100, "text": "Hello", "size": 20}))["id"].as_u64().unwrap();
+    click(&mut h, "type", 102.0, 95.0);
+    let r = ok(&mut h, "press_key", json!({"key": "A", "mods": {"cmd": true}}));
+    assert_eq!(r["command"], "select.all");
+    assert_eq!(r["result"], json!({"editing": id, "start": 0, "end": 5}));
+    assert_eq!(h.session.doc().unwrap().selection.objects, [vectorcraft_doc::NodeId(id)], "the art selection stays");
+}

crates/svg/src/import.rs

@@ -677,9 +677,12 @@ impl Importer {
             return Some(vec![]);
         }
         let text::PendingText { name, mut obj, servers, paints, non_scaling, under, .. } = self.slots.texts.get(i)?.clone();
+        // The scale the type draws at becomes its size (last, below): text space grows by `grow`.
+        let xf = ts * obj.xf;
+        let grow = text::size_scale(&obj, xf);
         // usvg resolved the `url(#…)` paints (the paths after the main one) in the element's user
         // space; runs paint in text space.
-        let to_text = obj.xf.inverse();
+        let to_text = Affine::scale(grow) * obj.xf.inverse();
         let slot_paint = |im: &mut Self, k: usize, m: Affine| match kids.get(main + 1 + k) {
             Some(usvg::Node::Path(p)) => p.fill().map_or(Paint::None, |f| {
                 let area = kurbo::Shape::bounding_box(&bezpath(p.data(), m));
@@ -697,7 +700,7 @@ impl Importer {
                 run.style.stroke = server(k);
             }
         }
-        obj.xf = ts * obj.xf;
+        obj.xf = xf;
         if non_scaling && !vector_effect::unscale_text(&mut obj, self.screen) {
             let label = if name.is_empty() || made_up(&name) { "a text".to_string() } else { format!("text '{name}'") };
             self.warn(format!("non-scaling stroke on {label} approximated: the text is stretched or skewed"));
@@ -712,6 +715,7 @@ impl Importer {
             ap.set_contents_at(1);
             ap
         });
+        text::fold_scale(&mut obj, grow);
         let mut n = self.named(&name, NodeKind::Text(Box::new(obj)));
         if let Some(ap) = under {
             n.appearance = ap;

crates/svg/src/import/text.rs

@@ -15,12 +15,16 @@
 //! line spacing), other vertical moves become baseline shift, horizontal moves become kerning (an
 //! absolute `x` is measured against the laid-out text), and rotations become character rotation.
 //! `<textPath>` becomes type on a path; vertical `writing-mode` becomes type on a vertical path.
+//!
+//! Type takes the size it draws at: the scale of the transforms and `viewBox` above a `<text>`
+//! moves into its sizes ([`size_scale`], [`fold_scale`]), and the rest (a stretch, skew,
+//! rotation or reflection) stays its transform.
 
 use std::borrow::Cow;
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::fmt::Write as _;
-use std::ops::Range;
+use std::ops::{Range, RangeInclusive};
 use std::rc::Rc;
 use std::str::FromStr;
 
@@ -653,6 +657,52 @@ fn stroke_under(cells: &mut [Cell], label: &str, warnings: &mut Vec<String>) ->
     first
 }
 
+/// The type sizes the Character panel takes, in points.
+const SIZES: RangeInclusive<f64> = 0.1..=1296.0;
+
+/// How much of `xf` (text space → document) [`fold_scale`] makes the type's size: the scale
+/// across the baseline for point type (a stretch along it, a skew, a rotation and a reflection
+/// stay in the transform), the mean scale for type on a path, whose baseline turns. Not past the
+/// Character panel's sizes (the rest stays in the transform); 1 when `xf` collapses the text.
+pub(super) fn size_scale(t: &TextObject, xf: Affine) -> f64 {
+    let [a, b, ..] = xf.as_coeffs();
+    let det = xf.determinant().abs();
+    let k = match t.kind {
+        TextKind::OnPath { .. } => det.sqrt(),
+        _ => det / a.hypot(b),
+    };
+    // To 6 significant digits: usvg's transforms are single precision, and `rotate(30) scale(2)`
+    // makes 7 pt type 14 pt, not 13.9999998 pt (the type draws the same either way).
+    let p = 10f64.powi((5.0 - k.log10().floor()) as i32);
+    let k = (k * p).round() / p;
+    if !(k.is_finite() && k > 0.0) {
+        return 1.0;
+    }
+    let (lo, hi) = t.runs.iter().map(|r| r.style.size).fold((f64::INFINITY, 0.0f64), |(lo, hi), s| (lo.min(s), hi.max(s)));
+    // Sizes already outside the range don't move further out.
+    if k > 1.0 { k.min((SIZES.end() / hi).max(1.0)) } else { k.max((SIZES.start() / lo).min(1.0)) }
+}
+
+/// Make text space `k` times larger and the transform `1 / k` times smaller, so the type draws
+/// the same at `k` times its size (and leading, baseline shift, character strokes and path): the
+/// size the Character panel shows is the size it draws at.
+pub(super) fn fold_scale(t: &mut TextObject, k: f64) {
+    for r in &mut t.runs {
+        let st = &mut r.style;
+        st.size *= k;
+        st.leading = st.leading.map(|l| l * k);
+        st.baseline_shift *= k;
+    }
+    t.scale_char_strokes(k);
+    let up = Affine::scale(k);
+    match &mut t.kind {
+        TextKind::OnPath { path, .. } | TextKind::Area { frame: path } => path.transform(up),
+        TextKind::Point => {}
+    }
+    t.cached_bounds = t.cached_bounds.map(|b| up.transform_rect_bbox(b));
+    t.xf *= Affine::scale(1.0 / k);
+}
+
 /// `v`, or 0 when far-off positions added up past f64's range.
 fn finite(v: f64) -> f64 {
     if v.is_finite() { v } else { 0.0 }

crates/svg/tests/import_text.rs

@@ -385,3 +385,136 @@ fn far_off_positions_stay_finite() {
         assert!(r.style.baseline_shift.is_finite() && r.style.kerning.is_none_or(f64::is_finite) && r.style.rotation.is_finite(), "{r:?}");
     }
 }
+
+/// Drawn bounds of the laid-out text in the document.
+fn drawn(t: &TextObject) -> Rect {
+    t.xf.transform_rect_bbox(layout(FontDb::global(), t).bounds)
+}
+
+/// The linear part of a transform.
+fn linear(t: &TextObject) -> [f64; 4] {
+    let [a, b, c, d, ..] = t.xf.as_coeffs();
+    [a, b, c, d]
+}
+
+fn close4(a: [f64; 4], b: [f64; 4]) -> bool {
+    // usvg's transforms are single precision.
+    a.iter().zip(b).all(|(a, b)| close(*a, b, 1e-6))
+}
+
+#[test]
+fn a_scale_above_text_becomes_its_size() {
+    // #396: a group's or the text's own scale is the size the type shows and draws at.
+    let d = open(
+        r#"<text x="50" y="100" font-size="7">HHHH Hamburg</text>
+        <g transform="scale(3)"><text x="16" y="60" font-size="7">HHHH Hamburg</text></g>
+        <text x="50" y="400" font-size="7" transform="scale(2)">HHHH Hamburg</text>"#,
+    );
+    let t = texts(&d);
+    let sizes: Vec<f64> = t.iter().map(|t| t.first_style().size).collect();
+    assert!(close(sizes[0], 7.0, 1e-9) && close(sizes[1], 21.0, 1e-9) && close(sizes[2], 14.0, 1e-9), "{sizes:?}");
+    for t in &t {
+        assert!(close4(linear(t), [1.0, 0.0, 0.0, 1.0]), "{:?}", t.xf);
+    }
+    assert!(t[1].xf.translation().to_point().distance(Point::new(48.0, 180.0)) < 1e-9, "{:?}", t[1].xf);
+    assert!(t[2].xf.translation().to_point().distance(Point::new(100.0, 800.0)) < 1e-9, "{:?}", t[2].xf);
+    // Drawn as large as their sizes say.
+    let h: Vec<f64> = t.iter().map(|t| drawn(t).height() / t.first_style().size).collect();
+    assert!(close(h[1], h[0], 1e-6) && close(h[2], h[0], 1e-6), "{h:?}");
+}
+
+#[test]
+fn a_viewbox_scale_becomes_the_size() {
+    let d = import(
+        r#"<svg xmlns="http://www.w3.org/2000/svg" width="306" height="396" viewBox="0 0 612 792"><text x="50" y="100" font-size="7">HH</text></svg>"#,
+    )
+    .unwrap();
+    let t = only_text(&d);
+    assert!(close(t.first_style().size, 3.5, 1e-9), "{}", t.first_style().size);
+    assert!(close4(linear(t), [1.0, 0.0, 0.0, 1.0]), "{:?}", t.xf);
+    assert!(t.xf.translation().to_point().distance(Point::new(25.0, 50.0)) < 1e-9, "{:?}", t.xf);
+}
+
+#[test]
+fn a_rotated_scale_scales_every_length_and_keeps_the_rotation() {
+    // The same text written at twice the size: the scale moves into size, leading, baseline
+    // shift and the character strokes; spacing in ems stays.
+    let scaled = open(
+        r#"<text transform="translate(100 50) rotate(30) scale(2)" x="5" y="10" font-size="7" letter-spacing="1" word-spacing="2" stroke="red" stroke-width="0.5" stroke-dasharray="1 2">Ab <tspan baseline-shift="3">c</tspan><tspan x="5" dy="12">Two</tspan></text>"#,
+    );
+    let written = open(
+        r#"<text transform="translate(100 50) rotate(30)" x="10" y="20" font-size="14" letter-spacing="2" word-spacing="4" stroke="red" stroke-width="1" stroke-dasharray="2 4">Ab <tspan baseline-shift="6">c</tspan><tspan x="10" dy="24">Two</tspan></text>"#,
+    );
+    let (s, w) = (only_text(&scaled), only_text(&written));
+    assert_eq!(s.runs, w.runs);
+    assert!(s.runs.iter().any(|r| r.style.leading == Some(24.0) && r.text.contains("Two")), "{:?}", s.runs);
+    assert!(close(s.xf.determinant(), 1.0, 1e-6), "{:?}", s.xf);
+    let r = 30f64.to_radians();
+    assert!(close4(linear(s), [r.cos(), r.sin(), -r.sin(), r.cos()]), "{:?}", s.xf);
+    for (a, b) in glyph_origins(s).iter().zip(glyph_origins(w)) {
+        assert!(a.distance(b) < 1e-6, "{a:?} {b:?}");
+    }
+}
+
+#[test]
+fn a_stretch_or_skew_stays_the_transform() {
+    // The scale across the baseline is the size; a stretch along it or a skew stays.
+    let d = open(
+        r#"<text x="10" y="20" font-size="7" transform="scale(3 1)">HH</text>
+        <text x="10" y="20" font-size="7" transform="scale(1 3)">HH</text>
+        <text x="10" y="20" font-size="7" transform="skewX(20)">HH</text>"#,
+    );
+    let t = texts(&d);
+    let sizes: Vec<f64> = t.iter().map(|t| t.first_style().size).collect();
+    assert!(close(sizes[0], 7.0, 1e-9) && close(sizes[1], 21.0, 1e-9) && close(sizes[2], 7.0, 1e-9), "{sizes:?}");
+    assert!(close4(linear(t[0]), [3.0, 0.0, 0.0, 1.0]), "{:?}", t[0].xf);
+    assert!(close4(linear(t[1]), [1.0 / 3.0, 0.0, 0.0, 1.0]), "{:?}", t[1].xf);
+    assert!(close4(linear(t[2]), [1.0, 0.0, 20f64.to_radians().tan(), 1.0]), "{:?}", t[2].xf);
+    // `scale(1 3)` draws three times as tall as `scale(3 1)`, a third as wide.
+    let (wide, tall) = (drawn(t[0]), drawn(t[1]));
+    assert!(close(tall.height(), 3.0 * wide.height(), 1e-6) && close(3.0 * tall.width(), wide.width(), 1e-6), "{wide:?} {tall:?}");
+    assert!(t[1].xf.translation().to_point().distance(Point::new(10.0, 60.0)) < 1e-9, "{:?}", t[1].xf);
+}
+
+#[test]
+fn type_on_a_scaled_path_takes_the_scale() {
+    let d = open(
+        r##"<g transform="scale(2)"><path id="p" d="M10 100 L110 100" fill="none"/>
+        <text font-size="10"><textPath href="#p">Curve</textPath></text></g>"##,
+    );
+    let t = only_text(&d);
+    assert!(close(t.first_style().size, 20.0, 1e-9), "{}", t.first_style().size);
+    assert!(close(t.xf.determinant(), 1.0, 1e-6), "{:?}", t.xf);
+    let TextKind::OnPath { path, .. } = &t.kind else { panic!("{:?}", t.kind) };
+    let b = t.xf.transform_rect_bbox(path.bounds().unwrap());
+    assert!(close(b.x0, 20.0, 1e-9) && close(b.x1, 220.0, 1e-9) && close(b.y0, 200.0, 1e-9), "{b:?}");
+}
+
+#[test]
+fn folded_sizes_stay_in_the_character_panels_range() {
+    // Past 1296 pt (or under 0.1 pt) the rest of the scale stays the transform.
+    let d = open(
+        r#"<g transform="scale(20)"><text y="10" font-size="100">Big</text></g>
+        <g transform="scale(0.001)"><text y="10" font-size="7">Small</text></g>
+        <text y="10" font-size="2000">Huge</text>"#,
+    );
+    let t = texts(&d);
+    let size = |i: usize| t[i].first_style().size;
+    assert!(close(size(0), 1296.0, 1e-9) && close(size(0) * linear(t[0])[0], 2000.0, 1e-9), "{:?}", t[0].xf);
+    assert!(close(size(1), 0.1, 1e-9) && close(size(1) * linear(t[1])[0], 0.007, 1e-9), "{:?}", t[1].xf);
+    assert!(close(size(2), 2000.0, 1e-9) && close4(linear(t[2]), [1.0, 0.0, 0.0, 1.0]), "unscaled type keeps its size");
+}
+
+#[test]
+fn gradients_on_scaled_text_stay_in_place() {
+    let d = open(
+        r##"<defs><linearGradient id="user" gradientUnits="userSpaceOnUse" x1="20" y1="0" x2="120" y2="0"><stop offset="0" stop-color="#f00"/><stop offset="1" stop-color="#00f"/></linearGradient></defs>
+        <g transform="scale(2)"><text x="20" y="50" font-size="20" fill="url(#user)">Gradient</text></g>"##,
+    );
+    let t = only_text(&d);
+    assert!(close(t.first_style().size, 40.0, 1e-9));
+    let Paint::Gradient(g) = &t.runs[0].style.fill else { panic!("{:?}", t.runs[0].style.fill) };
+    let geom = g.geom.unwrap();
+    let (start, end) = (t.xf * geom.start, t.xf * geom.end);
+    assert!(start.distance(Point::new(40.0, 0.0)) < 1e-6 && end.distance(Point::new(240.0, 0.0)) < 1e-6, "{start:?} {end:?}");
+}

crates/svg/tests/import_units.rs

@@ -115,11 +115,10 @@ fn text_lengths_in_physical_units() {
     assert!(close(o.x, 72.0) && close(o.y, 144.0), "{o:?}");
     let st = t.first_style();
     assert!(close(st.tracking, 100.0), "{}", st.tracking);
-    // User units of a physical root are CSS pixels (0.75 pt): the text carries that scale.
-    let scale = t.xf.as_coeffs()[0];
-    assert!(close(scale, 0.75), "{:?}", t.xf);
-    assert!(close(st.stroke_width * scale, 1.0), "{}", st.stroke_width);
-    assert!(close(st.size * scale, 15.0), "{}", st.size);
+    // User units of a physical root are CSS pixels (0.75 pt): that scale moves into the type.
+    assert!(close(t.xf.as_coeffs()[0], 1.0), "{:?}", t.xf);
+    assert!(close(st.stroke_width, 1.0), "{}", st.stroke_width);
+    assert!(close(st.size, 15.0), "{}", st.size);
 }
 
 #[test]

crates/svg/tests/non_scaling_stroke.rs

@@ -84,9 +84,10 @@ fn type_keeps_its_non_scaling_stroke_width() {
     let (d, warnings) = import_with_report(svg).unwrap();
     let t = text(&d);
     let st = &t.runs[0].style;
-    // Text space is scaled 2×: half the width there is the width on screen.
+    // The scale became the type's size: the stroke and its dashes keep their width on screen.
+    assert!(close(st.size, 40.0) && close(t.xf.determinant(), 1.0), "{} {:?}", st.size, t.xf);
     assert!(close(st.stroke_width * t.xf.determinant().sqrt(), 3.0), "{} {:?}", st.stroke_width, t.xf);
-    assert_eq!(st.stroke_dash.as_ref().map(|d| d.pattern.clone()), Some(vec![2.0, 1.0]));
+    assert_eq!(st.stroke_dash.as_ref().map(|d| d.pattern.clone()), Some(vec![4.0, 2.0]));
     assert!(warnings.is_empty(), "{warnings:?}");
 
     let (_, warnings) = import_with_report(&svg.replace("scale(2)", "scale(2 1)")).unwrap();

crates/svg/tests/roundtrip.rs

@@ -386,6 +386,33 @@ fn text_roundtrip_and_escaping() {
     assert!(t.xf.translation().to_point().distance(Point::new(20.0, 50.0)) < 0.01);
 }
 
+#[test]
+fn scaled_text_roundtrips_at_the_size_it_draws() {
+    // Type scaled with its object (its transform scales it) comes back at the size it draws at,
+    // drawn the same, and stays so on the next round trip; a stretch stays the transform.
+    let at = Affine::translate((20.0, 50.0));
+    let stretch = at * Affine::rotate(0.5) * Affine::scale_non_uniform(2.0, 1.0);
+    for (xf, size) in [(at * Affine::scale(2.0), 18.0), (at * Affine::rotate(0.5) * Affine::scale(3.0), 27.0), (stretch, 9.0)] {
+        let mut t = TextObject::point(Point::ZERO, "Scaled\ntype", CharStyle { size: 9.0, leading: Some(11.0), ..CharStyle::default() });
+        t.xf = xf;
+        let drawn = |t: &TextObject| t.xf.transform_rect_bbox(vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t).bounds);
+        let before = drawn(&t);
+        let id = Document::new(200.0, 200.0).alloc_id();
+        let d = doc_with(vec![Node::new(id, NodeKind::Text(Box::new(t)))]);
+        let once = roundtrip(&d);
+        let NodeKind::Text(t) = &art(&once)[0].kind else { panic!() };
+        // Within the precision of the exported matrix (3 decimals); the second line carries the
+        // leading.
+        let near = |a: f64, b: f64| (a - b).abs() < b * 1e-3;
+        let st = &t.runs.last().unwrap().style;
+        assert!(near(st.size, size) && near(st.leading.unwrap(), 11.0 * size / 9.0), "{xf:?}: {st:?}");
+        assert!(close_rect(drawn(t), before, 0.05), "{xf:?}: {:?} {before:?}", drawn(t));
+        let twice = roundtrip(&once);
+        let NodeKind::Text(t2) = &art(&twice)[0].kind else { panic!() };
+        assert!(near(t2.first_style().size, size) && close_rect(drawn(t2), before, 0.05), "{xf:?}: {:?} {:?}", t2.runs, drawn(t2));
+    }
+}
+
 #[test]
 fn text_on_path_roundtrip() {
     let mut d = Document::new(200.0, 200.0);

crates/ui-egui/src/font_menu.rs

@@ -6,7 +6,6 @@
 //! only those. Preferences › Type › Enable in-menu font previews and Font Preview Size turn the
 //! samples off or size the rows.
 
-use std::cell::RefCell;
 use std::collections::HashMap;
 use std::sync::Arc;
 
@@ -480,7 +479,7 @@ impl Samples {
 }
 
 thread_local! {
-    static SAMPLES: RefCell<Samples> = RefCell::new(Samples::default());
+    static SAMPLES: crate::graphics::TexCache<Samples> = crate::graphics::TexCache::default();
 }
 
 /// The sample of `family` for a row `height` points high: the selected text set in it (else a

crates/ui-egui/src/graphics.rs

@@ -0,0 +1,231 @@
+//! Losing the graphics device, and the textures uploaded to it (#369).
+//!
+//! A window can lose its graphics device: a driver reset or a GPU hang on the desktop, the browser
+//! dropping the page's WebGPU device or WebGL context. Everything uploaded to it is gone and
+//! nothing it draws reaches the screen any more, while the app itself goes on.
+//!
+//! - The host reports the loss through a [`GraphicsLoss`] (from wgpu's device-lost callback, the
+//!   canvas's `webglcontextlost` event), and the app keeps recovery copies of the modified
+//!   documents at once ([`VectorcraftApp::graphics_lost`]).
+//! - The web host then starts again with new graphics and a new egui context, handing it the same
+//!   app. The app notices the new context and makes everything it uploaded to the old one again:
+//!   its fonts and theme, the canvas, and every texture cache ([`TexCache`]).
+
+use std::cell::{Cell, Ref, RefCell, RefMut};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
+
+use crate::VectorcraftApp;
+
+/// Raised by the host when the window's graphics device is lost (from any thread), read on the UI
+/// thread. Cheap to clone; the clones share the report.
+#[derive(Clone, Default)]
+pub struct GraphicsLoss(Arc<Mutex<Option<String>>>);
+
+impl GraphicsLoss {
+    /// The graphics device was lost (`why`, for the log): the next frame of `ctx` handles it. A
+    /// second report before then adds nothing.
+    pub fn report(&self, ctx: &egui::Context, why: impl Into<String>) {
+        let why = why.into();
+        log::error!("vectorcraft: the graphics device was lost: {why}");
+        self.0.lock().unwrap_or_else(|e| e.into_inner()).get_or_insert(why);
+        ctx.request_repaint();
+    }
+
+    /// The loss reported since the last call, if any.
+    pub fn take(&self) -> Option<String> {
+        self.0.lock().unwrap_or_else(|e| e.into_inner()).take()
+    }
+}
+
+/// A number naming egui context `ctx`, the same every call and different from every other
+/// context's.
+pub(crate) fn context_tag(ctx: &egui::Context) -> u64 {
+    static NEXT: AtomicU64 = AtomicU64::new(1);
+    let id = egui::Id::new("vectorcraft-context-tag");
+    if let Some(tag) = ctx.data(|d| d.get_temp::<u64>(id)) {
+        return tag;
+    }
+    ctx.data_mut(|d| *d.get_temp_mut_or_insert_with(id, || NEXT.fetch_add(1, Ordering::Relaxed)))
+}
+
+thread_local! {
+    /// Bumped when the UI moves to a new egui context: [`TexCache`]s made before are emptied.
+    static EPOCH: Cell<u64> = const { Cell::new(0) };
+}
+
+/// The UI moved to a new egui context: every [`TexCache`] of this thread empties at its next use.
+pub(crate) fn forget_textures() {
+    EPOCH.with(|e| e.set(e.get().wrapping_add(1)));
+}
+
+/// A per-thread cache holding textures (thumbnails, previews, samples). Textures belong to the
+/// egui context they were uploaded to, so the cache goes back to `T::default()` when the UI moves
+/// to another one ([`forget_textures`]). Used like the `RefCell` it wraps.
+#[derive(Default)]
+pub(crate) struct TexCache<T> {
+    epoch: Cell<u64>,
+    value: RefCell<T>,
+}
+
+impl<T: Default> TexCache<T> {
+    /// Empty the cache if it was filled for another context.
+    fn refresh(&self) {
+        let now = EPOCH.with(Cell::get);
+        if self.epoch.replace(now) != now {
+            *self.value.borrow_mut() = T::default();
+        }
+    }
+
+    pub(crate) fn borrow(&self) -> Ref<'_, T> {
+        self.refresh();
+        self.value.borrow()
+    }
+
+    pub(crate) fn borrow_mut(&self) -> RefMut<'_, T> {
+        self.refresh();
+        self.value.borrow_mut()
+    }
+}
+
+impl VectorcraftApp {
+    /// The window's graphics device was lost (`why`, from [`GraphicsLoss::take`]): recovery copies
+    /// of the modified documents are written now, since the window may never draw again (even
+    /// with Data Recovery turned off: they go when the documents are saved or closed) → whether
+    /// every modified document has an up-to-date copy (none modified counts).
+    pub fn graphics_lost(&mut self, why: &str) -> bool {
+        if let Err(e) = self.session.execute("file.recovery.save", &serde_json::json!({})) {
+            log::warn!("vectorcraft: no recovery copies after losing the graphics ({why}): {e}");
+        }
+        self.session.documents().iter().filter(|st| st.is_dirty()).all(|st| st.recovery.as_ref().is_some_and(|c| Arc::ptr_eq(&c.doc, &st.doc)))
+    }
+
+    /// Textures live in one egui context. When the host hands the app a new one (it started again
+    /// after losing its graphics), everything uploaded to the old one is made again: the fonts and
+    /// theme, the canvas, the place cursor's thumbnails and every [`TexCache`].
+    pub(crate) fn adopt_context(&mut self, ctx: &egui::Context) {
+        let tag = context_tag(ctx);
+        if self.context == tag {
+            return;
+        }
+        if self.context != 0 {
+            log::info!("vectorcraft: new graphics context: uploading the UI again");
+            forget_textures();
+            self.styled = false;
+            self.fonts_ready = false;
+            self.ui_fonts = Default::default();
+            self.canvas.texture = None;
+            self.canvas.key = None;
+            self.place.forget_textures();
+        }
+        self.context = tag;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use serde_json::json;
+    use vectorcraft_engine::Session;
+    use vectorcraft_engine::cmd::recovery::{MemoryStore, RecoveryStore};
+
+    use super::*;
+    use crate::Services;
+
+    /// One headless frame of the whole window (800×600) in `ctx`.
+    fn frame(app: &mut VectorcraftApp, ctx: &egui::Context) {
+        let raw = egui::RawInput { screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(800.0, 600.0))), ..Default::default() };
+        let mut out = ctx.run_ui(raw, |ui| {
+            app.logic(ui.ctx());
+            app.ui(ui);
+        });
+        out.textures_delta.clear();
+    }
+
+    /// The name of texture `id` in `ctx`, if `ctx` has it.
+    fn texture_name(ctx: &egui::Context, id: egui::TextureId) -> Option<String> {
+        ctx.tex_manager().read().meta(id).map(|m| m.name.clone())
+    }
+
+    fn app() -> VectorcraftApp {
+        let mut app = VectorcraftApp::new(Session::new(), Services::default());
+        app.run("file.new", json!({"width": 200, "height": 100})).unwrap();
+        app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 20})).unwrap();
+        app
+    }
+
+    #[test]
+    fn a_loss_is_reported_once_from_any_thread() {
+        let (loss, ctx) = (GraphicsLoss::default(), egui::Context::default());
+        let (l, c) = (loss.clone(), ctx.clone());
+        std::thread::spawn(move || {
+            l.report(&c, "Unknown: driver reset");
+            l.report(&c, "Destroyed");
+        })
+        .join()
+        .unwrap();
+        assert_eq!(loss.take().as_deref(), Some("Unknown: driver reset"), "the first report wins");
+        assert_eq!(loss.take(), None, "handled once");
+    }
+
+    #[test]
+    fn a_tex_cache_empties_when_the_ui_moves_to_a_new_context() {
+        thread_local! {
+            static CACHE: TexCache<Vec<u32>> = TexCache::default();
+        }
+        CACHE.with(|c| c.borrow_mut().push(7));
+        assert_eq!(CACHE.with(|c| c.borrow().clone()), [7]);
+        forget_textures();
+        assert!(CACHE.with(|c| c.borrow().is_empty()), "emptied for the new context");
+        CACHE.with(|c| c.borrow_mut().push(8));
+        assert_eq!(CACHE.with(|c| c.borrow().clone()), [8], "and filled again");
+    }
+
+    #[test]
+    fn the_app_uploads_everything_again_in_a_new_context() {
+        let mut app = app();
+        let old = egui::Context::default();
+        // Fonts, then the canvas.
+        for _ in 0..3 {
+            frame(&mut app, &old);
+        }
+        let canvas = app.canvas.texture.as_ref().map(egui::TextureHandle::id).expect("the canvas is drawn");
+        assert_eq!(texture_name(&old, canvas).as_deref(), Some("canvas"));
+        let preview = |ctx: &egui::Context| {
+            let mut tex = None;
+            ctx.run_ui(Default::default(), |ui| {
+                tex = crate::widgets::doc_preview(ui, "loss", egui::vec2(8.0, 8.0), |w, h| Some(vectorcraft_doc::Document::new(w, h)))
+            })
+            .textures_delta
+            .clear();
+            tex.expect("a preview").id()
+        };
+        assert_eq!(texture_name(&old, preview(&old)).as_deref(), Some("preview-8x8@1:loss"));
+
+        // The host lost its graphics and started again: same app, new context.
+        let new = egui::Context::default();
+        for _ in 0..3 {
+            frame(&mut app, &new);
+        }
+        let canvas = app.canvas.texture.as_ref().map(egui::TextureHandle::id).expect("the canvas is drawn again");
+        assert_eq!(texture_name(&new, canvas).as_deref(), Some("canvas"), "uploaded to the new context");
+        assert_eq!(texture_name(&new, preview(&new)).as_deref(), Some("preview-8x8@1:loss"), "cached previews are made again");
+        assert_eq!(new.global_style().visuals.panel_fill, old.global_style().visuals.panel_fill, "the theme is applied again");
+        assert!(new.fonts(|f| f.definitions().font_data.contains_key("SourceSans3")), "and the fonts installed");
+    }
+
+    #[test]
+    fn losing_the_graphics_keeps_recovery_copies_at_once() {
+        let store = Arc::new(MemoryStore::default());
+        let mut app = VectorcraftApp::new(Session::new(), Services { recovery_store: Some(store.clone()), ..Default::default() });
+        assert!(app.graphics_lost("test"), "nothing modified: nothing to lose");
+        app.run("file.new", json!({"width": 200, "height": 100})).unwrap();
+        app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 20})).unwrap();
+        app.session.prefs.autosave_recovery = false;
+        assert!(app.graphics_lost("test"), "copied even with Data Recovery off");
+        assert_eq!(store.list().unwrap().iter().filter(|n| n.ends_with(".vectorcraft")).count(), 1);
+        // Without a store the work isn't safe.
+        assert!(!self::app().graphics_lost("test"));
+    }
+}

crates/ui-egui/src/lib.rs

@@ -24,6 +24,7 @@ pub mod dialogs;
 pub mod dock;
 pub mod find_font;
 pub mod font_menu;
+pub mod graphics;
 pub mod i18n;
 pub mod icon_data;
 pub mod icons;
@@ -105,6 +106,8 @@ mod tests_save;
 #[cfg(test)]
 mod tests_saveext;
 #[cfg(test)]
+mod tests_selectall;
+#[cfg(test)]
 mod tests_slices;
 #[cfg(test)]
 mod tests_svg;
@@ -280,6 +283,9 @@ pub struct VectorcraftApp {
     pub synthetic: Vec<egui::Event>,
     styled: bool,
     fonts_ready: bool,
+    /// The egui context the UI's textures were uploaded to (0: none yet; see
+    /// [`Self::adopt_context`]).
+    context: u64,
     /// Installed fonts added to the UI's for characters its own fonts lack (CJK names…).
     ui_fonts: ui_fonts::UiFonts,
     frame: u64,
@@ -369,6 +375,7 @@ impl VectorcraftApp {
             synthetic: vec![],
             styled: false,
             fonts_ready: false,
+            context: 0,
             ui_fonts: Default::default(),
             frame: 0,
             last_time: 0.0,
@@ -689,6 +696,7 @@ impl VectorcraftApp {
 
     fn logic_frame(&mut self, ctx: &egui::Context) {
         i18n::set_current(self.ui_language());
+        self.adopt_context(ctx);
         if !self.styled {
             theme::install_fonts(ctx);
             theme::apply(ctx, self.ui.brightness);

crates/ui-egui/src/menus.rs

@@ -2653,6 +2653,32 @@ fn menu_dialog(id: &str) -> Option<(&'static str, Value)> {
     })
 }
 
+/// The event a focused text field takes for Edit-menu command `id` (Select All, Cut, Copy,
+/// Paste), as the same keys would send it.
+fn field_event(app: &mut VectorcraftApp, id: &str) -> Option<egui::Event> {
+    Some(match id {
+        "select.all" => egui::Event::Key { key: egui::Key::A, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::COMMAND },
+        "edit.copy" => egui::Event::Copy,
+        "edit.cut" => egui::Event::Cut,
+        "edit.paste" | "edit.pasteWithoutFormatting" => egui::Event::Paste(app.system_clipboard_text()?),
+        _ => return None,
+    })
+}
+
+/// Invoke an item of the system menu bar (macOS), chosen by a click or by its key equivalent: the
+/// system takes those keys before the window sees them. While a text field has the keyboard,
+/// Select All, Cut, Copy and Paste act on the field's text, as their keys do in the window;
+/// everything else (and those commands with no field focused) goes to [`invoke`].
+pub fn invoke_from_system_menu(app: &mut VectorcraftApp, ctx: &egui::Context, id: &str, p: Value) {
+    if ctx.text_edit_focused()
+        && let Some(e) = field_event(app, id)
+    {
+        ctx.input_mut(|i| i.events.push(e));
+        return;
+    }
+    invoke(app, id, p);
+}
+
 /// Invoke a menu/command id with UI side effects (dialogs for "…" commands that need input).
 pub fn invoke(app: &mut VectorcraftApp, id: &str, p: Value) {
     if waits_for_ime(app, id) {

crates/ui-egui/src/panels/asset_export.rs

@@ -49,7 +49,7 @@ pub(crate) fn paint_thumb(ui: &Ui, st: &DocState, a: &ExportAsset, r: Rect) {
         static RENDERER: RefCell<vectorcraft_render::Renderer> = RefCell::new(vectorcraft_render::Renderer::new());
         /// The addresses of each asset's objects in one document revision (no tree walks per frame).
         static KEYS: RefCell<(Revision, HashMap<u64, Look>)> = RefCell::new(Default::default());
-        static CACHE: RefCell<HashMap<(Look, u32), egui::TextureHandle>> = RefCell::new(HashMap::new());
+        static CACHE: crate::graphics::TexCache<HashMap<(Look, u32), egui::TextureHandle>> = crate::graphics::TexCache::default();
     }
     ui.painter().rect_filled(r, 0.0, Color32::WHITE);
     if !ui.is_rect_visible(r) {

crates/ui-egui/src/panels/character.rs

@@ -123,8 +123,8 @@ fn text_paste(app: &mut VectorcraftApp, s: Option<String>) {
     }
 }
 
-/// Edit-menu commands while the Type tool edits text act on the text (Cut/Copy/Paste/Select
-/// All/Clear). `None` = not intercepted.
+/// Edit-menu commands while the Type tool edits text act on the text (Cut/Copy/Paste/Clear;
+/// Select All is the engine's `select.all`). `None` = not intercepted.
 pub(crate) fn intercept_text_command(app: &mut VectorcraftApp, id: &str) -> Option<Result<Value, String>> {
     if !app.session.tool_wants_text() {
         return None;
@@ -139,7 +139,6 @@ pub(crate) fn intercept_text_command(app: &mut VectorcraftApp, id: &str) -> Opti
             }
         }
         "edit.paste" | "edit.pasteWithoutFormatting" => text_paste(app, None),
-        "select.all" => app.session.set_tool_option("selectAll", &json!(true)),
         "edit.clear" => text_key(app, ToolKey::Delete, Mods::default()),
         _ => return None,
     }
@@ -152,10 +151,10 @@ enum TextInput {
     Copy,
     Cut,
     Paste(Option<String>),
-    SelectAll,
 }
 
-/// Route editing keys (with modifiers), clipboard events and Cmd+A/C/X/V to the Type tool.
+/// Route editing keys (with modifiers), clipboard events and Cmd+C/X/V to the Type tool (Cmd+A is
+/// left to the Select All shortcut, which selects the text being edited).
 pub(crate) fn route_type_input(app: &mut VectorcraftApp, ctx: &egui::Context) {
     CTX.get_or_init(|| ctx.clone());
     let mut todo = vec![];
@@ -193,10 +192,9 @@ pub(crate) fn route_type_input(app: &mut VectorcraftApp, ctx: &egui::Context) {
                     }
                     return false;
                 }
-                if m.command && !m.shift && !m.alt && matches!(key, Key::A | Key::C | Key::X | Key::V) {
+                if m.command && !m.shift && !m.alt && matches!(key, Key::C | Key::X | Key::V) {
                     if *pressed {
                         todo.push(match key {
-                            Key::A => TextInput::SelectAll,
                             Key::C => TextInput::Copy,
                             Key::X => TextInput::Cut,
                             _ => TextInput::Paste(None),
@@ -221,7 +219,6 @@ pub(crate) fn route_type_input(app: &mut VectorcraftApp, ctx: &egui::Context) {
                 }
             }
             TextInput::Paste(s) => text_paste(app, s),
-            TextInput::SelectAll => app.session.set_tool_option("selectAll", &json!(true)),
         }
     }
 }

crates/ui-egui/src/panels/flattener_preview.rs

@@ -116,6 +116,12 @@ struct Cache {
     view: View,
     generation: u64,
     renderer: Option<vectorcraft_render::Renderer>,
+    drawn: crate::graphics::TexCache<Drawn>,
+}
+
+/// The preview as drawn: for what, and its texture.
+#[derive(Default)]
+struct Drawn {
     key: Option<Key>,
     tex: Option<egui::TextureHandle>,
 }
@@ -268,8 +274,10 @@ fn preview_area(ui: &mut Ui, t: &Tokens, h: Highlight, overprints: Overprints) {
     let ppp = ui.ctx().pixels_per_point();
     CACHE.with(|c| {
         let mut c = c.borrow_mut();
-        let Cache { shot, view, renderer, key, tex, .. } = &mut *c;
+        let Cache { shot, view, renderer, drawn, .. } = &mut *c;
         let Some(shot) = shot.as_ref() else { return };
+        let mut drawn = drawn.borrow_mut();
+        let Drawn { key, tex } = &mut *drawn;
         let visible = view.visible(shot.fit);
         if resp.double_clicked() {
             *view = View::default();
@@ -420,7 +428,7 @@ mod tests {
         let mut app = app();
         frame(&mut app);
         assert!(CACHE.with(|c| c.borrow().shot.is_some()), "a first look refreshes");
-        assert!(CACHE.with(|c| c.borrow().tex.is_some()), "the preview is drawn");
+        assert!(CACHE.with(|c| c.borrow().drawn.borrow().tex.is_some()), "the preview is drawn");
         let v = command(&mut app, &json!({"highlight": "allAffected"})).unwrap();
         assert_eq!(v["counts"]["allAffected"], 2);
         assert_eq!(app.ui.open_panel.as_deref(), Some(ID));

crates/ui-egui/src/panels/glyphs.rs

@@ -2,7 +2,6 @@
 //! outlines. Double-click inserts the character at the Type tool's caret (or appends it to the
 //! selected text objects).
 
-use std::cell::RefCell;
 use std::collections::HashMap;
 
 use egui::{Color32, Sense, Ui, vec2};
@@ -29,7 +28,7 @@ const SUBSETS: [(&str, u32, u32); 7] = [
 ];
 
 thread_local! {
-    static TEX: RefCell<HashMap<(u32, u32, u32), egui::TextureHandle>> = RefCell::new(HashMap::new());
+    static TEX: crate::graphics::TexCache<HashMap<(u32, u32, u32), egui::TextureHandle>> = crate::graphics::TexCache::default();
 }
 
 /// Antialiased coverage mask (nonzero winding) of `path` in a `w`×`h` pixel grid.

crates/ui-egui/src/panels/graphic_styles.rs

@@ -68,7 +68,7 @@ const UV: Rect = Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0));
 thread_local! {
     static RENDERER: RefCell<vectorcraft_render::Renderer> = RefCell::new(vectorcraft_render::Renderer::new());
     /// Thumbnails by (look hash, pixels, preview shape, Override Character Color on type).
-    static THUMBS: RefCell<HashMap<(u64, u32, Preview, bool), TextureHandle>> = RefCell::new(HashMap::new());
+    static THUMBS: crate::graphics::TexCache<HashMap<(u64, u32, Preview, bool), TextureHandle>> = crate::graphics::TexCache::default();
 }
 
 // ---------- thumbnails ----------

crates/ui-egui/src/panels/layers.rs

@@ -714,7 +714,7 @@ pub(crate) fn real_thumb(ui: &Ui, doc: &vectorcraft_doc::Document, n: &Node, r:
     use std::collections::HashMap;
     thread_local! {
         static RENDERER: RefCell<vectorcraft_render::Renderer> = RefCell::new(vectorcraft_render::Renderer::new());
-        static CACHE: RefCell<HashMap<(usize, u64), egui::TextureHandle>> = RefCell::new(HashMap::new());
+        static CACHE: crate::graphics::TexCache<HashMap<(usize, u64), egui::TextureHandle>> = crate::graphics::TexCache::default();
     }
     if !ui.is_rect_visible(r) {
         return true;

crates/ui-egui/src/panels/navigator.rs

@@ -2,8 +2,6 @@
 //! document revision) with the red view box you drag to pan, zoom out/in buttons, a zoom slider
 //! and a zoom field.
 
-use std::cell::RefCell;
-
 use egui::{Color32, Rect, Sense, Stroke, StrokeKind, Ui, pos2, vec2};
 use serde_json::json;
 use vectorcraft_geom::{Point, Rect as DRect};
@@ -13,6 +11,7 @@ use crate::VectorcraftApp;
 use crate::theme::Tokens;
 use crate::widgets::{self, menu_item};
 
+#[derive(Default)]
 struct Cache {
     renderer: Option<vectorcraft_render::Renderer>,
     key: Option<(usize, u64, u32, u32, bool)>,
@@ -20,7 +19,7 @@ struct Cache {
 }
 
 thread_local! {
-    static CACHE: RefCell<Cache> = const { RefCell::new(Cache { renderer: None, key: None, tex: None }) };
+    static CACHE: crate::graphics::TexCache<Cache> = crate::graphics::TexCache::default();
 }
 
 /// Map a document point into the thumbnail rect (region → rect, aspect preserved).

crates/ui-egui/src/panels/swatches.rs

@@ -169,11 +169,10 @@ fn apply(app: &mut VectorcraftApp, ui: &Ui, e: &Entry) {
 
 /// A pattern swatch drawn as a rendered tile (cached by the definition's identity and size).
 fn pattern_thumb(app: &VectorcraftApp, ui: &Ui, r: Rect, paint: &Paint) {
-    use std::cell::RefCell;
     use std::collections::HashMap;
     type Key = (String, Vec<usize>, String, u32);
     thread_local! {
-        static CACHE: RefCell<HashMap<Key, Option<egui::TextureHandle>>> = RefCell::new(HashMap::new());
+        static CACHE: crate::graphics::TexCache<HashMap<Key, Option<egui::TextureHandle>>> = crate::graphics::TexCache::default();
     }
     let Paint::Pattern { pattern, .. } = paint else { return };
     let Some(st) = app.session.active() else { return };

crates/ui-egui/src/panels/symbols.rs

@@ -17,7 +17,7 @@ use crate::widgets::{self, PanelDrag, menu_item};
 fn thumb(ui: &Ui, doc: &Document, name: &str, size: f32) -> Option<egui::TextureHandle> {
     thread_local! {
         static RENDERER: RefCell<vectorcraft_render::Renderer> = RefCell::new(vectorcraft_render::Renderer::new());
-        static CACHE: RefCell<HashMap<(usize, String, u32), egui::TextureHandle>> = RefCell::new(HashMap::new());
+        static CACHE: crate::graphics::TexCache<HashMap<(usize, String, u32), egui::TextureHandle>> = crate::graphics::TexCache::default();
     }
     let sym = doc.symbols.iter().find(|s| s.name == name)?;
     let px = (size * ui.ctx().pixels_per_point()).round().max(8.0) as u32;

crates/ui-egui/src/place.rs

@@ -51,16 +51,26 @@ pub enum DropTarget {
 pub struct PlaceState {
     /// Web: the bytes of the files picked for the Place dialog, by name.
     picked: Vec<(String, Vec<u8>)>,
-    /// The loaded cursor's thumbnails by file name: decoded when the cursor is loaded, uploaded
-    /// when first drawn.
+    /// The loaded cursor's thumbnails by file name.
     thumbs: Vec<(String, Thumb)>,
     /// The Control bar's `image.info`, for (document uid, revision, image id).
     info: Option<((u64, u64, u64), Value)>,
 }
 
-enum Thumb {
-    Decoded(egui::ColorImage),
-    Uploaded(egui::TextureHandle),
+/// A place cursor thumbnail: decoded when the cursor is loaded, uploaded when first drawn (and
+/// again in a new graphics context).
+struct Thumb {
+    image: std::sync::Arc<egui::ColorImage>,
+    tex: Option<egui::TextureHandle>,
+}
+
+impl PlaceState {
+    /// The UI moved to a new egui context: the thumbnails are uploaded again when drawn.
+    pub(crate) fn forget_textures(&mut self) {
+        for (_, th) in &mut self.thumbs {
+            th.tex = None;
+        }
+    }
 }
 
 /// Run engine command `id` itself (past the UI's handling of the same id); an error shows in the
@@ -230,7 +240,7 @@ pub fn queue(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
             let png = vectorcraft_format::base64_decode(f["thumbnailBase64"].as_str()?)?;
             let img = image::load_from_memory_with_format(&png, image::ImageFormat::Png).ok()?.to_rgba8();
             let color = egui::ColorImage::from_rgba_unmultiplied([img.width() as usize, img.height() as usize], img.as_raw());
-            Some((f["name"].as_str()?.to_string(), Thumb::Decoded(color)))
+            Some((f["name"].as_str()?.to_string(), Thumb { image: std::sync::Arc::new(color), tex: None }))
         })
         .collect();
     Ok(r)
@@ -243,15 +253,10 @@ pub fn paint_cursor(app: &mut VectorcraftApp, ctx: &egui::Context, painter: &egu
     let name = opts["name"].as_str().unwrap_or_default();
     let t = Tokens::get(ctx);
     let tex = app.place.thumbs.iter_mut().find(|(n, _)| n == name).map(|(n, th)| {
-        if let Thumb::Decoded(img) = th {
-            *th = Thumb::Uploaded(ctx.load_texture(format!("place-thumb-{n}"), std::mem::take(img), egui::TextureOptions::LINEAR));
-        }
-        match th {
-            Thumb::Uploaded(tex) => Some((tex.id(), tex.size_vec2())),
-            Thumb::Decoded(_) => None,
-        }
+        let tex = th.tex.get_or_insert_with(|| ctx.load_texture(format!("place-thumb-{n}"), th.image.clone(), egui::TextureOptions::LINEAR));
+        (tex.id(), tex.size_vec2())
     });
-    let (id, size) = tex.flatten().unzip();
+    let (id, size) = tex.unzip();
     let size = size.unwrap_or(egui::vec2(THUMB as f32, THUMB as f32 * 0.75));
     let k = THUMB as f32 / size.x.max(size.y).max(1.0);
     let r = egui::Rect::from_min_size(pos + THUMB_OFFSET, size * k);

crates/ui-egui/src/shortcuts.rs

@@ -261,7 +261,7 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
             });
             return;
         }
-        // Editing keys with modifiers, clipboard and Cmd+A.
+        // Editing keys with modifiers and the clipboard (Cmd+A is Select All's, below: the text).
         crate::panels::character::route_type_input(app, ctx);
         // Enter was already delivered above as ToolKey::Enter (newline).
         let fire = all_shortcuts().into_iter().filter(|(sc, ..)| sc.modifiers.command).find(|(sc, ..)| ctx.input_mut(|i| consume(i, sc, false)));

crates/ui-egui/src/sysclip.rs

@@ -89,6 +89,14 @@ impl VectorcraftApp {
         })
     }
 
+    /// The text on the system clipboard, if any.
+    pub(crate) fn system_clipboard_text(&mut self) -> Option<String> {
+        match self.services.system_clipboard.as_mut() {
+            Some(cb) => cb.read(&[TEXT]).map(|f| String::from_utf8_lossy(&f.data).into_owned()),
+            None => self.services.clipboard_read.as_mut().and_then(|read| read()),
+        }
+    }
+
     /// Does the system clipboard hold something Paste can take (with nothing copied in the app)?
     pub(crate) fn system_clipboard_pasteable(&mut self) -> bool {
         match self.services.system_clipboard.as_mut() {

crates/ui-egui/src/tests_selectall.rs

@@ -0,0 +1,173 @@
+//! Select All (Cmd+A) follows the keyboard, from the window and from the system menu bar (macOS):
+//! a focused text field selects its own text, the Type tool editing selects the text being edited,
+//! and only otherwise are all the objects selected.
+
+use egui::{Event, Key, Modifiers, PointerButton, Pos2, Rect, vec2};
+use serde_json::json;
+use vectorcraft_engine::Session;
+use vectorcraft_tools::{PointerEvent, PointerKind};
+
+use crate::{VectorcraftApp, menus};
+
+struct App {
+    app: VectorcraftApp,
+    ctx: egui::Context,
+    time: f64,
+}
+
+impl App {
+    /// A document with a 37 pt wide rectangle (selected) and a second, unselected one.
+    fn new() -> Self {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
+        app.run("shape.rectangle", json!({"x": 200, "y": 150, "width": 20, "height": 20})).unwrap();
+        app.run("shape.rectangle", json!({"x": 20, "y": 20, "width": 37, "height": 40})).unwrap();
+        let mut a = Self { app, ctx: egui::Context::default(), time: 0.0 };
+        for _ in 0..3 {
+            a.frame(vec![]);
+        }
+        a
+    }
+
+    /// One whole app frame with `events`; `menu`: a system menu item chosen first, as the macOS
+    /// host dispatches it before the app's logic.
+    fn frame_with(&mut self, events: Vec<Event>, menu: Option<&str>) -> egui::FullOutput {
+        self.time += 0.1;
+        let raw = egui::RawInput {
+            events,
+            time: Some(self.time),
+            screen_rect: Some(Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 850.0))),
+            ..Default::default()
+        };
+        let app = &mut self.app;
+        let mut out = self.ctx.run_ui(raw, |ui| {
+            if let Some(id) = menu {
+                menus::invoke_from_system_menu(app, ui.ctx(), id, json!({}));
+            }
+            app.logic(ui.ctx());
+            app.ui(ui);
+        });
+        out.textures_delta.clear();
+        out
+    }
+
+    fn frame(&mut self, events: Vec<Event>) -> egui::FullOutput {
+        self.frame_with(events, None)
+    }
+
+    fn menu(&mut self, id: &str) -> egui::FullOutput {
+        self.frame_with(vec![], Some(id))
+    }
+
+    fn selected(&self) -> usize {
+        self.app.session.active().unwrap().selection.objects.len()
+    }
+
+    /// The panel number field showing `text` (the field keeps its text under its id): id, rect.
+    fn field(&self, text: &str) -> (egui::Id, Rect) {
+        let widgets: Vec<(egui::Id, Rect)> =
+            self.ctx.viewport(|vp| vp.prev_pass.widgets.layers().flat_map(|(_, w)| w.iter()).map(|w| (w.id, w.rect)).collect());
+        widgets
+            .into_iter()
+            .find(|&(id, _)| {
+                self.ctx.data(|d| d.get_temp::<String>(id)).is_some_and(|t| t == text) && egui::TextEdit::load_state(&self.ctx, id).is_some()
+            })
+            .unwrap_or_else(|| panic!("no field shows {text:?}"))
+    }
+
+    /// The selected character range of text field `id`.
+    fn field_selection(&self, id: egui::Id) -> Option<(usize, usize)> {
+        let r = egui::TextEdit::load_state(&self.ctx, id)?.cursor.char_range()?;
+        let (a, b) = (r.primary.index, r.secondary.index);
+        Some((a.min(b).into(), a.max(b).into()))
+    }
+}
+
+fn press(key: Key, modifiers: Modifiers) -> Event {
+    Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers }
+}
+
+fn click(at: Pos2, pressed: bool) -> Event {
+    Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Modifiers::NONE }
+}
+
+#[test]
+fn cmd_a_in_a_panel_field_selects_its_text_and_leaves_the_art() {
+    let mut a = App::new();
+    assert_eq!(a.selected(), 1);
+    let (id, rect) = a.field("37 pt");
+    a.frame(vec![Event::PointerMoved(rect.center()), click(rect.center(), true)]);
+    a.frame(vec![click(rect.center(), false)]);
+    a.frame(vec![]);
+    assert!(a.ctx.text_edit_focused(), "the W field has the keyboard");
+    let all = Some((0, "37 pt".chars().count()));
+    // The window's Cmd+A (Windows, Linux, the web, macOS without the system menu).
+    a.frame(vec![press(Key::End, Modifiers::NONE)]);
+    assert_eq!(a.field_selection(id), Some((5, 5)), "End collapses the selection");
+    a.frame(vec![press(Key::A, Modifiers::COMMAND)]);
+    assert_eq!(a.field_selection(id), all, "Cmd+A selects the field's text");
+    assert_eq!(a.selected(), 1, "and not the art");
+    // Select All from the macOS menu bar (its key equivalent or a click): the same.
+    a.frame(vec![press(Key::End, Modifiers::NONE)]);
+    a.menu("select.all");
+    a.frame(vec![]);
+    assert_eq!(a.field_selection(id), all, "the menu's Select All selects the field's text");
+    assert_eq!(a.selected(), 1, "and not the art");
+    // The menu's Copy copies the field's text, not the art.
+    let out = a.menu("edit.copy");
+    let copied: Vec<_> = out
+        .platform_output
+        .commands
+        .iter()
+        .filter_map(|c| match c {
+            egui::OutputCommand::CopyText(t) => Some(t.as_str()),
+            _ => None,
+        })
+        .collect();
+    assert_eq!(copied, ["37 pt"]);
+    assert!(a.app.session.clipboard.is_empty(), "no art copied");
+    assert!(a.ctx.text_edit_focused(), "the field keeps the keyboard");
+}
+
+#[test]
+fn cmd_a_while_editing_type_selects_all_of_its_text() {
+    let mut a = App::new();
+    a.app.select_tool("type");
+    let view = a.app.view_info();
+    for kind in [PointerKind::Down, PointerKind::Up] {
+        a.app.session.pointer(&PointerEvent::new(kind, 100.0, 200.0), view).unwrap();
+    }
+    a.frame(vec![Event::Text("abc".into())]);
+    let text = a.app.session.active().unwrap().selection.objects.clone();
+    let range = |a: &App| {
+        let o = a.app.session.tool_options();
+        (o["start"].as_u64().unwrap(), o["end"].as_u64().unwrap().min(3))
+    };
+    assert_eq!(range(&a), (3, 3), "the caret after the text");
+    // The window's Cmd+A.
+    a.frame(vec![press(Key::A, Modifiers::COMMAND)]);
+    assert_eq!(range(&a), (0, 3), "Cmd+A selects the text being edited");
+    assert_eq!(a.app.session.active().unwrap().selection.objects, text, "and not the art");
+    a.frame(vec![press(Key::End, Modifiers::NONE)]);
+    assert_eq!(range(&a), (3, 3));
+    // The macOS menu bar's Select All.
+    a.menu("select.all");
+    assert_eq!(range(&a), (0, 3), "the menu's Select All selects the text being edited");
+    assert_eq!(a.app.session.active().unwrap().selection.objects, text);
+    // Typing replaces it.
+    a.frame(vec![Event::Text("Z".into())]);
+    let doc = a.app.session.execute("document.inspect", &json!({})).unwrap();
+    let names: Vec<_> = doc["layers"][0]["children"].as_array().unwrap().iter().map(|c| c["name"].clone()).collect();
+    assert!(names.contains(&json!("Z")), "{names:?}");
+}
+
+#[test]
+fn cmd_a_on_the_canvas_selects_all_objects() {
+    let mut a = App::new();
+    assert!(!a.ctx.egui_wants_keyboard_input());
+    a.frame(vec![press(Key::A, Modifiers::COMMAND)]);
+    assert_eq!(a.selected(), 2, "Cmd+A selects every object");
+    a.app.run("select.none", json!({})).unwrap();
+    a.menu("select.all");
+    assert_eq!(a.selected(), 2, "so does the menu's Select All");
+}

crates/ui-egui/src/tests_sysclip.rs

@@ -95,9 +95,13 @@ pub(super) fn blue_png() -> Vec<u8> {
     png
 }
 
-/// One headless frame of app logic (shortcuts too, from the second frame on) delivering `events`.
+/// One headless frame of app logic (shortcuts too, from the second frame on) delivering `events`,
+/// in the test's one context (in a new one the app starts its fonts over).
 fn frame(app: &mut VectorcraftApp, events: Vec<egui::Event>) {
-    let ctx = egui::Context::default();
+    thread_local! {
+        static CTX: egui::Context = egui::Context::default();
+    }
+    let ctx = CTX.with(Clone::clone);
     ctx.run_ui(egui::RawInput { events, ..Default::default() }, |ui| app.logic(ui.ctx())).textures_delta.clear();
 }
 

crates/ui-egui/src/widgets.rs

@@ -1269,7 +1269,7 @@ pub fn doc_preview(ui: &Ui, key: &str, size: Vec2, build: impl FnOnce(f64, f64)
     use std::collections::HashMap;
     thread_local! {
         static RENDERER: RefCell<vectorcraft_render::Renderer> = RefCell::new(vectorcraft_render::Renderer::new());
-        static CACHE: RefCell<HashMap<String, egui::TextureHandle>> = RefCell::new(HashMap::new());
+        static CACHE: crate::graphics::TexCache<HashMap<String, egui::TextureHandle>> = crate::graphics::TexCache::default();
     }
     let ppp = ui.ctx().pixels_per_point() as f64;
     let (w, h) = (size.x as f64, size.y as f64);

docs/development.md

@@ -22,6 +22,15 @@ How the web shell (`apps/vectorcraft-web/src/web.rs`) differs from desktop:
 - **Save / Save As / Export** go through `Services::download`: a Blob, an object URL and a temporary `<a download>`, all created from Rust. There is no save dialog, so the suggested name becomes the download name.
 - **Drag-and-drop:** `WebShell` takes the frame's `dropped_files` before the app sees them, reads each with `DroppedFile::bytes_async` and pushes the bytes into the inbox (files dropped on a canvas go to `Services::place_inbox` with their `place::DropAt`: the document they were dropped on, by uid, and the point). A file that arrives after another document became active still lands in its own document, which becomes active again; if that document closed meanwhile, the file is not placed and the status bar says so. (The app's synchronous drop path is compiled out on wasm32.)
 - **Data Recovery** keeps its copies in `localStorage` (`vectorcraft-recovery/<area>/<name>`, shared by the site's tabs), so tabs can't lock their areas the way desktop apps lock a folder (`RecoveryStore::lock`). Each tab holds its area with a heartbeat it refreshes every minute and, where the browser has Web Locks (secure pages: `https://` or localhost), with a Web Lock named after the area (`apps/vectorcraft-web/src/locks.rs`, through `js_sys::Reflect` since web-sys has them only as an unstable API). The browser releases the lock only when the tab is gone, not while its timers are paused in the background, which a heartbeat can't tell apart (#367). `navigator.locks.query()` is asynchronous, so the shell keeps a snapshot refreshed every 10 seconds (taken once before the first frame); a snapshot older than a minute counts every area as held. An area is offered as a crash's leftovers only when no tab holds its lock and its heartbeat is older than three intervals. Without Web Locks a paused tab can still be taken for gone; it repairs that when it resumes: its next heartbeat (or recovery save) writes again the copies missing from its area, and a heartbeat newer than the one the other tab wrote taking the area over makes the area running again for that tab.
+- **Losing the graphics (#369):** the browser can drop the page's WebGPU device or WebGL context (a GPU reset, a driver update, too many tabs on the GPU; or a script calling `device.destroy()` / `WEBGL_lose_context.loseContext()`). The app goes on without it, so the shell watches for it: wgpu's device-lost callback for WebGPU, the canvas's `webglcontextlost` event for WebGL2. Both report to a `graphics::GraphicsLoss`, and the next frame of `WebShell::logic` handles it:
+  1. `VectorcraftApp::graphics_lost` writes Data Recovery copies of the modified documents at once (to browser storage, also when Data Recovery is turned off).
+  2. The shell puts a fresh `<canvas>` in place of the dead one (a canvas whose WebGL context is lost can't get another) and starts the same `WebRunner` again on it, with new graphics and a new egui context, handing over the same `VectorcraftApp`: documents, undo history, selection and panels stay as they were. Its `Services` are made again for the new context, and the status bar says the graphics were restarted.
+  3. Textures belong to the egui context they were uploaded to. The app notices the new context (`VectorcraftApp::adopt_context`) and uploads everything again: fonts and theme, the canvas, the place cursor's thumbnails, and every per-thread texture cache (thumbnails, previews, font samples), which are `graphics::TexCache`s for that reason. A new texture cache must be a `TexCache` (or live in the context's `ctx.data`), or it shows stale or wrong pictures after a restart.
+  4. If no new graphics can be had (no adapter, WebGL blocked after repeated losses) or the graphics were lost more than three times, the shell gives up: the dead canvas is removed, the app lets go of its recovery area but not its copies (`recovery::leave`: its heartbeat and Web Lock go, so the reloaded page offers the copies at once). The Web Locks are started once, before the first frame, and kept across graphics restarts, so a restarted tab stays the owner of its area and the page says to reload.
+
+  To try it, in the browser console: for WebGL2 (`?webgl`), `document.querySelector('canvas').getContext('webgl2').getExtension('WEBGL_lose_context').loseContext()`. For WebGPU, keep the device the page creates (wrap `GPUAdapter.prototype.requestDevice` before the page loads) and call its `destroy()`.
+
+  The desktop app can't make a new device for its window (eframe can't), so on a lost device (a driver reset) it logs the reason, writes the recovery copies, and says in the status bar to save and restart. Once the copies are written, closing the window skips the Save Changes question, which it can't show: the next launch offers the changes back.
 - **No control server:** browsers can't listen on TCP. To automate the web build, drive headless Chrome with `--remote-debugging-port`.
 - Quick smoke test: `"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --headless=new --enable-unsafe-webgpu --screenshot=web.png --window-size=1440,900 --virtual-time-budget=15000 http://127.0.0.1:8766/` (headless Chrome on macOS gets a real WebGPU adapter).
 

docs/mcp.md

@@ -1890,6 +1890,18 @@ square to the page. `object.resetBoundingBox` squares the box again without movi
 {"name":"run_command","arguments":{"command":"object.rotate","params":{"angle":45,"absolute":true}}}
 ```
 
+## Select All while editing type
+
+While the Type tool edits text (a click into type, `pointer_gesture` with `"tool":"type"`), `select.all` (Cmd+A,
+`press_key {key: "A", mods: {cmd: true}}`) selects all of that text instead of the art, as in the reference app, and
+returns `{editing, start, end}` (the text's id and the selected byte range, which `text.getRange` and
+`text.setRangeStyle` take); the art selection stays as it is. Without text being edited it selects every object and
+returns `{count}`. Text in threaded frames is selected one frame at a time.
+
+```json
+{"name":"press_key","arguments":{"key":"A","mods":{"cmd":true}}}
+```
+
 ## Empty point type
 
 Point type the Type tool places with a click and leaves empty is discarded when editing ends: Escape, another tool,