@weasel-js/core 1.6.1 → 1.7.1

package/dist/canvas/Canvas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Canvas.js","names":["clientToWorldHelper","_Fragment","alwaysVisible","buildSceneLayer","toPose","cfg","adapter","obj","drawOne","postProcess","finish","cullDrawCommands","cmds","viewToMat3","view","dims","paintBounds","culledIn","paintMissesView","slot","hidden","hideIds","a","filteredDrawOne","pose","v","debugSink","b","boundsOfFn","ox","oy","wrapNodeOutput","hierarchicalAdapter","id","tree","buildSceneTree","objects","children","culled","wrapped","cmd","buildSceneLayers","sceneLayerIds","l","sceneLayerKey","resolveToolsCursor","tools","tool","resolveCursorTier","ctxBase","base","NO_LAYER_VISIBILITY","toWorld","override","canvas","clientX","clientY","clientToWorld","CanvasInner","dprProp","adapterProp","layersMap","geometry","AUTO_POSE_DESCRIPTOR","viewProp","debugProp","props","debugKey","resolvedDebugConfig","useMemo","parseDebugFlags","createDebugSink","committedDebugSinkRef","useLatest","getDebug","useCallback","canvasRef","useRef","ownCanvasRef","setOwnCanvas","el","detached","paintInto","inputElement","paintTarget","paintTargetRef","paintRect","paintRectRef","helpersForLayersRef","dimsRef","getIsVisibleRef","getIsVisible","layerVisibilityRef","layerVisibility","layerOrderRef","layerOrder","paintRef","useFrameLoop","contentVersionRef","contentVersion","paintedVersionRef","getPaintedVersion","extrasVersion","setExtrasVersion","useState","extrasRef","registerLayer","layer","n","hitTestExtrasIn","layers","isVisible","visibility","order","only","isLayerPainted","hit","worldX","worldY","data","hitTestExtras","frame","viewRef","normalizeView","defaultView","isControlled","controlledView","viewSubsRef","onViewChangeRef","onViewChange","viewBoundsRef","viewBounds","isControlledRef","controlledWarnedRef","setView","resolved","next","bounds","clamped","clampView","forward","fn","requestRedraw","getView","subscribeView","element","registerMountedCanvas","paintedCursor","createPaintedCursorState","paintedCursorLayer","createPaintedCursorLayer","getSurfaceRect","origin","w","h","ref","subscribeFrame","subscribeBeforePaint","lease","useCanvasRenderer","layerCacheRef","viewRegistry","useOptionalViewRegistry","noopAdapter","effectiveAdapter","noopSelection","effectiveSelection","selection","effectiveAdapterRef","clientToWorldRef","toolsCtxBase","c","rect","ops","label","pickEveryRef","pickEvery","pickBestRef","pickBest","stablePickEveryForHud","pe","raw","wx","wy","stablePickBestForHud","selectedIdsForWiring","viewHelpers","viewChromeState","useViewHelpers","surfaceHelpers","helpersForLayers","pointerDownRef","handlePointerDown","autoFocusOnPointerDown","handlePointerMove","layersWithDebug","handlePointerLeave","handlePointerUp","backgroundLayer","backgroundFill","standardLayers","grid","isCustomEntry","cellHighlight","sceneCfg","sceneLayers","effectiveBoundsOf","ids","aggregatePreviewIds","extra","previewExtraRef","selSlot","createSelectionOverlayLayer","out","composeOrderedLayers","decorationLayer","placeToolOverlays","viewRegistryVersion","useSyncExternalStore","cb","surfaceLayersRef","r","x","y","withViews","createDebugOverlayLayer","useEffect","redraw","offs","off","useRedrawOn","redrawOn","shaderIdKey","shaders","paintInputs","paintInputsRef","helpersRef","debugSinkRef","paint","paintLayers","sink","dprIn","vis","paintFlattenTolerance","groups","paintShaders","i","renderer","spans","frameStats","paintT0","commands","drawLayers","frameStatsOf","useInsertionEffect","useLayoutEffect","width","height","flattenTolerance","layerGroups","syncPaint","layerCache","viewSubs","seen","getProgramSource","programSourceRegistry","now","changed","src","toolsCursorTier","toolsCursor","effectiveStyle","style","toolsPainted","toolsPaintedKey","layersForMoveRef","onDown","onMove","e","onUp","onLeave","onMenu","huds","Fragment","cursorCoordsHud","CursorCoordsHud","pickHud","PickHud","modalityHud","ModalityHud","Canvas","forwardRef"],"sources":["../../src/canvas/Canvas.tsx"],"sourcesContent":["/**\n * Low-level WebGL surface + viewport + pointer routing primitive.\n * Composes layers into a single GL render pass, applies a view transform,\n * routes pointer/keyboard events to the supplied `tools.dispatcher`, and\n * exposes scene-agnostic slot props (`backgroundFill`, `cursorCoordsHud`,\n * `pickHud`).\n *\n * Canvas owns NO scene-shaped state — selection, picking, kind registry,\n * scene-aware overlays — all live in `<SceneCanvas>` (the public consumer\n * entry point) which wraps `<Canvas>`.\n *\n * The `layers` prop is a map keyed by slot name. Standard slots render at a\n * canonical position; custom entries (any other key, value carrying `.layer`)\n * insert at `after`/`before` an existing slot, defaulting to the top.\n *\n * @internal\n * @deprecated Bare `<Canvas>` is not a supported consumer surface.\n *   Use `<SceneCanvas>` instead. Re-promotion is tracked in\n *   `docs/TODO.md`.\n */\n\nimport { forwardRef, useCallback, useEffect, useImperativeHandle, useInsertionEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react';\nimport type React from 'react';\nimport type { FillStyle } from '@weasel-js/paint';\nimport { composeOrderedLayers, placeToolOverlays } from './layerOrder';\nimport { sceneLayerKey } from './sceneLayerPaint';\nimport {\n  STANDARD_SLOTS,\n  isCustomEntry,\n  type CustomLayerEntry,\n} from './layerSlots';\nexport { STANDARD_SLOTS, isCustomEntry } from './layerSlots';\nexport type { StandardSlotName, CustomLayerEntry } from './layerSlots';\nimport type { CanvasExtensionApi } from './canvasExtension';\nimport { registerMountedCanvas } from './mountedCanvases';\nimport type { ToolsApi } from '../tools/overlayBinding';\nimport { aggregatePreviewIds } from './toolPreview';\nimport type { GestureSource } from './gestureBounds';\nimport { useViewHelpers } from './useViewHelpers';\nimport { useOptionalViewRegistry } from './viewRegistry';\nimport { useFrameLoop } from './useFrameLoop';\nimport { useRedrawOn } from './useRedrawOn';\nimport type { CanvasHelpers, CanvasSurfaceHelpers } from './useViewHelpers';\n\nimport type { ToolCtx } from '@weasel-js/routing';\nimport { useLatest } from '@weasel-js/react';\nimport type { Op } from 'core/ops/types';\nimport type { Path } from '@weasel-js/geom';\nimport { dispatchApplyBatch } from 'core/applyOps';\nimport { normalizeView, type View } from 'core/viewport/view';\nimport type { NodePaintCtx } from './NodeShape';\nimport { clampView } from 'core/viewport/clampView';\nimport { clientToWorld as clientToWorldHelper } from 'core/viewport/clientToWorld';\nimport {\n  drawLayers, isLayerPainted,\n  type Dims, type LayerCommandCache, type LayerDrawSpan, type LayerGroup, type RedrawSource, type RenderLayer,\n} from 'core/layers/render';\nimport { viewToMat3, cullDrawCommands, type DrawCommand, type ShaderProgramHandle } from '../renderer';\nimport { useCanvasRenderer } from './useCanvasRenderer';\nimport { getProgramSource, programSourceRegistry } from '../renderer/shaders/registerProgram';\nimport {\n  type SelectionApi,\n} from 'core/selection/useSelection';\nimport type {\n  MoveAdapter,\n  ResizeAdapter,\n  RotateAdapter,\n} from 'core/adapters/types';\nimport {\n  createSelectionOverlayLayer,\n  type SelectionOverlayLayerOpts,\n} from 'features/selection/overlay';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { CanvasDebugSink, DebugConfig, DebugSink } from '../debug/types';\nimport { parseDebugFlags } from '../debug/parseDebugFlags';\nimport { createDebugSink } from '../debug/createDebugSink';\nimport { createDebugOverlayLayer } from '../debug/createDebugOverlayLayer';\nimport { frameStatsOf } from '../debug/frameStats';\n\nconst alwaysVisible = (_id: string): boolean => true;\nimport { buildSceneTree, type HierarchicalAdapter } from './buildSceneTree';\nimport { resolveCursorTier } from '@weasel-js/cursor';\nimport type { ResolvedCursor } from '@weasel-js/cursor';\nimport { createPaintedCursorState } from '@weasel-js/cursor';\nimport type { PaintedCursor, PaintedCursorState } from '@weasel-js/cursor';\nimport { createPaintedCursorLayer } from '../features/cursor/paintedCursorLayer';\n\n/**\n * The scene-tree reading methods Canvas feature-detects at draw time, as an\n * *optional* mixin. A `SceneCanvasAdapter` supplies them; flat / bare-Canvas\n * adapters don't. `getPose` already lives on the base move adapter, so only the\n * three tree-walk methods are added here.\n */\ntype OptionalSceneHierarchy<TNode, TPose> = Partial<\n  Pick<HierarchicalAdapter<TNode, TPose>, 'getLayers' | 'getNode' | 'getChildren'>\n>;\n\n/** The full adapter shape Canvas threads through layers + gesture hooks: the\n *  move/resize/rotate intersection plus the optional scene-tree methods. */\ntype CanvasAdapter<TNode extends { id: string }, TPose> = MoveAdapter<TNode, TPose> &\n  ResizeAdapter<TNode, TPose> &\n  RotateAdapter<TNode, TPose> &\n  OptionalSceneHierarchy<TNode, TPose>;\nimport { wrapNodeOutput } from './wrapNodeOutput';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { paintMissesView, type PaintBoundsFn } from './paintCull';\nimport { CursorCoordsHud } from './CursorCoordsHud';\nimport { PickHud } from './PickHud';\nimport { ModalityHud } from './ModalityHud';\n\n\n\n/** Scene slot config — describes how to draw one object with its effective pose. */\nexport interface SceneSlotConfig<TNode extends { id: string }, TPose> {\n  /** Override `adapter.getNodes()` for the object iteration. */\n  objects?: TNode[];\n  /** Project an object to its committed pose. Defaults to `adapter.getPose(obj.id)`. */\n  toPose?: (obj: TNode) => TPose;\n  /** Draw a single object as a `DrawCommand` tree. `ctx` carries what only a\n   *  scene-aware caller can supply (a node's derived path); `<SceneCanvas>`\n   *  fills it in, bare `<Canvas>` never does. */\n  drawOne: (obj: TNode, pose: TPose, view: View, ctx?: NodePaintCtx) => DrawCommand[];\n  /** The path a container derives from its dependencies' poses, for the clip\n   *  it imposes on its subtree. The other half of what only a scene-aware\n   *  caller can supply — `drawOne`'s `ctx` carries the derived path a node\n   *  *paints*, this one the clip it *imposes*. */\n  derivedPathOf?: (obj: TNode, pose: TPose) => Path | null;\n  /** Default ghost alpha for the move-overlay slot. Default 0.85. */\n  ghostAlpha?: number;\n  /**\n   * Optional per-id alpha multiplier. When supplied, each node's emitted\n   * `DrawCommand[]` is wrapped in a `{ kind: 'group', alpha }` when the\n   * returned value is not 1. The scoping-dim integration supplies this to\n   * dim non-active nodes during a mode transition.\n   *\n   * Defaults to `() => 1` (no effect).\n   */\n  alphaFor?: (id: string) => number;\n  /**\n   * Optional post-processor for the scene slot's emitted commands. Called\n   * with the final world-space `DrawCommand[]` each time a scene canvas\n   * layer draws (after per-node rotation wrapping and `alphaFor`); the\n   * return value replaces the array handed to the renderer. When the scene\n   * slot is split into per-scene-layer canvas layers (`scene:<layerId>`),\n   * it runs once per layer. Identity by default.\n   *\n   * Commands are world-space — `drawLayers` applies the view transform\n   * afterward, so e.g. a `clip` path in a wrapping group is authored in\n   * world coordinates. Note clip nesting is capped at 7 levels; a wrapping\n   * group with `clip` consumes one.\n   *\n   * The move-overlay ghost (drag preview) is not post-processed.\n   */\n  postProcess?: (cmds: DrawCommand[], view: View, dims: Dims) => DrawCommand[];\n  /**\n   * Skip what cannot reach the view. A node `paintBounds` places outside the\n   * `dims` rectangle under `view` is not painted at all; then, after\n   * `postProcess`, `cullDrawCommands` drops any remaining command that cannot\n   * reach it — see there for what it can and cannot bound. So `postProcess`\n   * sees an empty group where a culled node would have painted.\n   *\n   * Off by default because it makes the layer's world-space output depend on\n   * the view: anything that draws this layer once and shows the result under\n   * another view — a cache keyed without `view`, a consumer re-wrapping the\n   * commands — would show the first view's cull.\n   */\n  cull?: boolean;\n  /**\n   * Where `drawOne`'s output for a node can reach, in the frame it paints in\n   * — before the pose rotation the slot wraps it in. `null` for a node it\n   * cannot bound cheaply. Read only under `cull`, which skips `drawOne` for a\n   * node whose box misses the view, so it must enclose everything `drawOne`\n   * paints: a box too small makes a node vanish before it leaves the screen.\n   *\n   * `<SceneCanvas>` supplies `defaultPaintBounds` while `drawOne` is\n   * `defaultDrawOne`. Omit it with any other `drawOne` and culling only\n   * trims commands after painting.\n   */\n  paintBounds?: PaintBoundsFn<TNode, TPose>;\n}\n\n/** Selection-overlay slot config — passed through to `createSelectionOverlayLayer`,\n *  minus the `getSelection`/`getPose` Canvas wires automatically. */\nexport type SelectionOverlaySlotConfig<TPose> = Omit<\n  SelectionOverlayLayerOpts<TPose>,\n  'getSelection' | 'getPose'\n> & {\n  /** Override the auto-wired pose lookup (overlay-aware → adapter fallback). */\n  poseById?: (id: string) => TPose | null;\n};\n\n\n/** Per-slot config union. The key narrows it in practice. */\nexport type StandardSlotConfig<TNode extends { id: string }, TPose> =\n  | SceneSlotConfig<TNode, TPose>\n  | SelectionOverlaySlotConfig<TPose>;\n\n/** What may fill one of the canvas's named layer slots: a config the canvas\n *  builds the layer from, a pre-built layer, or `null` to leave the slot\n *  empty. */\nexport type LayerSlotValue<TNode extends { id: string }, TPose> =\n  | StandardSlotConfig<TNode, TPose>\n  | CustomLayerEntry\n  | null;\n\n/** The canvas's render stack, as named slots. The standard slots (grid,\n *  scene, selection overlay, cell highlight) fix where a layer sits in the\n *  stack; scene and selection overlay can be configured, and every one can be\n *  given a layer of your own or switched off. Further keys add custom layers.\n *  `TSceneSlot` is what the scene slot accepts: `<SceneCanvas>` takes a\n *  partial config and fills the rest from its defaults. */\nexport type LayersMap<\n  TNode extends { id: string },\n  TPose,\n  TSceneSlot = SceneSlotConfig<TNode, TPose>,\n> = {\n  /** Grid slot, beneath the scene. Takes a pre-built layer (`{ layer }`) —\n   *  e.g. `createGridLayer` from `@weasel-js/guides` — or `null`. */\n  grid?: CustomLayerEntry | null;\n  scene?: TSceneSlot | null;\n  /** Selection-overlay slot. Canvas constructs the layer from a\n   *  `SelectionOverlaySlotConfig`; pass a `CustomLayerEntry` (`{ layer }`) to\n   *  supply a pre-built layer (e.g. from `<SceneCanvas>`). */\n  selectionOverlay?: SelectionOverlaySlotConfig<TPose> | CustomLayerEntry | null;\n  /** Cell-highlight overlay slot, drawn immediately after the grid. Takes a\n   *  pre-built layer (`{ layer }`) — e.g. `createCellHighlightLayer` from\n   *  `@weasel-js/guides` — or `null`. */\n  cellHighlight?: CustomLayerEntry | null;\n} & {\n  [customKey: string]: LayerSlotValue<TNode, TPose> | TSceneSlot | undefined;\n};\n\n/**\n * Props for `<Canvas>` — the low-level WebGL surface + viewport +\n * pointer routing primitive.\n *\n * Canvas is scene-agnostic. It owns the GL surface, view state, pointer/\n * keyboard dispatch, and slot composition. It does NOT own selection state,\n * picking logic, kind registries, or scene-aware overlays — those belong in\n * `<SceneCanvas>`.\n */\nexport interface CanvasProps<TNode extends { id: string } = { id: string }, TPose = unknown> {\n  /** CSS-pixel width. */\n  width: number;\n  /** CSS-pixel height. */\n  height: number;\n\n  /** Drawing-buffer density (device pixels per CSS pixel). When omitted the\n   *  canvas reads `window.devicePixelRatio` per paint — the long-standing\n   *  screen behavior. Supplying it makes density an explicit parameter, the\n   *  same contract the headless `renderSceneToPixels` path follows (that\n   *  path never reads ambient density at all). */\n  dpr?: number;\n\n  /** Flatness tolerance for curve tessellation, in world units. Forwarded to\n   *  `WeaselRendererOptions.flattenTolerance`. Leave unset for the cached\n   *  default (`DEFAULT_FLATTEN_TOLERANCE`, 0.5); a scene whose world unit is\n   *  not a pixel — feet, inches, millimetres — needs a value scaled to its\n   *  unit or sub-unit curves flatten to a handful of vertices. */\n  flattenTolerance?: number;\n\n  /** The version of whatever content this canvas draws, sampled at paint time\n   *  and reported by {@link CanvasExtensionApi.getPaintedVersion}.\n   *  `<SceneCanvas>` wires this to `scene.getVersion`. Chrome that must not\n   *  show DOM ahead of pixels compares the two and defers a frame. */\n  contentVersion?: () => number;\n\n  /** Paint inside the React commit rather than on the next animation frame.\n   *  Costs a synchronous paint per commit and per redraw request; buys\n   *  single-commit consistency between React-rendered DOM and canvas pixels.\n   *  For consumers with DOM chrome pinned to canvas content that cannot\n   *  tolerate a frame of skew. Live: toggling it switches modes from the next\n   *  redraw on. A redraw requested from inside a layer's `draw`, or from a\n   *  `subscribeFrame` callback, still waits for a frame — painting it in place\n   *  would recurse. */\n  syncPaint?: boolean;\n\n  /** External state the paint reads that no layer declares — typically what\n   *  an `alphaFor` consults. Each source is subscribed while mounted and\n   *  repaints the canvas when it notifies. A layer that reads outside state\n   *  declares it on `RenderLayer.subscribe` instead. */\n  redrawOn?: readonly RedrawSource[];\n\n  /**\n   * Combined adapter for scene-slot rendering, bounds computation, and\n   * move/resize/rotate gesture math. Optional — bare-Canvas consumers that\n   * don't need a scene slot may omit it.\n   *\n   * Canvas threads this adapter into layer factories and gesture hooks. The\n   * type is the move/resize/rotate intersection plus the *optional* scene-tree\n   * methods (`getLayers`/`getNode`/`getChildren`) — present on a hierarchical\n   * `SceneCanvasAdapter`, absent on flat adapters. The `buildSceneLayer` path\n   * feature-detects them at draw time.\n   *\n   * `<SceneCanvas>` synthesizes this from a `Scene`; bare-`<Canvas>` consumers\n   * must supply it explicitly when using the scene or selection-overlay slots.\n   */\n  adapter?: CanvasAdapter<TNode, TPose>;\n\n  /** Layer map. See module docstring for slot semantics. */\n  layers: LayersMap<TNode, TPose>;\n\n  /**\n   * Current selection state. Canvas is a pure pass-through — it owns no\n   * selection state of its own. When absent, Canvas behaves as if nothing is\n   * selected: no selection chrome, no select-on-click, no clear-on-background.\n   *\n   * `<SceneCanvas>` always supplies this from its internal `useSelection`.\n   * Bare-`<Canvas>` consumers may omit it for non-selection use cases (e.g.\n   * force-graph renderers or read-only viewers).\n   */\n  selection?: SelectionApi;\n\n\n  /**\n   * How to read and rewrite a pose. Drives the default `boundsOf` fallback and\n   * the selection-overlay bounds.\n   * Defaults to the rect identity (`AUTO_POSE_DESCRIPTOR`).\n   *\n   * This is a math helper, not a scene-shaped concern — it converts a pose\n   * value to an AABB and extracts rotation for the selection chrome. Bare-\n   * Canvas consumers that use a non-rect pose type should supply this.\n   */\n  poseDescriptor?: PoseDescriptor<TPose>;\n\n  // --- Gesture overrides (escape hatches for non-rect / group-aware apps) ---\n  /**\n   * Used by `PickHud` to display the list of ids under the cursor.\n   * NOT used for tool routing — see `getNodeAtPoint` for that.\n   * `<SceneCanvas>` passes its internal pick function here so the HUD\n   * stays in sync with the scene's actual hit-test order.\n   */\n  pickEvery?: (worldX: number, worldY: number) => string | string[] | null;\n  /**\n   * Override for committed bounds lookup. When supplied, takes precedence over\n   * the `poseDescriptor`-derived fallback. Used by the selection overlay, the\n   * multi-select union AABB, and `helpersRef.getEffectiveBounds`. Optional —\n   * bare-Canvas consumers that use a custom bounds shape should supply this;\n   * `<SceneCanvas>` derives it from its scene adapter and passes it via the\n   * scene-slot layer config rather than this prop.\n   */\n  boundsOf?: (id: string) => Bounds | null;\n  /** Bounds of `id` drawn at an in-flight pose — how chrome boxes a preview.\n   *  Defaults to the `poseDescriptor`'s box of that pose. */\n  boundsOfPose?: (id: string, pose: TPose) => Bounds | null;\n  /**\n   * Custom pointer-to-world coordinate transform. When supplied, overrides the\n   * default `(clientX - canvasRect.left) / scale + pan` calculation. Useful\n   * for consumers that apply an additional CSS transform to the canvas element.\n   */\n  clientToWorld?: (canvas: HTMLElement, cx: number, cy: number) => [number, number];\n\n  /**\n   * Paint into a caller-owned canvas at a rect on it, instead of an element\n   * this component creates. `x`/`y` are the rect's top-left in that canvas's\n   * CSS pixels; the rect's size is the existing `width`/`height` props.\n   *\n   * Requires `inputElement`: with no element of its own there is nowhere for\n   * pointer input, focus or the cursor to live, and nothing renders.\n   *\n   * N canvases can then share one GL context and one buffer.\n   */\n  paintInto?: { canvas: HTMLCanvasElement | null; x: number; y: number };\n  /**\n   * The element pointer input, focus and the cursor come from, and the element\n   * every client→world conversion measures. Only read alongside `paintInto`;\n   * an attached canvas uses the one it renders.\n   */\n  inputElement?: HTMLElement | null;\n\n  // --- Visuals / DOM passthrough ---\n  className?: string;\n  style?: React.CSSProperties;\n  tabIndex?: number;\n  /** Fired when the canvas element gains focus. The canvas is focusable by\n   *  default (`tabIndex` 0), so consumers driving focus-dependent chrome —\n   *  a focus ring, a \"keyboard shortcuts active\" hint — need to observe it. */\n  onFocus?: React.FocusEventHandler<HTMLCanvasElement>;\n  /** Fired when the canvas element loses focus. */\n  onBlur?: React.FocusEventHandler<HTMLCanvasElement>;\n  /**\n   * When `true` (default), the canvas element receives focus on `pointerdown`\n   * so keyboard events (tool hotkeys, undo/redo) are captured without a\n   * separate click-to-focus step. Set to `false` for canvases embedded inside\n   * a larger focus-managed layout where auto-focus would steal focus from\n   * sibling inputs.\n   */\n  autoFocusOnPointerDown?: boolean;\n\n  /** Opt-in keyboard-driven actions wired against the canvas's effective\n   *  selection. Each key turns the action on; values may be `true` (defaults)\n   *  or a config dict. Omitting a key leaves the action unbound. */\n  /** Tool primitive substrate. Pointer/keyboard/wheel events are routed\n   *  through `tools.dispatcher`. */\n  tools?: import('../tools/overlayBinding').ToolsApi;\n\n  /** Controlled viewport. When supplied, Canvas does not own the value —\n   *  the consumer must supply `onViewChange` and re-render with the new\n   *  view. See `View` JSDoc for the camera-position convention. */\n  view?: View;\n  /** Initial viewport for the uncontrolled path. Default `{x:0, y:0}`. */\n  defaultView?: View;\n  /** Fires whenever the viewport changes — in both controlled and\n   *  uncontrolled modes. */\n  onViewChange?: (next: View) => void;\n  /**\n   * Optional world-space rect that constrains pan. When supplied, every\n   * `setView` call passes through `clampView(next, viewBounds, {width, height})`\n   * before commit, keeping the visible rect inside `viewBounds`. If the visible\n   * rect is larger than the bounds along an axis (zoomed out past extent), that\n   * axis is centered. Has no effect on `scale`.\n   *\n   * A viewport concern, not scene-shaped. Consumers that want the pan to stay\n   * inside a document page boundary should wire this with the page dimensions.\n   */\n  viewBounds?: { x: number; y: number; width: number; height: number };\n  /**\n   * Mutable ref Canvas writes overlay-aware pose/bounds lookups to on every\n   * render. Custom layers can read it from inside their `draw` closure to\n   * reflect in-flight gestures (move/resize/rotate) instead of the committed\n   * scene. Both lookups apply when an id is in the active overlay; otherwise\n   * they fall back to the adapter.\n   *\n   * Useful for custom layers that render scene content outside of the standard\n   * slot system and need to stay in sync with gesture previews.\n   */\n  helpersRef?: React.MutableRefObject<CanvasHelpers<TPose> | null>;\n\n  /**\n   * Debug overlay configuration.\n   *  - `undefined` (default): read `?debug=…` from the URL.\n   *  - `false`: force off, ignore URL.\n   *  - `DebugConfig` object: force on with that config, ignore URL.\n   *\n   * When enabled, the Canvas appends a screen-space `debug-overlay` layer\n   * at the top of the layer stack and threads a `DebugSink` into every\n   * interaction hook so they record hit math + handle positions.\n   */\n  debug?: DebugConfig | false;\n\n  /** Test-only escape hatch: writes the live debug sink to this ref so tests\n   *  can call `snapshot()` after a render. No effect when debug is off. */\n  debugSinkRef?: React.MutableRefObject<CanvasDebugSink | null>;\n\n  /**\n   * Custom shader programs to compile on the renderer. Each handle must come\n   * from a module-level `registerProgram()` call. Compiled once per handle id\n   * on first render (or on context restore). Pass a stable reference (e.g.\n   * defined at module scope) — the array is read at renderer init time.\n   * Re-registering one of these ids with new source repaints the canvas, and\n   * the renderer recompiles it for that frame.\n   */\n  shaders?: ShaderProgramHandle[];\n\n  /**\n   * Extra source of ids whose committed paint should be suppressed during the\n   * current frame (in addition to those reported by the tools' `previewIds()`).\n   *\n   * Wired by `<SceneCanvas>` to expose the new gesture-dispatcher's in-flight\n   * handles: as legacy hooks are removed from tools, the\n   * source-hide for move/clone/etc. needs to follow the preview-ghost layer\n   * onto the dispatcher's `OngoingHandle.previewIds()`. Optional — bare\n   * `<Canvas>` consumers don't need to wire it.\n   */\n  previewIdsExtra?: () => Iterable<string> | null;\n\n  /**\n   * Extra preview-pose lookup checked after the active tool's `previewPose`\n   * misses. Wired by `<SceneCanvas>` to expose the gesture-dispatcher's\n   * in-flight `OngoingHandle.previewPose(id)` so selection chrome (resize/\n   * rotation handles, AABB outline) tracks the ghost during dispatcher-driven\n   * drags. Returns `null` / `undefined` when no preview is in flight.\n   */\n  previewPoseExtra?: (id: string) => unknown;\n\n  /**\n   * In-flight gesture state `<Canvas>` can't see for itself. Backs the\n   * `getGestureBounds` / `subscribeGestures` / `getGestureVersion` trio on\n   * `helpersRef`; wired by `<SceneCanvas>` from the gesture dispatcher\n   * (`createGestureSource`). Leaving it unwired is fine — those three then\n   * report \"no gesture in flight\" and never fire.\n   */\n  gestureSource?: GestureSource;\n\n  /**\n   * FillStyle applied to the full canvas surface behind the scene. Accepts the\n   * kit's `FillStyle` union (solid / pattern / linear-gradient / radial-gradient /\n   * conic-gradient) so consumers don't have to author a background node just to\n   * colorize the canvas.\n   *\n   * Rendered as a screen-space layer slotted before `'scene'` — independent of\n   * pan / zoom. Canvas owns this layer; `<SceneCanvas>` forwards its own\n   * `backgroundFill` prop verbatim so consumer apps see no breaking change.\n   */\n  backgroundFill?: FillStyle;\n\n  /**\n   * Dev HUD: when true, mounts a fixed-position widget showing live cursor\n   * coords in both viewport (client) and canvas (world) frames. Useful for\n   * diagnosing pointer-coord drift / pan-zoom misalignment without\n   * instrumenting events.\n   */\n  cursorCoordsHud?: boolean;\n\n  /**\n   * Dev HUD: when true, mounts a fixed-position widget just below the\n   * cursor-coords HUD listing the ids returned by `pickEvery(world)` under\n   * the cursor. Useful for diagnosing hit-test order and container/leaf\n   * overlap during select-tool work.\n   */\n  pickHud?: boolean;\n\n  /**\n   * Dev HUD: mounts a fixed-position widget below the pick HUD reporting\n   * the active modality mode, the active-slot tool, and the hotkey stack.\n   * Pass `true` to enable with no mode (renders `—` for the mode line —\n   * useful until the modality machine is wired). Pass an object to supply\n   * the current mode id.\n   */\n  modalityHud?: boolean | { modeId?: string };\n\n  /**\n   * Optional single-best hit resolver for the `pickHud` — the id this point\n   * would select on a bare click. When omitted the HUD skips the bold-best\n   * highlight. `<SceneCanvas>` forwards its `internalPickBest` here so the\n   * HUD shows the same best-candidate SceneCanvas would pick.\n   */\n  pickBest?: (worldX: number, worldY: number) => string | null;\n\n\n  /**\n   * Optional mode-owned decoration layer. When supplied, Canvas inserts it\n   * between the scene-render slot and the tool-overlay slot so decoration\n   * draw commands (e.g. path-edit anchor dots) paint above scene content but\n   * below tool overlays (drag rects, etc.).\n   *\n   * Slot ordering: scene → (scoping mask) → **decoration** → tool overlay → chrome.\n   *\n   * Wired by the modality machine after it activates a mode whose\n   * `ModeDefinition` supplies a `paint()` factory. Omitting this prop is a\n   * no-op — existing consumers are unaffected.\n   */\n  decorationLayer?: RenderLayer<unknown>;\n\n  /**\n   * Chrome-caps visibility resolver. When supplied, Canvas:\n   *   - exposes the predicate on `helpersForLayers.getIsVisible` so\n   *     custom layers (notably `composeAffordanceLayer`) can gate\n   *     paint by chrome id;\n   *   - threads it into the affordance-pipeline `HitTestContext.isVisible`\n   *     so the same gate applies to hit-testing.\n   *\n   * Called fresh per draw / per hitTest, so the consumer can return a\n   * predicate that closes over per-frame `ChromeCtx`. Omit to leave\n   * every chrome element visible (pre-chrome-caps behavior).\n   */\n  getIsVisible?: () => (id: string) => boolean;\n\n  /**\n   * Show or hide whole render layers by id. An id absent from the map falls\n   * back to the layer's own `defaultVisible`, and a layer marked `alwaysOn`\n   * ignores the map entirely.\n   *\n   * Hiding a layer also stops it claiming pointer events through\n   * `hitTestExtras` — a layer nobody can see must not swallow a click.\n   *\n   * This is `getIsVisible`'s coarser sibling: that one gates individual\n   * chrome elements *within* a layer, this one gates the layer.\n   */\n  layerVisibility?: Record<string, boolean>;\n\n  /**\n   * Draw order, by layer id, bottom first. Omit for the order the layers\n   * arrive in.\n   *\n   * **A listed order is the whole list:** any layer whose id is missing from\n   * it is not drawn. Reordering two layers means naming all of them.\n   */\n  layerOrder?: string[];\n\n  /**\n   * Runs of consecutive layers that composite as one — the surface for\n   * blurring the world while the chrome above it stays sharp. Members are\n   * named by layer id, and a layer in no group draws exactly as it did\n   * before. See {@link LayerGroup}.\n   */\n  layerGroups?: readonly LayerGroup[];\n}\n\nexport type {\n  CanvasViewHelpers,\n  CanvasSurfaceHelpers,\n  CanvasHelpers,\n} from './useViewHelpers';\n\n// Walks every registered + ambient tool: resize/rotate will register as\n/**\n * Build the scene layer. Tool ghosts (in-flight drag/resize/rotate poses) are\n * published via the active tool's `previewPose`/`previewIds` and rendered on\n * top of this layer (see SceneCanvas's preview-ghost layer); we draw committed\n * poses here, and `hideIds()` lets us skip the committed paint of ids the\n * active tool is currently ghosting so the source doesn't show through.\n */\nexport function buildSceneLayer<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: CanvasAdapter<TNode, TPose> | undefined,\n  debugSink: DebugSink | null,\n  boundsOfFn: ((id: string) => Bounds | null) | undefined,\n  hideIds: () => Set<string> | null,\n  /** When set, the returned layer carries this `id` and paints ONLY the named\n   *  scene layer (the rest are walked for ancestor clips). Used to split the\n   *  scene slot into per-scene-layer, individually-orderable canvas layers\n   *  (`scene:<layerId>`) so consumers can interleave custom layers between\n   *  them. Omit for the single bundled `scene` layer. */\n  slot?: { id: string; forLayer: string },\n): RenderLayer<unknown> {\n  const toPose =\n    cfg.toPose ??\n    ((obj: TNode) => (adapter ? adapter.getPose(obj.id) : (obj as unknown as TPose)));\n  const drawOne = cfg.drawOne;\n  const postProcess = cfg.postProcess;\n  const finish = cfg.cull\n    ? (cmds: DrawCommand[], view: View, dims: Dims): DrawCommand[] =>\n      cullDrawCommands(cmds, viewToMat3(view), { x: 0, y: 0, width: dims.width, height: dims.height })\n    : (cmds: DrawCommand[]): DrawCommand[] => cmds;\n  const paintBounds = cfg.cull ? cfg.paintBounds : undefined;\n  const culledIn = (view: View, dims: Dims) => paintBounds\n    ? paintMissesView(paintBounds, view, { x: 0, y: 0, width: dims.width, height: dims.height })\n    : undefined;\n  return {\n    id: slot?.id ?? 'scene',\n    label: slot ? `Scene: ${slot.forLayer}` : 'Scene',\n    draw: (_data, view, dims) => {\n      const hidden = hideIds();\n      const a = adapter;\n      if (\n        a &&\n        cfg.objects === undefined &&\n        typeof a.getLayers === 'function' &&\n        typeof a.getNode === 'function' &&\n        typeof a.getChildren === 'function' &&\n        drawOne\n      ) {\n        const filteredDrawOne = (obj: TNode, pose: TPose, v: View): DrawCommand[] => {\n          if (hidden && hidden.has(obj.id)) return [];\n          const cmds = drawOne(obj, pose, v);\n          if (debugSink) {\n            const b = boundsOfFn ? boundsOfFn(obj.id) : null;\n            if (b) debugSink.recordBounds(obj.id, b);\n            const ox = (pose as { x?: number }).x ?? (b ? b.x : 0);\n            const oy = (pose as { y?: number }).y ?? (b ? b.y : 0);\n            debugSink.recordOrigin(obj.id, { x: ox, y: oy });\n          }\n          return wrapNodeOutput(cmds, pose, cfg.alphaFor ? cfg.alphaFor(obj.id) : 1);\n        };\n        // Honor cfg.toPose on the hierarchical path by shimming getPose on the\n        // adapter so buildSceneTree routes through it instead of the raw adapter.\n        const hierarchicalAdapter = cfg.toPose\n          ? {\n              ...a,\n              getPose: (id: string) => {\n                const obj = a.getNode!(id);\n                return obj ? toPose(obj) : a.getPose(id);\n              },\n            }\n          : a;\n        // World-space commands; drawLayers wraps in viewToMat3 automatically.\n        const tree = buildSceneTree(\n          hierarchicalAdapter as Parameters<typeof buildSceneTree>[0],\n          filteredDrawOne as unknown as Parameters<typeof buildSceneTree>[1],\n          view,\n          slot?.forLayer,\n          cfg.derivedPathOf as Parameters<typeof buildSceneTree>[4],\n          culledIn(view, dims) as Parameters<typeof buildSceneTree>[5],\n        );\n        return finish(postProcess ? postProcess(tree, view, dims) : tree, view, dims);\n      }\n      // Flat fallback — keep existing body verbatim. (Per-layer slotting only\n      // applies on the hierarchical path; a flat adapter has no scene layers,\n      // so the `scene:<layer>` split is a no-op and we emit the whole scene.)\n      const objects = cfg.objects ?? adapter?.getNodes() ?? [];\n      const children: DrawCommand[] = [];\n      const culled = culledIn(view, dims);\n      for (const obj of objects) {\n        if (hidden && hidden.has(obj.id)) continue;\n        const pose: TPose = toPose(obj);\n        if (drawOne && !culled?.(obj, pose)) {\n          const cmds = drawOne(obj, pose, view);\n          const wrapped = wrapNodeOutput(cmds, pose, cfg.alphaFor ? cfg.alphaFor(obj.id) : 1);\n          for (const cmd of wrapped) children.push(cmd);\n        }\n        if (debugSink) {\n          const b = boundsOfFn ? boundsOfFn(obj.id) : null;\n          if (b) debugSink.recordBounds(obj.id, { x: b.x, y: b.y, width: b.width, height: b.height });\n          const ox = (pose as { x?: number }).x ?? (b ? b.x : 0);\n          const oy = (pose as { y?: number }).y ?? (b ? b.y : 0);\n          debugSink.recordOrigin(obj.id, { x: ox, y: oy });\n        }\n      }\n      // World-space commands; drawLayers wraps in viewToMat3 automatically.\n      return finish(postProcess ? postProcess(children, view, dims) : children, view, dims);\n    },\n  };\n}\n\n/**\n * Build the scene slot as one canvas layer **per scene layer** — keyed\n * `scene:<layerId>` — when the adapter is hierarchical (exposes `getLayers`).\n * This lets consumers interleave custom layers *between* scene layers via the\n * standard slot anchoring (`before: 'scene:plantings'`). Each per-layer canvas\n * layer re-runs the scene walk for its own layer only (others are still walked\n * for ancestor clips). Falls back to a single `scene` layer for flat adapters\n * or adapters with no declared layers.\n */\nexport function buildSceneLayers<TNode extends { id: string }, TPose>(\n  cfg: SceneSlotConfig<TNode, TPose>,\n  adapter: CanvasAdapter<TNode, TPose> | undefined,\n  debugSink: DebugSink | null,\n  boundsOfFn: ((id: string) => Bounds | null) | undefined,\n  hideIds: () => Set<string> | null,\n): Array<{ key: string; layer: RenderLayer<unknown> }> {\n  const sceneLayerIds =\n    cfg.objects === undefined && typeof adapter?.getLayers === 'function'\n      ? adapter.getLayers().map((l) => l.id)\n      : null;\n  if (!sceneLayerIds || sceneLayerIds.length === 0) {\n    return [{ key: 'scene', layer: buildSceneLayer(cfg, adapter, debugSink, boundsOfFn, hideIds) }];\n  }\n  return sceneLayerIds.map((id) => ({\n    key: sceneLayerKey(id),\n    layer: buildSceneLayer(cfg, adapter, debugSink, boundsOfFn, hideIds, {\n      id: sceneLayerKey(id),\n      forLayer: id,\n    }),\n  }));\n}\n\nfunction resolveToolsCursor(\n  tools: ToolsApi,\n  ctxBase?: () => Omit<ToolCtx, 'scratch'>,\n): ResolvedCursor | undefined {\n  const id = tools.hotkeyEngaged ?? tools.active;\n  const tool = id === null ? undefined : tools.registry[id];\n  if (!tool?.cursor) return undefined;\n  if (typeof tool.cursor !== 'function') return resolveCursorTier(tool.cursor);\n  if (!ctxBase) return undefined;\n  // Function form: invoke at render time with the live base ctx.\n  //\n  // `ctx.scratch` is always null here. It used to be the tool-routing\n  // dispatcher's in-flight gesture scratch, which is how `grab` became\n  // `grabbing` and how select swapped to `move` — mid-gesture cursors are now\n  // `Action.activeCursor`, applied imperatively by the hover pump. A tool that\n  // wants a cursor driven by its own state closes over its own ref (the pen\n  // does, for its close-path hint).\n  try {\n    const base = ctxBase();\n    return resolveCursorTier(tool.cursor({ ...base, scratch: null }));\n  } catch {\n    return undefined;\n  }\n}\n\n/** Stable empty map, so an omitted `layerVisibility` doesn't remake the paint\n *  effect's deps every render. */\nconst NO_LAYER_VISIBILITY: Record<string, boolean> = {};\n\n/** Client coords to world, through the `clientToWorld` prop when one is\n *  supplied and the canvas rect otherwise. Every pointer path in this file\n *  goes through here so the two cannot drift. */\nfunction toWorld(\n  canvas: HTMLElement,\n  clientX: number,\n  clientY: number,\n  view: View,\n  override: CanvasProps<never, never>['clientToWorld'],\n): [number, number] {\n  if (override) return override(canvas, clientX, clientY);\n  return clientToWorldHelper(clientX, clientY, canvas.getBoundingClientRect(), view);\n}\n\nfunction CanvasInner<TNode extends { id: string }, TPose>(\n  props: CanvasProps<TNode, TPose>,\n  ref: React.ForwardedRef<CanvasExtensionApi>,\n) {\n  const {\n    width,\n    height,\n    dpr: dprProp,\n    flattenTolerance,\n    contentVersion,\n    syncPaint = false,\n    redrawOn,\n    adapter: adapterProp,\n    layers: layersMap,\n    selection,\n    boundsOf,\n    boundsOfPose,\n    pickEvery,\n    clientToWorld,\n    paintInto,\n    inputElement,\n    poseDescriptor: geometry = AUTO_POSE_DESCRIPTOR as unknown as PoseDescriptor<TPose>,\n    className,\n    style,\n    tabIndex = 0,\n    onFocus,\n    onBlur,\n    autoFocusOnPointerDown = true,\n    helpersRef,\n    tools,\n    view: viewProp,\n    defaultView,\n    onViewChange,\n    viewBounds,\n    debug: debugProp,\n    debugSinkRef,\n    shaders,\n    previewIdsExtra,\n    previewPoseExtra,\n    gestureSource,\n    backgroundFill,\n    cursorCoordsHud,\n    pickHud,\n    modalityHud,\n    pickBest,\n    decorationLayer,\n    getIsVisible,\n    layerVisibility,\n    layerOrder,\n    layerGroups,\n  } = props;\n\n  // Resolve debug config: explicit prop wins; `undefined` falls back to URL;\n  // `false` forces off. Keyed on content, so a config written inline does not\n  // rebuild the sink, and lose what it has recorded, on every render.\n  const debugKey = debugProp === undefined ? undefined : JSON.stringify(debugProp);\n  const resolvedDebugConfig = useMemo<DebugConfig | null>(() => {\n    if (debugKey !== undefined) return (JSON.parse(debugKey) as DebugConfig | false) || null;\n    if (typeof window === 'undefined') return null;\n    return parseDebugFlags(window.location.search);\n  }, [debugKey]);\n\n  // Lazily build one sink per Canvas mount (per resolved config).\n  const debugSink = useMemo<CanvasDebugSink | null>(() => {\n    if (resolvedDebugConfig === null) return null;\n    return createDebugSink(resolvedDebugConfig);\n  }, [resolvedDebugConfig]);\n  const committedDebugSinkRef = useLatest(debugSink);\n  const getDebug = useCallback(() => committedDebugSinkRef.current, [committedDebugSinkRef]);\n\n  const adapter = adapterProp;\n\n  // The element input comes from and every client→world conversion measures.\n  // Normally the `<canvas>` this component renders; under `paintInto` it is\n  // the caller's `inputElement` instead — nothing downstream of here asks\n  // which of the two it is holding, because nothing downstream needs a canvas.\n  const canvasRef = useRef<HTMLElement | null>(null);\n  // The `<canvas>` this component rendered, if it rendered one. `paint` is the\n  // only thing that needs a real canvas, for `getContext`.\n  const ownCanvasRef = useRef<HTMLCanvasElement | null>(null);\n  // Stable, so a commit does not detach the element: an inline ref is nulled\n  // until the layout phase reaches it, and a sync paint asked for before that\n  // finds no canvas.\n  const setOwnCanvas = useCallback((el: HTMLCanvasElement | null) => {\n    ownCanvasRef.current = el;\n    canvasRef.current = el;\n  }, []);\n  const detached = !!paintInto;\n  // The detached input element reaches `canvasRef` at commit; the own canvas\n  // arrives through `setOwnCanvas`, React's ref callback.\n  useInsertionEffect(() => {\n    if (detached) canvasRef.current = inputElement ?? null;\n  });\n  // Where pixels go. Split from `canvasRef` only when detached.\n  const paintTarget = detached ? (paintInto.canvas ?? null) : null;\n  const paintTargetRef = useLatest(paintTarget);\n  const paintRect = detached ? { x: paintInto.x, y: paintInto.y } : null;\n  const paintRectRef = useLatest(paintRect);\n\n  // Read by `hitTestExtras`, which is built once and must see live values.\n  const helpersForLayersRef = useRef<CanvasHelpers<TPose> | null>(null);\n  const dimsRef = useLatest({ width, height });\n  const getIsVisibleRef = useLatest(getIsVisible);\n  const layerVisibilityRef = useLatest(layerVisibility);\n  const layerOrderRef = useLatest(layerOrder);\n\n  // React does not drive the paint; the frame loop does. The thunk defers to\n  // `paint` below, which needs inputs this render has not computed yet.\n  const paintRef = useRef<() => boolean>(() => false);\n  const { requestRedraw, subscribeFrame, subscribeBeforePaint } = useFrameLoop(\n    useCallback(() => paintRef.current(), []),\n    { syncPaint, target: canvasRef },\n  );\n\n  const contentVersionRef = useLatest(contentVersion);\n  const paintedVersionRef = useRef(0);\n  const getPaintedVersion = useCallback(() => paintedVersionRef.current, []);\n\n  // The `layersWithDebug` memo reads `extrasRef.current`, so registration has\n  // to bump state to re-run it. Rare (a HUD attaching, a loupe mounting).\n  const [extrasVersion, setExtrasVersion] = useState(0);\n  const extrasRef = useRef<Set<RenderLayer<unknown>>>(new Set());\n  const registerLayer = useCallback((layer: RenderLayer<unknown>) => {\n    extrasRef.current.add(layer);\n    setExtrasVersion(n => n + 1);\n    return () => {\n      extrasRef.current.delete(layer);\n      setExtrasVersion(n => n + 1);\n    };\n  }, []);\n\n  // Hit-test registered layers topmost-first. Registration order is draw\n  // order, so the last-registered layer is on top and gets first refusal —\n  // the reverse of the Set's iteration order.\n  //\n  // `<SceneCanvas>` folds this into its `affordanceAt` thunk. Canvas can't do\n  // that itself: it has the layers but not the dispatcher.\n  const hitTestExtrasIn = useCallback((\n    worldX: number,\n    worldY: number,\n    view: View,\n    dims: Dims,\n    data: unknown,\n    only?: readonly RenderLayer<unknown>[],\n  ) => {\n    const layers = [...extrasRef.current].reverse();\n    const isVisible = getIsVisibleRef.current?.() ?? alwaysVisible;\n    const visibility = layerVisibilityRef.current ?? NO_LAYER_VISIBILITY;\n    const order = layerOrderRef.current;\n    for (const layer of layers) {\n      if (!layer.hitTest) continue;\n      if (only && !only.includes(layer)) continue;\n      if (!isLayerPainted(layer, visibility, order)) continue;\n      const hit = layer.hitTest(worldX, worldY, data, view, dims, isVisible);\n      if (hit) return { layerId: layer.id, hit };\n    }\n    return null;\n  }, [getIsVisibleRef, layerOrderRef, layerVisibilityRef]);\n\n  const hitTestExtras = useCallback((\n    worldX: number,\n    worldY: number,\n    frame?: { view: View; dims: Dims },\n  ) => hitTestExtrasIn(\n    worldX,\n    worldY,\n    frame?.view ?? viewRef.current,\n    frame?.dims ?? dimsRef.current,\n    helpersForLayersRef.current,\n  ), [hitTestExtrasIn, dimsRef]);\n\n  // The uncontrolled view lives in a ref, not `useState`, so a camera moving\n  // at 60 Hz costs no React render; DOM that mirrors it subscribes instead.\n  const viewRef = useRef<View>(normalizeView(viewProp ?? defaultView ?? { x: 0, y: 0, scale: { x: 1, y: 1 } }));\n  const isControlled = viewProp !== undefined;\n  const controlledView = isControlled ? normalizeView(viewProp) : undefined;\n  const viewSubsRef = useRef<Set<(v: View) => void>>(new Set());\n  const onViewChangeRef = useLatest(onViewChange);\n  const viewBoundsRef = useLatest(viewBounds);\n  const isControlledRef = useLatest(isControlled);\n  const controlledWarnedRef = useRef(false);\n\n  const setView = useCallback((next: View | ((current: View) => View)) => {\n    const resolved = normalizeView(typeof next === 'function' ? next(viewRef.current) : next);\n    const bounds = viewBoundsRef.current;\n    const clamped = bounds ? clampView(resolved, bounds, dimsRef.current) : resolved;\n    if (isControlledRef.current) {\n      // The prop is the authority; writing the ref would put pixels and props\n      // out of step with nothing to reconcile them.\n      const forward = onViewChangeRef.current;\n      if (!controlledWarnedRef.current) {\n        controlledWarnedRef.current = true;\n        console.warn(forward\n          ? '[weasel] setView not applied locally: this canvas is controlled by its `view` prop. The value was forwarded to `onViewChange` — update the prop from there, or drop it to take the imperative path.'\n          : '[weasel] setView ignored: this canvas is controlled by its `view` prop and has no `onViewChange`, so the value has nowhere to go. Update the prop, or drop it to take the imperative path.');\n      }\n      forward?.(clamped);\n      return;\n    }\n    viewRef.current = clamped;\n    for (const fn of viewSubsRef.current) fn(clamped);\n    onViewChangeRef.current?.(clamped);\n    requestRedraw();\n  }, [requestRedraw, dimsRef, isControlledRef, onViewChangeRef, viewBoundsRef]);\n\n  const getView = useCallback(() => viewRef.current, []);\n  const subscribeView = useCallback((fn: (v: View) => void) => {\n    viewSubsRef.current.add(fn);\n    return () => { viewSubsRef.current.delete(fn); };\n  }, []);\n\n  useLayoutEffect(() => {\n    const element = canvasRef.current;\n    if (!element) return;\n    return registerMountedCanvas({ element, getView });\n  }, [detached, inputElement, getView]);\n\n  // The painted tier's channel. `<Canvas>` owns it because it owns both ends:\n  // the tool cursor that feeds it and the frame loop that has to repaint when\n  // it changes. The hover pump reaches it through the ref handle below.\n  const paintedCursor = useMemo<PaintedCursorState>(() => createPaintedCursorState(), []);\n  const paintedCursorLayer = useMemo(\n    () => createPaintedCursorLayer(paintedCursor),\n    [paintedCursor],\n  );\n  // An idle pointermove repaints nothing on its own, so a cursor the compositor\n  // is not drawing needs its own pump. The store stays quiet unless something\n  // painted is actually on screen.\n  useEffect(() => paintedCursor.subscribe(() => { requestRedraw(); }), [paintedCursor, requestRedraw]);\n\n  const getSurfaceRect = useCallback(() => {\n    const origin = paintRectRef.current;\n    const { width: w, height: h } = dimsRef.current;\n    return { x: origin?.x ?? 0, y: origin?.y ?? 0, width: w, height: h };\n  }, [dimsRef, paintRectRef]);\n\n  useImperativeHandle(ref, () => ({\n    // Named rather than read off `canvasRef` so the handle rebuilds when a\n    // detached surface's input element arrives, which is a render later.\n    element: detached ? inputElement ?? null : canvasRef.current,\n    surface: detached ? paintInto?.canvas ?? null : ownCanvasRef.current,\n    getSurfaceRect,\n    requestRedraw,\n    subscribeFrame,\n    subscribeBeforePaint,\n    registerLayer,\n    hitTestExtras,\n    getView,\n    setView,\n    subscribeView,\n    getPaintedVersion,\n    paintedCursor,\n    getDebug,\n  }), [canvasRef, ownCanvasRef, detached, inputElement, paintInto?.canvas,\n       getSurfaceRect, requestRedraw, subscribeFrame, subscribeBeforePaint, registerLayer,\n       hitTestExtras, getView, setView, subscribeView, getPaintedVersion,\n       paintedCursor, getDebug]);\n\n  // Created on the first paint, rebuilt when the paint target moves, and\n  // freed on unmount.\n  const lease = useCanvasRenderer();\n  const layerCacheRef = useRef<LayerCommandCache>(new Map());\n\n  // Views registered on this surface — declared as `views` descriptors or\n  // mounted as `<CanvasView>` children. Null outside a surface that mounts a\n  // registry, which is the single-view case.\n  const viewRegistry = useOptionalViewRegistry();\n\n  // Internal hooks always run (rules of hooks). They consult a noop adapter\n  // when none is supplied; their controllers are then unused because the\n  // gesture wiring below only enables move/resize when `adapter` is present.\n  const noopAdapter = useMemo(\n    () =>\n      ({\n        getPose: () => ({}) as TPose,\n        getNodes: () => [],\n      }) as unknown as MoveAdapter<TNode, TPose>\n        & ResizeAdapter<TNode, TPose>\n        & RotateAdapter<TNode, TPose>,\n    [],\n  );\n  const effectiveAdapter = (adapter ?? noopAdapter) as MoveAdapter<TNode, TPose>\n    & ResizeAdapter<TNode, TPose>\n    & RotateAdapter<TNode, TPose>;\n\n  // Canvas owns no selection state. The `selection` prop is the sole source.\n  // When absent, behave as if no selection exists (no chrome, no overlay).\n  // A no-op fallback keeps all downstream reads safe without branching.\n  const noopSelection = useMemo<SelectionApi>(\n    () => ({\n      current: [],\n      get: () => [],\n      contains: () => false,\n      set: () => {},\n      add: () => {},\n      remove: () => {},\n      toggle: () => {},\n      clear: () => {},\n      applyClick: () => {},\n      adapterMethods: {\n        getSelection: () => [],\n        setSelection: () => {},\n      },\n    }),\n    [],\n  );\n  const effectiveSelection: SelectionApi = selection ?? noopSelection;\n\n  // Base ctx for the function form of `Tool.cursor` — the last consumer of\n  // `ToolCtx` now that the tool-routing dispatcher is gone. The cursor is\n  // resolved during render, so the ctx carries this render's values; only\n  // `applyOps`, which a cursor function could call later, reads a ref.\n  const effectiveAdapterRef = useLatest(effectiveAdapter);\n  const clientToWorldRef = useLatest(clientToWorld);\n  const toolsCtxBase = () => {\n    const view = controlledView ?? viewRef.current;\n    const c = detached ? inputElement ?? null : canvasRef.current;\n    const rect = c ? c.getBoundingClientRect() : (typeof DOMRect !== 'undefined' ? new DOMRect() : ({ x: 0, y: 0, width: 0, height: 0, top: 0, left: 0, right: 0, bottom: 0 } as DOMRect));\n    return {\n      worldX: 0,\n      worldY: 0,\n      modifiers: { alt: false, shift: false, meta: false, ctrl: false },\n      selection: effectiveSelection,\n      adapter: effectiveAdapter,\n      applyOps: (ops: Op[], label: string) => {\n        dispatchApplyBatch(effectiveAdapterRef.current, ops, label);\n      },\n      view,\n      setView,\n      canvasRect: rect,\n      debug: debugSink ?? undefined,\n    };\n  };\n\n  // Stable wrappers for HUD props — read the ref at call time so the HUDs\n  // don't reinstall their useEffect on every render when the prop identity\n  // changes (e.g. when SceneCanvas re-renders with a new lambda reference).\n  // pickEvery and pickBest are HUD-only.\n  const pickEveryRef = useLatest(pickEvery);\n  const pickBestRef = useLatest(pickBest);\n  const stablePickEveryForHud = useCallback(\n    (wx: number, wy: number): readonly string[] => {\n      const pe = pickEveryRef.current;\n      if (!pe) return [];\n      const raw = pe(wx, wy);\n      if (!raw) return [];\n      return Array.isArray(raw) ? raw : [raw];\n    },\n    [pickEveryRef],\n  );\n  const stablePickBestForHud = useCallback(\n    (wx: number, wy: number): string | null => pickBestRef.current?.(wx, wy) ?? null,\n    [pickBestRef],\n  );\n  // Selection-driven action gestures (delete/nudge/undoRedo/duplicate) used\n  // to be wired here via legacy hooks. They now go through the Actions\n  // Registry / dispatcher path; consumers register them via the kit's\n  // standard descriptors (see `useStandardActions`).\n\n  const selectedIdsForWiring = effectiveSelection.current;\n\n  // One view's overlay-aware state. A hook, so N views are N components each\n  // calling it once — not a loop in this body.\n  const {\n    helpers: viewHelpers,\n    chromeState: viewChromeState,\n    effectiveBoundsOf,\n    previewExtraRef,\n  } = useViewHelpers<TPose>({\n    adapter,\n    geometry,\n    boundsOf,\n    boundsOfPose,\n    selection: selectedIdsForWiring,\n    tools,\n    gestureSource,\n    previewPoseExtra,\n    previewIdsExtra,\n    getIsVisible: () => getIsVisibleRef.current?.() ?? alwaysVisible,\n  });\n\n  // The affordance-layer hit-test used to be wired into the tool-routing\n  // dispatcher from here, so its pointerdown could walk tool overlays\n  // top-down. `<SceneCanvas>` now composes the equivalent walk into the\n  // `affordanceAt` thunk it hands `useGestureDispatcher` — over registered\n  // layers via `hitTestExtras` above, and over selection chrome itself.\n\n  const surfaceHelpers: CanvasSurfaceHelpers = {\n    getDebug: () => debugSink,\n  };\n  const helpersForLayers: CanvasHelpers<TPose> = { ...viewHelpers, ...surfaceHelpers, viewId: null };\n\n  // Pointer-pressed flag. The only thing `<Canvas>` still needs to know about\n  // pointer state: `onUncapturedMove` means \"hover\", so it stands down while a\n  // button is held. Everything else about pointer input — thresholds, click and\n  // double-click synthesis, drag handles, the document-level backstop for a\n  // release that lands off-canvas — belongs to `useGestureDispatcher`, which\n  // attaches its own listeners to this same element.\n  const pointerDownRef = useRef(false);\n\n  const handlePointerDown = (e: React.PointerEvent<HTMLCanvasElement>) => {\n    if (autoFocusOnPointerDown) e.currentTarget.focus();\n    pointerDownRef.current = true;\n  };\n  const handlePointerMove =\n    ((e: React.PointerEvent<HTMLCanvasElement>) => {\n      // Dispatch onUncapturedMove to layers when no button is held.\n      if (pointerDownRef.current) return;\n      const c = e.currentTarget;\n      const view = viewRef.current;\n      const [worldX, worldY] = toWorld(c, e.clientX, e.clientY, view, clientToWorldRef.current);\n      for (const layer of layersWithDebug) {\n        layer.onUncapturedMove?.(worldX, worldY, e.nativeEvent, view, { width, height });\n      }\n    });\n  const handlePointerLeave = (_e: React.PointerEvent<HTMLCanvasElement>) => {\n    pointerDownRef.current = false;\n    for (const layer of layersWithDebug) layer.onUncapturedLeave?.();\n  };\n  const handlePointerUp = (_e: React.PointerEvent<HTMLCanvasElement>) => {\n    pointerDownRef.current = false;\n  };\n  const handlePointerCancel = undefined;\n\n  // Background-fill layer: screen-space, emits a single full-canvas rect with\n  // the configured FillStyle. Drawn beneath every other layer.\n  // Independent of pan / zoom — backgrounds are canvas chrome, not world content.\n  const backgroundLayer = useMemo<RenderLayer<unknown> | null>(() => {\n    if (!backgroundFill) return null;\n    return {\n      id: 'scene-background-fill',\n      label: 'Background fill',\n      space: 'screen',\n      draw: (_data, _view, dims) => [{\n        kind: 'path',\n        path: { kind: 'rect', x: 0, y: 0, width: dims.width, height: dims.height },\n        fill: backgroundFill,\n      }],\n    };\n  }, [backgroundFill]);\n\n  const layers = useMemo<RenderLayer<unknown>[]>(() => {\n    const standardLayers: Partial<\n      Record<(typeof STANDARD_SLOTS)[number], RenderLayer<unknown>>\n    > = {};\n\n    const grid = layersMap.grid;\n    if (isCustomEntry(grid)) standardLayers.grid = grid.layer;\n    const cellHighlight = layersMap.cellHighlight;\n    if (isCustomEntry(cellHighlight)) standardLayers.cellHighlight = cellHighlight.layer;\n\n    const sceneCfg = layersMap.scene as SceneSlotConfig<TNode, TPose> | null | undefined;\n    let sceneLayers: Array<{ key: string; layer: RenderLayer<unknown> }> | undefined;\n    if (\n      sceneCfg &&\n      !isCustomEntry(sceneCfg) &&\n      (sceneCfg as SceneSlotConfig<TNode, TPose>).drawOne\n    ) {\n      sceneLayers = buildSceneLayers<TNode, TPose>(\n        sceneCfg,\n        adapter,\n        debugSink,\n        effectiveBoundsOf,\n        () => {\n          const ids = aggregatePreviewIds(tools);\n          const extra = previewExtraRef.current.previewIdsExtra?.();\n          if (extra) {\n            for (const id of extra) ids.add(id);\n          }\n          return ids.size > 0 ? ids : null;\n        },\n      );\n    }\n\n    const selSlot = layersMap.selectionOverlay as\n      | SelectionOverlaySlotConfig<TPose>\n      | CustomLayerEntry\n      | null\n      | undefined;\n    if (isCustomEntry(selSlot)) {\n      // Pre-built layer (e.g. from SceneCanvas) — pass through directly.\n      standardLayers.selectionOverlay = selSlot.layer;\n    } else if (selSlot !== null) {\n      const cfg = (selSlot ?? {}) as SelectionOverlaySlotConfig<TPose>;\n      standardLayers.selectionOverlay = createSelectionOverlayLayer<TPose>({\n        ...cfg,\n        // A consumer-supplied pose lookup still needs the configured geometry\n        // to project with; without one the layer reads bounds off the chrome\n        // state and never calls either.\n        ...(cfg.poseById\n          ? { getPose: cfg.poseById, poseDescriptor: cfg.poseDescriptor ?? geometry }\n          : {}),\n      });\n    }\n\n    const out: RenderLayer<unknown>[] = composeOrderedLayers(\n      layersMap, standardLayers, sceneLayers, backgroundLayer ?? undefined,\n    );\n    // Decoration layer: above scene, below tool overlay (per slot ordering doc).\n    if (decorationLayer) out.push(decorationLayer);\n    if (tools) {\n      placeToolOverlays(out, standardLayers.selectionOverlay, tools.getActiveOverlays);\n    }\n    return out;\n  }, [layersMap, adapter, effectiveBoundsOf, debugSink, tools, backgroundLayer,\n      decorationLayer, geometry, previewExtraRef]);\n\n  const viewRegistryVersion = useSyncExternalStore(\n    useCallback((cb: () => void) => viewRegistry?.subscribe(cb) ?? (() => {}), [viewRegistry]),\n    () => viewRegistry?.getVersion() ?? 0,\n    () => 0,\n  );\n\n  // The stack a view paints through its own camera is this canvas's, before\n  // the views themselves are folded in — otherwise a view would contain\n  // itself. Published by reference and read at draw time.\n  const surfaceLayersRef = useLatest<readonly RenderLayer<unknown>[]>(layers);\n  useEffect(() => {\n    viewRegistry?.attachSurface({\n      origin: () => {\n        const c = canvasRef.current;\n        if (!c) return { left: 0, top: 0 };\n        const r = c.getBoundingClientRect();\n        return { left: r.left, top: r.top };\n      },\n      view: () => viewRef.current,\n      dims: () => dimsRef.current,\n      layers: () => surfaceLayersRef.current,\n      requestRedraw,\n      chromeState: () => helpersForLayersRef.current!.getChromeState(),\n      hitTestExtras: hitTestExtrasIn,\n      claimsAbove: (x, y) => {\n        const view = viewRef.current;\n        return hitTestExtrasIn(\n          view.x + x / view.scale.x, view.y + y / view.scale.y,\n          view, dimsRef.current, helpersForLayersRef.current,\n        ) !== null;\n      },\n    });\n  }, [viewRegistry, canvasRef, requestRedraw, hitTestExtrasIn, dimsRef, surfaceLayersRef]);\n\n  // Append the debug overlay layer at the very top of the stack when debug\n  // is enabled. The layer reads from `debugSink.snapshot()` and paints in\n  // screen space.\n  const layersWithDebug = useMemo(() => {\n    // Views paint through the surface's own stack, so they sit above it and\n    // below both the debug overlay and externally-registered layers.\n    const withViews = viewRegistry\n      ? [...layers, ...viewRegistry.list().filter((r) => r.paint).map((r) => r.layer as RenderLayer<unknown>)]\n      : layers;\n    const base = debugSink && resolvedDebugConfig\n      ? [...withViews, createDebugOverlayLayer({ sink: debugSink, config: resolvedDebugConfig })]\n      : withViews;\n    // The cursor goes last: it is the one thing that is always in front of\n    // everything, including a consumer's own registered layers.\n    return [...base, ...extrasRef.current, paintedCursorLayer];\n    // extrasVersion drives re-reads of extrasRef when layers are registered/detached;\n    // viewRegistryVersion does the same for registered views.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [layers, debugSink, resolvedDebugConfig, extrasVersion, viewRegistry, viewRegistryVersion,\n      paintedCursorLayer]);\n\n  useEffect(() => {\n    const redraw = (): void => { requestRedraw(); };\n    const offs: (() => void)[] = [];\n    for (const layer of layersWithDebug) if (layer.subscribe) offs.push(layer.subscribe(redraw));\n    return () => { for (const off of offs) off(); };\n  }, [layersWithDebug, requestRedraw]);\n\n  useRedrawOn(redrawOn, requestRedraw);\n\n  const shaderIdKey = shaders?.map((h) => h.id).join('|') ?? '';\n\n  // Everything the paint, hit-testing and the view registry read that a React\n  // render owns. `useLatest` and the insertion effect below publish committed\n  // renders only, ahead of every layout effect in the commit, any of which may\n  // ask for a sync paint.\n  const paintInputs = {\n    layers: layersWithDebug, width, height, debugSink,\n    frameStats: resolvedDebugConfig?.fps === true,\n    dpr: dprProp, layerVisibility, layerOrder, layerGroups, shaders,\n    flattenTolerance,\n  };\n  const paintInputsRef = useLatest(paintInputs);\n  useInsertionEffect(() => {\n    if (controlledView) viewRef.current = controlledView;\n    helpersForLayersRef.current = helpersForLayers;\n    if (helpersRef) helpersRef.current = helpersForLayers;\n    if (debugSinkRef) debugSinkRef.current = debugSink;\n  });\n\n  const paint = useCallback((): boolean => {\n    const c = paintTargetRef.current ?? ownCanvasRef.current;\n    if (!c) return false;\n    const rect = paintRectRef.current;\n    const {\n      layers: paintLayers, width: w, height: h, debugSink: sink, frameStats,\n      dpr: dprIn, layerVisibility: vis, layerOrder: order,\n      flattenTolerance: paintFlattenTolerance,\n      layerGroups: groups, shaders: paintShaders,\n    } = paintInputsRef.current;\n\n    // Clear sink at the top of every paint so per-frame records don't leak.\n    sink?.beginFrame();\n    if (sink) {\n      for (let i = 0; i < paintLayers.length; i++) {\n        const layer = paintLayers[i];\n        if (layer.id === 'debug-overlay') continue;\n        sink.recordLayer(layer.id, layer.label, layer.space ?? 'world', i);\n      }\n    }\n\n    const renderer = lease.bind(c, { width: w, height: h, dpr: dprIn }, {\n      tile: rect,\n      flattenTolerance: paintFlattenTolerance,\n      shaders: paintShaders,\n    });\n    // jsdom or unsupported environment: no WebGL2, nothing to paint.\n    if (!renderer) return false;\n\n    const view = viewRef.current;\n    const spans: LayerDrawSpan[] | undefined = sink && frameStats ? [] : undefined;\n    const paintT0 = spans ? performance.now() : 0;\n    const commands = drawLayers(\n      paintLayers,\n      helpersForLayersRef.current,\n      vis ?? NO_LAYER_VISIBILITY,\n      order,\n      view,\n      { width: w, height: h },\n      layerCacheRef.current,\n      undefined,\n      groups,\n      spans,\n    );\n    renderer.render(commands, viewToMat3(view), spans ? { spans } : undefined);\n    if (sink && spans) sink.recordFrame(frameStatsOf(spans, renderer.lastFrameStats(), performance.now() - paintT0));\n    paintedVersionRef.current = contentVersionRef.current?.() ?? 0;\n    return true;\n  }, [contentVersionRef, lease, paintInputsRef, paintRectRef, paintTargetRef]);\n  useInsertionEffect(() => {\n    paintRef.current = paint;\n  });\n\n  // A tripwire, not a list of values this effect uses: every paint input that\n  // arrives on a render must appear here, or changing it paints stale.\n  // `viewChromeState` stands in for the whole overlay-aware set the layer\n  // helpers expose — it re-memoizes on exactly the selection, bounds and\n  // preview inputs they read. What moves between renders instead (a scene\n  // write, a gesture pump, a late image decode) pushes its own redraw.\n  // Layout, not passive, so a `syncPaint` surface lands its pixels in the same\n  // commit as the DOM.\n  useLayoutEffect(() => {\n    requestRedraw();\n  }, [layersWithDebug, width, height, viewProp, debugSink, dprProp, flattenTolerance,\n      layerVisibility, layerOrder, layerGroups, shaderIdKey, syncPaint,\n      viewChromeState, getIsVisible, paintTarget, paintRect?.x, paintRect?.y, requestRedraw]);\n\n  useEffect(() => {\n    const layerCache = layerCacheRef.current;\n    const viewSubs = viewSubsRef.current;\n    return () => {\n      layerCache.clear();\n      viewSubs.clear();\n    };\n  }, []);\n\n  useEffect(() => {\n    if (!shaderIdKey) return;\n    const ids = shaderIdKey.split('|');\n    let seen = ids.map(getProgramSource);\n    return programSourceRegistry.subscribe(() => {\n      const now = ids.map(getProgramSource);\n      const changed = now.some((src, i) => src !== seen[i]);\n      seen = now;\n      if (changed) requestRedraw();\n    });\n  }, [shaderIdKey, requestRedraw]);\n\n  // Resolved during render, so it reads this render's view, not the ref's\n  // last committed one.\n  const toolsCursorTier = tools\n    ? resolveToolsCursor(tools, toolsCtxBase)\n    : undefined;\n  // A painted tool cursor gets `none` here and the layer draws it instead.\n  const toolsCursor =\n    toolsCursorTier === undefined\n      ? undefined\n      : toolsCursorTier.kind === 'css'\n        ? toolsCursorTier.css\n        : 'none';\n  const effectiveStyle: React.CSSProperties | undefined = toolsCursor\n    ? { ...style, cursor: toolsCursor }\n    : style;\n  const toolsPainted: PaintedCursor | null =\n    toolsCursorTier?.kind === 'painted' ? toolsCursorTier : null;\n  // Keyed on the value, not the object: the tier is rebuilt every render, and\n  // publishing from render would notify a repaint mid-render.\n  const toolsPaintedKey = toolsPainted\n    ? `${toolsPainted.glyph}|${toolsPainted.angle}|${toolsPainted.size}|${toolsPainted.worldRadius}`\n    : '';\n  useEffect(() => {\n    paintedCursor.setBase(toolsPainted);\n    // `toolsPainted` is a fresh object each render; the key is its identity.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [paintedCursor, toolsPaintedKey]);\n\n  // Detached: the four handlers below are declared as JSX props on an element\n  // this component no longer renders, so attach them to the caller's instead.\n  // Everything else about pointer input already attaches to `canvasRef`, which\n  // is that same element.\n  const layersForMoveRef = useLatest(layersWithDebug);\n  useEffect(() => {\n    if (!detached || !inputElement) return;\n    const el = inputElement;\n    const onDown = (): void => {\n      if (autoFocusOnPointerDown) el.focus();\n      pointerDownRef.current = true;\n    };\n    const onMove = (e: PointerEvent): void => {\n      if (pointerDownRef.current) return;\n      const view = viewRef.current;\n      const [worldX, worldY] = toWorld(\n        el, e.clientX, e.clientY, view, clientToWorldRef.current,\n      );\n      const dims = dimsRef.current;\n      for (const layer of layersForMoveRef.current) {\n        layer.onUncapturedMove?.(worldX, worldY, e, view, dims);\n      }\n    };\n    const onUp = (): void => { pointerDownRef.current = false; };\n    const onLeave = (): void => {\n      pointerDownRef.current = false;\n      for (const layer of layersForMoveRef.current) layer.onUncapturedLeave?.();\n    };\n    const onMenu = (e: Event): void => e.preventDefault();\n    el.addEventListener('pointerdown', onDown);\n    el.addEventListener('pointermove', onMove);\n    el.addEventListener('pointerup', onUp);\n    el.addEventListener('pointerleave', onLeave);\n    el.addEventListener('contextmenu', onMenu);\n    return () => {\n      el.removeEventListener('pointerdown', onDown);\n      el.removeEventListener('pointermove', onMove);\n      el.removeEventListener('pointerup', onUp);\n      el.removeEventListener('pointerleave', onLeave);\n      el.removeEventListener('contextmenu', onMenu);\n    };\n  }, [detached, inputElement, autoFocusOnPointerDown, clientToWorldRef, dimsRef, layersForMoveRef]);\n\n  // The cursor is a tool's, but under `paintInto` it has no element of ours to\n  // sit on. Written imperatively rather than by the caller, so a tool's cursor\n  // keeps working without the caller mirroring tool state.\n  useEffect(() => {\n    if (!detached || !inputElement) return;\n    inputElement.style.cursor = toolsCursor ?? '';\n  }, [detached, inputElement, toolsCursor]);\n\n  const huds = (\n    <>\n      {cursorCoordsHud && (\n        <CursorCoordsHud\n          canvasRef={canvasRef}\n          {...(detached ? { anchorRef: canvasRef } : {})}\n          viewRef={viewRef}\n        />\n      )}\n      {pickHud && (\n        <PickHud\n          canvasRef={canvasRef}\n          {...(detached ? { anchorRef: canvasRef } : {})}\n          viewRef={viewRef}\n          pickEvery={stablePickEveryForHud}\n          pickBest={stablePickBestForHud}\n        />\n      )}\n      {modalityHud && (\n        <ModalityHud\n          canvasRef={canvasRef}\n          {...(detached ? { anchorRef: canvasRef } : {})}\n          modeId={typeof modalityHud === 'object' ? modalityHud.modeId : undefined}\n        />\n      )}\n    </>\n  );\n\n  // Detached: no element of our own, but the HUDs are DOM and still belong to\n  // this pane. Held until the input element arrives — `useHostAnchor` resolves\n  // its host on mount and again only when the panel or the window moves, so a\n  // HUD mounted against a null host would latch off.\n  if (detached) return inputElement ? huds : null;\n\n  return (\n    <>\n      <canvas\n        ref={setOwnCanvas}\n        width={width}\n        height={height}\n        tabIndex={tabIndex}\n        className={className}\n        style={effectiveStyle}\n        onFocus={onFocus}\n        onBlur={onBlur}\n        onPointerDown={handlePointerDown}\n        onPointerMove={handlePointerMove}\n        onPointerUp={handlePointerUp}\n        onPointerCancel={handlePointerCancel}\n        onPointerLeave={handlePointerLeave}\n        // Suppress the browser's default right-click menu over the canvas.\n        // Canvases are interaction surfaces; the browser's context menu\n        // (Save Image / Inspect Element / etc.) is almost never what the\n        // user wants, and right-click is a useful gesture surface that\n        // tools may consume. Consumers using right-click for their own\n        // gestures should add their own onContextMenu handler — calling\n        // `e.preventDefault()` is the no-op default; calling something\n        // else still works (this handler runs before the default menu).\n        onContextMenu={(e) => e.preventDefault()}\n      />\n      {huds}\n    </>\n  );\n}\n\n/**\n * Forward-ref'd `<canvas>` wrapper. Generic over the object and pose types —\n * TypeScript will infer them from the `adapter` (or `move`/`resize`) prop.\n */\nexport const Canvas = forwardRef(CanvasInner) as <\n  TNode extends { id: string } = { id: string },\n  TPose = TNode,\n>(\n  props: CanvasProps<TNode, TPose> & { ref?: React.ForwardedRef<CanvasExtensionApi> },\n) => ReturnType<typeof CanvasInner>;\n\n"],"mappings":"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"}

package/dist/canvas/CanvasView.js

@@ -0,0 +1,255 @@
+import { normalizeView as e } from "../core/viewport/view.js";
+import { createViewportLayer as t } from "../features/viewports/viewportLayer.js";
+import { useDeviceProfile as n } from "../core/device/useDeviceProfile.js";
+import { clientToWorld as r } from "../core/viewport/clientToWorld.js";
+import { clampView as i } from "../core/viewport/clampView.js";
+import { AUTO_POSE_DESCRIPTOR as a } from "../interactions/actions/resize/autoPoseDescriptor.js";
+import { pathFromPlane as o } from "./planeClips.js";
+import { createSceneLayerGate as s, paintedLayers as c } from "./sceneLayerPaint.js";
+import { useViewHelpers as ee } from "./useViewHelpers.js";
+import { IDENTITY_VIEW as l, UNMEASURED_DIMS as u, useOptionalViewRegistry as te } from "./viewRegistry.js";
+import { useSelection as ne } from "../core/selection/useSelection.js";
+import { useOptionalViewInputs as re } from "./viewInputs.js";
+import { viewportWorldRect as ie } from "../core/viewport/viewportWorldRect.js";
+import { anchorStateFrom as ae, buildAffordanceAt as oe, buildClassifyTarget as se } from "./affordanceAt.js";
+import { createDispatcherPreviewSources as ce, createGestureSource as le } from "./SceneCanvas/dispatcherGestureBounds.js";
+import { useCallback as d, useEffect as f, useMemo as p, useRef as ue, useState as m } from "react";
+import { useLatest as h } from "@weasel-js/react";
+import { createDispatcher as de } from "@weasel-js/routing";
+import { useOptionalDepRegistry as fe } from "@weasel-js/routing/react";
+//#region src/canvas/CanvasView.tsx
+var pe = {
+	adapter: void 0,
+	geometry: a,
+	boundsOf: void 0,
+	tools: void 0
+}, me = () => !0, he = (e) => e;
+function g(a) {
+	let { id: g, bounds: ge, view: _, defaultView: _e, onViewChange: ve, viewBounds: ye, layers: be = he, layerVisibility: xe, layerOrder: Se, background: v, order: y = Infinity, label: b, selection: Ce, selectionOptions: x, interactive: S = !0, paint: C = !0 } = a, w = te(), we = fe(), T = h(we), E = ne(x), D = Ce ?? (x ? E : void 0), [Te, Ee] = m(() => e(_e ?? l)), O = _ ?? Te, k = re(), A = D ?? k?.selectionApi ?? E, j = h({
+		view: O,
+		bounds: ge,
+		layers: be,
+		layerVisibility: xe,
+		layerOrder: Se,
+		onViewChange: ve,
+		viewBounds: ye,
+		viewProp: _,
+		viewSelection: D,
+		selection: A
+	}), M = d((e, t) => {
+		let n = j.current.bounds;
+		return typeof n == "function" ? n(e, t) : n;
+	}, [j]), N = d(() => {
+		let e = w?.surface();
+		return M(e?.view() ?? l, e?.dims() ?? u);
+	}, [w, M]), P = d((t, n) => {
+		let r = j.current.view;
+		return e(typeof r == "function" ? r(t, n) : r);
+	}, [j]), F = d(() => {
+		let e = w?.surface();
+		return P(e?.view() ?? l, e?.dims() ?? u);
+	}, [w, P]), I = d(() => c(w?.surface()?.layers() ?? [], j.current), [w, j]), [L] = m(s), R = d((e) => L(w?.surface()?.layers() ?? [], j.current)(e), [
+		w,
+		L,
+		j
+	]), z = d((t) => {
+		let { viewBounds: n, onViewChange: r, viewProp: a } = j.current, o = N(), s = e(t), c = n ? i(s, n, {
+			width: o.w,
+			height: o.h
+		}) : s;
+		a === void 0 && Ee(c), r?.(c), w?.surface()?.requestRedraw();
+	}, [
+		w,
+		N,
+		j
+	]), B = p(() => ({
+		get: F,
+		set: z,
+		hostSize: () => {
+			let e = N();
+			return {
+				width: e.w,
+				height: e.h
+			};
+		},
+		layerIsPainted: R
+	}), [
+		F,
+		N,
+		z,
+		R
+	]), V = p(() => {
+		let e = () => T.current?.get("ingestion");
+		return {
+			viewportWorldRect: () => {
+				let e = N();
+				return ie(F(), {
+					width: e.w,
+					height: e.h
+				});
+			},
+			get resolveSrc() {
+				return e()?.resolveSrc;
+			},
+			get svg() {
+				return e()?.svg;
+			},
+			get clipboard() {
+				return e()?.clipboard;
+			}
+		};
+	}, [
+		F,
+		N,
+		T
+	]), H = ue(null);
+	H.current ||= de();
+	let U = k?.rotationBadge ?? null, De = p(() => ({
+		gestureSource: le(() => H.current),
+		...ce(() => H.current)
+	}), []), W = h(k), G = d(() => ({
+		selection: j.current.selection.get(),
+		view: F(),
+		action: H.current.getActiveAction()
+	}), [F, j]), K = k?.boundsOf, Oe = p(() => K ? (e) => K(e, F()) : void 0, [K, F]), q = k?.boundsOfPose, ke = p(() => q ? (e, t) => q(e, t, F()) : void 0, [q, F]), { helpers: Ae } = ee({
+		...k ?? pe,
+		boundsOf: Oe,
+		boundsOfPose: ke,
+		...De,
+		selection: A.current,
+		getIsVisible: () => W.current?.chromeCaps?.isVisible(G()) ?? me
+	}), J = h(Ae), Y = d((e, t) => {
+		let n = w?.surface()?.origin() ?? {
+			left: 0,
+			top: 0
+		}, i = N(), [a, o] = r(e, t, {
+			left: n.left + i.x,
+			top: n.top + i.y
+		}, F());
+		return {
+			x: a,
+			y: o
+		};
+	}, [
+		w,
+		N,
+		F
+	]), X = p(() => ae(() => T.current, (e, t) => o(t, W.current?.planeOfNode?.(e, F()) ?? null)), [
+		F,
+		T,
+		W
+	]), { targetScale: Z } = n(), Q = p(() => {
+		let e = oe({
+			getChromeState: () => J.current.getChromeState(),
+			getView: F,
+			targetScale: Z,
+			rotationBadge: U,
+			getAnchorState: X,
+			getIsVisible: () => J.current.getIsVisible()
+		});
+		return (t) => {
+			let n = N(), r = (w?.surface())?.hitTestExtras(t.x, t.y, F(), {
+				width: n.w,
+				height: n.h
+			}, J.current, I());
+			if (r) {
+				let e = r.hit;
+				return {
+					kind: `layer:${r.layerId}`,
+					owner: r.layerId,
+					strength: e.strength ?? "shared",
+					...e.claimedKinds === void 0 ? {} : { claimedKinds: e.claimedKinds },
+					...e.cursor === void 0 ? {} : { cursor: e.cursor },
+					...e.initialScratch === void 0 ? {} : { payload: e.initialScratch }
+				};
+			}
+			return e(t);
+		};
+	}, [
+		X,
+		N,
+		w,
+		Z,
+		F,
+		I,
+		U,
+		J
+	]), je = p(() => {
+		let e = se(() => j.current.selection.get(), (e, t) => {
+			let n = W.current, r = {
+				...F(),
+				layerIsPainted: R
+			};
+			if (n?.pickBest) return n.pickBest(e, t, r);
+			let i = n?.pickEvery?.(e, t, r) ?? [];
+			return i.length > 0 ? i[i.length - 1] : null;
+		}, (e) => W.current?.kindOfNode?.(e));
+		return (t) => e(t);
+	}, [
+		F,
+		R,
+		j,
+		W
+	]), $ = p(() => ({
+		id: g,
+		order: y,
+		interactive: S,
+		paint: C,
+		layer: t({
+			id: g,
+			label: b ?? g,
+			source: I,
+			view: P,
+			bounds: (e, t) => M(e, t),
+			data: (e) => ({
+				...e,
+				...J.current,
+				viewId: g
+			}),
+			...v === void 0 ? {} : { background: v }
+		}),
+		layerIsPainted: R,
+		target: {
+			dispatcher: H.current,
+			affordanceAt: Q,
+			classifyTarget: je,
+			clientToWorld: Y,
+			deps: () => ({
+				view: B,
+				ingestion: V,
+				dispatcher: { cancelAll: (e) => H.current.cancelAll(e) },
+				...j.current.viewSelection ? { selection: j.current.viewSelection } : {}
+			}),
+			getRuleCtx: () => W.current?.chromeCaps?.ruleCtx(G())
+		}
+	}), [
+		g,
+		y,
+		S,
+		C,
+		b,
+		v,
+		M,
+		P,
+		B,
+		Q,
+		je,
+		Y,
+		G,
+		V,
+		I,
+		R,
+		j,
+		W,
+		J
+	]);
+	return f(() => {
+		if (w) return w.register($);
+	}, [w, $]), f(() => {
+		w?.surface()?.requestRedraw();
+	}, [w, O]), null;
+}
+//#endregion
+export { g as CanvasView };
+
+//# sourceMappingURL=CanvasView.js.map

package/dist/canvas/CanvasView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CanvasView.js","names":["NO_INPUTS","AUTO_POSE_DESCRIPTOR","ALWAYS_VISIBLE","ALL_LAYERS","s","CanvasView","viewProp","selectionProp","props","registry","useOptionalViewRegistry","depRegistry","useOptionalDepRegistry","depRegistryRef","useLatest","ownSelection","useSelection","selectionOptions","viewSelection","internalView","setInternalView","useState","normalizeView","defaultView","IDENTITY_VIEW","effectiveView","inputs","useOptionalViewInputs","selection","live","rectAt","useCallback","b","outer","dims","rectNow","surface","UNMEASURED_DIMS","cameraAt","v","camera","drawnLayers","paintedLayers","sceneLayerGate","createSceneLayerGate","layerIsPainted","layerId","setView","vb","cb","controlled","rect","valid","next","clamped","clampView","viewApi","useMemo","ingestionApi","base","viewportWorldRect","dispatcherRef","useRef","createDispatcher","rotationBadge","own","createGestureSource","createDispatcherPreviewSources","inputsRef","ruleInputs","surfaceBoundsOf","boundsOf","id","surfaceBoundsOfPose","boundsOfPose","pose","useViewHelpers","helpersRef","helpers","clientToWorldHere","canvas","x","y","clientToWorld","cx","cy","getAnchorState","anchorStateFrom","pathFromPlane","path","useDeviceProfile","affordanceAt","inner","buildAffordanceAt","extra","world","claim","targetScale","classifyTarget","buildClassifyTarget","i","frame","wx","wy","ids","registration","createViewportLayer","label","background","reason","order","interactive","paint","useEffect"],"sources":["../../src/canvas/CanvasView.tsx"],"sourcesContent":["/**\n * `<CanvasView>` — a second view on an existing canvas: its own camera over a\n * rect of the surface, with input routed to it.\n *\n * Mount one inside `<SceneCanvas>`, or declare the same thing through the\n * surface's `views` prop, which renders one of these per descriptor.\n */\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\nimport type { Dims, RenderLayer } from 'core/layers/render';\nimport { normalizeView, type View } from 'core/viewport/view';\nimport { clientToWorld } from 'core/viewport/clientToWorld';\nimport { clampView } from 'core/viewport/clampView';\nimport type { Bounds } from 'core/viewport/fitViewToBounds';\nimport { createViewportLayer } from 'features/viewports/viewportLayer';\nimport { createDispatcher } from '@weasel-js/routing';\nimport type { IngestionDep, ViewApi } from 'interactions/actions/depSchema';\nimport { viewportWorldRect } from 'core/viewport/viewportWorldRect';\nimport { useSelection, type SelectionApi, type UseSelectionOptions } from 'core/selection/useSelection';\nimport { AUTO_POSE_DESCRIPTOR } from 'interactions/actions/resize/autoPoseDescriptor';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport { useViewHelpers } from './useViewHelpers';\nimport { anchorStateFrom, buildAffordanceAt, buildClassifyTarget } from './affordanceAt';\nimport { pathFromPlane } from './planeClips';\nimport { useOptionalDepRegistry } from '@weasel-js/routing/react';\nimport { useLatest } from '@weasel-js/react';\nimport { useDeviceProfile } from 'core/device/useDeviceProfile';\nimport {\n  createGestureSource,\n  createDispatcherPreviewSources,\n} from './SceneCanvas/dispatcherGestureBounds';\nimport { useOptionalViewInputs, type SurfaceViewInputs, type ViewRuleInputs } from './viewInputs';\nimport { createSceneLayerGate, paintedLayers } from './sceneLayerPaint';\nimport {\n  useOptionalViewRegistry,\n  IDENTITY_VIEW,\n  UNMEASURED_DIMS,\n  type ViewRegistration,\n} from './viewRegistry';\n\n/** A rect on the surface, in CSS pixels from the canvas top-left. */\nexport interface ViewRect { x: number; y: number; w: number; h: number }\n\n/** Props for `<CanvasView>`. @experimental */\nexport interface CanvasViewProps {\n  /** Identifies the view to the surface and to input routing. Must be unique\n   *  among the views on one canvas. */\n  id: string;\n  /** Where this view paints, recomputed every frame so the rect can track the\n   *  outer camera. A plain rect is accepted for a fixed panel. */\n  bounds: ViewRect | ((outer: View, dims: Dims) => ViewRect);\n  /** Camera. Supply this to control it; otherwise the view keeps its own,\n   *  seeded from `defaultView`. `onViewChange` fires either way.\n   *\n   *  A thunk is a camera derived from the canvas's — a loupe following the\n   *  pointer — read fresh at every paint and every event, so the two cannot\n   *  disagree mid-gesture. It is controlled: a pan inside the view reaches\n   *  only `onViewChange`. */\n  view?: View | ((outer: View, dims: Dims) => View);\n  defaultView?: View;\n  onViewChange?: (v: View) => void;\n  /** Pan limits, applied to every camera change the same way `<Canvas>`\n   *  applies its own. */\n  viewBounds?: Bounds;\n  /** Which of the surface's layers this view paints. Defaults to all of them —\n   *  the same content through a second camera. */\n  layers?: (surface: readonly RenderLayer<unknown>[]) => readonly RenderLayer<unknown>[];\n  /**\n   * Show or hide layers in this view only, by id — the map `<Canvas>` takes,\n   * applied after `layers` narrows the stack. A scene layer paints as\n   * `scene:<layerId>`; one hidden here neither paints nor picks in this view,\n   * and a marquee or Cmd+A routed here passes over it. The surface and every\n   * other view are unaffected.\n   */\n  layerVisibility?: Record<string, boolean>;\n  /** Draw order for this view, by layer id, bottom first. A listed order is\n   *  the whole list, so a layer left out of it is neither painted nor picked\n   *  here. */\n  layerOrder?: string[];\n  /** Opaque ground painted before the source layers, so the surface does not\n   *  show through where the inner camera sees nothing. */\n  background?: string;\n  /** Paint and hit order. Defaults to `Infinity` — after every view the\n   *  surface declared as a prop. */\n  order?: number;\n  /** Label for debug overlays. Defaults to the id. */\n  label?: string;\n  /**\n   * Whether input over the view resolves through its camera. Default `true`:\n   * a press selects what the view shows, and a drag moves it in the view's\n   * world units. `false` paints only, and input over it reaches the canvas\n   * beneath as though the view were not there.\n   *\n   * Views do not nest. A view paints and routes the surface's own stack,\n   * never another view; overlapping views are hit in paint order.\n   */\n  interactive?: boolean;\n  /**\n   * Whether the surface paints the view. Default `true`. `false` is for a\n   * host that draws the view inside chrome of its own — a HUD window's\n   * interior — through `SceneCanvasApi.addView`'s `draw`, so it lands in\n   * that chrome's z-order rather than the surface's.\n   */\n  paint?: boolean;\n  /** A selection of this view's own, which actions dispatched inside it read\n   *  and write instead of the surface's. Omit both this and\n   *  `selectionOptions` and the view shares the surface's selection — the\n   *  default, so undo restores one selection rather than N. */\n  selection?: SelectionApi;\n  /** Opts this view into owning a selection, configured thus. Ignored when\n   *  `selection` is supplied. */\n  selectionOptions?: UseSelectionOptions;\n}\n\n/** What a view builds its helpers from outside a surface: nothing but the\n *  default geometry, which answers `null` for every lookup. */\n// A view outside a surface has no inputs to inherit — including a selection,\n// so it falls back to owning one.\nconst NO_INPUTS: Omit<SurfaceViewInputs, 'selectionApi'> = {\n  adapter: undefined,\n  geometry: AUTO_POSE_DESCRIPTOR as unknown as PoseDescriptor<unknown>,\n  boundsOf: undefined,\n  tools: undefined,\n};\n\nconst ALWAYS_VISIBLE = (): boolean => true;\n\nconst ALL_LAYERS = (s: readonly RenderLayer<unknown>[]): readonly RenderLayer<unknown>[] => s;\n\n/**\n * @experimental\n *\n * One view on a shared canvas. Owns a camera, contributes the viewport node\n * that paints it, and registers the dispatch record that sends gestures inside\n * its rect to that camera rather than to the canvas's.\n *\n * Renders nothing itself — it is a declaration, and the surface does the\n * drawing. Outside a surface that mounts a view registry it is inert.\n */\nexport function CanvasView(props: CanvasViewProps): null {\n  const {\n    id, bounds, view: viewProp, defaultView, onViewChange, viewBounds,\n    layers = ALL_LAYERS, layerVisibility, layerOrder, background, order = Infinity, label,\n    selection: selectionProp, selectionOptions, interactive = true, paint = true,\n  } = props;\n\n  const registry = useOptionalViewRegistry();\n  const depRegistry = useOptionalDepRegistry();\n  const depRegistryRef = useLatest(depRegistry);\n\n  // Hooks run unconditionally; the owned selection goes unused unless this\n  // view asked for one.\n  const ownSelection = useSelection(selectionOptions);\n  const viewSelection = selectionProp ?? (selectionOptions ? ownSelection : undefined);\n\n  const [internalView, setInternalView] = useState<View>(() => normalizeView(defaultView ?? IDENTITY_VIEW));\n  const effectiveView = viewProp ?? internalView;\n\n  const inputs = useOptionalViewInputs();\n  // The selection this view acts on: its own when it has one, the surface's\n  // otherwise.\n  const selection = viewSelection ?? inputs?.selectionApi ?? ownSelection;\n\n  // Everything the registration reads is behind a ref: the registration object\n  // is registered once and must not churn, but what it answers with has to be\n  // the last committed render's.\n  const live = useLatest({\n    view: effectiveView, bounds, layers, layerVisibility, layerOrder, onViewChange, viewBounds, viewProp,\n    viewSelection, selection,\n  });\n\n  const rectAt = useCallback((outer: View, dims: Dims): ViewRect => {\n    const b = live.current.bounds;\n    return typeof b === 'function' ? b(outer, dims) : b;\n  }, [live]);\n\n  /** The rect for the surface's current frame — what a client point and a\n   *  clamp are measured against outside a draw call. */\n  const rectNow = useCallback((): ViewRect => {\n    const surface = registry?.surface();\n    return rectAt(surface?.view() ?? IDENTITY_VIEW, surface?.dims() ?? UNMEASURED_DIMS);\n  }, [registry, rectAt]);\n\n  const cameraAt = useCallback((outer: View, dims: Dims): View => {\n    const v = live.current.view;\n    return normalizeView(typeof v === 'function' ? v(outer, dims) : v);\n  }, [live]);\n\n  /** The camera for the surface's current frame. */\n  const camera = useCallback((): View => {\n    const surface = registry?.surface();\n    return cameraAt(surface?.view() ?? IDENTITY_VIEW, surface?.dims() ?? UNMEASURED_DIMS);\n  }, [registry, cameraAt]);\n\n  /** The surface's layers this view draws, in the order it draws them. */\n  const drawnLayers = useCallback((): readonly RenderLayer<unknown>[] => (\n    paintedLayers(registry?.surface()?.layers() ?? [], live.current)\n  ), [registry, live]);\n\n  const [sceneLayerGate] = useState(createSceneLayerGate);\n  /** What this view's picks, marquees and select-alls ask of a scene layer. */\n  const layerIsPainted = useCallback((layerId: string): boolean => (\n    sceneLayerGate(registry?.surface()?.layers() ?? [], live.current)(layerId)\n  ), [registry, sceneLayerGate, live]);\n\n  const setView = useCallback((next: View) => {\n    const { viewBounds: vb, onViewChange: cb, viewProp: controlled } = live.current;\n    const rect = rectNow();\n    const valid = normalizeView(next);\n    const clamped = vb ? clampView(valid, vb, { width: rect.w, height: rect.h }) : valid;\n    if (controlled === undefined) setInternalView(clamped);\n    cb?.(clamped);\n    registry?.surface()?.requestRedraw();\n  }, [registry, rectNow, live]);\n\n  const viewApi = useMemo<ViewApi>(() => ({\n    get: camera,\n    set: setView,\n    hostSize: () => {\n      const rect = rectNow();\n      return { width: rect.w, height: rect.h };\n    },\n    layerIsPainted,\n  }), [camera, rectNow, setView, layerIsPainted]);\n\n  // Paste placement is a camera question, so it is this view's when the paste\n  // routed here. The rest of the dep — `resolveSrc`, `svg`, `clipboard` — is\n  // the surface's one wiring, read live off the canvas registry.\n  const ingestionApi = useMemo<IngestionDep>(() => {\n    const base = (): IngestionDep | undefined => depRegistryRef.current?.get('ingestion');\n    return {\n      viewportWorldRect: () => {\n        const rect = rectNow();\n        return viewportWorldRect(camera(), { width: rect.w, height: rect.h });\n      },\n      get resolveSrc() { return base()?.resolveSrc; },\n      get svg() { return base()?.svg; },\n      get clipboard() { return base()?.clipboard; },\n    };\n  }, [camera, rectNow, depRegistryRef]);\n\n  // One dispatcher per view: in-flight handles are per-view state, and two\n  // views must not be able to see each other's.\n  const dispatcherRef = useRef<ReturnType<typeof createDispatcher> | null>(null);\n  if (!dispatcherRef.current) dispatcherRef.current = createDispatcher();\n\n  // This view's overlay-aware state. The scene half comes from the surface —\n  // same adapter, same tools — but everything gesture-shaped is read off this\n  // view's own dispatcher, which is where a gesture inside this view lands.\n  const rotationBadge = inputs?.rotationBadge ?? null;\n  const own = useMemo(() => ({\n    gestureSource: createGestureSource(() => dispatcherRef.current),\n    ...createDispatcherPreviewSources(() => dispatcherRef.current),\n  }), []);\n\n  const inputsRef = useLatest(inputs);\n\n  /** The chrome-caps context this view answers for: its selection, its camera,\n   *  its dispatcher's in-flight action. */\n  const ruleInputs = useCallback((): ViewRuleInputs => ({\n    selection: live.current.selection.get(),\n    view: camera(),\n    action: dispatcherRef.current!.getActiveAction(),\n  }), [camera, live]);\n\n  // The surface's resolver, asked for this view's camera.\n  const surfaceBoundsOf = inputs?.boundsOf;\n  const boundsOf = useMemo(\n    () => (surfaceBoundsOf ? (id: string) => surfaceBoundsOf(id, camera()) : undefined),\n    [surfaceBoundsOf, camera],\n  );\n  const surfaceBoundsOfPose = inputs?.boundsOfPose;\n  const boundsOfPose = useMemo(\n    () => (surfaceBoundsOfPose\n      ? (id: string, pose: unknown) => surfaceBoundsOfPose(id, pose, camera())\n      : undefined),\n    [surfaceBoundsOfPose, camera],\n  );\n\n  const { helpers } = useViewHelpers<unknown>({\n    ...(inputs ?? NO_INPUTS),\n    boundsOf,\n    boundsOfPose,\n    ...own,\n    selection: selection.current,\n    getIsVisible: () =>\n      inputsRef.current?.chromeCaps?.isVisible(ruleInputs()) ?? ALWAYS_VISIBLE,\n  });\n  const helpersRef = useLatest(helpers);\n\n  /** A client point in this view's world. The rect moves with the outer\n   *  camera, so it is read per call rather than closed over. */\n  const clientToWorldHere = useCallback((cx: number, cy: number): { x: number; y: number } => {\n    const canvas = registry?.surface()?.origin() ?? { left: 0, top: 0 };\n    const rect = rectNow();\n    const [x, y] = clientToWorld(\n      cx, cy,\n      { left: canvas.left + rect.x, top: canvas.top + rect.y },\n      camera(),\n    );\n    return { x, y };\n  }, [registry, rectNow, camera]);\n\n  // Anchors are hit in this view's camera world, where its plane draws them.\n  const getAnchorState = useMemo(() => anchorStateFrom(\n    () => depRegistryRef.current,\n    (id, path) => pathFromPlane(path, inputsRef.current?.planeOfNode?.(id, camera()) ?? null),\n  ), [camera, depRegistryRef, inputsRef]);\n\n  const { targetScale } = useDeviceProfile();\n\n  // Selection chrome hit-testing for this view: same construction the surface\n  // does for its own, against this view's chrome and camera.\n  const affordanceAt = useMemo(() => {\n    const inner = buildAffordanceAt({\n      getChromeState: () => helpersRef.current.getChromeState(),\n      getView: camera,\n      targetScale,\n      rotationBadge,\n      getAnchorState,\n      getIsVisible: () => helpersRef.current.getIsVisible(),\n    });\n    return (world: { x: number; y: number }) => {\n      // A registered layer this view paints gets first refusal, on this\n      // view's frame and envelope. One painted over the surface already had\n      // its chance: it occludes the view before routing reaches here.\n      const rect = rectNow();\n      const surface = registry?.surface();\n      const extra = surface?.hitTestExtras(\n        world.x, world.y, camera(), { width: rect.w, height: rect.h },\n        helpersRef.current, drawnLayers(),\n      );\n      if (extra) {\n        const claim = extra.hit;\n        return {\n          kind: `layer:${extra.layerId}`,\n          owner: extra.layerId,\n          strength: claim.strength ?? 'shared',\n          ...(claim.claimedKinds !== undefined ? { claimedKinds: claim.claimedKinds } : {}),\n          ...(claim.cursor !== undefined ? { cursor: claim.cursor } : {}),\n          ...(claim.initialScratch !== undefined ? { payload: claim.initialScratch } : {}),\n        };\n      }\n      return inner(world);\n    };\n  }, [getAnchorState, rectNow, registry, targetScale, camera, drawnLayers, rotationBadge, helpersRef]);\n\n  const classifyTarget = useMemo(() => {\n    const inner = buildClassifyTarget(\n      () => live.current.selection.get(),\n      (wx, wy) => {\n        const i = inputsRef.current;\n        // This view's camera: the dispatcher converted with `clientToWorldHere`,\n        // and a screen-pixel tolerance needs the scale that produced it. The\n        // layer gate is this view's too, never the surface's.\n        const frame = { ...camera(), layerIsPainted };\n        if (i?.pickBest) return i.pickBest(wx, wy, frame);\n        const ids = i?.pickEvery?.(wx, wy, frame) ?? [];\n        return ids.length > 0 ? ids[ids.length - 1]! : null;\n      },\n      (id) => inputsRef.current?.kindOfNode?.(id),\n    );\n    return (world: { x: number; y: number }) => inner(world);\n  }, [camera, layerIsPainted, live, inputsRef]);\n\n  const registration = useMemo<ViewRegistration>(() => ({\n    id,\n    order,\n    interactive,\n    paint,\n    layer: createViewportLayer<unknown, unknown>({\n      id,\n      label: label ?? id,\n      source: drawnLayers,\n      view: cameraAt,\n      bounds: (outer, dims) => rectAt(outer, dims),\n      // The surface half of the envelope passes through; the view half is\n      // this view's, so its layers paint its chrome rather than the\n      // surface's.\n      data: (outer) => ({ ...(outer as object), ...helpersRef.current, viewId: id }),\n      ...(background !== undefined ? { background } : {}),\n    }),\n    layerIsPainted,\n    target: {\n      dispatcher: dispatcherRef.current!,\n      affordanceAt,\n      classifyTarget,\n      clientToWorld: clientToWorldHere,\n      deps: () => ({\n        view: viewApi,\n        ingestion: ingestionApi,\n        // An Escape here cancels what is in flight here.\n        dispatcher: { cancelAll: (reason) => dispatcherRef.current!.cancelAll(reason) },\n        // Only a view with its own selection overlays that one; otherwise the\n        // surface's answer stands, wrappers (`selectable`) included.\n        ...(live.current.viewSelection ? { selection: live.current.viewSelection } : {}),\n      }),\n      // Action eligibility is chrome-caps evaluated against this view, so a\n      // rule that hides an action in one panel cannot decline a gesture in\n      // another.\n      getRuleCtx: () => inputsRef.current?.chromeCaps?.ruleCtx(ruleInputs()),\n    },\n  }), [id, order, interactive, paint, label, background, rectAt, cameraAt, viewApi,\n       affordanceAt, classifyTarget, clientToWorldHere, ruleInputs, ingestionApi, drawnLayers,\n       layerIsPainted, live, inputsRef, helpersRef]);\n\n  useEffect(() => {\n    if (!registry) return;\n    return registry.register(registration);\n  }, [registry, registration]);\n\n  // A camera change is invisible until the surface repaints, and nothing else\n  // observes this component's state.\n  useEffect(() => {\n    registry?.surface()?.requestRedraw();\n  }, [registry, effectiveView]);\n\n  return null;\n}\n"],"mappings":"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"}

package/dist/canvas/CursorCoordsHud.js

@@ -0,0 +1,75 @@
+import { useVisibleRaf as e } from "../scheduling/useVisibleRaf.js";
+import { clientToWorld as t } from "../core/viewport/clientToWorld.js";
+import n from "./hud.module.js";
+import { useHostAnchor as r } from "./useHostAnchor.js";
+import { useEffect as i, useRef as a, useState as o } from "react";
+import { jsxs as s } from "react/jsx-runtime";
+//#region src/canvas/CursorCoordsHud.tsx
+function c({ canvasRef: c, anchorRef: l, viewRef: u, offset: d }) {
+	let [f, p] = o({
+		client: {
+			x: 0,
+			y: 0
+		},
+		world: null,
+		inCanvas: !1
+	}), [m, h] = o(0), { ref: g, style: _ } = r(() => l?.current ?? c.current?.parentElement ?? c.current, {
+		align: {
+			x: "end",
+			y: "start"
+		},
+		offset: {
+			x: d?.right ?? 8,
+			y: d?.top ?? 8
+		}
+	}), v = a(0), y = a(0), b = e(() => {
+		v.current++;
+		let e = performance.now(), t = e - y.current;
+		t >= 1e3 && (h(Math.round(v.current * 1e3 / t)), v.current = 0, y.current = e), b.request();
+	}, { onResume: () => {
+		v.current = 0, y.current = performance.now();
+	} });
+	return i(() => (y.current = performance.now(), b.request(), () => b.cancel()), [b]), i(() => {
+		let e = (e) => {
+			let n = c.current, r = u.current, i = {
+				x: e.clientX,
+				y: e.clientY
+			};
+			if (!n || !r) {
+				p({
+					client: i,
+					world: null,
+					inCanvas: !1
+				});
+				return;
+			}
+			let a = n.getBoundingClientRect(), o = e.clientX >= a.left && e.clientX <= a.right && e.clientY >= a.top && e.clientY <= a.bottom, [s, l] = t(e.clientX, e.clientY, a, r);
+			p({
+				client: i,
+				world: {
+					x: s,
+					y: l
+				},
+				inCanvas: o
+			});
+		};
+		return document.addEventListener("pointermove", e), () => {
+			document.removeEventListener("pointermove", e);
+		};
+	}, [c, u]), _ ? /* @__PURE__ */ s("div", {
+		ref: g,
+		className: `${n.hud} ${n.pre}`,
+		style: _,
+		children: [
+			`fps    ${m.toString().padStart(3)}`,
+			"\n",
+			`client (${f.client.x.toFixed(0)}, ${f.client.y.toFixed(0)})`,
+			"\n",
+			f.world ? `world  (${f.world.x.toFixed(1)}, ${f.world.y.toFixed(1)})${f.inCanvas ? "" : "  (off-canvas)"}` : "world  — (no canvas/view yet)"
+		]
+	}) : null;
+}
+//#endregion
+export { c as CursorCoordsHud };
+
+//# sourceMappingURL=CursorCoordsHud.js.map

package/dist/canvas/CursorCoordsHud.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CursorCoordsHud.js","names":["s","hud_module_default","CursorCoordsHud","state","setState","useState","fps","setFps","anchorStyle","useHostAnchor","anchorRef","canvasRef","offset","framesRef","useRef","lastFlushRef","fpsLoop","useVisibleRaf","now","dt","useEffect","onMove","canvas","view","viewRef","client","rect","inCanvas","wx","wy","clientToWorld"],"sources":["../../src/canvas/CursorCoordsHud.tsx"],"sourcesContent":["/**\n * Fixed-position dev HUD that shows the cursor's current viewport\n * (client) coords next to the equivalent canvas (world) coords. Mounts\n * top-left of the viewport; listens to `document` pointermove so it\n * reads the cursor even when it leaves the canvas.\n *\n * Mount inside a `<SceneCanvas>` subtree (or anywhere with access to a\n * canvas + view ref) for quick coord-reconciliation during gesture\n * debugging.\n */\nimport { useEffect, useRef, useState } from 'react';\nimport { useVisibleRaf } from '../scheduling/useVisibleRaf';\nimport s from './hud.module.css';\nimport { useHostAnchor } from './useHostAnchor';\nimport type { View } from 'core/viewport/view';\nimport { clientToWorld } from 'core/viewport/clientToWorld';\n\n/** Props for `<CursorCoordsHud>`. */\nexport interface CursorCoordsHudProps {\n  canvasRef: React.RefObject<HTMLElement | null>;\n  /** Element the HUD pins its corner to. Defaults to the canvas's parent — the\n   *  wrapper a bare `<canvas>` sits in. A detached canvas passes its own input\n   *  box, whose parent is the shared surface every pane sits in. */\n  anchorRef?: React.RefObject<HTMLElement | null>;\n  viewRef: React.RefObject<View>;\n  /** Inset from the canvas's top-right corner, in px. Default 8 on both axes. */\n  offset?: { top?: number; right?: number };\n}\n\ninterface HudState {\n  client: { x: number; y: number };\n  world: { x: number; y: number } | null;\n  inCanvas: boolean;\n}\n\n/** Debug overlay showing the pointer's client and world coordinates and the\n *  current frame rate, pinned to the canvas's top-right corner. */\nexport function CursorCoordsHud({ canvasRef, anchorRef, viewRef, offset }: CursorCoordsHudProps) {\n  const [state, setState] = useState<HudState>({\n    client: { x: 0, y: 0 }, world: null, inCanvas: false,\n  });\n  const [fps, setFps] = useState<number>(0);\n  const { ref, style: anchorStyle } = useHostAnchor(\n    () => anchorRef?.current ?? canvasRef.current?.parentElement ?? canvasRef.current,\n    {\n      align: { x: 'end', y: 'start' },\n      offset: { x: offset?.right ?? 8, y: offset?.top ?? 8 },\n    },\n  );\n\n  // FPS counter: tally frames per rAF tick; flush once a second.\n  const framesRef = useRef(0);\n  const lastFlushRef = useRef(0);\n  const fpsLoop = useVisibleRaf(\n    () => {\n      framesRef.current++;\n      const now = performance.now();\n      const dt = now - lastFlushRef.current;\n      if (dt >= 1000) {\n        setFps(Math.round((framesRef.current * 1000) / dt));\n        framesRef.current = 0;\n        lastFlushRef.current = now;\n      }\n      fpsLoop.request();\n    },\n    // Frames not drawn while hidden are not frames that were slow to draw:\n    // without this the readout would flush a near-zero rate on resume.\n    {\n      onResume: () => {\n        framesRef.current = 0;\n        lastFlushRef.current = performance.now();\n      },\n    },\n  );\n\n  useEffect(() => {\n    lastFlushRef.current = performance.now();\n    fpsLoop.request();\n    return () => fpsLoop.cancel();\n  }, [fpsLoop]);\n\n  useEffect(() => {\n    const onMove = (e: PointerEvent) => {\n      const canvas = canvasRef.current;\n      const view = viewRef.current;\n      const client = { x: e.clientX, y: e.clientY };\n      if (!canvas || !view) {\n        setState({ client, world: null, inCanvas: false });\n        return;\n      }\n      const rect = canvas.getBoundingClientRect();\n      const inCanvas =\n        e.clientX >= rect.left && e.clientX <= rect.right &&\n        e.clientY >= rect.top  && e.clientY <= rect.bottom;\n      const [wx, wy] = clientToWorld(e.clientX, e.clientY, rect, view);\n      const world = { x: wx, y: wy };\n      setState({ client, world, inCanvas });\n    };\n\n    document.addEventListener('pointermove', onMove);\n\n    return () => {\n      document.removeEventListener('pointermove', onMove);\n    };\n  }, [canvasRef, viewRef]);\n\n  if (!anchorStyle) return null;\n\n  return (\n    <div\n      ref={ref}\n      className={`${s.hud} ${s.pre}`}\n      style={anchorStyle}\n    >\n      {`fps    ${fps.toString().padStart(3)}`}\n      {'\\n'}\n      {`client (${state.client.x.toFixed(0)}, ${state.client.y.toFixed(0)})`}\n      {'\\n'}\n      {state.world\n        ? `world  (${state.world.x.toFixed(1)}, ${state.world.y.toFixed(1)})${state.inCanvas ? '' : '  (off-canvas)'}`\n        : 'world  — (no canvas/view yet)'}\n    </div>\n  );\n}\n"],"mappings":";;;;;;;AAqCA,SAAgBE,EAAgB,EAAE,cAAW,cAAW,YAAS,aAAgC;CAC/F,IAAM,CAACC,GAAOC,KAAYC,EAAmB;EAC3C,QAAQ;GAAE,GAAG;GAAG,GAAG;EAAE;EAAG,OAAO;EAAM,UAAU;CACjD,CAAC,GACK,CAACC,GAAKC,KAAUF,EAAiB,CAAC,GAClC,EAAE,QAAK,OAAOG,MAAgBC,QAC5BC,GAAW,WAAWC,EAAU,SAAS,iBAAiBA,EAAU,SAC1E;EACE,OAAO;GAAE,GAAG;GAAO,GAAG;EAAQ;EAC9B,QAAQ;GAAE,GAAGC,GAAQ,SAAS;GAAG,GAAGA,GAAQ,OAAO;EAAE;CACvD,CACF,GAGMC,IAAYC,EAAO,CAAC,GACpBC,IAAeD,EAAO,CAAC,GACvBE,IAAUC,QACR;EACJ,EAAU;EACV,IAAMC,IAAM,YAAY,IAAI,GACtBC,IAAKD,IAAMH,EAAa;EAM9B,AALII,KAAM,QACRZ,EAAO,KAAK,MAAOM,EAAU,UAAU,MAAQM,CAAE,CAAC,GAClD,EAAU,UAAU,GACpB,EAAa,UAAUD,IAEzBF,EAAQ,QAAQ;CAClB,GAGA,EACE,gBAAgB;EAEd,AADA,EAAU,UAAU,GACpB,EAAa,UAAU,YAAY,IAAI;CACzC,EACF,CACF;CAmCA,OAjCAI,SACE,EAAa,UAAU,YAAY,IAAI,GACvCJ,EAAQ,QAAQ,SACHA,EAAQ,OAAO,IAC3B,CAACA,CAAO,CAAC,GAEZI,QAAgB;EACd,IAAMC,KAAU,MAAoB;GAClC,IAAMC,IAASX,EAAU,SACnBY,IAAOC,EAAQ,SACfC,IAAS;IAAE,GAAG,EAAE;IAAS,GAAG,EAAE;GAAQ;GAC5C,IAAI,CAACH,KAAU,CAACC,GAAM;IACpB,EAAS;KAAE;KAAQ,OAAO;KAAM,UAAU;IAAM,CAAC;IACjD;GACF;GACA,IAAMG,IAAOJ,EAAO,sBAAsB,GACpCK,IACJ,EAAE,WAAWD,EAAK,QAAQ,EAAE,WAAWA,EAAK,SAC5C,EAAE,WAAWA,EAAK,OAAQ,EAAE,WAAWA,EAAK,QACxC,CAACE,GAAIC,KAAMC,EAAc,EAAE,SAAS,EAAE,SAASJ,GAAMH,CAAI;GAE/D,EAAS;IAAE;IAAQ,OAAA;KADH,GAAGK;KAAI,GAAGC;IACP;IAAO;GAAS,CAAC;EACtC;EAIA,OAFA,SAAS,iBAAiB,eAAeR,CAAM,SAElC;GACX,SAAS,oBAAoB,eAAeA,CAAM;EACpD;CACF,GAAG,CAACV,GAAWa,CAAO,CAAC,GAElBhB,IAGH,kBAAC,OAAD;EACO;EACL,WAAW,GAAGR,EAAE,IAAI,GAAGA,EAAE;EACzB,OAAOQ;EAHT,UAAA;GAKG,UAAUF,EAAI,SAAS,CAAC,CAAC,SAAS,CAAC;GACnC;GACA,WAAWH,EAAM,OAAO,EAAE,QAAQ,CAAC,EAAE,IAAIA,EAAM,OAAO,EAAE,QAAQ,CAAC,EAAE;GACnE;GACAA,EAAM,QACH,WAAWA,EAAM,MAAM,EAAE,QAAQ,CAAC,EAAE,IAAIA,EAAM,MAAM,EAAE,QAAQ,CAAC,EAAE,GAAGA,EAAM,WAAW,KAAK,qBAC1F;EACD;MAfkB;AAiB3B"}