@eventual-ai/mcap-viewer 0.1.0-alpha.0 → 0.1.0-alpha.2

package/dist/{types/core → core}/renderers/video-decoder.d.ts

@@ -10,8 +10,11 @@ export declare class CompressedVideoDecoder {
     private pending;
     private failed;
     constructor(output: (frame: VideoFrame, time: bigint) => void, error: (error: Error) => void);
-    decode(time: bigint, bytes: Uint8Array, format?: string): void;
+    /** Decoding starts at the first keyframe; earlier delta packets are dropped. */
+    decode(time: bigint, bytes: Uint8Array, keyframe: boolean, format?: string): void;
     private reject;
+    /** Report once and ignore further packets until `reset`. */
+    private fail;
     flush(): Promise<void>;
     reset(): void;
 }

package/dist/core/renderers/video-decoder.js

@@ -0,0 +1,146 @@
+import { inspectVideo } from "../mcap/codecs/video.js";
+export class CompressedVideoDecoder {
+    output;
+    error;
+    decoder;
+    origin = 0n;
+    times = new Map();
+    generation = 0;
+    initializing;
+    flushing;
+    pending = [];
+    failed = false;
+    constructor(output, error) {
+        this.output = output;
+        this.error = error;
+    }
+    /** Decoding starts at the first keyframe; earlier delta packets are dropped. */
+    decode(time, bytes, keyframe, format = "h264") {
+        if (this.failed)
+            return;
+        try {
+            if (!this.decoder && !this.initializing) {
+                if (!keyframe)
+                    return;
+                const name = format === "h265" ? "HEVC" : "H.264";
+                const codec = inspectVideo(bytes, format).codec;
+                if (!codec) {
+                    this.fail(new Error(`${name} keyframe is missing codec headers`));
+                    return;
+                }
+                if (typeof VideoDecoder === "undefined") {
+                    this.fail(new Error("This browser does not support WebCodecs video decoding"));
+                    return;
+                }
+                this.origin = time;
+                const generation = this.generation;
+                const config = { codec, optimizeForLatency: true };
+                const configure = () => {
+                    if (generation !== this.generation)
+                        return;
+                    this.decoder = new VideoDecoder({
+                        output: (frame) => {
+                            if (generation !== this.generation) {
+                                frame.close();
+                                return;
+                            }
+                            const timestamp = this.times.get(frame.timestamp);
+                            this.times.delete(frame.timestamp);
+                            if (timestamp === undefined) {
+                                frame.close();
+                                return;
+                            }
+                            this.output(frame, timestamp);
+                        },
+                        error: (error) => {
+                            if (generation === this.generation)
+                                this.reject(error, config.codec);
+                        },
+                    });
+                    this.decoder.configure(config);
+                    for (const chunk of this.pending.splice(0))
+                        this.decoder.decode(chunk);
+                };
+                if (typeof VideoDecoder.isConfigSupported === "function") {
+                    this.initializing = VideoDecoder.isConfigSupported(config)
+                        .then((support) => {
+                        if (generation !== this.generation)
+                            return;
+                        if (!support.supported)
+                            throw new Error(`This browser or device does not support ${name} video decoding (${config.codec})`);
+                        configure();
+                    })
+                        .catch((error) => {
+                        if (generation === this.generation)
+                            this.reject(error, config.codec);
+                    });
+                }
+                else
+                    configure();
+            }
+            // WebCodecs timestamps are whole microseconds; frames are far further apart.
+            const timestamp = Number((time - this.origin) / 1000n);
+            this.times.set(timestamp, time);
+            const chunk = new EncodedVideoChunk({
+                type: keyframe ? "key" : "delta",
+                timestamp,
+                data: bytes,
+            });
+            if (this.decoder)
+                this.decoder.decode(chunk);
+            else
+                this.pending.push(chunk);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error : new Error("Video decode failed"));
+        }
+    }
+    reject(error, codec) {
+        this.fail(new Error(`Video decoding failed (${codec}): ${error instanceof Error ? error.message : String(error)}`));
+    }
+    /** Report once and ignore further packets until `reset`. */
+    fail(error) {
+        this.failed = true;
+        this.pending = [];
+        this.times.clear();
+        this.error(error);
+    }
+    flush() {
+        if (this.flushing)
+            return this.flushing;
+        const generation = this.generation;
+        const flushing = (async () => {
+            if (this.initializing)
+                await this.initializing;
+            const decoder = this.decoder;
+            if (generation !== this.generation ||
+                !decoder ||
+                decoder.state !== "configured")
+                return;
+            try {
+                await decoder.flush();
+            }
+            catch (error) {
+                if (generation === this.generation)
+                    this.error(error instanceof Error ? error : new Error("Video decode failed"));
+            }
+        })().finally(() => {
+            // Concurrent callers share one flush; later calls flush again.
+            if (this.flushing === flushing)
+                this.flushing = undefined;
+        });
+        this.flushing = flushing;
+        return flushing;
+    }
+    reset() {
+        this.generation++;
+        if (this.decoder && this.decoder.state !== "closed")
+            this.decoder.close();
+        this.decoder = undefined;
+        this.initializing = undefined;
+        this.flushing = undefined;
+        this.pending = [];
+        this.failed = false;
+        this.times.clear();
+    }
+}

