@weasel-js/core 1.9.4 → 1.10.0

package/dist/canvas/SceneCanvas/toolRegistry.js

@@ -0,0 +1,23 @@
+import { IS_DEV as e } from "./isDev.js";
+import { featureToolIds as t } from "./features.js";
+import { BUILTIN_TOOL_IDS as n } from "./props.js";
+//#region src/canvas/SceneCanvas/toolRegistry.ts
+function r(r) {
+	let { builtins: i, defaultTools: a = [], enabled: o, patch: s, dev: c = e } = r, l = {}, u = t(o);
+	for (let e of n) {
+		let t = s?.[e];
+		t !== !1 && (t === !0 || a.includes(e) || u.has(e)) && (l[e] = i[e]);
+	}
+	for (let [e, t] of Object.entries(s ?? {})) if (t !== !1) {
+		if (t === !0) {
+			c && !n.includes(e) && console.warn(`[SceneCanvas] tools.${e}=true is not a known built-in id; ignoring`);
+			continue;
+		}
+		c && e in l && console.warn(`[SceneCanvas] tools prop overrides bundled "${e}" tool`), l[e] = t;
+	}
+	return l;
+}
+//#endregion
+export { r as resolveToolRegistry };
+
+//# sourceMappingURL=toolRegistry.js.map

package/dist/canvas/SceneCanvas/toolRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolRegistry.js","names":["resolveToolRegistry","IS_DEV","args","registry","preset","featureToolIds","enabled","id","BUILTIN_TOOL_IDS","patched","patch","defaultTools","builtins","value","dev"],"sources":["../../../src/canvas/SceneCanvas/toolRegistry.ts"],"sourcesContent":["import type { Tool } from 'tools/overlayBinding';\nimport { featureToolIds, type BaseFeature } from './features';\nimport { IS_DEV } from './isDev';\nimport { BUILTIN_TOOL_IDS, type BuiltinToolId } from './props';\n\n/** The patch form of `<SceneCanvas tools>`: per id, `true` mounts that\n *  built-in, `false` leaves it out, and a tool adds or replaces one. */\nexport type ToolsPatch = Record<string, Tool | true | false>;\n\n/** One tool per built-in id, mounted or not. */\nexport type BuiltinTools = Record<BuiltinToolId, Tool>;\n\nexport interface ResolveToolRegistryArgs {\n  builtins: BuiltinTools;\n  /** Built-ins asked for by id. */\n  defaultTools?: readonly BuiltinToolId[];\n  /** The presets the canvas runs with, each bringing the tools its\n   *  `FEATURE_PRESETS` row names. */\n  enabled: ReadonlySet<BaseFeature>;\n  patch: ToolsPatch | null;\n  /** Whether to warn about a patch entry that is probably a mistake. */\n  dev?: boolean;\n}\n\n/**\n * The tool registry a canvas mounts when it is not handed a whole `ToolsApi`.\n *\n * Built-ins come first, in `BUILTIN_TOOL_IDS` order whatever order they were\n * asked for in; a patch tool replaces a mounted one where it stands, and any\n * other is appended in patch order. That order is the palette's.\n */\nexport function resolveToolRegistry(args: ResolveToolRegistryArgs): Record<string, Tool> {\n  const { builtins, defaultTools = [], enabled, patch, dev = IS_DEV } = args;\n  const registry: Record<string, Tool> = {};\n  const preset = featureToolIds(enabled);\n  for (const id of BUILTIN_TOOL_IDS) {\n    const patched = patch?.[id];\n    if (patched === false) continue;\n    const asked = patched === true || defaultTools.includes(id) || preset.has(id);\n    if (asked) registry[id] = builtins[id];\n  }\n  for (const [id, value] of Object.entries(patch ?? {})) {\n    if (value === false) continue;\n    if (value === true) {\n      if (dev && !(BUILTIN_TOOL_IDS as readonly string[]).includes(id)) {\n        console.warn(`[SceneCanvas] tools.${id}=true is not a known built-in id; ignoring`);\n      }\n      continue;\n    }\n    if (dev && id in registry) {\n      console.warn(`[SceneCanvas] tools prop overrides bundled \"${id}\" tool`);\n    }\n    registry[id] = value;\n  }\n  return registry;\n}\n"],"mappings":";;;;AA+BA,SAAgBA,EAAoB,GAAqD;CACvF,IAAM,EAAE,aAAU,kBAAe,CAAC,GAAG,YAAS,UAAO,SAAMC,MAAWC,GAChEC,IAAiC,CAAC,GAClCC,IAASC,EAAeC,CAAO;CACrC,KAAK,IAAMC,KAAMC,GAAkB;EACjC,IAAMC,IAAUC,IAAQH;EACxB,AAAIE,MAAY,OACFA,MAAY,MAAQE,EAAa,SAASJ,CAAE,KAAKH,EAAO,IAAIG,CAAE,OACjE,EAASA,KAAMK,EAASL;CACrC;CACA,KAAK,IAAM,CAACA,GAAIM,MAAU,OAAO,QAAQH,KAAS,CAAC,CAAC,GAClD,IAAIG,MAAU,IACd;MAAIA,MAAU,IAAM;GAClB,AAAIC,KAAO,CAAEN,EAAuC,SAASD,CAAE,KAC7D,QAAQ,KAAK,uBAAuBA,EAAG,2CAA2C;GAEpF;EACF;EAIA,AAHIO,KAAOP,KAAMJ,KACf,QAAQ,KAAK,+CAA+CI,EAAG,OAAO,GAExE,EAASA,KAAMM;CAJf;CAMF,OAAOV;AACT"}

package/dist/canvas/SceneCanvas/useActionsPropResolver.js

@@ -42,7 +42,12 @@ function r(r, i) {
 		i
 	]);
 }
+function i(e, t) {
+	if (e === null) return null;
+	let n = { ...e ?? {} };
+	return t in n || (n[t] = null), n;
+}
 //#endregion
-export { r as useActionsPropResolver };
+export { i as actionsMuting, r as useActionsPropResolver };
 
 //# sourceMappingURL=useActionsPropResolver.js.map

package/dist/canvas/SceneCanvas/useActionsPropResolver.js.map

