@weasel-js/core 1.6.1 → 1.7.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"move.js","names":["runLayoutPass","layoutDep","scratch","moveCtx","scene","pc","poseAdapter","scenePoseAdapter","showReflow","id","localPose","grabAdapter","grabbedPoseAdapter","dragged","node","startWorld","composeWorldPose","g","poseDescriptorForNode","world","translatePoseViaDescriptor","dx","dy","b","draggedIds","c","minX","minY","maxX","maxY","selectionCenter","probeOffset","candidates","mode","testInside","region","layout","aabb","regionContains","cPose","consider","worldPose","worldAABB","arg","zPath","walk","childIds","parentId","i","childPath","parentPath","dest","byId","cAfter","container","working","cid","setWorking","at","placements","destReflow","dc","children","targets","target","poses","pose","asNodeId","reflowIds","parent","rebaseLocalPose","sourceReflow","srcId","leaving","groupBySourceContainer","srcLayout","srcNode","srcContainer","srcChildren","cur","next","local","point","bounds","pointInPath","out","d","src","exclude","set","translateCommitOps","ops","ids","l","localDelta","m","authored","createTransformOp","dataOp","geometryDataOp","f","from","to","unreleasedIds","selected","released","claimed","documentPose","definesFrame","adapter","releasedPoses","frame","frameAtOrAbove","landReleased","r","reflow","resolveDropTarget","dep","endCtx","\"nodeAtPoint\"","hit","hitNode","applyReparent","draggedWorld","newLocal","index","hitIdx","sid","moveAction","inPlane","selection","ctx","projection","poseDescriptorOf","applyOps","geometryProjection","IDENTITY_POSE_COMPOSITION","isAnchorOrControl","params","resolveParams","opts","expandIds","\"expandIds\"","startPoses","cascadeIds","seen","queue","caught","hold","shown","home","effectivePose","childId","childNode","carried","frames","behaviors","dragThresholdPx","\"dragThresholdPx\"","DRAG_THRESHOLD_PX","lifecycle","readGestureLifecycle","engaged","moveGestureAdapter","origin","readView","gestureViewReader","readPlane","gesturePlaneReader","gestureCtx","commitMove","committed","commitOps","commitGestureOps","gctx","ori","reduceBehaviorEnd","lp","commitAdapter","destId","rebaseOpToLocal","op","a","curParent","toParent","reparentOps","dropOps","placement","createReparentOp","reflowOps","releasedOps","rebaseReleased","sources","landed","reparentMode","\"reparentOnDrop\"","dropTarget","reparent","err","SceneArrivalRefused","s","pastDragThreshold","transform","primary","o","reason","runBehaviorCancel","dropPreviewOverrides","selectionLayer"],"sources":["../../../../src/interactions/actions/defaults/move.ts"],"sourcesContent":["/**\n * `moveAction` — first `ongoing`-timing Action descriptor.\n *\n * Mirrors the per-frame translate semantics of the `useMove` hook:\n *   - `start`: capture origin poses for all selected nodes; record the\n *     current drag delta in scratch each frame.\n *   - `onMove`: update the in-scratch `currentDelta`, and publish the frame's\n *     poses as ephemeral overrides. No *document* writes, so the undo stack\n *     still sees one entry for the whole drag.\n *   - `onEnd('commit')`: emit the final delta as transform ops and commit\n *     them as one batch (`commitGestureOps`) → at most one undo entry for the\n *     whole drag, none when the binding's params make it transient.\n *   - `onEnd('cancel')`: drop the overrides — the document was never mutated,\n *     so the committed poses are the restoration.\n *\n * ## Why no per-frame document writes\n *\n * `Scene.setPose` calls `executeAndLog`, which immediately records an undo\n * entry on the scene's history engine. Per-frame writes during drag would\n * create O(frames) history entries, so the drag commits one\n * `createTransformOp` batch at the end.\n *\n * The per-frame poses still go *somewhere* the scene can see: the ephemeral\n * override table, which bypasses history entirely. That is what lets a node\n * deriving its geometry from a dragged one follow the drag — `sceneDepLookup`\n * and the pick source both read overrides, and neither can see this action's\n * scratch. Keeping the frame in scratch alone is why the edge used to stay\n * anchored to the old endpoint and jump on drop.\n *\n * The behavior pipeline (snap-to-grid, snap-back-or-delete, snap-to-container,\n * etc.) via `opts.behaviors` from `BindingOpts` IS wired: `start` builds a\n * `GestureContext` + scene-backed adapter (`moveGestureAdapter`), `onMove`\n * folds each behavior's proposed-transform result, and `onEnd` runs a\n * first-non-undefined-wins reducer (`Op[]` commits via `scene.applyBatch`,\n * `null` aborts, all-`undefined` falls through to the default translate path).\n *\n * ## Pose generics\n *\n * Poses are `unknown`; every read and write goes through the `poseDescriptor`\n * dep (`AUTO_POSE_DESCRIPTOR` when unsourced).\n */\n\nimport { gesturePlaneReader, gestureViewReader } from '../../gestures/shared/screenTolerance';\nimport type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle, BindingOpts } from '@weasel-js/routing';\nimport { resolveParams, DRAG_THRESHOLD_PX, pastDragThreshold } from '@weasel-js/routing';\nimport { definesFrame, documentPose, effectivePose } from 'core/scene/effectivePose';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { syncPreviewOverrides, dropPreviewOverrides } from '../previewOverrides';\nimport { commitGestureOps, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel, type GestureLifecycle } from '../gestureLifecycle';\nimport { asNodeId } from 'core/scene/types';\nimport { SceneArrivalRefused } from 'core/scene/arrivals';\nimport type { Op } from 'core/ops/types';\nimport type { Mat3 } from '@weasel-js/geom';\nimport { createTransformOp } from 'core/ops/transform';\nimport { createReparentOp } from 'core/ops/reparent';\nimport { geometryDataOp, type GeometryProjection } from '../geometryProjection';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { NodeAtPointDep, LayoutDep } from '../depSchema';\nimport type {\n  LayoutStrategy,\n  LayoutContainer,\n  LayoutChild,\n  LayoutDragged,\n  DropTarget as LayoutDropTarget,\n  DropRegion,\n} from '../../../layout/types';\nimport { pointInPath } from '@weasel-js/geom';\nimport {\n  poseDescriptorForNode,\n  translatePoseViaDescriptor,\n  type PoseDescriptor,\n} from '../resize/geometry';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport { isAnchorOrControl } from '@weasel-js/routing';\nimport type { MoveBehavior, GroupTransform, GestureContext, BehaviorResult } from '../../gestures/types';\nimport { moveGestureAdapter, type MoveGestureAdapter } from '../move/gestureAdapter';\nimport {\n  composeWorldPose,\n  frameAtOrAbove,\n  rebaseLocalPose,\n  IDENTITY_POSE_COMPOSITION,\n  type PoseAdapter,\n  type PoseComposition,\n} from 'features/groups/composePose';\nimport { inPlane, selectionLayer } from '../planeInput';\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\n/** Drag-time layout pass. Picks the layout container under the *selection's*\n *  center (by `LayoutDep.dropTarget`), then places each dragged child in\n *  turn — every child sees the container state the previous one produced — and\n *  folds destination + source reflow poses into `scratch.previews` (so they\n *  render as ghosts), or into `scratch.reflowTargets` when a reflow transition\n *  carries them there. Sets `scratch.layoutPass` when one container accepts\n *  every member of the selection. */\nfunction runLayoutPass(scratch: MoveScratch, moveCtx: InvocationCtx): void {\n  const layoutDep = scratch.layout;\n  if (!layoutDep || !moveCtx.drag) return;\n  const scene = scratch.scene;\n  const pc = scratch.pc;\n  const poseAdapter = scenePoseAdapter(scene);\n  const { dx, dy } = scratch.currentDelta;\n  const showReflow = (id: NodeId, localPose: unknown): void => {\n    if (layoutDep.reflow) scratch.reflowTargets.set(id, localPose);\n    else scratch.previews.set(id, localPose);\n  };\n\n  type AABB = { x: number; y: number; width: number; height: number };\n  interface DraggedChild {\n    id: NodeId;\n    arg: LayoutDragged<unknown>;\n    center: { x: number; y: number };\n  }\n  // Each dragged preview in WORLD: compose the committed start pose up the\n  // parent chain, then add the world drag delta (same math as `applyReparent`).\n  // The LayoutStrategy contract is world-framed, so every pose handed to it\n  // below is composed to world; reflow results are rebased back to local.\n  const d = scratch.projection;\n  const grabAdapter = grabbedPoseAdapter(scratch, poseAdapter);\n  const dragged: DraggedChild[] = [];\n  for (const id of scratch.ids) {\n    const node = scene.get(id);\n    if (!node) continue;\n    const startWorld = composeWorldPose(grabAdapter, id as string, pc.compose);\n    const g = poseDescriptorForNode(d, node);\n    const world = translatePoseViaDescriptor(startWorld, dx, dy, g);\n    const b = g.getBounds(world);\n    dragged.push({\n      id,\n      arg: {\n        id: id as string,\n        originPose: startWorld,\n        pose: world,\n        sourceContainerId: (node.parent ?? null) as string | null,\n      },\n      center: { x: b.x + b.width / 2, y: b.y + b.height / 2 },\n    });\n  }\n  if (dragged.length === 0) return;\n  const draggedIds = new Set<NodeId>(dragged.map((c) => c.id));\n\n  // The selection lands as a unit, so one point decides the container: the\n  // center of the whole dragged group. Hit-testing each child on its own\n  // would scatter a selection straddling two containers.\n  let minX = Infinity;\n  let minY = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  for (const c of dragged) {\n    const b = d.getBounds(c.arg.pose);\n    minX = Math.min(minX, b.x);\n    minY = Math.min(minY, b.y);\n    maxX = Math.max(maxX, b.x + b.width);\n    maxY = Math.max(maxY, b.y + b.height);\n  }\n  const selectionCenter = { x: (minX + maxX) / 2, y: (minY + maxY) / 2 };\n  // Each child is snapped at its own position, displaced by however far the\n  // pointer sits from that center — the group keeps its shape, and a lone\n  // child is still probed at the pointer itself.\n  const probeOffset = {\n    x: moveCtx.drag.current.x - selectionCenter.x,\n    y: moveCtx.drag.current.y - selectionCenter.y,\n  };\n\n  type Layout = LayoutStrategy<unknown>;\n  interface Candidate {\n    id: NodeId;\n    bounds: AABB;\n    layout: Layout;\n    zPath: number[];\n    depth: number;\n  }\n  const candidates: Candidate[] = [];\n  const mode = layoutDep.dropTarget ?? 'innermost';\n  const testInside = (id: NodeId, cPose: unknown, aabb: AABB, layout: Layout): boolean => {\n    const region = layout.dropRegion?.({ id: id as string, bounds: aabb }) ?? null;\n    if (region) return regionContains(region, aabb, selectionCenter);\n    if (mode === 'region') return false;\n    if (layout.contains) return layout.contains(cPose, selectionCenter);\n    return selectionCenter.x >= aabb.x && selectionCenter.x < aabb.x + aabb.width\n      && selectionCenter.y >= aabb.y && selectionCenter.y < aabb.y + aabb.height;\n  };\n  const consider = (id: NodeId, zPath: number[]): void => {\n    if (draggedIds.has(id)) return;\n    const layout = layoutDep.getLayout(id as string);\n    if (!layout) return;\n    const node = scene.get(id);\n    if (!node) return;\n    const worldPose = composeWorldPose(poseAdapter, id as string, pc.compose);\n    const worldAABB = poseDescriptorForNode(d, node).getBounds(worldPose);\n    if (!testInside(id, worldPose, worldAABB, layout)) return;\n    if (layout.acceptsDrop) {\n      const arg: LayoutContainer = { id: id as string, bounds: worldAABB };\n      for (const c of dragged) if (!layout.acceptsDrop(arg, c.arg)) return;\n    }\n    candidates.push({\n      id,\n      bounds: worldAABB,\n      layout,\n      zPath,\n      depth: zPath.length,\n    });\n  };\n  const walk = (parentId: NodeId | null, parentPath: number[]): void => {\n    const childIds = parentId === null ? scene.roots : scene.childrenOf(parentId);\n    for (let i = 0; i < childIds.length; i++) {\n      const childPath = [...parentPath, i];\n      consider(childIds[i], childPath);\n      walk(childIds[i], childPath);\n    }\n  };\n  walk(null, []);\n\n  let dest: Candidate | null = null;\n  if (mode === 'topmost') {\n    // Painted last wins, in the scene's own render order — which crosses\n    // subtrees and layers, where a sibling-index path cannot.\n    const byId = new Map<NodeId, Candidate>(candidates.map((c) => [c.id, c]));\n    for (const id of scene.renderOrder()) dest = byId.get(id) ?? dest;\n  } else {\n    // Deepest wins; sibling-index path breaks ties (higher z = later index).\n    for (const c of candidates) {\n      if (dest === null) { dest = c; continue; }\n      if (c.depth > dest.depth) { dest = c; continue; }\n      if (c.depth < dest.depth) continue;\n      let cAfter = false;\n      for (let i = 0; i < c.zPath.length; i++) {\n        if (c.zPath[i] > dest.zPath[i]) { cAfter = true; break; }\n        if (c.zPath[i] < dest.zPath[i]) { cAfter = false; break; }\n      }\n      if (cAfter) dest = c;\n    }\n  }\n  if (!dest) return;\n\n  const layout = dest.layout;\n  const container: LayoutContainer = { id: dest.id as string, bounds: dest.bounds };\n  // The container state the placements run against, advanced by each one.\n  const working: LayoutChild<unknown>[] = scene.childrenOf(dest.id).map((cid) => ({\n    id: cid as string,\n    pose: composeWorldPose(poseAdapter, cid as string, pc.compose),\n  }));\n  const setWorking = (id: string, pose: unknown): void => {\n    const at = working.findIndex((c) => c.id === id);\n    if (at >= 0) working[at] = { id, pose };\n    else working.push({ id, pose });\n  };\n\n  const placements: LayoutPlacement[] = [];\n  const destReflow = new Map<NodeId, unknown>();\n  for (const dc of dragged) {\n    const children = working.map((c) => ({ ...c }));\n    const targets = layout.getDropTargets(container, children, dc.arg);\n    const target = layout.snap.pickTarget(targets, {\n      x: dc.center.x + probeOffset.x,\n      y: dc.center.y + probeOffset.y,\n    });\n    // All-or-nothing: a container that cannot take every member takes none\n    // rather than splitting the selection between two homes.\n    if (!target) return;\n    placements.push({ dragged: dc.arg, children, target });\n    const poses = layout.reflowPoses(container, children, dc.arg, target);\n    for (const [cid, pose] of poses) {\n      setWorking(cid, pose);\n      if (!draggedIds.has(asNodeId(cid))) destReflow.set(asNodeId(cid), pose);\n    }\n    setWorking(dc.arg.id, poses.get(dc.arg.id) ?? target.pose);\n  }\n\n  // Destination reflow → fold into previews (the dragged children keep their\n  // pointer-following ghosts). `reflowPoses` returns world; previews are\n  // local, so rebase to the child's current parent frame first.\n  const reflowIds = new Set<NodeId>();\n  for (const [cid, pose] of destReflow) {\n    const parent = scene.get(cid)?.parent ?? null;\n    showReflow(cid, rebaseLocalPose(poseAdapter, pose, parent, pc.compose, pc.decompose));\n    reflowIds.add(cid);\n  }\n\n  // Source reflow (cross-container) → fold changed leftovers into previews.\n  // One pass per container the selection left behind, with everything that\n  // left it withdrawn at once.\n  const sourceReflow = new Map<string, unknown>();\n  for (const [srcId, leaving] of groupBySourceContainer(dragged.map((c) => ({\n    id: c.id,\n    sourceContainerId: c.arg.sourceContainerId,\n  })), container.id)) {\n    const srcLayout = layoutDep.getLayout(srcId);\n    const srcNode = scene.get(asNodeId(srcId));\n    if (!srcLayout || !srcNode) continue;\n    const srcContainer: LayoutContainer = {\n      id: srcId,\n      bounds: d.getBounds(composeWorldPose(poseAdapter, srcId, pc.compose)),\n    };\n    const srcChildren: LayoutChild<unknown>[] = scene.childrenOf(asNodeId(srcId))\n      .filter((cid) => !leaving.has(cid))\n      .map((cid) => ({\n        id: cid as string,\n        pose: composeWorldPose(poseAdapter, cid as string, pc.compose),\n      }));\n    for (const [cid, pose] of srcLayout.childPoses(srcContainer, srcChildren)) {\n      const cur = d.getBounds(composeWorldPose(poseAdapter, cid, pc.compose));\n      const next = d.getBounds(pose);\n      const same = cur.x === next.x && cur.y === next.y\n        && cur.width === next.width && cur.height === next.height;\n      if (same) continue;\n      sourceReflow.set(cid, pose); // WORLD — rebased at each consumption point\n      const parent = scene.get(asNodeId(cid))?.parent ?? null;\n      showReflow(asNodeId(cid), rebaseLocalPose(poseAdapter, pose, parent, pc.compose, pc.decompose));\n      reflowIds.add(asNodeId(cid));\n    }\n  }\n\n  scratch.layoutPass = { layout, container, placements, sourceReflow, reflowIds };\n}\n\n/** Whether a world point falls in a drop region, which is authored relative to\n *  the top-left of the container's world bounds. */\nfunction regionContains(\n  region: DropRegion,\n  bounds: { x: number; y: number },\n  point: { x: number; y: number },\n): boolean {\n  const local = { x: point.x - bounds.x, y: point.y - bounds.y };\n  return typeof region === 'function'\n    ? region(local)\n    : pointInPath(region, local.x, local.y);\n}\n\n/** Dragged ids grouped by the container they are leaving, skipping any that\n *  stay put (`exclude` is the destination) or that had no container. */\nfunction groupBySourceContainer(\n  dragged: ReadonlyArray<{ id: NodeId; sourceContainerId: string | null }>,\n  exclude: string | null,\n): Map<string, Set<NodeId>> {\n  const out = new Map<string, Set<NodeId>>();\n  for (const d of dragged) {\n    const src = d.sourceContainerId;\n    if (!src || src === exclude) continue;\n    let set = out.get(src);\n    if (!set) { set = new Set<NodeId>(); out.set(src, set); }\n    set.add(d.id);\n  }\n  return out;\n}\n\n/** The default translate commit: one transform op per id, plus the data-held\n *  geometry op when the `geometryProjection` seam is wired. */\nfunction translateCommitOps(\n  scratch: MoveScratch,\n  ids: Iterable<NodeId>,\n  dx: number,\n  dy: number,\n): Op[] {\n  const ops: Op[] = [];\n  for (const id of ids) {\n    if (!scratch.startPoses.has(id) || scratch.carried.has(id)) continue;\n    const node = scratch.scene.get(id);\n    if (!node) continue;\n    const l = localDelta(scratch, id, dx, dy);\n    const c = scratch.caught.get(id);\n    if (c) { l.dx += c.dx; l.dy += c.dy; }\n    const m: Mat3 = [1, 0, 0, 1, l.dx, l.dy];\n    // The authored pose, not the captured one: a derived node's captured pose\n    // is its derivation, and writing that back would lose the placeholder undo\n    // restores.\n    const authored = node.pose;\n    ops.push(createTransformOp<unknown>({\n      id: id as string,\n      from: authored,\n      to: translatePoseViaDescriptor(authored, l.dx, l.dy, scratch.projection),\n      label: scratch.lifecycle.label,\n    }));\n    if (scratch.geometryProjection) {\n      const dataOp = geometryDataOp(\n        scratch.geometryProjection,\n        { id: id as string, data: node.data, pose: authored },\n        m,\n        scratch.lifecycle.label,\n      );\n      if (dataOp) ops.push(dataOp);\n    }\n  }\n  return ops;\n}\n\n/**\n * The world drag `(dx, dy)` as a translation of `id`'s stored pose. A pose is\n * stored in its frame, so under a turned frame the two point different ways.\n */\nfunction localDelta(\n  scratch: MoveScratch,\n  id: NodeId,\n  dx: number,\n  dy: number,\n): { dx: number; dy: number } {\n  const f = scratch.frames.get(id);\n  if (f === undefined) return { dx, dy };\n  const { pc, projection: d } = scratch;\n  const from = d.getBounds(pc.decompose(f.frameWorld, f.world));\n  const to = d.getBounds(\n    pc.decompose(f.frameWorld, translatePoseViaDescriptor(f.world, dx, dy, d)),\n  );\n  return { dx: to.x - from.x, dy: to.y - from.y };\n}\n\n/** Selected roots no source layout claimed on release, plus the descendants\n *  that follow them — the part of the selection the translate commit owns. */\nfunction unreleasedIds(scratch: MoveScratch, released: Set<NodeId>): NodeId[] {\n  const selected = new Set<NodeId>(scratch.ids);\n  const out: NodeId[] = scratch.ids.filter((id) => !released.has(id));\n  for (const id of scratch.cascadeIds) {\n    let cur = scratch.scene.get(id)?.parent ?? null;\n    let claimed = false;\n    while (cur) {\n      if (released.has(cur)) { claimed = true; break; }\n      if (selected.has(cur)) break;\n      cur = scratch.scene.get(cur)?.parent ?? null;\n    }\n    if (!claimed) out.push(id);\n  }\n  return out;\n}\n\n/** Allowed values for the `reparentOnDrop` binding param. `'off'` (the\n *  default) preserves the legacy translate-only commit. `'top'` lands the\n *  moved node at the top of the container under the cursor. `'above'`\n *  lands it immediately above the hit sibling in z-order (falls back to\n *  `'top'` semantics when the hit is itself a container or when the hit\n *  and moved node share no parent). */\nexport type ReparentOnDrop = 'off' | 'top' | 'above';\n\n/** Build a `PoseAdapter` over a `Scene` for `composePose` helpers.\n *  `getParent` returns the live parent at call time so mid-batch\n *  parent updates compose correctly. */\nfunction scenePoseAdapter(\n  scene: Scene<unknown, string, unknown>,\n): PoseAdapter<unknown> {\n  return {\n    getPose: (id) => documentPose(scene, scene.get(id as NodeId)!),\n    getParent: (id) => scene.get(id as NodeId)?.parent ?? null,\n    definesFrame: (id) => {\n      const node = scene.get(id as NodeId);\n      return node === undefined || definesFrame(node);\n    },\n  };\n}\n\n/** `adapter`, except that an id caught mid-glide answers with the pose it was\n *  grabbed at — where the drag measures it from. */\nfunction grabbedPoseAdapter(\n  scratch: MoveScratch,\n  adapter: PoseAdapter<unknown>,\n): PoseAdapter<unknown> {\n  if (scratch.caught.size === 0) return adapter;\n  return {\n    ...adapter,\n    getPose: (id) => (scratch.caught.has(id as NodeId)\n      ? scratch.startPoses.get(id as NodeId)\n      : adapter.getPose(id)),\n  };\n}\n\n/** Where a dragged id was shown when the gesture ended: its stored pose then,\n *  the parent that pose was stored under, and the same pose in world. */\ninterface Released {\n  local: unknown;\n  parent: NodeId | null;\n  world: unknown;\n}\n\nfunction releasedPoses(scratch: MoveScratch): Map<NodeId, Released> {\n  const out = new Map<NodeId, Released>();\n  const { scene, pc } = scratch;\n  const adapter = scenePoseAdapter(scene);\n  for (const id of scratch.startPoses.keys()) {\n    const local = scratch.previews.get(id);\n    if (local === undefined) continue;\n    const parent = scene.get(id)?.parent ?? null;\n    const frame = frameAtOrAbove(adapter, parent);\n    const world = frame === null ? local : pc.compose(composeWorldPose(adapter, frame, pc.compose), local);\n    out.set(id, { local, parent, world });\n  }\n  return out;\n}\n\n/** Hand every dragged id to the reflow transition to glide from where it was\n *  let go onto the pose the document now holds. An id caught mid-glide that\n *  never moved resumes settling from where it was held. */\nfunction landReleased(\n  scratch: MoveScratch,\n  reflow: NonNullable<LayoutDep['reflow']>,\n  released: Map<NodeId, Released>,\n): void {\n  const { scene, pc } = scratch;\n  const adapter = scenePoseAdapter(scene);\n  for (const id of scratch.startPoses.keys()) {\n    const r = released.get(id);\n    if (!r) {\n      if (scratch.caught.has(id)) reflow.settle(id as string);\n      continue;\n    }\n    const parent = scene.get(id)?.parent ?? null;\n    const from = parent === r.parent\n      ? r.local\n      : rebaseLocalPose(adapter, r.world, parent, pc.compose, pc.decompose);\n    reflow.settle(id as string, { from });\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\n/** Where one dragged child landed, and the container state it landed against.\n *  Holding the snapshot is what lets the commit replay the same sequence the\n *  preview showed, rather than re-deriving it from a scene the earlier\n *  placements never wrote to. */\ninterface LayoutPlacement {\n  dragged: LayoutDragged<unknown>;\n  children: LayoutChild<unknown>[];\n  target: LayoutDropTarget<unknown>;\n}\n\n/** Resolved layout drop for the latest onMove frame. Only set when a layout\n *  container accepted every member of the selection (non-null snap target for\n *  each). One placement per dragged child, in selection order. */\ninterface LayoutPass {\n  layout: LayoutStrategy<unknown>;\n  container: LayoutContainer;\n  placements: LayoutPlacement[];\n  /** Source-container leftovers that actually moved (id → new pose). */\n  sourceReflow: Map<string, unknown>;\n  /** Siblings reflowing into their destination slots, from both containers.\n   *  Surfaced as `previewOpaqueIds` so they paint settled rather than as\n   *  ghosts under the pointer. */\n  reflowIds: Set<NodeId>;\n}\n\ninterface MoveScratch {\n  /** Origin poses captured at drag start. Key is NodeId. Includes both\n   *  selected roots AND their descendant ids — when a container moves, the\n   *  preview-ghost layer needs every child's pose to render the subtree at\n   *  the previewed location (clipped to the container silhouette). */\n  startPoses: Map<NodeId, unknown>;\n  /** Selected ids only — the drag roots. */\n  ids: NodeId[];\n  /** Descendant ids cascaded for preview only. Their preview poses are\n   *  computed each frame so container drags show children moving along. */\n  cascadeIds: NodeId[];\n  /** Ids whose frame is itself moving, so they ride it and are not\n   *  translated. Empty under identity, where every node stores world. */\n  carried: Set<NodeId>;\n  /** For each moved id stored under a frame: its world pose and the frame's,\n   *  both at drag start — what `localDelta` rotates the drag through. */\n  frames: Map<NodeId, { world: unknown; frameWorld: unknown }>;\n  scene: Scene<unknown, string, unknown>;\n  /** Running drag delta — updated each onMove, applied once at commit. */\n  currentDelta: { dx: number; dy: number };\n  /** In-flight preview poses keyed by node id (roots + cascaded children).\n   *  Populated on onMove; cleared on onEnd. Read by `previewIds`/`previewPose`. */\n  previews: Map<NodeId, unknown>;\n  /** The override entry published to the scene for each previewed id, held by\n   *  reference so a frame mutates it in place — see `PoseOverrides`. */\n  overrideEntries: Map<NodeId, { pose: unknown }>;\n  /** This frame's reflow poses (local) when `layout.reflow` carries them\n   *  instead of `previews`. */\n  reflowTargets: Map<NodeId, unknown>;\n  /** Every id handed to `layout.reflow` this gesture and not yet settled. */\n  gliding: Set<NodeId>;\n  /** Ids grabbed mid-glide, with how far (stored frame) the pose shown at the\n   *  grab stood from the document's. The drag starts from what was shown. */\n  caught: Map<NodeId, { dx: number; dy: number }>;\n  /** Pose descriptor captured at drag start. */\n  projection: PoseDescriptor<unknown>;\n  /** Behaviors from `opts.behaviors`; empty array when none supplied. */\n  behaviors: MoveBehavior<unknown>[];\n  /** Reused gesture context handed to behaviors across the drag. */\n  gestureCtx: GestureContext<unknown>;\n  /** Scene-backed adapter the committed behavior ops apply through. */\n  adapter: MoveGestureAdapter<unknown>;\n  /** Layout dep captured at start; undefined when not registered. */\n  layout: LayoutDep | undefined;\n  /** Latest resolved layout pass, or null when no container accepted. */\n  layoutPass: LayoutPass | null;\n  /** Pose-composition strategy captured at gesture start. Defaults to\n   *  IDENTITY (absolute-pose) when the `poseComposition` dep is absent;\n   *  local-pose consumers supply composeRectPose/decomposeRectPose. */\n  pc: PoseComposition<unknown>;\n  /** Optional consumer commit hook captured at gesture start. When present,\n   *  ops-based commits route through it (consumer history) instead of\n   *  `scene.applyBatch`. Undefined → fall back to `scene.applyBatch`. */\n  applyOps?: (ops: Op[], label: string) => void;\n  /** Optional eager-sync seam captured at gesture start. When present, the\n   *  translate-only commit path emits a `setData` op per moved node mapping\n   *  its data-held geometry by the (dx,dy) translation. Undefined → pose-only. */\n  geometryProjection?: GeometryProjection;\n  /** Label, history and callbacks from the binding's params. */\n  lifecycle: GestureLifecycle;\n}\n\n/** Resolved drop target — the new parent + layer + (for `'above'` mode)\n *  the hit sibling whose z-order position the moved node should land\n *  immediately above. `newParent === null` means \"land at the layer\n *  root\" (top-level node of `newLayer`). */\ninterface DropTarget {\n  newParent: NodeId | null;\n  newLayer: string;\n  hitSibling: NodeId | null;\n}\n\n/** Walk the hit chain to find the appropriate drop target. Returns\n *  `null` when no reparent should happen (drop on empty canvas, or the\n *  only hits are the moved subtree itself). */\nfunction resolveDropTarget(\n  endCtx: InvocationCtx,\n  scratch: MoveScratch,\n): DropTarget | null {\n  const dep = endCtx.deps['nodeAtPoint'] as NodeAtPointDep | undefined;\n  if (!dep) return null;\n\n  // Exclude moved roots + their descendants. Otherwise we'd happily\n  // reparent a node into itself (or under one of its own children).\n  const exclude = new Set<NodeId>([...scratch.ids, ...scratch.cascadeIds]);\n  const hit = dep(endCtx.world, exclude);\n  if (!hit) return null;\n\n  const hitNode = scratch.scene.get(hit);\n  if (!hitNode) return null;\n\n  // Containers act as drop-INTO targets; leaves act as drop-NEXT-TO\n  // targets (parent = leaf's parent). When the leaf has no parent\n  // (top-level under a layer), `newParent === null` and the moved\n  // subtree lands at the layer root.\n  if (hitNode.kind === 'container') {\n    return { newParent: hit, newLayer: hitNode.layer, hitSibling: null };\n  }\n  return {\n    newParent: hitNode.parent,\n    newLayer: hitNode.layer,\n    hitSibling: hit,\n  };\n}\n\n/** Reparent + reposition each moved root. Pose math: the preview during\n *  the drag showed the node at `originWorldPose + (dx, dy)`. To preserve\n *  that world position after the parent swap, we compute the equivalent\n *  local pose under `newParent`'s frame via `rebaseLocalPose`. */\nfunction applyReparent(\n  scratch: MoveScratch,\n  target: DropTarget,\n  mode: ReparentOnDrop,\n  dx: number,\n  dy: number,\n  pc: PoseComposition<unknown>,\n): void {\n  const scene = scratch.scene;\n  const poseAdapter = scenePoseAdapter(scene);\n\n  for (const id of scratch.ids) {\n    if (!scratch.startPoses.has(id)) continue;\n\n    // World pose the user dragged the node to. `composeWorldPose` folds\n    // ancestor offsets in for nested nodes; for top-level nodes it\n    // collapses to the local pose. The drag delta is in world space, so\n    // it adds in directly. Reads from the current scene state, which is\n    // unchanged from drag start because `moveAction` doesn't write\n    // during `onMove`.\n    const startWorld = composeWorldPose(poseAdapter, id, pc.compose);\n    const draggedWorld = translatePoseViaDescriptor(startWorld, dx, dy, scratch.projection);\n    const newLocal = rebaseLocalPose(\n      poseAdapter,\n      draggedWorld,\n      target.newParent as string | null,\n      pc.compose,\n      pc.decompose,\n    );\n\n    // Cross-layer reparent requires orphaning before relayer (scene\n    // refuses `setLayer` on a node whose parent is on a different\n    // layer). For same-parent reorders or same-layer reparents this\n    // collapses to a single `move` + `setPose`.\n    const node = scene.get(id)!;\n    if (node.layer !== target.newLayer) {\n      if (node.parent !== null) scene.move(id, null);\n      scene.setLayer(id, target.newLayer as never);\n    }\n\n    // Destination index. `'above'` mode needs a hit sibling that shares\n    // `newParent`; otherwise fall through to `'top'` (index = undefined\n    // appends to end). `scene.move` detach-then-attaches, so the index\n    // is interpreted relative to the *post-detach* sibling list — we\n    // filter the moving id out before computing the slot or we'd land\n    // one position too far down when the moving node was previously a\n    // sibling preceding the hit.\n    let index: number | undefined;\n    if (mode === 'above' && target.hitSibling) {\n      const rawSiblings = target.newParent === null\n        ? scene.roots\n        : scene.childrenOf(target.newParent);\n      const siblings = rawSiblings.filter((sid) => sid !== id);\n      const hitIdx = siblings.indexOf(target.hitSibling);\n      if (hitIdx >= 0) index = hitIdx + 1;\n    }\n\n    scene.move(id, target.newParent, index);\n    scene.setPose(id, newLocal as never);\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `move` Action.\n *\n * Requires dep-schema entries: `selection`, `scene`.\n *\n * The invoker is `ongoing` — it returns an `OngoingHandle` from `start` that\n * the dispatcher pumps via `onMove`/`onEnd` for the duration of the drag.\n *\n * @see useMove — the React hook this descriptor mirrors for the simple case.\n */\nexport const moveAction: Action & { requires: string[] } = inPlane({\n  id: 'move',\n  label: 'Move',\n  // No hover `cursor`: pointing at a node shouldn't preemptively promise a\n  // move, matching what `useSelectTool` showed before its scratch-driven\n  // cursor was retired. Once the drag is running, it's a move.\n  activeCursor: 'move',\n  // Ambient default targets `selected-body` so a host without an explicit\n  // select-tool binding still gets drag-to-move on the selection — but ONLY\n  // on the selected body. A bare `{ kind: 'drag' }` catches every drag in\n  // ambient scope and bleeds the move into drawing-tool gestures (any path\n  // where the higher-priority active match falls through). Drawing tools\n  // bind bare drag at active scope and outrank this; the symptom of\n  // \"drawing tools move the selection\" disappears once the ambient binding\n  // is target-qualified instead of universal.\n  defaultBinding: { kind: 'drag', target: 'selected-body' },\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'poseDescriptor', 'layout', 'applyOps', 'poseComposition', 'geometryProjection', 'nodeAtPoint', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts?: BindingOpts): OngoingHandle {\n      const selection = ctx.deps.selection as SelectionApi | undefined;\n      const scene = ctx.deps.scene as Scene<unknown, string, unknown> | undefined;\n      const projection = poseDescriptorOf(ctx.deps.poseDescriptor);\n      const layout = ctx.deps.layout as LayoutDep | undefined;\n      const applyOps = ctx.deps.applyOps as ((ops: Op[], label: string) => void) | undefined;\n      const geometryProjection = ctx.deps.geometryProjection as GeometryProjection | undefined;\n      // Pose-composition strategy: how the consumer's scene folds local poses\n      // up to world (and back). Absent → IDENTITY (absolute-pose: nodes store\n      // world coords, parents are grouping-only). Local-pose consumers supply\n      // { compose: composeRectPose, decompose: decomposeRectPose }.\n      const pc = (ctx.deps.poseComposition as PoseComposition<unknown> | undefined)\n        ?? IDENTITY_POSE_COMPOSITION;\n\n      if (!selection || !scene) return {};\n      // Anchors sit on the selected body, and this binding ties editAnchors' on\n      // specificity; with no mode registry to filter move out, declining is what lets it through.\n      if (isAnchorOrControl(ctx.drag?.affordance)) return {};\n\n      const params = resolveParams(opts?.params);\n      const expandIds = params?.['expandIds'] as ((ids: string[]) => string[]) | undefined;\n      const selected = [...selection.get()] as string[];\n      const ids = (expandIds ? expandIds(selected) : selected) as NodeId[];\n      if (ids.length === 0) return {};\n\n      // Capture origin poses once at drag start. Walk descendants so\n      // container drags can preview every displaced child — required by\n      // `usePreviewGhostLayer.buildSubtree` which only recurses into ids\n      // present in `previewIds()`.\n      const startPoses = new Map<NodeId, unknown>();\n      const cascadeIds: NodeId[] = [];\n      const seen = new Set<NodeId>();\n      const queue: NodeId[] = [];\n      // A node still gliding from an earlier reflow is held where it is\n      // shown, and the drag starts from there.\n      const reflow = layout?.reflow ?? null;\n      const caught = new Map<NodeId, { dx: number; dy: number }>();\n      const hold = (id: NodeId, node: NonNullable<ReturnType<typeof scene.get>>): void => {\n        const shown = reflow?.poseOf(id as string);\n        if (!reflow || shown === undefined) return;\n        reflow.glide(id as string, shown, { from: shown });\n        const at = projection.getBounds(shown);\n        const home = projection.getBounds(documentPose(scene, node));\n        caught.set(id, { dx: at.x - home.x, dy: at.y - home.y });\n      };\n      for (const id of ids) {\n        const node = scene.get(id);\n        if (!node) continue;\n        hold(id, node);\n        startPoses.set(id, effectivePose(scene, node));\n        seen.add(id);\n        queue.push(id);\n      }\n      while (queue.length > 0) {\n        const parent = queue.shift()!;\n        for (const childId of scene.childrenOf(parent)) {\n          if (seen.has(childId)) continue;\n          seen.add(childId);\n          const childNode = scene.get(childId);\n          if (!childNode) continue;\n          hold(childId, childNode);\n          startPoses.set(childId, effectivePose(scene, childNode));\n          cascadeIds.push(childId);\n          queue.push(childId);\n        }\n      }\n\n      const carried = new Set<NodeId>();\n      const frames = new Map<NodeId, { world: unknown; frameWorld: unknown }>();\n      if (pc.closure !== 'identity') {\n        const poseAdapter = scenePoseAdapter(scene);\n        for (const id of startPoses.keys()) {\n          const frame = frameAtOrAbove(poseAdapter, scene.get(id)?.parent ?? null);\n          if (frame === null) continue;\n          if (startPoses.has(asNodeId(frame))) {\n            carried.add(id);\n            continue;\n          }\n          frames.set(id, {\n            world: composeWorldPose(poseAdapter, id as string, pc.compose),\n            frameWorld: composeWorldPose(poseAdapter, frame, pc.compose),\n          });\n        }\n      }\n\n      const behaviors = (opts?.behaviors ?? []) as MoveBehavior<unknown>[];\n      const dragThresholdPx = (params?.['dragThresholdPx'] as number | undefined)\n        ?? DRAG_THRESHOLD_PX;\n      const lifecycle = readGestureLifecycle(params, 'Move', behaviors);\n      let engaged = false;\n      const adapter = moveGestureAdapter<unknown>(scene as Scene<unknown, string, unknown>);\n      const origin = new Map<string, unknown>();\n      for (const [id, pose] of startPoses) origin.set(id as string, pose);\n      const readView = gestureViewReader(ctx.deps);\n      const readPlane = gesturePlaneReader(ctx.deps);\n      const gestureCtx: GestureContext<unknown> = {\n        draggedIds: ids as unknown as string[],\n        origin,\n        current: new Map(origin),\n        snap: null,\n        modifiers: { ...ctx.modifiers },\n        pointer: { worldX: ctx.world.x, worldY: ctx.world.y, clientX: 0, clientY: 0 },\n        view: readView(),\n        plane: readPlane(),\n        adapter: adapter as unknown as GestureContext<unknown>['adapter'],\n        scratch: {},\n      };\n      for (const b of behaviors) b.onStart?.(gestureCtx);\n\n      const scratch: MoveScratch = {\n        startPoses,\n        ids,\n        cascadeIds,\n        carried,\n        frames,\n        scene,\n        currentDelta: { dx: 0, dy: 0 },\n        previews: new Map<NodeId, unknown>(),\n        overrideEntries: new Map<NodeId, { pose: unknown }>(),\n        reflowTargets: new Map<NodeId, unknown>(),\n        gliding: new Set<NodeId>(),\n        caught,\n        projection,\n        behaviors,\n        gestureCtx,\n        adapter,\n        layout,\n        layoutPass: null,\n        pc,\n        applyOps,\n        geometryProjection,\n        lifecycle,\n      };\n\n      // Returns whether anything reached the document.\n      const commitMove = (endCtx: InvocationCtx): boolean => {\n        // Apply the final delta as a single batch → one undo entry.\n        const { dx, dy } = scratch.currentDelta;\n        let committed = false;\n        const commitOps = (ops: Op[]): void => {\n          commitGestureOps(scratch, lifecycle, ops);\n          committed = true;\n        };\n\n        // Behavior pipeline owns the commit if any behavior returns non-undefined.\n        if (scratch.behaviors.length > 0) {\n          const gctx = scratch.gestureCtx;\n          for (const [id, ori] of scratch.startPoses) {\n            gctx.current.set(id as string, translatePoseViaDescriptor(ori, dx, dy, scratch.projection));\n          }\n          const r = reduceBehaviorEnd(scratch.behaviors, gctx);\n          if (r === null) return false;           // abort (e.g. snap-back)\n          if (r !== undefined) {\n            commitOps(r);\n            return true;\n          }\n        }\n\n        // No-op if no movement (sub-threshold drag or zero delta).\n        if (dx === 0 && dy === 0) return false;\n\n        // Layout drop commit — takes precedence over reparent-on-drop when a\n        // layout container accepted the drag this gesture. One placement per\n        // dragged child, replayed in the order the preview resolved them.\n        // TODO: geometryProjection for drop-reflow — left pose-only because the\n        // reflow distributes per-child poses with no single global delta; not\n        // exercised by the geometry contract gate.\n        if (scratch.layout && scratch.layoutPass) {\n          const lp = scratch.layoutPass;\n          const pc = scratch.pc;\n          const commitAdapter = scenePoseAdapter(scratch.scene);\n          const destId = lp.container.id;\n          const draggedIds = new Set<string>(scratch.ids.map((id) => id as string));\n          // commitDrop returns world poses (the contract is world in/out).\n          // Rebase each transform op to local: a dragged id lands under the\n          // destination container; any other id keeps its current parent.\n          // `from` rebases under the node's PRE-commit parent.\n          const rebaseOpToLocal = (op: Op): Op => {\n            if (op.name !== 'transform') return op;\n            const a = op.args as { id: string; from: unknown; to: unknown; label?: string; coalesceKey?: string };\n            const curParent = scratch.scene.get(asNodeId(a.id))?.parent ?? null;\n            const toParent = draggedIds.has(a.id) ? destId : curParent;\n            return createTransformOp<unknown>({\n              id: a.id,\n              from: rebaseLocalPose(commitAdapter, a.from, curParent, pc.compose, pc.decompose),\n              to: rebaseLocalPose(commitAdapter, a.to, toParent, pc.compose, pc.decompose),\n              label: a.label,\n              coalesceKey: a.coalesceKey,\n            });\n          };\n          // Cross-container drop: reparent each dragged node under the\n          // destination container so its tree position matches its new\n          // visual home. Scene v1's absolute-pose semantics mean the\n          // subsequent pose op still lands the child at the snapped cell.\n          // Every reparent precedes every drop.\n          const reparentOps: Op[] = [];\n          const dropOps: Op[] = [];\n          for (const placement of lp.placements) {\n            if (placement.dragged.sourceContainerId !== destId) {\n              reparentOps.push(createReparentOp({\n                id: placement.dragged.id,\n                fromParentId: placement.dragged.sourceContainerId,\n                toParentId: destId,\n                label: 'Reparent',\n              }));\n            }\n            const ops = lp.layout.commitDrop(\n              lp.container,\n              placement.children,\n              placement.dragged,\n              placement.target,\n            );\n            for (const op of ops) dropOps.push(rebaseOpToLocal(op));\n          }\n          const reflowOps: Op[] = [];\n          for (const [cid, worldPose] of lp.sourceReflow) {\n            const parent = scratch.scene.get(asNodeId(cid))?.parent ?? null;\n            // Source-reflow siblings keep their parent, so `from` is already\n            // the live local pose (no rebase); only `to` (a world pose stored\n            // in `lp.sourceReflow`) is rebased to local. This is the\n            // intentional counterpart to the dropOps rebaser above, where\n            // `from` comes from a world `commitDrop` op and so does rebase.\n            reflowOps.push(createTransformOp<unknown>({\n              id: cid,\n              from: scratch.scene.get(asNodeId(cid))!.pose,\n              to: rebaseLocalPose(commitAdapter, worldPose, parent, pc.compose, pc.decompose),\n              label: 'Source reflow',\n            }));\n          }\n          const ops = [...reparentOps, ...dropOps, ...reflowOps];\n          if (ops.length > 0) commitOps(ops);\n          return committed;\n        }\n\n        // No container accepted the drop. Each source layout gets a say\n        // over its own children before they are left wherever the pointer\n        // stopped; the rest of the selection falls through to the translate.\n        const released = new Set<NodeId>();\n        const releasedOps: Op[] = [];\n        if (scratch.layout && !scratch.layoutPass) {\n          const pc = scratch.pc;\n          const commitAdapter = scenePoseAdapter(scratch.scene);\n          // Released children keep their parent, so both ends of a transform\n          // rebase under the same frame.\n          const rebaseReleased = (op: Op): Op => {\n            if (op.name !== 'transform') return op;\n            const a = op.args as { id: string; from: unknown; to: unknown; label?: string; coalesceKey?: string };\n            const parent = scratch.scene.get(asNodeId(a.id))?.parent ?? null;\n            return createTransformOp<unknown>({\n              id: a.id,\n              from: rebaseLocalPose(commitAdapter, a.from, parent, pc.compose, pc.decompose),\n              to: rebaseLocalPose(commitAdapter, a.to, parent, pc.compose, pc.decompose),\n              label: a.label,\n              coalesceKey: a.coalesceKey,\n            });\n          };\n          const sources = groupBySourceContainer(\n            scratch.ids.map((id) => ({\n              id,\n              sourceContainerId: (scratch.scene.get(id)?.parent ?? null) as string | null,\n            })),\n            null,\n          );\n          for (const [srcId, leaving] of sources) {\n            const srcLayout = scratch.layout.getLayout(srcId);\n            if (!srcLayout?.releaseDrop) continue;\n            const srcContainer: LayoutContainer = {\n              id: srcId,\n              bounds: scratch.projection.getBounds(\n                composeWorldPose(commitAdapter, srcId, pc.compose),\n              ),\n            };\n            // What the container is left holding — grown back as each\n            // release puts one of its own home again.\n            let srcChildren: LayoutChild<unknown>[] =\n              scratch.scene.childrenOf(asNodeId(srcId))\n                .filter((cid) => !leaving.has(cid))\n                .map((cid) => ({\n                  id: cid as string,\n                  pose: composeWorldPose(commitAdapter, cid as string, pc.compose),\n                }));\n            for (const id of leaving) {\n              const startWorld = composeWorldPose(\n                grabbedPoseAdapter(scratch, commitAdapter), id as string, pc.compose,\n              );\n              const ops = srcLayout.releaseDrop!(srcContainer, srcChildren, {\n                id: id as string,\n                originPose: startWorld,\n                pose: translatePoseViaDescriptor(startWorld, dx, dy, scratch.projection),\n                sourceContainerId: srcId,\n              });\n              if (ops === null) continue;\n              released.add(id);\n              let landed: unknown = startWorld;\n              for (const op of ops) {\n                const a = op.args as { id?: string; to?: unknown };\n                if (op.name === 'transform' && a.id === (id as string)) landed = a.to;\n                releasedOps.push(rebaseReleased(op));\n              }\n              srcChildren = [...srcChildren, { id: id as string, pose: landed }];\n            }\n          }\n        }\n        if (released.size > 0) {\n          const ops = [\n            ...releasedOps,\n            ...translateCommitOps(scratch, unreleasedIds(scratch, released), dx, dy),\n          ];\n          if (ops.length > 0) commitOps(ops);\n          return committed;\n        }\n\n        // Reparent-on-drop, when opted in via `opts.params.reparentOnDrop`.\n        // Resolves the drop target via the `nodeAtPoint` dep (sourced by\n        // `<SceneCanvas>`) and reparents each moved root under it, then\n        // writes the translated pose in the new parent's frame so the\n        // visual position is preserved across the parent swap.\n        const reparentMode = ((resolveParams(opts?.params)?.['reparentOnDrop'] as ReparentOnDrop | undefined) ?? 'off');\n        const dropTarget = reparentMode !== 'off'\n          ? resolveDropTarget(endCtx, scratch)\n          : null;\n\n        if (dropTarget) {\n          // Reparent-on-drop still commits directly to the scene. Routing\n          // this path through `commitOps` is a separate later task.\n          const reparent = () => applyReparent(scratch, dropTarget, reparentMode, dx, dy, scratch.pc);\n          try {\n            if (lifecycle.transient) scratch.scene.untracked(reparent);\n            else scratch.scene.batch(lifecycle.label, reparent);\n            committed = true;\n          } catch (err) {\n            // The container refused what was dropped into it; like a layout\n            // drop with no target, the drag lands nothing.\n            if (!(err instanceof SceneArrivalRefused)) throw err;\n          }\n        } else {\n          // No reparent — translate-only commit, emitted as transform ops so\n          // it routes through the consumer `applyOps` hook (consumer history)\n          // when present, else the scene's own history. Under scene v1's\n          // absolute-pose semantics every node stores world coords\n          // independently, so a container drag must explicitly re-stamp every\n          // cascaded descendant by the same dx/dy — otherwise children stay at\n          // their old absolute positions (visually they snap to the\n          // container's former location).\n          // Translate the data-held geometry by the same (dx,dy). Opt-in via\n          // the geometryProjection seam; a no-op when the dep is absent.\n          const ops = translateCommitOps(scratch, [...scratch.ids, ...scratch.cascadeIds], dx, dy);\n          if (ops.length > 0) commitOps(ops);\n        }\n        return committed;\n      };\n\n      return {\n        kind: 'move',\n        onMove(moveCtx: InvocationCtx): void {\n          if (!moveCtx.drag) return;\n          if (!engaged) {\n            const s = moveCtx.drag.screenDelta;\n            if (s && !pastDragThreshold({ clientX: 0, clientY: 0 }, { clientX: s.x, clientY: s.y }, dragThresholdPx)) return;\n            engaged = true;\n            lifecycle.start(scratch.ids as string[]);\n          }\n          let dx = moveCtx.drag.delta.x;\n          let dy = moveCtx.drag.delta.y;\n\n          if (scratch.behaviors.length > 0) {\n            const gctx = scratch.gestureCtx;\n            gctx.modifiers = { ...moveCtx.modifiers };\n            gctx.pointer = { worldX: moveCtx.drag.current.x, worldY: moveCtx.drag.current.y, clientX: 0, clientY: 0 };\n            gctx.view = readView();\n            gctx.plane = readPlane();\n            // `current` is pre-populated from the raw cursor delta BEFORE\n            // any behavior shapes `transform`. Unlike `onEnd`, it is NOT\n            // refreshed after each behavior runs — so onMove behaviors\n            // should derive position from `origin` + the `proposed`\n            // GroupTransform arg, NOT from `ctx.current` (which reflects\n            // the unmodified delta at this frame's start).\n            for (const [id, ori] of scratch.startPoses) {\n              gctx.current.set(id as string, translatePoseViaDescriptor(ori, dx, dy, scratch.projection));\n            }\n            let transform: GroupTransform = { kind: 'translate', dx, dy };\n            const primary = scratch.ids[0] as NodeId | undefined;\n            for (const b of scratch.behaviors) {\n              const r: BehaviorResult<unknown> | void = b.onMove?.(gctx, transform);\n              if (!r) continue;\n              if (r.transform && r.transform.kind === 'translate') {\n                transform = r.transform;\n              } else if (r.pose !== undefined && primary !== undefined) {\n                const o = scratch.startPoses.get(primary);\n                if (o !== undefined) {\n                  const from = scratch.projection.getBounds(o);\n                  const to = scratch.projection.getBounds(r.pose);\n                  transform = { kind: 'translate', dx: to.x - from.x, dy: to.y - from.y };\n                }\n              }\n              if (r.snap !== undefined) gctx.snap = r.snap;\n            }\n            if (transform.kind === 'translate') { dx = transform.dx; dy = transform.dy; }\n          }\n\n          // Track delta in scratch only — no scene writes, no history entries.\n          scratch.currentDelta = { dx, dy };\n          // Refresh preview poses for every displaced id (roots + cascade).\n          // The preview-ghost layer reads these via `previewIds`/`previewPose`.\n          scratch.previews.clear();\n          for (const [id, ori] of scratch.startPoses) {\n            if (scratch.carried.has(id)) {\n              scratch.previews.set(id, ori);\n              continue;\n            }\n            const l = localDelta(scratch, id, dx, dy);\n            scratch.previews.set(id, translatePoseViaDescriptor(ori, l.dx, l.dy, scratch.projection));\n          }\n\n          // Layout reflow pass — no-op without a layout dep.\n          scratch.layoutPass = null;\n          scratch.reflowTargets.clear();\n          runLayoutPass(scratch, moveCtx);\n          const reflow = scratch.layout?.reflow;\n          if (reflow) {\n            for (const [id, pose] of scratch.reflowTargets) {\n              reflow.glide(id as string, pose);\n              scratch.gliding.add(id);\n            }\n            for (const id of scratch.gliding) {\n              if (scratch.reflowTargets.has(id)) continue;\n              reflow.settle(id as string);\n              scratch.gliding.delete(id);\n            }\n          }\n\n          // After the layout pass, so a reflowed sibling publishes too.\n          syncPreviewOverrides(scratch);\n        },\n        onEnd(endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          const reflow = scratch.layout?.reflow ?? null;\n          const released = reflow ? releasedPoses(scratch) : null;\n          try {\n            // On cancel the document was never mutated — dropping the\n            // ephemeral overrides below restores the committed poses.\n            if (reason === 'commit') committed = commitMove(endCtx);\n            else runBehaviorCancel(scratch.behaviors, scratch.gestureCtx);\n          } finally {\n            // After the commit, so no frame can paint the pre-drag pose between\n            // the override going away and the document catching up.\n            dropPreviewOverrides(scratch);\n            scratch.previews.clear();\n            // Also after the commit: each glide settles onto the pose the\n            // document now holds, or back home on a cancel — the dragged ids\n            // from where they were let go.\n            if (reflow && released) {\n              for (const id of scratch.gliding) reflow.settle(id as string);\n              landReleased(scratch, reflow, released);\n            }\n            scratch.gliding.clear();\n            lifecycle.end(committed);\n          }\n        },\n        previewIds: () => scratch.previews.keys(),\n        previewPose: (id: string) => scratch.previews.get(id as NodeId) ?? null,\n        previewOpaqueIds: () => scratch.layoutPass?.reflowIds ?? null,\n      };\n    },\n  },\n  /**\n   * Always enabled at the descriptor level. The dispatcher's\n   * specificity-fallthrough loop (`dispatcher.ts`) treats anything\n   * `!== true` from `enabled()` as \"this match is disabled — fall through\n   * to the next-best one.\" Returning `ActionDisabledReason.SelectionRequired`\n   * here caused every drag-on-selected-body to silently lose to lower\n   * specificity ambient bindings (notably `insertAction`'s bare drag),\n   * inserting phantom rects on every move attempt. The invoker self-guards\n   * on empty selection by returning `{}`, so a static `true` is correct\n   * for the dispatcher gate; the command-palette enabled signal will need\n   * a deps-aware predicate when that surface is wired up.\n   *\n   * Phase 7 TODO (still standing): extend `Action.enabled` to accept a\n   * deps snapshot so command-palette enabled state can be selection-aware\n   * without breaking dispatcher routing.\n   */\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":"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"}

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

