@pascal-app/viewer 0.7.0 → 0.9.1

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

@@ -1,5 +1,5 @@
-import { useFrame } from '@react-three/fiber';
 import { getWallCurveFrameAt, getWallCurveLength, 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';
 const MIN_CURVE_SEGMENT_LENGTH = 0.18;
@@ -111,6 +111,7 @@ function createFenceParts(fence) {
     const spacing = Math.max(fence.postSpacing * styleDefaults.spacingFactor, postWidth * 1.2);
     const edgeInset = Math.max(fence.edgeInset ?? 0.015, 0.005);
     const isFloating = fence.baseStyle === 'floating';
+    const showInfill = fence.showInfill ?? true;
     const baseY = isFloating ? clearance : 0;
     const effectiveBaseHeight = baseHeight;
     const startInsetT = Math.min(0.499, edgeInset / length);
@@ -119,16 +120,17 @@ function createFenceParts(fence) {
         parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight / 2, effectiveBaseHeight, panelDepth * 1.05));
         parts.push(...createFenceCurveSpanParts(fence, 0, 1, baseY + effectiveBaseHeight + verticalHeight * 0.15, topRailHeight * 0.8, panelDepth * 0.35));
     }
-    const count = Math.max(2, Math.floor((length - edgeInset * 2) / spacing) + 1);
+    const count = showInfill ? Math.max(2, Math.floor((length - edgeInset * 2) / spacing) + 1) : 2;
     const verticalY = baseY + effectiveBaseHeight + verticalHeight / 2;
     for (let index = 0; index < count; index += 1) {
         const t = count === 1 ? 0.5 : startInsetT + (endInsetT - startInsetT) * (index / (count - 1));
         const frame = getFencePointAt(fence, t);
         const isEdgePost = index === 0 || index === count - 1;
-        const postHeight = isFloating && isEdgePost
+        const fullHeightPost = !showInfill || (isFloating && isEdgePost);
+        const postHeight = fullHeightPost
             ? effectiveBaseHeight + verticalHeight + topRailHeight + clearance
             : verticalHeight;
-        const postY = isFloating && isEdgePost ? postHeight / 2 : verticalY;
+        const postY = fullHeightPost ? postHeight / 2 : verticalY;
         parts.push({
             position: [frame.point.x, postY, frame.point.y],
             rotationY: -frame.tangentAngle,
@@ -141,11 +143,13 @@ function createFenceParts(fence) {
     }
     return parts;
 }
-function generateFenceGeometry(fence) {
+export function generateFenceGeometry(fence) {
     const parts = createFenceParts(fence);
     const geometries = parts.map(createFencePartGeometry);
     const merged = mergeGeometries(geometries, false) ?? new THREE.BufferGeometry();
-    geometries.forEach((geometry) => geometry.dispose());
+    geometries.forEach((geometry) => {
+        geometry.dispose();
+    });
     const mergedUv = merged.getAttribute('uv');
     if (mergedUv) {
         merged.setAttribute('uv2', new THREE.Float32BufferAttribute(Array.from(mergedUv.array), 2));

package/dist/systems/floor-elevation/floor-elevation-system.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Generic floor-elevation system.
+ *
+ * Walks `dirtyNodes` and, for any kind that declares
+ * `capabilities.floorPlaced`, lifts the registered mesh's Y by whatever
+ * slab the footprint overlaps. Items / shelves / etc. that sit directly
+ * on a level pick this up automatically — no per-kind elevation logic.
+ *
+ * Skips nodes whose parent is not a level (items hosted on shelves /
+ * tables inherit Y from the parent group), and respects
+ * `floorPlaced.applies` so items with `asset.attachTo` (wall / ceiling
+ * mounted) are left alone.
+ *
+ * Runs at priority 1 — before the priority-2 systems (`GeometrySystem`,
+ * `ItemSystem`) so the dirty mark survives long enough for those to do
+ * their own work. Kinds with no geometry/system have no downstream dirty
+ * consumer, so this system clears their dirty mark after applying the lift.
+ */
+export declare const FloorElevationSystem: () => null;
+//# sourceMappingURL=floor-elevation-system.d.ts.map

package/dist/systems/floor-elevation/floor-elevation-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-elevation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/floor-elevation/floor-elevation-system.tsx"],"names":[],"mappings":"AAwCA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB,YA6ChC,CAAA"}

package/dist/systems/floor-elevation/floor-elevation-system.js

@@ -0,0 +1,78 @@
+import { getEffectiveNode, getFloorStackedPosition, nodeRegistry, sceneRegistry, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+function withLiveTransform(node, id) {
+    const liveTransform = useLiveTransforms.getState().get(id);
+    if (!liveTransform)
+        return node;
+    const currentRotation = node.rotation;
+    const rotation = Array.isArray(currentRotation)
+        ? [currentRotation[0] ?? 0, liveTransform.rotation, currentRotation[2] ?? 0]
+        : typeof currentRotation === 'number'
+            ? liveTransform.rotation
+            : currentRotation;
+    return {
+        ...node,
+        position: liveTransform.position,
+        ...(rotation !== undefined ? { rotation } : {}),
+    };
+}
+/**
+ * Generic floor-elevation system.
+ *
+ * Walks `dirtyNodes` and, for any kind that declares
+ * `capabilities.floorPlaced`, lifts the registered mesh's Y by whatever
+ * slab the footprint overlaps. Items / shelves / etc. that sit directly
+ * on a level pick this up automatically — no per-kind elevation logic.
+ *
+ * Skips nodes whose parent is not a level (items hosted on shelves /
+ * tables inherit Y from the parent group), and respects
+ * `floorPlaced.applies` so items with `asset.attachTo` (wall / ceiling
+ * mounted) are left alone.
+ *
+ * Runs at priority 1 — before the priority-2 systems (`GeometrySystem`,
+ * `ItemSystem`) so the dirty mark survives long enough for those to do
+ * their own work. Kinds with no geometry/system have no downstream dirty
+ * consumer, so this system clears their dirty mark after applying the lift.
+ */
+export const FloorElevationSystem = () => {
+    const dirtyNodes = useScene((s) => s.dirtyNodes);
+    const clearDirty = useScene((s) => s.clearDirty);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node)
+                return;
+            const def = nodeRegistry.get(node.type);
+            const floorPlaced = def?.capabilities?.floorPlaced;
+            if (!floorPlaced)
+                return;
+            const mesh = sceneRegistry.nodes.get(id);
+            if (!mesh)
+                return;
+            const effectiveNode = withLiveTransform(getEffectiveNode(node), id);
+            const position = effectiveNode.position;
+            if (!position)
+                return;
+            // This system is the single drag-time authority for floor-stack mesh Y:
+            // tools publish base positions to live stores, renderers may
+            // reconcile that base Y onto the group, then this presentation system
+            // reapplies the resolver-derived visual Y before render. Because the
+            // override/store position remains base-height, the slab lift is never
+            // committed or applied twice.
+            const resolverNodes = effectiveNode === node ? nodes : { ...nodes, [effectiveNode.id]: effectiveNode };
+            const visualPosition = getFloorStackedPosition({
+                node: effectiveNode,
+                nodes: resolverNodes,
+                position,
+            });
+            mesh.position.y = visualPosition[1];
+            if (!(def.geometry || def.system)) {
+                clearDirty(id);
+            }
+        });
+    }, 1);
+    return null;
+};

package/dist/systems/geometry/geometry-system.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Generic geometry system.
+ *
+ * For every node in `dirtyNodes` whose definition exposes `def.geometry`,
+ * this system:
+ *  1. Looks up the registered `Group` from `sceneRegistry` (mounted by the
+ *     framework's `<ParametricNodeRenderer>`, or a custom renderer that
+ *     opts into the same mount contract).
+ *  2. Builds a `GeometryContext` from the current scene snapshot.
+ *  3. Calls `def.geometry(node, ctx)` to get the new `Object3D`.
+ *  4. Disposes the registered group's existing children + their geometries
+ *     and materials.
+ *  5. Reparents the returned object's children onto the registered group.
+ *  6. Clears the dirty flag.
+ *
+ * This is the "no per-kind system needed" path documented in
+ * `wiki/architecture/node-definitions.md`. A kind that only rebuilds on
+ * dirty (shelf, item, fence segment, etc.) ships nothing more than a pure
+ * `geometry` function — no `renderer.tsx`, no `system.tsx`.
+ *
+ * Kinds with `def.system` declared run their own systems *in addition* to
+ * this one — animation + cascade + named-mesh material poking stay
+ * kind-specific.
+ *
+ * Frame priority 2 mirrors the per-kind shelf system it replaces. Door
+ * animation systems run at priority 2 today too, marking dirty so the
+ * geometry rebuild lands at priority 3-4 next frame. Door/window/wall
+ * still have their own systems (they need cross-cutting work this system
+ * doesn't cover) — they coexist; this system only acts on kinds that
+ * declare `def.geometry`.
+ */
+export declare const GeometrySystem: () => null;
+export default GeometrySystem;
+//# sourceMappingURL=geometry-system.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry-system.d.ts","sourceRoot":"","sources":["../../../src/systems/geometry/geometry-system.tsx"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,cAAc,YAwK1B,CAAA;AAyHD,eAAe,cAAc,CAAA"}

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

@@ -0,0 +1,279 @@
+'use client';
+import { getEffectiveNode, nodeRegistry, sceneRegistry, useScene, } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
+import { FrontSide } from 'three';
+import { createSurfaceRoleMaterial, } from '../../lib/materials';
+import useViewer from '../../store/use-viewer';
+/**
+ * Generic geometry system.
+ *
+ * For every node in `dirtyNodes` whose definition exposes `def.geometry`,
+ * this system:
+ *  1. Looks up the registered `Group` from `sceneRegistry` (mounted by the
+ *     framework's `<ParametricNodeRenderer>`, or a custom renderer that
+ *     opts into the same mount contract).
+ *  2. Builds a `GeometryContext` from the current scene snapshot.
+ *  3. Calls `def.geometry(node, ctx)` to get the new `Object3D`.
+ *  4. Disposes the registered group's existing children + their geometries
+ *     and materials.
+ *  5. Reparents the returned object's children onto the registered group.
+ *  6. Clears the dirty flag.
+ *
+ * This is the "no per-kind system needed" path documented in
+ * `wiki/architecture/node-definitions.md`. A kind that only rebuilds on
+ * dirty (shelf, item, fence segment, etc.) ships nothing more than a pure
+ * `geometry` function — no `renderer.tsx`, no `system.tsx`.
+ *
+ * Kinds with `def.system` declared run their own systems *in addition* to
+ * this one — animation + cascade + named-mesh material poking stay
+ * kind-specific.
+ *
+ * Frame priority 2 mirrors the per-kind shelf system it replaces. Door
+ * animation systems run at priority 2 today too, marking dirty so the
+ * geometry rebuild lands at priority 3-4 next frame. Door/window/wall
+ * still have their own systems (they need cross-cutting work this system
+ * doesn't cover) — they coexist; this system only acts on kinds that
+ * declare `def.geometry`.
+ */
+export const GeometrySystem = () => {
+    const dirtyNodes = useScene((s) => s.dirtyNodes);
+    const clearDirty = useScene((s) => s.clearDirty);
+    const shading = useViewer((s) => s.shading);
+    const textures = useViewer((s) => s.textures);
+    const colorPreset = useViewer((s) => s.colorPreset);
+    const sceneTheme = useViewer((s) => s.sceneTheme);
+    // Per-node cache of the last-built geometry key (for kinds that declare
+    // `def.geometryKey`). Lets us skip a dispose+rebuild when a node is dirty
+    // but its geometry inputs are unchanged — e.g. an item reparenting onto a
+    // shelf dirties the shelf without altering its boards.
+    const builtGeometryKeyRef = useRef(new Map());
+    useEffect(() => {
+        const nodes = useScene.getState().nodes;
+        for (const node of Object.values(nodes)) {
+            const def = nodeRegistry.get(node.type);
+            if (def?.geometry) {
+                useScene.getState().markDirty(node.id);
+            }
+        }
+    }, [shading, textures, colorPreset, sceneTheme]);
+    useFrame(() => {
+        if (dirtyNodes.size === 0)
+            return;
+        const nodes = useScene.getState().nodes;
+        const batches = new Map();
+        const dirtyIds = [];
+        dirtyNodes.forEach((id) => {
+            const node = nodes[id];
+            if (!node)
+                return;
+            const def = nodeRegistry.get(node.type);
+            if (!def?.geometry)
+                return;
+            dirtyIds.push(id);
+            const parentId = (node.parentId ?? null);
+            const key = `${node.type}::${parentId ?? ''}`;
+            const existing = batches.get(key);
+            if (existing)
+                existing.ids.push(id);
+            else
+                batches.set(key, { kind: node.type, parentId, ids: [id] });
+        });
+        // Phase 2 — for each batch whose kind declares `computeLevelData`,
+        // collect every sibling in the level + run the precompute once.
+        const levelDataByBatch = new Map();
+        for (const [key, batch] of batches) {
+            const def = nodeRegistry.get(batch.kind);
+            if (!def?.computeLevelData)
+                continue;
+            const siblings = [];
+            if (batch.parentId) {
+                const parent = nodes[batch.parentId];
+                const childIds = parent?.children;
+                if (Array.isArray(childIds)) {
+                    for (const cid of childIds) {
+                        const child = nodes[cid];
+                        if (child?.type === batch.kind)
+                            siblings.push(child);
+                    }
+                }
+            }
+            else {
+                for (const node of Object.values(nodes)) {
+                    if (node?.type === batch.kind && !node.parentId)
+                        siblings.push(node);
+                }
+            }
+            levelDataByBatch.set(key, def.computeLevelData(siblings));
+        }
+        // Phase 3 — per-node rebuild. Each node receives its batch's
+        // precomputed `levelData` in ctx.
+        for (const id of dirtyIds) {
+            const node = nodes[id];
+            if (!node)
+                continue;
+            const def = nodeRegistry.get(node.type);
+            const builder = def?.geometry;
+            if (!builder)
+                continue;
+            const group = sceneRegistry.nodes.get(id);
+            if (!group)
+                continue; // mount hasn't run — keep dirty for next frame
+            // Merge any live drag override into the node so resize arrows /
+            // 2D affordances see their in-flight patch on every pointer move
+            // — zustand only learns about the final value on commit. Mirrors
+            // the WallSystem / DoorSystem / WindowSystem hook-up; any kind
+            // that drives its mesh through `def.geometry` (fence, shelf, item)
+            // now smooths drags through this single line.
+            const effectiveNode = getEffectiveNode(node);
+            // Skip the rebuild when the geometry inputs are unchanged (kinds that
+            // opt in via `def.geometryKey`). Fold in the global rendering inputs so
+            // a theme / shading change — which re-dirties every geometry node — is
+            // never skipped. This kills the board remount + pointer enter/leave
+            // churn when an item reparents onto a shelf.
+            if (def.geometryKey) {
+                const builtKey = `${shading}|${textures}|${colorPreset}|${sceneTheme}|${def.geometryKey(effectiveNode)}`;
+                if (builtGeometryKeyRef.current.get(id) === builtKey) {
+                    clearDirty(id);
+                    continue;
+                }
+                builtGeometryKeyRef.current.set(id, builtKey);
+            }
+            const parentId = (node.parentId ?? null);
+            const key = `${node.type}::${parentId ?? ''}`;
+            const levelData = levelDataByBatch.get(key);
+            const ctx = buildGeometryContext(effectiveNode, nodes, levelData);
+            // The builder is typed against the kind's specific node — at the
+            // generic system level we lose that refinement, so the cast lands
+            // here. Builders are responsible for trusting their schema.
+            const built = builder(effectiveNode, ctx, shading, textures, colorPreset, sceneTheme);
+            if (!textures && def.surfaceRole) {
+                applyDefaultSurfaceRole(built, def.surfaceRole, colorPreset, sceneTheme);
+            }
+            disposeChildren(group);
+            for (const child of [...built.children]) {
+                // Tag every child the builder produced so a subsequent rebuild
+                // can dispose only THIS rebuild's outputs and leave React-
+                // mounted siblings (hosted items inside a shelf / slab / etc.)
+                // alone. Without this, a parent rebuild triggered by a child
+                // event (e.g. an item reparenting onto a shelf calls
+                // `dirtyNodes.add(parent)` in `ItemRenderer`'s effect) would
+                // wipe ALL of the parent group's children — including the
+                // freshly-mounted item — leaving the item in scene state but
+                // invisible.
+                ;
+                child.userData = {
+                    ...child.userData,
+                    __fromGeometry: true,
+                };
+                group.add(child);
+            }
+            // NOTE: we intentionally do NOT reset `group.position` / `group.rotation`
+            // here. The `ParametricNodeRenderer` binds them via JSX (`position={...}`
+            // / `rotation={...}`) driven by `useLiveTransforms` during drag and
+            // `node.position` / `node.rotation` after commit. Zeroing them out
+            // during a rebuild would clobber the React-applied transform — and
+            // because the renderer doesn't necessarily re-render on the rebuild
+            // tick, R3F wouldn't re-apply the props, leaving the group stuck at
+            // origin. Geometry builders are expected to emit local-space children.
+            clearDirty(id);
+        }
+    }, 2);
+    return null;
+};
+function buildGeometryContext(node, nodes, levelData) {
+    const resolve = (id) => nodes[id];
+    const childIds = node.children;
+    const children = Array.isArray(childIds)
+        ? childIds.map((cid) => nodes[cid]).filter((n) => n !== undefined)
+        : [];
+    const parentId = node.parentId;
+    const parent = parentId ? (nodes[parentId] ?? null) : null;
+    // Siblings = same kind, same parent, excluding self. Walks the parent's
+    // children array; falls back to scanning the whole scene if the parent
+    // doesn't carry a `children` list (rare — most parents do).
+    let siblings = [];
+    if (parent) {
+        const parentChildIds = parent.children;
+        if (Array.isArray(parentChildIds)) {
+            for (const sid of parentChildIds) {
+                if (sid === node.id)
+                    continue;
+                const s = nodes[sid];
+                if (s && s.type === node.type)
+                    siblings.push(s);
+            }
+        }
+        else {
+            siblings = Object.values(nodes).filter((n) => n !== node && n.type === node.type && n.parentId === parentId);
+        }
+    }
+    return { resolve, children, siblings, parent, levelData };
+}
+function disposeChildren(group) {
+    // Only dispose meshes the geometry builder produced on the previous
+    // rebuild (marked via `userData.__fromGeometry`). React-managed
+    // children (hosted node renderers) get left in place — they have
+    // their own React-driven lifecycle and would lose their meshes /
+    // materials if we disposed them here.
+    for (const child of [...group.children]) {
+        const fromGeometry = child.userData
+            ?.__fromGeometry;
+        if (!fromGeometry)
+            continue;
+        group.remove(child);
+        const mesh = child;
+        if (mesh.geometry?.dispose)
+            mesh.geometry.dispose();
+        if ('material' in mesh) {
+            const m = mesh.material;
+            if (Array.isArray(m)) {
+                for (const mat of m) {
+                    if (isCachedMaterial(mat))
+                        continue;
+                    if (mat && typeof mat.dispose === 'function') {
+                        ;
+                        mat.dispose();
+                    }
+                }
+            }
+            else if (isCachedMaterial(m)) {
+            }
+            else if (m && typeof m.dispose === 'function') {
+                ;
+                m.dispose();
+            }
+        }
+    }
+}
+function applyDefaultSurfaceRole(root, defaultRole, colorPreset, sceneTheme) {
+    root.traverse((child) => {
+        const mesh = child;
+        if (!('material' in mesh) || !mesh.material)
+            return;
+        const role = getMeshSurfaceRole(mesh.userData.surfaceRole, defaultRole);
+        mesh.userData.surfaceRole = role;
+        mesh.material = createSurfaceRoleMaterial(role, colorPreset, getMaterialSide(mesh.material), sceneTheme);
+    });
+}
+function getMeshSurfaceRole(value, fallback) {
+    return typeof value === 'string' && isSurfaceRole(value) ? value : fallback;
+}
+function isSurfaceRole(value) {
+    return (value === 'wall' ||
+        value === 'floor' ||
+        value === 'ceiling' ||
+        value === 'roof' ||
+        value === 'joinery' ||
+        value === 'glazing' ||
+        value === 'furnishing');
+}
+function getMaterialSide(material) {
+    const source = Array.isArray(material) ? material[0] : material;
+    return source?.side ?? FrontSide;
+}
+function isCachedMaterial(value) {
+    return Boolean(value?.userData
+        ?.__pascalCachedMaterial);
+}
+export default GeometrySystem;

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

@@ -1 +1 @@
-{"version":3,"file":"guide-system.d.ts","sourceRoot":"","sources":["../../../src/systems/guide/guide-system.tsx"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,YAsCvB,CAAA"}
+{"version":3,"file":"guide-system.d.ts","sourceRoot":"","sources":["../../../src/systems/guide/guide-system.tsx"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,YAcvB,CAAA"}

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

@@ -1,4 +1,4 @@
-import { emitter, sceneRegistry } from '@pascal-app/core';
+import { sceneRegistry } from '@pascal-app/core';
 import { useEffect } from 'react';
 import useViewer from '../../store/use-viewer';
 export const GuideSystem = () => {
@@ -12,30 +12,5 @@ export const GuideSystem = () => {
             }
         });
     }, [showGuides]);
-    useEffect(() => {
-        const hideForCapture = () => {
-            const guides = sceneRegistry.byType.guide || new Set();
-            guides.forEach((guideId) => {
-                const node = sceneRegistry.nodes.get(guideId);
-                if (node)
-                    node.visible = false;
-            });
-        };
-        const restoreAfterCapture = () => {
-            const showGuidesNow = useViewer.getState().showGuides;
-            const guides = sceneRegistry.byType.guide || new Set();
-            guides.forEach((guideId) => {
-                const node = sceneRegistry.nodes.get(guideId);
-                if (node)
-                    node.visible = showGuidesNow;
-            });
-        };
-        emitter.on('thumbnail:before-capture', hideForCapture);
-        emitter.on('thumbnail:after-capture', restoreAfterCapture);
-        return () => {
-            emitter.off('thumbnail:before-capture', hideForCapture);
-            emitter.off('thumbnail:after-capture', restoreAfterCapture);
-        };
-    }, []);
     return null;
 };

package/dist/systems/interactive/interactive-system.d.ts

@@ -1,2 +1,2 @@
-export declare const InteractiveSystem: () => import("react/jsx-runtime").JSX.Element;
+export declare const InteractiveSystem: () => import("react").JSX.Element;
 //# sourceMappingURL=interactive-system.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"interactive-system.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/interactive-system.tsx"],"names":[],"mappings":"AAwBA,eAAO,MAAM,iBAAiB,+CAgB7B,CAAA"}
+{"version":3,"file":"interactive-system.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/interactive-system.tsx"],"names":[],"mappings":"AAwBA,eAAO,MAAM,iBAAiB,mCAgB7B,CAAA"}

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

@@ -1,2 +1,9 @@
+/**
+ * Per-frame wall-side offset for items mounted to wall faces. The slab-
+ * elevation lift for floor items lives in the generic
+ * `<FloorElevationSystem>` and runs at priority 1 — it has already
+ * landed `mesh.position.y` by the time this system clears the dirty
+ * mark at priority 2.
+ */
 export declare const ItemSystem: () => null;
 //# sourceMappingURL=item-system.d.ts.map

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":"AAiBA,eAAO,MAAM,UAAU,YA6CtB,CAAA"}
+{"version":3,"file":"item-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item/item-system.tsx"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,YA+BtB,CAAA"}

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

@@ -1,8 +1,15 @@
+import { sceneRegistry, useScene, } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
-import { getScaledDimensions, resolveLevelId, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
 // ============================================================================
 // ITEM SYSTEM
 // ============================================================================
+/**
+ * Per-frame wall-side offset for items mounted to wall faces. The slab-
+ * elevation lift for floor items lives in the generic
+ * `<FloorElevationSystem>` and runs at priority 1 — it has already
+ * landed `mesh.position.y` by the time this system clears the dirty
+ * mark at priority 2.
+ */
 export const ItemSystem = () => {
     const dirtyNodes = useScene((state) => state.dirtyNodes);
     const clearDirty = useScene((state) => state.clearDirty);
@@ -27,16 +34,6 @@ export const ItemSystem = () => {
                     mesh.position.z = (wallThickness / 2) * side;
                 }
             }
-            else if (!item.asset.attachTo) {
-                // If parented to another item (surface placement), R3F handles positioning via the hierarchy
-                const parentNode = item.parentId ? nodes[item.parentId] : undefined;
-                if (parentNode?.type !== 'item') {
-                    // Floor item: elevate by slab height (using full footprint overlap)
-                    const levelId = resolveLevelId(item, nodes);
-                    const slabElevation = spatialGridManager.getSlabElevationForItem(levelId, item.position, getScaledDimensions(item), item.rotation);
-                    mesh.position.y = slabElevation + item.position[1];
-                }
-            }
             clearDirty(id);
         });
     }, 2);

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

