@pascal-app/viewer 0.1.13 → 0.2.0

package/dist/lib/asset-url.d.ts

@@ -1,4 +1,4 @@
-export declare const ASSETS_CDN_URL = "https://editor.pascal.app";
+export declare const ASSETS_CDN_URL: any;
 /**
  * Resolves an asset URL to the appropriate format:
  * - If URL starts with http:// or https://, return as-is (external URL)

package/dist/lib/asset-url.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asset-url.d.ts","sourceRoot":"","sources":["../../src/lib/asset-url.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,cAAc,8BAA8B,CAAA;AAEzD;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAgB5F;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAiB3E"}
+{"version":3,"file":"asset-url.d.ts","sourceRoot":"","sources":["../../src/lib/asset-url.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,cAAc,KAAwE,CAAA;AAEnG;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAgB5F;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAiB3E"}

package/dist/lib/asset-url.js

@@ -1,5 +1,6 @@
 import { loadAssetUrl } from '@pascal-app/core';
-export const ASSETS_CDN_URL = 'https://editor.pascal.app';
+// @ts-expect-error
+export const ASSETS_CDN_URL = process.env.NEXT_PUBLIC_ASSETS_CDN_URL || 'https://editor.pascal.app';
 /**
  * Resolves an asset URL to the appropriate format:
  * - If URL starts with http:// or https://, return as-is (external URL)

package/dist/lib/layers.d.ts

@@ -0,0 +1,5 @@
+/** Default Three.js layer for main scene geometry. */
+export declare const SCENE_LAYER = 0;
+/** Layer used for zone rendering (floor fills and wall borders). */
+export declare const ZONE_LAYER = 2;
+//# sourceMappingURL=layers.d.ts.map

package/dist/lib/layers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layers.d.ts","sourceRoot":"","sources":["../../src/lib/layers.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,eAAO,MAAM,WAAW,IAAI,CAAA;AAE5B,oEAAoE;AACpE,eAAO,MAAM,UAAU,IAAI,CAAA"}

package/dist/lib/layers.js

@@ -0,0 +1,4 @@
+/** Default Three.js layer for main scene geometry. */
+export const SCENE_LAYER = 0;
+/** Layer used for zone rendering (floor fills and wall borders). */
+export const ZONE_LAYER = 2;

package/dist/store/use-item-light-pool.d.ts

@@ -0,0 +1,18 @@
+import type { AnyNodeId, Interactive, LightEffect } from '@pascal-app/core';
+export type LightRegistration = {
+    nodeId: AnyNodeId;
+    effect: LightEffect;
+    toggleIndex: number;
+    sliderIndex: number;
+    sliderMin: number;
+    sliderMax: number;
+    hasSlider: boolean;
+};
+type ItemLightPoolStore = {
+    registrations: Map<string, LightRegistration>;
+    register: (key: string, nodeId: AnyNodeId, effect: LightEffect, interactive: Interactive) => void;
+    unregister: (key: string) => void;
+};
+export declare const useItemLightPool: import("zustand").UseBoundStore<import("zustand").StoreApi<ItemLightPoolStore>>;
+export {};
+//# sourceMappingURL=use-item-light-pool.d.ts.map

package/dist/store/use-item-light-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-item-light-pool.d.ts","sourceRoot":"","sources":["../../src/store/use-item-light-pool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,EAAiB,MAAM,kBAAkB,CAAA;AAG1F,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,SAAS,CAAA;IACjB,MAAM,EAAE,WAAW,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,KAAK,kBAAkB,GAAG;IACxB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;IAC7C,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,KAAK,IAAI,CAAA;IACjG,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAA;CAClC,CAAA;AAED,eAAO,MAAM,gBAAgB,iFAiC1B,CAAA"}

package/dist/store/use-item-light-pool.js

@@ -0,0 +1,30 @@
+import { create } from 'zustand';
+export const useItemLightPool = create((set) => ({
+    registrations: new Map(),
+    register: (key, nodeId, effect, interactive) => {
+        const toggleIndex = interactive.controls.findIndex((c) => c.kind === 'toggle');
+        const sliderIndex = interactive.controls.findIndex((c) => c.kind === 'slider');
+        const sliderControl = sliderIndex >= 0 ? interactive.controls[sliderIndex] : null;
+        const registration = {
+            nodeId,
+            effect,
+            toggleIndex,
+            sliderIndex,
+            hasSlider: sliderControl !== null,
+            sliderMin: sliderControl?.min ?? 0,
+            sliderMax: sliderControl?.max ?? 1,
+        };
+        set((s) => {
+            const next = new Map(s.registrations);
+            next.set(key, registration);
+            return { registrations: next };
+        });
+    },
+    unregister: (key) => {
+        set((s) => {
+            const next = new Map(s.registrations);
+            next.delete(key);
+            return { registrations: next };
+        });
+    },
+}));

