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

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

@@ -1,6 +1,7 @@
-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-DIzZmeyf.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";
 import vn from "@grida/vn";
 import { createTextEditor } from "@grida/text-editor/dom";
 import { NO_MODS, Surface, measurementToHUDDraw, snapGuideToHUDDraw } from "@grida/hud";
@@ -342,6 +343,12 @@ var MemoizedGeometryProvider = class {
 	node_at_point(p) {
 		return this.driver.node_at_point(p);
 	}
+	/** Pass-through. Frame projection depends on live layout, not on the
+	*  bounds cache, so there is nothing to memoize. Falls back to the raw
+	*  delta when the driver can't resolve a frame. */
+	world_delta_to_local(id, delta) {
+		return this.driver.world_delta_to_local?.(id, delta) ?? delta;
+	}
 	/** Unsubscribe from both signals. Call on surface detach. */
 	dispose() {
 		for (const unsub of this.unsubscribers) unsub();
@@ -1204,7 +1211,8 @@ function sub_selection_equal(a, b) {
 var VectorEditSession = class {
 	constructor(node_id, source, session_d) {
 		this.node_id = node_id;
-		this.source = source;
+		this._source = source;
+		this._source_before_promotion = null;
 		this._session_d = session_d;
 		this._last_seen_d = session_d;
 		this._selected_vertices = [];
@@ -1212,6 +1220,51 @@ var VectorEditSession = class {
 		this._selected_tangents = [];
 		this._hovered_control = null;
 	}
+	/** Source tag the session currently projects through. See `_source`. */
+	get source() {
+		return this._source;
+	}
+	/**
+	* Flip the source to `path` after the underlying element was promoted
+	* (rect / circle / ellipse → `<path>`). Idempotent: a second call while
+	* already promoted does nothing, so the pre-promotion source captured by
+	* the first flip is never clobbered.
+	*/
+	promote_source_to_path() {
+		if (this._source_before_promotion !== null) return;
+		if (this._source.kind === "path") return;
+		this._source_before_promotion = this._source;
+		this._source = {
+			kind: "path",
+			d: this._session_d
+		};
+	}
+	/** Reverse a {@link promote_source_to_path} (gesture undo). No-op if the
+	*  source was never promoted. */
+	restore_source() {
+		if (this._source_before_promotion === null) return;
+		this._source = this._source_before_promotion;
+		this._source_before_promotion = null;
+	}
+	/**
+	* Re-sync the source to the document's current tag, outright. Unlike
+	* {@link promote_source_to_path} / {@link restore_source} (which manage a
+	* single primitive→path flip within one gesture), this sets the source to
+	* an authoritative value derived from the live document and clears the
+	* promotion bookkeeping.
+	*
+	* The host calls this when an undo/redo re-types the node out from under a
+	* *different* live session object than the one that performed the original
+	* flip (exit + undo-exit creates a fresh session; the captured session's
+	* `restore_source` then no-ops). Without it the live session could keep
+	* `source.kind === "path"` while the node is back to a primitive, and the
+	* next gesture would write a stray `d` onto the native tag. Re-deriving
+	* from the document keeps the live session authoritative.
+	*/
+	sync_source(source) {
+		this._source = source;
+		this._source_before_promotion = null;
+	}
 	/** The session's current PathModel-form `d`. Gesture handlers read
 	*  this instead of `doc.get_attr(node_id, "d")` so they stay tag-
 	*  oblivious (non-path sources have no `d` on the document). */
@@ -1376,26 +1429,39 @@ var VectorEditSession = class {
 function source_to_session_d(source) {
 	switch (source.kind) {
 		case "path": return source.d;
+		case "line": return vn.toSVGPathData(vn.fromPolyline([[source.x1, source.y1], [source.x2, source.y2]]));
 		case "polyline": return vn.toSVGPathData(vn.fromPolyline(source.points.map((p) => [p[0], p[1]])));
 		case "polygon": return vn.toSVGPathData(vn.fromPolygon(source.points.map((p) => [p[0], p[1]])));
+		case "circle": return vn.toSVGPathData(vn.fromEllipse({
+			x: source.cx - source.r,
+			y: source.cy - source.r,
+			width: source.r * 2,
+			height: source.r * 2
+		}));
+		case "ellipse": return vn.toSVGPathData(vn.fromEllipse({
+			x: source.cx - source.rx,
+			y: source.cy - source.ry,
+			width: source.rx * 2,
+			height: source.ry * 2
+		}));
+		case "rect": return SVGShapes.createRect(source.x, source.y, source.width, source.height, source.rx, source.ry).encode();
 	}
 }
 /**
-* Tag-aware document write. Given a new path-data `d` from a gesture,
+* Native-attribute writeback. Given a new path-data `d` from a gesture,
 * project it back into the source tag's native attrs and write those —
-* unless the source is `<path>`, in which case `d` is written
-* directly.
+* `<path>` takes `d` directly; `<line>` takes `x1/y1/x2/y2`;
+* `<polyline>` / `<polygon>` take `points`.
 *
-* Returns `true` on success. Returns `false` for non-path sources when
-* the model can no longer be expressed in the source tag's native attrs
-* (tangent introduced, topology change). v1 treats `false` as gesture
-* refusal — the caller should NOT fall through and write `d` on a non-
-* path element. Promotion to `<path>` lives in v1.1+.
+* Returns `true` if the geometry was written natively. Returns `false`
+* when the source tag cannot express the geometry — a curve was introduced
+* or the topology left the tag's canonical form, OR the source is a
+* geometry primitive (rect / circle / ellipse) which has no native vector
+* form at all. A `false` return is the re-type-to-`<path>` signal; the
+* caller ({@link vector_apply}) handles it. This function never re-types.
 *
-* Symmetric across apply / revert: gesture handlers call this for both
-* the in-flight write and the undo-revert (since both are just "set the
-* geometry to this d"), so apply/revert stay consistent even when one
-* writes native attrs and the other would.
+* Symmetric across apply / revert: callers use it for both the in-flight
+* write and the undo-revert (both are just "set the geometry to this d").
 */
 function apply_session_d(doc, node_id, source, d) {
 	if (source.kind === "path") {
@@ -1404,10 +1470,62 @@ function apply_session_d(doc, node_id, source, d) {
 	}
 	const native = PathModel.fromSvgPathD(d).toNativeAttrs(source.kind);
 	if (native === null) return false;
+	if (native.kind === "line") {
+		doc.set_attr(node_id, "x1", String(native.x1));
+		doc.set_attr(node_id, "y1", String(native.y1));
+		doc.set_attr(node_id, "x2", String(native.x2));
+		doc.set_attr(node_id, "y2", String(native.y2));
+		return true;
+	}
 	const points = native.points.map((p) => `${p[0]},${p[1]}`).join(" ");
 	doc.set_attr(node_id, "points", points);
 	return true;
 }
+/**
+* Session-aware geometry write — the single commit chokepoint the DOM
+* gesture handlers call so re-typing stays in one place rather than being
+* reimplemented per gesture. One uniform rule across every source:
+*
+*   1. Try native writeback ({@link apply_session_d}). For `<path>` and for
+*      a vertex tag (`line` / `polyline` / `polygon`) whose edit still fits
+*      its native form, this writes and we're done — the element keeps its
+*      tag.
+*   2. If native writeback refused (a curve was introduced, the topology
+*      escaped the canonical chain, or the source is a geometry primitive
+*      with no native form), re-type the element to `<path>` via
+*      {@link SvgDocument.retype_to_path} and flip the session source to
+*      `path` (so every downstream reader — overlay, gates, the
+*      external-mutation reconciler — behaves correctly).
+*
+* Returns the {@link RetypeRecord} token iff this call performed a re-type
+* (so the caller can pair it with the edit in one history bracket and hand
+* it to {@link vector_revert} on undo); otherwise `null`.
+*/
+function vector_apply(doc, session, d) {
+	if (apply_session_d(doc, session.node_id, session.source, d)) return null;
+	const token = doc.retype_to_path(session.node_id, d);
+	if (token) {
+		session.promote_source_to_path();
+		return token;
+	}
+	doc.set_attr(session.node_id, "d", d);
+	return null;
+}
+/**
+* Counterpart to {@link vector_apply}. If this gesture re-typed the element
+* (a non-null `promotion` token), restore the original tag/attrs and the
+* session source — the re-type and the edit undo as one step. Otherwise
+* re-write the baseline geometry natively; for a geometry primitive that
+* never re-typed, {@link apply_session_d} writes nothing (a correct no-op).
+*/
+function vector_revert(doc, session, baseline_d, promotion) {
+	if (promotion) {
+		doc.revert_retype(session.node_id, promotion);
+		session.restore_source();
+		return;
+	}
+	apply_session_d(doc, session.node_id, session.source, baseline_d);
+}
 //#endregion
 //#region src/core/vector-edit/marquee.ts
 let marquee;
@@ -1519,11 +1637,48 @@ const IS_MODIFIER_KEY = {
 *  surface skips render() during the in-flight mount and doesn't yank the
 *  live `<text>` element out from under the about-to-mount text surface. */
 const TEXT_EDIT_PENDING = { __pending: true };
-/** Per-frame `neighbours: []` for the `vector_of` HUD projection. Polyline
-*  and polygon sources never render tangent handles in v1 (curve edits would
-*  promote to `<path>`); using a frozen module-level array avoids allocating
-*  a fresh empty array per redraw frame. */
-const EMPTY_NEIGHBOURS = Object.freeze([]);
+/**
+* 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,
@@ -1578,6 +1733,7 @@ var DomSurface = class DomSurface {
 		this.teardown.push(() => this.attention.dispose());
 		if (process.env.NODE_ENV !== "production" && container.children.length > 0) console.warn("@grida/svg-editor: surface container is not empty at attach time. Render chrome (toolbars, layer lists, inspectors) as siblings of the container, not children — otherwise clicks on those children will silently break. See README §Surface.");
 		if (getComputedStyle(container).position === "static") container.style.position = "relative";
+		container.style.overflow = "hidden";
 		container.style.userSelect = "none";
 		container.style.webkitUserSelect = "none";
 		const translate_options = () => {
@@ -1594,7 +1750,8 @@ var DomSurface = class DomSurface {
 			emit: () => this.editor_internal().emit(),
 			open_preview: (label) => this.editor_internal().history.preview(label),
 			open_snap: (ids) => this.open_snap_session_for(ids),
-			options: translate_options
+			options: translate_options,
+			project_delta: (id, d) => this._geometry_provider?.world_delta_to_local(id, d) ?? d
 		});
 		const resize_options = () => {
 			const style = this.editor.style;
@@ -1662,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
@@ -1768,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;
@@ -2334,14 +2494,15 @@ var DomSurface = class DomSurface {
 		const neighbor_ids = compute_neighborhood(doc, ids);
 		const agent_id_set = /* @__PURE__ */ new Set();
 		for (const id of ids) for (const inner of snap_descent(doc, id)) agent_id_set.add(inner);
+		const bounds_of = (id) => this._geometry_provider?.bounds_of(id) ?? null;
 		const agents = [];
 		for (const id of agent_id_set) {
-			const r = this.bbox_world_for_snap(id);
+			const r = bounds_of(id);
 			if (r) agents.push(r);
 		}
 		const neighbors = [];
 		for (const id of neighbor_ids) {
-			const r = this.bbox_world_for_snap(id);
+			const r = bounds_of(id);
 			if (r) neighbors.push(r);
 		}
 		return new SnapSession({
@@ -2850,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":
@@ -3259,7 +3440,7 @@ var DomSurface = class DomSurface {
 		if (this.text_edit || this.vector_edit) return false;
 		const tag = this.tag_of(id);
 		if (tag === "text" || tag === "tspan") return this.enter_text_edit(id);
-		if (tag === "path" || tag === "polyline" || tag === "polygon") return this.enter_vector_edit(id);
+		if (this.editor_internal().doc.is_vector_edit_target(id) !== null) return this.enter_vector_edit(id);
 		return false;
 	}
 	/**
@@ -3542,11 +3723,11 @@ var DomSurface = class DomSurface {
 					b_control: project_point_through_ctm(b_ctrl_local[0], b_ctrl_local[1], ctm, offset)
 				};
 			}),
-			neighbours: this.vector_edit.source.kind === "path" ? model.neighbouringVertices({
+			neighbours: model.neighbouringVertices({
 				vertices: this.vector_edit.selected_vertices,
 				segments: this.vector_edit.selected_segments,
 				tangents: this.vector_edit.selected_tangents
-			}) : EMPTY_NEIGHBOURS,
+			}),
 			origin: [0, 0]
 		};
 	}
@@ -3611,11 +3792,54 @@ var DomSurface = class DomSurface {
 	replay_vector_session_state(target_node_id, d, selection) {
 		const cur = this.vector_edit;
 		if (!cur || cur.node_id !== target_node_id) return;
-		if (d !== null) cur.mark_seen(d);
+		if (d !== null) {
+			cur.mark_seen(d);
+			const live_source = this.editor_internal().doc.is_vector_edit_target(cur.node_id);
+			if (live_source) cur.sync_source(live_source);
+		}
 		cur.restore_selection(selection);
 		this.sync_selection_mirror();
 	}
 	/**
+	* Build the `{ apply, revert }` history step for a vector-edit geometry
+	* delta — the single chokepoint that routes the write through
+	* {@link vector_apply} / {@link vector_revert} so promote-to-path of a
+	* primitive source (rect / circle / ellipse) is handled in one place
+	* rather than per gesture.
+	*
+	* `promo` is the per-gesture token holder (shared by reference across an
+	* `active_preview`'s preview frames and its committed step) so the
+	* promotion that fires on the first frame is the one undo reverses —
+	* promotion + first edit collapse into a single undo step. On redo after
+	* an undo-demote, `apply` re-promotes and refreshes the token.
+	*
+	* `after_selection` / `before_selection` drive sub-selection replay;
+	* pass `null` (preview frames) to skip it.
+	*/
+	vector_geometry_step(node_id, target_d, baseline_d, promo, after_selection, before_selection) {
+		const internal = this.editor_internal();
+		const doc = internal.doc;
+		const emit = internal.emit;
+		const session = this.vector_edit;
+		return {
+			providerId: "svg-editor",
+			apply: () => {
+				if (session) {
+					const tok = vector_apply(doc, session, target_d);
+					if (tok) promo.token = tok;
+				}
+				if (after_selection) this.replay_vector_session_state(node_id, target_d, after_selection);
+				emit();
+			},
+			revert: () => {
+				if (session) vector_revert(doc, session, baseline_d, promo.token);
+				promo.token = null;
+				if (before_selection) this.replay_vector_session_state(node_id, baseline_d, before_selection);
+				emit();
+			}
+		};
+	}
+	/**
 	* Push a standalone vector sub-selection change as one history entry.
 	*
 	* Called by selection-only handlers (vertex / segment / tangent click,
@@ -3707,11 +3931,7 @@ var DomSurface = class DomSurface {
 	handle_translate_vertices(intent) {
 		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
 		const internal = this.editor_internal();
-		const doc = internal.doc;
-		const emit = internal.emit;
 		const node_id = intent.node_id;
-		const source = this.vector_edit.source;
-		const commit = (d) => apply_session_d(doc, node_id, source, d);
 		if (!this.active_preview || this.active_preview.kind !== "vector_vertex_translate" || this.active_preview.node_id !== node_id || !array_shallow_equal(this.active_preview.indices, intent.indices)) {
 			if (this.active_preview) {
 				if ("session" in this.active_preview) this.active_preview.session.discard();
@@ -3722,6 +3942,7 @@ var DomSurface = class DomSurface {
 			this.active_preview = {
 				kind: "vector_vertex_translate",
 				node_id,
+				promo: { token: null },
 				indices: [...intent.indices],
 				initial_d,
 				baseline_model,
@@ -3747,32 +3968,10 @@ var DomSurface = class DomSurface {
 		if (intent.phase === "commit") {
 			const before_selection = this.active_preview.before_selection;
 			const after_selection = this.vector_edit.snapshot_selection();
-			this.active_preview.session.set({
-				providerId: "svg-editor",
-				apply: () => {
-					commit(target_d);
-					this.replay_vector_session_state(node_id, target_d, after_selection);
-					emit();
-				},
-				revert: () => {
-					commit(baseline_d);
-					this.replay_vector_session_state(node_id, baseline_d, before_selection);
-					emit();
-				}
-			});
+			this.active_preview.session.set(this.vector_geometry_step(node_id, target_d, baseline_d, this.active_preview.promo, after_selection, before_selection));
 			this.active_preview.session.commit();
 			this.active_preview = null;
-		} else this.active_preview.session.set({
-			providerId: "svg-editor",
-			apply: () => {
-				commit(target_d);
-				emit();
-			},
-			revert: () => {
-				commit(baseline_d);
-				emit();
-			}
-		});
+		} else this.active_preview.session.set(this.vector_geometry_step(node_id, target_d, baseline_d, this.active_preview.promo, null, null));
 	}
 	/**
 	* `translate_vector_selection` — the sub-selection-aware delta-translate.
@@ -3804,11 +4003,7 @@ var DomSurface = class DomSurface {
 	handle_translate_vector_selection(intent) {
 		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
 		const internal = this.editor_internal();
-		const doc = internal.doc;
-		const emit = internal.emit;
 		const node_id = intent.node_id;
-		const source = this.vector_edit.source;
-		const commit = (d) => apply_session_d(doc, node_id, source, d);
 		const ses = this.vector_edit;
 		const current_d = this.read_session_d();
 		if (current_d === null) return;
@@ -3845,6 +4040,7 @@ var DomSurface = class DomSurface {
 			this.active_preview = {
 				kind: "vector_translate_selection",
 				node_id,
+				promo: { token: null },
 				indices: [...indices],
 				tangent_refs: [...tangent_refs],
 				initial_d,
@@ -3878,32 +4074,10 @@ var DomSurface = class DomSurface {
 		if (intent.phase === "commit") {
 			const before_selection = this.active_preview.before_selection;
 			const after_selection = this.vector_edit.snapshot_selection();
-			this.active_preview.session.set({
-				providerId: "svg-editor",
-				apply: () => {
-					commit(target_d);
-					this.replay_vector_session_state(node_id, target_d, after_selection);
-					emit();
-				},
-				revert: () => {
-					commit(baseline_d);
-					this.replay_vector_session_state(node_id, baseline_d, before_selection);
-					emit();
-				}
-			});
+			this.active_preview.session.set(this.vector_geometry_step(node_id, target_d, baseline_d, this.active_preview.promo, after_selection, before_selection));
 			this.active_preview.session.commit();
 			this.active_preview = null;
-		} else this.active_preview.session.set({
-			providerId: "svg-editor",
-			apply: () => {
-				commit(target_d);
-				emit();
-			},
-			revert: () => {
-				commit(baseline_d);
-				emit();
-			}
-		});
+		} else this.active_preview.session.set(this.vector_geometry_step(node_id, target_d, baseline_d, this.active_preview.promo, null, null));
 	}
 	/** Mirror handler for `select_tangent` (analogous to `select_vertex`). */
 	handle_select_tangent(intent) {
@@ -3928,13 +4102,8 @@ var DomSurface = class DomSurface {
 	*/
 	handle_set_tangent_intent(intent) {
 		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
-		if (this.vector_edit.source.kind !== "path") return;
 		const internal = this.editor_internal();
-		const doc = internal.doc;
-		const emit = internal.emit;
 		const node_id = intent.node_id;
-		const source = this.vector_edit.source;
-		const commit = (d) => apply_session_d(doc, node_id, source, d);
 		if (!this.active_preview || this.active_preview.kind !== "vector_set_tangent" || this.active_preview.node_id !== node_id || this.active_preview.tangent[0] !== intent.tangent[0] || this.active_preview.tangent[1] !== intent.tangent[1]) {
 			if (this.active_preview && "session" in this.active_preview) this.active_preview.session.discard();
 			const initial_d = this.read_session_d();
@@ -3943,6 +4112,7 @@ var DomSurface = class DomSurface {
 			this.active_preview = {
 				kind: "vector_set_tangent",
 				node_id,
+				promo: { token: null },
 				tangent: [intent.tangent[0], intent.tangent[1]],
 				initial_d,
 				baseline_model,
@@ -3960,32 +4130,10 @@ var DomSurface = class DomSurface {
 		if (intent.phase === "commit") {
 			const before_selection = this.active_preview.before_selection;
 			const after_selection = this.vector_edit.snapshot_selection();
-			this.active_preview.session.set({
-				providerId: "svg-editor",
-				apply: () => {
-					commit(target_d);
-					this.replay_vector_session_state(node_id, target_d, after_selection);
-					emit();
-				},
-				revert: () => {
-					commit(baseline_d);
-					this.replay_vector_session_state(node_id, baseline_d, before_selection);
-					emit();
-				}
-			});
+			this.active_preview.session.set(this.vector_geometry_step(node_id, target_d, baseline_d, this.active_preview.promo, after_selection, before_selection));
 			this.active_preview.session.commit();
 			this.active_preview = null;
-		} else this.active_preview.session.set({
-			providerId: "svg-editor",
-			apply: () => {
-				commit(target_d);
-				emit();
-			},
-			revert: () => {
-				commit(baseline_d);
-				emit();
-			}
-		});
+		} else this.active_preview.session.set(this.vector_geometry_step(node_id, target_d, baseline_d, this.active_preview.promo, null, null));
 	}
 	/**
 	* Split a segment at parametric position `t`. One-shot atomic edit; no
@@ -3996,35 +4144,20 @@ var DomSurface = class DomSurface {
 	handle_split_segment(intent) {
 		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
 		const node_id = intent.node_id;
-		const source = this.vector_edit.source;
-		const commit = (d) => apply_session_d(doc, node_id, source, d);
 		const baseline_d = this.read_session_d();
 		if (baseline_d === null) return;
 		const { model: next_model, new_vertex } = PathModel.fromSvgPathD(baseline_d).splitSegment(intent.segment, intent.t);
 		const target_d = next_model.toSvgPathD();
 		const internal = this.editor_internal();
-		const doc = internal.doc;
-		const emit = internal.emit;
 		const before_selection = this.vector_edit.snapshot_selection();
 		const after_selection = Object.freeze({
 			vertices: Object.freeze([new_vertex]),
 			segments: Object.freeze([]),
 			tangents: Object.freeze([])
 		});
+		const promo = { token: null };
 		const split_session = internal.history.preview("vector/split-segment");
-		split_session.set({
-			providerId: "svg-editor",
-			apply: () => {
-				commit(target_d);
-				this.replay_vector_session_state(node_id, target_d, after_selection);
-				emit();
-			},
-			revert: () => {
-				commit(baseline_d);
-				this.replay_vector_session_state(node_id, baseline_d, before_selection);
-				emit();
-			}
-		});
+		split_session.set(this.vector_geometry_step(node_id, target_d, baseline_d, promo, after_selection, before_selection));
 		split_session.commit();
 		this.redraw();
 	}
@@ -4039,13 +4172,8 @@ var DomSurface = class DomSurface {
 	*/
 	handle_bend_segment(intent) {
 		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
-		if (this.vector_edit.source.kind !== "path") return;
 		const internal = this.editor_internal();
-		const doc = internal.doc;
-		const emit = internal.emit;
 		const node_id = intent.node_id;
-		const source = this.vector_edit.source;
-		const commit = (d) => apply_session_d(doc, node_id, source, d);
 		if (!this.active_preview || this.active_preview.kind !== "vector_bend_segment" || this.active_preview.node_id !== node_id || this.active_preview.segment !== intent.segment || this.active_preview.ca !== intent.ca) {
 			if (this.active_preview && "session" in this.active_preview) this.active_preview.session.discard();
 			const initial_d = this.read_session_d();
@@ -4059,6 +4187,7 @@ var DomSurface = class DomSurface {
 			this.active_preview = {
 				kind: "vector_bend_segment",
 				node_id,
+				promo: { token: null },
 				segment: intent.segment,
 				ca: intent.ca,
 				frozen: {
@@ -4084,32 +4213,10 @@ var DomSurface = class DomSurface {
 		if (intent.phase === "commit") {
 			const before_selection = this.active_preview.before_selection;
 			const after_selection = this.vector_edit.snapshot_selection();
-			this.active_preview.session.set({
-				providerId: "svg-editor",
-				apply: () => {
-					commit(target_d);
-					this.replay_vector_session_state(node_id, target_d, after_selection);
-					emit();
-				},
-				revert: () => {
-					commit(baseline_d);
-					this.replay_vector_session_state(node_id, baseline_d, before_selection);
-					emit();
-				}
-			});
+			this.active_preview.session.set(this.vector_geometry_step(node_id, target_d, baseline_d, this.active_preview.promo, after_selection, before_selection));
 			this.active_preview.session.commit();
 			this.active_preview = null;
-		} else this.active_preview.session.set({
-			providerId: "svg-editor",
-			apply: () => {
-				commit(target_d);
-				emit();
-			},
-			revert: () => {
-				commit(baseline_d);
-				emit();
-			}
-		});
+		} else this.active_preview.session.set(this.vector_geometry_step(node_id, target_d, baseline_d, this.active_preview.promo, null, null));
 	}
 	/**
 	* Project a doc-space point (HUD's container CSS-px frame) back to the
@@ -4166,24 +4273,6 @@ var DomSurface = class DomSurface {
 		const transform_str = this.editor.document.get_attr(id, "transform");
 		return transform.project(local, transform_str);
 	}
-	/** World-space rect for snap purposes. Differs from `bbox_world` for
-	*  `<svg>` viewport-establishing elements: `getBBox()` on an `<svg>`
-	*  reports the union of descendant geometry (SVG 2 §4.6.4), which —
-	*  when the dragged element is a descendant — silently turns the
-	*  dragged element's own pre-gesture position into a snap target via
-	*  the parent's edges. Use the viewport extent instead so the root
-	*  SVG's snap edges represent the canvas boundary, not "wherever the
-	*  children happen to be right now". */
-	bbox_world_for_snap(id) {
-		if (this.tag_of(id) === "svg") {
-			const el = this.element_index.get(id);
-			if (el instanceof SVGSVGElement) {
-				const vp = svg_viewport_bounds(el);
-				if (vp) return vp;
-			}
-		}
-		return this.bbox_world(id);
-	}
 	editor_internal() {
 		return this.editor._internal;
 	}
@@ -4438,6 +4527,36 @@ var SvgGeometryDriver = class {
 	node_at_point(p) {
 		return this.accessors.pick_at_world(p, true);
 	}
+	/** World→local delta projection. The frame an element's position is
+	*  written in is its PARENT user-space: a `<rect>`'s `x`/`y` and the
+	*  leading `translate(...)` composed onto a `<g>`/transformed node are
+	*  both interpreted there. We take the parent element's frame (not the
+	*  element's own) so that translating a node whose OWN transform has a
+	*  scale/rotation is not double-counted.
+	*
+	*  Camera-free: `inv(root.getScreenCTM) ∘ parent.getScreenCTM` maps
+	*  parent user-space → root world-space, cancelling the shared CSS /
+	*  camera transform. Inverting its linear part turns a world delta into
+	*  the local delta. Identity (→ delta unchanged) for flat frames,
+	*  top-level nodes, and any degenerate / unavailable matrix. */
+	world_delta_to_local(id, delta) {
+		const parent = this.accessors.element_for(id)?.parentNode;
+		const root = this.accessors.root();
+		if (!(parent instanceof SVGGraphicsElement) || !root) return delta;
+		if (parent === root) return delta;
+		if (typeof parent.getScreenCTM !== "function" || typeof root.getScreenCTM !== "function") return delta;
+		const parent_ctm = parent.getScreenCTM();
+		const root_ctm = root.getScreenCTM();
+		if (!parent_ctm || !root_ctm) return delta;
+		const m = root_ctm.inverse().multiply(parent_ctm);
+		const det = m.a * m.d - m.c * m.b;
+		if (!Number.isFinite(det) || det === 0) return delta;
+		const [x, y] = project_delta_inverse_ctm(delta.x, delta.y, m);
+		return {
+			x,
+			y
+		};
+	}
 };
 var SvgHitShapeDriver = class {
 	constructor(accessors) {
@@ -4461,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 };