@plico-ai/runtime 0.0.0-reserved.0 → 0.1.0

package/dist/run/strategies/scripted.js

@@ -0,0 +1,106 @@
+import { RunCancelled } from "../../engine/index.js";
+import { RuntimeDiagnosticError } from "../../errors.js";
+import { approvalTimeoutMs, decideApproval } from "../../policy/approval.js";
+import { runToolStep } from "../tool-step.js";
+import { nameToolStep } from "../tracing.js";
+import { awaitApproval } from "./approval.js";
+export async function runScriptedDryRun(ctx, script, tools, events, eventStore, config, mockTools = false) {
+    const toolsByName = new Map(tools.map((tool) => [tool.name, tool]));
+    let output;
+    let workspaceId;
+    const artifactPaths = new Set();
+    const artifactVersions = new Map();
+    for (const [index, step] of script.entries()) {
+        if (step.type === "assistant.output") {
+            output = step.content;
+            await events.append("assistant.output", { content: step.content });
+            continue;
+        }
+        if (step.type === "artifact.write") {
+            if (workspaceId === undefined) {
+                workspaceId = `${ctx.runId}:workspace`;
+                await events.append("artifact.workspace.created", { workspaceId });
+            }
+            for (const file of step.files) {
+                artifactPaths.add(file.path);
+                const version = (artifactVersions.get(file.path) ?? 0) + 1;
+                artifactVersions.set(file.path, version);
+                await events.append("artifact.file.written", {
+                    path: file.path,
+                    content: file.content,
+                    mimeType: file.mimeType ?? "text/plain",
+                    version,
+                });
+            }
+            const snapshotId = `${ctx.runId}:snapshot:${index}`;
+            await events.append("artifact.snapshot.created", {
+                snapshotId,
+                fileCount: artifactPaths.size,
+            });
+            output = `Artifact workspace ${workspaceId} created with ${step.files.length} files`;
+            continue;
+        }
+        const tool = toolsByName.get(step.toolName);
+        if (!tool) {
+            throw new RuntimeDiagnosticError({
+                phase: "tool.validation",
+                toolName: step.toolName,
+                message: `Unknown tool: ${step.toolName}`,
+            });
+        }
+        await events.append("tool.call", {
+            toolName: tool.name,
+            arguments: step.arguments,
+        });
+        const parsedInput = await tool.parseInput(step.arguments);
+        if (!parsedInput.success) {
+            throw new RuntimeDiagnosticError({
+                phase: "tool.validation",
+                toolName: tool.name,
+                message: `Tool ${tool.name} arguments invalid: ${parsedInput.error}`,
+            });
+        }
+        const approval = decideApproval(tool, config);
+        if (approval.required) {
+            const requestId = `${ctx.runId}:${index}`;
+            await events.append("approval.requested", {
+                requestId,
+                toolName: tool.name,
+                arguments: step.arguments,
+                approval,
+            });
+            await events.append("run.waiting", {
+                requestId,
+                toolName: tool.name,
+                ...(output === undefined ? {} : { output }),
+            });
+            await awaitApproval(ctx, requestId, tool.name, output, events, approvalTimeoutMs(config));
+        }
+        if (mockTools && step.live !== true) {
+            if (!("result" in step)) {
+                throw new RuntimeDiagnosticError({
+                    phase: "tool.validation",
+                    toolName: tool.name,
+                    message: `Tool ${tool.name} has no mocked result. Add "result" to the step, or "live": true to run the real handler.`,
+                });
+            }
+            await events.append("tool.result", { toolName: tool.name, result: step.result });
+            continue;
+        }
+        const idempotencyKey = `${ctx.runId}:${index}`;
+        nameToolStep(ctx, `tool:${index}`, tool.name);
+        try {
+            await runToolStep(ctx, events, eventStore, tool, parsedInput.value, `tool:${index}`, idempotencyKey);
+        }
+        catch (error) {
+            if (error instanceof RunCancelled)
+                throw error;
+            throw new RuntimeDiagnosticError({
+                phase: "runtime",
+                toolName: tool.name,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return output;
+}

package/dist/run/tool-fingerprint.d.ts

@@ -0,0 +1,2 @@
+/** Hashes every TypeScript file under `tools/`, tool files and the helpers they import. */
+export declare function fingerprintTools(root: string): Promise<string>;

package/dist/run/tool-fingerprint.js

@@ -0,0 +1,26 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getProjectPaths } from "@plico-ai/core";
+async function toolFiles(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const path = join(directory, entry.name);
+        if (entry.isDirectory())
+            return entry.name === "node_modules" ? [] : toolFiles(path);
+        return entry.name.endsWith(".ts") ? [path] : [];
+    }));
+    return files.flat().sort();
+}
+/** Hashes every TypeScript file under `tools/`, tool files and the helpers they import. */
+export async function fingerprintTools(root) {
+    const directory = getProjectPaths(root).directories.tools;
+    const hash = createHash("sha256");
+    for (const file of await toolFiles(directory)) {
+        hash.update(file.slice(directory.length).replaceAll("\\", "/"));
+        hash.update("\0");
+        hash.update(await readFile(file));
+        hash.update("\0");
+    }
+    return hash.digest("hex");
+}