@@ -0,0 +1,110 @@
+import { createTransformOp as e } from "../../../core/ops/transform.js";
+import { geometryDataOp as t } from "../geometryProjection.js";
+import { translatePoseViaDescriptor as n } from "../../../core/geometry/poseDescriptor.js";
+import { poseDescriptorOf as r } from "../poseDescriptorDep.js";
+import { defaultCommitAdapter as i } from "../defaultCommitAdapter.js";
+import { requiresSelection as a } from "./requiresSelection.js";
+//#region src/interactions/actions/defaults/nudge.ts
+var o = {
+	up: "ArrowUp",
+	down: "ArrowDown",
+	left: "ArrowLeft",
+	right: "ArrowRight"
+}, s = {
+	up: "Up",
+	down: "Down",
+	left: "Left",
+	right: "Right"
+};
+function c(e, t) {
+	switch (e) {
+		case "up": return {
+			dx: 0,
+			dy: -t
+		};
+		case "down": return {
+			dx: 0,
+			dy: t
+		};
+		case "left": return {
+			dx: -t,
+			dy: 0
+		};
+		case "right": return {
+			dx: t,
+			dy: 0
+		};
+	}
+}
+var l = 1, u = 10;
+function d(r, a, o, s, c, l, u) {
+	let d = r.get();
+	if (d.length === 0) return;
+	let f = [
+		1,
+		0,
+		0,
+		1,
+		o,
+		s
+	], p = [];
+	for (let r of d) {
+		let i = a.get(r);
+		if (!i) continue;
+		p.push(e({
+			id: r,
+			from: i.pose,
+			to: n(i.pose, o, s, u),
+			label: "Nudge"
+		}));
+		let c = t(l, {
+			id: r,
+			data: i.data,
+			pose: i.pose
+		}, f, "Nudge");
+		c && p.push(c);
+	}
+	p.length !== 0 && (c ? c(p, "Nudge") : a.applyBatch(p, "Nudge", i(a, r.adapterMethods)));
+}
+function f(e) {
+	return {
+		id: `nudge.${e}`,
+		label: `Nudge ${s[e]}`,
+		group: "nudge",
+		defaultBinding: [{
+			spec: {
+				kind: "key",
+				key: o[e]
+			},
+			opts: { params: { magnitude: "small" } }
+		}, {
+			spec: {
+				kind: "key",
+				key: o[e],
+				mods: { shift: !0 }
+			},
+			opts: { params: { magnitude: "big" } }
+		}],
+		eligible: { capability: "transforms-selection" },
+		requires: [
+			"selection",
+			"scene",
+			"applyOps",
+			"geometryProjection",
+			"poseDescriptor"
+		],
+		invoker: {
+			timing: "immediate",
+			run: (t, n) => {
+				let { dx: i, dy: a } = c(e, (n?.magnitude ?? "small") === "big" ? u : l), o = t.selection, s = t.scene, f = t.applyOps, p = t.geometryProjection;
+				o && s && d(o, s, i, a, f, p, r(t.poseDescriptor));
+			}
+		},
+		enabled: a
+	};
+}
+var p = f("up"), m = f("down"), h = f("left"), g = f("right");
+//#endregion
+export { m as nudgeDownAction, h as nudgeLeftAction, g as nudgeRightAction, p as nudgeUpAction };
+
+//# sourceMappingURL=nudge.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nudge.js","names":["KEY_FOR","LABEL_FOR","delta","dir","step","SMALL_STEP","BIG_STEP","nudgeSelection","ids","selection","m","dx","dy","ops","id","node","scene","createTransformOp","translatePoseViaDescriptor","d","dataOp","geometryDataOp","geometryProjection","applyOps","defaultCommitAdapter","makeNudgeAction","params","deps","poseDescriptorOf","requiresSelection","nudgeUpAction","nudgeDownAction","nudgeLeftAction","nudgeRightAction"],"sources":["../../../../src/interactions/actions/defaults/nudge.ts"],"sourcesContent":["import type { Scene } from 'core/scene/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport type { Op } from 'core/ops/types';\nimport type { Mat3 } from '@weasel-js/geom';\nimport { createTransformOp } from 'core/ops/transform';\nimport type { PoseDescriptor } from '../resize/geometry';\nimport { translatePoseViaDescriptor } from '../resize/geometry';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport type { Action } from '@weasel-js/routing';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { requiresSelection } from './requiresSelection';\nimport { geometryDataOp, type GeometryProjection } from '../geometryProjection';\n\ntype Direction = 'up' | 'down' | 'left' | 'right';\nconst KEY_FOR: Record<Direction, string> = {\n  up: 'ArrowUp', down: 'ArrowDown', left: 'ArrowLeft', right: 'ArrowRight',\n};\nconst LABEL_FOR: Record<Direction, string> = {\n  up: 'Up', down: 'Down', left: 'Left', right: 'Right',\n};\nfunction delta(dir: Direction, step: number): { dx: number; dy: number } {\n  switch (dir) {\n    case 'up':    return { dx: 0,     dy: -step };\n    case 'down':  return { dx: 0,     dy:  step };\n    case 'left':  return { dx: -step, dy: 0     };\n    case 'right': return { dx:  step, dy: 0     };\n  }\n}\n\n/** Default step sizes used by the nudge descriptors. */\nconst SMALL_STEP = 1;\nconst BIG_STEP = 10;\n\n/**\n * Apply a translation of (dx, dy) to all currently-selected nodes by building\n * one `createTransformOp` per node (from = pre-mutation pose, to = nudged\n * pose) and routing the batch through the consumer commit hook. Translates\n * through the `poseDescriptor` dep, so any pose shape moves.\n *\n * Mirrors `moveAction`'s `commitOps` helper: when `deps.applyOps` is present\n * 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 nudge is a\n * single batch → one undo entry, preserving the old `scene.batch('Nudge', …)`\n * semantics exactly.\n */\nfunction nudgeSelection(\n  selection: SelectionApi,\n  scene: Scene<unknown, string, unknown>,\n  dx: number,\n  dy: number,\n  applyOps: ((ops: Op[], label: string) => void) | undefined,\n  geometryProjection: GeometryProjection | undefined,\n  d: PoseDescriptor<unknown>,\n): void {\n  const ids = selection.get();\n  if (ids.length === 0) return;\n  // Pure translation by the nudge step. Pushed alongside each transform op so\n  // a wired geometryProjection mirrors the node's data-held geometry too.\n  const m: Mat3 = [1, 0, 0, 1, dx, dy];\n\n  // Read poses BEFORE building ops so each op's `from` is the pre-mutation\n  // value (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    ops.push(createTransformOp<unknown>({\n      id: id as string,\n      from: node.pose,\n      to: translatePoseViaDescriptor(node.pose, dx, dy, d),\n      label: 'Nudge',\n    }));\n    const dataOp = geometryDataOp(\n      geometryProjection,\n      { id: id as string, data: node.data, pose: node.pose },\n      m,\n      'Nudge',\n    );\n    if (dataOp) ops.push(dataOp);\n  }\n  if (ops.length === 0) return;\n\n  if (applyOps) applyOps(ops, 'Nudge');\n  else scene.applyBatch(ops, 'Nudge', defaultCommitAdapter(scene, selection.adapterMethods));\n}\n\n/**\n * @experimental\n * Build one static nudge descriptor for the given direction. Each descriptor\n * carries two parametric bindings: bare arrow (magnitude='small') and\n * Shift+arrow (magnitude='big').\n *\n * Requires dep-schema entries: `selection`, `scene`.\n */\nfunction makeNudgeAction(dir: Direction): Action & { requires: string[] } {\n  return {\n    id: `nudge.${dir}`,\n    label: `Nudge ${LABEL_FOR[dir]}`,\n    group: 'nudge',\n    defaultBinding: [\n      { spec: { kind: 'key', key: KEY_FOR[dir] },                              opts: { params: { magnitude: 'small' } } },\n      { spec: { kind: 'key', key: KEY_FOR[dir], mods: { shift: true } }, opts: { params: { magnitude: 'big' } } },\n    ],\n    eligible: { capability: 'transforms-selection' },\n    requires: ['selection', 'scene', 'applyOps', 'geometryProjection', 'poseDescriptor'],\n    invoker: {\n      timing: 'immediate',\n      run: (deps, params) => {\n        const magnitude = (params?.magnitude as 'small' | 'big' | undefined) ?? 'small';\n        const step = magnitude === 'big' ? BIG_STEP : SMALL_STEP;\n        const { dx, dy } = delta(dir, step);\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        nudgeSelection(selection, scene, dx, dy, applyOps, geometryProjection, poseDescriptorOf(deps.poseDescriptor));\n      },\n    },\n    enabled: requiresSelection,\n  };\n}\n\nexport const nudgeUpAction    = makeNudgeAction('up');\nexport const nudgeDownAction  = makeNudgeAction('down');\nexport const nudgeLeftAction  = makeNudgeAction('left');\nexport const nudgeRightAction = makeNudgeAction('right');\n"],"mappings":";;;;;;;AAcA,IAAMA,IAAqC;CACzC,IAAI;CAAW,MAAM;CAAa,MAAM;CAAa,OAAO;AAC9D,GACMC,IAAuC;CAC3C,IAAI;CAAM,MAAM;CAAQ,MAAM;CAAQ,OAAO;AAC/C;AACA,SAASC,EAAM,GAAgB,GAA0C;CACvE,QAAQC,GAAR;EACE,KAAK,MAAS,OAAO;GAAE,IAAI;GAAO,IAAI,CAACC;EAAK;EAC5C,KAAK,QAAS,OAAO;GAAE,IAAI;GAAO,IAAKA;EAAK;EAC5C,KAAK,QAAS,OAAO;GAAE,IAAI,CAACA;GAAM,IAAI;EAAM;EAC5C,KAAK,SAAS,OAAO;GAAE,IAAKA;GAAM,IAAI;EAAM;CAC9C;AACF;AAGA,IAAMC,IAAa,GACbC,IAAW;AAejB,SAASC,EACP,GACA,GACA,GACA,GACA,GACA,GACA,GACM;CACN,IAAMC,IAAMC,EAAU,IAAI;CAC1B,IAAID,EAAI,WAAW,GAAG;CAGtB,IAAME,IAAU;EAAC;EAAG;EAAG;EAAG;EAAGC;EAAIC;CAAE,GAI7BC,IAAY,CAAC;CACnB,KAAK,IAAMC,KAAMN,GAAK;EACpB,IAAMO,IAAOC,EAAM,IAAIF,CAAE;EACzB,IAAI,CAACC,GAAM;EACX,EAAI,KAAKE,EAA2B;GAC9B;GACJ,MAAMF,EAAK;GACX,IAAIG,EAA2BH,EAAK,MAAMJ,GAAIC,GAAIO,CAAC;GACnD,OAAO;EACT,CAAC,CAAC;EACF,IAAMC,IAASC,EACbC,GACA;GAAM;GAAc,MAAMP,EAAK;GAAM,MAAMA,EAAK;EAAK,GACrDL,GACA,OACF;EACA,AAAIU,KAAQP,EAAI,KAAKO,CAAM;CAC7B;CACA,AAAIP,EAAI,WAAW,MAEfU,IAAUA,EAASV,GAAK,OAAO,IAC9BG,EAAM,WAAWH,GAAK,SAASW,EAAqBR,GAAOP,EAAU,cAAc,CAAC;AAC3F;AAUA,SAASgB,EAAgB,GAAiD;CACxE,OAAO;EACL,IAAI,SAAStB;EACb,OAAO,SAASF,EAAUE;EAC1B,OAAO;EACP,gBAAgB,CACd;GAAE,MAAM;IAAE,MAAM;IAAO,KAAKH,EAAQG;GAAK;GAAgC,MAAM,EAAE,QAAQ,EAAE,WAAW,QAAQ,EAAE;EAAE,GAClH;GAAE,MAAM;IAAE,MAAM;IAAO,KAAKH,EAAQG;IAAM,MAAM,EAAE,OAAO,GAAK;GAAE;GAAG,MAAM,EAAE,QAAQ,EAAE,WAAW,MAAM,EAAE;EAAE,CAC5G;EACA,UAAU,EAAE,YAAY,uBAAuB;EAC/C,UAAU;GAAC;GAAa;GAAS;GAAY;GAAsB;EAAgB;EACnF,SAAS;GACP,QAAQ;GACR,MAAM,GAAM,MAAW;IAGrB,IAAM,EAAE,OAAI,UAAOD,EAAMC,IAFNuB,GAAQ,aAA6C,aAC7C,QAAQpB,IAAWD,CACZ,GAC5BI,IAAYkB,EAAK,WACjBX,IAAQW,EAAK,OACbJ,IAAWI,EAAK,UAChBL,IAAqBK,EAAK;IAChC,AAAKlB,KAAcO,KACnBT,EAAeE,GAAWO,GAAOL,GAAIC,GAAIW,GAAUD,GAAoBM,EAAiBD,EAAK,cAAc,CAAC;GAC9G;EACF;EACA,SAASE;CACX;AACF;AAEA,IAAaC,IAAmBL,EAAgB,IAAI,GACvCM,IAAmBN,EAAgB,MAAM,GACzCO,IAAmBP,EAAgB,MAAM,GACzCQ,IAAmBR,EAAgB,OAAO"}

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

