@pascal-app/viewer 1.0.6 → 1.1.0

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

@@ -1,129 +1,52 @@
 'use client';
-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, useMemo, useState } from 'react';
-import { Vector3 } from 'three';
-import { useShallow } from 'zustand/react/shallow';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+import { useCallback, useState } from 'react';
+import { SelectionCallout } from '../../components/viewer/selection-callout';
 import useViewer from '../../store/use-viewer';
-import { ControlWidget } from './control-widget';
-import { proceduralControlDescriptors } from './procedural-controls';
-const _tempVec = new Vector3();
-// ---- Parent: overlays for selected interactive items and the selected zone ----
-//
-// 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.
-//
+import { calloutSubtitle, hasCallout, nodeCalloutActions } from './callout-actions';
+function calloutTitle(node) {
+    if (node.name)
+        return node.name;
+    const asset = node.asset;
+    if (asset?.name)
+        return asset.name;
+    const word = node.type.replaceAll('-', ' ');
+    return word.charAt(0).toUpperCase() + word.slice(1);
+}
+/**
+ * The parametric viewer's callout on the one selected element: its name, what
+ * it is, and what it can do (open a door, switch a lamp, close the shutters).
+ */
 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;
-        const z = s.nodes[zoneId];
-        return z?.polygon ?? null;
-    });
-    const interactiveNodeIds = useScene(useShallow((state) => Object.values(state.nodes)
-        .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
-            .filter((id) => zonePolygon?.length || selectedIds.includes(id))
-            .map((id) => (_jsx(ItemControlsOverlay, { isSelected: selectedIds.includes(id), nodeId: id, zonePolygon: zonePolygon }, id))) }));
+    const walkthrough = useViewer((s) => s.walkthroughMode);
+    const node = useScene((s) => selectedIds.length === 1
+        ? s.nodes[selectedIds[0]]
+        : undefined);
+    if (walkthrough || !node || !hasCallout(node.type))
+        return null;
+    return _jsx(NodeCallout, { node: node }, node.id);
 };
-// ---- Child: polls sceneRegistry then portals controls into the item group ----
-const FADE_MS = 300;
-const ItemControlsOverlay = ({ nodeId, zonePolygon, isSelected, }) => {
-    const node = useScene((state) => state.nodes[nodeId]);
-    const [itemObj, setItemObj] = useState(null);
+function NodeCallout({ node }) {
+    const [object, setObject] = useState(null);
+    // The renderer registers the object a frame or more after selection lands,
+    // and may swap it for a new one when the element rebuilds (a sash opening).
     useFrame(() => {
-        if (itemObj)
-            return;
-        const obj = sceneRegistry.nodes.get(nodeId);
-        if (obj)
-            setItemObj(obj);
+        const registered = sceneRegistry.nodes.get(node.id) ?? null;
+        if (registered !== object)
+            setObject(registered);
     });
-    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);
-    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 = visible || pointInPolygon(_tempVec.x, _tempVec.z, zonePolygon);
-    }
-    // Fade in on mount and fade out before unmounting the <Html>.
-    const [mounted, setMounted] = useState(false);
-    const [shown, setShown] = useState(false);
-    useEffect(() => {
-        if (visible) {
-            setMounted(true);
-            // Double rAF: the overlay has to paint once at opacity 0 before the
-            // opacity-1 style lands, otherwise the fade-in transition is skipped.
-            let raf2 = 0;
-            const raf1 = requestAnimationFrame(() => {
-                raf2 = requestAnimationFrame(() => setShown(true));
-            });
-            return () => {
-                cancelAnimationFrame(raf1);
-                cancelAnimationFrame(raf2);
-            };
-        }
-        setShown(false);
-        const timeout = setTimeout(() => setMounted(false), FADE_MS);
-        return () => clearTimeout(timeout);
-    }, [visible]);
-    if (!(mounted && itemObj && descriptors.length))
+    const title = calloutTitle(node);
+    const interactive = useInteractive();
+    const actions = nodeCalloutActions(node, title, interactive);
+    const dismiss = useCallback(() => {
+        const { selection, setSelection } = useViewer.getState();
+        if (selection.selectedIds.includes(node.id))
+            setSelection({ selectedIds: [] });
+    }, [node.id]);
+    if (!object)
         return null;
