@weasel-js/core 1.9.4 → 1.10.1

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","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, 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 } from 'core/viewport/pxExtent';\nimport { PenIcon } from '../../../icons';\nimport { boundsOfPath, 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 { 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 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`: 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   *  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, 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<PenScratch> {\n  const { 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({ 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, 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: 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) 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: 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 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`.\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', '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, 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              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            // 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.\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). 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            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 — 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            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 (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                  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]);\n\n  return useMemo(() => {\n    return defineTool<PenScratch>({\n      id: 'pen',\n      keybinding: { key: 'P' },\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        trail.stop();\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, trail]);\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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"}
+{"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","next","editAnchorSetTracked","set","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, editAnchorSetTracked, 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 next = editAnchorSetTracked(cont.original, (set) => {\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      })!;\n      if (samePath(next.path, cont.original)) return;\n      edit.applyEdit(cont.id, next.path, 'Continue path', next.origins);\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 next = editAnchorSetTracked(cont.original, (set) => {\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) return;\n        set.anchors.splice(hit.sub, 1);\n        set.closed.splice(hit.sub, 1);\n      })!;\n      ops.push(...edit.editOps!(cont.id, next.path, label, next.origins));\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; // eslint-disable-line react-hooks/immutability -- the trail's own camera, read by `track`\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.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        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":";;;;;;;AAwCA,SAAgBC,EAAc,IAA6B,CAAC,GAAe;CACzE,IAAM,EAAE,iBAAcC;CACtB,OAAOC,QAEHC,EAAiB;EACf,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"}
+{"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

@@ -2,29 +2,26 @@
 function e(e, n) {
 	if (e.length === 0) return null;
 	if (e.length === 1) return e[0];
-	let r = e, i = n?.getParent;
-	if (typeof i == "function") {
-		let t = new Set(e), n = /* @__PURE__ */ new Set();
-		for (let r of e) {
-			let e = i(r), a = 0;
-			for (; e != null && a++ < 1e4;) t.has(e) && n.add(e), e = i(e);
-		}
-		if (n.size > 0) {
-			let t = e.filter((e) => !n.has(e));
-			if (t.length === 1) return t[0];
-			t.length > 1 && (r = t);
-		}
+	let r = e, i = new Set(e), a = /* @__PURE__ */ new Set();
+	for (let t of e) {
+		let e = n.getParent(t), r = 0;
+		for (; e != null && r++ < 1e4;) i.has(e) && a.add(e), e = n.getParent(e);
+	}
+	if (a.size > 0) {
+		let t = e.filter((e) => !a.has(e));
+		if (t.length === 1) return t[0];
+		t.length > 1 && (r = t);
 	}
 	return t(r, n);
 }
 function t(e, t) {
-	let r = t?.compareZ;
+	let r = t.compareZ;
 	if (typeof r == "function") {
 		let t = e[0];
 		for (let n = 1; n < e.length; n++) r(e[n], t) >= 0 && (t = e[n]);
 		return t;
 	}
-	let i = t?.getZIndex;
+	let i = t.getZIndex;
 	if (typeof i == "function") {
 		let t = e[0], r = n(i, t);
 		for (let a = 1; a < e.length; a++) {

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","set","dropped","id","p","adapter","depth","filtered","pickHighestZ","compareZ","best","i","getZIndex","bestZ","zOf","z"],"sources":["../../../src/tools/builtin/pickTopMostHit.ts"],"sourcesContent":["/** What `pickTopMostHit` ranks a hit list by: the tree, and a z signal where\n *  the adapter has one. */\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,\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 set = new Set(ids);\n  const dropped = new Set<string>();\n  for (const id of ids) {\n    let p: string | null = adapter.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 = adapter.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  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,\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":";AAoBA,SAAgBA,EACd,GACA,GACe;CACf,IAAIC,EAAI,WAAW,GAAG,OAAO;CAC7B,IAAIA,EAAI,WAAW,GAAG,OAAOA,EAAI;CAEjC,IAAIC,IAAaD,GAEXE,IAAM,IAAI,IAAIF,CAAG,GACjBG,oBAAU,IAAI,IAAY;CAChC,KAAK,IAAMC,KAAMJ,GAAK;EACpB,IAAIK,IAAmBC,EAAQ,UAAUF,CAAE,GAEvCG,IAAQ;EACZ,OAAOF,KAAK,QAAQ,MAAU,MAE5B,AADIH,EAAI,IAAIG,CAAC,KAAGF,EAAQ,IAAIE,CAAC,GAC7B,IAAIC,EAAQ,UAAUD,CAAC;CAE3B;CACA,IAAIF,EAAQ,OAAO,GAAG;EACpB,IAAMK,IAAWR,EAAI,QAAQ,MAAO,CAACG,EAAQ,IAAIC,CAAE,CAAC;EAGpD,IAAII,EAAS,WAAW,GAAG,OAAOA,EAAS;EAC3C,AAAIA,EAAS,SAAS,MAAG,IAAaA;CACxC;CAEA,OAAOC,EAAaR,GAAYK,CAAO;AACzC;AAKA,SAASG,EACP,GACA,GACQ;CACR,IAAMC,IAAWJ,EAAQ;CACzB,IAAI,OAAOI,KAAa,YAAY;EAClC,IAAIC,IAAOX,EAAI;EACf,KAAK,IAAIY,IAAI,GAAGA,IAAIZ,EAAI,QAAQ,KAC9B,AAAIU,EAASV,EAAIY,IAAID,CAAI,KAAK,MAAG,IAAOX,EAAIY;EAE9C,OAAOD;CACT;CAEA,IAAME,IAAYP,EAAQ;CAC1B,IAAI,OAAOO,KAAc,YAAY;EACnC,IAAIF,IAAOX,EAAI,IACXc,IAAQC,EAAIF,GAAWF,CAAI;EAC/B,KAAK,IAAIC,IAAI,GAAGA,IAAIZ,EAAI,QAAQ,KAAK;GACnC,IAAMgB,IAAID,EAAIF,GAAWb,EAAIY,EAAE;GAC/B,AAAII,KAAKF,MAAS,IAAOd,EAAIY,IAAI,IAAQI;EAC3C;EACA,OAAOL;CACT;CAEA,OAAOX,EAAIA,EAAI,SAAS;AAC1B;AAEA,SAASe,EAAI,GAAsD,GAAoB;CACrF,IAAMC,IAAIH,EAAUT,CAAE;CACtB,OAAO,OAAOY,KAAM,YAAY,OAAO,SAASA,CAAC,IAAIA,IAAI;AAC3D"}

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

@@ -1,34 +1,35 @@
-import { defineTool as e } from "../../overlayBinding.js";
-import t from "../../../icons/PolygonIcon.js";
-import { insertBindingBehaviors as n } from "../shared/insertToolOptions.js";
-import { useCallback as r, useMemo as i, useRef as a, useState as o } from "react";
-import { jsx as s } from "react/jsx-runtime";
-import { cursorFor as c } from "@weasel-js/cursor";
+import { INSERT_REPOSITION_BINDING as e } from "../../../interactions/actions/insert/repositionAction.js";
+import { SHAPE_COUNT_RANGE as t } from "../../../features/paths/shapeGenerator.js";
+import { defineTool as n } from "../../overlayBinding.js";
+import r from "../../../icons/PolygonIcon.js";
+import { insertBindingBehaviors as i } from "../shared/insertToolOptions.js";
+import { useCallback as a, useMemo as o, useRef as s, useState as c } from "react";
+import { jsx as l } from "react/jsx-runtime";
+import { cursorFor as u } from "@weasel-js/cursor";
 //#region src/tools/builtin/polygon/usePolygonTool.tsx
-var l = 3, u = 32;
 function d(d = {}) {
-	let { sides: f = 6, label: p = "Polygon", behaviors: m } = d, h = a(f), [, g] = o(0), _ = r(() => g((e) => e + 1), []), v = i(() => ({
+	let { sides: f = 6, label: p = "Polygon", behaviors: m } = d, h = s(f), [, g] = c(0), _ = a(() => g((e) => e + 1), []), v = o(() => ({
 		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 && (h.current = r > 0 ? Math.min(u, h.current + 1) : Math.max(l, h.current - 1), _());
+			run: (e, n) => {
+				let r = n, i = r?.delta ?? (r?.deltaY !== void 0 && r.deltaY !== 0 ? r.deltaY > 0 ? 1 : -1 : 0);
+				i !== 0 && (h.current = i > 0 ? Math.min(t.max, h.current + 1) : Math.max(t.min, h.current - 1), _());
 			}
 		}
 	}), [_]);
-	return i(() => e({
+	return o(() => n({
 		id: "polygon",
 		keybinding: { key: "G" },
 		capabilities: ["creates-shapes"],
 		hookName: "usePolygonTool",
-		cursor: c("crosshairPolygon", { fallback: "crosshair" }),
+		cursor: u("crosshairPolygon", { fallback: "crosshair" }),
 		actions: [v],
 		presentation: {
 			label: p,
 			group: "shape",
-			icon: /* @__PURE__ */ s(t, {})
+			icon: /* @__PURE__ */ l(r, {})
 		},
 		bindings: [
 			{
@@ -39,9 +40,10 @@ function d(d = {}) {
 						kind: "polygon",
 						sides: h.current
 					}),
-					...n(m)
+					...i(m)
 				}
 			},
+			e,
 			{
 				spec: {
 					kind: "wheel",

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","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<null> {\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<null>({\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,GACtB;CACZ,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,EAAiB;EACf,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"}
+{"version":3,"file":"usePolygonTool.js","names":["PolygonIcon","usePolygonTool","initialSides","options","sidesRef","useRef","setSidesTick","useState","bumpSides","useCallback","n","adjustSidesAction","useMemo","p","params","step","SHAPE_COUNT_RANGE","defineTool","cursorFor","insertBindingBehaviors","behaviors","INSERT_REPOSITION_BINDING","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 { INSERT_REPOSITION_BINDING } from 'interactions/actions/insert/repositionAction';\nimport { SHAPE_COUNT_RANGE } from 'features/paths/shapeGenerator';\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\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          // from the wheel. Wheel up (deltaY > 0 under natural scrolling)\n          // adds a side.\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(SHAPE_COUNT_RANGE.max, sidesRef.current + 1)\n            : Math.max(SHAPE_COUNT_RANGE.min, 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          INSERT_REPOSITION_BINDING,\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":";;;;;;;;;AAiCA,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,GAIJC,IAAOF,GAAG,UAAUA,GAAG,WAAW,KAAA,KAAaA,EAAE,WAAW,IAC7DA,EAAE,SAAS,IAAI,IAAI,KACpB;IACJ,AAAIE,MAAS,MACb,EAAS,UAAUA,IAAO,IACtB,KAAK,IAAIC,EAAkB,KAAKZ,EAAS,UAAU,CAAC,IACpD,KAAK,IAAIY,EAAkB,KAAKZ,EAAS,UAAU,CAAC,GACxDI,EAAU;GACZ;EACF;CACF,IACA,CAACA,CAAS,CACZ;CAOA,OAAOI,QAEHK,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,CAACP,CAAiB;EAC3B,cAAc;GACZ;GACA,OAAO;GACP,MAAM,kBAACX,GAAD,CAAc,CAAA;EACtB;EACA,UAAU;GAMR;IACE,MAAM,EAAE,MAAM,OAAO;IACrB,UAAU;IAKV,MAAM;KACJ,eAAe;MACb,MAAM;MACN,OAAOI,EAAS;KAClB;KACA,GAAGe,EAAuBC,CAAS;IACrC;GACF;GACAC;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;EAACV;EAAmBS;EAAWE;CAAK,CACtC;AACF"}

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

@@ -1,20 +1,21 @@
-import { defineTool as e } from "../../overlayBinding.js";
-import t from "../../../icons/RectIcon.js";
-import { insertBindingBehaviors as n } from "../shared/insertToolOptions.js";
-import { createElement as r, useMemo as i } from "react";
-import { cursorFor as a } from "@weasel-js/cursor";
+import { INSERT_REPOSITION_BINDING as e } from "../../../interactions/actions/insert/repositionAction.js";
+import { defineTool as t } from "../../overlayBinding.js";
+import n from "../../../icons/RectIcon.js";
+import { insertBindingBehaviors as r } from "../shared/insertToolOptions.js";
+import { createElement as i, useMemo as a } from "react";
+import { cursorFor as o } from "@weasel-js/cursor";
 //#region src/tools/builtin/rect/useRectTool.ts
-function o(o = {}) {
-	let { behaviors: s } = o;
-	return i(() => e({
+function s(s = {}) {
+	let { behaviors: c } = s;
+	return a(() => t({
 		id: "rect",
 		keybinding: { key: "R" },
 		capabilities: ["creates-shapes"],
 		hookName: "useRectTool",
-		cursor: a("crosshairRect", { fallback: "crosshair" }),
+		cursor: o("crosshairRect", { fallback: "crosshair" }),
 		presentation: {
 			label: "Rectangle",
-			icon: r(t),
+			icon: i(n),
 			group: "shape"
 		},
 		bindings: [{
@@ -22,12 +23,12 @@ function o(o = {}) {
 			actionId: "insert",
 			opts: {
 				params: { kind: "rect" },
-				...n(s)
+				...r(c)
 			}
-		}]
-	}), [s]);
+		}, e]
+	}), [c]);
 }
 //#endregion
-export { o as useRectTool };
+export { s as useRectTool };
 
 //# sourceMappingURL=useRectTool.js.map

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        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 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,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;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","INSERT_REPOSITION_BINDING"],"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 { INSERT_REPOSITION_BINDING } from 'interactions/actions/insert/repositionAction';\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          INSERT_REPOSITION_BINDING,\n        ],\n      }),\n    [behaviors],\n  );\n}\n"],"mappings":";;;;;;;AAgBA,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,GACAC,CACF;CACF,CAAC,GACH,CAACD,CAAS,CACZ;AACF"}

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

@@ -0,0 +1,40 @@
+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 { applyToPoint as i, boundsOfPath as a, meanScale as o, pathContainsPoint as s } from "@weasel-js/geom";
+//#region src/tools/builtin/select/adapterPointQuery.ts
+function c(c, l) {
+	let u = (d, f, p) => ({
+		hits: (e, i, o) => {
+			let u = o ? a(o) : t(c, e).getBounds(i);
+			if (e.kind !== "container") {
+				let t = l || o ? p : 0;
+				return d >= u.x - t && d <= u.x + u.width + t && f >= u.y - t && f <= u.y + u.height + t ? !l || n(e, i, d, f, {
+					tolerance: p,
+					derivedPath: o
+				}) : !1;
+			}
+			if (!(d >= u.x && d <= u.x + u.width && f >= u.y && f <= u.y + u.height)) return !1;
+			let m = r(e, i, o);
+			return m === null || s(m, d, f);
+		},
+		clipAdmits: (e) => s(e, d, f),
+		inPlane: (t) => {
+			let n = e(t, {
+				x: d,
+				y: f
+			});
+			return u(n.x, n.y, p * o(t.scale));
+		},
+		inCopy: (e) => {
+			let [t, n] = i(e, d, f);
+			return u(t, n, p * Math.sqrt(Math.abs(e[0] * e[3] - e[1] * e[2])));
+		}
+	});
+	return u;
+}
+//#endregion
+export { c 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","x","y","applyToPoint"],"sources":["../../../../src/tools/builtin/select/adapterPointQuery.ts"],"sourcesContent":["import { applyToPoint, 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    inCopy: (m) => {\n      const [x, y] = applyToPoint(m, px, py);\n      return pointQuery(x, y, t * Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])));\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;EACA,SAAS,MAAM;GACb,IAAM,CAACE,GAAGC,KAAKC,EAAaJ,GAAGT,GAAIC,CAAE;GACrC,OAAOZ,EAAWsB,GAAGC,GAAGb,IAAI,KAAK,KAAK,KAAK,IAAIU,EAAE,KAAKA,EAAE,KAAKA,EAAE,KAAKA,EAAE,EAAE,CAAC,CAAC;EAC5E;CACF;CACA,OAAOpB;AACT"}

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

@@ -1,5 +1,5 @@
 import { gestureLifecycleParams as e } from "../../../interactions/actions/gestureLifecycle.js";
-import { isAnchorOrControl as t, isResizeHandle as n, isRotateHandle as r } from "@weasel-js/routing";
+import { isPathEditPart 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 a = "selection.move", o = "selection.transform", s = "selection.resize", c = "selection.rotate";
@@ -68,7 +68,7 @@ function d(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: {
@@ -110,8 +110,8 @@ function g(e = {}) {
 		bindings: d(e)
 	};
 }
-var _ = "selection.areaSelect", v = i((e, t) => e == null && t === "empty");
-function y() {
+var _ = "selection.areaSelect", v = i((e, t) => e == null && t === "empty"), y = i((e, t) => e == null && t !== "empty");
+function b() {
 	return {
 		id: _,
 		eligibility: { always: !0 },
@@ -125,6 +125,6 @@ function y() {
 	};
 }
 //#endregion
-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, y as areaSelectContribution, 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 };
+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