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

package/dist/{model-B2UWgViT.mjs → model-DMaN5GnH.mjs}

@@ -1,4 +1,5 @@
 import cmath from "@grida/cmath";
+import { SVG_NS, XLINK_NS as XLINK_NS$1, XMLNS_NS, encode_attr_value, encode_text, parse_svg } from "@grida/svg/parser";
 import { svg_parse } from "@grida/svg/parse";
 import { SVGPathData, SVGPathDataTransformer, encodeSVGPath } from "@grida/svg/pathdata";
 import vn from "@grida/vn";
@@ -26,75 +27,1126 @@ function array_shallow_equal(a, b) {
 	return true;
 }
 //#endregion
-//#region src/core/group.ts
-let group;
-(function(_group) {
-	const STRUCTURAL_GRAPHICS = _group.STRUCTURAL_GRAPHICS = new Set([
-		"g",
-		"defs",
-		"svg",
-		"use",
-		"image",
-		"switch",
-		"foreignObject",
-		"path",
-		"rect",
-		"circle",
-		"ellipse",
-		"line",
-		"polyline",
-		"polygon",
-		"text",
-		"a"
-	]);
-	const CONSTRAINED_PARENT = _group.CONSTRAINED_PARENT = new Set([
-		"text",
-		"tspan",
-		"defs",
-		"clipPath",
-		"mask",
-		"pattern",
-		"marker",
-		"symbol",
-		"filter",
-		"linearGradient",
-		"radialGradient",
-		"animateMotion",
-		"switch"
-	]);
-	function plan(doc, ids) {
-		if (ids.length === 0) return null;
-		const parent = doc.parent_of(ids[0]);
+//#region src/core/document.ts
+/** The native vector tags `retype_to_path` can re-type, keyed by tag → the
+*  native geometry attributes it consumes (so no orphaned geometry attr
+*  survives on the resulting `<path>`). Covers the geometry primitives
+*  (rect / circle / ellipse — always re-typed) and the vertex tags (line /
+*  polyline / polygon — re-typed only when an edit escapes their native
+*  form). */
+const RETYPABLE_GEOMETRY_ATTRS = {
+	line: new Set([
+		"x1",
+		"y1",
+		"x2",
+		"y2"
+	]),
+	polyline: new Set(["points"]),
+	polygon: new Set(["points"]),
+	rect: new Set([
+		"x",
+		"y",
+		"width",
+		"height",
+		"rx",
+		"ry"
+	]),
+	circle: new Set([
+		"cx",
+		"cy",
+		"r"
+	]),
+	ellipse: new Set([
+		"cx",
+		"cy",
+		"rx",
+		"ry"
+	])
+};
+/**
+* Parse a single SVG length attribute as a plain user-unit number. Returns
+* `null` for absent, non-finite, or unit/percentage values (`50%`, `5px`,
+* `5em`) — those are an out-of-scope geometry gap, and refusing them here
+* means the editor never offers a promotion it cannot perform faithfully.
+*/
+function parse_user_unit(raw) {
+	if (raw === null) return null;
+	const s = raw.trim();
+	if (s === "") return null;
+	if (!/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(s)) return null;
+	const n = Number(s);
+	return Number.isFinite(n) ? n : null;
+}
+/**
+* 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"
+]);
+/** `transform:` CSS property at the start of a declaration list or after `;`. */
+const CSS_TRANSFORM_PROPERTY = /(?:^|;)\s*transform\s*:/i;
+/** Trivia shape for editor-synthesized attribute tokens — parser-authored
+*  tokens carry their source trivia verbatim; tokens the editor appends get
+*  this one canonical shape (` name="value"`). */
+const SYNTH_ATTR_TRIVIA = {
+	pre: " ",
+	eq_trivia: "",
+	eq_trailing: "",
+	quote: "\""
+};
+var SvgDocument = class SvgDocument {
+	constructor(svg) {
+		this.listeners = /* @__PURE__ */ new Set();
+		this._structure_version = 0;
+		this._revision = 0;
+		this._geometry_version = 0;
+		if (typeof svg !== "string") throw new TypeError(`new SvgDocument(svg) requires a string source, got ${svg === null ? "null" : typeof svg}`);
+		this.source = svg;
+		const parsed = parse_svg(svg);
+		this.original = parsed;
+		this.nodes = parsed.nodes;
+		this.prolog = parsed.prolog;
+		this.epilog = parsed.epilog;
+		this.root = parsed.root;
+	}
+	static parse(svg) {
+		return new SvgDocument(svg);
+	}
+	/** Reload from the original parse, discarding all edits. */
+	reset_to_original() {
+		const parsed = parse_svg(this.source);
+		this.original = parsed;
+		this.nodes = parsed.nodes;
+		this.prolog = parsed.prolog;
+		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). */
+	load(svg) {
+		if (typeof svg !== "string") throw new TypeError(`SvgDocument.load(svg) requires a string source, got ${svg === null ? "null" : typeof svg}`);
+		this.source = svg;
+		const parsed = parse_svg(svg);
+		this.original = parsed;
+		this.nodes = parsed.nodes;
+		this.prolog = parsed.prolog;
+		this.epilog = parsed.epilog;
+		this.root = parsed.root;
+		this._structure_version++;
+		this._geometry_version++;
+		this.emit();
+	}
+	on_change(fn) {
+		this.listeners.add(fn);
+		return () => this.listeners.delete(fn);
+	}
+	/** See `_structure_version` for what this counter signals. */
+	get structure_version() {
+		return this._structure_version;
+	}
+	/**
+	* Total mutation counter — advances on EVERY listener-visible mutation
+	* (attribute, style, text, topology, load/reset), unlike the selective
+	* `structure_version` / `geometry_version` channels. The single
+	* edit-version source: anything derived from this document — the
+	* editor's `content_version` / `dirty`, memoized reads, a rendered
+	* projection — answers "am I current?" by comparing values, with no
+	* event-ordering dependence. Advances BEFORE listeners fire, so a
+	* read issued from inside a change listener already sees the new
+	* value.
+	*/
+	get revision() {
+		return this._revision;
+	}
+	/** See `_geometry_version` for what this counter signals. */
+	get geometry_version() {
+		return this._geometry_version;
+	}
+	/**
+	* Advance `_geometry_version` by exactly 1 WITHOUT touching the tree,
+	* any attribute, `structure_version`, or the `on_change` listeners.
+	*
+	* The one geometry mutation with no attribute write: a `<text>` /
+	* `<tspan>` reflow the IR cannot see — a web font finishing load AFTER
+	* the `font-family` / `font-size` write was already serialized. The DOM
+	* surface observes the reflow (`document.fonts` `loadingdone`) and asks
+	* the geometry channel to advance so the bounds cache re-reads the
+	* settled glyph metrics. See ../../docs/geometry.md §Limitations.
+	*
+	* Deliberately does NOT call `emit()`: this is not a document edit, so
+	* `revision` must not advance — no dirty flag, no undo, no render
+	* flush. The editor's `_internal.bump_geometry` advances
+	* `geometry_version` here and fans out the geometry listeners itself.
+	*/
+	bump_geometry() {
+		this._geometry_version++;
+	}
+	emit() {
+		this._revision++;
+		for (const fn of this.listeners) fn();
+	}
+	/** Notify subscribers — for callers that mutate directly via setAttr/etc. */
+	notify() {
+		this.emit();
+	}
+	get(id) {
+		return this.nodes.get(id) ?? null;
+	}
+	is_element(id) {
+		return this.nodes.get(id)?.kind === "element";
+	}
+	parent_of(id) {
+		return this.nodes.get(id)?.parent ?? null;
+	}
+	children_of(id) {
+		const n = this.nodes.get(id);
+		if (!n || n.kind !== "element") return [];
+		return n.children;
+	}
+	/** Element children only — text/comment/cdata filtered out. */
+	element_children_of(id) {
+		return this.children_of(id).filter((c) => this.is_element(c));
+	}
+	next_sibling_of(id) {
+		const parent = this.parent_of(id);
 		if (parent === null) return null;
-		for (const id of ids) {
-			if (doc.parent_of(id) !== parent) return null;
-			if (!STRUCTURAL_GRAPHICS.has(doc.tag_of(id))) return null;
+		const siblings = this.children_of(parent);
+		const i = siblings.indexOf(id);
+		return i >= 0 && i + 1 < siblings.length ? siblings[i + 1] : null;
+	}
+	next_element_sibling_of(id) {
+		const parent = this.parent_of(id);
+		if (parent === null) return null;
+		const siblings = this.element_children_of(parent);
+		const i = siblings.indexOf(id);
+		return i >= 0 && i + 1 < siblings.length ? siblings[i + 1] : null;
+	}
+	tag_of(id) {
+		const n = this.nodes.get(id);
+		return n && n.kind === "element" ? n.local : "";
+	}
+	contains(ancestor, descendant) {
+		if (ancestor === descendant) return true;
+		let cur = this.parent_of(descendant);
+		while (cur !== null) {
+			if (cur === ancestor) return true;
+			cur = this.parent_of(cur);
 		}
-		if (CONSTRAINED_PARENT.has(doc.tag_of(parent))) return null;
-		const siblings = doc.element_children_of(parent);
-		const sibling_index = /* @__PURE__ */ new Map();
-		for (let i = 0; i < siblings.length; i++) sibling_index.set(siblings[i], i);
-		const indices = [];
+		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) {
-			const i = sibling_index.get(id);
-			if (i === void 0) return null;
-			indices.push(i);
+			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);
 		}
-		const sorted = Array.from(new Set(indices)).sort((a, b) => a - b);
-		for (let i = 1; i < sorted.length; i++) if (sorted[i] !== sorted[i - 1] + 1) return null;
-		const children = sorted.map((i) => siblings[i]);
-		const last_index = sorted[sorted.length - 1];
-		const original_positions = /* @__PURE__ */ new Map();
-		for (const i of sorted) original_positions.set(siblings[i], siblings[i + 1] ?? null);
+		return out;
+	}
+	all_nodes() {
+		const out = [];
+		const walk = (id) => {
+			out.push(id);
+			const c = this.children_of(id);
+			for (const ch of c) walk(ch);
+		};
+		walk(this.root);
+		return out;
+	}
+	all_elements() {
+		return this.all_nodes().filter((id) => this.is_element(id));
+	}
+	find_by_tag(ancestor, tag) {
+		const out = [];
+		const walk = (id) => {
+			if (id !== ancestor && this.is_element(id) && this.tag_of(id) === tag) out.push(id);
+			for (const c of this.children_of(id)) walk(c);
+		};
+		walk(ancestor);
+		return out;
+	}
+	/** Read attribute by local name, optionally namespace-filtered. */
+	get_attr(id, name, ns = null) {
+		const n = this.nodes.get(id);
+		if (!n || n.kind !== "element") return null;
+		for (const a of n.attrs) if (a.local === name && (ns === null || a.ns === ns)) return a.value;
+		return null;
+	}
+	/**
+	* Set / remove an attribute. If the attribute exists, it is mutated in place
+	* (preserving source position). If it doesn't, it's appended.
+	*/
+	set_attr(id, name, value, ns = null) {
+		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 === XLINK_NS$1 ? "xlink" : ns === XMLNS_NS ? "xmlns" : null;
+			n.attrs.push({
+				raw_name: prefix ? `${prefix}:${name}` : name,
+				prefix,
+				local: name,
+				ns,
+				value,
+				...SYNTH_ATTR_TRIVIA
+			});
+			if (structural) this._structure_version++;
+			if (geometry) this._geometry_version++;
+			this.emit();
+		}
+	}
+	attributes_of(id) {
+		const n = this.nodes.get(id);
+		if (!n || n.kind !== "element") return [];
+		return n.attrs.map((a) => ({
+			name: a.local,
+			ns: a.ns,
+			value: a.value
+		}));
+	}
+	get_style(id, property) {
+		const style = this.get_attr(id, "style");
+		if (!style) return null;
+		const decls = parse_inline_style(style);
+		for (const d of decls) if (d.property === property) return d.value;
+		return null;
+	}
+	set_style(id, property, value) {
+		const decls = parse_inline_style(this.get_attr(id, "style") ?? "");
+		const idx = decls.findIndex((d) => d.property === property);
+		if (value === null) {
+			if (idx === -1) return;
+			decls.splice(idx, 1);
+		} else if (idx === -1) decls.push({
+			property,
+			value
+		});
+		else decls[idx].value = value;
+		const next = decls.map((d) => `${d.property}: ${d.value}`).join("; ");
+		this.set_attr(id, "style", next === "" ? null : next);
+	}
+	get_all_styles(id) {
+		const style = this.get_attr(id, "style");
+		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;
+	}
+	/**
+	* Returns a tag-discriminated snapshot of the authored geometry attrs
+	* if this node is eligible for vector (vertex) editing — else `null`.
+	*
+	* Eligibility:
+	*   - `<path>`     — requires non-empty `d`.
+	*   - `<line>`     — requires two distinct finite user-unit endpoints.
+	*   - `<polyline>` — requires `points` parseable to ≥ 2 vertices.
+	*   - `<polygon>`  — same as polyline.
+	*   - `<rect>`     — requires finite user-unit `width`/`height` > 0.
+	*   - `<circle>`   — requires finite user-unit `r` > 0.
+	*   - `<ellipse>`  — requires finite user-unit `rx`/`ry` > 0.
+	*
+	* The vertex tags (`line` / `polyline` / `polygon`) write edits back to
+	* their native attributes while the geometry stays expressible there; an
+	* edit that escapes the native form (a curve, or a topology change that
+	* leaves the canonical chain) re-types the element to `<path>`. The
+	* geometry primitives (`rect` / `circle` / `ellipse`) have no native
+	* vector form, so any vector edit re-types them. In all cases the native
+	* tag is preserved byte-for-byte until the first re-typing edit commits
+	* (see `retype_to_path`). Design:
+	* `docs/wg/feat-svg-editor/promote-to-path.md`.
+	*
+	* Geometry that is not a plain user-unit number (`%`, `px`, `em`, …) is
+	* an out-of-scope gap, so such an element returns `null` rather than
+	* advertising an edit the editor cannot perform faithfully.
+	*
+	* Rejects `<image>` / `<use>` (raster / reference bounding boxes, no
+	* editable outline).
+	*/
+	/**
+	* Parse an optional SVG geometry coordinate (`x`/`y`, `cx`/`cy`, the line
+	* endpoints). An **absent** attribute takes the SVG default (`0`); a
+	* **present** attribute that is not a plain user-unit number (`%`, `px`,
+	* `em`, …) is out of scope and yields `null` so the caller refuses the
+	* element — the same gate required attrs (width / radius) already apply.
+	*
+	* The absent-vs-present distinction is the point: a bare `?? 0` would
+	* silently coerce an authored `x1="5px"` to `0`, then the first native
+	* writeback would overwrite that authored value. Refusing keeps the
+	* editor from misrepresenting geometry it cannot read faithfully.
+	*/
+	optional_user_unit_coord(id, name) {
+		const raw = this.get_attr(id, name);
+		if (raw === null) return 0;
+		return parse_user_unit(raw);
+	}
+	is_vector_edit_target(id) {
+		const n = this.nodes.get(id);
+		if (!n || n.kind !== "element") return null;
+		if (RETYPABLE_GEOMETRY_ATTRS[n.local] && n.attrs.some((a) => a.prefix === null && a.ns === null && a.local === "d")) return null;
+		switch (n.local) {
+			case "path": {
+				const d = this.get_attr(id, "d");
+				if (d === null || d.trim().length === 0) return null;
+				return {
+					kind: "path",
+					d
+				};
+			}
+			case "line": {
+				const x1 = this.optional_user_unit_coord(id, "x1");
+				const y1 = this.optional_user_unit_coord(id, "y1");
+				const x2 = this.optional_user_unit_coord(id, "x2");
+				const y2 = this.optional_user_unit_coord(id, "y2");
+				if (x1 === null || y1 === null || x2 === null || y2 === null) return null;
+				if (x1 === x2 && y1 === y2) return null;
+				return {
+					kind: "line",
+					x1,
+					y1,
+					x2,
+					y2
+				};
+			}
+			case "polyline":
+			case "polygon": {
+				const raw = this.get_attr(id, "points") ?? "";
+				const parsed = svg_parse.parse_points(raw);
+				if (parsed.length < 2) return null;
+				const points = parsed.map((p) => [p.x, p.y]);
+				return n.local === "polyline" ? {
+					kind: "polyline",
+					points
+				} : {
+					kind: "polygon",
+					points
+				};
+			}
+			case "rect": {
+				const x = this.optional_user_unit_coord(id, "x");
+				const y = this.optional_user_unit_coord(id, "y");
+				if (x === null || y === null) return null;
+				const width = parse_user_unit(this.get_attr(id, "width"));
+				const height = parse_user_unit(this.get_attr(id, "height"));
+				if (width === null || height === null) return null;
+				if (width <= 0 || height <= 0) return null;
+				const rx_attr = this.get_attr(id, "rx");
+				const ry_attr = this.get_attr(id, "ry");
+				const rx_parsed = rx_attr === null ? null : parse_user_unit(rx_attr);
+				const ry_parsed = ry_attr === null ? null : parse_user_unit(ry_attr);
+				if (rx_attr !== null && rx_parsed === null) return null;
+				if (ry_attr !== null && ry_parsed === null) return null;
+				let rx = rx_parsed ?? ry_parsed ?? 0;
+				let ry = ry_parsed ?? rx_parsed ?? 0;
+				rx = Math.max(0, Math.min(rx, width / 2));
+				ry = Math.max(0, Math.min(ry, height / 2));
+				return {
+					kind: "rect",
+					x,
+					y,
+					width,
+					height,
+					rx,
+					ry
+				};
+			}
+			case "circle": {
+				const cx = this.optional_user_unit_coord(id, "cx");
+				const cy = this.optional_user_unit_coord(id, "cy");
+				if (cx === null || cy === null) return null;
+				const r = parse_user_unit(this.get_attr(id, "r"));
+				if (r === null || r <= 0) return null;
+				return {
+					kind: "circle",
+					cx,
+					cy,
+					r
+				};
+			}
+			case "ellipse": {
+				const cx = this.optional_user_unit_coord(id, "cx");
+				const cy = this.optional_user_unit_coord(id, "cy");
+				if (cx === null || cy === null) return null;
+				const rx = parse_user_unit(this.get_attr(id, "rx"));
+				const ry = parse_user_unit(this.get_attr(id, "ry"));
+				if (rx === null || ry === null) return null;
+				if (rx <= 0 || ry <= 0) return null;
+				return {
+					kind: "ellipse",
+					cx,
+					cy,
+					rx,
+					ry
+				};
+			}
+			default: return null;
+		}
+	}
+	/**
+	* Re-type a native vector element (`<line>` / `<polyline>` / `<polygon>` /
+	* `<rect>` / `<circle>` / `<ellipse>`) into a `<path>` in place, consuming
+	* its native geometry attributes and setting `d`. A structural mutation:
+	* this layer executes the re-type; it does not decide when one is
+	* warranted.
+	*
+	* Idempotent: returns `null` if `id` is not currently one of those tags
+	* (so it is safe to call repeatedly — once re-typed, e.g. already a
+	* `<path>`, further calls are no-ops). Otherwise mutates the node and
+	* returns an opaque {@link RetypeRecord} reversal token.
+	*
+	* Identity, children, `self_closing`, non-geometry attributes, and all
+	* source trivia are preserved unchanged — only the tag and the geometry
+	* attributes move. Pass the token to {@link revert_retype} to restore
+	* the original primitive byte-for-byte.
+	*
+	* (see test/svg-editor-vector-promote-to-path.md)
+	*/
+	retype_to_path(id, d) {
+		const n = this.nodes.get(id);
+		if (!n || n.kind !== "element") return null;
+		const geom = RETYPABLE_GEOMETRY_ATTRS[n.local];
+		if (!geom) return null;
+		const prev_local = n.local;
+		const prev_raw_tag = n.raw_tag;
+		const removed = [];
+		for (let i = n.attrs.length - 1; i >= 0; i--) {
+			const a = n.attrs[i];
+			if (a.prefix === null && a.ns === null && geom.has(a.local)) {
+				removed.push({
+					index: i,
+					token: a
+				});
+				n.attrs.splice(i, 1);
+			}
+		}
+		removed.reverse();
+		n.local = "path";
+		n.raw_tag = n.prefix ? `${n.prefix}:path` : "path";
+		n.attrs.push({
+			raw_name: "d",
+			prefix: null,
+			local: "d",
+			ns: null,
+			value: d,
+			...SYNTH_ATTR_TRIVIA
+		});
+		let added_fill_none = false;
+		if (prev_local === "line" && this.get_attr(id, "fill") === null && this.get_style(id, "fill") === null) {
+			n.attrs.push({
+				raw_name: "fill",
+				prefix: null,
+				local: "fill",
+				ns: null,
+				value: "none",
+				...SYNTH_ATTR_TRIVIA
+			});
+			added_fill_none = true;
+		}
+		this._structure_version++;
+		this._geometry_version++;
+		this.emit();
 		return {
-			parent,
-			insert_before: siblings[last_index + 1] ?? null,
-			children,
-			original_positions
+			prev_local,
+			prev_raw_tag,
+			removed,
+			added_fill_none
 		};
 	}
-	_group.plan = plan;
-})(group || (group = {}));
+	/**
+	* Reverse a {@link retype_to_path}: restore the original tag, remove the
+	* `d` attribute the promotion added, and splice the captured geometry
+	* attribute tokens back at their original positions (preserving their
+	* trivia, so a later `serialize()` is byte-equal to the pre-promotion
+	* source).
+	*/
+	revert_retype(id, token) {
+		const n = this.nodes.get(id);
+		if (!n || n.kind !== "element") return;
+		for (let i = n.attrs.length - 1; i >= 0; i--) {
+			const a = n.attrs[i];
+			if (a.prefix === null && a.ns === null && a.local === "d") {
+				n.attrs.splice(i, 1);
+				break;
+			}
+		}
+		if (token.added_fill_none) for (let i = n.attrs.length - 1; i >= 0; i--) {
+			const a = n.attrs[i];
+			if (a.prefix === null && a.ns === null && a.local === "fill") {
+				n.attrs.splice(i, 1);
+				break;
+			}
+		}
+		n.local = token.prev_local;
+		n.raw_tag = token.prev_raw_tag;
+		for (const { index, token: t } of token.removed) n.attrs.splice(index, 0, t);
+		this._structure_version++;
+		this._geometry_version++;
+		this.emit();
+	}
+	/**
+	* True iff this `<text>` / `<tspan>` carries a non-empty `rotate=""`
+	* per-glyph attribute (which conflicts with element-level rotation).
+	*/
+	has_glyph_rotate(id) {
+		const tag = this.tag_of(id);
+		if (tag !== "text" && tag !== "tspan") return false;
+		const value = this.get_attr(id, "rotate");
+		if (value === null) return false;
+		return value.trim() !== "";
+	}
+	/**
+	* True iff this element's inline `style=""` declares a `transform:`
+	* CSS property (which would shadow the editor's `transform=` writes).
+	*/
+	has_inline_css_transform(id) {
+		const style = this.get_attr(id, "style");
+		if (!style) return false;
+		return CSS_TRANSFORM_PROPERTY.test(style);
+	}
+	/**
+	* True iff this element has a direct `<animateTransform>` child
+	* (which produces a time-varying transform invisible to attribute writes).
+	* Only direct children are checked — nested cases attach to the nearer ancestor.
+	*/
+	has_animate_transform_child(id) {
+		for (const c of this.children_of(id)) {
+			const n = this.nodes.get(c);
+			if (n?.kind === "element" && n.local === "animateTransform") return true;
+		}
+		return false;
+	}
+	text_of(id) {
+		const n = this.nodes.get(id);
+		if (!n || n.kind !== "element") return "";
+		let out = "";
+		for (const c of n.children) {
+			const cn = this.nodes.get(c);
+			if (cn?.kind === "text") out += cn.value;
+		}
+		return out;
+	}
+	/** Replace all direct text children with a single text node carrying `value`. */
+	set_text(id, value) {
+		const n = this.nodes.get(id);
+		if (!n || n.kind !== "element") return;
+		n.children = n.children.filter((c) => this.nodes.get(c)?.kind !== "text");
+		if (value !== "") {
+			const text_id = `t${Math.random().toString(36).slice(2, 10)}`;
+			const text_node = {
+				kind: "text",
+				id: text_id,
+				parent: id,
+				value
+			};
+			this.nodes.set(text_id, text_node);
+			n.children.push(text_id);
+		}
+		this._structure_version++;
+		this._geometry_version++;
+		this.emit();
+	}
+	insert(id, parent, before) {
+		const node = this.nodes.get(id);
+		const parent_node = this.nodes.get(parent);
+		if (!node || !parent_node || parent_node.kind !== "element") return;
+		if (node.parent !== null) {
+			const old_parent = this.nodes.get(node.parent);
+			if (old_parent && old_parent.kind === "element") {
+				const i = old_parent.children.indexOf(id);
+				if (i >= 0) old_parent.children.splice(i, 1);
+			}
+		}
+		const ix = before === null ? -1 : parent_node.children.indexOf(before);
+		if (ix < 0) parent_node.children.push(id);
+		else parent_node.children.splice(ix, 0, id);
+		node.parent = parent;
+		this._structure_version++;
+		this._geometry_version++;
+		this.emit();
+	}
+	remove(id) {
+		const n = this.nodes.get(id);
+		if (!n || n.parent === null) return;
+		const parent = this.nodes.get(n.parent);
+		if (!parent || parent.kind !== "element") return;
+		const i = parent.children.indexOf(id);
+		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). */
+	create_element(local, opts) {
+		const id = this.fresh_node_id();
+		const prefix = opts?.prefix ?? null;
+		const ns = opts?.ns ?? null;
+		const node = {
+			kind: "element",
+			id,
+			parent: null,
+			raw_tag: prefix ? `${prefix}:${local}` : local,
+			prefix,
+			local,
+			ns,
+			attrs: [],
+			children: [],
+			self_closing: false,
+			open_tag_trailing: "",
+			close_tag_leading: "",
+			close_tag_trailing: ""
+		};
+		this.nodes.set(id, node);
+		return id;
+	}
+	/** Fresh internal NodeId, guaranteed unique within this document's node
+	*  map. Shared by `create_element` and fragment adoption — collisions
+	*  matter for the latter because the parser assigns sequential per-parse
+	*  ids that a second parse would repeat. */
+	fresh_node_id() {
+		let id;
+		do
+			id = `e${Math.random().toString(36).slice(2, 10)}`;
+		while (this.nodes.has(id));
+		return id;
+	}
+	/**
+	* Parse an SVG **fragment** string and adopt its element subtrees into
+	* this document's node store — registered like {@link create_element}
+	* but NOT inserted into the tree (no version bump, no emit). Callers
+	* attach the returned roots via {@link insert}; the editor's
+	* `commands.insert_fragment` is the history-bracketed consumer.
+	*
+	* Input shapes:
+	*   - A **bare fragment** — one or more sibling elements
+	*     (`<path …/><path …/>`, or a single `<g>…</g>`). The top-level
+	*     elements become the returned roots, in source order.
+	*   - A **full SVG document** — when the input's only top-level element
+	*     is an `<svg>`, that element is treated as a document SHELL, not
+	*     content: its element children become the roots and the shell
+	*     itself (viewBox, width/height, prolog, doctype) is discarded. Its
+	*     `xmlns:*` prefix declarations are harvested into `xmlns` so the
+	*     caller can re-declare prefixes the adopted content still uses.
+	*     An `<svg>` that appears as one of SEVERAL top-level elements (or
+	*     anywhere below the top level) is content, adopted as-is.
+	*
+	* Top-level non-element nodes (whitespace between roots, comments, PIs,
+	* doctype) are dropped — adoption takes elements, and the host
+	* document's own trivia stays untouched. WITHIN each adopted subtree
+	* every byte of source trivia survives verbatim (attribute order, quote
+	* styles, whitespace, comments), so the inserted markup serializes back
+	* exactly as authored — same rules as the initial parse.
+	*
+	* Authored `id=""` attributes are adopted verbatim — never rewritten,
+	* even when they collide with ids already in the document. Silent id
+	* renaming is exactly the proprietary noise this editor refuses (README
+	* "What clean means" §3); deduplication belongs to the explicit Tidy
+	* command. Internal NodeIds ARE freshly assigned (see
+	* {@link fresh_node_id}) so adopted nodes never collide in the id map.
+	*
+	* Throws `TypeError` on a non-string input and `Error` on markup the
+	* parser rejects (unclosed / mismatched tags, malformed attributes). An
+	* input with no top-level elements (empty string, whitespace, comments
+	* only) returns `{ roots: [], xmlns: [] }`.
+	*/
+	create_fragment(markup) {
+		if (typeof markup !== "string") throw new TypeError(`create_fragment(markup) requires a string source, got ${markup === null ? "null" : typeof markup}`);
+		const parsed = parse_svg(`<svg xmlns="${SVG_NS}" xmlns:xlink="${XLINK_NS$1}">${markup}</svg>`);
+		const wrapper = parsed.nodes.get(parsed.root);
+		const element_children = (n) => n.children.map((c) => parsed.nodes.get(c)).filter((cn) => cn?.kind === "element");
+		let content = element_children(wrapper);
+		const xmlns = [];
+		if (content.length === 1 && content[0].local === "svg") {
+			const shell = content[0];
+			for (const a of shell.attrs) if (a.prefix === "xmlns") xmlns.push({
+				prefix: a.local,
+				uri: a.value
+			});
+			content = element_children(shell);
+		}
+		const roots = [];
+		for (const node of content) roots.push(this.adopt_parsed_subtree(node, parsed.nodes, null));
+		return {
+			roots,
+			xmlns
+		};
+	}
+	/**
+	* Register `node` and its whole subtree (from a foreign parse) into this
+	* document's node map under fresh NodeIds. The parser assigns sequential
+	* per-parse ids (`n0`, `n1`, …), so adopting without a remap would
+	* collide with this document's own nodes. Children links are rewritten;
+	* the subtree root arrives detached (`parent: null`), like
+	* `create_element`. Mutates the parsed nodes in place — a parse result
+	* is single-use.
+	*/
+	adopt_parsed_subtree(node, source, parent) {
+		const id = this.fresh_node_id();
+		node.id = id;
+		node.parent = parent;
+		this.nodes.set(id, node);
+		if (node.kind === "element") {
+			const parsed_children = node.children;
+			node.children = [];
+			for (const c of parsed_children) {
+				const child = source.get(c);
+				if (!child) continue;
+				node.children.push(this.adopt_parsed_subtree(child, source, id));
+			}
+		}
+		return id;
+	}
+	/**
+	* Namespace prefixes USED within `id`'s subtree (element tags and
+	* attribute names) that are not DECLARED within the subtree itself —
+	* i.e. prefixes the subtree borrows from ancestor scope. `xml` and
+	* `xmlns` are excluded (bound by the XML spec, never declared).
+	* Declaration scoping is honored per use-site: a prefix declared on the
+	* using element or any of its ancestors up to (and including) the
+	* subtree root counts as declared.
+	*
+	* Structural fact only — the caller decides what an unbound prefix
+	* means (e.g. `commands.insert_fragment` hoists a resolvable
+	* declaration onto the document root).
+	*/
+	undeclared_ns_prefixes(id) {
+		const out = /* @__PURE__ */ new Set();
+		const walk = (nid, declared) => {
+			const n = this.nodes.get(nid);
+			if (!n || n.kind !== "element") return;
+			const scope = new Set(declared);
+			for (const a of n.attrs) if (a.prefix === "xmlns") scope.add(a.local);
+			const need = (p) => {
+				if (p === null || p === "xml" || p === "xmlns") return;
+				if (!scope.has(p)) out.add(p);
+			};
+			need(n.prefix);
+			for (const a of n.attrs) if (a.prefix !== "xmlns") need(a.prefix);
+			for (const c of n.children) walk(c, scope);
+		};
+		walk(id, /* @__PURE__ */ new Set());
+		return out;
+	}
+	/**
+	* Declare a namespace prefix on the ROOT element: appends
+	* `xmlns:<prefix>="<uri>"` when the root doesn't already declare that
+	* prefix. An authored declaration always wins — this never rebinds.
+	* Policy wrapper over {@link set_attr} in the `XMLNS_NS` space; removal
+	* works through `set_attr(root, prefix, null, XMLNS_NS)` as usual.
+	*/
+	declare_xmlns(prefix, uri) {
+		if (this.get_attr(this.root, prefix, XMLNS_NS) !== null) return;
+		this.set_attr(this.root, prefix, uri, XMLNS_NS);
+	}
+	serialize() {
+		let out = "";
+		for (const p of this.prolog) out += this.emit_node(p);
+		out += this.emit_node(this.nodes.get(this.root));
+		for (const e of this.epilog) out += this.emit_node(e);
+		return out;
+	}
+	/**
+	* Serialize a single element's subtree as an SVG **fragment**, using the
+	* same trivia-preserving rules as {@link serialize} (attribute order,
+	* quote style, whitespace, comments — emitted exactly as authored).
+	*
+	* This is NOT {@link serialize} scoped to a node — it is a deliberately
+	* weaker output (sdk-design D3, asymmetric outputs stay separate):
+	*
+	*   - `serialize()` emits the whole document and carries the P1
+	*     whole-document round-trip guarantee.
+	*   - `serialize_node()` emits a fragment and does NOT. Namespace
+	*     declarations that live on an ancestor (`xmlns:xlink` and friends,
+	*     normally on the root `<svg>`) are NOT inlined — a node using
+	*     `xlink:href` serializes without `xmlns:xlink`. The fragment is the
+	*     element's markup as authored, not a standalone parseable document.
+	*
+	* Throws on an unknown id, a non-element node, or a node detached from
+	* the live tree: the contract is "the markup for a selected element,"
+	* selections are always live elements, and a string return of `""` for a
+	* bad id would hide consumer bugs. The detached case matters because
+	* `remove()` keeps the node in the id map for undo — a stale id from a
+	* removed node would otherwise serialize content no longer in the
+	* document, silently feeding a consumer deleted markup.
+	*/
+	serialize_node(id) {
+		const n = this.nodes.get(id);
+		if (!n) throw new Error(`serialize_node: unknown node id ${JSON.stringify(id)}`);
+		if (n.kind !== "element") throw new Error(`serialize_node: node ${JSON.stringify(id)} is a ${n.kind} node, not an element`);
+		if (!this.contains(this.root, id)) throw new Error(`serialize_node: node ${JSON.stringify(id)} is detached from the current document`);
+		return this.emit_node(n);
+	}
+	emit_node(n) {
+		switch (n.kind) {
+			case "text": return encode_text(n.value);
+			case "comment": return `<!--${n.value}-->`;
+			case "cdata": return `<![CDATA[${n.value}]]>`;
+			case "pi": {
+				const pi = n;
+				return `<?${pi.target}${pi.value ? " " + pi.value : ""}?>`;
+			}
+			case "doctype": return `<!DOCTYPE${n.value}>`;
+			case "element": {
+				const e = n;
+				let s = `<${e.raw_tag}`;
+				for (const a of e.attrs) s += this.emit_attr(a);
+				if (e.children.length === 0 && e.self_closing) {
+					s += `${e.open_tag_trailing}/>`;
+					return s;
+				}
+				s += `${e.open_tag_trailing}>`;
+				for (const cid of e.children) {
+					const cn = this.nodes.get(cid);
+					if (cn) s += this.emit_node(cn);
+				}
+				s += `</${e.close_tag_leading}${e.raw_tag}${e.close_tag_trailing}>`;
+				return s;
+			}
+		}
+	}
+	emit_attr(a) {
+		return `${a.pre}${a.raw_name}${a.eq_trivia}=${a.eq_trailing}${a.quote}${encode_attr_value(a.value, a.quote)}${a.quote}`;
+	}
+};
+function parse_inline_style(s) {
+	const out = [];
+	const decls = s.split(";");
+	for (const decl of decls) {
+		const colon = decl.indexOf(":");
+		if (colon === -1) continue;
+		const property = decl.slice(0, colon).trim();
+		const value = decl.slice(colon + 1).trim();
+		if (property) out.push({
+			property,
+			value
+		});
+	}
+	return out;
+}
+/**
+* Namespace prefixes resolvable without a source declaration. ONE table,
+* shared by the paste-side hoist (`insert_fragment`'s xmlns plan) and the
+* copy-side shell repair (clipboard payload extraction) — the two sides
+* form a round-trip and must agree: a prefix only one side knows would
+* produce payloads the other can't honor.
+*/
+const WELL_KNOWN_NS_PREFIXES = new Map([["xlink", XLINK_NS$1]]);
+//#endregion
+//#region src/core/subtree.ts
+/**
+* The selection → subtree algebra the two extraction operations share,
+* plus the clone-specific member (`clone_plan`).
+*
+* The clipboard FRD
+* ([docs/wg/feat-svg-editor/clipboard.md](../../../../docs/wg/feat-svg-editor/clipboard.md)
+* §Two extraction operations) names two operations over a normalized
+* selection: **payload extraction** (copy — `core/clipboard.ts`) and
+* **subtree clone** (duplicate / clone-drag — this module; design note:
+* [docs/wg/feat-svg-editor/subtree-clone.md](../../../../docs/wg/feat-svg-editor/subtree-clone.md)).
+* They share exactly two things — selection normalization
+* ({@link subtree.normalize_roots}) and verbatim subtree serialization
+* (`SvgDocument.serialize_node`) — and nothing else.
+*
+* Unlike copy's payload, a clone carries **no reference closure and no
+* namespace shell**: the destination is the source document, every
+* `url(#…)` / `href` reference still resolves against it, and carrying
+* definitions would deposit duplicate defs on every duplicate.
+*
+* Consumers: `commands.duplicate` (⌘D) and the translate orchestrator's
+* Alt-drag clone session (gridaco/grida#817).
+*
+* Verbatim-id policy: authored `id=""` attributes are cloned verbatim,
+* NEVER rewritten — same stance as `insert_fragment`. A clone of a node
+* carrying `id="x"` yields a second `id="x"`; reference resolution follows
+* the host renderer's first-in-document-order rule (a cloned subtree's
+* internal self-reference resolves to the ORIGINAL), and deduplication is
+* the explicit Tidy command's job.
+*/
+let subtree;
+(function(_subtree) {
+	function by_document_order(doc) {
+		const index = /* @__PURE__ */ new Map();
+		let i = 0;
+		for (const id of doc.all_nodes()) index.set(id, i++);
+		return (a, b) => (index.get(a) ?? 0) - (index.get(b) ?? 0);
+	}
+	_subtree.by_document_order = by_document_order;
+	function normalize_roots(doc, selection, order) {
+		const live = [...new Set(selection)].filter((id) => doc.is_element(id) && doc.contains(doc.root, id));
+		const roots = doc.prune_nested_nodes(live);
+		if (roots.length > 1) roots.sort(order ?? by_document_order(doc));
+		return roots;
+	}
+	_subtree.normalize_roots = normalize_roots;
+	function clone_plan(doc, selection) {
+		const out = [];
+		for (const origin of normalize_roots(doc, selection)) {
+			const parent = doc.parent_of(origin);
+			if (parent === null) continue;
+			if (doc.tag_of(origin) === "svg") continue;
+			const { roots } = doc.create_fragment(doc.serialize_node(origin));
+			if (roots.length !== 1) throw new Error(`subtree.clone_plan: cloning ${JSON.stringify(origin)} yielded ${roots.length} roots`);
+			out.push({
+				origin,
+				clone: roots[0],
+				parent,
+				before: doc.next_sibling_of(origin)
+			});
+		}
+		return out;
+	}
+	_subtree.clone_plan = clone_plan;
+	function insert_plan(doc, plan) {
+		for (const p of plan) doc.insert(p.clone, p.parent, p.before);
+	}
+	_subtree.insert_plan = insert_plan;
+	function remove_plan(doc, plan) {
+		for (const p of plan) doc.remove(p.clone);
+	}
+	_subtree.remove_plan = remove_plan;
+	/** Per-member rigidity tolerance for the rigid-translate witness in
+	*  {@link repeat_delta} — position drift from the shared delta, and
+	*  size drift from the origin. Generous against float noise from
+	*  re-encoded path data / `getBBox`, far below anything a user would
+	*  call a move or a resize. */
+	const REPEAT_RIGID_EPSILON = .01;
+	function repeat_delta(record, targets, bounds_of) {
+		if (record === null) return null;
+		if (record.origins.length === 0) return null;
+		if (record.origins.length !== record.clones.length) return null;
+		if (!array_shallow_equal(record.clones, targets)) return null;
+		const origin_bounds = collect_bounds(record.origins, bounds_of);
+		if (origin_bounds === null) return null;
+		const clone_bounds = collect_bounds(record.clones, bounds_of);
+		if (clone_bounds === null) return null;
+		const a = cmath.rect.union(origin_bounds);
+		const b = cmath.rect.union(clone_bounds);
+		const dx = b.x - a.x;
+		const dy = b.y - a.y;
+		for (let i = 0; i < origin_bounds.length; i++) {
+			const o = origin_bounds[i];
+			const c = clone_bounds[i];
+			if (Math.abs(c.x - o.x - dx) > REPEAT_RIGID_EPSILON || Math.abs(c.y - o.y - dy) > REPEAT_RIGID_EPSILON || Math.abs(c.width - o.width) > REPEAT_RIGID_EPSILON || Math.abs(c.height - o.height) > REPEAT_RIGID_EPSILON) return null;
+		}
+		if (Math.abs(dx) <= REPEAT_RIGID_EPSILON && Math.abs(dy) <= REPEAT_RIGID_EPSILON) return null;
+		return {
+			x: dx,
+			y: dy
+		};
+	}
+	_subtree.repeat_delta = repeat_delta;
+	/** All-or-nothing bounds gather for {@link repeat_delta} — one
+	*  unmeasurable member and the record can't witness a rigid
+	*  translate. */
+	function collect_bounds(ids, bounds_of) {
+		const out = [];
+		for (const id of ids) {
+			const r = bounds_of(id);
+			if (r === null) return null;
+			out.push(r);
+		}
+		return out;
+	}
+})(subtree || (subtree = {}));
 //#endregion
 //#region src/core/transform.ts
 let transform;
