@plico-ai/runtime 0.0.0-stage → 0.1.0

package/dist/engine/engine.js

@@ -0,0 +1,235 @@
+import { randomUUID } from "node:crypto";
+import { createContext, toJson } from "./context.js";
+import { RunCancelled, RunSuspended } from "./errors.js";
+export const defaultLeaseMs = 30_000;
+export function createEngine({ journal, workerId = randomUUID(), leaseMs = defaultLeaseMs, now = Date.now, }) {
+    const lease = () => ({ workerId, until: now() + leaseMs });
+    /** Runs this process can continue by itself when a signal or timeout arrives. */
+    const registered = new Map();
+    /** Runs executing in this process right now. */
+    const active = new Set();
+    const timers = new Map();
+    /** Aborts the step a run is executing here when it is cancelled. */
+    const controllers = new Map();
+    function stopTimer(runId) {
+        clearTimeout(timers.get(runId));
+        timers.delete(runId);
+    }
+    /** Runs the workflow, replaying it each time a wait ends, until it completes or must wait. */
+    async function execute(runId, workflow, input) {
+        registered.set(runId, { workflow, input });
+        stopTimer(runId);
+        const controller = new AbortController();
+        controllers.set(runId, controller);
+        const heartbeat = setInterval(() => {
+            journal.renew(runId, lease()).catch(() => undefined);
+            // Cancel may have been requested from another process.
+            journal
+                .getRun(runId)
+                .then((run) => run?.cancelRequested && controller.abort())
+                .catch(() => undefined);
+        }, leaseMs / 3);
+        heartbeat.unref();
+        try {
+            for (;;) {
+                const ctx = createContext(runId, journal, now, controller.signal);
+                let output;
+                let returned = false;
+                try {
+                    output = await workflow(ctx, input);
+                    returned = true;
+                }
+                catch (error) {
+                    if (!(error instanceof RunSuspended || error instanceof RunCancelled))
+                        throw error;
+                }
+                if (ctx.cancelled()) {
+                    await journal.setState(runId, "cancelled");
+                    registered.delete(runId);
+                    return returned ? { state: "cancelled", output: output } : { state: "cancelled" };
+                }
+                const suspension = ctx.suspension();
+                if (!suspension) {
+                    await journal.setState(runId, "completed");
+                    registered.delete(runId);
+                    return { state: "completed", output: output };
+                }
+                await journal.setState(runId, "waiting");
+                // A signal or timeout that landed while the run was stopping must not be lost.
+                const wait = await journal.getWait(runId, suspension.name);
+                const ready = (await journal.getRun(runId))?.cancelRequested === true ||
+                    (await journal.getSignal(runId, suspension.name)) !== undefined ||
+                    (wait?.deadline != null && now() >= wait.deadline);
+                if (ready) {
+                    if (await journal.claimWaiting(runId, lease()))
+                        continue;
+                    // Another worker took the run; report what this execution produced before it stopped.
+                    return returned ? { state: "waiting", output: output } : { state: "waiting" };
+                }
+                if (suspension.deadline !== null) {
+                    const delay = Math.max(0, suspension.deadline - now());
+                    const timer = setTimeout(() => resumeHere(runId).catch(() => undefined), delay);
+                    timer.unref();
+                    timers.set(runId, timer);
+                }
+                return returned ? { state: "waiting", output: output } : { state: "waiting" };
+            }
+        }
+        catch (error) {
+            await journal.setState(runId, "failed");
+            registered.delete(runId);
+            throw error;
+        }
+        finally {
+            clearInterval(heartbeat);
+            controllers.delete(runId);
+            active.delete(runId);
+        }
+    }
+    /** Continues a waiting run this process started, once its wait can end. */
+    async function resumeHere(runId) {
+        const known = registered.get(runId);
+        if (!known || active.has(runId))
+            return;
+        active.add(runId);
+        try {
+            const run = await journal.getRun(runId);
+            if (run?.state !== "waiting") {
+                active.delete(runId);
+                return;
+            }
+            if (!(await journal.claimWaiting(runId, lease()))) {
+                active.delete(runId);
+                return;
+            }
+        }
+        catch (error) {
+            active.delete(runId);
+            throw error;
+        }
+        // Everything the run did is in the event log; its outcome here has no reader.
+        execute(runId, known.workflow, known.input).catch(() => undefined);
+    }
+    async function start(runId, workflow, input) {
+        const inputJson = toJson(input);
+        if (!(await journal.begin(runId, inputJson, lease()))) {
+            throw new Error(`Run ${runId} already exists.`);
+        }
+        active.add(runId);
+        const result = execute(runId, workflow, JSON.parse(inputJson));
+        // The handle's reader observes the failure; this keeps an unread handle from crashing the process.
+        result.catch(() => undefined);
+        return { runId, result: () => result };
+    }
+    return {
+        start,
+        async run(runId, workflow, input) {
+            return (await start(runId, workflow, input)).result();
+        },
+        async resume(runId, workflow) {
+            const run = await journal.getRun(runId);
+            if (!run)
+                throw new Error(`Run ${runId} is unknown.`);
+            if (run.state === "completed" || run.state === "cancelled")
+                throw new Error(`Run ${runId} already finished.`);
+            if (run.state === "running") {
+                const stale = (await journal.listStale(workerId, now())).find((item) => item.runId === runId);
+                if (!stale || !(await journal.claim(runId, lease(), stale.held)))
+                    throw new Error(`Run ${runId} is held by a live worker or its lease changed.`);
+            }
+            else if (!(await (run.state === "waiting"
+                ? journal.claimWaiting(runId, lease())
+                : journal.claim(runId, lease())))) {
+                throw new Error(`Run ${runId} could not be claimed.`);
+            }
+            active.add(runId);
+            return execute(runId, workflow, JSON.parse(run.inputJson));
+        },
+        async signal(runId, name, value) {
+            const run = await journal.getRun(runId);
+            if (!run)
+                return "unknown";
+            if (["completed", "failed", "cancelled"].includes(run.state))
+                return "ignored";
+            const wait = await journal.getWait(runId, name);
+            if (wait?.outcomeJson != null)
+                return "ignored";
+            if (wait?.deadline != null && now() >= wait.deadline) {
+                // The deadline passed first: the wait ends as a timeout and this decision is late.
+                await journal.resolveWait(runId, name, JSON.stringify({ kind: "timeout" }));
+                resumeHere(runId).catch(() => undefined);
+                return "ignored";
+            }
+            if (!(await journal.putSignal(runId, name, toJson(value))))
+                return "ignored";
+            resumeHere(runId).catch(() => undefined);
+            return "accepted";
+        },
+        async cancel(runId) {
+            const run = await journal.getRun(runId);
+            if (!run)
+                return "unknown";
+            if (!(await journal.requestCancel(runId)))
+                return "ignored";
+            const running = controllers.get(runId);
+            if (running)
+                running.abort();
+            else
+                resumeHere(runId).catch(() => undefined);
+            return "accepted";
+        },
+        async recover(resolve) {
+            for (const { runId, deadline } of await journal.listWaiting()) {
+                if (active.has(runId) || registered.has(runId))
+                    continue;
+                const run = await journal.getRun(runId);
+                if (!run || run.state !== "waiting")
+                    continue;
+                const input = JSON.parse(run.inputJson);
+                const workflow = resolve(runId, input);
+                if (!workflow)
+                    continue;
+                registered.set(runId, { workflow, input });
+                if (deadline !== null) {
+                    const timer = setTimeout(() => resumeHere(runId).catch(() => undefined), Math.max(0, deadline - now()));
+                    timer.unref();
+                    timers.set(runId, timer);
+                }
+            }
+            const candidates = [
+                ...(await journal.listStale(workerId, now())).map((item) => ({ ...item, waiting: false })),
+                ...(await journal.listReady(now())).map((item) => ({ ...item, waiting: true })),
+            ];
+            const recovered = [];
+            for (const { runId, held, waiting } of candidates) {
+                if (active.has(runId))
+                    continue;
+                const run = await journal.getRun(runId);
+                if (!run)
+                    continue;
+                const input = JSON.parse(run.inputJson);
+                const workflow = resolve(runId, input);
+                if (!workflow ||
+                    !(await (waiting
+                        ? journal.claimWaiting(runId, lease(), held)
+                        : journal.claim(runId, lease(), held))))
+                    continue;
+                active.add(runId);
+                recovered.push(execute(runId, workflow, input).then((outcome) => ({
+                    runId,
+                    state: outcome.state,
+                    ...(outcome.output === undefined ? {} : { output: outcome.output }),
+                }), (error) => ({
+                    runId,
+                    state: "failed",
+                    error: error instanceof Error ? error.message : String(error),
+                })));
+            }
+            return Promise.all(recovered);
+        },
+        async status(runId) {
+            const run = await journal.getRun(runId);
+            return run && { state: run.state };
+        },
+    };
+}

