@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/wall/treatments.d.ts

@@ -1,27 +1,27 @@
-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';
+import { type WallTreatmentLevelData } from './treatment-level-data.js';
 type OpeningLike = {
     type: string;
     width?: number;
     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,EAIpB,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,2FA2GlC;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,12 +1,12 @@
 '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 { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { getWallCurveFrameAt, getWallLocalFaceZ, getWallMiterBoundaryPoints, getWallTrimFaces, getWallTrimSlotId, isCurvedWall, spatialGridManager, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, wallDoorStepRuns, wallFaceBaseOffset, wallFaceScriptSkirtingGap, } from '@pascal-app/core';
 import { baseMaterial, createMaterialFromPresetRef, resolveMaterialRef, } from '@pascal-app/viewer';
 import { memo, useEffect, useMemo } from 'react';
 import * as THREE from 'three';
 import { mergeGeometries as mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
-import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
-import { treatmentMiterDataForProud } from './treatment-level-data';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
+import { treatmentMiterDataForProud } from './treatment-level-data.js';
 const CURVE_SEGMENTS = 24;
 const MIN_SLICE_PROUD = 0.0005;
 const EPS = 1e-6;
@@ -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,51 @@ 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 face = resolveTreatmentSideSign(node, side) > 0 ? 'a' : 'b';
+    const faceScript = kind === 'skirting' ? node.finishScripts?.[face] : undefined;
+    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]);
+            }
+        const scripted = faceScript && support
+            ? wallFaceScriptSkirtingGap(faceScript, bottom + height - wallFaceBaseOffset(support, face))
+            : null;
+        if (scripted)
+            openingRanges.push(scripted);
+        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 +487,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 +496,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 +522,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 +548,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;
 /**

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

@@ -1 +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;AAiCtF;;;;;;;;;;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"}
+{"version":3,"file":"wall-batch-system.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch-system.tsx"],"names":[],"mappings":"AAUA,OAAO,EAOL,KAAK,QAAQ,EACd,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EAAE,KAAK,QAAQ,EAAW,IAAI,EAAiB,MAAM,OAAO,CAAA;AAwGnE,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;AAiCtF;;;;;;;;;;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,CAe5E;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,EAC5B,SAAS,EAAE,SAAS,QAAQ,EAAE,GAC7B,QAAQ,EAAE,CAcZ;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,CAErE;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,eAAe,GAAE,WAAW,CAAC,MAAM,CAAa,GAC/C,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAoBnC;AAyGD,eAAO,MAAM,eAAe,YAoE3B,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,QA+J3D"}

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

@@ -1,10 +1,11 @@
 'use client';
-import { emitter, sceneRegistry, useScene } from '@pascal-app/core';
-import { drainRebuiltWalls, getPendingWallRebuildCount, isIsolationActive, SCENE_LAYER, useViewer, } from '@pascal-app/viewer';
+import { emitter, getLibraryMaterialsVersion, sceneRegistry, useScene, } from '@pascal-app/core';
+import { drainRebuiltWalls, getPendingWallRebuildCount, isIsolationActive, isNodeRevealing, SCENE_LAYER, useViewer, } from '@pascal-app/viewer';
 import { useFrame, useThree } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import { Matrix4, Mesh } from 'three';
-import { applyWallBatchGroups, buildWallBatch, hideBatchedWall, revealBatchedWall, } from './wall-batch';
+import { isSlotPaintPreviewActive } from '../shared/slot-paint.js';
+import { applyWallBatchGroups, buildWallBatch, hideBatchedWall, revealBatchedWall, } from './wall-batch.js';
 // A level's walls are merged only once they stop changing. Below this many
 // walls a merge is not worth the buffer, and the leftovers (a selected wall,
 // a lone partition) keep drawing themselves.
@@ -17,15 +18,18 @@ const lastAppearance = {
     colorPreset: undefined,
     sceneTheme: undefined,
     materials: null,
+    libraryVersion: -1,
 };
 function appearanceChanged() {
     const viewer = useViewer.getState();
     const materials = useScene.getState().materials;
+    const libraryVersion = getLibraryMaterialsVersion();
     if (lastAppearance.shading === viewer.shading &&
         lastAppearance.textures === viewer.textures &&
         lastAppearance.colorPreset === viewer.colorPreset &&
         lastAppearance.sceneTheme === viewer.sceneTheme &&
-        lastAppearance.materials === materials) {
+        lastAppearance.materials === materials &&
+        lastAppearance.libraryVersion === libraryVersion) {
         return false;
     }
     lastAppearance.shading = viewer.shading;
@@ -33,6 +37,7 @@ function appearanceChanged() {
     lastAppearance.colorPreset = viewer.colorPreset;
     lastAppearance.sceneTheme = viewer.sceneTheme;
     lastAppearance.materials = materials;
+    lastAppearance.libraryVersion = libraryVersion;
     return true;
 }
 const batchesByLevel = new Map();
@@ -167,9 +172,35 @@ export function collectTintedWalls(wallIds) {
     const hovered = viewer.hoveredId;
     if (hovered && wallIds.has(hovered))
         tinted.add(hovered);
+    // A paint preview spreads past the hovered wall (a room's walls): each one it
+    // repaints has to draw itself, or the merged copy hides the preview.
+    for (const id of wallIds)
+        if (isSlotPaintPreviewActive(id))
+            tinted.add(id);
     return tinted;
 }
-function materialSetKey(materials) {
+/**
+ * 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 function canonicalWallMaterials(mesh, materials) {
+    const groups = mesh.geometry.groups;
+    const used = new Set();
+    if (groups.length === 0) {
+        if (materials[0])
+            used.add(materials[0]);
+    }
+    else {
+        for (const group of groups) {
+            const material = materials[group.materialIndex ?? 0];
+            if (material)
+                used.add(material);
+        }
+    }
+    return [...used].sort((left, right) => left.uuid < right.uuid ? -1 : left.uuid > right.uuid ? 1 : 0);
+}
+export function materialSetKey(materials) {
     return materials.map((material) => material.uuid).join('|');
 }
 export function collectWallBatchCandidates(levelId, excludedNodeIds = EMPTY_IDS) {
@@ -185,7 +216,7 @@ export function collectWallBatchCandidates(levelId, excludedNodeIds = EMPTY_IDS)
         const candidate = toCandidate(childId, child, excludedNodeIds);
         if (!candidate)
             continue;
-        const key = materialSetKey(candidate.materials);
+        const key = materialSetKey(canonicalWallMaterials(candidate.mesh, candidate.materials));
         const bucket = grouped.get(key);
         if (bucket)
             bucket.push(candidate);
@@ -202,6 +233,18 @@ export function collectWallBatchCandidates(levelId, excludedNodeIds = EMPTY_IDS)
  * pays off once enough walls have drifted out, so a single edit leaves the
  * floor's merged mesh exactly where it was.
  */
