@pascal-app/viewer 1.0.0-beta.4 → 1.0.0

package/dist/systems/wall/wall-cutout.js

@@ -1,146 +1,39 @@
-import { emitter, getWallFaceBandConfig, getWallPlaneTop, resolveLevelId, resolveWallEffectiveHeight, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
+import { emitter, sceneRegistry, useScene } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
-import { useEffect, useRef } from 'react';
+import { useEffect, useMemo } from 'react';
 import { Vector3 } from 'three/webgpu';
-import useViewer from '../../store/use-viewer';
-import { getMaterialsForWall, getSelectionHighlightMaterials, getWallMaterialHash, } from './wall-materials';
-const tmpVec = new Vector3();
-const u = new Vector3();
+import useViewer, {} from '../../store/use-viewer';
+import { sameMaterialArray, WallCutoutCache, wallHiddenFromFacing, } from './wall-cutout-cache';
+import { getMaterialsForWall, getSelectionHighlightMaterials } from './wall-materials';
+import { subscribeWallRebuilds } from './wall-rebuild-notifications';
 const v = new Vector3();
-function getWallHideState(wallNode, wallMesh, wallMode, cameraDir) {
-    let hideWall = wallNode.frontSide === 'interior' && wallNode.backSide === 'interior';
-    if (wallMode === 'up') {
-        hideWall = false;
-    }
-    else if (wallMode === 'down') {
-        hideWall = true;
-    }
-    else {
-        wallMesh.getWorldDirection(v);
-        if (v.dot(cameraDir) < 0) {
-            if (wallNode.frontSide === 'exterior' && wallNode.backSide !== 'exterior') {
-                hideWall = true;
-            }
-        }
-        else if (wallNode.backSide === 'exterior' && wallNode.frontSide !== 'exterior') {
-            hideWall = true;
-        }
-    }
-    return hideWall;
+export const WALL_CUTOUT_FRAME_PRIORITY = 0;
+export function runWallCutoutFrame(cache, { camera, clock }) {
+    cache.update(camera, clock.elapsedTime);
 }
-function sameMaterialArray(a, b) {
-    return Array.isArray(a) && a.length === b.length && a.every((material, i) => material === b[i]);
+/**
+ * Whether a wall should be hidden or see-through for the current camera and
+ * wall mode. Pure: reads only its arguments and the mesh's world direction.
+ *
+ * Exported so hosts rendering their own layers inside `<Viewer>` can match
+ * these semantics instead of re-deriving the facing test or inferring state
+ * from the assigned material variant.
+ */
+export function getWallHideState(wallNode, wallMesh, wallMode, cameraDir) {
+    if (wallMode === 'up')
+        return false;
+    if (wallMode === 'down')
+        return true;
+    wallMesh.getWorldDirection(v);
+    return wallHiddenFromFacing(wallNode, wallMode, v.dot(cameraDir) < 0);
 }
-export const WallCutout = () => {
-    const lastCameraPosition = useRef(new Vector3());
-    const lastCameraTarget = useRef(new Vector3());
-    const lastUpdateTime = useRef(0);
-    const lastWallMode = useRef(useViewer.getState().wallMode);
-    const lastShading = useRef(useViewer.getState().shading);
-    const lastNumberOfWalls = useRef(0);
-    const lastHighlightKey = useRef('');
-    const lastWallAppearanceKey = useRef('');
-    const lastTextures = useRef(useViewer.getState().textures);
-    const lastColorPreset = useRef(useViewer.getState().colorPreset);
-    const lastSceneTheme = useRef(useViewer.getState().sceneTheme);
-    useFrame(({ camera, clock }) => {
-        const wallMode = useViewer.getState().wallMode;
-        const shading = useViewer.getState().shading;
-        const textures = useViewer.getState().textures;
-        const colorPreset = useViewer.getState().colorPreset;
-        const sceneTheme = useViewer.getState().sceneTheme;
-        const selectedIds = useViewer.getState().selection.selectedIds;
-        const previewSelectedIds = useViewer.getState().previewSelectedIds;
-        const hoveredId = useViewer.getState().hoveredId;
-        const hoverHighlightMode = useViewer.getState().hoverHighlightMode;
-        const sceneState = useScene.getState();
-        const currentTime = clock.elapsedTime;
-        const currentCameraPosition = camera.position;
-        camera.getWorldDirection(tmpVec);
-        tmpVec.add(currentCameraPosition);
-        const highlightedWallIds = new Set([...selectedIds, ...previewSelectedIds].filter((id) => sceneState.nodes[id]?.type === 'wall'));
-        const deleteHoveredWallId = hoverHighlightMode === 'delete' &&
-            hoveredId &&
-            sceneState.nodes[hoveredId]?.type === 'wall'
-            ? hoveredId
-            : null;
-        const highlightKey = `${Array.from(highlightedWallIds).sort().join('|')}::${deleteHoveredWallId ?? ''}`;
-        const wallAppearanceKey = Array.from(sceneRegistry.byType.wall)
-            .sort()
-            .map((wallId) => {
-            const wallNode = sceneState.nodes[wallId];
-            if (wallNode?.type !== 'wall')
-                return `${wallId}:missing`;
-            return `${wallId}:${getWallMaterialHash(wallNode, shading, sceneState.materials)}:${JSON.stringify(wallNode.faceBands ?? null)}`;
-        })
-            .join('|');
-        const distanceMoved = currentCameraPosition.distanceTo(lastCameraPosition.current);
-        const directionChanged = tmpVec.distanceTo(lastCameraTarget.current);
-        const timeSinceUpdate = currentTime - lastUpdateTime.current;
-        if (((distanceMoved > 0.5 || directionChanged > 0.3) && timeSinceUpdate > 0.1) ||
-            lastWallMode.current !== wallMode ||
-            lastShading.current !== shading ||
-            lastTextures.current !== textures ||
-            lastColorPreset.current !== colorPreset ||
-            lastSceneTheme.current !== sceneTheme ||
-            sceneRegistry.byType.wall.size !== lastNumberOfWalls.current ||
-            lastHighlightKey.current !== highlightKey ||
-            lastWallAppearanceKey.current !== wallAppearanceKey) {
-            lastCameraPosition.current.copy(currentCameraPosition);
-            lastCameraTarget.current.copy(tmpVec);
-            lastUpdateTime.current = currentTime;
-            camera.getWorldDirection(u);
-            const walls = sceneRegistry.byType.wall;
-            walls.forEach((wallId) => {
-                const wallMesh = sceneRegistry.nodes.get(wallId);
-                if (!wallMesh)
-                    return;
-                const wallNode = sceneState.nodes[wallId];
-                if (wallNode?.type !== 'wall')
-                    return;
-                const hideWall = getWallHideState(wallNode, wallMesh, wallMode, u);
-                const isDeleteHighlighted = deleteHoveredWallId === wallId;
-                const isSelectionHighlighted = !isDeleteHighlighted && highlightedWallIds.has(wallId);
-                const levelId = resolveLevelId(wallNode, sceneState.nodes);
-                const support = spatialGridManager.getSlabSupportForWall(levelId, wallNode.start, wallNode.end, wallNode.curveOffset ?? 0, wallNode.thickness, wallNode.supportSlabId);
-                const effectiveWallHeight = resolveWallEffectiveHeight(wallNode, getWallPlaneTop(wallNode, levelId, sceneState.nodes), support.elevation);
-                const shouldSelectionHighlight = isSelectionHighlighted && !getWallFaceBandConfig(wallNode, effectiveWallHeight).enabled;
-                const materials = getMaterialsForWall(wallNode, shading, textures, colorPreset, sceneTheme, sceneState.materials);
-                if (wallMode === 'translucent') {
-                    ;
-                    wallMesh.material = isDeleteHighlighted
-                        ? materials.deleteTranslucent
-                        : shouldSelectionHighlight
-                            ? getSelectionHighlightMaterials(materials.translucent)
-                            : materials.translucent;
-                }
-                else if (hideWall) {
-                    ;
-                    wallMesh.material = isDeleteHighlighted
-                        ? materials.deleteInvisible
-                        : shouldSelectionHighlight
-                            ? getSelectionHighlightMaterials(materials.invisible)
-                            : materials.invisible;
-                }
-                else {
-                    ;
-                    wallMesh.material = isDeleteHighlighted
-                        ? materials.deleteVisible
-                        : shouldSelectionHighlight
-                            ? getSelectionHighlightMaterials(materials.visible)
-                            : materials.visible;
-                }
-            });
-            lastWallMode.current = wallMode;
-            lastShading.current = shading;
-            lastTextures.current = textures;
-            lastColorPreset.current = colorPreset;
-            lastSceneTheme.current = sceneTheme;
-            lastNumberOfWalls.current = sceneRegistry.byType.wall.size;
-            lastHighlightKey.current = highlightKey;
-            lastWallAppearanceKey.current = wallAppearanceKey;
-        }
-    });
+export const WallCutout = ({ viewerStore = useViewer, }) => {
+    const cache = useMemo(() => new WallCutoutCache(viewerStore), [viewerStore]);
+    useEffect(() => subscribeWallRebuilds((id) => cache.rebuilt.add(id)), [cache]);
+    useEffect(() => cache.subscribeLiveTransforms(), [cache]);
+    // Camera changes reach PostProcessing (1) in this frame. WallSystem (4)
+    // notifies the next frame; WallBatchSystem (5) reads this frame's stamps.
+    useFrame((state) => runWallCutoutFrame(cache, state), WALL_CUTOUT_FRAME_PRIORITY);
     useEffect(() => {
         const snapshot = new Map();
         const restoreForCapture = () => {
@@ -151,7 +44,7 @@ export const WallCutout = () => {
                 const wallNode = useScene.getState().nodes[wallId];
                 if (wallNode?.type !== 'wall')
                     return;
-                const mats = getMaterialsForWall(wallNode, useViewer.getState().shading, useViewer.getState().textures, useViewer.getState().colorPreset, useViewer.getState().sceneTheme, useScene.getState().materials);
+                const mats = getMaterialsForWall(wallNode, viewerStore.getState().shading, viewerStore.getState().textures, viewerStore.getState().colorPreset, viewerStore.getState().sceneTheme, useScene.getState().materials);
                 const current = wallMesh.material;
                 snapshot.set(wallMesh, current);
                 if (current === mats.deleteVisible) {
@@ -178,6 +71,6 @@ export const WallCutout = () => {
             emitter.off('thumbnail:before-capture', restoreForCapture);
             emitter.off('thumbnail:after-capture', reapplyAfterCapture);
         };
-    }, []);
+    }, [viewerStore]);
     return null;
 };

package/dist/systems/wall/wall-material-variant.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Which material variant does a wall draw this pass?
+ *
+ * Extracted from `WallCutout`'s per-wall assignment so the precedence is a
+ * testable truth table. Precedence within each display mode:
+ *
+ *   delete-hover > selection > select-hover > base
+ *
+ * The SELECT-HOVER variant exists for HIDDEN walls only (QA f2, REVISE):
+ * with the Bones X-ray on, hidden walls are hover/selection ray targets
+ * (nearest-first, see nodes/wall/pointer-transparency.ts) — but an
+ * invisible wall gave no hover feedback at all, so what the user saw
+ * lighting up on hover was the furniture BEHIND the wall. Hovering a hidden
+ * wall now glows its stipple film. Visible and translucent walls keep their
+ * existing hover affordance (the post-processing outline pass) — a material
+ * glow there would double-highlight.
+ */
+export type WallMaterialVariant = 'visible' | 'invisible' | 'translucent' | 'delete-visible' | 'delete-invisible' | 'delete-translucent' | 'selection-visible' | 'selection-invisible' | 'selection-translucent' | 'hover-invisible';
+export declare const resolveWallMaterialVariant: ({ translucentMode, hidden, deleteHighlighted, selectionHighlighted, hoverHighlighted, }: {
+    /** wallMode === 'translucent' (overrides the hide state). */
+    translucentMode: boolean;
+    /** The wall-mode pass hides this wall ('down', cutaway, auto-interior). */
+    hidden: boolean;
+    /** Delete-mode hover on this wall (deleteInvisible flow). */
+    deleteHighlighted: boolean;
+    /** Selected (and the wall's face-band config allows the highlight). */
+    selectionHighlighted: boolean;
+    /** Select-mode hover on this wall (useViewer.hoveredId). */
+    hoverHighlighted: boolean;
+}) => WallMaterialVariant;
+//# sourceMappingURL=wall-material-variant.d.ts.map

package/dist/systems/wall/wall-material-variant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-material-variant.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-material-variant.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,mBAAmB,GAC3B,SAAS,GACT,WAAW,GACX,aAAa,GACb,gBAAgB,GAChB,kBAAkB,GAClB,oBAAoB,GACpB,mBAAmB,GACnB,qBAAqB,GACrB,uBAAuB,GACvB,iBAAiB,CAAA;AAErB,eAAO,MAAM,0BAA0B,GAAI,yFAMxC;IACD,6DAA6D;IAC7D,eAAe,EAAE,OAAO,CAAA;IACxB,2EAA2E;IAC3E,MAAM,EAAE,OAAO,CAAA;IACf,6DAA6D;IAC7D,iBAAiB,EAAE,OAAO,CAAA;IAC1B,uEAAuE;IACvE,oBAAoB,EAAE,OAAO,CAAA;IAC7B,4DAA4D;IAC5D,gBAAgB,EAAE,OAAO,CAAA;CAC1B,KAAG,mBAMH,CAAA"}

package/dist/systems/wall/wall-material-variant.js

@@ -0,0 +1,10 @@
+export const resolveWallMaterialVariant = ({ translucentMode, hidden, deleteHighlighted, selectionHighlighted, hoverHighlighted, }) => {
+    const base = translucentMode ? 'translucent' : hidden ? 'invisible' : 'visible';
+    if (deleteHighlighted)
+        return `delete-${base}`;
+    if (selectionHighlighted)
+        return `selection-${base}`;
+    if (hoverHighlighted && base === 'invisible')
+        return 'hover-invisible';
+    return base;
+};

package/dist/systems/wall/wall-materials.d.ts

@@ -14,6 +14,12 @@ export interface WallMaterials {
 }
 /** Lazy light-emissive selection variant of a wall's material array (keeps texture). */
 export declare function getSelectionHighlightMaterials(materials: WallMaterialArray): WallMaterialArray;
+/**
+ * Softer hover sibling of the selection variant — the affordance for a
+ * hovered HIDDEN wall (`WallCutout` applies it to the invisible stipple
+ * film so the wall the click would select reads under the cursor).
+ */
+export declare function getHoverHighlightMaterials(materials: WallMaterialArray): WallMaterialArray;
 export declare function getWallMaterialHash(wallNode: WallNode, shading: RenderShading, sceneMaterials?: SceneMaterials): string;
 export declare function getMaterialsForWall(wallNode: WallNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string, sceneMaterials?: SceneMaterials): WallMaterials;
 export declare function getVisibleWallMaterials(wallNode: WallNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string, sceneMaterials?: SceneMaterials): WallMaterialArray;

package/dist/systems/wall/wall-materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,eAAe,EAGpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAS,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAG5C,OAAO,EAEL,KAAK,WAAW,EAKhB,KAAK,aAAa,EAGnB,MAAM,qBAAqB,CAAA;AAE5B,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,CAAA;AAexE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,EAAE,CAAA;AAE1C,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,iBAAiB,CAAA;IAC1B,SAAS,EAAE,iBAAiB,CAAA;IAC5B,WAAW,EAAE,iBAAiB,CAAA;IAC9B,aAAa,EAAE,iBAAiB,CAAA;IAChC,eAAe,EAAE,iBAAiB,CAAA;IAClC,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,YAAY,EAAE,MAAM,CAAA;CACrB;AAiSD,wFAAwF;AACxF,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,iBAAiB,GAAG,iBAAiB,CAE9F;AA4DD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,aAAa,EACtB,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CAcR;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,GAC9B,aAAa,CAgIf;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,GAC9B,iBAAiB,CAGnB"}
+{"version":3,"file":"wall-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,eAAe,EAGpB,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAS,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAG5C,OAAO,EAEL,KAAK,WAAW,EAMhB,KAAK,aAAa,EAGnB,MAAM,qBAAqB,CAAA;AAE5B,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,CAAA;AAexE,MAAM,MAAM,iBAAiB,GAAG,QAAQ,EAAE,CAAA;AAE1C,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,iBAAiB,CAAA;IAC1B,SAAS,EAAE,iBAAiB,CAAA;IAC5B,WAAW,EAAE,iBAAiB,CAAA;IAC9B,aAAa,EAAE,iBAAiB,CAAA;IAChC,eAAe,EAAE,iBAAiB,CAAA;IAClC,iBAAiB,EAAE,iBAAiB,CAAA;IACpC,YAAY,EAAE,MAAM,CAAA;CACrB;AA+SD,wFAAwF;AACxF,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,iBAAiB,GAAG,iBAAiB,CAS9F;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,iBAAiB,GAAG,iBAAiB,CAS1F;AA4DD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,aAAa,EACtB,cAAc,CAAC,EAAE,cAAc,GAC9B,MAAM,CAcR;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,GAC9B,aAAa,CAgIf;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,cAAc,GAC9B,iBAAiB,CAGnB"}

package/dist/systems/wall/wall-materials.js

@@ -2,7 +2,7 @@ import { getEffectiveWallSurfaceMaterial, getMaterialPresetByRef, getWallSurface
 import { Color } from 'three';
 import { Fn, float, fract, length, mix, positionLocal, smoothstep, step, vec2 } from 'three/tsl';
 import { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
-import { baseMaterial, createDefaultMaterial, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, resolveMaterialRef, resolveSurfaceColor, } from '../../lib/materials';
+import { baseMaterial, createDefaultMaterial, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, materialPresetRefSignature, resolveMaterialRef, resolveSurfaceColor, } from '../../lib/materials';
 const DEFAULT_WALL_COLOR = '#e9e7e3';
 const WALL_HIGHLIGHT_PROFILES = {
     delete: {
@@ -74,8 +74,10 @@ function resolveWallSlotMaterial(wallNode, slotId, shading, sceneMaterials) {
 }
 // Cache-key fragment for one face: the slot ref plus, for a `scene:` ref, the
 // referenced material's *content* — so editing a scene material assigned to a
-// wall invalidates the cache (a `library:` ref is static catalog content, so
-// its id alone is enough). Falls back to the legacy signature when unmigrated.
+// wall invalidates the cache. A `library:` ref carries its resolution state
+// instead: AI-generated materials register asynchronously, and a dangling ref
+// resolved to the slot default must not stay cached once the library lands.
+// Falls back to the legacy signature when unmigrated.
 function wallFaceMaterialSignature(wallNode, side, sceneMaterials) {
     const ref = wallNode.slots?.[side];
     if (ref) {
@@ -86,7 +88,7 @@ function wallFaceMaterialSignature(wallNode, side, sceneMaterials) {
                 material: sceneMaterials?.[parsed.id]?.material ?? null,
             });
         }
-        return JSON.stringify({ ref });
+        return JSON.stringify({ ref: materialPresetRefSignature(ref) });
     }
     return getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(wallNode, side));
 }
@@ -100,7 +102,7 @@ function wallSlotMaterialSignature(wallNode, slotId, sceneMaterials) {
                 material: sceneMaterials?.[parsed.id]?.material ?? null,
             });
         }
-        return JSON.stringify({ ref });
+        return JSON.stringify({ ref: materialPresetRefSignature(ref) });
     }
     const side = getWallSurfaceSideFromBandSlot(slotId);
     if (side)
@@ -181,6 +183,13 @@ function createHighlightedWallMaterial(material, kind) {
 const SELECTION_HIGHLIGHT_COLOR = new Color('#818cf8');
 const SELECTION_EMISSIVE_BLEND = 0.4;
 const SELECTION_EMISSIVE_INTENSITY = 0.12;
+// Softer sibling of the selection glow, for HOVERING a hidden wall (the
+// X-ray nearest-first selection made hidden walls hover targets; without a
+// material affordance the only thing lighting up was the furniture behind
+// them). Same indigo so hover reads as "this will select", weaker so a
+// hovered-then-selected wall still steps up on click.
+const HOVER_EMISSIVE_BLEND = 0.4;
+const HOVER_EMISSIVE_INTENSITY = 0.2;
 const SELECTION_TEXTURE_MAP_KEYS = [
     'map',
     'normalMap',
@@ -194,9 +203,10 @@ const SELECTION_TEXTURE_MAP_KEYS = [
     'lightMap',
 ];
 const selectionHighlightCache = new WeakMap();
-function getSelectionHighlightMaterial(base) {
+const hoverHighlightCache = new WeakMap();
+function getEmissiveHighlightMaterial(base, cache, emissiveBlend, emissiveIntensity) {
     const baseMap = base.map ?? null;
-    const cached = selectionHighlightCache.get(base);
+    const cached = cache.get(base);
     if (cached && cached.map === baseMap)
         return cached.clone;
     const clone = base.clone();
@@ -208,20 +218,26 @@ function getSelectionHighlightMaterial(base) {
             dst[key] = src[key];
     }
     if ('emissive' in clone && clone.emissive) {
-        clone.emissive = clone.emissive
-            .clone()
-            .lerp(SELECTION_HIGHLIGHT_COLOR, SELECTION_EMISSIVE_BLEND);
+        clone.emissive = clone.emissive.clone().lerp(SELECTION_HIGHLIGHT_COLOR, emissiveBlend);
     }
     if ('emissiveIntensity' in clone) {
-        clone.emissiveIntensity = Math.max(clone.emissiveIntensity ?? 0, SELECTION_EMISSIVE_INTENSITY);
+        clone.emissiveIntensity = Math.max(clone.emissiveIntensity ?? 0, emissiveIntensity);
     }
     clone.needsUpdate = true;
-    selectionHighlightCache.set(base, { clone, map: baseMap });
+    cache.set(base, { clone, map: baseMap });
     return clone;
 }
 /** Lazy light-emissive selection variant of a wall's material array (keeps texture). */
 export function getSelectionHighlightMaterials(materials) {
-    return materials.map(getSelectionHighlightMaterial);
+    return materials.map((material) => getEmissiveHighlightMaterial(material, selectionHighlightCache, SELECTION_EMISSIVE_BLEND, SELECTION_EMISSIVE_INTENSITY));
+}
+/**
+ * Softer hover sibling of the selection variant — the affordance for a
+ * hovered HIDDEN wall (`WallCutout` applies it to the invisible stipple
+ * film so the wall the click would select reads under the cursor).
+ */
+export function getHoverHighlightMaterials(materials) {
+    return materials.map((material) => getEmissiveHighlightMaterial(material, hoverHighlightCache, HOVER_EMISSIVE_BLEND, HOVER_EMISSIVE_INTENSITY));
 }
 function createInvisibleWallMaterial(color, shading) {
     const material = shading === 'solid'

package/dist/systems/wall/wall-placeholder-sweep.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Self-healing backstop for wall geometry: every registered wall whose mesh
+ * still carries the mount-time PLACEHOLDER geometry must eventually rebuild,
+ * no matter what consumed its dirty mark or when the wall system mounted.
+ *
+ * Why it exists: a live session (QA f2 probe5/probe6 — scene loaded with
+ * the Bones X-ray already active) surfaced all 24 walls stuck on their
+ * degenerate placeholder collision meshes indefinitely: no wall on the
+ * level ever became a ray target, so the hidden-wall selection gate could
+ * not engage even in principle. The renderer marks a wall dirty exactly
+ * once, on mount — if that one mark is consumed while the rebuild loop
+ * isn't looking (system mounted late, mark cleared by an unrelated flow,
+ * suspense unmount/remount), nothing ever re-marks it. This sweep closes
+ * that class: placeholder + not dirty → re-mark, and the normal rebuild
+ * path takes it from there. Idempotent and cheap (one geometry probe per
+ * wall, run every `WALL_PLACEHOLDER_SWEEP_INTERVAL` frames).
+ *
+ * Placeholder detection: `createPlaceholderGeometry` (packages/nodes,
+ * shared/placeholder-geometry.ts) mints a 3-vertex degenerate triangle and
+ * stamps `userData.placeholder`. Real wall extrusions always carry far more
+ * vertices, so the vertex-count signature doubles as a fallback for
+ * placeholders minted before the stamp existed.
+ */
+export declare const WALL_PLACEHOLDER_SWEEP_INTERVAL = 30;
+type GeometryLike = {
+    userData?: {
+        placeholder?: unknown;
+        built?: unknown;
+    };
+    getAttribute?: (name: string) => {
+        count: number;
+    } | undefined;
+} | null;
+/** Is this still the mount-time placeholder (never built by the system)? */
+export declare const isPlaceholderWallGeometry: (geometry: GeometryLike) => boolean;
+/**
+ * Re-mark every registered wall still on placeholder geometry that carries
+ * no dirty mark. Returns the ids it marked (for tests / diagnostics).
+ */
+export declare const sweepUnbuiltWalls: ({ wallIds, geometryOf, isDirty, markDirty, }: {
+    /** Registered wall node ids (sceneRegistry.byType.wall). */
+    wallIds: Iterable<string>;
+    /** The wall root mesh's current geometry, or null when unmounted. */
+    geometryOf: (wallId: string) => GeometryLike;
+    /** Whether the id already has a dirty mark (rebuild pending). */
+    isDirty: (wallId: string) => boolean;
+    markDirty: (wallId: string) => void;
+}) => string[];
+export {};
+//# sourceMappingURL=wall-placeholder-sweep.d.ts.map

package/dist/systems/wall/wall-placeholder-sweep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-placeholder-sweep.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-placeholder-sweep.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,eAAO,MAAM,+BAA+B,KAAK,CAAA;AAEjD,KAAK,YAAY,GAAG;IAClB,QAAQ,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;IACrD,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAA;CAC/D,GAAG,IAAI,CAAA;AAER,4EAA4E;AAC5E,eAAO,MAAM,yBAAyB,GAAI,UAAU,YAAY,KAAG,OAMlE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,8CAK/B;IACD,4DAA4D;IAC5D,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA;IACzB,qEAAqE;IACrE,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,YAAY,CAAA;IAC5C,iEAAiE;IACjE,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAA;IACpC,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;CACpC,KAAG,MAAM,EAST,CAAA"}

package/dist/systems/wall/wall-placeholder-sweep.js

@@ -0,0 +1,51 @@
+/**
+ * Self-healing backstop for wall geometry: every registered wall whose mesh
+ * still carries the mount-time PLACEHOLDER geometry must eventually rebuild,
+ * no matter what consumed its dirty mark or when the wall system mounted.
+ *
+ * Why it exists: a live session (QA f2 probe5/probe6 — scene loaded with
+ * the Bones X-ray already active) surfaced all 24 walls stuck on their
+ * degenerate placeholder collision meshes indefinitely: no wall on the
+ * level ever became a ray target, so the hidden-wall selection gate could
+ * not engage even in principle. The renderer marks a wall dirty exactly
+ * once, on mount — if that one mark is consumed while the rebuild loop
+ * isn't looking (system mounted late, mark cleared by an unrelated flow,
+ * suspense unmount/remount), nothing ever re-marks it. This sweep closes
+ * that class: placeholder + not dirty → re-mark, and the normal rebuild
+ * path takes it from there. Idempotent and cheap (one geometry probe per
+ * wall, run every `WALL_PLACEHOLDER_SWEEP_INTERVAL` frames).
+ *
+ * Placeholder detection: `createPlaceholderGeometry` (packages/nodes,
+ * shared/placeholder-geometry.ts) mints a 3-vertex degenerate triangle and
+ * stamps `userData.placeholder`. Real wall extrusions always carry far more
+ * vertices, so the vertex-count signature doubles as a fallback for
+ * placeholders minted before the stamp existed.
+ */
+export const WALL_PLACEHOLDER_SWEEP_INTERVAL = 30;
+/** Is this still the mount-time placeholder (never built by the system)? */
+export const isPlaceholderWallGeometry = (geometry) => {
+    if (!geometry)
+        return false;
+    if (geometry.userData?.placeholder === true)
+        return true;
+    if (geometry.userData?.built === true)
+        return false;
+    const position = geometry.getAttribute?.('position');
+    return position !== undefined && position.count === 3;
+};
+/**
+ * Re-mark every registered wall still on placeholder geometry that carries
+ * no dirty mark. Returns the ids it marked (for tests / diagnostics).
+ */
+export const sweepUnbuiltWalls = ({ wallIds, geometryOf, isDirty, markDirty, }) => {
+    const marked = [];
+    for (const wallId of wallIds) {
+        if (isDirty(wallId))
+            continue;
+        if (!isPlaceholderWallGeometry(geometryOf(wallId)))
+            continue;
+        markDirty(wallId);
+        marked.push(wallId);
+    }
+    return marked;
+};

package/dist/systems/wall/wall-rebuild-notifications.d.ts

@@ -0,0 +1,5 @@
+export declare function notifyWallRebuilt(wallId: string): void;
+export declare function subscribeWallRebuilds(listener: (wallId: string) => void): () => void;
+/** Moves every rebuild notice collected so far into `into`. */
+export declare function drainRebuiltWalls(into: Set<string>): void;
+//# sourceMappingURL=wall-rebuild-notifications.d.ts.map

package/dist/systems/wall/wall-rebuild-notifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-rebuild-notifications.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-rebuild-notifications.ts"],"names":[],"mappings":"AAOA,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAGtD;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CAKpF;AAED,+DAA+D;AAC/D,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAGzD"}

package/dist/systems/wall/wall-rebuild-notifications.js

@@ -0,0 +1,23 @@
+// New kind-specific modules belong in nodes; viewer must not depend on nodes.
+// This extracts the existing viewer-owned WallSystem rebuild signal.
+// Dirty marks disappear before later systems run. Keep the batch drain and
+// cutout subscribers independent, including deferred neighbour rebuilds.
+const rebuiltWalls = new Set();
+const listeners = new Set();
+export function notifyWallRebuilt(wallId) {
+    rebuiltWalls.add(wallId);
+    for (const listener of listeners)
+        listener(wallId);
+}
+export function subscribeWallRebuilds(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+/** Moves every rebuild notice collected so far into `into`. */
+export function drainRebuiltWalls(into) {
+    for (const wallId of rebuiltWalls)
+        into.add(wallId);
+    rebuiltWalls.clear();
+}

package/dist/systems/wall/wall-system.d.ts

@@ -1,7 +1,18 @@
-import { type AnyNode, type WallMiterData, type WallNode, type WallSlabSupportSegment } from '@pascal-app/core';
+import { type AnyNode, type AnyNodeId, type WallMiterData, type WallNode, type WallSlabSupportSegment } from '@pascal-app/core';
 import * as THREE from 'three';
+import { Brush } from 'three-bvh-csg';
+export { isWallInitialBuildActive } from './wall-build-lifecycle';
+export { drainRebuiltWalls } from './wall-rebuild-notifications';
+export declare function mergeWallCutoutBrushes(brushes: readonly Brush[]): {
+    cutter: Brush | null;
+    fallbackBrushes: Brush[];
+    droppedCount: number;
+};
+export declare function shouldDeferWallRebuild(wallId: string, nodes: Record<AnyNodeId, AnyNode>, rebuiltThisFrame: number, elapsedMs: number): boolean;
+/** Rebuilds this system still owes — neighbours deferred during a drag. */
+export declare function getPendingWallRebuildCount(): number;
 export declare const WallSystem: () => null;
+export declare function runWallBuildFrame(): void;
 type WallTerrainBottomSampler = (x: number, z: number) => number | null;
 export declare function generateExtrudedWall(wallNode: WallNode, childrenNodes: AnyNode[], miterData: WallMiterData, slabElevation?: number, baseElevation?: number, baseSegments?: readonly WallSlabSupportSegment[], storeyHeight?: number, terrainBottomAt?: WallTerrainBottomSampler): THREE.BufferGeometry;
-export {};
 //# sourceMappingURL=wall-system.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EA2BZ,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,sBAAsB,EAI5B,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAqd9B,eAAO,MAAM,UAAU,YAwJtB,CAAA;AAgND,KAAK,wBAAwB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;AAgEvE,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,EACjB,aAAa,SAAgB,EAC7B,YAAY,GAAE,SAAS,sBAAsB,EAE5C,EACD,YAAY,SAAuB,EACnC,eAAe,CAAC,EAAE,wBAAwB,GACzC,KAAK,CAAC,cAAc,CA0OtB"}
+{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAyBd,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,sBAAsB,EAI5B,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAY,KAAK,EAA0B,MAAM,eAAe,CAAA;AAsBvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AA2DhE,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,SAAS,KAAK,EAAE,GAAG;IACjE,MAAM,EAAE,KAAK,GAAG,IAAI,CAAA;IACpB,eAAe,EAAE,KAAK,EAAE,CAAA;IACxB,YAAY,EAAE,MAAM,CAAA;CACrB,CA4FA;AAmbD,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,gBAAgB,EAAE,MAAM,EACxB,SAAS,EAAE,MAAM,GAChB,OAAO,CAET;AAED,2EAA2E;AAC3E,wBAAgB,0BAA0B,IAAI,MAAM,CAEnD;AAID,eAAO,MAAM,UAAU,YAMtB,CAAA;AAED,wBAAgB,iBAAiB,SAahC;AA6bD,KAAK,wBAAwB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;AAgEvE,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,EACjB,aAAa,SAAgB,EAC7B,YAAY,GAAE,SAAS,sBAAsB,EAE5C,EACD,YAAY,SAAuB,EACnC,eAAe,CAAC,EAAE,wBAAwB,GACzC,KAAK,CAAC,cAAc,CAwPtB"}