@pascal-app/viewer 1.1.0 → 1.1.1

package/dist/components/viewer/first-person/ground-holes.js

@@ -0,0 +1,116 @@
+/**
+ * Holes in the site ground's collision geometry.
+ *
+ * The walkthrough stands on one merged BVH mesh, and the site's ground (a flat slab, or the terrain)
+ * is a sheet across the whole lot. Where the house stands over a basement the ground is drawn open
+ * (`coveredBelowGradeFootprints`), but the sheet under the stairwell stayed: the player descending
+ * the stair met it at grade and could go no deeper. Cutting the collider by the same rings the
+ * ground is drawn open over lets the player follow the building's floors and stairs there.
+ *
+ * Every triangle that reaches a hole is cut against it in plan; the pieces keep the source
+ * triangle's plane (height and normal interpolated from its corners) and its facing, so the cut
+ * surface is exactly the one the uncut triangle was.
+ */
+import { difference, union } from '@pascal-app/core';
+import { BufferAttribute, BufferGeometry, ShapeUtils, Vector2 } from 'three';
+/** Triangles flatter than this in plan (m²) are vertical faces: they hold nothing up. */
+const MIN_PLAN_AREA = 1e-9;
+/** Twice the signed plan area of `a b c` (x right, z down). */
+function orient(a, b, c) {
+    return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+}
+/**
+ * `geometry` (non-indexed, `position` and `normal`, in the frame the rings are in) without the part
+ * of it that lies over `holes`. A triangle the clip fails on is kept whole: the ground closed is
+ * the safe side. The geometry is returned as it is when there are no holes.
+ */
+export function cutGroundCollider(geometry, holes) {
+    if (holes.length === 0)
+        return geometry;
+    const cutouts = union(holes);
+    if (cutouts.length === 0)
+        return geometry;
+    const boxes = cutouts.map(({ outer }) => ({
+        minX: Math.min(...outer.map(([x]) => x)),
+        maxX: Math.max(...outer.map(([x]) => x)),
+        minZ: Math.min(...outer.map(([, z]) => z)),
+        maxZ: Math.max(...outer.map(([, z]) => z)),
+    }));
+    const position = geometry.getAttribute('position');
+    const normal = geometry.getAttribute('normal');
+    const positions = [];
+    const normals = [];
+    const push = (corner) => {
+        positions.push(corner.x, corner.y, corner.z);
+        normals.push(corner.nx, corner.ny, corner.nz);
+    };
+    for (let i = 0; i + 2 < position.count; i += 3) {
+        const corners = [0, 1, 2].map((k) => ({
+            x: position.getX(i + k),
+            y: position.getY(i + k),
+            z: position.getZ(i + k),
+            nx: normal.getX(i + k),
+            ny: normal.getY(i + k),
+            nz: normal.getZ(i + k),
+        }));
+        const [a, b, c] = corners;
+        const minX = Math.min(a.x, b.x, c.x);
+        const maxX = Math.max(a.x, b.x, c.x);
+        const minZ = Math.min(a.z, b.z, c.z);
+        const maxZ = Math.max(a.z, b.z, c.z);
+        const reached = boxes.some((box) => box.maxX > minX && box.minX < maxX && box.maxZ > minZ && box.minZ < maxZ);
+        const plan = [
+            [a.x, a.z],
+            [b.x, b.z],
+            [c.x, c.z],
+        ];
+        const determinant = orient(plan[0], plan[1], plan[2]);
+        if (!reached || Math.abs(determinant) < MIN_PLAN_AREA) {
+            corners.forEach(push);
+            continue;
+        }
+        let pieces;
+        try {
+            pieces = difference(plan, cutouts, { throwOnError: true });
+        }
+        catch {
+            corners.forEach(push);
+            continue;
+        }
+        const at = (x, z) => {
+            const wa = ((b.z - c.z) * (x - c.x) + (c.x - b.x) * (z - c.z)) / determinant;
+            const wb = ((c.z - a.z) * (x - c.x) + (a.x - c.x) * (z - c.z)) / determinant;
+            const wc = 1 - wa - wb;
+            const nx = a.nx * wa + b.nx * wb + c.nx * wc;
+            const ny = a.ny * wa + b.ny * wb + c.ny * wc;
+            const nz = a.nz * wa + b.nz * wb + c.nz * wc;
+            const length = Math.hypot(nx, ny, nz) || 1;
+            return {
+                x,
+                y: a.y * wa + b.y * wb + c.y * wc,
+                z,
+                nx: nx / length,
+                ny: ny / length,
+                nz: nz / length,
+            };
+        };
+        for (const piece of pieces) {
+            const rings = [piece.outer, ...piece.holes];
+            const points = rings.flat();
+            const contour = piece.outer.map(([x, z]) => new Vector2(x, z));
+            const voids = piece.holes.map((ring) => ring.map(([x, z]) => new Vector2(x, z)));
+            for (const [p, q, r] of ShapeUtils.triangulateShape(contour, voids)) {
+                const corner = [p, q, r].map((index) => points[index]);
+                const swap = Math.sign(orient(corner[0], corner[1], corner[2])) !== Math.sign(determinant);
+                const ordered = swap ? [corner[0], corner[2], corner[1]] : corner;
+                for (const [x, z] of ordered)
+                    push(at(x, z));
+            }
+        }
+    }
+    const cut = new BufferGeometry();
+    cut.setAttribute('position', new BufferAttribute(new Float32Array(positions), 3));
+    cut.setAttribute('normal', new BufferAttribute(new Float32Array(normals), 3));
+    geometry.dispose();
+    return cut;
+}

