@pascal-app/viewer 1.0.3 → 1.0.5

package/dist/components/viewer/glb-walkthrough-controller.d.ts

@@ -14,7 +14,7 @@ export declare const EYE_LERP_SPEED = 12;
  * mesh collision) fed a collider built from the artifact's own geometry — so the
  * baked viewer walks the building with the same physics as the editor, without
  * the parametric scene. Pointer-lock drives look; WASD moves; Space jumps; Shift
- * sprints. Door/window interaction stays in `GlbScene` (its centre-ray HUD).
+ * sprints. Interaction stays in `GlbScene` (its centre-ray HUD).
  */
 export declare function GlbWalkthroughController({ url }: {
     url: string;

package/dist/components/viewer/glb-walkthrough-controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glb-walkthrough-controller.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-walkthrough-controller.tsx"],"names":[],"mappings":"AAiCA,eAAO,MAAM,eAAe,KAAK,CAAA;AAkBjC,eAAO,MAAM,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AAChF,eAAO,MAAM,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AACjF,eAAO,MAAM,kBAAkB,MAAM,CAAA;AACrC,eAAO,MAAM,mBAAmB,OAAO,CAAA;AACvC,eAAO,MAAM,iBAAiB,MAAM,CAAA;AACpC,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAClC,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAInC,eAAO,MAAM,eAAe,OAAO,CAAA;AACnC,eAAO,MAAM,cAAc,KAAK,CAAA;AA8LhC;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,GAAG,EAAE,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,sCAqPhE"}
+{"version":3,"file":"glb-walkthrough-controller.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-walkthrough-controller.tsx"],"names":[],"mappings":"AAkCA,eAAO,MAAM,eAAe,KAAK,CAAA;AAkBjC,eAAO,MAAM,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AAChF,eAAO,MAAM,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AACjF,eAAO,MAAM,kBAAkB,MAAM,CAAA;AACrC,eAAO,MAAM,mBAAmB,OAAO,CAAA;AACvC,eAAO,MAAM,iBAAiB,MAAM,CAAA;AACpC,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAClC,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAInC,eAAO,MAAM,eAAe,OAAO,CAAA;AACnC,eAAO,MAAM,cAAc,KAAK,CAAA;AAiMhC;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,GAAG,EAAE,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,sCA0PhE"}

package/dist/components/viewer/glb-walkthrough-controller.js

@@ -10,6 +10,7 @@ import { useGLTFKTX2 } from '../../hooks/use-gltf-ktx2';
 import { SCENE_LAYER } from '../../lib/layers';
 import useViewer from '../../store/use-viewer';
 import BVHEcctrl, {} from './bvh-ecctrl';
+import { applyWalkthroughCameraClipping } from './viewer-camera';
 // First-person FOV. The orbit camera is 50° (set on the Canvas), which feels
 // cramped on foot; ~60° vertical (~90° horizontal at 16:9) restores peripheral
 // awareness without wide-angle distortion. Applied only while walking — both
@@ -145,6 +146,11 @@ function buildGlbColliderWorld(scene) {
             return;
         if (!isEffectivelyVisible(mesh))
             return;
+        let ancestor = mesh;
+        while (ancestor && !ancestor.userData.proceduralMotion)
+            ancestor = ancestor.parent;
+        if (ancestor)
+            return;
         const kind = kindOf(mesh);
         if (kind && COLLIDER_EXCLUDED_KINDS.has(kind))
             return;
@@ -172,7 +178,7 @@ function buildGlbColliderWorld(scene) {
     ;
     merged.computeBoundsTree = computeBoundsTree;
     merged.disposeBoundsTree = disposeBoundsTree;
-    merged.computeBoundsTree({ maxLeafSize: 12, strategy: 0 });
+    merged.computeBoundsTree({ targetLeafSize: 12, strategy: 0 });
     merged.computeBoundingBox();
     const mesh = new Mesh(merged, colliderMaterial);
     mesh.raycast = acceleratedRaycast;
@@ -220,7 +226,7 @@ function resolveGlbSpawn(scene) {
  * mesh collision) fed a collider built from the artifact's own geometry — so the
  * baked viewer walks the building with the same physics as the editor, without
  * the parametric scene. Pointer-lock drives look; WASD moves; Space jumps; Shift
- * sprints. Door/window interaction stays in `GlbScene` (its centre-ray HUD).
+ * sprints. Interaction stays in `GlbScene` (its centre-ray HUD).
  */
 export function GlbWalkthroughController({ url }) {
     const { camera, gl } = useThree();
@@ -273,6 +279,11 @@ export function GlbWalkthroughController({ url }) {
             cam.updateProjectionMatrix();
         };
     }, [camera]);
+    useEffect(() => {
+        if (!camera.isPerspectiveCamera)
+            return;
+        return applyWalkthroughCameraClipping(camera);
+    }, [camera]);
     useEffect(() => {
         worldRef.current = world;
         if (world) {

package/dist/components/viewer/index.d.ts

@@ -1,8 +1,9 @@
-import { type AnyNodeId } from '@pascal-app/core';
+import { type AnyNodeId, type SitePresentation } from '@pascal-app/core';
 import { type ThreeElement } from '@react-three/fiber';
 import { type ComponentType } from 'react';
 import * as THREE from 'three/webgpu';
 import type { ColorPreset, RenderShading } from '../../lib/materials';
+import { type ViewerBreadcrumbHandler } from '../../lib/pointer-events';
 import { type RenderContext } from '../../store/use-viewer';
 import { type HoverStyles } from './post-processing';
 declare module '@react-three/fiber' {
@@ -10,6 +11,13 @@ declare module '@react-three/fiber' {
         lineBasicNodeMaterial: ThreeElement<typeof THREE.LineBasicNodeMaterial>;
     }
 }
+/**
+ * The scene-ready gate's own test as a count — nodes still to build or load
+ * (an item holds its mark until its model settles), 1 while the graph has
+ * not mounted. A capture waits on it, and reads a count that stops moving
+ * as a node no system will ever settle.
+ */
+export declare function pendingSceneBuildCount(): number;
 export interface ViewerImmersiveSession {
     Session: ComponentType<{
         children: React.ReactNode;
@@ -32,6 +40,8 @@ interface ViewerProps {
         textures?: boolean;
         colorPreset?: ColorPreset;
     };
+    /** Saved site appearance when rendering a baked asset without its graph. Null ignores it. */
+    presentation?: SitePresentation | null;
     /**
      * Visibility filter on the live canvas. When non-null, every registered
      * node group whose id is not in `isolate` (or in the isolated set's
@@ -49,6 +59,19 @@ interface ViewerProps {
      */
     sceneReadyKey?: string | number | null;
     onSceneReadyChange?: (ready: boolean) => void;
+    /**
+     * Called when something in the scene throws while rendering (a node
+     * renderer or system, such as a plugin's lazy chunk that failed to load).
+     * The scene boundary still renders nothing in its place; this lets a host
+     * that must not carry on silently (a bake) fail with its own error.
+     */
+    onRenderError?: (cause: unknown) => void;
+    /**
+     * Called with diagnostics worth keeping on a host's error-reporter trail,
+     * such as `raycast_invalid_material` when a pointer raycast skips a mesh
+     * whose geometry groups point past its material array.
+     */
+    onBreadcrumb?: ViewerBreadcrumbHandler;
     /**
      * Wall-clock give-up cap for scene readiness, replacing the default
      * frame-count cap. Set it on hosts whose frame cadence is decoupled from

package/dist/components/viewer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,SAAS,EAMf,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAkB,KAAK,YAAY,EAAsB,MAAM,oBAAoB,CAAA;AAC1F,OAAO,EACL,KAAK,aAAa,EAOnB,MAAM,OAAO,CAAA;AACd,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAKrC,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAKrE,OAAkB,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAA;AActE,OAAuB,EAAwB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAY1F,OAAO,QAAQ,oBAAoB,CAAC;IAOlC,UAAU,aAAa;QACrB,qBAAqB,EAAE,YAAY,CAAC,OAAO,KAAK,CAAC,qBAAqB,CAAC,CAAA;KACxE;CACF;AAoRD,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAA;IACrD,KAAK,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAA;IACnD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACnC;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,gBAAgB,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAA;IACvC,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,aAAa,CAAC,EAAE;QACd,OAAO,CAAC,EAAE,aAAa,CAAA;QACvB,QAAQ,CAAC,EAAE,OAAO,CAAA;QAClB,WAAW,CAAC,EAAE,WAAW,CAAA;KAC1B,CAAA;IACD;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,SAAS,EAAE,GAAG,IAAI,CAAA;IAC5B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IACtC,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IAC7C;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,6EAA6E;IAC7E,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,sEAAsE;IACtE,SAAS,CAAC,EAAE,sBAAsB,CAAA;CACnC;AAED,yDAAyD;AACzD,MAAM,MAAM,YAAY,GAAG;IACzB;;;;;OAKG;IACH,WAAW,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,IAAI,GAAG,IAAI,CAAA;CAC3C,CAAA;AAED,QAAA,MAAM,MAAM,sGAuPV,CAAA;AAyEF,eAAe,MAAM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/index.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,SAAS,EAGd,KAAK,gBAAgB,EAKtB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAkB,KAAK,YAAY,EAAsB,MAAM,oBAAoB,CAAA;AAC1F,OAAO,EACL,KAAK,aAAa,EAOnB,MAAM,OAAO,CAAA;AACd,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAKrC,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACrE,OAAO,EAAuB,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAI5F,OAAkB,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAA;AActE,OAAuB,EAAwB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAa1F,OAAO,QAAQ,oBAAoB,CAAC;IAOlC,UAAU,aAAa;QACrB,qBAAqB,EAAE,YAAY,CAAC,OAAO,KAAK,CAAC,qBAAqB,CAAC,CAAA;KACxE;CACF;AAsPD;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAS/C;AAsED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAA;IACrD,KAAK,EAAE,aAAa,CAAC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAA;IACnD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACnC;AAED,UAAU,WAAW;IACnB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,gBAAgB,CAAC,EAAE,SAAS,GAAG,QAAQ,CAAA;IACvC,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,aAAa,CAAC,EAAE;QACd,OAAO,CAAC,EAAE,aAAa,CAAA;QACvB,QAAQ,CAAC,EAAE,OAAO,CAAA;QAClB,WAAW,CAAC,EAAE,WAAW,CAAA;KAC1B,CAAA;IACD,6FAA6F;IAC7F,YAAY,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAA;IACtC;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,SAAS,EAAE,GAAG,IAAI,CAAA;IAC5B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAA;IACtC,kBAAkB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IAC7C;;;;;OAKG;IACH,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IACxC;;;;OAIG;IACH,YAAY,CAAC,EAAE,uBAAuB,CAAA;IACtC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,6EAA6E;IAC7E,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,sEAAsE;IACtE,SAAS,CAAC,EAAE,sBAAsB,CAAA;CACnC;AAED,yDAAyD;AACzD,MAAM,MAAM,YAAY,GAAG;IACzB;;;;;OAKG;IACH,WAAW,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,IAAI,GAAG,IAAI,CAAA;CAC3C,CAAA;AAED,QAAA,MAAM,MAAM,sGA2RV,CAAA;eAyEa,MAAM"}

package/dist/components/viewer/index.js

@@ -1,6 +1,6 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { nodeRegistry, RoofElevationSystem, StairOpeningSystem, sceneRegistry, useScene, } from '@pascal-app/core';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { nodeRegistry, RoofElevationSystem, StairOpeningSystem, sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
 import { Canvas, extend, useFrame, useThree } from '@react-three/fiber';
 import { forwardRef, useEffect, useImperativeHandle, useLayoutEffect, useRef, useState, } from 'react';
 import * as THREE from 'three/webgpu';
@@ -16,9 +16,9 @@ import useViewer, {} from '../../store/use-viewer';
 import { FloorElevationSystem } from '../../systems/floor-elevation/floor-elevation-system';
 import { GeometrySystem } from '../../systems/geometry/geometry-system';
 import { PerfActionSettleSystem } from '../../systems/perf-action-settle/perf-action-settle-system';
+import { getPendingRoofMergeCount } from '../../systems/roof/roof-system';
 import { subscribeWallBuildInteractions } from '../../systems/wall/wall-build-lifecycle';
 import { ImmersiveXRPresentationProvider } from '../../xr/presentation-context';
-import { ErrorBoundary } from '../error-boundary';
 import { SceneRenderer } from '../renderers/scene-renderer';
 import { BATCH_SPIKE_ENABLED, BatchedMeshSpike } from './batched-mesh-spike';
 import FrameLimiter from './frame-limiter';
@@ -28,6 +28,7 @@ import { PerfPanel } from './perf-panel';
 import { PointerRaycastLayers } from './pointer-raycast-layers';
 import PostProcessing, { DEFAULT_HOVER_STYLES } from './post-processing';
 import { RegisteredSystems } from './registered-systems';
+import { composeRenderErrorHandlers, SceneErrorBoundary } from './render-error';
 import { useSceneAtmosphere } from './scene-atmosphere';
 import { SceneBvh } from './scene-bvh';
 import { SelectionManager } from './selection-manager';
@@ -83,6 +84,35 @@ const warnedEmptyDraw = process.env.NODE_ENV === 'production' ? null : new WeakS
  * carry the same check inline).
  */
 function installEmptyDrawGuard(renderer) {
+    // The render-object hook is one funnel; the post-processing passes and the
+    // outline node reach the backend by other paths, and a geometry whose
+    // draw range is empty still slips past a position count. The backend's
+    // own `draw` is the last gate before the command encoder — a zero-vertex
+    // draw leaves a vertex-buffer slot unbound ("Vertex buffer slot 1 required
+    // by [RenderPipeline "…MeshLambertNodeMaterial…"] was not set … Draw(0, …)",
+    // 2026-09-10) and poisons the whole encoder, so it is dropped here.
+    const backend = renderer.backend;
+    if (backend && typeof backend.draw === 'function' && !backend.__pascalDrawGuard) {
+        const draw = backend.draw.bind(backend);
+        backend.draw = (renderObject, ...rest) => {
+            const geometry = renderObject?.geometry;
+            const range = geometry?.drawRange;
+            if (!hasDrawableGeometry(geometry) || (range && range.count === 0)) {
+                if (warnedEmptyDraw && geometry && !warnedEmptyDraw.has(geometry)) {
+                    warnedEmptyDraw.add(geometry);
+                    console.warn('[viewer] dropped a zero-vertex draw at the backend', {
+                        name: renderObject?.object
+                            ?.name,
+                        type: renderObject?.object
+                            ?.type,
+                    });
+                }
+                return;
+            }
+            return draw(renderObject, ...rest);
+        };
+        backend.__pascalDrawGuard = true;
+    }
     renderer.setRenderObjectFunction((object, scene, camera, geometry, material, group, lightsNode, clippingContext, passId) => {
         if (!hasDrawableGeometry(geometry)) {
             if (warnedEmptyDraw && !warnedEmptyDraw.has(geometry ?? object)) {
@@ -134,16 +164,16 @@ function GPUDeviceWatcher({ intentionalWebGL = false }) {
     return null;
 }
 function ToneMappingExposure() {
-    const sceneTheme = useViewer((state) => state.sceneTheme);
+    const appearance = useViewer((state) => state.sceneAppearance);
     const atmosphere = useSceneAtmosphere();
     const gl = useThree((state) => state.gl);
     const invalidate = useThree((state) => state.invalidate);
     useEffect(() => {
         if (atmosphere)
             return;
-        gl.toneMappingExposure = getSceneTheme(sceneTheme).toneMappingExposure;
+        gl.toneMappingExposure = appearance.toneMappingExposure;
         invalidate();
-    }, [atmosphere, gl, invalidate, sceneTheme]);
+    }, [atmosphere, gl, invalidate, appearance]);
     useFrame(() => {
         if (!atmosphere)
             return;
@@ -152,34 +182,54 @@ function ToneMappingExposure() {
     return null;
 }
 function ImmersiveXRBackground() {
-    const background = useViewer((state) => getSceneTheme(state.sceneTheme).background);
+    const background = useViewer((state) => state.sceneAppearance.background);
     return _jsx("color", { args: [background], attach: "background" });
 }
+function isPendingSceneBuild(id, { nodes, rootNodeIds }) {
+    const node = nodes[id];
+    if (!node)
+        return false;
+    // Unreachable nodes (orphaned by a broken detach: the parent doesn't list
+    // them in `children`, or no parent and not a root) never render — every
+    // renderer enumerates the parent's `children` array — so no system will
+    // ever build them or clear their mark. They must not hold scene-ready
+    // hostage (observed in prod scene data: two dangling windows kept every
+    // bake of that scene waiting out the full readiness cap).
+    const parent = node.parentId ? nodes[node.parentId] : undefined;
+    const reachable = parent
+        ? parent.children?.includes(id) === true
+        : rootNodeIds.includes(id);
+    if (!reachable)
+        return false;
+    const def = nodeRegistry.get(node.type);
+    return Boolean(def?.geometry || def?.capabilities?.floorPlaced || DIRTY_BUILD_KINDS.has(node.type));
+}
 function hasPendingSceneBuildWork() {
-    const { dirtyNodes, nodes, rootNodeIds } = useScene.getState();
-    for (const id of dirtyNodes) {
-        const node = nodes[id];
-        if (!node)
-            continue;
-        // Unreachable nodes (orphaned by a broken detach: the parent doesn't list
-        // them in `children`, or no parent and not a root) never render — every
-        // renderer enumerates the parent's `children` array — so no system will
-        // ever build them or clear their mark. They must not hold scene-ready
-        // hostage (observed in prod scene data: two dangling windows kept every
-        // bake of that scene waiting out the full readiness cap).
-        const parent = node.parentId ? nodes[node.parentId] : undefined;
-        const reachable = parent
-            ? parent.children?.includes(id) === true
-            : rootNodeIds.includes(id);
-        if (!reachable)
-            continue;
-        const def = nodeRegistry.get(node.type);
-        if (def?.geometry || def?.capabilities?.floorPlaced || DIRTY_BUILD_KINDS.has(node.type)) {
+    const state = useScene.getState();
+    for (const id of state.dirtyNodes) {
+        if (isPendingSceneBuild(id, state))
             return true;
-        }
     }
     return false;
 }
+/**
+ * The scene-ready gate's own test as a count — nodes still to build or load
+ * (an item holds its mark until its model settles), 1 while the graph has
+ * not mounted. A capture waits on it, and reads a count that stops moving
+ * as a node no system will ever settle.
+ */
+export function pendingSceneBuildCount() {
+    if (!hasCommittedSceneRoot())
+        return 1;
+    const state = useScene.getState();
+    // A roof's dirty mark clears when its merged shell is queued, frames before it is built.
+    let count = getPendingRoofMergeCount();
+    for (const id of state.dirtyNodes) {
+        if (isPendingSceneBuild(id, state))
+            count++;
+    }
+    return count;
+}
 function hasCommittedSceneRoot() {
     const { nodes, rootNodeIds } = useScene.getState();
     if (rootNodeIds.length === 0)
@@ -233,7 +283,7 @@ function SceneReadyTracker({ onSceneReadyChange, sceneReadyKey, sceneReadyMaxWai
     }, 10);
     return null;
 }
-const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVER_STYLES, selectionManager = 'default', perf = false, useBvh = true, renderContext = 'editor', transparent, defaultRender, isolate, sceneReadyKey, onSceneReadyChange, sceneReadyMaxWaitMs, maxFps = 50, disablePostFx = false, renderPaused = false, immersive, }, ref) {
+const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVER_STYLES, selectionManager = 'default', perf = false, useBvh = true, renderContext = 'editor', transparent, defaultRender, presentation: suppliedPresentation, isolate, sceneReadyKey, onSceneReadyChange, onRenderError, onBreadcrumb, sceneReadyMaxWaitMs, maxFps = 50, disablePostFx = false, renderPaused = false, immersive, }, ref) {
     useEffect(() => {
         if (nodeRegistry.size === 0) {
             console.warn('[viewer] Node registry is empty. Install @pascal-app/nodes and call await loadPlugin(builtinPlugin) before mounting <Viewer>.');
@@ -256,9 +306,19 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
                 clearIsolation();
         };
     }, [isolate]);
-    const [pointerEvents] = useState(() => choosePointerEvents());
+    const onBreadcrumbRef = useRef(onBreadcrumb);
+    onBreadcrumbRef.current = onBreadcrumb;
+    const [pointerEvents] = useState(() => choosePointerEvents(undefined, (breadcrumb) => onBreadcrumbRef.current?.(breadcrumb)));
     const [rendererInitFailed, setRendererInitFailed] = useState(false);
-    const isDark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark');
+    const isDark = useViewer((state) => state.sceneAppearance.appearance === 'dark');
+    const sceneTheme = useViewer((state) => state.sceneTheme);
+    const previousLampTheme = useRef(sceneTheme);
+    useEffect(() => {
+        useInteractive
+            .getState()
+            .setLampDefault(getSceneTheme(sceneTheme).appearance === 'dark', previousLampTheme.current !== sceneTheme);
+        previousLampTheme.current = sceneTheme;
+    }, [sceneTheme]);
     const transparentBackground = useViewer((state) => state.transparentBackground);
     // The shadows toggle drives `renderer.shadowMap.enabled` (via the Canvas
     // `shadows` prop) rather than the lights' `castShadow`: toggling castShadow
@@ -276,15 +336,28 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
             useViewer.getState().setTransparentBackground(false);
         };
     }, [transparent]);
+    const scenePresentation = useScene((state) => {
+        for (const id of state.rootNodeIds) {
+            const node = state.nodes[id];
+            if (node?.type === 'site')
+                return node.presentation;
+        }
+        return undefined;
+    });
+    const presentation = suppliedPresentation === undefined ? scenePresentation : (suppliedPresentation ?? undefined);
+    const projectId = useViewer((state) => state.projectId);
+    useLayoutEffect(() => {
+        // Project selection clears the previous look even when both graphs share a preset.
+        if (useViewer.getState().projectId === projectId)
+            useViewer.getState().setProjectPresentation(presentation);
+    }, [presentation, projectId]);
     const defaultShading = defaultRender?.shading;
     const defaultTextures = defaultRender?.textures;
     const defaultColorPreset = defaultRender?.colorPreset;
     const hasDefaultRender = defaultRender != null;
     useEffect(() => {
         const ctx = renderContext;
-        useViewer.getState().setRenderContext(ctx);
-        const { shading, shadingByContext, setShading } = useViewer.getState();
-        setShading(shadingByContext[ctx] ?? defaultShading ?? shading);
+        useViewer.getState().setRenderContext(ctx, defaultShading);
         if (!hasDefaultRender || typeof window === 'undefined')
             return;
         let persistedState = {};
@@ -354,7 +427,8 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
                                     trackTimestamp: PERF_OVERLAY_ENABLED,
                                 });
                                 renderer.toneMapping = THREE.ACESFilmicToneMapping;
-                                renderer.toneMappingExposure = getSceneTheme(useViewer.getState().sceneTheme).toneMappingExposure;
+                                renderer.toneMappingExposure =
+                                    useViewer.getState().sceneAppearance.toneMappingExposure;
                                 return renderer;
                             },
                         });
@@ -382,11 +456,11 @@ const Viewer = forwardRef(function Viewer({ children, hoverStyles = DEFAULT_HOVE
                 }, shadows: {
                     type: THREE.PCFShadowMap,
                     enabled: shadowsEnabled,
-                }, children: _jsx(ImmersiveXRPresentationProvider, { enabled: immersiveActive, children: ImmersiveSession ? (_jsx(ImmersiveSession, { children: _jsx(ViewerScene, { disablePostFx: true, hoverStyles: hoverStyles, immersiveXR: true, onRenderError: immersive.onError, onSceneReadyChange: onSceneReadyChange, perf: perf, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs, selectionManager: selectionManager, useBvh: useBvh, SceneWrapper: immersive.Scene, children: children }) })) : (_jsxs(_Fragment, { children: [_jsx(FrameLimiter, { fps: maxFps, paused: renderPaused }), _jsx(ViewerScene, { disablePostFx: disablePostFx, hoverStyles: hoverStyles, onSceneReadyChange: onSceneReadyChange, perf: perf, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs, selectionManager: selectionManager, useBvh: useBvh, children: children })] })) }) }, immersiveActive ? 'webgl-xr' : 'webgpu')] }));
+                }, children: _jsx(ImmersiveXRPresentationProvider, { enabled: immersiveActive, children: ImmersiveSession ? (_jsx(ImmersiveSession, { children: _jsx(ViewerScene, { disablePostFx: true, hoverStyles: hoverStyles, immersiveXR: true, renderErrorHandlers: [immersive.onError, onRenderError], onSceneReadyChange: onSceneReadyChange, perf: perf, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs, selectionManager: selectionManager, useBvh: useBvh, SceneWrapper: immersive.Scene, children: children }) })) : (_jsxs(_Fragment, { children: [_jsx(FrameLimiter, { fps: maxFps, onFrameError: composeRenderErrorHandlers(onRenderError), paused: renderPaused }), _jsx(ViewerScene, { disablePostFx: disablePostFx, hoverStyles: hoverStyles, renderErrorHandlers: [onRenderError], onSceneReadyChange: onSceneReadyChange, perf: perf, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs, selectionManager: selectionManager, useBvh: useBvh, children: children })] })) }) }, immersiveActive ? 'webgl-xr' : 'webgpu')] }));
 });