+/**
+ * A wall still rising from a construction reveal moves every frame, and a
+ * merge would freeze it mid-rise — or, if it were left out, keep it out until
+ * enough walls drift to re-sew the floor. Its level waits for the whole rise.
+ */
+function levelHasRevealingWalls(levelId) {
+    const nodes = useScene.getState().nodes;
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return false;
+    return level.children.some((childId) => nodes[childId]?.type === 'wall' && isNodeRevealing(childId));
+}
 function unbatchedWallCount(levelId, excludedNodeIds = EMPTY_IDS) {
     const nodes = useScene.getState().nodes;
     const level = nodes[levelId];
@@ -234,18 +277,23 @@ function mergeLevel(levelId, excludedNodeIds = EMPTY_IDS) {
     for (const candidates of collectWallBatchCandidates(levelId, excludedNodeIds).values()) {
         if (candidates.length < MIN_BATCH_WALLS)
             continue;
+        const canonical = canonicalWallMaterials(candidates[0].mesh, candidates[0].materials);
         const sources = candidates.map((candidate) => {
             candidate.mesh.updateWorldMatrix(true, false);
             return {
                 nodeId: candidate.nodeId,
                 geometry: candidate.mesh.geometry,
                 matrix: localMatrix.multiplyMatrices(rootInverse, candidate.mesh.matrixWorld).clone(),
+                materialIndexMap: candidate.materials.map((material) => {
+                    const index = canonical.indexOf(material);
+                    return index < 0 ? undefined : index;
+                }),
             };
         });
         const batch = buildWallBatch(sources);
         if (!batch)
             continue;
-        const mesh = new Mesh(batch.geometry, candidates[0].materials);
+        const mesh = new Mesh(batch.geometry, canonical);
         mesh.name = 'wall-batch';
         mesh.userData.pascalExport = 'strip';
         mesh.castShadow = true;
@@ -331,6 +379,7 @@ export const WallBatchSystem = () => {
         lastAppearance.colorPreset = undefined;
         lastAppearance.sceneTheme = undefined;
         lastAppearance.materials = null;
+        lastAppearance.libraryVersion = -1;
     }, []);
     return null;
 };
@@ -368,6 +417,16 @@ export function runBatchFrame(invalidate, wakeRef) {
         releaseWall(nodeId);
     }
     changedWalls.clear();
+    // A wall going out in a reverse play (an undo) moves its own mesh while the merged mesh keeps
+    // drawing it whole: it draws itself until the host takes it out. Its level waits for it
+    // (`levelHasRevealingWalls`), so it is not sewn back in under the play.
+    for (const [nodeId, record] of [...batchByNode]) {
+        if (!isNodeRevealing(nodeId))
+            continue;
+        staleLevels.add(record.levelId);
+        releaseWall(nodeId);
+        changed = true;
+    }
     // A tinted wall paints itself through materials the merged mesh never reads,
     // so it goes back to drawing its own geometry for as long as it is lit. It
     // stays out afterwards: one wall short of a batch is not worth re-sewing a
@@ -480,10 +539,25 @@ export function runBatchFrame(invalidate, wakeRef) {
         }, BATCH_SETTLE_MS + 20);
         return;
     }