package/dist/engine/errors.d.ts

@@ -0,0 +1,12 @@
+export declare class ProjectChangedError extends Error {
+    constructor(what: "step" | "event", index: number, recorded: string, current: string);
+}
+/** Thrown by `ctx.wait` when the run must stop and wait. Not a failure. */
+export declare class RunSuspended extends Error {
+    readonly waitName: string;
+    constructor(waitName: string);
+}
+/** Thrown by `ctx.step` and `ctx.wait` once the run is cancelled. Not a failure. */
+export declare class RunCancelled extends Error {
+    constructor();
+}

package/dist/engine/errors.js

@@ -0,0 +1,19 @@
+export class ProjectChangedError extends Error {
+    constructor(what, index, recorded, current) {
+        super(`Project changed during run: ${what} ${index + 1} was "${recorded}", now "${current}".`);
+    }
+}
+/** Thrown by `ctx.wait` when the run must stop and wait. Not a failure. */
+export class RunSuspended extends Error {
+    waitName;
+    constructor(waitName) {
+        super(`Run is waiting for ${waitName}.`);
+        this.waitName = waitName;
+    }
+}
+/** Thrown by `ctx.step` and `ctx.wait` once the run is cancelled. Not a failure. */
+export class RunCancelled extends Error {
+    constructor() {
+        super("Run was cancelled.");
+    }
+}

