@pascal-app/viewer 1.0.3 → 1.0.5

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 { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { isScriptedNode, pointInPolygon, sceneRegistry, scriptedOrigin, scriptedSize, scriptInteractive, 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,18 @@ 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) => (isScriptedNode(n) && scriptInteractive(n.source.manifest) != null) ||
+        (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 +51,43 @@ 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;
+    const interactive = isScriptedNode(node)
+        ? scriptInteractive(node.source.manifest, scriptedOrigin(node))
+        : node?.type === 'item'
+            ? node.asset.interactive
+            : undefined;
+    if (interactive && controlValues) {
+        descriptors = interactive.controls.map((control, i) => ({
+            key: String(i),
+            control,
+            value: controlValues[i] ?? false,
+            onChange: (value) => setControlValue(nodeId, i, value),
+        }));
+        height = isScriptedNode(node)
+            ? scriptedSize(node.source.manifest)[1] + scriptedOrigin(node)[1]
+            : node?.type === 'item'
+                ? node.asset.dimensions[1]
+                : 0;
+    }
+    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 +110,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 +125,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 { Fragment as _Fragment, jsx as _jsx } 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"}

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 { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+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-hold.d.ts

@@ -0,0 +1,4 @@
+export declare const setHeldLevelY: (levelId: string, y: number) => void;
+export declare const heldLevelY: (levelId: string) => number | undefined;
+export declare const releaseLevel: (levelId: string) => void;
+//# sourceMappingURL=level-hold.d.ts.map