@pascal-app/viewer 0.9.1 → 0.9.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"glb-interactive.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-interactive.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,SAAS,EACd,KAAK,WAAW,EAGhB,KAAK,UAAU,EAGhB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EACL,KAAK,eAAe,EAGpB,KAAK,QAAQ,EAGd,MAAM,OAAO,CAAA;AAKd;;kFAEkF;AAClF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,SAAS,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,WAAW,CAAA;CACzB,CAAA;AAED,8EAA8E;AAC9E,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,QAAQ,CAAA;IACd,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;CAC5B,CAAA;AAED;;4CAE4C;AAC5C,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GACxC,kBAAkB,EAAE,CAuBtB;AAID;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAC7B,KAAK,EACL,QAAQ,EACR,KAAK,EACL,OAAO,EACP,UAAU,GACX,EAAE;IACD,KAAK,EAAE,kBAAkB,EAAE,CAAA;IAC3B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAC/B,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB;8BAC0B;IAC1B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAAC,CAAA;IAC/C;gFAC4E;IAC5E,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB,+BA6FA"}

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

@@ -0,0 +1,394 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { pointInPolygon, useInteractive, } from '@pascal-app/core';
+import { Html } from '@react-three/drei';
+import { createPortal, useFrame } from '@react-three/fiber';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { LoopRepeat, MathUtils, Vector3, } from 'three';
+import { useShallow } from 'zustand/react/shallow';
+import useViewer from '../../store/use-viewer';
+import { ControlWidget } from '../../systems/interactive/control-widget';
+/** 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. */
+export function buildGlbInteractiveItems(sceneGraph) {
+    const nodes = sceneGraph?.nodes;
+    if (!nodes)
+        return [];
+    const items = [];
+    for (const [id, raw] of Object.entries(nodes)) {
+        const node = raw;
+        if (node?.type !== 'item')
+            continue;
+        const interactive = node.asset?.interactive;
+        if (!interactive?.effects?.length)
+            continue;
+        const dims = node.asset?.dimensions ?? [1, 1, 1];
+        const scaleY = node.scale?.[1] ?? 1;
+        items.push({
+            pascalId: id,
+            label: node.asset?.name ?? id,
+            height: (dims[1] ?? 1) * scaleY,
+            interactive,
+        });
+    }
+    return items;
+}
+const _itemPos = new Vector3();
+/**
+ * Re-creates the item-driven interactivity the parametric viewer has — pooled
+ * lights, ambient animation, and the controls overlay — on top of a baked GLB.
+ * Effects come from the DB scene graph (`items`); world transforms come from the
+ * baked Object3Ds (`identity`), joined on `pascalId`. Nothing is stamped into
+ * 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.
+    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);
+            });
+        }
+        return () => {
+            const store = useInteractive.getState();
+            for (const item of items)
+                store.removeItem(item.pascalId);
+        };
+    }, [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 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.
+    const focusedZoneId = useViewer((s) => s.selection.zoneId);
+    const worldPolygon = useMemo(() => {
+        if (!focusedZoneId)
+            return null;
+        const zone = zones.find((z) => z.id === focusedZoneId);
+        if (!zone)
+            return null;
+        zone.node.updateWorldMatrix(true, false);
+        return zone.polygon.map(([x, z]) => {
+            const v = new Vector3(x, 0, z).applyMatrix4(zone.node.matrixWorld);
+            return [v.x, v.z];
+        });
+    }, [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) => {
+                const object = identity.get(item.pascalId);
+                return object ? (_jsx(GlbItemControls, { item: item, object: object, worldPolygon: worldPolygon }, item.pascalId)) : null;
+            })] }));
+}
+// ── Pooled item lights ──────────────────────────────────────────────────────
+//
+// Mirrors the parametric `ItemLightSystem`: a fixed pool of point lights is
+// assigned to the nearest/most-visible lit items each tick (camera-proximity
+// scored, with hysteresis), snapped to the item's world position + offset, and
+// faded in/out on reassignment. Mounting a light per item instead would blow
+// the renderer's light budget on a large house.
+const POOL_SIZE = 12;
+const REASSIGN_INTERVAL = 0.2;
+const HYSTERESIS = 0.15;
+const CAM_MOVE_DIST = 0.5;
+const CAM_ROT_DOT = 0.995;
+const _camPos = new Vector3();
+const _camFwd = new Vector3();
+const _dir = new Vector3();
+const _lightWorld = new Vector3();
+/** The nearest level-identity ancestor's pascalId, for the level factor. */
+function findLevelId(object) {
+    let cur = object;
+    while (cur) {
+        const ud = cur.userData;
+        if (ud.kind === 'level' && ud.pascalId)
+            return ud.pascalId;
+        cur = cur.parent;
+    }
+    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;
+    }
+    reg.object.getWorldPosition(_lightWorld);
+    _lightWorld.x += reg.effect.offset[0];
+    _lightWorld.y += reg.effect.offset[1];
+    _lightWorld.z += reg.effect.offset[2];
+    _dir.copy(_lightWorld).sub(_camPos).normalize();
+    const angular = 1 - _camFwd.dot(_dir);
+    const dist = _camPos.distanceTo(_lightWorld) / 200;
+    let levelPenalty = 0;
+    if (selectedLevelId) {
+        if (reg.levelId !== selectedLevelId)
+            levelPenalty = levelMode === 'solo' ? 100 : 0.8;
+    }
+    else if (reg.levelId && (levelIndexById.get(reg.levelId) ?? 0) !== 0) {
+        levelPenalty = 0.3;
+    }
+    return angular * 0.7 + dist * 0.3 + levelPenalty;
+}
+function GlbItemLights({ regs, levelIndexById, }) {
+    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);
+    const prevCamPos = useRef(new Vector3());
+    const prevCamFwd = useRef(new Vector3(0, 0, -1));
+    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 ||
+            _camFwd.dot(prevCamFwd.current) < CAM_ROT_DOT;
+        reassignTimer.current -= delta;
+        if (reassignTimer.current <= 0 || camMoved) {
+            reassignTimer.current = REASSIGN_INTERVAL;
+            prevCamPos.current.copy(_camPos);
+            prevCamFwd.current.copy(_camFwd);
+            const viewer = useViewer.getState();
+            const selectedLevelId = viewer.selection.levelId;
+            const levelMode = viewer.levelMode;
+            const scored = regs.map((reg) => ({
+                key: reg.key,
+                score: scoreReg(reg, selectedLevelId, levelMode, levelIndexById, interactiveState),
+            }));
+            scored.sort((a, b) => a.score - b.score);
+            const scoreByKey = new Map(scored.map((s) => [s.key, s.score]));
+            const desired = scored
+                .filter((s) => Number.isFinite(s.score))
+                .slice(0, POOL_SIZE)
+                .map((s) => s.key);
+            const currentlyAssigned = new Map();
+            for (let i = 0; i < POOL_SIZE; i++) {
+                const s = slots.current[i];
+                const k = s?.key ?? s?.pendingKey;
+                if (k)
+                    currentlyAssigned.set(k, i);
+            }
+            const usedSlots = new Set();
+            const assignedKeys = new Set();
+            // Pass 1: keep existing slots whose key is still wanted.
+            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 the rest to free slots, evicting only on a clear win.
+            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;
+                const freeSlotData = slots.current[freeSlot];
+                const currentKey = freeSlotData ? (freeSlotData.key ?? freeSlotData.pendingKey) : null;
+                if (currentKey && !desired.includes(currentKey)) {
+                    const currentScore = scoreByKey.get(currentKey) ?? Number.POSITIVE_INFINITY;
+                    const newScore = scoreByKey.get(key) ?? 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.key = key;
+                        slot.pendingKey = null;
+                        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;
+                        }
+                    }
+                }
+                freeSlot++;
+            }
+            // Retire slots whose key is no longer wanted.
+            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;
+                    }
+                }
+            }
+        }
+        // Per-frame: fade, snap position, and track intensity from control state.
+        // The pool lights stay permanently `visible` — only `intensity` is animated
+        // (an idle light just lerps to 0). Toggling `visible` would change the
+        // active-light count, which forces the WebGPU renderer to recompile every
+        // material's lighting node — a hard frame-time spike on every reassignment
+        // (i.e. on every camera move). Keeping the count fixed avoids that entirely.
+        for (let i = 0; i < POOL_SIZE; i++) {
+            const light = lightRefs.current[i];
+            const slot = slots.current[i];
+            if (!(light && slot))
+                continue;
+            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 = regByKey.get(slot.key);
+                        if (reg) {
+                            light.color.set(reg.effect.color);
+                            light.distance = reg.effect.distance ?? 0;
+                        }
+                    }
+                }
+                continue;
+            }
+            if (!slot.key) {
+                light.intensity = MathUtils.lerp(light.intensity, 0, dt * 12);
+                continue;
+            }
+            const reg = regByKey.get(slot.key);
+            if (!reg) {
+                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];
+            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))) }));
+}
+/** Plays an item's baked ambient loop (a fan's spin), gated on its toggle.
+ *  The clip and its targets are already in the GLB; we only start/stop it. */
+function GlbItemAnimation({ item, actions, }) {
+    const values = useInteractive(useShallow((s) => s.items[item.pascalId]?.controlValues));
+    const toggleIndex = item.interactive.controls.findIndex((c) => c.kind === 'toggle');
+    const isOn = toggleIndex >= 0 ? Boolean(values?.[toggleIndex] ?? true) : true;
+    useEffect(() => {
+        const action = actions[`${item.pascalId}: loop`];
+        if (!action)
+            return;
+        action.loop = LoopRepeat;
+        action.clampWhenFinished = false;
+        if (isOn) {
+            action.enabled = true;
+            action.paused = false;
+            if (!action.isRunning())
+                action.play();
+        }
+        else {
+            action.stop();
+        }
+    }, [actions, item.pascalId, isOn]);
+    return null;
+}
+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, }) {
+    const controlValues = useInteractive(useShallow((s) => s.items[item.pascalId]?.controlValues));
+    const setControlValue = useInteractive((s) => s.setControlValue);
+    let visible = false;
+    if (worldPolygon?.length) {
+        object.getWorldPosition(_itemPos);
+        visible = pointInPolygon(_itemPos.x, _itemPos.z, worldPolygon);
+    }
+    // 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);
+            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 && controlValues))
+        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',
+                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: item.interactive.controls.map((control, i) => (_jsx(ControlWidget, { control: control, onChange: (v) => setControlValue(item.pascalId, i, v), value: controlValues[i] ?? false }, i))) }) }), object);
+}