-function ViewerScene({ children, disablePostFx, hoverStyles, immersiveXR = false, onRenderError, onSceneReadyChange, perf, sceneReadyKey, sceneReadyMaxWaitMs, selectionManager, useBvh, SceneWrapper, }) {
+function ViewerScene({ children, disablePostFx, hoverStyles, immersiveXR = false, renderErrorHandlers, onSceneReadyChange, perf, sceneReadyKey, sceneReadyMaxWaitMs, selectionManager, useBvh, SceneWrapper, }) {
     const renderedScene = useBvh ? (_jsx(SceneBvh, { children: _jsx(SceneRenderer, {}) })) : (_jsx(SceneRenderer, {}));
     const spatialScene = (_jsxs(_Fragment, { children: [renderedScene, _jsx(FloorElevationSystem, {}), _jsx(GeometrySystem, {}), _jsx(StairOpeningSystem, {}), _jsx(RoofElevationSystem, {}), _jsx(RegisteredSystems, {}), BATCH_SPIKE_ENABLED && _jsx(BatchedMeshSpike, {}), children] }));
-    return (_jsxs(_Fragment, { children: [_jsx(ViewerCamera, { immersiveXR: immersiveXR }), immersiveXR && _jsx(ImmersiveXRBackground, {}), _jsx(PointerRaycastLayers, {}), _jsx(GPUDeviceWatcher, { intentionalWebGL: immersiveXR }), _jsx(ToneMappingExposure, {}), _jsx(SceneReadyTracker, { onSceneReadyChange: onSceneReadyChange, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs }), _jsxs(ErrorBoundary, { fallback: null, onError: onRenderError, scope: "viewer-scene", children: [_jsx(Lights, {}), SceneWrapper ? _jsx(SceneWrapper, { children: spatialScene }) : spatialScene, !immersiveXR && _jsx(PostProcessing, { disablePostFx: disablePostFx, hoverStyles: hoverStyles }), selectionManager === 'default' && _jsx(SelectionManager, {}), (perf || PERF_OVERLAY_ENABLED) && _jsx(PerfMonitor, {}), (perf || PERF_OVERLAY_ENABLED) && _jsx(PerfActionSettleSystem, {})] })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(ViewerCamera, { immersiveXR: immersiveXR }), immersiveXR && _jsx(ImmersiveXRBackground, {}), _jsx(PointerRaycastLayers, {}), _jsx(GPUDeviceWatcher, { intentionalWebGL: immersiveXR }), _jsx(ToneMappingExposure, {}), _jsx(SceneReadyTracker, { onSceneReadyChange: onSceneReadyChange, sceneReadyKey: sceneReadyKey, sceneReadyMaxWaitMs: sceneReadyMaxWaitMs }), _jsxs(SceneErrorBoundary, { handlers: renderErrorHandlers, children: [_jsx(Lights, {}), SceneWrapper ? _jsx(SceneWrapper, { children: spatialScene }) : spatialScene, !immersiveXR && _jsx(PostProcessing, { disablePostFx: disablePostFx, hoverStyles: hoverStyles }), selectionManager === 'default' && _jsx(SelectionManager, {}), (perf || PERF_OVERLAY_ENABLED) && _jsx(PerfMonitor, {}), (perf || PERF_OVERLAY_ENABLED) && _jsx(PerfActionSettleSystem, {})] })] }));
 }
 export default Viewer;

package/dist/components/viewer/lights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lights.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/lights.tsx"],"names":[],"mappings":"AA6EA,wBAAgB,MAAM,gCAqQrB"}
+{"version":3,"file":"lights.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/lights.tsx"],"names":[],"mappings":"AAmGA,wBAAgB,MAAM,gCAiVrB"}