package/dist/run/tool-step.d.ts

@@ -0,0 +1,4 @@
+import type { RunContext } from "../engine/index.js";
+import type { InMemoryEventLog } from "../events.js";
+import type { DeclaredTool, EventStore } from "../types/index.js";
+export declare function runToolStep(ctx: RunContext, events: InMemoryEventLog, eventStore: EventStore | undefined, tool: DeclaredTool, input: unknown, stepName: string, idempotencyKey: string): Promise<unknown>;

package/dist/run/tool-step.js

@@ -0,0 +1,62 @@
+import { encodeArtifactContent } from "../artifacts.js";
+import { artifactWriteEventPayload, createStagedArtifactContext, } from "./artifact-tool-context.js";
+export async function runToolStep(ctx, events, eventStore, tool, input, stepName, idempotencyKey) {
+    const started = events.all().find((event) => event.type === "run.started");
+    const threadId = started?.payload.threadId;
+    const context = started?.payload.context;
+    let staged;
+    const workspaceId = threadId ? `${threadId}:workspace` : `${ctx.runId}:workspace`;
+    const ensureStaged = async () => {
+        if (staged)
+            return staged;
+        const threadHistory = threadId && eventStore?.getThreadRunEvents
+            ? (await eventStore.getThreadRunEvents(threadId)).filter((event) => event.runId !== ctx.runId)
+            : [];
+        staged = createStagedArtifactContext(ctx.runId, threadId, [...threadHistory, ...events.all()]);
+        return staged;
+    };
+    const artifacts = {
+        async read(path) {
+            return (await ensureStaged()).context.read(path);
+        },
+        async write(path, content, options) {
+            return (await ensureStaged()).context.write(path, content, options);
+        },
+        async list() {
+            return (await ensureStaged()).context.list();
+        },
+    };
+    const recorded = await ctx.step(stepName, async ({ signal }) => {
+        const result = await tool.handler(input, {
+            signal,
+            idempotencyKey,
+            artifacts,
+            ...(context === undefined ? {} : { context }),
+        });
+        return {
+            result: normalizeToolResult(result),
+            writes: staged?.writes() ?? [],
+            createWorkspace: staged?.workspaceCreated() ?? false,
+            workspaceId: staged?.workspaceId ?? workspaceId,
+        };
+    });
+    await events.append("tool.result", { toolName: tool.name, result: recorded.result });
+    if (recorded.createWorkspace) {
+        await events.append("artifact.workspace.created", { workspaceId: recorded.workspaceId });
+    }
+    for (const write of recorded.writes) {
+        await events.append("artifact.file.written", artifactWriteEventPayload(write));
+    }
+    return recorded.result;
+}
+function normalizeToolResult(value) {
+    if (value instanceof Uint8Array)
+        return encodeArtifactContent(value);
+    if (Array.isArray(value))
+        return value.map(normalizeToolResult);
+    if (value !== null &&
+        typeof value === "object" &&
+        Object.getPrototypeOf(value) === Object.prototype)
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizeToolResult(entry)]));
+    return value;
+}

package/dist/run/tracing.d.ts