package/dist/components/viewer/glb-reference-nodes.d.ts

@@ -0,0 +1,29 @@
+import { type AnyNode, type SceneGraph } from '@pascal-app/core';
+import type { Object3D } from 'three';
+/**
+ * Kinds with `def.bake === 'strip'` (scans/LiDAR, guides/floorplan images) are
+ * excluded from the baked GLB — heavy reference assets stored elsewhere. The GLB
+ * viewer re-adds them at runtime from the scene graph, portaled into their parent
+ * level's baked node so they ride level stacking, using the same registry
+ * renderers as the parametric viewer. Selection is registry-driven; scan/guide
+ * privacy is enforced upstream (`show_*_public`), so a disallowed asset is never
+ * even fetched — we still honour the flags here as a second gate.
+ */
+export declare function buildGlbReferenceNodes(sceneGraph: SceneGraph | null | undefined, allow: {
+    scans: boolean;
+    guides: boolean;
+}): AnyNode[];
+/**
+ * Kinds with `def.bake === 'replace'` — baked as static geometry (so plain glTF
+ * viewers still show them) but re-rendered live here, since their runtime look
+ * differs from a frozen snapshot (shader wind, interactivity). `GlbScene` hides
+ * the baked meshes for these kinds; this feeds them back through the same
+ * portal-into-level path as reference nodes. Registry-driven; no privacy gate
+ * (dynamic scene content, not user uploads).
+ */
+export declare function buildGlbReplaceNodes(sceneGraph: SceneGraph | null | undefined): AnyNode[];
+export declare const GlbReferenceNodes: import("react").MemoExoticComponent<({ nodes, identity, }: {
+    nodes: AnyNode[];
+    identity: Map<string, Object3D>;
+}) => import("react").JSX.Element>;
+//# sourceMappingURL=glb-reference-nodes.d.ts.map

