@pascal-app/viewer 1.0.3 → 1.0.4

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

@@ -4,8 +4,10 @@ import { useFrame } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import { FrontSide } from 'three';
 import { disposeObject3DResources } from '../../lib/dispose-object3d';
-import { createSurfaceRoleMaterial, } from '../../lib/materials';
+import { createSurfaceRoleMaterial, materialCastsShadow, } from '../../lib/materials';
+import { createNodeTopSurfaceHeightSampler } from '../../lib/node-top-surface-height';
 import { timeSpan } from '../../lib/perf-tracks';
+import { createSceneSupportHeightSampler } from '../../lib/scene-support-height';
 import useViewer from '../../store/use-viewer';
 /**
  * Generic geometry system.
@@ -55,6 +57,22 @@ export const GeometrySystem = () => {
     // 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());
+    const liveBuildIds = useRef(new Set());
+    useEffect(() => {
+        const unsubscribe = useLiveNodeOverrides.subscribe((state, previous) => {
+            for (const id of new Set([...state.overrides.keys(), ...previous.overrides.keys()])) {
+                if (state.overrides.get(id) === previous.overrides.get(id))
+                    continue;
+                const node = useScene.getState().nodes[id];
+                if (node && nodeRegistry.get(node.type)?.geometry)
+                    liveBuildIds.current.add(id);
+            }
+        });
+        return () => {
+            unsubscribe();
+            liveBuildIds.current.clear();
+        };
+    }, []);
     // Re-mark every geometry-backed node dirty whenever a viewer appearance
     // value changes, so `def.geometry` builders re-run and pick up the new
     // shading / texture / preset / theme. These four are deliberate re-run
@@ -92,19 +110,23 @@ export const GeometrySystem = () => {
         }
     }, [sceneMaterials]);
     useFrame(() => {
-        if (dirtyNodes.size === 0)
+        if (dirtyNodes.size === 0 && liveBuildIds.current.size === 0)
             return;
         const nodes = useScene.getState().nodes;
         let rebuiltGeometry = false;
         const batches = new Map();
         const dirtyIds = [];
-        dirtyNodes.forEach((id) => {
+        for (const id of new Set([...dirtyNodes, ...liveBuildIds.current])) {
             const node = nodes[id];
-            if (!node)
-                return;
+            if (!node) {
+                liveBuildIds.current.delete(id);
+                continue;
+            }
             const def = nodeRegistry.get(node.type);
-            if (!def?.geometry)
-                return;
+            if (!def?.geometry) {
+                liveBuildIds.current.delete(id);
+                continue;
+            }
             dirtyIds.push(id);
             const parentId = (node.parentId ?? null);
             const key = `${node.type}::${parentId ?? ''}`;
@@ -113,7 +135,7 @@ export const GeometrySystem = () => {
                 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();
@@ -170,7 +192,9 @@ export const GeometrySystem = () => {
                 const childLiveOverrideKey = liveChildOverrideKey(node);
                 const builtKey = `${shading}|${textures}|${colorPreset}|${sceneTheme}|${def.geometryKey(effectiveNode)}|${childLiveOverrideKey}`;
                 if (shouldReuseGeometryBuild(builtGeometryKeyRef.current, id, group, builtKey)) {
-                    clearDirty(id);
+                    liveBuildIds.current.delete(id);
+                    if (dirtyNodes.has(id))
+                        clearDirty(id);
                     continue;
                 }
             }
@@ -199,7 +223,9 @@ export const GeometrySystem = () => {
             // 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);
+            liveBuildIds.current.delete(id);
+            if (dirtyNodes.has(id))
+                clearDirty(id);
         }
         if (rebuiltGeometry)
             bumpGeometryRevision();
@@ -281,7 +307,38 @@ function buildGeometryContext(node, nodes, levelData, materials) {
         noteLevelBaseConsumer(node.type);
         return levelId ? levelBaseElevationAt(nodes, levelId, x, z) : 0;
     };
-    return { resolve, children, siblings, parent, levelBaseAt, levelData, materials };
+    const surfaceSamplers = new Map();
+    const surfaceHeightAt = (hostId, x, z) => {
+        if (!levelId)
+            return null;
+        if (!surfaceSamplers.has(hostId)) {
+            surfaceSamplers.set(hostId, createNodeTopSurfaceHeightSampler(hostId, levelId));
+        }
+        return surfaceSamplers.get(hostId)?.(x, z) ?? null;
+    };
+    const supportSamplers = new Map();
+    const supportHeightAt = (x, z, selectedHostId) => {
+        if (!levelId)
+            return levelBaseAt(x, z);
+        const key = selectedHostId ?? 'auto';
+        let sampler = supportSamplers.get(key);
+        if (!sampler) {
+            sampler = createSceneSupportHeightSampler(nodes, levelId, selectedHostId);
+            supportSamplers.set(key, sampler);
+        }
+        return sampler(x, z);
+    };
+    return {
+        resolve,
+        children,
+        siblings,
+        parent,
+        levelBaseAt,
+        surfaceHeightAt,
+        supportHeightAt,
+        levelData,
+        materials,
+    };
 }
 function disposeChildren(group) {
     // Only dispose meshes the geometry builder produced on the previous
@@ -330,6 +387,9 @@ export function markGeometryBuildOutput(child) {
     // example a cabinet sink faucet handle), while disposal still removes only
     // top-level builder children from the registered group.
     child.traverse((object) => {
+        const mesh = object;
+        if (mesh.isMesh)
+            mesh.castShadow = mesh.castShadow && materialCastsShadow(mesh.material);
         object.userData = {
             ...object.userData,
             __fromGeometry: true,

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":"AAiCA,eAAO,MAAM,iBAAiB,mCAsB7B,CAAA"}
+{"version":3,"file":"interactive-system.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/interactive-system.tsx"],"names":[],"mappings":"AAmCA,eAAO,MAAM,iBAAiB,mCAmC7B,CAAA"}

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

@@ -1,27 +1,27 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
 import { pointInPolygon, sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
+import { evaluateRecipe, operableParts, } from '@pascal-app/core/procedural-items';
 import { Html } from '@react-three/drei';
 import { createPortal, useFrame } from '@react-three/fiber';
-import { useEffect, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 import { Vector3 } from 'three';
 import { useShallow } from 'zustand/react/shallow';
 import useViewer from '../../store/use-viewer';
 import { ControlWidget } from './control-widget';
+import { proceduralControlDescriptors } from './procedural-controls';
 const _tempVec = new Vector3();
-// ---- Parent: one overlay per interactive item inside the selected zone ----
+// ---- Parent: overlays for selected interactive items and the selected zone ----
 //
-// The <Html> overlays only exist while a zone is selected and the item sits
-// inside it. Mounting them unconditionally is not an option: each drei <Html>
+// Mounting <Html> overlays unconditionally is not an option: each drei <Html>
 // repositions and re-sorts its DOM element on every camera-move frame, and
 // with `occlude` it also raycasts the entire scene per overlay per frame. On
 // large scenes (hundreds of interactive items) that starves the frame budget
 // and the display/z-index churn makes the whole DOM UI flicker.
 //
-// The child components stay rendered (returning null) so an overlay can fade
-// out before its <Html> unmounts.
 export const InteractiveSystem = () => {
     const zoneId = useViewer((s) => s.selection.zoneId);
+    const selectedIds = useViewer((s) => s.selection.selectedIds);
     const zonePolygon = useScene((s) => {
         if (!zoneId)
             return null;
@@ -29,13 +29,17 @@ export const InteractiveSystem = () => {
         return z?.polygon ?? null;
     });
     const interactiveNodeIds = useScene(useShallow((state) => Object.values(state.nodes)
-        .filter((n) => n.type === 'item' && n.asset.interactive != null)
+        .filter((n) => (n.type === 'item' && n.asset.interactive != null) ||
+        (n.type === 'procedural-item' &&
+            (operableParts(n.recipe).length > 0 || n.recipe.parts.some((part) => part.light))))
         .map((n) => n.id)));
-    return (_jsx(_Fragment, { children: interactiveNodeIds.map((id) => (_jsx(ItemControlsOverlay, { nodeId: id, zonePolygon: zonePolygon }, id))) }));
+    return (_jsx(_Fragment, { children: interactiveNodeIds
+            .filter((id) => zonePolygon?.length || selectedIds.includes(id))
+            .map((id) => (_jsx(ItemControlsOverlay, { isSelected: selectedIds.includes(id), nodeId: id, zonePolygon: zonePolygon }, id))) }));
 };
 // ---- Child: polls sceneRegistry then portals controls into the item group ----
 const FADE_MS = 300;
-const ItemControlsOverlay = ({ nodeId, zonePolygon, }) => {
+const ItemControlsOverlay = ({ nodeId, zonePolygon, isSelected, }) => {
     const node = useScene((state) => state.nodes[nodeId]);
     const [itemObj, setItemObj] = useState(null);
     useFrame(() => {
@@ -46,11 +50,34 @@ const ItemControlsOverlay = ({ nodeId, zonePolygon, }) => {
             setItemObj(obj);
     });
     const controlValues = useInteractive(useShallow((state) => state.items[nodeId]?.controlValues));
+    const proceduralState = useInteractive((state) => state.procedural[nodeId]);
+    const lampDefault = useInteractive((state) => state.lampDefault);
     const setControlValue = useInteractive((state) => state.setControlValue);
-    let visible = false;
+    const togglePart = useInteractive((state) => state.toggleProceduralPart);
+    const toggleLights = useInteractive((state) => state.toggleProceduralLights);
+    const proceduralHeight = useMemo(() => node?.type === 'procedural-item' ? evaluateRecipe(node.recipe, node.parameters).max[1] : 0, [
+        node?.type === 'procedural-item' ? node.recipe : null,
+        node?.type === 'procedural-item' ? node.parameters : null,
+    ]);
+    let descriptors = [];
+    let height = 0;
+    if (node?.type === 'item' && node.asset.interactive && controlValues) {
+        descriptors = node.asset.interactive.controls.map((control, i) => ({
+            key: String(i),
+            control,
+            value: controlValues[i] ?? false,
+            onChange: (value) => setControlValue(nodeId, i, value),
+        }));
+        height = node.asset.dimensions[1];
+    }
+    else if (node?.type === 'procedural-item') {
+        descriptors = proceduralControlDescriptors(node.recipe, proceduralState, (partId) => togglePart(nodeId, partId), () => toggleLights(nodeId), lampDefault);
+        height = proceduralHeight;
+    }
+    let visible = isSelected;
     if (itemObj && zonePolygon?.length) {
         itemObj.getWorldPosition(_tempVec);
-        visible = pointInPolygon(_tempVec.x, _tempVec.z, zonePolygon);
+        visible = visible || pointInPolygon(_tempVec.x, _tempVec.z, zonePolygon);
     }
     // Fade in on mount and fade out before unmounting the <Html>.
     const [mounted, setMounted] = useState(false);
@@ -73,10 +100,8 @@ const ItemControlsOverlay = ({ nodeId, zonePolygon, }) => {
         const timeout = setTimeout(() => setMounted(false), FADE_MS);
         return () => clearTimeout(timeout);
     }, [visible]);
-    if (!(mounted && itemObj && controlValues && node?.asset.interactive))
+    if (!(mounted && itemObj && descriptors.length))
         return null;
-    const { controls } = node.asset.interactive;
-    const [, height] = node.asset.dimensions;
     return createPortal(_jsx(Html, { center: true, distanceFactor: 8, eps: -1, position: [0, height + 0.3, 0], zIndexRange: [20, 0], children: _jsx("div", { style: {
                 display: 'flex',
                 flexDirection: 'column',
@@ -90,5 +115,5 @@ const ItemControlsOverlay = ({ nodeId, zonePolygon, }) => {
                 userSelect: 'none',
                 opacity: shown ? 1 : 0,
                 transition: `opacity ${FADE_MS}ms ease`,
-            }, children: controls.map((control, i) => (_jsx(ControlWidget, { control: control, onChange: (v) => setControlValue(nodeId, i, v), value: controlValues[i] ?? false }, i))) }) }), itemObj);
+            }, children: descriptors.map((descriptor) => (_jsx(ControlWidget, { control: descriptor.control, onChange: descriptor.onChange, value: descriptor.value }, descriptor.key))) }) }), itemObj);
 };

package/dist/systems/interactive/procedural-controls.d.ts

@@ -0,0 +1,13 @@
+import type { Control, ControlValue } from '@pascal-app/core';
+import { type ProceduralItemNode } from '@pascal-app/core/procedural-items';
+export type ControlDescriptor = {
+    key: string;
+    control: Control;
+    value: ControlValue;
+    onChange: (value: ControlValue) => void;
+};
+export declare function proceduralControlDescriptors(recipe: Pick<ProceduralItemNode['recipe'], 'parts' | 'joints'>, state: {
+    parts: Record<string, boolean>;
+    lightsOn: boolean;
+} | undefined, togglePart: (partId: string) => void, toggleLights: () => void, lampDefault?: boolean): ControlDescriptor[];
+//# sourceMappingURL=procedural-controls.d.ts.map

package/dist/systems/interactive/procedural-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedural-controls.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/procedural-controls.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC7D,OAAO,EAAiB,KAAK,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE1F,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,YAAY,CAAA;IACnB,QAAQ,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;CACxC,CAAA;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC,EAC9D,KAAK,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,EACxE,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EACpC,YAAY,EAAE,MAAM,IAAI,EACxB,WAAW,UAAQ,GAClB,iBAAiB,EAAE,CAerB"}

package/dist/systems/interactive/procedural-controls.js

@@ -0,0 +1,17 @@
+import { operableParts } from '@pascal-app/core/procedural-items';
+export function proceduralControlDescriptors(recipe, state, togglePart, toggleLights, lampDefault = false) {
+    const controls = operableParts(recipe).map((part) => ({
+        key: part.id,
+        control: { kind: 'toggle', label: part.label },
+        value: state?.parts[part.id] ?? part.kind === 'spin',
+        onChange: () => togglePart(part.id),
+    }));
+    if (recipe.parts.some((part) => part.light))
+        controls.push({
+            key: 'lights',
+            control: { kind: 'toggle', label: 'Lights' },
+            value: state?.lightsOn ?? lampDefault,
+            onChange: toggleLights,
+        });
+    return controls;
+}

package/dist/systems/interactive/scripted-clips.d.ts

@@ -0,0 +1,19 @@
+import { type AnyNodeId, type Interactive } from '@pascal-app/core';
+import { type RefObject } from 'react';
+import { type AnimationAction, type AnimationClip, Object3D } from 'three';
+/** Actions keyed by the clip names the script wrote (`open`, `loop`, `Princess twirl`). */
+export type ScriptedClipActions = Record<string, AnimationAction | null | undefined>;
+/** Own the action cache so replacing clips cannot retain bindings to an old artifact. */
+export declare function useClipActions(clips: AnimationClip[], root: RefObject<Object3D | null>): Record<string, AnimationAction | null>;
+/**
+ * An authored object's clips, each driven by its own toggle: an open-close
+ * effect plays `open` once and holds, closing plays `close` or `open` reversed;
+ * an ambient effect plays its clip while its toggle is on (always, for `loop`).
+ * Shared by the live item renderer and the baked viewer.
+ */
+export declare function ScriptedClips({ nodeId, interactive, actions, }: {
+    nodeId: AnyNodeId;
+    interactive: Interactive;
+    actions: ScriptedClipActions;
+}): import("react").JSX.Element;
+//# sourceMappingURL=scripted-clips.d.ts.map

