@weasel-js/core 1.9.3 → 1.10.0

package/dist/tools/builtin/pen/usePenTool.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePenTool.js","names":["p","PenIcon","freshScratch","resetScratch","anchorCount","s","n","sp","buildPath","all","subpaths","trailing","anchorsToPath","usePenTool","options","scratchRef","useRef","optsRef","useLatest","forceRender","useReducer","x","commitContinuation","useCallback","cont","drawn","edit","added","addedClosed","pathToAnchors","reverseAnchors","set","next","samePath","commit","deps","allClosed","path","pose","id","joinable","hit","scene","commitJoin","current","other","otherSet","tail","joined","joint","out","sameNode","rest","i","label","ops","keptId","node","createInsertOp","createDeleteOp","applyOps","defaultCommitAdapter","pickUpEndpoint","scratch","radius","scale","viewScale","nearestPathAnchor","pathsNear","wx","wy","h","original","picked","reversed","snap","fn","placeAt","y","withinCloseRadius","withinPxRadius","ax","ay","actions","useMemo","p","params","first","join","ActionDisabledReason","origin","ctx","pickedUp","joinHit","linked","applyOutHandle","sm","moveCtx","se","reason","endCtx","defineTool","cursorFor","createElement","anchor","to","target","dx","dy","shift","c","constrainTo45","area","view","e","pxExtent","px","ids","a","b"],"sources":["../../../../src/tools/builtin/pen/usePenTool.ts"],"sourcesContent":["import { useCallback, useMemo, useReducer, useRef, createElement } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { defineTool } from '../../overlayBinding';\nimport type { Tool } from '../../overlayBinding';\nimport type { ToolPrefGroup } from '../../prefs';\nimport type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { ActionDeps, InvocationCtx } from '@weasel-js/routing';\nimport type { EditAnchorsDep } from 'interactions/actions/depSchema';\nimport { pxExtent, withinPxRadius } from 'core/viewport/pxExtent';\nimport { PenIcon } from '../../../icons';\nimport type { PolygonPath } from '@weasel-js/geom';\nimport { anchorsToPath, pathToAnchors } from 'features/paths/anchors';\nimport { nearestPathAnchor, reverseAnchors, type PathAnchorHit } from 'features/paths/nearestAnchor';\nimport type { Op } from 'core/ops/types';\nimport { createInsertOp } from 'core/ops/create';\nimport { createDeleteOp } from 'core/ops/delete';\nimport { defaultCommitAdapter } from 'interactions/actions/defaultCommitAdapter';\nimport { constrainTo45 } from '../../../util/constrainTo45';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/**\n * In-progress pen anchor. A click places a corner, with no handles. A drag\n * sets `outHandle` to the drag point and `inHandle` to its mirror through\n * the anchor, which shapes the segment coming into it.\n */\nexport interface PenAnchor {\n  x: number;\n  y: number;\n  outHandle?: { x: number; y: number };\n  inHandle?: { x: number; y: number };\n  /** True once Alt is held during the placement drag: from then on the\n   *  in-handle stays where it is, and an anchor dragged with Alt down from\n   *  the start gets none. */\n  altBroken?: boolean;\n}\n\n/** One in-progress subpath of the pen tool: its anchors so far, and whether\n *  the user has closed it. */\nexport interface PenSubpath {\n  anchors: PenAnchor[]; // LOCAL PenAnchor — in-progress\n  closed: boolean;\n}\n\n/**\n * Mutable scratch shared across pen-tool gestures. The hook keeps a stable\n * reference to a single instance and `initScratch` returns it on every call,\n * so click-by-click state survives gesture boundaries and the preview layer\n * can read the same object.\n *\n * ## The pen draws paths; it does not reshape them\n *\n * It draws new nodes, and extends an existing node's open subpath from one\n * of its ends (see `continuing`). Reshaping an existing path is anchor\n * editing: double-click a path to\n * enter edit mode, then use the `editAnchors` / `insertPathAnchor` /\n * `nudgeAnchors` / `deleteAnchors` / `marqueeAnchors` / `cutPathAtAnchor`\n * Actions.\n *\n * The pen used to carry a second, private implementation of all of that,\n * with its own scratch mode, hit-test override, overlay, and undo\n * plumbing. It was reachable only through a `getPathObj` option whose\n * contract required `pose.kind` to be `'polygon'` or `'rect'` — which no\n * kit-created node has, including the ones the pen itself creates. So it\n * was dead in every consumer while shadowing the live implementation, and\n * the two had drifted. Its geometry now lives in\n * `features/paths/anchorEdits.ts`, driven by those Actions.\n */\nexport interface PenScratch {\n  finishedSubpaths: PenSubpath[];\n  current: PenSubpath | null;\n  cursor: { x: number; y: number } | null;\n  draggingHandleAt: number | null;\n  closeHintActive: boolean;\n  /** Set while the pen is extending an existing node's open subpath rather\n   *  than drawing a new node. `current` then starts as that subpath (turned\n   *  around when it was picked up by its first anchor), and the commit\n   *  writes back into the node. */\n  continuing: PenContinuation | null;\n}\n\n/** Which existing subpath the pen picked up, and the node's path as it was. */\nexport interface PenContinuation {\n  id: string;\n  /** Index of the picked-up subpath within `original`. */\n  sub: number;\n  /** True when it was picked up by its first anchor, so `current` runs\n   *  backwards and is turned around again on commit. */\n  reversed: boolean;\n  /** The node's path in world coords at pick-up. */\n  original: PolygonPath;\n}\n\n/** Options for `usePenTool`: how a finished path becomes a pose, where it is\n *  inserted, and when a closed subpath commits. */\nexport interface UsePenToolOptions<TPose> {\n  /** Wrap a finished PolygonPath in the consumer's pose type. */\n  wrapPath: (path: PolygonPath, opts: { closed: boolean }) => TPose;\n  /** Insert + select adapter. */\n  adapter: {\n    addNode: (pose: TPose) => string;\n    setSelection: (ids: string[]) => void;\n    /** Build, without inserting, the node `addNode` would insert for `pose`,\n     *  so the pen can put it in a larger op batch — a new path finished on\n     *  another open path's endpoint is inserted and the other path deleted\n     *  in one undo step. Without it, that click only places an anchor. */\n    makeNode?: (pose: TPose) => { id: string };\n  };\n  /** Auto-select the new object after commit. Default `true`. */\n  autoSelect?: boolean;\n  /** When true (default), clicking the first anchor to close a subpath\n   *  commits immediately — the closed region renders with its fill right\n   *  away. When false, the closed subpath stays in scratch so the user can\n   *  start another subpath; commit then fires on Enter / tool-switch /\n   *  ⌘-click / double-click, producing a compound path. */\n  autoCommitOnClose?: boolean;\n  /** Screen-px hit radius for \"click first anchor to close\". Default `8`.\n   *  Measured as a screen-space circle, so it stays round under non-uniform\n   *  zoom; aligns with `useSelectTool.handleHitRadius`. */\n  closeHitRadius?: number;\n  /** Screen-px radius within which a placed anchor lands exactly on an\n   *  existing path's anchor. Default `8`; `0` turns it off. Takes precedence\n   *  over `snapPoint`, which applies only when no anchor is in range. */\n  anchorSnapRadius?: number;\n  /** Optional point snapper applied to every world-space coordinate the\n   *  pen records or previews — anchor positions (corner clicks, smooth-\n   *  drag base point), the rubber-band cursor, and the outgoing-handle\n   *  target. Receives raw world coords; returns snapped world coords.\n   *  Wire to `gridSnapStrategy`-style spacing via the consumer:\n   *\n   *      snapPoint: (p) => ({\n   *        x: Math.round(p.x / SPACING) * SPACING,\n   *        y: Math.round(p.y / SPACING) * SPACING,\n   *      })\n   *\n   *  Pen state (anchor handles, etc.) is computed AFTER snapping so the\n   *  visible geometry stays grid-aligned. */\n  snapPoint?: (p: { x: number; y: number }) => { x: number; y: number };\n}\n\nfunction freshScratch(): PenScratch {\n  return {\n    finishedSubpaths: [],\n    current: null,\n    cursor: null,\n    draggingHandleAt: null,\n    closeHintActive: false,\n    continuing: null,\n  };\n}\n\nfunction resetScratch(s: PenScratch): void {\n  s.finishedSubpaths = [];\n  s.current = null;\n  s.cursor = null;\n  s.draggingHandleAt = null;\n  s.closeHintActive = false;\n  s.continuing = null;\n}\n\n/** Total anchors across finished subpaths plus the in-progress one. */\nfunction anchorCount(s: PenScratch): number {\n  return (s.current ? s.current.anchors.length : 0)\n    + s.finishedSubpaths.reduce((n, sp) => n + sp.anchors.length, 0);\n}\n\n/** Build a PolygonPath from the pen's accumulated subpaths, by the same\n *  rule as any anchor set: segment A→B is a cubic through A's out-handle and\n *  B's in-handle when either exists, else a line. */\nfunction buildPath(\n  subpaths: PenSubpath[],\n  trailing: PenSubpath | null,\n): PolygonPath {\n  const all = [...subpaths];\n  if (trailing && trailing.anchors.length > 0) all.push(trailing);\n  return anchorsToPath(all.map((sp) => sp.anchors), all.map((sp) => sp.closed));\n}\n\n/**\n * Active-slot Tool: click + drag to build a `PolygonPath` Illustrator-style.\n *\n * State machine: Idle / Drawing / BetweenSubpaths (see design doc).\n * Click places a corner anchor; click-drag places an anchor with an\n * outgoing bezier handle; click-the-first-anchor closes the subpath; Enter\n * open-finishes; Esc discards; tool-switch commits if ≥2 anchors else\n * discards. Shift constrains the placement-drag handle to 0/45/90/135°;\n * Alt during drag breaks the handle mirror for the next segment.\n *\n * Reshaping an existing path is not this tool's job — see {@link PenScratch}.\n */\nexport function usePenTool<TPose>(\n  options: UsePenToolOptions<TPose>,\n): Tool<PenScratch> {\n  const { wrapPath, adapter, autoSelect = true, autoCommitOnClose = true, closeHitRadius = 8, anchorSnapRadius = 8, snapPoint } = options;\n\n  // Persistent scratch: single ref reused across gestures so multi-click\n  // state survives the dispatcher's per-gesture initScratch contract.\n  const scratchRef = useRef<PenScratch | null>(null);\n  if (scratchRef.current === null) scratchRef.current = freshScratch();\n\n  // Latest options stashed so handlers see fresh values without rebuilding\n  // the Tool record (which would lose scratch identity in the dispatcher).\n  const optsRef = useLatest({ wrapPath, adapter, autoSelect, autoCommitOnClose, closeHitRadius, anchorSnapRadius, snapPoint });\n\n  // Scratch is a mutable ref (so click-by-click state survives the\n  // dispatcher's per-gesture initScratch contract). Mutations alone don't\n  // trigger React re-renders, so Canvas never re-paints and the preview\n  // layer stays invisible until something else (e.g. commit) bumps host\n  // state. Force a render after every scratch mutation so the host's\n  // <Canvas layers={{...}}> literal gets a new identity and the paint\n  // useEffect fires. Pull the trigger via ref so the memoized Tool record\n  // doesn't need to rebuild.\n  const [, forceRender] = useReducer((x: number) => x + 1, 0);\n\n  // Geometry helpers shared by the actions below. They read `optsRef` so a\n  // re-render with new options is visible without rebuilding the actions\n  // (which would lose the scratch identity `penPreviewLayer` reads through\n  // `Tool.initScratch`).\n\n  /** Write the pen's subpaths back into the node it picked up: the first\n   *  replaces the subpath it continued, any later ones are appended. Skips\n   *  the write when nothing changed, so an empty pick-up leaves no undo\n   *  entry. */\n  const commitContinuation = useCallback(\n    (s: PenScratch, trailing: PenSubpath | null, edit: EditAnchorsDep | undefined): void => {\n      const cont = s.continuing!;\n      const drawn = [...s.finishedSubpaths, ...(trailing ? [trailing] : [])];\n      if (!edit || drawn.length === 0) return;\n      const { anchors: added, closed: addedClosed } = pathToAnchors(buildPath(drawn, null));\n      if (cont.reversed) added[0] = reverseAnchors(added[0]);\n      const set = pathToAnchors(cont.original);\n      set.anchors.splice(cont.sub, 1, added[0]);\n      set.closed.splice(cont.sub, 1, addedClosed[0]);\n      set.anchors.push(...added.slice(1));\n      set.closed.push(...addedClosed.slice(1));\n      const next: PolygonPath = { ...anchorsToPath(set.anchors, set.closed), fillRule: cont.original.fillRule };\n      if (samePath(next, cont.original)) return;\n      edit.applyEdit(cont.id, next, 'Continue path');\n      if (optsRef.current.autoSelect) optsRef.current.adapter.setSelection([cont.id]);\n    },\n    [optsRef],\n  );\n\n  const commit = useCallback((s: PenScratch, deps: ActionDeps): void => {\n    const trailing = s.current && s.current.anchors.length > 0 ? s.current : null;\n    if (s.continuing) {\n      commitContinuation(s, trailing, deps.editAnchors);\n      resetScratch(s);\n      return;\n    }\n    if (s.finishedSubpaths.length === 0 && !trailing) return;\n    const allClosed =\n      s.finishedSubpaths.every((sp) => sp.closed) &&\n      (trailing === null || trailing.closed);\n    const path = buildPath(s.finishedSubpaths, trailing);\n    const pose = optsRef.current.wrapPath(path, { closed: allClosed });\n    const id = optsRef.current.adapter.addNode(pose);\n    if (optsRef.current.autoSelect) optsRef.current.adapter.setSelection([id]);\n    resetScratch(s);\n  }, [commitContinuation, optsRef]);\n\n  /** Whether an anchor about to land on `hit` finishes the path by joining\n   *  onto another open subpath. Its own continued subpath never counts —\n   *  reaching that one's far end is a close. Declines when the deps can't\n   *  commit the join as one op batch. */\n  const joinable = useCallback((s: PenScratch, deps: ActionDeps, hit: PathAnchorHit | null): hit is PathAnchorHit => {\n    if (!hit || hit.end === null || !s.current || s.current.anchors.length === 0) return false;\n    const cont = s.continuing;\n    if (cont && hit.id === cont.id && hit.sub === cont.sub) return false;\n    const scene = deps.scene;\n    if (!scene && !deps.applyOps) return false;\n    if (!(cont ? deps.editAnchors?.editOps : optsRef.current.adapter.makeNode)) return false;\n    return cont?.id === hit.id || scene?.get(hit.id as never) !== undefined;\n  }, [optsRef]);\n\n  /** Finish the path onto `hit`, the endpoint its last anchor was just placed\n   *  on: the other subpath's anchors follow on from it, turned around when\n   *  `hit` is its last anchor, and its node is deleted. The path being drawn\n   *  keeps its identity — a continued node keeps its id and style, and a new\n   *  path is minted the way any pen path is. One op batch, so one undo. */\n  const commitJoin = useCallback((s: PenScratch, deps: ActionDeps, hit: PathAnchorHit): void => {\n    const edit = deps.editAnchors!;\n    const scene = deps.scene;\n    const current = s.current!;\n    const { anchors: added, closed: addedClosed } = pathToAnchors(buildPath([...s.finishedSubpaths, current], null));\n\n    const other = edit.getEditablePath(hit.id) as PolygonPath;\n    const otherSet = pathToAnchors(other);\n    const tail = hit.end === 'last' ? reverseAnchors(otherSet.anchors[hit.sub]) : otherSet.anchors[hit.sub];\n    const joined = added[added.length - 1];\n    const joint = joined[joined.length - 1];\n    const out = current.anchors[current.anchors.length - 1].outHandle ?? tail[0].outHandle;\n    if (out) joint.outHandle = { ...out };\n    joined.push(...tail.slice(1));\n\n    const cont = s.continuing;\n    const sameNode = cont?.id === hit.id;\n    const rest = sameNode ? { anchors: [], closed: [] } : {\n      anchors: otherSet.anchors.filter((_, i) => i !== hit.sub),\n      closed: otherSet.closed.filter((_, i) => i !== hit.sub),\n    };\n    const label = 'Join paths';\n    const ops: Op[] = [];\n    let keptId: string;\n    if (cont) {\n      if (cont.reversed) added[0] = reverseAnchors(added[0]);\n      const set = pathToAnchors(cont.original);\n      set.anchors.splice(cont.sub, 1, added[0]);\n      set.closed.splice(cont.sub, 1, addedClosed[0]);\n      set.anchors.push(...added.slice(1), ...rest.anchors);\n      set.closed.push(...addedClosed.slice(1), ...rest.closed);\n      if (sameNode) {\n        set.anchors.splice(hit.sub, 1);\n        set.closed.splice(hit.sub, 1);\n      }\n      const next: PolygonPath = { ...anchorsToPath(set.anchors, set.closed), fillRule: cont.original.fillRule };\n      ops.push(...edit.editOps!(cont.id, next, label));\n      keptId = cont.id;\n    } else {\n      const path = anchorsToPath([...added, ...rest.anchors], [...addedClosed, ...rest.closed]);\n      const node = optsRef.current.adapter.makeNode!(optsRef.current.wrapPath(path, { closed: false }));\n      ops.push(createInsertOp({ node }));\n      keptId = node.id;\n    }\n    if (!sameNode) ops.push(createDeleteOp({ node: scene!.get(hit.id as never) as { id: string } }));\n\n    const applyOps = deps.applyOps;\n    if (applyOps) applyOps(ops, label);\n    else scene!.applyBatch(ops, label, defaultCommitAdapter(scene!));\n    if (optsRef.current.autoSelect) optsRef.current.adapter.setSelection([keptId]);\n    resetScratch(s);\n  }, [optsRef]);\n\n  /** From idle, a press on an open subpath's end anchor picks that subpath\n   *  up: it becomes `current`, turned so the pressed end is last. Returns\n   *  whether it did. */\n  const pickUpEndpoint = useCallback((deps: ActionDeps, wx: number, wy: number): boolean => {\n    const scratch = scratchRef.current!;\n    if (scratch.current || scratch.finishedSubpaths.length > 0) return false;\n    const radius = optsRef.current.closeHitRadius;\n    const scale = viewScale(deps);\n    const hit = nearestPathAnchor(pathsNear(deps, wx, wy, radius), { x: wx, y: wy }, radius, scale, (h) => h.end !== null);\n    if (!hit) return false;\n    const original = deps.editAnchors!.getEditablePath(hit.id) as PolygonPath;\n    const picked = pathToAnchors(original).anchors[hit.sub];\n    const reversed = hit.end === 'first' && picked.length > 1;\n    scratch.current = { anchors: reversed ? reverseAnchors(picked) : picked, closed: false };\n    scratch.continuing = { id: hit.id, sub: hit.sub, reversed, original };\n    return true;\n  }, [optsRef]);\n\n  const snap = useCallback((x: number, y: number): { x: number; y: number } => {\n    const fn = optsRef.current.snapPoint;\n    return fn ? fn({ x, y }) : { x, y };\n  }, [optsRef]);\n\n  /** Where an anchor pressed at `(x, y)` lands: on an existing path's anchor\n   *  when one is within `anchorSnapRadius`, else wherever `snapPoint` puts it.\n   *  `hit` names the anchor it snapped to. */\n  const placeAt = useCallback((deps: ActionDeps, x: number, y: number): { x: number; y: number; hit: PathAnchorHit | null } => {\n    const radius = optsRef.current.anchorSnapRadius;\n    if (radius > 0) {\n      const hit = nearestPathAnchor(pathsNear(deps, x, y, radius), { x, y }, radius, viewScale(deps));\n      if (hit) return { x: hit.x, y: hit.y, hit };\n    }\n    return { ...snap(x, y), hit: null };\n  }, [snap, optsRef]);\n\n  /** Is a world point within the close-hit radius of `(ax, ay)`? Measured as a\n   *  screen-space circle, so the zone stays round under non-uniform zoom. */\n  const withinCloseRadius = useCallback(\n    (deps: ActionDeps, ax: number, ay: number, wx: number, wy: number): boolean => {\n      return withinPxRadius(ax - wx, ay - wy, optsRef.current.closeHitRadius, viewScale(deps));\n    },\n    [optsRef],\n  );\n\n  /**\n   * Actions the pen owns, registered by `useToolActions` from inside the\n   * ActionsProvider — see `ToolDef.actions`.\n   *\n   * They close over `scratchRef`, which is why the pen needs no `Selector`\n   * exposing tool scratch to the action layer: the state never leaves the\n   * hook. `useMemo([])` keeps their identity stable for the same reason\n   * `scratchRef` is a ref — the preview layer reads that one object.\n   */\n  const actions = useMemo<Action[]>(() => {\n    const s = () => scratchRef.current!;\n\n    return [\n      {\n        id: 'pen.placeAnchor',\n        label: 'Pen — place anchor',\n        eligible: { capability: 'creates-paths' },\n        requires: ['view', 'areaSelect', 'editAnchors', 'scene', 'applyOps'],\n        invoker: {\n          timing: 'immediate' as const,\n          run: (deps, params) => {\n            const p = params as { pressX?: number; pressY?: number } | undefined;\n            if (p?.pressX === undefined || p.pressY === undefined) return;\n            // The press point, not the release: a click may drift up to the\n            // drag threshold, and an anchor should land where you put the\n            // pointer down. Snapping happens here rather than at press time\n            // so the snapped value is what the geometry records.\n            if (pickUpEndpoint(deps, p.pressX, p.pressY)) {\n              forceRender();\n              return;\n            }\n            const { x: wx, y: wy, hit } = placeAt(deps, p.pressX, p.pressY);\n            const scratch = s();\n\n            // Close-on-first-anchor (>= 3 anchors). With `autoCommitOnClose`\n            // on (default) this commits right away so the closed region\n            // renders with its fill — Illustrator-style. With it off the\n            // closed subpath stays in scratch for compound-path builds and\n            // commits on Enter / tool switch.\n            if (scratch.current && scratch.current.anchors.length >= 3) {\n              const first = scratch.current.anchors[0];\n              if (withinCloseRadius(deps, first.x, first.y, wx, wy)) {\n                scratch.current.closed = true;\n                scratch.finishedSubpaths.push(scratch.current);\n                scratch.current = null;\n                scratch.closeHintActive = false;\n                if (optsRef.current.autoCommitOnClose) commit(scratch, deps);\n                forceRender();\n                return;\n              }\n            }\n\n            const join = joinable(scratch, deps, hit);\n            // Otherwise: append a corner anchor, starting a subpath if needed.\n            if (!scratch.current) scratch.current = { anchors: [], closed: false };\n            scratch.current.anchors.push({ x: wx, y: wy });\n            if (join) commitJoin(scratch, deps, hit);\n            forceRender();\n          },\n        },\n      },\n\n      {\n        id: 'pen.finishOpen',\n        label: 'Pen — finish open path',\n        eligible: { capability: 'creates-paths' },\n        requires: ['editAnchors'],\n        // Needs an actual path to commit. Declining also lets the gesture\n        // fall through: a ⌘-click with fewer than two anchors reaches the\n        // plain-click binding and places an anchor instead.\n        enabled: () => (anchorCount(s()) >= 2 ? true : ActionDisabledReason.NotApplicable),\n        invoker: {\n          timing: 'immediate' as const,\n          run: (deps, params) => {\n            const scratch = s();\n            const p = params as { viaDoubleClick?: boolean } | undefined;\n\n            // A double click arrives AFTER both of its clicks, so the second\n            // one has already appended an anchor. Undo exactly that before\n            // committing: pop it, and drop the subpath entirely if it was the\n            // only anchor in it (which happens when the FIRST click closed a\n            // subpath and the second started a fresh one). The net effect\n            // matches the pen's old private 300ms detector — one anchor\n            // placed, path finished — while using the dispatcher's single\n            // definition of a double click.\n            //\n            // No position check is needed: the anchor to drop is by\n            // construction the one the second click just appended.\n            if (p?.viaDoubleClick && scratch.current) {\n              scratch.current.anchors.pop();\n              if (scratch.current.anchors.length === 0) scratch.current = null;\n            }\n\n            commit(scratch, deps);\n            forceRender();\n          },\n        },\n      },\n\n      {\n        id: 'pen.dragHandle',\n        label: 'Pen — drag out a bezier handle',\n        eligible: { capability: 'creates-paths' },\n        requires: ['view', 'areaSelect', 'editAnchors', 'scene', 'applyOps'],\n        invoker: {\n          timing: 'ongoing' as const,\n          start: (ctx: InvocationCtx) => {\n            const scratch = s();\n            // `drag.start` is the pointerdown position — the dispatcher\n            // buffers the press and releases it at the drag threshold, so the\n            // anchor lands where the user pressed rather than where the\n            // threshold happened to be crossed.\n            const origin = ctx.drag?.start ?? ctx.world;\n            // Dragging from an open path's end picks the path up and pulls\n            // that end's own handle rather than placing a new anchor on it.\n            const pickedUp = pickUpEndpoint(ctx.deps, origin.x, origin.y);\n            // Dragging on another open path's endpoint joins onto it once\n            // the handle is set.\n            let joinHit: PathAnchorHit | null = null;\n            if (!pickedUp) {\n              const { x: ax, y: ay, hit } = placeAt(ctx.deps, origin.x, origin.y);\n              if (joinable(scratch, ctx.deps, hit)) joinHit = hit;\n              if (!scratch.current) scratch.current = { anchors: [], closed: false };\n              scratch.current.anchors.push({ x: ax, y: ay });\n            }\n            scratch.draggingHandleAt = scratch.current!.anchors.length - 1;\n            if (ctx.modifiers.alt) {\n              scratch.current!.anchors[scratch.draggingHandleAt].altBroken = true;\n            }\n            // A picked-up endpoint's in-handle belongs to the existing\n            // segment into it, which the pen does not reshape.\n            const linked = !pickedUp;\n            applyOutHandle(scratch, ctx.world, ctx.modifiers.shift, linked, optsRef.current.snapPoint);\n            forceRender();\n\n            return {\n              onMove: (moveCtx: InvocationCtx) => {\n                const sm = s();\n                if (sm.draggingHandleAt === null) return;\n                if (moveCtx.modifiers.alt && sm.current) {\n                  sm.current.anchors[sm.draggingHandleAt].altBroken = true;\n                }\n                applyOutHandle(sm, moveCtx.world, moveCtx.modifiers.shift, linked, optsRef.current.snapPoint);\n                forceRender();\n              },\n              onEnd: (endCtx: InvocationCtx, reason: 'commit' | 'cancel') => {\n                const se = s();\n                if (reason === 'cancel') {\n                  // `start` appended the anchor (or picked a path up); a\n                  // cancel (pointercancel is the reachable one — Escape and a\n                  // tool switch both reset the whole scratch first) has to\n                  // take it back out.\n                  if (pickedUp) {\n                    resetScratch(se);\n                  } else if (se.current && se.draggingHandleAt === se.current.anchors.length - 1) {\n                    se.current.anchors.pop();\n                    if (se.current.anchors.length === 0) se.current = null;\n                  }\n                  se.draggingHandleAt = null;\n                  forceRender();\n                  return;\n                }\n                if (se.draggingHandleAt !== null) {\n                  if (endCtx.modifiers.alt && se.current) {\n                    se.current.anchors[se.draggingHandleAt].altBroken = true;\n                  }\n                  applyOutHandle(se, endCtx.world, endCtx.modifiers.shift, linked, optsRef.current.snapPoint);\n                  se.draggingHandleAt = null;\n                }\n                if (joinHit && se.current) commitJoin(se, ctx.deps, joinHit);\n                forceRender();\n              },\n            };\n          },\n        },\n      },\n\n      {\n        id: 'pen.finish',\n        label: 'Pen — finish path',\n        eligible: { capability: 'creates-paths' },\n        requires: ['editAnchors'],\n        enabled: () => (anchorCount(s()) > 0 ? true : ActionDisabledReason.NotApplicable),\n        invoker: {\n          timing: 'immediate' as const,\n          run: (deps) => {\n            commit(s(), deps);\n            forceRender();\n          },\n        },\n      },\n\n      {\n        id: 'pen.cancel',\n        label: 'Pen — discard path',\n        eligible: { capability: 'creates-paths' },\n        // Declining with nothing drawn is what keeps Escape's first-match\n        // ladder intact: an empty pen passes the key to `escape`, which goes\n        // on to clear the selection / return to the default tool.\n        enabled: () => {\n          const scratch = s();\n          return scratch.current !== null || scratch.finishedSubpaths.length > 0\n            ? true\n            : ActionDisabledReason.NotApplicable;\n        },\n        invoker: {\n          timing: 'immediate' as const,\n          run: () => {\n            resetScratch(s());\n            forceRender();\n          },\n        },\n      },\n    ];\n  }, [commit, placeAt, withinCloseRadius, pickUpEndpoint, joinable, commitJoin, optsRef]);\n\n  return useMemo(() => {\n    return defineTool<PenScratch>({\n      id: 'pen',\n      capabilities: ['creates-paths'],\n      hookName: 'usePenTool',\n      // Reads the tool's own ref rather than a scratch handed in by a\n      // dispatcher — the pen owns this state and nothing else needs it.\n      cursor: () =>\n        scratchRef.current?.closeHintActive\n          ? 'pointer'\n          : cursorFor('pen', { fallback: 'crosshair' }),\n      presentation: {\n        label: 'Pen',\n        icon: createElement(PenIcon),\n        group: 'draw',\n      },\n      // Persistent-ref scratch. `penPreviewLayer` reads the in-progress path\n      // by calling `Tool.initScratch()` and getting this same object back, so\n      // the identity is load-bearing.\n      initScratch: () => scratchRef.current!,\n      actions,\n\n      onDeactivate: () => {\n        // Anything still in scratch is by definition incomplete — the user\n        // hasn't closed it (close-on-first-anchor), open-finished it\n        // (cmd-click), or pressed Enter. Switching tools mid-path should\n        // discard, not auto-commit a stub polyline that the user didn't\n        // ask for. Mirrors Escape's behavior so \"stop drawing\" is\n        // consistent across exits.\n        resetScratch(scratchRef.current!);\n        forceRender();\n      },\n\n      bindings: [\n        // Plain click places an anchor; ⌘/Ctrl-click open-finishes\n        // (Illustrator). Strict modifier matching keeps the two apart, and\n        // `mod` resolves to meta on mac / ctrl elsewhere — the tool-route\n        // grammar's modifier matcher accepted either key on either platform.\n        { spec: { kind: 'click' as const, mods: { shift: 'optional' as const, alt: 'optional' as const } }, actionId: 'pen.placeAnchor' },\n        { spec: { kind: 'click' as const, mods: { mod: true, shift: 'optional' as const, alt: 'optional' as const } }, actionId: 'pen.finishOpen' },\n        // Double-click on the last anchor also open-finishes. This used to be\n        // a private 300ms/radius check inside the click route — a fourth\n        // double-click detector in a codebase that had just collapsed three\n        // into one (audit 3.3).\n        {\n          spec: { kind: 'doubleClick' as const, mods: { shift: 'optional' as const, alt: 'optional' as const } },\n          actionId: 'pen.finishOpen',\n          opts: { params: { viaDoubleClick: true } },\n        },\n        { spec: { kind: 'drag' as const, mods: { shift: 'optional' as const, alt: 'optional' as const } }, actionId: 'pen.dragHandle' },\n        { spec: { kind: 'key' as const, key: 'Enter' }, actionId: 'pen.finish' },\n        { spec: { kind: 'key' as const, key: 'Escape' }, actionId: 'pen.cancel' },\n      ],\n    });\n  }, [actions]);\n}\n\nusePenTool.prefs = {\n  name: 'Pen',\n  description: 'Pen-tool behavior.',\n  children: {\n    autoCommitOnClose: {\n      kind: 'boolean',\n      name: 'Auto-commit pen on close',\n      description: \"When you click the pen tool's first anchor to close a region, commit immediately so it renders with its fill. Off: keep the path in preview until you press Enter (lets you build a compound path from multiple closed subpaths).\",\n      default: true,\n    },\n  },\n} satisfies ToolPrefGroup;\n\n/** Point the anchor's outgoing handle at `target`, optionally snapped and\n *  optionally constrained to 45° steps. When `linked` and not Alt-broken,\n *  the in-handle follows as its mirror through the anchor. */\nfunction applyOutHandle<S extends PenScratch>(\n  s: S,\n  target: { x: number; y: number },\n  shift: boolean,\n  linked: boolean,\n  snap?: (p: { x: number; y: number }) => { x: number; y: number },\n): void {\n  if (s.current === null || s.draggingHandleAt === null) return;\n  const anchor = s.current.anchors[s.draggingHandleAt];\n  const to = snap ? snap(target) : target;\n  let dx = to.x - anchor.x;\n  let dy = to.y - anchor.y;\n  if (shift) {\n    const c = constrainTo45(dx, dy);\n    dx = c.dx;\n    dy = c.dy;\n  }\n  anchor.outHandle = { x: anchor.x + dx, y: anchor.y + dy };\n  if (linked && !anchor.altBroken) anchor.inHandle = { x: anchor.x - dx, y: anchor.y - dy };\n}\n\nfunction viewScale(deps: ActionDeps): { x: number; y: number } {\n  return deps.view?.get().scale ?? { x: 1, y: 1 };\n}\n\n/** Existing editable paths, world coords, with ink within `px` screen\n *  pixels of `(wx, wy)` — front-to-back, as the area query returns them.\n *  Empty when the host publishes no `areaSelect` or `editAnchors` dep. */\nfunction pathsNear(\n  deps: ActionDeps,\n  wx: number,\n  wy: number,\n  px: number,\n): Array<{ id: string; path: PolygonPath }> {\n  const area = deps.areaSelect;\n  const edit = deps.editAnchors;\n  if (!area || !edit) return [];\n  const view = deps.view;\n  const e = pxExtent(px, viewScale(deps));\n  const ids = area.hitTestArea({ x: wx - e.x, y: wy - e.y, width: 2 * e.x, height: 2 * e.y }, view);\n  const out: Array<{ id: string; path: PolygonPath }> = [];\n  for (const id of ids) {\n    const path = edit.getEditablePath(id) as PolygonPath | null;\n    if (path?.kind === 'polygon') out.push({ id, path });\n  }\n  return out;\n}\n\nfunction samePath(a: PolygonPath, b: PolygonPath): boolean {\n  if (a.commands.length !== b.commands.length || a.coords.length !== b.coords.length) return false;\n  for (let i = 0; i < a.commands.length; i++) if (a.commands[i] !== b.commands[i]) return false;\n  for (let i = 0; i < a.coords.length; i++) if (a.coords[i] !== b.coords[i]) return false;\n  return true;\n}\n"],"mappings":"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"}
+{"version":3,"file":"usePenTool.js","names":["p","PenIcon","freshScratch","resetScratch","anchorCount","s","n","sp","buildPath","all","subpaths","trailing","anchorsToPath","usePenTool","options","scratchRef","useRef","optsRef","useLatest","forceRender","useReducer","x","overlay","useState","createPenPreviewLayer","commitContinuation","useCallback","edit","deps","cont","drawn","added","addedClosed","pathToAnchors","reverseAnchors","set","next","samePath","asNodeId","commit","open","allClosed","path","id","boundsOfPath","joinable","hit","scene","commitJoin","current","other","otherSet","tail","joined","joint","out","sameNode","rest","i","label","ops","keptId","built","createDeleteOp","applyOps","defaultCommitAdapter","pickUpEndpoint","scratch","radius","scale","viewScale","nearestPathAnchor","pathsNear","wx","wy","h","original","picked","reversed","snap","fn","placeAt","y","withinCloseRadius","withinPxRadius","ax","ay","trail","useMemo","view","follower","createPointerFollower","track","at","first","actions","p","params","join","ActionDisabledReason","origin","ctx","pickedUp","joinHit","linked","applyOutHandle","sm","moveCtx","se","reason","endCtx","defineTool","cursorFor","createElement","anchor","to","target","dx","dy","shift","c","constrainTo45","area","e","pxExtent","px","ids","a","b"],"sources":["../../../../src/tools/builtin/pen/usePenTool.ts"],"sourcesContent":["import { useCallback, useMemo, useReducer, useRef, useState, createElement } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { PrefGroup } from '@weasel-js/prefs';\nimport { defineTool } from '../../overlayBinding';\nimport type { Tool } from '../../overlayBinding';\nimport type { Action } from '@weasel-js/routing';\nimport { ActionDisabledReason } from '@weasel-js/routing';\nimport type { ActionDeps, InvocationCtx } from '@weasel-js/routing';\nimport { asNodeId } from 'core/scene/types';\nimport { pxExtent, withinPxRadius, nearestPathAnchor, reverseAnchors, type PathAnchorHit } from '@weasel-js/geom';\nimport { PenIcon } from '../../../icons';\nimport { boundsOfPath, type PolygonPath, anchorsToPath, pathToAnchors } from '@weasel-js/geom';\nimport { createPenPreviewLayer } from 'features/paths/penPreviewLayer';\nimport type { Op } from 'core/ops/types';\nimport { createDeleteOp } from 'core/ops/delete';\nimport { defaultCommitAdapter } from 'interactions/actions/defaultCommitAdapter';\nimport { constrainTo45 } from '../../../util/constrainTo45';\nimport { cursorFor } from '@weasel-js/cursor';\nimport { createPointerFollower } from '../shared/pointerFollower';\n\n/**\n * In-progress pen anchor. A click places a corner, with no handles. A drag\n * sets `outHandle` to the drag point and `inHandle` to its mirror through\n * the anchor, which shapes the segment coming into it.\n */\nexport interface PenAnchor {\n  x: number;\n  y: number;\n  outHandle?: { x: number; y: number };\n  inHandle?: { x: number; y: number };\n  /** True once Alt is held during the placement drag: from then on the\n   *  in-handle stays where it is, and an anchor dragged with Alt down from\n   *  the start gets none. */\n  altBroken?: boolean;\n}\n\n/** One in-progress subpath of the pen tool: its anchors so far, and whether\n *  the user has closed it. */\nexport interface PenSubpath {\n  anchors: PenAnchor[]; // LOCAL PenAnchor — in-progress\n  closed: boolean;\n}\n\n/**\n * Mutable state shared across pen-tool gestures. The hook keeps a single\n * instance for its life and changes it in place, so click-by-click state\n * survives gesture boundaries and the tool's preview overlay reads the same\n * object.\n *\n * The pen draws new nodes, and extends an existing node's open subpath from\n * one of its ends (see `continuing`). Reshaping an existing path is anchor\n * editing: double-click a path to enter edit mode.\n */\nexport interface PenScratch {\n  finishedSubpaths: PenSubpath[];\n  current: PenSubpath | null;\n  cursor: { x: number; y: number } | null;\n  draggingHandleAt: number | null;\n  closeHintActive: boolean;\n  /** Set while the pen is extending an existing node's open subpath rather\n   *  than drawing a new node. `current` then starts as that subpath (turned\n   *  around when it was picked up by its first anchor), and the commit\n   *  writes back into the node. */\n  continuing: PenContinuation | null;\n}\n\n/** Which existing subpath the pen picked up, and the node's path as it was. */\nexport interface PenContinuation {\n  id: string;\n  /** Index of the picked-up subpath within `original`. */\n  sub: number;\n  /** True when it was picked up by its first anchor, so `current` runs\n   *  backwards and is turned around again on commit. */\n  reversed: boolean;\n  /** The node's path in world coords at pick-up. */\n  original: PolygonPath;\n}\n\n/** Options for `usePenTool`: when a closed subpath commits, and how anchors\n *  snap. A finished path is inserted through the `insert` dep as kind\n *  `'path'`, the route every shape tool takes, so a consumer shapes the node\n *  by overriding that dep. */\nexport interface UsePenToolOptions {\n  /** Auto-select the new object after commit. Default `true`. */\n  autoSelect?: boolean;\n  /** When true (default), clicking the first anchor to close a subpath\n   *  commits immediately — the closed region renders with its fill right\n   *  away. When false, the closed subpath stays in scratch so the user can\n   *  start another subpath; commit then fires on Enter / ⌘-click /\n   *  double-click, producing a compound path. Switching tools first discards\n   *  it, as Escape does. */\n  autoCommitOnClose?: boolean;\n  /** Screen-px hit radius for \"click first anchor to close\". Default `8`.\n   *  Measured as a screen-space circle, so it stays round under non-uniform\n   *  zoom; aligns with `useSelectTool.handleHitRadius`. */\n  closeHitRadius?: number;\n  /** Screen-px radius within which a placed anchor lands exactly on an\n   *  existing path's anchor. Default `8`; `0` turns it off. Takes precedence\n   *  over `snapPoint`, which applies only when no anchor is in range. */\n  anchorSnapRadius?: number;\n  /** Optional point snapper applied to every world-space coordinate the\n   *  pen records or previews — anchor positions (corner clicks, smooth-\n   *  drag base point), the rubber-band cursor, and the outgoing-handle\n   *  target. Receives raw world coords; returns snapped world coords.\n   *  Pen state (anchor handles, etc.) is computed AFTER snapping so the\n   *  visible geometry stays grid-aligned. */\n  snapPoint?: (p: { x: number; y: number }) => { x: number; y: number };\n}\n\nfunction freshScratch(): PenScratch {\n  return {\n    finishedSubpaths: [],\n    current: null,\n    cursor: null,\n    draggingHandleAt: null,\n    closeHintActive: false,\n    continuing: null,\n  };\n}\n\nfunction resetScratch(s: PenScratch): void {\n  s.finishedSubpaths = [];\n  s.current = null;\n  s.cursor = null;\n  s.draggingHandleAt = null;\n  s.closeHintActive = false;\n  s.continuing = null;\n}\n\n/** Total anchors across finished subpaths plus the in-progress one. */\nfunction anchorCount(s: PenScratch): number {\n  return (s.current ? s.current.anchors.length : 0)\n    + s.finishedSubpaths.reduce((n, sp) => n + sp.anchors.length, 0);\n}\n\n/** Build a PolygonPath from the pen's accumulated subpaths, by the same\n *  rule as any anchor set: segment A→B is a cubic through A's out-handle and\n *  B's in-handle when either exists, else a line. */\nfunction buildPath(\n  subpaths: PenSubpath[],\n  trailing: PenSubpath | null,\n): PolygonPath {\n  const all = [...subpaths];\n  if (trailing && trailing.anchors.length > 0) all.push(trailing);\n  return anchorsToPath(all.map((sp) => sp.anchors), all.map((sp) => sp.closed));\n}\n\n/**\n * Active-slot Tool: click + drag to build a `PolygonPath` Illustrator-style.\n *\n * Click places a corner anchor; click-drag places an anchor with an\n * outgoing bezier handle; click-the-first-anchor closes the subpath; Enter\n * open-finishes; Esc discards, and so does a tool switch. Shift constrains the placement-drag handle to 0/45/90/135°;\n * Alt during drag breaks the handle mirror for the next segment.\n *\n * Reshaping an existing path is not this tool's job — see {@link PenScratch}.\n */\nexport function usePenTool(\n  options: UsePenToolOptions = {},\n): Tool {\n  const { autoSelect = true, autoCommitOnClose = true, closeHitRadius = 8, anchorSnapRadius = 8, snapPoint } = options;\n\n  const scratchRef = useRef<PenScratch | null>(null);\n  if (scratchRef.current === null) scratchRef.current = freshScratch();\n\n  // Latest options stashed so handlers see fresh values without rebuilding\n  // the Tool record.\n  const optsRef = useLatest({ autoSelect, autoCommitOnClose, closeHitRadius, anchorSnapRadius, snapPoint });\n\n  // Scratch mutations alone don't trigger React re-renders, so the preview\n  // layer would not repaint. Force a render after every scratch mutation.\n  const [, forceRender] = useReducer((x: number) => x + 1, 0);\n  const [overlay] = useState(() => createPenPreviewLayer({ state: scratchRef.current! }));\n\n  /** Write the pen's subpaths back into the node it picked up: the first\n   *  replaces the subpath it continued, any later ones are appended. Skips\n   *  the write when nothing changed, so an empty pick-up leaves no undo\n   *  entry. */\n  const commitContinuation = useCallback(\n    (s: PenScratch, trailing: PenSubpath | null, deps: ActionDeps): void => {\n      const edit = deps.editAnchors;\n      const cont = s.continuing!;\n      const drawn = [...s.finishedSubpaths, ...(trailing ? [trailing] : [])];\n      if (!edit || drawn.length === 0) return;\n      const { anchors: added, closed: addedClosed } = pathToAnchors(buildPath(drawn, null));\n      if (cont.reversed) added[0] = reverseAnchors(added[0]);\n      const set = pathToAnchors(cont.original);\n      set.anchors.splice(cont.sub, 1, added[0]);\n      set.closed.splice(cont.sub, 1, addedClosed[0]);\n      set.anchors.push(...added.slice(1));\n      set.closed.push(...addedClosed.slice(1));\n      const next = anchorsToPath(set.anchors, set.closed, cont.original);\n      if (samePath(next, cont.original)) return;\n      edit.applyEdit(cont.id, next, 'Continue path');\n      if (optsRef.current.autoSelect) deps.selection?.set([asNodeId(cont.id)]);\n    },\n    [optsRef],\n  );\n\n  const commit = useCallback((s: PenScratch, deps: ActionDeps): void => {\n    const trailing = s.current && s.current.anchors.length > 0 ? s.current : null;\n    if (s.continuing) {\n      commitContinuation(s, trailing, deps);\n      resetScratch(s);\n      return;\n    }\n    // One anchor draws nothing; committing it would leave an invisible node.\n    const open = trailing && trailing.anchors.length >= 2 ? trailing : null;\n    if (s.finishedSubpaths.length === 0 && !open) {\n      resetScratch(s);\n      return;\n    }\n    const allClosed =\n      s.finishedSubpaths.every((sp) => sp.closed) &&\n      (open === null || open.closed);\n    const path = buildPath(s.finishedSubpaths, open);\n    const id = deps.insert?.commit(boundsOfPath(path), { kind: 'path', path, closed: allClosed }) ?? null;\n    if (id !== null && optsRef.current.autoSelect) deps.selection?.set([id]);\n    resetScratch(s);\n  }, [commitContinuation, optsRef]);\n\n  /** Whether an anchor about to land on `hit` finishes the path by joining\n   *  onto another open subpath. Its own continued subpath never counts —\n   *  reaching that one's far end is a close. Declines when the deps can't\n   *  commit the join as one op batch. */\n  const joinable = useCallback((s: PenScratch, deps: ActionDeps, hit: PathAnchorHit | null): hit is PathAnchorHit => {\n    if (!hit || hit.end === null || !s.current || s.current.anchors.length === 0) return false;\n    const cont = s.continuing;\n    if (cont && hit.id === cont.id && hit.sub === cont.sub) return false;\n    const scene = deps.scene;\n    if (!scene && !deps.applyOps) return false;\n    if (!(cont ? deps.editAnchors?.editOps : deps.insert?.build)) return false;\n    return cont?.id === hit.id || scene?.get(hit.id as never) !== undefined;\n  }, []);\n\n  /** Finish the path onto `hit`, the endpoint its last anchor was just placed\n   *  on: the other subpath's anchors follow on from it, turned around when\n   *  `hit` is its last anchor, and its node is deleted. The path being drawn\n   *  keeps its identity — a continued node keeps its id and style, and a new\n   *  path is minted the way any pen path is. One op batch, so one undo. */\n  const commitJoin = useCallback((s: PenScratch, deps: ActionDeps, hit: PathAnchorHit): void => {\n    const edit = deps.editAnchors!;\n    const scene = deps.scene;\n    const current = s.current!;\n    const { anchors: added, closed: addedClosed } = pathToAnchors(buildPath([...s.finishedSubpaths, current], null));\n\n    const other = edit.getEditablePath(hit.id) as PolygonPath;\n    const otherSet = pathToAnchors(other);\n    const tail = hit.end === 'last' ? reverseAnchors(otherSet.anchors[hit.sub]) : otherSet.anchors[hit.sub];\n    const joined = added[added.length - 1];\n    const joint = joined[joined.length - 1];\n    const out = current.anchors[current.anchors.length - 1].outHandle ?? tail[0].outHandle;\n    if (out) joint.outHandle = { ...out };\n    joined.push(...tail.slice(1));\n\n    const cont = s.continuing;\n    const sameNode = cont?.id === hit.id;\n    const rest = sameNode ? { anchors: [], closed: [] } : {\n      anchors: otherSet.anchors.filter((_, i) => i !== hit.sub),\n      closed: otherSet.closed.filter((_, i) => i !== hit.sub),\n    };\n    const label = 'Join paths';\n    const ops: Op[] = [];\n    let keptId: string;\n    if (cont) {\n      if (cont.reversed) added[0] = reverseAnchors(added[0]);\n      const set = pathToAnchors(cont.original);\n      set.anchors.splice(cont.sub, 1, added[0]);\n      set.closed.splice(cont.sub, 1, addedClosed[0]);\n      set.anchors.push(...added.slice(1), ...rest.anchors);\n      set.closed.push(...addedClosed.slice(1), ...rest.closed);\n      if (sameNode) {\n        set.anchors.splice(hit.sub, 1);\n        set.closed.splice(hit.sub, 1);\n      }\n      const next = anchorsToPath(set.anchors, set.closed, cont.original);\n      ops.push(...edit.editOps!(cont.id, next, label));\n      keptId = cont.id;\n    } else {\n      const path = anchorsToPath([...added, ...rest.anchors], [...addedClosed, ...rest.closed]);\n      const built = deps.insert!.build!(boundsOfPath(path), { kind: 'path', path, closed: false });\n      if (built === null) return;\n      ops.push(...built.ops);\n      keptId = built.id;\n    }\n    if (!sameNode) ops.push(createDeleteOp({ node: scene!.get(hit.id as never) as { id: string } }));\n\n    const applyOps = deps.applyOps;\n    if (applyOps) applyOps(ops, label);\n    else scene!.applyBatch(ops, label, defaultCommitAdapter(scene!));\n    if (optsRef.current.autoSelect) deps.selection?.set([asNodeId(keptId)]);\n    resetScratch(s);\n  }, [optsRef]);\n\n  /** From idle, a press on an open subpath's end anchor picks that subpath\n   *  up: it becomes `current`, turned so the pressed end is last. Returns\n   *  whether it did. */\n  const pickUpEndpoint = useCallback((deps: ActionDeps, wx: number, wy: number): boolean => {\n    const scratch = scratchRef.current!;\n    if (scratch.current || scratch.finishedSubpaths.length > 0) return false;\n    const radius = optsRef.current.closeHitRadius;\n    const scale = viewScale(deps);\n    const hit = nearestPathAnchor(pathsNear(deps, wx, wy, radius), { x: wx, y: wy }, radius, scale, (h) => h.end !== null);\n    if (!hit) return false;\n    const original = deps.editAnchors!.getEditablePath(hit.id) as PolygonPath;\n    const picked = pathToAnchors(original).anchors[hit.sub];\n    const reversed = hit.end === 'first' && picked.length > 1;\n    scratch.current = { anchors: reversed ? reverseAnchors(picked) : picked, closed: false };\n    scratch.continuing = { id: hit.id, sub: hit.sub, reversed, original };\n    return true;\n  }, [optsRef]);\n\n  const snap = useCallback((x: number, y: number): { x: number; y: number } => {\n    const fn = optsRef.current.snapPoint;\n    return fn ? fn({ x, y }) : { x, y };\n  }, [optsRef]);\n\n  /** Where an anchor pressed at `(x, y)` lands: on an existing path's anchor\n   *  when one is within `anchorSnapRadius`, else wherever `snapPoint` puts it.\n   *  `hit` names the anchor it snapped to. */\n  const placeAt = useCallback((deps: ActionDeps, x: number, y: number): { x: number; y: number; hit: PathAnchorHit | null } => {\n    const radius = optsRef.current.anchorSnapRadius;\n    if (radius > 0) {\n      const hit = nearestPathAnchor(pathsNear(deps, x, y, radius), { x, y }, radius, viewScale(deps));\n      if (hit) return { x: hit.x, y: hit.y, hit };\n    }\n    return { ...snap(x, y), hit: null };\n  }, [snap, optsRef]);\n\n  /** Is a world point within the close-hit radius of `(ax, ay)`? Measured as a\n   *  screen-space circle, so the zone stays round under non-uniform zoom. */\n  const withinCloseRadius = useCallback(\n    (deps: ActionDeps, ax: number, ay: number, wx: number, wy: number): boolean => {\n      return withinPxRadius(ax - wx, ay - wy, optsRef.current.closeHitRadius, viewScale(deps));\n    },\n    [optsRef],\n  );\n\n  // The rubber band and the close hint trail the `pointer` dep while a path is\n  // in progress. `view` is the camera of the deps last followed through.\n  const trail = useMemo(() => {\n    let view: ActionDeps['view'];\n    const follower = createPointerFollower(() => track());\n    const track = (): void => {\n      const s = scratchRef.current!;\n      if (!s.current && s.finishedSubpaths.length === 0) follower.unfollow();\n      const at = s.current ? follower.pointer()?.get() ?? null : null;\n      s.cursor = at ? snap(at.worldX, at.worldY) : null;\n      const first = s.current && s.current.anchors.length >= 3 ? s.current.anchors[0] : null;\n      s.closeHintActive = first !== null && s.cursor !== null && withinPxRadius(\n        first.x - s.cursor.x, first.y - s.cursor.y,\n        optsRef.current.closeHitRadius, view?.get().scale ?? { x: 1, y: 1 },\n      );\n      forceRender();\n    };\n    return {\n      /** Repaint after a scratch change. */\n      refresh: track,\n      /** The same, following `deps`' pointer from here on. */\n      update(deps: ActionDeps): void {\n        view = deps.view;\n        follower.follow(deps.pointer);\n        track();\n      },\n      stop(): void {\n        follower.unfollow();\n        forceRender();\n      },\n    };\n  }, [snap, optsRef]);\n\n  /**\n   * Actions the pen owns, registered by `useToolActions` from inside the\n   * ActionsProvider — see `ToolDef.actions`. They close over `scratchRef`,\n   * so the state never leaves the hook.\n   */\n  const actions = useMemo<Action[]>(() => {\n    const s = () => scratchRef.current!;\n\n    return [\n      {\n        id: 'pen.placeAnchor',\n        label: 'Pen — place anchor',\n        eligible: { capability: 'creates-paths' },\n        requires: ['view', 'pointer', 'areaSelect', 'editAnchors', 'scene', 'applyOps', 'insert', 'selection'],\n        invoker: {\n          timing: 'immediate' as const,\n          run: (deps, params) => {\n            const p = params as { pressX?: number; pressY?: number } | undefined;\n            if (p?.pressX === undefined || p.pressY === undefined) return;\n            // The press point, not the release: a click may drift up to the\n            // drag threshold.\n            if (pickUpEndpoint(deps, p.pressX, p.pressY)) {\n              trail.update(deps);\n              return;\n            }\n            const { x: wx, y: wy, hit } = placeAt(deps, p.pressX, p.pressY);\n            const scratch = s();\n\n            // Close-on-first-anchor (>= 3 anchors). With `autoCommitOnClose`\n            // off the closed subpath stays in scratch for compound-path builds.\n            if (scratch.current && scratch.current.anchors.length >= 3) {\n              const first = scratch.current.anchors[0];\n              if (withinCloseRadius(deps, first.x, first.y, wx, wy)) {\n                scratch.current.closed = true;\n                scratch.finishedSubpaths.push(scratch.current);\n                scratch.current = null;\n                scratch.closeHintActive = false;\n                if (optsRef.current.autoCommitOnClose) commit(scratch, deps);\n                trail.update(deps);\n                return;\n              }\n            }\n\n            const join = joinable(scratch, deps, hit);\n            // Otherwise: append a corner anchor, starting a subpath if needed.\n            if (!scratch.current) scratch.current = { anchors: [], closed: false };\n            scratch.current.anchors.push({ x: wx, y: wy });\n            if (join) commitJoin(scratch, deps, hit);\n            trail.update(deps);\n          },\n        },\n      },\n\n      {\n        id: 'pen.finishOpen',\n        label: 'Pen — finish open path',\n        eligible: { capability: 'creates-paths' },\n        requires: ['editAnchors', 'insert', 'selection'],\n        // Needs an actual path to commit. Declining also lets the gesture\n        // fall through: a ⌘-click with fewer than two anchors reaches the\n        // plain-click binding and places an anchor instead.\n        enabled: () => (anchorCount(s()) >= 2 ? true : ActionDisabledReason.NotApplicable),\n        invoker: {\n          timing: 'immediate' as const,\n          run: (deps, params) => {\n            const scratch = s();\n            const p = params as { viaDoubleClick?: boolean } | undefined;\n\n            // A double click arrives AFTER both of its clicks, so the second\n            // one has already appended an anchor. Undo exactly that before\n            // committing: pop it, and drop the subpath entirely if it was the\n            // only anchor in it (which happens when the FIRST click closed a\n            // subpath and the second started a fresh one).\n            if (p?.viaDoubleClick && scratch.current) {\n              scratch.current.anchors.pop();\n              if (scratch.current.anchors.length === 0) scratch.current = null;\n            }\n\n            commit(scratch, deps);\n            trail.refresh();\n          },\n        },\n      },\n\n      {\n        id: 'pen.dragHandle',\n        label: 'Pen — drag out a bezier handle',\n        eligible: { capability: 'creates-paths' },\n        requires: ['view', 'pointer', 'areaSelect', 'editAnchors', 'scene', 'applyOps', 'insert', 'selection'],\n        invoker: {\n          timing: 'ongoing' as const,\n          start: (ctx: InvocationCtx) => {\n            const scratch = s();\n            // `drag.start` is the pointerdown position, so the anchor lands\n            // where the user pressed rather than where the drag threshold\n            // happened to be crossed.\n            const origin = ctx.drag?.start ?? ctx.world;\n            // Dragging from an open path's end picks the path up and pulls\n            // that end's own handle rather than placing a new anchor on it.\n            const pickedUp = pickUpEndpoint(ctx.deps, origin.x, origin.y);\n            // Dragging on another open path's endpoint joins onto it once\n            // the handle is set.\n            let joinHit: PathAnchorHit | null = null;\n            if (!pickedUp) {\n              const { x: ax, y: ay, hit } = placeAt(ctx.deps, origin.x, origin.y);\n              if (joinable(scratch, ctx.deps, hit)) joinHit = hit;\n              if (!scratch.current) scratch.current = { anchors: [], closed: false };\n              scratch.current.anchors.push({ x: ax, y: ay });\n            }\n            scratch.draggingHandleAt = scratch.current!.anchors.length - 1;\n            if (ctx.modifiers.alt) {\n              scratch.current!.anchors[scratch.draggingHandleAt].altBroken = true;\n            }\n            // A picked-up endpoint's in-handle belongs to the existing\n            // segment into it, which the pen does not reshape.\n            const linked = !pickedUp;\n            applyOutHandle(scratch, ctx.world, ctx.modifiers.shift, linked, optsRef.current.snapPoint);\n            trail.update(ctx.deps);\n\n            return {\n              onMove: (moveCtx: InvocationCtx) => {\n                const sm = s();\n                if (sm.draggingHandleAt === null) return;\n                if (moveCtx.modifiers.alt && sm.current) {\n                  sm.current.anchors[sm.draggingHandleAt].altBroken = true;\n                }\n                applyOutHandle(sm, moveCtx.world, moveCtx.modifiers.shift, linked, optsRef.current.snapPoint);\n                forceRender();\n              },\n              onEnd: (endCtx: InvocationCtx, reason: 'commit' | 'cancel') => {\n                const se = s();\n                if (reason === 'cancel') {\n                  // `start` appended the anchor (or picked a path up); a\n                  // cancel has to take it back out.\n                  if (pickedUp) {\n                    resetScratch(se);\n                  } else if (se.current && se.draggingHandleAt === se.current.anchors.length - 1) {\n                    se.current.anchors.pop();\n                    if (se.current.anchors.length === 0) se.current = null;\n                  }\n                  se.draggingHandleAt = null;\n                  trail.refresh();\n                  return;\n                }\n                if (se.draggingHandleAt !== null) {\n                  if (endCtx.modifiers.alt && se.current) {\n                    se.current.anchors[se.draggingHandleAt].altBroken = true;\n                  }\n                  applyOutHandle(se, endCtx.world, endCtx.modifiers.shift, linked, optsRef.current.snapPoint);\n                  se.draggingHandleAt = null;\n                }\n                if (joinHit && se.current) commitJoin(se, ctx.deps, joinHit);\n                trail.refresh();\n              },\n            };\n          },\n        },\n      },\n\n      {\n        id: 'pen.finish',\n        label: 'Pen — finish path',\n        eligible: { capability: 'creates-paths' },\n        requires: ['editAnchors', 'insert', 'selection'],\n        enabled: () => (anchorCount(s()) > 0 ? true : ActionDisabledReason.NotApplicable),\n        invoker: {\n          timing: 'immediate' as const,\n          run: (deps) => {\n            commit(s(), deps);\n            trail.refresh();\n          },\n        },\n      },\n\n      {\n        id: 'pen.cancel',\n        label: 'Pen — discard path',\n        eligible: { capability: 'creates-paths' },\n        // Declining with nothing drawn is what keeps Escape's first-match\n        // ladder intact: an empty pen passes the key to `escape`, which goes\n        // on to clear the selection / return to the default tool.\n        enabled: () => {\n          const scratch = s();\n          return scratch.current !== null || scratch.finishedSubpaths.length > 0\n            ? true\n            : ActionDisabledReason.NotApplicable;\n        },\n        invoker: {\n          timing: 'immediate' as const,\n          run: () => {\n            resetScratch(s());\n            trail.refresh();\n          },\n        },\n      },\n    ];\n  }, [commit, placeAt, withinCloseRadius, pickUpEndpoint, joinable, commitJoin, optsRef, trail, forceRender]);\n\n  return useMemo(() => {\n    return defineTool({\n      id: 'pen',\n      keybinding: { key: 'P' },\n      capabilities: ['creates-paths'],\n      hookName: 'usePenTool',\n      cursor: () =>\n        scratchRef.current?.closeHintActive\n          ? 'pointer'\n          : cursorFor('pen', { fallback: 'crosshair' }),\n      presentation: {\n        label: 'Pen',\n        icon: createElement(PenIcon),\n        group: 'draw',\n      },\n      actions,\n      overlay,\n      overlayPosition: 'before-selection',\n\n      onDeactivate: () => {\n        // Anything still in scratch is incomplete. Switching tools mid-path\n        // discards it, as Escape does, rather than committing a stub polyline.\n        resetScratch(scratchRef.current!);\n        trail.stop();\n      },\n\n      bindings: [\n        // Plain click places an anchor; ⌘/Ctrl-click open-finishes. Strict\n        // modifier matching keeps the two apart.\n        { spec: { kind: 'click' as const, mods: { shift: 'optional' as const, alt: 'optional' as const } }, actionId: 'pen.placeAnchor' },\n        { spec: { kind: 'click' as const, mods: { mod: true, shift: 'optional' as const, alt: 'optional' as const } }, actionId: 'pen.finishOpen' },\n        // Double-click on the last anchor also open-finishes.\n        {\n          spec: { kind: 'doubleClick' as const, mods: { shift: 'optional' as const, alt: 'optional' as const } },\n          actionId: 'pen.finishOpen',\n          opts: { params: { viaDoubleClick: true } },\n        },\n        { spec: { kind: 'drag' as const, mods: { shift: 'optional' as const, alt: 'optional' as const } }, actionId: 'pen.dragHandle' },\n        { spec: { kind: 'key' as const, key: 'Enter' }, actionId: 'pen.finish' },\n        { spec: { kind: 'key' as const, key: 'Escape' }, actionId: 'pen.cancel' },\n      ],\n    });\n  }, [actions, trail, overlay]);\n}\n\nusePenTool.prefs = {\n  name: 'Pen',\n  description: 'Pen-tool behavior.',\n  children: {\n    autoCommitOnClose: {\n      kind: 'boolean',\n      name: 'Auto-commit pen on close',\n      description: \"When you click the pen tool's first anchor to close a region, commit immediately so it renders with its fill. Off: keep the path in preview until you press Enter (lets you build a compound path from multiple closed subpaths).\",\n      default: true,\n    },\n  },\n} satisfies PrefGroup;\n\n/** Point the anchor's outgoing handle at `target`, optionally snapped and\n *  optionally constrained to 45° steps. When `linked` and not Alt-broken,\n *  the in-handle follows as its mirror through the anchor. */\nfunction applyOutHandle<S extends PenScratch>(\n  s: S,\n  target: { x: number; y: number },\n  shift: boolean,\n  linked: boolean,\n  snap?: (p: { x: number; y: number }) => { x: number; y: number },\n): void {\n  if (s.current === null || s.draggingHandleAt === null) return;\n  const anchor = s.current.anchors[s.draggingHandleAt];\n  const to = snap ? snap(target) : target;\n  let dx = to.x - anchor.x;\n  let dy = to.y - anchor.y;\n  if (shift) {\n    const c = constrainTo45(dx, dy);\n    dx = c.dx;\n    dy = c.dy;\n  }\n  anchor.outHandle = { x: anchor.x + dx, y: anchor.y + dy };\n  if (linked && !anchor.altBroken) anchor.inHandle = { x: anchor.x - dx, y: anchor.y - dy };\n}\n\nfunction viewScale(deps: ActionDeps): { x: number; y: number } {\n  return deps.view?.get().scale ?? { x: 1, y: 1 };\n}\n\n/** Existing editable paths, world coords, with ink within `px` screen\n *  pixels of `(wx, wy)` — front-to-back, as the area query returns them.\n *  Empty when the host publishes no `areaSelect` or `editAnchors` dep. */\nfunction pathsNear(\n  deps: ActionDeps,\n  wx: number,\n  wy: number,\n  px: number,\n): Array<{ id: string; path: PolygonPath }> {\n  const area = deps.areaSelect;\n  const edit = deps.editAnchors;\n  if (!area || !edit) return [];\n  const view = deps.view;\n  const e = pxExtent(px, viewScale(deps));\n  const ids = area.hitTestArea({ x: wx - e.x, y: wy - e.y, width: 2 * e.x, height: 2 * e.y }, view);\n  const out: Array<{ id: string; path: PolygonPath }> = [];\n  for (const id of ids) {\n    const path = edit.getEditablePath(id) as PolygonPath | null;\n    if (path?.kind === 'polygon') out.push({ id, path });\n  }\n  return out;\n}\n\nfunction samePath(a: PolygonPath, b: PolygonPath): boolean {\n  if (a.commands.length !== b.commands.length || a.coords.length !== b.coords.length) return false;\n  for (let i = 0; i < a.commands.length; i++) if (a.commands[i] !== b.commands[i]) return false;\n  for (let i = 0; i < a.coords.length; i++) if (a.coords[i] !== b.coords[i]) return false;\n  return true;\n}\n"],"mappings":"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"}

package/dist/tools/builtin/pencil/usePencilTool.js

@@ -9,6 +9,7 @@ function o(o = {}) {
 	let { behaviors: s } = o;
 	return r(() => e({
 		id: "pencil",
+		keybinding: { key: "N" },
 		capabilities: ["creates-paths"],
 		hookName: "usePencilTool",
 		cursor: a("pencil", { fallback: "crosshair" }),

package/dist/tools/builtin/pencil/usePencilTool.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePencilTool.js","names":["PencilIcon","usePencilTool","options","useMemo","defineTool","cursorFor","insertBindingBehaviors","behaviors"],"sources":["../../../../src/tools/builtin/pencil/usePencilTool.tsx"],"sourcesContent":["import { useMemo } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { PencilIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/** A single pointer sample captured during a freehand pencil stroke.\n *\n *  `pressure` / `tiltX` / `tiltY` come straight from the underlying\n *  `PointerEvent` and let downstream consumers modulate stroke width or\n *  opacity by stylus input. Mouse and ordinary touch report\n *  `pressure: 0.5` while a button is held, `0` otherwise (per the Pointer\n *  Events spec), so a consumer that wants stylus-only modulation should\n *  gate on `pointerType` from the originating event — the kit exposes\n *  `usePointerStylus()` for that.\n *\n *  The dispatcher accumulates these on the drag trail and hands the whole\n *  array to `insertAction`, which forwards it as the `pencil` insert\n *  extras' `samples`. A consumer that wants pressure-driven\n *  `Stroke.vertexWidths` reads it off the samples in its own `insert` dep\n *  (`useDepSource('insert', …)`) — see `apps/site/demos/StrokeAndFillDemo.tsx`.\n */\nexport interface PencilPoint {\n  x: number;\n  y: number;\n  /** 0..1. Absent when the originating event carried no pressure. */\n  pressure?: number;\n  /** Degrees, ±90. Zero for mouse/touch. */\n  tiltX?: number;\n  /** Degrees, ±90. Zero for mouse/touch. */\n  tiltY?: number;\n}\n\n/**\n * Freehand pencil tool. The `drag` binding routes to `insertAction`,\n * which accumulates the pointer trail and commits it as\n * `{ kind: 'pencil', samples }`. The kit's default `insert` dep runs\n * `schneiderFit` over the samples to produce a cubic-Bezier path.\n */\nexport function usePencilTool(options: InsertToolOptions = {}): Tool<null> {\n  const { behaviors } = options;\n  return useMemo(\n    () =>\n      defineTool<null>({\n        id: 'pencil',\n        capabilities: ['creates-paths'],\n        hookName: 'usePencilTool',\n        cursor: cursorFor('pencil', { fallback: 'crosshair' }),\n        presentation: {\n          label: 'Pencil',\n          group: 'draw',\n          icon: <PencilIcon />,\n        },\n        bindings: [\n          {\n            spec: { kind: 'drag', target: 'empty' },\n            actionId: 'insert',\n            opts: { params: { kind: 'pencil' } , ...insertBindingBehaviors(behaviors) },\n          },\n        ],\n      }),\n    [behaviors],\n  );\n}\n"],"mappings":";;;;;;;AAwCA,SAAgBC,EAAc,IAA6B,CAAC,GAAe;CACzE,IAAM,EAAE,iBAAcC;CACtB,OAAOC,QAEHC,EAAiB;EACf,IAAI;EACJ,cAAc,CAAC,eAAe;EAC9B,UAAU;EACV,QAAQC,EAAU,UAAU,EAAE,UAAU,YAAY,CAAC;EACrD,cAAc;GACZ,OAAO;GACP,OAAO;GACP,MAAM,kBAACL,GAAD,CAAa,CAAA;EACrB;EACA,UAAU,CACR;GACE,MAAM;IAAE,MAAM;IAAQ,QAAQ;GAAQ;GACtC,UAAU;GACV,MAAM;IAAE,QAAQ,EAAE,MAAM,SAAS;IAAI,GAAGM,EAAuBC,CAAS;GAAE;EAC5E,CACF;CACF,CAAC,GACH,CAACA,CAAS,CACZ;AACF"}
+{"version":3,"file":"usePencilTool.js","names":["PencilIcon","usePencilTool","options","useMemo","defineTool","cursorFor","insertBindingBehaviors","behaviors"],"sources":["../../../../src/tools/builtin/pencil/usePencilTool.tsx"],"sourcesContent":["import { useMemo } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { PencilIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/** A single pointer sample captured during a freehand pencil stroke.\n *\n *  `pressure` / `tiltX` / `tiltY` come straight from the underlying\n *  `PointerEvent`. Mouse and ordinary touch report `pressure: 0.5` while a\n *  button is held, `0` otherwise (per the Pointer Events spec), so a consumer\n *  that wants stylus-only modulation should gate on `pointerType` — the kit\n *  exposes `usePointerStylus()` for that.\n *\n *  The samples reach the `insert` dep as the `pencil` insert extras'\n *  `samples`; a consumer that wants pressure-driven `Stroke.vertexWidths`\n *  reads it off them in its own `insert` dep (`useDepSource('insert', …)`).\n */\nexport interface PencilPoint {\n  x: number;\n  y: number;\n  /** 0..1. Absent when the originating event carried no pressure. */\n  pressure?: number;\n  /** Degrees, ±90. Zero for mouse/touch. */\n  tiltX?: number;\n  /** Degrees, ±90. Zero for mouse/touch. */\n  tiltY?: number;\n}\n\n/**\n * Freehand pencil tool. The `drag` binding routes to `insertAction`,\n * which accumulates the pointer trail and commits it as\n * `{ kind: 'pencil', samples }`. The kit's default `insert` dep runs\n * `schneiderFit` over the samples to produce a cubic-Bezier path.\n */\nexport function usePencilTool(options: InsertToolOptions = {}): Tool {\n  const { behaviors } = options;\n  return useMemo(\n    () =>\n      defineTool({\n        id: 'pencil',\n        keybinding: { key: 'N' },\n        capabilities: ['creates-paths'],\n        hookName: 'usePencilTool',\n        cursor: cursorFor('pencil', { fallback: 'crosshair' }),\n        presentation: {\n          label: 'Pencil',\n          group: 'draw',\n          icon: <PencilIcon />,\n        },\n        bindings: [\n          {\n            spec: { kind: 'drag', target: 'empty' },\n            actionId: 'insert',\n            opts: { params: { kind: 'pencil' } , ...insertBindingBehaviors(behaviors) },\n          },\n        ],\n      }),\n    [behaviors],\n  );\n}\n"],"mappings":";;;;;;;AAoCA,SAAgBC,EAAc,IAA6B,CAAC,GAAS;CACnE,IAAM,EAAE,iBAAcC;CACtB,OAAOC,QAEHC,EAAW;EACT,IAAI;EACJ,YAAY,EAAE,KAAK,IAAI;EACvB,cAAc,CAAC,eAAe;EAC9B,UAAU;EACV,QAAQC,EAAU,UAAU,EAAE,UAAU,YAAY,CAAC;EACrD,cAAc;GACZ,OAAO;GACP,OAAO;GACP,MAAM,kBAACL,GAAD,CAAa,CAAA;EACrB;EACA,UAAU,CACR;GACE,MAAM;IAAE,MAAM;IAAQ,QAAQ;GAAQ;GACtC,UAAU;GACV,MAAM;IAAE,QAAQ,EAAE,MAAM,SAAS;IAAI,GAAGM,EAAuBC,CAAS;GAAE;EAC5E,CACF;CACF,CAAC,GACH,CAACA,CAAS,CACZ;AACF"}

package/dist/tools/builtin/pickTopMostHit.js.map

@@ -1 +1 @@
-{"version":3,"file":"pickTopMostHit.js","names":["pickTopMostHit","ids","candidates","getParent","adapter","set","dropped","id","p","depth","filtered","pickHighestZ","compareZ","best","i","getZIndex","bestZ","zOf","z"],"sources":["../../../src/tools/builtin/pickTopMostHit.ts"],"sourcesContent":["/**\n * Pick the topmost id from a body-hit list, using whatever signal the\n * adapter exposes.\n *\n * Why this exists: `pickEvery` returns every id whose body covers the pointer.\n * Naively taking `ids[0]` makes containers swallow clicks on their children\n * (the container's bounds also cover the hit point, and demo iteration\n * order tends to put parents before children). This helper resolves the\n * ambiguity in a way that's correct by default for the common parent/child\n * case, while remaining a no-op for the trivial single-hit case.\n *\n * Resolution rules (in order):\n *\n * 1. **Empty / single hit.** Return `null` / the lone id.\n * 2. **Parent/child collapse.** When `adapter.getParent` is present, drop\n *    any id in the hit set that is an ancestor of another id in the hit\n *    set. After the collapse, if exactly one id remains, return it.\n * 3. **Sibling z-order.** When the adapter exposes `compareZ` or `getZIndex`,\n *    the survivors of the collapse are ranked by it and the highest wins.\n *    This composes with step 2 rather than replacing it: a child still beats\n *    its own ancestor regardless of what z the two report.\n * 4. **Tiebreaker.** Return the LAST id in the (collapsed) array. Scenes\n *    walked forward (`renderOrder()`, `Object.keys`, `for of items`) come\n *    back bottom-first by convention, so \"last\" gives the topmost. A caller\n *    that z-sorts topmost-first and exposes neither z hook should resolve\n *    before calling — this helper doesn't try to detect that.\n */\nexport interface PickTopMostHitAdapter {\n  getParent?: (id: string) => string | null;\n  /** Paint depth of `id`; higher draws later, so higher wins a hit. Ids the\n   *  adapter doesn't know sort below every id it does. */\n  getZIndex?: (id: string) => number | null | undefined;\n  /** Full ordering, for scenes whose depth isn't a number (a path through a\n   *  tree, say). Negative when `a` paints below `b`. Takes precedence over\n   *  `getZIndex` when both are present. */\n  compareZ?: (a: string, b: string) => number;\n}\n\n/** Reduce a set of hit ids to the single one a click should act on: drop any\n *  id that is an ancestor of another in the set, then take the topmost of what\n *  remains. */\nexport function pickTopMostHit(\n  ids: readonly string[],\n  adapter: PickTopMostHitAdapter | undefined | null,\n): string | null {\n  if (ids.length === 0) return null;\n  if (ids.length === 1) return ids[0];\n\n  let candidates = ids;\n\n  const getParent = adapter?.getParent;\n  if (typeof getParent === 'function') {\n    const set = new Set(ids);\n    const dropped = new Set<string>();\n    for (const id of ids) {\n      let p: string | null = getParent(id);\n      // Cap walk to avoid pathological cycles in malformed adapters.\n      let depth = 0;\n      while (p != null && depth++ < 10_000) {\n        if (set.has(p)) dropped.add(p);\n        p = getParent(p);\n      }\n    }\n    if (dropped.size > 0) {\n      const filtered = ids.filter((id) => !dropped.has(id));\n      // A pathological adapter (cyclic `getParent`) can drop everything;\n      // keep the original array rather than answering null.\n      if (filtered.length === 1) return filtered[0];\n      if (filtered.length > 1) candidates = filtered;\n    }\n  }\n\n  return pickHighestZ(candidates, adapter);\n}\n\n/** Highest-z survivor, or the last one when the adapter exposes no z signal.\n *  Scanning forward and taking strictly-greater makes the array's own order\n *  the tiebreaker, so equal-z ids resolve the same way as no-z ones. */\nfunction pickHighestZ(\n  ids: readonly string[],\n  adapter: PickTopMostHitAdapter | undefined | null,\n): string {\n  const compareZ = adapter?.compareZ;\n  if (typeof compareZ === 'function') {\n    let best = ids[0];\n    for (let i = 1; i < ids.length; i++) {\n      if (compareZ(ids[i], best) >= 0) best = ids[i];\n    }\n    return best;\n  }\n\n  const getZIndex = adapter?.getZIndex;\n  if (typeof getZIndex === 'function') {\n    let best = ids[0];\n    let bestZ = zOf(getZIndex, best);\n    for (let i = 1; i < ids.length; i++) {\n      const z = zOf(getZIndex, ids[i]);\n      if (z >= bestZ) { best = ids[i]; bestZ = z; }\n    }\n    return best;\n  }\n\n  return ids[ids.length - 1];\n}\n\nfunction zOf(getZIndex: (id: string) => number | null | undefined, id: string): number {\n  const z = getZIndex(id);\n  return typeof z === 'number' && Number.isFinite(z) ? z : -Infinity;\n}\n"],"mappings":";AAyCA,SAAgBA,EACd,GACA,GACe;CACf,IAAIC,EAAI,WAAW,GAAG,OAAO;CAC7B,IAAIA,EAAI,WAAW,GAAG,OAAOA,EAAI;CAEjC,IAAIC,IAAaD,GAEXE,IAAYC,GAAS;CAC3B,IAAI,OAAOD,KAAc,YAAY;EACnC,IAAME,IAAM,IAAI,IAAIJ,CAAG,GACjBK,oBAAU,IAAI,IAAY;EAChC,KAAK,IAAMC,KAAMN,GAAK;GACpB,IAAIO,IAAmBL,EAAUI,CAAE,GAE/BE,IAAQ;GACZ,OAAOD,KAAK,QAAQ,MAAU,MAE5B,AADIH,EAAI,IAAIG,CAAC,KAAGF,EAAQ,IAAIE,CAAC,GAC7B,IAAIL,EAAUK,CAAC;EAEnB;EACA,IAAIF,EAAQ,OAAO,GAAG;GACpB,IAAMI,IAAWT,EAAI,QAAQ,MAAO,CAACK,EAAQ,IAAIC,CAAE,CAAC;GAGpD,IAAIG,EAAS,WAAW,GAAG,OAAOA,EAAS;GAC3C,AAAIA,EAAS,SAAS,MAAG,IAAaA;EACxC;CACF;CAEA,OAAOC,EAAaT,GAAYE,CAAO;AACzC;AAKA,SAASO,EACP,GACA,GACQ;CACR,IAAMC,IAAWR,GAAS;CAC1B,IAAI,OAAOQ,KAAa,YAAY;EAClC,IAAIC,IAAOZ,EAAI;EACf,KAAK,IAAIa,IAAI,GAAGA,IAAIb,EAAI,QAAQ,KAC9B,AAAIW,EAASX,EAAIa,IAAID,CAAI,KAAK,MAAG,IAAOZ,EAAIa;EAE9C,OAAOD;CACT;CAEA,IAAME,IAAYX,GAAS;CAC3B,IAAI,OAAOW,KAAc,YAAY;EACnC,IAAIF,IAAOZ,EAAI,IACXe,IAAQC,EAAIF,GAAWF,CAAI;EAC/B,KAAK,IAAIC,IAAI,GAAGA,IAAIb,EAAI,QAAQ,KAAK;GACnC,IAAMiB,IAAID,EAAIF,GAAWd,EAAIa,EAAE;GAC/B,AAAII,KAAKF,MAAS,IAAOf,EAAIa,IAAI,IAAQI;EAC3C;EACA,OAAOL;CACT;CAEA,OAAOZ,EAAIA,EAAI,SAAS;AAC1B;AAEA,SAASgB,EAAI,GAAsD,GAAoB;CACrF,IAAMC,IAAIH,EAAUR,CAAE;CACtB,OAAO,OAAOW,KAAM,YAAY,OAAO,SAASA,CAAC,IAAIA,IAAI;AAC3D"}
+{"version":3,"file":"pickTopMostHit.js","names":["pickTopMostHit","ids","candidates","getParent","adapter","set","dropped","id","p","depth","filtered","pickHighestZ","compareZ","best","i","getZIndex","bestZ","zOf","z"],"sources":["../../../src/tools/builtin/pickTopMostHit.ts"],"sourcesContent":["/** The signals `pickTopMostHit` ranks a hit list by. All optional. */\nexport interface PickTopMostHitAdapter {\n  getParent?: (id: string) => string | null;\n  /** Paint depth of `id`; higher draws later, so higher wins a hit. Ids the\n   *  adapter doesn't know sort below every id it does. */\n  getZIndex?: (id: string) => number | null | undefined;\n  /** Full ordering, for scenes whose depth isn't a number (a path through a\n   *  tree, say). Negative when `a` paints below `b`. Takes precedence over\n   *  `getZIndex` when both are present. */\n  compareZ?: (a: string, b: string) => number;\n}\n\n/** Reduce a set of hit ids to the single one a click should act on: drop any\n *  id that is an ancestor of another in the set, then take the topmost of what\n *  remains. A child beats its own ancestor regardless of what z the two report.\n *\n *  With no z signal the LAST id wins: scenes walked forward come back\n *  bottom-first by convention. A caller that z-sorts topmost-first and exposes\n *  neither z hook should resolve before calling. */\nexport function pickTopMostHit(\n  ids: readonly string[],\n  adapter: PickTopMostHitAdapter | undefined | null,\n): string | null {\n  if (ids.length === 0) return null;\n  if (ids.length === 1) return ids[0];\n\n  let candidates = ids;\n\n  const getParent = adapter?.getParent;\n  if (typeof getParent === 'function') {\n    const set = new Set(ids);\n    const dropped = new Set<string>();\n    for (const id of ids) {\n      let p: string | null = getParent(id);\n      // Cap walk to avoid pathological cycles in malformed adapters.\n      let depth = 0;\n      while (p != null && depth++ < 10_000) {\n        if (set.has(p)) dropped.add(p);\n        p = getParent(p);\n      }\n    }\n    if (dropped.size > 0) {\n      const filtered = ids.filter((id) => !dropped.has(id));\n      // A pathological adapter (cyclic `getParent`) can drop everything;\n      // keep the original array rather than answering null.\n      if (filtered.length === 1) return filtered[0];\n      if (filtered.length > 1) candidates = filtered;\n    }\n  }\n\n  return pickHighestZ(candidates, adapter);\n}\n\n/** Highest-z survivor, or the last one when the adapter exposes no z signal.\n *  Scanning forward and taking strictly-greater makes the array's own order\n *  the tiebreaker, so equal-z ids resolve the same way as no-z ones. */\nfunction pickHighestZ(\n  ids: readonly string[],\n  adapter: PickTopMostHitAdapter | undefined | null,\n): string {\n  const compareZ = adapter?.compareZ;\n  if (typeof compareZ === 'function') {\n    let best = ids[0];\n    for (let i = 1; i < ids.length; i++) {\n      if (compareZ(ids[i], best) >= 0) best = ids[i];\n    }\n    return best;\n  }\n\n  const getZIndex = adapter?.getZIndex;\n  if (typeof getZIndex === 'function') {\n    let best = ids[0];\n    let bestZ = zOf(getZIndex, best);\n    for (let i = 1; i < ids.length; i++) {\n      const z = zOf(getZIndex, ids[i]);\n      if (z >= bestZ) { best = ids[i]; bestZ = z; }\n    }\n    return best;\n  }\n\n  return ids[ids.length - 1];\n}\n\nfunction zOf(getZIndex: (id: string) => number | null | undefined, id: string): number {\n  const z = getZIndex(id);\n  return typeof z === 'number' && Number.isFinite(z) ? z : -Infinity;\n}\n"],"mappings":";AAmBA,SAAgBA,EACd,GACA,GACe;CACf,IAAIC,EAAI,WAAW,GAAG,OAAO;CAC7B,IAAIA,EAAI,WAAW,GAAG,OAAOA,EAAI;CAEjC,IAAIC,IAAaD,GAEXE,IAAYC,GAAS;CAC3B,IAAI,OAAOD,KAAc,YAAY;EACnC,IAAME,IAAM,IAAI,IAAIJ,CAAG,GACjBK,oBAAU,IAAI,IAAY;EAChC,KAAK,IAAMC,KAAMN,GAAK;GACpB,IAAIO,IAAmBL,EAAUI,CAAE,GAE/BE,IAAQ;GACZ,OAAOD,KAAK,QAAQ,MAAU,MAE5B,AADIH,EAAI,IAAIG,CAAC,KAAGF,EAAQ,IAAIE,CAAC,GAC7B,IAAIL,EAAUK,CAAC;EAEnB;EACA,IAAIF,EAAQ,OAAO,GAAG;GACpB,IAAMI,IAAWT,EAAI,QAAQ,MAAO,CAACK,EAAQ,IAAIC,CAAE,CAAC;GAGpD,IAAIG,EAAS,WAAW,GAAG,OAAOA,EAAS;GAC3C,AAAIA,EAAS,SAAS,MAAG,IAAaA;EACxC;CACF;CAEA,OAAOC,EAAaT,GAAYE,CAAO;AACzC;AAKA,SAASO,EACP,GACA,GACQ;CACR,IAAMC,IAAWR,GAAS;CAC1B,IAAI,OAAOQ,KAAa,YAAY;EAClC,IAAIC,IAAOZ,EAAI;EACf,KAAK,IAAIa,IAAI,GAAGA,IAAIb,EAAI,QAAQ,KAC9B,AAAIW,EAASX,EAAIa,IAAID,CAAI,KAAK,MAAG,IAAOZ,EAAIa;EAE9C,OAAOD;CACT;CAEA,IAAME,IAAYX,GAAS;CAC3B,IAAI,OAAOW,KAAc,YAAY;EACnC,IAAIF,IAAOZ,EAAI,IACXe,IAAQC,EAAIF,GAAWF,CAAI;EAC/B,KAAK,IAAIC,IAAI,GAAGA,IAAIb,EAAI,QAAQ,KAAK;GACnC,IAAMiB,IAAID,EAAIF,GAAWd,EAAIa,EAAE;GAC/B,AAAII,KAAKF,MAAS,IAAOf,EAAIa,IAAI,IAAQI;EAC3C;EACA,OAAOL;CACT;CAEA,OAAOZ,EAAIA,EAAI,SAAS;AAC1B;AAEA,SAASgB,EAAI,GAAsD,GAAoB;CACrF,IAAMC,IAAIH,EAAUR,CAAE;CACtB,OAAO,OAAOW,KAAM,YAAY,OAAO,SAASA,CAAC,IAAIA,IAAI;AAC3D"}

package/dist/tools/builtin/polygon/usePolygonTool.js

@@ -7,25 +7,26 @@ import { cursorFor as c } from "@weasel-js/cursor";
 //#region src/tools/builtin/polygon/usePolygonTool.tsx
 var l = 3, u = 32;
 function d(d = {}) {
-	let { sides: f = 6, behaviors: p } = d, m = a(f), [, h] = o(0), g = r(() => h((e) => e + 1), []), _ = i(() => ({
+	let { sides: f = 6, label: p = "Polygon", behaviors: m } = d, h = a(f), [, g] = o(0), _ = r(() => g((e) => e + 1), []), v = i(() => ({
 		id: "polygon.adjustSides",
 		label: "Polygon — adjust sides",
 		invoker: {
 			timing: "immediate",
 			run: (e, t) => {
 				let n = t, r = n?.delta ?? (n?.deltaY !== void 0 && n.deltaY !== 0 ? n.deltaY > 0 ? 1 : -1 : 0);
-				r !== 0 && (m.current = r > 0 ? Math.min(u, m.current + 1) : Math.max(l, m.current - 1), g());
+				r !== 0 && (h.current = r > 0 ? Math.min(u, h.current + 1) : Math.max(l, h.current - 1), _());
 			}
 		}
-	}), [g]);
+	}), [_]);
 	return i(() => e({
 		id: "polygon",
+		keybinding: { key: "G" },
 		capabilities: ["creates-shapes"],
 		hookName: "usePolygonTool",
 		cursor: c("crosshairPolygon", { fallback: "crosshair" }),
-		actions: [_],
+		actions: [v],
 		presentation: {
-			label: "Polygon",
+			label: p,
 			group: "shape",
 			icon: /* @__PURE__ */ s(t, {})
 		},
@@ -36,9 +37,9 @@ function d(d = {}) {
 				opts: {
 					params: () => ({
 						kind: "polygon",
-						sides: m.current
+						sides: h.current
 					}),
-					...n(p)
+					...n(m)
 				}
 			},
 			{
@@ -73,7 +74,11 @@ function d(d = {}) {
 				opts: { params: { delta: -1 } }
 			}
 		]
-	}), [_, p]);
+	}), [
+		v,
+		m,
+		p
+	]);
 }
 //#endregion
 export { d as usePolygonTool };

package/dist/tools/builtin/polygon/usePolygonTool.js.map

@@ -1 +1 @@
-{"version":3,"file":"usePolygonTool.js","names":["PolygonIcon","MIN_SIDES","MAX_SIDES","usePolygonTool","initialSides","options","sidesRef","useRef","setSidesTick","useState","bumpSides","useCallback","n","adjustSidesAction","useMemo","p","params","step","defineTool","cursorFor","insertBindingBehaviors","behaviors"],"sources":["../../../../src/tools/builtin/polygon/usePolygonTool.tsx"],"sourcesContent":["import { useCallback, useMemo, useRef, useState } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { PolygonIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\nimport type { Action } from '@weasel-js/routing';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/** A point in world coordinates. */\nexport interface PolygonPoint { x: number; y: number }\n\n/** Options for `usePolygonTool`. */\nexport interface UsePolygonToolOptions extends InsertToolOptions {\n  label?: string;\n  /** Initial side count. Side count persists across gestures\n   *  (Illustrator convention) and is adjustable mid-drag via\n   *  ArrowUp/Down or wheel (range 3–32). */\n  sides?: number;\n}\n\nconst MIN_SIDES = 3;\nconst MAX_SIDES = 32;\n\n/**\n * Drag-from-center polygon tool. Pointerdown sets center; drag\n * determines radius + rotation; release commits via `insertAction` (the\n * kit's standard insert dep, sourced by `<SceneCanvas>`). Side count\n * defaults to 6, adjustable mid-gesture via ArrowUp/Down or wheel.\n *\n * The live preview is painted by the dispatcher overlay layer reading\n * `insertAction.overlay()` — the action returns `{ kind:'insertPreview',\n * shape:'polygon', bounds, extras: { sides, ... } }`. Consumers wanting\n * a custom polygon node shape override the `insert` dep.\n */\nexport function usePolygonTool<TNode extends { id: string } = { id: string }>(\n  options: UsePolygonToolOptions = {},\n): Tool<null> {\n  const { sides: initialSides = 6, behaviors } = options;\n  // Side count in a ref so keyDown / wheel mutations are visible\n  // synchronously to the insert binding's thunked params (re-resolved\n  // every frame for the live preview and at commit time). A useState\n  // tick alongside forces a render so the dispatcher overlay layer\n  // repaints when the count changes between pointer events.\n  const sidesRef = useRef(initialSides);\n  const [, setSidesTick] = useState(0);\n  const bumpSides = useCallback(() => setSidesTick((n) => n + 1), []);\n\n  // Wheel-to-adjust-sides action. Bound to `[engaged] wheel` so it only\n  // fires while a polygon insert drag is in flight — outside that window\n  // wheel falls through to ambient viewport.pan/zoom. The action's run\n  // body reads the dispatcher-injected wheel delta from params.\n  const adjustSidesAction = useMemo<Action>(\n    () => ({\n      id: 'polygon.adjustSides',\n      label: 'Polygon — adjust sides',\n      invoker: {\n        timing: 'immediate' as const,\n        run: (_deps, params) => {\n          const p = params as { deltaY?: number; delta?: number } | undefined;\n          // `delta` comes from the ArrowUp/ArrowDown key bindings; `deltaY`\n          // is the dispatcher-injected wheel delta. Wheel \"up\" (deltaY > 0\n          // under Mac natural scrolling / page-scrolls-up gesture) adds a\n          // side; wheel \"down\" removes one. Matches the user's mental model:\n          // scroll up = more.\n          const step = p?.delta ?? (p?.deltaY !== undefined && p.deltaY !== 0\n            ? (p.deltaY > 0 ? 1 : -1)\n            : 0);\n          if (step === 0) return;\n          sidesRef.current = step > 0\n            ? Math.min(MAX_SIDES, sidesRef.current + 1)\n            : Math.max(MIN_SIDES, sidesRef.current - 1);\n          bumpSides();\n        },\n      },\n    }),\n    [bumpSides],\n  );\n\n  // `TNode` is retained for source-compat with callers that previously\n  // threaded a node-record type through; the tool no longer mints nodes\n  // (insertAction does), so the parameter has no runtime effect.\n  void ({} as TNode);\n\n  return useMemo(\n    () =>\n      defineTool<null>({\n        id: 'polygon',\n        capabilities: ['creates-shapes'],\n        hookName: 'usePolygonTool',\n        cursor: cursorFor('crosshairPolygon', { fallback: 'crosshair' }),\n        // Registered by <ToolActionsMounter>, inside the ActionsProvider —\n        // see `ToolDef.actions` for why the hook can't register it itself.\n        actions: [adjustSidesAction],\n        presentation: {\n          label: 'Polygon',\n          group: 'shape',\n          icon: <PolygonIcon />,\n        },\n        bindings: [\n          // Default = drag from corner, consistent with rect/ellipse.\n          // The dispatcher overlay paints an anchorPoint dot at the\n          // click so the radial shape reads as anchored even though no\n          // polygon vertex sits at the AABB corner. Alt held flips to\n          // center mode (insertAction reads live modifier state).\n          {\n            spec: { kind: 'drag' },\n            actionId: 'insert',\n            // Thunked params re-evaluated at commit time (and on every\n            // overlay() call for live preview) so mid-gesture\n            // ArrowUp/Down/wheel side-count changes flow through both\n            // the ghost and the committed geometry.\n            opts: {\n              params: () => ({\n                kind: 'polygon',\n                sides: sidesRef.current,\n              }),\n              ...insertBindingBehaviors(behaviors),\n            },\n          },\n          // Wheel-during-drag → adjust side count. Phase-gated to\n          // `engaged` so wheel while the tool is idle still falls\n          // through to ambient viewport.pan / viewport.zoom.\n          {\n            spec: { kind: 'wheel', phase: 'engaged' },\n            actionId: 'polygon.adjustSides',\n          },\n          // Shift+wheel during engaged drag → rotate the in-flight\n          // shape in place. Strict modifier matching means this\n          // doesn't conflict with the unmodified wheel binding above.\n          {\n            spec: { kind: 'wheel', phase: 'engaged', mods: { shift: true } },\n            actionId: 'insert.adjustRotation',\n          },\n          // ArrowUp/Down → adjust side count. These were phase-table\n          // `initial.keyDown` routes, which put them on the OTHER dispatch\n          // pipeline: the tool route claimed the key but its `claim()` never\n          // reached the DOM as preventDefault/stopPropagation, so `nudge.up`\n          // matched the same keypress on the interactions dispatcher and\n          // moved the selection at the same time (audit §4 — derived there,\n          // reproduced and now covered by a smoke test). As active-scope\n          // bindings they out-prioritize ambient `nudge.*` and the\n          // dispatcher's first-match-wins settles it.\n          {\n            spec: { kind: 'key', key: 'ArrowUp' },\n            actionId: 'polygon.adjustSides',\n            opts: { params: { delta: 1 } },\n          },\n          {\n            spec: { kind: 'key', key: 'ArrowDown' },\n            actionId: 'polygon.adjustSides',\n            opts: { params: { delta: -1 } },\n          },\n        ],\n      }),\n    [adjustSidesAction, behaviors],\n  );\n}\n"],"mappings":";;;;;;;AAoBA,IAAMC,IAAY,GACZC,IAAY;AAalB,SAAgBC,EACd,IAAiC,CAAC,GACtB;CACZ,IAAM,EAAE,OAAOC,IAAe,GAAG,iBAAcC,GAMzCC,IAAWC,EAAOH,CAAY,GAC9B,GAAGI,KAAgBC,EAAS,CAAC,GAC7BC,IAAYC,QAAkBH,GAAc,MAAMI,IAAI,CAAC,GAAG,CAAC,CAAC,GAM5DC,IAAoBC,SACjB;EACL,IAAI;EACJ,OAAO;EACP,SAAS;GACP,QAAQ;GACR,MAAM,GAAO,MAAW;IACtB,IAAMC,IAAIC,GAMJC,IAAOF,GAAG,UAAUA,GAAG,WAAW,KAAA,KAAaA,EAAE,WAAW,IAC7DA,EAAE,SAAS,IAAI,IAAI,KACpB;IACJ,AAAIE,MAAS,MACb,EAAS,UAAUA,IAAO,IACtB,KAAK,IAAIf,GAAWI,EAAS,UAAU,CAAC,IACxC,KAAK,IAAIL,GAAWK,EAAS,UAAU,CAAC,GAC5CI,EAAU;GACZ;EACF;CACF,IACA,CAACA,CAAS,CACZ;CAOA,OAAOI,QAEHI,EAAiB;EACf,IAAI;EACJ,cAAc,CAAC,gBAAgB;EAC/B,UAAU;EACV,QAAQC,EAAU,oBAAoB,EAAE,UAAU,YAAY,CAAC;EAG/D,SAAS,CAACN,CAAiB;EAC3B,cAAc;GACZ,OAAO;GACP,OAAO;GACP,MAAM,kBAACb,GAAD,CAAc,CAAA;EACtB;EACA,UAAU;GAMR;IACE,MAAM,EAAE,MAAM,OAAO;IACrB,UAAU;IAKV,MAAM;KACJ,eAAe;MACb,MAAM;MACN,OAAOM,EAAS;KAClB;KACA,GAAGc,EAAuBC,CAAS;IACrC;GACF;GAIA;IACE,MAAM;KAAE,MAAM;KAAS,OAAO;IAAU;IACxC,UAAU;GACZ;GAIA;IACE,MAAM;KAAE,MAAM;KAAS,OAAO;KAAW,MAAM,EAAE,OAAO,GAAK;IAAE;IAC/D,UAAU;GACZ;GAUA;IACE,MAAM;KAAE,MAAM;KAAO,KAAK;IAAU;IACpC,UAAU;IACV,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE;GAC/B;GACA;IACE,MAAM;KAAE,MAAM;KAAO,KAAK;IAAY;IACtC,UAAU;IACV,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,EAAE;GAChC;EACF;CACF,CAAC,GACH,CAACR,GAAmBQ,CAAS,CAC/B;AACF"}
+{"version":3,"file":"usePolygonTool.js","names":["PolygonIcon","MIN_SIDES","MAX_SIDES","usePolygonTool","initialSides","options","sidesRef","useRef","setSidesTick","useState","bumpSides","useCallback","n","adjustSidesAction","useMemo","p","params","step","defineTool","cursorFor","insertBindingBehaviors","behaviors","label"],"sources":["../../../../src/tools/builtin/polygon/usePolygonTool.tsx"],"sourcesContent":["import { useCallback, useMemo, useRef, useState } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { PolygonIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\nimport type { Action } from '@weasel-js/routing';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/** A point in world coordinates. */\nexport interface PolygonPoint { x: number; y: number }\n\n/** Options for `usePolygonTool`. */\nexport interface UsePolygonToolOptions extends InsertToolOptions {\n  label?: string;\n  /** Initial side count. Side count persists across gestures\n   *  (Illustrator convention) and is adjustable mid-drag via\n   *  ArrowUp/Down or wheel (range 3–32). */\n  sides?: number;\n}\n\nconst MIN_SIDES = 3;\nconst MAX_SIDES = 32;\n\n/**\n * Drag-from-center polygon tool. Pointerdown sets center; drag\n * determines radius + rotation; release commits via `insertAction` (the\n * kit's standard insert dep, sourced by `<SceneCanvas>`). Side count\n * defaults to 6, adjustable mid-gesture via ArrowUp/Down or wheel.\n *\n * The live preview is painted by the dispatcher overlay layer reading\n * `insertAction.overlay()` — the action returns `{ kind:'insertPreview',\n * shape:'polygon', bounds, extras: { sides, ... } }`. Consumers wanting\n * a custom polygon node shape override the `insert` dep.\n */\nexport function usePolygonTool<TNode extends { id: string } = { id: string }>(\n  options: UsePolygonToolOptions = {},\n): Tool {\n  const { sides: initialSides = 6, label = 'Polygon', behaviors } = options;\n  // Side count in a ref so keyDown / wheel mutations are visible\n  // synchronously to the insert binding's thunked params (re-resolved\n  // every frame for the live preview and at commit time). A useState\n  // tick alongside forces a render so the dispatcher overlay layer\n  // repaints when the count changes between pointer events.\n  const sidesRef = useRef(initialSides);\n  const [, setSidesTick] = useState(0);\n  const bumpSides = useCallback(() => setSidesTick((n) => n + 1), []);\n\n  // Wheel-to-adjust-sides action. Bound to `[engaged] wheel` so it only\n  // fires while a polygon insert drag is in flight — outside that window\n  // wheel falls through to ambient viewport.pan/zoom. The action's run\n  // body reads the dispatcher-injected wheel delta from params.\n  const adjustSidesAction = useMemo<Action>(\n    () => ({\n      id: 'polygon.adjustSides',\n      label: 'Polygon — adjust sides',\n      invoker: {\n        timing: 'immediate' as const,\n        run: (_deps, params) => {\n          const p = params as { deltaY?: number; delta?: number } | undefined;\n          // `delta` comes from the ArrowUp/ArrowDown key bindings; `deltaY`\n          // is the dispatcher-injected wheel delta. Wheel \"up\" (deltaY > 0\n          // under Mac natural scrolling / page-scrolls-up gesture) adds a\n          // side; wheel \"down\" removes one. Matches the user's mental model:\n          // scroll up = more.\n          const step = p?.delta ?? (p?.deltaY !== undefined && p.deltaY !== 0\n            ? (p.deltaY > 0 ? 1 : -1)\n            : 0);\n          if (step === 0) return;\n          sidesRef.current = step > 0\n            ? Math.min(MAX_SIDES, sidesRef.current + 1)\n            : Math.max(MIN_SIDES, sidesRef.current - 1);\n          bumpSides();\n        },\n      },\n    }),\n    [bumpSides],\n  );\n\n  // `TNode` is retained for source-compat with callers that previously\n  // threaded a node-record type through; the tool no longer mints nodes\n  // (insertAction does), so the parameter has no runtime effect.\n  void ({} as TNode);\n\n  return useMemo(\n    () =>\n      defineTool({\n        id: 'polygon',\n        keybinding: { key: 'G' },\n        capabilities: ['creates-shapes'],\n        hookName: 'usePolygonTool',\n        cursor: cursorFor('crosshairPolygon', { fallback: 'crosshair' }),\n        // Registered by <ToolActionsMounter>, inside the ActionsProvider —\n        // see `ToolDef.actions` for why the hook can't register it itself.\n        actions: [adjustSidesAction],\n        presentation: {\n          label,\n          group: 'shape',\n          icon: <PolygonIcon />,\n        },\n        bindings: [\n          // Default = drag from corner, consistent with rect/ellipse.\n          // The dispatcher overlay paints an anchorPoint dot at the\n          // click so the radial shape reads as anchored even though no\n          // polygon vertex sits at the AABB corner. Alt held flips to\n          // center mode (insertAction reads live modifier state).\n          {\n            spec: { kind: 'drag' },\n            actionId: 'insert',\n            // Thunked params re-evaluated at commit time (and on every\n            // overlay() call for live preview) so mid-gesture\n            // ArrowUp/Down/wheel side-count changes flow through both\n            // the ghost and the committed geometry.\n            opts: {\n              params: () => ({\n                kind: 'polygon',\n                sides: sidesRef.current,\n              }),\n              ...insertBindingBehaviors(behaviors),\n            },\n          },\n          // Wheel-during-drag → adjust side count. Phase-gated to\n          // `engaged` so wheel while the tool is idle still falls\n          // through to ambient viewport.pan / viewport.zoom.\n          {\n            spec: { kind: 'wheel', phase: 'engaged' },\n            actionId: 'polygon.adjustSides',\n          },\n          // Shift+wheel during engaged drag → rotate the in-flight\n          // shape in place. Strict modifier matching means this\n          // doesn't conflict with the unmodified wheel binding above.\n          {\n            spec: { kind: 'wheel', phase: 'engaged', mods: { shift: true } },\n            actionId: 'insert.adjustRotation',\n          },\n          // ArrowUp/Down → adjust side count. These were phase-table\n          // `initial.keyDown` routes, which put them on the OTHER dispatch\n          // pipeline: the tool route claimed the key but its `claim()` never\n          // reached the DOM as preventDefault/stopPropagation, so `nudge.up`\n          // matched the same keypress on the interactions dispatcher and\n          // moved the selection at the same time (audit §4 — derived there,\n          // reproduced and now covered by a smoke test). As active-scope\n          // bindings they out-prioritize ambient `nudge.*` and the\n          // dispatcher's first-match-wins settles it.\n          {\n            spec: { kind: 'key', key: 'ArrowUp' },\n            actionId: 'polygon.adjustSides',\n            opts: { params: { delta: 1 } },\n          },\n          {\n            spec: { kind: 'key', key: 'ArrowDown' },\n            actionId: 'polygon.adjustSides',\n            opts: { params: { delta: -1 } },\n          },\n        ],\n      }),\n    [adjustSidesAction, behaviors, label],\n  );\n}\n"],"mappings":";;;;;;;AAoBA,IAAMC,IAAY,GACZC,IAAY;AAalB,SAAgBC,EACd,IAAiC,CAAC,GAC5B;CACN,IAAM,EAAE,OAAOC,IAAe,GAAG,WAAQ,WAAW,iBAAcC,GAM5DC,IAAWC,EAAOH,CAAY,GAC9B,GAAGI,KAAgBC,EAAS,CAAC,GAC7BC,IAAYC,QAAkBH,GAAc,MAAMI,IAAI,CAAC,GAAG,CAAC,CAAC,GAM5DC,IAAoBC,SACjB;EACL,IAAI;EACJ,OAAO;EACP,SAAS;GACP,QAAQ;GACR,MAAM,GAAO,MAAW;IACtB,IAAMC,IAAIC,GAMJC,IAAOF,GAAG,UAAUA,GAAG,WAAW,KAAA,KAAaA,EAAE,WAAW,IAC7DA,EAAE,SAAS,IAAI,IAAI,KACpB;IACJ,AAAIE,MAAS,MACb,EAAS,UAAUA,IAAO,IACtB,KAAK,IAAIf,GAAWI,EAAS,UAAU,CAAC,IACxC,KAAK,IAAIL,GAAWK,EAAS,UAAU,CAAC,GAC5CI,EAAU;GACZ;EACF;CACF,IACA,CAACA,CAAS,CACZ;CAOA,OAAOI,QAEHI,EAAW;EACT,IAAI;EACJ,YAAY,EAAE,KAAK,IAAI;EACvB,cAAc,CAAC,gBAAgB;EAC/B,UAAU;EACV,QAAQC,EAAU,oBAAoB,EAAE,UAAU,YAAY,CAAC;EAG/D,SAAS,CAACN,CAAiB;EAC3B,cAAc;GACZ;GACA,OAAO;GACP,MAAM,kBAACb,GAAD,CAAc,CAAA;EACtB;EACA,UAAU;GAMR;IACE,MAAM,EAAE,MAAM,OAAO;IACrB,UAAU;IAKV,MAAM;KACJ,eAAe;MACb,MAAM;MACN,OAAOM,EAAS;KAClB;KACA,GAAGc,EAAuBC,CAAS;IACrC;GACF;GAIA;IACE,MAAM;KAAE,MAAM;KAAS,OAAO;IAAU;IACxC,UAAU;GACZ;GAIA;IACE,MAAM;KAAE,MAAM;KAAS,OAAO;KAAW,MAAM,EAAE,OAAO,GAAK;IAAE;IAC/D,UAAU;GACZ;GAUA;IACE,MAAM;KAAE,MAAM;KAAO,KAAK;IAAU;IACpC,UAAU;IACV,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE;GAC/B;GACA;IACE,MAAM;KAAE,MAAM;KAAO,KAAK;IAAY;IACtC,UAAU;IACV,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,EAAE;GAChC;EACF;CACF,CAAC,GACH;EAACR;EAAmBQ;EAAWC;CAAK,CACtC;AACF"}

package/dist/tools/builtin/rect/useRectTool.js

@@ -8,6 +8,7 @@ function o(o = {}) {
 	let { behaviors: s } = o;
 	return i(() => e({
 		id: "rect",
+		keybinding: { key: "R" },
 		capabilities: ["creates-shapes"],
 		hookName: "useRectTool",
 		cursor: a("crosshairRect", { fallback: "crosshair" }),

package/dist/tools/builtin/rect/useRectTool.js.map

@@ -1 +1 @@
-{"version":3,"file":"useRectTool.js","names":["RectIcon","useRectTool","options","useMemo","defineTool","cursorFor","createElement","insertBindingBehaviors","behaviors"],"sources":["../../../../src/tools/builtin/rect/useRectTool.ts"],"sourcesContent":["import { useMemo, createElement } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { RectIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/**\n * Drag-to-draw rectangle tool.\n *\n * The gesture is owned end-to-end by the dispatcher: the `drag` binding\n * routes to `insertAction`, which tracks the live bounds, paints the\n * preview through its `overlay()` surface, and commits via the `insert`\n * dep on release. `<SceneCanvas>` sources that dep from\n * `useInsertDepSource`; consumers wanting a custom node factory override\n * the dep (`useDepSource('insert', …)`) rather than the tool.\n *\n * Grid snapping comes from the `snap` dep, also read by `insertAction` —\n * see `SnapDep` in `interactions/actions/depSchema.ts`.\n */\nexport function useRectTool(options: InsertToolOptions = {}): Tool<null> {\n  const { behaviors } = options;\n  return useMemo(\n    () =>\n      defineTool<null>({\n        id: 'rect',\n        capabilities: ['creates-shapes'],\n        hookName: 'useRectTool',\n        cursor: cursorFor('crosshairRect', { fallback: 'crosshair' }),\n        presentation: {\n          label: 'Rectangle',\n          icon: createElement(RectIcon),\n          group: 'shape',\n        },\n        // Single binding; insertAction toggles corner ⇄ center based on\n        // live Alt state so users can engage/disengage Alt mid-drag and\n        // see the bounds snap between the two modes.\n        bindings: [\n          {\n            spec: { kind: 'drag' },\n            actionId: 'insert',\n            opts: { params: { kind: 'rect' } , ...insertBindingBehaviors(behaviors) },\n          },\n        ],\n      }),\n    [behaviors],\n  );\n}\n"],"mappings":";;;;;;AAoBA,SAAgBC,EAAY,IAA6B,CAAC,GAAe;CACvE,IAAM,EAAE,iBAAcC;CACtB,OAAOC,QAEHC,EAAiB;EACf,IAAI;EACJ,cAAc,CAAC,gBAAgB;EAC/B,UAAU;EACV,QAAQC,EAAU,iBAAiB,EAAE,UAAU,YAAY,CAAC;EAC5D,cAAc;GACZ,OAAO;GACP,MAAMC,EAAcN,CAAQ;GAC5B,OAAO;EACT;EAIA,UAAU,CACR;GACE,MAAM,EAAE,MAAM,OAAO;GACrB,UAAU;GACV,MAAM;IAAE,QAAQ,EAAE,MAAM,OAAO;IAAI,GAAGO,EAAuBC,CAAS;GAAE;EAC1E,CACF;CACF,CAAC,GACH,CAACA,CAAS,CACZ;AACF"}
+{"version":3,"file":"useRectTool.js","names":["RectIcon","useRectTool","options","useMemo","defineTool","cursorFor","createElement","insertBindingBehaviors","behaviors"],"sources":["../../../../src/tools/builtin/rect/useRectTool.ts"],"sourcesContent":["import { useMemo, createElement } from 'react';\nimport { defineTool } from '../../overlayBinding';\nimport { RectIcon } from '../../../icons';\nimport type { Tool } from '../../overlayBinding';\nimport { insertBindingBehaviors, type InsertToolOptions } from '../shared/insertToolOptions';\nimport { cursorFor } from '@weasel-js/cursor';\n\n/**\n * Drag-to-draw rectangle tool.\n *\n * The `drag` binding routes to `insertAction`, which owns the live preview\n * and commits via the `insert` dep on release. Consumers wanting a custom\n * node factory override the dep (`useDepSource('insert', …)`) rather than\n * the tool. Grid snapping comes from the `snap` dep.\n */\nexport function useRectTool(options: InsertToolOptions = {}): Tool {\n  const { behaviors } = options;\n  return useMemo(\n    () =>\n      defineTool({\n        id: 'rect',\n        keybinding: { key: 'R' },\n        capabilities: ['creates-shapes'],\n        hookName: 'useRectTool',\n        cursor: cursorFor('crosshairRect', { fallback: 'crosshair' }),\n        presentation: {\n          label: 'Rectangle',\n          icon: createElement(RectIcon),\n          group: 'shape',\n        },\n        // Single binding: insertAction toggles corner ⇄ center on live Alt\n        // state, so Alt can be engaged mid-drag.\n        bindings: [\n          {\n            spec: { kind: 'drag' },\n            actionId: 'insert',\n            opts: { params: { kind: 'rect' } , ...insertBindingBehaviors(behaviors) },\n          },\n        ],\n      }),\n    [behaviors],\n  );\n}\n"],"mappings":";;;;;;AAeA,SAAgBC,EAAY,IAA6B,CAAC,GAAS;CACjE,IAAM,EAAE,iBAAcC;CACtB,OAAOC,QAEHC,EAAW;EACT,IAAI;EACJ,YAAY,EAAE,KAAK,IAAI;EACvB,cAAc,CAAC,gBAAgB;EAC/B,UAAU;EACV,QAAQC,EAAU,iBAAiB,EAAE,UAAU,YAAY,CAAC;EAC5D,cAAc;GACZ,OAAO;GACP,MAAMC,EAAcN,CAAQ;GAC5B,OAAO;EACT;EAGA,UAAU,CACR;GACE,MAAM,EAAE,MAAM,OAAO;GACrB,UAAU;GACV,MAAM;IAAE,QAAQ,EAAE,MAAM,OAAO;IAAI,GAAGO,EAAuBC,CAAS;GAAE;EAC1E,CACF;CACF,CAAC,GACH,CAACA,CAAS,CACZ;AACF"}

package/dist/tools/builtin/select/adapterPointQuery.js

@@ -0,0 +1,36 @@
+import { toPlane as e } from "../../../core/viewport/parallax.js";
+import { poseDescriptorForNode as t } from "../../../core/geometry/poseDescriptor.js";
+import { shapeCoversPoint as n } from "../../../canvas/NodeShape.js";
+import { ownClipOf as r } from "../../../canvas/pickWalk.js";
+import { boundsOfPath as i, meanScale as a, pathContainsPoint as o } from "@weasel-js/geom";
+//#region src/tools/builtin/select/adapterPointQuery.ts
+function s(s, c) {
+	let l = (u, d, f) => ({
+		hits: (e, a, l) => {
+			let p = l ? i(l) : t(s, e).getBounds(a);
+			if (e.kind !== "container") {
+				let t = c || l ? f : 0;
+				return u >= p.x - t && u <= p.x + p.width + t && d >= p.y - t && d <= p.y + p.height + t ? !c || n(e, a, u, d, {
+					tolerance: f,
+					derivedPath: l
+				}) : !1;
+			}
+			if (!(u >= p.x && u <= p.x + p.width && d >= p.y && d <= p.y + p.height)) return !1;
+			let m = r(e, a, l);
+			return m === null || o(m, u, d);
+		},
+		clipAdmits: (e) => o(e, u, d),
+		inPlane: (t) => {
+			let n = e(t, {
+				x: u,
+				y: d
+			});
+			return l(n.x, n.y, f * a(t.scale));
+		}
+	});
+	return l;
+}
+//#endregion
+export { s as adapterPointQuery };
+
+//# sourceMappingURL=adapterPointQuery.js.map

package/dist/tools/builtin/select/adapterPointQuery.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapterPointQuery.js","names":["adapterPointQuery","pointQuery","b","derived","boundsOfPath","poseDescriptorForNode","d","node","pose","slop","preciseLeaves","t","px","py","shapeCoversPoint","own","ownClipOf","pathContainsPoint","clip","p","toPlane","m","meanScale"],"sources":["../../../../src/tools/builtin/select/adapterPointQuery.ts"],"sourcesContent":["import { boundsOfPath, meanScale, pathContainsPoint } from '@weasel-js/geom';\nimport { shapeCoversPoint } from 'canvas/NodeShape';\nimport { ownClipOf, type PickQuery } from 'canvas/pickWalk';\nimport { poseDescriptorForNode, type PoseDescriptor } from 'core/geometry/poseDescriptor';\nimport type { Node } from 'core/scene/types';\nimport { toPlane } from 'core/viewport/parallax';\n\n/**\n * The point query `useSelectTool`'s default `pickEvery` asks of a bare adapter:\n * a point at (px, py) with `t` world units of slop. AABB first (cheap), then\n * the painter's ink when `preciseLeaves` asks for it and it is available. A\n * painter with no `silhouette` — or one that returns null, as `kit:text` does\n * for an empty node — keeps the AABB answer.\n *\n * The AABB pre-filter is grown by the slop: a shape's outline, and the slop\n * around it, reach outside the shape's own bounds.\n *\n * A node that derives its path is tested against that path's box: its own pose\n * is a placeholder, and the box of a straight route has no area to land in\n * without the slop.\n */\nexport function adapterPointQuery<TPose>(\n  d: PoseDescriptor<TPose>,\n  preciseLeaves: boolean,\n): (px: number, py: number, t: number) => PickQuery<TPose> {\n  const pointQuery = (px: number, py: number, t: number): PickQuery<TPose> => ({\n    hits: (node, pose, derived) => {\n      const b = derived ? boundsOfPath(derived) : poseDescriptorForNode(d, node).getBounds(pose);\n      if (node.kind !== 'container') {\n        const slop = preciseLeaves || derived ? t : 0;\n        if (!(px >= b.x - slop && px <= b.x + b.width + slop\n              && py >= b.y - slop && py <= b.y + b.height + slop)) {\n          return false;\n        }\n        if (!preciseLeaves) return true;\n        return shapeCoversPoint(\n          node as Node<unknown, string, TPose>, pose, px, py, { tolerance: t, derivedPath: derived },\n        );\n      }\n      // A container's own clip *is* its hit shape — it is picked where it\n      // paints, and it paints only inside its clip. Ancestor clips are the\n      // walk's business; this one is not.\n      const inAabb = px >= b.x && px <= b.x + b.width\n        && py >= b.y && py <= b.y + b.height;\n      if (!inAabb) return false;\n      const own = ownClipOf(node, pose, derived);\n      return own === null || pathContainsPoint(own, px, py);\n    },\n    clipAdmits: (clip) => pathContainsPoint(clip, px, py),\n    inPlane: (m) => {\n      const p = toPlane(m, { x: px, y: py });\n      return pointQuery(p.x, p.y, t * meanScale(m.scale));\n    },\n  });\n  return pointQuery;\n}\n"],"mappings":";;;;;;AAqBA,SAAgBA,EACd,GACA,GACyD;CACzD,IAAMC,KAAc,GAAY,GAAY,OAAiC;EAC3E,OAAO,GAAM,GAAM,MAAY;GAC7B,IAAMC,IAAIC,IAAUC,EAAaD,CAAO,IAAIE,EAAsBC,GAAGC,CAAI,CAAC,CAAC,UAAUC,CAAI;GACzF,IAAID,EAAK,SAAS,aAAa;IAC7B,IAAME,IAAOC,KAAiBP,IAAUQ,IAAI;IAM5C,OALMC,KAAMV,EAAE,IAAIO,KAAQG,KAAMV,EAAE,IAAIA,EAAE,QAAQO,KACvCI,KAAMX,EAAE,IAAIO,KAAQI,KAAMX,EAAE,IAAIA,EAAE,SAASO,IAGpD,CAAKC,KACEI,EACLP,GAAsCC,GAAMI,GAAIC,GAAI;KAAE,WAAWF;KAAG,aAAaR;IAAQ,CAC3F,IALS;GAMX;GAMA,IAAI,EAFWS,KAAMV,EAAE,KAAKU,KAAMV,EAAE,IAAIA,EAAE,SACrCW,KAAMX,EAAE,KAAKW,KAAMX,EAAE,IAAIA,EAAE,SACnB,OAAO;GACpB,IAAMa,IAAMC,EAAUT,GAAMC,GAAML,CAAO;GACzC,OAAOY,MAAQ,QAAQE,EAAkBF,GAAKH,GAAIC,CAAE;EACtD;EACA,aAAa,MAASI,EAAkBC,GAAMN,GAAIC,CAAE;EACpD,UAAU,MAAM;GACd,IAAMM,IAAIC,EAAQC,GAAG;IAAE,GAAGT;IAAI,GAAGC;GAAG,CAAC;GACrC,OAAOZ,EAAWkB,EAAE,GAAGA,EAAE,GAAGR,IAAIW,EAAUD,EAAE,KAAK,CAAC;EACpD;CACF;CACA,OAAOpB;AACT"}

package/dist/tools/builtin/select/selectionContributions.js

@@ -1,8 +1,9 @@
 import { gestureLifecycleParams as e } from "../../../interactions/actions/gestureLifecycle.js";
 import { isAnchorOrControl as t, isResizeHandle as n, isRotateHandle as r } from "@weasel-js/routing";
+import { hitPredicate as i } from "@weasel-js/gestures";
 //#region src/tools/builtin/select/selectionContributions.ts
-var i = "selection.move", a = "selection.transform", o = "selection.resize", s = "selection.rotate";
-function c(n = {}) {
+var a = "selection.move", o = "selection.transform", s = "selection.resize", c = "selection.rotate";
+function l(n = {}) {
 	let r = (() => {
 		let t = n.move ?? {}, r = e({
 			...t,
@@ -35,7 +36,7 @@ function c(n = {}) {
 		{
 			spec: {
 				kind: "drag",
-				target: { kindOf: (e, n) => n === "selected-body" && !t(e) }
+				target: { kindOf: i((e, n) => n === "selected-body" && !t(e)) }
 			},
 			actionId: "move",
 			...r
@@ -50,7 +51,7 @@ function c(n = {}) {
 		}
 	];
 }
-function l() {
+function u() {
 	return [{
 		spec: {
 			kind: "drag",
@@ -59,7 +60,7 @@ function l() {
 		actionId: "resize"
 	}];
 }
-function u(t = {}) {
+function d(t = {}) {
 	let n = t.rotate ?? {}, i = e({
 		...n,
 		label: n.rotateLabel
@@ -67,7 +68,7 @@ function u(t = {}) {
 	n.pivot && (i.pivot = n.pivot);
 	let a = {
 		...Object.keys(i).length > 0 ? { params: i } : {},
-		...n.behaviors?.length ? { behaviors: n.behaviors } : {}
+		...n.behaviors === void 0 ? {} : { behaviors: n.behaviors }
 	};
 	return [{
 		spec: {
@@ -78,52 +79,52 @@ function u(t = {}) {
 		...Object.keys(a).length > 0 ? { opts: a } : {}
 	}];
 }
-function d(e = {}) {
-	return [...l(), ...u(e)];
-}
 function f(e = {}) {
-	return {
-		id: i,
-		eligibility: { always: !0 },
-		bindings: c(e)
-	};
+	return [...u(), ...d(e)];
 }
 function p(e = {}) {
 	return {
 		id: a,
 		eligibility: { always: !0 },
-		bindings: d(e)
+		bindings: l(e)
 	};
 }
-function m() {
+function m(e = {}) {
 	return {
 		id: o,
 		eligibility: { always: !0 },
-		bindings: l()
+		bindings: f(e)
 	};
 }
-function h(e = {}) {
+function h() {
 	return {
 		id: s,
 		eligibility: { always: !0 },
-		bindings: u(e)
+		bindings: u()
+	};
+}
+function g(e = {}) {
+	return {
+		id: c,
+		eligibility: { always: !0 },
+		bindings: d(e)
 	};
 }
-var g = "selection.areaSelect", _ = (e, t) => e == null && t === "empty";
-function v() {
+var _ = "selection.areaSelect", v = i((e, t) => e == null && t === "empty"), y = i((e, t) => e == null && t !== "empty");
+function b() {
 	return {
-		id: g,
+		id: _,
 		eligibility: { always: !0 },
 		bindings: [{
 			spec: {
 				kind: "drag",
-				target: { kindOf: _ }
+				target: { kindOf: v }
 			},
 			actionId: "areaSelect"
 		}]
 	};
 }
 //#endregion
-export { g as AREA_SELECT_ID, i as SELECTION_MOVE_ID, o as SELECTION_RESIZE_ID, s as SELECTION_ROTATE_ID, a as SELECTION_TRANSFORM_ID, v as areaSelectContribution, _ as onEmptyCanvas, c as selectionMoveBindings, f as selectionMoveContribution, l as selectionResizeBindings, m as selectionResizeContribution, u as selectionRotateBindings, h as selectionRotateContribution, d as selectionTransformBindings, p as selectionTransformContribution };
+export { _ as AREA_SELECT_ID, a as SELECTION_MOVE_ID, s as SELECTION_RESIZE_ID, c as SELECTION_ROTATE_ID, o as SELECTION_TRANSFORM_ID, b as areaSelectContribution, y as onBody, v as onEmptyCanvas, l as selectionMoveBindings, p as selectionMoveContribution, u as selectionResizeBindings, h as selectionResizeContribution, d as selectionRotateBindings, g as selectionRotateContribution, f as selectionTransformBindings, m as selectionTransformContribution };
 
 //# sourceMappingURL=selectionContributions.js.map