@weasel-js/core 1.10.0 → 1.11.0

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

@@ -1 +1 @@
-{"version":3,"file":"props.js","names":["DEFAULT_HANDLE_SIZE","HANDLE_BASE_PX","mergeLayersWithDefaults","defaults","defaultDrawOne","defaultPaintBounds","targetSizesPx","targetScale","user","result","isCustomEntry","scene","paintBoundsFor","NON_SHAPE_BUILTIN_TOOLS","BUILTIN_TOOL_IDS","KIT_SHAPE_KINDS"],"sources":["../../../src/canvas/SceneCanvas/props.ts"],"sourcesContent":["import type { ModeRegistry } from '@weasel-js/modes';\nimport type { PathEditHost } from './pathEditHost';\nimport type { Paint } from '@weasel-js/paint';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { Yoke } from '@weasel-js/routing/react';\nimport type { PasteOmission } from 'core/adapters/types';\nimport type { Op } from 'core/ops/types';\nimport type { Node, Scene, SerializedScene } from 'core/scene/types';\nimport type { SelectionApi, UseSelectionOptions } from 'core/selection/useSelection';\nimport { KIT_SHAPE_KINDS, type BuiltinShapeToolId } from 'core/shapeKinds';\nimport type { InertiaConfig } from 'core/viewport/useDecayLoop';\nimport type { View } from 'core/viewport/view';\nimport type {\n  ContentHandlerEntry\n} from 'features/ingestion';\nimport type { PinchZoomOptions } from 'interactions/actions/defaults/pinchZoom';\nimport type { WheelPanOptions } from 'interactions/actions/defaults/viewportWheelPan';\nimport type { ViewportZoomAnimateOptions, ViewportZoomOptions } from 'interactions/actions/defaults/viewportZoom';\nimport type { SvgIngestOptions } from 'interactions/actions/depSchema';\nimport type { GeometryProjection } from 'interactions/actions/geometryProjection';\nimport type { UseMoveOptions } from 'interactions/actions/move/options';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type { UseRotateOptions } from 'interactions/actions/rotate/options';\nimport type { SnapStrategy } from 'interactions/gestures/types';\nimport type { ReactNode } from 'react';\nimport type { Bounds } from 'tools/builtin/select';\nimport type { Animator } from '@weasel-js/animator';\nimport { HANDLE_BASE_PX, targetSizesPx } from '../../core/device/targets';\nimport type { DeviceProfile } from '../../core/device/types';\nimport type { NodeRoutingEntry } from '../../core/scene/NodeRouting';\nimport type { DebugConfig } from '../../debug/types';\nimport type { LayoutDropTargetMode, ReflowTransition } from '../../layout/types';\nimport type { DrawCommand, ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { Tool, ToolsApi } from '../../tools/overlayBinding';\nimport type { SceneSlotConfig } from '../buildSceneLayer';\nimport type { CanvasProps } from '../Canvas';\nimport { isCustomEntry, type LayersMap } from '../layerSlots';\nimport type { CanvasViewProps } from '../CanvasView';\nimport { defaultDrawOne, defaultPaintBounds, paintBoundsFor } from '../defaultDrawOne';\nimport type {\n  InsertNodeFactory,\n  InsertPaint\n} from '../deps';\nimport type { SceneToAdapterOptions } from '../sceneAdapter';\nimport type { SurfaceContribution } from '../surfaceContribution';\nimport type { CameraProps } from '../useCanvasView';\nimport type {\n  Feature\n} from './features';\nimport type { BuiltinToolOptions } from './useBuiltinShapeTools';\nimport type { VersionCheck } from './useContributionRoles';\n\n/** The adapter surface delete / duplicate / group / ungroup need, narrowed from\n *  `SceneCanvasAdapter` because `StandardActionsRegistrar` is non-generic. */\nexport interface BridgeAdapter {\n  applyOps(ops: Op[], label?: string): void;\n  insertNode(node: { id: string; [k: string]: unknown }): void;\n  removeNode(id: string): void;\n  setSelection(ids: string[]): void;\n}\n\n/** Default size in CSS pixels for selection corner-handles AND their\n *  hit-test radius, at `targetScale = 1`. Deliberately unscaled; kit-internal\n *  use sites multiply by `DeviceProfile.targetScale`. */\nexport const DEFAULT_HANDLE_SIZE = HANDLE_BASE_PX;\n\n/** `<SceneCanvas longPress>`. */\nexport interface SceneCanvasLongPress {\n  /**\n   * Shown while a long-press is held and some binding would fire on it.\n   * Default: a ring that fills around the press point\n   * (`createLongPressFeedbackContribution()`), static under\n   * `prefers-reduced-motion`. `false` shows nothing; a contribution replaces\n   * it, reading the `longPress` dep. Installed beside `ambient`, so under a\n   * `tools` takeover add it to your own `useTools` call instead.\n   */\n  feedback?: boolean | SurfaceContribution;\n  /** Default true. A long-press some binding handled pulses\n   *  `navigator.vibrate` briefly, for touch and pen, where the API exists. */\n  haptics?: boolean;\n  /** Hold time in ms. Default `LONG_PRESS_MS` (500). */\n  duration?: number;\n}\n\n/** `<SceneCanvas layers>`: a {@link LayersMap} whose scene slot may be partial,\n *  since the defaults fill in whatever it leaves out. */\nexport type SceneCanvasLayers<TNode extends { id: string }, TPose> = LayersMap<\n  TNode,\n  TPose,\n  Partial<SceneSlotConfig<TNode, TPose>>\n>;\n\n/** Deep-merge user-supplied `layers` with kit defaults. Slots the user\n *  doesn't mention get filled with defaults; slots explicitly set to\n *  `null` are dropped. Partial slot configs are shallow-spread on top of the\n *  default slot config. `targetScale` comes from the resolved {@link DeviceProfile}. */\nexport function mergeLayersWithDefaults<TData, TLayer extends string, TPose>(\n  user: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose> | undefined,\n  targetScale = 1,\n): LayersMap<Node<TData, TLayer, TPose>, TPose> {\n  const defaults = {\n    scene: {\n      drawOne: defaultDrawOne as (\n        node: Node<TData, TLayer, TPose>,\n        pose: TPose,\n      ) => DrawCommand[],\n      paintBounds: defaultPaintBounds<TData, TLayer, TPose>,\n    },\n    selectionOverlay: { handles: { size: targetSizesPx(targetScale).handle } },\n  };\n\n  if (!user) return defaults as LayersMap<Node<TData, TLayer, TPose>, TPose>;\n\n  // Start from a shallow copy of the user map so unknown slots pass through.\n  const result = { ...user } as LayersMap<Node<TData, TLayer, TPose>, TPose>;\n\n  if (!('scene' in user)) {\n    result.scene = defaults.scene;\n  } else if (user.scene === null || isCustomEntry(user.scene)) {\n    result.scene = user.scene;\n  } else {\n    const scene = { ...defaults.scene, ...user.scene };\n    result.scene = user.scene && 'paintBounds' in user.scene\n      ? scene\n      : { ...scene, paintBounds: paintBoundsFor<TData, TLayer, TPose>(scene.drawOne) };\n  }\n\n  if (!('selectionOverlay' in user)) {\n    result.selectionOverlay = defaults.selectionOverlay;\n  } else if (user.selectionOverlay === null || isCustomEntry(user.selectionOverlay)) {\n    result.selectionOverlay = user.selectionOverlay;\n  } else {\n    result.selectionOverlay = { ...defaults.selectionOverlay, ...user.selectionOverlay };\n  }\n\n  return result;\n}\n\n/** Built-in tool ids SceneCanvas knows how to mount when no `tools` prop\n *  is supplied, via `defaultTools`. */\nexport type BuiltinToolId = 'select' | 'hand' | BuiltinShapeToolId;\n\n/** Built-in tool ids that aren't shape tools — the ones with no entry in\n *  the `core/shapeKinds` table. */\nexport const NON_SHAPE_BUILTIN_TOOLS: readonly Exclude<BuiltinToolId, BuiltinShapeToolId>[] = ['select', 'hand'];\n\n/** Every built-in tool id, shape tools included. */\nexport const BUILTIN_TOOL_IDS: readonly BuiltinToolId[] = [...NON_SHAPE_BUILTIN_TOOLS, ...KIT_SHAPE_KINDS];\n\n/** Minimal hit descriptor passed to `onDoubleClick`. Contains the fields\n *  modality dispatch needs; extends as the kit's `Hit` type evolves. */\nexport interface SceneCanvasHit {\n  id: string;\n  kind: string;\n}\n\n/** Props for `<SceneCanvas>`. A scene is the only thing it needs. With nothing\n *  else it renders that scene and keeps a selection no input sets; `features`\n *  turns behavior on by preset, and the rest configures what those turn on. */\nexport type SceneCanvasProps<TData, TLayer extends string, TPose> =\n  Omit<\n    CanvasProps<TPose>,\n    | 'adapter' | 'boundsOf' | 'selection' | 'tools'\n    | 'viewState'       // SceneCanvas makes the camera from the view props below\n    | 'layers'          // stripped so we can re-add as optional below\n    | 'getIsVisible'    // SceneCanvas synthesizes this from chromeVisibility\n    | 'contentVersion'  // SceneCanvas wires this to the scene's own version\n    | 'layerVisibility' | 'layerOrder' // re-declared below: they gate picking here too\n    | 'debug'           // re-declared below with SceneCanvas's own `slops`\n  > & CameraProps\n  & {\n    /** A `Scene` (typically from `useScene`) — or a `SerializedScene` JSON\n     *  object, which SceneCanvas bakes into a Scene on first render. The\n     *  serialized form is read once; pass a `key` on `<SceneCanvas>` to force\n     *  a fresh canvas from updated JSON.\n     *\n     *  The JSON shape is relaxed (`version: number` rather than the `1`\n     *  literal) so an `import json from './x.json'` result satisfies the type\n     *  without an `as` cast. */\n    scene:\n      | Scene<TData, TLayer, TPose>\n      | SerializedScene<TData, TLayer, TPose>\n      | { version: number; systemLayers?: ReadonlyArray<{ id: string }>; nodes: ReadonlyArray<unknown> };\n\n    /** Layer configuration. When omitted, SceneCanvas applies kit defaults\n     *  (a scene slot that paints `node.data.fill` rects + a default\n     *  selection overlay). A partial scene or selection-overlay config is\n     *  spread over that slot's defaults; pass `slot: null` to suppress a\n     *  default explicitly. */\n    layers?: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose>;\n\n    /** Layout strategies keyed by container node id (or a resolver), for\n     *  containers whose scene node declares none (`ContainerNode.layout`\n     *  wins). Applied to a drag and to every other change to their children,\n     *  through the scene's layout pass. */\n    layouts?: SceneToAdapterOptions<TData, TLayer, TPose>['layouts'];\n\n    /** Which layout container a drag lands in when several contain the drop\n     *  point — the innermost (default), the topmost in paint order, or only\n     *  containers whose strategy declares a `dropRegion`. Decides both the\n     *  drag-time reflow preview and the commit. */\n    layoutDropTarget?: LayoutDropTargetMode;\n\n    /** Carries the siblings a layout reflow displaces to their slots over time\n     *  instead of snapping them — `useAnimatedReflow` builds one. Covers a\n     *  drag's reflow and every one the scene records (an insert, delete,\n     *  reorder or resize inside a laid-out container). Absent or `null`,\n     *  they snap. */\n    reflowTransition?: ReflowTransition<TPose> | null;\n\n    /**\n     * Lets pose-transform actions (move, resize, nudge, flip — NOT rotate) also rewrite a\n     * node's data-held geometry. Given a node and the affine `m` applied to its pose,\n     * `transform(node, m)` returns updated `data`, or `null` for nodes with no data-held\n     * geometry. When absent, the kit emits only the pose op and leaves `data` untouched.\n     *\n     * @see GeometryProjection\n     */\n    geometryProjection?: GeometryProjection;\n\n    /**\n     * Routing-trait classifiers. The kit builds a `NodeRouting` registry per `<SceneCanvas>`\n     * from this prop and uses it to derive each hit's `kind`, which tool routing tables\n     * (e.g. `{ target: 'rect', actionId: 'move' }`) match against. Pass `defaultNodeRouting`\n     * for the kit's built-in shape kinds; spread additional entries for consumer-defined\n     * kinds.\n     *\n     * **Memoize the `routing` value.** The registry is memoized on the prop's reference\n     * identity: a fresh array each render rebuilds it and cascades into a new adapter,\n     * churning gesture state.\n     */\n    routing?: readonly NodeRoutingEntry[];\n\n    /** How to read and rewrite this scene's poses. Every built-in action,\n     *  the selection chrome and picking read it. Default `AUTO_POSE_DESCRIPTOR`\n     *  (rect poses and `Path` poses). */\n    poseDescriptor?: PoseDescriptor<TPose>;\n\n    // --- Geometry: hit-test + bounds overrides consumed by the internal\n    //     `useSelectTool`. Ignored if the consumer passes their own `tools`. ---\n    geometry?: {\n      /** Hit-test override. Return the topmost id, the full back-to-front hit\n       *  stack (`string[]`), or `null` for empty space. The stack form lets a\n       *  consumer with domain overlap ordering (e.g. children over their\n       *  container) feed the kit's `pickTopMostHit` the true order instead of\n       *  pre-collapsing to one id. Matches `Canvas`'s `pickEvery` shape. */\n      pickEvery?: (worldX: number, worldY: number) => string | string[] | null;\n      boundsOf?: (id: string) => Bounds | null;\n      /**\n       * What \"the pointer is on this node\" means for the default body-pick.\n       *\n       * - `'pose'` — the node's pose rect, rotation honored.\n       * - `'shape'` (default) — the pose rect as a pre-filter, then the ink the painter\n       *   actually lays down: its silhouette filled or not per the painter's `ink`, plus\n       *   its outline widened by the stroke half-width and `pickTolerancePx`.\n       *\n       * Painters with no silhouette keep the pose-rect answer either way. Ignored when\n       * `pickEvery` is supplied: that override owns the test.\n       */\n      picking?: 'pose' | 'shape';\n      /**\n       * Grab slop around a shape's outline, in **screen** pixels, so the target keeps\n       * its apparent size at any zoom. Default 4. It widens the outline test under\n       * `picking: 'shape'` and grows the pose-rect pre-filter so those outline hits\n       * survive it. Set `0` for exact geometry.\n       */\n      pickTolerancePx?: number;\n    };\n\n    // --- Selection options. `pickBest` and `handleHitRadius` configure the\n    //     internal select tool, and are ignored under a `tools` takeover;\n    //     `move`, `snap`, `resize` and `rotate` configure the `move`,\n    //     `resize` and `rotate` presets, and apply either way. ---\n    selectTool?: {\n      move?: UseMoveOptions<TPose>;\n      resize?: UseResizeOptions<TPose>;\n      /** Rotation options, or `false` to disable rotation entirely — drops the\n       *  `rotate` action AND hides the selection rotation-handle chrome. */\n      rotate?: UseRotateOptions<TPose> | false;\n      snap?: SnapStrategy<TPose>;\n      handleHitRadius?: number;\n      /** Override the body-pick used on click/pointerdown. Alt-aware: receives\n       *  the live alt state + current selection so consumers can implement\n       *  alt-cycling through an overlapping stack. Default: top-most hit\n       *  (alt ignored). */\n      pickBest?: (worldX: number, worldY: number, alt: boolean, sel: readonly string[]) => string | null;\n    };\n\n    /** Consumer node factories for the `insert` action, keyed by tool `kind`.\n     *  Each factory receives the drag AABB + tool `extras` and returns the\n     *  node's `data` (in this canvas's own data shape) plus an optional `pose`.\n     *  A factory for a kit kind (`rect`, `line`, …) replaces the kit's default\n     *  `{ path, fill }` node for that kind; a factory for a novel kind (e.g.\n     *  `text`) adds insert support the kit doesn't ship. The dep supplies id,\n     *  layer, and the undoable op. Return `null` to reject an insert. */\n    insertNodeFactories?: Record<string, InsertNodeFactory>;\n\n    /** The fill, stroke, and fill rule a kit-built shape is inserted with, by\n     *  tool `kind` and insert count; the kit keeps the geometry. Default\n     *  `paletteInsertPaint`, the kit palette in turn. A kind with a factory in\n     *  `insertNodeFactories` is not asked. */\n    insertPaint?: InsertPaint;\n\n    /** External-content ingestion (OS drop / clipboard paste / picker).\n     *\n     *  - `handlers` — consumer content handlers registered for this canvas's\n     *    lifetime (priority 0 by default — they beat the kit's `image/*` /\n     *    `image/svg+xml` handlers at -100/-90).\n     *  - `resolveSrc` — overrides the image handler's `data:`-URI embed (e.g.\n     *    upload to an asset store, return the URL).\n     *  - `svg.unpack` — makes the kit SVG handler parse dropped SVG files into\n     *    native scene nodes instead of one embedded-image node each.\n     *  - `clipboard` — the kit weasel-JSON paste handler, enabled by default.\n     *    `reviver` restores JSON-unfriendly values the copying side encoded via\n     *    `jsonReplacer`. `enabled: false` opts the canvas out, but the kit\n     *    handler still consumes weasel-matching items and declines them inert\n     *    rather than letting them fall through. Also governs Cmd/Ctrl+V under\n     *    the `edit` preset; the rest takes the `ingest` preset.\n     *\n     *  Memoize `handlers` and `clipboard.reviver`: an inline array literal\n     *  re-registers the handlers on every render. */\n    ingestion?: {\n      handlers?: ContentHandlerEntry[];\n      resolveSrc?: (file: File) => Promise<string>;\n      svg?: SvgIngestOptions;\n      clipboard?: {\n        reviver?: (key: string, value: unknown) => unknown;\n        enabled?: boolean;\n        /** Called when a paste left copied nodes out, with each one and the\n         *  reason. `useClipboardOps` takes the same callback as\n         *  `onPasteOmitted` for a paste from its own in-memory copy. */\n        onOmitted?: (omitted: PasteOmission[]) => void;\n      };\n    };\n\n    selection?: SelectionApi;\n    selectionOptions?: UseSelectionOptions;\n\n    /**\n     * `false` stops the canvas writing the selection: no click, marquee,\n     * lasso, action or tool, and no op committed through the adapter it hands\n     * its tools. The consumer's own `SelectionApi` — the `selection` prop, or\n     * `useSelection({ scene })` — still writes, and the canvas draws what it\n     * holds. Undo and redo still restore the selection each history entry\n     * recorded. Default `true`.\n     *\n     * Click policy (whether shift-click extends) is the selection's `mode`:\n     * `useSelection({ mode: 'multi' })`, or `selectionOptions={{ mode: 'multi' }}`\n     * for the selection the canvas builds itself.\n     */\n    selectable?: boolean;\n\n    /**\n     * Behavior presets to turn on, composable in any combination. A canvas\n     * with none renders its scene and keeps a selection (the `selection` API\n     * works) that no input sets: no tools, no standard actions or their keys,\n     * no clipboard, no drop or paste, and no selection chrome. The dispatcher\n     * is still mounted, so bindings a consumer adds work.\n     *\n     * - `view` — wheel pan and zoom, pinch, the zoom keys, and the hand tool\n     *   (H, or hold Space). Passing `viewport` implies it.\n     * - `select` — the select tool, as the initial active tool and Escape's\n     *   return target: click to pick, drag on empty to marquee, click on empty\n     *   to clear.\n     * - `outline` — the selection outline, whichever tool sets the selection.\n     * - `pick` — `select` and `outline`.\n     * - `move` — drag a body to move it, Alt-drag to clone it. Ambient, so it\n     *   runs under any tool that does not claim the drag.\n     * - `resize` — resize handles, drawn and bound.\n     * - `rotate` — the rotation handle, drawn and bound.\n     * - `transform` — `resize` and `rotate`.\n     * - `edit` — undo/redo, delete, duplicate, group/ungroup, nudge,\n     *   select-all, Escape, cancel-gesture, cut/copy/paste, fill and stroke,\n     *   and their keys. Cmd/Ctrl+V pastes nodes a kit canvas copied, from\n     *   this tab or another, and nothing else.\n     * - `arrange` — align, distribute, reorder, flip.\n     * - `paths` — pathfinder operations, path-edit entry and anchor editing.\n     * - `ingest` — dropped and pasted content: images, SVG, files, and\n     *   whatever `ingestion.handlers` accept, on Cmd/Ctrl+V or an OS drop.\n     * - `draw` — all of the above.\n     *\n     * Tools add the actions they bind — a shape tool brings `insert` — so\n     * `defaultTools` composes with any preset. `actions` then adds, overrides\n     * or removes on top of what the presets registered.\n     */\n    features?: readonly Feature[];\n\n    /** Extra tools or overrides keyed by id, or a full `ToolsApi` takeover.\n     *\n     *  **Patch form** (`Record<string, Tool | true | false>`): merged\n     *  into the built-in registry on top of whatever `defaultTools` and\n     *  `features` already selected.\n     *    - `true` pulls in the built-in for this id (`'pen'`, `'lasso'`,\n     *      `'hand'`, …), the same as listing it in `defaultTools`. Unknown\n     *      built-in ids warn in dev and are ignored.\n     *    - `Tool` adds a new id or replaces an existing one\n     *      (dev-only warning on replace).\n     *    - `false` omits a bundled tool entirely.\n     *  Auto-wiring (keybindings, dispatcher, action registry) still runs.\n     *\n     *  **Takeover form** (`ToolsApi`): the internal registry is bypassed and\n     *  this `tools` value is forwarded to Canvas as-is — the consumer owns\n     *  active-slot management, and `pick`'s select tool is theirs to supply.\n     *  Every other preset still applies. Keybindings are still auto-wired\n     *  against the supplied registry; pass `enableKeybindings={false}` to opt\n     *  out. */\n    tools?: ToolsApi | Record<string, Tool | true | false>;\n\n    /**\n     * Auto-wire keyboard shortcuts. Default `true`. When `false`, SceneCanvas still mounts\n     * its tools but routes no keyboard input to them — neither tool hotkeys nor\n     * keyboard-bound actions like delete / escape / nudge. Pointer, wheel, and contextmenu\n     * interactions are unaffected.\n     */\n    enableKeybindings?: boolean;\n\n    /**\n     * Take the keyboard on mount, as a press in the canvas would. A key that\n     * reaches the page goes to the canvas the user last pressed or scrolled\n     * in, and to no canvas before the first such interaction, so a canvas in a\n     * side panel does not take Space from a page that wants it. An app whose\n     * canvas is the page sets this so its shortcuts work before the first\n     * click. Default `false`.\n     */\n    claimKeys?: boolean;\n\n    /**\n     * Auto-mount the gesture dispatcher (`useGestureDispatcher`). Default `true`. `false` is\n     * for tests or demos that drive actions another way, or that call\n     * `useGestureDispatcher` themselves.\n     */\n    enableGestureDispatcher?: boolean;\n\n    /** Called with the `ToolsApi` SceneCanvas constructs or receives, whenever its identity\n     *  changes. For introspection. */\n    onToolsCreated?: (tools: ToolsApi) => void;\n\n    /**\n     * Built-in tools SceneCanvas registers in its internal `useTools`, on top\n     * of the ones presets bring (`select` from `pick`, `hand` from `view`).\n     * Default: none. Each tool also registers the kit actions it binds, so\n     * `['rect']` brings `insert`. Ignored when the consumer supplies their own\n     * `tools` prop.\n     */\n    defaultTools?: readonly BuiltinToolId[];\n\n    /** Per-tool option overrides for the built-in shape/lasso/clone tools.\n     *  Each entry is a narrow subset of the underlying hook's options\n     *  surface — `lasso.mode`, `clone.cloneSelection`, etc. */\n    toolOptions?: BuiltinToolOptions;\n\n    /** Initial active-slot tool id. Default: `'select'` when it is\n     *  registered, otherwise none — a canvas can run on ambient bindings\n     *  alone. Must be one of the registered tools. Ignored when the consumer\n     *  supplies their own `tools` prop. */\n    initialActiveTool?: string;\n\n    /** Always-on entries to register alongside the internal tools — every one\n     *  a `SurfaceContribution`, whose views, deps, overlay, bindings, actions\n     *  and `attach` all install from this one list, and uninstall when the\n     *  entry leaves it. A tool is a contribution too, so one can go here. If\n     *  you supply your own `tools` prop, this is ignored — wire `ambient`\n     *  through your own `useTools` call instead. */\n    ambient?: readonly SurfaceContribution[];\n\n    /** What an entry's `requires` does when the running kit does not meet\n     *  it: `'warn'` (the default) logs in development, `'strict'` throws,\n     *  `'off'` skips the check. */\n    versionCheck?: VersionCheck;\n\n    /** Touch and pen long-press: its hold time, its haptic, and the\n     *  feedback shown while it is held. */\n    longPress?: SceneCanvasLongPress;\n\n    /** Configures the `view` preset, and implies it: passing this turns\n     *  `view` on.\n     *\n     *  - `inertia` and `animatedZoom` are opt-in: pass `true` for defaults or\n     *    an object to tune. Omitted means off.\n     *  - `pan` (wheel pan), `zoom` (Cmd+wheel + Cmd+=/-/0), and `pinchZoom`\n     *    (two-finger pinch) are on under `view`; pass `false` to disable one.\n     *    Disabling via the `actions` prop\n     *    (`actions: { 'viewport.wheelPan': null }`) also works and runs after\n     *    this. */\n    viewport?: {\n      inertia?: boolean | InertiaConfig;\n      /** Two-finger pinch zoom. `true`/omitted = on with the kit's 0.1–8\n       *  clamp; `false` disables. An object sets the scale clamp. */\n      pinchZoom?: boolean | PinchZoomOptions;\n      /** Glide Cmd+=/-/0 instead of jumping. `true` uses the kit defaults\n       *  (250 ms, ease-out-cubic); a {@link ViewportZoomAnimateOptions} tunes\n       *  duration, easing, interpolator and the reset-branch duration. Wheel\n       *  and pinch are unaffected — their input already samples every frame. */\n      animatedZoom?: boolean | ViewportZoomAnimateOptions;\n      /** Wheel pan. `true`/omitted = on; `false` disables; an object locks the\n       *  axis (`{ axis: 'x' }`) so a single-axis viewport needs no commit clamp. */\n      pan?: boolean | WheelPanOptions;\n      /** Wheel/keyboard zoom. `true`/omitted = default Cmd+wheel zoom with the\n       *  kit's 0.1–8 clamp; `false` disables. Pass a {@link ViewportZoomOptions}\n       *  object to bind zoom to plain wheel (`wheel: 'plain'`, pair with\n       *  `pan: false`) and/or set `min`/`max` scale clamps. */\n      zoom?: boolean | ViewportZoomOptions;\n      /** Callback invoked by Cmd-0 (`viewport.zoom` action's `reset` branch).\n       *  When supplied, replaces the default reset-to-identity behavior —\n       *  consumers typically refit the document page into the workspace via\n       *  `fitViewToBounds`. Return the target `View` to let the kit animate\n       *  there when `animatedZoom` is on; return nothing to dispatch it\n       *  yourself, which is what a controlled canvas does. */\n      recenter?: () => View | void;\n    };\n\n    /**\n     * @experimental\n     * Override / disable / extend the default action set. Pass `null` to disable all\n     * defaults.\n     */\n    actions?: ActionsProp;\n\n    /**\n     * @experimental\n     * Given a scene node, return a short human-readable \"kind\" label (e.g. `'rectangle'`,\n     * `'sticky note'`), which the kit publishes per id into any surrounding\n     * `<SelectionContextProvider>`. Return `undefined` to skip an entry. When omitted,\n     * containers report `'group'`, poses with a `kind` property report `'path'`, and\n     * everything else is left unlabelled.\n     */\n    describeKind?: (node: Node<TData, TLayer, TPose>) => string | undefined;\n\n    /**\n     * Animator to bind for per-frame redraws. SceneCanvas requests a redraw on every active\n     * animation frame and paints `animator.colorOverrides` onto the scene's nodes: the\n     * kit's path and shape painters apply them, and a custom `drawOne` receives them as\n     * `ctx.vertexColors`.\n     */\n    animator?: Animator;\n\n    /**\n     * Extra views on this canvas: each is a camera over a rect of the same\n     * surface, drawn through one GL context, with input routed to it. The flat\n     * `view` / `onViewChange` props above stay the canvas's own camera — view\n     * zero — and are unaffected by anything declared here.\n     *\n     * Order is paint and hit order, low to high. Each entry is a\n     * `<CanvasView>`; mounting one as a child is the same declaration, and\n     * children land after every entry here.\n     */\n    views?: readonly CanvasViewProps[];\n\n    /**\n     * Children rendered alongside the canvas, inside its input scope (e.g.\n     * shortcuts overlays, probes).\n     */\n    children?: ReactNode;\n\n    /**\n     * A yoke to join, from `useYoke()`: canvases on one yoke share the\n     * active tool, the gesture in flight and history. Omitted, this canvas\n     * keeps its own.\n     */\n    yoke?: Yoke;\n\n    /**\n     * Chrome-caps visibility overrides, keyed by chrome id (`selection.outline`,\n     * `selection.rotation-handle`, `gesture.marquee`, …). Each entry is a composable\n     * {@link Condition} built from the `cond()` builder, merged on top of the kit's\n     * `defaultVisibilityRules`. Set an id to `never` to suppress a chrome element\n     * entirely (also unhittable), or to `always` to force-show.\n     */\n    chromeVisibility?: import('features/chrome-caps').VisibilityRules;\n\n    /**\n     * The app's mode registry (`createModeRegistry` in `@weasel-js/modes`).\n     * The canvas reads the active mode from it to gate chrome, tool\n     * activation and the dispatcher's eligibility filter, repaints when it\n     * switches, and hands every registered mode to the dev-time route-conflict\n     * check. Omitted, the canvas behaves as the kit's normal mode and nothing\n     * revokes anchor editing.\n     */\n    modes?: ModeRegistry;\n\n    /** Hands which path is being anchor-edited to the host. See {@link PathEditHost}. */\n    pathEdit?: PathEditHost;\n\n    /**\n     * Override detected device facts. Merged over what `matchMedia` reports;\n     * `targetScale` is re-derived from the merged `coarsePointer` unless you\n     * override it explicitly.\n     */\n    device?: Partial<DeviceProfile>;\n\n    /**\n     * Live focus getter for chrome-caps' `focused` ctx field, for visibility rules that\n     * read the `focused` atom (the kit's default `selection.rotation-handle` rule does).\n     * Omit to default `focused` to `true`.\n     */\n    getFocused?: () => boolean;\n\n    /** Custom shader programs to compile on the renderer. See `CanvasProps.shaders`. */\n    shaders?: ShaderProgramHandle[];\n\n    /** Flatness tolerance for curve tessellation, in world units. See\n     *  `CanvasProps.flattenTolerance`. */\n    flattenTolerance?: number;\n\n    /** Fill for the full canvas behind the scene, drawn as a screen-space layer slotted\n     *  before `'scene'` — independent of pan / zoom. */\n    backgroundFill?: Paint;\n    /** Dev HUD: a fixed-position widget showing live cursor coords in both viewport\n     *  (client) and canvas (world) frames. */\n    cursorCoordsHud?: boolean;\n    /** Dev HUD: a fixed-position widget listing the ids `pickEvery(world)` returns under\n     *  the cursor. */\n    pickHud?: boolean;\n    /**\n     * The debug overlay: `<Canvas debug>`'s config, plus `slops: true` for\n     * translucent halos at every affordance hit zone. `false` turns it off;\n     * absent reads `?debug=…` from the URL, as `<Canvas>` does.\n     */\n    debug?: (DebugConfig & { slops?: boolean }) | false;\n    /**\n     * Dev HUD: when true (or object), mounts a fixed-position widget below\n     * the pick HUD showing the active modality mode, active-slot tool, and\n     * hotkey stack. Pass `{ modeId }` to populate the mode line.\n     */\n    modalityHud?: boolean | { modeId?: string };\n\n    /**\n     * Per-id alpha multiplier for the scene-render slot: each node's draw output is wrapped\n     * in a group with the returned alpha, and 1 emits no wrapper. Typical use: dimming\n     * non-active nodes during a mode transition.\n     */\n    alphaFor?: (id: string) => number;\n\n    /**\n     * Show or hide render layers in this canvas's own view, by id — the map\n     * `<Canvas>` takes. Each scene layer paints as its own render layer, keyed\n     * `scene:<layerId>`, so `{ 'scene:guides': false }` hides one scene layer\n     * here and nowhere else.\n     *\n     * A layer hidden this way is gone from this view: it does not paint, and a\n     * click, a marquee or Cmd+A here passes over it. Another view of the same\n     * scene — a `<CanvasView>`, a second canvas, a minimap — still shows it and\n     * can still take it. It applies on top of the scene's own\n     * `LayerRecord.visible` and cannot show a layer the scene hides.\n     */\n    layerVisibility?: Record<string, boolean>;\n\n    /**\n     * Draw order for this view, by render-layer id, bottom first. A listed\n     * order is the whole list: a scene layer left out of it is neither painted\n     * nor picked here. See `CanvasProps.layerOrder`.\n     */\n    layerOrder?: string[];\n\n    /**\n     * Per-id pointer-interactivity predicate: an id it returns `false` for is excluded from\n     * hit-test results. Typical use: suppressing pointer events for dimmed nodes.\n     */\n    isPointerInteractive?: (id: string) => boolean;\n\n    /**\n     * Called when the user double-clicks the canvas, with the hit node (id + kind) at that\n     * position, or `null` on empty canvas. Typical use: modality dispatch — enter path-edit\n     * on a path node, isolation on a group, text-edit on a text node.\n     */\n    onDoubleClick?: (hit: SceneCanvasHit | null) => void;\n    /** Called on every click — a press and release without a drag — with the\n     *  node under it, or `null` on empty canvas. Fires after the click's own\n     *  behavior, so a pick it made is already in the selection, and fires\n     *  again on a node that was already picked. */\n    onClick?: (hit: SceneCanvasHit | null) => void;\n  };\n"],"mappings":";;;;;;AAiEA,IAAaA,IAAsBC;AAgCnC,SAAgBC,EACd,GACA,IAAc,GACgC;CAC9C,IAAMC,IAAW;EACf,OAAO;GACL,SAASC;GAIT,aAAaC;EACf;EACA,kBAAkB,EAAE,SAAS,EAAE,MAAMC,EAAcC,CAAW,CAAC,CAAC,OAAO,EAAE;CAC3E;CAEA,IAAI,CAACC,GAAM,OAAOL;CAGlB,IAAMM,IAAS,EAAE,GAAGD,EAAK;CAEzB,IAAI,EAAE,WAAWA,IACf,EAAO,QAAQL,EAAS;MACnB,IAAIK,EAAK,UAAU,QAAQE,EAAcF,EAAK,KAAK,GACxD,EAAO,QAAQA,EAAK;MACf;EACL,IAAMG,IAAQ;GAAE,GAAGR,EAAS;GAAO,GAAGK,EAAK;EAAM;EACjD,EAAO,QAAQA,EAAK,SAAS,iBAAiBA,EAAK,QAC/CG,IACA;GAAE,GAAGA;GAAO,aAAaC,EAAqCD,EAAM,OAAO;EAAE;CACnF;CAUA,OARA,AACEF,EAAO,mBADH,sBAAsBD,IAEjBA,EAAK,qBAAqB,QAAQE,EAAcF,EAAK,gBAAgB,IACpDA,EAAK,mBAEL;EAAE,GAAGL,EAAS;EAAkB,GAAGK,EAAK;CAAiB,IAJzDL,EAAS,kBAO9BM;AACT;AAQA,IAAaI,IAAiF,CAAC,UAAU,MAAM,GAGlGC,IAA6C,CAAC,GAAGD,GAAyB,GAAGE,CAAe"}
+{"version":3,"file":"props.js","names":[],"sources":["../../../src/canvas/SceneCanvas/props.ts"],"sourcesContent":["import type { ModeRegistry } from '@weasel-js/modes';\nimport type { PathEditHost, PathEditOpening } from './pathEditHost';\nimport type { SceneCanvasGeometry } from './geometryProps';\nimport type { SceneCanvasHit, SceneCanvasPointerProps } from './pointerProps';\nimport type { Paint } from '@weasel-js/paint';\nimport type { ActionsProp, ActionTunings } from '@weasel-js/routing';\nimport { Yoke } from '@weasel-js/routing/react';\nimport type { PasteOmission } from 'core/adapters/types';\nimport type { Op } from 'core/ops/types';\nimport type { Node, Scene, SerializedScene } from 'core/scene/types';\nimport type { SelectionApi, UseSelectionOptions } from 'core/selection/useSelection';\nimport { KIT_SHAPE_KINDS, type BuiltinShapeToolId } from 'core/shapeKinds';\nimport type { ContentHandlerEntry } from 'features/ingestion';\nimport type { SceneCanvasSnap } from 'features/snap/types';\nimport type { SvgIngestOptions } from 'interactions/actions/depSchema';\nimport type { GeometryProjection } from 'interactions/actions/geometryProjection';\nimport type { UseMoveOptions } from 'interactions/actions/move/options';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type { UseRotateOptions } from 'interactions/actions/rotate/options';\nimport type { ReactNode } from 'react';\nimport type { Animator } from '@weasel-js/animator';\nimport type { PoseTransitionSeat } from '../../animation/poseTransition';\nimport { HANDLE_BASE_PX } from '../../core/device/targets';\nimport type { DeviceProfile } from '../../core/device/types';\nimport type { NodeRoutingEntry } from '../../core/scene/NodeRouting';\nimport type { DebugConfig } from '../../debug/types';\nimport type { LayoutDropTargetMode, ReflowTransition } from '../../layout/types';\nimport type { FlattenTolerance, ShaderProgramHandle } from '@weasel-js/renderer';\nimport type { Tool, ToolsApi } from '../../tools/overlayBinding';\nimport type { SceneSlotConfig } from '../buildSceneLayer';\nimport type { CanvasProps } from '../Canvas';\nimport type { LayersMap } from '../layerSlots';\nimport type { CanvasViewProps } from '../CanvasView';\nimport type { InsertNodeFactory, InsertPaint } from '../deps';\nimport type { SurfaceContribution } from '../surfaceContribution';\nimport type { CameraProps } from '../useCanvasView';\nimport type { FeatureEntry } from './features';\nimport type { BuiltinToolOptions } from './useBuiltinShapeTools';\nimport type { VersionCheck } from './useContributionRoles';\nimport type { SceneCanvasViewport } from './viewportProp';\n\n/** The adapter surface delete / duplicate / group / ungroup need, narrowed from\n *  `SceneCanvasAdapter` because `useSceneStandardActions` is non-generic. */\nexport interface BridgeAdapter {\n  applyOps(ops: Op[], label?: string): void;\n  insertNode(node: { id: string; [k: string]: unknown }): void;\n  removeNode(id: string): void;\n  setSelection(ids: string[]): void;\n}\n\n/** Default size in CSS pixels for selection corner-handles AND their\n *  hit-test radius, at `targetScale = 1`. Deliberately unscaled; kit-internal\n *  use sites multiply by `DeviceProfile.targetScale`. */\nexport const DEFAULT_HANDLE_SIZE = HANDLE_BASE_PX;\n\n/** `<SceneCanvas longPress>`. */\nexport interface SceneCanvasLongPress {\n  /**\n   * Shown while a long-press is held and some binding would fire on it.\n   * Default: a ring that fills around the press point\n   * (`createLongPressFeedbackContribution()`), static under\n   * `prefers-reduced-motion`. `false` shows nothing; a contribution replaces\n   * it, reading the `longPress` dep. Installed beside `ambient`, so under a\n   * `tools` takeover add it to your own `useTools` call instead.\n   */\n  feedback?: boolean | SurfaceContribution;\n  /** Default true. A long-press some binding handled pulses\n   *  `navigator.vibrate` briefly, for touch and pen, where the API exists. */\n  haptics?: boolean;\n  /** Hold time in ms. Default `LONG_PRESS_MS` (500). */\n  duration?: number;\n}\n\n/** `<SceneCanvas layers>`: a {@link LayersMap} whose scene slot may be partial,\n *  since the defaults fill in whatever it leaves out. */\nexport type SceneCanvasLayers<TNode extends { id: string }, TPose> = LayersMap<\n  TNode,\n  TPose,\n  Partial<SceneSlotConfig<TNode, TPose>>\n>;\n\n/** Built-in tool ids SceneCanvas knows how to mount when no `tools` prop\n *  is supplied, via `defaultTools`. */\nexport type BuiltinToolId = 'select' | 'hand' | BuiltinShapeToolId | 'slice' | 'bone' | 'weight';\n\n/** Every built-in tool id, in palette order: the navigation tools, the shape\n *  tools of the `core/shapeKinds` table, then the knife and the rig tools. */\nexport const BUILTIN_TOOL_IDS: readonly BuiltinToolId[] = ['select', 'hand', ...KIT_SHAPE_KINDS, 'slice', 'bone', 'weight'];\n\nexport type { SceneCanvasHit };\n\n/** Props for `<SceneCanvas>`. A scene is the only thing it needs. With nothing\n *  else it renders that scene and keeps a selection no input sets; `features`\n *  turns behavior on by preset, and the rest configures what those turn on. */\nexport type SceneCanvasProps<TData, TLayer extends string, TPose> =\n  Omit<\n    CanvasProps<TPose>,\n    | 'adapter' | 'boundsOf' | 'selection' | 'tools'\n    | 'viewState'       // SceneCanvas makes the camera from the view props below\n    | 'layers'          // stripped so we can re-add as optional below\n    | 'getIsVisible'    // SceneCanvas synthesizes this from chromeVisibility\n    | 'contentVersion'  // SceneCanvas wires this to the scene's own version\n    | 'layerVisibility' | 'layerOrder' // re-declared below: they gate picking here too\n    | 'debug'           // re-declared below with SceneCanvas's own `slops`\n  > & CameraProps\n  & {\n    /** A `Scene` (typically from `useScene`) — or a `SerializedScene` JSON\n     *  object, which SceneCanvas bakes into a Scene on first render. The\n     *  serialized form is read once; pass a `key` on `<SceneCanvas>` to force\n     *  a fresh canvas from updated JSON.\n     *\n     *  The JSON shape is relaxed (`version: number` rather than the `1`\n     *  literal) so an `import json from './x.json'` result satisfies the type\n     *  without an `as` cast. */\n    scene:\n      | Scene<TData, TLayer, TPose>\n      | SerializedScene<TData, TLayer, TPose>\n      | { version: number; systemLayers?: ReadonlyArray<{ id: string }>; nodes: ReadonlyArray<unknown> };\n\n    /** Layer configuration. When omitted, SceneCanvas applies kit defaults\n     *  (a scene slot that paints `node.data.fill` rects + a default\n     *  selection overlay). A partial scene or selection-overlay config is\n     *  spread over that slot's defaults; pass `slot: null` to suppress a\n     *  default explicitly. */\n    layers?: SceneCanvasLayers<Node<TData, TLayer, TPose>, TPose>;\n\n    /** Which layout container a drag lands in when several contain the drop\n     *  point — the innermost (default), the topmost in paint order, or only\n     *  containers whose strategy declares a `dropRegion`. Decides both the\n     *  drag-time reflow preview and the commit. */\n    layoutDropTarget?: LayoutDropTargetMode;\n\n    /** Carries the siblings a layout reflow displaces to their slots over time\n     *  instead of snapping them — `useAnimatedReflow` builds one. Covers a\n     *  drag's reflow and every one the scene records (an insert, delete,\n     *  reorder or resize inside a laid-out container). Absent or `null`,\n     *  they snap. */\n    reflowTransition?: ReflowTransition<TPose> | null;\n\n    /** Glides what is shown when the scene writes a pose — a `scene.setPose`, an undo — and sees\n     *  removed nodes off with `exit`. Absent or `null`, writes snap. See {@link PoseTransitionSeat}. */\n    poseTransition?: PoseTransitionSeat<TPose> | null;\n\n    /**\n     * Lets pose-transform actions (move, resize, nudge, flip — NOT rotate) also rewrite a\n     * node's data-held geometry. Given a node and the affine `m` applied to its pose,\n     * `transform(node, m)` returns updated `data`, or `null` for nodes with no data-held\n     * geometry. When absent, the kit emits only the pose op and leaves `data` untouched.\n     *\n     * @see GeometryProjection\n     */\n    geometryProjection?: GeometryProjection;\n\n    /**\n     * Routing-trait classifiers. The kit builds a `NodeRouting` registry per `<SceneCanvas>`\n     * from this prop and uses it to derive each hit's `kind`, which tool routing tables\n     * (e.g. `{ target: 'rect', actionId: 'move' }`) match against. Pass `defaultNodeRouting`\n     * for the kit's built-in shape kinds; spread additional entries for consumer-defined\n     * kinds.\n     *\n     * **Memoize the `routing` value.** The registry is memoized on the prop's reference\n     * identity: a fresh array each render rebuilds it and cascades into a new adapter,\n     * churning gesture state.\n     */\n    routing?: readonly NodeRoutingEntry[];\n\n    /** How to read and rewrite this scene's poses. Every built-in action,\n     *  the selection chrome and picking read it. Default `AUTO_POSE_DESCRIPTOR`\n     *  (rect poses and `Path` poses). */\n    poseDescriptor?: PoseDescriptor<TPose>;\n\n    // --- Geometry: hit-test + bounds overrides consumed by the internal\n    //     `useSelectTool`. Ignored if the consumer passes their own `tools`. ---\n    geometry?: SceneCanvasGeometry;\n\n    // --- Selection options. `pickBest` and `handleHitRadius` configure the\n    //     internal select tool, and are ignored under a `tools` takeover;\n    //     `move`, `resize` and `rotate` configure the `move`,\n    //     `resize` and `rotate` presets, and apply either way. ---\n    selectTool?: {\n      move?: UseMoveOptions<TPose>;\n      resize?: UseResizeOptions<TPose>;\n      /** Rotation options, or `false` to disable rotation entirely — drops the\n       *  `rotate` action AND hides the selection rotation-handle chrome. */\n      rotate?: UseRotateOptions<TPose> | false;\n      handleHitRadius?: number;\n      /** Override the body-pick used on click/pointerdown. Alt-aware: receives\n       *  the live alt state + current selection so consumers can implement\n       *  alt-cycling through an overlapping stack. Default: top-most hit\n       *  (alt ignored). */\n      pickBest?: (worldX: number, worldY: number, alt: boolean, sel: readonly string[]) => string | null;\n    };\n\n    /** Consumer node factories for the `insert` action, keyed by tool `kind`.\n     *  Each factory receives the drag AABB + tool `extras` and returns the\n     *  node's `data` (in this canvas's own data shape) plus an optional `pose`.\n     *  A factory for a kit kind (`rect`, `line`, …) replaces the kit's default\n     *  `{ path, fill }` node for that kind; a factory for a novel kind (e.g.\n     *  `text`) adds insert support the kit doesn't ship. The dep supplies id,\n     *  layer, and the undoable op. Return `null` to reject an insert. */\n    insertNodeFactories?: Record<string, InsertNodeFactory>;\n\n    /** The fill, stroke, and fill rule a kit-built shape is inserted with, by\n     *  tool `kind` and insert count; the kit keeps the geometry. Default\n     *  `paletteInsertPaint`, the kit palette in turn. A kind with a factory in\n     *  `insertNodeFactories` is not asked. */\n    insertPaint?: InsertPaint;\n\n    /** External-content ingestion (OS drop / clipboard paste / picker).\n     *\n     *  - `handlers` — consumer content handlers registered for this canvas's\n     *    lifetime (priority 0 by default — they beat the kit's `image/*` /\n     *    `image/svg+xml` handlers at -100/-90).\n     *  - `resolveSrc` — overrides the image handler's `data:`-URI embed (e.g.\n     *    upload to an asset store, return the URL).\n     *  - `svg.unpack` — makes the kit SVG handler parse dropped SVG files into\n     *    native scene nodes instead of one embedded-image node each.\n     *  - `clipboard` — the kit weasel-JSON paste handler, enabled by default.\n     *    `reviver` restores JSON-unfriendly values the copying side encoded via\n     *    `jsonReplacer`. `enabled: false` opts the canvas out, but the kit\n     *    handler still consumes weasel-matching items and declines them inert\n     *    rather than letting them fall through. Also governs Cmd/Ctrl+V under\n     *    the `edit` preset; the rest takes the `ingest` preset.\n     *\n     *  Memoize `handlers` and `clipboard.reviver`: an inline array literal\n     *  re-registers the handlers on every render. */\n    ingestion?: {\n      handlers?: ContentHandlerEntry[];\n      resolveSrc?: (file: File) => Promise<string>;\n      svg?: SvgIngestOptions;\n      clipboard?: {\n        reviver?: (key: string, value: unknown) => unknown;\n        enabled?: boolean;\n        /** Called when a paste left copied nodes out, with each one and the\n         *  reason. `useClipboardOps` takes the same callback as\n         *  `onPasteOmitted` for a paste from its own in-memory copy. */\n        onOmitted?: (omitted: PasteOmission[]) => void;\n      };\n    };\n\n    selection?: SelectionApi;\n    selectionOptions?: UseSelectionOptions;\n\n    /**\n     * `false` stops the canvas writing the selection: no click, marquee,\n     * lasso, action or tool, and no op committed through the adapter it hands\n     * its tools. The consumer's own `SelectionApi` — the `selection` prop, or\n     * `useSelection({ scene })` — still writes, and the canvas draws what it\n     * holds. Undo and redo still restore the selection each history entry\n     * recorded. Default `true`.\n     *\n     * Click policy (whether shift-click extends) is the selection's `mode`:\n     * `useSelection({ mode: 'multi' })`, or `selectionOptions={{ mode: 'multi' }}`\n     * for the selection the canvas builds itself.\n     */\n    selectable?: boolean;\n\n    /**\n     * Behavior presets to turn on, composable in any combination. A canvas\n     * with none renders its scene and keeps a selection (the `selection` API\n     * works) that no input sets: no tools, no standard actions or their keys,\n     * no clipboard, no drop or paste, and no selection chrome. The dispatcher\n     * is still mounted, so bindings a consumer adds work.\n     *\n     * - `view` — wheel pan and zoom, pinch, the zoom keys, and the hand tool\n     *   (H, or hold Space). Passing `viewport` implies it.\n     * - `select` — the select tool, as the initial active tool and Escape's\n     *   return target: click to pick, drag on empty to marquee, click on empty\n     *   to clear.\n     * - `outline` — the selection outline, whichever tool sets the selection.\n     * - `pick` — `select` and `outline`.\n     * - `move` — drag a body to move it, Alt-drag to clone it. Ambient, so it\n     *   runs under any tool that does not claim the drag.\n     * - `resize` — resize handles, drawn and bound.\n     * - `rotate` — the rotation handle, drawn and bound.\n     * - `transform` — `resize` and `rotate`.\n     * - `edit` — undo/redo, delete, duplicate, group/ungroup, nudge,\n     *   select-all, Escape, cancel-gesture, cut/copy/paste, fill and stroke,\n     *   and their keys. Cmd/Ctrl+V pastes nodes a kit canvas copied, from\n     *   this tab or another, and nothing else.\n     * - `arrange` — align, distribute, reorder, flip.\n     * - `paths` — pathfinder operations, path-edit entry and anchor editing.\n     * - `ingest` — dropped and pasted content: images, SVG, files, and\n     *   whatever `ingestion.handlers` accept, on Cmd/Ctrl+V or an OS drop.\n     * - `draw` — all of the above.\n     *\n     * Any `FeaturePreset` object goes beside the names: core's own\n     * (`pathsPreset`), or one a package ships.\n     * Tools add the actions they bind — a shape tool brings `insert` — so\n     * `defaultTools` composes with any preset. `actions` then adds, overrides\n     * or removes on top of what the presets registered.\n     */\n    features?: readonly FeatureEntry[];\n\n    /** Extra tools or overrides keyed by id, or a full `ToolsApi` takeover.\n     *\n     *  **Patch form** (`Record<string, Tool | true | false>`): merged\n     *  into the built-in registry on top of whatever `defaultTools` and\n     *  `features` already selected.\n     *    - `true` pulls in the built-in for this id (`'pen'`, `'lasso'`,\n     *      `'hand'`, …), the same as listing it in `defaultTools`. Unknown\n     *      built-in ids warn in dev and are ignored.\n     *    - `Tool` adds a new id or replaces an existing one\n     *      (dev-only warning on replace).\n     *    - `false` omits a bundled tool entirely.\n     *  Auto-wiring (keybindings, dispatcher, action registry) still runs.\n     *\n     *  **Takeover form** (`ToolsApi`): the internal registry is bypassed and\n     *  this `tools` value is forwarded to Canvas as-is — the consumer owns\n     *  active-slot management, and `pick`'s select tool is theirs to supply.\n     *  Every other preset still applies. Keybindings are still auto-wired\n     *  against the supplied registry; pass `enableKeybindings={false}` to opt\n     *  out. */\n    tools?: ToolsApi | Record<string, Tool | true | false>;\n\n    /**\n     * Auto-wire keyboard shortcuts. Default `true`. When `false`, SceneCanvas still mounts\n     * its tools but routes no keyboard input to them — neither tool hotkeys nor\n     * keyboard-bound actions like delete / escape / nudge. Pointer, wheel, and contextmenu\n     * interactions are unaffected.\n     */\n    enableKeybindings?: boolean;\n\n    /**\n     * Take the keyboard on mount, as a press in the canvas would. A key that\n     * reaches the page goes to the canvas the user last pressed or scrolled\n     * in, and to no canvas before the first such interaction, so a canvas in a\n     * side panel does not take Space from a page that wants it. An app whose\n     * canvas is the page sets this so its shortcuts work before the first\n     * click. Default `false`.\n     */\n    claimKeys?: boolean;\n\n    /**\n     * Auto-mount the gesture dispatcher (`useGestureDispatcher`). Default `true`. `false` is\n     * for tests or demos that drive actions another way, or that call\n     * `useGestureDispatcher` themselves.\n     */\n    enableGestureDispatcher?: boolean;\n\n    /** Called with the `ToolsApi` SceneCanvas constructs or receives, whenever its identity\n     *  changes. For introspection. */\n    onToolsCreated?: (tools: ToolsApi) => void;\n\n    /**\n     * Built-in tools SceneCanvas registers in its internal `useTools`, on top\n     * of the ones presets bring (`select` from `pick`, `hand` from `view`).\n     * Default: none. Each tool also registers the kit actions it binds, so\n     * `['rect']` brings `insert`. Ignored when the consumer supplies their own\n     * `tools` prop.\n     */\n    defaultTools?: readonly BuiltinToolId[];\n\n    /** Per-tool option overrides for the built-in tools. Each entry is a\n     *  narrow subset of the underlying hook's options surface — `lasso.mode`,\n     *  `rig.state`, etc. */\n    toolOptions?: BuiltinToolOptions;\n    /** What gestures snap to, and how near it pulls. */\n    snap?: SceneCanvasSnap;\n\n    /** Initial active-slot tool id. Default: `'select'` when it is\n     *  registered, otherwise none — a canvas can run on ambient bindings\n     *  alone. Must be one of the registered tools. Ignored when the consumer\n     *  supplies their own `tools` prop. */\n    initialActiveTool?: string;\n\n    /** Always-on entries to register alongside the internal tools — every one\n     *  a `SurfaceContribution`, whose views, deps, overlay, bindings, actions\n     *  and `attach` all install from this one list, and uninstall when the\n     *  entry leaves it. A tool is a contribution too, so one can go here. If\n     *  you supply your own `tools` prop, this is ignored — wire `ambient`\n     *  through your own `useTools` call instead. */\n    ambient?: readonly SurfaceContribution[];\n\n    /** What an entry's `requires` does when the running kit does not meet\n     *  it: `'warn'` (the default) logs in development, `'strict'` throws,\n     *  `'off'` skips the check. */\n    versionCheck?: VersionCheck;\n\n    /** Touch and pen long-press: its hold time, its haptic, and the\n     *  feedback shown while it is held. */\n    longPress?: SceneCanvasLongPress;\n\n    /** Configures the `view` preset, and implies it. See {@link SceneCanvasViewport}. */\n    viewport?: SceneCanvasViewport;\n\n    /**\n     * Tune actions on this canvas without restating them, keyed by action id:\n     * `params` every invocation starts from, and `bindings` added beside the\n     * action's own. A tuning applies to whichever descriptor holds the id, a\n     * preset's or a tool's. Pass a stable object; a params thunk is read on\n     * every call. See the core README (\"Tuning an action\").\n     */\n    tune?: ActionTunings;\n\n    /**\n     * Replace, add or mute whole action descriptors. Pass `null` to disable\n     * all defaults. To change a built-in's params or add a key, use `tune`.\n     */\n    actions?: ActionsProp;\n\n    /**\n     * Given a scene node, return a short human-readable \"kind\" label (e.g. `'rectangle'`,\n     * `'sticky note'`), which the kit publishes per id into any surrounding\n     * `<SelectionContextProvider>`. Return `undefined` to skip an entry. When omitted,\n     * containers report `'group'`, poses with a `kind` property report `'path'`, and\n     * everything else is left unlabelled.\n     */\n    describeKind?: (node: Node<TData, TLayer, TPose>) => string | undefined;\n\n    /**\n     * Animator to bind for per-frame redraws. SceneCanvas requests a redraw on every active\n     * animation frame and paints `animator.colorOverrides` onto the scene's nodes: the\n     * kit's path and shape painters apply them, and a custom `drawOne` receives them as\n     * `ctx.vertexColors`.\n     */\n    animator?: Animator;\n\n    /**\n     * Extra views on this canvas: each is a camera over a rect of the same\n     * surface, drawn through one GL context, with input routed to it. The flat\n     * `view` / `onViewChange` props above stay the canvas's own camera — view\n     * zero — and are unaffected by anything declared here.\n     *\n     * Order is paint and hit order, low to high. Each entry is a\n     * `<CanvasView>`; mounting one as a child is the same declaration, and\n     * children land after every entry here.\n     */\n    views?: readonly CanvasViewProps[];\n\n    /**\n     * Children rendered alongside the canvas, inside its input scope (e.g.\n     * shortcuts overlays, probes).\n     */\n    children?: ReactNode;\n\n    /** A yoke to join, from `useYoke()`: canvases on one yoke share the active tool, the gesture\n     *  in flight and history. Omitted, this canvas keeps its own. */\n    yoke?: Yoke;\n\n    /**\n     * Chrome-caps visibility overrides, keyed by chrome id (`selection.outline`,\n     * `selection.rotation-handle`, `gesture.marquee`, …). Each entry is a composable\n     * {@link Condition} built from the `cond()` builder, merged on top of the kit's\n     * `defaultVisibilityRules`. Set an id to `never` to suppress a chrome element\n     * entirely (also unhittable), or to `always` to force-show.\n     */\n    chromeVisibility?: import('features/chrome-caps').VisibilityRules;\n\n    /**\n     * The app's mode registry (`createModeRegistry` in `@weasel-js/modes`).\n     * The canvas reads the active mode from it to gate chrome, tool\n     * activation and the dispatcher's eligibility filter, repaints when it\n     * switches, and hands every registered mode to the dev-time route-conflict\n     * check. Omitted, the canvas behaves as the kit's normal mode and nothing\n     * revokes anchor editing.\n     */\n    modes?: ModeRegistry;\n\n    /** Hands which path is being anchor-edited to the host. See {@link PathEditHost}. */\n    pathEdit?: PathEditHost;\n    /** A path to open in anchor edit as the canvas mounts, with anchors selected. Read once. */\n    defaultPathEdit?: PathEditOpening;\n\n    /**\n     * Override detected device facts. Merged over what `matchMedia` reports;\n     * `targetScale` is re-derived from the merged `coarsePointer` unless you\n     * override it explicitly.\n     */\n    device?: Partial<DeviceProfile>;\n\n    /**\n     * Live focus getter for chrome-caps' `focused` ctx field, for visibility rules that\n     * read the `focused` atom (the kit's default `selection.rotation-handle` rule does).\n     * Omit to default `focused` to `true`.\n     */\n    getFocused?: () => boolean;\n\n    /** Custom shader programs to compile on the renderer. See `CanvasProps.shaders`. */\n    shaders?: ShaderProgramHandle[];\n\n    /** Flatness tolerance for curve tessellation. See `CanvasProps.flattenTolerance`. */\n    flattenTolerance?: FlattenTolerance;\n\n    /** Fill for the full canvas behind the scene, drawn as a screen-space layer slotted\n     *  before `'scene'` — independent of pan / zoom. */\n    backgroundFill?: Paint;\n    /** Dev HUD: a fixed-position widget showing live cursor coords in both viewport\n     *  (client) and canvas (world) frames. */\n    cursorCoordsHud?: boolean;\n    /** Dev HUD: a fixed-position widget listing the ids `pickEvery(world)` returns under\n     *  the cursor. */\n    pickHud?: boolean;\n    /**\n     * The debug overlay: `<Canvas debug>`'s config, plus `slops: true` for\n     * translucent halos at every affordance hit zone. `false` turns it off;\n     * absent reads `?debug=…` from the URL, as `<Canvas>` does.\n     */\n    debug?: (DebugConfig & { slops?: boolean }) | false;\n    /**\n     * Dev HUD: when true (or object), mounts a fixed-position widget below\n     * the pick HUD showing the active modality mode, active-slot tool, and\n     * hotkey stack. Pass `{ modeId }` to populate the mode line.\n     */\n    modalityHud?: boolean | { modeId?: string };\n\n    /**\n     * Per-id alpha multiplier for the scene-render slot: each node's draw output is wrapped\n     * in a group with the returned alpha, and 1 emits no wrapper. Typical use: dimming\n     * non-active nodes during a mode transition.\n     */\n    alphaFor?: (id: string) => number;\n\n    /**\n     * Show or hide render layers in this canvas's own view, by id — the map\n     * `<Canvas>` takes. Each scene layer paints as its own render layer, keyed\n     * `scene:<layerId>`, so `{ 'scene:guides': false }` hides one scene layer\n     * here and nowhere else.\n     *\n     * A layer hidden this way is gone from this view: it does not paint, and a\n     * click, a marquee or Cmd+A here passes over it. Another view of the same\n     * scene — a `<CanvasView>`, a second canvas, a minimap — still shows it and\n     * can still take it. It applies on top of the scene's own\n     * `LayerRecord.visible` and cannot show a layer the scene hides.\n     */\n    layerVisibility?: Record<string, boolean>;\n\n    /**\n     * Draw order for this view, by render-layer id, bottom first. A listed\n     * order is the whole list: a scene layer left out of it is neither painted\n     * nor picked here. See `CanvasProps.layerOrder`.\n     */\n    layerOrder?: string[];\n  } & SceneCanvasPointerProps;\n"],"mappings":";;;;;;;;AAsDA,IAAa,sBAAsB;;;AAkCnC,IAAa,mBAA6C;CAAC;CAAU;CAAQ,GAAG;CAAiB;CAAS;CAAQ;AAAQ"}

