@pascal-app/viewer 0.9.1 → 0.9.2

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

@@ -1,9 +1,9 @@
-import { emitter, sceneRegistry, useScene } from '@pascal-app/core';
+import { emitter, getWallFaceBandConfig, sceneRegistry, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import { Vector3 } from 'three/webgpu';
 import useViewer from '../../store/use-viewer';
-import { getMaterialsForWall } from './wall-materials';
+import { getMaterialsForWall, getSelectionHighlightMaterials, getWallMaterialHash, } from './wall-materials';
 const tmpVec = new Vector3();
 const u = new Vector3();
 const v = new Vector3();
@@ -28,6 +28,9 @@ function getWallHideState(wallNode, wallMesh, wallMode, cameraDir) {
     }
     return hideWall;
 }
+function sameMaterialArray(a, b) {
+    return Array.isArray(a) && a.length === b.length && a.every((material, i) => material === b[i]);
+}
 export const WallCutout = () => {
     const lastCameraPosition = useRef(new Vector3());
     const lastCameraTarget = useRef(new Vector3());
@@ -36,6 +39,7 @@ export const WallCutout = () => {
     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);
@@ -49,17 +53,27 @@ export const WallCutout = () => {
         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) => useScene.getState().nodes[id]?.type === 'wall'));
+        const highlightedWallIds = new Set([...selectedIds, ...previewSelectedIds].filter((id) => sceneState.nodes[id]?.type === 'wall'));
         const deleteHoveredWallId = hoverHighlightMode === 'delete' &&
             hoveredId &&
-            useScene.getState().nodes[hoveredId]?.type === 'wall'
+            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;
@@ -70,7 +84,8 @@ export const WallCutout = () => {
             lastColorPreset.current !== colorPreset ||
             lastSceneTheme.current !== sceneTheme ||
             sceneRegistry.byType.wall.size !== lastNumberOfWalls.current ||
-            lastHighlightKey.current !== highlightKey) {
+            lastHighlightKey.current !== highlightKey ||
+            lastWallAppearanceKey.current !== wallAppearanceKey) {
             lastCameraPosition.current.copy(currentCameraPosition);
             lastCameraTarget.current.copy(tmpVec);
             lastUpdateTime.current = currentTime;
@@ -80,27 +95,36 @@ export const WallCutout = () => {
                 const wallMesh = sceneRegistry.nodes.get(wallId);
                 if (!wallMesh)
                     return;
-                const wallNode = useScene.getState().nodes[wallId];
-                if (!wallNode || wallNode.type !== 'wall')
+                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 materials = getMaterialsForWall(wallNode, shading, textures, colorPreset, sceneTheme);
-                if (hideWall) {
+                const shouldSelectionHighlight = isSelectionHighlighted && !getWallFaceBandConfig(wallNode).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
-                        : isSelectionHighlighted
-                            ? materials.highlightedInvisible
+                        : shouldSelectionHighlight
+                            ? getSelectionHighlightMaterials(materials.invisible)
                             : materials.invisible;
                 }
                 else {
                     ;
                     wallMesh.material = isDeleteHighlighted
                         ? materials.deleteVisible
-                        : isSelectionHighlighted
-                            ? materials.highlightedVisible
+                        : shouldSelectionHighlight
+                            ? getSelectionHighlightMaterials(materials.visible)
                             : materials.visible;
                 }
             });
