@delali/sirannon-db 0.1.3 → 0.1.5

package/dist/core/index.mjs

@@ -1,214 +1,62 @@
-import { BackupError, ConnectionPoolError, QueryError, MigrationError, ReadOnlyError, SubscriptionBuilderImpl, ExtensionError, SirannonError, ChangeTracker, SubscriptionManager, startPolling, MaxDatabasesError, DatabaseAlreadyExistsError, DatabaseNotFoundError } from '../chunk-VI4UP4RR.mjs';
-export { BackupError, CDCError, ConnectionPoolError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError, HookDeniedError, MaxDatabasesError, MigrationError, QueryError, ReadOnlyError, SirannonError, TransactionError } from '../chunk-VI4UP4RR.mjs';
-import { existsSync, mkdirSync, rmSync, readdirSync, lstatSync, readFileSync, statSync } from 'fs';
-import { resolve, dirname, join } from 'path';
-import { Cron } from 'croner';
-import Database from 'better-sqlite3';
+import { SubscriptionBuilderImpl, ChangeTracker, SubscriptionManager, startPolling } from '../chunk-UTO3ZAFS.mjs';
+export { ChangeTracker } from '../chunk-UTO3ZAFS.mjs';
+export { defineDriver } from '../chunk-74UN4DIE.mjs';
+import { BackupManager, BackupScheduler } from '../chunk-PXKAKK2V.mjs';
+export { BackupManager, BackupScheduler } from '../chunk-PXKAKK2V.mjs';
+import { Transaction, query, queryOne, execute, executeBatch } from '../chunk-3MCMONVP.mjs';
+export { Transaction, execute, executeBatch, query, queryOne } from '../chunk-3MCMONVP.mjs';
+import '../chunk-GS7T5YMI.mjs';
+import { ConnectionPoolError, MigrationError, ReadOnlyError, SirannonError, MaxDatabasesError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError } from '../chunk-O7BHI3CF.mjs';
+export { BackupError, CDCError, ConnectionPoolError, DatabaseAlreadyExistsError, DatabaseNotFoundError, ExtensionError, HookDeniedError, MaxDatabasesError, MigrationError, QueryError, ReadOnlyError, SirannonError, TransactionError } from '../chunk-O7BHI3CF.mjs';
 
