@creatornader/agent-bridge 0.2.0

package/dist/chunk-WEULPMUY.js

@@ -0,0 +1,988 @@
+#!/usr/bin/env node
+import {
+  assertIdempotentReplay
+} from "./chunk-YD6YJATN.js";
+import {
+  decodeCursor,
+  encodeCursor
+} from "./chunk-BV6W4AJK.js";
+
+// src/sqlite-edge-store.ts
+import { createHash, randomUUID } from "crypto";
+import { chmodSync, existsSync, mkdirSync } from "fs";
+import { createRequire } from "module";
+import { dirname } from "path";
+var require2 = createRequire(import.meta.url);
+function openDatabase(path) {
+  const { DatabaseSync } = require2("node:sqlite");
+  return new DatabaseSync(path);
+}
+var MAX_SEQUENCE = 9223372036854775807n;
+var schema = `
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = FULL;
+PRAGMA foreign_keys = ON;
+CREATE TABLE IF NOT EXISTS edge_scopes (
+  scope_key TEXT PRIMARY KEY,
+  endpoint_hash TEXT NOT NULL,
+  workspace TEXT NOT NULL,
+  agent TEXT NOT NULL,
+  pull_cursor TEXT,
+  last_sync_at TEXT,
+  last_error TEXT
+);
+CREATE TABLE IF NOT EXISTS edge_outbox (
+  position INTEGER PRIMARY KEY AUTOINCREMENT,
+  scope_key TEXT NOT NULL REFERENCES edge_scopes(scope_key),
+  message_id TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  payload_hash TEXT NOT NULL,
+  draft_json TEXT NOT NULL,
+  state TEXT NOT NULL CHECK(state IN ('pending', 'blocked')),
+  attempts INTEGER NOT NULL DEFAULT 0,
+  available_at TEXT NOT NULL,
+  lease_token TEXT,
+  lease_expires_at TEXT,
+  last_error TEXT,
+  created_at TEXT NOT NULL,
+  UNIQUE(scope_key, message_id),
+  UNIQUE(scope_key, idempotency_key)
+);
+CREATE INDEX IF NOT EXISTS edge_outbox_due
+  ON edge_outbox(scope_key, state, available_at, position);
+CREATE TABLE IF NOT EXISTS edge_inbox (
+  scope_key TEXT NOT NULL REFERENCES edge_scopes(scope_key),
+  message_id TEXT NOT NULL,
+  remote_sequence TEXT NOT NULL,
+  sequence_key TEXT NOT NULL,
+  workspace TEXT NOT NULL,
+  source TEXT NOT NULL,
+  type TEXT NOT NULL,
+  thread_id TEXT,
+  created_at TEXT NOT NULL,
+  expires_at TEXT,
+  message_json TEXT NOT NULL,
+  PRIMARY KEY(scope_key, message_id),
+  UNIQUE(scope_key, sequence_key)
+);
+CREATE INDEX IF NOT EXISTS edge_inbox_cursor
+  ON edge_inbox(scope_key, sequence_key);
+CREATE INDEX IF NOT EXISTS edge_inbox_source
+  ON edge_inbox(scope_key, source, sequence_key);
+CREATE INDEX IF NOT EXISTS edge_inbox_thread
+  ON edge_inbox(scope_key, thread_id, sequence_key);
+CREATE INDEX IF NOT EXISTS edge_inbox_created
+  ON edge_inbox(scope_key, created_at, sequence_key);
+`;
+var EdgeConflictError = class extends Error {
+  constructor() {
+    super(...arguments);
+    this.code = "edge_idempotency_conflict";
+  }
+};
+function canonical(value) {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  return `{${Object.keys(value).filter((key) => value[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+}
+function intent(message2) {
+  return {
+    workspace: message2.workspace,
+    source: message2.source,
+    type: message2.type,
+    content: message2.content,
+    contentType: message2.contentType,
+    data: message2.data ?? null,
+    targets: [...message2.targets].sort(),
+    threadId: message2.threadId ?? null,
+    replyToId: message2.replyToId ?? null,
+    correlationId: message2.correlationId ?? null,
+    causationId: message2.causationId ?? null,
+    priority: message2.priority,
+    expiresAt: message2.expiresAt ?? null,
+    atribReceiptId: message2.atribReceiptId ?? null,
+    informedBy: [...message2.informedBy ?? []].sort(),
+    metadata: message2.metadata ?? null
+  };
+}
+function edgeMessageFingerprint(message2) {
+  return createHash("sha256").update(canonical(intent(message2))).digest("hex");
+}
+function stableIdempotency(message2) {
+  return message2.idempotencyKey ? message2 : { ...message2, idempotencyKey: `agent-bridge:id:${message2.id}` };
+}
+function edgeScopeKey(scope) {
+  return createHash("sha256").update(`${scope.endpoint.replace(/\/$/, "")}\0${scope.principal.workspace}\0${scope.principal.agent}`).digest("hex");
+}
+function sequenceKey(sequence) {
+  if (!/^(0|[1-9][0-9]*)$/.test(sequence) || BigInt(sequence) > MAX_SEQUENCE) {
+    throw new EdgeConflictError("remote sequence is invalid");
+  }
+  return sequence.padStart(19, "0");
+}
+function parseDraft(value) {
+  return JSON.parse(String(value));
+}
+function parseMessage(value) {
+  return JSON.parse(String(value));
+}
+var SQLiteEdgeStore = class {
+  constructor(path, scope, busyTimeoutMs = 2e3) {
+    this.path = path;
+    this.scope = scope;
+    this.busyTimeoutMs = busyTimeoutMs;
+    this.initialized = false;
+    if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    this.db = openDatabase(path);
+    this.restrictFiles();
+    this.key = edgeScopeKey(scope);
+  }
+  restrictFiles() {
+    if (this.path === ":memory:") return;
+    for (const path of [this.path, `${this.path}-wal`, `${this.path}-shm`]) {
+      if (existsSync(path)) chmodSync(path, 384);
+    }
+  }
+  get scopeKey() {
+    return this.key;
+  }
+  async initialize() {
+    if (this.initialized) return;
+    this.db.exec(`PRAGMA busy_timeout = ${Math.max(1, Math.trunc(this.busyTimeoutMs))}; ${schema}`);
+    this.restrictFiles();
+    const endpointHash = createHash("sha256").update(this.scope.endpoint.replace(/\/$/, "")).digest("hex");
+    this.db.prepare(`INSERT INTO edge_scopes (scope_key, endpoint_hash, workspace, agent)
+      VALUES (?, ?, ?, ?) ON CONFLICT(scope_key) DO NOTHING`).run(this.key, endpointHash, this.scope.principal.workspace, this.scope.principal.agent);
+    this.initialized = true;
+  }
+  async ready() {
+    await this.initialize();
+  }
+  async enqueue(input, now = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    const draft = stableIdempotency(input);
+    const payloadHash = edgeMessageFingerprint(draft);
+    const serialized = canonical(draft);
+    const nowText = now.toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const existing = this.db.prepare(`SELECT * FROM edge_outbox
+        WHERE scope_key=? AND (message_id=? OR idempotency_key=?) ORDER BY position LIMIT 1`).get(this.key, draft.id, draft.idempotencyKey);
+      if (existing) {
+        if (String(existing.payload_hash) !== payloadHash) {
+          throw new EdgeConflictError("message ID or idempotency key is already bound to different content");
+        }
+        this.db.exec("COMMIT");
+        return { draft: parseDraft(existing.draft_json), created: false };
+      }
+      this.db.prepare(`INSERT INTO edge_outbox
+        (scope_key, message_id, idempotency_key, payload_hash, draft_json, state, available_at, created_at)
+        VALUES (?, ?, ?, ?, ?, 'pending', ?, ?)`).run(this.key, draft.id, draft.idempotencyKey, payloadHash, serialized, nowText, nowText);
+      this.db.exec("COMMIT");
+      return { draft, created: true };
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async claimNext(now = /* @__PURE__ */ new Date(), leaseMs = 3e4) {
+    await this.ready();
+    const nowText = now.toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const head = this.db.prepare(`SELECT * FROM edge_outbox
+        WHERE scope_key=? AND state='pending' ORDER BY position LIMIT 1`).get(this.key);
+      if (!head || String(head.available_at) > nowText || head.lease_expires_at && String(head.lease_expires_at) > nowText) {
+        this.db.exec("COMMIT");
+        return void 0;
+      }
+      const leaseToken = randomUUID();
+      const leaseExpiresAt = new Date(now.getTime() + leaseMs).toISOString();
+      const updated = this.db.prepare(`UPDATE edge_outbox
+        SET lease_token=?, lease_expires_at=? WHERE scope_key=? AND position=?
+          AND (lease_expires_at IS NULL OR lease_expires_at<=?)`).run(leaseToken, leaseExpiresAt, this.key, Number(head.position), nowText);
+      if (!updated.changes) {
+        this.db.exec("COMMIT");
+        return void 0;
+      }
+      this.db.exec("COMMIT");
+      return {
+        position: Number(head.position),
+        draft: parseDraft(head.draft_json),
+        payloadHash: String(head.payload_hash),
+        attempts: Number(head.attempts),
+        leaseToken,
+        createdAt: String(head.created_at)
+      };
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async retry(record, error, availableAt) {
+    await this.ready();
+    this.db.prepare(`UPDATE edge_outbox SET attempts=attempts+1, available_at=?,
+      lease_token=NULL, lease_expires_at=NULL, last_error=?
+      WHERE scope_key=? AND position=? AND lease_token=?`).run(availableAt.toISOString(), error.slice(0, 256), this.key, record.position, record.leaseToken);
+    await this.noteError(error);
+  }
+  async block(record, error) {
+    await this.ready();
+    this.db.prepare(`UPDATE edge_outbox SET state='blocked', attempts=attempts+1,
+      lease_token=NULL, lease_expires_at=NULL, last_error=?
+      WHERE scope_key=? AND position=? AND lease_token=?`).run(error.slice(0, 256), this.key, record.position, record.leaseToken);
+    await this.noteError(error);
+  }
+  async commit(record, message2, cacheVisible, now = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      if (cacheVisible) this.cacheOne(message2);
+      const deleted = this.db.prepare(`DELETE FROM edge_outbox
+        WHERE scope_key=? AND position=? AND lease_token=?`).run(this.key, record.position, record.leaseToken);
+      if (deleted.changes !== 1) throw new EdgeConflictError("outbox lease was lost before commit");
+      this.db.prepare(`UPDATE edge_scopes SET last_sync_at=?, last_error=NULL WHERE scope_key=?`).run(now.toISOString(), this.key);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  cacheOne(message2) {
+    const serialized = canonical(message2);
+    const key = sequenceKey(message2.sequence);
+    const byId = this.db.prepare(`SELECT remote_sequence, message_json FROM edge_inbox
+      WHERE scope_key=? AND message_id=?`).get(this.key, message2.id);
+    const bySequence = this.db.prepare(`SELECT message_id, message_json FROM edge_inbox
+      WHERE scope_key=? AND sequence_key=?`).get(this.key, key);
+    if (byId || bySequence) {
+      if (!byId || String(byId.remote_sequence) !== message2.sequence || String(byId.message_json) !== serialized || bySequence && String(bySequence.message_id) !== message2.id) {
+        throw new EdgeConflictError("cached message conflicts with immutable remote history");
+      }
+      return;
+    }
+    this.db.prepare(`INSERT INTO edge_inbox
+      (scope_key, message_id, remote_sequence, sequence_key, workspace, source, type,
+       thread_id, created_at, expires_at, message_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
+      this.key,
+      message2.id,
+      message2.sequence,
+      key,
+      message2.workspace,
+      message2.source,
+      message2.type,
+      message2.threadId ?? null,
+      message2.createdAt,
+      message2.expiresAt ?? null,
+      serialized
+    );
+  }
+  async cachePage(messages, cursor, now = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      for (const message2 of messages) this.cacheOne(message2);
+      const current = this.db.prepare("SELECT pull_cursor FROM edge_scopes WHERE scope_key=?").get(this.key);
+      const currentCursor = current.pull_cursor ? String(current.pull_cursor) : void 0;
+      const nextCursor = !cursor ? currentCursor : !currentCursor || sequenceKey(decodeCursor(cursor)) >= sequenceKey(decodeCursor(currentCursor)) ? cursor : currentCursor;
+      this.db.prepare(`UPDATE edge_scopes SET pull_cursor=?, last_sync_at=?, last_error=NULL
+        WHERE scope_key=?`).run(nextCursor ?? null, now.toISOString(), this.key);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async cacheLatest(messages, now = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      for (const message2 of messages) this.cacheOne(message2);
+      this.db.prepare(`UPDATE edge_scopes SET last_sync_at=?, last_error=NULL WHERE scope_key=?`).run(now.toISOString(), this.key);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async list(query = {}) {
+    await this.ready();
+    if (query.unacknowledgedBy) {
+      throw new Error("offline cache cannot evaluate unacknowledgedBy");
+    }
+    const clauses = ["scope_key=?"];
+    const args = [this.key];
+    if (!query.latest) {
+      clauses.push("sequence_key>?");
+      args.push(sequenceKey(decodeCursor(query.cursor) ?? "0"));
+    }
+    if (!query.includeExpired) {
+      clauses.push("(expires_at IS NULL OR expires_at>?)");
+      args.push((/* @__PURE__ */ new Date()).toISOString());
+    }
+    if (query.types?.length) {
+      clauses.push(`type IN (${query.types.map(() => "?").join(",")})`);
+      args.push(...query.types);
+    }
+    if (query.source) {
+      clauses.push("source=?");
+      args.push(query.source);
+    }
+    if (query.since) {
+      clauses.push("created_at>=?");
+      args.push(query.since);
+    }
+    if (query.threadId) {
+      clauses.push("thread_id=?");
+      args.push(query.threadId);
+    }
+    const limit = Math.min(Math.max(Math.trunc(query.limit ?? 50), 1), 200);
+    const rows = this.db.prepare(`SELECT message_json FROM edge_inbox
+      WHERE ${clauses.join(" AND ")} ORDER BY sequence_key ${query.latest ? "DESC" : "ASC"} LIMIT ?`).all(...args, limit);
+    const messages = rows.map((row) => parseMessage(row.message_json));
+    const cursorMessage = query.latest ? messages[0] : messages[messages.length - 1];
+    return { messages, cursor: cursorMessage ? encodeCursor(cursorMessage.sequence) : query.cursor };
+  }
+  async pullCursor() {
+    await this.ready();
+    const row = this.db.prepare("SELECT pull_cursor FROM edge_scopes WHERE scope_key=?").get(this.key);
+    return row.pull_cursor ? String(row.pull_cursor) : void 0;
+  }
+  async noteError(error) {
+    await this.ready();
+    this.db.prepare("UPDATE edge_scopes SET last_error=? WHERE scope_key=?").run(error.slice(0, 256), this.key);
+  }
+  async stats() {
+    await this.ready();
+    const counts = this.db.prepare(`SELECT
+      sum(CASE WHEN state='pending' THEN 1 ELSE 0 END) AS pending,
+      sum(CASE WHEN state='blocked' THEN 1 ELSE 0 END) AS blocked
+      FROM edge_outbox WHERE scope_key=?`).get(this.key);
+    const cache = this.db.prepare("SELECT count(*) AS count FROM edge_inbox WHERE scope_key=?").get(this.key);
+    const state = this.db.prepare(`SELECT pull_cursor, last_sync_at, last_error
+      FROM edge_scopes WHERE scope_key=?`).get(this.key);
+    return {
+      pending: Number(counts.pending ?? 0),
+      blocked: Number(counts.blocked ?? 0),
+      cached: Number(cache.count ?? 0),
+      pullCursor: state.pull_cursor ? String(state.pull_cursor) : void 0,
+      lastSyncAt: state.last_sync_at ? String(state.last_sync_at) : void 0,
+      lastError: state.last_error ? String(state.last_error) : void 0
+    };
+  }
+  async close() {
+    this.db.close();
+  }
+};
+
+// src/syncing-bridge-store.ts
+function statusOf(error) {
+  if (!error || typeof error !== "object" || !("status" in error)) return void 0;
+  const status = Number(error.status);
+  return Number.isFinite(status) ? status : void 0;
+}
+function codeOf(error) {
+  if (error && typeof error === "object" && "code" in error) {
+    const code = error.code;
+    if (typeof code === "string" && code) return code.slice(0, 128);
+  }
+  return error instanceof Error ? error.name.slice(0, 128) : "sync_error";
+}
+function isRetryableSyncError(error) {
+  const status = statusOf(error);
+  const code = codeOf(error);
+  if (["invalid_input", "idempotency_conflict", "principal_mismatch"].includes(code)) return false;
+  return status === void 0 || status === 0 || status === 408 || status === 425 || status === 429 || status >= 500;
+}
+function provisional(draft, createdAt) {
+  return { ...draft, sequence: "0", createdAt };
+}
+var SyncingBridgeStore = class {
+  constructor(edge, remote, principal, options = {}) {
+    this.edge = edge;
+    this.remote = remote;
+    this.principal = principal;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.random = options.random ?? Math.random;
+    this.baseDelayMs = options.baseDelayMs ?? 1e3;
+    this.maxDelayMs = options.maxDelayMs ?? 5 * 6e4;
+    this.leaseMs = options.leaseMs ?? 3e4;
+  }
+  async initialize() {
+    await this.edge.initialize();
+  }
+  async verifyRemote() {
+    await this.ensureRemote();
+  }
+  async ensureRemote() {
+    if (!this.remoteReady) {
+      this.remoteReady = this.remote.initialize().catch((error) => {
+        this.remoteReady = void 0;
+        throw error;
+      });
+    }
+    await this.remoteReady;
+  }
+  assertPrincipal(principal, includeInstance = true) {
+    if (principal.workspace !== this.principal.workspace || principal.agent !== this.principal.agent || includeInstance && principal.instance !== this.principal.instance) {
+      const error = new Error("principal does not match the synchronized edge scope");
+      Object.assign(error, { status: 403, code: "principal_mismatch" });
+      throw error;
+    }
+  }
+  delay(attempts) {
+    const exponential = Math.min(this.maxDelayMs, this.baseDelayMs * 2 ** Math.min(attempts, 20));
+    const jitter = 0.8 + this.random() * 0.4;
+    return Math.max(1, Math.round(exponential * jitter));
+  }
+  async flushOne() {
+    try {
+      await this.ensureRemote();
+    } catch (error) {
+      await this.edge.noteError(codeOf(error));
+      return {
+        state: "retry",
+        error: error instanceof Error ? error : new Error(String(error)),
+        retryable: isRetryableSyncError(error)
+      };
+    }
+    const record = await this.edge.claimNext(this.now(), this.leaseMs);
+    if (!record) return { state: "empty" };
+    try {
+      const result = await this.remote.insertMessage(record.draft);
+      if (edgeMessageFingerprint(result.message) !== record.payloadHash) {
+        const error = new Error("idempotency key resolved to different message content");
+        Object.assign(error, { status: 409, code: "idempotency_conflict" });
+        await this.edge.block(record, codeOf(error));
+        return { state: "blocked", error };
+      }
+      const cacheVisible = result.message.targets.length === 0 || result.message.targets.includes(this.principal.agent);
+      await this.edge.commit(record, result.message, cacheVisible, this.now());
+      return { state: "committed", result, messageId: record.draft.id };
+    } catch (error) {
+      const caught = error instanceof Error ? error : new Error(String(error));
+      if (isRetryableSyncError(error)) {
+        await this.edge.retry(
+          record,
+          codeOf(error),
+          new Date(this.now().getTime() + this.delay(record.attempts))
+        );
+        return { state: "retry", error: caught, retryable: true };
+      }
+      await this.edge.block(record, codeOf(error));
+      return { state: "blocked", error: caught };
+    }
+  }
+  async insertMessage(message2) {
+    this.assertPrincipal({ workspace: message2.workspace, agent: message2.source }, false);
+    const queued = await this.edge.enqueue(message2, this.now());
+    const draft = queued.draft;
+    const flushed = await this.flushOne();
+    if (flushed.state === "blocked") throw flushed.error;
+    if (flushed.state === "retry" && !flushed.retryable) throw flushed.error;
+    if (flushed.state === "committed" && flushed.messageId === draft.id) {
+      return { ...flushed.result, disposition: "committed", authoritative: true };
+    }
+    return {
+      message: provisional(draft, this.now().toISOString()),
+      created: queued.created,
+      disposition: "queued",
+      authoritative: false
+    };
+  }
+  async pull(maxPages) {
+    let pulled = 0;
+    for (let pageNumber = 0; pageNumber < maxPages; pageNumber += 1) {
+      const before = await this.edge.pullCursor();
+      try {
+        await this.ensureRemote();
+        const page = await this.remote.listMessages(this.principal, {
+          cursor: before,
+          limit: 200,
+          includeExpired: true
+        });
+        await this.edge.cachePage(page.messages, page.cursor, this.now());
+        pulled += page.messages.length;
+        if (page.messages.length < 200 || !page.cursor || page.cursor === before) break;
+      } catch (error) {
+        await this.edge.noteError(codeOf(error));
+        return {
+          online: false,
+          pulled,
+          error: error instanceof Error ? error : new Error(String(error)),
+          retryable: isRetryableSyncError(error)
+        };
+      }
+    }
+    return { online: true, pulled };
+  }
+  async sync(options = {}) {
+    await this.edge.initialize();
+    const maxPush = Math.min(Math.max(Math.trunc(options.maxPush ?? 100), 0), 1e3);
+    const maxPages = Math.min(Math.max(Math.trunc(options.maxPages ?? 20), 0), 100);
+    let pushed = 0;
+    let deduplicated = 0;
+    let online = true;
+    let lastError;
+    let failureRetryable;
+    for (let index = 0; index < maxPush; index += 1) {
+      const result = await this.flushOne();
+      if (result.state === "empty") break;
+      if (result.state === "committed") {
+        pushed += 1;
+        if (!result.result.created) deduplicated += 1;
+        continue;
+      }
+      lastError = codeOf(result.error);
+      failureRetryable = result.state === "retry" ? result.retryable : false;
+      if (result.state === "retry") online = false;
+      break;
+    }
+    let pulled = 0;
+    if (maxPages > 0) {
+      const pull = await this.pull(maxPages);
+      online = online && pull.online;
+      pulled = pull.pulled;
+      if (pull.error) {
+        lastError = codeOf(pull.error);
+        failureRetryable = pull.retryable;
+      }
+    }
+    const stats = await this.edge.stats();
+    return {
+      online,
+      pushed,
+      deduplicated,
+      pulled,
+      pending: stats.pending,
+      blocked: stats.blocked,
+      cached: stats.cached,
+      cursor: stats.pullCursor,
+      lastSyncedAt: stats.lastSyncAt,
+      lastError: lastError ?? stats.lastError,
+      failureRetryable
+    };
+  }
+  async listMessages(principal, query = {}) {
+    this.assertPrincipal(principal);
+    if (query.unacknowledgedBy) {
+      await this.ensureRemote();
+      const remotePage = await this.remote.listMessages(principal, query);
+      await this.edge.cacheLatest(remotePage.messages, this.now());
+      const stats = await this.edge.stats();
+      return { ...remotePage, source: "remote", stale: false, lastSyncedAt: stats.lastSyncAt };
+    }
+    if (query.latest) {
+      try {
+        await this.ensureRemote();
+        const remotePage = await this.remote.listMessages(principal, query);
+        await this.edge.cacheLatest(remotePage.messages, this.now());
+        const stats = await this.edge.stats();
+        return { ...remotePage, source: "remote", stale: false, lastSyncedAt: stats.lastSyncAt };
+      } catch (error) {
+        if (!isRetryableSyncError(error)) throw error;
+        await this.edge.noteError(codeOf(error));
+        const cached = await this.edge.list(query);
+        const stats = await this.edge.stats();
+        return { ...cached, source: "cache", stale: true, lastSyncedAt: stats.lastSyncAt };
+      }
+    }
+    await this.sync({ maxPush: 20, maxPages: 0 });
+    try {
+      await this.ensureRemote();
+      const remotePage = await this.remote.listMessages(principal, query);
+      await this.edge.cacheLatest(remotePage.messages, this.now());
+      const stats = await this.edge.stats();
+      return { ...remotePage, source: "remote", stale: false, lastSyncedAt: stats.lastSyncAt };
+    } catch (error) {
+      if (!isRetryableSyncError(error)) throw error;
+      await this.edge.noteError(codeOf(error));
+      const cached = await this.edge.list(query);
+      const stats = await this.edge.stats();
+      return { ...cached, source: "cache", stale: true, lastSyncedAt: stats.lastSyncAt };
+    }
+  }
+  async recordReceipt(workspace, messageIds, principal, readAt) {
+    this.assertPrincipal({ workspace, agent: principal }, false);
+    await this.ensureRemote();
+    return this.remote.recordReceipt(workspace, messageIds, principal, readAt);
+  }
+  async claimDelivery(principal, options) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    return this.remote.claimDelivery(principal, options);
+  }
+  async renewDelivery(principal, deliveryId, leaseToken, leaseMs) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    return this.remote.renewDelivery(principal, deliveryId, leaseToken, leaseMs);
+  }
+  async settleDelivery(principal, deliveryId, leaseToken, state, error, retryPolicy) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    return this.remote.settleDelivery(principal, deliveryId, leaseToken, state, error, retryPolicy);
+  }
+  async diagnostics(principal) {
+    this.assertPrincipal(principal);
+    const edge = await this.edge.stats();
+    let remote;
+    try {
+      await this.ensureRemote();
+      remote = await this.remote.diagnostics?.(principal);
+    } catch {
+    }
+    return {
+      schemaVersion: remote?.schemaVersion ?? "postgres-v2",
+      deliverySupported: remote?.deliverySupported ?? true,
+      pending: remote?.pending ?? null,
+      claimed: remote?.claimed ?? null,
+      retrying: remote?.retrying ?? null,
+      dead: remote?.dead ?? null,
+      oldestAvailableAt: remote?.oldestAvailableAt,
+      principal: { workspace: principal.workspace, agent: principal.agent },
+      remoteReachable: Boolean(remote),
+      outboxPending: edge.pending,
+      outboxBlocked: edge.blocked,
+      cachedMessages: edge.cached,
+      lastSyncAt: edge.lastSyncAt,
+      lastSyncError: edge.lastError
+    };
+  }
+  async heartbeat(principal, leaseMs, runtimeType, capabilities = []) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    if (!this.remote.heartbeat) throw new Error("presence is not supported by the remote provider");
+    return this.remote.heartbeat(principal, leaseMs, runtimeType, capabilities);
+  }
+  async listPresence(principal) {
+    this.assertPrincipal(principal);
+    await this.ensureRemote();
+    if (!this.remote.listPresence) throw new Error("presence is not supported by the remote provider");
+    return this.remote.listPresence(principal);
+  }
+  async close() {
+    await this.edge.close();
+    await this.remote.close?.();
+  }
+};
+
+// src/sqlite-bridge-store.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { chmodSync as chmodSync2, existsSync as existsSync2 } from "fs";
+import { createRequire as createRequire2 } from "module";
+var require3 = createRequire2(import.meta.url);
+function openDatabase2(path) {
+  const { DatabaseSync } = require3("node:sqlite");
+  return new DatabaseSync(path);
+}
+var schema2 = `
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = FULL;
+PRAGMA foreign_keys = ON;
+CREATE TABLE IF NOT EXISTS bridge_messages (
+ sequence INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE, workspace TEXT NOT NULL, source TEXT NOT NULL,
+ type TEXT NOT NULL, content TEXT NOT NULL, content_type TEXT NOT NULL, data TEXT, targets TEXT NOT NULL DEFAULT '[]',
+ thread_id TEXT, reply_to_id TEXT, correlation_id TEXT, causation_id TEXT, priority TEXT NOT NULL, expires_at TEXT,
+ idempotency_key TEXT, atrib_receipt_id TEXT, informed_by TEXT, metadata TEXT, created_at TEXT NOT NULL,
+ UNIQUE(workspace, id), CHECK(json_valid(targets) AND json_type(targets) = 'array'),
+ CHECK(priority IN ('info', 'high', 'urgent'))
+);
+CREATE UNIQUE INDEX IF NOT EXISTS bridge_messages_idempotency ON bridge_messages(workspace, source, idempotency_key) WHERE idempotency_key IS NOT NULL;
+CREATE INDEX IF NOT EXISTS bridge_messages_cursor ON bridge_messages(workspace, sequence);
+CREATE INDEX IF NOT EXISTS bridge_messages_source ON bridge_messages(workspace, source, sequence);
+CREATE INDEX IF NOT EXISTS bridge_messages_thread ON bridge_messages(workspace, thread_id, sequence) WHERE thread_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS bridge_messages_created ON bridge_messages(workspace, created_at, sequence);
+CREATE TABLE IF NOT EXISTS bridge_receipts (workspace TEXT NOT NULL, message_id TEXT NOT NULL, principal TEXT NOT NULL, read_at TEXT NOT NULL, PRIMARY KEY(workspace, message_id, principal), FOREIGN KEY(workspace, message_id) REFERENCES bridge_messages(workspace, id) ON DELETE CASCADE);
+CREATE TABLE IF NOT EXISTS bridge_deliveries (
+ id TEXT PRIMARY KEY, message_id TEXT NOT NULL, workspace TEXT NOT NULL, recipient TEXT NOT NULL,
+ state TEXT NOT NULL, attempt INTEGER NOT NULL DEFAULT 0, available_at TEXT NOT NULL, lease_token TEXT, lease_owner TEXT, lease_expires_at TEXT, last_error TEXT,
+ UNIQUE(message_id, recipient), FOREIGN KEY(workspace, message_id) REFERENCES bridge_messages(workspace, id) ON DELETE CASCADE,
+ CHECK(state IN ('pending', 'claimed', 'acked', 'retrying', 'dead')), CHECK(attempt >= 0),
+ CHECK((state = 'claimed' AND lease_token IS NOT NULL AND lease_expires_at IS NOT NULL) OR (state <> 'claimed' AND lease_token IS NULL AND lease_owner IS NULL AND lease_expires_at IS NULL))
+);
+CREATE INDEX IF NOT EXISTS bridge_deliveries_claim ON bridge_deliveries(workspace, recipient, state, available_at);
+CREATE TABLE IF NOT EXISTS bridge_delivery_events (
+ sequence INTEGER PRIMARY KEY AUTOINCREMENT, delivery_id TEXT NOT NULL,
+ message_id TEXT NOT NULL, workspace TEXT NOT NULL, recipient TEXT NOT NULL,
+ from_state TEXT, to_state TEXT NOT NULL, attempt INTEGER NOT NULL,
+ lease_owner TEXT, error TEXT, created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS bridge_delivery_events_lookup
+ ON bridge_delivery_events(workspace, delivery_id, sequence);
+CREATE TRIGGER IF NOT EXISTS bridge_delivery_events_insert
+ AFTER INSERT ON bridge_deliveries BEGIN
+  INSERT INTO bridge_delivery_events
+   (delivery_id,message_id,workspace,recipient,from_state,to_state,attempt,lease_owner,error,created_at)
+  VALUES
+   (NEW.id,NEW.message_id,NEW.workspace,NEW.recipient,NULL,NEW.state,NEW.attempt,NEW.lease_owner,NEW.last_error,strftime('%Y-%m-%dT%H:%M:%fZ','now'));
+ END;
+CREATE TRIGGER IF NOT EXISTS bridge_delivery_events_update
+ AFTER UPDATE ON bridge_deliveries
+ WHEN OLD.state IS NOT NEW.state OR OLD.attempt IS NOT NEW.attempt BEGIN
+  INSERT INTO bridge_delivery_events
+   (delivery_id,message_id,workspace,recipient,from_state,to_state,attempt,lease_owner,error,created_at)
+  VALUES
+   (NEW.id,NEW.message_id,NEW.workspace,NEW.recipient,OLD.state,NEW.state,NEW.attempt,NEW.lease_owner,NEW.last_error,strftime('%Y-%m-%dT%H:%M:%fZ','now'));
+ END;
+CREATE TABLE IF NOT EXISTS bridge_presence (
+ workspace TEXT NOT NULL, agent TEXT NOT NULL, instance TEXT NOT NULL, runtime_type TEXT,
+ capabilities TEXT NOT NULL DEFAULT '[]', lease_expires_at TEXT NOT NULL, last_seen_at TEXT NOT NULL,
+ PRIMARY KEY(workspace, agent, instance), CHECK(json_valid(capabilities) AND json_type(capabilities)='array')
+);
+CREATE INDEX IF NOT EXISTS bridge_presence_active ON bridge_presence(workspace, lease_expires_at);
+CREATE TRIGGER IF NOT EXISTS bridge_messages_no_update BEFORE UPDATE ON bridge_messages BEGIN SELECT RAISE(ABORT, 'bridge messages are immutable'); END;
+CREATE TRIGGER IF NOT EXISTS bridge_messages_no_delete BEFORE DELETE ON bridge_messages BEGIN SELECT RAISE(ABORT, 'bridge messages are immutable'); END;
+`;
+function stringify(value) {
+  return value === void 0 ? null : JSON.stringify(value);
+}
+function parse(value) {
+  return typeof value === "string" ? JSON.parse(value) : void 0;
+}
+function message(row) {
+  return { id: String(row.id), workspace: String(row.workspace), source: String(row.source), sequence: String(row.sequence), type: String(row.type), content: String(row.content), contentType: String(row.content_type), data: parse(row.data), targets: parse(row.targets) ?? [], threadId: row.thread_id, replyToId: row.reply_to_id, correlationId: row.correlation_id, causationId: row.causation_id, priority: row.priority, expiresAt: row.expires_at, idempotencyKey: row.idempotency_key, atribReceiptId: row.atrib_receipt_id, informedBy: parse(row.informed_by), metadata: parse(row.metadata), createdAt: String(row.created_at) };
+}
+function delivery(row) {
+  return { id: String(row.id), messageId: String(row.message_id), workspace: String(row.workspace), recipient: String(row.recipient), state: row.state, attempt: Number(row.attempt), availableAt: String(row.available_at), leaseToken: row.lease_token, leaseOwner: row.lease_owner, leaseExpiresAt: row.lease_expires_at, lastError: row.last_error };
+}
+function presence(row) {
+  return { workspace: String(row.workspace), agent: String(row.agent), instance: String(row.instance), runtimeType: row.runtime_type, capabilities: parse(row.capabilities) ?? [], leaseExpiresAt: String(row.lease_expires_at), lastSeenAt: String(row.last_seen_at) };
+}
+function deliveryEvent(row) {
+  return { sequence: String(row.sequence), deliveryId: String(row.delivery_id), messageId: String(row.message_id), workspace: String(row.workspace), recipient: String(row.recipient), fromState: row.from_state, toState: row.to_state, attempt: Number(row.attempt), leaseOwner: row.lease_owner, error: row.error, createdAt: String(row.created_at) };
+}
+var SQLiteBridgeStore = class {
+  constructor(path = ":memory:", busyTimeoutMs = 2e3) {
+    this.path = path;
+    this.busyTimeoutMs = busyTimeoutMs;
+    this.initialized = false;
+    this.db = openDatabase2(path);
+    this.restrictFiles();
+  }
+  restrictFiles() {
+    if (this.path === ":memory:") return;
+    for (const path of [this.path, `${this.path}-wal`, `${this.path}-shm`]) {
+      if (existsSync2(path)) chmodSync2(path, 384);
+    }
+  }
+  async initialize() {
+    if (this.initialized) return;
+    const versionRow = this.db.prepare("SELECT sqlite_version() AS version").get();
+    const parts = String(versionRow.version).split(".").map(Number);
+    const encoded = (parts[0] ?? 0) * 1e6 + (parts[1] ?? 0) * 1e3 + (parts[2] ?? 0);
+    if (encoded < 3051003) throw new Error("SQLite 3.51.3 or newer is required");
+    this.db.exec(`PRAGMA busy_timeout = ${Math.max(1, Math.trunc(this.busyTimeoutMs))}; ${schema2}`);
+    this.restrictFiles();
+    this.initialized = true;
+  }
+  async ready() {
+    await this.initialize();
+  }
+  async insertMessage(input) {
+    await this.ready();
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      if (input.idempotencyKey) {
+        const existing = this.db.prepare("SELECT * FROM bridge_messages WHERE workspace = ? AND source = ? AND idempotency_key = ?").get(input.workspace, input.source, input.idempotencyKey);
+        if (existing) {
+          const replay = message(existing);
+          assertIdempotentReplay(replay, input);
+          this.db.exec("COMMIT");
+          return { message: replay, created: false };
+        }
+      }
+      this.db.prepare(`INSERT INTO bridge_messages (id,workspace,source,type,content,content_type,data,targets,thread_id,reply_to_id,correlation_id,causation_id,priority,expires_at,idempotency_key,atrib_receipt_id,informed_by,metadata,created_at) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(input.id, input.workspace, input.source, input.type, input.content, input.contentType, stringify(input.data), JSON.stringify(input.targets), input.threadId ?? null, input.replyToId ?? null, input.correlationId ?? null, input.causationId ?? null, input.priority, input.expiresAt ?? null, input.idempotencyKey ?? null, input.atribReceiptId ?? null, stringify(input.informedBy), stringify(input.metadata), createdAt);
+      for (const recipient of input.targets) this.db.prepare("INSERT INTO bridge_deliveries (id,message_id,workspace,recipient,state,available_at) VALUES (?,?,?,?,?,?)").run(randomUUID2(), input.id, input.workspace, recipient, "pending", createdAt);
+      const row = this.db.prepare("SELECT * FROM bridge_messages WHERE id = ?").get(input.id);
+      this.db.exec("COMMIT");
+      return { message: message(row), created: true };
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async listMessages(principal, query = {}) {
+    await this.ready();
+    const cursor = decodeCursor(query.cursor);
+    const limit = Math.min(Math.max(Math.trunc(query.limit ?? 50), 1), 200);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const highWaterRow = query.latest ? void 0 : this.db.prepare("SELECT max(sequence) AS sequence FROM bridge_messages WHERE workspace=?").get(principal.workspace);
+    const highWater = highWaterRow?.sequence === null || highWaterRow?.sequence === void 0 ? void 0 : String(highWaterRow.sequence);
+    const clauses = ["workspace = ?", query.latest ? "1=1" : "sequence > ?", "(targets = '[]' OR EXISTS (SELECT 1 FROM json_each(targets) WHERE value = ?))"];
+    const args = query.latest ? [principal.workspace, principal.agent] : [principal.workspace, cursor ?? "0", principal.agent];
+    if (highWater) {
+      clauses.push("sequence <= ?");
+      args.push(highWater);
+    }
+    if (!query.includeExpired) {
+      clauses.push("(expires_at IS NULL OR expires_at > ?)");
+      args.push(now);
+    }
+    if (query.types?.length) {
+      clauses.push(`type IN (${query.types.map(() => "?").join(",")})`);
+      args.push(...query.types);
+    }
+    if (query.source) {
+      clauses.push("source = ?");
+      args.push(query.source);
+    }
+    if (query.since) {
+      clauses.push("created_at >= ?");
+      args.push(query.since);
+    }
+    if (query.unacknowledgedBy) {
+      clauses.push("NOT EXISTS (SELECT 1 FROM bridge_receipts receipt WHERE receipt.workspace=bridge_messages.workspace AND receipt.message_id=bridge_messages.id AND receipt.principal=?)");
+      args.push(query.unacknowledgedBy);
+    }
+    if (query.threadId) {
+      clauses.push("thread_id = ?");
+      args.push(query.threadId);
+    }
+    const rows = this.db.prepare(`SELECT * FROM bridge_messages WHERE ${clauses.join(" AND ")} ORDER BY sequence ${query.latest ? "DESC" : "ASC"} LIMIT ?`).all(...args, limit);
+    const messages = rows.map(message);
+    const last = messages[messages.length - 1];
+    if (query.latest) return { messages, cursor: messages[0] ? encodeCursor(messages[0].sequence) : query.cursor };
+    if (messages.length === limit) return { messages, cursor: encodeCursor(last.sequence) };
+    return { messages, cursor: highWater ? encodeCursor(highWater) : query.cursor };
+  }
+  async recordReceipt(workspace, messageIds, principal, readAt = /* @__PURE__ */ new Date()) {
+    await this.ready();
+    const stmt = this.db.prepare("INSERT OR IGNORE INTO bridge_receipts (workspace,message_id,principal,read_at) SELECT workspace,id,?,? FROM bridge_messages WHERE workspace=? AND id=? AND (targets='[]' OR EXISTS (SELECT 1 FROM json_each(targets) WHERE value=?))");
+    let changed = 0;
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      for (const id of messageIds) changed += Number(stmt.run(principal, readAt.toISOString(), workspace, id, principal).changes);
+      this.db.exec("COMMIT");
+      return changed;
+    } catch (e) {
+      this.db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+  async claimDelivery(principal, options) {
+    await this.ready();
+    const now = options.now ?? /* @__PURE__ */ new Date();
+    const nowText = now.toISOString();
+    const expires = new Date(now.getTime() + options.leaseMs).toISOString();
+    const owner = principal.instance ?? principal.agent;
+    const maxAttempts = options.maxAttempts ?? 5;
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.db.prepare("UPDATE bridge_deliveries SET state='dead', last_error='message expired', lease_token=NULL, lease_owner=NULL, lease_expires_at=NULL WHERE workspace=? AND recipient=? AND state IN ('pending','retrying','claimed') AND EXISTS (SELECT 1 FROM bridge_messages message WHERE message.workspace=bridge_deliveries.workspace AND message.id=bridge_deliveries.message_id AND message.expires_at IS NOT NULL AND message.expires_at <= ?)").run(principal.workspace, principal.agent, nowText);
+      this.db.prepare("UPDATE bridge_deliveries SET state='dead', last_error='maximum attempts reached', lease_token=NULL, lease_owner=NULL, lease_expires_at=NULL WHERE workspace=? AND recipient=? AND attempt>=? AND (state IN ('pending','retrying') OR (state='claimed' AND lease_expires_at<=?))").run(principal.workspace, principal.agent, maxAttempts, nowText);
+      this.db.prepare("UPDATE bridge_deliveries SET state='retrying', lease_token=NULL, lease_owner=NULL, lease_expires_at=NULL WHERE workspace=? AND recipient=? AND state='claimed' AND lease_expires_at <= ? AND attempt<?").run(principal.workspace, principal.agent, nowText, maxAttempts);
+      const candidate = this.db.prepare("SELECT delivery.id FROM bridge_deliveries delivery JOIN bridge_messages message ON message.workspace=delivery.workspace AND message.id=delivery.message_id WHERE delivery.workspace=? AND delivery.recipient=? AND delivery.state IN ('pending','retrying') AND delivery.available_at <= ? AND delivery.attempt<? AND (message.expires_at IS NULL OR message.expires_at > ?) ORDER BY delivery.available_at,delivery.id LIMIT 1").get(principal.workspace, principal.agent, nowText, maxAttempts, nowText);
+      if (!candidate) {
+        this.db.exec("COMMIT");
+        return null;
+      }
+      const candidateId = String(candidate.id);
+      const token = randomUUID2();
+      this.db.prepare("UPDATE bridge_deliveries SET state='claimed', attempt=attempt+1, lease_token=?, lease_owner=?, lease_expires_at=? WHERE id=?").run(token, owner, expires, candidateId);
+      const claimed = this.db.prepare("SELECT * FROM bridge_deliveries WHERE id=?").get(candidateId);
+      this.db.exec("COMMIT");
+      return delivery(claimed);
+    } catch (e) {
+      this.db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+  async renewDelivery(principal, id, token, leaseMs) {
+    await this.ready();
+    const now = /* @__PURE__ */ new Date();
+    const expires = new Date(now.getTime() + leaseMs).toISOString();
+    const owner = principal.instance ?? principal.agent;
+    const result = this.db.prepare("UPDATE bridge_deliveries SET lease_expires_at=? WHERE workspace=? AND recipient=? AND lease_owner=? AND id=? AND lease_token=? AND state='claimed' AND lease_expires_at > ?").run(expires, principal.workspace, principal.agent, owner, id, token, now.toISOString());
+    if (!result.changes) return null;
+    return delivery(this.db.prepare("SELECT * FROM bridge_deliveries WHERE id=?").get(id));
+  }
+  async settleDelivery(principal, id, token, state, error, retryPolicy) {
+    await this.ready();
+    const now = /* @__PURE__ */ new Date();
+    const owner = principal.instance ?? principal.agent;
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const current = this.db.prepare("SELECT * FROM bridge_deliveries WHERE workspace=? AND recipient=? AND lease_owner=? AND id=? AND lease_token=? AND state='claimed' AND lease_expires_at > ?").get(principal.workspace, principal.agent, owner, id, token, now.toISOString());
+      if (!current) {
+        this.db.exec("COMMIT");
+        return null;
+      }
+      const attempt = Number(current.attempt);
+      const nextState = state === "retrying" && attempt >= retryPolicy.maxAttempts ? "dead" : state;
+      const exponential = Math.min(retryPolicy.maxDelayMs, retryPolicy.baseDelayMs * 2 ** Math.max(0, attempt - 1));
+      const jitter = 1 + (Math.random() * 2 - 1) * retryPolicy.jitterRatio;
+      const delay = nextState === "retrying" ? Math.max(1, Math.round(exponential * jitter)) : 0;
+      const available = new Date(now.getTime() + delay).toISOString();
+      this.db.prepare("UPDATE bridge_deliveries SET state=?, available_at=?, last_error=?, lease_token=NULL, lease_owner=NULL, lease_expires_at=NULL WHERE id=?").run(nextState, available, error?.slice(0, 1024) ?? null, id);
+      const result = delivery(this.db.prepare("SELECT * FROM bridge_deliveries WHERE id=?").get(id));
+      this.db.exec("COMMIT");
+      return result;
+    } catch (caught) {
+      this.db.exec("ROLLBACK");
+      throw caught;
+    }
+  }
+  async diagnostics(principal) {
+    await this.ready();
+    const rows = this.db.prepare("SELECT state, count(*) AS count, min(available_at) AS oldest FROM bridge_deliveries WHERE workspace=? AND recipient=? GROUP BY state").all(principal.workspace, principal.agent);
+    const counts = new Map(rows.map((row) => [String(row.state), Number(row.count)]));
+    const oldest = rows.filter((row) => row.state === "pending" || row.state === "retrying").map((row) => row.oldest ? String(row.oldest) : void 0).filter(Boolean).sort()[0];
+    return { schemaVersion: "local-v2", deliverySupported: true, pending: counts.get("pending") ?? 0, claimed: counts.get("claimed") ?? 0, retrying: counts.get("retrying") ?? 0, dead: counts.get("dead") ?? 0, oldestAvailableAt: oldest };
+  }
+  async heartbeat(principal, leaseMs, runtimeType, capabilities = []) {
+    await this.ready();
+    const now = /* @__PURE__ */ new Date();
+    const nowText = now.toISOString();
+    const expires = new Date(now.getTime() + leaseMs).toISOString();
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.db.prepare("DELETE FROM bridge_presence WHERE workspace=? AND lease_expires_at<=?").run(principal.workspace, nowText);
+      const current = this.db.prepare("SELECT 1 FROM bridge_presence WHERE workspace=? AND agent=? AND instance=?").get(principal.workspace, principal.agent, principal.instance);
+      const agentCount = this.db.prepare("SELECT count(*) AS count FROM bridge_presence WHERE workspace=? AND agent=?").get(principal.workspace, principal.agent);
+      const workspaceCount = this.db.prepare("SELECT count(*) AS count FROM bridge_presence WHERE workspace=?").get(principal.workspace);
+      if (!current && (Number(agentCount.count) >= 128 || Number(workspaceCount.count) >= 4096)) {
+        throw Object.assign(new Error("active instance limit reached"), {
+          status: 429,
+          code: "presence_limit"
+        });
+      }
+      this.db.prepare("INSERT INTO bridge_presence (workspace,agent,instance,runtime_type,capabilities,lease_expires_at,last_seen_at) VALUES (?,?,?,?,?,?,?) ON CONFLICT(workspace,agent,instance) DO UPDATE SET runtime_type=excluded.runtime_type, capabilities=excluded.capabilities, lease_expires_at=excluded.lease_expires_at, last_seen_at=excluded.last_seen_at").run(principal.workspace, principal.agent, principal.instance, runtimeType ?? null, JSON.stringify(capabilities), expires, nowText);
+      const result = presence(this.db.prepare("SELECT * FROM bridge_presence WHERE workspace=? AND agent=? AND instance=?").get(principal.workspace, principal.agent, principal.instance));
+      this.db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async listPresence(principal) {
+    await this.ready();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.db.prepare("DELETE FROM bridge_presence WHERE workspace=? AND lease_expires_at<=?").run(principal.workspace, now);
+    const rows = this.db.prepare("SELECT * FROM bridge_presence WHERE workspace=? ORDER BY agent,instance").all(principal.workspace);
+    return rows.map(presence);
+  }
+  async listDeliveryEvents(deliveryId) {
+    await this.ready();
+    const rows = this.db.prepare("SELECT * FROM bridge_delivery_events WHERE delivery_id=? ORDER BY sequence").all(deliveryId);
+    return rows.map(deliveryEvent);
+  }
+  async close() {
+    this.db.close();
+  }
+};
+
+export {
+  EdgeConflictError,
+  edgeMessageFingerprint,
+  stableIdempotency,
+  edgeScopeKey,
+  SQLiteEdgeStore,
+  isRetryableSyncError,
+  SyncingBridgeStore,
+  SQLiteBridgeStore
+};
+//# sourceMappingURL=chunk-WEULPMUY.js.map