+    const revealingLevels = new Set();
     for (const levelId of staleLevels) {
+        if (levelHasRevealingWalls(levelId)) {
+            revealingLevels.add(levelId);
+            continue;
+        }
         if (unbatchedWallCount(levelId, excludedNodeIds) >= MIN_BATCH_WALLS) {
             mergeLevel(levelId, excludedNodeIds);
         }
     }
     staleLevels.clear();
+    if (revealingLevels.size === 0)
+        return;
+    for (const levelId of revealingLevels)
+        staleLevels.add(levelId);
+    if (wakeRef.current)
+        clearTimeout(wakeRef.current);
+    wakeRef.current = setTimeout(() => {
+        wakeRef.current = null;
+        invalidate();
+    }, BATCH_SETTLE_MS + 20);
 }

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

@@ -17,6 +17,12 @@ export type WallBatchSource = {
     geometry: THREE.BufferGeometry;
     /** Source-local to batch-root transform, baked into the merged vertices. */
     matrix: THREE.Matrix4;
+    /**
+     * Source material index → batch material index. Walls that draw the same
+     * materials in a different palette order share a batch this way; a group
+     * whose index maps nowhere draws nothing and is dropped.
+     */
+    materialIndexMap?: ReadonlyArray<number | undefined>;
 };
 export type WallBatch = {
     geometry: THREE.BufferGeometry;

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

@@ -1 +1 @@
-{"version":3,"file":"wall-batch.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,0EAA0E;AAC1E,MAAM,MAAM,cAAc,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7E,mEAAmE;AACnE,MAAM,MAAM,YAAY,GAAG;IACzB,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,cAAc,EAAE,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,4EAA4E;IAC5E,MAAM,EAAE,KAAK,CAAC,OAAO,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,IAAI,EAAE,YAAY,EAAE,CAAA;CACrB,CAAA;AAkCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,GAAG,IAAI,CAmEpF;AAwCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAmBxF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE1D;AAED,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE5D"}
+{"version":3,"file":"wall-batch.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,0EAA0E;AAC1E,MAAM,MAAM,cAAc,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7E,mEAAmE;AACnE,MAAM,MAAM,YAAY,GAAG;IACzB,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,cAAc,EAAE,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,4EAA4E;IAC5E,MAAM,EAAE,KAAK,CAAC,OAAO,CAAA;IACrB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CACrD,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,IAAI,EAAE,YAAY,EAAE,CAAA;CACrB,CAAA;AAuCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,GAAG,IAAI,CAmEpF;AAwCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAmBxF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE1D;AAED,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE5D"}

package/dist/wall/wall-batch.js

@@ -20,7 +20,13 @@ function planSource(source) {
         const count = Math.min(group.count, position.count - start);
         if (count <= 0)
             continue;
-        groups.push({ materialIndex: group.materialIndex ?? 0, start, count });
+        const sourceIndex = group.materialIndex ?? 0;
+        const materialIndex = source.materialIndexMap
+            ? source.materialIndexMap[sourceIndex]
+            : sourceIndex;
+        if (materialIndex === undefined)
+            continue;
+        groups.push({ materialIndex, start, count });
     }
     return groups.length > 0 ? { source, groups } : null;
 }

