@ailoud/providers 1.0.0-dev.1

package/dist/provision/whisperInstall.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The whisper.cpp release ailoud installs. Pinned, never "latest": two people
+ * running the same `ailoud setup` a week apart must get the same binaries, and
+ * an upstream change must not be able to break installation for everyone at
+ * once. Bumping this is a reviewable commit.
+ */
+export declare const WHISPER_TAG = "b4938";
+/**
+ * The prebuilt tarball for this platform and CPU.
+ *
+ * Linux only. macOS installs through brew, which has a whisper-cpp formula;
+ * Linux has no apt package, so ailoud uses the project's own release assets.
+ * Both x64 and arm64 Ubuntu builds are published.
+ */
+export declare function whisperTarballUrl(platform: NodeJS.Platform, arch: string): string;
+export interface InstallWhisperOptions {
+    readonly platform: NodeJS.Platform;
+    readonly arch: string;
+    readonly dataDir: string;
+    /**
+     * Whether a real terminal is attached. The macOS route shells out to brew
+     * through `runInteractive`, which has no timeout by design (a password or
+     * a "install the Xcode command line tools?" prompt must be allowed to
+     * wait), so with nothing on stdin it would wait forever. False means
+     * report the command instead of running it -- refusing beats hanging a CI
+     * job until it times out.
+     */
+    readonly interactive: boolean;
+    readonly onProgress?: (received: number, total: number | null) => void;
+}
+export interface WhisperPaths {
+    readonly binary: string;
+    readonly vadBinary: string;
+}
+/**
+ * `paths` is null when whisper.cpp landed on PATH and ailoud therefore records
+ * nothing (the macOS/brew route). `skipped` carries the exact commands a
+ * human has to run, for the non-interactive case where ailoud refuses to spawn
+ * something that could block on a prompt.
+ */
+export type InstallWhisperResult = {
+    readonly kind: 'installed';
+    readonly paths: WhisperPaths | null;
+} | {
+    readonly kind: 'skipped';
+    readonly commands: readonly string[];
+};
+/**
+ * Installs whisper.cpp and reports where its binaries ended up.
+ *
+ * Reports `paths: null` on macOS: brew puts `whisper-cli` on PATH, and ailoud's
+ * existing config defaults already resolve it. Writing an absolute Cellar
+ * path into the config there would break on the next `brew upgrade`.
+ *
+ * On Linux it returns absolute paths, because the extracted tree lives
+ * somewhere only ailoud knows. The tree is kept intact: the binaries embed
+ * `$ORIGIN` and load `libwhisper.so` and `libggml*.so` from their own
+ * directory, so moving or symlinking a single binary out of it would break
+ * the loader.
+ */
+export declare function installWhisper(options: InstallWhisperOptions): Promise<InstallWhisperResult>;

package/dist/provision/whisperInstall.js

