rewound 0.2.0

package/dist/db.js

@@ -0,0 +1,441 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import Database from "better-sqlite3";
+import { estimateCostUsd } from "./pricing.js";
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY, source TEXT NOT NULL, project_dir TEXT NOT NULL,
+  file_path TEXT NOT NULL, title TEXT, git_branch TEXT,
+  started_at TEXT, ended_at TEXT, message_count INTEGER DEFAULT 0,
+  models TEXT,               -- JSON array
+  input_tokens INTEGER DEFAULT 0, output_tokens INTEGER DEFAULT 0,
+  cache_read_tokens INTEGER DEFAULT 0, cache_write_tokens INTEGER DEFAULT 0,
+  est_cost_usd REAL DEFAULT 0, parse_errors INTEGER DEFAULT 0,
+  archived INTEGER DEFAULT 0  -- 1 once source file is gone (archive mode)
+);
+CREATE TABLE IF NOT EXISTS files (
+  path TEXT PRIMARY KEY, session_id TEXT NOT NULL,
+  size INTEGER NOT NULL, mtime_ms INTEGER NOT NULL, byte_offset INTEGER NOT NULL
+);
+CREATE TABLE IF NOT EXISTS messages (
+  id INTEGER PRIMARY KEY, session_id TEXT NOT NULL, uuid TEXT,
+  role TEXT NOT NULL, ts TEXT, text TEXT NOT NULL, tools TEXT,
+  model TEXT, is_sidechain INTEGER DEFAULT 0,
+  tool_text TEXT NOT NULL DEFAULT ''  -- tool_result output, ranked below prose (see bm25 weights)
+);
+CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+  text, tool_text, content='messages', content_rowid='id', tokenize='porter unicode61'
+);
+CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN
+  INSERT INTO messages_fts(rowid, text, tool_text) VALUES (new.id, new.text, new.tool_text);
+END;
+CREATE TRIGGER IF NOT EXISTS messages_ad AFTER DELETE ON messages BEGIN
+  INSERT INTO messages_fts(messages_fts, rowid, text, tool_text) VALUES('delete', old.id, old.text, old.tool_text);
+END;
+CREATE TRIGGER IF NOT EXISTS messages_au AFTER UPDATE ON messages BEGIN
+  INSERT INTO messages_fts(messages_fts, rowid, text, tool_text) VALUES('delete', old.id, old.text, old.tool_text);
+  INSERT INTO messages_fts(rowid, text, tool_text) VALUES (new.id, new.text, new.tool_text);
+END;
+`;
+export const CURRENT_SCHEMA_VERSION = 2;
+// bm25 column weights: a match in prose (typed user text, assistant text) is
+// worth 3x a match in tool output. Tool dumps stay searchable — error strings
+// often exist ONLY there — they just stop outranking a human sentence.
+export const PROSE_BM25_WEIGHT = 3.0;
+export const TOOL_BM25_WEIGHT = 1.0;
+// v1 (0.1.0) → v2: messages gains tool_text; FTS becomes two weighted columns.
+// Migrates IN PLACE from the content table — never by reparsing source files,
+// because archived sessions' transcripts may already be deleted. Legacy rows
+// keep their combined text in the prose column (they rank no worse than
+// before); newly indexed messages get the proper split.
+function migrateToV2(db) {
+    const migrate = db.transaction(() => {
+        db.exec(`
+      ALTER TABLE messages ADD COLUMN tool_text TEXT NOT NULL DEFAULT '';
+      DROP TRIGGER IF EXISTS messages_ai;
+      DROP TRIGGER IF EXISTS messages_ad;
+      DROP TRIGGER IF EXISTS messages_au;
+      DROP TABLE IF EXISTS messages_fts;
+    `);
+        db.exec(SCHEMA_SQL);
+        db.exec(`INSERT INTO messages_fts(messages_fts) VALUES('rebuild');`);
+        db.pragma(`user_version = ${CURRENT_SCHEMA_VERSION}`);
+    });
+    migrate();
+}
+// Resolution order: --db flag > REWOUND_DB > AGENTGREP_DB (pre-rename compat) >
+// existing new-location DB > existing pre-rename DB > fresh new-location default.
+// The legacy fallbacks exist because rewound shipped its first releases as
+// "agentgrep"; a rename must never orphan an existing index.
+export function resolveDbPath(cliFlag, opts = {}) {
+    if (cliFlag)
+        return cliFlag;
+    const env = opts.env ?? process.env;
+    if (env.REWOUND_DB)
+        return env.REWOUND_DB;
+    if (env.AGENTGREP_DB)
+        return env.AGENTGREP_DB;
+    const home = opts.home ?? os.homedir();
+    const newPath = path.join(home, ".rewound", "rewound.db");
+    if (fs.existsSync(newPath))
+        return newPath;
+    const legacyPath = path.join(home, ".agentgrep", "agentgrep.db");
+    if (fs.existsSync(legacyPath))
+        return legacyPath;
+    return newPath;
+}
+export function openDb(dbPath) {
+    const dir = path.dirname(dbPath);
+    if (dir && dir !== ".")
+        fs.mkdirSync(dir, { recursive: true });
+    const db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    const hasMessages = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='messages'")
+        .get();
+    const version = db.pragma("user_version", { simple: true });
+    if (hasMessages && version < 2) {
+        migrateToV2(db); // legacy v1 DBs never stamped user_version, so they read 0
+    }
+    else {
+        db.exec(SCHEMA_SQL);
+        if (version < CURRENT_SCHEMA_VERSION)
+            db.pragma(`user_version = ${CURRENT_SCHEMA_VERSION}`);
+    }
+    return db;
+}
+export function getFileRecord(db, filePath) {
+    const row = db
+        .prepare("SELECT path, session_id, size, mtime_ms, byte_offset FROM files WHERE path = ?")
+        .get(filePath);
+    if (!row)
+        return undefined;
+    return {
+        path: row.path,
+        sessionId: row.session_id,
+        size: row.size,
+        mtimeMs: row.mtime_ms,
+        byteOffset: row.byte_offset,
+    };
+}
+export function upsertFileRecord(db, rec) {
+    db.prepare(`INSERT INTO files (path, session_id, size, mtime_ms, byte_offset)
+     VALUES (@path, @sessionId, @size, @mtimeMs, @byteOffset)
+     ON CONFLICT(path) DO UPDATE SET
+       session_id = excluded.session_id,
+       size = excluded.size,
+       mtime_ms = excluded.mtime_ms,
+       byte_offset = excluded.byte_offset`).run(rec);
+}
+export function listTrackedFiles(db) {
+    const rows = db.prepare("SELECT path, session_id as sessionId FROM files").all();
+    return rows;
+}
+function rowToSession(row) {
+    return {
+        id: row.id,
+        source: row.source,
+        projectDir: row.project_dir,
+        filePath: row.file_path,
+        title: row.title ?? undefined,
+        gitBranch: row.git_branch ?? undefined,
+        startedAt: row.started_at ?? undefined,
+        endedAt: row.ended_at ?? undefined,
+        messageCount: row.message_count,
+        models: parseJsonStringArray(row.models),
+        inputTokens: row.input_tokens,
+        outputTokens: row.output_tokens,
+        cacheReadTokens: row.cache_read_tokens,
+        cacheWriteTokens: row.cache_write_tokens,
+        estCostUsd: row.est_cost_usd,
+        parseErrors: row.parse_errors,
+        archived: Boolean(row.archived),
+    };
+}
+export function getSession(db, id) {
+    const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+    return row ? rowToSession(row) : undefined;
+}
+export function getSessionByIdOrPrefix(db, idOrPrefix) {
+    const exact = getSession(db, idOrPrefix);
+    if (exact)
+        return exact;
+    const row = db.prepare("SELECT * FROM sessions WHERE id LIKE ? ORDER BY id LIMIT 1").get(`${idOrPrefix}%`);
+    return row ? rowToSession(row) : undefined;
+}
+export function markSessionArchived(db, id) {
+    db.prepare("UPDATE sessions SET archived = 1 WHERE id = ?").run(id);
+}
+export function deleteSessionMessages(db, id) {
+    db.prepare("DELETE FROM messages WHERE session_id = ?").run(id);
+}
+export function upsertSessionMessages(db, session, opts) {
+    const tx = db.transaction(() => {
+        if (opts.mode === "replace") {
+            deleteSessionMessages(db, session.id);
+        }
+        const insertMessage = db.prepare(`INSERT INTO messages (session_id, uuid, role, ts, text, tools, model, is_sidechain, tool_text)
+       VALUES (@sessionId, @uuid, @role, @ts, @text, @tools, @model, @isSidechain, @toolText)`);
+        for (const m of session.messages) {
+            insertMessage.run({
+                sessionId: session.id,
+                uuid: m.uuid,
+                role: m.role,
+                ts: m.ts,
+                text: m.text,
+                toolText: m.toolText ?? "",
+                tools: JSON.stringify(m.tools ?? []),
+                model: m.model ?? null,
+                isSidechain: m.isSidechain ? 1 : 0,
+            });
+        }
+        const existing = opts.mode === "append" ? getSession(db, session.id) : undefined;
+        // A fallback-derived projectDir (naive dash→slash dir-name decode) must never
+        // clobber a stored value: incremental append chunks with no cwd-bearing lines
+        // (e.g. session-end meta records) would otherwise permanently mangle hyphenated
+        // project names ("/home/dev/my-app" → "/home/dev/my/app"). cwd-derived always wins.
+        const projectDir = session.projectDirSource === "cwd" ? session.projectDir : existing?.projectDir ?? session.projectDir;
+        const modelsSeen = new Set(existing?.models ?? []);
+        let costDelta = 0;
+        for (const m of session.messages) {
+            if (m.model)
+                modelsSeen.add(m.model);
+            if (m.usage)
+                costDelta += estimateCostUsd(m.model, m.usage);
+        }
+        const usageSums = session.messages.reduce((acc, m) => {
+            if (m.usage) {
+                acc.input += m.usage.input;
+                acc.output += m.usage.output;
+                acc.cacheRead += m.usage.cacheRead;
+                acc.cacheWrite += m.usage.cacheWrite;
+            }
+            return acc;
+        }, { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 });
+        const messageCount = (existing?.messageCount ?? 0) + session.messages.length;
+        const inputTokens = (existing?.inputTokens ?? 0) + usageSums.input;
+        const outputTokens = (existing?.outputTokens ?? 0) + usageSums.output;
+        const cacheReadTokens = (existing?.cacheReadTokens ?? 0) + usageSums.cacheRead;
+        const cacheWriteTokens = (existing?.cacheWriteTokens ?? 0) + usageSums.cacheWrite;
+        const estCostUsd = (existing?.estCostUsd ?? 0) + costDelta;
+        const parseErrors = (existing?.parseErrors ?? 0) + session.parseErrors;
+        const title = session.title ?? existing?.title;
+        const gitBranch = session.gitBranch ?? existing?.gitBranch;
+        const startedAt = existing?.startedAt && session.startedAt
+            ? existing.startedAt < session.startedAt
+                ? existing.startedAt
+                : session.startedAt
+            : session.startedAt ?? existing?.startedAt;
+        const endedAt = existing?.endedAt && session.endedAt
+            ? existing.endedAt > session.endedAt
+                ? existing.endedAt
+                : session.endedAt
+            : session.endedAt ?? existing?.endedAt;
+        db.prepare(`INSERT INTO sessions (
+         id, source, project_dir, file_path, title, git_branch, started_at, ended_at,
+         message_count, models, input_tokens, output_tokens, cache_read_tokens,
+         cache_write_tokens, est_cost_usd, parse_errors, archived
+       ) VALUES (
+         @id, @source, @projectDir, @filePath, @title, @gitBranch, @startedAt, @endedAt,
+         @messageCount, @models, @inputTokens, @outputTokens, @cacheReadTokens,
+         @cacheWriteTokens, @estCostUsd, @parseErrors, 0
+       )
+       ON CONFLICT(id) DO UPDATE SET
+         project_dir = excluded.project_dir,
+         file_path = excluded.file_path,
+         title = excluded.title,
+         git_branch = excluded.git_branch,
+         started_at = excluded.started_at,
+         ended_at = excluded.ended_at,
+         message_count = excluded.message_count,
+         models = excluded.models,
+         input_tokens = excluded.input_tokens,
+         output_tokens = excluded.output_tokens,
+         cache_read_tokens = excluded.cache_read_tokens,
+         cache_write_tokens = excluded.cache_write_tokens,
+         est_cost_usd = excluded.est_cost_usd,
+         parse_errors = excluded.parse_errors,
+         archived = 0`).run({
+            id: session.id,
+            source: session.source,
+            projectDir,
+            filePath: session.filePath,
+            title: title ?? null,
+            gitBranch: gitBranch ?? null,
+            startedAt: startedAt ?? null,
+            endedAt: endedAt ?? null,
+            messageCount,
+            models: JSON.stringify(Array.from(modelsSeen)),
+            inputTokens,
+            outputTokens,
+            cacheReadTokens,
+            cacheWriteTokens,
+            estCostUsd,
+            parseErrors,
+        });
+    });
+    tx();
+}
+export function searchMessagesRaw(db, matchExpr, opts) {
+    const clauses = ["messages_fts MATCH @matchExpr"];
+    const params = {
+        matchExpr,
+        limit: opts.limit ?? 25,
+        offset: opts.offset ?? 0,
+    };
+    if (opts.project) {
+        clauses.push("s.project_dir LIKE @project");
+        params.project = `%${opts.project}%`;
+    }
+    if (opts.since) {
+        clauses.push("m.ts >= @since");
+        params.since = opts.since;
+    }
+    if (opts.role) {
+        clauses.push("m.role = @role");
+        params.role = opts.role;
+    }
+    if (!opts.sidechains) {
+        clauses.push("m.is_sidechain = 0");
+    }
+    // The 3rd/4th snippet() args below are literal \x01/\x02 bytes (invisible
+    // here), not empty strings — sentinels consumed by cli.ts's highlightSnippet
+    // and web/html.ts's highlightSnippetHtml to mark match boundaries.
+    // Default result shape is one row per session (its best-ranked hit) so the
+    // top of the list spans distinct moments instead of one chatty session;
+    // allMatches disassembles back to per-message rows. Both carry the session's
+    // total match count. snippet column -1 = auto-pick the best-matching column.
+    const sql = `
+    SELECT * FROM (
+      SELECT hits.*,
+             row_number() OVER (PARTITION BY sessionId ORDER BY rank) AS rn,
+             count(*)     OVER (PARTITION BY sessionId) AS matchesInSession
+      FROM (
+        SELECT m.session_id as sessionId, m.uuid as uuid, m.role as role, m.ts as ts,
+               m.text as text, m.model as model, m.is_sidechain as isSidechain,
+               s.project_dir as projectDir, s.title as title, s.est_cost_usd as estCostUsd,
+               snippet(messages_fts, -1, '
', '', '...', 12) as snippet,
+               bm25(messages_fts, ${PROSE_BM25_WEIGHT}, ${TOOL_BM25_WEIGHT}) as rank
+        FROM messages_fts
+        JOIN messages m ON m.id = messages_fts.rowid
+        JOIN sessions s ON s.id = m.session_id
+        WHERE ${clauses.join(" AND ")}
+      ) AS hits
+    )
+    ${opts.allMatches ? "" : "WHERE rn = 1"}
+    ORDER BY rank
+    LIMIT @limit OFFSET @offset
+  `;
+    const rows = db.prepare(sql).all(params);
+    return rows.map((r) => ({
+        sessionId: r.sessionId,
+        uuid: r.uuid,
+        role: r.role,
+        ts: r.ts,
+        text: r.text,
+        snippet: r.snippet,
+        model: r.model ?? undefined,
+        isSidechain: Boolean(r.isSidechain),
+        projectDir: r.projectDir,
+        title: r.title ?? undefined,
+        estCostUsd: r.estCostUsd,
+        matchesInSession: r.matchesInSession,
+    }));
+}
+export function listSessions(db, opts = {}) {
+    const clauses = [];
+    const params = { limit: opts.limit ?? 50 };
+    if (opts.project) {
+        clauses.push("project_dir LIKE @project");
+        params.project = `%${opts.project}%`;
+    }
+    const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = db
+        .prepare(`SELECT * FROM sessions ${where} ORDER BY started_at DESC LIMIT @limit`)
+        .all(params);
+    return rows.map(rowToSession);
+}
+// The messages.tools and sessions.models columns are written by us as JSON arrays, but
+// treat them as untrusted on read: a corrupted row (partial write, manual edit, future
+// schema drift) should degrade to an empty list instead of throwing mid-render in the
+// CLI/MCP/web surfaces.
+export function parseJsonStringArray(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.filter((t) => typeof t === "string") : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function hasAnyMessages(db) {
+    const row = db.prepare("SELECT EXISTS(SELECT 1 FROM messages) AS present").get();
+    return Boolean(row.present);
+}
+export function getMessagesForSession(db, sessionId, opts = {}) {
+    // SQLite treats a negative LIMIT as "no limit" — lets the default (no opts)
+    // case share one prepared statement with the paginated case.
+    const limit = opts.limit ?? -1;
+    const offset = opts.offset ?? 0;
+    return db
+        .prepare("SELECT * FROM messages WHERE session_id = ? ORDER BY ts ASC, id ASC LIMIT ? OFFSET ?")
+        .all(sessionId, limit, offset);
+}
+export function listProjects(db) {
+    const rows = db
+        .prepare("SELECT DISTINCT project_dir as projectDir FROM sessions ORDER BY project_dir ASC")
+        .all();
+    return rows.map((r) => r.projectDir);
+}
+export function listRecentProjects(db, limit) {
+    const rows = db
+        .prepare(`SELECT project_dir as projectDir
+       FROM sessions
+       GROUP BY project_dir
+       ORDER BY MAX(started_at) DESC
+       LIMIT ?`)
+        .all(limit);
+    return rows.map((r) => r.projectDir);
+}
+export function getDailyMessageCounts(db, sinceIso) {
+    const rows = db
+        .prepare(`SELECT substr(ts, 1, 10) as date, COUNT(*) as count
+       FROM messages
+       WHERE ts >= ?
+       GROUP BY date
+       ORDER BY date ASC`)
+        .all(sinceIso);
+    return rows;
+}
+// Timestamp of the newest indexed message — i.e. how far the index "covers".
+// Used to hint at staleness: a search can only miss recent work silently, so
+// zero-hit UX should say what the index has actually seen.
+export function getNewestMessageTs(db) {
+    const row = db.prepare(`SELECT MAX(ts) as maxTs FROM messages`).get();
+    return row?.maxTs ?? undefined;
+}
+export function getStats(db, topN = 15) {
+    const totals = db
+        .prepare("SELECT COUNT(*) as sessions, COALESCE(SUM(message_count),0) as messages, COALESCE(SUM(est_cost_usd),0) as cost FROM sessions")
+        .get();
+    const byProject = db
+        .prepare(`SELECT project_dir as projectDir, COUNT(*) as sessions,
+              COALESCE(SUM(message_count),0) as messages,
+              COALESCE(SUM(est_cost_usd),0) as estCostUsd
+       FROM sessions
+       GROUP BY project_dir
+       ORDER BY estCostUsd DESC
+       LIMIT ?`)
+        .all(topN);
+    return {
+        totalSessions: totals.sessions,
+        totalMessages: totals.messages,
+        totalCostUsd: totals.cost,
+        byProject,
+    };
+}

package/dist/indexer.js

@@ -0,0 +1,100 @@
+import fs from "node:fs";
+import { getFileRecord, upsertFileRecord, upsertSessionMessages, markSessionArchived, listTrackedFiles, getSession, } from "./db.js";
+// byteOffset/size must come from what adapter.parse() actually consumed
+// (session.bytesConsumed), never from an independent fs.stat. adapter.parse()
+// does its own fs.readFileSync internally; a stat taken by the caller — before
+// OR after that call — can disagree with what was actually read if the source
+// file grows concurrently (a real risk: these files are actively appended to
+// by live agent sessions). Using a stat instead of the parser's own count is
+// wrong in both directions: a pre-parse stat can under-count what parse() then
+// reads (duplicate messages next run), and a post-parse stat can over-count it
+// if the file grew after the read but before the stat (silently skipped bytes
+// — permanent data loss, the worse failure mode). bytesConsumed is derived
+// solely from the buffer parse() actually read, so there is no such race.
+//
+// mtimeMs is persisted (it's part of the locked schema) but change detection
+// below is deliberately size-only: these files are append-only JSONL, so size
+// is a strictly stronger signal than mtime for "did new records show up." We
+// reuse the pre-parse stat's mtime as a best-effort value; it's never used
+// for decisions.
+function recordFile(db, filePath, sessionId, bytesConsumed, mtimeMs) {
+    upsertFileRecord(db, {
+        path: filePath,
+        sessionId,
+        size: bytesConsumed,
+        mtimeMs,
+        byteOffset: bytesConsumed,
+    });
+}
+function indexOneFile(db, adapter, filePath) {
+    const stat = fs.statSync(filePath);
+    const existing = getFileRecord(db, filePath);
+    if (!existing) {
+        const session = adapter.parse(filePath, 0);
+        upsertSessionMessages(db, session, { mode: "replace" });
+        recordFile(db, filePath, session.id, session.bytesConsumed, stat.mtimeMs);
+        return { status: "new", messagesIndexed: session.messages.length, parseErrors: session.parseErrors };
+    }
+    const offsetValid = existing.byteOffset <= stat.size;
+    if (stat.size < existing.size || !offsetValid) {
+        // upsertSessionMessages in "replace" mode deletes existing messages and
+        // re-inserts inside a single transaction; no separate delete needed here.
+        const session = adapter.parse(filePath, 0);
+        upsertSessionMessages(db, session, { mode: "replace" });
+        recordFile(db, filePath, session.id, session.bytesConsumed, stat.mtimeMs);
+        return { status: "updated", messagesIndexed: session.messages.length, parseErrors: session.parseErrors };
+    }
+    if (stat.size > existing.size) {
+        const session = adapter.parse(filePath, existing.byteOffset);
+        upsertSessionMessages(db, session, { mode: "append" });
+        recordFile(db, filePath, existing.sessionId, session.bytesConsumed, stat.mtimeMs);
+        return { status: "updated", messagesIndexed: session.messages.length, parseErrors: session.parseErrors };
+    }
+    // Unchanged on disk. A session archived because its file briefly vanished
+    // un-archives here once the (byte-for-byte identical) file reappears.
+    const sessionRow = getSession(db, existing.sessionId);
+    if (sessionRow?.archived) {
+        upsertSessionMessages(db, {
+            id: sessionRow.id,
+            source: "claude-code",
+            projectDir: sessionRow.projectDir,
+            filePath,
+            parseErrors: 0,
+            messages: [],
+            bytesConsumed: 0,
+        }, { mode: "append" });
+    }
+    return { status: "unchanged", messagesIndexed: 0, parseErrors: 0 };
+}
+export function indexAll(db, adapter, roots) {
+    const start = Date.now();
+    const discovered = adapter.discover(roots);
+    const discoveredSet = new Set(discovered);
+    let filesNew = 0;
+    let filesUpdated = 0;
+    let messagesIndexed = 0;
+    let parseErrors = 0;
+    for (const filePath of discovered) {
+        const result = indexOneFile(db, adapter, filePath);
+        if (result.status === "new")
+            filesNew++;
+        else if (result.status === "updated")
+            filesUpdated++;
+        messagesIndexed += result.messagesIndexed;
+        parseErrors += result.parseErrors;
+    }
+    const tracked = listTrackedFiles(db);
+    for (const row of tracked) {
+        if (!discoveredSet.has(row.path) && !fs.existsSync(row.path)) {
+            markSessionArchived(db, row.sessionId);
+        }
+    }
+    return {
+        filesScanned: discovered.length,
+        filesNew,
+        filesUpdated,
+        messagesIndexed,
+        parseErrors,
+        elapsedMs: Date.now() - start,
+    };
+}