@pascal-app/nodes 1.0.0-beta.5 → 1.0.1

package/dist/wall/selection-hit-owner.js

@@ -0,0 +1,79 @@
+import { isRegistrySelectable, sceneRegistry, useScene } from '@pascal-app/core';
+/**
+ * Built-in kinds with selection semantics in the editor (mirrors
+ * SelectionManager's structure/furnish lists until Phase 4 makes
+ * `capabilities.selectable` the single source of truth). Wrapper kinds
+ * (level/building/site) and the zone volume are deliberately absent: a hit
+ * whose nearest owner is a wrapper is passive scenery, and zone volumes
+ * share the wall's own planes.
+ */
+const BUILTIN_SELECTABLE_COMPETITOR_KINDS = new Set([
+    'fence',
+    'item',
+    'column',
+    'elevator',
+    'slab',
+    'ceiling',
+    'roof',
+    'roof-segment',
+    'stair',
+    'stair-segment',
+    'spawn',
+    'window',
+    'door',
+    'shelf',
+]);
+const liveDeps = {
+    registryRevision: () => sceneRegistry.revision,
+    registeredEntries: () => sceneRegistry.nodes.entries(),
+    // The store index is keyed by AnyNodeId; keep the loose read in one place.
+    kindOf: (id) => useScene.getState().nodes[id]?.type,
+    isRegistrySelectableKind: isRegistrySelectable,
+};
+/**
+ * Reverse lookup (Object3D → registered node id), rebuilt lazily when the
+ * scene registry's revision moves. One map per classifier factory; the
+ * default factory below shares a single module-level instance.
+ */
+const createRegisteredObjectLookup = (deps) => {
+    let revision = -1;
+    let reverse = new Map();
+    return (object) => {
+        const currentRevision = deps.registryRevision();
+        if (currentRevision !== revision) {
+            revision = currentRevision;
+            reverse = new Map();
+            for (const [id, root] of deps.registeredEntries())
+                reverse.set(root, id);
+        }
+        let current = object;
+        while (current) {
+            const id = reverse.get(current);
+            if (id !== undefined)
+                return id;
+            current = current.parent;
+        }
+        return null;
+    };
+};
+const isSelectableCompetitorKind = (kind, deps) => BUILTIN_SELECTABLE_COMPETITOR_KINDS.has(kind) || deps.isRegistrySelectableKind(kind);
+/**
+ * Build a classifier for one wall's pointer gate. `selfWallId` is that
+ * wall's node id; hits resolving to it are 'self-wall'.
+ */
+export const createWallRayHitClassifier = (selfWallId, deps = liveDeps) => {
+    const nearestRegisteredId = createRegisteredObjectLookup(deps);
+    return (object) => {
+        const ownerId = nearestRegisteredId(object);
+        if (ownerId === null)
+            return 'passive';
+        if (ownerId === selfWallId)
+            return 'self-wall';
+        const kind = deps.kindOf(ownerId);
+        if (kind === undefined)
+            return 'passive';
+        if (kind === 'wall')
+            return 'other-wall';
+        return isSelectableCompetitorKind(kind, deps) ? 'selectable' : 'passive';
+    };
+};

package/dist/wall/system.d.ts

@@ -1,3 +1,5 @@
+export declare function resetWallTreatmentLevels(): void;
+export declare function updateWallTreatmentLevels(): void;
 /**
  * Registry-driven wall system bundle.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,WAAW,mCAShB,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAkCA,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAyChD;AASD;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,WAAW,mCAShB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/wall/system.js

@@ -1,40 +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;
 };
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AA6bA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAkf5B,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

@@ -325,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);
@@ -432,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();
@@ -545,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]);
@@ -591,6 +594,8 @@ export const WallTool = () => {
                     preferredSupportSlabId: draftPlane?.supportSlabId ?? null,
                     constructionElevation: draftPlane?.elevation ?? null,
                     constructionHeight: previewHeightRef.current,
+                    constructionSourceNodeId: constructionPlane.current?.sourceNodeId ?? null,
+                    flatConstructionBase: flatConstructionBase.current,
                 });
                 if (!createdWall)
                     return;

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

@@ -1,5 +1,7 @@
 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;
@@ -10,14 +12,44 @@ export type WallBatchCandidate = {
  *
  * 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 one wall mode. `cutaway` re-assigns materials
- * from the camera's facing test as the view turns, `down` makes every wall
- * see-through and `translucent` does the same by definition — in all three the
- * merged copy would keep drawing walls the cutaway pass has since turned to
- * glass. 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.
+ * 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

@@ -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;AA4HnE,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAA;AA8BtF;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,OAAO,GAAG,OAAO,CAEnF;AA2BD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,eAAe,GAAE,WAAW,CAAC,MAAM,CAAa,GAC/C,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAoBnC;AAqFD,eAAO,MAAM,eAAe,YAwB3B,CAAA"}
+{"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"}