-    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',
-                gap: 6,
-                background: 'rgba(0,0,0,0.75)',
-                backdropFilter: 'blur(8px)',
-                borderRadius: 8,
-                padding: '8px 12px',
-                minWidth: 120,
-                pointerEvents: visible ? 'auto' : 'none',
-                userSelect: 'none',
-                opacity: shown ? 1 : 0,
-                transition: `opacity ${FADE_MS}ms ease`,
-            }, children: descriptors.map((descriptor) => (_jsx(ControlWidget, { control: descriptor.control, onChange: descriptor.onChange, value: descriptor.value }, descriptor.key))) }) }), itemObj);
-};
+    return (_jsx(SelectionCallout, { actions: actions, object: object, onDismiss: dismiss, subtitle: calloutSubtitle(node, title), title: title }));
+}

package/dist/systems/interactive/opening-settled.d.ts

@@ -0,0 +1,16 @@
+import { type AnyNodeId } from '@pascal-app/core';
+/**
+ * Resolves when a built-in door's leaf or a window's sash (or, with `shutters`,
+ * its shutters) finishes the run just started, so the latch can sound on the
+ * frame the leaf lands.
+ */
+export declare function openingSettled(node: {
+    id: string;
+    type: string;
+}, part?: 'leaf' | 'shutters'): Promise<void>;
+/**
+ * Resolves when a procedural item's latest commanded run (a cabinet door, a
+ * drawer, a lid) has its moving parts at rest. Call it right after the toggle.
+ */
+export declare function proceduralSettled(nodeId: AnyNodeId): Promise<void>;
+//# sourceMappingURL=opening-settled.d.ts.map

package/dist/systems/interactive/opening-settled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-settled.d.ts","sourceRoot":"","sources":["../../../src/systems/interactive/opening-settled.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAA2B,MAAM,kBAAkB,CAAA;AAK1E;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAClC,IAAI,GAAE,MAAM,GAAG,UAAmB,GACjC,OAAO,CAAC,IAAI,CAAC,CAmBf;AAKD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAclE"}

package/dist/systems/interactive/opening-settled.js

@@ -0,0 +1,53 @@
+import { emitter, useInteractive } from '@pascal-app/core';
+/** Longer than any built-in leaf, sash or shutter run, so a missed event never strands a sound. */
+const FALLBACK_MS = 2000;
+/**
+ * Resolves when a built-in door's leaf or a window's sash (or, with `shutters`,
+ * its shutters) finishes the run just started, so the latch can sound on the
+ * frame the leaf lands.
+ */
+export function openingSettled(node, part = 'leaf') {
+    return new Promise((resolve) => {
+        const done = () => {
+            clearTimeout(timer);
+            emitter.off('door:animation-completed', onDoor);
+            emitter.off('window:animation-completed', onWindow);
+            resolve();
+        };
+        const onDoor = (event) => {
+            if (node.type === 'door' && event.doorId === node.id)
+                done();
+        };
+        const onWindow = (event) => {
+            if (node.type !== 'window' || event.windowId !== node.id)
+                return;
+            if ((event.field === 'operationState') === (part === 'leaf'))
+                done();
+        };
+        const timer = setTimeout(done, FALLBACK_MS);
+        emitter.on('door:animation-completed', onDoor);
+        emitter.on('window:animation-completed', onWindow);
+    });
+}
+/** Recipe timelines run longer than a door leaf; past this, a lost event still frees the sound. */
+const MOTION_FALLBACK_MS = 6000;
+/**
+ * Resolves when a procedural item's latest commanded run (a cabinet door, a
+ * drawer, a lid) has its moving parts at rest. Call it right after the toggle.
+ */
+export function proceduralSettled(nodeId) {
+    const sequence = useInteractive.getState().procedural[nodeId]?.motionCommand?.sequence ?? 0;
+    return new Promise((resolve) => {
+        const done = () => {
+            clearTimeout(timer);
+            emitter.off('procedural:motion-settled', onSettled);
+            resolve();
+        };
+        const onSettled = (event) => {
+            if (event.nodeId === nodeId && event.sequence >= sequence)
+                done();
+        };
+        const timer = setTimeout(done, MOTION_FALLBACK_MS);
+        emitter.on('procedural:motion-settled', onSettled);
+    });
+}

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":"AAgGA,wBAAgB,eAAe,uCA0M9B"}
+{"version":3,"file":"item-light-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item-light/item-light-system.tsx"],"names":[],"mappings":"AA+CA,wBAAgB,eAAe,uCAoB9B"}

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