@@ -1 +1 @@
-{"version":3,"file":"useActionsPropResolver.js","names":["useActionsPropResolver","reg","useActionsRegistry","actionsRef","useLatest","actions","prop","unregisters","id","a","u","warnedIds","slotId","entry","isFull","existing","_drop","rest","merged","rev"],"sources":["../../../src/canvas/SceneCanvas/useActionsPropResolver.ts"],"sourcesContent":["/**\n * `useActionsPropResolver` — applies the `actions` prop overrides on top of\n * whatever `useStandardActions` registered. Runs after it (caller mounts this\n * hook last). Resolution rules:\n *\n *   actions === null           → mute every currently-registered action\n *   actions[id] === null       → mute that id\n *   actions[id] = partial      → merge onto the existing descriptor (slot wins\n *                                over entry.id; warns once on mismatch)\n *   actions[id] = full (new)   → register alongside defaults\n *\n * `null` mutes rather than unregisters: the opt-out belongs to this canvas, so\n * a sibling sharing the registry keeps the action and this canvas's unmount\n * gives it back.\n */\nimport { useEffect } from 'react';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Action } from '@weasel-js/routing';\n\n/** `rev` re-applies the overrides when it changes — pass whatever changes when\n *  the set they sit on is re-registered. */\nexport function useActionsPropResolver(actions: ActionsProp | undefined, rev?: string): void {\n  const reg = useActionsRegistry();\n  const actionsRef = useLatest(actions);\n\n  useEffect(() => {\n    if (!reg) return;\n    const prop = actionsRef.current;\n\n    const unregisters: Array<() => void> = [];\n\n    if (prop === null) {\n      for (const id of reg.list().map((a) => a.id)) unregisters.push(reg.mute(id));\n      return () => { for (const u of unregisters) u(); };\n    }\n\n    if (!prop) return;\n\n    const warnedIds = new Set<string>();\n\n    for (const [slotId, entry] of Object.entries(prop)) {\n      if (entry === null) {\n        unregisters.push(reg.mute(slotId));\n        continue;\n      }\n\n      const isFull = (e: Partial<Action>): e is Action =>\n        typeof e.id === 'string' && typeof e.label === 'string' && !!e.invoker;\n      const existing = reg.list().find((a) => a.id === slotId);\n\n      if (!existing) {\n        if (isFull(entry)) {\n          unregisters.push(reg.register(entry));\n        } else if (!warnedIds.has(slotId)) {\n          warnedIds.add(slotId);\n          console.warn(\n            `weasel actions resolver: actions[\"${slotId}\"] is a partial Action but no default ` +\n            `with this id exists. Pass a complete {id, label, invoker} descriptor.`,\n          );\n        }\n        continue;\n      }\n\n      if (entry.id !== undefined && entry.id !== slotId && !warnedIds.has(`mismatch:${slotId}`)) {\n        warnedIds.add(`mismatch:${slotId}`);\n        console.warn(\n          `weasel actions resolver: actions[\"${slotId}\"].id=\"${entry.id as string}\" mismatches the slot key. ` +\n          `Ignoring the id field; the action remains at id=\"${slotId}\".`,\n        );\n      }\n      const { id: _drop, ...rest } = entry;\n      void _drop;\n      const merged: Action = { ...existing, ...rest };\n      // No explicit restore: `register` stacks, so popping `merged` uncovers\n      // the descriptor it displaced. Re-registering `existing` here would push\n      // a stale snapshot back on top and never take it off again.\n      unregisters.push(reg.register(merged));\n    }\n\n    return () => { for (const u of unregisters) u(); };\n  }, [reg, actions, actionsRef, rev]);\n}\n"],"mappings":";;;;AAuBA,SAAgBA,EAAuB,GAAkC,GAAoB;CAC3F,IAAMC,IAAMC,EAAmB,GACzBC,IAAaC,EAAUC,CAAO;CAEpC,QAAgB;EACd,IAAI,CAACJ,GAAK;EACV,IAAMK,IAAOH,EAAW,SAElBI,IAAiC,CAAC;EAExC,IAAID,MAAS,MAAM;GACjB,KAAK,IAAME,KAAMP,EAAI,KAAK,CAAC,CAAC,KAAK,MAAMQ,EAAE,EAAE,GAAG,EAAY,KAAKR,EAAI,KAAKO,CAAE,CAAC;GAC3E,aAAa;IAAE,KAAK,IAAME,KAAKH,GAAa,EAAE;GAAG;EACnD;EAEA,IAAI,CAACD,GAAM;EAEX,IAAMK,oBAAY,IAAI,IAAY;EAElC,KAAK,IAAM,CAACC,GAAQC,MAAU,OAAO,QAAQP,CAAI,GAAG;GAClD,IAAIO,MAAU,MAAM;IAClB,EAAY,KAAKZ,EAAI,KAAKW,CAAM,CAAC;IACjC;GACF;GAEA,IAAME,KAAU,MACd,OAAO,EAAE,MAAO,YAAY,OAAO,EAAE,SAAU,YAAY,CAAC,CAAC,EAAE,SAC3DC,IAAWd,EAAI,KAAK,CAAC,CAAC,MAAM,MAAMQ,EAAE,OAAOG,CAAM;GAEvD,IAAI,CAACG,GAAU;IACb,AAAID,EAAOD,CAAK,IACdN,EAAY,KAAKN,EAAI,SAASY,CAAK,CAAC,IAC1BF,EAAU,IAAIC,CAAM,MAC9BD,EAAU,IAAIC,CAAM,GACpB,QAAQ,KACN,qCAAqCA,EAAO,4GAE9C;IAEF;GACF;GAEA,AAAIC,EAAM,OAAO,KAAA,KAAaA,EAAM,OAAOD,KAAU,CAACD,EAAU,IAAI,YAAYC,GAAQ,MACtFD,EAAU,IAAI,YAAYC,GAAQ,GAClC,QAAQ,KACN,qCAAqCA,EAAO,SAASC,EAAM,GAAa,8EACpBD,EAAO,GAC7D;GAEF,IAAM,EAAE,IAAII,GAAO,GAAGC,MAASJ,GAEzBK,IAAiB;IAAE,GAAGH;IAAU,GAAGE;GAAK;GAI9C,EAAY,KAAKhB,EAAI,SAASiB,CAAM,CAAC;EACvC;EAEA,aAAa;GAAE,KAAK,IAAMR,KAAKH,GAAa,EAAE;EAAG;CACnD,GAAG;EAACN;EAAKI;EAASF;EAAYgB;CAAG,CAAC;AACpC"}
+{"version":3,"file":"useActionsPropResolver.js","names":["useActionsPropResolver","reg","useActionsRegistry","actionsRef","useLatest","actions","prop","unregisters","id","a","u","warnedIds","slotId","entry","isFull","existing","_drop","rest","merged","rev","actionsMuting"],"sources":["../../../src/canvas/SceneCanvas/useActionsPropResolver.ts"],"sourcesContent":["/**\n * Applies the `actions` prop overrides on top of whatever is already\n * registered, so the caller mounts this hook last.\n *\n *   actions === null           → mute every currently-registered action\n *   actions[id] === null       → mute that id\n *   actions[id] = partial      → merge onto the existing descriptor (slot wins\n *                                over entry.id; warns once on mismatch)\n *   actions[id] = full (new)   → register alongside defaults\n *\n * `null` mutes rather than unregisters: the opt-out belongs to this canvas, so\n * a sibling sharing the registry keeps the action and this canvas's unmount\n * gives it back.\n */\nimport { useEffect } from 'react';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport type { Action } from '@weasel-js/routing';\n\n/** `rev` re-applies the overrides when it changes — pass whatever changes when\n *  the set they sit on is re-registered. */\nexport function useActionsPropResolver(actions: ActionsProp | undefined, rev?: string): void {\n  const reg = useActionsRegistry();\n  const actionsRef = useLatest(actions);\n\n  useEffect(() => {\n    if (!reg) return;\n    const prop = actionsRef.current;\n\n    const unregisters: Array<() => void> = [];\n\n    if (prop === null) {\n      for (const id of reg.list().map((a) => a.id)) unregisters.push(reg.mute(id));\n      return () => { for (const u of unregisters) u(); };\n    }\n\n    if (!prop) return;\n\n    const warnedIds = new Set<string>();\n\n    for (const [slotId, entry] of Object.entries(prop)) {\n      if (entry === null) {\n        unregisters.push(reg.mute(slotId));\n        continue;\n      }\n\n      const isFull = (e: Partial<Action>): e is Action =>\n        typeof e.id === 'string' && typeof e.label === 'string' && !!e.invoker;\n      const existing = reg.list().find((a) => a.id === slotId);\n\n      if (!existing) {\n        if (isFull(entry)) {\n          unregisters.push(reg.register(entry));\n        } else if (!warnedIds.has(slotId)) {\n          warnedIds.add(slotId);\n          console.warn(\n            `weasel actions resolver: actions[\"${slotId}\"] is a partial Action but no default ` +\n            `with this id exists. Pass a complete {id, label, invoker} descriptor.`,\n          );\n        }\n        continue;\n      }\n\n      if (entry.id !== undefined && entry.id !== slotId && !warnedIds.has(`mismatch:${slotId}`)) {\n        warnedIds.add(`mismatch:${slotId}`);\n        console.warn(\n          `weasel actions resolver: actions[\"${slotId}\"].id=\"${entry.id as string}\" mismatches the slot key. ` +\n          `Ignoring the id field; the action remains at id=\"${slotId}\".`,\n        );\n      }\n      const { id: _drop, ...rest } = entry;\n      void _drop;\n      const merged: Action = { ...existing, ...rest };\n      // No explicit restore: `register` stacks, so popping `merged` uncovers\n      // the descriptor it displaced. Re-registering `existing` here would push\n      // a stale snapshot back on top and never take it off again.\n      unregisters.push(reg.register(merged));\n    }\n\n    return () => { for (const u of unregisters) u(); };\n  }, [reg, actions, actionsRef, rev]);\n}\n\n/**\n * `actions` with `id` muted. A caller's own entry for `id` still wins, and\n * `null` (every default muted) is left as it is.\n */\nexport function actionsMuting(actions: ActionsProp | undefined, id: string): ActionsProp {\n  if (actions === null) return null;\n  const merged = { ...(actions ?? {}) } as Record<string, unknown>;\n  if (!(id in merged)) merged[id] = null;\n  return merged as ActionsProp;\n}\n"],"mappings":";;;;AAsBA,SAAgBA,EAAuB,GAAkC,GAAoB;CAC3F,IAAMC,IAAMC,EAAmB,GACzBC,IAAaC,EAAUC,CAAO;CAEpC,QAAgB;EACd,IAAI,CAACJ,GAAK;EACV,IAAMK,IAAOH,EAAW,SAElBI,IAAiC,CAAC;EAExC,IAAID,MAAS,MAAM;GACjB,KAAK,IAAME,KAAMP,EAAI,KAAK,CAAC,CAAC,KAAK,MAAMQ,EAAE,EAAE,GAAG,EAAY,KAAKR,EAAI,KAAKO,CAAE,CAAC;GAC3E,aAAa;IAAE,KAAK,IAAME,KAAKH,GAAa,EAAE;GAAG;EACnD;EAEA,IAAI,CAACD,GAAM;EAEX,IAAMK,oBAAY,IAAI,IAAY;EAElC,KAAK,IAAM,CAACC,GAAQC,MAAU,OAAO,QAAQP,CAAI,GAAG;GAClD,IAAIO,MAAU,MAAM;IAClB,EAAY,KAAKZ,EAAI,KAAKW,CAAM,CAAC;IACjC;GACF;GAEA,IAAME,KAAU,MACd,OAAO,EAAE,MAAO,YAAY,OAAO,EAAE,SAAU,YAAY,CAAC,CAAC,EAAE,SAC3DC,IAAWd,EAAI,KAAK,CAAC,CAAC,MAAM,MAAMQ,EAAE,OAAOG,CAAM;GAEvD,IAAI,CAACG,GAAU;IACb,AAAID,EAAOD,CAAK,IACdN,EAAY,KAAKN,EAAI,SAASY,CAAK,CAAC,IAC1BF,EAAU,IAAIC,CAAM,MAC9BD,EAAU,IAAIC,CAAM,GACpB,QAAQ,KACN,qCAAqCA,EAAO,4GAE9C;IAEF;GACF;GAEA,AAAIC,EAAM,OAAO,KAAA,KAAaA,EAAM,OAAOD,KAAU,CAACD,EAAU,IAAI,YAAYC,GAAQ,MACtFD,EAAU,IAAI,YAAYC,GAAQ,GAClC,QAAQ,KACN,qCAAqCA,EAAO,SAASC,EAAM,GAAa,8EACpBD,EAAO,GAC7D;GAEF,IAAM,EAAE,IAAII,GAAO,GAAGC,MAASJ,GAEzBK,IAAiB;IAAE,GAAGH;IAAU,GAAGE;GAAK;GAI9C,EAAY,KAAKhB,EAAI,SAASiB,CAAM,CAAC;EACvC;EAEA,aAAa;GAAE,KAAK,IAAMR,KAAKH,GAAa,EAAE;EAAG;CACnD,GAAG;EAACN;EAAKI;EAASF;EAAYgB;CAAG,CAAC;AACpC;AAMA,SAAgBC,EAAc,GAAkC,GAAyB;CACvF,IAAIf,MAAY,MAAM,OAAO;CAC7B,IAAMa,IAAS,EAAE,GAAIb,KAAW,CAAC,EAAG;CAEpC,OADMG,KAAMU,MAAS,EAAOV,KAAM,OAC3BU;AACT"}

