@noormdev/sdk 1.0.0-alpha.16 → 1.0.0-alpha.18

package/dist/index.js

@@ -1,19 +1,22 @@
-import { processFile, DtReader, isTemplate, FORMAT_VERSION, DT_EXTENSIONS, encryptWithPassphrase, ENCODED_TYPES, GZIP_THRESHOLD, GZIP_RATIO_THRESHOLD } from './chunk-BTXUEWYQ.js';
-import { NOORM_TABLES, initializeVault, getVaultStatus, setVaultSecret, getVaultSecret, getAllVaultSecrets, listVaultSecretKeys, deleteVaultSecret, vaultSecretExists, getVaultKey, encryptVaultKey } from './chunk-ZRZ7AECF.js';
+import { processFile, DtReader, isTemplate, FORMAT_VERSION, DT_EXTENSIONS, encryptWithPassphrase, ENCODED_TYPES } from './chunk-KF7GE2VM.js';
+import { initializeVault, getVaultStatus, setVaultSecret, getVaultSecret, getAllVaultSecrets, listVaultSecretKeys, deleteVaultSecret, vaultSecretExists, getVaultKey, noormDb, getNoormTables, encryptVaultKey } from './chunk-LJDHQEWW.js';
 import { observer } from './chunk-4HW4CS2C.js';
 import { constants, existsSync, readFileSync, mkdirSync, writeFileSync, createWriteStream } from 'fs';
-import path, { join, dirname } from 'path';
+import path, { join, dirname, resolve } from 'path';
 import { makeNestedConfig, gigabytes, attempt, retry, clone, merge, attemptSync } from '@logosdx/utils';
-import { homedir, userInfo } from 'os';
+import { homedir, availableParallelism, userInfo } from 'os';
 import { stat, mkdir, writeFile, unlink, rename, rm, readdir, readFile, access } from 'fs/promises';
-import { createHash, createDecipheriv, randomBytes, createCipheriv, hkdfSync } from 'crypto';
+import { createHash, createDecipheriv, randomBytes, createCipheriv, randomUUID, hkdfSync } from 'crypto';
 import { z } from 'zod';
 import { parse, stringify } from 'yaml';
 import { execSync } from 'child_process';
 import { sql } from 'kysely';
 import 'dayjs';
 import ansis from 'ansis';
-import { createGzip, gunzipSync, gzipSync } from 'zlib';
+import { Worker, parentPort, workerData } from 'worker_threads';
+import { ObserverRelay } from '@logosdx/observer';
+import { fileURLToPath } from 'url';
+import { createGzip } from 'zlib';
 import { pipeline } from 'stream/promises';
 import { PassThrough } from 'stream';
 import JSON5 from 'json5';