@@ -1,25 +1,10 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { 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 { useThree } from '@react-three/fiber';
 import { SCENE_LAYER } from '../../lib/layers';
 import { useItemLightPool } from '../../store/use-item-light-pool';
 import useViewer from '../../store/use-viewer';
-const POOL_SIZE = 12;
-// How often (in seconds) to re-evaluate which items have lights assigned (fallback timer)
-const REASSIGN_INTERVAL = 0.2;
-// Hysteresis: a currently-assigned slot keeps its key unless an unassigned
-// candidate beats it by at least this much (prevents flickering at the boundary)
-const HYSTERESIS = 0.15;
-// Camera movement thresholds that trigger an early re-evaluation
-const CAM_MOVE_DIST = 0.5; // units
-const CAM_ROT_DOT = 0.995; // cos(~5.7°)
-// Module-level temp vectors reused every frame (avoids GC pressure)
-const _dir = new Vector3();
-const _camPos = new Vector3();
-const _camFwd = new Vector3();
-const _itemPos = new Vector3();
+import { PooledLights } from './pooled-lights';
 function isRendered(nodeId) {
     let object = sceneRegistry.nodes.get(nodeId);
     if (!object?.layers.isEnabled(SCENE_LAYER))
@@ -31,213 +16,36 @@ function isRendered(nodeId) {
     }
     return true;
 }
-function scoreRegistration(reg, nodes, selectedLevelId, levelMode, hideAbove) {
-    if (!reg.isEligible() || !isRendered(reg.nodeId) || !reg.getWorldPosition(_itemPos))
-        return Number.POSITIVE_INFINITY;
+// A light on another storey than the one being edited counts for this much of what it adds.
+const OTHER_LEVEL_WEIGHT = 0.25;
+/** 0 while the light cannot be seen lit (off, hidden, on a hidden level), else its level factor. */
+function registrationWeight(reg, nodes, selectedLevelId, levelMode, hideAbove) {
+    if (!reg.isEligible() || !isRendered(reg.nodeId))
+        return 0;
     const { nodeId } = reg;
     let current = nodes[nodeId];
     while (current) {
         if (current.type !== 'site' && current.visible === false)
-            return Number.POSITIVE_INFINITY;
+            return 0;
         current = current.parentId ? nodes[current.parentId] : undefined;
     }
     const itemLevelId = findLevelAncestorId(nodeId, nodes);
-    if (selectedLevelId && itemLevelId !== selectedLevelId && levelMode === 'solo')
-        return Number.POSITIVE_INFINITY;
-    _dir.copy(_itemPos).sub(_camPos).normalize();
-    const dot = _camFwd.dot(_dir); // 1 = ahead, -1 = behind
-    // Angular component (0 = dead ahead, 2 = directly behind)
-    const angular = 1 - dot;
-    // Normalised distance component (assumes scenes < 200 units)
-    const dist = _camPos.distanceTo(_itemPos) / 200;
-    // ── Level factor ──────────────────────────────────────────────────────────
-    let levelPenalty = 0;
-    if (selectedLevelId) {
-        if (itemLevelId !== selectedLevelId) {
-            // 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) {
-        // No level selected — lightly prefer items on level index 0
-        const levelNode = nodes[itemLevelId];
-        const levelIndex = levelNode?.level ?? 0;
-        if (levelIndex !== 0)
-            levelPenalty = 0.3;
-    }
-    return angular * 0.7 + dist * 0.3 + levelPenalty;
+    if (!selectedLevelId || itemLevelId === selectedLevelId)
+        return 1;
+    if (levelMode === 'solo')
+        return 0;
+    // Above the selected level while editing, a storey is hidden.
+    const itemIndex = nodes[itemLevelId]?.level ?? 0;
+    const selectedIndex = nodes[selectedLevelId]?.level ?? 0;
+    return hideAbove && itemIndex > selectedIndex ? 0 : OTHER_LEVEL_WEIGHT;
 }
 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);
-    // Track camera state at last reassignment to detect meaningful movement
-    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();
-        // ── 1. Throttled priority reassignment ──────────────────────────────────
-        camera.getWorldPosition(_camPos);
-        camera.getWorldDirection(_camFwd);
-        const camMoved = _camPos.distanceTo(prevReassignCamPos.current) > CAM_MOVE_DIST ||
-            _camFwd.dot(prevReassignCamFwd.current) < CAM_ROT_DOT;
-        reassignTimer.current -= delta;
-        const shouldReassign = reassignTimer.current <= 0 || camMoved;
-        if (shouldReassign) {
-            reassignTimer.current = REASSIGN_INTERVAL;
-            prevReassignCamPos.current.copy(_camPos);
-            prevReassignCamFwd.current.copy(_camFwd);
-            // Read level/scene state once for the whole tick
-            const nodes = useScene.getState().nodes;
-            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, hideAbove),
-                });
-            }
-            scored.sort((a, b) => a.score - b.score);
-            // Build the desired assignment (top POOL_SIZE keys)
-            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++) {
-                const s = slots.current[i];
-                if (!s)
-                    continue;
-                const k = s.key ?? s.pendingKey;
-                if (k)
-                    currentlyAssigned.set(k, i);
-            }
-            // Assign desired keys to slots — prefer keeping existing assignments
-            const usedSlots = new Set();
-            const assignedKeys = new Set();
-            // Pass 1: keep existing slots where the key is still in desired
-            for (const key of desired) {
-                const existingSlot = currentlyAssigned.get(key);
-                if (existingSlot !== undefined && !usedSlots.has(existingSlot)) {
-                    usedSlots.add(existingSlot);
-                    assignedKeys.add(key);
-                }
-            }
-            // Pass 2: assign remaining desired keys to free slots
-            let freeSlot = 0;
-            for (const key of desired) {
-                if (assignedKeys.has(key))
-                    continue;
-                while (freeSlot < POOL_SIZE && usedSlots.has(freeSlot))
-                    freeSlot++;
-                if (freeSlot >= POOL_SIZE)
-                    break;
-                // Hysteresis: only evict the current occupant if the new key scores
-                // meaningfully better than it
-                const freeSlotData = slots.current[freeSlot];
-                const currentKey = freeSlotData ? (freeSlotData.key ?? freeSlotData.pendingKey) : null;
-                if (currentKey && !desired.includes(currentKey)) {
-                    const currentScore = scored.find((s) => s.key === currentKey)?.score ?? Number.POSITIVE_INFINITY;
-                    const newScore = scored.find((s) => s.key === key)?.score ?? 0;
-                    if (currentScore - newScore < HYSTERESIS) {
-                        freeSlot++;
-                        continue;
-                    }
-                }
-                usedSlots.add(freeSlot);
-                assignedKeys.add(key);
-                const slot = slots.current[freeSlot];
-                if (slot && slot.key !== key) {
-                    slot.pendingKey = key;
-                    slot.isFadingOut = slot.key !== null;
-                    if (!slot.isFadingOut) {
-                        // Slot was idle — skip fade-out, assign immediately
-                        slot.key = key;
-                        slot.pendingKey = null;
-                        const light = lightRefs.current[freeSlot];
-                        const reg = registrations.get(key);
-                        if (light && reg) {
-                            light.color.set(reg.color);
-                            light.distance = reg.distance;
-                        }
-                    }
-                }
-                freeSlot++;
-            }
-            // Clear slots whose key is no longer in desired and not pending
-            for (let i = 0; i < POOL_SIZE; i++) {
-                if (!usedSlots.has(i)) {
-                    const slot = slots.current[i];
-                    if (slot?.key && !desired.includes(slot.key)) {
-                        slot.pendingKey = null;
-                        slot.isFadingOut = true;
-                    }
-                }
-            }
-        }
-        // ── 2. Per-frame light updates ───────────────────────────────────────────
-        for (let i = 0; i < POOL_SIZE; i++) {
-            const light = lightRefs.current[i];
-            if (!light)
-                continue;
-            const slot = slots.current[i];
-            if (!slot)
-                continue;
-            // Fade-out phase: lerp intensity → 0, then complete the transition
-            if (slot.isFadingOut) {
-                light.intensity = MathUtils.lerp(light.intensity, 0, dt * 12);
-                if (light.intensity < 0.01) {
-                    light.intensity = 0;
-                    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.color);
-                            light.distance = reg.distance;
-                        }
-                    }
-                }
-                continue;
-            }
-            if (!slot.key) {
-                // Idle slot — keep dark
-                light.intensity = 0;
-                continue;
-            }
-            const reg = registrations.get(slot.key);
-            if (!reg) {
-                slot.key = null;
-                light.intensity = 0;
-                continue;
-            }
-            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;
-            }
-        }
-    }, 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))) }));
+    return (_jsx(PooledLights, { getLights: () => useItemLightPool.getState().registrations.values(), intensity: (reg) => (reg.isEligible() && isRendered(reg.nodeId) ? reg.getIntensity() : 0), weight: (reg) => {
+            const viewer = useViewer.getState();
+            return registrationWeight(reg, useScene.getState().nodes, viewer.selection.levelId, viewer.levelMode, viewer.hideLevelsAboveSelection);
+        } }));
 }

