@pascal-app/viewer 0.8.0 → 0.9.1

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.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;AAiS9B,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,GAChB,KAAK,CAAC,cAAc,CAyGtB"}
+{"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"}

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

@@ -1,4 +1,4 @@
-import { calculateLevelMiters, DEFAULT_WALL_HEIGHT, getAdjacentWallIds, getWallCurveFrameAt, getWallMiterBoundaryPoints, getWallPlanFootprint, getWallSurfacePolygon, getWallThickness, isCurvedWall, pointToKey, resolveLevelId, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
+import { calculateLevelMiters, DEFAULT_WALL_HEIGHT, getAdjacentWallIds, getEffectiveNode, getWallCurveFrameAt, getWallMiterBoundaryPoints, getWallPlanFootprint, getWallSurfacePolygon, getWallThickness, isCurvedWall, pointToKey, resolveLevelId, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
 import { Brush, Evaluator, SUBTRACTION } from 'three-bvh-csg';
@@ -208,49 +208,158 @@ function assignWallMaterialGroups(geometry, wall, boundaryEdges) {
 // WALL SYSTEM
 // ============================================================================
 let useFrameNb = 0;
+// ─── Drag-throttle state (singleton — one WallSystem mounted globally) ──
+//
+// Endpoint drags fire `markDirty(wallId)` on every pointermove tick. Without
+// throttling, each tick rebuilds the dragged wall (~1 CSG + miter pass) AND
+// every adjacent wall sharing a corner (3–4× in a t-junction or room).
+// Visible as drag lag, especially on walls with door/window cutouts.
+//
+// Strategy: rebuild the dragged wall every tick (so the drag follows the
+// cursor with full fidelity), but defer adjacent rebuilds to a trailing-
+// edge flush DRAG_FLUSH_MS after the dirty stream stops. Visually, neighbor
+// corners stay at their pre-drag miter until release, then snap into place
+// within ~80ms. Standard CAD-app behavior. Speeds up t-junction drags ~3×,
+// 4-corner-room drags ~4×.
+const DRAG_FLUSH_MS = 80;
+const MAX_WALL_REBUILDS_PER_FRAME = 8;
+const WALL_PROGRESSIVE_DIRTY_THRESHOLD = MAX_WALL_REBUILDS_PER_FRAME;
+const WALL_PROGRESSIVE_TIME_BUDGET_MS = 8;
+let lastWallDirtyAtMs = 0;
+const pendingAdjacentByLevel = new Map();
+function getPendingAdjacentCount() {
+    let count = 0;
+    for (const ids of pendingAdjacentByLevel.values()) {
+        count += ids.size;
+    }
+    return count;
+}
 export const WallSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
+    // Subscribe so override-only changes (no scene write) still re-run
+    // this component, which lets the gate below pick up the latest
+    // `dirtyNodes` set from the same render pass that received the
+    // override-publishing `markDirty` call. Without this, very fast
+    // drags could land an override and a markDirty in the same React
+    // tick and the next `useFrame` would still see the stale closure.
+    useLiveNodeOverrides((s) => s.overrides);
     useFrame(() => {
-        if (dirtyNodes.size === 0)
+        const hasDirty = dirtyNodes.size > 0;
+        const hasPending = pendingAdjacentByLevel.size > 0;
+        if (!hasDirty && !hasPending)
             return;
         const nodes = useScene.getState().nodes;
+        const now = performance.now();
         // Collect dirty walls and their levels
         const dirtyWallsByLevel = new Map();
+        let dirtyWallCount = 0;
         useFrameNb += 1;
-        dirtyNodes.forEach((id) => {
-            const node = nodes[id];
-            if (!node || node.type !== 'wall')
-                return;
-            const levelId = node.parentId;
-            if (!levelId)
-                return;
-            if (!dirtyWallsByLevel.has(levelId)) {
-                dirtyWallsByLevel.set(levelId, new Set());
-            }
-            dirtyWallsByLevel.get(levelId)?.add(id);
-        });
+        if (hasDirty) {
+            dirtyNodes.forEach((id) => {
+                const node = nodes[id];
+                if (!node || node.type !== 'wall')
+                    return;
+                const levelId = node.parentId;
+                if (!levelId)
+                    return;
+                if (!dirtyWallsByLevel.has(levelId)) {
+                    dirtyWallsByLevel.set(levelId, new Set());
+                }
+                dirtyWallsByLevel.get(levelId)?.add(id);
+                dirtyWallCount += 1;
+            });
+        }
+        const hasDirtyWalls = dirtyWallsByLevel.size > 0;
+        if (hasDirtyWalls) {
+            lastWallDirtyAtMs = now;
+        }
+        const useProgressiveWallRebuilds = dirtyWallCount > WALL_PROGRESSIVE_DIRTY_THRESHOLD;
+        let rebuiltWallsThisFrame = 0;
+        const rebuildFrameStartedAt = now;
         // Process each level that has dirty walls
         for (const [levelId, dirtyWallIds] of dirtyWallsByLevel) {
+            if (useProgressiveWallRebuilds && rebuiltWallsThisFrame >= MAX_WALL_REBUILDS_PER_FRAME) {
+                break;
+            }
             const levelWalls = getLevelWalls(levelId);
             const miterData = calculateLevelMiters(levelWalls);
-            // Update dirty walls
+            const rebuiltWallIds = new Set();
+            // Update dirty walls — always, no throttling. The dragged wall must
+            // follow the cursor with full fidelity (cutouts and all). Large imports
+            // enter the progressive path so initial load can't lock the tab.
             for (const wallId of dirtyWallIds) {
+                if (useProgressiveWallRebuilds) {
+                    if (rebuiltWallsThisFrame >= MAX_WALL_REBUILDS_PER_FRAME) {
+                        break;
+                    }
+                    if (rebuiltWallsThisFrame > 0 &&
+                        performance.now() - rebuildFrameStartedAt >= WALL_PROGRESSIVE_TIME_BUDGET_MS) {
+                        break;
+                    }
+                }
                 const mesh = sceneRegistry.nodes.get(wallId);
                 if (mesh) {
                     updateWallGeometry(wallId, miterData);
                     clearDirty(wallId);
+                    rebuiltWallIds.add(wallId);
+                    rebuiltWallsThisFrame += 1;
                 }
                 // If mesh not found, keep it dirty for next frame
             }
-            // Update adjacent walls that share junctions
-            const adjacentWallIds = getAdjacentWallIds(levelWalls, dirtyWallIds);
+            if (rebuiltWallIds.size === 0) {
+                continue;
+            }
+            // Adjacent walls sharing junctions — *defer* during active drag
+            // (dirty arrived this frame), flush on the trailing edge.
+            const adjacentWallIds = getAdjacentWallIds(levelWalls, rebuiltWallIds);
+            let pending = pendingAdjacentByLevel.get(levelId);
+            if (!pending) {
+                pending = new Set();
+                pendingAdjacentByLevel.set(levelId, pending);
+            }
             for (const wallId of adjacentWallIds) {
                 if (!dirtyWallIds.has(wallId)) {
+                    pending.add(wallId);
+                }
+            }
+        }
+        // Trailing-edge flush: if no new dirty marks for DRAG_FLUSH_MS, the
+        // drag has ended — rebuild the queued neighbors so corners snap into
+        // their correct miter joins.
+        const quiet = !hasDirtyWalls && now - lastWallDirtyAtMs >= DRAG_FLUSH_MS;
+        if (quiet && pendingAdjacentByLevel.size > 0) {
+            const pendingCount = getPendingAdjacentCount();
+            const useProgressiveAdjacentRebuilds = pendingCount > WALL_PROGRESSIVE_DIRTY_THRESHOLD;
+            let rebuiltAdjacentThisFrame = 0;
+            const adjacentFrameStartedAt = performance.now();
+            for (const [levelId, pendingIds] of pendingAdjacentByLevel) {
+                if (pendingIds.size === 0)
+                    continue;
+                const levelWalls = getLevelWalls(levelId);
+                const miterData = calculateLevelMiters(levelWalls);
+                for (const wallId of Array.from(pendingIds)) {
+                    if (useProgressiveAdjacentRebuilds) {
+                        if (rebuiltAdjacentThisFrame >= MAX_WALL_REBUILDS_PER_FRAME) {
+                            break;
+                        }
+                        if (rebuiltAdjacentThisFrame > 0 &&
+                            performance.now() - adjacentFrameStartedAt >= WALL_PROGRESSIVE_TIME_BUDGET_MS) {
+                            break;
+                        }
+                    }
                     const mesh = sceneRegistry.nodes.get(wallId);
-                    if (mesh) {
+                    if (mesh)
                         updateWallGeometry(wallId, miterData);
-                    }
+                    pendingIds.delete(wallId);
+                    rebuiltAdjacentThisFrame += 1;
+                }
+                if (pendingIds.size === 0) {
+                    pendingAdjacentByLevel.delete(levelId);
+                }
+                if (useProgressiveAdjacentRebuilds &&
+                    rebuiltAdjacentThisFrame >= MAX_WALL_REBUILDS_PER_FRAME) {
+                    break;
                 }
             }
         }
@@ -258,7 +367,22 @@ export const WallSystem = () => {
     return null;
 };
 /**
- * Gets all walls that belong to a level
+ * Merge any live override for a wall into the scene record. Lets the
+ * 2D move handler publish `{ start, end, curveOffset }` to
+ * `useLiveNodeOverrides` and have the geometry / miter pipeline use
+ * those values without zustand churn during the drag. When no
+ * override is set, the wall is returned unchanged.
+ */
+function getEffectiveWall(wall) {
+    const override = useLiveNodeOverrides.getState().get(wall.id);
+    if (!override || Object.keys(override).length === 0)
+        return wall;
+    return { ...wall, ...override };
+}
+/**
+ * Gets all walls that belong to a level, with any live overrides
+ * merged in so miters compute against the cursor-driven positions
+ * (not the pre-drag scene state).
  */
 function getLevelWalls(levelId) {
     const { nodes } = useScene.getState();
@@ -269,28 +393,49 @@ function getLevelWalls(levelId) {
     for (const childId of level.children) {
         const child = nodes[childId];
         if (child?.type === 'wall') {
-            walls.push(child);
+            walls.push(getEffectiveWall(child));
         }
     }
     return walls;
 }
 /**
- * Updates the geometry for a single wall
+ * Updates the geometry for a single wall. Reads the effective node
+ * (override-merged) so a 2D drag visibly moves the 3D mesh without
+ * having touched `useScene` mid-drag.
  */
 function updateWallGeometry(wallId, miterData) {
     const nodes = useScene.getState().nodes;
-    const node = nodes[wallId];
-    if (!node || node.type !== 'wall')
+    const sceneNode = nodes[wallId];
+    if (!sceneNode || sceneNode.type !== 'wall')
         return;
+    const node = getEffectiveWall(sceneNode);
     const mesh = sceneRegistry.nodes.get(wallId);
     if (!mesh)
         return;
     const levelId = resolveLevelId(node, nodes);
-    const slabElevation = spatialGridManager.getSlabElevationForWall(levelId, node.start, node.end);
+    const slabElevation = spatialGridManager.getSlabElevationForWall(levelId, node.start, node.end, node.curveOffset ?? 0, node.thickness);
     const childrenIds = node.children || [];
+    // Merge live overrides into door / window children so cutouts track an
+    // in-flight resize drag (door width arrow, window height arrow, etc.)
+    // without waiting on the scene store. Non-cutout children pass through
+    // unchanged.
     const childrenNodes = childrenIds
         .map((childId) => nodes[childId])
-        .filter((n) => n !== undefined);
+        .filter((n) => n !== undefined)
+        .map((child) => {
+        if (child.type !== 'door' && child.type !== 'window')
+            return child;
+        // `getEffectiveNode` folds in resize overrides (width/height arrows).
+        // Position moves publish to `useLiveTransforms` instead, so fold that
+        // in too — otherwise shaped openings (arch/rounded/`opening`), whose
+        // cutout brush is rebuilt from `node.position`, lag the live move
+        // (rectangular cutouts already track via the live mesh matrixWorld).
+        const effective = getEffectiveNode(child);
+        const live = useLiveTransforms.getState().get(child.id);
+        if (!live?.position)
+            return effective;
+        return { ...effective, position: live.position };
+    });
     const newGeo = generateExtrudedWall(node, childrenNodes, miterData, slabElevation);
     mesh.geometry.dispose();
     mesh.geometry = newGeo;

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

@@ -1 +1 @@
-{"version":3,"file":"window-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-system.tsx"],"names":[],"mappings":"AAaA,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,8BAA8B,8BAA8B,CAAA;AACzE,eAAO,MAAM,+BAA+B,+BAA+B,CAAA;AAC3E,eAAO,MAAM,gCAAgC,gCAAgC,CAAA;AAC7E,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,0BAA0B,0BAA0B,CAAA;AACjE,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAC3D,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAE3D,eAAO,MAAM,YAAY,YA2BxB,CAAA"}
+{"version":3,"file":"window-system.d.ts","sourceRoot":"","sources":["../../../src/systems/window/window-system.tsx"],"names":[],"mappings":"AAuBA,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,8BAA8B,8BAA8B,CAAA;AACzE,eAAO,MAAM,+BAA+B,+BAA+B,CAAA;AAC3E,eAAO,MAAM,gCAAgC,gCAAgC,CAAA;AAC7E,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,yBAAyB,yBAAyB,CAAA;AAC/D,eAAO,MAAM,4BAA4B,4BAA4B,CAAA;AACrE,eAAO,MAAM,0BAA0B,0BAA0B,CAAA;AACjE,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAC3D,eAAO,MAAM,uBAAuB,uBAAuB,CAAA;AAM3D,eAAO,MAAM,YAAY,YA0FxB,CAAA"}

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

@@ -1,9 +1,13 @@
-import { sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
+import { getEffectiveNode, sceneRegistry, useInteractive, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
 import * as THREE from 'three';
-import { baseMaterial, glassMaterial } from '../../lib/materials';
+import { createSurfaceRoleMaterial, glassMaterial as defaultGlassMaterial, baseMaterial as getBaseMaterial, } from '../../lib/materials';
+import useViewer from '../../store/use-viewer';
 // Invisible material for root mesh — used as selection hitbox only
 const hitboxMaterial = new THREE.MeshBasicMaterial({ visible: false });
+let baseMaterial = getBaseMaterial();
+let glassMaterial = defaultGlassMaterial;
 export const CASEMENT_WINDOW_SASH_NAME = 'casement-window-sash';
 export const FRENCH_CASEMENT_LEFT_SASH_NAME = 'french-casement-left-sash';
 export const FRENCH_CASEMENT_RIGHT_SASH_NAME = 'french-casement-right-sash';
@@ -14,27 +18,87 @@ export const DOUBLE_HUNG_BOTTOM_SASH_NAME = 'double-hung-bottom-sash';
 export const LOUVERED_WINDOW_SLATS_NAME = 'louvered-window-slats';
 export const AWNING_WINDOW_SASH_NAME = 'awning-window-sash';
 export const HOPPER_WINDOW_SASH_NAME = 'hopper-window-sash';
+const MAX_WINDOW_REBUILDS_PER_FRAME = 16;
+const WINDOW_PROGRESSIVE_DIRTY_THRESHOLD = MAX_WINDOW_REBUILDS_PER_FRAME;
+const WINDOW_PROGRESSIVE_TIME_BUDGET_MS = 8;
 export const WindowSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
+    const shading = useViewer((state) => state.shading);
+    const textures = useViewer((state) => state.textures);
+    const colorPreset = useViewer((state) => state.colorPreset);
+    const materialRevisionRef = useRef(null);
+    // Subscribe so override-only updates re-run this component. Mirrors
+    // WallSystem + DoorSystem.
+    useLiveNodeOverrides((s) => s.overrides);
+    baseMaterial = textures
+        ? getBaseMaterial(shading)
+        : createSurfaceRoleMaterial('joinery', colorPreset);
+    glassMaterial = textures
+        ? defaultGlassMaterial
+        : createSurfaceRoleMaterial('glazing', colorPreset);
+    useEffect(() => {
+        const materialRevision = `${shading}:${textures ? 'textures' : 'solid'}:${colorPreset}`;
+        if (materialRevisionRef.current === materialRevision)
+            return;
+        materialRevisionRef.current = materialRevision;
+        const nodes = useScene.getState().nodes;
+        for (const node of Object.values(nodes)) {
+            if (node?.type === 'window') {
+                useScene.getState().dirtyNodes.add(node.id);
+            }
+        }
+    });
     useFrame(() => {
         if (dirtyNodes.size === 0)
             return;
+        baseMaterial = textures
+            ? getBaseMaterial(shading)
+            : createSurfaceRoleMaterial('joinery', colorPreset);
+        glassMaterial = textures
+            ? defaultGlassMaterial
+            : createSurfaceRoleMaterial('glazing', colorPreset);
         const nodes = useScene.getState().nodes;
+        const dirtyWindowIds = [];
         dirtyNodes.forEach((id) => {
             const node = nodes[id];
             if (!node || node.type !== 'window')
                 return;
+            dirtyWindowIds.push(id);
+        });
+        const useProgressiveWindowRebuilds = dirtyWindowIds.length > WINDOW_PROGRESSIVE_DIRTY_THRESHOLD;
+        const frameStartedAt = performance.now();
+        let rebuiltWindowsThisFrame = 0;
+        for (const id of dirtyWindowIds) {
+            if (useProgressiveWindowRebuilds) {
+                if (rebuiltWindowsThisFrame >= MAX_WINDOW_REBUILDS_PER_FRAME) {
+                    break;
+                }
+                if (rebuiltWindowsThisFrame > 0 &&
+                    performance.now() - frameStartedAt >= WINDOW_PROGRESSIVE_TIME_BUDGET_MS) {
+                    break;
+                }
+            }
+            const node = nodes[id];
+            if (!node || node.type !== 'window')
+                continue;
             const mesh = sceneRegistry.nodes.get(id);
             if (!mesh)
-                return; // Keep dirty until mesh mounts
-            updateWindowMesh(node, mesh);
+                continue; // Keep dirty until mesh mounts
+            // Merge any live override (width / height / position) so the mesh
+            // rebuild reflects the in-flight drag without zustand churn.
+            const effectiveNode = getEffectiveNode(node);
+            updateWindowMesh(effectiveNode, mesh);
             clearDirty(id);
+            rebuiltWindowsThisFrame += 1;
             // Rebuild the parent wall so its cutout reflects the updated window geometry
-            if (node.parentId) {
-                useScene.getState().dirtyNodes.add(node.parentId);
+            // Avoid triggering expensive wall CSG rebuilds while the window is being interactively moved/duplicated.
+            // The editor tools will request a final wall rebuild on commit.
+            const isTransient = !!node.metadata?.isTransient;
+            if (!isTransient && effectiveNode.parentId) {
+                useScene.getState().dirtyNodes.add(effectiveNode.parentId);
             }
-        });
+        }
     }, 3);
     return null;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/viewer",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "3D viewer component for Pascal building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,14 +22,13 @@
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^0.7.0",
+    "@pascal-app/core": "^0.9.1",
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
     "three": "^0.184"
   },
   "dependencies": {
-    "polygon-clipping": "^0.15.7",
     "three-bvh-csg": "^0.0.18",
     "three-mesh-bvh": "^0.9.8",
     "zustand": "^5"
@@ -39,7 +38,7 @@
     "@types/node": "^22",
     "@types/react": "^19.2.2",
     "@types/three": "^0.184.0",
-    "typescript": "6.0.2"
+    "typescript": "6.0.3"
   },
   "keywords": [
     "3d",

package/dist/components/renderers/building/building-renderer.d.ts

@@ -1,5 +0,0 @@
-import { type BuildingNode } from '@pascal-app/core';
-export declare const BuildingRenderer: ({ node }: {
-    node: BuildingNode;
-}) => import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=building-renderer.d.ts.map

package/dist/components/renderers/building/building-renderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"building-renderer.d.ts","sourceRoot":"","sources":["../../../../src/components/renderers/building/building-renderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAe,MAAM,kBAAkB,CAAA;AAMjE,eAAO,MAAM,gBAAgB,GAAI,UAAU;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,4CAkBhE,CAAA"}