package/dist/components/viewer/glb-reference-nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glb-reference-nodes.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-reference-nodes.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EAKZ,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAGrC;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,EACzC,KAAK,EAAE;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GACzC,OAAO,EAAE,CAaX;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,EAAE,CAUzF;AAQD,eAAO,MAAM,iBAAiB,6DAG3B;IACD,KAAK,EAAE,OAAO,EAAE,CAAA;IAChB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CAChC,iCASC,CAAA"}

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

@@ -0,0 +1,80 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { bakePolicyOf, isNodeKindEnabled, nodeRegistry, } from '@pascal-app/core';
+import { createPortal } from '@react-three/fiber';
+import { memo, Suspense } from 'react';
+import { getRegistryRenderer } from '../renderers/node-renderer';
+/**
+ * Kinds with `def.bake === 'strip'` (scans/LiDAR, guides/floorplan images) are
+ * excluded from the baked GLB — heavy reference assets stored elsewhere. The GLB
+ * viewer re-adds them at runtime from the scene graph, portaled into their parent
+ * level's baked node so they ride level stacking, using the same registry
+ * renderers as the parametric viewer. Selection is registry-driven; scan/guide
+ * privacy is enforced upstream (`show_*_public`), so a disallowed asset is never
+ * even fetched — we still honour the flags here as a second gate.
+ */
+export function buildGlbReferenceNodes(sceneGraph, allow) {
+    const nodes = sceneGraph?.nodes;
+    if (!nodes)
+        return [];
+    const out = [];
+    for (const raw of Object.values(nodes)) {
+        const node = raw;
+        if (!isNodeKindEnabled(node.type, sceneGraph?.installedPlugins))
+            continue;
+        if (bakePolicyOf(node.type) !== 'strip')
+            continue;
+        if (node.type === 'scan' && !allow.scans)
+            continue;
+        if (node.type === 'guide' && !allow.guides)
+            continue;
+        out.push(node);
+    }
+    return out;
+}
+/**
+ * Kinds with `def.bake === 'replace'` — baked as static geometry (so plain glTF
+ * viewers still show them) but re-rendered live here, since their runtime look
+ * differs from a frozen snapshot (shader wind, interactivity). `GlbScene` hides
+ * the baked meshes for these kinds; this feeds them back through the same
+ * portal-into-level path as reference nodes. Registry-driven; no privacy gate
+ * (dynamic scene content, not user uploads).
+ */
+export function buildGlbReplaceNodes(sceneGraph) {
+    const nodes = sceneGraph?.nodes;
+    if (!nodes)
+        return [];
+    const out = [];
+    for (const raw of Object.values(nodes)) {
+        const node = raw;
+        if (!isNodeKindEnabled(node.type, sceneGraph?.installedPlugins))
+            continue;
+        if (bakePolicyOf(node.type) === 'replace')
+            out.push(node);
+    }
+    return out;
+}
+// Memoized: `GlbScene` re-renders every frame during camera movement (hover
+// raycast, walkthrough HUD). Without memo, all rebuilt nodes reconcile each
+// frame — negligible for one or two scans/guides, but a `replace` kind can put
+// dozens of nodes here (e.g. a forest), so each frame reconciles dozens of
+// portals + submeshes. `nodes` and `identity` are stable references (page-level
+// `useState` / `useMemo([gltf.scene])`), so memo short-circuits cleanly.
+export const GlbReferenceNodes = memo(function GlbReferenceNodes({ nodes, identity, }) {
+    return (_jsx(_Fragment, { children: nodes.map((node) => {
+            const anchor = node.parentId ? identity.get(node.parentId) : undefined;
+            return anchor ? _jsx(GlbReferenceNode, { anchor: anchor, node: node }, node.id) : null;
+        }) }));
+});
+/** Render one `strip` node (scan/guide) via its registry `renderer`, portaled
+ *  into its parent level's baked Object3D (so the node's level-local transform
+ *  resolves to the same world pose as the parametric scene). Memoized so an
+ *  unchanged `(node, anchor)` skips the subtree when the parent re-renders on
+ *  camera move. (`replace` kinds use the collective `GlbReplaceInstances` path.) */
+const GlbReferenceNode = memo(function GlbReferenceNode({ node, anchor, }) {
+    const source = nodeRegistry.get(node.type)?.renderer;
+    const Renderer = source ? getRegistryRenderer(source) : null;
+    if (!Renderer)
+        return null;
+    return createPortal(_jsx(Suspense, { fallback: null, children: _jsx(Renderer, { node: node }) }), anchor);
+});