@@ -0,0 +1,89 @@
+import { mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { FailureError } from '@ailoud/core';
+import { run, runInteractive } from '../process/run.js';
+import { formatInstallCommand, whisperInstallCommands } from './packageManager.js';
+import { downloadFile } from './download.js';
+/**
+ * The whisper.cpp release ailoud installs. Pinned, never "latest": two people
+ * running the same `ailoud setup` a week apart must get the same binaries, and
+ * an upstream change must not be able to break installation for everyone at
+ * once. Bumping this is a reviewable commit.
+ */
+export const WHISPER_TAG = 'b4938';
+const RELEASES = 'https://github.com/ggml-org/whisper.cpp/releases/download';
+/**
+ * The prebuilt tarball for this platform and CPU.
+ *
+ * Linux only. macOS installs through brew, which has a whisper-cpp formula;
+ * Linux has no apt package, so ailoud uses the project's own release assets.
+ * Both x64 and arm64 Ubuntu builds are published.
+ */
+export function whisperTarballUrl(platform, arch) {
+    if (platform !== 'linux') {
+        throw new FailureError(`no prebuilt whisper.cpp tarball is published for ${platform}`);
+    }
+    if (arch !== 'x64' && arch !== 'arm64') {
+        // Name the way out, not just the obstacle: only x64 and arm64 Linux
+        // builds are published, so a user on anything else has no automated
+        // route at all and needs to know that building it themselves is the
+        // supported answer rather than a workaround.
+        throw new FailureError(`no prebuilt whisper.cpp tarball is published for ${arch}; build whisper.cpp from ` +
+            'source and set "stt.whisperCpp.binary" and "stt.whisperCpp.vadBinary" to the ' +
+            'resulting binaries');
+    }
+    return `${RELEASES}/${WHISPER_TAG}/whisper-bin-ubuntu-${arch}.tar.gz`;
+}
+/**
+ * Installs whisper.cpp and reports where its binaries ended up.
+ *
+ * Reports `paths: null` on macOS: brew puts `whisper-cli` on PATH, and ailoud's
+ * existing config defaults already resolve it. Writing an absolute Cellar
+ * path into the config there would break on the next `brew upgrade`.
+ *
+ * On Linux it returns absolute paths, because the extracted tree lives
+ * somewhere only ailoud knows. The tree is kept intact: the binaries embed
+ * `$ORIGIN` and load `libwhisper.so` and `libggml*.so` from their own
+ * directory, so moving or symlinking a single binary out of it would break
+ * the loader.
+ */
+export async function installWhisper(options) {
+    const { platform, arch, dataDir } = options;
+    if (platform === 'darwin') {
+        const commands = whisperInstallCommands('brew');
+        if (!options.interactive) {
+            return { kind: 'skipped', commands: commands.map(formatInstallCommand) };
+        }
+        for (const command of commands) {
+            const code = await runInteractive(command.command, command.args);
+            if (code !== 0) {
+                throw new FailureError(`"${formatInstallCommand(command)}" exited with code ${code}`);
+            }
+        }
+        return { kind: 'installed', paths: null };
+    }
+    if (platform !== 'linux') {
+        throw new FailureError(`ailoud cannot install whisper.cpp on ${platform} automatically; see README.md for the ` +
+            'manual steps');
+    }
+    const url = whisperTarballUrl(platform, arch);
+    const root = join(dataDir, 'whisper', WHISPER_TAG);
+    const archive = join(dataDir, 'whisper', `whisper-${WHISPER_TAG}-${arch}.tar.gz`);
+    await mkdir(root, { recursive: true });
+    await downloadFile(url, archive, { onProgress: options.onProgress });
+    // --strip-components=1 drops the "whisper-bin-ubuntu-<arch>/" wrapper so the
+    // binaries and their shared libraries land directly in `root`, side by side,
+    // which is what $ORIGIN resolution needs.
+    const extract = await run('tar', ['-xzf', archive, '-C', root, '--strip-components=1']);
+    if (extract.code !== 0) {
+        throw new FailureError(`extracting ${archive} failed: ${extract.stderr.trim()}`);
+    }
+    await rm(archive, { force: true });
+    return {
+        kind: 'installed',
+        paths: {
+            binary: join(root, 'whisper-cli'),
+            vadBinary: join(root, 'whisper-vad-speech-segments'),
+        },
+    };
+}

package/dist/store/sqliteStore.d.ts

@@ -0,0 +1,64 @@
+import { DatabaseSync } from 'node:sqlite';
+import type { ManagedRecordingStore, Recording, RecordingListFilter, Segment, SpeakerName, SegmentHit, SegmentSearchFilter, Summary, Transcript } from '@ailoud/core';
+export declare class SqliteStore implements ManagedRecordingStore {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    static open(path: string): SqliteStore;
+    private migrate;
+    schemaVersion(): number;
+    integrityCheck(): string;
+    close(): void;
+    insertRecording(r: Recording): Promise<void>;
+    getRecording(id: string): Promise<Recording | null>;
+    findRecordingBySha(sha256: string): Promise<Recording | null>;
+    listRecordings(filter: RecordingListFilter): Promise<Recording[]>;
+    insertTranscript(t: Transcript, segments: readonly Segment[]): Promise<void>;
+    latestTranscript(recordingId: string): Promise<Transcript | null>;
+    getTranscript(id: string): Promise<Transcript | null>;
+    listSegments(transcriptId: string): Promise<Segment[]>;
+    findRecordingsByIdPrefix(prefix: string): Promise<Recording[]>;
+    findTranscriptsByIdPrefix(prefix: string): Promise<Transcript[]>;
+    addTags(recordingId: string, tags: readonly string[]): Promise<void>;
+    listTags(recordingId: string): Promise<string[]>;
+    listAllTags(): Promise<{
+        tag: string;
+        count: number;
+    }[]>;
+    setSpeakerName(recordingId: string, label: string, name: string): Promise<void>;
+    /**
+     * Full-text search over segments.
+     *
+     * `bm25` rather than raw `rank` in the order-by so the sort is explicit
+     * about what it means, and the newest recording wins ties -- of two equally
+     * relevant hits, the recent one is almost always the one being looked for.
+     *
+     * The newest-transcript restriction is a correlated subquery rather than a
+     * join on a grouped query: a recording re-transcribed with --force has
+     * several transcripts holding the same words, and without this the same
+     * sentence comes back two or three times, reading as several occurrences.
+     */
+    searchSegments(match: string, filter: SegmentSearchFilter): Promise<SegmentHit[]>;
+    insertSummary(summary: Summary): Promise<void>;
+    /**
+     * The newest summary covering this recording ALONE.
+     *
+     * The `NOT EXISTS` is the whole point: a group summary of ten meetings also
+     * has a row here for each of them, and handing it back as "the summary of
+     * the third meeting" would answer a question about one recording with nine
+     * others mixed in.
+     */
+    latestSummaryOf(recordingId: string): Promise<Summary | null>;
+    listSummaries(recordingId: string): Promise<Summary[]>;
+    listAllSummaries(): Promise<Summary[]>;
+    findSummariesByIdPrefix(prefix: string): Promise<Summary[]>;
+    deleteSummary(id: string): Promise<boolean>;
+    private toSummary;
+    listSpeakerNames(recordingId: string): Promise<SpeakerName[]>;
+    annotateRecording(id: string, fields: {
+        readonly title?: string;
+        readonly notes?: string;
+    }): Promise<void>;
+    deleteRecording(id: string): Promise<boolean>;
+    languagesByTranscript(transcriptIds: readonly string[]): Promise<Map<string, readonly string[]>>;
+}
+export declare const openStore: (path: string) => SqliteStore;

package/dist/store/sqliteStore.js

@@ -0,0 +1,433 @@
+import { DatabaseSync } from 'node:sqlite';
+import { orderLanguages, pendingMigrations } from '@ailoud/core';
+/**
+ * Whether a prefix is safe to put in front of a LIKE.
+ *
+ * Checked HERE rather than trusted from the caller, which is the difference
+ * between an invariant and a hope. The CLI does validate -- `resolveId.ts`
+ * enforces the ULID alphabet -- but the MCP resource handler passes a raw URI
+ * variable straight through, so `ailoud://report/_Z` reached this line with a
+ * LIKE wildcard in it and returned a report's body for a URI that identifies
+ * no report. An empty prefix would have matched the whole table.
+ *
+ * Ids are Crockford base32, which contains neither % nor _, so requiring that
+ * alphabet also removes every wildcard by construction.
+ */
+function usableIdPrefix(prefix) {
+    return prefix !== '' && /^[0-9A-Za-z]+$/.test(prefix);
+}
+const toRecording = (row) => ({
+    id: row.id,
+    sha256: row.sha256,
+    sourcePath: row.source_path,
+    mediaPath: row.media_path,
+    durationMs: row.duration_ms,
+    mime: row.mime,
+    title: row.title,
+    notes: row.notes,
+    recordedAt: row.recorded_at,
+    importedAt: row.imported_at,
+});
+const toTranscript = (row) => ({
+    id: row.id,
+    recordingId: row.recording_id,
+    provider: row.provider,
+    model: row.model,
+    language: row.language,
+    text: row.text,
+    createdAt: row.created_at,
+});
+const toSegment = (row) => ({
+    id: row.id,
+    transcriptId: row.transcript_id,
+    idx: row.idx,
+    startMs: row.start_ms,
+    endMs: row.end_ms,
+    text: row.text,
+    speaker: row.speaker,
+    language: row.language,
+});
+export class SqliteStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    static open(path) {
+        const db = new DatabaseSync(path);
+        db.exec('PRAGMA journal_mode = WAL');
+        db.exec('PRAGMA foreign_keys = ON');
+        const store = new SqliteStore(db);
+        store.migrate();
+        return store;
+    }
+    migrate() {
+        const row = this.db.prepare('PRAGMA user_version').get();
+        const pending = pendingMigrations(row.user_version);
+        if (pending.length === 0)
+            return;
+        this.db.exec('BEGIN');
+        try {
+            for (const migration of pending) {
+                for (const statement of migration.statements)
+                    this.db.exec(statement);
+                // PRAGMA does not accept a bound parameter, and the value is an integer
+                // from our own migration list, never user input.
+                this.db.exec(`PRAGMA user_version = ${migration.version}`);
+            }
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    schemaVersion() {
+        return this.db.prepare('PRAGMA user_version').get().user_version;
+    }
+    integrityCheck() {
+        return this.db.prepare('PRAGMA integrity_check').get()
+            .integrity_check;
+    }
+    close() {
+        this.db.close();
+    }
+    async insertRecording(r) {
+        this.db
+            .prepare(`INSERT INTO recording
+         (id, sha256, source_path, media_path, duration_ms, mime, title, notes, recorded_at,
+          imported_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(r.id, r.sha256, r.sourcePath, r.mediaPath, r.durationMs, r.mime, r.title, r.notes, r.recordedAt, r.importedAt);
+    }
+    async getRecording(id) {
+        const row = this.db.prepare('SELECT * FROM recording WHERE id = ?').get(id);
+        return row ? toRecording(row) : null;
+    }
+    async findRecordingBySha(sha256) {
+        const row = this.db.prepare('SELECT * FROM recording WHERE sha256 = ?').get(sha256);
+        return row ? toRecording(row) : null;
+    }
+    async listRecordings(filter) {
+        const where = [];
+        const params = [];
+        if (filter.ids && filter.ids.length > 0) {
+            where.push(`id IN (${filter.ids.map(() => '?').join(', ')})`);
+            params.push(...filter.ids);
+        }
+        if (filter.withoutTranscript === true) {
+            where.push('NOT EXISTS (SELECT 1 FROM transcript t WHERE t.recording_id = recording.id)');
+        }
+        if (filter.tags && filter.tags.length > 0) {
+            // One EXISTS per tag, so several tags mean "carries all of them"
+            // rather than "carries any". Narrowing is what a second tag is for; a
+            // filter that widened as you added terms would be a surprise.
+            for (const tag of filter.tags) {
+                where.push('EXISTS (SELECT 1 FROM tag g WHERE g.recording_id = recording.id AND g.tag = ?)');
+                params.push(tag);
+            }
+        }
+        const clause = where.length > 0 ? ` WHERE ${where.join(' AND ')}` : '';
+        // node:sqlite types .all() as Record<string, SQLOutputValue>[], an index
+        // signature type the compiler will not cast directly to our named-field
+        // row type as `X[]` (TS2352). The single-row `.get()` casts below compile
+        // only because their target type is `X | undefined`, not because arrays
+        // are treated differently in general. Routing through `unknown` is the
+        // standard, non-`any` escape for that specific TypeScript limitation.
+        const rows = this.db
+            .prepare(`SELECT * FROM recording${clause} ORDER BY imported_at, id`)
+            .all(...params);
+        return rows.map(toRecording);
+    }
+    async insertTranscript(t, segments) {
+        this.db.exec('BEGIN');
+        try {
+            this.db
+                .prepare(`INSERT INTO transcript
+           (id, recording_id, provider, model, language, text, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`)
+                .run(t.id, t.recordingId, t.provider, t.model, t.language, t.text, t.createdAt);
+            const insertSegment = this.db.prepare(`INSERT INTO segment
+           (id, transcript_id, idx, start_ms, end_ms, text, speaker, language)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+            for (const s of segments) {
+                insertSegment.run(s.id, s.transcriptId, s.idx, s.startMs, s.endMs, s.text, s.speaker, s.language);
+            }
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async latestTranscript(recordingId) {
+        const row = this.db
+            .prepare(`SELECT * FROM transcript WHERE recording_id = ?
+       ORDER BY created_at DESC, id DESC LIMIT 1`)
+            .get(recordingId);
+        return row ? toTranscript(row) : null;
+    }
+    async getTranscript(id) {
+        const row = this.db.prepare('SELECT * FROM transcript WHERE id = ?').get(id);
+        return row ? toTranscript(row) : null;
+    }
+    async listSegments(transcriptId) {
+        // See the comment in listRecordings: .all() returns an index signature
+        // type, which needs the `unknown` step before it can become our
+        // named-field row type.
+        const rows = this.db
+            .prepare('SELECT * FROM segment WHERE transcript_id = ? ORDER BY idx')
+            .all(transcriptId);
+        return rows.map(toSegment);
+    }
+    async findRecordingsByIdPrefix(prefix) {
+        if (!usableIdPrefix(prefix))
+            return [];
+        const rows = this.db
+            .prepare(`SELECT * FROM recording WHERE id LIKE ? || '%' ORDER BY id`)
+            .all(prefix);
+        return rows.map(toRecording);
+    }
+    async findTranscriptsByIdPrefix(prefix) {
+        if (!usableIdPrefix(prefix))
+            return [];
+        const rows = this.db
+            .prepare(`SELECT * FROM transcript WHERE id LIKE ? || '%' ORDER BY id`)
+            .all(prefix);
+        return rows.map(toTranscript);
+    }
+    async addTags(recordingId, tags) {
+        // OR IGNORE: re-tagging is how a user makes sure a tag is there, not an
+        // error to report at them.
+        const insert = this.db.prepare('INSERT OR IGNORE INTO tag (recording_id, tag) VALUES (?, ?)');
+        for (const tag of tags)
+            insert.run(recordingId, tag);
+    }
+    async listTags(recordingId) {
+        const rows = this.db
+            .prepare('SELECT tag FROM tag WHERE recording_id = ? ORDER BY tag')
+            .all(recordingId);
+        return rows.map((row) => row.tag);
+    }
+    async listAllTags() {
+        const rows = this.db
+            .prepare('SELECT tag, count(*) AS n FROM tag GROUP BY tag ORDER BY n DESC, tag')
+            .all();
+        return rows.map((row) => ({ tag: row.tag, count: Number(row.n) }));
+    }
+    async setSpeakerName(recordingId, label, name) {
+        // Upsert: naming the same speaker twice is a correction, not an error.
+        this.db
+            .prepare(`INSERT INTO speaker (recording_id, label, name) VALUES (?, ?, ?)
+         ON CONFLICT (recording_id, label) DO UPDATE SET name = excluded.name`)
+            .run(recordingId, label, name);
+    }
+    /**
+     * Full-text search over segments.
+     *
+     * `bm25` rather than raw `rank` in the order-by so the sort is explicit
+     * about what it means, and the newest recording wins ties -- of two equally
+     * relevant hits, the recent one is almost always the one being looked for.
+     *
+     * The newest-transcript restriction is a correlated subquery rather than a
+     * join on a grouped query: a recording re-transcribed with --force has
+     * several transcripts holding the same words, and without this the same
+     * sentence comes back two or three times, reading as several occurrences.
+     */
+    async searchSegments(match, filter) {
+        const where = ['segment_fts MATCH ?'];
+        const params = [match];
+        if (filter.allTranscripts !== true) {
+            where.push(`t.id = (
+        SELECT inner_t.id FROM transcript inner_t
+         WHERE inner_t.recording_id = r.id
+         ORDER BY inner_t.created_at DESC, inner_t.id DESC LIMIT 1
+      )`);
+        }
+        if (filter.language !== undefined) {
+            where.push('s.language = ?');
+            params.push(filter.language);
+        }
+        const ids = filter.recordingIds ?? [];
+        if (ids.length > 0) {
+            where.push(`r.id IN (${ids.map(() => '?').join(', ')})`);
+            params.push(...ids);
+        }
+        for (const tag of filter.tags ?? []) {
+            // One EXISTS per tag: several tags narrow rather than widen, so a
+            // recording must carry all of them -- the same rule `ls --tag` follows.
+            where.push('EXISTS (SELECT 1 FROM tag WHERE tag.recording_id = r.id AND tag.tag = ?)');
+            params.push(tag);
+        }
+        const limit = filter.limit ?? 50;
+        const rows = this.db
+            .prepare(`SELECT s.id AS segment_id, s.transcript_id, s.start_ms, s.end_ms, s.text,
+                s.speaker, s.language,
+                r.id AS recording_id, r.title, r.recorded_at, r.imported_at
+           FROM segment_fts f
+           JOIN segment s ON s.rowid = f.rowid
+           JOIN transcript t ON t.id = s.transcript_id
+           JOIN recording r ON r.id = t.recording_id
+          WHERE ${where.join('\n            AND ')}
+          ORDER BY bm25(segment_fts), r.imported_at DESC, s.start_ms
+          LIMIT ?`)
+            .all(...params, limit);
+        const tagsOf = this.db.prepare('SELECT tag FROM tag WHERE recording_id = ? ORDER BY tag');
+        return rows.map((row) => ({
+            recordingId: row.recording_id,
+            recordingTitle: row.title,
+            recordedAt: row.recorded_at ?? row.imported_at,
+            tags: tagsOf.all(row.recording_id).map((t) => t.tag),
+            transcriptId: row.transcript_id,
+            segmentId: row.segment_id,
+            startMs: row.start_ms,
+            endMs: row.end_ms,
+            speaker: row.speaker,
+            language: row.language,
+            text: row.text,
+        }));
+    }
+    async insertSummary(summary) {
+        this.db.exec('BEGIN');
+        try {
+            this.db
+                .prepare(`INSERT INTO summary
+             (id, created_at, language, provider, model, body, template, context)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(summary.id, summary.createdAt, summary.language, summary.provider, summary.model, summary.body, summary.template, summary.context);
+            const link = this.db.prepare('INSERT INTO summary_recording (summary_id, recording_id) VALUES (?, ?)');
+            for (const recordingId of summary.recordingIds)
+                link.run(summary.id, recordingId);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    /**
+     * The newest summary covering this recording ALONE.
+     *
+     * The `NOT EXISTS` is the whole point: a group summary of ten meetings also
+     * has a row here for each of them, and handing it back as "the summary of
+     * the third meeting" would answer a question about one recording with nine
+     * others mixed in.
+     */
+    async latestSummaryOf(recordingId) {
+        const row = this.db
+            .prepare(`SELECT s.* FROM summary s
+           JOIN summary_recording sr ON sr.summary_id = s.id
+          WHERE sr.recording_id = ?
+            AND NOT EXISTS (
+              SELECT 1 FROM summary_recording other
+               WHERE other.summary_id = s.id AND other.recording_id <> ?
+            )
+          ORDER BY s.created_at DESC, s.id DESC LIMIT 1`)
+            .get(recordingId, recordingId);
+        return row ? this.toSummary(row) : null;
+    }
+    async listSummaries(recordingId) {
+        const rows = this.db
+            .prepare(`SELECT s.* FROM summary s
+           JOIN summary_recording sr ON sr.summary_id = s.id
+          WHERE sr.recording_id = ?
+          ORDER BY s.created_at DESC, s.id DESC`)
+            .all(recordingId);
+        return rows.map((row) => this.toSummary(row));
+    }
+    async listAllSummaries() {
+        const rows = this.db
+            .prepare('SELECT * FROM summary ORDER BY created_at DESC, id DESC')
+            .all();
+        return rows.map((row) => this.toSummary(row));
+    }
+    async findSummariesByIdPrefix(prefix) {
+        if (!usableIdPrefix(prefix))
+            return [];
+        const rows = this.db
+            .prepare(`SELECT * FROM summary WHERE id LIKE ? || '%' ORDER BY id`)
+            .all(prefix);
+        return rows.map((row) => this.toSummary(row));
+    }
+    async deleteSummary(id) {
+        // The join rows go with it through ON DELETE CASCADE, which the store
+        // enables with PRAGMA foreign_keys = ON. Recordings are untouched: the
+        // cascade runs from summary to summary_recording, never the other way.
+        const result = this.db.prepare('DELETE FROM summary WHERE id = ?').run(id);
+        return Number(result.changes) > 0;
+    }
+    toSummary(row) {
+        const ids = this.db
+            .prepare('SELECT recording_id FROM summary_recording WHERE summary_id = ? ORDER BY recording_id')
+            .all(row.id);
+        return {
+            id: row.id,
+            createdAt: row.created_at,
+            language: row.language,
+            provider: row.provider,
+            model: row.model,
+            body: row.body,
+            template: row.template,
+            context: row.context,
+            recordingIds: ids.map((entry) => entry.recording_id),
+        };
+    }
+    async listSpeakerNames(recordingId) {
+        const rows = this.db
+            .prepare('SELECT label, name FROM speaker WHERE recording_id = ? ORDER BY label')
+            .all(recordingId);
+        return rows.map((row) => ({ label: row.label, name: row.name }));
+    }
+    async annotateRecording(id, fields) {
+        // COALESCE with a null parameter leaves the stored value alone, so one
+        // statement covers "set the title", "set the notes", and "set both"
+        // without three of them drifting apart.
+        this.db
+            .prepare(`UPDATE recording SET title = COALESCE(?, title), notes = COALESCE(?, notes)
+         WHERE id = ?`)
+            .run(fields.title ?? null, fields.notes ?? null, id);
+    }
+    async deleteRecording(id) {
+        // One statement: transcript and segment rows go through ON DELETE
+        // CASCADE, which works because open() sets PRAGMA foreign_keys = ON.
+        // The segment_fts index is kept in step by the AFTER DELETE trigger on
+        // segment, which a cascade fires like any other delete -- there is a
+        // test for exactly that, because a stale search index would corrupt
+        // results silently rather than failing.
+        const result = this.db.prepare('DELETE FROM recording WHERE id = ?').run(id);
+        return Number(result.changes) > 0;
+    }
+    async languagesByTranscript(transcriptIds) {
+        // `IN ()` is a syntax error, and there is nothing to ask about anyway.
+        if (transcriptIds.length === 0)
+            return new Map();
+        // One aggregate for the whole list, not one query per transcript: this
+        // exists so that `ls` can show a language per row without loading the
+        // segments of every recording in the library.
+        //
+        // max(x, 0) clamps a segment whose end precedes its start, matching what
+        // summarizeLanguages does in memory -- a negative span must not subtract
+        // from a language's total and reorder the result. Rows with no language
+        // are excluded here rather than filtered later, so a transcript with no
+        // languages recorded produces no rows and stays absent from the map.
+        const placeholders = transcriptIds.map(() => '?').join(',');
+        const rows = this.db
+            .prepare(`SELECT transcript_id, language,
+                SUM(max(end_ms - start_ms, 0)) AS spoken_ms,
+                MIN(idx) AS first_idx
+         FROM segment
+         WHERE transcript_id IN (${placeholders})
+           AND language IS NOT NULL AND language <> ''
+         GROUP BY transcript_id, language`)
+            .all(...transcriptIds);
+        const totalsByTranscript = new Map();
+        for (const row of rows) {
+            const totals = totalsByTranscript.get(row.transcript_id) ?? [];
+            totals.push({ language: row.language, spokenMs: row.spoken_ms, firstIdx: row.first_idx });
+            totalsByTranscript.set(row.transcript_id, totals);
+        }
+        // The ordering rule itself lives in core (orderLanguages), shared with
+        // summarizeLanguages, so SQL and TypeScript cannot drift apart on it.
+        return new Map([...totalsByTranscript.entries()].map(([id, totals]) => [id, orderLanguages(totals)]));
+    }
+}
+export const openStore = (path) => SqliteStore.open(path);