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

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

@@ -1,16 +1,17 @@
-import { sceneRegistry } from '@pascal-app/core';
+import { sceneRegistry, useScene } from '@pascal-app/core';
 import { useEffect } from 'react';
 import useViewer from '../../store/use-viewer';
 export const ScanSystem = () => {
     const showScans = useViewer((state) => state.showScans);
+    const nodes = useScene((state) => state.nodes);
     useEffect(() => {
         const scans = sceneRegistry.byType.scan || new Set();
         scans.forEach((scanId) => {
             const node = sceneRegistry.nodes.get(scanId);
-            if (node) {
-                node.visible = showScans;
-            }
+            const scan = nodes[scanId];
+            if (node && scan?.type === 'scan')
+                node.visible = showScans && scan.visible;
         });
-    }, [showScans]);
+    }, [nodes, showScans]);
     return null;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACb,KAAK,kBAAkB,EACxB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAQ9B;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,kBAAkB,GAC1B,KAAK,CAAC,cAAc,CAItB"}
+{"version":3,"file":"slab-system.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-system.tsx"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACb,KAAK,kBAAkB,EAExB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAO9B;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,kBAAkB,GAC1B,KAAK,CAAC,cAAc,CAItB"}

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

@@ -1,6 +1,5 @@
-import { getRenderableSlabPolygon, pointInPolygon2D, polygonsIntersect, } from '@pascal-app/core';
+import { getRenderableSlabPolygon, pointInPolygon2D, polygonsIntersect, subtractPolygonsFromPolygon, } from '@pascal-app/core';
 import * as THREE from 'three';
-import { subtractPolygonsFromPolygon } from '../../lib/polygon-union';
 import { mergeSurfaceHolePolygons } from '../surface-hole-geometry';
 // ============================================================================
 // SLAB GEOMETRY GENERATORS

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

@@ -1 +1 @@
-{"version":3,"file":"stair-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-system.tsx"],"names":[],"mappings":"AA0BA,eAAO,MAAM,WAAW,YAuGvB,CAAA"}
+{"version":3,"file":"stair-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-system.tsx"],"names":[],"mappings":"AA2BA,eAAO,MAAM,WAAW,YAuGvB,CAAA"}

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

