@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/SceneCanvas.js.map

@@ -1 +1 @@
-{"version":3,"file":"SceneCanvas.js","names":["canvasDebug","debug","_slops","rest","SceneCanvasInner","sceneInput","selectToolOpts","selectionProp","toolsProp","viewDescriptors","getFocusedProp","redrawOnProp","restProps","props","descriptor","poseDescriptor","AUTO_POSE_DESCRIPTOR","deviceProfile","useDeviceProfile","bakedScene","useState","isSerializedScene","sceneFromJSON","scene","getActiveMode","useMemo","modes","getActiveModeFor","heldModifiers","useHeldModifiers","redrawOn","useSceneRedrawSources","internalCanvasRef","useRef","canvasApiRef","dlog","useCanvasCamera","viewState","viewportZoomProp","viewport","animatedZoom","resolvedViewportZoom","viewportZoomOption","selection","useCanvasSelection","selectionOptions","pathEditState","usePathEditState","pathEdit","isSelectedNode","id","selectToolWithDefaults","selectionRef","useLatest","useNodeKinds","routing","composedAlphaFor","composeAlphaFor","alphaFor","viewLayerGate","useViewLayerGate","layerVisibility","layerOrder","adapter","useSceneAdapter","internalSelect","internalPickEvery","internalPickBest","internalBoundsOf","internalBoundsOfPose","internalPlaneOfNode","internalMoveOptions","useSceneSelectTool","viewRef","getNodeAtPoint","useNodeAtPoint","enabled","useEnabledFeatures","features","internalTools","toolsTakeover","useCanvasTools","longPress","featureContributions","useFeatureBindings","getNodeAtPointRef","onDoubleClickObserver","useHitObserver","onDoubleClick","onClickObserver","onClick","rotateOff","resolvedActions","actionsMuting","actions","actionsRegistry","useActionsRegistry","useCanvasDispatcher","wiredLayers","useSceneCanvasLayers","animator","previewIdsExtra","trackHoverOn","useSceneHover","chromeVisibility","chromeRules","useChromeRules","getIsVisibleForCanvas","getRuleCtxForCanvas","useSurfaceChromeCaps","ingestionClipboard","useCanvasIngestion","ingestion","addedViews","useAddedViews","canvasReady","useSceneCanvasHandle","viewInputs","kindOfNode","chromeCaps","rotationBadge","useTestHook","tools","ViewInputsProvider","PointerProviderIfRoot","Canvas","handleRef","DevHuds","cursorCoordsHud","pickHud","modalityHud","PointerPublisher","StandardActionsRegistrar","standardActionsExclude","toolOptions","GestureDispatcherMounter","enableGestureDispatcher","enableKeybindings","ToolKeybindingsMounter","CanvasView","v","i","contributionEntries","children","SceneCanvasInnerForwardRef","forwardRef","SceneCanvasWrapper","InputScope","DeviceProfileProvider","device","ViewRegistryProvider","SceneCanvas","BUILTIN_TOOL_IDS","DEFAULT_HANDLE_SIZE","SCENE_CANVAS_FEATURES","rotateAroundAABBCenter"],"sources":["../../src/canvas/SceneCanvas.tsx"],"sourcesContent":["/**\n * `<SceneCanvas>` — `<Canvas>` wired to a `Scene` primitive. Bare, it only renders: behavior\n * comes from the `features` presets (`canvas/SceneCanvas/features.ts`), each of which turns on\n * its own actions, tools, ambient bindings, and chrome.\n *\n * A consumer needing custom tools can pass `tools={useTools(...)}` and SceneCanvas forwards it\n * as-is — the internal tool registry is ignored in that case.\n */\nimport { getActiveModeFor } from '@weasel-js/modes';\nimport { useLatest } from '@weasel-js/react';\nimport type { ActionsProp } from '@weasel-js/routing';\nimport { InputScope, useActionsRegistry } from '@weasel-js/routing/react';\nimport { sceneFromJSON } from 'core/scene/scene';\nimport { isSerializedScene } from 'core/scene/serialization';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { useCanvasCamera } from './SceneCanvas/useCanvasCamera';\nimport { useHeldModifiers } from './SceneCanvas/useHeldModifiers';\nimport { useCanvasIngestion } from 'features/ingestion/useCanvasIngestion';\nimport { isSelectedNode } from 'features/paths/pathEditState';\nimport { usePathEditState } from 'features/paths/usePathEdit';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { UseResizeOptions } from 'interactions/actions/resize/options';\nimport type React from 'react';\nimport { forwardRef, useEffect, useMemo, useRef, useState } from 'react';\nimport { DeviceProfileProvider, useDeviceProfile } from '../core/device/useDeviceProfile';\nimport { dlog } from '../debug/flag';\nimport type { DebugConfig } from '../debug/types';\nimport type { ReflowTransition } from '../layout/types';\nimport { useTestHook } from '../test-hook/useTestHook';\nimport { Canvas } from './Canvas';\nimport { CanvasView } from './CanvasView';\nimport { DevHuds } from './SceneCanvas/DevHuds';\nimport { GestureDispatcherMounter } from './SceneCanvas/GestureDispatcherMounter';\nimport { PointerProviderIfRoot, PointerPublisher } from './SceneCanvas/PointerProviderIfRoot';\nimport { StandardActionsRegistrar } from './SceneCanvas/StandardActionsRegistrar';\nimport { ToolKeybindingsMounter } from './SceneCanvas/ToolKeybindingsMounter';\nimport type { FeatureBindingOptions } from './SceneCanvas/features';\nimport type { BridgeAdapter, SceneCanvasProps } from './SceneCanvas/props';\nimport { actionsMuting } from './SceneCanvas/useActionsPropResolver';\nimport { useCanvasDispatcher } from './SceneCanvas/useCanvasDispatcher';\nimport { useCanvasSelection } from './SceneCanvas/useCanvasSelection';\nimport { useCanvasTools, useEnabledFeatures, useFeatureBindings } from './SceneCanvas/useCanvasTools';\nimport { contributionEntries } from './SceneCanvas/useContributionRoles';\nimport { useNodeAtPoint } from './SceneCanvas/useNodeAtPoint';\nimport { useNodeKinds } from './SceneCanvas/useNodeKinds';\nimport { useAddedViews, useSceneCanvasHandle } from './SceneCanvas/useSceneCanvasHandle';\nimport { useSceneCanvasLayers } from './SceneCanvas/useSceneCanvasLayers';\nimport { useChromeRules, useSceneHover, useSurfaceChromeCaps } from './SceneCanvas/useSceneChrome';\nimport { useSceneRedrawSources } from './SceneCanvas/useSceneRedrawSources';\nimport { useSceneSelectTool } from './SceneCanvas/useSceneSelectTool';\nimport { useViewLayerGate } from './SceneCanvas/useViewLayerGate';\nimport { viewportZoomOption } from './SceneCanvas/useViewportActions';\nimport type { CanvasExtensionApi, SceneCanvasApi } from './canvasExtension';\nimport { useSceneAdapter } from './useSceneAdapter';\nimport { composeAlphaFor } from './sceneSlotWiring';\nimport { useHitObserver } from './useHitObserver';\nimport { ViewInputsProvider, type SurfaceViewInputs } from './viewInputs';\nimport { ViewRegistryProvider } from './viewRegistry';\nexport { SCENE_CANVAS_FEATURES } from './SceneCanvas/features';\nexport type { Feature } from './SceneCanvas/features';\nexport type { BuiltinToolOptions } from './SceneCanvas/useBuiltinShapeTools';\nexport { defaultDrawOne } from './defaultDrawOne';\nexport { rotateAroundAABBCenter } from './poseRotation';\n\n/** `<SceneCanvas debug>` minus the flag only SceneCanvas reads. */\nfunction canvasDebug(debug: (DebugConfig & { slops?: boolean }) | false): DebugConfig | false {\n  if (debug === false) return false;\n  const { slops: _slops, ...rest } = debug;\n  return rest;\n}\n\nfunction SceneCanvasInner<TData, TLayer extends string, TPose>(\n  props: SceneCanvasProps<TData, TLayer, TPose>,\n  ref: React.ForwardedRef<SceneCanvasApi>,\n) {\n  const {\n    scene: sceneInput,\n    geometry,\n    poseDescriptor,\n    selectTool: selectToolOpts,\n    insertNodeFactories,\n    insertPaint,\n    ingestion,\n    layoutDropTarget,\n    reflowTransition,\n    geometryProjection,\n    routing,\n    selection: selectionProp,\n    selectionOptions,\n    selectable = true,\n    tools: toolsProp,\n    features,\n    enableKeybindings = true,\n    claimKeys = false,\n    enableGestureDispatcher = true,\n    onToolsCreated,\n    defaultTools,\n    toolOptions,\n    initialActiveTool,\n    ambient,\n    versionCheck,\n    longPress,\n    viewport,\n    layers,\n    actions, tune,\n    describeKind,\n    animator,\n    views: viewDescriptors,\n    children,\n    debug,\n    alphaFor,\n    layerVisibility,\n    layerOrder,\n    isPointerInteractive,\n    onDoubleClick,\n    onClick,\n    chromeVisibility,\n    modes,\n    pathEdit,\n    getFocused: getFocusedProp,\n    cursorCoordsHud, pickHud, modalityHud,\n    view, onViewChange, defaultView, viewBounds, redrawOn: redrawOnProp,\n    ...restProps\n  } = props;\n\n  const descriptor = (poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const deviceProfile = useDeviceProfile();\n\n  // `scene` accepts either a live `Scene` or a `SerializedScene` JSON object. JSON is baked\n  // once; later prop changes are ignored (use a `key` on `<SceneCanvas>` to force a fresh canvas).\n  const [bakedScene] = useState<Scene<TData, TLayer, TPose> | null>(\n    () => (isSerializedScene<TData, TLayer, TPose>(sceneInput) ? sceneFromJSON(sceneInput, {}) : null),\n  );\n  const scene = bakedScene ?? (sceneInput as Scene<TData, TLayer, TPose>);\n\n  const getActiveMode = useMemo(() => (modes ? getActiveModeFor(modes) : undefined), [modes]);\n  const heldModifiers = useHeldModifiers();\n  const redrawOn = useSceneRedrawSources({ supplied: redrawOnProp, scene, heldModifiers, animator, modes });\n\n  // The canvas element, kept here so the dispatcher can attach its input listeners even when\n  // the consumer passes their own forwarded ref, and the full handle, for `requestRedraw`.\n  const internalCanvasRef = useRef<HTMLElement | null>(null);\n  const canvasApiRef = useRef<CanvasExtensionApi | null>(null);\n\n  useEffect(() => {\n    dlog('scene-canvas', 'mount');\n    return () => dlog('scene-canvas', 'unmount');\n  }, []);\n\n  const { viewState, viewAnimation, camera } = useCanvasCamera({\n    view, defaultView, onViewChange, viewBounds,\n    width: restProps.width,\n    height: restProps.height,\n    requestRedraw: () => { canvasApiRef.current?.requestRedraw(); },\n  });\n  const { viewRef } = viewState;\n\n  const viewportZoomProp = viewport?.zoom;\n  const animatedZoom = viewport?.animatedZoom;\n  const resolvedViewportZoom = useMemo(\n    () => viewportZoomOption(viewportZoomProp, animatedZoom),\n    [viewportZoomProp, animatedZoom],\n  );\n\n  const selection = useCanvasSelection({\n    scene, supplied: selectionProp, options: selectionOptions, selectable, describeKind,\n  });\n\n  // `isAllowed` is absent, not a predicate, when no mode registry is wired:\n  // see `PathEditSource.isAllowed`.\n  const pathEditState = usePathEditState({\n    host: pathEdit,\n    isAllowed: getActiveMode\n      ? () => getActiveMode().allowedCapabilities.has('edits-anchors')\n      : undefined,\n    isSelectedNode: (id) => isSelectedNode(scene, selection, id),\n  });\n\n  const selectToolWithDefaults = useMemo(() => ({\n    // Shift-click belongs to the anchor selection while a path is being\n    // anchor-edited; see `UseSelectToolOptions.extendClickLocked`.\n    extendClickLocked: () => pathEditState.getEditingId() !== '',\n    ...selectToolOpts,\n  }), [selectToolOpts, pathEditState]);\n\n  const selectionRef = useLatest(selection);\n  const { kindOfData, kindOfNode } = useNodeKinds(scene, routing);\n\n  // The painted alpha of a node in this view: the caller's `alphaFor` times any per-node\n  // override alpha. The pick path reads the same number the painter does, or a node faded\n  // to nothing stays clickable.\n  const composedAlphaFor = useMemo(\n    () => composeAlphaFor(scene, alphaFor),\n    [scene, alphaFor],\n  );\n  const viewLayerGate = useViewLayerGate(layerVisibility, layerOrder);\n\n  const adapter = useSceneAdapter(scene, {\n    // `adapterMethods` is memoized; `selection` itself is a fresh object each render.\n    selection: selection.adapterMethods,\n    poseDescriptor: descriptor,\n  });\n\n  const {\n    selectTool: internalSelect, pickEvery: internalPickEvery, pickBest: internalPickBest,\n    boundsOf: internalBoundsOf, boundsOfPose: internalBoundsOfPose, planeOfNode: internalPlaneOfNode,\n    moveOptions: internalMoveOptions,\n  } = useSceneSelectTool({\n    scene,\n    adapter,\n    poseDescriptor: descriptor,\n    geometry,\n    // The pick tolerance is declared in screen pixels; this is what converts it.\n    getView: () => viewRef.current,\n    // Only when the consumer actually fades something. Without a prop the\n    // composed function is just the override lookup, and the source resolves\n    // that once per walk instead of once per candidate.\n    ...(alphaFor ? { alphaOf: composedAlphaFor } : {}),\n    ...(viewLayerGate ? { layerIsPainted: viewLayerGate } : {}),\n    selectTool: selectToolWithDefaults,\n  });\n\n  const getNodeAtPoint = useNodeAtPoint({\n    pickBest: internalPickBest, nodes: adapter, kindOfData, isPointerInteractive,\n  });\n\n  const enabled = useEnabledFeatures(features, viewport !== undefined);\n  const { tools, internal: internalTools, takeover: toolsTakeover } = useCanvasTools({\n    select: internalSelect,\n    enabled,\n    tools: toolsProp,\n    defaultTools,\n    toolOptions,\n    inertia: viewport?.inertia,\n    ambient,\n    pressFeedback: longPress?.feedback,\n    initialActiveTool,\n    modes,\n    onToolsCreated,\n  });\n  const { contributions: featureContributions, standardActionsExclude } = useFeatureBindings({\n    enabled,\n    tools,\n    move: internalMoveOptions as FeatureBindingOptions['move'],\n    rotate: (selectToolOpts?.rotate || undefined) as FeatureBindingOptions['rotate'],\n  });\n\n  // Rides the gesture dispatcher as an OBSERVER rather than an Action binding because the\n  // prop is a notification, not a behavior: as a binding it would lose first-match-wins to\n  // `enterPathEdit` on every body hit and silently stop firing.\n  const getNodeAtPointRef = useLatest(getNodeAtPoint);\n  const onDoubleClickObserver = useHitObserver(onDoubleClick, getNodeAtPointRef);\n  const onClickObserver = useHitObserver(onClick, getNodeAtPointRef);\n\n  // `selectTool.rotate === false` disables rotation: its action is muted here and its\n  // handle hidden by `useChromeRules`.\n  const rotateOff = selectToolOpts?.rotate === false;\n  const resolvedActions = useMemo<ActionsProp | undefined>(\n    () => (rotateOff ? actionsMuting(actions, 'rotate') : actions),\n    [actions, rotateOff],\n  );\n\n  // The wrapper's `<InputScope>` provides it.\n  const actionsRegistry = useActionsRegistry();\n  const { dispatcher, gestureSource, previewIdsExtra, previewPoseExtra } = useCanvasDispatcher(actionsRegistry);\n\n  const { layers: wiredLayers, rotationBadge, chromeAffordancesRef } = useSceneCanvasLayers({\n    layers,\n    targetScale: deviceProfile.targetScale,\n    scene,\n    adapter,\n    poseDescriptor: descriptor,\n    alphaFor,\n    colorOverrides: animator?.colorOverrides,\n    boundsOf: internalBoundsOf,\n    planeOfNode: internalPlaneOfNode,\n    previewIds: previewIdsExtra,\n    dispatcher,\n    pathEditState,\n    slops: debug !== undefined && debug !== false && debug.slops === true,\n  });\n\n  const { getHover, canvasRef: trackHoverOn } = useSceneHover({\n    canvasApiRef, viewRef, nodeAtPointRef: getNodeAtPointRef, enabled: chromeVisibility !== undefined,\n  });\n  const chromeRules = useChromeRules({ enabled, selectable, rotateOff, chromeVisibility });\n  const { chromeCaps, getIsVisible: getIsVisibleForCanvas, getRuleCtx: getRuleCtxForCanvas } = useSurfaceChromeCaps({\n    source: {\n      rules: chromeRules,\n      getMode: getActiveMode,\n      getFocused: getFocusedProp,\n      getHover,\n      getModifiers: heldModifiers.get,\n      resizable: selectToolOpts?.resize?.resizable,\n      editingAnchors: () => pathEditState.getEditingId() !== '',\n      device: deviceProfile,\n    },\n    selection: selection.current as readonly NodeId[],\n    viewRef,\n    dispatcher,\n  });\n\n  const { ingest, clipboard: ingestionClipboard } = useCanvasIngestion(\n    adapter, () => actionsRegistry, ingestion,\n  );\n\n  const { views: addedViews, addView } = useAddedViews();\n  // The consumer's handle extends the primitive's with `ingest`, which needs the action stack.\n  const { handleRef, ready: canvasReady } = useSceneCanvasHandle({\n    ref, elementRef: internalCanvasRef, apiRef: canvasApiRef, onElement: trackHoverOn,\n    ingest, viewAnimation, camera, addView,\n  });\n\n  // What a view needs to build its own overlay-aware state. `geometry` is the\n  // same descriptor handed to `<Canvas>`, so the two cannot diverge.\n  const viewInputs = useMemo<SurfaceViewInputs>(() => ({\n    adapter: adapter as unknown as { getPose(id: string): unknown },\n    geometry: descriptor as PoseDescriptor<unknown>,\n    boundsOf: internalBoundsOf,\n    boundsOfPose: internalBoundsOfPose as SurfaceViewInputs['boundsOfPose'],\n    planeOfNode: internalPlaneOfNode,\n    pickEvery: internalPickEvery,\n    pickBest: internalPickBest,\n    kindOfNode,\n    chromeCaps,\n    selectionApi: selection,\n    rotationBadge,\n  }), [adapter, descriptor, internalBoundsOf, internalBoundsOfPose, internalPlaneOfNode,\n       internalPickEvery, internalPickBest, kindOfNode, chromeCaps, selection, rotationBadge]);\n\n  useTestHook({\n    getScene: () => scene as never,\n    getSelectionIds: () => (selection.current as readonly string[] | undefined) ?? [],\n    getView: () => viewRef.current,\n    getActiveToolId: () => tools.active ?? null,\n  });\n\n  return (\n    <ViewInputsProvider value={viewInputs}>\n      <PointerProviderIfRoot>\n        <Canvas<TPose>\n          ref={handleRef}\n          adapter={adapter}\n          selection={selection}\n          poseDescriptor={descriptor}\n          tools={tools}\n          layers={wiredLayers}\n          // The chrome's bounds are the picker's: a node on a parallax plane is\n          // boxed where the plane draws it, and a `geometry.boundsOf` reaches both.\n          boundsOf={internalBoundsOf}\n          boundsOfPose={internalBoundsOfPose}\n          getIsVisible={getIsVisibleForCanvas}\n          // The gesture surface behind `helpersRef.getGestureBounds()` /\n          // `subscribeGestures()` — Canvas has no dispatcher of its own.\n          gestureSource={gestureSource}\n          previewPoseExtra={previewPoseExtra}\n          {...(debug !== undefined ? { debug: canvasDebug(debug) } : {})}\n          contentVersion={scene.getVersion}\n          layerVisibility={layerVisibility}\n          layerOrder={layerOrder}\n          viewState={viewState}\n          redrawOn={redrawOn}\n          {...restProps}\n        />\n        <DevHuds\n          cursorCoords={cursorCoordsHud}\n          pick={pickHud}\n          modality={modalityHud}\n          canvasRef={internalCanvasRef}\n          canvasApiRef={canvasApiRef}\n          detachedInput={restProps.paintInto ? restProps.inputElement ?? null : undefined}\n          viewRef={viewRef}\n          pickEvery={internalPickEvery}\n          pickBest={internalPickBest}\n        />\n        <PointerPublisher canvasRef={internalCanvasRef} canvasApiRef={canvasApiRef} />\n        <StandardActionsRegistrar\n          selection={selection}\n          scene={scene}\n          adapter={adapter as unknown as BridgeAdapter}\n          actions={resolvedActions} tune={tune}\n          excludeActions={standardActionsExclude}\n          currentViewRef={viewRef}\n          onViewChange={viewState.setViewFromInput}\n          resizeOptions={selectToolOpts?.resize as UseResizeOptions<unknown> | undefined}\n          poseDescriptor={descriptor as PoseDescriptor<unknown>}\n          geometryProjection={geometryProjection}\n          dispatcher={dispatcher}\n          pickEvery={internalPickEvery}\n          layerIsPainted={viewLayerGate}\n          alphaOf={alphaFor ? composedAlphaFor : undefined}\n          viewportPanEnabled={enabled.has('view') ? (viewport?.pan ?? true) : false}\n          viewportZoom={enabled.has('view') ? resolvedViewportZoom : false}\n          viewportPinchZoom={enabled.has('view') ? (viewport?.pinchZoom ?? true) : false}\n          viewportRecenter={viewport?.recenter}\n          viewAnimation={viewAnimation}\n          editAnchorsExternalState={pathEditState}\n          layoutDropTarget={layoutDropTarget}\n          reflowTransition={reflowTransition as ReflowTransition<unknown> | null | undefined}\n          insertNodeFactories={insertNodeFactories}\n          insertPaint={insertPaint}\n          snapPoint={toolOptions?.snapPoint}\n          canvasRef={internalCanvasRef}\n          canvasApiRef={canvasApiRef}\n          ingestionResolveSrc={ingestion?.resolveSrc}\n          ingestionSvg={ingestion?.svg}\n          ingestionClipboard={ingestionClipboard}\n        />\n        <GestureDispatcherMounter\n          canvasRef={internalCanvasRef}\n          canvasApiRef={canvasApiRef}\n          tools={tools}\n          contributions={featureContributions}\n          enabled={enableGestureDispatcher}\n          keyboard={enableKeybindings}\n          claimKeys={claimKeys}\n          selectionRef={selectionRef}\n          boundsOf={internalBoundsOf}\n          planeOfNode={internalPlaneOfNode}\n          pickEvery={internalPickEvery}\n          pickBest={internalPickBest}\n          kindOfNode={kindOfNode}\n          viewRef={viewRef}\n          dispatcher={dispatcher}\n          getIsVisibleForCanvas={getIsVisibleForCanvas}\n          getRuleCtx={getRuleCtxForCanvas}\n          targetScale={deviceProfile.targetScale}\n          handleHitRadius={selectToolOpts?.handleHitRadius}\n          rotationBadge={rotationBadge}\n          chromeAffordancesRef={chromeAffordancesRef}\n          onDoubleClick={onDoubleClickObserver}\n          onClick={onClickObserver}\n          longPress={longPress}\n        />\n        <ToolKeybindingsMounter\n          internalTools={internalTools}\n          toolsTakeover={toolsTakeover ?? undefined}\n          enableKeybindings={enableKeybindings}\n          modes={modes}\n          canvasApi={canvasReady ? canvasApiRef.current : null}\n          versionCheck={versionCheck}\n        />\n        {viewDescriptors?.map((v, i) => (\n          <CanvasView key={v.id} {...v} order={v.order ?? i} />\n        ))}\n        {contributionEntries(tools).flatMap((e) => e.views ?? []).map((v) => (\n          <CanvasView key={`contribution:${v.id}`} {...v} />\n        ))}\n        {addedViews.map((v) => <CanvasView key={`added:${v.id}`} {...v} />)}\n        {children}\n      </PointerProviderIfRoot>\n    </ViewInputsProvider>\n  );\n}\n\nconst SceneCanvasInnerForwardRef = forwardRef(SceneCanvasInner);\n\n// The canvas's input scope sits above `SceneCanvasInner`, whose own hooks\n// (`useTools` among them) must already read this canvas's tool and registries.\n// Its device profile too, so the canvas and everything under it share one.\nfunction SceneCanvasWrapper<TData, TLayer extends string, TPose>(\n  { device, ...props }: SceneCanvasProps<TData, TLayer, TPose>,\n  ref: React.ForwardedRef<SceneCanvasApi>,\n) {\n  return (\n    <InputScope yoke={props.yoke}>\n      <DeviceProfileProvider value={device}>\n        <ViewRegistryProvider>\n          <SceneCanvasInnerForwardRef {...(props as SceneCanvasProps<unknown, string, unknown>)} ref={ref} />\n        </ViewRegistryProvider>\n      </DeviceProfileProvider>\n    </InputScope>\n  );\n}\n\n/**\n * The canvas component: renders a `Scene` and wires the interaction stack\n * around it.\n *\n * Mounted bare it renders the scene, keeps a selection no input sets, and\n * runs a gesture dispatcher for whatever bindings the consumer adds. The\n * `features` presets turn the kit's behavior on — `features={['draw']}` is the\n * whole editor: tools, standard actions and their keys, selection chrome,\n * undo. This is the intended entry point; the lower-level primitives it\n * composes are not part of the public surface.\n *\n * Its ref exposes a `SceneCanvasApi` for the imperative operations that do not\n * fit a prop (view control, hit queries, redraw requests).\n */\nexport const SceneCanvas = forwardRef(SceneCanvasWrapper) as <\n  TData, TLayer extends string, TPose,\n>(\n  props: SceneCanvasProps<TData, TLayer, TPose> & { ref?: React.Ref<SceneCanvasApi> },\n) => ReturnType<typeof SceneCanvasInner>;\n\nexport { DEFAULT_HANDLE_SIZE, mergeLayersWithDefaults, BUILTIN_TOOL_IDS } from './SceneCanvas/props';\nexport type {\n  SceneCanvasProps,\n  SceneCanvasHit,\n  SceneCanvasLayers,\n  SceneCanvasLongPress,\n  BuiltinToolId,\n} from './SceneCanvas/props';\nexport type { CoordTraceEntry } from './SceneCanvas/coordTrace';\n"],"mappings":"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"}
+{"version":3,"file":"SceneCanvas.js","names":[],"sources":["../../src/canvas/SceneCanvas.tsx"],"sourcesContent":["/**\n * `<SceneCanvas>` — `<Canvas>` wired to a `Scene` primitive. Bare, it only renders: behavior\n * comes from the `features` presets (`canvas/SceneCanvas/features.ts`), each of which turns on\n * its own actions, tools, ambient bindings, and chrome.\n *\n * A consumer needing custom tools can pass `tools={useTools(...)}` and SceneCanvas forwards it\n * as-is — the internal tool registry is ignored in that case.\n */\nimport { getActiveModeFor } from '@weasel-js/modes';\nimport { useLatest } from '@weasel-js/react';\nimport { InputScope, useActionsRegistry } from '@weasel-js/routing/react';\nimport type { NodeId, Scene } from 'core/scene/types';\nimport { useCanvasCamera } from './SceneCanvas/useCanvasCamera';\nimport { useHeldModifiers } from './SceneCanvas/useHeldModifiers';\nimport { useCanvasIngestion } from 'features/ingestion/useCanvasIngestion';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type React from 'react';\nimport { forwardRef, useMemo, useRef } from 'react';\nimport { DeviceProfileProvider, useDeviceProfile } from '../core/device/useDeviceProfile';\nimport { Canvas } from './Canvas';\nimport { CanvasView } from './CanvasView';\nimport { canvasDebug, DevHuds } from './SceneCanvas/DevHuds';\nimport { CanvasKitProviders } from './SceneCanvas/CanvasKitProviders';\nimport { canvasPassThrough } from './SceneCanvas/canvasPassThrough';\nimport { SceneCanvasInput, type SceneCanvasInputOptions } from './SceneCanvas/SceneCanvasInput';\nimport type { PresetSource } from './SceneCanvas/features';\nimport { CORE_PRESET_SOURCE } from './SceneCanvas/namedPresets';\nimport type { BridgeAdapter, SceneCanvasProps } from './SceneCanvas/props';\nimport { useBakedScene } from './SceneCanvas/useBakedScene';\nimport { useCanvasDispatcher } from './SceneCanvas/useCanvasDispatcher';\nimport { useCanvasSelection } from './SceneCanvas/useCanvasSelection';\nimport { useEnabledFeatures } from './SceneCanvas/useCanvasTools';\nimport { contributionEntries } from './SceneCanvas/useContributionRoles';\nimport { useAddedViews, useSceneCanvasHandle } from './SceneCanvas/useSceneCanvasHandle';\nimport { useSceneCanvasLayers } from './SceneCanvas/useSceneCanvasLayers';\nimport { useSceneCanvasPathEdit } from './SceneCanvas/useSceneCanvasPathEdit';\nimport { useSceneCanvasTools, type SceneCanvasToolProps } from './SceneCanvas/useSceneCanvasTools';\nimport { useSceneCanvasChrome } from './SceneCanvas/useSceneChrome';\nimport { useSceneRedrawSources } from './SceneCanvas/useSceneRedrawSources';\nimport { useScenePicking } from './SceneCanvas/useScenePicking';\nimport { useSurfaceViewInputs } from './SceneCanvas/useSurfaceViewInputs';\nimport type { CanvasExtensionApi, SceneCanvasApi } from './canvasExtension';\nimport { ViewRegistryProvider } from './viewRegistry';\nexport { SCENE_CANVAS_FEATURES, type Feature } from './SceneCanvas/features';\nexport type { BuiltinToolOptions } from './SceneCanvas/useBuiltinShapeTools';\nexport { defaultDrawOne } from './defaultDrawOne';\nexport { rotateAroundAABBCenter } from './poseRotation';\n\nfunction SceneCanvasInner<TData, TLayer extends string, TPose>(\n  props: SceneCanvasProps<TData, TLayer, TPose> & { presetSource: PresetSource },\n  ref: React.ForwardedRef<SceneCanvasApi>,\n) {\n  const { selectTool: selectToolOpts, selectable = true, viewport, modes, debug } = props;\n  const descriptor = (props.poseDescriptor ?? AUTO_POSE_DESCRIPTOR) as PoseDescriptor<TPose>;\n  const deviceProfile = useDeviceProfile();\n  const scene = useBakedScene(props.scene);\n  const getActiveMode = useMemo(() => (modes ? getActiveModeFor(modes) : undefined), [modes]);\n  const heldModifiers = useHeldModifiers();\n\n  // Our own refs, so input listeners attach even when the consumer forwards its own ref.\n  const internalCanvasRef = useRef<HTMLElement | null>(null);\n  const canvasApiRef = useRef<CanvasExtensionApi | null>(null);\n  const declaredSize = useLatest({ width: props.width ?? 0, height: props.height ?? 0 });\n  const { viewState, viewAnimation, camera } = useCanvasCamera({\n    view: props.view, defaultView: props.defaultView, onViewChange: props.onViewChange, viewBounds: props.viewBounds,\n    dims: () => canvasApiRef.current?.getSurfaceRect() ?? declaredSize.current,\n    requestRedraw: () => { canvasApiRef.current?.requestRedraw(); },\n  });\n  const { viewRef } = viewState;\n  const selection = useCanvasSelection({\n    scene, supplied: props.selection, options: props.selectionOptions, selectable, describeKind: props.describeKind,\n  });\n  const enabled = useEnabledFeatures(props.features, props.presetSource.named, viewport !== undefined);\n  const { pathEditState, selectToolWithDefaults } = useSceneCanvasPathEdit({\n    host: props.pathEdit, opening: props.defaultPathEdit, getActiveMode, scene, selection,\n    extensions: enabled.pathEdit, selectTool: selectToolOpts,\n  });\n  const picking = useScenePicking({ scene, selection, descriptor, props, viewRef, selectTool: selectToolWithDefaults });\n  const { adapter, boundsOf, planeOfNode } = picking;\n  const getNodeAtPointRef = useLatest(picking.getNodeAtPoint);\n  const tools = useSceneCanvasTools({\n    props: props as SceneCanvasToolProps, select: picking.selectTool, move: picking.moveOptions,\n    scene: scene as Scene<unknown, string, unknown>, selection, enabled, presetSource: props.presetSource,\n  });\n\n  // `selectTool.rotate === false` disables rotation: its action is muted by the standard\n  // actions and its handle hidden by `useChromeRules`.\n  const rotateOff = selectToolOpts?.rotate === false;\n\n  // The wrapper's `<InputScope>` provides it.\n  const actionsRegistry = useActionsRegistry();\n  const { dispatcher, gestureSource, previewIdsExtra, previewPoseExtra } = useCanvasDispatcher(actionsRegistry);\n\n  const layered = useSceneCanvasLayers({\n    layers: props.layers, targetScale: deviceProfile.targetScale, scene, adapter, poseDescriptor: descriptor,\n    alphaFor: props.alphaFor, colorOverrides: props.animator?.colorOverrides, boundsOf, planeOfNode,\n    poseTransition: props.poseTransition, previewIds: previewIdsExtra, dispatcher, snapReadout: props.snap?.readout !== false, snapReadoutStyle: props.snap?.readoutStyle, pathEditState,\n    slops: debug !== undefined && debug !== false && debug.slops === true,\n    boundsIncludeStroke: props.geometry?.boundsIncludeStroke ?? true, selectTool: selectToolOpts,\n  });\n  const redrawOn = useSceneRedrawSources({ props, scene, heldModifiers, departures: layered.departures });\n\n  const chrome = useSceneCanvasChrome({\n    source: {\n      getMode: getActiveMode, getFocused: props.getFocused, getModifiers: heldModifiers.get,\n      resizable: selectToolOpts?.resize?.resizable,\n      editingAnchors: () => pathEditState.getEditingId() !== '',\n      device: deviceProfile,\n    },\n    rules: { enabled, selectable, rotateOff, chromeVisibility: props.chromeVisibility },\n    hover: { canvasApiRef, nodeAtPointRef: getNodeAtPointRef },\n    selection: selection.current as readonly NodeId[], viewRef, dispatcher,\n  });\n\n  const { ingest, clipboard: ingestionClipboard } = useCanvasIngestion(adapter, () => actionsRegistry, props.ingestion);\n  const { views: addedViews, addView, viewAt } = useAddedViews();\n  // The consumer's handle extends the primitive's with `ingest`, which needs the action stack.\n  const { handleRef, ready: canvasReady } = useSceneCanvasHandle({\n    ref, elementRef: internalCanvasRef, apiRef: canvasApiRef, onElement: chrome.trackHoverOn,\n    ingest, viewAnimation, camera, addView, viewAt,\n  });\n  const viewInputs = useSurfaceViewInputs({ picking, selection, resizeHandles: layered.resizeHandles,\n    descriptor: descriptor as PoseDescriptor<unknown>, chromeCaps: chrome.chromeCaps, rotationBadge: layered.rotationBadge,\n  });\n\n  return (\n    <CanvasKitProviders viewInputs={viewInputs}>\n      <Canvas<TPose>\n        ref={handleRef} adapter={adapter} selection={selection} poseDescriptor={descriptor}\n        tools={tools.tools} layers={layered.layers}\n        // The chrome's bounds are the picker's: a node on a parallax plane is\n        // boxed where the plane draws it, and a `geometry.boundsOf` reaches both.\n        boundsOf={boundsOf} boundsOfPose={picking.boundsOfPose}\n        getIsVisible={chrome.getIsVisible}\n        // The gesture surface behind `helpersRef.getGestureBounds()` /\n        // `subscribeGestures()` — Canvas has no dispatcher of its own.\n        gestureSource={gestureSource}\n        previewPoseExtra={previewPoseExtra}\n        {...(debug !== undefined ? { debug: canvasDebug(debug) } : {})}\n        contentVersion={scene.getVersion} layerVisibility={props.layerVisibility} layerOrder={props.layerOrder}\n        viewState={viewState} redrawOn={redrawOn}\n        {...canvasPassThrough(props)}\n      />\n      <DevHuds\n        cursorCoords={props.cursorCoordsHud} pick={props.pickHud} modality={props.modalityHud}\n        canvasRef={internalCanvasRef} canvasApiRef={canvasApiRef}\n        detachedInput={props.paintInto ? props.inputElement ?? null : undefined}\n        viewRef={viewRef} pickEvery={picking.pickEvery} pickBest={picking.pickBest}\n      />\n      <SceneCanvasInput\n        props={props as SceneCanvasInputOptions} scene={scene as Scene<unknown, string, unknown>}\n        selection={selection} descriptor={descriptor as PoseDescriptor<unknown>}\n        picking={{ ...picking, adapter: adapter as unknown as BridgeAdapter }} nodeAtPointRef={getNodeAtPointRef}\n        tools={tools} rotateOff={rotateOff} viewOn={enabled.has('view')} camera={{ viewState, viewAnimation }}\n        dispatcher={dispatcher} pathEdit={{ state: pathEditState }}\n        chrome={chrome} overlay={layered} ingestionClipboard={ingestionClipboard}\n        canvas={{ elementRef: internalCanvasRef, apiRef: canvasApiRef, ready: canvasReady }} snapSources={enabled.snapSources} snapStore={layered.snapStore}\n      />\n      {props.views?.map((v, i) => <CanvasView key={v.id} {...v} order={v.order ?? i} />)}\n      {contributionEntries(tools.tools).flatMap((e) => e.views ?? []).map((v) => (\n        <CanvasView key={`contribution:${v.id}`} {...v} />\n      ))}\n      {addedViews.map((v) => <CanvasView key={`added:${v.id}`} {...v} />)}\n      {props.children}\n    </CanvasKitProviders>\n  );\n}\n\nconst SceneCanvasInnerForwardRef = forwardRef(SceneCanvasInner);\n\n// The canvas's input scope sits above `SceneCanvasInner`, whose own hooks\n// (`useTools` among them) must already read this canvas's tool and registries.\n// Its device profile too, so the canvas and everything under it share one.\n/** A scene canvas resolving its `features` through `source`. */\nexport function renderSceneCanvas<TData, TLayer extends string, TPose>(\n  source: PresetSource,\n  { device, ...props }: SceneCanvasProps<TData, TLayer, TPose>,\n  ref: React.ForwardedRef<SceneCanvasApi>,\n) {\n  return (\n    <InputScope yoke={props.yoke}>\n      <DeviceProfileProvider value={device}>\n        <ViewRegistryProvider>\n          <SceneCanvasInnerForwardRef {...(props as SceneCanvasProps<unknown, string, unknown>)} presetSource={source} ref={ref} />\n        </ViewRegistryProvider>\n      </DeviceProfileProvider>\n    </InputScope>\n  );\n}\n\nfunction SceneCanvasWrapper<TData, TLayer extends string, TPose>(\n  props: SceneCanvasProps<TData, TLayer, TPose>, ref: React.ForwardedRef<SceneCanvasApi>,\n) {\n  return renderSceneCanvas(CORE_PRESET_SOURCE, props, ref);\n}\n\n// Marked pure so a bundle using only `LeanSceneCanvas` drops it, and core's named presets with it.\n/**\n * The canvas component: renders a `Scene` and wires the interaction stack\n * around it.\n *\n * Mounted bare it renders the scene, keeps a selection no input sets, and\n * runs a gesture dispatcher for whatever bindings the consumer adds. The\n * `features` presets turn the kit's behavior on — `features={['draw']}` is the\n * whole editor: tools, standard actions and their keys, selection chrome,\n * undo. This is the intended entry point; the lower-level primitives it\n * composes are not part of the public surface.\n *\n * Its ref exposes a `SceneCanvasApi` for the imperative operations that do not\n * fit a prop (view control, hit queries, redraw requests).\n */\nexport const SceneCanvas = /* @__PURE__ */ forwardRef(SceneCanvasWrapper) as <\n  TData, TLayer extends string, TPose,\n>(\n  props: SceneCanvasProps<TData, TLayer, TPose> & { ref?: React.Ref<SceneCanvasApi> },\n) => ReturnType<typeof SceneCanvasInner>;\n\nexport { DEFAULT_HANDLE_SIZE, BUILTIN_TOOL_IDS } from './SceneCanvas/props';\nexport { mergeLayersWithDefaults } from './SceneCanvas/mergeLayers';\nexport type {\n  SceneCanvasProps, SceneCanvasHit, SceneCanvasLayers, SceneCanvasLongPress, BuiltinToolId,\n} from './SceneCanvas/props';\nexport type { CoordTraceEntry } from './SceneCanvas/coordTrace';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,SAAS,iBACP,OACA,KACA;CACA,MAAM,EAAE,YAAY,gBAAgB,aAAa,MAAM,UAAU,OAAO,UAAU;CAClF,MAAM,aAAc,MAAM,kBAAkB;CAC5C,MAAM,gBAAgB,iBAAiB;CACvC,MAAM,QAAQ,cAAc,MAAM,KAAK;CACvC,MAAM,gBAAgB,cAAe,QAAQ,iBAAiB,KAAK,IAAI,QAAY,CAAC,KAAK,CAAC;CAC1F,MAAM,gBAAgB,iBAAiB;CAGvC,MAAM,oBAAoB,OAA2B,IAAI;CACzD,MAAM,eAAe,OAAkC,IAAI;CAC3D,MAAM,eAAe,UAAU;EAAE,OAAO,MAAM,SAAS;EAAG,QAAQ,MAAM,UAAU;CAAE,CAAC;CACrF,MAAM,EAAE,WAAW,eAAe,WAAW,gBAAgB;EAC3D,MAAM,MAAM;EAAM,aAAa,MAAM;EAAa,cAAc,MAAM;EAAc,YAAY,MAAM;EACtG,YAAY,aAAa,SAAS,eAAe,KAAK,aAAa;EACnE,qBAAqB;GAAE,aAAa,SAAS,cAAc;EAAG;CAChE,CAAC;CACD,MAAM,EAAE,YAAY;CACpB,MAAM,YAAY,mBAAmB;EACnC;EAAO,UAAU,MAAM;EAAW,SAAS,MAAM;EAAkB;EAAY,cAAc,MAAM;CACrG,CAAC;CACD,MAAM,UAAU,mBAAmB,MAAM,UAAU,MAAM,aAAa,OAAO,aAAa,MAAS;CACnG,MAAM,EAAE,eAAe,2BAA2B,uBAAuB;EACvE,MAAM,MAAM;EAAU,SAAS,MAAM;EAAiB;EAAe;EAAO;EAC5E,YAAY,QAAQ;EAAU,YAAY;CAC5C,CAAC;CACD,MAAM,UAAU,gBAAgB;EAAE;EAAO;EAAW;EAAY;EAAO;EAAS,YAAY;CAAuB,CAAC;CACpH,MAAM,EAAE,SAAS,UAAU,gBAAgB;CAC3C,MAAM,oBAAoB,UAAU,QAAQ,cAAc;CAC1D,MAAM,QAAQ,oBAAoB;EACzB;EAA+B,QAAQ,QAAQ;EAAY,MAAM,QAAQ;EACzE;EAA0C;EAAW;EAAS,cAAc,MAAM;CAC3F,CAAC;CAID,MAAM,YAAY,gBAAgB,WAAW;CAG7C,MAAM,kBAAkB,mBAAmB;CAC3C,MAAM,EAAE,YAAY,eAAe,iBAAiB,qBAAqB,oBAAoB,eAAe;CAE5G,MAAM,UAAU,qBAAqB;EACnC,QAAQ,MAAM;EAAQ,aAAa,cAAc;EAAa;EAAO;EAAS,gBAAgB;EAC9F,UAAU,MAAM;EAAU,gBAAgB,MAAM,UAAU;EAAgB;EAAU;EACpF,gBAAgB,MAAM;EAAgB,YAAY;EAAiB;EAAY,aAAa,MAAM,MAAM,YAAY;EAAO,kBAAkB,MAAM,MAAM;EAAc;EACvK,OAAO,UAAU,UAAa,UAAU,SAAS,MAAM,UAAU;EACjE,qBAAqB,MAAM,UAAU,uBAAuB;EAAM,YAAY;CAChF,CAAC;CACD,MAAM,WAAW,sBAAsB;EAAE;EAAO;EAAO;EAAe,YAAY,QAAQ;CAAW,CAAC;CAEtG,MAAM,SAAS,qBAAqB;EAClC,QAAQ;GACN,SAAS;GAAe,YAAY,MAAM;GAAY,cAAc,cAAc;GAClF,WAAW,gBAAgB,QAAQ;GACnC,sBAAsB,cAAc,aAAa,MAAM;GACvD,QAAQ;EACV;EACA,OAAO;GAAE;GAAS;GAAY;GAAW,kBAAkB,MAAM;EAAiB;EAClF,OAAO;GAAE;GAAc,gBAAgB;EAAkB;EACzD,WAAW,UAAU;EAA8B;EAAS;CAC9D,CAAC;CAED,MAAM,EAAE,QAAQ,WAAW,uBAAuB,mBAAmB,eAAe,iBAAiB,MAAM,SAAS;CACpH,MAAM,EAAE,OAAO,YAAY,SAAS,WAAW,cAAc;CAE7D,MAAM,EAAE,WAAW,OAAO,gBAAgB,qBAAqB;EAC7D;EAAK,YAAY;EAAmB,QAAQ;EAAc,WAAW,OAAO;EAC5E;EAAQ;EAAe;EAAQ;EAAS;CAC1C,CAAC;CACD,MAAM,aAAa,qBAAqB;EAAE;EAAS;EAAW,eAAe,QAAQ;EACvE;EAAuC,YAAY,OAAO;EAAY,eAAe,QAAQ;CAC3G,CAAC;CAED,OACE,qBAAC,oBAAD;EAAgC;EAAhC,UAAA;GACE,oBAAC,QAAD;IACE,KAAK;IAAoB;IAAoB;IAAW,gBAAgB;IACxE,OAAO,MAAM;IAAO,QAAQ,QAAQ;IAG1B;IAAU,cAAc,QAAQ;IAC1C,cAAc,OAAO;IAGN;IACG;IAClB,GAAK,UAAU,SAAY,EAAE,OAAO,YAAY,KAAK,EAAE,IAAI,CAAC;IAC5D,gBAAgB,MAAM;IAAY,iBAAiB,MAAM;IAAiB,YAAY,MAAM;IACjF;IAAqB;IAChC,GAAI,kBAAkB,KAAK;GAC5B,CAAA;GACD,oBAAC,SAAD;IACE,cAAc,MAAM;IAAiB,MAAM,MAAM;IAAS,UAAU,MAAM;IAC1E,WAAW;IAAiC;IAC5C,eAAe,MAAM,YAAY,MAAM,gBAAgB,OAAO;IACrD;IAAS,WAAW,QAAQ;IAAW,UAAU,QAAQ;GACnE,CAAA;GACD,oBAAC,kBAAD;IACS;IAAyC;IACrC;IAAuB;IAClC,SAAS;KAAE,GAAG;KAAkB;IAAoC;IAAG,gBAAgB;IAChF;IAAkB;IAAW,QAAQ,QAAQ,IAAI,MAAM;IAAG,QAAQ;KAAE;KAAW;IAAc;IACxF;IAAY,UAAU,EAAE,OAAO,cAAc;IACjD;IAAQ,SAAS;IAA6B;IACtD,QAAQ;KAAE,YAAY;KAAmB,QAAQ;KAAc,OAAO;IAAY;IAAG,aAAa,QAAQ;IAAa,WAAW,QAAQ;GAC3I,CAAA;GACA,MAAM,OAAO,KAAK,GAAG,MAAM,oBAAC,YAAD;IAAuB,GAAI;IAAG,OAAO,EAAE,SAAS;GAAI,GAAnC,EAAE,EAAiC,CAAC;GAChF,oBAAoB,MAAM,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,MACnE,oBAAC,YAAD,EAAyC,GAAI,EAAI,GAAhC,gBAAgB,EAAE,IAAc,CAClD;GACA,WAAW,KAAK,MAAM,oBAAC,YAAD,EAAkC,GAAI,EAAI,GAAzB,SAAS,EAAE,IAAc,CAAC;GACjE,MAAM;EACW;;AAExB;AAEA,IAAM,6BAA6B,WAAW,gBAAgB;;AAM9D,SAAgB,kBACd,QACA,EAAE,QAAQ,GAAG,SACb,KACA;CACA,OACE,oBAAC,YAAD;EAAY,MAAM,MAAM;EACtB,UAAA,oBAAC,uBAAD;GAAuB,OAAO;GAC5B,UAAA,oBAAC,sBAAD,EAAA,UACE,oBAAC,4BAAD;IAA4B,GAAK;IAAsD,cAAc;IAAa;GAAM,CAAA,EACpG,CAAA;EACD,CAAA;CACb,CAAA;AAEhB;AAEA,SAAS,mBACP,OAA+C,KAC/C;CACA,OAAO,kBAAkB,oBAAoB,OAAO,GAAG;AACzD;;;;;;;;;;;;;;;AAiBA,IAAa,cAA8B,2BAAW,kBAAkB"}

package/dist/canvas/SceneViewCanvas.js

@@ -1,50 +1,76 @@
-import { normalizeView as e } from "../core/viewport/view.js";
-import { useCanvasSurface as t } from "./useCanvasSurface.js";
-import { SurfaceCanvas as n } from "./SurfaceCanvas.js";
-import { sceneViewFrame as r } from "./sceneViewRender.js";
-import { useCallback as i, useEffect as a, useRef as o, useSyncExternalStore as s } from "react";
-import { assignRef as c } from "@weasel-js/react";
-import { jsx as l } from "react/jsx-runtime";
+import { normalizeView } from "../core/viewport/view.js";
+import { useCanvasSurface } from "./useCanvasSurface.js";
+import { SurfaceCanvas } from "./SurfaceCanvas.js";
+import { useSurfaceSize } from "./useSurfaceSize.js";
+import { sceneViewFrame } from "./sceneViewRender.js";
+import { useCallback, useEffect, useRef, useSyncExternalStore } from "react";
+import { assignRef } from "@weasel-js/react";
+import { jsx } from "react/jsx-runtime";
+
 //#region src/canvas/SceneViewCanvas.tsx
-function u(u) {
-	let { scene: d, width: f, height: p, drawOne: m, extraCommands: h, alphaFor: g, layerVisibility: _, layerOrder: v, animator: y, className: b, canvasRef: x, cull: S, paintBounds: C } = u, w = e(u.view);
-	s(d.subscribe, d.getVersion, d.getVersion);
-	let T = o(null), E = i((e) => {
-		T.current = e, c(x, e);
-	}, [x]), { requestRedraw: D } = t((e) => {
-		let t = T.current;
-		if (!t) return !1;
-		let n = r({
-			scene: d,
-			view: w,
-			width: f,
-			height: p,
-			drawOne: m,
-			extraCommands: h,
-			alphaFor: g,
-			layerVisibility: _,
-			layerOrder: v,
-			colorOverrides: y?.colorOverrides,
-			cull: S,
-			paintBounds: C
+/**
+* `<SceneViewCanvas>` — pointer-inert, read-only render of a `Scene` at a
+* given `View` into its own `<canvas>` DOM element.
+*
+* It paints through `useFrameLoop` rather than from React: a render and an
+* override commit both just mark the surface dirty. The mount paint is
+* synchronous, so the first frame the user sees is the scene, and nothing
+* paints while the canvas is off screen or the tab is hidden.
+*/
+function SceneViewCanvasInner(props) {
+	const { scene, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder, animator, className, canvasRef, cull, paintBounds } = props;
+	const view = normalizeView(props.view);
+	useSyncExternalStore(scene.subscribe, scene.getVersion, scene.getVersion);
+	const localRef = useRef(null);
+	const setCanvasRef = useCallback((el) => {
+		localRef.current = el;
+		assignRef(canvasRef, el);
+	}, [canvasRef]);
+	const { width, height } = useSurfaceSize(props, localRef);
+	const paint = (lease) => {
+		const canvas = localRef.current;
+		if (!canvas || width === 0 || height === 0) return false;
+		const commands = sceneViewFrame({
+			scene,
+			view,
+			width,
+			height,
+			drawOne,
+			extraCommands,
+			alphaFor,
+			layerVisibility,
+			layerOrder,
+			colorOverrides: animator?.colorOverrides,
+			cull,
+			paintBounds
 		});
-		return e.paint(t, n, w, {
-			width: f,
-			height: p
+		return lease.paint(canvas, commands, view, {
+			width,
+			height
 		});
-	}, {
-		target: T,
-		paintOnCommit: !0
+	};
+	const { requestRedraw } = useCanvasSurface(paint, {
+		target: localRef,
+		onCommit: "paint"
 	});
-	return a(() => d.overrides.subscribe(D), [d, D]), a(() => y?.onTick(D), [y, D]), /* @__PURE__ */ l(n, {
-		ref: E,
-		width: f,
-		height: p,
-		className: b
+	useEffect(() => scene.overrides.subscribe(requestRedraw), [scene, requestRedraw]);
+	useEffect(() => animator?.onTick(requestRedraw), [animator, requestRedraw]);
+	return /* @__PURE__ */ jsx(SurfaceCanvas, {
+		ref: setCanvasRef,
+		width: props.width,
+		height: props.height,
+		className
 	});
 }
-var d = u;
-//#endregion
-export { d as SceneViewCanvas };
+/**
+* Pointer-inert read-only scene view. It attaches no event listeners;
+* consumers attach their own through `canvasRef`, a plain prop because
+* `forwardRef` erases the component's generics. `width` and `height` are CSS
+* pixels and size the drawing buffer; a `className` rule that sizes the
+* element stretches that buffer to fit. Given neither, it fills its parent.
+*/
+var SceneViewCanvas = SceneViewCanvasInner;
 
+//#endregion
+export { SceneViewCanvas };
 //# sourceMappingURL=SceneViewCanvas.js.map

package/dist/canvas/SceneViewCanvas.js.map

@@ -1 +1 @@
-{"version":3,"file":"SceneViewCanvas.js","names":["SceneViewCanvasInner","props","view","normalizeView","scene","localRef","useRef","setCanvasRef","useCallback","el","assignRef","canvasRef","useCanvasSurface","canvas","commands","sceneViewFrame","animator","lease","useEffect","requestRedraw","SurfaceCanvas","SceneViewCanvas"],"sources":["../../src/canvas/SceneViewCanvas.tsx"],"sourcesContent":["/**\n * `<SceneViewCanvas>` — pointer-inert, read-only render of a `Scene` at a\n * given `View` into its own `<canvas>` DOM element.\n *\n * It paints through `useFrameLoop` rather than from React: a render and an\n * override commit both just mark the surface dirty. The mount paint is\n * synchronous, so the first frame the user sees is the scene, and nothing\n * paints while the canvas is off screen or the tab is hidden.\n */\nimport {\n  useCallback,\n  useEffect,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\nimport type { Ref } from 'react';\nimport { assignRef } from '@weasel-js/react';\nimport { useCanvasSurface } from './useCanvasSurface';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport { SurfaceCanvas } from './SurfaceCanvas';\nimport { sceneViewFrame } from './sceneViewRender';\nimport type { RenderSceneToCanvasArgs, SceneViewDrawOne, SceneViewLayers } from './sceneViewRender';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { normalizeView, type View } from '../core/viewport/view';\nimport type { Scene } from '../core/scene/types';\nimport type { Animator } from '@weasel-js/animator';\n\n/** Props for `<SceneViewCanvas>`. */\nexport interface SceneViewCanvasProps<TData, TLayer extends string, TPose> {\n  /** Scene to render. The component subscribes to it and repaints when it\n   *  changes. */\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera. Applied to scene + `extraCommands` via the renderer's group\n   *  transform. */\n  view: View;\n  /** CSS-pixel width. Drives both layout (via the rendered drawing-buffer\n   *  size) and the renderer's coordinate space. */\n  width: number;\n  /** CSS-pixel height. */\n  height: number;\n  /** Per-node draw callback. See `SceneViewDrawOne`. The consumer is\n   *  responsible for what gets painted — there is no AABB-fill default. */\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Optional extra commands appended after scene commands, inside the same\n   *  view transform — a world-space annotation over the scene. */\n  extraCommands?: ReadonlyArray<DrawCommand>;\n  /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Pass the same function the main canvas uses to keep a\n   *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Hide scene layers in this view only, keyed `scene:<layerId>` as on\n   *  `<SceneCanvas>` — pass the main canvas's map to keep the two in step. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Paint order for this view, keyed as `layerVisibility`. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Skip nodes and commands that cannot reach this view — the scene slot's\n   *  `cull`. Off by default; worth it when the view shows a small part of a\n   *  large scene. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach — the scene slot's\n   *  `paintBounds`. Defaults to `defaultPaintBounds` when `drawOne` is\n   *  `defaultDrawOne`. */\n  paintBounds?: RenderSceneToCanvasArgs<TData, TLayer, TPose>['paintBounds'];\n  /** Optional animator, as on `<SceneCanvas>`: the view repaints on its ticks\n   *  and paints its `colorOverrides`. Pass the main canvas's animator so both\n   *  show the same colors. */\n  animator?: Animator;\n  /** Optional CSS class for the `<canvas>`. Its size is `width` × `height`\n   *  unless a rule on this class sizes it. */\n  className?: string;\n  /** Forwarded ref to the underlying `<canvas>`. Consumers attach their own\n   *  pointer listeners or call `toBlob` for snapshots through this. */\n  canvasRef?: Ref<HTMLCanvasElement>;\n}\n\nfunction SceneViewCanvasInner<TData, TLayer extends string, TPose>(\n  props: SceneViewCanvasProps<TData, TLayer, TPose>,\n) {\n  const {\n    scene, width, height, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    animator, className, canvasRef, cull, paintBounds,\n  } = props;\n  const view = normalizeView(props.view);\n\n  // Subscribe to scene version. The snapshot value isn't used directly —\n  // we only need React to re-render the component when the scene mutates.\n  useSyncExternalStore(scene.subscribe, scene.getVersion, scene.getVersion);\n\n  const localRef = useRef<HTMLCanvasElement | null>(null);\n\n  const setCanvasRef = useCallback((el: HTMLCanvasElement | null): void => {\n    localRef.current = el;\n    assignRef(canvasRef, el);\n  }, [canvasRef]);\n\n  const paint = (lease: CanvasRendererLease): boolean => {\n    const canvas = localRef.current;\n    if (!canvas) return false;\n    const commands = sceneViewFrame({\n      scene,\n      view,\n      width,\n      height,\n      drawOne,\n      extraCommands: extraCommands as DrawCommand[] | undefined,\n      alphaFor,\n      layerVisibility,\n      layerOrder,\n      colorOverrides: animator?.colorOverrides,\n      cull,\n      paintBounds,\n    });\n    return lease.paint(canvas, commands, view, { width, height });\n  };\n  const { requestRedraw } = useCanvasSurface(paint, { target: localRef, paintOnCommit: true });\n\n  // Override writes never bump the scene version, so the version subscription\n  // above cannot see them.\n  useEffect(() => scene.overrides.subscribe(requestRedraw), [scene, requestRedraw]);\n  useEffect(() => animator?.onTick(requestRedraw), [animator, requestRedraw]);\n\n  return (\n    <SurfaceCanvas\n      ref={setCanvasRef}\n      width={width}\n      height={height}\n      className={className}\n    />\n  );\n}\n\n/**\n * Pointer-inert read-only scene view. It attaches no event listeners;\n * consumers attach their own through `canvasRef`, a plain prop because\n * `forwardRef` erases the component's generics. `width` and `height` are CSS\n * pixels and size the drawing buffer; a `className` rule that sizes the\n * element stretches that buffer to fit.\n */\nexport const SceneViewCanvas = SceneViewCanvasInner;\n"],"mappings":";;;;;;;;AA2EA,SAASA,EACP,GACA;CACA,IAAM,EACJ,UAAO,UAAO,WAAQ,YAAS,kBAAe,aAAU,oBAAiB,eACzE,aAAU,cAAW,cAAW,SAAM,mBACpCC,GACEC,IAAOC,EAAcF,EAAM,IAAI;CAIrC,EAAqBG,EAAM,WAAWA,EAAM,YAAYA,EAAM,UAAU;CAExE,IAAMC,IAAWC,EAAiC,IAAI,GAEhDC,IAAeC,GAAa,MAAuC;EAEvE,AADA,EAAS,UAAUC,GACnBC,EAAUC,GAAWF,CAAE;CACzB,GAAG,CAACE,CAAS,CAAC,GAqBR,EAAE,qBAAkBC,GAnBX,MAAwC;EACrD,IAAMC,IAASR,EAAS;EACxB,IAAI,CAACQ,GAAQ,OAAO;EACpB,IAAMC,IAAWC,EAAe;GAC9B;GACA;GACA;GACA;GACA;GACe;GACf;GACA;GACA;GACA,gBAAgBC,GAAU;GAC1B;GACA;EACF,CAAC;EACD,OAAOC,EAAM,MAAMJ,GAAQC,GAAUZ,GAAM;GAAE;GAAO;EAAO,CAAC;CAC9D,GACkD;EAAE,QAAQG;EAAU,eAAe;CAAK,CAAC;CAO3F,OAHAa,QAAgBd,EAAM,UAAU,UAAUe,CAAa,GAAG,CAACf,GAAOe,CAAa,CAAC,GAChFD,QAAgBF,GAAU,OAAOG,CAAa,GAAG,CAACH,GAAUG,CAAa,CAAC,GAGxE,kBAACC,GAAD;EACE,KAAKb;EACE;EACC;EACG;CACZ,CAAA;AAEL;AASA,IAAac,IAAkBrB"}
+{"version":3,"file":"SceneViewCanvas.js","names":[],"sources":["../../src/canvas/SceneViewCanvas.tsx"],"sourcesContent":["/**\n * `<SceneViewCanvas>` — pointer-inert, read-only render of a `Scene` at a\n * given `View` into its own `<canvas>` DOM element.\n *\n * It paints through `useFrameLoop` rather than from React: a render and an\n * override commit both just mark the surface dirty. The mount paint is\n * synchronous, so the first frame the user sees is the scene, and nothing\n * paints while the canvas is off screen or the tab is hidden.\n */\nimport {\n  useCallback,\n  useEffect,\n  useRef,\n  useSyncExternalStore,\n} from 'react';\nimport type { Ref } from 'react';\nimport { assignRef } from '@weasel-js/react';\nimport { useCanvasSurface } from './useCanvasSurface';\nimport type { CanvasRendererLease } from './canvasRenderer';\nimport { SurfaceCanvas } from './SurfaceCanvas';\nimport { useSurfaceSize, type SurfaceSizeProps } from './useSurfaceSize';\nimport { sceneViewFrame } from './sceneViewRender';\nimport type { RenderSceneToCanvasArgs, SceneViewDrawOne, SceneViewLayers } from './sceneViewRender';\nimport type { DrawCommand } from '@weasel-js/renderer';\nimport { normalizeView, type View } from '../core/viewport/view';\nimport type { Scene } from '../core/scene/types';\nimport type { Animator } from '@weasel-js/animator';\n\n/** Props for `<SceneViewCanvas>`. */\nexport interface SceneViewCanvasProps<TData, TLayer extends string, TPose> extends SurfaceSizeProps {\n  /** Scene to render. The component subscribes to it and repaints when it\n   *  changes. */\n  scene: Scene<TData, TLayer, TPose>;\n  /** Camera. Applied to scene + `extraCommands` via the renderer's group\n   *  transform. */\n  view: View;\n  /** Per-node draw callback. See `SceneViewDrawOne`. The consumer is\n   *  responsible for what gets painted — there is no AABB-fill default. */\n  drawOne: SceneViewDrawOne<TData, TLayer, TPose>;\n  /** Optional extra commands appended after scene commands, inside the same\n   *  view transform — a world-space annotation over the scene. */\n  extraCommands?: ReadonlyArray<DrawCommand>;\n  /** Optional per-id alpha multiplier, mirroring `<SceneCanvas>`'s scene-slot\n   *  `alphaFor`. Pass the same function the main canvas uses to keep a\n   *  scoping-dim treatment consistent across both. Defaults to `() => 1`. */\n  alphaFor?: (id: string) => number;\n  /** Hide scene layers in this view only, keyed `scene:<layerId>` as on\n   *  `<SceneCanvas>` — pass the main canvas's map to keep the two in step. */\n  layerVisibility?: SceneViewLayers['layerVisibility'];\n  /** Paint order for this view, keyed as `layerVisibility`. */\n  layerOrder?: SceneViewLayers['layerOrder'];\n  /** Skip nodes and commands that cannot reach this view — the scene slot's\n   *  `cull`. Off by default; worth it when the view shows a small part of a\n   *  large scene. */\n  cull?: boolean;\n  /** Where `drawOne`'s output for a node can reach — the scene slot's\n   *  `paintBounds`. Defaults to `defaultPaintBounds` when `drawOne` is\n   *  `defaultDrawOne`. */\n  paintBounds?: RenderSceneToCanvasArgs<TData, TLayer, TPose>['paintBounds'];\n  /** Optional animator, as on `<SceneCanvas>`: the view repaints on its ticks\n   *  and paints its `colorOverrides`. Pass the main canvas's animator so both\n   *  show the same colors. */\n  animator?: Animator;\n  /** Optional CSS class for the `<canvas>`. Its size is `width` × `height`\n   *  unless a rule on this class sizes it. */\n  className?: string;\n  /** Forwarded ref to the underlying `<canvas>`. Consumers attach their own\n   *  pointer listeners or call `toBlob` for snapshots through this. */\n  canvasRef?: Ref<HTMLCanvasElement>;\n}\n\nfunction SceneViewCanvasInner<TData, TLayer extends string, TPose>(\n  props: SceneViewCanvasProps<TData, TLayer, TPose>,\n) {\n  const {\n    scene, drawOne, extraCommands, alphaFor, layerVisibility, layerOrder,\n    animator, className, canvasRef, cull, paintBounds,\n  } = props;\n  const view = normalizeView(props.view);\n\n  // Subscribe to scene version. The snapshot value isn't used directly —\n  // we only need React to re-render the component when the scene mutates.\n  useSyncExternalStore(scene.subscribe, scene.getVersion, scene.getVersion);\n\n  const localRef = useRef<HTMLCanvasElement | null>(null);\n\n  const setCanvasRef = useCallback((el: HTMLCanvasElement | null): void => {\n    localRef.current = el;\n    assignRef(canvasRef, el);\n  }, [canvasRef]);\n  const { width, height } = useSurfaceSize(props, localRef);\n\n  const paint = (lease: CanvasRendererLease): boolean => {\n    const canvas = localRef.current;\n    if (!canvas || width === 0 || height === 0) return false;\n    const commands = sceneViewFrame({\n      scene,\n      view,\n      width,\n      height,\n      drawOne,\n      extraCommands: extraCommands as DrawCommand[] | undefined,\n      alphaFor,\n      layerVisibility,\n      layerOrder,\n      colorOverrides: animator?.colorOverrides,\n      cull,\n      paintBounds,\n    });\n    return lease.paint(canvas, commands, view, { width, height });\n  };\n  const { requestRedraw } = useCanvasSurface(paint, { target: localRef, onCommit: 'paint' });\n\n  // Override writes never bump the scene version, so the version subscription\n  // above cannot see them.\n  useEffect(() => scene.overrides.subscribe(requestRedraw), [scene, requestRedraw]);\n  useEffect(() => animator?.onTick(requestRedraw), [animator, requestRedraw]);\n\n  return (\n    <SurfaceCanvas\n      ref={setCanvasRef}\n      width={props.width}\n      height={props.height}\n      className={className}\n    />\n  );\n}\n\n/**\n * Pointer-inert read-only scene view. It attaches no event listeners;\n * consumers attach their own through `canvasRef`, a plain prop because\n * `forwardRef` erases the component's generics. `width` and `height` are CSS\n * pixels and size the drawing buffer; a `className` rule that sizes the\n * element stretches that buffer to fit. Given neither, it fills its parent.\n */\nexport const SceneViewCanvas = SceneViewCanvasInner;\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAuEA,SAAS,qBACP,OACA;CACA,MAAM,EACJ,OAAO,SAAS,eAAe,UAAU,iBAAiB,YAC1D,UAAU,WAAW,WAAW,MAAM,gBACpC;CACJ,MAAM,OAAO,cAAc,MAAM,IAAI;CAIrC,qBAAqB,MAAM,WAAW,MAAM,YAAY,MAAM,UAAU;CAExE,MAAM,WAAW,OAAiC,IAAI;CAEtD,MAAM,eAAe,aAAa,OAAuC;EACvE,SAAS,UAAU;EACnB,UAAU,WAAW,EAAE;CACzB,GAAG,CAAC,SAAS,CAAC;CACd,MAAM,EAAE,OAAO,WAAW,eAAe,OAAO,QAAQ;CAExD,MAAM,SAAS,UAAwC;EACrD,MAAM,SAAS,SAAS;EACxB,IAAI,CAAC,UAAU,UAAU,KAAK,WAAW,GAAG,OAAO;EACnD,MAAM,WAAW,eAAe;GAC9B;GACA;GACA;GACA;GACA;GACe;GACf;GACA;GACA;GACA,gBAAgB,UAAU;GAC1B;GACA;EACF,CAAC;EACD,OAAO,MAAM,MAAM,QAAQ,UAAU,MAAM;GAAE;GAAO;EAAO,CAAC;CAC9D;CACA,MAAM,EAAE,kBAAkB,iBAAiB,OAAO;EAAE,QAAQ;EAAU,UAAU;CAAQ,CAAC;CAIzF,gBAAgB,MAAM,UAAU,UAAU,aAAa,GAAG,CAAC,OAAO,aAAa,CAAC;CAChF,gBAAgB,UAAU,OAAO,aAAa,GAAG,CAAC,UAAU,aAAa,CAAC;CAE1E,OACE,oBAAC,eAAD;EACE,KAAK;EACL,OAAO,MAAM;EACb,QAAQ,MAAM;EACH;CACZ,CAAA;AAEL;;;;;;;;AASA,IAAa,kBAAkB"}

package/dist/canvas/SurfaceCanvas.js

@@ -1,40 +1,62 @@
-import { forwardRef as e, useCallback as t } from "react";
-import { assignRef as n } from "@weasel-js/react";
-import { jsx as r } from "react/jsx-runtime";
+import { forwardRef, useCallback } from "react";
+import { assignRef } from "@weasel-js/react";
+import { jsx } from "react/jsx-runtime";
+
 //#region src/canvas/SurfaceCanvas.tsx
-var i = ":where([data-wzl-surface]) { width: var(--wzl-surface-width); height: var(--wzl-surface-height); }", a = /* @__PURE__ */ new WeakSet();
-function o(e) {
-	let t = e.ownerDocument, n = e.getRootNode(), r = "host" in n ? n : t;
-	if (a.has(r)) return;
-	a.add(r);
-	let o = t.defaultView?.CSSStyleSheet;
-	if (o && "replaceSync" in o.prototype && Array.isArray(r.adoptedStyleSheets)) {
-		let e = new o();
-		e.replaceSync(i), r.adoptedStyleSheets = [...r.adoptedStyleSheets, e];
+/** The CSS size of a canvas the kit renders: its `width` and `height` props,
+*  and its parent's box on an axis given neither. Zero specificity, so a class
+*  the consumer passes resizes the element.
+*
+*  A filling canvas must give its parent no size back, or the parent could
+*  never shrink. `contain: size` drops its buffer's size, but Chrome still
+*  takes the buffer's aspect ratio for an auto height, so a near-flat ratio
+*  replaces it. */
+var SURFACE_RULE = ":where([data-wzl-surface]) { width: var(--wzl-surface-width, 100%); height: var(--wzl-surface-height, 100%); } :where([data-wzl-surface='fill']) { display: block; contain: size; aspect-ratio: 1000000 / 1; }";
+var adopted = /* @__PURE__ */ new WeakSet();
+/**
+* Hold {@link SURFACE_RULE} in the root `el`'s styles come from: its shadow
+* root, else its document. Once per root, and never taken back out.
+*/
+function adoptSurfaceRule(el) {
+	const doc = el.ownerDocument;
+	const node = el.getRootNode();
+	const root = "host" in node ? node : doc;
+	if (adopted.has(root)) return;
+	adopted.add(root);
+	const Sheet = doc.defaultView?.CSSStyleSheet;
+	if (Sheet && "replaceSync" in Sheet.prototype && Array.isArray(root.adoptedStyleSheets)) {
+		const sheet = new Sheet();
+		sheet.replaceSync(SURFACE_RULE);
+		root.adoptedStyleSheets = [...root.adoptedStyleSheets, sheet];
 		return;
 	}
-	let s = t.createElement("style");
-	s.textContent = i, ("host" in r ? r : r.head).appendChild(s);
+	const style = doc.createElement("style");
+	style.textContent = SURFACE_RULE;
+	("host" in root ? root : root.head).appendChild(style);
 }
-var s = e(function({ width: e, height: i, className: a, style: s, tabIndex: c }, l) {
-	let u = t((e) => {
-		e && o(e), n(l, e);
-	}, [l]), d = {
-		...s,
-		"--wzl-surface-width": `${e}px`,
-		"--wzl-surface-height": `${i}px`
+/** The `<canvas>` a kit component paints into, `width` × `height` CSS pixels,
+*  or its parent's size on an axis given neither. */
+var SurfaceCanvas = forwardRef(function SurfaceCanvas({ width, height, className, style, tabIndex }, ref) {
+	const setRef = useCallback((el) => {
+		if (el) adoptSurfaceRule(el);
+		assignRef(ref, el);
+	}, [ref]);
+	const sized = {
+		...style,
+		...width !== void 0 ? { "--wzl-surface-width": `${width}px` } : {},
+		...height !== void 0 ? { "--wzl-surface-height": `${height}px` } : {}
 	};
-	return /* @__PURE__ */ r("canvas", {
-		ref: u,
-		width: e,
-		height: i,
-		tabIndex: c,
-		className: a,
-		style: d,
-		"data-wzl-surface": ""
+	return /* @__PURE__ */ jsx("canvas", {
+		ref: setRef,
+		width,
+		height,
+		tabIndex,
+		className,
+		style: sized,
+		"data-wzl-surface": width === void 0 || height === void 0 ? "fill" : ""
 	});
 });
-//#endregion
-export { i as SURFACE_RULE, s as SurfaceCanvas, o as adoptSurfaceRule };
 
+//#endregion
+export { SURFACE_RULE, SurfaceCanvas, adoptSurfaceRule };
 //# sourceMappingURL=SurfaceCanvas.js.map

package/dist/canvas/SurfaceCanvas.js.map

@@ -1 +1 @@
-{"version":3,"file":"SurfaceCanvas.js","names":["SURFACE_RULE","adopted","adoptSurfaceRule","doc","el","node","root","Sheet","sheet","style","SurfaceCanvas","forwardRef","setRef","useCallback","assignRef","ref","sized","width","height"],"sources":["../../src/canvas/SurfaceCanvas.tsx"],"sourcesContent":["import { forwardRef, useCallback, type CSSProperties } from 'react';\nimport { assignRef } from '@weasel-js/react';\n\n/** Where an element's styles come from. */\ntype StyleRoot = Document | ShadowRoot;\n\n/** The CSS size of a canvas the kit renders: its `width` and `height` props.\n *  Zero specificity, so a class the consumer passes resizes the element. */\nexport const SURFACE_RULE =\n  ':where([data-wzl-surface]) { width: var(--wzl-surface-width); height: var(--wzl-surface-height); }';\n\nlet adopted = new WeakSet<StyleRoot>();\n\n/**\n * Hold {@link SURFACE_RULE} in the root `el`'s styles come from: its shadow\n * root, else its document. Once per root, and never taken back out.\n */\nexport function adoptSurfaceRule(el: Element): void {\n  const doc = el.ownerDocument;\n  const node = el.getRootNode();\n  const root: StyleRoot = 'host' in node ? (node as ShadowRoot) : doc;\n  if (adopted.has(root)) return;\n  adopted.add(root);\n  const Sheet = doc.defaultView?.CSSStyleSheet;\n  if (Sheet && 'replaceSync' in Sheet.prototype && Array.isArray(root.adoptedStyleSheets)) {\n    // From the root's own window: a constructed sheet cannot be adopted across documents.\n    const sheet = new Sheet();\n    sheet.replaceSync(SURFACE_RULE);\n    root.adoptedStyleSheets = [...root.adoptedStyleSheets, sheet];\n    return;\n  }\n  const style = doc.createElement('style');\n  style.textContent = SURFACE_RULE;\n  ('host' in root ? root : root.head).appendChild(style);\n}\n\n/** Test seam: forgets which roots hold the rule. */\nexport function __resetSurfaceRule(): void {\n  adopted = new WeakSet();\n}\n\nexport interface SurfaceCanvasProps {\n  /** CSS pixels. The renderer sizes only the drawing buffer, so without the\n   *  rule this element holds it is as large as its buffer: `dpr` times too big. */\n  width: number;\n  height: number;\n  className?: string;\n  style?: CSSProperties;\n  tabIndex?: number;\n}\n\n/** The `<canvas>` a kit component paints into, `width` × `height` CSS pixels. */\nexport const SurfaceCanvas = forwardRef<HTMLCanvasElement, SurfaceCanvasProps>(\n  function SurfaceCanvas({ width, height, className, style, tabIndex }, ref) {\n    // Stable while `ref` is, so a commit does not detach the element.\n    const setRef = useCallback((el: HTMLCanvasElement | null) => {\n      if (el) adoptSurfaceRule(el);\n      assignRef(ref, el);\n    }, [ref]);\n    const sized = { ...style, '--wzl-surface-width': `${width}px`, '--wzl-surface-height': `${height}px` };\n    return (\n      <canvas\n        ref={setRef}\n        width={width}\n        height={height}\n        tabIndex={tabIndex}\n        className={className}\n        style={sized as CSSProperties}\n        data-wzl-surface=\"\"\n      />\n    );\n  },\n);\n"],"mappings":";;;;AAQA,IAAaA,IACX,sGAEEC,oBAAU,IAAI,QAAmB;AAMrC,SAAgBC,EAAiB,GAAmB;CAClD,IAAMC,IAAMC,EAAG,eACTC,IAAOD,EAAG,YAAY,GACtBE,IAAkB,UAAUD,IAAQA,IAAsBF;CAChE,IAAIF,EAAQ,IAAIK,CAAI,GAAG;CACvB,EAAQ,IAAIA,CAAI;CAChB,IAAMC,IAAQJ,EAAI,aAAa;CAC/B,IAAII,KAAS,iBAAiBA,EAAM,aAAa,MAAM,QAAQD,EAAK,kBAAkB,GAAG;EAEvF,IAAME,IAAQ,IAAID,EAAM;EAExB,AADAC,EAAM,YAAYR,CAAY,GAC9B,EAAK,qBAAqB,CAAC,GAAGM,EAAK,oBAAoBE,CAAK;EAC5D;CACF;CACA,IAAMC,IAAQN,EAAI,cAAc,OAAO;CAEvC,AADA,EAAM,cAAcH,IACnB,UAAUM,IAAOA,IAAOA,EAAK,KAAA,CAAM,YAAYG,CAAK;AACvD;AAkBA,IAAaC,IAAgBC,EAC3B,SAAuB,EAAE,UAAO,WAAQ,cAAW,UAAO,eAAY,GAAK;CAEzE,IAAMC,IAASC,GAAa,MAAiC;EAE3D,AADIT,KAAIF,EAAiBE,CAAE,GAC3BU,EAAUC,GAAKX,CAAE;CACnB,GAAG,CAACW,CAAG,CAAC,GACFC,IAAQ;EAAE,GAAGP;EAAO,uBAAuB,GAAGQ,EAAM;EAAK,wBAAwB,GAAGC,EAAO;CAAI;CACrG,OACE,kBAAC,UAAD;EACE,KAAKN;EACE;EACC;EACE;EACC;EACX,OAAOI;EACP,oBAAiB;CAClB,CAAA;AAEL,CACF"}
+{"version":3,"file":"SurfaceCanvas.js","names":[],"sources":["../../src/canvas/SurfaceCanvas.tsx"],"sourcesContent":["import { forwardRef, useCallback, type CSSProperties } from 'react';\nimport { assignRef } from '@weasel-js/react';\n\n/** Where an element's styles come from. */\ntype StyleRoot = Document | ShadowRoot;\n\n/** The CSS size of a canvas the kit renders: its `width` and `height` props,\n *  and its parent's box on an axis given neither. Zero specificity, so a class\n *  the consumer passes resizes the element.\n *\n *  A filling canvas must give its parent no size back, or the parent could\n *  never shrink. `contain: size` drops its buffer's size, but Chrome still\n *  takes the buffer's aspect ratio for an auto height, so a near-flat ratio\n *  replaces it. */\nexport const SURFACE_RULE =\n  ':where([data-wzl-surface]) { width: var(--wzl-surface-width, 100%); height: var(--wzl-surface-height, 100%); }'\n  + \" :where([data-wzl-surface='fill']) { display: block; contain: size; aspect-ratio: 1000000 / 1; }\";\n\nlet adopted = new WeakSet<StyleRoot>();\n\n/**\n * Hold {@link SURFACE_RULE} in the root `el`'s styles come from: its shadow\n * root, else its document. Once per root, and never taken back out.\n */\nexport function adoptSurfaceRule(el: Element): void {\n  const doc = el.ownerDocument;\n  const node = el.getRootNode();\n  const root: StyleRoot = 'host' in node ? (node as ShadowRoot) : doc;\n  if (adopted.has(root)) return;\n  adopted.add(root);\n  const Sheet = doc.defaultView?.CSSStyleSheet;\n  if (Sheet && 'replaceSync' in Sheet.prototype && Array.isArray(root.adoptedStyleSheets)) {\n    // From the root's own window: a constructed sheet cannot be adopted across documents.\n    const sheet = new Sheet();\n    sheet.replaceSync(SURFACE_RULE);\n    root.adoptedStyleSheets = [...root.adoptedStyleSheets, sheet];\n    return;\n  }\n  const style = doc.createElement('style');\n  style.textContent = SURFACE_RULE;\n  ('host' in root ? root : root.head).appendChild(style);\n}\n\n/** Test seam: forgets which roots hold the rule. */\nexport function __resetSurfaceRule(): void {\n  adopted = new WeakSet();\n}\n\nexport interface SurfaceCanvasProps {\n  /** CSS pixels. The renderer sizes only the drawing buffer, so without the\n   *  rule this element holds it is as large as its buffer: `dpr` times too big.\n   *  Omitted, the element fills its parent on that axis. */\n  width?: number;\n  height?: number;\n  className?: string;\n  style?: CSSProperties;\n  tabIndex?: number;\n}\n\n/** The `<canvas>` a kit component paints into, `width` × `height` CSS pixels,\n *  or its parent's size on an axis given neither. */\nexport const SurfaceCanvas = forwardRef<HTMLCanvasElement, SurfaceCanvasProps>(\n  function SurfaceCanvas({ width, height, className, style, tabIndex }, ref) {\n    // Stable while `ref` is, so a commit does not detach the element.\n    const setRef = useCallback((el: HTMLCanvasElement | null) => {\n      if (el) adoptSurfaceRule(el);\n      assignRef(ref, el);\n    }, [ref]);\n    const sized = {\n      ...style,\n      ...(width !== undefined ? { '--wzl-surface-width': `${width}px` } : {}),\n      ...(height !== undefined ? { '--wzl-surface-height': `${height}px` } : {}),\n    };\n    const fills = width === undefined || height === undefined;\n    return (\n      <canvas\n        ref={setRef}\n        width={width}\n        height={height}\n        tabIndex={tabIndex}\n        className={className}\n        style={sized as CSSProperties}\n        data-wzl-surface={fills ? 'fill' : ''}\n      />\n    );\n  },\n);\n"],"mappings":";;;;;;;;;;;;;AAcA,IAAa,eACX;AAGF,IAAI,0BAAU,IAAI,QAAmB;;;;;AAMrC,SAAgB,iBAAiB,IAAmB;CAClD,MAAM,MAAM,GAAG;CACf,MAAM,OAAO,GAAG,YAAY;CAC5B,MAAM,OAAkB,UAAU,OAAQ,OAAsB;CAChE,IAAI,QAAQ,IAAI,IAAI,GAAG;CACvB,QAAQ,IAAI,IAAI;CAChB,MAAM,QAAQ,IAAI,aAAa;CAC/B,IAAI,SAAS,iBAAiB,MAAM,aAAa,MAAM,QAAQ,KAAK,kBAAkB,GAAG;EAEvF,MAAM,QAAQ,IAAI,MAAM;EACxB,MAAM,YAAY,YAAY;EAC9B,KAAK,qBAAqB,CAAC,GAAG,KAAK,oBAAoB,KAAK;EAC5D;CACF;CACA,MAAM,QAAQ,IAAI,cAAc,OAAO;CACvC,MAAM,cAAc;CACpB,CAAC,UAAU,OAAO,OAAO,KAAK,KAAA,CAAM,YAAY,KAAK;AACvD;;;AAoBA,IAAa,gBAAgB,WAC3B,SAAS,cAAc,EAAE,OAAO,QAAQ,WAAW,OAAO,YAAY,KAAK;CAEzE,MAAM,SAAS,aAAa,OAAiC;EAC3D,IAAI,IAAI,iBAAiB,EAAE;EAC3B,UAAU,KAAK,EAAE;CACnB,GAAG,CAAC,GAAG,CAAC;CACR,MAAM,QAAQ;EACZ,GAAG;EACH,GAAI,UAAU,SAAY,EAAE,uBAAuB,GAAG,MAAM,IAAI,IAAI,CAAC;EACrE,GAAI,WAAW,SAAY,EAAE,wBAAwB,GAAG,OAAO,IAAI,IAAI,CAAC;CAC1E;CAEA,OACE,oBAAC,UAAD;EACE,KAAK;EACE;EACC;EACE;EACC;EACX,OAAO;EACP,oBATU,UAAU,UAAa,WAAW,SASlB,SAAS;CACpC,CAAA;AAEL,CACF"}

package/dist/canvas/accentColor.js

@@ -1,9 +1,12 @@
 //#region src/canvas/accentColor.ts
-var e = "#4c8dff";
-function t(t) {
-	return !t || typeof getComputedStyle != "function" ? e : getComputedStyle(t).getPropertyValue("--wzl-accent").trim() || e;
+/** The accent canvas chrome paints in when the element sits under no theme. */
+var FALLBACK_ACCENT = "#4c8dff";
+/** Read `--wzl-accent` off `el`, where the theme cascade lands on a canvas. */
+function accentColorOf(el) {
+	if (!el || typeof getComputedStyle !== "function") return FALLBACK_ACCENT;
+	return getComputedStyle(el).getPropertyValue("--wzl-accent").trim() || FALLBACK_ACCENT;
 }
-//#endregion
-export { e as FALLBACK_ACCENT, t as accentColorOf };
 
+//#endregion
+export { FALLBACK_ACCENT, accentColorOf };
 //# sourceMappingURL=accentColor.js.map

package/dist/canvas/accentColor.js.map

@@ -1 +1 @@
-{"version":3,"file":"accentColor.js","names":["FALLBACK_ACCENT","accentColorOf","el"],"sources":["../../src/canvas/accentColor.ts"],"sourcesContent":["/** The accent canvas chrome paints in when the element sits under no theme. */\nexport const FALLBACK_ACCENT = '#4c8dff';\n\n/** Read `--wzl-accent` off `el`, where the theme cascade lands on a canvas. */\nexport function accentColorOf(el: Element | null | undefined): string {\n  if (!el || typeof getComputedStyle !== 'function') return FALLBACK_ACCENT;\n  return getComputedStyle(el).getPropertyValue('--wzl-accent').trim() || FALLBACK_ACCENT;\n}\n"],"mappings":";AACA,IAAaA,IAAkB;AAG/B,SAAgBC,EAAc,GAAwC;CAEpE,OADI,CAACC,KAAM,OAAO,oBAAqB,aAAmBF,IACnD,iBAAiBE,CAAE,CAAC,CAAC,iBAAiB,cAAc,CAAC,CAAC,KAAK,KAAKF;AACzE"}
+{"version":3,"file":"accentColor.js","names":[],"sources":["../../src/canvas/accentColor.ts"],"sourcesContent":["/** The accent canvas chrome paints in when the element sits under no theme. */\nexport const FALLBACK_ACCENT = '#4c8dff';\n\n/** Read `--wzl-accent` off `el`, where the theme cascade lands on a canvas. */\nexport function accentColorOf(el: Element | null | undefined): string {\n  if (!el || typeof getComputedStyle !== 'function') return FALLBACK_ACCENT;\n  return getComputedStyle(el).getPropertyValue('--wzl-accent').trim() || FALLBACK_ACCENT;\n}\n"],"mappings":";;AACA,IAAa,kBAAkB;;AAG/B,SAAgB,cAAc,IAAwC;CACpE,IAAI,CAAC,MAAM,OAAO,qBAAqB,YAAY,OAAO;CAC1D,OAAO,iBAAiB,EAAE,CAAC,CAAC,iBAAiB,cAAc,CAAC,CAAC,KAAK,KAAK;AACzE"}

package/dist/canvas/adapterDerivedPath.js

@@ -1,26 +1,41 @@
-import { createNodeMemoScope as e } from "../core/scene/nodeMemo.js";
-import { resolveDerivedPath as t } from "../core/scene/derivedPath.js";
+import { createNodeMemoScope } from "../core/scene/nodeMemo.js";
+import { resolveDerivedPath } from "../core/scene/derivedPath.js";
+
 //#region src/canvas/adapterDerivedPath.ts
-var n = /* @__PURE__ */ new WeakMap();
-function r(r) {
-	let i = n.get(r);
-	i === void 0 && (i = e(), n.set(r, i));
-	let a = i, o = (e) => typeof r.getWorldPose == "function" ? r.getWorldPose(e) : r.getPose(e), s = (e) => r.getChildren(e), c = (e) => {
-		let t = r.getNode(e);
-		if (t != null) return {
-			node: t,
-			pose: o(e),
+var scopes = /* @__PURE__ */ new WeakMap();
+/**
+* The path the node `id` computes from its dependencies, or `null` when it
+* derives none. Memoized against `adapter`, so every reader of one adapter
+* shares a route.
+*/
+function adapterDerivedPathOf(adapter) {
+	let scope = scopes.get(adapter);
+	if (scope === void 0) {
+		scope = createNodeMemoScope();
+		scopes.set(adapter, scope);
+	}
+	const slot = scope;
+	const poseOf = (id) => typeof adapter.getWorldPose === "function" ? adapter.getWorldPose(id) : adapter.getPose(id);
+	const childrenOf = (id) => adapter.getChildren(id);
+	const depOf = (id) => {
+		const node = adapter.getNode(id);
+		if (node === void 0 || node === null) return void 0;
+		return {
+			node,
+			pose: poseOf(id),
 			get path() {
-				return l(e);
+				return pathOf(id);
 			}
 		};
-	}, l = (e) => {
-		let n = r.getNode(e);
-		return !n || n.dependsOn === void 0 || n.derivePath === void 0 ? null : t(n, c, s, a);
 	};
-	return l;
+	const pathOf = (id) => {
+		const node = adapter.getNode(id);
+		if (!node || node.dependsOn === void 0 || node.derivePath === void 0) return null;
+		return resolveDerivedPath(node, depOf, childrenOf, slot);
+	};
+	return pathOf;
 }
-//#endregion
-export { r as adapterDerivedPathOf };
 
+//#endregion
+export { adapterDerivedPathOf };
 //# sourceMappingURL=adapterDerivedPath.js.map

package/dist/canvas/adapterDerivedPath.js.map

@@ -1 +1 @@
-{"version":3,"file":"adapterDerivedPath.js","names":["scopes","adapterDerivedPathOf","scope","adapter","createNodeMemoScope","slot","poseOf","id","childrenOf","depOf","node","pathOf","resolveDerivedPath"],"sources":["../../src/canvas/adapterDerivedPath.ts"],"sourcesContent":["/**\n * A derived node's path, resolved through an adapter with no scene in scope.\n *\n * A derivation reads its dependencies' nodes and where they are drawn, and\n * every adapter already answers both by id. Nothing pushes an invalidation\n * here, so freshness is the memo's own re-check of what the adapter answers.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { resolveDerivedPath, type PathDerivingNode } from 'core/scene/derivedPath';\nimport { createNodeMemoScope, type NodeMemoScope } from 'core/scene/nodeMemo';\nimport type { DerivedDep, Node, NodeId } from 'core/scene/types';\n\n/** What deriving reads of an adapter. */\nexport interface DerivingAdapter<TPose> {\n  getNode(id: string): unknown;\n  getPose(id: string): TPose;\n  /** Where the node is drawn, when the adapter composes poses. */\n  getWorldPose?(id: string): TPose;\n  getChildren(parentId: string | null): readonly string[];\n}\n\nconst scopes = new WeakMap<object, NodeMemoScope>();\n\n/**\n * The path the node `id` computes from its dependencies, or `null` when it\n * derives none. Memoized against `adapter`, so every reader of one adapter\n * shares a route.\n */\nexport function adapterDerivedPathOf<TPose>(\n  adapter: DerivingAdapter<TPose>,\n): (id: string) => Path | null {\n  let scope = scopes.get(adapter);\n  if (scope === undefined) {\n    scope = createNodeMemoScope();\n    scopes.set(adapter, scope);\n  }\n  const slot = scope;\n  const poseOf = (id: string): TPose =>\n    (typeof adapter.getWorldPose === 'function' ? adapter.getWorldPose(id) : adapter.getPose(id));\n  const childrenOf = (id: NodeId): readonly NodeId[] =>\n    adapter.getChildren(id) as readonly NodeId[];\n  const depOf = (id: NodeId): DerivedDep<TPose> | undefined => {\n    const node = adapter.getNode(id);\n    if (node === undefined || node === null) return undefined;\n    return {\n      node: node as Node<unknown, string, TPose>,\n      pose: poseOf(id),\n      get path(): Path | null { return pathOf(id); },\n    };\n  };\n  const pathOf = (id: string): Path | null => {\n    const node = adapter.getNode(id) as PathDerivingNode<TPose> | undefined | null;\n    if (!node || node.dependsOn === undefined || node.derivePath === undefined) return null;\n    return resolveDerivedPath(node, depOf, childrenOf, slot);\n  };\n  return pathOf;\n}\n"],"mappings":";;;AAqBA,IAAMA,oBAAS,IAAI,QAA+B;AAOlD,SAAgBC,EACd,GAC6B;CAC7B,IAAIC,IAAQF,EAAO,IAAIG,CAAO;CAC9B,AAAID,MAAU,KAAA,MACZ,IAAQE,EAAoB,GAC5BJ,EAAO,IAAIG,GAASD,CAAK;CAE3B,IAAMG,IAAOH,GACPI,KAAU,MACb,OAAOH,EAAQ,gBAAiB,aAAaA,EAAQ,aAAaI,CAAE,IAAIJ,EAAQ,QAAQI,CAAE,GACvFC,KAAc,MAClBL,EAAQ,YAAYI,CAAE,GAClBE,KAAS,MAA8C;EAC3D,IAAMC,IAAOP,EAAQ,QAAQI,CAAE;EAC/B,IAAIG,KAA+B,MACnC,OAAO;GACC;GACN,MAAMJ,EAAOC,CAAE;GACf,IAAI,OAAoB;IAAE,OAAOI,EAAOJ,CAAE;GAAG;EAC/C;CACF,GACMI,KAAU,MAA4B;EAC1C,IAAMD,IAAOP,EAAQ,QAAQI,CAAE;EAE/B,OADI,CAACG,KAAQA,EAAK,cAAc,KAAA,KAAaA,EAAK,eAAe,KAAA,IAAkB,OAC5EE,EAAmBF,GAAMD,GAAOD,GAAYH,CAAI;CACzD;CACA,OAAOM;AACT"}
+{"version":3,"file":"adapterDerivedPath.js","names":[],"sources":["../../src/canvas/adapterDerivedPath.ts"],"sourcesContent":["/**\n * A derived node's path, resolved through an adapter with no scene in scope.\n *\n * A derivation reads its dependencies' nodes and where they are drawn, and\n * every adapter already answers both by id. Nothing pushes an invalidation\n * here, so freshness is the memo's own re-check of what the adapter answers.\n */\nimport type { Path } from '@weasel-js/geom';\nimport { resolveDerivedPath, type PathDerivingNode } from 'core/scene/derivedPath';\nimport { createNodeMemoScope, type NodeMemoScope } from 'core/scene/nodeMemo';\nimport type { DerivedDep, Node, NodeId } from 'core/scene/types';\n\n/** What deriving reads of an adapter. */\nexport interface DerivingAdapter<TPose> {\n  getNode(id: string): unknown;\n  getPose(id: string): TPose;\n  /** Where the node is drawn, when the adapter composes poses. */\n  getWorldPose?(id: string): TPose;\n  getChildren(parentId: string | null): readonly string[];\n}\n\nconst scopes = new WeakMap<object, NodeMemoScope>();\n\n/**\n * The path the node `id` computes from its dependencies, or `null` when it\n * derives none. Memoized against `adapter`, so every reader of one adapter\n * shares a route.\n */\nexport function adapterDerivedPathOf<TPose>(\n  adapter: DerivingAdapter<TPose>,\n): (id: string) => Path | null {\n  let scope = scopes.get(adapter);\n  if (scope === undefined) {\n    scope = createNodeMemoScope();\n    scopes.set(adapter, scope);\n  }\n  const slot = scope;\n  const poseOf = (id: string): TPose =>\n    (typeof adapter.getWorldPose === 'function' ? adapter.getWorldPose(id) : adapter.getPose(id));\n  const childrenOf = (id: NodeId): readonly NodeId[] =>\n    adapter.getChildren(id) as readonly NodeId[];\n  const depOf = (id: NodeId): DerivedDep<TPose> | undefined => {\n    const node = adapter.getNode(id);\n    if (node === undefined || node === null) return undefined;\n    return {\n      node: node as Node<unknown, string, TPose>,\n      pose: poseOf(id),\n      get path(): Path | null { return pathOf(id); },\n    };\n  };\n  const pathOf = (id: string): Path | null => {\n    const node = adapter.getNode(id) as PathDerivingNode<TPose> | undefined | null;\n    if (!node || node.dependsOn === undefined || node.derivePath === undefined) return null;\n    return resolveDerivedPath(node, depOf, childrenOf, slot);\n  };\n  return pathOf;\n}\n"],"mappings":";;;;AAqBA,IAAM,yBAAS,IAAI,QAA+B;;;;;;AAOlD,SAAgB,qBACd,SAC6B;CAC7B,IAAI,QAAQ,OAAO,IAAI,OAAO;CAC9B,IAAI,UAAU,QAAW;EACvB,QAAQ,oBAAoB;EAC5B,OAAO,IAAI,SAAS,KAAK;CAC3B;CACA,MAAM,OAAO;CACb,MAAM,UAAU,OACb,OAAO,QAAQ,iBAAiB,aAAa,QAAQ,aAAa,EAAE,IAAI,QAAQ,QAAQ,EAAE;CAC7F,MAAM,cAAc,OAClB,QAAQ,YAAY,EAAE;CACxB,MAAM,SAAS,OAA8C;EAC3D,MAAM,OAAO,QAAQ,QAAQ,EAAE;EAC/B,IAAI,SAAS,UAAa,SAAS,MAAM,OAAO;EAChD,OAAO;GACC;GACN,MAAM,OAAO,EAAE;GACf,IAAI,OAAoB;IAAE,OAAO,OAAO,EAAE;GAAG;EAC/C;CACF;CACA,MAAM,UAAU,OAA4B;EAC1C,MAAM,OAAO,QAAQ,QAAQ,EAAE;EAC/B,IAAI,CAAC,QAAQ,KAAK,cAAc,UAAa,KAAK,eAAe,QAAW,OAAO;EACnF,OAAO,mBAAmB,MAAM,OAAO,YAAY,IAAI;CACzD;CACA,OAAO;AACT"}

package/dist/canvas/adapterPickSource.js

@@ -1,34 +1,60 @@
-import { adapterDerivedPathOf as e } from "./adapterDerivedPath.js";
+import { adapterDerivedPathOf } from "./adapterDerivedPath.js";
+
 //#region src/canvas/adapterPickSource.ts
-function t(t, n = {}) {
-	let r = /* @__PURE__ */ new Map(), i = (e) => typeof t.getWorldPose == "function" ? t.getWorldPose(e) : t.getPose(e), a = e(t), o = (e) => ({
-		...t.getNode(e),
-		id: e,
-		pose: i(e)
-	});
+/**
+* A source over a bare `SelectAdapter`, for consumers with no `Scene`.
+*
+* The adapter's tree is walked depth-first, parents before children — the
+* same back-to-front order `renderOrderNodes` produces for a single layer.
+*
+* `gates` come from whichever view is picking, never from the adapter.
+*/
+function adapterPickSource(adapter, gates = {}) {
+	let parents = /* @__PURE__ */ new Map();
+	const worldPose = (id) => typeof adapter.getWorldPose === "function" ? adapter.getWorldPose(id) : adapter.getPose(id);
+	const derived = adapterDerivedPathOf(adapter);
+	const nodeOf = (id) => {
+		return {
+			...adapter.getNode(id),
+			id,
+			pose: worldPose(id)
+		};
+	};
 	return {
 		order() {
-			let e = [], n = /* @__PURE__ */ new Map(), i = (r, a) => {
-				for (let s of t.getChildren(r)) {
-					let t = o(s);
-					a && n.set(s, a), e.push(t), i(s, t);
+			const out = [];
+			const next = /* @__PURE__ */ new Map();
+			const visit = (parentId, parent) => {
+				for (const childId of adapter.getChildren(parentId)) {
+					const node = nodeOf(childId);
+					if (parent) next.set(childId, parent);
+					out.push(node);
+					visit(childId, node);
 				}
 			};
-			return i(null, null), r = n, e;
+			visit(null, null);
+			parents = next;
+			return out;
 		},
-		...n.alphaOf ? { alphaOf: n.alphaOf } : {},
-		...n.layerIsPainted ? { layerIsPainted: n.layerIsPainted } : {},
-		...n.planeOf ? { planeOf: n.planeOf } : {},
-		poseOf: (e) => i(e.id),
-		derivedPathOf: (e) => a(e.id),
-		parentsOf(e) {
-			let t = [], n = r.get(e.id), i = /* @__PURE__ */ new Set();
-			for (; n && !i.has(n.id);) i.add(n.id), t.push(n), n = r.get(n.id);
-			return t;
+		...gates.alphaOf ? { alphaOf: gates.alphaOf } : {},
+		...gates.layerIsPainted ? { layerIsPainted: gates.layerIsPainted } : {},
+		...gates.planeOf ? { planeOf: gates.planeOf } : {},
+		poseOf: (node) => worldPose(node.id),
+		derivedPathOf: (node) => derived(node.id),
+		parentsOf(node) {
+			const chain = [];
+			let cur = parents.get(node.id);
+			const seen = /* @__PURE__ */ new Set();
+			while (cur && !seen.has(cur.id)) {
+				seen.add(cur.id);
+				chain.push(cur);
+				cur = parents.get(cur.id);
+			}
+			return chain;
 		}
 	};
 }
-//#endregion
-export { t as adapterPickSource };
 
+//#endregion
+export { adapterPickSource };
 //# sourceMappingURL=adapterPickSource.js.map