@weasel-js/core 1.9.3 → 1.10.0

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

@@ -1 +0,0 @@
-{"version":3,"file":"resize.js","names":["IDENTITY_EXPAND","ids","EMPTY_POINT_SNAP","resolveDeps","geometry","poseDescriptorOf","ctx","dep","DEFAULT_RESIZE_BEHAVIORS","buildPointSnapContext","cx","pose","cy","tl","rotatePoint","rotation","tr","br","bl","draggedCorner","fixedCorner","anchor","fixedPt","draggedPt","applyPointSnap","result","dx","dy","pin","Dx","Dy","cos","sin","localW","localH","newWidth","newHeight","newCx","newCy","pointSnapToCamera","cam","w","fromPlane","m","p","pointSnapFromPlane","r","toPlane","computeProposedBounds","cs","sn","dxLocal","dyLocal","nx","ob","ny","nw","nh","resizeAction","inPlane","selection","scene","applyOps","geometryProjection","expanded","expandIds","isGroupPath","writeIds","frame","scenePoseFrame","view","stored","layer","id","carryPose","world","planeOf","startPoses","startWorlds","leafBounds","node","invertPlane","originBounds","unionBounds","originPose","originRotation","fixedLocal","fixedCornerOf","fixedWorld","startWorld","readView","gestureViewReader","readPlane","gesturePlaneReader","gestureCtx","ctxAsRect","b","behaviors","scratch","readGestureLifecycle","policy","commitResize","target","defaultCommitAdapter","reduceBehaviorEnd","commitGestureOps","lifecycle","ops","next","from","committed","sb","db","boxToBox","dataOp","geometryDataOp","nb","createTransformOp","mctx","proposedBounds","behaviorCtx","computePose","sp","poseRotationOf","remapRotatedLeaf","proposedPose","newCenterX","newCenterY","newFixedLocal","newFixedWorld","correctionX","correctionY","translatePoseViaDescriptor","poseAsRect","psCtx","plane","beh","reason","runBehaviorCancel","dropPreviewOverrides","selectionLayer"],"sources":["../../../../src/interactions/actions/defaults/resize.ts"],"sourcesContent":["/**\n * `resizeAction` — ongoing Action descriptor for anchor-relative drag resize.\n *\n * ## Status: REAL\n *\n * Performs real anchor-relative resize math for rect-shaped poses. Reads\n * `ctx.drag.affordance.anchor` to determine which corner is fixed, captures\n * start poses, applies per-frame bounds remapping, and commits one batch on\n * end — labeled, transient and observed per the `resizePolicy` dep's\n * lifecycle fields.\n *\n * ## Behaviors / point-snap / expandIds — via the `resizePolicy` dep\n *\n * The `resizePolicy` dep carries the behavior options the legacy `useResize`\n * hook exposed (`behaviors`, `pointSnapBehaviors`, `expandIds`). When the dep\n * is registered, this invoker:\n *\n *  - Calls `expandIds([id])` at start. When the result expands beyond the\n *    starting id, takes the group path (union-AABB origin, per-leaf remap).\n *  - Runs `behaviors[]` after the raw anchor-math bounds are computed.\n *    Behaviors return `{ pose? }` and rewrite the proposed bounds before\n *    they're projected back into pose space.\n *  - Runs `pointSnap[]` after the bounds→pose projection. The first non-null\n *    `PointSnapResult` wins; this invoker back-solves a pose so the chosen\n *    frame's world point lands on the snap target.\n *\n * When the dep is absent the invoker falls back to identity defaults\n * (no behaviors, no snap, `ids => ids` expansion).\n *\n * ## Pose geometry — via the `poseDescriptor` dep\n *\n * Every pose read and rewrite goes through the `poseDescriptor` dep, which\n * `<SceneCanvas>` sources from its `poseDescriptor` prop. Unsourced it is\n * `AUTO_POSE_DESCRIPTOR`, which dispatches per call to `pathPoseDescriptor`\n * for Path-shaped poses and to `RECT_POSE_DESCRIPTOR` for everything else.\n *\n * @see useResize — the React hook this descriptor mirrors.\n * @see src/interactions/actions/resize/geometry.ts — `PoseDescriptor`.\n */\n\nimport { gesturePlaneReader, gestureViewReader } from '../../gestures/shared/screenTolerance';\nimport type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { syncPreviewOverrides, dropPreviewOverrides } from '../previewOverrides';\nimport type {\n  GestureContext,\n  ModifierState,\n  PointSnapBehavior,\n  PointSnapContext,\n  PointSnapResult,\n  ResizeAnchor,\n  BoundsConstraint,\n  RotatedPose,\n} from '../../gestures/types';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport type { ResizePolicy } from '../depSchema';\nimport { DEFAULT_RESIZE_BEHAVIORS } from '../resize/behaviors';\nimport { remapRotatedLeaf, translatePoseViaDescriptor, type PoseDescriptor } from '../resize/geometry';\nimport { poseRotationOf } from 'core/geometry/poseRotation';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport { fixedCornerOf } from '../resize/cornerHandles';\nimport { rotatePoint } from '../rotate/geometry';\nimport type { Op } from 'core/ops/types';\nimport type { Mat3 } from '@weasel-js/geom';\nimport { boxToBox } from '@weasel-js/geom';\nimport { createTransformOp } from 'core/ops/transform';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { geometryDataOp, type GeometryProjection } from '../geometryProjection';\nimport { unionBounds } from 'core/geometry/unionBounds';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { commitGestureOps, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel, type GestureLifecycle } from '../gestureLifecycle';\nimport { carryPose, invertPlane, inPlane, planeOf, selectionLayer } from '../planeInput';\nimport { fromPlane, toPlane, type PlaneMap } from 'core/viewport/parallax';\n\n// ---------------------------------------------------------------------------\n// Defaults applied when `resizePolicy` dep is absent. Mirrors the\n// destructuring defaults in `useResize`.\n// ---------------------------------------------------------------------------\n\nconst IDENTITY_EXPAND = (ids: string[]) => ids;\nconst EMPTY_POINT_SNAP: PointSnapBehavior<Bounds>[] = [];\n\nfunction resolveDeps(ctx: InvocationCtx): {\n  behaviors: BoundsConstraint<Bounds>[];\n  pointSnap: PointSnapBehavior<Bounds>[];\n  expandIds: (ids: string[]) => string[];\n  geometry: PoseDescriptor<unknown>;\n  policy: ResizePolicy<unknown> | undefined;\n} {\n  const geometry = poseDescriptorOf(ctx.deps.poseDescriptor);\n  const dep = ctx.deps.resizePolicy;\n  if (!dep) {\n    return {\n      // Standard kit behaviors (shift = aspect lock) apply even with no\n      // policy wired; consumers opt out via an explicit `behaviors: []`.\n      behaviors: DEFAULT_RESIZE_BEHAVIORS as BoundsConstraint<Bounds>[],\n      pointSnap: EMPTY_POINT_SNAP,\n      expandIds: IDENTITY_EXPAND,\n      geometry,\n      policy: undefined,\n    };\n  }\n  return {\n    behaviors: dep.constraints as unknown as BoundsConstraint<Bounds>[],\n    pointSnap: dep.pointSnap as unknown as PointSnapBehavior<Bounds>[],\n    expandIds: dep.expandIds,\n    geometry,\n    policy: dep,\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Point-snap math (lifted from `useResize`).\n// ---------------------------------------------------------------------------\n\nfunction buildPointSnapContext<TPose extends Bounds>(\n  pose: TPose,\n  rotation: number,\n  anchor: ResizeAnchor,\n  modifiers: ModifierState,\n): PointSnapContext<TPose> {\n  const cx = pose.x + pose.width / 2;\n  const cy = pose.y + pose.height / 2;\n\n  const tl = rotatePoint(pose.x, pose.y, cx, cy, rotation);\n  const tr = rotatePoint(pose.x + pose.width, pose.y, cx, cy, rotation);\n  const br = rotatePoint(pose.x + pose.width, pose.y + pose.height, cx, cy, rotation);\n  const bl = rotatePoint(pose.x, pose.y + pose.height, cx, cy, rotation);\n\n  let draggedCorner: { worldX: number; worldY: number } | null = null;\n  let fixedCorner: { worldX: number; worldY: number } | null = null;\n\n  if (anchor.x !== 'free' && anchor.y !== 'free') {\n    const fixedPt =\n      anchor.x === 'min' && anchor.y === 'min' ? tl :\n      anchor.x === 'max' && anchor.y === 'min' ? tr :\n      anchor.x === 'max' && anchor.y === 'max' ? br : bl;\n    const draggedPt =\n      anchor.x === 'min' && anchor.y === 'min' ? br :\n      anchor.x === 'max' && anchor.y === 'min' ? bl :\n      anchor.x === 'max' && anchor.y === 'max' ? tl : tr;\n    fixedCorner = { worldX: fixedPt.x, worldY: fixedPt.y };\n    draggedCorner = { worldX: draggedPt.x, worldY: draggedPt.y };\n  }\n\n  return {\n    draggedCorner,\n    fixedCorner,\n    center: { worldX: cx, worldY: cy },\n    origin: { worldX: tl.x, worldY: tl.y },\n    rotation,\n    anchor,\n    proposed: pose,\n    modifiers,\n  };\n}\n\nfunction applyPointSnap<TPose extends Bounds>(\n  pose: TPose,\n  rotation: number,\n  result: PointSnapResult,\n  ctx: PointSnapContext<TPose>,\n): TPose {\n  if (result.frame === 'center') {\n    const dx = result.worldX - ctx.center.worldX;\n    const dy = result.worldY - ctx.center.worldY;\n    return { ...pose, x: pose.x + dx, y: pose.y + dy };\n  }\n  if (result.frame === 'origin') {\n    const dx = result.worldX - ctx.origin.worldX;\n    const dy = result.worldY - ctx.origin.worldY;\n    return { ...pose, x: pose.x + dx, y: pose.y + dy };\n  }\n  const pin = result.frame === 'dragged-corner' ? ctx.fixedCorner : ctx.draggedCorner;\n  if (!pin) return pose;\n  const Dx = result.worldX - pin.worldX;\n  const Dy = result.worldY - pin.worldY;\n  const cos = Math.cos(rotation);\n  const sin = Math.sin(rotation);\n  const localW = Dx * cos + Dy * sin;\n  const localH = -Dx * sin + Dy * cos;\n  const newWidth = Math.abs(localW);\n  const newHeight = Math.abs(localH);\n  const newCx = (pin.worldX + result.worldX) / 2;\n  const newCy = (pin.worldY + result.worldY) / 2;\n  return { ...pose, x: newCx - newWidth / 2, y: newCy - newHeight / 2, width: newWidth, height: newHeight };\n}\n\n/** `ctx`'s points in the camera's world, for a snap rule written against it. */\nfunction pointSnapToCamera<TPose extends Bounds>(\n  ctx: PointSnapContext<TPose>,\n  m: PlaneMap,\n): PointSnapContext<TPose> {\n  const cam = (p: { worldX: number; worldY: number }) => {\n    const w = fromPlane(m, { x: p.worldX, y: p.worldY });\n    return { worldX: w.x, worldY: w.y };\n  };\n  return {\n    ...ctx,\n    draggedCorner: ctx.draggedCorner && cam(ctx.draggedCorner),\n    fixedCorner: ctx.fixedCorner && cam(ctx.fixedCorner),\n    center: cam(ctx.center),\n    origin: cam(ctx.origin),\n  };\n}\n\n/** A snap rule's answer, back in the plane the resize works in. */\nfunction pointSnapFromPlane(\n  r: PointSnapResult | null | undefined,\n  m: PlaneMap,\n): PointSnapResult | null | undefined {\n  if (!r) return r;\n  const p = toPlane(m, { x: r.worldX, y: r.worldY });\n  return { ...r, worldX: p.x, worldY: p.y };\n}\n\n// ---------------------------------------------------------------------------\n// Anchor math (rotated and unrotated).\n// ---------------------------------------------------------------------------\n\nfunction computeProposedBounds(\n  ob: Bounds,\n  anchor: ResizeAnchor,\n  dx: number,\n  dy: number,\n  rotation: number,\n): Bounds {\n  if (rotation !== 0) {\n    const cs = Math.cos(-rotation);\n    const sn = Math.sin(-rotation);\n    const dxLocal = cs * dx - sn * dy;\n    const dyLocal = sn * dx + cs * dy;\n    dx = dxLocal;\n    dy = dyLocal;\n  }\n  let nx = ob.x;\n  let ny = ob.y;\n  let nw = ob.width;\n  let nh = ob.height;\n  if (anchor.x === 'min') {\n    nw = ob.width + dx;\n  } else if (anchor.x === 'max') {\n    nx = ob.x + dx;\n    nw = ob.width - dx;\n  }\n  if (anchor.y === 'min') {\n    nh = ob.height + dy;\n  } else if (anchor.y === 'max') {\n    ny = ob.y + dy;\n    nh = ob.height - dy;\n  }\n  return { x: nx, y: ny, width: nw, height: nh };\n}\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\ninterface ResizeScratch {\n  /** Ids the gesture writes to. For group expansion this is the leaf set;\n   *  for the single-id path it's the original selection. */\n  writeIds: NodeId[];\n  scene: Scene<unknown, string, unknown>;\n  /** World reads and local writes over the scene's composition strategy. */\n  frame: PoseFrame<unknown>;\n  /** Start poses keyed by write id, as stored — the `from` of each op. */\n  startPoses: Map<NodeId, unknown>;\n  /** Start poses in world — the frame the anchor math and the drag share. */\n  startWorlds: Map<NodeId, unknown>;\n  /** Shared origin bounds (union for group/multi-select, own bounds for\n   *  single). Used as the `src` rect for `geometry.remapBounds`. */\n  originBounds: Bounds;\n  anchor: ResizeAnchor;\n  startWorld: { x: number; y: number };\n  /** Rotation captured at gesture start (from `geometry.getRotation?`). */\n  originRotation: number;\n  /** World-space position of the diagonally opposite corner at start. Used\n   *  for the rotated-resize fixed-corner pin correction. */\n  fixedWorld: { x: number; y: number };\n  /** In-flight preview poses buffered during drag. */\n  previews: Map<NodeId, unknown>;\n  overrideEntries: Map<NodeId, { pose: unknown }>;\n  geometry: PoseDescriptor<unknown>;\n  behaviors: BoundsConstraint<Bounds>[];\n  pointSnap: PointSnapBehavior<Bounds>[];\n  /** Gesture context handed to behaviors. Reused across move/end. */\n  gestureCtx: GestureContext<unknown>;\n  /** Optional consumer commit hook captured at gesture start. When present,\n   *  the final pose commit routes 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   *  commit emits a `setData` op per leaf mapping its data-held geometry by\n   *  the box→box affine the pose underwent. Undefined → pose-only commit. */\n  geometryProjection?: GeometryProjection;\n  /** Label, history and callbacks from the `resizePolicy` dep. */\n  lifecycle: GestureLifecycle;\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `resize` Action.\n *\n * Requires dep-schema entries: `selection`, `scene`.\n * Reads optional `resizePolicy` dep when present.\n * Requires `InvocationCtx.drag.affordance` with a `handle:*` kind.\n */\nexport const resizeAction: Action & { requires: string[] } = inPlane({\n  id: 'resize',\n  label: 'Resize',\n  // No default binding: a bare `{ kind: 'drag' }` claimed every drag at ambient\n  // scope, tying areaSelect's. The resize handles bind it\n  // (`selectionResizeBindings`, the `resize` preset).\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'resizePolicy', 'poseDescriptor', 'applyOps', 'geometryProjection', 'poseComposition', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, _opts): OngoingHandle {\n      const selection = ctx.deps.selection;\n      const scene = ctx.deps.scene;\n      const applyOps = ctx.deps.applyOps;\n      const geometryProjection = ctx.deps.geometryProjection;\n\n      if (!selection || !scene) return {};\n\n      const ids = selection.get() as NodeId[];\n      if (ids.length === 0) return {};\n\n      const affordance = ctx.drag?.affordance;\n      const anchor = affordance?.anchor;\n      if (!anchor) return {};\n\n      const { behaviors, pointSnap, expandIds, geometry, policy } = resolveDeps(ctx);\n\n      // Group expansion. When the starting selection is a single id but\n      // `expandIds` returns a different set, we're in the group path:\n      // every leaf is written, and origin bounds is the union AABB.\n      // When `expandIds` returns the same list (identity default or no-op),\n      // we write the selected ids directly.\n      const expanded = expandIds(ids as unknown as string[]);\n      if (expanded.length === 0) return {};\n\n      const isGroupPath =\n        ids.length === 1 && (expanded.length !== 1 || expanded[0] !== (ids[0] as string));\n      const writeIds = (isGroupPath ? expanded : (ids as unknown as string[])) as NodeId[];\n\n      // Capture start poses + per-leaf bounds. The drag delta is world, so\n      // the anchor math runs on world poses — carried into the plane the edit\n      // is measured in — and each result is carried back to its node's plane\n      // and stored in the node's own parent frame.\n      const frame = scenePoseFrame(scene, ctx.deps.poseComposition);\n      const view = ctx.deps.view;\n      /** A world result for `id`, as stored. */\n      const stored = (id: NodeId, world: unknown): unknown => {\n        const layer = scene.get(id)?.layer;\n        return frame.local(id, carryPose(geometry, world, layer === undefined ? null : planeOf(view, layer)));\n      };\n      const startPoses = new Map<NodeId, unknown>();\n      const startWorlds = new Map<NodeId, unknown>();\n      const leafBounds: Bounds[] = [];\n      for (const id of writeIds) {\n        const node = scene.get(id);\n        if (!node) continue;\n        startPoses.set(id, node.pose);\n        const world = carryPose(geometry, frame.world(id), invertPlane(planeOf(view, node.layer)));\n        startWorlds.set(id, world);\n        leafBounds.push(geometry.getBounds(world));\n      }\n      if (startPoses.size === 0) return {};\n\n      // `leafBounds` is non-empty here (startPoses.size === 0 guarded above),\n      // and the union branch only runs for length >= 2 → `!` is safe.\n      const originBounds = leafBounds.length === 1\n        ? leafBounds[0]\n        : unionBounds(leafBounds)!;\n\n      // Rotation captured only for the single-write-id path; group-resize\n      // takes the AABB-frame (unrotated) path even if leaves have rotation.\n      const originPose = !isGroupPath && writeIds.length === 1\n        ? startWorlds.get(writeIds[0])\n        : (originBounds as unknown);\n      const originRotation = !isGroupPath\n        ? (geometry.getRotation?.(originPose) ?? 0)\n        : 0;\n\n      const fixedLocal = fixedCornerOf(originBounds, anchor);\n      const fixedWorld = originRotation === 0\n        ? fixedLocal\n        : rotatePoint(\n            fixedLocal.x, fixedLocal.y,\n            originBounds.x + originBounds.width / 2,\n            originBounds.y + originBounds.height / 2,\n            originRotation,\n          );\n\n      const startWorld = { x: ctx.drag?.start.x ?? 0, y: ctx.drag?.start.y ?? 0 };\n\n      // Minimal GestureContext for behaviors. `draggedIds` matches the\n      // legacy hook: the starting id (not the expanded leaf set).\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: new Map<string, unknown>([[ids[0] as string, originPose]]),\n        current: new Map<string, unknown>([[ids[0] as string, originPose]]),\n        snap: null,\n        modifiers: { ...ctx.modifiers },\n        pointer: { worldX: startWorld.x, worldY: startWorld.y, clientX: 0, clientY: 0 },\n        view: readView(),\n        plane: readPlane(),\n        // `adapter` is unused by the kit's behaviors; cast to satisfy the type.\n        adapter: undefined as unknown as GestureContext<unknown>['adapter'],\n        scratch: {},\n      };\n\n      // Fire behavior onStart hooks (parity with `useResize`).\n      const ctxAsRect = gestureCtx as unknown as GestureContext<Bounds>;\n      for (const b of behaviors) b.onStart?.(ctxAsRect);\n\n      const scratch: ResizeScratch = {\n        writeIds,\n        scene,\n        frame,\n        startPoses,\n        startWorlds,\n        originBounds,\n        anchor,\n        startWorld,\n        originRotation,\n        fixedWorld,\n        previews: new Map<NodeId, unknown>(),\n        overrideEntries: new Map<NodeId, { pose: unknown }>(),\n        geometry,\n        behaviors,\n        pointSnap,\n        gestureCtx,\n        applyOps,\n        geometryProjection,\n        lifecycle: readGestureLifecycle(policy, 'Resize', behaviors),\n      };\n      const { lifecycle } = scratch;\n      lifecycle.start(writeIds as string[]);\n\n      // Returns whether anything reached the document.\n      const commitResize = (): boolean => {\n        const target = {\n          scene,\n          applyOps: scratch.applyOps,\n          adapter: defaultCommitAdapter(scene, selection.adapterMethods),\n        };\n        const r = reduceBehaviorEnd(scratch.behaviors, scratch.gestureCtx as unknown as GestureContext<Bounds>);\n        if (r === null) return false;\n        if (r !== undefined) {\n          commitGestureOps(target, lifecycle, r);\n          return true;\n        }\n\n        if (scratch.previews.size === 0) return false;\n\n        // One transform op per write id (from = pre-drag start pose, to =\n        // final preview pose), committed as a single batch → one undo entry.\n        const ops: Op[] = [];\n        for (const id of scratch.writeIds) {\n          const next = scratch.previews.get(id);\n          if (next === undefined) continue;\n          const from = scratch.startPoses.get(id);\n          if (from === undefined) continue;\n          let committed = next;\n          // Eager-sync: map data-held geometry by the box→box affine the\n          // pose underwent (start-pose bounds → final-pose bounds). Opt-in\n          // via the geometryProjection seam; a no-op when the dep is absent.\n          if (scratch.geometryProjection) {\n            const node = scratch.scene.get(id);\n            if (node) {\n              const sb = scratch.geometry.getBounds(from);\n              const db = scratch.geometry.getBounds(next);\n              const m: Mat3 = boxToBox(\n                sb.x, sb.y, sb.width, sb.height,\n                db.x, db.y, db.width, db.height,\n              );\n              const dataOp = geometryDataOp(\n                scratch.geometryProjection,\n                { id: id as string, data: node.data, pose: from },\n                m,\n                lifecycle.label,\n              );\n              if (dataOp) {\n                ops.push(dataOp);\n                // The data absorbed the affine — including any mirror from a\n                // drag past the opposite edge — so the pose must commit as a\n                // normalized AABB. Leaving signed extents on the pose makes\n                // the node unhittable (hit-testing assumes normalized boxes).\n                // Without the seam the signed pose is kept: a bare-AABB pose\n                // is the only carrier of the flip there.\n                if (db.width < 0 || db.height < 0) {\n                  const nb = {\n                    ...db,\n                    x: db.width < 0 ? db.x + db.width : db.x,\n                    y: db.height < 0 ? db.y + db.height : db.y,\n                    width: Math.abs(db.width),\n                    height: Math.abs(db.height),\n                  };\n                  committed = scratch.geometry.remapBounds(next, db, nb) as typeof next;\n                }\n              }\n            }\n          }\n          ops.push(createTransformOp<unknown>({\n            id: id as string,\n            from,\n            to: committed,\n            label: lifecycle.label,\n          }));\n        }\n        if (ops.length === 0) return false;\n        commitGestureOps(target, lifecycle, ops);\n        return true;\n      };\n\n      return {\n        kind: 'resize',\n        onMove(mctx: InvocationCtx): void {\n          if (!mctx.drag) return;\n          const dx = mctx.drag.current.x - scratch.startWorld.x;\n          const dy = mctx.drag.current.y - scratch.startWorld.y;\n\n          // Refresh modifiers + pointer on the gesture ctx for behaviors.\n          scratch.gestureCtx.modifiers = { ...mctx.modifiers };\n          scratch.gestureCtx.pointer = {\n            worldX: mctx.drag.current.x,\n            worldY: mctx.drag.current.y,\n            clientX: 0,\n            clientY: 0,\n          };\n          scratch.gestureCtx.view = readView();\n          scratch.gestureCtx.plane = readPlane();\n\n          let proposedBounds = computeProposedBounds(\n            scratch.originBounds,\n            scratch.anchor,\n            dx,\n            dy,\n            scratch.originRotation,\n          );\n\n          // Behaviors run in bounds-space.\n          const behaviorCtx = scratch.gestureCtx as unknown as GestureContext<Bounds>;\n          for (const b of scratch.behaviors) {\n            const r = b.onMove?.(behaviorCtx, {\n              pose: proposedBounds,\n              anchor: scratch.anchor,\n            });\n            if (!r) continue;\n            if (r.pose !== undefined) {\n              proposedBounds = {\n                x: r.pose.x, y: r.pose.y, width: r.pose.width, height: r.pose.height,\n              };\n            }\n          }\n\n          // Project bounds → pose. For the group path, each leaf is remapped\n          // from its own startPose; for single, from the start pose directly.\n          //\n          // A rotated leaf in a group needs its own frame: `src`/`dst` are\n          // world-frame here, unlike the single path where the drag delta was\n          // already projected into the leaf's frame, so the naive affine\n          // scales the wrong pair of extents. See `remapRotatedLeaf`.\n          const computePose = (id: NodeId): unknown => {\n            const sp = scratch.startWorlds.get(id);\n            if (sp === undefined) return undefined;\n            if (isGroupPath && poseRotationOf(sp) !== null) {\n              return remapRotatedLeaf(\n                sp as RotatedPose, scratch.originBounds, proposedBounds,\n              );\n            }\n            return scratch.geometry.remapBounds(sp, scratch.originBounds, proposedBounds);\n          };\n\n          // Single-id path: apply rotation correction + point-snap, then\n          // store. Group path: rotation correction + point-snap don't apply\n          // (group resize is AABB-frame).\n          scratch.previews.clear();\n\n          if (!isGroupPath && scratch.writeIds.length === 1) {\n            const id = scratch.writeIds[0];\n            let proposedPose = computePose(id);\n            if (proposedPose === undefined) { syncPreviewOverrides(scratch); return; }\n\n            if (scratch.originRotation !== 0) {\n              const newCenterX = proposedBounds.x + proposedBounds.width / 2;\n              const newCenterY = proposedBounds.y + proposedBounds.height / 2;\n              const newFixedLocal = fixedCornerOf(proposedBounds, scratch.anchor);\n              const newFixedWorld = rotatePoint(\n                newFixedLocal.x, newFixedLocal.y,\n                newCenterX, newCenterY,\n                scratch.originRotation,\n              );\n              const correctionX = scratch.fixedWorld.x - newFixedWorld.x;\n              const correctionY = scratch.fixedWorld.y - newFixedWorld.y;\n              proposedPose = translatePoseViaDescriptor(proposedPose, correctionX, correctionY, scratch.geometry);\n            }\n\n            if (scratch.pointSnap.length > 0) {\n              const rotation = scratch.originRotation;\n              const poseAsRect = proposedPose as Bounds;\n              const psCtx = buildPointSnapContext(\n                poseAsRect,\n                rotation,\n                scratch.anchor,\n                scratch.gestureCtx.modifiers,\n              );\n              // Point snaps are the surface's rules over the camera's world, so\n              // on a plane their points cross at this boundary.\n              const plane = scratch.gestureCtx.plane ?? null;\n              for (const beh of scratch.pointSnap) {\n                const result = plane\n                  ? pointSnapFromPlane(beh.onMove(pointSnapToCamera(psCtx, plane)), plane)\n                  : beh.onMove(psCtx);\n                if (result) {\n                  proposedPose = applyPointSnap(poseAsRect, rotation, result, psCtx) as unknown;\n                  break;\n                }\n              }\n            }\n\n            scratch.previews.set(id, stored(id, proposedPose));\n            scratch.gestureCtx.current = new Map<string, unknown>([[id as string, proposedPose]]);\n          } else {\n            // Group / multi path: remap each leaf and store.\n            for (const id of scratch.writeIds) {\n              const next = computePose(id);\n              if (next === undefined) continue;\n              scratch.previews.set(id, stored(id, next));\n            }\n          }\n\n          syncPreviewOverrides(scratch);\n        },\n\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            if (reason === 'commit') committed = commitResize();\n            else runBehaviorCancel(scratch.behaviors, scratch.gestureCtx as unknown as GestureContext<Bounds>);\n          } finally {\n            dropPreviewOverrides(scratch);\n            scratch.previews.clear();\n            lifecycle.end(committed);\n          }\n        },\n        previewIds: () => scratch.previews.keys(),\n        previewPose: (id: string) => scratch.previews.get(id as NodeId) ?? null,\n      };\n    },\n  },\n  /**\n   * Always enabled at the descriptor level. The dispatcher's\n   * specificity-fallthrough loop treats anything `!== true` as \"skip and\n   * try the next match\" — returning `ActionDisabledReason.SelectionRequired`\n   * here makes the resize binding silently lose to lower-specificity\n   * matches (e.g. ambient `insertAction`), inserting phantom nodes on\n   * every drag instead of resizing. The invoker self-guards on empty\n   * selection (returns `{}`), so a static `true` here is correct.\n   *\n   * Fix: previously `() => ActionDisabledReason.SelectionRequired`\n   * — that broke every dispatcher-routed resize. See git blame.\n   */\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAgFA,IAAMA,KAAmB,MAAkBC,GACrCC,IAAgD,CAAC;AAEvD,SAASC,EAAY,GAMnB;CACA,IAAMC,IAAWC,EAAiBC,EAAI,KAAK,cAAc,GACnDC,IAAMD,EAAI,KAAK;CAYrB,OAXKC,IAWE;EACL,WAAWA,EAAI;EACf,WAAWA,EAAI;EACf,WAAWA,EAAI;EACf;EACA,QAAQA;CACV,IAhBS;EAGL,WAAWC;EACX,WAAWN;EACX,WAAWF;EACX;EACA,QAAQ,KAAA;CACV;AASJ;AAMA,SAASS,EACP,GACA,GACA,GACA,GACyB;CACzB,IAAMC,IAAKC,EAAK,IAAIA,EAAK,QAAQ,GAC3BC,IAAKD,EAAK,IAAIA,EAAK,SAAS,GAE5BE,IAAKC,EAAYH,EAAK,GAAGA,EAAK,GAAGD,GAAIE,GAAIG,CAAQ,GACjDC,IAAKF,EAAYH,EAAK,IAAIA,EAAK,OAAOA,EAAK,GAAGD,GAAIE,GAAIG,CAAQ,GAC9DE,IAAKH,EAAYH,EAAK,IAAIA,EAAK,OAAOA,EAAK,IAAIA,EAAK,QAAQD,GAAIE,GAAIG,CAAQ,GAC5EG,IAAKJ,EAAYH,EAAK,GAAGA,EAAK,IAAIA,EAAK,QAAQD,GAAIE,GAAIG,CAAQ,GAEjEI,IAA2D,MAC3DC,IAAyD;CAE7D,IAAIC,EAAO,MAAM,UAAUA,EAAO,MAAM,QAAQ;EAC9C,IAAMC,IACJD,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQR,IAC3CQ,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQL,IAC3CK,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQJ,IAAKC,GAC5CK,IACJF,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQJ,IAC3CI,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQH,IAC3CG,EAAO,MAAM,SAASA,EAAO,MAAM,QAAQR,IAAKG;EAElD,AADA,IAAc;GAAE,QAAQM,EAAQ;GAAG,QAAQA,EAAQ;EAAE,GACrD,IAAgB;GAAE,QAAQC,EAAU;GAAG,QAAQA,EAAU;EAAE;CAC7D;CAEA,OAAO;EACL;EACA;EACA,QAAQ;GAAE,QAAQb;GAAI,QAAQE;EAAG;EACjC,QAAQ;GAAE,QAAQC,EAAG;GAAG,QAAQA,EAAG;EAAE;EACrC;EACA;EACA,UAAUF;EACV;CACF;AACF;AAEA,SAASa,GACP,GACA,GACA,GACA,GACO;CACP,IAAIC,EAAO,UAAU,UAAU;EAC7B,IAAMC,IAAKD,EAAO,SAASnB,EAAI,OAAO,QAChCqB,IAAKF,EAAO,SAASnB,EAAI,OAAO;EACtC,OAAO;GAAE,GAAGK;GAAM,GAAGA,EAAK,IAAIe;GAAI,GAAGf,EAAK,IAAIgB;EAAG;CACnD;CACA,IAAIF,EAAO,UAAU,UAAU;EAC7B,IAAMC,IAAKD,EAAO,SAASnB,EAAI,OAAO,QAChCqB,IAAKF,EAAO,SAASnB,EAAI,OAAO;EACtC,OAAO;GAAE,GAAGK;GAAM,GAAGA,EAAK,IAAIe;GAAI,GAAGf,EAAK,IAAIgB;EAAG;CACnD;CACA,IAAMC,IAAMH,EAAO,UAAU,mBAAmBnB,EAAI,cAAcA,EAAI;CACtE,IAAI,CAACsB,GAAK,OAAOjB;CACjB,IAAMkB,IAAKJ,EAAO,SAASG,EAAI,QACzBE,IAAKL,EAAO,SAASG,EAAI,QACzBG,IAAM,KAAK,IAAIhB,CAAQ,GACvBiB,IAAM,KAAK,IAAIjB,CAAQ,GACvBkB,IAASJ,IAAKE,IAAMD,IAAKE,GACzBE,IAAS,CAACL,IAAKG,IAAMF,IAAKC,GAC1BI,IAAW,KAAK,IAAIF,CAAM,GAC1BG,IAAY,KAAK,IAAIF,CAAM,GAC3BG,KAAST,EAAI,SAASH,EAAO,UAAU,GACvCa,KAASV,EAAI,SAASH,EAAO,UAAU;CAC7C,OAAO;EAAE,GAAGd;EAAM,GAAG0B,IAAQF,IAAW;EAAG,GAAGG,IAAQF,IAAY;EAAG,OAAOD;EAAU,QAAQC;CAAU;AAC1G;AAGA,SAASG,GACP,GACA,GACyB;CACzB,IAAMC,KAAO,MAA0C;EACrD,IAAMC,IAAIC,EAAUC,GAAG;GAAE,GAAGC,EAAE;GAAQ,GAAGA,EAAE;EAAO,CAAC;EACnD,OAAO;GAAE,QAAQH,EAAE;GAAG,QAAQA,EAAE;EAAE;CACpC;CACA,OAAO;EACL,GAAGnC;EACH,eAAeA,EAAI,iBAAiBkC,EAAIlC,EAAI,aAAa;EACzD,aAAaA,EAAI,eAAekC,EAAIlC,EAAI,WAAW;EACnD,QAAQkC,EAAIlC,EAAI,MAAM;EACtB,QAAQkC,EAAIlC,EAAI,MAAM;CACxB;AACF;AAGA,SAASuC,GACP,GACA,GACoC;CACpC,IAAI,CAACC,GAAG,OAAOA;CACf,IAAMF,IAAIG,EAAQJ,GAAG;EAAE,GAAGG,EAAE;EAAQ,GAAGA,EAAE;CAAO,CAAC;CACjD,OAAO;EAAE,GAAGA;EAAG,QAAQF,EAAE;EAAG,QAAQA,EAAE;CAAE;AAC1C;AAMA,SAASI,GACP,GACA,GACA,GACA,GACA,GACQ;CACR,IAAIjC,MAAa,GAAG;EAClB,IAAMkC,IAAK,KAAK,IAAI,CAAClC,CAAQ,GACvBmC,IAAK,KAAK,IAAI,CAACnC,CAAQ,GACvBoC,IAAUF,IAAKvB,IAAKwB,IAAKvB,GACzByB,IAAUF,IAAKxB,IAAKuB,IAAKtB;EAE/B,AADA,IAAKwB,GACL,IAAKC;CACP;CACA,IAAIC,IAAKC,EAAG,GACRC,IAAKD,EAAG,GACRE,IAAKF,EAAG,OACRG,IAAKH,EAAG;CAaZ,OAZIjC,EAAO,MAAM,QACf,IAAKiC,EAAG,QAAQ5B,IACPL,EAAO,MAAM,UACtB,IAAKiC,EAAG,IAAI5B,GACZ,IAAK4B,EAAG,QAAQ5B,IAEdL,EAAO,MAAM,QACf,IAAKiC,EAAG,SAAS3B,IACRN,EAAO,MAAM,UACtB,IAAKiC,EAAG,IAAI3B,GACZ,IAAK2B,EAAG,SAAS3B,IAEZ;EAAE,GAAG0B;EAAI,GAAGE;EAAI,OAAOC;EAAI,QAAQC;CAAG;AAC/C;AA2DA,IAAaC,IAAgDC,EAAQ;CACnE,IAAI;CACJ,OAAO;CAIP,UAAU,EAAE,YAAY,uBAAuB;CAC/C,UAAU;EAAC;EAAa;EAAS;EAAgB;EAAkB;EAAY;EAAsB;EAAmB;CAAM;CAC9H,SAAS;EACP,QAAQ;EACR,MAAM,GAAoB,GAAsB;GAC9C,IAAMC,IAAYtD,EAAI,KAAK,WACrBuD,IAAQvD,EAAI,KAAK,OACjBwD,IAAWxD,EAAI,KAAK,UACpByD,IAAqBzD,EAAI,KAAK;GAEpC,IAAI,CAACsD,KAAa,CAACC,GAAO,OAAO,CAAC;GAElC,IAAM5D,IAAM2D,EAAU,IAAI;GAC1B,IAAI3D,EAAI,WAAW,GAAG,OAAO,CAAC;GAG9B,IAAMoB,IADaf,EAAI,MAAM,YACF;GAC3B,IAAI,CAACe,GAAQ,OAAO,CAAC;GAErB,IAAM,EAAE,cAAW,cAAW,cAAW,aAAU,cAAWlB,EAAYG,CAAG,GAOvE0D,IAAWC,EAAUhE,CAA0B;GACrD,IAAI+D,EAAS,WAAW,GAAG,OAAO,CAAC;GAEnC,IAAME,IACJjE,EAAI,WAAW,MAAM+D,EAAS,WAAW,KAAKA,EAAS,OAAQ/D,EAAI,KAC/DkE,IAAYD,IAAcF,IAAY/D,GAMtCmE,IAAQC,GAAeR,GAAOvD,EAAI,KAAK,eAAe,GACtDgE,IAAOhE,EAAI,KAAK,MAEhBiE,KAAU,GAAY,MAA4B;IACtD,IAAMC,IAAQX,EAAM,IAAIY,CAAE,CAAC,EAAE;IAC7B,OAAOL,EAAM,MAAMK,GAAIC,EAAUtE,GAAUuE,GAAOH,MAAU,KAAA,IAAY,OAAOI,EAAQN,GAAME,CAAK,CAAC,CAAC;GACtG,GACMK,oBAAa,IAAI,IAAqB,GACtCC,oBAAc,IAAI,IAAqB,GACvCC,IAAuB,CAAC;GAC9B,KAAK,IAAMN,KAAMN,GAAU;IACzB,IAAMa,IAAOnB,EAAM,IAAIY,CAAE;IACzB,IAAI,CAACO,GAAM;IACX,EAAW,IAAIP,GAAIO,EAAK,IAAI;IAC5B,IAAML,IAAQD,EAAUtE,GAAUgE,EAAM,MAAMK,CAAE,GAAGQ,EAAYL,EAAQN,GAAMU,EAAK,KAAK,CAAC,CAAC;IAEzF,AADAF,EAAY,IAAIL,GAAIE,CAAK,GACzBI,EAAW,KAAK3E,EAAS,UAAUuE,CAAK,CAAC;GAC3C;GACA,IAAIE,EAAW,SAAS,GAAG,OAAO,CAAC;GAInC,IAAMK,IAAeH,EAAW,WAAW,IACvCA,EAAW,KACXI,EAAYJ,CAAU,GAIpBK,IAAa,CAAClB,KAAeC,EAAS,WAAW,IACnDW,EAAY,IAAIX,EAAS,EAAE,IAC1Be,GACCG,IAAkBnB,IAEpB,IADC9D,EAAS,cAAcgF,CAAU,KAAK,GAGrCE,IAAaC,EAAcL,GAAc7D,CAAM,GAC/CmE,KAAaH,MAAmB,IAClCC,IACAxE,EACEwE,EAAW,GAAGA,EAAW,GACzBJ,EAAa,IAAIA,EAAa,QAAQ,GACtCA,EAAa,IAAIA,EAAa,SAAS,GACvCG,CACF,GAEEI,IAAa;IAAE,GAAGnF,EAAI,MAAM,MAAM,KAAK;IAAG,GAAGA,EAAI,MAAM,MAAM,KAAK;GAAE,GAIpEoF,IAAWC,EAAkBrF,EAAI,IAAI,GACrCsF,IAAYC,EAAmBvF,EAAI,IAAI,GACvCwF,IAAsC;IAC1C,YAAY7F;IACZ,wBAAQ,IAAI,IAAqB,CAAC,CAACA,EAAI,IAAcmF,CAAU,CAAC,CAAC;IACjE,yBAAS,IAAI,IAAqB,CAAC,CAACnF,EAAI,IAAcmF,CAAU,CAAC,CAAC;IAClE,MAAM;IACN,WAAW,EAAE,GAAG9E,EAAI,UAAU;IAC9B,SAAS;KAAE,QAAQmF,EAAW;KAAG,QAAQA,EAAW;KAAG,SAAS;KAAG,SAAS;IAAE;IAC9E,MAAMC,EAAS;IACf,OAAOE,EAAU;IAEjB,SAAS,KAAA;IACT,SAAS,CAAC;GACZ,GAGMG,KAAYD;GAClB,KAAK,IAAME,KAAKC,GAAW,EAAE,UAAUF,EAAS;GAEhD,IAAMG,IAAyB;IAC7B;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA,0BAAU,IAAI,IAAqB;IACnC,iCAAiB,IAAI,IAA+B;IACpD;IACA;IACA;IACA;IACA;IACA;IACA,WAAWC,EAAqBC,GAAQ,UAAUH,CAAS;GAC7D,GACM,EAAE,iBAAcC;GACtB,EAAU,MAAM/B,CAAoB;GAGpC,IAAMkC,WAA8B;IAClC,IAAMC,IAAS;KACb;KACA,UAAUJ,EAAQ;KAClB,SAASK,GAAqB1C,GAAOD,EAAU,cAAc;IAC/D,GACMd,IAAI0D,EAAkBN,EAAQ,WAAWA,EAAQ,UAA+C;IACtG,IAAIpD,MAAM,MAAM,OAAO;IACvB,IAAIA,MAAM,KAAA,GAER,OADA2D,EAAiBH,GAAQI,GAAW5D,CAAC,GAC9B;IAGT,IAAIoD,EAAQ,SAAS,SAAS,GAAG,OAAO;IAIxC,IAAMS,IAAY,CAAC;IACnB,KAAK,IAAMlC,KAAMyB,EAAQ,UAAU;KACjC,IAAMU,IAAOV,EAAQ,SAAS,IAAIzB,CAAE;KACpC,IAAImC,MAAS,KAAA,GAAW;KACxB,IAAMC,IAAOX,EAAQ,WAAW,IAAIzB,CAAE;KACtC,IAAIoC,MAAS,KAAA,GAAW;KACxB,IAAIC,IAAYF;KAIhB,IAAIV,EAAQ,oBAAoB;MAC9B,IAAMlB,IAAOkB,EAAQ,MAAM,IAAIzB,CAAE;MACjC,IAAIO,GAAM;OACR,IAAM+B,IAAKb,EAAQ,SAAS,UAAUW,CAAI,GACpCG,IAAKd,EAAQ,SAAS,UAAUU,CAAI,GACpCjE,IAAUsE,EACdF,EAAG,GAAGA,EAAG,GAAGA,EAAG,OAAOA,EAAG,QACzBC,EAAG,GAAGA,EAAG,GAAGA,EAAG,OAAOA,EAAG,MAC3B,GACME,IAASC,EACbjB,EAAQ,oBACR;QAAM;QAAc,MAAMlB,EAAK;QAAM,MAAM6B;OAAK,GAChDlE,GACA+D,EAAU,KACZ;OACA,IAAIQ,MACFP,EAAI,KAAKO,CAAM,GAOXF,EAAG,QAAQ,KAAKA,EAAG,SAAS,IAAG;QACjC,IAAMI,IAAK;SACT,GAAGJ;SACH,GAAGA,EAAG,QAAQ,IAAIA,EAAG,IAAIA,EAAG,QAAQA,EAAG;SACvC,GAAGA,EAAG,SAAS,IAAIA,EAAG,IAAIA,EAAG,SAASA,EAAG;SACzC,OAAO,KAAK,IAAIA,EAAG,KAAK;SACxB,QAAQ,KAAK,IAAIA,EAAG,MAAM;QAC5B;QACA,IAAYd,EAAQ,SAAS,YAAYU,GAAMI,GAAII,CAAE;OACvD;MAEJ;KACF;KACA,EAAI,KAAKC,EAA2B;MAC9B;MACJ;MACA,IAAIP;MACJ,OAAOJ,EAAU;KACnB,CAAC,CAAC;IACJ;IAGA,OAFIC,EAAI,WAAW,MACnBF,EAAiBH,GAAQI,GAAWC,CAAG,GAChC;GACT;GAEA,OAAO;IACL,MAAM;IACN,OAAO,GAA2B;KAChC,IAAI,CAACW,EAAK,MAAM;KAChB,IAAM5F,IAAK4F,EAAK,KAAK,QAAQ,IAAIpB,EAAQ,WAAW,GAC9CvE,IAAK2F,EAAK,KAAK,QAAQ,IAAIpB,EAAQ,WAAW;KAWpD,AARA,EAAQ,WAAW,YAAY,EAAE,GAAGoB,EAAK,UAAU,GACnD,EAAQ,WAAW,UAAU;MAC3B,QAAQA,EAAK,KAAK,QAAQ;MAC1B,QAAQA,EAAK,KAAK,QAAQ;MAC1B,SAAS;MACT,SAAS;KACX,GACA,EAAQ,WAAW,OAAO5B,EAAS,GACnC,EAAQ,WAAW,QAAQE,EAAU;KAErC,IAAI2B,IAAiBvE,GACnBkD,EAAQ,cACRA,EAAQ,QACRxE,GACAC,GACAuE,EAAQ,cACV,GAGMsB,IAActB,EAAQ;KAC5B,KAAK,IAAMF,KAAKE,EAAQ,WAAW;MACjC,IAAMpD,IAAIkD,EAAE,SAASwB,GAAa;OAChC,MAAMD;OACN,QAAQrB,EAAQ;MAClB,CAAC;MACD,AAAKpD,KACDA,EAAE,SAAS,KAAA,MACb,IAAiB;OACf,GAAGA,EAAE,KAAK;OAAG,GAAGA,EAAE,KAAK;OAAG,OAAOA,EAAE,KAAK;OAAO,QAAQA,EAAE,KAAK;MAChE;KAEJ;KASA,IAAM2E,KAAe,MAAwB;MAC3C,IAAMC,IAAKxB,EAAQ,YAAY,IAAIzB,CAAE;MACrC,IAAIiD,MAAO,KAAA,GAMX,OALIxD,KAAeyD,EAAeD,CAAE,MAAM,OACjCE,EACLF,GAAmBxB,EAAQ,cAAcqB,CAC3C,IAEKrB,EAAQ,SAAS,YAAYwB,GAAIxB,EAAQ,cAAcqB,CAAc;KAC9E;KAOA,IAFArB,EAAQ,SAAS,MAAM,GAEnB,CAAChC,KAAegC,EAAQ,SAAS,WAAW,GAAG;MACjD,IAAMzB,IAAKyB,EAAQ,SAAS,IACxB2B,IAAeJ,EAAYhD,CAAE;MACjC,IAAIoD,MAAiB,KAAA,GAAW;OAAE,EAAqB3B,CAAO;OAAG;MAAQ;MAEzE,IAAIA,EAAQ,mBAAmB,GAAG;OAChC,IAAM4B,IAAaP,EAAe,IAAIA,EAAe,QAAQ,GACvDQ,IAAaR,EAAe,IAAIA,EAAe,SAAS,GACxDS,IAAgBzC,EAAcgC,GAAgBrB,EAAQ,MAAM,GAC5D+B,IAAgBnH,EACpBkH,EAAc,GAAGA,EAAc,GAC/BF,GAAYC,GACZ7B,EAAQ,cACV,GACMgC,IAAchC,EAAQ,WAAW,IAAI+B,EAAc,GACnDE,IAAcjC,EAAQ,WAAW,IAAI+B,EAAc;OACzD,IAAeG,EAA2BP,GAAcK,GAAaC,GAAajC,EAAQ,QAAQ;MACpG;MAEA,IAAIA,EAAQ,UAAU,SAAS,GAAG;OAChC,IAAMnF,IAAWmF,EAAQ,gBACnBmC,IAAaR,GACbS,IAAQ7H,EACZ4H,GACAtH,GACAmF,EAAQ,QACRA,EAAQ,WAAW,SACrB,GAGMqC,IAAQrC,EAAQ,WAAW,SAAS;OAC1C,KAAK,IAAMsC,KAAOtC,EAAQ,WAAW;QACnC,IAAMzE,IAAS8G,IACX1F,GAAmB2F,EAAI,OAAOjG,GAAkB+F,GAAOC,CAAK,CAAC,GAAGA,CAAK,IACrEC,EAAI,OAAOF,CAAK;QACpB,IAAI7G,GAAQ;SACV,IAAeD,GAAe6G,GAAYtH,GAAUU,GAAQ6G,CAAK;SACjE;QACF;OACF;MACF;MAGA,AADApC,EAAQ,SAAS,IAAIzB,GAAIF,EAAOE,GAAIoD,CAAY,CAAC,GACjD,EAAQ,WAAW,0BAAU,IAAI,IAAqB,CAAC,CAACpD,GAAcoD,CAAY,CAAC,CAAC;KACtF,OAEE,KAAK,IAAMpD,KAAMyB,EAAQ,UAAU;MACjC,IAAMU,IAAOa,EAAYhD,CAAE;MAC3B,AAAImC,MAAS,KAAA,KACbV,EAAQ,SAAS,IAAIzB,GAAIF,EAAOE,GAAImC,CAAI,CAAC;KAC3C;KAGF,EAAqBV,CAAO;IAC9B;IAEA,MAAM,GAAwB,GAAmC;KAC/D,IAAIY,IAAY;KAChB,IAAI;MACF,AAAI2B,MAAW,WAAU,IAAYpC,GAAa,IAC7CqC,EAAkBxC,EAAQ,WAAWA,EAAQ,UAA+C;KACnG,UAAU;MAGR,AAFAyC,EAAqBzC,CAAO,GAC5BA,EAAQ,SAAS,MAAM,GACvBQ,EAAU,IAAII,CAAS;KACzB;IACF;IACA,kBAAkBZ,EAAQ,SAAS,KAAK;IACxC,cAAc,MAAeA,EAAQ,SAAS,IAAIzB,CAAY,KAAK;GACrE;EACF;CACF;CAaA,eAAe;AACjB,GAAGmE,CAAc"}

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

@@ -1,184 +0,0 @@
-import { dropPreviewOverrides as e, syncPreviewOverrides as t } from "../previewOverrides.js";
-import { gesturePlaneReader as n, gestureViewReader as r } from "../../gestures/shared/screenTolerance.js";
-import { commitGestureOps as i, readGestureLifecycle as a, reduceBehaviorEnd as o, runBehaviorCancel as s } from "../gestureLifecycle.js";
-import { createTransformOp as c } from "../../../core/ops/transform.js";
-import { unionAABB as l } from "../../../core/geometry/unionBounds.js";
-import { poseDescriptorForNode as u, translatePoseViaDescriptor as d, visualBoundsViaDescriptor as f } from "../../../core/geometry/poseDescriptor.js";
-import { poseDescriptorOf as p } from "../poseDescriptorDep.js";
-import { moveGestureAdapter as m } from "../move/gestureAdapter.js";
-import { carryPose as h, inPlane as g, invertPlane as _, planeOf as v, selectionLayer as y } from "../planeInput.js";
-import { defaultCommitAdapter as b } from "../defaultCommitAdapter.js";
-import { scenePoseFrame as x } from "../poseFrame.js";
-import { resolveParams as S } from "@weasel-js/routing";
-//#region src/interactions/actions/defaults/rotate.ts
-function C(e, t, n, r, i, a, o) {
-	let s = e.withRotation(t, n + r);
-	if (!o) return s;
-	let c = Math.cos(r), l = Math.sin(r), u = i.x - a.x, f = i.y - a.y, p = a.x + u * c - f * l, m = a.y + u * l + f * c;
-	return d(s, p - i.x, m - i.y, e);
-}
-var w = g({
-	id: "rotate",
-	label: "Rotate",
-	eligible: { capability: "transforms-selection" },
-	requires: [
-		"selection",
-		"scene",
-		"applyOps",
-		"poseDescriptor",
-		"poseComposition",
-		"view"
-	],
-	invoker: {
-		timing: "ongoing",
-		start(d, g) {
-			let y = d.deps.selection, w = d.deps.scene, T = d.deps.applyOps, E = S(g?.params), D = g?.behaviors ?? [];
-			if (!y || !w) return {};
-			let O = y.get();
-			if (O.length === 0) return {};
-			let k = p(d.deps.poseDescriptor), A = x(w, d.deps.poseComposition), j = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map(), N = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Map(), F = [];
-			for (let e of O) {
-				let t = w.get(e);
-				if (!t) continue;
-				let n = u(k, t);
-				if (!n.withRotation || n.supportsRotation?.(t.pose) === !1) continue;
-				j.set(e, t.pose);
-				let r = h(n, A.world(e), _(v(d.deps.view, t.layer)));
-				M.set(e, r);
-				let i = n.getBounds(r);
-				N.set(e, {
-					x: i.x + i.width / 2,
-					y: i.y + i.height / 2
-				}), P.set(e, n.getRotation?.(r) ?? 0), F.push(f(r, n));
-			}
-			if (j.size === 0) return {};
-			let I = l(F), L = {
-				x: I.x + I.width / 2,
-				y: I.y + I.height / 2
-			}, R = Math.atan2(d.world.y - L.y, d.world.x - L.x), z = r(d.deps), B = d.deps.view, V = n(d.deps), H = {
-				ids: O,
-				scene: w,
-				descriptor: k,
-				frame: A,
-				originPoses: j,
-				originWorlds: M,
-				originCenters: N,
-				originRotations: P,
-				unionCenter: L,
-				startPointerAngle: R,
-				currentDelta: 0,
-				useUnionPivot: O.length > 1 && E?.pivot !== "each",
-				previews: /* @__PURE__ */ new Map(),
-				overrideEntries: /* @__PURE__ */ new Map(),
-				applyOps: T,
-				lifecycle: a(E, "Rotate", D),
-				behaviors: D,
-				gestureCtx: {
-					draggedIds: [...j.keys()],
-					origin: new Map([...M].map(([e, t]) => [e, t])),
-					current: new Map([...M].map(([e, t]) => [e, t])),
-					snap: null,
-					modifiers: { ...d.modifiers },
-					pointer: {
-						worldX: d.world.x,
-						worldY: d.world.y,
-						clientX: 0,
-						clientY: 0
-					},
-					view: z(),
-					plane: V(),
-					adapter: m(w),
-					scratch: {}
-				}
-			}, { lifecycle: U } = H, W = (e) => {
-				let t = /* @__PURE__ */ new Map();
-				for (let [n, r] of H.originWorlds) t.set(n, C(H.descriptor, r, H.originRotations.get(n) ?? 0, e, H.originCenters.get(n) ?? {
-					x: 0,
-					y: 0
-				}, H.unionCenter, H.useUnionPivot));
-				return t;
-			}, G = (e) => {
-				let t = W(e);
-				for (let [e, n] of t) H.gestureCtx.current.set(e, n);
-				return t;
-			}, K = (e, t) => {
-				let n = H.gestureCtx;
-				n.modifiers = { ...e.modifiers }, n.pointer = {
-					worldX: e.world.x,
-					worldY: e.world.y,
-					clientX: 0,
-					clientY: 0
-				}, n.view = z(), n.plane = V();
-				let r = H.originWorlds.keys().next().value, i = H.originRotations.get(r) ?? 0, a = t, o = {
-					pose: G(t).get(r),
-					rotation: i + t
-				};
-				for (let e of H.behaviors) {
-					let t = e.onMove?.(n, o);
-					if (!t || t.pose === void 0) continue;
-					let r = H.descriptor.getRotation?.(t.pose) ?? 0;
-					a = r - i, o = {
-						pose: t.pose,
-						rotation: r
-					};
-				}
-				return a;
-			}, q = () => {
-				let e = {
-					scene: w,
-					applyOps: H.applyOps,
-					adapter: b(w, y.adapterMethods)
-				};
-				if (H.behaviors.length > 0) {
-					G(H.currentDelta);
-					let t = o(H.behaviors, H.gestureCtx);
-					if (t === null) return !1;
-					if (t !== void 0) return i(e, U, t), !0;
-				}
-				if (H.currentDelta === 0) return !1;
-				let t = [];
-				for (let e of H.ids) {
-					let n = H.previews.get(e);
-					if (n === void 0) continue;
-					let r = H.originPoses.get(e);
-					r !== void 0 && t.push(c({
-						id: e,
-						from: r,
-						to: n,
-						label: U.label
-					}));
-				}
-				return t.length !== 0 && (i(e, U, t), !0);
-			}, J = (e) => {
-				if (H.previews.clear(), e !== 0) for (let [t, n] of W(e)) {
-					let e = H.scene.get(t)?.layer, r = e === void 0 ? null : v(B, e);
-					H.previews.set(t, H.frame.local(t, h(H.descriptor, n, r)));
-				}
-				t(H);
-			};
-			for (let e of D) e.onStart?.(H.gestureCtx);
-			return U.start(H.gestureCtx.draggedIds), {
-				kind: "rotate",
-				onMove(e) {
-					let t = Math.atan2(e.world.y - H.unionCenter.y, e.world.x - H.unionCenter.x) - H.startPointerAngle;
-					H.currentDelta = H.behaviors.length > 0 ? K(e, t) : t, J(H.currentDelta);
-				},
-				onEnd(t, n) {
-					let r = !1;
-					try {
-						n === "commit" ? r = q() : s(H.behaviors, H.gestureCtx);
-					} finally {
-						e(H), H.previews.clear(), U.end(r);
-					}
-				},
-				previewIds: () => H.previews.keys(),
-				previewPose: (e) => H.previews.get(e) ?? null
-			};
-		}
-	},
-	enabled: () => !0
-}, y);
-//#endregion
-export { w as rotateAction };
-
-//# sourceMappingURL=rotate.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"rotate.js","names":["applyRotationDelta","rotated","d","pose","originRotation","delta","useUnionPivot","cos","sin","ox","originCenter","unionCenter","oy","nx","ny","translatePoseViaDescriptor","rotateAction","inPlane","selection","ctx","scene","applyOps","params","resolveParams","opts","behaviors","ids","descriptor","poseDescriptorOf","frame","scenePoseFrame","originPoses","originWorlds","originCenters","originRotations","visual","id","node","g","poseDescriptorForNode","world","carryPose","invertPlane","planeOf","b","visualBoundsViaDescriptor","union","unionAABB","startPointerAngle","readView","gestureViewReader","view","readPlane","gesturePlaneReader","scratch","\"pivot\"","readGestureLifecycle","p","moveGestureAdapter","turnedWorlds","out","origin","syncGestureCurrent","turned","shapeDelta","gctx","moveCtx","primary","raw","proposed","r","rotation","commitRotate","target","defaultCommitAdapter","reduceBehaviorEnd","commitGestureOps","lifecycle","ops","next","from","createTransformOp","recomputePreviews","layer","own","committed","reason","runBehaviorCancel","dropPreviewOverrides","selectionLayer"],"sources":["../../../../src/interactions/actions/defaults/rotate.ts"],"sourcesContent":["/**\n * `rotateAction` — ongoing Action descriptor for pointer-driven rotation.\n *\n * ## Status: REAL (unrotated-pivot path)\n *\n * Implements the core rotation math from `useRotate`:\n *   - `start`: captures origin poses + AABB centers; computes start pointer\n *     angle around the union center of selected nodes.\n *   - `onMove`: derives pointer angle delta from start, applies to each node's\n *     origin rotation. In union-pivot mode (multi-selection) orbits each item's\n *     center around the union center.\n *   - `onEnd('commit')`: builds one `createTransformOp` per node (from =\n *     pre-mutation origin pose, to = rotated pose) and commits them as a\n *     single batch → one undo entry for the whole drag. Routes through the\n *     optional `applyOps` dep (consumer history) when present, else\n *     `scene.applyBatch` + `defaultCommitAdapter`.\n *   - `onEnd('cancel')`: no scene writes (scene never mutated during drag).\n *\n * ## Constraints vs `useRotate`\n *\n * - Reads and writes poses through the `poseDescriptor` dep; a pose whose\n *   descriptor has no `withRotation`, or reports `supportsRotation` false, is\n *   left alone.\n * - Behaviors (`opts.behaviors`) see the first rotated node's turned pose; a\n *   pose one returns from `onMove` sets the rotation for the whole selection.\n * - No overlay rendering — deferred to Phase 7 overlay surface.\n * - Shift-snap (15° quantum) is NOT wired in this phase — omitted deliberately\n *   to keep the invoker self-contained (would need to read shift from onMove ctx).\n *   TODO: thread shift from InvocationCtx.modifiers.shift into snap logic.\n */\n\nimport { gesturePlaneReader, gestureViewReader } from '../../gestures/shared/screenTolerance';\nimport type { Action } from '@weasel-js/routing';\nimport type { InvocationCtx, OngoingHandle } from '@weasel-js/routing';\nimport { resolveParams } from '@weasel-js/routing';\nimport type { Scene, NodeId } from 'core/scene/types';\nimport { syncPreviewOverrides, dropPreviewOverrides } from '../previewOverrides';\nimport type { Op } from 'core/ops/types';\nimport { createTransformOp } from 'core/ops/transform';\nimport { defaultCommitAdapter } from '../defaultCommitAdapter';\nimport { unionAABB } from 'core/geometry/unionBounds';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { poseDescriptorOf } from '../poseDescriptorDep';\nimport {\n  poseDescriptorForNode,\n  translatePoseViaDescriptor,\n  visualBoundsViaDescriptor,\n  type PoseDescriptor,\n} from '../resize/geometry';\nimport { scenePoseFrame, type PoseFrame } from '../poseFrame';\nimport { commitGestureOps, readGestureLifecycle, reduceBehaviorEnd, runBehaviorCancel, type GestureLifecycle } from '../gestureLifecycle';\nimport { moveGestureAdapter } from '../move/gestureAdapter';\nimport type { GestureContext, RotateBehavior, RotateProposed } from '../../gestures/types';\nimport { carryPose, invertPlane, inPlane, planeOf, selectionLayer } from '../planeInput';\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\n/** Apply a rotation delta (radians) to a pose, optionally orbiting the item's\n *  center around a shared union center. */\nfunction applyRotationDelta(\n  d: PoseDescriptor<unknown>,\n  pose: unknown,\n  originRotation: number,\n  delta: number,\n  originCenter: { x: number; y: number },\n  unionCenter: { x: number; y: number },\n  useUnionPivot: boolean,\n): unknown {\n  const rotated = d.withRotation!(pose, originRotation + delta);\n  if (!useUnionPivot) return rotated;\n  const cos = Math.cos(delta);\n  const sin = Math.sin(delta);\n  const ox = originCenter.x - unionCenter.x;\n  const oy = originCenter.y - unionCenter.y;\n  const nx = unionCenter.x + ox * cos - oy * sin;\n  const ny = unionCenter.y + ox * sin + oy * cos;\n  return translatePoseViaDescriptor(rotated, nx - originCenter.x, ny - originCenter.y, d);\n}\n\n// ---------------------------------------------------------------------------\n// Internal scratch\n// ---------------------------------------------------------------------------\n\ninterface RotateScratch {\n  ids: NodeId[];\n  scene: Scene<unknown, string, unknown>;\n  descriptor: PoseDescriptor<unknown>;\n  /** World reads and local writes over the scene's composition strategy. */\n  frame: PoseFrame<unknown>;\n  /** Origin pose for each selected node as stored — the `from` of its op. */\n  originPoses: Map<NodeId, unknown>;\n  /** Origin pose for each selected node in world — what the gesture turns. */\n  originWorlds: Map<NodeId, unknown>;\n  /** AABB center for each selected node (from origin pose). */\n  originCenters: Map<NodeId, { x: number; y: number }>;\n  /** Per-node origin rotation (radians). */\n  originRotations: Map<NodeId, number>;\n  /** Union center of all selected nodes — the rotation pivot. */\n  unionCenter: { x: number; y: number };\n  /** Pointer angle around unionCenter at drag start. */\n  startPointerAngle: number;\n  /** Running delta — updated each onMove, applied once at commit. */\n  currentDelta: number;\n  /** Use union pivot (multi-select) vs each item's own center. */\n  useUnionPivot: boolean;\n  /** In-flight preview poses keyed by node id. */\n  previews: Map<NodeId, unknown>;\n  overrideEntries: Map<NodeId, { pose: 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  lifecycle: GestureLifecycle;\n  behaviors: RotateBehavior<unknown>[];\n  /** Reused gesture context handed to behaviors across the drag. */\n  gestureCtx: GestureContext<unknown>;\n}\n\n// ---------------------------------------------------------------------------\n// Descriptor\n// ---------------------------------------------------------------------------\n\n/**\n * @experimental\n * Static descriptor for the `rotate` Action.\n *\n * Requires dep-schema entries: `selection`, `scene`.\n *\n * Implements the unrotated-pivot rotation path from `useRotate`.\n *\n * @see useRotate — the React hook this descriptor mirrors for the rect case.\n */\nexport const rotateAction: Action & { requires: string[] } = inPlane({\n  id: 'rotate',\n  label: 'Rotate',\n  // No default binding. It used to be a bare `{ kind: 'drag' }`, which made\n  // any drag no active tool claimed rotate a non-empty selection. The rotation\n  // handle binds it (`selectionRotateBindings`, the `rotate` preset).\n  eligible: { capability: 'transforms-selection' },\n  requires: ['selection', 'scene', 'applyOps', 'poseDescriptor', 'poseComposition', 'view'],\n  invoker: {\n    timing: 'ongoing',\n    start(ctx: InvocationCtx, opts): OngoingHandle {\n      const selection = ctx.deps.selection;\n      const scene = ctx.deps.scene;\n      const applyOps = ctx.deps.applyOps;\n      const params = resolveParams(opts?.params);\n      const behaviors = (opts?.behaviors ?? []) as RotateBehavior<unknown>[];\n\n      if (!selection || !scene) return {};\n\n      const ids = selection.get() as NodeId[];\n      if (ids.length === 0) return {};\n\n      const descriptor = poseDescriptorOf(ctx.deps.poseDescriptor);\n      // The pivot the pointer orbits is a world point, so every pose the\n      // gesture turns is a world pose. Each turned result is stored back in\n      // the node's own parent frame at preview and commit alike.\n      const frame = scenePoseFrame(scene, ctx.deps.poseComposition);\n      const originPoses = new Map<NodeId, unknown>();\n      const originWorlds = new Map<NodeId, unknown>();\n      const originCenters = new Map<NodeId, { x: number; y: number }>();\n      const originRotations = new Map<NodeId, number>();\n      const visual: Bounds[] = [];\n\n      for (const id of ids) {\n        const node = scene.get(id);\n        if (!node) continue;\n        const g = poseDescriptorForNode(descriptor, node);\n        if (!g.withRotation || g.supportsRotation?.(node.pose) === false) continue;\n        originPoses.set(id, node.pose);\n        // The pivot is a world point, so every measurement the gesture orbits\n        // is taken from the world pose, not the stored one — carried into the\n        // plane the edit is measured in, where the pointer's angle is read.\n        const world = carryPose(g, frame.world(id), invertPlane(planeOf(ctx.deps.view, node.layer)));\n        originWorlds.set(id, world);\n        const b = g.getBounds(world);\n        originCenters.set(id, { x: b.x + b.width / 2, y: b.y + b.height / 2 });\n        originRotations.set(id, g.getRotation?.(world) ?? 0);\n        visual.push(visualBoundsViaDescriptor(world, g));\n      }\n\n      if (originPoses.size === 0) return {};\n\n      const union = unionAABB(visual)!;\n      const unionCenter = { x: union.x + union.width / 2, y: union.y + union.height / 2 };\n      const startPointerAngle = Math.atan2(\n        ctx.world.y - unionCenter.y,\n        ctx.world.x - unionCenter.x,\n      );\n\n      const readView = gestureViewReader(ctx.deps);\n      const view = ctx.deps.view;\n\n      const readPlane = gesturePlaneReader(ctx.deps);\n      const scratch: RotateScratch = {\n        ids,\n        scene,\n        descriptor,\n        frame,\n        originPoses,\n        originWorlds,\n        originCenters,\n        originRotations,\n        unionCenter,\n        startPointerAngle,\n        currentDelta: 0,\n        useUnionPivot: ids.length > 1 && params?.['pivot'] !== 'each',\n        previews: new Map<NodeId, unknown>(),\n        overrideEntries: new Map<NodeId, { pose: unknown }>(),\n        applyOps,\n        lifecycle: readGestureLifecycle(params, 'Rotate', behaviors),\n        behaviors,\n        gestureCtx: {\n          draggedIds: [...originPoses.keys()] as string[],\n          origin: new Map([...originWorlds].map(([id, p]) => [id as string, p])),\n          current: new Map([...originWorlds].map(([id, p]) => [id as string, p])),\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: moveGestureAdapter(scene) as unknown as GestureContext<unknown>['adapter'],\n          scratch: {},\n        },\n      };\n      const { lifecycle } = scratch;\n\n      /** Each rotated node's world pose turned by `delta`. */\n      const turnedWorlds = (delta: number): Map<NodeId, unknown> => {\n        const out = new Map<NodeId, unknown>();\n        for (const [id, origin] of scratch.originWorlds) {\n          out.set(id, applyRotationDelta(\n            scratch.descriptor,\n            origin,\n            scratch.originRotations.get(id) ?? 0,\n            delta,\n            scratch.originCenters.get(id) ?? { x: 0, y: 0 },\n            scratch.unionCenter,\n            scratch.useUnionPivot,\n          ));\n        }\n        return out;\n      };\n\n      const syncGestureCurrent = (delta: number): Map<NodeId, unknown> => {\n        const turned = turnedWorlds(delta);\n        for (const [id, pose] of turned) scratch.gestureCtx.current.set(id as string, pose);\n        return turned;\n      };\n\n      /** The pointer's delta as the behaviors reshape it. */\n      const shapeDelta = (moveCtx: InvocationCtx, raw: number): number => {\n        const gctx = scratch.gestureCtx;\n        gctx.modifiers = { ...moveCtx.modifiers };\n        gctx.pointer = { worldX: moveCtx.world.x, worldY: moveCtx.world.y, clientX: 0, clientY: 0 };\n        gctx.view = readView();\n        gctx.plane = readPlane();\n        const primary = scratch.originWorlds.keys().next().value as NodeId;\n        const originRotation = scratch.originRotations.get(primary) ?? 0;\n        let delta = raw;\n        let proposed: RotateProposed<unknown> = {\n          pose: syncGestureCurrent(raw).get(primary),\n          rotation: originRotation + raw,\n        };\n        for (const b of scratch.behaviors) {\n          const r = b.onMove?.(gctx, proposed);\n          if (!r || r.pose === undefined) continue;\n          const rotation = scratch.descriptor.getRotation?.(r.pose) ?? 0;\n          delta = rotation - originRotation;\n          proposed = { pose: r.pose, rotation };\n        }\n        return delta;\n      };\n\n      // Returns whether anything reached the document.\n      const commitRotate = (): boolean => {\n        const target = {\n          scene,\n          applyOps: scratch.applyOps,\n          adapter: defaultCommitAdapter(scene, selection.adapterMethods),\n        };\n        if (scratch.behaviors.length > 0) {\n          syncGestureCurrent(scratch.currentDelta);\n          const r = reduceBehaviorEnd(scratch.behaviors, scratch.gestureCtx);\n          if (r === null) return false;\n          if (r !== undefined) {\n            commitGestureOps(target, lifecycle, r);\n            return true;\n          }\n        }\n        if (scratch.currentDelta === 0) return false;\n        // One transform op per node: `from` is the origin pose captured at drag\n        // start, `to` the rotated preview. A single batch, so one undo entry.\n        const ops: Op[] = [];\n        for (const id of scratch.ids) {\n          const next = scratch.previews.get(id);\n          if (next === undefined) continue;\n          const from = scratch.originPoses.get(id);\n          if (from === undefined) continue;\n          ops.push(createTransformOp<unknown>({\n            id: id as string,\n            from,\n            to: next,\n            label: lifecycle.label,\n          }));\n        }\n        if (ops.length === 0) return false;\n        commitGestureOps(target, lifecycle, ops);\n        return true;\n      };\n\n      const recomputePreviews = (delta: number) => {\n        scratch.previews.clear();\n        if (delta !== 0) {\n          for (const [id, turned] of turnedWorlds(delta)) {\n            const layer = scratch.scene.get(id)?.layer;\n            const own = layer === undefined ? null : planeOf(view, layer);\n            scratch.previews.set(id, scratch.frame.local(id, carryPose(scratch.descriptor, turned, own)));\n          }\n        }\n        syncPreviewOverrides(scratch);\n      };\n\n      for (const b of behaviors) b.onStart?.(scratch.gestureCtx);\n      lifecycle.start(scratch.gestureCtx.draggedIds);\n\n      return {\n        kind: 'rotate',\n        onMove(moveCtx: InvocationCtx): void {\n          const pointerAngle = Math.atan2(\n            moveCtx.world.y - scratch.unionCenter.y,\n            moveCtx.world.x - scratch.unionCenter.x,\n          );\n          const raw = pointerAngle - scratch.startPointerAngle;\n          scratch.currentDelta = scratch.behaviors.length > 0 ? shapeDelta(moveCtx, raw) : raw;\n          recomputePreviews(scratch.currentDelta);\n        },\n        onEnd(_endCtx: InvocationCtx, reason: 'commit' | 'cancel'): void {\n          let committed = false;\n          try {\n            if (reason === 'commit') committed = commitRotate();\n            else runBehaviorCancel(scratch.behaviors, scratch.gestureCtx);\n          } finally {\n            dropPreviewOverrides(scratch);\n            scratch.previews.clear();\n            lifecycle.end(committed);\n          }\n        },\n        previewIds: () => scratch.previews.keys(),\n        previewPose: (id: string) => scratch.previews.get(id as NodeId) ?? null,\n      };\n    },\n  },\n  enabled: () => true,\n}, selectionLayer);\n"],"mappings":"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"}

package/dist/interactions/actions/previewOverrides.js

@@ -1,25 +0,0 @@
-//#region src/interactions/actions/previewOverrides.ts
-function e(e) {
-	let { overrides: t } = e.scene;
-	for (let [n, r] of e.previews) {
-		let i = e.overrideEntries.get(n);
-		if (i) {
-			i.pose = r;
-			continue;
-		}
-		let a = { pose: r };
-		e.overrideEntries.set(n, a), t.set(n, a);
-	}
-	for (let n of e.overrideEntries.keys()) e.previews.has(n) || (e.overrideEntries.delete(n), t.clear(n));
-	t.commit();
-}
-function t(e) {
-	if (e.overrideEntries.size !== 0) {
-		for (let t of e.overrideEntries.keys()) e.scene.overrides.clear(t);
-		e.overrideEntries.clear(), e.scene.overrides.commit();
-	}
-}
-//#endregion
-export { t as dropPreviewOverrides, e as syncPreviewOverrides };
-
-//# sourceMappingURL=previewOverrides.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"previewOverrides.js","names":["syncPreviewOverrides","state","id","pose","existing","entry","overrides","dropPreviewOverrides"],"sources":["../../../src/interactions/actions/previewOverrides.ts"],"sourcesContent":["/**\n * Publishing an in-flight gesture's poses where the *scene* can see them.\n *\n * An ongoing action keeps its per-frame poses in its own scratch and exposes\n * them as `previewIds` / `previewPose`. That surface is enough to paint a\n * ghost and to size selection chrome, but it is invisible to anything that\n * asks the scene where a node is — `sceneDepLookup`, which resolves a derived\n * node's geometry, and the pick source, which decides what the pointer can\n * grab. A node deriving its path from a dragged one therefore stayed anchored\n * to the pre-drag position and jumped on drop.\n *\n * These publish the same frame into the scene's ephemeral override table, the\n * one channel both of those already read. Nothing here reaches `executeAndLog`,\n * so a drag still commits as exactly one undo entry.\n */\nimport type { NodeId, Scene } from 'core/scene/types';\n\n/** The scratch fields these operate on. Actions carry more; this is the part\n *  that has to agree across them. */\nexport interface PreviewOverrideState {\n  scene: Scene<unknown, string, unknown>;\n  /** This frame's poses, keyed by node id — the action's own buffer. */\n  previews: Map<NodeId, unknown>;\n  /** The entry published per id, held by reference so a frame mutates it in\n   *  place. Initialize to an empty map in the action's scratch. */\n  overrideEntries: Map<NodeId, { pose: unknown }>;\n}\n\n/**\n * Publish `previews` as scene overrides. Call once per frame, after every\n * pass that can add to `previews` (a layout reflow, a cascade).\n *\n * Entries are set once and mutated in place, then published with a single\n * `commit()` — `PoseOverrides.set` notifies subscribers per call, so setting\n * every id every frame would fan out one repaint per node.\n */\nexport function syncPreviewOverrides(state: PreviewOverrideState): void {\n  const { overrides } = state.scene;\n  for (const [id, pose] of state.previews) {\n    const existing = state.overrideEntries.get(id);\n    if (existing) {\n      existing.pose = pose;\n      continue;\n    }\n    const entry = { pose };\n    state.overrideEntries.set(id, entry);\n    overrides.set(id, entry);\n  }\n  // An id can leave the preview set mid-gesture — a cascade child whose\n  // container stopped being the drag root, a layout sibling that stopped\n  // reflowing. Left published, it would pin that node to a stale frame.\n  for (const id of state.overrideEntries.keys()) {\n    if (state.previews.has(id)) continue;\n    state.overrideEntries.delete(id);\n    overrides.clear(id);\n  }\n  overrides.commit();\n}\n\n/**\n * Drop everything this gesture published. Call on both ends — on commit the\n * document poses take over, on cancel the untouched originals do.\n *\n * On commit, call it *after* the ops land: dropping first leaves a window in\n * which the scene answers with the pre-gesture pose.\n */\nexport function dropPreviewOverrides(state: PreviewOverrideState): void {\n  if (state.overrideEntries.size === 0) return;\n  for (const id of state.overrideEntries.keys()) state.scene.overrides.clear(id);\n  state.overrideEntries.clear();\n  state.scene.overrides.commit();\n}\n"],"mappings":";AAoCA,SAAgBA,EAAqB,GAAmC;CACtE,IAAM,EAAE,iBAAcC,EAAM;CAC5B,KAAK,IAAM,CAACC,GAAIC,MAASF,EAAM,UAAU;EACvC,IAAMG,IAAWH,EAAM,gBAAgB,IAAIC,CAAE;EAC7C,IAAIE,GAAU;GACZ,EAAS,OAAOD;GAChB;EACF;EACA,IAAME,IAAQ,EAAE,QAAK;EAErB,AADAJ,EAAM,gBAAgB,IAAIC,GAAIG,CAAK,GACnCC,EAAU,IAAIJ,GAAIG,CAAK;CACzB;CAIA,KAAK,IAAMH,KAAMD,EAAM,gBAAgB,KAAK,GAC1C,AAAIA,EAAM,SAAS,IAAIC,CAAE,MACzBD,EAAM,gBAAgB,OAAOC,CAAE,GAC/BI,EAAU,MAAMJ,CAAE;CAEpB,EAAU,OAAO;AACnB;AASA,SAAgBK,EAAqB,GAAmC;CACtE,IAAIN,EAAM,gBAAgB,SAAS,GACnC;OAAK,IAAMC,KAAMD,EAAM,gBAAgB,KAAK,GAAG,EAAM,MAAM,UAAU,MAAMC,CAAE;EAE7E,AADAD,EAAM,gBAAgB,MAAM,GAC5BA,EAAM,MAAM,UAAU,OAAO;CAFgD;AAG/E"}

package/dist/interactions/actions/resize/autoPoseDescriptor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"autoPoseDescriptor.js","names":["isPathLike","p","isRectPose","r","AUTO_POSE_DESCRIPTOR","pathPoseDescriptor","RECT_POSE_DESCRIPTOR","src","dst","template","b","dx","dy"],"sources":["../../../../src/interactions/actions/resize/autoPoseDescriptor.ts"],"sourcesContent":["import type { Path } from '@weasel-js/geom';\nimport { pathPoseDescriptor } from 'features/paths/poseDescriptor';\nimport { RECT_POSE_DESCRIPTOR, type PoseDescriptor } from './geometry';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\n\n/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for\n *  callers that need to fork between `pathPoseDescriptor` and\n *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire\n *  `poseDescriptor` explicitly. */\nexport function isPathLike(p: unknown): p is Path {\n  return !!p && typeof p === 'object' && 'kind' in p\n    && ((p as { kind: unknown }).kind === 'polygon' || (p as { kind: unknown }).kind === 'rect');\n}\n\n/** True for a pose with numeric top-level `x`/`y`/`width`/`height` — the only\n *  shape the rect descriptor and the kit's built-in painters can read. */\nexport function isRectPose(p: unknown): p is { x: number; y: number; width: number; height: number; rotation?: number } {\n  if (!p || typeof p !== 'object') return false;\n  const r = p as Record<string, unknown>;\n  return typeof r.x === 'number' && typeof r.y === 'number'\n    && typeof r.width === 'number' && typeof r.height === 'number';\n}\n\n/** Per-call dispatch: if the pose looks like a Path, route to\n *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing\n *  demos with Path TPose to wire `poseDescriptor={pathPoseDescriptor}`\n *  explicitly. `getRotation` surfaces a `pose.rotation` field on non-Path poses\n *  so demos using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to\n *  wire `poseDescriptor={ROTATED_POSE_DESCRIPTOR}` just to get rotated\n *  selection chrome and rotation-aware corner hit-tests. */\nexport const AUTO_POSE_DESCRIPTOR: PoseDescriptor<unknown> = {\n  getBounds: (p) => isPathLike(p)\n    ? pathPoseDescriptor.getBounds(p)\n    : RECT_POSE_DESCRIPTOR.getBounds(p as { x: number; y: number; width: number; height: number }),\n  remapBounds: (p, src, dst) => isPathLike(p)\n    ? pathPoseDescriptor.remapBounds(p, src, dst)\n    : RECT_POSE_DESCRIPTOR.remapBounds(p as { x: number; y: number; width: number; height: number }, src, dst),\n  fromBounds: (b, template) => isPathLike(template)\n    ? pathPoseDescriptor.fromBounds(b, template)\n    : RECT_POSE_DESCRIPTOR.fromBounds(b, template as Bounds),\n  translate: (p, dx, dy) => isPathLike(p)\n    ? pathPoseDescriptor.translate!(p, dx, dy)\n    : RECT_POSE_DESCRIPTOR.translate!(p as { x: number; y: number; width: number; height: number }, dx, dy),\n  getRotation: (p) => {\n    if (isPathLike(p)) return 0;\n    const r = (p as { rotation?: unknown }).rotation;\n    return typeof r === 'number' ? r : 0;\n  },\n  // Path-shaped poses can't carry rotation (see `pathPoseDescriptor`).\n  // Everything else flows through `wrapWithPoseRotation`'s x/y/w/h gate at\n  // paint time, so report `true` and let the wrapper no-op for poses\n  // missing AABB fields.\n  supportsRotation: (p) => !isPathLike(p),\n  withRotation: (p, rotation) => isPathLike(p) ? p : { ...(p as object), rotation },\n};\n"],"mappings":";;;AASA,SAAgBA,EAAW,GAAuB;CAChD,OAAO,CAAC,CAACC,KAAK,OAAOA,KAAM,YAAY,UAAUA,MAC1CA,EAAwB,SAAS,aAAcA,EAAwB,SAAS;AACzF;AAIA,SAAgBC,EAAW,GAA6F;CACtH,IAAI,CAACD,KAAK,OAAOA,KAAM,UAAU,OAAO;CACxC,IAAME,IAAIF;CACV,OAAO,OAAOE,EAAE,KAAM,YAAY,OAAOA,EAAE,KAAM,YAC5C,OAAOA,EAAE,SAAU,YAAY,OAAOA,EAAE,UAAW;AAC1D;AASA,IAAaC,IAAgD;CAC3D,YAAY,MAAMJ,EAAWC,CAAC,IAC1BI,EAAmB,UAAUJ,CAAC,IAC9BK,EAAqB,UAAUL,CAA4D;CAC/F,cAAc,GAAG,GAAK,MAAQD,EAAWC,CAAC,IACtCI,EAAmB,YAAYJ,GAAGM,GAAKC,CAAG,IAC1CF,EAAqB,YAAYL,GAA8DM,GAAKC,CAAG;CAC3G,aAAa,GAAG,MAAaR,EAAWS,CAAQ,IAC5CJ,EAAmB,WAAWK,GAAGD,CAAQ,IACzCH,EAAqB,WAAWI,GAAGD,CAAkB;CACzD,YAAY,GAAG,GAAI,MAAOT,EAAWC,CAAC,IAClCI,EAAmB,UAAWJ,GAAGU,GAAIC,CAAE,IACvCN,EAAqB,UAAWL,GAA8DU,GAAIC,CAAE;CACxG,cAAc,MAAM;EAClB,IAAIZ,EAAWC,CAAC,GAAG,OAAO;EAC1B,IAAME,IAAKF,EAA6B;EACxC,OAAO,OAAOE,KAAM,WAAWA,IAAI;CACrC;CAKA,mBAAmB,MAAM,CAACH,EAAWC,CAAC;CACtC,eAAe,GAAG,MAAaD,EAAWC,CAAC,IAAIA,IAAI;EAAE,GAAIA;EAAc;CAAS;AAClF"}

