@pascal-app/viewer 1.0.1 → 1.0.4

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

@@ -1 +1 @@
-{"version":3,"file":"item-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item/item-system.tsx"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,YA8CtB,CAAA"}
+{"version":3,"file":"item-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item/item-system.tsx"],"names":[],"mappings":"AAmBA;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,YAsDtB,CAAA"}

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

@@ -1,5 +1,7 @@
-import { sceneRegistry, useScene, } from '@pascal-app/core';
+import { getEffectiveNode, getWallBodyCenterOffset, getWallLocalFaceZ, sceneRegistry, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
+import { useEffect } from 'react';
+import { initializeObjectCutInvalidation } from './object-cut-invalidation';
 // ============================================================================
 // ITEM SYSTEM
 // ============================================================================
@@ -11,6 +13,7 @@ import { useFrame } from '@react-three/fiber';
  * mark at priority 2.
  */
 export const ItemSystem = () => {
+    useEffect(initializeObjectCutInvalidation, []);
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
     useFrame(() => {
@@ -25,6 +28,10 @@ export const ItemSystem = () => {
             const mesh = sceneRegistry.nodes.get(id);
             if (!mesh)
                 return;
+            const host = item.parentId ? nodes[item.parentId] : undefined;
+            if (item.asset.attachTo === 'wall' && host?.type === 'wall') {
+                mesh.position.z = item.position[2] + getWallBodyCenterOffset(getEffectiveNode(host));
+            }
             if (item.asset.attachTo === 'wall-side') {
                 // Wall-attached item: offset Z by half the host wall's thickness.
                 // Roof-segment wall faces share the convention — the face frame's
@@ -37,8 +44,7 @@ export const ItemSystem = () => {
                         ? (parent.wallThickness ?? 0.1)
                         : undefined;
                 if (thickness !== undefined) {
-                    const side = item.side === 'front' ? 1 : -1;
-                    mesh.position.z = (thickness / 2) * side;
+                    mesh.position.z = getWallLocalFaceZ(parent?.type === 'wall' ? getEffectiveNode(parent) : { thickness }, item.side === 'front' ? 'a' : 'b');
                 }
             }
             // Hold the mark until the model settles (loaded, terminally failed, or

package/dist/systems/item/object-cut-invalidation.d.ts

@@ -0,0 +1,3 @@
+/** Geometry remains derived; only dirty marks cross into the scene store. */
+export declare function initializeObjectCutInvalidation(): () => void;
+//# sourceMappingURL=object-cut-invalidation.d.ts.map

package/dist/systems/item/object-cut-invalidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-cut-invalidation.d.ts","sourceRoot":"","sources":["../../../src/systems/item/object-cut-invalidation.ts"],"names":[],"mappings":"AAUA,6EAA6E;AAC7E,wBAAgB,+BAA+B,eA6D9C"}

package/dist/systems/item/object-cut-invalidation.js

@@ -0,0 +1,68 @@
+import { getEffectiveCutterNode, resolveCutterHost, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
+/** Geometry remains derived; only dirty marks cross into the scene store. */
+export function initializeObjectCutInvalidation() {
+    let previous = new Map();
+    let cutterIds = [];
+    const collect = (nodes) => {
+        cutterIds = [];
+        for (const node of Object.values(nodes)) {
+            if (node.type === 'item' && node.source?.manifest.cutters?.length)
+                cutterIds.push(node.id);
+        }
+    };
+    // Drags fire every frame: a scene without cutters pays nothing here.
+    const refresh = () => {
+        if (!cutterIds.length && !previous.size)
+            return;
+        const state = useScene.getState();
+        const nodes = { ...state.nodes };
+        for (const id of new Set([
+            ...useLiveNodeOverrides.getState().overrides.keys(),
+            ...useLiveTransforms.getState().transforms.keys(),
+        ])) {
+            if (nodes[id])
+                nodes[id] = getEffectiveCutterNode(nodes[id]);
+        }
+        const owners = new Map();
+        for (const id of cutterIds) {
+            const node = nodes[id];
+            if (node?.type !== 'item' || !node.source?.manifest.cutters?.length)
+                continue;
+            for (const cutter of node.source.manifest.cutters) {
+                const host = resolveCutterHost(node, cutter.host === 'mounted' ? 'cutout' : `cut:${cutter.host}`, nodes);
+                if (!host)
+                    continue;
+                const entries = owners.get(host.id) ?? [];
+                entries.push([node.id, node.source.artifact, node.position, node.rotation, node.scale]);
+                owners.set(host.id, entries);
+            }
+        }
+        const next = new Map([...owners].map(([id, entries]) => [id, JSON.stringify(entries)]));
+        const changed = [...new Set([...previous.keys(), ...next.keys()])].filter((id) => previous.get(id) !== next.get(id));
+        previous = next;
+        for (const id of changed)
+            if (nodes[id])
+                state.markDirty(id);
+    };
+    collect(useScene.getState().nodes);
+    refresh();
+    const unsubscribeScene = useScene.subscribe((state, before) => {
+        if (state.nodes === before.nodes)
+            return;
+        collect(state.nodes);
+        refresh();
+    });
+    const unsubscribeLive = useLiveNodeOverrides.subscribe((state, before) => {
+        if (state.overrides !== before.overrides)
+            refresh();
+    });
+    const unsubscribeTransforms = useLiveTransforms.subscribe((state, before) => {
+        if (state.transforms !== before.transforms)
+            refresh();
+    });
+    return () => {
+        unsubscribeScene();
+        unsubscribeLive();
+        unsubscribeTransforms();
+    };
+}

package/dist/systems/item-light/item-light-system.d.ts

@@ -1,2 +1,2 @@
-export declare function ItemLightSystem(): import("react").JSX.Element;
+export declare function ItemLightSystem(): import("react").JSX.Element | null;
 //# sourceMappingURL=item-light-system.d.ts.map

package/dist/systems/item-light/item-light-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"item-light-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item-light/item-light-system.tsx"],"names":[],"mappings":"AAuFA,wBAAgB,eAAe,gCA8N9B"}
+{"version":3,"file":"item-light-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item-light/item-light-system.tsx"],"names":[],"mappings":"AAgGA,wBAAgB,eAAe,uCA0M9B"}

package/dist/systems/item-light/item-light-system.js

@@ -1,8 +1,9 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { findLevelAncestorId, sceneRegistry, useInteractive, useScene } from '@pascal-app/core';
-import { useFrame } from '@react-three/fiber';
+import { findLevelAncestorId, sceneRegistry, useScene } from '@pascal-app/core';
+import { useFrame, useThree } from '@react-three/fiber';
 import { useRef } from 'react';
 import { MathUtils, Vector3 } from 'three';
+import { SCENE_LAYER } from '../../lib/layers';
 import { useItemLightPool } from '../../store/use-item-light-pool';
 import useViewer from '../../store/use-viewer';
 const POOL_SIZE = 12;
@@ -19,22 +20,30 @@ const _dir = new Vector3();
 const _camPos = new Vector3();
 const _camFwd = new Vector3();
 const _itemPos = new Vector3();
-function scoreRegistration(reg, nodes, selectedLevelId, levelMode, interactiveState) {
-    // Skip lights that are toggled off — they contribute no illumination
-    if (reg.toggleIndex >= 0) {
-        const values = interactiveState.items[reg.nodeId]?.controlValues;
-        const isOn = Boolean(values?.[reg.toggleIndex]);
-        if (!isOn)
+function isRendered(nodeId) {
+    let object = sceneRegistry.nodes.get(nodeId);
+    if (!object?.layers.isEnabled(SCENE_LAYER))
+        return false;
+    while (object) {
+        if (!object.visible)
+            return false;
+        object = object.parent;
+    }
+    return true;
+}
+function scoreRegistration(reg, nodes, selectedLevelId, levelMode, hideAbove) {
+    if (!reg.isEligible() || !isRendered(reg.nodeId) || !reg.getWorldPosition(_itemPos))
+        return Number.POSITIVE_INFINITY;
+    const { nodeId } = reg;
+    let current = nodes[nodeId];
+    while (current) {
+        if (current.type !== 'site' && current.visible === false)
             return Number.POSITIVE_INFINITY;
+        current = current.parentId ? nodes[current.parentId] : undefined;
     }
-    const { nodeId, effect } = reg;
-    const obj = sceneRegistry.nodes.get(nodeId);
-    if (!obj)
+    const itemLevelId = findLevelAncestorId(nodeId, nodes);
+    if (selectedLevelId && itemLevelId !== selectedLevelId && levelMode === 'solo')
         return Number.POSITIVE_INFINITY;
-    obj.getWorldPosition(_itemPos);
-    _itemPos.x += effect.offset[0];
-    _itemPos.y += effect.offset[1];
-    _itemPos.z += effect.offset[2];
     _dir.copy(_itemPos).sub(_camPos).normalize();
     const dot = _camFwd.dot(_dir); // 1 = ahead, -1 = behind
     // Angular component (0 = dead ahead, 2 = directly behind)
@@ -42,12 +51,15 @@ function scoreRegistration(reg, nodes, selectedLevelId, levelMode, interactiveSt
     // Normalised distance component (assumes scenes < 200 units)
     const dist = _camPos.distanceTo(_itemPos) / 200;
     // ── Level factor ──────────────────────────────────────────────────────────
-    const itemLevelId = findLevelAncestorId(nodeId, nodes);
     let levelPenalty = 0;
     if (selectedLevelId) {
         if (itemLevelId !== selectedLevelId) {
-            // In solo mode items on other levels are invisible — deprioritize strongly
-            levelPenalty = levelMode === 'solo' ? 100 : 0.8;
+            // Items on hidden levels (every other one in solo, those above the
+            // selected one while editing) are invisible — deprioritize strongly
+            const itemIndex = nodes[itemLevelId]?.level ?? 0;
+            const selectedIndex = nodes[selectedLevelId]?.level ?? 0;
+            const hidden = levelMode === 'solo' || (hideAbove && itemIndex > selectedIndex);
+            levelPenalty = hidden ? 100 : 0.8;
         }
     }
     else if (itemLevelId) {
@@ -60,6 +72,8 @@ function scoreRegistration(reg, nodes, selectedLevelId, levelMode, interactiveSt
     return angular * 0.7 + dist * 0.3 + levelPenalty;
 }
 export function ItemLightSystem() {
+    const scene = useThree((state) => state.scene);
+    const bakedOwner = useItemLightPool((state) => state.bakedCanvases.has(scene));
     const lightRefs = useRef(Array.from({ length: POOL_SIZE }, () => null));
     const slots = useRef(Array.from({ length: POOL_SIZE }, () => ({ key: null, pendingKey: null, isFadingOut: false })));
     const reassignTimer = useRef(0);
@@ -67,9 +81,10 @@ export function ItemLightSystem() {
     const prevReassignCamPos = useRef(new Vector3());
     const prevReassignCamFwd = useRef(new Vector3(0, 0, -1));
     useFrame(({ camera }, delta) => {
+        if (bakedOwner)
+            return;
         const dt = Math.min(delta, 0.1);
         const { registrations } = useItemLightPool.getState();
-        const interactiveState = useInteractive.getState();
         // ── 1. Throttled priority reassignment ──────────────────────────────────
         camera.getWorldPosition(_camPos);
         camera.getWorldDirection(_camFwd);
@@ -86,12 +101,13 @@ export function ItemLightSystem() {
             const viewerState = useViewer.getState();
             const selectedLevelId = viewerState.selection.levelId;
             const levelMode = viewerState.levelMode;
+            const hideAbove = viewerState.hideLevelsAboveSelection;
             // Score every registration
             const scored = [];
             for (const [key, reg] of registrations) {
                 scored.push({
                     key,
-                    score: scoreRegistration(reg, nodes, selectedLevelId, levelMode, interactiveState),
+                    score: scoreRegistration(reg, nodes, selectedLevelId, levelMode, hideAbove),
                 });
             }
             scored.sort((a, b) => a.score - b.score);
@@ -155,8 +171,8 @@ export function ItemLightSystem() {
                         const light = lightRefs.current[freeSlot];
                         const reg = registrations.get(key);
                         if (light && reg) {
-                            light.color.set(reg.effect.color);
-                            light.distance = reg.effect.distance ?? 0;
+                            light.color.set(reg.color);
+                            light.distance = reg.distance;
                         }
                     }
                 }
@@ -183,19 +199,17 @@ export function ItemLightSystem() {
                 continue;
             // Fade-out phase: lerp intensity → 0, then complete the transition
             if (slot.isFadingOut) {
-                light.visible = true;
                 light.intensity = MathUtils.lerp(light.intensity, 0, dt * 12);
                 if (light.intensity < 0.01) {
                     light.intensity = 0;
-                    light.visible = false;
                     slot.isFadingOut = false;
                     slot.key = slot.pendingKey;
                     slot.pendingKey = null;
                     if (slot.key) {
                         const reg = registrations.get(slot.key);
                         if (reg) {
-                            light.color.set(reg.effect.color);
-                            light.distance = reg.effect.distance ?? 0;
+                            light.color.set(reg.color);
+                            light.distance = reg.distance;
                         }
                     }
                 }
@@ -204,45 +218,26 @@ export function ItemLightSystem() {
             if (!slot.key) {
                 // Idle slot — keep dark
                 light.intensity = 0;
-                light.visible = false;
                 continue;
             }
             const reg = registrations.get(slot.key);
             if (!reg) {
                 slot.key = null;
                 light.intensity = 0;
-                light.visible = false;
                 continue;
             }
-            // Snap world position each frame
-            const obj = sceneRegistry.nodes.get(reg.nodeId);
-            if (obj) {
-                obj.getWorldPosition(_itemPos);
-                const [ox, oy, oz] = reg.effect.offset;
-                light.position.set(_itemPos.x + ox, _itemPos.y + oy, _itemPos.z + oz);
-            }
-            // Compute target intensity
-            const values = interactiveState.items[reg.nodeId]?.controlValues;
-            const isOn = reg.toggleIndex >= 0 ? Boolean(values?.[reg.toggleIndex]) : true;
-            let t = 1;
-            if (reg.hasSlider) {
-                const raw = values?.[reg.sliderIndex] ?? reg.sliderMin;
-                t = (raw - reg.sliderMin) / (reg.sliderMax - reg.sliderMin);
-            }
-            const targetIntensity = isOn
-                ? MathUtils.lerp(reg.effect.intensityRange[0], reg.effect.intensityRange[1], t)
-                : reg.effect.intensityRange[0];
-            if (targetIntensity > 0) {
-                light.visible = true;
-            }
+            if (reg.getWorldPosition(_itemPos))
+                light.position.copy(_itemPos);
+            const targetIntensity = reg.isEligible() && isRendered(reg.nodeId) ? reg.getIntensity() : 0;
             light.intensity = MathUtils.lerp(light.intensity, targetIntensity, dt * 12);
             if (targetIntensity <= 0 && light.intensity < 0.01) {
                 light.intensity = 0;
-                light.visible = false;
             }
         }
-    });
-    return (_jsx(_Fragment, { children: Array.from({ length: POOL_SIZE }, (_, i) => (_jsx("pointLight", { castShadow: false, intensity: 0, visible: false, ref: (el) => {
+    }, 6);
+    if (bakedOwner)
+        return null;
+    return (_jsx(_Fragment, { children: Array.from({ length: POOL_SIZE }, (_, i) => (_jsx("pointLight", { castShadow: false, intensity: 0, visible: true, ref: (el) => {
                 lightRefs.current[i] = el;
             } }, i))) }));
 }

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

@@ -1 +1 @@
-{"version":3,"file":"level-system.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-system.tsx"],"names":[],"mappings":"AAcA,eAAO,MAAM,WAAW,YA6DvB,CAAA"}
+{"version":3,"file":"level-system.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-system.tsx"],"names":[],"mappings":"AAQA,eAAO,MAAM,WAAW,YA+DvB,CAAA"}

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

@@ -3,16 +3,13 @@ import { useFrame } from '@react-three/fiber';
 import { lerp } from 'three/src/math/MathUtils.js';
 import { applyShadowOnly, clearShadowOnly } from '../../lib/shadow-only';
 import useViewer from '../../store/use-viewer';
-import { EXPLODED_GAP } from './level-utils';
-// Levels currently in shadow-caster-only mode (solo hides them from the color
-// passes but keeps their sun shadows). Tracked so we can restore layer masks
-// exactly once on transition; apply re-runs every frame so meshes rebuilt
-// while hidden (theme/texture changes) get re-hidden.
-const shadowOnlyLevels = new WeakSet();
+import { EXPLODED_GAP, resolveLevelVisibility } from './level-utils';
+import { shadowOnlyLevels } from './shadow-only-levels';
 export const LevelSystem = () => {
     useFrame((_, delta) => {
         const nodes = useScene.getState().nodes;
         const levelMode = useViewer.getState().levelMode;
+        const hideAbove = useViewer.getState().hideLevelsAboveSelection;
         const selectedLevel = useViewer.getState().selection.levelId;
         const levelElevations = getLevelElevations(nodes);
         const entries = [];
@@ -42,23 +39,24 @@ export const LevelSystem = () => {
             // (blank viewport). Clamping keeps every step a contraction: identical
             // feel at 60 fps, exact snap instead of overshoot on slow frames.
             obj.position.y = lerp(obj.position.y, targetY, Math.min(1, delta * 12));
-            // Solo: hidden levels ABOVE the soloed one stay in the shadow map
-            // (shadow-caster-only) so the sun still shadows the soloed floor through
-            // them; levels below can't block the sun, so they plain-hide.
-            const hidden = levelMode === 'solo' && Boolean(selectedLevel) && level?.id !== selectedLevel;
-            const castsWhileHidden = hidden && selectedIndex !== undefined && index > selectedIndex;
-            if (castsWhileHidden) {
+            const { visible, shadowOnly } = resolveLevelVisibility({
+                levelMode,
+                hideAbove,
+                hasSelectedLevel: Boolean(selectedLevel),
+                isSelected: level?.id === selectedLevel,
+                index,
+                selectedIndex,
+                nodeVisible: level?.visible !== false,
+            });
+            if (shadowOnly) {
                 applyShadowOnly(obj);
                 shadowOnlyLevels.add(obj);
-                obj.visible = true;
             }
-            else {
-                if (shadowOnlyLevels.has(obj)) {
-                    clearShadowOnly(obj);
-                    shadowOnlyLevels.delete(obj);
-                }
-                obj.visible = !hidden;
+            else if (shadowOnlyLevels.has(obj)) {
+                clearShadowOnly(obj);
+                shadowOnlyLevels.delete(obj);
             }
+            obj.visible = visible;
         }
     }, 5); // Using a lower priority so it runs after transforms from other systems have settled
     return null;

package/dist/systems/level/level-utils.d.ts

@@ -7,9 +7,36 @@ export declare const EXPLODED_GAP = 5;
  * code framing a level must aim at the destination, not the moving target.
  */
 export declare function getLevelPresentationY(levelId: string, nodes: Record<string, unknown>, levelMode: 'stacked' | 'exploded' | 'solo' | 'manual'): number;
+/**
+ * Whether a level renders this frame, and whether it renders as a
+ * shadow-caster only.
+ *
+ * Two unrelated things hide a level and they do not compose: the author's own
+ * `visible` flag (the sidebar eye), which hides the floor outright, and
+ * presentation hiding — solo mode hides every level but the soloed one, and
+ * the editor's level display (`hideAbove`) hides the levels above the
+ * selected one. Presentation-hidden levels ABOVE the selected one stay in the
+ * shadow map so the sun still shadows the selected floor through them.
+ * A level the author hid never enters that shadow-caster branch: its shadows
+ * on the floor below would be exactly what hiding it was meant to remove.
+ */
+export declare function resolveLevelVisibility({ levelMode, hideAbove, hasSelectedLevel, isSelected, index, selectedIndex, nodeVisible, }: {
+    levelMode: 'stacked' | 'exploded' | 'solo' | 'manual';
+    hideAbove: boolean;
+    hasSelectedLevel: boolean;
+    isSelected: boolean;
+    index: number;
+    selectedIndex: number | undefined;
+    nodeVisible: boolean;
+}): {
+    visible: boolean;
+    shadowOnly: boolean;
+};
 /**
  * Instantly snaps all level Objects3D to their true stacked Y positions
- * (ignores levelMode — always uses stacked, no exploded gap).
+ * (ignores levelMode — always uses stacked, no exploded gap). Presentation
+ * hiding is undone with it, but a level the author hid stays hidden: the
+ * capture has to match the export, which prunes it.
  *
  * Returns a restore function that reverts each level's Y to what it was
  * before the snap, so lerp animations in LevelSystem can continue undisturbed.

package/dist/systems/level/level-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"level-utils.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,IAAI,CAAA;AAE7B;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GACpD,MAAM,CAKR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,IAAI,CAyCtD"}
+{"version":3,"file":"level-utils.d.ts","sourceRoot":"","sources":["../../../src/systems/level/level-utils.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,IAAI,CAAA;AAE7B;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GACpD,MAAM,CAKR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,SAAS,EACT,SAAS,EACT,gBAAgB,EAChB,UAAU,EACV,KAAK,EACL,aAAa,EACb,WAAW,GACZ,EAAE;IACD,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAA;IACrD,SAAS,EAAE,OAAO,CAAA;IAClB,gBAAgB,EAAE,OAAO,CAAA;IACzB,UAAU,EAAE,OAAO,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,aAAa,EAAE,MAAM,GAAG,SAAS,CAAA;IACjC,WAAW,EAAE,OAAO,CAAA;CACrB,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAQ5C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,IAAI,CA+CtD"}

package/dist/systems/level/level-utils.js

@@ -1,4 +1,6 @@
 import { getLevelElevations, sceneRegistry, useScene } from '@pascal-app/core';
+import { applyShadowOnly, clearShadowOnly } from '../../lib/shadow-only';
+import { shadowOnlyLevels } from './shadow-only-levels';
 export const EXPLODED_GAP = 5;
 /**
  * The Y a level settles at under the given presentation mode — its stacked
@@ -13,9 +15,32 @@ export function getLevelPresentationY(levelId, nodes, levelMode) {
     const explodedExtra = levelMode === 'exploded' && level ? level.level * EXPLODED_GAP : 0;
     return baseY + explodedExtra;
 }
+/**
+ * Whether a level renders this frame, and whether it renders as a
+ * shadow-caster only.
+ *
+ * Two unrelated things hide a level and they do not compose: the author's own
+ * `visible` flag (the sidebar eye), which hides the floor outright, and
+ * presentation hiding — solo mode hides every level but the soloed one, and
+ * the editor's level display (`hideAbove`) hides the levels above the
+ * selected one. Presentation-hidden levels ABOVE the selected one stay in the
+ * shadow map so the sun still shadows the selected floor through them.
+ * A level the author hid never enters that shadow-caster branch: its shadows
+ * on the floor below would be exactly what hiding it was meant to remove.
+ */
+export function resolveLevelVisibility({ levelMode, hideAbove, hasSelectedLevel, isSelected, index, selectedIndex, nodeVisible, }) {
+    if (!nodeVisible)
+        return { visible: false, shadowOnly: false };
+    const hidden = (levelMode === 'solo' && hasSelectedLevel && !isSelected) ||
+        (hideAbove && selectedIndex !== undefined && index > selectedIndex);
+    const shadowOnly = hidden && selectedIndex !== undefined && index > selectedIndex;
+    return { visible: shadowOnly || !hidden, shadowOnly };
+}
 /**
  * Instantly snaps all level Objects3D to their true stacked Y positions
- * (ignores levelMode — always uses stacked, no exploded gap).
+ * (ignores levelMode — always uses stacked, no exploded gap). Presentation
+ * hiding is undone with it, but a level the author hid stays hidden: the
+ * capture has to match the export, which prunes it.
  *
  * Returns a restore function that reverts each level's Y to what it was
  * before the snap, so lerp animations in LevelSystem can continue undisturbed.
@@ -35,17 +60,22 @@ export function snapLevelsToTruePositions() {
             entries.push({
                 levelId,
                 obj,
+                nodeVisible: level.visible !== false,
             });
         }
     });
     const levelElevations = getLevelElevations(nodes);
     // Snapshot current Y and visibility so we can restore them after the render
     const snapshot = new Map(entries.map(({ levelId, obj }) => [levelId, { y: obj.position.y, visible: obj.visible }]));
-    // Snap to true stacked positions and make all levels visible
-    for (const { levelId, obj } of entries) {
+    // Snap to true stacked positions and undo presentation hiding — including
+    // the levels kept shadow-caster-only above the selected level.
+    const shadowOnly = entries.filter(({ obj }) => shadowOnlyLevels.has(obj));
+    for (const { levelId, obj, nodeVisible } of entries) {
         obj.position.y = levelElevations.get(levelId)?.baseY ?? 0;
-        obj.visible = true;
+        obj.visible = nodeVisible;
     }
+    for (const { obj } of shadowOnly)
+        clearShadowOnly(obj);
     return () => {
         for (const { levelId, obj } of entries) {
             const saved = snapshot.get(levelId);
@@ -54,5 +84,7 @@ export function snapLevelsToTruePositions() {
                 obj.visible = saved.visible;
             }
         }
+        for (const { obj } of shadowOnly)
+            applyShadowOnly(obj);
     };
 }

package/dist/systems/level/shadow-only-levels.d.ts

@@ -0,0 +1,9 @@
+import type { Object3D } from 'three';
+/**
+ * Levels currently in shadow-caster-only mode (hidden above the selected level
+ * by solo or by the editor's level display). Tracked so layer masks are
+ * restored exactly once on transition, and so a full-building capture can
+ * show them for its one render.
+ */
+export declare const shadowOnlyLevels: WeakSet<Object3D<import("three").Object3DEventMap>>;
+//# sourceMappingURL=shadow-only-levels.d.ts.map

package/dist/systems/level/shadow-only-levels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadow-only-levels.d.ts","sourceRoot":"","sources":["../../../src/systems/level/shadow-only-levels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,qDAA0B,CAAA"}

package/dist/systems/level/shadow-only-levels.js

@@ -0,0 +1,7 @@
+/**
+ * Levels currently in shadow-caster-only mode (hidden above the selected level
+ * by solo or by the editor's level display). Tracked so layer masks are
+ * restored exactly once on transition, and so a full-building capture can
+ * show them for its one render.
+ */
+export const shadowOnlyLevels = new WeakSet();

package/dist/systems/roof/roof-materials.d.ts

@@ -1,6 +1,18 @@
-import { type RoofNode } from '@pascal-app/core';
+import { type AnyNode, type RoofNode, type SceneMaterial, type SceneMaterialId } from '@pascal-app/core';
 import type * as THREE from 'three';
 import { type ColorPreset, type RenderShading } from '../../lib/materials';
+type SceneMaterials = Record<SceneMaterialId, SceneMaterial> | undefined;
 export type RoofMaterialArray = [THREE.Material, THREE.Material, THREE.Material, THREE.Material];
-export declare function getRoofMaterialArray(node: RoofNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): RoofMaterialArray | null;
+/**
+ * The cladding the walls under a roof declare through their ASSEMBLIES
+ * (`wall.assembly.exterior.finish` → catalog ref), so the roof's gable band —
+ * the triangle of wall above the plate that the roof kind builds — is skinned
+ * like the walls it sits on instead of the bare drywall default. The most
+ * common ref among the level's walls wins; null when none declares one.
+ */
+export declare function levelWallCladdingRef(nodes: Readonly<Record<string, AnyNode | undefined>>, roof: Pick<RoofNode, 'parentId'>): string | null;
+export declare function getRoofMaterialArray(node: RoofNode, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string, 
+/** Catalog ref for the gable/trim band when unpainted — see `levelWallCladdingRef`. */
+wallCladdingRef?: string | null, sceneMaterials?: SceneMaterials): RoofMaterialArray | null;
+export {};
 //# sourceMappingURL=roof-materials.d.ts.map

package/dist/systems/roof/roof-materials.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AACnC,OAAO,EACL,KAAK,WAAW,EAIhB,KAAK,aAAa,EAEnB,MAAM,qBAAqB,CAAA;AAa5B,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AA6BhG,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,iBAAiB,GAAG,IAAI,CAsE1B"}
+{"version":3,"file":"roof-materials.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-materials.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,QAAQ,EAEb,KAAK,aAAa,EAClB,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AACnC,OAAO,EACL,KAAK,WAAW,EAGhB,KAAK,aAAa,EAGnB,MAAM,qBAAqB,CAAA;AAE5B,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,GAAG,SAAS,CAAA;AAaxE,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;AAqChG;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,EACpD,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,GAC/B,MAAM,GAAG,IAAI,CAkBf;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM;AACnB,uFAAuF;AACvF,eAAe,GAAE,MAAM,GAAG,IAAW,EACrC,cAAc,CAAC,EAAE,cAAc,GAC9B,iBAAiB,GAAG,IAAI,CAyE1B"}