package/dist/components/viewer/first-person/mechanism-targets.d.ts

@@ -0,0 +1,27 @@
+import { type AnyNode, type AnyNodeId } from '@pascal-app/core';
+import type { WalkthroughInteract } from '../../../store/use-first-person-hud';
+/**
+ * Whether the walkthrough swings this door or window itself, through the native `operationState`
+ * its door and window systems draw. One built from a script has no native leaf or sash: a swing
+ * would draw nothing, so its clips run through its mechanism, as an authored object's do.
+ */
+export declare function hasNativeLeaf(node: AnyNode | undefined): boolean;
+/** Mounted doors and windows the walkthrough's own door and window targets cover. */
+export declare function nativeOpeningIds(): AnyNodeId[];
+/**
+ * Mounted nodes the walkthrough runs through `capabilities.mechanism`, any kind
+ * included. `covered` holds the nodes a finer target already tested (procedural
+ * parts, catalog item toggles), so no node is targeted twice.
+ */
+export declare function mechanismTargetIds(covered: ReadonlySet<string>): AnyNodeId[];
+/** The walkthrough prompt for a mechanism target: its name and what E does next. */
+export declare function mechanismHudInteract(node: AnyNode): WalkthroughInteract;
+/**
+ * Calls `onChange` when a mounted door built from a script opens or closes. The walkthrough's
+ * collider follows the door's mechanism, and its model's clip is moved by no tween system that
+ * would report the end, as a native door's does: without this the world keeps the leaf that was
+ * there when it was last built. It fires at the toggle: the doorway is passable as the leaves
+ * start to move, and solid again as they start to close.
+ */
+export declare function watchScriptedDoors(onChange: () => void): () => void;
+//# sourceMappingURL=mechanism-targets.d.ts.map

package/dist/components/viewer/first-person/mechanism-targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mechanism-targets.d.ts","sourceRoot":"","sources":["../../../../src/components/viewer/first-person/mechanism-targets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAOf,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAA;AAE9E;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,OAAO,CAEhE;AAED,qFAAqF;AACrF,wBAAgB,gBAAgB,IAAI,SAAS,EAAE,CAS9C;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,EAAE,CAU5E;AAED,oFAAoF;AACpF,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,mBAAmB,CAMvE;AAcD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CASnE"}

package/dist/components/viewer/first-person/mechanism-targets.js

