@pascal-app/viewer 1.0.3 → 1.0.5

package/dist/components/viewer/glb-interactive.js

@@ -1,13 +1,19 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { pointInPolygon, useInteractive, } from '@pascal-app/core';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { containsPoint, isScriptedNode, scriptedOrigin, scriptedSize, scriptInteractive, useInteractive, } from '@pascal-app/core';
+import { evaluateRecipe, } from '@pascal-app/core/procedural-items';
 import { Html } from '@react-three/drei';
-import { createPortal, useFrame } from '@react-three/fiber';
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { createPortal, useFrame, useThree } from '@react-three/fiber';
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
 import { LoopRepeat, MathUtils, Vector3, } from 'three';
 import { useShallow } from 'zustand/react/shallow';
+import { SCENE_LAYER } from '../../lib/layers';
+import { decorateProceduralEmission, proceduralSlotMeshes, setProceduralEmission, } from '../../lib/procedural-emission';
+import { useItemLightPool } from '../../store/use-item-light-pool';
 import useViewer from '../../store/use-viewer';
 import { ControlWidget } from '../../systems/interactive/control-widget';
+import { proceduralControlDescriptors } from '../../systems/interactive/procedural-controls';
+import { ScriptedClips } from '../../systems/interactive/scripted-clips';
 /** Pull the interactive items out of a scene graph. Only items that actually
  *  carry effects (light / animation) are returned — everything else baked
  *  faithfully and needs no runtime help. */
