@weasel-js/core 1.9.4 → 1.10.1

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":"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"}
+{"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","slots","locateChild","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 { Affine, 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): Affine | 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   * The full object for an id. The delete ops capture it, so their `invert`\n   * (an insert) restores the complete object on undo.\n   */\n  getNode(id: NodeId): { id: string } | undefined | null;\n  /**\n   * The tree. The kit reads each source's slot among its siblings through\n   * `getParent` and `getChildren`, and moves each result into the slot of\n   * the topmost source in its own source's parent through `setChildOrder`.\n   * `defaultCommitAdapter` supplies all three, and `getNode`.\n   */\n  getParent(id: string): string | null;\n  getChildren(parentId: string | null): string[];\n  setChildOrder(parentId: string | null, ids: string[]): void;\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  // Every source's slot, read before the scene is mutated.\n  const slots: (BooleanZOrder | undefined)[] =\n    entries.map((e) => locateChild(adapter, e.id) ?? undefined);\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. The index is -1 for a source its parent does not list.\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 { Affine, 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: Affine | 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,16 +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 { 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, ingestFromEvent as l } from "./ingest.js";
-import { createElement as u } from "react";
-import { ActionDisabledReason as d } from "@weasel-js/routing";
-//#region src/interactions/actions/defaults/clipboard.ts
-var f = {
+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: u(t),
+	icon: d(t),
 	group: "clipboard",
 	defaultBinding: {
 		kind: "key",
@@ -26,10 +26,10 @@ var f = {
 		}
 	},
 	enabled: i
-}, p = {
+}, m = {
 	id: "clipboard.cut",
 	label: "Cut",
-	icon: u(n),
+	icon: d(n),
 	group: "clipboard",
 	defaultBinding: {
 		kind: "key",
@@ -56,10 +56,10 @@ var f = {
 		}
 	},
 	enabled: i
-}, m = {
+}, h = {
 	id: "clipboard.paste",
 	label: "Paste",
-	icon: u(r),
+	icon: d(r),
 	group: "clipboard",
 	eligible: { capability: "edits-page" },
 	requires: ["clipboard"],
@@ -71,9 +71,9 @@ var f = {
 	},
 	enabled: (e) => {
 		let t = e?.clipboard;
-		return t && !t.isEmpty() ? !0 : d.NotApplicable;
+		return t && !t.isEmpty() ? !0 : f.NotApplicable;
 	}
-}, h = [o], g = {
+}, g = [o], _ = {
 	id: "clipboard.pasteEvent",
 	label: "Paste copied nodes",
 	defaultBinding: {
@@ -84,11 +84,11 @@ var f = {
 	requires: [...c],
 	invoker: {
 		timing: "immediate",
-		run: (e, t) => l(e, t, { handlers: h })
+		run: (e, t) => u(e, t, { handlers: g })
 	},
-	enabled: () => !0
+	enabled: (e, t, n) => l(n, g)
 };
 //#endregion
-export { f as clipboardCopyAction, p as clipboardCutAction, m as clipboardPasteAction, g as clipboardPasteEventAction };
+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"}

package/dist/interactions/actions/clipboard/clipboardOps.js

@@ -1,14 +1,14 @@
 import { dwarn as e } from "../../../debug/flag.js";
-import { usePointerContext as t } from "../../../features/pointer/PointerContext.js";
-import { dispatchApplyBatch as n } from "../../../core/applyOps.js";
-import { materializePaste as r } from "./materializePaste.js";
-import { WEASEL_CLIPBOARD_MIME as i, buildWeaselClipboardText as a } from "./wireFormat.js";
-import { useCallback as o, useRef as s } from "react";
-import { useLatest as c } from "@weasel-js/react";
+import { dispatchApplyBatch as t } from "../../../core/applyOps.js";
+import { materializePaste as n } from "./materializePaste.js";
+import { WEASEL_CLIPBOARD_MIME as r, buildWeaselClipboardText as i } from "./wireFormat.js";
+import { useCallback as a, useRef as o } from "react";
+import { useLatest as s } from "@weasel-js/react";
+import { usePointerContext as c } from "@weasel-js/routing/react";
 //#region src/interactions/actions/clipboard/clipboardOps.ts
 var l = { items: [] };
-function u(i, a) {
-	let { getSelection: u, onPaste: f, onPasteOmitted: m, pasteLabel: h = "Paste", getDropPoint: g, produceFlavors: _, jsonReplacer: v } = a, y = t(), b = g ?? y?.getDropPoint, x = s(l), S = c(i), C = c({
+function u(r, i) {
+	let { getSelection: u, onPaste: f, onPasteOmitted: m, pasteLabel: h = "Paste", getDropPoint: g, produceFlavors: _, jsonReplacer: v } = i, y = c(), b = g ?? y?.getDropPoint, x = o(l), S = s(r), C = s({
 		getSelection: u,
 		onPaste: f,
 		onPasteOmitted: m,
@@ -18,7 +18,7 @@ function u(i, a) {
 		jsonReplacer: v
 	});
 	return {
-		copy: o(() => {
+		copy: a(() => {
 			let t = C.current.getSelection();
 			if (t.length === 0) return;
 			let n = S.current.snapshotSelection;
@@ -32,23 +32,23 @@ function u(i, a) {
 			}
 			r && p(r);
 		}, [S, C]),
-		paste: o(() => {
+		paste: a(() => {
 			let e = x.current;
 			if (e.items.length === 0) return;
-			let t = S.current, i = r(t, e, {
+			let r = S.current, i = n(r, e, {
 				currentSelection: C.current.getSelection(),
 				dropPoint: C.current.getDropPoint?.(),
 				onOmitted: C.current.onPasteOmitted
 			});
-			i && (n(t, i.ops, C.current.pasteLabel), x.current = { items: i.created }, C.current.onPaste?.(i.newIds));
+			i && (t(r, i.ops, C.current.pasteLabel), x.current = { items: i.created }, C.current.onPaste?.(i.newIds));
 		}, [S, C]),
-		isEmpty: o(() => x.current.items.length === 0, [])
+		isEmpty: a(() => x.current.items.length === 0, [])
 	};
 }
 function d(e, t) {
-	let n = a(e.items, t);
+	let n = i(e.items, t);
 	return {
-		[i]: n,
+		[r]: n,
 		"text/plain": n
 	};
 }

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

@@ -1 +1 @@
-{"version":3,"file":"clipboardOps.js","names":["EMPTY","useClipboardOps","options","pointerCtx","usePointerContext","effectiveGetDropPoint","getDropPoint","clipboardRef","useRef","adapterRef","useLatest","adapter","optsRef","useCallback","ids","snap","flavors","defaultFlavors","err","writeOsClipboard","cb","a","result","materializePaste","dispatchApplyBatch","text","buildWeaselClipboardText","snapshot","replacer","WEASEL_CLIPBOARD_MIME","WELL_KNOWN_CLIPBOARD_MIMES","entries","rejected","mime","wireMime","toItem","fs","wire","blob","t","promised","writeLive","live","next","standard","dwarn"],"sources":["../../../../src/interactions/actions/clipboard/clipboardOps.ts"],"sourcesContent":["import { useCallback, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport type { InsertAdapter, PasteOmission } from 'core/adapters/types';\nimport type { ClipboardSnapshot } from './types';\nimport { usePointerContext } from 'features/pointer/PointerContext';\nimport { dwarn } from 'debug/flag';\nimport { materializePaste } from './materializePaste';\nimport { WEASEL_CLIPBOARD_MIME, buildWeaselClipboardText } from './wireFormat';\n\ntype Replacer = (key: string, value: unknown) => unknown;\n\n/** Options for `useClipboardOps`. */\nexport interface UseClipboardOpsOptions {\n  /** How the hook reads \"current selection\" for copy. The kit doesn't assume\n   *  a global selection store; each consumer wires this. */\n  getSelection: () => NodeId[];\n  /** Called after a successful paste with the ids of the newly inserted objects. */\n  onPaste?: (newIds: NodeId[]) => void;\n  /** Called when a paste left copied nodes out, with each one and the reason\n   *  — an edge whose endpoints were not copied with it, say. Also called for\n   *  a paste that made nothing. */\n  onPasteOmitted?: (omitted: PasteOmission[]) => void;\n  /** Label for the history entry produced by paste. Default 'Paste'. */\n  pasteLabel?: string;\n  /** Pulled once per paste() call. When non-null, threaded to commitPaste\n   *  as `ctx.dropPoint`; adapters typically use it as the cluster origin\n   *  (ignoring `offset`). When null/undefined, the hook falls back to the\n   *  existing cascade-offset behavior. */\n  getDropPoint?: () => { worldX: number; worldY: number } | null;\n  /** Produce the OS-clipboard flavor map for a copied snapshot. Keys are MIME\n   *  types, values the serialized payload. The kit default emits\n   *  `application/x-weasel-clipboard+json` plus `text/plain` carrying the\n   *  same JSON. Apps override to add richer flavors (e.g. real SVG) or to\n   *  replace the text flavor. Return an empty object to skip the OS write\n   *  entirely. A value may be a promise — an SVG flavor waiting on\n   *  `warmSvg`, say: the write is still issued inside the copy gesture and\n   *  the clipboard takes the text when it resolves. The producer itself runs\n   *  synchronously, so it reads the selection as it stood at the copy. */\n  produceFlavors?: (snapshot: ClipboardSnapshot) => ClipboardFlavors;\n  /** Replacer for the kit-default JSON flavor (typed arrays etc.). Ignored\n   *  when `produceFlavors` is supplied. */\n  jsonReplacer?: Replacer;\n}\n\n/** MIME type to payload, as `produceFlavors` returns it. */\nexport type ClipboardFlavors = Record<string, string | Promise<string>>;\n\n/** Return shape of `useClipboardOps`: imperative `copy`, `paste`, and `isEmpty` functions. */\nexport interface UseClipboardOpsReturn {\n  copy(): void;\n  paste(): void;\n  isEmpty(): boolean;\n}\n\nconst EMPTY: ClipboardSnapshot = { items: [] };\n\n/** In-memory copy/paste of selections via `InsertAdapter.snapshotSelection` / `commitPaste`. */\nexport function useClipboardOps<TNode extends { id: string }>(\n  adapter: InsertAdapter<TNode>,\n  options: UseClipboardOpsOptions,\n): UseClipboardOpsReturn {\n  const {\n    getSelection, onPaste, onPasteOmitted, pasteLabel = 'Paste', getDropPoint, produceFlavors, jsonReplacer,\n  } = options;\n  // Fall back to the ambient pointer context (auto-published by SceneCanvas)\n  // when the caller didn't supply an explicit `getDropPoint`. Null context\n  // (no provider in scope) and no caller-supplied thunk together mean\n  // \"no drop point\" — paste uses the cascade offset instead.\n  const pointerCtx = usePointerContext();\n  const effectiveGetDropPoint = getDropPoint ?? pointerCtx?.getDropPoint;\n  const clipboardRef = useRef<ClipboardSnapshot>(EMPTY);\n  // Keep callbacks stable across renders.\n  const adapterRef = useLatest(adapter);\n  const optsRef = useLatest({\n    getSelection, onPaste, onPasteOmitted, pasteLabel, getDropPoint: effectiveGetDropPoint, produceFlavors,\n    jsonReplacer,\n  });\n\n  const copy = useCallback(() => {\n    const ids = optsRef.current.getSelection();\n    if (ids.length === 0) return;\n    const snap = adapterRef.current.snapshotSelection;\n    if (!snap) return;\n    clipboardRef.current = snap(ids);\n    // Best-effort OS write. Never blocks or throws — the in-memory ref is\n    // already set, and OS clipboard support varies (custom formats are\n    // Chromium-only via the \"web \" prefix; jsdom/non-secure contexts have\n    // no API at all). The flavor producer itself is untrusted consumer code\n    // (`produceFlavors`), so guard its call too — a throwing producer must\n    // not break `copy()`, it just skips the OS write.\n    let flavors: ClipboardFlavors | null = null;\n    try {\n      flavors = optsRef.current.produceFlavors?.(clipboardRef.current)\n        ?? defaultFlavors(clipboardRef.current, optsRef.current.jsonReplacer);\n    } catch (err) {\n      dwarn('clipboard', `flavor producer threw — skipping OS write: ${String(err)}`);\n    }\n    if (flavors) void writeOsClipboard(flavors);\n  }, [adapterRef, optsRef]);\n\n  const paste = useCallback(() => {\n    const cb = clipboardRef.current;\n    if (cb.items.length === 0) return;\n    const a = adapterRef.current;\n    const result = materializePaste(a, cb, {\n      currentSelection: optsRef.current.getSelection(),\n      dropPoint: optsRef.current.getDropPoint?.(),\n      onOmitted: optsRef.current.onPasteOmitted,\n    });\n    if (!result) return;\n    dispatchApplyBatch(a, result.ops, optsRef.current.pasteLabel);\n    // Use the just-created objects as the next cascade source. Re-snapshotting\n    // via `adapter.snapshotSelection(newIds)` would read adapter state, but\n    // React-state adapters haven't flushed yet — `itemsRef.current` still\n    // points at the pre-insert array, so the snapshot would come back empty\n    // and the next paste would no-op.\n    clipboardRef.current = { items: result.created };\n    optsRef.current.onPaste?.(result.newIds as NodeId[]);\n  }, [adapterRef, optsRef]);\n\n  const isEmpty = useCallback(() => clipboardRef.current.items.length === 0, []);\n\n  return { copy, paste, isEmpty };\n}\n\nfunction defaultFlavors(snapshot: ClipboardSnapshot, replacer?: Replacer): ClipboardFlavors {\n  const text = buildWeaselClipboardText(snapshot.items, replacer);\n  return { [WEASEL_CLIPBOARD_MIME]: text, 'text/plain': text };\n}\n\n/** MIME types the async Clipboard API accepts unprefixed. Every other type\n *  (including our own custom MIME, and app-supplied flavors like\n *  `image/svg+xml`) must carry Chromium's `web ` prefix or `ClipboardItem`'s\n *  constructor throws. */\nconst WELL_KNOWN_CLIPBOARD_MIMES = new Set(['text/plain', 'text/html', 'image/png']);\n\n/** Degradation ladder: full map (every non-well-known MIME web-prefixed) →\n *  the same minus any promised flavor that rejected → well-known-only → give\n *  up with a dwarn. Chromium writes nothing when one flavor rejects, so a\n *  rejection costs only that flavor, never the clipboard's previous content\n *  half-overwritten.\n *  @internal test seam — exported so unit tests can await the fire-and-forget\n *  write directly; tests should still exercise this at least once through\n *  the public `copy()` (see clipboardOps.test.tsx). */\nexport async function writeOsClipboard(flavors: ClipboardFlavors): Promise<void> {\n  const entries = Object.entries(flavors);\n  if (entries.length === 0) return;\n  const cb = typeof navigator !== 'undefined' ? navigator.clipboard : undefined;\n  if (!cb?.write || typeof ClipboardItem === 'undefined') return;\n  const rejected = new Set<string>();\n  for (const [mime, text] of entries) {\n    if (typeof text !== 'string') text.catch(() => { rejected.add(mime); });\n  }\n  const wireMime = (mime: string) => (WELL_KNOWN_CLIPBOARD_MIMES.has(mime) ? mime : `web ${mime}`);\n  const toItem = (fs: Flavor[]) => new ClipboardItem(Object.fromEntries(\n    fs.map(([mime, text]) => {\n      const wire = wireMime(mime);\n      const blob = (t: string) => new Blob([t], { type: wire });\n      if (typeof text === 'string') return [wire, blob(text)];\n      const promised = text.then(blob);\n      // Chromium leaves a ClipboardItem's rejected promise unhandled.\n      promised.catch(() => {});\n      return [wire, promised];\n    }),\n  ));\n  // Writes `fs`, dropping flavors whose promise rejected and retrying the\n  // rest. Returns the last error, or null once a write lands.\n  const writeLive = async (fs: Flavor[]): Promise<unknown> => {\n    let live = fs;\n    for (;;) {\n      try {\n        await cb.write([toItem(live)]);\n        return null;\n      } catch (err) {\n        const next = live.filter(([mime]) => !rejected.has(mime));\n        if (next.length === live.length || next.length === 0) return err;\n        live = next;\n      }\n    }\n  };\n  if (await writeLive(entries) === null) return;\n  const standard = entries.filter(([mime]) => WELL_KNOWN_CLIPBOARD_MIMES.has(mime) && !rejected.has(mime));\n  if (standard.length === 0) { dwarn('clipboard', 'OS write failed; no standard flavors to fall back to'); return; }\n  const err = await writeLive(standard);\n  if (err !== null) dwarn('clipboard', `OS clipboard write failed twice — copy stays in-memory only: ${String(err)}`);\n}\n\ntype Flavor = [mime: string, text: string | Promise<string>];\n"],"mappings":"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"}
+{"version":3,"file":"clipboardOps.js","names":["EMPTY","useClipboardOps","options","pointerCtx","usePointerContext","effectiveGetDropPoint","getDropPoint","clipboardRef","useRef","adapterRef","useLatest","adapter","optsRef","useCallback","ids","snap","flavors","defaultFlavors","err","writeOsClipboard","cb","a","result","materializePaste","dispatchApplyBatch","text","buildWeaselClipboardText","snapshot","replacer","WEASEL_CLIPBOARD_MIME","WELL_KNOWN_CLIPBOARD_MIMES","entries","rejected","mime","wireMime","toItem","fs","wire","blob","t","promised","writeLive","live","next","standard","dwarn"],"sources":["../../../../src/interactions/actions/clipboard/clipboardOps.ts"],"sourcesContent":["import { useCallback, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport type { InsertAdapter, PasteOmission } from 'core/adapters/types';\nimport type { ClipboardSnapshot } from './types';\nimport { usePointerContext } from '@weasel-js/routing/react';\nimport { dwarn } from 'debug/flag';\nimport { materializePaste } from './materializePaste';\nimport { WEASEL_CLIPBOARD_MIME, buildWeaselClipboardText } from './wireFormat';\n\ntype Replacer = (key: string, value: unknown) => unknown;\n\n/** Options for `useClipboardOps`. */\nexport interface UseClipboardOpsOptions {\n  /** How the hook reads \"current selection\" for copy. The kit doesn't assume\n   *  a global selection store; each consumer wires this. */\n  getSelection: () => NodeId[];\n  /** Called after a successful paste with the ids of the newly inserted objects. */\n  onPaste?: (newIds: NodeId[]) => void;\n  /** Called when a paste left copied nodes out, with each one and the reason\n   *  — an edge whose endpoints were not copied with it, say. Also called for\n   *  a paste that made nothing. */\n  onPasteOmitted?: (omitted: PasteOmission[]) => void;\n  /** Label for the history entry produced by paste. Default 'Paste'. */\n  pasteLabel?: string;\n  /** Pulled once per paste() call. When non-null, threaded to commitPaste\n   *  as `ctx.dropPoint`; adapters typically use it as the cluster origin\n   *  (ignoring `offset`). When null/undefined, the hook falls back to the\n   *  existing cascade-offset behavior. */\n  getDropPoint?: () => { worldX: number; worldY: number } | null;\n  /** Produce the OS-clipboard flavor map for a copied snapshot. Keys are MIME\n   *  types, values the serialized payload. The kit default emits\n   *  `application/x-weasel-clipboard+json` plus `text/plain` carrying the\n   *  same JSON. Apps override to add richer flavors (e.g. real SVG) or to\n   *  replace the text flavor. Return an empty object to skip the OS write\n   *  entirely. A value may be a promise — an SVG flavor waiting on\n   *  `warmSvg`, say: the write is still issued inside the copy gesture and\n   *  the clipboard takes the text when it resolves. The producer itself runs\n   *  synchronously, so it reads the selection as it stood at the copy. */\n  produceFlavors?: (snapshot: ClipboardSnapshot) => ClipboardFlavors;\n  /** Replacer for the kit-default JSON flavor (typed arrays etc.). Ignored\n   *  when `produceFlavors` is supplied. */\n  jsonReplacer?: Replacer;\n}\n\n/** MIME type to payload, as `produceFlavors` returns it. */\nexport type ClipboardFlavors = Record<string, string | Promise<string>>;\n\n/** Return shape of `useClipboardOps`: imperative `copy`, `paste`, and `isEmpty` functions. */\nexport interface UseClipboardOpsReturn {\n  copy(): void;\n  paste(): void;\n  isEmpty(): boolean;\n}\n\nconst EMPTY: ClipboardSnapshot = { items: [] };\n\n/** In-memory copy/paste of selections via `InsertAdapter.snapshotSelection` / `commitPaste`. */\nexport function useClipboardOps<TNode extends { id: string }>(\n  adapter: InsertAdapter<TNode>,\n  options: UseClipboardOpsOptions,\n): UseClipboardOpsReturn {\n  const {\n    getSelection, onPaste, onPasteOmitted, pasteLabel = 'Paste', getDropPoint, produceFlavors, jsonReplacer,\n  } = options;\n  // Fall back to the ambient pointer context (auto-published by SceneCanvas)\n  // when the caller didn't supply an explicit `getDropPoint`. Null context\n  // (no provider in scope) and no caller-supplied thunk together mean\n  // \"no drop point\" — paste uses the cascade offset instead.\n  const pointerCtx = usePointerContext();\n  const effectiveGetDropPoint = getDropPoint ?? pointerCtx?.getDropPoint;\n  const clipboardRef = useRef<ClipboardSnapshot>(EMPTY);\n  // Keep callbacks stable across renders.\n  const adapterRef = useLatest(adapter);\n  const optsRef = useLatest({\n    getSelection, onPaste, onPasteOmitted, pasteLabel, getDropPoint: effectiveGetDropPoint, produceFlavors,\n    jsonReplacer,\n  });\n\n  const copy = useCallback(() => {\n    const ids = optsRef.current.getSelection();\n    if (ids.length === 0) return;\n    const snap = adapterRef.current.snapshotSelection;\n    if (!snap) return;\n    clipboardRef.current = snap(ids);\n    // Best-effort OS write. Never blocks or throws — the in-memory ref is\n    // already set, and OS clipboard support varies (custom formats are\n    // Chromium-only via the \"web \" prefix; jsdom/non-secure contexts have\n    // no API at all). The flavor producer itself is untrusted consumer code\n    // (`produceFlavors`), so guard its call too — a throwing producer must\n    // not break `copy()`, it just skips the OS write.\n    let flavors: ClipboardFlavors | null = null;\n    try {\n      flavors = optsRef.current.produceFlavors?.(clipboardRef.current)\n        ?? defaultFlavors(clipboardRef.current, optsRef.current.jsonReplacer);\n    } catch (err) {\n      dwarn('clipboard', `flavor producer threw — skipping OS write: ${String(err)}`);\n    }\n    if (flavors) void writeOsClipboard(flavors);\n  }, [adapterRef, optsRef]);\n\n  const paste = useCallback(() => {\n    const cb = clipboardRef.current;\n    if (cb.items.length === 0) return;\n    const a = adapterRef.current;\n    const result = materializePaste(a, cb, {\n      currentSelection: optsRef.current.getSelection(),\n      dropPoint: optsRef.current.getDropPoint?.(),\n      onOmitted: optsRef.current.onPasteOmitted,\n    });\n    if (!result) return;\n    dispatchApplyBatch(a, result.ops, optsRef.current.pasteLabel);\n    // Use the just-created objects as the next cascade source. Re-snapshotting\n    // via `adapter.snapshotSelection(newIds)` would read adapter state, but\n    // React-state adapters haven't flushed yet — `itemsRef.current` still\n    // points at the pre-insert array, so the snapshot would come back empty\n    // and the next paste would no-op.\n    clipboardRef.current = { items: result.created };\n    optsRef.current.onPaste?.(result.newIds as NodeId[]);\n  }, [adapterRef, optsRef]);\n\n  const isEmpty = useCallback(() => clipboardRef.current.items.length === 0, []);\n\n  return { copy, paste, isEmpty };\n}\n\nfunction defaultFlavors(snapshot: ClipboardSnapshot, replacer?: Replacer): ClipboardFlavors {\n  const text = buildWeaselClipboardText(snapshot.items, replacer);\n  return { [WEASEL_CLIPBOARD_MIME]: text, 'text/plain': text };\n}\n\n/** MIME types the async Clipboard API accepts unprefixed. Every other type\n *  (including our own custom MIME, and app-supplied flavors like\n *  `image/svg+xml`) must carry Chromium's `web ` prefix or `ClipboardItem`'s\n *  constructor throws. */\nconst WELL_KNOWN_CLIPBOARD_MIMES = new Set(['text/plain', 'text/html', 'image/png']);\n\n/** Degradation ladder: full map (every non-well-known MIME web-prefixed) →\n *  the same minus any promised flavor that rejected → well-known-only → give\n *  up with a dwarn. Chromium writes nothing when one flavor rejects, so a\n *  rejection costs only that flavor, never the clipboard's previous content\n *  half-overwritten.\n *  @internal test seam — exported so unit tests can await the fire-and-forget\n *  write directly; tests should still exercise this at least once through\n *  the public `copy()` (see clipboardOps.test.tsx). */\nexport async function writeOsClipboard(flavors: ClipboardFlavors): Promise<void> {\n  const entries = Object.entries(flavors);\n  if (entries.length === 0) return;\n  const cb = typeof navigator !== 'undefined' ? navigator.clipboard : undefined;\n  if (!cb?.write || typeof ClipboardItem === 'undefined') return;\n  const rejected = new Set<string>();\n  for (const [mime, text] of entries) {\n    if (typeof text !== 'string') text.catch(() => { rejected.add(mime); });\n  }\n  const wireMime = (mime: string) => (WELL_KNOWN_CLIPBOARD_MIMES.has(mime) ? mime : `web ${mime}`);\n  const toItem = (fs: Flavor[]) => new ClipboardItem(Object.fromEntries(\n    fs.map(([mime, text]) => {\n      const wire = wireMime(mime);\n      const blob = (t: string) => new Blob([t], { type: wire });\n      if (typeof text === 'string') return [wire, blob(text)];\n      const promised = text.then(blob);\n      // Chromium leaves a ClipboardItem's rejected promise unhandled.\n      promised.catch(() => {});\n      return [wire, promised];\n    }),\n  ));\n  // Writes `fs`, dropping flavors whose promise rejected and retrying the\n  // rest. Returns the last error, or null once a write lands.\n  const writeLive = async (fs: Flavor[]): Promise<unknown> => {\n    let live = fs;\n    for (;;) {\n      try {\n        await cb.write([toItem(live)]);\n        return null;\n      } catch (err) {\n        const next = live.filter(([mime]) => !rejected.has(mime));\n        if (next.length === live.length || next.length === 0) return err;\n        live = next;\n      }\n    }\n  };\n  if (await writeLive(entries) === null) return;\n  const standard = entries.filter(([mime]) => WELL_KNOWN_CLIPBOARD_MIMES.has(mime) && !rejected.has(mime));\n  if (standard.length === 0) { dwarn('clipboard', 'OS write failed; no standard flavors to fall back to'); return; }\n  const err = await writeLive(standard);\n  if (err !== null) dwarn('clipboard', `OS clipboard write failed twice — copy stays in-memory only: ${String(err)}`);\n}\n\ntype Flavor = [mime: string, text: string | Promise<string>];\n"],"mappings":";;;;;;;;AAwDA,IAAMA,IAA2B,EAAE,OAAO,CAAC,EAAE;AAG7C,SAAgBC,EACd,GACA,GACuB;CACvB,IAAM,EACJ,iBAAc,YAAS,mBAAgB,gBAAa,SAAS,iBAAc,mBAAgB,oBACzFC,GAKEC,IAAaC,EAAkB,GAC/BC,IAAwBC,KAAgBH,GAAY,cACpDI,IAAeC,EAA0BR,CAAK,GAE9CS,IAAaC,EAAUC,CAAO,GAC9BC,IAAUF,EAAU;EACxB;EAAc;EAAS;EAAgB;EAAY,cAAcL;EAAuB;EACxF;CACF,CAAC;CA8CD,OAAO;EAAE,MA5CIQ,QAAkB;GAC7B,IAAMC,IAAMF,EAAQ,QAAQ,aAAa;GACzC,IAAIE,EAAI,WAAW,GAAG;GACtB,IAAMC,IAAON,EAAW,QAAQ;GAChC,IAAI,CAACM,GAAM;GACX,EAAa,UAAUA,EAAKD,CAAG;GAO/B,IAAIE,IAAmC;GACvC,IAAI;IACF,IAAUJ,EAAQ,QAAQ,iBAAiBL,EAAa,OAAO,KAC1DU,EAAeV,EAAa,SAASK,EAAQ,QAAQ,YAAY;GACxE,SAASM,GAAK;IACZ,EAAM,aAAa,8CAA8C,OAAOA,CAAG,GAAG;GAChF;GACA,AAAIF,KAASG,EAAsBH,CAAO;EAC5C,GAAG,CAACP,GAAYG,CAAO,CAwBd;EAAM,OAtBDC,QAAkB;GAC9B,IAAMO,IAAKb,EAAa;GACxB,IAAIa,EAAG,MAAM,WAAW,GAAG;GAC3B,IAAMC,IAAIZ,EAAW,SACfa,IAASC,EAAiBF,GAAGD,GAAI;IACrC,kBAAkBR,EAAQ,QAAQ,aAAa;IAC/C,WAAWA,EAAQ,QAAQ,eAAe;IAC1C,WAAWA,EAAQ,QAAQ;GAC7B,CAAC;GACD,AAAKU,MACLE,EAAmBH,GAAGC,EAAO,KAAKV,EAAQ,QAAQ,UAAU,GAM5D,EAAa,UAAU,EAAE,OAAOU,EAAO,QAAQ,GAC/CV,EAAQ,QAAQ,UAAUU,EAAO,MAAkB;EACrD,GAAG,CAACb,GAAYG,CAAO,CAIR;EAAO,SAFNC,QAAkBN,EAAa,QAAQ,MAAM,WAAW,GAAG,CAAC,CAEtD;CAAQ;AAChC;AAEA,SAASU,EAAe,GAA6B,GAAuC;CAC1F,IAAMQ,IAAOC,EAAyBC,EAAS,OAAOC,CAAQ;CAC9D,OAAO;GAAGC,IAAwBJ;EAAM,cAAcA;CAAK;AAC7D;AAMA,IAAMK,oBAA6B,IAAI,IAAI;CAAC;CAAc;CAAa;AAAW,CAAC;AAUnF,eAAsBX,EAAiB,GAA0C;CAC/E,IAAMY,IAAU,OAAO,QAAQf,CAAO;CACtC,IAAIe,EAAQ,WAAW,GAAG;CAC1B,IAAMX,IAAK,OAAO,YAAc,MAAc,UAAU,YAAY,KAAA;CACpE,IAAI,CAACA,GAAI,SAAS,OAAO,gBAAkB,KAAa;CACxD,IAAMY,oBAAW,IAAI,IAAY;CACjC,KAAK,IAAM,CAACC,GAAMR,MAASM,GACzB,AAAI,OAAON,KAAS,YAAUA,EAAK,YAAY;EAAE,EAAS,IAAIQ,CAAI;CAAG,CAAC;CAExE,IAAMC,KAAY,MAAkBJ,EAA2B,IAAIG,CAAI,IAAIA,IAAO,OAAOA,KACnFE,KAAU,MAAiB,IAAI,cAAc,OAAO,YACxDC,EAAG,KAAK,CAACH,GAAMR,OAAU;EACvB,IAAMY,IAAOH,EAASD,CAAI,GACpBK,KAAQ,MAAc,IAAI,KAAK,CAACC,CAAC,GAAG,EAAE,MAAMF,EAAK,CAAC;EACxD,IAAI,OAAOZ,KAAS,UAAU,OAAO,CAACY,GAAMC,EAAKb,CAAI,CAAC;EACtD,IAAMe,IAAWf,EAAK,KAAKa,CAAI;EAG/B,OADAE,EAAS,YAAY,CAAC,CAAC,GAChB,CAACH,GAAMG,CAAQ;CACxB,CAAC,CACH,CAAC,GAGKC,IAAY,OAAO,MAAmC;EAC1D,IAAIC,IAAON;EACX,SACE,IAAI;GAEF,OADA,MAAMhB,EAAG,MAAM,CAACe,EAAOO,CAAI,CAAC,CAAC,GACtB;EACT,SAASxB,GAAK;GACZ,IAAMyB,IAAOD,EAAK,QAAQ,CAACT,OAAU,CAACD,EAAS,IAAIC,CAAI,CAAC;GACxD,IAAIU,EAAK,WAAWD,EAAK,UAAUC,EAAK,WAAW,GAAG,OAAOzB;GAC7D,IAAOyB;EACT;CAEJ;CACA,IAAI,MAAMF,EAAUV,CAAO,MAAM,MAAM;CACvC,IAAMa,IAAWb,EAAQ,QAAQ,CAACE,OAAUH,EAA2B,IAAIG,CAAI,KAAK,CAACD,EAAS,IAAIC,CAAI,CAAC;CACvG,IAAIW,EAAS,WAAW,GAAG;EAAE,EAAM,aAAa,sDAAsD;EAAG;CAAQ;CACjH,IAAM1B,IAAM,MAAMuB,EAAUG,CAAQ;CACpC,AAAI1B,MAAQ,QAAM2B,EAAM,aAAa,gEAAgE,OAAO3B,CAAG,GAAG;AACpH"}

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

@@ -1 +1 @@
-{"version":3,"file":"wireFormat.js","names":["WEASEL_CLIPBOARD_MIME","WEASEL_CLIPBOARD_MIME_WEB","buildWeaselClipboardText","items","replacer","sniffWeaselClipboardText","text","parsed","SVG_OPEN_TAG","embedWeaselMetadataInSvg","open","svgText","dwarn","cdata","payloadText","at","extractWeaselClipboardFromSvg","block","inner","payload","m","parseWeaselClipboardText","reviver","err"],"sources":["../../../../src/interactions/actions/clipboard/wireFormat.ts"],"sourcesContent":["import { dwarn } from 'debug/flag';\n\n/** MIME type the kit writes its full-fidelity clipboard payload under, so a\n *  copy/paste between two weasel canvases round-trips scene nodes rather than\n *  the SVG or text flavors other apps read. */\nexport const WEASEL_CLIPBOARD_MIME = 'application/x-weasel-clipboard+json';\n/** Chromium's async-clipboard spelling for custom formats. */\nexport const WEASEL_CLIPBOARD_MIME_WEB = `web ${WEASEL_CLIPBOARD_MIME}`;\n\ninterface WeaselClipboardPayload { weaselClipboard: 1; nodes: unknown[] }\n\ntype Replacer = (key: string, value: unknown) => unknown;\ntype Reviver = (key: string, value: unknown) => unknown;\n\n/** Serialize snapshot items into the versioned wire text.\n *\n *  JSON drops a function-valued field (a container's `clipFromPose`, a\n *  node's `derivePath`). A scene adapter's snapshot also carries each one's\n *  `SceneRegistry` key (`clipFromPoseKey`, `derivePathKey`, …), which does\n *  cross, and its paste restores the function from the pasting scene's\n *  registry. A function that is not registered does not survive. */\nexport function buildWeaselClipboardText(items: unknown[], replacer?: Replacer): string {\n  const payload: WeaselClipboardPayload = { weaselClipboard: 1, nodes: items };\n  return JSON.stringify(payload, replacer as Parameters<typeof JSON.stringify>[1]);\n}\n\n/** Cheap check: could this text be a weasel clipboard payload? Substring\n *  pre-check, then a guarded parse + marker/version test. */\nexport function sniffWeaselClipboardText(text: string): boolean {\n  if (!text.includes('\"weaselClipboard\"')) return false;\n  try {\n    const parsed = JSON.parse(text) as Partial<WeaselClipboardPayload> | null;\n    return !!parsed && parsed.weaselClipboard === 1;\n  } catch {\n    return false;\n  }\n}\n\n// Opening `<svg ...>` tag of a serialized document. `[^>]*` is safe for OUR\n// serializer's output (attribute values are XML-escaped, so no raw `>` can\n// appear inside the tag) — see embedWeaselMetadataInSvg's contract note.\nconst SVG_OPEN_TAG = /<svg(?:\\s[^>]*)?>/i;\n\n/**\n * Embed a weasel clipboard payload in an SVG document as a `<metadata>`\n * child of the root — legal SVG 1.1, ignored by external tools — so one\n * `text/plain` flavor serves both audiences: external tools parse the SVG,\n * weasel extracts the JSON for full fidelity on draw→draw DOM paste.\n *\n * The payload rides in CDATA so JSON's `<` / `&` need no entity escaping; a\n * literal `]]>` inside the payload is split across CDATA sections\n * (`]]]]><![CDATA[>`), which {@link extractWeaselClipboardFromSvg} rejoins.\n *\n * Intended for OUR serializer's output only (`serializeSvg` — single\n * `<svg ...>` open tag, XML-escaped attributes). When no open tag is found\n * the input is returned unchanged with a debug warning.\n */\nexport function embedWeaselMetadataInSvg(svgText: string, payloadText: string): string {\n  const open = SVG_OPEN_TAG.exec(svgText);\n  if (!open) {\n    dwarn('clipboard', 'embedWeaselMetadataInSvg: no <svg ...> open tag found — returning input unchanged');\n    return svgText;\n  }\n  const cdata = `<![CDATA[${payloadText.replaceAll(']]>', ']]]]><![CDATA[>')}]]>`;\n  const at = open.index + open[0].length;\n  return `${svgText.slice(0, at)}<metadata>${cdata}</metadata>${svgText.slice(at)}`;\n}\n\n/**\n * Recover an embedded weasel clipboard payload from SVG text: read the first\n * `<metadata>` block, rejoin its CDATA sections (concatenation restores the\n * `]]>` split by {@link embedWeaselMetadataInSvg}; plain non-CDATA content\n * passes through as-is), and return the payload text iff it sniffs as the\n * weasel wire format — else null (external/non-weasel metadata declines).\n *\n * A text scan, not an XML parse — the payload is small and ours.\n */\nexport function extractWeaselClipboardFromSvg(svgText: string): string | null {\n  const block = /<metadata(?:\\s[^>]*)?>([\\s\\S]*?)<\\/metadata>/i.exec(svgText);\n  if (!block) return null;\n  const inner = block[1];\n  const payload = inner.includes('<![CDATA[')\n    ? Array.from(inner.matchAll(/<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>/g), (m) => m[1]).join('')\n    : inner;\n  return sniffWeaselClipboardText(payload) ? payload : null;\n}\n\n/** Parse wire text to snapshot items, or null when malformed/mismatched\n *  (callers decline to the next content handler). */\nexport function parseWeaselClipboardText(text: string, reviver?: Reviver): unknown[] | null {\n  try {\n    const parsed = JSON.parse(text, reviver as Parameters<typeof JSON.parse>[1]) as\n      Partial<WeaselClipboardPayload> | null;\n    if (!parsed || parsed.weaselClipboard !== 1 || !Array.isArray(parsed.nodes)) return null;\n    return parsed.nodes;\n  } catch (err) {\n    dwarn('clipboard', `weasel payload failed to parse: ${String(err)}`);\n    return null;\n  }\n}\n"],"mappings":";;AAKA,IAAaA,IAAwB,uCAExBC,IAA4B,OAAOD;AAchD,SAAgBE,EAAyB,GAAkB,GAA6B;CAEtF,OAAO,KAAK,UAAU;EADoB,iBAAiB;EAAG,OAAOC;CAC/C,GAASC,CAAgD;AACjF;AAIA,SAAgBC,EAAyB,GAAuB;CAC9D,IAAI,CAACC,EAAK,SAAS,qBAAmB,GAAG,OAAO;CAChD,IAAI;EACF,IAAMC,IAAS,KAAK,MAAMD,CAAI;EAC9B,OAAO,CAAC,CAACC,KAAUA,EAAO,oBAAoB;CAChD,QAAQ;EACN,OAAO;CACT;AACF;AAKA,IAAMC,IAAe;AAgBrB,SAAgBC,EAAyB,GAAiB,GAA6B;CACrF,IAAMC,IAAOF,EAAa,KAAKG,CAAO;CACtC,IAAI,CAACD,GAEH,OADAE,EAAM,aAAa,mFAAmF,GAC/FD;CAET,IAAME,IAAQ,YAAYC,EAAY,WAAW,OAAO,iBAAiB,EAAE,MACrEC,IAAKL,EAAK,QAAQA,EAAK,EAAE,CAAC;CAChC,OAAO,GAAGC,EAAQ,MAAM,GAAGI,CAAE,EAAE,YAAYF,EAAM,aAAaF,EAAQ,MAAMI,CAAE;AAChF;AAWA,SAAgBC,EAA8B,GAAgC;CAC5E,IAAMC,IAAQ,gDAAgD,KAAKN,CAAO;CAC1E,IAAI,CAACM,GAAO,OAAO;CACnB,IAAMC,IAAQD,EAAM,IACdE,IAAUD,EAAM,SAAS,WAAW,IACtC,MAAM,KAAKA,EAAM,SAAS,6BAA6B,IAAI,MAAME,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,IAC9EF;CACJ,OAAOb,EAAyBc,CAAO,IAAIA,IAAU;AACvD;AAIA,SAAgBE,EAAyB,GAAc,GAAqC;CAC1F,IAAI;EACF,IAAMd,IAAS,KAAK,MAAMD,GAAMgB,CAA2C;EAG3E,OADI,CAACf,KAAUA,EAAO,oBAAoB,KAAK,CAAC,MAAM,QAAQA,EAAO,KAAK,IAAU,OAC7EA,EAAO;CAChB,SAASgB,GAAK;EAEZ,OADAX,EAAM,aAAa,mCAAmC,OAAOW,CAAG,GAAG,GAC5D;CACT;AACF"}
+{"version":3,"file":"wireFormat.js","names":["WEASEL_CLIPBOARD_MIME","WEASEL_CLIPBOARD_MIME_WEB","buildWeaselClipboardText","items","replacer","sniffWeaselClipboardText","text","parsed","SVG_OPEN_TAG","embedWeaselMetadataInSvg","open","svgText","dwarn","cdata","payloadText","at","extractWeaselClipboardFromSvg","block","inner","payload","m","parseWeaselClipboardText","reviver","err"],"sources":["../../../../src/interactions/actions/clipboard/wireFormat.ts"],"sourcesContent":["import { dwarn } from 'debug/flag';\n\n/** MIME type the kit writes its full-fidelity clipboard payload under, so a\n *  copy/paste between two weasel canvases round-trips scene nodes rather than\n *  the SVG or text flavors other apps read. */\nexport const WEASEL_CLIPBOARD_MIME = 'application/x-weasel-clipboard+json';\n/** Chromium's async-clipboard spelling for custom formats. */\nexport const WEASEL_CLIPBOARD_MIME_WEB = `web ${WEASEL_CLIPBOARD_MIME}`;\n\ninterface WeaselClipboardPayload { weaselClipboard: 1; nodes: unknown[] }\n\ntype Replacer = (key: string, value: unknown) => unknown;\ntype Reviver = (key: string, value: unknown) => unknown;\n\n/** Serialize snapshot items into the versioned wire text.\n *\n *  JSON drops a function-valued field (a container's `clipFromPose`, a\n *  node's `derivePath`). A scene adapter's snapshot also carries each one's\n *  `SceneRegistry` key (`clipFromPoseKey`, `derivePathKey`, …), which does\n *  cross, and its paste restores the function from the pasting scene's\n *  registry. A function that is not registered does not survive. */\nexport function buildWeaselClipboardText(items: unknown[], replacer?: Replacer): string {\n  const payload: WeaselClipboardPayload = { weaselClipboard: 1, nodes: items };\n  return JSON.stringify(payload, replacer as Parameters<typeof JSON.stringify>[1]);\n}\n\n/** Cheap check: could this text be a weasel clipboard payload? Substring\n *  pre-check, then a guarded parse + marker/version test. */\nexport function sniffWeaselClipboardText(text: string): boolean {\n  if (!text.includes('\"weaselClipboard\"')) return false;\n  try {\n    const parsed = JSON.parse(text) as Partial<WeaselClipboardPayload> | null;\n    return !!parsed && parsed.weaselClipboard === 1;\n  } catch {\n    return false;\n  }\n}\n\n// `[^>]*` is safe for OUR serializer's output only: attribute values are\n// XML-escaped, so no raw `>` can appear inside the tag.\nconst SVG_OPEN_TAG = /<svg(?:\\s[^>]*)?>/i;\n\n/**\n * Embed a weasel clipboard payload in an SVG document as a `<metadata>`\n * child of the root — legal SVG 1.1, ignored by external tools — so one\n * `text/plain` flavor serves both audiences.\n *\n * Intended for OUR serializer's output only (`serializeSvg` — single\n * `<svg ...>` open tag, XML-escaped attributes). When no open tag is found\n * the input is returned unchanged with a debug warning.\n */\nexport function embedWeaselMetadataInSvg(svgText: string, payloadText: string): string {\n  const open = SVG_OPEN_TAG.exec(svgText);\n  if (!open) {\n    dwarn('clipboard', 'embedWeaselMetadataInSvg: no <svg ...> open tag found — returning input unchanged');\n    return svgText;\n  }\n  const cdata = `<![CDATA[${payloadText.replaceAll(']]>', ']]]]><![CDATA[>')}]]>`;\n  const at = open.index + open[0].length;\n  return `${svgText.slice(0, at)}<metadata>${cdata}</metadata>${svgText.slice(at)}`;\n}\n\n/**\n * The weasel clipboard payload embedded in SVG text by\n * {@link embedWeaselMetadataInSvg}, or null when the first `<metadata>` block\n * is absent or not the weasel wire format. A text scan, not an XML parse.\n */\nexport function extractWeaselClipboardFromSvg(svgText: string): string | null {\n  const block = /<metadata(?:\\s[^>]*)?>([\\s\\S]*?)<\\/metadata>/i.exec(svgText);\n  if (!block) return null;\n  const inner = block[1];\n  const payload = inner.includes('<![CDATA[')\n    ? Array.from(inner.matchAll(/<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>/g), (m) => m[1]).join('')\n    : inner;\n  return sniffWeaselClipboardText(payload) ? payload : null;\n}\n\n/** Parse wire text to snapshot items, or null when malformed/mismatched\n *  (callers decline to the next content handler). */\nexport function parseWeaselClipboardText(text: string, reviver?: Reviver): unknown[] | null {\n  try {\n    const parsed = JSON.parse(text, reviver as Parameters<typeof JSON.parse>[1]) as\n      Partial<WeaselClipboardPayload> | null;\n    if (!parsed || parsed.weaselClipboard !== 1 || !Array.isArray(parsed.nodes)) return null;\n    return parsed.nodes;\n  } catch (err) {\n    dwarn('clipboard', `weasel payload failed to parse: ${String(err)}`);\n    return null;\n  }\n}\n"],"mappings":";;AAKA,IAAaA,IAAwB,uCAExBC,IAA4B,OAAOD;AAchD,SAAgBE,EAAyB,GAAkB,GAA6B;CAEtF,OAAO,KAAK,UAAU;EADoB,iBAAiB;EAAG,OAAOC;CAC/C,GAASC,CAAgD;AACjF;AAIA,SAAgBC,EAAyB,GAAuB;CAC9D,IAAI,CAACC,EAAK,SAAS,qBAAmB,GAAG,OAAO;CAChD,IAAI;EACF,IAAMC,IAAS,KAAK,MAAMD,CAAI;EAC9B,OAAO,CAAC,CAACC,KAAUA,EAAO,oBAAoB;CAChD,QAAQ;EACN,OAAO;CACT;AACF;AAIA,IAAMC,IAAe;AAWrB,SAAgBC,EAAyB,GAAiB,GAA6B;CACrF,IAAMC,IAAOF,EAAa,KAAKG,CAAO;CACtC,IAAI,CAACD,GAEH,OADAE,EAAM,aAAa,mFAAmF,GAC/FD;CAET,IAAME,IAAQ,YAAYC,EAAY,WAAW,OAAO,iBAAiB,EAAE,MACrEC,IAAKL,EAAK,QAAQA,EAAK,EAAE,CAAC;CAChC,OAAO,GAAGC,EAAQ,MAAM,GAAGI,CAAE,EAAE,YAAYF,EAAM,aAAaF,EAAQ,MAAMI,CAAE;AAChF;AAOA,SAAgBC,EAA8B,GAAgC;CAC5E,IAAMC,IAAQ,gDAAgD,KAAKN,CAAO;CAC1E,IAAI,CAACM,GAAO,OAAO;CACnB,IAAMC,IAAQD,EAAM,IACdE,IAAUD,EAAM,SAAS,WAAW,IACtC,MAAM,KAAKA,EAAM,SAAS,6BAA6B,IAAI,MAAME,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,IAC9EF;CACJ,OAAOb,EAAyBc,CAAO,IAAIA,IAAU;AACvD;AAIA,SAAgBE,EAAyB,GAAc,GAAqC;CAC1F,IAAI;EACF,IAAMd,IAAS,KAAK,MAAMD,GAAMgB,CAA2C;EAG3E,OADI,CAACf,KAAUA,EAAO,oBAAoB,KAAK,CAAC,MAAM,QAAQA,EAAO,KAAK,IAAU,OAC7EA,EAAO;CAChB,SAASgB,GAAK;EAEZ,OADAX,EAAM,aAAa,mCAAmC,OAAOW,CAAG,GAAG,GAC5D;CACT;AACF"}