@pascal-app/viewer 0.7.0 → 0.9.1

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

@@ -1,6 +1,5 @@
+import { getEffectiveNode, getFloorStackedPosition, sceneRegistry, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
-import { resolveLevelId, sceneRegistry, spatialGridManager, syncAutoStairOpenings, useScene, } from '@pascal-app/core';
-import { useEffect, useRef } from 'react';
 import * as THREE from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 const pendingStairUpdates = new Set();
@@ -17,26 +16,6 @@ export const StairSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
     const rootNodeIds = useScene((state) => state.rootNodeIds);
-    const syncingAutoOpeningsRef = useRef(false);
-    useEffect(() => {
-        const applyUpdates = (updates) => {
-            if (updates.length === 0)
-                return;
-            syncingAutoOpeningsRef.current = true;
-            useScene.getState().updateNodes(updates);
-            queueMicrotask(() => {
-                syncingAutoOpeningsRef.current = false;
-            });
-        };
-        applyUpdates(syncAutoStairOpenings(useScene.getState().nodes));
-        return useScene.subscribe((state, prevState) => {
-            if (syncingAutoOpeningsRef.current)
-                return;
-            if (state.nodes === prevState.nodes)
-                return;
-            applyUpdates(syncAutoStairOpenings(state.nodes));
-        });
-    }, []);
     useFrame(() => {
         if (rootNodeIds.length === 0) {
             pendingStairUpdates.clear();
@@ -58,8 +37,13 @@ export const StairSystem = () => {
                 if (mesh) {
                     const isVisible = mesh.parent?.visible !== false;
                     if (isVisible && segmentsProcessed < MAX_SEGMENTS_PER_FRAME) {
-                        // Geometry will be updated; chained position is applied in the parent sync pass below
-                        updateStairSegmentGeometry(node, mesh);
+                        // Geometry will be updated; chained position is applied in the parent sync pass below.
+                        // Merge live overrides so width / length / height drags update the
+                        // mesh in real time — the resize arrows publish to
+                        // `useLiveNodeOverrides` and only commit to scene on pointer-up, so
+                        // without this the geometry would rebuild from the pre-drag values.
+                        const effectiveSegment = getEffectiveNode(node);
+                        updateStairSegmentGeometry(effectiveSegment, mesh);
                         if (node.parentId)
                             parentsNeedingSegmentSync.add(node.parentId);
                         segmentsProcessed++;
@@ -68,11 +52,9 @@ export const StairSystem = () => {
                         return; // Over budget — keep dirty, process next frame
                     }
                     else if (mesh.geometry.type === 'BoxGeometry') {
-                        // Replace BoxGeometry placeholder with empty geometry
+                        // Replace BoxGeometry placeholder with a non-drawing degenerate one.
                         mesh.geometry.dispose();
-                        const placeholder = new THREE.BufferGeometry();
-                        placeholder.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
-                        mesh.geometry = placeholder;
+                        mesh.geometry = createEmptyGeometry();
                     }
                     clearDirty(id);
                 }
@@ -93,9 +75,17 @@ export const StairSystem = () => {
         });
         // --- Pass 1b: Sync chained transforms to individual segment meshes (edit mode) ---
         for (const stairId of parentsNeedingSegmentSync) {
-            const stairNode = nodes[stairId];
-            if (!stairNode || stairNode.type !== 'stair')
+            const baseStairNode = nodes[stairId];
+            if (!baseStairNode || baseStairNode.type !== 'stair')
                 continue;
+            // Merge any in-flight drag override (e.g. parent-stair rotate handle)
+            // so slab-elevation spatial queries match where the segments are
+            // actually being rendered. Without this, dragging the rotate gizmo
+            // looks up slabs at the pre-drag world XZ — if rotation carries a
+            // segment off the original slab footprint, the floor-stack
+            // resolver would otherwise read the pre-drag footprint and drop
+            // the flight or landing below the floor mid-drag.
+            const stairNode = getEffectiveNode(baseStairNode);
             const group = sceneRegistry.nodes.get(stairId);
             if (group) {
                 syncStairGroupElevation(stairNode, group, nodes);
@@ -217,9 +207,14 @@ function updateStairSegmentGeometry(node, mesh) {
  * not by the node's stored position field.
  */
 function syncSegmentMeshTransforms(stairNode, nodes) {
+    // Merge live overrides into each segment so the chain math reflects the
+    // in-flight drag (a width / length change shifts every downstream segment's
+    // anchor). Without this, dragging a width handle would resize the dragged
+    // segment's mesh but leave subsequent segments at their pre-drag positions.
     const segments = (stairNode.children ?? [])
         .map((childId) => nodes[childId])
-        .filter((n) => n?.type === 'stair-segment');
+        .filter((n) => n?.type === 'stair-segment')
+        .map((n) => getEffectiveNode(n));
     if (segments.length === 0)
         return;
     const transforms = computeSegmentTransforms(segments);
@@ -234,35 +229,20 @@ function syncSegmentMeshTransforms(stairNode, nodes) {
     }
 }
 function syncStairGroupElevation(stairNode, group, nodes) {
-    const levelId = resolveLevelId(stairNode, nodes);
-    const slabElevation = getStairSlabElevation(levelId, stairNode, nodes);
-    group.position.y = stairNode.position[1] + slabElevation;
-}
-function getStairSlabElevation(levelId, stairNode, nodes) {
-    const segments = (stairNode.children ?? [])
-        .map((childId) => nodes[childId])
-        .filter((n) => n?.type === 'stair-segment');
-    if (segments.length === 0)
-        return 0;
-    const transforms = computeSegmentTransforms(segments);
-    let maxElevation = Number.NEGATIVE_INFINITY;
-    for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i];
-        const transform = transforms[i];
-        const [centerOffsetX, centerOffsetZ] = rotateXZ(0, segment.length / 2, transform.rotation);
-        const centerInGroupX = transform.position[0] + centerOffsetX;
-        const centerInGroupZ = transform.position[2] + centerOffsetZ;
-        const [centerOffsetWorldX, centerOffsetWorldZ] = rotateXZ(centerInGroupX, centerInGroupZ, stairNode.rotation);
-        const slabElevation = spatialGridManager.getSlabElevationForItem(levelId, [
-            stairNode.position[0] + centerOffsetWorldX,
-            stairNode.position[1] + transform.position[1],
-            stairNode.position[2] + centerOffsetWorldZ,
-        ], [segment.width, Math.max(segment.height, segment.thickness, 0.01), segment.length], [0, stairNode.rotation + transform.rotation, 0]);
-        if (slabElevation > maxElevation) {
-            maxElevation = slabElevation;
+    const effectiveNodes = { ...nodes, [stairNode.id]: stairNode };
+    for (const childId of stairNode.children ?? []) {
+        const segment = nodes[childId];
+        if (segment?.type === 'stair-segment') {
+            effectiveNodes[segment.id] = getEffectiveNode(segment);
         }
     }
-    return maxElevation === Number.NEGATIVE_INFINITY ? 0 : maxElevation;
+    const visualPosition = getFloorStackedPosition({
+        node: stairNode,
+        nodes: effectiveNodes,
+        position: stairNode.position,
+        rotation: stairNode.rotation,
+    });
+    group.position.y = visualPosition[1];
 }
 // ============================================================================
 // MERGED STAIR GEOMETRY
@@ -281,9 +261,14 @@ function updateMergedStairGeometry(stairNode, group, nodes) {
         return;
     }
     const children = stairNode.children ?? [];
+    // Merge live overrides — same reason as `syncSegmentMeshTransforms`: a
+    // width / length / height drag publishes the new value to
+    // `useLiveNodeOverrides`, so the merged geometry has to read through that
+    // overlay or the merged mesh stays at pre-drag values until pointer-up.
     const segments = children
         .map((childId) => nodes[childId])
-        .filter((n) => n?.type === 'stair-segment');
+        .filter((n) => n?.type === 'stair-segment')
+        .map((n) => getEffectiveNode(n));
     if (segments.length === 0) {
         replaceMeshGeometry(mergedMesh, createEmptyGeometry());
         return;
@@ -362,7 +347,7 @@ function applyStraightStairMaterialGroups(geometry) {
 function applyStairSegmentUvs(geometry) {
     const position = geometry.getAttribute('position');
     const normal = geometry.getAttribute('normal');
-    if (!position || !normal || position.count === 0) {
+    if (!(position && normal) || position.count === 0) {
         geometry.deleteAttribute('uv');
         return;
     }
@@ -444,7 +429,11 @@ function rotateXZ(x, z, angle) {
 }
 function createEmptyGeometry() {
     const geometry = new THREE.BufferGeometry();
-    geometry.setAttribute('position', new THREE.Float32BufferAttribute([], 3));
+    // Three zero-vertices (one degenerate, invisible triangle), not an empty
+    // attribute: an empty position (count 0) leaves WebGPU vertex buffer slot 0
+    // unbound and the draw is rejected ("Vertex buffer slot 0 … was not set"),
+    // poisoning the command encoder. The count-0 groups keep nothing drawn.
+    geometry.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(9), 3));
     geometry.addGroup(0, 0, STAIR_TREAD_MATERIAL_INDEX);
     geometry.addGroup(0, 0, STAIR_SIDE_MATERIAL_INDEX);
     return geometry;
@@ -479,7 +468,7 @@ function generateStairRailingGeometry(stairNode, segments, transforms) {
     for (let index = 1; index < segmentRailPaths.length; index++) {
         const previousPath = segmentRailPaths[index - 1];
         const currentPath = segmentRailPaths[index];
-        if (!(previousPath && currentPath && currentPath.connectFromPrevious))
+        if (!(previousPath && currentPath?.connectFromPrevious))
             continue;
         if (previousPath.segment.segmentType === 'landing')
             continue;
@@ -554,9 +543,9 @@ function buildStairRailPaths(segments, transforms, railingMode, inset, landingIn
             return {
                 segment,
                 sidePaths: isStraightLineDoubleLandingLayout && index === 1
-                    ? (['left', 'right']
+                    ? ['left', 'right']
                         .map((side) => buildSegmentRailPath(layout, side, previousSegment, nextSegment, inset, landingInset))
-                        .filter((entry) => entry !== null))
+                        .filter((entry) => entry !== null)
                     : sidePaths,
                 connectFromPrevious: index > 0 &&
                     !(previousSegment?.segmentType === 'landing' && segment.segmentType === 'landing'),
@@ -652,7 +641,9 @@ function buildSegmentRailPath(layout, side, previousSegment, nextSegment, inset,
     const segmentStepHeight = segment.segmentType === 'landing' ? 0 : segment.height / segmentSteps;
     const segmentTopThickness = getSegmentTopThickness(segment);
     const flightSideOffset = side === 'left' ? segment.width / 2 - 0.045 : -segment.width / 2 + 0.045;
-    const flightStartX = previousSegment?.segmentType === 'landing' ? -segment.length / 2 + landingInset : -segment.length / 2;
+    const flightStartX = previousSegment?.segmentType === 'landing'
+        ? -segment.length / 2 + landingInset
+        : -segment.length / 2;
     const flightEndX = nextSegment?.segmentType === 'landing' ? segment.length / 2 - landingInset : segment.length / 2;
     if (segment.segmentType === 'landing') {
         return buildLandingRailPathFromScratch(layout, side, previousSegment, nextSegment, segmentTopThickness, landingInset);
@@ -662,15 +653,11 @@ function buildSegmentRailPath(layout, side, previousSegment, nextSegment, inset,
         points: [
             ...(previousSegment?.segmentType === 'landing'
                 ? []
-                : [
-                    toRailLayoutWorldPoint(layout, flightStartX, segmentTopThickness, flightSideOffset),
-                ]),
+                : [toRailLayoutWorldPoint(layout, flightStartX, segmentTopThickness, flightSideOffset)]),
             ...Array.from({ length: segmentSteps }).map((_, index) => toRailLayoutWorldPoint(layout, -segment.length / 2 + segmentStepDepth * index + segmentStepDepth / 2, segmentStepHeight * (index + 1), flightSideOffset)),
             ...(nextSegment?.segmentType === 'landing'
                 ? []
-                : [
-                    toRailLayoutWorldPoint(layout, flightEndX, segment.height, flightSideOffset),
-                ]),
+                : [toRailLayoutWorldPoint(layout, flightEndX, segment.height, flightSideOffset)]),
         ],
     };
 }

package/dist/systems/surface-hole-geometry.d.ts

@@ -0,0 +1,3 @@
+import { type Point2D } from '../lib/polygon-union';
+export declare function mergeSurfaceHolePolygons(holes: Point2D[][]): Point2D[][];
+//# sourceMappingURL=surface-hole-geometry.d.ts.map

package/dist/systems/surface-hole-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-hole-geometry.d.ts","sourceRoot":"","sources":["../../src/systems/surface-hole-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,sBAAsB,CAAA;AAElE,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAExE"}

package/dist/systems/surface-hole-geometry.js

@@ -0,0 +1,4 @@
+import { unionPolygons } from '../lib/polygon-union';
+export function mergeSurfaceHolePolygons(holes) {
+    return unionPolygons(holes);
+}

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

@@ -1 +1 @@
-{"version":3,"file":"wall-cutout.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout.tsx"],"names":[],"mappings":"AAsCA,eAAO,MAAM,UAAU,YAkHtB,CAAA"}
+{"version":3,"file":"wall-cutout.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout.tsx"],"names":[],"mappings":"AAsCA,eAAO,MAAM,UAAU,YAwItB,CAAA"}

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

@@ -33,10 +33,18 @@ export const WallCutout = () => {
     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 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;
@@ -57,6 +65,10 @@ export const WallCutout = () => {
         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) {
             lastCameraPosition.current.copy(currentCameraPosition);
@@ -74,7 +86,7 @@ export const WallCutout = () => {
                 const hideWall = getWallHideState(wallNode, wallMesh, wallMode, u);
                 const isDeleteHighlighted = deleteHoveredWallId === wallId;
                 const isSelectionHighlighted = !isDeleteHighlighted && highlightedWallIds.has(wallId);
-                const materials = getMaterialsForWall(wallNode);
+                const materials = getMaterialsForWall(wallNode, shading, textures, colorPreset, sceneTheme);
                 if (hideWall) {
                     ;
                     wallMesh.material = isDeleteHighlighted
@@ -93,6 +105,10 @@ export const WallCutout = () => {
                 }
             });
             lastWallMode.current = wallMode;
+            lastShading.current = shading;
+            lastTextures.current = textures;
+            lastColorPreset.current = colorPreset;
+            lastSceneTheme.current = sceneTheme;
             lastNumberOfWalls.current = sceneRegistry.byType.wall.size;
             lastHighlightKey.current = highlightKey;
         }
@@ -107,7 +123,7 @@ export const WallCutout = () => {
                 const wallNode = useScene.getState().nodes[wallId];
                 if (!wallNode || wallNode.type !== 'wall')
                     return;
-                const mats = getMaterialsForWall(wallNode);
+                const mats = getMaterialsForWall(wallNode, useViewer.getState().shading, useViewer.getState().textures, useViewer.getState().colorPreset, useViewer.getState().sceneTheme);
                 const current = wallMesh.material;
                 snapshot.set(wallMesh, current);
                 if (current === mats.highlightedVisible || current === mats.deleteVisible) {

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

@@ -1,5 +1,6 @@
 import { 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];
 export interface WallMaterials {
     visible: WallMaterialArray;
@@ -10,7 +11,7 @@ export interface WallMaterials {
     highlightedInvisible: WallMaterialArray;
     materialHash: string;
 }
-export declare function getWallMaterialHash(wallNode: WallNode): string;
-export declare function getMaterialsForWall(wallNode: WallNode): WallMaterials;
-export declare function getVisibleWallMaterials(wallNode: WallNode): WallMaterialArray;
+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;
 //# 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;AAwB5C,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;AA4GD,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAS9D;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,GAAG,aAAa,CA2DrE;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,GAAG,iBAAiB,CAE7E"}
+{"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"}

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

@@ -1,8 +1,8 @@
 import { getEffectiveWallSurfaceMaterial, getMaterialPresetByRef, getWallSurfaceMaterialSignature, resolveMaterial, } from '@pascal-app/core';
 import { Color } from 'three';
 import { Fn, float, fract, length, mix, positionLocal, smoothstep, step, vec2 } from 'three/tsl';
-import { MeshStandardNodeMaterial } from 'three/webgpu';
-import { baseMaterial, createMaterial, createMaterialFromPresetRef } from '../../lib/materials';
+import { MeshLambertNodeMaterial, MeshStandardNodeMaterial } from 'three/webgpu';
+import { baseMaterial, createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, resolveSurfaceColor, } from '../../lib/materials';
 const DEFAULT_WALL_COLOR = '#f2f0ed';
 const WALL_HIGHLIGHT_PROFILES = {
     delete: {
@@ -30,14 +30,17 @@ const dotPattern = Fn(() => {
     const yFade = float(1).sub(smoothstep(float(0), fadeHeight, positionLocal.y));
     return dots.mul(yFade);
 });
-function getSurfaceVisibleMaterial(spec) {
+function getSurfaceVisibleMaterial(spec, shading) {
     if (spec.materialPreset) {
-        return createMaterialFromPresetRef(spec.materialPreset) ?? baseMaterial;
+        return createMaterialFromPresetRef(spec.materialPreset, shading) ?? baseMaterial(shading);
     }
     if (spec.material) {
-        return createMaterial(spec.material);
+        return createMaterial(spec.material, shading);
     }
-    return baseMaterial;
+    return baseMaterial(shading);
+}
+function hasExplicitMaterial(spec) {
+    return Boolean(spec.materialPreset || spec.material);
 }
 function getSurfaceColor(spec, fallback = DEFAULT_WALL_COLOR) {
     const preset = getMaterialPresetByRef(spec.materialPreset);
@@ -70,14 +73,22 @@ function createHighlightedWallMaterial(material, kind) {
     highlightedMaterial.needsUpdate = true;
     return highlightedMaterial;
 }
-function createInvisibleWallMaterial(color) {
-    return new MeshStandardNodeMaterial({
-        transparent: true,
-        opacityNode: mix(float(0.0), float(0.24), dotPattern()),
-        color,
-        depthWrite: false,
-        emissive: color,
-    });
+function createInvisibleWallMaterial(color, shading) {
+    const material = shading === 'solid'
+        ? new MeshLambertNodeMaterial({
+            transparent: true,
+            color,
+            depthWrite: false,
+            emissive: color,
+        })
+        : new MeshStandardNodeMaterial({
+            transparent: true,
+            color,
+            depthWrite: false,
+            emissive: color,
+        });
+    material.opacityNode = mix(float(0.0), float(0.24), dotPattern());
+    return material;
 }
 function mapWallMaterialArray(materials, iteratee) {
     return materials.map(iteratee);
@@ -93,15 +104,18 @@ function disposeOwnedMaterials(materials) {
         material.dispose();
     });
 }
-export function getWallMaterialHash(wallNode) {
+export function getWallMaterialHash(wallNode, shading) {
     return JSON.stringify({
+        shading,
         interior: getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(wallNode, 'interior')),
         exterior: getWallSurfaceMaterialSignature(getEffectiveWallSurfaceMaterial(wallNode, 'exterior')),
     });
 }
-export function getMaterialsForWall(wallNode) {
-    const cacheKey = wallNode.id;
-    const materialHash = getWallMaterialHash(wallNode);
+export function getMaterialsForWall(wallNode, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+    const cacheKey = `${wallNode.id}-${shading}-${textures}-${colorPreset}-${sceneTheme ?? 'base'}`;
+    const materialHash = textures
+        ? getWallMaterialHash(wallNode, shading)
+        : JSON.stringify({ textures, colorPreset, sceneTheme });
     const existing = wallMaterialCache.get(cacheKey);
     if (existing && existing.materialHash === materialHash) {
         return existing;
@@ -117,15 +131,25 @@ export function getMaterialsForWall(wallNode) {
     }
     const interiorSpec = getEffectiveWallSurfaceMaterial(wallNode, 'interior');
     const exteriorSpec = getEffectiveWallSurfaceMaterial(wallNode, 'exterior');
-    const visible = [
-        baseMaterial,
-        getSurfaceVisibleMaterial(interiorSpec),
-        getSurfaceVisibleMaterial(exteriorSpec),
-    ];
+    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.
+    const visible = textures
+        ? [
+            wallRoleMaterial,
+            hasExplicitMaterial(interiorSpec)
+                ? getSurfaceVisibleMaterial(interiorSpec, shading)
+                : wallRoleMaterial,
+            hasExplicitMaterial(exteriorSpec)
+                ? getSurfaceVisibleMaterial(exteriorSpec, shading)
+                : wallRoleMaterial,
+        ]
+        : [wallRoleMaterial, wallRoleMaterial, wallRoleMaterial];
+    const wallRoleColor = resolveSurfaceColor('wall', colorPreset, sceneTheme);
     const invisible = [
-        createInvisibleWallMaterial(DEFAULT_WALL_COLOR),
-        createInvisibleWallMaterial(getSurfaceColor(interiorSpec, DEFAULT_WALL_COLOR)),
-        createInvisibleWallMaterial(getSurfaceColor(exteriorSpec, DEFAULT_WALL_COLOR)),
+        createInvisibleWallMaterial(wallRoleColor, textures ? shading : 'solid'),
+        createInvisibleWallMaterial(textures ? getSurfaceColor(interiorSpec, wallRoleColor) : wallRoleColor, textures ? shading : 'solid'),
+        createInvisibleWallMaterial(textures ? getSurfaceColor(exteriorSpec, wallRoleColor) : wallRoleColor, textures ? shading : 'solid'),
     ];
     const highlightedVisible = mapWallMaterialArray(visible, (material) => createHighlightedWallMaterial(material, 'selection'));
     const highlightedInvisible = mapWallMaterialArray(invisible, (material) => createHighlightedWallMaterial(material, 'selection'));
@@ -143,6 +167,6 @@ export function getMaterialsForWall(wallNode) {
     wallMaterialCache.set(cacheKey, result);
     return result;
 }
-export function getVisibleWallMaterials(wallNode) {
-    return getMaterialsForWall(wallNode).visible;
+export function getVisibleWallMaterials(wallNode, shading = 'rendered', textures = true, colorPreset = 'clay', sceneTheme) {
+    return getMaterialsForWall(wallNode, shading, textures, colorPreset, sceneTheme).visible;
 }

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

@@ -7,5 +7,5 @@ export declare const WallSystem: () => null;
  * Key insight from demo: polygon is built in WORLD coordinates first,
  * then we transform to wall-local for the 3D mesh.
  */
-export declare function generateExtrudedWall(wallNode: WallNode, childrenNodes: AnyNode[], miterData: WallMiterData, slabElevation?: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+export declare function generateExtrudedWall(wallNode: WallNode, childrenNodes: AnyNode[], miterData: WallMiterData, slabElevation?: number): THREE.BufferGeometry;
 //# 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,EAkBZ,KAAK,aAAa,EAClB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA6R9B,eAAO,MAAM,UAAU,YAuDtB,CAAA;AA0DD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,oFA0GlB"}
+{"version":3,"file":"wall-system.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAqBZ,KAAK,aAAa,EAClB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA8T9B,eAAO,MAAM,UAAU,YAwJtB,CAAA;AAkGD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,OAAO,EAAE,EACxB,SAAS,EAAE,aAAa,EACxB,aAAa,SAAI,GAChB,KAAK,CAAC,cAAc,CAyGtB"}