package/dist/systems/item-light/pooled-lights.d.ts

@@ -0,0 +1,70 @@
+import type { LightSpot } from '@pascal-app/core';
+import { type Camera, Frustum, type Object3D, Vector3 } from 'three/webgpu';
+/** A light an item holds, as the pools drive it. */
+export type PooledLight = {
+    key: string;
+    color: string;
+    distance: number;
+    spot?: LightSpot;
+    shadows?: boolean;
+    glow?: {
+        size: number;
+        strength?: number;
+    };
+    /** Its fully-on intensity, so its glow dims with it. */
+    peak?: number;
+    /** Where it shines from; false while its object is not mounted. */
+    getWorldPosition: (out: Vector3) => boolean;
+    /** Its spot's aim in world space, turned with its item. */
+    getWorldDirection?: (out: Vector3) => void;
+};
+type Props<T extends PooledLight> = {
+    getLights: () => Iterable<T>;
+    /**
+     * 0 while it cannot be seen lit (off, hidden, on a hidden level); otherwise a factor on what it
+     * adds to the view (a light on another storey than the one being edited counts for less).
+     */
+    weight: (light: T) => number;
+    /** What it shines at now: 0 while off or not drawn. */
+    intensity: (light: T) => number;
+};
+type Slot = {
+    key: string | null;
+    pendingKey: string | null;
+    isFadingOut: boolean;
+};
+type Candidate = {
+    key: string;
+    priority: number;
+};
+/**
+ * Roughly what a light adds to a view: its intensity over its squared distance from the eye, or 0
+ * when its reach (its distance, else where it falls under REACH_CUTOFF) misses the view.
+ */
+export declare function lightContribution(position: Vector3, intensity: number, distance: number, eye: Vector3, frustum: Frustum): number;
+/**
+ * Gives the wanted keys (most first) the pool's slots: a key that holds a slot keeps it, and a
+ * newcomer evicts a key no longer wanted only on a clear win. A slot changing hands fades out
+ * first; an idle slot takes its key at once.
+ */
+export declare function assignSlots(slots: Slot[], wanted: Candidate[], priorityByKey: Map<string, number>): void;
+/** How much a glow shows: 1 at night, nearly nothing in daylight. */
+export declare function glowDarkness(sunDirection: Vector3 | null, appearance: 'light' | 'dark'): number;
+/**
+ * Sets the item lights of `scene` for a picture taken through `camera`: the pools re-ranked for
+ * what that camera sees and every light straight at its strength, no fade. A capture camera is not
+ * the live view's, and a theme switched for the picture leaves no time for lamps to fade in.
+ * Returns what puts the live view's lights back.
+ */
+export declare function itemLightsForCapture(scene: Object3D, camera: Camera): () => void;
+/**
+ * The lights items hold, through fixed pools of point lights, spots and two shadow-casting slots,
+ * handed to the lights that add most to the view (intensity over squared distance, among those
+ * whose reach meets the view frustum), with hysteresis, and faded across reassignment. Every pool
+ * light stays mounted and visible and only its intensity moves: changing the light count
+ * recompiles every material. The spot and shadow pools mount the first time a light needs them,
+ * and stay. Glows are one instanced sprite for every glowing lamp, pooled or not.
+ */
+export declare function PooledLights<T extends PooledLight>(props: Props<T>): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=pooled-lights.d.ts.map