package/dist/canvas/SceneCanvas/scenePointQuery.js

@@ -0,0 +1,58 @@
+import { toPlane } from "../../core/viewport/parallax.js";
+import { findShapeInk, shapeCoversPoint } from "../NodeShape.js";
+import { poseContains, poseContainsRotated } from "./poseGeometry.js";
+import { applyToPoint, meanScale, pathContainsPoint } from "@weasel-js/geom";
+
+//#region src/canvas/SceneCanvas/scenePointQuery.ts
+/** The point query `<SceneCanvas>`'s default pick asks: a world point with
+*  `pickTolerancePx` of screen slop, refined to the painter's ink when
+*  `shapePicking` is on. */
+function scenePointQuery(d, shapePicking, pickTolerancePx) {
+	const pointQuery = (px, py, s) => {
+		const scale = meanScale(s);
+		const tolerance = {
+			px: pickTolerancePx,
+			scale: s
+		};
+		return {
+			hits: (n, pose, derived) => {
+				const ink = shapePicking ? findShapeInk(n, pose, { scale }) : null;
+				const slop = {
+					...tolerance,
+					px: tolerance.px + (ink?.outsetPx ?? 0),
+					reach: ink?.outset ?? 0
+				};
+				if (!(derived ? poseContains(derived, px, py, slop, d) : poseContainsRotated(pose, px, py, slop, d))) return false;
+				return !shapePicking || shapeCoversPoint(n, pose, px, py, {
+					tolerance,
+					scale,
+					derivedPath: derived
+				});
+			},
+			clipAdmits: (clip) => pathContainsPoint(clip, px, py),
+			inPlane: (m) => {
+				const p = toPlane(m, {
+					x: px,
+					y: py
+				});
+				return pointQuery(p.x, p.y, {
+					x: s.x / m.scale.x,
+					y: s.y / m.scale.y
+				});
+			},
+			inCopy: (m) => {
+				const [x, y] = applyToPoint(m, px, py);
+				const k = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
+				return pointQuery(x, y, {
+					x: s.x / k,
+					y: s.y / k
+				});
+			}
+		};
+	};
+	return pointQuery;
+}
+
+//#endregion
+export { scenePointQuery };
+//# sourceMappingURL=scenePointQuery.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scenePointQuery.js","names":[],"sources":["../../../src/canvas/SceneCanvas/scenePointQuery.ts"],"sourcesContent":["import { applyToPoint, meanScale, pathContainsPoint } from '@weasel-js/geom';\nimport type { PickQuery } from 'canvas/pickWalk';\nimport { findShapeInk, shapeCoversPoint } from 'canvas/NodeShape';\nimport { toPlane } from 'core/viewport/parallax';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { poseContains, poseContainsRotated } from './poseGeometry';\n\n/** The point query `<SceneCanvas>`'s default pick asks: a world point with\n *  `pickTolerancePx` of screen slop, refined to the painter's ink when\n *  `shapePicking` is on. */\nexport function scenePointQuery<TPose>(\n  d: PoseDescriptor<unknown>,\n  shapePicking: boolean,\n  pickTolerancePx: number,\n): (px: number, py: number, s: { x: number; y: number }) => PickQuery<TPose> {\n  // `s` makes the slop a screen distance, so the grab zone stays the same\n  // apparent thickness at any zoom and on every axis. A `{ px }` stroke's\n  // reach is on screen too, and joins the slop there.\n  const pointQuery = (px: number, py: number, s: { x: number; y: number }): PickQuery<TPose> => {\n    const scale = meanScale(s);\n    const tolerance = { px: pickTolerancePx, scale: s };\n    return {\n      hits: (n, pose, derived) => {\n        // The pre-filter has to be at least as generous as the refinement\n        // that follows it, or it rejects points the refinement would have\n        // claimed. A stroke reaches past the pose box by `outset` — a whole\n        // stroke width for an outer align — on top of the pointer slop.\n        const ink = shapePicking ? findShapeInk(n as never, pose, { scale }) : null;\n        // A derived node's pose is a placeholder — typically zero-sized at\n        // the origin — so its own box rejects every point the path covers.\n        // The path is the region to test instead, and `poseContains` already\n        // reads a path-like pose as one.\n        const slop = { ...tolerance, px: tolerance.px + (ink?.outsetPx ?? 0), reach: ink?.outset ?? 0 };\n        const admitted = derived\n          ? poseContains(derived as never, px, py, slop, d as PoseDescriptor<unknown>)\n          : poseContainsRotated(pose, px, py, slop, d as PoseDescriptor<unknown>);\n        if (!admitted) return false;\n        // `shapeCoversPoint` narrows the rect to the ink the painter actually\n        // lays down (and answers `true` for painters that have no silhouette,\n        // so nothing becomes unpickable).\n        return !shapePicking\n          || shapeCoversPoint(n as never, pose, px, py, {\n            tolerance, scale, derivedPath: derived,\n          });\n      },\n      clipAdmits: (clip) => pathContainsPoint(clip, px, py),\n      inPlane: (m) => {\n        const p = toPlane(m, { x: px, y: py });\n        return pointQuery(p.x, p.y, { x: s.x / m.scale.x, y: s.y / m.scale.y });\n      },\n      inCopy: (m) => {\n        const [x, y] = applyToPoint(m, px, py);\n        const k = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));\n        return pointQuery(x, y, { x: s.x / k, y: s.y / k });\n      },\n    };\n  };\n  return pointQuery;\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,gBACd,GACA,cACA,iBAC2E;CAI3E,MAAM,cAAc,IAAY,IAAY,MAAkD;EAC5F,MAAM,QAAQ,UAAU,CAAC;EACzB,MAAM,YAAY;GAAE,IAAI;GAAiB,OAAO;EAAE;EAClD,OAAO;GACL,OAAO,GAAG,MAAM,YAAY;IAK1B,MAAM,MAAM,eAAe,aAAa,GAAY,MAAM,EAAE,MAAM,CAAC,IAAI;IAKvE,MAAM,OAAO;KAAE,GAAG;KAAW,IAAI,UAAU,MAAM,KAAK,YAAY;KAAI,OAAO,KAAK,UAAU;IAAE;IAI9F,IAAI,EAHa,UACb,aAAa,SAAkB,IAAI,IAAI,MAAM,CAA4B,IACzE,oBAAoB,MAAM,IAAI,IAAI,MAAM,CAA4B,IACzD,OAAO;IAItB,OAAO,CAAC,gBACH,iBAAiB,GAAY,MAAM,IAAI,IAAI;KAC5C;KAAW;KAAO,aAAa;IACjC,CAAC;GACL;GACA,aAAa,SAAS,kBAAkB,MAAM,IAAI,EAAE;GACpD,UAAU,MAAM;IACd,MAAM,IAAI,QAAQ,GAAG;KAAE,GAAG;KAAI,GAAG;IAAG,CAAC;IACrC,OAAO,WAAW,EAAE,GAAG,EAAE,GAAG;KAAE,GAAG,EAAE,IAAI,EAAE,MAAM;KAAG,GAAG,EAAE,IAAI,EAAE,MAAM;IAAE,CAAC;GACxE;GACA,SAAS,MAAM;IACb,MAAM,CAAC,GAAG,KAAK,aAAa,GAAG,IAAI,EAAE;IACrC,MAAM,IAAI,KAAK,KAAK,KAAK,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC;IACvD,OAAO,WAAW,GAAG,GAAG;KAAE,GAAG,EAAE,IAAI;KAAG,GAAG,EAAE,IAAI;IAAE,CAAC;GACpD;EACF;CACF;CACA,OAAO;AACT"}

