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

package/dist/wall/system.js

@@ -1,39 +1,81 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
-import { WallCutout, WallSystem } from '@pascal-app/viewer';
+import { timeSpan, WallCutout, WallSystem } from '@pascal-app/viewer';
 import { useFrame } from '@react-three/fiber';
-import { buildWallTreatmentLevelData, useWallTreatmentLevelData } from './treatment-level-data';
+import { useEffect } from 'react';
+import { buildWallTreatmentLevelData, clearWallTreatmentMiterCache, sameTreatmentWalls, treatmentProudKeys, useWallTreatmentLevelData, } from './treatment-level-data';
 import { wallTreatmentProudOffsets } from './treatments';
+import { WallBatchSystem } from './wall-batch-system';
+const levelInputs = new Map();
+let effectiveWalls = new WeakMap();
+let previousNodes;
+let previousOverrides;
 function effectiveWall(wall) {
     const override = useLiveNodeOverrides.getState().get(wall.id);
-    return override ? { ...wall, ...override } : wall;
+    if (!override)
+        return wall;
+    const cached = effectiveWalls.get(wall);
+    if (cached?.override === override)
+        return cached.wall;
+    const effective = { ...wall, ...override };
+    effectiveWalls.set(wall, { override, wall: effective });
+    return effective;
 }