package/dist/math-Drrw4ewZ.d.ts

@@ -1,160 +0,0 @@
-import '@weasel-js/geom';
-import { Bounds } from '@weasel-js/routing';
-import { b as RotatedPose } from './poseDescriptor-D-OH-tu5.js';
-import './autoPoseDescriptor-vCdt55xm.js';
-
-/**
- * Minimal node interface for the simulation primitive. Matches d3-force's
- * node shape exactly so d3-force's bundled forces work without translation.
- *
- * Consumers extend this with arbitrary additional fields (id, label, etc.).
- */
-interface SimulationNode {
-    x: number;
-    y: number;
-    vx?: number;
-    vy?: number;
-    /** Pin x to this value when non-null. The integrator skips x/vx for the node. */
-    fx?: number | null;
-    fy?: number | null;
-    /** Array index, written by `initialize`. Some forces (e.g. forceLink) rely on it. */
-    index?: number;
-}
-/**
- * Force protocol — contract-compatible with d3-force. A force is a function
- * called once per tick with the current alpha; it mutates `vx`/`vy` on nodes.
- * Optional `initialize` lets the force compute setup (link indices, etc.).
- */
-interface SimulationForce<TNode extends SimulationNode = SimulationNode> {
-    (alpha: number): void;
-    initialize?(nodes: TNode[], random?: () => number): void;
-}
-/** Options for `useSimulation`: everything {@link SimulationOptions} carries,
- *  plus the loop's own callbacks and clock. */
-interface UseSimulationOptions<TNode extends SimulationNode> extends SimulationOptions<TNode> {
-    /** Fired after each integration step. */
-    onTick?: (nodes: TNode[]) => void;
-    /** Fired once when the sim settles (alpha < alphaMin && alphaTarget === 0). */
-    onEnd?: () => void;
-    /** Optional rAF injection. Defaults to window.requestAnimationFrame. */
-    requestFrame?: (cb: (t: number) => void) => number;
-    cancelFrame?: (handle: number) => void;
-}
-/**
- * A force simulation over a set of nodes, with no clock of its own.
- *
- * Each tick applies every force and then integrates velocities, scaled by
- * `alpha` — a temperature that decays toward `alphaTarget` so the layout
- * settles instead of jittering forever. Raise `alphaTarget` to reheat it,
- * which is what a drag does.
- *
- * Nodes are mutated in place; the simulation holds the array, not a copy.
- *
- * Nothing here advances time. {@link Simulation} adds the frame loop; a caller
- * that wants the whole relaxation at once — a layout pass, a pre-warm, a test
- * — drives {@link SimulationCore.tick} itself.
- */
-interface SimulationCore<TNode extends SimulationNode> {
-    readonly nodes: TNode[];
-    setNodes(nodes: TNode[]): this;
-    setForces(forces: SimulationForce<TNode>[]): this;
-    alpha(): number;
-    alpha(value: number): this;
-    alphaTarget(): number;
-    alphaTarget(value: number): this;
-    alphaDecay(): number;
-    alphaDecay(value: number): this;
-    alphaMin(): number;
-    alphaMin(value: number): this;
-    velocityDecay(): number;
-    velocityDecay(value: number): this;
-    /**
-     * Run the tick body synchronously `iterations` times. Does NOT fire
-     * onTick or onEnd (matches d3-force). Used for offscreen pre-warm and tests.
-     */
-    tick(iterations?: number): this;
-    isSettled(): boolean;
-}
-/** A {@link SimulationCore} running on a frame loop. */
-interface Simulation<TNode extends SimulationNode> extends SimulationCore<TNode> {
-    /** Resume the RAF loop. If alpha < alphaMin, reset alpha to 1. */
-    restart(): this;
-    /** Cancel the RAF loop. Does not change alpha. */
-    stop(): this;
-}
-/** What {@link SimulationCore} needs: the nodes, the forces acting on them,
- *  and the cooling schedule. {@link UseSimulationOptions} adds the loop's. */
-interface SimulationOptions<TNode extends SimulationNode> {
-    /** Mutable array of nodes. Kit + forces mutate vx/vy/x/y in place. */
-    nodes: TNode[];
-    /** Forces applied per tick. Each may implement `initialize` for setup. */
-    forces?: SimulationForce<TNode>[];
-    /** Initial alpha. Default 1. */
-    alpha?: number;
-    /** Settle threshold. When alpha drops below and alphaTarget is 0, onEnd fires. Default 0.001. */
-    alphaMin?: number;
-    /** Per-tick decay rate toward alphaTarget. Default 1 - 0.001^(1/300) ≈ 0.0228. */
-    alphaDecay?: number;
-    /** Target alpha. Set above alphaMin to keep sim warm (e.g. during drag). Default 0. */
-    alphaTarget?: number;
-    /** Friction multiplier on velocity per tick: vx *= (1 - velocityDecay). Default 0.4. */
-    velocityDecay?: number;
-    /** Handed to each force's `initialize`. Default `Math.random`; pass a seeded
-     *  source to make a run reproducible. */
-    random?: () => number;
-}
-/** Default alpha decay: such that alpha drops from 1 to alphaMin (0.001) in 300 ticks. */
-declare const DEFAULT_ALPHA_DECAY: number;
-/** Alpha below which a cooling simulation is considered settled. */
-declare const DEFAULT_ALPHA_MIN = 0.001;
-/** Fraction of velocity shed each tick — friction. Higher settles sooner and
- *  overshoots less. */
-declare const DEFAULT_VELOCITY_DECAY = 0.4;
-
-/**
- * The integrator, with no clock attached.
- *
- * Velocity-Verlet over a pluggable force list, contract-compatible with
- * d3-force so d3's own bundled forces drop in untranslated. Nothing here
- * advances time: `tick()` is the only thing that moves a node, and the caller
- * decides how often to call it. `useSimulation` calls it once a frame; a
- * layout pass calls it a few hundred times in one go and reads the result.
- *
- * Splitting it out is what lets a *pure* function run a relaxation — a React
- * hook cannot, and the alternative was a second integrator drifting away from
- * this one.
- */
-
-/**
- * A d3-force-compatible simulation with no clock: nothing moves until `tick()`.
- * Nodes are mutated in place, and primed with `index`, `vx` and `vy` on creation.
- */
-declare function createSimulation<TNode extends SimulationNode>(opts: SimulationOptions<TNode>): SimulationCore<TNode>;
-
-/** AABB center of an unrotated rect — the canonical rotation pivot. */
-declare function aabbCenter(bounds: Bounds): {
-    x: number;
-    y: number;
-};
-/** Rotate `(px, py)` by `angle` (radians) around `(cx, cy)`. */
-declare function rotatePoint(px: number, py: number, cx: number, cy: number, angle: number): {
-    x: number;
-    y: number;
-};
-/** Four corners of an unrotated rect, in TL/TR/BR/BL order. */
-declare function rectCorners(bounds: Bounds): {
-    x: number;
-    y: number;
-}[];
-/** Four corners of a rotated rect (rotation around AABB center), in
- *  TL/TR/BR/BL order. Useful for selection-overlay rendering. */
-declare function rotatedRectCorners(pose: RotatedPose): {
-    x: number;
-    y: number;
-}[];
-/** Hit-test a world point against a rotated rect (rotation around AABB
- *  center). Standard pattern: invert the rotation and AABB-test in the
- *  rect's local frame. */
-declare function pointInRotatedRect(pose: RotatedPose, worldX: number, worldY: number): boolean;
-
-export { DEFAULT_ALPHA_DECAY as D, type SimulationNode as S, type UseSimulationOptions as U, type Simulation as a, DEFAULT_ALPHA_MIN as b, DEFAULT_VELOCITY_DECAY as c, type SimulationCore as d, type SimulationForce as e, type SimulationOptions as f, aabbCenter as g, createSimulation as h, rotatePoint as i, rotatedRectCorners as j, pointInRotatedRect as p, rectCorners as r };