@@ -18,6 +24,48 @@ export function buildGlbInteractiveItems(sceneGraph) {
     const items = [];
     for (const [id, raw] of Object.entries(nodes)) {
         const node = raw;
+        if (node?.type === 'procedural-item') {
+            const procedural = raw;
+            const evaluation = evaluateRecipe(procedural.recipe, procedural.parameters);
+            if (!evaluation.lights.length && !evaluation.motions.length)
+                continue;
+            items.push({
+                pascalId: id,
+                label: procedural.name ?? id,
+                height: evaluation.max[1],
+                interactive: { controls: [], effects: [] },
+                procedural: {
+                    lights: evaluation.lights,
+                    parts: procedural.recipe.parts,
+                    recipe: procedural.recipe,
+                },
+            });
+            continue;
+        }
+        // A node built from a script: its controls come from what the script
+        // emitted, as in the editor.
+        if (isScriptedNode(raw)) {
+            const scripted = raw;
+            const interactive = scriptInteractive(scripted.source.manifest, scriptedOrigin(scripted));
+            if (!interactive)
+                continue;
+            const [, height] = scriptedSize(scripted.source.manifest);
+            items.push({
+                pascalId: id,
+                label: scripted.name ??
+                    (scripted.type === 'item'
+                        ? scripted.asset.name
+                        : `${scripted.type[0].toUpperCase()}${scripted.type.slice(1)}`),
+                // A window or door is placed by its centre, everything else by its base.
+                height: scripted.type === 'window' || scripted.type === 'door'
+                    ? height / 2
+                    : height * (scripted.type === 'item' ? (scripted.scale?.[1] ?? 1) : 1),
+                interactive,
+                scripted: true,
+                localScale: scripted.type === 'item' ? scripted.scale : [1, 1, 1],
+            });
+            continue;
+        }
         if (node?.type !== 'item')
             continue;
         const interactive = node.asset?.interactive;
@@ -34,6 +82,86 @@ export function buildGlbInteractiveItems(sceneGraph) {
     }
     return items;
 }
+export function buildGlbLightRegs(items, identity) {
+    const regs = [];
+    for (const item of items) {
+        const object = identity.get(item.pascalId);
+        if (!object)
+            continue;
+        if (item.procedural) {
+            const groups = new Map();
+            object.traverse((child) => {
+                const motion = child.userData.proceduralMotion;
+                if (motion?.groupId)
+                    groups.set(motion.groupId, child);
+            });
+            for (const light of item.procedural.lights) {
+                const motion = light.motionGroup ? groups.get(light.motionGroup) : undefined;
+                const local = new Vector3(...light.position);
+                // A nested group's position is relative to its parent group: the design-space pivot
+                // is the sum along its chain of motion groups.
+                for (let group = motion; group && group !== object; group = group.parent ?? undefined)
+                    if (group.userData.proceduralMotion)
+                        local.sub(group.position);
+                regs.push({
+                    key: `${item.pascalId}:procedural:${light.id}`,
+                    nodeId: item.pascalId,
+                    object,
+                    color: light.color,
+                    distance: light.distance,
+                    getWorldPosition: (out) => {
+                        const anchor = motion ?? object;
+                        anchor.updateWorldMatrix(true, false);
+                        out.copy(local).applyMatrix4(anchor.matrixWorld);
+                    },
+                    getIntensity: () => light.intensity,
+                    isOn: () => useInteractive.getState().procedural[item.pascalId]?.lightsOn ??
+                        useInteractive.getState().lampDefault,
+                    levelId: findLevelId(object),
+                });
+            }
+        }
+        const controls = item.interactive.controls;
+        const toggleIndex = controls.findIndex((control) => control.kind === 'toggle');
+        const sliderIndex = controls.findIndex((control) => control.kind === 'slider');
+        const slider = sliderIndex >= 0 ? controls[sliderIndex] : null;
+        item.interactive.effects.forEach((effect, index) => {
+            if (effect.kind !== 'light')
+                return;
+            regs.push({
+                key: `${item.pascalId}:${index}`,
+                nodeId: item.pascalId,
+                object,
+                color: effect.color,
+                distance: effect.distance ?? 0,
+                getWorldPosition: (out) => {
+                    object.updateWorldMatrix(true, false);
+                    if (item.scripted) {
+                        const scale = item.localScale ?? [1, 1, 1];
+                        out
+                            .set(effect.offset[0] * scale[0], effect.offset[1] * scale[1], effect.offset[2] * scale[2])
+                            .applyMatrix4(object.matrixWorld);
+                        return;
+                    }
+                    object.getWorldPosition(out);
+                    out.set(out.x + effect.offset[0], out.y + effect.offset[1], out.z + effect.offset[2]);
+                },
+                getIntensity: () => {
+                    const values = useInteractive.getState().items[item.pascalId]?.controlValues;
+                    const raw = slider ? (values?.[sliderIndex] ?? slider.min) : 1;
+                    const fraction = slider && slider.max > slider.min ? (raw - slider.min) / (slider.max - slider.min) : 1;
+                    return MathUtils.lerp(effect.intensityRange[0], effect.intensityRange[1], fraction);
+                },
+                isOn: () => {
+                    const values = useInteractive.getState().items[item.pascalId]?.controlValues;
+                    return toggleIndex < 0 || Boolean(values?.[toggleIndex]);
+                },
+                levelId: findLevelId(object),
+            });
+        });
+    }
+    return regs;
+}
 const _itemPos = new Vector3();
 /**
  * Re-creates the item-driven interactivity the parametric viewer has — pooled
@@ -43,18 +171,26 @@ const _itemPos = new Vector3();
  * the GLB itself, so the artifact stays integrator-clean.
  */
 export function GlbInteractive({ items, identity, zones, actions, levelOrder, }) {
-    // Seed control state for every interactive item. The viewer shows a baked
-    // scene "lit": toggles default ON (the editor defaults them off) and sliders
-    // to their authored default, so lamps glow and fans spin on load. Explicit
-    // overlay toggles then win. Cleared on unmount so the global store never
-    // carries state across scenes.
+    const scene = useThree((state) => state.scene);
+    useLayoutEffect(() => {
+        useItemLightPool.getState().setBakedCanvas(scene, true);
+        return () => useItemLightPool.getState().setBakedCanvas(scene, false);
+    }, [scene]);
+    // Baked catalog animation toggles start on; light toggles follow the current
+    // theme; an authored object's toggles keep their own defaults, as in the
+    // editor. Clear per-item state on unmount so it cannot carry into another scene.
     useEffect(() => {
         const store = useInteractive.getState();
         for (const item of items) {
-            store.initItem(item.pascalId, item.interactive);
-            item.interactive.controls.forEach((control, i) => {
-                if (control.kind === 'toggle')
-                    store.setControlValue(item.pascalId, i, true);
+            store.initItem(item.pascalId, item.interactive, true);
+            if (item.scripted)
+                continue;
+            const lampIndex = item.interactive.effects.some((effect) => effect.kind === 'light')
+                ? item.interactive.controls.findIndex((control) => control.kind === 'toggle')
+                : -1;
+            item.interactive.controls.forEach((control, index) => {
+                if (control.kind === 'toggle' && index !== lampIndex)
+                    store.setControlValue(item.pascalId, index, true);
             });
         }
         return () => {
@@ -64,40 +200,12 @@ export function GlbInteractive({ items, identity, zones, actions, levelOrder, })
         };
     }, [items]);
     const animationItems = useMemo(() => items.filter((item) => item.interactive.effects.some((e) => e.kind === 'animation')), [items]);
-    // Light registrations: one per item with a light effect, joined to its baked
-    // node. Fed to a fixed pool (below) rather than mounting a light per item.
-    const lightRegs = useMemo(() => {
-        const regs = [];
-        for (const item of items) {
-            const effect = item.interactive.effects.find((e) => e.kind === 'light');
-            if (!effect)
-                continue;
-            const object = identity.get(item.pascalId);
-            if (!object)
-                continue;
-            const controls = item.interactive.controls;
-            const toggleIndex = controls.findIndex((c) => c.kind === 'toggle');
-            const sliderIndex = controls.findIndex((c) => c.kind === 'slider');
-            const slider = sliderIndex >= 0 ? controls[sliderIndex] : null;
-            regs.push({
-                key: item.pascalId,
-                object,
-                effect,
-                toggleIndex,
-                sliderIndex,
-                hasSlider: !!slider,
-                sliderMin: slider?.min ?? 0,
-                sliderMax: slider?.max ?? 1,
-                levelId: findLevelId(object),
-            });
-        }
-        return regs;
-    }, [items, identity]);
+    const lightRegs = useMemo(() => buildGlbLightRegs(items, identity), [items, identity]);
     const levelIndexById = useMemo(() => new Map(levelOrder.map((id, i) => [id, i])), [levelOrder]);
-    // Controls overlay is scoped to the focused zone (matches the parametric
-    // viewer). Project the zone's baked-local polygon into world space once so an
-    // item's world position can be point-tested regardless of level stacking.
+    // Project the zone's baked-local polygon into world space so focused zone
+    // membership still works after level stacking moves its parent.
     const focusedZoneId = useViewer((s) => s.selection.zoneId);
+    const selectedIds = useViewer((s) => s.selection.selectedIds);
     const worldPolygon = useMemo(() => {
         if (!focusedZoneId)
             return null;
@@ -105,16 +213,51 @@ export function GlbInteractive({ items, identity, zones, actions, levelOrder, })
         if (!zone)
             return null;
         zone.node.updateWorldMatrix(true, false);
-        return zone.polygon.map(([x, z]) => {
+        const project = (ring) => ring.map(([x, z]) => {
             const v = new Vector3(x, 0, z).applyMatrix4(zone.node.matrixWorld);
             return [v.x, v.z];
         });
+        return { outer: project(zone.polygon), holes: (zone.holes ?? []).map(project) };
     }, [focusedZoneId, zones]);
-    return (_jsxs(_Fragment, { children: [_jsx(GlbItemLights, { levelIndexById: levelIndexById, regs: lightRegs }), animationItems.map((item) => (_jsx(GlbItemAnimation, { actions: actions, item: item }, item.pascalId))), items.map((item) => {
+    return (_jsxs(_Fragment, { children: [_jsx(GlbItemLights, { levelIndexById: levelIndexById, regs: lightRegs }), animationItems.map((item) => item.scripted ? (_jsx(GlbScriptedClips, { actions: actions, item: item }, item.pascalId)) : (_jsx(GlbItemAnimation, { actions: actions, item: item }, item.pascalId))), items
+                .filter((item) => item.procedural?.lights.length)
+                .map((item) => {
+                const object = identity.get(item.pascalId);
+                return object ? (_jsx(GlbProceduralEmission, { item: item, object: object }, item.pascalId)) : null;
+            }), items
+                .filter((item) => worldPolygon || selectedIds.includes(item.pascalId))
+                .map((item) => {
                 const object = identity.get(item.pascalId);
-                return object ? (_jsx(GlbItemControls, { item: item, object: object, worldPolygon: worldPolygon }, item.pascalId)) : null;
+                return object ? (_jsx(GlbItemControls, { isSelected: selectedIds.includes(item.pascalId), item: item, object: object, worldPolygon: worldPolygon }, item.pascalId)) : null;
             })] }));
 }
+function GlbProceduralEmission({ item, object }) {
+    useEffect(() => {
+        const lights = item.procedural?.lights ?? [];
+        const restore = decorateProceduralEmission(object, lights, true);
+        const update = () => {
+            const on = useInteractive.getState().procedural[item.pascalId]?.lightsOn ??
+                useInteractive.getState().lampDefault;
+            const slots = new Set(lights.map((light) => light.emissiveSlot).filter(Boolean));
+            for (const mesh of proceduralSlotMeshes(object, slots)) {
+                const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+                for (const material of materials)
+                    setProceduralEmission(material, on);
+            }
+        };
+        update();
+        const unsubscribe = useInteractive.subscribe((state, previous) => {
+            if (state.procedural[item.pascalId] !== previous.procedural[item.pascalId] ||
+                state.lampDefault !== previous.lampDefault)
+                update();
+        });
+        return () => {
+            unsubscribe();
+            restore();
+        };
+    }, [item, object]);
+    return null;
+}
 // ── Pooled item lights ──────────────────────────────────────────────────────
 //
 // Mirrors the parametric `ItemLightSystem`: a fixed pool of point lights is
@@ -142,15 +285,21 @@ function findLevelId(object) {
     }
     return null;
 }
-function scoreReg(reg, selectedLevelId, levelMode, levelIndexById, interactiveState) {
-    // Toggled-off lights contribute no illumination — drop them from the pool.
-    if (reg.toggleIndex >= 0 && !interactiveState.items[reg.key]?.controlValues?.[reg.toggleIndex]) {
-        return Number.POSITIVE_INFINITY;
+function isRendered(object) {
+    let current = object;
+    while (current) {
+        if (!current.visible || !current.layers.isEnabled(SCENE_LAYER))
+            return false;
+        current = current.parent;
     }
-    reg.object.getWorldPosition(_lightWorld);
-    _lightWorld.x += reg.effect.offset[0];
-    _lightWorld.y += reg.effect.offset[1];
-    _lightWorld.z += reg.effect.offset[2];
+    return true;
+}
+function scoreReg(reg, selectedLevelId, levelMode, levelIndexById) {
+    if (!reg.isOn() || !isRendered(reg.object))
+        return Number.POSITIVE_INFINITY;
+    if (selectedLevelId && reg.levelId !== selectedLevelId && levelMode === 'solo')
+        return Number.POSITIVE_INFINITY;
+    reg.getWorldPosition(_lightWorld);
     _dir.copy(_lightWorld).sub(_camPos).normalize();
     const angular = 1 - _camFwd.dot(_dir);
     const dist = _camPos.distanceTo(_lightWorld) / 200;
@@ -173,7 +322,6 @@ function GlbItemLights({ regs, levelIndexById, }) {
     const regByKey = useMemo(() => new Map(regs.map((r) => [r.key, r])), [regs]);
     useFrame(({ camera }, delta) => {
         const dt = Math.min(delta, 0.1);
-        const interactiveState = useInteractive.getState();
         camera.getWorldPosition(_camPos);
         camera.getWorldDirection(_camFwd);
         const camMoved = _camPos.distanceTo(prevCamPos.current) > CAM_MOVE_DIST ||
@@ -188,7 +336,7 @@ function GlbItemLights({ regs, levelIndexById, }) {
             const levelMode = viewer.levelMode;
             const scored = regs.map((reg) => ({
                 key: reg.key,
-                score: scoreReg(reg, selectedLevelId, levelMode, levelIndexById, interactiveState),
+                score: scoreReg(reg, selectedLevelId, levelMode, levelIndexById),
             }));
             scored.sort((a, b) => a.score - b.score);
             const scoreByKey = new Map(scored.map((s) => [s.key, s.score]));
@@ -244,8 +392,8 @@ function GlbItemLights({ regs, levelIndexById, }) {
                         const light = lightRefs.current[freeSlot];
                         const reg = regByKey.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;
                         }
                     }
                 }
@@ -283,8 +431,8 @@ function GlbItemLights({ regs, levelIndexById, }) {
                     if (slot.key) {
                         const reg = regByKey.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;
                         }
                     }
                 }
@@ -299,24 +447,12 @@ function GlbItemLights({ regs, levelIndexById, }) {
                 slot.key = null;
                 continue;
             }
-            reg.object.getWorldPosition(_lightWorld);
-            light.position.set(_lightWorld.x + reg.effect.offset[0], _lightWorld.y + reg.effect.offset[1], _lightWorld.z + reg.effect.offset[2]);
-            const values = interactiveState.items[reg.key]?.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 =
-                    reg.sliderMax > reg.sliderMin
-                        ? (raw - reg.sliderMin) / (reg.sliderMax - reg.sliderMin)
-                        : 1;
-            }
-            const targetIntensity = isOn
-                ? MathUtils.lerp(reg.effect.intensityRange[0], reg.effect.intensityRange[1], t)
-                : reg.effect.intensityRange[0];
+            reg.getWorldPosition(_lightWorld);
+            light.position.copy(_lightWorld);
+            const targetIntensity = reg.isOn() && isRendered(reg.object) ? reg.getIntensity() : 0;
             light.intensity = MathUtils.lerp(light.intensity, targetIntensity, dt * 12);
         }
-    });
+    }, 6);
     return (_jsx(_Fragment, { children: Array.from({ length: POOL_SIZE }, (_, i) => (_jsx("pointLight", { castShadow: false, intensity: 0, ref: (el) => {
                 lightRefs.current[i] = el;
             } }, i))) }));
@@ -345,16 +481,47 @@ function GlbItemAnimation({ item, actions, }) {
     }, [actions, item.pascalId, isOn]);
     return null;
 }
+/** Plays an authored object's baked clips through the shared `ScriptedClips`,
+ *  addressing each by the name the script gave it. */
+function GlbScriptedClips({ item, actions, }) {
+    // drei creates each action on first read, once the scene root is mounted, so
+    // forward reads instead of copying the actions during render.
+    const scriptActions = useMemo(() => {
+        const prefix = `${item.pascalId}: `;
+        const forwarded = {};
+        for (const name of Object.keys(actions)) {
+            if (!name.startsWith(prefix))
+                continue;
+            Object.defineProperty(forwarded, name.slice(prefix.length), {
+                enumerable: true,
+                get: () => actions[name],
+            });
+        }
+        return forwarded;
+    }, [actions, item.pascalId]);
+    return (_jsx(ScriptedClips, { actions: scriptActions, interactive: item.interactive, nodeId: item.pascalId }));
+}
 const FADE_MS = 300;
-/** Controls overlay for one item — fades in while the item sits inside the
- *  focused zone, portaled above the baked node. */
-function GlbItemControls({ item, object, worldPolygon, }) {
+/** Controls overlay for a selected item or one inside the focused zone. */
+function GlbItemControls({ item, object, worldPolygon, isSelected, }) {
     const controlValues = useInteractive(useShallow((s) => s.items[item.pascalId]?.controlValues));
+    const proceduralState = useInteractive((s) => s.procedural[item.pascalId]);
+    const lampDefault = useInteractive((s) => s.lampDefault);
     const setControlValue = useInteractive((s) => s.setControlValue);
-    let visible = false;
-    if (worldPolygon?.length) {
+    const togglePart = useInteractive((s) => s.toggleProceduralPart);
+    const toggleLights = useInteractive((s) => s.toggleProceduralLights);
+    const descriptors = item.procedural
+        ? proceduralControlDescriptors(item.procedural.recipe ?? { parts: item.procedural.parts }, proceduralState, (partId) => togglePart(item.pascalId, partId), () => toggleLights(item.pascalId), lampDefault)
+        : item.interactive.controls.map((control, index) => ({
+            key: String(index),
+            control,
+            value: controlValues?.[index] ?? false,
+            onChange: (value) => setControlValue(item.pascalId, index, value),
+        }));
+    let visible = isSelected;
+    if (worldPolygon) {
         object.getWorldPosition(_itemPos);
-        visible = pointInPolygon(_itemPos.x, _itemPos.z, worldPolygon);
+        visible = visible || containsPoint([worldPolygon], [_itemPos.x, _itemPos.z]);
     }
     // Fade in on mount and fade out before unmounting the <Html>.
     const [mounted, setMounted] = useState(false);
@@ -375,7 +542,7 @@ function GlbItemControls({ item, object, worldPolygon, }) {
         const timeout = setTimeout(() => setMounted(false), FADE_MS);
         return () => clearTimeout(timeout);
     }, [visible]);
-    if (!(mounted && controlValues))
+    if (!(mounted && descriptors.length))
         return null;
     return createPortal(_jsx(Html, { center: true, distanceFactor: 8, eps: -1, position: [0, item.height + 0.3, 0], zIndexRange: [20, 0], children: _jsx("div", { onClick: (e) => e.stopPropagation(), onPointerDown: (e) => e.stopPropagation(), onPointerUp: (e) => e.stopPropagation(), style: {
                 display: 'flex',
@@ -390,5 +557,5 @@ function GlbItemControls({ item, object, worldPolygon, }) {
                 userSelect: 'none',
                 opacity: shown ? 1 : 0,
                 transition: `opacity ${FADE_MS}ms ease`,
-            }, children: item.interactive.controls.map((control, i) => (_jsx(ControlWidget, { control: control, onChange: (v) => setControlValue(item.pascalId, i, v), value: controlValues[i] ?? false }, i))) }) }), object);
+            }, children: descriptors.map((descriptor) => (_jsx(ControlWidget, { control: descriptor.control, onChange: descriptor.onChange, value: descriptor.value }, descriptor.key))) }) }), object);
 }

package/dist/components/viewer/glb-mechanisms.d.ts

@@ -0,0 +1,10 @@
+import type { Object3D } from 'three';
+/**
+ * Baked nodes whose loop clips no other controller plays (a plugin kind's
+ * mechanism, such as an articulated asset's joints), read from the GLB alone:
+ * `pascalId` → its `: loop` clip names. `owned` holds the nodes procedural
+ * playback or the scene graph's interactive items already drive; openables
+ * keep their open/close path.
+ */
+export declare function bakedLoopMechanisms(identity: ReadonlyMap<string, Object3D>, owned: ReadonlySet<string>): Map<string, string[]>;
+//# sourceMappingURL=glb-mechanisms.d.ts.map

package/dist/components/viewer/glb-mechanisms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glb-mechanisms.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-mechanisms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAErC;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,EACvC,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GACzB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAWvB"}

package/dist/components/viewer/glb-mechanisms.js

@@ -0,0 +1,19 @@
+/**
+ * Baked nodes whose loop clips no other controller plays (a plugin kind's
+ * mechanism, such as an articulated asset's joints), read from the GLB alone:
+ * `pascalId` → its `: loop` clip names. `owned` holds the nodes procedural
+ * playback or the scene graph's interactive items already drive; openables
+ * keep their open/close path.
+ */
+export function bakedLoopMechanisms(identity, owned) {
+    const mechanisms = new Map();
+    for (const [id, object] of identity) {
+        const { clips, openable } = object.userData;
+        if (openable || owned.has(id) || !Array.isArray(clips))
+            continue;
+        const loops = clips.filter((clip) => typeof clip === 'string' && clip.endsWith(': loop'));
+        if (loops.length)
+            mechanisms.set(id, loops);
+    }
+    return mechanisms;
+}

package/dist/components/viewer/glb-reference-nodes.js

@@ -1,5 +1,5 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { bakePolicyOf, isNodeKindEnabled, nodeRegistry, } from '@pascal-app/core';
 import { createPortal } from '@react-three/fiber';
 import { memo, Suspense } from 'react';

package/dist/components/viewer/glb-replace-instances.js

@@ -1,5 +1,5 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { nodeRegistry } from '@pascal-app/core';
 import { createPortal } from '@react-three/fiber';
 import { Fragment, lazy, memo, Suspense, useMemo } from 'react';

package/dist/components/viewer/glb-scene.d.ts

@@ -1,41 +1,57 @@
 import { type AnyNode } from '@pascal-app/core';
+import * as THREE from 'three';
 import { type GlbInteractiveItem } from './glb-interactive';
-/** A building floor discovered in the baked GLB, ordered bottom-to-top. */
-export type GlbLevel = {
-    id: `level_${string}`;
-    label: string;
+/**
+ * A pointer on the baked building, handed to the host's selection rules: the
+ * baked node under it (its `pascalId`) and the hit in its level's local XZ,
+ * or null for empty space.
+ */
+export type GlbPickEvent = {
+    type: 'click' | 'hover';
+    pick: {
+        nodeId: string;
+        point: [number, number] | null;
+    } | null;
+    modifiers: {
+        alt: boolean;
+        ctrl: boolean;
+        meta: boolean;
+        shift: boolean;
+    };
 };
-/** pascalId → display info, reported so a host can label the breadcrumb. */
-export type GlbIdentity = Record<string, {
-    kind: string;
-    label: string;
-}>;
-/** What the cursor would act on at the current drill depth (for a hover label). */
-export type GlbHover = {
-    kind: string;
-    label: string;
-} | null;
 /** Walkthrough HUD state, reported each frame: the floor/room the camera is in
- *  and the openable door/window directly in view (for the reticle prompt). */
+ *  and the interactive part directly in view (for the reticle prompt). */
 export type GlbWalkthrough = {
     zoneLabel: string | null;
     floorLabel: string | null;
     door: {
         label: string;
         isOpen: boolean;
+        verb?: string;
     } | null;
 } | null;
+type HitCandidate = {
+    object: THREE.Object3D;
+    point: THREE.Vector3;
+};
+/**
+ * The baked node under a pointer that a click can land on: the nearest hit
+ * whose identity is not a kind that only frames (site, building, level, zone,
+ * ceiling) and is not on a hidden floor, with the hit in its level's local XZ.
+ */
+export declare function resolveGlbPick(hits: readonly HitCandidate[], identity: ReadonlyMap<string, THREE.Object3D>): (NonNullable<GlbPickEvent['pick']> & {
+    hitObject: THREE.Object3D;
+}) | null;
 /**
- * GLB-consuming viewer scene (plan phase 2). Loads a baked artifact and drives
- * the editor's presentation/interaction with no parametric scene graph. Hover
- * and click resolve through the drill hierarchy (building → level → zone →
- * object): the cursor targets the floor in the building view, the room or
- * structure in a level, and items/structure inside a room. Selection feeds the
- * existing outline post-FX, openables play their baked clips, and the shared
- * `useViewer.selection` (with its hierarchy guard) holds the drill state. The
- * host disables the parametric `SelectionManager` (`selectionManager="custom"`).
+ * GLB-consuming viewer scene. Loads a baked artifact and drives the viewer's
+ * presentation and interaction with no parametric scene graph. A pointer
+ * becomes a `GlbPickEvent` the host runs through its selection rules (the
+ * same rules as the parametric viewer); the shared `useViewer.selection` and
+ * `hoveredId` then drive the outline, and openables play their baked clips
+ * when clicked. The host disables the parametric `SelectionManager`
+ * (`selectionManager="custom"`).
  */
-export declare function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes, onLevelsChange, onIdentityChange, onHoverChange, onWalkthroughChange, }: {
+export declare function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes, onObjectsChange, onPick, onWalkthroughChange, }: {
     url: string;
     /** Light / animation effects + controls recovered from the DB scene graph,
      *  joined to the baked nodes by `pascalId` to re-light + re-animate the GLB. */
@@ -46,9 +62,11 @@ export declare function GlbScene({ url, interactiveItems, referenceNodes, replac
     /** `bake: 'replace'` nodes (e.g. plugin trees): baked static but re-rendered
      *  live here via their `bakeReplaceRenderer`; the baked meshes are hidden. */
     replaceNodes?: AnyNode[];
-    onLevelsChange?: (levels: GlbLevel[]) => void;
-    onIdentityChange?: (identity: GlbIdentity) => void;
-    onHoverChange?: (hover: GlbHover) => void;
+    /** pascalId → baked object, so the host can place room pills and frame nodes. */
+    onObjectsChange?: (objects: ReadonlyMap<string, THREE.Object3D>) => void;
+    /** Clicks and hovers on the building; without it the scene is look-only. */
+    onPick?: (event: GlbPickEvent) => void;
     onWalkthroughChange?: (state: GlbWalkthrough) => void;
 }): import("react").JSX.Element;
+export {};
 //# sourceMappingURL=glb-scene.d.ts.map

package/dist/components/viewer/glb-scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glb-scene.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-scene.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,OAAO,EAAkC,MAAM,kBAAkB,CAAA;AAc/E,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAqB3E,2EAA2E;AAC3E,MAAM,MAAM,QAAQ,GAAG;IAAE,EAAE,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/D,4EAA4E;AAC5E,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAEzE,mFAAmF;AACnF,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAA;AAE7D;8EAC8E;AAC9E,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAA;CAChD,GAAG,IAAI,CAAA;AA8NR;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,EACvB,GAAG,EACH,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,mBAAmB,GACpB,EAAE;IACD,GAAG,EAAE,MAAM,CAAA;IACX;oFACgF;IAChF,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,CAAA;IACvC;mFAC+E;IAC/E,cAAc,CAAC,EAAE,OAAO,EAAE,CAAA;IAC1B;kFAC8E;IAC9E,YAAY,CAAC,EAAE,OAAO,EAAE,CAAA;IACxB,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,IAAI,CAAA;IAC7C,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,WAAW,KAAK,IAAI,CAAA;IAClD,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAA;IACzC,mBAAmB,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAA;CACtD,+BAkzBA"}
+{"version":3,"file":"glb-scene.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-scene.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EAYb,MAAM,kBAAkB,CAAA;AAQzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAS9B,OAAO,EAAkB,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAmB3E;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,OAAO,GAAG,OAAO,CAAA;IACvB,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAA;IAC/D,SAAS,EAAE;QAAE,GAAG,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAA;CAC1E,CAAA;AAKD;0EAC0E;AAC1E,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,IAAI,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAC/D,GAAG,IAAI,CAAA;AAoDR,KAAK,YAAY,GAAG;IAAE,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAA;CAAE,CAAA;AA0CpE;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,YAAY,EAAE,EAC7B,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,GAC5C,CAAC,WAAW,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,GAAG;IAAE,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAA;CAAE,CAAC,GAAG,IAAI,CAkB5E;AASD;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,EACvB,GAAG,EACH,gBAAgB,EAChB,cAAc,EACd,YAAY,EACZ,eAAe,EACf,MAAM,EACN,mBAAmB,GACpB,EAAE;IACD,GAAG,EAAE,MAAM,CAAA;IACX;oFACgF;IAChF,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,CAAA;IACvC;mFAC+E;IAC/E,cAAc,CAAC,EAAE,OAAO,EAAE,CAAA;IAC1B;kFAC8E;IAC9E,YAAY,CAAC,EAAE,OAAO,EAAE,CAAA;IACxB,iFAAiF;IACjF,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAA;IACxE,4EAA4E;IAC5E,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IACtC,mBAAmB,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAA;CACtD,+BA8xBA"}