@grida/svg-editor 1.0.0-alpha.4 → 1.0.0

package/dist/editor-CWNtt1vu.mjs

@@ -0,0 +1,2998 @@
+import { C as is_text_input_focused, E as registerDefaultCommands, S as array_shallow_equal, _ as subtree, a as paint, b as WELL_KNOWN_NS_PREFIXES, d as rotate_pipeline, g as transform, h as group, i as TOOL_CURSOR, m as translate_pipeline, n as insertions, r as DEFAULT_STYLE, s as resize_pipeline, v as SVG_NS, w as TOOL_SET, x as XMLNS_NS, y as SvgDocument } from "./model-D0iEDcg3.mjs";
+import { HistoryImpl } from "@grida/history";
+import { KeyCode, M, chunkKey, eventToChunk, getKeyboardOS, kb, keybindingsToKeyCodes } from "@grida/keybinding";
+import cmath from "@grida/cmath";
+import { encode_attr_value } from "@grida/svg/parser";
+//#region src/commands/registry.ts
+var CommandRegistry = class {
+	constructor() {
+		this.map = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Register a command. Returns an unregister function. Re-registering
+	* the same id replaces the previous handler (last writer wins).
+	*/
+	register(id, handler) {
+		this.map.set(id, handler);
+		return () => {
+			if (this.map.get(id) === handler) this.map.delete(id);
+		};
+	}
+	/**
+	* Invoke a command by id. Returns `true` if the handler consumed,
+	* `false` otherwise (including unknown ids and handlers that returned
+	* `false`/`undefined`).
+	*/
+	invoke(id, args) {
+		const handler = this.map.get(id);
+		if (!handler) return false;
+		return handler(args) === true;
+	}
+	has(id) {
+		return this.map.has(id);
+	}
+	/** All registered ids, for debugging / introspection. */
+	ids() {
+		return Array.from(this.map.keys());
+	}
+};
+//#endregion
+//#region src/keymap/keymap.ts
+/**
+* Keymap — bindings of declarative `Keybinding`s (from `@grida/keybinding`)
+* to command ids.
+*
+* Dispatch is ProseMirror-`chainCommands`-shaped: multiple bindings on
+* the same key are tried in priority order; the first whose handler
+* returns `true` wins, the rest are skipped. This keeps "one key, many
+* meanings" expressible without a `when:` DSL — handlers self-guard on
+* editor state and return `false` when not applicable.
+*
+* The keymap does NOT see modifier-as-signal (e.g. Alt-held for
+* measurement). That stays on the HUD modifiers channel. The keymap
+* only sees Mod+D-shape chords.
+*/
+var Keymap = class {
+	constructor(commands, platformGetter = getKeyboardOS) {
+		this.commands = commands;
+		this.platformGetter = platformGetter;
+		this.buckets = /* @__PURE__ */ new Map();
+		this.seq = 0;
+	}
+	/**
+	* Bind a key combination to a command. Returns an unbind function.
+	* The same `Keybinding` can be bound to multiple commands — they will
+	* all be tried in chain order on dispatch.
+	*/
+	bind(binding) {
+		const entry = {
+			binding,
+			seq: ++this.seq
+		};
+		for (const hash of this.chunkKeysFor(binding.keybinding)) {
+			const list = this.buckets.get(hash);
+			if (list) {
+				list.push(entry);
+				list.sort(compareEntries);
+			} else this.buckets.set(hash, [entry]);
+		}
+		return () => {
+			for (const hash of this.chunkKeysFor(binding.keybinding)) {
+				const list = this.buckets.get(hash);
+				if (!list) continue;
+				const idx = list.findIndex((e) => e === entry);
+				if (idx >= 0) list.splice(idx, 1);
+				if (list.length === 0) this.buckets.delete(hash);
+			}
+		};
+	}
+	/**
+	* Remove bindings matching the spec. If both filters are passed, only
+	* bindings that match BOTH are removed.
+	*/
+	unbind(spec) {
+		const hashFilter = spec.keybinding ? new Set(this.chunkKeysFor(spec.keybinding)) : null;
+		for (const [hash, list] of this.buckets) {
+			if (hashFilter && !hashFilter.has(hash)) continue;
+			const next = list.filter((e) => {
+				if (spec.command && e.binding.command !== spec.command) return true;
+				return false;
+			});
+			if (next.length === 0) this.buckets.delete(hash);
+			else if (next.length !== list.length) this.buckets.set(hash, next);
+		}
+	}
+	/** All registered bindings, for introspection. Order is not guaranteed. */
+	bindings() {
+		const seen = /* @__PURE__ */ new Set();
+		for (const list of this.buckets.values()) for (const e of list) seen.add(e.binding);
+		return Array.from(seen);
+	}
+	/**
+	* Does the keymap have a binding that matches this event's chord —
+	* regardless of whether any handler would consume it? Hosts use this
+	* to decide whether to swallow the platform's default action (e.g.
+	* `event.preventDefault()` in the browser), so that an advertised
+	* shortcut like `Cmd+G` doesn't fall through to the browser's find
+	* bar even when the binding's handler rejects.
+	*
+	* Pure read; runs no handlers, no side effects. Honors the same
+	* form-element focus guard `dispatch` uses, so a typing user's
+	* keystroke isn't "claimed" — and the browser's native text-editing
+	* default (Cmd+A select all, Cmd+Z undo, etc.) wins.
+	*/
+	claims(event) {
+		const chunk = eventToChunk(event);
+		if (chunk.keys.length === 0) return false;
+		const list = this.buckets.get(chunkKey(chunk));
+		if (!list || list.length === 0) return false;
+		if (is_text_input_focused()) return list.some(({ binding }) => binding.allowInFormElement === true);
+		return true;
+	}
+	/**
+	* Match the event against bound chunks, then run candidates in chain
+	* order. Returns `true` on the first handler that consumes; returns
+	* `false` if nothing matched or all matches fell through.
+	*
+	* **Form-element focus guard.** When a text input is focused
+	* (`<input>`, `<textarea>`, contentEditable), bindings are suppressed
+	* by default so the platform's native shortcuts (Cmd+A, Cmd+Z, Cmd+C,
+	* arrow nav, …) are preserved. A binding can opt out of this guard
+	* with `allowInFormElement: true` — see `KeymapBinding`.
+	*
+	* `dispatch` is browser-agnostic: it does NOT call `preventDefault()`
+	* or touch the event in any way. The host decides what to do with the
+	* platform default — typically `if (keymap.claims(e)) e.preventDefault()`,
+	* which prevents the platform default for advertised shortcuts even
+	* when the chain rejects. See README → `editor.keymap`.
+	*/
+	dispatch(event) {
+		const chunk = eventToChunk(event);
+		if (chunk.keys.length === 0) return false;
+		const hash = chunkKey(chunk);
+		const list = this.buckets.get(hash);
+		if (!list || list.length === 0) return false;
+		const text_focused = is_text_input_focused();
+		for (const { binding } of list) {
+			if (text_focused && binding.allowInFormElement !== true) continue;
+			if (this.commands.invoke(binding.command, binding.args)) return true;
+		}
+		return false;
+	}
+	/**
+	* Compute the set of canonical hashes a `Keybinding` lights up. A
+	* binding with aliases (multiple sequences) contributes one hash per
+	* single-chunk alias; multi-chunk sequences (chords) are skipped in
+	* V1.
+	*/
+	chunkKeysFor(binding) {
+		const sequences = keybindingsToKeyCodes(binding, this.platformGetter());
+		const out = [];
+		for (const seq of sequences) {
+			if (seq.length !== 1) continue;
+			out.push(chunkKey(seq[0]));
+		}
+		return out;
+	}
+};
+function compareEntries(a, b) {
+	const pa = a.binding.priority ?? 0;
+	const pb = b.binding.priority ?? 0;
+	if (pa !== pb) return pb - pa;
+	return a.seq - b.seq;
+}
+//#endregion
+//#region src/keymap/defaults.ts
+/**
+* Default keybindings shipped with `@grida/svg-editor`.
+*
+* THIS IS THE ONLY FILE where built-in shortcuts are declared. Adding
+* a new shortcut = one new row here (plus, if the target command is
+* new, one new handler in `src/commands/defaults.ts`). That is the
+* V1 design contract.
+*
+* Same key, multiple meanings? Add multiple rows. The chain semantics
+* (handler returns `false` when not applicable) handle the rest.
+*/
+const NUDGE_MEANINGFUL = M.Shift | M.Ctrl;
+const RESIZE_MEANINGFUL = M.Shift | M.Ctrl | M.Alt;
+const DEFAULT_BINDINGS = [
+	{
+		keybinding: kb(KeyCode.KeyZ, M.CtrlCmd),
+		command: "history.undo"
+	},
+	{
+		keybinding: kb(KeyCode.KeyZ, M.CtrlCmd | M.Shift),
+		command: "history.redo"
+	},
+	{
+		keybinding: kb(KeyCode.KeyY, M.CtrlCmd),
+		command: "history.redo"
+	},
+	{
+		keybinding: kb(KeyCode.Escape),
+		command: "selection.deselect"
+	},
+	{
+		keybinding: kb(KeyCode.Backspace),
+		command: "vector.delete-vertex"
+	},
+	{
+		keybinding: kb(KeyCode.Backspace),
+		command: "selection.remove"
+	},
+	{
+		keybinding: kb(KeyCode.Delete),
+		command: "vector.delete-vertex"
+	},
+	{
+		keybinding: kb(KeyCode.Delete),
+		command: "selection.remove"
+	},
+	{
+		keybinding: kb(KeyCode.KeyG, M.CtrlCmd),
+		command: "selection.group"
+	},
+	{
+		keybinding: kb(KeyCode.KeyG, M.CtrlCmd | M.Shift),
+		command: "selection.ungroup"
+	},
+	{
+		keybinding: kb(KeyCode.KeyD, M.CtrlCmd),
+		command: "selection.duplicate"
+	},
+	{
+		keybinding: kb(KeyCode.KeyA, M.CtrlCmd),
+		command: "selection.all"
+	},
+	{
+		keybinding: kb(KeyCode.Tab),
+		command: "selection.sibling",
+		args: "next"
+	},
+	{
+		keybinding: kb(KeyCode.Tab, M.Shift),
+		command: "selection.sibling",
+		args: "prev"
+	},
+	{
+		keybinding: kb(KeyCode.KeyA, M.Alt),
+		command: "selection.align",
+		args: "left"
+	},
+	{
+		keybinding: kb(KeyCode.KeyD, M.Alt),
+		command: "selection.align",
+		args: "right"
+	},
+	{
+		keybinding: kb(KeyCode.KeyW, M.Alt),
+		command: "selection.align",
+		args: "top"
+	},
+	{
+		keybinding: kb(KeyCode.KeyS, M.Alt),
+		command: "selection.align",
+		args: "bottom"
+	},
+	{
+		keybinding: kb(KeyCode.KeyH, M.Alt),
+		command: "selection.align",
+		args: "horizontal_centers"
+	},
+	{
+		keybinding: kb(KeyCode.KeyV, M.Alt),
+		command: "selection.align",
+		args: "vertical_centers"
+	},
+	{
+		keybinding: kb(KeyCode.Enter),
+		command: "content.enter"
+	},
+	{
+		keybinding: kb(KeyCode.Enter),
+		command: "hierarchy.enter"
+	},
+	{
+		keybinding: kb(KeyCode.Enter, M.Shift),
+		command: "hierarchy.exit"
+	},
+	{
+		keybinding: kb(KeyCode.LeftArrow, 0, NUDGE_MEANINGFUL),
+		command: "transform.nudge",
+		args: {
+			dx: -1,
+			dy: 0
+		}
+	},
+	{
+		keybinding: kb(KeyCode.RightArrow, 0, NUDGE_MEANINGFUL),
+		command: "transform.nudge",
+		args: {
+			dx: 1,
+			dy: 0
+		}
+	},
+	{
+		keybinding: kb(KeyCode.UpArrow, 0, NUDGE_MEANINGFUL),
+		command: "transform.nudge",
+		args: {
+			dx: 0,
+			dy: -1
+		}
+	},
+	{
+		keybinding: kb(KeyCode.DownArrow, 0, NUDGE_MEANINGFUL),
+		command: "transform.nudge",
+		args: {
+			dx: 0,
+			dy: 1
+		}
+	},
+	{
+		keybinding: kb(KeyCode.LeftArrow, M.Shift, NUDGE_MEANINGFUL),
+		command: "transform.nudge",
+		args: {
+			dx: -10,
+			dy: 0
+		}
+	},
+	{
+		keybinding: kb(KeyCode.RightArrow, M.Shift, NUDGE_MEANINGFUL),
+		command: "transform.nudge",
+		args: {
+			dx: 10,
+			dy: 0
+		}
+	},
+	{
+		keybinding: kb(KeyCode.UpArrow, M.Shift, NUDGE_MEANINGFUL),
+		command: "transform.nudge",
+		args: {
+			dx: 0,
+			dy: -10
+		}
+	},
+	{
+		keybinding: kb(KeyCode.DownArrow, M.Shift, NUDGE_MEANINGFUL),
+		command: "transform.nudge",
+		args: {
+			dx: 0,
+			dy: 10
+		}
+	},
+	{
+		keybinding: kb(KeyCode.RightArrow, M.Ctrl | M.Alt, RESIZE_MEANINGFUL),
+		command: "selection.nudge_resize",
+		args: {
+			dw: 1,
+			dh: 0
+		}
+	},
+	{
+		keybinding: kb(KeyCode.LeftArrow, M.Ctrl | M.Alt, RESIZE_MEANINGFUL),
+		command: "selection.nudge_resize",
+		args: {
+			dw: -1,
+			dh: 0
+		}
+	},
+	{
+		keybinding: kb(KeyCode.DownArrow, M.Ctrl | M.Alt, RESIZE_MEANINGFUL),
+		command: "selection.nudge_resize",
+		args: {
+			dw: 0,
+			dh: 1
+		}
+	},
+	{
+		keybinding: kb(KeyCode.UpArrow, M.Ctrl | M.Alt, RESIZE_MEANINGFUL),
+		command: "selection.nudge_resize",
+		args: {
+			dw: 0,
+			dh: -1
+		}
+	},
+	{
+		keybinding: kb(KeyCode.RightArrow, M.Ctrl | M.Alt | M.Shift, RESIZE_MEANINGFUL),
+		command: "selection.nudge_resize",
+		args: {
+			dw: 10,
+			dh: 0
+		}
+	},
+	{
+		keybinding: kb(KeyCode.LeftArrow, M.Ctrl | M.Alt | M.Shift, RESIZE_MEANINGFUL),
+		command: "selection.nudge_resize",
+		args: {
+			dw: -10,
+			dh: 0
+		}
+	},
+	{
+		keybinding: kb(KeyCode.DownArrow, M.Ctrl | M.Alt | M.Shift, RESIZE_MEANINGFUL),
+		command: "selection.nudge_resize",
+		args: {
+			dw: 0,
+			dh: 10
+		}
+	},
+	{
+		keybinding: kb(KeyCode.UpArrow, M.Ctrl | M.Alt | M.Shift, RESIZE_MEANINGFUL),
+		command: "selection.nudge_resize",
+		args: {
+			dw: 0,
+			dh: -10
+		}
+	},
+	{
+		keybinding: kb(KeyCode.KeyV),
+		command: TOOL_SET,
+		args: { type: "cursor" }
+	},
+	{
+		keybinding: kb(KeyCode.KeyR),
+		command: TOOL_SET,
+		args: {
+			type: "insert",
+			tag: "rect"
+		}
+	},
+	{
+		keybinding: kb(KeyCode.KeyO),
+		command: TOOL_SET,
+		args: {
+			type: "insert",
+			tag: "ellipse"
+		}
+	},
+	{
+		keybinding: kb(KeyCode.KeyL),
+		command: TOOL_SET,
+		args: {
+			type: "insert",
+			tag: "line"
+		}
+	},
+	{
+		keybinding: kb(KeyCode.KeyT),
+		command: TOOL_SET,
+		args: { type: "insert-text" }
+	},
+	{
+		keybinding: kb(KeyCode.KeyQ),
+		command: TOOL_SET,
+		args: { type: "lasso" }
+	},
+	{
+		keybinding: kb(KeyCode.BracketRight),
+		command: "reorder",
+		args: "bring_to_front"
+	},
+	{
+		keybinding: kb(KeyCode.BracketLeft),
+		command: "reorder",
+		args: "send_to_back"
+	},
+	{
+		keybinding: kb(KeyCode.BracketRight, M.CtrlCmd),
+		command: "reorder",
+		args: "bring_forward"
+	},
+	{
+		keybinding: kb(KeyCode.BracketLeft, M.CtrlCmd),
+		command: "reorder",
+		args: "send_backward"
+	}
+];
+/** Register every default binding into a keymap. */
+function applyDefaultBindings(keymap) {
+	for (const b of DEFAULT_BINDINGS) keymap.bind(b);
+}
+//#endregion
+//#region src/core/defs.ts
+var GradientsRegistry = class {
+	constructor(doc) {
+		this.doc = doc;
+		this.listeners = /* @__PURE__ */ new Set();
+		this.counter = 0;
+		this._cached = null;
+		this._cached_by_id = /* @__PURE__ */ new Map();
+		this._dirty = true;
+		doc.on_change(() => {
+			this._dirty = true;
+			this.emit();
+		});
+	}
+	list() {
+		if (!this._dirty && this._cached) return this._cached;
+		const out = [];
+		let any_change = !this._cached;
+		const seen = /* @__PURE__ */ new Set();
+		const defs = this.find_defs_elements();
+		for (const def_id of defs) for (const child of this.doc.element_children_of(def_id)) {
+			const tag = this.doc.tag_of(child);
+			if (tag === "linearGradient" || tag === "radialGradient") {
+				const id = this.doc.get_attr(child, "id");
+				if (!id) continue;
+				const definition = this.read_gradient(child, tag);
+				if (!definition) continue;
+				const ref_count = this.count_refs(id);
+				const prev = this._cached_by_id.get(id);
+				if (prev && prev.ref_count === ref_count && gradient_definition_equals(prev.definition, definition)) out.push(prev);
+				else {
+					const entry = {
+						id,
+						definition,
+						ref_count
+					};
+					this._cached_by_id.set(id, entry);
+					out.push(entry);
+					any_change = true;
+				}
+				seen.add(id);
+			}
+		}
+		for (const id of this._cached_by_id.keys()) if (!seen.has(id)) {
+			this._cached_by_id.delete(id);
+			any_change = true;
+		}
+		if (!any_change && this._cached && array_shallow_equal(this._cached, out)) {
+			this._dirty = false;
+			return this._cached;
+		}
+		const frozen = Object.freeze(out);
+		this._cached = frozen;
+		this._dirty = false;
+		return frozen;
+	}
+	get(id) {
+		return this.list().find((g) => g.id === id) ?? null;
+	}
+	upsert(definition, opts) {
+		const existing_id = opts?.id;
+		if (existing_id) {
+			const node = this.find_gradient_node(existing_id);
+			if (node !== null) {
+				this.write_gradient(node, definition);
+				return existing_id;
+			}
+		}
+		const id = existing_id ?? this.fresh_id();
+		const defs_id = this.ensure_defs();
+		const tag = definition.kind === "linear" ? "linearGradient" : "radialGradient";
+		const new_id = this.doc.create_element(tag, { ns: "http://www.w3.org/2000/svg" });
+		this.doc.set_attr(new_id, "id", id);
+		this.doc.insert(new_id, defs_id, null);
+		this.write_gradient(new_id, definition);
+		this.emit();
+		return id;
+	}
+	remove(id) {
+		const refs = this.count_refs(id);
+		if (refs > 0) throw new Error(`[svg-editor] cannot remove gradient "${id}": ${refs} node(s) still reference it`);
+		const node = this.find_gradient_node(id);
+		if (node !== null) {
+			this.doc.remove(node);
+			this.emit();
+		}
+	}
+	subscribe(fn) {
+		this.listeners.add(fn);
+		return () => {
+			this.listeners.delete(fn);
+		};
+	}
+	emit() {
+		const snap = this.list();
+		for (const fn of this.listeners) fn(snap);
+	}
+	fresh_id() {
+		let id;
+		do
+			id = `g${++this.counter}`;
+		while (this.find_gradient_node(id) !== null);
+		return id;
+	}
+	find_defs_elements() {
+		return this.doc.find_by_tag(this.doc.root, "defs");
+	}
+	ensure_defs() {
+		const existing = this.find_defs_elements();
+		if (existing.length > 0) return existing[0];
+		const defs = this.doc.create_element("defs", { ns: "http://www.w3.org/2000/svg" });
+		const first = this.doc.children_of(this.doc.root)[0] ?? null;
+		this.doc.insert(defs, this.doc.root, first);
+		return defs;
+	}
+	find_gradient_node(id) {
+		for (const def of this.find_defs_elements()) for (const child of this.doc.element_children_of(def)) if (this.doc.get_attr(child, "id") === id) {
+			const tag = this.doc.tag_of(child);
+			if (tag === "linearGradient" || tag === "radialGradient") return child;
+		}
+		return null;
+	}
+	read_gradient(id, tag) {
+		const stops = [];
+		for (const child of this.doc.element_children_of(id)) {
+			if (this.doc.tag_of(child) !== "stop") continue;
+			const offset = parseFloat(this.doc.get_attr(child, "offset") ?? "0");
+			const color = this.doc.get_attr(child, "stop-color") ?? this.doc.get_style(child, "stop-color") ?? "#000000";
+			const opacity_str = this.doc.get_attr(child, "stop-opacity") ?? this.doc.get_style(child, "stop-opacity");
+			const opacity = opacity_str !== null ? parseFloat(opacity_str) : void 0;
+			stops.push({
+				offset,
+				color,
+				...opacity !== void 0 ? { opacity } : {}
+			});
+		}
+		const gu = this.doc.get_attr(id, "gradientUnits");
+		const gradient_units = gu === "userSpaceOnUse" ? "user_space_on_use" : gu === "objectBoundingBox" ? "object_bounding_box" : void 0;
+		const sm = this.doc.get_attr(id, "spreadMethod");
+		const spread_method = sm === "pad" || sm === "reflect" || sm === "repeat" ? sm : void 0;
+		const num = (n) => {
+			const v = this.doc.get_attr(id, n);
+			return v !== null ? parseFloat(v) : void 0;
+		};
+		if (tag === "linearGradient") return {
+			kind: "linear",
+			stops,
+			x1: num("x1"),
+			y1: num("y1"),
+			x2: num("x2"),
+			y2: num("y2"),
+			gradient_units,
+			spread_method
+		};
+		return {
+			kind: "radial",
+			stops,
+			cx: num("cx"),
+			cy: num("cy"),
+			r: num("r"),
+			fx: num("fx"),
+			fy: num("fy"),
+			gradient_units,
+			spread_method
+		};
+	}
+	write_gradient(node, def) {
+		for (const c of this.doc.children_of(node).slice()) this.doc.remove(c);
+		const set_num = (name, v) => {
+			this.doc.set_attr(node, name, v === void 0 ? null : String(v));
+		};
+		if (def.kind === "linear") {
+			set_num("x1", def.x1);
+			set_num("y1", def.y1);
+			set_num("x2", def.x2);
+			set_num("y2", def.y2);
+		} else {
+			set_num("cx", def.cx);
+			set_num("cy", def.cy);
+			set_num("r", def.r);
+			set_num("fx", def.fx);
+			set_num("fy", def.fy);
+		}
+		if (def.gradient_units) this.doc.set_attr(node, "gradientUnits", def.gradient_units === "user_space_on_use" ? "userSpaceOnUse" : "objectBoundingBox");
+		if (def.spread_method) this.doc.set_attr(node, "spreadMethod", def.spread_method);
+		for (const stop of def.stops) {
+			const stop_id = this.doc.create_element("stop", { ns: "http://www.w3.org/2000/svg" });
+			this.doc.set_attr(stop_id, "offset", String(stop.offset));
+			this.doc.set_attr(stop_id, "stop-color", stop.color);
+			if (stop.opacity !== void 0) this.doc.set_attr(stop_id, "stop-opacity", String(stop.opacity));
+			this.doc.insert(stop_id, node, null);
+		}
+	}
+	count_refs(id) {
+		let count = 0;
+		const pattern = new RegExp(`url\\(\\s*["']?#${escape_regex(id)}["']?\\s*\\)`);
+		for (const node of this.doc.all_elements()) {
+			const fill = this.doc.get_attr(node, "fill");
+			const stroke = this.doc.get_attr(node, "stroke");
+			const style_fill = this.doc.get_style(node, "fill");
+			const style_stroke = this.doc.get_style(node, "stroke");
+			for (const v of [
+				fill,
+				stroke,
+				style_fill,
+				style_stroke
+			]) if (v && pattern.test(v)) count++;
+		}
+		return count;
+	}
+};
+function escape_regex(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function gradient_definition_equals(a, b) {
+	if (a === b) return true;
+	if (a.kind !== b.kind) return false;
+	if (a.stops.length !== b.stops.length) return false;
+	for (let i = 0; i < a.stops.length; i++) {
+		const sa = a.stops[i];
+		const sb = b.stops[i];
+		if (sa.offset !== sb.offset || sa.color !== sb.color || sa.opacity !== sb.opacity) return false;
+	}
+	if (a.kind === "linear" && b.kind === "linear") return a.x1 === b.x1 && a.y1 === b.y1 && a.x2 === b.x2 && a.y2 === b.y2 && a.gradient_units === b.gradient_units && a.spread_method === b.spread_method;
+	if (a.kind === "radial" && b.kind === "radial") return a.cx === b.cx && a.cy === b.cy && a.r === b.r && a.fx === b.fx && a.fy === b.fy && a.gradient_units === b.gradient_units && a.spread_method === b.spread_method;
+	return false;
+}
+function create_defs(doc) {
+	return { gradients: new GradientsRegistry(doc) };
+}
+//#endregion
+//#region src/core/clipboard.ts
+/**
+* Clipboard payload extraction — selection → standalone SVG document.
+*
+* Implements the copy side of the clipboard FRD
+* ([docs/wg/feat-svg-editor/clipboard.md](../../../../docs/wg/feat-svg-editor/clipboard.md)):
+* the payload is a standalone, namespace-well-formed SVG document — not a
+* private envelope. Assembly is a pure function of (document, selection):
+* no geometry, no environment, no randomness (FRD R6 — the same selection
+* yields the same bytes headless or surface-attached).
+*
+* What the payload carries, and what it deliberately does not
+* (FRD §Extraction — five context kinds):
+*
+*   1. Referenced resources — CARRIED. The outbound `url(#…)` / `href`
+*      closure is walked from the closed carrier list below and emitted
+*      verbatim in one `<defs>` block.
+*   2. Namespace declarations — CARRIED. Prefixes a subtree borrows from
+*      ancestor scope are declared on the payload shell (an undeclared
+*      prefix is a well-formedness error, so this includes the deliberate
+*      well-known-table repair for e.g. `xlink`).
+*   3. Ancestor transforms — NOT carried (verbatim policy).
+*   4. Inherited presentation / cascade — NOT carried (verbatim policy).
+*   5. Viewport — NOT carried (no `viewBox`, no sizing on the shell).
+*
+* This module is the **payload extraction** operation only. The sibling
+* operation the FRD names — in-document subtree CLONE (duplicate /
+* clone-drag), which must NOT carry the closure — lives in `./subtree`.
+* The two share exactly selection normalization (`subtree.normalize_roots`)
+* and verbatim subtree serialization (`doc.serialize_node`).
+*/
+let clipboard;
+(function(_clipboard) {
+	/**
+	* Presentation carriers that may hold `url(#…)` references, read both as
+	* a presentation attribute and as an inline `style=""` declaration.
+	*
+	* CLOSED LIST — extending it is a spec change to the FRD's §Extraction 1
+	* carrier list, not a bug fix. Deliberately NOT walked in v1 (documented
+	* degradations): `<style>` element rules (CSS parsing is the deferred
+	* cascade capability), SMIL timing/value references, `cursor`, SVG 2
+	* text-layout properties.
+	*/
+	const URL_REF_PROPS = [
+		"fill",
+		"stroke",
+		"filter",
+		"clip-path",
+		"mask",
+		"marker-start",
+		"marker-mid",
+		"marker-end",
+		"marker"
+	];
+	/** Set view of {@link URL_REF_PROPS} for membership tests over parsed
+	*  style declarations. */
+	const URL_REF_PROP_SET = new Set(URL_REF_PROPS);
+	/**
+	* Elements whose `href` / `xlink:href` is a same-document resource
+	* reference the closure follows. CLOSED LIST — `<a href>` is navigation,
+	* `<image href>` is content, SMIL `href` is an animation target; none of
+	* them are walked.
+	*/
+	const HREF_TAGS = new Set([
+		"use",
+		"textPath",
+		"mpath",
+		"feImage",
+		"pattern",
+		"linearGradient",
+		"radialGradient",
+		"filter"
+	]);
+	/**
+	* `url(#id)` extractor. Global — a single value can carry several
+	* references (`filter: url(#a) blur(2px) url(#b)` is a legal filter
+	* function list). Same quoting tolerance as the defs registry's
+	* ref-counting pattern.
+	*/
+	const URL_REF_RE = /url\(\s*["']?#([^"')\s]+)["']?\s*\)/g;
+	function extract_payload(doc, selection) {
+		const order = subtree.by_document_order(doc);
+		const roots = subtree.normalize_roots(doc, selection, order);
+		if (roots.length === 0) return null;
+		const closure = collect_reference_closure(doc, roots);
+		const shell_ns = /* @__PURE__ */ new Map();
+		for (const member of [...closure, ...roots].sort(order)) for (const prefix of doc.undeclared_ns_prefixes(member)) {
+			if (shell_ns.has(prefix)) continue;
+			const uri = resolve_prefix(doc, member, prefix);
+			if (uri !== null) shell_ns.set(prefix, uri);
+		}
+		let shell = `<svg xmlns="${SVG_NS}"`;
+		for (const [prefix, uri] of shell_ns) shell += ` xmlns:${prefix}="${encode_attr_value(uri, "\"")}"`;
+		shell += ">";
+		const defs_block = closure.length > 0 ? `<defs>${closure.map((id) => doc.serialize_node(id)).join("")}</defs>` : "";
+		const content = roots.map((id) => doc.serialize_node(id)).join("");
+		return `${shell}${defs_block}${content}</svg>`;
+	}
+	_clipboard.extract_payload = extract_payload;
+	function collect_reference_closure(doc, roots) {
+		const id_map = /* @__PURE__ */ new Map();
+		for (const el of doc.all_elements()) {
+			const id_attr = doc.get_attr(el, "id");
+			if (id_attr !== null && !id_map.has(id_attr)) id_map.set(id_attr, el);
+		}
+		const in_forest = (target) => roots.some((r) => doc.contains(r, target));
+		const collected = /* @__PURE__ */ new Set();
+		const pending = [...roots];
+		while (pending.length > 0) {
+			const subtree = pending.pop();
+			for (const el of elements_of_subtree(doc, subtree)) for (const ref of refs_of(doc, el)) {
+				const target = id_map.get(ref);
+				if (target === void 0) continue;
+				if (in_forest(target)) continue;
+				if (collected.has(target)) continue;
+				collected.add(target);
+				pending.push(target);
+			}
+		}
+		return doc.prune_nested_nodes([...collected]).sort(subtree.by_document_order(doc));
+	}
+	_clipboard.collect_reference_closure = collect_reference_closure;
+	/** Preorder element walk of `root`'s subtree, root included. */
+	function elements_of_subtree(doc, root) {
+		const out = [];
+		const walk = (id) => {
+			if (!doc.is_element(id)) return;
+			out.push(id);
+			for (const c of doc.children_of(id)) walk(c);
+		};
+		walk(root);
+		return out;
+	}
+	/** Same-document reference ids carried by one element, per the closed
+	*  carrier list. */
+	function refs_of(doc, id) {
+		const out = [];
+		for (const prop of URL_REF_PROPS) {
+			const value = doc.get_attr(id, prop);
+			if (!value) continue;
+			for (const m of value.matchAll(URL_REF_RE)) out.push(m[1]);
+		}
+		for (const { property, value } of doc.get_all_styles(id)) {
+			if (!URL_REF_PROP_SET.has(property)) continue;
+			for (const m of value.matchAll(URL_REF_RE)) out.push(m[1]);
+		}
+		if (HREF_TAGS.has(doc.tag_of(id))) {
+			const href = doc.get_attr(id, "href");
+			if (href !== null && href.startsWith("#") && href.length > 1) out.push(href.slice(1));
+		}
+		return out;
+	}
+	/**
+	* Resolve a prefix a member's subtree borrows from ancestor scope:
+	* nearest ancestor `xmlns:<prefix>` declaration wins (correct XML
+	* scoping), falling back to the well-known table — the deliberate
+	* repair that keeps the payload namespace-well-formed even when the
+	* source never declared the prefix (FRD §Extraction 2).
+	*/
+	function resolve_prefix(doc, member, prefix) {
+		let cur = doc.parent_of(member);
+		while (cur !== null) {
+			const uri = doc.get_attr(cur, prefix, XMLNS_NS);
+			if (uri !== null) return uri;
+			cur = doc.parent_of(cur);
+		}
+		return WELL_KNOWN_NS_PREFIXES.get(prefix) ?? null;
+	}
+})(clipboard || (clipboard = {}));
+//#endregion
+//#region src/core/align.ts
+/**
+* Compute per-member translation deltas to align `members` against `target`.
+*
+* Convention (matches Figma menu labels and `cmath.rect.alignA`):
+*   - `left` / `right`           → shift X so each left/right edge matches target's
+*   - `top` / `bottom`           → shift Y so each top/bottom edge matches target's
+*   - `horizontal_centers`       → shift X so each center-X matches target's center-X
+*   - `vertical_centers`         → shift Y so each center-Y matches target's center-Y
+*
+* Members already at the target position are omitted from the returned map —
+* callers iterate non-zero deltas only.
+*/
+function compute_align_deltas(members, target, direction) {
+	const out = /* @__PURE__ */ new Map();
+	for (const m of members) {
+		const d = delta_for(m.bbox, target, direction);
+		if (d.x !== 0 || d.y !== 0) out.set(m.id, d);
+	}
+	return out;
+}
+function delta_for(bbox, target, direction) {
+	switch (direction) {
+		case "left": return {
+			x: target.x - bbox.x,
+			y: 0
+		};
+		case "right": return {
+			x: target.x + target.width - (bbox.x + bbox.width),
+			y: 0
+		};
+		case "top": return {
+			x: 0,
+			y: target.y - bbox.y
+		};
+		case "bottom": return {
+			x: 0,
+			y: target.y + target.height - (bbox.y + bbox.height)
+		};
+		case "horizontal_centers": return {
+			x: target.x + target.width / 2 - (bbox.x + bbox.width / 2),
+			y: 0
+		};
+		case "vertical_centers": return {
+			x: 0,
+			y: target.y + target.height / 2 - (bbox.y + bbox.height / 2)
+		};
+	}
+}
+//#endregion
+//#region src/core/properties.ts
+let properties;
+(function(_properties) {
+	/** SVG properties that inherit per SVG 2 §6 (subset; the common ones). */
+	const INHERITED = new Set([
+		"color",
+		"cursor",
+		"direction",
+		"fill",
+		"fill-opacity",
+		"fill-rule",
+		"font",
+		"font-family",
+		"font-size",
+		"font-style",
+		"font-variant",
+		"font-weight",
+		"letter-spacing",
+		"marker",
+		"marker-end",
+		"marker-mid",
+		"marker-start",
+		"paint-order",
+		"pointer-events",
+		"shape-rendering",
+		"stroke",
+		"stroke-dasharray",
+		"stroke-dashoffset",
+		"stroke-linecap",
+		"stroke-linejoin",
+		"stroke-miterlimit",
+		"stroke-opacity",
+		"stroke-width",
+		"text-anchor",
+		"text-rendering",
+		"visibility",
+		"word-spacing",
+		"writing-mode"
+	]);
+	/** Initial values for known properties (subset). */
+	const INITIAL = {
+		fill: "black",
+		stroke: "none",
+		"fill-opacity": "1",
+		"stroke-opacity": "1",
+		"stroke-width": "1",
+		opacity: "1",
+		visibility: "visible",
+		display: "inline"
+	};
+	function resolve_declared(doc, id, property) {
+		const inline = doc.get_style(id, property);
+		if (inline !== null && inline !== "") return {
+			declared: inline,
+			provenance: {
+				origin: "author",
+				carrier: "inline_style"
+			}
+		};
+		const attr = doc.get_attr(id, property);
+		if (attr !== null && attr !== "") return {
+			declared: attr,
+			provenance: {
+				origin: "author",
+				carrier: "presentation_attribute"
+			}
+		};
+		if (INHERITED.has(property)) {
+			const parent = doc.parent_of(id);
+			if (parent !== null && doc.is_element(parent)) {
+				const r = resolve_declared(doc, parent, property);
+				if (r.declared !== null) return {
+					declared: r.declared,
+					provenance: {
+						origin: "author",
+						carrier: "inherited"
+					}
+				};
+			}
+		}
+		return {
+			declared: INITIAL[property] ?? null,
+			provenance: {
+				origin: "user_agent",
+				carrier: "defaulted"
+			}
+		};
+	}
+	_properties.resolve_declared = resolve_declared;
+	function compute_known(property, declared) {
+		if (declared === null) return null;
+		const trimmed = declared.trim();
+		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)`
+		};
+		switch (property) {
+			case "opacity":
+			case "fill-opacity":
+			case "stroke-opacity":
+			case "stroke-width":
+			case "x":
+			case "y":
+			case "width":
+			case "height":
+			case "cx":
+			case "cy":
+			case "r":
+			case "rx":
+			case "ry":
+			case "font-size": {
+				const n = parseFloat(trimmed);
+				return Number.isFinite(n) ? n : trimmed;
+			}
+			default: return trimmed;
+		}
+	}
+	_properties.compute_known = compute_known;
+	function read(doc, id, property) {
+		const { declared, provenance } = resolve_declared(doc, id, property);
+		return {
+			declared,
+			computed: compute_known(property, declared),
+			provenance
+		};
+	}
+	_properties.read = read;
+	function choose_write_carrier(doc, id, property) {
+		const inline = doc.get_style(id, property);
+		if (inline !== null && inline !== "") return "inline_style";
+		return "presentation_attribute";
+	}
+	_properties.choose_write_carrier = choose_write_carrier;
+	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;
+		if (a.computed === b.computed) return true;
+		if (a.computed && b.computed && typeof a.computed === "object" && typeof b.computed === "object" && "error" in a.computed && "error" in b.computed) return a.computed.error === b.computed.error && a.computed.reason === b.computed.reason;
+		return false;
+	}
+	_properties.value_equals = value_equals;
+})(properties || (properties = {}));
+//#endregion
+//#region src/core/editor.ts
+const PROVIDER_ID = "svg-editor";
+/** Max characters in a synthesized display label before truncation. */
+const DISPLAY_LABEL_MAX_LEN = 40;
+/**
+* Wide internal factory — returns the full object including the
+* `_internal` / `keymap` surfaces in its inferred type. Stays private.
+* The public `createSvgEditor` below wraps this and narrows the return
+* to `SvgEditor` so the published `.d.ts` doesn't advertise internals.
+*/
+function _create_svg_editor_internal(opts) {
+	const doc = new SvgDocument(opts.svg);
+	const history = new HistoryImpl();
+	const defs = create_defs(doc);
+	let selection = [];
+	let scope = null;
+	let mode = "select";
+	let tool = TOOL_CURSOR;
+	let version = 0;
+	/** `doc.revision` at the last load()/reset(); compared to derive `dirty`.
+	*  The doc's own total mutation counter is the single edit-version
+	*  source — `content_version`, `dirty`, and the typed-read memo caches
+	*  all derive from it (no editor-side shadow counter to drift). */
+	let baseline_revision = doc.revision;
+	/**
+	* Bumps once per `editor.load(svg)` call. The constructor's initial parse
+	* does NOT count — it's the "factory" state. Hosts subscribe via
+	* `subscribe_with_selector(s => s.load_version, ...)` to react to fresh
+	* document loads without firing on every edit.
+	*/
+	let load_version = 0;
+	let style = {
+		...DEFAULT_STYLE,
+		...opts.style
+	};
+	const providers = opts.providers ?? {};
+	/**
+	* In-memory clipboard buffer — the transport floor (FRD R1: the buffer
+	* write cannot fail; external channels are best-effort on top). NOT part
+	* of `EditorState` and NOT history-managed: it survives `load()` /
+	* `reset()` / undo, like the OS clipboard it mirrors.
+	*/
+	let clipboard_buffer = null;
+	/**
+	* The last committed duplication — read by the NEXT `duplicate()` to
+	* repeat the user's translate delta (gridaco/grida#825; spec
+	* §Repeating offset). Session state like `clipboard_buffer`: not in
+	* `EditorState`, not history-managed (undo/redo replay never re-arms
+	* it — only a user-initiated ⌘D or cloned-drag commit does). Staleness
+	* is caught at use by `subtree.repeat_delta`; the only eager clears are
+	* `load()` / `reset()`, where every NodeId dies wholesale.
+	*/
+	let active_duplication = null;
+	const listeners = /* @__PURE__ */ new Set();
+	let attached_surface = null;
+	/**
+	* World-space geometry query provider. Set by the DOM surface on
+	* attach (`editor._internal.set_geometry`); cleared on detach. Null
+	* means no renderer is attached — bounds queries cannot be answered.
+	*/
+	let geometry_provider = null;
+	const modes = ["select", "edit-content"];
+	function snapshot() {
+		return Object.freeze({
+			selection,
+			scope,
+			mode,
+			tool,
+			dirty: doc.revision !== baseline_revision,
+			can_undo: history.stack.canUndo,
+			can_redo: history.stack.canRedo,
+			version,
+			content_version: doc.revision,
+			structure_version: doc.structure_version,
+			geometry_version: doc.geometry_version,
+			load_version
+		});
+	}
+	function emit() {
+		version++;
+		const s = snapshot();
+		for (const fn of listeners) fn(s);
+	}
+	history.on("onChange", () => emit());
+	history.on("onUndo", () => emit());
+	history.on("onRedo", () => emit());
+	let last_emitted_geometry_version = doc.geometry_version;
+	const geometry_listeners = /* @__PURE__ */ new Set();
+	const translate_commit_listeners = /* @__PURE__ */ new Set();
+	const notify_translate_commit = () => {
+		for (const cb of translate_commit_listeners) cb();
+	};
+	/**
+	* Fan out the geometry channel iff the doc's `geometry_version` has
+	* moved since we last fired. Shared by the `doc.on_change` handler
+	* (mutation-driven bumps) and the surface-driven `bump_geometry` seam
+	* (font-load reflow). Idempotent against a stale version — never
+	* double-fires for the same value.
+	*/
+	function fire_geometry_listeners_if_advanced() {
+		if (doc.geometry_version !== last_emitted_geometry_version) {
+			last_emitted_geometry_version = doc.geometry_version;
+			for (const cb of geometry_listeners) cb();
+		}
+	}
+	doc.on_change(() => {
+		fire_geometry_listeners_if_advanced();
+	});
+	function subscribe(fn) {
+		listeners.add(fn);
+		return () => {
+			listeners.delete(fn);
+		};
+	}
+	function subscribe_with_selector(selector, fn, equals = Object.is) {
+		let prev = selector(snapshot());
+		return subscribe((state) => {
+			const next = selector(state);
+			if (!equals(prev, next)) {
+				const p = prev;
+				prev = next;
+				fn(next, p);
+			}
+		});
+	}
+	function set_selection(next) {
+		const pruned = doc.prune_nested_nodes(next);
+		if (pruned.length === selection.length) {
+			let same = true;
+			for (let i = 0; i < pruned.length; i++) if (pruned[i] !== selection[i]) {
+				same = false;
+				break;
+			}
+			if (same) return;
+		}
+		selection = Object.freeze([...pruned]);
+		emit();
+	}
+	function select(target, opts) {
+		const ids = typeof target === "string" ? [target] : [...target];
+		const mode = opts?.mode ?? "replace";
+		if (mode === "replace") {
+			set_selection(ids);
+			return;
+		}
+		const next = new Set(selection);
+		if (mode === "add") for (const id of ids) next.add(id);
+		else for (const id of ids) if (next.has(id)) next.delete(id);
+		else next.add(id);
+		set_selection([...next]);
+	}
+	function deselect() {
+		set_selection([]);
+	}
+	function enter_scope(group) {
+		scope = group;
+		emit();
+	}
+	function exit_scope() {
+		if (scope === null) return;
+		const parent = doc.parent_of(scope);
+		scope = parent && parent !== doc.root ? parent : null;
+		emit();
+	}
+	function set_mode(next) {
+		if (mode === next) return;
+		mode = next;
+		emit();
+	}
+	function tools_equal(a, b) {
+		if (a.type !== b.type) return false;
+		if (a.type === "cursor" || a.type === "lasso" || a.type === "bend" || a.type === "insert-text") return true;
+		return b.type === "insert" && a.tag === b.tag;
+	}
+	function set_tool(next) {
+		if (tools_equal(tool, next)) return;
+		tool = next;
+		emit();
+	}
+	const paint_cache = /* @__PURE__ */ new Map();
+	const property_cache = /* @__PURE__ */ new Map();
+	const properties_cache = /* @__PURE__ */ new Map();
+	let tree_cache = null;
+	const tree_node_pool = /* @__PURE__ */ new Map();
+	function tree_snapshot() {
+		const sv = doc.structure_version;
+		if (tree_cache && tree_cache.structure_version === sv) return tree_cache.value;
+		const map = /* @__PURE__ */ new Map();
+		let any_change = !tree_cache;
+		for (const id of doc.all_elements()) {
+			const tag = doc.tag_of(id);
+			const name = doc.get_attr(id, "id") ?? void 0;
+			const parent = doc.parent_of(id);
+			const children = doc.element_children_of(id);
+			const pooled = tree_node_pool.get(id);
+			if (pooled && pooled.tag === tag && pooled.name === name && pooled.parent === parent && array_shallow_equal(pooled.children, children)) {
+				map.set(id, pooled);
+				continue;
+			}
+			const node = {
+				id,
+				tag,
+				name,
+				parent,
+				children
+			};
+			tree_node_pool.set(id, node);
+			map.set(id, node);
+			any_change = true;
+		}
+		for (const id of tree_node_pool.keys()) if (!map.has(id)) {
+			tree_node_pool.delete(id);
+			any_change = true;
+		}
+		if (!any_change && tree_cache) {
+			tree_cache.structure_version = sv;
+			return tree_cache.value;
+		}
+		const snap = {
+			root: doc.root,
+			nodes: map
+		};
+		tree_cache = {
+			structure_version: sv,
+			value: snap
+		};
+		return snap;
+	}
+	function node_property_cached(id, name) {
+		const key = `${id}${name}`;
+		const cached = property_cache.get(key);
+		if (cached && cached.revision === doc.revision) return cached.value;
+		const next = properties.read(doc, id, name);
+		if (cached && properties.value_equals(cached.value, next)) {
+			cached.revision = doc.revision;
+			return cached.value;
+		}
+		property_cache.set(key, {
+			revision: doc.revision,
+			value: next
+		});
+		return next;
+	}
+	function node_properties(id, names) {
+		const key = `${id}${names.join("
")}`;
+		const cached = properties_cache.get(key);
+		if (cached && cached.revision === doc.revision) return cached.value;
+		const next = {};
+		let changed = !cached;
+		for (const name of names) {
+			const v = node_property_cached(id, name);
+			next[name] = v;
+			if (cached && cached.value[name] !== v) changed = true;
+		}
+		if (cached && !changed) {
+			cached.revision = doc.revision;
+			return cached.value;
+		}
+		const frozen = Object.freeze(next);
+		properties_cache.set(key, {
+			revision: doc.revision,
+			value: frozen
+		});
+		return frozen;
+	}
+	function node_paint(id, channel) {
+		const key = `${id}${channel}`;
+		const cached = paint_cache.get(key);
+		if (cached && cached.revision === doc.revision) return cached.value;
+		const { declared, provenance } = properties.resolve_declared(doc, id, channel);
+		const next = {
+			declared,
+			computed: paint.parse(declared),
+			provenance
+		};
+		if (cached && paint.value_equals(cached.value, next)) {
+			cached.revision = doc.revision;
+			return cached.value;
+		}
+		paint_cache.set(key, {
+			revision: doc.revision,
+			value: next
+		});
+		return next;
+	}
+	function write_property(id, name, value) {
+		if (properties.choose_write_carrier(doc, id, name) === "inline_style") doc.set_style(id, name, value);
+		else doc.set_attr(id, name, value);
+	}
+	/** Open `preview_property` sessions, keyed by property name. A discrete
+	*  write to the same name supersedes the in-flight gesture: the session
+	*  is silently discarded so a later host-side `commit()` cannot replay
+	*  the stale previewed value over the discrete write. The stored
+	*  function reverts the previewed value and unregisters itself. */
+	const open_property_previews = /* @__PURE__ */ new Map();
+	function supersede_property_preview(name) {
+		open_property_previews.get(name)?.();
+	}
+	/** End EVERY open preview session. Called by operations that detach
+	*  nodes (remove / cut, ungroup) or replace the document (load,
+	*  reset): the sessions' deltas target nodes that are about to die,
+	*  so a later close-time `commit()` would push a dead history step.
+	*  Must run BEFORE the destructive mutation — each discard reverts
+	*  its in-flight delta against the still-intact document. (Live
+	*  iteration is safe: each discard deletes only its own map entry.) */
+	function discard_open_property_previews() {
+		for (const discard of open_property_previews.values()) discard();
+	}
+	function set_property(name, value) {
+		if (selection.length === 0) return;
+		supersede_property_preview(name);
+		const before = [];
+		for (const id of selection) before.push({
+			id,
+			attr: doc.get_attr(id, name),
+			style: doc.get_style(id, name)
+		});
+		const targets = [...selection];
+		const apply = () => {
+			for (const id of targets) write_property(id, name, value);
+			emit();
+		};
+		const revert = () => {
+			for (const b of before) {
+				if (b.style !== null) doc.set_style(b.id, name, b.style);
+				else doc.set_style(b.id, name, null);
+				doc.set_attr(b.id, name, b.attr);
+			}
+			emit();
+		};
+		apply();
+		history.atomic(`set ${name}`, (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+	}
+	function preview_property(name) {
+		supersede_property_preview(name);
+		const targets = [...selection];
+		const before = [];
+		for (const id of targets) before.push({
+			id,
+			attr: doc.get_attr(id, name),
+			style: doc.get_style(id, name)
+		});
+		const preview = history.preview(`change ${name}`);
+		const live = () => preview.state === "active";
+		const close = () => {
+			if (open_property_previews.get(name) === discard) open_property_previews.delete(name);
+		};
+		const discard = () => {
+			close();
+			if (live()) preview.discard();
+		};
+		open_property_previews.set(name, discard);
+		return {
+			get live() {
+				return live();
+			},
+			update(value) {
+				if (!live()) return;
+				preview.set({
+					providerId: PROVIDER_ID,
+					apply: () => {
+						for (const id of targets) write_property(id, name, value);
+						emit();
+					},
+					revert: () => {
+						for (const b of before) {
+							if (b.style !== null) doc.set_style(b.id, name, b.style);
+							else doc.set_style(b.id, name, null);
+							doc.set_attr(b.id, name, b.attr);
+						}
+						emit();
+					}
+				});
+			},
+			commit: () => {
+				close();
+				if (live()) preview.commit();
+			},
+			discard
+		};
+	}
+	function set_paint(channel, p) {
+		if (selection.length === 0) return;
+		set_property(channel, paint.serialize(p));
+	}
+	function preview_paint(channel) {
+		const session = preview_property(channel);
+		return {
+			get live() {
+				return session.live;
+			},
+			update: (p) => session.update(paint.serialize(p)),
+			commit: () => session.commit(),
+			discard: () => session.discard()
+		};
+	}
+	function set_paint_from_gradient(channel, definition, _opts) {
+		const gradient_id = defs.gradients.upsert(definition);
+		set_paint(channel, {
+			kind: "ref",
+			id: gradient_id
+		});
+		return { gradient_id };
+	}
+	function set_opacity(value) {
+		if (!Number.isFinite(value)) return;
+		const clamped = cmath.clamp01(value);
+		set_property("opacity", String(clamped));
+	}
+	/** World→local delta projection shared by every one-shot translate
+	*  writer (translate / nudge via `prepare_rpc`, align). Re-expresses a
+	*  world-space delta in the frame the target's position attributes are
+	*  written in — nested-viewport / transformed-ancestor correctness.
+	*  Identity for flat docs and DOM-less hosts (no provider, or a
+	*  provider without a layout engine). */
+	const project_world_delta = (id, d) => geometry_provider?.world_delta_to_local?.(id, d) ?? d;
+	/** Shared one-shot translate runner. `stages` selects semantics — see
+	*  `core/translate-pipeline/README.md`'s "Stage lists per entry point". */
+	function do_translate_oneshot(delta, stages, label) {
+		if (selection.length === 0) return false;
+		if (delta.dx === 0 && delta.dy === 0) return false;
+		const { apply, revert } = translate_pipeline.prepare_rpc({
+			doc,
+			ids: selection,
+			delta: {
+				x: delta.dx,
+				y: delta.dy
+			},
+			options: {
+				pixel_grid_quantum: style.snap_to_pixel_grid ? style.pixel_grid_size : null,
+				snap_enabled: style.snap_enabled,
+				snap_threshold_px: style.snap_threshold_px
+			},
+			emit,
+			stages,
+			project: project_world_delta
+		});
+		apply();
+		history.atomic(label, (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		return true;
+	}
+	function translate(delta) {
+		if (do_translate_oneshot(delta, void 0, "translate")) notify_translate_commit();
+	}
+	function nudge(delta) {
+		if (do_translate_oneshot(delta, translate_pipeline.stages.NUDGE, "nudge")) notify_translate_commit();
+	}
+	/**
+	* Gate + capture for a resize gesture. Returns the resizable members (with
+	* captured baseline / pre-transform / bbox), or `null` if the gesture can't
+	* run: no geometry provider, empty selection, or — in `all_or_nothing` mode
+	* — any member fails the gate.
+	*
+	* `mode`:
+	*  - `"skip"`           — drop members failing the `is_resizable_node` gate
+	*    (tag + transform class) or lacking a bbox; resize the rest. Used by the
+	*    inspector `resize_to` (set-bbox) path.
+	*  - `"all_or_nothing"` — refuse the WHOLE gesture (return `null`) if ANY
+	*    member fails. Used by keyboard `resize_by` (nudge), matching the resize
+	*    HUD, whose handle-drag is rejected when any member is unsafe.
+	*/
+	function collect_resize_members(ids, mode) {
+		if (ids.length === 0) return null;
+		if (!geometry_provider) return null;
+		const members = [];
+		for (const id of ids) {
+			if (!resize_pipeline.intent.is_resizable_node(doc, id)) {
+				if (mode === "all_or_nothing") return null;
+				continue;
+			}
+			const bbox = geometry_provider.bounds_of(id);
+			if (!bbox) {
+				if (mode === "all_or_nothing") return null;
+				continue;
+			}
+			members.push({
+				id,
+				rz: resize_pipeline.intent.capture_baseline(doc, id, bbox),
+				bbox
+			});
+		}
+		return members.length === 0 ? null : members;
+	}
+	/**
+	* Apply a resize to each member, optionally followed by a uniform group
+	* translate, as ONE atomic history step. `op` resolves each member's scale
+	* factors + scale origin; `group_translate` is the post-scale envelope shift
+	* (group resize only — `null` for per-element). Callers guarantee `members`
+	* is non-empty. Returns `true` when a history step was pushed; `false` when
+	* the gesture is geometrically identity (no member scales and no group
+	* translate) so undo isn't polluted with an empty step. NOTE: a per-tag
+	* constraint that collapses a non-1 factor to identity *inside* the handler
+	* (e.g. `<circle>` uniform `min` on a single-axis nudge) is not detected
+	* here — the op-level factor is still ≠ 1, so that case still pushes a step.
+	*/
+	function commit_resize(members, op, group_translate, label) {
+		const ops = members.map((m) => ({
+			m,
+			...op(m)
+		}));
+		const scales = ops.some(({ sx, sy }) => sx !== 1 || sy !== 1);
+		const translates = !!group_translate && (group_translate.dx !== 0 || group_translate.dy !== 0);
+		if (!scales && !translates) return false;
+		const apply = () => {
+			for (const { m, sx, sy, origin } of ops) resize_pipeline.intent.apply(doc, m.id, m.rz, sx, sy, origin);
+			if (group_translate && (group_translate.dx !== 0 || group_translate.dy !== 0)) for (const m of members) {
+				const tx_after = translate_pipeline.intent.capture_baseline(doc, m.id);
+				translate_pipeline.intent.apply(doc, m.id, tx_after, group_translate.dx, group_translate.dy);
+			}
+			emit();
+		};
+		const revert = () => {
+			for (const { m } of ops) resize_pipeline.intent.restore(doc, m.id, m.rz);
+			emit();
+		};
+		apply();
+		history.atomic(label, (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		return true;
+	}
+	/**
+	* One-shot multi-member resize to an explicit target rect. Mirrors a
+	* drag-resize gesture in mechanics — capture per-member baselines,
+	* scale around the union's NW corner, translate the result so the
+	* union NW lands at the requested position — but as a single
+	* atomic step rather than a preview session. This is the GROUP path:
+	* the whole selection is treated as one envelope.
+	*
+	* The function does its own geometry lookup via the
+	* `geometry_provider` registered by the DOM surface. When no surface
+	* is attached, the call is a no-op (returns `false`). Members that fail
+	* the `is_resizable_node` gate — an unresizable tag (e.g. `<g>`) OR a
+	* non-trivially-transformed element — are silently skipped (see
+	* `collect_resize_members`).
+	*
+	* Revert restores the captured `transform` attribute and all
+	* geometry attrs the apply step wrote — so a `<rect>` with an
+	* existing `transform` round-trips cleanly. See `apply_translate`'s
+	* `viaTransform` arm for why this matters.
+	*/
+	function resize_to(target, opts) {
+		const members = collect_resize_members(opts?.ids ?? selection, "skip");
+		if (!members) return false;
+		const union = cmath.rect.union(members.map((m) => m.bbox));
+		const sx = union.width === 0 ? 1 : target.width / union.width;
+		const sy = union.height === 0 ? 1 : target.height / union.height;
+		const origin = {
+			x: union.x,
+			y: union.y
+		};
+		return commit_resize(members, () => ({
+			sx,
+			sy,
+			origin
+		}), {
+			dx: target.x - union.x,
+			dy: target.y - union.y
+		}, opts?.label ?? "resize-to");
+	}
+	/**
+	* Resize by a `{dw, dh}` delta — the core verb behind keyboard nudge-resize
+	* (`Ctrl+Alt+Arrow`). This is the PER-ELEMENT path: each selected member
+	* grows/shrinks by the delta around ITS OWN NW corner, so members keep their
+	* positions relative to one another. This deliberately differs from
+	* {@link resize_to} (the group/envelope path): a HUD group-resize scales the
+	* whole selection around the shared union origin, translating off-origin
+	* members — correct for a drag handle, wrong for a keyboard nudge, whose UX
+	* is "apply the delta to each".
+	*
+	* ALL-OR-NOTHING gate (`collect_resize_members("all_or_nothing")`): refuses
+	* (returns `false`, no history step) on empty selection, no geometry
+	* provider, or any member failing the `is_resizable_node` gate — matching
+	* the resize HUD rather than `resize_to`'s per-member skip.
+	*/
+	function resize_by(delta, opts) {
+		const members = collect_resize_members(opts?.ids ?? selection, "all_or_nothing");
+		if (!members) return false;
+		const axis = (size, d) => size === 0 ? 1 : Math.max(0, size + d) / size;
+		return commit_resize(members, (m) => ({
+			sx: axis(m.bbox.width, delta.dw),
+			sy: axis(m.bbox.height, delta.dh),
+			origin: {
+				x: m.bbox.x,
+				y: m.bbox.y
+			}
+		}), null, "nudge-resize");
+	}
+	/** Shared helper: compute a default rotation pivot from the live
+	*  geometry_provider when the caller omitted one. Falls back to (0,0)
+	*  if no surface is attached. */
+	function default_rotate_pivot(ids) {
+		if (!geometry_provider || ids.length === 0) return {
+			x: 0,
+			y: 0
+		};
+		const rects = [];
+		for (const id of ids) {
+			const b = geometry_provider.bounds_of(id);
+			if (b) rects.push(b);
+		}
+		if (rects.length === 0) return {
+			x: 0,
+			y: 0
+		};
+		const u = cmath.rect.union(rects);
+		return {
+			x: u.x + u.width / 2,
+			y: u.y + u.height / 2
+		};
+	}
+	function rotate(angle, opts) {
+		const ids = opts?.ids ?? selection;
+		if (ids.length === 0) return false;
+		const pivot = opts?.pivot ?? default_rotate_pivot(ids);
+		const prepared = rotate_pipeline.prepare_rpc({
+			doc,
+			ids,
+			pivot,
+			angle_radians: angle,
+			options: { angle_snap_step_radians: style.angle_snap_step_radians },
+			emit
+		});
+		for (const v of prepared.verdicts.values()) if (v.kind === "refuse") return false;
+		prepared.apply();
+		history.atomic("rotate", (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply: prepared.apply,
+				revert: prepared.revert
+			});
+		});
+		return true;
+	}
+	function rotate_to(angle, opts) {
+		const ids = opts?.ids ?? selection;
+		if (ids.length === 0) return false;
+		const pivot = opts?.pivot ?? default_rotate_pivot(ids);
+		const probe = rotate_pipeline.prepare_rpc({
+			doc,
+			ids,
+			pivot,
+			angle_radians: 0,
+			options: { angle_snap_step_radians: style.angle_snap_step_radians },
+			emit: () => {}
+		});
+		for (const v of probe.verdicts.values()) if (v.kind === "refuse") return false;
+		const DEG_TO_RAD = Math.PI / 180;
+		const apply = () => {
+			for (const m of probe.plan.members) {
+				const delta = angle - m.baseline.current_rotation_deg * DEG_TO_RAD;
+				rotate_pipeline.intent.apply(doc, m.id, m.baseline, delta);
+			}
+			emit();
+		};
+		const revert = () => {
+			for (const m of probe.plan.members) rotate_pipeline.intent.apply(doc, m.id, m.baseline, 0);
+			emit();
+		};
+		apply();
+		history.atomic("rotate-to", (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		return true;
+	}
+	/**
+	* Relative affine compose about a pivot. See the `Commands.transform`
+	* doc for the full contract. This function owns ONLY the pivot/effective-
+	* matrix computation (which needs `geometry_provider`); the parse→fold→
+	* emit round-trip is delegated per-member to the pure
+	* `transform.apply_affine` helper.
+	*/
+	function apply_transform(matrix, opts) {
+		const ids = opts?.ids ?? selection;
+		if (ids.length === 0) return false;
+		if (!geometry_provider) return false;
+		for (const id of ids) if (rotate_pipeline.intent.is_transformable(doc, id).kind === "refuse") return false;
+		const pivot = opts?.pivot ?? default_rotate_pivot(ids);
+		const [a, b, c, d, e, f] = matrix;
+		const requested = [[
+			a,
+			c,
+			e
+		], [
+			b,
+			d,
+			f
+		]];
+		const t_pivot = [[
+			1,
+			0,
+			pivot.x
+		], [
+			0,
+			1,
+			pivot.y
+		]];
+		const t_neg_pivot = [[
+			1,
+			0,
+			-pivot.x
+		], [
+			0,
+			1,
+			-pivot.y
+		]];
+		const effective = cmath.transform.multiply(cmath.transform.multiply(t_pivot, requested), t_neg_pivot);
+		const members = ids.map((id) => ({
+			id,
+			transform_pre: doc.get_attr(id, "transform")
+		}));
+		const apply = () => {
+			for (const m of members) doc.set_attr(m.id, "transform", transform.apply_affine(m.transform_pre, effective));
+			emit();
+		};
+		const revert = () => {
+			for (const m of members) doc.set_attr(m.id, "transform", m.transform_pre);
+			emit();
+		};
+		apply();
+		history.atomic("transform", (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		return true;
+	}
+	function flatten_transform(opts) {
+		const ids = opts?.ids ?? selection;
+		if (ids.length === 0) return false;
+		const members = [];
+		for (const id of ids) {
+			const pre = doc.get_attr(id, "transform");
+			if (pre === null) continue;
+			const ops = transform.parse(pre);
+			if (ops === null) continue;
+			if (ops.length === 1 && ops[0].type === "matrix") continue;
+			members.push({
+				id,
+				transform_pre: pre,
+				ops
+			});
+		}
+		if (members.length === 0) return false;
+		const apply = () => {
+			for (const m of members) {
+				let mat = FLATTEN_IDENT;
+				for (const op of m.ops) mat = flatten_mul(mat, flatten_op_to_mat(op));
+				doc.set_attr(m.id, "transform", transform.emit([{
+					type: "matrix",
+					a: mat[0],
+					b: mat[1],
+					c: mat[2],
+					d: mat[3],
+					e: mat[4],
+					f: mat[5]
+				}]));
+			}
+			emit();
+		};
+		const revert = () => {
+			for (const m of members) doc.set_attr(m.id, "transform", m.transform_pre);
+			emit();
+		};
+		apply();
+		history.atomic("flatten-transform", (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		return true;
+	}
+	/**
+	* Translate selected members so they line up along the requested edge or
+	* center of a reference rect. Same mechanics as `resize_to`: per-member
+	* translate baselines (so `<g>`, transformed, and natively-attributed
+	* nodes all write the cleanest in-place representation), one atomic
+	* history step. Deltas are computed in world space and re-expressed in
+	* each member's local frame before writing (`world_delta_to_local`),
+	* so members under scaled/rotated ancestors land exactly and a repeat
+	* invocation is a no-op.
+	*
+	* Reference rect is selection-size dependent:
+	*   - multi-selection: union of member bboxes
+	*   - single selection: the parent's bbox (root → `<svg>` viewport,
+	*     inside a `<g>` → that group's bbox). Refuses when the selected
+	*     node IS the root (no container to align against).
+	*
+	* Refuses when `geometry_provider` is null (no surface attached) or when
+	* no member has a resolvable bbox.
+	*/
+	function align(direction, opts) {
+		const ids = opts?.ids ?? selection;
+		if (ids.length === 0) return false;
+		if (!geometry_provider) return false;
+		const members = [];
+		for (const id of ids) {
+			const bbox = geometry_provider.bounds_of(id);
+			if (!bbox) continue;
+			const baseline = translate_pipeline.intent.capture_baseline(doc, id);
+			if (baseline.type === "unsupported") continue;
+			members.push({
+				id,
+				bbox,
+				baseline
+			});
+		}
+		if (members.length === 0) return false;
+		let target;
+		if (members.length === 1) {
+			const parent_id = doc.parent_of(members[0].id);
+			if (parent_id === null) return false;
+			const parent_bbox = geometry_provider.bounds_of(parent_id);
+			if (!parent_bbox) return false;
+			target = parent_bbox;
+		} else target = cmath.rect.union(members.map((m) => m.bbox));
+		const world_deltas = compute_align_deltas(members, target, direction);
+		if (world_deltas.size === 0) return false;
+		const deltas = /* @__PURE__ */ new Map();
+		for (const [id, d] of world_deltas) deltas.set(id, project_world_delta(id, d));
+		const apply = () => {
+			for (const m of members) {
+				const d = deltas.get(m.id);
+				if (d) translate_pipeline.intent.apply(doc, m.id, m.baseline, d.x, d.y);
+			}
+			emit();
+		};
+		const revert = () => {
+			for (const m of members) if (deltas.has(m.id)) translate_pipeline.intent.apply(doc, m.id, m.baseline, 0, 0);
+			emit();
+		};
+		apply();
+		history.atomic(`align ${direction}`, (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		return true;
+	}
+	function select_all() {
+		const parent = scope ?? doc.root;
+		const children = doc.element_children_of(parent);
+		if (children.length === 0) return false;
+		set_selection(children);
+		return true;
+	}
+	/**
+	* Cycle the selection to the next / previous sibling. Single-selection
+	* path uses the selected node's parent; empty / multi-selection falls
+	* back to the current scope's first / last child. Wraps at edges.
+	*/
+	function select_sibling(direction) {
+		let parent;
+		let anchor_index;
+		let siblings;
+		if (selection.length === 1) {
+			const current = selection[0];
+			parent = doc.parent_of(current);
+			if (parent === null) return false;
+			siblings = doc.element_children_of(parent);
+			anchor_index = siblings.indexOf(current);
+			if (anchor_index < 0) return false;
+		} else {
+			parent = scope ?? doc.root;
+			siblings = doc.element_children_of(parent);
+			if (siblings.length === 0) return false;
+			anchor_index = direction === "next" ? -1 : siblings.length;
+		}
+		const n = siblings.length;
+		const next = direction === "next" ? (anchor_index + 1) % n : (anchor_index - 1 + n) % n;
+		set_selection([siblings[next]]);
+		return true;
+	}
+	function reorder(direction) {
+		if (selection.length !== 1) return;
+		const target = selection[0];
+		const parent = doc.parent_of(target);
+		if (parent === null) return;
+		const siblings = doc.element_children_of(parent);
+		const i = siblings.indexOf(target);
+		if (i < 0) return;
+		const original_before = siblings[i + 1] ?? null;
+		let new_before;
+		switch (direction) {
+			case "bring_forward":
+				if (i >= siblings.length - 1) return;
+				new_before = siblings[i + 2] ?? null;
+				break;
+			case "send_backward":
+				if (i <= 0) return;
+				new_before = siblings[i - 1];
+				break;
+			case "bring_to_front":
+				if (i === siblings.length - 1) return;
+				new_before = null;
+				break;
+			case "send_to_back":
+				if (i === 0) return;
+				new_before = siblings[0];
+				break;
+		}
+		const apply = () => {
+			doc.insert(target, parent, new_before);
+			emit();
+		};
+		const revert = () => {
+			doc.insert(target, parent, original_before);
+			emit();
+		};
+		apply();
+		history.atomic(`reorder: ${direction}`, (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+	}
+	function remove() {
+		remove_selection("remove");
+	}
+	/**
+	* Shared deletion body for `remove` and `cut` — identical
+	* capture/revert semantics, differing only in the history label
+	* (`verb`), so undo attribution names the gesture that caused the
+	* deletion.
+	*/
+	function remove_selection(verb) {
+		if (selection.length === 0) return;
+		const filtered = doc.prune_nested_nodes(selection).filter((id) => doc.parent_of(id) !== null);
+		if (filtered.length === 0) return;
+		discard_open_property_previews();
+		const captures = [...filtered].sort(subtree.by_document_order(doc)).map((id) => ({
+			id,
+			parent: doc.parent_of(id),
+			next_sibling: doc.next_element_sibling_of(id)
+		}));
+		const old_selection = selection;
+		const apply = () => {
+			for (const c of captures) doc.remove(c.id);
+			set_selection([]);
+		};
+		const revert = () => {
+			for (let i = captures.length - 1; i >= 0; i--) {
+				const c = captures[i];
+				doc.insert(c.id, c.parent, c.next_sibling);
+			}
+			set_selection(old_selection);
+		};
+		apply();
+		history.atomic(captures.length === 1 ? verb : `${verb} ${captures.length}`, (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+	}
+	function group$1() {
+		const plan = group.plan(doc, selection);
+		if (!plan) return false;
+		const group_id = doc.create_element("g");
+		const original_selection = selection;
+		const apply = () => {
+			doc.insert(group_id, plan.parent, plan.insert_before);
+			for (const child of plan.children) doc.insert(child, group_id, null);
+			set_selection([group_id]);
+		};
+		const revert = () => {
+			for (let i = plan.children.length - 1; i >= 0; i--) {
+				const child = plan.children[i];
+				doc.insert(child, plan.parent, plan.original_positions.get(child) ?? null);
+			}
+			doc.remove(group_id);
+			set_selection(original_selection);
+		};
+		apply();
+		history.atomic("group", (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		return true;
+	}
+	function ungroup(opts) {
+		let target;
+		if (opts?.id !== void 0) target = opts.id;
+		else {
+			if (selection.length !== 1) return false;
+			target = selection[0];
+		}
+		discard_open_property_previews();
+		const plan = group.plan_ungroup(doc, target);
+		if (!plan) return false;
+		const group_id = plan.group_id;
+		const group_next_sibling = doc.next_element_sibling_of(group_id);
+		const original_child_transforms = /* @__PURE__ */ new Map();
+		for (const child of plan.children) original_child_transforms.set(child, doc.get_attr(child, "transform"));
+		const group_ops = plan.group_transform === null ? [] : transform.parse(plan.group_transform) ?? [];
+		const original_selection = selection;
+		const apply = () => {
+			if (group_ops.length > 0) for (const child of plan.children) {
+				const child_ops = transform.parse(doc.get_attr(child, "transform")) ?? [];
+				const next = transform.emit([...group_ops, ...child_ops]);
+				doc.set_attr(child, "transform", next === "" ? null : next);
+			}
+			for (const child of plan.children) doc.insert(child, plan.parent, group_id);
+			doc.remove(group_id);
+			set_selection(plan.children);
+		};
+		const revert = () => {
+			doc.insert(group_id, plan.parent, group_next_sibling);
+			for (const child of plan.children) doc.insert(child, group_id, null);
+			if (group_ops.length > 0) for (const child of plan.children) doc.set_attr(child, "transform", original_child_transforms.get(child) ?? null);
+			set_selection(original_selection);
+		};
+		apply();
+		history.atomic("ungroup", (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		return true;
+	}
+	/**
+	* Atomic one-shot insertion. Used by paste, programmatic RPC, and the
+	* click-no-drag commit path inside the insertion gesture driver. One
+	* undo step. Returns the new node id.
+	*
+	* `attrs` are merged on top of `default_paint_attrs(tag)` — caller attrs
+	* win. `opts.parent` defaults to root; `opts.index` (insert-before
+	* sibling index) defaults to append; `opts.select` defaults to `true`.
+	*/
+	/**
+	* Resolve an optional `index` (position in `parent`'s element-children
+	* list to insert AT — anything at or after it shifts; out-of-range or
+	* `undefined` appends) to an insert-before anchor. Shared by `insert`,
+	* `insert_fragment`, and `insert_preview`.
+	*/
+	function resolve_insert_before(parent, index) {
+		if (index === void 0) return null;
+		return doc.element_children_of(parent)[index] ?? null;
+	}
+	function insert(tag, attrs, opts) {
+		const parent = opts?.parent ?? doc.root;
+		const select_after = opts?.select !== false;
+		const insert_before = resolve_insert_before(parent, opts?.index);
+		const id = doc.create_element(tag);
+		const merged_attrs = {
+			...default_paint_attrs_for(tag),
+			...attrs
+		};
+		const attr_pairs = Object.entries(merged_attrs);
+		const previous_selection = selection;
+		const apply = () => {
+			for (const [name, value] of attr_pairs) doc.set_attr(id, name, value);
+			doc.insert(id, parent, insert_before);
+			if (select_after) set_selection([id]);
+		};
+		const revert = () => {
+			doc.remove(id);
+			if (select_after) set_selection(previous_selection);
+		};
+		apply();
+		history.atomic(`insert ${tag}`, (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		return id;
+	}
+	/**
+	* Atomic fragment insertion — contract in {@link Commands.insert_fragment}.
+	* Parses + adopts via `doc.create_fragment` (subtrees registered but
+	* detached, like `create_element` — history.redo finds them via
+	* closure), computes the namespace hoist plan, then brackets inserts +
+	* hoisted declarations + selection in ONE history step.
+	*/
+	function insert_fragment(svg, opts) {
+		return insert_fragment_impl(svg, opts, "insert fragment");
+	}
+	/**
+	* Label-bearing body shared by `insert_fragment` and `paste` — same
+	* atomic insertion, differing only in history attribution (undo for a
+	* paste gesture should read "paste", not "insert fragment").
+	*/
+	function insert_fragment_impl(svg, opts, label) {
+		const parent = opts?.parent ?? doc.root;
+		if (!doc.is_element(parent) || !doc.contains(doc.root, parent)) throw new Error(`insert_fragment: parent ${JSON.stringify(parent)} is not an element in the current document`);
+		const select_after = opts?.select !== false;
+		const { roots, xmlns } = doc.create_fragment(svg);
+		if (roots.length === 0) return [];
+		const known_uri = new Map(WELL_KNOWN_NS_PREFIXES);
+		for (const d of xmlns) known_uri.set(d.prefix, d.uri);
+		const hoist = [];
+		const considered = /* @__PURE__ */ new Set();
+		for (const id of roots) for (const prefix of doc.undeclared_ns_prefixes(id)) {
+			if (considered.has(prefix)) continue;
+			considered.add(prefix);
+			if (doc.get_attr(doc.root, prefix, XMLNS_NS) !== null) continue;
+			const uri = known_uri.get(prefix);
+			if (uri === void 0) continue;
+			hoist.push({
+				prefix,
+				uri
+			});
+		}
+		const insert_before = resolve_insert_before(parent, opts?.index);
+		const previous_selection = selection;
+		const apply = () => {
+			for (const { prefix, uri } of hoist) doc.declare_xmlns(prefix, uri);
+			for (const id of roots) doc.insert(id, parent, insert_before);
+			if (select_after) set_selection(roots);
+		};
+		const revert = () => {
+			for (let i = roots.length - 1; i >= 0; i--) doc.remove(roots[i]);
+			for (const { prefix } of hoist) doc.set_attr(doc.root, prefix, null, XMLNS_NS);
+			if (select_after) set_selection(previous_selection);
+		};
+		apply();
+		history.atomic(label, (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		return roots;
+	}
+	function copy_impl(deliver_external) {
+		const payload = clipboard.extract_payload(doc, selection);
+		if (payload === null) return null;
+		clipboard_buffer = payload;
+		if (deliver_external && providers.clipboard) providers.clipboard.write(payload).catch((err) => {
+			console.warn("[svg-editor] clipboard provider write failed:", err);
+		});
+		return payload;
+	}
+	function copy() {
+		return copy_impl(true);
+	}
+	function cut_impl(deliver_external) {
+		if (selection.length === 0) return null;
+		discard_open_property_previews();
+		const payload = copy_impl(deliver_external);
+		if (payload === null) return null;
+		remove_selection("cut");
+		return payload;
+	}
+	function cut() {
+		return cut_impl(true);
+	}
+	function paste(text) {
+		if (text !== void 0 && typeof text !== "string") throw new TypeError(`paste(text) requires a string when provided, got ${text === null ? "null" : typeof text}`);
+		const source = text ?? clipboard_buffer;
+		if (source === null) return [];
+		try {
+			return insert_fragment_impl(source, void 0, "paste");
+		} catch (err) {
+			if (err instanceof TypeError) throw err;
+			return [];
+		}
+	}
+	/**
+	* Duplicate over `subtree.clone_plan` — see the `Commands` doc. Same
+	* atomic shape as `insert_fragment_impl`: closures own the
+	* insert/remove pair so redo re-inserts the same NodeIds.
+	*
+	* Repeating offset (gridaco/grida#825, spec §Repeating offset): when
+	* the targets are exactly the previous duplication's clones and
+	* geometry witnesses a rigid translate between that record's origins
+	* and clones, the fresh clones land displaced by the same delta. The
+	* offset rides the translate pipeline INSIDE the same atomic step —
+	* one undo removes copy + offset together. Clone baselines are
+	* key-swapped from the origins (a clone is a verbatim copy at rest —
+	* the orchestrator's `enter_clone` trick), so nothing reads the
+	* detached clones. Any failed precondition degrades to plain
+	* duplicate-in-place; never an error.
+	*/
+	function duplicate() {
+		const plan = subtree.clone_plan(doc, selection);
+		if (plan.length === 0) return [];
+		const clones = plan.map((p) => p.clone);
+		const origins = plan.map((p) => p.origin);
+		const previous_selection = selection;
+		const delta = subtree.repeat_delta(active_duplication, origins, (id) => geometry_provider ? geometry_provider.bounds_of(id) : null);
+		let offset_plan = null;
+		if (delta) {
+			const baselines = /* @__PURE__ */ new Map();
+			for (const p of plan) baselines.set(p.clone, translate_pipeline.intent.capture_baseline(doc, p.origin));
+			offset_plan = {
+				ids: clones,
+				baselines,
+				delta
+			};
+		}
+		const apply = () => {
+			subtree.insert_plan(doc, plan);
+			if (offset_plan) translate_pipeline.apply(doc, offset_plan, project_world_delta);
+			set_selection(clones);
+		};
+		const revert = () => {
+			if (offset_plan) translate_pipeline.revert(doc, offset_plan);
+			subtree.remove_plan(doc, plan);
+			set_selection(previous_selection);
+		};
+		apply();
+		history.atomic("duplicate", (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		active_duplication = {
+			origins,
+			clones
+		};
+		return clones;
+	}
+	/**
+	* Preview-bracketed insertion. Used by the pointer-driven drag gesture
+	* in the DOM surface. Per-frame attr writes call `update(attrs)`; one
+	* undo step on `commit()`; clean rollback on `discard()`.
+	*
+	* The node is created and inserted on open so the HUD selection chrome
+	* can render the in-progress shape immediately. On `discard()` the
+	* preview's revert removes the node entirely.
+	*/
+	function insert_preview(tag, initial, opts) {
+		const parent = opts?.parent ?? doc.root;
+		const insert_before = resolve_insert_before(parent, opts?.index);
+		const id = doc.create_element(tag);
+		const previous_selection = selection;
+		const live_attrs = {
+			...default_paint_attrs_for(tag),
+			...initial
+		};
+		for (const name in live_attrs) doc.set_attr(id, name, live_attrs[name]);
+		doc.insert(id, parent, insert_before);
+		set_selection([id]);
+		const preview = history.preview(`insert ${tag}`);
+		const live = () => preview.state === "active";
+		const apply = () => {
+			for (const name in live_attrs) doc.set_attr(id, name, live_attrs[name]);
+			if (doc.parent_of(id) === null) doc.insert(id, parent, insert_before);
+			set_selection([id]);
+		};
+		const revert = () => {
+			doc.remove(id);
+			set_selection(previous_selection);
+		};
+		const entry = {
+			providerId: PROVIDER_ID,
+			apply,
+			revert
+		};
+		preview.set(entry);
+		return {
+			id,
+			update(attrs) {
+				if (!live()) return;
+				for (const name in attrs) {
+					live_attrs[name] = attrs[name];
+					doc.set_attr(id, name, attrs[name]);
+				}
+				preview.set(entry);
+			},
+			commit() {
+				if (!live()) return;
+				preview.commit();
+			},
+			discard() {
+				if (!live()) return;
+				preview.discard();
+			}
+		};
+	}
+	/**
+	* Text-creation bracket for the click-to-place text tool. Creates an
+	* empty `<text>` with `initial` attrs, opens a single history preview,
+	* and selects it — the DOM surface then mounts inline content-edit on
+	* it. The surface finalizes the returned session when content-edit
+	* exits:
+	*
+	*  - `commit()` — snapshots the live text content into the delta and
+	*    commits ONE undo step (create + text together). Redo replays both,
+	*    so a redone text insert keeps its content (a plain `insert_preview`
+	*    would lose it — text is not an attribute).
+	*  - `discard()` — rolls the creation back entirely: no node, no
+	*    committed history entry. This is the empty-equals-delete rule for a
+	*    freshly-placed node (design:
+	*    `docs/wg/feat-svg-editor/text-tool.md`).
+	*
+	* The node is inserted empty on open (so the caret has somewhere to
+	* live); live edits mutate its text in place, and `commit()` reads the
+	* final text back off the document.
+	*/
+	function insert_text_preview(initial, opts) {
+		const parent = opts?.parent ?? doc.root;
+		const id = doc.create_element("text");
+		const previous_selection = selection;
+		const attrs = { ...initial };
+		let committed_text = "";
+		const apply = () => {
+			for (const name in attrs) doc.set_attr(id, name, attrs[name]);
+			if (doc.parent_of(id) === null) doc.insert(id, parent, null);
+			doc.set_text(id, committed_text);
+			set_selection([id]);
+		};
+		const revert = () => {
+			doc.remove(id);
+			set_selection(previous_selection);
+		};
+		const preview = history.preview("insert text");
+		const live = () => preview.state === "active";
+		preview.set({
+			providerId: PROVIDER_ID,
+			apply,
+			revert
+		});
+		return {
+			id,
+			commit() {
+				if (!live()) return;
+				committed_text = doc.text_of(id);
+				preview.commit();
+			},
+			discard() {
+				if (!live()) return;
+				preview.discard();
+			}
+		};
+	}
+	/** Per-tag default paint attrs. Wrapped so callers don't need to depend
+	*  on the InsertableTag type — `insert()` accepts arbitrary string tags
+	*  (so `commands.insert("path", ...)` works for paste / RPC) but only
+	*  the closed insertable set gets default paint. */
+	function default_paint_attrs_for(tag) {
+		if (tag === "rect" || tag === "ellipse" || tag === "line") return insertions.default_paint_attrs(tag);
+		return {};
+	}
+	function set_text(value) {
+		if (selection.length !== 1) return;
+		const target = selection[0];
+		if (!doc.is_text_edit_target(target)) return;
+		const original = doc.text_of(target);
+		if (original === value) return;
+		const apply = () => {
+			doc.set_text(target, value);
+			emit();
+		};
+		const revert = () => {
+			doc.set_text(target, original);
+			emit();
+		};
+		apply();
+		history.atomic("edit text", (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+	}
+	let content_edit_driver = null;
+	let vector_subselect_driver = null;
+	let vector_delete_driver = null;
+	let computed_resolver = null;
+	function dom_computed_property(id, name) {
+		return computed_resolver?.computed_property(id, name) ?? null;
+	}
+	function dom_computed_paint(id, channel) {
+		return computed_resolver?.computed_paint(id, channel) ?? null;
+	}
+	let current_surface_hover = null;
+	let surface_hover_override = null;
+	const surface_hover_listeners = /* @__PURE__ */ new Set();
+	let surface_hover_override_driver = null;
+	function notify_surface_hover() {
+		for (const cb of surface_hover_listeners) cb();
+	}
+	function _set_current_surface_hover(id) {
+		if (current_surface_hover === id) return;
+		current_surface_hover = id;
+		notify_surface_hover();
+	}
+	const pick_listeners = /* @__PURE__ */ new Set();
+	function notify_pick(e) {
+		for (const cb of pick_listeners) cb(e);
+	}
+	let current_vector_subselection = null;
+	const vector_subselection_listeners = /* @__PURE__ */ new Set();
+	function notify_vector_subselection() {
+		for (const cb of vector_subselection_listeners) cb(current_vector_subselection);
+	}
+	function _set_current_vector_subselection(sel) {
+		current_vector_subselection = sel;
+		notify_vector_subselection();
+	}
+	function enter_content_edit(target, opts) {
+		const id = target ?? (selection.length === 1 ? selection[0] : null);
+		if (!id) return false;
+		if (!doc.is_text_edit_target(id) && doc.is_vector_edit_target(id) === null) return false;
+		if (!content_edit_driver) return false;
+		return content_edit_driver(id, opts);
+	}
+	function set_vector_selection(input, mode) {
+		if (!vector_subselect_driver) return false;
+		return vector_subselect_driver(input, mode);
+	}
+	function delete_vector_selection() {
+		if (!vector_delete_driver) return false;
+		return vector_delete_driver();
+	}
+	function load_svg(svg) {
+		discard_open_property_previews();
+		history.clear();
+		doc.load(svg);
+		selection = [];
+		scope = null;
+		mode = "select";
+		tool = TOOL_CURSOR;
+		active_duplication = null;
+		baseline_revision = doc.revision;
+		load_version++;
+		emit();
+	}
+	function serialize_svg() {
+		return doc.serialize();
+	}
+	function undo() {
+		history.undo();
+	}
+	function redo() {
+		history.redo();
+	}
+	const registry = new CommandRegistry();
+	const keymap = new Keymap(registry);
+	const commands = {
+		select,
+		deselect,
+		select_all,
+		select_sibling,
+		enter_scope,
+		exit_scope,
+		set_mode,
+		set_property,
+		preview_property,
+		set_paint,
+		preview_paint,
+		set_paint_from_gradient,
+		set_opacity,
+		translate,
+		nudge,
+		resize_to,
+		resize_by,
+		rotate,
+		rotate_to,
+		transform: apply_transform,
+		flatten_transform,
+		align,
+		reorder,
+		remove,
+		copy,
+		cut,
+		paste,
+		duplicate,
+		group: group$1,
+		ungroup,
+		insert,
+		insert_fragment,
+		insert_preview,
+		set_text,
+		set_vector_selection,
+		delete_vector_selection,
+		load_svg,
+		serialize_svg,
+		undo,
+		redo,
+		register: (id, handler) => registry.register(id, handler),
+		invoke: (id, args) => registry.invoke(id, args),
+		has: (id) => registry.has(id)
+	};
+	function load(svg) {
+		load_svg(svg);
+	}
+	function serialize() {
+		return doc.serialize();
+	}
+	function reset() {
+		discard_open_property_previews();
+		history.clear();
+		doc.reset_to_original();
+		selection = [];
+		scope = null;
+		mode = "select";
+		tool = TOOL_CURSOR;
+		active_duplication = null;
+		baseline_revision = doc.revision;
+		emit();
+	}
+	function attach(surface) {
+		if (attached_surface) attached_surface.dispose();
+		attached_surface = surface;
+		return { detach() {
+			if (attached_surface === surface) {
+				attached_surface.dispose();
+				attached_surface = null;
+			}
+		} };
+	}
+	function detach() {
+		if (attached_surface) {
+			attached_surface.dispose();
+			attached_surface = null;
+		}
+	}
+	function dispose() {
+		detach();
+		listeners.clear();
+		surface_hover_listeners.clear();
+		geometry_listeners.clear();
+		translate_commit_listeners.clear();
+		pick_listeners.clear();
+		vector_subselection_listeners.clear();
+	}
+	function set_style(partial) {
+		style = {
+			...style,
+			...partial
+		};
+		emit();
+	}
+	const public_editor = {
+		/**
+		* Low-level IR handle. Mutating directly bypasses history; prefer
+		* `editor.commands` for app code.
+		*/
+		document: doc,
+		get state() {
+			return snapshot();
+		},
+		subscribe,
+		subscribe_with_selector,
+		node_properties,
+		node_paint,
+		dom_computed_property,
+		dom_computed_paint,
+		/**
+		* Enter content-edit mode on a `<text>` node. Returns `false` (no-op)
+		* when no DOM surface is attached.
+		*/
+		enter_content_edit,
+		defs,
+		commands,
+		/**
+		* Human-readable label for hierarchy panels. SVG has no native "name";
+		* this is the package's single source of truth so panels don't reinvent
+		* the rule.
+		*
+		* Rule:
+		*   - `<text>` → text content, whitespace-collapsed and truncated at
+		*     ~40 chars (falls back to `"text"` for empty content).
+		*   - Otherwise → tag name, suffixed with `#id` when the `id` attribute
+		*     is present (e.g. `"rect #sun"`).
+		*
+		* `opts.tagLabel` lets callers substitute a friendlier or localized
+		* term for the raw tag (e.g. `"rect"` → `"Rectangle"`). Only invoked
+		* on the non-text branch.
+		*/
+		display_label(id, opts) {
+			const tag = doc.tag_of(id);
+			if (tag === "text") {
+				const collapsed = doc.text_of(id).replace(/\s+/g, " ").trim();
+				if (collapsed.length === 0) return "text";
+				return collapsed.length > DISPLAY_LABEL_MAX_LEN ? `${collapsed.slice(0, DISPLAY_LABEL_MAX_LEN)}…` : collapsed;
+			}
+			const elem_id = doc.get_attr(id, "id");
+			const head = opts?.tagLabel ? opts.tagLabel(tag) : tag;
+			return elem_id && elem_id.length > 0 ? `${head} #${elem_id}` : head;
+		},
+		tree() {
+			return tree_snapshot();
+		},
+		/**
+		* The effective hover from the attached HUD surface — what's under the
+		* pointer, OR whatever `set_surface_hover_override` last pushed. Used
+		* by out-of-canvas UI (layers panel, breadcrumbs) to mirror the canvas
+		* highlight. Returns `null` when nothing is hovered.
+		*/
+		surface_hover() {
+			return current_surface_hover;
+		},
+		/**
+		* Push a hover override into the HUD surface — e.g. when the user
+		* hovers a row in a layers panel. The HUD will render the override's
+		* outline and (when applicable) drive measurement to that node.
+		* Pass `null` to clear and let the pointer pick take over again.
+		*/
+		set_surface_hover_override(id) {
+			if (surface_hover_override === id) return;
+			surface_hover_override = id;
+			if (surface_hover_override_driver) surface_hover_override_driver(id);
+		},
+		/**
+		* Subscribe to changes in the effective surface hover. Fires when the
+		* HUD reports a new pointer pick AND when an override is set/cleared.
+		* Cheap channel — does NOT bump `state.version`.
+		*/
+		subscribe_surface_hover(cb) {
+			surface_hover_listeners.add(cb);
+			return () => {
+				surface_hover_listeners.delete(cb);
+			};
+		},
+		/**
+		* Subscribe to pick (tap) outcomes — a discrete click on the canvas,
+		* reporting the document-space point and the node under it (`null` for
+		* empty canvas), plus the button and modifier snapshot. Fires once per
+		* tap, after the editor's own selection handling. Observe-only: a pick
+		* cannot alter selection, and the channel does NOT bump `state.version`.
+		* See {@link PickEvent}.
+		*
+		* @unstable
+		*/
+		subscribe_pick(cb) {
+			pick_listeners.add(cb);
+			return () => {
+				pick_listeners.delete(cb);
+			};
+		},
+		/**
+		* The current vector sub-selection (vertices / segments / tangents) inside
+		* an open vector content-edit session, or `null` when no such session is
+		* active (gridaco/grida#790). The read counterpart to
+		* `commands.set_vector_selection`. See {@link VectorSubSelection}.
+		*/
+		vector_subselection() {
+			return current_vector_subselection;
+		},
+		/**
+		* Subscribe to vector sub-selection changes — fires whenever the live
+		* vertex / segment / tangent selection changes (click, marquee, lasso,
+		* programmatic `set_vector_selection`, undo/redo) and on session
+		* enter/exit (`null` on exit). The callback receives the new value, also
+		* readable via {@link vector_subselection}. Cheap channel — does NOT bump
+		* `state.version`.
+		*/
+		subscribe_vector_subselection(cb) {
+			vector_subselection_listeners.add(cb);
+			return () => {
+				vector_subselection_listeners.delete(cb);
+			};
+		},
+		/**
+		* Subscribe to bounds-affecting changes. Fires when any document
+		* mutation advances `state.geometry_version` — drag, resize, text
+		* edit, structural insert/remove. Skips presentation-only writes
+		* (fill, opacity, stroke-color).
+		*/
+		subscribe_geometry(cb) {
+			geometry_listeners.add(cb);
+			return () => {
+				geometry_listeners.delete(cb);
+			};
+		},
+		/**
+		* World-space geometry queries. Non-null when a DOM surface is
+		* attached; null otherwise (queries need a renderer to read bbox
+		* from). Read-only — never mutates document state.
+		*/
+		get geometry() {
+			return geometry_provider;
+		},
+		modes,
+		/** Switch the active tool. No history entry; bumps `state.version`. */
+		set_tool,
+		get style() {
+			return style;
+		},
+		set_style,
+		load,
+		serialize,
+		/**
+		* Serialize a single element's subtree as an SVG **fragment**, using the
+		* same trivia-preserving rules as {@link serialize} — for handing "the
+		* markup of the element the user selected" to a downstream consumer
+		* (e.g. an AI agent) without re-serializing the whole document.
+		*
+		* Fragment, not document (see `SvgDocument.serialize_node`): it does NOT
+		* carry `serialize()`'s whole-document round-trip guarantee. Namespace
+		* declarations on an ancestor (`xmlns:xlink`, normally on the root
+		* `<svg>`) are NOT inlined — a node using `xlink:href` serializes without
+		* `xmlns:xlink`. Throws on an unknown id or a non-element node.
+		*/
+		serialize_node(id) {
+			return doc.serialize_node(id);
+		},
+		reset,
+		attach,
+		detach,
+		dispose,
+		providers,
+		_internal: {
+			doc,
+			history: {
+				preview: (label) => history.preview(label),
+				undo_label: () => history.stack.undoLabel
+			},
+			clipboard: {
+				copy: () => copy_impl(false),
+				cut: () => cut_impl(false)
+			},
+			insert_text_preview,
+			emit,
+			subscribe_translate_commit(cb) {
+				translate_commit_listeners.add(cb);
+				return () => {
+					translate_commit_listeners.delete(cb);
+				};
+			},
+			notify_translate_commit,
+			seed_duplication(record) {
+				active_duplication = record;
+			},
+			set_content_edit_driver(fn) {
+				content_edit_driver = fn;
+			},
+			set_vector_subselect_driver(fn) {
+				vector_subselect_driver = fn;
+			},
+			set_vector_delete_driver(fn) {
+				vector_delete_driver = fn;
+			},
+			push_vector_subselection(sel) {
+				_set_current_vector_subselection(sel);
+			},
+			set_surface_hover_override_driver(fn) {
+				surface_hover_override_driver = fn;
+				if (fn) fn(surface_hover_override);
+			},
+			push_surface_hover(id) {
+				_set_current_surface_hover(id);
+			},
+			push_pick(e) {
+				notify_pick(e);
+			},
+			set_computed_resolver(fn) {
+				computed_resolver = fn;
+			},
+			set_geometry(p) {
+				geometry_provider = p;
+			},
+			register_command(id, handler) {
+				return registry.register(id, handler);
+			},
+			bump_geometry() {
+				doc.bump_geometry();
+				fire_geometry_listeners_if_advanced();
+			}
+		},
+		keymap
+	};
+	registerDefaultCommands(registry, public_editor);
+	applyDefaultBindings(keymap);
+	return public_editor;
+}
+/**
+* Construct a headless SVG editor. The returned object is the public
+* editor surface — observation (`state`, `subscribe`), commands
+* (`commands.*`), lifecycle (`attach` / `dispose`), and the typed-read
+* caches (`node_paint`, `node_properties`). Surfaces (DOM, headless)
+* attach later via `editor.attach(surface)`.
+*/
+function createSvgEditor(opts) {
+	if (opts == null || typeof opts.svg !== "string") {
+		const got = opts == null ? String(opts) : opts.svg === null ? "null" : typeof opts.svg;
+		throw new TypeError(`createSvgEditor({ svg }) requires { svg: string }, got svg=${got}`);
+	}
+	return _create_svg_editor_internal(opts);
+}
+const FLATTEN_IDENT = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+function flatten_mul(m1, m2) {
+	const [a1, b1, c1, d1, e1, f1] = m1;
+	const [a2, b2, c2, d2, e2, f2] = m2;
+	return [
+		a1 * a2 + c1 * b2,
+		b1 * a2 + d1 * b2,
+		a1 * c2 + c1 * d2,
+		b1 * c2 + d1 * d2,
+		a1 * e2 + c1 * f2 + e1,
+		b1 * e2 + d1 * f2 + f1
+	];
+}
+function flatten_op_to_mat(op) {
+	switch (op.type) {
+		case "matrix": return [
+			op.a,
+			op.b,
+			op.c,
+			op.d,
+			op.e,
+			op.f
+		];
+		case "translate": return [
+			1,
+			0,
+			0,
+			1,
+			op.tx,
+			op.ty
+		];
+		case "rotate": {
+			const rad = op.angle * Math.PI / 180;
+			const c = Math.cos(rad);
+			const s = Math.sin(rad);
+			if (op.cx === 0 && op.cy === 0) return [
+				c,
+				s,
+				-s,
+				c,
+				0,
+				0
+			];
+			const e = op.cx - c * op.cx + s * op.cy;
+			const f = op.cy - s * op.cx - c * op.cy;
+			return [
+				c,
+				s,
+				-s,
+				c,
+				e,
+				f
+			];
+		}
+		case "scale": return [
+			op.sx,
+			0,
+			0,
+			op.sy,
+			0,
+			0
+		];
+		case "skewX": {
+			const rad = op.angle * Math.PI / 180;
+			return [
+				1,
+				0,
+				Math.tan(rad),
+				1,
+				0,
+				0
+			];
+		}
+		case "skewY": {
+			const rad = op.angle * Math.PI / 180;
+			return [
+				1,
+				Math.tan(rad),
+				0,
+				1,
+				0,
+				0
+			];
+		}
+	}
+}
+//#endregion
+export { createSvgEditor as t };