@@ -332,8 +1384,186 @@ let transform;
 		} : op));
 	}
 	_transform.recompose = recompose;
+	/** Epsilon for the identity-leading-matrix drop. Trig/compose noise on
+	*  a flip-then-flip round-trip lands well inside 1e-9; authored SVG
+	*  coordinates rarely carry more than 4 significant decimals, so this
+	*  never collapses a meaningful matrix. */
+	const IDENTITY_EPSILON = 1e-9;
+	/** A `cmath.Transform` (`[[a,c,e],[b,d,f]]`) as a `matrix` op
+	*  (`matrix(a b c d e f)` argument order). */
+	function transform_to_matrix_op(m) {
+		return {
+			type: "matrix",
+			a: m[0][0],
+			b: m[1][0],
+			c: m[0][1],
+			d: m[1][1],
+			e: m[0][2],
+			f: m[1][2]
+		};
+	}
+	function is_identity_matrix(m) {
+		const id = cmath.transform.identity;
+		return Math.abs(m[0][0] - id[0][0]) <= IDENTITY_EPSILON && Math.abs(m[0][1] - id[0][1]) <= IDENTITY_EPSILON && Math.abs(m[0][2] - id[0][2]) <= IDENTITY_EPSILON && Math.abs(m[1][0] - id[1][0]) <= IDENTITY_EPSILON && Math.abs(m[1][1] - id[1][1]) <= IDENTITY_EPSILON && Math.abs(m[1][2] - id[1][2]) <= IDENTITY_EPSILON;
+	}
+	function apply_affine(transform_str, effective) {
+		const ops = parse(transform_str);
+		if (ops === null) return transform_str;
+		const has_leading_matrix = ops.length > 0 && ops[0].type === "matrix";
+		const existing_leading = has_leading_matrix ? op_matrix(ops[0]) : cmath.transform.identity;
+		const rest = has_leading_matrix ? ops.slice(1) : ops;
+		const folded = cmath.transform.multiply(effective, existing_leading);
+		if (is_identity_matrix(folded)) {
+			if (rest.length === 0) return null;
+			return emit(rest);
+		}
+		return emit([transform_to_matrix_op(folded), ...rest]);
+	}
+	_transform.apply_affine = apply_affine;
 })(transform || (transform = {}));
 //#endregion