package/dist/canvas/SceneCanvas/shapeGeneratorProperties.js

@@ -0,0 +1,59 @@
+import { SHAPE_COUNT_RANGE, STAR_RATIO_RANGE } from "../../features/paths/shapeGenerator.js";
+import { decimal } from "@weasel-js/quantity";
+
+//#region src/canvas/SceneCanvas/shapeGeneratorProperties.ts
+var WHOLE = decimal({
+	maxPlaces: 2,
+	grouping: false
+});
+/**
+* The rows that edit a polygon's or a star's `data.generator`, each shown only
+* on a node holding that kind's generator. A write to one regenerates the
+* shape through the entry's `settle` (`settleShapeGenerator`).
+*/
+var SHAPE_GENERATOR_SECTIONS = {
+	polygon: {
+		name: "Polygon",
+		showIf: { path: "data.generator.sides" },
+		members: { "data.generator.sides": {
+			kind: "number",
+			display: WHOLE,
+			name: "Sides",
+			description: "Number of sides.",
+			default: 6,
+			min: SHAPE_COUNT_RANGE.min,
+			max: SHAPE_COUNT_RANGE.max,
+			step: 1
+		} }
+	},
+	star: {
+		name: "Star",
+		showIf: { path: "data.generator.points" },
+		members: {
+			"data.generator.points": {
+				kind: "number",
+				display: WHOLE,
+				name: "Points",
+				description: "Number of points.",
+				default: 5,
+				min: SHAPE_COUNT_RANGE.min,
+				max: SHAPE_COUNT_RANGE.max,
+				step: 1
+			},
+			"data.generator.innerRadiusRatio": {
+				kind: "number",
+				name: "Inner",
+				description: "Inner radius as a fraction of the outer one.",
+				default: .5,
+				min: STAR_RATIO_RANGE.min,
+				max: STAR_RATIO_RANGE.max,
+				step: .01,
+				control: "slider"
+			}
+		}
+	}
+};
+
+//#endregion
+export { SHAPE_GENERATOR_SECTIONS };
+//# sourceMappingURL=shapeGeneratorProperties.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shapeGeneratorProperties.js","names":[],"sources":["../../../src/canvas/SceneCanvas/shapeGeneratorProperties.ts"],"sourcesContent":["import type { PrefSection } from '@weasel-js/prefs';\nimport { decimal } from '@weasel-js/quantity';\nimport { SHAPE_COUNT_RANGE, STAR_RATIO_RANGE } from 'features/paths/shapeGenerator';\n\nconst WHOLE = decimal({ maxPlaces: 2, grouping: false });\n\n/**\n * The rows that edit a polygon's or a star's `data.generator`, each shown only\n * on a node holding that kind's generator. A write to one regenerates the\n * shape through the entry's `settle` (`settleShapeGenerator`).\n */\nexport const SHAPE_GENERATOR_SECTIONS: Record<string, PrefSection> = {\n  polygon: {\n    name: 'Polygon',\n    showIf: { path: 'data.generator.sides' },\n    members: {\n      'data.generator.sides': {\n        kind: 'number', display: WHOLE, name: 'Sides', description: 'Number of sides.',\n        default: 6, min: SHAPE_COUNT_RANGE.min, max: SHAPE_COUNT_RANGE.max, step: 1,\n      },\n    },\n  },\n  star: {\n    name: 'Star',\n    showIf: { path: 'data.generator.points' },\n    members: {\n      'data.generator.points': {\n        kind: 'number', display: WHOLE, name: 'Points', description: 'Number of points.',\n        default: 5, min: SHAPE_COUNT_RANGE.min, max: SHAPE_COUNT_RANGE.max, step: 1,\n      },\n      'data.generator.innerRadiusRatio': {\n        kind: 'number', name: 'Inner', description: 'Inner radius as a fraction of the outer one.',\n        default: 0.5, min: STAR_RATIO_RANGE.min, max: STAR_RATIO_RANGE.max, step: 0.01, control: 'slider',\n      },\n    },\n  },\n};\n"],"mappings":";;;;AAIA,IAAM,QAAQ,QAAQ;CAAE,WAAW;CAAG,UAAU;AAAM,CAAC;;;;;;AAOvD,IAAa,2BAAwD;CACnE,SAAS;EACP,MAAM;EACN,QAAQ,EAAE,MAAM,uBAAuB;EACvC,SAAS,EACP,wBAAwB;GACtB,MAAM;GAAU,SAAS;GAAO,MAAM;GAAS,aAAa;GAC5D,SAAS;GAAG,KAAK,kBAAkB;GAAK,KAAK,kBAAkB;GAAK,MAAM;EAC5E,EACF;CACF;CACA,MAAM;EACJ,MAAM;EACN,QAAQ,EAAE,MAAM,wBAAwB;EACxC,SAAS;GACP,yBAAyB;IACvB,MAAM;IAAU,SAAS;IAAO,MAAM;IAAU,aAAa;IAC7D,SAAS;IAAG,KAAK,kBAAkB;IAAK,KAAK,kBAAkB;IAAK,MAAM;GAC5E;GACA,mCAAmC;IACjC,MAAM;IAAU,MAAM;IAAS,aAAa;IAC5C,SAAS;IAAK,KAAK,iBAAiB;IAAK,KAAK,iBAAiB;IAAK,MAAM;IAAM,SAAS;GAC3F;EACF;CACF;AACF"}

