@weasel-js/core 1.7.0 → 1.7.2

package/dist/interactions/actions/defaults/duplicate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate.js","names":["DUPLICATE_OFFSET","hasSelectedAncestor","parent","scene","id","set","copySubtree","node","newId","freshNodeId","copy","translatePoseViaDescriptor","offset","d","createInsertOp","childOffset","offsetDescendants","child","ops","duplicateAction","createElement","DuplicateIcon","selection","deps","applyOps","ids","descriptor","poseDescriptorOf","newIds","nid","asNodeId","defaultCommitAdapter","requiresSelection"],"sources":["../../../../src/interactions/actions/defaults/duplicate.ts"],"sourcesContent":["import type { Action } from '@weasel-js/routing';\nimport { createElement } from 'react';\nimport { DuplicateIcon } from './icons/editIcons';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Op } from 'core/ops/types';\nimport { createInsertOp } from 'core/ops/create';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { freshNodeId } from './freshNodeId';\nimport { requiresSelection } from './requiresSelection';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport { translatePoseViaDescriptor, type PoseDescriptor } from '../resize/geometry';\n\n/** Same nudge `sceneToAdapter.getPasteOffset` gives a paste, so duplicate and\n *  paste land in the same place rather than disagreeing by a few units. */\nconst DUPLICATE_OFFSET = 12;\n\n/** True when any ancestor of `id` is also in `set` — that ancestor's copy\n *  already brings this node along, so duplicating it again would double it. */\nfunction hasSelectedAncestor(\n  scene: Scene<unknown, string, unknown>,\n  id: NodeId,\n  set: ReadonlySet<string>,\n): boolean {\n  let parent = scene.get(id)?.parent ?? null;\n  while (parent != null) {\n    if (set.has(parent)) return true;\n    parent = scene.get(parent)?.parent ?? null;\n  }\n  return false;\n}\n\n/**\n * Copy `id`'s whole subtree, appending one insert op per node in pre-order so\n * a parent always exists before its children are inserted. Returns the new\n * root's id.\n *\n * `offsetDescendants` is false for local-pose consumers (those that registered\n * a `poseComposition`): a child's pose is relative there, so offsetting the\n * root already carries the subtree, and offsetting again would double it. With\n * the default absolute poses every node stores world coords and every one\n * moves.\n */\nfunction copySubtree(\n  scene: Scene<unknown, string, unknown>,\n  id: NodeId,\n  parent: NodeId | null,\n  offset: { dx: number; dy: number },\n  offsetDescendants: boolean,\n  ops: Op[],\n  d: PoseDescriptor<unknown>,\n): NodeId | null {\n  const node = scene.get(id);\n  if (!node) return null;\n  const newId = freshNodeId();\n  const copy = {\n    ...node,\n    id: newId,\n    pose: translatePoseViaDescriptor(node.pose, offset.dx, offset.dy, d),\n    parent,\n  } as Node<unknown, string, unknown>;\n  ops.push(createInsertOp<Node<unknown, string, unknown>>({ node: copy, label: 'Duplicate' }));\n  const childOffset = offsetDescendants ? offset : { dx: 0, dy: 0 };\n  for (const child of scene.childrenOf(id)) {\n    copySubtree(scene, child, newId, childOffset, offsetDescendants, ops, d);\n  }\n  return newId;\n}\n\n/**\n * @experimental\n * Static descriptor for the `duplicate` Action. Copies each selected node —\n * with its subtree, so duplicating a group produces a populated group — offset\n * by a small nudge, as one undoable batch, then selects the copies.\n */\nexport const duplicateAction: Action & { requires: string[] } = {\n  id: 'duplicate',\n  label: 'Duplicate',\n  icon: createElement(DuplicateIcon),\n  group: 'edit',\n  defaultBinding: { kind: 'key', key: 'd', mods: { mod: true } },\n  eligible: { capability: ['edits-page', 'creates-selection'] },\n  // `selection` is read by the `enabled` gate as well as the invoker. An\n  // undeclared read throws inside the dev-build deps Proxy before the gate can\n  // answer, which is how this action spent a while doing nothing at all.\n  requires: ['scene', 'selection', 'applyOps', 'poseComposition', 'poseDescriptor'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const selection = deps.selection as SelectionApi | undefined;\n      const scene = deps.scene as Scene<unknown, string, unknown> | undefined;\n      const applyOps = deps.applyOps as ((ops: Op[], label: string) => void) | undefined;\n      if (!selection || !scene) return;\n      const ids = selection.get();\n      if (ids.length === 0) return;\n\n      const set = new Set<string>(ids);\n      const descriptor = poseDescriptorOf(deps.poseDescriptor);\n      const offset = { dx: DUPLICATE_OFFSET, dy: DUPLICATE_OFFSET };\n      const ops: Op[] = [];\n      const newIds: NodeId[] = [];\n      for (const id of ids) {\n        const nid = asNodeId(id);\n        const node = scene.get(nid);\n        if (!node) continue;\n        if (hasSelectedAncestor(scene, nid, set)) continue;\n        const newId = copySubtree(scene, nid, node.parent ?? null, offset, deps.poseComposition === undefined, ops, descriptor);\n        if (newId) newIds.push(newId);\n      }\n\n      if (ops.length === 0) return;\n      if (applyOps) applyOps(ops, 'Duplicate');\n      else scene.applyBatch(ops, 'Duplicate', defaultCommitAdapter(scene, selection.adapterMethods));\n      selection.set(newIds);\n    },\n  },\n  enabled: requiresSelection,\n};\n"],"mappings":";;;;;;;;;;AAgBA,IAAMA,IAAmB;AAIzB,SAASC,EACP,GACA,GACA,GACS;CACT,IAAIC,IAASC,EAAM,IAAIC,CAAE,CAAC,EAAE,UAAU;CACtC,OAAOF,KAAU,OAAM;EACrB,IAAIG,EAAI,IAAIH,CAAM,GAAG,OAAO;EAC5B,IAASC,EAAM,IAAID,CAAM,CAAC,EAAE,UAAU;CACxC;CACA,OAAO;AACT;AAaA,SAASI,EACP,GACA,GACA,GACA,GACA,GACA,GACA,GACe;CACf,IAAMC,IAAOJ,EAAM,IAAIC,CAAE;CACzB,IAAI,CAACG,GAAM,OAAO;CAClB,IAAMC,IAAQC,EAAY,GACpBC,IAAO;EACX,GAAGH;EACH,IAAIC;EACJ,MAAMG,EAA2BJ,EAAK,MAAMK,EAAO,IAAIA,EAAO,IAAIC,CAAC;EACnE;CACF;CACA,EAAI,KAAKC,EAA+C;EAAE,MAAMJ;EAAM,OAAO;CAAY,CAAC,CAAC;CAC3F,IAAMK,IAAcC,IAAoBJ,IAAS;EAAE,IAAI;EAAG,IAAI;CAAE;CAChE,KAAK,IAAMK,KAASd,EAAM,WAAWC,CAAE,GACrC,EAAYD,GAAOc,GAAOT,GAAOO,GAAaC,GAAmBE,GAAKL,CAAC;CAEzE,OAAOL;AACT;AAQA,IAAaW,IAAmD;CAC9D,IAAI;CACJ,OAAO;CACP,MAAMC,EAAcC,CAAa;CACjC,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;EAAK,MAAM,EAAE,KAAK,GAAK;CAAE;CAC7D,UAAU,EAAE,YAAY,CAAC,cAAc,mBAAmB,EAAE;CAI5D,UAAU;EAAC;EAAS;EAAa;EAAY;EAAmB;CAAgB;CAChF,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,IAAMC,IAAYC,EAAK,WACjBpB,IAAQoB,EAAK,OACbC,IAAWD,EAAK;GACtB,IAAI,CAACD,KAAa,CAACnB,GAAO;GAC1B,IAAMsB,IAAMH,EAAU,IAAI;GAC1B,IAAIG,EAAI,WAAW,GAAG;GAEtB,IAAMpB,IAAM,IAAI,IAAYoB,CAAG,GACzBC,IAAaC,EAAiBJ,EAAK,cAAc,GACjDX,IAAS;IAAE,IAAIZ;IAAkB,IAAIA;GAAiB,GACtDkB,IAAY,CAAC,GACbU,IAAmB,CAAC;GAC1B,KAAK,IAAMxB,KAAMqB,GAAK;IACpB,IAAMI,IAAMC,EAAS1B,CAAE,GACjBG,IAAOJ,EAAM,IAAI0B,CAAG;IAE1B,IADI,CAACtB,KACDN,EAAoBE,GAAO0B,GAAKxB,CAAG,GAAG;IAC1C,IAAMG,IAAQF,EAAYH,GAAO0B,GAAKtB,EAAK,UAAU,MAAMK,GAAQW,EAAK,oBAAoB,KAAA,GAAWL,GAAKQ,CAAU;IACtH,AAAIlB,KAAOoB,EAAO,KAAKpB,CAAK;GAC9B;GAEA,AAAIU,EAAI,WAAW,MACfM,IAAUA,EAASN,GAAK,WAAW,IAClCf,EAAM,WAAWe,GAAK,aAAaa,EAAqB5B,GAAOmB,EAAU,cAAc,CAAC,GAC7FA,EAAU,IAAIM,CAAM;EACtB;CACF;CACA,SAASI;AACX"}

package/dist/interactions/actions/defaults/editAnchors.js

@@ -0,0 +1,100 @@
+import { editingLayer as e, inPlane as t } from "../planeInput.js";
+import { pathToAnchors as n } from "../../../features/paths/anchors.js";
+import { anchorAt as r, editAnchorSet as i, moveHandleTo as a, translateAnchorBy as o } from "../../../features/paths/anchorEdits.js";
+import { worldEditToStorage as s } from "../../../features/paths/pathInWorld.js";
+import { isAnchorOrControl as c } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/editAnchors.ts
+function l(e) {
+	let t = e.match(/^(anchor|controlIn|controlOut):(\d+)$/);
+	return t ? {
+		anchorIndex: parseInt(t[2], 10),
+		part: t[1]
+	} : null;
+}
+function u(e, t, n) {
+	if (n) {
+		let n = new Set(e);
+		return n.has(t) ? n.delete(t) : n.add(t), n;
+	}
+	return e.has(t) && e.size > 1 ? new Set(e) : /* @__PURE__ */ new Set([t]);
+}
+var d = t({
+	id: "editAnchors",
+	label: "Edit Anchors",
+	defaultBinding: {
+		kind: "drag",
+		target: { kindOf: c }
+	},
+	eligible: { capability: "edits-anchors" },
+	requires: ["selection", "editAnchors"],
+	invoker: {
+		timing: "ongoing",
+		start(e, t) {
+			let c = e.deps.editAnchors;
+			if (!c) return {};
+			let d = e.drag?.affordance;
+			if (!d) return {};
+			let f = l(d.kind);
+			if (!f) return {};
+			let { editingId: p } = c, m = c.getEditablePath(p);
+			if (!m || m.kind !== "polygon") return {};
+			let h = c.getStorageKind(p);
+			if (h !== "pose" && h !== "data") return {};
+			let g = n(m), _ = r(g, f.anchorIndex);
+			if (!_ || f.part === "controlIn" && !_.inHandle || f.part === "controlOut" && !_.outHandle) return {};
+			let v = [f.anchorIndex];
+			if (f.part === "anchor") {
+				let t = u(c.selectedAnchors, f.anchorIndex, e.modifiers.shift);
+				c.setSelectedAnchors(t), v = t.has(f.anchorIndex) ? [...t] : [];
+			}
+			let y = h === "data" ? c.getNodeShape(p) : null, b = y ? y.pose : void 0, x = y ? y.data : void 0, S = {
+				dep: c,
+				id: p,
+				anchorIndex: f.anchorIndex,
+				part: f.part,
+				dragging: v,
+				anchorOrigin: {
+					x: _.x,
+					y: _.y
+				},
+				originPose: m,
+				currentPose: m,
+				storageKind: h
+			}, C = !1;
+			return {
+				kind: "edit-anchors",
+				onMove(e) {
+					if (S.part === "anchor") {
+						if (S.dragging.length === 0) return;
+						let t = e.world.x - S.anchorOrigin.x, n = e.world.y - S.anchorOrigin.y, r = i(S.originPose, (e) => {
+							for (let r of S.dragging) o(e, r, t, n);
+						});
+						r && (S.currentPose = r);
+					} else {
+						let t = S.part === "controlIn" ? "in" : "out", n = i(S.originPose, (n) => a(n, S.anchorIndex, t, e.world.x, e.world.y, e.modifiers.alt));
+						n && (S.currentPose = n);
+					}
+					C = !0;
+				},
+				onEnd(e, t) {
+					C = !1, t !== "cancel" && S.originPose !== S.currentPose && S.dep.applyEdit(S.id, S.currentPose, "Edit anchors");
+				},
+				previewIds: () => C ? [S.id] : null,
+				previewPose: (e) => !C || e !== S.id ? null : S.storageKind === "pose" ? S.currentPose : b ? s(b, S.currentPose).pose : null,
+				previewData: (e) => {
+					if (!C || e !== S.id || S.storageKind !== "data" || !x) return null;
+					let { path: t } = s(b, S.currentPose);
+					return {
+						...x,
+						path: t
+					};
+				}
+			};
+		}
+	},
+	enabled: () => !0
+}, e);
+//#endregion
+export { d as editAnchorsAction, u as selectionAfterAnchorPress };
+
+//# sourceMappingURL=editAnchors.js.map

package/dist/interactions/actions/defaults/editAnchors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"editAnchors.js","names":["parseAnchorAffordance","m","kind","selectionAfterAnchorPress","additive","next","current","anchorIndex","editAnchorsAction","inPlane","isAnchorOrControl","dep","ctx","affordance","anchorInfo","worldPath","editingId","storageKind","decoded","pathToAnchors","origin","anchorAt","dragging","nodeShape","originRectPose","originData","scratch","active","dx","moveCtx","dy","editAnchorSet","flat","set","side","moveHandleTo","reason","id","worldEditToStorage","editingLayer"],"sources":["../../../../src/interactions/actions/defaults/editAnchors.ts"],"sourcesContent":["/**\n * `editAnchorsAction` — ongoing Action descriptor for editing polygon anchors.\n *\n * Owns the whole press-on-an-anchor gesture, because pressing and dragging\n * an anchor are two outcomes of one interaction rather than two\n * interactions:\n *\n *   - **Press** selects. Bare press replaces the anchor selection; Shift\n *     toggles the pressed anchor in or out of it. Pressing an anchor that\n *     is already part of a multi-anchor selection leaves the selection\n *     alone, so you can grab a set and move it.\n *   - **Drag** then moves whatever the press left selected — one anchor,\n *     or every selected anchor together.\n *   - **Dragging a control handle** moves just that handle, mirroring the\n *     opposite one while the anchor is smooth. Alt breaks the mirror.\n *\n * Selection lives on the `editAnchors` dep (flat anchor indices) rather\n * than in this handle's scratch, because the keyboard actions\n * (`nudgeAnchors`, `deleteAnchors`) and the overlay all need to read it\n * between gestures.\n *\n * ## Wiring\n *\n * The descriptor is operational when the consumer wires:\n *   1. `buildAffordanceAt` with a `getAnchorState` thunk so the dispatcher\n *      classifies anchor/control-handle hits as `anchor:N`, `controlIn:N`,\n *      or `controlOut:N` affordances on pointerdown.\n *   2. The `editAnchors` dep in the DepSchema.\n *\n * When `ctx.drag.affordance` is absent or is not an anchor/control kind,\n * `start` returns `{}` (no-op) so other bindings can handle the drag.\n *\n * @see buildAffordanceAt — the classifier that produces anchor affordances.\n * @see anchorEdits — the pure geometry these handlers drive.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { EditAnchorsDep } from '../depSchema';\nimport { isAnchorOrControl } from '@weasel-js/routing';\nimport {\n  anchorAt,\n  editAnchorSet,\n  moveHandleTo,\n  translateAnchorBy,\n  type AnchorSet,\n} from 'features/paths/anchorEdits';\nimport { pathToAnchors } from 'features/paths/anchors';\nimport { worldEditToStorage } from 'features/paths/pathInWorld';\n// Commit goes through dep.applyEdit (routes setPose or setPose+update\n// based on the node's path-storage shape); no direct op or dispatch\n// helpers needed here.\nimport type { PolygonPath } from '@weasel-js/geom';\nimport { inPlane, editingLayer } from '../planeInput';\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Parse an anchor affordance kind string into the anchor it names.\n * Returns `null` when the affordance is not an anchor kind.\n *\n * Format: `'anchor:N'` | `'controlIn:N'` | `'controlOut:N'`, where N is the\n * flat anchor index — the same numbering `enumerateAnchors` produces and\n * `anchorEdits` addresses by.\n */\nfunction parseAnchorAffordance(\n  kind: string,\n): { anchorIndex: number; part: 'anchor' | 'controlIn' | 'controlOut' } | null {\n  const m = kind.match(/^(anchor|controlIn|controlOut):(\\d+)$/);\n  if (!m) return null;\n  return {\n    anchorIndex: parseInt(m[2], 10),\n    part: m[1] as 'anchor' | 'controlIn' | 'controlOut',\n  };\n}\n\n/**\n * Resolve what a press on `anchorIndex` should leave selected.\n *\n * Shift toggles. A bare press on an anchor that's already part of the\n * selection keeps the selection intact (so the drag moves the whole set);\n * a bare press anywhere else collapses to just that anchor.\n */\nexport function selectionAfterAnchorPress(\n  current: ReadonlySet<number>,\n  anchorIndex: number,\n  additive: boolean,\n): Set<number> {\n  if (additive) {\n    const next = new Set(current);\n    if (next.has(anchorIndex)) next.delete(anchorIndex);\n    else next.add(anchorIndex);\n    return next;\n  }\n  if (current.has(anchorIndex) && current.size > 1) return new Set(current);\n  return new Set([anchorIndex]);\n}\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\ninterface EditAnchorsScratch {\n  dep: EditAnchorsDep;\n  id: string;\n  anchorIndex: number;\n  /** `'anchor'` drags on-curve points (and their handles) by a delta.\n   *  `'controlIn'` / `'controlOut'` drag one control point to an absolute\n   *  world coord. */\n  part: 'anchor' | 'controlIn' | 'controlOut';\n  /** Anchors this drag moves — the pressed one, or the whole anchor\n   *  selection when the press landed inside it. Flat indices. */\n  dragging: readonly number[];\n  /** World position of the pressed anchor at drag start; the drag delta is\n   *  measured from here rather than accumulated per move, so the geometry\n   *  is always derived from `originPose` in one step. */\n  anchorOrigin: { x: number; y: number };\n  originPose: PolygonPath;\n  currentPose: PolygonPath;\n  /** Where the polygon lives on the node — drives which preview-ghost\n   *  axes the handle populates (`previewPose` only for pose-as-polygon,\n   *  `previewPose` + `previewData` for data.path). */\n  storageKind: 'pose' | 'data';\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * Static descriptor for the `editAnchors` Action.\n *\n * Requires dep-schema entries: `selection`, `editAnchors`.\n */\nexport const editAnchorsAction: Action & { requires: string[] } = inPlane({\n  id: 'editAnchors',\n  label: 'Edit Anchors',\n  defaultBinding: {\n    kind: 'drag',\n    // Only matches drags whose pointerdown hit an anchor or control handle.\n    // Ties moveAction's `selected-body` on specificity and registers after\n    // it, so move declines these presses in `start`.\n    target: { kindOf: isAnchorOrControl },\n  },\n  eligible: { capability: 'edits-anchors' },\n  requires: ['selection', 'editAnchors'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, _opts): OngoingHandle {\n      const dep = ctx.deps.editAnchors as EditAnchorsDep | undefined;\n      if (!dep) return {};\n\n      const affordance = ctx.drag?.affordance;\n      if (!affordance) {\n        // No affordance hit → this drag doesn't target an anchor handle.\n        // Let other bindings handle it (the handle returns {}, dispatcher moves on).\n        return {};\n      }\n\n      const anchorInfo = parseAnchorAffordance(affordance.kind);\n      if (!anchorInfo) {\n        // Affordance is a non-anchor kind (e.g. resize handle, rotate handle).\n        return {};\n      }\n\n      const { editingId } = dep;\n      // World-coord polygon. For pose-as-polygon nodes this equals\n      // node.pose; for data.path nodes it's pathInWorld-projected (translate +\n      // rotation) so the anchor world coords match what the user clicked.\n      const worldPath = dep.getEditablePath(editingId) as PolygonPath | undefined;\n      if (!worldPath || worldPath.kind !== 'polygon') return {};\n      const storageKind = dep.getStorageKind(editingId);\n      if (storageKind !== 'pose' && storageKind !== 'data') return {};\n\n      // Decode once to validate the affordance index against the actual\n      // geometry and to read the press origin. A stale affordance (the\n      // path changed between pointerdown and now) fails here rather than\n      // silently editing whichever anchor now holds that index.\n      const decoded = pathToAnchors(worldPath) as AnchorSet;\n      const origin = anchorAt(decoded, anchorInfo.anchorIndex);\n      if (!origin) return {};\n      if (anchorInfo.part === 'controlIn' && !origin.inHandle) return {};\n      if (anchorInfo.part === 'controlOut' && !origin.outHandle) return {};\n\n      // --- Press semantics: selection updates immediately, before any move.\n      let dragging: readonly number[] = [anchorInfo.anchorIndex];\n      if (anchorInfo.part === 'anchor') {\n        const next = selectionAfterAnchorPress(\n          dep.selectedAnchors,\n          anchorInfo.anchorIndex,\n          ctx.modifiers.shift,\n        );\n        dep.setSelectedAnchors(next);\n        // Shift-pressing an anchor OUT of the selection must not then drag\n        // it; drag whatever the press left selected, intersected with the\n        // pressed anchor's membership.\n        dragging = next.has(anchorInfo.anchorIndex)\n          ? [...next]\n          : [];\n      }\n\n      // For data.path nodes, we also need the original rect pose + data\n      // so previewPose / previewData can be derived from currentPose.\n      // Captured at start so onMove doesn't re-read the scene.\n      const nodeShape = storageKind === 'data' ? dep.getNodeShape(editingId) : null;\n      const originRectPose =\n        nodeShape ? (nodeShape.pose as { x: number; y: number; width: number; height: number }) : undefined;\n      const originData = nodeShape ? (nodeShape.data as object) : undefined;\n\n      const scratch: EditAnchorsScratch = {\n        dep,\n        id: editingId,\n        anchorIndex: anchorInfo.anchorIndex,\n        part: anchorInfo.part,\n        dragging,\n        anchorOrigin: { x: origin.x, y: origin.y },\n        originPose: worldPath,\n        currentPose: worldPath,\n        storageKind,\n      };\n\n      let active = false;\n\n      return {\n        kind: 'edit-anchors',\n        onMove(moveCtx: InvocationCtx): void {\n          if (scratch.part === 'anchor') {\n            if (scratch.dragging.length === 0) return;\n            const dx = moveCtx.world.x - scratch.anchorOrigin.x;\n            const dy = moveCtx.world.y - scratch.anchorOrigin.y;\n            const next = editAnchorSet(scratch.originPose, (set) => {\n              for (const flat of scratch.dragging) translateAnchorBy(set, flat, dx, dy);\n            });\n            if (next) scratch.currentPose = next;\n          } else {\n            const side = scratch.part === 'controlIn' ? 'in' : 'out';\n            const next = editAnchorSet(scratch.originPose, (set) =>\n              moveHandleTo(\n                set,\n                scratch.anchorIndex,\n                side,\n                moveCtx.world.x,\n                moveCtx.world.y,\n                // Alt breaks the smooth mirror for this drag — read live so\n                // the user can press or release Alt mid-drag.\n                moveCtx.modifiers.alt,\n              ),\n            );\n            if (next) scratch.currentPose = next;\n          }\n          active = true;\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          active = false;\n          if (reason === 'cancel') return;\n          if (scratch.originPose === scratch.currentPose) return;\n          scratch.dep.applyEdit(scratch.id, scratch.currentPose, 'Edit anchors');\n        },\n        previewIds: () => (active ? [scratch.id] : null),\n        previewPose: (id: string): unknown | null => {\n          if (!active || id !== scratch.id) return null;\n          if (scratch.storageKind === 'pose') {\n            // Pose IS the polygon — preview pose is the polygon itself.\n            return scratch.currentPose;\n          }\n          // data.path: invert the world edit the same way the commit does, so\n          // the preview ghost (which re-applies pose.rotation via the render\n          // wrap) matches the committed result — no double-rotation.\n          if (!originRectPose) return null;\n          return worldEditToStorage(originRectPose, scratch.currentPose).pose;\n        },\n        previewData: (id: string): unknown | null => {\n          if (!active || id !== scratch.id) return null;\n          if (scratch.storageKind !== 'data') return null;\n          if (!originData) return null;\n          // Stored path is the unrotated, origin-aligned contour; the render\n          // invariant `pathInWorld(stored, pose) === world` holds.\n          const { path } = worldEditToStorage(originRectPose!, scratch.currentPose);\n          return { ...originData, path };\n        },\n      };\n    },\n  },\n  enabled: () => true,\n}, editingLayer);\n"],"mappings":"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"}

