opencode-swarm 7.164.11 → 7.164.12

package/dist/cli/index-es64amqt.js

@@ -0,0 +1,675 @@
+// @bun
+import {
+  canonicalExistingFilesystemPath
+} from "./index-ry16d01s.js";
+import {
+  loadDatabaseCtor
+} from "./index-n4fzmqz8.js";
+import {
+  canonicalRootKeyFresh,
+  lexicalRootAliasKey
+} from "./index-7qefgq4j.js";
+import {
+  atomicWriteSwarmFileSync
+} from "./index-ewv8qa8q.js";
+
+// src/db/project-db.ts
+import { existsSync, mkdirSync, unlinkSync } from "fs";
+import { join, resolve } from "path";
+
+// src/db/db-errors.ts
+class ProjectDbError extends Error {
+  category;
+  constructor(category, message) {
+    super(message);
+    this.name = "ProjectDbError";
+    this.category = category;
+  }
+}
+
+class DbWriteError extends Error {
+  category;
+  constructor(category, message) {
+    super(message);
+    this.name = "DbWriteError";
+    this.category = category;
+  }
+}
+function classifyDbWriteError(err) {
+  const errno = err?.code;
+  if (errno === "ENOSPC")
+    return "disk_full";
+  if (errno === "EACCES" || errno === "EROFS" || errno === "EPERM")
+    return "read_only";
+  const message = err instanceof Error ? err.message : String(err);
+  const upper = message.toUpperCase();
+  if (upper.includes("SQLITE_FULL") || upper.includes("DATABASE OR DISK IS FULL")) {
+    return "disk_full";
+  }
+  if (upper.includes("SQLITE_READONLY") || upper.includes("ATTEMPT TO WRITE A READONLY")) {
+    return "read_only";
+  }
+  if (upper.includes("SQLITE_CORRUPT") || upper.includes("DATABASE DISK IMAGE IS MALFORMED") || upper.includes("NOT A DATABASE")) {
+    return "corrupt";
+  }
+  if (upper.includes("SQLITE_BUSY") || upper.includes("DATABASE IS LOCKED")) {
+    return "busy";
+  }
+  return "unknown";
+}
+
+// src/db/project-db.ts
+var MIGRATION_FAILURE_ERROR_MAX_CHARS = 500;
+var MIGRATION_FAILURE_MARKER = "db-migration-failure.json";
+var MIGRATION_BUSY_RETRIES = 2;
+var OPEN_CONTENTION_RETRIES = 4;
+var MIGRATIONS = [
+  {
+    version: 1,
+    name: "create_project_constraints",
+    sql: `CREATE TABLE project_constraints (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			constraint_type TEXT NOT NULL,
+			content TEXT NOT NULL,
+			created_at TEXT NOT NULL DEFAULT (datetime('now'))
+		)`
+  },
+  {
+    version: 2,
+    name: "create_qa_gate_profile",
+    sql: `CREATE TABLE qa_gate_profile (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			plan_id TEXT NOT NULL UNIQUE,
+			created_at TEXT NOT NULL DEFAULT (datetime('now')),
+			project_type TEXT,
+			gates TEXT NOT NULL DEFAULT '{}',
+			locked_at TEXT,
+			locked_by_snapshot_seq INTEGER
+		)`
+  },
+  {
+    version: 3,
+    name: "create_qa_gate_profile_immutability_trigger",
+    sql: `CREATE TRIGGER IF NOT EXISTS trg_qa_gate_profile_no_update_after_lock
+			BEFORE UPDATE ON qa_gate_profile
+			WHEN OLD.locked_at IS NOT NULL
+			BEGIN
+				SELECT RAISE(ABORT, 'qa_gate_profile row is locked and cannot be modified after critic approval');
+			END`
+  },
+  {
+    version: 4,
+    name: "add_qa_gate_profile_raw_swarm",
+    sql: "ALTER TABLE qa_gate_profile ADD COLUMN raw_swarm TEXT"
+  },
+  {
+    version: 5,
+    name: "add_qa_gate_profile_raw_title",
+    sql: "ALTER TABLE qa_gate_profile ADD COLUMN raw_title TEXT"
+  },
+  {
+    version: 6,
+    name: "add_qa_gate_profile_identity_hash",
+    sql: "ALTER TABLE qa_gate_profile ADD COLUMN identity_hash TEXT"
+  },
+  {
+    version: 7,
+    name: "create_qa_gate_profile_identity_hash_index",
+    sql: `CREATE UNIQUE INDEX IF NOT EXISTS idx_qa_gate_profile_identity_hash
+			ON qa_gate_profile(identity_hash)
+			WHERE identity_hash IS NOT NULL`
+  },
+  {
+    version: 8,
+    name: "create_qa_gate_profile_identity",
+    sql: `CREATE TABLE qa_gate_profile_identity (
+			identity_hash TEXT PRIMARY KEY,
+			profile_id INTEGER NOT NULL UNIQUE REFERENCES qa_gate_profile(id) ON DELETE CASCADE,
+			raw_swarm TEXT NOT NULL,
+			raw_title TEXT NOT NULL,
+			readable_plan_id TEXT NOT NULL
+		)`
+  },
+  {
+    version: 9,
+    name: "create_qa_gate_profile_identity_readable_plan_index",
+    sql: `CREATE INDEX idx_qa_gate_profile_identity_readable_plan_id
+			ON qa_gate_profile_identity(readable_plan_id)`
+  },
+  {
+    version: 10,
+    name: "backfill_qa_gate_profile_identity_from_legacy_columns",
+    sql: `INSERT INTO qa_gate_profile_identity (
+				identity_hash,
+				profile_id,
+				raw_swarm,
+				raw_title,
+				readable_plan_id
+			)
+			SELECT
+				identity_hash,
+				id,
+				raw_swarm,
+				raw_title,
+				plan_id
+			FROM qa_gate_profile
+			WHERE identity_hash IS NOT NULL
+				AND raw_swarm IS NOT NULL
+				AND raw_title IS NOT NULL
+				AND NOT EXISTS (
+					SELECT 1
+					FROM qa_gate_profile_identity AS qi
+					WHERE qi.profile_id = qa_gate_profile.id
+				)`
+  },
+  {
+    version: 11,
+    name: "create_task_checkpoint_receipt",
+    sql: `CREATE TABLE task_checkpoint_receipt (
+			plan_identity_hash TEXT NOT NULL,
+			task_id TEXT NOT NULL,
+			label TEXT NOT NULL,
+			state TEXT NOT NULL CHECK(state IN ('pending', 'committed', 'logged')),
+			sha TEXT,
+			created_at TEXT NOT NULL DEFAULT (datetime('now')),
+			updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+			PRIMARY KEY(plan_identity_hash, task_id)
+		)`
+  },
+  {
+    version: 12,
+    name: "add_task_checkpoint_receipt_completion_generation",
+    sql: `ALTER TABLE task_checkpoint_receipt
+			ADD COLUMN generation INTEGER NOT NULL DEFAULT 1;
+		ALTER TABLE task_checkpoint_receipt
+			ADD COLUMN completion_active INTEGER NOT NULL DEFAULT 1
+			CHECK(completion_active IN (0, 1))`
+  },
+  {
+    version: 13,
+    name: "bind_task_checkpoint_receipt_to_completion_ledger_seq",
+    sql: `ALTER TABLE task_checkpoint_receipt
+			ADD COLUMN completion_ledger_seq INTEGER
+			CHECK(completion_ledger_seq IS NULL OR completion_ledger_seq >= 0)`
+  },
+  {
+    version: 14,
+    name: "create_migration_failures",
+    sql: `CREATE TABLE IF NOT EXISTS migration_failures (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			version INTEGER NOT NULL,
+			name TEXT NOT NULL,
+			error TEXT NOT NULL,
+			failed_at TEXT NOT NULL DEFAULT (datetime('now'))
+		)`
+  },
+  {
+    version: 15,
+    name: "create_insight_candidate_stream",
+    sql: `CREATE TABLE IF NOT EXISTS insight_candidate (
+			stream_id TEXT NOT NULL,
+			version INTEGER NOT NULL,
+			payload TEXT NOT NULL,
+			created_at TEXT NOT NULL,
+			consumed_at TEXT,
+			PRIMARY KEY(stream_id, version)
+		)`
+  },
+  {
+    version: 16,
+    name: "create_insight_candidate_pending_index",
+    sql: `CREATE INDEX IF NOT EXISTS idx_insight_candidate_pending
+			ON insight_candidate(stream_id, version)
+			WHERE consumed_at IS NULL`
+  },
+  {
+    version: 17,
+    name: "create_phase_report",
+    sql: `CREATE TABLE IF NOT EXISTS phase_report (
+			kind TEXT NOT NULL CHECK(kind IN ('curator_drift', 'design_doc_drift')),
+			phase INTEGER NOT NULL,
+			payload TEXT NOT NULL,
+			updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+			PRIMARY KEY(kind, phase)
+		)`
+  },
+  {
+    version: 18,
+    name: "create_coordination_event",
+    sql: `CREATE TABLE IF NOT EXISTS coordination_event (
+			stream_id TEXT NOT NULL,
+			version INTEGER NOT NULL CHECK(version >= 1),
+			idempotency_key TEXT NOT NULL,
+			event_type TEXT NOT NULL,
+			generation INTEGER NOT NULL CHECK(generation >= 0),
+			payload TEXT NOT NULL,
+			created_at TEXT NOT NULL,
+			PRIMARY KEY(stream_id, version),
+			UNIQUE(stream_id, idempotency_key)
+		)`
+  },
+  {
+    version: 19,
+    name: "create_coordination_event_type_index",
+    sql: `CREATE INDEX IF NOT EXISTS idx_coordination_event_type
+			ON coordination_event(event_type, created_at)`
+  },
+  {
+    version: 20,
+    name: "create_coordination_state",
+    sql: `CREATE TABLE IF NOT EXISTS coordination_state (
+			namespace TEXT NOT NULL,
+			entity_key TEXT NOT NULL,
+			revision INTEGER NOT NULL CHECK(revision >= 1),
+			generation INTEGER NOT NULL CHECK(generation >= 0),
+			status TEXT NOT NULL,
+			payload TEXT NOT NULL,
+			updated_at TEXT NOT NULL,
+			PRIMARY KEY(namespace, entity_key)
+		)`
+  },
+  {
+    version: 21,
+    name: "create_coordination_state_status_index",
+    sql: `CREATE INDEX IF NOT EXISTS idx_coordination_state_status
+			ON coordination_state(namespace, status, updated_at)`
+  },
+  {
+    version: 22,
+    name: "create_coordination_lease",
+    sql: `CREATE TABLE IF NOT EXISTS coordination_lease (
+			namespace TEXT NOT NULL,
+			entity_key TEXT NOT NULL,
+			generation INTEGER NOT NULL CHECK(generation >= 0),
+			owner_token TEXT NOT NULL,
+			lease_expires_at TEXT NOT NULL,
+			payload TEXT NOT NULL,
+			updated_at TEXT NOT NULL,
+			PRIMARY KEY(namespace, entity_key)
+		)`
+  },
+  {
+    version: 23,
+    name: "create_coordination_lease_expiry_index",
+    sql: `CREATE INDEX IF NOT EXISTS idx_coordination_lease_expiry
+			ON coordination_lease(namespace, lease_expires_at)`
+  },
+  {
+    version: 24,
+    name: "create_coordination_import",
+    sql: `CREATE TABLE IF NOT EXISTS coordination_import (
+			source TEXT PRIMARY KEY,
+			imported_at TEXT NOT NULL,
+			source_digest TEXT NOT NULL,
+			row_count INTEGER NOT NULL CHECK(row_count >= 0)
+		)`
+  },
+  {
+    version: 25,
+    name: "create_coordination_event_created_index",
+    sql: `CREATE INDEX IF NOT EXISTS idx_coordination_event_created
+			ON coordination_event(created_at, stream_id, version)`
+  },
+  {
+    version: 26,
+    name: "create_coordination_event_idempotency_fence",
+    sql: `CREATE TABLE IF NOT EXISTS coordination_event_fence (
+			stream_id TEXT NOT NULL,
+			idempotency_key TEXT NOT NULL,
+			event_type TEXT NOT NULL,
+			generation INTEGER NOT NULL CHECK(generation >= 0),
+			payload_digest TEXT NOT NULL,
+			created_at TEXT NOT NULL,
+			PRIMARY KEY(stream_id, idempotency_key)
+		)`
+  },
+  {
+    version: 27,
+    name: "create_coordination_event_fence_stream_age_index",
+    sql: `CREATE INDEX IF NOT EXISTS idx_coordination_event_fence_stream_age
+			ON coordination_event_fence(stream_id, created_at)`
+  },
+  {
+    version: 28,
+    name: "create_coordination_event_fence_global_age_index",
+    sql: `CREATE INDEX IF NOT EXISTS idx_coordination_event_fence_global_age
+			ON coordination_event_fence(created_at, stream_id)`
+  }
+];
+var _projectDbs = new Map;
+var _projectDbAliases = new Map;
+var MAX_ALIASES_PER_PROJECT_DB = 128;
+function lexicalAliasKey(directory) {
+  return lexicalRootAliasKey(directory);
+}
+function unbindAlias(alias, physicalKey) {
+  if (_projectDbAliases.get(alias) === physicalKey) {
+    _projectDbAliases.delete(alias);
+  }
+  _projectDbs.get(physicalKey)?.aliases.delete(alias);
+}
+function bindAlias(record, physicalKey, alias) {
+  const previousKey = _projectDbAliases.get(alias);
+  if (previousKey !== undefined && previousKey !== physicalKey) {
+    unbindAlias(alias, previousKey);
+  }
+  record.aliases.delete(alias);
+  record.aliases.add(alias);
+  _projectDbAliases.set(alias, physicalKey);
+  while (record.aliases.size > MAX_ALIASES_PER_PROJECT_DB) {
+    const evicted = [...record.aliases].find((candidate) => candidate !== record.primaryAlias && candidate !== alias);
+    if (evicted === undefined)
+      break;
+    unbindAlias(evicted, physicalKey);
+  }
+}
+function closeRecord(physicalKey, record) {
+  _internals.checkpointWalBestEffort(record.db);
+  record.db.close();
+  _projectDbs.delete(physicalKey);
+  for (const alias of [...record.aliases])
+    unbindAlias(alias, physicalKey);
+}
+function recordMigrationFailure(db, migration, err, markerDir) {
+  const errorText = String(err instanceof Error ? err.message : err).slice(0, MIGRATION_FAILURE_ERROR_MAX_CHARS);
+  try {
+    db.run("INSERT INTO migration_failures (version, name, error) VALUES (?, ?, ?)", [migration.version, migration.name, errorText]);
+    return;
+  } catch {}
+  if (!markerDir)
+    return;
+  try {
+    atomicWriteSwarmFileSync(join(markerDir, MIGRATION_FAILURE_MARKER), JSON.stringify({
+      schema_version: 1,
+      version: migration.version,
+      name: migration.name,
+      error: errorText,
+      failed_at: new Date().toISOString()
+    }, null, 2));
+  } catch {}
+}
+function removeMigrationFailureMarker(markerDir) {
+  const marker = join(markerDir, MIGRATION_FAILURE_MARKER);
+  if (!existsSync(marker))
+    return;
+  try {
+    unlinkSync(marker);
+  } catch {}
+}
+function isConcurrentMigrationApply(err) {
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  if (msg.includes("unique constraint failed: schema_migrations"))
+    return true;
+  return msg.includes("already exists") && (msg.includes("table") || msg.includes("index") || msg.includes("trigger"));
+}
+function isSqliteBusy(err) {
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  return msg.includes("sqlite_busy") || msg.includes("database is locked") || msg.includes("database is busy");
+}
+function isConcurrentOpenContention(err, dbPath) {
+  if (isSqliteBusy(err))
+    return true;
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  return msg.includes("disk i/o error") && existsSync(dbPath);
+}
+function sleepSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < ms) {}
+  }
+}
+function currentVersionNowCovers(db, version) {
+  const row = db.query("SELECT MAX(version) as version FROM schema_migrations").get();
+  return (row?.version ?? 0) >= version;
+}
+function currentVersionNowCoversSafely(db, version) {
+  try {
+    return currentVersionNowCovers(db, version);
+  } catch {
+    return false;
+  }
+}
+function runProjectMigrations(db, markerDir) {
+  db.run(`CREATE TABLE IF NOT EXISTS schema_migrations (
+		version INTEGER PRIMARY KEY,
+		name TEXT NOT NULL,
+		applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+	)`);
+  const row = db.query("SELECT MAX(version) as version FROM schema_migrations").get();
+  const currentVersion = row?.version ?? 0;
+  for (const migration of MIGRATIONS) {
+    if (migration.version <= currentVersion)
+      continue;
+    const apply = db.transaction(() => {
+      db.run(migration.sql);
+      db.run("INSERT INTO schema_migrations (version, name) VALUES (?, ?)", [
+        migration.version,
+        migration.name
+      ]);
+    });
+    let lastError;
+    for (let attempt = 0;attempt <= MIGRATION_BUSY_RETRIES; attempt += 1) {
+      try {
+        apply();
+        lastError = undefined;
+        break;
+      } catch (err) {
+        lastError = err;
+        if (currentVersionNowCoversSafely(db, migration.version)) {
+          lastError = undefined;
+          break;
+        }
+        if (!isSqliteBusy(err) || attempt === MIGRATION_BUSY_RETRIES)
+          break;
+        sleepSync(10 * (attempt + 1));
+      }
+    }
+    if (lastError !== undefined) {
+      const err = lastError;
+      if (isConcurrentMigrationApply(err) && currentVersionNowCoversSafely(db, migration.version)) {
+        continue;
+      }
+      recordMigrationFailure(db, migration, err, markerDir);
+      throw new ProjectDbError("migration_failed", `swarm.db migration v${migration.version} (${migration.name}) failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (markerDir)
+    removeMigrationFailureMarker(markerDir);
+}
+function projectDbPath(directory) {
+  return join(canonicalRootKeyFresh(directory), ".swarm", "swarm.db");
+}
+function projectDbExists(directory) {
+  return existsSync(projectDbPath(directory));
+}
+function checkpointWalBestEffort(db) {
+  try {
+    const row = db.query("PRAGMA wal_checkpoint(TRUNCATE)").get();
+    if (row && row.busy === 1) {
+      db.run("PRAGMA wal_checkpoint(PASSIVE);");
+    }
+  } catch {
+    try {
+      db.run("PRAGMA wal_checkpoint(PASSIVE);");
+    } catch {}
+  }
+}
+function getProjectDb(directory) {
+  const materializedDirectory = resolve(directory);
+  try {
+    mkdirSync(materializedDirectory, { recursive: true });
+  } catch (err) {
+    throw new ProjectDbError("mkdir_failed", `Failed to create project root ${materializedDirectory}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const key = canonicalRootKeyFresh(materializedDirectory);
+  const alias = lexicalAliasKey(directory);
+  const existing = _projectDbs.get(key);
+  if (existing) {
+    bindAlias(existing, key, alias);
+    return existing.db;
+  }
+  const swarmDir = join(key, ".swarm");
+  try {
+    mkdirSync(swarmDir, { recursive: true });
+  } catch (err) {
+    throw new ProjectDbError("mkdir_failed", `Failed to create .swarm/ for project ${key}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  let db;
+  try {
+    let Db;
+    try {
+      Db = loadDatabaseCtor();
+    } catch (err) {
+      throw new ProjectDbError("driver_unavailable", `Failed to resolve a SQLite driver for project ${key}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const dbFile = join(swarmDir, "swarm.db");
+    for (let attempt = 0;attempt <= OPEN_CONTENTION_RETRIES; attempt += 1) {
+      db = new Db(dbFile);
+      try {
+        db.run("PRAGMA busy_timeout = 5000;");
+        db.run("PRAGMA journal_mode = WAL;");
+        db.run("PRAGMA synchronous = NORMAL;");
+        db.run("PRAGMA foreign_keys = ON;");
+        runProjectMigrations(db, swarmDir);
+        break;
+      } catch (err) {
+        try {
+          db.close();
+        } catch {}
+        db = undefined;
+        if (!isConcurrentOpenContention(err, dbFile) || attempt === OPEN_CONTENTION_RETRIES)
+          throw err;
+        sleepSync(25 * (attempt + 1));
+      }
+    }
+    if (!db)
+      throw new Error("SQLite initialization exhausted its busy retry budget");
+  } catch (err) {
+    if (db) {
+      try {
+        db.close();
+      } catch {}
+    }
+    if (err instanceof ProjectDbError)
+      throw err;
+    throw new ProjectDbError("open_failed", `Failed to open .swarm/swarm.db for project ${key}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const record = {
+    db,
+    primaryAlias: alias,
+    aliases: new Set
+  };
+  _projectDbs.set(key, record);
+  bindAlias(record, key, alias);
+  return db;
+}
+function closeProjectDb(directory) {
+  const alias = lexicalAliasKey(directory);
+  const currentPath = canonicalExistingFilesystemPath(directory);
+  if (currentPath !== null) {
+    const currentKey = canonicalRootKeyFresh(directory);
+    const currentRecord = _projectDbs.get(currentKey);
+    if (currentRecord)
+      closeRecord(currentKey, currentRecord);
+    return;
+  }
+  const previousKey = _projectDbAliases.get(alias);
+  const previousRecord = previousKey === undefined ? undefined : _projectDbs.get(previousKey);
+  if (previousKey !== undefined && previousRecord) {
+    closeRecord(previousKey, previousRecord);
+  }
+}
+function closeAllProjectDbs() {
+  for (const record of _projectDbs.values()) {
+    try {
+      checkpointWalBestEffort(record.db);
+      record.db.close();
+    } catch {}
+  }
+  _projectDbs.clear();
+  _projectDbAliases.clear();
+}
+var _internals = {
+  checkpointWalBestEffort,
+  projectDbCount: () => _projectDbs.size,
+  projectDbAliasCount: () => _projectDbAliases.size
+};
+
+// src/db/durability.ts
+var DURABILITY_CLASSES = {
+  qa_gate_profile: "full",
+  qa_gate_profile_identity: "full",
+  task_checkpoint_receipt: "full",
+  coordination_event: "full",
+  coordination_state: "full",
+  coordination_lease: "full",
+  coordination_import: "full",
+  insight_candidate: "normal",
+  phase_report: "normal",
+  project_constraints: "normal",
+  migration_failures: "normal",
+  schema_migrations: "normal"
+};
+function batchDurabilityClass(classes) {
+  for (const cls of classes) {
+    if (cls === "full")
+      return "full";
+  }
+  return "normal";
+}
+function applySynchronousForClass(db, cls) {
+  db.run(cls === "full" ? "PRAGMA synchronous = FULL;" : "PRAGMA synchronous = NORMAL;");
+}
+function withDurabilityClass(db, cls, fn) {
+  applySynchronousForClass(db, cls);
+  try {
+    return fn();
+  } finally {
+    applySynchronousForClass(db, "normal");
+  }
+}
+var transactionOwners = new WeakMap;
+function withImmediateTransaction(db, cls, fn, hooks = {}) {
+  const owner = transactionOwners.get(db);
+  if (owner) {
+    if (cls === "full" && owner.durability !== "full") {
+      throw new Error("Cannot nest a FULL coordination transaction inside a NORMAL owner");
+    }
+    owner.depth += 1;
+    try {
+      return db.transaction(fn)();
+    } finally {
+      owner.depth -= 1;
+    }
+  }
+  if (db.inTransaction) {
+    throw new Error("Refusing to nest inside an unknown non-coordination-owned transaction");
+  }
+  hooks.beforeBegin?.(db);
+  applySynchronousForClass(db, cls);
+  transactionOwners.set(db, { durability: cls, depth: 1 });
+  db.run("BEGIN IMMEDIATE");
+  let committed = false;
+  try {
+    const result = fn();
+    hooks.beforeOuterCommit?.(db);
+    db.run("COMMIT");
+    committed = true;
+    hooks.afterOuterCommit?.(db);
+    return result;
+  } catch (err) {
+    if (!committed) {
+      try {
+        db.run("ROLLBACK");
+      } catch {}
+    }
+    throw err;
+  } finally {
+    transactionOwners.delete(db);
+    applySynchronousForClass(db, "normal");
+  }
+}
+
+export { DURABILITY_CLASSES, batchDurabilityClass, applySynchronousForClass, withDurabilityClass, withImmediateTransaction, DbWriteError, classifyDbWriteError, projectDbPath, projectDbExists, getProjectDb, closeProjectDb, closeAllProjectDbs };