@@ -111,6 +135,7 @@ export const WallCutout = () => {
             lastSceneTheme.current = sceneTheme;
             lastNumberOfWalls.current = sceneRegistry.byType.wall.size;
             lastHighlightKey.current = highlightKey;
+            lastWallAppearanceKey.current = wallAppearanceKey;
         }
     });
     useEffect(() => {
@@ -121,17 +146,21 @@ export const WallCutout = () => {
                 if (!wallMesh)
                     return;
                 const wallNode = useScene.getState().nodes[wallId];
-                if (!wallNode || wallNode.type !== 'wall')
+                if (wallNode?.type !== 'wall')
                     return;
-                const mats = getMaterialsForWall(wallNode, useViewer.getState().shading, useViewer.getState().textures, useViewer.getState().colorPreset, useViewer.getState().sceneTheme);
+                const mats = getMaterialsForWall(wallNode, useViewer.getState().shading, useViewer.getState().textures, useViewer.getState().colorPreset, useViewer.getState().sceneTheme, useScene.getState().materials);
                 const current = wallMesh.material;
                 snapshot.set(wallMesh, current);
-                if (current === mats.highlightedVisible || current === mats.deleteVisible) {
+                if (current === mats.deleteVisible) {
                     wallMesh.material = mats.visible;
                 }
-                else if (current === mats.highlightedInvisible || current === mats.deleteInvisible) {
+                else if (current === mats.deleteInvisible) {
                     wallMesh.material = mats.invisible;
                 }
+                else if (current === mats.deleteTranslucent ||
+                    sameMaterialArray(current, getSelectionHighlightMaterials(mats.translucent))) {
+                    wallMesh.material = mats.translucent;
+                }
             });
         };
         const reapplyAfterCapture = () => {

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

@@ -1,17 +1,21 @@
-import { type WallNode } from '@pascal-app/core';
+import { type SceneMaterial, type SceneMaterialId, type WallNode } from '@pascal-app/core';
 import { type Material } from 'three';
 import { type ColorPreset, type RenderShading } from '../../lib/materials';
-export type WallMaterialArray = [Material, Material, Material];
+type SceneMaterials = Record<SceneMaterialId, SceneMaterial> | undefined;
+export type WallMaterialArray = Material[];
 export interface WallMaterials {
     visible: WallMaterialArray;
     invisible: WallMaterialArray;
+    translucent: WallMaterialArray;
     deleteVisible: WallMaterialArray;
     deleteInvisible: WallMaterialArray;
-    highlightedVisible: WallMaterialArray;
-    highlightedInvisible: WallMaterialArray;
+    deleteTranslucent: WallMaterialArray;
     materialHash: string;
 }
-export declare function getWallMaterialHash(wallNode: WallNode, shading: RenderShading): string;
-export declare function getMaterialsForWall(wallNode: WallNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): WallMaterials;
-export declare function getVisibleWallMaterials(wallNode: WallNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): WallMaterialArray;
+/** Lazy light-emissive selection variant of a wall's material array (keeps texture). */
+export declare function getSelectionHighlightMaterials(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;
+export {};
 //# sourceMappingURL=wall-materials.d.ts.map

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,EAKL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAS,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAA;AAG5C,OAAO,EAEL,KAAK,WAAW,EAIhB,KAAK,aAAa,EAEnB,MAAM,qBAAqB,CAAA;AAqB5B,MAAM,MAAM,iBAAiB,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAA;AAE9D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,iBAAiB,CAAA;IAC1B,SAAS,EAAE,iBAAiB,CAAA;IAC5B,aAAa,EAAE,iBAAiB,CAAA;IAChC,eAAe,EAAE,iBAAiB,CAAA;IAClC,kBAAkB,EAAE,iBAAiB,CAAA;IACrC,oBAAoB,EAAE,iBAAiB,CAAA;IACvC,YAAY,EAAE,MAAM,CAAA;CACrB;AA6HD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,aAAa,GAAG,MAAM,CAUtF;AAED,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,aAAa,CA6Ef;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,iBAAiB,CAEnB"}
+{"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"}

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

@@ -1,9 +1,9 @@
-import { getEffectiveWallSurfaceMaterial, getMaterialPresetByRef, getWallSurfaceMaterialSignature, resolveMaterial, } from '@pascal-app/core';
+import { getEffectiveWallSurfaceMaterial, getMaterialPresetByRef, getWallSurfaceMaterialSignature, getWallSurfaceSideFromBandSlot, parseMaterialRef, resolveMaterial, WALL_SLOT_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
 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, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, resolveSurfaceColor, } from '../../lib/materials';
-const DEFAULT_WALL_COLOR = '#f2f0ed';
+import { baseMaterial, createDefaultMaterial, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, resolveMaterialRef, resolveSurfaceColor, } from '../../lib/materials';
+const DEFAULT_WALL_COLOR = '#e9e7e3';
 const WALL_HIGHLIGHT_PROFILES = {
     delete: {
         color: new Color('#dc2626'),
@@ -11,12 +11,6 @@ const WALL_HIGHLIGHT_PROFILES = {
         emissiveBlend: 0.92,
         emissiveIntensity: 0.46,
     },
-    selection: {
-        color: new Color('#818cf8'),
-        blend: 0.32,
-        emissiveBlend: 0.7,
-        emissiveIntensity: 0.42,
-    },
 };
 const wallMaterialCache = new Map();
 const dotPattern = Fn(() => {
@@ -42,6 +36,108 @@ function getSurfaceVisibleMaterial(spec, shading) {
 function hasExplicitMaterial(spec) {
     return Boolean(spec.materialPreset || spec.material);
 }
+// Resolve a wall face's declared default — a catalog `library:` finish or a
+// flat colour — to a renderable material.
+function resolveWallSlotDefault(slotDefault, shading) {
+    if (parseMaterialRef(slotDefault)?.kind === 'library') {
+        return createMaterialFromPresetRef(slotDefault, shading) ?? baseMaterial(shading);
+    }
+    return createDefaultMaterial(slotDefault, 0.9, shading);
+}
+// Slot-first resolution for one wall face, matching every other paintable kind:
+//   node.slots[side] ref → legacy inline fields → declared slot default.
+// A dangling `scene:` ref (material deleted / copied across scenes) falls back
+// to the declared default — it never blocks rendering (the dangling-ref rule).
+function resolveWallFaceMaterial(wallNode, side, shading, sceneMaterials) {
+    const ref = wallNode.slots?.[side];
+    if (ref) {
+        return (resolveMaterialRef(ref, sceneMaterials, shading) ??
+            resolveWallSlotDefault(WALL_SLOT_DEFAULT[side], shading));
+    }
+    const spec = getEffectiveWallSurfaceMaterial(wallNode, side);
+    if (hasExplicitMaterial(spec)) {
+        return getSurfaceVisibleMaterial(spec, shading);
+    }
+    return resolveWallSlotDefault(WALL_SLOT_DEFAULT[side], shading);
+}
+function resolveWallSlotMaterial(wallNode, slotId, shading, sceneMaterials) {
+    const ref = wallNode.slots?.[slotId];
+    if (ref) {
+        return (resolveMaterialRef(ref, sceneMaterials, shading) ??
+            resolveWallSlotDefault(WALL_SURFACE_SLOT_DEFAULTS[slotId], shading));
+    }
+    const side = getWallSurfaceSideFromBandSlot(slotId);
+    if (side) {
+        return resolveWallFaceMaterial(wallNode, side, shading, sceneMaterials);
+    }
+    return resolveWallSlotDefault(WALL_SURFACE_SLOT_DEFAULTS[slotId], shading);
+}
+// 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.
+function wallFaceMaterialSignature(wallNode, side, sceneMaterials) {
+    const ref = wallNode.slots?.[side];
+    if (ref) {
+        const parsed = parseMaterialRef(ref);
+        if (parsed?.kind === 'scene') {
+            return JSON.stringify({
+                ref,
+                material: sceneMaterials?.[parsed.id]?.material ?? null,
+            });
+        }
+        return JSON.stringify({ ref });
+    }
+    return getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(wallNode, side));
+}
+function wallSlotMaterialSignature(wallNode, slotId, sceneMaterials) {
+    const ref = wallNode.slots?.[slotId];
+    if (ref) {
+        const parsed = parseMaterialRef(ref);
+        if (parsed?.kind === 'scene') {
+            return JSON.stringify({
+                ref,
+                material: sceneMaterials?.[parsed.id]?.material ?? null,
+            });
+        }
+        return JSON.stringify({ ref });
+    }
+    const side = getWallSurfaceSideFromBandSlot(slotId);
+    if (side)
+        return wallFaceMaterialSignature(wallNode, side, sceneMaterials);
+    return JSON.stringify({ default: WALL_SURFACE_SLOT_DEFAULTS[slotId] });
+}
+// Slot-first tint for the cutaway/invisible wall variant.
+function resolveWallFaceColor(wallNode, side, sceneMaterials, fallback) {
+    const ref = wallNode.slots?.[side];
+    if (ref) {
+        const parsed = parseMaterialRef(ref);
+        if (parsed?.kind === 'library') {
+            return getMaterialPresetByRef(ref)?.mapProperties?.color ?? fallback;
+        }
+        if (parsed?.kind === 'scene') {
+            const sceneMaterial = sceneMaterials?.[parsed.id];
+            return sceneMaterial ? resolveMaterial(sceneMaterial.material).color : fallback;
+        }
+        return fallback;
+    }
+    return getSurfaceColor(getEffectiveWallSurfaceMaterial(wallNode, side), fallback);
+}
+function resolveWallSlotColor(wallNode, slotId, sceneMaterials, fallback) {
+    const ref = wallNode.slots?.[slotId];
+    if (ref) {
+        const parsed = parseMaterialRef(ref);
+        if (parsed?.kind === 'library') {
+            return getMaterialPresetByRef(ref)?.mapProperties?.color ?? fallback;
+        }
+        if (parsed?.kind === 'scene') {
+            const sceneMaterial = sceneMaterials?.[parsed.id];
+            return sceneMaterial ? resolveMaterial(sceneMaterial.material).color : fallback;
+        }
+    }
+    const side = getWallSurfaceSideFromBandSlot(slotId);
+    return side ? resolveWallFaceColor(wallNode, side, sceneMaterials, fallback) : fallback;
+}
 function getSurfaceColor(spec, fallback = DEFAULT_WALL_COLOR) {
     const preset = getMaterialPresetByRef(spec.materialPreset);
     if (preset?.mapProperties?.color) {
@@ -73,6 +169,60 @@ function createHighlightedWallMaterial(material, kind) {
     highlightedMaterial.needsUpdate = true;
     return highlightedMaterial;
 }
+// Light selection highlight for walls (walls are excluded from the generic
+// editor selection highlight, so they need their own). Adds a gentle indigo
+// emissive (no albedo tint) so the real material/texture stays readable with a
+// soft "selected" glow. Two NodeMaterial-clone gotchas are handled:
+//   1. `clone()` on the WebGPU backend drops the texture-map nodes → re-attach
+//      them from the source (shared by reference).
+//   2. The wall's finish texture loads async, so an early clone has no map yet →
+//      cache keyed by the source `.map` and rebuild when it changes (self-heals
+//      once the texture lands).
+const SELECTION_HIGHLIGHT_COLOR = new Color('#818cf8');
+const SELECTION_EMISSIVE_BLEND = 0.4;
+const SELECTION_EMISSIVE_INTENSITY = 0.12;
+const SELECTION_TEXTURE_MAP_KEYS = [
+    'map',
+    'normalMap',
+    'roughnessMap',
+    'metalnessMap',
+    'aoMap',
+    'emissiveMap',
+    'bumpMap',
+    'displacementMap',
+    'alphaMap',
+    'lightMap',
+];
+const selectionHighlightCache = new WeakMap();
+function getSelectionHighlightMaterial(base) {
+    const baseMap = base.map ?? null;
+    const cached = selectionHighlightCache.get(base);
+    if (cached && cached.map === baseMap)
+        return cached.clone;
+    const clone = base.clone();
+    // Re-attach texture maps the WebGPU NodeMaterial clone drops.
+    const src = base;
+    const dst = clone;
+    for (const key of SELECTION_TEXTURE_MAP_KEYS) {
+        if (src[key])
+            dst[key] = src[key];
+    }
+    if ('emissive' in clone && clone.emissive) {
+        clone.emissive = clone.emissive
+            .clone()
+            .lerp(SELECTION_HIGHLIGHT_COLOR, SELECTION_EMISSIVE_BLEND);
+    }
+    if ('emissiveIntensity' in clone) {
+        clone.emissiveIntensity = Math.max(clone.emissiveIntensity ?? 0, SELECTION_EMISSIVE_INTENSITY);
+    }
+    clone.needsUpdate = true;
+    selectionHighlightCache.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);
+}
 function createInvisibleWallMaterial(color, shading) {
     const material = shading === 'solid'
         ? new MeshLambertNodeMaterial({
@@ -90,6 +240,22 @@ function createInvisibleWallMaterial(color, shading) {
     material.opacityNode = mix(float(0.0), float(0.24), dotPattern());
     return material;
 }
+function createTranslucentWallMaterial(color, shading) {
+    const material = shading === 'solid'
+        ? new MeshLambertNodeMaterial({
+            transparent: true,
+            color,
+            opacity: 0.35,
+            depthWrite: false,
+        })
+        : new MeshStandardNodeMaterial({
+            transparent: true,
+            color,
+            opacity: 0.35,
+            depthWrite: false,
+        });
+    return material;
+}
 function mapWallMaterialArray(materials, iteratee) {
     return materials.map(iteratee);
 }
@@ -104,17 +270,25 @@ function disposeOwnedMaterials(materials) {
         material.dispose();
     });
 }
-export function getWallMaterialHash(wallNode, shading) {
+export function getWallMaterialHash(wallNode, shading, sceneMaterials) {
     return JSON.stringify({
         shading,
-        interior: getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(wallNode, 'interior')),
-        exterior: getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(wallNode, 'exterior')),
+        interior: wallFaceMaterialSignature(wallNode, 'interior', sceneMaterials),
+        exterior: wallFaceMaterialSignature(wallNode, 'exterior', sceneMaterials),
+        lowerInterior: wallSlotMaterialSignature(wallNode, 'lowerInterior', sceneMaterials),
+        middleInterior: wallSlotMaterialSignature(wallNode, 'middleInterior', sceneMaterials),
+        upperInterior: wallSlotMaterialSignature(wallNode, 'upperInterior', sceneMaterials),
+        topInterior: wallSlotMaterialSignature(wallNode, 'topInterior', sceneMaterials),
+        lowerExterior: wallSlotMaterialSignature(wallNode, 'lowerExterior', sceneMaterials),
+        middleExterior: wallSlotMaterialSignature(wallNode, 'middleExterior', sceneMaterials),
+        upperExterior: wallSlotMaterialSignature(wallNode, 'upperExterior', sceneMaterials),
+        topExterior: wallSlotMaterialSignature(wallNode, 'topExterior', sceneMaterials),
     });
 }
-export function getMaterialsForWall(wallNode, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+export function getMaterialsForWall(wallNode, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme, sceneMaterials) {
     const cacheKey = `${wallNode.id}-${shading}-${textures}-${colorPreset}-${sceneTheme ?? 'base'}`;
     const materialHash = textures
-        ? getWallMaterialHash(wallNode, shading)
+        ? getWallMaterialHash(wallNode, shading, sceneMaterials)
         : JSON.stringify({ textures, colorPreset, sceneTheme });
     const existing = wallMaterialCache.get(cacheKey);
     if (existing && existing.materialHash === materialHash) {
@@ -123,50 +297,85 @@ export function getMaterialsForWall(wallNode, shading = 'rendered', textures = t
     if (existing) {
         disposeOwnedMaterials([
             existing.invisible,
+            existing.translucent,
             existing.deleteVisible,
             existing.deleteInvisible,
-            existing.highlightedVisible,
-            existing.highlightedInvisible,
+            existing.deleteTranslucent,
         ]);
     }
-    const interiorSpec = getEffectiveWallSurfaceMaterial(wallNode, 'interior');
-    const exteriorSpec = getEffectiveWallSurfaceMaterial(wallNode, 'exterior');
     const wallRoleMaterial = createSurfaceRoleMaterial('wall', colorPreset, undefined, sceneTheme);
-    // Untextured surfaces take the themed wall role colour even with textures on;
-    // only surfaces with an explicit preset/material keep their texture.
+    // Colored mode: each face resolves slot-first (node.slots ref → legacy inline
+    // fields → declared slot default, parity with the retired DEFAULT_WALL_MATERIAL).
+    // Textures-off collapses every face to the themed wall role (the guaranteed
+    // escape hatch). The edge/cap slot (index 0) stays role-based.
     const visible = textures
         ? [
             wallRoleMaterial,
-            hasExplicitMaterial(interiorSpec)
-                ? getSurfaceVisibleMaterial(interiorSpec, shading)
-                : wallRoleMaterial,
-            hasExplicitMaterial(exteriorSpec)
-                ? getSurfaceVisibleMaterial(exteriorSpec, shading)
-                : wallRoleMaterial,
+            resolveWallFaceMaterial(wallNode, 'interior', shading, sceneMaterials),
+            resolveWallFaceMaterial(wallNode, 'exterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'lowerInterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'middleInterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'upperInterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'topInterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'lowerExterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'middleExterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'upperExterior', shading, sceneMaterials),
+            resolveWallSlotMaterial(wallNode, 'topExterior', shading, sceneMaterials),
         ]
-        : [wallRoleMaterial, wallRoleMaterial, wallRoleMaterial];
+        : Array.from({ length: 11 }, () => wallRoleMaterial);
     const wallRoleColor = resolveSurfaceColor('wall', colorPreset, sceneTheme);
     const invisible = [
         createInvisibleWallMaterial(wallRoleColor, textures ? shading : 'solid'),
-        createInvisibleWallMaterial(textures ? getSurfaceColor(interiorSpec, wallRoleColor) : wallRoleColor, textures ? shading : 'solid'),
-        createInvisibleWallMaterial(textures ? getSurfaceColor(exteriorSpec, wallRoleColor) : wallRoleColor, textures ? shading : 'solid'),
+        ...['interior', 'exterior'].map((side) => createInvisibleWallMaterial(textures
+            ? resolveWallFaceColor(wallNode, side, sceneMaterials, wallRoleColor)
+            : wallRoleColor, textures ? shading : 'solid')),
+        ...[
+            'lowerInterior',
+            'middleInterior',
+            'upperInterior',
+            'topInterior',
+            'lowerExterior',
+            'middleExterior',
+            'upperExterior',
+            'topExterior',
+        ].map((slotId) => createInvisibleWallMaterial(textures
+            ? resolveWallSlotColor(wallNode, slotId, sceneMaterials, wallRoleColor)
+            : wallRoleColor, textures ? shading : 'solid')),
+    ];
+    const translucent = [
+        createTranslucentWallMaterial(wallRoleColor, textures ? shading : 'solid'),
+        ...['interior', 'exterior'].map((side) => createTranslucentWallMaterial(textures
+            ? resolveWallFaceColor(wallNode, side, sceneMaterials, wallRoleColor)
+            : wallRoleColor, textures ? shading : 'solid')),
+        ...[
+            'lowerInterior',
+            'middleInterior',
+            'upperInterior',
+            'topInterior',
+            'lowerExterior',
+            'middleExterior',
+            'upperExterior',
+            'topExterior',
+        ].map((slotId) => createTranslucentWallMaterial(textures
+            ? resolveWallSlotColor(wallNode, slotId, sceneMaterials, wallRoleColor)
+            : wallRoleColor, textures ? shading : 'solid')),
     ];
-    const highlightedVisible = mapWallMaterialArray(visible, (material) => createHighlightedWallMaterial(material, 'selection'));
-    const highlightedInvisible = mapWallMaterialArray(invisible, (material) => createHighlightedWallMaterial(material, 'selection'));
     const deleteVisible = mapWallMaterialArray(visible, (material) => createHighlightedWallMaterial(material, 'delete'));
     const deleteInvisible = mapWallMaterialArray(invisible, (material) => createHighlightedWallMaterial(material, 'delete'));
+    const deleteTranslucent = mapWallMaterialArray(translucent, (material) => createHighlightedWallMaterial(material, 'delete'));
     const result = {
         visible,
         invisible,
+        translucent,
         deleteVisible,
         deleteInvisible,
-        highlightedVisible,
-        highlightedInvisible,
+        deleteTranslucent,
         materialHash,
     };
     wallMaterialCache.set(cacheKey, result);
     return result;
 }
-export function getVisibleWallMaterials(wallNode, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
-    return getMaterialsForWall(wallNode, shading, textures, colorPreset, sceneTheme).visible;
+export function getVisibleWallMaterials(wallNode, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme, sceneMaterials) {
+    return getMaterialsForWall(wallNode, shading, textures, colorPreset, sceneTheme, sceneMaterials)
+        .visible;
 }

package/dist/systems/wall/wall-opening-cutout.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wall-opening-cutout.test.d.ts.map

package/dist/systems/wall/wall-opening-cutout.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-opening-cutout.test.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-opening-cutout.test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,59 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; viewer does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { calculateLevelMiters, DoorNode, sceneRegistry, WallNode } from '@pascal-app/core';
+import * as THREE from 'three';
+import { generateExtrudedWall } from './wall-system';
+describe('wall opening cutout', () => {
+    test('cuts a floor-level door directly from node geometry without a proxy mesh', () => {
+        const wall = WallNode.parse({
+            id: 'wall_floor-opening-cutout',
+            start: [0, 0],
+            end: [2, 0],
+            height: 2.5,
+            thickness: 0.1,
+        });
+        const door = DoorNode.parse({
+            id: 'door_floor-opening-cutout',
+            wallId: wall.id,
+            position: [1, 1.05, 0],
+            width: 0.9,
+            height: 2.1,
+        });
+        const wallMesh = new THREE.Mesh();
+        sceneRegistry.nodes.set(wall.id, wallMesh);
+        try {
+            const geometry = generateExtrudedWall(wall, [door], calculateLevelMiters([wall]));
+            const position = geometry.getAttribute('position');
+            const index = geometry.index;
+            const openingLeft = door.position[0] - door.width / 2;
+            const openingRight = door.position[0] + door.width / 2;
+            let wallFaceTrianglesInsideOpening = 0;
+            let baseTrianglesInsideOpening = 0;
+            for (let offset = 0; offset < (index?.count ?? position.count); offset += 3) {
+                const indices = [0, 1, 2].map((corner) => index ? index.getX(offset + corner) : offset + corner);
+                const vertices = indices.map((vertexIndex) => new THREE.Vector3(position.getX(vertexIndex), position.getY(vertexIndex), position.getZ(vertexIndex)));
+                const centroid = vertices
+                    .reduce((sum, vertex) => sum.add(vertex), new THREE.Vector3())
+                    .multiplyScalar(1 / 3);
+                const insideOpeningX = centroid.x > openingLeft + 1e-4 && centroid.x < openingRight - 1e-4;
+                if (!insideOpeningX)
+                    continue;
+                const onWallFace = vertices.every((vertex) => Math.abs(Math.abs(vertex.z) - (wall.thickness ?? 0.1) / 2) < 1e-5);
+                if (onWallFace && centroid.y > 1e-4 && centroid.y < door.height - 1e-4) {
+                    wallFaceTrianglesInsideOpening += 1;
+                }
+                if (vertices.every((vertex) => Math.abs(vertex.y) < 1e-5)) {
+                    baseTrianglesInsideOpening += 1;
+                }
+            }
+            expect(wallFaceTrianglesInsideOpening).toBe(0);
+            expect(baseTrianglesInsideOpening).toBe(0);
+            geometry.dispose();
+        }
+        finally {
+            sceneRegistry.nodes.delete(wall.id);
+            wallMesh.geometry.dispose();
+        }
+    });
+});

package/dist/systems/wall/wall-support-extension.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wall-support-extension.test.d.ts.map

package/dist/systems/wall/wall-support-extension.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-support-extension.test.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-support-extension.test.ts"],"names":[],"mappings":""}