@weasel-js/core 1.9.3 → 1.10.0

package/dist/interactions/actions/booleans/booleans.js

@@ -3,118 +3,109 @@ import { createDeleteOp as t } from "../../../core/ops/delete.js";
 import { createInsertOp as n } from "../../../core/ops/create.js";
 import { dispatchApplyBatch as r } from "../../../core/applyOps.js";
 import { createSetSelectionOp as i } from "../../../core/ops/select.js";
-import { createMoveToIndexOp as a } from "../../../core/ops/reorder/index.js";
-import { pathCrop as o, pathDivide as s, pathExclude as c, pathIntersect as l, pathSubtract as u, pathUnion as d } from "../../../features/paths/booleans.js";
-import { TextOutlinesError as f, textToPath as p } from "../../../features/text/textToPath.js";
+import { resolveOperand as a } from "./operands.js";
+import { booleanPieces as o } from "./pieces.js";
+import { placementOps as s } from "./placement.js";
+import { TextOutlinesError as c } from "@weasel-js/text";
 //#region src/interactions/actions/booleans/booleans.ts
-function m(e, t) {
-	let n = e.getWorldPath(t);
-	if (n) return n;
-	let r = e.getTextSource?.(t);
-	if (!r) return;
-	let i = p(r.data, r.pose);
-	return i.commands.length > 0 ? i : void 0;
-}
-var h = {
+var l = {
 	union: "Union",
 	intersect: "Intersect",
 	subtract: "Subtract",
 	exclude: "Exclude",
 	divide: "Divide",
-	crop: "Crop"
+	crop: "Crop",
+	trim: "Trim",
+	merge: "Merge"
 };
-function g(e) {
-	return e.commands.length === 0;
-}
-function _(p, _) {
-	let v = [...p.getSelection()], y = (t) => p.getZOrder ? p.getZOrder(t) : e(p, t) ?? void 0, b;
+function u(e, t, n, r) {
+	let i;
 	try {
-		b = v.map((e) => ({
-			id: e,
-			path: m(p, e)
+		i = t.map((t) => ({
+			id: t,
+			operand: a(e, t, r)
 		}));
 	} catch (e) {
-		if (e instanceof f) return {
+		if (e instanceof c) return {
 			kind: "failed",
 			reason: "text-outlines",
 			error: e
 		};
 		throw e;
 	}
-	let x = b.filter((e) => e.path != null).sort((e, t) => p.compareZ(e.id, t.id));
-	if (x.length === 0) return {
+	let s = i.filter((e) => e.operand != null).sort((t, n) => e.compareZ(t.id, n.id));
+	if (s.length === 0) return {
 		kind: "noop",
 		reason: "no-paths"
 	};
-	if (_ === "subtract" && x.length < 2) return {
+	if (n === "subtract" && s.length < 2) return {
 		kind: "noop",
 		reason: "too-few-for-subtract"
 	};
-	if (x.length < 2) return {
+	if (s.length < 2) return {
 		kind: "noop",
 		reason: "no-paths"
 	};
-	let S = x.map((e) => e.path), C;
-	switch (_) {
-		case "union":
-			C = [d(...S)];
-			break;
-		case "intersect":
-			C = [l(...S)];
-			break;
-		case "exclude":
-			C = [c(...S)];
-			break;
-		case "subtract": {
-			let e = S[0], t = S.length === 2 ? S[1] : d(...S.slice(1));
-			C = [u(e, t)];
-			break;
-		}
-		case "divide":
-			C = s(...S);
-			break;
-		case "crop": C = o(...S);
-	}
-	if (C = C.filter((e) => !g(e)), C.length === 0) return {
+	let l = o(n, s.map((e) => e.operand.path), (t) => {
+		let { id: n, operand: r } = s[t], i = r.paint ?? e.getPaint?.(n);
+		return i ? JSON.stringify(i.fill ?? null) : t;
+	});
+	return l.length === 0 ? {
 		kind: "noop",
 		reason: "empty-result"
+	} : {
+		entries: s,
+		pieces: l
 	};
-	let w = x[x.length - 1].id, T = y(w), E = T?.index;
-	if (T) {
-		let e = 0;
-		for (let t = 0; t < x.length - 1; t++) {
-			let n = y(x[t].id);
-			n && n.parentId === T.parentId && n.index < T.index && e++;
-		}
-		E = T.index - e;
-	}
-	let D = C.map((e) => p.createPathNode(e, _, w)), O = [], k = [];
-	for (let e of x) {
-		let t = p.getNode?.(e.id) ?? { id: e.id }, n = y(e.id)?.index ?? -1;
-		k.push({
-			node: t,
-			index: n
-		});
-	}
-	k.sort((e, t) => t.index - e.index);
-	for (let { node: e, index: n } of k) O.push(t({
+}
+function d(e, t, n = {}) {
+	let r = u(e, [...e.getSelection()], t, n);
+	return "kind" in r ? r : {
+		kind: "pieces",
+		pieces: r.pieces.map((e) => {
+			let { id: t, operand: n } = r.entries[e.source];
+			return n.paint ? {
+				path: e.path,
+				sourceId: t,
+				paint: n.paint
+			} : {
+				path: e.path,
+				sourceId: t
+			};
+		})
+	};
+}
+function f(a, o, c = {}) {
+	let d = [...a.getSelection()], f = u(a, d, o, c);
+	if ("kind" in f) return f;
+	let { entries: p, pieces: m } = f, h = (t) => a.getZOrder ? a.getZOrder(t) : e(a, t) ?? void 0, g = p.map((e) => h(e.id)), _ = m.map((e) => {
+		let { id: t, operand: n } = p[e.source];
+		return {
+			node: a.createPathNode(e.path, o, t, n.paint),
+			slot: g[e.source]
+		};
+	}), v = _.map((e) => e.node), y = [], b = p.map((e, t) => ({
+		node: a.getNode?.(e.id) ?? { id: e.id },
+		index: g[t]?.index ?? -1
+	}));
+	b.sort((e, t) => t.index - e.index);
+	for (let { node: e, index: n } of b) y.push(t({
 		node: e,
 		index: n
 	}));
-	for (let e of D) O.push(n({ node: e }));
-	return T && E !== void 0 && O.push(a({
-		ids: D.map((e) => e.id),
-		parentId: T.parentId,
-		index: E
-	})), O.push(i({
-		from: v,
-		to: D.map((e) => e.id)
-	})), r(p, O, h[_]), {
+	for (let e of v) y.push(n({ node: e }));
+	return y.push(...s(_.map((e) => ({
+		id: e.node.id,
+		slot: e.slot
+	})), g)), y.push(i({
+		from: d,
+		to: v.map((e) => e.id)
+	})), r(a, y, l[o]), {
 		kind: "applied",
-		resultIds: D.map((e) => e.id)
+		resultIds: v.map((e) => e.id)
 	};
 }
 //#endregion
-export { _ as applyBooleanOp };
+export { f as applyBooleanOp, d as previewBooleanOp };
 
 //# sourceMappingURL=booleans.js.map

package/dist/interactions/actions/booleans/booleans.js.map

@@ -1 +1 @@
-{"version":3,"file":"booleans.js","names":["operandPath","path","adapter","id","text","glyphs","textToPath","LABEL","isEmpty","p","applyBooleanOp","sel","zOrder","locateChild","resolved","err","TextOutlinesError","entries","a","b","op","paths","results","pathUnion","pathIntersect","pathExclude","back","front","pathSubtract","pathDivide","pathCrop","topmostId","topAnchor","targetIndex","shift","i","z","newNodes","ops","captured","node","index","createDeleteOp","n","createInsertOp","createMoveToIndexOp","createSetSelectionOp","dispatchApplyBatch"],"sources":["../../../../src/interactions/actions/booleans/booleans.ts"],"sourcesContent":["/**\n * Pure action core for path boolean operations. Resolves the current\n * selection into z-ordered paths, runs the chosen op, and dispatches a\n * single batch of `Op`s (delete sources + insert results + set selection).\n *\n * The hook (`useBooleans`) wraps this with React glue; testing here is\n * trivial because the function takes a plain adapter.\n */\nimport {\n  pathUnion,\n  pathIntersect,\n  pathSubtract,\n  pathExclude,\n  pathDivide,\n  pathCrop,\n} from 'features/paths/booleans';\nimport type { Path, PolygonPath } from '@weasel-js/geom';\nimport { createInsertOp } from 'core/ops/create';\nimport { createDeleteOp } from 'core/ops/delete';\nimport { createMoveToIndexOp } from 'core/ops/reorder';\nimport { createSetSelectionOp } from 'core/ops/select';\nimport { locateChild } from 'core/ops/slot';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport { textToPath, TextOutlinesError, type TextNodeSource } from 'features/text/textToPath';\n\n/** Boolean op identifiers — five Pathfinder primaries plus Crop. */\nexport type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop';\n\n/**\n * z-position descriptor for a path node. `parentId` is the direct parent\n * (or `null` for a top-level node); `index` is the position within that\n * parent's child order — never a global render index.\n */\n/** @internal */\nexport interface BooleanZOrder {\n  parentId: string | null;\n  index: number;\n}\n\n/** Adapter the hook and the pure core both consume. */\nexport interface BooleansAdapter {\n  getSelection(): readonly NodeId[] | readonly string[];\n  getWorldPath(id: NodeId): Path | undefined;\n  /**\n   * Optional: the text node behind `id`, for an id `getWorldPath` has no path\n   * for. Its glyph outlines (`textToPath`) become the operand, so text can be\n   * cut, united or intersected like any shape.\n   */\n  getTextSource?(id: NodeId): TextNodeSource | undefined;\n  compareZ(a: NodeId, b: NodeId): number;\n  /**\n   * Mint a new node from a boolean-op result `Path`. `producedBy` names the\n   * op that synthesized it — adapters that store provenance (e.g. for a\n   * layer-panel icon) record it; others ignore the arg. `sourceId` is the\n   * topmost source, whose slot the result takes: give the node that source's\n   * parent, or the kit's reorder cannot find it there.\n   */\n  createPathNode(path: Path, producedBy: BooleanOp, sourceId: NodeId): { id: string };\n  /**\n   * Optional: return the full object for an id, used by the delete ops so\n   * their `invert` (an insert) can restore the complete object on undo.\n   * If omitted, a `{ id }` stub is captured — undo will reinstate the id\n   * but consumers reading other fields (path, fill, etc.) will see them as\n   * undefined. Mirrors `DeleteAdapter.getNode`; should be provided whenever\n   * undo over boolean ops is expected to be lossless.\n   */\n  getNode?(id: NodeId): { id: string } | undefined | null;\n  /**\n   * Optional: the reorder contract. With `getChildren` (and `getParent`, or\n   * every node reads as top-level) the kit reads each source's slot among its\n   * siblings, and with `setChildOrder` as well it moves the result into the\n   * topmost source's slot. Without them the result lands wherever\n   * `insertNode` defaults to. `defaultCommitAdapter` supplies all three.\n   */\n  getParent?(id: string): string | null;\n  getChildren?(parentId: string | null): readonly string[];\n  setChildOrder?(parentId: string | null, ids: string[]): void;\n  /**\n   * Optional override for the slot the kit otherwise reads through\n   * `getParent` / `getChildren`: `id`'s parent and its index in that\n   * parent's child order.\n   *\n   * @deprecated Supply `getParent` and `getChildren` instead, and the kit\n   * derives this.\n   */\n  getZOrder?(id: NodeId): BooleanZOrder | undefined;\n  applyOps?(ops: Op[], label?: string): void;\n  setSelection?(ids: NodeId[]): void;\n  insertNode?(node: { id: string }): void;\n  removeNode?(id: string): void;\n}\n\n/** Outcome reported back to callers (lets the hook surface no-op signals). */\nexport type BooleanOpResult =\n  | { kind: 'applied'; resultIds: string[] }\n  | { kind: 'noop'; reason: 'no-paths' | 'too-few-for-subtract' | 'empty-result' }\n  /** A text operand had no outline geometry. Nothing was changed: an op that\n   *  quietly dropped the operand would commit a different shape than asked. */\n  | { kind: 'failed'; reason: 'text-outlines'; error: TextOutlinesError };\n\nfunction operandPath(adapter: BooleansAdapter, id: NodeId): Path | undefined {\n  const path = adapter.getWorldPath(id);\n  if (path) return path;\n  const text = adapter.getTextSource?.(id);\n  if (!text) return undefined;\n  // Blank text has no geometry, and is no more an operand than a group is.\n  const glyphs = textToPath(text.data, text.pose);\n  return glyphs.commands.length > 0 ? glyphs : undefined;\n}\n\nconst LABEL: Record<BooleanOp, string> = {\n  union: 'Union',\n  intersect: 'Intersect',\n  subtract: 'Subtract',\n  exclude: 'Exclude',\n  divide: 'Divide',\n  crop: 'Crop',\n};\n\nfunction isEmpty(p: PolygonPath): boolean {\n  return p.commands.length === 0;\n}\n\n/**\n * Run one Boolean operation over the selected paths and commit the result as a\n * single undoable batch.\n *\n * Operands are ordered back-to-front, which is what makes `subtract` mean\n * \"everything in front removed from the backmost shape\". Returns without\n * mutating anything when the selection holds no paths, or too few for the\n * requested operation.\n */\nexport function applyBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n): BooleanOpResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const zOrder = (id: NodeId): BooleanZOrder | undefined =>\n    adapter.getZOrder ? adapter.getZOrder(id) : locateChild(adapter, id) ?? undefined;\n  // Resolve path nodes only, sorted ascending by `compareZ` so paths[0] is\n  // the bottommost (back) member. `subtract` relies on this: it computes\n  // `back − union(rest)`, which is Illustrator's \"Minus Front.\" Keep this\n  // convention in sync if compareZ semantics ever flip.\n  let resolved: { id: NodeId; path: Path | undefined }[];\n  try {\n    resolved = sel.map((id) => ({ id, path: operandPath(adapter, id) }));\n  } catch (err) {\n    if (err instanceof TextOutlinesError) return { kind: 'failed', reason: 'text-outlines', error: err };\n    throw err;\n  }\n  const entries = resolved\n    .filter((e): e is { id: NodeId; path: Path } => e.path != null)\n    .sort((a, b) => adapter.compareZ(a.id, b.id));\n\n  if (entries.length === 0) return { kind: 'noop', reason: 'no-paths' };\n  if (op === 'subtract' && entries.length < 2) {\n    return { kind: 'noop', reason: 'too-few-for-subtract' };\n  }\n  if (entries.length < 2) return { kind: 'noop', reason: 'no-paths' };\n\n  const paths = entries.map((e) => e.path);\n  let results: PolygonPath[];\n\n  switch (op) {\n    case 'union':     results = [pathUnion(...paths)]; break;\n    case 'intersect': results = [pathIntersect(...paths)]; break;\n    case 'exclude':   results = [pathExclude(...paths)]; break;\n    case 'subtract': {\n      // Illustrator \"Minus Front\": back − union(everything in front).\n      const back = paths[0];\n      const front = paths.length === 2 ? paths[1] : pathUnion(...paths.slice(1));\n      results = [pathSubtract(back, front)];\n      break;\n    }\n    case 'divide': {\n      results = pathDivide(...paths);\n      break;\n    }\n    case 'crop': {\n      // Illustrator \"Crop\": clip every source-below-top to the topmost\n      // path; topmost is consumed as the mask. `paths` is back-to-front\n      // ascending, so the topmost source is `paths[paths.length-1]`.\n      results = pathCrop(...paths);\n      break;\n    }\n  }\n\n  results = results.filter((p) => !isEmpty(p));\n  if (results.length === 0) return { kind: 'noop', reason: 'empty-result' };\n\n  // Capture the topmost source's z-slot before we mutate the scene. The\n  // topmost source is the last entry (entries are back-to-front ascending).\n  // We adjust for selected members that sit below the topmost in the same\n  // parent — their deletions collapse the parent's child list before the\n  // reorder runs, so the visual slot the topmost occupied lives at a lower\n  // index after the deletes. Members in a different parent don't affect\n  // this parent's indexing.\n  const topmostId = entries[entries.length - 1].id;\n  const topAnchor = zOrder(topmostId);\n  let targetIndex = topAnchor?.index;\n  if (topAnchor) {\n    let shift = 0;\n    for (let i = 0; i < entries.length - 1; i++) {\n      const z = zOrder(entries[i].id);\n      if (z && z.parentId === topAnchor.parentId && z.index < topAnchor.index) {\n        shift++;\n      }\n    }\n    targetIndex = topAnchor.index - shift;\n  }\n\n  const newNodes = results.map((p) => adapter.createPathNode(p, op, topmostId));\n  const ops: Op[] = [];\n  const captured: { node: { id: string }; index: number }[] = [];\n  for (const e of entries) {\n    // Capture the full node so the delete's `invert()` (an insert) restores\n    // every field on undo. Fallback to a `{ id }` stub matches the legacy\n    // behavior for adapters that haven't opted in yet. Index comes from\n    // the same slot read used for anchoring; -1 when the adapter doesn't\n    // expose order.\n    const node = adapter.getNode?.(e.id) ?? { id: e.id };\n    const index = zOrder(e.id)?.index ?? -1;\n    captured.push({ node, index });\n  }\n  // Order by index DESC so reverse-then-invert (history's undo path)\n  // re-inserts ASC — each splice lands on a correctly-sized array\n  // instead of clamping high indices to a still-growing length.\n  captured.sort((a, b) => b.index - a.index);\n  for (const { node, index } of captured) ops.push(createDeleteOp({ node, index }));\n  for (const n of newNodes) ops.push(createInsertOp({ node: n }));\n  if (topAnchor && targetIndex !== undefined) {\n    // After the deletes, the topmost source's index is no longer occupied;\n    // moving the new nodes to the adjusted index drops them into that slot.\n    // For divide (N outputs), they form a contiguous block in input order\n    // starting at the target index.\n    ops.push(createMoveToIndexOp({\n      ids: newNodes.map((n) => n.id),\n      parentId: topAnchor.parentId,\n      index: targetIndex,\n    }));\n  }\n  ops.push(createSetSelectionOp({\n    from: sel,\n    to: newNodes.map((n) => n.id as NodeId),\n  }));\n  dispatchApplyBatch(adapter, ops, LABEL[op]);\n\n  return { kind: 'applied', resultIds: newNodes.map((n) => n.id) };\n}\n"],"mappings":";;;;;;;;;AAsGA,SAASA,EAAY,GAA0B,GAA8B;CAC3E,IAAMC,IAAOC,EAAQ,aAAaC,CAAE;CACpC,IAAIF,GAAM,OAAOA;CACjB,IAAMG,IAAOF,EAAQ,gBAAgBC,CAAE;CACvC,IAAI,CAACC,GAAM;CAEX,IAAMC,IAASC,EAAWF,EAAK,MAAMA,EAAK,IAAI;CAC9C,OAAOC,EAAO,SAAS,SAAS,IAAIA,IAAS,KAAA;AAC/C;AAEA,IAAME,IAAmC;CACvC,OAAO;CACP,WAAW;CACX,UAAU;CACV,SAAS;CACT,QAAQ;CACR,MAAM;AACR;AAEA,SAASC,EAAQ,GAAyB;CACxC,OAAOC,EAAE,SAAS,WAAW;AAC/B;AAWA,SAAgBC,EACd,GACA,GACiB;CACjB,IAAMC,IAAM,CAAC,GAAGT,EAAQ,aAAa,CAAC,GAChCU,KAAU,MACdV,EAAQ,YAAYA,EAAQ,UAAUC,CAAE,IAAIU,EAAYX,GAASC,CAAE,KAAK,KAAA,GAKtEW;CACJ,IAAI;EACF,IAAWH,EAAI,KAAK,OAAQ;GAAE;GAAI,MAAMX,EAAYE,GAASC,CAAE;EAAE,EAAE;CACrE,SAASY,GAAK;EACZ,IAAIA,aAAeC,GAAmB,OAAO;GAAE,MAAM;GAAU,QAAQ;GAAiB,OAAOD;EAAI;EACnG,MAAMA;CACR;CACA,IAAME,IAAUH,EACb,QAAQ,MAAuC,EAAE,QAAQ,IAAI,CAAC,CAC9D,MAAM,GAAG,MAAMZ,EAAQ,SAASgB,EAAE,IAAIC,EAAE,EAAE,CAAC;CAE9C,IAAIF,EAAQ,WAAW,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAW;CACpE,IAAIG,MAAO,cAAcH,EAAQ,SAAS,GACxC,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAuB;CAExD,IAAIA,EAAQ,SAAS,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAW;CAElE,IAAMI,IAAQJ,EAAQ,KAAK,MAAM,EAAE,IAAI,GACnCK;CAEJ,QAAQF,GAAR;EACE,KAAK;GAAa,IAAU,CAACG,EAAU,GAAGF,CAAK,CAAC;GAAG;EACnD,KAAK;GAAa,IAAU,CAACG,EAAc,GAAGH,CAAK,CAAC;GAAG;EACvD,KAAK;GAAa,IAAU,CAACI,EAAY,GAAGJ,CAAK,CAAC;GAAG;EACrD,KAAK,YAAY;GAEf,IAAMK,IAAOL,EAAM,IACbM,IAAQN,EAAM,WAAW,IAAIA,EAAM,KAAKE,EAAU,GAAGF,EAAM,MAAM,CAAC,CAAC;GACzE,IAAU,CAACO,EAAaF,GAAMC,CAAK,CAAC;GACpC;EACF;EACA,KAAK;GACH,IAAUE,EAAW,GAAGR,CAAK;GAC7B;EAEF,KAAK,QAIH,IAAUS,EAAS,GAAGT,CAAK;CAG/B;CAGA,IADA,IAAUC,EAAQ,QAAQ,MAAM,CAACd,EAAQC,CAAC,CAAC,GACvCa,EAAQ,WAAW,GAAG,OAAO;EAAE,MAAM;EAAQ,QAAQ;CAAe;CASxE,IAAMS,IAAYd,EAAQA,EAAQ,SAAS,EAAE,CAAC,IACxCe,IAAYpB,EAAOmB,CAAS,GAC9BE,IAAcD,GAAW;CAC7B,IAAIA,GAAW;EACb,IAAIE,IAAQ;EACZ,KAAK,IAAIC,IAAI,GAAGA,IAAIlB,EAAQ,SAAS,GAAG,KAAK;GAC3C,IAAMmB,IAAIxB,EAAOK,EAAQkB,EAAE,CAAC,EAAE;GAC9B,AAAIC,KAAKA,EAAE,aAAaJ,EAAU,YAAYI,EAAE,QAAQJ,EAAU,SAChE;EAEJ;EACA,IAAcA,EAAU,QAAQE;CAClC;CAEA,IAAMG,IAAWf,EAAQ,KAAK,MAAMpB,EAAQ,eAAeO,GAAGW,GAAIW,CAAS,CAAC,GACtEO,IAAY,CAAC,GACbC,IAAsD,CAAC;CAC7D,KAAK,IAAM,KAAKtB,GAAS;EAMvB,IAAMuB,IAAOtC,EAAQ,UAAU,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,GAC7CuC,IAAQ7B,EAAO,EAAE,EAAE,CAAC,EAAE,SAAS;EACrC,EAAS,KAAK;GAAE;GAAM;EAAM,CAAC;CAC/B;CAIA,EAAS,MAAM,GAAG,MAAMO,EAAE,QAAQD,EAAE,KAAK;CACzC,KAAK,IAAM,EAAE,SAAM,cAAWqB,GAAU,EAAI,KAAKG,EAAe;EAAE;EAAM;CAAM,CAAC,CAAC;CAChF,KAAK,IAAMC,KAAKN,GAAU,EAAI,KAAKO,EAAe,EAAE,MAAMD,EAAE,CAAC,CAAC;CAkB9D,OAjBIX,KAAaC,MAAgB,KAAA,KAK/BK,EAAI,KAAKO,EAAoB;EAC3B,KAAKR,EAAS,KAAK,MAAMM,EAAE,EAAE;EAC7B,UAAUX,EAAU;EACpB,OAAOC;CACT,CAAC,CAAC,GAEJK,EAAI,KAAKQ,EAAqB;EAC5B,MAAMnC;EACN,IAAI0B,EAAS,KAAK,MAAMM,EAAE,EAAY;CACxC,CAAC,CAAC,GACFI,EAAmB7C,GAASoC,GAAK/B,EAAMa,EAAG,GAEnC;EAAE,MAAM;EAAW,WAAWiB,EAAS,KAAK,MAAMM,EAAE,EAAE;CAAE;AACjE"}
+{"version":3,"file":"booleans.js","names":["LABEL","planBooleanOp","resolved","sel","resolveOperand","adapter","id","opts","err","TextOutlinesError","entries","a","b","op","pieces","booleanPieces","i","paint","operand","previewBooleanOp","plan","piece","applyBooleanOp","zOrder","locateChild","slots","made","newNodes","m","ops","captured","createDeleteOp","n","createInsertOp","placementOps","createSetSelectionOp","dispatchApplyBatch"],"sources":["../../../../src/interactions/actions/booleans/booleans.ts"],"sourcesContent":["/**\n * Pure action core for path boolean operations. Resolves the current\n * selection into z-ordered paths, runs the chosen op, and dispatches a\n * single batch of `Op`s (delete sources + insert results + set selection).\n */\nimport type { Mat3, Path } from '@weasel-js/geom';\nimport { createInsertOp } from 'core/ops/create';\nimport { createDeleteOp } from 'core/ops/delete';\nimport { createSetSelectionOp } from 'core/ops/select';\nimport { locateChild } from 'core/ops/slot';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport { TextOutlinesError, type TextNodeSource } from '@weasel-js/text';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport { resolveOperand, type BooleanOpOptions, type BooleanOperand } from './operands';\nimport { booleanPieces, type ResultPiece } from './pieces';\nimport { placementOps } from './placement';\n\n/** Boolean op identifiers: the five Pathfinder primaries, and Crop, Trim, and Merge. */\nexport type BooleanOp = 'union' | 'intersect' | 'subtract' | 'exclude' | 'divide' | 'crop' | 'trim' | 'merge';\n\n/**\n * z-position descriptor for a path node. `parentId` is the direct parent\n * (or `null` for a top-level node); `index` is the position within that\n * parent's child order — never a global render index.\n */\n/** @internal */\nexport interface BooleanZOrder {\n  parentId: string | null;\n  index: number;\n}\n\n/** Adapter the hook and the pure core both consume. */\nexport interface BooleansAdapter {\n  getSelection(): readonly NodeId[] | readonly string[];\n  getWorldPath(id: NodeId): Path | undefined;\n  /**\n   * Optional: the text node behind `id`, for an id `getWorldPath` has no path\n   * for. Its glyph outlines (`textToPath`) become the operand, so text can be\n   * cut, united or intersected like any shape.\n   */\n  getTextSource?(id: NodeId): TextNodeSource | undefined;\n  /**\n   * Optional: the paint the path node behind `id` wears. An operation told to\n   * count strokes (`BooleanOpOptions.strokes`) reads it to learn whether the\n   * node is stroked and whether it is filled; without it every operand is its\n   * path alone.\n   */\n  getPaint?(id: NodeId): PathPaint | undefined;\n  /**\n   * Optional: the frame the node behind `id` draws its stroke in, as the\n   * matrix taking that frame to world (`poseFrameOf`); null or absent for a\n   * node drawn straight. A counted world-width stroke is skewed and stretched\n   * with it. Without it every stroke is outlined in world.\n   */\n  getStrokeFrame?(id: NodeId): Mat3 | null | undefined;\n  compareZ(a: NodeId, b: NodeId): number;\n  /**\n   * Mint a new node from a boolean-op result `Path`. `producedBy` names the\n   * op that synthesized it — adapters that store provenance (e.g. for a\n   * layer-panel icon) record it; others ignore the arg. `sourceId` is the\n   * source the result stands in for: the topmost, except that each piece of\n   * a Divide, Crop, Trim, or Merge names the topmost source it was cut from. Give the\n   * node that source's parent, or the kit's reorder cannot find it there.\n   * `paint` is passed when that source's stroke went into the geometry, and\n   * the node must wear it as given: wearing the source's stroke again would\n   * draw it twice. Without `paint`, give it that source's paint. The kit never\n   * reads a node's `data`: anything else the result should keep of its source,\n   * a name say, is the adapter's to copy from `sourceId`.\n   */\n  createPathNode(path: Path, producedBy: BooleanOp, sourceId: NodeId, paint?: PathPaint): { id: string };\n  /**\n   * Optional: return the full object for an id, used by the delete ops so\n   * their `invert` (an insert) can restore the complete object on undo.\n   * If omitted, a `{ id }` stub is captured — undo will reinstate the id\n   * but consumers reading other fields (path, fill, etc.) will see them as\n   * undefined.\n   */\n  getNode?(id: NodeId): { id: string } | undefined | null;\n  /**\n   * Optional: the reorder contract. With `getChildren` (and `getParent`, or\n   * every node reads as top-level) the kit reads each source's slot among its\n   * siblings, and with `setChildOrder` as well it moves each result into the\n   * slot of the topmost source in its own source's parent. Without them the result lands wherever\n   * `insertNode` defaults to. `defaultCommitAdapter` supplies all three.\n   */\n  getParent?(id: string): string | null;\n  getChildren?(parentId: string | null): readonly string[];\n  setChildOrder?(parentId: string | null, ids: string[]): void;\n  /**\n   * Optional override for the slot the kit otherwise reads through\n   * `getParent` / `getChildren`: `id`'s parent and its index in that\n   * parent's child order.\n   *\n   * @deprecated Supply `getParent` and `getChildren` instead, and the kit\n   * derives this.\n   */\n  getZOrder?(id: NodeId): BooleanZOrder | undefined;\n  applyOps?(ops: Op[], label?: string): void;\n  setSelection?(ids: NodeId[]): void;\n  insertNode?(node: { id: string }): void;\n  removeNode?(id: string): void;\n}\n\n/** Outcome reported back to callers (lets the hook surface no-op signals). */\nexport type BooleanOpResult =\n  | { kind: 'applied'; resultIds: string[] }\n  | { kind: 'noop'; reason: 'no-paths' | 'too-few-for-subtract' | 'empty-result' }\n  /** A text operand had no outline geometry. Nothing was changed: an op that\n   *  quietly dropped the operand would commit a different shape than asked. */\n  | { kind: 'failed'; reason: 'text-outlines'; error: TextOutlinesError };\n\nconst LABEL: Record<BooleanOp, string> = {\n  union: 'Union',\n  intersect: 'Intersect',\n  subtract: 'Subtract',\n  exclude: 'Exclude',\n  divide: 'Divide',\n  crop: 'Crop',\n  trim: 'Trim',\n  merge: 'Merge',\n};\n\n/** One path a Boolean operation would make. */\nexport interface BooleanPreviewPiece {\n  path: Path;\n  /** The source the piece stands in for; see `BooleansAdapter.createPathNode`. */\n  sourceId: NodeId;\n  /** Set when that source's stroke went into `path`: the paint the piece wears. */\n  paint?: PathPaint;\n}\n\n/** What {@link previewBooleanOp} answers: the pieces, or why there are none. */\nexport type BooleanOpPreview =\n  | { kind: 'pieces'; pieces: BooleanPreviewPiece[] }\n  | Exclude<BooleanOpResult, { kind: 'applied' }>;\n\ntype Entry = { id: NodeId; operand: BooleanOperand };\n\n/** The operands back to front and the pieces `op` makes of them, or the\n *  result that says why it makes none. Reads the adapter and changes nothing. */\nfunction planBooleanOp(\n  adapter: BooleansAdapter,\n  sel: readonly NodeId[],\n  op: BooleanOp,\n  opts: BooleanOpOptions,\n): { entries: Entry[]; pieces: ResultPiece[] } | Exclude<BooleanOpResult, { kind: 'applied' }> {\n  // Sorted ascending by `compareZ` so the first entry is the bottommost\n  // (back) member. `subtract` relies on this: it computes `back − union(rest)`.\n  let resolved: { id: NodeId; operand: BooleanOperand | undefined }[];\n  try {\n    resolved = sel.map((id) => ({ id, operand: resolveOperand(adapter, id, opts) }));\n  } catch (err) {\n    if (err instanceof TextOutlinesError) return { kind: 'failed', reason: 'text-outlines', error: err };\n    throw err;\n  }\n  const entries = resolved\n    .filter((e): e is Entry => e.operand != null)\n    .sort((a, b) => adapter.compareZ(a.id, b.id));\n\n  if (entries.length === 0) return { kind: 'noop', reason: 'no-paths' };\n  if (op === 'subtract' && entries.length < 2) {\n    return { kind: 'noop', reason: 'too-few-for-subtract' };\n  }\n  if (entries.length < 2) return { kind: 'noop', reason: 'no-paths' };\n\n  // Merge unites the operands that wear one fill; one whose paint is unknown is united with nothing.\n  const fillKey = (i: number): unknown => {\n    const { id, operand } = entries[i]!;\n    const paint = operand.paint ?? adapter.getPaint?.(id);\n    return paint ? JSON.stringify(paint.fill ?? null) : i;\n  };\n  const pieces = booleanPieces(op, entries.map((e) => e.operand.path), fillKey);\n  if (pieces.length === 0) return { kind: 'noop', reason: 'empty-result' };\n  return { entries, pieces };\n}\n\n/**\n * What {@link applyBooleanOp} would make of the selection, without minting a\n * node or committing anything: for drawing an operation before it is applied.\n */\nexport function previewBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n  opts: BooleanOpOptions = {},\n): BooleanOpPreview {\n  const plan = planBooleanOp(adapter, [...adapter.getSelection()] as NodeId[], op, opts);\n  if ('kind' in plan) return plan;\n  return {\n    kind: 'pieces',\n    pieces: plan.pieces.map((piece) => {\n      const { id, operand } = plan.entries[piece.source]!;\n      return operand.paint ? { path: piece.path, sourceId: id, paint: operand.paint } : { path: piece.path, sourceId: id };\n    }),\n  };\n}\n\n/**\n * Run one Boolean operation over the selected paths and commit the result as a\n * single undoable batch.\n *\n * Operands are ordered back-to-front, which is what makes `subtract` mean\n * \"everything in front removed from the backmost shape\". Returns without\n * mutating anything when the selection holds no paths, or too few for the\n * requested operation. `opts.strokes` says what a stroked operand gives.\n */\nexport function applyBooleanOp(\n  adapter: BooleansAdapter,\n  op: BooleanOp,\n  opts: BooleanOpOptions = {},\n): BooleanOpResult {\n  const sel = [...adapter.getSelection()] as NodeId[];\n  const plan = planBooleanOp(adapter, sel, op, opts);\n  if ('kind' in plan) return plan;\n  const { entries, pieces } = plan;\n  const zOrder = (id: NodeId): BooleanZOrder | undefined =>\n    adapter.getZOrder ? adapter.getZOrder(id) : locateChild(adapter, id) ?? undefined;\n\n  // Every source's slot, read before the scene is mutated.\n  const slots = entries.map((e) => zOrder(e.id));\n  // A piece stands in for its own source: it is minted from that source, wears\n  // the paint a stroke folded into that source left it, and takes its slot.\n  const made = pieces.map((piece) => {\n    const { id, operand } = entries[piece.source]!;\n    return { node: adapter.createPathNode(piece.path, op, id, operand.paint), slot: slots[piece.source] };\n  });\n  const newNodes = made.map((m) => m.node);\n  const ops: Op[] = [];\n  // Capture the full node so the delete's `invert()` (an insert) restores\n  // every field on undo; a `{ id }` stub for an adapter with no `getNode`.\n  // The index is -1 when the adapter exposes no order.\n  const captured = entries.map((e, i) => ({\n    node: adapter.getNode?.(e.id) ?? { id: e.id },\n    index: slots[i]?.index ?? -1,\n  }));\n  // Order by index DESC so reverse-then-invert (history's undo path)\n  // re-inserts ASC — each splice lands on a correctly-sized array\n  // instead of clamping high indices to a still-growing length.\n  captured.sort((a, b) => b.index - a.index);\n  for (const { node, index } of captured) ops.push(createDeleteOp({ node, index }));\n  for (const n of newNodes) ops.push(createInsertOp({ node: n }));\n  ops.push(...placementOps(made.map((m) => ({ id: m.node.id, slot: m.slot })), slots));\n  ops.push(createSetSelectionOp({\n    from: sel,\n    to: newNodes.map((n) => n.id as NodeId),\n  }));\n  dispatchApplyBatch(adapter, ops, LABEL[op]);\n\n  return { kind: 'applied', resultIds: newNodes.map((n) => n.id) };\n}\n"],"mappings":"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"}

package/dist/interactions/actions/booleans/operands.js

@@ -0,0 +1,40 @@
+import { strokeRegion as e } from "../outlines/strokeRegion.js";
+import { textToPath as t, textToPathsByPaint as n } from "@weasel-js/text";
+import { pathUnion as r } from "@weasel-js/geom/booleans";
+//#region src/interactions/actions/booleans/operands.ts
+function i(t, n, i, a) {
+	let { path: o, fill: s } = t, { stroke: c } = t, l = c?.paint;
+	if (!c || l == null || n === "ignore" || n === "unfilled" && s !== null) return { path: o };
+	let u = e(o, c, i, a === void 0 ? {} : { scale: a });
+	return u.commands.length === 0 ? { path: o } : {
+		path: s === null ? u : r(o, u),
+		paint: { fill: s ?? { paint: l } }
+	};
+}
+function a(e, a, { strokes: o = "ignore", scale: s }) {
+	let c = e.getWorldPath(a);
+	if (c) {
+		let t = o === "ignore" ? void 0 : e.getPaint?.(a);
+		return t ? i({
+			path: c,
+			...t
+		}, o, e.getStrokeFrame?.(a), s) : { path: c };
+	}
+	let l = e.getTextSource?.(a);
+	if (!l) return;
+	if (o === "ignore") {
+		let e = t(l.data, l.pose);
+		return e.commands.length > 0 ? { path: e } : void 0;
+	}
+	let u = n(l.data, l.pose).map((t) => i(t, o, e.getStrokeFrame?.(a), s));
+	if (u.length === 0) return;
+	let d = u.find((e) => e.paint)?.paint, f = u.length === 1 ? u[0].path : r(...u.map((e) => e.path));
+	return d ? {
+		path: f,
+		paint: d
+	} : { path: f };
+}
+//#endregion
+export { a as resolveOperand };
+
+//# sourceMappingURL=operands.js.map

package/dist/interactions/actions/booleans/operands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operands.js","names":["inkOf","source","strokePaint","stroke","strokes","fill","ribbon","strokeRegion","path","frame","scale","pathUnion","resolveOperand","adapter","id","paint","text","glyphs","textToPath","inks","textToPathsByPaint","p","ink","whole"],"sources":["../../../../src/interactions/actions/booleans/operands.ts"],"sourcesContent":["/**\n * What each selected node gives a Boolean operation: its path, its glyph\n * outlines, or the region its ink covers once a stroke is counted.\n */\nimport type { Mat3, Path, Scale2 } from '@weasel-js/geom';\nimport { pathUnion } from '@weasel-js/geom/booleans';\nimport { textToPath, textToPathsByPaint } from '@weasel-js/text';\nimport type { PathPaint } from 'canvas/nodeShapes/nodePaint';\nimport type { NodeId } from 'core/scene/types';\nimport type { PaintedPath } from '../outlines/replaceWithPaths';\nimport { strokeRegion } from '../outlines/strokeRegion';\nimport type { BooleansAdapter } from './booleans';\n\n/**\n * What a stroked operand gives a Boolean operation.\n *\n * - `'ignore'`: its path, as though it had no stroke.\n * - `'unfilled'`: the region its stroke covers when it has no fill, as a line\n *   or an open pencil stroke has none; its path when it is filled.\n * - `'include'`: what it paints — its fill and its stroke together, or the\n *   stroke alone when it has no fill.\n *\n * Any mode but `'ignore'` needs {@link BooleansAdapter.getPaint}.\n */\nexport type BooleanStrokes = 'ignore' | 'unfilled' | 'include';\n\n/** Options for `applyBooleanOp`. */\nexport interface BooleanOpOptions {\n  /** Default `'ignore'`. */\n  strokes?: BooleanStrokes;\n  /** The view scale a `{ px }` stroke width resolves against: one number, or\n   *  the view's own scale per axis. Default 1. */\n  scale?: number | Scale2;\n}\n\n/** @internal */\nexport interface BooleanOperand {\n  path: Path;\n  /** Set when a stroke went into `path`: what a result standing in for this\n   *  operand wears, the stroke being part of its shape now. */\n  paint?: PathPaint;\n}\n\nfunction inkOf(\n  source: PaintedPath,\n  strokes: BooleanStrokes,\n  frame: Mat3 | null | undefined,\n  scale: number | Scale2 | undefined,\n): BooleanOperand {\n  const { path, fill } = source;\n  const { stroke } = source;\n  const strokePaint = stroke?.paint;\n  if (!stroke || strokePaint == null) return { path };\n  if (strokes === 'ignore' || (strokes === 'unfilled' && fill !== null)) return { path };\n  const ribbon = strokeRegion(path, stroke, frame, scale === undefined ? {} : { scale });\n  if (ribbon.commands.length === 0) return { path };\n  return { path: fill !== null ? pathUnion(path, ribbon) : ribbon, paint: { fill: fill ?? { paint: strokePaint } } };\n}\n\n/**\n * The operand behind `id`, or `undefined` for a node that is not one: a group,\n * blank text, anything the adapter has neither a path nor text for. Throws\n * `TextOutlinesError` for text whose face has no outlines.\n */\nexport function resolveOperand(\n  adapter: BooleansAdapter,\n  id: NodeId,\n  { strokes = 'ignore', scale }: BooleanOpOptions,\n): BooleanOperand | undefined {\n  const path = adapter.getWorldPath(id);\n  if (path) {\n    const paint = strokes === 'ignore' ? undefined : adapter.getPaint?.(id);\n    return paint ? inkOf({ path, ...paint }, strokes, adapter.getStrokeFrame?.(id), scale) : { path };\n  }\n  const text = adapter.getTextSource?.(id);\n  if (!text) return undefined;\n  if (strokes === 'ignore') {\n    const glyphs = textToPath(text.data, text.pose);\n    return glyphs.commands.length > 0 ? { path: glyphs } : undefined;\n  }\n  const inks = textToPathsByPaint(text.data, text.pose).map((p) => inkOf(p, strokes, adapter.getStrokeFrame?.(id), scale));\n  if (inks.length === 0) return undefined;\n  const paint = inks.find((ink) => ink.paint)?.paint;\n  const whole = inks.length === 1 ? inks[0]!.path : pathUnion(...inks.map((ink) => ink.path));\n  return paint ? { path: whole, paint } : { path: whole };\n}\n"],"mappings":";;;;AA2CA,SAASA,EACP,GACA,GACA,GACA,GACgB;CAChB,IAAM,EAAE,SAAM,YAASC,GACjB,EAAE,cAAWA,GACbC,IAAcC,GAAQ;CAE5B,IADI,CAACA,KAAUD,KAAe,QAC1BE,MAAY,YAAaA,MAAY,cAAcC,MAAS,MAAO,OAAO,EAAE,QAAK;CACrF,IAAMC,IAASC,EAAaC,GAAML,GAAQM,GAAOC,MAAU,KAAA,IAAY,CAAC,IAAI,EAAE,SAAM,CAAC;CAErF,OADIJ,EAAO,SAAS,WAAW,IAAU,EAAE,QAAK,IACzC;EAAE,MAAMD,MAAS,OAAiCC,IAA1BK,EAAUH,GAAMF,CAAM;EAAY,OAAO,EAAE,MAAMD,KAAQ,EAAE,OAAOH,EAAY,EAAE;CAAE;AACnH;AAOA,SAAgBU,EACd,GACA,GACA,EAAE,aAAU,UAAU,YACM;CAC5B,IAAMJ,IAAOK,EAAQ,aAAaC,CAAE;CACpC,IAAIN,GAAM;EACR,IAAMO,IAAQX,MAAY,WAAW,KAAA,IAAYS,EAAQ,WAAWC,CAAE;EACtE,OAAOC,IAAQf,EAAM;GAAE;GAAM,GAAGe;EAAM,GAAGX,GAASS,EAAQ,iBAAiBC,CAAE,GAAGJ,CAAK,IAAI,EAAE,QAAK;CAClG;CACA,IAAMM,IAAOH,EAAQ,gBAAgBC,CAAE;CACvC,IAAI,CAACE,GAAM;CACX,IAAIZ,MAAY,UAAU;EACxB,IAAMa,IAASC,EAAWF,EAAK,MAAMA,EAAK,IAAI;EAC9C,OAAOC,EAAO,SAAS,SAAS,IAAI,EAAE,MAAMA,EAAO,IAAI,KAAA;CACzD;CACA,IAAME,IAAOC,EAAmBJ,EAAK,MAAMA,EAAK,IAAI,CAAC,CAAC,KAAK,MAAMhB,EAAMqB,GAAGjB,GAASS,EAAQ,iBAAiBC,CAAE,GAAGJ,CAAK,CAAC;CACvH,IAAIS,EAAK,WAAW,GAAG;CACvB,IAAMJ,IAAQI,EAAK,MAAM,MAAQG,EAAI,KAAK,CAAC,EAAE,OACvCC,IAAQJ,EAAK,WAAW,IAAIA,EAAK,EAAE,CAAE,OAAOR,EAAU,GAAGQ,EAAK,KAAK,MAAQG,EAAI,IAAI,CAAC;CAC1F,OAAOP,IAAQ;EAAE,MAAMQ;EAAO;CAAM,IAAI,EAAE,MAAMA,EAAM;AACxD"}

package/dist/interactions/actions/booleans/pieces.js

@@ -0,0 +1,45 @@
+import { pathCropPieces as e, pathDividePieces as t, pathExclude as n, pathIntersect as r, pathMerge as i, pathSubtract as a, pathTrim as o, pathUnion as s } from "@weasel-js/geom/booleans";
+//#region src/interactions/actions/booleans/pieces.ts
+function c(e) {
+	return e.map((e) => ({
+		path: e.path,
+		source: e.sources[e.sources.length - 1]
+	}));
+}
+function l(l, u, d) {
+	let f = u.length - 1, p = (e) => [{
+		path: e,
+		source: f
+	}], m;
+	switch (l) {
+		case "union":
+			m = p(s(...u));
+			break;
+		case "intersect":
+			m = p(r(...u));
+			break;
+		case "exclude":
+			m = p(n(...u));
+			break;
+		case "subtract": {
+			let e = u.length === 2 ? u[1] : s(...u.slice(1));
+			m = p(a(u[0], e));
+			break;
+		}
+		case "divide":
+			m = c(t(...u));
+			break;
+		case "crop":
+			m = c(e(...u));
+			break;
+		case "trim":
+			m = c(o(...u));
+			break;
+		case "merge": m = c(i(u, d));
+	}
+	return m.filter((e) => e.path.commands.length > 0);
+}
+//#endregion
+export { l as booleanPieces };
+
+//# sourceMappingURL=pieces.js.map

package/dist/interactions/actions/booleans/pieces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pieces.js","names":["bySource","pieces","p","booleanPieces","top","paths","whole","op","pathUnion","pathIntersect","pathExclude","front","pathSubtract","pathDividePieces","pathCropPieces","pathTrim","pathMerge","mergeKey"],"sources":["../../../../src/interactions/actions/booleans/pieces.ts"],"sourcesContent":["import {\n  pathUnion,\n  pathIntersect,\n  pathSubtract,\n  pathExclude,\n  pathDividePieces,\n  pathCropPieces,\n  pathTrim,\n  pathMerge,\n  type BooleanPiece,\n} from '@weasel-js/geom/booleans';\nimport type { Path, PolygonPath } from '@weasel-js/geom';\nimport type { BooleanOp } from './booleans';\n\n/** One result path, and the operand it stands in for: an index into the\n *  operands, back to front. */\nexport interface ResultPiece {\n  path: PolygonPath;\n  source: number;\n}\n\n/** A piece stands in for the topmost input left in it. */\nfunction bySource(pieces: BooleanPiece[]): ResultPiece[] {\n  return pieces.map((p) => ({ path: p.path, source: p.sources[p.sources.length - 1]! }));\n}\n\n/** Run `op` over `paths`, back to front, dropping empty results. `mergeKey`\n *  answers alike for the paths a Merge unites. */\nexport function booleanPieces(op: BooleanOp, paths: Path[], mergeKey: (index: number) => unknown): ResultPiece[] {\n  const top = paths.length - 1;\n  const whole = (path: PolygonPath): ResultPiece[] => [{ path, source: top }];\n  let pieces: ResultPiece[];\n  switch (op) {\n    case 'union':     pieces = whole(pathUnion(...paths)); break;\n    case 'intersect': pieces = whole(pathIntersect(...paths)); break;\n    case 'exclude':   pieces = whole(pathExclude(...paths)); break;\n    case 'subtract': {\n      // Illustrator \"Minus Front\": back − union(everything in front).\n      const front = paths.length === 2 ? paths[1]! : pathUnion(...paths.slice(1));\n      pieces = whole(pathSubtract(paths[0]!, front));\n      break;\n    }\n    case 'divide':    pieces = bySource(pathDividePieces(...paths)); break;\n    // Illustrator \"Crop\": every source below the topmost, clipped to it; the\n    // topmost is consumed as the mask.\n    case 'crop':      pieces = bySource(pathCropPieces(...paths)); break;\n    case 'trim':      pieces = bySource(pathTrim(...paths)); break;\n    case 'merge':     pieces = bySource(pathMerge(paths, mergeKey)); break;\n  }\n  return pieces.filter((p) => p.path.commands.length > 0);\n}\n"],"mappings":";;AAsBA,SAASA,EAAS,GAAuC;CACvD,OAAOC,EAAO,KAAK,OAAO;EAAE,MAAMC,EAAE;EAAM,QAAQA,EAAE,QAAQA,EAAE,QAAQ,SAAS;CAAI,EAAE;AACvF;AAIA,SAAgBC,EAAc,GAAe,GAAe,GAAqD;CAC/G,IAAMC,IAAMC,EAAM,SAAS,GACrBC,KAAS,MAAqC,CAAC;EAAE;EAAM,QAAQF;CAAI,CAAC,GACtEH;CACJ,QAAQM,GAAR;EACE,KAAK;GAAa,IAASD,EAAME,EAAU,GAAGH,CAAK,CAAC;GAAG;EACvD,KAAK;GAAa,IAASC,EAAMG,EAAc,GAAGJ,CAAK,CAAC;GAAG;EAC3D,KAAK;GAAa,IAASC,EAAMI,EAAY,GAAGL,CAAK,CAAC;GAAG;EACzD,KAAK,YAAY;GAEf,IAAMM,IAAQN,EAAM,WAAW,IAAIA,EAAM,KAAMG,EAAU,GAAGH,EAAM,MAAM,CAAC,CAAC;GAC1E,IAASC,EAAMM,EAAaP,EAAM,IAAKM,CAAK,CAAC;GAC7C;EACF;EACA,KAAK;GAAa,IAASX,EAASa,EAAiB,GAAGR,CAAK,CAAC;GAAG;EAGjE,KAAK;GAAa,IAASL,EAASc,EAAe,GAAGT,CAAK,CAAC;GAAG;EAC/D,KAAK;GAAa,IAASL,EAASe,EAAS,GAAGV,CAAK,CAAC;GAAG;EACzD,KAAK,SAAa,IAASL,EAASgB,EAAUX,GAAOY,CAAQ,CAAC;CAChE;CACA,OAAOhB,EAAO,QAAQ,MAAMC,EAAE,KAAK,SAAS,SAAS,CAAC;AACxD"}

package/dist/interactions/actions/booleans/placement.js

@@ -0,0 +1,24 @@
+import { createMoveToIndexOp as e } from "../../../core/ops/reorder/index.js";
+//#region src/interactions/actions/booleans/placement.ts
+function t(t, n) {
+	let r = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		if (!e.slot) continue;
+		let t = r.get(e.slot.parentId);
+		t ? t.push(e.id) : r.set(e.slot.parentId, [e.id]);
+	}
+	let i = [];
+	for (let [t, a] of r) {
+		let r = n.flatMap((e) => e && e.parentId === t ? [e.index] : []), o = Math.max(...r);
+		i.push(e({
+			ids: a,
+			parentId: t,
+			index: o - (r.length - 1)
+		}));
+	}
+	return i;
+}
+//#endregion
+export { t as placementOps };
+
+//# sourceMappingURL=placement.js.map

package/dist/interactions/actions/booleans/placement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"placement.js","names":["placementOps","groups","r","results","group","ops","parentId","ids","indices","sourceSlots","s","top","createMoveToIndexOp"],"sources":["../../../../src/interactions/actions/booleans/placement.ts"],"sourcesContent":["import { createMoveToIndexOp } from 'core/ops/reorder';\nimport type { Op } from 'core/ops/types';\nimport type { BooleanZOrder } from './booleans';\n\n/**\n * The ops that put each result where its source was. Results are grouped by\n * their source's parent, and each group lands as one block, in result order,\n * in the slot of the topmost source in that parent.\n *\n * `sourceSlots` holds every source's slot, read before anything is deleted.\n * The sources below a slot in the same parent are deleted before the reorder\n * runs, so the block goes that many places lower. A result whose source has\n * no slot is left wherever the insert put it.\n */\nexport function placementOps(\n  results: readonly { id: string; slot: BooleanZOrder | undefined }[],\n  sourceSlots: readonly (BooleanZOrder | undefined)[],\n): Op[] {\n  const groups = new Map<string | null, string[]>();\n  for (const r of results) {\n    if (!r.slot) continue;\n    const group = groups.get(r.slot.parentId);\n    if (group) group.push(r.id);\n    else groups.set(r.slot.parentId, [r.id]);\n  }\n  const ops: Op[] = [];\n  for (const [parentId, ids] of groups) {\n    const indices = sourceSlots.flatMap((s) => (s && s.parentId === parentId ? [s.index] : []));\n    const top = Math.max(...indices);\n    ops.push(createMoveToIndexOp({ ids, parentId, index: top - (indices.length - 1) }));\n  }\n  return ops;\n}\n"],"mappings":";;AAcA,SAAgBA,EACd,GACA,GACM;CACN,IAAMC,oBAAS,IAAI,IAA6B;CAChD,KAAK,IAAMC,KAAKC,GAAS;EACvB,IAAI,CAACD,EAAE,MAAM;EACb,IAAME,IAAQH,EAAO,IAAIC,EAAE,KAAK,QAAQ;EACxC,AAAIE,IAAOA,EAAM,KAAKF,EAAE,EAAE,IACrBD,EAAO,IAAIC,EAAE,KAAK,UAAU,CAACA,EAAE,EAAE,CAAC;CACzC;CACA,IAAMG,IAAY,CAAC;CACnB,KAAK,IAAM,CAACC,GAAUC,MAAQN,GAAQ;EACpC,IAAMO,IAAUC,EAAY,SAAS,MAAOC,KAAKA,EAAE,aAAaJ,IAAW,CAACI,EAAE,KAAK,IAAI,CAAC,CAAE,GACpFC,IAAM,KAAK,IAAI,GAAGH,CAAO;EAC/B,EAAI,KAAKI,EAAoB;GAAE;GAAK;GAAU,OAAOD,KAAOH,EAAQ,SAAS;EAAG,CAAC,CAAC;CACpF;CACA,OAAOH;AACT"}

package/dist/interactions/actions/booleans/useBooleans.js

@@ -2,16 +2,18 @@ import { applyBooleanOp as e } from "./booleans.js";
 import { useCallback as t } from "react";
 import { useLatest as n } from "@weasel-js/react";
 function r(r, i = {}) {
-	let a = n(r), o = t((t) => {
-		e(a.current, t);
-	}, [a]);
+	let a = n(r), o = n(i), s = t((t) => {
+		e(a.current, t, o.current);
+	}, [a, o]);
 	return {
-		union: t(() => o("union"), [o]),
-		intersect: t(() => o("intersect"), [o]),
-		subtract: t(() => o("subtract"), [o]),
-		exclude: t(() => o("exclude"), [o]),
-		divide: t(() => o("divide"), [o]),
-		crop: t(() => o("crop"), [o])
+		union: t(() => s("union"), [s]),
+		intersect: t(() => s("intersect"), [s]),
+		subtract: t(() => s("subtract"), [s]),
+		exclude: t(() => s("exclude"), [s]),
+		divide: t(() => s("divide"), [s]),
+		crop: t(() => s("crop"), [s]),
+		trim: t(() => s("trim"), [s]),
+		merge: t(() => s("merge"), [s])
 	};
 }
 //#endregion

package/dist/interactions/actions/booleans/useBooleans.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBooleans.js","names":["useBooleans","adapterRef","useLatest","adapter","run","useCallback","op"],"sources":["../../../../src/interactions/actions/booleans/useBooleans.ts"],"sourcesContent":["/**\n * `useBooleans` — selection-driven Boolean ops on path layers.\n *\n * Returns six imperative callables (`union` / `intersect` / `subtract` /\n * `exclude` / `divide` / `crop`). Each reads the current selection,\n * performs the op in world space, and dispatches a single batch through\n * the adapter's `applyOps` (one undo step).\n *\n * Adapter shape: see `BooleansAdapter` in `./booleans.ts`. Consumers\n * supply how to read selection, fetch the world-space `Path` for an id,\n * compare ids by stacking order, and mint a node from a result `Path`.\n *\n * No-ops are silent in production; in dev, `subtract` with < 2 selected\n * paths emits a `console.warn`.\n */\nimport { useCallback } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { applyBooleanOp, type BooleansAdapter, type BooleanOp } from './booleans';\n\n/** The six Boolean path operations, each acting on the current selection and\n *  committing as one undo step. */\nexport interface UseBooleansReturn {\n  union(): void;\n  intersect(): void;\n  subtract(): void;\n  exclude(): void;\n  divide(): void;\n  crop(): void;\n}\n\n/** Options for `useBooleans`. */\nexport interface UseBooleansOptions {\n  /** No-op. Retained for source-compatibility; auto-registration is now\n   *  handled by `useStandardActions` via the Pathfinder descriptors. */\n  enableActions?: boolean;\n}\n\nconst isDev = typeof import.meta !== 'undefined'\n  && (import.meta as { env?: { DEV?: boolean } }).env?.DEV;\n\n/** Bind the Boolean path operations to an adapter that knows how to read the\n *  selection, fetch world-space paths and mint result nodes. */\nexport function useBooleans(\n  adapter: BooleansAdapter,\n  _options: UseBooleansOptions = {},\n): UseBooleansReturn {\n  const adapterRef = useLatest(adapter);\n\n  const run = useCallback((op: BooleanOp) => {\n    const result = applyBooleanOp(adapterRef.current, op);\n    if (isDev && result.kind === 'noop' && result.reason === 'too-few-for-subtract') {\n      console.warn('[useBooleans] subtract requires at least 2 selected paths');\n    }\n  }, [adapterRef]);\n\n  return {\n    union: useCallback(() => run('union'), [run]),\n    intersect: useCallback(() => run('intersect'), [run]),\n    subtract: useCallback(() => run('subtract'), [run]),\n    exclude: useCallback(() => run('exclude'), [run]),\n    divide: useCallback(() => run('divide'), [run]),\n    crop: useCallback(() => run('crop'), [run]),\n  };\n}\n"],"mappings":";;;AA0CA,SAAgBA,EACd,GACA,IAA+B,CAAC,GACb;CACnB,IAAMC,IAAaC,EAAUC,CAAO,GAE9BC,IAAMC,GAAa,MAAkB;EAC1B,EAAeJ,EAAW,SAASK,CAAE;CAItD,GAAG,CAACL,CAAU,CAAC;CAEf,OAAO;EACL,OAAOI,QAAkBD,EAAI,OAAO,GAAG,CAACA,CAAG,CAAC;EAC5C,WAAWC,QAAkBD,EAAI,WAAW,GAAG,CAACA,CAAG,CAAC;EACpD,UAAUC,QAAkBD,EAAI,UAAU,GAAG,CAACA,CAAG,CAAC;EAClD,SAASC,QAAkBD,EAAI,SAAS,GAAG,CAACA,CAAG,CAAC;EAChD,QAAQC,QAAkBD,EAAI,QAAQ,GAAG,CAACA,CAAG,CAAC;EAC9C,MAAMC,QAAkBD,EAAI,MAAM,GAAG,CAACA,CAAG,CAAC;CAC5C;AACF"}
+{"version":3,"file":"useBooleans.js","names":["useBooleans","adapterRef","useLatest","adapter","optionsRef","options","run","useCallback","op"],"sources":["../../../../src/interactions/actions/booleans/useBooleans.ts"],"sourcesContent":["/**\n * `useBooleans` — selection-driven Boolean ops on path layers. No-ops are\n * silent in production; in dev, `subtract` with < 2 selected paths emits a\n * `console.warn`.\n */\nimport { useCallback } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { applyBooleanOp, type BooleansAdapter, type BooleanOp } from './booleans';\nimport type { BooleanOpOptions } from './operands';\n\n/** The Boolean path operations, each acting on the current selection and\n *  committing as one undo step. */\nexport interface UseBooleansReturn {\n  union(): void;\n  intersect(): void;\n  subtract(): void;\n  exclude(): void;\n  divide(): void;\n  crop(): void;\n  trim(): void;\n  merge(): void;\n}\n\n/** Options for `useBooleans`. */\nexport interface UseBooleansOptions extends BooleanOpOptions {\n  /** No-op. Retained for source-compatibility; `useStandardActions`\n   *  registers the actions. */\n  enableActions?: boolean;\n}\n\nconst isDev = typeof import.meta !== 'undefined'\n  && (import.meta as { env?: { DEV?: boolean } }).env?.DEV;\n\n/** Bind the Boolean path operations to an adapter that knows how to read the\n *  selection, fetch world-space paths and mint result nodes. */\nexport function useBooleans(\n  adapter: BooleansAdapter,\n  options: UseBooleansOptions = {},\n): UseBooleansReturn {\n  const adapterRef = useLatest(adapter);\n  const optionsRef = useLatest(options);\n\n  const run = useCallback((op: BooleanOp) => {\n    const result = applyBooleanOp(adapterRef.current, op, optionsRef.current);\n    if (isDev && result.kind === 'noop' && result.reason === 'too-few-for-subtract') {\n      console.warn('[useBooleans] subtract requires at least 2 selected paths');\n    }\n  }, [adapterRef, optionsRef]);\n\n  return {\n    union: useCallback(() => run('union'), [run]),\n    intersect: useCallback(() => run('intersect'), [run]),\n    subtract: useCallback(() => run('subtract'), [run]),\n    exclude: useCallback(() => run('exclude'), [run]),\n    divide: useCallback(() => run('divide'), [run]),\n    crop: useCallback(() => run('crop'), [run]),\n    trim: useCallback(() => run('trim'), [run]),\n    merge: useCallback(() => run('merge'), [run]),\n  };\n}\n"],"mappings":";;;AAmCA,SAAgBA,EACd,GACA,IAA8B,CAAC,GACZ;CACnB,IAAMC,IAAaC,EAAUC,CAAO,GAC9BC,IAAaF,EAAUG,CAAO,GAE9BC,IAAMC,GAAa,MAAkB;EAC1B,EAAeN,EAAW,SAASO,GAAIJ,EAAW,OAAO;CAI1E,GAAG,CAACH,GAAYG,CAAU,CAAC;CAE3B,OAAO;EACL,OAAOG,QAAkBD,EAAI,OAAO,GAAG,CAACA,CAAG,CAAC;EAC5C,WAAWC,QAAkBD,EAAI,WAAW,GAAG,CAACA,CAAG,CAAC;EACpD,UAAUC,QAAkBD,EAAI,UAAU,GAAG,CAACA,CAAG,CAAC;EAClD,SAASC,QAAkBD,EAAI,SAAS,GAAG,CAACA,CAAG,CAAC;EAChD,QAAQC,QAAkBD,EAAI,QAAQ,GAAG,CAACA,CAAG,CAAC;EAC9C,MAAMC,QAAkBD,EAAI,MAAM,GAAG,CAACA,CAAG,CAAC;EAC1C,MAAMC,QAAkBD,EAAI,MAAM,GAAG,CAACA,CAAG,CAAC;EAC1C,OAAOC,QAAkBD,EAAI,OAAO,GAAG,CAACA,CAAG,CAAC;CAC9C;AACF"}

package/dist/interactions/actions/booleans/useBooleansAdapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBooleansAdapter.js","names":["useBooleansAdapter","adapter"],"sources":["../../../../src/interactions/actions/booleans/useBooleansAdapter.ts"],"sourcesContent":["/**\n * `useBooleansAdapter` — publishes a `BooleansAdapter` to the surrounding\n * `<DepRegistryProvider>` (typically inside `<SceneCanvas>`).\n *\n * The Pathfinder action descriptors (`pathfinderUnionAction`, etc., registered\n * by `useStandardActions`) read this dep both in their `enabled` predicate\n * (via `deps.booleansAdapter` — actually they read selection; the adapter is\n * read by the invoker) and in their immediate invoker. Consumers construct an\n * adapter that bridges to their scene's data shape and call this hook to make\n * the kit's Pathfinder strip operational.\n *\n * No-op when no `<DepRegistryProvider>` is in scope — mirrors the silent-\n * no-op contract of `useDepSource`.\n */\nimport { useDepSource } from '@weasel-js/routing/react';\nimport type { BooleansAdapter } from './booleans';\n\n/** Publish a Boolean-ops adapter so the built-in Pathfinder actions can run.\n *  Silently does nothing outside a `<DepRegistryProvider>`. */\nexport function useBooleansAdapter(adapter: BooleansAdapter): void {\n  useDepSource('booleansAdapter', () => adapter);\n}\n"],"mappings":";;AAmBA,SAAgBA,EAAmB,GAAgC;CACjE,EAAa,yBAAyBC,CAAO;AAC/C"}
+{"version":3,"file":"useBooleansAdapter.js","names":["useBooleansAdapter","adapter"],"sources":["../../../../src/interactions/actions/booleans/useBooleansAdapter.ts"],"sourcesContent":["import { useDepSource } from '@weasel-js/routing/react';\nimport type { BooleansAdapter } from './booleans';\n\n/** Publish a Boolean-ops adapter so the built-in Pathfinder actions can run.\n *  Silently does nothing outside a `<DepRegistryProvider>`. */\nexport function useBooleansAdapter(adapter: BooleansAdapter): void {\n  useDepSource('booleansAdapter', () => adapter);\n}\n"],"mappings":";;AAKA,SAAgBA,EAAmB,GAAgC;CACjE,EAAa,yBAAyBC,CAAO;AAC/C"}

package/dist/interactions/actions/{defaults/clipboard.js → clipboard/action.js}

@@ -1,14 +1,16 @@
 import { defaultCommitAdapter as e } from "../defaultCommitAdapter.js";
-import { CopyIcon as t, CutIcon as n, PasteIcon as r } from "./icons/editIcons.js";
-import { requiresSelection as i } from "./requiresSelection.js";
-import { buildDeleteOps as a } from "./delete.js";
-import { createElement as o } from "react";
-import { ActionDisabledReason as s } from "@weasel-js/routing";
-//#region src/interactions/actions/defaults/clipboard.ts
-var c = {
+import { CopyIcon as t, CutIcon as n, PasteIcon as r } from "../defaults/icons/editIcons.js";
+import { requiresSelection as i } from "../defaults/requiresSelection.js";
+import { buildDeleteOps as a } from "../defaults/delete.js";
+import { kitWeaselJsonHandler as o } from "../../../features/ingestion/weaselJsonHandler.js";
+import { ANY_INGEST_MODS as s, INGEST_REQUIRES as c, claimable as l, ingestFromEvent as u } from "../defaults/ingest.js";
+import { createElement as d } from "react";
+import { ActionDisabledReason as f } from "@weasel-js/routing";
+//#region src/interactions/actions/clipboard/action.ts
+var p = {
 	id: "clipboard.copy",
 	label: "Copy",
-	icon: o(t),
+	icon: d(t),
 	group: "clipboard",
 	defaultBinding: {
 		kind: "key",
@@ -24,10 +26,10 @@ var c = {
 		}
 	},
 	enabled: i
-}, l = {
+}, m = {
 	id: "clipboard.cut",
 	label: "Cut",
-	icon: o(n),
+	icon: d(n),
 	group: "clipboard",
 	defaultBinding: {
 		kind: "key",
@@ -54,10 +56,10 @@ var c = {
 		}
 	},
 	enabled: i
-}, u = {
+}, h = {
 	id: "clipboard.paste",
 	label: "Paste",
-	icon: o(r),
+	icon: d(r),
 	group: "clipboard",
 	eligible: { capability: "edits-page" },
 	requires: ["clipboard"],
@@ -69,10 +71,24 @@ var c = {
 	},
 	enabled: (e) => {
 		let t = e?.clipboard;
-		return t && !t.isEmpty() ? !0 : s.NotApplicable;
+		return t && !t.isEmpty() ? !0 : f.NotApplicable;
 	}
+}, g = [o], _ = {
+	id: "clipboard.pasteEvent",
+	label: "Paste copied nodes",
+	defaultBinding: {
+		kind: "paste",
+		types: ["text/plain"],
+		mods: s
+	},
+	requires: [...c],
+	invoker: {
+		timing: "immediate",
+		run: (e, t) => u(e, t, { handlers: g })
+	},
+	enabled: (e, t, n) => l(n, g)
 };
 //#endregion
-export { c as clipboardCopyAction, l as clipboardCutAction, u as clipboardPasteAction };
+export { p as clipboardCopyAction, m as clipboardCutAction, h as clipboardPasteAction, _ as clipboardPasteEventAction };
 
-//# sourceMappingURL=clipboard.js.map
+//# sourceMappingURL=action.js.map

package/dist/interactions/actions/clipboard/action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.js","names":["clipboardCopyAction","createElement","CopyIcon","requiresSelection","clipboardCutAction","CutIcon","clipboard","deps","selection","scene","applyOps","ids","ops","buildDeleteOps","defaultCommitAdapter","clipboardPasteAction","PasteIcon","ActionDisabledReason","PASTE_EVENT_HANDLERS","kitWeaselJsonHandler","clipboardPasteEventAction","ANY_INGEST_MODS","INGEST_REQUIRES","ingestFromEvent","params","claimable","carried"],"sources":["../../../../src/interactions/actions/clipboard/action.ts"],"sourcesContent":["import { createElement } from 'react';\nimport { CopyIcon, CutIcon, PasteIcon } from '../defaults/icons/editIcons';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { ActionDisabledReason, type Action } from '@weasel-js/routing';\nimport { buildDeleteOps } from '../defaults/delete';\nimport { requiresSelection } from '../defaults/requiresSelection';\nimport { kitWeaselJsonHandler } from 'features/ingestion/weaselJsonHandler';\nimport { ANY_INGEST_MODS, claimable, INGEST_REQUIRES, ingestFromEvent } from '../defaults/ingest';\n\n/**\n * @experimental\n * Static descriptor for the `clipboard.copy` Action (Cmd/Ctrl+C).\n */\nexport const clipboardCopyAction: Action & { requires: string[] } = {\n  id: 'clipboard.copy',\n  label: 'Copy',\n  icon: createElement(CopyIcon),\n  group: 'clipboard',\n  defaultBinding: { kind: 'key', key: 'c', mods: { mod: true } },\n  // Same gate as `duplicate`: a mode that can neither edit the page nor own a\n  // selection has nothing to copy. Notably excludes `text-edit`, where Cmd+C\n  // must stay the browser's own copy of the caret range.\n  eligible: { capability: ['edits-page', 'creates-selection'] },\n  // `selection` is read by the `enabled` gate, not the invoker — the\n  // dispatcher builds deps for both, and an undeclared read is undefined.\n  requires: ['clipboard', 'selection'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      deps.clipboard?.copy();\n    },\n  },\n  enabled: requiresSelection,\n};\n\n/**\n * @experimental\n * Static descriptor for the `clipboard.cut` Action (Cmd/Ctrl+X) — copy, then\n * the same batched delete `deleteAction` performs, as one undo entry.\n */\nexport const clipboardCutAction: Action & { requires: string[] } = {\n  id: 'clipboard.cut',\n  label: 'Cut',\n  icon: createElement(CutIcon),\n  group: 'clipboard',\n  defaultBinding: { kind: 'key', key: 'x', mods: { mod: true } },\n  eligible: { capability: 'edits-page' },\n  requires: ['clipboard', 'scene', 'selection', 'applyOps'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const clipboard = deps.clipboard;\n      const selection = deps.selection;\n      const scene = deps.scene;\n      const applyOps = deps.applyOps;\n      if (!clipboard || !selection || !scene) return;\n      const ids = selection.get();\n      if (ids.length === 0) return;\n\n      // Snapshot before removal — `snapshotSelection` reads live nodes.\n      clipboard.copy();\n\n      const ops = buildDeleteOps(scene, ids, 'Cut');\n      if (ops.length > 0) {\n        if (applyOps) applyOps(ops, 'Cut');\n        else scene.applyBatch(ops, 'Cut', defaultCommitAdapter(scene, selection.adapterMethods));\n      }\n      selection.set([]);\n    },\n  },\n  enabled: requiresSelection,\n};\n\n/**\n * @experimental\n * Static descriptor for the `clipboard.paste` Action — what a Paste button or\n * menu item triggers, pasting the last copy this canvas made. It has no key\n * binding: Cmd/Ctrl+V already arrives as a DOM `paste` event, which the\n * dispatcher routes to `clipboard.pasteEvent` or `ingest`, and a binding here\n * would fire alongside it and paste twice.\n */\nexport const clipboardPasteAction: Action & { requires: string[] } = {\n  id: 'clipboard.paste',\n  label: 'Paste',\n  icon: createElement(PasteIcon),\n  group: 'clipboard',\n  eligible: { capability: 'edits-page' },\n  requires: ['clipboard'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      deps.clipboard?.paste();\n    },\n  },\n  enabled: (deps) => {\n    const clipboard = deps?.clipboard;\n    return clipboard && !clipboard.isEmpty() ? true : ActionDisabledReason.NotApplicable;\n  },\n};\n\nconst PASTE_EVENT_HANDLERS = [kitWeaselJsonHandler];\n\n/**\n * @experimental\n * Static descriptor for the `clipboard.pasteEvent` Action — Cmd/Ctrl+V on a\n * canvas that edits and does not ingest. It answers the DOM `paste` event by\n * pasting nodes a kit canvas copied to the OS clipboard, in this tab or\n * another, and nothing else: an image, SVG, or file on the clipboard, and\n * every consumer content handler, need `ingest`. `ingest` binds the same\n * event and takes this payload among the rest, so `useStandardActions`\n * leaves this one unregistered wherever `ingest` is registered.\n *\n * Bound to `text/plain` because that is the only flavor of a copy a paste\n * event carries; a paste without text stays the page's.\n */\nexport const clipboardPasteEventAction: Action & { requires: string[] } = {\n  id: 'clipboard.pasteEvent',\n  label: 'Paste copied nodes',\n  defaultBinding: { kind: 'paste', types: ['text/plain'], mods: ANY_INGEST_MODS },\n  requires: [...INGEST_REQUIRES],\n  invoker: {\n    timing: 'immediate',\n    run: (deps, params) => ingestFromEvent(deps, params, { handlers: PASTE_EVENT_HANDLERS }),\n  },\n  enabled: (_deps, _at, carried) => claimable(carried, PASTE_EVENT_HANDLERS),\n};\n"],"mappings":";;;;;;;;;AAaA,IAAaA,IAAuD;CAClE,IAAI;CACJ,OAAO;CACP,MAAMC,EAAcC,CAAQ;CAC5B,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;EAAK,MAAM,EAAE,KAAK,GAAK;CAAE;CAI7D,UAAU,EAAE,YAAY,CAAC,cAAc,mBAAmB,EAAE;CAG5D,UAAU,CAAC,aAAa,WAAW;CACnC,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,EAAK,WAAW,KAAK;EACvB;CACF;CACA,SAASC;AACX,GAOaC,IAAsD;CACjE,IAAI;CACJ,OAAO;CACP,MAAMH,EAAcI,CAAO;CAC3B,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;EAAK,MAAM,EAAE,KAAK,GAAK;CAAE;CAC7D,UAAU,EAAE,YAAY,aAAa;CACrC,UAAU;EAAC;EAAa;EAAS;EAAa;CAAU;CACxD,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,IAAMC,IAAYC,EAAK,WACjBC,IAAYD,EAAK,WACjBE,IAAQF,EAAK,OACbG,IAAWH,EAAK;GACtB,IAAI,CAACD,KAAa,CAACE,KAAa,CAACC,GAAO;GACxC,IAAME,IAAMH,EAAU,IAAI;GAC1B,IAAIG,EAAI,WAAW,GAAG;GAGtB,EAAU,KAAK;GAEf,IAAMC,IAAMC,EAAeJ,GAAOE,GAAK,KAAK;GAK5C,AAJIC,EAAI,SAAS,MACXF,IAAUA,EAASE,GAAK,KAAK,IAC5BH,EAAM,WAAWG,GAAK,OAAOE,EAAqBL,GAAOD,EAAU,cAAc,CAAC,IAEzFA,EAAU,IAAI,CAAC,CAAC;EAClB;CACF;CACA,SAASL;AACX,GAUaY,IAAwD;CACnE,IAAI;CACJ,OAAO;CACP,MAAMd,EAAce,CAAS;CAC7B,OAAO;CACP,UAAU,EAAE,YAAY,aAAa;CACrC,UAAU,CAAC,WAAW;CACtB,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,EAAK,WAAW,MAAM;EACxB;CACF;CACA,UAAU,MAAS;EACjB,IAAMV,IAAYC,GAAM;EACxB,OAAOD,KAAa,CAACA,EAAU,QAAQ,IAAI,KAAOW,EAAqB;CACzE;AACF,GAEMC,IAAuB,CAACC,CAAoB,GAerCC,IAA6D;CACxE,IAAI;CACJ,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAS,OAAO,CAAC,YAAY;EAAG,MAAMC;CAAgB;CAC9E,UAAU,CAAC,GAAGC,CAAe;CAC7B,SAAS;EACP,QAAQ;EACR,MAAM,GAAM,MAAWC,EAAgBhB,GAAMiB,GAAQ,EAAE,UAAUN,EAAqB,CAAC;CACzF;CACA,UAAU,GAAO,GAAK,MAAYO,EAAUC,GAASR,CAAoB;AAC3E"}