@@ -0,0 +1,79 @@
+import { isScriptedNode, nodeMechanism, nodeRegistry, sceneRegistry, useInteractive, useScene, } from '@pascal-app/core';
+/**
+ * Whether the walkthrough swings this door or window itself, through the native `operationState`
+ * its door and window systems draw. One built from a script has no native leaf or sash: a swing
+ * would draw nothing, so its clips run through its mechanism, as an authored object's do.
+ */
+export function hasNativeLeaf(node) {
+    return !isScriptedNode(node);
+}
+/** Mounted doors and windows the walkthrough's own door and window targets cover. */
+export function nativeOpeningIds() {
+    const nodes = useScene.getState().nodes;
+    const ids = [];
+    for (const kind of ['door', 'window']) {
+        for (const id of sceneRegistry.byType[kind] ?? []) {
+            if (hasNativeLeaf(nodes[id]))
+                ids.push(id);
+        }
+    }
+    return ids;
+}
+/**
+ * Mounted nodes the walkthrough runs through `capabilities.mechanism`, any kind
+ * included. `covered` holds the nodes a finer target already tested (procedural
+ * parts, catalog item toggles), so no node is targeted twice.
+ */
+export function mechanismTargetIds(covered) {
+    const nodes = useScene.getState().nodes;
+    const ids = [];
+    for (const [kind, kindIds] of Object.entries(sceneRegistry.byType)) {
+        if (!nodeRegistry.get(kind)?.capabilities.mechanism)
+            continue;
+        for (const id of kindIds) {
+            if (!covered.has(id) && nodeMechanism(nodes[id]))
+                ids.push(id);
+        }
+    }
+    return ids;
+}
+/** The walkthrough prompt for a mechanism target: its name and what E does next. */
+export function mechanismHudInteract(node) {
+    const mechanism = nodeMechanism(node);
+    if (!mechanism)
+        return null;
+    const on = mechanism.isOn(node, useInteractive.getState());
+    const verb = mechanism.verb === 'open' ? (on ? 'close' : 'open') : on ? 'turn off' : 'turn on';
+    return { label: node.name ?? 'item', verb };
+}
+/** Ids of the mounted doors built from a script that are open, by their mechanism. */
+function openScriptedDoors() {
+    const nodes = useScene.getState().nodes;
+    const state = useInteractive.getState();
+    const open = [];
+    for (const id of sceneRegistry.byType.door ?? []) {
+        const node = nodes[id];
+        if (isScriptedNode(node) && nodeMechanism(node)?.isOn(node, state))
+            open.push(id);
+    }
+    return open.sort().join(',');
+}
+/**
+ * Calls `onChange` when a mounted door built from a script opens or closes. The walkthrough's
+ * collider follows the door's mechanism, and its model's clip is moved by no tween system that
+ * would report the end, as a native door's does: without this the world keeps the leaf that was
+ * there when it was last built. It fires at the toggle: the doorway is passable as the leaves
+ * start to move, and solid again as they start to close.
+ */
+export function watchScriptedDoors(onChange) {
+    let known = openScriptedDoors();
+    return useInteractive.subscribe((state, previous) => {
+        if (state.items === previous.items)
+            return;
+        const next = openScriptedDoors();
+        if (next === known)
+            return;
+        known = next;
+        onChange();
+    });
+}

package/dist/components/viewer/first-person/terrain-collider.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The sculpted ground as walkthrough collision geometry.
+ *
+ * The first-person collider world is a single merged BVH mesh, and before terrain
+ * the ground contributed one flat 2 km box to it. That box is wrong in both
+ * directions on a sculpted site: it holds the player up at the datum inside an
+ * excavation, and buries them inside a hill. This module replaces it.
+ *
+ * Two properties it has to hold, because the whole point is that walking agrees
+ * with every other consumer of the field:
+ *
+ * - **The surface is the field**, sampled at every vertex — the same
+ *   `heightAtSample`/`normalAt` the rendered mesh uses (`terrain-geometry.ts`),
+ *   so what you see is what you stand on. It is deliberately not a decimated
+ *   proxy at realistic field sizes.
+ * - **It extends past the field**, because `heightAt` clamps to the border
+ *   outside it. A collider that stopped at the field edge would drop the player
+ *   into the void one step past the site, which is exactly the bug the flat box
+ *   existed to prevent. The skirt extrudes each border sample outward at its own
+ *   height, so the collider and `heightAt` agree everywhere, not just inside.
+ *
+ * Non-indexed triangles with position + normal, matching what the other collider
+ * contributors emit — `mergeGeometries` requires every input to agree on both.
+ */
+import { type TerrainField } from '@pascal-app/core';
+import * as THREE from 'three';
+/**
+ * Terrain collision geometry in the site's own frame — the caller applies the
+ * site's world matrix, exactly as it did for the flat box it replaces.
+ */
+export declare function createTerrainColliderGeometry(field: TerrainField): THREE.BufferGeometry | null;
+//# sourceMappingURL=terrain-collider.d.ts.map

package/dist/components/viewer/first-person/terrain-collider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain-collider.d.ts","sourceRoot":"","sources":["../../../../src/components/viewer/first-person/terrain-collider.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAA4B,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC9E,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AA2E9B;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,YAAY,GAAG,KAAK,CAAC,cAAc,GAAG,IAAI,CA0G9F"}

package/dist/components/viewer/first-person/terrain-collider.js