@@ -0,0 +1,63 @@
+import { DEFAULT_MAX_ZOOM as e, DEFAULT_MIN_ZOOM as t } from "../../../core/viewport/zoomBounds.js";
+import { viewToTransform as n } from "../../../core/viewport/view.js";
+import { screenToWorld as r } from "../../../core/viewport/viewTransform.js";
+import { zoomAt as i } from "../../../core/viewport/zoomAt.js";
+//#region src/interactions/actions/defaults/pinchZoom.ts
+function a(a = {}) {
+	let o = {
+		min: a.min ?? t,
+		max: a.max ?? e
+	};
+	return {
+		id: "viewport.pinchZoom",
+		label: "Pinch Zoom",
+		group: "viewport",
+		defaultBinding: {
+			kind: "multiTouch",
+			fingers: 2
+		},
+		requires: ["view", "debug"],
+		invoker: {
+			timing: "ongoing",
+			start(e, t) {
+				let a = e.deps.view;
+				if (!a) return {};
+				let s = e.multiTouch;
+				if (!s) return {};
+				let c = {
+					view: a,
+					startSpread: s.spread > 0 ? s.spread : 1,
+					centroid: s.centroid
+				}, l = e.deps.debug, u = a.get(), [d, f] = r(s.centroid.x, s.centroid.y, n(u));
+				return {
+					kind: "pinch",
+					onMove(e) {
+						let t = e.multiTouch;
+						if (!t?.pinch) return;
+						let { currentSpread: n, centroid: r } = t.pinch;
+						if (n <= 0 || c.startSpread <= 0) return;
+						let a = n / c.startSpread;
+						c.startSpread = n;
+						let s = c.centroid;
+						c.centroid = r;
+						let p = c.view.get(), m = i(p, s, a, o), h = {
+							scale: m.scale,
+							x: m.x - (r.x - s.x) / m.scale.x,
+							y: m.y - (r.y - s.y) / m.scale.y
+						};
+						c.view.set(h), l?.recordViewport("zoom", u, h, {
+							x: d,
+							y: f
+						});
+					}
+				};
+			}
+		},
+		enabled: () => !0
+	};
+}
+var o = a();
+//#endregion
+export { a as makePinchZoomAction, o as pinchZoomAction };
+
+//# sourceMappingURL=pinchZoom.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pinchZoom.js","names":["makePinchZoomAction","clamp","opts","DEFAULT_MIN_ZOOM","DEFAULT_MAX_ZOOM","view","ctx","multiTouch","scratch","debug","startView","ax","ay","screenToWorld","viewToTransform","mt","moveCtx","currentSpread","factor","prev","centroid","current","zoomed","zoomAt","next","pinchZoomAction"],"sources":["../../../../src/interactions/actions/defaults/pinchZoom.ts"],"sourcesContent":["/**\n * `pinchZoomAction` — ongoing Action descriptor for two-finger pinch zoom\n * and pan. The id and label stay `pinchZoom` / `Pinch Zoom`.\n *\n * ## Status: REAL\n *\n * Implements pinch-zoom via the multi-touch pointer stream:\n *   - `start`: captures startSpread from `ctx.multiTouch.pinch.startSpread`\n *     (or falls back to `ctx.multiTouch.spread`). Records the initial centroid.\n *   - `onMove`: computes zoom factor = currentSpread / startSpread, anchors\n *     `zoomAt` on the previous centroid, then translates by the centroid\n *     delta. Together those pin the world point under the gesture midpoint\n *     as the midpoint moves, so the same gesture zooms and pans.\n *   - `onEnd`: no-op — zoom is already applied each frame.\n *\n * ## Dispatcher extensions required\n *\n * - `InvocationCtx.multiTouch.pinch`: the dispatcher\n *   populates it on every multitouch move-pump event. `startSpread` is\n *   captured once when the handle opens; `currentSpread` updates each frame.\n * - `InputEvent.multitouch.centroid / spread`:\n *   `useGestureDispatcher` synthesizes updated geometry on `pointermove`\n *   when a multitouch handle is in flight.\n *\n * ## Graceful degradation\n *\n * If `ctx.multiTouch.pinch` is absent (e.g. old dispatcher without these\n * extensions), `start` returns an empty handle — no-op, no crash.\n *\n * @see zoomAt — fixed-point zoom primitive from `core/viewport/zoomAt`.\n */\n\nimport type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { ViewApi } from '../depSchema';\nimport { zoomAt } from 'core/viewport/zoomAt';\nimport { viewToTransform } from 'core/viewport/view';\nimport { screenToWorld } from 'core/viewport/viewTransform';\nimport type { DebugSink } from '@weasel-js/routing';\nimport { DEFAULT_MIN_ZOOM, DEFAULT_MAX_ZOOM } from 'core/viewport/zoomBounds';\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\ninterface PinchScratch {\n  view: ViewApi;\n  startSpread: number;\n  centroid: { x: number; y: number };\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Tuning for {@link makePinchZoomAction}.\n */\nexport interface PinchZoomOptions {\n  /** Lower clamp on the resulting view scale, forwarded to `zoomAt`. Default 0.1. */\n  min?: number;\n  /** Upper clamp on the resulting view scale, forwarded to `zoomAt`. Default 8. */\n  max?: number;\n}\n\n/**\n * @experimental\n * Build a `viewport.pinchZoom` Action descriptor with a configurable scale\n * clamp. The binding (two-finger multitouch) is fixed; only the clamp varies.\n *\n * Requires dep-schema entries: `view`.\n *\n * The invoker is `ongoing`. Zoom is applied per-frame via `view.set(zoomAt(...))`.\n */\n// No `eligible` field → pinch zoom is always eligible across all modes.\nexport function makePinchZoomAction(\n  opts: PinchZoomOptions = {},\n): Action & { requires: string[] } {\n  const clamp = { min: opts.min ?? DEFAULT_MIN_ZOOM, max: opts.max ?? DEFAULT_MAX_ZOOM };\n  return {\n    id: 'viewport.pinchZoom',\n    label: 'Pinch Zoom',\n    group: 'viewport',\n    defaultBinding: { kind: 'multiTouch', fingers: 2 },\n    requires: ['view', 'debug'],\n    invoker: {\n      timing: 'ongoing',\n      start(ctx: InvocationCtx, _opts): OngoingHandle {\n        const view = ctx.deps.view as ViewApi | undefined;\n        if (!view) return {};\n\n        const multiTouch = ctx.multiTouch;\n        if (!multiTouch) return {};\n\n        // On start, spread comes from the initial multitouch event.\n        // The pinch field may not be set yet on start (it's populated on moves).\n        const startSpread = multiTouch.spread > 0 ? multiTouch.spread : 1;\n\n        const scratch: PinchScratch = { view, startSpread, centroid: multiTouch.centroid };\n        const debug = ctx.deps.debug as DebugSink | undefined;\n        const startView = view.get();\n        const [ax, ay] = screenToWorld(multiTouch.centroid.x, multiTouch.centroid.y, viewToTransform(startView));\n\n        return {\n          kind: 'pinch',\n          onMove(moveCtx: InvocationCtx): void {\n            const mt = moveCtx.multiTouch;\n            if (!mt?.pinch) return;\n            const { currentSpread, centroid } = mt.pinch;\n            if (currentSpread <= 0 || scratch.startSpread <= 0) return;\n            const factor = currentSpread / scratch.startSpread;\n            // Update startSpread each frame so the factor is incremental.\n            // This avoids drift accumulation across many frames.\n            scratch.startSpread = currentSpread;\n            const prev = scratch.centroid;\n            scratch.centroid = centroid;\n            const current = scratch.view.get();\n            // Anchor the zoom on where the fingers *were*, then translate by how\n            // far they travelled — together those pin the world point under the\n            // centroid as it moves. Anchoring on the new centroid instead drops\n            // the translation half, so a two-finger drag zooms without panning.\n            const zoomed = zoomAt(current, prev, factor, clamp);\n            const next = {\n              scale: zoomed.scale,\n              x: zoomed.x - (centroid.x - prev.x) / zoomed.scale.x,\n              y: zoomed.y - (centroid.y - prev.y) / zoomed.scale.y,\n            };\n            scratch.view.set(next);\n            debug?.recordViewport('zoom', startView, next, { x: ax, y: ay });\n          },\n          // onEnd: nothing to do — zoom was applied each frame.\n        };\n      },\n    },\n    enabled: () => true,\n  };\n}\n\n/**\n * @experimental\n * Default `viewport.pinchZoom` descriptor: two-finger pinch with the kit's\n * default 0.1–8 scale clamp. Equivalent to `makePinchZoomAction()`.\n */\nexport const pinchZoomAction: Action & { requires: string[] } = makePinchZoomAction();\n"],"mappings":";;;;;AA4EA,SAAgBA,EACd,IAAyB,CAAC,GACO;CACjC,IAAMC,IAAQ;EAAE,KAAKC,EAAK,OAAOC;EAAkB,KAAKD,EAAK,OAAOE;CAAiB;CACrF,OAAO;EACL,IAAI;EACJ,OAAO;EACP,OAAO;EACP,gBAAgB;GAAE,MAAM;GAAc,SAAS;EAAE;EACjD,UAAU,CAAC,QAAQ,OAAO;EAC1B,SAAS;GACP,QAAQ;GACR,MAAM,GAAoB,GAAsB;IAC9C,IAAMC,IAAOC,EAAI,KAAK;IACtB,IAAI,CAACD,GAAM,OAAO,CAAC;IAEnB,IAAME,IAAaD,EAAI;IACvB,IAAI,CAACC,GAAY,OAAO,CAAC;IAMzB,IAAMC,IAAwB;KAAE;KAAM,aAFlBD,EAAW,SAAS,IAAIA,EAAW,SAAS;KAEb,UAAUA,EAAW;IAAS,GAC3EE,IAAQH,EAAI,KAAK,OACjBI,IAAYL,EAAK,IAAI,GACrB,CAACM,GAAIC,KAAMC,EAAcN,EAAW,SAAS,GAAGA,EAAW,SAAS,GAAGO,EAAgBJ,CAAS,CAAC;IAEvG,OAAO;KACL,MAAM;KACN,OAAO,GAA8B;MACnC,IAAMK,IAAKC,EAAQ;MACnB,IAAI,CAACD,GAAI,OAAO;MAChB,IAAM,EAAE,kBAAe,gBAAaA,EAAG;MACvC,IAAIE,KAAiB,KAAKT,EAAQ,eAAe,GAAG;MACpD,IAAMU,IAASD,IAAgBT,EAAQ;MAGvC,EAAQ,cAAcS;MACtB,IAAME,IAAOX,EAAQ;MACrB,EAAQ,WAAWY;MACnB,IAAMC,IAAUb,EAAQ,KAAK,IAAI,GAK3Bc,IAASC,EAAOF,GAASF,GAAMD,GAAQjB,CAAK,GAC5CuB,IAAO;OACX,OAAOF,EAAO;OACd,GAAGA,EAAO,KAAKF,EAAS,IAAID,EAAK,KAAKG,EAAO,MAAM;OACnD,GAAGA,EAAO,KAAKF,EAAS,IAAID,EAAK,KAAKG,EAAO,MAAM;MACrD;MAEA,AADAd,EAAQ,KAAK,IAAIgB,CAAI,GACrBf,GAAO,eAAe,QAAQC,GAAWc,GAAM;OAAE,GAAGb;OAAI,GAAGC;MAAG,CAAC;KACjE;IAEF;GACF;EACF;EACA,eAAe;CACjB;AACF;AAOA,IAAaa,IAAmDzB,EAAoB"}

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