package/dist/window/contextual-dimensions.js

@@ -1,4 +1,4 @@
-import { buildWallHostedOpeningContextualDimensions } from '../wall/contextual-dimensions';
+import { buildWallHostedOpeningContextualDimensions } from '../wall/contextual-dimensions.js';
 export function buildWindowContextualDimensions(node, ctx) {
     return buildWallHostedOpeningContextualDimensions(node, ctx, {
         showClearancesWhileMoving: true,

package/dist/window/corner-cue.d.ts

@@ -0,0 +1,9 @@
+import type { CornerBlock, CornerSnap } from '@pascal-app/core';
+/** Show the cue for `snap`, or clear it when null: away from a corner, a new tool, a cancel. */
+export declare function showCornerCue(snap: CornerSnap | null, block?: CornerBlock | null): void;
+/**
+ * Whether the person turned snapping off for what they are doing (no context, no choice made):
+ * the corner snap is a snap, and goes with it.
+ */
+export declare const snappingTurnedOff: () => boolean;
+//# sourceMappingURL=corner-cue.d.ts.map

package/dist/window/corner-cue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corner-cue.d.ts","sourceRoot":"","sources":["../../src/window/corner-cue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAW/D,gGAAgG;AAChG,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,EAAE,KAAK,GAAE,WAAW,GAAG,IAAW,QActF;AAED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,eACwC,CAAA"}

package/dist/window/corner-cue.js

@@ -0,0 +1,31 @@
+import { getActiveSnapContext, getActiveSnappingMode, useCornerSnapHint } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+// What a window placed or dragged near a corner shows: the HUD hint says what a click will do, and
+// the window already waiting on the other wall is outlined in the editor's hover colour, so the
+// join is visible before it happens. Where a wall end is not a corner a window can wrap, the HUD
+// says why instead of showing nothing.
+let outlined = null;
+/** Show the cue for `snap`, or clear it when null: away from a corner, a new tool, a cancel. */
+export function showCornerCue(snap, block = null) {
+    useCornerSnapHint
+        .getState()
+        .setHint(snap ? (snap.waitingId ? 'join' : 'new') : (block?.reason ?? null));
+    const next = snap?.waitingId ?? null;
+    if (next === outlined)
+        return;
+    const viewer = useViewer.getState();
+    // Only what this cue outlined is ever cleared: a hover that is something else's stays.
+    if (next === null) {
+        if (viewer.hoveredId === outlined)
+            viewer.setHoveredId(null);
+    }
+    else {
+        viewer.setHoveredId(next);
+    }
+    outlined = next;
+}
+/**
+ * Whether the person turned snapping off for what they are doing (no context, no choice made):
+ * the corner snap is a snap, and goes with it.
+ */
+export const snappingTurnedOff = () => getActiveSnapContext() !== null && getActiveSnappingMode() === 'off';

package/dist/window/corner-fuse.d.ts

@@ -0,0 +1,14 @@
+import { type CornerSnap } from '@pascal-app/core';
+/**
+ * The window just placed or dropped at a corner joins the corner window: with the window waiting
+ * on the other wall (`waitingId`) it becomes one corner pair, the waiting window's height, sill and
+ * type kept; with none waiting, a partner is created on the other wall. A refusal leaves the window
+ * where it stands, plain.
+ */
+export declare function fuseAtCorner(windowId: string, waitingId: string | null): void;
+/**
+ * A window moved and dropped: joined at the corner it was dropped at, else, when it was one side of
+ * a corner window and no longer is (dragged off its corner), both sides plain again.
+ */
+export declare function settleMovedWindow(windowId: string, snap: CornerSnap | null): void;
+//# sourceMappingURL=corner-fuse.d.ts.map

package/dist/window/corner-fuse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corner-fuse.d.ts","sourceRoot":"","sources":["../../src/window/corner-fuse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAY,MAAM,kBAAkB,CAAA;AAK5D;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,QAgBtE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,QAO1E"}

package/dist/window/corner-fuse.js

@@ -0,0 +1,42 @@
+import { useScene } from '@pascal-app/core';
+import { isAgentRefusal } from '@pascal-app/core/agent-tools';
+import { mergeWindows, strayCornerClears, wrapCorner } from '@pascal-app/core/building';
+import { writeWindowChanges } from '@pascal-app/editor';
+/**
+ * The window just placed or dropped at a corner joins the corner window: with the window waiting
+ * on the other wall (`waitingId`) it becomes one corner pair, the waiting window's height, sill and
+ * type kept; with none waiting, a partner is created on the other wall. A refusal leaves the window
+ * where it stands, plain.
+ */
+export function fuseAtCorner(windowId, waitingId) {
+    try {
+        if (waitingId) {
+            const merge = mergeWindows(useScene.getState().nodes, waitingId, windowId);
+            writeWindowChanges({
+                create: null,
+                updates: Object.fromEntries(merge.changes.update.map(({ id, data }) => [id, data])),
+                remove: merge.changes.delete,
+            });
+            return;
+        }
+        const { create, updates } = wrapCorner(useScene.getState().nodes, windowId);
+        writeWindowChanges({ create, updates, remove: [] });
+    }
+    catch (error) {
+        if (!isAgentRefusal(error))
+            throw error;
+    }
+}
+/**
+ * A window moved and dropped: joined at the corner it was dropped at, else, when it was one side of
+ * a corner window and no longer is (dragged off its corner), both sides plain again.
+ */
+export function settleMovedWindow(windowId, snap) {
+    if (snap) {
+        fuseAtCorner(windowId, snap.waitingId);
+        return;
+    }
+    const updates = strayCornerClears(useScene.getState().nodes, windowId);
+    if (Object.keys(updates).length)
+        writeWindowChanges({ create: null, updates, remove: [] });
+}

package/dist/window/definition.d.ts

@@ -1,5 +1,5 @@
 import type { AnyNodeId, NodeDefinition, SceneApi, WindowNode as WindowNodeType } from '@pascal-app/core';
-import { WindowNode } from './schema';
+import { WindowNode } from './schema.js';
 export declare function resolveWindowHandlePortalTarget(window: WindowNodeType, scene: Pick<SceneApi, 'get'>): AnyNodeId | null;
 /**
  * Window — Phase 5 batch kind. Mirrors door's shape: hosted on walls,