@@ -0,0 +1,12 @@
+import { type Span, type SpanContext } from "@opentelemetry/api";
+import type { RunContext } from "../engine/index.js";
+export type StoredSpanContext = Pick<SpanContext, "traceId" | "spanId" | "traceFlags"> & {
+    traceState?: string;
+};
+export declare function storeSpanContext(span: Span): StoredSpanContext;
+export declare function nameToolStep(ctx: RunContext, step: string, tool: string): void;
+export declare function startRunSpan(runId: string, stored?: StoredSpanContext): Span;
+export declare function tracedContext(ctx: RunContext, runSpan: Span, model?: {
+    name: string;
+    provider: string;
+}): RunContext;

package/dist/run/tracing.js

@@ -0,0 +1,92 @@
+import { context, createTraceState, ROOT_CONTEXT, SpanStatusCode, trace, } from "@opentelemetry/api";
+const getTracer = () => trace.getTracer("@plico-ai/runtime");
+const toolNames = new WeakMap();
+export function storeSpanContext(span) {
+    const { traceId, spanId, traceFlags, traceState } = span.spanContext();
+    return {
+        traceId,
+        spanId,
+        traceFlags,
+        ...(traceState ? { traceState: traceState.serialize() } : {}),
+    };
+}
+export function nameToolStep(ctx, step, tool) {
+    toolNames.get(ctx)?.set(step, tool);
+}
+export function startRunSpan(runId, stored) {
+    const previous = stored && {
+        traceId: stored.traceId,
+        spanId: stored.spanId,
+        traceFlags: stored.traceFlags,
+        ...(typeof stored.traceState === "string"
+            ? { traceState: createTraceState(stored.traceState) }
+            : {}),
+    };
+    return getTracer().startSpan("plico.run", {
+        attributes: { "plico.run.id": runId },
+        ...(previous && trace.isSpanContextValid(previous) ? { links: [{ context: previous }] } : {}),
+    });
+}
+export function tracedContext(ctx, runSpan, model) {
+    const names = new Map();
+    const wrapped = {
+        get runId() {
+            return ctx.runId;
+        },
+        get signal() {
+            return ctx.signal;
+        },
+        wait: (name, options) => ctx.wait(name, options),
+        step: (name, fn, options) => {
+            const step = getTracer().startSpan("plico.step", { attributes: { "plico.step.name": name } }, trace.setSpan(ROOT_CONTEXT, runSpan));
+            return ctx
+                .step(name, async (attempt) => {
+                const tool = names.get(name);
+                const modelCall = name.startsWith("model:");
+                const child = getTracer().startSpan(modelCall
+                    ? `chat ${model?.name ?? "model"}`
+                    : tool
+                        ? `execute_tool ${tool}`
+                        : "plico.attempt", {
+                    attributes: {
+                        "plico.step.attempt": attempt.attempt,
+                        ...(tool
+                            ? { "gen_ai.operation.name": "execute_tool", "gen_ai.tool.name": tool }
+                            : {}),
+                        ...(modelCall
+                            ? {
+                                "gen_ai.operation.name": "chat",
+                                ...(model
+                                    ? {
+                                        "gen_ai.request.model": model.name,
+                                        "gen_ai.provider.name": model.provider,
+                                    }
+                                    : {}),
+                            }
+                            : {}),
+                    },
+                }, trace.setSpan(ROOT_CONTEXT, step));
+                try {
+                    return await context.with(trace.setSpan(context.active(), child), () => fn(attempt));
+                }
+                catch (error) {
+                    child.setStatus({ code: SpanStatusCode.ERROR });
+                    throw error;
+                }
+                finally {
+                    child.end();
+                }
+            }, options)
+                .then((value) => {
+                step.end();
+                return value;
+            }, (error) => {
+                step.setStatus({ code: SpanStatusCode.ERROR });
+                step.end();
+                throw error;
+            });
+        },
+    };
+    toolNames.set(wrapped, names);
+    return wrapped;
+}

package/dist/script.d.ts

@@ -0,0 +1,4 @@
+import type { DryRunScriptStep } from "./types/index.js";
+export declare class ScriptValidationError extends Error {
+}
+export declare function normalizeScript(value: unknown): DryRunScriptStep[];

package/dist/script.js