package/dist/core/schemas.d.ts

@@ -0,0 +1,19 @@
+export interface Timestamp {
+    /** int64 as a decimal string. */
+    seconds: string;
+    nanos: number;
+}
+/** One native H.264 or H.265 access unit, the only message MDA sends. */
+export interface CompressedVideo {
+    timestamp: Timestamp | null;
+    frame_id: string;
+    data: Uint8Array;
+    format: string;
+    keyframe: boolean;
+    width: number;
+    height: number;
+    /** uint64 decode position as a decimal string; absent when unset. */
+    decode_order?: string;
+}
+export declare const videoSchema = "eventual.mda.v1.CompressedVideo";
+export declare function compressedVideo(value: unknown): CompressedVideo;

package/dist/core/schemas.js

@@ -0,0 +1,13 @@
+export const videoSchema = "eventual.mda.v1.CompressedVideo";
+export function compressedVideo(value) {
+    if (!value ||
+        typeof value !== "object" ||
+        !("data" in value) ||
+        !(value.data instanceof Uint8Array) ||
+        !("format" in value) ||
+        typeof value.format !== "string" ||
+        !("keyframe" in value) ||
+        typeof value.keyframe !== "boolean")
+        throw new Error("Invalid CompressedVideo message");
+    return value;
+}

package/dist/data-loader/index.d.ts

@@ -0,0 +1,2 @@
+export { DataLoader } from "./loader.js";
+export type { DataLoaderOptions, RequestOptions, Capabilities, TopicInfo, Discovery, Span, ManifestRequest, Manifest, ManifestResult, } from "./types.js";

package/dist/data-loader/index.js

@@ -0,0 +1 @@
+export { DataLoader } from "./loader.js";

package/dist/{types/data-loader → data-loader}/loader.d.ts

@@ -1,17 +1,17 @@
 import { McapRecording } from "../core/mcap/recording.js";
 import type { ReadOptions } from "../core/mcap/reader.js";
-import type { Capabilities, Discovery, ManifestRequest, ManifestResult, ReplayDataLoaderOptions, RequestOptions } from "./types.js";
+import type { Capabilities, Discovery, ManifestRequest, ManifestResult, DataLoaderOptions, RequestOptions } from "./types.js";
 /** Backend-specific discovery and manifests for the generic MCAP playback core. */