+//#region src/core/group.ts
+let group;
+(function(_group) {
+	const STRUCTURAL_GRAPHICS = _group.STRUCTURAL_GRAPHICS = new Set([
+		"g",
+		"defs",
+		"svg",
+		"use",
+		"image",
+		"switch",
+		"foreignObject",
+		"path",
+		"rect",
+		"circle",
+		"ellipse",
+		"line",
+		"polyline",
+		"polygon",
+		"text",
+		"a"
+	]);
+	const CONSTRAINED_PARENT = _group.CONSTRAINED_PARENT = new Set([
+		"text",
+		"tspan",
+		"defs",
+		"clipPath",
+		"mask",
+		"pattern",
+		"marker",
+		"symbol",
+		"filter",
+		"linearGradient",
+		"radialGradient",
+		"animateMotion",
+		"switch"
+	]);
+	function plan(doc, ids) {
+		if (ids.length === 0) return null;
+		const parent = doc.parent_of(ids[0]);
+		if (parent === null) return null;
+		for (const id of ids) {
+			if (doc.parent_of(id) !== parent) return null;
+			if (!STRUCTURAL_GRAPHICS.has(doc.tag_of(id))) return null;
+		}
+		if (CONSTRAINED_PARENT.has(doc.tag_of(parent))) return null;
+		const siblings = doc.element_children_of(parent);
+		const sibling_index = /* @__PURE__ */ new Map();
+		for (let i = 0; i < siblings.length; i++) sibling_index.set(siblings[i], i);
+		const indices = [];
+		for (const id of ids) {
+			const i = sibling_index.get(id);
+			if (i === void 0) return null;
+			indices.push(i);
+		}
+		const sorted = Array.from(new Set(indices)).sort((a, b) => a - b);
+		for (let i = 1; i < sorted.length; i++) if (sorted[i] !== sorted[i - 1] + 1) return null;
+		const children = sorted.map((i) => siblings[i]);
+		const last_index = sorted[sorted.length - 1];
+		const original_positions = /* @__PURE__ */ new Map();
+		for (const i of sorted) original_positions.set(siblings[i], siblings[i + 1] ?? null);
+		return {
+			parent,
+			insert_before: siblings[last_index + 1] ?? null,
+			children,
+			original_positions
+		};
+	}
+	_group.plan = plan;
+	/**
+	* Own-attribute allowlist for the safe clean-structural ungroup subset.
+	* A group carrying ONLY these attributes is a plain structural wrapper:
+	* dissolving it splices its children into the parent without changing
+	* what renders (modulo baking the `transform`, which `ungroup` does).
+	*
+	* - `transform` — baked into each child by prepending its ops.
+	* - `id` — only allowed when no `<use>` references it (checked below);
+	*   the group's own `id` simply disappears (no child inherits it).
+	* - `data-grida-id` — the editor's runtime node identity. Internal; the
+	*   group node is removed entirely so the id retires with it.
+	*
+	* ANY other own attribute (`class`, `style`, `opacity`, `fill`,
+	* `stroke`, `filter`, `clip-path`, `mask`, `font-*`, …) carries visual
+	* / cascade / inheritance state that is NOT generally equivalent to the
+	* per-child result of removing the group (TODO §10). Those groups are
+	* refused — never silently mishandled.
+	*/
+	const UNGROUP_OWN_ATTR_ALLOWLIST = new Set([
+		"transform",
+		"id",
+		"data-grida-id"
+	]);
+	/** SVG animation elements (SMIL). A direct animation child targets the
+	*  group as its `targetElement`; dissolving the group orphans the
+	*  animation. Refuse rather than relocate it. */
+	const ANIMATION_TAGS = new Set([
+		"animate",
+		"animateTransform",
+		"animateMotion",
+		"set"
+	]);
+	function plan_ungroup(doc, id) {
+		if (doc.tag_of(id) !== "g") return null;
+		const parent = doc.parent_of(id);
+		if (parent === null) return null;
+		{
+			let cur = parent;
+			while (cur !== null) {
+				if (doc.tag_of(cur) === "defs") return null;
+				cur = doc.parent_of(cur);
+			}
+		}
+		const children = doc.element_children_of(id);
+		if (children.length < 1) return null;
+		let has_id = false;
+		for (const a of doc.attributes_of(id)) {
+			if (a.ns !== null) return null;
+			if (!UNGROUP_OWN_ATTR_ALLOWLIST.has(a.name)) return null;
+			if (a.name === "id") has_id = true;
+		}
+		if (has_id) {
+			const own_id = doc.get_attr(id, "id");
+			if (own_id !== null) {
+				const fragment = `#${own_id}`;
+				for (const use_id of doc.find_by_tag(doc.root, "use")) if ((doc.get_attr(use_id, "href") ?? doc.get_attr(use_id, "href", XLINK_NS$1)) === fragment) return null;
+			}
+		}
+		for (const child of children) if (ANIMATION_TAGS.has(doc.tag_of(child))) return null;
+		const group_transform = doc.get_attr(id, "transform");
+		if (group_transform !== null) {
+			if (transform.parse(group_transform) === null) return null;
+			for (const child of children) if (transform.parse(doc.get_attr(child, "transform")) === null) return null;
+		}
+		return {
+			group_id: id,
+			parent,
+			children: [...children],
+			group_transform
+		};
+	}
+	_group.plan_ungroup = plan_ungroup;
+})(group || (group = {}));
+//#endregion
 //#region src/core/translate-pipeline/translate-pipeline.ts
 let translate_pipeline;
 (function(_translate_pipeline) {
@@ -684,6 +1914,8 @@ let translate_pipeline;
 })(translate_pipeline || (translate_pipeline = {}));
 //#endregion
 //#region src/core/translate-pipeline/orchestrator.ts