package/dist/engine/index.d.ts

@@ -0,0 +1,7 @@
+export { createEngine, defaultLeaseMs, type EngineOptions } from "./engine.js";
+export { ProjectChangedError, RunCancelled, RunSuspended } from "./errors.js";
+export type { Journal, JournalRun, JournalStep, JournalWait, Lease } from "./journal.js";
+export { createMemoryJournal } from "./memory-journal.js";
+export { createSqliteEngine, type SqliteEngineOptions } from "./sqlite-engine.js";
+export { createSqliteJournal } from "./sqlite-journal.js";
+export type { CancelResult, Engine, ExecutionState, ExecutionStatus, RecoveredRun, RunContext, RunHandle, RunOutcome, SignalResult, StepAttempt, StepOptions, WaitOptions, WaitOutcome, Workflow, } from "./types.js";

package/dist/engine/index.js

@@ -0,0 +1,5 @@
+export { createEngine, defaultLeaseMs } from "./engine.js";
+export { ProjectChangedError, RunCancelled, RunSuspended } from "./errors.js";
+export { createMemoryJournal } from "./memory-journal.js";
+export { createSqliteEngine } from "./sqlite-engine.js";
+export { createSqliteJournal } from "./sqlite-journal.js";

package/dist/engine/journal.d.ts

