@alisio/core 0.1.0-alpha.9 → 0.1.1

package/dist/runtime/store.js

@@ -1,5 +1,8 @@
 import { textResult, } from "@alisio/sdk";
+import { isProcessAlive } from "./process.js";
 import { openDatabase } from "./sqlite.js";
+const alive = isProcessAlive;
+const TERMINAL_RUN = "('completed','turns_exceeded','failed','cancelled','interrupted')";
 export class SQLiteStore {
     db;
     constructor(path) {
@@ -45,12 +48,210 @@ export class SQLiteStore {
                 this.db.exec("CREATE INDEX IF NOT EXISTS sessions_parent ON sessions(parent_id)");
                 this.db.exec("INSERT OR IGNORE INTO schema_migrations VALUES(3)");
             });
+        if (!has(4))
+            this.db.transaction(() => {
+                // v4 (additive): run journal, workspace UI metadata, blob index and nullable columns.
+                this.db.exec(`CREATE TABLE IF NOT EXISTS runs(
+            id TEXT PRIMARY KEY,
+            session TEXT NOT NULL REFERENCES sessions(id),
+            status TEXT NOT NULL,
+            request_id TEXT,
+            correlation_id TEXT,
+            owner_pid INTEGER,
+            model TEXT,
+            created_at INTEGER NOT NULL,
+            started_at INTEGER,
+            ended_at INTEGER,
+            error TEXT,
+            usage TEXT);
+          CREATE UNIQUE INDEX IF NOT EXISTS runs_request ON runs(session, request_id) WHERE request_id IS NOT NULL;
+          CREATE INDEX IF NOT EXISTS runs_session ON runs(session, created_at);
+          CREATE TABLE IF NOT EXISTS workspaces(
+            path TEXT PRIMARY KEY,
+            label TEXT,
+            pinned INTEGER NOT NULL DEFAULT 0,
+            last_opened_at INTEGER);
+          CREATE TABLE IF NOT EXISTS blobs(
+            hash TEXT PRIMARY KEY,
+            mime TEXT NOT NULL,
+            size INTEGER NOT NULL,
+            width INTEGER,
+            height INTEGER,
+            created_at INTEGER NOT NULL);`);
+                const add = (table, name, type) => {
+                    const columns = this.db.prepare(`PRAGMA table_info(${table})`).all();
+                    if (!columns.some((c) => c.name === name))
+                        this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${name} ${type}`);
+                };
+                add("sessions", "pinned", "INTEGER NOT NULL DEFAULT 0");
+                add("sessions", "archived_at", "INTEGER");
+                add("events", "created_at", "INTEGER");
+                add("events", "correlation_id", "TEXT");
+                add("tool_calls", "run_id", "TEXT");
+                add("tool_calls", "name", "TEXT");
+                add("tool_calls", "effect", "TEXT");
+                add("tool_calls", "started_at", "INTEGER");
+                add("tool_calls", "ended_at", "INTEGER");
+                this.db.exec(`CREATE INDEX IF NOT EXISTS events_session ON events(session, seq);
+          CREATE INDEX IF NOT EXISTS messages_session ON messages(session, seq);
+          INSERT OR IGNORE INTO schema_migrations VALUES(4);`);
+            });
+        if (!has(5))
+            this.db.transaction(() => {
+                // v5 (additive): archived workspaces (hidden from the default web list).
+                const columns = this.db.prepare("PRAGMA table_info(workspaces)").all();
+                if (!columns.some((c) => c.name === "archived_at"))
+                    this.db.exec("ALTER TABLE workspaces ADD COLUMN archived_at INTEGER");
+                this.db.exec("INSERT OR IGNORE INTO schema_migrations VALUES(5)");
+            });
+        if (!has(6))
+            this.db.transaction(() => {
+                // v6 (additive): Python analysis executions, published artifacts, persisted capability
+                // grants (audit included) and tabular datasets (used from the data phase on).
+                this.db.exec(`CREATE TABLE IF NOT EXISTS analysis_executions(
+            id TEXT PRIMARY KEY,
+            session TEXT NOT NULL,
+            root_session TEXT NOT NULL,
+            workspace TEXT NOT NULL,
+            run_id TEXT, call_id TEXT,
+            runtime TEXT NOT NULL CHECK(runtime IN ('managed','oci')),
+            status TEXT NOT NULL CHECK(status IN ('running','completed','failed','cancelled','timed_out')),
+            script_sha256 TEXT NOT NULL,
+            exit_code INTEGER, error TEXT,
+            rel_dir TEXT NOT NULL,
+            rerun_of TEXT,
+            created_at INTEGER NOT NULL, ended_at INTEGER);
+          CREATE INDEX IF NOT EXISTS analysis_executions_session
+            ON analysis_executions(root_session, created_at);
+          CREATE TABLE IF NOT EXISTS artifacts(
+            id TEXT PRIMARY KEY,
+            session TEXT NOT NULL, root_session TEXT NOT NULL, workspace TEXT NOT NULL,
+            run_id TEXT, call_id TEXT,
+            execution_id TEXT REFERENCES analysis_executions(id),
+            source_path TEXT,
+            title TEXT NOT NULL, file_name TEXT NOT NULL,
+            kind TEXT NOT NULL, mime TEXT NOT NULL,
+            bytes INTEGER NOT NULL, file_count INTEGER NOT NULL DEFAULT 1,
+            sha256 TEXT NOT NULL, entry TEXT,
+            rel_dir TEXT NOT NULL,
+            status TEXT NOT NULL CHECK(status IN ('ready','deleted','expired')),
+            provenance TEXT NOT NULL,
+            created_at INTEGER NOT NULL, deleted_at INTEGER,
+            UNIQUE(execution_id, source_path));
+          CREATE INDEX IF NOT EXISTS artifacts_session ON artifacts(root_session, created_at);
+          CREATE TABLE IF NOT EXISTS capability_grants(
+            id TEXT PRIMARY KEY,
+            capability TEXT NOT NULL,
+            session TEXT NOT NULL,
+            workspace TEXT NOT NULL,
+            scope TEXT NOT NULL CHECK(scope IN ('once','session')),
+            decision TEXT NOT NULL CHECK(decision IN ('allow','deny')),
+            source TEXT NOT NULL CHECK(source IN ('tui','web','flag','headless-grant')),
+            call_id TEXT, run_id TEXT, correlation_id TEXT,
+            created_at INTEGER NOT NULL,
+            revoked_at INTEGER, revoked_by TEXT);
+          CREATE INDEX IF NOT EXISTS capability_grants_lookup
+            ON capability_grants(capability, session, scope, decision, revoked_at);
+          CREATE TABLE IF NOT EXISTS datasets(
+            id TEXT PRIMARY KEY,
+            session TEXT NOT NULL, root_session TEXT NOT NULL,
+            name TEXT NOT NULL, format TEXT NOT NULL,
+            sha256 TEXT NOT NULL, bytes INTEGER NOT NULL,
+            blob_hash TEXT,
+            source_path TEXT,
+            db_rel_path TEXT NOT NULL,
+            ingest_version INTEGER NOT NULL,
+            sheets TEXT NOT NULL,
+            created_at INTEGER NOT NULL);
+          INSERT OR IGNORE INTO schema_migrations VALUES(6);`);
+            });
+        if (!has(7))
+            this.db.transaction(() => {
+                // v7 (additive): background tasks (`bg_run`, with their owner process, so a restart can
+                // tell a dead owner's tasks from another live process's) and the per-session goal
+                // (`session_goals`, written from the goal phase on).
+                this.db.exec(`CREATE TABLE IF NOT EXISTS background_tasks(
+            id TEXT PRIMARY KEY,
+            session TEXT NOT NULL,
+            root_session TEXT NOT NULL,
+            workspace TEXT NOT NULL,
+            kind TEXT NOT NULL CHECK(kind IN ('shell','subagent')),
+            label TEXT NOT NULL,
+            command TEXT, cwd TEXT,
+            status TEXT NOT NULL CHECK(status IN
+              ('queued','running','stopping','succeeded','failed','cancelled','lost')),
+            exit_code INTEGER, signal TEXT,
+            error_code TEXT,
+            abort_origin TEXT CHECK(abort_origin IN ('user','model','timeout','shutdown')),
+            pid INTEGER, owner_pid INTEGER NOT NULL,
+            timeout_ms INTEGER,
+            log_path TEXT NOT NULL,
+            bytes INTEGER NOT NULL DEFAULT 0,
+            truncated INTEGER NOT NULL DEFAULT 0,
+            created_at INTEGER NOT NULL, started_at INTEGER, ended_at INTEGER,
+            delivered_at INTEGER);
+          CREATE INDEX IF NOT EXISTS background_tasks_owner
+            ON background_tasks(root_session, created_at);
+          CREATE INDEX IF NOT EXISTS background_tasks_status
+            ON background_tasks(status, owner_pid);
+          CREATE TABLE IF NOT EXISTS session_goals(
+            session TEXT PRIMARY KEY REFERENCES sessions(id),
+            objective TEXT NOT NULL,
+            status TEXT NOT NULL CHECK(status IN
+              ('active','paused','blocked','budget_limited','complete')),
+            reason TEXT, evidence TEXT,
+            epoch INTEGER NOT NULL DEFAULT 1,
+            token_budget INTEGER, tokens_used INTEGER NOT NULL DEFAULT 0,
+            turns_used INTEGER NOT NULL DEFAULT 0,
+            max_turns INTEGER NOT NULL, max_wall_ms INTEGER NOT NULL,
+            active_ms INTEGER NOT NULL DEFAULT 0,
+            no_tool_streak INTEGER NOT NULL DEFAULT 0, repeat_streak INTEGER NOT NULL DEFAULT 0,
+            last_reply_hash TEXT, blocked_streak INTEGER NOT NULL DEFAULT 0,
+            created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, completed_at INTEGER);
+          INSERT OR IGNORE INTO schema_migrations VALUES(7);`);
+            });
+        if (!has(8))
+            this.db.transaction(() => {
+                // v8 (additive): the goal runtime's own columns (the continuation counter and its
+                // in-flight request id, the last settled run, the contract-sent flag, the driving
+                // process). `session_goals` was created by v7 and had no reader until the goal phase.
+                const columns = new Set(this.db.prepare("PRAGMA table_info(session_goals)").all().map((c) => c.name));
+                const add = (name, type) => {
+                    if (!columns.has(name))
+                        this.db.exec(`ALTER TABLE session_goals ADD COLUMN ${name} ${type}`);
+                };
+                add("goal_id", "TEXT");
+                add("detail", "TEXT");
+                add("summary", "TEXT");
+                add("blocked_run", "TEXT");
+                add("continuations", "INTEGER NOT NULL DEFAULT 0");
+                add("inflight", "TEXT");
+                add("last_run_id", "TEXT");
+                add("kickoff_sent", "INTEGER NOT NULL DEFAULT 0");
+                add("owner_pid", "INTEGER");
+                this.db.exec("INSERT OR IGNORE INTO schema_migrations VALUES(8)");
+            });
+    }
+    /**
+     * The root of a session (itself for roots), following `parent_id`. Unknown ids are their own
+     * root, so callers never throw on a session another process has not written yet.
+     */
+    rootOf(id) {
+        let current = id;
+        for (let depth = 0; depth < 32; depth++) {
+            const row = this.db.prepare("SELECT parent_id FROM sessions WHERE id=?").get(current);
+            if (!row?.parent_id)
+                return current;
+            current = row.parent_id;
+        }
+        return current;
     }
     create(workspace, provider, model) {
         const id = crypto.randomUUID();
+        const now = Date.now();
         this.db
-            .prepare("INSERT INTO sessions(id,workspace,provider,model) VALUES(?,?,?,?)")
-            .run(id, workspace, provider, model);
+            .prepare("INSERT INTO sessions(id,workspace,provider,model,created_at,updated_at) VALUES(?,?,?,?,?,?)")
+            .run(id, workspace, provider, model, now, now);
         return { id, workspace, provider, model };
     }
     row(r) {
@@ -68,6 +269,8 @@ export class SQLiteStore {
             ...(r.options ? { options: JSON.parse(String(r.options)) } : {}),
             ...(r.created_at ? { createdAt: Number(r.created_at) } : {}),
             ...(r.updated_at ? { updatedAt: Number(r.updated_at) } : {}),
+            ...(r.pinned ? { pinned: true } : {}),
+            ...(r.archived_at ? { archivedAt: Number(r.archived_at) } : {}),
         };
     }
     get(id) {
@@ -147,6 +350,10 @@ export class SQLiteStore {
         this.db
             .prepare("INSERT INTO messages(session,body) VALUES(?,?)")
             .run(id, JSON.stringify(message));
+        this.touch(id);
+    }
+    touch(id) {
+        this.db.prepare("UPDATE sessions SET updated_at=? WHERE id=?").run(Date.now(), id);
     }
     setModel(id, model) {
         if (!model.trim())
@@ -201,15 +408,37 @@ export class SQLiteStore {
             .prepare("UPDATE sessions SET locked_pid=NULL WHERE id=? AND locked_pid=?")
             .run(id, process.pid);
     }
-    beginCall(id, call) {
+    beginCall(id, call, meta = {}) {
         this.db
-            .prepare("INSERT INTO tool_calls(session,call_id,status) VALUES(?,?,'pending')")
-            .run(id, call.id);
+            .prepare("INSERT INTO tool_calls(session,call_id,status,run_id,name,effect,started_at) VALUES(?,?,'pending',?,?,?,?)")
+            .run(id, call.id, meta.runId ?? null, call.name, meta.effect ?? null, Date.now());
     }
     endCall(id, call, result) {
         this.db
-            .prepare("INSERT INTO tool_calls(session,call_id,status,result) VALUES(?,?,'completed',?) ON CONFLICT(session,call_id) DO UPDATE SET status='completed',result=excluded.result")
-            .run(id, call.id, JSON.stringify(result));
+            .prepare("INSERT INTO tool_calls(session,call_id,status,result,name,ended_at) VALUES(?,?,'completed',?,?,?) ON CONFLICT(session,call_id) DO UPDATE SET status='completed',result=excluded.result,ended_at=excluded.ended_at,name=COALESCE(tool_calls.name,excluded.name)")
+            .run(id, call.id, JSON.stringify(result), call.name, Date.now());
+    }
+    /**
+     * Calls of a session with one effect (for example `write`), oldest first. Needs the v4
+     * `effect`/`run_id`/`started_at` columns; rows written by older versions have no effect.
+     */
+    effectCalls(session, effect) {
+        const rows = this.db
+            .prepare("SELECT call_id,name,run_id,started_at FROM tool_calls WHERE session=? AND effect=? ORDER BY started_at, rowid")
+            .all(session, effect);
+        return rows.map((row) => ({
+            callId: row.call_id,
+            name: row.name ?? "",
+            ...(row.run_id ? { runId: row.run_id } : {}),
+            ...(row.started_at != null ? { startedAt: Number(row.started_at) } : {}),
+        }));
+    }
+    /** Rich (ui/image) parts persist as part of the serialized result and replay verbatim. */
+    callResult(id, callId) {
+        const row = this.db
+            .prepare("SELECT result FROM tool_calls WHERE session=? AND call_id=? AND status='completed'")
+            .get(id, callId);
+        return row?.result ? JSON.parse(row.result) : undefined;
     }
     reconcile(id, acknowledge = false) {
         this.db.transaction(() => {
@@ -237,10 +466,235 @@ export class SQLiteStore {
             }
         });
     }
-    event(id, runId, type, data) {
-        this.db
-            .prepare("INSERT INTO events(session,run_id,type,body) VALUES(?,?,?,?)")
-            .run(id, runId, type, JSON.stringify(data));
+    /** Persists a durable event and returns its global `events.seq`. */
+    event(id, runId, type, data, meta = {}) {
+        const { lastInsertRowid } = this.db
+            .prepare("INSERT INTO events(session,run_id,type,body,created_at,correlation_id) VALUES(?,?,?,?,?,?)")
+            .run(id, runId, type, JSON.stringify(data), Date.now(), meta.correlationId ?? null);
+        return Number(lastInsertRowid);
+    }
+    runRow(r) {
+        return {
+            id: String(r.id),
+            session: String(r.session),
+            status: r.status,
+            ...(r.request_id != null ? { requestId: String(r.request_id) } : {}),
+            ...(r.correlation_id != null ? { correlationId: String(r.correlation_id) } : {}),
+            ...(r.owner_pid != null ? { ownerPid: Number(r.owner_pid) } : {}),
+            ...(r.model != null ? { model: String(r.model) } : {}),
+            createdAt: Number(r.created_at),
+            ...(r.started_at != null ? { startedAt: Number(r.started_at) } : {}),
+            ...(r.ended_at != null ? { endedAt: Number(r.ended_at) } : {}),
+            ...(r.error != null ? { error: String(r.error) } : {}),
+            ...(r.usage != null ? { usage: JSON.parse(String(r.usage)) } : {}),
+        };
+    }
+    runById(id) {
+        const row = this.db.prepare("SELECT * FROM runs WHERE id=?").get(id);
+        return row ? this.runRow(row) : undefined;
+    }
+    beginRun(input) {
+        return this.db.transaction(() => {
+            const status = input.status ?? "running";
+            const now = Date.now();
+            const existing = this.runById(input.id);
+            if (existing) {
+                if (existing.status === "queued" && status === "running")
+                    this.db
+                        .prepare("UPDATE runs SET status='running', started_at=?, owner_pid=?, model=COALESCE(?,model) WHERE id=?")
+                        .run(now, process.pid, input.model ?? null, input.id);
+                return { run: this.runById(input.id), created: false };
+            }
+            if (input.requestId !== undefined) {
+                const retried = this.runByRequest(input.session, input.requestId);
+                if (retried)
+                    return { run: retried, created: false };
+            }
+            this.db
+                .prepare(`INSERT INTO runs(id,session,status,request_id,correlation_id,owner_pid,model,created_at,started_at)
+           VALUES(?,?,?,?,?,?,?,?,?)`)
+                .run(input.id, input.session, status, input.requestId ?? null, input.correlationId ?? null, process.pid, input.model ?? null, now, status === "running" ? now : null);
+            return { run: this.runById(input.id), created: true };
+        });
+    }
+    endRun(id, input) {
+        const now = Date.now();
+        this.db.transaction(() => {
+            this.db
+                .prepare(`UPDATE runs SET status=?, ended_at=?, error=?, usage=COALESCE(?,usage)
+           WHERE id=? AND status NOT IN ${TERMINAL_RUN}`)
+                .run(input.status, now, input.error ?? null, input.usage ? JSON.stringify(input.usage) : null, id);
+            const run = this.runById(id);
+            if (run)
+                this.touch(run.session);
+        });
+    }
+    runByRequest(session, requestId) {
+        const row = this.db
+            .prepare("SELECT * FROM runs WHERE session=? AND request_id=?")
+            .get(session, requestId);
+        return row ? this.runRow(row) : undefined;
+    }
+    runs(session, options = {}) {
+        return this.db
+            .prepare("SELECT * FROM runs WHERE session=? ORDER BY created_at DESC, rowid DESC LIMIT ?")
+            .all(session, options.limit ?? 100)
+            .map((r) => this.runRow(r));
+    }
+    interruptRuns() {
+        const rows = this.db
+            .prepare("SELECT id, owner_pid FROM runs WHERE status IN ('queued','running')")
+            .all();
+        let count = 0;
+        for (const row of rows) {
+            // Runs of this process (another Application in it) or of another live process stay.
+            if (row.owner_pid && (row.owner_pid === process.pid || alive(row.owner_pid)))
+                continue;
+            this.endRun(row.id, { status: "interrupted" });
+            count++;
+        }
+        return count;
+    }
+    /**
+     * A page of messages by `seq`. With `after`, the first `limit` rows after it; otherwise the
+     * newest `limit` rows (before `before` when given). Items are always in ascending order.
+     */
+    messagesPage(session, options = {}) {
+        const limit = Math.max(1, Math.min(options.limit ?? 100, 1000));
+        const active = options.compacted ? "" : " AND compacted=0";
+        const rows = (options.after !== undefined
+            ? this.db
+                .prepare(`SELECT seq,body,compacted FROM messages WHERE session=? AND seq>?${active} ORDER BY seq LIMIT ?`)
+                .all(session, options.after, limit + 1)
+            : this.db
+                .prepare(`SELECT seq,body,compacted FROM messages WHERE session=? AND seq<?${active} ORDER BY seq DESC LIMIT ?`)
+                .all(session, options.before ?? Number.MAX_SAFE_INTEGER, limit + 1));
+        const hasMore = rows.length > limit;
+        const page = rows.slice(0, limit);
+        if (options.after === undefined)
+            page.reverse();
+        return {
+            items: page.map((r) => ({
+                seq: Number(r.seq),
+                message: JSON.parse(r.body),
+                compacted: !!r.compacted,
+            })),
+            hasMore,
+        };
+    }
+    /** Durable events of a session after `after` (a previous `eventId`), ascending. */
+    eventsPage(session, options = {}) {
+        const limit = Math.max(1, Math.min(options.limit ?? 500, 5000));
+        const rows = this.db
+            .prepare("SELECT seq,run_id,type,body,created_at,correlation_id FROM events WHERE session=? AND seq>? AND seq<? ORDER BY seq LIMIT ?")
+            .all(session, options.after ?? 0, options.before ?? Number.MAX_SAFE_INTEGER, limit + 1);
+        return {
+            items: rows.slice(0, limit).map((r) => ({
+                eventId: String(r.seq),
+                runId: String(r.run_id),
+                type: String(r.type),
+                data: r.body == null ? undefined : JSON.parse(String(r.body)),
+                ...(r.created_at != null ? { createdAt: Number(r.created_at) } : {}),
+                ...(r.correlation_id != null ? { correlationId: String(r.correlation_id) } : {}),
+            })),
+            hasMore: rows.length > limit,
+        };
+    }
+    /**
+     * Known workspaces for web clients: the workspaces of root sessions plus the ones recorded with
+     * `recordWorkspace` (v4 `workspaces` table), with their UI metadata (v5: `archivedAt`) and
+     * root-session count.
+     */
+    workspaces() {
+        const rows = this.db
+            .prepare(`SELECT p.path, w.label, COALESCE(w.pinned, 0) AS pinned, w.last_opened_at, w.archived_at,
+           (SELECT count(*) FROM sessions s WHERE s.workspace=p.path AND s.parent_id IS NULL) AS sessions
+         FROM (SELECT workspace AS path FROM sessions WHERE parent_id IS NULL AND workspace IS NOT NULL
+               UNION SELECT path FROM workspaces) p
+         LEFT JOIN workspaces w ON w.path=p.path
+         ORDER BY p.path`)
+            .all();
+        return rows.map((r) => ({
+            path: String(r.path),
+            ...(r.label != null ? { label: String(r.label) } : {}),
+            pinned: !!r.pinned,
+            ...(r.last_opened_at != null ? { lastOpenedAt: Number(r.last_opened_at) } : {}),
+            ...(r.archived_at != null ? { archivedAt: Number(r.archived_at) } : {}),
+            sessions: Number(r.sessions ?? 0),
+        }));
+    }
+    /**
+     * Records (upserts) a workspace and patches its UI metadata (`label: null` clears the label;
+     * `archived` stamps or clears `archived_at` and never touches its sessions).
+     */
+    recordWorkspace(path, patch = {}) {
+        this.db.transaction(() => {
+            this.db.prepare("INSERT OR IGNORE INTO workspaces(path) VALUES(?)").run(path);
+            if (patch.label !== undefined)
+                this.db.prepare("UPDATE workspaces SET label=? WHERE path=?").run(patch.label, path);
+            if (patch.pinned !== undefined)
+                this.db
+                    .prepare("UPDATE workspaces SET pinned=? WHERE path=?")
+                    .run(patch.pinned ? 1 : 0, path);
+            if (patch.lastOpenedAt !== undefined)
+                this.db
+                    .prepare("UPDATE workspaces SET last_opened_at=? WHERE path=?")
+                    .run(patch.lastOpenedAt, path);
+            if (patch.archived !== undefined)
+                this.db
+                    .prepare("UPDATE workspaces SET archived_at=? WHERE path=?")
+                    .run(patch.archived ? Date.now() : null, path);
+        });
+    }
+    /**
+     * Patches web-facing session metadata: title, pin, archive flag and `options` (shallow-merged
+     * into the stored options object). Does not touch the run-relevant columns.
+     */
+    updateSessionMeta(id, patch) {
+        this.db.transaction(() => {
+            const current = this.get(id);
+            if (patch.title !== undefined)
+                this.db.prepare("UPDATE sessions SET title=? WHERE id=?").run(patch.title, id);
+            if (patch.pinned !== undefined)
+                this.db.prepare("UPDATE sessions SET pinned=? WHERE id=?").run(patch.pinned ? 1 : 0, id);
+            if (patch.archived !== undefined)
+                this.db
+                    .prepare("UPDATE sessions SET archived_at=? WHERE id=?")
+                    .run(patch.archived ? Date.now() : null, id);
+            if (patch.options)
+                this.db
+                    .prepare("UPDATE sessions SET options=? WHERE id=?")
+                    .run(JSON.stringify({ ...(current.options ?? {}), ...patch.options }), id);
+        });
+    }
+    /**
+     * Atomic read-modify-write of `sessions.options` (`BEGIN IMMEDIATE`: safe across processes that
+     * share the database). `change` receives the current options and returns the keys to merge
+     * (`undefined` removes a key; `undefined` as a whole changes nothing) and a value for the caller.
+     */
+    mutateSessionOptions(id, change) {
+        return this.db.transaction(() => {
+            const current = this.get(id).options ?? {};
+            const { patch, value } = change(current);
+            if (patch)
+                this.db
+                    .prepare("UPDATE sessions SET options=? WHERE id=?")
+                    .run(JSON.stringify({ ...current, ...patch }), id);
+            return value;
+        });
+    }
+    /** `MAX(events.seq)` of a session (0 without events): the web snapshot cursor. */
+    lastEventId(session) {
+        const row = this.db
+            .prepare("SELECT MAX(seq) AS seq FROM events WHERE session=?")
+            .get(session);
+        return Number(row?.seq ?? 0);
+    }
+    /** The pid of another live process holding the session lock, if any. */
+    lockedBy(id) {
+        const row = this.db.prepare("SELECT locked_pid FROM sessions WHERE id=?").get(id);
+        const pid = row?.locked_pid;
+        return pid && pid !== process.pid && alive(pid) ? pid : undefined;
     }
     getState(plugin, key) {
         const row = this.db

package/dist/runtime/zip.d.ts

@@ -0,0 +1,24 @@
+export type ZipEntry = {
+    name: string;
+    source: string;
+} | {
+    name: string;
+    data: Uint8Array;
+};
+/** CRC-32 (IEEE) of `bytes`, continuing from `crc`. */
+export declare function crc32(bytes: Uint8Array, crc?: number): number;
+/** Something to write the archive to (an HTTP response, a file stream…), honoring backpressure. */
+export interface ZipSink {
+    write(chunk: Buffer): boolean;
+    once(event: "drain", listener: () => void): unknown;
+}
+/**
+ * Writes `entries` as a ZIP archive to `out`, streaming file contents. Entry names use `/` and
+ * must be relative; the caller validates them. Throws when the archive would need ZIP64.
+ */
+export declare function writeZip(entries: ZipEntry[], out: ZipSink, options?: {
+    now?: Date;
+    signal?: AbortSignal;
+}): Promise<{
+    bytes: number;
+}>;

package/dist/runtime/zip.js

@@ -0,0 +1,126 @@
+/**
+ * Streaming ZIP writer on `node:zlib` (no dependency): DEFLATE entries with a data descriptor,
+ * UTF-8 names (general-purpose bit 11) and no ZIP64, so archives and entries must stay below
+ * 4 GiB. Used for multi-file artifact downloads and for folders published as one archive.
+ */
+import { createReadStream } from "node:fs";
+import { createDeflateRaw } from "node:zlib";
+let table;
+/** CRC-32 (IEEE) of `bytes`, continuing from `crc`. */
+export function crc32(bytes, crc = 0) {
+    if (!table) {
+        table = new Uint32Array(256);
+        for (let n = 0; n < 256; n++) {
+            let c = n;
+            for (let k = 0; k < 8; k++)
+                c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+            table[n] = c >>> 0;
+        }
+    }
+    let value = ~crc >>> 0;
+    for (let i = 0; i < bytes.length; i++)
+        value = table[(value ^ bytes[i]) & 0xff] ^ (value >>> 8);
+    return ~value >>> 0;
+}
+/** MS-DOS date and time of `date` (local time, 2-second resolution, 1980 minimum). */
+function dosTime(date) {
+    const year = Math.max(1980, date.getFullYear());
+    return {
+        time: (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2),
+        date: ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate(),
+    };
+}
+const LIMIT = 0xffff_ffff;
+/**
+ * Writes `entries` as a ZIP archive to `out`, streaming file contents. Entry names use `/` and
+ * must be relative; the caller validates them. Throws when the archive would need ZIP64.
+ */
+export async function writeZip(entries, out, options = {}) {
+    if (entries.length > 0xffff)
+        throw new Error("ZIP archives hold at most 65535 entries");
+    let offset = 0;
+    const put = async (chunk) => {
+        options.signal?.throwIfAborted();
+        offset += chunk.byteLength;
+        if (offset > LIMIT)
+            throw new Error("ZIP archives larger than 4 GiB are not supported");
+        if (!out.write(chunk))
+            await new Promise((resolve) => out.once("drain", resolve));
+    };
+    const { time, date } = dosTime(options.now ?? new Date());
+    const central = [];
+    for (const entry of entries) {
+        const name = Buffer.from(entry.name.replace(/\\/g, "/"), "utf8");
+        const start = offset;
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(0x04034b50, 0);
+        local.writeUInt16LE(20, 4); // version needed
+        local.writeUInt16LE(0x0808, 6); // data descriptor + UTF-8 names
+        local.writeUInt16LE(8, 8); // deflate
+        local.writeUInt16LE(time, 10);
+        local.writeUInt16LE(date, 12);
+        local.writeUInt16LE(name.length, 26);
+        await put(local);
+        await put(name);
+        let crc = 0, size = 0, compressed = 0;
+        const deflate = createDeflateRaw();
+        const feed = "data" in entry
+            ? (async () => {
+                crc = crc32(entry.data);
+                size = entry.data.byteLength;
+                deflate.end(Buffer.from(entry.data));
+            })()
+            : new Promise((resolve, reject) => {
+                const input = createReadStream(entry.source);
+                input.on("data", (chunk) => {
+                    const bytes = chunk;
+                    crc = crc32(bytes, crc);
+                    size += bytes.byteLength;
+                });
+                input.once("error", (error) => {
+                    deflate.destroy(error);
+                    reject(error);
+                });
+                input.once("end", resolve);
+                input.pipe(deflate);
+            });
+        for await (const chunk of deflate) {
+            compressed += chunk.byteLength;
+            await put(chunk);
+        }
+        await feed;
+        if (size > LIMIT || compressed > LIMIT)
+            throw new Error("ZIP entries larger than 4 GiB are not supported");
+        const descriptor = Buffer.alloc(16);
+        descriptor.writeUInt32LE(0x08074b50, 0);
+        descriptor.writeUInt32LE(crc, 4);
+        descriptor.writeUInt32LE(compressed, 8);
+        descriptor.writeUInt32LE(size, 12);
+        await put(descriptor);
+        const header = Buffer.alloc(46);
+        header.writeUInt32LE(0x02014b50, 0);
+        header.writeUInt16LE(20, 4); // version made by
+        header.writeUInt16LE(20, 6); // version needed
+        header.writeUInt16LE(0x0808, 8);
+        header.writeUInt16LE(8, 10);
+        header.writeUInt16LE(time, 12);
+        header.writeUInt16LE(date, 14);
+        header.writeUInt32LE(crc, 16);
+        header.writeUInt32LE(compressed, 20);
+        header.writeUInt32LE(size, 24);
+        header.writeUInt16LE(name.length, 28);
+        header.writeUInt32LE(start, 42);
+        central.push(header, name);
+    }
+    const directoryStart = offset;
+    for (const part of central)
+        await put(part);
+    const end = Buffer.alloc(22);
+    end.writeUInt32LE(0x06054b50, 0);
+    end.writeUInt16LE(entries.length, 8);
+    end.writeUInt16LE(entries.length, 10);
+    end.writeUInt32LE(offset - directoryStart, 12);
+    end.writeUInt32LE(directoryStart, 16);
+    await put(end);
+    return { bytes: offset };
+}