@@ -1672,6 +1675,7 @@ async function loadExistingIdentity() {
 var ConnectionManager = class {
   #cached = /* @__PURE__ */ new Map();
   #tracked = /* @__PURE__ */ new Map();
+  #bridges = /* @__PURE__ */ new Map();
   #nextId = 1;
   #shuttingDown = false;
   #unsubscribe = null;
@@ -1755,7 +1759,7 @@ var ConnectionManager = class {
     for (const [id, entry] of trackedEntries) {
       const destroyWithTimeout = Promise.race([
         entry.conn.destroy(),
-        new Promise((resolve) => setTimeout(resolve, CLOSE_TIMEOUT))
+        new Promise((resolve2) => setTimeout(resolve2, CLOSE_TIMEOUT))
       ]);
       const [, err] = await attempt(() => destroyWithTimeout);
       this.#tracked.delete(id);
@@ -1765,6 +1769,28 @@ var ConnectionManager = class {
         observer.emit("connection:close", { configName: entry.configName });
       }
     }
+    const bridgeNames = Array.from(this.#bridges.keys());
+    for (const name of bridgeNames) {
+      await this.closeBridge(name);
+    }
+  }
+  /**
+   * Track a WorkerBridge connection for a config.
+   *
+   * The bridge is shut down alongside regular connections on app:shutdown.
+   */
+  trackBridge(configName, bridge) {
+    this.#bridges.set(configName, bridge);
+  }
+  /**
+   * Close a specific bridge by config name.
+   */
+  async closeBridge(configName) {
+    const bridge = this.#bridges.get(configName);
+    if (bridge) {
+      await bridge.shutdown();
+      this.#bridges.delete(configName);
+    }
   }
   /**
    * Check if a cached connection exists for a config name.
@@ -1776,7 +1802,7 @@ var ConnectionManager = class {
    * Get total number of active connections.
    */
   get size() {
-    return this.#cached.size + this.#tracked.size;
+    return this.#cached.size + this.#tracked.size + this.#bridges.size;
   }
   /**
    * Check if shutdown is in progress.
@@ -1889,7 +1915,7 @@ async function createConnection(config, configName = "__default__") {
     destroy: wrappedDestroy
   };
   observer.emit("connection:open", { configName, dialect: config.dialect });
-  await waitForIdentityToLoad(trackedConn.db);
+  await waitForIdentityToLoad(trackedConn.db, config.dialect);
   return trackedConn;
 }
 var SYSTEM_DATABASES = {
@@ -1920,7 +1946,7 @@ async function testConnection(config, options = {}) {
 // src/core/version/types.ts
 var CURRENT_VERSIONS = Object.freeze({
   /** Database tracking tables schema version */
-  schema: 1,
+  schema: 2,
   /** State file (state.enc) schema version */
   state: 1,
   /** Settings file (settings.yml) schema version */
@@ -2022,6 +2048,171 @@ var v1 = {
     await db.schema.dropTable("__noorm_version__").execute();
   }
 };
+var TABLE_MAP = [
+  { old: "__noorm_version__", new: "version" },
+  { old: "__noorm_change__", new: "change" },
+  { old: "__noorm_executions__", new: "executions" },
+  { old: "__noorm_lock__", new: "lock" },
+  { old: "__noorm_identities__", new: "identities" },
+  { old: "__noorm_vault__", new: "vault" }
+];
+var INDEXES = [
+  { name: "idx_executions_change_id", table: "executions", columns: ["change_id"] },
+  { name: "idx_change_name_config", table: "change", columns: ["name", "config_name"] },
+  { name: "idx_vault_secret_key", table: "vault", columns: ["secret_key"] }
+];
+var v2 = {
+  version: 2,
+  description: "Move tracking tables to noorm schema",
+  async up(db, dialect) {
+    if (dialect === "sqlite" || dialect === "mysql") return;
+    await db.transaction().execute(async (trx) => {
+      if (dialect === "postgres") {
+        await sql`CREATE SCHEMA IF NOT EXISTS noorm`.execute(trx);
+      } else {
+        await sql`IF NOT EXISTS (SELECT 1 FROM sys.schemas WHERE name = 'noorm') EXEC('CREATE SCHEMA noorm')`.execute(trx);
+      }
+      if (dialect === "postgres") {
+        const { rows } = await sql`
+                    SELECT constraint_name
+                    FROM information_schema.table_constraints
+                    WHERE table_name = '__noorm_executions__'
+                    AND constraint_type = 'FOREIGN KEY'
+                `.execute(trx);
+        for (const row of rows) {
+          await sql`ALTER TABLE __noorm_executions__ DROP CONSTRAINT ${sql.ref(row.constraint_name)}`.execute(trx);
+        }
+      } else {
+        const { rows } = await sql`
+                    SELECT fk.name AS fk_name
+                    FROM sys.foreign_keys fk
+                    JOIN sys.tables t ON fk.parent_object_id = t.object_id
+                    WHERE t.name = '__noorm_executions__'
+                `.execute(trx);
+        for (const row of rows) {
+          await sql`ALTER TABLE __noorm_executions__ DROP CONSTRAINT ${sql.ref(row.fk_name)}`.execute(trx);
+        }
+      }
+      if (dialect === "postgres") {
+        for (const idx of INDEXES) {
+          await sql`DROP INDEX IF EXISTS ${sql.ref(idx.name)}`.execute(trx);
+        }
+      } else {
+        const prefixedTables = {
+          executions: "__noorm_executions__",
+          change: "__noorm_change__",
+          vault: "__noorm_vault__"
+        };
+        for (const idx of INDEXES) {
+          const tableName = prefixedTables[idx.table];
+          await sql`
+                        IF EXISTS (SELECT 1 FROM sys.indexes WHERE name = ${idx.name})
+                        DROP INDEX ${sql.ref(idx.name)} ON ${sql.table(tableName)}
+                    `.execute(trx);
+        }
+      }
+      for (const t of TABLE_MAP) {
+        if (dialect === "postgres") {
+          await sql`ALTER TABLE ${sql.table(t.old)} SET SCHEMA noorm`.execute(trx);
+        } else {
+          await sql`ALTER SCHEMA noorm TRANSFER ${sql.ref(`dbo.${t.old}`)}`.execute(trx);
+        }
+      }
+      for (const t of TABLE_MAP) {
+        if (dialect === "postgres") {
+          await sql`ALTER TABLE ${sql.table(`noorm.${t.old}`)} RENAME TO ${sql.ref(t.new)}`.execute(trx);
+        } else {
+          await sql`EXEC sp_rename ${sql.raw(`'noorm.${t.old}'`)}, ${sql.raw(`'${t.new}'`)}`.execute(trx);
+        }
+      }
+      await sql`
+                ALTER TABLE ${sql.table("noorm.executions")}
+                ADD CONSTRAINT fk_executions_change_id
+                FOREIGN KEY (change_id) REFERENCES ${sql.table("noorm.change")}(id)
+                ON DELETE CASCADE
+            `.execute(trx);
+      for (const idx of INDEXES) {
+        const cols = idx.columns.join(", ");
+        await sql`CREATE INDEX ${sql.ref(idx.name)} ON ${sql.table(`noorm.${idx.table}`)} (${sql.raw(cols)})`.execute(trx);
+      }
+    });
+  },
+  async down(db, dialect) {
+    if (dialect === "sqlite" || dialect === "mysql") return;
+    await db.transaction().execute(async (trx) => {
+      if (dialect === "postgres") {
+        const { rows } = await sql`
+                    SELECT constraint_name
+                    FROM information_schema.table_constraints
+                    WHERE table_schema = 'noorm'
+                    AND table_name = 'executions'
+                    AND constraint_type = 'FOREIGN KEY'
+                `.execute(trx);
+        for (const row of rows) {
+          await sql`ALTER TABLE ${sql.table("noorm.executions")} DROP CONSTRAINT ${sql.ref(row.constraint_name)}`.execute(trx);
+        }
+      } else {
+        const { rows } = await sql`
+                    SELECT fk.name AS fk_name
+                    FROM sys.foreign_keys fk
+                    JOIN sys.tables t ON fk.parent_object_id = t.object_id
+                    JOIN sys.schemas s ON t.schema_id = s.schema_id
+                    WHERE t.name = 'executions' AND s.name = 'noorm'
+                `.execute(trx);
+        for (const row of rows) {
+          await sql`ALTER TABLE ${sql.table("noorm.executions")} DROP CONSTRAINT ${sql.ref(row.fk_name)}`.execute(trx);
+        }
+      }
+      if (dialect === "postgres") {
+        for (const idx of INDEXES) {
+          await sql`DROP INDEX IF EXISTS ${sql.ref(`noorm.${idx.name}`)}`.execute(trx);
+        }
+      } else {
+        for (const idx of INDEXES) {
+          await sql`
+                        IF EXISTS (SELECT 1 FROM sys.indexes WHERE name = ${idx.name})
+                        DROP INDEX ${sql.ref(idx.name)} ON ${sql.table(`noorm.${idx.table}`)}
+                    `.execute(trx);
+        }
+      }
+      for (const t of TABLE_MAP) {
+        if (dialect === "postgres") {
+          await sql`ALTER TABLE ${sql.table(`noorm.${t.new}`)} RENAME TO ${sql.ref(t.old)}`.execute(trx);
+        } else {
+          await sql`EXEC sp_rename ${sql.raw(`'noorm.${t.new}'`)}, ${sql.raw(`'${t.old}'`)}`.execute(trx);
+        }
+      }
+      for (const t of TABLE_MAP) {
+        if (dialect === "postgres") {
+          await sql`ALTER TABLE ${sql.table(`noorm.${t.old}`)} SET SCHEMA public`.execute(trx);
+        } else {
+          await sql`ALTER SCHEMA dbo TRANSFER ${sql.ref(`noorm.${t.old}`)}`.execute(trx);
+        }
+      }
+      await sql`
+                ALTER TABLE __noorm_executions__
+                ADD CONSTRAINT fk_executions_change_id
+                FOREIGN KEY (change_id) REFERENCES __noorm_change__(id)
+                ON DELETE CASCADE
+            `.execute(trx);
+      for (const idx of INDEXES) {
+        const prefixedTables = {
+          executions: "__noorm_executions__",
+          change: "__noorm_change__",
+          vault: "__noorm_vault__"
+        };
+        const tableName = prefixedTables[idx.table];
+        const cols = idx.columns.join(", ");
+        await sql`CREATE INDEX ${sql.ref(idx.name)} ON ${sql.table(tableName)} (${sql.raw(cols)})`.execute(trx);
+      }
+      if (dialect === "postgres") {
+        await sql`DROP SCHEMA IF EXISTS noorm`.execute(trx);
+      } else {
+        await sql`IF EXISTS (SELECT 1 FROM sys.schemas WHERE name = 'noorm') DROP SCHEMA noorm`.execute(trx);
+      }
+    });
+  }
+};
 
 // src/core/update/checker.ts
 function getCurrentVersion() {
@@ -2029,26 +2220,43 @@ function getCurrentVersion() {
 }
 
 // src/core/version/schema/index.ts
-var MIGRATIONS = [v1];
-async function tablesExist(db) {
-  const [result, err] = await attempt(async () => {
-    await sql`SELECT 1 FROM __noorm_version__ LIMIT 1`.execute(db);
+var MIGRATIONS = [v1, v2];
+async function tablesExist(db, dialect) {
+  const [legacyResult] = await attempt(async () => {
+    await db.selectFrom("__noorm_version__").select("id").limit(1).executeTakeFirst();
     return true;
   });
-  if (err) return false;
-  return result;
+  if (legacyResult) return true;
+  if (dialect === "postgres" || dialect === "mssql") {
+    const ndb = noormDb(db, dialect);
+    const tables = getNoormTables(dialect);
+    const [schemaResult] = await attempt(async () => {
+      await ndb.selectFrom(tables.version).select("id").limit(1).executeTakeFirst();
+      return true;
+    });
+    if (schemaResult) return true;
+  }
+  return false;
 }
-async function getSchemaVersion(db) {
-  const exists = await tablesExist(db);
+async function getSchemaVersion(db, dialect) {
+  const exists = await tablesExist(db, dialect);
   if (!exists) return 0;
-  const [result, err] = await attempt(async () => {
+  const [legacyResult] = await attempt(async () => {
     return db.selectFrom("__noorm_version__").select("noorm_version").orderBy("id", "desc").limit(1).executeTakeFirst();
   });
-  if (err) return 0;
-  return result?.noorm_version ?? 0;
+  if (legacyResult) return legacyResult.noorm_version ?? 0;
+  if (dialect === "postgres" || dialect === "mssql") {
+    const ndb = noormDb(db, dialect);
+    const tables = getNoormTables(dialect);
+    const [schemaResult] = await attempt(async () => {
+      return ndb.selectFrom(tables.version).select("noorm_version").orderBy("id", "desc").limit(1).executeTakeFirst();
+    });
+    if (schemaResult) return schemaResult.noorm_version ?? 0;
+  }
+  return 0;
 }
-async function checkSchemaVersion(db) {
-  const current = await getSchemaVersion(db);
+async function checkSchemaVersion(db, dialect) {
+  const current = await getSchemaVersion(db, dialect);
   const expected = CURRENT_VERSIONS.schema;
   observer.emit("version:schema:checking", { current });
   return {
@@ -2070,7 +2278,9 @@ async function bootstrapSchema(db, dialect, options) {
       throw new MigrationError("schema", migration.version, err);
     }
   }
-  await db.insertInto("__noorm_version__").values({
+  const ndb = noormDb(db, dialect);
+  const tables = getNoormTables(dialect);
+  await ndb.insertInto(tables.version).values({
     cli_version: getCurrentVersion(),
     noorm_version: CURRENT_VERSIONS.schema,
     state_version: CURRENT_VERSIONS.state,
@@ -2082,22 +2292,37 @@ async function bootstrapSchema(db, dialect, options) {
     to: CURRENT_VERSIONS.schema,
     durationMs
   });
-  await waitForIdentityToLoad(db);
+  await waitForIdentityToLoad(db, dialect);
 }
-async function getLatestVersionRecord(db) {
-  const exists = await tablesExist(db);
+async function getLatestVersionRecord(db, dialect) {
+  const exists = await tablesExist(db, dialect);
   if (!exists) return null;
-  const [result, err] = await attempt(async () => {
+  const [legacyResult] = await attempt(async () => {
     return db.selectFrom("__noorm_version__").select(["state_version", "settings_version"]).orderBy("id", "desc").limit(1).executeTakeFirst();
   });
-  if (err || !result) return null;
-  return {
-    stateVersion: result.state_version,
-    settingsVersion: result.settings_version
-  };
+  if (legacyResult) {
+    return {
+      stateVersion: legacyResult.state_version,
+      settingsVersion: legacyResult.settings_version
+    };
+  }
+  if (dialect === "postgres" || dialect === "mssql") {
+    const ndb = noormDb(db, dialect);
+    const tables = getNoormTables(dialect);
+    const [schemaResult] = await attempt(async () => {
+      return ndb.selectFrom(tables.version).select(["state_version", "settings_version"]).orderBy("id", "desc").limit(1).executeTakeFirst();
+    });
+    if (schemaResult) {
+      return {
+        stateVersion: schemaResult.state_version,
+        settingsVersion: schemaResult.settings_version
+      };
+    }
+  }
+  return null;
 }
 async function migrateSchema(db, dialect, options) {
-  const status = await checkSchemaVersion(db);
+  const status = await checkSchemaVersion(db, dialect);
   if (status.isNewer) {
     observer.emit("version:mismatch", {
       layer: "schema",
@@ -2116,7 +2341,7 @@ async function migrateSchema(db, dialect, options) {
     from: status.current,
     to: CURRENT_VERSIONS.schema
   });
-  const existing = await getLatestVersionRecord(db);
+  const existing = await getLatestVersionRecord(db, dialect);
   const pendingMigrations = MIGRATIONS.filter((m) => m.version > status.current);
   for (const migration of pendingMigrations) {
     const [, err] = await attempt(() => migration.up(db, dialect));
@@ -2124,7 +2349,9 @@ async function migrateSchema(db, dialect, options) {
       throw new MigrationError("schema", migration.version, err);
     }
   }
-  await db.insertInto("__noorm_version__").values({
+  const ndb = noormDb(db, dialect);
+  const tables = getNoormTables(dialect);
+  await ndb.insertInto(tables.version).values({
     cli_version: getCurrentVersion(),
     noorm_version: CURRENT_VERSIONS.schema,
     state_version: existing?.stateVersion ?? CURRENT_VERSIONS.state,
@@ -2136,7 +2363,7 @@ async function migrateSchema(db, dialect, options) {
     to: CURRENT_VERSIONS.schema,
     durationMs
   });
-  await waitForIdentityToLoad(db);
+  await waitForIdentityToLoad(db, dialect);
 }
 async function ensureSchemaVersion(db, dialect, options) {
   await migrateSchema(db, dialect);
@@ -2284,9 +2511,11 @@ addMaskedFields([
 ]);
 
 // src/core/identity/sync.ts
-async function registerIdentity(db, identity) {
+async function registerIdentity(db, identity, dialect) {
+  const ndb = noormDb(db, dialect);
+  const tables = getNoormTables(dialect);
   const [existing, selectErr] = await attempt(
-    () => db.selectFrom("__noorm_identities__").select(["id"]).where("identity_hash", "=", identity.identityHash).executeTakeFirst()
+    () => ndb.selectFrom(tables.identities).select(["id"]).where("identity_hash", "=", identity.identityHash).executeTakeFirst()
   );
   if (selectErr) {
     observer.emit("error", {
@@ -2302,7 +2531,7 @@ async function registerIdentity(db, identity) {
   }
   if (existing) {
     const [, updateErr] = await attempt(
-      () => db.updateTable("__noorm_identities__").set({ last_seen_at: /* @__PURE__ */ new Date() }).where("identity_hash", "=", identity.identityHash).execute()
+      () => ndb.updateTable(tables.identities).set({ last_seen_at: /* @__PURE__ */ new Date() }).where("identity_hash", "=", identity.identityHash).execute()
     );
     if (updateErr) {
       observer.emit("error", {
@@ -2319,7 +2548,7 @@ async function registerIdentity(db, identity) {
     return { ok: true, registered: false };
   }
   const [, insertErr] = await attempt(
-    () => db.insertInto("__noorm_identities__").values({
+    () => ndb.insertInto(tables.identities).values({
       identity_hash: identity.identityHash,
       email: identity.email,
       name: identity.name,
@@ -2362,11 +2591,11 @@ function resolveIdentity2(options = {}) {
 function getIdentityForConfig(config) {
   return resolveIdentity2({ configIdentity: config.identity });
 }
-async function waitForIdentityToLoad(db) {
+async function waitForIdentityToLoad(db, dialect) {
   const identity = await loadExistingIdentity();
   if (!identity) observer.emit("identity:not-found");
   if (!identity) return;
-  const [, err] = await attempt(() => registerIdentity(db, identity));
+  const [, err] = await attempt(() => registerIdentity(db, identity, dialect));
   if (err) observer.emit("error", {
     error: err,
     source: "identity:ensure",
@@ -2946,9 +3175,13 @@ function getExtension(filename) {
 }
 var ChangeHistory = class {
   #db;
+  #ndb;
+  #tables;
   #configName;
-  constructor(db, configName) {
+  constructor(db, configName, dialect = "sqlite") {
     this.#db = db;
+    this.#ndb = noormDb(db, dialect);
+    this.#tables = getNoormTables(dialect);
     this.#configName = configName;
   }
   // ─────────────────────────────────────────────────────────
@@ -2965,7 +3198,7 @@ var ChangeHistory = class {
    */
   async getStatus(name) {
     const [record, err] = await attempt(
-      () => this.#db.selectFrom(NOORM_TABLES.change).select([
+      () => this.#ndb.selectFrom(this.#tables.change).select([
         "name",
         "status",
         "executed_at",
@@ -2986,7 +3219,7 @@ var ChangeHistory = class {
       return null;
     }
     const [revertRecord] = await attempt(
-      () => this.#db.selectFrom(NOORM_TABLES.change).select(["executed_at"]).where("name", "=", name).where("change_type", "=", "change").where("direction", "=", "revert").where("status", "=", "success").where("config_name", "=", this.#configName).orderBy("id", "desc").limit(1).executeTakeFirst()
+      () => this.#ndb.selectFrom(this.#tables.change).select(["executed_at"]).where("name", "=", name).where("change_type", "=", "change").where("direction", "=", "revert").where("status", "=", "success").where("config_name", "=", this.#configName).orderBy("id", "desc").limit(1).executeTakeFirst()
     );
     return {
       name: record.name,
@@ -3007,7 +3240,7 @@ var ChangeHistory = class {
   async getAllStatuses() {
     const statuses = /* @__PURE__ */ new Map();
     const [records, err] = await attempt(
-      () => this.#db.selectFrom(NOORM_TABLES.change).select(["id", "name", "status", "executed_at", "executed_by", "error_message"]).where("change_type", "=", "change").where("direction", "=", "change").where("config_name", "=", this.#configName).orderBy("id", "desc").execute()
+      () => this.#ndb.selectFrom(this.#tables.change).select(["id", "name", "status", "executed_at", "executed_by", "error_message"]).where("change_type", "=", "change").where("direction", "=", "change").where("config_name", "=", this.#configName).orderBy("id", "desc").execute()
     );
     if (err) {
       observer.emit("error", {
@@ -3031,7 +3264,7 @@ var ChangeHistory = class {
       }
     }
     const [reverts] = await attempt(
-      () => this.#db.selectFrom(NOORM_TABLES.change).select(["name", "executed_at"]).where("change_type", "=", "change").where("direction", "=", "revert").where("status", "=", "success").where("config_name", "=", this.#configName).orderBy("id", "desc").execute()
+      () => this.#ndb.selectFrom(this.#tables.change).select(["name", "executed_at"]).where("change_type", "=", "change").where("direction", "=", "revert").where("status", "=", "success").where("config_name", "=", this.#configName).orderBy("id", "desc").execute()
     );
     if (reverts) {
       const seenReverts = /* @__PURE__ */ new Set();
@@ -3061,7 +3294,7 @@ var ChangeHistory = class {
       return { needsRun: true, reason: "force" };
     }
     const [record, err] = await attempt(
-      () => this.#db.selectFrom(NOORM_TABLES.change).select(["status", "checksum"]).where("name", "=", name).where("change_type", "=", "change").where("direction", "=", "change").where("config_name", "=", this.#configName).orderBy("id", "desc").limit(1).executeTakeFirst()
+      () => this.#ndb.selectFrom(this.#tables.change).select(["status", "checksum"]).where("name", "=", name).where("change_type", "=", "change").where("direction", "=", "change").where("config_name", "=", this.#configName).orderBy("id", "desc").limit(1).executeTakeFirst()
     );
     if (err) {
       observer.emit("error", {
@@ -3126,7 +3359,7 @@ var ChangeHistory = class {
    */
   async createOperation(data2) {
     const [result, err] = await attempt(
-      () => this.#db.insertInto(NOORM_TABLES.change).values({
+      () => this.#ndb.insertInto(this.#tables.change).values({
         name: data2.name,
         change_type: "change",
         direction: data2.direction,
@@ -3170,7 +3403,7 @@ var ChangeHistory = class {
       status: "pending"
     }));
     const [, err] = await attempt(
-      () => this.#db.insertInto(NOORM_TABLES.executions).values(values).execute()
+      () => this.#ndb.insertInto(this.#tables.executions).values(values).execute()
     );
     if (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -3193,7 +3426,7 @@ var ChangeHistory = class {
    */
   async updateFileExecution(operationId, filepath, status, durationMs, errorMessage, skipReason) {
     const [result, err] = await attempt(
-      () => this.#db.updateTable(NOORM_TABLES.executions).set({
+      () => this.#ndb.updateTable(this.#tables.executions).set({
         status,
         duration_ms: Math.round(durationMs),
         error_message: errorMessage ?? "",
@@ -3228,7 +3461,7 @@ var ChangeHistory = class {
    */
   async skipRemainingFiles(operationId, reason) {
     const [, err] = await attempt(
-      () => this.#db.updateTable(NOORM_TABLES.executions).set({
+      () => this.#ndb.updateTable(this.#tables.executions).set({
         status: "skipped",
         skip_reason: reason
       }).where("change_id", "=", operationId).where("status", "=", "pending").execute()
@@ -3251,7 +3484,7 @@ var ChangeHistory = class {
   async finalizeOperation(operationId, status, checksum, durationMs, errorMessage) {
     const truncatedError = errorMessage ? errorMessage.slice(0, 2e3) : "";
     const [result, err] = await attempt(
-      () => this.#db.updateTable(NOORM_TABLES.change).set({
+      () => this.#ndb.updateTable(this.#tables.change).set({
         status,
         checksum,
         duration_ms: Math.round(durationMs),
@@ -3292,7 +3525,7 @@ var ChangeHistory = class {
    */
   async recordReset(executedBy, reason) {
     const [result, err] = await attempt(
-      () => this.#db.insertInto(NOORM_TABLES.change).values({
+      () => this.#ndb.insertInto(this.#tables.change).values({
         name: "__reset__",
         change_type: "change",
         direction: "change",
@@ -3322,14 +3555,14 @@ var ChangeHistory = class {
    */
   async deleteRecords(name) {
     const [operations, queryErr] = await attempt(
-      () => this.#db.selectFrom(NOORM_TABLES.change).select(["id"]).where("name", "=", name).where("change_type", "=", "change").where("config_name", "=", this.#configName).execute()
+      () => this.#ndb.selectFrom(this.#tables.change).select(["id"]).where("name", "=", name).where("change_type", "=", "change").where("config_name", "=", this.#configName).execute()
     );
     if (queryErr || !operations || operations.length === 0) {
       return;
     }
     const operationIds = operations.map((o) => o.id);
     const [, execErr] = await attempt(
-      () => this.#db.deleteFrom(NOORM_TABLES.executions).where("change_id", "in", operationIds).execute()
+      () => this.#ndb.deleteFrom(this.#tables.executions).where("change_id", "in", operationIds).execute()
     );
     if (execErr) {
       observer.emit("error", {
@@ -3339,7 +3572,7 @@ var ChangeHistory = class {
       });
     }
     const [, changeErr] = await attempt(
-      () => this.#db.deleteFrom(NOORM_TABLES.change).where("id", "in", operationIds).execute()
+      () => this.#ndb.deleteFrom(this.#tables.change).where("id", "in", operationIds).execute()
     );
     if (changeErr) {
       observer.emit("error", {
@@ -3359,7 +3592,7 @@ var ChangeHistory = class {
    * @param limit - Max records to return
    */
   async getHistory(name, limit) {
-    let query = this.#db.selectFrom(NOORM_TABLES.change).select([
+    let query = this.#ndb.selectFrom(this.#tables.change).select([
       "id",
       "name",
       "direction",
@@ -3407,7 +3640,7 @@ var ChangeHistory = class {
    * @param limit - Max records to return
    */
   async getUnifiedHistory(changeTypes, limit) {
-    let query = this.#db.selectFrom(NOORM_TABLES.change).select([
+    let query = this.#ndb.selectFrom(this.#tables.change).select([
       "id",
       "name",
       "change_type",
@@ -3463,7 +3696,7 @@ var ChangeHistory = class {
    */
   async getFileHistory(operationId) {
     const [records, err] = await attempt(
-      () => this.#db.selectFrom(NOORM_TABLES.executions).select([
+      () => this.#ndb.selectFrom(this.#tables.executions).select([
         "id",
         "change_id",
         "filepath",
@@ -3513,9 +3746,13 @@ var ChangeHistory = class {
 };
 var Tracker = class {
   #db;
+  #ndb;
+  #tables;
   #configName;
-  constructor(db, configName) {
+  constructor(db, configName, dialect = "sqlite") {
     this.#db = db;
+    this.#ndb = noormDb(db, dialect);
+    this.#tables = getNoormTables(dialect);
     this.#configName = configName;
   }
   /**
@@ -3538,15 +3775,16 @@ var Tracker = class {
       return { needsRun: true, reason: "force" };
     }
     const [record, err] = await attempt(
-      () => this.#db.selectFrom(NOORM_TABLES.executions).innerJoin(
-        NOORM_TABLES.change,
-        `${NOORM_TABLES.change}.id`,
-        `${NOORM_TABLES.executions}.change_id`
+      () => this.#ndb.selectFrom(this.#tables.executions).innerJoin(
+        this.#tables.change,
+        `${this.#tables.change}.id`,
+        `${this.#tables.executions}.change_id`
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
       ).select((eb) => [
-        eb.ref(`${NOORM_TABLES.executions}.checksum`).as("checksum"),
-        eb.ref(`${NOORM_TABLES.executions}.status`).as("exec_status"),
-        eb.ref(`${NOORM_TABLES.change}.status`).as("change_status")
-      ]).where(`${NOORM_TABLES.executions}.filepath`, "=", filepath).where(`${NOORM_TABLES.change}.config_name`, "=", this.#configName).orderBy(`${NOORM_TABLES.executions}.id`, "desc").limit(1).executeTakeFirst()
+        eb.ref(`${this.#tables.executions}.checksum`).as("checksum"),
+        eb.ref(`${this.#tables.executions}.status`).as("exec_status"),
+        eb.ref(`${this.#tables.change}.status`).as("change_status")
+      ]).where(`${this.#tables.executions}.filepath`, "=", filepath).where(`${this.#tables.change}.config_name`, "=", this.#configName).orderBy(`${this.#tables.executions}.id`, "desc").limit(1).executeTakeFirst()
     );
     if (err) {
       observer.emit("error", {
@@ -3602,7 +3840,7 @@ var Tracker = class {
     const direction = data2.direction ?? "commit";
     const dbDirection = direction === "commit" ? "change" : "revert";
     const [result, err] = await attempt(
-      () => this.#db.insertInto(NOORM_TABLES.change).values({
+      () => this.#ndb.insertInto(this.#tables.change).values({
         name: data2.name,
         change_type: data2.changeType,
         direction: dbDirection,
@@ -3639,7 +3877,7 @@ var Tracker = class {
    */
   async recordExecution(data2) {
     const [, err] = await attempt(
-      () => this.#db.insertInto(NOORM_TABLES.executions).values({
+      () => this.#ndb.insertInto(this.#tables.executions).values({
         change_id: data2.changeId,
         filepath: data2.filepath,
         file_type: "sql",
@@ -3673,7 +3911,7 @@ var Tracker = class {
   async finalizeOperation(operationId, status, durationMs, checksum, errorMessage) {
     const truncatedError = errorMessage ? errorMessage.slice(0, 2e3) : "";
     const [result, err] = await attempt(
-      () => this.#db.updateTable(NOORM_TABLES.change).set({
+      () => this.#ndb.updateTable(this.#tables.change).set({
         status,
         duration_ms: Math.round(durationMs),
         checksum: checksum ?? "",
@@ -3724,7 +3962,7 @@ var Tracker = class {
       status: "pending"
     }));
     const [, err] = await attempt(
-      () => this.#db.insertInto(NOORM_TABLES.executions).values(values).execute()
+      () => this.#ndb.insertInto(this.#tables.executions).values(values).execute()
     );
     if (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -3752,7 +3990,7 @@ var Tracker = class {
    */
   async updateFileExecution(operationId, filepath, status, durationMs, errorMessage, skipReason) {
     const [result, err] = await attempt(
-      () => this.#db.updateTable(NOORM_TABLES.executions).set({
+      () => this.#ndb.updateTable(this.#tables.executions).set({
         status,
         duration_ms: Math.round(durationMs),
         error_message: errorMessage ?? "",
@@ -3792,7 +4030,7 @@ var Tracker = class {
    */
   async skipRemainingFiles(operationId, reason) {
     const [, err] = await attempt(
-      () => this.#db.updateTable(NOORM_TABLES.executions).set({
+      () => this.#ndb.updateTable(this.#tables.executions).set({
         status: "skipped",
         skip_reason: reason
       }).where("change_id", "=", operationId).where("status", "=", "pending").execute()
@@ -3823,7 +4061,7 @@ var Tracker = class {
       return { needsRun: true, reason: "force" };
     }
     const [record, err] = await attempt(
-      () => this.#db.selectFrom(NOORM_TABLES.change).select(["status", "checksum"]).where("name", "=", name).where("direction", "=", "change").where("config_name", "=", this.#configName).orderBy("id", "desc").limit(1).executeTakeFirst()
+      () => this.#ndb.selectFrom(this.#tables.change).select(["status", "checksum"]).where("name", "=", name).where("direction", "=", "change").where("config_name", "=", this.#configName).orderBy("id", "desc").limit(1).executeTakeFirst()
     );
     if (err) {
       observer.emit("error", {
@@ -3877,11 +4115,13 @@ var Tracker = class {
 var ChangeTracker = class extends Tracker {
   // Store db and configName for change-specific queries
   // (Tracker uses private fields, so we need our own references)
-  #db;
+  #ndb;
+  #tables;
   #configName;
-  constructor(db, configName) {
-    super(db, configName);
-    this.#db = db;
+  constructor(db, configName, dialect = "sqlite") {
+    super(db, configName, dialect);
+    this.#ndb = noormDb(db, dialect);
+    this.#tables = getNoormTables(dialect);
     this.#configName = configName;
   }
   /**
@@ -3893,7 +4133,7 @@ var ChangeTracker = class extends Tracker {
    */
   async canRevert(name, force) {
     const [record, err] = await attempt(
-      () => this.#db.selectFrom(NOORM_TABLES.change).select(["status"]).where("name", "=", name).where("change_type", "=", "change").where("direction", "=", "change").where("config_name", "=", this.#configName).orderBy("id", "desc").limit(1).executeTakeFirst()
+      () => this.#ndb.selectFrom(this.#tables.change).select(["status"]).where("name", "=", name).where("change_type", "=", "change").where("direction", "=", "change").where("config_name", "=", this.#configName).orderBy("id", "desc").limit(1).executeTakeFirst()
     );
     if (err) {
       observer.emit("error", {
@@ -3933,11 +4173,11 @@ var ChangeTracker = class extends Tracker {
    */
   async markAsReverted(name) {
     const [record] = await attempt(
-      () => this.#db.selectFrom(NOORM_TABLES.change).select(["id"]).where("name", "=", name).where("change_type", "=", "change").where("direction", "=", "change").where("config_name", "=", this.#configName).orderBy("id", "desc").limit(1).executeTakeFirst()
+      () => this.#ndb.selectFrom(this.#tables.change).select(["id"]).where("name", "=", name).where("change_type", "=", "change").where("direction", "=", "change").where("config_name", "=", this.#configName).orderBy("id", "desc").limit(1).executeTakeFirst()
     );
     if (record) {
       await attempt(
-        () => this.#db.updateTable(NOORM_TABLES.change).set({ status: "reverted" }).where("id", "=", record.id).execute()
+        () => this.#ndb.updateTable(this.#tables.change).set({ status: "reverted" }).where("id", "=", record.id).execute()
       );
     }
   }
@@ -3953,7 +4193,7 @@ var ChangeTracker = class extends Tracker {
    */
   async markAllAsStale() {
     const [result, err] = await attempt(
-      () => this.#db.updateTable(NOORM_TABLES.change).set({ status: "stale" }).where("direction", "=", "change").where("status", "in", ["success", "failed", "pending"]).where("config_name", "=", this.#configName).execute()
+      () => this.#ndb.updateTable(this.#tables.change).set({ status: "stale" }).where("direction", "=", "change").where("status", "in", ["success", "failed", "pending"]).where("config_name", "=", this.#configName).execute()
     );
     if (err) {
       observer.emit("error", {
@@ -4065,7 +4305,7 @@ var LockManager = class {
     observer.emit("lock:acquiring", { configName, identity });
     while (true) {
       await this.cleanupExpired(db, configName, opts.dialect);
-      const existing = await this.getLock(db, configName);
+      const existing = await this.getLock(db, configName, opts.dialect);
       if (!existing) {
         const lock = await this.createLock(db, configName, identity, opts);
         observer.emit("lock:acquired", {
@@ -4117,18 +4357,21 @@ var LockManager = class {
    * @param db - Kysely database instance
    * @param configName - Config/database scope
    * @param identity - Identity of the lock holder
+   * @param dialect - Database dialect for schema-aware table resolution
    * @throws LockNotFoundError if no lock exists
    * @throws LockOwnershipError if lock is held by someone else
    */
-  async release(db, configName, identity) {
-    const existing = await this.getLock(db, configName);
+  async release(db, configName, identity, dialect) {
+    const ndb = noormDb(db, dialect);
+    const tables = getNoormTables(dialect);
+    const existing = await this.getLock(db, configName, dialect);
     if (!existing) {
       throw new LockNotFoundError(configName, identity);
     }
     if (existing.lockedBy !== identity) {
       throw new LockOwnershipError(configName, identity, existing.lockedBy);
     }
-    await db.deleteFrom(NOORM_TABLES.lock).where("config_name", "=", configName).where("locked_by", "=", identity).execute();
+    await ndb.deleteFrom(tables.lock).where("config_name", "=", configName).where("locked_by", "=", identity).execute();
     observer.emit("lock:released", { configName, identity });
   }
   /**
@@ -4139,14 +4382,17 @@ var LockManager = class {
    *
    * @param db - Kysely database instance
    * @param configName - Config/database scope
+   * @param dialect - Database dialect for schema-aware table resolution
    * @returns true if a lock was released, false if none existed
    */
-  async forceRelease(db, configName) {
-    const existing = await this.getLock(db, configName);
+  async forceRelease(db, configName, dialect) {
+    const ndb = noormDb(db, dialect);
+    const tables = getNoormTables(dialect);
+    const existing = await this.getLock(db, configName, dialect);
     if (!existing) {
       return false;
     }
-    await db.deleteFrom(NOORM_TABLES.lock).where("config_name", "=", configName).execute();
+    await ndb.deleteFrom(tables.lock).where("config_name", "=", configName).execute();
     observer.emit("lock:released", {
       configName,
       identity: existing.lockedBy
@@ -4167,11 +4413,12 @@ var LockManager = class {
    * @returns Result of the operation
    */
   async withLock(db, configName, identity, operation, options = {}) {
+    const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
     await this.acquire(db, configName, identity, options);
     try {
       return await operation();
     } finally {
-      const [, err] = await attempt(() => this.release(db, configName, identity));
+      const [, err] = await attempt(() => this.release(db, configName, identity, opts.dialect));
       if (err) {
         observer.emit("error", {
           source: "lock",
@@ -4189,12 +4436,13 @@ var LockManager = class {
    * @param db - Kysely database instance
    * @param configName - Config/database scope
    * @param identity - Expected lock holder
+   * @param dialect - Database dialect for schema-aware table resolution
    * @throws LockExpiredError if lock has expired
    * @throws LockOwnershipError if lock is held by someone else
    * @throws LockNotFoundError if no lock exists
    */
   async validate(db, configName, identity, dialect = "postgres") {
-    const existing = await this.getLock(db, configName);
+    const existing = await this.getLock(db, configName, dialect);
     if (!existing) {
       throw new LockNotFoundError(configName, identity);
     }
@@ -4216,7 +4464,8 @@ var LockManager = class {
    * @returns Updated lock state
    */
   async extend(db, configName, identity, options = {}) {
-    await this.validate(db, configName, identity);
+    const opts = { ...DEFAULT_LOCK_OPTIONS, ...options };
+    await this.validate(db, configName, identity, opts.dialect);
     return this.extendLock(db, configName, identity, options);
   }
   /**
@@ -4229,7 +4478,7 @@ var LockManager = class {
    */
   async status(db, configName, dialect = "postgres") {
     await this.cleanupExpired(db, configName, dialect);
-    const lock = await this.getLock(db, configName);
+    const lock = await this.getLock(db, configName, dialect);
     return {
       isLocked: lock !== null,
       lock
@@ -4241,8 +4490,10 @@ var LockManager = class {
   /**
    * Get lock from database, or null if none exists.
    */
-  async getLock(db, configName) {
-    const row = await db.selectFrom(NOORM_TABLES.lock).selectAll().where("config_name", "=", configName).executeTakeFirst();
+  async getLock(db, configName, dialect) {
+    const ndb = noormDb(db, dialect);
+    const tables = getNoormTables(dialect);
+    const row = await ndb.selectFrom(tables.lock).selectAll().where("config_name", "=", configName).executeTakeFirst();
     if (!row) {
       return null;
     }
@@ -4257,9 +4508,11 @@ var LockManager = class {
    * Create a new lock in the database.
    */
   async createLock(db, configName, identity, opts) {
+    const ndb = noormDb(db, opts.dialect);
+    const tables = getNoormTables(opts.dialect);
     const now = /* @__PURE__ */ new Date();
     const expiresAt = new Date(now.getTime() + opts.timeout);
-    await db.insertInto(NOORM_TABLES.lock).values({
+    await ndb.insertInto(tables.lock).values({
       config_name: configName,
       locked_by: identity,
       locked_at: formatDateForDialect(now, opts.dialect),
@@ -4279,6 +4532,8 @@ var LockManager = class {
   async extendLock(db, configName, identity, opts) {
     const dialect = opts.dialect ?? DEFAULT_LOCK_OPTIONS.dialect;
     const timeout = opts.timeout ?? DEFAULT_LOCK_OPTIONS.timeout;
+    const ndb = noormDb(db, dialect);
+    const tables = getNoormTables(dialect);
     const now = /* @__PURE__ */ new Date();
     const expiresAt = new Date(now.getTime() + timeout);
     const updateValues = {
@@ -4287,19 +4542,21 @@ var LockManager = class {
     if (opts.reason !== void 0) {
       updateValues["reason"] = opts.reason;
     }
-    await db.updateTable(NOORM_TABLES.lock).set(updateValues).where("config_name", "=", configName).where("locked_by", "=", identity).execute();
-    const lock = await this.getLock(db, configName);
+    await ndb.updateTable(tables.lock).set(updateValues).where("config_name", "=", configName).where("locked_by", "=", identity).execute();
+    const lock = await this.getLock(db, configName, dialect);
     return lock;
   }
   /**
    * Clean up expired locks.
    */
   async cleanupExpired(db, configName, dialect = "postgres") {
+    const ndb = noormDb(db, dialect);
+    const tables = getNoormTables(dialect);
     const now = /* @__PURE__ */ new Date();
     const nowForDb = formatDateForDialect(now, dialect);
-    const expired = await db.selectFrom(NOORM_TABLES.lock).select(["locked_by"]).where("config_name", "=", configName).where("expires_at", "<", nowForDb).executeTakeFirst();
+    const expired = await ndb.selectFrom(tables.lock).select(["locked_by"]).where("config_name", "=", configName).where("expires_at", "<", nowForDb).executeTakeFirst();
     if (expired) {
-      await db.deleteFrom(NOORM_TABLES.lock).where("config_name", "=", configName).where("expires_at", "<", nowForDb).execute();
+      await ndb.deleteFrom(tables.lock).where("config_name", "=", configName).where("expires_at", "<", nowForDb).execute();
       observer.emit("lock:expired", {
         configName,
         previousHolder: expired.locked_by
@@ -4315,7 +4572,7 @@ function getLockManager() {
   return instance3;
 }
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 
 // src/core/change/executor.ts
@@ -4358,7 +4615,7 @@ async function executeChange(context, change, options = {}) {
     return createFailedResult(change.name, "change", checksumErr.message, start);
   }
   const changeChecksum = computeCombinedChecksum(checksums);
-  const history = new ChangeHistory(context.db, context.configName);
+  const history = new ChangeHistory(context.db, context.configName, context.dialect ?? "postgres");
   if (!opts.dryRun && !opts.preview) {
     const needsRunResult = await history.needsRun(
       change.name,
@@ -4407,7 +4664,7 @@ async function executeChange(context, change, options = {}) {
       start
     )
   );
-  await attempt(() => lockManager.release(context.db, context.configName, identity));
+  await attempt(() => lockManager.release(context.db, context.configName, identity, context.dialect ?? "postgres"));
   if (execErr) {
     throw execErr;
   }
@@ -4430,8 +4687,8 @@ async function revertChange(context, change, options = {}) {
     return createFailedResult(change.name, "revert", checksumErr.message, start);
   }
   const revertChecksum = computeCombinedChecksum(checksums);
-  const history = new ChangeHistory(context.db, context.configName);
-  const tracker = new ChangeTracker(context.db, context.configName);
+  const history = new ChangeHistory(context.db, context.configName, context.dialect ?? "postgres");
+  const tracker = new ChangeTracker(context.db, context.configName, context.dialect ?? "postgres");
   if (!opts.dryRun && !opts.preview) {
     const canRevertResult = await tracker.canRevert(change.name, opts.force);
     if (!canRevertResult.canRevert) {
@@ -4479,7 +4736,7 @@ async function revertChange(context, change, options = {}) {
       start
     )
   );
-  await attempt(() => lockManager.release(context.db, context.configName, identity));
+  await attempt(() => lockManager.release(context.db, context.configName, identity, context.dialect ?? "postgres"));
   if (execErr) {
     throw execErr;
   }
@@ -4893,7 +5150,7 @@ var ChangeManager = class {
   #history;
   constructor(context) {
     this.#context = context;
-    this.#history = new ChangeHistory(context.db, context.configName);
+    this.#history = new ChangeHistory(context.db, context.configName, context.dialect ?? "postgres");
   }
   // ─────────────────────────────────────────────────────────
   // List
@@ -5513,7 +5770,7 @@ async function runFile(context, filepath, options = {}) {
     filepath,
     configName: context.configName
   });
-  const tracker = new Tracker(context.db, context.configName);
+  const tracker = new Tracker(context.db, context.configName, context.dialect ?? "postgres");
   const operationName = `run:${(/* @__PURE__ */ new Date()).toISOString()}`;
   const [operationId, createErr] = await attempt(
     () => tracker.createOperation({
@@ -5645,7 +5902,7 @@ async function executeFiles2(context, files, runOptions, execOptions) {
       durationMs: durationMs2
     };
   }
-  const tracker = execOptions.tracker ?? new Tracker(context.db, context.configName);
+  const tracker = execOptions.tracker ?? new Tracker(context.db, context.configName, context.dialect ?? "postgres");
   const [operationId, createErr] = await attempt(
     () => tracker.createOperation({
       name: execOptions.operationName,
@@ -6231,13 +6488,14 @@ var RunNamespace = class {
       configName: this.#state.config.name,
       identity: this.#state.identity,
       projectRoot: this.#state.projectRoot,
+      dialect: this.#state.config.connection.dialect,
       config: this.#state.config,
       secrets: state.getAllSecrets(this.#state.config.name),
       globalSecrets: state.getAllGlobalSecrets()
     };
   }
 };
-var EXCLUDED_SCHEMAS = ["pg_catalog", "information_schema", "pg_toast"];
+var EXCLUDED_SCHEMAS = ["pg_catalog", "information_schema", "pg_toast", "noorm"];
 var postgresExploreOperations = {
   async getOverview(db) {
     const [tables, views, procedures, functions, types, indexes, foreignKeys] = await Promise.all([
@@ -7435,7 +7693,7 @@ var mysqlExploreOperations = {
     };
   }
 };
-var EXCLUDED_SCHEMAS2 = ["sys", "INFORMATION_SCHEMA", "guest"];
+var EXCLUDED_SCHEMAS2 = ["sys", "INFORMATION_SCHEMA", "guest", "noorm"];
 var mssqlExploreOperations = {
   async getOverview(db) {
     const [tables, views, procedures, functions, types, indexes, foreignKeys] = await Promise.all([
@@ -8649,10 +8907,10 @@ function getTeardownOperations(dialect) {
 }
 
 // src/core/teardown/operations.ts
-var NOORM_TABLE_NAMES = new Set(Object.values(NOORM_TABLES));
 function isNoormTable2(name) {
   if (!name) return false;
-  return name.startsWith("__noorm_") || NOORM_TABLE_NAMES.has(name);
+  if (name.startsWith("__noorm_")) return true;
+  return false;
 }
 async function truncateData(db, dialect, options = {}) {
   const startTime = performance.now();
@@ -8825,11 +9083,13 @@ async function teardownSchema(db, dialect, options = {}) {
   if (options.configName && options.executedBy && !options.dryRun) {
     const tracker = new ChangeTracker(
       db,
-      options.configName
+      options.configName,
+      dialect
     );
     const history = new ChangeHistory(
       db,
-      options.configName
+      options.configName,
+      dialect
     );
     result.staleCount = await tracker.markAllAsStale();
     const parts = [
@@ -9058,7 +9318,8 @@ var LockNamespace = class {
     await lockManager.release(
       this.#kysely,
       this.#state.config.name,
-      identityStr
+      identityStr,
+      this.#state.config.connection.dialect
     );
   }
   /**
@@ -9110,7 +9371,8 @@ var LockNamespace = class {
     const lockManager = getLockManager();
     return lockManager.forceRelease(
       this.#kysely,
-      this.#state.config.name
+      this.#state.config.name,
+      this.#state.config.connection.dialect
     );
   }
   // ─────────────────────────────────────────────────────
@@ -9123,9 +9385,11 @@ var LockNamespace = class {
     return this.#state.connection.db;
   }
 };
-async function getUsersWithoutVaultAccess(db) {
+async function getUsersWithoutVaultAccess(db, dialect) {
+  const ndb = noormDb(db, dialect);
+  const tables = getNoormTables(dialect);
   const [rows, err] = await attempt(async () => {
-    return db.selectFrom(NOORM_TABLES.identities).select([
+    return ndb.selectFrom(tables.identities).select([
       "identity_hash",
       "public_key",
       "name",
@@ -9140,11 +9404,13 @@ async function getUsersWithoutVaultAccess(db) {
     email: r.email
   }));
 }
-async function propagateVaultKey(db, vaultKey) {
-  const users = await getUsersWithoutVaultAccess(db);
+async function propagateVaultKey(db, vaultKey, dialect) {
+  const ndb = noormDb(db, dialect);
+  const tables = getNoormTables(dialect);
+  const users = await getUsersWithoutVaultAccess(db, dialect);
   if (users.length === 0) {
     const [countResult2] = await attempt(async () => {
-      return db.selectFrom(NOORM_TABLES.identities).select(db.fn.count("id").as("count")).where("encrypted_vault_key", "is not", null).executeTakeFirst();
+      return ndb.selectFrom(tables.identities).select(ndb.fn.count("id").as("count")).where("encrypted_vault_key", "is not", null).executeTakeFirst();
     });
     return {
       propagatedTo: [],
@@ -9156,7 +9422,7 @@ async function propagateVaultKey(db, vaultKey) {
     const encrypted = encryptVaultKey(vaultKey, user.publicKey);
     const encryptedJson = JSON.stringify(encrypted);
     const [, err] = await attempt(async () => {
-      return db.updateTable(NOORM_TABLES.identities).set({ encrypted_vault_key: encryptedJson }).where("identity_hash", "=", user.identityHash).execute();
+      return ndb.updateTable(tables.identities).set({ encrypted_vault_key: encryptedJson }).where("identity_hash", "=", user.identityHash).execute();
     });
     if (!err) {
       propagatedTo.push(user.identityHash);
@@ -9167,7 +9433,7 @@ async function propagateVaultKey(db, vaultKey) {
     }
   }
   const [countResult] = await attempt(async () => {
-    return db.selectFrom(NOORM_TABLES.identities).select(db.fn.count("id").as("count")).where("encrypted_vault_key", "is not", null).executeTakeFirst();
+    return ndb.selectFrom(tables.identities).select(ndb.fn.count("id").as("count")).where("encrypted_vault_key", "is not", null).executeTakeFirst();
   });
   const totalWithAccess = countResult ? Number(countResult.count) : 0;
   const alreadyHadAccess = totalWithAccess - propagatedTo.length;
@@ -9247,18 +9513,20 @@ async function copyVaultSecrets(sourceConfig, destConfig, keys, identityHash, pr
       const sourceVaultKey = await getVaultKey(
         ctx.source.db,
         identityHash,
-        privateKey
+        privateKey,
+        ctx.source.dialect
       );
       if (!sourceVaultKey) {
         throw new Error(`No vault access on source config "${sourceConfig.name}"`);
       }
-      const destStatus = await getVaultStatus(ctx.destination.db, identityHash);
-      let destVaultKey = null;
+      const destStatus = await getVaultStatus(ctx.destination.db, identityHash, ctx.destination.dialect);
+      let destVaultKey;
       if (!destStatus.isInitialized) {
         const [newKey, initErr] = await initializeVault(
           ctx.destination.db,
           identityHash,
-          publicKey
+          publicKey,
+          ctx.destination.dialect
         );
         if (initErr) {
           throw new Error(`Failed to initialize vault on destination: ${initErr.message}`);
@@ -9270,13 +9538,14 @@ async function copyVaultSecrets(sourceConfig, destConfig, keys, identityHash, pr
         destVaultKey = await getVaultKey(
           ctx.destination.db,
           identityHash,
-          privateKey
+          privateKey,
+          ctx.destination.dialect
         );
       }
       if (!destVaultKey) {
         throw new Error("Failed to get vault key for destination");
       }
-      const allSourceSecrets = await getAllVaultSecrets(ctx.source.db, sourceVaultKey);
+      const allSourceSecrets = await getAllVaultSecrets(ctx.source.db, sourceVaultKey, ctx.source.dialect);
       const secretsToCopy = keys === "all" ? Object.entries(allSourceSecrets) : Object.entries(allSourceSecrets).filter(([key]) => keys.includes(key));
       const result = {
         copied: [],
@@ -9294,7 +9563,7 @@ async function copyVaultSecrets(sourceConfig, destConfig, keys, identityHash, pr
         }
       }
       for (const [key, secret] of secretsToCopy) {
-        const exists = await vaultSecretExists(ctx.destination.db, key);
+        const exists = await vaultSecretExists(ctx.destination.db, key, ctx.destination.dialect);
         if (exists && !force) {
           result.skipped.push(key);
           continue;
@@ -9305,7 +9574,8 @@ async function copyVaultSecrets(sourceConfig, destConfig, keys, identityHash, pr
           destVaultKey,
           key,
           secret.value,
-          setBy
+          setBy,
+          ctx.destination.dialect
         );
         if (setErr) {
           result.errors.push({ key, error: setErr.message });
@@ -9346,7 +9616,8 @@ var VaultNamespace = class {
     return initializeVault(
       this.#kysely,
       this.#identityHash,
-      this.#publicKey
+      this.#publicKey,
+      this.#dialect
     );
   }
   /**
@@ -9360,7 +9631,8 @@ var VaultNamespace = class {
   async status() {
     return getVaultStatus(
       this.#kysely,
-      this.#identityHash
+      this.#identityHash,
+      this.#dialect
     );
   }
   // ─────────────────────────────────────────────────────
@@ -9382,7 +9654,8 @@ var VaultNamespace = class {
       vaultKey,
       key,
       value,
-      formatIdentity(this.#state.identity)
+      formatIdentity(this.#state.identity),
+      this.#dialect
     );
   }
   /**
@@ -9399,7 +9672,8 @@ var VaultNamespace = class {
     return getVaultSecret(
       this.#kysely,
       vaultKey,
-      key
+      key,
+      this.#dialect
     );
   }
   /**
@@ -9415,7 +9689,8 @@ var VaultNamespace = class {
     if (!vaultKey) return {};
     return getAllVaultSecrets(
       this.#kysely,
-      vaultKey
+      vaultKey,
+      this.#dialect
     );
   }
   /**
@@ -9428,7 +9703,8 @@ var VaultNamespace = class {
    */
   async list() {
     return listVaultSecretKeys(
-      this.#kysely
+      this.#kysely,
+      this.#dialect
     );
   }
   /**
@@ -9442,7 +9718,8 @@ var VaultNamespace = class {
   async delete(key) {
     return deleteVaultSecret(
       this.#kysely,
-      key
+      key,
+      this.#dialect
     );
   }
   /**
@@ -9456,7 +9733,8 @@ var VaultNamespace = class {
   async exists(key) {
     return vaultSecretExists(
       this.#kysely,
-      key
+      key,
+      this.#dialect
     );
   }
   // ─────────────────────────────────────────────────────
@@ -9477,7 +9755,8 @@ var VaultNamespace = class {
     }
     return propagateVaultKey(
       this.#kysely,
-      vaultKey
+      vaultKey,
+      this.#dialect
     );
   }
   /**
@@ -9516,11 +9795,15 @@ var VaultNamespace = class {
     const identity = this.#state.identity;
     return identity["publicKey"] ?? "";
   }
+  get #dialect() {
+    return this.#state.config.connection.dialect;
+  }
   async #getVaultKey(privateKey) {
     return getVaultKey(
       this.#kysely,
       this.#identityHash,
-      privateKey
+      privateKey,
+      this.#dialect
     );
   }
 };
@@ -10424,16 +10707,16 @@ async function planTransfer(ctx, options = {}) {
   const orderedNames = sortErr ? allTables.map((t) => t.name) : sortedNames;
   const tablePlans = [];
   for (const name of orderedNames) {
-    const meta = tablesByName[name];
-    if (!meta) continue;
+    const meta2 = tablesByName[name];
+    if (!meta2) continue;
     tablePlans.push({
-      name: meta.name,
-      schema: meta.schema,
-      rowCount: meta.rowCount,
-      hasIdentity: meta.hasIdentity,
-      identityColumn: meta.identityColumn,
-      primaryKey: meta.primaryKey,
-      columns: meta.columns,
+      name: meta2.name,
+      schema: meta2.schema,
+      rowCount: meta2.rowCount,
+      hasIdentity: meta2.hasIdentity,
+      identityColumn: meta2.identityColumn,
+      primaryKey: meta2.primaryKey,
+      columns: meta2.columns,
       dependsOn: dependencyMap.get(name) ?? []
     });
   }
@@ -10977,8 +11260,8 @@ async function executeTransfer(ctx, plan, options = {}) {
     const strategy = options.onConflict ?? "fail";
     const useSameServer = plan.sameServer && strategy === "fail" && !plan.crossDialect;
     const useCrossDialect = plan.crossDialect && tablePlan.columnTypes;
-    let tableResult = null;
-    let tableErr = null;
+    let tableResult;
+    let tableErr;
     if (useSameServer) {
       [tableResult, tableErr] = await transferTableSameServer(
         ctx,
@@ -11607,6 +11890,174 @@ var TransferNamespace = class {
     return getTransferPlan(this.#state.config, destConfig, options);
   }
 };
+
+// src/core/worker-bridge/pool.ts
+var WorkerPool = class {
+  #workers;
+  #nextIndex = 0;
+  #isShutdown = false;
+  constructor(script, options) {
+    const size = Math.max(1, options.size);
+    this.#workers = Array.from(
+      { length: size },
+      () => new WorkerBridge(script)
+    );
+  }
+  /**
+   * Returns the number of workers in the pool.
+   */
+  get size() {
+    return this.#workers.length;
+  }
+  /**
+   * Returns true if the pool has been shut down.
+   */
+  get isShutdown() {
+    return this.#isShutdown;
+  }
+  /**
+   * Sends a request to the next available worker (round-robin) and awaits its response.
+   *
+   * Injects a correlation ID so concurrent requests on the same event type
+   * can be matched to their originating worker.
+   *
+   * @example
+   * const { values } = await pool.request('serialize', { row, columns, index: 0 })
+   */
+  async request(event, data2, options) {
+    const worker = this.#workers[this.#nextIndex];
+    this.#nextIndex = (this.#nextIndex + 1) % this.#workers.length;
+    return worker.request(event, data2, options);
+  }
+  /**
+   * Registers a listener on all workers for the given event.
+   *
+   * Useful for broadcast-style events that every worker may emit.
+   *
+   * @example
+   * pool.on('serialize:res', ({ data }) => console.log(data.values))
+   */
+  on(event, callback, options) {
+    for (const worker of this.#workers) {
+      worker.on(event, callback, options);
+    }
+  }
+  /**
+   * Terminates all workers in the pool.
+   *
+   * Marks the pool as shut down and waits for every worker thread to exit
+   * before resolving.
+   *
+   * @example
+   * await pool.shutdown()
+   */
+  async shutdown() {
+    this.#isShutdown = true;
+    await Promise.all(this.#workers.map((w) => w.shutdown()));
+  }
+};
+
+// src/core/worker-bridge/types.ts
+function isTransferable(data2) {
+  return !!data2 && typeof data2 === "object" && "__transfer" in data2;
+}
+
+// src/core/worker-bridge/bridge.ts
+var WorkerBridge = class extends ObserverRelay {
+  #port;
+  #ownsWorker;
+  constructor(script, data2) {
+    const isParent = !!script;
+    super({ name: isParent ? "bridge:parent" : "bridge:worker" });
+    if (script) {
+      this.#port = new Worker(script, { workerData: data2 });
+      this.#ownsWorker = true;
+      this.#port.on("exit", (code) => {
+        if (!this.isShutdown && code !== 0) {
+          this.receive("worker:exit", { code, error: `Worker exited with code ${code}` }, {});
+        }
+      });
+    } else {
+      if (!parentPort) {
+        throw new Error(
+          "WorkerBridge: no script provided and not in a worker thread"
+        );
+      }
+      this.#port = parentPort;
+      this.#ownsWorker = false;
+    }
+    this.#port.on("message", (msg) => {
+      this.receive(msg.event, msg.data, {});
+    });
+  }
+  send(event, data2) {
+    if (isTransferable(data2)) {
+      this.#port.postMessage({ event, data: data2 }, data2.__transfer);
+    } else {
+      this.#port.postMessage({ event, data: data2 }, []);
+    }
+  }
+  async request(event, data2, options) {
+    const cid = randomUUID();
+    const pending = this.once(new RegExp(`^${event}:res:${cid}$`), options);
+    this.send(event, { ...data2, __cid: cid });
+    const { data: { data: result } } = await pending;
+    return result;
+  }
+  transfer(event, data2, transferables) {
+    this.#port.postMessage({ event, data: data2 }, transferables);
+  }
+  static pool(script, options) {
+    return new WorkerPool(script, options);
+  }
+  static get workerData() {
+    return workerData;
+  }
+  async shutdown() {
+    super.shutdown();
+    if (this.#ownsWorker && "terminate" in this.#port) {
+      await this.#port.terminate();
+    }
+  }
+};
+
+// src/core/worker-bridge/order-buffer.ts
+var OrderBuffer = class {
+  #buffer = /* @__PURE__ */ new Map();
+  #nextIndex = 0;
+  #flush;
+  constructor(flush) {
+    this.#flush = flush;
+  }
+  get nextIndex() {
+    return this.#nextIndex;
+  }
+  get pending() {
+    return this.#buffer.size;
+  }
+  add(index, item) {
+    this.#buffer.set(index, item);
+    this.#drain();
+  }
+  #drain() {
+    while (this.#buffer.has(this.#nextIndex)) {
+      const item = this.#buffer.get(this.#nextIndex);
+      this.#buffer.delete(this.#nextIndex);
+      this.#nextIndex++;
+      this.#flush(item);
+    }
+  }
+};
+var IS_COMPILED = import.meta.url.includes("$bunfs");
+var meta = import.meta;
+var MODULE_DIR = typeof meta.dir === "string" ? meta.dir : dirname(fileURLToPath(import.meta.url));
+var WORKER_DIR = resolve(MODULE_DIR, "../../workers");
+function resolveWorker(name) {
+  if (IS_COMPILED) {
+    return new URL(`./workers/${name}.js`, import.meta.url);
+  }
+  return resolve(WORKER_DIR, `${name}.js`);
+}
 var DtWriter = class {
   #filepath;
   #schema;
@@ -11710,8 +12161,8 @@ var DtWriter = class {
       this.#passthrough.end();
       await this.#pipelinePromise;
     } else if (this.#stream) {
-      await new Promise((resolve, reject) => {
-        this.#stream.end(() => resolve());
+      await new Promise((resolve2, reject) => {
+        this.#stream.end(() => resolve2());
         this.#stream.on("error", reject);
       });
     }
@@ -11728,211 +12179,26 @@ var DtWriter = class {
     this.#stream.write(buf);
   }
 };
-function serializeRow(options) {
-  const { row, columns } = options;
-  const result = [];
-  for (const col of columns) {
-    const value = row[col.name];
-    result.push(serializeValue(value, col));
-  }
-  return result;
-}
-function serializeValue(value, column) {
-  if (value === null || value === void 0) {
-    return null;
-  }
-  if (isEncodedType(column.type)) {
-    return encodeValue(value, column.type);
-  }
-  return serializeSimple(value, column.type);
-}
-function serializeSimple(value, type) {
-  switch (type) {
-    case "bigint":
-      return String(value);
-    case "decimal":
-      return String(value);
-    case "bool":
-      if (typeof value === "number") return value !== 0;
-      if (typeof value === "string") return value === "1" || value.toLowerCase() === "true";
-      return Boolean(value);
-    case "timestamp": {
-      if (value instanceof Date) return value.toISOString();
-      return String(value);
-    }
-    case "date": {
-      if (value instanceof Date) return value.toISOString().split("T")[0];
-      return String(value);
-    }
-    case "uuid":
-      return String(value);
-    case "int":
-    case "float":
-      return typeof value === "string" ? Number(value) : value;
-    case "string":
-    default:
-      return String(value);
-  }
-}
-function encodeValue(value, type) {
-  if (type === "binary") {
-    return encodeBinary(value);
-  }
-  return encodeJsonLike(value);
-}
-function encodeBinary(value) {
-  const buf = toBuffer(value);
-  const byteLength = buf.length;
-  if (byteLength < GZIP_THRESHOLD) {
-    return [buf.toString("base64"), "b64"];
-  }
-  const compressed = gzipSync(buf);
-  if (compressed.length < byteLength * GZIP_RATIO_THRESHOLD) {
-    return [compressed.toString("base64"), "gz64"];
-  }
-  return [buf.toString("base64"), "b64"];
-}
-function encodeJsonLike(value) {
-  const jsonStr = JSON.stringify(value);
-  const byteLength = Buffer.byteLength(jsonStr, "utf8");
-  if (byteLength < GZIP_THRESHOLD) {
-    return [value, "raw"];
-  }
-  const buf = Buffer.from(jsonStr, "utf8");
-  const compressed = gzipSync(buf);
-  if (compressed.length < byteLength * GZIP_RATIO_THRESHOLD) {
-    return [compressed.toString("base64"), "gz64"];
-  }
-  return [value, "raw"];
-}
-function toBuffer(value) {
-  if (Buffer.isBuffer(value)) return value;
-  if (value instanceof Uint8Array) return Buffer.from(value);
-  if (typeof value === "string") return Buffer.from(value, "base64");
-  return Buffer.from(String(value), "utf8");
-}
-function deserializeRow(options) {
-  const { values, columns, targetDialect, targetVersion } = options;
-  const result = {};
-  for (let i = 0; i < columns.length; i++) {
-    const col = columns[i];
-    const value = values[i];
-    result[col.name] = deserializeValue(value, col, targetDialect, targetVersion);
-  }
-  return result;
-}
-function deserializeValue(value, column, targetDialect, targetVersion) {
-  if (value === null || value === void 0) {
-    return null;
-  }
-  if (isEncodedType(column.type)) {
-    const decoded = decodeTuple(value);
-    return convertEncodedForTarget(decoded, column.type, targetDialect, targetVersion);
-  }
-  return convertSimpleForTarget(value, column.type, targetDialect);
-}
-function decodeTuple(tuple) {
-  if (!Array.isArray(tuple) || tuple.length < 2) {
-    return tuple;
-  }
-  const [value, encoding] = tuple;
-  switch (encoding) {
-    case "raw":
-      return value;
-    case "b64":
-      return Buffer.from(value, "base64");
-    case "gz64": {
-      const compressed = Buffer.from(value, "base64");
-      const decompressed = gunzipSync(compressed);
-      const str = decompressed.toString("utf8");
-      if (/^[[{"\d]/.test(str)) {
-        return JSON.parse(str);
-      }
-      return decompressed;
-    }
-    default:
-      return value;
-  }
-}
-function convertEncodedForTarget(decoded, type, targetDialect, targetVersion) {
-  switch (type) {
-    case "json":
-      return convertJsonForTarget(decoded, targetDialect, targetVersion);
-    case "text":
-      return decoded;
-    case "binary":
-      return decoded;
-    case "vector":
-      return convertVectorForTarget(decoded, targetDialect, targetVersion);
-    case "array":
-      return convertArrayForTarget(decoded, targetDialect);
-    case "custom":
-      if (typeof decoded === "object") return JSON.stringify(decoded);
-      return decoded;
-    default:
-      return decoded;
-  }
-}
-function convertJsonForTarget(decoded, targetDialect, targetVersion) {
-  if (targetDialect === "mssql") {
-    const major = targetVersion?.major ?? 2022;
-    if (major < 2025) {
-      return typeof decoded === "string" ? decoded : JSON.stringify(decoded);
-    }
-  }
-  return decoded;
-}
-function convertVectorForTarget(decoded, targetDialect, targetVersion) {
-  const arr = Array.isArray(decoded) ? decoded : decoded;
-  if (targetDialect === "postgres") {
-    return Array.isArray(arr) ? `[${arr.join(",")}]` : String(arr);
-  }
-  if (targetDialect === "mysql") {
-    const major = targetVersion?.major ?? 8;
-    if (major >= 9) {
-      return Array.isArray(arr) ? `[${arr.join(",")}]` : String(arr);
-    }
-    return Array.isArray(arr) ? JSON.stringify(arr) : String(arr);
-  }
-  return Array.isArray(arr) ? JSON.stringify(arr) : String(arr);
-}
-function convertArrayForTarget(decoded, targetDialect) {
-  if (targetDialect === "postgres") {
-    return decoded;
-  }
-  return Array.isArray(decoded) ? JSON.stringify(decoded) : String(decoded);
+
+// src/core/dt/index.ts
+var CONNECTION_WORKER = resolveWorker("connection");
+var COMPUTE_WORKER = resolveWorker("compute");
+function createDefaultComputePool() {
+  return WorkerBridge.pool(COMPUTE_WORKER, {
+    size: Math.max(1, availableParallelism() - 2)
+  });
 }
-function convertSimpleForTarget(value, type, targetDialect) {
-  switch (type) {
-    case "bigint":
-      if (typeof value === "string") {
-        const num = Number(value);
-        if (Number.isSafeInteger(num)) return num;
-      }
-      return value;
-    case "decimal":
-      return value;
-    case "bool":
-      if (targetDialect === "mssql") return value ? 1 : 0;
-      if (targetDialect === "mysql") return value ? 1 : 0;
-      return value;
-    case "timestamp":
-      if (typeof value === "string") return new Date(value);
-      return value;
-    case "date":
-      return value;
-    case "uuid":
-      return value;
-    case "int":
-    case "float":
-      return value;
-    case "string":
-    default:
-      return value;
+async function createDefaultConnectionBridge(dialect, connectionString) {
+  const bridge = new WorkerBridge(CONNECTION_WORKER);
+  const [, connectErr] = await attempt(
+    () => bridge.request("connect", { dialect, connectionString })
+  );
+  if (connectErr) {
+    await attempt(() => bridge.shutdown());
+    return [null, connectErr];
   }
+  return [bridge, null];
 }
-
-// src/core/dt/index.ts
 async function exportTable(options) {
   const startTime = Date.now();
   const { db, dialect, tableName, filepath, passphrase, schema: schemaName } = options;
@@ -11958,58 +12224,178 @@ async function exportTable(options) {
   if (openErr) {
     return [null, openErr];
   }
-  let offset = 0;
+  let ownedConnectionBridge = null;
+  let ownedComputePool = null;
+  let connectionBridge = options.connectionBridge;
+  let computePool = options.computePool;
+  if (!connectionBridge && options.connectionString) {
+    const [bridge, bridgeErr] = await createDefaultConnectionBridge(dialect, options.connectionString);
+    if (bridgeErr) {
+      return [null, bridgeErr];
+    }
+    connectionBridge = bridge;
+    ownedConnectionBridge = bridge;
+  }
+  if (!computePool) {
+    computePool = createDefaultComputePool();
+    ownedComputePool = computePool;
+  }
+  const [result, workerErr] = await exportTableWithWorkers({
+    writer,
+    dtSchema,
+    tableName,
+    filepath,
+    dialect,
+    batchSize,
+    connectionBridge,
+    computePool,
+    kyselyDb
+  });
+  if (ownedComputePool) {
+    await attempt(() => ownedComputePool.shutdown());
+  }
+  if (ownedConnectionBridge) {
+    await attempt(() => ownedConnectionBridge.shutdown());
+  }
+  if (workerErr) {
+    return [null, workerErr];
+  }
+  const durationMs = Date.now() - startTime;
+  observer.emit("dt:export:complete", {
+    filepath,
+    table: tableName,
+    rowsWritten: result.rowsWritten,
+    bytesWritten: result.bytesWritten,
+    durationMs
+  });
+  return [result, null];
+}
+function getQuoteIdent(dialect) {
+  if (dialect === "mssql") return (c) => `[${c}]`;
+  if (dialect === "mysql") return (c) => `\`${c}\``;
+  return (c) => `"${c}"`;
+}
+function buildBatchSql(dialect, tableName, columnList, orderCol, batchSize, offset) {
+  if (dialect === "mssql") {
+    return `SELECT ${columnList} FROM [${tableName}] ORDER BY ${orderCol} OFFSET ${offset} ROWS FETCH NEXT ${batchSize} ROWS ONLY`;
+  }
+  return `SELECT ${columnList} FROM "${tableName}" LIMIT ${batchSize} OFFSET ${offset}`;
+}
+async function exportTableWithWorkers(ctx) {
+  const { writer, dtSchema, tableName, filepath, dialect, batchSize } = ctx;
+  const { connectionBridge, computePool, kyselyDb } = ctx;
+  const backpressureLimit = batchSize * 3;
+  let totalRows = 0;
+  if (connectionBridge) {
+    const countSql = dialect === "mssql" ? `SELECT COUNT(*) AS cnt FROM [${tableName}]` : `SELECT COUNT(*) AS cnt FROM "${tableName}"`;
+    const [countResult, countErr] = await attempt(
+      () => connectionBridge.request("query", { sql: countSql })
+    );
+    if (countErr) {
+      return [null, countErr];
+    }
+    const firstRow = countResult.rows[0];
+    totalRows = Number(firstRow?.["cnt"] ?? 0);
+  }
   const columns = dtSchema.columns.map((c) => c.name);
-  const quoteIdent4 = dialect === "mssql" ? (c) => `[${c}]` : dialect === "mysql" ? (c) => `\`${c}\`` : (c) => `"${c}"`;
+  const quoteIdent4 = getQuoteIdent(dialect);
   const columnList = columns.map(quoteIdent4).join(", ");
+  const orderCol = quoteIdent4(columns[0]);
+  let globalIndex = 0;
+  let loaded = 0;
+  let processed = 0;
+  let saved = 0;
+  let inFlight = 0;
+  let pipelineError = null;
+  const orderBuffer = new OrderBuffer((values) => {
+    writer.writeRow(values);
+    saved++;
+    inFlight--;
+    observer.emit("dt:export:saved", { table: tableName, saved, totalRows });
+  });
+  let offset = 0;
   while (true) {
-    const [rows, fetchErr] = await attempt(() => {
-      if (dialect === "mssql") {
-        const orderCol = quoteIdent4(columns[0]);
+    while (inFlight >= backpressureLimit) {
+      await new Promise((resolve2) => setTimeout(resolve2, 1));
+    }
+    let batchRows;
+    if (connectionBridge) {
+      const batchSql = buildBatchSql(dialect, tableName, columnList, orderCol, batchSize, offset);
+      const [queryResult, queryErr] = await attempt(
+        () => connectionBridge.request("query", { sql: batchSql })
+      );
+      if (queryErr) {
+        pipelineError = queryErr;
+        break;
+      }
+      if (queryResult.error) {
+        pipelineError = new Error(queryResult.error);
+        break;
+      }
+      batchRows = queryResult.rows;
+    } else {
+      const [rows, fetchErr] = await attempt(() => {
+        if (dialect === "mssql") {
+          return sql`
+                        SELECT ${sql.raw(columnList)}
+                        FROM ${sql.table(tableName)}
+                        ORDER BY ${sql.raw(orderCol)}
+                        OFFSET ${offset} ROWS
+                        FETCH NEXT ${batchSize} ROWS ONLY
+                    `.execute(kyselyDb);
+        }
         return sql`
                     SELECT ${sql.raw(columnList)}
                     FROM ${sql.table(tableName)}
-                    ORDER BY ${sql.raw(orderCol)}
-                    OFFSET ${offset} ROWS
-                    FETCH NEXT ${batchSize} ROWS ONLY
+                    LIMIT ${batchSize}
+                    OFFSET ${offset}
                 `.execute(kyselyDb);
+      });
+      if (fetchErr) {
+        pipelineError = fetchErr;
+        break;
       }
-      return sql`
-                SELECT ${sql.raw(columnList)}
-                FROM ${sql.table(tableName)}
-                LIMIT ${batchSize}
-                OFFSET ${offset}
-            `.execute(kyselyDb);
-    });
-    if (fetchErr) {
-      return [null, fetchErr];
-    }
-    if (rows.rows.length === 0) break;
-    for (const row of rows.rows) {
-      const values = serializeRow({ row, columns: dtSchema.columns });
-      writer.writeRow(values);
+      batchRows = rows.rows;
+    }
+    if (batchRows.length === 0) break;
+    loaded += batchRows.length;
+    observer.emit("dt:export:loaded", { table: tableName, loaded, totalRows });
+    for (const row of batchRows) {
+      const rowIndex = globalIndex++;
+      inFlight++;
+      computePool.request("serialize", {
+        row,
+        columns: dtSchema.columns,
+        index: rowIndex
+      }).then((result) => {
+        processed++;
+        observer.emit("dt:export:processed", { table: tableName, processed, totalRows });
+        if (result.error) {
+          pipelineError = pipelineError ?? new Error(result.error);
+          return;
+        }
+        orderBuffer.add(result.index, result.values);
+      });
     }
-    offset += rows.rows.length;
+    offset += batchRows.length;
     observer.emit("dt:export:progress", {
       filepath,
       table: tableName,
       rowsWritten: writer.rowsWritten,
       bytesWritten: writer.bytesWritten
     });
-    if (rows.rows.length < batchSize) break;
+    if (batchRows.length < batchSize) break;
+  }
+  while (inFlight > 0) {
+    await new Promise((resolve2) => setTimeout(resolve2, 1));
+  }
+  if (pipelineError) {
+    return [null, pipelineError];
   }
   const [, closeErr] = await attempt(() => writer.close());
   if (closeErr) {
     return [null, closeErr];
   }
-  const durationMs = Date.now() - startTime;
-  observer.emit("dt:export:complete", {
-    filepath,
-    table: tableName,
-    rowsWritten: writer.rowsWritten,
-    bytesWritten: writer.bytesWritten,
-    durationMs
-  });
   return [{ rowsWritten: writer.rowsWritten, bytesWritten: writer.bytesWritten }, null];
 }
 async function importDtFile(options) {
@@ -12069,70 +12455,158 @@ async function importDtFile(options) {
       return [null, err];
     }
   }
+  let ownedComputePool = null;
+  let computePool = options.computePool;
+  if (!computePool) {
+    computePool = createDefaultComputePool();
+    ownedComputePool = computePool;
+  }
+  const [result, workerErr] = await importFileWithWorkers({
+    reader,
+    dtSchema,
+    tableName,
+    filepath,
+    dialect,
+    version,
+    batchSize,
+    onConflict: options.onConflict ?? "fail",
+    computePool,
+    kyselyDb
+  });
+  if (ownedComputePool) {
+    await attempt(() => ownedComputePool.shutdown());
+  }
+  if (workerErr) {
+    reader.close();
+    observer.emit("error", { source: "dt:import", error: workerErr, context: { filepath, table: tableName } });
+    return [null, workerErr];
+  }
+  reader.close();
+  const durationMs = Date.now() - startTime;
+  observer.emit("dt:import:complete", {
+    filepath,
+    table: tableName,
+    rowsImported: result.rowsImported,
+    rowsSkipped: result.rowsSkipped,
+    durationMs
+  });
+  return [result, null];
+}
+async function importFileWithWorkers(ctx) {
+  const { reader, dtSchema, tableName, filepath, dialect, version, batchSize } = ctx;
+  const { onConflict, computePool, kyselyDb } = ctx;
   let rowsImported = 0;
   let rowsSkipped = 0;
-  let batch = [];
-  for await (const values of reader.rows()) {
-    const row = deserializeRow({
-      values,
-      columns: dtSchema.columns,
-      targetDialect: dialect,
-      targetVersion: version
-    });
-    batch.push(row);
-    if (batch.length >= batchSize) {
-      const columnNames = dtSchema.columns.map((c) => c.name);
-      const [batchResult, insertErr] = await insertImportBatch(
-        kyselyDb,
-        tableName,
-        batch,
-        options.onConflict ?? "fail",
-        dialect,
-        columnNames
-      );
-      if (insertErr) {
-        reader.close();
-        observer.emit("error", { source: "dt:import", error: insertErr, context: { filepath, table: tableName } });
-        return [null, insertErr];
-      }
-      rowsImported += batchResult.inserted + batchResult.updated;
-      rowsSkipped += batchResult.skipped;
-      batch = [];
-      observer.emit("dt:import:progress", {
-        filepath,
-        table: tableName,
-        rowsImported,
-        rowsSkipped
-      });
-    }
-  }
-  if (batch.length > 0) {
-    const columnNames = dtSchema.columns.map((c) => c.name);
+  let loaded = 0;
+  let processed = 0;
+  let saved = 0;
+  let globalIndex = 0;
+  let inFlight = 0;
+  let pipelineError = null;
+  let totalRows = 0;
+  let insertBatch2 = [];
+  const columnNames = dtSchema.columns.map((c) => c.name);
+  const flushInsertBatch = async () => {
+    if (insertBatch2.length === 0) return null;
     const [batchResult, insertErr] = await insertImportBatch(
       kyselyDb,
       tableName,
-      batch,
-      options.onConflict ?? "fail",
+      insertBatch2,
+      onConflict,
       dialect,
       columnNames
     );
     if (insertErr) {
-      reader.close();
-      observer.emit("error", { source: "dt:import", error: insertErr, context: { filepath, table: tableName } });
-      return [null, insertErr];
+      return insertErr;
     }
     rowsImported += batchResult.inserted + batchResult.updated;
     rowsSkipped += batchResult.skipped;
-  }
-  reader.close();
-  const durationMs = Date.now() - startTime;
-  observer.emit("dt:import:complete", {
-    filepath,
-    table: tableName,
-    rowsImported,
-    rowsSkipped,
-    durationMs
+    insertBatch2 = [];
+    observer.emit("dt:import:progress", {
+      filepath,
+      table: tableName,
+      rowsImported,
+      rowsSkipped
+    });
+    return null;
+  };
+  const orderBuffer = new OrderBuffer((record) => {
+    insertBatch2.push(record);
+    saved++;
+    inFlight--;
+    observer.emit("dt:import:saved", { table: tableName, saved, totalRows });
   });
+  let readBatch = [];
+  for await (const values of reader.rows()) {
+    readBatch.push(values);
+    loaded++;
+    totalRows = Math.max(totalRows, loaded);
+    if (readBatch.length >= batchSize) {
+      observer.emit("dt:import:loaded", { table: tableName, loaded, totalRows });
+      for (const rowValues of readBatch) {
+        const rowIndex = globalIndex++;
+        inFlight++;
+        computePool.request("deserialize", {
+          values: rowValues,
+          columns: dtSchema.columns,
+          targetDialect: dialect,
+          targetVersion: version ? `${version.major}.${version.minor}` : void 0,
+          index: rowIndex
+        }).then((result) => {
+          processed++;
+          observer.emit("dt:import:processed", { table: tableName, processed, totalRows });
+          if (result.error) {
+            pipelineError = pipelineError ?? new Error(result.error);
+            return;
+          }
+          orderBuffer.add(result.index, result.record);
+        });
+      }
+      readBatch = [];
+      while (inFlight > 0) {
+        await new Promise((resolve2) => setTimeout(resolve2, 1));
+      }
+      if (pipelineError) {
+        return [null, pipelineError];
+      }
+      const flushErr = await flushInsertBatch();
+      if (flushErr) {
+        return [null, flushErr];
+      }
+    }
+  }
+  if (readBatch.length > 0) {
+    observer.emit("dt:import:loaded", { table: tableName, loaded, totalRows });
+    for (const rowValues of readBatch) {
+      const rowIndex = globalIndex++;
+      inFlight++;
+      computePool.request("deserialize", {
+        values: rowValues,
+        columns: dtSchema.columns,
+        targetDialect: dialect,
+        targetVersion: version ? `${version.major}.${version.minor}` : void 0,
+        index: rowIndex
+      }).then((result) => {
+        processed++;
+        observer.emit("dt:import:processed", { table: tableName, processed, totalRows });
+        if (result.error) {
+          pipelineError = pipelineError ?? new Error(result.error);
+          return;
+        }
+        orderBuffer.add(result.index, result.record);
+      });
+    }
+    while (inFlight > 0) {
+      await new Promise((resolve2) => setTimeout(resolve2, 1));
+    }
+    if (pipelineError) {
+      return [null, pipelineError];
+    }
+    const flushErr = await flushInsertBatch();
+    if (flushErr) {
+      return [null, flushErr];
+    }
+  }
   return [{ rowsImported, rowsSkipped }, null];
 }
 async function insertImportBatch(db, table, rows, onConflict, dialect, columns) {