-const WallTreatmentMiterSystem = () => {
-    useFrame(() => {
-        const { dirtyNodes, nodes } = useScene.getState();
-        if (dirtyNodes.size === 0)
-            return;
-        const dirtyLevelIds = new Set();
-        for (const id of dirtyNodes) {
-            const node = nodes[id];
-            if (node?.type === 'wall' && node.parentId)
-                dirtyLevelIds.add(node.parentId);
+export function resetWallTreatmentLevels() {
+    levelInputs.clear();
+    effectiveWalls = new WeakMap();
+    previousNodes = undefined;
+    previousOverrides = undefined;
+    clearWallTreatmentMiterCache();
+    useWallTreatmentLevelData.setState({ byLevelId: new Map() });
+}
+export function updateWallTreatmentLevels() {
+    const { dirtyNodes, nodes } = useScene.getState();
+    const { overrides } = useLiveNodeOverrides.getState();
+    const dirtyLevelIds = new Set();
+    for (const id of dirtyNodes) {
+        const node = nodes[id];
+        if (node?.type === 'wall' && node.parentId)
+            dirtyLevelIds.add(node.parentId);
+        else if (node?.type === 'level')
+            dirtyLevelIds.add(node.id);
+    }
+    // Removed walls and cleared overrides can leave no dirty wall to identify their old level.
+    if (nodes !== previousNodes || overrides !== previousOverrides) {
+        for (const levelId of levelInputs.keys())
+            dirtyLevelIds.add(levelId);
+        previousNodes = nodes;
+        previousOverrides = overrides;
+    }
+    for (const levelId of dirtyLevelIds) {
+        const level = nodes[levelId];
+        if (level?.type !== 'level') {
+            levelInputs.delete(levelId);
+            clearWallTreatmentMiterCache(levelId);
+            useWallTreatmentLevelData.getState().removeLevelData(levelId);
+            continue;
         }
-        for (const levelId of dirtyLevelIds) {
-            const level = nodes[levelId];
-            if (level?.type !== 'level')
-                continue;
-            const walls = level.children
-                .map((id) => nodes[id])
-                .filter((node) => node?.type === 'wall')
-                .map(effectiveWall);
-            const proudOffsets = walls.flatMap(wallTreatmentProudOffsets);
+        const walls = level.children
+            .map((id) => nodes[id])
+            .filter((node) => node?.type === 'wall')
+            .map(effectiveWall);
+        const proudOffsets = walls.flatMap(wallTreatmentProudOffsets);
+        const proudKey = treatmentProudKeys(proudOffsets).join(',');
+        const previous = levelInputs.get(levelId);
+        if (previous?.proudKey === proudKey && sameTreatmentWalls(previous.walls, walls))
+            continue;
+        timeSpan('wall-treatment-level', () => {
             useWallTreatmentLevelData
                 .getState()
-                .setLevelData(levelId, buildWallTreatmentLevelData(walls, proudOffsets));
-        }
-    }, -1);
+                .setLevelData(levelId, buildWallTreatmentLevelData(levelId, walls, proudOffsets));
+            levelInputs.set(levelId, { walls, proudKey });
+        });
+    }
+}
+const WallTreatmentMiterSystem = () => {
+    useEffect(() => resetWallTreatmentLevels, []);
+    useFrame(updateWallTreatmentLevels, -1);
     return null;
 };
 /**
@@ -46,8 +88,11 @@ const WallTreatmentMiterSystem = () => {
  *    bulk of the wall runtime (~820 lines in viewer).
  *  - **`WallCutout`** — cutaway-mode hide/show logic based on camera
  *    direction and `frontSide` / `backSide` interior/exterior tags.
+ *  - **`WallBatchSystem`** — once a level stops changing, sews its opaque
+ *    walls into one mesh per material set so a floor costs a handful of
+ *    draw calls instead of one per wall face run.
  */
 const WallSystems = () => {
-    return (_jsxs(_Fragment, { children: [_jsx(WallTreatmentMiterSystem, {}), _jsx(WallSystem, {}), _jsx(WallCutout, {})] }));
+    return (_jsxs(_Fragment, { children: [_jsx(WallTreatmentMiterSystem, {}), _jsx(WallSystem, {}), _jsx(WallCutout, {}), _jsx(WallBatchSystem, {})] }));
 };
 export default WallSystems;

package/dist/wall/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AAgcA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EA+e5B,CAAA;AAED,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AA6bA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAuf5B,CAAA;AAED,eAAe,QAAQ,CAAA"}

package/dist/wall/tool.js

@@ -1,10 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { calculateLevelMiters, collectAlignmentAnchors, DEFAULT_LEVEL_HEIGHT, emitter, getWallMiterBoundaryPoints, resolveAlignment, resolveBuildingForLevel, sceneRegistry, useScene, wallClosesRoom, } from '@pascal-app/core';
+import { calculateLevelMiters, collectAlignmentAnchors, DEFAULT_LEVEL_HEIGHT, emitter, GROUND_SUPPORT_ID, getWallMiterBoundaryPoints, resolveAlignment, resolveBuildingForLevel, sceneRegistry, useScene, wallClosesRoom, } from '@pascal-app/core';
 import { CursorSphere, chainEndJoinsExistingWall, clearPlacementSurface, createWallOnCurrentLevel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolvePointerSupportSurface, snapWallDraftPointDetailed, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, useSegmentDraftChain, useWallSnapIndicator, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useRef, useState } from 'react';
-import { BoxGeometry, DoubleSide, Vector3 } from 'three';
+import { DoubleSide, Vector3 } from 'three';
 import { DraftAngleArc, DraftAxisGuides, DraftMeasurementLabel, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
 /**
  * Phase 5 Stage D — wall placement tool (kind-owned).
@@ -217,14 +217,14 @@ function getDraftAngleLabels(start, end, walls, baseY, previewHeight) {
     }
     return labels;
 }
-function getDraftMeasurementState(start, end, walls, unit, baseY, previewHeight) {
+function getDraftMeasurementState(start, end, walls, unit, metricNotation, baseY, previewHeight) {
     const dx = end[0] - start[0];
     const dz = end[1] - start[1];
     const length = Math.hypot(dx, dz);
     if (length < 0.01)
         return null;
     return {
-        lengthLabel: formatLinearMeasurement(length, unit),
+        lengthLabel: formatLinearMeasurement(length, unit, metricNotation),
         lengthPosition: [
             (start[0] + end[0]) / 2,
             baseY + previewHeight + DRAFT_LABEL_Y_OFFSET,
@@ -242,14 +242,10 @@ function updateWallPreview(mesh, start, end, previewHeight, previewThickness) {
     }
     mesh.visible = true;
     direction.normalize();
-    const geometry = new BoxGeometry(length, previewHeight, previewThickness);
     const angle = Math.atan2(direction.z, direction.x);
     mesh.position.set((start.x + end.x) / 2, start.y + previewHeight / 2, (start.z + end.z) / 2);
     mesh.rotation.y = -angle;
-    if (mesh.geometry) {
-        mesh.geometry.dispose();
-    }
-    mesh.geometry = geometry;
+    mesh.scale.set(length, previewHeight, previewThickness);
 }
 function getLevelWalls(levelId, nodes) {
     if (!levelId)
@@ -295,6 +291,7 @@ function getBelowLevelWalls() {
 }
 export const WallTool = () => {
     const unit = useViewer((state) => state.unit);
+    const metricNotation = useViewer((state) => state.metricNotation);
     const isDark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark');
     const activeLevelId = useViewer((state) => state.selection.levelId);
     const activeLevelHeight = useScene((state) => {
@@ -328,6 +325,7 @@ export const WallTool = () => {
     // snapping onto the chain's own segments never reads as a join.
     const chainWallIds = useRef([]);
     const constructionPlane = useRef(null);
+    const flatConstructionBase = useRef(false);
     const buildingState = useRef(0);
     const [draftMeasurement, setDraftMeasurement] = useState(null);
     const [axisGuide, setAxisGuide] = useState(null);
@@ -435,6 +433,7 @@ export const WallTool = () => {
         const stopDrafting = () => {
             buildingState.current = 0;
             constructionPlane.current = null;
+            flatConstructionBase.current = false;
             chainFirstVertex.current = null;
             chainWallIds.current = [];
             const draftPreview = useFloorplanDraftPreview.getState();
@@ -512,7 +511,7 @@ export const WallTool = () => {
                 }
                 previousWallEnd = currentWallEnd;
                 updateWallPreview(wallPreviewRef.current, startingPoint.current, endingPoint.current, previewHeightRef.current, previewThicknessRef.current);
-                setDraftMeasurement(getDraftMeasurementState([startingPoint.current.x, startingPoint.current.z], snappedLocal, walls, unit, startingPoint.current.y, previewHeightRef.current));
+                setDraftMeasurement(getDraftMeasurementState([startingPoint.current.x, startingPoint.current.z], snappedLocal, walls, unit, metricNotation, startingPoint.current.y, previewHeightRef.current));
             }
             else {
                 const hoverPlane = resampleTerrainConstructionPlane(resolveEventConstructionPlane(event, pointed), gridPosition);
@@ -548,6 +547,7 @@ export const WallTool = () => {
                         : null) ?? resolveEventConstructionPlane(event, pointed);
                 const plane = resampleTerrainConstructionPlane(resolvedPlane, snappedStart);
                 constructionPlane.current = plane;
+                flatConstructionBase.current = pointed?.sourceNodeId != null;
                 publishHorizontalConstructionPlane(event, plane);
                 gridPosition = snappedStart;
                 startingPoint.current.set(snappedStart[0], plane.localY, snappedStart[1]);
@@ -564,13 +564,9 @@ export const WallTool = () => {
                     angleLabel: null,
                 });
                 triggerSFX('sfx:structure-build-start');
-                // Visibility is owned by `updateWallPreview` — it flips
-                // `mesh.visible` based on segment length. Setting it here
-                // (before any geometry data has been written) draws the
-                // mesh's empty `<shapeGeometry/>` placeholder, which WebGPU
-                // flags as "Vertex buffer slot 0 ... was not set" on the
-                // first frame after click. Leaving it false until the next
-                // `onGridMove` writes a real BoxGeometry skips that frame.
+                // Visibility is owned by `updateWallPreview`. Leave the
+                // unit box hidden until the first pointer move scales and
+                // positions it for the active segment.
                 setDraftMeasurement(null);
             }
             else if (buildingState.current === 1) {
@@ -586,12 +582,20 @@ export const WallTool = () => {
                 const dz = snappedEnd[1] - startingPoint.current.z;
                 if (dx * dx + dz * dz < 0.01 * 0.01)
                     return;
+                // A ground(terrain)-hosted chain keeps its frozen construction plane;
+                // any other chain re-resolves the aimed surface per commit so a later
+                // segment can still elect the slab it visibly crosses instead of
+                // being capped at the first click's elevation.
+                const draftPlane = constructionPlane.current;
+                const commitPointed = draftPlane?.supportSlabId === GROUND_SUPPORT_ID ? null : pointedSurfaceFor(event);
                 // Both start and end are building-local ✓
                 const createdWall = createWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd, {
-                    supportCap: constructionPlane.current?.elevation ?? null,
-                    preferredSupportSlabId: constructionPlane.current?.supportSlabId ?? null,
-                    constructionElevation: constructionPlane.current?.elevation ?? null,
+                    supportCap: commitPointed ? commitPointed.elevation : (draftPlane?.elevation ?? null),
+                    preferredSupportSlabId: draftPlane?.supportSlabId ?? null,
+                    constructionElevation: draftPlane?.elevation ?? null,
                     constructionHeight: previewHeightRef.current,
+                    constructionSourceNodeId: constructionPlane.current?.sourceNodeId ?? null,
+                    flatConstructionBase: flatConstructionBase.current,
                 });
                 if (!createdWall)
                     return;
@@ -642,11 +646,9 @@ export const WallTool = () => {
                     y: draftY,
                     angleLabel: null,
                 });
-                // Hide the preview until the next `onGridMove` writes the
-                // new segment's geometry. Without this the prior segment's
-                // BoxGeometry stays visible for a frame on top of the
-                // freshly-committed real wall, producing a brief
-                // double-paint at the new wall's position.
+                // Hide the preview until the next `onGridMove` scales and
+                // repositions it. Otherwise the prior segment stays visible
+                // for a frame on top of the freshly committed wall.
                 if (wallPreviewRef.current) {
                     wallPreviewRef.current.visible = false;
                 }
@@ -674,7 +676,7 @@ export const WallTool = () => {
             draftPreview.setWallDraftStart(null);
             draftPreview.setWallDraftEnd(null);
         };
-    }, [unit]);
-    return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsxs("mesh", { layers: EDITOR_LAYER, ref: wallPreviewRef, renderOrder: 1, visible: false, children: [_jsx("shapeGeometry", {}), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.5, side: DoubleSide, transparent: true })] }), draftMeasurement && (_jsxs(_Fragment, { children: [_jsx(DraftMeasurementLabel, { color: measurementColor, label: draftMeasurement.lengthLabel, position: draftMeasurement.lengthPosition, shadowColor: measurementShadowColor }), draftMeasurement.angleLabels.map((angleLabel) => (_jsxs("group", { children: [_jsx(DraftAngleArc, { arc: angleLabel.arc, color: measurementColor }), _jsx(DraftMeasurementLabel, { color: measurementColor, label: angleLabel.label, position: angleLabel.position, shadowColor: measurementShadowColor })] }, angleLabel.id)))] }))] }));
+    }, [unit, metricNotation]);
+    return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsxs("mesh", { layers: EDITOR_LAYER, ref: wallPreviewRef, renderOrder: 1, visible: false, children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.5, side: DoubleSide, transparent: true })] }), draftMeasurement && (_jsxs(_Fragment, { children: [_jsx(DraftMeasurementLabel, { color: measurementColor, label: draftMeasurement.lengthLabel, position: draftMeasurement.lengthPosition, shadowColor: measurementShadowColor }), draftMeasurement.angleLabels.map((angleLabel) => (_jsxs("group", { children: [_jsx(DraftAngleArc, { arc: angleLabel.arc, color: measurementColor }), _jsx(DraftMeasurementLabel, { color: measurementColor, label: angleLabel.label, position: angleLabel.position, shadowColor: measurementShadowColor })] }, angleLabel.id)))] }))] }));
 };
 export default WallTool;

package/dist/wall/treatment-level-data.d.ts

@@ -1,14 +1,19 @@
 import { type WallMiterData, type WallNode } from '@pascal-app/core';
+export declare function treatmentProudKeys(proudOffsets: readonly number[]): number[];
+export declare function sameTreatmentWalls(a: readonly WallNode[], b: readonly WallNode[]): boolean;
 export type WallTreatmentLevelData = {
     walls: readonly WallNode[];
     miterDataByProud: ReadonlyMap<number, WallMiterData>;
 };
-export declare function buildWallTreatmentLevelData(walls: readonly WallNode[], proudOffsets: readonly number[]): WallTreatmentLevelData;
+export declare function clearWallTreatmentMiterCache(levelId?: string): void;
+export declare function buildWallTreatmentLevelData(levelId: string, walls: readonly WallNode[], proudOffsets: readonly number[]): WallTreatmentLevelData;
 export declare function treatmentMiterDataForProud(levelData: WallTreatmentLevelData, proud: number): WallMiterData | undefined;
 type WallTreatmentLevelDataState = {
     byLevelId: ReadonlyMap<string, WallTreatmentLevelData>;
     setLevelData: (levelId: string, data: WallTreatmentLevelData) => void;
+    removeLevelData: (levelId: string) => void;
 };
+export declare function createWallTreatmentSelector(node: WallNode, proudOffsets: readonly number[]): (state: WallTreatmentLevelDataState) => WallTreatmentLevelData | undefined;
 export declare const useWallTreatmentLevelData: import("zustand").UseBoundStore<import("zustand").StoreApi<WallTreatmentLevelDataState>>;
 export {};
 //# sourceMappingURL=treatment-level-data.d.ts.map

package/dist/wall/treatment-level-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treatment-level-data.d.ts","sourceRoot":"","sources":["../../src/wall/treatment-level-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AASzB,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC1B,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CACrD,CAAA;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,sBAAsB,CAgBxB;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,MAAM,GACZ,aAAa,GAAG,SAAS,CAE3B;AAED,KAAK,2BAA2B,GAAG;IACjC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;IACtD,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,sBAAsB,KAAK,IAAI,CAAA;CACtE,CAAA;AAED,eAAO,MAAM,yBAAyB,0FAQnC,CAAA"}
+{"version":3,"file":"treatment-level-data.d.ts","sourceRoot":"","sources":["../../src/wall/treatment-level-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAUzB,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAE5E;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS,QAAQ,EAAE,EAAE,CAAC,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAE1F;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC1B,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CACrD,CAAA;AAID,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAGnE;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,sBAAsB,CAwBxB;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,MAAM,GACZ,aAAa,GAAG,SAAS,CAE3B;AAED,KAAK,2BAA2B,GAAG;IACjC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;IACtD,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,sBAAsB,KAAK,IAAI,CAAA;IACrE,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3C,CAAA;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,SAAS,MAAM,EAAE,IASjF,OAAO,2BAA2B,KAAG,sBAAsB,GAAG,SAAS,CAqChF;AAED,eAAO,MAAM,yBAAyB,0FAenC,CAAA"}

package/dist/wall/treatment-level-data.js

@@ -1,13 +1,33 @@
-import { calculateLevelMiters, getWallThickness, } from '@pascal-app/core';
+import { calculateLevelMiters, getWallThickness, isCurvedWall, pointToKey, } from '@pascal-app/core';
 import { create } from 'zustand';
+import { shallow } from 'zustand/vanilla/shallow';
 const PROUD_KEY_PRECISION = 1e6;
 function proudKey(proud) {
     return Math.round(proud * PROUD_KEY_PRECISION) / PROUD_KEY_PRECISION;
 }
-export function buildWallTreatmentLevelData(walls, proudOffsets) {
-    const uniqueProudOffsets = new Set([0, ...proudOffsets.map(proudKey)]);
+export function treatmentProudKeys(proudOffsets) {
+    return [...new Set([0, ...proudOffsets.map(proudKey)])].sort((a, b) => a - b);
+}
+export function sameTreatmentWalls(a, b) {
+    return a.length === b.length && a.every((wall, index) => wall === b[index]);
+}
+const levelMiterCache = new Map();
+export function clearWallTreatmentMiterCache(levelId) {
+    if (levelId === undefined)
+        levelMiterCache.clear();
+    else
+        levelMiterCache.delete(levelId);
+}
+export function buildWallTreatmentLevelData(levelId, walls, proudOffsets) {
+    const cached = levelMiterCache.get(levelId);
+    const reusable = cached && sameTreatmentWalls(cached.walls, walls) ? cached : undefined;
     const miterDataByProud = new Map();
-    for (const proud of uniqueProudOffsets) {
+    for (const proud of treatmentProudKeys(proudOffsets)) {
+        const previous = reusable?.miterDataByProud.get(proud);
+        if (previous) {
+            miterDataByProud.set(proud, previous);
+            continue;
+        }
         const adjustedWalls = proud === 0
             ? [...walls]
             : walls.map((wall) => ({
@@ -16,11 +36,61 @@ export function buildWallTreatmentLevelData(walls, proudOffsets) {
             }));
         miterDataByProud.set(proud, calculateLevelMiters(adjustedWalls));
     }
-    return { walls, miterDataByProud };
+    const data = { walls, miterDataByProud };
+    levelMiterCache.set(levelId, data);
+    return data;
 }
 export function treatmentMiterDataForProud(levelData, proud) {
     return levelData.miterDataByProud.get(proudKey(proud));
 }
+export function createWallTreatmentSelector(node, proudOffsets) {
+    const keys = isCurvedWall(node)
+        ? []
+        : [...new Set([node.start, node.end].map(([x, y]) => pointToKey({ x, y })))];
+    const prouds = treatmentProudKeys(proudOffsets);
+    let previousLevel;
+    let previousSlice;
+    let previousInputs = [];
+    return (state) => {
+        const level = node.parentId ? state.byLevelId.get(node.parentId) : undefined;
+        if (level === previousLevel)
+            return previousSlice;
+        previousLevel = level;
+        if (!level) {
+            previousSlice = undefined;
+            previousInputs = [];
+            return undefined;
+        }
+        const inputs = [];
+        for (const proud of prouds) {
+            const data = level.miterDataByProud.get(proud);
+            inputs.push(!!data);
+            for (const key of keys) {
+                const entry = data?.junctionData.get(key)?.get(node.id);
+                inputs.push(entry?.left?.x, entry?.left?.y, entry?.right?.x, entry?.right?.y);
+            }
+        }
+        if (previousSlice && shallow(previousInputs, inputs))
+            return previousSlice;
+        const miterDataByProud = new Map();
+        for (const proud of prouds) {
+            const data = level.miterDataByProud.get(proud);
+            if (!data)
+                continue;
+            const junctionData = new Map();
+            for (const key of keys) {
+                const entry = data.junctionData.get(key)?.get(node.id);
+                if (entry)
+                    junctionData.set(key, new Map([[node.id, entry]]));
+            }
+            // Trim boundaries read only this wall's endpoint intersections, never junction membership.
+            miterDataByProud.set(proud, { junctionData, junctions: new Map() });
+        }
+        previousInputs = inputs;
+        previousSlice = { walls: [node], miterDataByProud };
+        return previousSlice;
+    };
+}
 export const useWallTreatmentLevelData = create((set) => ({
     byLevelId: new Map(),
     setLevelData: (levelId, data) => set((state) => {
@@ -28,4 +98,11 @@ export const useWallTreatmentLevelData = create((set) => ({
         byLevelId.set(levelId, data);
         return { byLevelId };
     }),
+    removeLevelData: (levelId) => set((state) => {
+        if (!state.byLevelId.has(levelId))
+            return state;
+        const byLevelId = new Map(state.byLevelId);
+        byLevelId.delete(levelId);
+        return { byLevelId };
+    }),
 }));

package/dist/wall/treatments.d.ts

@@ -12,6 +12,7 @@ type TrimKind = 'skirting' | 'crown' | 'chairRail';
 type WallSide = 'interior' | 'exterior';
 type SceneMaterials = Record<SceneMaterialId, SceneMaterial>;
 type WallTreatmentSlotId = 'skirtingInterior' | 'skirtingExterior' | 'crownInterior' | 'crownExterior' | 'chairRailInterior' | 'chairRailExterior';
+export declare function hasWallTreatments(node: WallNode): boolean;
 export declare function wallTreatmentProudOffsets(node: WallNode): number[];
 export declare function buildTrimGeometry(node: WallNode, side: WallSide, trim: WallTrimConfig, kind: TrimKind, childrenNodes: OpeningLike[], levelData: WallTreatmentLevelData): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | null;
 export declare function createWallExtraSlotMaterials(node: WallNode, shading: RenderShading, sceneMaterials: SceneMaterials): {

package/dist/wall/treatments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,eAAe,EAMpB,KAAK,QAAQ,EAEb,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,EAA8B,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAMhG,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC,CAAA;AAED,KAAK,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,CAAA;AAClD,KAAK,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAA;AACvC,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAE5D,KAAK,mBAAmB,GACpB,kBAAkB,GAClB,kBAAkB,GAClB,eAAe,GACf,eAAe,GACf,mBAAmB,GACnB,mBAAmB,CAAA;AAmNvB,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAoBlE;AAuND,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,WAAW,EAAE,EAC5B,SAAS,EAAE,sBAAsB,2FAsDlC;AAkBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,cAAc;;;;;;;EAU/B;AAED,eAAO,MAAM,cAAc,uFAKxB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,EAAE,WAAW,EAAE,CAAA;IAC5B,SAAS,EAAE,sBAAsB,CAAA;IACjC,SAAS,EAAE,MAAM,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CACvD,iCAmEC,CAAA"}
+{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,eAAe,EAMpB,KAAK,QAAQ,EAEb,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,EAA8B,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAMhG,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC,CAAA;AAED,KAAK,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,CAAA;AAClD,KAAK,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAA;AACvC,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAE5D,KAAK,mBAAmB,GACpB,kBAAkB,GAClB,kBAAkB,GAClB,eAAe,GACf,eAAe,GACf,mBAAmB,GACnB,mBAAmB,CAAA;AAmNvB,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAMzD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAoBlE;AAuND,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,WAAW,EAAE,EAC5B,SAAS,EAAE,sBAAsB,2FAsDlC;AAkBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,cAAc;;;;;;;EAU/B;AAED,eAAO,MAAM,cAAc,uFAKxB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,EAAE,WAAW,EAAE,CAAA;IAC5B,SAAS,EAAE,sBAAsB,CAAA;IACjC,SAAS,EAAE,MAAM,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CACvD,iCAmEC,CAAA"}

package/dist/wall/treatments.js

@@ -221,6 +221,11 @@ function resolveTrimProfile(kind, trim) {
         TRIM_PROFILES[kind][defaultProfile] ??
         TRIM_PROFILES[kind].flat);
 }
+export function hasWallTreatments(node) {
+    return !!((node.skirting?.enabled ?? WALL_SKIRTING_DEFAULT.enabled) ||
+        (node.crown?.enabled ?? WALL_CROWN_DEFAULT.enabled) ||
+        (node.chairRail?.enabled ?? WALL_CHAIR_RAIL_DEFAULT.enabled));
+}
 export function wallTreatmentProudOffsets(node) {
     const offsets = new Set();
     const configs = [

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

@@ -0,0 +1,55 @@
+import { type WallMode } from '@pascal-app/viewer';
+import { type Material, Mesh } from 'three';
+export declare function revealBatchedWallsForCapture(): void;
+export declare function holdBatchedWallsAfterCapture(): void;
+export type WallBatchCandidate = {
+    nodeId: string;
+    mesh: Mesh;
+    materials: Material[];
+};
+/**
+ * Whether a level's walls may be merged at all right now.
+ *
+ * The merged mesh captures one material set when it is sewn and nothing
+ * re-reads it, so batching is only sound while every batched wall's materials
+ * hold still. That is true in `up`; in `cutaway`, walls stamped `wallHidden`
+ * are released per wall in the same frame because WallCutout runs at priority
+ * 0 and this system at 5. `down` and `translucent` make every wall see-through.
+ * Isolation is the other stand-down: it hides the level root the merged mesh
+ * hangs off, which would leave a focused batched wall drawn by nobody.
+ */
+export declare function canBatchWalls(wallMode: WallMode, isolationActive: boolean): boolean;
+/**
+ * Walls the viewer is currently lighting up — a selection, or any hover.
+ *
+ * A selection or delete hover paints the wall by swapping the materials on its
+ * own mesh, which the merged mesh does not follow. Every other hover draws an
+ * outline instead, and that needs the same thing for a different reason: the
+ * outline node renders `outliner.hoveredObjects` through the main camera, which
+ * enables no batched layer, so a sewn wall reaches neither mask pass and
+ * hovering it lights up nothing at all — in select mode, and in paint mode
+ * where the outline is the only signal for which surface the next click lands
+ * on.
+ *
+ * Both wants are the same one: a lit wall goes back to drawing its own
+ * geometry. Only ever a handful are lit at once, and a handful of extra draw
+ * calls is what lighting them costs.
+ */
+export declare function collectTintedWalls(wallIds: ReadonlySet<string>): Set<string>;
+export declare function collectWallBatchCandidates(levelId: string, excludedNodeIds?: ReadonlySet<string>): Map<string, WallBatchCandidate[]>;
+export declare const WallBatchSystem: () => null;
+/**
+ * Follows the scene's dirty tracking rather than watching the walls itself.
+ *
+ * A wall changes for exactly one reason the merged mesh cares about: the wall
+ * system rebuilt its geometry. That system already runs off `dirtyNodes`, so
+ * this reads the same signal from both ends — the marks still standing when
+ * this frame reaches us, and the rebuild notices the wall system left behind
+ * for the walls whose marks it has already cleared. Nothing here re-derives
+ * "did this wall move" on its own, and the per-frame cost is the size of the
+ * dirty set rather than the size of the floor.
+ */
+export declare function runBatchFrame(invalidate: () => void, wakeRef: {
+    current: ReturnType<typeof setTimeout> | null;
+}): void;
+//# sourceMappingURL=wall-batch-system.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-batch-system.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch-system.tsx"],"names":[],"mappings":"AAGA,OAAO,EAML,KAAK,QAAQ,EACd,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EAAE,KAAK,QAAQ,EAAW,IAAI,EAAiB,MAAM,OAAO,CAAA;AAkGnE,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED,wBAAgB,4BAA4B,IAAI,IAAI,CAKnD;AA6BD,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAA;AA+BtF;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,OAAO,GAAG,OAAO,CAEnF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAW5E;AAMD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,eAAe,GAAE,WAAW,CAAC,MAAM,CAAa,GAC/C,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAoBnC;AAsFD,eAAO,MAAM,eAAe,YAmE3B,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,IAAI,EACtB,OAAO,EAAE;IAAE,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAA;CAAE,QAyI3D"}