@weasel-js/core 1.0.4 → 1.2.0

package/dist/{chunk-JOSUVS6C.js → chunk-ADWOB5K2.js}

@@ -212,5 +212,5 @@ async function writeOsClipboard(flavors) {
 }
 
 export { PointerContextProvider, WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, applyOpsTo, buildWeaselClipboardText, dispatchApplyBatch, dlog, dwarn, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, isDebugEnabled, materializePaste, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps, usePointerContext };
-//# sourceMappingURL=chunk-JOSUVS6C.js.map
-//# sourceMappingURL=chunk-JOSUVS6C.js.map
+//# sourceMappingURL=chunk-ADWOB5K2.js.map
+//# sourceMappingURL=chunk-ADWOB5K2.js.map

package/dist/chunk-ADWOB5K2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/applyOps.ts","../src/debug/flag.ts","../src/features/pointer/PointerContext.tsx","../src/interactions/actions/clipboard/wireFormat.ts","../src/interactions/actions/clipboard/materializePaste.ts","../src/interactions/actions/clipboard/clipboardOps.ts"],"names":["useRef"],"mappings":"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","file":"chunk-ADWOB5K2.js","sourcesContent":["import type { Op } from './ops/types';\n\n/**\n * Default `applyOps` implementation: apply each op in order against\n * `adapter`. Used by hooks when an adapter omits `applyOps`. Apps that\n * need history integration (checkpoint + push entry) supply their own\n * `applyOps` instead.\n *\n * The `_label` parameter mirrors the `applyOps(ops, label)` signature so\n * call-sites can dispatch through `(adapter.applyOps ?? applyOpsTo)` with\n * matching arguments. The default ignores it.\n */\nexport function applyOpsTo<A>(adapter: A, ops: Op[], _label?: string): void {\n  for (const op of ops) op.apply(adapter);\n}\n\n/**\n * Dispatcher: invokes `adapter.applyOps` if present, otherwise falls back\n * to `applyOpsTo`. Convenience for hooks so they don't repeat the\n * `?? applyOpsTo` pattern at every call site.\n */\nexport function dispatchApplyBatch<A>(\n  adapter: A,\n  ops: Op[],\n  label?: string,\n): void {\n  const a = adapter as { applyOps?: (ops: Op[], label?: string) => void };\n  if (a.applyOps) a.applyOps(ops, label);\n  else applyOpsTo(adapter, ops, label);\n}\n","/**\n * Namespaced, opt-in console tracing for the kit.\n *\n * Enable in the browser:\n *\n *   localStorage.setItem('weasel.debug', '*')                 // all namespaces\n *   localStorage.setItem('weasel.debug', 'tools,dispatch')    // specific ones\n *   localStorage.setItem('weasel.debug', '1')                 // legacy \"all\"\n *\n * Each call site picks a stable namespace string. Off by default; the flag\n * is read once and cached per page session — reload to pick up a change.\n *\n * Mirrors `packages/ui/src/dlog.ts`. The two impls live in separate\n * packages because weasel-ui doesn't depend on the kit, but both read the\n * same localStorage keys so behavior is uniform from a debugger's POV.\n *\n * Known kit namespaces:\n *   - tools           — active-tool + hotkey transitions (useTools)\n *   - dispatch        — gesture start / end / cancel (dispatcher)\n *   - drag-rect       — useDragRect lifecycle\n *   - drag-radial     — useDragRadial lifecycle\n *   - scene           — restored-op replay gaps (history persistence)\n *   - scene-canvas    — SceneCanvas mount / unmount; adapter paste-translation warnings\n *   - history         — applyOps push, no-op suppression, serialize/restore\n *   - clipboard       — OS clipboard write/read failures, malformed payloads\n */\n\nconst KEYS = ['weasel.debug', 'weaseldraw.debug'] as const;\n\ninterface Cached {\n  all: boolean;\n  set: Set<string>;\n}\n\nlet cached: Cached | null = null;\n\nfunction read(): Cached {\n  const empty: Cached = { all: false, set: new Set() };\n  if (typeof localStorage === 'undefined') return empty;\n  try {\n    for (const k of KEYS) {\n      const v = localStorage.getItem(k);\n      if (v == null || v === '') continue;\n      if (v === '1' || v === 'true' || v === '*') return { all: true, set: new Set() };\n      return { all: false, set: new Set(v.split(/[\\s,]+/).filter(Boolean)) };\n    }\n    return empty;\n  } catch {\n    return empty;\n  }\n}\n\nfunction get(): Cached {\n  if (cached === null) cached = read();\n  return cached;\n}\n\n/** True when `namespace` (or `*`) is enabled. Pass no argument to test\n *  whether *any* namespace is on (legacy global-flag semantics). */\nexport function isDebugEnabled(namespace?: string): boolean {\n  const c = get();\n  if (c.all) return true;\n  if (namespace === undefined) return c.set.size > 0;\n  return c.set.has(namespace);\n}\n\n/** Conditional `console.debug` — no-op unless `namespace` (or `*`) is enabled.\n *  Each call is prefixed with `[namespace]` so the source is searchable. */\nexport function dlog(namespace: string, ...args: unknown[]): void {\n  if (!isDebugEnabled(namespace)) return;\n  // eslint-disable-next-line no-console\n  console.debug(`[${namespace}]`, ...args);\n}\n\n/** Conditional `console.warn` — like `dlog` but at warn level. Use for\n *  diagnostics that indicate something worth surfacing during debugging\n *  (e.g. no-op op batches suppressed). */\nexport function dwarn(namespace: string, ...args: unknown[]): void {\n  if (!isDebugEnabled(namespace)) return;\n  console.warn(`[${namespace}]`, ...args);\n}\n","/**\n * @experimental\n * PointerContext — a tiny ambient context that publishes the world-space\n * position of the canvas pointer, refreshed on every `pointermove` over\n * the canvas. Cleared (set to `null`) on `pointerleave`.\n *\n * Why ref-based and not state-based: cursor moves fire dozens of times per\n * second; routing those through React state would re-render every consumer\n * in the tree. The context exposes a stable `pointerRef` whose `.current`\n * is mutated directly by the publisher, plus a thunk `getDropPoint()` that\n * reads it on demand. Consumers (e.g. `useClipboard`) pull via the thunk\n * inside their callbacks — no subscription, no re-render.\n *\n * `<SceneCanvas>` publishes automatically. `useClipboardOps` consumes when\n * the caller didn't pass an explicit `getDropPoint` option. Other future\n * hit-on-cursor consumers (drop-zone hover, context-menu anchor) can reuse\n * the same context.\n */\nimport { createContext, useContext, useMemo, useRef, type MutableRefObject, type ReactNode } from 'react';\n\n/** @experimental World-space pointer position, or `null` when the pointer\n *  isn't over the publishing canvas. */\nexport type PointerWorldPos = { worldX: number; worldY: number } | null;\n\n/** @experimental */\nexport interface PointerContextValue {\n  /** Live ref — mutate to publish, read for the latest snapshot. The\n   *  identity is stable for the lifetime of the provider. */\n  readonly pointerRef: MutableRefObject<PointerWorldPos>;\n  /** Convenience thunk equivalent to `() => pointerRef.current`. Stable\n   *  identity for the lifetime of the provider; safe to pass to hooks. */\n  readonly getDropPoint: () => PointerWorldPos;\n}\n\nconst PointerContext = createContext<PointerContextValue | null>(null);\n\n/**\n * @experimental\n * Wrap the part of the React tree that should share a pointer-position\n * context. Usually placed at the demo / app root, alongside\n * `<ActionsProvider>` and `<SelectionContextProvider>`.\n *\n * Most consumers don't need to mount this directly — `<SceneCanvas>` mounts\n * an internal provider when no parent provider is in scope, so child hooks\n * (`useClipboard` without an explicit `getDropPoint`) read the canvas's\n * tracked pointer for free.\n */\nexport function PointerContextProvider({ children }: { children: ReactNode }): ReactNode {\n  const pointerRef = useRef<PointerWorldPos>(null);\n  const value = useMemo<PointerContextValue>(() => ({\n    pointerRef,\n    getDropPoint: () => pointerRef.current,\n  }), []);\n  return <PointerContext.Provider value={value}>{children}</PointerContext.Provider>;\n}\n\n/** @experimental Read the surrounding pointer-context value, or `null` when\n *  no provider is in scope. */\nexport function usePointerContext(): PointerContextValue | null {\n  return useContext(PointerContext);\n}\n","import { dwarn } from 'debug/flag';\n\n/** MIME type the kit writes its full-fidelity clipboard payload under, so a\n *  copy/paste between two weasel canvases round-trips scene nodes rather than\n *  the SVG or text flavors other apps read. */\nexport const WEASEL_CLIPBOARD_MIME = 'application/x-weasel-clipboard+json';\n/** Chromium's async-clipboard spelling for custom formats. */\nexport const WEASEL_CLIPBOARD_MIME_WEB = `web ${WEASEL_CLIPBOARD_MIME}`;\n\ninterface WeaselClipboardPayload { weaselClipboard: 1; nodes: unknown[] }\n\ntype Replacer = (key: string, value: unknown) => unknown;\ntype Reviver = (key: string, value: unknown) => unknown;\n\n/** Serialize snapshot items into the versioned wire text.\n *\n *  Function-valued fields (e.g. a container's `clipFromPose`) are dropped by\n *  JSON serialization — OS-pasted clip containers arrive unclipped.\n *  Consumers who need clips to survive the OS round-trip can translate\n *  function ↔ registry key in their `jsonReplacer`/reviver pair (the\n *  scene-serialization `clipFromPoseKey` precedent). */\nexport function buildWeaselClipboardText(items: unknown[], replacer?: Replacer): string {\n  const payload: WeaselClipboardPayload = { weaselClipboard: 1, nodes: items };\n  return JSON.stringify(payload, replacer as Parameters<typeof JSON.stringify>[1]);\n}\n\n/** Cheap check: could this text be a weasel clipboard payload? Substring\n *  pre-check, then a guarded parse + marker/version test. */\nexport function sniffWeaselClipboardText(text: string): boolean {\n  if (!text.includes('\"weaselClipboard\"')) return false;\n  try {\n    const parsed = JSON.parse(text) as Partial<WeaselClipboardPayload> | null;\n    return !!parsed && parsed.weaselClipboard === 1;\n  } catch {\n    return false;\n  }\n}\n\n// Opening `<svg ...>` tag of a serialized document. `[^>]*` is safe for OUR\n// serializer's output (attribute values are XML-escaped, so no raw `>` can\n// appear inside the tag) — see embedWeaselMetadataInSvg's contract note.\nconst SVG_OPEN_TAG = /<svg(?:\\s[^>]*)?>/i;\n\n/**\n * Embed a weasel clipboard payload in an SVG document as a `<metadata>`\n * child of the root — legal SVG 1.1, ignored by external tools — so one\n * `text/plain` flavor serves both audiences: external tools parse the SVG,\n * weasel extracts the JSON for full fidelity on draw→draw DOM paste.\n *\n * The payload rides in CDATA so JSON's `<` / `&` need no entity escaping; a\n * literal `]]>` inside the payload is split across CDATA sections\n * (`]]]]><![CDATA[>`), which {@link extractWeaselClipboardFromSvg} rejoins.\n *\n * Intended for OUR serializer's output only (`serializeSvg` — single\n * `<svg ...>` open tag, XML-escaped attributes). When no open tag is found\n * the input is returned unchanged with a debug warning.\n */\nexport function embedWeaselMetadataInSvg(svgText: string, payloadText: string): string {\n  const open = SVG_OPEN_TAG.exec(svgText);\n  if (!open) {\n    dwarn('clipboard', 'embedWeaselMetadataInSvg: no <svg ...> open tag found — returning input unchanged');\n    return svgText;\n  }\n  const cdata = `<![CDATA[${payloadText.replaceAll(']]>', ']]]]><![CDATA[>')}]]>`;\n  const at = open.index + open[0].length;\n  return `${svgText.slice(0, at)}<metadata>${cdata}</metadata>${svgText.slice(at)}`;\n}\n\n/**\n * Recover an embedded weasel clipboard payload from SVG text: read the first\n * `<metadata>` block, rejoin its CDATA sections (concatenation restores the\n * `]]>` split by {@link embedWeaselMetadataInSvg}; plain non-CDATA content\n * passes through as-is), and return the payload text iff it sniffs as the\n * weasel wire format — else null (external/non-weasel metadata declines).\n *\n * A text scan, not an XML parse — the payload is small and ours.\n */\nexport function extractWeaselClipboardFromSvg(svgText: string): string | null {\n  const block = /<metadata(?:\\s[^>]*)?>([\\s\\S]*?)<\\/metadata>/i.exec(svgText);\n  if (!block) return null;\n  const inner = block[1];\n  const payload = inner.includes('<![CDATA[')\n    ? Array.from(inner.matchAll(/<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>/g), (m) => m[1]).join('')\n    : inner;\n  return sniffWeaselClipboardText(payload) ? payload : null;\n}\n\n/** Parse wire text to snapshot items, or null when malformed/mismatched\n *  (callers decline to the next content handler). */\nexport function parseWeaselClipboardText(text: string, reviver?: Reviver): unknown[] | null {\n  try {\n    const parsed = JSON.parse(text, reviver as Parameters<typeof JSON.parse>[1]) as\n      Partial<WeaselClipboardPayload> | null;\n    if (!parsed || parsed.weaselClipboard !== 1 || !Array.isArray(parsed.nodes)) return null;\n    return parsed.nodes;\n  } catch (err) {\n    dwarn('clipboard', `weasel payload failed to parse: ${String(err)}`);\n    return null;\n  }\n}\n","/**\n * Shared paste materialization — the one place the paste recipe lives:\n * offset policy → `commitPaste` → the op batch (InsertOps parents-first +\n * a SetSelectionOp). Both `useClipboardOps.paste` (in-memory paste) and the\n * kit weasel-JSON content handler (OS-clipboard paste) dispatch exactly this\n * batch, so the two arrival paths stay indistinguishable in history.\n *\n * Pure: no dispatching here — callers own how the ops are applied\n * (`dispatchApplyBatch` vs `IngestCtx.applyOps`) and any post-paste\n * bookkeeping (the hook's cascade re-snapshot, the handler's selection set).\n */\nimport { createInsertOp } from 'core/ops/create';\nimport { createSetSelectionOp } from 'core/ops/select';\nimport type { Op } from 'core/ops/types';\nimport type { NodeId } from 'core/scene/types';\nimport type { ClipboardSnapshot, InsertAdapter } from 'core/adapters/types';\n\n/** Shared paste materialization: offset policy → commitPaste → the op batch\n *  both the in-memory paste and the OS-paste handler dispatch. Returns null\n *  when the adapter can't paste or nothing was created. */\nexport function materializePaste<TNode extends { id: string }>(\n  adapter: InsertAdapter<TNode>,\n  snapshot: ClipboardSnapshot,\n  opts: {\n    currentSelection: string[];\n    dropPoint?: { worldX: number; worldY: number } | null;\n  },\n): { ops: Op[]; newIds: string[]; created: TNode[] } | null {\n  const commitPaste = adapter.commitPaste;\n  if (!commitPaste) return null;\n  const offset = adapter.getPasteOffset?.(snapshot) ?? { dx: 0, dy: 0 };\n  const ctx = opts.dropPoint != null ? { dropPoint: opts.dropPoint } : undefined;\n  const created = commitPaste.call(adapter, snapshot, offset, ctx);\n  if (created.length === 0) return null;\n  const newIds = created.map((o) => o.id);\n  const ops: Op[] = [\n    ...created.map((o) => createInsertOp({ node: o })),\n    createSetSelectionOp({ from: opts.currentSelection as NodeId[], to: newIds as NodeId[] }),\n  ];\n  return { ops, newIds, created };\n}\n","import { useCallback, useRef } from 'react';\nimport type { NodeId } from 'core/scene/types';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport type { InsertAdapter } from 'core/adapters/types';\nimport type { ClipboardSnapshot } from './types';\nimport { usePointerContext } from 'features/pointer/PointerContext';\nimport { dwarn } from 'debug/flag';\nimport { materializePaste } from './materializePaste';\nimport { WEASEL_CLIPBOARD_MIME, buildWeaselClipboardText } from './wireFormat';\n\ntype Replacer = (key: string, value: unknown) => unknown;\n\n/** Options for `useClipboardOps`. */\nexport interface UseClipboardOpsOptions {\n  /** How the hook reads \"current selection\" for copy. The kit doesn't assume\n   *  a global selection store; each consumer wires this. */\n  getSelection: () => NodeId[];\n  /** Called after a successful paste with the ids of the newly inserted objects. */\n  onPaste?: (newIds: NodeId[]) => void;\n  /** Label for the history entry produced by paste. Default 'Paste'. */\n  pasteLabel?: string;\n  /** Pulled once per paste() call. When non-null, threaded to commitPaste\n   *  as `ctx.dropPoint`; adapters typically use it as the cluster origin\n   *  (ignoring `offset`). When null/undefined, the hook falls back to the\n   *  existing cascade-offset behavior. */\n  getDropPoint?: () => { worldX: number; worldY: number } | null;\n  /** Produce the OS-clipboard flavor map for a copied snapshot. Keys are MIME\n   *  types, values the serialized payload. The kit default emits\n   *  `application/x-weasel-clipboard+json` plus `text/plain` carrying the\n   *  same JSON. Apps override to add richer flavors (e.g. real SVG) or to\n   *  replace the text flavor. Return an empty object to skip the OS write\n   *  entirely. */\n  produceFlavors?: (snapshot: ClipboardSnapshot) => Record<string, string>;\n  /** Replacer for the kit-default JSON flavor (typed arrays etc.). Ignored\n   *  when `produceFlavors` is supplied. */\n  jsonReplacer?: Replacer;\n}\n\n/** Return shape of `useClipboardOps`: imperative `copy`, `paste`, and `isEmpty` functions. */\nexport interface UseClipboardOpsReturn {\n  copy(): void;\n  paste(): void;\n  isEmpty(): boolean;\n}\n\nconst EMPTY: ClipboardSnapshot = { items: [] };\n\n/** In-memory copy/paste of selections via `InsertAdapter.snapshotSelection` / `commitPaste`. */\nexport function useClipboardOps<TNode extends { id: string }>(\n  adapter: InsertAdapter<TNode>,\n  options: UseClipboardOpsOptions,\n): UseClipboardOpsReturn {\n  const { getSelection, onPaste, pasteLabel = 'Paste', getDropPoint, produceFlavors, jsonReplacer } = options;\n  // Fall back to the ambient pointer context (auto-published by SceneCanvas)\n  // when the caller didn't supply an explicit `getDropPoint`. Null context\n  // (no provider in scope) and no caller-supplied thunk together mean\n  // \"no drop point\" — paste uses the cascade offset instead.\n  const pointerCtx = usePointerContext();\n  const effectiveGetDropPoint = getDropPoint ?? pointerCtx?.getDropPoint;\n  const clipboardRef = useRef<ClipboardSnapshot>(EMPTY);\n  // Keep callbacks stable across renders.\n  const adapterRef = useRef(adapter);\n  adapterRef.current = adapter;\n  const optsRef = useRef({\n    getSelection, onPaste, pasteLabel, getDropPoint: effectiveGetDropPoint, produceFlavors, jsonReplacer,\n  });\n  optsRef.current = {\n    getSelection, onPaste, pasteLabel, getDropPoint: effectiveGetDropPoint, produceFlavors, jsonReplacer,\n  };\n\n  const copy = useCallback(() => {\n    const ids = optsRef.current.getSelection();\n    if (ids.length === 0) return;\n    const snap = adapterRef.current.snapshotSelection;\n    if (!snap) return;\n    clipboardRef.current = snap(ids);\n    // Best-effort OS write. Never blocks or throws — the in-memory ref is\n    // already set, and OS clipboard support varies (custom formats are\n    // Chromium-only via the \"web \" prefix; jsdom/non-secure contexts have\n    // no API at all). The flavor producer itself is untrusted consumer code\n    // (`produceFlavors`), so guard its call too — a throwing producer must\n    // not break `copy()`, it just skips the OS write.\n    let flavors: Record<string, string> | null = null;\n    try {\n      flavors = optsRef.current.produceFlavors?.(clipboardRef.current)\n        ?? defaultFlavors(clipboardRef.current, optsRef.current.jsonReplacer);\n    } catch (err) {\n      dwarn('clipboard', `flavor producer threw — skipping OS write: ${String(err)}`);\n    }\n    if (flavors) void writeOsClipboard(flavors);\n  }, []);\n\n  const paste = useCallback(() => {\n    const cb = clipboardRef.current;\n    if (cb.items.length === 0) return;\n    const a = adapterRef.current;\n    const result = materializePaste(a, cb, {\n      currentSelection: optsRef.current.getSelection(),\n      dropPoint: optsRef.current.getDropPoint?.(),\n    });\n    if (!result) return;\n    dispatchApplyBatch(a, result.ops, optsRef.current.pasteLabel);\n    // Use the just-created objects as the next cascade source. Re-snapshotting\n    // via `adapter.snapshotSelection(newIds)` would read adapter state, but\n    // React-state adapters haven't flushed yet — `itemsRef.current` still\n    // points at the pre-insert array, so the snapshot would come back empty\n    // and the next paste would no-op.\n    clipboardRef.current = { items: result.created };\n    optsRef.current.onPaste?.(result.newIds as NodeId[]);\n  }, []);\n\n  const isEmpty = useCallback(() => clipboardRef.current.items.length === 0, []);\n\n  return { copy, paste, isEmpty };\n}\n\nfunction defaultFlavors(snapshot: ClipboardSnapshot, replacer?: Replacer): Record<string, string> {\n  const text = buildWeaselClipboardText(snapshot.items, replacer);\n  return { [WEASEL_CLIPBOARD_MIME]: text, 'text/plain': text };\n}\n\n/** MIME types the async Clipboard API accepts unprefixed. Every other type\n *  (including our own custom MIME, and app-supplied flavors like\n *  `image/svg+xml`) must carry Chromium's `web ` prefix or `ClipboardItem`'s\n *  constructor throws. */\nconst WELL_KNOWN_CLIPBOARD_MIMES = new Set(['text/plain', 'text/html', 'image/png']);\n\n/** Degradation ladder: full map (every non-well-known MIME web-prefixed) →\n *  well-known-only → give up with a dwarn.\n *  @internal test seam — exported so unit tests can await the fire-and-forget\n *  write directly; tests should still exercise this at least once through\n *  the public `copy()` (see clipboardOps.test.tsx). */\nexport async function writeOsClipboard(flavors: Record<string, string>): Promise<void> {\n  const entries = Object.entries(flavors);\n  if (entries.length === 0) return;\n  const cb = typeof navigator !== 'undefined' ? navigator.clipboard : undefined;\n  if (!cb?.write || typeof ClipboardItem === 'undefined') return;\n  const wireMime = (mime: string) => (WELL_KNOWN_CLIPBOARD_MIMES.has(mime) ? mime : `web ${mime}`);\n  const toItem = (fs: [string, string][]) => new ClipboardItem(Object.fromEntries(\n    fs.map(([mime, text]) => {\n      const wire = wireMime(mime);\n      return [wire, new Blob([text], { type: wire })];\n    }),\n  ));\n  try {\n    await cb.write([toItem(entries)]);\n  } catch {\n    const standard = entries.filter(([mime]) => WELL_KNOWN_CLIPBOARD_MIMES.has(mime));\n    if (standard.length === 0) { dwarn('clipboard', 'OS write failed; no standard flavors to fall back to'); return; }\n    try {\n      await cb.write([toItem(standard)]);\n    } catch (err) {\n      dwarn('clipboard', `OS clipboard write failed twice — copy stays in-memory only: ${String(err)}`);\n    }\n  }\n}\n"]}

package/dist/{chunk-J3YC3GVF.js → chunk-CKADTCHK.js}

@@ -430,5 +430,5 @@ function reportRouteConflicts(scopes, warn = (m) => console.warn(m)) {
 }
 
 export { ActionDisabledReason, ActionsProvider, DepRegistryProvider, actionBindings, buildDepsFromRequires, buildRouteRegistry, evaluateEnabled, findConflicts, reportRouteConflicts, useAction, useActionsRegistry, useDepRegistry, useDepSource, useOptionalDepRegistry };
-//# sourceMappingURL=chunk-J3YC3GVF.js.map
-//# sourceMappingURL=chunk-J3YC3GVF.js.map
+//# sourceMappingURL=chunk-CKADTCHK.js.map
+//# sourceMappingURL=chunk-CKADTCHK.js.map

package/dist/chunk-CKADTCHK.js.map

@@ -0,0 +1 @@
+{"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":";;;;;;AAgCA,IAAM,kBAAA,GAAqB,cAAkC,IAAI,CAAA;AAI1D,SAAS,mBAAA,CAAoB,EAAE,QAAA,EAAS,EAA4B;AACzE,EAAA,MAAM,UAAA,GAAa,MAAA,iBAAO,IAAI,GAAA,EAA2D,CAAA;AAEzF,EAAA,MAAM,QAAA,GAAW,QAAqB,OAAO;AAAA,IAC3C,QAAA,EAAU,CAAoB,IAAA,EAAS,MAAA,KAA+B;AACpE,MAAA,UAAA,CAAW,OAAA,CAAQ,GAAA,CAAI,IAAA,EAAgB,MAAuB,CAAA;AAC9D,MAAA,OAAO,MAAM;AAAE,QAAA,UAAA,CAAW,OAAA,CAAQ,OAAO,IAAc,CAAA;AAAA,MAAG,CAAA;AAAA,IAC5D,CAAA;AAAA,IACA,KAAK,CAAoB,IAAA,KACvB,WAAW,OAAA,CAAQ,GAAA,CAAI,IAAc,CAAA;AAAI,GAC7C,CAAA,EAAI,EAAE,CAAA;AAEN,EAAA,2BAAQ,kBAAA,CAAmB,QAAA,EAAnB,EAA4B,KAAA,EAAO,UAAW,QAAA,EAAS,CAAA;AACjE;AAGO,SAAS,cAAA,GAA8B;AAC5C,EAAA,MAAM,CAAA,GAAI,WAAW,kBAAkB,CAAA;AACvC,EAAA,IAAI,MAAM,IAAA,EAAM;AACd,IAAA,MAAM,IAAI,MAAM,8HAA8H,CAAA;AAAA,EAChJ;AACA,EAAA,OAAO,CAAA;AACT;AAOO,SAAS,sBAAA,GAA6C;AAC3D,EAAA,OAAO,WAAW,kBAAkB,CAAA;AACtC;AAKO,SAAS,YAAA,CAAgC,MAAS,MAAA,EAA4B;AACnF,EAAA,MAAM,WAAW,cAAA,EAAe;AAChC,EAAA,MAAM,SAAA,GAAY,OAAO,MAAM,CAAA;AAC/B,EAAA,SAAA,CAAU,OAAA,GAAU,MAAA;AACpB,EAAA,SAAA,CAAU,MAAM;AACd,IAAA,OAAO,SAAS,QAAA,CAAS,IAAA,EAAM,MAAM,SAAA,CAAU,SAAS,CAAA;AAAA,EAC1D,CAAA,EAAG,CAAC,IAAA,EAAM,QAAQ,CAAC,CAAA;AACrB;;;AClEA,IAAM,OAAgB,MAAM;AAC1B,EAAA,IAAI;AACF,IAAA,OAAO,OAAA,CAAS,MAAA,CAAA,IAAA,CAAuD,GAAA,EAAK,GAAG,CAAA;AAAA,EACjF,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,KAAA;AAAA,EACT;AACF,CAAA,GAAG;AAGI,SAAS,qBAAA,CAAsB,QAAgB,WAAA,EAAsC;AAC1F,EAAA,MAAM,QAAA,GAAW,MAAA,CAAO,QAAA,IAAY,EAAC;AACrC,EAAA,MAAM,OAAA,GAAU,QAAA,CAAS,GAAA,CAAI,CAAC,IAAA,KAAS,CAAC,IAAA,EAAM,WAAA,CAAY,GAAA,CAAI,IAAI,CAAC,CAAC,CAAA;AACpE,EAAA,MAAM,IAAA,GAAO,MAAA,CAAO,WAAA,CAAY,OAAO,CAAA;AAMvC,EAAA,IAAI,GAAA,EAAK;AACP,IAAA,MAAM,QAAA,GAAW,IAAI,GAAA,CAAY,QAAQ,CAAA;AACzC,IAAA,OAAO,IAAI,MAAM,IAAA,EAAiC;AAAA,MAChD,GAAA,CAAI,MAAA,EAAQ,IAAA,EAAM,QAAA,EAAU;AAC1B,QAAA,IAAI,OAAO,SAAS,QAAA,IAAY,CAAC,SAAS,GAAA,CAAI,IAAI,CAAA,IAAK,IAAA,KAAS,MAAA,EAAQ;AACtE,UAAA,MAAM,UACJ,CAAA,4BAAA,EAA+B,MAAA,CAAO,EAAE,CAAA,YAAA,EAAe,IAAI,iEACnC,IAAI,CAAA,+DAAA,CAAA;AAI9B,UAAA,OAAA,CAAQ,KAAK,OAAO,CAAA;AACpB,UAAA,MAAM,IAAI,MAAM,OAAO,CAAA;AAAA,QACzB;AACA,QAAA,OAAO,OAAA,CAAQ,GAAA,CAAI,MAAA,EAAQ,IAAA,EAAM,QAAQ,CAAA;AAAA,MAC3C;AAAA,KACD,CAAA;AAAA,EACH;AACA,EAAA,OAAO,IAAA;AACT;ACTO,SAAS,eAAe,MAAA,EAAkC;AAC/D,EAAA,MAAM,KAAK,MAAA,CAAO,cAAA;AAClB,EAAA,IAAI,CAAC,EAAA,EAAI,OAAO,EAAC;AACjB,EAAA,MAAM,MAAsB,KAAA,CAAM,OAAA,CAAQ,EAAE,CAAA,GAAI,EAAA,GAAK,CAAC,EAAkB,CAAA;AACxE,EAAA,OAAO,GAAA,CAAI,GAAA,CAAI,CAAC,KAAA,KAAU;AACxB,IAAA,MAAM,UAAA,GAAa,EAAE,MAAA,IAAU,KAAA,CAAA;AAC/B,IAAA,MAAM,IAAA,GAAO,UAAA,GAAc,KAAA,CAAgC,IAAA,GAAQ,KAAA;AACnE,IAAA,MAAM,IAAA,GAAO,UAAA,GAAc,KAAA,CAAgC,IAAA,GAAO,MAAA;AAClE,IAAA,OAAO,EAAE,IAAA,EAAM,QAAA,EAAU,MAAA,CAAO,EAAA,EAAI,GAAI,IAAA,KAAS,MAAA,GAAY,EAAE,IAAA,EAAK,GAAI,EAAC,EAAG;AAAA,EAC9E,CAAC,CAAA;AACH;AAsIO,IAAM,oBAAA,GAAuB;AAAA,EAClC,iBAAA,EAAmB,oBAAA;AAAA,EACnB,UAAA,EAAY,aAAA;AAAA,EACZ,aAAA,EAAe,gBAAA;AAAA;AAAA,EAEf,cAAA,EAAgB;AAClB;AAcA,IAAM,iBAAA,uBAAwB,GAAA,EAAY;AAC1C,IAAM,kBAAA,uBAAyB,GAAA,EAAY;AAC3C,IAAM,iBAAA,GAAoB,CAAA;AASnB,SAAS,eAAA,CACd,QACA,IAAA,EACqB;AACrB,EAAA,IAAI,CAAC,MAAA,CAAO,OAAA,EAAS,OAAO,EAAE,SAAS,IAAA,EAAK;AAC5C,EAAA,MAAM,QAAQ,OAAO,OAAA,KAAY,cAAc,OAAA,CAAQ,GAAA,CAAI,aAAa,YAAA,GAAe,IAAA;AACvF,EAAA,MAAM,GAAA,GAAO,OAAO,WAAA,KAAgB,WAAA,IAAe,OAAO,WAAA,CAAY,GAAA,KAAQ,UAAA,GAC1E,MAAM,WAAA,CAAY,GAAA,EAAI,GACtB,MAAM,KAAK,GAAA,EAAI;AACnB,EAAA,MAAM,KAAA,GAAQ,KAAA,GAAQ,GAAA,EAAI,GAAI,CAAA;AAC9B,EAAA,IAAI;AACF,IAAA,MAAM,MAAA,GAAS,MAAA,CAAO,OAAA,CAAQ,IAAI,CAAA;AAClC,IAAA,IAAI,KAAA,EAAO;AACT,MAAA,MAAM,OAAA,GAAU,KAAI,GAAI,KAAA;AACxB,MAAA,IAAI,UAAU,iBAAA,IAAqB,CAAC,kBAAkB,GAAA,CAAI,MAAA,CAAO,EAAE,CAAA,EAAG;AACpE,QAAA,iBAAA,CAAkB,GAAA,CAAI,OAAO,EAAE,CAAA;AAC/B,QAAA,OAAA,CAAQ,IAAA;AAAA,UACN,CAAA,sCAAA,EAAyC,OAAO,EAAE,CAAA,OAAA,EAAU,QAAQ,OAAA,CAAQ,CAAC,CAAC,CAAA,WAAA,EACnE,iBAAiB,CAAA,yEAAA;AAAA,SAC9B;AAAA,MACF;AAAA,IACF;AACA,IAAA,IAAI,MAAA,KAAW,IAAA,EAAM,OAAO,EAAE,SAAS,IAAA,EAAK;AAC5C,IAAA,OAAO,EAAE,OAAA,EAAS,KAAA,EAAO,MAAA,EAAQ,MAAA,EAAO;AAAA,EAC1C,SAAS,CAAA,EAAG;AACV,IAAA,IAAI,SAAS,CAAC,kBAAA,CAAmB,GAAA,CAAI,MAAA,CAAO,EAAE,CAAA,EAAG;AAC/C,MAAA,kBAAA,CAAmB,GAAA,CAAI,OAAO,EAAE,CAAA;AAChC,MAAA,OAAA,CAAQ,IAAA;AAAA,QACN,CAAA,sCAAA,EAAyC,OAAO,EAAE,CAAA,4FAAA,CAAA;AAAA,QAElD;AAAA,OACF;AAAA,IACF;AACA,IAAA,OAAO,EAAE,OAAA,EAAS,KAAA,EAAO,MAAA,EAAQ,qBAAqB,cAAA,EAAe;AAAA,EACvE;AACF;AA2EA,SAAS,iBAAiB,EAAA,EAAkB;AAC1C,EAAA,IAAI,EAAA,CAAG,WAAW,CAAA,EAAG;AACnB,IAAA,MAAM,IAAI,MAAM,CAAA,kCAAA,CAAoC,CAAA;AAAA,EACtD;AACA,EAAA,IAAI,oBAAA,CAAqB,GAAA,CAAI,EAAA,CAAG,CAAC,CAAE,CAAA,EAAG;AACpC,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,CAAA,mBAAA,EAAsB,EAAE,CAAA,8BAAA,EAAiC,EAAA,CAAG,CAAC,CAAC,CAAA,iBAAA,EAC5C,CAAC,GAAG,oBAAoB,CAAA,CAAE,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA;AAAA,KACvD;AAAA,EACF;AACA,EAAA,IAAI,iBAAA,CAAkB,GAAA,CAAI,EAAE,CAAA,EAAG;AAC7B,IAAA,MAAM,IAAI,KAAA;AAAA,MACR,CAAA,mBAAA,EAAsB,EAAE,CAAA,oDAAA,EACV,CAAC,GAAG,iBAAiB,CAAA,CAAE,IAAA,CAAK,IAAI,CAAC,CAAA,CAAA;AAAA,KACjD;AAAA,EACF;AACF;AAKA,SAAS,6BAA6B,MAAA,EAAsB;AAC1D,EAAA,MAAM,KAAK,MAAA,CAAO,cAAA;AAClB,EAAA,IAAI,CAAC,EAAA,EAAI;AACT,EAAA,MAAM,UAA0B,KAAA,CAAM,OAAA,CAAQ,EAAE,CAAA,GAAI,EAAA,GAAK,CAAC,EAAkB,CAAA;AAC5E,EAAA,KAAA,MAAW,SAAS,OAAA,EAAS;AAC3B,IAAA,MAAM,IAAA,GAAQ,MAAA,IAAU,KAAA,GAAQ,KAAA,GAAQ,KAAA,CAAM,IAAA;AAC9C,IAAA,MAAM,QAA+B,IAAA,CAAK,KAAA;AAC1C,IAAA,IAAI,UAAU,MAAA,EAAW;AACzB,IAAA,MAAM,KAAA,GAA8B,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,GACnD,KAAA,GACA,CAAC,EAAE,OAAA,EAAS,GAAA,EAAK,KAAA,EAAc,CAAA;AACnC,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,IAAI,IAAA,CAAK,YAAY,GAAA,EAAK;AACxB,QAAA,MAAM,IAAI,KAAA;AAAA,UACR,CAAA,gBAAA,EAAmB,OAAO,EAAE,CAAA,gMAAA;AAAA,SAI9B;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;AAEA,IAAM,cAAA,GAAiBA,cAAsC,IAAI,CAAA;AAQ1D,SAAS,eAAA,CAAgB,EAAE,QAAA,EAAS,EAA0C;AACnF,EAAA,MAAM,UAAA,GAAaC,MAAAA,iBAA4B,IAAI,GAAA,EAAK,CAAA;AACxD,EAAA,MAAM,UAAA,GAAaA,OAAO,CAAC,CAAA;AAC3B,EAAA,MAAM,SAAA,GAAYA,MAAAA,CAA0B,EAAE,CAAA;AAC9C,EAAA,MAAM,YAAA,GAAeA,OAAO,EAAE,CAAA;AAC9B,EAAA,MAAM,YAAA,GAAeA,MAAAA,iBAAwB,IAAI,GAAA,EAAK,CAAA;AAKtD,EAAA,MAAM,SAAS,sBAAA,EAAuB;AACtC,EAAA,MAAM,SAAA,GAAYA,OAA2B,MAAM,CAAA;AACnD,EAAA,SAAA,CAAU,OAAA,GAAU,MAAA;AAKpB,EAAA,MAAM,cAAA,GAAiBA,OAA2B,IAAI,CAAA;AAItD,EAAA,MAAM,aAAA,GAAgBA,OAA0B,IAAI,CAAA;AAQpD,EAAA,MAAM,QAAA,GAAWC,QAAyB,MAAM;AAC9C,IAAA,MAAM,WAAW,MAAyB;AACxC,MAAA,MAAM,IAAI,UAAA,CAAW,OAAA;AACrB,MAAA,IAAI,YAAA,CAAa,OAAA,KAAY,CAAA,EAAG,OAAO,SAAA,CAAU,OAAA;AACjD,MAAA,MAAM,GAAA,GAAM,OAAO,MAAA,CAAO,KAAA,CAAM,KAAK,UAAA,CAAW,OAAA,CAAQ,MAAA,EAAQ,CAAC,CAAA;AACjE,MAAA,SAAA,CAAU,OAAA,GAAU,GAAA;AACpB,MAAA,YAAA,CAAa,OAAA,GAAU,CAAA;AACvB,MAAA,OAAO,GAAA;AAAA,IACT,CAAA;AACA,IAAA,MAAM,SAAS,MAAY;AACzB,MAAA,KAAA,MAAW,CAAA,IAAK,aAAa,OAAA,EAAS;AACpC,QAAA,IAAI;AACF,UAAA,CAAA,EAAE;AAAA,QACJ,SAAS,GAAA,EAAK;AACZ,UAAA,OAAA,CAAQ,KAAA,CAAM,4CAA4C,GAAG,CAAA;AAAA,QAC/D;AAAA,MACF;AAAA,IACF,CAAA;AACA,IAAA,OAAO;AAAA,MACL,QAAA,EAAU,CAAC,MAAA,KAAmB;AAC5B,QAAA,gBAAA,CAAiB,OAAO,EAAE,CAAA;AAC1B,QAAA,4BAAA,CAA6B,MAAM,CAAA;AACnC,QAAA,UAAA,CAAW,OAAA,CAAQ,GAAA,CAAI,MAAA,CAAO,EAAA,EAAI,MAAM,CAAA;AACxC,QAAA,UAAA,CAAW,OAAA,EAAA;AACX,QAAA,MAAA,EAAO;AACP,QAAA,OAAO,MAAM;AACX,UAAA,MAAM,GAAA,GAAM,UAAA,CAAW,OAAA,CAAQ,GAAA,CAAI,OAAO,EAAE,CAAA;AAG5C,UAAA,IAAI,QAAQ,MAAA,EAAQ;AAClB,YAAA,UAAA,CAAW,OAAA,CAAQ,MAAA,CAAO,MAAA,CAAO,EAAE,CAAA;AACnC,YAAA,UAAA,CAAW,OAAA,EAAA;AACX,YAAA,MAAA,EAAO;AAAA,UACT;AAAA,QACF,CAAA;AAAA,MACF,CAAA;AAAA,MACA,UAAA,EAAY,CAAC,EAAA,KAAe;AAC1B,QAAA,IAAI,UAAA,CAAW,OAAA,CAAQ,MAAA,CAAO,EAAE,CAAA,EAAG;AACjC,UAAA,UAAA,CAAW,OAAA,EAAA;AACX,UAAA,MAAA,EAAO;AAAA,QACT;AAAA,MACF,CAAA;AAAA,MACA,IAAA,EAAM,MAAM,QAAA,EAAS;AAAA,MACrB,OAAA,EAAS,CAAC,EAAA,EAAY,MAAA,KAAqC;AACzD,QAAA,MAAM,CAAA,GAAI,UAAA,CAAW,OAAA,CAAQ,GAAA,CAAI,EAAE,CAAA;AACnC,QAAA,IAAI,CAAC,GAAG,OAAO,KAAA;AACf,QAAA,IAAI;AACF,UAAA,IAAI,CAAA,CAAE,OAAA,IAAW,CAAA,CAAE,OAAA,CAAQ,WAAW,WAAA,EAAa;AACjD,YAAA,MAAM,CAAA,GAAI,cAAA,CAAe,OAAA,IAAW,SAAA,CAAU,OAAA;AAK9C,YAAA,MAAM,IAAA,GAAO,CAAC,CAAA,GACV,EAAC,GACD,EAAE,QAAA,GACA,qBAAA,CAAsB,CAAA,EAAG,CAAC,CAAA,GAC1B;AAAA,cACE,SAAA,EAAW,CAAA,CAAE,GAAA,CAAI,WAAsB,CAAA;AAAA,cACvC,KAAA,EAAO,CAAA,CAAE,GAAA,CAAI,OAAkB,CAAA;AAAA,cAC/B,OAAA,EAAS,CAAA,CAAE,GAAA,CAAI,SAAoB,CAAA;AAAA,cACnC,IAAA,EAAM,CAAA,CAAE,GAAA,CAAI,MAAiB,CAAA;AAAA,cAC7B,OAAA,EAAS,CAAA,CAAE,GAAA,CAAI,SAAoB,CAAA;AAAA,cACnC,UAAA,EAAY,CAAA,CAAE,GAAA,CAAI,YAAuB,CAAA;AAAA,cACzC,eAAA,EAAiB,CAAA,CAAE,GAAA,CAAI,iBAA4B;AAAA,aACrD;AACN,YAAA,CAAA,CAAE,OAAA,CAAQ,GAAA,CAAI,IAAA,EAAe,MAAM,CAAA;AAAA,UACrC;AAAA,QACF,SAAS,GAAA,EAAK;AACZ,UAAA,OAAA,CAAQ,KAAA,CAAM,CAAA,gCAAA,EAAmC,EAAE,CAAA,OAAA,CAAA,EAAW,GAAG,CAAA;AAAA,QACnE;AACA,QAAA,OAAO,IAAA;AAAA,MACT,CAAA;AAAA,MACA,SAAA,EAAW,CAAC,QAAA,KAAyB;AACnC,QAAA,YAAA,CAAa,OAAA,CAAQ,IAAI,QAAQ,CAAA;AACjC,QAAA,OAAO,MAAM;AACX,UAAA,YAAA,CAAa,OAAA,CAAQ,OAAO,QAAQ,CAAA;AAAA,QACtC,CAAA;AAAA,MACF,CAAA;AAAA,MACA,aAAA,EAAe,CAAC,CAAA,KAAyB;AACvC,QAAA,aAAA,CAAc,OAAA,GAAU,CAAA;AAAA,MAC1B,CAAA;AAAA,MACA,cAAA,EAAgB,CAAC,CAAA,KAA0B;AACzC,QAAA,cAAA,CAAe,OAAA,GAAU,CAAA;AAAA,MAC3B,CAAA;AAAA,MACA,KAAA,EAAO,CAAC,EAAA,EAAY,MAAA,KAAqC;AACvD,QAAA,MAAM,OAAO,aAAA,CAAc,OAAA;AAC3B,QAAA,IAAI,CAAC,MAAM,OAAO,IAAA;AAClB,QAAA,MAAM,CAAA,GAAI,cAAA,CAAe,OAAA,IAAW,SAAA,CAAU,OAAA;AAC9C,QAAA,MAAM,CAAA,GAAI,UAAA,CAAW,OAAA,CAAQ,GAAA,CAAI,EAAE,CAAA;AAMnC,QAAA,MAAM,IAAA,GAAO,CAAC,CAAA,GACV,EAAC,GACD,GAAG,QAAA,GACD,qBAAA,CAAsB,CAAA,EAAG,CAAC,CAAA,GAC1B;AAAA,UACE,SAAA,EAAW,CAAA,CAAE,GAAA,CAAI,WAAsB,CAAA;AAAA,UACvC,KAAA,EAAO,CAAA,CAAE,GAAA,CAAI,OAAkB,CAAA;AAAA,UAC/B,OAAA,EAAS,CAAA,CAAE,GAAA,CAAI,SAAoB,CAAA;AAAA,UACnC,IAAA,EAAM,CAAA,CAAE,GAAA,CAAI,MAAiB,CAAA;AAAA,UAC7B,OAAA,EAAS,CAAA,CAAE,GAAA,CAAI,SAAoB,CAAA;AAAA,UACnC,UAAA,EAAY,CAAA,CAAE,GAAA,CAAI,YAAuB,CAAA;AAAA,UACzC,eAAA,EAAiB,CAAA,CAAE,GAAA,CAAI,iBAA4B;AAAA,SACrD;AACN,QAAA,OAAO,IAAA,CAAK,cAAA,CAAe,EAAA,EAAI,IAAA,EAAe,MAAM,CAAA;AAAA,MACtD;AAAA,KACF;AAAA,EACF,CAAA,EAAG,EAAE,CAAA;AAEL,EAAA,uBAAOC,GAAAA,CAAC,cAAA,CAAe,UAAf,EAAwB,KAAA,EAAO,UAAW,QAAA,EAAS,CAAA;AAC7D;AAMO,SAAS,kBAAA,GAA6C;AAC3D,EAAA,OAAOC,WAAW,cAAc,CAAA;AAClC;AAQO,SAAS,UAAU,MAAA,EAAsB;AAC9C,EAAA,MAAM,MAAM,kBAAA,EAAmB;AAC/B,EAAAC,UAAU,MAAM;AACd,IAAA,IAAI,CAAC,GAAA,EAAK;AACV,IAAA,OAAO,GAAA,CAAI,SAAS,MAAM,CAAA;AAAA,EAC5B,CAAA,EAAG,CAAC,GAAA,EAAK,MAAM,CAAC,CAAA;AAClB;;;AC5eO,IAAM,gBAAA,GAAmB,WAAA;AAKhC,IAAM,oBAAA,GAA6E;AAAA,EACjF,GAAA,EAAK,SAAA;AAAA,EACL,UAAA,EAAY,SAAA;AAAA,EACZ,KAAA,EAAO,OAAA;AAAA,EACP,KAAA,EAAO,OAAA;AAAA,EACP,WAAA,EAAa,QAAA;AAAA,EACb,WAAA,EAAa,aAAA;AAAA,EACb,SAAA,EAAW,WAAA;AAAA,EACX,IAAA,EAAM,MAAA;AAAA,EACN,WAAA,EAAa,aAAA;AAAA,EACb,UAAA,EAAY,MAAA;AAAA,EACZ,aAAA,EAAe,eAAA;AAAA,EACf,IAAA,EAAM,MAAA;AAAA,EACN,KAAA,EAAO;AACT,CAAA;AAaO,SAAS,mBACd,KAAA,EACiB;AACjB,EAAA,MAAM,MAAuB,EAAC;AAC9B,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,KAAA,MAAW,OAAA,IAAW,IAAA,CAAK,QAAA,IAAY,EAAC,EAAG;AACzC,MAAA,MAAM,QAAQ,QAAA,CAAS,IAAA,CAAK,IAAI,OAAA,CAAQ,IAAA,EAAM,QAAQ,QAAQ,CAAA;AAC9D,MAAA,IAAI,KAAA,EAAO,GAAA,CAAI,IAAA,CAAK,KAAK,CAAA;AAAA,IAC3B;AAAA,EACF;AACA,EAAA,OAAO,GAAA;AACT;AAEA,SAAS,QAAA,CACP,MAAA,EACA,IAAA,EACA,QAAA,EACsB;AACtB,EAAA,MAAM,OAAA,GAAU,oBAAA,CAAqB,IAAA,CAAK,IAAI,CAAA;AAC9C,EAAA,IAAI,CAAC,OAAA,IAAW,CAAC,kBAAA,CAAmB,OAAO,GAAG,OAAO,IAAA;AACrD,EAAA,MAAM,UAAA,GAAa,qBAAqB,OAAO,CAAA;AAC/C,EAAA,OAAO;AAAA,IACL,MAAA;AAAA,IACA,QAAA;AAAA,IACA,OAAA;AAAA,IACA,OAAO,OAAA,CAAQ,OAAA,IAAW,IAAA,GAAO,IAAA,CAAK,QAAQ,MAAS,CAAA;AAAA,IACvD,WAAW,YAAA,CAAa,MAAA,IAAU,IAAA,GAAO,IAAA,CAAK,OAAO,MAAS,CAAA;AAAA,IAC9D,GAAA,EAAK,WAAW,GAAA,GAAM,KAAA,CAAM,MAAM,UAAA,CAAW,GAAA,CAAI,OAAO,CAAA,GAAI,MAAA;AAAA,IAC5D,MAAA,EAAQ,WAAW,SAAA,GACf,QAAA,CAAS,YAAY,IAAA,GAAO,IAAA,CAAK,MAAA,GAAS,MAAS,CAAA,GACnD,MAAA;AAAA,IACJ;AAAA,GACF;AACF;AAQA,SAAS,QAAQ,KAAA,EAA6D;AAC5E,EAAA,IAAI,KAAA,KAAU,MAAA,IAAa,KAAA,KAAU,GAAA,EAAK,OAAO,KAAA;AACjD,EAAA,IAAI,KAAA,KAAU,SAAA,IAAa,KAAA,KAAU,SAAA,EAAW,OAAO,KAAA;AACvD,EAAA,MAAM,QAAA,GAAW,IAAI,GAAA,CAAI,KAAA,CAAM,IAAI,CAAC,IAAA,KAAS,IAAA,CAAK,KAAK,CAAC,CAAA;AACxD,EAAA,IAAI,QAAA,CAAS,IAAA,KAAS,CAAA,EAAG,OAAO,KAAA;AAChC,EAAA,MAAM,IAAA,GAAO,CAAC,GAAG,QAAQ,EAAE,CAAC,CAAA;AAC5B,EAAA,OAAO,IAAA,KAAS,SAAA,IAAa,IAAA,KAAS,SAAA,GAAY,IAAA,GAAO,KAAA;AAC3D;AAIA,SAAS,aAAa,IAAA,EAA4C;AAChE,EAAA,IAAI,CAAC,IAAA,EAAM,OAAO,EAAC;AACnB,EAAA,MAAM,MAAuB,EAAC;AAC9B,EAAA,KAAA,MAAW,CAAC,IAAA,EAAM,GAAG,KAAK,MAAA,CAAO,OAAA,CAAQ,IAAI,CAAA,EAAG;AAC9C,IAAA,IAAI,GAAA,KAAQ,IAAA,EAAM,GAAA,CAAI,IAAmB,CAAA,GAAI,UAAA;AAAA,SAAA,IACpC,GAAA,KAAQ,UAAA,EAAY,GAAA,CAAI,IAAmB,CAAA,GAAI,UAAA;AAAA,EAC1D;AACA,EAAA,OAAO,GAAA;AACT;AAEA,SAAS,SAAS,MAAA,EAAoD;AACpE,EAAA,IAAI,MAAA,KAAW,QAAW,OAAO,MAAA;AACjC,EAAA,OAAO,OAAO,MAAA,KAAW,QAAA,GAAW,MAAA,GAAS,gBAAA;AAC/C;AAEA,SAAS,KAAA,CAAM,MAAmB,QAAA,EAAkD;AAClF,EAAA,IAAI,SAAS,IAAA,EAAM;AACjB,IAAA,OAAO,KAAA,CAAM,OAAA,CAAQ,IAAA,CAAK,GAAG,CAAA,GAAI,KAAK,GAAA,CAAI,IAAA,CAAK,GAAG,CAAA,GAAI,IAAA,CAAK,GAAA;AAAA,EAC7D;AACA,EAAA,IAAI,SAAA,IAAa,IAAA,EAAM,OAAO,MAAA,CAAO,KAAK,OAAO,CAAA;AACjD,EAAA,IAAI,WAAA,IAAe,IAAA,EAAM,OAAO,IAAA,CAAK,SAAA,IAAa,QAAA;AAClD,EAAA,IAAI,OAAA,IAAW,IAAA,EAAM,OAAO,IAAA,CAAK,KAAA,EAAO,SAAS,IAAA,CAAK,KAAA,CAAM,IAAA,CAAK,GAAG,CAAA,GAAI,QAAA;AACxE,EAAA,OAAO,QAAA;AACT;;;AC5GO,SAAS,cACd,KAAA,EACY;AACZ,EAAA,MAAM,OAAA,GAAU,mBAAmB,KAAK,CAAA;AACxC,EAAA,MAAM,MAAA,uBAAa,GAAA,EAA6B;AAChD,EAAA,KAAA,MAAW,SAAS,OAAA,EAAS;AAC3B,IAAA,MAAM,MAAM,CAAA,EAAG,KAAA,CAAM,KAAK,CAAA,CAAA,EAAI,KAAA,CAAM,OAAO,CAAA,CAAA,EAAI,KAAA,CAAM,OAAO,EAAE,CAAA,CAAA,EAAI,UAAU,KAAK,CAAC,IAAI,kBAAA,CAAmB,KAAA,CAAM,SAAS,CAAC,CAAA,CAAA;AACzH,IAAA,MAAM,MAAA,GAAS,MAAA,CAAO,GAAA,CAAI,GAAG,CAAA;AAC7B,IAAA,IAAI,MAAA,EAAQ,MAAA,CAAO,IAAA,CAAK,KAAK,CAAA;AAAA,SACxB,MAAA,CAAO,GAAA,CAAI,GAAA,EAAK,CAAC,KAAK,CAAC,CAAA;AAAA,EAC9B;AACA,EAAA,MAAM,YAAwB,EAAC;AAC/B,EAAA,KAAA,MAAW,MAAA,IAAU,MAAA,CAAO,MAAA,EAAO,EAAG;AACpC,IAAA,IAAI,MAAA,CAAO,SAAS,CAAA,EAAG;AACvB,IAAA,MAAM,KAAA,GAAQ,OAAO,CAAC,CAAA;AACtB,IAAA,SAAA,CAAU,IAAA,CAAK;AAAA,MACb,OAAO,KAAA,CAAM,KAAA;AAAA,MACb,SAAS,KAAA,CAAM,OAAA;AAAA,MACf,KAAK,KAAA,CAAM,GAAA;AAAA,MACX,QAAQ,KAAA,CAAM,MAAA;AAAA,MACd,WAAW,KAAA,CAAM,SAAA;AAAA,MACjB,SAAS,MAAA,CAAO,GAAA,CAAI,CAAC,CAAA,KAAM,EAAE,MAAM;AAAA,KACpC,CAAA;AAAA,EACH;AACA,EAAA,OAAO,SAAA;AACT;AAKA,SAAS,UAAU,KAAA,EAA8B;AAC/C,EAAA,IAAI,KAAA,CAAM,MAAA,KAAW,gBAAA,EAAkB,OAAO,MAAM,MAAA,IAAU,EAAA;AAC9D,EAAA,MAAM,OAAO,KAAA,CAAM,IAAA;AACnB,EAAA,MAAM,OAAO,IAAA,CAAK,MAAA;AAClB,EAAA,IAAI,OAAO,IAAA,KAAS,QAAA,IAAY,IAAA,KAAS,MAAM,OAAO,gBAAA;AACtD,EAAA,OAAO,CAAA,EAAG,gBAAgB,CAAA,CAAA,EAAI,WAAA,CAAY,IAAI,CAAC,CAAA,CAAA;AACjD;AAEA,IAAM,aAAA,uBAAoB,OAAA,EAAwB;AAClD,IAAI,eAAA,GAAkB,CAAA;AAEtB,SAAS,YAAY,IAAA,EAAsB;AACzC,EAAA,IAAI,EAAA,GAAK,aAAA,CAAc,GAAA,CAAI,IAAI,CAAA;AAC/B,EAAA,IAAI,OAAO,MAAA,EAAW;AACpB,IAAA,EAAA,GAAK,eAAA,EAAA;AACL,IAAA,aAAA,CAAc,GAAA,CAAI,MAAM,EAAE,CAAA;AAAA,EAC5B;AACA,EAAA,OAAO,EAAA;AACT;AAkBA,SAAS,aAAa,MAAA,EAA+B;AACnD,EAAA,OAAO,EAAE,EAAA,EAAI,MAAA,CAAO,EAAA,EAAI,WAAA,EAAa,EAAC,EAAG,QAAA,EAAU,cAAA,CAAe,MAAM,CAAA,EAAE;AAC5E;AAyBO,SAAS,oBAAoB,MAAA,EAAgC;AAClE,EAAA,MAAM,QAAA,GAAW,KAAA,CAAM,OAAA,CAAQ,MAAA,CAAO,QAAQ,CAAA,GACzC,MAAA,CAAO,QAAA,GACR,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,QAAmD,CAAA;AAC5E,EAAA,MAAM,OAAA,GAAU,MAAA,CAAO,OAAA,IAAW,EAAC;AACnC,EAAA,MAAM,cAAA,GAAiB,OAAA,CAAQ,MAAA,CAAO,CAAC,CAAA,KAAM,EAAE,KAAA,KAAU,QAAQ,CAAA,CAAE,GAAA,CAAI,YAAY,CAAA;AACnF,EAAA,MAAM,aAAA,GAAgB,OAAA,CAAQ,MAAA,CAAO,CAAC,CAAA,KAAM,EAAE,KAAA,KAAU,QAAQ,CAAA,CAAE,GAAA,CAAI,YAAY,CAAA;AAClF,EAAA,MAAM,OAAA,GAAU,CAAC,GAAI,MAAA,CAAO,WAAW,EAAC,EAAI,GAAG,cAAc,CAAA;AAE7D,EAAA,MAAM,MAAkB,EAAC;AACzB,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAY;AAC7B,EAAA,MAAM,GAAA,GAAM,CAAC,SAAA,KAAyC;AACpD,IAAA,KAAA,MAAW,KAAK,SAAA,EAAW;AACzB,MAAA,MAAM,GAAA,GAAM,CAAA,EAAG,CAAA,CAAE,KAAK,CAAA,CAAA,EAAI,EAAE,OAAO,CAAA,CAAA,EAAI,CAAA,CAAE,GAAA,IAAO,EAAE,CAAA,CAAA,EAAI,EAAE,MAAA,IAAU,EAAE,CAAA,CAAA,EAC5D,kBAAA,CAAmB,CAAA,CAAE,SAAS,CAAC,CAAA,CAAA,EAAI,CAAA,CAAE,OAAA,CAAQ,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA;AAC9D,MAAA,IAAI,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA,EAAG;AACnB,MAAA,IAAA,CAAK,IAAI,GAAG,CAAA;AACZ,MAAA,GAAA,CAAI,KAAK,CAAC,CAAA;AAAA,IACZ;AAAA,EACF,CAAA;AAGA,EAAA,KAAA,MAAW,IAAA,IAAQ,CAAC,GAAG,QAAA,EAAU,GAAI,MAAA,CAAO,OAAA,IAAW,EAAG,GAAG,GAAA,CAAI,aAAA,CAAc,CAAC,IAAI,CAAC,CAAC,CAAA;AAEtF,EAAA,IAAI,QAAQ,MAAA,GAAS,CAAA,EAAG,GAAA,CAAI,aAAA,CAAc,OAAO,CAAC,CAAA;AAKlD,EAAA,MAAM,MAAA,GAAS;AAAA,IACb,GAAG,SAAS,MAAA,CAAO,CAAC,MAAO,CAAA,CAAE,GAAA,EAA0C,WAAW,MAAS,CAAA;AAAA,IAC3F,GAAG;AAAA,GACL;AACA,EAAA,IAAI,OAAO,MAAA,GAAS,CAAA,EAAG,GAAA,CAAI,aAAA,CAAc,MAAM,CAAC,CAAA;AAEhD,EAAA,OAAO,GAAA;AACT;AAWO,SAAS,eAAe,QAAA,EAA4B;AACzD,EAAA,MAAM,QAAQ,WAAA,CAAY;AAAA,IACxB,MAAA,EAAQ,CAAC,EAAE,OAAA,EAAS,GAAA,EAAK,KAAA,EAAO,QAAA,CAAS,KAAA,KAAU,KAAA,GAAQ,GAAA,GAAM,QAAA,CAAS,KAAA,EAAO,CAAA;AAAA,IACjF,SAAS,QAAA,CAAS,OAAA;AAAA,IAClB,KAAK,QAAA,CAAS,GAAA;AAAA,IACd,QAAQ,QAAA,CAAS,MAAA;AAAA,IACjB,WAAW,QAAA,CAAS;AAAA,GACrB,CAAA;AACD,EAAA,OAAO,GAAG,KAAK,CAAA,oBAAA,EAAkB,SAAS,OAAA,CAAQ,IAAA,CAAK,IAAI,CAAC,CAAA,CAAA;AAC9D;AAmBO,SAAS,oBAAA,CACd,QACA,IAAA,GAAkC,CAAC,MAAM,OAAA,CAAQ,IAAA,CAAK,CAAC,CAAA,EAC3C;AACZ,EAAA,MAAM,SAAA,GAAY,oBAAoB,MAAM,CAAA;AAC5C,EAAA,KAAA,MAAW,KAAK,SAAA,EAAW;AACzB,IAAA,IAAA;AAAA,MACE,CAAA;AAAA,EAAA,EAC+E,cAAA,CAAe,CAAC,CAAC,CAAA;AAAA,KAClG;AAAA,EACF;AACA,EAAA,OAAO,SAAA;AACT","file":"chunk-CKADTCHK.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          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 a = actionsRef.current.get(id);\n        // Same resolution order as `trigger`: the action's declared `requires`\n        // when it has one, the legacy fixed bag otherwise. The fixed bag has no\n        // `applyOps`, so the paint actions — which declare it and are the only\n        // callers of `begin` — used to fall back to the scene's own history\n        // instead of the consumer's.\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        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/clipboard.d.ts

@@ -1,5 +1,5 @@
-import { N as NodeId } from './types-vqxpCFVp.js';
-import { C as ClipboardSnapshot, I as InsertAdapter } from './types-DpQ0cWYC.js';
+import { N as NodeId } from './types-C2R2bjxf.js';
+import { C as ClipboardSnapshot, I as InsertAdapter } from './types-DbysOO-2.js';
 import '@weasel-js/history';
 import './path-B6MMiodD.js';
 

package/dist/clipboard.js

@@ -1,4 +1,4 @@
-export { WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps } from './chunk-JOSUVS6C.js';
+export { WEASEL_CLIPBOARD_MIME, WEASEL_CLIPBOARD_MIME_WEB, buildWeaselClipboardText, embedWeaselMetadataInSvg, extractWeaselClipboardFromSvg, parseWeaselClipboardText, sniffWeaselClipboardText, useClipboardOps } from './chunk-ADWOB5K2.js';
 import './chunk-BHVYVFGV.js';
 import './chunk-GVCNT7UH.js';
 //# sourceMappingURL=clipboard.js.map

package/dist/clone.d.ts

@@ -1,6 +1,6 @@
-import { C as CloneBehavior } from './types-ByZxoD6P.js';
+import { C as CloneBehavior } from './types-BhrifbZ1.js';
 import '@weasel-js/history';
-import './types-DpQ0cWYC.js';
+import './types-DbysOO-2.js';
 
 /** Clone-on-alt-drag behavior for `useClone`; activates when Alt/Option is held at drag start. */
 declare function cloneByAltDrag(): CloneBehavior;

package/dist/{geometry-5X6TrAkX.d.ts → geometry-C56YbnfD.d.ts}

@@ -1,5 +1,5 @@
 import { V as View } from './view-DSQgxBJB.js';
-import { R as ResizePose, a as RotatedPose } from './types-ByZxoD6P.js';
+import { R as ResizePose, a as RotatedPose } from './types-BhrifbZ1.js';
 
 /**
  * Axis-aligned rectangle in world space. Kit-wide `Bounds` shape used by

package/dist/{grid-sfilv5HP.d.ts → grid-DqOi0Vgi.d.ts}

@@ -1,4 +1,4 @@
-import { b as MoveBehavior, S as SnapStrategy } from './types-ByZxoD6P.js';
+import { b as MoveBehavior, S as SnapStrategy } from './types-BhrifbZ1.js';
 import { D as DebugSink } from './types-BHK2dkMu.js';
 
 /**