package/dist/components/viewer/glb-replace-instances.d.ts

@@ -0,0 +1,18 @@
+import { type AnyNode } from '@pascal-app/core';
+import type { Object3D } from 'three';
+/**
+ * Re-renders `bake: 'replace'` kinds (e.g. plugin trees) live over the baked GLB.
+ * The baked static meshes are hidden by `GlbScene`; these nodes are grouped by
+ * `(parent level, kind)` and each group is handed to the kind's collective
+ * `bakeReplaceRenderer` (an instanced renderer), portaled into that level's baked
+ * `Object3D`. Local-space instances therefore ride level stacking/explode for
+ * free, and a forest stays a few instanced draw calls.
+ *
+ * Memoized: `GlbScene` re-renders each frame on camera move; `nodes` and
+ * `identity` are stable refs, so this whole subtree short-circuits.
+ */
+export declare const GlbReplaceInstances: import("react").MemoExoticComponent<({ nodes, identity, }: {
+    nodes: AnyNode[];
+    identity: Map<string, Object3D>;
+}) => import("react").JSX.Element>;
+//# sourceMappingURL=glb-replace-instances.d.ts.map

package/dist/components/viewer/glb-replace-instances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glb-replace-instances.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-replace-instances.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,OAAO,EAA0C,MAAM,kBAAkB,CAAA;AAGvF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAerC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,6DAG7B;IACD,KAAK,EAAE,OAAO,EAAE,CAAA;IAChB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CAChC,iCAyCC,CAAA"}

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

