tassello 0.6.0 → 0.7.0

package/dist/server/rosbag.js

@@ -1,15 +1,26 @@
-// Rosbags (rosbag2), for the behavior tree inspectors' record and playback:
-// the messages of some of their topics, read from either storage (MCAP,
-// Jazzy's default, or SQLite, Humble's), serialized as recorded; and topics
-// recorded into a new one by ros2 bag record, the robot's own tool.
-import { spawn } from 'node:child_process';
-import { promises as fs } from 'node:fs';
+// Rosbags (rosbag2) as files: what the Rosbags widget lists of a folder's
+// bags (rosbags.ts), and the messages of some of a bag's topics, which the
+// behavior tree inspectors play back. Either storage is read (MCAP, Jazzy's
+// default, or SQLite, Humble's), compressed by rosbag2 or not (zstd, of each
+// file or of each message); messages come serialized as recorded. Recording
+// and playing them is ros2 bag's (rosbag_process.ts).
+import { createReadStream, createWriteStream, promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { pipeline } from 'node:stream/promises';
 import zlib from 'node:zlib';
-import { errorMessage, stripAnsi } from './util.js';
-const BAG_FILE = /\.(mcap|db3)$/i;
-function absolute(input, home) {
+import { parseMetadata } from './rosbag_format.js';
+import { errorMessage } from './util.js';
+// The files of a bag, compressed by rosbag2 (.zstd) or not
+const BAG_FILE = /\.(mcap|db3)(\.zstd)?$/i;
+const COMPRESSED = /\.zstd$/i;
+const METADATA = 'metadata.yaml';
+// SQLite bags without metadata are counted only up to this size: node:sqlite
+// blocks the server while it reads
+const SQLITE_SCAN_BYTES = 64 * 1024 * 1024;
+const natural = (a, b) => a.localeCompare(b, undefined, { numeric: true });
+// An absolute path from /… or ~/…
+export function bagPath(input, home = os.homedir()) {
     const trimmed = input.trim();
     const expanded = trimmed === '~' || trimmed.startsWith('~/') ? path.join(home, trimmed.slice(1)) : trimmed;
     if (!path.isAbsolute(expanded)) {
@@ -18,33 +29,63 @@ function absolute(input, home) {
     return path.resolve(expanded);
 }
 const nsToMs = (ns) => Number(ns / 1000n) / 1000;
-// The files of a bag: its folder's (split bags' in order), or one of them
-export async function bagFiles(input, home = os.homedir()) {
-    const location = absolute(input, home);
+async function readMetadata(folder) {
+    const text = await fs.readFile(path.join(folder, METADATA), 'utf8').catch(() => null);
+    return text === null ? null : parseMetadata(text);
+}
+// A bag: its folder (its files those its metadata names, else those it has,
+// split bags' in order), or one of its files
+export async function openBag(input, home = os.homedir()) {
+    const location = bagPath(input, home);
     const stat = await fs.stat(location).catch(() => null);
     if (!stat) {
         throw new Error(`No rosbag at ${location}`);
     }
-    if (stat.isDirectory()) {
-        const names = await fs.readdir(location);
-        const files = names.filter((name) => BAG_FILE.test(name)).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
-        if (files.length === 0) {
-            const compressed = names.some((name) => /\.(mcap|db3)\.\w+$/i.test(name));
-            throw new Error(`No rosbag in ${location}: no .mcap nor .db3 file${compressed ? ' (compressed files are not read)' : ''}`);
+    if (!stat.isDirectory()) {
+        if (!BAG_FILE.test(location)) {
+            throw new Error(`Not a rosbag: ${location} (a bag’s folder, an .mcap or .db3 file)`);
         }
-        return files.map((name) => path.join(location, name));
+        return { files: [location], messageCompression: '' };
     }
-    if (!BAG_FILE.test(location)) {
-        throw new Error(`Not a rosbag: ${location} (a bag's folder, an .mcap or .db3 file)`);
+    let metadata = null;
+    try {
+        metadata = await readMetadata(location);
     }
-    return [location];
+    catch {
+        // Its files are read without it
+    }
+    const names = await fs.readdir(location);
+    let files = metadata?.files.filter((name) => names.includes(name)) ?? [];
+    if (files.length === 0) {
+        const found = names.filter((name) => BAG_FILE.test(name)).sort(natural);
+        // A compressed bag played leaves its files uncompressed beside them
+        const plain = found.filter((name) => !COMPRESSED.test(name));
+        files = plain.length ? plain : found;
+    }
+    if (files.length === 0) {
+        throw new Error(`No rosbag in ${location}: no .mcap nor .db3 file`);
+    }
+    return {
+        files: files.map((name) => path.join(location, name)),
+        messageCompression: metadata?.compression?.mode === 'message' ? metadata.compression.format : '',
+    };
+}
+// The files of a bag: see openBag
+export async function bagFiles(input, home = os.homedir()) {
+    return (await openBag(input, home)).files;
 }
 // The messages of the topics accepted, by topic, in the order recorded
-export async function readBag(files, accept) {
+export async function readBag(bag, accept) {
+    const { files, messageCompression } = Array.isArray(bag) ? { files: bag, messageCompression: '' } : bag;
     const topics = new Map();
     for (const file of files) {
-        const read = /\.mcap$/i.test(file) ? await readMcap(file, accept) : await readSqlite(file, accept);
+        const read = await readFile(file, accept);
         for (const [name, found] of read) {
+            if (messageCompression) {
+                for (const message of found.messages) {
+                    message.data = decompress(messageCompression, Buffer.from(message.data));
+                }
+            }
             const known = topics.get(name);
             if (known) {
                 known.messages = known.messages.concat(found.messages);
@@ -59,6 +100,235 @@ export async function readBag(files, accept) {
     }
     return topics;
 }
+function readFile(file, accept) {
+    if (COMPRESSED.test(file)) {
+        return withDecompressed(file, (plain) => readFile(plain, accept));
+    }
+    return /\.mcap$/i.test(file) ? readMcap(file, accept) : readSqlite(file, accept);
+}
+// A file rosbag2 compressed whole, decompressed into a folder of its own for
+// the time of use
+async function withDecompressed(file, use) {
+    if (typeof zlib.createZstdDecompress !== 'function') {
+        throw new Error('Reading zstd compressed rosbags needs Node.js 22.15 or newer');
+    }
+    const folder = await fs.mkdtemp(path.join(os.tmpdir(), 'tassello-bag-'));
+    try {
+        const plain = path.join(folder, path.basename(file).replace(COMPRESSED, ''));
+        await pipeline(createReadStream(file), zlib.createZstdDecompress(), createWriteStream(plain)).catch((e) => {
+            throw new Error(`Cannot decompress ${file}: ${errorMessage(e)}`);
+        });
+        return await use(plain);
+    }
+    finally {
+        await fs.rm(folder, { recursive: true, force: true });
+    }
+}
+async function fileSummary(file, size) {
+    if (COMPRESSED.test(file)) {
+        return null;
+    }
+    return /\.mcap$/i.test(file) ? mcapSummary(file) : sqliteSummary(file, size);
+}
+// A bag's folder, or one of its files, as listed: its metadata, else its
+// files' summaries. Throws if it is not a bag.
+export async function bagInfo(input, home = os.homedir()) {
+    const location = bagPath(input, home);
+    const stat = await fs.stat(location).catch(() => null);
+    if (!stat) {
+        throw new Error(`No rosbag at ${location}`);
+    }
+    const info = {
+        path: location,
+        name: path.basename(location),
+        size: 0,
+        modified: stat.mtimeMs,
+        storage: '',
+        start: null,
+        duration: null,
+        messages: null,
+        topics: [],
+        files: [],
+        compression: null,
+        recording: false,
+        problem: null,
+    };
+    let metadata = null;
+    let names;
+    if (stat.isDirectory()) {
+        try {
+            metadata = await readMetadata(location);
+        }
+        catch (e) {
+            info.problem = `Its ${METADATA} cannot be read: ${errorMessage(e)}`;
+        }
+        const entries = await fs.readdir(location);
+        names = metadata?.files.filter((name) => entries.includes(name)) ?? [];
+        if (names.length === 0) {
+            names = entries.filter((name) => BAG_FILE.test(name)).sort(natural);
+        }
+        if (!metadata && names.length === 0) {
+            throw new Error(`No rosbag in ${location}`);
+        }
+    }
+    else if (BAG_FILE.test(location)) {
+        names = [path.basename(location)];
+    }
+    else {
+        throw new Error(`Not a rosbag: ${location}`);
+    }
+    const folder = stat.isDirectory() ? location : path.dirname(location);
+    for (const name of names) {
+        const file = await fs.stat(path.join(folder, name)).catch(() => null);
+        if (file) {
+            info.files.push({ name, size: file.size });
+            info.size += file.size;
+            info.modified = Math.max(info.modified, file.mtimeMs);
+        }
+    }
+    if (metadata) {
+        Object.assign(info, {
+            storage: metadata.storage,
+            start: metadata.start,
+            duration: metadata.duration,
+            messages: metadata.messages,
+            topics: metadata.topics,
+            compression: metadata.compression,
+        });
+        if (info.files.length < names.length) {
+            info.problem = `${names.length - info.files.length} of its files missing`;
+        }
+        return info;
+    }
+    // Without metadata: what its files say of themselves
+    const topics = new Map();
+    let start = Infinity;
+    let end = -Infinity;
+    let known = true;
+    for (const { name, size } of info.files) {
+        let summary = null;
+        try {
+            summary = await fileSummary(path.join(folder, name), size);
+        }
+        catch {
+            // As if it said nothing
+        }
+        if (!summary) {
+            known = false;
+            continue;
+        }
+        info.storage ||= summary.storage;
+        for (const topic of summary.topics) {
+            const seen = topics.get(topic.name);
+            if (!seen) {
+                topics.set(topic.name, { ...topic });
+            }
+            else if (seen.count !== null) {
+                seen.count = topic.count === null ? null : seen.count + topic.count;
+            }
+        }
+        if (summary.start === null || summary.end === null) {
+            known = false;
+        }
+        else {
+            start = Math.min(start, summary.start);
+            end = Math.max(end, summary.end);
+        }
+    }
+    info.storage ||= /\.mcap/i.test(names[0] ?? '') ? 'mcap' : 'sqlite3';
+    info.topics = [...topics.values()].sort((a, b) => a.name.localeCompare(b.name));
+    if (known && Number.isFinite(start)) {
+        info.start = start;
+        info.duration = end - start;
+        info.messages = info.topics.every((topic) => topic.count !== null)
+            ? info.topics.reduce((sum, topic) => sum + (topic.count ?? 0), 0)
+            : null;
+    }
+    if (stat.isDirectory() && !info.problem) {
+        info.problem = `No ${METADATA}: being recorded, or its recording did not end (ros2 bag reindex makes it)`;
+    }
+    return info;
+}
+// The version of a bag as files: its files' names, sizes and times
+async function bagVersion(location, directory) {
+    const names = directory ? await fs.readdir(location) : [''];
+    const parts = await Promise.all(names.map(async (name) => {
+        const stat = await fs.stat(path.join(location, name)).catch(() => null);
+        return stat ? `${name}:${stat.size}:${stat.mtimeMs}` : name;
+    }));
+    return parts.sort().join('|');
+}
+// The bags of a folder (its folders that are bags, and its lone bag files),
+// the newest first. A folder not there yet has none. Bags read before are
+// read again only if their files changed.
+export async function listBags(folder, cache = new Map(), home = os.homedir()) {
+    const location = bagPath(folder, home);
+    const entries = await fs.readdir(location, { withFileTypes: true }).catch((e) => {
+        if (e.code === 'ENOENT') {
+            return [];
+        }
+        throw new Error(`Cannot read ${location}: ${e.code ?? errorMessage(e)}`);
+    });
+    const bags = [];
+    const seen = new Set();
+    for (const entry of entries) {
+        if (entry.name.startsWith('.')) {
+            continue;
+        }
+        const full = path.join(location, entry.name);
+        let directory = entry.isDirectory();
+        if (entry.isSymbolicLink()) {
+            directory = (await fs.stat(full).catch(() => null))?.isDirectory() ?? false;
+        }
+        if (directory) {
+            const inside = await fs.readdir(full).catch(() => []);
+            if (!inside.some((name) => name === METADATA || BAG_FILE.test(name))) {
+                continue;
+            }
+        }
+        else if (!/\.(mcap|db3)$/i.test(entry.name)) {
+            continue;
+        }
+        seen.add(full);
+        const version = await bagVersion(full, directory);
+        const cached = cache.get(full);
+        if (cached?.version === version) {
+            bags.push(cached.info);
+            continue;
+        }
+        let info;
+        try {
+            info = await bagInfo(full, home);
+        }
+        catch {
+            // Gone while read, or not a bag after all
+            continue;
+        }
+        cache.set(full, { version, info });
+        bags.push(info);
+    }
+    for (const key of cache.keys()) {
+        if (path.dirname(key) === location && !seen.has(key)) {
+            cache.delete(key);
+        }
+    }
+    return bags.sort((a, b) => (b.start ?? b.modified) - (a.start ?? a.modified));
+}
+// The folder a recording makes: a new one, absolute or ~/…, its parent made
+export async function newBagFolder(input, home = os.homedir()) {
+    const folder = bagPath(input.trim().replace(/(.)\/+$/, '$1'), home);
+    if (await fs.stat(folder).catch(() => null)) {
+        throw new Error(`${folder} exists already: a recording makes a new folder`);
+    }
+    await fs.mkdir(path.dirname(folder), { recursive: true });
+    return folder;
+}
+// Of a folder's files, bytes
+export async function folderSize(folder) {
+    const names = await fs.readdir(folder).catch(() => []);
+    const sizes = await Promise.all(names.map((name) => fs.stat(path.join(folder, name)).then((s) => (s.isFile() ? s.size : 0), () => 0)));
+    return sizes.reduce((sum, size) => sum + size, 0);
+}
 // ── MCAP ─────────────────────────────────────────────────────────────────────
 // Records: opcode (u8), length (u64), content; little endian, strings and
 // maps prefixed with their u32 byte length (https://mcap.dev/spec)
@@ -69,6 +339,7 @@ const CHANNEL = 0x04;
 const MESSAGE = 0x05;
 const CHUNK = 0x06;
 const CHUNK_INDEX = 0x08;
+const STATISTICS = 0x0b;
 const DATA_END = 0x0f;
 // Opcode, length, summary start, summary offset start, summary CRC
 const FOOTER_BYTES = 1 + 8 + 8 + 8 + 4;
@@ -113,32 +384,32 @@ class Cursor {
         return this.bytes(this.u32()).toString('utf8');
     }
 }
+// MCAP's chunks, and rosbag2's messages
 function decompress(compression, data) {
     if (!compression) {
         return data;
     }
     if (compression === 'zstd') {
         if (typeof zlib.zstdDecompressSync !== 'function') {
-            throw new Error('Reading zstd compressed MCAP needs Node.js 22.15 or newer');
+            throw new Error('Reading zstd compressed rosbags needs Node.js 22.15 or newer');
         }
         return zlib.zstdDecompressSync(data);
     }
-    throw new Error(`MCAP compressed with ${compression} is not read: record with zstd, or without compression`);
+    throw new Error(`Rosbags compressed with ${compression} are not read: record with zstd, or without compression`);
 }
-// What the records of a file say: its schemas and channels, and the messages
-// of those accepted
+// What the records of a file say: its schemas and channels, its statistics,
+// and the messages of the channels accepted
 class McapRecords {
     topics = new Map();
+    // Every channel, and those whose messages are read
     channels = new Map();
+    accepted = new Set();
+    statistics = null;
     schemas = new Map();
     accept;
     constructor(accept) {
         this.accept = accept;
     }
-    // The channels whose messages are read
-    wanted() {
-        return new Set([...this.channels].flatMap(([id, topic]) => (topic ? [id] : [])));
-    }
     record(opcode, content) {
         const cursor = new Cursor(content);
         switch (opcode) {
@@ -150,12 +421,16 @@ class McapRecords {
                 const schema = cursor.u16();
                 const topic = { name: cursor.string(), type: this.schemas.get(schema) ?? '' };
                 if (!this.channels.has(id)) {
-                    this.channels.set(id, this.accept(topic) ? topic : null);
+                    this.channels.set(id, topic);
+                    if (this.accept(topic)) {
+                        this.accepted.add(id);
+                    }
                 }
                 break;
             }
             case MESSAGE: {
-                const topic = this.channels.get(cursor.u16());
+                const id = cursor.u16();
+                const topic = this.accepted.has(id) ? this.channels.get(id) : undefined;
                 if (!topic) {
                     break;
                 }
@@ -179,6 +454,20 @@ class McapRecords {
                 this.records(decompress(compression, cursor.bytes(cursor.size())));
                 break;
             }
+            case STATISTICS: {
+                cursor.u64();
+                cursor.u16();
+                cursor.offset += 4 * 4;
+                const start = nsToMs(cursor.u64());
+                const end = nsToMs(cursor.u64());
+                const map = new Cursor(cursor.bytes(cursor.u32()));
+                const counts = new Map();
+                while (map.offset < map.data.length) {
+                    counts.set(map.u16(), Number(map.u64()));
+                }
+                this.statistics = { start, end, counts };
+                break;
+            }
         }
     }
     // A sequence of records, e.g. a chunk's
@@ -190,7 +479,8 @@ class McapRecords {
         }
     }
 }
-async function readMcap(file, accept) {
+// Opens an MCAP file for use: throws if it is not one
+async function withMcap(file, use) {
     const handle = await fs.open(file, 'r').catch((e) => {
         throw new Error(`Cannot read ${file}: ${e.code ?? errorMessage(e)}`);
     });
@@ -205,20 +495,41 @@ async function readMcap(file, accept) {
         if (!MCAP_MAGIC.every((byte, i) => head[i] === byte)) {
             throw new Error(`${file} is not an MCAP file`);
         }
-        const records = new McapRecords(accept);
-        if (!(await readIndexed(records, read, size))) {
-            await readSequentially(records, read, size);
-        }
-        return records.topics;
+        return await use(read, size);
     }
     finally {
         await handle.close();
     }
 }
-// From the summary at the end of the file: the channels, and where the
-// chunks with messages of those accepted are, which alone are read. false if
-// the file has no summary (unfinished, or written without chunks).
-async function readIndexed(records, read, size) {
+async function readMcap(file, accept) {
+    return withMcap(file, async (read, size) => {
+        const records = new McapRecords(accept);
+        if (!(await readIndexed(records, read, size, true))) {
+            await readSequentially(records, read, size);
+        }
+        return records.topics;
+    });
+}
+// Its channels and statistics, from its summary
+async function mcapSummary(file) {
+    return withMcap(file, async (read, size) => {
+        const records = new McapRecords(() => false);
+        await readIndexed(records, read, size, false);
+        const { statistics } = records;
+        if (records.channels.size === 0 && !statistics) {
+            return null;
+        }
+        const topics = [...records.channels].map(([id, topic]) => ({ ...topic, count: statistics?.counts.get(id) ?? (statistics ? 0 : null) }));
+        // Statistics of a file without messages say 0 for both
+        const timed = statistics && statistics.end >= statistics.start && statistics.end > 0;
+        return { storage: 'mcap', topics, start: timed ? statistics.start : null, end: timed ? statistics.end : null };
+    });
+}
+// From the summary at the end of the file: the channels, the statistics, and
+// (chunks) where the chunks with messages of those accepted are, which alone
+// are read. false if the file has no summary (unfinished, or written without
+// chunks).
+async function readIndexed(records, read, size, chunks) {
     const footerAt = size - 8 - FOOTER_BYTES;
     if (footerAt < 8) {
         return false;
@@ -232,7 +543,7 @@ async function readIndexed(records, read, size) {
     if (summaryAt === 0 || summaryAt >= footerAt) {
         return false;
     }
-    const chunks = [];
+    const indexes = [];
     const summary = new Cursor(await read(summaryAt, footerAt - summaryAt));
     while (summary.offset + 9 <= summary.data.length) {
         const opcode = summary.u8();
@@ -252,14 +563,16 @@ async function readIndexed(records, read, size) {
             channels.push(map.u16());
             map.u64();
         }
-        chunks.push({ at, length, start, channels });
+        indexes.push({ at, length, start, channels });
+    }
+    if (!chunks) {
+        return true;
     }
-    if (chunks.length === 0) {
+    if (indexes.length === 0) {
         return false;
     }
-    const wanted = records.wanted();
-    chunks.sort((a, b) => (a.start < b.start ? -1 : a.start > b.start ? 1 : 0));
-    for (const chunk of chunks.filter((c) => c.channels.some((id) => wanted.has(id)))) {
+    indexes.sort((a, b) => (a.start < b.start ? -1 : a.start > b.start ? 1 : 0));
+    for (const chunk of indexes.filter((c) => c.channels.some((id) => records.accepted.has(id)))) {
         const record = new Cursor(await read(chunk.at, chunk.length));
         const opcode = record.u8();
         records.record(opcode, record.bytes(record.size()));
@@ -288,7 +601,7 @@ async function readSequentially(records, read, size) {
     }
 }
 // ── SQLite ───────────────────────────────────────────────────────────────────
-async function readSqlite(file, accept) {
+async function withSqlite(file, use) {
     let sqlite;
     try {
         sqlite = await import('node:sqlite');
@@ -304,6 +617,17 @@ async function readSqlite(file, accept) {
         throw new Error(`Cannot read ${file}: ${errorMessage(e)}`);
     }
     try {
+        return use(db);
+    }
+    catch (e) {
+        throw new Error(`Cannot read ${file}: ${errorMessage(e)}`);
+    }
+    finally {
+        db.close();
+    }
+}
+async function readSqlite(file, accept) {
+    return withSqlite(file, (db) => {
         const topics = new Map();
         const rows = db.prepare('SELECT id, name, type FROM topics').all();
         const select = db.prepare('SELECT timestamp, data FROM messages WHERE topic_id = ? ORDER BY timestamp');
@@ -320,99 +644,27 @@ async function readSqlite(file, accept) {
             }
         }
         return topics;
-    }
-    catch (e) {
-        throw new Error(`Cannot read ${file}: ${errorMessage(e)}`);
-    }
-    finally {
-        db.close();
-    }
-}
-// ── Recording ────────────────────────────────────────────────────────────────
-// Waited for ros2 bag record to say it records; quiet, it is taken as doing so
-const START_TIMEOUT_MS = 8000;
-// Then it is killed: the bag may lack its metadata
-const STOP_TIMEOUT_MS = 10_000;
-const READY = /Subscribed to topic|Listening for topics|Recording\.\.\./;
-const OUTPUT_LIMIT = 4000;
-// The folder a recording makes: a new one, absolute or ~/…, its parent made
-export async function newBagFolder(input, home = os.homedir()) {
-    const folder = absolute(input.trim().replace(/(.)\/+$/, '$1'), home);
-    if (await fs.stat(folder).catch(() => null)) {
-        throw new Error(`${folder} exists already: a recording makes a new folder`);
-    }
-    await fs.mkdir(path.dirname(folder), { recursive: true });
-    return folder;
+    });
 }
-// ros2 bag record of topics into a new folder, until stopped
-export class BagRecorder {
-    folder;
-    // Called if it stops by itself, with why
-    onExit = null;
-    child;
-    output = '';
-    stopping = false;
-    constructor(child, folder) {
-        this.child = child;
-        this.folder = folder;
-    }
-    // Resolves once it records, rejects with why it could not
-    static start(folder, topics) {
-        return new Promise((resolve, reject) => {
-            const child = spawn('ros2', ['bag', 'record', '-o', folder, ...topics], {
-                cwd: os.homedir(),
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-            const recorder = new BagRecorder(child, folder);
-            let settled = false;
-            const ready = () => {
-                if (!settled) {
-                    settled = true;
-                    clearTimeout(timer);
-                    resolve(recorder);
-                }
-            };
-            const timer = setTimeout(ready, START_TIMEOUT_MS);
-            const onOutput = (chunk) => {
-                recorder.output = (recorder.output + stripAnsi(chunk.toString())).slice(-OUTPUT_LIMIT);
-                if (READY.test(recorder.output)) {
-                    ready();
-                }
-            };
-            child.stdout?.on('data', onOutput);
-            child.stderr?.on('data', onOutput);
-            child.on('error', (e) => {
-                recorder.output = e.code === 'ENOENT' ? 'ros2 not found: is ROS sourced?' : errorMessage(e);
-                if (!settled) {
-                    settled = true;
-                    clearTimeout(timer);
-                    reject(new Error(recorder.output));
-                }
-            });
-            child.on('close', (code, signal) => {
-                clearTimeout(timer);
-                const lines = recorder.output.trim().split('\n').slice(-2).join(' ').trim();
-                const reason = lines || `ros2 bag record exited (${signal ?? code})`;
-                if (!settled) {
-                    settled = true;
-                    reject(new Error(reason));
-                }
-                else if (!recorder.stopping) {
-                    recorder.onExit?.(reason);
-                }
-            });
-        });
-    }
-    // As Ctrl+C does, which completes the bag
-    async stop() {
-        this.stopping = true;
-        if (this.child.exitCode !== null || this.child.signalCode !== null) {
-            return;
+// Its topics; their counts and its time span if small enough to count
+async function sqliteSummary(file, size) {
+    return withSqlite(file, (db) => {
+        const rows = db.prepare('SELECT id, name, type FROM topics').all();
+        if (size > SQLITE_SCAN_BYTES) {
+            return { storage: 'sqlite3', topics: rows.map((row) => ({ name: row.name, type: row.type, count: null })), start: null, end: null };
         }
-        const closed = new Promise((resolve) => this.child.once('close', resolve));
-        this.child.kill('SIGINT');
-        const timer = setTimeout(() => this.child.kill('SIGKILL'), STOP_TIMEOUT_MS);
-        await closed;
-        clearTimeout(timer);
-    }
+        const select = db.prepare('SELECT topic_id, COUNT(*) AS count, MIN(timestamp) AS first, MAX(timestamp) AS last FROM messages GROUP BY topic_id');
+        select.setReadBigInts(true);
+        const counts = new Map();
+        for (const row of select.all()) {
+            counts.set(Number(row.topic_id), row);
+        }
+        const spans = [...counts.values()];
+        return {
+            storage: 'sqlite3',
+            topics: rows.map((row) => ({ name: row.name, type: row.type, count: Number(counts.get(row.id)?.count ?? 0n) })),
+            start: spans.length ? Math.min(...spans.map((s) => nsToMs(s.first))) : null,
+            end: spans.length ? Math.max(...spans.map((s) => nsToMs(s.last))) : null,
+        };
+    });
 }