@pascal-app/viewer 1.0.0-beta.5 → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pascal Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -120,6 +120,61 @@ floor-plan pan/zoom/rotation, and the compass synchronize through transient subs
 navigation does not require a React render per frame. Set `showCompass={false}` or
 `showSwitcher={false}` when the host supplies its own controls.
 
+## Capture Sessions
+
+`@pascal-app/viewer/capture` holds the optional capture runtime and its reference layers. Mount
+`CaptureRuntime` as a child of `Viewer` and provide a source resolver. The host owns access control
+and transport; the runtime owns source lifecycle, scan-node placement, layer visibility, and
+reference renderers for RoomPlan models, device trajectories, and PLY/live point clouds. The
+session contracts it consumes live in `@pascal-app/core/capture`.
+
+```tsx
+import { createHttpCaptureSource } from '@pascal-app/core/capture'
+import { Viewer } from '@pascal-app/viewer'
+import { CaptureRuntime } from '@pascal-app/viewer/capture'
+
+function CaptureViewer() {
+  return (
+    <Viewer>
+      <CaptureRuntime
+        onError={(error, context) => reportCaptureError(error, context)}
+        resolveSource={(locator) => createHttpCaptureSource(locator, { credentials: 'include' })}
+        retryKey={retryVersion}
+      />
+    </Viewer>
+  )
+}
+```
+
+Unknown streams remain in the descriptor and can be rendered by passing a custom renderer keyed by
+stream role or kind. A live transport implements `CaptureSource.subscribe()`; no particular
+WebSocket, WebRTC, or collaboration backend is required.
+
+`CaptureRuntime` keeps telemetry host-neutral: pass `onError` to report source or per-stream
+failures in the host, then increment `retryKey` to reload every affected session. Direct
+`useCaptureSource()` consumers can call its `retry()` function instead.
+
+Hosts can pass `defaultLayerVisibility` to keep expensive optional layers disabled until a user
+enables them. Persisted values in the scan node's `layers` map always override those host defaults;
+without host defaults, every available layer remains visible for backwards compatibility. Hidden
+sessions and layers are unmounted rather than only made visually transparent, so they stop
+raycasting, artifact work, animation, and live packet subscriptions while disabled.
+
+### Local surface previews
+
+`@pascal-app/viewer/capture/preview` exports `createSurfaceMeshGeometry` and `createClayMatcap`
+without importing the React viewer runtime, so a capture client can render a locally saved surface
+immediately, before its archive is uploaded. The geometry decoder uses the shared
+`@pascal-app/core/capture` validator, including the native 20,000-face budget, byte lengths, and
+index bounds. It returns `null` for invalid input. The host owns the returned geometry and matcap
+texture and must dispose them on teardown.
+
+Direct `CaptureStreamLayer` consumers can pass
+`meshPresentation={{ previewMaterial: 'clay', dollhouse: true }}`. Clay replaces preliminary vertex
+colors; dollhouse enables front-face rendering for surface previews and room models, revealing
+inward-facing room surfaces from outside. It changes per-instance materials, not geometry or
+loader-cached materials. Omitting these options preserves the existing presentation.
+
 ## Viewer State
 
 ```typescript

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

@@ -0,0 +1,2 @@
+export declare function rewriteLoopbackAssetUrl(value: string): string;
+//# sourceMappingURL=asset-url.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"asset-url.d.ts","sourceRoot":"","sources":["../../src/capture/asset-url.ts"],"names":[],"mappings":"AAAA,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAa7D"}

package/dist/capture/asset-url.js

@@ -0,0 +1,13 @@
+export function rewriteLoopbackAssetUrl(value) {
+    try {
+        const url = new URL(value);
+        if (typeof window !== 'undefined' &&
+            (url.hostname === '127.0.0.1' || url.hostname === 'localhost')) {
+            url.hostname = window.location.hostname;
+        }
+        return url.toString();
+    }
+    catch {
+        return value;
+    }
+}

package/dist/capture/capture-runtime.d.ts

@@ -0,0 +1,43 @@
+import { type ScanNode } from '@pascal-app/core';
+import { type CaptureSessionDescriptor, type CaptureSource, type CaptureSourceResolver, type CaptureStreamDescriptor, type CaptureStreamPacket } from '@pascal-app/core/capture';
+import { type ComponentType } from 'react';
+export type CaptureMeshPresentation = {
+    dollhouse?: boolean;
+    previewMaterial?: 'clay' | 'recorded';
+};
+export type CaptureStreamRendererProps = {
+    artifactUrl: string | null;
+    descriptor: CaptureSessionDescriptor;
+    meshPresentation?: CaptureMeshPresentation;
+    packets: readonly CaptureStreamPacket[];
+    scan: ScanNode;
+    source: CaptureSource;
+    stream: CaptureStreamDescriptor;
+    streamEpoch: string;
+};
+export type CaptureStreamRenderer = ComponentType<CaptureStreamRendererProps>;
+export type CaptureRuntimeErrorContext = {
+    phase: 'source';
+    scanId: ScanNode['id'];
+    sessionId: string;
+} | {
+    layerKey: string;
+    phase: 'stream';
+    scanId: ScanNode['id'];
+    sessionId: string;
+    streamId: string;
+    streamKind: string;
+};
+export type CaptureRuntimeProps = {
+    defaultLayerVisibility?: Readonly<Record<string, boolean>>;
+    maxPacketsPerStream?: number;
+    onError?: (error: Error, context: CaptureRuntimeErrorContext) => void;
+    renderers?: Readonly<Record<string, CaptureStreamRenderer>>;
+    resolveSource: CaptureSourceResolver;
+    retryKey?: number | string;
+};
+export declare function CaptureRuntime({ defaultLayerVisibility, maxPacketsPerStream, onError, renderers, resolveSource, retryKey, }: CaptureRuntimeProps): import("react").JSX.Element;
+export declare function CaptureStreamLayer({ descriptor, meshPresentation, packets, renderers, scan, source, stream, streamEpoch, }: Omit<CaptureStreamRendererProps, 'artifactUrl'> & {
+    renderers: Readonly<Record<string, CaptureStreamRenderer>>;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=capture-runtime.d.ts.map

package/dist/capture/capture-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture-runtime.d.ts","sourceRoot":"","sources":["../../src/capture/capture-runtime.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,QAAQ,EAA2B,MAAM,kBAAkB,CAAA;AACzE,OAAO,EAIL,KAAK,wBAAwB,EAE7B,KAAK,aAAa,EAClB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EAGzB,MAAM,0BAA0B,CAAA;AAEjC,OAAO,EACL,KAAK,aAAa,EAQnB,MAAM,OAAO,CAAA;AAsBd,MAAM,MAAM,uBAAuB,GAAG;IACpC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,eAAe,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;CACtC,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,UAAU,EAAE,wBAAwB,CAAA;IACpC,gBAAgB,CAAC,EAAE,uBAAuB,CAAA;IAC1C,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACvC,IAAI,EAAE,QAAQ,CAAA;IACd,MAAM,EAAE,aAAa,CAAA;IACrB,MAAM,EAAE,uBAAuB,CAAA;IAC/B,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,0BAA0B,CAAC,CAAA;AAE7E,MAAM,MAAM,0BAA0B,GAClC;IACE,KAAK,EAAE,QAAQ,CAAA;IACf,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;CAClB,GACD;IACE,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,QAAQ,CAAA;IACf,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAEL,MAAM,MAAM,mBAAmB,GAAG;IAChC,sBAAsB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IAC1D,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,0BAA0B,KAAK,IAAI,CAAA;IACrE,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAA;IAC3D,aAAa,EAAE,qBAAqB,CAAA;IACpC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAC3B,CAAA;AAMD,wBAAgB,cAAc,CAAC,EAC7B,sBAA+C,EAC/C,mBAAwB,EACxB,OAAO,EACP,SAA2B,EAC3B,aAAa,EACb,QAAY,GACb,EAAE,mBAAmB,+BA6BrB;AAoHD,wBAAgB,kBAAkB,CAAC,EACjC,UAAU,EACV,gBAAgB,EAChB,OAAO,EACP,SAAS,EACT,IAAI,EACJ,MAAM,EACN,MAAM,EACN,WAAW,GACZ,EAAE,IAAI,CAAC,0BAA0B,EAAE,aAAa,CAAC,GAAG;IACnD,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC,CAAA;CAC3D,sCAqGA"}

package/dist/capture/capture-runtime.js

@@ -0,0 +1,228 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { sceneRegistry, useScene } from '@pascal-app/core';
+import { CaptureArtifactReferenceSchema, captureLayerKey, DeviceMotionTrajectorySchema, } from '@pascal-app/core/capture';
+import { createPortal, useFrame } from '@react-three/fiber';
+import { Suspense, useCallback, useEffect, useMemo, useRef, useState, } from 'react';
+import { ErrorBoundary } from '../components/error-boundary';
+import { useNodeEvents } from '../hooks/use-node-events';
+import useViewer from '../store/use-viewer';
+import { rewriteLoopbackAssetUrl } from './asset-url';
+import { resolveCaptureFrameMatrix } from './frame';
+import { isCaptureSessionVisible, isCaptureStreamVisible } from './layer-visibility';
+import { CaptureDeviceMotionLayer } from './layers/device-motion-layer';
+import { CapturePointCloudLayer } from './layers/point-cloud-layer';
+import { CaptureRoomModel } from './layers/room-model-layer';
+import { CaptureSurfaceMeshLayer } from './layers/surface-mesh-layer';
+import { useCaptureSource } from './source-state';
+import { captureModelFormat, isCaptureModelArtifact, isCapturePointCloudArtifact, isCaptureStreamRenderable, streamHydratesJsonPayload, } from './stream-rendering';
+import { parseDeviceTrajectoryPackets, parseDeviceTrajectoryPayload } from './trajectory';
+const EMPTY_RENDERERS = {};
+const EMPTY_LAYER_VISIBILITY = {};
+export function CaptureRuntime({ defaultLayerVisibility = EMPTY_LAYER_VISIBILITY, maxPacketsPerStream = 32, onError, renderers = EMPTY_RENDERERS, resolveSource, retryKey = 0, }) {
+    const nodes = useScene((state) => state.nodes);
+    const showScans = useViewer((state) => state.showScans);
+    const scans = useMemo(() => Object.values(nodes).filter((node) => node.type === 'scan' &&
+        node.captureSession !== null &&
+        isCaptureSessionVisible(showScans, node.visible)), [nodes, showScans]);
+    return (_jsx(_Fragment, { children: scans.map((scan) => (_jsx(CaptureSessionPortal, { defaultLayerVisibility: defaultLayerVisibility, maxPacketsPerStream: maxPacketsPerStream, onError: onError, renderers: renderers, resolveSource: resolveSource, scan: scan }, `${scan.id}:${retryKey}`))) }));
+}
+function CaptureSessionPortal({ defaultLayerVisibility, maxPacketsPerStream, onError, renderers, resolveSource, scan, }) {
+    const [target, setTarget] = useState(null);
+    const onErrorRef = useRef(onError);
+    const handlers = useNodeEvents(scan, 'scan');
+    const customRendererKeys = useMemo(() => new Set(Object.keys(renderers)), [renderers]);
+    const streamFilter = useCallback((stream) => isCaptureStreamVisible(stream, scan.layers, defaultLayerVisibility) &&
+        isCaptureStreamRenderable(stream, customRendererKeys), [customRendererKeys, defaultLayerVisibility, scan.layers]);
+    const sourceState = useCaptureSource(scan.captureSession, resolveSource, {
+        maxPacketsPerStream,
+        streamFilter,
+    });
+    useEffect(() => {
+        onErrorRef.current = onError;
+    }, [onError]);
+    useEffect(() => {
+        if (!sourceState.error)
+            return;
+        onErrorRef.current?.(sourceState.error, {
+            phase: 'source',
+            scanId: scan.id,
+            sessionId: scan.captureSession.sessionId,
+        });
+    }, [scan.captureSession.sessionId, scan.id, sourceState.error]);
+    useFrame(() => {
+        const nextTarget = sceneRegistry.nodes.get(scan.id) ?? null;
+        if (nextTarget !== target)
+            setTarget(nextTarget);
+    });
+    const descriptor = sourceState.descriptor;
+    const source = sourceState.source;
+    if (!(target && descriptor && source))
+        return null;
+    const visibleStreams = descriptor.streams.filter(streamFilter);
+    return createPortal(_jsx("group", { ...handlers, children: visibleStreams.map((stream) => {
+            const layerKey = captureLayerKey(stream);
+            const renderKey = captureStreamRenderKey(stream);
+            const packets = sourceState.packets[stream.id] ?? [];
+            const streamEpoch = sourceState.streamEpochs[stream.id] ??
+                `descriptor:${descriptor.revisionId ?? ''}:${stream.id}:${stream.frameId ?? ''}`;
+            const latestPacket = packets.at(-1);
+            const packetRevision = latestPacket
+                ? `${latestPacket.generation}:${latestPacket.sequence}:${latestPacket.frameId ?? ''}`
+                : 'static';
+            return (_jsx(ErrorBoundary, { fallback: _jsx("group", {}), onError: (error) => onErrorRef.current?.(error, {
+                    layerKey,
+                    phase: 'stream',
+                    scanId: scan.id,
+                    sessionId: scan.captureSession.sessionId,
+                    streamId: stream.id,
+                    streamKind: stream.kind,
+                }), resetKey: `${renderKey}:${sourceState.descriptorVersion}:${streamEpoch}:${packetRevision}`, scope: `capture:${layerKey}`, children: _jsx(Suspense, { fallback: null, children: _jsx(CaptureStreamLayer, { descriptor: descriptor, packets: packets, renderers: renderers, scan: scan, source: source, stream: stream, streamEpoch: streamEpoch }) }) }, renderKey));
+        }) }), target);
+}
+function captureStreamRenderKey(stream) {
+    const artifact = stream.artifact;
+    return [
+        stream.id,
+        stream.availability,
+        artifact?.id ?? '',
+        artifact?.sha256 ?? '',
+        artifact?.uri ?? '',
+    ].join(':');
+}
+export function CaptureStreamLayer({ descriptor, meshPresentation, packets, renderers, scan, source, stream, streamEpoch, }) {
+    const artifactUrl = useResolvedArtifact(source, stream.artifact);
+    const layerKey = captureLayerKey(stream);
+    const Renderer = renderers[layerKey] ?? renderers[stream.kind];
+    // Extracted previews archive the inline payload shape as a JSON artifact.
+    const payloadArtifactUrl = streamHydratesJsonPayload(stream) ? artifactUrl : null;
+    const fetchedPayload = useJsonArtifactPayload(payloadArtifactUrl);
+    const payload = stream.inline ?? fetchedPayload;
+    const frameId = packets.at(-1)?.frameId ?? stream.frameId ?? stream.artifact?.frameId;
+    const frameMatrix = useMemo(() => resolveCaptureFrameMatrix(descriptor, frameId), [descriptor, frameId]);
+    const trajectory = useMemo(() => {
+        if (layerKey !== 'deviceMotion')
+            return null;
+        const inline = DeviceMotionTrajectorySchema.safeParse(payload);
+        return inline.success
+            ? parseDeviceTrajectoryPayload(inline.data)
+            : parseDeviceTrajectoryPackets(packets.map((packet) => packet.payload));
+    }, [layerKey, packets, payload]);
+    const motionPlaybackKey = useMemo(() => {
+        if (layerKey !== 'deviceMotion')
+            return '';
+        // Fetched payloads can be megabytes — key them by artifact identity and
+        // load state instead of stringifying their content.
+        const inlineVersion = packets.length === 0
+            ? stream.inline != null
+                ? JSON.stringify(stream.inline)
+                : `${payloadArtifactUrl ?? ''}:${fetchedPayload ? 'loaded' : 'pending'}`
+            : '';
+        return [descriptor.revisionId ?? '', streamEpoch, inlineVersion].join(':');
+    }, [
+        descriptor.revisionId,
+        fetchedPayload,
+        layerKey,
+        packets.length,
+        payloadArtifactUrl,
+        stream.inline,
+        streamEpoch,
+    ]);
+    if (frameId && !frameMatrix) {
+        throw new Error(`Capture stream ${stream.id} references an invalid frame: ${frameId}.`);
+    }
+    let content = null;
+    if (Renderer) {
+        content = (_jsx(Renderer, { artifactUrl: artifactUrl, descriptor: descriptor, meshPresentation: meshPresentation, packets: packets, scan: scan, source: source, stream: stream, streamEpoch: streamEpoch }));
+    }
+    else if (layerKey === 'model' &&
+        isCaptureModelArtifact(stream.artifact) &&
+        stream.artifact &&
+        artifactUrl) {
+        content = (_jsx(CaptureRoomModel, { dollhouse: meshPresentation?.dollhouse, format: captureModelFormat(stream.artifact) ?? undefined, mediaType: stream.artifact.mediaType, opacity: scan.opacity, url: artifactUrl }));
+    }
+    else if (layerKey === 'deviceMotion') {
+        content = trajectory ? (_jsx(CaptureDeviceMotionLayer, { trajectory: trajectory }, motionPlaybackKey)) : null;
+    }
+    else if (layerKey === 'pointCloud') {
+        content = (_jsx(CapturePointCloudLayer, { artifactUrl: isCapturePointCloudArtifact(stream.artifact) ? (artifactUrl ?? undefined) : undefined, inline: payload, packets: stream.availability === 'live' ? packets : [] }));
+    }
+    else if (layerKey === 'surfaceMesh') {
+        content = (_jsx(CaptureSurfaceMeshLayer, { appearance: meshPresentation?.previewMaterial, dollhouse: meshPresentation?.dollhouse, inline: payload }));
+    }
+    if (!(content && frameMatrix))
+        return content;
+    return (_jsx("group", { matrix: frameMatrix, matrixAutoUpdate: false, children: content }));
+}
+function useJsonArtifactPayload(url) {
+    const [error, setError] = useState(null);
+    const [payload, setPayload] = useState(null);
+    useEffect(() => {
+        setError(null);
+        setPayload(null);
+        if (!url)
+            return;
+        const abort = new AbortController();
+        void fetch(rewriteLoopbackAssetUrl(url), { signal: abort.signal })
+            .then(async (response) => {
+            if (!response.ok)
+                throw new Error(`Could not load ${url}: ${response.status}`);
+            return (await response.json());
+        })
+            .then((data) => {
+            if (!abort.signal.aborted)
+                setPayload(data);
+        })
+            .catch((cause) => {
+            if (abort.signal.aborted)
+                return;
+            setError(cause instanceof Error ? cause : new Error(`Could not load ${url}.`));
+        });
+        return () => abort.abort();
+    }, [url]);
+    if (error)
+        throw error;
+    return payload;
+}
+function useResolvedArtifact(source, artifact) {
+    const [error, setError] = useState(null);
+    const [url, setUrl] = useState(null);
+    const artifactKey = artifact ? JSON.stringify(artifact) : null;
+    const artifactSnapshot = useMemo(() => artifactKey
+        ? CaptureArtifactReferenceSchema.parse(JSON.parse(artifactKey))
+        : undefined, [artifactKey]);
+    useEffect(() => {
+        const abort = new AbortController();
+        let dispose;
+        setError(null);
+        setUrl(null);
+        if (!artifactSnapshot)
+            return () => abort.abort();
+        const resolve = source.resolveArtifact
+            ? source.resolveArtifact(artifactSnapshot, abort.signal)
+            : artifactSnapshot.uri
+                ? Promise.resolve({ url: artifactSnapshot.uri })
+                : Promise.reject(new Error(`Capture artifact ${artifactSnapshot.id} has no URI.`));
+        void resolve
+            .then((result) => {
+            if (abort.signal.aborted) {
+                result.dispose?.();
+                return;
+            }
+            dispose = result.dispose;
+            setUrl(result.url);
+        })
+            .catch((cause) => {
+            if (!abort.signal.aborted) {
+                setError(cause instanceof Error ? cause : new Error('Could not resolve capture artifact.'));
+            }
+        });
+        return () => {
+            abort.abort();
+            dispose?.();
+        };
+    }, [artifactSnapshot, source]);
+    if (error)
+        throw error;
+    return url;
+}

package/dist/capture/frame.d.ts

@@ -0,0 +1,4 @@
+import type { CaptureSessionDescriptor } from '@pascal-app/core/capture';
+import { Matrix4 } from 'three';
+export declare function resolveCaptureFrameMatrix(descriptor: CaptureSessionDescriptor, frameId: string | undefined): Matrix4 | null;
+//# sourceMappingURL=frame.d.ts.map

package/dist/capture/frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.d.ts","sourceRoot":"","sources":["../../src/capture/frame.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAA;AACxE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAA;AAE/B,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,wBAAwB,EACpC,OAAO,EAAE,MAAM,GAAG,SAAS,GAC1B,OAAO,GAAG,IAAI,CAiBhB"}

package/dist/capture/frame.js

@@ -0,0 +1,21 @@
+import { Matrix4 } from 'three';
+export function resolveCaptureFrameMatrix(descriptor, frameId) {
+    if (!frameId)
+        return null;
+    const frames = new Map(descriptor.coordinateFrames.map((frame) => [frame.id, frame]));
+    const visited = new Set();
+    const matrix = new Matrix4();
+    let currentId = frameId;
+    while (currentId) {
+        if (visited.has(currentId))
+            return null;
+        visited.add(currentId);
+        const frame = frames.get(currentId);
+        if (!frame)
+            return null;
+        if (frame.transform)
+            matrix.premultiply(new Matrix4().fromArray(frame.transform));
+        currentId = frame.parentId;
+    }
+    return matrix;
+}

package/dist/capture/index.d.ts

@@ -0,0 +1,12 @@
+export { rewriteLoopbackAssetUrl } from './asset-url';
+export { type CaptureMeshPresentation, CaptureRuntime, type CaptureRuntimeErrorContext, type CaptureRuntimeProps, CaptureStreamLayer, type CaptureStreamRenderer, type CaptureStreamRendererProps, } from './capture-runtime';
+export { resolveCaptureFrameMatrix } from './frame';
+export { isCaptureLayerVisible, isCaptureSessionVisible, isCaptureStreamVisible, } from './layer-visibility';
+export { CaptureDeviceMotionLayer, DEVICE_MOTION_PLAYBACK_SPEED, } from './layers/device-motion-layer';
+export { buildPointCloudData, CapturePointCloudLayer, type PointCloudData, } from './layers/point-cloud-layer';
+export { CaptureRoomModel } from './layers/room-model-layer';
+export { buildSurfaceMeshData, CaptureSurfaceMeshLayer, type SurfaceMeshData, } from './layers/surface-mesh-layer';
+export { appendCapturePacket, type CaptureSourceState, captureSubscriptionStreamIds, type UseCaptureSourceOptions, useCaptureSource, } from './source-state';
+export { type CaptureModelFormat, captureModelFormat, isCaptureModelArtifact, isCapturePointCloudArtifact, isCaptureStreamRenderable, } from './stream-rendering';
+export { type DeviceTrajectory, type DeviceTrajectoryFrame, type DeviceTrajectoryPose, parseDeviceTrajectoryPackets, parseDeviceTrajectoryPayload, sampleDeviceTrajectory, } from './trajectory';
+//# sourceMappingURL=index.d.ts.map

package/dist/capture/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/capture/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AACrD,OAAO,EACL,KAAK,uBAAuB,EAC5B,cAAc,EACd,KAAK,0BAA0B,EAC/B,KAAK,mBAAmB,EACxB,kBAAkB,EAClB,KAAK,qBAAqB,EAC1B,KAAK,0BAA0B,GAChC,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AACnD,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,sBAAsB,GACvB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,wBAAwB,EACxB,4BAA4B,GAC7B,MAAM,8BAA8B,CAAA;AACrC,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,KAAK,cAAc,GACpB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAC5D,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,KAAK,eAAe,GACrB,MAAM,6BAA6B,CAAA;AACpC,OAAO,EACL,mBAAmB,EACnB,KAAK,kBAAkB,EACvB,4BAA4B,EAC5B,KAAK,uBAAuB,EAC5B,gBAAgB,GACjB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,KAAK,kBAAkB,EACvB,kBAAkB,EAClB,sBAAsB,EACtB,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,4BAA4B,EAC5B,4BAA4B,EAC5B,sBAAsB,GACvB,MAAM,cAAc,CAAA"}

package/dist/capture/index.js

@@ -0,0 +1,11 @@
+export { rewriteLoopbackAssetUrl } from './asset-url';
+export { CaptureRuntime, CaptureStreamLayer, } from './capture-runtime';
+export { resolveCaptureFrameMatrix } from './frame';
+export { isCaptureLayerVisible, isCaptureSessionVisible, isCaptureStreamVisible, } from './layer-visibility';
+export { CaptureDeviceMotionLayer, DEVICE_MOTION_PLAYBACK_SPEED, } from './layers/device-motion-layer';
+export { buildPointCloudData, CapturePointCloudLayer, } from './layers/point-cloud-layer';
+export { CaptureRoomModel } from './layers/room-model-layer';
+export { buildSurfaceMeshData, CaptureSurfaceMeshLayer, } from './layers/surface-mesh-layer';
+export { appendCapturePacket, captureSubscriptionStreamIds, useCaptureSource, } from './source-state';
+export { captureModelFormat, isCaptureModelArtifact, isCapturePointCloudArtifact, isCaptureStreamRenderable, } from './stream-rendering';
+export { parseDeviceTrajectoryPackets, parseDeviceTrajectoryPayload, sampleDeviceTrajectory, } from './trajectory';

package/dist/capture/layer-visibility.d.ts

@@ -0,0 +1,5 @@
+import type { CaptureStreamDescriptor } from '@pascal-app/core/capture';
+export declare function isCaptureLayerVisible(layers: Readonly<Record<string, boolean>>, layerKey: string, defaultLayerVisibility?: Readonly<Record<string, boolean>>): boolean;
+export declare function isCaptureStreamVisible(stream: CaptureStreamDescriptor, layers: Readonly<Record<string, boolean>>, defaultLayerVisibility?: Readonly<Record<string, boolean>>): boolean;
+export declare function isCaptureSessionVisible(showScans: boolean, scanVisible: boolean): boolean;
+//# sourceMappingURL=layer-visibility.d.ts.map

package/dist/capture/layer-visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-visibility.d.ts","sourceRoot":"","sources":["../../src/capture/layer-visibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAKvE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,QAAQ,EAAE,MAAM,EAChB,sBAAsB,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAA0B,GACjF,OAAO,CAET;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,sBAAsB,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAA0B,GACjF,OAAO,CAET;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,GAAG,OAAO,CAEzF"}

package/dist/capture/layer-visibility.js

@@ -0,0 +1,11 @@
+import { captureLayerKey } from '@pascal-app/core/capture';
+const EMPTY_LAYER_VISIBILITY = {};
+export function isCaptureLayerVisible(layers, layerKey, defaultLayerVisibility = EMPTY_LAYER_VISIBILITY) {
+    return layers[layerKey] ?? defaultLayerVisibility[layerKey] ?? true;
+}
+export function isCaptureStreamVisible(stream, layers, defaultLayerVisibility = EMPTY_LAYER_VISIBILITY) {
+    return isCaptureLayerVisible(layers, captureLayerKey(stream), defaultLayerVisibility);
+}
+export function isCaptureSessionVisible(showScans, scanVisible) {
+    return showScans && scanVisible;
+}

package/dist/capture/layers/clay-matcap.d.ts

@@ -0,0 +1,3 @@
+import { DataTexture } from 'three';
+export declare function createClayMatcap(): DataTexture;
+//# sourceMappingURL=clay-matcap.d.ts.map

package/dist/capture/layers/clay-matcap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clay-matcap.d.ts","sourceRoot":"","sources":["../../../src/capture/layers/clay-matcap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA4C,MAAM,OAAO,CAAA;AAE7E,wBAAgB,gBAAgB,IAAI,WAAW,CA0B9C"}

package/dist/capture/layers/clay-matcap.js

@@ -0,0 +1,26 @@
+import { DataTexture, LinearFilter, RGBAFormat, SRGBColorSpace } from 'three';
+export function createClayMatcap() {
+    const size = 128;
+    const pixels = new Uint8Array(size * size * 4);
+    for (let row = 0; row < size; row += 1) {
+        for (let column = 0; column < size; column += 1) {
+            const x = (column / (size - 1)) * 2 - 1;
+            const y = (row / (size - 1)) * 2 - 1;
+            const z = Math.sqrt(Math.max(0, 1 - x * x - y * y));
+            const gloss = Math.exp(-((x + 0.34) ** 2 / 0.045 + (y - 0.42) ** 2 / 0.075));
+            const rim = Math.exp(-((x - 0.65) ** 2 / 0.025 + (y + 0.15) ** 2 / 0.5)) * 0.3;
+            const base = [0.3 + (1 - z) * 0.22, 0.35 + (x + 1) * 0.16 + z * 0.12, 0.64 + z * 0.2];
+            const offset = (row * size + column) * 4;
+            for (let channel = 0; channel < 3; channel += 1) {
+                pixels[offset + channel] = Math.round(Math.min(1, base[channel] + gloss * 0.58 + rim) * 255);
+            }
+            pixels[offset + 3] = 255;
+        }
+    }
+    const texture = new DataTexture(pixels, size, size, RGBAFormat);
+    texture.colorSpace = SRGBColorSpace;
+    texture.minFilter = LinearFilter;
+    texture.magFilter = LinearFilter;
+    texture.needsUpdate = true;
+    return texture;
+}

package/dist/capture/layers/device-motion-layer.d.ts

@@ -0,0 +1,7 @@
+import { type DeviceTrajectory } from '../trajectory';
+export declare const DEVICE_MOTION_PLAYBACK_SPEED = 3;
+export declare function CaptureDeviceMotionLayer({ lineWidth, trajectory, }: {
+    lineWidth?: number;
+    trajectory: DeviceTrajectory;
+}): import("react").JSX.Element;
+//# sourceMappingURL=device-motion-layer.d.ts.map

package/dist/capture/layers/device-motion-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-motion-layer.d.ts","sourceRoot":"","sources":["../../../src/capture/layers/device-motion-layer.tsx"],"names":[],"mappings":"AAaA,OAAO,EAAE,KAAK,gBAAgB,EAA0B,MAAM,eAAe,CAAA;AAE7E,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C,wBAAgB,wBAAwB,CAAC,EACvC,SAAe,EACf,UAAU,GACX,EAAE;IACD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,gBAAgB,CAAA;CAC7B,+BAiDA"}

package/dist/capture/layers/device-motion-layer.js

@@ -0,0 +1,78 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useFrame } from '@react-three/fiber';
+import { useEffect, useMemo, useRef } from 'react';
+import { BufferGeometry, LineBasicMaterial, LineSegments, Quaternion, Line as ThreeLine, Vector3, } from 'three';
+import { sampleDeviceTrajectory } from '../trajectory';
+export const DEVICE_MOTION_PLAYBACK_SPEED = 3;
+export function CaptureDeviceMotionLayer({ lineWidth = 2.5, trajectory, }) {
+    const deviceRef = useRef(null);
+    const elapsedRef = useRef(0);
+    const position = useMemo(() => new Vector3(), []);
+    const toPosition = useMemo(() => new Vector3(), []);
+    const fromQuaternion = useMemo(() => new Quaternion(), []);
+    const toQuaternion = useMemo(() => new Quaternion(), []);
+    const trajectorySegments = useMemo(() => {
+        const segments = new Map();
+        for (const pose of trajectory.poses) {
+            const points = segments.get(pose.segment) ?? [];
+            points.push(pose.position);
+            segments.set(pose.segment, points);
+        }
+        return [...segments.entries()]
+            .filter(([, points]) => points.length > 1)
+            .map(([segment, points]) => ({ points, segment }));
+    }, [trajectory]);
+    useFrame((_, delta) => {
+        if (!deviceRef.current)
+            return;
+        elapsedRef.current += delta * DEVICE_MOTION_PLAYBACK_SPEED;
+        const frame = sampleDeviceTrajectory(trajectory, elapsedRef.current);
+        position
+            .fromArray(frame.from.position)
+            .lerp(toPosition.fromArray(frame.to.position), frame.alpha);
+        fromQuaternion.fromArray(frame.from.quaternion);
+        toQuaternion.fromArray(frame.to.quaternion);
+        deviceRef.current.position.copy(position);
+        deviceRef.current.quaternion.slerpQuaternions(fromQuaternion, toQuaternion, frame.alpha);
+    });
+    return (_jsxs("group", { children: [trajectorySegments.map(({ points, segment }) => (_jsx(CaptureLine, { color: "#222326", lineWidth: lineWidth, opacity: 0.78, points: points }, segment))), _jsx("group", { ref: deviceRef, children: _jsx(CameraFrustum, { lineWidth: lineWidth }) })] }));
+}
+function CameraFrustum({ lineWidth }) {
+    const apex = [0, 0, 0];
+    const topRight = [0.14, 0.1, -0.28];
+    const topLeft = [-0.14, 0.1, -0.28];
+    const bottomLeft = [-0.14, -0.1, -0.28];
+    const bottomRight = [0.14, -0.1, -0.28];
+    const corners = [topRight, topLeft, bottomLeft, bottomRight];
+    const points = [
+        ...corners.map((corner) => [apex, corner]),
+        [topRight, topLeft],
+        [topLeft, bottomLeft],
+        [bottomLeft, bottomRight],
+        [bottomRight, topRight],
+    ].flat();
+    return (_jsxs("group", { children: [_jsx(CaptureLine, { color: "#f5b900", lineWidth: lineWidth, points: points, segments: true }), _jsxs("mesh", { children: [_jsx("sphereGeometry", { args: [0.025, 12, 12] }), _jsx("meshBasicMaterial", { color: "#ffd84d" })] })] }));
+}
+function CaptureLine({ color, lineWidth, opacity = 1, points, segments = false, }) {
+    const line = useMemo(() => {
+        const geometry = new BufferGeometry().setFromPoints(points.map(([x, y, z]) => new Vector3(x, y, z)));
+        const material = new LineBasicMaterial({
+            color,
+            depthWrite: opacity >= 1,
+            linewidth: lineWidth,
+            opacity,
+            transparent: opacity < 1,
+        });
+        const object = segments
+            ? new LineSegments(geometry, material)
+            : new ThreeLine(geometry, material);
+        object.frustumCulled = false;
+        return object;
+    }, [color, lineWidth, opacity, points, segments]);
+    useEffect(() => () => {
+        line.geometry.dispose();
+        line.material.dispose();
+    }, [line]);
+    return _jsx("primitive", { object: line });
+}

package/dist/capture/layers/point-cloud-layer.d.ts

@@ -0,0 +1,15 @@
+import type { CaptureStreamPacket } from '@pascal-app/core/capture';
+export type PointCloudData = {
+    colors: Float32Array | null;
+    positions: Float32Array;
+};
+export declare function CapturePointCloudLayer({ artifactUrl, inline, maxPoints, packets, pointSize, }: {
+    artifactUrl?: string;
+    inline?: unknown;
+    maxPoints?: number;
+    packets?: readonly CaptureStreamPacket[];
+    pointSize?: number;
+}): import("react").JSX.Element | null;
+export declare function buildPointCloudData(packets: readonly CaptureStreamPacket[], maxPoints: number): PointCloudData;
+export declare function buildPointCloudPayloadData(value: unknown, maxPoints: number): PointCloudData;
+//# sourceMappingURL=point-cloud-layer.d.ts.map

package/dist/capture/layers/point-cloud-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"point-cloud-layer.d.ts","sourceRoot":"","sources":["../../../src/capture/layers/point-cloud-layer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAOnE,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,YAAY,GAAG,IAAI,CAAA;IAC3B,SAAS,EAAE,YAAY,CAAA;CACxB,CAAA;AAED,wBAAgB,sBAAsB,CAAC,EACrC,WAAW,EACX,MAAM,EACN,SAAmB,EACnB,OAAY,EACZ,SAAiB,GAClB,EAAE;IACD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAA;IACxC,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,sCAaA;AAyCD,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,mBAAmB,EAAE,EACvC,SAAS,EAAE,MAAM,GAChB,cAAc,CA6BhB;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,cAAc,CAY5F"}