@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/wall/tool.js

@@ -1,11 +1,12 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 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 { addWallPolygonDraftCorner, CursorSphere, chainEndJoinsExistingWall, clearPlacementSurface, commitWallPolygonDraft, createWallOnCurrentLevel, DraftMeasurementLabel, discardWallPolygonDraft, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getWallDrawVariant, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolvePointerSupportSurface, snapWallDraftPointDetailed, startWallPolygonDraft, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, useSegmentDraftChain, useWallDrawVariant, useWallSnapIndicator, visibleScene, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, wallPolygonDraftWalls, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useRef, useState } from 'react';
 import { DoubleSide, Vector3 } from 'three';
-import { DraftAngleArc, DraftAxisGuides, DraftMeasurementLabel, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
+import { DraftAngleArc, DraftAxisGuides, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
+import RectangleWallTool from './rectangle-tool';
 /**
  * Phase 5 Stage D — wall placement tool (kind-owned).
  *
@@ -289,7 +290,7 @@ function getBelowLevelWalls() {
         .sort((a, b) => b.level - a.level)[0];
     return getLevelWalls(belowLevel?.id ?? null, nodes);
 }
-export const WallTool = () => {
+const LineWallTool = () => {
     const unit = useViewer((state) => state.unit);
     const metricNotation = useViewer((state) => state.metricNotation);
     const isDark = useViewer((state) => getSceneTheme(state.sceneTheme).appearance === 'dark');
@@ -328,12 +329,11 @@ export const WallTool = () => {
     const flatConstructionBase = useRef(false);
     const buildingState = useRef(0);
     const [draftMeasurement, setDraftMeasurement] = useState(null);
+    // Base Y of an open Polygon room's ghost sides (its construction plane).
+    const [polygonGhostY, setPolygonGhostY] = useState(0);
     const [axisGuide, setAxisGuide] = useState(null);
     const measurementColor = isDark ? '#ffffff' : '#111111';
     const measurementShadowColor = isDark ? '#111111' : '#ffffff';
-    // Clear preset-seeded defaults on deactivation so a later manual wall draw
-    // isn't built with a stale preset's parameters. Unmount-only.
-    useEffect(() => () => useEditor.getState().setToolDefaults('wall', null), []);
     useEffect(() => {
         let gridPosition = [0, 0];
         let previousWallEnd = null;
@@ -382,6 +382,7 @@ export const WallTool = () => {
         const pointedSurfaceFor = (event) => event.nativeEvent?.target instanceof HTMLCanvasElement
             ? resolvePointerSupportSurface(cameraRef.current, event.position, {
                 includeNodeTopSurfaces: true,
+                pointerRay: event.nativeEvent.ray,
             })
             : null;
         const snappedWallConstructionPlane = (targetWallIds, walls) => {
@@ -430,7 +431,10 @@ export const WallTool = () => {
             }
             return resolved;
         };
+        // Stopping without committing drops an open Polygon room — its corners
+        // were never written. Completing paths commit before they stop.
         const stopDrafting = () => {
+            discardWallPolygonDraft();
             buildingState.current = 0;
             constructionPlane.current = null;
             flatConstructionBase.current = false;
@@ -449,8 +453,12 @@ export const WallTool = () => {
             useSegmentDraftChain.getState().clear('wall');
             clearPlacementSurface();
         };
+        // In 2D-only view the plan owns wall drafting; this tool stays mounted
+        // behind the hidden canvas and still hears the plan's grid events, so it
+        // must not also draft (it would add every corner twice).
+        const planOwnsInput = () => visibleScene(useEditor.getState()) === '2d';
         const onGridMove = (event) => {
-            if (!(cursorRef.current && wallPreviewRef.current))
+            if (!(cursorRef.current && wallPreviewRef.current) || planOwnsInput())
                 return;
             // Ride the grid event plane on the pointed surface: aiming at an
             // elevated deck lifts the plane to the deck top, so the draft's XZ
@@ -468,7 +476,7 @@ export const WallTool = () => {
             // Add walls on the floor below as extra snap references so the new wall
             // can align with the level beneath it. Kept separate from `walls` so the
             // measurement HUD only reports against the active level.
-            const snapWalls = [...walls, ...getBelowLevelWalls()];
+            const snapWalls = [...walls, ...getBelowLevelWalls(), ...wallPolygonDraftWalls()];
             const localPoint = pointed?.localPoint
                 ? [pointed.localPoint[0], pointed.localPoint[2]]
                 : [event.localPosition[0], event.localPosition[2]];
@@ -521,14 +529,16 @@ export const WallTool = () => {
             }
         };
         const onGridClick = (event) => {
-            if (!wallPreviewRef.current)
+            if (!wallPreviewRef.current || planOwnsInput())
                 return;
             if (buildingState.current === 1 && event.nativeEvent.detail >= 2) {
+                // A double-click finishes the chain and keeps an open Polygon room.
+                commitWallPolygonDraft();
                 stopDrafting();
                 return;
             }
             const walls = getCurrentLevelWalls();
-            const snapWalls = [...walls, ...getBelowLevelWalls()];
+            const snapWalls = [...walls, ...getBelowLevelWalls(), ...wallPolygonDraftWalls()];
             const pointed = buildingState.current === 0 ? pointedSurfaceFor(event) : null;
             const localClick = pointed?.localPoint
                 ? [pointed.localPoint[0], pointed.localPoint[2]]
@@ -564,6 +574,18 @@ export const WallTool = () => {
                     angleLabel: null,
                 });
                 triggerSFX('sfx:structure-build-start');
+                const levelId = useViewer.getState().selection.levelId;
+                if (getWallDrawVariant() === 'polygon' && levelId) {
+                    startWallPolygonDraft(levelId, snappedStart, {
+                        supportCap: plane.elevation ?? null,
+                        preferredSupportSlabId: plane.supportSlabId ?? null,
+                        constructionElevation: plane.elevation ?? null,
+                        constructionHeight: previewHeightRef.current,
+                        constructionSourceNodeId: plane.sourceNodeId ?? null,
+                        flatConstructionBase: flatConstructionBase.current,
+                    });
+                    setPolygonGhostY(plane.localY);
+                }
                 // Visibility is owned by `updateWallPreview`. Leave the
                 // unit box hidden until the first pointer move scales and
                 // positions it for the active segment.
@@ -586,47 +608,63 @@ export const WallTool = () => {
                 // 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: 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;
-                chainWallIds.current.push(createdWall.id);
-                // The new segment is now a real node — make it an alignment target
-                // for the next segment, and drop the just-shown guide.
-                refreshAlignmentCandidates();
-                useAlignmentGuides.getState().clear();
-                useWallSnapIndicator.getState().clear();
-                if (useEditor.getState().getContinuation('wall') === 'single') {
-                    stopDrafting();
-                    return;
+                let nextStart;
+                if (getWallDrawVariant() === 'polygon') {
+                    // A Polygon room writes nothing until it completes: the corner joins
+                    // the draft, and closing / sealing / teeing commits every wall at once.
+                    const outcome = addWallPolygonDraftCorner(snappedEnd);
+                    useAlignmentGuides.getState().clear();
+                    useWallSnapIndicator.getState().clear();
+                    if (outcome !== 'open') {
+                        commitWallPolygonDraft();
+                        stopDrafting();
+                        return;
+                    }
+                    nextStart = snappedEnd;
                 }
-                const closedToChainStart = chainFirstVertex.current &&
-                    isWithinWallJoinSnapRadius(createdWall.end, chainFirstVertex.current);
-                // Auto-close also fires when the segment seals a room against the
-                // existing wall network (e.g. a bay closed onto the middle of another
-                // wall), not just when the chain loops back to its own start. Shares the
-                // room graph with auto slab/ceiling detection so the two never disagree.
-                // A resolved end that tees into wall geometry outside the chain also
-                // terminates even without an enclosed room — nobody continues drawing
-                // from a T-junction into an existing wall; a dead end in free space
-                // keeps the chain going.
-                const levelWalls = getCurrentLevelWalls();
-                if (closedToChainStart ||
-                    chainEndJoinsExistingWall(createdWall.end, levelWalls, chainWallIds.current) ||
-                    wallClosesRoom(levelWalls, createdWall)) {
-                    stopDrafting();
-                    return;
+                else {
+                    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: 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;
+                    chainWallIds.current.push(createdWall.id);
+                    // The new segment is now a real node — make it an alignment target
+                    // for the next segment, and drop the just-shown guide.
+                    refreshAlignmentCandidates();
+                    useAlignmentGuides.getState().clear();
+                    useWallSnapIndicator.getState().clear();
+                    if (useEditor.getState().getContinuation('wall') === 'single') {
+                        stopDrafting();
+                        return;
+                    }
+                    const closedToChainStart = chainFirstVertex.current &&
+                        isWithinWallJoinSnapRadius(createdWall.end, chainFirstVertex.current);
+                    // Auto-close also fires when the segment seals a room against the
+                    // existing wall network (e.g. a bay closed onto the middle of another
+                    // wall), not just when the chain loops back to its own start. Shares the
+                    // room graph with auto slab/ceiling detection so the two never disagree.
+                    // A resolved end that tees into wall geometry outside the chain also
+                    // terminates even without an enclosed room — nobody continues drawing
+                    // from a T-junction into an existing wall; a dead end in free space
+                    // keeps the chain going.
+                    const levelWalls = getCurrentLevelWalls();
+                    if (closedToChainStart ||
+                        chainEndJoinsExistingWall(createdWall.end, levelWalls, chainWallIds.current) ||
+                        wallClosesRoom(levelWalls, createdWall)) {
+                        stopDrafting();
+                        return;
+                    }
+                    nextStart = createdWall.end;
                 }
-                const nextStart = createdWall.end;
                 // Publish the resolved chain start so the 2D floor-plan draft
                 // chains its next segment from the same point (its own snap
                 // pipeline can resolve a slightly different endpoint).
@@ -665,6 +703,8 @@ export const WallTool = () => {
         emitter.on('grid:click', onGridClick);
         emitter.on('tool:cancel', onCancel);
         return () => {
+            // Leaving the tool mid-polygon abandons it (nothing was written).
+            discardWallPolygonDraft();
             emitter.off('grid:move', onGridMove);
             emitter.off('grid:click', onGridClick);
             emitter.off('tool:cancel', onCancel);
@@ -677,6 +717,30 @@ export const WallTool = () => {
             draftPreview.setWallDraftEnd(null);
         };
     }, [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)))] }))] }));
+    return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsx(PolygonDraftGhosts, { height: previewHeight, thickness: previewThickness, y: polygonGhostY }), _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)))] }))] }));
+};
+/**
+ * The placed sides of an open Polygon room, drawn like the live segment's
+ * preview. They are draft state (`wallPolygonDraftPoints`), not scene walls.
+ */
+function PolygonDraftGhosts({ height, thickness, y, }) {
+    const corners = useFloorplanDraftPreview((state) => state.wallPolygonDraftPoints);
+    return (_jsx(_Fragment, { children: corners.slice(1).map((end, index) => {
+            const start = corners[index];
+            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 (_jsxs("mesh", { layers: EDITOR_LAYER, position: [(start[0] + end[0]) / 2, y + height / 2, (start[1] + end[1]) / 2], renderOrder: 1, rotation: [0, -Math.atan2(dz, dx), 0], scale: [length, height, thickness], children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.5, side: DoubleSide, transparent: true })] }, `${index}:${start[0]},${start[1]}`));
+        }) }));
+}
+export const WallTool = () => {
+    // Clear preset-seeded defaults on deactivation so a later manual wall draw
+    // isn't built with a stale preset's parameters. Unmount-only.
+    useEffect(() => () => useEditor.getState().setToolDefaults('wall', null), []);
+    // The drawing variant is picked in the Build panel's Rooms group.
+    const variant = useWallDrawVariant();
+    return variant === 'rectangle' ? _jsx(RectangleWallTool, {}) : _jsx(LineWallTool, {});
 };
 export default WallTool;

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