package/dist/systems/item-light/pooled-lights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pooled-lights.d.ts","sourceRoot":"","sources":["../../../src/systems/item-light/pooled-lights.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAYjD,OAAO,EAEL,KAAK,MAAM,EAGX,OAAO,EAIP,KAAK,QAAQ,EAMb,OAAO,EACR,MAAM,cAAc,CAAA;AAMrB,oDAAoD;AACpD,MAAM,MAAM,WAAW,GAAG;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,SAAS,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;IAEjB,IAAI,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1C,wDAAwD;IACxD,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,mEAAmE;IACnE,gBAAgB,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAA;IAC3C,2DAA2D;IAC3D,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;CAC3C,CAAA;AAED,KAAK,KAAK,CAAC,CAAC,SAAS,WAAW,IAAI;IAClC,SAAS,EAAE,MAAM,QAAQ,CAAC,CAAC,CAAC,CAAA;IAC5B;;;OAGG;IACH,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAA;IAC5B,uDAAuD;IACvD,SAAS,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAA;CAChC,CAAA;AAmCD,KAAK,IAAI,GAAG;IAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAAA;AACnF,KAAK,SAAS,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAoBlD;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,OAAO,EACjB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,OAAO,EACZ,OAAO,EAAE,OAAO,GACf,MAAM,CAKR;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,IAAI,EAAE,EACb,MAAM,EAAE,SAAS,EAAE,EACnB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,QAiDnC;AAWD,qEAAqE;AACrE,wBAAgB,YAAY,CAAC,YAAY,EAAE,OAAO,GAAG,IAAI,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAI/F;AAuGD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,CAKhF;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,+BAKlE"}