+const movers = (s) => s.clone?.ids ?? s.ids;
+const mover_baselines = (s) => s.clone?.baselines ?? s.baselines;
 const PROVIDER_ID$2 = "svg-editor";
 var TranslateOrchestrator = class {
 	constructor(deps) {
@@ -706,25 +1938,33 @@ var TranslateOrchestrator = class {
 	drive(input, modifiers, opts) {
 		if (this.active === null) this.active = this.open(input.ids, opts.snap, opts.label ?? "move");
 		const session = this.active;
+		this.reconcile_clone(session, modifiers);
 		const stages = opts.stages ?? translate_pipeline.stages.DEFAULT;
 		const result = this.run_pass(session, input.movement, modifiers, opts.policy, stages);
 		session.last_movement = input.movement;
 		session.last_policy = opts.policy;
 		session.last_stages = stages;
-		this.write_preview_delta(session, result.plan);
+		if (opts.phase === "commit" && session.clone !== null) this.write_commit_composite(session, result.plan);
+		else this.write_preview_delta(session, result.plan);
 		if (opts.phase === "commit") {
+			const cloned = session.clone;
 			session.preview.commit();
 			this.dispose_session();
+			if (cloned !== null) this.deps.on_clone_commit?.({
+				origins: cloned.plan.map((p) => p.origin),
+				clones: cloned.ids
+			});
 		}
 		return result;
 	}
 	/** Re-run the current preview frame with new modifiers, reusing the
 	*  last-known movement / policy / stages. Used when a modifier key
-	*  changes between pointer-move events (Shift down/up mid-drag).
-	*  No-op when no session is active. */
+	*  changes between pointer-move events (Shift down/up mid-drag,
+	*  Alt down/up → clone toggle). No-op when no session is active. */
 	redrive_modifiers(modifiers) {
 		if (!this.active) return null;
 		const session = this.active;
+		this.reconcile_clone(session, modifiers);
 		const result = this.run_pass(session, session.last_movement, modifiers, session.last_policy, session.last_stages);
 		this.write_preview_delta(session, result.plan);
 		return result;
@@ -732,15 +1972,22 @@ var TranslateOrchestrator = class {
 	/** Cancel an in-flight gesture (Escape, programmatic abort). */
 	cancel() {
 		if (!this.active) return;
-		this.active.preview.discard();
+		const session = this.active;
+		session.preview.discard();
+		if (session.clone !== null) {
+			subtree.remove_plan(this.deps.get_doc(), session.clone.plan);
+			this.deps.set_selection?.(session.ids);
+			this.deps.emit();
+		}
 		this.dispose_session();
 	}
 	/** Build a plan + context, run the pipeline, stash guides. Pure
-	*  computation — does not touch the preview. */
+	*  computation — does not touch the preview. The context's modifiers
+	*  are the pipeline's own vocabulary: stages never see `clone`. */
 	run_pass(session, movement, modifiers, policy, stages) {
 		const plan0 = {
-			ids: session.ids,
-			baselines: session.baselines,
+			ids: movers(session),
+			baselines: mover_baselines(session),
 			delta: {
 				x: 0,
 				y: 0
@@ -748,7 +1995,7 @@ var TranslateOrchestrator = class {
 		};
 		const ctx = {
 			input: {
-				ids: session.ids,
+				ids: plan0.ids,
 				movement
 			},
 			modifiers,
@@ -760,6 +2007,69 @@ var TranslateOrchestrator = class {
 		this._last_guides = result.guides;
 		return result;
 	}
+	/**
+	* Clone-modifier state machine (Alt-drag translate-with-clone). Runs
+	* before each pipeline pass so a toggle takes effect on the very frame
+	* it happens — lazy clone on the first frame with the modifier held.
+	*
+	* Both edges and the composite commit below depend on one invariant:
+	* `translate_pipeline.*.revert` writes ABSOLUTE baseline values (incl.
+	* tspan's exact-attr restore), so re-reverting an already-reverted set
+	* is a no-op. A future relative-write baseline kind would break this.
+	*/
+	reconcile_clone(session, modifiers) {
+		const want = modifiers.clone === true;
+		const cloned = session.clone !== null;
+		if (want && !cloned) this.enter_clone(session);
+		else if (!want && cloned) this.exit_clone(session);
+	}
+	/** Enter the cloned state: origins back to rest, verbatim clones
+	*  inserted next to them, gesture + selection + snap retargeted to the
+	*  clones. The origin set stays untouched for the rest of the cloned
+	*  gesture — the CLONE moves, the origin stays (Figma convention). */
+	enter_clone(session) {
+		const doc = this.deps.get_doc();
+		translate_pipeline.revert(doc, {
+			ids: session.ids,
+			baselines: session.baselines,
+			delta: {
+				x: 0,
+				y: 0
+			}
+		});
+		const plan = subtree.clone_plan(doc, session.ids);
+		if (plan.length === 0) return;
+		subtree.insert_plan(doc, plan);
+		const baselines = /* @__PURE__ */ new Map();
+		for (const p of plan) baselines.set(p.clone, session.baselines.get(p.origin));
+		session.clone = {
+			plan,
+			ids: plan.map((p) => p.clone),
+			baselines
+		};
+		this.retarget(session, session.clone.ids);
+	}
+	/** Exit the cloned state: clones removed, gesture + selection + snap
+	*  retargeted back to the origins, which resume following the cursor
+	*  on the next pass. Removed clones stay in the document's id map
+	*  (standard removed-node policy) and are never serialized; a stale
+	*  preview delta auto-reverting onto them later is harmless. Re-press
+	*  = fresh enter with new clones. */
+	exit_clone(session) {
+		subtree.remove_plan(this.deps.get_doc(), session.clone.plan);
+		session.clone = null;
+		this.retarget(session, session.ids);
+	}
+	/** Point selection + snap at the new mover set. Selection + emit run
+	*  BEFORE the snap reopen: the surface re-renders on notify, so freshly
+	*  inserted clones are measurable when the new snap session captures
+	*  its neighborhood (where the origins are legitimate snap targets). */
+	retarget(session, ids) {
+		this.deps.set_selection?.(ids);
+		this.deps.emit();
+		session.snap?.dispose();
+		session.snap = session.snap_requested ? this.deps.open_snap(ids) : null;
+	}
 	open(ids, snap, label) {
 		const doc = this.deps.get_doc();
 		const filtered = doc.prune_nested_nodes(ids);
@@ -767,10 +2077,12 @@ var TranslateOrchestrator = class {
 			ids: filtered,
 			baselines: translate_pipeline.intent.capture_baselines(doc, filtered),
 			snap: snap ? this.deps.open_snap(filtered) : null,
+			snap_requested: snap,
 			preview: this.deps.open_preview(label),
 			last_movement: [0, 0],
 			last_policy: "engine",
-			last_stages: translate_pipeline.stages.DEFAULT
+			last_stages: translate_pipeline.stages.DEFAULT,
+			clone: null
 		};
 	}
 	/** Bind a fresh apply/revert pair (closure over `plan`) into the
@@ -792,6 +2104,43 @@ var TranslateOrchestrator = class {
 			}
 		});
 	}
+	/** Commit-time delta for a CLONED gesture. Per-frame deltas stay
+	*  translate-only; the structural insert happened at the toggle edge,
+	*  outside the preview. The one delta that gets committed must own the
+	*  whole outcome, so a single undo removes clone + move and a redo
+	*  restores both:
+	*    apply  = insert clones (idempotent reposition when live) +
+	*             translate + select clones
+	*    revert = un-translate + remove clones + select origins
+	*  `preview.set` reverts the previous translate-only delta first
+	*  (clones back to rest), then runs this apply — the document passes
+	*  through exactly the states the closures describe.
+	*  Captures locals only (not the session), so the committed delta
+	*  retains the minimum undo/redo needs. */
+	write_commit_composite(session, plan) {
+		const doc = this.deps.get_doc();
+		const emit = this.deps.emit;
+		const project = this.deps.project_delta;
+		const set_selection = this.deps.set_selection;
+		const clone_plan = session.clone.plan;
+		const clone_ids = session.clone.ids;
+		const origin_ids = session.ids;
+		session.preview.set({
+			providerId: PROVIDER_ID$2,
+			apply: () => {
+				subtree.insert_plan(doc, clone_plan);
+				translate_pipeline.apply(doc, plan, project);
+				set_selection?.(clone_ids);
+				emit();
+			},
+			revert: () => {
+				translate_pipeline.revert(doc, plan);
+				subtree.remove_plan(doc, clone_plan);
+				set_selection?.(origin_ids);
+				emit();
+			}
+		});
+	}
 	dispose_session() {
 		if (!this.active) return;
 		this.active.snap?.dispose();
@@ -935,6 +2284,27 @@ let rotate_pipeline;
 			return { kind: "yes" };
 		}
 		_intent.is_rotatable = is_rotatable;
+		function is_transformable(doc, id) {
+			const own_transform = doc.get_attr(id, "transform");
+			if (transform.parse(own_transform) === null) return {
+				kind: "refuse",
+				reason: "non-trivial-transform"
+			};
+			if (doc.has_glyph_rotate(id)) return {
+				kind: "refuse",
+				reason: "text-with-glyph-rotate"
+			};
+			if (doc.has_inline_css_transform(id)) return {
+				kind: "refuse",
+				reason: "css-property-transform"
+			};
+			if (doc.has_animate_transform_child(id)) return {
+				kind: "refuse",
+				reason: "animated-transform"
+			};
+			return { kind: "yes" };
+		}
+		_intent.is_transformable = is_transformable;
 		function find_op(ops, type) {
 			for (const op of ops) if (op.type === type) return op;
 			return null;
@@ -3726,4 +5096,4 @@ function emitWithVerbs(network, meta) {
 	return encodeSVGPath(commands);
 }
 //#endregion
-export { is_text_input_focused as _, paint as a, hit_shape_svg as c, NudgeDwellWatcher as d, TranslateOrchestrator as f, array_shallow_equal as g, group as h, TOOL_CURSOR as i, RotateOrchestrator as l, transform as m, insertions as n, ResizeOrchestrator as o, translate_pipeline as p, DEFAULT_STYLE as r, resize_pipeline as s, PathModel as t, rotate_pipeline as u };
+export { is_text_input_focused as S, SVG_NS as _, paint as a, XMLNS_NS as b, hit_shape_svg as c, NudgeDwellWatcher as d, TranslateOrchestrator as f, subtree as g, transform as h, TOOL_CURSOR as i, RotateOrchestrator as l, group as m, insertions as n, ResizeOrchestrator as o, translate_pipeline as p, DEFAULT_STYLE as r, resize_pipeline as s, PathModel as t, rotate_pipeline as u, SvgDocument as v, array_shallow_equal as x, WELL_KNOWN_NS_PREFIXES as y };