@pascal-app/viewer 1.0.3 → 1.0.5

package/dist/systems/construction-reveal/dust-material.d.ts

@@ -0,0 +1,10 @@
+import type { InstancedBufferAttribute } from 'three';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+/**
+ * A soft disc on a quad, faded per sprite by `alpha`. It draws into the scene pass so walls in front
+ * hide it, and writes nothing to that pass's normals and diffuse colour (alpha 0 under their material
+ * blending): the ink reads the normals, and the whole quad, not just its disc, was an edge there.
+ * `output` is named too: a pass without MRT draws what this node names and nothing else.
+ */
+export declare function createDustMaterial(alpha: InstancedBufferAttribute): MeshBasicNodeMaterial;
+//# sourceMappingURL=dust-material.d.ts.map

package/dist/systems/construction-reveal/dust-material.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dust-material.d.ts","sourceRoot":"","sources":["../../../src/systems/construction-reveal/dust-material.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,OAAO,CAAA;AAErD,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAIpD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,wBAAwB,yBAOjE"}

package/dist/systems/construction-reveal/dust-material.js

@@ -0,0 +1,17 @@
+import { color, float, instancedDynamicBufferAttribute, mrt, output, uv, vec4 } from 'three/tsl';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+const DUST_COLOR = '#d9cdb8';
+/**
+ * A soft disc on a quad, faded per sprite by `alpha`. It draws into the scene pass so walls in front
+ * hide it, and writes nothing to that pass's normals and diffuse colour (alpha 0 under their material
+ * blending): the ink reads the normals, and the whole quad, not just its disc, was an edge there.
+ * `output` is named too: a pass without MRT draws what this node names and nothing else.
+ */
+export function createDustMaterial(alpha) {
+    const material = new MeshBasicNodeMaterial({ transparent: true, depthWrite: false });
+    material.colorNode = color(DUST_COLOR);
+    const edge = float(1).sub(uv().sub(0.5).length().mul(2)).clamp(0, 1);
+    material.opacityNode = edge.mul(edge).mul(instancedDynamicBufferAttribute(alpha, 'float'));
+    material.mrtNode = mrt({ output, diffuseColor: vec4(0), normal: vec4(0) });
+    return material;
+}

package/dist/systems/construction-reveal/ghost-dress.d.ts

@@ -0,0 +1,10 @@
+import type { Object3D } from 'three';
+/**
+ * The picture a deleted node plays out is a copy of what stood there, and a copy wears the
+ * material its source had in that frame. A node the cutaway was hiding wears its stipple, so its
+ * deletion would play as faint dots: when its source carries a visible variant (the wall cutout
+ * keeps one, `visibleMaterialsOf`), the copy wears that instead, the one a capture draws, for as long
+ * as it plays. What the cutaway showed, and any other wall mode, keep what they wear.
+ */
+export declare function dressDeletionGhost(source: Object3D, clone: Object3D): void;
+//# sourceMappingURL=ghost-dress.d.ts.map

package/dist/systems/construction-reveal/ghost-dress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ghost-dress.d.ts","sourceRoot":"","sources":["../../../src/systems/construction-reveal/ghost-dress.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,OAAO,CAAA;AAK3C;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,QAenE"}

package/dist/systems/construction-reveal/ghost-dress.js

@@ -0,0 +1,24 @@
+import { hasMaterialsForGroups } from '../../lib/pointer-events';
+import useViewer from '../../store/use-viewer';
+import { visibleMaterialsOf } from '../wall/wall-cutout-cache';
+/**
+ * The picture a deleted node plays out is a copy of what stood there, and a copy wears the
+ * material its source had in that frame. A node the cutaway was hiding wears its stipple, so its
+ * deletion would play as faint dots: when its source carries a visible variant (the wall cutout
+ * keeps one, `visibleMaterialsOf`), the copy wears that instead, the one a capture draws, for as long
+ * as it plays. What the cutaway showed, and any other wall mode, keep what they wear.
+ */
+export function dressDeletionGhost(source, clone) {
+    const visible = visibleMaterialsOf.get(source);
+    const mesh = clone;
+    if (visible &&
+        useViewer.getState().wallMode === 'cutaway' &&
+        source.userData.wallHidden === true &&
+        mesh.isMesh &&
+        mesh.geometry &&
+        // A room-wide paint preview can leave the source with more groups than the palette has
+        // entries; a copy with a group and no material throws on every raycast over it (see
+        // `WallCutoutCache.mayAssign`), so it keeps what it wears then.
+        hasMaterialsForGroups(mesh, visible))
+        mesh.material = visible;
+}