@@ -0,0 +1,61 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { nodeRegistry } from '@pascal-app/core';
+import { createPortal } from '@react-three/fiber';
+import { Fragment, lazy, memo, Suspense, useMemo } from 'react';
+// Lazy components cached by their source so React.lazy isn't re-invoked per render.
+const lazyCache = new WeakMap();
+function getReplaceRenderer(source) {
+    const cached = lazyCache.get(source);
+    if (cached)
+        return cached;
+    const Comp = lazy(source.module);
+    lazyCache.set(source, Comp);
+    return Comp;
+}
+/**
+ * Re-renders `bake: 'replace'` kinds (e.g. plugin trees) live over the baked GLB.
+ * The baked static meshes are hidden by `GlbScene`; these nodes are grouped by
+ * `(parent level, kind)` and each group is handed to the kind's collective
+ * `bakeReplaceRenderer` (an instanced renderer), portaled into that level's baked
+ * `Object3D`. Local-space instances therefore ride level stacking/explode for
+ * free, and a forest stays a few instanced draw calls.
+ *
+ * Memoized: `GlbScene` re-renders each frame on camera move; `nodes` and
+ * `identity` are stable refs, so this whole subtree short-circuits.
+ */
+export const GlbReplaceInstances = memo(function GlbReplaceInstances({ nodes, identity, }) {
+    const byLevel = useMemo(() => {
+        const levels = new Map();
+        for (const node of nodes) {
+            const parentId = node.parentId;
+            if (!parentId)
+                continue;
+            let byKind = levels.get(parentId);
+            if (!byKind) {
+                byKind = new Map();
+                levels.set(parentId, byKind);
+            }
+            const list = byKind.get(node.type);
+            if (list)
+                list.push(node);
+            else
+                byKind.set(node.type, [node]);
+        }
+        return levels;
+    }, [nodes]);
+    const portals = [];
+    byLevel.forEach((byKind, parentId) => {
+        const anchor = identity.get(parentId);
+        if (!anchor)
+            return;
+        byKind.forEach((kindNodes, kind) => {
+            const source = nodeRegistry.get(kind)?.bakeReplaceRenderer;
+            if (!source)
+                return;
+            const Renderer = getReplaceRenderer(source);
+            portals.push(_jsx(Fragment, { children: createPortal(_jsx(Suspense, { fallback: null, children: _jsx(Renderer, { nodes: kindNodes }) }), anchor) }, `${parentId}:${kind}`));
+        });
+    });
+    return _jsx(_Fragment, { children: portals });
+});

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

@@ -0,0 +1,54 @@
+import { type AnyNode } from '@pascal-app/core';
+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;
+};
+/** 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). */
+export type GlbWalkthrough = {
+    zoneLabel: string | null;
+    floorLabel: string | null;
+    door: {
+        label: string;
+        isOpen: boolean;
+    } | null;
+} | 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"`).
+ */
+export declare function GlbScene({ url, interactiveItems, referenceNodes, replaceNodes, onLevelsChange, onIdentityChange, onHoverChange, 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. */
+    interactiveItems?: GlbInteractiveItem[];
+    /** Scan / guide nodes from the scene graph, re-added at runtime (they're
+     *  stripped from the bake). Already filtered by the privacy flags upstream. */
+    referenceNodes?: AnyNode[];
+    /** `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;
+    onWalkthroughChange?: (state: GlbWalkthrough) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=glb-scene.d.ts.map

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

@@ -0,0 +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,+BAgzBA"}