package/dist/canvas/SceneCanvas/toolRegistry.js

@@ -1,23 +1,38 @@
-import { IS_DEV as e } from "./isDev.js";
-import { featureToolIds as t } from "./features.js";
-import { BUILTIN_TOOL_IDS as n } from "./props.js";
+import { presetBuiltinTools, presetOwnTools } from "./features.js";
+import { BUILTIN_TOOL_IDS } from "./props.js";
+import { isDev } from "@weasel-js/react";
+
 //#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]);
+/**
+* The tool registry a canvas mounts when it is not handed a whole `ToolsApi`.
+*
+* Built-ins come first, in `BUILTIN_TOOL_IDS` order whatever order they were
+* asked for in, then the presets' own tools in preset order; a patch tool
+* replaces a mounted one where it stands, and any other is appended in patch
+* order. That order is the palette's.
+*/
+function resolveToolRegistry(args) {
+	const { builtins, defaultTools = [], enabled, patch, dev = isDev() } = args;
+	const registry = {};
+	const preset = presetBuiltinTools(enabled);
+	for (const id of BUILTIN_TOOL_IDS) {
+		const patched = patch?.[id];
+		if (patched === false) continue;
+		if (patched === true || defaultTools.includes(id) || preset.has(id)) registry[id] = builtins[id];
 	}
-	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`);
+	for (const [id, tool] of Object.entries(presetOwnTools(enabled))) if (patch?.[id] !== false) registry[id] = tool;
+	for (const [id, value] of Object.entries(patch ?? {})) {
+		if (value === false) continue;
+		if (value === true) {
+			if (dev && !BUILTIN_TOOL_IDS.includes(id)) console.warn(`[SceneCanvas] tools.${id}=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;
+		if (dev && id in registry) console.warn(`[SceneCanvas] tools prop overrides bundled "${id}" tool`);
+		registry[id] = value;
 	}
