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

package/README.md

@@ -49,7 +49,9 @@ const recording = await loader.openSpan(result, { signal });
 ```
 
 Each manifest supplies one streamed MCAP URL. Payload requests omit control
-credentials. The loader applies the requested span bounds. `discover` maps topic
+credentials. Playback covers the requested span, which the MCAP records in its
+`mda` metadata, so `McapRecording.open` on a saved file starts at the same time
+(`bounds: null` keeps the keyframe preroll). `discover` maps topic
 names to canonical schemas and actual wire encodings:
 
 ```json

package/dist/core/mcap/reader.d.ts

@@ -3,6 +3,11 @@ import type { LoadOptions, McapStreamSource } from "./source.js";
 import { McapRecording } from "./recording.js";
 import type { TimeBounds } from "./types.js";
 export interface ReadOptions extends LoadOptions {
-    bounds?: TimeBounds;
+    /**
+     * Playback bounds. By default, the span MDA records in `mda` metadata
+     * (`start_ns`, exclusive `end_ns`), whose file starts at the preceding
+     * keyframe; `null` plays every message.
+     */
+    bounds?: TimeBounds | null;
 }
 export declare function readMcap(input: Blob | McapStreamSource, options?: ReadOptions): Promise<McapRecording>;

package/dist/core/mcap/reader.js

@@ -39,13 +39,30 @@ export async function readMcap(input, options = {}) {
     const byTopic = new Map();
     const messages = [];
     const metadata = new Map();
-    const recording = new McapRecording(metadata, channels, messages, byTopic, loading, options.bounds);
+    let recording = new McapRecording(metadata, channels, messages, byTopic, loading, options.bounds ?? undefined);
+    let opened = false;
     let resolveReady;
     let rejectReady;
     const ready = new Promise((resolve, reject) => {
         resolveReady = resolve;
         rejectReady = reject;
     });
+    const open = () => {
+        opened = true;
+        resolveReady(recording);
+    };
+    // MDA writes its metadata before any message, so bounds are set before `open`.
+    const applyMdaBounds = (record) => {
+        if (options.bounds !== undefined || opened)
+            return;
+        const start = record.get("start_ns");
+        const end = record.get("end_ns");
+        if (start !== undefined && end !== undefined)
+            recording = recording.withBounds({
+                start: BigInt(start),
+                end: BigInt(end) - 1n,
+            });
+    };
     async function consume() {
         let lastTime;
         for await (const bytes of source.stream({ signal })) {
@@ -58,8 +75,11 @@ export async function readMcap(input, options = {}) {
                 signal.throwIfAborted();
                 if (record.type === "Schema")
                     schemas.set(record.id, record);
-                else if (record.type === "Metadata")
+                else if (record.type === "Metadata") {
                     metadata.set(record.name, record.metadata);
+                    if (record.name === "mda")
+                        applyMdaBounds(record.metadata);
+                }
                 else if (record.type === "Channel") {
                     // The summary section repeats channels; keep the objects messages reference.
                     if (channels.has(record.id))
@@ -104,14 +124,14 @@ export async function readMcap(input, options = {}) {
             if (bufferedEnd !== undefined && bufferedEnd !== loading.bufferedEnd) {
                 loading.advance(bufferedEnd);
                 if (recording.bufferedEnd !== undefined)
-                    resolveReady(recording);
+                    open();
             }
         }
         signal.throwIfAborted();
         if (!reader.done())
             throw new Error("Incomplete MCAP recording");
         loading.finish();
-        resolveReady(recording);
+        open();
     }
     void consume().catch((error) => {
         loading.fail(error);

package/dist/data-loader/loader.js

@@ -39,14 +39,6 @@ export class DataLoader {
     async openSpan(result, options = {}) {
         if ("error" in result)
             throw new Error(`${result.error.code}: ${result.error.message}`);
-        const recording = await McapRecording.open(result.manifest.url, options);
-        if (options.bounds)
-            return recording;
-        const metadata = recording.metadata.get("mda");
-        const start = metadata?.get("start_ns");
-        const end = metadata?.get("end_ns");
-        return start !== undefined && end !== undefined
-            ? recording.withBounds({ start: BigInt(start), end: BigInt(end) - 1n })
-            : recording;
+        return McapRecording.open(result.manifest.url, options);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventual-ai/mcap-viewer",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.2",
   "description": "Browser playback of native H.264/H.265 video from streamed MCAP recordings.",
   "license": "MIT",
   "type": "module",