@@ -0,0 +1,175 @@
+/**
+ * The sculpted ground as walkthrough collision geometry.
+ *
+ * The first-person collider world is a single merged BVH mesh, and before terrain
+ * the ground contributed one flat 2 km box to it. That box is wrong in both
+ * directions on a sculpted site: it holds the player up at the datum inside an
+ * excavation, and buries them inside a hill. This module replaces it.
+ *
+ * Two properties it has to hold, because the whole point is that walking agrees
+ * with every other consumer of the field:
+ *
+ * - **The surface is the field**, sampled at every vertex — the same
+ *   `heightAtSample`/`normalAt` the rendered mesh uses (`terrain-geometry.ts`),
+ *   so what you see is what you stand on. It is deliberately not a decimated
+ *   proxy at realistic field sizes.
+ * - **It extends past the field**, because `heightAt` clamps to the border
+ *   outside it. A collider that stopped at the field edge would drop the player
+ *   into the void one step past the site, which is exactly the bug the flat box
+ *   existed to prevent. The skirt extrudes each border sample outward at its own
+ *   height, so the collider and `heightAt` agree everywhere, not just inside.
+ *
+ * Non-indexed triangles with position + normal, matching what the other collider
+ * contributors emit — `mergeGeometries` requires every input to agree on both.
+ */
+import { heightAtSample, normalAt } from '@pascal-app/core';
+import * as THREE from 'three';
+/**
+ * How far past the field the ground keeps holding the player, in metres. Matches
+ * the flat box's half-extent so a site's collider bounds do not change size when
+ * it gains terrain.
+ */
+const SKIRT_REACH = 1000;
+/**
+ * Cell budget before the collider decimates.
+ *
+ * 66k cells is a 257² field — the largest anything realistic produces, and ~131k
+ * triangles, which the BVH builds in well under a frame's worth of budget. The
+ * schema allows up to 4097² (a decode-bomb guard, not a real terrain); at that
+ * size an exact collider would be 100M triangles, so past the budget this steps
+ * the sample grid and the collider becomes a faithful-but-coarser version of the
+ * same surface rather than an out-of-memory crash.
+ */
+const MAX_COLLIDER_CELLS = 66_000;
+function colliderStride(field) {
+    const cells = Math.max(1, (field.cols - 1) * (field.rows - 1));
+    if (cells <= MAX_COLLIDER_CELLS)
+        return 1;
+    return Math.ceil(Math.sqrt(cells / MAX_COLLIDER_CELLS));
+}
+/** The sample indices the collider walks: every `stride`-th, always including the border. */
+function sampleLine(count, stride) {
+    const line = [];
+    for (let i = 0; i < count - 1; i += stride)
+        line.push(i);
+    line.push(count - 1);
+    return line;
+}
+class TriangleSink {
+    field;
+    positions = [];
+    normals = [];
+    constructor(field) {
+        this.field = field;
+    }
+    push(v) {
+        this.positions.push(v.x, v.y, v.z);
+        const [nx, ny, nz] = normalAt(this.field, v.x, v.z);
+        this.normals.push(nx, ny, nz);
+    }
+    /**
+     * One cell, given its four corners named by axis order. Winding matches
+     * `buildTerrainMesh`: `(p00, p01, p10)` and `(p10, p01, p11)` faces +Y, which is
+     * what the spawn resolver's `normal.dot(UP) > 0.2` floor test needs.
+     */
+    quad(p00, p10, p01, p11) {
+        this.push(p00);
+        this.push(p01);
+        this.push(p10);
+        this.push(p10);
+        this.push(p01);
+        this.push(p11);
+    }
+    build() {
+        if (this.positions.length === 0)
+            return null;
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(this.positions), 3));
+        geometry.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(this.normals), 3));
+        return geometry;
+    }
+}
+/**
+ * Terrain collision geometry in the site's own frame — the caller applies the
+ * site's world matrix, exactly as it did for the flat box it replaces.
+ */
+export function createTerrainColliderGeometry(field) {
+    if (field.cols < 2 || field.rows < 2)
+        return null;
+    const stride = colliderStride(field);
+    const cols = sampleLine(field.cols, stride);
+    const rows = sampleLine(field.rows, stride);
+    const sink = new TriangleSink(field);
+    const xAt = (col) => field.origin[0] + col * field.spacing;
+    const zAt = (row) => field.origin[1] + row * field.spacing;
+    const at = (col, row) => ({
+        x: xAt(col),
+        y: heightAtSample(field, col, row),
+        z: zAt(row),
+    });
+    for (let ri = 0; ri < rows.length - 1; ri++) {
+        const r0 = rows[ri];
+        const r1 = rows[ri + 1];
+        for (let ci = 0; ci < cols.length - 1; ci++) {
+            const c0 = cols[ci];
+            const c1 = cols[ci + 1];
+            sink.quad(at(c0, r0), at(c1, r0), at(c0, r1), at(c1, r1));
+        }
+    }
+    // The skirt: each border sample extruded outward at its own height, so stepping
+    // off the field lands on the border height rather than on nothing. This is the
+    // collider spelling of `heightAt`'s edge clamp.
+    const firstCol = 0;
+    const lastCol = field.cols - 1;
+    const firstRow = 0;
+    const lastRow = field.rows - 1;
+    const westX = xAt(firstCol) - SKIRT_REACH;
+    const eastX = xAt(lastCol) + SKIRT_REACH;
+    const northZ = zAt(firstRow) - SKIRT_REACH;
+    const southZ = zAt(lastRow) + SKIRT_REACH;
+    for (let ci = 0; ci < cols.length - 1; ci++) {
+        const c0 = cols[ci];
+        const c1 = cols[ci + 1];
+        const north0 = at(c0, firstRow);
+        const north1 = at(c1, firstRow);
+        sink.quad({ x: north0.x, y: north0.y, z: northZ }, { x: north1.x, y: north1.y, z: northZ }, north0, north1);
+        const south0 = at(c0, lastRow);
+        const south1 = at(c1, lastRow);
+        sink.quad(south0, south1, { x: south0.x, y: south0.y, z: southZ }, {
+            x: south1.x,
+            y: south1.y,
+            z: southZ,
+        });
+    }
+    for (let ri = 0; ri < rows.length - 1; ri++) {
+        const r0 = rows[ri];
+        const r1 = rows[ri + 1];
+        const west0 = at(firstCol, r0);
+        const west1 = at(firstCol, r1);
+        sink.quad({ x: westX, y: west0.y, z: west0.z }, west0, { x: westX, y: west1.y, z: west1.z }, west1);
+        const east0 = at(lastCol, r0);
+        const east1 = at(lastCol, r1);
+        sink.quad(east0, { x: eastX, y: east0.y, z: east0.z }, east1, {
+            x: eastX,
+            y: east1.y,
+            z: east1.z,
+        });
+    }
+    // Corner quads, flat at the corner sample's height — the diagonal region no edge
+    // strip covers, and where `heightAt` also reports the corner value.
+    const corners = [
+        [at(firstCol, firstRow), westX, northZ],
+        [at(lastCol, firstRow), eastX, northZ],
+        [at(firstCol, lastRow), westX, southZ],
+        [at(lastCol, lastRow), eastX, southZ],
+    ];
+    for (const [corner, farX, farZ] of corners) {
+        const minX = Math.min(corner.x, farX);
+        const maxX = Math.max(corner.x, farX);
+        const minZ = Math.min(corner.z, farZ);
+        const maxZ = Math.max(corner.z, farZ);
+        const y = corner.y;
+        sink.quad({ x: minX, y, z: minZ }, { x: maxX, y, z: minZ }, { x: minX, y, z: maxZ }, { x: maxX, y, z: maxZ });
+    }
+    return sink.build();
+}