package/dist/store/use-viewer.d.ts

@@ -1,10 +1,10 @@
-import type { AnyNode, BaseNode, BuildingNode, LevelNode, ZoneNode } from "@pascal-app/core";
-import type { Object3D } from "three";
+import type { AnyNode, BaseNode, BuildingNode, LevelNode, ZoneNode } from '@pascal-app/core';
+import type { Object3D } from 'three';
 type SelectionPath = {
-    buildingId: BuildingNode["id"] | null;
-    levelId: LevelNode["id"] | null;
-    zoneId: ZoneNode["id"] | null;
-    selectedIds: BaseNode["id"][];
+    buildingId: BuildingNode['id'] | null;
+    levelId: LevelNode['id'] | null;
+    zoneId: ZoneNode['id'] | null;
+    selectedIds: BaseNode['id'][];
 };
 type Outliner = {
     selectedObjects: Object3D[];
@@ -16,6 +16,8 @@ type ViewerState = {
     setHoveredId: (id: AnyNode['id'] | ZoneNode['id'] | null) => void;
     cameraMode: 'perspective' | 'orthographic';
     setCameraMode: (mode: 'perspective' | 'orthographic') => void;
+    theme: 'light' | 'dark';
+    setTheme: (theme: 'light' | 'dark') => void;
     levelMode: 'stacked' | 'exploded' | 'solo' | 'manual';
     setLevelMode: (mode: 'stacked' | 'exploded' | 'solo' | 'manual') => void;
     wallMode: 'up' | 'cutaway' | 'down';
@@ -24,14 +26,57 @@ type ViewerState = {
     setShowScans: (show: boolean) => void;
     showGuides: boolean;
     setShowGuides: (show: boolean) => void;
+    showGrid: boolean;
+    setShowGrid: (show: boolean) => void;
+    projectId: string | null;
+    setProjectId: (id: string | null) => void;
+    projectPreferences: Record<string, {
+        showScans?: boolean;
+        showGuides?: boolean;
+        showGrid?: boolean;
+    }>;
     setSelection: (updates: Partial<SelectionPath>) => void;
     resetSelection: () => void;
     outliner: Outliner;
     exportScene: (() => Promise<void>) | null;
     setExportScene: (fn: (() => Promise<void>) | null) => void;
+    debugColors: boolean;
+    setDebugColors: (enabled: boolean) => void;
     cameraDragging: boolean;
     setCameraDragging: (dragging: boolean) => void;
 };
-declare const useViewer: import("zustand").UseBoundStore<import("zustand").StoreApi<ViewerState>>;
+declare const useViewer: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<ViewerState>, "setState" | "persist"> & {
+    setState(partial: ViewerState | Partial<ViewerState> | ((state: ViewerState) => ViewerState | Partial<ViewerState>), replace?: false | undefined): unknown;
+    setState(state: ViewerState | ((state: ViewerState) => ViewerState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<ViewerState, {
+            cameraMode: "perspective" | "orthographic";
+            theme: "light" | "dark";
+            levelMode: "stacked" | "exploded" | "solo" | "manual";
+            wallMode: "up" | "cutaway" | "down";
+            projectPreferences: Record<string, {
+                showScans?: boolean;
+                showGuides?: boolean;
+                showGrid?: boolean;
+            }>;
+        }, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: ViewerState) => void) => () => void;
+        onFinishHydration: (fn: (state: ViewerState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<ViewerState, {
+            cameraMode: "perspective" | "orthographic";
+            theme: "light" | "dark";
+            levelMode: "stacked" | "exploded" | "solo" | "manual";
+            wallMode: "up" | "cutaway" | "down";
+            projectPreferences: Record<string, {
+                showScans?: boolean;
+                showGuides?: boolean;
+                showGrid?: boolean;
+            }>;
+        }, unknown>>;
+    };
+}>;
 export default useViewer;
 //# sourceMappingURL=use-viewer.d.ts.map

package/dist/store/use-viewer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-viewer.d.ts","sourceRoot":"","sources":["../../src/store/use-viewer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,QAAQ,EACT,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAItC,KAAK,aAAa,GAAG;IACnB,UAAU,EAAE,YAAY,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACtC,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAChC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAC9B,WAAW,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;CAC/B,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,eAAe,EAAE,QAAQ,EAAE,CAAC;IAC5B,cAAc,EAAE,QAAQ,EAAE,CAAC;CAC5B,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,aAAa,CAAA;IACxB,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAChD,YAAY,EAAE,CAAC,EAAE,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,KAAK,IAAI,CAAA;IAEjE,UAAU,EAAE,aAAa,GAAG,cAAc,CAAA;IAC1C,aAAa,EAAE,CAAC,IAAI,EAAE,aAAa,GAAG,cAAc,KAAK,IAAI,CAAA;IAE7D,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAA;IACrD,YAAY,EAAE,CAAC,IAAI,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,KAAK,IAAI,CAAA;IAExE,QAAQ,EAAE,IAAI,GAAG,SAAS,GAAG,MAAM,CAAA;IACnC,WAAW,EAAE,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,GAAG,MAAM,KAAK,IAAI,CAAA;IAEtD,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IAErC,UAAU,EAAE,OAAO,CAAA;IACnB,aAAa,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;IAGtC,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,KAAK,IAAI,CAAA;IACvD,cAAc,EAAE,MAAM,IAAI,CAAA;IAE1B,QAAQ,EAAE,QAAQ,CAAA;IAGlB,WAAW,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAA;IACzC,cAAc,EAAE,CAAC,EAAE,EAAE,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,IAAI,KAAK,IAAI,CAAA;IAE1D,cAAc,EAAE,OAAO,CAAA;IACvB,iBAAiB,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAA;CAC/C,CAAA;AAED,QAAA,MAAM,SAAS,0EAwDZ,CAAC;AAEJ,eAAe,SAAS,CAAC"}
+{"version":3,"file":"use-viewer.d.ts","sourceRoot":"","sources":["../../src/store/use-viewer.ts"],"names":[],"mappings":"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"}

package/dist/store/use-viewer.js

@@ -1,33 +1,84 @@
-"use client";
-import { create } from "zustand";
-const useViewer = create()((set, get) => ({
+'use client';
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+const useViewer = create()(persist((set) => ({
     selection: { buildingId: null, levelId: null, zoneId: null, selectedIds: [] },
     hoveredId: null,
     setHoveredId: (id) => set({ hoveredId: id }),
-    cameraMode: "perspective",
+    cameraMode: 'perspective',
     setCameraMode: (mode) => set({ cameraMode: mode }),
-    levelMode: "stacked",
+    theme: 'light',
+    setTheme: (theme) => set({ theme }),
+    levelMode: 'stacked',
     setLevelMode: (mode) => set({ levelMode: mode }),
-    wallMode: 'cutaway',
+    wallMode: 'up',
     setWallMode: (mode) => set({ wallMode: mode }),
     showScans: true,
-    setShowScans: (show) => set({ showScans: show }),
+    setShowScans: (show) => set((state) => {
+        const projectPreferences = { ...(state.projectPreferences || {}) };
+        if (state.projectId) {
+            projectPreferences[state.projectId] = {
+                ...(projectPreferences[state.projectId] || {}),
+                showScans: show,
+            };
+        }
+        return { showScans: show, projectPreferences };
+    }),
     showGuides: true,
-    setShowGuides: (show) => set({ showGuides: show }),
+    setShowGuides: (show) => set((state) => {
+        const projectPreferences = { ...(state.projectPreferences || {}) };
+        if (state.projectId) {
+            projectPreferences[state.projectId] = {
+                ...(projectPreferences[state.projectId] || {}),
+                showGuides: show,
+            };
+        }
+        return { showGuides: show, projectPreferences };
+    }),
+    showGrid: true,
+    setShowGrid: (show) => set((state) => {
+        const projectPreferences = { ...(state.projectPreferences || {}) };
+        if (state.projectId) {
+            projectPreferences[state.projectId] = {
+                ...(projectPreferences[state.projectId] || {}),
+                showGrid: show,
+            };
+        }
+        return { showGrid: show, projectPreferences };
+    }),
+    projectId: null,
+    setProjectId: (id) => set((state) => {
+        if (!id)
+            return { projectId: id };
+        const prefs = state.projectPreferences?.[id] || {};
+        return {
+            projectId: id,
+            showScans: prefs.showScans ?? true,
+            showGuides: prefs.showGuides ?? true,
+            showGrid: prefs.showGrid ?? true,
+        };
+    }),
+    projectPreferences: {},
     setSelection: (updates) => set((state) => {
         const newSelection = { ...state.selection, ...updates };
-        // Hierarchy Guard: If we change a high-level parent, reset the children
+        // Hierarchy Guard: If we change a high-level parent, reset the children unless explicitly provided
         if (updates.buildingId !== undefined) {
-            newSelection.levelId = null;
-            newSelection.zoneId = null;
-            newSelection.selectedIds = [];
+            if (updates.levelId === undefined)
+                newSelection.levelId = null;
+            if (updates.zoneId === undefined)
+                newSelection.zoneId = null;
+            if (updates.selectedIds === undefined)
+                newSelection.selectedIds = [];
         }
-        else if (updates.levelId !== undefined) {
-            newSelection.zoneId = null;
-            newSelection.selectedIds = [];
+        if (updates.levelId !== undefined) {
+            if (updates.zoneId === undefined)
+                newSelection.zoneId = null;
+            if (updates.selectedIds === undefined)
+                newSelection.selectedIds = [];
         }
-        else if (updates.zoneId !== undefined) {
-            newSelection.selectedIds = [];
+        if (updates.zoneId !== undefined) {
+            if (updates.selectedIds === undefined)
+                newSelection.selectedIds = [];
         }
         return { selection: newSelection };
     }),
@@ -42,7 +93,18 @@ const useViewer = create()((set, get) => ({
     outliner: { selectedObjects: [], hoveredObjects: [] },
     exportScene: null,
     setExportScene: (fn) => set({ exportScene: fn }),
+    debugColors: false,
+    setDebugColors: (enabled) => set({ debugColors: enabled }),
     cameraDragging: false,
     setCameraDragging: (dragging) => set({ cameraDragging: dragging }),
+}), {
+    name: 'viewer-preferences',
+    partialize: (state) => ({
+        cameraMode: state.cameraMode,
+        theme: state.theme,
+        levelMode: state.levelMode,
+        wallMode: state.wallMode,
+        projectPreferences: state.projectPreferences,
+    }),
 }));
 export default useViewer;

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

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

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

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

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

@@ -0,0 +1,95 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { pointInPolygon, sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
+import { Html } from '@react-three/drei';
+import { createPortal, useFrame } from '@react-three/fiber';
+import { useState } from 'react';
+import { Vector3 } from 'three';
+import { useShallow } from 'zustand/react/shallow';
+import useViewer from '../../store/use-viewer';
+const _tempVec = new Vector3();
+// ---- Parent: one overlay per interactive item ----
+export const InteractiveSystem = () => {
+    const interactiveNodeIds = useScene(useShallow((state) => Object.values(state.nodes)
+        .filter((n) => n.type === 'item' && n.asset.interactive != null)
+        .map((n) => n.id)));
+    return (_jsx(_Fragment, { children: interactiveNodeIds.map((id) => (_jsx(ItemControlsOverlay, { nodeId: id }, id))) }));
+};
+// ---- Child: polls sceneRegistry then portals controls into the item group ----
+const ItemControlsOverlay = ({ nodeId }) => {
+    const node = useScene((state) => state.nodes[nodeId]);
+    const [itemObj, setItemObj] = useState(null);
+    useFrame(() => {
+        if (itemObj)
+            return;
+        const obj = sceneRegistry.nodes.get(nodeId);
+        if (obj)
+            setItemObj(obj);
+    });
+    const controlValues = useInteractive(useShallow((state) => state.items[nodeId]?.controlValues));
+    const setControlValue = useInteractive((state) => state.setControlValue);
+    const zoneId = useViewer((s) => s.selection.zoneId);
+    const zonePolygon = useScene((s) => {
+        if (!zoneId)
+            return null;
+        const z = s.nodes[zoneId];
+        return z?.polygon ?? null;
+    });
+    if (!(itemObj && controlValues && node?.asset.interactive))
+        return null;
+    const { controls } = node.asset.interactive;
+    const [, height] = node.asset.dimensions;
+    let opacity = 0;
+    let pointerEvents = 'none';
+    if (zoneId && zonePolygon?.length) {
+        itemObj.getWorldPosition(_tempVec);
+        const inside = pointInPolygon(_tempVec.x, _tempVec.z, zonePolygon);
+        opacity = inside ? 1 : 0.1;
+        pointerEvents = inside ? 'auto' : 'none';
+    }
+    return createPortal(_jsx(Html, { center: true, distanceFactor: 8, occlude: true, 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,
+                userSelect: 'none',
+                opacity,
+                transition: 'opacity 0.3s ease',
+            }, children: controls.map((control, i) => (_jsx(ControlWidget, { control: control, onChange: (v) => setControlValue(nodeId, i, v), value: controlValues[i] ?? false }, i))) }) }), itemObj);
+};
+// ---- Control widgets ----
+const ControlWidget = ({ control, value, onChange, }) => {
+    const labelStyle = {
+        color: 'white',
+        fontSize: 11,
+        fontFamily: 'monospace',
+        display: 'flex',
+        flexDirection: 'column',
+        gap: 2,
+    };
+    if (control.kind === 'toggle') {
+        return (_jsx("button", { onClick: () => onChange(!value), style: {
+                background: value ? '#4ade80' : '#374151',
+                color: 'white',
+                border: 'none',
+                borderRadius: 4,
+                padding: '4px 8px',
+                cursor: 'pointer',
+                fontSize: 12,
+                fontFamily: 'monospace',
+                transition: 'background 0.2s',
+            }, children: control.label ?? (value ? 'On' : 'Off') }));
+    }
+    if (control.kind === 'slider') {
+        return (_jsxs("label", { style: labelStyle, children: [_jsxs("span", { children: [control.label, ": ", value, control.unit ? ` ${control.unit}` : ''] }), _jsx("input", { max: control.max, min: control.min, onChange: (e) => onChange(Number(e.target.value)), onPointerDown: (e) => e.stopPropagation(), step: control.step, type: "range", value: value })] }));
+    }
+    if (control.kind === 'temperature') {
+        return (_jsxs("label", { style: labelStyle, children: [_jsxs("span", { children: [control.label, ": ", value, "\u00B0", control.unit] }), _jsx("input", { max: control.max, min: control.min, onChange: (e) => onChange(Number(e.target.value)), onPointerDown: (e) => e.stopPropagation(), step: 1, type: "range", value: value })] }));
+    }
+    return null;
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"item-light-system.d.ts","sourceRoot":"","sources":["../../../src/systems/item-light/item-light-system.tsx"],"names":[],"mappings":"AAwFA,wBAAgB,eAAe,4CA+M9B"}

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

@@ -0,0 +1,235 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { sceneRegistry, useInteractive, useScene } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+import { useRef } from 'react';
+import { MathUtils, Vector3 } from 'three';
+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();
+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)
+            return Number.POSITIVE_INFINITY;
+    }
+    const { nodeId, effect } = reg;
+    const obj = sceneRegistry.nodes.get(nodeId);
+    if (!obj)
+        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)
+    const angular = 1 - dot;
+    // Normalised distance component (assumes scenes < 200 units)
+    const dist = _camPos.distanceTo(_itemPos) / 200;
+    // ── Level factor ──────────────────────────────────────────────────────────
+    const node = nodes[nodeId];
+    const itemLevelId = node?.parentId ?? null;
+    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;
+        }
+    }
+    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;
+}
+export function ItemLightSystem() {
+    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) => {
+        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);
+        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;
+            // Score every registration
+            const scored = [];
+            for (const [key, reg] of registrations) {
+                scored.push({
+                    key,
+                    score: scoreRegistration(reg, nodes, selectedLevelId, levelMode, interactiveState),
+                });
+            }
+            scored.sort((a, b) => a.score - b.score);
+            // Build the desired assignment (top POOL_SIZE keys)
+            const desired = scored.slice(0, POOL_SIZE).map((s) => s.key);
+            // 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.effect.color);
+                            light.distance = reg.effect.distance ?? 0;
+                        }
+                    }
+                }
+                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.effect.color);
+                            light.distance = reg.effect.distance ?? 0;
+                        }
+                    }
+                }
+                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;
+            }
+            // 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];
+            light.intensity = MathUtils.lerp(light.intensity, targetIntensity, dt * 12);
+        }
+    });
+    return (_jsx(_Fragment, { children: Array.from({ length: POOL_SIZE }, (_, i) => (_jsx("pointLight", { castShadow: false, intensity: 0, ref: (el) => {
+                lightRefs.current[i] = el;
+            } }, i))) }));
+}