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

package/dist/model-DIzZmeyf.mjs

@@ -0,0 +1,3677 @@
+import cmath from "@grida/cmath";
+import { svg_parse } from "@grida/svg/parse";
+import { SVGPathData, SVGPathDataTransformer, encodeSVGPath } from "@grida/svg/pathdata";
+import vn from "@grida/vn";
+//#region src/util/dom.ts
+/**
+* `true` when the document's active element is a text-input-like control
+* (input / textarea / contentEditable). Used by keymap + gesture defaults
+* to avoid hijacking keystrokes while the user is typing.
+*/
+function is_text_input_focused() {
+	if (typeof document === "undefined") return false;
+	const el = document.activeElement;
+	if (!el) return false;
+	const tag = el.tagName;
+	if (tag === "INPUT" || tag === "TEXTAREA") return true;
+	if (el.isContentEditable) return true;
+	return false;
+}
+//#endregion
+//#region src/util/equal.ts
+function array_shallow_equal(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+//#endregion
+//#region src/core/group.ts
+let group;
+(function(_group) {
+	const STRUCTURAL_GRAPHICS = _group.STRUCTURAL_GRAPHICS = new Set([
+		"g",
+		"defs",
+		"svg",
+		"use",
+		"image",
+		"switch",
+		"foreignObject",
+		"path",
+		"rect",
+		"circle",
+		"ellipse",
+		"line",
+		"polyline",
+		"polygon",
+		"text",
+		"a"
+	]);
+	const CONSTRAINED_PARENT = _group.CONSTRAINED_PARENT = new Set([
+		"text",
+		"tspan",
+		"defs",
+		"clipPath",
+		"mask",
+		"pattern",
+		"marker",
+		"symbol",
+		"filter",
+		"linearGradient",
+		"radialGradient",
+		"animateMotion",
+		"switch"
+	]);
+	function plan(doc, ids) {
+		if (ids.length === 0) return null;
+		const parent = doc.parent_of(ids[0]);
+		if (parent === null) return null;
+		for (const id of ids) {
+			if (doc.parent_of(id) !== parent) return null;
+			if (!STRUCTURAL_GRAPHICS.has(doc.tag_of(id))) return null;
+		}
+		if (CONSTRAINED_PARENT.has(doc.tag_of(parent))) return null;
+		const siblings = doc.element_children_of(parent);
+		const sibling_index = /* @__PURE__ */ new Map();
+		for (let i = 0; i < siblings.length; i++) sibling_index.set(siblings[i], i);
+		const indices = [];
+		for (const id of ids) {
+			const i = sibling_index.get(id);
+			if (i === void 0) return null;
+			indices.push(i);
+		}
+		const sorted = Array.from(new Set(indices)).sort((a, b) => a - b);
+		for (let i = 1; i < sorted.length; i++) if (sorted[i] !== sorted[i - 1] + 1) return null;
+		const children = sorted.map((i) => siblings[i]);
+		const last_index = sorted[sorted.length - 1];
+		const original_positions = /* @__PURE__ */ new Map();
+		for (const i of sorted) original_positions.set(siblings[i], siblings[i + 1] ?? null);
+		return {
+			parent,
+			insert_before: siblings[last_index + 1] ?? null,
+			children,
+			original_positions
+		};
+	}
+	_group.plan = plan;
+})(group || (group = {}));
+//#endregion
+//#region src/core/transform.ts
+let transform;
+(function(_transform) {
+	/** SVG `<number>` production (spec-aligned subset). */
+	const SVG_NUMBER_SRC = "[+-]?(?:\\d+\\.?\\d*|\\.\\d+)(?:[eE][+-]?\\d+)?";
+	/** Recognized function names. Names are case-sensitive per SVG 1.1 §7.6. */
+	const FUNCTION_RE = /\s*([A-Za-z]+)\s*\(([^)]*)\)\s*/y;
+	const NUMBER_GLOBAL_RE = new RegExp(SVG_NUMBER_SRC, "g");
+	/** SVG 2 §11.6.1: `transform="none"` ≡ identity. CSS-wide keywords are
+	*  normalized at parse time per SVG 2 cascade. */
+	const IDENTITY_RE = /^\s*(?:none|inherit|unset|initial|revert|revert-layer)?\s*$/;
+	function parse_args(args) {
+		const tokens = args.match(NUMBER_GLOBAL_RE);
+		if (!tokens) return [];
+		const out = [];
+		for (const t of tokens) {
+			const n = parseFloat(t);
+			if (!Number.isFinite(n)) return null;
+			out.push(n);
+		}
+		return out;
+	}
+	function build_op(name, a) {
+		switch (name) {
+			case "matrix":
+				if (a.length !== 6) return null;
+				return {
+					type: "matrix",
+					a: a[0],
+					b: a[1],
+					c: a[2],
+					d: a[3],
+					e: a[4],
+					f: a[5]
+				};
+			case "translate":
+				if (a.length !== 1 && a.length !== 2) return null;
+				return {
+					type: "translate",
+					tx: a[0],
+					ty: a.length === 2 ? a[1] : 0
+				};
+			case "rotate":
+				if (a.length !== 1 && a.length !== 3) return null;
+				return {
+					type: "rotate",
+					angle: a[0],
+					cx: a.length === 3 ? a[1] : 0,
+					cy: a.length === 3 ? a[2] : 0,
+					explicit_pivot: a.length === 3
+				};
+			case "scale":
+				if (a.length !== 1 && a.length !== 2) return null;
+				return {
+					type: "scale",
+					sx: a[0],
+					sy: a.length === 2 ? a[1] : a[0]
+				};
+			case "skewX":
+				if (a.length !== 1) return null;
+				return {
+					type: "skewX",
+					angle: a[0]
+				};
+			case "skewY":
+				if (a.length !== 1) return null;
+				return {
+					type: "skewY",
+					angle: a[0]
+				};
+			default: return null;
+		}
+	}
+	function parse(input) {
+		if (input === null) return [];
+		if (IDENTITY_RE.test(input)) return [];
+		const ops = [];
+		FUNCTION_RE.lastIndex = 0;
+		let pos = 0;
+		while (pos < input.length) {
+			FUNCTION_RE.lastIndex = pos;
+			const m = FUNCTION_RE.exec(input);
+			if (!m || m.index !== pos) return null;
+			const name = m[1];
+			const args = parse_args(m[2]);
+			if (args === null) return null;
+			const op = build_op(name, args);
+			if (!op) return null;
+			ops.push(op);
+			pos = FUNCTION_RE.lastIndex;
+			while (pos < input.length && /[\s,]/.test(input[pos])) pos++;
+		}
+		return ops;
+	}
+	_transform.parse = parse;
+	function n(x) {
+		return String(x);
+	}
+	function emit_op(op) {
+		switch (op.type) {
+			case "matrix": return `matrix(${n(op.a)} ${n(op.b)} ${n(op.c)} ${n(op.d)} ${n(op.e)} ${n(op.f)})`;
+			case "translate": return `translate(${n(op.tx)} ${n(op.ty)})`;
+			case "rotate": return `rotate(${n(op.angle)} ${n(op.cx)} ${n(op.cy)})`;
+			case "scale": return `scale(${n(op.sx)} ${n(op.sy)})`;
+			case "skewX": return `skewX(${n(op.angle)})`;
+			case "skewY": return `skewY(${n(op.angle)})`;
+		}
+	}
+	_transform.emit_op = emit_op;
+	function emit(ops) {
+		return ops.map(emit_op).join(" ");
+	}
+	_transform.emit = emit;
+	function is_identity_translate(op) {
+		return op.type === "translate" && op.tx === 0 && op.ty === 0;
+	}
+	function is_identity_rotate(op) {
+		return op.type === "rotate" && op.angle === 0;
+	}
+	function classify(ops) {
+		const trimmed = ops.filter((op) => !is_identity_translate(op) && !is_identity_rotate(op));
+		if (trimmed.length === 0) return "identity";
+		if (trimmed.length === 1) {
+			if (trimmed[0].type === "translate") return "leading_translate_only";
+			if (trimmed[0].type === "rotate") return "single_rotate_only";
+			return "mixed";
+		}
+		if (trimmed.length === 2 && trimmed[0].type === "translate" && trimmed[1].type === "rotate") return "leading_translate_then_single_rotate";
+		return "mixed";
+	}
+	_transform.classify = classify;
+	function op_matrix(op) {
+		switch (op.type) {
+			case "matrix": return [[
+				op.a,
+				op.c,
+				op.e
+			], [
+				op.b,
+				op.d,
+				op.f
+			]];
+			case "translate": return [[
+				1,
+				0,
+				op.tx
+			], [
+				0,
+				1,
+				op.ty
+			]];
+			case "rotate": {
+				const t = op.angle * Math.PI / 180;
+				const cos = Math.cos(t);
+				const sin = Math.sin(t);
+				return [[
+					cos,
+					-sin,
+					op.cx - op.cx * cos + op.cy * sin
+				], [
+					sin,
+					cos,
+					op.cy - op.cx * sin - op.cy * cos
+				]];
+			}
+			case "scale": return [[
+				op.sx,
+				0,
+				0
+			], [
+				0,
+				op.sy,
+				0
+			]];
+			case "skewX": {
+				const t = op.angle * Math.PI / 180;
+				return [[
+					1,
+					Math.tan(t),
+					0
+				], [
+					0,
+					1,
+					0
+				]];
+			}
+			case "skewY": {
+				const t = op.angle * Math.PI / 180;
+				return [[
+					1,
+					0,
+					0
+				], [
+					Math.tan(t),
+					1,
+					0
+				]];
+			}
+		}
+	}
+	/** Compose a transform-list into a single 2×3 affine. Ops compose
+	*  source-order = left-to-right multiplication: `transform="A B C"`
+	*  maps a column-vector point `p` as `A · B · C · p` (per SVG 1.1
+	*  §7.5). */
+	function compose(ops) {
+		let m = cmath.transform.identity;
+		for (const op of ops) m = cmath.transform.multiply(m, op_matrix(op));
+		return m;
+	}
+	function project(local, transform_str) {
+		if (!transform_str) return local;
+		const ops = parse(transform_str);
+		if (ops === null || ops.length === 0) return local;
+		const m = compose(ops);
+		const projected = [
+			[local.x, local.y],
+			[local.x + local.width, local.y],
+			[local.x + local.width, local.y + local.height],
+			[local.x, local.y + local.height]
+		].map((p) => cmath.vector2.transform(p, m));
+		return cmath.rect.fromPointsOrZero(projected);
+	}
+	_transform.project = project;
+	function recompose(ops, new_cx, new_cy) {
+		const tx_op = ops.find((op) => op.type === "translate");
+		const tx = tx_op?.type === "translate" ? tx_op.tx : 0;
+		const ty = tx_op?.type === "translate" ? tx_op.ty : 0;
+		return emit(ops.map((op) => op.type === "rotate" ? {
+			type: "rotate",
+			angle: op.angle,
+			cx: new_cx - tx,
+			cy: new_cy - ty,
+			explicit_pivot: true
+		} : op));
+	}
+	_transform.recompose = recompose;
+})(transform || (transform = {}));
+//#endregion
+//#region src/core/translate-pipeline/translate-pipeline.ts
+let translate_pipeline;
+(function(_translate_pipeline) {
+	let intent;
+	(function(_intent) {
+		function num(doc, id, name, fallback = 0) {
+			return svg_parse.parse_number(doc.get_attr(id, name), fallback);
+		}
+		function capture_baseline(doc, id) {
+			const tag = doc.tag_of(id);
+			const own_transform = doc.get_attr(id, "transform");
+			if (own_transform !== null || tag === "g") return {
+				type: "viaTransform",
+				transform: own_transform
+			};
+			switch (tag) {
+				case "rect": return {
+					type: "rect",
+					x: num(doc, id, "x"),
+					y: num(doc, id, "y")
+				};
+				case "circle": return {
+					type: "circle",
+					cx: num(doc, id, "cx"),
+					cy: num(doc, id, "cy")
+				};
+				case "ellipse": return {
+					type: "ellipse",
+					cx: num(doc, id, "cx"),
+					cy: num(doc, id, "cy")
+				};
+				case "line": return {
+					type: "line",
+					x1: num(doc, id, "x1"),
+					y1: num(doc, id, "y1"),
+					x2: num(doc, id, "x2"),
+					y2: num(doc, id, "y2")
+				};
+				case "polyline": return {
+					type: "polyline",
+					points: doc.get_attr(id, "points") ?? ""
+				};
+				case "polygon": return {
+					type: "polygon",
+					points: doc.get_attr(id, "points") ?? ""
+				};
+				case "path": return {
+					type: "path",
+					d: doc.get_attr(id, "d") ?? ""
+				};
+				case "text": return {
+					type: "text",
+					x: num(doc, id, "x"),
+					y: num(doc, id, "y")
+				};
+				case "tspan": return {
+					type: "tspan",
+					x: num(doc, id, "x"),
+					y: num(doc, id, "y")
+				};
+				case "image": return {
+					type: "image",
+					x: num(doc, id, "x"),
+					y: num(doc, id, "y")
+				};
+				case "use": return {
+					type: "use",
+					x: num(doc, id, "x"),
+					y: num(doc, id, "y")
+				};
+				default: return { type: "unsupported" };
+			}
+		}
+		_intent.capture_baseline = capture_baseline;
+		function capture_baselines(doc, ids) {
+			const out = /* @__PURE__ */ new Map();
+			for (const id of ids) out.set(id, capture_baseline(doc, id));
+			return out;
+		}
+		_intent.capture_baselines = capture_baselines;
+		function baseline_anchor(b) {
+			switch (b.type) {
+				case "rect":
+				case "text":
+				case "tspan":
+				case "image":
+				case "use": return {
+					x: b.x,
+					y: b.y
+				};
+				case "circle":
+				case "ellipse": return {
+					x: b.cx,
+					y: b.cy
+				};
+				case "line": return {
+					x: Math.min(b.x1, b.x2),
+					y: Math.min(b.y1, b.y2)
+				};
+				case "polyline":
+				case "polygon": return svg_parse.points_top_left(svg_parse.parse_points(b.points));
+				case "path": return svg_parse.parse_path_first_move(b.d);
+				case "viaTransform": {
+					const ops = transform.parse(b.transform);
+					if (ops === null) return null;
+					for (const op of ops) {
+						if (op.type === "translate") return {
+							x: op.tx,
+							y: op.ty
+						};
+						break;
+					}
+					return null;
+				}
+				case "unsupported": return null;
+			}
+		}
+		_intent.baseline_anchor = baseline_anchor;
+		function baseline_union_top_left(baselines) {
+			const anchors = [];
+			for (const b of baselines.values()) {
+				const p = baseline_anchor(b);
+				if (p) anchors.push(p);
+			}
+			return svg_parse.points_top_left(anchors);
+		}
+		_intent.baseline_union_top_left = baseline_union_top_left;
+		function shift_points_string(points, dx, dy) {
+			if (dx === 0 && dy === 0) return points;
+			return svg_parse.parse_points(points).map((p) => `${p.x + dx},${p.y + dy}`).join(" ");
+		}
+		function compose_leading_translate(existing, dx, dy) {
+			if (dx === 0 && dy === 0) return existing ? existing : null;
+			if (!existing) return `translate(${dx} ${dy})`;
+			const lead = svg_parse.parse_leading_translate(existing);
+			if (lead) {
+				const tx = lead.tx + dx;
+				const ty = lead.ty + dy;
+				return lead.rest ? `translate(${tx} ${ty}) ${lead.rest}` : `translate(${tx} ${ty})`;
+			}
+			return `translate(${dx} ${dy}) ${existing}`;
+		}
+		_intent.compose_leading_translate = compose_leading_translate;
+		function shift_path_d(d, dx, dy) {
+			if (dx === 0 && dy === 0) return d;
+			try {
+				return new SVGPathData(d).transform(SVGPathDataTransformer.TRANSLATE(dx, dy)).encode();
+			} catch {
+				return d;
+			}
+		}
+		function apply(doc, id, baseline, dx, dy) {
+			switch (baseline.type) {
+				case "viaTransform":
+					doc.set_attr(id, "transform", compose_leading_translate(baseline.transform ?? "", dx, dy));
+					return;
+				case "rect":
+				case "image":
+				case "use":
+				case "text":
+				case "tspan":
+					doc.set_attr(id, "x", String(baseline.x + dx));
+					doc.set_attr(id, "y", String(baseline.y + dy));
+					return;
+				case "circle":
+				case "ellipse":
+					doc.set_attr(id, "cx", String(baseline.cx + dx));
+					doc.set_attr(id, "cy", String(baseline.cy + dy));
+					return;
+				case "line":
+					doc.set_attr(id, "x1", String(baseline.x1 + dx));
+					doc.set_attr(id, "y1", String(baseline.y1 + dy));
+					doc.set_attr(id, "x2", String(baseline.x2 + dx));
+					doc.set_attr(id, "y2", String(baseline.y2 + dy));
+					return;
+				case "polyline":
+				case "polygon":
+					doc.set_attr(id, "points", shift_points_string(baseline.points, dx, dy));
+					return;
+				case "path":
+					doc.set_attr(id, "d", shift_path_d(baseline.d, dx, dy));
+					return;
+				case "unsupported": return;
+			}
+		}
+		_intent.apply = apply;
+	})(intent || (intent = _translate_pipeline.intent || (_translate_pipeline.intent = {})));
+	let stages;
+	(function(_stages) {
+		const axis_lock = _stages.axis_lock = {
+			name: "axis_lock",
+			run(plan, ctx) {
+				const m = ctx.input.movement;
+				const locked = ctx.modifiers.axis_lock === "by_dominance" ? cmath.ext.movement.axisLockedByDominance(m) : m;
+				const [x, y] = cmath.ext.movement.normalize(locked);
+				return { plan: {
+					...plan,
+					delta: {
+						x,
+						y
+					}
+				} };
+			}
+		};
+		const snap = _stages.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 r = ctx.snap_session.snap(plan.delta, {
+					enabled: true,
+					threshold_px: ctx.options.snap_threshold_px
+				}, ctx.snap_policy);
+				return {
+					plan: {
+						...plan,
+						delta: r.delta
+					},
+					emit: r.guide ? { guide: r.guide } : void 0
+				};
+			}
+		};
+		const pixel_grid = _stages.pixel_grid = {
+			name: "pixel_grid",
+			run(plan, ctx) {
+				const q = ctx.options.pixel_grid_quantum;
+				if (q === null || q <= 0) return { plan };
+				const anchor = ctx.snap_session?.baseline_union_readonly ?? intent.baseline_union_top_left(plan.baselines);
+				if (!anchor) return { plan };
+				const qx = Math.round((anchor.x + plan.delta.x) / q) * q - anchor.x;
+				const qy = Math.round((anchor.y + plan.delta.y) / q) * q - anchor.y;
+				return { plan: {
+					...plan,
+					delta: {
+						x: qx,
+						y: qy
+					}
+				} };
+			}
+		};
+		_stages.DEFAULT = Object.freeze([
+			axis_lock,
+			snap,
+			pixel_grid
+		]);
+		_stages.NUDGE = Object.freeze([axis_lock, pixel_grid]);
+		_stages.RPC = Object.freeze([axis_lock]);
+	})(stages || (stages = _translate_pipeline.stages || (_translate_pipeline.stages = {})));
+	function run(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
+		};
+	}
+	_translate_pipeline.run = run;
+	function apply(doc, plan) {
+		for (const id of plan.ids) {
+			const baseline = plan.baselines.get(id);
+			if (!baseline) continue;
+			intent.apply(doc, id, baseline, plan.delta.x, plan.delta.y);
+		}
+	}
+	_translate_pipeline.apply = apply;
+	function revert(doc, plan) {
+		for (const id of plan.ids) {
+			const baseline = plan.baselines.get(id);
+			if (!baseline) continue;
+			intent.apply(doc, id, baseline, 0, 0);
+		}
+	}
+	_translate_pipeline.revert = revert;
+	function prepare_rpc(args) {
+		const { doc, ids, delta, options, emit, stages: stage_list = stages.RPC } = args;
+		const filtered_ids = doc.prune_nested_nodes(ids);
+		const plan0 = {
+			ids: filtered_ids,
+			baselines: intent.capture_baselines(doc, filtered_ids),
+			delta: {
+				x: 0,
+				y: 0
+			}
+		};
+		const { plan } = run(plan0, stage_list, {
+			input: {
+				ids: plan0.ids,
+				movement: [delta.x, delta.y]
+			},
+			modifiers: {
+				axis_lock: "off",
+				force_disable_snap: true
+			},
+			options,
+			snap_session: null,
+			snap_policy: "engine"
+		});
+		return {
+			plan,
+			apply: () => {
+				apply(doc, plan);
+				emit();
+			},
+			revert: () => {
+				revert(doc, plan);
+				emit();
+			}
+		};
+	}
+	_translate_pipeline.prepare_rpc = prepare_rpc;
+})(translate_pipeline || (translate_pipeline = {}));
+//#endregion
+//#region src/core/translate-pipeline/orchestrator.ts
+const PROVIDER_ID$2 = "svg-editor";
+var TranslateOrchestrator = class {
+	constructor(deps) {
+		this.deps = deps;
+		this.active = null;
+		this._last_guides = [];
+	}
+	/** Guides emitted by the most recent pipeline run. Cleared on
+	*  cancel/dispose. HUD compositors read this to draw snap chrome. */
+	get last_guides() {
+		return this._last_guides;
+	}
+	/** True while a gesture session is open. */
+	has_active_session() {
+		return this.active !== null;
+	}
+	/** Per-frame drive: lazily opens a session on first call, runs the
+	*  pipeline, writes apply/revert into the preview, and commits when
+	*  `opts.phase === "commit"`. */
+	drive(input, modifiers, opts) {
+		if (this.active === null) this.active = this.open(input.ids, opts.snap, opts.label ?? "move");
+		const session = this.active;
+		const stages = opts.stages ?? translate_pipeline.stages.DEFAULT;
+		const result = this.run_pass(session, input.movement, modifiers, opts.policy, stages);
+		session.last_movement = input.movement;
+		session.last_policy = opts.policy;
+		session.last_stages = stages;
+		this.write_preview_delta(session, result.plan);
+		if (opts.phase === "commit") {
+			session.preview.commit();
+			this.dispose_session();
+		}
+		return result;
+	}
+	/** Re-run the current preview frame with new modifiers, reusing the
+	*  last-known movement / policy / stages. Used when a modifier key
+	*  changes between pointer-move events (Shift down/up mid-drag).
+	*  No-op when no session is active. */
+	redrive_modifiers(modifiers) {
+		if (!this.active) return null;
+		const session = this.active;
+		const result = this.run_pass(session, session.last_movement, modifiers, session.last_policy, session.last_stages);
+		this.write_preview_delta(session, result.plan);
+		return result;
+	}
+	/** Cancel an in-flight gesture (Escape, programmatic abort). */
+	cancel() {
+		if (!this.active) return;
+		this.active.preview.discard();
+		this.dispose_session();
+	}
+	/** Build a plan + context, run the pipeline, stash guides. Pure
+	*  computation — does not touch the preview. */
+	run_pass(session, movement, modifiers, policy, stages) {
+		const plan0 = {
+			ids: session.ids,
+			baselines: session.baselines,
+			delta: {
+				x: 0,
+				y: 0
+			}
+		};
+		const ctx = {
+			input: {
+				ids: session.ids,
+				movement
+			},
+			modifiers,
+			options: this.deps.options(),
+			snap_session: session.snap,
+			snap_policy: policy
+		};
+		const result = translate_pipeline.run(plan0, stages, ctx);
+		this._last_guides = result.guides;
+		return result;
+	}
+	open(ids, snap, label) {
+		const doc = this.deps.get_doc();
+		const filtered = doc.prune_nested_nodes(ids);
+		return {
+			ids: filtered,
+			baselines: translate_pipeline.intent.capture_baselines(doc, filtered),
+			snap: snap ? this.deps.open_snap(filtered) : null,
+			preview: this.deps.open_preview(label),
+			last_movement: [0, 0],
+			last_policy: "engine",
+			last_stages: translate_pipeline.stages.DEFAULT
+		};
+	}
+	/** Bind a fresh apply/revert pair (closure over `plan`) into the
+	*  preview slot. Called from both `drive` (per pointer frame) and
+	*  `redrive_modifiers` (on modifier flip). */
+	write_preview_delta(session, plan) {
+		const doc = this.deps.get_doc();
+		const emit = this.deps.emit;
+		session.preview.set({
+			providerId: PROVIDER_ID$2,
+			apply: () => {
+				translate_pipeline.apply(doc, plan);
+				emit();
+			},
+			revert: () => {
+				translate_pipeline.revert(doc, plan);
+				emit();
+			}
+		});
+	}
+	dispose_session() {
+		if (!this.active) return;
+		this.active.snap?.dispose();
+		this.active = null;
+		this._last_guides = [];
+	}
+};
+//#endregion
+//#region src/core/translate-pipeline/nudge-dwell-watcher.ts
+/** Hold-time after the last firing detection. Show is immediate (next
+*  frame); only the hide edge is delayed. */
+const HIDE_MS = 500;
+var NudgeDwellWatcher = class {
+	constructor(deps) {
+		this.deps = deps;
+		this._guides = [];
+		this.raf_id = null;
+		this.hide_timer = null;
+		this.unsubscribe = deps.editor.subscribe_translate_commit(() => this.schedule_detect());
+	}
+	/** Currently-published dwell guides. Empty between detections. */
+	get guides() {
+		return this._guides;
+	}
+	/** Drop any pending detection / held guide. Idempotent. */
+	cancel_pending() {
+		this.clear_raf();
+		this.clear_hide();
+		this.publish_guides([]);
+	}
+	dispose() {
+		this.unsubscribe();
+		this.cancel_pending();
+	}
+	schedule_detect() {
+		if (this.raf_id !== null) return;
+		this.raf_id = this.deps.window.requestAnimationFrame(() => {
+			this.raf_id = null;
+			this.detect();
+		});
+	}
+	detect() {
+		const ids = this.deps.editor.state.selection;
+		if (ids.length === 0) {
+			this.publish_guides([]);
+			this.clear_hide();
+			return;
+		}
+		const snap = this.deps.open_snap(ids);
+		if (!snap) {
+			this.publish_guides([]);
+			this.clear_hide();
+			return;
+		}
+		try {
+			const plan0 = {
+				ids: [...ids],
+				baselines: translate_pipeline.intent.capture_baselines(this.deps.editor.document, ids),
+				delta: {
+					x: 0,
+					y: 0
+				}
+			};
+			const ctx = {
+				input: {
+					ids: plan0.ids,
+					movement: [0, 0]
+				},
+				modifiers: {
+					axis_lock: "off",
+					force_disable_snap: false
+				},
+				options: this.deps.options(),
+				snap_session: snap,
+				snap_policy: "aligned"
+			};
+			const result = translate_pipeline.run(plan0, translate_pipeline.stages.DEFAULT, ctx);
+			if (result.guides.length === 0) {
+				this.publish_guides([]);
+				this.clear_hide();
+				return;
+			}
+			this.publish_guides(result.guides);
+			this.arm_hide();
+		} finally {
+			snap.dispose();
+		}
+	}
+	arm_hide() {
+		this.clear_hide();
+		this.hide_timer = this.deps.window.setTimeout(() => {
+			this.hide_timer = null;
+			this.publish_guides([]);
+		}, HIDE_MS);
+	}
+	publish_guides(next) {
+		if (next.length === 0 && this._guides.length === 0) return;
+		this._guides = next;
+		this.deps.on_guides_change();
+	}
+	clear_raf() {
+		if (this.raf_id === null) return;
+		this.deps.window.cancelAnimationFrame(this.raf_id);
+		this.raf_id = null;
+	}
+	clear_hide() {
+		if (this.hide_timer === null) return;
+		this.deps.window.clearTimeout(this.hide_timer);
+		this.hide_timer = null;
+	}
+};
+//#endregion
+//#region src/core/rotate-pipeline/rotate-pipeline.ts
+let rotate_pipeline;
+(function(_rotate_pipeline) {
+	let intent;
+	(function(_intent) {
+		function is_rotatable(doc, id) {
+			const own_transform = doc.get_attr(id, "transform");
+			const ops = transform.parse(own_transform);
+			if (ops === null) return {
+				kind: "refuse",
+				reason: "non-trivial-transform"
+			};
+			if (transform.classify(ops) === "mixed") return {
+				kind: "refuse",
+				reason: "non-trivial-transform"
+			};
+			if (doc.has_glyph_rotate(id)) return {
+				kind: "refuse",
+				reason: "text-with-glyph-rotate"
+			};
+			if (doc.has_inline_css_transform(id)) return {
+				kind: "refuse",
+				reason: "css-property-transform"
+			};
+			if (doc.has_animate_transform_child(id)) return {
+				kind: "refuse",
+				reason: "animated-transform"
+			};
+			return { kind: "yes" };
+		}
+		_intent.is_rotatable = is_rotatable;
+		function find_op(ops, type) {
+			for (const op of ops) if (op.type === type) return op;
+			return null;
+		}
+		function capture_baseline(doc, id, pivot) {
+			const transform_str = doc.get_attr(id, "transform");
+			const ops = transform.parse(transform_str) ?? [];
+			const lead = find_op(ops, "translate");
+			const rot = find_op(ops, "rotate");
+			return {
+				transform: transform_str,
+				leading_translate: lead ? {
+					x: lead.tx,
+					y: lead.ty
+				} : null,
+				current_rotation_deg: rot?.angle ?? 0,
+				pivot
+			};
+		}
+		_intent.capture_baseline = capture_baseline;
+		function capture_baselines(doc, ids, pivot) {
+			const out = /* @__PURE__ */ new Map();
+			for (const id of ids) out.set(id, capture_baseline(doc, id, pivot));
+			return out;
+		}
+		_intent.capture_baselines = capture_baselines;
+		const RAD_TO_DEG = 180 / Math.PI;
+		/** Snap trailing FP noise off the 10th decimal place. The rad→deg
+		*  conversion + addition produce e.g. `29.999999999999996` for
+		*  what the user dragged as "30°"; rounding to 1e-9 absorbs the
+		*  noise without losing any user-meaningful precision (SVG
+		*  coordinates rarely go past 4 decimals in authored content).
+		*
+		*  Limits drift accumulation across a long gesture: each frame's
+		*  emit re-renders from `current_rotation_deg + delta_deg`, where
+		*  the delta is recomputed against the gesture-start anchor — not
+		*  accumulated. So noise stays bounded per-frame. */
+		function fmt_angle(n) {
+			return String(Math.round(n * 1e9) / 1e9);
+		}
+		function apply(doc, id, baseline, angle_radians) {
+			const angle_deg = angle_radians * RAD_TO_DEG;
+			const total = baseline.current_rotation_deg + angle_deg;
+			if (total === 0 && angle_deg === 0) {
+				doc.set_attr(id, "transform", baseline.transform);
+				return;
+			}
+			const tx = baseline.leading_translate?.x ?? 0;
+			const ty = baseline.leading_translate?.y ?? 0;
+			const cx = baseline.pivot.x - tx;
+			const cy = baseline.pivot.y - ty;
+			const rotate_token = `rotate(${fmt_angle(total)} ${cx} ${cy})`;
+			const str = baseline.leading_translate ? `translate(${tx} ${ty}) ${rotate_token}` : rotate_token;
+			doc.set_attr(id, "transform", str);
+		}
+		_intent.apply = apply;
+	})(intent || (intent = _rotate_pipeline.intent || (_rotate_pipeline.intent = {})));
+	let stages;
+	(function(_stages) {
+		const angle_snap = _stages.angle_snap = {
+			name: "angle_snap",
+			run(plan, ctx) {
+				if (ctx.modifiers.force_disable_snap) return { plan };
+				if (ctx.modifiers.angle_snap !== "step") return { plan };
+				const step = ctx.options.angle_snap_step_radians;
+				if (step === null || step <= 0) return { plan };
+				const snapped = Math.round(plan.angle_radians / step) * step;
+				return { plan: {
+					...plan,
+					angle_radians: snapped
+				} };
+			}
+		};
+		_stages.DEFAULT = Object.freeze([angle_snap]);
+		_stages.RPC = Object.freeze([]);
+	})(stages || (stages = _rotate_pipeline.stages || (_rotate_pipeline.stages = {})));
+	function run(init, stages, ctx) {
+		let plan = init;
+		for (const stage of stages) plan = stage.run(plan, ctx).plan;
+		return { plan };
+	}
+	_rotate_pipeline.run = run;
+	function apply(doc, plan) {
+		for (const m of plan.members) intent.apply(doc, m.id, m.baseline, plan.angle_radians);
+	}
+	_rotate_pipeline.apply = apply;
+	function revert(doc, plan) {
+		for (const m of plan.members) intent.apply(doc, m.id, m.baseline, 0);
+	}
+	_rotate_pipeline.revert = revert;
+	function prepare_rpc(args) {
+		const { doc, ids, pivot, angle_radians, options, emit, stages: stage_list = stages.RPC } = args;
+		const filtered_ids = doc.prune_nested_nodes(ids);
+		const baselines = intent.capture_baselines(doc, filtered_ids, pivot);
+		const members = filtered_ids.map((id) => ({
+			id,
+			baseline: baselines.get(id)
+		}));
+		const verdicts = /* @__PURE__ */ new Map();
+		for (const id of filtered_ids) verdicts.set(id, intent.is_rotatable(doc, id));
+		const { plan } = run({
+			members,
+			pivot,
+			angle_radians
+		}, stage_list, {
+			input: {
+				ids: filtered_ids,
+				angle_radians
+			},
+			modifiers: {
+				angle_snap: "off",
+				force_disable_snap: true
+			},
+			options
+		});
+		return {
+			plan,
+			verdicts,
+			apply: () => {
+				apply(doc, plan);
+				emit();
+			},
+			revert: () => {
+				revert(doc, plan);
+				emit();
+			}
+		};
+	}
+	_rotate_pipeline.prepare_rpc = prepare_rpc;
+})(rotate_pipeline || (rotate_pipeline = {}));
+//#endregion
+//#region src/core/rotate-pipeline/orchestrator.ts
+const PROVIDER_ID$1 = "svg-editor";
+function ids_key$1(ids) {
+	return [...ids].sort().join("\0");
+}
+var RotateOrchestrator = class {
+	constructor(deps) {
+		this.deps = deps;
+		this.active = null;
+	}
+	has_active_session() {
+		return this.active !== null;
+	}
+	is_active_for(ids) {
+		return this.active !== null && this.active.ids_key === ids_key$1(ids);
+	}
+	/** Per-frame drive. Opens a session lazily on the first call. Returns
+	*  `null` when `ids` is empty. On commit, returns a `RotateCommitOutcome`
+	*  the caller uses to surface refusal chips. */
+	drive(input, modifiers, opts) {
+		if (input.ids.length === 0) return null;
+		const key = ids_key$1(input.ids);
+		if (this.active && this.active.ids_key !== key) {
+			this.active.preview.discard();
+			this.dispose_session();
+		}
+		if (this.active === null) this.active = this.open(input.ids, opts.label ?? "rotate");
+		const session = this.active;
+		const stages = opts.stages ?? rotate_pipeline.stages.DEFAULT;
+		const result = this.run_pass(session, input.angle_radians, modifiers, stages);
+		session.last_angle = input.angle_radians;
+		session.last_stages = stages;
+		this.write_preview(session, result.plan);
+		if (opts.phase === "commit") {
+			let outcome;
+			let refused = false;
+			for (const v of session.verdicts.values()) if (v.kind === "refuse") {
+				refused = true;
+				break;
+			}
+			if (refused) {
+				session.preview.discard();
+				outcome = {
+					kind: "refused",
+					verdicts: session.verdicts
+				};
+			} else {
+				session.preview.commit();
+				outcome = {
+					kind: "committed",
+					plan: result.plan
+				};
+			}
+			this.dispose_session();
+			return {
+				result,
+				outcome
+			};
+		}
+		return {
+			result,
+			outcome: null
+		};
+	}
+	redrive_modifiers(modifiers) {
+		if (!this.active) return null;
+		const session = this.active;
+		const result = this.run_pass(session, session.last_angle, modifiers, session.last_stages);
+		this.write_preview(session, result.plan);
+		return result;
+	}
+	cancel() {
+		if (!this.active) return;
+		this.active.preview.discard();
+		this.dispose_session();
+	}
+	run_pass(session, angle_radians, modifiers, stages) {
+		const plan0 = {
+			members: session.members,
+			pivot: session.pivot,
+			angle_radians
+		};
+		const ctx = {
+			input: {
+				ids: session.members.map((m) => m.id),
+				angle_radians
+			},
+			modifiers,
+			options: this.deps.options()
+		};
+		return rotate_pipeline.run(plan0, stages, ctx);
+	}
+	open(ids, label) {
+		const doc = this.deps.get_doc();
+		const filtered = doc.prune_nested_nodes(ids);
+		const pivot = compute_union_center(filtered, this.deps.bbox_world);
+		const baselines = rotate_pipeline.intent.capture_baselines(doc, filtered, pivot);
+		const members = filtered.map((id) => ({
+			id,
+			baseline: baselines.get(id)
+		}));
+		const verdicts = /* @__PURE__ */ new Map();
+		for (const id of filtered) verdicts.set(id, rotate_pipeline.intent.is_rotatable(doc, id));
+		return {
+			ids_key: ids_key$1(ids),
+			members,
+			pivot,
+			verdicts,
+			preview: this.deps.open_preview(label),
+			last_angle: 0,
+			last_stages: rotate_pipeline.stages.DEFAULT
+		};
+	}
+	write_preview(session, plan) {
+		const doc = this.deps.get_doc();
+		const emit = this.deps.emit;
+		session.preview.set({
+			providerId: PROVIDER_ID$1,
+			apply: () => {
+				rotate_pipeline.apply(doc, plan);
+				emit();
+			},
+			revert: () => {
+				rotate_pipeline.revert(doc, plan);
+				emit();
+			}
+		});
+	}
+	dispose_session() {
+		this.active = null;
+	}
+};
+function compute_union_center(ids, bbox_world) {
+	const rects = ids.map(bbox_world);
+	const u = cmath.rect.union(rects);
+	return {
+		x: u.x + u.width / 2,
+		y: u.y + u.height / 2
+	};
+}
+//#endregion
+//#region src/core/hit-shape-svg.ts
+let hit_shape_svg;
+(function(_hit_shape_svg) {
+	/** Tags that never participate in picking. Containers and non-
+	*  rendering metadata. The root `<svg>` is in this set — root
+	*  pickability is a host decision (measurement HUD wants it,
+	*  selection doesn't), gated by an explicit `allow_root` flag at the
+	*  caller. */
+	const TRANSPARENT_TAGS = new Set([
+		"g",
+		"svg",
+		"defs",
+		"symbol",
+		"clipPath",
+		"mask",
+		"marker",
+		"pattern",
+		"linearGradient",
+		"radialGradient",
+		"stop",
+		"filter",
+		"title",
+		"desc",
+		"metadata",
+		"style",
+		"script"
+	]);
+	function is_transparent_tag(tag) {
+		return TRANSPARENT_TAGS.has(tag);
+	}
+	_hit_shape_svg.is_transparent_tag = is_transparent_tag;
+	function num(doc, id, name, fallback = 0) {
+		return svg_parse.parse_number(doc.get_attr(id, name), fallback);
+	}
+	function of_doc(doc, id) {
+		const tag = doc.tag_of(id);
+		const ops = transform.parse(doc.get_attr(id, "transform"));
+		if (ops === null) return null;
+		if (transform.classify(ops) === "mixed") return null;
+		const xform = pick_affine(ops);
+		const has_rotation = xform.angle_rad !== 0;
+		switch (tag) {
+			case "rect": {
+				const x = num(doc, id, "x");
+				const y = num(doc, id, "y");
+				const w = num(doc, id, "width");
+				const h = num(doc, id, "height");
+				if (!has_rotation) {
+					const t = xform.translate;
+					return {
+						kind: "rect",
+						x: x + t.x,
+						y: y + t.y,
+						width: w,
+						height: h
+					};
+				}
+				return {
+					kind: "polygon",
+					pts: [
+						{
+							x,
+							y
+						},
+						{
+							x: x + w,
+							y
+						},
+						{
+							x: x + w,
+							y: y + h
+						},
+						{
+							x,
+							y: y + h
+						}
+					].map((p) => transform_point(p, xform)),
+					closed: true
+				};
+			}
+			case "circle": {
+				const cx = num(doc, id, "cx");
+				const cy = num(doc, id, "cy");
+				const r = num(doc, id, "r");
+				const tc = transform_point({
+					x: cx,
+					y: cy
+				}, xform);
+				return {
+					kind: "ellipse",
+					cx: tc.x,
+					cy: tc.y,
+					rx: r,
+					ry: r
+				};
+			}
+			case "ellipse": {
+				const cx = num(doc, id, "cx");
+				const cy = num(doc, id, "cy");
+				const rx = num(doc, id, "rx");
+				const ry = num(doc, id, "ry");
+				if (has_rotation) return null;
+				const tc = transform_point({
+					x: cx,
+					y: cy
+				}, xform);
+				return {
+					kind: "ellipse",
+					cx: tc.x,
+					cy: tc.y,
+					rx,
+					ry
+				};
+			}
+			case "line": return {
+				kind: "segment",
+				a: transform_point({
+					x: num(doc, id, "x1"),
+					y: num(doc, id, "y1")
+				}, xform),
+				b: transform_point({
+					x: num(doc, id, "x2"),
+					y: num(doc, id, "y2")
+				}, xform)
+			};
+			case "polyline": {
+				const pts = svg_parse.parse_points(doc.get_attr(id, "points") ?? "");
+				if (pts.length === 0) return null;
+				return {
+					kind: "polyline",
+					pts: pts.map((q) => transform_point({
+						x: q.x,
+						y: q.y
+					}, xform)),
+					closed: false
+				};
+			}
+			case "polygon": {
+				const pts = svg_parse.parse_points(doc.get_attr(id, "points") ?? "");
+				if (pts.length === 0) return null;
+				return {
+					kind: "polygon",
+					pts: pts.map((q) => transform_point({
+						x: q.x,
+						y: q.y
+					}, xform)),
+					closed: true
+				};
+			}
+			case "path": {
+				const d = doc.get_attr(id, "d") ?? "";
+				const pts = path_control_polyline(d);
+				if (pts.length === 0) return null;
+				return {
+					kind: "path",
+					pts: pts.map((p) => transform_point(p, xform)),
+					closed: /[zZ]\s*$/.test(d)
+				};
+			}
+			default: return null;
+		}
+	}
+	_hit_shape_svg.of_doc = of_doc;
+	function pick_affine(ops) {
+		let tx = 0;
+		let ty = 0;
+		let pivot = {
+			x: 0,
+			y: 0
+		};
+		let angle_rad = 0;
+		for (const op of ops) if (op.type === "translate") {
+			tx = op.tx;
+			ty = op.ty;
+		} else if (op.type === "rotate") {
+			pivot = {
+				x: op.cx,
+				y: op.cy
+			};
+			angle_rad = op.angle * Math.PI / 180;
+		}
+		return {
+			translate: {
+				x: tx,
+				y: ty
+			},
+			pivot,
+			angle_rad
+		};
+	}
+	/** Apply (rotate around pivot by angle_rad, then translate). Mirrors
+	*  the SVG transform-list semantic order: `translate(...)
+	*  rotate(...)` means matrix product T·R applied to P → translation
+	*  moves the *rotated* point. */
+	function transform_point(p, x) {
+		let q = p;
+		if (x.angle_rad !== 0) {
+			const c = Math.cos(x.angle_rad);
+			const s = Math.sin(x.angle_rad);
+			const dx = q.x - x.pivot.x;
+			const dy = q.y - x.pivot.y;
+			q = {
+				x: x.pivot.x + dx * c - dy * s,
+				y: x.pivot.y + dx * s + dy * c
+			};
+		}
+		if (x.translate.x !== 0 || x.translate.y !== 0) q = {
+			x: q.x + x.translate.x,
+			y: q.y + x.translate.y
+		};
+		return q;
+	}
+	function path_control_polyline(d) {
+		if (!d) return [];
+		let path;
+		try {
+			path = new SVGPathData(d).toAbs();
+		} catch {
+			return [];
+		}
+		const out = [];
+		for (const cmd of path.commands) {
+			const c = cmd;
+			if (typeof c.x1 === "number" && typeof c.y1 === "number") out.push({
+				x: c.x1,
+				y: c.y1
+			});
+			if (typeof c.x2 === "number" && typeof c.y2 === "number") out.push({
+				x: c.x2,
+				y: c.y2
+			});
+			if (typeof c.x === "number" && typeof c.y === "number") out.push({
+				x: c.x,
+				y: c.y
+			});
+		}
+		return out;
+	}
+	_hit_shape_svg.path_control_polyline = path_control_polyline;
+})(hit_shape_svg || (hit_shape_svg = {}));
+//#endregion
+//#region src/core/policy-class/types.ts
+/**
+* The four top-level intents — distinguished as their own constant for
+* tables that only declare top-level intent cells.
+*/
+const TOP_LEVEL_INTENTS = [
+	"resize",
+	"translate",
+	"rotate",
+	"enter-vector-edit"
+];
+/**
+* The vector-edit sub-intents — the atomic operations exposed inside
+* vector-editing mode. See the v1 intent coverage section of the
+* glossary doc for the per-class table.
+*/
+const VECTOR_EDIT_SUB_INTENTS = [
+	"translate-vertex",
+	"insert-vertex",
+	"delete-vertex",
+	"close-shape",
+	"open-shape",
+	"insert-tangent",
+	"adjust-tangent",
+	"convert-segment-type",
+	"adjust-arc-radii",
+	"split-sub-path"
+];
+[...TOP_LEVEL_INTENTS, ...VECTOR_EDIT_SUB_INTENTS];
+//#endregion
+//#region src/core/policy-class/index.ts
+let policy_class;
+(function(_policy_class) {
+	function of(tag) {
+		switch (tag) {
+			case "line":
+			case "polyline":
+			case "polygon": return "vertex-chain";
+			case "rect":
+			case "image":
+			case "use": return "vertex-box";
+			case "circle": return "circle";
+			case "ellipse": return "ellipse";
+			case "path": return "path";
+			case "text":
+			case "tspan": return "text";
+			case "g": return "group";
+			default: return "none";
+		}
+	}
+	_policy_class.of = of;
+	const SOLUTION_SPACE = {
+		"vertex-chain": {
+			resize: ["bake"],
+			translate: ["bake", "via-transform"],
+			rotate: ["via-transform"],
+			"enter-vector-edit": ["bake"],
+			"translate-vertex": ["bake"],
+			"insert-vertex": ["bake"],
+			"delete-vertex": ["bake", "restrict"],
+			"close-shape": ["promote"],
+			"open-shape": ["promote"]
+		},
+		"vertex-box": {
+			resize: ["bake"],
+			translate: ["bake", "via-transform"],
+			rotate: ["via-transform"]
+		},
+		circle: {
+			resize: [
+				"restrict",
+				"promote",
+				"via-transform"
+			],
+			translate: ["bake"],
+			rotate: ["via-transform"]
+		},
+		ellipse: {
+			resize: ["bake", "via-transform"],
+			translate: ["bake"],
+			rotate: ["via-transform"]
+		},
+		path: {
+			resize: ["bake", "via-transform"],
+			translate: ["bake", "via-transform"],
+			rotate: ["bake", "via-transform"],
+			"enter-vector-edit": ["bake"],
+			"translate-vertex": ["bake"],
+			"insert-vertex": ["bake"],
+			"delete-vertex": ["bake"],
+			"close-shape": ["bake"],
+			"open-shape": ["bake"],
+			"insert-tangent": ["bake"],
+			"adjust-tangent": ["bake"],
+			"convert-segment-type": ["bake"],
+			"adjust-arc-radii": ["bake"],
+			"split-sub-path": ["bake"]
+		},
+		text: {},
+		group: {
+			translate: ["via-transform"],
+			rotate: ["via-transform"]
+		},
+		none: {}
+	};
+	const CHOSEN_POLICY = {
+		"vertex-chain": {
+			resize: "bake",
+			translate: "bake",
+			rotate: "via-transform",
+			"enter-vector-edit": "bake",
+			"translate-vertex": "bake",
+			"insert-vertex": "bake",
+			"delete-vertex": "restrict",
+			"close-shape": "promote",
+			"open-shape": "promote"
+		},
+		"vertex-box": {
+			resize: "bake",
+			translate: "bake",
+			rotate: "via-transform"
+		},
+		circle: {
+			resize: "restrict",
+			translate: "bake",
+			rotate: "via-transform"
+		},
+		ellipse: {
+			resize: "bake",
+			translate: "bake",
+			rotate: "via-transform"
+		},
+		path: {
+			resize: "bake",
+			translate: "bake",
+			rotate: "via-transform"
+		},
+		text: {},
+		group: {
+			translate: "via-transform",
+			rotate: "via-transform"
+		},
+		none: {}
+	};
+	/** Shared empty solution-space — returned on misses to avoid per-call
+	*  array allocation. */
+	const EMPTY = Object.freeze([]);
+	function legal_solutions(cls, intent) {
+		return SOLUTION_SPACE[cls][intent] ?? EMPTY;
+	}
+	_policy_class.legal_solutions = legal_solutions;
+	function chosen_policy(cls, intent) {
+		return CHOSEN_POLICY[cls][intent];
+	}
+	_policy_class.chosen_policy = chosen_policy;
+	function accepts(cls, intent) {
+		return legal_solutions(cls, intent).length > 0;
+	}
+	_policy_class.accepts = accepts;
+	function fork_count(cls, intent) {
+		return legal_solutions(cls, intent).length;
+	}
+	_policy_class.fork_count = fork_count;
+	_policy_class._internal_SOLUTION_SPACE = SOLUTION_SPACE;
+	_policy_class._internal_CHOSEN_POLICY = CHOSEN_POLICY;
+})(policy_class || (policy_class = {}));
+//#endregion
+//#region src/core/policy-class/handlers/resize.ts
+function scale_points_string(points, origin, sx, sy) {
+	return svg_parse.parse_points(points).map((p) => {
+		return `${origin.x + (p.x - origin.x) * sx},${origin.y + (p.y - origin.y) * sy}`;
+	}).join(" ");
+}
+function scale_path_d(d, origin, sx, sy) {
+	try {
+		const e = origin.x * (1 - sx);
+		const f = origin.y * (1 - sy);
+		return new SVGPathData(d).transform(SVGPathDataTransformer.MATRIX(sx, 0, 0, sy, e, f)).encode();
+	} catch {
+		return d;
+	}
+}
+/**
+* VertexChain × resize — vertex transport in local space.
+* Line carries its own (x1, y1, x2, y2); polyline / polygon share `points`.
+* Result type is preserved.
+*/
+function resize_vertex_chain(doc, id, baseline, sx, sy, origin) {
+	const a = baseline.attrs;
+	if (a.kind === "line") {
+		doc.set_attr(id, "x1", String(origin.x + (a.x1 - origin.x) * sx));
+		doc.set_attr(id, "y1", String(origin.y + (a.y1 - origin.y) * sy));
+		doc.set_attr(id, "x2", String(origin.x + (a.x2 - origin.x) * sx));
+		doc.set_attr(id, "y2", String(origin.y + (a.y2 - origin.y) * sy));
+		return;
+	}
+	if (a.kind === "polyline" || a.kind === "polygon") {
+		doc.set_attr(id, "points", scale_points_string(a.points, origin, sx, sy));
+		return;
+	}
+}
+/**
+* VertexBox × resize — axis-aligned bounding-box transport (rect / image / use).
+* Width/height clamp at 0.001 prevents inverted boxes and degenerate writes.
+*/
+function resize_vertex_box(doc, id, baseline, sx, sy, origin) {
+	const a = baseline.attrs;
+	if (a.kind !== "rect" && a.kind !== "image" && a.kind !== "use") return;
+	doc.set_attr(id, "x", String(origin.x + (a.x - origin.x) * sx));
+	doc.set_attr(id, "y", String(origin.y + (a.y - origin.y) * sy));
+	doc.set_attr(id, "width", String(Math.max(.001, a.w * sx)));
+	doc.set_attr(id, "height", String(Math.max(.001, a.h * sy)));
+}
+/**
+* Circle × resize — the canonical Policy Class fork.
+*
+* v1 picks `restrict`: clamp the gesture onto the `rx = ry` constraint
+* surface (`s = min(sx, sy)`) and bake the projection. The circle stays
+* a circle. `promote` and `via-transform` are declared legal but
+* unimplemented; the exhaustive switch surfaces any future swap.
+*/
+function resize_circle(doc, id, baseline, sx, sy, origin) {
+	const a = baseline.attrs;
+	if (a.kind !== "circle") return;
+	const policy = policy_class.chosen_policy("circle", "resize");
+	switch (policy) {
+		case "restrict": {
+			const s = Math.min(sx, sy);
+			doc.set_attr(id, "cx", String(origin.x + (a.cx - origin.x) * s));
+			doc.set_attr(id, "cy", String(origin.y + (a.cy - origin.y) * s));
+			doc.set_attr(id, "r", String(Math.max(.001, a.r * s)));
+			return;
+		}
+		case "promote":
+		case "via-transform":
+		case "bake": throw new Error(`Circle resize policy '${policy}' is legal per Policy Class but not implemented in v1`);
+		case void 0: throw new Error("Circle resize has no chosen policy declared in Policy Class");
+		default: throw new Error("unreachable");
+	}
+}
+/**
+* Ellipse × resize — independent rx, ry. No constraint to enforce
+* (ellipse is already the general axis-aligned-radii form).
+*/
+function resize_ellipse(doc, id, baseline, sx, sy, origin) {
+	const a = baseline.attrs;
+	if (a.kind !== "ellipse") return;
+	doc.set_attr(id, "cx", String(origin.x + (a.cx - origin.x) * sx));
+	doc.set_attr(id, "cy", String(origin.y + (a.cy - origin.y) * sy));
+	doc.set_attr(id, "rx", String(Math.max(.001, a.rx * sx)));
+	doc.set_attr(id, "ry", String(Math.max(.001, a.ry * sy)));
+}
+/**
+* Path × resize — bake the affine into every segment of `d` via
+* svg-pathdata's MATRIX transformer. Curve handles, arc radii, and
+* segment endpoints scale together; segment types are preserved.
+*/
+function resize_path(doc, id, baseline, sx, sy, origin) {
+	const a = baseline.attrs;
+	if (a.kind !== "path") return;
+	doc.set_attr(id, "d", scale_path_d(a.d, origin, sx, sy));
+}
+/**
+* Text × resize.
+*
+* **Unnatural — see UNNATURAL.md.** Text class is "deferred" in Policy
+* Class (no resize cells declared) but accepted by the legacy
+* `is_resizable` capability gate. This handler preserves legacy
+* behavior verbatim:
+*
+*   - Edge drags (one of sx, sy is 1) are refused.
+*   - Corner drags scale (x, y, font-size) uniformly by min(sx, sy).
+*
+* When Text class is properly declared in Policy Class, the policy
+* switch above will gain a `text` branch and this handler's body will
+* either re-route through `chosen_policy("text", "resize")` or split
+* by sub-class (font-resize vs. container-box-resize is a design
+* question for the Text class work).
+*/
+function resize_text(doc, id, baseline, sx, sy, origin) {
+	const a = baseline.attrs;
+	if (a.kind !== "text") return;
+	if (!(sx !== 1 && sy !== 1)) return;
+	const s = Math.min(sx, sy);
+	doc.set_attr(id, "x", String(origin.x + (a.x - origin.x) * s));
+	doc.set_attr(id, "y", String(origin.y + (a.y - origin.y) * s));
+	doc.set_attr(id, "font-size", String(Math.max(1, a.fontSize * s)));
+}
+/**
+* Resize dispatch through Policy Class.
+*
+* Replaces the nine-arm tag switch in `intents.ts:apply_resize`. The
+* caller (`apply_resize`) wraps this with the commit-phase pivot
+* recomposition; this function does **only** the geometry write.
+*
+* Classes rejected by Policy Class (`group`, `none`) noop silently.
+* Text is carved out as the one known gap (see Text handler doc).
+*/
+function dispatch_resize(doc, id, baseline, sx, sy, origin) {
+	switch (policy_class.of(doc.tag_of(id))) {
+		case "vertex-chain": return resize_vertex_chain(doc, id, baseline, sx, sy, origin);
+		case "vertex-box": return resize_vertex_box(doc, id, baseline, sx, sy, origin);
+		case "circle": return resize_circle(doc, id, baseline, sx, sy, origin);
+		case "ellipse": return resize_ellipse(doc, id, baseline, sx, sy, origin);
+		case "path": return resize_path(doc, id, baseline, sx, sy, origin);
+		case "text": return resize_text(doc, id, baseline, sx, sy, origin);
+		case "group":
+		case "none": return;
+		default: return;
+	}
+}
+//#endregion
+//#region src/core/resize-capability.ts
+let resize_capability;
+(function(_resize_capability) {
+	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
+		};
+	}
+	_resize_capability.direction_mask = direction_mask;
+	function is_corner(dir) {
+		return dir === "nw" || dir === "ne" || dir === "se" || dir === "sw";
+	}
+	_resize_capability.is_corner = is_corner;
+	function 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(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
+			};
+		}
+	}
+	_resize_capability.constraint = constraint;
+	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
+			};
+		}
+	}
+	_resize_capability.corner_of_rect = corner_of_rect;
+	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
+			};
+		}
+	}
+	_resize_capability.origin_of_direction = origin_of_direction;
+	function effective(baseline, dir, sx_gesture, sy_gesture) {
+		const bbox = baseline.bbox;
+		const origin = origin_of_direction(bbox, dir);
+		const c = 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
+		};
+	}
+	_resize_capability.effective = effective;
+})(resize_capability || (resize_capability = {}));
+//#endregion
+//#region src/core/resize-pipeline/resize-pipeline.ts
+const XLINK_NS = "http://www.w3.org/1999/xlink";
+let resize_pipeline;
+(function(_resize_pipeline) {
+	let intent;
+	(function(_intent) {
+		function num(doc, id, name, fallback = 0) {
+			return svg_parse.parse_number(doc.get_attr(id, name), fallback);
+		}
+		function is_resizable(tag) {
+			switch (tag) {
+				case "rect":
+				case "image":
+				case "use":
+				case "circle":
+				case "ellipse":
+				case "line":
+				case "polyline":
+				case "polygon":
+				case "path":
+				case "text": return true;
+				default: return false;
+			}
+		}
+		_intent.is_resizable = is_resizable;
+		function capture_baseline(doc, id, bbox) {
+			const tag = doc.tag_of(id);
+			let attrs;
+			switch (tag) {
+				case "rect":
+					attrs = {
+						kind: "rect",
+						x: num(doc, id, "x"),
+						y: num(doc, id, "y"),
+						w: num(doc, id, "width", bbox.width),
+						h: num(doc, id, "height", bbox.height)
+					};
+					break;
+				case "image":
+					attrs = {
+						kind: "image",
+						x: num(doc, id, "x"),
+						y: num(doc, id, "y"),
+						w: num(doc, id, "width", bbox.width),
+						h: num(doc, id, "height", bbox.height)
+					};
+					break;
+				case "use":
+					attrs = {
+						kind: "use",
+						x: num(doc, id, "x"),
+						y: num(doc, id, "y"),
+						w: num(doc, id, "width", bbox.width),
+						h: num(doc, id, "height", bbox.height)
+					};
+					break;
+				case "circle":
+					attrs = {
+						kind: "circle",
+						cx: num(doc, id, "cx"),
+						cy: num(doc, id, "cy"),
+						r: num(doc, id, "r")
+					};
+					break;
+				case "ellipse":
+					attrs = {
+						kind: "ellipse",
+						cx: num(doc, id, "cx"),
+						cy: num(doc, id, "cy"),
+						rx: num(doc, id, "rx"),
+						ry: num(doc, id, "ry")
+					};
+					break;
+				case "line":
+					attrs = {
+						kind: "line",
+						x1: num(doc, id, "x1"),
+						y1: num(doc, id, "y1"),
+						x2: num(doc, id, "x2"),
+						y2: num(doc, id, "y2")
+					};
+					break;
+				case "polyline":
+					attrs = {
+						kind: "polyline",
+						points: doc.get_attr(id, "points") ?? ""
+					};
+					break;
+				case "polygon":
+					attrs = {
+						kind: "polygon",
+						points: doc.get_attr(id, "points") ?? ""
+					};
+					break;
+				case "path":
+					attrs = {
+						kind: "path",
+						d: doc.get_attr(id, "d") ?? ""
+					};
+					break;
+				case "text":
+					attrs = {
+						kind: "text",
+						x: num(doc, id, "x"),
+						y: num(doc, id, "y"),
+						fontSize: parseFloat(doc.get_attr(id, "font-size") ?? "16") || 16
+					};
+					break;
+				default: attrs = { kind: "unsupported" };
+			}
+			return {
+				bbox,
+				attrs
+			};
+		}
+		_intent.capture_baseline = capture_baseline;
+		function compute_factors(baseline, dir, dx, dy, shift) {
+			const b = baseline.bbox;
+			let anchorX = 0;
+			let anchorY = 0;
+			let baseHX = 0;
+			let baseHY = 0;
+			let affectsX = true;
+			let affectsY = true;
+			switch (dir) {
+				case "nw":
+					anchorX = b.x + b.width;
+					anchorY = b.y + b.height;
+					baseHX = b.x;
+					baseHY = b.y;
+					break;
+				case "n":
+					anchorX = b.x + b.width / 2;
+					anchorY = b.y + b.height;
+					baseHX = b.x + b.width / 2;
+					baseHY = b.y;
+					affectsX = false;
+					break;
+				case "ne":
+					anchorX = b.x;
+					anchorY = b.y + b.height;
+					baseHX = b.x + b.width;
+					baseHY = b.y;
+					break;
+				case "e":
+					anchorX = b.x;
+					anchorY = b.y + b.height / 2;
+					baseHX = b.x + b.width;
+					baseHY = b.y + b.height / 2;
+					affectsY = false;
+					break;
+				case "se":
+					anchorX = b.x;
+					anchorY = b.y;
+					baseHX = b.x + b.width;
+					baseHY = b.y + b.height;
+					break;
+				case "s":
+					anchorX = b.x + b.width / 2;
+					anchorY = b.y;
+					baseHX = b.x + b.width / 2;
+					baseHY = b.y + b.height;
+					affectsX = false;
+					break;
+				case "sw":
+					anchorX = b.x + b.width;
+					anchorY = b.y;
+					baseHX = b.x;
+					baseHY = b.y + b.height;
+					break;
+				case "w":
+					anchorX = b.x + b.width;
+					anchorY = b.y + b.height / 2;
+					baseHX = b.x;
+					baseHY = b.y + b.height / 2;
+					affectsY = false;
+					break;
+			}
+			const newHX = baseHX + (affectsX ? dx : 0);
+			const newHY = baseHY + (affectsY ? dy : 0);
+			const denomX = baseHX - anchorX;
+			const denomY = baseHY - anchorY;
+			let sx = affectsX && denomX !== 0 ? (newHX - anchorX) / denomX : 1;
+			let sy = affectsY && denomY !== 0 ? (newHY - anchorY) / denomY : 1;
+			if (shift && affectsX && affectsY) {
+				const mag = Math.max(Math.abs(sx), Math.abs(sy));
+				sx = sx >= 0 ? mag : -mag;
+				sy = sy >= 0 ? mag : -mag;
+			}
+			sx = Math.max(.001, sx);
+			sy = Math.max(.001, sy);
+			return {
+				sx,
+				sy,
+				origin: {
+					x: anchorX,
+					y: anchorY
+				}
+			};
+		}
+		_intent.compute_factors = compute_factors;
+		function bbox_center(points) {
+			if (points.length === 0) return null;
+			const r = cmath.rect.fromPointsOrZero(points.map((p) => [p.x, p.y]));
+			return {
+				cx: r.x + r.width / 2,
+				cy: r.y + r.height / 2
+			};
+		}
+		function new_local_center(doc, id) {
+			switch (doc.tag_of(id)) {
+				case "rect":
+				case "image":
+				case "use": {
+					const x = num(doc, id, "x");
+					const y = num(doc, id, "y");
+					return {
+						cx: x + num(doc, id, "width") / 2,
+						cy: y + num(doc, id, "height") / 2
+					};
+				}
+				case "circle":
+				case "ellipse": return {
+					cx: num(doc, id, "cx"),
+					cy: num(doc, id, "cy")
+				};
+				case "line": {
+					const x1 = num(doc, id, "x1");
+					const y1 = num(doc, id, "y1");
+					const x2 = num(doc, id, "x2");
+					const y2 = num(doc, id, "y2");
+					return {
+						cx: (x1 + x2) / 2,
+						cy: (y1 + y2) / 2
+					};
+				}
+				case "polyline":
+				case "polygon": {
+					const points = doc.get_attr(id, "points");
+					if (!points) return null;
+					return bbox_center(svg_parse.parse_points(points));
+				}
+				case "path": {
+					const d = doc.get_attr(id, "d");
+					if (!d) return null;
+					return bbox_center(hit_shape_svg.path_control_polyline(d));
+				}
+				default: return null;
+			}
+		}
+		function shift_points_string(points, dx, dy) {
+			if (dx === 0 && dy === 0) return points;
+			return svg_parse.parse_points(points).map((p) => `${p.x + dx},${p.y + dy}`).join(" ");
+		}
+		function shift_path_d(d, dx, dy) {
+			if (dx === 0 && dy === 0) return d;
+			try {
+				return new SVGPathData(d).transform(SVGPathDataTransformer.TRANSLATE(dx, dy)).encode();
+			} catch {
+				return d;
+			}
+		}
+		/** Translate every local-frame coord of `id`'s geometry by (dx,
+		*  dy). The primitive arms write intrinsic attrs directly — we
+		*  can't route through `translate_pipeline.intent.apply` here
+		*  because `translate_pipeline.intent.capture_baseline` returns
+		*  `viaTransform` whenever the node has a `transform=`, and that
+		*  branch prepends a `translate()` to the transform string, which
+		*  would clobber the pivot rewrite the caller is about to do. */
+		function shift_geometry(doc, id, dx, dy) {
+			switch (doc.tag_of(id)) {
+				case "rect":
+				case "image":
+				case "use":
+					doc.set_attr(id, "x", String(num(doc, id, "x") + dx));
+					doc.set_attr(id, "y", String(num(doc, id, "y") + dy));
+					return;
+				case "circle":
+				case "ellipse":
+					doc.set_attr(id, "cx", String(num(doc, id, "cx") + dx));
+					doc.set_attr(id, "cy", String(num(doc, id, "cy") + dy));
+					return;
+				case "line":
+					doc.set_attr(id, "x1", String(num(doc, id, "x1") + dx));
+					doc.set_attr(id, "y1", String(num(doc, id, "y1") + dy));
+					doc.set_attr(id, "x2", String(num(doc, id, "x2") + dx));
+					doc.set_attr(id, "y2", String(num(doc, id, "y2") + dy));
+					return;
+				case "polyline":
+				case "polygon": {
+					const points = doc.get_attr(id, "points");
+					if (points) doc.set_attr(id, "points", shift_points_string(points, dx, dy));
+					return;
+				}
+				case "path": {
+					const d = doc.get_attr(id, "d");
+					if (d) doc.set_attr(id, "d", shift_path_d(d, dx, dy));
+					return;
+				}
+			}
+		}
+		function find_rotate_op(ops) {
+			for (const op of ops) if (op.type === "rotate") return op;
+			return null;
+		}
+		/**
+		* Commit-only. Moves the rotate pivot to the new local center and
+		* shifts geometry by δ = (R − I) · Δc so the doc-space rendering
+		* is unchanged. Without the shift, changing the pivot offsets the
+		* rect in doc space and the HUD's stable-matrix chrome falls out
+		* of alignment with the element.
+		*/
+		function renormalize_rotate_pivot(doc, id) {
+			const existing = doc.get_attr(id, "transform");
+			if (existing === null || existing.indexOf("rotate") === -1) return;
+			const ops = transform.parse(existing);
+			if (ops === null) return;
+			const cls = transform.classify(ops);
+			if (cls !== "single_rotate_only" && cls !== "leading_translate_then_single_rotate") return;
+			const rot = find_rotate_op(ops);
+			if (!rot || rot.explicit_pivot !== true) return;
+			const c_pre = new_local_center(doc, id);
+			if (!c_pre) return;
+			const dc_x = c_pre.cx - rot.cx;
+			const dc_y = c_pre.cy - rot.cy;
+			if (dc_x === 0 && dc_y === 0) return;
+			const theta = rot.angle * Math.PI / 180;
+			const cos = Math.cos(theta);
+			const sin = Math.sin(theta);
+			const dx = (cos - 1) * dc_x - sin * dc_y;
+			const dy = sin * dc_x + (cos - 1) * dc_y;
+			shift_geometry(doc, id, dx, dy);
+			const next = transform.recompose(ops, c_pre.cx + dx, c_pre.cy + dy);
+			if (next === existing) return;
+			doc.set_attr(id, "transform", next);
+		}
+		function apply(doc, id, baseline, sx, sy, origin, phase = "commit") {
+			dispatch_resize(doc, id, baseline, sx, sy, origin);
+			if (phase === "commit") renormalize_rotate_pivot(doc, id);
+		}
+		_intent.apply = apply;
+		function replace_href(doc, id, value) {
+			const old_href = doc.get_attr(id, "href");
+			const old_xlink = doc.get_attr(id, "href", XLINK_NS);
+			const write_href = old_href !== null || old_xlink === null;
+			const write_xlink = old_xlink !== null;
+			if (write_href) doc.set_attr(id, "href", value);
+			if (write_xlink) doc.set_attr(id, "href", value, XLINK_NS);
+			return {
+				old_href,
+				old_xlink
+			};
+		}
+		_intent.replace_href = replace_href;
+		function is_resizable_node(doc, id) {
+			if (!is_resizable(doc.tag_of(id))) return false;
+			const ops = transform.parse(doc.get_attr(id, "transform"));
+			if (ops === null) return false;
+			const cls = transform.classify(ops);
+			if (cls === "identity" || cls === "leading_translate_only") return true;
+			if (cls === "single_rotate_only" || cls === "leading_translate_then_single_rotate") return find_rotate_op(ops)?.explicit_pivot === true;
+			return false;
+		}
+		_intent.is_resizable_node = is_resizable_node;
+	})(intent || (intent = _resize_pipeline.intent || (_resize_pipeline.intent = {})));
+	let stages;
+	(function(_stages) {
+		function pipeline_baseline(plan) {
+			return plan.baseline;
+		}
+		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;
+			}
+		}
+		const aspect_lock = _stages.aspect_lock = {
+			name: "aspect_lock",
+			run(plan, ctx) {
+				if (ctx.modifiers.aspect_lock !== "uniform") return { plan };
+				if (!resize_capability.is_corner(plan.direction)) return { plan };
+				const pbase = pipeline_baseline(plan);
+				const locked = intent.compute_factors(pbase, plan.direction, plan.dx, plan.dy, true);
+				const bbox = pbase.bbox;
+				const Hx_base = corner_x_of(bbox, plan.direction);
+				const Hy_base = corner_y_of(bbox, plan.direction);
+				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
+				} };
+			}
+		};
+		const snap = _stages.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 = intent.compute_factors(pbase, plan.direction, plan.dx, plan.dy, false);
+				const eff = resize_capability.effective(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
+				};
+			}
+		};
+		const pixel_grid = _stages.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 = intent.compute_factors(pbase, plan.direction, plan.dx, plan.dy, false);
+				const eff = resize_capability.effective(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
+				} };
+			}
+		};
+		_stages.DEFAULT = Object.freeze([
+			aspect_lock,
+			snap,
+			pixel_grid
+		]);
+	})(stages || (stages = _resize_pipeline.stages || (_resize_pipeline.stages = {})));
+	function run(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
+		};
+	}
+	_resize_pipeline.run = run;
+	function apply(doc, plan, phase = "commit") {
+		const f = intent.compute_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) intent.apply(doc, m.id, m.baseline, f.sx, f.sy, f.origin, phase);
+	}
+	_resize_pipeline.apply = apply;
+	function revert(doc, plan) {
+		const f = intent.compute_factors(plan.baseline, plan.direction, 0, 0, false);
+		const members = plan.members ?? [{
+			id: plan.id,
+			baseline: plan.baseline
+		}];
+		for (const m of members) intent.apply(doc, m.id, m.baseline, 1, 1, f.origin, "preview");
+	}
+	_resize_pipeline.revert = revert;
+	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
+			}
+		};
+	}
+	_resize_pipeline.synthesize_group_baseline = synthesize_group_baseline;
+})(resize_pipeline || (resize_pipeline = {}));
+//#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
+	};
+}
+/** 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 (!resize_pipeline.intent.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 ?? resize_pipeline.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 plan0 = {
+			id: session.primary_id,
+			baseline: session.baseline,
+			members: session.members,
+			direction: session.direction,
+			dx,
+			dy
+		};
+		const ctx = {
+			input: {
+				id: session.primary_id,
+				direction: session.direction,
+				dx,
+				dy
+			},
+			modifiers,
+			options: this.deps.options(),
+			snap_session: session.snap
+		};
+		const result = resize_pipeline.run(plan0, stages, ctx);
+		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: resize_pipeline.intent.capture_baseline(doc, id, this.deps.bbox_world(id))
+		}));
+		const baseline = members.length === 1 ? members[0].baseline : resize_pipeline.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: resize_pipeline.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: () => {
+				resize_pipeline.apply(doc, plan, phase);
+				emit();
+			},
+			revert: () => {
+				resize_pipeline.revert(doc, plan);
+				emit();
+			}
+		});
+	}
+	dispose_session() {
+		if (!this.active) return;
+		this.active.snap?.dispose();
+		this.active = null;
+		this._last_guides = [];
+	}
+};
+//#endregion
+//#region src/core/paint.ts
+let paint;
+(function(_paint) {
+	function parse(declared) {
+		if (declared === null || declared === "") return null;
+		const trimmed = declared.trim();
+		if (trimmed === "") return null;
+		if (trimmed === "inherit" || trimmed === "initial" || trimmed === "unset" || trimmed === "revert" || trimmed === "revert-layer") return null;
+		if (/^var\s*\(/i.test(trimmed)) return {
+			error: "invalid_at_computed_value_time",
+			reason: "var() substitution requires a cascade engine (not implemented)"
+		};
+		if (trimmed === "none") return { kind: "none" };
+		if (trimmed === "context-fill" || trimmed === "contextFill") return { kind: "context_fill" };
+		if (trimmed === "context-stroke" || trimmed === "contextStroke") return { kind: "context_stroke" };
+		const url_match = trimmed.match(/^url\(\s*(["']?)#([^)"']+)\1\s*\)\s*(.*)$/i);
+		if (url_match) {
+			const id = url_match[2];
+			const rest = url_match[3].trim();
+			let fallback;
+			if (rest !== "") {
+				const f = parse(rest);
+				if (f && f.kind === "none") fallback = { kind: "none" };
+				else if (f && f.kind === "color") fallback = {
+					kind: "color",
+					value: f.value
+				};
+			}
+			return fallback ? {
+				kind: "ref",
+				id,
+				fallback
+			} : {
+				kind: "ref",
+				id
+			};
+		}
+		if (/^currentcolor$/i.test(trimmed)) return {
+			kind: "color",
+			value: { kind: "current_color" }
+		};
+		return {
+			kind: "color",
+			value: {
+				kind: "rgb",
+				value: trimmed
+			}
+		};
+	}
+	_paint.parse = parse;
+	function serialize(p) {
+		switch (p.kind) {
+			case "none": return "none";
+			case "context_fill": return "context-fill";
+			case "context_stroke": return "context-stroke";
+			case "color": return p.value.kind === "current_color" ? "currentColor" : p.value.value;
+			case "ref":
+				if (p.fallback) {
+					const f = p.fallback.kind === "none" ? "none" : p.fallback.value.kind === "current_color" ? "currentColor" : p.fallback.value.value;
+					return `url(#${p.id}) ${f}`;
+				}
+				return `url(#${p.id})`;
+		}
+	}
+	_paint.serialize = serialize;
+	function value_equals(a, b) {
+		if (a === b) return true;
+		if (a.declared !== b.declared) return false;
+		if (a.provenance.carrier !== b.provenance.carrier) return false;
+		if (a.provenance.origin !== b.provenance.origin) return false;
+		return computed_equals(a.computed, b.computed);
+	}
+	_paint.value_equals = value_equals;
+	function computed_equals(a, b) {
+		if (a === b) return true;
+		if (a == null || b == null) return false;
+		if ("error" in a || "error" in b) return "error" in a && "error" in b && a.error === b.error && a.reason === b.reason;
+		if (a.kind !== b.kind) return false;
+		if (a.kind === "color" && b.kind === "color") {
+			if (a.value.kind !== b.value.kind) return false;
+			if (a.value.kind === "rgb" && b.value.kind === "rgb") return a.value.value === b.value.value;
+			return true;
+		}
+		if (a.kind === "ref" && b.kind === "ref") return a.id === b.id;
+		if (a.kind === "none" && b.kind === "none") return true;
+		if (a.kind === "context_fill" && b.kind === "context_fill") return true;
+		if (a.kind === "context_stroke" && b.kind === "context_stroke") return true;
+		return false;
+	}
+})(paint || (paint = {}));
+//#endregion
+//#region src/types.ts
+const TOOL_CURSOR = { type: "cursor" };
+const DEFAULT_STYLE = {
+	chrome_color: "#2563eb",
+	handle_size: 8,
+	handle_fill: "#ffffff",
+	handle_stroke: "#2563eb",
+	endpoint_dot_radius: 5,
+	selection_outline_width: 2,
+	measurement_color: "#ff3a30",
+	show_size_meter: true,
+	snap_enabled: true,
+	snap_threshold_px: 6,
+	hit_tolerance_px: 0,
+	snap_to_pixel_grid: false,
+	pixel_grid_size: 1,
+	pixel_grid: true,
+	angle_snap_step_radians: Math.PI / 12
+};
+//#endregion
+//#region src/core/insertions.ts
+let insertions;
+(function(_insertions) {
+	const DEFAULT_SIZE = _insertions.DEFAULT_SIZE = 100;
+	const DEFAULT_FILL = _insertions.DEFAULT_FILL = "#D9D9D9";
+	function initial_attrs(tag, point) {
+		switch (tag) {
+			case "rect": return {
+				x: fmt(point.x),
+				y: fmt(point.y),
+				width: "0",
+				height: "0"
+			};
+			case "ellipse": return {
+				cx: fmt(point.x),
+				cy: fmt(point.y),
+				rx: "0",
+				ry: "0"
+			};
+			case "line": return {
+				x1: fmt(point.x),
+				y1: fmt(point.y),
+				x2: fmt(point.x),
+				y2: fmt(point.y)
+			};
+		}
+	}
+	_insertions.initial_attrs = initial_attrs;
+	function default_attrs(tag, point, size = DEFAULT_SIZE) {
+		switch (tag) {
+			case "rect": return {
+				x: fmt(point.x - size / 2),
+				y: fmt(point.y - size / 2),
+				width: fmt(size),
+				height: fmt(size)
+			};
+			case "ellipse": return {
+				cx: fmt(point.x),
+				cy: fmt(point.y),
+				rx: fmt(size / 2),
+				ry: fmt(size / 2)
+			};
+			case "line": return {
+				x1: fmt(point.x - size / 2),
+				y1: fmt(point.y),
+				x2: fmt(point.x + size / 2),
+				y2: fmt(point.y)
+			};
+		}
+	}
+	_insertions.default_attrs = default_attrs;
+	function compute_drag_attrs(tag, anchor, current, modifiers) {
+		switch (tag) {
+			case "rect": return rect_attrs(anchor, current, modifiers);
+			case "ellipse": return ellipse_attrs(anchor, current, modifiers);
+			case "line": return line_attrs(anchor, current, modifiers);
+		}
+	}
+	_insertions.compute_drag_attrs = compute_drag_attrs;
+	function default_paint_attrs(tag) {
+		switch (tag) {
+			case "rect":
+			case "ellipse": return { fill: DEFAULT_FILL };
+			case "line": return {
+				stroke: "#000000",
+				"stroke-width": "1"
+			};
+		}
+	}
+	_insertions.default_paint_attrs = default_paint_attrs;
+	const DEFAULT_TEXT_FONT_SIZE = _insertions.DEFAULT_TEXT_FONT_SIZE = 16;
+	const DEFAULT_TEXT_FONT_FAMILY = _insertions.DEFAULT_TEXT_FONT_FAMILY = "sans-serif";
+	const DEFAULT_TEXT_FILL = _insertions.DEFAULT_TEXT_FILL = "#000000";
+	function default_text_attrs(point) {
+		return {
+			x: fmt(point.x),
+			y: fmt(point.y),
+			"font-size": String(DEFAULT_TEXT_FONT_SIZE),
+			"font-family": DEFAULT_TEXT_FONT_FAMILY,
+			fill: DEFAULT_TEXT_FILL
+		};
+	}
+	_insertions.default_text_attrs = default_text_attrs;
+	function rect_attrs(anchor, current, mods) {
+		let dx = current.x - anchor.x;
+		let dy = current.y - anchor.y;
+		if (mods.shift) {
+			const m = Math.max(Math.abs(dx), Math.abs(dy));
+			dx = dx < 0 ? -m : m;
+			dy = dy < 0 ? -m : m;
+		}
+		let x;
+		let y;
+		let w;
+		let h;
+		if (mods.alt) {
+			x = anchor.x - Math.abs(dx);
+			y = anchor.y - Math.abs(dy);
+			w = Math.abs(dx) * 2;
+			h = Math.abs(dy) * 2;
+		} else {
+			x = Math.min(anchor.x, anchor.x + dx);
+			y = Math.min(anchor.y, anchor.y + dy);
+			w = Math.abs(dx);
+			h = Math.abs(dy);
+		}
+		return {
+			x: fmt(x),
+			y: fmt(y),
+			width: fmt(w),
+			height: fmt(h)
+		};
+	}
+	function ellipse_attrs(anchor, current, mods) {
+		let dx = current.x - anchor.x;
+		let dy = current.y - anchor.y;
+		if (mods.shift) {
+			const m = Math.max(Math.abs(dx), Math.abs(dy));
+			dx = dx < 0 ? -m : m;
+			dy = dy < 0 ? -m : m;
+		}
+		let cx;
+		let cy;
+		let rx;
+		let ry;
+		if (mods.alt) {
+			cx = anchor.x;
+			cy = anchor.y;
+			rx = Math.abs(dx);
+			ry = Math.abs(dy);
+		} else {
+			cx = anchor.x + dx / 2;
+			cy = anchor.y + dy / 2;
+			rx = Math.abs(dx) / 2;
+			ry = Math.abs(dy) / 2;
+		}
+		return {
+			cx: fmt(cx),
+			cy: fmt(cy),
+			rx: fmt(rx),
+			ry: fmt(ry)
+		};
+	}
+	function line_attrs(anchor, current, mods) {
+		let dx = current.x - anchor.x;
+		let dy = current.y - anchor.y;
+		if (mods.shift) {
+			const len = Math.hypot(dx, dy);
+			if (len > 0) {
+				const angle = Math.atan2(dy, dx);
+				const step = Math.PI / 4;
+				const quantized = Math.round(angle / step) * step;
+				dx = Math.cos(quantized) * len;
+				dy = Math.sin(quantized) * len;
+			}
+		}
+		let x1;
+		let y1;
+		let x2;
+		let y2;
+		if (mods.alt) {
+			x1 = anchor.x - dx;
+			y1 = anchor.y - dy;
+			x2 = anchor.x + dx;
+			y2 = anchor.y + dy;
+		} else {
+			x1 = anchor.x;
+			y1 = anchor.y;
+			x2 = anchor.x + dx;
+			y2 = anchor.y + dy;
+		}
+		return {
+			x1: fmt(x1),
+			y1: fmt(y1),
+			x2: fmt(x2),
+			y2: fmt(y2)
+		};
+	}
+	/** Format a numeric value for SVG attr output. Rounds to 4 decimals
+	*  to suppress IEEE-754 noise (`0.30000000000000004` → `0.3`);
+	*  `String()` drops trailing zeros and the decimal point for
+	*  integers. */
+	function fmt(n) {
+		return String(Math.round(n * 1e4) / 1e4);
+	}
+})(insertions || (insertions = {}));
+//#endregion
+//#region src/core/vector-edit/model.ts
+/**
+* Canonical vector-network model for a single SVG path's `d` string.
+*
+* `PathModel` is a self-contained geometry primitive — it parses an SVG
+* path `d` into a vertex/segment graph (with verb hints preserved for
+* round-trip honesty), exposes POJO observers, and serializes back to
+* `d`. It does not hold or reference an `SvgDocument`, an editor
+* instance, the DOM, or any host. It is safe to construct in any
+* environment that can run the package.
+*
+* Public re-exported as a top-level Layer-A primitive from
+* `@grida/svg-editor` for callers that want canonical path geometry
+* without mounting an editor. The full mutation surface (translate /
+* bend / set-tangent / split, etc.) is package-internal and may shift;
+* the publicly-stable contract for external callers is the construction
+* + serialization + observation methods documented at the entry point.
+*
+* @experimental Surface shape is v0; signatures may change before the
+* package reaches semver stability.
+*/
+var PathModel = class PathModel {
+	constructor(network, meta) {
+		if (network.segments.length !== meta.length) throw new Error(`PathModel invariant violated: segments(${network.segments.length}) !== meta(${meta.length})`);
+		this._network = network;
+		this._meta = meta;
+	}
+	static fromSvgPathD(d) {
+		const { network, meta } = parseWithVerbs(d);
+		return new PathModel(network, meta);
+	}
+	/** Construct from a vn network with no verb info (every segment defaults to undefined verb). */
+	static fromVectorNetwork(network) {
+		const meta = network.segments.map(() => ({}));
+		return new PathModel(cloneNetwork(network), meta);
+	}
+	toSvgPathD() {
+		return emitWithVerbs(this._network, this._meta);
+	}
+	snapshot() {
+		return {
+			vertices: this._network.vertices,
+			segments: this._network.segments.map((seg, i) => ({
+				a: seg.a,
+				b: seg.b,
+				ta: seg.ta,
+				tb: seg.tb,
+				source_verb: this._meta[i]?.source_verb
+			}))
+		};
+	}
+	bbox() {
+		return new vn.VectorNetworkEditor(this._network).getBBox();
+	}
+	vertexCount() {
+		return this._network.vertices.length;
+	}
+	segmentCount() {
+		return this._network.segments.length;
+	}
+	/**
+	* If the model's current geometry is still expressible in the source
+	* SVG tag's native attribute form, return the equivalent
+	* `VectorEditSource` (which is also the writeable shape) — else `null`.
+	*
+	* This is the decider that gates per-gesture native-attrs writeback in
+	* `VectorEditSession.apply_d`. `null` means "the user's edit cannot be
+	* faithfully written back to the source tag" — in v1 with no
+	* promotion, the gesture is refused; in v1.1+ with promotion, the
+	* element is rewritten to `<path d="…">`.
+	*
+	* v1 expressibility (all source kinds require every segment's `ta` and
+	* `tb` to be exactly zero — any tangent edit forces promotion):
+	*
+	* - **path** — always `null` (no native fallback; the canonical form
+	*   IS `<path d>`, so callers should just write `d` directly).
+	* - **polyline** — segments form the canonical open chain
+	*   `0→1, 1→2, …, (n-2)→(n-1)`. (Topology after `vn.fromPolyline` and
+	*   any sequence of vertex translates.)
+	* - **polygon** — segments form the canonical closed chain
+	*   `0→1, 1→2, …, (n-1)→0`. (Topology after `vn.fromPolygon` and any
+	*   sequence of vertex translates.)
+	*
+	* Anything that changes segment topology (insert-vertex, delete-vertex,
+	* close/open shape) leaves the canonical chain and returns `null` here;
+	* the higher layer is responsible for routing those to tag-promotion
+	* (intra-Vertex or to-path).
+	*/
+	toNativeAttrs(source_tag) {
+		if (source_tag === "path") return null;
+		const { vertices, segments } = this._network;
+		for (const s of segments) {
+			if (s.ta[0] !== 0 || s.ta[1] !== 0) return null;
+			if (s.tb[0] !== 0 || s.tb[1] !== 0) return null;
+		}
+		const n = vertices.length;
+		if (source_tag === "polyline") {
+			if (segments.length !== n - 1 || n < 2) return null;
+			for (let i = 0; i < segments.length; i++) {
+				const s = segments[i];
+				if (s.a !== i || s.b !== i + 1) return null;
+			}
+			return {
+				kind: "polyline",
+				points: vertices.map((v) => [v[0], v[1]])
+			};
+		}
+		if (source_tag === "polygon") {
+			if (segments.length !== n || n < 2) return null;
+			for (let i = 0; i < segments.length - 1; i++) {
+				const s = segments[i];
+				if (s.a !== i || s.b !== i + 1) return null;
+			}
+			const closer = segments[segments.length - 1];
+			if (closer.a !== n - 1 || closer.b !== 0) return null;
+			return {
+				kind: "polygon",
+				points: vertices.map((v) => [v[0], v[1]])
+			};
+		}
+		return null;
+	}
+	/** Translate one vertex by `delta`. Connected segments follow because
+	*  tangents are stored relative to vertices. Verb metadata is preserved
+	*  as-is; emit-time honesty handles cases where the shape no longer
+	*  matches the recorded verb (e.g. an H whose endpoint y-coord drifts). */
+	translateVertex(v, delta) {
+		if (v < 0 || v >= this._network.vertices.length) throw new Error(`PathModel.translateVertex: invalid vertex ${v}`);
+		const next_network = cloneNetwork(this._network);
+		const vne = new vn.VectorNetworkEditor(next_network);
+		vne.translateVertex(v, [delta[0], delta[1]]);
+		return new PathModel(vne.value, this._meta);
+	}
+	/** Bulk-translate a set of vertices by the same delta. Atomic — either
+	*  every move succeeds or none (input is validated up-front). */
+	translateVertices(indices, delta) {
+		if (indices.length === 0) return this;
+		for (const v of indices) if (v < 0 || v >= this._network.vertices.length) throw new Error(`PathModel.translateVertices: invalid vertex ${v}`);
+		const next_network = cloneNetwork(this._network);
+		const vne = new vn.VectorNetworkEditor(next_network);
+		for (const v of indices) vne.translateVertex(v, [delta[0], delta[1]]);
+		return new PathModel(vne.value, this._meta);
+	}
+	/** Translate one segment by `delta` — moves both endpoints, dragging
+	*  their tangents along (tangents are stored relative to vertices, so
+	*  this is automatic). Other segments connected to the moved endpoints
+	*  also follow at the shared vertex. */
+	translateSegment(seg, delta) {
+		if (seg < 0 || seg >= this._network.segments.length) throw new Error(`PathModel.translateSegment: invalid segment ${seg}`);
+		const s = this._network.segments[seg];
+		const unique = s.a === s.b ? [s.a] : [s.a, s.b];
+		return this.translateVertices(unique, delta);
+	}
+	/**
+	* Bend a curve segment by dragging a point at parameter `ca` to `cb`
+	* (cb is in absolute doc-space). Delegates to vn's `bendSegment` —
+	* which solves for the new ta/tb that put `B(ca) === cb`, holding the
+	* endpoints fixed.
+	*
+	* The "frozen" snapshot of the segment at gesture start is the caller's
+	* responsibility. Convention: call this from a preview session where
+	* each frame replays from the baseline (same pattern as translate).
+	*/
+	bendSegment(seg, ca, cb, frozen) {
+		if (seg < 0 || seg >= this._network.segments.length) throw new Error(`PathModel.bendSegment: invalid segment ${seg}`);
+		const next_network = cloneNetwork(this._network);
+		const vne = new vn.VectorNetworkEditor(next_network);
+		vne.bendSegment(seg, ca, [cb[0], cb[1]], {
+			a: [frozen.a[0], frozen.a[1]],
+			b: [frozen.b[0], frozen.b[1]],
+			ta: [frozen.ta[0], frozen.ta[1]],
+			tb: [frozen.tb[0], frozen.tb[1]]
+		});
+		return new PathModel(vne.value, this._meta);
+	}
+	/**
+	* Move one tangent control point to a new absolute position. Mirror
+	* policy follows vn's `updateTangent`. The other tangent at the same
+	* vertex is updated according to the policy.
+	*
+	* Returns a new PathModel; verb metadata is preserved verbatim.
+	* `toSvgPathD` will demote (e.g. L → C) if the new tangents make the
+	* recorded verb no longer match the geometry.
+	*/
+	setTangent(t, abs_pos, mirror = "auto") {
+		const located = this._locateTangent(t);
+		if (!located) throw new Error(`PathModel.setTangent: no segment found for tangent [${t[0]}, ${t[1]}]`);
+		const { seg_index, control } = located;
+		const seg = this._network.segments[seg_index];
+		const anchor_idx = control === "ta" ? seg.a : seg.b;
+		const anchor = this._network.vertices[anchor_idx];
+		const value = [abs_pos[0] - anchor[0], abs_pos[1] - anchor[1]];
+		const next_network = cloneNetwork(this._network);
+		const vne = new vn.VectorNetworkEditor(next_network);
+		vne.updateTangent(seg_index, control, value, mirror);
+		return new PathModel(vne.value, this._meta);
+	}
+	/**
+	* Split segment `seg` at parametric position `t ∈ [0,1]`, inserting a
+	* new vertex. Returns the new model and the **canonical (path-order)**
+	* index of the inserted vertex.
+	*
+	* Verb metadata for the split: the original segment's verb propagates
+	* to BOTH halves if it was a curve type (`C`/`S`/`Q`/`T`/`A`); for
+	* straight verbs (`L`/`H`/`V`), the split halves stay straight (their
+	* tangents are zero from vn's `preserveZero` path when both originals
+	* were zero). Arc-group identity is dropped from the halves — the
+	* arc is broken once split (the emitter will fall back to `C`/`L`).
+	*
+	* **Index space contract.** `VectorNetworkEditor.splitSegment` APPENDS
+	* the new vertex at the end of the network's vertices array — its
+	* index is the in-memory insertion order. But `toSvgPathD` / `fromSvgPathD`
+	* canonicalize vertices in path order, so the same vertex gets a
+	* DIFFERENT index in the d-derived model that consumers re-parse each
+	* frame (e.g., the host's `handle_translate_vertices`). Returning the
+	* insertion-order index causes the classic split-and-drag bug: the
+	* surface holds index N (insertion-order) but the live model has
+	* index M (path-order) at that position — drag moves the wrong vertex
+	* and the user sees "split happened but the new vertex doesn't move".
+	*
+	* To prevent that, we round-trip the post-split model through
+	* `toSvgPathD` → `fromSvgPathD` and return the canonical (path-order)
+	* index of the new vertex. The returned `model` is the canonical
+	* one, so any subsequent op on it uses the same index space the d
+	* roundtrip exposes. See `__tests__/README.md` §"index identity
+	* across the `d` round-trip" for the test pattern that pins this.
+	*/
+	splitSegment(seg, t) {
+		if (seg < 0 || seg >= this._network.segments.length) throw new Error(`PathModel.splitSegment: invalid segment ${seg}`);
+		const next_network = cloneNetwork(this._network);
+		const vne = new vn.VectorNetworkEditor(next_network);
+		const in_memory_new_vertex = vne.splitSegment({
+			segment: seg,
+			t
+		});
+		const orig = this._meta[seg];
+		const half = { source_verb: orig?.source_verb };
+		const half_first = { ...half };
+		const half_second = {
+			...half,
+			is_close_segment: orig?.is_close_segment
+		};
+		const next_meta = [
+			...this._meta.slice(0, seg),
+			half_first,
+			half_second,
+			...this._meta.slice(seg + 1)
+		];
+		const new_vertex_pos = vne.value.vertices[in_memory_new_vertex];
+		const target_d = new PathModel(vne.value, next_meta).toSvgPathD();
+		const canonical_model = PathModel.fromSvgPathD(target_d);
+		const canonical_vertices = canonical_model._network.vertices;
+		let canonical_new_vertex = -1;
+		for (let i = 0; i < canonical_vertices.length; i++) {
+			const v = canonical_vertices[i];
+			if (Math.abs(v[0] - new_vertex_pos[0]) < 1e-9 && Math.abs(v[1] - new_vertex_pos[1]) < 1e-9) {
+				canonical_new_vertex = i;
+				break;
+			}
+		}
+		if (canonical_new_vertex < 0) canonical_new_vertex = in_memory_new_vertex;
+		return {
+			model: canonical_model,
+			new_vertex: canonical_new_vertex
+		};
+	}
+	/**
+	* Doc-space position of a tangent control point. `t` references a
+	* segment and which end (`a` or `b`) the tangent belongs to; the
+	* result is `vertex + tangent_value + origin`. Returns null if no
+	* segment has this tangent (e.g. the vertex is isolated).
+	*/
+	tangentAbsolute(t, origin) {
+		const located = this._locateTangent(t);
+		if (!located) return null;
+		const { seg_index, control } = located;
+		const seg = this._network.segments[seg_index];
+		const anchor_idx = control === "ta" ? seg.a : seg.b;
+		const anchor = this._network.vertices[anchor_idx];
+		const value = control === "ta" ? seg.ta : seg.tb;
+		return [anchor[0] + value[0] + origin[0], anchor[1] + value[1] + origin[1]];
+	}
+	/**
+	* Vertices "neighbouring" the current selection — these are the
+	* vertices whose tangent handles should render in chrome.
+	*
+	* Two-phase, mirrors `editor/grida-canvas/reducers/methods/vector.ts`
+	* `getUXNeighbouringVertices`:
+	*
+	*   1. Collect "active" vertices:
+	*      - every selected vertex
+	*      - every tangent-owning vertex
+	*      - both endpoints of every selected segment
+	*   2. Expand uniformly to 1-hop neighbours (vertices sharing a segment
+	*      with any active vertex).
+	*
+	* Without phase 2 for tangent / segment selections, selecting only a
+	* tangent would hide neighbouring-vertex tangents — the user loses
+	* spatial context. Phase 2 makes the affordance symmetric: whatever
+	* triggered selection, the 1-hop ring of tangent handles is visible.
+	*
+	* Sorted ascending; deduped.
+	*/
+	neighbouringVertices(sel) {
+		const { vertices, segments } = this._network;
+		const active = /* @__PURE__ */ new Set();
+		const add_if_valid = (v) => {
+			if (v >= 0 && v < vertices.length) active.add(v);
+		};
+		for (const v of sel.vertices) add_if_valid(v);
+		for (const seg_idx of sel.segments) {
+			if (seg_idx < 0 || seg_idx >= segments.length) continue;
+			const s = segments[seg_idx];
+			add_if_valid(s.a);
+			add_if_valid(s.b);
+		}
+		for (const t of sel.tangents) {
+			const located = this._locateTangent(t);
+			if (!located) continue;
+			add_if_valid(t[0]);
+			const s = segments[located.seg_index];
+			add_if_valid(s.a);
+			add_if_valid(s.b);
+		}
+		const out = new Set(active);
+		if (active.size > 0) {
+			const vne = new vn.VectorNetworkEditor(this._network);
+			for (const v of active) for (const n of vne.getNeighboringVerticies(v)) if (n >= 0 && n < vertices.length) out.add(n);
+		}
+		return Array.from(out).sort((x, y) => x - y);
+	}
+	/**
+	* True iff segment `seg`'s curve is entirely contained in the rect.
+	* Delegates to `cmath.bezier.containedByRect`.
+	*/
+	segmentContainedByRect(seg, rect, origin = [0, 0]) {
+		if (seg < 0 || seg >= this._network.segments.length) return false;
+		const s = this._network.segments[seg];
+		const a = this._network.vertices[s.a];
+		const b = this._network.vertices[s.b];
+		const local_rect = {
+			x: rect.x - origin[0],
+			y: rect.y - origin[1],
+			width: rect.width,
+			height: rect.height
+		};
+		return cmath.bezier.containedByRect([a[0], a[1]], [b[0], b[1]], [s.ta[0], s.ta[1]], [s.tb[0], s.tb[1]], local_rect);
+	}
+	/** @internal */
+	_rawNetwork() {
+		return this._network;
+	}
+	/** @internal */
+	_rawMeta() {
+		return this._meta;
+	}
+	/**
+	* Map a `TangentRef` to a concrete `(segment_index, control)` pair.
+	*
+	* `[v, 0]` → first segment whose `a === v` (its `ta`).
+	* `[v, 1]` → first segment whose `b === v` (its `tb`).
+	*
+	* Y-junctions (multi-outgoing or multi-incoming) are uncommon for SVG
+	* `<path>` content; v1 picks the first match. If we ever support those
+	* cleanly, extend `TangentRef` to carry the segment id explicitly.
+	*/
+	_locateTangent(t) {
+		const [vertex_idx, end] = t;
+		const segs = this._network.segments;
+		for (let i = 0; i < segs.length; i++) {
+			const s = segs[i];
+			if (end === 0 && s.a === vertex_idx) return {
+				seg_index: i,
+				control: "ta"
+			};
+			if (end === 1 && s.b === vertex_idx) return {
+				seg_index: i,
+				control: "tb"
+			};
+		}
+		return null;
+	}
+};
+function cloneNetwork(net) {
+	return {
+		vertices: net.vertices.map((v) => [v[0], v[1]]),
+		segments: net.segments.map((s) => ({
+			a: s.a,
+			b: s.b,
+			ta: [s.ta[0], s.ta[1]],
+			tb: [s.tb[0], s.tb[1]]
+		}))
+	};
+}
+/**
+* Walks the SVG path commands once, building the vn network AND a parallel
+* `meta` array. Mirrors the structure of `vn.fromSVGPathData` but tags each
+* emitted segment with its originating verb. The two stay logically in lock-
+* step: every segment vn would push, we push one meta entry for.
+*/
+function parseWithVerbs(d) {
+	const commands = new SVGPathData(d).toAbs().commands;
+	const vne = new vn.VectorNetworkEditor();
+	const meta = [];
+	let last_point = null;
+	let last_quadratic_control = null;
+	/** Vertex index of the current point. Tracked explicitly because
+	*  `vne.addVertex` reuses an existing vertex when the coordinate matches,
+	*  so `vne.vertices.length - 1` is NOT reliable for "current vertex." */
+	let current_idx = -1;
+	/** Vertex index of the current subpath's start (set on M). */
+	let subpath_start_idx = -1;
+	/** Monotonic counter for arc groups. */
+	let arc_group_seq = 0;
+	const pushSegmentMeta = (entry) => {
+		meta.push(entry);
+	};
+	for (const command of commands) {
+		const { type } = command;
+		switch (type) {
+			case SVGPathData.MOVE_TO: {
+				const { x, y } = command;
+				current_idx = vne.addVertex([x, y]);
+				subpath_start_idx = current_idx;
+				last_point = [x, y];
+				last_quadratic_control = null;
+				break;
+			}
+			case SVGPathData.LINE_TO: {
+				const { x, y } = command;
+				if (last_point) {
+					current_idx = vne.addVertex([x, y], current_idx);
+					pushSegmentMeta({ source_verb: "L" });
+				}
+				last_point = [x, y];
+				last_quadratic_control = null;
+				break;
+			}
+			case SVGPathData.HORIZ_LINE_TO: {
+				const { x } = command;
+				if (last_point) {
+					current_idx = vne.addVertex([x, last_point[1]], current_idx);
+					pushSegmentMeta({ source_verb: "H" });
+				}
+				last_point = [x, last_point ? last_point[1] : 0];
+				last_quadratic_control = null;
+				break;
+			}
+			case SVGPathData.VERT_LINE_TO: {
+				const { y } = command;
+				if (last_point) {
+					current_idx = vne.addVertex([last_point[0], y], current_idx);
+					pushSegmentMeta({ source_verb: "V" });
+				}
+				last_point = [last_point ? last_point[0] : 0, y];
+				last_quadratic_control = null;
+				break;
+			}
+			case SVGPathData.CURVE_TO: {
+				const { x, y } = command;
+				if (last_point) {
+					const ta = [command.x1 - last_point[0], command.y1 - last_point[1]];
+					const tb = [command.x2 - x, command.y2 - y];
+					current_idx = vne.addVertex([x, y], current_idx, ta, tb);
+					pushSegmentMeta({ source_verb: "C" });
+				}
+				last_point = [x, y];
+				last_quadratic_control = null;
+				break;
+			}
+			case SVGPathData.SMOOTH_CURVE_TO: {
+				const { x, y, x2, y2 } = command;
+				if (last_point) {
+					const ta = vne.getNextMirroredTangent(current_idx);
+					const tb = [x2 - x, y2 - y];
+					current_idx = vne.addVertex([x, y], current_idx, ta, tb);
+					pushSegmentMeta({ source_verb: "S" });
+				}
+				last_point = [x, y];
+				last_quadratic_control = null;
+				break;
+			}
+			case SVGPathData.QUAD_TO:
+				if (last_point) {
+					const control = [command.x1, command.y1];
+					const end = [command.x, command.y];
+					const ta = [2 / 3 * (control[0] - last_point[0]), 2 / 3 * (control[1] - last_point[1])];
+					const tb = [2 / 3 * (control[0] - end[0]), 2 / 3 * (control[1] - end[1])];
+					current_idx = vne.addVertex(end, current_idx, ta, tb);
+					pushSegmentMeta({ source_verb: "Q" });
+					last_point = end;
+					last_quadratic_control = control;
+				}
+				break;
+			case SVGPathData.SMOOTH_QUAD_TO:
+				if (last_point) {
+					const end = [command.x, command.y];
+					const control = last_quadratic_control ? [2 * last_point[0] - last_quadratic_control[0], 2 * last_point[1] - last_quadratic_control[1]] : [last_point[0], last_point[1]];
+					const ta = [2 / 3 * (control[0] - last_point[0]), 2 / 3 * (control[1] - last_point[1])];
+					const tb = [2 / 3 * (control[0] - end[0]), 2 / 3 * (control[1] - end[1])];
+					current_idx = vne.addVertex(end, current_idx, ta, tb);
+					pushSegmentMeta({ source_verb: "T" });
+					last_point = end;
+					last_quadratic_control = control;
+				}
+				break;
+			case SVGPathData.ARC: {
+				const { rX, rY, xRot, lArcFlag, sweepFlag, x, y } = command;
+				if (last_point) {
+					const [x1, y1] = last_point;
+					const curves = cmath.bezier.a2c(x1, y1, rX, rY, xRot, lArcFlag, sweepFlag, x, y);
+					const seg_count = curves.length / 6;
+					const group_id = ++arc_group_seq;
+					let current_point = last_point;
+					let seq = 0;
+					for (let i = 0; i < curves.length; i += 6) {
+						const [cx1, cy1, cx2, cy2, ex, ey] = curves.slice(i, i + 6);
+						const end_point = [ex, ey];
+						const ta = [cx1 - current_point[0], cy1 - current_point[1]];
+						const tb = [cx2 - end_point[0], cy2 - end_point[1]];
+						current_idx = vne.addVertex(end_point, current_idx, ta, tb);
+						const is_last = seq === seg_count - 1;
+						pushSegmentMeta({
+							source_verb: "A",
+							arc: {
+								group_id,
+								rx: rX,
+								ry: rY,
+								x_rot: xRot,
+								large_arc_flag: lArcFlag,
+								sweep_flag: sweepFlag,
+								baseline_ta: [ta[0], ta[1]],
+								baseline_tb: [tb[0], tb[1]],
+								baseline_b_abs: [end_point[0], end_point[1]],
+								seq,
+								count: seg_count,
+								original_end: is_last ? [x, y] : void 0
+							}
+						});
+						current_point = end_point;
+						seq++;
+					}
+					last_point = current_point;
+				}
+				last_quadratic_control = null;
+				break;
+			}
+			case SVGPathData.CLOSE_PATH:
+				if (current_idx !== -1 && subpath_start_idx !== -1 && current_idx !== subpath_start_idx) {
+					vne.addSegment(current_idx, subpath_start_idx);
+					pushSegmentMeta({
+						source_verb: "Z",
+						is_close_segment: true
+					});
+					current_idx = subpath_start_idx;
+					last_point = vne.vertices[subpath_start_idx];
+				} else if (current_idx !== -1 && current_idx === subpath_start_idx && meta.length > 0) {
+					const last_seg = vne.segments[vne.segments.length - 1];
+					if (last_seg && last_seg.b === subpath_start_idx) meta[meta.length - 1] = {
+						...meta[meta.length - 1],
+						is_close_segment: true
+					};
+				}
+				last_quadratic_control = null;
+				break;
+			default: throw new Error(`Unsupported path command type: ${type}`);
+		}
+	}
+	return {
+		network: vne.value,
+		meta
+	};
+}
+const EPSILON = 1e-9;
+function approxEqual(a, b, eps = EPSILON) {
+	return Math.abs(a - b) <= eps;
+}
+function vec2Equal(a, b, eps = EPSILON) {
+	return approxEqual(a[0], b[0], eps) && approxEqual(a[1], b[1], eps);
+}
+function isZeroTangent(t) {
+	return approxEqual(t[0], 0) && approxEqual(t[1], 0);
+}
+/**
+* Returns true iff the segment's tangents are consistent with a single
+* quadratic Bézier control point at ratio 2/3 (i.e. the segment was emitted
+* from a `Q` or `T` command and has not been edited).
+*
+* For a quadratic with start=A, end=B, control=C:
+*   ta = 2/3 * (C - A)  =>  C = A + (3/2) * ta
+*   tb = 2/3 * (C - B)  =>  C = B + (3/2) * tb
+* Both must yield the same C.
+*/
+function tangentsRepresentQuadratic(a, b, ta, tb) {
+	const c_from_a = [a[0] + 1.5 * ta[0], a[1] + 1.5 * ta[1]];
+	if (vec2Equal(c_from_a, [b[0] + 1.5 * tb[0], b[1] + 1.5 * tb[1]], 1e-6)) return {
+		ok: true,
+		control: c_from_a
+	};
+	return { ok: false };
+}
+/**
+* Returns true iff `ta` mirrors the previous segment's `tb` (i.e. the
+* vertex is a smooth join — what `S`/`T` commands require).
+*
+* For `ta` at vertex V (segment a=V) to mirror previous segment's `tb`
+* (whose b=V), we need: ta == -prev.tb (both expressed relative to V).
+*/
+function isSmoothJoin(prev_tb, curr_ta) {
+	return vec2Equal([curr_ta[0], curr_ta[1]], [-prev_tb[0], -prev_tb[1]], 1e-6);
+}
+/**
+* Determines whether an arc-group's segments are byte-equal to their parse-
+* time baselines. If any segment in the group has been edited (vertex moved,
+* tangent changed), the entire arc must be promoted to C.
+*/
+function isArcGroupUnchanged(segments, meta, vertices, group_id) {
+	for (let i = 0; i < segments.length; i++) {
+		const m = meta[i];
+		if (m?.arc?.group_id !== group_id) continue;
+		const seg = segments[i];
+		if (!vec2Equal(seg.ta, m.arc.baseline_ta)) return false;
+		if (!vec2Equal(seg.tb, m.arc.baseline_tb)) return false;
+		if (!vec2Equal(vertices[seg.b], m.arc.baseline_b_abs)) return false;
+	}
+	return true;
+}
+function emitWithVerbs(network, meta) {
+	const { vertices, segments } = network;
+	if (segments.length === 0) return "";
+	const commands = [];
+	const arc_unchanged = /* @__PURE__ */ new Map();
+	const arcStillValid = (group_id) => {
+		const cached = arc_unchanged.get(group_id);
+		if (cached !== void 0) return cached;
+		const ok = isArcGroupUnchanged(segments, meta, vertices, group_id);
+		arc_unchanged.set(group_id, ok);
+		return ok;
+	};
+	let current_start = null;
+	let previous_end = null;
+	let prev_segment_tb = null;
+	/** When true, the previous segment was emitted as a quadratic (Q or T) and `prev_quad_control` is valid. */
+	let prev_quad_control = null;
+	/** Skip the next K iterations because we already emitted an arc for them. */
+	let skip_to_index = -1;
+	for (let i = 0; i < segments.length; i++) {
+		if (i < skip_to_index) continue;
+		const segment = segments[i];
+		const m = meta[i] ?? {};
+		const { a, b, ta, tb } = segment;
+		const start = vertices[a];
+		const end = vertices[b];
+		if (previous_end !== a) {
+			commands.push({
+				type: SVGPathData.MOVE_TO,
+				x: start[0],
+				y: start[1],
+				relative: false
+			});
+			current_start = a;
+			prev_segment_tb = null;
+			prev_quad_control = null;
+		}
+		const is_straight = isZeroTangent(ta) && isZeroTangent(tb);
+		const is_closing = m.is_close_segment === true && current_start !== null && b === current_start;
+		if (m.arc && m.source_verb === "A" && arcStillValid(m.arc.group_id)) {
+			let last_idx = i;
+			while (last_idx + 1 < segments.length && meta[last_idx + 1]?.arc?.group_id === m.arc.group_id) last_idx++;
+			const last_seg = segments[last_idx];
+			const last_end = meta[last_idx]?.arc?.original_end ?? vertices[last_seg.b];
+			commands.push({
+				type: SVGPathData.ARC,
+				rX: m.arc.rx,
+				rY: m.arc.ry,
+				xRot: m.arc.x_rot,
+				lArcFlag: m.arc.large_arc_flag,
+				sweepFlag: m.arc.sweep_flag,
+				x: last_end[0],
+				y: last_end[1],
+				relative: false
+			});
+			previous_end = last_seg.b;
+			prev_segment_tb = last_seg.tb;
+			prev_quad_control = null;
+			skip_to_index = last_idx + 1;
+			continue;
+		}
+		if (is_closing && is_straight) {
+			commands.push({ type: SVGPathData.CLOSE_PATH });
+			previous_end = null;
+			current_start = null;
+			prev_segment_tb = null;
+			prev_quad_control = null;
+			continue;
+		}
+		if (is_straight) {
+			if (m.source_verb === "H" && approxEqual(end[1], start[1])) commands.push({
+				type: SVGPathData.HORIZ_LINE_TO,
+				x: end[0],
+				relative: false
+			});
+			else if (m.source_verb === "V" && approxEqual(end[0], start[0])) commands.push({
+				type: SVGPathData.VERT_LINE_TO,
+				y: end[1],
+				relative: false
+			});
+			else commands.push({
+				type: SVGPathData.LINE_TO,
+				x: end[0],
+				y: end[1],
+				relative: false
+			});
+			previous_end = b;
+			prev_segment_tb = tb;
+			prev_quad_control = null;
+			if (current_start !== null && b === current_start) {}
+			continue;
+		}
+		let emitted = false;
+		if (!emitted && (m.source_verb === "Q" || m.source_verb === "T")) {
+			const quad = tangentsRepresentQuadratic(start, end, ta, tb);
+			if (quad.ok) {
+				if (m.source_verb === "T" && prev_quad_control !== null && vec2Equal([start[0] - prev_quad_control[0], start[1] - prev_quad_control[1]], [quad.control[0] - start[0], quad.control[1] - start[1]], 1e-6)) commands.push({
+					type: SVGPathData.SMOOTH_QUAD_TO,
+					x: end[0],
+					y: end[1],
+					relative: false
+				});
+				else commands.push({
+					type: SVGPathData.QUAD_TO,
+					x1: quad.control[0],
+					y1: quad.control[1],
+					x: end[0],
+					y: end[1],
+					relative: false
+				});
+				previous_end = b;
+				prev_segment_tb = tb;
+				prev_quad_control = quad.control;
+				emitted = true;
+			}
+		}
+		if (!emitted && m.source_verb === "S" && prev_segment_tb !== null && isSmoothJoin(prev_segment_tb, ta)) {
+			const c2 = [end[0] + tb[0], end[1] + tb[1]];
+			commands.push({
+				type: SVGPathData.SMOOTH_CURVE_TO,
+				x2: c2[0],
+				y2: c2[1],
+				x: end[0],
+				y: end[1],
+				relative: false
+			});
+			previous_end = b;
+			prev_segment_tb = tb;
+			prev_quad_control = null;
+			emitted = true;
+		}
+		if (!emitted) {
+			const c1 = [start[0] + ta[0], start[1] + ta[1]];
+			const c2 = [end[0] + tb[0], end[1] + tb[1]];
+			commands.push({
+				type: SVGPathData.CURVE_TO,
+				x1: c1[0],
+				y1: c1[1],
+				x2: c2[0],
+				y2: c2[1],
+				x: end[0],
+				y: end[1],
+				relative: false
+			});
+			previous_end = b;
+			prev_segment_tb = tb;
+			prev_quad_control = null;
+		}
+		if (is_closing && !is_straight) {
+			commands.push({ type: SVGPathData.CLOSE_PATH });
+			previous_end = null;
+			current_start = null;
+			prev_segment_tb = null;
+			prev_quad_control = null;
+		}
+	}
+	return encodeSVGPath(commands);
+}
+//#endregion
+export { is_text_input_focused as _, paint as a, hit_shape_svg as c, NudgeDwellWatcher as d, TranslateOrchestrator as f, array_shallow_equal as g, group as h, TOOL_CURSOR as i, RotateOrchestrator as l, transform as m, insertions as n, ResizeOrchestrator as o, translate_pipeline as p, DEFAULT_STYLE as r, resize_pipeline as s, PathModel as t, rotate_pipeline as u };