@@ -0,0 +1,143 @@
+import { defaultCommitAdapter as e } from "../defaultCommitAdapter.js";
+import { BringForwardIcon as t, BringToFrontIcon as n, SendBackwardIcon as r, SendToBackIcon as i } from "./icons/editIcons.js";
+import { requiresSelection as a } from "./requiresSelection.js";
+import { createReorderOp as o } from "../../../core/ops/reorder/index.js";
+import { createElement as s } from "react";
+//#region src/interactions/actions/defaults/reorder.ts
+function c(t, n, r, i, a) {
+	let s = t.get();
+	if (s.length === 0) return;
+	let c = o({
+		ids: s,
+		direction: r === "forward" ? i === "extreme" ? "front" : "forward" : i === "extreme" ? "back" : "backward",
+		label: "Reorder"
+	});
+	a ? a([c], "Reorder") : n.applyBatch([c], "Reorder", e(n, t.adapterMethods));
+}
+var l = {
+	id: "reorder.forward",
+	label: "Bring Forward",
+	group: "reorder",
+	variants: [{
+		key: "adjacent",
+		label: "Bring Forward",
+		icon: s(t),
+		params: { distance: "adjacent" }
+	}, {
+		key: "extreme",
+		label: "Bring to Front",
+		icon: s(n),
+		params: { distance: "extreme" }
+	}],
+	defaultBinding: [
+		{
+			spec: {
+				kind: "key",
+				key: ["]"],
+				mods: { mod: !0 }
+			},
+			opts: { params: { distance: "adjacent" } }
+		},
+		{
+			spec: {
+				kind: "key",
+				key: ["]", "}"],
+				mods: {
+					mod: !0,
+					shift: !0
+				}
+			},
+			opts: { params: { distance: "extreme" } }
+		},
+		{
+			spec: {
+				kind: "key",
+				key: ["]", "‘"],
+				mods: {
+					mod: !0,
+					alt: !0
+				}
+			},
+			opts: { params: { distance: "extreme" } }
+		}
+	],
+	eligible: { capability: "edits-page" },
+	requires: [
+		"selection",
+		"scene",
+		"applyOps"
+	],
+	invoker: {
+		timing: "immediate",
+		run: (e, t) => {
+			let n = t?.distance ?? "adjacent", r = e.selection, i = e.scene, a = e.applyOps;
+			r && i && c(r, i, "forward", n, a);
+		}
+	},
+	enabled: a
+}, u = {
+	id: "reorder.backward",
+	label: "Send Backward",
+	group: "reorder",
+	variants: [{
+		key: "adjacent",
+		label: "Send Backward",
+		icon: s(r),
+		params: { distance: "adjacent" }
+	}, {
+		key: "extreme",
+		label: "Send to Back",
+		icon: s(i),
+		params: { distance: "extreme" }
+	}],
+	defaultBinding: [
+		{
+			spec: {
+				kind: "key",
+				key: ["["],
+				mods: { mod: !0 }
+			},
+			opts: { params: { distance: "adjacent" } }
+		},
+		{
+			spec: {
+				kind: "key",
+				key: ["[", "{"],
+				mods: {
+					mod: !0,
+					shift: !0
+				}
+			},
+			opts: { params: { distance: "extreme" } }
+		},
+		{
+			spec: {
+				kind: "key",
+				key: ["[", "“"],
+				mods: {
+					mod: !0,
+					alt: !0
+				}
+			},
+			opts: { params: { distance: "extreme" } }
+		}
+	],
+	eligible: { capability: "edits-page" },
+	requires: [
+		"selection",
+		"scene",
+		"applyOps"
+	],
+	invoker: {
+		timing: "immediate",
+		run: (e, t) => {
+			let n = t?.distance ?? "adjacent", r = e.selection, i = e.scene, a = e.applyOps;
+			r && i && c(r, i, "backward", n, a);
+		}
+	},
+	enabled: a
+};
+//#endregion
+export { u as reorderBackwardAction, l as reorderForwardAction };
+
+//# sourceMappingURL=reorder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reorder.js","names":["reorderSelection","ids","selection","op","createReorderOp","direction","distance","applyOps","scene","defaultCommitAdapter","reorderForwardAction","createElement","BringForwardIcon","BringToFrontIcon","params","deps","requiresSelection","reorderBackwardAction","SendBackwardIcon","SendToBackIcon"],"sources":["../../../../src/interactions/actions/defaults/reorder.ts"],"sourcesContent":["import { createReorderOp } from 'core/ops/reorder';\nimport { createElement } from 'react';\nimport { BringForwardIcon, BringToFrontIcon, SendBackwardIcon, SendToBackIcon } from './icons/editIcons';\nimport type { Scene } from 'core/scene/types';\nimport type { Op } from 'core/ops/types';\nimport type { SelectionApi } from 'core/selection/useSelection';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport type { Action } from '@weasel-js/routing';\nimport { requiresSelection } from './requiresSelection';\n\n// ---------------------------------------------------------------------------\n// Shared helper\n// ---------------------------------------------------------------------------\n\ntype ReorderDistance = 'adjacent' | 'extreme';\n\n/**\n * Execute a directional reorder on the current selection. Translates\n * `direction` + `distance` into the four-way `ReorderDirection` understood by\n * `createReorderOp`, then routes the single reorder op through the consumer\n * `applyOps` commit hook (consumer history) when present, falling back to\n * `scene.applyBatch` against the shared `defaultCommitAdapter`. Either way the\n * whole reorder lands as one undo entry labelled `'Reorder'`.\n */\nfunction reorderSelection(\n  selection: SelectionApi,\n  scene: Scene<unknown, string, unknown>,\n  direction: 'forward' | 'backward',\n  distance: ReorderDistance,\n  applyOps: ((ops: Op[], label: string) => void) | undefined,\n): void {\n  const ids = selection.get() as string[];\n  if (ids.length === 0) return;\n\n  const reorderDir =\n    direction === 'forward'\n      ? distance === 'extreme' ? 'front' : 'forward'\n      : distance === 'extreme' ? 'back' : 'backward';\n\n  // `createReorderOp` partitions `ids` by their current parent and rewrites\n  // each affected parent's child order via the adapter's `getChildren` /\n  // `setChildOrder` (and `getParent`) — all carried by `defaultCommitAdapter`.\n  const op = createReorderOp({ ids, direction: reorderDir, label: 'Reorder' });\n\n  if (applyOps) applyOps([op], 'Reorder');\n  else scene.applyBatch([op], 'Reorder', defaultCommitAdapter(scene, selection.adapterMethods));\n}\n\n// ---------------------------------------------------------------------------\n// Descriptors\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Parametric descriptor for forward reorder (`reorder.forward`).\n *\n * Collapses the old `reorder.forward` (adjacent) and `reorder.front`\n * (extreme) actions into one descriptor with two keybindings. The distance\n * param (`'adjacent'` | `'extreme'`) is carried in `opts.params.distance`\n * and forwarded to `invoker.run` by the dispatcher.\n */\nexport const reorderForwardAction: Action & { requires: string[] } = {\n  id: 'reorder.forward',\n  label: 'Bring Forward',\n  group: 'reorder',\n  variants: [\n    { key: 'adjacent', label: 'Bring Forward', icon: createElement(BringForwardIcon), params: { distance: 'adjacent' } },\n    { key: 'extreme', label: 'Bring to Front', icon: createElement(BringToFrontIcon), params: { distance: 'extreme' } },\n  ],\n  defaultBinding: [\n    {\n      // Modifier matching is strict, so Shift must be absent here — listing\n      // the shifted `'}'` on this binding would be dead weight, since you\n      // can't type it without the Shift this spec forbids.\n      spec: { kind: 'key', key: [']'], mods: { mod: true } },\n      opts: { params: { distance: 'adjacent' } },\n    },\n    {\n      // Cmd+Shift+] → bring-to-front, the convention every drawing app uses.\n      // With Shift held the US-layout key reports as '}', so both characters\n      // are listed. Some browsers bind Cmd+Shift+[ / ] to tab switching and\n      // may consume the event before the page sees it — hence the Cmd+Alt\n      // binding below, which nothing reserves.\n      spec: { kind: 'key', key: [']', '}'], mods: { mod: true, shift: true } },\n      opts: { params: { distance: 'extreme' } },\n    },\n    {\n      // Cmd+Alt+] → bring-to-front. On macOS Option+] emits '‘' (U+2018);\n      // whether Cmd suppresses that transform is browser-dependent, so match\n      // both the bracket and the Option-produced char (US layout). matchKey is\n      // character-based, so non-US layouts may need a rebind.\n      spec: { kind: 'key', key: [']', '‘'], mods: { mod: true, alt: true } },\n      opts: { params: { distance: 'extreme' } },\n    },\n  ],\n  eligible: { capability: 'edits-page' },\n  requires: ['selection', 'scene', 'applyOps'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps, params) => {\n      const distance = (params?.distance as ReorderDistance | undefined) ?? 'adjacent';\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      reorderSelection(selection, scene, 'forward', distance, applyOps);\n    },\n  },\n  enabled: requiresSelection,\n};\n\n/**\n * @experimental\n * Parametric descriptor for backward reorder (`reorder.backward`).\n *\n * Collapses the old `reorder.backward` (adjacent) and `reorder.back`\n * (extreme) actions into one descriptor with two keybindings.\n */\nexport const reorderBackwardAction: Action & { requires: string[] } = {\n  id: 'reorder.backward',\n  label: 'Send Backward',\n  group: 'reorder',\n  variants: [\n    { key: 'adjacent', label: 'Send Backward', icon: createElement(SendBackwardIcon), params: { distance: 'adjacent' } },\n    { key: 'extreme', label: 'Send to Back', icon: createElement(SendToBackIcon), params: { distance: 'extreme' } },\n  ],\n  defaultBinding: [\n    {\n      spec: { kind: 'key', key: ['['], mods: { mod: true } },\n      opts: { params: { distance: 'adjacent' } },\n    },\n    {\n      // Cmd+Shift+[ → send-to-back. See the bring-to-front notes above.\n      spec: { kind: 'key', key: ['[', '{'], mods: { mod: true, shift: true } },\n      opts: { params: { distance: 'extreme' } },\n    },\n    {\n      // Cmd+Alt+[ → send-to-back, the binding no browser reserves. On macOS\n      // Option+[ emits '“' (U+201C), included alongside the bracket.\n      spec: { kind: 'key', key: ['[', '“'], mods: { mod: true, alt: true } },\n      opts: { params: { distance: 'extreme' } },\n    },\n  ],\n  eligible: { capability: 'edits-page' },\n  requires: ['selection', 'scene', 'applyOps'],\n  invoker: {\n    timing: 'immediate',\n    run: (deps, params) => {\n      const distance = (params?.distance as ReorderDistance | undefined) ?? 'adjacent';\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      reorderSelection(selection, scene, 'backward', distance, applyOps);\n    },\n  },\n  enabled: requiresSelection,\n};\n\n"],"mappings":"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"}

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