@@ -1,12 +1,13 @@
-import { type WallMiterData, type WallNode } from '@pascal-app/core';
+import { type WallMiterData, type WallNode, type WallSlabSupport } 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[];
+    supports?: ReadonlyMap<string, WallSlabSupport>;
     miterDataByProud: ReadonlyMap<number, WallMiterData>;
 };
 export declare function clearWallTreatmentMiterCache(levelId?: string): void;
-export declare function buildWallTreatmentLevelData(levelId: string, walls: readonly WallNode[], proudOffsets: readonly number[]): WallTreatmentLevelData;
+export declare function buildWallTreatmentLevelData(levelId: string, walls: readonly WallNode[], proudOffsets: readonly number[], supports?: ReadonlyMap<string, WallSlabSupport>): WallTreatmentLevelData;
 export declare function treatmentMiterDataForProud(levelData: WallTreatmentLevelData, proud: number): WallMiterData | undefined;
 type WallTreatmentLevelDataState = {
     byLevelId: ReadonlyMap<string, WallTreatmentLevelData>;

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,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"}
+{"version":3,"file":"treatment-level-data.d.ts","sourceRoot":"","sources":["../../src/wall/treatment-level-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,eAAe,EACrB,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,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAC/C,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,EAC/B,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,GAC9C,sBAAsB,CAiBxB;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,CA+ChF;AAED,eAAO,MAAM,yBAAyB,0FAenC,CAAA"}

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

@@ -1,4 +1,4 @@
-import { calculateLevelMiters, getWallThickness, isCurvedWall, pointToKey, } from '@pascal-app/core';
+import { calculateLevelMiters, isCurvedWall, pointToKey, } from '@pascal-app/core';
 import { create } from 'zustand';
 import { shallow } from 'zustand/vanilla/shallow';
 const PROUD_KEY_PRECISION = 1e6;
@@ -18,7 +18,7 @@ export function clearWallTreatmentMiterCache(levelId) {
     else
         levelMiterCache.delete(levelId);
 }
-export function buildWallTreatmentLevelData(levelId, walls, proudOffsets) {
+export function buildWallTreatmentLevelData(levelId, walls, proudOffsets, supports) {
     const cached = levelMiterCache.get(levelId);
     const reusable = cached && sameTreatmentWalls(cached.walls, walls) ? cached : undefined;
     const miterDataByProud = new Map();
@@ -28,15 +28,9 @@ export function buildWallTreatmentLevelData(levelId, walls, proudOffsets) {
             miterDataByProud.set(proud, previous);
             continue;
         }
-        const adjustedWalls = proud === 0
-            ? [...walls]
-            : walls.map((wall) => ({
-                ...wall,
-                thickness: getWallThickness(wall) + proud * 2,
-            }));
-        miterDataByProud.set(proud, calculateLevelMiters(adjustedWalls));
+        miterDataByProud.set(proud, calculateLevelMiters([...walls], proud));
     }
-    const data = { walls, miterDataByProud };
+    const data = { walls, miterDataByProud, supports };
     levelMiterCache.set(levelId, data);
     return data;
 }
@@ -59,9 +53,15 @@ export function createWallTreatmentSelector(node, proudOffsets) {
         if (!level) {
             previousSlice = undefined;
             previousInputs = [];
-            return undefined;
+            return;
+        }
+        const support = level.supports?.get(node.id);
+        const inputs = [support?.elevation];
+        for (const face of ['a', 'b']) {
+            inputs.push(support?.faceDatum[face].length);
+            for (const segment of support?.faceDatum[face] ?? [])
+                inputs.push(segment.start, segment.end, segment.elevation, segment.endElevation);
         }
-        const inputs = [];
         for (const proud of prouds) {
             const data = level.miterDataByProud.get(proud);
             inputs.push(!!data);
@@ -87,7 +87,11 @@ export function createWallTreatmentSelector(node, proudOffsets) {
             miterDataByProud.set(proud, { junctionData, junctions: new Map() });
         }
         previousInputs = inputs;
-        previousSlice = { walls: [node], miterDataByProud };
+        previousSlice = {
+            walls: [node],
+            miterDataByProud,
+            supports: support ? new Map([[node.id, support]]) : undefined,
+        };
         return previousSlice;
     };
 }

package/dist/wall/treatments.d.ts

@@ -1,4 +1,4 @@
-import { type SceneMaterial, type SceneMaterialId, type WallNode, type WallTrimConfig } from '@pascal-app/core';
+import { type SceneMaterial, type SceneMaterialId, type WallFace, type WallNode, type WallTrimConfig, type WallTrimKind, type WallTrimSlotId } from '@pascal-app/core';
 import { type RenderShading } from '@pascal-app/viewer';
 import * as THREE from 'three';
 import { type WallTreatmentLevelData } from './treatment-level-data';
@@ -8,20 +8,20 @@ type OpeningLike = {
     height?: number;
     position?: [number, number, number];
 };
-type TrimKind = 'skirting' | 'crown' | 'chairRail';
-type WallSide = 'interior' | 'exterior';
+type TrimKind = WallTrimKind;
+type WallSide = WallFace;
 type SceneMaterials = Record<SceneMaterialId, SceneMaterial>;
-type WallTreatmentSlotId = 'skirtingInterior' | 'skirtingExterior' | 'crownInterior' | 'crownExterior' | 'chairRailInterior' | 'chairRailExterior';
+type WallTreatmentSlotId = WallTrimSlotId;
 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): {
-    skirtingInterior: THREE.Material<THREE.MaterialEventMap>;
-    skirtingExterior: THREE.Material<THREE.MaterialEventMap>;
-    crownInterior: THREE.Material<THREE.MaterialEventMap>;
-    crownExterior: THREE.Material<THREE.MaterialEventMap>;
-    chairRailInterior: THREE.Material<THREE.MaterialEventMap>;
-    chairRailExterior: THREE.Material<THREE.MaterialEventMap>;
+    aSkirting: THREE.Material<THREE.MaterialEventMap>;
+    bSkirting: THREE.Material<THREE.MaterialEventMap>;
+    aCrown: THREE.Material<THREE.MaterialEventMap>;
+    bCrown: THREE.Material<THREE.MaterialEventMap>;
+    aChairRail: THREE.Material<THREE.MaterialEventMap>;
+    bChairRail: THREE.Material<THREE.MaterialEventMap>;
 };
 export declare const WallTreatments: import("react").MemoExoticComponent<({ node, childrenNodes, levelData, materials, }: {
     node: WallNode;

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,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"}
+{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,eAAe,EAOpB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,YAAY,EAEjB,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,YAAY,CAAA;AAC5B,KAAK,QAAQ,GAAG,QAAQ,CAAA;AACxB,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAE5D,KAAK,mBAAmB,GAAG,cAAc,CAAA;AAoMzC,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAMzD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAoBlE;AAwND,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,2FAoGlC;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,iCA+DC,CAAA"}

package/dist/wall/treatments.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { getWallCurveFrameAt, getWallMiterBoundaryPoints, getWallThickness, isCurvedWall, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
+import { getWallCurveFrameAt, getWallLocalFaceZ, getWallMiterBoundaryPoints, getWallTrimFaces, getWallTrimSlotId, isCurvedWall, spatialGridManager, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, wallDoorStepRuns, } from '@pascal-app/core';
 import { baseMaterial, createMaterialFromPresetRef, resolveMaterialRef, } from '@pascal-app/viewer';
 import { memo, useEffect, useMemo } from 'react';
 import * as THREE from 'three';
@@ -202,18 +202,9 @@ const TRIM_PROFILES = {
     },
 };
 const TRIM_KIND_CONFIG = {
-    skirting: {
-        defaultConfig: WALL_SKIRTING_DEFAULT,
-        slots: { interior: 'skirtingInterior', exterior: 'skirtingExterior' },
-    },
-    crown: {
-        defaultConfig: WALL_CROWN_DEFAULT,
-        slots: { interior: 'crownInterior', exterior: 'crownExterior' },
-    },
-    chairRail: {
-        defaultConfig: WALL_CHAIR_RAIL_DEFAULT,
-        slots: { interior: 'chairRailInterior', exterior: 'chairRailExterior' },
-    },
+    skirting: { defaultConfig: WALL_SKIRTING_DEFAULT },
+    crown: { defaultConfig: WALL_CROWN_DEFAULT },
+    chairRail: { defaultConfig: WALL_CHAIR_RAIL_DEFAULT },
 };
 function resolveTrimProfile(kind, trim) {
     const defaultProfile = TRIM_KIND_CONFIG[kind].defaultConfig.profile;
@@ -247,19 +238,9 @@ export function wallTreatmentProudOffsets(node) {
     }
     return [...offsets];
 }
-function resolveTreatmentSideSign(node, side) {
-    if (side === 'interior') {
-        if (node.frontSide === 'interior')
-            return 1;
-        if (node.backSide === 'interior')
-            return -1;
-        return 1;
-    }
-    if (node.frontSide === 'exterior')
-        return 1;
-    if (node.backSide === 'exterior')
-        return -1;
-    return -1;
+// Face a is the wall's left (+normal), face b its right.
+function resolveTreatmentSideSign(_node, side) {
+    return side === 'a' ? 1 : -1;
 }
 function wallToLocalTransform(node) {
     const dx = node.end[0] - node.start[0];
@@ -294,11 +275,11 @@ function buildMiteredSidePolyline(node, levelData, side, offset) {
         return buildSidePolyline(node, side, offset);
     const sideSign = resolveTreatmentSideSign(node, side);
     const toLocal = wallToLocalTransform(node);
-    const proud = offset - getWallThickness(node) / 2;
+    const proud = offset - getWallLocalFaceZ(node, sideSign > 0 ? 'a' : 'b') * sideSign;
     const boundarySource = treatmentMiterDataForProud(levelData, proud);
     if (!boundarySource)
         return buildSidePolyline(node, side, offset);
-    const boundary = getWallMiterBoundaryPoints({ ...node, thickness: offset * 2 }, boundarySource);
+    const boundary = getWallMiterBoundaryPoints(node, boundarySource, proud);
     if (!boundary)
         return buildSidePolyline(node, side, offset);
     const start = sideSign > 0 ? boundary.startLeft : boundary.startRight;
@@ -417,7 +398,7 @@ function applyWorldScaleUvs(geometry) {
     }
     geometry.setAttribute('uv', new THREE.BufferAttribute(uv, 2));
 }
-function buildTrimSliceGeometry(outer, inner, extrudeHeight, translateY) {
+function buildTrimSliceGeometry(outer, inner, extrudeHeight, translateY, slope = 0, slopeStart = 0) {
     const shape = buildPlanPolygon(outer, inner);
     if (!shape)
         return null;
@@ -429,6 +410,11 @@ function buildTrimSliceGeometry(outer, inner, extrudeHeight, translateY) {
     });
     geometry.rotateX(-Math.PI / 2);
     geometry.translate(0, translateY, 0);
+    if (slope !== 0) {
+        const positions = geometry.getAttribute('position');
+        for (let i = 0; i < positions.count; i++)
+            positions.setY(i, positions.getY(i) + (positions.getX(i) - slopeStart) * slope);
+    }
     geometry.computeVertexNormals();
     applyWorldScaleUvs(geometry);
     return geometry;
@@ -449,14 +435,44 @@ export function buildTrimGeometry(node, side, trim, kind, childrenNodes, levelDa
         : kind === 'chairRail'
             ? Math.max(0, Math.min(wallHeight - height, trim.offsetY ?? WALL_CHAIR_RAIL_DEFAULT.offsetY ?? 0.9))
             : 0;
-    const thickness = getWallThickness(node);
-    const inner = buildMiteredSidePolyline(node, levelData, side, thickness / 2);
+    const faceOffset = getWallLocalFaceZ(node, resolveTreatmentSideSign(node, side) > 0 ? 'a' : 'b') *
+        resolveTreatmentSideSign(node, side);
+    const inner = buildMiteredSidePolyline(node, levelData, side, faceOffset);
     if (inner.length < 2)
         return null;
     const wallLength = Math.hypot(node.end[0] - node.start[0], node.end[1] - node.start[1]);
-    const openingRanges = trimOpeningRanges(node, childrenNodes, yBottom, height);
-    const fullRanges = [[0, wallLength]];
-    const runs = subtractOpeningRanges(fullRanges, openingRanges);
+    const support = kind === 'skirting' && node.parentId
+        ? (levelData.supports?.get(node.id) ??
+            spatialGridManager.getSlabSupportForWall(node.parentId, node.start, node.end, node.curveOffset ?? 0, node.thickness, node.supportSlabId, undefined, node.supportOffset, node.justification))
+        : undefined;
+    const bases = support?.faceDatum[resolveTreatmentSideSign(node, side) > 0 ? 'a' : 'b'] ?? [
+        { start: 0, end: 1, elevation: yBottom },
+    ];
+    const stationX = (t) => {
+        if (!isCurvedWall(node))
+            return t * wallLength;
+        const frame = getWallCurveFrameAt(node, t);
+        return wallToLocalTransform(node)(frame.point.x, frame.point.y).x;
+    };
+    const runs = bases.flatMap((base) => {
+        const bottom = support ? base.elevation - support.elevation : yBottom;
+        const openingRanges = trimOpeningRanges(node, childrenNodes, bottom, height);
+        if (support)
+            for (const child of childrenNodes) {
+                for (const run of wallDoorStepRuns(node, child, support.faceDatum, support.elevation))
+                    if (run.bottom < bottom + height && run.top > bottom)
+                        openingRanges.push([run.start, run.end]);
+            }
+        return subtractOpeningRanges([[stationX(base.start), stationX(base.end)]], openingRanges).map(([start, end]) => ({
+            start,
+            end,
+            bottom,
+            slopeStart: stationX(base.start),
+            slope: base.endElevation === undefined
+                ? 0
+                : (base.endElevation - base.elevation) / (stationX(base.end) - stationX(base.start)),
+        }));
+    });
     if (runs.length === 0)
         return null;
     const slices = [];
@@ -464,7 +480,7 @@ export function buildTrimGeometry(node, side, trim, kind, childrenNodes, levelDa
     if (!profile)
         return null;
     const sliceHeight = height / profile.samples;
-    for (const [runStart, runEnd] of runs) {
+    for (const { start: runStart, end: runEnd, bottom, slope, slopeStart } of runs) {
         const clipStart = runStart > EPS ? runStart : undefined;
         const clipEnd = runEnd < wallLength - EPS ? runEnd : undefined;
         const innerRun = clipPolyline(inner, clipStart, clipEnd);
@@ -473,11 +489,11 @@ export function buildTrimGeometry(node, side, trim, kind, childrenNodes, levelDa
         for (let index = 0; index < profile.samples; index += 1) {
             const t = (index + 0.5) / profile.samples;
             const proud = Math.max(MIN_SLICE_PROUD, trim.proud * profile.proudAt(t));
-            const outerRun = buildMiteredSidePolyline(node, levelData, side, thickness / 2 + proud);
+            const outerRun = buildMiteredSidePolyline(node, levelData, side, faceOffset + proud);
             const outerClipped = clipPolyline(outerRun, clipStart, clipEnd);
             if (outerClipped.length < 2)
                 continue;
-            const slice = buildTrimSliceGeometry(outerClipped, innerRun, sliceHeight, yBottom + index * sliceHeight);
+            const slice = buildTrimSliceGeometry(outerClipped, innerRun, sliceHeight, bottom + index * sliceHeight, slope, slopeStart);
             if (slice)
                 slices.push(slice);
         }
@@ -499,21 +515,21 @@ function resolveWallSlotMaterial(node, slotId, shading, sceneMaterials) {
 }
 export function createWallExtraSlotMaterials(node, shading, sceneMaterials) {
     return {
-        skirtingInterior: resolveWallSlotMaterial(node, 'skirtingInterior', shading, sceneMaterials),
-        skirtingExterior: resolveWallSlotMaterial(node, 'skirtingExterior', shading, sceneMaterials),
-        crownInterior: resolveWallSlotMaterial(node, 'crownInterior', shading, sceneMaterials),
-        crownExterior: resolveWallSlotMaterial(node, 'crownExterior', shading, sceneMaterials),
-        chairRailInterior: resolveWallSlotMaterial(node, 'chairRailInterior', shading, sceneMaterials),
-        chairRailExterior: resolveWallSlotMaterial(node, 'chairRailExterior', shading, sceneMaterials),
+        aSkirting: resolveWallSlotMaterial(node, 'aSkirting', shading, sceneMaterials),
+        bSkirting: resolveWallSlotMaterial(node, 'bSkirting', shading, sceneMaterials),
+        aCrown: resolveWallSlotMaterial(node, 'aCrown', shading, sceneMaterials),
+        bCrown: resolveWallSlotMaterial(node, 'bCrown', shading, sceneMaterials),
+        aChairRail: resolveWallSlotMaterial(node, 'aChairRail', shading, sceneMaterials),
+        bChairRail: resolveWallSlotMaterial(node, 'bChairRail', shading, sceneMaterials),
     };
 }
 export const WallTreatments = memo(function WallTreatments({ node, childrenNodes, levelData, materials, }) {
-    const fallbackMaterial = materials.skirtingInterior ??
-        materials.skirtingExterior ??
-        materials.crownInterior ??
-        materials.crownExterior ??
-        materials.chairRailInterior ??
-        materials.chairRailExterior;
+    const fallbackMaterial = materials.aSkirting ??
+        materials.bSkirting ??
+        materials.aCrown ??
+        materials.bCrown ??
+        materials.aChairRail ??
+        materials.bChairRail;
     const trimEntries = useMemo(() => {
         const out = [];
         const configs = [
@@ -525,14 +541,11 @@ export const WallTreatments = memo(function WallTreatments({ node, childrenNodes
             const trim = { ...TRIM_KIND_CONFIG[kind].defaultConfig, ...(rawConfig ?? {}) };
             if (!trim.enabled)
                 continue;
-            const sides = trim.sides === 'both'
-                ? ['interior', 'exterior']
-                : [trim.sides];
-            for (const side of sides) {
+            for (const side of getWallTrimFaces(trim.sides)) {
                 const geometry = buildTrimGeometry(node, side, trim, kind, childrenNodes, levelData);
                 if (!geometry)
                     continue;
-                const slotId = TRIM_KIND_CONFIG[kind].slots[side];
+                const slotId = getWallTrimSlotId(side, kind);
                 out.push({
                     key: `${kind}-${side}`,
                     slotId,

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

@@ -36,6 +36,13 @@ export declare function canBatchWalls(wallMode: WallMode, isolationActive: boole
  * calls is what lighting them costs.
  */
 export declare function collectTintedWalls(wallIds: ReadonlySet<string>): Set<string>;
+/**
+ * The materials a wall actually draws, in canonical (uuid) order. Two walls
+ * showing the same finishes batch together however their palettes are laid out
+ * — a room's finish on side a of one wall and side b of the next is one set.
+ */
+export declare function canonicalWallMaterials(mesh: Pick<Mesh, 'geometry'>, materials: readonly Material[]): Material[];
+export declare function materialSetKey(materials: readonly Material[]): string;
 export declare function collectWallBatchCandidates(levelId: string, excludedNodeIds?: ReadonlySet<string>): Map<string, WallBatchCandidate[]>;
 export declare const WallBatchSystem: () => null;
 /**