package/dist/systems/interactive/scripted-clips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scripted-clips.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/scripted-clips.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,WAAW,EAEjB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,KAAK,SAAS,EAA+C,MAAM,OAAO,CAAA;AACnF,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,aAAa,EAIlB,QAAQ,EACT,MAAM,OAAO,CAAA;AAEd,2FAA2F;AAC3F,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,CAAC,CAAA;AAEpF,yFAAyF;AACzF,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,EAAE,EAAE,IAAI,EAAE,SAAS,CAAC,QAAQ,GAAG,IAAI,CAAC,0CAoCtF;AAQD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EACN,WAAW,EACX,OAAO,GACR,EAAE;IACD,MAAM,EAAE,SAAS,CAAA;IACjB,WAAW,EAAE,WAAW,CAAA;IACxB,OAAO,EAAE,mBAAmB,CAAA;CAC7B,+BAoBA"}

package/dist/systems/interactive/scripted-clips.js

@@ -0,0 +1,134 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useInteractive, } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import { AnimationMixer, LoopOnce, LoopRepeat, Object3D, } from 'three';
+/** Own the action cache so replacing clips cannot retain bindings to an old artifact. */
+export function useClipActions(clips, root) {
+    const { mixer, actions, cached, lifecycle } = useMemo(() => {
+        const mixer = new AnimationMixer(new Object3D());
+        const cached = new Map();
+        const lifecycle = { active: true };
+        const actions = {};
+        for (const clip of clips) {
+            Object.defineProperty(actions, clip.name, {
+                enumerable: true,
+                configurable: true,
+                get: () => {
+                    if (!lifecycle.active || !root.current)
+                        return null;
+                    let action = cached.get(clip.name);
+                    if (!action) {
+                        action = mixer.clipAction(clip, root.current);
+                        cached.set(clip.name, action);
+                    }
+                    return action;
+                },
+            });
+        }
+        return { mixer, actions, cached, lifecycle };
+    }, [clips, root]);
+    useFrame((_, delta) => mixer.update(delta));
+    useLayoutEffect(() => {
+        lifecycle.active = true;
+        return () => {
+            // React's development prop diff can read old getters after cleanup.
+            lifecycle.active = false;
+            mixer.stopAllAction();
+            const roots = new Set([...cached.values()].map((action) => action.getRoot()));
+            cached.clear();
+            for (const object of roots)
+                mixer.uncacheRoot(object);
+        };
+    }, [mixer, cached, lifecycle]);
+    return actions;
+}
+/** Whether an effect's toggle is on; an effect without one always runs. */
+const useEffectControl = (nodeId, control) => useInteractive((s) => control === undefined ? true : Boolean(s.items[nodeId]?.controlValues[control]));
+/**
+ * An authored object's clips, each driven by its own toggle: an open-close
+ * effect plays `open` once and holds, closing plays `close` or `open` reversed;
+ * an ambient effect plays its clip while its toggle is on (always, for `loop`).
+ * Shared by the live item renderer and the baked viewer.
+ */
+export function ScriptedClips({ nodeId, interactive, actions, }) {
+    const effects = interactive.effects.filter((effect) => effect.kind === 'animation');
+    return (_jsx(_Fragment, { children: effects.map((effect) => effect.mode === 'open-close' ? (_jsx(OpenCloseClip, { actions: actions, effect: effect, nodeId: nodeId }, effect.clips.on)) : (_jsx(PlayClip, { actions: actions, effect: effect, nodeId: nodeId }, effect.clips.on ?? effect.clips.loop))) }));
+}
+const PlayClip = ({ nodeId, effect, actions, }) => {
+    const on = useEffectControl(nodeId, effect.control);
+    const name = effect.clips.on ?? effect.clips.loop;
+    useEffect(() => {
+        const action = name ? actions[name] : undefined;
+        return () => {
+            action?.stop();
+        };
+    }, [actions, name]);
+    useEffect(() => {
+        const action = name ? actions[name] : undefined;
+        if (!action)
+            return;
+        if (on) {
+            action.setLoop(LoopRepeat, Number.POSITIVE_INFINITY);
+            action.clampWhenFinished = false;
+            action.paused = false;
+            action.play();
+        }
+        else {
+            // Hold the pose where it was, like pausing a music box.
+            action.paused = true;
+        }
+    }, [actions, name, on]);
+    return null;
+};
+const OpenCloseClip = ({ nodeId, effect, actions, }) => {
+    const isOpen = useEffectControl(nodeId, effect.control);
+    const mounted = useRef(false);
+    useEffect(() => {
+        const open = effect.clips.on ? actions[effect.clips.on] : undefined;
+        const close = effect.clips.off ? actions[effect.clips.off] : undefined;
+        return () => {
+            open?.stop();
+            close?.stop();
+            mounted.current = false;
+        };
+    }, [actions, effect.clips.on, effect.clips.off]);
+    useEffect(() => {
+        const open = effect.clips.on ? actions[effect.clips.on] : undefined;
+        const close = effect.clips.off ? actions[effect.clips.off] : undefined;
+        if (!open)
+            return;
+        const first = !mounted.current;
+        mounted.current = true;
+        for (const action of [open, close]) {
+            if (!action)
+                continue;
+            action.setLoop(LoopOnce, 1);
+            action.clampWhenFinished = true;
+        }
+        if (isOpen) {
+            close?.stop();
+            open.paused = false;
+            open.timeScale = 1;
+            if (!open.isRunning())
+                open.reset();
+            open.play();
+            // Already open when the scene loads: hold the open pose, no swing.
+            if (first)
+                open.time = open.getClip().duration;
+            return;
+        }
+        if (first)
+            return;
+        if (close) {
+            open.stop();
+            close.reset().play();
+            return;
+        }
+        open.paused = false;
+        open.timeScale = -1;
+        open.play();
+    }, [actions, effect.clips.on, effect.clips.off, isOpen]);
+    return null;
+};

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"}