package/dist/canvas/SceneCanvas/useBuiltinShapeTools.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBuiltinShapeTools.js","names":["useBuiltinShapeTools","args","snapPoint","options","insert","rect","useRectTool","ellipse","useEllipseTool","line","useLineTool","polygon","usePolygonTool","star","useStarTool","pencil","usePencilTool","usePenTool","useLassoTool","useTextTool"],"sources":["../../../src/canvas/SceneCanvas/useBuiltinShapeTools.tsx"],"sourcesContent":["/**\n * Shape-tool synthesis for `<SceneCanvas>` — calls the kit's per-shape tool\n * hooks; the `insert` dep mints each tool's node. Lets consumers opt into\n * a complete drawing toolset via `<SceneCanvas defaultTools={['rect', 'ellipse']}>`\n * without writing per-tool factory code.\n *\n * All hooks are always called (React rules of hooks) — `<SceneCanvas>` only\n * registers the ones requested via `defaultTools`.\n */\nimport { useEllipseTool } from 'tools/builtin/ellipse/useEllipseTool';\nimport { useLassoTool } from 'tools/builtin/lasso/useLassoTool';\nimport { useLineTool } from 'tools/builtin/line/useLineTool';\nimport { usePencilTool } from 'tools/builtin/pencil/usePencilTool';\nimport { usePenTool } from 'tools/builtin/pen/usePenTool';\nimport { usePolygonTool } from 'tools/builtin/polygon/usePolygonTool';\nimport { useRectTool } from 'tools/builtin/rect/useRectTool';\nimport { useStarTool } from 'tools/builtin/star/useStarTool';\nimport { useTextTool } from 'tools/builtin/text/useTextTool';\nimport type { AnyTool } from 'tools/overlayBinding';\nimport type { InsertToolOptions } from 'tools/builtin/shared/insertToolOptions';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport type { BuiltinShapeToolId } from 'core/shapeKinds';\n\n/** Per-tool option overrides for the built-in shape/lasso tools.\n *  Each entry is a narrow subset of the underlying hook's options surface\n *  — just the knobs that need consumer control under the bundle pattern. */\nexport interface BuiltinToolOptions {\n  lasso?: { mode?: LassoHitMode };\n  /** Insert-action options for every drag-to-insert tool (rect / ellipse /\n   *  line / polygon / star / pencil / text): `behaviors` become each insert\n   *  binding's `opts.behaviors`, the way `selectTool.move.behaviors` do for\n   *  move. */\n  insert?: InsertToolOptions;\n  /** Snap world-space points to the active grid (or any other snap target).\n   *\n   *  Registered as the `snap` dep, which `insertAction` applies to the\n   *  drag start and current point — so the live preview and the committed\n   *  geometry agree — and which the pen tool reads for its own anchor\n   *  placement. Covers every drag-to-insert tool (rect / ellipse / line /\n   *  polygon / star / text); freehand pencil samples are deliberately left\n   *  unsnapped. */\n  snapPoint?: (p: { x: number; y: number }) => { x: number; y: number };\n}\n\n// `BuiltinShapeToolId` / `KIT_SHAPE_KINDS` derive from the `core/shapeKinds`\n// table, a dependency-free module, so barrel-reachable code can reach them\n// without entering this file's `@weasel-js/core` self-import cycle.\n// Re-exported here so existing importers of this module keep working.\nexport { KIT_SHAPE_KINDS } from 'core/shapeKinds';\nexport type { BuiltinShapeToolId } from 'core/shapeKinds';\n\nexport interface UseBuiltinShapeToolsArgs {\n  /** Per-tool option overrides (lasso mode, etc.). */\n  options?: BuiltinToolOptions;\n}\n\nexport type BuiltinShapeTools = Record<BuiltinShapeToolId, AnyTool>;\n\n/** Synthesize the full shape-tool registry. Hooks always run; consumers\n *  decide via `wants(...)` which to register with `useTools`. */\nexport function useBuiltinShapeTools(args: UseBuiltinShapeToolsArgs = {}): BuiltinShapeTools {\n  const { options } = args;\n\n  const snapPoint = options?.snapPoint;\n  // Every tool here is a declarative shell: the `insert` dep\n  // (`useInsertDepSource`) mints the node, so a consumer wanting its own node\n  // shape overrides the dep, not the tool.\n  const insert = options?.insert ?? {};\n  const rect = useRectTool(insert);\n  const ellipse = useEllipseTool(insert);\n  const line = useLineTool(insert);\n  const polygon = usePolygonTool(insert);\n  const star = useStarTool(insert);\n  const pencil = usePencilTool(insert);\n  const pen = usePenTool({ snapPoint });\n  const lasso = useLassoTool(options?.lasso ?? {});\n  const text = useTextTool(insert);\n  return { rect, ellipse, line, polygon, star, pen, pencil, lasso, text };\n}\n"],"mappings":";;;;;;;;;;;AA4DA,SAAgBA,EAAqB,IAAiC,CAAC,GAAsB;CAC3F,IAAM,EAAE,eAAYC,GAEdC,IAAYC,GAAS,WAIrBC,IAASD,GAAS,UAAU,CAAC,GAC7BE,IAAOC,EAAYF,CAAM,GACzBG,IAAUC,EAAeJ,CAAM,GAC/BK,IAAOC,EAAYN,CAAM,GACzBO,IAAUC,EAAeR,CAAM,GAC/BS,IAAOC,EAAYV,CAAM,GACzBW,IAASC,EAAcZ,CAAM;CAInC,OAAO;EAAE;EAAM;EAAS;EAAM;EAAS;EAAM,KAHjCa,EAAW,EAAE,aAAU,CAGU;EAAK;EAAQ,OAF5CC,EAAaf,GAAS,SAAS,CAAC,CAEY;EAAO,MADpDgB,EAAYf,CACwC;CAAK;AACxE"}
+{"version":3,"file":"useBuiltinShapeTools.js","names":["useBuiltinShapeTools","args","snapPoint","options","insert","rect","useRectTool","ellipse","useEllipseTool","line","useLineTool","polygon","usePolygonTool","star","useStarTool","pencil","usePencilTool","usePenTool","useLassoTool","useTextTool"],"sources":["../../../src/canvas/SceneCanvas/useBuiltinShapeTools.tsx"],"sourcesContent":["/**\n * Shape-tool synthesis for `<SceneCanvas>` — calls the kit's per-shape tool\n * hooks; the `insert` dep mints each tool's node. Lets consumers opt into\n * a complete drawing toolset via `<SceneCanvas defaultTools={['rect', 'ellipse']}>`\n * without writing per-tool factory code.\n *\n * All hooks are always called (React rules of hooks) — `resolveToolRegistry`\n * decides which the canvas registers.\n */\nimport { useEllipseTool } from 'tools/builtin/ellipse/useEllipseTool';\nimport { useLassoTool } from 'tools/builtin/lasso/useLassoTool';\nimport { useLineTool } from 'tools/builtin/line/useLineTool';\nimport { usePencilTool } from 'tools/builtin/pencil/usePencilTool';\nimport { usePenTool } from 'tools/builtin/pen/usePenTool';\nimport { usePolygonTool } from 'tools/builtin/polygon/usePolygonTool';\nimport { useRectTool } from 'tools/builtin/rect/useRectTool';\nimport { useStarTool } from 'tools/builtin/star/useStarTool';\nimport { useTextTool } from 'tools/builtin/text/useTextTool';\nimport type { Tool } from 'tools/overlayBinding';\nimport type { InsertToolOptions } from 'tools/builtin/shared/insertToolOptions';\nimport type { LassoHitMode } from 'core/adapters/types';\nimport type { BuiltinShapeToolId } from 'core/shapeKinds';\n\n/** Per-tool option overrides for the built-in shape/lasso tools.\n *  Each entry is a narrow subset of the underlying hook's options surface\n *  — just the knobs that need consumer control under the bundle pattern. */\nexport interface BuiltinToolOptions {\n  lasso?: { mode?: LassoHitMode };\n  /** Insert-action options for every drag-to-insert tool (rect / ellipse /\n   *  line / polygon / star / pencil / text): `behaviors` become each insert\n   *  binding's `opts.behaviors`, the way `selectTool.move.behaviors` do for\n   *  move. */\n  insert?: InsertToolOptions;\n  /** Snap world-space points to the active grid (or any other snap target).\n   *\n   *  Registered as the `snap` dep, which `insertAction` applies to the\n   *  drag start and current point — so the live preview and the committed\n   *  geometry agree — and which the pen tool reads for its own anchor\n   *  placement. Covers every drag-to-insert tool (rect / ellipse / line /\n   *  polygon / star / text); freehand pencil samples are deliberately left\n   *  unsnapped. */\n  snapPoint?: (p: { x: number; y: number }) => { x: number; y: number };\n}\n\n// `BuiltinShapeToolId` / `KIT_SHAPE_KINDS` derive from the `core/shapeKinds`\n// table, a dependency-free module, so barrel-reachable code can reach them\n// without entering this file's `@weasel-js/core` self-import cycle.\n// Re-exported here so existing importers of this module keep working.\nexport { KIT_SHAPE_KINDS } from 'core/shapeKinds';\nexport type { BuiltinShapeToolId } from 'core/shapeKinds';\n\nexport interface UseBuiltinShapeToolsArgs {\n  /** Per-tool option overrides (lasso mode, etc.). */\n  options?: BuiltinToolOptions;\n}\n\nexport type BuiltinShapeTools = Record<BuiltinShapeToolId, Tool>;\n\n/** Synthesize the full shape-tool registry. Hooks always run;\n *  `useBuiltinTools` registers the ones asked for. */\nexport function useBuiltinShapeTools(args: UseBuiltinShapeToolsArgs = {}): BuiltinShapeTools {\n  const { options } = args;\n\n  const snapPoint = options?.snapPoint;\n  // Every tool here is a declarative shell: the `insert` dep\n  // (`useInsertDepSource`) mints the node, so a consumer wanting its own node\n  // shape overrides the dep, not the tool.\n  const insert = options?.insert ?? {};\n  const rect = useRectTool(insert);\n  const ellipse = useEllipseTool(insert);\n  const line = useLineTool(insert);\n  const polygon = usePolygonTool(insert);\n  const star = useStarTool(insert);\n  const pencil = usePencilTool(insert);\n  const pen = usePenTool({ snapPoint });\n  const lasso = useLassoTool(options?.lasso ?? {});\n  const text = useTextTool(insert);\n  return { rect, ellipse, line, polygon, star, pen, pencil, lasso, text };\n}\n"],"mappings":";;;;;;;;;;;AA4DA,SAAgBA,EAAqB,IAAiC,CAAC,GAAsB;CAC3F,IAAM,EAAE,eAAYC,GAEdC,IAAYC,GAAS,WAIrBC,IAASD,GAAS,UAAU,CAAC,GAC7BE,IAAOC,EAAYF,CAAM,GACzBG,IAAUC,EAAeJ,CAAM,GAC/BK,IAAOC,EAAYN,CAAM,GACzBO,IAAUC,EAAeR,CAAM,GAC/BS,IAAOC,EAAYV,CAAM,GACzBW,IAASC,EAAcZ,CAAM;CAInC,OAAO;EAAE;EAAM;EAAS;EAAM;EAAS;EAAM,KAHjCa,EAAW,EAAE,aAAU,CAGU;EAAK;EAAQ,OAF5CC,EAAaf,GAAS,SAAS,CAAC,CAEY;EAAO,MADpDgB,EAAYf,CACwC;CAAK;AACxE"}

package/dist/canvas/SceneCanvas/useBuiltinTools.js

@@ -0,0 +1,21 @@
+import { useHandTool as e } from "../../tools/builtin/hand/useHandTool.js";
+import { resolveToolRegistry as t } from "./toolRegistry.js";
+import { useBuiltinShapeTools as n } from "./useBuiltinShapeTools.js";
+//#region src/canvas/SceneCanvas/useBuiltinTools.ts
+function r(r) {
+	let { select: i, enabled: a, defaultTools: o, patch: s, toolOptions: c, inertia: l } = r, u = e({ inertia: l }), d = n({ options: c });
+	return t({
+		builtins: {
+			select: i,
+			hand: u,
+			...d
+		},
+		defaultTools: o,
+		enabled: a,
+		patch: s
+	});
+}
+//#endregion
+export { r as useBuiltinTools };
+
+//# sourceMappingURL=useBuiltinTools.js.map

package/dist/canvas/SceneCanvas/useBuiltinTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBuiltinTools.js","names":["useBuiltinTools","args","hand","useHandTool","shapes","useBuiltinShapeTools","toolOptions","resolveToolRegistry"],"sources":["../../../src/canvas/SceneCanvas/useBuiltinTools.ts"],"sourcesContent":["import type { InertiaConfig } from 'core/viewport/useDecayLoop';\nimport { useHandTool } from 'tools/builtin/hand';\nimport type { Tool } from 'tools/overlayBinding';\nimport type { BaseFeature } from './features';\nimport type { BuiltinToolId } from './props';\nimport { resolveToolRegistry, type ToolsPatch } from './toolRegistry';\nimport { useBuiltinShapeTools, type BuiltinToolOptions } from './useBuiltinShapeTools';\n\nexport interface UseBuiltinToolsArgs {\n  /** The canvas's select tool, which is built from its scene and pickers. */\n  select: Tool;\n  enabled: ReadonlySet<BaseFeature>;\n  defaultTools?: readonly BuiltinToolId[];\n  patch: ToolsPatch | null;\n  toolOptions?: BuiltinToolOptions;\n  /** `viewport.inertia`, which is the hand tool's. */\n  inertia?: boolean | InertiaConfig;\n}\n\n/** The registry of tools `<SceneCanvas>` mounts for itself. Every built-in's\n *  hook runs on every render; `resolveToolRegistry` decides which are in. */\nexport function useBuiltinTools(args: UseBuiltinToolsArgs): Record<string, Tool> {\n  const { select, enabled, defaultTools, patch, toolOptions, inertia } = args;\n  const hand = useHandTool({ inertia });\n  const shapes = useBuiltinShapeTools({ options: toolOptions });\n  return resolveToolRegistry({\n    builtins: { select, hand, ...shapes },\n    defaultTools,\n    enabled,\n    patch,\n  });\n}\n"],"mappings":";;;;AAqBA,SAAgBA,EAAgB,GAAiD;CAC/E,IAAM,EAAE,WAAQ,YAAS,iBAAc,UAAO,gBAAa,eAAYC,GACjEC,IAAOC,EAAY,EAAE,WAAQ,CAAC,GAC9BC,IAASC,EAAqB,EAAE,SAASC,EAAY,CAAC;CAC5D,OAAOC,EAAoB;EACzB,UAAU;GAAE;GAAQ;GAAM,GAAGH;EAAO;EACpC;EACA;EACA;CACF,CAAC;AACH"}

package/dist/canvas/SceneCanvas/useCanvasCamera.js

@@ -0,0 +1,38 @@
+import { useViewAnimationOn as e } from "../../core/viewport/useViewAnimation.js";
+import { useCanvasView as t } from "../useCanvasView.js";
+import { useInsertionEffect as n, useMemo as r, useRef as i } from "react";
+import { useLatest as a } from "@weasel-js/react";
+import { useAnimator as o } from "@weasel-js/animator";
+//#region src/canvas/SceneCanvas/useCanvasCamera.ts
+function s(s) {
+	let { view: c, defaultView: l, onViewChange: u, viewBounds: d, width: f, height: p, requestRedraw: m } = s, h = a({
+		width: f,
+		height: p
+	}), g = i(null), _ = t({
+		view: c,
+		defaultView: l,
+		onViewChange: (e) => {
+			g.current?.stopIfExternal(), u?.(e);
+		},
+		viewBounds: d,
+		dims: () => h.current,
+		requestRedraw: m
+	}), v = o(), { viewRef: y, setViewFromInput: b } = _, x = r(() => ({
+		get: () => y.current,
+		set: b
+	}), [y, b]), S = e(x, v);
+	return n(() => {
+		g.current = S;
+	}), {
+		viewState: _,
+		viewAnimation: S,
+		camera: r(() => ({
+			target: S.viewTarget,
+			animator: v
+		}), [S, v])
+	};
+}
+//#endregion
+export { s as useCanvasCamera };
+
+//# sourceMappingURL=useCanvasCamera.js.map

