@weasel-js/core 1.0.3 → 1.0.4

package/dist/chunk-TR3HZN34.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/interactions/actions/depRegistry.tsx","../src/interactions/actions/buildDeps.ts","../src/interactions/actions/registry.tsx","../src/tools/routing/reflection/registry.ts","../src/tools/routing/reflection/conflicts.ts"],"names":["createContext","useRef","useMemo","jsx","useContext","useEffect"],"mappings":"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","file":"chunk-TR3HZN34.js","sourcesContent":["/**\n * Dep registry for registry unification.\n *\n * Holds named \"live source\" thunks. Actions declare `requires: ['selection']`;\n * the dispatcher calls `registry.get('selection')` at invocation time to\n * build a typed Deps bag.\n *\n * `DepSchema` — the map of dep name → value type — is the single source of\n * truth for what `requires`/`register`/`get` accept. Its concrete fields live\n * in `./depSchema` (co-located with the dep value types). It is declared there\n * as a plain `export interface` rather than via a cross-module\n * `declare module './depRegistry'` augmentation: that augmentation does NOT\n * merge once rollup-plugin-dts flattens both files into one `.d.ts` chunk,\n * which silently emptied `DepSchema` for consumers. Consumers still extend it\n * via `declare module '@weasel-js/core'` augmentation.\n */\nimport {\n  createContext, useContext, useEffect, useMemo, useRef,\n  type ReactNode,\n} from 'react';\nimport type { DepSchema, DepName } from './depSchema';\n\nexport type { DepSchema, DepName };\n\n/** Holds the live sources an action's declared dependencies resolve to.\n *  Sources are thunks, read at invocation time, so an action never captures\n *  stale state. */\nexport interface DepRegistry {\n  register<K extends DepName>(name: K, source: () => DepSchema[K]): () => void;\n  get<K extends DepName>(name: K): DepSchema[K] | undefined;\n}\n\nconst DepRegistryContext = createContext<DepRegistry | null>(null);\n\n/** Provides the dep registry for a canvas. `<SceneCanvas>` mounts one; a\n *  consumer registering its own dep sources must be inside it. */\nexport function DepRegistryProvider({ children }: { children: ReactNode }) {\n  const sourcesRef = useRef(new Map<DepName, () => unknown>() as Map<string, () => unknown>);\n\n  const registry = useMemo<DepRegistry>(() => ({\n    register: <K extends DepName>(name: K, source: () => DepSchema[K]) => {\n      sourcesRef.current.set(name as string, source as () => unknown);\n      return () => { sourcesRef.current.delete(name as string); };\n    },\n    get: <K extends DepName>(name: K) =>\n      sourcesRef.current.get(name as string)?.() as DepSchema[K] | undefined,\n  }), []);\n\n  return <DepRegistryContext.Provider value={registry}>{children}</DepRegistryContext.Provider>;\n}\n\n/** The dep registry in scope. Throws outside a `<DepRegistryProvider>`. */\nexport function useDepRegistry(): DepRegistry {\n  const r = useContext(DepRegistryContext);\n  if (r === null) {\n    throw new Error('useDepRegistry: no DepRegistryProvider in scope. Wrap your tree with <DepRegistryProvider> (typically inside <SceneCanvas>).');\n  }\n  return r;\n}\n\n/**\n * Like `useDepRegistry`, but returns `null` when no `<DepRegistryProvider>` is\n * in scope instead of throwing. Used by `useStandardActions` to preserve its\n * silent-no-op contract when neither provider is present.\n */\nexport function useOptionalDepRegistry(): DepRegistry | null {\n  return useContext(DepRegistryContext);\n}\n\n/** Register a live source for `name` for the lifetime of the calling\n *  component. The `source` thunk is called at dispatch time and should\n *  return the latest value. */\nexport function useDepSource<K extends DepName>(name: K, source: () => DepSchema[K]) {\n  const registry = useDepRegistry();\n  const sourceRef = useRef(source);\n  sourceRef.current = source;\n  useEffect(() => {\n    return registry.register(name, () => sourceRef.current());\n  }, [name, registry]);\n}\n","/**\n * Shared dep-bag builder — the single implementation behind both the gesture\n * dispatcher's per-invocation `buildDeps` and `ActionsRegistry.trigger`'s\n * `requires` branch. Reads the action's declared `requires`, resolves each\n * name against the `DepRegistry`, and (dev builds only) wraps the bag in a\n * Proxy that warns on undeclared reads.\n */\nimport type { Action } from './registry';\nimport type { DepRegistry } from './depRegistry';\nimport type { ActionDeps } from './invoker';\n\n/** True in dev builds; false in production. Tree-shakes the Proxy out of\n *  prod entirely. (Mirrors the dispatcher's own `DEV` const.) */\nconst DEV: boolean = (() => {\n  try {\n    return Boolean((import.meta as unknown as { env?: { DEV?: boolean } }).env?.DEV);\n  } catch {\n    return false;\n  }\n})();\n\n/** Build the deps bag for an action from its declared `requires`. */\nexport function buildDepsFromRequires(action: Action, depRegistry: DepRegistry): ActionDeps {\n  const requires = action.requires ?? [];\n  const entries = requires.map((name) => [name, depRegistry.get(name)]);\n  const deps = Object.fromEntries(entries) as ActionDeps;\n\n  // Dev-only: wrap deps in a Proxy that warns when the invoker reads a\n  // key not declared in `requires`. Catches silent-failure-by-typo or\n  // forgotten-requires (the #1 bug class in this codebase pre-Phase-14e).\n  // Production builds: bypass the Proxy entirely (zero overhead).\n  if (DEV) {\n    const declared = new Set<string>(requires);\n    return new Proxy(deps as Record<string, unknown>, {\n      get(target, prop, receiver) {\n        if (typeof prop === 'string' && !declared.has(prop) && prop !== 'then') {\n          const message =\n            `[weasel:dispatcher] action \"${action.id}\" read deps.${prop} but did not declare it in \\`requires\\`. ` +\n            `Add \\`requires: [...'${prop}']\\` to the descriptor or the dep will be undefined at runtime.`;\n          // Warn first so the console trail survives even when the throw is\n          // swallowed by a caller, then throw so the gesture fails visibly\n          // instead of silently running without the dep.\n          // eslint-disable-next-line no-console\n          console.warn(message);\n          throw new Error(message);\n        }\n        return Reflect.get(target, prop, receiver);\n      },\n    }) as ActionDeps;\n  }\n  return deps;\n}\n","/**\n * @experimental\n * Actions Registry — owns the registered `Action` descriptors and the\n * imperative `trigger` path. Keystrokes reach actions through the gesture\n * dispatcher matching their `defaultBinding`, not through a listener here.\n * Spec: docs/superpowers/specs/2026-05-09-actions-registry-design.md\n */\nimport {\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n  type ReactElement,\n  type ReactNode,\n} from 'react';\nimport type { GestureSpec, PhaseSpec } from '../gestures/spec';\nimport type { ActionDeps, BindingOpts, Invoker } from './invoker';\nimport type { GestureBinding } from './binding';\nimport { useOptionalDepRegistry, type DepRegistry, type DepName } from './depRegistry';\nimport { buildDepsFromRequires } from './buildDeps';\nimport { RESERVED_ID_NAMES, RESERVED_ID_PREFIXES, type PhaseAtom } from '../../tools/routing/routeGrammar';\nimport type { Dispatcher, UiOngoingControl } from '../dispatcher/dispatcher';\nexport type { UiOngoingControl } from '../dispatcher/dispatcher';\n\n/**\n * @experimental\n * A single entry in `Action.defaultBinding[]`. Either a bare `GestureSpec`\n * (no per-binding opts) or an object form that pairs a spec with\n * `BindingOpts` for parametric actions (e.g. `{ params: { axis: 'x' } }`).\n * Use the object form when two bindings for the same action differ only in\n * a runtime parameter — the dispatcher extracts `opts.params` and passes\n * them to `ImmediateInvoker.run` as its second argument.\n */\nexport type BoundGesture = GestureSpec | { spec: GestureSpec; opts: BindingOpts };\n\n/**\n * @experimental\n * Flatten an action's `defaultBinding` into `GestureBinding`s. A bare\n * `GestureSpec` has `kind` at top level; the object form has `spec`.\n */\nexport function actionBindings(action: Action): GestureBinding[] {\n  const gs = action.defaultBinding;\n  if (!gs) return [];\n  const raw: BoundGesture[] = Array.isArray(gs) ? gs : [gs as BoundGesture];\n  return raw.map((entry) => {\n    const isBoundObj = !('kind' in entry);\n    const spec = isBoundObj ? (entry as { spec: GestureSpec }).spec : (entry as GestureSpec);\n    const opts = isBoundObj ? (entry as { opts: BindingOpts }).opts : undefined;\n    return { spec, actionId: action.id, ...(opts !== undefined ? { opts } : {}) };\n  });\n}\n\n/**\n * @experimental\n * Single registered action. v1: one binding per action.\n */\nexport interface Action {\n  id: string;\n  label: string;\n  /** The gesture-spec form of the binding, read by the gesture dispatcher.\n   *  May be a single `GestureSpec`, a bare `GestureSpec[]` (any-of semantics),\n   *  or a `BoundGesture[]` where each entry is either a bare `GestureSpec` or\n   *  `{ spec, opts }` — use the object form for parametric actions where two\n   *  bindings for the same action differ only by `opts.params` (e.g. `flip`\n   *  with `axis: 'x'` vs `'y'`). The dispatcher extracts `opts.params` and\n   *  passes them to `ImmediateInvoker.run` as its second argument. */\n  defaultBinding?: GestureSpec | BoundGesture[];\n  /** Names of the deps this action's invoker reads (keys of `DepSchema`).\n   *  The dispatcher (and `trigger`, when `requires` is present) resolves\n   *  each name against the `DepRegistry` at invocation time and passes the\n   *  resulting bag to the invoker. Dev builds warn when the invoker reads a\n   *  dep it didn't declare here — see `buildDepsFromRequires`. */\n  requires?: readonly DepName[];\n  /** Inline-SVG icon for palette / toolbar surfaces. Mirrors\n   *  `ToolPresentation.icon` so a generic `<ActionBar>` can render from\n   *  action metadata the same way `<ToolPalette>` renders from tool\n   *  metadata. May be a static `ReactNode` or a function (rare; useful\n   *  for state-aware icons like a \"lock\" toggle). */\n  icon?: ReactNode | (() => ReactNode);\n  /** Grouping key for palette/menu surfaces. Free-form string; the kit\n   *  ships defaults for `'align'` (six edges/centers), `'distribute'`\n   *  (two axes), and recommends `'pathfinder'` for boolean ops. */\n  group?: string;\n  /** Display override for the keyboard shortcut. When omitted, palette\n   *  surfaces derive a label from `defaultBinding` via their own\n   *  formatter. */\n  shortcut?: string;\n  /** Pluggable invocation strategy. The gesture dispatcher routes matched\n   *  bindings through `invoker.start` / `invoker.run` depending on timing.\n   *  All kit-standard descriptors ship one; consumer-supplied actions\n   *  without an invoker can still register but won't be triggered. */\n  invoker?: Invoker;\n  /** When set to `'hotkey'`, this action's `defaultBinding` rides the hotkey\n   *  `BindingScope` instead of the ambient scope — meaning it beats any\n   *  active-tool binding on the same input shape. Use for tool-switch\n   *  shortcuts and global held-key triggers. Default: ambient. */\n  scope?: 'hotkey';\n  /**\n   * @experimental\n   * Optional predicate the command palette consults when rendering. Return\n   * `true` when the action is currently triggerable. Return a reason string\n   * (e.g. `'Selection required'`) when disabled — the palette greys out\n   * the row, skips it in keyboard nav, ignores clicks, and shows the\n   * reason next to the label. Keystroke dispatch (the registered binding)\n   * is unaffected; the action's own `run` should self-guard.\n   *\n   * **Contract:** must be pure (no side effects), fast (< 4ms in dev), and\n   * must not throw. If a call throws or exceeds the budget in dev mode,\n   * `evaluateEnabled` logs a one-time warning per action id; throws are\n   * caught and treated as disabled with reason `'(predicate threw)'`.\n   *\n   * Snapshot-on-open semantics: the palette evaluates `enabled` once when\n   * opened and does NOT re-evaluate on selection changes while open. Live\n   * reactive updates are deferred — palette is short-lived.\n   *\n   * The reason set is a closed enum — to add a new reason, edit\n   * `ActionDisabledReason` and the consumer's display map.\n   *\n   * The optional `deps` argument is the same bag passed to\n   * `ImmediateInvoker.run`; callers (`evaluateEnabled` / the ActionBar) may\n   * synthesize it from the surrounding `DepRegistry` so predicates can\n   * inspect selection / scene / etc. Predicates that don't need deps just\n   * ignore the arg.\n   */\n  enabled?: (deps?: ActionDeps) => true | ActionDisabledReason;\n  /**\n   * Declarative eligibility rule, evaluated against the current\n   * `RuleCtx` by the dispatcher before invoking `start()`. Omitted =\n   * always eligible.\n   *\n   * Accepts either a fluent `Condition` (callable with `.rule`) or a\n   * raw `Rule` tree; the dispatcher normalizes via `.rule` unwrap.\n   *\n   * Prefer `capability:`-based rules (e.g. `{ capability: 'transforms-selection' }`)\n   * over `mode:` rules — capability rules survive new modes being added\n   * that allow the same capability.\n   */\n  eligible?:\n    | import('../../features/chrome-caps').Rule\n    | import('../../features/chrome-caps').Condition;\n  /**\n   * CSS cursor shown while the pointer hovers a spot where this action\n   * would win the drag. The hover-cursor pump (in `useGestureDispatcher`)\n   * runs `Dispatcher.resolveOnly` on each idle pointermove — the same\n   * match walk a real pointerdown takes — and applies the winning\n   * action's `cursor`, so the hint and the actual click target stay in\n   * sync by construction. Omitted = no override (the active tool's\n   * `Tool.cursor` shows). Affordance hits are resolved earlier in the\n   * pump via `AffordanceRegion.cursor` and never reach this field.\n   *\n   * Static string only. Prediction runs `enabled()` but cannot run the\n   * invoker, so an action that matches yet bails at `start()` (empty\n   * handle) may still show its cursor — keep `enabled` accurate for\n   * actions that declare one.\n   */\n  cursor?: string;\n  /**\n   * CSS cursor shown while THIS action's ongoing handle is in flight —\n   * grabbing while panning, `move` while dragging a selection, `crosshair`\n   * while pulling a marquee.\n   *\n   * Separate from `cursor` because the two answer different questions:\n   * `cursor` is a prediction (\"a drag from here would pan\"), this is a state\n   * (\"you are panning\"). An action can declare either, both, or neither;\n   * with only `cursor` set, the hover hint holds for the duration of the\n   * gesture.\n   *\n   * This is where mid-gesture cursors live now. They used to come from the\n   * tool side — `ViewportToolDef.engaged.cursor` for a phase-gated string,\n   * or a function-form `Tool.cursor` reading the gesture scratch out of the\n   * tool-routing dispatcher. Both belonged to a pipeline whose whole job was\n   * being taken over by bindings, and neither could describe a cursor for an\n   * action a tool doesn't own.\n   */\n  activeCursor?: string;\n}\n\n/**\n * @experimental\n * Closed enum of reasons an action might report itself as disabled. The\n * consumer (palette, menu, etc.) maps these symbolic values to display\n * strings via its own label map — see `demo/CommandPalette.tsx` for the\n * canonical mapping.\n */\nexport const ActionDisabledReason = {\n  SelectionRequired: 'selection-required',\n  SceneEmpty: 'scene-empty',\n  NotApplicable: 'not-applicable',\n  /** Sentinel: the predicate threw. Surfaced by `evaluateEnabled`'s catch. */\n  PredicateThrew: 'predicate-threw',\n} as const;\n/** Why an action is unavailable right now. */\nexport type ActionDisabledReason =\n  (typeof ActionDisabledReason)[keyof typeof ActionDisabledReason];\n\n/**\n * @experimental\n * Result of evaluating an Action's `enabled` predicate.\n */\nexport interface ActionEnabledResult {\n  enabled: boolean;\n  reason?: ActionDisabledReason;\n}\n\nconst enabledSlowWarned = new Set<string>();\nconst enabledThrewWarned = new Set<string>();\nconst ENABLED_BUDGET_MS = 4;\n/**\n * @experimental\n * Safely evaluate an action's `enabled` predicate. Returns `{enabled: true}`\n * when no predicate is supplied. Catches throws and treats them as disabled\n * with reason `'(predicate threw)'`. In dev mode, warns once per action id\n * when a single call exceeds 4ms (single frame at 240fps — generous; real\n * predicates should be sub-millisecond).\n */\nexport function evaluateEnabled(\n  action: Action,\n  deps?: ActionDeps,\n): ActionEnabledResult {\n  if (!action.enabled) return { enabled: true };\n  const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n  const now = (typeof performance !== 'undefined' && typeof performance.now === 'function')\n    ? () => performance.now()\n    : () => Date.now();\n  const start = isDev ? now() : 0;\n  try {\n    const result = action.enabled(deps);\n    if (isDev) {\n      const elapsed = now() - start;\n      if (elapsed > ENABLED_BUDGET_MS && !enabledSlowWarned.has(action.id)) {\n        enabledSlowWarned.add(action.id);\n        console.warn(\n          `weasel actions: enabled() for action \"${action.id}\" took ${elapsed.toFixed(2)}ms ` +\n          `(budget ${ENABLED_BUDGET_MS}ms). The predicate must be pure and fast — see Action.enabled JSDoc.`,\n        );\n      }\n    }\n    if (result === true) return { enabled: true };\n    return { enabled: false, reason: result };\n  } catch (e) {\n    if (isDev && !enabledThrewWarned.has(action.id)) {\n      enabledThrewWarned.add(action.id);\n      console.warn(\n        `weasel actions: enabled() for action \"${action.id}\" threw; treating as disabled. ` +\n        `The predicate must not throw — see Action.enabled JSDoc.`,\n        e,\n      );\n    }\n    return { enabled: false, reason: ActionDisabledReason.PredicateThrew };\n  }\n}\n\n/** @internal Test helper: reset warn-once dedup so tests can repro-fire warnings. */\nexport function _resetEnabledWarnsForTests(): void {\n  enabledSlowWarned.clear();\n  enabledThrewWarned.clear();\n}\n\n/**\n * @experimental\n * Partial override or full descriptor passed via `<SceneCanvas actions={...}>`.\n * `null` disables a default at this id.\n */\nexport type ActionEntry = null | Partial<Action> | Action;\n\n/**\n * @experimental\n * Shape of the `actions` prop on `<SceneCanvas>`. `null` disables all defaults.\n */\nexport type ActionsProp = null | Record<string, ActionEntry>;\n\n/**\n * @experimental\n * Imperative API exposed by `useActionsRegistry()`.\n */\nexport interface ActionsRegistry {\n  register(action: Action): () => void;\n  unregister(id: string): void;\n  list(): readonly Action[];\n  /** Fire an immediate-invoker action by id. The optional `params` arg is\n   *  forwarded to `ImmediateInvoker.run` as its second argument — use it for\n   *  parametric actions (e.g. `trigger('tool.activate', { toolId: 'rect' })`).\n   *  Ongoing-invoker actions are not reachable from `trigger`. */\n  trigger(id: string, params?: Record<string, unknown>): boolean;\n  /**\n   * Subscribe to registry mutations. The callback fires after any\n   * `register`/`unregister` that changes the version. Returns an\n   * unsubscribe function. Designed for `useSyncExternalStore`-driven\n   * surfaces (e.g. `<ActionBar>` in `@weasel-js/ui`) that need to\n   * re-render when the action set changes.\n   */\n  subscribe(listener: () => void): () => void;\n\n  /**\n   * Start an ongoing action driven by UI (color picker, opacity slider).\n   * Returns a control object with `update(params)` and `end(reason)`.\n   *\n   * Returns `null` if no dispatcher is wired into this registry, the\n   * action is unknown, or its invoker is not ongoing.\n   *\n   * See `Dispatcher.beginUiOngoing` for full semantics including\n   * auto-commit when a prior UI handle for the same action is in flight.\n   */\n  begin(id: string, params?: Record<string, unknown>): UiOngoingControl | null;\n\n  /** Wire a dispatcher into the registry so `begin()` can delegate to it.\n   *  Call with `null` to detach. Idempotent. */\n  setDispatcher(d: Dispatcher | null): void;\n\n  /** Wire a `DepRegistry` into the registry so `trigger()` / `begin()` can\n   *  resolve action deps even when this provider is mounted ABOVE the dep\n   *  registry (e.g. a consumer's root `<ActionsProvider>` reused by\n   *  SceneCanvas's `ActionsProviderIfRoot`). Takes precedence over the dep\n   *  registry read from context at the provider's own level. Call with\n   *  `null` to detach. */\n  setDepRegistry(r: DepRegistry | null): void;\n}\n\n// ─── Registration-time validation ─────────────────────────────────────────\n\n/** Validate that `id` is usable as an action id in the route grammar.\n *  Rejects ids that start with a reserved sigil (would shadow future\n *  grammar extensions) and ids that collide with phase keywords (would\n *  parse as the bare-phase shorthand). Mirrors `defineTool`'s tool-id\n *  validation. */\nfunction validateActionId(id: string): void {\n  if (id.length === 0) {\n    throw new Error(`weasel: action id may not be empty`);\n  }\n  if (RESERVED_ID_PREFIXES.has(id[0]!)) {\n    throw new Error(\n      `weasel: action id \"${id}\" starts with reserved sigil \"${id[0]}\" ` +\n      `(reserved set: ${[...RESERVED_ID_PREFIXES].join(' ')})`,\n    );\n  }\n  if (RESERVED_ID_NAMES.has(id)) {\n    throw new Error(\n      `weasel: action id \"${id}\" collides with a reserved phase keyword ` +\n      `(reserved: ${[...RESERVED_ID_NAMES].join(', ')})`,\n    );\n  }\n}\n\n/** Reject any '&'-channel phase atom in an Action's defaultBinding —\n *  actions have no owning tool, so '&' can't resolve. Tool-side bindings\n *  (Tool.bindings) are the right place for '&' atoms. */\nfunction validateActionDefaultBinding(action: Action): void {\n  const gs = action.defaultBinding;\n  if (!gs) return;\n  const entries: BoundGesture[] = Array.isArray(gs) ? gs : [gs as BoundGesture];\n  for (const entry of entries) {\n    const spec = ('kind' in entry ? entry : entry.spec) as GestureSpec;\n    const phase: PhaseSpec | undefined = spec.phase;\n    if (phase === undefined) continue;\n    const atoms: readonly PhaseAtom[] = Array.isArray(phase)\n      ? phase\n      : [{ channel: '&', phase: phase }];\n    for (const atom of atoms) {\n      if (atom.channel === '&') {\n        throw new Error(\n          `weasel: action \"${action.id}\" defaultBinding uses '&' channel ` +\n          `which has no owning tool to resolve to. Use a named tool channel ` +\n          `(e.g. '[rect:engaged]') or '*' instead, or move this binding to ` +\n          `the tool's own Tool.bindings.`,\n        );\n      }\n    }\n  }\n}\n\nconst ActionsContext = createContext<ActionsRegistry | null>(null);\n\n/**\n * @experimental\n * Mounts an `ActionsRegistry` for its lifetime. Children call\n * `useActionsRegistry()` or `useAction()` to participate. Mounts no input\n * listener of its own — the gesture dispatcher owns input.\n */\nexport function ActionsProvider({ children }: { children: ReactNode }): ReactElement {\n  const actionsRef = useRef<Map<string, Action>>(new Map());\n  const versionRef = useRef(0);\n  const cachedRef = useRef<readonly Action[]>([]);\n  const cachedVerRef = useRef(-1);\n  const listenersRef = useRef<Set<() => void>>(new Set());\n\n  // Trigger() consults the optional dep registry so actions can be fired\n  // imperatively from ActionBar / palette callers — the registered\n  // `invoker.run` receives a deps bag built fresh from the registry.\n  const depReg = useOptionalDepRegistry();\n  const depRegRef = useRef<DepRegistry | null>(depReg);\n  depRegRef.current = depReg;\n\n  // Dep registry wired via setDepRegistry — set by SceneCanvas's registrar\n  // when this provider sits above the dep-registry scope (consumer root\n  // <ActionsProvider>). Preferred over the context read above.\n  const wiredDepRegRef = useRef<DepRegistry | null>(null);\n\n  // Dispatcher ref — wired from SceneCanvas via setDispatcher so that\n  // begin() can delegate to beginUiOngoing.\n  const dispatcherRef = useRef<Dispatcher | null>(null);\n\n  // The legacy keystroke loop that walked every action's\n  // `defaultBinding: KeyBinding` and matched against keydown is gone, along\n  // with the per-action consumer hooks (`useEscape`, `useDelete`, ...) that\n  // carried their own `useKeybinding` listener. Every kit-standard descriptor\n  // now routes through the gesture dispatcher via `defaultBinding`.\n\n  const registry = useMemo<ActionsRegistry>(() => {\n    const snapshot = (): readonly Action[] => {\n      const v = versionRef.current;\n      if (cachedVerRef.current === v) return cachedRef.current;\n      const out = Object.freeze(Array.from(actionsRef.current.values()));\n      cachedRef.current = out;\n      cachedVerRef.current = v;\n      return out;\n    };\n    const notify = (): void => {\n      for (const l of listenersRef.current) {\n        try {\n          l();\n        } catch (err) {\n          console.error('weasel ActionsRegistry: subscriber threw', err);\n        }\n      }\n    };\n    return {\n      register: (action: Action) => {\n        validateActionId(action.id);\n        validateActionDefaultBinding(action);\n        actionsRef.current.set(action.id, action);\n        versionRef.current++;\n        notify();\n        return () => {\n          const cur = actionsRef.current.get(action.id);\n          // Only unregister if the current entry is still us (last-writer-wins\n          // means a later registrant should not be clobbered by our cleanup).\n          if (cur === action) {\n            actionsRef.current.delete(action.id);\n            versionRef.current++;\n            notify();\n          }\n        };\n      },\n      unregister: (id: string) => {\n        if (actionsRef.current.delete(id)) {\n          versionRef.current++;\n          notify();\n        }\n      },\n      list: () => snapshot(),\n      trigger: (id: string, params?: Record<string, unknown>) => {\n        const a = actionsRef.current.get(id);\n        if (!a) return false;\n        try {\n          if (a.invoker && a.invoker.timing === 'immediate') {\n            const r = wiredDepRegRef.current ?? depRegRef.current;\n            // Prefer the action's declared `requires` (same contract the\n            // dispatcher uses — shared `buildDepsFromRequires`, including\n            // the dev-mode undeclared-read guard); legacy fixed bag\n            // otherwise.\n            const deps = !r\n              ? {}\n              : a.requires\n                ? buildDepsFromRequires(a, r)\n                : {\n                    selection: r.get('selection' as DepName),\n                    scene: r.get('scene' as DepName),\n                    history: r.get('history' as DepName),\n                    view: r.get('view' as DepName),\n                    pointer: r.get('pointer' as DepName),\n                    activeTool: r.get('activeTool' as DepName),\n                    booleansAdapter: r.get('booleansAdapter' as DepName),\n                  };\n            a.invoker.run(deps as never, params);\n          }\n        } catch (err) {\n          console.error(`weasel ActionsRegistry: action \"${id}\" threw`, err);\n        }\n        return true;\n      },\n      subscribe: (listener: () => void) => {\n        listenersRef.current.add(listener);\n        return () => {\n          listenersRef.current.delete(listener);\n        };\n      },\n      setDispatcher: (d: Dispatcher | null) => {\n        dispatcherRef.current = d;\n      },\n      setDepRegistry: (r: DepRegistry | null) => {\n        wiredDepRegRef.current = r;\n      },\n      begin: (id: string, params?: Record<string, unknown>) => {\n        const disp = dispatcherRef.current;\n        if (!disp) return null;\n        const r = wiredDepRegRef.current ?? depRegRef.current;\n        const deps = r\n          ? {\n              selection: r.get('selection' as DepName),\n              scene: r.get('scene' as DepName),\n              history: r.get('history' as DepName),\n              view: r.get('view' as DepName),\n              pointer: r.get('pointer' as DepName),\n              activeTool: r.get('activeTool' as DepName),\n              booleansAdapter: r.get('booleansAdapter' as DepName),\n            }\n          : {};\n        return disp.beginUiOngoing(id, deps as never, params);\n      },\n    };\n  }, []);\n\n  return <ActionsContext.Provider value={registry}>{children}</ActionsContext.Provider>;\n}\n\n/**\n * @experimental\n * Returns the parent `ActionsRegistry`, or `null` when no provider is in scope.\n */\nexport function useActionsRegistry(): ActionsRegistry | null {\n  return useContext(ActionsContext);\n}\n\n/**\n * @experimental\n * Register an `Action` for the lifetime of the calling component. No-op when\n * no `ActionsProvider` is in scope. Re-registers on `action` reference change\n * (consumers should memoize stable identities to avoid churn).\n */\nexport function useAction(action: Action): void {\n  const reg = useActionsRegistry();\n  useEffect(() => {\n    if (!reg) return;\n    return reg.register(action);\n  }, [reg, action]);\n}\n","import type { Tool } from '../../types';\nimport type { GestureSpec, ModSpec, TargetSpec, PhaseSpec } from '@weasel-js/gestures';\nimport type { ParsedModifiers, ModifierKey } from '../routeGrammar';\nimport { getGestureDescriptor, isKnownGestureName, type GestureName } from '../gestures';\n\n/**\n * One row in the route registry — a single `GestureBinding` on one tool,\n * flattened into the route grammar's vocabulary so the inspector, the\n * conflict checker, and `describeRoute` can all read the same shape.\n *\n * Multiple rows can share (gesture, arg, target, modifiers) if different tools\n * declare them; consumers walk the list and group client-side.\n */\nexport interface RegistryEntry {\n  toolId: string;\n  /** Which phase the binding's `phase` spec restricts it to. `'any'` when it\n   *  declares none, declares `'*'`, or declares an atom list whose atoms\n   *  don't agree on one phase — such a binding fires in either phase, and\n   *  reporting it as `'initial'` made it collide with genuinely-initial\n   *  bindings in `findConflicts`' bucket key. */\n  phase: 'initial' | 'engaged' | 'any';\n  /** Structured v3 modifier requirements. Empty object = \"no modifiers\n   *  held\" (the strict default). */\n  modifiers: ParsedModifiers;\n  gesture: GestureName;\n  /** Resolved arg value for arg-bearing gestures (wheel direction,\n   *  key name, multiTouchTap fingers). Undefined for gestures whose\n   *  descriptor has no `arg`. */\n  arg: string | undefined;\n  /** Target class for hit-testing gestures. `undefined` when the descriptor\n   *  has `hasTarget: false` or the spec declares no target;\n   *  {@link PREDICATE_TARGET} when the spec uses a `kindOf` predicate, which\n   *  the route grammar has no notation for. */\n  target: string | undefined;\n  /** The action this binding fires. */\n  actionId: string;\n  /** The `GestureSpec` this row was flattened from, by reference. Reflection\n   *  consumers that need something the grammar doesn't capture — the\n   *  specificity tuple, a `kindOf` predicate identity — read it here rather\n   *  than re-walking `Tool.bindings`. */\n  spec: GestureSpec;\n}\n\n/**\n * Stand-in target for a `{ kindOf }` predicate spec.\n *\n * The route grammar can name target *classes* (`empty`, `selected-body`,\n * `kind:rect`) but not arbitrary predicates, so three distinct select-tool\n * bindings all render as this one token. Narrowing it would mean giving the\n * grammar a way to describe a function, which is a real design question and\n * not one this reflection layer should answer by inventing syntax.\n */\nexport const PREDICATE_TARGET = 'predicate';\n\n/** `GestureSpec.kind` → route-grammar gesture name. `multiTouch` has no\n *  route-grammar gesture (only its tap synthesis does), so specs of that kind\n *  are skipped. */\nconst SPEC_KIND_TO_GESTURE: Record<GestureSpec['kind'], GestureName | undefined> = {\n  key: 'keyDown',\n  'key-held': 'keyHeld',\n  wheel: 'wheel',\n  click: 'click',\n  doubleClick: 'dblTap',\n  contextMenu: 'contextMenu',\n  longPress: 'longPress',\n  drag: 'drag',\n  pointerDown: 'pointerDown',\n  multiTouch: undefined,\n  multiTouchTap: 'multiTouchTap',\n  drop: 'drop',\n  paste: 'paste',\n};\n\n/**\n * Flatten every tool's `bindings` into route-registry rows.\n *\n * This was `buildActionRegistry`, and it walked `ToolDef.initial` /\n * `.engaged` phase tables — the grammar that no longer exists. It was also\n * blind to `Tool.bindings` the entire time the two lived side by side, which\n * is why the inspector under-reported select by more than half. The rename\n * fixes a second thing: it never had anything to do with the Actions\n * Registry, and reading `buildActionRegistry` next to `ActionsRegistry`\n * suggested otherwise.\n */\nexport function buildRouteRegistry(\n  tools: readonly Tool<unknown>[],\n): RegistryEntry[] {\n  const out: RegistryEntry[] = [];\n  for (const tool of tools) {\n    for (const binding of tool.bindings ?? []) {\n      const entry = entryFor(tool.id, binding.spec, binding.actionId);\n      if (entry) out.push(entry);\n    }\n  }\n  return out;\n}\n\nfunction entryFor(\n  toolId: string,\n  spec: GestureSpec,\n  actionId: string,\n): RegistryEntry | null {\n  const gesture = SPEC_KIND_TO_GESTURE[spec.kind];\n  if (!gesture || !isKnownGestureName(gesture)) return null;\n  const descriptor = getGestureDescriptor(gesture);\n  return {\n    toolId,\n    actionId,\n    gesture,\n    phase: phaseOf('phase' in spec ? spec.phase : undefined),\n    modifiers: parseModSpec('mods' in spec ? spec.mods : undefined),\n    arg: descriptor.arg ? argOf(spec, descriptor.arg.default) : undefined,\n    target: descriptor.hasTarget\n      ? targetOf('target' in spec ? spec.target : undefined)\n      : undefined,\n    spec,\n  };\n}\n\n/** Collapse a `PhaseSpec` to the single phase a binding is restricted to, or\n *  `'any'` when it isn't restricted to one.\n *\n *  `PhaseAtom.channel` says which channel's phase state the binding reads,\n *  not which phase it fires in, so it plays no part in this collapse — only\n *  the set of distinct `atom.phase` values matters. */\nfunction phaseOf(phase: PhaseSpec | undefined): 'initial' | 'engaged' | 'any' {\n  if (phase === undefined || phase === '*') return 'any';\n  if (phase === 'initial' || phase === 'engaged') return phase;\n  const distinct = new Set(phase.map((atom) => atom.phase));\n  if (distinct.size !== 1) return 'any';\n  const only = [...distinct][0];\n  return only === 'initial' || only === 'engaged' ? only : 'any';\n}\n\n/** `ModSpec` (per-key tri-state) → `ParsedModifiers`. `false` and absent both\n *  mean \"must not be held\", which the parsed form spells as an absent key. */\nfunction parseModSpec(mods: ModSpec | undefined): ParsedModifiers {\n  if (!mods) return {};\n  const out: ParsedModifiers = {};\n  for (const [name, req] of Object.entries(mods)) {\n    if (req === true) out[name as ModifierKey] = 'required';\n    else if (req === 'optional') out[name as ModifierKey] = 'optional';\n  }\n  return out;\n}\n\nfunction targetOf(target: TargetSpec | undefined): string | undefined {\n  if (target === undefined) return undefined;\n  return typeof target === 'string' ? target : PREDICATE_TARGET;\n}\n\nfunction argOf(spec: GestureSpec, fallback: string | undefined): string | undefined {\n  if ('key' in spec) {\n    return Array.isArray(spec.key) ? spec.key.join('|') : spec.key;\n  }\n  if ('fingers' in spec) return String(spec.fingers);\n  if ('direction' in spec) return spec.direction ?? fallback;\n  if ('types' in spec) return spec.types?.length ? spec.types.join('|') : fallback;\n  return fallback;\n}\n\n// Re-export for downstream consumers.\nexport { getGestureDescriptor };\nexport type { GestureName };\n","import type { Tool } from '../../types';\nimport { actionBindings, type Action } from '../../../interactions/actions/registry';\nimport type { ParsedModifiers } from '../routeGrammar';\nimport { canonicalModifiers, formatRoute } from '../routeGrammar';\nimport { buildRouteRegistry, PREDICATE_TARGET, type RegistryEntry, type GestureName } from './registry';\n\n/** Two or more tools declare the same exact (phase, gesture, arg, target,\n *  modifiers) tuple — the dispatcher's slot precedence picks one\n *  arbitrarily (well, deterministically by slot order, but the author\n *  probably didn't intend the duplication). */\nexport interface Conflict {\n  phase: 'initial' | 'engaged' | 'any';\n  gesture: GestureName;\n  arg: string | undefined;\n  target: string | undefined;\n  modifiers: ParsedModifiers;\n  /** All tool ids that registered the same tuple. At least 2 by\n   *  construction. Order matches the input tools[] order. */\n  toolIds: string[];\n}\n\n/** Detect exact-tuple overlaps across a tool registration set.\n *\n *  Intentionally NOT flagged:\n *  - Broad vs. narrow targets (e.g. an untargeted `click` alongside\n *    `click` on `empty`) — the dispatcher's specificity ordering resolves\n *    those cleanly, and the broad one is usually the intended fallback.\n *  - Different modifier requirements on the same target — they fire on\n *    different inputs.\n *  - A binding whose action declines via `enabled()` so a lower-priority\n *    one can take the gesture. Detecting that intent would mean evaluating\n *    the action; consumers can suppress known-intentional compositions in\n *    their UI layer.\n *\n *  - Two `{ kindOf }` predicate targets. The route grammar renders every\n *    predicate as the single token {@link PREDICATE_TARGET}, so bucketing on\n *    the rendered target alone reported select's `resize` / `rotate` / `move`\n *    drags — three genuinely different predicates — as a three-way conflict.\n *    Predicate entries bucket by function identity instead, which means two\n *    *separately written but equivalent* predicates go unflagged. That's the\n *    right way to be wrong here: this check has to be silent when nothing is\n *    wrong or nobody will keep it on.\n *\n *  Note that two bindings sharing a tuple on the SAME tool are now possible\n *  (bindings are an array, where phase tables were objects with unique\n *  keys) — so a conflict may name one tool twice.\n *\n *  This is the raw same-tuple detector. Feeding it a whole tool *registry*\n *  over-reports, because registry tools take turns in the active slot and\n *  can't collide with each other — see {@link findScopedConflicts}.\n */\nexport function findConflicts(\n  tools: readonly Tool<unknown>[],\n): Conflict[] {\n  const entries = buildRouteRegistry(tools);\n  const groups = new Map<string, RegistryEntry[]>();\n  for (const entry of entries) {\n    const key = `${entry.phase}|${entry.gesture}|${entry.arg ?? ''}|${targetKey(entry)}|${canonicalModifiers(entry.modifiers)}`;\n    const bucket = groups.get(key);\n    if (bucket) bucket.push(entry);\n    else groups.set(key, [entry]);\n  }\n  const conflicts: Conflict[] = [];\n  for (const bucket of groups.values()) {\n    if (bucket.length < 2) continue;\n    const first = bucket[0];\n    conflicts.push({\n      phase: first.phase,\n      gesture: first.gesture,\n      arg: first.arg,\n      target: first.target,\n      modifiers: first.modifiers,\n      toolIds: bucket.map((e) => e.toolId),\n    });\n  }\n  return conflicts;\n}\n\n/** Bucket key for an entry's target slot. Predicate targets all render as\n *  the same grammar token, so they're keyed by the predicate's identity —\n *  two different functions are two different targets. */\nfunction targetKey(entry: RegistryEntry): string {\n  if (entry.target !== PREDICATE_TARGET) return entry.target ?? '';\n  const spec = entry.spec as { target?: unknown };\n  const pred = spec.target;\n  if (typeof pred !== 'object' || pred === null) return PREDICATE_TARGET;\n  return `${PREDICATE_TARGET}#${predicateId(pred)}`;\n}\n\nconst PREDICATE_IDS = new WeakMap<object, number>();\nlet nextPredicateId = 0;\n\nfunction predicateId(pred: object): number {\n  let id = PREDICATE_IDS.get(pred);\n  if (id === undefined) {\n    id = nextPredicateId++;\n    PREDICATE_IDS.set(pred, id);\n  }\n  return id;\n}\n\n/**\n * The tool scopes as the dispatcher sees them — which is what decides whether\n * two same-tuple bindings can actually collide.\n */\nexport interface ToolScopes {\n  /** Tools eligible for the active slot, keyed by id or as a flat list. */\n  registry: readonly Tool<unknown>[] | Readonly<Record<string, Tool<unknown>>>;\n  /** Always-on tools. Every one of these is live at once. */\n  ambient?: readonly Tool<unknown>[];\n  /** Registered actions. Their `defaultBinding`s assemble at ambient scope\n   *  (hotkey scope when `Action.scope` says so), alongside the tools above. */\n  actions?: readonly Action[];\n}\n\n/** An action's `defaultBinding`s in the shape the route registry reads, so a\n *  tool-vs-action collision buckets with the tool-vs-tool ones. */\nfunction actionAsTool(action: Action): Tool<unknown> {\n  return { id: action.id, eligibility: {}, bindings: actionBindings(action) };\n}\n\n/**\n * Detect the same-tuple overlaps that are *reachable* — the ones where the\n * dispatcher really does fall back on declaration order.\n *\n * `matchSorted` walks scopes in strict priority (hotkey > active > ambient)\n * and only sorts by specificity *within* a scope. So a cross-scope tie isn't\n * a tie at all: an ambient tool losing a tuple to the active tool is the\n * documented design, not an accident. Likewise two registry tools sharing a\n * tuple — `rect` and `ellipse` both binding a bare `drag` — can never both be\n * in the active slot, so they never compete.\n *\n * What's left, and what this reports:\n *  - a single tool colliding with **itself** (possible since bindings became\n *    an array), which is ambiguous in whichever slot it occupies;\n *  - two **ambient** tools, all of which are live simultaneously and are\n *    ordered only by registration;\n *  - two **hotkey-capable** tools, which can stack.\n *\n * Registered actions join the same two buckets: their `defaultBinding`s\n * assemble at ambient scope (hotkey scope when `Action.scope` says so), so an\n * ambient tool and an action claiming one tuple really do fall back on\n * declaration order.\n */\nexport function findScopedConflicts(scopes: ToolScopes): Conflict[] {\n  const registry = Array.isArray(scopes.registry)\n    ? (scopes.registry as readonly Tool<unknown>[])\n    : Object.values(scopes.registry as Readonly<Record<string, Tool<unknown>>>);\n  const actions = scopes.actions ?? [];\n  const ambientActions = actions.filter((a) => a.scope !== 'hotkey').map(actionAsTool);\n  const hotkeyActions = actions.filter((a) => a.scope === 'hotkey').map(actionAsTool);\n  const ambient = [...(scopes.ambient ?? []), ...ambientActions];\n\n  const out: Conflict[] = [];\n  const seen = new Set<string>();\n  const add = (conflicts: readonly Conflict[]): void => {\n    for (const c of conflicts) {\n      const key = `${c.phase}|${c.gesture}|${c.arg ?? ''}|${c.target ?? ''}`\n        + `|${canonicalModifiers(c.modifiers)}|${c.toolIds.join(',')}`;\n      if (seen.has(key)) continue;\n      seen.add(key);\n      out.push(c);\n    }\n  };\n\n  // Self-collisions: every tool, whichever slot it lands in.\n  for (const tool of [...registry, ...(scopes.ambient ?? [])]) add(findConflicts([tool]));\n  // Ambient tools and ambient-scope actions are all live together.\n  if (ambient.length > 1) add(findConflicts(ambient));\n  // Hotkey-capable tools can stack on each other. `hotkey` is declared on the\n  // authored `ToolDef`, not carried onto the runtime `Tool` — `Tool.def` is\n  // the reflection handle for exactly this kind of read, and it's typed\n  // `unknown` so consumers cast at the use site.\n  const hotkey = [\n    ...registry.filter((t) => (t.def as { hotkey?: unknown } | undefined)?.hotkey !== undefined),\n    ...hotkeyActions,\n  ];\n  if (hotkey.length > 1) add(findConflicts(hotkey));\n\n  return out;\n}\n\n/**\n * Render a conflict as one line of human-readable text.\n *\n * The tuple is printed through {@link formatRoute}, so the message names the\n * collision in the same grammar the author wrote the binding in — modulo the\n * phase slot, which prints as a bare `'&'`-channel atom because the bucket key\n * collapses channel-bearing phase specs (`sel:engaged` and `&:engaged` collide\n * with each other, and the collapse is what made them collide).\n */\nexport function formatConflict(conflict: Conflict): string {\n  const route = formatRoute({\n    phases: [{ channel: '&', phase: conflict.phase === 'any' ? '*' : conflict.phase }],\n    gesture: conflict.gesture,\n    arg: conflict.arg,\n    target: conflict.target,\n    modifiers: conflict.modifiers,\n  });\n  return `${route} — declared by ${conflict.toolIds.join(', ')}`;\n}\n\n/**\n * Detect reachable route conflicts in an assembled tool set and report each one.\n *\n * This is the wiring `findConflicts` spent its first life without: the kit\n * could detect the one class of genuine routing ambiguity it has and never\n * looked. Call it once wherever a tool set is assembled (`useTools` does),\n * behind a `process.env.NODE_ENV !== 'production'` guard.\n *\n * **Warn, never throw.** A conflict between a consumer's tool and a kit tool\n * is a design question — sometimes deliberate, since the loser can still take\n * the gesture by declining through `enabled()` — and exploding in a running\n * app is the wrong way to raise it. A conflict between two *kit* tools is\n * always a bug, but the place to fail on that is the kit's own test suite\n * (`canvas/SceneCanvas.routeConflicts.test.tsx`), not a consumer's console.\n *\n * @returns The conflicts found, so callers can dedupe repeat reports.\n */\nexport function reportRouteConflicts(\n  scopes: ToolScopes,\n  warn: (message: string) => void = (m) => console.warn(m),\n): Conflict[] {\n  const conflicts = findScopedConflicts(scopes);\n  for (const c of conflicts) {\n    warn(\n      `[weasel] route conflict: two bindings declare the same (phase, gesture, arg, target, modifiers) tuple `\n      + `in the same scope, so declaration order alone decides which one fires.\\n  ${formatConflict(c)}`,\n    );\n  }\n  return conflicts;\n}\n"]}

package/dist/chunk-U45SODC2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/units.ts","../src/core/geometry/path.ts","../src/features/paths/bounds.ts","../src/features/paths/flatten.ts","../src/features/paths/hitTest.ts","../src/features/paths/builder.ts","../src/features/paths/transformPath.ts","../src/features/paths/transform.ts","../src/interactions/actions/resize/geometry.ts","../src/features/paths/poseDescriptor.ts","../src/interactions/actions/resize/autoPoseDescriptor.ts","../src/interactions/gestures/shared/strategies/grid.ts","../src/core/viewport/pxExtent.ts","../src/interactions/gestures/shared/strategies/guides.ts"],"names":["ex","ey","COORD_COUNT"],"mappings":"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","file":"chunk-U45SODC2.js","sourcesContent":["/**\n * Units — a tiny customizable unit system for canvas-kit APIs.\n *\n * The kit stores all coordinates as bare numbers in a single base unit\n * chosen by the consumer app. To make API call sites self-documenting,\n * the public surface accepts `UnitValue` — either a bare number (interpreted\n * as base units) or a `{ value, unit }` tag that's resolved against a\n * `UnitSystem` at the API boundary. Internals never see units.\n *\n * Linear factors only. No per-axis units. No mixed-unit arithmetic.\n */\n\n/** A unit name (e.g. `'in'`, `'ft'`, `'mm'`). Looked up in a `UnitSystem`. */\nexport type Unit = string;\n\n/** Conversion table mapping unit names to factors against a base unit. */\nexport interface UnitSystem {\n  /** Name of the base unit, e.g. 'in'. All conversions resolve to this. */\n  base: Unit;\n  /** Factor to multiply a value in `unit` by to get base units. base unit's factor is 1. */\n  units: Record<Unit, number>;\n}\n\n/** Value at a unit-aware API boundary: bare number (in base units) or `{ value, unit }` tag. */\nexport type UnitValue = number | { value: number; unit: Unit };\n\n/**\n * Resolve a UnitValue to a number in base units.\n *  - bare number: returned as-is (assumed base)\n *  - tagged: looks up factor; throws if unit not in unit system\n */\nexport function resolveUnit(v: UnitValue, unitSystem?: UnitSystem): number {\n  if (typeof v === 'number') return v;\n  if (!unitSystem) {\n    throw new Error(\n      `resolveUnit: tagged value { value: ${v.value}, unit: '${v.unit}' } requires a UnitSystem`,\n    );\n  }\n  const factor = unitSystem.units[v.unit];\n  if (factor === undefined) {\n    const known = Object.keys(unitSystem.units).join(', ') || '(none)';\n    throw new Error(\n      `resolveUnit: unknown unit '${v.unit}' (system base: '${unitSystem.base}', known units: ${known})`,\n    );\n  }\n  return v.value * factor;\n}\n\n/**\n * Format a base-unit number as a string in the named display unit.\n *  e.g. formatUnit(36, 'ft', IMPERIAL_INCHES) => '3ft'\n *  Default precision: 2. Trailing zeros trimmed.\n */\nexport function formatUnit(\n  baseValue: number,\n  displayUnit: Unit,\n  unitSystem: UnitSystem,\n  opts?: { precision?: number; suffix?: boolean },\n): string {\n  const factor = unitSystem.units[displayUnit];\n  if (factor === undefined) {\n    const known = Object.keys(unitSystem.units).join(', ') || '(none)';\n    throw new Error(\n      `formatUnit: unknown unit '${displayUnit}' (system base: '${unitSystem.base}', known units: ${known})`,\n    );\n  }\n  const precision = opts?.precision ?? 2;\n  const suffix = opts?.suffix ?? true;\n  const display = baseValue / factor;\n  // Trim trailing zeros (and a dangling decimal point) without losing precision.\n  let s = display.toFixed(precision);\n  if (s.includes('.')) {\n    s = s.replace(/0+$/, '').replace(/\\.$/, '');\n  }\n  return suffix ? `${s}${displayUnit}` : s;\n}\n\n/** Imperial unit system with base 'in'. */\nexport const IMPERIAL_INCHES: UnitSystem = {\n  base: 'in',\n  units: { in: 1, ft: 12, yd: 36, mi: 63360 },\n};\n\n/** Metric unit system with base 'mm'. */\nexport const METRIC_MM: UnitSystem = {\n  base: 'mm',\n  units: { mm: 1, cm: 10, m: 1000, km: 1_000_000 },\n};\n\n/** Pixel unit system — sole unit is the base. */\nexport const PIXELS: UnitSystem = {\n  base: 'px',\n  units: { px: 1 },\n};\n","/**\n * Path data model. Vector-graphics primitive used kit-wide as the canonical\n * shape (replacing per-shape ad-hoc poses). SVG-style command stream so we\n * cover lines, polygons, beziers, and multi-contour shapes (think the inner\n * hole of an \"O\") under one type.\n *\n * Storage: command codes in a `Uint8Array`, parameters in a `Float32Array`.\n * Each command consumes a fixed number of float coords from the parameter\n * array; the parser walks both arrays in lockstep. This keeps interaction\n * hot loops monomorphic and keeps GC pressure low under heavy edits.\n *\n * Two path subtypes are distinguished at the type level so common-case\n * machinery (selection AABBs, area-select intersection, hit-testing rect\n * silhouettes) can short-circuit on `RectPath` without paying the polygon\n * kernel cost. Polymorphic kernels accept either via the `Path` union and\n * dispatch on `kind`.\n */\n\n/** Command code: moveTo. */\nexport const PATH_M = 0;\n/** Command code: lineTo. */\nexport const PATH_L = 1;\n/** Command code: cubic bezier (`bezierCurveTo`). */\nexport const PATH_C = 2;\n/** Command code: quadratic bezier (`quadraticCurveTo`). */\nexport const PATH_Q = 3;\n/** Command code: close subpath. */\nexport const PATH_Z = 4;\n\n/** Float coords consumed by each command, indexed by command code. */\nexport const PATH_CMD_LENGTHS: readonly number[] = [2, 2, 6, 4, 0];\n\n/** Fill rule used by polygon path hit-testing and `ctx.fill()`. */\nexport type PathFillRule = 'nonzero' | 'evenodd';\n\n/**\n * Polygon path with arbitrary contours and optional bezier segments.\n * Multi-contour: each `M` opens a new subpath; `Z` closes the current one.\n * Open subpaths (no `Z`) render as polylines and don't contribute to fills.\n */\nexport interface PolygonPath {\n  kind: 'polygon';\n  commands: Uint8Array;\n  coords: Float32Array;\n  fillRule: PathFillRule;\n}\n\n/**\n * Axis-aligned rectangle. Fast path for the (very common) case where the\n * shape is just a rect — preserves O(1) bounds and hit-test, avoids the\n * polygon kernel entirely. Promote to `PolygonPath` only when the shape\n * grows beyond what a rect can express.\n */\nexport interface RectPath {\n  kind: 'rect';\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n}\n\n/** Canonical path shape — either an axis-aligned rect (fast path) or a polygon command stream. */\nexport type Path = PolygonPath | RectPath;\n","/**\n * AABB bounds of a `Path`. Returned as `RectPath` for direct reuse with the\n * rect fast path machinery (selection AABB, area-select intersection).\n *\n * `RectPath` is its own bounds — O(1). For `PolygonPath`, walk segment by\n * segment, computing the tight bound per segment:\n *\n *   - `M` / `L`: just the endpoint.\n *   - `Q`: quadratic Bezier — endpoints plus axis-aligned extrema (one\n *     possible inflection per axis).\n *   - `C`: cubic Bezier — endpoints plus axis-aligned extrema (up to two\n *     possible inflections per axis, found via the quadratic formula on\n *     the derivative).\n *\n * Control points are NOT included directly; they're used only to compute\n * extrema that actually lie on the curve. This avoids the classic \"AABB\n * extends past where the curve visibly reaches\" bug for curved paths whose\n * control points poke outside the visible extent.\n *\n * Empty paths (no commands) return a zero-size rect anchored at the\n * origin — the convention used elsewhere in the kit for missing geometry.\n */\n\nimport { cubicBounds, elevateQuadraticToCubic } from '@weasel-js/geom';\nimport {\n  PATH_C,\n  PATH_L,\n  PATH_M,\n  PATH_Q,\n  PATH_Z,\n  type Path,\n  type RectPath,\n} from './types';\n\n/** AABB of a `Path`, returned as a `RectPath` for direct reuse with rect-fast-path machinery. */\nexport function boundsOfPath(path: Path): RectPath {\n  if (path.kind === 'rect') return path;\n\n  const { commands, coords } = path;\n  if (commands.length === 0) {\n    return { kind: 'rect', x: 0, y: 0, width: 0, height: 0 };\n  }\n\n  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;\n  let ci = 0;\n  let seen = false;\n  // Pen position carried across segments — needed because curves are\n  // defined relative to the previous endpoint, which is itself the start\n  // of the next segment but not re-encoded in `coords`.\n  let px = 0, py = 0;\n\n  const include = (x: number, y: number) => {\n    if (x < minX) minX = x;\n    if (x > maxX) maxX = x;\n    if (y < minY) minY = y;\n    if (y > maxY) maxY = y;\n    seen = true;\n  };\n\n  for (let i = 0; i < commands.length; i++) {\n    const cmd = commands[i];\n    switch (cmd) {\n      case PATH_M:\n      case PATH_L: {\n        const x = coords[ci], y = coords[ci + 1];\n        include(x, y);\n        px = x; py = y;\n        ci += 2;\n        break;\n      }\n      case PATH_C: {\n        const x1 = coords[ci],     y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        const x3 = coords[ci + 4], y3 = coords[ci + 5];\n        const [bMinX, bMinY, bMaxX, bMaxY] = cubicBounds(px, py, x1, y1, x2, y2, x3, y3);\n        include(bMinX, bMinY);\n        include(bMaxX, bMaxY);\n        px = x3; py = y3;\n        ci += 6;\n        break;\n      }\n      case PATH_Q: {\n        const qx1 = coords[ci],     qy1 = coords[ci + 1];\n        const qx2 = coords[ci + 2], qy2 = coords[ci + 3];\n        const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(px, py, qx1, qy1, qx2, qy2);\n        const [bMinX, bMinY, bMaxX, bMaxY] = cubicBounds(px, py, c1x, c1y, c2x, c2y, qx2, qy2);\n        include(bMinX, bMinY);\n        include(bMaxX, bMaxY);\n        px = qx2; py = qy2;\n        ci += 4;\n        break;\n      }\n      case PATH_Z:\n        break;\n      default:\n        throw new Error(`boundsOfPath: unknown command ${cmd}`);\n    }\n  }\n\n  if (!seen) return { kind: 'rect', x: 0, y: 0, width: 0, height: 0 };\n  return { kind: 'rect', x: minX, y: minY, width: maxX - minX, height: maxY - minY };\n}\n\n","/**\n * Bezier flattening — subdivide cubic and quadratic segments into polyline\n * approximations within a flatness tolerance. Used by hit-testing and\n * (eventually) any kernel that doesn't want to special-case curves.\n *\n * The flatness metric is the maximum perpendicular distance from any\n * control point to the chord between endpoints. When that distance falls\n * below `tolerance`, the segment is \"flat enough\" and emitted as a single\n * line segment.\n *\n * Tolerance is in world units. 0.5 is a sensible default for screen-rate\n * rendering at 1× zoom; consumers that zoom in heavily should pass a\n * tighter tolerance.\n */\n\nexport const DEFAULT_FLATTEN_TOLERANCE = 0.5;\n\n/** Distance from point P to line AB (perpendicular). */\nfunction distPointToLine(px: number, py: number, ax: number, ay: number, bx: number, by: number): number {\n  const dx = bx - ax;\n  const dy = by - ay;\n  const len2 = dx * dx + dy * dy;\n  if (len2 === 0) {\n    const ex = px - ax;\n    const ey = py - ay;\n    return Math.sqrt(ex * ex + ey * ey);\n  }\n  const cross = (px - ax) * dy - (py - ay) * dx;\n  return Math.abs(cross) / Math.sqrt(len2);\n}\n\n/**\n * Recursively subdivide a cubic bezier (P0..P3) and append `lineTo`-style\n * vertices to `out` (interleaved x,y). The starting endpoint is *not*\n * appended — callers usually emitted it as the segment's previous vertex.\n */\nexport function flattenCubic(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  x3: number, y3: number,\n  tolerance: number,\n  out: number[],\n): void {\n  const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);\n  const d2 = distPointToLine(x2, y2, x0, y0, x3, y3);\n  if (Math.max(d1, d2) <= tolerance) {\n    out.push(x3, y3);\n    return;\n  }\n  // De Casteljau split at t=0.5\n  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;\n  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;\n  const x23 = (x2 + x3) * 0.5, y23 = (y2 + y3) * 0.5;\n  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;\n  const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;\n  const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;\n  flattenCubic(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out);\n  flattenCubic(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out);\n}\n\n/** Recursively subdivide a quadratic bezier (P0, P1, P2). */\nexport function flattenQuadratic(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  tolerance: number,\n  out: number[],\n): void {\n  const d = distPointToLine(x1, y1, x0, y0, x2, y2);\n  if (d <= tolerance) {\n    out.push(x2, y2);\n    return;\n  }\n  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;\n  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;\n  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;\n  flattenQuadratic(x0, y0, x01, y01, x012, y012, tolerance, out);\n  flattenQuadratic(x012, y012, x12, y12, x2, y2, tolerance, out);\n}\n\n/**\n * Like `flattenCubic` but also appends, for each new flattened point, its\n * arc-length fraction `t` (relative to the polyline distance accumulated so\n * far inside this curve) to `arcOut`. Caller then post-processes the segment's\n * `arcOut` range by dividing each by the segment's total flattened arc length\n * to yield t ∈ (0, 1].\n *\n * The returned values are *cumulative distance from the segment start*, not\n * normalized fractions. Two-pass design (accumulate, then divide) keeps the\n * recursive splitter simple — it doesn't need to know the total length up\n * front.\n */\nexport function flattenCubicWithArcLen(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  x3: number, y3: number,\n  tolerance: number,\n  out: number[],\n  arcOut: number[],\n): number {\n  return flattenCubicArcRec(x0, y0, x1, y1, x2, y2, x3, y3, tolerance, out, arcOut, 0);\n}\n\nfunction flattenCubicArcRec(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  x3: number, y3: number,\n  tolerance: number,\n  out: number[],\n  arcOut: number[],\n  accum: number,\n): number {\n  const d1 = distPointToLine(x1, y1, x0, y0, x3, y3);\n  const d2 = distPointToLine(x2, y2, x0, y0, x3, y3);\n  if (Math.max(d1, d2) <= tolerance) {\n    const lastX = out.length >= 2 ? out[out.length - 2] : x0;\n    const lastY = out.length >= 2 ? out[out.length - 1] : y0;\n    const seg = Math.hypot(x3 - lastX, y3 - lastY);\n    accum += seg;\n    out.push(x3, y3);\n    arcOut.push(accum);\n    return accum;\n  }\n  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;\n  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;\n  const x23 = (x2 + x3) * 0.5, y23 = (y2 + y3) * 0.5;\n  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;\n  const x123 = (x12 + x23) * 0.5, y123 = (y12 + y23) * 0.5;\n  const x0123 = (x012 + x123) * 0.5, y0123 = (y012 + y123) * 0.5;\n  accum = flattenCubicArcRec(x0, y0, x01, y01, x012, y012, x0123, y0123, tolerance, out, arcOut, accum);\n  accum = flattenCubicArcRec(x0123, y0123, x123, y123, x23, y23, x3, y3, tolerance, out, arcOut, accum);\n  return accum;\n}\n\n/** Flatten a quadratic bezier into line segments within `tolerance`, appending\n *  points to `out` and their cumulative arc lengths to `arcOut`. The arc\n *  lengths are what lets per-anchor color and dash phase be interpolated\n *  evenly along the curve rather than per segment. */\nexport function flattenQuadraticWithArcLen(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  tolerance: number,\n  out: number[],\n  arcOut: number[],\n): number {\n  return flattenQuadraticArcRec(x0, y0, x1, y1, x2, y2, tolerance, out, arcOut, 0);\n}\n\nfunction flattenQuadraticArcRec(\n  x0: number, y0: number,\n  x1: number, y1: number,\n  x2: number, y2: number,\n  tolerance: number,\n  out: number[],\n  arcOut: number[],\n  accum: number,\n): number {\n  const d = distPointToLine(x1, y1, x0, y0, x2, y2);\n  if (d <= tolerance) {\n    const lastX = out.length >= 2 ? out[out.length - 2] : x0;\n    const lastY = out.length >= 2 ? out[out.length - 1] : y0;\n    const seg = Math.hypot(x2 - lastX, y2 - lastY);\n    accum += seg;\n    out.push(x2, y2);\n    arcOut.push(accum);\n    return accum;\n  }\n  const x01 = (x0 + x1) * 0.5, y01 = (y0 + y1) * 0.5;\n  const x12 = (x1 + x2) * 0.5, y12 = (y1 + y2) * 0.5;\n  const x012 = (x01 + x12) * 0.5, y012 = (y01 + y12) * 0.5;\n  accum = flattenQuadraticArcRec(x0, y0, x01, y01, x012, y012, tolerance, out, arcOut, accum);\n  accum = flattenQuadraticArcRec(x012, y012, x12, y12, x2, y2, tolerance, out, arcOut, accum);\n  return accum;\n}\n\n","/**\n * Point-in-path hit-testing. `RectPath` short-circuits to AABB compare\n * (O(1)). `PolygonPath` walks the command stream, flattening any bezier\n * segments to line segments, then runs ray-casting (even-odd) or\n * winding-number (non-zero) per the path's `fillRule`.\n *\n * Open subpaths (no `Z`) are skipped for filled hit-testing — they have\n * no enclosed area. For open polylines (strokes), use `strokeHitTest`\n * which computes point-to-segment distance against the flattened\n * polyline and returns true within a configurable threshold.\n */\n\nimport { flattenCubic, flattenQuadratic, DEFAULT_FLATTEN_TOLERANCE } from './flatten';\nimport {\n  PATH_C,\n  PATH_L,\n  PATH_M,\n  PATH_Q,\n  PATH_Z,\n  type Path,\n  type PolygonPath,\n} from './types';\n\n/** Options for `pointInPath`. */\nexport interface PointInPathOptions {\n  /** Bezier flattening tolerance in world units. Default 0.5. */\n  tolerance?: number;\n}\n\n/** Filled-region hit-test for a `Path`. Rect short-circuits to AABB; polygons run ray-cast / winding per `fillRule`. */\nexport function pointInPath(\n  path: Path,\n  x: number,\n  y: number,\n  opts: PointInPathOptions = {},\n): boolean {\n  if (path.kind === 'rect') {\n    return x >= path.x && x <= path.x + path.width && y >= path.y && y <= path.y + path.height;\n  }\n  return pointInPolygonPath(path, x, y, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);\n}\n\nfunction pointInPolygonPath(path: PolygonPath, x: number, y: number, tolerance: number): boolean {\n  const { commands, coords, fillRule } = path;\n  if (commands.length === 0) return false;\n\n  // Walk the command stream; flatten beziers into per-subpath vertex arrays.\n  // For each closed subpath, accumulate winding/crossings against (x, y).\n  let crossings = 0;\n  let winding = 0;\n\n  let subStartX = 0, subStartY = 0;\n  let curX = 0, curY = 0;\n  let subVerts: number[] = []; // flat [x, y, x, y, ...] for current subpath\n  let subOpen = false;\n\n  const flushSubpath = (closed: boolean) => {\n    if (closed && subVerts.length >= 4) {\n      // Close the subpath back to its start.\n      subVerts.push(subStartX, subStartY);\n      // Now subVerts is a closed polyline; tally crossings/winding.\n      for (let i = 0; i < subVerts.length - 2; i += 2) {\n        const ax = subVerts[i],     ay = subVerts[i + 1];\n        const bx = subVerts[i + 2], by = subVerts[i + 3];\n        if (segmentCrossesRayRight(x, y, ax, ay, bx, by)) {\n          crossings++;\n          if (ay <= y && by > y) winding++;\n          else if (by <= y && ay > y) winding--;\n        }\n      }\n    }\n    subVerts = [];\n    subOpen = false;\n  };\n\n  let ci = 0;\n  for (let i = 0; i < commands.length; i++) {\n    const cmd = commands[i];\n    switch (cmd) {\n      case PATH_M: {\n        if (subOpen) flushSubpath(false);\n        subStartX = coords[ci]; subStartY = coords[ci + 1];\n        curX = subStartX; curY = subStartY;\n        subVerts.push(curX, curY);\n        subOpen = true;\n        ci += 2;\n        break;\n      }\n      case PATH_L: {\n        curX = coords[ci]; curY = coords[ci + 1];\n        subVerts.push(curX, curY);\n        ci += 2;\n        break;\n      }\n      case PATH_C: {\n        const x1 = coords[ci],     y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        const x3 = coords[ci + 4], y3 = coords[ci + 5];\n        flattenCubic(curX, curY, x1, y1, x2, y2, x3, y3, tolerance, subVerts);\n        curX = x3; curY = y3;\n        ci += 6;\n        break;\n      }\n      case PATH_Q: {\n        const x1 = coords[ci],     y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        flattenQuadratic(curX, curY, x1, y1, x2, y2, tolerance, subVerts);\n        curX = x2; curY = y2;\n        ci += 4;\n        break;\n      }\n      case PATH_Z: {\n        flushSubpath(true);\n        curX = subStartX; curY = subStartY;\n        break;\n      }\n      default:\n        throw new Error(`pointInPath: unknown command ${cmd}`);\n    }\n  }\n  if (subOpen) flushSubpath(false);\n\n  return fillRule === 'evenodd' ? (crossings & 1) === 1 : winding !== 0;\n}\n\n/**\n * Does the rightward horizontal ray from (x, y) cross segment (ax,ay)→(bx,by)?\n * Standard half-open rule (segments touching from above count, from below\n * don't) — avoids double-counting at shared vertices.\n */\nfunction segmentCrossesRayRight(\n  x: number, y: number,\n  ax: number, ay: number,\n  bx: number, by: number,\n): boolean {\n  if ((ay > y) === (by > y)) return false;\n  const xCross = ax + ((y - ay) / (by - ay)) * (bx - ax);\n  return x < xCross;\n}\n\n/** Options for {@link strokeHitTest}. */\nexport interface StrokeHitTestOptions {\n  /** Bezier flattening tolerance in world units. Default 0.5. */\n  tolerance?: number;\n}\n\n/**\n * Stroke-distance hit-test. Returns true when (x, y) lies within\n * `threshold` world units of the path's outline — i.e. when a stroke\n * of total width `2 * threshold` drawn along the path would cover the\n * point.\n *\n * Works for both closed and open subpaths — unlike {@link pointInPath},\n * which only tests filled regions. Use this for picking on open\n * polylines / curves and for adding stroke-clickability to closed\n * shapes (logical OR with `pointInPath` when both behaviors are\n * desired).\n *\n * `threshold` is typically the stroke's half-width plus a small slop\n * (e.g. `strokeWidth / 2 + 4`). Cap segments are approximated by the\n * threshold radius around each anchor — the test treats every flattened\n * segment as a capsule of width `2 * threshold`.\n */\nexport function strokeHitTest(\n  path: Path,\n  x: number,\n  y: number,\n  threshold: number,\n  opts: StrokeHitTestOptions = {},\n): boolean {\n  const t2 = threshold * threshold;\n  if (path.kind === 'rect') {\n    const { x: rx, y: ry, width: w, height: h } = path;\n    return (\n      pointSegmentDist2(x, y, rx, ry, rx + w, ry) <= t2\n      || pointSegmentDist2(x, y, rx + w, ry, rx + w, ry + h) <= t2\n      || pointSegmentDist2(x, y, rx + w, ry + h, rx, ry + h) <= t2\n      || pointSegmentDist2(x, y, rx, ry + h, rx, ry) <= t2\n    );\n  }\n  return polylineWithinThreshold(path, x, y, t2, opts.tolerance ?? DEFAULT_FLATTEN_TOLERANCE);\n}\n\nfunction polylineWithinThreshold(\n  path: PolygonPath,\n  px: number, py: number,\n  t2: number,\n  tolerance: number,\n): boolean {\n  const { commands, coords } = path;\n  if (commands.length === 0) return false;\n\n  // Reuse pointInPath's command-stream + flatten walk; check distance from\n  // (px, py) to each emitted segment instead of accumulating crossings.\n  let subStartX = 0, subStartY = 0;\n  let curX = 0, curY = 0;\n  let subVerts: number[] = [];\n  let subOpen = false;\n\n  const checkSegments = (closed: boolean): boolean => {\n    if (closed && subVerts.length >= 4) subVerts.push(subStartX, subStartY);\n    for (let i = 0; i < subVerts.length - 2; i += 2) {\n      if (pointSegmentDist2(px, py, subVerts[i], subVerts[i + 1], subVerts[i + 2], subVerts[i + 3]) <= t2) {\n        return true;\n      }\n    }\n    return false;\n  };\n\n  let ci = 0;\n  for (let i = 0; i < commands.length; i++) {\n    const cmd = commands[i];\n    switch (cmd) {\n      case PATH_M: {\n        if (subOpen) {\n          if (checkSegments(false)) return true;\n          subVerts = [];\n        }\n        subStartX = coords[ci]; subStartY = coords[ci + 1];\n        curX = subStartX; curY = subStartY;\n        subVerts.push(curX, curY);\n        subOpen = true;\n        ci += 2;\n        break;\n      }\n      case PATH_L: {\n        curX = coords[ci]; curY = coords[ci + 1];\n        subVerts.push(curX, curY);\n        ci += 2;\n        break;\n      }\n      case PATH_C: {\n        const x1 = coords[ci],     y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        const x3 = coords[ci + 4], y3 = coords[ci + 5];\n        flattenCubic(curX, curY, x1, y1, x2, y2, x3, y3, tolerance, subVerts);\n        curX = x3; curY = y3;\n        ci += 6;\n        break;\n      }\n      case PATH_Q: {\n        const x1 = coords[ci],     y1 = coords[ci + 1];\n        const x2 = coords[ci + 2], y2 = coords[ci + 3];\n        flattenQuadratic(curX, curY, x1, y1, x2, y2, tolerance, subVerts);\n        curX = x2; curY = y2;\n        ci += 4;\n        break;\n      }\n      case PATH_Z: {\n        if (checkSegments(true)) return true;\n        subVerts = [];\n        subOpen = false;\n        curX = subStartX; curY = subStartY;\n        break;\n      }\n      default:\n        throw new Error(`strokeHitTest: unknown command ${cmd}`);\n    }\n  }\n  if (subOpen && checkSegments(false)) return true;\n  return false;\n}\n\n/** Squared distance from (px, py) to the closest point on segment (ax,ay)→(bx,by). */\nfunction pointSegmentDist2(\n  px: number, py: number,\n  ax: number, ay: number,\n  bx: number, by: number,\n): number {\n  const dx = bx - ax;\n  const dy = by - ay;\n  const len2 = dx * dx + dy * dy;\n  if (len2 === 0) {\n    const ex = px - ax, ey = py - ay;\n    return ex * ex + ey * ey;\n  }\n  let t = ((px - ax) * dx + (py - ay) * dy) / len2;\n  if (t < 0) t = 0; else if (t > 1) t = 1;\n  const cx = ax + t * dx;\n  const cy = ay + t * dy;\n  const ex = px - cx, ey = py - cy;\n  return ex * ex + ey * ey;\n}\n","/**\n * Fluent builder for `PolygonPath`. Hides the `Uint8Array` / `Float32Array`\n * encoding behind move/line/curve/close calls and a final `build()`. Use\n * this to construct paths in tests and demos; production callers that need\n * to mutate large paths in place should reach for the raw arrays directly.\n *\n * Numeric capacity grows by doubling — typical for amortized O(1) push.\n *\n * Also exposes `rectPath` / `polygonFromPoints` shortcuts for the common\n * cases. `rectPath` returns the lighter `RectPath` subtype, not a polygon.\n */\n\nimport {\n  PATH_C,\n  PATH_L,\n  PATH_M,\n  PATH_Q,\n  PATH_Z,\n  type PathFillRule,\n  type PolygonPath,\n  type RectPath,\n} from './types';\n\n/** Fluent builder for `PolygonPath`; hides the `Uint8Array`/`Float32Array` encoding behind move/line/curve/close calls. */\nexport class PathBuilder {\n  private cmds: number[] = [];\n  private xs: number[] = [];\n  private fillRule: PathFillRule = 'nonzero';\n\n  /** Seed a builder with an existing `PolygonPath`. Useful for extending\n   *  an in-flight path with another segment (e.g. appending a cubic to\n   *  the end of a curve in response to a user action) without hand-\n   *  reaching into the `commands` / `coords` typed arrays.\n   *\n   *  ```ts\n   *  const next = PathBuilder.fromPath(current).curveTo(...).build();\n   *  ```\n   */\n  static fromPath(path: PolygonPath): PathBuilder {\n    const b = new PathBuilder();\n    b.cmds = Array.from(path.commands);\n    b.xs = Array.from(path.coords);\n    b.fillRule = path.fillRule;\n    return b;\n  }\n\n  setFillRule(rule: PathFillRule): this {\n    this.fillRule = rule;\n    return this;\n  }\n\n  moveTo(x: number, y: number): this {\n    this.cmds.push(PATH_M);\n    this.xs.push(x, y);\n    return this;\n  }\n\n  lineTo(x: number, y: number): this {\n    this.cmds.push(PATH_L);\n    this.xs.push(x, y);\n    return this;\n  }\n\n  /** Cubic bezier to (x, y) with control points (x1, y1) and (x2, y2). */\n  curveTo(x1: number, y1: number, x2: number, y2: number, x: number, y: number): this {\n    this.cmds.push(PATH_C);\n    this.xs.push(x1, y1, x2, y2, x, y);\n    return this;\n  }\n\n  /** Quadratic bezier to (x, y) with control point (x1, y1). */\n  quadTo(x1: number, y1: number, x: number, y: number): this {\n    this.cmds.push(PATH_Q);\n    this.xs.push(x1, y1, x, y);\n    return this;\n  }\n\n  close(): this {\n    this.cmds.push(PATH_Z);\n    return this;\n  }\n\n  build(): PolygonPath {\n    return {\n      kind: 'polygon',\n      commands: new Uint8Array(this.cmds),\n      coords: new Float32Array(this.xs),\n      fillRule: this.fillRule,\n    };\n  }\n}\n\n/** Construct a `RectPath` (the fast-path subtype). */\nexport function rectPath(x: number, y: number, width: number, height: number): RectPath {\n  return { kind: 'rect', x, y, width, height };\n}\n\n/** Build a closed polygon from a flat list of points. */\nexport function polygonFromPoints(\n  points: readonly { x: number; y: number }[],\n  opts: { fillRule?: PathFillRule } = {},\n): PolygonPath {\n  if (points.length === 0) {\n    return {\n      kind: 'polygon',\n      commands: new Uint8Array(),\n      coords: new Float32Array(),\n      fillRule: opts.fillRule ?? 'nonzero',\n    };\n  }\n  const b = new PathBuilder();\n  if (opts.fillRule) b.setFillRule(opts.fillRule);\n  b.moveTo(points[0].x, points[0].y);\n  for (let i = 1; i < points.length; i++) b.lineTo(points[i].x, points[i].y);\n  b.close();\n  return b.build();\n}\n\n/** Cubic-Bezier kappa for circular-quadrant approximation (<1% max error). */\nconst ELLIPSE_KAPPA = 0.5522847498307936;\n\n/** Closed ellipse inscribed in `bounds`, as a 4-cubic-Bezier `PolygonPath`.\n *  Matches the geometry `useEllipseTool`'s overlay paints. */\nexport function ellipsePath(\n  bounds: { x: number; y: number; width: number; height: number },\n): PolygonPath {\n  const cx = bounds.x + bounds.width / 2;\n  const cy = bounds.y + bounds.height / 2;\n  const rx = bounds.width / 2;\n  const ry = bounds.height / 2;\n  const ox = rx * ELLIPSE_KAPPA;\n  const oy = ry * ELLIPSE_KAPPA;\n  const b = new PathBuilder();\n  b.moveTo(cx + rx, cy);\n  b.curveTo(cx + rx, cy + oy, cx + ox, cy + ry, cx, cy + ry);\n  b.curveTo(cx - ox, cy + ry, cx - rx, cy + oy, cx - rx, cy);\n  b.curveTo(cx - rx, cy - oy, cx - ox, cy - ry, cx, cy - ry);\n  b.curveTo(cx + ox, cy - ry, cx + rx, cy - oy, cx + rx, cy);\n  b.close();\n  return b.build();\n}\n\n/** Closed regular n-gon centered at `center`, circumscribed by `radius`.\n *  `rotation` is in radians; default 0 puts the first vertex on the +x axis. */\nexport function regularPolygonPath(\n  center: { x: number; y: number },\n  radius: number,\n  sides: number,\n  rotation = 0,\n): PolygonPath {\n  const b = new PathBuilder();\n  for (let i = 0; i < sides; i++) {\n    const a = rotation + (i / sides) * Math.PI * 2;\n    const x = center.x + radius * Math.cos(a);\n    const y = center.y + radius * Math.sin(a);\n    if (i === 0) b.moveTo(x, y); else b.lineTo(x, y);\n  }\n  b.close();\n  return b.build();\n}\n\n/** Closed n-pointed star centered at `center`, alternating `outerRadius` and\n *  `innerRadius` (default `outerRadius / 2`). `rotation` is in radians. */\nexport function starPath(\n  center: { x: number; y: number },\n  outerRadius: number,\n  points = 5,\n  innerRadius: number = outerRadius / 2,\n  rotation = 0,\n): PolygonPath {\n  const b = new PathBuilder();\n  const n = points * 2;\n  for (let i = 0; i < n; i++) {\n    const a = rotation + (i / n) * Math.PI * 2;\n    const r = i % 2 === 0 ? outerRadius : innerRadius;\n    const x = center.x + r * Math.cos(a);\n    const y = center.y + r * Math.sin(a);\n    if (i === 0) b.moveTo(x, y); else b.lineTo(x, y);\n  }\n  b.close();\n  return b.build();\n}\n\n/** Open 2-vertex polyline from `a` to `b` — strokeable, not fillable. */\nexport function linePath(\n  a: { x: number; y: number },\n  b: { x: number; y: number },\n): PolygonPath {\n  const pb = new PathBuilder();\n  pb.moveTo(a.x, a.y);\n  pb.lineTo(b.x, b.y);\n  return pb.build();\n}\n","import { type Mat3, transformCoords } from '@weasel-js/geom';\nimport { PathBuilder } from './builder';\nimport { type Path, type PolygonPath } from './types';\n\n/** Apply an affine `Mat3` to a path's geometry.\n *\n * Axis-aligned maps (no rotation/shear, i.e. `m[1] === 0 && m[2] === 0`) keep a\n * `RectPath` a rect — the four corners stay axis-aligned, so we transform the\n * two diagonal corners and normalize negative extent (mirror). Rotation or\n * shear promotes the rect's four corners to a `PolygonPath`. Polygon paths map\n * every coord via the kernel's `transformCoords`, preserving the command stream\n * and `fillRule`. Never mutates the input.\n *\n * `Mat3` here is the 6-tuple `number[]` from `@weasel-js/geom` (DOMMatrix order:\n * `[a, b, c, d, e, f]` where `x' = a·x + c·y + e`, `y' = b·x + d·y + f`),\n * not the renderer's 9-element `Float32Array`. */\nexport function transformPath(path: Path, m: Mat3): Path {\n  const [a, b, c, d, e, f] = m;\n  if (path.kind === 'rect') {\n    if (b === 0 && c === 0) {\n      // Pure scale + translate — corners remain axis-aligned.\n      const x0 = a * path.x + e;\n      const y0 = d * path.y + f;\n      const x1 = a * (path.x + path.width) + e;\n      const y1 = d * (path.y + path.height) + f;\n      return {\n        kind: 'rect',\n        x: Math.min(x0, x1),\n        y: Math.min(y0, y1),\n        width: Math.abs(x1 - x0),\n        height: Math.abs(y1 - y0),\n      };\n    }\n    // Rotation / shear — promote to polygon with the four rect corners.\n    const poly = new PathBuilder()\n      .moveTo(path.x, path.y)\n      .lineTo(path.x + path.width, path.y)\n      .lineTo(path.x + path.width, path.y + path.height)\n      .lineTo(path.x, path.y + path.height)\n      .close()\n      .build();\n    return transformPolygon(poly, m);\n  }\n  return transformPolygon(path, m);\n}\n\nfunction transformPolygon(path: PolygonPath, m: Mat3): PolygonPath {\n  // transformCoords returns Float64Array; PolygonPath.coords is Float32Array.\n  const mapped = transformCoords(path.coords, m);\n  return { ...path, coords: Float32Array.from(mapped) };\n}\n","/**\n * In-place and copy-out path transforms. Translation is the most common —\n * called every pointermove during a drag — so the polygon variant mutates\n * the float buffer directly to keep allocation pressure off the GC.\n *\n * `scalePathToBounds` is for the resize interaction: given the path's\n * current AABB and the desired new AABB, scales every coordinate\n * proportionally. Degenerate source bounds (zero width/height) collapse\n * the corresponding axis to the new origin — preferable to dividing by\n * zero or refusing to resize.\n */\n\nimport { boxToBox } from '@weasel-js/geom';\nimport { boundsOfPath } from './bounds';\nimport { transformPath } from './transformPath';\nimport { PATH_C, PATH_L, PATH_M, PATH_Q, PATH_Z, type Path, type PolygonPath, type RectPath } from './types';\n\n/**\n * Translate a path by (dx, dy). Returns a new instance — the kit's pose\n * model treats poses as immutable to keep React state-update semantics\n * predictable. Polygon coords are copied into a fresh `Float32Array`.\n */\nexport function translatePath(path: Path, dx: number, dy: number): Path {\n  if (path.kind === 'rect') {\n    return { kind: 'rect', x: path.x + dx, y: path.y + dy, width: path.width, height: path.height };\n  }\n  return translatePolygonCopy(path, dx, dy);\n}\n\nfunction translatePolygonCopy(path: PolygonPath, dx: number, dy: number): PolygonPath {\n  const next = new Float32Array(path.coords.length);\n  const { commands, coords } = path;\n  let ci = 0;\n  for (let i = 0; i < commands.length; i++) {\n    const len = COORD_COUNT[commands[i]];\n    for (let k = 0; k < len; k += 2) {\n      next[ci + k] = coords[ci + k] + dx;\n      next[ci + k + 1] = coords[ci + k + 1] + dy;\n    }\n    ci += len;\n  }\n  return { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\n}\n\n/**\n * Translate a polygon path's coords *in place*. Returns the same\n * `PolygonPath` reference. Use only for transient overlay buffers — never\n * for committed scene state, which must remain immutable for React.\n */\nexport function translatePolygonInPlace(path: PolygonPath, dx: number, dy: number): PolygonPath {\n  const { commands, coords } = path;\n  let ci = 0;\n  for (let i = 0; i < commands.length; i++) {\n    const len = COORD_COUNT[commands[i]];\n    for (let k = 0; k < len; k += 2) {\n      coords[ci + k] += dx;\n      coords[ci + k + 1] += dy;\n    }\n    ci += len;\n  }\n  return path;\n}\n\n/**\n * Scale a path's coords so its current AABB maps to `target`. Resize\n * interactions use this to make a polygon follow a corner-handle drag.\n *\n * Degenerate source axes (width or height == 0) collapse to `target.x` /\n * `target.y` — every coord on that axis becomes the new origin. Avoids\n * division by zero without throwing.\n */\nexport function scalePathToBounds(path: Path, target: RectPath): Path {\n  if (path.kind === 'rect') {\n    return { kind: 'rect', x: target.x, y: target.y, width: target.width, height: target.height };\n  }\n  const src = boundsOfPath(path);\n  return scalePolygon(path, src, target);\n}\n\nfunction scalePolygon(path: PolygonPath, src: RectPath, dst: RectPath): PolygonPath {\n  const m = boxToBox(src.x, src.y, src.width, src.height, dst.x, dst.y, dst.width, dst.height);\n  // src/dst are axis-aligned, so the polygon stays a polygon after this pure scale+translate.\n  return transformPath(path, m) as PolygonPath;\n}\n\nconst COORD_COUNT: Readonly<Record<number, number>> = {\n  [PATH_M]: 2,\n  [PATH_L]: 2,\n  [PATH_C]: 6,\n  [PATH_Q]: 4,\n  [PATH_Z]: 0,\n};\n","import type { ResizePose, RotatedPose } from '../../gestures/types';\n\n/**\n * Bridges arbitrary `TPose` shapes into the resize hook's bounds-driven math.\n * The hook reads bounds via `getBounds`, runs anchor-relative math on those\n * bounds, then asks `remapBounds` to project the result back into TPose.\n *\n * `remapBounds(pose, src, dst)` is a single operation that subsumes both\n * \"set my own AABB to dst\" (single-leaf resize) and \"scale me as a leaf\n * inside parent's src→dst rect\" (group resize) — they're the same affine\n * map. For rect-shaped poses the default geometry interprets the pose as\n * its own bounds; for Path or polygon poses the consumer supplies a\n * projection that knows how to read and rewrite the underlying geometry.\n */\nexport interface PoseProjection<TPose> {\n  getBounds(pose: TPose): ResizePose;\n  remapBounds(pose: TPose, src: ResizePose, dst: ResizePose): TPose;\n  /** Translate the pose by (dx, dy). Optional — when omitted, callers fall\n   *  back to a translation derived from `remapBounds` (origin shifted, no\n   *  scale). Path-shaped poses should provide this for performance. */\n  translate?(pose: TPose, dx: number, dy: number): TPose;\n  /** True iff any portion of the pose's geometry intersects `rect`. Optional\n   *  — when omitted, area-select and similar callers test against `getBounds`\n   *  AABB (looser, but correct for axis-aligned rect poses). */\n  intersectsRect?(pose: TPose, rect: ResizePose): boolean;\n  /** Interpolate between two poses. Optional — animation helpers fall back to\n   *  rect-shape lerp when omitted (which fails for non-rect poses). */\n  lerp?(a: TPose, b: TPose, t: number): TPose;\n  /** Read the pose's rotation in radians. Pivot is the AABB center\n   *  (`getBounds(pose)` center). Default 0 when omitted — descriptor\n   *  declares \"this pose has no rotation.\" When supplied and non-zero,\n   *  `useResize` projects the drag delta into the leaf's local frame,\n   *  runs anchor math there, and translates the resulting pose so the\n   *  diagonally opposite world-space corner is pinned. */\n  getRotation?(pose: TPose): number;\n  /** True iff this pose shape can carry a rotation. Consulted by the\n   *  rotation affordance to decide whether to render the rotate cursor /\n   *  drag-band over a selection. When omitted, the kit assumes `true` for\n   *  back-compat — descriptors whose poses lack `x/y/width/height/rotation`\n   *  fields (e.g. polygon Paths) should return `false` so the affordance\n   *  hides instead of exposing a non-functional rotate cursor. */\n  supportsRotation?(pose: TPose): boolean;\n}\n\n/** AABB-vs-AABB overlap. Exported for callers building a default\n *  `intersectsRect` from `getBounds`. */\nexport function aabbIntersectsRect(b: ResizePose, r: ResizePose): boolean {\n  return b.x < r.x + r.width && b.x + b.width > r.x && b.y < r.y + r.height && b.y + b.height > r.y;\n}\n\n/** Identity geometry for `TPose extends ResizePose`. Treats the pose as its\n *  own bounds and remaps via affine scale against `src`/`dst`. */\nexport const RECT_POSE_DESCRIPTOR: PoseProjection<ResizePose> = {\n  getBounds: (p) => p,\n  remapBounds: (p, src, dst) => {\n    const sx = src.width === 0 ? 1 : dst.width / src.width;\n    const sy = src.height === 0 ? 1 : dst.height / src.height;\n    return {\n      ...p,\n      x: dst.x + (p.x - src.x) * sx,\n      y: dst.y + (p.y - src.y) * sy,\n      width: p.width * sx,\n      height: p.height * sy,\n    };\n  },\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n  intersectsRect: (p, r) => aabbIntersectsRect(p, r),\n  lerp: (a, b, t) => ({\n    ...a,\n    x: a.x + (b.x - a.x) * t,\n    y: a.y + (b.y - a.y) * t,\n    width: a.width + (b.width - a.width) * t,\n    height: a.height + (b.height - a.height) * t,\n  }),\n};\n\n/** Identity geometry for `RotatedPose`. Inherits rect-shape projection\n *  from `RECT_POSE_DESCRIPTOR` (the `RotatedPose extends ResizePose`\n *  subtype lets the rect descriptor's methods apply directly; `remapBounds`\n *  preserves the `rotation` field via `...p` spread). Adds `getRotation` so\n *  `useResize` knows to take the rotation-aware math path. */\nexport const ROTATED_POSE_DESCRIPTOR: PoseProjection<RotatedPose> = {\n  getBounds: RECT_POSE_DESCRIPTOR.getBounds as PoseProjection<RotatedPose>['getBounds'],\n  remapBounds: RECT_POSE_DESCRIPTOR.remapBounds as PoseProjection<RotatedPose>['remapBounds'],\n  translate: RECT_POSE_DESCRIPTOR.translate as PoseProjection<RotatedPose>['translate'],\n  intersectsRect: RECT_POSE_DESCRIPTOR.intersectsRect as PoseProjection<RotatedPose>['intersectsRect'],\n  lerp: RECT_POSE_DESCRIPTOR.lerp as PoseProjection<RotatedPose>['lerp'],\n  getRotation: (p) => p.rotation,\n};\n\n/**\n * Remap a **rotated** leaf inside a group resize.\n *\n * The naive `remapBounds` scales a leaf's axis-aligned `width`/`height` by the\n * group's per-axis factors and carries `rotation` through untouched. That is\n * right when `src`/`dst` are already expressed in the leaf's own frame — the\n * single-leaf resize path, where the drag delta was projected into that frame\n * before the anchor math ran. In a group resize they are world-frame, so the\n * leaf's local axes do not line up with the axes being scaled: at 90° a\n * horizontal stretch should grow the leaf's `height`, and the naive map grows\n * its `width`.\n *\n * What this computes is the group affine applied to the leaf's local frame,\n * with the shear dropped — the pose model is `{x, y, width, height, rotation}`\n * and cannot represent the parallelogram a non-uniform scale of a rotated box\n * actually produces. The centre moves exactly; each local axis takes the\n * length of its own image; the rotation follows the image of the local x-axis.\n *\n * Degenerates to the naive map at `rotation === 0`, and to a plain uniform\n * scale when `sx === sy`, both exactly.\n */\nexport function remapRotatedLeaf<TPose extends RotatedPose>(\n  pose: TPose,\n  src: ResizePose,\n  dst: ResizePose,\n): TPose {\n  const sx = src.width === 0 ? 1 : dst.width / src.width;\n  const sy = src.height === 0 ? 1 : dst.height / src.height;\n  const theta = pose.rotation ?? 0;\n  const cos = Math.cos(theta);\n  const sin = Math.sin(theta);\n\n  // Images of the leaf's local unit axes under the group's diagonal scale.\n  const ux = sx * cos, uy = sy * sin;\n  const vx = -sx * sin, vy = sy * cos;\n\n  const width = pose.width * Math.hypot(ux, uy);\n  const height = pose.height * Math.hypot(vx, vy);\n  const rotation = Math.atan2(uy, ux);\n\n  // The centre is a point, so it takes the group affine directly.\n  const cxNew = dst.x + (pose.x + pose.width / 2 - src.x) * sx;\n  const cyNew = dst.y + (pose.y + pose.height / 2 - src.y) * sy;\n\n  return {\n    ...pose,\n    x: cxNew - width / 2,\n    y: cyNew - height / 2,\n    width,\n    height,\n    rotation,\n  };\n}\n","import { boundsOfPath } from './bounds';\nimport { pointInPath } from './hitTest';\nimport { translatePath } from './transform';\nimport { PATH_C, PATH_L, PATH_M, PATH_Q, PATH_Z, type Path, type PolygonPath } from './types';\nimport { aabbIntersectsRect, type PoseProjection } from 'interactions/actions/resize/geometry';\nimport type { ResizePose } from 'interactions/gestures/types';\n\n/**\n * `PoseProjection` for `Path` poses — wires `useResize` to operate\n * on `Path` directly. `getBounds` defers to the same `boundsOfPath` kernel\n * the rest of the kit uses; `remapBounds` does an affine scale of every\n * coord against `src`/`dst`. Degenerate axes (zero src extent) collapse to\n * the new origin so resize from a flat edge doesn't produce NaN.\n *\n * Mirrors `scalePathToBounds` but takes `src` explicitly: the resize hook\n * knows the group's origin AABB and uses it for every leaf, instead of\n * each leaf scaling against its own AABB (which would ignore group context).\n */\nexport const pathPoseDescriptor: PoseProjection<Path> = {\n  getBounds: (path) => boundsOfPath(path),\n  remapBounds: (path, src, dst) => {\n    const sx = src.width === 0 ? 0 : dst.width / src.width;\n    const sy = src.height === 0 ? 0 : dst.height / src.height;\n    if (path.kind === 'rect') {\n      return {\n        kind: 'rect',\n        x: dst.x + (path.x - src.x) * sx,\n        y: dst.y + (path.y - src.y) * sy,\n        width: path.width * sx,\n        height: path.height * sy,\n      };\n    }\n    return remapPolygon(path, src, dst, sx, sy);\n  },\n  translate: (path, dx, dy) => translatePath(path, dx, dy),\n  // WHY: AABB pre-test is cheap; only fall through to per-corner pointInPath\n  //      when the rect is fully inside the AABB (silhouette test).\n  intersectsRect: (path, rect) => {\n    const b = boundsOfPath(path);\n    if (!aabbIntersectsRect(b, rect)) return false;\n    if (path.kind === 'rect') return true;\n    // Sample the rect's four corners; any inside the polygon ⇒ overlap.\n    if (\n      pointInPath(path, rect.x, rect.y) ||\n      pointInPath(path, rect.x + rect.width, rect.y) ||\n      pointInPath(path, rect.x, rect.y + rect.height) ||\n      pointInPath(path, rect.x + rect.width, rect.y + rect.height)\n    ) return true;\n    // Conservative fallback: AABB overlap counts. Tighter edge-vs-edge test\n    // would be the next step; defer until a demo demands it.\n    return true;\n  },\n  lerp: (a, b, t) => {\n    if (a.kind === 'rect' && b.kind === 'rect') {\n      return {\n        kind: 'rect',\n        x: a.x + (b.x - a.x) * t,\n        y: a.y + (b.y - a.y) * t,\n        width: a.width + (b.width - a.width) * t,\n        height: a.height + (b.height - a.height) * t,\n      };\n    }\n    if (a.kind === 'polygon' && b.kind === 'polygon' && a.coords.length === b.coords.length) {\n      const next = new Float32Array(a.coords.length);\n      for (let i = 0; i < a.coords.length; i++) {\n        next[i] = a.coords[i] + (b.coords[i] - a.coords[i]) * t;\n      }\n      return { kind: 'polygon', commands: a.commands, coords: next, fillRule: a.fillRule };\n    }\n    throw new Error('pathPoseDescriptor.lerp: incompatible path shapes');\n  },\n  // Path poses carry no x/y/width/height/rotation fields — the kit's\n  // `wrapWithPoseRotation` helper has nothing to bind a rotation to, and\n  // `remapBounds` would drop a synthetic rotation field on every commit.\n  // Returning false here hides the rotation affordance for Path consumers\n  // so the rotate cursor doesn't appear without a working interaction.\n  supportsRotation: () => false,\n};\n\nfunction remapPolygon(path: PolygonPath, src: ResizePose, dst: ResizePose, sx: number, sy: number): PolygonPath {\n  const next = new Float32Array(path.coords.length);\n  const { commands, coords } = path;\n  let ci = 0;\n  for (let i = 0; i < commands.length; i++) {\n    const len = COORD_COUNT[commands[i]];\n    for (let k = 0; k < len; k += 2) {\n      next[ci + k] = dst.x + (coords[ci + k] - src.x) * sx;\n      next[ci + k + 1] = dst.y + (coords[ci + k + 1] - src.y) * sy;\n    }\n    ci += len;\n  }\n  return { kind: 'polygon', commands: path.commands, coords: next, fillRule: path.fillRule };\n}\n\nconst COORD_COUNT: Readonly<Record<number, number>> = {\n  [PATH_M]: 2,\n  [PATH_L]: 2,\n  [PATH_C]: 6,\n  [PATH_Q]: 4,\n  [PATH_Z]: 0,\n};\n","import type { Path } from 'features/paths/types';\nimport { pathPoseDescriptor } from 'features/paths/poseDescriptor';\nimport { RECT_POSE_DESCRIPTOR, type PoseProjection } from './geometry';\n\n/** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for\n *  callers that need to fork between `pathPoseDescriptor` and\n *  `RECT_POSE_DESCRIPTOR` without forcing the consumer to wire `geometry`\n *  explicitly. */\nexport function isPathLike(p: unknown): p is Path {\n  return !!p && typeof p === 'object' && 'kind' in p\n    && ((p as { kind: unknown }).kind === 'polygon' || (p as { kind: unknown }).kind === 'rect');\n}\n\n/** Per-call dispatch: if the pose looks like a Path, route to\n *  `pathPoseDescriptor`; otherwise treat as a plain rect pose. Avoids forcing\n *  demos with Path TPose to wire `geometry={pathPoseDescriptor}` explicitly.\n *  `getRotation` surfaces a `pose.rotation` field on non-Path poses so demos\n *  using rect-with-rotation shapes (e.g. `RotatedPose`) don't have to wire\n *  `geometry={ROTATED_POSE_DESCRIPTOR}` just to get rotated selection chrome\n *  and rotation-aware corner hit-tests. */\nexport const AUTO_POSE_DESCRIPTOR: PoseProjection<unknown> = {\n  getBounds: (p) => isPathLike(p)\n    ? pathPoseDescriptor.getBounds(p)\n    : RECT_POSE_DESCRIPTOR.getBounds(p as { x: number; y: number; width: number; height: number }),\n  remapBounds: (p, src, dst) => isPathLike(p)\n    ? pathPoseDescriptor.remapBounds(p, src, dst)\n    : RECT_POSE_DESCRIPTOR.remapBounds(p as { x: number; y: number; width: number; height: number }, src, dst),\n  translate: (p, dx, dy) => isPathLike(p)\n    ? pathPoseDescriptor.translate!(p, dx, dy)\n    : RECT_POSE_DESCRIPTOR.translate!(p as { x: number; y: number; width: number; height: number }, dx, dy),\n  intersectsRect: (p, rect) => isPathLike(p)\n    ? pathPoseDescriptor.intersectsRect!(p, rect)\n    : RECT_POSE_DESCRIPTOR.intersectsRect!(p as { x: number; y: number; width: number; height: number }, rect),\n  getRotation: (p) => {\n    if (isPathLike(p)) return 0;\n    const r = (p as { rotation?: unknown }).rotation;\n    return typeof r === 'number' ? r : 0;\n  },\n  // Path-shaped poses can't carry rotation (see `pathPoseDescriptor`).\n  // Everything else flows through `wrapWithPoseRotation`'s x/y/w/h gate at\n  // paint time, so report `true` and let the wrapper no-op for poses\n  // missing AABB fields.\n  supportsRotation: (p) => !isPathLike(p),\n};\n","import type { SnapStrategy } from '../../types';\nimport { resolveUnit, type UnitSystem, type UnitValue } from 'core/units';\nimport type { DebugSink } from '../../../../debug/types';\nimport { isPathLike } from 'interactions/actions/resize/autoPoseDescriptor';\nimport { boundsOfPath } from 'features/paths/bounds';\nimport { translatePath } from 'features/paths/transform';\nimport type { Path } from 'features/paths/types';\n\n/**\n * Projection used by `gridSnapStrategy` when `TPose` doesn't expose `{x,y}`\n * directly (Path, polygon, etc.). The strategy reads the snap point via\n * `getOrigin`, rounds it to the grid, then asks `translate` to move the\n * pose by the resulting delta.\n */\nexport interface OriginProjection<TPose> {\n  getOrigin(pose: TPose): { x: number; y: number };\n  translate(pose: TPose, dx: number, dy: number): TPose;\n}\n\n/** Identity projection for `TPose extends { x; y }`. */\nexport const RECT_ORIGIN_PROJECTION: OriginProjection<{ x: number; y: number }> = {\n  getOrigin: (p) => ({ x: p.x, y: p.y }),\n  translate: (p, dx, dy) => ({ ...p, x: p.x + dx, y: p.y + dy }),\n};\n\n/** Per-call dispatch: routes Path-shaped poses to the path origin/translate\n *  helpers and everything else to `RECT_ORIGIN_PROJECTION`. Default for\n *  `gridSnapStrategy` so consumers with Path TPose don't have to thread\n *  `pathOriginProjection` explicitly. */\nexport const AUTO_ORIGIN_PROJECTION: OriginProjection<unknown> = {\n  getOrigin: (p) => {\n    if (isPathLike(p)) {\n      const b = boundsOfPath(p as Path);\n      return { x: b.x, y: b.y };\n    }\n    const r = p as { x: number; y: number };\n    return { x: r.x, y: r.y };\n  },\n  translate: (p, dx, dy) => {\n    if (isPathLike(p)) return translatePath(p as Path, dx, dy);\n    const r = p as { x: number; y: number };\n    return { ...r, x: r.x + dx, y: r.y + dy };\n  },\n};\n\n/** Snap-strategy that rounds the pose's origin to the nearest multiple of\n *  `spacing` (resolved through `unitSystem`). For non-rect TPose pass an\n *  `OriginProjection` so the strategy knows how to read/write the origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  unitSystem?: UnitSystem,\n): SnapStrategy<TPose>;\n/** As above, additionally reporting each candidate to a debug sink. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  opts: { unitSystem?: UnitSystem; debug?: DebugSink },\n): SnapStrategy<TPose>;\n/** As above, for a `TPose` that is not a rect: `origin` tells the strategy how\n *  to read and write the pose's origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  opts: { unitSystem?: UnitSystem; origin: OriginProjection<TPose>; debug?: DebugSink },\n): SnapStrategy<TPose>;\n/** Snap-strategy that rounds the pose's origin to the nearest multiple of\n *  `spacing` (resolved through `unitSystem`). For non-rect TPose pass an\n *  `OriginProjection` so the strategy knows how to read/write the origin. */\nexport function gridSnapStrategy<TPose>(\n  spacing: UnitValue,\n  arg?: UnitSystem | { unitSystem?: UnitSystem; origin?: OriginProjection<TPose>; debug?: DebugSink },\n): SnapStrategy<TPose> {\n  const isOpts =\n    typeof arg === 'object' &&\n    arg !== null &&\n    ('origin' in arg || 'debug' in arg || 'unitSystem' in arg) &&\n    !('base' in arg);\n  const optsArg = isOpts\n    ? (arg as { unitSystem?: UnitSystem; origin?: OriginProjection<TPose>; debug?: DebugSink })\n    : null;\n  const unitSystem = optsArg ? optsArg.unitSystem : (arg as UnitSystem | undefined);\n  const proj: OriginProjection<TPose> = optsArg && optsArg.origin\n    ? optsArg.origin\n    : (AUTO_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n  const debug: DebugSink | undefined = optsArg ? optsArg.debug : undefined;\n  const c = resolveUnit(spacing, unitSystem);\n  return {\n    snap(pose) {\n      const o = proj.getOrigin(pose);\n      const sx = Math.round(o.x / c) * c;\n      const sy = Math.round(o.y / c) * c;\n      debug?.recordSnapCandidate({ x: sx, y: sy }, true);\n      return proj.translate(pose, sx - o.x, sy - o.y);\n    },\n  };\n}\n\n/**\n * Compute the integer cell `{col, row}` that contains `point`, given a grid\n * `spacing` and optional `origin` and `unitSystem`. Pair with\n * `createCellHighlightLayer` (its `getCell` callback) to draw a snap-target\n * preview that uses the same spacing as `gridSnapStrategy` — so the visual\n * and behavioral grids stay in lockstep:\n *\n *     const SPACING = 20;\n *     const snap = gridSnapStrategy(SPACING);\n *     // visual grid:\n *     createGridLayer({ spacing: SPACING, bounds: () => ... });\n *     // hover-preview overlay:\n *     createCellHighlightLayer({\n *       spacing: SPACING,\n *       getCell: () => hoverPoint && pointToGridCell(hoverPoint, SPACING),\n *     });\n */\nexport function pointToGridCell(\n  point: { x: number; y: number },\n  spacing: UnitValue,\n  unitSystem?: UnitSystem,\n  origin: { x: number; y: number } = { x: 0, y: 0 },\n): { col: number; row: number } {\n  const s = resolveUnit(spacing, unitSystem);\n  return {\n    col: Math.floor((point.x - origin.x) / s),\n    row: Math.floor((point.y - origin.y) / s),\n  };\n}\n","/**\n * Screen-pixel lengths in world units, per axis.\n *\n * Chrome declares its hit zones in screen pixels — an 8px handle stays 8px at\n * every zoom, because it paints in screen space. Converting one such length to\n * world units with a single scalar (see `meanScale`) is exact only under\n * uniform zoom; per-axis it is too generous on one axis and too mean on the\n * other, so the pickable region stops matching the painted one.\n *\n * Prefer {@link withinPxBox} / {@link withinPxRadius}, which compare in screen\n * space and so can't drift from the paint at all. {@link pxExtent} is for the\n * cases that must stay in world units — a tolerance handed to geometry that\n * doesn't know about the view.\n */\n\nexport interface Scale2 {\n  x: number;\n  y: number;\n}\n\n/** Guard against a degenerate axis: a zero scale would send the extent to\n *  infinity and make every point a hit. */\nconst MIN_SCALE = 1e-9;\n\n/** One screen-pixel length as world-space extents, per axis. */\nexport function pxExtent(px: number, scale: Scale2): { x: number; y: number } {\n  return {\n    x: px / Math.max(MIN_SCALE, Math.abs(scale.x)),\n    y: px / Math.max(MIN_SCALE, Math.abs(scale.y)),\n  };\n}\n\n/** World delta → screen delta. Only the scale participates: translation\n *  cancels in a difference, and the kit's views carry no skew. */\nexport function scaleDelta(dx: number, dy: number, scale: Scale2): { x: number; y: number } {\n  return { x: dx * scale.x, y: dy * scale.y };\n}\n\n/**\n * Is a world-space delta inside a screen-space square of half-extent `px`?\n *\n * The square is axis-aligned **on screen**, which is what a handle painted in\n * screen space actually is — so this stays true under non-uniform zoom and\n * under a rotated target, where an axis-aligned world-space test is a rotated\n * rectangle on screen.\n */\nexport function withinPxBox(dx: number, dy: number, px: number, scale: Scale2): boolean {\n  const s = scaleDelta(dx, dy, scale);\n  return Math.abs(s.x) <= px && Math.abs(s.y) <= px;\n}\n\n/** Is a world-space delta inside a screen-space circle of radius `px`? */\nexport function withinPxRadius(dx: number, dy: number, px: number, scale: Scale2): boolean {\n  const s = scaleDelta(dx, dy, scale);\n  return s.x * s.x + s.y * s.y <= px * px;\n}\n","import type { SnapStrategy } from '../../types';\nimport type { Guide } from 'features/guides/types';\nimport type { View } from 'core/viewport/view';\nimport { pxExtent } from 'core/viewport/pxExtent';\nimport type { OriginProjection } from './grid';\nimport { RECT_ORIGIN_PROJECTION } from './grid';\n\n/** Default snap tolerance (screen pixels). */\nexport const DEFAULT_GUIDE_TOLERANCE_PX = 6;\n\n/** Options for `guideSnapStrategy`. */\nexport interface GuideSnapOptions<TPose> {\n  /**\n   * Tolerance, in screen pixels (CSS px) when `getView` is provided, or in\n   * world units otherwise. Defaults to `DEFAULT_GUIDE_TOLERANCE_PX`.\n   */\n  tolerance?: number;\n  /**\n   * Read the active view transform. When supplied, `tolerance` is interpreted\n   * in screen pixels and divided by `view.scale` so the trigger zone stays\n   * the same on screen as the user zooms in/out. Without it, `tolerance`\n   * is treated as world units.\n   */\n  getView?: () => View;\n  /**\n   * Projection used when `TPose` doesn't expose `{x, y}` directly (Path,\n   * polygon, etc.) — same contract as `gridSnapStrategy`. Defaults to the\n   * rect-pose identity projection.\n   */\n  origin?: OriginProjection<TPose>;\n}\n\n/**\n * Snap-strategy that snaps the pose's origin to the nearest guide line on\n * each axis when within tolerance. Each axis is considered independently:\n * a vertical guide (`axis: 'x'`) constrains X, a horizontal guide\n * (`axis: 'y'`) constrains Y. When multiple guides are within range on the\n * same axis, the closest wins.\n *\n * Pair with `useGuides` for storage and `createGuidesLayer` for rendering.\n *\n * **Composition:** combining with `gridSnapStrategy` is left to the\n * consumer in v1 — typically by picking one based on a modifier key, or\n * by stacking two move/resize/insert behaviors in priority order.\n */\nexport function guideSnapStrategy<TPose extends { x: number; y: number }>(\n  getGuides: () => readonly Guide[],\n  options?: Omit<GuideSnapOptions<TPose>, 'origin'>,\n): SnapStrategy<TPose>;\n/** As above, for a `TPose` that is not a rect: `origin` tells the strategy how\n *  to read and write the pose's origin. */\nexport function guideSnapStrategy<TPose>(\n  getGuides: () => readonly Guide[],\n  options: GuideSnapOptions<TPose> & { origin: OriginProjection<TPose> },\n): SnapStrategy<TPose>;\n/** Snap a pose's origin to the nearest guide line within tolerance, per axis. */\nexport function guideSnapStrategy<TPose>(\n  getGuides: () => readonly Guide[],\n  options: GuideSnapOptions<TPose> = {},\n): SnapStrategy<TPose> {\n  const tolerance = options.tolerance ?? DEFAULT_GUIDE_TOLERANCE_PX;\n  const getView = options.getView;\n  const proj: OriginProjection<TPose> =\n    options.origin ?? (RECT_ORIGIN_PROJECTION as unknown as OriginProjection<TPose>);\n\n  return {\n    snap(pose) {\n      const guides = getGuides();\n      if (guides.length === 0) return null;\n\n      // Convert tolerance to world units, per axis: a guide on the x axis is\n      // matched by a horizontal distance, so it answers to `scale.x` alone.\n      // With no view, treat tolerance as already-world.\n      const tol = getView ? pxExtent(tolerance, getView().scale) : { x: tolerance, y: tolerance };\n\n      const o = proj.getOrigin(pose);\n\n      let bestDx = 0;\n      let bestAbsDx = Infinity;\n      let bestDy = 0;\n      let bestAbsDy = Infinity;\n\n      for (const g of guides) {\n        if (g.axis === 'x') {\n          const d = g.offset - o.x;\n          const ad = Math.abs(d);\n          if (ad <= tol.x && ad < bestAbsDx) {\n            bestAbsDx = ad;\n            bestDx = d;\n          }\n        } else {\n          const d = g.offset - o.y;\n          const ad = Math.abs(d);\n          if (ad <= tol.y && ad < bestAbsDy) {\n            bestAbsDy = ad;\n            bestDy = d;\n          }\n        }\n      }\n\n      if (bestAbsDx === Infinity && bestAbsDy === Infinity) return null;\n      const dx = bestAbsDx === Infinity ? 0 : bestDx;\n      const dy = bestAbsDy === Infinity ? 0 : bestDy;\n      if (dx === 0 && dy === 0) return null;\n      return proj.translate(pose, dx, dy);\n    },\n  };\n}\n"]}