-var BACKUP_FILE_PREFIX = "backup";
-function hasControlCharacters(s) {
-  for (let i = 0; i < s.length; i++) {
-    const code = s.charCodeAt(i);
-    if (code <= 31 && code !== 9 && code !== 10 && code !== 13) {
-      return true;
-    }
-  }
-  return false;
-}
-var BackupManager = class {
-  /**
-   * Creates a one-shot backup of the database using VACUUM INTO.
-   * Produces a fresh, defragmented copy at the specified destination path.
-   *
-   * The destination file must not already exist. Parent directories are
-   * created automatically when missing.
-   *
-   * Note: there is a narrow TOCTOU window between the existence check and
-   * the VACUUM INTO statement. In the unlikely event that another process
-   * creates a file at the same path during that window, VACUUM INTO may
-   * silently overwrite it depending on the SQLite version.
-   */
-  backup(db, destPath) {
-    if (hasControlCharacters(destPath)) {
-      throw new BackupError("Backup path contains invalid characters");
-    }
-    const resolved = resolve(destPath);
-    const dir = dirname(resolved);
-    if (!existsSync(dir)) {
-      try {
-        mkdirSync(dir, { recursive: true });
-      } catch (err) {
-        throw new BackupError(
-          `Failed to create backup directory '${dir}': ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    if (existsSync(resolved)) {
-      throw new BackupError(`Backup destination '${destPath}' already exists`);
-    }
-    const escaped = resolved.replace(/'/g, "''");
-    try {
-      db.exec(`VACUUM INTO '${escaped}'`);
-    } catch (err) {
-      try {
-        rmSync(resolved, { force: true });
-      } catch {
-      }
-      throw new BackupError(`Backup to '${destPath}' failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-  /**
-   * Generates a timestamped backup filename.
-   *
-   * Format: `backup-YYYY-MM-DDTHH-MM-SS-mmmZ.db`
-   *
-   * Colons and dots in the ISO timestamp are replaced with hyphens so the
-   * filename is safe on every major filesystem.
-   */
-  generateFilename() {
-    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    return `${BACKUP_FILE_PREFIX}-${ts}.db`;
-  }
-  /**
-   * Removes old backup files in {@link dir}, keeping the {@link maxFiles}
-   * most recent entries. Only files matching the `backup-*.db` naming
-   * convention are considered; other files in the directory are left alone.
-   *
-   * When {@link maxFiles} is zero or negative the method is a no-op.
-   * A non-existent directory is silently ignored.
-   */
-  rotate(dir, maxFiles) {
-    if (maxFiles <= 0) return;
-    const resolved = resolve(dir);
-    if (!existsSync(resolved)) return;
-    let entries;
-    try {
-      entries = readdirSync(resolved).filter((f) => f.startsWith(`${BACKUP_FILE_PREFIX}-`) && f.endsWith(".db")).map((f) => {
-        const filePath = join(resolved, f);
-        return { path: filePath, mtimeMs: lstatSync(filePath).mtimeMs };
-      }).sort((a, b) => b.mtimeMs - a.mtimeMs);
-    } catch (err) {
-      throw new BackupError(
-        `Failed to list backup files in '${dir}': ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    for (const entry of entries.slice(maxFiles)) {
-      try {
-        rmSync(entry.path, { force: true });
-      } catch {
-      }
-    }
-  }
-};
-var DEFAULT_MAX_FILES = 5;
-var BackupScheduler = class {
-  manager;
-  constructor(manager) {
-    this.manager = manager ?? new BackupManager();
-  }
-  /**
-   * Schedules periodic backups on a cron expression.
-   *
-   * Each tick creates a timestamped backup file inside {@link options.destDir}
-   * and rotates old files so no more than {@link options.maxFiles} (default 5)
-   * are retained.
-   *
-   * Provide {@link options.onError} to receive notification when a scheduled
-   * backup fails. Without it, errors are silently discarded to prevent
-   * unhandled exceptions from crashing the process.
-   *
-   * The underlying timer is unreferenced so it won't keep the Node.js
-   * process alive on its own (consistent with the CDC polling timer).
-   *
-   * Returns a cancel function that stops the scheduled job immediately.
-   */
-  schedule(db, options) {
-    const { cron: cronExpr, destDir, maxFiles = DEFAULT_MAX_FILES, onError } = options;
-    const resolvedDir = resolve(destDir);
-    if (!existsSync(resolvedDir)) {
-      try {
-        mkdirSync(resolvedDir, { recursive: true });
-      } catch (err) {
-        throw new BackupError(
-          `Failed to create backup directory '${destDir}': ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    let job;
-    try {
-      job = new Cron(
-        cronExpr,
-        {
-          unref: true,
-          catch: (err) => {
-            if (onError) {
-              const error = err instanceof Error ? err : new BackupError(typeof err === "string" ? err : "Scheduled backup failed");
-              onError(error);
-            }
-          }
-        },
-        () => {
-          const filename = this.manager.generateFilename();
-          const destPath = join(resolvedDir, filename);
-          this.manager.backup(db, destPath);
-          this.manager.rotate(resolvedDir, maxFiles);
-        }
-      );
-    } catch (err) {
-      throw new BackupError(
-        `Invalid cron expression '${cronExpr}': ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    return () => {
-      job.stop();
-    };
-  }
-};
-function closeAllSilently(connections) {
+// src/core/connection-pool.ts
+async function closeAllSilently(connections) {
   for (const conn of connections) {
     if (!conn) continue;
     try {
-      conn.close();
+      await conn.close();
     } catch {
     }
   }
 }
-var ConnectionPool = class {
+var ConnectionPool = class _ConnectionPool {
   writer;
   readers;
   readerIndex = 0;
   closed = false;
-  constructor(options) {
-    const { path, readOnly = false, readPoolSize = 4, walMode = true } = options;
+  constructor(writer, readers) {
+    this.writer = writer;
+    this.readers = readers;
+  }
+  static async create(options) {
+    const { driver, path, readOnly = false, readPoolSize = 4, walMode = true } = options;
     let writer = null;
     const readers = [];
     try {
       if (!readOnly) {
-        writer = new Database(path);
-        if (walMode) {
-          writer.pragma("journal_mode = WAL");
-        }
-        writer.pragma("synchronous = NORMAL");
-        writer.pragma("foreign_keys = ON");
-        writer.pragma("busy_timeout = 5000");
+        writer = await driver.open(path, { walMode });
       }
-      const poolSize = Math.max(readPoolSize, 1);
+      const poolSize = driver.capabilities.multipleConnections ? Math.max(readPoolSize, 1) : 0;
       for (let i = 0; i < poolSize; i++) {
-        const reader = new Database(path, { readonly: true });
+        const reader = await driver.open(path, { readonly: true, walMode: false });
         readers.push(reader);
-        reader.pragma("foreign_keys = ON");
       }
     } catch (err) {
-      closeAllSilently([...readers, writer]);
+      await closeAllSilently([...readers, writer]);
       throw err;
     }
-    this.writer = writer;
-    this.readers = readers;
+    return new _ConnectionPool(writer, readers);
   }
   acquireReader() {
     if (this.closed) {
       throw new ConnectionPoolError("Connection pool is closed");
     }
+    if (this.readers.length === 0) {
+      if (!this.writer) {
+        throw new ConnectionPoolError("No connections available");
+      }
+      return this.writer;
+    }
     const reader = this.readers[this.readerIndex % this.readers.length];
     this.readerIndex = (this.readerIndex + 1) % this.readers.length;
     return reader;
@@ -228,31 +76,20 @@ var ConnectionPool = class {
   get isReadOnly() {
     return this.writer === null;
   }
-  loadExtension(extensionPath) {
-    if (this.closed) {
-      throw new ConnectionPoolError("Connection pool is closed");
-    }
-    if (this.writer) {
-      this.writer.loadExtension(extensionPath);
-    }
-    for (const reader of this.readers) {
-      reader.loadExtension(extensionPath);
-    }
-  }
-  close() {
+  async close() {
     if (this.closed) return;
     this.closed = true;
     const errors = [];
     for (const reader of this.readers) {
       try {
-        reader.close();
+        await reader.close();
       } catch (err) {
         errors.push(err);
       }
     }
     if (this.writer) {
       try {
-        this.writer.close();
+        await this.writer.close();
       } catch (err) {
         errors.push(err);
       }
@@ -263,6 +100,81 @@ var ConnectionPool = class {
   }
 };
 
+// src/core/cdc/ddl-handler.ts
+var DDL_PREFIX_RE = /^\s*(CREATE\s+TABLE|ALTER\s+TABLE\s+\S+\s+ADD\s+COLUMN|DROP\s+TABLE|CREATE\s+INDEX|DROP\s+INDEX)\b/i;
+var DROP_TABLE_RE = /^\s*DROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?"?([A-Za-z_][A-Za-z0-9_]*)"?\s*;?\s*$/i;
+function isCdcRelevantDdl(sql) {
+  return DDL_PREFIX_RE.test(sql);
+}
+function extractDroppedTable(sql) {
+  const m = DROP_TABLE_RE.exec(sql);
+  return m?.[1] ?? null;
+}
+async function applyDdlSideEffects(tracker, writerConn, sql) {
+  if (tracker.watchedTables.size === 0) {
+    return;
+  }
+  await tracker.refreshAllTriggersUsingConnection(writerConn);
+  const dropped = extractDroppedTable(sql);
+  if (dropped !== null) {
+    await tracker.pruneDroppedTables(writerConn, [dropped]);
+  }
+}
+
+// src/core/cdc/cdc-aware-transaction.ts
+var CdcAwareTransaction = class extends Transaction {
+  constructor(txConn, tracker, state) {
+    super(txConn);
+    this.tracker = tracker;
+    this.state = state;
+    this.txConn = txConn;
+  }
+  txConn;
+  async execute(sql, params) {
+    const isDdl = isCdcRelevantDdl(sql);
+    const result = await super.execute(sql, params);
+    if (!isDdl) {
+      return result;
+    }
+    this.state.sawDdl = true;
+    const dropped = extractDroppedTable(sql);
+    if (dropped !== null) {
+      this.state.droppedTables.push(dropped);
+    }
+    if (this.tracker.watchedTables.size > 0) {
+      await this.tracker.refreshAllTriggersUsingConnection(this.txConn);
+    }
+    return result;
+  }
+};
+
+// src/core/extension-loader.ts
+async function loadExtension(driver, writer, extensionPath) {
+  if (!driver.capabilities.extensions) {
+    throw new ExtensionError(extensionPath, "Extensions are not supported by the current driver");
+  }
+  if (!extensionPath || extensionPath.includes("\0")) {
+    throw new ExtensionError(extensionPath || "", "Extension path is empty or contains null bytes");
+  }
+  for (let i = 0; i < extensionPath.length; i++) {
+    if (extensionPath.charCodeAt(i) <= 31) {
+      throw new ExtensionError(extensionPath, "Extension path contains control characters");
+    }
+  }
+  const segments = extensionPath.split(/[/\\]/);
+  if (segments.includes("..")) {
+    throw new ExtensionError(extensionPath, "Extension path must not contain directory traversal segments");
+  }
+  const { resolve } = await import('path');
+  const resolved = resolve(extensionPath);
+  try {
+    const escaped = resolved.replace(/'/g, "''");
+    await writer.exec(`SELECT load_extension('${escaped}')`);
+  } catch (err) {
+    throw new ExtensionError(extensionPath, err instanceof Error ? err.message : String(err));
+  }
+}
+
 // src/core/hooks/registry.ts
 var HOOK_CONFIG_MAP = {
   onBeforeQuery: "beforeQuery",
@@ -345,227 +257,6 @@ var HookRegistry = class {
   }
 };
 
-// src/core/query-executor.ts
-var STATEMENT_CACHE_CAPACITY = 128;
-var statementCaches = /* @__PURE__ */ new WeakMap();
-function getStatement(db, sql) {
-  let cache = statementCaches.get(db);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    statementCaches.set(db, cache);
-  }
-  const cached = cache.get(sql);
-  if (cached) {
-    cache.delete(sql);
-    cache.set(sql, cached);
-    return cached;
-  }
-  const stmt = db.prepare(sql);
-  cache.set(sql, stmt);
-  if (cache.size > STATEMENT_CACHE_CAPACITY) {
-    const oldest = cache.keys().next().value;
-    if (oldest !== void 0) {
-      cache.delete(oldest);
-    }
-  }
-  return stmt;
-}
-function bindParams(params) {
-  if (params === void 0) return [];
-  if (Array.isArray(params)) return params;
-  return [params];
-}
-function query(db, sql, params) {
-  try {
-    const stmt = getStatement(db, sql);
-    return stmt.all(...bindParams(params));
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-function queryOne(db, sql, params) {
-  try {
-    const stmt = getStatement(db, sql);
-    return stmt.get(...bindParams(params));
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-function execute(db, sql, params) {
-  try {
-    const stmt = getStatement(db, sql);
-    const result = stmt.run(...bindParams(params));
-    return {
-      changes: result.changes,
-      lastInsertRowId: result.lastInsertRowid
-    };
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-function executeBatch(db, sql, paramsBatch) {
-  try {
-    const stmt = getStatement(db, sql);
-    const run = db.transaction(() => {
-      const results = [];
-      for (const params of paramsBatch) {
-        const result = stmt.run(...bindParams(params));
-        results.push({
-          changes: result.changes,
-          lastInsertRowId: result.lastInsertRowid
-        });
-      }
-      return results;
-    });
-    return run();
-  } catch (err) {
-    throw new QueryError(err instanceof Error ? err.message : String(err), sql);
-  }
-}
-
-// src/core/transaction.ts
-var Transaction = class _Transaction {
-  constructor(db) {
-    this.db = db;
-  }
-  _lastInsertRowId = 0;
-  query(sql, params) {
-    return query(this.db, sql, params);
-  }
-  execute(sql, params) {
-    const result = execute(this.db, sql, params);
-    this._lastInsertRowId = result.lastInsertRowId;
-    return result;
-  }
-  executeBatch(sql, paramsBatch) {
-    const results = executeBatch(this.db, sql, paramsBatch);
-    if (results.length > 0) {
-      this._lastInsertRowId = results[results.length - 1].lastInsertRowId;
-    }
-    return results;
-  }
-  get lastInsertRowId() {
-    return this._lastInsertRowId;
-  }
-  static run(db, fn) {
-    const tx = new _Transaction(db);
-    return db.transaction(() => fn(tx))();
-  }
-};
-var MIGRATION_FILENAME_PATTERN = /^(\d+)_(\w+)\.(up|down)\.sql$/;
-function scanDirectory(dirPath) {
-  if (dirPath.includes("\0")) {
-    throw new MigrationError("Migration path contains null bytes", 0, "MIGRATION_VALIDATION_ERROR");
-  }
-  const segments = dirPath.split(/[/\\]/);
-  if (segments.includes("..")) {
-    throw new MigrationError(
-      "Migration path must not contain directory traversal segments",
-      0,
-      "MIGRATION_VALIDATION_ERROR"
-    );
-  }
-  const resolvedPath = resolve(dirPath);
-  let stat;
-  try {
-    stat = statSync(resolvedPath);
-  } catch {
-    throw new MigrationError(`Migrations path does not exist: ${resolvedPath}`, 0);
-  }
-  if (!stat.isDirectory()) {
-    throw new MigrationError(`Migrations path is not a directory: ${resolvedPath}`, 0);
-  }
-  const entries = readdirSync(resolvedPath, { withFileTypes: true });
-  const grouped = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    if (!entry.isFile()) continue;
-    const match = MIGRATION_FILENAME_PATTERN.exec(entry.name);
-    if (!match) continue;
-    const version = parseInt(match[1], 10);
-    const name = match[2];
-    const direction = match[3];
-    if (!Number.isFinite(version) || version <= 0 || !Number.isSafeInteger(version)) {
-      throw new MigrationError(`Invalid migration version: ${match[1]}`, version, "MIGRATION_VALIDATION_ERROR");
-    }
-    const existing = grouped.get(version);
-    if (existing && existing.name !== name) {
-      throw new MigrationError(
-        `Duplicate migration version ${version}: '${existing.name}' and '${name}'`,
-        version,
-        "MIGRATION_DUPLICATE_VERSION"
-      );
-    }
-    const filePath = join(resolvedPath, entry.name);
-    if (!existing) {
-      grouped.set(version, {
-        name,
-        [direction === "up" ? "upPath" : "downPath"]: filePath
-      });
-    } else {
-      if (direction === "up") existing.upPath = filePath;
-      else existing.downPath = filePath;
-    }
-  }
-  const results = [];
-  for (const [version, entry] of grouped) {
-    if (!entry.upPath) {
-      throw new MigrationError(
-        `Migration version ${version} (${entry.name}) is missing an .up.sql file`,
-        version,
-        "MIGRATION_VALIDATION_ERROR"
-      );
-    }
-    results.push({
-      version,
-      name: entry.name,
-      upPath: entry.upPath,
-      downPath: entry.downPath ?? null
-    });
-  }
-  results.sort((a, b) => a.version - b.version);
-  return results;
-}
-function readUpMigrations(scanned) {
-  return scanned.map((entry) => {
-    const sql = readFileSync(entry.upPath, "utf-8").trim();
-    if (sql.length === 0) {
-      throw new MigrationError(`Migration file is empty: ${entry.upPath}`, entry.version, "MIGRATION_VALIDATION_ERROR");
-    }
-    return {
-      version: entry.version,
-      name: entry.name,
-      up: sql
-    };
-  });
-}
-function readDownMigrations(scanned, versions) {
-  const versionSet = new Set(versions);
-  const filtered = scanned.filter((s) => versionSet.has(s.version));
-  return filtered.map((entry) => {
-    if (!entry.downPath) {
-      throw new MigrationError(
-        `Migration version ${entry.version} (${entry.name}) has no .down.sql file`,
-        entry.version,
-        "MIGRATION_NO_DOWN"
-      );
-    }
-    const downSql = readFileSync(entry.downPath, "utf-8").trim();
-    if (downSql.length === 0) {
-      throw new MigrationError(
-        `Down migration file is empty: ${entry.downPath}`,
-        entry.version,
-        "MIGRATION_VALIDATION_ERROR"
-      );
-    }
-    return {
-      version: entry.version,
-      name: entry.name,
-      up: "",
-      down: downSql
-    };
-  });
-}
-
 // src/core/migrations/runner.ts
 var CREATE_TRACKING_TABLE = `
   CREATE TABLE IF NOT EXISTS _sirannon_migrations (
@@ -575,23 +266,24 @@ var CREATE_TRACKING_TABLE = `
   )
 `;
 var MigrationRunner = class _MigrationRunner {
-  static run(db, input) {
-    db.exec(CREATE_TRACKING_TABLE);
-    const migrations = typeof input === "string" ? readUpMigrations(scanDirectory(input)) : _MigrationRunner.validateMigrations(input);
-    const applied = _MigrationRunner.getAppliedVersions(db);
-    const pending = migrations.filter((m) => !applied.has(m.version));
+  static async run(conn, migrations) {
+    await conn.exec(CREATE_TRACKING_TABLE);
+    const validated = _MigrationRunner.validateMigrations(migrations);
+    const applied = await _MigrationRunner.getAppliedVersions(conn);
+    const pending = validated.filter((m) => !applied.has(m.version));
     if (pending.length === 0) {
-      return { applied: [], skipped: migrations.length };
+      return { applied: [], skipped: validated.length };
     }
-    const insertMigration = db.prepare("INSERT INTO _sirannon_migrations (version, name) VALUES (?, ?)");
     const appliedEntries = [];
-    db.transaction(() => {
+    await conn.transaction(async (txConn) => {
+      const insertStmt = await txConn.prepare("INSERT INTO _sirannon_migrations (version, name) VALUES (?, ?)");
       for (const migration of pending) {
         try {
           if (typeof migration.up === "string") {
-            db.exec(migration.up);
+            await txConn.exec(migration.up);
           } else {
-            migration.up(new Transaction(db));
+            const result = migration.up(new Transaction(txConn));
+            if (result instanceof Promise) await result;
           }
         } catch (err) {
           if (err instanceof MigrationError) throw err;
@@ -600,16 +292,16 @@ var MigrationRunner = class _MigrationRunner {
             migration.version
           );
         }
-        insertMigration.run(migration.version, migration.name);
+        await insertStmt.run(migration.version, migration.name);
         appliedEntries.push({ version: migration.version, name: migration.name });
       }
-    })();
+    });
     return {
       applied: appliedEntries,
-      skipped: migrations.length - pending.length
+      skipped: validated.length - pending.length
     };
   }
-  static rollback(db, input, version) {
+  static async rollback(conn, migrations, version) {
     if (version !== void 0 && (!Number.isSafeInteger(version) || version < 0)) {
       throw new MigrationError(
         `Invalid rollback target version: ${version}`,
@@ -617,8 +309,9 @@ var MigrationRunner = class _MigrationRunner {
         "MIGRATION_VALIDATION_ERROR"
       );
     }
-    db.exec(CREATE_TRACKING_TABLE);
-    const appliedRows = db.prepare("SELECT version, name FROM _sirannon_migrations ORDER BY version DESC").all();
+    await conn.exec(CREATE_TRACKING_TABLE);
+    const selectStmt = await conn.prepare("SELECT version, name FROM _sirannon_migrations ORDER BY version DESC");
+    const appliedRows = await selectStmt.all();
     if (appliedRows.length === 0) {
       return { rolledBack: [] };
     }
@@ -631,26 +324,20 @@ var MigrationRunner = class _MigrationRunner {
     if (rollbackSet.length === 0) {
       return { rolledBack: [] };
     }
+    _MigrationRunner.validateMigrations(migrations);
     const rollbackVersions = rollbackSet.map((r) => r.version);
-    let downByVersion;
-    if (typeof input === "string") {
-      const scanned = scanDirectory(input);
-      const downMigrations = readDownMigrations(scanned, rollbackVersions);
-      downByVersion = new Map(downMigrations.map((m) => [m.version, m]));
-    } else {
-      const inputByVersion = new Map(input.map((m) => [m.version, m]));
-      downByVersion = /* @__PURE__ */ new Map();
-      for (const v of rollbackVersions) {
-        const m = inputByVersion.get(v);
-        if (!m || m.down === void 0) {
-          throw new MigrationError(`Migration version ${v} has no down migration`, v, "MIGRATION_NO_DOWN");
-        }
-        downByVersion.set(v, m);
+    const inputByVersion = new Map(migrations.map((m) => [m.version, m]));
+    const downByVersion = /* @__PURE__ */ new Map();
+    for (const v of rollbackVersions) {
+      const m = inputByVersion.get(v);
+      if (!m || m.down === void 0) {
+        throw new MigrationError(`Migration version ${v} has no down migration`, v, "MIGRATION_NO_DOWN");
       }
+      downByVersion.set(v, m);
     }
-    const deleteMigration = db.prepare("DELETE FROM _sirannon_migrations WHERE version = ?");
     const rolledBackEntries = [];
-    db.transaction(() => {
+    await conn.transaction(async (txConn) => {
+      const deleteStmt = await txConn.prepare("DELETE FROM _sirannon_migrations WHERE version = ?");
       for (const entry of rollbackSet) {
         const migration = downByVersion.get(entry.version);
         if (!migration) {
@@ -662,9 +349,10 @@ var MigrationRunner = class _MigrationRunner {
         }
         try {
           if (typeof migration.down === "string") {
-            db.exec(migration.down);
+            await txConn.exec(migration.down);
           } else {
-            migration.down?.(new Transaction(db));
+            const result = migration.down?.(new Transaction(txConn));
+            if (result instanceof Promise) await result;
           }
         } catch (err) {
           if (err instanceof MigrationError) throw err;
@@ -674,10 +362,10 @@ var MigrationRunner = class _MigrationRunner {
             "MIGRATION_ROLLBACK_ERROR"
           );
         }
-        deleteMigration.run(entry.version);
+        await deleteStmt.run(entry.version);
         rolledBackEntries.push({ version: entry.version, name: entry.name });
       }
-    })();
+    });
     return { rolledBack: rolledBackEntries };
   }
   static validateMigrations(migrations) {
@@ -719,18 +407,20 @@ var MigrationRunner = class _MigrationRunner {
     }
     return [...migrations].sort((a, b) => a.version - b.version);
   }
-  static getAppliedVersions(db) {
-    const rows = db.prepare("SELECT version FROM _sirannon_migrations ORDER BY version").all();
+  static async getAppliedVersions(conn) {
+    const stmt = await conn.prepare("SELECT version FROM _sirannon_migrations ORDER BY version");
+    const rows = await stmt.all();
     return new Set(rows.map((r) => r.version));
   }
 };
 
 // src/core/database.ts
-var Database2 = class {
+var Database = class _Database {
   id;
   path;
   readOnly;
   pool;
+  driver;
   closeListeners = [];
   _closed = false;
   changeTracker = null;
@@ -744,109 +434,135 @@ var Database2 = class {
   backupManager = new BackupManager();
   backupScheduler = new BackupScheduler(this.backupManager);
   scheduledBackupCancellers = [];
-  constructor(id, path, options, internals) {
+  constructor(id, path, pool, driver, options, internals) {
     this.id = id;
     this.path = path;
+    this.pool = pool;
+    this.driver = driver;
     this.readOnly = options?.readOnly ?? false;
     this.cdcPollInterval = options?.cdcPollInterval ?? 50;
     this.cdcRetention = options?.cdcRetention ?? 36e5;
     this.parentHooks = internals?.parentHooks ?? null;
     this.metricsCollector = internals?.metrics ?? null;
-    this.pool = new ConnectionPool({
+  }
+  static async create(id, path, driver, options, internals) {
+    const pool = await ConnectionPool.create({
+      driver,
       path,
-      readOnly: this.readOnly,
+      readOnly: options?.readOnly,
       readPoolSize: options?.readPoolSize ?? 4,
       walMode: options?.walMode ?? true
     });
+    return new _Database(id, path, pool, driver, options, internals);
   }
-  query(sql, params) {
+  async query(sql, params, options) {
     this.ensureOpen();
-    this.fireBeforeQueryHooks(sql, params);
+    this.fireBeforeQueryHooks(sql, params, options);
     const start = performance.now();
     try {
       const reader = this.pool.acquireReader();
       if (this.metricsCollector) {
-        return this.metricsCollector.trackQuery(() => query(reader, sql, params), {
+        return await this.metricsCollector.trackQuery(() => query(reader, sql, params), {
           databaseId: this.id,
           sql
         });
       }
-      return query(reader, sql, params);
+      return await query(reader, sql, params);
     } finally {
       this.fireAfterQueryHooks(sql, params, performance.now() - start);
     }
   }
-  queryOne(sql, params) {
+  async queryOne(sql, params, options) {
     this.ensureOpen();
-    this.fireBeforeQueryHooks(sql, params);
+    this.fireBeforeQueryHooks(sql, params, options);
     const start = performance.now();
     try {
       const reader = this.pool.acquireReader();
       if (this.metricsCollector) {
-        return this.metricsCollector.trackQuery(() => queryOne(reader, sql, params), {
+        return await this.metricsCollector.trackQuery(() => queryOne(reader, sql, params), {
           databaseId: this.id,
           sql
         });
       }
-      return queryOne(reader, sql, params);
+      return await queryOne(reader, sql, params);
     } finally {
       this.fireAfterQueryHooks(sql, params, performance.now() - start);
     }
   }
-  execute(sql, params) {
+  async execute(sql, params, options) {
     this.ensureOpen();
-    this.fireBeforeQueryHooks(sql, params);
+    if (this.readOnly) throw new ReadOnlyError(this.id);
+    this.fireBeforeQueryHooks(sql, params, options);
     const start = performance.now();
     try {
       const writer = this.pool.acquireWriter();
-      if (this.metricsCollector) {
-        return this.metricsCollector.trackQuery(() => execute(writer, sql, params), {
-          databaseId: this.id,
-          sql
-        });
-      }
-      return execute(writer, sql, params);
+      const result = this.metricsCollector ? await this.metricsCollector.trackQuery(() => execute(writer, sql, params), {
+        databaseId: this.id,
+        sql
+      }) : await execute(writer, sql, params);
+      await this.maybeApplyDdlSideEffects(writer, sql);
+      return result;
     } finally {
       this.fireAfterQueryHooks(sql, params, performance.now() - start);
     }
   }
-  executeBatch(sql, paramsBatch) {
+  async executeBatch(sql, paramsBatch, options) {
     this.ensureOpen();
-    this.fireBeforeQueryHooks(sql);
+    if (this.readOnly) throw new ReadOnlyError(this.id);
+    this.fireBeforeQueryHooks(sql, void 0, options);
     const start = performance.now();
     try {
       const writer = this.pool.acquireWriter();
-      if (this.metricsCollector) {
-        return this.metricsCollector.trackQuery(() => executeBatch(writer, sql, paramsBatch), {
-          databaseId: this.id,
-          sql
-        });
-      }
-      return executeBatch(writer, sql, paramsBatch);
+      const batchFn = () => writer.transaction(async (txConn) => executeBatch(txConn, sql, paramsBatch));
+      const results = this.metricsCollector ? await this.metricsCollector.trackQuery(batchFn, {
+        databaseId: this.id,
+        sql
+      }) : await batchFn();
+      await this.maybeApplyDdlSideEffects(writer, sql);
+      return results;
     } finally {
       this.fireAfterQueryHooks(sql, void 0, performance.now() - start);
     }
   }
-  transaction(fn) {
+  async transaction(fn) {
     this.ensureOpen();
+    if (this.readOnly) throw new ReadOnlyError(this.id);
     const writer = this.pool.acquireWriter();
-    return Transaction.run(writer, fn);
+    const tracker = this.changeTracker;
+    if (!tracker) {
+      return Transaction.run(writer, fn);
+    }
+    const state = { sawDdl: false, droppedTables: [] };
+    const result = await writer.transaction(async (txConn) => {
+      const tx = new CdcAwareTransaction(txConn, tracker, state);
+      return fn(tx);
+    });
+    if (state.sawDdl && state.droppedTables.length > 0) {
+      await tracker.pruneDroppedTables(writer, state.droppedTables);
+    }
+    return result;
   }
-  watch(table) {
+  async maybeApplyDdlSideEffects(writer, sql) {
+    const tracker = this.changeTracker;
+    if (!tracker) return;
+    if (!isCdcRelevantDdl(sql)) return;
+    await applyDdlSideEffects(tracker, writer, sql);
+  }
+  async watch(table) {
     this.ensureOpen();
     if (this.readOnly) {
       throw new ReadOnlyError(this.id);
     }
     this.ensureCdc();
     const writer = this.pool.acquireWriter();
-    this.changeTracker?.watch(writer, table);
+    await this.changeTracker?.watch(writer, table);
     this.ensureCdcPolling();
   }
-  unwatch(table) {
+  async unwatch(table) {
     this.ensureOpen();
     if (!this.changeTracker) return;
     const writer = this.pool.acquireWriter();
-    this.changeTracker.unwatch(writer, table);
+    await this.changeTracker.unwatch(writer, table);
     if (this.changeTracker.watchedTables.size === 0) {
       this.stopCdcPollingLoop();
     }
@@ -858,20 +574,20 @@ var Database2 = class {
     if (!manager) throw new Error("subscriptionManager not initialized");
     return new SubscriptionBuilderImpl(table, manager);
   }
-  migrate(input) {
+  async migrate(migrations) {
     this.ensureOpen();
     const writer = this.pool.acquireWriter();
-    return MigrationRunner.run(writer, input);
+    return MigrationRunner.run(writer, migrations);
   }
-  rollback(input, version) {
+  async rollback(migrations, version) {
     this.ensureOpen();
     const writer = this.pool.acquireWriter();
-    return MigrationRunner.rollback(writer, input, version);
+    return MigrationRunner.rollback(writer, migrations, version);
   }
-  backup(destPath) {
+  async backup(destPath) {
     this.ensureOpen();
     const writer = this.pool.acquireWriter();
-    this.backupManager.backup(writer, destPath);
+    await this.backupManager.backup(writer, destPath);
   }
   scheduleBackup(options) {
     this.ensureOpen();
@@ -879,21 +595,10 @@ var Database2 = class {
     const cancel = this.backupScheduler.schedule(writer, options);
     this.scheduledBackupCancellers.push(cancel);
   }
-  loadExtension(extensionPath) {
+  async loadExtension(extensionPath) {
     this.ensureOpen();
-    if (!extensionPath || extensionPath.includes("\0")) {
-      throw new ExtensionError(extensionPath || "", "Extension path is empty or contains null bytes");
-    }
-    const segments = extensionPath.split(/[/\\]/);
-    if (segments.includes("..")) {
-      throw new ExtensionError(extensionPath, "Extension path must not contain directory traversal segments");
-    }
-    const resolved = resolve(extensionPath);
-    try {
-      this.pool.loadExtension(resolved);
-    } catch (err) {
-      throw new ExtensionError(extensionPath, err instanceof Error ? err.message : String(err));
-    }
+    const writer = this.pool.acquireWriter();
+    await loadExtension(this.driver, writer, extensionPath);
   }
   onBeforeQuery(hook) {
     this.hookRegistry.register("beforeQuery", hook);
@@ -905,7 +610,7 @@ var Database2 = class {
     this.ensureOpen();
     this.closeListeners.push(fn);
   }
-  close() {
+  async close() {
     if (this._closed) return;
     this._closed = true;
     this.stopCdcPollingLoop();
@@ -918,13 +623,13 @@ var Database2 = class {
     this.scheduledBackupCancellers.length = 0;
     let poolError;
     try {
-      this.pool.close();
+      await this.pool.close();
     } catch (err) {
       poolError = err;
     }
     for (const fn of this.closeListeners) {
       try {
-        fn();
+        await fn();
       } catch {
       }
     }
@@ -963,11 +668,17 @@ var Database2 = class {
       this.stopCdcPolling = null;
     }
   }
-  fireBeforeQueryHooks(sql, params) {
+  fireBeforeQueryHooks(sql, params, options) {
     const hasParent = this.parentHooks?.has("beforeQuery");
     const hasLocal = this.hookRegistry.has("beforeQuery");
     if (!hasParent && !hasLocal) return;
-    const ctx = { databaseId: this.id, sql, params };
+    const ctx = {
+      databaseId: this.id,
+      sql,
+      params,
+      writeConcern: options?.writeConcern,
+      readConcern: options?.readConcern
+    };
     this.parentHooks?.invokeSync("beforeQuery", ctx);
     this.hookRegistry.invokeSync("beforeQuery", ctx);
   }
@@ -994,27 +705,21 @@ var LifecycleManager = class {
   lastAccess = /* @__PURE__ */ new Map();
   idleTimer = null;
   _disposed = false;
+  #idleCheckPromise = null;
   constructor(config, callbacks) {
     this.config = config;
     this.callbacks = callbacks;
     const timeout = config.idleTimeout;
     if (timeout && timeout > 0) {
       const interval = Math.min(Math.max(Math.floor(timeout / 2), 100), 6e4);
-      this.idleTimer = setInterval(() => this.checkIdle(), interval);
-      if (typeof this.idleTimer === "object" && "unref" in this.idleTimer) {
-        this.idleTimer.unref();
-      }
+      const timer = setInterval(async () => {
+        await this.#runIdleCheck();
+      }, interval);
+      timer.unref?.();
+      this.idleTimer = timer;
     }
   }
-  /**
-   * Attempt to auto-open a database by ID using the configured resolver.
-   * Returns the opened Database, or `undefined` when no resolver is
-   * configured or the resolver does not recognise the ID.
-   *
-   * Throws {@link MaxDatabasesError} when the registry is at capacity and
-   * eviction cannot free a slot.
-   */
-  resolve(id) {
+  async resolve(id) {
     this.ensureNotDisposed();
     const resolver = this.config.autoOpen?.resolver;
     if (!resolver) return void 0;
@@ -1022,27 +727,21 @@ var LifecycleManager = class {
     if (!resolved) return void 0;
     const maxOpen = this.config.maxOpen;
     if (maxOpen && maxOpen > 0 && this.callbacks.count() >= maxOpen) {
-      this.evict();
+      await this.evict();
       if (this.callbacks.count() >= maxOpen) {
         throw new MaxDatabasesError(maxOpen);
       }
     }
-    const db = this.callbacks.open(id, resolved.path, resolved.options);
+    const db = await this.callbacks.open(id, resolved.path, resolved.options);
     this.markActive(id);
     return db;
   }
-  /** Record an access for the given database ID. */
   markActive(id) {
     if (!this._disposed) {
       this.lastAccess.set(id, Date.now());
     }
   }
-  /**
-   * Close every database whose last access was longer ago than the
-   * configured idle timeout. Also cleans up tracking entries for
-   * databases that were closed externally.
-   */
-  checkIdle() {
+  async checkIdle() {
     const timeout = this.config.idleTimeout;
     if (!timeout || timeout <= 0) return;
     const now = Date.now();
@@ -1059,7 +758,7 @@ var LifecycleManager = class {
     }
     for (const id of toClose) {
       try {
-        this.callbacks.close(id);
+        await this.callbacks.close(id);
       } catch {
       }
       toRemove.push(id);
@@ -1068,11 +767,7 @@ var LifecycleManager = class {
       this.lastAccess.delete(id);
     }
   }
-  /**
-   * Close the least-recently-used tracked database. Called internally
-   * by {@link resolve} when `maxOpen` capacity is reached.
-   */
-  evict() {
+  async evict() {
     let oldestId = null;
     let oldestTime = Infinity;
     const stale = [];
@@ -1091,25 +786,21 @@ var LifecycleManager = class {
     }
     if (oldestId) {
       try {
-        this.callbacks.close(oldestId);
+        await this.callbacks.close(oldestId);
       } catch {
       }
       this.lastAccess.delete(oldestId);
     }
   }
-  /** Remove a database from idle tracking (e.g. after an explicit close). */
   untrack(id) {
     this.lastAccess.delete(id);
   }
-  /** Whether this manager has been disposed. */
   get disposed() {
     return this._disposed;
   }
-  /** The number of databases currently tracked for idle management. */
   get trackedCount() {
     return this.lastAccess.size;
   }
-  /** Shut down the manager: stop the idle timer and clear all state. */
   dispose() {
     if (this._disposed) return;
     this._disposed = true;
@@ -1124,7 +815,22 @@ var LifecycleManager = class {
       throw new SirannonError("LifecycleManager has been disposed", "LIFECYCLE_DISPOSED");
     }
   }
+  async #runIdleCheck() {
+    if (this.#idleCheckPromise) {
+      await this.#idleCheckPromise;
+      return;
+    }
+    this.#idleCheckPromise = this.checkIdle();
+    try {
+      await this.#idleCheckPromise;
+    } catch {
+    } finally {
+      this.#idleCheckPromise = null;
+    }
+  }
 };
+
+// src/core/lifecycle/tenant.ts
 var SAFE_ID_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
 var MAX_ID_LENGTH = 255;
 var MAX_FILENAME_LENGTH = 255;
@@ -1142,7 +848,7 @@ function tenantPath(basePath, tenantId, extension = ".db") {
   if (filename.length > MAX_FILENAME_LENGTH) {
     throw new Error(`Tenant filename exceeds maximum length of ${MAX_FILENAME_LENGTH} characters`);
   }
-  return join(basePath, filename);
+  return `${basePath}/${filename}`;
 }
 function createTenantResolver(options) {
   const ext = options.extension ?? ".db";
@@ -1153,7 +859,7 @@ function createTenantResolver(options) {
     const filename = `${sanitized}${ext}`;
     if (filename.length > MAX_FILENAME_LENGTH) return void 0;
     return {
-      path: join(options.basePath, filename),
+      path: `${options.basePath}/${filename}`,
       options: defaultOpts
     };
   };
@@ -1165,14 +871,14 @@ var MetricsCollector = class {
   constructor(config) {
     this.config = config ?? {};
   }
-  trackQuery(fn, context) {
+  async trackQuery(fn, context) {
     if (!this.config.onQueryComplete) {
       return fn();
     }
     const start = performance.now();
     let failed = false;
     try {
-      return fn();
+      return await fn();
     } catch (err) {
       failed = true;
       throw err;
@@ -1213,9 +919,10 @@ var MetricsCollector = class {
 var Sirannon = class {
   constructor(options) {
     this.options = options;
-    this.hookRegistry = new HookRegistry(options?.hooks);
-    this.metricsCollector = options?.metrics ? new MetricsCollector(options.metrics) : null;
-    this.lifecycleManager = options?.lifecycle ? new LifecycleManager(options.lifecycle, {
+    this._driver = options.driver;
+    this.hookRegistry = new HookRegistry(options.hooks);
+    this.metricsCollector = options.metrics ? new MetricsCollector(options.metrics) : null;
+    this.lifecycleManager = options.lifecycle ? new LifecycleManager(options.lifecycle, {
       open: (id, path, opts) => this.open(id, path, opts),
       close: (id) => this.close(id),
       count: () => this.dbs.size,
@@ -1223,31 +930,44 @@ var Sirannon = class {
     }) : null;
   }
   dbs = /* @__PURE__ */ new Map();
+  opening = /* @__PURE__ */ new Set();
   _shutdown = false;
+  _driver;
   hookRegistry;
   metricsCollector;
   lifecycleManager;
-  open(id, path, options) {
+  get driver() {
+    return this._driver;
+  }
+  async open(id, path, options) {
     this.ensureRunning();
-    if (this.dbs.has(id)) {
+    if (this.dbs.has(id) || this.opening.has(id)) {
       throw new DatabaseAlreadyExistsError(id);
     }
-    if (this.hookRegistry.has("beforeConnect")) {
-      this.hookRegistry.invokeSync("beforeConnect", { databaseId: id, path });
-    }
+    this.opening.add(id);
     let db;
     try {
-      db = new Database2(id, path, options, {
+      if (this.hookRegistry.has("beforeConnect")) {
+        this.hookRegistry.invokeSync("beforeConnect", { databaseId: id, path });
+      }
+      db = await Database.create(id, path, this._driver, options, {
         parentHooks: this.hookRegistry,
         metrics: this.metricsCollector ?? void 0
       });
     } catch (err) {
+      this.opening.delete(id);
       if (err instanceof SirannonError) throw err;
       throw new SirannonError(
         `Failed to open database '${id}' at '${path}': ${err instanceof Error ? err.message : String(err)}`,
         "DATABASE_OPEN_FAILED"
       );
     }
+    this.opening.delete(id);
+    if (this._shutdown) {
+      await db.close().catch(() => {
+      });
+      throw new SirannonError("Sirannon has been shut down", "SHUTDOWN");
+    }
     db.addCloseListener(() => {
       this.dbs.delete(id);
       this.lifecycleManager?.untrack(id);
@@ -1280,13 +1000,13 @@ var Sirannon = class {
     });
     return db;
   }
-  close(id) {
+  async close(id) {
     this.ensureRunning();
     const db = this.dbs.get(id);
     if (!db) {
       throw new DatabaseNotFoundError(id);
     }
-    db.close();
+    await db.close();
   }
   get(id) {
     const db = this.dbs.get(id);
@@ -1295,6 +1015,12 @@ var Sirannon = class {
       return db;
     }
     if (this._shutdown) return void 0;
+    return void 0;
+  }
+  async resolve(id) {
+    const db = this.get(id);
+    if (db) return db;
+    if (this._shutdown) return void 0;
     return this.lifecycleManager?.resolve(id);
   }
   has(id) {
@@ -1303,7 +1029,7 @@ var Sirannon = class {
   databases() {
     return new Map(this.dbs);
   }
-  shutdown() {
+  async shutdown() {
     if (this._shutdown) return;
     this._shutdown = true;
     this.lifecycleManager?.dispose();
@@ -1311,7 +1037,7 @@ var Sirannon = class {
     const snapshot = [...this.dbs.values()];
     for (const db of snapshot) {
       try {
-        db.close();
+        await db.close();
       } catch (err) {
         errors.push(err);
       }
@@ -1343,4 +1069,4 @@ var Sirannon = class {
   }
 };
 
-export { BackupManager, BackupScheduler, ConnectionPool, Database2 as Database, HookRegistry, LifecycleManager, MetricsCollector, MigrationRunner, Sirannon, Transaction, createTenantResolver, execute, executeBatch, query, queryOne, sanitizeTenantId, tenantPath };
+export { ConnectionPool, Database, HookRegistry, LifecycleManager, MetricsCollector, MigrationRunner, Sirannon, createTenantResolver, sanitizeTenantId, tenantPath };