package/dist/interactions/actions/defaults/enterPathEdit.js

@@ -0,0 +1,29 @@
+import { isBody as e } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/enterPathEdit.ts
+var t = {
+	id: "enterPathEdit",
+	label: "Edit path anchors",
+	defaultBinding: {
+		kind: "doubleClick",
+		target: { kindOf: e }
+	},
+	eligible: { mode: { in: ["normal", "isolation"] } },
+	requires: ["editAnchors", "selection"],
+	invoker: {
+		timing: "immediate",
+		run(e) {
+			let t = e.editAnchors, n = e.selection;
+			if (!t || !n) return;
+			let r = n.get();
+			for (let e of r) if (t.getEditablePath(e)) {
+				t.setEditingId(e);
+				return;
+			}
+		}
+	},
+	enabled: () => !0
+};
+//#endregion
+export { t as enterPathEditAction };
+
+//# sourceMappingURL=enterPathEdit.js.map

package/dist/interactions/actions/defaults/enterPathEdit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enterPathEdit.js","names":["enterPathEditAction","isBody","editAnchors","deps","selection","ids","id"],"sources":["../../../../src/interactions/actions/defaults/enterPathEdit.ts"],"sourcesContent":["/**\n * `enterPathEditAction` — immediate Action that enters path-anchor edit\n * mode on a double-click against a selected polygon. Sets\n * `editAnchors.editingId` to the first selected polygon's id; the\n * gesture-side hit-test (via `buildAffordanceAt`) and the\n * `pathEditingOverlayLayer` chrome both gate on that id.\n *\n * No-op when the selection contains no polygon. The companion\n * `exitPathEditAction` (Escape) clears edit mode.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport type { ImmediateInvoker } from '@weasel-js/routing';\nimport type { EditAnchorsDep } from '../depSchema';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { NodeId } from 'core/scene/types';\nimport { isBody } from '@weasel-js/routing';\n\nexport const enterPathEditAction: Action & { requires: string[] } = {\n  id: 'enterPathEdit',\n  label: 'Edit path anchors',\n  // Double-click on a polygon body (selected OR unselected) — matches the\n  // Figma/Illustrator convention where double-clicking a path enters edit\n  // mode regardless of prior selection state. The `kindOf` predicate fires\n  // on either body class but not on empty space, so a double-click on\n  // empty canvas doesn't accidentally enter edit mode.\n  defaultBinding: {\n    kind: 'doubleClick',\n    target: { kindOf: isBody },\n  },\n  eligible: { mode: { in: ['normal', 'isolation'] } },\n  requires: ['editAnchors', 'selection'],\n  invoker: {\n    timing: 'immediate',\n    run(deps) {\n      const editAnchors = deps.editAnchors as EditAnchorsDep | undefined;\n      const selection = deps.selection as SelectionApi | undefined;\n      if (!editAnchors || !selection) return;\n      const ids = selection.get() as NodeId[];\n      // Use the dep's editability check rather than poking at node.pose\n      // directly — the dep knows whether a node has an editable polygon\n      // (pose-as-polygon OR data.path) so this picks up both shapes.\n      for (const id of ids) {\n        if (editAnchors.getEditablePath(id)) {\n          editAnchors.setEditingId(id);\n          return;\n        }\n      }\n    },\n  } as ImmediateInvoker,\n  enabled: () => true,\n};\n"],"mappings":";;AAkBA,IAAaA,IAAuD;CAClE,IAAI;CACJ,OAAO;CAMP,gBAAgB;EACd,MAAM;EACN,QAAQ,EAAE,QAAQC,EAAO;CAC3B;CACA,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,WAAW,EAAE,EAAE;CAClD,UAAU,CAAC,eAAe,WAAW;CACrC,SAAS;EACP,QAAQ;EACR,IAAI,GAAM;GACR,IAAMC,IAAcC,EAAK,aACnBC,IAAYD,EAAK;GACvB,IAAI,CAACD,KAAe,CAACE,GAAW;GAChC,IAAMC,IAAMD,EAAU,IAAI;GAI1B,KAAK,IAAME,KAAMD,GACf,IAAIH,EAAY,gBAAgBI,CAAE,GAAG;IACnC,EAAY,aAAaA,CAAE;IAC3B;GACF;EAEJ;CACF;CACA,eAAe;AACjB"}

package/dist/interactions/actions/defaults/enterTextEdit.js

@@ -0,0 +1,20 @@
+//#region src/interactions/actions/defaults/enterTextEdit.ts
+var e = {
+	id: "enterTextEdit",
+	label: "Enter text edit",
+	eligible: { mode: { in: ["normal", "isolation"] } },
+	requires: ["textEdit", "selection"],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			let t = e.selection?.get() ?? [];
+			if (t.length !== 1) return;
+			let n = t[0], r = e.textEdit;
+			r && (!r.isTextNode || r.isTextNode(n)) && r.startEdit(n);
+		}
+	}
+};
+//#endregion
+export { e as enterTextEditAction };
+
+//# sourceMappingURL=enterTextEdit.js.map

package/dist/interactions/actions/defaults/enterTextEdit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enterTextEdit.js","names":["enterTextEditAction","sel","deps","id","textEdit"],"sources":["../../../../src/interactions/actions/defaults/enterTextEdit.ts"],"sourcesContent":["/**\n * `enterTextEditAction` — immediate Action descriptor for entering in-place\n * text editing on a selected text node.\n *\n * ## Status: REAL\n *\n * Fires via `useTextTool.bindings` when the user clicks on a\n * selected text node. Calls `deps.textEdit.startEdit(id)` to activate the\n * contenteditable overlay managed by `useTextEdit` / `useSceneTextEdit`.\n *\n * ## No defaultBinding / defaultBinding\n *\n * This action has no ambient key or gesture binding — it fires ONLY via\n * `useTextTool`'s `Tool.bindings` entry:\n *\n * ```ts\n * bindings: [\n *   { spec: { kind: 'click', target: 'selected-body' }, actionId: 'enterTextEdit' },\n * ]\n * ```\n *\n * Keeping it binding-free avoids ambient double-fire and scopes the action to\n * the text tool context where `classifyTarget` is already wired.\n *\n * ## Self-guard: only act on text nodes\n *\n * The `'selected-body'` target yields a match for any selected node kind. To\n * avoid entering text-edit mode when the text tool happens to have a non-text\n * node selected, the action self-guards via an optional `isTextNode` predicate\n * on `TextEditDep`:\n *\n * - When `isTextNode` is absent: action fires unconditionally (the binding\n *   spec is the real gate — consumers should only bind this action from the\n *   text tool).\n * - When `isTextNode(id)` returns `false`: action is a no-op for that node.\n *\n * ### Pre-filtering at dispatch time\n *\n * `classifyTarget` now surfaces node kind, so a binding can pre-filter instead\n * of relying on the self-guard:\n *\n * ```ts\n * { spec: { kind: 'click', target: 'kind:text:selected' }, actionId: 'enterTextEdit' }\n * ```\n *\n * That reads the *routing trait's* kind, so it matches whatever names the\n * consumer registered in `<SceneCanvas routing>` — `'text'` under the kit's\n * inferred default. `isTextNode` stays on `TextEditDep` because it also covers\n * consumers who bind the broader `'selected-body'` target, and because it is\n * the only guard for a consumer who opted out of routing entirely.\n *\n * ## Migration plan for useTextTool\n *\n * When wiring `useTextTool` to `Tool.bindings`:\n *\n * 1. Add to `useTextTool`'s `bindings`:\n *    ```ts\n *    { spec: { kind: 'click', target: 'selected-body' }, actionId: 'enterTextEdit' }\n *    ```\n * 2. Register a `textEdit` dep sourced from the `useTextEdit` / `useSceneTextEdit`\n *    return value, plus an `isTextNode` predicate that checks `data.kind === 'text'`\n *    (or however the consumer identifies text nodes).\n * 3. The existing `hitExisting` gate in `useTextTool`'s click route becomes\n *    redundant — remove it in the same pass.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport type { TextEditDep } from '../depSchema';\nimport type { NodeId } from 'core/scene/types';\n\n// ---------------------------------------------------------------------------\n// TextEditDep\n// ---------------------------------------------------------------------------\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `enterTextEdit` Action.\n *\n * Requires dep-schema entries: `textEdit`, `selection`.\n *\n * No `defaultBinding` / `defaultBinding` — fires only via `Tool.bindings`.\n * Self-guards via `TextEditDep.isTextNode` when provided.\n */\nexport const enterTextEditAction: Action & { requires: string[] } = {\n  id: 'enterTextEdit',\n  label: 'Enter text edit',\n  // No defaultBinding / defaultBinding — fires only via Tool.bindings.\n  eligible: { mode: { in: ['normal', 'isolation'] } },\n  requires: ['textEdit', 'selection'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const sel = (deps.selection as { get(): NodeId[] } | undefined)?.get() ?? [];\n      if (sel.length !== 1) return;\n\n      const id = sel[0];\n      const textEdit = deps.textEdit as TextEditDep | undefined;\n      if (!textEdit) return;\n\n      // Self-guard: skip non-text nodes when the predicate is supplied.\n      if (textEdit.isTextNode && !textEdit.isTextNode(id)) return;\n\n      textEdit.startEdit(id);\n    },\n  },\n};\n"],"mappings":";AAuFA,IAAaA,IAAuD;CAClE,IAAI;CACJ,OAAO;CAEP,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,WAAW,EAAE,EAAE;CAClD,UAAU,CAAC,YAAY,WAAW;CAClC,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,IAAMC,IAAOC,EAAK,WAA+C,IAAI,KAAK,CAAC;GAC3E,IAAID,EAAI,WAAW,GAAG;GAEtB,IAAME,IAAKF,EAAI,IACTG,IAAWF,EAAK;GACtB,AAAKE,MAGD,GAAS,cAAeA,EAAS,WAAWD,CAAE,MAElDC,EAAS,UAAUD,CAAE;EACvB;CACF;AACF"}

package/dist/interactions/actions/defaults/escape.js

@@ -0,0 +1,26 @@
+import { ActionDisabledReason as e } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/escape.ts
+var t = {
+	id: "escape",
+	label: "Escape",
+	defaultBinding: {
+		kind: "key",
+		key: "Escape",
+		phase: [{
+			channel: "*",
+			phase: "initial"
+		}]
+	},
+	requires: ["selection", "editAnchors"],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			(e.selection?.get() ?? []).length !== 0 && e.selection?.set([]);
+		}
+	},
+	enabled: (t) => t?.editAnchors?.editingId || ((t?.selection)?.get() ?? []).length === 0 ? e.NotApplicable : !0
+};
+//#endregion
+export { t as escapeAction };
+
+//# sourceMappingURL=escape.js.map

