@grida/svg-editor 1.0.0-alpha.1 → 1.0.0-alpha.12

package/dist/{editor-B5z-gTML.mjs → editor-DtuRIs-Q.mjs}

@@ -1,6 +1,8 @@
-import { i as apply_translate, n as serialize_paint, o as capture_translate_baseline, t as parse_paint } from "./paint-DuCg6Y-K.mjs";
+import { A as is_text_input_focused, D as parse_transform_list, E as emit_transform_list, _ as apply_translate, a as DEFAULT_STYLE, c as serialize_paint, g as apply_rotate, h as apply_resize, k as plan_group, m as STAGES_NUDGE, o as TOOL_CURSOR, p as prepare_translate_rpc, r as default_paint_attrs, s as parse_paint, u as prepare_rotate_rpc, v as capture_resize_baseline, x as is_resizable, y as capture_translate_baseline } from "./insertions-Okcuo-Ck.mjs";
 import { HistoryImpl } from "@grida/history";
 import { KeyCode, M, chunkKey, eventToChunk, getKeyboardOS, kb, keybindingsToKeyCodes } from "@grida/keybinding";
+import cmath from "@grida/cmath";
+import { XLINK_NS, encode_attr_value, encode_text, parse_svg } from "@grida/svg/parser";
 //#region src/commands/registry.ts
 var CommandRegistry = class {
 	constructor() {
@@ -36,6 +38,25 @@ var CommandRegistry = class {
 };
 //#endregion
 //#region src/commands/defaults.ts
+/** Command id for `tool.set`. Bound to V/R/O/L in `keymap/defaults.ts`. */
+const TOOL_SET = "tool.set";
+/**
+* The headless default `transform.nudge` handler. Exported so a host
+* surface that overrides nudge (e.g. for faux-snap UX) can restore the
+* default on teardown — the registry doesn't stack handlers, so a plain
+* unregister leaves the slot empty.
+*/
+function default_nudge_handler(editor) {
+	return (args) => {
+		if (editor.state.selection.length === 0) return false;
+		const { dx, dy } = args;
+		editor.commands.nudge({
+			dx,
+			dy
+		});
+		return true;
+	};
+}
 function registerDefaultCommands(reg, editor) {
 	reg.register("history.undo", () => {
 		if (!editor.state.can_undo) return false;
@@ -57,6 +78,46 @@ function registerDefaultCommands(reg, editor) {
 		editor.commands.remove();
 		return true;
 	});
+	reg.register("selection.group", () => {
+		if (editor.state.mode !== "select") return false;
+		if (editor.state.selection.length === 0) return false;
+		return editor.commands.group();
+	});
+	reg.register("selection.resize_to", (args) => {
+		if (editor.state.mode !== "select") return false;
+		if (editor.state.selection.length === 0) return false;
+		const target = args;
+		return editor.commands.resize_to(target);
+	});
+	reg.register("selection.rotate", (args) => {
+		if (editor.state.mode !== "select") return false;
+		if (editor.state.selection.length === 0) return false;
+		const a = args;
+		return editor.commands.rotate(a.angle, { pivot: a.pivot });
+	});
+	reg.register("selection.rotate_to", (args) => {
+		if (editor.state.mode !== "select") return false;
+		if (editor.state.selection.length === 0) return false;
+		const a = args;
+		return editor.commands.rotate_to(a.angle, { pivot: a.pivot });
+	});
+	reg.register("selection.flatten_transform", () => {
+		if (editor.state.mode !== "select") return false;
+		if (editor.state.selection.length === 0) return false;
+		return editor.commands.flatten_transform();
+	});
+	reg.register("selection.all", () => {
+		if (editor.state.mode !== "select") return false;
+		return editor.commands.select_all();
+	});
+	reg.register("selection.sibling", (args) => {
+		if (editor.state.mode !== "select") return false;
+		return editor.commands.select_sibling(args);
+	});
+	reg.register("selection.align", (args) => {
+		if (editor.state.mode !== "select") return false;
+		return editor.commands.align(args);
+	});
 	reg.register("hierarchy.enter", () => {
 		if (editor.state.selection.length !== 1) return false;
 		const id = editor.state.selection[0];
@@ -74,20 +135,17 @@ function registerDefaultCommands(reg, editor) {
 		editor.commands.select(node.parent);
 		return true;
 	});
-	reg.register("transform.nudge", (args) => {
-		if (editor.state.selection.length === 0) return false;
-		const { dx, dy } = args;
-		editor.commands.translate({
-			dx,
-			dy
-		});
-		return true;
-	});
+	reg.register("transform.nudge", default_nudge_handler(editor));
 	reg.register("reorder", (args) => {
 		if (editor.state.selection.length !== 1) return false;
 		editor.commands.reorder(args);
 		return true;
 	});
+	reg.register(TOOL_SET, (args) => {
+		if (editor.state.mode !== "select") return false;
+		editor.set_tool(args);
+		return true;
+	});
 }
 //#endregion
 //#region src/keymap/keymap.ts
@@ -111,15 +169,6 @@ const TEXT_INPUT_SAFE_MODS = new Set([
 	KeyCode.Ctrl,
 	KeyCode.Alt
 ]);
-function is_text_input_focused() {
-	if (typeof document === "undefined") return false;
-	const el = document.activeElement;
-	if (!el) return false;
-	const tag = el.tagName;
-	if (tag === "INPUT" || tag === "TEXTAREA") return true;
-	if (el.isContentEditable) return true;
-	return false;
-}
 var Keymap = class {
 	constructor(commands, platformGetter = getKeyboardOS) {
 		this.commands = commands;
@@ -177,10 +226,35 @@ var Keymap = class {
 		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
+	* text-input-focused guard `dispatch` uses, so a typing user's
+	* keystroke isn't "claimed" by an unrelated unmodified key.
+	*/
+	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() && !this.has_safe_mod(chunk.mods)) return false;
+		return true;
+	}
+	/**
 	* Match the event against bound chunks, then run candidates in chain
-	* order. Returns `true` and calls `preventDefault()` on the first
-	* handler that consumes; returns `false` if nothing matched or all
-	* matches fell through.
+	* order. Returns `true` on the first handler that consumes; returns
+	* `false` if nothing matched or all matches fell through.
+	*
+	* `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);
@@ -191,10 +265,7 @@ var Keymap = class {
 		const text_focused = is_text_input_focused();
 		for (const { binding } of list) {
 			if (text_focused && !this.has_safe_mod(chunk.mods)) continue;
-			if (this.commands.invoke(binding.command, binding.args)) {
-				event.preventDefault();
-				return true;
-			}
+			if (this.commands.invoke(binding.command, binding.args)) return true;
 		}
 		return false;
 	}
@@ -237,6 +308,7 @@ function compareEntries(a, b) {
 * Same key, multiple meanings? Add multiple rows. The chain semantics
 * (handler returns `false` when not applicable) handle the rest.
 */
+const NUDGE_MEANINGFUL = M.Shift;
 const DEFAULT_BINDINGS = [
 	{
 		keybinding: kb(KeyCode.KeyZ, M.CtrlCmd),
@@ -262,6 +334,54 @@ const DEFAULT_BINDINGS = [
 		keybinding: kb(KeyCode.Delete),
 		command: "selection.remove"
 	},
+	{
+		keybinding: kb(KeyCode.KeyG, M.CtrlCmd),
+		command: "selection.group"
+	},
+	{
+		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: "hierarchy.enter"
@@ -271,7 +391,7 @@ const DEFAULT_BINDINGS = [
 		command: "hierarchy.exit"
 	},
 	{
-		keybinding: kb(KeyCode.LeftArrow),
+		keybinding: kb(KeyCode.LeftArrow, 0, NUDGE_MEANINGFUL),
 		command: "transform.nudge",
 		args: {
 			dx: -1,
@@ -279,7 +399,7 @@ const DEFAULT_BINDINGS = [
 		}
 	},
 	{
-		keybinding: kb(KeyCode.RightArrow),
+		keybinding: kb(KeyCode.RightArrow, 0, NUDGE_MEANINGFUL),
 		command: "transform.nudge",
 		args: {
 			dx: 1,
@@ -287,7 +407,7 @@ const DEFAULT_BINDINGS = [
 		}
 	},
 	{
-		keybinding: kb(KeyCode.UpArrow),
+		keybinding: kb(KeyCode.UpArrow, 0, NUDGE_MEANINGFUL),
 		command: "transform.nudge",
 		args: {
 			dx: 0,
@@ -295,7 +415,7 @@ const DEFAULT_BINDINGS = [
 		}
 	},
 	{
-		keybinding: kb(KeyCode.DownArrow),
+		keybinding: kb(KeyCode.DownArrow, 0, NUDGE_MEANINGFUL),
 		command: "transform.nudge",
 		args: {
 			dx: 0,
@@ -303,7 +423,7 @@ const DEFAULT_BINDINGS = [
 		}
 	},
 	{
-		keybinding: kb(KeyCode.LeftArrow, M.Shift),
+		keybinding: kb(KeyCode.LeftArrow, M.Shift, NUDGE_MEANINGFUL),
 		command: "transform.nudge",
 		args: {
 			dx: -10,
@@ -311,7 +431,7 @@ const DEFAULT_BINDINGS = [
 		}
 	},
 	{
-		keybinding: kb(KeyCode.RightArrow, M.Shift),
+		keybinding: kb(KeyCode.RightArrow, M.Shift, NUDGE_MEANINGFUL),
 		command: "transform.nudge",
 		args: {
 			dx: 10,
@@ -319,7 +439,7 @@ const DEFAULT_BINDINGS = [
 		}
 	},
 	{
-		keybinding: kb(KeyCode.UpArrow, M.Shift),
+		keybinding: kb(KeyCode.UpArrow, M.Shift, NUDGE_MEANINGFUL),
 		command: "transform.nudge",
 		args: {
 			dx: 0,
@@ -327,13 +447,42 @@ const DEFAULT_BINDINGS = [
 		}
 	},
 	{
-		keybinding: kb(KeyCode.DownArrow, M.Shift),
+		keybinding: kb(KeyCode.DownArrow, M.Shift, NUDGE_MEANINGFUL),
 		command: "transform.nudge",
 		args: {
 			dx: 0,
 			dy: 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.BracketRight),
 		command: "reorder",
@@ -360,16 +509,33 @@ function applyDefaultBindings(keymap) {
 	for (const b of DEFAULT_BINDINGS) keymap.bind(b);
 }
 //#endregion
+//#region src/util/equal.ts
+function array_shallow_equal(a, b) {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+//#endregion
 //#region src/core/defs.ts
 var GradientsRegistry = class {
 	constructor(doc) {
 		this.doc = doc;
 		this.listeners = /* @__PURE__ */ new Set();
 		this.counter = 0;
-		doc.on_change(() => this.emit());
+		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);
@@ -378,14 +544,34 @@ var GradientsRegistry = class {
 				if (!id) continue;
 				const definition = this.read_gradient(child, tag);
 				if (!definition) continue;
-				out.push({
-					id,
-					definition,
-					ref_count: this.count_refs(id)
-				});
+				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);
 			}
 		}
-		return out;
+		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;
@@ -498,7 +684,7 @@ var GradientsRegistry = class {
 		};
 	}
 	write_gradient(node, def) {
-		for (const c of [...this.doc.children_of(node)]) this.doc.remove(c);
+		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));
 		};
@@ -545,290 +731,71 @@ var GradientsRegistry = class {
 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) };
 }
-const XML_NS = "http://www.w3.org/XML/1998/namespace";
-const XMLNS_NS = "http://www.w3.org/2000/xmlns/";
-let id_counter = 0;
-function fresh_id() {
-	return `n${id_counter++}`;
-}
-function reset_id_counter() {
-	id_counter = 0;
-}
-function parse_svg(src) {
-	reset_id_counter();
-	const nodes = /* @__PURE__ */ new Map();
-	const prolog = [];
-	const epilog = [];
-	let i = 0;
-	const n = src.length;
-	let root = null;
-	const open_stack = [];
-	/** ns prefix → uri, per ancestor scope (top of stack). */
-	const ns_stack = [new Map([["xml", XML_NS], ["xmlns", XMLNS_NS]])];
-	/** default ns per ancestor scope (top of stack). */
-	const default_ns_stack = [null];
-	function push_to_parent(node) {
-		nodes.set(node.id, node);
-		if (open_stack.length === 0) {
-			if (node.kind === "element" && root === null) return;
-			if (root === null) prolog.push(node);
-			else epilog.push(node);
-			return;
-		}
-		const parent = open_stack[open_stack.length - 1];
-		node.parent = parent.id;
-		parent.children.push(node.id);
-	}
-	while (i < n) {
-		if (src[i] === "<") {
-			if (src.startsWith("<!--", i)) {
-				const end = src.indexOf("-->", i + 4);
-				if (end === -1) throw new Error("unterminated comment");
-				const value = src.slice(i + 4, end);
-				push_to_parent({
-					kind: "comment",
-					id: fresh_id(),
-					parent: null,
-					value
-				});
-				i = end + 3;
-				continue;
-			}
-			if (src.startsWith("<![CDATA[", i)) {
-				const end = src.indexOf("]]>", i + 9);
-				if (end === -1) throw new Error("unterminated CDATA");
-				const value = src.slice(i + 9, end);
-				push_to_parent({
-					kind: "cdata",
-					id: fresh_id(),
-					parent: null,
-					value
-				});
-				i = end + 3;
-				continue;
-			}
-			if (src.startsWith("<!DOCTYPE", i) || src.startsWith("<!doctype", i)) {
-				let depth = 1;
-				let j = i + 9;
-				while (j < n && depth > 0) {
-					const c = src[j];
-					if (c === "<") depth++;
-					else if (c === ">") depth--;
-					if (depth === 0) break;
-					j++;
-				}
-				if (j >= n) throw new Error("unterminated doctype");
-				push_to_parent({
-					kind: "doctype",
-					id: fresh_id(),
-					parent: null,
-					value: src.slice(i + 9, j)
-				});
-				i = j + 1;
-				continue;
-			}
-			if (src.startsWith("<?", i)) {
-				const end = src.indexOf("?>", i + 2);
-				if (end === -1) throw new Error("unterminated PI");
-				const body = src.slice(i + 2, end);
-				const space = body.search(/\s/);
-				const target = space === -1 ? body : body.slice(0, space);
-				const value = space === -1 ? "" : body.slice(space + 1);
-				push_to_parent({
-					kind: "pi",
-					id: fresh_id(),
-					parent: null,
-					target,
-					value
-				});
-				i = end + 2;
-				continue;
-			}
-			if (src[i + 1] === "/") {
-				const end = src.indexOf(">", i + 2);
-				if (end === -1) throw new Error("unterminated end tag");
-				const open = open_stack.pop();
-				if (!open) throw new Error("unexpected end tag at " + i);
-				ns_stack.pop();
-				default_ns_stack.pop();
-				const m = src.slice(i + 2, end).match(/^(\s*)([^\s]+)(\s*)$/);
-				if (m) {
-					open.close_tag_leading = m[1];
-					open.close_tag_trailing = m[3];
-				}
-				i = end + 1;
-				continue;
-			}
-			const start = i + 1;
-			let j = start;
-			while (j < n && !/[\s/>]/.test(src[j])) j++;
-			const raw_tag = src.slice(start, j);
-			const [prefix, local] = split_qname(raw_tag);
-			const { attrs, end_index, self_closing, trailing } = parse_attrs(src, j);
-			const new_ns_map = new Map(ns_stack[ns_stack.length - 1]);
-			let new_default_ns = default_ns_stack[default_ns_stack.length - 1];
-			for (const a of attrs) if (a.prefix === "xmlns") new_ns_map.set(a.local, a.value);
-			else if (a.prefix === null && a.local === "xmlns") new_default_ns = a.value;
-			for (const a of attrs) if (a.prefix === "xmlns" || a.prefix === null && a.local === "xmlns") a.ns = XMLNS_NS;
-			else if (a.prefix) a.ns = new_ns_map.get(a.prefix) ?? null;
-			else a.ns = null;
-			const element_ns = prefix ? new_ns_map.get(prefix) ?? null : new_default_ns;
-			const elem = {
-				kind: "element",
-				id: fresh_id(),
-				parent: null,
-				raw_tag,
-				prefix,
-				local,
-				ns: element_ns,
-				attrs,
-				children: [],
-				self_closing,
-				open_tag_trailing: trailing,
-				close_tag_leading: "",
-				close_tag_trailing: ""
-			};
-			push_to_parent(elem);
-			if (root === null) root = elem.id;
-			if (!self_closing) {
-				open_stack.push(elem);
-				ns_stack.push(new_ns_map);
-				default_ns_stack.push(new_default_ns);
-			}
-			i = end_index;
-			continue;
-		}
-		const next = src.indexOf("<", i);
-		const end = next === -1 ? n : next;
-		const value = decode_entities(src.slice(i, end));
-		push_to_parent({
-			kind: "text",
-			id: fresh_id(),
-			parent: null,
-			value
-		});
-		i = end;
-	}
-	if (open_stack.length > 0) throw new Error(`unclosed element <${open_stack[open_stack.length - 1].raw_tag}>`);
-	if (root === null) throw new Error("no root element");
-	return {
-		prolog,
-		root,
-		epilog,
-		nodes
-	};
-}
-function split_qname(qname) {
-	const idx = qname.indexOf(":");
-	if (idx === -1) return [null, qname];
-	return [qname.slice(0, idx), qname.slice(idx + 1)];
-}
-function parse_attrs(src, from) {
-	const attrs = [];
-	let i = from;
-	let pre = "";
-	const n = src.length;
-	while (i < n) {
-		const ws_start = i;
-		while (i < n && /\s/.test(src[i])) i++;
-		pre += src.slice(ws_start, i);
-		if (i >= n) throw new Error("unterminated start tag");
-		const c = src[i];
-		if (c === "/") {
-			if (src[i + 1] !== ">") throw new Error("expected '/>' at " + i);
-			pre + "";
-			return {
-				attrs,
-				end_index: i + 2,
-				self_closing: true,
-				trailing: pre
-			};
-		}
-		if (c === ">") return {
-			attrs,
-			end_index: i + 1,
-			self_closing: false,
-			trailing: pre
-		};
-		const name_start = i;
-		while (i < n && !/[\s=/>]/.test(src[i])) i++;
-		const raw_name = src.slice(name_start, i);
-		let eq_trivia = "";
-		while (i < n && /\s/.test(src[i])) {
-			eq_trivia += src[i];
-			i++;
-		}
-		if (src[i] !== "=") {
-			const [prefix, local] = split_qname(raw_name);
-			attrs.push({
-				raw_name,
-				prefix,
-				local,
-				ns: null,
-				value: "",
-				pre,
-				eq_trivia,
-				quote: "\""
-			});
-			pre = "";
-			continue;
-		}
-		i++;
-		while (i < n && /\s/.test(src[i])) i++;
-		const quote = src[i];
-		if (quote !== "\"" && quote !== "'") throw new Error("expected attribute quote at " + i);
-		i++;
-		const val_start = i;
-		while (i < n && src[i] !== quote) i++;
-		if (i >= n) throw new Error("unterminated attribute value");
-		const raw_value = src.slice(val_start, i);
-		i++;
-		const [prefix, local] = split_qname(raw_name);
-		attrs.push({
-			raw_name,
-			prefix,
-			local,
-			ns: null,
-			value: decode_entities(raw_value),
-			pre,
-			eq_trivia,
-			quote
-		});
-		pre = "";
-	}
-	throw new Error("unterminated start tag");
-}
-const NAMED_ENTITIES = {
-	amp: "&",
-	lt: "<",
-	gt: ">",
-	quot: "\"",
-	apos: "'"
-};
-function decode_entities(s) {
-	return s.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z][a-zA-Z0-9]*);/g, (_, ent) => {
-		if (ent.startsWith("#x") || ent.startsWith("#X")) return String.fromCodePoint(parseInt(ent.slice(2), 16));
-		if (ent.startsWith("#")) return String.fromCodePoint(parseInt(ent.slice(1), 10));
-		return NAMED_ENTITIES[ent] ?? `&${ent};`;
-	});
-}
-function encode_attr_value(value, quote) {
-	let out = value.replace(/&/g, "&amp;").replace(/</g, "&lt;");
-	out = quote === "\"" ? out.replace(/"/g, "&quot;") : out.replace(/'/g, "&apos;");
-	return out;
-}
-function encode_text(value) {
-	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;");
-}
 //#endregion
 //#region src/core/document.ts
+/**
+* Attribute names whose writes can shift a node's rendered bounds.
+* Membership drives `_geometry_version` bumps in `set_attr`. Only
+* non-namespaced attribute names — namespaced writes (xlink:href, etc.)
+* never bump because they're references, not geometry.
+*
+* Includes text-shaping attributes (font-*) because they re-shape glyph
+* runs and change `<text>` bbox.
+*/
+const GEOMETRY_ATTRS = new Set([
+	"x",
+	"y",
+	"x1",
+	"y1",
+	"x2",
+	"y2",
+	"cx",
+	"cy",
+	"width",
+	"height",
+	"r",
+	"rx",
+	"ry",
+	"points",
+	"d",
+	"transform",
+	"viewBox",
+	"font-size",
+	"font-family",
+	"font-weight",
+	"font-style",
+	"text-anchor",
+	"dx",
+	"dy",
+	"rotate",
+	"textLength",
+	"lengthAdjust",
+	"pathLength",
+	"marker-start",
+	"marker-mid",
+	"marker-end"
+]);
 var SvgDocument = class SvgDocument {
 	constructor(svg) {
 		this.listeners = /* @__PURE__ */ new Set();
 		this._structure_version = 0;
+		this._geometry_version = 0;
 		this.source = svg;
 		const parsed = parse_svg(svg);
 		this.original = parsed;
@@ -849,6 +816,7 @@ var SvgDocument = class SvgDocument {
 		this.epilog = parsed.epilog;
 		this.root = parsed.root;
 		this._structure_version++;
+		this._geometry_version++;
 		this.emit();
 	}
 	/** Replace document with new svg source (clears edits + history-owned state). */
@@ -861,6 +829,7 @@ var SvgDocument = class SvgDocument {
 		this.epilog = parsed.epilog;
 		this.root = parsed.root;
 		this._structure_version++;
+		this._geometry_version++;
 		this.emit();
 	}
 	on_change(fn) {
@@ -871,6 +840,10 @@ var SvgDocument = class SvgDocument {
 	get structure_version() {
 		return this._structure_version;
 	}
+	/** See `_geometry_version` for what this counter signals. */
+	get geometry_version() {
+		return this._geometry_version;
+	}
 	emit() {
 		for (const fn of this.listeners) fn();
 	}
@@ -923,6 +896,48 @@ var SvgDocument = class SvgDocument {
 		}
 		return false;
 	}
+	/**
+	* Filter a selection down to its **subtree roots** — drop any id whose
+	* ancestor is also in the input set.
+	*
+	* Mirrors `pruneNestedNodes` in the main canvas editor's query module
+	* ([editor/grida-canvas/query/index.ts:138](../../../../editor/grida-canvas/query/index.ts)) and shares its UX motivation:
+	* when a parent and a descendant are both selected, only the parent
+	* should drive multi-node mutations — otherwise the descendant
+	* accumulates the transform twice (once via the parent's `transform`,
+	* once via its own attribute write). Required for `commands.remove`
+	* (avoids re-attaching detached descendants on undo) and any multi-
+	* member translate path (avoids 2× drift for the Bar-chart marquee
+	* case).
+	*
+	* Order: preserves the input order for retained ids. Duplicates in
+	* the input are not deduplicated — callers are responsible (the
+	* editor's `commands.select` already dedupes).
+	*
+	* Performance: `O(n × depth)`. Builds a `Set` over the input once,
+	* then walks each id's ancestor chain at most once. The main editor's
+	* version is `O(n² × depth)` (per-pair `isAncestor`) — fine at typical
+	* selection sizes (a few dozen), worth winning here for free since
+	* `parent_of` is `O(1)` on our parent-map.
+	*/
+	prune_nested_nodes(ids) {
+		if (ids.length <= 1) return [...ids];
+		const set = new Set(ids);
+		const out = [];
+		for (const id of ids) {
+			let nested = false;
+			let cur = this.parent_of(id);
+			while (cur !== null) {
+				if (set.has(cur)) {
+					nested = true;
+					break;
+				}
+				cur = this.parent_of(cur);
+			}
+			if (!nested) out.push(id);
+		}
+		return out;
+	}
 	all_nodes() {
 		const out = [];
 		const walk = (id) => {
@@ -960,18 +975,20 @@ var SvgDocument = class SvgDocument {
 		const n = this.nodes.get(id);
 		if (!n || n.kind !== "element") return;
 		const structural = name === "id";
+		const geometry = ns === null && GEOMETRY_ATTRS.has(name);
 		for (let i = 0; i < n.attrs.length; i++) {
 			const a = n.attrs[i];
 			if (a.local === name && (ns === null || a.ns === ns)) {
 				if (value === null) n.attrs.splice(i, 1);
 				else a.value = value;
 				if (structural) this._structure_version++;
+				if (geometry) this._geometry_version++;
 				this.emit();
 				return;
 			}
 		}
 		if (value !== null) {
-			const prefix = ns === "http://www.w3.org/1999/xlink" ? "xlink" : null;
+			const prefix = ns === XLINK_NS ? "xlink" : null;
 			n.attrs.push({
 				raw_name: prefix ? `${prefix}:${name}` : name,
 				prefix,
@@ -983,6 +1000,7 @@ var SvgDocument = class SvgDocument {
 				quote: "\""
 			});
 			if (structural) this._structure_version++;
+			if (geometry) this._geometry_version++;
 			this.emit();
 		}
 	}
@@ -1021,6 +1039,25 @@ var SvgDocument = class SvgDocument {
 		if (!style) return [];
 		return parse_inline_style(style);
 	}
+	/**
+	* Whether `id` can be opened in the flat-string text editor.
+	*
+	* v1 contract: the editor only operates on a *single flat text run*. That
+	* means the target must be a `<text>` or `<tspan>` whose direct children
+	* are all text nodes (or it has no children). A `<text>` containing a
+	* `<tspan>` is *not* honestly editable — `text_of` would drop the tspan
+	* content from the editor's view, and a flat-text write would leave the
+	* tspan dangling. Tspan-as-target is fine and well-defined when it's a
+	* leaf; only the host decides whether to route double-click to a tspan
+	* or its parent text.
+	*/
+	is_text_edit_target(id) {
+		const n = this.nodes.get(id);
+		if (!n || n.kind !== "element") return false;
+		if (n.local !== "text" && n.local !== "tspan") return false;
+		for (const c of n.children) if (this.nodes.get(c)?.kind !== "text") return false;
+		return true;
+	}
 	text_of(id) {
 		const n = this.nodes.get(id);
 		if (!n || n.kind !== "element") return "";
@@ -1048,6 +1085,7 @@ var SvgDocument = class SvgDocument {
 			n.children.push(text_id);
 		}
 		this._structure_version++;
+		this._geometry_version++;
 		this.emit();
 	}
 	insert(id, parent, before) {
@@ -1066,6 +1104,7 @@ var SvgDocument = class SvgDocument {
 		else parent_node.children.splice(ix, 0, id);
 		node.parent = parent;
 		this._structure_version++;
+		this._geometry_version++;
 		this.emit();
 	}
 	remove(id) {
@@ -1077,6 +1116,7 @@ var SvgDocument = class SvgDocument {
 		if (i >= 0) parent.children.splice(i, 1);
 		n.parent = null;
 		this._structure_version++;
+		this._geometry_version++;
 		this.emit();
 	}
 	/** Create a new element node and register it (not yet inserted). */
@@ -1157,6 +1197,56 @@ function parse_inline_style(s) {
 	return out;
 }
 //#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
 /** SVG properties that inherit per SVG 2 §6 (subset; the common ones). */
 const INHERITED = new Set([
@@ -1300,17 +1390,6 @@ function choose_write_carrier(doc, id, property) {
 	return "presentation_attribute";
 }
 //#endregion
-//#region src/types.ts
-const DEFAULT_STYLE = {
-	chrome_color: "#2563eb",
-	handle_size: 8,
-	handle_fill: "#ffffff",
-	handle_stroke: "#2563eb",
-	endpoint_dot_radius: 5,
-	selection_outline_width: 2,
-	measurement_color: "#ff3a30"
-};
-//#endregion
 //#region src/core/editor.ts
 const PROVIDER_ID = "svg-editor";
 /** Max characters in a synthesized display label before truncation. */
@@ -1322,29 +1401,46 @@ function createSvgEditor(opts) {
 	let selection = [];
 	let scope = null;
 	let mode = "select";
+	let tool = TOOL_CURSOR;
 	let version = 0;
 	/** Document-edit counter — only bumps on actual mutations, not selection. */
 	let doc_version = 0;
 	/** doc_version at the last load()/serialize(); compared to derive `dirty`. */
 	let baseline_doc_version = 0;
+	/**
+	* 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 ?? {}
+		...opts.style
 	};
 	const providers = opts.providers ?? {};
 	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_version !== baseline_doc_version,
 			can_undo: history.stack.canUndo,
 			can_redo: history.stack.canRedo,
 			version,
-			structure_version: doc.structure_version
+			structure_version: doc.structure_version,
+			geometry_version: doc.geometry_version,
+			load_version
 		});
 	}
 	function emit() {
@@ -1355,8 +1451,18 @@ function createSvgEditor(opts) {
 	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();
+	};
 	doc.on_change(() => {
 		doc_version++;
+		if (doc.geometry_version !== last_emitted_geometry_version) {
+			last_emitted_geometry_version = doc.geometry_version;
+			for (const cb of geometry_listeners) cb();
+		}
 	});
 	function subscribe(fn) {
 		listeners.add(fn);
@@ -1376,16 +1482,29 @@ function createSvgEditor(opts) {
 		});
 	}
 	function set_selection(next) {
+		if (next.length === selection.length) {
+			let same = true;
+			for (let i = 0; i < next.length; i++) if (next[i] !== selection[i]) {
+				same = false;
+				break;
+			}
+			if (same) return;
+		}
 		selection = Object.freeze([...next]);
 		emit();
 	}
 	function select(target, opts) {
 		const ids = typeof target === "string" ? [target] : [...target];
-		if (opts?.additive) {
-			const merged = new Set(selection);
-			for (const id of ids) merged.add(id);
-			set_selection([...merged]);
-		} else set_selection(ids);
+		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([]);
@@ -1405,18 +1524,121 @@ function createSvgEditor(opts) {
 		mode = next;
 		emit();
 	}
+	function tools_equal(a, b) {
+		if (a.type !== b.type) return false;
+		if (a.type === "cursor") 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.doc_version === doc_version) return cached.value;
+		const next = read_property(doc, id, name);
+		if (cached && property_value_equals(cached.value, next)) {
+			cached.doc_version = doc_version;
+			return cached.value;
+		}
+		property_cache.set(key, {
+			doc_version,
+			value: next
+		});
+		return next;
+	}
 	function node_properties(id, names) {
-		const out = {};
-		for (const name of names) out[name] = read_property(doc, id, name);
-		return out;
+		const key = `${id}${names.join("
")}`;
+		const cached = properties_cache.get(key);
+		if (cached && cached.doc_version === doc_version) 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.doc_version = doc_version;
+			return cached.value;
+		}
+		const frozen = Object.freeze(next);
+		properties_cache.set(key, {
+			doc_version,
+			value: frozen
+		});
+		return frozen;
 	}
 	function node_paint(id, channel) {
+		const key = `${id}${channel}`;
+		const cached = paint_cache.get(key);
+		if (cached && cached.doc_version === doc_version) return cached.value;
 		const { declared, provenance } = resolve_declared(doc, id, channel);
-		return {
+		const next = {
 			declared,
 			computed: parse_paint(declared),
 			provenance
 		};
+		if (cached && paint_value_equals(cached.value, next)) {
+			cached.doc_version = doc_version;
+			return cached.value;
+		}
+		paint_cache.set(key, {
+			doc_version,
+			value: next
+		});
+		return next;
 	}
 	function write_property(id, name, value) {
 		if (choose_write_carrier(doc, id, name) === "inline_style") doc.set_style(id, name, value);
@@ -1502,29 +1724,427 @@ function createSvgEditor(opts) {
 		});
 		return { gradient_id };
 	}
+	/** 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 } = prepare_translate_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
+		});
+		apply();
+		history.atomic(label, (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		return true;
+	}
 	function translate(delta) {
-		if (selection.length === 0) return;
-		if (delta.dx === 0 && delta.dy === 0) return;
-		const baselines = selection.map((id) => ({
-			id,
-			baseline: capture_translate_baseline(doc, id)
-		}));
+		if (do_translate_oneshot(delta, void 0, "translate")) notify_translate_commit();
+	}
+	function nudge(delta) {
+		if (do_translate_oneshot(delta, STAGES_NUDGE, "nudge")) notify_translate_commit();
+	}
+	/**
+	* 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.
+	*
+	* 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 whose
+	* tag is not resizable are silently filtered.
+	*
+	* 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 ids = opts?.ids ?? selection;
+		if (ids.length === 0) return false;
+		if (!geometry_provider) return false;
+		const members = [];
+		for (const id of ids) {
+			if (!is_resizable(doc.tag_of(id))) continue;
+			const bbox = geometry_provider.bounds_of(id);
+			if (!bbox) continue;
+			members.push({
+				id,
+				rz: capture_resize_baseline(doc, id, bbox),
+				tx_pre: capture_translate_baseline(doc, id),
+				transform_pre: doc.get_attr(id, "transform"),
+				bbox
+			});
+		}
+		if (members.length === 0) 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
+		};
+		const dx = target.x - union.x;
+		const dy = target.y - union.y;
 		const apply = () => {
-			for (const { id, baseline } of baselines) apply_translate(doc, id, baseline, delta.dx, delta.dy);
+			for (const m of members) apply_resize(doc, m.id, m.rz, sx, sy, origin);
+			if (dx !== 0 || dy !== 0) for (const m of members) {
+				const tx_after = capture_translate_baseline(doc, m.id);
+				apply_translate(doc, m.id, tx_after, dx, dy);
+			}
 			emit();
 		};
 		const revert = () => {
-			for (const { id, baseline } of baselines) apply_translate(doc, id, baseline, 0, 0);
+			for (const m of members) {
+				apply_resize(doc, m.id, m.rz, 1, 1, origin);
+				doc.set_attr(m.id, "transform", m.transform_pre);
+			}
 			emit();
 		};
 		apply();
-		history.atomic("translate", (tx) => {
+		history.atomic("resize-to", (tx) => {
 			tx.push({
 				providerId: PROVIDER_ID,
 				apply,
 				revert
 			});
 		});
+		return true;
+	}
+	/** 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 prepared = prepare_rotate_rpc({
+			doc,
+			ids,
+			pivot: opts?.pivot ?? default_rotate_pivot(ids),
+			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 probe = prepare_rotate_rpc({
+			doc,
+			ids,
+			pivot: opts?.pivot ?? default_rotate_pivot(ids),
+			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;
+				apply_rotate(doc, m.id, m.baseline, delta);
+			}
+			emit();
+		};
+		const revert = () => {
+			for (const m of probe.plan.members) apply_rotate(doc, m.id, m.baseline, 0);
+			emit();
+		};
+		apply();
+		history.atomic("rotate-to", (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 = parse_transform_list(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 IDENT = [
+			1,
+			0,
+			0,
+			1,
+			0,
+			0
+		];
+		function 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 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
+					];
+				}
+			}
+		}
+		const apply = () => {
+			for (const m of members) {
+				let mat = IDENT;
+				for (const op of m.ops) mat = mul(mat, op_to_mat(op));
+				doc.set_attr(m.id, "transform", emit_transform_list([{
+					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.
+	*
+	* 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 = capture_translate_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 deltas = compute_align_deltas(members, target, direction);
+		if (deltas.size === 0) return false;
+		const apply = () => {
+			for (const m of members) {
+				const d = deltas.get(m.id);
+				if (d) apply_translate(doc, m.id, m.baseline, d.x, d.y);
+			}
+			emit();
+		};
+		const revert = () => {
+			for (const m of members) if (deltas.has(m.id)) apply_translate(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;
@@ -1572,33 +2192,179 @@ function createSvgEditor(opts) {
 		});
 	}
 	function remove() {
-		if (selection.length !== 1) return;
-		const target = selection[0];
-		const parent = doc.parent_of(target);
-		if (parent === null) return;
-		const next_sibling = doc.next_element_sibling_of(target);
+		if (selection.length === 0) return;
+		const filtered = doc.prune_nested_nodes(selection).filter((id) => doc.parent_of(id) !== null);
+		if (filtered.length === 0) return;
+		const doc_order = doc.all_elements();
+		const index_of = /* @__PURE__ */ new Map();
+		for (let i = 0; i < doc_order.length; i++) index_of.set(doc_order[i], i);
+		const captures = [...filtered].sort((a, b) => (index_of.get(a) ?? 0) - (index_of.get(b) ?? 0)).map((id) => ({
+			id,
+			parent: doc.parent_of(id),
+			next_sibling: doc.next_element_sibling_of(id)
+		}));
 		const old_selection = selection;
 		const apply = () => {
-			doc.remove(target);
+			for (const c of captures) doc.remove(c.id);
 			set_selection([]);
 		};
 		const revert = () => {
-			doc.insert(target, parent, next_sibling);
+			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("remove", (tx) => {
+		history.atomic(captures.length === 1 ? "remove" : `remove ${captures.length}`, (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+	}
+	function group() {
+		const plan = plan_group(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;
+	}
+	/**
+	* 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`.
+	*/
+	function insert(tag, attrs, opts) {
+		const parent = opts?.parent ?? doc.root;
+		const select_after = opts?.select !== false;
+		let insert_before = null;
+		if (opts?.index !== void 0) insert_before = doc.element_children_of(parent)[opts.index] ?? null;
+		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;
+	}
+	/**
+	* 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;
+		let insert_before = null;
+		if (opts?.index !== void 0) insert_before = doc.element_children_of(parent)[opts.index] ?? null;
+		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}`);
+		let active = true;
+		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 (!active) return;
+				for (const name in attrs) {
+					live_attrs[name] = attrs[name];
+					doc.set_attr(id, name, attrs[name]);
+				}
+				preview.set(entry);
+			},
+			commit() {
+				if (!active) return;
+				active = false;
+				preview.commit();
+			},
+			discard() {
+				if (!active) return;
+				active = false;
+				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 default_paint_attrs(tag);
+		return {};
 	}
 	function set_text(value) {
 		if (selection.length !== 1) return;
 		const target = selection[0];
-		if (doc.tag_of(target) !== "text") return;
+		if (!doc.is_text_edit_target(target)) return;
 		const original = doc.text_of(target);
 		if (original === value) return;
 		const apply = () => {
@@ -1641,7 +2407,7 @@ function createSvgEditor(opts) {
 	function enter_content_edit(target) {
 		const id = target ?? (selection.length === 1 ? selection[0] : null);
 		if (!id) return false;
-		if (doc.tag_of(id) !== "text") return false;
+		if (!doc.is_text_edit_target(id)) return false;
 		if (!content_edit_driver) return false;
 		return content_edit_driver(id);
 	}
@@ -1650,8 +2416,10 @@ function createSvgEditor(opts) {
 		selection = [];
 		scope = null;
 		mode = "select";
+		tool = TOOL_CURSOR;
 		history.clear();
 		baseline_doc_version = doc_version;
+		load_version++;
 		emit();
 	}
 	function serialize_svg() {
@@ -1668,6 +2436,8 @@ function createSvgEditor(opts) {
 	const commands = {
 		select,
 		deselect,
+		select_all,
+		select_sibling,
 		enter_scope,
 		exit_scope,
 		set_mode,
@@ -1677,8 +2447,17 @@ function createSvgEditor(opts) {
 		preview_paint,
 		set_paint_from_gradient,
 		translate,
+		nudge,
+		resize_to,
+		rotate,
+		rotate_to,
+		flatten_transform,
+		align,
 		reorder,
 		remove,
+		group,
+		insert,
+		insert_preview,
 		set_text,
 		load_svg,
 		serialize_svg,
@@ -1700,6 +2479,7 @@ function createSvgEditor(opts) {
 		selection = [];
 		scope = null;
 		mode = "select";
+		tool = TOOL_CURSOR;
 		baseline_doc_version = doc_version;
 		emit();
 	}
@@ -1756,18 +2536,7 @@ function createSvgEditor(opts) {
 			return elem_id && elem_id.length > 0 ? `${head} #${elem_id}` : head;
 		},
 		tree() {
-			const map = /* @__PURE__ */ new Map();
-			for (const id of doc.all_elements()) map.set(id, {
-				id,
-				tag: doc.tag_of(id),
-				name: doc.get_attr(id, "id") ?? void 0,
-				parent: doc.parent_of(id),
-				children: doc.element_children_of(id)
-			});
-			return {
-				root: doc.root,
-				nodes: map
-			};
+			return tree_snapshot();
 		},
 		surface_hover() {
 			return current_surface_hover;
@@ -1783,7 +2552,17 @@ function createSvgEditor(opts) {
 				surface_hover_listeners.delete(cb);
 			};
 		},
+		subscribe_geometry(cb) {
+			geometry_listeners.add(cb);
+			return () => {
+				geometry_listeners.delete(cb);
+			};
+		},
+		get geometry() {
+			return geometry_provider;
+		},
 		modes,
+		set_tool,
 		get style() {
 			return style;
 		},
@@ -1797,6 +2576,15 @@ function createSvgEditor(opts) {
 		providers,
 		_internal: {
 			doc,
+			history: { preview: (label) => history.preview(label) },
+			emit,
+			subscribe_translate_commit(cb) {
+				translate_commit_listeners.add(cb);
+				return () => {
+					translate_commit_listeners.delete(cb);
+				};
+			},
+			notify_translate_commit,
 			set_content_edit_driver(fn) {
 				content_edit_driver = fn;
 			},
@@ -1809,6 +2597,9 @@ function createSvgEditor(opts) {
 			},
 			set_computed_resolver(fn) {
 				computed_resolver = fn;
+			},
+			set_geometry(p) {
+				geometry_provider = p;
 			}
 		},
 		keymap
@@ -1817,5 +2608,37 @@ function createSvgEditor(opts) {
 	applyDefaultBindings(keymap);
 	return public_editor;
 }
+function paint_value_equals(a, b) {
+	if (a === b) return true;
+	if (a.declared !== b.declared) return false;
+	if (a.provenance.carrier !== b.provenance.carrier) return false;
+	if (a.provenance.origin !== b.provenance.origin) return false;
+	return paint_equals(a.computed, b.computed);
+}
+function paint_equals(a, b) {
+	if (a === b) return true;
+	if (a == null || b == null) return false;
+	if ("error" in a || "error" in b) return "error" in a && "error" in b && a.error === b.error && a.reason === b.reason;
+	if (a.kind !== b.kind) return false;
+	if (a.kind === "color" && b.kind === "color") {
+		if (a.value.kind !== b.value.kind) return false;
+		if (a.value.kind === "rgb" && b.value.kind === "rgb") return a.value.value === b.value.value;
+		return true;
+	}
+	if (a.kind === "ref" && b.kind === "ref") return a.id === b.id;
+	if (a.kind === "none" && b.kind === "none") return true;
+	if (a.kind === "context_fill" && b.kind === "context_fill") return true;
+	if (a.kind === "context_stroke" && b.kind === "context_stroke") return true;
+	return false;
+}
+function property_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;
+}
 //#endregion
-export { DEFAULT_STYLE as n, createSvgEditor as t };
+export { createSvgEditor as t };