@@ -0,0 +1,65 @@
+import type { ExecutionState } from "./types.js";
+export interface JournalRun {
+    runId: string;
+    state: ExecutionState;
+    inputJson: string;
+    cancelRequested: boolean;
+}
+export interface JournalStep {
+    name: string;
+    resultJson: string;
+}
+/** A worker's hold on a running run. `until` is epoch milliseconds. */
+export interface Lease {
+    workerId: string;
+    until: number;
+}
+export interface JournalWait {
+    /** Epoch milliseconds, or null for a wait with no timeout. */
+    deadline: number | null;
+    /** Set once the wait ended; null while it is open. */
+    outcomeJson: string | null;
+}
+/** The engine's private record of where each run resumes. It never says what happened; events do. */
+export interface Journal {
+    /** Creates the run, held by `lease`. Returns false when the id is already taken. */
+    begin(runId: string, inputJson: string, lease: Lease): Promise<boolean>;
+    getRun(runId: string): Promise<JournalRun | undefined>;
+    setState(runId: string, state: ExecutionState): Promise<void>;
+    /** Extends the lease if `lease.workerId` still holds the run. */
+    renew(runId: string, lease: Lease): Promise<void>;
+    /**
+     * Makes `lease.workerId` the holder and sets the run running. With `expected`, it only does so
+     * when that holder still has the run, so two recoverers cannot both win.
+     */
+    claim(runId: string, lease: Lease, expected?: Lease): Promise<boolean>;
+    /** Atomically claims a waiting run; only one contender can transition it to running. */
+    claimWaiting(runId: string, lease: Lease, expected?: Lease): Promise<boolean>;
+    /** Running runs another worker held and lost: its lease ran out or its process is gone. */
+    listStale(workerId: string, now: number): Promise<Array<{
+        runId: string;
+        held: Lease;
+    }>>;
+    /** Waiting runs that can move on now: a wait has a signal or passed its deadline, or cancel was requested. */
+    listReady(now: number): Promise<Array<{
+        runId: string;
+        held: Lease;
+    }>>;
+    listWaiting(): Promise<Array<{
+        runId: string;
+        deadline: number | null;
+    }>>;
+    /** Marks the run cancelled-on-next-chance. Returns false when it already finished or was marked. */
+    requestCancel(runId: string): Promise<boolean>;
+    getWait(runId: string, name: string): Promise<JournalWait | undefined>;
+    /** Opens the wait with its deadline. A second open changes nothing, so a replay keeps the deadline. */
+    openWait(runId: string, name: string, deadline: number | null): Promise<void>;
+    /** Ends the wait. Returns false when it had already ended. */
+    resolveWait(runId: string, name: string, outcomeJson: string): Promise<boolean>;
+    /** Stores a signal. Returns false when one is already stored for the name. */
+    putSignal(runId: string, name: string, valueJson: string): Promise<boolean>;
+    getSignal(runId: string, name: string): Promise<string | undefined>;
+    getStep(runId: string, index: number): Promise<JournalStep | undefined>;
+    /** Records a step once. A second write at the same index changes nothing. */
+    putStep(runId: string, index: number, step: JournalStep): Promise<void>;
+}

package/dist/engine/journal.js

@@ -0,0 +1 @@
+export {};

package/dist/engine/memory-journal.d.ts

@@ -0,0 +1,2 @@
+import type { Journal } from "./journal.js";
+export declare function createMemoryJournal(): Journal;

package/dist/engine/memory-journal.js