package/dist/interactions/actions/defaults/escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.js","names":["escapeAction","deps","ActionDisabledReason"],"sources":["../../../../src/interactions/actions/defaults/escape.ts"],"sourcesContent":["import type { NodeId } from 'core/scene/types';\nimport type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { EditAnchorsDep } from '../depSchema';\n\n/**\n * @experimental\n * Static descriptor for the `escape` Action. Clears selection.\n */\n// No `eligible` field → always eligible. Escape works in every mode; the\n// runtime `enabled` thunk handles the path-edit defer-to-exit case.\nexport const escapeAction: Action & { requires: string[] } = {\n  id: 'escape',\n  label: 'Escape',\n  // Gated to \"no tool is engaged\" so a mid-drag Escape goes to\n  // `cancelGestureAction` (cancels the drag) instead of clearing\n  // selection.\n  defaultBinding: {\n    kind: 'key',\n    key: 'Escape',\n    phase: [{ channel: '*', phase: 'initial' }],\n  },\n  requires: ['selection', 'editAnchors'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const sel = (deps.selection as { get(): NodeId[] } | undefined)?.get() ?? [];\n      if (sel.length === 0) return;\n      (deps.selection as { set(ids: NodeId[]): void } | undefined)?.set([]);\n    },\n  },\n  // Defer to `exitPathEditAction` while path-anchor edit mode is active.\n  // Otherwise the more-specific phase qualifier on this binding would beat\n  // `exitPathEdit`'s bare key spec, swallowing the Escape that should leave\n  // edit mode. With this gate, `escape` reports a disabled reason in that\n  // case and the dispatcher falls through to `exitPathEdit`.\n  // With nothing selected there is nothing to clear, so the press falls\n  // through to `tool.resetToDefault` instead of being spent here.\n  enabled: (deps) => {\n    const editAnchors = deps?.editAnchors as EditAnchorsDep | undefined;\n    if (editAnchors?.editingId) return ActionDisabledReason.NotApplicable;\n    const sel = (deps?.selection as { get(): NodeId[] } | undefined)?.get() ?? [];\n    if (sel.length === 0) return ActionDisabledReason.NotApplicable;\n    return true;\n  },\n};\n"],"mappings":";;AAWA,IAAaA,IAAgD;CAC3D,IAAI;CACJ,OAAO;CAIP,gBAAgB;EACd,MAAM;EACN,KAAK;EACL,OAAO,CAAC;GAAE,SAAS;GAAK,OAAO;EAAU,CAAC;CAC5C;CACA,UAAU,CAAC,aAAa,aAAa;CACrC,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GAEb,CADaC,EAAK,WAA+C,IAAI,KAAK,CAAC,EAAA,CACnE,WAAW,KACnBA,EAAM,WAAwD,IAAI,CAAC,CAAC;EACtE;CACF;CAQA,UAAU,MACYA,GAAM,aACT,eACJA,GAAM,UAAA,EAA+C,IAAI,KAAK,CAAC,EAAA,CACpE,WAAW,IAAUC,EAAqB,gBAC3C;AAEX"}