@@ -1,4 +1,4 @@
-import { getEffectiveNode, getFloorStackedPosition, sceneRegistry, useScene, } from '@pascal-app/core';
+import { createStairFlightFromStair, getEffectiveNode, getFloorStackedPosition, sceneRegistry, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import * as THREE from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
@@ -269,15 +269,16 @@ function updateMergedStairGeometry(stairNode, group, nodes) {
         .map((childId) => nodes[childId])
         .filter((n) => n?.type === 'stair-segment')
         .map((n) => getEffectiveNode(n));
-    if (segments.length === 0) {
-        replaceMeshGeometry(mergedMesh, createEmptyGeometry());
-        return;
-    }
+    // A straight stair with no segments has nothing to merge and would render as
+    // nothing at all — the state a stair authored as curved lands in the moment
+    // it is switched to straight. Draw the flight its own fields describe
+    // instead of vanishing; it is the same flight the panel materializes.
+    const bodySegments = segments.length > 0 ? segments : [createStairFlightFromStair(stairNode, nodes)];
     // Compute chained transforms for segments
-    const transforms = computeSegmentTransforms(segments);
+    const transforms = computeSegmentTransforms(bodySegments);
     const geometries = [];
-    for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i];
+    for (let i = 0; i < bodySegments.length; i++) {
+        const segment = bodySegments[i];
         const transform = transforms[i];
         const absoluteHeight = transform.position[1];
         const geo = generateStairSegmentGeometry(segment, absoluteHeight);

package/dist/systems/surface-hole-geometry.d.ts

@@ -1,3 +1,3 @@
-import { type Point2D } from '../lib/polygon-union';
+import { type PolygonBooleanPoint2D as Point2D } from '@pascal-app/core';
 export declare function mergeSurfaceHolePolygons(holes: Point2D[][]): Point2D[][];
 //# sourceMappingURL=surface-hole-geometry.d.ts.map

package/dist/systems/surface-hole-geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"surface-hole-geometry.d.ts","sourceRoot":"","sources":["../../src/systems/surface-hole-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,sBAAsB,CAAA;AAElE,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAExE"}
+{"version":3,"file":"surface-hole-geometry.d.ts","sourceRoot":"","sources":["../../src/systems/surface-hole-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,qBAAqB,IAAI,OAAO,EAAiB,MAAM,kBAAkB,CAAA;AAEvF,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAExE"}

package/dist/systems/surface-hole-geometry.js

@@ -1,4 +1,4 @@
-import { unionPolygons } from '../lib/polygon-union';
+import { unionPolygons } from '@pascal-app/core';
 export function mergeSurfaceHolePolygons(holes) {
     return unionPolygons(holes);
 }

package/dist/systems/wall/level-miter-cache.d.ts

@@ -0,0 +1,10 @@
+import { type WallMiterData, type WallNode } from '@pascal-app/core';
+export declare function sameMiterInputs(a: WallNode[], b: WallNode[]): boolean;
+export declare function getCachedLevelMiters(levelId: string, levelWalls: WallNode[]): WallMiterData;
+/**
+ * The cache is module-level, so it outlives any single mount. Editor teardown
+ * resets the other shared singletons; without the same reset a remount in the
+ * same tab keeps every previous level's walls reachable.
+ */
+export declare function clearLevelMiterCache(): void;
+//# sourceMappingURL=level-miter-cache.d.ts.map

package/dist/systems/wall/level-miter-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level-miter-cache.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/level-miter-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,aAAa,EAAE,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAY1F,wBAAgB,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,OAAO,CAoBrE;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,aAAa,CAO3F;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C"}

package/dist/systems/wall/level-miter-cache.js

@@ -0,0 +1,40 @@
+import { calculateLevelMiters } from '@pascal-app/core';
+const levelMiterCache = new Map();
+export function sameMiterInputs(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        const x = a[i];
+        const y = b[i];
+        if (x === y)
+            continue;
+        if (!x || !y)
+            return false;
+        if (x.id !== y.id ||
+            x.start[0] !== y.start[0] ||
+            x.start[1] !== y.start[1] ||
+            x.end[0] !== y.end[0] ||
+            x.end[1] !== y.end[1] ||
+            x.thickness !== y.thickness ||
+            x.curveOffset !== y.curveOffset) {
+            return false;
+        }
+    }
+    return true;
+}
+export function getCachedLevelMiters(levelId, levelWalls) {
+    const cached = levelMiterCache.get(levelId);
+    if (cached && sameMiterInputs(cached.walls, levelWalls))
+        return cached.data;
+    const data = calculateLevelMiters(levelWalls);
+    levelMiterCache.set(levelId, { walls: levelWalls, data });
+    return data;
+}
+/**
+ * The cache is module-level, so it outlives any single mount. Editor teardown
+ * resets the other shared singletons; without the same reset a remount in the
+ * same tab keeps every previous level's walls reachable.
+ */
+export function clearLevelMiterCache() {
+    levelMiterCache.clear();
+}

package/dist/systems/wall/wall-build-lifecycle.d.ts

@@ -0,0 +1,9 @@
+import { type PerfBatchStats } from '../../lib/perf-panel-store';
+export declare const pendingAdjacentByLevel: Map<string, Set<string>>;
+export declare const initiallyBuiltWalls: Set<string>;
+export declare const drainStats: NonNullable<PerfBatchStats['wallDrain']>;
+export declare function publishWallDrainStats(): void;
+export declare function endInitialBuild(): void;
+export declare function isWallInitialBuildActive(): boolean;
+export declare function subscribeWallBuildInteractions(target: EventTarget | null): (() => void) | undefined;
+//# sourceMappingURL=wall-build-lifecycle.d.ts.map

package/dist/systems/wall/wall-build-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-build-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-build-lifecycle.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,cAAc,EAA6B,MAAM,4BAA4B,CAAA;AAG3F,eAAO,MAAM,sBAAsB,0BAAiC,CAAA;AAKpE,eAAO,MAAM,mBAAmB,aAAoB,CAAA;AACpD,eAAO,MAAM,UAAU,EAAE,WAAW,CAAC,cAAc,CAAC,WAAW,CAAC,CAW/D,CAAA;AAED,wBAAgB,qBAAqB,SAGpC;AAED,wBAAgB,eAAe,SAM9B;AAED,wBAAgB,wBAAwB,IAAI,OAAO,CAuBlD;AAID,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,WAAW,GAAG,IAAI,GACzB,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAU1B"}

package/dist/systems/wall/wall-build-lifecycle.js

@@ -0,0 +1,74 @@
+import { useScene } from '@pascal-app/core';
+import { PERF_OVERLAY_ENABLED } from '../../lib/gpu-perf';
+import { publishPerfWallDrainStats } from '../../lib/perf-panel-store';
+import { beginSpan, endSpan } from '../../lib/perf-tracks';
+export const pendingAdjacentByLevel = new Map();
+let hydrationId = null;
+let hydrationToken = null;
+let initialBuildActive = false;
+let initialBuildSpan = null;
+export const initiallyBuiltWalls = new Set();
+export const drainStats = {
+    initialBuildActive: false,
+    wallsConsumedThisFrame: 0,
+    budgetExits: 0,
+    heavyExits: 0,
+    drainedExits: 0,
+    capExits: 0,
+    pendingNeighbours: 0,
+    firstBuilds: 0,
+    reinvalidationBuilds: 0,
+    neighbourEnqueues: 0,
+};
+export function publishWallDrainStats() {
+    drainStats.initialBuildActive = initialBuildActive;
+    if (PERF_OVERLAY_ENABLED)
+        publishPerfWallDrainStats(drainStats);
+}
+export function endInitialBuild() {
+    if (!initialBuildActive)
+        return;
+    initialBuildActive = false;
+    endSpan(initialBuildSpan);
+    initialBuildSpan = null;
+    publishWallDrainStats();
+}
+export function isWallInitialBuildActive() {
+    const state = useScene.getState();
+    if (state.hydrationId !== hydrationId) {
+        endInitialBuild();
+        hydrationId = state.hydrationId;
+        initiallyBuiltWalls.clear();
+        pendingAdjacentByLevel.clear();
+        for (const key of Object.keys(drainStats)) {
+            if (key !== 'initialBuildActive')
+                drainStats[key] = 0;
+        }
+        publishWallDrainStats();
+    }
+    const token = state.hydrationToken;
+    if (token !== hydrationToken) {
+        endInitialBuild();
+        hydrationToken = token;
+        if (token) {
+            initialBuildActive = true;
+            initialBuildSpan = beginSpan('wall-initial-build');
+            publishWallDrainStats();
+        }
+    }
+    return initialBuildActive;
+}
+useScene.subscribe(() => isWallInitialBuildActive());
+export function subscribeWallBuildInteractions(target) {
+    if (!target)
+        return;
+    const interrupt = () => useScene.getState().invalidateHydration();
+    const events = ['pointerdown', 'pointermove', 'wheel'];
+    for (const event of events)
+        target.addEventListener(event, interrupt, { capture: true, passive: true });
+    isWallInitialBuildActive();
+    return () => {
+        for (const event of events)
+            target.removeEventListener(event, interrupt, true);
+    };
+}

package/dist/systems/wall/wall-cutout-cache.d.ts

@@ -0,0 +1,57 @@
+import { type WallNode } from '@pascal-app/core';
+import { type Camera, type Material, Matrix4, type Mesh, Vector3 } from 'three';
+import useViewer, { type WallMode } from '../../store/use-viewer';
+import { type WallMaterialVariant } from './wall-material-variant';
+export declare function sameMaterialArray(a: Material | Material[], b: Material[]): boolean;
+type Variant = {
+    key: WallMaterialVariant;
+    materials: Material[];
+};
+type CachedWall = {
+    mesh: Mesh;
+    node: WallNode;
+    normal: Vector3;
+    matrix: Matrix4;
+    geometry: Mesh['geometry'];
+    negativeFacing: boolean | undefined;
+    hidden: boolean | undefined;
+    variantKey: WallMaterialVariant | undefined;
+    assignedMaterials: Material | Material[] | undefined;
+    visibleVariant: Variant;
+    hiddenVariant: Variant;
+};
+export declare const WALL_FACING_HYSTERESIS = 0.001;
+export declare function wallHiddenFromFacing(node: Pick<WallNode, 'frontSide' | 'backSide'>, mode: WallMode, negativeFacing: boolean): boolean;
+export declare function wallFacingNegative(dot: number, previous: boolean | undefined): boolean;
+export type WallCutoutViewerState = Pick<ReturnType<typeof useViewer.getState>, 'wallMode' | 'shading' | 'textures' | 'colorPreset' | 'sceneTheme' | 'selection' | 'previewSelectedIds' | 'hoveredId' | 'hoverHighlightMode'>;
+export type WallCutoutViewerStore = {
+    getState: () => WallCutoutViewerState;
+};
+export declare class WallCutoutCache {
+    private readonly viewerStore;
+    readonly walls: Map<string, CachedWall>;
+    readonly rebuilt: Set<string>;
+    private viewer;
+    private nodes;
+    private materials;
+    private registryRevision;
+    private wallCount;
+    private libraryVersion;
+    private lastCameraPosition;
+    private lastCameraTarget;
+    private cameraDirection;
+    private cameraTarget;
+    private lastUpdateTime;
+    private textureVersion;
+    private selected;
+    private highlightKey;
+    private transformed;
+    constructor(viewerStore?: WallCutoutViewerStore);
+    subscribeLiveTransforms(): () => void;
+    update(camera: Camera, time: number): void;
+    private refreshAppearance;
+    private refreshNormal;
+    private apply;
+}
+export {};
+//# sourceMappingURL=wall-cutout-cache.d.ts.map

package/dist/systems/wall/wall-cutout-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-cutout-cache.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout-cache.ts"],"names":[],"mappings":"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"}

package/dist/systems/wall/wall-cutout-cache.js

@@ -0,0 +1,304 @@
+// New kind-specific modules belong in nodes; viewer must not depend on nodes.
+// This extends the existing viewer-owned wall cutout and material implementation.
+import { getLibraryMaterialsVersion, getWallFaceBandConfig, getWallPlaneTop, resolveLevelId, resolveWallEffectiveHeight, sceneRegistry, spatialGridManager, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { Matrix4, Vector3 } from 'three';
+import { getMaterialTextureVersion } from '../../lib/materials';
+import useViewer, {} from '../../store/use-viewer';
+import { resolveWallMaterialVariant } from './wall-material-variant';
+import { getHoverHighlightMaterials, getMaterialsForWall, getSelectionHighlightMaterials, } from './wall-materials';
+export function sameMaterialArray(a, b) {
+    return Array.isArray(a) && a.length === b.length && a.every((material, i) => material === b[i]);
+}
+/** Materialize a resolved variant from the wall's cached material set. */
+function materialsForVariant(variant, materials) {
+    switch (variant) {
+        case 'visible':
+            return materials.visible;
+        case 'invisible':
+            return materials.invisible;
+        case 'translucent':
+            return materials.translucent;
+        case 'delete-visible':
+            return materials.deleteVisible;
+        case 'delete-invisible':
+            return materials.deleteInvisible;
+        case 'delete-translucent':
+            return materials.deleteTranslucent;
+        case 'selection-visible':
+            return getSelectionHighlightMaterials(materials.visible);
+        case 'selection-invisible':
+            return getSelectionHighlightMaterials(materials.invisible);
+        case 'selection-translucent':
+            return getSelectionHighlightMaterials(materials.translucent);
+        case 'hover-invisible':
+            return getHoverHighlightMaterials(materials.invisible);
+        default: {
+            const exhaustive = variant;
+            return exhaustive;
+        }
+    }
+}
+// About 0.06 degrees: retain the previous side at edge-on poses without
+// introducing a perceptible delay when an orbit crosses a wall's plane.
+export const WALL_FACING_HYSTERESIS = 0.001;
+export function wallHiddenFromFacing(node, mode, negativeFacing) {
+    if (mode === 'up')
+        return false;
+    if (mode === 'down')
+        return true;
+    if (node.frontSide === 'interior' && node.backSide === 'interior')
+        return true;
+    return negativeFacing
+        ? node.frontSide === 'exterior' && node.backSide !== 'exterior'
+        : node.backSide === 'exterior' && node.frontSide !== 'exterior';
+}
+export function wallFacingNegative(dot, previous) {
+    if (previous === undefined)
+        return dot < 0;
+    return previous ? dot < WALL_FACING_HYSTERESIS : dot < -WALL_FACING_HYSTERESIS;
+}
+export class WallCutoutCache {
+    viewerStore;
+    walls = new Map();
+    rebuilt = new Set();
+    viewer;
+    nodes;
+    materials;
+    registryRevision = -1;
+    wallCount = -1;
+    libraryVersion = -1;
+    lastCameraPosition = new Vector3();
+    lastCameraTarget = new Vector3();
+    cameraDirection = new Vector3();
+    cameraTarget = new Vector3();
+    lastUpdateTime = 0;
+    textureVersion = -1;
+    selected = new Set();
+    highlightKey = '';
+    transformed = new Set();
+    constructor(viewerStore = useViewer) {
+        this.viewerStore = viewerStore;
+    }
+    subscribeLiveTransforms() {
+        return useLiveTransforms.subscribe((state, previous) => {
+            for (const [id, transform] of state.transforms) {
+                if (transform !== previous.transforms.get(id))
+                    this.transformed.add(id);
+            }
+            for (const id of previous.transforms.keys()) {
+                if (!state.transforms.has(id))
+                    this.transformed.add(id);
+            }
+        });
+    }
+    update(camera, time) {
+        const viewer = this.viewerStore.getState();
+        const scene = useScene.getState();
+        const wallIds = sceneRegistry.byType.wall;
+        const libraryVersion = getLibraryMaterialsVersion();
+        const textureVersion = getMaterialTextureVersion();
+        const previous = this.viewer;
+        const nodesChanged = this.nodes !== scene.nodes;
+        const registryChanged = this.registryRevision !== sceneRegistry.revision || this.wallCount !== wallIds.size;
+        let highlightChanged = false;
+        if (!previous ||
+            nodesChanged ||
+            previous.selection.selectedIds !== viewer.selection.selectedIds ||
+            previous.previewSelectedIds !== viewer.previewSelectedIds ||
+            previous.hoveredId !== viewer.hoveredId ||
+            previous.hoverHighlightMode !== viewer.hoverHighlightMode) {
+            this.selected = new Set([...viewer.selection.selectedIds, ...viewer.previewSelectedIds].filter((id) => scene.nodes[id]?.type === 'wall'));
+            const hovered = scene.nodes[viewer.hoveredId]?.type === 'wall' ? viewer.hoveredId : null;
+            const key = `${Array.from(this.selected).sort().join('|')}::${viewer.hoverHighlightMode === 'delete' ? (hovered ?? '') : ''}::${viewer.hoverHighlightMode === 'default' ? (hovered ?? '') : ''}`;
+            highlightChanged = key !== this.highlightKey;
+            this.highlightKey = key;
+        }
+        const appearanceChanged = !previous ||
+            highlightChanged ||
+            this.materials !== scene.materials ||
+            this.libraryVersion !== libraryVersion ||
+            (this.textureVersion !== textureVersion && this.selected.size > 0) ||
+            previous.wallMode !== viewer.wallMode ||
+            previous.shading !== viewer.shading ||
+            previous.textures !== viewer.textures ||
+            previous.colorPreset !== viewer.colorPreset ||
+            previous.sceneTheme !== viewer.sceneTheme;
+        const previewId = (state) => state && state.hoverHighlightMode !== 'default' && state.hoverHighlightMode !== 'delete'
+            ? state.hoveredId
+            : null;
+        const releasedPreview = previewId(previous) !== previewId(viewer) ? previewId(previous) : null;
+        this.viewer = viewer;
+        const invalidated = appearanceChanged ||
+            nodesChanged ||
+            registryChanged ||
+            this.rebuilt.size > 0 ||
+            this.transformed.size > 0 ||
+            releasedPreview !== null;
+        if (!invalidated && viewer.wallMode !== 'cutaway')
+            return;
+        camera.getWorldDirection(this.cameraDirection);
+        this.cameraTarget.copy(this.cameraDirection).add(camera.position);
+        const cameraChanged = viewer.wallMode === 'cutaway' &&
+            time - this.lastUpdateTime > 0.1 &&
+            (camera.position.distanceTo(this.lastCameraPosition) > 0.5 ||
+                this.cameraTarget.distanceTo(this.lastCameraTarget) > 0.3);
+        if (!invalidated && !cameraChanged)
+            return;
+        if (registryChanged || nodesChanged) {
+            for (const [id, wall] of this.walls) {
+                if (!wallIds.has(id) ||
+                    sceneRegistry.nodes.get(id) !== wall.mesh ||
+                    scene.nodes[id]?.type !== 'wall')
+                    this.walls.delete(id);
+            }
+        }
+        if (invalidated) {
+            const changedPaths = new Map();
+            const pathChanged = (id) => {
+                const cached = changedPaths.get(id);
+                if (cached !== undefined)
+                    return cached;
+                const node = scene.nodes[id];
+                const changed = this.transformed.has(id) ||
+                    (nodesChanged && this.nodes?.[id] !== node) ||
+                    !!(node?.parentId && pathChanged(node.parentId));
+                changedPaths.set(id, changed);
+                return changed;
+            };
+            const visited = new Set();
+            for (const id of wallIds) {
+                const node = scene.nodes[id];
+                if (node?.type !== 'wall')
+                    continue;
+                let wall = this.walls.get(id);
+                const added = !wall;
+                if (!wall) {
+                    const mesh = sceneRegistry.nodes.get(id);
+                    if (!mesh)
+                        continue;
+                    wall = {
+                        mesh,
+                        node,
+                        normal: new Vector3(),
+                        matrix: new Matrix4().makeScale(0, 0, 0),
+                        geometry: mesh.geometry,
+                        negativeFacing: undefined,
+                        hidden: undefined,
+                        variantKey: undefined,
+                        assignedMaterials: undefined,
+                        visibleVariant: { key: 'visible', materials: [] },
+                        hiddenVariant: { key: 'invisible', materials: [] },
+                    };
+                    this.walls.set(id, wall);
+                }
+                const changed = pathChanged(id);
+                const rebuilt = this.rebuilt.has(id);
+                if (added || changed || rebuilt)
+                    this.refreshNormal(wall, visited);
+                wall.node = node;
+                if (added || appearanceChanged || (nodesChanged && changed))
+                    this.refreshAppearance(wall);
+                if (added ||
+                    appearanceChanged ||
+                    changed ||
+                    rebuilt ||
+                    releasedPreview === id ||
+                    cameraChanged) {
+                    this.apply(wall, viewer.wallMode, added || appearanceChanged || (nodesChanged && changed));
+                }
+            }
+        }
+        else {
+            for (const wall of this.walls.values())
+                this.apply(wall, viewer.wallMode, false);
+        }
+        this.rebuilt.clear();
+        this.transformed.clear();
+        this.nodes = scene.nodes;
+        this.materials = scene.materials;
+        this.registryRevision = sceneRegistry.revision;
+        this.wallCount = wallIds.size;
+        this.libraryVersion = libraryVersion;
+        this.textureVersion = getMaterialTextureVersion();
+        if (appearanceChanged || cameraChanged) {
+            this.lastCameraPosition.copy(camera.position);
+            this.lastCameraTarget.copy(this.cameraTarget);
+            this.lastUpdateTime = time;
+        }
+    }
+    refreshAppearance(wall) {
+        const viewer = this.viewer;
+        const scene = useScene.getState();
+        const node = wall.node;
+        const deleted = viewer.hoverHighlightMode === 'delete' && viewer.hoveredId === node.id;
+        let selectionHighlighted = !deleted && this.selected.has(node.id);
+        if (selectionHighlighted) {
+            const levelId = resolveLevelId(node, scene.nodes);
+            const support = spatialGridManager.getSlabSupportForWall(levelId, node.start, node.end, node.curveOffset ?? 0, node.thickness, node.supportSlabId);
+            const height = resolveWallEffectiveHeight(node, getWallPlaneTop(node, levelId, scene.nodes), support.elevation);
+            selectionHighlighted = !getWallFaceBandConfig(node, height).enabled;
+        }
+        const materials = getMaterialsForWall(node, viewer.shading, viewer.textures, viewer.colorPreset, viewer.sceneTheme, scene.materials);
+        const variant = (hidden) => {
+            const key = resolveWallMaterialVariant({
+                translucentMode: viewer.wallMode === 'translucent',
+                hidden,
+                deleteHighlighted: deleted,
+                selectionHighlighted,
+                hoverHighlighted: viewer.hoverHighlightMode === 'default' && viewer.hoveredId === node.id,
+            });
+            return { key, materials: materialsForVariant(key, materials) };
+        };
+        wall.visibleVariant = variant(false);
+        wall.hiddenVariant = variant(true);
+    }
+    refreshNormal(wall, visited) {
+        const update = (object) => {
+            if (visited.has(object))
+                return;
+            if (object.parent)
+                update(object.parent);
+            object.updateWorldMatrix(false, false);
+            visited.add(object);
+        };
+        update(wall.mesh);
+        if (wall.matrix.equals(wall.mesh.matrixWorld) && wall.geometry === wall.mesh.geometry)
+            return;
+        wall.matrix.copy(wall.mesh.matrixWorld);
+        wall.geometry = wall.mesh.geometry;
+        wall.normal.setFromMatrixColumn(wall.matrix, 2).normalize();
+    }
+    apply(wall, mode, refresh) {
+        if (mode === 'cutaway') {
+            wall.negativeFacing = wallFacingNegative(wall.normal.dot(this.cameraDirection), wall.negativeFacing);
+        }
+        const hidden = wallHiddenFromFacing(wall.node, mode, wall.negativeFacing ?? false);
+        wall.hidden = hidden;
+        // The wall batch and pointer handlers consume this boolean, including
+        // false on stamp lift; translucent walls must continue receiving events.
+        const stamp = mode !== 'translucent' && hidden;
+        if (wall.mesh.userData.wallHidden !== stamp)
+            wall.mesh.userData.wallHidden = stamp;
+        const variant = hidden ? wall.hiddenVariant : wall.visibleVariant;
+        // Non-highlight hover owns a temporary material until its restore callback runs.
+        const viewer = this.viewer;
+        if (viewer.hoveredId === wall.node.id &&
+            viewer.hoverHighlightMode !== 'default' &&
+            viewer.hoverHighlightMode !== 'delete') {
+            if (refresh)
+                wall.variantKey = undefined;
+            return;
+        }
+        if (wall.variantKey !== variant.key || refresh) {
+            if (wall.mesh.material !== variant.materials &&
+                !sameMaterialArray(wall.mesh.material, variant.materials)) {
+                wall.mesh.material = variant.materials;
+            }
+            wall.variantKey = variant.key;
+            wall.assignedMaterials = wall.mesh.material;
+        }
+        else if (wall.mesh.material !== wall.assignedMaterials) {
+            wall.mesh.material = wall.assignedMaterials;
+        }
+    }
+}

package/dist/systems/wall/wall-cutout.d.ts

@@ -1,2 +1,25 @@
-export declare const WallCutout: () => null;
+import { type WallNode } from '@pascal-app/core';
+import type { Camera } from 'three';
+import { type Mesh, Vector3 } from 'three/webgpu';
+import { type WallMode } from '../../store/use-viewer';
+import { WallCutoutCache, type WallCutoutViewerStore } from './wall-cutout-cache';
+export declare const WALL_CUTOUT_FRAME_PRIORITY = 0;
+export declare function runWallCutoutFrame(cache: WallCutoutCache, { camera, clock }: {
+    camera: Camera;
+    clock: {
+        elapsedTime: number;
+    };
+}): void;
+/**
+ * Whether a wall should be hidden or see-through for the current camera and
+ * wall mode. Pure: reads only its arguments and the mesh's world direction.
+ *
+ * Exported so hosts rendering their own layers inside `<Viewer>` can match
+ * these semantics instead of re-deriving the facing test or inferring state
+ * from the assigned material variant.
+ */
+export declare function getWallHideState(wallNode: WallNode, wallMesh: Mesh, wallMode: WallMode, cameraDir: Vector3): boolean;
+export declare const WallCutout: ({ viewerStore, }: {
+    viewerStore?: WallCutoutViewerStore;
+}) => null;
 //# sourceMappingURL=wall-cutout.d.ts.map

package/dist/systems/wall/wall-cutout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-cutout.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout.tsx"],"names":[],"mappings":"AAyDA,eAAO,MAAM,UAAU,YAuLtB,CAAA"}
+{"version":3,"file":"wall-cutout.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-cutout.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAoD,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGlG,OAAO,KAAK,EAAE,MAAM,EAAY,MAAM,OAAO,CAAA;AAC7C,OAAO,EAAE,KAAK,IAAI,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACjD,OAAkB,EAAE,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AACjE,OAAO,EAEL,eAAe,EACf,KAAK,qBAAqB,EAE3B,MAAM,qBAAqB,CAAA;AAM5B,eAAO,MAAM,0BAA0B,IAAI,CAAA;AAE3C,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,eAAe,EACtB,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAE,WAAW,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,QAGtE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,IAAI,EACd,QAAQ,EAAE,QAAQ,EAClB,SAAS,EAAE,OAAO,GACjB,OAAO,CAKT;AAED,eAAO,MAAM,UAAU,GAAI,kBAExB;IACD,WAAW,CAAC,EAAE,qBAAqB,CAAA;CACpC,SA2DA,CAAA"}