@@ -0,0 +1,125 @@
+export function createMemoryJournal() {
+    const runs = new Map();
+    const steps = new Map();
+    const waits = new Map();
+    const signals = new Map();
+    return {
+        async begin(runId, inputJson, lease) {
+            if (runs.has(runId))
+                return false;
+            runs.set(runId, { runId, state: "running", inputJson, cancelRequested: false, lease });
+            return true;
+        },
+        async getRun(runId) {
+            const run = runs.get(runId);
+            return (run && {
+                runId,
+                state: run.state,
+                inputJson: run.inputJson,
+                cancelRequested: run.cancelRequested,
+            });
+        },
+        async setState(runId, state) {
+            const run = runs.get(runId);
+            if (run)
+                run.state = state;
+        },
+        async renew(runId, lease) {
+            const run = runs.get(runId);
+            if (run?.lease.workerId === lease.workerId)
+                run.lease = lease;
+        },
+        async claim(runId, lease, expected) {
+            const run = runs.get(runId);
+            if (!run)
+                return false;
+            if (expected &&
+                (run.lease.workerId !== expected.workerId || run.lease.until !== expected.until)) {
+                return false;
+            }
+            run.lease = lease;
+            run.state = "running";
+            return true;
+        },
+        async claimWaiting(runId, lease, expected) {
+            const run = runs.get(runId);
+            if (!run || run.state !== "waiting")
+                return false;
+            if (expected &&
+                (run.lease.workerId !== expected.workerId || run.lease.until !== expected.until))
+                return false;
+            run.lease = lease;
+            run.state = "running";
+            return true;
+        },
+        async listStale(workerId, now) {
+            return [...runs.values()]
+                .filter((run) => run.state === "running" && run.lease.workerId !== workerId && run.lease.until < now)
+                .map((run) => ({ runId: run.runId, held: run.lease }));
+        },
+        async listReady(now) {
+            return [...runs.values()]
+                .filter((run) => {
+                if (run.state !== "waiting")
+                    return false;
+                if (run.cancelRequested)
+                    return true;
+                return [...waits.entries()].some(([key, wait]) => {
+                    if (!key.startsWith(`${run.runId}\u0000`) || wait.outcomeJson !== null)
+                        return false;
+                    return signals.has(key) || (wait.deadline !== null && wait.deadline <= now);
+                });
+            })
+                .map((run) => ({ runId: run.runId, held: run.lease }));
+        },
+        async requestCancel(runId) {
+            const run = runs.get(runId);
+            if (!run || run.cancelRequested || ["completed", "failed", "cancelled"].includes(run.state)) {
+                return false;
+            }
+            run.cancelRequested = true;
+            return true;
+        },
+        async listWaiting() {
+            return [...runs.values()]
+                .filter((run) => run.state === "waiting")
+                .flatMap((run) => [...waits.entries()]
+                .filter(([key, wait]) => key.startsWith(`${run.runId}\0`) && wait.outcomeJson === null)
+                .map(([, wait]) => ({ runId: run.runId, deadline: wait.deadline })));
+        },
+        async getWait(runId, name) {
+            const wait = waits.get(`${runId}\u0000${name}`);
+            return wait && { ...wait };
+        },
+        async openWait(runId, name, deadline) {
+            const key = `${runId}\u0000${name}`;
+            if (!waits.has(key))
+                waits.set(key, { deadline, outcomeJson: null });
+        },
+        async resolveWait(runId, name, outcomeJson) {
+            const wait = waits.get(`${runId}\u0000${name}`);
+            if (!wait || wait.outcomeJson !== null)
+                return false;
+            wait.outcomeJson = outcomeJson;
+            return true;
+        },
+        async putSignal(runId, name, valueJson) {
+            const key = `${runId}\u0000${name}`;
+            if (signals.has(key))
+                return false;
+            signals.set(key, valueJson);
+            return true;
+        },
+        async getSignal(runId, name) {
+            return signals.get(`${runId}\u0000${name}`);
+        },
+        async getStep(runId, index) {
+            return steps.get(`${runId}:${index}`);
+        },
+        async putStep(runId, index, step) {
+            const key = `${runId}:${index}`;
+            if (!steps.has(key))
+                steps.set(key, step);
+        },
+    };
+}

package/dist/engine/sqlite-engine.d.ts