@@ -0,0 +1,10 @@
+import { ActionDisabledReason as e } from "@weasel-js/routing";
+//#region src/interactions/actions/defaults/requiresSelection.ts
+function t(t) {
+	let n = t?.selection;
+	return !n || n.get().length === 0 ? e.SelectionRequired : !0;
+}
+//#endregion
+export { t as requiresSelection };
+
+//# sourceMappingURL=requiresSelection.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requiresSelection.js","names":["requiresSelection","selection","deps","ActionDisabledReason"],"sources":["../../../../src/interactions/actions/defaults/requiresSelection.ts"],"sourcesContent":["import type { SelectionApi } from 'core/selection/useSelection';\nimport type { ActionDeps } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\n\n/**\n * Shared `enabled` predicate for selection-gated actions (reorder, duplicate,\n * flip, nudge, …).\n *\n * Returns `true` when the active selection is non-empty, otherwise\n * `SelectionRequired` so the palette/ActionBar can grey the entry out.\n *\n * The dispatcher evaluates this gate with the action's built deps, so a\n * deps-aware predicate is required for these actions to dispatch at all — a\n * constant `() => SelectionRequired` stub falls through forever. When called\n * without deps (e.g. a bare `enabled()` introspection) it conservatively\n * reports `SelectionRequired`; the invoker independently no-ops on an empty\n * selection, so dispatch correctness never relies on the gate alone.\n */\nexport function requiresSelection(deps?: ActionDeps): true | ActionDisabledReason {\n  const selection = deps?.selection as SelectionApi | undefined;\n  if (!selection || (selection.get() as unknown[]).length === 0) {\n    return ActionDisabledReason.SelectionRequired;\n  }\n  return true;\n}\n"],"mappings":";;AAkBA,SAAgBA,EAAkB,GAAgD;CAChF,IAAMC,IAAYC,GAAM;CAIxB,OAHI,CAACD,KAAcA,EAAU,IAAI,CAAC,CAAe,WAAW,IACnDE,EAAqB,oBAEvB;AACT"}