package/dist/components/viewer/glb-walkthrough-controller.d.ts

@@ -9,7 +9,7 @@ export declare const CROUCH_RUN_SPEED = 1.4;
 export declare const STAND_CLEARANCE = 1.25;
 export declare const EYE_LERP_SPEED = 12;
 /**
- * First-person walkthrough controller for the baked GLB. Reuses the editor's
+ * First-person walkthrough controller for the baked GLB. Uses the shared
  * `BVHEcctrl` capsule character controller (gravity, jump, sprint, ground-float,
  * mesh collision) fed a collider built from the artifact's own geometry — so the
  * baked viewer walks the building with the same physics as the editor, without

package/dist/components/viewer/glb-walkthrough-controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glb-walkthrough-controller.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-walkthrough-controller.tsx"],"names":[],"mappings":"AAkCA,eAAO,MAAM,eAAe,KAAK,CAAA;AAkBjC,eAAO,MAAM,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AAChF,eAAO,MAAM,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AACjF,eAAO,MAAM,kBAAkB,MAAM,CAAA;AACrC,eAAO,MAAM,mBAAmB,OAAO,CAAA;AACvC,eAAO,MAAM,iBAAiB,MAAM,CAAA;AACpC,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAClC,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAInC,eAAO,MAAM,eAAe,OAAO,CAAA;AACnC,eAAO,MAAM,cAAc,KAAK,CAAA;AAmMhC;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,GAAG,EAAE,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,sCA0PhE"}
+{"version":3,"file":"glb-walkthrough-controller.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/glb-walkthrough-controller.tsx"],"names":[],"mappings":"AAkCA,eAAO,MAAM,eAAe,KAAK,CAAA;AAiBjC,eAAO,MAAM,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AAChF,eAAO,MAAM,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,CAAA;AACjF,eAAO,MAAM,kBAAkB,MAAM,CAAA;AACrC,eAAO,MAAM,mBAAmB,OAAO,CAAA;AACvC,eAAO,MAAM,iBAAiB,MAAM,CAAA;AACpC,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAClC,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAInC,eAAO,MAAM,eAAe,OAAO,CAAA;AACnC,eAAO,MAAM,cAAc,KAAK,CAAA;AAmMhC;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,EAAE,GAAG,EAAE,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,sCA0PhE"}

package/dist/components/viewer/glb-walkthrough-controller.js

@@ -16,8 +16,7 @@ import { applyWalkthroughCameraClipping } from './viewer-camera';
 // awareness without wide-angle distortion. Applied only while walking — both
 // walkthrough controllers read this and restore the orbit FOV on exit.
 export const WALKTHROUGH_FOV = 60;
-// Eye/capsule geometry mirrors the editor's first-person controller so the
-// baked walkthrough feels identical. The capsule centre sits below the eye; the
+// Shared with the live walkthrough so baked and parametric scenes feel identical. The capsule centre sits below the eye; the
 // camera rides the capsule with a small offset and the controller floats it to
 // the ground.
 const CAMERA_EYE_OFFSET = 0.45;
@@ -109,7 +108,7 @@ function boxFloorGeometry(cx, topY, cz, width, depth) {
 // Fallback ground so the player never falls into the void: a single large
 // ground plane at the lowest level (level 0). Upper levels rely on their own
 // baked slabs — a slab-less upper floor lets you fall down to the ground, which
-// the ground plane catches. (Mirrors the editor walkthrough's site ground.)
+// the ground plane catches. (Mirrors the live walkthrough's site ground.)
 function addFallbackFloors(scene, geometries) {
     const sceneBounds = new Box3();
     for (const geometry of geometries) {
@@ -224,7 +223,7 @@ function resolveGlbSpawn(scene) {
     };
 }
 /**
- * First-person walkthrough controller for the baked GLB. Reuses the editor's
+ * First-person walkthrough controller for the baked GLB. Uses the shared
  * `BVHEcctrl` capsule character controller (gravity, jump, sprint, ground-float,
  * mesh collision) fed a collider built from the artifact's own geometry — so the
  * baked viewer walks the building with the same physics as the editor, without

package/dist/components/viewer/live-walkthrough-controller.d.ts

@@ -0,0 +1,17 @@
+export type LiveWalkthroughControllerProps = {
+    /** Freeze movement and look while a host renders a still. */
+    paused?: boolean;
+    /**
+     * Whether the host owns camera FOV right now (e.g. a capture rig). Read when walkthrough
+     * starts and when it ends, so the answer at teardown decides whether the orbit FOV returns.
+     */
+    externalFov?: () => boolean;
+    /** Allow locked-pointer clicks to operate the targeted object (E/R still work). */
+    pointerInteraction?: boolean;
+    /** Keep walkthrough active when pointer lock is lost; Escape with a free cursor exits. */
+    suspendOnUnlock?: boolean;
+    /** Called after walkthroughMode is cleared, including on Escape or pointer unlock. */
+    onExit?: () => void;
+};
+export declare function LiveWalkthroughController(props: LiveWalkthroughControllerProps): import("react").JSX.Element | null;
+//# sourceMappingURL=live-walkthrough-controller.d.ts.map

package/dist/components/viewer/live-walkthrough-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-walkthrough-controller.d.ts","sourceRoot":"","sources":["../../../src/components/viewer/live-walkthrough-controller.tsx"],"names":[],"mappings":"AA8uBA,MAAM,MAAM,8BAA8B,GAAG;IAC3C,6DAA6D;IAC7D,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,OAAO,CAAA;IAC3B,mFAAmF;IACnF,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,0FAA0F;IAC1F,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,sFAAsF;IACtF,MAAM,CAAC,EAAE,MAAM,IAAI,CAAA;CACpB,CAAA;AAKD,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,8BAA8B,sCAG9E"}