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

package/dist/capture/layers/point-cloud-layer.js

@@ -0,0 +1,106 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLoader } from '@react-three/fiber';
+import { useEffect, useMemo } from 'react';
+import { BufferGeometry, Float32BufferAttribute } from 'three';
+import { PLYLoader } from 'three/addons/loaders/PLYLoader.js';
+import { rewriteLoopbackAssetUrl } from '../asset-url';
+export function CapturePointCloudLayer({ artifactUrl, inline, maxPoints = 250_000, packets = [], pointSize = 0.012, }) {
+    const liveData = useMemo(() => buildPointCloudData(packets, maxPoints), [maxPoints, packets]);
+    const inlineData = useMemo(() => buildPointCloudPayloadData(inline, maxPoints), [inline, maxPoints]);
+    if (liveData.positions.length > 0) {
+        return _jsx(PointCloudDataLayer, { data: liveData, pointSize: pointSize });
+    }
+    if (inlineData.positions.length > 0) {
+        return _jsx(PointCloudDataLayer, { data: inlineData, pointSize: pointSize });
+    }
+    return artifactUrl ? _jsx(PlyPointCloud, { pointSize: pointSize, url: artifactUrl }) : null;
+}
+function PlyPointCloud({ pointSize, url }) {
+    const source = useLoader(PLYLoader, rewriteLoopbackAssetUrl(url));
+    const geometry = useMemo(() => source.clone(), [source]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    return (_jsx("points", { frustumCulled: false, geometry: geometry, children: _jsx("pointsMaterial", { color: geometry.getAttribute('color') ? undefined : '#8fb8d8', size: pointSize, sizeAttenuation: true, vertexColors: Boolean(geometry.getAttribute('color')) }) }));
+}
+function PointCloudDataLayer({ data, pointSize }) {
+    const geometry = useMemo(() => {
+        const next = new BufferGeometry();
+        next.setAttribute('position', new Float32BufferAttribute(data.positions, 3));
+        if (data.colors)
+            next.setAttribute('color', new Float32BufferAttribute(data.colors, 3));
+        next.computeBoundingSphere();
+        return next;
+    }, [data]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    return (_jsx("points", { frustumCulled: false, geometry: geometry, children: _jsx("pointsMaterial", { color: data.colors ? undefined : '#8fb8d8', size: pointSize, sizeAttenuation: true, vertexColors: Boolean(data.colors) }) }));
+}
+export function buildPointCloudData(packets, maxPoints) {
+    const chunks = [];
+    let pointCount = 0;
+    let allHaveColors = true;
+    for (let index = packets.length - 1; index >= 0 && pointCount < maxPoints; index -= 1) {
+        const parsed = parsePointPayload(packets[index]?.payload);
+        if (!parsed)
+            continue;
+        const availablePoints = Math.floor(parsed.positions.length / 3);
+        const keepPoints = Math.min(availablePoints, maxPoints - pointCount);
+        if (keepPoints <= 0)
+            continue;
+        const start = (availablePoints - keepPoints) * 3;
+        chunks.unshift({
+            colors: parsed.colors?.slice(start) ?? null,
+            positions: parsed.positions.slice(start),
+        });
+        pointCount += keepPoints;
+        allHaveColors &&= parsed.colors !== null;
+    }
+    const positions = new Float32Array(pointCount * 3);
+    const colors = allHaveColors && pointCount > 0 ? new Float32Array(pointCount * 3) : null;
+    let offset = 0;
+    for (const chunk of chunks) {
+        positions.set(chunk.positions, offset);
+        if (colors && chunk.colors)
+            colors.set(normalizeColors(chunk.colors), offset);
+        offset += chunk.positions.length;
+    }
+    return { colors, positions };
+}
+export function buildPointCloudPayloadData(value, maxPoints) {
+    const parsed = parsePointPayload(value);
+    if (!parsed)
+        return { colors: null, positions: new Float32Array() };
+    const availablePoints = Math.floor(parsed.positions.length / 3);
+    const keepPoints = Math.min(availablePoints, maxPoints);
+    const start = (availablePoints - keepPoints) * 3;
+    const positions = new Float32Array(parsed.positions.slice(start));
+    const colors = parsed.colors
+        ? new Float32Array(normalizeColors(parsed.colors.slice(start)))
+        : null;
+    return { colors, positions };
+}
+function parsePointPayload(value) {
+    if (!(value && typeof value === 'object'))
+        return null;
+    const payload = value;
+    const positions = numericArray(payload.positions);
+    if (!(positions && positions.length >= 3 && positions.length % 3 === 0))
+        return null;
+    const colors = numericArray(payload.colors);
+    return {
+        colors: colors && colors.length === positions.length ? colors : null,
+        positions,
+    };
+}
+function numericArray(value) {
+    if (Array.isArray(value) && value.every((entry) => Number.isFinite(entry)))
+        return value;
+    if (ArrayBuffer.isView(value)) {
+        const entries = Array.from(value);
+        return entries.every(Number.isFinite) ? entries : null;
+    }
+    return null;
+}
+function normalizeColors(colors) {
+    const divisor = colors.some((value) => value > 1) ? 255 : 1;
+    return colors.map((value) => Math.min(1, Math.max(0, value / divisor)));
+}

package/dist/capture/layers/room-model-layer.d.ts

@@ -0,0 +1,9 @@
+import type { CaptureModelFormat } from '../stream-rendering';
+export declare function CaptureRoomModel({ dollhouse, format, mediaType, opacity, url, }: {
+    dollhouse?: boolean;
+    format?: CaptureModelFormat;
+    mediaType: string;
+    opacity?: number;
+    url: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=room-model-layer.d.ts.map

package/dist/capture/layers/room-model-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-model-layer.d.ts","sourceRoot":"","sources":["../../../src/capture/layers/room-model-layer.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAE7D,wBAAgB,gBAAgB,CAAC,EAC/B,SAAS,EACT,MAAM,EACN,SAAS,EACT,OAAa,EACb,GAAG,GACJ,EAAE;IACD,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,MAAM,CAAC,EAAE,kBAAkB,CAAA;IAC3B,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;CACZ,+BASA"}

package/dist/capture/layers/room-model-layer.js

@@ -0,0 +1,71 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLoader } from '@react-three/fiber';
+import { useEffect, useMemo } from 'react';
+import { DoubleSide, FrontSide } from 'three';
+import { USDLoader } from 'three/addons/loaders/USDLoader.js';
+import { useGLTFKTX2 } from '../../hooks/use-gltf-ktx2';
+import { rewriteLoopbackAssetUrl } from '../asset-url';
+export function CaptureRoomModel({ dollhouse, format, mediaType, opacity = 100, url, }) {
+    if (format === 'usdz' ||
+        mediaType === 'model/vnd.usdz+zip' ||
+        url.toLowerCase().endsWith('.usdz')) {
+        return _jsx(UsdzRoomModel, { dollhouse: dollhouse, opacity: opacity, url: url });
+    }
+    return _jsx(GlbRoomModel, { dollhouse: dollhouse, opacity: opacity, url: url });
+}
+function UsdzRoomModel({ dollhouse, opacity, url, }) {
+    const source = useLoader(USDLoader, rewriteLoopbackAssetUrl(url));
+    const model = useClonedModel(source, opacity, dollhouse);
+    return _jsx("primitive", { object: model });
+}
+function GlbRoomModel({ dollhouse, opacity, url, }) {
+    const gltf = useGLTFKTX2(rewriteLoopbackAssetUrl(url));
+    const model = useClonedModel(gltf.scene, opacity, dollhouse);
+    return _jsx("primitive", { object: model });
+}
+function useClonedModel(source, opacity, dollhouse) {
+    const model = useMemo(() => {
+        const clone = source.clone(true);
+        clone.traverse((child) => {
+            const mesh = child;
+            if (!mesh.isMesh)
+                return;
+            mesh.material = Array.isArray(mesh.material)
+                ? mesh.material.map((material) => material.clone())
+                : mesh.material.clone();
+            for (const material of Array.isArray(mesh.material) ? mesh.material : [mesh.material]) {
+                if (dollhouse !== undefined)
+                    material.side = dollhouse ? FrontSide : DoubleSide;
+            }
+        });
+        return clone;
+    }, [source, dollhouse]);
+    useEffect(() => {
+        const normalizedOpacity = opacity / 100;
+        const transparent = normalizedOpacity < 1;
+        model.traverse((child) => {
+            const mesh = child;
+            if (!mesh.isMesh)
+                return;
+            const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+            for (const material of materials) {
+                material.transparent = transparent;
+                material.opacity = normalizedOpacity;
+                material.depthWrite = !transparent;
+                material.needsUpdate = true;
+            }
+        });
+    }, [model, opacity]);
+    useEffect(() => () => {
+        model.traverse((child) => {
+            const mesh = child;
+            if (!mesh.isMesh)
+                return;
+            const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
+            for (const material of materials)
+                material.dispose();
+        });
+    }, [model]);
+    return model;
+}

package/dist/capture/layers/surface-mesh-data.d.ts

@@ -0,0 +1,9 @@
+import { BufferGeometry } from 'three';
+export type SurfaceMeshData = {
+    colors: Float32Array;
+    indices: Uint16Array;
+    positions: Float32Array;
+};
+export declare function createSurfaceMeshGeometry(value: unknown): BufferGeometry | null;
+export declare function buildSurfaceMeshData(value: unknown): SurfaceMeshData | null;
+//# sourceMappingURL=surface-mesh-data.d.ts.map

package/dist/capture/layers/surface-mesh-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-mesh-data.d.ts","sourceRoot":"","sources":["../../../src/capture/layers/surface-mesh-data.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAiD,MAAM,OAAO,CAAA;AAErF,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,YAAY,CAAA;IACpB,OAAO,EAAE,WAAW,CAAA;IACpB,SAAS,EAAE,YAAY,CAAA;CACxB,CAAA;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,GAAG,IAAI,CAU/E;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,GAAG,IAAI,CAwC3E"}

package/dist/capture/layers/surface-mesh-data.js

@@ -0,0 +1,74 @@
+import { SurfaceMeshPayloadSchema } from '@pascal-app/core/capture';
+import { BufferGeometry, Float32BufferAttribute, Uint16BufferAttribute } from 'three';
+export function createSurfaceMeshGeometry(value) {
+    const data = buildSurfaceMeshData(value);
+    if (!data)
+        return null;
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(data.positions, 3));
+    geometry.setAttribute('color', new Float32BufferAttribute(data.colors, 3));
+    geometry.setIndex(new Uint16BufferAttribute(data.indices, 1));
+    geometry.computeVertexNormals();
+    geometry.computeBoundingSphere();
+    return geometry;
+}
+export function buildSurfaceMeshData(value) {
+    const parsed = SurfaceMeshPayloadSchema.safeParse(value);
+    if (!parsed.success)
+        return null;
+    const payload = parsed.data;
+    const positionBytes = decodeBase64(payload.positions);
+    const colorBytes = decodeBase64(payload.colors);
+    const indexBytes = decodeBase64(payload.indices);
+    if (positionBytes.byteLength !== payload.vertexCount * 3 * 2 ||
+        colorBytes.byteLength !== payload.vertexCount * 3 ||
+        indexBytes.byteLength !== payload.faceCount * 3 * 2) {
+        return null;
+    }
+    const positions = new Float32Array(payload.vertexCount * 3);
+    const colors = new Float32Array(payload.vertexCount * 3);
+    const indices = new Uint16Array(payload.faceCount * 3);
+    const positionView = new DataView(positionBytes.buffer, positionBytes.byteOffset, positionBytes.byteLength);
+    const indexView = new DataView(indexBytes.buffer, indexBytes.byteOffset, indexBytes.byteLength);
+    for (let index = 0; index < payload.vertexCount; index += 1) {
+        for (let axis = 0; axis < 3; axis += 1) {
+            const offset = index * 3 + axis;
+            const minimum = payload.boundsMin[axis] ?? 0;
+            const maximum = payload.boundsMax[axis] ?? minimum;
+            const quantized = positionView.getUint16(offset * 2, true);
+            positions[offset] = minimum + (quantized / 65_535) * (maximum - minimum);
+            colors[offset] = (colorBytes[offset] ?? 0) / 255;
+        }
+    }
+    for (let index = 0; index < indices.length; index += 1) {
+        const vertexIndex = indexView.getUint16(index * 2, true);
+        if (vertexIndex >= payload.vertexCount)
+            return null;
+        indices[index] = vertexIndex;
+    }
+    return { colors, indices, positions };
+}
+function decodeBase64(value) {
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    const clean = value.replace(/\s/g, '');
+    const padding = clean.endsWith('==') ? 2 : clean.endsWith('=') ? 1 : 0;
+    const outputLength = Math.floor((clean.length * 3) / 4) - padding;
+    const output = new Uint8Array(Math.max(0, outputLength));
+    let outputIndex = 0;
+    for (let index = 0; index < clean.length; index += 4) {
+        const a = alphabet.indexOf(clean[index] ?? '');
+        const b = alphabet.indexOf(clean[index + 1] ?? '');
+        const c = clean[index + 2] === '=' ? 0 : alphabet.indexOf(clean[index + 2] ?? '');
+        const d = clean[index + 3] === '=' ? 0 : alphabet.indexOf(clean[index + 3] ?? '');
+        if (a < 0 || b < 0 || c < 0 || d < 0)
+            return new Uint8Array();
+        const bits = (a << 18) | (b << 12) | (c << 6) | d;
+        if (outputIndex < output.length)
+            output[outputIndex++] = (bits >> 16) & 0xff;
+        if (outputIndex < output.length)
+            output[outputIndex++] = (bits >> 8) & 0xff;
+        if (outputIndex < output.length)
+            output[outputIndex++] = bits & 0xff;
+    }
+    return output;
+}

package/dist/capture/layers/surface-mesh-layer.d.ts

@@ -0,0 +1,7 @@
+export { buildSurfaceMeshData, type SurfaceMeshData } from './surface-mesh-data';
+export declare function CaptureSurfaceMeshLayer({ inline, dollhouse, appearance, }: {
+    inline: unknown;
+    dollhouse?: boolean;
+    appearance?: 'clay' | 'recorded';
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=surface-mesh-layer.d.ts.map

package/dist/capture/layers/surface-mesh-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-mesh-layer.d.ts","sourceRoot":"","sources":["../../../src/capture/layers/surface-mesh-layer.tsx"],"names":[],"mappings":"AAOA,OAAO,EAAE,oBAAoB,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAEhF,wBAAgB,uBAAuB,CAAC,EACtC,MAAM,EACN,SAAiB,EACjB,UAAuB,GACxB,EAAE;IACD,MAAM,EAAE,OAAO,CAAA;IACf,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,GAAG,UAAU,CAAA;CACjC,sCAqBA"}

package/dist/capture/layers/surface-mesh-layer.js

@@ -0,0 +1,16 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useMemo } from 'react';
+import { DoubleSide, FrontSide } from 'three';
+import { createClayMatcap } from './clay-matcap';
+import { createSurfaceMeshGeometry } from './surface-mesh-data';
+export { buildSurfaceMeshData } from './surface-mesh-data';
+export function CaptureSurfaceMeshLayer({ inline, dollhouse = false, appearance = 'recorded', }) {
+    const matcap = useMemo(() => (appearance === 'clay' ? createClayMatcap() : null), [appearance]);
+    useEffect(() => () => matcap?.dispose(), [matcap]);
+    const geometry = useMemo(() => createSurfaceMeshGeometry(inline), [inline]);
+    useEffect(() => () => geometry?.dispose(), [geometry]);
+    if (!geometry)
+        return null;
+    return (_jsx("mesh", { frustumCulled: false, geometry: geometry, children: matcap ? (_jsx("meshMatcapMaterial", { matcap: matcap, side: dollhouse ? FrontSide : DoubleSide })) : (_jsx("meshStandardMaterial", { metalness: 0, roughness: 0.9, side: dollhouse ? FrontSide : DoubleSide, vertexColors: true })) }));
+}

package/dist/capture/preview.d.ts

@@ -0,0 +1,3 @@
+export { createClayMatcap } from './layers/clay-matcap';
+export { buildSurfaceMeshData, createSurfaceMeshGeometry, type SurfaceMeshData, } from './layers/surface-mesh-data';
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/capture/preview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EACL,oBAAoB,EACpB,yBAAyB,EACzB,KAAK,eAAe,GACrB,MAAM,4BAA4B,CAAA"}

package/dist/capture/preview.js

@@ -0,0 +1,2 @@
+export { createClayMatcap } from './layers/clay-matcap';
+export { buildSurfaceMeshData, createSurfaceMeshGeometry, } from './layers/surface-mesh-data';

package/dist/capture/source-state.d.ts

@@ -0,0 +1,22 @@
+import type { CaptureSessionDescriptor, CaptureSessionLocator, CaptureSource, CaptureSourceResolver, CaptureStreamDescriptor, CaptureStreamPacket } from '@pascal-app/core/capture';
+export type CaptureSourceState = {
+    descriptor: CaptureSessionDescriptor | null;
+    descriptorVersion: number;
+    error: Error | null;
+    loading: boolean;
+    packets: Readonly<Record<string, readonly CaptureStreamPacket[]>>;
+    retry: () => void;
+    source: CaptureSource | null;
+    streamEpochs: Readonly<Record<string, string>>;
+};
+export type UseCaptureSourceOptions = {
+    maxPacketsPerStream?: number;
+    streamFilter?: (stream: CaptureStreamDescriptor) => boolean;
+    subscribe?: boolean;
+};
+export declare function useCaptureSource(locator: CaptureSessionLocator | null, resolveSource: CaptureSourceResolver, options?: UseCaptureSourceOptions): CaptureSourceState;
+export declare function captureSubscriptionStreamIds(descriptor: CaptureSessionDescriptor, streamFilter: ((stream: CaptureStreamDescriptor) => boolean) | undefined): readonly string[] | undefined;
+export declare function retainLiveCapturePackets(packetsByStream: Readonly<Record<string, readonly CaptureStreamPacket[]>>, descriptor: CaptureSessionDescriptor): Readonly<Record<string, readonly CaptureStreamPacket[]>>;
+export declare function appendCapturePacket(packetsByStream: Readonly<Record<string, readonly CaptureStreamPacket[]>>, packet: CaptureStreamPacket, maxPacketsPerStream: number): Readonly<Record<string, readonly CaptureStreamPacket[]>>;
+export declare function nextCaptureStreamEpoch(currentEpoch: string | undefined, previousPackets: readonly CaptureStreamPacket[], packet: CaptureStreamPacket): string;
+//# sourceMappingURL=source-state.d.ts.map

package/dist/capture/source-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-state.d.ts","sourceRoot":"","sources":["../../src/capture/source-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,wBAAwB,EACxB,qBAAqB,EACrB,aAAa,EACb,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,EACpB,MAAM,0BAA0B,CAAA;AAGjC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,UAAU,EAAE,wBAAwB,GAAG,IAAI,CAAA;IAC3C,iBAAiB,EAAE,MAAM,CAAA;IACzB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC,CAAC,CAAA;IACjE,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,MAAM,EAAE,aAAa,GAAG,IAAI,CAAA;IAC5B,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAC/C,CAAA;AAID,MAAM,MAAM,uBAAuB,GAAG;IACpC,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,uBAAuB,KAAK,OAAO,CAAA;IAC3D,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAKD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,qBAAqB,GAAG,IAAI,EACrC,aAAa,EAAE,qBAAqB,EACpC,OAAO,GAAE,uBAA4B,GACpC,kBAAkB,CAoDpB;AA8FD,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,wBAAwB,EACpC,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,uBAAuB,KAAK,OAAO,CAAC,GAAG,SAAS,GACvE,SAAS,MAAM,EAAE,GAAG,SAAS,CAI/B;AAED,wBAAgB,wBAAwB,CACtC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC,CAAC,EACzE,UAAU,EAAE,wBAAwB,GACnC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC,CAAC,CAS1D;AAgBD,wBAAgB,mBAAmB,CACjC,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC,CAAC,EACzE,MAAM,EAAE,mBAAmB,EAC3B,mBAAmB,EAAE,MAAM,GAC1B,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC,CAAC,CA+B1D;AAED,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,eAAe,EAAE,SAAS,mBAAmB,EAAE,EAC/C,MAAM,EAAE,mBAAmB,GAC1B,MAAM,CAYR"}

package/dist/capture/source-state.js

@@ -0,0 +1,182 @@
+import { useCallback, useEffect, useState } from 'react';
+const EMPTY_PACKETS = {};
+const EMPTY_STREAM_EPOCHS = {};
+export function useCaptureSource(locator, resolveSource, options = {}) {
+    const { maxPacketsPerStream = 32, streamFilter, subscribe = true } = options;
+    const [retryVersion, setRetryVersion] = useState(0);
+    const [state, setState] = useState({
+        descriptor: null,
+        descriptorVersion: 0,
+        error: null,
+        loading: Boolean(locator),
+        packets: EMPTY_PACKETS,
+        source: null,
+        streamEpochs: EMPTY_STREAM_EPOCHS,
+    });
+    useEffect(() => {
+        const abort = new AbortController();
+        if (!locator) {
+            setState({
+                descriptor: null,
+                descriptorVersion: 0,
+                error: null,
+                loading: false,
+                packets: EMPTY_PACKETS,
+                source: null,
+                streamEpochs: EMPTY_STREAM_EPOCHS,
+            });
+            return () => abort.abort();
+        }
+        setState({
+            descriptor: null,
+            descriptorVersion: retryVersion,
+            error: null,
+            loading: true,
+            packets: EMPTY_PACKETS,
+            source: null,
+            streamEpochs: EMPTY_STREAM_EPOCHS,
+        });
+        void consumeCaptureSource(locator, resolveSource, abort.signal, retryVersion, maxPacketsPerStream, streamFilter, subscribe, setState);
+        return () => abort.abort();
+    }, [locator, maxPacketsPerStream, resolveSource, retryVersion, streamFilter, subscribe]);
+    const retry = useCallback(() => setRetryVersion((current) => current + 1), []);
+    return { ...state, retry };
+}
+async function consumeCaptureSource(locator, resolveSource, signal, descriptorVersion, maxPacketsPerStream, streamFilter, subscribe, setState) {
+    try {
+        const source = await resolveSource(locator);
+        const descriptor = await source.describe(signal);
+        if (signal.aborted)
+            return;
+        setState({
+            descriptor,
+            descriptorVersion,
+            error: null,
+            loading: false,
+            packets: EMPTY_PACKETS,
+            source,
+            streamEpochs: EMPTY_STREAM_EPOCHS,
+        });
+        if (!(subscribe && source.subscribe))
+            return;
+        const streamIds = captureSubscriptionStreamIds(descriptor, streamFilter);
+        const iterator = source.subscribe({ signal, streamIds })[Symbol.asyncIterator]();
+        const closeIterator = () => void iterator.return?.();
+        signal.addEventListener('abort', closeIterator, { once: true });
+        try {
+            for (;;) {
+                const next = await iterator.next();
+                if (next.done || signal.aborted || next.value.type === 'closed')
+                    return;
+                const event = next.value;
+                if (event.type === 'descriptor') {
+                    setState((current) => {
+                        const revisionChanged = current.descriptor?.revisionId !== event.descriptor.revisionId &&
+                            (current.descriptor?.revisionId !== undefined ||
+                                event.descriptor.revisionId !== undefined);
+                        return {
+                            ...current,
+                            descriptor: event.descriptor,
+                            descriptorVersion: current.descriptorVersion + 1,
+                            packets: revisionChanged
+                                ? EMPTY_PACKETS
+                                : retainLiveCapturePackets(current.packets, event.descriptor),
+                            streamEpochs: revisionChanged
+                                ? EMPTY_STREAM_EPOCHS
+                                : retainLiveCaptureStreamValues(current.streamEpochs, event.descriptor),
+                        };
+                    });
+                }
+                else {
+                    setState((current) => {
+                        const previousPackets = current.packets[event.packet.streamId] ?? [];
+                        const packets = appendCapturePacket(current.packets, event.packet, maxPacketsPerStream);
+                        if (packets === current.packets)
+                            return current;
+                        return {
+                            ...current,
+                            packets,
+                            streamEpochs: {
+                                ...current.streamEpochs,
+                                [event.packet.streamId]: nextCaptureStreamEpoch(current.streamEpochs[event.packet.streamId], previousPackets, event.packet),
+                            },
+                        };
+                    });
+                }
+            }
+        }
+        finally {
+            signal.removeEventListener('abort', closeIterator);
+            await iterator.return?.();
+        }
+    }
+    catch (cause) {
+        if (signal.aborted)
+            return;
+        setState({
+            descriptor: null,
+            descriptorVersion,
+            error: cause instanceof Error ? cause : new Error('Could not load capture session.'),
+            loading: false,
+            packets: EMPTY_PACKETS,
+            source: null,
+            streamEpochs: EMPTY_STREAM_EPOCHS,
+        });
+    }
+}
+export function captureSubscriptionStreamIds(descriptor, streamFilter) {
+    return streamFilter
+        ? descriptor.streams.filter(streamFilter).map((stream) => stream.id)
+        : undefined;
+}
+export function retainLiveCapturePackets(packetsByStream, descriptor) {
+    const liveStreamIds = new Set(descriptor.streams
+        .filter((stream) => stream.availability === 'live')
+        .map((stream) => stream.id));
+    return Object.fromEntries(Object.entries(packetsByStream).filter(([streamId]) => liveStreamIds.has(streamId)));
+}
+function retainLiveCaptureStreamValues(valuesByStream, descriptor) {
+    const liveStreamIds = new Set(descriptor.streams
+        .filter((stream) => stream.availability === 'live')
+        .map((stream) => stream.id));
+    return Object.fromEntries(Object.entries(valuesByStream).filter(([streamId]) => liveStreamIds.has(streamId)));
+}
+export function appendCapturePacket(packetsByStream, packet, maxPacketsPerStream) {
+    const previous = packetsByStream[packet.streamId] ?? [];
+    const latest = previous.at(-1);
+    const currentGeneration = latest?.generation;
+    if (currentGeneration !== undefined && packet.generation < currentGeneration)
+        return packetsByStream;
+    const resetSequence = previous[0]?.keyframe ? previous[0].sequence : null;
+    if (currentGeneration === packet.generation &&
+        resetSequence !== null &&
+        packet.sequence <= resetSequence) {
+        return packetsByStream;
+    }
+    const resetsStream = Boolean(packet.keyframe) || latest?.frameId !== packet.frameId;
+    if (latest &&
+        currentGeneration === packet.generation &&
+        resetsStream &&
+        packet.sequence <= latest.sequence) {
+        return packetsByStream;
+    }
+    const sameGeneration = currentGeneration === packet.generation && !resetsStream ? previous : [];
+    if (sameGeneration.some((candidate) => candidate.sequence === packet.sequence))
+        return packetsByStream;
+    const limit = Math.max(1, maxPacketsPerStream);
+    const next = [...sameGeneration, packet]
+        .sort((left, right) => left.sequence - right.sequence)
+        .slice(-limit);
+    return { ...packetsByStream, [packet.streamId]: next };
+}
+export function nextCaptureStreamEpoch(currentEpoch, previousPackets, packet) {
+    const latest = previousPackets.at(-1);
+    const resetsStream = previousPackets.length === 0 ||
+        latest?.generation !== packet.generation ||
+        latest.frameId !== packet.frameId ||
+        Boolean(packet.keyframe);
+    if (resetsStream)
+        return `${packet.generation}:${packet.frameId ?? ''}:${packet.sequence}`;
+    return (currentEpoch ??
+        `${latest.generation}:${latest.frameId ?? ''}:${previousPackets[0]?.sequence ?? latest.sequence}`);
+}

package/dist/capture/stream-rendering.d.ts

@@ -0,0 +1,14 @@
+import { type CaptureArtifactReference, type CaptureStreamDescriptor } from '@pascal-app/core/capture';
+export type CaptureModelFormat = 'gltf' | 'usdz';
+export declare function isCaptureStreamRenderable(stream: CaptureStreamDescriptor, customRendererKeys?: ReadonlySet<string>): boolean;
+/**
+ * Extracted viewer previews (device motion, point cloud, surface mesh) are
+ * archived as JSON payload artifacts whose content matches the inline shape.
+ * One predicate decides both renderability and runtime hydration, so a
+ * stream can never be declared renderable without a hydration path.
+ */
+export declare function streamHydratesJsonPayload(stream: CaptureStreamDescriptor): boolean;
+export declare function isCaptureModelArtifact(artifact: CaptureArtifactReference | undefined): boolean;
+export declare function captureModelFormat(artifact: CaptureArtifactReference | undefined): CaptureModelFormat | null;
+export declare function isCapturePointCloudArtifact(artifact: CaptureArtifactReference | undefined): boolean;
+//# sourceMappingURL=stream-rendering.d.ts.map

package/dist/capture/stream-rendering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-rendering.d.ts","sourceRoot":"","sources":["../../src/capture/stream-rendering.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAK7B,MAAM,0BAA0B,CAAA;AAOjC,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,MAAM,CAAA;AAEhD,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,uBAAuB,EAC/B,kBAAkB,GAAE,WAAW,CAAC,MAAM,CAAa,GAClD,OAAO,CA0BT;AAID;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAKlF;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,wBAAwB,GAAG,SAAS,GAAG,OAAO,CAE9F;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,wBAAwB,GAAG,SAAS,GAC7C,kBAAkB,GAAG,IAAI,CAS3B;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,wBAAwB,GAAG,SAAS,GAC7C,OAAO,CAGT"}

package/dist/capture/stream-rendering.js

@@ -0,0 +1,69 @@
+import { captureLayerKey, DeviceMotionTrajectorySchema, PointCloudPayloadSchema, SurfaceMeshPayloadSchema, } from '@pascal-app/core/capture';
+const GLB_MEDIA_TYPES = new Set(['model/gltf-binary', 'model/gltf+json']);
+const USDZ_MEDIA_TYPES = new Set(['model/vnd.usdz+zip']);
+const PLY_MEDIA_TYPES = new Set(['application/ply', 'application/vnd.ply', 'model/ply']);
+const JSON_MEDIA_TYPES = new Set(['application/json']);
+export function isCaptureStreamRenderable(stream, customRendererKeys = new Set()) {
+    if (stream.availability === 'failed' || stream.availability === 'pending')
+        return false;
+    const layerKey = captureLayerKey(stream);
+    if (customRendererKeys.has(layerKey) || customRendererKeys.has(stream.kind))
+        return true;
+    if (layerKey === 'model')
+        return isCaptureModelArtifact(stream.artifact);
+    if (layerKey === 'deviceMotion') {
+        return (stream.availability === 'live' ||
+            streamHydratesJsonPayload(stream) ||
+            DeviceMotionTrajectorySchema.safeParse(stream.inline).success);
+    }
+    if (layerKey === 'pointCloud') {
+        return (stream.availability === 'live' ||
+            isCapturePointCloudArtifact(stream.artifact) ||
+            streamHydratesJsonPayload(stream) ||
+            PointCloudPayloadSchema.safeParse(stream.inline).success);
+    }
+    if (layerKey === 'surfaceMesh') {
+        return (streamHydratesJsonPayload(stream) || SurfaceMeshPayloadSchema.safeParse(stream.inline).success);
+    }
+    return false;
+}
+const JSON_PAYLOAD_LAYER_KEYS = new Set(['deviceMotion', 'pointCloud', 'surfaceMesh']);
+/**
+ * Extracted viewer previews (device motion, point cloud, surface mesh) are
+ * archived as JSON payload artifacts whose content matches the inline shape.
+ * One predicate decides both renderability and runtime hydration, so a
+ * stream can never be declared renderable without a hydration path.
+ */
+export function streamHydratesJsonPayload(stream) {
+    const artifact = stream.artifact;
+    if (!artifact || stream.inline != null)
+        return false;
+    if (!JSON_PAYLOAD_LAYER_KEYS.has(captureLayerKey(stream)))
+        return false;
+    return JSON_MEDIA_TYPES.has(artifact.mediaType) || hasExtension(artifact.uri, ['.json']);
+}
+export function isCaptureModelArtifact(artifact) {
+    return captureModelFormat(artifact) !== null;
+}
+export function captureModelFormat(artifact) {
+    if (!artifact)
+        return null;
+    if (USDZ_MEDIA_TYPES.has(artifact.mediaType) || hasExtension(artifact.uri, ['.usdz'])) {
+        return 'usdz';
+    }
+    if (GLB_MEDIA_TYPES.has(artifact.mediaType) || hasExtension(artifact.uri, ['.glb', '.gltf'])) {
+        return 'gltf';
+    }
+    return null;
+}
+export function isCapturePointCloudArtifact(artifact) {
+    if (!artifact)
+        return false;
+    return PLY_MEDIA_TYPES.has(artifact.mediaType) || hasExtension(artifact.uri, ['.ply']);
+}
+function hasExtension(uri, extensions) {
+    if (!uri)
+        return false;
+    const path = uri.split(/[?#]/, 1)[0]?.toLowerCase() ?? '';
+    return extensions.some((extension) => path.endsWith(extension));
+}

package/dist/capture/trajectory.d.ts

@@ -0,0 +1,20 @@
+import { type DeviceMotionTrajectoryPayload } from '@pascal-app/core/capture';
+export type DeviceTrajectoryPose = {
+    position: [number, number, number];
+    quaternion: [number, number, number, number];
+    segment: number;
+    timestamp: number;
+};
+export type DeviceTrajectory = {
+    duration: number;
+    poses: DeviceTrajectoryPose[];
+};
+export type DeviceTrajectoryFrame = {
+    alpha: number;
+    from: DeviceTrajectoryPose;
+    to: DeviceTrajectoryPose;
+};
+export declare function parseDeviceTrajectoryPayload(trajectory: DeviceMotionTrajectoryPayload | null | undefined): DeviceTrajectory | null;
+export declare function parseDeviceTrajectoryPackets(payloads: readonly unknown[]): DeviceTrajectory | null;
+export declare function sampleDeviceTrajectory(trajectory: DeviceTrajectory, elapsed: number): DeviceTrajectoryFrame;
+//# sourceMappingURL=trajectory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trajectory.d.ts","sourceRoot":"","sources":["../../src/capture/trajectory.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,6BAA6B,EAEnC,MAAM,0BAA0B,CAAA;AAGjC,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5C,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,EAAE,MAAM,CAAA;IAChB,KAAK,EAAE,oBAAoB,EAAE,CAAA;CAC9B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,oBAAoB,CAAA;IAC1B,EAAE,EAAE,oBAAoB,CAAA;CACzB,CAAA;AAED,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,6BAA6B,GAAG,IAAI,GAAG,SAAS,GAC3D,gBAAgB,GAAG,IAAI,CAezB;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B,gBAAgB,GAAG,IAAI,CAezB;AAED,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,gBAAgB,EAC5B,OAAO,EAAE,MAAM,GACd,qBAAqB,CAqBvB"}