package/dist/interactions/actions/defaults/exitPathEdit.js

@@ -0,0 +1,22 @@
+//#region src/interactions/actions/defaults/exitPathEdit.ts
+var e = {
+	id: "exitPathEdit",
+	label: "Exit path edit",
+	defaultBinding: {
+		kind: "key",
+		key: "Escape"
+	},
+	eligible: { mode: "path-edit" },
+	requires: ["editAnchors"],
+	invoker: {
+		timing: "immediate",
+		run(e) {
+			e.editAnchors?.setEditingId(null);
+		}
+	},
+	enabled: () => !0
+};
+//#endregion
+export { e as exitPathEditAction };
+
+//# sourceMappingURL=exitPathEdit.js.map

package/dist/interactions/actions/defaults/exitPathEdit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exitPathEdit.js","names":["exitPathEditAction"],"sources":["../../../../src/interactions/actions/defaults/exitPathEdit.ts"],"sourcesContent":["/**\n * `exitPathEditAction` — immediate Action that exits path-anchor edit\n * mode. Bound to Escape by default; companion to `enterPathEditAction`.\n * Clears `editAnchors.editingId`, which the gesture-side hit-test and\n * `pathEditingOverlayLayer` both gate on.\n *\n * Always enabled — calling it when no path is being edited is a no-op.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport type { ImmediateInvoker } from '@weasel-js/routing';\nimport type { EditAnchorsDep } from '../depSchema';\n\nexport const exitPathEditAction: Action & { requires: string[] } = {\n  id: 'exitPathEdit',\n  label: 'Exit path edit',\n  defaultBinding: { kind: 'key', key: 'Escape' },\n  eligible: { mode: 'path-edit' },\n  requires: ['editAnchors'],\n  invoker: {\n    timing: 'immediate',\n    run(deps) {\n      const editAnchors = deps.editAnchors as EditAnchorsDep | undefined;\n      editAnchors?.setEditingId(null);\n    },\n  } as ImmediateInvoker,\n  enabled: () => true,\n};\n"],"mappings":";AAaA,IAAaA,IAAsD;CACjE,IAAI;CACJ,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;CAAS;CAC7C,UAAU,EAAE,MAAM,YAAY;CAC9B,UAAU,CAAC,aAAa;CACxB,SAAS;EACP,QAAQ;EACR,IAAI,GAAM;GAER,EADyB,aACZ,aAAa,IAAI;EAChC;CACF;CACA,eAAe;AACjB"}

package/dist/interactions/actions/defaults/flip.js

@@ -0,0 +1,119 @@
+import { createTransformOp as e } from "../../../core/ops/transform.js";
+import { geometryDataOp as t } from "../geometryProjection.js";
+import { unionAABB as n } from "../../../core/geometry/unionBounds.js";
+import { visualBoundsViaDescriptor as r } from "../../../core/geometry/poseDescriptor.js";
+import { poseDescriptorOf as i } from "../poseDescriptorDep.js";
+import { defaultCommitAdapter as a } from "../defaultCommitAdapter.js";
+import { scenePoseFrame as o } from "../poseFrame.js";
+import { FlipXIcon as s, FlipYIcon as c } from "./icons/editIcons.js";
+import { requiresSelection as l } from "./requiresSelection.js";
+import { flipPoseAboutBounds as u, flipPoseViaDescriptor as d } from "../flip/helpers.js";
+import { actionReferenceSources as f, resolveSpatialReference as p } from "../spatialReference.js";
+import { multiply as m, rotate as h, translate as g } from "@weasel-js/geom";
+import { createElement as _ } from "react";
+//#region src/interactions/actions/defaults/flip.ts
+function v(e, t, n, r) {
+	let i = t.local(n, {
+		x: r.x + r.width / 2,
+		y: r.y + r.height / 2,
+		width: 0,
+		height: 0,
+		rotation: 0
+	}), a = i.rotation ?? 0, o = e === "x" ? [
+		-1,
+		0,
+		0,
+		1,
+		0,
+		0
+	] : [
+		1,
+		0,
+		0,
+		-1,
+		0,
+		0
+	], s = m(m(h(a), o), h(-a));
+	return m(g(i.x, i.y), m(s, g(-i.x, -i.y)));
+}
+function y(i, s, c, l, m, h, g, _, y, b) {
+	let x = i.get();
+	if (x.length === 0) return;
+	let S = o(s, _), C = /* @__PURE__ */ new Map();
+	for (let e of x) s.get(e) !== void 0 && C.set(e, S.world(e));
+	let w = null;
+	if (l === "union") w = n([...C.values()].map((e) => r(e, g)));
+	else if (l !== "each" && (w = p(l, f(y, b, s, S, g)), w === null)) return;
+	let T = [];
+	for (let n of x) {
+		let r = s.get(n);
+		if (!r) continue;
+		let i = C.get(n), a = w ? u(i, c, g, w) : d(i, c, g);
+		T.push(e({
+			id: n,
+			from: r.pose,
+			to: S.local(n, a),
+			label: "Flip"
+		}));
+		let o = w ?? g.getBounds(i), l = t(h, {
+			id: n,
+			data: r.data,
+			pose: r.pose
+		}, v(c, S, n, o), "Flip");
+		l && T.push(l);
+	}
+	T.length !== 0 && (m ? m(T, "Flip") : s.applyBatch(T, "Flip", a(s, i.adapterMethods)));
+}
+var b = {
+	id: "flip",
+	label: "Flip",
+	group: "flip",
+	variants: [{
+		key: "x",
+		label: "Flip Horizontal",
+		icon: _(s),
+		params: { axis: "x" }
+	}, {
+		key: "y",
+		label: "Flip Vertical",
+		icon: _(c),
+		params: { axis: "y" }
+	}],
+	defaultBinding: [{
+		spec: {
+			kind: "key",
+			key: ["h", "H"],
+			mods: { shift: !0 }
+		},
+		opts: { params: { axis: "x" } }
+	}, {
+		spec: {
+			kind: "key",
+			key: ["v", "V"],
+			mods: { shift: !0 }
+		},
+		opts: { params: { axis: "y" } }
+	}],
+	eligible: { capability: "transforms-selection" },
+	requires: [
+		"selection",
+		"scene",
+		"applyOps",
+		"geometryProjection",
+		"poseDescriptor",
+		"poseComposition",
+		"pointer"
+	],
+	invoker: {
+		timing: "immediate",
+		run: (e, t) => {
+			let n = t?.axis ?? "x", r = t?.pivot ?? "each", a = e.selection, o = e.scene, s = e.applyOps, c = e.geometryProjection;
+			a && o && y(a, o, n, r, s, c, i(e.poseDescriptor), e.poseComposition, t, e.pointer);
+		}
+	},
+	enabled: l
+};
+//#endregion
+export { b as flipAction };
+
+//# sourceMappingURL=flip.js.map