@@ -1,2 +1,2 @@
-export declare function ItemLightSystem(): import("react/jsx-runtime").JSX.Element;
+export declare function ItemLightSystem(): import("react").JSX.Element;
 //# 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":"AAwFA,wBAAgB,eAAe,4CA+M9B"}
+{"version":3,"file":"item-light-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item-light/item-light-system.tsx"],"names":[],"mappings":"AAuFA,wBAAgB,eAAe,gCA8N9B"}

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

@@ -1,5 +1,5 @@
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { sceneRegistry, useInteractive, useScene } from '@pascal-app/core';
+import { findLevelAncestorId, sceneRegistry, useInteractive, useScene } from '@pascal-app/core';
 import { useFrame } from '@react-three/fiber';
 import { useRef } from 'react';
 import { MathUtils, Vector3 } from 'three';
@@ -42,8 +42,7 @@ function scoreRegistration(reg, nodes, selectedLevelId, levelMode, interactiveSt
     // Normalised distance component (assumes scenes < 200 units)
     const dist = _camPos.distanceTo(_itemPos) / 200;
     // ── Level factor ──────────────────────────────────────────────────────────
-    const node = nodes[nodeId];
-    const itemLevelId = node?.parentId ?? null;
+    const itemLevelId = findLevelAncestorId(nodeId, nodes);
     let levelPenalty = 0;
     if (selectedLevelId) {
         if (itemLevelId !== selectedLevelId) {
@@ -97,7 +96,10 @@ export function ItemLightSystem() {
             }
             scored.sort((a, b) => a.score - b.score);
             // Build the desired assignment (top POOL_SIZE keys)
-            const desired = scored.slice(0, POOL_SIZE).map((s) => s.key);
+            const desired = scored
+                .filter((s) => Number.isFinite(s.score))
+                .slice(0, POOL_SIZE)
+                .map((s) => s.key);
             // Build a map of currently-assigned keys → slot index for hysteresis
             const currentlyAssigned = new Map();
             for (let i = 0; i < POOL_SIZE; i++) {
@@ -181,9 +183,11 @@ 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;
@@ -200,12 +204,14 @@ 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
@@ -226,10 +232,17 @@ export function ItemLightSystem() {
             const targetIntensity = isOn
                 ? MathUtils.lerp(reg.effect.intensityRange[0], reg.effect.intensityRange[1], t)
                 : reg.effect.intensityRange[0];
+            if (targetIntensity > 0) {
+                light.visible = true;
+            }
             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, ref: (el) => {
+    return (_jsx(_Fragment, { children: Array.from({ length: POOL_SIZE }, (_, i) => (_jsx("pointLight", { castShadow: false, intensity: 0, visible: false, ref: (el) => {
                 lightRefs.current[i] = el;
             } }, i))) }));
 }