@@ -0,0 +1,51 @@
+export class ScriptValidationError extends Error {
+}
+export function normalizeScript(value) {
+    if (!Array.isArray(value))
+        throw new ScriptValidationError("script must be an array.");
+    return value.map(normalizeStep);
+}
+function normalizeStep(step, index) {
+    const prefix = `script step ${index + 1}`;
+    if (!isRecord(step) || typeof step.type !== "string") {
+        throw new ScriptValidationError(`${prefix} must include a type.`);
+    }
+    if (step.type === "assistant.output") {
+        if (typeof step.content !== "string") {
+            throw new ScriptValidationError(`${prefix} must include content.`);
+        }
+        return { type: "assistant.output", content: step.content };
+    }
+    if (step.type === "tool.call") {
+        if (typeof step.toolName !== "string") {
+            throw new ScriptValidationError(`${prefix} must include a toolName.`);
+        }
+        return {
+            type: "tool.call",
+            toolName: step.toolName,
+            arguments: step.arguments,
+            ...("result" in step ? { result: step.result } : {}),
+            ...(step.live === true ? { live: true } : {}),
+        };
+    }
+    if (step.type === "artifact.write") {
+        if (!Array.isArray(step.files)) {
+            throw new ScriptValidationError(`${prefix} must include a files array.`);
+        }
+        const files = step.files.map((file, fileIndex) => {
+            if (!isRecord(file) || typeof file.path !== "string" || typeof file.content !== "string") {
+                throw new ScriptValidationError(`${prefix} file ${fileIndex + 1} must have path and content strings.`);
+            }
+            return {
+                path: file.path,
+                content: file.content,
+                ...(typeof file.mimeType === "string" ? { mimeType: file.mimeType } : {}),
+            };
+        });
+        return { type: "artifact.write", files };
+    }
+    throw new ScriptValidationError(`${prefix} has an unsupported type.`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/storage/index.d.ts

@@ -0,0 +1 @@
+export { createSqliteEventStore } from "./sqlite/index.js";

package/dist/storage/index.js

@@ -0,0 +1 @@
+export { createSqliteEventStore } from "./sqlite/index.js";

package/dist/storage/metadata.d.ts

@@ -0,0 +1,5 @@
+import type { JsonValue } from "@plico-ai/contracts";
+export type Metadata = Record<string, JsonValue>;
+/** True when every top-level key of `filter` equals the same key of `metadata`, compared as JSON. */
+export declare function matchesMetadata(metadata: Metadata | undefined, filter: Metadata | undefined): boolean;
+export declare function parseMetadata(json: unknown): Metadata | undefined;

package/dist/storage/metadata.js

@@ -0,0 +1,26 @@
+/** True when every top-level key of `filter` equals the same key of `metadata`, compared as JSON. */
+export function matchesMetadata(metadata, filter) {
+    if (filter === undefined)
+        return true;
+    return Object.entries(filter).every(([key, value]) => metadata !== undefined &&
+        Object.hasOwn(metadata, key) &&
+        sameJson(metadata[key], value));
+}
+function sameJson(left, right) {
+    if (left === right)
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return (Array.isArray(left) &&
+            Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((item, index) => sameJson(item, right[index])));
+    }
+    if (left === null || right === null || typeof left !== "object" || typeof right !== "object")
+        return false;
+    const keys = Object.keys(left);
+    return (keys.length === Object.keys(right).length &&
+        keys.every((key) => Object.hasOwn(right, key) && sameJson(left[key], right[key])));
+}
+export function parseMetadata(json) {
+    return typeof json === "string" ? JSON.parse(json) : undefined;
+}

package/dist/storage/sqlite/append-event.d.ts

@@ -0,0 +1,3 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { PlicoEvent } from "@plico-ai/contracts";
+export declare function appendEventRecord(database: DatabaseSync, event: PlicoEvent): void;

package/dist/storage/sqlite/append-event.js

@@ -0,0 +1,108 @@
+import { artifactContentBytes, hashArtifactContent } from "../../artifacts.js";
+import { acquireOwner } from "./owner-lock.js";
+import { projectThreadEvent } from "./project-thread.js";
+export function appendEventRecord(database, event) {
+    if (event.streamType !== "run" || event.streamId !== event.runId) {
+        throw new Error("Event must belong to its run stream.");
+    }
+    database.exec("BEGIN IMMEDIATE");
+    try {
+        const payload = compactArtifactPayload(database, event);
+        const existing = database
+            .prepare("SELECT event_id, type, timestamp, payload_json FROM events WHERE stream_type = ? AND stream_id = ? AND sequence = ?")
+            .get(event.streamType, event.streamId, event.sequence);
+        if (existing) {
+            if (existing.event_id !== event.id ||
+                existing.type !== event.type ||
+                existing.timestamp !== event.timestamp ||
+                existing.payload_json !== JSON.stringify(payload)) {
+                throw new Error(`Conflicting event at sequence ${event.sequence}.`);
+            }
+            database.exec("COMMIT");
+            return;
+        }
+        const row = database.prepare("SELECT status FROM runs WHERE run_id = ?").get(event.runId);
+        const last = database
+            .prepare("SELECT sequence, type FROM events WHERE stream_type = ? AND stream_id = ? ORDER BY sequence DESC LIMIT 1")
+            .get(event.streamType, event.streamId);
+        if (event.sequence !== (last?.sequence ?? 0) + 1)
+            throw new Error("Events must be appended in sequence.");
+        if (last?.type === "run.error" && event.type !== "run.failed") {
+            throw new Error("run.error must be followed by run.failed.");
+        }
+        if (!row) {
+            if (event.type !== "run.started" || event.sequence !== 1)
+                throw new Error("The first event must be run.started.");
+            database
+                .prepare("INSERT INTO runs (run_id, project_root, project_name, status, started_at, ended_at, metadata_json) VALUES (?, ?, ?, 'running', ?, NULL, ?)")
+                .run(event.runId, String(event.payload.projectRoot ?? ""), String(event.payload.projectName ?? ""), event.timestamp, event.payload.metadata === undefined ? null : JSON.stringify(event.payload.metadata));
+            const owner = acquireOwner();
+            database
+                .prepare("INSERT INTO run_owners (run_id, process_id, owner_token, owner_path) VALUES (?, ?, ?, ?)")
+                .run(event.runId, process.pid, owner.token, owner.path);
+        }
+        else {
+            if (row.status === "waiting") {
+                // The first event after run.waiting is the run continuing, so the log alone says it is running.
+                database
+                    .prepare("UPDATE runs SET status = 'running', ended_at = NULL WHERE run_id = ?")
+                    .run(event.runId);
+                const owner = acquireOwner();
+                database
+                    .prepare("INSERT OR REPLACE INTO run_owners (run_id, process_id, owner_token, owner_path) VALUES (?, ?, ?, ?)")
+                    .run(event.runId, process.pid, owner.token, owner.path);
+            }
+            else if (row.status !== "running") {
+                throw new Error(`Cannot append to run with status ${row.status}.`);
+            }
+            if (event.type === "run.started")
+                throw new Error("Run has already started.");
+            const status = event.type === "run.waiting"
+                ? "waiting"
+                : event.type === "run.completed"
+                    ? "completed"
+                    : event.type === "run.failed"
+                        ? "failed"
+                        : event.type === "run.cancelled"
+                            ? "cancelled"
+                            : undefined;
+            if (status) {
+                const endedAt = status === "waiting" ? null : event.timestamp;
+                const output = (event.type === "run.completed" || event.type === "run.waiting") &&
+                    typeof event.payload.output === "string"
+                    ? event.payload.output
+                    : null;
+                database
+                    .prepare("UPDATE runs SET status = ?, ended_at = ?, output = ? WHERE run_id = ?")
+                    .run(status, endedAt, output, event.runId);
+                // Drop the owner once the run leaves running, including waiting; recovery only inspects running runs.
+                database.prepare("DELETE FROM run_owners WHERE run_id = ?").run(event.runId);
+            }
+        }
+        database
+            .prepare("INSERT INTO events (stream_type, stream_id, sequence, event_id, schema_version, type, timestamp, payload_json) VALUES (?, ?, ?, ?, ?, ?, ?, ?)")
+            .run(event.streamType, event.streamId, event.sequence, event.id, event.schemaVersion, event.type, event.timestamp, JSON.stringify(payload));
+        projectThreadEvent(database, event);
+        database.exec("COMMIT");
+    }
+    catch (error) {
+        database.exec("ROLLBACK");
+        throw error;
+    }
+}
+function compactArtifactPayload(database, event) {
+    if (event.type !== "artifact.file.written")
+        return event.payload;
+    const { content, contentHash: declaredHash, ...receipt } = event.payload;
+    const actualHash = hashArtifactContent(content);
+    if (declaredHash !== undefined && actualHash !== declaredHash)
+        throw new Error("Artifact content hash does not match its content.");
+    database
+        .prepare("INSERT OR IGNORE INTO artifact_content (content_hash, content) VALUES (?, ?)")
+        .run(actualHash, Buffer.from(artifactContentBytes(content)));
+    return {
+        ...receipt,
+        ...(typeof content === "string" ? {} : { contentEncoding: "base64" }),
+        contentHash: actualHash,
+    };
+}

package/dist/storage/sqlite/driver.d.ts

@@ -0,0 +1,9 @@
+import type { DatabaseSync } from "node:sqlite";
+type SqliteSource = ConstructorParameters<typeof DatabaseSync>[0];
+type SqliteOptions = ConstructorParameters<typeof DatabaseSync>[1];
+/**
+ * Opens a SQLite database, loading `node:sqlite` on first use. Importing it eagerly would print
+ * Node's experimental warning for commands that never touch a database, such as `--version`.
+ */
+export declare function createDatabase(path: SqliteSource, options?: SqliteOptions): DatabaseSync;
+export {};

package/dist/storage/sqlite/driver.js

@@ -0,0 +1,13 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+let sqlite;
+/**
+ * Opens a SQLite database, loading `node:sqlite` on first use. Importing it eagerly would print
+ * Node's experimental warning for commands that never touch a database, such as `--version`.
+ */
+export function createDatabase(path, options) {
+    sqlite ??= require("node:sqlite");
+    return options === undefined
+        ? new sqlite.DatabaseSync(path)
+        : new sqlite.DatabaseSync(path, options);
+}

package/dist/storage/sqlite/index.d.ts

@@ -0,0 +1 @@
+export { createSqliteEventStore } from "./store.js";

package/dist/storage/sqlite/index.js

@@ -0,0 +1 @@
+export { createSqliteEventStore } from "./store.js";

package/dist/storage/sqlite/open.d.ts

@@ -0,0 +1,3 @@
+import type { DatabaseSync } from "node:sqlite";
+/** Opens the database with the pragma order and migrator every Plico store shares. */
+export declare function openDatabase(databasePath: string, readOnly?: boolean): DatabaseSync;

package/dist/storage/sqlite/open.js

@@ -0,0 +1,54 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createDatabase } from "./driver.js";
+import { checkReadOnlySchema, initializeSchema } from "./schema.js";
+/** Opens the database with the pragma order and migrator every Plico store shares. */
+export function openDatabase(databasePath, readOnly = false) {
+    if (!readOnly)
+        mkdirSync(dirname(databasePath), { recursive: true });
+    const database = createDatabase(readOnly ? readOnlySource(databasePath) : databasePath, {
+        readOnly,
+    });
+    try {
+        database.exec("PRAGMA busy_timeout = 5000;");
+        if (!readOnly) {
+            setWalMode(database);
+            initializeSchema(database);
+        }
+        else {
+            checkReadOnlySchema(database);
+        }
+    }
+    catch (error) {
+        database.close();
+        throw error;
+    }
+    return database;
+}
+function setWalMode(database) {
+    // Changing journal mode may return SQLITE_BUSY immediately even with busy_timeout set.
+    const deadline = Date.now() + 5000;
+    const pause = new Int32Array(new SharedArrayBuffer(4));
+    while (true) {
+        try {
+            database.exec("PRAGMA journal_mode = WAL;");
+            return;
+        }
+        catch (error) {
+            const code = error.errcode;
+            if (code === undefined || (code & 0xff) !== 5 || Date.now() >= deadline)
+                throw error;
+            Atomics.wait(pause, 0, 0, Math.min(25, deadline - Date.now()));
+        }
+    }
+}
+// A plain read-only open of a WAL database creates -shm and -wal files. Immutable mode
+// avoids them but ignores WAL content, so it is only safe when no -wal file exists.
+function readOnlySource(databasePath) {
+    if (existsSync(`${databasePath}-wal`))
+        return databasePath;
+    const url = pathToFileURL(databasePath);
+    url.searchParams.set("immutable", "1");
+    return url;
+}

package/dist/storage/sqlite/owner-lock.d.ts

@@ -0,0 +1,5 @@
+export declare function acquireOwner(): {
+    token: string;
+    path: string;
+};
+export declare function ownerIsAlive(token: string, path: string): boolean;