package/dist/interactions/actions/defaults/flip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flip.js","names":["localMirror","at","frame","id","pivotWorld","theta","mirror","axis","turned","multiply","rotate","translate","flipSelection","ids","selection","scenePoseFrame","scene","poseComposition","worlds","sharedPivot","pivot","unionAABB","visualBoundsViaDescriptor","p","geom","resolveSpatialReference","actionReferenceSources","params","pointer","ops","node","world","flipped","flipPoseAboutBounds","flipPoseViaDescriptor","createTransformOp","g","dataOp","geometryDataOp","geometryProjection","applyOps","defaultCommitAdapter","flipAction","createElement","FlipXIcon","FlipYIcon","deps","poseDescriptorOf","requiresSelection"],"sources":["../../../../src/interactions/actions/defaults/flip.ts"],"sourcesContent":["import type { Scene } from 'core/scene/types';\nimport { createElement } from 'react';\nimport { FlipXIcon, FlipYIcon } from './icons/editIcons';\nimport type { Op } from 'core/ops/types';\nimport { multiply, rotate, translate, type Mat3 } from '@weasel-js/geom';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { PoseDescriptor } from '../resize/geometry';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport {\n  flipPoseAboutBounds,\n  flipPoseViaDescriptor,\n  type FlipAxis,\n  type FlipPivot,\n} from '../flip/helpers';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport { visualBoundsViaDescriptor } from '../align/align';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { actionReferenceSources, resolveSpatialReference } from '../spatialReference';\nimport type { PointerContextValue } from 'features/pointer/PointerContext';\nimport type { RectPose } from 'core/scene/types';\nimport type { Action } from '@weasel-js/routing';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { requiresSelection } from './requiresSelection';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { geometryDataOp, type GeometryProjection } from '../geometryProjection';\n\n/**\n * The world mirror about `axis` through the center of `pivotWorld`, written in\n * the frame `id` stores its data in. `geometryProjection.transform` is given\n * the affine the node's own pose underwent, and data-held geometry is local —\n * so a world mirror has to be conjugated by the frame or an asymmetric shape\n * reflects across the wrong line while its pose lands correctly.\n *\n * The frame's turn comes back as the rotation on a rebased zero-size pose at\n * the pivot point, so no composition strategy has to expose one.\n */\nfunction localMirror(\n  axis: FlipAxis,\n  frame: PoseFrame<unknown>,\n  id: Parameters<PoseFrame<unknown>['local']>[0],\n  pivotWorld: { x: number; y: number; width: number; height: number },\n): Mat3 {\n  const at = frame.local(id, {\n    x: pivotWorld.x + pivotWorld.width / 2,\n    y: pivotWorld.y + pivotWorld.height / 2,\n    width: 0,\n    height: 0,\n    rotation: 0,\n  }) as RectPose;\n  const theta = at.rotation ?? 0;\n  const mirror: Mat3 = axis === 'x' ? [-1, 0, 0, 1, 0, 0] : [1, 0, 0, -1, 0, 0];\n  const turned = multiply(multiply(rotate(theta), mirror), rotate(-theta));\n  return multiply(translate(at.x, at.y), multiply(turned, translate(-at.x, -at.y)));\n}\n\n/**\n * Flip the current selection in `scene` along `axis`, using the\n * `poseDescriptor` dep. Called from `flipAction.invoker.run`.\n *\n * Builds one `createTransformOp` per selected node (from = pre-flip pose,\n * to = flipped pose) and routes the batch through the consumer commit hook.\n * Mirrors `moveAction`/`nudge`'s `commitOps` helper: when `deps.applyOps` is\n * present the ops route through the consumer's history (one undo entry there);\n * otherwise they apply straight to the scene's own history via\n * `scene.applyBatch` + `defaultCommitAdapter`. Either way the whole flip is a\n * single batch → one undo entry, preserving the old `scene.batch('Flip', …)`\n * semantics exactly.\n *\n * Pivot: `'each'` (per-item own AABB) unless the caller passes `'union'`,\n * which mirrors every pose about the selection's *visual* union AABB — the\n * rotated ink extents — so items swap sides as well as reflect, or a\n * `SpatialReference`, which mirrors about the center of what it names. A rotated\n * member's own mirrored position needs no expansion: `axisAlignedBounds`\n * keeps the stored box's centre, so mirroring either box lands the same place.\n */\nfunction flipSelection(\n  selection: SelectionApi,\n  scene: Scene<unknown, string, unknown>,\n  axis: FlipAxis,\n  pivot: FlipPivot,\n  applyOps: ((ops: Op[], label: string) => void) | undefined,\n  geometryProjection: GeometryProjection | undefined,\n  geom: PoseDescriptor<unknown>,\n  poseComposition: unknown,\n  params: Record<string, unknown> | undefined,\n  pointer: PointerContextValue | undefined,\n): void {\n  const ids = selection.get();\n  if (ids.length === 0) return;\n  const frame = scenePoseFrame(scene, poseComposition);\n\n  const worlds = new Map<string, unknown>();\n  for (const id of ids) {\n    if (scene.get(id) !== undefined) worlds.set(id as string, frame.world(id));\n  }\n  let sharedPivot: ReturnType<typeof unionAABB> = null;\n  if (pivot === 'union') {\n    sharedPivot = unionAABB([...worlds.values()].map((p) => visualBoundsViaDescriptor(p, geom)));\n  } else if (pivot !== 'each') {\n    sharedPivot = resolveSpatialReference(pivot, actionReferenceSources(params, pointer, scene, frame, geom));\n    if (sharedPivot === null) return;\n  }\n\n  // Read poses BEFORE building ops so each op's `from` is the pre-flip value\n  // (the same value the old direct mutation captured implicitly).\n  const ops: Op[] = [];\n  for (const id of ids) {\n    const node = scene.get(id);\n    if (!node) continue;\n    const world = worlds.get(id as string)!;\n    const flipped = sharedPivot\n      ? flipPoseAboutBounds(world, axis, geom, sharedPivot)\n      : flipPoseViaDescriptor(world, axis, geom);\n    ops.push(createTransformOp<unknown>({\n      id: id as string,\n      from: node.pose,\n      to: frame.local(id, flipped),\n      label: 'Flip',\n    }));\n    // Mirror the data-held geometry about the SAME pivot the pose flip uses,\n    // so a wired geometryProjection reflects the contents in lock-step with\n    // the frame. A pose-only flip of a bare-AABB pose is identity, so this\n    // data op is the only way an asymmetric shape actually mirrors.\n    const g = sharedPivot ?? geom.getBounds(world);\n    const dataOp = geometryDataOp(\n      geometryProjection,\n      { id: id as string, data: node.data, pose: node.pose },\n      localMirror(axis, frame, id, g),\n      'Flip',\n    );\n    if (dataOp) ops.push(dataOp);\n  }\n  if (ops.length === 0) return;\n\n  if (applyOps) applyOps(ops, 'Flip');\n  else scene.applyBatch(ops, 'Flip', defaultCommitAdapter(scene, selection.adapterMethods));\n}\n\n/**\n * @experimental\n * Static descriptor for the unified `flip` Action.\n *\n * Collapses the old `flip.horizontal` and `flip.vertical` pair into one action\n * with two parametric gesture bindings. The axis (`'x'` | `'y'`) is carried in\n * `opts.params.axis` and forwarded to `invoker.run` by the dispatcher, as is\n * the optional `opts.params.pivot` (a `FlipPivot`, default `'each'`).\n *\n * Requires dep-schema entries: `selection`, `scene`.\n */\nexport const flipAction: Action & { requires: string[] } = {\n  id: 'flip',\n  label: 'Flip',\n  group: 'flip',\n  variants: [\n    { key: 'x', label: 'Flip Horizontal', icon: createElement(FlipXIcon), params: { axis: 'x' } },\n    { key: 'y', label: 'Flip Vertical', icon: createElement(FlipYIcon), params: { axis: 'y' } },\n  ],\n  defaultBinding: [\n    { spec: { kind: 'key', key: ['h', 'H'], mods: { shift: true } }, opts: { params: { axis: 'x' } } },\n    { spec: { kind: 'key', key: ['v', 'V'], mods: { shift: true } }, opts: { params: { axis: 'y' } } },\n  ],\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'applyOps', 'geometryProjection', 'poseDescriptor', 'poseComposition', 'pointer'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps, params) => {\n      const axis = (params?.axis as FlipAxis | undefined) ?? 'x';\n      const pivot = (params?.pivot as FlipPivot | undefined) ?? 'each';\n      const selection = deps.selection as SelectionApi | undefined;\n      const scene = deps.scene as Scene<unknown, string, unknown> | undefined;\n      const applyOps = deps.applyOps as ((ops: Op[], label: string) => void) | undefined;\n      const geometryProjection = deps.geometryProjection as GeometryProjection | undefined;\n      if (!selection || !scene) return;\n      flipSelection(\n        selection, scene, axis, pivot, applyOps, geometryProjection,\n        poseDescriptorOf(deps.poseDescriptor), deps.poseComposition,\n        params, deps.pointer as PointerContextValue | undefined,\n      );\n    },\n  },\n  enabled: requiresSelection,\n};\n"],"mappings":"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"}

package/dist/interactions/actions/defaults/freshNodeId.js

@@ -0,0 +1,10 @@
+import { asNodeId as e } from "../../../core/scene/types.js";
+//#region src/interactions/actions/defaults/freshNodeId.ts
+var t = 0;
+function n() {
+	return e(`n${(t++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
+}
+//#endregion
+export { n as freshNodeId };
+
+//# sourceMappingURL=freshNodeId.js.map

package/dist/interactions/actions/defaults/freshNodeId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"freshNodeId.js","names":["counter","freshNodeId","asNodeId"],"sources":["../../../../src/interactions/actions/defaults/freshNodeId.ts"],"sourcesContent":["import type { NodeId } from 'core/scene/types';\nimport { asNodeId } from 'core/scene/types';\n\nlet counter = 0;\n\n/**\n * Mint a fresh `NodeId` for a node an action materializes itself.\n *\n * Actions that build `createInsertOp` ops can't let the scene generate the id\n * the way `scene.add(spec)` does — the op carries a whole node, so the id has\n * to exist before the op does. Mirrors the scene's own `n{counter}-{random}`\n * scheme, which `core/scene/scene.ts` keeps module-private.\n */\nexport function freshNodeId(): NodeId {\n  return asNodeId(`n${(counter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);\n}\n"],"mappings":";;AAGA,IAAIA,IAAU;AAUd,SAAgBC,IAAsB;CACpC,OAAOC,EAAS,KAAK,IAAA,CAAW,SAAS,EAAE,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,GAAG;AAC1F"}

package/dist/interactions/actions/defaults/group.js

@@ -0,0 +1,131 @@
+import { asNodeId as e } from "../../../core/scene/types.js";
+import { createTransformOp as t } from "../../../core/ops/transform.js";
+import { createReparentOp as n } from "../../../core/ops/reparent.js";
+import { unionBounds as r } from "../../../core/geometry/unionBounds.js";
+import { visualBoundsViaDescriptor as i } from "../../../core/geometry/poseDescriptor.js";
+import { poseDescriptorOf as a } from "../poseDescriptorDep.js";
+import { defaultCommitAdapter as o } from "../defaultCommitAdapter.js";
+import { scenePoseFrame as s } from "../poseFrame.js";
+import { createInsertOp as c } from "../../../core/ops/create.js";
+import { GroupIcon as l, UngroupIcon as u } from "./icons/editIcons.js";
+import { requiresSelection as d } from "./requiresSelection.js";
+import { UNION_OF_CHILDREN as f, unionOfChildren as p } from "../../../core/scene/kitRegistry.js";
+import { createElement as m } from "react";
+import { ActionDisabledReason as h } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/group.ts
+var g = 0;
+function _() {
+	return e(`n${(g++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);
+}
+var v = {
+	id: "group",
+	label: "Group",
+	icon: m(l),
+	group: "structure",
+	defaultBinding: {
+		kind: "key",
+		key: "g",
+		mods: { mod: !0 }
+	},
+	eligible: { capability: "edits-page" },
+	requires: [
+		"scene",
+		"selection",
+		"applyOps",
+		"poseDescriptor",
+		"poseComposition"
+	],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			let l = e.selection, u = e.scene, d = e.applyOps;
+			if (!l || !u) return;
+			let m = l.get();
+			if (m.length === 0) return;
+			let h = m.map((e) => u.get(e)).filter((e) => e !== void 0);
+			if (h.length === 0 || new Set(h.map((e) => e.layer)).size > 1) return;
+			let g = h[0].layer, v = new Set(h.map((e) => e.parent)).size === 1 ? h[0].parent : null, y = a(e.poseDescriptor), b = s(u, e.poseComposition), x = /* @__PURE__ */ new Map();
+			for (let e of h) x.set(e.id, b.world(e.id));
+			let S = r([...x.values()].map((e) => i(e, y))), C = S === null ? h[0].pose : y.fromBounds(S, h[0].pose), w = b.localUnder(v, C), T = b.pc.closure === "identity", E = u.registry.derivePose?.[f] ?? p, D = _(), O = [c({
+				node: {
+					id: D,
+					kind: "container",
+					layer: g,
+					pose: w,
+					data: {},
+					parent: v ?? null,
+					...T ? {
+						dependsOn: "children",
+						derivePose: E
+					} : {}
+				},
+				label: "Group"
+			})];
+			for (let e of h) O.push(n({
+				id: e.id,
+				fromParentId: e.parent ?? null,
+				toParentId: D,
+				label: "Group"
+			})), !T && O.push(t({
+				id: e.id,
+				from: e.pose,
+				to: b.pc.decompose(C, x.get(e.id)),
+				label: "Group"
+			}));
+			d ? d(O, "Group") : u.applyBatch(O, "Group", o(u, l.adapterMethods)), l.set([D]);
+		}
+	},
+	enabled: d
+}, y = {
+	id: "ungroup",
+	label: "Ungroup",
+	icon: m(u),
+	group: "structure",
+	defaultBinding: {
+		kind: "key",
+		key: "g",
+		mods: {
+			mod: !0,
+			shift: !0
+		}
+	},
+	eligible: { capability: "edits-page" },
+	requires: [
+		"scene",
+		"selection",
+		"poseComposition"
+	],
+	invoker: {
+		timing: "immediate",
+		run: (e) => {
+			let t = e.selection, n = e.scene;
+			if (!t || !n) return;
+			let r = t.get();
+			if (r.length === 0) return;
+			let i = r.filter((e) => n.get(e)?.kind === "container");
+			if (i.length === 0) return;
+			let a = s(n, e.poseComposition), o = a.pc.closure === "identity";
+			n.batch("Ungroup", () => {
+				let e = [];
+				for (let t of i) {
+					let r = n.get(t);
+					if (!r || r.kind !== "container") continue;
+					let i = r.parent ?? null, s = i === null ? n.roots.indexOf(t) : n.childrenOf(i).indexOf(t), c = [...n.childrenOf(t)], l = /* @__PURE__ */ new Map();
+					if (!o) for (let e of c) l.set(e, a.world(e));
+					c.forEach((t, r) => {
+						n.move(t, i, s < 0 ? void 0 : s + r), o || n.setPose(t, a.localUnder(i, l.get(t))), e.push(t);
+					}), n.remove(t);
+				}
+				t.set(e);
+			});
+		}
+	},
+	enabled: (e) => {
+		let t = e?.selection, n = e?.scene;
+		return t?.get().some((e) => n?.get(e)?.kind === "container") ? !0 : h.NotApplicable;
+	}
+};
+//#endregion
+export { v as groupAction, y as ungroupAction };
+
+//# sourceMappingURL=group.js.map

package/dist/interactions/actions/defaults/group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.js","names":["containerIdCounter","freshContainerId","asNodeId","groupAction","createElement","GroupIcon","selection","deps","scene","applyOps","ids","nodes","id","n","layer","parent","d","poseDescriptorOf","frame","scenePoseFrame","worlds","node","union","unionBounds","visualBoundsViaDescriptor","p","containerWorldPose","pose","absolutePoses","derive","UNION_OF_CHILDREN","unionOfChildren","containerId","ops","createInsertOp","createReparentOp","createTransformOp","defaultCommitAdapter","requiresSelection","ungroupAction","UngroupIcon","containers","freed","container","baseIndex","children","childId","i","ActionDisabledReason"],"sources":["../../../../src/interactions/actions/defaults/group.ts"],"sourcesContent":["import type { Node, NodeId, Scene } from 'core/scene/types';\nimport { createElement } from 'react';\nimport { GroupIcon, UngroupIcon } from './icons/editIcons';\nimport { asNodeId } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Op } from 'core/ops/types';\nimport { createInsertOp } from 'core/ops/create';\nimport { createReparentOp } from 'core/ops/reparent';\nimport { unionBounds } from 'core/geometry/unionBounds';\nimport { unionOfChildren, UNION_OF_CHILDREN } from 'core/scene/kitRegistry';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport { visualBoundsViaDescriptor } from '../resize/geometry';\nimport { createTransformOp } from 'core/ops/transform';\nimport { ActionDisabledReason, type Action } from '@weasel-js/routing';\nimport { requiresSelection } from './requiresSelection';\nimport { scenePoseFrame } from '../poseFrame';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\n\n/** Mint a fresh NodeId for a new container. The old `scene.add(spec)` path\n *  (no explicit id) let the scene generate a random id, so the produced id\n *  was never deterministic/observable — pre-generating one here to feed the\n *  insert op preserves behavior. Mirrors the scene's default id scheme\n *  (`n{counter}-{random}`), which `core/scene/scene.ts` keeps module-private.\n *  Same approach as `cloneAction`. */\nlet containerIdCounter = 0;\nfunction freshContainerId(): NodeId {\n  return asNodeId(`n${(containerIdCounter++).toString(36)}-${Math.random().toString(36).slice(2, 8)}`);\n}\n\n/**\n * @experimental\n * Static descriptor for the `group` Action.\n *\n * \"Group\" here means a structural `ContainerNode` — the real group that\n * round-trips to SVG `<g>` — not the legacy membership-list. `run` creates a\n * fresh container and reparents the current selection under it as a single\n * undoable batch.\n *\n * Grouping never moves a member on screen. The container takes the world\n * envelope of its members' ink; each member is then re-expressed in that\n * container's frame, which is a no-op only when the scene composes poses by\n * identity.\n *\n * Under identity the container's pose is also *derived* from its members, so\n * it tracks one that moves later instead of freezing at the moment the group\n * was made. Under any other composition that derivation is circular — the\n * members' poses are expressed in the container's own frame — so the container\n * keeps the authored envelope instead. Making it track its members again needs\n * its own decision; see the group-as-frame design doc.\n */\nexport const groupAction: Action & { requires: string[] } = {\n  id: 'group',\n  label: 'Group',\n  icon: createElement(GroupIcon),\n  group: 'structure',\n  defaultBinding: { kind: 'key', key: 'g', mods: { mod: true } },\n  eligible: { capability: 'edits-page' },\n  requires: ['scene', 'selection', 'applyOps', 'poseDescriptor', 'poseComposition'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const selection = deps.selection as SelectionApi | undefined;\n      const scene = deps.scene as Scene<unknown, string, unknown> | undefined;\n      const applyOps = deps.applyOps as ((ops: Op[], label: string) => void) | undefined;\n      if (!selection || !scene) return;\n\n      const ids = selection.get();\n      if (ids.length === 0) return;\n\n      // Resolve nodes; drop any that have gone missing.\n      const nodes = ids\n        .map((id) => scene.get(id as NodeId))\n        .filter((n): n is NonNullable<typeof n> => n !== undefined);\n      if (nodes.length === 0) return;\n\n      // Members must share a layer — containers live on a single layer.\n      const layers = new Set(nodes.map((n) => n.layer));\n      if (layers.size > 1) return;\n      const layer = nodes[0]!.layer;\n\n      // Nest under the shared parent if the members agree, else at the root.\n      const parents = new Set(nodes.map((n) => n.parent));\n      const parent = parents.size === 1 ? nodes[0]!.parent : null;\n\n      // The container takes the world envelope of its members' ink. The\n      // authored pose is only the fallback (an emptied group, a lost registry\n      // key); under identity the derived union is what the scene shows.\n      const d = poseDescriptorOf(deps.poseDescriptor);\n      const frame = scenePoseFrame(scene, deps.poseComposition);\n      const worlds = new Map<NodeId, unknown>();\n      for (const node of nodes) worlds.set(node.id, frame.world(node.id));\n      // Visual, not stored, bounds: a turned member's ink reaches outside its\n      // own box, and the container has to cover what is drawn.\n      const union = unionBounds([...worlds.values()].map((p) => visualBoundsViaDescriptor(p, d)));\n      const containerWorldPose = union === null\n        ? nodes[0]!.pose\n        : d.fromBounds(union, nodes[0]!.pose);\n      const pose = frame.localUnder(parent, containerWorldPose);\n      // Under identity the container is an envelope that tracks its members;\n      // under a composing strategy it is a frame they are re-expressed in.\n      const absolutePoses = frame.pc.closure === 'identity';\n      const derive = scene.registry.derivePose?.[UNION_OF_CHILDREN] ?? unionOfChildren;\n\n      // Build ops mirroring the old direct mutations, in the same order the\n      // `scene.batch('Group', …)` body produced them:\n      //   1. insert the fresh container (the old `scene.add` minted a random\n      //      id; we pre-generate one so the insert op carries a full node —\n      //      the id was never observable, so behavior is preserved);\n      //   2. reparent each selected id under the new container, in selection\n      //      order, capturing each node's PRE-mutation parent as `from`\n      //      (the op captures the sibling slot itself, on apply).\n      // The container must exist before any child reparents into it, so the\n      // insert op is emitted first. A member's pose then follows its reparent,\n      // re-expressed in the container's frame so the member does not move.\n      const containerId = freshContainerId();\n      const ops: Op[] = [\n        createInsertOp<Node<unknown, string, unknown>>({\n          node: {\n            id: containerId,\n            kind: 'container',\n            layer,\n            pose: pose as unknown,\n            data: {} as unknown,\n            parent: parent ?? null,\n            ...(absolutePoses ? { dependsOn: 'children', derivePose: derive } : {}),\n          } as Node<unknown, string, unknown>,\n          label: 'Group',\n        }),\n      ];\n      for (const node of nodes) {\n        ops.push(createReparentOp({\n          id: node.id as string,\n          fromParentId: (node.parent ?? null) as string | null,\n          toParentId: containerId as string,\n          label: 'Group',\n        }));\n        if (absolutePoses) continue;\n        ops.push(createTransformOp<unknown>({\n          id: node.id as string,\n          from: node.pose,\n          to: frame.pc.decompose(containerWorldPose, worlds.get(node.id)!),\n          label: 'Group',\n        }));\n      }\n\n      // Route the batch through the consumer `applyOps` hook when present (so\n      // an app with its own history captures the group as a single undo\n      // entry); otherwise commit straight to the scene's own history via\n      // `scene.applyBatch`. One applyOps / applyBatch call = one undo entry,\n      // matching the prior single `scene.batch('Group', …)`.\n      if (applyOps) applyOps(ops, 'Group');\n      else scene.applyBatch(ops, 'Group', defaultCommitAdapter(scene, selection.adapterMethods));\n\n      // Selection update is selection state, not a scene op — set it after the\n      // commit regardless of which path ran (the old code set it inside the\n      // batch; it was never an undoable scene mutation).\n      selection.set([containerId]);\n    },\n  },\n  enabled: requiresSelection,\n};\n\n/**\n * @experimental\n * Static descriptor for the `ungroup` Action.\n *\n * \"Group\" here means a structural `ContainerNode`. `run` dissolves each\n * selected container by reparenting its children up to the container's own\n * parent (preserving z-order) and removing the now-empty container, as a single\n * undoable batch. Selected non-container nodes are ignored. The freed children\n * become the new selection.\n *\n * A child's pose is expressed in the container's frame, so each one is\n * re-expressed in the frame it lands in and nothing moves on screen.\n */\nexport const ungroupAction: Action & { requires: string[] } = {\n  id: 'ungroup',\n  label: 'Ungroup',\n  icon: createElement(UngroupIcon),\n  group: 'structure',\n  defaultBinding: { kind: 'key', key: 'g', mods: { mod: true, shift: true } },\n  eligible: { capability: 'edits-page' },\n  requires: ['scene', 'selection', 'poseComposition'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps) => {\n      const selection = deps.selection as SelectionApi | undefined;\n      const scene = deps.scene as Scene<unknown, string, unknown> | undefined;\n      if (!selection || !scene) return;\n\n      const ids = selection.get();\n      if (ids.length === 0) return;\n\n      const containers = ids.filter((id) => scene.get(id as NodeId)?.kind === 'container');\n      if (containers.length === 0) return;\n\n      const frame = scenePoseFrame(scene, deps.poseComposition);\n      const absolutePoses = frame.pc.closure === 'identity';\n\n      scene.batch('Ungroup', () => {\n        const freed: NodeId[] = [];\n        for (const containerId of containers) {\n          const container = scene.get(containerId as NodeId);\n          if (!container || container.kind !== 'container') continue;\n\n          const parent = container.parent ?? null;\n          const baseIndex =\n            parent === null\n              ? scene.roots.indexOf(containerId as NodeId)\n              : scene.childrenOf(parent).indexOf(containerId as NodeId);\n\n          const children = [...scene.childrenOf(containerId as NodeId)];\n          // Read every world pose before the first move: the frame resolves\n          // through the live scene, and the container is about to leave it.\n          const worlds = new Map<NodeId, unknown>();\n          if (!absolutePoses) {\n            for (const childId of children) worlds.set(childId, frame.world(childId));\n          }\n          children.forEach((childId, i) => {\n            scene.move(childId, parent, baseIndex < 0 ? undefined : baseIndex + i);\n            if (!absolutePoses) {\n              scene.setPose(childId, frame.localUnder(parent, worlds.get(childId)!) as never);\n            }\n            freed.push(childId);\n          });\n\n          scene.remove(containerId as NodeId);\n        }\n        selection.set(freed);\n      });\n    },\n  },\n  enabled: (deps) => {\n    const selection = deps?.selection as SelectionApi | undefined;\n    const scene = deps?.scene as Scene<unknown, string, unknown> | undefined;\n    const any = selection?.get().some((id) => scene?.get(id as NodeId)?.kind === 'container');\n    return any ? true : ActionDisabledReason.NotApplicable;\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;AAwBA,IAAIA,IAAqB;AACzB,SAASC,IAA2B;CAClC,OAAOC,EAAS,KAAK,IAAA,CAAsB,SAAS,EAAE,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,GAAG;AACrG;AAuBA,IAAaC,IAA+C;CAC1D,IAAI;CACJ,OAAO;CACP,MAAMC,EAAcC,CAAS;CAC7B,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;EAAK,MAAM,EAAE,KAAK,GAAK;CAAE;CAC7D,UAAU,EAAE,YAAY,aAAa;CACrC,UAAU;EAAC;EAAS;EAAa;EAAY;EAAkB;CAAiB;CAChF,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,IAAMC,IAAYC,EAAK,WACjBC,IAAQD,EAAK,OACbE,IAAWF,EAAK;GACtB,IAAI,CAACD,KAAa,CAACE,GAAO;GAE1B,IAAME,IAAMJ,EAAU,IAAI;GAC1B,IAAII,EAAI,WAAW,GAAG;GAGtB,IAAMC,IAAQD,EACX,KAAK,MAAOF,EAAM,IAAII,CAAY,CAAC,CAAC,CACpC,QAAQ,MAAkCC,MAAM,KAAA,CAAS;GAK5D,IAJIF,EAAM,WAAW,KAIjB,IADe,IAAIA,EAAM,KAAK,MAAME,EAAE,KAAK,CAC3C,CAAA,CAAO,OAAO,GAAG;GACrB,IAAMC,IAAQH,EAAM,EAAE,CAAE,OAIlBI,IAAS,IADK,IAAIJ,EAAM,KAAK,MAAME,EAAE,MAAM,CAClC,CAAA,CAAQ,SAAS,IAAIF,EAAM,EAAE,CAAE,SAAS,MAKjDK,IAAIC,EAAiBV,EAAK,cAAc,GACxCW,IAAQC,EAAeX,GAAOD,EAAK,eAAe,GAClDa,oBAAS,IAAI,IAAqB;GACxC,KAAK,IAAMC,KAAQV,GAAO,EAAO,IAAIU,EAAK,IAAIH,EAAM,MAAMG,EAAK,EAAE,CAAC;GAGlE,IAAMC,IAAQC,EAAY,CAAC,GAAGH,EAAO,OAAO,CAAC,CAAC,CAAC,KAAK,MAAMI,EAA0BC,GAAGT,CAAC,CAAC,CAAC,GACpFU,IAAqBJ,MAAU,OACjCX,EAAM,EAAE,CAAE,OACVK,EAAE,WAAWM,GAAOX,EAAM,EAAE,CAAE,IAAI,GAChCgB,IAAOT,EAAM,WAAWH,GAAQW,CAAkB,GAGlDE,IAAgBV,EAAM,GAAG,YAAY,YACrCW,IAASrB,EAAM,SAAS,aAAasB,MAAsBC,GAa3DC,IAAc/B,EAAiB,GAC/BgC,IAAY,CAChBC,EAA+C;IAC7C,MAAM;KACJ,IAAIF;KACJ,MAAM;KACN;KACM;KACN,MAAM,CAAC;KACP,QAAQjB,KAAU;KAClB,GAAIa,IAAgB;MAAE,WAAW;MAAY,YAAYC;KAAO,IAAI,CAAC;IACvE;IACA,OAAO;GACT,CAAC,CACH;GACA,KAAK,IAAMR,KAAQV,GAOjB,AANAsB,EAAI,KAAKE,EAAiB;IACxB,IAAId,EAAK;IACT,cAAeA,EAAK,UAAU;IAC9B,YAAYW;IACZ,OAAO;GACT,CAAC,CAAC,GACE,MACJC,EAAI,KAAKG,EAA2B;IAClC,IAAIf,EAAK;IACT,MAAMA,EAAK;IACX,IAAIH,EAAM,GAAG,UAAUQ,GAAoBN,EAAO,IAAIC,EAAK,EAAE,CAAE;IAC/D,OAAO;GACT,CAAC,CAAC;GAcJ,AANIZ,IAAUA,EAASwB,GAAK,OAAO,IAC9BzB,EAAM,WAAWyB,GAAK,SAASI,EAAqB7B,GAAOF,EAAU,cAAc,CAAC,GAKzFA,EAAU,IAAI,CAAC0B,CAAW,CAAC;EAC7B;CACF;CACA,SAASM;AACX,GAeaC,IAAiD;CAC5D,IAAI;CACJ,OAAO;CACP,MAAMnC,EAAcoC,CAAW;CAC/B,OAAO;CACP,gBAAgB;EAAE,MAAM;EAAO,KAAK;EAAK,MAAM;GAAE,KAAK;GAAM,OAAO;EAAK;CAAE;CAC1E,UAAU,EAAE,YAAY,aAAa;CACrC,UAAU;EAAC;EAAS;EAAa;CAAiB;CAClD,SAAS;EACP,QAAQ;EACR,MAAM,MAAS;GACb,IAAMlC,IAAYC,EAAK,WACjBC,IAAQD,EAAK;GACnB,IAAI,CAACD,KAAa,CAACE,GAAO;GAE1B,IAAME,IAAMJ,EAAU,IAAI;GAC1B,IAAII,EAAI,WAAW,GAAG;GAEtB,IAAM+B,IAAa/B,EAAI,QAAQ,MAAOF,EAAM,IAAII,CAAY,CAAC,EAAE,SAAS,WAAW;GACnF,IAAI6B,EAAW,WAAW,GAAG;GAE7B,IAAMvB,IAAQC,EAAeX,GAAOD,EAAK,eAAe,GAClDqB,IAAgBV,EAAM,GAAG,YAAY;GAE3C,EAAM,MAAM,iBAAiB;IAC3B,IAAMwB,IAAkB,CAAC;IACzB,KAAK,IAAMV,KAAeS,GAAY;KACpC,IAAME,IAAYnC,EAAM,IAAIwB,CAAqB;KACjD,IAAI,CAACW,KAAaA,EAAU,SAAS,aAAa;KAElD,IAAM5B,IAAS4B,EAAU,UAAU,MAC7BC,IACJ7B,MAAW,OACPP,EAAM,MAAM,QAAQwB,CAAqB,IACzCxB,EAAM,WAAWO,CAAM,CAAC,CAAC,QAAQiB,CAAqB,GAEtDa,IAAW,CAAC,GAAGrC,EAAM,WAAWwB,CAAqB,CAAC,GAGtDZ,oBAAS,IAAI,IAAqB;KACxC,IAAI,CAACQ,GACH,KAAK,IAAMkB,KAAWD,GAAU,EAAO,IAAIC,GAAS5B,EAAM,MAAM4B,CAAO,CAAC;KAU1E,AARAD,EAAS,SAAS,GAAS,MAAM;MAK/B,AAJArC,EAAM,KAAKsC,GAAS/B,GAAQ6B,IAAY,IAAI,KAAA,IAAYA,IAAYG,CAAC,GAChEnB,KACHpB,EAAM,QAAQsC,GAAS5B,EAAM,WAAWH,GAAQK,EAAO,IAAI0B,CAAO,CAAE,CAAU,GAEhFJ,EAAM,KAAKI,CAAO;KACpB,CAAC,GAEDtC,EAAM,OAAOwB,CAAqB;IACpC;IACA,EAAU,IAAIU,CAAK;GACrB,CAAC;EACH;CACF;CACA,UAAU,MAAS;EACjB,IAAMpC,IAAYC,GAAM,WAClBC,IAAQD,GAAM;EAEpB,OADYD,GAAW,IAAI,CAAC,CAAC,MAAM,MAAOE,GAAO,IAAII,CAAY,CAAC,EAAE,SAAS,WAAW,IAC3E,KAAOoC,EAAqB;CAC3C;AACF"}