@anvia/durable 0.0.0-bootstrap.0 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anvia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,163 @@
-# @anvia/durable — bootstrap placeholder
+# @anvia/durable
 
-This version reserves the package for npm Trusted Publishing setup. It contains no runtime implementation and is not intended for application use.
+Run Anvia agents with persisted model and tool checkpoints. Submit work, observe its
+progress, and recover unfinished runs after a process restart.
 
-Future releases will be published from https://github.com/anvia-hq/anvia through its OIDC release workflow.
+Experimental: this first version supports one runtime owner per local SQLite database,
+static local tools, and committed progress events. It does not stream individual tokens.
+
+## Install
+
+```sh
+pnpm add @anvia/durable @anvia/core @anvia/openai zod
+```
+
+SQLite requires Node.js 22.16 or newer. Use the accompanying core release with the
+durable execution protocol; older core versions are rejected when importing this package.
+
+## Quickstart
+
+```ts
+import { Agent } from "@anvia/core/agent";
+import { DurableRuntime } from "@anvia/durable";
+import { SqliteDurableStore } from "@anvia/durable/sqlite";
+import { OpenAIClient } from "@anvia/openai";
+
+const client = new OpenAIClient({ apiKey: process.env.OPENAI_API_KEY! });
+const researcher = new Agent({
+  id: "researcher",
+  model: client.completionModel({ modelId: "gpt-5.6", api: "responses" }),
+  instructions: "Produce a concise research brief from the supplied material.",
+});
+
+const runtime = await DurableRuntime.open({
+  store: new SqliteDurableStore("./anvia-runs.sqlite"),
+  agents: [{ agent: researcher, version: "1" }],
+  maxConcurrentRuns: 4,
+});
+
+try {
+  await runtime.resume(); // discover unfinished work from the previous process
+  const run = await runtime.submit({
+    agentId: researcher.id,
+    sessionId: "research-session",
+    requestId: "research-job-42",
+    prompt: "Summarize these research notes: ...",
+  });
+
+  for await (const event of run.stream()) {
+    console.log(event.type, event.data);
+  }
+  const outcome = await run.result();
+  if (outcome.type === "response") console.log(outcome.output);
+} finally {
+  await runtime.close();
+}
+```
+
+Keep the runtime alive at application scope in a server. A client disconnect should close
+only that client's subscription. Call `run.cancel()` to explicitly cancel the work.
+
+## What survives a restart
+
+- Submissions, deduplicated by `(sessionId, requestId)`; changed content with the same ID is rejected.
+- Completed normalized model responses and tool results, reused during recovery.
+- Pending approvals and questions, with responses accepted once per interaction ID.
+- Session history, operation IDs, model-turn counts, usage, and progress-event cursors.
+- Explicit cancellations, which are never restarted automatically.
+
+Interrupted model requests may be sent again. A provider may bill both attempts; usage
+records only completed responses received and committed by this runtime.
+
+Tools default to `manual` recovery. Mark read-only tools `safe`, or use `idempotent` only
+when the external service deduplicates requests using `context.operationId`:
+
+```ts
+const runtime = await DurableRuntime.open({
+  store: new SqliteDurableStore("./anvia-runs.sqlite"),
+  agents: [
+    {
+      agent: researcher,
+      version: "1",
+      toolRecovery: { search: "safe", createTicket: "idempotent" },
+    },
+  ],
+});
+```
+
+The tools in `toolRecovery` must be registered on that agent. A committed tool result is
+never executed again, regardless of policy. An interrupted `manual` tool becomes
+`needs_attention`; inspect the external system and supply its actual result with
+`run.resolveTool(operationId, output)`. Merely selecting `idempotent` does not make an API safe.
+
+## Queues, inspection, and HTTP
+
+Use `runtime.listRuns({ sessionId, status: "waiting", limit: 25 })` to discover pending
+approvals. Listings also support agent/status filters and insertion cursors. Inspect the
+full record with `runtime.getRun(id)` and `run.snapshot()`.
+
+`runtime.submit(input, { enqueue: true })` persists a successor behind the current session
+run. Different sessions execute up to `maxConcurrentRuns` (default 4). Approvals and recovery
+blocks pause their session queue while freeing capacity for other sessions.
+
+Opt into persisted model backoff on a registration:
+
+```ts
+{ agent: researcher, version: "1", modelRetry: {
+  maxAttempts: 3, initialDelayMs: 1000, maxDelayMs: 30_000,
+} }
+```
+
+The policy applies to core completion-attempt errors, including provider errors, completion
+validation, and completion observers. Attempt counts include interrupted
+requests; retry deadlines survive restart. Tool recovery policies remain separate.
+
+`@anvia/server/durable` provides an authorized Fetch handler, and `@anvia/client/durable`
+provides a browser-safe HTTP/SSE client. Reconnect using an atomic snapshot and its event
+cursor. See the [HTTP guide](../../docs/packages/durable.md#http-server-and-client).
+
+## Task graphs
+
+`runtime.submitGraph({ sessionId, requestId, tasks })` creates a persisted static DAG.
+Each task specifies `id`, `agentId`, `prompt`, and optional `dependsOn` task IDs. Independent
+nodes run concurrently; a dependent starts only after all prerequisites return successfully.
+Their committed outputs are supplied as JSON data in the dependent's input.
+
+`graph.snapshot()` exposes nodes, edges, outputs, interactions, waiting reasons, and an event
+cursor. `graph.stream()` emits committed task events; refresh the snapshot for live graph
+state. Use each node's `runId` for existing approval, retry, and reconciliation methods.
+`runtime.resume()` recovers eligible graph nodes after restart. Approvals and uncertain
+external effects still require explicit decisions.
+
+The HTTP client exposes `submitGraph`, `graphSnapshot`, `listGraphs`, `streamGraph`, and
+`cancelGraph`. See the [task graph guide](../../docs/packages/durable.md#task-dependencies-and-exposed-graphs).
+This version exposes graph data and execution;
+Studio visualization and durable core Pipeline execution remain future work.
+
+## Custom tasks and dynamic ownership
+
+Use `defineTask()` for schema-validated input, checkpoints, and output. Register definitions
+in `DurableRuntime.open({ store, tasks, agents })`, then call `runtime.submitTask()`.
+A phase can spawn custom or agent children, persist a child join, wait for a timer or named
+signal, and journal external effects with explicit recovery policies. Waiting phases release
+capacity; cancelling a tree fences new work and waits for owned callbacks to settle.
+
+`task.graph()` exposes the complete bounded ownership tree and current waits. `task.stream()`
+emits committed tree changes. The HTTP/client integration also exposes custom-task submission,
+signals, reconciliation, cancellation, snapshots, and graph/event reads. See the
+[custom task guide](../../docs/packages/durable-tasks.md) for contracts, examples, and limits.
+
+## Operational controls
+
+Use `runtime.health()` for readiness, `runtime.metrics()` for aggregate status counts, and
+`onFatalError` to notify your supervisor. Storage failures stop both schedulers and reject
+new work. Configurable pending-work, payload, and operation limits bound admission.
+
+`@anvia/durable/maintenance` provides offline `backupSqlite` and `restoreSqlite`; both write
+new files only. See the [operations guide](../../docs/packages/durable-operations.md) for
+restore, upgrade, rollback, and rollout procedures. The package remains experimental.
+
+## Learn more
+
+- [Execution, recovery, and API guide](../../docs/packages/durable.md)
+- [Anvia overview](../../README.md)

package/dist/chunk-7WOOJGHA.js

@@ -0,0 +1,499 @@
+import {
+  eventTypeSchema,
+  graphListSchema,
+  json,
+  listOptionsSchema,
+  nonblank,
+  parseGraphRecord,
+  parseOperation,
+  parseRun,
+  parseTask,
+  taskListSchema
+} from "./chunk-KIMHK6CE.js";
+
+// src/metrics.ts
+function sqliteMetrics(db) {
+  const statuses = (table) => Object.fromEntries(
+    db.prepare(`SELECT status, COUNT(*) AS n FROM ${table} GROUP BY status`).all().map((row) => [String(row.status), Number(row.n)])
+  );
+  const oldest = db.prepare(`SELECT MIN(created) AS oldest FROM (
+    SELECT MIN(json_extract(record, '$.createdAt')) AS created FROM anvia_durable_runs WHERE status NOT IN ('completed', 'failed', 'cancelled')
+    UNION ALL SELECT MIN(json_extract(record, '$.createdAt')) FROM anvia_durable_tasks WHERE status NOT IN ('completed', 'failed', 'cancelled')
+  )`).get().oldest;
+  const count = (table) => Number(db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get().n);
+  return {
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    runs: statuses("anvia_durable_runs"),
+    tasks: statuses("anvia_durable_tasks"),
+    oldestPendingAgeMs: typeof oldest === "string" ? Math.max(0, Date.now() - Date.parse(oldest)) : 0,
+    operations: count("anvia_durable_operations"),
+    events: count("anvia_durable_events"),
+    databaseBytes: Number(db.prepare("PRAGMA page_count").get().page_count) * Number(db.prepare("PRAGMA page_size").get().page_size)
+  };
+}
+
+// src/tasks/sqlite.ts
+var taskTables = `
+  CREATE TABLE IF NOT EXISTS anvia_durable_tasks (
+    id TEXT PRIMARY KEY, root_id TEXT NOT NULL, parent_id TEXT NOT NULL,
+    session_id TEXT NOT NULL, key TEXT NOT NULL, status TEXT NOT NULL, ready_order INTEGER NOT NULL, record TEXT NOT NULL,
+    UNIQUE(session_id, parent_id, key)
+  );
+  CREATE INDEX IF NOT EXISTS anvia_durable_task_root ON anvia_durable_tasks(root_id);
+  CREATE INDEX IF NOT EXISTS anvia_durable_task_parent ON anvia_durable_tasks(parent_id);
+  CREATE INDEX IF NOT EXISTS anvia_durable_task_status ON anvia_durable_tasks(status);
+`;
+function taskTransaction(db, assertActive) {
+  const read = (sql, ...parameters) => {
+    assertActive();
+    return db.prepare(sql).all(...parameters).map((row) => parseTask(JSON.parse(String(row.record))));
+  };
+  return {
+    getTask: (id) => read("SELECT record FROM anvia_durable_tasks WHERE id = ?", id)[0],
+    findTask: (session, parent, key) => read(
+      "SELECT record FROM anvia_durable_tasks WHERE session_id = ? AND parent_id = ? AND key = ?",
+      session,
+      parent ?? "",
+      key
+    )[0],
+    taskChildren: (id) => read("SELECT record FROM anvia_durable_tasks WHERE parent_id = ? ORDER BY rowid", id),
+    taskTree: (root) => read("SELECT record FROM anvia_durable_tasks WHERE root_id = ? ORDER BY rowid", root),
+    putTask: (value) => {
+      assertActive();
+      const task = parseTask(value);
+      db.prepare(`INSERT INTO anvia_durable_tasks(id, root_id, parent_id, session_id, key, status, record, ready_order)
+        VALUES (?, ?, ?, ?, ?, ?, ?, (SELECT COALESCE(MAX(sequence), 0) + 1 FROM anvia_durable_events))
+        ON CONFLICT(id) DO UPDATE SET status = excluded.status, record = excluded.record, ready_order = excluded.ready_order`).run(
+        task.id,
+        task.rootId,
+        task.parentId ?? "",
+        task.sessionId,
+        task.key,
+        task.status,
+        JSON.stringify(task)
+      );
+    }
+  };
+}
+function listTasks(db, input) {
+  const options = taskListSchema.parse(input);
+  const limit = options.limit ?? 50;
+  const rows = db.prepare(`SELECT rowid AS cursor, record FROM anvia_durable_tasks WHERE parent_id = ''
+    AND rowid > ? ${options.sessionId === void 0 ? "" : "AND session_id = ?"} ORDER BY rowid LIMIT ?`).all(
+    options.after ?? 0,
+    ...options.sessionId === void 0 ? [] : [options.sessionId],
+    limit + 1
+  );
+  const page = rows.slice(0, limit);
+  return {
+    tasks: page.map((row) => parseTask(JSON.parse(String(row.record)))),
+    ...rows.length > limit ? { nextCursor: Number(page.at(-1).cursor) } : {}
+  };
+}
+function scheduleTasks(db, excluded, limit) {
+  const filter = excluded.length === 0 ? "" : `AND id NOT IN (${excluded.map(() => "?").join(",")})`;
+  return db.prepare(
+    `SELECT id FROM anvia_durable_tasks WHERE status IN ('pending', 'running') ${filter} ORDER BY ready_order, rowid LIMIT ?`
+  ).all(...excluded, limit).map((row) => String(row.id));
+}
+function unsettledTaskRoots(db, after) {
+  const rows = db.prepare(`SELECT rowid AS cursor, id FROM anvia_durable_tasks
+    WHERE parent_id = '' AND status NOT IN ('completed', 'failed', 'cancelled') AND rowid > ? ORDER BY rowid LIMIT 100`).all(after);
+  return {
+    ids: rows.map((row) => String(row.id)),
+    ...rows.length === 100 ? { cursor: Number(rows.at(-1).cursor) } : {}
+  };
+}
+
+// src/sqlite.ts
+import { hostname } from "node:os";
+import { DatabaseSync } from "node:sqlite";
+var SqliteDurableStore = class {
+  database;
+  token = globalThis.crypto.randomUUID();
+  acquired = false;
+  closed = false;
+  inTransaction = false;
+  constructor(path) {
+    nonblank(path, "SQLite path");
+    this.database = new DatabaseSync(path);
+    try {
+      if (this.database.prepare("SELECT 1 FROM sqlite_master WHERE name = 'anvia_durable_backup'").get() !== void 0)
+        throw new Error("Sealed durable backup; restore it into a new database before opening.");
+      this.database.exec(`
+        PRAGMA busy_timeout = 5000;
+        PRAGMA journal_mode = WAL;
+        PRAGMA synchronous = FULL;
+        CREATE TABLE IF NOT EXISTS anvia_durable_owner (
+          singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
+          version INTEGER NOT NULL, token TEXT, pid INTEGER, host TEXT
+        );
+        INSERT OR IGNORE INTO anvia_durable_owner(singleton, version) VALUES (1, 3);
+        CREATE TABLE IF NOT EXISTS anvia_durable_runs (
+          id TEXT PRIMARY KEY, session_id TEXT NOT NULL, request_id TEXT NOT NULL,
+          status TEXT NOT NULL, record TEXT NOT NULL,
+          UNIQUE(session_id, request_id)
+        );
+        CREATE INDEX IF NOT EXISTS anvia_durable_run_session ON anvia_durable_runs(session_id, status);
+        CREATE TABLE IF NOT EXISTS anvia_durable_graphs (
+          id TEXT PRIMARY KEY, session_id TEXT NOT NULL, request_id TEXT NOT NULL, record TEXT NOT NULL,
+          UNIQUE(session_id, request_id)
+        );
+        CREATE INDEX IF NOT EXISTS anvia_durable_run_graph ON anvia_durable_runs(json_extract(record, '$.graphId'));
+        CREATE TABLE IF NOT EXISTS anvia_durable_operations (
+          run_id TEXT NOT NULL, key TEXT NOT NULL, record TEXT NOT NULL,
+          PRIMARY KEY(run_id, key)
+        );
+        CREATE TABLE IF NOT EXISTS anvia_durable_events (
+          sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+          run_id TEXT NOT NULL, created_at TEXT NOT NULL, type TEXT NOT NULL, data TEXT NOT NULL
+        );
+        CREATE INDEX IF NOT EXISTS anvia_durable_event_run ON anvia_durable_events(run_id, sequence);
+        ${taskTables}
+      `);
+      const version = this.database.prepare("SELECT version FROM anvia_durable_owner WHERE singleton = 1").get();
+      if (version?.version !== 1 && version?.version !== 2 && version?.version !== 3)
+        throw new Error("Unsupported durable database schema version.");
+    } catch (error) {
+      this.database.close();
+      throw error;
+    }
+  }
+  acquire() {
+    if (this.closed || this.acquired)
+      throw new Error("Durable store is closed or already acquired.");
+    this.atomic(() => {
+      const owner = this.database.prepare("SELECT token, pid, host FROM anvia_durable_owner WHERE singleton = 1").get();
+      if (owner.token !== null && (owner.host !== hostname() || processExists(Number(owner.pid)))) {
+        throw new Error(
+          "Durable store already has a live owner. Only one runtime per database is supported."
+        );
+      }
+      this.database.prepare(
+        "UPDATE anvia_durable_owner SET token = ?, pid = ?, host = ?, version = 3 WHERE singleton = 1"
+      ).run(this.token, process.pid, hostname());
+    });
+    this.acquired = true;
+  }
+  close() {
+    if (this.closed) return;
+    try {
+      if (this.acquired) {
+        this.atomic(() => {
+          this.database.prepare(
+            "UPDATE anvia_durable_owner SET token = NULL, pid = NULL, host = NULL WHERE singleton = 1 AND token = ?"
+          ).run(this.token);
+        });
+      }
+    } finally {
+      this.database.close();
+      this.closed = true;
+      this.acquired = false;
+    }
+  }
+  transaction(callback) {
+    this.assertOpen();
+    return this.atomic(() => {
+      this.assertOwner();
+      let active = true;
+      try {
+        return callback(
+          this.transactionApi(() => {
+            if (!active) throw new Error("Durable transaction has finished.");
+          })
+        );
+      } finally {
+        active = false;
+      }
+    });
+  }
+  metrics() {
+    this.assertOpen();
+    return sqliteMetrics(this.database);
+  }
+  listGraphs(input) {
+    this.assertOpen();
+    const options = graphListSchema.parse(input);
+    const limit = options.limit ?? 50;
+    const filter = options.sessionId === void 0 ? "" : "AND session_id = ?";
+    const rows = this.database.prepare(`SELECT rowid AS cursor, id, session_id, request_id, json_extract(record, '$.createdAt') AS created_at
+      FROM anvia_durable_graphs WHERE rowid > ? ${filter} ORDER BY rowid LIMIT ?`).all(
+      options.after ?? 0,
+      ...options.sessionId === void 0 ? [] : [options.sessionId],
+      limit + 1
+    );
+    const page = rows.slice(0, limit);
+    return {
+      graphs: page.map((row) => ({
+        id: String(row.id),
+        sessionId: String(row.session_id),
+        requestId: String(row.request_id),
+        createdAt: String(row.created_at)
+      })),
+      ...rows.length > limit ? { nextCursor: Number(page.at(-1).cursor) } : {}
+    };
+  }
+  listTasks(options) {
+    this.assertOpen();
+    return listTasks(this.database, options);
+  }
+  scheduleTasks(excluded, limit) {
+    this.assertOpen();
+    return scheduleTasks(this.database, excluded, limit);
+  }
+  unsettledTaskRoots(after) {
+    this.assertOpen();
+    return unsettledTaskRoots(this.database, after);
+  }
+  taskEvents(rootId, after, limit) {
+    this.assertOpen();
+    if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 1e3)
+      throw new TypeError("Invalid task event cursor or page size.");
+    return this.database.prepare(`SELECT e.* FROM anvia_durable_events e JOIN anvia_durable_tasks t ON t.id = e.run_id
+      WHERE t.root_id = ? AND e.sequence > ? ORDER BY e.sequence LIMIT ?`).all(rootId, after, limit).map((row) => ({
+      sequence: Number(row.sequence),
+      runId: String(row.run_id),
+      createdAt: String(row.created_at),
+      type: eventTypeSchema.parse(row.type),
+      data: json(JSON.parse(String(row.data)))
+    }));
+  }
+  graphEvents(graphId, after, limit) {
+    this.assertOpen();
+    if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 1e3)
+      throw new TypeError("Invalid graph event cursor or page size.");
+    return this.database.prepare(`SELECT e.* FROM anvia_durable_events e JOIN anvia_durable_runs r ON r.id = e.run_id
+      WHERE json_extract(r.record, '$.graphId') = ? AND e.sequence > ? ORDER BY e.sequence LIMIT ?`).all(graphId, after, limit).map((row) => ({
+      sequence: Number(row.sequence),
+      runId: String(row.run_id),
+      createdAt: String(row.created_at),
+      type: eventTypeSchema.parse(row.type),
+      data: json(JSON.parse(String(row.data)))
+    }));
+  }
+  list(input) {
+    this.assertOpen();
+    const options = listOptionsSchema.parse(input);
+    const conditions = ["rowid > ?"];
+    const parameters = [options.after ?? 0];
+    for (const [column, value] of [
+      ["session_id", options.sessionId],
+      ["json_extract(record, '$.agentId')", options.agentId],
+      ["status", options.status]
+    ]) {
+      if (value !== void 0) {
+        conditions.push(`${column} = ?`);
+        parameters.push(value);
+      }
+    }
+    const limit = options.limit ?? 50;
+    const rows = this.database.prepare(
+      `SELECT rowid AS cursor, record FROM anvia_durable_runs WHERE ${conditions.join(" AND ")} ORDER BY rowid LIMIT ?`
+    ).all(...parameters, limit + 1);
+    const page = rows.slice(0, limit);
+    return {
+      runs: page.map((row) => {
+        const {
+          id,
+          agentId,
+          sessionId,
+          requestId,
+          status,
+          createdAt,
+          updatedAt,
+          error,
+          blockedOperation,
+          nextAttemptAt
+        } = parseRun(JSON.parse(String(row.record)));
+        return {
+          id,
+          agentId,
+          sessionId,
+          requestId,
+          status,
+          createdAt,
+          updatedAt,
+          ...error === void 0 ? {} : { error },
+          ...blockedOperation === void 0 ? {} : { blockedOperation },
+          ...nextAttemptAt === void 0 ? {} : { nextAttemptAt }
+        };
+      }),
+      ...rows.length > limit ? { nextCursor: Number(page.at(-1).cursor) } : {}
+    };
+  }
+  schedule(now, limit, excludedSessions) {
+    this.assertOpen();
+    if (!Number.isSafeInteger(limit) || limit < 1) throw new TypeError("Invalid scheduler limit.");
+    const exclude = excludedSessions.length === 0 ? "" : `AND r.session_id NOT IN (${excludedSessions.map(() => "?").join(",")})`;
+    const eligible = `FROM anvia_durable_runs r
+      WHERE r.status IN ('queued', 'pending', 'running', 'retry_wait') ${exclude}
+      AND NOT EXISTS (SELECT 1 FROM anvia_durable_runs previous
+        WHERE previous.session_id = r.session_id AND previous.rowid < r.rowid
+        AND previous.status NOT IN ('completed', 'failed', 'cancelled'))
+      AND NOT EXISTS (SELECT 1 FROM json_each(json_extract(r.record, '$.dependencies')) dependency
+        LEFT JOIN anvia_durable_runs prerequisite ON prerequisite.id = dependency.value
+        WHERE prerequisite.id IS NULL OR prerequisite.status != 'completed'
+          OR json_extract(prerequisite.record, '$.outcome.type') IS NOT 'response')`;
+    const ids = this.database.prepare(`SELECT r.id ${eligible}
+      AND (r.status != 'retry_wait' OR json_extract(r.record, '$.nextAttemptAt') <= ?)
+      ORDER BY r.rowid LIMIT ?`).all(...excludedSessions, now, limit).map((row) => String(row.id));
+    const wake = this.database.prepare(`SELECT MIN(json_extract(r.record, '$.nextAttemptAt')) AS deadline
+      ${eligible} AND r.status = 'retry_wait' AND json_extract(r.record, '$.nextAttemptAt') > ?`).get(...excludedSessions, now);
+    return { ids, ...typeof wake?.deadline === "string" ? { nextAttemptAt: wake.deadline } : {} };
+  }
+  events(runId, after, limit) {
+    this.assertOpen();
+    if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 1e3) {
+      throw new TypeError("Invalid durable event cursor or page size.");
+    }
+    return this.database.prepare(
+      "SELECT * FROM anvia_durable_events WHERE run_id = ? AND sequence > ? ORDER BY sequence LIMIT ?"
+    ).all(runId, after, limit).map((row) => ({
+      sequence: Number(row.sequence),
+      runId: String(row.run_id),
+      createdAt: String(row.created_at),
+      type: eventTypeSchema.parse(row.type),
+      data: json(JSON.parse(String(row.data)))
+    }));
+  }
+  transactionApi(assertActive) {
+    const readRun = (sql, ...parameters) => {
+      assertActive();
+      const row = this.database.prepare(sql).get(...parameters);
+      return row === void 0 ? void 0 : parseRun(JSON.parse(String(row.record)));
+    };
+    return {
+      ...taskTransaction(this.database, assertActive),
+      pendingCounts: () => {
+        assertActive();
+        const count = (table) => Number(
+          this.database.prepare(
+            `SELECT COUNT(*) AS n FROM ${table} WHERE status NOT IN ('completed', 'failed', 'cancelled')`
+          ).get().n
+        );
+        return { runs: count("anvia_durable_runs"), tasks: count("anvia_durable_tasks") };
+      },
+      operationCount: (id) => {
+        assertActive();
+        return Number(
+          this.database.prepare("SELECT COUNT(*) AS n FROM anvia_durable_operations WHERE run_id = ?").get(id).n
+        );
+      },
+      getGraph: (id) => {
+        assertActive();
+        const row = this.database.prepare("SELECT record FROM anvia_durable_graphs WHERE id = ?").get(id);
+        return row === void 0 ? void 0 : parseGraphRecord(JSON.parse(String(row.record)));
+      },
+      findGraphRequest: (session, request) => {
+        assertActive();
+        const row = this.database.prepare(
+          "SELECT record FROM anvia_durable_graphs WHERE session_id = ? AND request_id = ?"
+        ).get(session, request);
+        return row === void 0 ? void 0 : parseGraphRecord(JSON.parse(String(row.record)));
+      },
+      putGraph: (graph) => {
+        assertActive();
+        this.database.prepare(`INSERT INTO anvia_durable_graphs(id, session_id, request_id, record) VALUES (?, ?, ?, ?)
+          ON CONFLICT(id) DO UPDATE SET record = excluded.record`).run(
+          graph.id,
+          graph.submission.sessionId,
+          graph.submission.requestId,
+          JSON.stringify(parseGraphRecord(json(graph)))
+        );
+      },
+      getRun: (id) => readRun("SELECT record FROM anvia_durable_runs WHERE id = ?", id),
+      findRequest: (session, request) => readRun(
+        "SELECT record FROM anvia_durable_runs WHERE session_id = ? AND request_id = ?",
+        session,
+        request
+      ),
+      activeRun: (session) => readRun(
+        "SELECT record FROM anvia_durable_runs WHERE session_id = ? AND status NOT IN ('completed', 'failed', 'cancelled') LIMIT 1",
+        session
+      ),
+      latestCompleted: (session) => readRun(
+        "SELECT record FROM anvia_durable_runs WHERE session_id = ? AND status = 'completed' ORDER BY rowid DESC LIMIT 1",
+        session
+      ),
+      hasLaterStartedRun: (id) => {
+        assertActive();
+        return this.database.prepare(`SELECT 1 FROM anvia_durable_runs later
+          JOIN anvia_durable_runs current ON later.session_id = current.session_id
+          WHERE current.id = ? AND later.rowid > current.rowid AND (later.status NOT IN ('queued', 'cancelled') OR json_extract(later.record, '$.startedAt') IS NOT NULL) LIMIT 1`).get(id) !== void 0;
+      },
+      putRun: (run) => {
+        assertActive();
+        const serialized = JSON.stringify(parseRun(json(run)));
+        this.database.prepare(`INSERT INTO anvia_durable_runs(id, session_id, request_id, status, record)
+          VALUES (?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET status = excluded.status, record = excluded.record`).run(run.id, run.sessionId, run.requestId, run.status, serialized);
+      },
+      getOperation: (runId, key) => {
+        assertActive();
+        const row = this.database.prepare("SELECT record FROM anvia_durable_operations WHERE run_id = ? AND key = ?").get(runId, key);
+        return row === void 0 ? void 0 : parseOperation(JSON.parse(String(row.record)));
+      },
+      operations: (runId) => {
+        assertActive();
+        return this.database.prepare("SELECT record FROM anvia_durable_operations WHERE run_id = ? ORDER BY rowid").all(runId).map((row) => parseOperation(JSON.parse(String(row.record))));
+      },
+      putOperation: (runId, operation) => {
+        assertActive();
+        this.database.prepare(`INSERT INTO anvia_durable_operations(run_id, key, record) VALUES (?, ?, ?)
+          ON CONFLICT(run_id, key) DO UPDATE SET record = excluded.record`).run(runId, operation.key, JSON.stringify(parseOperation(json(operation))));
+      },
+      appendEvent: (runId, type, data) => {
+        assertActive();
+        this.database.prepare(
+          "INSERT INTO anvia_durable_events(run_id, created_at, type, data) VALUES (?, ?, ?, ?)"
+        ).run(runId, (/* @__PURE__ */ new Date()).toISOString(), type, JSON.stringify(json(data)));
+      },
+      cursor: () => {
+        assertActive();
+        return Number(
+          this.database.prepare("SELECT COALESCE(MAX(sequence), 0) AS cursor FROM anvia_durable_events").get().cursor
+        );
+      }
+    };
+  }
+  atomic(callback) {
+    if (this.inTransaction) throw new Error("Nested durable transactions are not supported.");
+    this.database.exec("BEGIN IMMEDIATE");
+    this.inTransaction = true;
+    try {
+      const result = callback();
+      if (result !== null && typeof result === "object" && "then" in result) {
+        void Promise.resolve(result).catch(() => {
+        });
+        throw new TypeError("Durable transactions must be synchronous.");
+      }
+      this.database.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.database.exec("ROLLBACK");
+      throw error;
+    } finally {
+      this.inTransaction = false;
+    }
+  }
+  assertOpen() {
+    if (this.closed || !this.acquired) throw new Error("Durable store is not acquired.");
+  }
+  assertOwner() {
+    const owner = this.database.prepare("SELECT token FROM anvia_durable_owner WHERE singleton = 1").get();
+    if (owner?.token !== this.token) throw new Error("Durable store ownership was lost.");
+  }
+};
+function processExists(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+
+export {
+  SqliteDurableStore
+};
+//# sourceMappingURL=chunk-7WOOJGHA.js.map