@grida/svg-editor 1.0.0-alpha.15 → 1.0.0-alpha.16

package/README.md

@@ -304,6 +304,25 @@ editor.subscribe_with_selector<T>(
 
 `state` is a frozen snapshot. Consumers never destructure into internals; if a view they need isn't here or in the purpose-built views below, that's an API gap.
 
+### Observation — pick (tap)
+
+A **pick** is a discrete tap on the canvas — a press and release within the drag threshold, no drag. It is observe-only and deliberately **separate from selection**: selection answers "what do commands target," a pick answers "what did the user just click, and where." A primary tap on a node both selects it _and_ emits a pick; a tap on empty canvas emits a pick with `node_id: null` (distinguishable from "nothing is selected," which selection alone cannot express); a secondary (right-button) tap emits a pick and does **not** change selection. This is the seam a click-driven host tool needs — a comment / annotation tool anchors UI at `point` and scopes its action to `node_id`, or to the whole document when `null`.
+
+```ts
+type PickEvent = {
+  point: Vec2; // document-space — the pointer-DOWN point the tap resolved against
+  node_id: NodeId | null; // topmost node under point; null = empty canvas
+  button: "primary" | "secondary"; // middle is pan, never taps
+  mods: { shift: boolean; alt: boolean; meta: boolean; ctrl: boolean };
+};
+
+editor.subscribe_pick(fn: (e: PickEvent) => void): Unsubscribe;
+```
+
+The point is document-space and always the pointer-**down** point — so it stays correct even for a tap on an already-selected node (whose selection commits on pointer-up). The channel does **not** bump `state.version`. In React, wire it with `useEditorPick(handler)`.
+
+> **Status:** `@unstable` — shipped against one consumer; the shape is open until a second click-driven tool exercises it (P6).
+
 ### Observation — properties
 
 This section is about **property semantics on a single node**, following the CSS / SVG spec. Multi-selection ("mixed values") is a separate concern; see the [Multi-selection](#multi-selection-mixed-values) section below. The two are kept apart on purpose: property semantics is defined by the spec; mixed semantics is an aggregation layer the editor adds because it supports multi-select.
@@ -608,6 +627,8 @@ editor.commands.{
   resize_to(target: { width: number; height: number; anchor?: ResizeAnchor }): void;
   rotate(args: { angle: number; pivot?: { x: number; y: number } }): void;
   rotate_to(args: { angle: number; pivot?: { x: number; y: number } }): void;
+  // `matrix` is SVG `matrix(a b c d e f)` order (the `Matrix2D` tuple).
+  transform(matrix: Matrix2D, opts?: { ids?: NodeId[]; pivot?: { x: number; y: number } }): boolean;
   flatten_transform(): void;          // bake `transform=` into native attrs where possible
 
   // alignment (operates on selection of ≥2 nodes against their union bbox)
@@ -616,12 +637,24 @@ editor.commands.{
   // structure
   reorder(direction: "bring_forward" | "send_backward" | "bring_to_front" | "send_to_back"): void;
   group(): void;                      // wrap selection in a new <g>
+  ungroup(opts?: { id?: NodeId }): boolean; // dissolve a plain structural <g>
+                                      // (clean-structural subset only; refuses
+                                      // groups with visual state — see TODO §10)
   remove(): void;
 
   // insertion — `tag` is an open string (so paste / RPC can create any element,
   // e.g. "path"); only the closed `InsertableTag` set gets a pointer-driven
   // draw gesture and default paint.
   insert(tag: string, attrs?: Readonly<Record<string, string>>): NodeId;
+  // markup-shaped sibling of `insert` — one or more sibling elements, or a
+  // full `<svg>` doc (the shell is discarded; its children are the content).
+  // Subtrees adopted verbatim; ONE history step; returns root ids in
+  // document order. Authored ids are NEVER rewritten (dedup is Tidy's job);
+  // undeclared `xlink:` / shell-declared prefixes are hoisted onto the root
+  // in the same step. Position is authored content: wrap the fragment in
+  // `<g transform="translate(x y)">` to land it at a point — same single
+  // undo step, no placement opt.
+  insert_fragment(svg: string, opts?: { parent?: NodeId; index?: number; select?: boolean }): NodeId[];
   insert_preview(tag: string, initial?: Readonly<Record<string, string>>): InsertPreviewSession;
 
   // content
@@ -643,6 +676,8 @@ editor.commands.{
 
 All commands operate on `state.selection` unless they take an explicit target. Commands that can't apply (e.g. `set_text` with no text node selected) are no-ops, not errors.
 
+`transform` composes a general 2×3 affine onto the selection **relative** and **in world space about a pivot** (default: the selection union-bbox center) — `E = T(pivot) · matrix · T(-pivot)` — so a bare `[-1, 0, 0, 1, 0, 0]` is an in-place horizontal flip and `[1, 0, 0, -1, 0, 0]` a vertical one. The editor owns the round-trip: `E` is folded onto each member's transform list as a **single leading `matrix` op** (existing `rotate`/`translate` tokens are preserved after it; repeated applies collapse into one matrix; a net-identity leading matrix is dropped). It refuses (returns `false`, no history) on empty selection, no attached surface, or any member that isn't rotatable (matrix / scale / skew / `<text rotate>` / CSS-property / animated transforms — same gate as `rotate`; Flatten Transform is the recovery path). Flat-doc only: nested transformed ancestors are out of scope.
+
 (Naming convention for the API surface is `snake_case` to match the SVG / CSS property naming the editor already echoes — `set_property("stroke-width", …)` reads cleanly next to `set_paint("fill", …)`. JavaScript identifiers use `snake_case`; user-facing strings that mirror SVG attribute names stay `kebab-case` exactly as the spec writes them.)
 
 ### Providers
@@ -880,6 +915,7 @@ What this editor will never be. Each one is a defensive perimeter for the princi
 - **Not customizable in HUD layout.** Style spec only — no overlay slots, no handle replacement, no custom chrome components.
 - **Not a private IR.** SVG is the source of truth. The editor does not maintain an alternative on-disk format, and the bytes are not projected from any in-memory canonical store. (The internal typed element IR described under [Paradigm § Element IR (internal)](#element-ir-internal) is a typed view over the parsed AST, not a store the file is derived from — the AST and the file are the source of truth, and the IR is rebuilt from them on each load.)
 - **Not a serializer playground.** Round-trip rules are fixed (P1). No "compact mode," no "Prettier mode," no consumer-supplied formatter.
+- **Not an input-interception hook.** The pick/tap observation (`subscribe_pick`) reports a click that already happened; it cannot prevent, delay, or replace the editor's own selection and gesture handling. A host that needs to intercept input owns the container and splices its own layer in (the DOM escape hatch) — it does not get a veto through the observation surface.
 
 If a consumer needs any of the above, the right answer is "this is the wrong tool." Saying yes to any one is the path that turned the Grida main editor into a 6,800-line god-class.
 

package/dist/{dom-CK6GlgFF.d.mts → dom-98AUOfsP.d.mts}

@@ -1,4 +1,4 @@
-import { c as SvgEditor, p as Gestures, s as SurfaceHandle, w as Camera } from "./editor-Dl7c0q5A.mjs";
+import { c as SvgEditor, p as Gestures, s as SurfaceHandle, w as Camera } from "./editor-D2eQe8lB.mjs";
 import cmath from "@grida/cmath";
 import { guide } from "@grida/cmath/_snap";
 
@@ -13,6 +13,35 @@ type SnapOptions = {
 declare const DEFAULT_SNAP_OPTIONS: SnapOptions;
 //#endregion
 //#region src/dom.d.ts
+/**
+ * Wire a web-font settle source to the editor's geometry channel.
+ *
+ * The DOM surface re-serializes the `<svg>` on every editor tick, but a
+ * `<text>` / `<tspan>` bbox can change with NO attribute write: a web font
+ * finishing load AFTER its `font-family` / `font-size` was already written.
+ * The IR never sees that reflow, so nothing bumps `geometry_version` and
+ * every bounds-keyed consumer (snap, HUD chrome, size meter) stays stuck at
+ * the fallback-face metrics until the next real edit.
+ *
+ * Listens for `loadingdone` on `source` (a `FontFaceSet`, or any injected
+ * `EventTarget` in tests) and calls `bump` once per settle. COARSE on
+ * purpose: one bump clears the WHOLE bounds cache, not just text nodes —
+ * consistent with the package's pessimistic-invalidation stance, and far
+ * cheaper than scoping the bump to the (possibly many) reflowed runs.
+ *
+ * Also bumps once when `source.ready` resolves (when present): fonts that
+ * settled before attach — a cache hit, or `font-display` resolving the same
+ * tick the surface mounts — never re-fire `loadingdone`, so a document
+ * mounted post-settle still needs one bump to re-read at the real metrics.
+ *
+ * Returns a teardown that removes the listener and neutralizes the pending
+ * `ready` bump (leak guard) — call it on surface detach.
+ *
+ * Factored out of the surface so it can be unit-tested with a fake
+ * `EventTarget` in the node-only test env (jsdom's `FontFaceSet` is
+ * incomplete); never a real font / network.
+ */
+declare function install_font_load_geometry_bump(source: EventTarget | null, bump: () => void): () => void;
 type DomSurfaceOptions = {
   /** Mount the SVG inside this container. */container: HTMLElement;
   /**
@@ -33,6 +62,19 @@ type DomSurfaceOptions = {
    * when `fit: true`.
    */
   initial_camera?: cmath.Transform;
+  /**
+   * Font-load settle source — the `EventTarget` whose `loadingdone` event
+   * signals "web fonts finished loading, text may have reflowed." Defaults
+   * to `container.ownerDocument.fonts` (the live `FontFaceSet`). The
+   * surface installs a `loadingdone` listener that advances the editor's
+   * geometry channel so text bounds re-read at the settled glyph metrics
+   * (see ../docs/geometry.md §Limitations "Text bbox depends on font").
+   *
+   * Injectable as a DOM seam: jsdom's `FontFaceSet` is incomplete, so
+   * tests pass a plain `EventTarget` stub and `dispatchEvent(new Event(
+   * "loadingdone"))` to simulate a settle without a real font / network.
+   */
+  font_load_source?: EventTarget;
 };
 /**
  * Surface handle for the DOM surface. Extends the editor's core
@@ -111,4 +153,4 @@ declare function inverse_project_rect(rect: {
   f: number;
 }, offset: readonly [number, number]): cmath.Rectangle | null;
 //#endregion
-export { project_delta_inverse_ctm as a, SnapOptions as c, inverse_project_rect as i, DomSurfaceOptions as n, project_point_through_ctm as o, attach_dom_surface as r, DEFAULT_SNAP_OPTIONS as s, DomSurfaceHandle as t };
+export { inverse_project_rect as a, DEFAULT_SNAP_OPTIONS as c, install_font_load_geometry_bump as i, SnapOptions as l, DomSurfaceOptions as n, project_delta_inverse_ctm as o, attach_dom_surface as r, project_point_through_ctm as s, DomSurfaceHandle as t };

package/dist/{dom-CsKXTaNw.d.ts → dom-BO2-E9oK.d.ts}

@@ -1,4 +1,4 @@
-import { c as SvgEditor, p as Gestures, s as SurfaceHandle, w as Camera } from "./editor-BKoo9SPL.js";
+import { c as SvgEditor, p as Gestures, s as SurfaceHandle, w as Camera } from "./editor-CYoGJ3Hf.js";
 import cmath from "@grida/cmath";
 //#region src/core/snap/options.d.ts
 type SnapOptions = {
@@ -11,6 +11,35 @@ type SnapOptions = {
 declare const DEFAULT_SNAP_OPTIONS: SnapOptions;
 //#endregion
 //#region src/dom.d.ts
+/**
+ * Wire a web-font settle source to the editor's geometry channel.
+ *
+ * The DOM surface re-serializes the `<svg>` on every editor tick, but a
+ * `<text>` / `<tspan>` bbox can change with NO attribute write: a web font
+ * finishing load AFTER its `font-family` / `font-size` was already written.
+ * The IR never sees that reflow, so nothing bumps `geometry_version` and
+ * every bounds-keyed consumer (snap, HUD chrome, size meter) stays stuck at
+ * the fallback-face metrics until the next real edit.
+ *
+ * Listens for `loadingdone` on `source` (a `FontFaceSet`, or any injected
+ * `EventTarget` in tests) and calls `bump` once per settle. COARSE on
+ * purpose: one bump clears the WHOLE bounds cache, not just text nodes —
+ * consistent with the package's pessimistic-invalidation stance, and far
+ * cheaper than scoping the bump to the (possibly many) reflowed runs.
+ *
+ * Also bumps once when `source.ready` resolves (when present): fonts that
+ * settled before attach — a cache hit, or `font-display` resolving the same
+ * tick the surface mounts — never re-fire `loadingdone`, so a document
+ * mounted post-settle still needs one bump to re-read at the real metrics.
+ *
+ * Returns a teardown that removes the listener and neutralizes the pending
+ * `ready` bump (leak guard) — call it on surface detach.
+ *
+ * Factored out of the surface so it can be unit-tested with a fake
+ * `EventTarget` in the node-only test env (jsdom's `FontFaceSet` is
+ * incomplete); never a real font / network.
+ */
+declare function install_font_load_geometry_bump(source: EventTarget | null, bump: () => void): () => void;
 type DomSurfaceOptions = {
   /** Mount the SVG inside this container. */container: HTMLElement;
   /**
@@ -31,6 +60,19 @@ type DomSurfaceOptions = {
    * when `fit: true`.
    */
   initial_camera?: cmath.Transform;
+  /**
+   * Font-load settle source — the `EventTarget` whose `loadingdone` event
+   * signals "web fonts finished loading, text may have reflowed." Defaults
+   * to `container.ownerDocument.fonts` (the live `FontFaceSet`). The
+   * surface installs a `loadingdone` listener that advances the editor's
+   * geometry channel so text bounds re-read at the settled glyph metrics
+   * (see ../docs/geometry.md §Limitations "Text bbox depends on font").
+   *
+   * Injectable as a DOM seam: jsdom's `FontFaceSet` is incomplete, so
+   * tests pass a plain `EventTarget` stub and `dispatchEvent(new Event(
+   * "loadingdone"))` to simulate a settle without a real font / network.
+   */
+  font_load_source?: EventTarget;
 };
 /**
  * Surface handle for the DOM surface. Extends the editor's core
@@ -109,4 +151,4 @@ declare function inverse_project_rect(rect: {
   f: number;
 }, offset: readonly [number, number]): cmath.Rectangle | null;
 //#endregion
-export { project_delta_inverse_ctm as a, SnapOptions as c, inverse_project_rect as i, DomSurfaceOptions as n, project_point_through_ctm as o, attach_dom_surface as r, DEFAULT_SNAP_OPTIONS as s, DomSurfaceHandle as t };
+export { inverse_project_rect as a, DEFAULT_SNAP_OPTIONS as c, install_font_load_geometry_bump as i, SnapOptions as l, DomSurfaceOptions as n, project_delta_inverse_ctm as o, attach_dom_surface as r, project_point_through_ctm as s, DomSurfaceHandle as t };

package/dist/{dom-DILY80j7.mjs → dom-DOvcMvl4.mjs}

@@ -1,4 +1,4 @@
-import { _ as is_text_input_focused, a as paint, c as hit_shape_svg, d as NudgeDwellWatcher, f as TranslateOrchestrator, g as array_shallow_equal, h as group, i as TOOL_CURSOR, l as RotateOrchestrator, m as transform, n as insertions, o as ResizeOrchestrator, s as resize_pipeline, t as PathModel } from "./model-B2UWgViT.mjs";
+import { a as paint, b as is_text_input_focused, c as hit_shape_svg, d as NudgeDwellWatcher, f as TranslateOrchestrator, h as transform, i as TOOL_CURSOR, l as RotateOrchestrator, m as group, n as insertions, o as ResizeOrchestrator, s as resize_pipeline, t as PathModel, y as array_shallow_equal } from "./model-L3t9ixT_.mjs";
 import cmath from "@grida/cmath";
 import { svg_parse } from "@grida/svg/parse";
 import { SVGShapes } from "@grida/svg/pathdata";
@@ -1638,6 +1638,48 @@ const IS_MODIFIER_KEY = {
 *  live `<text>` element out from under the about-to-mount text surface. */
 const TEXT_EDIT_PENDING = { __pending: true };
 /**
+* Wire a web-font settle source to the editor's geometry channel.
+*
+* The DOM surface re-serializes the `<svg>` on every editor tick, but a
+* `<text>` / `<tspan>` bbox can change with NO attribute write: a web font
+* finishing load AFTER its `font-family` / `font-size` was already written.
+* The IR never sees that reflow, so nothing bumps `geometry_version` and
+* every bounds-keyed consumer (snap, HUD chrome, size meter) stays stuck at
+* the fallback-face metrics until the next real edit.
+*
+* Listens for `loadingdone` on `source` (a `FontFaceSet`, or any injected
+* `EventTarget` in tests) and calls `bump` once per settle. COARSE on
+* purpose: one bump clears the WHOLE bounds cache, not just text nodes —
+* consistent with the package's pessimistic-invalidation stance, and far
+* cheaper than scoping the bump to the (possibly many) reflowed runs.
+*
+* Also bumps once when `source.ready` resolves (when present): fonts that
+* settled before attach — a cache hit, or `font-display` resolving the same
+* tick the surface mounts — never re-fire `loadingdone`, so a document
+* mounted post-settle still needs one bump to re-read at the real metrics.
+*
+* Returns a teardown that removes the listener and neutralizes the pending
+* `ready` bump (leak guard) — call it on surface detach.
+*
+* Factored out of the surface so it can be unit-tested with a fake
+* `EventTarget` in the node-only test env (jsdom's `FontFaceSet` is
+* incomplete); never a real font / network.
+*/
+function install_font_load_geometry_bump(source, bump) {
+	if (!source) return () => {};
+	const on_fonts_settled = () => bump();
+	source.addEventListener("loadingdone", on_fonts_settled);
+	let alive = true;
+	const ready = source.ready;
+	if (ready && typeof ready.then === "function") ready.then(() => {
+		if (alive) bump();
+	});
+	return () => {
+		alive = false;
+		source.removeEventListener("loadingdone", on_fonts_settled);
+	};
+}
+/**
 * Attach a DOM surface to a headless editor. Returns a `DomSurfaceHandle`
 * whose `detach()` is the inverse — DOM cleared, listeners removed,
 * gestures uninstalled.
@@ -1777,6 +1819,7 @@ var DomSurface = class DomSurface {
 			shapeOf: (id) => this.shape_of(id),
 			vectorOf: (id) => this.vector_of(id),
 			onIntent: (i) => this.commit_intent(i),
+			onTap: (t) => this.handle_tap(t),
 			style: {
 				chromeColor: editor.style.chrome_color,
 				showRotationHandles: true
@@ -1883,6 +1926,8 @@ var DomSurface = class DomSurface {
 			win.addEventListener("resize", fn);
 			this.teardown.push(() => win.removeEventListener("resize", fn));
 		}
+		const detach_font_listener = install_font_load_geometry_bump(options.font_load_source ?? container.ownerDocument.fonts ?? null, () => editor._internal.bump_geometry());
+		this.teardown.push(detach_font_listener);
 		this.wire_events();
 		const internal = editor._internal;
 		this.editor_hover_internal = internal;
@@ -2966,6 +3011,26 @@ var DomSurface = class DomSurface {
 		if (this.editor.keymap.claims(e)) e.preventDefault();
 		this.editor.keymap.dispatch(e);
 	}
+	/**
+	* Re-express a HUD tap as an editor {@link PickEvent} and fan it out on the
+	* editor's pick channel. The HUD already resolved everything that matters —
+	* the pointer-down point, the hit node, and click-vs-drag — so this is a
+	* pure translation (HUD `[x, y]` tuple → editor `{ x, y }` doc-space point)
+	* with NO re-hit-testing. Taking the hit from the HUD (not a fresh
+	* `node_at_point`) guarantees the pick and the selection it accompanies can
+	* never disagree. Observe-only: this mutates no editor state.
+	*/
+	handle_tap(tap) {
+		this.editor._internal.push_pick({
+			point: {
+				x: tap.point[0],
+				y: tap.point[1]
+			},
+			node_id: tap.hit,
+			button: tap.button,
+			mods: tap.mods
+		});
+	}
 	commit_intent(intent) {
 		switch (intent.kind) {
 			case "select":
@@ -4515,4 +4580,4 @@ var SvgHitShapeDriver = class {
 	}
 };
 //#endregion
-export { Gestures as a, Camera as c, project_point_through_ctm as i, inverse_project_rect as n, DEFAULT_SNAP_OPTIONS as o, project_delta_inverse_ctm as r, MemoizedGeometryProvider as s, attach_dom_surface as t };
+export { project_point_through_ctm as a, MemoizedGeometryProvider as c, project_delta_inverse_ctm as i, Camera as l, install_font_load_geometry_bump as n, Gestures as o, inverse_project_rect as r, DEFAULT_SNAP_OPTIONS as s, attach_dom_surface as t };

package/dist/{dom-Dee6FtgZ.js → dom-U6ae5fQF.js}

@@ -1,4 +1,4 @@
-const require_model = require("./model-CJ1Ctq14.js");
+const require_model = require("./model-D0nU_EkL.js");
 let _grida_cmath = require("@grida/cmath");
 _grida_cmath = require_model.__toESM(_grida_cmath);
 let _grida_svg_parse = require("@grida/svg/parse");
@@ -1640,6 +1640,48 @@ const IS_MODIFIER_KEY = {
 *  live `<text>` element out from under the about-to-mount text surface. */
 const TEXT_EDIT_PENDING = { __pending: true };
 /**
+* Wire a web-font settle source to the editor's geometry channel.
+*
+* The DOM surface re-serializes the `<svg>` on every editor tick, but a
+* `<text>` / `<tspan>` bbox can change with NO attribute write: a web font
+* finishing load AFTER its `font-family` / `font-size` was already written.
+* The IR never sees that reflow, so nothing bumps `geometry_version` and
+* every bounds-keyed consumer (snap, HUD chrome, size meter) stays stuck at
+* the fallback-face metrics until the next real edit.
+*
+* Listens for `loadingdone` on `source` (a `FontFaceSet`, or any injected
+* `EventTarget` in tests) and calls `bump` once per settle. COARSE on
+* purpose: one bump clears the WHOLE bounds cache, not just text nodes —
+* consistent with the package's pessimistic-invalidation stance, and far
+* cheaper than scoping the bump to the (possibly many) reflowed runs.
+*
+* Also bumps once when `source.ready` resolves (when present): fonts that
+* settled before attach — a cache hit, or `font-display` resolving the same
+* tick the surface mounts — never re-fire `loadingdone`, so a document
+* mounted post-settle still needs one bump to re-read at the real metrics.
+*
+* Returns a teardown that removes the listener and neutralizes the pending
+* `ready` bump (leak guard) — call it on surface detach.
+*
+* Factored out of the surface so it can be unit-tested with a fake
+* `EventTarget` in the node-only test env (jsdom's `FontFaceSet` is
+* incomplete); never a real font / network.
+*/
+function install_font_load_geometry_bump(source, bump) {
+	if (!source) return () => {};
+	const on_fonts_settled = () => bump();
+	source.addEventListener("loadingdone", on_fonts_settled);
+	let alive = true;
+	const ready = source.ready;
+	if (ready && typeof ready.then === "function") ready.then(() => {
+		if (alive) bump();
+	});
+	return () => {
+		alive = false;
+		source.removeEventListener("loadingdone", on_fonts_settled);
+	};
+}
+/**
 * Attach a DOM surface to a headless editor. Returns a `DomSurfaceHandle`
 * whose `detach()` is the inverse — DOM cleared, listeners removed,
 * gestures uninstalled.
@@ -1779,6 +1821,7 @@ var DomSurface = class DomSurface {
 			shapeOf: (id) => this.shape_of(id),
 			vectorOf: (id) => this.vector_of(id),
 			onIntent: (i) => this.commit_intent(i),
+			onTap: (t) => this.handle_tap(t),
 			style: {
 				chromeColor: editor.style.chrome_color,
 				showRotationHandles: true
@@ -1885,6 +1928,8 @@ var DomSurface = class DomSurface {
 			win.addEventListener("resize", fn);
 			this.teardown.push(() => win.removeEventListener("resize", fn));
 		}
+		const detach_font_listener = install_font_load_geometry_bump(options.font_load_source ?? container.ownerDocument.fonts ?? null, () => editor._internal.bump_geometry());
+		this.teardown.push(detach_font_listener);
 		this.wire_events();
 		const internal = editor._internal;
 		this.editor_hover_internal = internal;
@@ -2968,6 +3013,26 @@ var DomSurface = class DomSurface {
 		if (this.editor.keymap.claims(e)) e.preventDefault();
 		this.editor.keymap.dispatch(e);
 	}
+	/**
+	* Re-express a HUD tap as an editor {@link PickEvent} and fan it out on the
+	* editor's pick channel. The HUD already resolved everything that matters —
+	* the pointer-down point, the hit node, and click-vs-drag — so this is a
+	* pure translation (HUD `[x, y]` tuple → editor `{ x, y }` doc-space point)
+	* with NO re-hit-testing. Taking the hit from the HUD (not a fresh
+	* `node_at_point`) guarantees the pick and the selection it accompanies can
+	* never disagree. Observe-only: this mutates no editor state.
+	*/
+	handle_tap(tap) {
+		this.editor._internal.push_pick({
+			point: {
+				x: tap.point[0],
+				y: tap.point[1]
+			},
+			node_id: tap.hit,
+			button: tap.button,
+			mods: tap.mods
+		});
+	}
 	commit_intent(intent) {
 		switch (intent.kind) {
 			case "select":
@@ -4547,6 +4612,12 @@ Object.defineProperty(exports, "attach_dom_surface", {
 		return attach_dom_surface;
 	}
 });
+Object.defineProperty(exports, "install_font_load_geometry_bump", {
+	enumerable: true,
+	get: function() {
+		return install_font_load_geometry_bump;
+	}
+});
 Object.defineProperty(exports, "inverse_project_rect", {
 	enumerable: true,
 	get: function() {

package/dist/dom.d.mts

@@ -1,3 +1,3 @@
-import { C as BoundsResolver, E as CameraOptions, T as CameraConstraints, d as GestureContext, f as GestureId, g as MemoizedGeometryProvider, h as GeometrySignals, i as DomComputedResolver, m as GeometryProvider, p as Gestures, r as DomComputedPaint, u as GestureBinding, w as Camera } from "./editor-Dl7c0q5A.mjs";
-import { a as project_delta_inverse_ctm, c as SnapOptions, i as inverse_project_rect, n as DomSurfaceOptions, o as project_point_through_ctm, r as attach_dom_surface, s as DEFAULT_SNAP_OPTIONS, t as DomSurfaceHandle } from "./dom-CK6GlgFF.mjs";
-export { type BoundsResolver, Camera, type CameraConstraints, type CameraOptions, DEFAULT_SNAP_OPTIONS, type DomComputedPaint, type DomComputedResolver, DomSurfaceHandle, DomSurfaceOptions, type GeometryProvider, type GeometrySignals, type GestureBinding, type GestureContext, type GestureId, Gestures, MemoizedGeometryProvider, type SnapOptions, attach_dom_surface, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };
+import { C as BoundsResolver, E as CameraOptions, T as CameraConstraints, d as GestureContext, f as GestureId, g as MemoizedGeometryProvider, h as GeometrySignals, i as DomComputedResolver, m as GeometryProvider, p as Gestures, r as DomComputedPaint, u as GestureBinding, w as Camera } from "./editor-D2eQe8lB.mjs";
+import { a as inverse_project_rect, c as DEFAULT_SNAP_OPTIONS, i as install_font_load_geometry_bump, l as SnapOptions, n as DomSurfaceOptions, o as project_delta_inverse_ctm, r as attach_dom_surface, s as project_point_through_ctm, t as DomSurfaceHandle } from "./dom-98AUOfsP.mjs";
+export { type BoundsResolver, Camera, type CameraConstraints, type CameraOptions, DEFAULT_SNAP_OPTIONS, type DomComputedPaint, type DomComputedResolver, DomSurfaceHandle, DomSurfaceOptions, type GeometryProvider, type GeometrySignals, type GestureBinding, type GestureContext, type GestureId, Gestures, MemoizedGeometryProvider, type SnapOptions, attach_dom_surface, install_font_load_geometry_bump, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };

package/dist/dom.d.ts

@@ -1,3 +1,3 @@
-import { C as BoundsResolver, E as CameraOptions, T as CameraConstraints, d as GestureContext, f as GestureId, g as MemoizedGeometryProvider, h as GeometrySignals, i as DomComputedResolver, m as GeometryProvider, p as Gestures, r as DomComputedPaint, u as GestureBinding, w as Camera } from "./editor-BKoo9SPL.js";
-import { a as project_delta_inverse_ctm, c as SnapOptions, i as inverse_project_rect, n as DomSurfaceOptions, o as project_point_through_ctm, r as attach_dom_surface, s as DEFAULT_SNAP_OPTIONS, t as DomSurfaceHandle } from "./dom-CsKXTaNw.js";
-export { type BoundsResolver, Camera, type CameraConstraints, type CameraOptions, DEFAULT_SNAP_OPTIONS, type DomComputedPaint, type DomComputedResolver, DomSurfaceHandle, DomSurfaceOptions, type GeometryProvider, type GeometrySignals, type GestureBinding, type GestureContext, type GestureId, Gestures, MemoizedGeometryProvider, type SnapOptions, attach_dom_surface, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };
+import { C as BoundsResolver, E as CameraOptions, T as CameraConstraints, d as GestureContext, f as GestureId, g as MemoizedGeometryProvider, h as GeometrySignals, i as DomComputedResolver, m as GeometryProvider, p as Gestures, r as DomComputedPaint, u as GestureBinding, w as Camera } from "./editor-CYoGJ3Hf.js";
+import { a as inverse_project_rect, c as DEFAULT_SNAP_OPTIONS, i as install_font_load_geometry_bump, l as SnapOptions, n as DomSurfaceOptions, o as project_delta_inverse_ctm, r as attach_dom_surface, s as project_point_through_ctm, t as DomSurfaceHandle } from "./dom-BO2-E9oK.js";
+export { type BoundsResolver, Camera, type CameraConstraints, type CameraOptions, DEFAULT_SNAP_OPTIONS, type DomComputedPaint, type DomComputedResolver, DomSurfaceHandle, DomSurfaceOptions, type GeometryProvider, type GeometrySignals, type GestureBinding, type GestureContext, type GestureId, Gestures, MemoizedGeometryProvider, type SnapOptions, attach_dom_surface, install_font_load_geometry_bump, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };

package/dist/dom.js

@@ -1,10 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_dom = require("./dom-Dee6FtgZ.js");
+const require_dom = require("./dom-U6ae5fQF.js");
 exports.Camera = require_dom.Camera;
 exports.DEFAULT_SNAP_OPTIONS = require_dom.DEFAULT_SNAP_OPTIONS;
 exports.Gestures = require_dom.Gestures;
 exports.MemoizedGeometryProvider = require_dom.MemoizedGeometryProvider;
 exports.attach_dom_surface = require_dom.attach_dom_surface;
+exports.install_font_load_geometry_bump = require_dom.install_font_load_geometry_bump;
 exports.inverse_project_rect = require_dom.inverse_project_rect;
 exports.project_delta_inverse_ctm = require_dom.project_delta_inverse_ctm;
 exports.project_point_through_ctm = require_dom.project_point_through_ctm;

package/dist/dom.mjs

@@ -1,2 +1,2 @@
-import { a as Gestures, c as Camera, i as project_point_through_ctm, n as inverse_project_rect, o as DEFAULT_SNAP_OPTIONS, r as project_delta_inverse_ctm, s as MemoizedGeometryProvider, t as attach_dom_surface } from "./dom-DILY80j7.mjs";
-export { Camera, DEFAULT_SNAP_OPTIONS, Gestures, MemoizedGeometryProvider, attach_dom_surface, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };
+import { a as project_point_through_ctm, c as MemoizedGeometryProvider, i as project_delta_inverse_ctm, l as Camera, n as install_font_load_geometry_bump, o as Gestures, r as inverse_project_rect, s as DEFAULT_SNAP_OPTIONS, t as attach_dom_surface } from "./dom-DOvcMvl4.mjs";
+export { Camera, DEFAULT_SNAP_OPTIONS, Gestures, MemoizedGeometryProvider, attach_dom_surface, install_font_load_geometry_bump, inverse_project_rect, project_delta_inverse_ctm, project_point_through_ctm };