@@ -0,0 +1,7 @@
+import { type EngineOptions } from "./engine.js";
+import type { Engine } from "./types.js";
+export interface SqliteEngineOptions extends Omit<EngineOptions, "journal"> {
+    databasePath: string;
+}
+/** The local engine: runs survive a restart because the journal lives in the project's SQLite file. */
+export declare function createSqliteEngine({ databasePath, ...options }: SqliteEngineOptions): Engine;

package/dist/engine/sqlite-engine.js

@@ -0,0 +1,6 @@
+import { createEngine } from "./engine.js";
+import { createSqliteJournal } from "./sqlite-journal.js";
+/** The local engine: runs survive a restart because the journal lives in the project's SQLite file. */
+export function createSqliteEngine({ databasePath, ...options }) {
+    return createEngine({ ...options, journal: createSqliteJournal({ databasePath }) });
+}

package/dist/engine/sqlite-journal.d.ts

@@ -0,0 +1,5 @@
+import type { Journal } from "./journal.js";
+/** Keeps the journal in the project's SQLite file, in tables private to the engine. */
+export declare function createSqliteJournal({ databasePath }: {
+    databasePath: string;
+}): Journal;

package/dist/engine/sqlite-journal.js

@@ -0,0 +1,136 @@
+import { openDatabase } from "../storage/sqlite/open.js";
+import { acquireOwner, ownerIsAlive } from "../storage/sqlite/owner-lock.js";
+function leaseOf(row) {
+    return { workerId: row.worker_id, until: row.lease_until };
+}
+/** Keeps the journal in the project's SQLite file, in tables private to the engine. */
+export function createSqliteJournal({ databasePath }) {
+    const database = openDatabase(databasePath);
+    function readRun(runId) {
+        return database.prepare("SELECT * FROM engine_runs WHERE run_id = ?").get(runId);
+    }
+    return {
+        async begin(runId, inputJson, lease) {
+            const owner = acquireOwner();
+            const result = database
+                .prepare("INSERT OR IGNORE INTO engine_runs (run_id, state, input_json, worker_id, lease_until, owner_token, owner_path) VALUES (?, 'running', ?, ?, ?, ?, ?)")
+                .run(runId, inputJson, lease.workerId, lease.until, owner.token, owner.path);
+            return result.changes === 1;
+        },
+        async getRun(runId) {
+            const row = readRun(runId);
+            return (row && {
+                runId,
+                state: row.state,
+                inputJson: row.input_json,
+                cancelRequested: row.cancel_requested === 1,
+            });
+        },
+        async setState(runId, state) {
+            database.prepare("UPDATE engine_runs SET state = ? WHERE run_id = ?").run(state, runId);
+        },
+        async renew(runId, lease) {
+            database
+                .prepare("UPDATE engine_runs SET lease_until = ? WHERE run_id = ? AND worker_id = ?")
+                .run(lease.until, runId, lease.workerId);
+        },
+        async claim(runId, lease, expected) {
+            const owner = acquireOwner();
+            const result = expected
+                ? database
+                    .prepare("UPDATE engine_runs SET state = 'running', worker_id = ?, lease_until = ?, owner_token = ?, owner_path = ? WHERE run_id = ? AND worker_id = ? AND lease_until = ?")
+                    .run(lease.workerId, lease.until, owner.token, owner.path, runId, expected.workerId, expected.until)
+                : database
+                    .prepare("UPDATE engine_runs SET state = 'running', worker_id = ?, lease_until = ?, owner_token = ?, owner_path = ? WHERE run_id = ?")
+                    .run(lease.workerId, lease.until, owner.token, owner.path, runId);
+            return result.changes === 1;
+        },
+        async claimWaiting(runId, lease, expected) {
+            const owner = acquireOwner();
+            const sql = `UPDATE engine_runs SET state = 'running', worker_id = ?, lease_until = ?, owner_token = ?, owner_path = ? WHERE run_id = ? AND state = 'waiting'`;
+            const result = expected
+                ? database
+                    .prepare(`${sql} AND worker_id = ? AND lease_until = ?`)
+                    .run(lease.workerId, lease.until, owner.token, owner.path, runId, expected.workerId, expected.until)
+                : database.prepare(sql).run(lease.workerId, lease.until, owner.token, owner.path, runId);
+            return result.changes === 1;
+        },
+        async listStale(workerId, now) {
+            const rows = database
+                .prepare("SELECT * FROM engine_runs WHERE state = 'running' AND worker_id != ?")
+                .all(workerId);
+            // A dead process is recovered at the next start; a live one only after its lease runs out.
+            return rows
+                .filter((row) => row.lease_until < now || !ownerIsAlive(row.owner_token, row.owner_path))
+                .map((row) => ({ runId: row.run_id, held: leaseOf(row) }));
+        },
+        async listReady(now) {
+            const rows = database
+                .prepare(`
+          SELECT DISTINCT r.* FROM engine_runs r
+          JOIN engine_waits w ON w.run_id = r.run_id AND w.outcome_json IS NULL
+          WHERE r.state = 'waiting' AND (
+            r.cancel_requested = 1 OR w.deadline <= ? OR EXISTS (
+              SELECT 1 FROM engine_signals s WHERE s.run_id = w.run_id AND s.name = w.name
+            )
+          )
+        `)
+                .all(now);
+            return rows.map((row) => ({ runId: row.run_id, held: leaseOf(row) }));
+        },
+        async listWaiting() {
+            const rows = database
+                .prepare(`SELECT r.run_id, w.deadline FROM engine_runs r
+        JOIN engine_waits w ON w.run_id = r.run_id AND w.outcome_json IS NULL
+        WHERE r.state = 'waiting'`)
+                .all();
+            return rows.map((row) => ({ runId: row.run_id, deadline: row.deadline }));
+        },
+        async requestCancel(runId) {
+            const result = database
+                .prepare("UPDATE engine_runs SET cancel_requested = 1 WHERE run_id = ? AND cancel_requested = 0 AND state IN ('running', 'waiting')")
+                .run(runId);
+            return result.changes === 1;
+        },
+        async getWait(runId, name) {
+            const row = database
+                .prepare("SELECT deadline, outcome_json FROM engine_waits WHERE run_id = ? AND name = ?")
+                .get(runId, name);
+            return row && { deadline: row.deadline, outcomeJson: row.outcome_json };
+        },
+        async openWait(runId, name, deadline) {
+            database
+                .prepare("INSERT OR IGNORE INTO engine_waits (run_id, name, deadline) VALUES (?, ?, ?)")
+                .run(runId, name, deadline);
+        },
+        async resolveWait(runId, name, outcomeJson) {
+            const result = database
+                .prepare("UPDATE engine_waits SET outcome_json = ? WHERE run_id = ? AND name = ? AND outcome_json IS NULL")
+                .run(outcomeJson, runId, name);
+            return result.changes === 1;
+        },
+        async putSignal(runId, name, valueJson) {
+            const result = database
+                .prepare("INSERT OR IGNORE INTO engine_signals (run_id, name, value_json) VALUES (?, ?, ?)")
+                .run(runId, name, valueJson);
+            return result.changes === 1;
+        },
+        async getSignal(runId, name) {
+            const row = database
+                .prepare("SELECT value_json FROM engine_signals WHERE run_id = ? AND name = ?")
+                .get(runId, name);
+            return row?.value_json;
+        },
+        async getStep(runId, index) {
+            const row = database
+                .prepare("SELECT name, result_json FROM engine_steps WHERE run_id = ? AND step_index = ?")
+                .get(runId, index);
+            return row && { name: row.name, resultJson: row.result_json };
+        },
+        async putStep(runId, index, step) {
+            database
+                .prepare("INSERT OR IGNORE INTO engine_steps (run_id, step_index, name, result_json) VALUES (?, ?, ?, ?)")
+                .run(runId, index, step.name, step.resultJson);
+        },
+    };
+}