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

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

@@ -1,6 +1,8 @@
-import { A as is_text_input_focused, C as hit_shape_of_doc, O as STRUCTURAL_GRAPHICS_SET, S as is_resizable_node, T as project_local_bbox, b as compute_resize_factors, d as NudgeDwellWatcher, f as TranslateOrchestrator, h as apply_resize, i as initial_attrs, l as RotateOrchestrator, n as default_attrs, o as TOOL_CURSOR, s as parse_paint, t as compute_drag_attrs, v as capture_resize_baseline, w as is_transparent_tag } from "./insertions-Okcuo-Ck.mjs";
+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 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";
 import { cursors } from "@grida/hud/cursors";
@@ -295,7 +297,7 @@ function transform_equal(a, b) {
 //#region src/core/geometry.ts
 /**
 * Caches `bounds_of` results keyed on `NodeId`; full-clears on either
-* `structure_version` or `geometry_version` bump. See docs/wg/feat-svg-editor/geometry.md for
+* `structure_version` or `geometry_version` bump. See ../../docs/geometry.md for
 * why the cache is load-bearing under the surface's per-tick re-render.
 */
 var MemoizedGeometryProvider = class {
@@ -341,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();
@@ -670,7 +678,7 @@ function is_self_rendered(doc, id) {
 function collect_rendered_subtree(doc, parent, out) {
 	for (const child of doc.element_children_of(parent)) {
 		if (!is_self_rendered(doc, child)) continue;
-		if (!STRUCTURAL_GRAPHICS_SET.has(doc.tag_of(child))) continue;
+		if (!group.STRUCTURAL_GRAPHICS.has(doc.tag_of(child))) continue;
 		out.add(child);
 		if (doc.tag_of(child) === "g") collect_rendered_subtree(doc, child, out);
 	}
@@ -706,10 +714,10 @@ function compute_neighborhood(doc, dragged) {
 	for (const id of dragged) {
 		const parent = doc.parent_of(id);
 		if (parent === null) continue;
-		if (!excluded.has(parent) && STRUCTURAL_GRAPHICS_SET.has(doc.tag_of(parent)) && is_self_rendered(doc, parent)) out.add(parent);
+		if (!excluded.has(parent) && group.STRUCTURAL_GRAPHICS.has(doc.tag_of(parent)) && is_self_rendered(doc, parent)) out.add(parent);
 		for (const sib of doc.element_children_of(parent)) {
 			if (excluded.has(sib)) continue;
-			if (!STRUCTURAL_GRAPHICS_SET.has(doc.tag_of(sib))) continue;
+			if (!group.STRUCTURAL_GRAPHICS.has(doc.tag_of(sib))) continue;
 			if (!is_self_rendered(doc, sib)) continue;
 			for (const inner of snap_descent(doc, sib)) {
 				if (excluded.has(inner)) continue;
@@ -726,565 +734,28 @@ const DEFAULT_SNAP_OPTIONS = {
 	threshold_px: 6
 };
 //#endregion
-//#region src/core/resize-pipeline/pipeline.ts
-/** The funnel. Threads `plan` through `stages` in order; aggregates guide
-*  emissions. Pure: same inputs → same outputs. */
-function run_resize_pipeline(init, stages, ctx) {
-	let plan = init;
-	const guides = [];
-	for (const stage of stages) {
-		const out = stage.run(plan, ctx);
-		plan = out.plan;
-		if (out.emit?.guide) guides.push(out.emit.guide);
-	}
-	return {
-		plan,
-		guides
-	};
-}
-//#endregion
-//#region src/core/resize-capability.ts
-function direction_mask(dir) {
-	const has_n = dir === "n" || dir === "ne" || dir === "nw";
-	const has_s = dir === "s" || dir === "se" || dir === "sw";
-	const has_e = dir === "e" || dir === "ne" || dir === "se";
-	const has_w = dir === "w" || dir === "nw" || dir === "sw";
-	return {
-		affects_x: has_e || has_w,
-		affects_y: has_n || has_s,
-		x_edge: has_e ? "right" : has_w ? "left" : null,
-		y_edge: has_n ? "top" : has_s ? "bottom" : null
-	};
-}
-/** Is this direction one of the four corners (vs. an edge handle)? */
-function is_corner_direction(dir) {
-	return dir === "nw" || dir === "ne" || dir === "se" || dir === "sw";
-}
-/**
-* Apply per-element resize constraints to a gesture's proposed `(sx, sy)`.
-*
-* The constraint mirrors `apply_resize` exactly so that the *effective
-* rect* the caller computes from `(sx, sy)` matches what attribute writes
-* actually produce. This is the keystone of resize snap: snapping on the
-* gesture-proposed rect would lie about where the geometry lands when an
-* element-type constraint kicks in.
-*
-* Constraints:
-*   - `rect` / `image` / `use` / `ellipse` / `line` / `polyline` /
-*     `polygon` / `path`: free per-axis. Identity.
-*   - `circle`: uniform. `s = min(sx, sy)`.
-*   - `text`: uniform on corner drags; no-op on edge drags. Mirrors the
-*     `isCorner = sx !== 1 && sy !== 1` check in `apply_resize`.
-*   - `unsupported`: no-op.
-*/
-function resize_constraint(baseline, dir, sx_gesture, sy_gesture) {
-	switch (baseline.attrs.kind) {
-		case "rect":
-		case "image":
-		case "use":
-		case "ellipse":
-		case "line":
-		case "polyline":
-		case "polygon":
-		case "path": return {
-			sx: sx_gesture,
-			sy: sy_gesture,
-			no_op: false,
-			uniform: false
-		};
-		case "circle": {
-			const s = Math.min(sx_gesture, sy_gesture);
-			return {
-				sx: s,
-				sy: s,
-				no_op: false,
-				uniform: true
-			};
-		}
-		case "text": {
-			if (!is_corner_direction(dir)) return {
-				sx: 1,
-				sy: 1,
-				no_op: true,
-				uniform: true
-			};
-			const s = Math.min(sx_gesture, sy_gesture);
-			return {
-				sx: s,
-				sy: s,
-				no_op: false,
-				uniform: true
-			};
-		}
-		case "unsupported": return {
-			sx: 1,
-			sy: 1,
-			no_op: true,
-			uniform: false
-		};
-	}
-}
-/** Position of a bbox corner / edge midpoint by direction. */
-function corner_of_rect(r, dir) {
-	switch (dir) {
-		case "nw": return {
-			x: r.x,
-			y: r.y
-		};
-		case "n": return {
-			x: r.x + r.width / 2,
-			y: r.y
-		};
-		case "ne": return {
-			x: r.x + r.width,
-			y: r.y
-		};
-		case "e": return {
-			x: r.x + r.width,
-			y: r.y + r.height / 2
-		};
-		case "se": return {
-			x: r.x + r.width,
-			y: r.y + r.height
-		};
-		case "s": return {
-			x: r.x + r.width / 2,
-			y: r.y + r.height
-		};
-		case "sw": return {
-			x: r.x,
-			y: r.y + r.height
-		};
-		case "w": return {
-			x: r.x,
-			y: r.y + r.height / 2
-		};
-	}
-}
-/** The fixed-origin corner for a drag (opposite the moving corner). */
-function origin_of_direction(r, dir) {
-	switch (dir) {
-		case "nw": return {
-			x: r.x + r.width,
-			y: r.y + r.height
-		};
-		case "n": return {
-			x: r.x + r.width / 2,
-			y: r.y + r.height
-		};
-		case "ne": return {
-			x: r.x,
-			y: r.y + r.height
-		};
-		case "e": return {
-			x: r.x,
-			y: r.y + r.height / 2
-		};
-		case "se": return {
-			x: r.x,
-			y: r.y
-		};
-		case "s": return {
-			x: r.x + r.width / 2,
-			y: r.y
-		};
-		case "sw": return {
-			x: r.x + r.width,
-			y: r.y
-		};
-		case "w": return {
-			x: r.x + r.width,
-			y: r.y + r.height / 2
-		};
-	}
-}
+//#region src/core/text-edit.ts
 /**
-* Compute the effective rect that `apply_resize` would write for the
-* given gesture. This is what snap operates on.
+* Decide what happens when inline text content-editing exits.
 *
-* The rect is computed by scaling `baseline.bbox` around `origin` by the
-* constrained `(sx, sy)`. For free elements this matches the gesture
-* exactly; for circle / text-on-corner it collapses to a uniform-scale
-* rect; for text-on-edge it returns the baseline rect unchanged.
-*/
-function effective_resize(baseline, dir, sx_gesture, sy_gesture) {
-	const bbox = baseline.bbox;
-	const origin = origin_of_direction(bbox, dir);
-	const c = resize_constraint(baseline, dir, sx_gesture, sy_gesture);
-	const mask = direction_mask(dir);
-	const rect = {
-		x: origin.x + (bbox.x - origin.x) * c.sx,
-		y: origin.y + (bbox.y - origin.y) * c.sy,
-		width: bbox.width * c.sx,
-		height: bbox.height * c.sy
-	};
-	const moving_corner = corner_of_rect(rect, dir);
-	return {
-		rect,
-		sx: c.sx,
-		sy: c.sy,
-		moving_corner,
-		origin,
-		no_op: c.no_op,
-		uniform: c.uniform,
-		mask
-	};
-}
-//#endregion
-//#region src/core/resize-pipeline/stages.ts
-function pipeline_baseline(plan) {
-	return plan.baseline;
-}
-/** Collapse `(dx, dy)` to a uniform scale when Shift-drag is active.
-*  Element-driven uniform (circle / text-on-corner) is enforced inside
-*  `resize_constraint`, not here — this stage is *only* the user-visible
-*  modifier. No-op on edge handles (uniform across one axis isn't a
-*  meaningful constraint). */
-const stage_aspect_lock = {
-	name: "aspect_lock",
-	run(plan, ctx) {
-		if (ctx.modifiers.aspect_lock !== "uniform") return { plan };
-		if (!is_corner_direction(plan.direction)) return { plan };
-		const pbase = pipeline_baseline(plan);
-		const locked = compute_resize_factors(pbase, plan.direction, plan.dx, plan.dy, true);
-		const bbox = pbase.bbox;
-		const Hx_base = (() => {
-			switch (plan.direction) {
-				case "nw":
-				case "w":
-				case "sw": return bbox.x;
-				case "ne":
-				case "e":
-				case "se": return bbox.x + bbox.width;
-				case "n":
-				case "s": return bbox.x + bbox.width / 2;
-			}
-		})();
-		const Hy_base = (() => {
-			switch (plan.direction) {
-				case "nw":
-				case "n":
-				case "ne": return bbox.y;
-				case "sw":
-				case "s":
-				case "se": return bbox.y + bbox.height;
-				case "e":
-				case "w": return bbox.y + bbox.height / 2;
-			}
-		})();
-		const new_Hx = locked.origin.x + (Hx_base - locked.origin.x) * locked.sx;
-		const new_Hy = locked.origin.y + (Hy_base - locked.origin.y) * locked.sy;
-		return { plan: {
-			...plan,
-			dx: new_Hx - Hx_base,
-			dy: new_Hy - Hy_base
-		} };
-	}
-};
-/** Consults `ctx.snap_session` for moving-edge alignment correction.
-*  Identity on `force_disable_snap`, missing session, or
-*  `snap_enabled === false`. */
-const stage_snap = {
-	name: "snap",
-	run(plan, ctx) {
-		if (ctx.modifiers.force_disable_snap) return { plan };
-		if (!ctx.snap_session) return { plan };
-		if (!ctx.options.snap_enabled) return { plan };
-		const pbase = pipeline_baseline(plan);
-		const f = compute_resize_factors(pbase, plan.direction, plan.dx, plan.dy, false);
-		const eff = effective_resize(pbase, plan.direction, f.sx, f.sy);
-		if (eff.no_op) return { plan };
-		const r = ctx.snap_session.snap_resize(eff.rect, {
-			x: eff.mask.x_edge,
-			y: eff.mask.y_edge
-		}, {
-			enabled: true,
-			threshold_px: ctx.options.snap_threshold_px
-		});
-		if (r.dx === 0 && r.dy === 0) return {
-			plan,
-			emit: r.guide ? { guide: r.guide } : void 0
-		};
-		if (eff.uniform) {
-			const bbox = pbase.bbox;
-			const new_Hx = eff.moving_corner.x + r.dx;
-			const new_Hy = eff.moving_corner.y + r.dy;
-			const sx_from_x = eff.mask.x_edge !== null && r.dx !== 0 && bbox.width !== 0 ? (new_Hx - eff.origin.x) / (eff.moving_corner.x - eff.origin.x) * eff.sx : null;
-			const sy_from_y = eff.mask.y_edge !== null && r.dy !== 0 && bbox.height !== 0 ? (new_Hy - eff.origin.y) / (eff.moving_corner.y - eff.origin.y) * eff.sy : null;
-			let s = eff.sx;
-			if (sx_from_x !== null && sy_from_y !== null) s = Math.min(sx_from_x, sy_from_y);
-			else if (sx_from_x !== null) s = sx_from_x;
-			else if (sy_from_y !== null) s = sy_from_y;
-			const Hx_base = corner_x_of(bbox, plan.direction);
-			const Hy_base = corner_y_of(bbox, plan.direction);
-			const target_Hx = eff.origin.x + (Hx_base - eff.origin.x) * s;
-			const target_Hy = eff.origin.y + (Hy_base - eff.origin.y) * s;
-			return {
-				plan: {
-					...plan,
-					dx: eff.mask.affects_x ? target_Hx - Hx_base : 0,
-					dy: eff.mask.affects_y ? target_Hy - Hy_base : 0
-				},
-				emit: r.guide ? { guide: r.guide } : void 0
-			};
-		}
-		return {
-			plan: {
-				...plan,
-				dx: eff.mask.affects_x ? plan.dx + r.dx : plan.dx,
-				dy: eff.mask.affects_y ? plan.dy + r.dy : plan.dy
-			},
-			emit: r.guide ? { guide: r.guide } : void 0
-		};
-	}
-};
-/** Quantize the moving corner's *post-resize* position to integer
-*  multiples of `pixel_grid_quantum` in own-frame space. Identity when
-*  quantum is `null` / `<= 0` or the gesture is a no-op. */
-const stage_pixel_grid = {
-	name: "pixel_grid",
-	run(plan, ctx) {
-		const q = ctx.options.pixel_grid_quantum;
-		if (q === null || q <= 0) return { plan };
-		const pbase = pipeline_baseline(plan);
-		const f = compute_resize_factors(pbase, plan.direction, plan.dx, plan.dy, false);
-		const eff = effective_resize(pbase, plan.direction, f.sx, f.sy);
-		if (eff.no_op) return { plan };
-		const target_Hx = eff.mask.affects_x ? Math.round(eff.moving_corner.x / q) * q : eff.moving_corner.x;
-		const target_Hy = eff.mask.affects_y ? Math.round(eff.moving_corner.y / q) * q : eff.moving_corner.y;
-		const bbox = pbase.bbox;
-		const Hx_base = corner_x_of(bbox, plan.direction);
-		const Hy_base = corner_y_of(bbox, plan.direction);
-		return { plan: {
-			...plan,
-			dx: eff.mask.affects_x ? target_Hx - Hx_base : 0,
-			dy: eff.mask.affects_y ? target_Hy - Hy_base : 0
-		} };
-	}
-};
-function corner_x_of(r, dir) {
-	switch (dir) {
-		case "nw":
-		case "w":
-		case "sw": return r.x;
-		case "ne":
-		case "e":
-		case "se": return r.x + r.width;
-		case "n":
-		case "s": return r.x + r.width / 2;
-	}
-}
-function corner_y_of(r, dir) {
-	switch (dir) {
-		case "nw":
-		case "n":
-		case "ne": return r.y;
-		case "sw":
-		case "s":
-		case "se": return r.y + r.height;
-		case "e":
-		case "w": return r.y + r.height / 2;
-	}
-}
-/** Default stage list for HUD-driven resize gestures (drag).
-*  No NUDGE / RPC analogs at v1 (no `commands.resize` per README). */
-const STAGES_DEFAULT = Object.freeze([
-	stage_aspect_lock,
-	stage_snap,
-	stage_pixel_grid
-]);
-//#endregion
-//#region src/core/resize-pipeline/apply.ts
-function applyResizePlan(doc, plan, phase = "commit") {
-	const f = compute_resize_factors(plan.baseline, plan.direction, plan.dx, plan.dy, false);
-	const members = plan.members ?? [{
-		id: plan.id,
-		baseline: plan.baseline
-	}];
-	for (const m of members) apply_resize(doc, m.id, m.baseline, f.sx, f.sy, f.origin, phase);
-}
-function revertResizePlan(doc, plan) {
-	const f = compute_resize_factors(plan.baseline, plan.direction, 0, 0, false);
-	const members = plan.members ?? [{
-		id: plan.id,
-		baseline: plan.baseline
-	}];
-	for (const m of members) apply_resize(doc, m.id, m.baseline, 1, 1, f.origin, "preview");
-}
-/**
-* Synthesize a "group" baseline over an arbitrary union rect. The attrs
-* carrier is `rect`-kind so the pipeline math (snap / pixel-grid)
-* treats the group as free per-axis — per-member constraints (circle
-* uniform, text edge no-op) kick in at apply time against each
-* member's own captured baseline.
+* `result` is the text that should remain — the typed text on commit, the
+* original on cancel. "Empty" means zero-length: a space is authored
+* content and is kept. The rule is unconditional — an empty result deletes
+* the node however it got there (freshly placed and never typed, cleared by
+* the author, or already empty on entry).
 *
-* For single-member groups callers should pass the member's own
-* baseline directly so the per-element snap correction (`eff.uniform`
-* branch) fires correctly.
+* See docs/wg/feat-svg-editor/text-tool.md.
 */
-function synthesize_group_baseline(union) {
-	return {
-		bbox: {
-			x: union.x,
-			y: union.y,
-			width: union.width,
-			height: union.height
-		},
-		attrs: {
-			kind: "rect",
-			x: union.x,
-			y: union.y,
-			w: union.width,
-			h: union.height
-		}
-	};
-}
-//#endregion
-//#region src/core/resize-pipeline/orchestrator.ts
-const PROVIDER_ID = "svg-editor";
-/** West/north-anchor flips invert the corresponding world delta so a
-*  positive value always grows the moving edge outward — the convention
-*  `compute_resize_factors` consumes. */
-function sign_adjust(dir, dx_world, dy_world) {
-	return {
-		dx: dir === "w" || dir === "nw" || dir === "sw" ? -dx_world : dx_world,
-		dy: dir === "n" || dir === "ne" || dir === "nw" ? -dy_world : dy_world
+function resolve_text_exit(input) {
+	const is_empty = input.result.length === 0;
+	if (input.origin === "fresh") return is_empty ? { kind: "discard_insert" } : { kind: "commit_insert" };
+	if (is_empty) return { kind: "remove" };
+	if (input.result !== input.original) return {
+		kind: "set_text",
+		value: input.result
 	};
+	return { kind: "noop" };
 }
-/** Stable, order-independent key for an id set — used by `is_active_for`
-*  to decide whether the current session targets the same group. */
-function ids_key(ids) {
-	return [...ids].sort().join("\0");
-}
-var ResizeOrchestrator = class {
-	constructor(deps) {
-		this.deps = deps;
-		this.active = null;
-		this._last_guides = [];
-	}
-	/** Guides emitted by the most recent pipeline run. Cleared on
-	*  cancel/dispose. */
-	get last_guides() {
-		return this._last_guides;
-	}
-	has_active_session() {
-		return this.active !== null;
-	}
-	/** Is the gesture currently targeting `ids` with `direction`? Used by
-	*  the HUD dispatch to decide whether to reset the session on a new
-	*  handle / target. Order-independent. */
-	is_active_for(ids, direction) {
-		return this.active !== null && this.active.direction === direction && this.active.ids_key === ids_key(ids);
-	}
-	/** Per-frame drive. Opens a session lazily on the first call. The
-	*  HUD passes its gesture-target rect dimensions in **world space**;
-	*  the orchestrator derives the signed world-frame delta against its
-	*  captured `baseline.bbox`. The DOM adapter is responsible for the
-	*  CSS-px → world conversion at the intent boundary. */
-	drive(input, modifiers, opts) {
-		if (input.ids.length === 0) return null;
-		const doc = this.deps.get_doc();
-		for (const id of input.ids) if (!is_resizable_node(doc, id)) return null;
-		const key = ids_key(input.ids);
-		if (this.active && (this.active.ids_key !== key || this.active.direction !== input.direction)) {
-			this.active.preview.discard();
-			this.dispose_session();
-		}
-		if (this.active === null) this.active = this.open(input.ids, input.direction, opts.snap, opts.label ?? "resize");
-		const session = this.active;
-		const bbox = session.baseline.bbox;
-		const dx_world = input.target_width - bbox.width;
-		const dy_world = input.target_height - bbox.height;
-		const d = sign_adjust(input.direction, dx_world, dy_world);
-		const stages = opts.stages ?? STAGES_DEFAULT;
-		const result = this.run_pass(session, d.dx, d.dy, modifiers, stages);
-		session.last_dx = d.dx;
-		session.last_dy = d.dy;
-		session.last_stages = stages;
-		this.write_preview(session, result.plan, opts.phase);
-		if (opts.phase === "commit") {
-			session.preview.commit();
-			this.dispose_session();
-		}
-		return result;
-	}
-	/** Re-run the current preview frame with new modifiers. */
-	redrive_modifiers(modifiers) {
-		if (!this.active) return null;
-		const session = this.active;
-		const result = this.run_pass(session, session.last_dx, session.last_dy, modifiers, session.last_stages);
-		this.write_preview(session, result.plan, "preview");
-		return result;
-	}
-	cancel() {
-		if (!this.active) return;
-		this.active.preview.discard();
-		this.dispose_session();
-	}
-	run_pass(session, dx, dy, modifiers, stages) {
-		const result = run_resize_pipeline({
-			id: session.primary_id,
-			baseline: session.baseline,
-			members: session.members,
-			direction: session.direction,
-			dx,
-			dy
-		}, stages, {
-			input: {
-				id: session.primary_id,
-				direction: session.direction,
-				dx,
-				dy
-			},
-			modifiers,
-			options: this.deps.options(),
-			snap_session: session.snap
-		});
-		this._last_guides = result.guides;
-		return result;
-	}
-	open(ids, direction, snap, label) {
-		const doc = this.deps.get_doc();
-		const members = ids.map((id) => ({
-			id,
-			baseline: capture_resize_baseline(doc, id, this.deps.bbox_world(id))
-		}));
-		const baseline = members.length === 1 ? members[0].baseline : synthesize_group_baseline(cmath.rect.union(members.map((m) => m.baseline.bbox)));
-		return {
-			ids_key: ids_key(ids),
-			primary_id: members[0].id,
-			direction,
-			members,
-			baseline,
-			snap: snap ? this.deps.open_snap(ids) : null,
-			preview: this.deps.open_preview(label),
-			last_dx: 0,
-			last_dy: 0,
-			last_stages: STAGES_DEFAULT
-		};
-	}
-	write_preview(session, plan, phase) {
-		const doc = this.deps.get_doc();
-		const emit = this.deps.emit;
-		session.preview.set({
-			providerId: PROVIDER_ID,
-			apply: () => {
-				applyResizePlan(doc, plan, phase);
-				emit();
-			},
-			revert: () => {
-				revertResizePlan(doc, plan);
-				emit();
-			}
-		});
-	}
-	dispose_session() {
-		if (!this.active) return;
-		this.active.snap?.dispose();
-		this.active = null;
-		this._last_guides = [];
-	}
-};
 //#endregion
 //#region src/gestures/gestures.ts
 /**
@@ -1420,7 +891,7 @@ const DEFAULT_GESTURE_BINDINGS = [
 	WHEEL_PAN_ZOOM,
 	{
 		id: "space-drag-pan",
-		install({ container, camera }) {
+		install({ container, camera, is_attended }) {
 			let space_held = false;
 			let prev_cursor = null;
 			const set_cursor = (next) => {
@@ -1431,6 +902,7 @@ const DEFAULT_GESTURE_BINDINGS = [
 			const on_keydown = (e) => {
 				if (e.code !== "Space" || e.repeat) return;
 				if (is_text_input_focused()) return;
+				if (!is_attended()) return;
 				space_held = true;
 				set_cursor("grab");
 				e.preventDefault();
@@ -1483,11 +955,10 @@ const DEFAULT_GESTURE_BINDINGS = [
 	},
 	{
 		id: "keyboard-zoom",
-		install({ container, camera }) {
+		install({ container, camera, is_attended }) {
 			const owner_doc = container.ownerDocument;
 			const on_keydown = (e) => {
-				const active = owner_doc.activeElement;
-				if (active && active !== owner_doc.body && !container.contains(active)) return;
+				if (!is_attended()) return;
 				if (is_text_input_focused()) return;
 				const mod = e.metaKey || e.ctrlKey;
 				if (e.shiftKey && !mod && (e.code === "Digit0" || e.code === "Numpad0")) {
@@ -1517,6 +988,39 @@ function applyDefaultGestures(gestures) {
 	for (const b of DEFAULT_GESTURE_BINDINGS) gestures.bind(b);
 }
 //#endregion
+//#region src/util/attention.ts
+/**
+* Install pointer-tracking listeners on `container` and return the
+* read-side handle. The tracker is owned by the surface and disposed
+* alongside it; gesture bindings that need to consult it receive the
+* read-only `is_attended` predicate through `GestureContext`.
+*/
+function create_attention_tracker(container) {
+	let pointer_over = false;
+	const on_enter = () => {
+		pointer_over = true;
+	};
+	const on_leave = () => {
+		pointer_over = false;
+	};
+	container.addEventListener("pointerenter", on_enter);
+	container.addEventListener("pointerleave", on_leave);
+	const is_attended = () => {
+		const owner = container.ownerDocument;
+		if (!owner) return pointer_over;
+		const active = owner.activeElement;
+		if (active && active !== owner.body && container.contains(active)) return true;
+		return pointer_over;
+	};
+	return {
+		is_attended,
+		dispose: () => {
+			container.removeEventListener("pointerenter", on_enter);
+			container.removeEventListener("pointerleave", on_leave);
+		}
+	};
+}
+//#endregion
 //#region src/text-surface.ts
 const SVG_NS = "http://www.w3.org/2000/svg";
 const XML_NS = "http://www.w3.org/XML/1998/namespace";
@@ -1676,6 +1180,423 @@ var SvgTextSurface = class {
 	}
 };
 //#endregion
+//#region src/core/vector-edit/session.ts
+function tangents_equal(a, b) {
+	return a[0] === b[0] && a[1] === b[1];
+}
+/**
+* Shallow equality over the three sub-selection arrays. Order-sensitive
+* (mirrors how the host stores them). Used by the orchestrator to skip
+* pushing a no-op undo entry when a selection handler resolves to the
+* same state — e.g. clicking an already-selected vertex in `replace`
+* mode.
+*/
+function sub_selection_equal(a, b) {
+	if (a === b) return true;
+	if (a.vertices.length !== b.vertices.length) return false;
+	if (a.segments.length !== b.segments.length) return false;
+	if (a.tangents.length !== b.tangents.length) return false;
+	for (let i = 0; i < a.vertices.length; i++) if (a.vertices[i] !== b.vertices[i]) return false;
+	for (let i = 0; i < a.segments.length; i++) if (a.segments[i] !== b.segments[i]) return false;
+	for (let i = 0; i < a.tangents.length; i++) if (!tangents_equal(a.tangents[i], b.tangents[i])) return false;
+	return true;
+}
+/**
+* Host-side state for vector content-edit (vertex / segment / tangent
+* gestures) on the supported source tags. "Vector" here names the
+* editing mode — NOT a `vn.VectorNetwork` wrapper. The session holds
+* the source tag's authored attrs plus a path-form session-d, and
+* delegates geometry to {@link PathModel} via the apply.ts shim.
+*/
+var VectorEditSession = class {
+	constructor(node_id, source, session_d) {
+		this.node_id = node_id;
+		this._source = source;
+		this._source_before_promotion = null;
+		this._session_d = session_d;
+		this._last_seen_d = session_d;
+		this._selected_vertices = [];
+		this._selected_segments = [];
+		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). */
+	get current_d() {
+		return this._session_d;
+	}
+	/** Update the session's view after a write produced `next_d`. Caller
+	*  is `apply_session_d` (or the gesture handler that called it). */
+	update_session_d(next_d) {
+		this._session_d = next_d;
+	}
+	get last_seen_d() {
+		return this._last_seen_d;
+	}
+	get selected_vertices() {
+		return this._selected_vertices;
+	}
+	get selected_segments() {
+		return this._selected_segments;
+	}
+	get selected_tangents() {
+		return this._selected_tangents;
+	}
+	get hovered_control() {
+		return this._hovered_control;
+	}
+	/**
+	* Record that the host's most recent gesture write produced `d`.
+	* Updates both the session-d (the in-session canonical form) and the
+	* last-seen mark. The next state-change tick uses last_seen to
+	* distinguish "we wrote this" from "the document changed under us".
+	*/
+	mark_seen(d) {
+		this._session_d = d;
+		this._last_seen_d = d;
+	}
+	/**
+	* The session's response to a detected external mutation of `d`
+	* (undo / redo / programmatic / collab). Atomically (a) advances
+	* `last_seen_d` to the now-current value and (b) drops sub-selection
+	* — selection indices reference vertices and segments by ordinal
+	* position, and an external mutation may have shifted or removed
+	* them.
+	*
+	* Exposed as a single method so callers cannot get the two halves
+	* out of order. Doing `clear_selection` without `mark_seen` would
+	* leave us "stuck dirty" — the next tick would reconcile again.
+	* Doing `mark_seen` without `clear_selection` would leave stale
+	* indices pointing into a geometry that no longer matches.
+	*/
+	reconcile_after_external_mutation(d) {
+		this.mark_seen(d);
+		this.clear_selection();
+	}
+	select_vertex(index, mode) {
+		switch (mode) {
+			case "replace":
+				this._selected_vertices = [index];
+				break;
+			case "add":
+				if (!this._selected_vertices.includes(index)) this._selected_vertices = [...this._selected_vertices, index];
+				break;
+			case "toggle":
+				this._selected_vertices = this._selected_vertices.includes(index) ? this._selected_vertices.filter((v) => v !== index) : [...this._selected_vertices, index];
+				break;
+		}
+		if (mode === "replace") {
+			this._selected_segments = [];
+			this._selected_tangents = [];
+		}
+	}
+	select_segment(index, mode) {
+		switch (mode) {
+			case "replace":
+				this._selected_segments = [index];
+				break;
+			case "add":
+				if (!this._selected_segments.includes(index)) this._selected_segments = [...this._selected_segments, index];
+				break;
+			case "toggle":
+				this._selected_segments = this._selected_segments.includes(index) ? this._selected_segments.filter((s) => s !== index) : [...this._selected_segments, index];
+				break;
+		}
+		if (mode === "replace") {
+			this._selected_vertices = [];
+			this._selected_tangents = [];
+		}
+	}
+	select_tangent(ref, mode) {
+		const has = this._selected_tangents.some((t) => tangents_equal(t, ref));
+		switch (mode) {
+			case "replace":
+				this._selected_tangents = [ref];
+				break;
+			case "add":
+				if (!has) this._selected_tangents = [...this._selected_tangents, ref];
+				break;
+			case "toggle":
+				this._selected_tangents = has ? this._selected_tangents.filter((t) => !tangents_equal(t, ref)) : [...this._selected_tangents, ref];
+				break;
+		}
+		if (mode === "replace") {
+			this._selected_vertices = [];
+			this._selected_segments = [];
+		}
+	}
+	/**
+	* Replace the entire sub-selection at once. Useful for marquee /
+	* lasso results, which compute the full set up-front.
+	*/
+	set_selection(next) {
+		this._selected_vertices = [...next.vertices];
+		this._selected_segments = [...next.segments];
+		this._selected_tangents = next.tangents.map((t) => [t[0], t[1]]);
+	}
+	/**
+	* Capture the current sub-selection as a frozen triple. The
+	* orchestrator closes over snapshots in gesture deltas (so undo
+	* restores selection alongside geometry) and in standalone selection
+	* deltas (so a click on a vertex is itself undoable).
+	*
+	* Returned arrays are fresh copies — safe to retain across
+	* subsequent mutations of the session.
+	*/
+	snapshot_selection() {
+		return Object.freeze({
+			vertices: Object.freeze([...this._selected_vertices]),
+			segments: Object.freeze([...this._selected_segments]),
+			tangents: Object.freeze(this._selected_tangents.map((t) => [t[0], t[1]]))
+		});
+	}
+	/**
+	* Restore a previously-captured sub-selection. Counterpart to
+	* {@link snapshot_selection}. Equivalent to calling
+	* {@link set_selection} with the snapshot's contents.
+	*/
+	restore_selection(snap) {
+		this.set_selection(snap);
+	}
+	clear_selection() {
+		if (this._selected_vertices.length === 0 && this._selected_segments.length === 0 && this._selected_tangents.length === 0) return;
+		this._selected_vertices = [];
+		this._selected_segments = [];
+		this._selected_tangents = [];
+	}
+};
+//#endregion
+//#region src/core/vector-edit/apply.ts
+/**
+* Build the in-session path-form `d` ("session-d") for a freshly-
+* entered vector-edit. For `<path>` this is the verbatim authored
+* string; for the two vertex-chain tags we route through
+* `vn.fromPolyline` / `vn.fromPolygon` and emit via `vn.toSVGPathData`
+* — same zero-tangent `M`/`L` sequence the gesture handlers'
+* `PathModel.toSvgPathD()` will produce on subsequent commits.
+*
+* The returned string is internal to the session — it is never written
+* to the document on its own. Native-attr writeback happens through
+* {@link apply_session_d} (which calls {@link PathModel.toNativeAttrs}
+* to project the path-form geometry back to source-tag attrs).
+*/
+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();
+	}
+}
+/**
+* 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 —
+* `<path>` takes `d` directly; `<line>` takes `x1/y1/x2/y2`;
+* `<polyline>` / `<polygon>` take `points`.
+*
+* 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: 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") {
+		doc.set_attr(node_id, "d", d);
+		return true;
+	}
+	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;
+(function(_marquee) {
+	function points_in_rect(candidates, rect) {
+		const hits = [];
+		for (const c of candidates) if (cmath.rect.containsPoint(rect, c.pos)) hits.push(c.key);
+		return hits;
+	}
+	_marquee.points_in_rect = points_in_rect;
+	function points_in_polygon(candidates, polygon) {
+		const hits = [];
+		const poly = polygon;
+		for (const c of candidates) if (cmath.polygon.pointInPolygon(c.pos, poly)) hits.push(c.key);
+		return hits;
+	}
+	_marquee.points_in_polygon = points_in_polygon;
+	function subpath_select_candidates(model, selection, to_doc = identity_proj) {
+		const snap = model.snapshot();
+		const vertices = snap.vertices.map((v, i) => ({
+			key: i,
+			pos: to_doc(v)
+		}));
+		const neigh_set = new Set(model.neighbouringVertices(selection));
+		const tangents = [];
+		for (let si = 0; si < snap.segments.length; si++) {
+			const s = snap.segments[si];
+			if (neigh_set.has(s.a)) {
+				const va = snap.vertices[s.a];
+				tangents.push({
+					key: [s.a, 0],
+					pos: to_doc([va[0] + s.ta[0], va[1] + s.ta[1]])
+				});
+			}
+			if (neigh_set.has(s.b)) {
+				const vb = snap.vertices[s.b];
+				tangents.push({
+					key: [s.b, 1],
+					pos: to_doc([vb[0] + s.tb[0], vb[1] + s.tb[1]])
+				});
+			}
+		}
+		return {
+			vertices,
+			tangents,
+			segments: Array.from({ length: snap.segments.length }, (_, i) => i)
+		};
+	}
+	_marquee.subpath_select_candidates = subpath_select_candidates;
+	function identity_proj(p) {
+		return p;
+	}
+	function merge_subpath_hits(prev, hits, additive) {
+		if (!additive) return {
+			vertices: [...hits.vertices],
+			segments: [...hits.segments],
+			tangents: hits.tangents.map((t) => [t[0], t[1]])
+		};
+		const vertices = Array.from(new Set([...prev.vertices, ...hits.vertices]));
+		const segments = Array.from(new Set([...prev.segments, ...hits.segments]));
+		const tangents = prev.tangents.map((t) => [t[0], t[1]]);
+		for (const t of hits.tangents) if (!tangents.some((x) => x[0] === t[0] && x[1] === t[1])) tangents.push(t);
+		return {
+			vertices,
+			segments,
+			tangents
+		};
+	}
+	_marquee.merge_subpath_hits = merge_subpath_hits;
+})(marquee || (marquee = {}));
+//#endregion
 //#region src/dom.ts
 /** Stamped on every rendered SVG element by `render()` so external
 *  tooling (host inspectors, the layers panel, snapshot tests) can map
@@ -1757,14 +1678,20 @@ var DomSurface = class DomSurface {
 		this.text_edit = null;
 		this.text_edit_target = null;
 		this.text_edit_original = "";
+		this.pending_text_insert = null;
+		this.vector_edit = null;
+		this.vector_edit_region_baseline = null;
 		this.current_tool = TOOL_CURSOR;
 		this.pending_insert = null;
 		this.editor_hover_internal = null;
 		this.container = options.container;
 		const container = this.container;
 		this.fit_on_attach = options.fit === true;
+		this.attention = create_attention_tracker(container);
+		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 = () => {
@@ -1781,7 +1708,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;
@@ -1847,6 +1775,7 @@ var DomSurface = class DomSurface {
 		this.hud = new Surface(this.hud_canvas, {
 			pick: (p) => this.hit_test(p[0], p[1]),
 			shapeOf: (id) => this.shape_of(id),
+			vectorOf: (id) => this.vector_of(id),
 			onIntent: (i) => this.commit_intent(i),
 			style: {
 				chromeColor: editor.style.chrome_color,
@@ -1899,11 +1828,14 @@ var DomSurface = class DomSurface {
 			hud_canvas: this.hud_canvas,
 			camera: this.camera,
 			editor,
-			handle: { detach: () => {} }
+			handle: { detach: () => {} },
+			is_attended: () => this.attention.is_attended()
 		});
 		if (options.gestures !== false) applyDefaultGestures(this.gestures);
 		const unsub = editor.subscribe(() => {
 			this.current_tool = editor.state.tool;
+			this.hud.setVectorSelectionMode(this.current_tool.type === "lasso" ? "lasso" : "marquee");
+			this.hud.setVectorBendMode(this.current_tool.type === "bend" ? "always" : "auto");
 			this.render();
 			this.sync_surface_selection();
 			this.hud.setPixelGrid({
@@ -1920,6 +1852,23 @@ var DomSurface = class DomSurface {
 					this.pending_insert = null;
 				}
 			}
+			if (this.vector_edit && !this.active_preview) {
+				const ses = this.vector_edit;
+				const live_source = this.editor_internal().doc.is_vector_edit_target(ses.node_id);
+				const had_selection = ses.selected_vertices.length > 0 || ses.selected_segments.length > 0 || ses.selected_tangents.length > 0;
+				if (live_source === null || live_source.kind !== ses.source.kind) {
+					if (had_selection) {
+						ses.clear_selection();
+						this.sync_selection_mirror();
+					}
+				} else {
+					const live_d = source_to_session_d(live_source);
+					if (live_d !== ses.last_seen_d) {
+						ses.reconcile_after_external_mutation(live_d);
+						if (had_selection) this.sync_selection_mirror();
+					}
+				}
+			}
 			this.request_redraw();
 		});
 		this.teardown.push(unsub);
@@ -1953,7 +1902,7 @@ var DomSurface = class DomSurface {
 				if (computed === "") return null;
 				return {
 					computed,
-					resolved_paint: parse_paint(computed)
+					resolved_paint: paint.parse(computed)
 				};
 			}
 		});
@@ -2005,8 +1954,8 @@ var DomSurface = class DomSurface {
 		});
 		this.teardown.push(() => internal.set_surface_hover_override_driver(null));
 	}
-	paint(_snapshot) {}
 	hit_test(x, y) {
+		if (this.vector_edit) return null;
 		return this.pick_at(x, y, false);
 	}
 	/** Element-walk under (x, y) → first ancestor with `ID_ATTR`. When
@@ -2034,7 +1983,7 @@ var DomSurface = class DomSurface {
 	*      `<text>` / `<use>` / transformed nodes). Tolerance is screen-
 	*      CSS-px, converted to world units via `camera.zoom` so the band
 	*      stays the same width on screen regardless of zoom. Has known
-	*      issues — see `docs/wg/feat-svg-editor/hit-test.md`.
+	*      issues — see https://grida.co/docs/wg/feat-svg-editor/hit-test.
 	*
 	*    - **`<= 0` (legacy elementFromPoint)** — opt-out of the cmath
 	*      picker. Uses the browser's painted-pixel hit-test plus a
@@ -2112,15 +2061,17 @@ var DomSurface = class DomSurface {
 		if (this._z_order_cache.length > 0 && this._z_order_cache[0] === root_id) return this._z_order_cache.slice(1);
 		return this._z_order_cache.filter((id) => id !== root_id);
 	}
-	on_input(_listener) {
-		return () => {};
-	}
 	dispose() {
 		if (this.text_edit) {
 			this.text_edit.cancel();
 			this.text_edit = null;
 			this.text_edit_target = null;
 		}
+		if (this.vector_edit) {
+			this.vector_edit = null;
+			this.vector_edit_region_baseline = null;
+			this.hud.setVectorSelection(null);
+		}
 		this.gestures._dispose();
 		this.translate_orchestrator.cancel();
 		this.resize_orchestrator.cancel();
@@ -2188,6 +2139,17 @@ var DomSurface = class DomSurface {
 		style.left = "0";
 		style.top = "0";
 		style.transformOrigin = "0 0";
+		const vb = this.svg_root.getAttribute("viewBox");
+		if (vb) {
+			const parts = vb.split(/[\s,]+/).map(Number);
+			if (parts.length === 4 && parts.every((n) => Number.isFinite(n))) {
+				const [, , w, h] = parts;
+				if (w > 0 && h > 0) {
+					style.width = `${w}px`;
+					style.height = `${h}px`;
+				}
+			}
+		}
 	}
 	/**
 	* Push the current camera transform to the SVG as a CSS `matrix(...)`.
@@ -2487,14 +2449,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({
@@ -2835,6 +2798,17 @@ var DomSurface = class DomSurface {
 				}
 			}
 		}
+		if (tool.type === "insert-text") {
+			if (kind === "pointer_down" && e.button === 0) {
+				const world = this.camera.screen_to_world({
+					x,
+					y
+				});
+				this.editor.set_tool({ type: "cursor" });
+				this.begin_text_insert(world);
+				return;
+			}
+		}
 		const button = e.button === 0 ? "primary" : e.button === 2 ? "secondary" : "middle";
 		let event;
 		if (kind === "pointer_move") event = {
@@ -2893,7 +2867,7 @@ var DomSurface = class DomSurface {
 	}
 	/** Transition `armed` → `drawing`: open `insert_preview` + snap session. */
 	arm_to_draw(armed) {
-		const session = this.editor.commands.insert_preview(armed.tag, initial_attrs(armed.tag, armed.anchor));
+		const session = this.editor.commands.insert_preview(armed.tag, insertions.initial_attrs(armed.tag, armed.anchor));
 		const snap_session = this.editor.style.snap_enabled && (armed.tag === "rect" || armed.tag === "ellipse") ? this.open_snap_session_for([session.id]) : null;
 		this.pending_insert = {
 			phase: "drawing",
@@ -2915,7 +2889,7 @@ var DomSurface = class DomSurface {
 			shift: mods.shift,
 			alt: mods.alt
 		};
-		drawing.session.update(compute_drag_attrs(drawing.tag, drawing.anchor, world, dm));
+		drawing.session.update(insertions.compute_drag_attrs(drawing.tag, drawing.anchor, world, dm));
 	}
 	/** Commit on pointer-up. `armed` → one-shot `commands.insert` with
 	*  `default_attrs` (click-no-drag, never touches the IR mid-gesture).
@@ -2923,7 +2897,7 @@ var DomSurface = class DomSurface {
 	commit_insert_gesture(screen_pt, mods) {
 		const cur = this.pending_insert;
 		if (!cur) return;
-		if (cur.phase === "armed") this.editor.commands.insert(cur.tag, default_attrs(cur.tag, cur.anchor));
+		if (cur.phase === "armed") this.editor.commands.insert(cur.tag, insertions.default_attrs(cur.tag, cur.anchor));
 		else {
 			this.push_drawing_frame(cur, screen_pt, mods);
 			cur.session.commit();
@@ -2974,11 +2948,20 @@ var DomSurface = class DomSurface {
 			this.container.style.cursor = "crosshair";
 			return;
 		}
+		if (this.current_tool.type === "insert-text") {
+			this.container.style.cursor = "text";
+			return;
+		}
 		this.container.style.cursor = this.hud.cursorCss();
 	}
 	on_keydown(e) {
 		if (this.text_edit) return;
-		if (e.code === "Escape") this.cancel_in_flight();
+		if (e.code !== "Escape" && !this.attention.is_attended()) return;
+		if (e.code === "Escape") {
+			const canceled = this.cancel_in_flight();
+			if (!this.attention.is_attended()) return;
+			if (!canceled && this.vector_edit) this.exit_vector_edit();
+		}
 		if ((this.active_preview || this.translate_orchestrator.has_active_session() || this.resize_orchestrator.has_active_session() || this.rotate_orchestrator.has_active_session() || this.pending_insert) && e.code !== "Escape") return;
 		if (this.editor.keymap.claims(e)) e.preventDefault();
 		this.editor.keymap.dispatch(e);
@@ -2991,6 +2974,15 @@ var DomSurface = class DomSurface {
 			case "deselect_all":
 				this.editor.commands.deselect();
 				return;
+			case "clear_vector_selection": {
+				if (!this.vector_edit) return;
+				const before = this.vector_edit.snapshot_selection();
+				this.vector_edit.clear_selection();
+				this.sync_selection_mirror();
+				this.redraw();
+				this.record_vector_selection_change(before, "clear vector selection");
+				return;
+			}
 			case "translate":
 				this.handle_translate(intent);
 				return;
@@ -3003,6 +2995,9 @@ var DomSurface = class DomSurface {
 			case "marquee_select":
 				this.handle_marquee(intent);
 				return;
+			case "lasso_select":
+				this.handle_lasso_select(intent);
+				return;
 			case "set_endpoint":
 				this.handle_set_endpoint(intent);
 				return;
@@ -3010,6 +3005,33 @@ var DomSurface = class DomSurface {
 				this.editor.commands.select(intent.id);
 				this.editor.enter_content_edit(intent.id);
 				return;
+			case "exit_content_edit":
+				this.exit_vector_edit();
+				return;
+			case "select_vertex":
+				this.handle_select_vertex(intent);
+				return;
+			case "translate_vertices":
+				this.handle_translate_vertices(intent);
+				return;
+			case "translate_vector_selection":
+				this.handle_translate_vector_selection(intent);
+				return;
+			case "select_segment":
+				this.handle_select_segment(intent);
+				return;
+			case "select_tangent":
+				this.handle_select_tangent(intent);
+				return;
+			case "set_tangent":
+				this.handle_set_tangent_intent(intent);
+				return;
+			case "split_segment":
+				this.handle_split_segment(intent);
+				return;
+			case "bend_segment":
+				this.handle_bend_segment(intent);
+				return;
 			case "cancel_gesture":
 				this.cancel_in_flight();
 				return;
@@ -3049,7 +3071,7 @@ var DomSurface = class DomSurface {
 	}
 	handle_resize(intent) {
 		if (intent.ids.length === 0) return;
-		for (const id of intent.ids) if (!is_resizable_node(this.editor.document, id)) return;
+		for (const id of intent.ids) if (!resize_pipeline.intent.is_resizable_node(this.editor.document, id)) return;
 		const dir = intent.anchor;
 		let target_width;
 		let target_height;
@@ -3097,9 +3119,7 @@ var DomSurface = class DomSurface {
 		for (const v of verdicts.values()) {
 			if (v.kind !== "refuse") continue;
 			const message = v.reason === "non-trivial-transform" ? "Cannot rotate cleanly — element has a composite transform. Use Flatten Transform first." : v.reason === "text-with-glyph-rotate" ? "Cannot rotate — text has per-glyph rotation. Edit `rotate=` or remove it first." : v.reason === "css-property-transform" ? "Cannot rotate — transform is set via CSS. Move the declaration to the `transform` attribute first." : "Cannot rotate — element has an animated transform. Remove `<animateTransform>` first.";
-			const hud = this.hud;
-			if (typeof hud.setTransientToast === "function") hud.setTransientToast(message);
-			else console.warn(`[svg-editor] ${message}`);
+			console.warn(`[svg-editor] ${message}`);
 			return;
 		}
 	}
@@ -3184,7 +3204,28 @@ var DomSurface = class DomSurface {
 			y: t.y
 		};
 	}
+	/**
+	* Capture the vector-edit sub-selection on the first region-gesture
+	* preview, and reuse it for every subsequent preview + the commit.
+	* Anchors additive merging and tangent-candidate eligibility to the
+	* gesture-start state so they don't shift mid-drag. Shared by marquee
+	* and lasso — both gestures emit a preview-per-move, both consume the
+	* same baseline. See `vector_edit_region_baseline` doc-comment for the
+	* full rationale. Caller must have a non-null `this.vector_edit`.
+	*/
+	ensure_region_baseline() {
+		if (!this.vector_edit_region_baseline) this.vector_edit_region_baseline = {
+			vertices: this.vector_edit.selected_vertices.slice(),
+			segments: this.vector_edit.selected_segments.slice(),
+			tangents: this.vector_edit.selected_tangents.map((t) => [t[0], t[1]])
+		};
+		return this.vector_edit_region_baseline;
+	}
 	handle_marquee(intent) {
+		if (this.vector_edit) {
+			this.handle_marquee_vectors(intent);
+			return;
+		}
 		if (intent.phase !== "commit") return;
 		const ids = [];
 		for (const id of this.element_index.keys()) {
@@ -3199,7 +3240,170 @@ var DomSurface = class DomSurface {
 		}
 		this.editor.commands.select(ids, { mode: intent.additive ? "add" : "replace" });
 	}
-	enter_content_edit(id) {
+	/**
+	* Vector marquee predicate — applies the **vertex-priority precedence
+	* rule** ported from the main editor:
+	*
+	*   1. Vertices: keep those whose container-space position falls inside
+	*      the marquee rect.
+	*   2. Tangents: keep only those at the (new) selection's neighbouring
+	*      vertices whose control point falls inside the rect.
+	*   3. Segments: keep only segments **fully contained** in the rect AND
+	*      whose endpoints are NOT among the selected vertices. (If a vertex
+	*      is selected, the segments meeting it would double-credit the
+	*      drag, so they're dropped — "vertex priority.")
+	*
+	* The rect comes in container CSS-px (HUD's frame). We project it back
+	* to path-local by applying the inverse-CTM linear part to its size and
+	* shifting its position via `project_delta_inverse_ctm` against the
+	* top-left in doc-space — but a cleaner approach is to project each
+	* vertex/tangent/segment-sample into doc-space and test against the rect
+	* directly. For consistency with how `vector_of` projects, we do the
+	* "project geometry to doc-space, test against doc-space rect" approach.
+	*/
+	handle_marquee_vectors(intent) {
+		if (!this.vector_edit) return;
+		const node_id = this.vector_edit.node_id;
+		const el = this.element_index.get(node_id);
+		if (!(el instanceof SVGGraphicsElement)) return;
+		if (typeof el.getScreenCTM !== "function") return;
+		const ctm = el.getScreenCTM();
+		if (!ctm) return;
+		const cr = this.container.getBoundingClientRect();
+		const offset = [-cr.left + this.container.scrollLeft, -cr.top + this.container.scrollTop];
+		const model = this.session_model();
+		if (!model) return;
+		const rect = intent.rect;
+		const baseline = this.ensure_region_baseline();
+		const pre_selection = {
+			vertices: baseline.vertices,
+			segments: baseline.segments,
+			tangents: baseline.tangents
+		};
+		const candidates = marquee.subpath_select_candidates(model, pre_selection, (p) => project_point_through_ctm(p[0], p[1], ctm, offset));
+		const vertex_hits = marquee.points_in_rect(candidates.vertices, rect);
+		const tangent_hits = marquee.points_in_rect(candidates.tangents, rect);
+		const rect_local = inverse_project_rect(rect, ctm, offset);
+		const vertex_hit_set = new Set(vertex_hits);
+		const segment_hits = [];
+		if (rect_local) {
+			const segs = model.snapshot().segments;
+			for (const sid of candidates.segments) {
+				const s = segs[sid];
+				if (vertex_hit_set.has(s.a) || vertex_hit_set.has(s.b)) continue;
+				if (model.segmentContainedByRect(sid, rect_local)) segment_hits.push(sid);
+			}
+		}
+		const merged = marquee.merge_subpath_hits(pre_selection, {
+			vertices: vertex_hits,
+			segments: segment_hits,
+			tangents: tangent_hits
+		}, intent.additive);
+		this.vector_edit.set_selection(merged);
+		this.sync_selection_mirror();
+		if (intent.phase === "commit") {
+			const baseline_snapshot = Object.freeze({
+				vertices: baseline.vertices,
+				segments: baseline.segments,
+				tangents: baseline.tangents
+			});
+			this.vector_edit_region_baseline = null;
+			this.record_vector_selection_change(baseline_snapshot, "marquee select");
+		}
+		this.redraw();
+	}
+	/**
+	* Lasso (freeform polygon) sub-selection — vector analogue of
+	* `handle_marquee`. Per the main editor's decision
+	* (editor/grida-canvas/reducers/methods/vector.ts:163–291 +
+	* event-target.reducer.ts:629–641) lasso targets **vertices and
+	* tangents only** — segments are NOT tested against the polygon. The
+	* segment-vs-region test is rect-only and lives in the marquee path.
+	*
+	* Lifecycle / baseline behaviour matches marquee: snapshot on first
+	* preview, reuse for additive merge and tangent-eligibility, clear on
+	* commit and on vector-edit exit. Scene (non-vector-edit) lasso is a
+	* follow-up.
+	*/
+	handle_lasso_select(intent) {
+		if (!this.vector_edit) return;
+		const node_id = this.vector_edit.node_id;
+		const el = this.element_index.get(node_id);
+		if (!(el instanceof SVGGraphicsElement)) return;
+		if (typeof el.getScreenCTM !== "function") return;
+		const ctm = el.getScreenCTM();
+		if (!ctm) return;
+		const cr = this.container.getBoundingClientRect();
+		const offset = [-cr.left + this.container.scrollLeft, -cr.top + this.container.scrollTop];
+		const model = this.session_model();
+		if (!model) return;
+		const polygon = intent.polygon;
+		if (polygon.length < 3) return;
+		const baseline = this.ensure_region_baseline();
+		const pre_selection = {
+			vertices: baseline.vertices,
+			segments: baseline.segments,
+			tangents: baseline.tangents
+		};
+		const candidates = marquee.subpath_select_candidates(model, pre_selection, (p) => project_point_through_ctm(p[0], p[1], ctm, offset));
+		const vertex_hits = marquee.points_in_polygon(candidates.vertices, polygon);
+		const tangent_hits = marquee.points_in_polygon(candidates.tangents, polygon);
+		const merged = marquee.merge_subpath_hits(pre_selection, {
+			vertices: vertex_hits,
+			segments: [],
+			tangents: tangent_hits
+		}, intent.additive);
+		this.vector_edit.set_selection(merged);
+		this.sync_selection_mirror();
+		if (intent.phase === "commit") {
+			const baseline_snapshot = Object.freeze({
+				vertices: baseline.vertices,
+				segments: baseline.segments,
+				tangents: baseline.tangents
+			});
+			this.vector_edit_region_baseline = null;
+			this.record_vector_selection_change(baseline_snapshot, "lasso select");
+		}
+		this.redraw();
+	}
+	/**
+	* Dispatched by the editor when `enter_content_edit(id)` is called. The
+	* editor has already gated on text-OR-path eligibility; this method
+	* routes on the actual tag.
+	*/
+	enter_content_edit(id) {
+		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 (this.editor_internal().doc.is_vector_edit_target(id) !== null) return this.enter_vector_edit(id);
+		return false;
+	}
+	/**
+	* Place a new single-line `<text>` at `world` and immediately enter
+	* content-edit on it. Creation + first edit are bracketed in one history
+	* preview (via `insert_text_preview`): committing with content is one
+	* undo step, exiting empty discards the node entirely (empty-equals-
+	* delete). The bracket is finalized in {@link enter_text_edit}'s
+	* commit/cancel callbacks via `this.pending_text_insert`.
+	*
+	* Default font appearance lives in `core/insertions.ts`
+	* (`default_text_attrs`), alongside the shape insertion defaults — not
+	* hard-coded here — so the per-element insert semantics stay in core (P3).
+	*/
+	begin_text_insert(world) {
+		if (this.text_edit || this.vector_edit) return;
+		const session = this.editor_internal().insert_text_preview(insertions.default_text_attrs(world));
+		this.pending_text_insert = {
+			id: session.id,
+			session
+		};
+		this.editor.enter_content_edit(session.id);
+		if (this.text_edit_target !== session.id) {
+			this.pending_text_insert = null;
+			session.discard();
+		}
+	}
+	enter_text_edit(id) {
 		if (this.text_edit) return false;
 		const el = this.element_index.get(id);
 		if (!(el instanceof SVGElement)) return false;
@@ -3215,15 +3419,6 @@ var DomSurface = class DomSurface {
 		const text_surface = new SvgTextSurface(this.element_index.get(id) ?? el);
 		const is_mac = typeof navigator !== "undefined" && /Mac|iPod|iPhone|iPad/.test(navigator.userAgent);
 		let settled = false;
-		const cleanup_after_commit_or_cancel = () => {
-			this.editor.commands.set_mode("select");
-			this.render();
-			this.sync_surface_selection();
-			this.sync_cursor();
-			this.redraw();
-			this.text_edit = null;
-			this.text_edit_target = null;
-		};
 		this.text_edit = createTextEditor({
 			container: this.container,
 			initialText: this.text_edit_original,
@@ -3239,16 +3434,12 @@ var DomSurface = class DomSurface {
 				onCommit: (final_text) => {
 					if (settled) return;
 					settled = true;
-					doc.doc.set_text(id, this.text_edit_original);
-					cleanup_after_commit_or_cancel();
-					if (final_text !== this.text_edit_original) this.editor.commands.set_text(final_text);
+					this.finalize_text_exit(id, final_text);
 				},
 				onCancel: () => {
 					if (settled) return;
 					settled = true;
-					doc.doc.set_text(id, this.text_edit_original);
-					cleanup_after_commit_or_cancel();
-					doc.emit();
+					this.finalize_text_exit(id, this.text_edit_original);
 				},
 				onUndoFallthrough: () => {
 					this.text_edit?.commit();
@@ -3262,6 +3453,726 @@ var DomSurface = class DomSurface {
 		});
 		return true;
 	}
+	/**
+	* Exit inline text-edit back to select mode. P4 — observers should see a
+	* consistent post-edit state, so do all observable mutations + surface
+	* syncs first, then clear the text-edit handles last (so anything polling
+	* "is text-edit active?" still says yes until the world is settled).
+	*/
+	cleanup_text_edit() {
+		this.editor.commands.set_mode("select");
+		this.render();
+		this.sync_surface_selection();
+		this.sync_cursor();
+		this.redraw();
+		this.text_edit = null;
+		this.text_edit_target = null;
+	}
+	/**
+	* Realize the result of a text content-edit session and exit. `result`
+	* is the text that should remain — the typed text on commit, the original
+	* on cancel. Implements the empty-equals-delete rule (design:
+	* docs/wg/feat-svg-editor/text-tool.md): an empty result removes the node.
+	* (see test/svg-editor-text-empty-delete.md)
+	*
+	* The empty-equals-delete decision is pure and lives in
+	* {@link resolve_text_exit} (`core/text-edit.ts`) — tested headlessly.
+	* This method is the thin dispatcher that realizes each action against
+	* the surface + editor.
+	*/
+	finalize_text_exit(id, result) {
+		const internal = this.editor_internal();
+		const insert = this.pending_text_insert;
+		this.pending_text_insert = null;
+		const action = resolve_text_exit({
+			origin: insert && insert.id === id ? "fresh" : "existing",
+			result,
+			original: this.text_edit_original
+		});
+		if (action.kind === "commit_insert" || action.kind === "discard_insert") {
+			if (!insert) return;
+			if (action.kind === "discard_insert") {
+				this.cleanup_text_edit();
+				insert.session.discard();
+			} else {
+				this.cleanup_text_edit();
+				insert.session.commit();
+			}
+			return;
+		}
+		internal.doc.set_text(id, this.text_edit_original);
+		this.cleanup_text_edit();
+		switch (action.kind) {
+			case "remove":
+				this.editor.commands.select(id);
+				this.editor.commands.remove();
+				break;
+			case "set_text":
+				this.editor.commands.set_text(action.value);
+				break;
+			case "noop":
+				internal.emit();
+				break;
+			default:
+		}
+	}
+	/**
+	* Enter path-vertex-edit mode. Mirrors `enter_text_edit` shape: capture
+	* the original `d`, flip the editor mode, push a vector-selection mirror
+	* to the HUD, and start serving `vectorOf` from the live session.
+	*
+	* Exit happens via `exit_vector_edit` (Esc / `set_mode("select")` /
+	* dblclick away). On exit, any in-flight preview is discarded; committed
+	* intermediate states stay (each gesture's commit was its own history
+	* entry, per the gesture-bracketed history doctrine).
+	*
+	* The enter is itself a history step (tagged `vector-mode-enter`) so
+	* undo from inside vector-edit reverts the entry — symmetric to the
+	* `vector-mode-exit` push in {@link exit_vector_edit}. Both deltas
+	* delegate to the unchecked {@link _do_enter_vector_edit} /
+	* {@link _do_exit_vector_edit} helpers; the public wrappers below own
+	* the history side, the unchecked helpers own the state mutation.
+	*/
+	enter_vector_edit(id) {
+		if (this.vector_edit) return false;
+		if (!this._do_enter_vector_edit(id)) return false;
+		const internal = this.editor_internal();
+		const node_id = id;
+		const preview = internal.history.preview("enter vector edit");
+		preview.set({
+			providerId: "svg-editor",
+			descriptor: { kind: "vector-mode-enter" },
+			apply: () => {
+				this._do_enter_vector_edit(node_id);
+			},
+			revert: () => {
+				this._do_exit_vector_edit();
+			}
+		});
+		preview.commit();
+		return true;
+	}
+	/**
+	* Discard any in-flight preview, clear the vector-edit session, and return
+	* the editor to select mode. Safe to call when no vector-edit is active
+	* (no-op). Idempotent.
+	*
+	* Pushes a `vector-mode-exit` history step that closes over the
+	* session's `node_id` and its final sub-selection, so undo re-enters
+	* the same path and restores the selection the user was about to
+	* leave. Pairs with {@link enter_vector_edit}.
+	*/
+	exit_vector_edit() {
+		if (!this.vector_edit) return;
+		const node_id = this.vector_edit.node_id;
+		const final_selection = this.vector_edit.snapshot_selection();
+		this._do_exit_vector_edit();
+		const preview = this.editor_internal().history.preview("exit vector edit");
+		preview.set({
+			providerId: "svg-editor",
+			descriptor: { kind: "vector-mode-exit" },
+			apply: () => {
+				this._do_exit_vector_edit();
+			},
+			revert: () => {
+				if (this._do_enter_vector_edit(node_id)) {
+					this.vector_edit?.restore_selection(final_selection);
+					this.sync_selection_mirror();
+					this.redraw();
+				}
+			}
+		});
+		preview.commit();
+	}
+	/**
+	* Unchecked enter — performs the mode flip + HUD wiring without
+	* pushing to history. Called by {@link enter_vector_edit} (user-facing,
+	* which pushes the delta) and by the exit-delta's revert (history-
+	* driven re-entry on undo). Returns `false` if the node has no usable
+	* `d` attribute, leaving editor state untouched.
+	*/
+	_do_enter_vector_edit(id) {
+		if (this.vector_edit) return false;
+		const source = this.editor_internal().doc.is_vector_edit_target(id);
+		if (source === null) return false;
+		const session_d = source_to_session_d(source);
+		this.vector_edit = new VectorEditSession(id, source, session_d);
+		this.editor.commands.set_mode("edit-content");
+		this.sync_selection_mirror();
+		this.sync_surface_selection();
+		this.sync_cursor();
+		this.redraw();
+		return true;
+	}
+	/**
+	* Unchecked exit — counterpart to {@link _do_enter_vector_edit}. No
+	* history push. Safe to call when no session is active.
+	*/
+	_do_exit_vector_edit() {
+		if (!this.vector_edit) return;
+		if (this.active_preview && (this.active_preview.kind === "vector_vertex_translate" || this.active_preview.kind === "vector_set_tangent" || this.active_preview.kind === "vector_bend_segment" || this.active_preview.kind === "vector_translate_selection")) {
+			this.active_preview.session.discard();
+			this.active_preview = null;
+		}
+		this.vector_edit = null;
+		this.vector_edit_region_baseline = null;
+		this.hud.setVectorSelection(null);
+		if (this.current_tool.type === "lasso" || this.current_tool.type === "bend") this.editor.set_tool({ type: "cursor" });
+		this.editor.commands.set_mode("select");
+		this.sync_surface_selection();
+		this.sync_cursor();
+		this.redraw();
+	}
+	/**
+	* `vectorOf` provider for the HUD. Returns the live PathSnapshot for the
+	* named node when a vector-edit session is active for it; otherwise null.
+	* HUD calls this each frame; cheap enough to recompute (snapshot just
+	* copies the underlying network's arrays via the model's getter).
+	*/
+	vector_of(id) {
+		if (!this.vector_edit || this.vector_edit.node_id !== id) return null;
+		const model = this.active_preview_model_for(id) ?? this.session_model();
+		if (!model) return null;
+		const snap = model.snapshot();
+		const el = this.element_index.get(id);
+		if (!(el instanceof SVGGraphicsElement)) return null;
+		if (typeof el.getScreenCTM !== "function") return null;
+		const ctm = el.getScreenCTM();
+		if (!ctm) return null;
+		const cr = this.container.getBoundingClientRect();
+		const offset = [-cr.left + this.container.scrollLeft, -cr.top + this.container.scrollTop];
+		return {
+			vertices: Array.from({ length: snap.vertices.length }, (_, i) => {
+				const v = snap.vertices[i];
+				return project_point_through_ctm(v[0], v[1], ctm, offset);
+			}),
+			segments: snap.segments.map((s) => {
+				const va = snap.vertices[s.a];
+				const vb = snap.vertices[s.b];
+				const a_ctrl_local = [va[0] + s.ta[0], va[1] + s.ta[1]];
+				const b_ctrl_local = [vb[0] + s.tb[0], vb[1] + s.tb[1]];
+				return {
+					a: s.a,
+					b: s.b,
+					a_control: project_point_through_ctm(a_ctrl_local[0], a_ctrl_local[1], ctm, offset),
+					b_control: project_point_through_ctm(b_ctrl_local[0], b_ctrl_local[1], ctm, offset)
+				};
+			}),
+			neighbours: model.neighbouringVertices({
+				vertices: this.vector_edit.selected_vertices,
+				segments: this.vector_edit.selected_segments,
+				tangents: this.vector_edit.selected_tangents
+			}),
+			origin: [0, 0]
+		};
+	}
+	/**
+	* The session's in-memory PathModel-form `d`. For `<path>` sources
+	* this stays in lock-step with `doc.get_attr(id, "d")`; for
+	* `<line>` / `<polyline>` / `<polygon>` sources the document holds
+	* native attrs and the session-d is the lingua-franca view that
+	* gesture handlers parse from and write back to via
+	* {@link apply_session_d}. Returns `null` if no session is active.
+	*/
+	read_session_d() {
+		if (!this.vector_edit) return null;
+		return this.vector_edit.current_d;
+	}
+	/**
+	* Derive a fresh `PathModel` from the current `d` for the path under
+	* edit. Computed on read — there is no cached copy held on the session.
+	* See `vector-edit/session.ts` for the doctrine ("d is the live store").
+	*/
+	session_model() {
+		const d = this.read_session_d();
+		if (d === null) return null;
+		return PathModel.fromSvgPathD(d);
+	}
+	/**
+	* Republish the vector-edit sub-selection to the HUD. No-op when no
+	* session is open. Every selection-changing handler ends with this so
+	* the surface mirror stays in lock-step with `this.vector_edit` — the
+	* inline `setVectorSelection({ node_id, vertices, segments, tangents })`
+	* block was repeated at 6+ sites before this collapse.
+	*/
+	sync_selection_mirror() {
+		if (!this.vector_edit) return;
+		this.hud.setVectorSelection({
+			node_id: this.vector_edit.node_id,
+			vertices: this.vector_edit.selected_vertices,
+			segments: this.vector_edit.selected_segments,
+			tangents: this.vector_edit.selected_tangents
+		});
+	}
+	/**
+	* Replay the session-side effects of a committed vector-edit delta onto
+	* the LIVE `this.vector_edit` session — but only if it is still aimed at
+	* the same node. Geometry restoration is the closure's `commit(d)` job
+	* (document-level, always safe); this method handles the bits the
+	* geometry write cannot reach on its own: advancing `last_seen_d` so
+	* the external-mutation watcher doesn't pounce, and re-installing the
+	* captured sub-selection.
+	*
+	* Closures used to call `session.mark_seen(...)` / `session.restore_selection(...)`
+	* on a `const session = this.vector_edit` captured at gesture start.
+	* After exit + undo-exit + undo-geometry, that capture pointed at the
+	* disposed session while the live session was a fresh one — geometry
+	* still restored correctly (via `commit`), but sub-selection didn't,
+	* and the live session's stale `last_seen_d` would then cause the
+	* watcher to clear the new session's selection on its next tick.
+	*
+	* Pass `d = null` for selection-only deltas (no geometry change → no
+	* watermark advance).
+	*/
+	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);
+			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,
+	* marquee / lasso commit, clear-vector-selection) AFTER the
+	* `VectorEditSession` has been mutated to the new state. `before` is the
+	* snapshot captured before the mutation; the current session state is
+	* captured here as `after`.
+	*
+	* Tagged with `descriptor: { kind: "vector-selection" }` so hosts that
+	* want Figma-style "skip selection on undo" can filter on the
+	* descriptor without inspecting closure internals. Default behavior:
+	* standalone vector-selection IS undoable.
+	*
+	* No-op when the snapshot is unchanged — avoids spamming the stack
+	* with entries from clicks that resolve to the same state (e.g.
+	* clicking an already-selected vertex in `replace` mode).
+	*/
+	record_vector_selection_change(before, label) {
+		if (!this.vector_edit) return;
+		const after = this.vector_edit.snapshot_selection();
+		if (sub_selection_equal(before, after)) return;
+		const target_node_id = this.vector_edit.node_id;
+		const preview = this.editor_internal().history.preview(label);
+		preview.set({
+			providerId: "svg-editor",
+			descriptor: { kind: "vector-selection" },
+			apply: () => {
+				this.replay_vector_session_state(target_node_id, null, after);
+				this.redraw();
+			},
+			revert: () => {
+				this.replay_vector_session_state(target_node_id, null, before);
+				this.redraw();
+			}
+		});
+		preview.commit();
+	}
+	/** Resolve the in-flight `PathModel` for the named node id when a
+	*  vector-preview is active; null otherwise. */
+	active_preview_model_for(id) {
+		const ap = this.active_preview;
+		if (!ap) return null;
+		switch (ap.kind) {
+			case "vector_vertex_translate": return ap.node_id === id ? ap.preview_model : null;
+			case "vector_set_tangent": return ap.node_id === id ? ap.preview_model : null;
+			case "vector_bend_segment": return ap.node_id === id ? ap.preview_model : null;
+			case "vector_translate_selection": return ap.node_id === id ? ap.preview_model : null;
+			default: return null;
+		}
+	}
+	/**
+	* Apply a `select_vertex` intent. Updates the vector-edit session's sub-
+	* selection and pushes a fresh mirror to the HUD.
+	*/
+	handle_select_vertex(intent) {
+		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
+		const before = this.vector_edit.snapshot_selection();
+		this.vector_edit.select_vertex(intent.index, intent.mode);
+		this.sync_selection_mirror();
+		this.redraw();
+		this.record_vector_selection_change(before, "select vertex");
+	}
+	/**
+	* Apply a `select_segment` intent. Mirrors {@link handle_select_vertex}.
+	* Fired when the user clicks a segment OFF the ghost insertion knob —
+	* clicking the ghost itself fires `split_segment` instead.
+	*/
+	handle_select_segment(intent) {
+		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
+		const before = this.vector_edit.snapshot_selection();
+		this.vector_edit.select_segment(intent.segment, intent.mode);
+		this.sync_selection_mirror();
+		this.redraw();
+		this.record_vector_selection_change(before, "select segment");
+	}
+	/**
+	* Apply a `translate_vertices` intent. Mirrors the `set_endpoint` flow:
+	* - First frame opens a `history.preview` session capturing the original `d`.
+	* - Each subsequent preview frame applies a fresh translation FROM the
+	*   original baseline (so the cumulative delta on the intent stays correct
+	*   and we don't accumulate drift across frames).
+	* - The commit frame finalizes the preview; the session keeps its updated
+	*   model for the next gesture.
+	*
+	* The vector-edit session's `model` is updated to reflect the committed
+	* state (preview model is computed on the fly each frame from the
+	* baseline; only commit writes back into session.model).
+	*/
+	handle_translate_vertices(intent) {
+		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
+		const internal = this.editor_internal();
+		const node_id = intent.node_id;
+		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();
+			}
+			const initial_d = this.read_session_d();
+			if (initial_d === null) return;
+			const baseline_model = PathModel.fromSvgPathD(initial_d);
+			this.active_preview = {
+				kind: "vector_vertex_translate",
+				node_id,
+				promo: { token: null },
+				indices: [...intent.indices],
+				initial_d,
+				baseline_model,
+				before_selection: this.vector_edit.snapshot_selection(),
+				preview_model: baseline_model,
+				session: internal.history.preview("vector/translate-vertex")
+			};
+		}
+		const baseline_d = this.active_preview.initial_d;
+		const indices = this.active_preview.indices;
+		let local_dx = intent.dx;
+		let local_dy = intent.dy;
+		const el = this.element_index.get(node_id);
+		if (el instanceof SVGGraphicsElement && typeof el.getScreenCTM === "function") {
+			const ctm = el.getScreenCTM();
+			if (ctm) {
+				if (ctm.a * ctm.d - ctm.c * ctm.b !== 0) [local_dx, local_dy] = project_delta_inverse_ctm(intent.dx, intent.dy, ctm);
+			}
+		}
+		const preview_model = this.active_preview.baseline_model.translateVertices(indices, [local_dx, local_dy]);
+		const target_d = preview_model.toSvgPathD();
+		this.active_preview.preview_model = preview_model;
+		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(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(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.
+	*
+	* Mirrors main editor's `translate-vector-controls`
+	* (`editor/grida-canvas/reducers/tools/event-target.cem-vector.reducer.ts:667-675`).
+	* Translates the union of:
+	*
+	*   - selected vertices                       (authoritative sub-selection)
+	*   - endpoints of selected segments          (segment selection implies
+	*                                              its two endpoints translate)
+	*   - intent.additional_vertex_indices        (carried by segment drag so
+	*                                              endpoints translate even
+	*                                              when the segment isn't yet
+	*                                              in sub-selection — the
+	*                                              deferred select_segment was
+	*                                              canceled by drag promotion)
+	*
+	* AND delta-translates selected tangents, EXCLUDING tangents whose parent
+	* vertex is already in the translated set (mirrors `vector.ts:39-42`'s
+	* `getUXNeighbouringVertices`-style exclusion: the vertex move already
+	* carries its tangent controls, so double-applying would shift them
+	* twice). Mirror policy pinned to `"none"` during multi-translate; mirror
+	* behavior is reserved for the singleton-tangent curve gesture.
+	*
+	* Opens a dedicated `vector_translate_selection` preview so the
+	* vertex translate AND tangent delta apply atomically per frame.
+	*/
+	handle_translate_vector_selection(intent) {
+		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
+		const internal = this.editor_internal();
+		const node_id = intent.node_id;
+		const ses = this.vector_edit;
+		const current_d = this.read_session_d();
+		if (current_d === null) return;
+		const resolved_model = PathModel.fromSvgPathD(current_d);
+		const vertex_count = resolved_model.vertexCount();
+		const segment_snapshot = resolved_model.snapshot().segments;
+		const indices_set = /* @__PURE__ */ new Set();
+		const add_if_valid = (i) => {
+			if (i >= 0 && i < vertex_count) indices_set.add(i);
+		};
+		for (const v of ses.selected_vertices) add_if_valid(v);
+		for (const s of ses.selected_segments) {
+			const seg = segment_snapshot[s];
+			if (!seg) continue;
+			add_if_valid(seg.a);
+			add_if_valid(seg.b);
+		}
+		for (const v of intent.additional_vertex_indices) add_if_valid(v);
+		const tangent_refs = [];
+		for (const ref of ses.selected_tangents) {
+			if (indices_set.has(ref[0])) continue;
+			tangent_refs.push(ref);
+		}
+		if (indices_set.size === 0 && tangent_refs.length === 0) return;
+		const indices = Array.from(indices_set).sort((a, b) => a - b);
+		if (!this.active_preview || this.active_preview.kind !== "vector_translate_selection" || this.active_preview.node_id !== node_id || !array_shallow_equal(this.active_preview.indices, indices) || !sameTangentRefs(this.active_preview.tangent_refs, tangent_refs)) {
+			if (this.active_preview) {
+				if ("session" in this.active_preview) this.active_preview.session.discard();
+			}
+			const initial_d = this.read_session_d();
+			if (initial_d === null) return;
+			const baseline_model = PathModel.fromSvgPathD(initial_d);
+			const baseline_tangent_abs = tangent_refs.map((ref) => baseline_model.tangentAbsolute(ref, [0, 0]));
+			this.active_preview = {
+				kind: "vector_translate_selection",
+				node_id,
+				promo: { token: null },
+				indices: [...indices],
+				tangent_refs: [...tangent_refs],
+				initial_d,
+				before_selection: this.vector_edit.snapshot_selection(),
+				preview_model: baseline_model,
+				baseline_model,
+				baseline_tangent_abs,
+				session: internal.history.preview("vector/translate-selection")
+			};
+		}
+		const baseline_d = this.active_preview.initial_d;
+		let local_dx = intent.dx;
+		let local_dy = intent.dy;
+		const el = this.element_index.get(node_id);
+		if (el instanceof SVGGraphicsElement && typeof el.getScreenCTM === "function") {
+			const ctm = el.getScreenCTM();
+			if (ctm) {
+				if (ctm.a * ctm.d - ctm.c * ctm.b !== 0) [local_dx, local_dy] = project_delta_inverse_ctm(intent.dx, intent.dy, ctm);
+			}
+		}
+		const baseline_model = this.active_preview.baseline_model;
+		const baseline_tangent_abs = this.active_preview.baseline_tangent_abs;
+		let preview_model = indices.length > 0 ? baseline_model.translateVertices(indices, [local_dx, local_dy]) : baseline_model;
+		for (let i = 0; i < tangent_refs.length; i++) {
+			const baseline_abs = baseline_tangent_abs[i];
+			if (baseline_abs === null) continue;
+			preview_model = preview_model.setTangent(tangent_refs[i], [baseline_abs[0] + local_dx, baseline_abs[1] + local_dy], "none");
+		}
+		const target_d = preview_model.toSvgPathD();
+		this.active_preview.preview_model = preview_model;
+		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(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(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) {
+		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
+		const before = this.vector_edit.snapshot_selection();
+		this.vector_edit.select_tangent(intent.tangent, intent.mode);
+		this.sync_selection_mirror();
+		this.redraw();
+		this.record_vector_selection_change(before, "select tangent");
+	}
+	/**
+	* Tangent drag handler. Mirrors `handle_translate_vertices`:
+	*
+	* - First frame opens a `history.preview` session, captures `original_d`.
+	* - Each preview frame replays setTangent from the baseline model so
+	*   cumulative drift never accumulates.
+	* - Commit finalizes the preview and reseeds the session.
+	*
+	* `intent.pos` arrives in container CSS-px (HUD's doc-space). We project
+	* it back through the inverse-CTM to path-local before calling
+	* `PathModel.setTangent`.
+	*/
+	handle_set_tangent_intent(intent) {
+		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
+		const internal = this.editor_internal();
+		const node_id = intent.node_id;
+		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();
+			if (initial_d === null) return;
+			const baseline_model = PathModel.fromSvgPathD(initial_d);
+			this.active_preview = {
+				kind: "vector_set_tangent",
+				node_id,
+				promo: { token: null },
+				tangent: [intent.tangent[0], intent.tangent[1]],
+				initial_d,
+				baseline_model,
+				before_selection: this.vector_edit.snapshot_selection(),
+				preview_model: baseline_model,
+				session: internal.history.preview("vector/set-tangent")
+			};
+		}
+		const baseline_d = this.active_preview.initial_d;
+		const local_pos = this.project_doc_point_to_local(node_id, intent.pos);
+		if (!local_pos) return;
+		const preview_model = this.active_preview.baseline_model.setTangent(intent.tangent, local_pos, intent.mirror);
+		const target_d = preview_model.toSvgPathD();
+		this.active_preview.preview_model = preview_model;
+		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(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(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
+	* preview phase. After the split, the new vertex is auto-selected — this
+	* matches Figma's add-anchor behavior and prepares the user to immediately
+	* drag the newly inserted anchor.
+	*/
+	handle_split_segment(intent) {
+		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
+		const node_id = intent.node_id;
+		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 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(this.vector_geometry_step(node_id, target_d, baseline_d, promo, after_selection, before_selection));
+		split_session.commit();
+		this.redraw();
+	}
+	/**
+	* Bend a segment by dragging an interior point. Mirrors set_tangent —
+	* preview session opened on first frame, replays from baseline each
+	* frame, commits / reseeds on phase===commit.
+	*
+	* `frozen` is captured ONCE at session open from the baseline model;
+	* `vne.bendSegment` solves for new tangents against this snapshot, so
+	* the cumulative drag delta is correct without per-frame drift.
+	*/
+	handle_bend_segment(intent) {
+		if (!this.vector_edit || this.vector_edit.node_id !== intent.node_id) return;
+		const internal = this.editor_internal();
+		const node_id = intent.node_id;
+		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();
+			if (initial_d === null) return;
+			const baseline_model = PathModel.fromSvgPathD(initial_d);
+			const snap = baseline_model.snapshot();
+			const s = snap.segments[intent.segment];
+			if (!s) return;
+			const va = snap.vertices[s.a];
+			const vb = snap.vertices[s.b];
+			this.active_preview = {
+				kind: "vector_bend_segment",
+				node_id,
+				promo: { token: null },
+				segment: intent.segment,
+				ca: intent.ca,
+				frozen: {
+					a: [va[0], va[1]],
+					b: [vb[0], vb[1]],
+					ta: [s.ta[0], s.ta[1]],
+					tb: [s.tb[0], s.tb[1]]
+				},
+				initial_d,
+				baseline_model,
+				before_selection: this.vector_edit.snapshot_selection(),
+				preview_model: baseline_model,
+				session: internal.history.preview("vector/bend-segment")
+			};
+		}
+		const baseline_d = this.active_preview.initial_d;
+		const frozen = this.active_preview.frozen;
+		const local_cb = this.project_doc_point_to_local(node_id, intent.cb);
+		if (!local_cb) return;
+		const preview_model = this.active_preview.baseline_model.bendSegment(intent.segment, intent.ca, local_cb, frozen);
+		const target_d = preview_model.toSvgPathD();
+		this.active_preview.preview_model = preview_model;
+		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(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(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
+	* named element's local frame via inverse-CTM. Returns null if no CTM
+	* is available or the CTM is singular.
+	*/
+	project_doc_point_to_local(id, p) {
+		const el = this.element_index.get(id);
+		if (!(el instanceof SVGGraphicsElement)) return null;
+		if (typeof el.getScreenCTM !== "function") return null;
+		const ctm = el.getScreenCTM();
+		if (!ctm) return null;
+		const cr = this.container.getBoundingClientRect();
+		const offset_x = -cr.left + this.container.scrollLeft;
+		const offset_y = -cr.top + this.container.scrollTop;
+		const det = ctm.a * ctm.d - ctm.c * ctm.b;
+		if (det === 0) return null;
+		const px = p[0] - offset_x;
+		const py = p[1] - offset_y;
+		return [(ctm.d * (px - ctm.e) - ctm.c * (py - ctm.f)) / det, (-ctm.b * (px - ctm.e) + ctm.a * (py - ctm.f)) / det];
+	}
 	tag_of(id) {
 		return this.editor.tree().nodes.get(id)?.tag ?? "";
 	}
@@ -3294,25 +4205,8 @@ var DomSurface = class DomSurface {
 	bbox_world(id) {
 		const local = this.bbox_local(id);
 		if (!local) return null;
-		return project_local_bbox(local, this.editor.document.get_attr(id, "transform"));
-	}
-	/** 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);
+		const transform_str = this.editor.document.get_attr(id, "transform");
+		return transform.project(local, transform_str);
 	}
 	editor_internal() {
 		return this.editor._internal;
@@ -3321,13 +4215,92 @@ var DomSurface = class DomSurface {
 function numAttr(doc, id, name) {
 	return svg_parse.parse_number(doc.get_attr(id, name));
 }
+/** Order-sensitive shallow equality for tangent-ref arrays. */
+function sameTangentRefs(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i][0] !== b[i][0] || a[i][1] !== b[i][1]) return false;
+	return true;
+}
+/**
+* Affine projection of a point through a 2×3 CTM, then offset by a
+* container origin (in page CSS-px). Mirrors how `line_endpoints_in_container`
+* and `shape_of` (transformed branch) bridge from local SVG coords to the
+* HUD's container-CSS-px space (HUD keeps its own transform at identity;
+* the SVG carries the camera as a CSS transform, which getScreenCTM
+* folds in).
+*
+* Exported for headless test coverage — pure function, no DOM types.
+*/
+function project_point_through_ctm(px, py, ctm, container_offset) {
+	const [sx, sy] = cmath.vector2.transform([px, py], [[
+		ctm.a,
+		ctm.c,
+		ctm.e
+	], [
+		ctm.b,
+		ctm.d,
+		ctm.f
+	]]);
+	return [sx + container_offset[0], sy + container_offset[1]];
+}
+/**
+* Inverse of the CTM's linear part applied to a delta vector. Drops
+* translation. Used to convert a HUD-reported container-space drag delta
+* back to the path's local coord space for `PathModel.translateVertices`.
+*
+* Throws on a degenerate (det = 0) matrix — the caller is expected to
+* have a non-singular CTM for any visible element.
+*/
+function project_delta_inverse_ctm(dx, dy, ctm) {
+	if (ctm.a * ctm.d - ctm.c * ctm.b === 0) throw new Error("project_delta_inverse_ctm: singular CTM linear part");
+	const inv = cmath.transform.invert([[
+		ctm.a,
+		ctm.c,
+		0
+	], [
+		ctm.b,
+		ctm.d,
+		0
+	]]);
+	return cmath.vector2.transform([dx, dy], inv);
+}
+/**
+* Inverse-project a doc-space rect through a CTM + container offset back
+* into the element's local frame. The output is the AABB of the four
+* inverse-projected corners — when the CTM has a rotation component the
+* AABB is an approximation, but it matches what the user visually
+* expects from a screen-aligned marquee drag.
+*
+* Returns `null` when the CTM's linear part is singular (degenerate
+* camera) — the caller should skip any test that needs the local rect.
+*/
+function inverse_project_rect(rect, ctm, offset) {
+	if (ctm.a * ctm.d - ctm.c * ctm.b === 0) return null;
+	const inv = cmath.transform.invert([[
+		ctm.a,
+		ctm.c,
+		ctm.e
+	], [
+		ctm.b,
+		ctm.d,
+		ctm.f
+	]]);
+	const to_local = (px, py) => cmath.vector2.transform([px - offset[0], py - offset[1]], inv);
+	const corners = [
+		to_local(rect.x, rect.y),
+		to_local(rect.x + rect.width, rect.y),
+		to_local(rect.x, rect.y + rect.height),
+		to_local(rect.x + rect.width, rect.y + rect.height)
+	];
+	return cmath.rect.fromPoints(corners);
+}
 /** World-space viewport rect of an `<svg>` element. Prefers `viewBox`
 *  (the declared user-space rect — what the user perceives as canvas),
 *  falls back to `width`/`height` at (0,0). For nested `<svg>` with a
 *  positional `x`/`y`, the declared viewBox/(0,0) is in the nested
 *  element's OWN user space; callers are responsible for CTM
 *  projection if a different frame is desired. v1 nested-svg story is
-*  documented in docs/wg/feat-svg-editor/geometry.md as out of scope. */
+*  documented in ../docs/geometry.md as out of scope. */
 function svg_viewport_bounds(el) {
 	const vb = el.getAttribute("viewBox");
 	if (vb) {
@@ -3489,6 +4462,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) {
@@ -3497,9 +4500,9 @@ var SvgHitShapeDriver = class {
 	hit_shape_of(id) {
 		const doc = this.accessors.doc();
 		if (!doc) return null;
-		const intrinsic = hit_shape_of_doc(doc, id);
+		const intrinsic = hit_shape_svg.of_doc(doc, id);
 		if (intrinsic) return intrinsic;
-		if (is_transparent_tag(doc.tag_of(id))) return null;
+		if (hit_shape_svg.is_transparent_tag(doc.tag_of(id))) return null;
 		const bounds = this.accessors.bounds_of(id);
 		if (!bounds) return null;
 		return {
@@ -3512,4 +4515,4 @@ var SvgHitShapeDriver = class {
 	}
 };
 //#endregion
-export { Camera as a, MemoizedGeometryProvider as i, Gestures as n, DEFAULT_SNAP_OPTIONS as r, attach_dom_surface as t };
+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 };