package/dist/components/viewer/lights.js

@@ -1,12 +1,14 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { sceneRegistry } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
-import { useMemo, useRef } from 'react';
+import { useEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three/webgpu';
+import { getKeyLightDirectionOverride } from '../../lib/key-light-override';
 import { SHADOW_ONLY_LAYER } from '../../lib/layers';
-import { getSceneTheme } from '../../lib/scene-themes';
-import useViewer from '../../store/use-viewer';
+import { registerSkyLights } from '../../lib/underground-ambiance';
+import useViewer, { groundVeiled } from '../../store/use-viewer';
 import { useSceneAtmosphere } from './scene-atmosphere';
+import { UndergroundAmbiance } from './underground-ambiance';
 // Diagnostic toggle: `?disable=shadows` skips the shadow-map render pass
 // (which doubles draw calls for every shadow-casting mesh) so you can
 // isolate how much of the baseline GPU cost is shadows vs. raw geometry.
@@ -58,10 +60,42 @@ const SHADOW_MARGIN = 3;
 const SHADOW_BACKOFF = 10;
 // Fallback radius when the scene has no building geometry yet (empty scene).
 const SHADOW_FALLBACK_RADIUS = 30;
+/**
+ * The live counterpart of the interior capture's lighting: a light that shines from the eye along
+ * the view, casting no shadow. Over a veiled ground the floor below grade still lies in the
+ * shadow of the storeys above and has no sky: this keeps it from reading as a cave. The
+ * underground ambiance owns its intensity (the veil's 1 at rest, brought up as the sky's light
+ * comes down when the eye dives, back to rest in a capture); the hemisphere's ground side is
+ * lifted in `Lights`.
+ */
+function UndergroundFill({ lightRef }) {
+    const look = useMemo(() => new THREE.Vector3(), []);
+    useFrame(({ camera }) => {
+        const fill = lightRef.current;
+        if (!fill)
+            return;
+        camera.getWorldPosition(fill.position);
+        fill.target.position.copy(fill.position).add(camera.getWorldDirection(look));
+        fill.target.updateMatrixWorld();
+    });
+    return _jsx("directionalLight", { intensity: 0, ref: lightRef });
+}
 export function Lights() {
-    const sceneTheme = useViewer((state) => state.sceneTheme);
-    const theme = getSceneTheme(sceneTheme);
+    const theme = useViewer((state) => state.sceneAppearance);
     const shadows = useViewer((state) => state.shadows);
+    const veiled = useViewer(groundVeiled);
+    // The eye's fill is mounted once, and stays: adding or taking away a light changes every lit
+    // material's shader (a runtime compile that lagged the switch to a basement), so it is there
+    // from the moment the scene has a level below grade or the eye may dive (or a view first needs
+    // it) and only its intensity, the ambiance's, moves.
+    const wantsFill = useViewer((state) => state.hasLevelBelowGrade ||
+        state.diveAvailable ||
+        groundVeiled(state) ||
+        state.ambianceActive);
+    const fillMounted = useRef(false);
+    if (wantsFill)
+        fillMounted.current = true;
+    const filled = fillMounted.current;
     const atmosphere = useSceneAtmosphere();
     const lightSlots = useMemo(() => Array.from({ length: atmosphere ? 2 : theme.lights.length }, (_, index) => index), [atmosphere, theme.lights.length]);
     const lightRefs = useRef([]);
@@ -78,6 +112,17 @@ export function Lights() {
     const shadowHelpers = useRef([]);
     const hemiRef = useRef(null);
     const ambientRef = useRef(null);
+    const fillRef = useRef(null);
+    // What the eye's fill shines at with no ambiance: the veil's own 1 over a veiled ground.
+    const fillRest = useRef(0);
+    fillRest.current = veiled ? 1 : 0;
+    // The underground ambiance moves the sky's own light and the eye's fill for the frame it draws.
+    useEffect(() => registerSkyLights(() => ({
+        ambient: ambientRef.current,
+        hemisphere: hemiRef.current,
+        fill: fillRef.current,
+        fillRest: fillRest.current,
+    })), []);
     const initialized = useRef(false);
     const lightTargets = useRef([]);
     const targets = useMemo(() => ({
@@ -88,6 +133,8 @@ export function Lights() {
     useFrame((state, delta) => {
         // Clamp delta to avoid huge jumps on tab switch.
         const dt = Math.min(delta, 0.1) * 4;
+        const sourceShadow = atmosphere ? undefined : theme.lights[0]?.shadow;
+        const sourceCamera = sourceShadow?.camera;
         // Atmosphere directions are stable mutable vectors. Keep both light
         // resources mounted and move them imperatively so time/angle changes never
         // rebuild materials or shadow resources.
@@ -102,12 +149,23 @@ export function Lights() {
                 light.target.updateMatrixWorld();
             }
         }
+        else {
+            for (const index of lightSlots) {
+                const light = lightRefs.current[index];
+                const config = theme.lights[index];
+                if (!light || !config || (index === 0 && shadows && !sourceCamera))
+                    continue;
+                light.position.set(...config.position);
+                light.target.position.set(...(config.target ?? [0, 0, 0]));
+                light.target.updateMatrixWorld();
+            }
+        }
         // Fit the single key-light shadow frustum to the BUILDING geometry rather
         // than the camera. The source controls its direction; only its distance and
         // frustum extents are derived here.
         if (shadows) {
             const now = state.clock.elapsedTime;
-            if (now - lastBoundsTime.current >= BOUNDS_REFRESH_INTERVAL) {
+            if (!sourceCamera && now - lastBoundsTime.current >= BOUNDS_REFRESH_INTERVAL) {
                 lastBoundsTime.current = now;
                 const box = boundsBox.current.makeEmpty();
                 for (const [id, obj] of sceneRegistry.nodes) {
@@ -137,15 +195,27 @@ export function Lights() {
             const castsShadow = atmosphere ? true : Boolean(themeKey?.castShadow);
             if (light && castsShadow) {
                 const focus = shadowFocus.current;
-                const size = shadowRadius.current * SHADOW_MARGIN_SCALE + SHADOW_MARGIN;
+                const size = shadowRadius.current * SHADOW_MARGIN_SCALE +
+                    Math.min(SHADOW_MARGIN, shadowRadius.current * 0.25);
                 const distance = size + SHADOW_BACKOFF;
                 const near = SHADOW_BACKOFF;
-                const far = distance + size;
-                if (atmosphere) {
+                // Receivers can lie beyond the caster's bounds, especially under a low sun.
+                const far = distance + shadowRadius.current * SHADOW_MARGIN_SCALE + SHADOW_MARGIN;
+                const directionOverride = getKeyLightDirectionOverride();
+                if (directionOverride) {
+                    shadowDir.current.set(...directionOverride);
+                }
+                else if (atmosphere) {
                     shadowDir.current.copy(atmosphere.sunDirection);
                 }
                 else if (themeKey) {
                     shadowDir.current.set(...themeKey.position);
+                    if (themeKey.target) {
+                        const [x, y, z] = themeKey.target;
+                        shadowDir.current.x -= x;
+                        shadowDir.current.y -= y;
+                        shadowDir.current.z -= z;
+                    }
                 }
                 else {
                     shadowDir.current.set(0, 1, 0);
@@ -153,18 +223,38 @@ export function Lights() {
                 if (shadowDir.current.lengthSq() === 0)
                     shadowDir.current.set(0, 1, 0);
                 shadowDir.current.normalize().multiplyScalar(distance);
-                light.position.copy(focus).add(shadowDir.current);
-                light.target.position.copy(focus);
-                light.target.updateMatrixWorld();
+                if (!sourceCamera) {
+                    light.position.copy(focus).add(shadowDir.current);
+                    light.target.position.copy(focus);
+                    light.target.updateMatrixWorld();
+                }
+                else if (directionOverride && themeKey) {
+                    const [x, y, z] = themeKey.position;
+                    const [tx, ty, tz] = themeKey.target ?? [0, 0, 0];
+                    shadowDir.current.normalize().multiplyScalar(Math.hypot(x - tx, y - ty, z - tz) || 1);
+                    light.position.set(tx, ty, tz).add(shadowDir.current);
+                }
                 const cam = light.shadow?.camera;
                 if (cam) {
+                    // The calibrated building bias detaches furniture-scale contact shadows.
+                    // Small scenes need finer shadow edges too; retain the building map budget.
+                    const smallScene = !sourceCamera && shadowRadius.current < 1.5;
+                    light.shadow.mapSize.setScalar(sourceShadow?.mapSize ?? (smallScene ? 2048 : 1024));
+                    light.shadow.bias = sourceShadow?.bias ?? SHADOW_DEPTH_BIAS;
+                    light.shadow.radius = sourceShadow?.radius ?? 2;
+                    light.shadow.normalBias =
+                        sourceShadow?.normalBias ??
+                            (smallScene
+                                ? Math.min(SHADOW_NORMAL_BIAS, (4 * size) / light.shadow.mapSize.x)
+                                : SHADOW_NORMAL_BIAS);
                     cam.layers.enable(SHADOW_ONLY_LAYER);
-                    cam.left = -size;
-                    cam.right = size;
-                    cam.top = size;
-                    cam.bottom = -size;
-                    cam.near = near;
-                    cam.far = far;
+                    // A retained source frustum keeps distant context from diluting the building's shadows.
+                    cam.left = sourceCamera?.left ?? -size;
+                    cam.right = sourceCamera?.right ?? size;
+                    cam.top = sourceCamera?.top ?? size;
+                    cam.bottom = sourceCamera?.bottom ?? -size;
+                    cam.near = sourceCamera?.near ?? near;
+                    cam.far = sourceCamera?.far ?? far;
                     cam.updateProjectionMatrix();
                     if (SHADOW_CAMERA_DEBUG) {
                         let helper = shadowHelpers.current[0];
@@ -210,7 +300,7 @@ export function Lights() {
                 light.color.lerp(target, dt);
             }
             if (index === 0 && light.shadow?.intensity !== undefined) {
-                const shadowIntensity = intensity <= 1 ? intensity : MAX_SHADOW_INTENSITY;
+                const shadowIntensity = sourceShadow?.intensity ?? (intensity <= 1 ? intensity : MAX_SHADOW_INTENSITY);
                 light.shadow.intensity =
                     atmosphere || !initialized.current
                         ? shadowIntensity
@@ -219,7 +309,8 @@ export function Lights() {
         }
         const hemiIntensity = atmosphere ? atmosphere.hemisphereIntensity : theme.hemi?.intensity;
         const hemiSky = atmosphere ? atmosphere.skyColor : theme.hemi?.sky;
-        const hemiGround = atmosphere ? atmosphere.groundColor : theme.hemi?.ground;
+        // Over a veiled ground the floor is lit from below as from above, as in an interior capture.
+        const hemiGround = veiled ? hemiSky : atmosphere ? atmosphere.groundColor : theme.hemi?.ground;
         if (hemiRef.current && hemiIntensity !== undefined && hemiSky && hemiGround) {
             if (atmosphere || !initialized.current) {
                 hemiRef.current.intensity = hemiIntensity;
@@ -262,5 +353,5 @@ export function Lights() {
                         : (themeLight?.position ?? [0, 1, 0]), ref: (light) => {
                         lightRefs.current[index] = light;
                     }, "shadow-bias": SHADOW_DEPTH_BIAS, "shadow-mapSize": [1024, 1024], "shadow-normalBias": SHADOW_NORMAL_BIAS, "shadow-radius": 2, children: index === 0 && keyCastsShadow ? (_jsx("orthographicCamera", { attach: "shadow-camera", bottom: -shadowCameraSize, far: 400, left: -shadowCameraSize, near: 1, ref: shadowCamera, right: shadowCameraSize, top: shadowCameraSize })) : null }, index));
-            }), atmosphere || theme.hemi ? _jsx("hemisphereLight", { ref: hemiRef }) : null, _jsx("ambientLight", { ref: ambientRef })] }));
+            }), atmosphere || theme.hemi ? _jsx("hemisphereLight", { ref: hemiRef }) : null, _jsx("ambientLight", { ref: ambientRef }), filled && _jsx(UndergroundFill, { lightRef: fillRef }), _jsx(UndergroundAmbiance, {})] }));
 }

package/dist/components/viewer/perf-monitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"perf-monitor.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/perf-monitor.tsx"],"names":[],"mappings":"AA2CA;;;;GAIG;AACH,eAAO,MAAM,WAAW,YAuTvB,CAAA"}
+{"version":3,"file":"perf-monitor.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/perf-monitor.tsx"],"names":[],"mappings":"AA6CA;;;;GAIG;AACH,eAAO,MAAM,WAAW,YA2TvB,CAAA"}

package/dist/components/viewer/perf-monitor.js

@@ -4,7 +4,9 @@ import { useEffect, useRef } from 'react';
 import { Vector3 } from 'three';
 import { initPerfObservers } from '../../lib/perf-observers';
 import { publishPerfStats, readPerfBatchStats } from '../../lib/perf-panel-store';
+import { readPerfHistory, readPerfSelection } from '../../lib/perf-probe-state';
 import { clearPerfMeasures, drainPerfCounters } from '../../lib/perf-tracks';
+import useViewer from '../../store/use-viewer';
 const SAMPLE_INTERVAL = 0.5; // seconds between display updates
 // Walking the scene graph is the overlay's own biggest cost on large projects,
 // and the counts barely move between ticks — sample it at 2s instead of 0.5s.
@@ -73,6 +75,10 @@ export const PerfMonitor = () => {
     useEffect(() => {
         const probe = {
             batchStats: readPerfBatchStats,
+            // Undo/redo entry counts and history pause state, and the selection path: what a
+            // gesture receipt needs on a production build, where the stores have no handle.
+            history: () => readPerfHistory(useScene),
+            selection: () => readPerfSelection(useViewer),
             listNodes(type) {
                 return Object.values(useScene.getState().nodes)
                     .filter((n) => n.type === type)

package/dist/components/viewer/perf-panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"perf-panel.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/perf-panel.tsx"],"names":[],"mappings":"AA2GA,eAAO,MAAM,SAAS,0CA2MrB,CAAA;AAED,eAAe,SAAS,CAAA"}
+{"version":3,"file":"perf-panel.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/perf-panel.tsx"],"names":[],"mappings":"AA2GA,eAAO,MAAM,SAAS,0CA2MrB,CAAA;eAEc,SAAS"}