-export declare class ReplayDataLoader {
+export declare class DataLoader {
     private readonly baseUrl;
     private readonly headers;
-    constructor({ baseUrl, headers }: ReplayDataLoaderOptions);
+    constructor({ baseUrl, headers }: DataLoaderOptions);
     private request;
     /** List the service's supported canonical data types. */
     capabilities(options?: RequestOptions): Promise<Capabilities>;
     /** Discover a datasource's canonical schemas and actual wire encodings. */
     discover(datasource: string, options?: RequestOptions): Promise<Discovery>;
-    /** Resolve topic URLs for ordered spans; each span can succeed or fail independently. */
+    /** Resolve one MCAP URL per span, in request order; each span succeeds or fails independently. */
     manifest(request: ManifestRequest, options?: RequestOptions): Promise<readonly ManifestResult[]>;
     /** Open the single MCAP shared by all topics in one successful manifest result. */
     openSpan(result: ManifestResult, options?: ReadOptions): Promise<McapRecording>;

package/dist/data-loader/loader.js

@@ -0,0 +1,44 @@
+import { McapRecording } from "../core/mcap/recording.js";
+/** Backend-specific discovery and manifests for the generic MCAP playback core. */
+export class DataLoader {
+    baseUrl;
+    headers;
+    constructor({ baseUrl, headers }) {
+        this.baseUrl = new URL(`${String(baseUrl).replace(/\/+$/, "")}/`);
+        this.headers = new Headers(headers);
+    }
+    async request(path, options, body) {
+        const headers = new Headers(this.headers);
+        new Headers(options.headers).forEach((value, key) => headers.set(key, value));
+        if (body !== undefined)
+            headers.set("Content-Type", "application/json");
+        const response = await fetch(new URL(`v1/${path}`, this.baseUrl), {
+            method: body === undefined ? "GET" : "POST",
+            headers,
+            signal: options.signal,
+            body: body === undefined ? undefined : JSON.stringify(body),
+            cache: "no-store",
+        });
+        if (!response.ok)
+            throw new Error(`MDA request failed (${response.status}): ${await response.text()}`);
+        return response.json();
+    }
+    /** List the service's supported canonical data types. */
+    capabilities(options = {}) {
+        return this.request("capabilities", options);
+    }
+    /** Discover a datasource's canonical schemas and actual wire encodings. */
+    discover(datasource, options = {}) {
+        return this.request(`discover?${new URLSearchParams({ datasource })}`, options);
+    }
+    /** Resolve one MCAP URL per span, in request order; each span succeeds or fails independently. */
+    manifest(request, options = {}) {
+        return this.request("manifest", options, request);
+    }
+    /** Open the single MCAP shared by all topics in one successful manifest result. */
+    async openSpan(result, options = {}) {
+        if ("error" in result)
+            throw new Error(`${result.error.code}: ${result.error.message}`);
+        return McapRecording.open(result.manifest.url, options);
+    }
+}

package/dist/{types/data-loader → data-loader}/types.d.ts

@@ -2,7 +2,7 @@ import type { LoadOptions } from "../core/mcap/source.js";
 export interface RequestOptions extends LoadOptions {
     headers?: HeadersInit;
 }
-export interface ReplayDataLoaderOptions {
+export interface DataLoaderOptions {
     baseUrl: string | URL;
     headers?: HeadersInit;
 }
@@ -17,7 +17,7 @@ export interface Capabilities {
         status: "live";
     }>>;
 }
-export type ReplaySpan = {
+export type Span = {
     id: string;
 } & ({
     start: number;
@@ -29,7 +29,7 @@ export type ReplaySpan = {
 export interface ManifestRequest {
     datasource: string;
     topics: readonly string[];
-    spans: readonly ReplaySpan[];
+    spans: readonly Span[];
 }
 export interface Manifest {
     url: string;

package/dist/data-loader/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./core/index.js";
+export * from "./data-loader/index.js";

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@eventual-ai/mcap-viewer",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0-alpha.2",
   "description": "Browser playback of native H.264/H.265 video from streamed MCAP recordings.",
   "license": "MIT",
   "type": "module",
-  "types": "./dist/types/index.d.ts",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
-      "import": "./dist/mcap-viewer.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
     "./core": {
-      "types": "./dist/types/core/index.d.ts",
-      "import": "./dist/core.js"
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.js"
     },
     "./data-loader": {
-      "types": "./dist/types/data-loader/index.d.ts",
-      "import": "./dist/data-loader.js"
+      "types": "./dist/data-loader/index.d.ts",
+      "import": "./dist/data-loader/index.js"
     }
   },
   "files": [
@@ -30,22 +30,23 @@
   },
   "scripts": {
     "dev": "vite --host 127.0.0.1",
-    "build": "vite build && tsc",
-    "build:example": "vite build --mode example",
-    "fixtures": "replay_client_test_root=\"$PWD\"; cd \"${REPLAY_TEST_SERVICE_ROOT:-../services/replay-service}\" && uv run --locked pytest \"$replay_client_test_root/tests/server_fixture.py\" -q",
+    "build": "rm -rf dist && tsc",
+    "build:example": "vite build",
+    "fixtures": "mcap_viewer_test_root=\"$PWD\"; cd \"${MDA_TEST_SERVICE_ROOT:-../services/mda}\" && uv run --locked pytest \"$mcap_viewer_test_root/tests/server_fixture.py\" -q",
     "pretest": "npm run fixtures && npm run build && npm run typecheck && npm run build:example",
     "test": "node --import tsx --test tests/*.test.js",
-    "typecheck": "tsc --noEmit --emitDeclarationOnly false && tsc -p tests/tsconfig.json",
+    "typecheck": "tsc --noEmit && tsc -p tests/tsconfig.json",
     "prepublishOnly": "npm run build",
     "lint": "prettier --check src tests examples vite.config.js package.json tsconfig.json",
     "format": "prettier --write src tests examples vite.config.js package.json tsconfig.json"
   },
-  "devDependencies": {
-    "@foxglove/wasm-zstd": "^1.0.1",
+  "dependencies": {
     "@mcap/core": "^2.4.0",
-    "buffer": "^6.0.3",
-    "prettier": "^3.6.2",
     "protobufjs": "^8.8.1",
+    "zstddec": "^0.3.4"
+  },
+  "devDependencies": {
+    "prettier": "^3.6.2",
     "tsx": "^4.23.15",
     "typescript": "^5.9.3",
     "vite": "^7.3.7"