package/dist/systems/door/door-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"door-system.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EAYd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA2D9B,eAAO,MAAM,UAAU,YAuHtB,CAAA;AA0pCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,SAAS,EAChC,KAAK,EAAE,MAAM,GACZ,OAAO,CA6GT;AAyuCD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,KAAK,CAAC,IAAI,CAI/D"}
+{"version":3,"file":"door-system.d.ts","sourceRoot":"","sources":["../../../src/systems/door/door-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EAcd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA6D9B,eAAO,MAAM,UAAU,YAyHtB,CAAA;AAiqCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,SAAS,EAChC,KAAK,EAAE,MAAM,GACZ,OAAO,CA6GT;AA6wCD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,KAAK,CAAC,IAAI,CAI/D"}

package/dist/systems/door/door-system.js

@@ -1,10 +1,11 @@
-import { clampDoorOperationState, DEFAULT_WALL_THICKNESS, DoorNode as DoorNodeSchema, getDoorRenderOpenAmount, getEffectiveNode, getWallThickness, sceneRegistry, useInteractive, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { clampDoorOperationState, DEFAULT_WALL_THICKNESS, DoorNode as DoorNodeSchema, getDoorRenderOpenAmount, getEffectiveNode, getOpeningWallPlacement, getWallThickness, sceneRegistry, scriptedSize, useInteractive, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import * as THREE from 'three';
 import { applyWorldScaleBoxUVs } from '../../lib/box-uv';
-import { createDefaultMaterial, createSurfaceRoleMaterial, glassMaterial as defaultGlassMaterial, baseMaterial as getBaseMaterial, resolveMaterialRef, } from '../../lib/materials';
+import { createDefaultMaterial, createMaterial, createSurfaceRoleMaterial, glassMaterial as defaultGlassMaterial, baseMaterial as getBaseMaterial, resolveMaterialRef, } from '../../lib/materials';
 import { timeSpan } from '../../lib/perf-tracks';
+import { settleScriptedOpening } from '../../lib/scripted-opening';
 import useViewer from '../../store/use-viewer';
 import { getOpeningCutoutProxyDepth } from '../wall/opening-cutout-geometry';
 // Invisible material for root mesh — used as selection hitbox only
@@ -146,9 +147,12 @@ export const DoorSystem = () => {
             // rebuild reflects the in-flight drag without zustand churn. When
             // no override is set this returns the scene node unchanged.
             const effectiveNode = getEffectiveNode(node);
-            timeSpan('door', () => updateDoorMesh(effectiveNode, mesh), {
+            const built = timeSpan('door', () => updateDoorMesh(effectiveNode, mesh), {
                 properties: [['node', id]],
             });
+            // A scripted opening stays dirty until its artifact has loaded.
+            if (!built)
+                continue;
             clearDirty(id);
             rebuiltDoorsThisFrame += 1;
             // Rebuild the parent wall so its cutout reflects the updated door geometry
@@ -208,16 +212,21 @@ function doorSlotDefault(slotId) {
         getBaseMaterial(currentShading));
 }
 // Resolve a door's slot to a material: the `node.slots` override (colored mode
-// only) → the body/glass/hardware default. Textures-off ignores overrides — the
-// monochrome escape hatch.
+// only) → the door-wide `material` for the body (panel and frame; glass and
+// hardware keep their own finish) → the body/glass/hardware default.
+// Textures-off ignores overrides — the monochrome escape hatch.
 function resolveDoorSlotMaterial(node, slotId) {
     const fallback = doorSlotDefault(slotId);
     if (!currentTextures)
         return fallback;
     const ref = node.slots?.[slotId];
-    if (!ref)
-        return fallback;
-    return resolveMaterialRef(ref, currentSceneMaterials, currentShading) ?? fallback;
+    const painted = ref ? resolveMaterialRef(ref, currentSceneMaterials, currentShading) : null;
+    if (painted)
+        return painted;
+    if (node.material && (slotId === 'panel' || slotId === 'frame')) {
+        return createMaterial(node.material, currentShading);
+    }
+    return fallback;
 }
 function addBox(parent, material, w, h, d, x, y, z) {
     const geometry = new THREE.BoxGeometry(w, h, d);
@@ -676,7 +685,9 @@ function addLeafSegmentContent({ addLeafBox, addLeafShape, leafWidth, leafHeight
                         addLeafShape(baseMaterial, innerPanelShape, effectiveDepth);
                     }
                     else {
+                        // A leaf is paneled on both faces, so the person sees the style from either side.
                         addLeafBox(baseMaterial, panelW, panelH, effectiveDepth, colX, segCenterY, panelZ);
+                        addLeafBox(baseMaterial, panelW, panelH, effectiveDepth, colX, segCenterY, -panelZ);
                     }
                 }
             }
@@ -1239,8 +1250,19 @@ function updateDoorMesh(rawNode, mesh) {
     mesh.geometry = new THREE.BoxGeometry(node.width, node.height, node.frameDepth);
     mesh.material = hitboxMaterial;
     // Sync transform from node (React may lag behind the system by a frame during drag)
-    mesh.position.set(node.position[0], node.position[1], node.position[2]);
-    mesh.rotation.set(node.rotation[0], node.rotation[1], node.rotation[2]);
+    const parent = node.parentId ? useScene.getState().nodes[node.parentId] : undefined;
+    const placement = parent?.type === 'wall' && !node.roofSegmentId
+        ? getOpeningWallPlacement(getEffectiveNode(parent), node, useScene.getState().nodes)
+        : node;
+    mesh.position.set(...placement.position);
+    mesh.rotation.set(...placement.rotation);
+    // Built from a script: the renderer shows its artifact, not the parametric
+    // frame, and the hit box is what the script built.
+    if (node.source) {
+        mesh.geometry.dispose();
+        mesh.geometry = new THREE.BoxGeometry(...scriptedSize(node.source.manifest));
+        return settleScriptedOpening(mesh);
+    }
     // Dispose and remove all old visual children; preserve 'cutout'
     for (const child of [...mesh.children]) {
         if (child.name === 'cutout')
@@ -1263,7 +1285,7 @@ function updateDoorMesh(rawNode, mesh) {
     const clampedSwingAngle = Math.max(0, Math.min(Math.PI / 2, swingAngle));
     if (openingKind === 'opening') {
         syncDoorCutout(node, mesh);
-        return;
+        return true;
     }
     const insideWidth = width - 2 * frameThickness;
     const leafH = height - frameThickness; // only top frame
@@ -1505,11 +1527,12 @@ function updateDoorMesh(rawNode, mesh) {
     // … was not set" on a Draw(0, …)). Hide any empty mesh so it is never
     // drawn (it would render nothing anyway).
     hideEmptyGeometryMeshes(mesh);
+    return true;
 }
 function hideEmptyGeometryMeshes(root) {
     root.traverse((obj) => {
         const child = obj;
-        if (!child.isMesh || !child.geometry)
+        if (!(child.isMesh && child.geometry))
             return;
         const position = child.geometry.getAttribute('position');
         if (!position || position.count === 0)
@@ -1531,7 +1554,15 @@ function syncDoorCutout(node, mesh) {
         mesh.add(cutout);
     }
     cutout.geometry.dispose();
-    const depth = resolveOpeningCutoutProxyDepth(node);
+    const { depth, center } = resolveOpeningCutoutProxy(node);
+    cutout.position.set(0, 0, 0);
+    if (center) {
+        // Curved and justified walls place openings off the reference line. Remove
+        // only the visual plane offset, preserving the frame's resolved floor datum.
+        cutout.position
+            .set(center[0] - mesh.position.x, 0, center[2] - mesh.position.z)
+            .applyQuaternion(mesh.quaternion.clone().invert());
+    }
     const openingShape = getEffectiveOpeningShape(node);
     if (openingShape === 'arch') {
         cutout.geometry = new THREE.ExtrudeGeometry(createArchShape(-node.width / 2, node.width / 2, -node.height / 2, node.height / 2, getClampedArchHeight(node.width, node.height, node.archHeight)), {
@@ -1558,11 +1589,18 @@ function syncDoorCutout(node, mesh) {
 // the proxy stays proud of both wall faces (front/back selection) without the
 // old 1m depth that blanketed the floor. Falls back to the default thickness
 // when the parent wall isn't a resolvable wall node.
-function resolveOpeningCutoutProxyDepth(node) {
+function resolveOpeningCutoutProxy(node) {
     const parentId = node.parentId;
-    const parent = parentId ? useScene.getState().nodes[parentId] : undefined;
-    const wallThickness = parent?.type === 'wall' ? getWallThickness(parent) : DEFAULT_WALL_THICKNESS;
-    return getOpeningCutoutProxyDepth(wallThickness);
+    const nodes = useScene.getState().nodes;
+    const parent = parentId ? nodes[parentId] : undefined;
+    const wall = parent?.type === 'wall' ? getEffectiveNode(parent) : undefined;
+    const wallThickness = wall ? getWallThickness(wall) : DEFAULT_WALL_THICKNESS;
+    return {
+        depth: getOpeningCutoutProxyDepth(wallThickness),
+        center: wall && !node.roofSegmentId && node.position[2] !== 0
+            ? getOpeningWallPlacement(wall, { ...node, position: [node.position[0], node.position[1], 0] }, nodes).position
+            : undefined,
+    };
 }
 /**
  * Build a fresh door mesh for preview/ghost rendering.

package/dist/systems/elevator/elevator-interaction-system.d.ts

@@ -1,2 +1,9 @@
+import { type Object3D } from 'three';
+/**
+ * The roots of every elevator button under `object`. Any button along the ray
+ * takes the click, so only they are raycast — never the rest of the scene,
+ * whose meshes this capture-phase listener must not trip over.
+ */
+export declare function collectElevatorButtons(object: Object3D, into?: Object3D[]): Object3D[];
 export declare function ElevatorInteractionSystem(): null;
 //# sourceMappingURL=elevator-interaction-system.d.ts.map

package/dist/systems/elevator/elevator-interaction-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elevator-interaction-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-interaction-system.tsx"],"names":[],"mappings":"AAkCA,wBAAgB,yBAAyB,SA0DxC"}
+{"version":3,"file":"elevator-interaction-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-interaction-system.tsx"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,QAAQ,EAAsB,MAAM,OAAO,CAAA;AAwBzD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,GAAE,QAAQ,EAAO,GAAG,QAAQ,EAAE,CAO1F;AAED,wBAAgB,yBAAyB,SA6DxC"}

package/dist/systems/elevator/elevator-interaction-system.js

@@ -12,6 +12,20 @@ function getElevatorButtonData(object) {
     }
     return null;
 }
+/**
+ * The roots of every elevator button under `object`. Any button along the ray
+ * takes the click, so only they are raycast — never the rest of the scene,
+ * whose meshes this capture-phase listener must not trip over.
+ */
+export function collectElevatorButtons(object, into = []) {
+    if (object.userData.elevatorButton) {
+        into.push(object);
+        return into;
+    }
+    for (const child of object.children)
+        collectElevatorButtons(child, into);
+    return into;
+}
 export function ElevatorInteractionSystem() {
     const camera = useThree((state) => state.camera);
     const gl = useThree((state) => state.gl);
@@ -23,6 +37,9 @@ export function ElevatorInteractionSystem() {
         const handlePointerDown = (event) => {
             if (event.button !== 0)
                 return;
+            const buttons = collectElevatorButtons(scene);
+            if (buttons.length === 0)
+                return;
             const rect = canvas.getBoundingClientRect();
             const pointer = pointerRef.current;
             pointer.x = ((event.clientX - rect.left) / rect.width) * 2 - 1;
@@ -30,7 +47,7 @@ export function ElevatorInteractionSystem() {
             const raycaster = raycasterRef.current;
             raycaster.setFromCamera(pointer, camera);
             const button = raycaster
-                .intersectObjects(scene.children, true)
+                .intersectObjects(buttons, true)
                 .map((intersection) => getElevatorButtonData(intersection.object))
                 .find((data) => data !== null);
             if (!button || button.disabled)

package/dist/systems/floor-elevation/floor-elevation-system.d.ts

@@ -14,7 +14,9 @@
  * Runs at priority 1 — before the priority-2 systems (`GeometrySystem`,
  * `ItemSystem`) so the dirty mark survives long enough for those to do
  * their own work. Kinds with no geometry/system have no downstream dirty
- * consumer, so this system clears their dirty mark after applying the lift.
+ * consumer, so this system clears their dirty mark after applying the lift,
+ * at priority 2 like every other consumer: the node batch snapshots marks at
+ * priority 1, and a mark cleared there could run before that snapshot.
  */
 export declare const FloorElevationSystem: () => null;
 //# sourceMappingURL=floor-elevation-system.d.ts.map

package/dist/systems/floor-elevation/floor-elevation-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floor-elevation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/floor-elevation/floor-elevation-system.tsx"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB,YA2LhC,CAAA"}
+{"version":3,"file":"floor-elevation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/floor-elevation/floor-elevation-system.tsx"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB,YAoNhC,CAAA"}

package/dist/systems/floor-elevation/floor-elevation-system.js

@@ -43,11 +43,17 @@ function restoreMountedExitPose(saved) {
  * Runs at priority 1 — before the priority-2 systems (`GeometrySystem`,
  * `ItemSystem`) so the dirty mark survives long enough for those to do
  * their own work. Kinds with no geometry/system have no downstream dirty
- * consumer, so this system clears their dirty mark after applying the lift.
+ * consumer, so this system clears their dirty mark after applying the lift,
+ * at priority 2 like every other consumer: the node batch snapshots marks at
+ * priority 1, and a mark cleared there could run before that snapshot.
  */
 export const FloorElevationSystem = () => {
     const dirtyNodes = useScene((s) => s.dirtyNodes);
     const clearDirty = useScene((s) => s.clearDirty);
+    const consumed = useMemo(() => new Set(), []);
+    // Meshes already lifted once. A mesh mounts at its base Y, and a remount (entering Preview
+    // builds a fresh viewer tree) raises no dirty mark, so the lift would never be applied.
+    const mounted = useMemo(() => ({ revision: -1, meshes: new WeakSet() }), []);
     const preview = useMemo(() => ({
         local: new Matrix4(),
         target: new Matrix4(),
@@ -107,7 +113,8 @@ export const FloorElevationSystem = () => {
         // during group drags over elevated slabs).
         const overrides = useLiveNodeOverrides.getState().overrides;
         const transforms = useLiveTransforms.getState().transforms;
-        if (dirtyNodes.size === 0 && overrides.size === 0 && transforms.size === 0)
+        const registryChanged = sceneRegistry.revision !== mounted.revision;
+        if (dirtyNodes.size === 0 && overrides.size === 0 && transforms.size === 0 && !registryChanged)
             return;
         const nodes = useScene.getState().nodes;
         const applyLift = (id) => {
@@ -128,9 +135,11 @@ export const FloorElevationSystem = () => {
                 return;
             if (effectiveNode.parentId !== node.parentId)
                 return;
-            if (!(def.geometry || def.system) && dirtyNodes.has(id)) {
-                clearDirty(id);
-            }
+            // A mounted object still loading (a scripted column's artifact) keeps its mark, so
+            // scene-ready and bakes wait for it; settling marks the node dirty again.
+            const settled = def.capabilities?.batchable?.settled?.(mesh.userData) ?? true;
+            if (!(def.geometry || def.system) && dirtyNodes.has(id) && settled)
+                consumed.add(id);
             // `applies === false` means the kind opts OUT of floor stacking for this
             // node: its Y belongs to a host frame (a wall/ceiling-mounted item, a
             // cabinet module inside a run, a wall duct terminal). `getFloorPlacedElevation`
@@ -162,6 +171,20 @@ export const FloorElevationSystem = () => {
             });
             mesh.position.y = visualPosition[1];
         };
+        if (registryChanged) {
+            mounted.revision = sceneRegistry.revision;
+            for (const [kind, ids] of Object.entries(sceneRegistry.byType)) {
+                if (!nodeRegistry.get(kind)?.capabilities?.floorPlaced)
+                    continue;
+                for (const id of ids) {
+                    const mesh = sceneRegistry.nodes.get(id);
+                    if (!mesh || mounted.meshes.has(mesh))
+                        continue;
+                    mounted.meshes.add(mesh);
+                    applyLift(id);
+                }
+            }
+        }
         dirtyNodes.forEach((id) => {
             applyLift(id);
         });
@@ -174,6 +197,11 @@ export const FloorElevationSystem = () => {
                 applyLift(id);
         });
     }, 1);
+    useFrame(() => {
+        for (const id of consumed)
+            clearDirty(id);
+        consumed.clear();
+    }, 2);
     // PostProcessing draws at priority 1 after this system; later callbacks would show one wrong frame per move.
     useFrame(() => {
         const nodes = useScene.getState().nodes;

package/dist/systems/geometry/geometry-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry-system.d.ts","sourceRoot":"","sources":["../../../src/systems/geometry/geometry-system.tsx"],"names":[],"mappings":"AAkBA,OAAO,EAAa,KAAK,KAAK,EAA4B,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAUtF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,cAAc,YAuM1B,CAAA;AAiJD,eAAe,cAAc,CAAA;AAE7B,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,KAAK,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAU7D;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC3C,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,GACV,OAAO,CAKT"}
+{"version":3,"file":"geometry-system.d.ts","sourceRoot":"","sources":["../../../src/systems/geometry/geometry-system.tsx"],"names":[],"mappings":"AAkBA,OAAO,EAAa,KAAK,KAAK,EAA4B,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAatF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,cAAc,YA8N1B,CAAA;eA+Kc,cAAc;AAE7B,MAAM,MAAM,uBAAuB,GAAG;IACpC,KAAK,EAAE,KAAK,CAAA;IACZ,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAY7D;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC3C,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,KAAK,EACZ,GAAG,EAAE,MAAM,GACV,OAAO,CAKT"}

package/dist/systems/geometry/geometry-system.js

@@ -4,8 +4,10 @@ import { useFrame } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import { FrontSide } from 'three';
 import { disposeObject3DResources } from '../../lib/dispose-object3d';
-import { createSurfaceRoleMaterial, } from '../../lib/materials';
+import { createSurfaceRoleMaterial, materialCastsShadow, } from '../../lib/materials';
+import { createNodeTopSurfaceHeightSampler } from '../../lib/node-top-surface-height';
 import { timeSpan } from '../../lib/perf-tracks';
+import { createSceneSupportHeightSampler } from '../../lib/scene-support-height';
 import useViewer from '../../store/use-viewer';
 /**
  * Generic geometry system.
@@ -55,6 +57,22 @@ export const GeometrySystem = () => {
     // but its geometry inputs are unchanged — e.g. an item reparenting onto a
     // shelf dirties the shelf without altering its boards.
     const builtGeometryKeyRef = useRef(new Map());
+    const liveBuildIds = useRef(new Set());
+    useEffect(() => {
+        const unsubscribe = useLiveNodeOverrides.subscribe((state, previous) => {
+            for (const id of new Set([...state.overrides.keys(), ...previous.overrides.keys()])) {
+                if (state.overrides.get(id) === previous.overrides.get(id))
+                    continue;
+                const node = useScene.getState().nodes[id];
+                if (node && nodeRegistry.get(node.type)?.geometry)
+                    liveBuildIds.current.add(id);
+            }
+        });
+        return () => {
+            unsubscribe();
+            liveBuildIds.current.clear();
+        };
+    }, []);
     // Re-mark every geometry-backed node dirty whenever a viewer appearance
     // value changes, so `def.geometry` builders re-run and pick up the new
     // shading / texture / preset / theme. These four are deliberate re-run
@@ -92,19 +110,23 @@ export const GeometrySystem = () => {
         }
     }, [sceneMaterials]);
     useFrame(() => {
-        if (dirtyNodes.size === 0)
+        if (dirtyNodes.size === 0 && liveBuildIds.current.size === 0)
             return;
         const nodes = useScene.getState().nodes;
         let rebuiltGeometry = false;
         const batches = new Map();
         const dirtyIds = [];
-        dirtyNodes.forEach((id) => {
+        for (const id of new Set([...dirtyNodes, ...liveBuildIds.current])) {
             const node = nodes[id];
-            if (!node)
-                return;
+            if (!node) {
+                liveBuildIds.current.delete(id);
+                continue;
+            }
             const def = nodeRegistry.get(node.type);
-            if (!def?.geometry)
-                return;
+            if (!def?.geometry) {
+                liveBuildIds.current.delete(id);
+                continue;
+            }
             dirtyIds.push(id);
             const parentId = (node.parentId ?? null);
             const key = `${node.type}::${parentId ?? ''}`;
@@ -113,7 +135,7 @@ export const GeometrySystem = () => {
                 existing.ids.push(id);
             else
                 batches.set(key, { kind: node.type, parentId, ids: [id] });
-        });
+        }
         // Phase 2 — for each batch whose kind declares `computeLevelData`,
         // collect every sibling in the level + run the precompute once.
         const levelDataByBatch = new Map();
@@ -170,7 +192,9 @@ export const GeometrySystem = () => {
                 const childLiveOverrideKey = liveChildOverrideKey(node);
                 const builtKey = `${shading}|${textures}|${colorPreset}|${sceneTheme}|${def.geometryKey(effectiveNode)}|${childLiveOverrideKey}`;
                 if (shouldReuseGeometryBuild(builtGeometryKeyRef.current, id, group, builtKey)) {
-                    clearDirty(id);
+                    liveBuildIds.current.delete(id);
+                    if (dirtyNodes.has(id))
+                        clearDirty(id);
                     continue;
                 }
             }
@@ -199,7 +223,9 @@ export const GeometrySystem = () => {
             // because the renderer doesn't necessarily re-render on the rebuild
             // tick, R3F wouldn't re-apply the props, leaving the group stuck at
             // origin. Geometry builders are expected to emit local-space children.
-            clearDirty(id);
+            liveBuildIds.current.delete(id);
+            if (dirtyNodes.has(id))
+                clearDirty(id);
         }
         if (rebuiltGeometry)
             bumpGeometryRevision();
@@ -281,7 +307,38 @@ function buildGeometryContext(node, nodes, levelData, materials) {
         noteLevelBaseConsumer(node.type);
         return levelId ? levelBaseElevationAt(nodes, levelId, x, z) : 0;
     };
-    return { resolve, children, siblings, parent, levelBaseAt, levelData, materials };
+    const surfaceSamplers = new Map();
+    const surfaceHeightAt = (hostId, x, z) => {
+        if (!levelId)
+            return null;
+        if (!surfaceSamplers.has(hostId)) {
+            surfaceSamplers.set(hostId, createNodeTopSurfaceHeightSampler(hostId, levelId));
+        }
+        return surfaceSamplers.get(hostId)?.(x, z) ?? null;
+    };
+    const supportSamplers = new Map();
+    const supportHeightAt = (x, z, selectedHostId) => {
+        if (!levelId)
+            return levelBaseAt(x, z);
+        const key = selectedHostId ?? 'auto';
+        let sampler = supportSamplers.get(key);
+        if (!sampler) {
+            sampler = createSceneSupportHeightSampler(nodes, levelId, selectedHostId);
+            supportSamplers.set(key, sampler);
+        }
+        return sampler(x, z);
+    };
+    return {
+        resolve,
+        children,
+        siblings,
+        parent,
+        levelBaseAt,
+        surfaceHeightAt,
+        supportHeightAt,
+        levelData,
+        materials,
+    };
 }
 function disposeChildren(group) {
     // Only dispose meshes the geometry builder produced on the previous
@@ -330,6 +387,9 @@ export function markGeometryBuildOutput(child) {
     // example a cabinet sink faucet handle), while disposal still removes only
     // top-level builder children from the registered group.
     child.traverse((object) => {
+        const mesh = object;
+        if (mesh.isMesh)
+            mesh.castShadow = mesh.castShadow && materialCastsShadow(mesh.material);
         object.userData = {
             ...object.userData,
             __fromGeometry: true,

package/dist/systems/interactive/control-widget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"control-widget.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/control-widget.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE7D;;8EAE8E;AAC9E,eAAO,MAAM,aAAa,GAAI,+BAI3B;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,YAAY,CAAA;IACnB,QAAQ,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,IAAI,CAAA;CACpC,uCAuEA,CAAA"}
+{"version":3,"file":"control-widget.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/control-widget.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE7D;;8EAE8E;AAC9E,eAAO,MAAM,aAAa,kCAIvB;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,YAAY,CAAA;IACnB,QAAQ,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,IAAI,CAAA;CACpC,uCAuEA,CAAA"}

package/dist/systems/interactive/interactive-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"interactive-system.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/interactive-system.tsx"],"names":[],"mappings":"AAiCA,eAAO,MAAM,iBAAiB,mCAsB7B,CAAA"}
+{"version":3,"file":"interactive-system.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/interactive-system.tsx"],"names":[],"mappings":"AAwCA,eAAO,MAAM,iBAAiB,mCAoC7B,CAAA"}