package/dist/canvas/SceneCanvas/useCanvasCamera.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasCamera.js","names":["useCanvasCamera","opts","size","useLatest","animationRef","useRef","viewState","useCanvasView","onViewChange","next","animator","useAnimator","channel","useMemo","viewRef","setViewFromInput","viewAnimation","useViewAnimationOn","useInsertionEffect"],"sources":["../../../src/canvas/SceneCanvas/useCanvasCamera.ts"],"sourcesContent":["import { useInsertionEffect, useMemo, useRef } from 'react';\nimport { useAnimator } from '@weasel-js/animator';\nimport { useLatest } from '@weasel-js/react';\nimport { useViewAnimationOn, type ViewAnimationApi } from 'core/viewport/useViewAnimation';\nimport type { SceneCanvasApi } from '../canvasExtension';\nimport { useCanvasView, type CameraProps, type CanvasViewState } from '../useCanvasView';\n\n/**\n * The canvas's camera: the view `<Canvas>` looks through, the runner behind\n * `animateView`, and the target and animator it runs on.\n */\nexport function useCanvasCamera(opts: CameraProps & {\n  /** The size the camera looks through, which `viewBounds` clamps against. */\n  width: number;\n  height: number;\n  requestRedraw: () => void;\n}): {\n  viewState: CanvasViewState;\n  viewAnimation: ViewAnimationApi;\n  camera: SceneCanvasApi['camera'];\n} {\n  const { view, defaultView, onViewChange, viewBounds, width, height, requestRedraw } = opts;\n  const size = useLatest({ width, height });\n  const animationRef = useRef<ViewAnimationApi | null>(null);\n  const viewState = useCanvasView({\n    view,\n    defaultView,\n    // Every write to the view is reported here, so it is the runner's one\n    // interrupt feed.\n    onViewChange: (next) => {\n      animationRef.current?.stopIfExternal();\n      onViewChange?.(next);\n    },\n    viewBounds,\n    dims: () => size.current,\n    requestRedraw,\n  });\n\n  // The camera runs on its own animator, never the `animator` prop's: that prop\n  // is the consumer's scene animator, and their `cancelAll()` or `pause()` must\n  // not strand a zoom half-finished or freeze the camera.\n  const animator = useAnimator();\n  const { viewRef, setViewFromInput } = viewState;\n  const channel = useMemo(\n    () => ({ get: () => viewRef.current, set: setViewFromInput }),\n    [viewRef, setViewFromInput],\n  );\n  const viewAnimation = useViewAnimationOn(channel, animator);\n  useInsertionEffect(() => { animationRef.current = viewAnimation; });\n  const camera = useMemo(() => ({ target: viewAnimation.viewTarget, animator }), [viewAnimation, animator]);\n  return { viewState, viewAnimation, camera };\n}\n"],"mappings":";;;;;;AAWA,SAAgBA,EAAgB,GAS9B;CACA,IAAM,EAAE,SAAM,gBAAa,iBAAc,eAAY,UAAO,WAAQ,qBAAkBC,GAChFC,IAAOC,EAAU;EAAE;EAAO;CAAO,CAAC,GAClCC,IAAeC,EAAgC,IAAI,GACnDC,IAAYC,EAAc;EAC9B;EACA;EAGA,eAAe,MAAS;GAEtB,AADAH,EAAa,SAAS,eAAe,GACrCI,IAAeC,CAAI;EACrB;EACA;EACA,YAAYP,EAAK;EACjB;CACF,CAAC,GAKKQ,IAAWC,EAAY,GACvB,EAAE,YAAS,wBAAqBL,GAChCM,IAAUC,SACP;EAAE,WAAWC,EAAQ;EAAS,KAAKC;CAAiB,IAC3D,CAACD,GAASC,CAAgB,CAC5B,GACMC,IAAgBC,EAAmBL,GAASF,CAAQ;CAG1D,OAFAQ,QAAyB;EAAE,EAAa,UAAUF;CAAe,CAAC,GAE3D;EAAE;EAAW;EAAe,QADpBH,SAAe;GAAE,QAAQG,EAAc;GAAY;EAAS,IAAI,CAACA,GAAeN,CAAQ,CACpE;CAAO;AAC5C"}

package/dist/canvas/SceneCanvas/useCanvasDispatcher.js

@@ -0,0 +1,20 @@
+import { createDispatcherPreviewSources as e, createGestureSource as t } from "./dispatcherGestureBounds.js";
+import { useRef as n, useState as r } from "react";
+import { createDispatcher as i } from "@weasel-js/routing";
+//#region src/canvas/SceneCanvas/useCanvasDispatcher.ts
+function a() {
+	let a = n(null), o = n(null);
+	o.current ||= i({ getAction: (e) => a.current?.(e) });
+	let s = o.current, [c] = r(() => t(() => o.current)), [{ previewIdsExtra: l, previewPoseExtra: u }] = r(() => e(() => o.current));
+	return {
+		dispatcher: s,
+		getActionRef: a,
+		gestureSource: c,
+		previewIdsExtra: l,
+		previewPoseExtra: u
+	};
+}
+//#endregion
+export { a as useCanvasDispatcher };
+
+//# sourceMappingURL=useCanvasDispatcher.js.map

package/dist/canvas/SceneCanvas/useCanvasDispatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasDispatcher.js","names":["useCanvasDispatcher","getActionRef","useRef","dispatcherRef","createDispatcher","id","dispatcher","gestureSource","useState","createGestureSource","createDispatcherPreviewSources"],"sources":["../../../src/canvas/SceneCanvas/useCanvasDispatcher.ts"],"sourcesContent":["import { useRef, useState, type MutableRefObject } from 'react';\nimport { createDispatcher, type Action, type Dispatcher } from '@weasel-js/routing';\nimport type { GestureSource } from '../gestureBounds';\nimport { createDispatcherPreviewSources, createGestureSource } from './dispatcherGestureBounds';\n\n/**\n * One `Dispatcher` for the life of a `<SceneCanvas>`, shared by the gesture\n * mounter that pumps input into it and the layers that walk its in-flight\n * handles, with the lookups those layers and `<Canvas>` read it through.\n */\nexport function useCanvasDispatcher(): {\n  dispatcher: Dispatcher;\n  /** How the dispatcher resolves an action id at call time. Populated by\n   *  `StandardActionsRegistrar` once it has the registry in scope. */\n  getActionRef: MutableRefObject<((id: string) => Action | undefined) | null>;\n  /** In-flight preview ids, nascent-insert bounds, and the pump signal. */\n  gestureSource: GestureSource;\n  /** Ids whose committed paint an in-flight ghost hides. */\n  previewIdsExtra: () => string[];\n  /** The pose an in-flight handle proposes for an id. */\n  previewPoseExtra: (id: string) => unknown;\n} {\n  const getActionRef = useRef<((id: string) => Action | undefined) | null>(null);\n  const dispatcherRef = useRef<Dispatcher | null>(null);\n  if (!dispatcherRef.current) {\n    dispatcherRef.current = createDispatcher({\n      getAction: (id) => getActionRef.current?.(id),\n    });\n  }\n  const dispatcher = dispatcherRef.current;\n  const [gestureSource] = useState(() => createGestureSource(() => dispatcherRef.current));\n  const [{ previewIdsExtra, previewPoseExtra }] = useState(\n    () => createDispatcherPreviewSources(() => dispatcherRef.current),\n  );\n  return { dispatcher, getActionRef, gestureSource, previewIdsExtra, previewPoseExtra };\n}\n"],"mappings":";;;;AAUA,SAAgBA,IAWd;CACA,IAAMC,IAAeC,EAAoD,IAAI,GACvEC,IAAgBD,EAA0B,IAAI;CACpD,AACEC,EAAc,YAAUC,EAAiB,EACvC,YAAY,MAAOH,EAAa,UAAUI,CAAE,EAC9C,CAAC;CAEH,IAAMC,IAAaH,EAAc,SAC3B,CAACI,KAAiBC,QAAeC,QAA0BN,EAAc,OAAO,CAAC,GACjF,CAAC,EAAE,oBAAiB,yBAAsBK,QACxCE,QAAqCP,EAAc,OAAO,CAClE;CACA,OAAO;EAAE;EAAY;EAAc;EAAe;EAAiB;CAAiB;AACtF"}

package/dist/canvas/SceneCanvas/useCanvasSelection.js

@@ -0,0 +1,16 @@
+import { useSelection as e } from "../../core/selection/useSelection.js";
+import { readOnlySelection as t } from "../../core/selection/readOnlySelection.js";
+import { usePublishSceneSelection as n } from "../../core/selection/usePublishSceneSelection.js";
+import { useMemo as r } from "react";
+//#region src/canvas/SceneCanvas/useCanvasSelection.ts
+function i(i) {
+	let { scene: a, supplied: o, options: s, selectable: c, describeKind: l } = i, u = r(() => ({
+		scene: a,
+		...s ?? {}
+	}), [a, s]), d = e(u), f = o ?? d, p = c ? f : t(f);
+	return n(a, p.current, l), p;
+}
+//#endregion
+export { i as useCanvasSelection };
+
+//# sourceMappingURL=useCanvasSelection.js.map

package/dist/canvas/SceneCanvas/useCanvasSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasSelection.js","names":["useCanvasSelection","args","derivedOptions","useMemo","options","scene","internal","useSelection","base","supplied","selection","selectable","readOnlySelection","usePublishSceneSelection","describeKind"],"sources":["../../../src/canvas/SceneCanvas/useCanvasSelection.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport type { Node, NodeId, Scene } from 'core/scene/types';\nimport { readOnlySelection } from 'core/selection/readOnlySelection';\nimport { usePublishSceneSelection } from 'core/selection/usePublishSceneSelection';\nimport { useSelection, type SelectionApi, type UseSelectionOptions } from 'core/selection/useSelection';\n\n/**\n * The canvas's selection, published to any surrounding selection context.\n *\n * A caller-supplied api wins, and the one built here is then unused. The\n * built one is bound to the scene, so the selection an edit was made under\n * rides on the scene's history entries and undo can put it back.\n *\n * Everything the kit writes selection through (the `selection` dep, the\n * adapter's `setSelection`, ops committed through either) reads the returned\n * api, so on an unselectable canvas every write path here is closed. The\n * caller's own api is not wrapped and still writes.\n */\nexport function useCanvasSelection<TData, TLayer extends string, TPose>(args: {\n  scene: Scene<TData, TLayer, TPose>;\n  /** `<SceneCanvas selection>`. */\n  supplied: SelectionApi | undefined;\n  options: UseSelectionOptions | undefined;\n  selectable: boolean;\n  describeKind: ((node: Node<TData, TLayer, TPose>) => string | undefined) | undefined;\n}): SelectionApi {\n  const { scene, supplied, options, selectable, describeKind } = args;\n  const derivedOptions = useMemo<UseSelectionOptions>(\n    () => ({ scene, ...(options ?? {}) }),\n    [scene, options],\n  );\n  const internal = useSelection(derivedOptions);\n  const base = supplied ?? internal;\n  const selection = selectable ? base : readOnlySelection(base);\n  usePublishSceneSelection(scene, selection.current as readonly NodeId[], describeKind);\n  return selection;\n}\n"],"mappings":";;;;;AAkBA,SAAgBA,EAAwD,GAOvD;CACf,IAAM,EAAE,UAAO,aAAU,YAAS,eAAY,oBAAiBC,GACzDC,IAAiBC,SACd;EAAE;EAAO,GAAIC,KAAW,CAAC;CAAG,IACnC,CAACC,GAAOD,CAAO,CACjB,GACME,IAAWC,EAAaL,CAAc,GACtCM,IAAOC,KAAYH,GACnBI,IAAYC,IAAaH,IAAOI,EAAkBJ,CAAI;CAE5D,OADAK,EAAyBR,GAAOK,EAAU,SAA8BI,CAAY,GAC7EJ;AACT"}

package/dist/canvas/SceneCanvas/useCanvasTools.js

@@ -0,0 +1,67 @@
+import { createLongPressFeedbackContribution as e } from "../../features/longPress/longPressFeedback.js";
+import { KIT_STANDARD_ACTION_IDS as t } from "../../interactions/actions/useStandardActions.js";
+import { useTools as n } from "../../tools/overlayBinding.js";
+import { featureActionIds as r, featureAmbient as i, resolveFeatures as a } from "./features.js";
+import { useBuiltinTools as o } from "./useBuiltinTools.js";
+import { useEffect as s, useMemo as c } from "react";
+import { useLatest as l } from "@weasel-js/react";
+//#region src/canvas/SceneCanvas/useCanvasTools.ts
+function u(e) {
+	return typeof e.setActive == "function";
+}
+function d(e, t) {
+	let n = (e ?? []).join("|");
+	return c(() => a(e, { viewport: t }), [n, t]);
+}
+function f(t) {
+	let { select: r, enabled: i, tools: a, defaultTools: d, toolOptions: f, inertia: p, ambient: m, initialActiveTool: h, modes: g, onToolsCreated: _ } = t, v = a && u(a) ? a : null, y = o({
+		select: r,
+		enabled: i,
+		defaultTools: d,
+		patch: a && !u(a) ? a : null,
+		toolOptions: f,
+		inertia: p
+	}), b = c(() => e(), []), x = t.pressFeedback ?? !0, S = x === !0 ? b : x || null, C = c(() => S ? [...m ?? [], S] : m ?? [], [m, S]), w = n({
+		active: h ?? ("select" in y ? "select" : null),
+		registry: y,
+		...C.length ? { ambient: C } : {},
+		...g ? { modes: g } : {}
+	}), T = v ?? w, E = l(_);
+	return s(() => {
+		E.current?.(T);
+	}, [T, E]), {
+		tools: T,
+		internal: w,
+		takeover: v
+	};
+}
+function p(e) {
+	let { enabled: n, tools: a, move: o, rotate: s } = e, l = c(() => i(n, {
+		move: o,
+		rotate: s
+	}), [
+		n,
+		o,
+		s
+	]);
+	return {
+		contributions: l,
+		standardActionsExclude: c(() => {
+			let e = r(n), i = [
+				...Object.values(a.registry),
+				...a.ambient,
+				...l
+			];
+			for (let t of i) for (let n of t.bindings ?? []) e.add(n.actionId);
+			return t.filter((t) => !e.has(t));
+		}, [
+			n,
+			a,
+			l
+		])
+	};
+}
+//#endregion
+export { f as useCanvasTools, d as useEnabledFeatures, p as useFeatureBindings };
+
+//# sourceMappingURL=useCanvasTools.js.map

package/dist/canvas/SceneCanvas/useCanvasTools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasTools.js","names":["isToolsApi","tools","useEnabledFeatures","featuresKey","features","useMemo","resolveFeatures","hasViewport","useCanvasTools","toolsProp","args","takeover","registry","useBuiltinTools","defaultPressFeedback","createLongPressFeedbackContribution","feedbackOpt","pressFeedback","mergedAmbient","ambient","internal","useTools","initialActiveTool","modes","onToolsCreatedRef","useLatest","onToolsCreated","useEffect","useFeatureBindings","contributions","featureAmbient","enabled","move","rotate","include","featureActionIds","bound","entry","b","KIT_STANDARD_ACTION_IDS","id"],"sources":["../../../src/canvas/SceneCanvas/useCanvasTools.ts"],"sourcesContent":["import { useEffect, useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { KIT_STANDARD_ACTION_IDS } from 'interactions/actions/useStandardActions';\nimport { createLongPressFeedbackContribution } from '../../features/longPress/longPressFeedback';\nimport { useTools, type Contribution, type Tool, type ToolsApi } from '../../tools/overlayBinding';\nimport {\n  featureActionIds,\n  featureAmbient,\n  resolveFeatures,\n  type BaseFeature,\n  type Feature,\n  type FeatureBindingOptions,\n} from './features';\nimport type { SceneCanvasProps } from './props';\nimport type { ToolsPatch } from './toolRegistry';\nimport { useBuiltinTools } from './useBuiltinTools';\n\ntype Props = SceneCanvasProps<unknown, string, unknown>;\n\n/** Discriminate the polymorphic `tools` prop: `ToolsApi` has `setActive`\n *  / `active` / `registry`; the patch record shape has none of those. */\nfunction isToolsApi(tools: ToolsApi | ToolsPatch): tools is ToolsApi {\n  return typeof (tools as ToolsApi).setActive === 'function';\n}\n\n/** The presets a canvas runs with. Keyed on the ids, not the array, so an\n *  inline `features={['draw']}` does not re-derive every render. */\nexport function useEnabledFeatures(\n  features: readonly Feature[] | undefined,\n  hasViewport: boolean,\n): ReadonlySet<BaseFeature> {\n  const featuresKey = (features ?? []).join('|');\n  return useMemo(\n    () => resolveFeatures(features, { viewport: hasViewport }),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [featuresKey, hasViewport],\n  );\n}\n\n/**\n * The canvas's tools: a caller's own `ToolsApi` when the `tools` prop is one\n * (the takeover form), and otherwise the built-ins the presets and\n * `defaultTools` name, patched by a `tools` record.\n */\nexport function useCanvasTools(args: {\n  /** The canvas's select tool, which is built from its scene and pickers. */\n  select: Tool;\n  enabled: ReadonlySet<BaseFeature>;\n  tools: Props['tools'];\n  defaultTools: Props['defaultTools'];\n  toolOptions: Props['toolOptions'];\n  /** `viewport.inertia`, which is the hand tool's. */\n  inertia: NonNullable<Props['viewport']>['inertia'];\n  ambient: Props['ambient'];\n  /** `longPress.feedback`. Default true, which installs the kit's own. */\n  pressFeedback: NonNullable<Props['longPress']>['feedback'];\n  initialActiveTool: Props['initialActiveTool'];\n  modes: Props['modes'];\n  onToolsCreated: Props['onToolsCreated'];\n}): {\n  /** What the canvas routes input through: the takeover, or `internal`. */\n  tools: ToolsApi;\n  /** The canvas's own api, built whether or not a takeover replaces it. */\n  internal: ToolsApi;\n  takeover: ToolsApi | null;\n} {\n  const { select, enabled, tools: toolsProp, defaultTools, toolOptions, inertia, ambient, initialActiveTool, modes, onToolsCreated } = args;\n\n  const takeover = toolsProp && isToolsApi(toolsProp) ? toolsProp : null;\n  const registry = useBuiltinTools({\n    select,\n    enabled,\n    defaultTools,\n    patch: toolsProp && !isToolsApi(toolsProp) ? toolsProp : null,\n    toolOptions,\n    inertia,\n  });\n\n  const defaultPressFeedback = useMemo(() => createLongPressFeedbackContribution(), []);\n  const feedbackOpt = args.pressFeedback ?? true;\n  const pressFeedback = feedbackOpt === true ? defaultPressFeedback : feedbackOpt || null;\n  const mergedAmbient = useMemo(\n    () => (pressFeedback ? [...(ambient ?? []), pressFeedback] : (ambient ?? [])),\n    [ambient, pressFeedback],\n  );\n\n  const internal = useTools({\n    active: initialActiveTool ?? ('select' in registry ? 'select' : null),\n    registry,\n    ...(mergedAmbient.length ? { ambient: mergedAmbient } : {}),\n    ...(modes ? { modes } : {}),\n  });\n  const tools = takeover ?? internal;\n\n  const onToolsCreatedRef = useLatest(onToolsCreated);\n  useEffect(() => { onToolsCreatedRef.current?.(tools); }, [tools, onToolsCreatedRef]);\n\n  return { tools, internal, takeover };\n}\n\n/**\n * The presets' ambient bindings, and the kit-standard actions the canvas\n * leaves unregistered. The bindings are not tools and sit outside `tools`, so\n * they apply under a takeover too. An action is registered when a preset\n * names it or a tool or contribution on this canvas binds it: a tool brings\n * the actions it routes to, so `defaultTools={['rect']}` works under any preset.\n */\nexport function useFeatureBindings(args: {\n  enabled: ReadonlySet<BaseFeature>;\n  tools: Pick<ToolsApi, 'registry' | 'ambient'>;\n  move: FeatureBindingOptions['move'];\n  rotate: FeatureBindingOptions['rotate'];\n}): { contributions: Contribution[]; standardActionsExclude: string[] } {\n  const { enabled, tools, move, rotate } = args;\n  const contributions = useMemo<Contribution[]>(\n    () => featureAmbient(enabled, { move, rotate }),\n    [enabled, move, rotate],\n  );\n  const standardActionsExclude = useMemo(() => {\n    const include = featureActionIds(enabled);\n    const bound = [...Object.values(tools.registry), ...tools.ambient, ...contributions];\n    for (const entry of bound) {\n      for (const b of entry.bindings ?? []) include.add(b.actionId);\n    }\n    return KIT_STANDARD_ACTION_IDS.filter((id) => !include.has(id));\n  }, [enabled, tools, contributions]);\n  return { contributions, standardActionsExclude };\n}\n"],"mappings":";;;;;;;;AAqBA,SAASA,EAAW,GAAiD;CACnE,OAAO,OAAQC,EAAmB,aAAc;AAClD;AAIA,SAAgBC,EACd,GACA,GAC0B;CAC1B,IAAMC,KAAeC,KAAY,CAAC,EAAA,CAAG,KAAK,GAAG;CAC7C,OAAOC,QACCC,EAAgBF,GAAU,EAAE,UAAUG,EAAY,CAAC,GAEzD,CAACJ,GAAaI,CAAW,CAC3B;AACF;AAOA,SAAgBC,EAAe,GAqB7B;CACA,IAAM,EAAE,WAAQ,YAAS,OAAOC,GAAW,iBAAc,gBAAa,YAAS,YAAS,sBAAmB,UAAO,sBAAmBC,GAE/HC,IAAWF,KAAaT,EAAWS,CAAS,IAAIA,IAAY,MAC5DG,IAAWC,EAAgB;EAC/B;EACA;EACA;EACA,OAAOJ,KAAa,CAACT,EAAWS,CAAS,IAAIA,IAAY;EACzD;EACA;CACF,CAAC,GAEKK,IAAuBT,QAAcU,EAAoC,GAAG,CAAC,CAAC,GAC9EC,IAAcN,EAAK,iBAAiB,IACpCO,IAAgBD,MAAgB,KAAOF,IAAuBE,KAAe,MAC7EE,IAAgBb,QACbY,IAAgB,CAAC,GAAIE,KAAW,CAAC,GAAIF,CAAa,IAAKE,KAAW,CAAC,GAC1E,CAACA,GAASF,CAAa,CACzB,GAEMG,IAAWC,EAAS;EACxB,QAAQC,MAAsB,YAAYV,IAAW,WAAW;EAChE;EACA,GAAIM,EAAc,SAAS,EAAE,SAASA,EAAc,IAAI,CAAC;EACzD,GAAIK,IAAQ,EAAE,SAAM,IAAI,CAAC;CAC3B,CAAC,GACKtB,IAAQU,KAAYS,GAEpBI,IAAoBC,EAAUC,CAAc;CAGlD,OAFAC,QAAgB;EAAE,EAAkB,UAAU1B,CAAK;CAAG,GAAG,CAACA,GAAOuB,CAAiB,CAAC,GAE5E;EAAE;EAAO;EAAU;CAAS;AACrC;AASA,SAAgBI,EAAmB,GAKqC;CACtE,IAAM,EAAE,YAAS,UAAO,SAAM,cAAWlB,GACnCmB,IAAgBxB,QACdyB,EAAeC,GAAS;EAAE;EAAM;CAAO,CAAC,GAC9C;EAACA;EAASC;EAAMC;CAAM,CACxB;CASA,OAAO;EAAE;EAAe,wBARO5B,QAAc;GAC3C,IAAM6B,IAAUC,EAAiBJ,CAAO,GAClCK,IAAQ;IAAC,GAAG,OAAO,OAAOnC,EAAM,QAAQ;IAAG,GAAGA,EAAM;IAAS,GAAG4B;GAAa;GACnF,KAAK,IAAMQ,KAASD,GAClB,KAAK,IAAME,KAAKD,EAAM,YAAY,CAAC,GAAG,EAAQ,IAAIC,EAAE,QAAQ;GAE9D,OAAOC,EAAwB,QAAQ,MAAO,CAACL,EAAQ,IAAIM,CAAE,CAAC;EAChE,GAAG;GAACT;GAAS9B;GAAO4B;EAAa,CACT;CAAuB;AACjD"}

package/dist/canvas/SceneCanvas/useDispatcherOverlayLayer.js

@@ -1,9 +1,9 @@
 import { viewToTransform as e } from "../../core/viewport/view.js";
 import { worldToScreen as t } from "../../core/viewport/viewTransform.js";
-import { getImageBitmap as n } from "../../features/images/imageCache.js";
-import { OVERLAY_ROLE_STROKES as r } from "../overlayRoleStrokes.js";
-import { gestureOverlaysFrom as i, isVisibleFrom as a } from "../drawEnvelope.js";
-import { resolveOverlays as o } from "../../interactions/actions/resolveOverlays.js";
+import { OVERLAY_ROLE_STROKES as n } from "../overlayRoleStrokes.js";
+import { gestureOverlaysFrom as r, isVisibleFrom as i } from "../drawEnvelope.js";
+import { resolveOverlays as a } from "../../interactions/actions/resolveOverlays.js";
+import { getImageBitmap as o } from "@weasel-js/renderer";
 import { ellipsePath as s, linePath as c, polygonFromPoints as l, polylineFromPoints as u, rectPath as d, regularPolygonPath as f, starPath as p } from "@weasel-js/geom";
 import { useEffect as m, useMemo as h, useReducer as g } from "react";
 import { useLatest as _ } from "@weasel-js/react";
@@ -27,10 +27,10 @@ function b(b) {
 				...v,
 				...C.current ?? {}
 			}, _ = {
-				...r,
+				...n,
 				...C.current?.roles ?? {}
-			}, b = e(h), x = [], S = a(m), w = (e) => !S || S(e);
-			for (let e of o(i(m))) if (w(e.visibilityId)) {
+			}, b = e(h), x = [], S = i(m), w = (e) => !S || S(e);
+			for (let e of a(r(m))) if (w(e.visibilityId)) {
 				if (e.kind === "marquee") {
 					let n = e.bounds, [r, i] = t(n.x, n.y, b), a = {
 						kind: "path",
@@ -41,7 +41,7 @@ function b(b) {
 							width: n.width * h.scale.x,
 							height: n.height * h.scale.y
 						},
-						fill: { color: g.fill },
+						fill: { paint: { color: g.fill } },
 						stroke: {
 							paint: { color: g.stroke },
 							width: g.lineWidth,
@@ -52,52 +52,52 @@ function b(b) {
 					continue;
 				}
 				if (e.kind === "insertPreview") {
-					let r = e.bounds, i = (e, n) => {
+					let n = e.bounds, r = (e, n) => {
 						let [r, i] = t(e, n, b);
 						return {
 							x: r,
 							y: i
 						};
-					}, a = (e) => e.map((e) => i(e.x, e.y)), o = (h.scale.x + h.scale.y) / 2, l = null, m = e.geometry;
+					}, i = (e) => e.map((e) => r(e.x, e.y)), a = (h.scale.x + h.scale.y) / 2, l = null, m = e.geometry;
 					switch (m.kind) {
 						case "box": {
-							let [i, a] = t(r.x, r.y, b), o = r.width * h.scale.x, c = r.height * h.scale.y;
+							let [r, i] = t(n.x, n.y, b), a = n.width * h.scale.x, c = n.height * h.scale.y;
 							if (e.shape === "image") {
-								let t = e.extras, r = t.preview === "outline" || !t.src ? void 0 : n(t.src);
-								r && x.push({
+								let t = e.extras, n = t.preview === "outline" || !t.src ? void 0 : o(t.src);
+								n && x.push({
 									kind: "image",
-									image: r,
-									x: i,
-									y: a,
-									w: o,
+									image: n,
+									x: r,
+									y: i,
+									w: a,
 									h: c,
 									opacity: y
 								});
 							}
 							l = e.shape === "ellipse" ? s({
-								x: i,
-								y: a,
-								width: o,
+								x: r,
+								y: i,
+								width: a,
 								height: c
-							}) : d(i, a, o, c);
+							}) : d(r, i, a, c);
 							break;
 						}
 						case "line":
-							l = c(i(m.a.x, m.a.y), i(m.b.x, m.b.y));
+							l = c(r(m.a.x, m.a.y), r(m.b.x, m.b.y));
 							break;
 						case "polygon":
-							l = f(i(m.center.x, m.center.y), m.radius * o, m.sides, m.rotation);
+							l = f(r(m.center.x, m.center.y), m.radius * a, m.sides, m.rotation);
 							break;
 						case "star":
-							l = p(i(m.center.x, m.center.y), m.outerRadius * o, m.points, m.innerRadius * o, m.rotation);
+							l = p(r(m.center.x, m.center.y), m.outerRadius * a, m.points, m.innerRadius * a, m.rotation);
 							break;
-						case "pencil": l = u(a(m.samples));
+						case "pencil": l = u(i(m.samples));
 					}
 					if (!l) continue;
 					let _ = {
 						kind: "path",
 						path: l,
-						fill: e.shape === "line" || e.shape === "pencil" || e.shape === "image" ? void 0 : { color: g.fill },
+						fill: e.shape === "line" || e.shape === "pencil" || e.shape === "image" ? void 0 : { paint: { color: g.fill } },
 						stroke: {
 							paint: { color: g.stroke },
 							width: g.lineWidth,
@@ -105,7 +105,7 @@ function b(b) {
 						}
 					};
 					if (x.push(_), e.anchorPoint) {
-						let t = i(e.anchorPoint.x, e.anchorPoint.y);
+						let t = r(e.anchorPoint.x, e.anchorPoint.y);
 						x.push({
 							kind: "path",
 							path: s({
@@ -114,7 +114,7 @@ function b(b) {
 								width: 8,
 								height: 8
 							}),
-							fill: { color: g.stroke }
+							fill: { paint: { color: g.stroke } }
 						});
 					}
 					continue;
@@ -131,7 +131,7 @@ function b(b) {
 					let r = {
 						kind: "path",
 						path: l(n),
-						fill: { color: g.fill },
+						fill: { paint: { color: g.fill } },
 						stroke: {
 							paint: { color: g.stroke },
 							width: g.lineWidth,

package/dist/canvas/SceneCanvas/useDispatcherOverlayLayer.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDispatcherOverlayLayer.js","names":["DEFAULT_STYLE","PREVIEW_CONTENT_OPACITY","useDispatcherOverlayLayer","args","styleRef","useLatest","style","forceRerender","useReducer","n","useEffect","dispatcher","useMemo","cfg","roles","OVERLAY_ROLE_STROKES","t","viewToTransform","view","out","isVisible","isVisibleFrom","data","passes","id","ov","resolveOverlays","gestureOverlaysFrom","b","sx","sy","worldToScreen","cmd","projectPoint","wx","wy","projectPoints","pts","p","radialScale","pathCmd","geom","sw","sh","e","bmp","getImageBitmap","ellipsePath","rectPath","linePath","regularPolygonPath","starPath","polylineFromPoints","anchorScreen","screenPts","v","polygonFromPoints","stroke","pt"],"sources":["../../../src/canvas/SceneCanvas/useDispatcherOverlayLayer.ts"],"sourcesContent":["/**\n * Dispatcher overlay render layer for `<SceneCanvas>`.\n *\n * Paints the overlay shapes the drawing view's in-flight handles publish,\n * taken off the draw envelope so a panel shows its own gesture rather than\n * the surface's. `resolveOverlays` does the reading — normalizing the drag,\n * sizing the nascent shape, dropping what is degenerate — and everything left\n * here is painting: projection into screen coordinates, the chrome-caps gate,\n * fill/stroke policy, the stroke each overlay role reads as, the anchor dot's\n * size, and the image bitmap.\n *\n * Distinct from `usePreviewGhostLayer`, which paints displaced scene-node\n * silhouettes via `previewIds()` / `previewPose(id)`. The dispatcher\n * overlay layer is for gestures whose visual feedback isn't a moved scene\n * node — marquee rect (area-select), polyline + dashed close-line (lasso),\n * and any future overlay-only chrome an action wants to render.\n *\n * Replaces the per-tool `select-overlay` rendering for the same gestures\n * once the dispatcher path is the sole driver. Until\n * then both run side-by-side; the visuals overlap exactly so the\n * user-visible result is identical.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { DrawCommand, PathDrawCommand } from '../../renderer';\nimport type { CommandStroke } from '@weasel-js/paint';\nimport type { RenderLayer } from 'core/layers/render';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport {\n  polygonFromPoints,\n  polylineFromPoints,\n  rectPath,\n  ellipsePath,\n  linePath,\n  regularPolygonPath,\n  starPath,\n} from '@weasel-js/geom';\nimport { getImageBitmap } from 'features/images/imageCache';\nimport { resolveOverlays } from 'interactions/actions/resolveOverlays';\nimport { gestureOverlaysFrom, isVisibleFrom } from '../drawEnvelope';\nimport { OVERLAY_ROLE_STROKES } from '../overlayRoleStrokes';\n\n/** Style knobs for the dispatcher-overlay layer's marquee + lasso paints.\n *  Defaults match the legacy `useSelectTool` `areaSelectOverlayStyle`\n *  defaults so the visual swap is invisible to users. */\nexport interface DispatcherOverlayStyle {\n  fill?: string;\n  stroke?: string;\n  dash?: number[];\n  lineWidth?: number;\n  /** Stroke per `polyline` overlay role, merged over the kit's. A role with\n   *  no entry here and none of the kit's paints as plain chrome — the\n   *  `stroke` / `lineWidth` / `dash` above. */\n  roles?: Readonly<Record<string, CommandStroke>>;\n}\n\nconst DEFAULT_STYLE: Required<Omit<DispatcherOverlayStyle, 'roles'>> = {\n  fill: 'rgba(164, 139, 212, 0.18)',\n  stroke: '#a48bd4',\n  dash: [3, 3],\n  lineWidth: 1,\n};\n\n/** Alpha for content previewed inside an in-flight gesture. Matches the\n *  preview-ghost layer, so a dragged node and an uncommitted insert read as\n *  equally provisional. */\nconst PREVIEW_CONTENT_OPACITY = 0.85;\n\n\nexport function useDispatcherOverlayLayer(args: {\n  /** The surface's dispatcher, subscribed to only so a pump repaints. What\n   *  gets painted is the drawing view's own `getGestureOverlays()`. */\n  dispatcher: Dispatcher | null | undefined;\n  style?: DispatcherOverlayStyle;\n}): RenderLayer<unknown> {\n  const { dispatcher, style } = args;\n\n  const styleRef = useLatest(style);\n\n  // Re-render on every dispatcher pump so live overlay (marquee, lasso\n  // polyline) tracks pointermove instead of freezing on the first frame.\n  const [, forceRerender] = useReducer((n: number) => n + 1, 0);\n  useEffect(() => {\n    if (!dispatcher) return;\n    return dispatcher.subscribe(forceRerender);\n  }, [dispatcher]);\n\n  return useMemo<RenderLayer<unknown>>(\n    () => ({\n      id: 'dispatcher-overlay',\n      label: 'Dispatcher overlay',\n      space: 'screen',\n      draw: (data, view) => {\n        const cfg = { ...DEFAULT_STYLE, ...(styleRef.current ?? {}) };\n        // Merged rather than replaced: naming one role must not delete the\n        // kit's others.\n        const roles = { ...OVERLAY_ROLE_STROKES, ...(styleRef.current?.roles ?? {}) };\n        const t = viewToTransform(view);\n        const out: DrawCommand[] = [];\n\n        // Chrome-caps gate. Mirrors `composeAffordanceLayer` /\n        // `createSelectionOverlayLayer`: pull a visibility predicate off\n        // the data envelope and consult it per overlay before pushing draw\n        // commands. Absent envelope → every overlay paints. This stays on the\n        // painting side: the predicate is a property of the view's envelope,\n        // and two views of one surface may answer differently for the same\n        // in-flight gesture.\n        const isVisible = isVisibleFrom(data);\n        const passes = (id: string) => (isVisible ? isVisible(id) : true);\n\n        for (const ov of resolveOverlays(gestureOverlaysFrom(data))) {\n          if (!passes(ov.visibilityId)) continue;\n\n          if (ov.kind === 'marquee') {\n            const b = ov.bounds;\n            const [sx, sy] = worldToScreen(b.x, b.y, t);\n            const sw = b.width * view.scale.x;\n            const sh = b.height * view.scale.y;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: { kind: 'rect', x: sx, y: sy, width: sw, height: sh },\n              fill: { color: cfg.fill },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'insertPreview') {\n            const b = ov.bounds;\n            const projectPoint = (wx: number, wy: number): { x: number; y: number } => {\n              const [sx, sy] = worldToScreen(wx, wy, t);\n              return { x: sx, y: sy };\n            };\n            const projectPoints = (\n              pts: ReadonlyArray<{ x: number; y: number }>,\n            ): { x: number; y: number }[] => pts.map((p) => projectPoint(p.x, p.y));\n            // Radial shapes inscribe in a square, so a single screen-space\n            // radius needs one scale factor; average the axes.\n            const radialScale = (view.scale.x + view.scale.y) / 2;\n\n            let pathCmd: PathDrawCommand['path'] | null = null;\n            const geom = ov.geometry;\n            switch (geom.kind) {\n              case 'box': {\n                const [sx, sy] = worldToScreen(b.x, b.y, t);\n                const sw = b.width * view.scale.x;\n                const sh = b.height * view.scale.y;\n                if (ov.shape === 'image') {\n                  const e = ov.extras as Partial<{ src: string; preview: string }>;\n                  // The bitmap when it has decoded, the bare outline until then\n                  // (or when the tool opted out) — the outline is drawn either\n                  // way, so the drag always has an edge to read.\n                  const bmp = e.preview === 'outline' || !e.src\n                    ? undefined\n                    : getImageBitmap(e.src);\n                  if (bmp) {\n                    out.push({\n                      kind: 'image',\n                      image: bmp,\n                      x: sx, y: sy, w: sw, h: sh,\n                      opacity: PREVIEW_CONTENT_OPACITY,\n                    });\n                  }\n                }\n                pathCmd = ov.shape === 'ellipse'\n                  ? ellipsePath({ x: sx, y: sy, width: sw, height: sh })\n                  : rectPath(sx, sy, sw, sh);\n                break;\n              }\n              case 'line':\n                pathCmd = linePath(projectPoint(geom.a.x, geom.a.y), projectPoint(geom.b.x, geom.b.y));\n                break;\n              case 'polygon':\n                pathCmd = regularPolygonPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.radius * radialScale,\n                  geom.sides,\n                  geom.rotation,\n                );\n                break;\n              case 'star':\n                pathCmd = starPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.outerRadius * radialScale,\n                  geom.points,\n                  geom.innerRadius * radialScale,\n                  geom.rotation,\n                );\n                break;\n              case 'pencil':\n                // Genuinely open: `polygonFromPoints` closes the path, and the\n                // closing edge from the last sample back to the first reads as\n                // a marquee rather than as the stroke being drawn.\n                pathCmd = polylineFromPoints(projectPoints(geom.samples));\n                break;\n            }\n\n            if (!pathCmd) continue;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: pathCmd,\n              fill: ov.shape === 'line' || ov.shape === 'pencil' || ov.shape === 'image'\n                ? undefined\n                : { color: cfg.fill },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            // Anchor dot at the drag's click point. Sells the anchoring\n            // visually for radial shapes (polygon/star — no vertex sits\n            // at the AABB corner) and for center mode (dot marks the\n            // growth axis). 4 CSS-px radius, same stroke color as the\n            // ghost so it reads as part of the chrome.\n            if (ov.anchorPoint) {\n              const anchorScreen = projectPoint(ov.anchorPoint.x, ov.anchorPoint.y);\n              out.push({\n                kind: 'path',\n                path: ellipsePath({\n                  x: anchorScreen.x - 4,\n                  y: anchorScreen.y - 4,\n                  width: 8,\n                  height: 8,\n                }),\n                fill: { color: cfg.stroke },\n              });\n            }\n            continue;\n          }\n\n          if (ov.kind === 'lasso') {\n            // Project every vertex to screen coords; build a single polygon\n            // path. The polygon already closes (polygonFromPoints adds Z),\n            // which renders as the dashed \"close-line\" implicit in the\n            // legacy hook's visual. Fill paints the would-be selection\n            // region; stroke paints the polyline + close-line.\n            const screenPts: { x: number; y: number }[] = [];\n            for (const v of ov.vertices) {\n              const [sx, sy] = worldToScreen(v.x, v.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: polygonFromPoints(screenPts),\n              fill: { color: cfg.fill },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'polyline') {\n            const stroke =\n              roles[ov.role] ??\n              { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash };\n            const screenPts: { x: number; y: number }[] = [];\n            for (const pt of ov.points) {\n              const [sx, sy] = worldToScreen(pt.x, pt.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            out.push({\n              kind: 'path',\n              path: polylineFromPoints(screenPts),\n              stroke,\n            } satisfies PathDrawCommand);\n            continue;\n          }\n        }\n\n        if (out.length === 0) return [];\n        // Screen-space layer: emit commands directly. The worldToScreen\n        // projection above has already mapped every coord into CSS pixels.\n        return out;\n      },\n    }),\n    [styleRef],\n  );\n}\n"],"mappings":"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"}
+{"version":3,"file":"useDispatcherOverlayLayer.js","names":["DEFAULT_STYLE","PREVIEW_CONTENT_OPACITY","useDispatcherOverlayLayer","args","styleRef","useLatest","style","forceRerender","useReducer","n","useEffect","dispatcher","useMemo","cfg","roles","OVERLAY_ROLE_STROKES","t","viewToTransform","view","out","isVisible","isVisibleFrom","data","passes","id","ov","resolveOverlays","gestureOverlaysFrom","b","sx","sy","worldToScreen","cmd","projectPoint","wx","wy","projectPoints","pts","p","radialScale","pathCmd","geom","sw","sh","e","bmp","getImageBitmap","ellipsePath","rectPath","linePath","regularPolygonPath","starPath","polylineFromPoints","anchorScreen","screenPts","v","polygonFromPoints","stroke","pt"],"sources":["../../../src/canvas/SceneCanvas/useDispatcherOverlayLayer.ts"],"sourcesContent":["/**\n * Dispatcher overlay render layer for `<SceneCanvas>`.\n *\n * Paints the overlay shapes the drawing view's in-flight handles publish,\n * taken off the draw envelope so a panel shows its own gesture rather than\n * the surface's. `resolveOverlays` does the reading; everything here is\n * painting.\n *\n * Distinct from `usePreviewGhostLayer`, which paints displaced scene-node\n * silhouettes. This layer is for gestures whose visual feedback isn't a moved\n * scene node — a marquee rect, a lasso polyline, an insert preview.\n */\nimport { useEffect, useMemo, useReducer } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport type { DrawCommand, PathDrawCommand } from '@weasel-js/renderer';\nimport type { CommandStroke } from '@weasel-js/paint';\nimport type { RenderLayer } from 'core/layers/render';\nimport { viewToTransform } from 'core/viewport/view';\nimport { worldToScreen } from 'core/viewport/viewTransform';\nimport type { Dispatcher } from '@weasel-js/routing';\nimport {\n  polygonFromPoints,\n  polylineFromPoints,\n  rectPath,\n  ellipsePath,\n  linePath,\n  regularPolygonPath,\n  starPath,\n} from '@weasel-js/geom';\nimport { getImageBitmap } from '@weasel-js/renderer';\nimport { resolveOverlays } from 'interactions/actions/resolveOverlays';\nimport { gestureOverlaysFrom, isVisibleFrom } from '../drawEnvelope';\nimport { OVERLAY_ROLE_STROKES } from '../overlayRoleStrokes';\n\n/** Style knobs for the dispatcher-overlay layer's marquee + lasso paints. */\nexport interface DispatcherOverlayStyle {\n  fill?: string;\n  stroke?: string;\n  dash?: number[];\n  lineWidth?: number;\n  /** Stroke per `polyline` overlay role, merged over the kit's. A role with\n   *  no entry here and none of the kit's paints as plain chrome — the\n   *  `stroke` / `lineWidth` / `dash` above. */\n  roles?: Readonly<Record<string, CommandStroke>>;\n}\n\nconst DEFAULT_STYLE: Required<Omit<DispatcherOverlayStyle, 'roles'>> = {\n  fill: 'rgba(164, 139, 212, 0.18)',\n  stroke: '#a48bd4',\n  dash: [3, 3],\n  lineWidth: 1,\n};\n\n/** Alpha for content previewed inside an in-flight gesture. Matches the\n *  preview-ghost layer, so a dragged node and an uncommitted insert read as\n *  equally provisional. */\nconst PREVIEW_CONTENT_OPACITY = 0.85;\n\n\nexport function useDispatcherOverlayLayer(args: {\n  /** The surface's dispatcher, subscribed to only so a pump repaints. What\n   *  gets painted is the drawing view's own `getGestureOverlays()`. */\n  dispatcher: Dispatcher | null | undefined;\n  style?: DispatcherOverlayStyle;\n}): RenderLayer<unknown> {\n  const { dispatcher, style } = args;\n\n  const styleRef = useLatest(style);\n\n  // Re-render on every dispatcher pump so live overlay (marquee, lasso\n  // polyline) tracks pointermove instead of freezing on the first frame.\n  const [, forceRerender] = useReducer((n: number) => n + 1, 0);\n  useEffect(() => {\n    if (!dispatcher) return;\n    return dispatcher.subscribe(forceRerender);\n  }, [dispatcher]);\n\n  return useMemo<RenderLayer<unknown>>(\n    () => ({\n      id: 'dispatcher-overlay',\n      label: 'Dispatcher overlay',\n      space: 'screen',\n      draw: (data, view) => {\n        const cfg = { ...DEFAULT_STYLE, ...(styleRef.current ?? {}) };\n        // Merged rather than replaced: naming one role must not delete the\n        // kit's others.\n        const roles = { ...OVERLAY_ROLE_STROKES, ...(styleRef.current?.roles ?? {}) };\n        const t = viewToTransform(view);\n        const out: DrawCommand[] = [];\n\n        // Chrome-caps gate. Absent envelope → every overlay paints. This stays\n        // on the painting side: the predicate is a property of the view's\n        // envelope, and two views of one surface may answer differently for\n        // the same in-flight gesture.\n        const isVisible = isVisibleFrom(data);\n        const passes = (id: string) => (isVisible ? isVisible(id) : true);\n\n        for (const ov of resolveOverlays(gestureOverlaysFrom(data))) {\n          if (!passes(ov.visibilityId)) continue;\n\n          if (ov.kind === 'marquee') {\n            const b = ov.bounds;\n            const [sx, sy] = worldToScreen(b.x, b.y, t);\n            const sw = b.width * view.scale.x;\n            const sh = b.height * view.scale.y;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: { kind: 'rect', x: sx, y: sy, width: sw, height: sh },\n              fill: { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'insertPreview') {\n            const b = ov.bounds;\n            const projectPoint = (wx: number, wy: number): { x: number; y: number } => {\n              const [sx, sy] = worldToScreen(wx, wy, t);\n              return { x: sx, y: sy };\n            };\n            const projectPoints = (\n              pts: ReadonlyArray<{ x: number; y: number }>,\n            ): { x: number; y: number }[] => pts.map((p) => projectPoint(p.x, p.y));\n            // Radial shapes inscribe in a square, so a single screen-space\n            // radius needs one scale factor; average the axes.\n            const radialScale = (view.scale.x + view.scale.y) / 2;\n\n            let pathCmd: PathDrawCommand['path'] | null = null;\n            const geom = ov.geometry;\n            switch (geom.kind) {\n              case 'box': {\n                const [sx, sy] = worldToScreen(b.x, b.y, t);\n                const sw = b.width * view.scale.x;\n                const sh = b.height * view.scale.y;\n                if (ov.shape === 'image') {\n                  const e = ov.extras as Partial<{ src: string; preview: string }>;\n                  // The bitmap when it has decoded, the bare outline until then\n                  // (or when the tool opted out) — the outline is drawn either\n                  // way, so the drag always has an edge to read.\n                  const bmp = e.preview === 'outline' || !e.src\n                    ? undefined\n                    : getImageBitmap(e.src);\n                  if (bmp) {\n                    out.push({\n                      kind: 'image',\n                      image: bmp,\n                      x: sx, y: sy, w: sw, h: sh,\n                      opacity: PREVIEW_CONTENT_OPACITY,\n                    });\n                  }\n                }\n                pathCmd = ov.shape === 'ellipse'\n                  ? ellipsePath({ x: sx, y: sy, width: sw, height: sh })\n                  : rectPath(sx, sy, sw, sh);\n                break;\n              }\n              case 'line':\n                pathCmd = linePath(projectPoint(geom.a.x, geom.a.y), projectPoint(geom.b.x, geom.b.y));\n                break;\n              case 'polygon':\n                pathCmd = regularPolygonPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.radius * radialScale,\n                  geom.sides,\n                  geom.rotation,\n                );\n                break;\n              case 'star':\n                pathCmd = starPath(\n                  projectPoint(geom.center.x, geom.center.y),\n                  geom.outerRadius * radialScale,\n                  geom.points,\n                  geom.innerRadius * radialScale,\n                  geom.rotation,\n                );\n                break;\n              case 'pencil':\n                // Genuinely open: `polygonFromPoints` closes the path, and the\n                // closing edge from the last sample back to the first reads as\n                // a marquee rather than as the stroke being drawn.\n                pathCmd = polylineFromPoints(projectPoints(geom.samples));\n                break;\n            }\n\n            if (!pathCmd) continue;\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: pathCmd,\n              fill: ov.shape === 'line' || ov.shape === 'pencil' || ov.shape === 'image'\n                ? undefined\n                : { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            // Anchor dot at the drag's click point: for radial shapes no\n            // vertex sits at the AABB corner, and in center mode the dot marks\n            // the growth axis.\n            if (ov.anchorPoint) {\n              const anchorScreen = projectPoint(ov.anchorPoint.x, ov.anchorPoint.y);\n              out.push({\n                kind: 'path',\n                path: ellipsePath({\n                  x: anchorScreen.x - 4,\n                  y: anchorScreen.y - 4,\n                  width: 8,\n                  height: 8,\n                }),\n                fill: { paint: { color: cfg.stroke } },\n              });\n            }\n            continue;\n          }\n\n          if (ov.kind === 'lasso') {\n            // `polygonFromPoints` closes the path, which draws the dashed\n            // close-line back to the first vertex.\n            const screenPts: { x: number; y: number }[] = [];\n            for (const v of ov.vertices) {\n              const [sx, sy] = worldToScreen(v.x, v.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            const cmd: PathDrawCommand = {\n              kind: 'path',\n              path: polygonFromPoints(screenPts),\n              fill: { paint: { color: cfg.fill } },\n              stroke: { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash },\n            };\n            out.push(cmd);\n            continue;\n          }\n\n          if (ov.kind === 'polyline') {\n            const stroke =\n              roles[ov.role] ??\n              { paint: { color: cfg.stroke }, width: cfg.lineWidth, dash: cfg.dash };\n            const screenPts: { x: number; y: number }[] = [];\n            for (const pt of ov.points) {\n              const [sx, sy] = worldToScreen(pt.x, pt.y, t);\n              screenPts.push({ x: sx, y: sy });\n            }\n            out.push({\n              kind: 'path',\n              path: polylineFromPoints(screenPts),\n              stroke,\n            } satisfies PathDrawCommand);\n            continue;\n          }\n        }\n\n        if (out.length === 0) return [];\n        return out;\n      },\n    }),\n    [styleRef],\n  );\n}\n"],"mappings":"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"}

package/dist/canvas/SceneCanvas/useHeldModifiers.js

@@ -0,0 +1,20 @@
+import { useKeyState as e } from "../../input/useKeyState.js";
+import { useMemo as t } from "react";
+//#region src/canvas/SceneCanvas/useHeldModifiers.ts
+function n() {
+	let n = e({ skipInEditable: !1 });
+	return t(() => ({
+		get: n.modifiers,
+		subscribe(e) {
+			let t = n.modifiers();
+			return n.subscribe(() => {
+				let r = n.modifiers();
+				r !== t && (t = r, e());
+			});
+		}
+	}), [n]);
+}
+//#endregion
+export { n as useHeldModifiers };
+
+//# sourceMappingURL=useHeldModifiers.js.map

package/dist/canvas/SceneCanvas/useHeldModifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHeldModifiers.js","names":["useHeldModifiers","keys","useKeyState","useMemo","held","now","listener"],"sources":["../../../src/canvas/SceneCanvas/useHeldModifiers.ts"],"sourcesContent":["/** The modifier keys held, for a surface's rule context. */\nimport { useMemo } from 'react';\nimport type { ModifierState } from '../../core/modifierState';\nimport type { RedrawSource } from '../../core/layers/render';\nimport { useKeyState } from '../../input/useKeyState';\n\nexport interface HeldModifiers extends RedrawSource {\n  /** Read when a rule is evaluated. The same object until a modifier changes. */\n  get(): ModifierState;\n}\n\n/** The modifiers held anywhere in the window, a text field included: a rule\n *  is asked about the keyboard, not about where focus is. `subscribe` reports\n *  a modifier going down or up and no other key. */\nexport function useHeldModifiers(): HeldModifiers {\n  const keys = useKeyState({ skipInEditable: false });\n  return useMemo(() => ({\n    get: keys.modifiers,\n    subscribe(listener) {\n      let held = keys.modifiers();\n      return keys.subscribe(() => {\n        const now = keys.modifiers();\n        if (now === held) return;\n        held = now;\n        listener();\n      });\n    },\n  }), [keys]);\n}\n"],"mappings":";;;AAcA,SAAgBA,IAAkC;CAChD,IAAMC,IAAOC,EAAY,EAAE,gBAAgB,GAAM,CAAC;CAClD,OAAOC,SAAe;EACpB,KAAKF,EAAK;EACV,UAAU,GAAU;GAClB,IAAIG,IAAOH,EAAK,UAAU;GAC1B,OAAOA,EAAK,gBAAgB;IAC1B,IAAMI,IAAMJ,EAAK,UAAU;IAC3B,AAAII,MAAQD,MACZ,IAAOC,GACPC,EAAS;GACX,CAAC;EACH;CACF,IAAI,CAACL,CAAI,CAAC;AACZ"}

package/dist/canvas/SceneCanvas/useNodeAtPoint.js

@@ -0,0 +1,26 @@
+import { makeGetNodeAtPoint as e } from "../getNodeAtPoint.js";
+import { useMemo as t } from "react";
+//#region src/canvas/SceneCanvas/useNodeAtPoint.ts
+function n(n) {
+	let { pickBest: r, nodes: i, kindOfData: a, isPointerInteractive: o } = n;
+	return t(() => {
+		if (!r) return;
+		let t = e(r, (e) => {
+			let t = i.getNode(e);
+			return t ? { kind: a ? a(t.data) : "unknown" } : null;
+		});
+		return o ? (e, n, r) => {
+			let i = t(e, n, r);
+			return i == null || o(i.id) === !1 ? null : i;
+		} : t;
+	}, [
+		i,
+		r,
+		o,
+		a
+	]);
+}
+//#endregion
+export { n as useNodeAtPoint };
+
+//# sourceMappingURL=useNodeAtPoint.js.map

package/dist/canvas/SceneCanvas/useNodeAtPoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNodeAtPoint.js","names":["useNodeAtPoint","args","useMemo","pickBest","base","makeGetNodeAtPoint","node","nodes","id","kindOfData","isPointerInteractive","hit","wx","wy","view"],"sources":["../../../src/canvas/SceneCanvas/useNodeAtPoint.ts"],"sourcesContent":["import { useMemo } from 'react';\nimport { makeGetNodeAtPoint, type NodeAtPointHit } from '../getNodeAtPoint';\nimport type { PickView } from './useSceneSelectTool';\n\nexport type NodeAtPoint = (wx: number, wy: number, view?: PickView | null) => NodeAtPointHit | null;\n\n/**\n * The node under a world point with its routing kind, resolved through the\n * select tool's own single-hit picker, so `onClick`, `onDoubleClick`, hover,\n * and tool routing all name the node a click selects. A hit whose id\n * `isPointerInteractive` rejects comes back null.\n */\nexport function useNodeAtPoint<TData>(args: {\n  pickBest: ((wx: number, wy: number, view?: PickView | null) => string | null) | undefined;\n  /** A caller's `geometry.pickEvery` can answer an id the scene does not hold. */\n  nodes: { getNode(id: string): { data: TData } | null | undefined };\n  kindOfData: ((data: TData) => string) | undefined;\n  isPointerInteractive: ((id: string) => boolean) | undefined;\n}): NodeAtPoint | undefined {\n  const { pickBest, nodes, kindOfData, isPointerInteractive } = args;\n  return useMemo(() => {\n    if (!pickBest) return undefined;\n    const base = makeGetNodeAtPoint(pickBest, (id) => {\n      const node = nodes.getNode(id);\n      if (!node) return null;\n      return { kind: kindOfData ? kindOfData(node.data) : 'unknown' };\n    });\n    if (!isPointerInteractive) return base;\n    return (wx, wy, view) => {\n      const hit = base(wx, wy, view);\n      if (hit == null) return null;\n      if (isPointerInteractive(hit.id) === false) return null;\n      return hit;\n    };\n  }, [nodes, pickBest, isPointerInteractive, kindOfData]);\n}\n"],"mappings":";;;AAYA,SAAgBA,EAAsB,GAMV;CAC1B,IAAM,EAAE,aAAU,UAAO,eAAY,4BAAyBC;CAC9D,OAAOC,QAAc;EACnB,IAAI,CAACC,GAAU;EACf,IAAMC,IAAOC,EAAmBF,IAAW,MAAO;GAChD,IAAMG,IAAOC,EAAM,QAAQC,CAAE;GAE7B,OADKF,IACE,EAAE,MAAMG,IAAaA,EAAWH,EAAK,IAAI,IAAI,UAAU,IAD5C;EAEpB,CAAC;EAED,OADKI,KACG,GAAI,GAAI,MAAS;GACvB,IAAMC,IAAMP,EAAKQ,GAAIC,GAAIC,CAAI;GAG7B,OAFIH,KAAO,QACPD,EAAqBC,EAAI,EAAE,MAAM,KAAc,OAC5CA;EACT,IANkCP;CAOpC,GAAG;EAACG;EAAOJ;EAAUO;EAAsBD;CAAU,CAAC;AACxD"}