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

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

@@ -1,7 +1,8 @@
-const require_model = require("./model-DqGqV1H4.js");
+const require_model = require("./model-CJ1Ctq14.js");
 let _grida_cmath = require("@grida/cmath");
 _grida_cmath = require_model.__toESM(_grida_cmath);
 let _grida_svg_parse = require("@grida/svg/parse");
+let _grida_svg_pathdata = require("@grida/svg/pathdata");
 let _grida_vn = require("@grida/vn");
 _grida_vn = require_model.__toESM(_grida_vn);
 let _grida_text_editor_dom = require("@grida/text-editor/dom");
@@ -344,6 +345,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();
@@ -1206,7 +1213,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 = [];
@@ -1214,6 +1222,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). */
@@ -1378,26 +1431,39 @@ var VectorEditSession = class {
 function source_to_session_d(source) {
 	switch (source.kind) {
 		case "path": return source.d;
+		case "line": return _grida_vn.default.toSVGPathData(_grida_vn.default.fromPolyline([[source.x1, source.y1], [source.x2, source.y2]]));
 		case "polyline": return _grida_vn.default.toSVGPathData(_grida_vn.default.fromPolyline(source.points.map((p) => [p[0], p[1]])));
 		case "polygon": return _grida_vn.default.toSVGPathData(_grida_vn.default.fromPolygon(source.points.map((p) => [p[0], p[1]])));
+		case "circle": return _grida_vn.default.toSVGPathData(_grida_vn.default.fromEllipse({
+			x: source.cx - source.r,
+			y: source.cy - source.r,
+			width: source.r * 2,
+			height: source.r * 2
+		}));
+		case "ellipse": return _grida_vn.default.toSVGPathData(_grida_vn.default.fromEllipse({
+			x: source.cx - source.rx,
+			y: source.cy - source.ry,
+			width: source.rx * 2,
+			height: source.ry * 2
+		}));
+		case "rect": return _grida_svg_pathdata.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") {
@@ -1406,10 +1472,62 @@ function apply_session_d(doc, node_id, source, d) {
 	}
 	const native = require_model.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;
@@ -1521,11 +1639,6 @@ 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([]);
 /**
 * Attach a DOM surface to a headless editor. Returns a `DomSurfaceHandle`
 * whose `detach()` is the inverse — DOM cleared, listeners removed,
@@ -1580,6 +1693,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 = () => {
@@ -1596,7 +1710,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;
@@ -2336,14 +2451,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({
@@ -3261,7 +3377,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;
 	}
 	/**
@@ -3544,11 +3660,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]
 		};
 	}
@@ -3613,11 +3729,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,
@@ -3709,11 +3868,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 || !require_model.array_shallow_equal(this.active_preview.indices, intent.indices)) {
 			if (this.active_preview) {
 				if ("session" in this.active_preview) this.active_preview.session.discard();
@@ -3724,6 +3879,7 @@ var DomSurface = class DomSurface {
 			this.active_preview = {
 				kind: "vector_vertex_translate",
 				node_id,
+				promo: { token: null },
 				indices: [...intent.indices],
 				initial_d,
 				baseline_model,
@@ -3749,32 +3905,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.
@@ -3806,11 +3940,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;
@@ -3847,6 +3977,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,
@@ -3880,32 +4011,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) {
@@ -3930,13 +4039,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();
@@ -3945,6 +4049,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,
@@ -3962,32 +4067,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
@@ -3998,35 +4081,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 } = require_model.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();
 	}
@@ -4041,13 +4109,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();
@@ -4061,6 +4124,7 @@ var DomSurface = class DomSurface {
 			this.active_preview = {
 				kind: "vector_bend_segment",
 				node_id,
+				promo: { token: null },
 				segment: intent.segment,
 				ca: intent.ca,
 				frozen: {
@@ -4086,32 +4150,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
@@ -4168,24 +4210,6 @@ var DomSurface = class DomSurface {
 		const transform_str = this.editor.document.get_attr(id, "transform");
 		return require_model.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;
 	}
@@ -4440,6 +4464,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) {

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-YQwdWHBb.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-Dz_V6q0Y.mjs";
+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 };

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-CJ2KuRh5.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-D4dy6kq5.js";
+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 };

package/dist/dom.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_dom = require("./dom-BuD8TKmL.js");
+const require_dom = require("./dom-Dee6FtgZ.js");
 exports.Camera = require_dom.Camera;
 exports.DEFAULT_SNAP_OPTIONS = require_dom.DEFAULT_SNAP_OPTIONS;
 exports.Gestures = require_dom.Gestures;

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-DSjfCllZ.mjs";
+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 };