-	return l;
+	return registry;
 }
-//#endregion
-export { r as resolveToolRegistry };
 
+//#endregion
+export { resolveToolRegistry };
 //# sourceMappingURL=toolRegistry.js.map

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

@@ -1 +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"}
+{"version":3,"file":"toolRegistry.js","names":[],"sources":["../../../src/canvas/SceneCanvas/toolRegistry.ts"],"sourcesContent":["import type { Tool } from 'tools/overlayBinding';\nimport { presetBuiltinTools, presetOwnTools, type EnabledPresets } from './features';\nimport { isDev } from '@weasel-js/react';\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 it names. */\n  enabled: EnabledPresets;\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, then the presets' own tools in preset order; a patch tool\n * replaces a mounted one where it stands, and any other is appended in patch\n * order. That order is the palette's.\n */\nexport function resolveToolRegistry(args: ResolveToolRegistryArgs): Record<string, Tool> {\n  const { builtins, defaultTools = [], enabled, patch, dev = isDev() } = args;\n  const registry: Record<string, Tool> = {};\n  const preset = presetBuiltinTools(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, tool] of Object.entries(presetOwnTools(enabled))) {\n    if (patch?.[id] !== false) registry[id] = tool;\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,SAAgB,oBAAoB,MAAqD;CACvF,MAAM,EAAE,UAAU,eAAe,CAAC,GAAG,SAAS,OAAO,MAAM,MAAM,MAAM;CACvE,MAAM,WAAiC,CAAC;CACxC,MAAM,SAAS,mBAAmB,OAAO;CACzC,KAAK,MAAM,MAAM,kBAAkB;EACjC,MAAM,UAAU,QAAQ;EACxB,IAAI,YAAY,OAAO;EAEvB,IADc,YAAY,QAAQ,aAAa,SAAS,EAAE,KAAK,OAAO,IAAI,EAAE,GACjE,SAAS,MAAM,SAAS;CACrC;CACA,KAAK,MAAM,CAAC,IAAI,SAAS,OAAO,QAAQ,eAAe,OAAO,CAAC,GAC7D,IAAI,QAAQ,QAAQ,OAAO,SAAS,MAAM;CAE5C,KAAK,MAAM,CAAC,IAAI,UAAU,OAAO,QAAQ,SAAS,CAAC,CAAC,GAAG;EACrD,IAAI,UAAU,OAAO;EACrB,IAAI,UAAU,MAAM;GAClB,IAAI,OAAO,CAAE,iBAAuC,SAAS,EAAE,GAC7D,QAAQ,KAAK,uBAAuB,GAAG,2CAA2C;GAEpF;EACF;EACA,IAAI,OAAO,MAAM,UACf,QAAQ,KAAK,+CAA+C,GAAG,OAAO;EAExE,SAAS,MAAM;CACjB;CACA,OAAO;AACT"}

package/dist/canvas/SceneCanvas/useActionTunings.js

@@ -0,0 +1,20 @@
+import { useEffect } from "react";
+import { useActionsRegistry } from "@weasel-js/routing/react";
+
+//#region src/canvas/SceneCanvas/useActionTunings.ts
+/** Hold `tune`'s tunings on the registry in scope for as long as the object
+*  is the same one. */
+function useActionTunings(tune) {
+	const reg = useActionsRegistry();
+	useEffect(() => {
+		if (!reg || !tune) return;
+		const releases = Object.entries(tune).flatMap(([id, t]) => t ? [reg.tune(id, t)] : []);
+		return () => {
+			for (const release of releases) release();
+		};
+	}, [reg, tune]);
+}
+
+//#endregion
+export { useActionTunings };
+//# sourceMappingURL=useActionTunings.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useActionTunings.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useActionTunings.ts"],"sourcesContent":["import { useEffect } from 'react';\nimport type { ActionTuning, ActionTunings } from '@weasel-js/routing';\nimport { useActionsRegistry } from '@weasel-js/routing/react';\n\n/** Hold `tune`'s tunings on the registry in scope for as long as the object\n *  is the same one. */\nexport function useActionTunings(tune: ActionTunings | undefined): void {\n  const reg = useActionsRegistry();\n  useEffect(() => {\n    if (!reg || !tune) return;\n    const releases = Object.entries(tune).flatMap(([id, t]) => (t ? [reg.tune(id, t as ActionTuning)] : []));\n    return () => { for (const release of releases) release(); };\n  }, [reg, tune]);\n}\n"],"mappings":";;;;;;AAMA,SAAgB,iBAAiB,MAAuC;CACtE,MAAM,MAAM,mBAAmB;CAC/B,gBAAgB;EACd,IAAI,CAAC,OAAO,CAAC,MAAM;EACnB,MAAM,WAAW,OAAO,QAAQ,IAAI,CAAC,CAAC,SAAS,CAAC,IAAI,OAAQ,IAAI,CAAC,IAAI,KAAK,IAAI,CAAiB,CAAC,IAAI,CAAC,CAAE;EACvG,aAAa;GAAE,KAAK,MAAM,WAAW,UAAU,QAAQ;EAAG;CAC5D,GAAG,CAAC,KAAK,IAAI,CAAC;AAChB"}

package/dist/canvas/SceneCanvas/useActionsPropResolver.js

@@ -1,53 +1,86 @@
-import { useEffect as e } from "react";
-import { useLatest as t } from "@weasel-js/react";
-import { useActionsRegistry as n } from "@weasel-js/routing/react";
+import { useEffect } from "react";
+import { useLatest } from "@weasel-js/react";
+import { useActionsRegistry } from "@weasel-js/routing/react";
+
 //#region src/canvas/SceneCanvas/useActionsPropResolver.ts
-function r(r, i) {
-	let a = n(), o = t(r);
-	e(() => {
-		if (!a) return;
-		let e = o.current, t = [];
-		if (e === null) {
-			for (let e of a.list().map((e) => e.id)) t.push(a.mute(e));
+/**
+* Applies the `actions` prop overrides on top of whatever is already
+* registered, so the caller mounts this hook last.
+*
+*   actions === null           → mute every currently-registered action
+*   actions[id] === null       → mute that id
+*   actions[id] = partial      → merge onto the existing descriptor (slot wins
+*                                over entry.id; warns once on mismatch)
+*   actions[id] = full (new)   → register alongside defaults
+*
+* `null` mutes rather than unregisters: the opt-out belongs to this canvas, so
+* a sibling sharing the registry keeps the action and this canvas's unmount
+* gives it back.
+*/
+/** `rev` re-applies the overrides when it changes — pass whatever changes when
+*  the set they sit on is re-registered. */
+function useActionsPropResolver(actions, rev) {
+	const reg = useActionsRegistry();
+	const actionsRef = useLatest(actions);
+	useEffect(() => {
+		if (!reg) return;
+		const prop = actionsRef.current;
+		const unregisters = [];
+		if (prop === null) {
+			for (const id of reg.list().map((a) => a.id)) unregisters.push(reg.mute(id));
 			return () => {
-				for (let e of t) e();
+				for (const u of unregisters) u();
 			};
 		}
-		if (!e) return;
-		let n = /* @__PURE__ */ new Set();
-		for (let [r, i] of Object.entries(e)) {
-			if (i === null) {
-				t.push(a.mute(r));
+		if (!prop) return;
+		const warnedIds = /* @__PURE__ */ new Set();
+		for (const [slotId, entry] of Object.entries(prop)) {
+			if (entry === null) {
+				unregisters.push(reg.mute(slotId));
 				continue;
 			}
-			let e = (e) => typeof e.id == "string" && typeof e.label == "string" && !!e.invoker, o = a.list().find((e) => e.id === r);
-			if (!o) {
-				e(i) ? t.push(a.register(i)) : n.has(r) || (n.add(r), console.warn(`weasel actions resolver: actions["${r}"] is a partial Action but no default with this id exists. Pass a complete {id, label, invoker} descriptor.`));
+			const isFull = (e) => typeof e.id === "string" && typeof e.label === "string" && !!e.invoker;
+			const existing = reg.list().find((a) => a.id === slotId);
+			if (!existing) {
+				if (isFull(entry)) unregisters.push(reg.register(entry));
+				else if (!warnedIds.has(slotId)) {
+					warnedIds.add(slotId);
+					console.warn(`weasel actions resolver: actions["${slotId}"] is a partial Action but no default with this id exists. Pass a complete {id, label, invoker} descriptor.`);
+				}
 				continue;
 			}
-			i.id !== void 0 && i.id !== r && !n.has(`mismatch:${r}`) && (n.add(`mismatch:${r}`), console.warn(`weasel actions resolver: actions["${r}"].id="${i.id}" mismatches the slot key. Ignoring the id field; the action remains at id="${r}".`));
-			let { id: s, ...c } = i, l = {
-				...o,
-				...c
+			if (entry.id !== void 0 && entry.id !== slotId && !warnedIds.has(`mismatch:${slotId}`)) {
+				warnedIds.add(`mismatch:${slotId}`);
+				console.warn(`weasel actions resolver: actions["${slotId}"].id="${entry.id}" mismatches the slot key. Ignoring the id field; the action remains at id="${slotId}".`);
+			}
+			const { id: _drop, ...rest } = entry;
+			const merged = {
+				...existing,
+				...rest
 			};
-			t.push(a.register(l));
+			unregisters.push(reg.register(merged));
 		}
 		return () => {
-			for (let e of t) e();
+			for (const u of unregisters) u();
 		};
 	}, [
-		a,
-		r,
-		o,
-		i
+		reg,
+		actions,
+		actionsRef,
+		rev
 	]);
 }
-function i(e, t) {
-	if (e === null) return null;
-	let n = { ...e ?? {} };
-	return t in n || (n[t] = null), n;
+/**
+* `actions` with `id` muted. A caller's own entry for `id` still wins, and
+* `null` (every default muted) is left as it is.
+*/
+function actionsMuting(actions, id) {
+	if (actions === null) return null;
+	const merged = { ...actions ?? {} };
+	if (!(id in merged)) merged[id] = null;
+	return merged;
 }
-//#endregion
-export { i as actionsMuting, r as useActionsPropResolver };
 
+//#endregion
+export { actionsMuting, 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","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"}
+{"version":3,"file":"useActionsPropResolver.js","names":[],"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,SAAgB,uBAAuB,SAAkC,KAAoB;CAC3F,MAAM,MAAM,mBAAmB;CAC/B,MAAM,aAAa,UAAU,OAAO;CAEpC,gBAAgB;EACd,IAAI,CAAC,KAAK;EACV,MAAM,OAAO,WAAW;EAExB,MAAM,cAAiC,CAAC;EAExC,IAAI,SAAS,MAAM;GACjB,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,CAAC,KAAK,MAAM,EAAE,EAAE,GAAG,YAAY,KAAK,IAAI,KAAK,EAAE,CAAC;GAC3E,aAAa;IAAE,KAAK,MAAM,KAAK,aAAa,EAAE;GAAG;EACnD;EAEA,IAAI,CAAC,MAAM;EAEX,MAAM,4BAAY,IAAI,IAAY;EAElC,KAAK,MAAM,CAAC,QAAQ,UAAU,OAAO,QAAQ,IAAI,GAAG;GAClD,IAAI,UAAU,MAAM;IAClB,YAAY,KAAK,IAAI,KAAK,MAAM,CAAC;IACjC;GACF;GAEA,MAAM,UAAU,MACd,OAAO,EAAE,OAAO,YAAY,OAAO,EAAE,UAAU,YAAY,CAAC,CAAC,EAAE;GACjE,MAAM,WAAW,IAAI,KAAK,CAAC,CAAC,MAAM,MAAM,EAAE,OAAO,MAAM;GAEvD,IAAI,CAAC,UAAU;IACb,IAAI,OAAO,KAAK,GACd,YAAY,KAAK,IAAI,SAAS,KAAK,CAAC;SAC/B,IAAI,CAAC,UAAU,IAAI,MAAM,GAAG;KACjC,UAAU,IAAI,MAAM;KACpB,QAAQ,KACN,qCAAqC,OAAO,4GAE9C;IACF;IACA;GACF;GAEA,IAAI,MAAM,OAAO,UAAa,MAAM,OAAO,UAAU,CAAC,UAAU,IAAI,YAAY,QAAQ,GAAG;IACzF,UAAU,IAAI,YAAY,QAAQ;IAClC,QAAQ,KACN,qCAAqC,OAAO,SAAS,MAAM,GAAa,8EACpB,OAAO,GAC7D;GACF;GACA,MAAM,EAAE,IAAI,OAAO,GAAG,SAAS;GAE/B,MAAM,SAAiB;IAAE,GAAG;IAAU,GAAG;GAAK;GAI9C,YAAY,KAAK,IAAI,SAAS,MAAM,CAAC;EACvC;EAEA,aAAa;GAAE,KAAK,MAAM,KAAK,aAAa,EAAE;EAAG;CACnD,GAAG;EAAC;EAAK;EAAS;EAAY;CAAG,CAAC;AACpC;;;;;AAMA,SAAgB,cAAc,SAAkC,IAAyB;CACvF,IAAI,YAAY,MAAM,OAAO;CAC7B,MAAM,SAAS,EAAE,GAAI,WAAW,CAAC,EAAG;CACpC,IAAI,EAAE,MAAM,SAAS,OAAO,MAAM;CAClC,OAAO;AACT"}

package/dist/canvas/SceneCanvas/useBakedScene.js

@@ -0,0 +1,17 @@
+import { isSerializedScene } from "../../core/scene/serialization.js";
+import { sceneFromJSON } from "../../core/scene/scene.js";
+import { useState } from "react";
+
+//#region src/canvas/SceneCanvas/useBakedScene.ts
+/**
+* `scene` accepts either a live `Scene` or a `SerializedScene` JSON object. JSON is baked
+* once; later prop changes are ignored (use a `key` on `<SceneCanvas>` to force a fresh canvas).
+*/
+function useBakedScene(sceneInput) {
+	const [bakedScene] = useState(() => isSerializedScene(sceneInput) ? sceneFromJSON(sceneInput, {}) : null);
+	return bakedScene ?? sceneInput;
+}
+
+//#endregion
+export { useBakedScene };
+//# sourceMappingURL=useBakedScene.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useBakedScene.js","names":[],"sources":["../../../src/canvas/SceneCanvas/useBakedScene.ts"],"sourcesContent":["import { useState } from 'react';\nimport { sceneFromJSON } from 'core/scene/scene';\nimport { isSerializedScene } from 'core/scene/serialization';\nimport type { Scene } from 'core/scene/types';\nimport type { SceneCanvasProps } from './props';\n\n/**\n * `scene` accepts either a live `Scene` or a `SerializedScene` JSON object. JSON is baked\n * once; later prop changes are ignored (use a `key` on `<SceneCanvas>` to force a fresh canvas).\n */\nexport function useBakedScene<TData, TLayer extends string, TPose>(\n  sceneInput: SceneCanvasProps<TData, TLayer, TPose>['scene'],\n): Scene<TData, TLayer, TPose> {\n  const [bakedScene] = useState<Scene<TData, TLayer, TPose> | null>(\n    () => (isSerializedScene<TData, TLayer, TPose>(sceneInput) ? sceneFromJSON(sceneInput, {}) : null),\n  );\n  return bakedScene ?? (sceneInput as Scene<TData, TLayer, TPose>);\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,cACd,YAC6B;CAC7B,MAAM,CAAC,cAAc,eACZ,kBAAwC,UAAU,IAAI,cAAc,YAAY,CAAC,CAAC,IAAI,IAC/F;CACA,OAAO,cAAe;AACxB"}