@noormdev/sdk 1.0.0-alpha.0 → 1.0.0-alpha.10

package/dist/index.js

@@ -1,22 +1,41 @@
-import { observer, processFile, isTemplate } from './chunk-MERTHCAJ.js';
-import { existsSync, readFileSync, mkdirSync, writeFileSync, constants } from 'fs';
-import path6, { join, dirname } from 'path';
-import { makeNestedConfig, attempt, retry, clone, merge, attemptSync } from '@logosdx/utils';
+import { observer, processFile, DtReader, FORMAT_VERSION, DT_EXTENSIONS, encryptWithPassphrase, isTemplate, ENCODED_TYPES, GZIP_THRESHOLD, GZIP_RATIO_THRESHOLD } from './chunk-GR57BRV4.js';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, createWriteStream, constants } from 'fs';
+import path7, { join, dirname } from 'path';
+import { makeNestedConfig, gigabytes, attempt, retry, clone, merge, attemptSync } from '@logosdx/utils';
 import { homedir, userInfo } from 'os';
 import { readFile, stat, readdir, rm, access, mkdir, writeFile } from 'fs/promises';
 import { createHash, createDecipheriv, randomBytes, createCipheriv, hkdfSync } from 'crypto';
-import { createRequire } from 'module';
 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 { pipeline } from 'stream/promises';
+import { PassThrough } from 'stream';
+import JSON5 from 'json5';
 
 var NOORM_HOME = join(homedir(), ".noorm");
 var PRIVATE_KEY_PATH = join(NOORM_HOME, "identity.key");
-join(NOORM_HOME, "identity.pub");
-join(NOORM_HOME, "identity.json");
+var PUBLIC_KEY_PATH = join(NOORM_HOME, "identity.pub");
+var IDENTITY_METADATA_PATH = join(NOORM_HOME, "identity.json");
+async function loadIdentityMetadata() {
+  const [content, err] = await attempt(
+    () => readFile(IDENTITY_METADATA_PATH, { encoding: "utf8" })
+  );
+  if (err) {
+    if (err.code === "ENOENT") {
+      return null;
+    }
+    throw new Error(`Failed to read identity metadata: ${err.message}`);
+  }
+  const [parsed, parseErr] = attemptSync(() => JSON.parse(content));
+  if (parseErr) {
+    return null;
+  }
+  return parsed;
+}
 async function loadPrivateKey() {
   const [content, err] = await attempt(() => readFile(PRIVATE_KEY_PATH, { encoding: "utf8" }));
   if (err) {
@@ -27,6 +46,16 @@ async function loadPrivateKey() {
   }
   return content.trim();
 }
+async function loadPublicKey() {
+  const [content, err] = await attempt(() => readFile(PUBLIC_KEY_PATH, { encoding: "utf8" }));
+  if (err) {
+    if (err.code === "ENOENT") {
+      return null;
+    }
+    throw new Error(`Failed to read public key: ${err.message}`);
+  }
+  return content.trim();
+}
 function deriveStateKey(privateKey) {
   const privateKeyBuffer = Buffer.from(privateKey, "hex");
   return Buffer.from(
@@ -120,14 +149,15 @@ function needsMigration(state, currentVersion) {
   if (!("knownUsers" in obj)) return true;
   return false;
 }
-var require2 = createRequire(import.meta.url);
+
+// src/core/state/version.ts
+var VERSION = typeof __CLI_VERSION__ !== "undefined" ? __CLI_VERSION__ : "0.0.0-dev";
 function getPackageVersion() {
-  const pkg = require2("../../../package.json");
-  return pkg.version;
+  return VERSION;
 }
 
 // src/core/state/manager.ts
-var DEFAULT_STATE_DIR = ".noorm";
+var DEFAULT_STATE_DIR = ".noorm/state";
 var DEFAULT_STATE_FILE = "state.enc";
 var StateManager = class {
   constructor(projectRoot, options = {}) {
@@ -632,7 +662,7 @@ var StrictConfigSchema = z.object({
 var LoggingConfigSchema = z.object({
   enabled: z.boolean().default(true),
   level: LogLevelSchema.default("info"),
-  file: z.string().default(".noorm/noorm.log"),
+  file: z.string().default(".noorm/state/noorm.log"),
   maxSize: FileSizeSchema.default("10mb"),
   maxFiles: z.number().int().min(1).default(5)
 });
@@ -682,7 +712,7 @@ var DEFAULT_STRICT_CONFIG = {
 var DEFAULT_LOGGING_CONFIG = {
   enabled: true,
   level: "info",
-  file: ".noorm/noorm.log",
+  file: ".noorm/state/noorm.log",
   maxSize: "10mb",
   maxFiles: 5
 };
@@ -746,13 +776,13 @@ function evaluateRules(rules, config) {
     const result = evaluateRule(rule, config);
     if (result.matched) {
       matchedRules.push(rule);
-      for (const path7 of result.include) {
-        includeSet.add(path7);
-        excludeSet.delete(path7);
+      for (const path8 of result.include) {
+        includeSet.add(path8);
+        excludeSet.delete(path8);
       }
-      for (const path7 of result.exclude) {
-        excludeSet.add(path7);
-        includeSet.delete(path7);
+      for (const path8 of result.exclude) {
+        excludeSet.add(path8);
+        includeSet.delete(path8);
       }
     }
   }
@@ -765,13 +795,13 @@ function evaluateRules(rules, config) {
 function mergeWithBuildConfig(buildInclude, buildExclude, ruleResult) {
   const includeSet = new Set(buildInclude);
   const excludeSet = new Set(buildExclude);
-  for (const path7 of ruleResult.include) {
-    includeSet.add(path7);
-    excludeSet.delete(path7);
+  for (const path8 of ruleResult.include) {
+    includeSet.add(path8);
+    excludeSet.delete(path8);
   }
-  for (const path7 of ruleResult.exclude) {
-    excludeSet.add(path7);
-    includeSet.delete(path7);
+  for (const path8 of ruleResult.exclude) {
+    excludeSet.add(path8);
+    includeSet.delete(path8);
   }
   return {
     include: Array.from(includeSet),
@@ -1441,6 +1471,20 @@ function formatIdentity(identity) {
   }
   return identity.name;
 }
+async function loadExistingIdentity() {
+  const metadata = await loadIdentityMetadata();
+  if (!metadata) {
+    return null;
+  }
+  const publicKey = await loadPublicKey();
+  if (!publicKey) {
+    return null;
+  }
+  return {
+    ...metadata,
+    publicKey
+  };
+}
 var ConnectionManager = class {
   #cached = /* @__PURE__ */ new Map();
   #tracked = /* @__PURE__ */ new Map();
@@ -1653,6 +1697,7 @@ async function createConnection(config, configName = "__default__") {
     destroy: wrappedDestroy
   };
   observer.emit("connection:open", { configName, dialect: config.dialect });
+  await waitForIdentityToLoad(trackedConn.db);
   return trackedConn;
 }
 var SYSTEM_DATABASES = {
@@ -1680,6 +1725,223 @@ async function testConnection(config, options = {}) {
   return { ok: true };
 }
 
+// src/core/version/types.ts
+var CURRENT_VERSIONS = Object.freeze({
+  /** Database tracking tables schema version */
+  schema: 1,
+  /** State file (state.enc) schema version */
+  state: 1,
+  /** Settings file (settings.yml) schema version */
+  settings: 1
+});
+var VersionMismatchError = class extends Error {
+  constructor(layer, current, expected) {
+    super(
+      `${layer} version ${current} is newer than CLI supports (${expected}). Please upgrade noorm.`
+    );
+    this.layer = layer;
+    this.current = current;
+    this.expected = expected;
+    this.name = "VersionMismatchError";
+  }
+};
+var MigrationError = class extends Error {
+  constructor(layer, version, cause) {
+    super(`${layer} migration v${version} failed: ${cause.message}`);
+    this.layer = layer;
+    this.version = version;
+    this.cause = cause;
+    this.name = "MigrationError";
+  }
+};
+function addIdColumn(builder, dialect) {
+  if (dialect === "postgres") {
+    return builder.addColumn("id", "serial", (col) => col.primaryKey());
+  }
+  return builder.addColumn("id", "integer", (col) => col.primaryKey().autoIncrement());
+}
+var v1 = {
+  version: 1,
+  description: "Create initial tracking tables",
+  async up(db, dialect) {
+    await addIdColumn(db.schema.createTable("__noorm_version__"), dialect).addColumn("cli_version", "varchar(50)", (col) => col.notNull()).addColumn("noorm_version", "integer", (col) => col.notNull()).addColumn("state_version", "integer", (col) => col.notNull()).addColumn("settings_version", "integer", (col) => col.notNull()).addColumn(
+      "installed_at",
+      "timestamp",
+      (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+    ).addColumn(
+      "upgraded_at",
+      "timestamp",
+      (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+    ).execute();
+    await addIdColumn(db.schema.createTable("__noorm_change__"), dialect).addColumn("name", "varchar(255)", (col) => col.notNull()).addColumn("change_type", "varchar(50)", (col) => col.notNull()).addColumn("direction", "varchar(50)", (col) => col.notNull()).addColumn("checksum", "varchar(64)", (col) => col.notNull().defaultTo("")).addColumn(
+      "executed_at",
+      "timestamp",
+      (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+    ).addColumn("executed_by", "varchar(255)", (col) => col.notNull().defaultTo("")).addColumn("config_name", "varchar(255)", (col) => col.notNull().defaultTo("")).addColumn("cli_version", "varchar(50)", (col) => col.notNull().defaultTo("")).addColumn("status", "varchar(50)", (col) => col.notNull()).addColumn("error_message", "text", (col) => col.notNull().defaultTo("")).addColumn("duration_ms", "integer", (col) => col.notNull().defaultTo(0)).execute();
+    await addIdColumn(db.schema.createTable("__noorm_executions__"), dialect).addColumn(
+      "change_id",
+      "integer",
+      (col) => col.notNull().references("__noorm_change__.id").onDelete("cascade")
+    ).addColumn("filepath", "varchar(500)", (col) => col.notNull()).addColumn("file_type", "varchar(10)", (col) => col.notNull()).addColumn("checksum", "varchar(64)", (col) => col.notNull().defaultTo("")).addColumn("cli_version", "varchar(50)", (col) => col.notNull().defaultTo("")).addColumn("status", "varchar(50)", (col) => col.notNull()).addColumn("error_message", "text", (col) => col.notNull().defaultTo("")).addColumn("skip_reason", "varchar(100)", (col) => col.notNull().defaultTo("")).addColumn("duration_ms", "integer", (col) => col.notNull().defaultTo(0)).execute();
+    await addIdColumn(db.schema.createTable("__noorm_lock__"), dialect).addColumn("config_name", "varchar(255)", (col) => col.notNull().unique()).addColumn("locked_by", "varchar(255)", (col) => col.notNull()).addColumn(
+      "locked_at",
+      "timestamp",
+      (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+    ).addColumn("expires_at", "timestamp", (col) => col.notNull()).addColumn("reason", "varchar(255)", (col) => col.notNull().defaultTo("")).execute();
+    await addIdColumn(db.schema.createTable("__noorm_identities__"), dialect).addColumn("identity_hash", "varchar(64)", (col) => col.notNull().unique()).addColumn("email", "varchar(255)", (col) => col.notNull()).addColumn("name", "varchar(255)", (col) => col.notNull()).addColumn("machine", "varchar(255)", (col) => col.notNull()).addColumn("os", "varchar(255)", (col) => col.notNull()).addColumn("public_key", "text", (col) => col.notNull()).addColumn("encrypted_vault_key", "text").addColumn(
+      "registered_at",
+      "timestamp",
+      (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+    ).addColumn(
+      "last_seen_at",
+      "timestamp",
+      (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+    ).execute();
+    await addIdColumn(db.schema.createTable("__noorm_vault__"), dialect).addColumn("secret_key", "varchar(255)", (col) => col.notNull().unique()).addColumn("encrypted_value", "text", (col) => col.notNull()).addColumn("set_by", "varchar(255)", (col) => col.notNull()).addColumn(
+      "created_at",
+      "timestamp",
+      (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+    ).addColumn(
+      "updated_at",
+      "timestamp",
+      (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+    ).execute();
+    await db.schema.createIndex("idx_executions_change_id").on("__noorm_executions__").column("change_id").execute();
+    await db.schema.createIndex("idx_change_name_config").on("__noorm_change__").columns(["name", "config_name"]).execute();
+    await db.schema.createIndex("idx_vault_secret_key").on("__noorm_vault__").column("secret_key").execute();
+  },
+  async down(db, _dialect) {
+    await db.schema.dropIndex("idx_change_name_config").execute();
+    await db.schema.dropIndex("idx_executions_change_id").execute();
+    await db.schema.dropIndex("idx_vault_secret_key").execute();
+    await db.schema.dropTable("__noorm_vault__").execute();
+    await db.schema.dropTable("__noorm_identities__").execute();
+    await db.schema.dropTable("__noorm_lock__").execute();
+    await db.schema.dropTable("__noorm_executions__").execute();
+    await db.schema.dropTable("__noorm_change__").execute();
+    await db.schema.dropTable("__noorm_version__").execute();
+  }
+};
+
+// src/core/update/checker.ts
+function getCurrentVersion() {
+  return typeof __CLI_VERSION__ !== "undefined" ? __CLI_VERSION__ : "0.0.0-dev";
+}
+
+// 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);
+    return true;
+  });
+  if (err) return false;
+  return result;
+}
+async function getSchemaVersion(db) {
+  const exists = await tablesExist(db);
+  if (!exists) return 0;
+  const [result, err] = 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;
+}
+async function checkSchemaVersion(db) {
+  const current = await getSchemaVersion(db);
+  const expected = CURRENT_VERSIONS.schema;
+  observer.emit("version:schema:checking", { current });
+  return {
+    current,
+    expected,
+    needsMigration: current < expected,
+    isNewer: current > expected
+  };
+}
+async function bootstrapSchema(db, dialect, options) {
+  const start = performance.now();
+  observer.emit("version:schema:migrating", {
+    from: 0,
+    to: CURRENT_VERSIONS.schema
+  });
+  for (const migration of MIGRATIONS) {
+    const [, err] = await attempt(() => migration.up(db, dialect));
+    if (err) {
+      throw new MigrationError("schema", migration.version, err);
+    }
+  }
+  await db.insertInto("__noorm_version__").values({
+    cli_version: getCurrentVersion(),
+    noorm_version: CURRENT_VERSIONS.schema,
+    state_version: CURRENT_VERSIONS.state,
+    settings_version: CURRENT_VERSIONS.settings
+  }).execute();
+  const durationMs = performance.now() - start;
+  observer.emit("version:schema:migrated", {
+    from: 0,
+    to: CURRENT_VERSIONS.schema,
+    durationMs
+  });
+  await waitForIdentityToLoad(db);
+}
+async function getLatestVersionRecord(db) {
+  const exists = await tablesExist(db);
+  if (!exists) return null;
+  const [result, err] = 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
+  };
+}
+async function migrateSchema(db, dialect, options) {
+  const status = await checkSchemaVersion(db);
+  if (status.isNewer) {
+    observer.emit("version:mismatch", {
+      layer: "schema",
+      current: status.current,
+      expected: status.expected
+    });
+    throw new VersionMismatchError("schema", status.current, status.expected);
+  }
+  if (!status.needsMigration) return;
+  if (status.current === 0) {
+    await bootstrapSchema(db, dialect);
+    return;
+  }
+  const start = performance.now();
+  observer.emit("version:schema:migrating", {
+    from: status.current,
+    to: CURRENT_VERSIONS.schema
+  });
+  const existing = await getLatestVersionRecord(db);
+  const pendingMigrations = MIGRATIONS.filter((m) => m.version > status.current);
+  for (const migration of pendingMigrations) {
+    const [, err] = await attempt(() => migration.up(db, dialect));
+    if (err) {
+      throw new MigrationError("schema", migration.version, err);
+    }
+  }
+  await db.insertInto("__noorm_version__").values({
+    cli_version: getCurrentVersion(),
+    noorm_version: CURRENT_VERSIONS.schema,
+    state_version: existing?.stateVersion ?? CURRENT_VERSIONS.state,
+    settings_version: existing?.settingsVersion ?? CURRENT_VERSIONS.settings
+  }).execute();
+  const durationMs = performance.now() - start;
+  observer.emit("version:schema:migrated", {
+    from: status.current,
+    to: CURRENT_VERSIONS.schema,
+    durationMs
+  });
+  await waitForIdentityToLoad(db);
+}
+async function ensureSchemaVersion(db, dialect, options) {
+  await migrateSchema(db, dialect);
+}
+
 // src/core/shared/tables.ts
 var NOORM_TABLES = Object.freeze({
   /** Version tracking table */
@@ -1691,7 +1953,9 @@ var NOORM_TABLES = Object.freeze({
   /** Concurrent operation lock table */
   lock: "__noorm_lock__",
   /** Team member identity table */
-  identities: "__noorm_identities__"
+  identities: "__noorm_identities__",
+  /** Vault secrets table */
+  vault: "__noorm_vault__"
 });
 
 // src/core/environment.ts
@@ -1824,6 +2088,71 @@ addMaskedFields([
   "session_secret"
 ]);
 
+// src/core/identity/sync.ts
+async function registerIdentity(db, identity) {
+  const [existing, selectErr] = await attempt(
+    () => db.selectFrom("__noorm_identities__").select(["id"]).where("identity_hash", "=", identity.identityHash).executeTakeFirst()
+  );
+  if (selectErr) {
+    observer.emit("error", {
+      source: "identity:register:select",
+      error: selectErr,
+      context: {
+        identityHash: identity.identityHash,
+        name: identity.name,
+        email: identity.email
+      }
+    });
+    return { ok: false, registered: false, error: selectErr.message };
+  }
+  if (existing) {
+    const [, updateErr] = await attempt(
+      () => db.updateTable("__noorm_identities__").set({ last_seen_at: /* @__PURE__ */ new Date() }).where("identity_hash", "=", identity.identityHash).execute()
+    );
+    if (updateErr) {
+      observer.emit("error", {
+        source: "identity:register:update",
+        error: updateErr,
+        context: {
+          identityHash: identity.identityHash,
+          name: identity.name,
+          email: identity.email
+        }
+      });
+      return { ok: false, registered: false, error: updateErr.message };
+    }
+    return { ok: true, registered: false };
+  }
+  const [, insertErr] = await attempt(
+    () => db.insertInto("__noorm_identities__").values({
+      identity_hash: identity.identityHash,
+      email: identity.email,
+      name: identity.name,
+      machine: identity.machine,
+      os: identity.os,
+      public_key: identity.publicKey
+    }).execute()
+  );
+  if (insertErr) {
+    observer.emit("error", {
+      source: "identity:register:insert",
+      error: insertErr,
+      context: {
+        identityHash: identity.identityHash,
+        name: identity.name,
+        email: identity.email
+      }
+    });
+    return { ok: false, registered: false, error: insertErr.message };
+  }
+  observer.emit("identity:registered", {
+    identityHash: identity.identityHash,
+    name: identity.name,
+    email: identity.email
+  });
+  return { ok: true, registered: true };
+}
+
 // src/core/identity/index.ts
 var cachedIdentity = null;
 function resolveIdentity2(options = {}) {
@@ -1838,6 +2167,17 @@ function resolveIdentity2(options = {}) {
 function getIdentityForConfig(config) {
   return resolveIdentity2({ configIdentity: config.identity });
 }
+async function waitForIdentityToLoad(db) {
+  const identity = await loadExistingIdentity();
+  if (!identity) observer.emit("identity:not-found");
+  if (!identity) return;
+  const [, err] = await attempt(() => registerIdentity(db, identity));
+  if (err) observer.emit("error", {
+    error: err,
+    source: "identity:ensure",
+    context: { identity }
+  });
+}
 var DialectSchema2 = z.enum(["postgres", "mysql", "sqlite", "mssql"]);
 var ConfigNameSchema = z.string().min(1, "Config name is required").regex(
   /^[a-z0-9_-]+$/i,
@@ -2034,6 +2374,78 @@ function resolveFromEnvOnly(envConfig, flags, stageName, settings) {
   }
   return parseConfig(merged);
 }
+function buildProcCall(dialect, name, params) {
+  if (dialect === "sqlite") {
+    throw new Error("SQLite does not support stored procedures.");
+  }
+  const rawName = sql.raw(name);
+  if (!params || Array.isArray(params) && params.length === 0 || !Array.isArray(params) && Object.keys(params).length === 0) {
+    if (dialect === "mssql") {
+      return sql`EXEC ${rawName}`;
+    }
+    return sql`CALL ${rawName}()`;
+  }
+  if (dialect === "mssql") {
+    return buildMssqlProc(rawName, params);
+  }
+  if (dialect === "postgres") {
+    return buildPostgresProc(rawName, params);
+  }
+  return buildMysqlProc(rawName, params);
+}
+function buildFuncCall(dialect, name, column, params) {
+  if (dialect === "sqlite") {
+    throw new Error("SQLite does not support database function calls.");
+  }
+  const rawName = sql.raw(name);
+  const rawCol = sql.raw(column);
+  if (!params || Array.isArray(params) && params.length === 0 || !Array.isArray(params) && Object.keys(params).length === 0) {
+    return sql`SELECT ${rawName}() AS ${rawCol}`;
+  }
+  if (dialect === "postgres" && !Array.isArray(params)) {
+    const parts = Object.entries(params).map(
+      ([key, val]) => sql`${sql.raw(key)} => ${val}`
+    );
+    return sql`SELECT ${rawName}(${sql.join(parts)}) AS ${rawCol}`;
+  }
+  if (dialect === "mssql" && !Array.isArray(params)) {
+    const parts = Object.entries(params).map(
+      ([key, val]) => sql`${sql.raw(`@${key}`)} = ${val}`
+    );
+    return sql`DECLARE @__result sql_variant; EXEC @__result = ${rawName} ${sql.join(parts)}; SELECT @__result AS ${rawCol}`;
+  }
+  if (dialect === "mysql" && !Array.isArray(params)) {
+    throw new Error("MySQL does not support named parameters in function calls. Use positional parameters (array) instead.");
+  }
+  const values = Array.isArray(params) ? params : Object.values(params);
+  const joined = sql.join(values.map((v) => sql`${v}`));
+  return sql`SELECT ${rawName}(${joined}) AS ${rawCol}`;
+}
+function buildMssqlProc(rawName, params) {
+  if (Array.isArray(params)) {
+    const joined = sql.join(params.map((v) => sql`${v}`));
+    return sql`EXEC ${rawName} ${joined}`;
+  }
+  const parts = Object.entries(params).map(
+    ([key, val]) => sql`${sql.raw(`@${key}`)} = ${val}`
+  );
+  return sql`EXEC ${rawName} ${sql.join(parts)}`;
+}
+function buildPostgresProc(rawName, params) {
+  if (Array.isArray(params)) {
+    const joined = sql.join(params.map((v) => sql`${v}`));
+    return sql`CALL ${rawName}(${joined})`;
+  }
+  const parts = Object.entries(params).map(
+    ([key, val]) => sql`${sql.raw(key)} => ${val}`
+  );
+  return sql`CALL ${rawName}(${sql.join(parts)})`;
+}
+function buildMysqlProc(rawName, params) {
+  const values = Array.isArray(params) ? params : Object.values(params);
+  const joined = sql.join(values.map((v) => sql`${v}`));
+  return sql`CALL ${rawName}(${joined})`;
+}
 var EXCLUDED_SCHEMAS = ["pg_catalog", "information_schema", "pg_toast"];
 var postgresExploreOperations = {
   async getOverview(db) {
@@ -4495,21 +4907,21 @@ var DATE_PREFIX_REGEX = /^(\d{4}-\d{2}-\d{2})-(.+)$/;
 async function parseChange(folderPath, sqlDir) {
   const [folderStat, statErr] = await attempt(() => stat(folderPath));
   if (statErr || !folderStat?.isDirectory()) {
-    throw new ChangeNotFoundError(path6.basename(folderPath));
+    throw new ChangeNotFoundError(path7.basename(folderPath));
   }
-  const name = path6.basename(folderPath);
+  const name = path7.basename(folderPath);
   const { date, description } = parseName(name);
-  const changePath = path6.join(folderPath, "change");
+  const changePath = path7.join(folderPath, "change");
   const [changeFiles, changeErr] = await attempt(() => scanFolder(changePath, sqlDir));
   if (changeErr && !isNotFoundError(changeErr)) {
     throw changeErr;
   }
-  const revertPath = path6.join(folderPath, "revert");
+  const revertPath = path7.join(folderPath, "revert");
   const [revertFiles, revertErr] = await attempt(() => scanFolder(revertPath, sqlDir));
   if (revertErr && !isNotFoundError(revertErr)) {
     throw revertErr;
   }
-  const changelogPath = path6.join(folderPath, "changelog.md");
+  const changelogPath = path7.join(folderPath, "changelog.md");
   const hasChangelog = await fileExists(changelogPath);
   if ((!changeFiles || changeFiles.length === 0) && (!revertFiles || revertFiles.length === 0)) {
     throw new ChangeValidationError(
@@ -4544,7 +4956,7 @@ async function discoverChanges(changesDir, sqlDir) {
   const folders = entries.filter((e) => e.isDirectory());
   const changes = [];
   for (const folder of folders) {
-    const folderPath = path6.join(changesDir, folder.name);
+    const folderPath = path7.join(changesDir, folder.name);
     const [change, parseErr] = await attempt(() => parseChange(folderPath, sqlDir));
     if (parseErr) {
       observer.emit("error", {
@@ -4566,13 +4978,13 @@ async function resolveManifest(manifestPath, sqlDir) {
   const lines = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
   if (lines.length === 0) {
     throw new ChangeValidationError(
-      path6.basename(path6.dirname(path6.dirname(manifestPath))),
-      `Empty manifest file: ${path6.basename(manifestPath)}`
+      path7.basename(path7.dirname(path7.dirname(manifestPath))),
+      `Empty manifest file: ${path7.basename(manifestPath)}`
     );
   }
   const resolvedPaths = [];
   for (const relativePath of lines) {
-    const absolutePath = path6.join(sqlDir, relativePath);
+    const absolutePath = path7.join(sqlDir, relativePath);
     const [exists] = await attempt(() => access(absolutePath, constants.R_OK));
     if (exists === void 0) {
       resolvedPaths.push(absolutePath);
@@ -4624,7 +5036,7 @@ async function scanFolder(folderPath, sqlDir) {
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     const filename = entry.name;
-    const filePath = path6.join(folderPath, filename);
+    const filePath = path7.join(folderPath, filename);
     const type = getFileType(filename);
     if (!type) continue;
     const file = {
@@ -6377,7 +6789,7 @@ async function executeFiles(context, change, files, direction, checksum, history
     });
   }
   if (failed) {
-    const skipReason = failedFile ? `${path6.basename(failedFile)} failed: ${failureError ?? "unknown error"}` : "change failed";
+    const skipReason = failedFile ? `${path7.basename(failedFile)} failed: ${failureError ?? "unknown error"}` : "change failed";
     const skipError = await history.skipRemainingFiles(operationId, skipReason);
     if (skipError) {
       observer.emit("error", {
@@ -6389,7 +6801,7 @@ async function executeFiles(context, change, files, direction, checksum, history
   }
   const totalDurationMs = performance.now() - startTime;
   const executionStatus = failed ? "failed" : "success";
-  const errorMessage = failedFile ? `${path6.basename(failedFile)}: ${failureError ?? "unknown error"}` : failureError;
+  const errorMessage = failedFile ? `${path7.basename(failedFile)}: ${failureError ?? "unknown error"}` : failureError;
   const finalizeError = await history.finalizeOperation(
     operationId,
     executionStatus,
@@ -6462,7 +6874,7 @@ async function expandFiles(files, sqlDir) {
       if (file.resolvedPaths) {
         for (const resolvedPath of file.resolvedPaths) {
           expanded.push({
-            filename: path6.basename(resolvedPath),
+            filename: path7.basename(resolvedPath),
             path: resolvedPath,
             type: "sql"
           });
@@ -6471,7 +6883,7 @@ async function expandFiles(files, sqlDir) {
         const resolved = await resolveManifest(file.path, sqlDir);
         for (const resolvedPath of resolved) {
           expanded.push({
-            filename: path6.basename(resolvedPath),
+            filename: path7.basename(resolvedPath),
             path: resolvedPath,
             type: "sql"
           });
@@ -6539,6 +6951,11 @@ async function executeDryRun(context, change, files, direction, startTime) {
     const [checksum] = await attempt(() => computeChecksum(file.path));
     const [sqlContent, loadErr] = await attempt(() => loadAndRenderFile(context, file.path));
     if (loadErr) {
+      observer.emit("file:dry-run", {
+        filepath: file.path,
+        status: "failed",
+        error: loadErr.message
+      });
       results.push({
         filepath: file.path,
         checksum: checksum ?? "",
@@ -6559,6 +6976,12 @@ async function executeDryRun(context, change, files, direction, startTime) {
         context: { filepath: file.path, operation: "dry-run-write" }
       });
     }
+    const outputPath = getDryRunOutputPath(context.projectRoot, file.path);
+    observer.emit("file:dry-run", {
+      filepath: file.path,
+      status: "success",
+      outputPath
+    });
     results.push({
       filepath: file.path,
       checksum: checksum ?? "",
@@ -6576,13 +6999,13 @@ async function executeDryRun(context, change, files, direction, startTime) {
   };
 }
 function getDryRunOutputPath(projectRoot, filepath) {
-  const relativePath = path6.relative(projectRoot, filepath);
+  const relativePath = path7.relative(projectRoot, filepath);
   const outputRelativePath = relativePath.endsWith(".tmpl") ? relativePath.slice(0, -5) : relativePath;
-  return path6.join(projectRoot, "tmp", outputRelativePath);
+  return path7.join(projectRoot, "tmp", outputRelativePath);
 }
 async function writeDryRunOutput(projectRoot, filepath, content) {
   const outputPath = getDryRunOutputPath(projectRoot, filepath);
-  const outputDir = path6.dirname(outputPath);
+  const outputDir = path7.dirname(outputPath);
   await mkdir(outputDir, { recursive: true });
   await writeFile(outputPath, content, "utf-8");
 }
@@ -6908,7 +7331,7 @@ var ChangeManager = class {
    */
   async remove(name, options) {
     if (options.disk) {
-      const changePath = path6.join(this.#context.changesDir, name);
+      const changePath = path7.join(this.#context.changesDir, name);
       const [change, loadErr] = await attempt(
         () => parseChange(changePath, this.#context.sqlDir)
       );
@@ -6943,7 +7366,7 @@ var ChangeManager = class {
    * Load a change from disk by name.
    */
   async #loadChange(name) {
-    const changePath = path6.join(this.#context.changesDir, name);
+    const changePath = path7.join(this.#context.changesDir, name);
     const [change, err] = await attempt(
       () => parseChange(changePath, this.#context.sqlDir)
     );
@@ -7177,17 +7600,21 @@ var FILE_HEADER_TEMPLATE = `-- =================================================
 -- ============================================================
 
 `;
-async function runBuild(context, sqlPath, options = {}) {
+async function runBuild(context, sqlPath, options = {}, preFilteredFiles) {
   const start = performance.now();
   const opts = { ...DEFAULT_RUN_OPTIONS_INTERNAL, ...options };
-  const [files, discoverErr] = await attempt(() => discoverFiles(sqlPath));
-  if (discoverErr) {
-    observer.emit("error", {
-      source: "runner",
-      error: discoverErr,
-      context: { sqlPath, operation: "discover-files" }
-    });
-    return createFailedBatchResult(discoverErr.message, performance.now() - start);
+  let files;
+  {
+    const [discovered, discoverErr] = await attempt(() => discoverFiles(sqlPath));
+    if (discoverErr) {
+      observer.emit("error", {
+        source: "runner",
+        error: discoverErr,
+        context: { sqlPath, operation: "discover-files" }
+      });
+      return createFailedBatchResult(discoverErr.message, performance.now() - start);
+    }
+    files = discovered;
   }
   observer.emit("build:start", {
     sqlPath,
@@ -7708,6 +8135,11 @@ async function executeDryRun2(context, files) {
     const start = performance.now();
     const [checksum, checksumErr] = await attempt(() => computeChecksum(filepath));
     if (checksumErr) {
+      observer.emit("file:dry-run", {
+        filepath,
+        status: "failed",
+        error: checksumErr.message
+      });
       results.push({
         filepath,
         checksum: "",
@@ -7719,6 +8151,11 @@ async function executeDryRun2(context, files) {
     }
     const [sqlContent, loadErr] = await attempt(() => loadAndRenderFile2(context, filepath));
     if (loadErr) {
+      observer.emit("file:dry-run", {
+        filepath,
+        status: "failed",
+        error: loadErr.message
+      });
       results.push({
         filepath,
         checksum,
@@ -7742,6 +8179,7 @@ async function executeDryRun2(context, files) {
     const outputPath = getDryRunOutputPath2(context.projectRoot, filepath);
     observer.emit("file:dry-run", {
       filepath,
+      status: "success",
       outputPath
     });
     results.push({
@@ -7755,13 +8193,13 @@ async function executeDryRun2(context, files) {
   return results;
 }
 function getDryRunOutputPath2(projectRoot, filepath) {
-  const relativePath = path6.relative(projectRoot, filepath);
+  const relativePath = path7.relative(projectRoot, filepath);
   const outputRelativePath = relativePath.endsWith(".tmpl") ? relativePath.slice(0, -5) : relativePath;
-  return path6.join(projectRoot, "tmp", outputRelativePath);
+  return path7.join(projectRoot, "tmp", outputRelativePath);
 }
 async function writeDryRunOutput2(projectRoot, filepath, content) {
   const outputPath = getDryRunOutputPath2(projectRoot, filepath);
-  const outputDir = path6.dirname(outputPath);
+  const outputDir = path7.dirname(outputPath);
   await mkdir(outputDir, { recursive: true });
   await writeFile(outputPath, content, "utf-8");
 }
@@ -7773,7 +8211,7 @@ async function discoverFiles(dirpath) {
       throw new Error(`Failed to read directory: ${dir}`, { cause: err });
     }
     for (const entry of entries) {
-      const fullPath = path6.join(dir, entry.name);
+      const fullPath = path7.join(dir, entry.name);
       if (entry.isDirectory()) {
         await scan(fullPath);
       } else if (entry.isFile() && isSqlFile(entry.name)) {
@@ -7797,200 +8235,2916 @@ function createFailedBatchResult(error, durationMs) {
     durationMs
   };
 }
-
-// src/sdk/guards.ts
-var RequireTestError = class extends Error {
-  constructor(configName) {
-    super(`Config "${configName}" does not have isTest: true`);
-    this.configName = configName;
-  }
-  name = "RequireTestError";
-};
-var ProtectedConfigError = class extends Error {
-  constructor(configName, operation) {
-    super(`Cannot ${operation} on protected config "${configName}"`);
-    this.configName = configName;
-    this.operation = operation;
+async function withDualConnection(options, fn) {
+  const { sourceConfig, destConfig, ensureSchema = true } = options;
+  let sourceConn = null;
+  let destConn = null;
+  observer.emit("db:dual:connecting", {
+    source: sourceConfig.name,
+    destination: destConfig.name
+  });
+  const [result, err] = await attempt(async () => {
+    sourceConn = await createConnection(sourceConfig.connection, sourceConfig.name);
+    destConn = await createConnection(destConfig.connection, destConfig.name);
+    observer.emit("db:dual:connected", {
+      source: sourceConfig.name,
+      destination: destConfig.name
+    });
+    if (ensureSchema) {
+      await ensureSchemaVersion(
+        destConn.db,
+        destConn.dialect
+      );
+    }
+    return fn({
+      source: {
+        config: sourceConfig,
+        db: sourceConn.db,
+        dialect: sourceConn.dialect
+      },
+      destination: {
+        config: destConfig,
+        db: destConn.db,
+        dialect: destConn.dialect
+      }
+    });
+  });
+  const cleanupErrors = [];
+  observer.emit("db:dual:disconnecting", {
+    source: sourceConfig.name,
+    destination: destConfig.name
+  });
+  if (sourceConn) {
+    const [, closeErr] = await attempt(() => sourceConn.destroy());
+    if (closeErr) cleanupErrors.push(closeErr);
   }
-  name = "ProtectedConfigError";
-};
-function checkRequireTest(config, options) {
-  if (options.requireTest && !config.isTest) {
-    throw new RequireTestError(config.name);
+  if (destConn) {
+    const [, closeErr] = await attempt(() => destConn.destroy());
+    if (closeErr) cleanupErrors.push(closeErr);
   }
-}
-function checkProtectedConfig(config, operation, options) {
-  if (config.protected && !options.allowProtected) {
-    throw new ProtectedConfigError(config.name, operation);
+  observer.emit("db:dual:disconnected", {
+    source: sourceConfig.name,
+    destination: destConfig.name
+  });
+  if (!err && cleanupErrors.length > 0) {
+    observer.emit("db:dual:cleanup-warning", { errors: cleanupErrors.map((e) => e.message) });
   }
+  return [result, err];
 }
 
-// src/sdk/context.ts
-var Context = class {
-  #connection = null;
-  #config;
-  #settings;
-  #identity;
-  #options;
-  #projectRoot;
-  #changeManager = null;
-  constructor(config, settings, identity, options, projectRoot) {
-    this.#config = config;
-    this.#settings = settings;
-    this.#identity = identity;
-    this.#options = options;
-    this.#projectRoot = projectRoot;
-  }
-  // ─────────────────────────────────────────────────────────
-  // Read-only Properties
-  // ─────────────────────────────────────────────────────────
-  get config() {
-    return this.#config;
-  }
-  get settings() {
-    return this.#settings;
+// src/core/transfer/same-server.ts
+var DEFAULT_PORTS = {
+  postgres: 5432,
+  mysql: 3306,
+  mssql: 1433,
+  sqlite: 0
+  // Not applicable
+};
+function normalizeHost(host) {
+  const h = (host ?? "localhost").toLowerCase();
+  if (h === "127.0.0.1" || h === "::1" || h === "localhost.localdomain") {
+    return "localhost";
   }
-  get identity() {
-    return this.#identity;
+  return h;
+}
+function isSameServer(source, dest) {
+  if (source.dialect !== dest.dialect) {
+    return false;
   }
-  get dialect() {
-    return this.#config.connection.dialect;
+  if (source.dialect === "sqlite") {
+    return false;
   }
-  get connected() {
-    return this.#connection !== null;
+  const srcHost = normalizeHost(source.host);
+  const dstHost = normalizeHost(dest.host);
+  const srcPort = source.port ?? DEFAULT_PORTS[source.dialect];
+  const dstPort = dest.port ?? DEFAULT_PORTS[dest.dialect];
+  if (srcHost !== dstHost || srcPort !== dstPort) {
+    return false;
   }
-  get observer() {
-    return observer;
+  if (source.dialect === "postgres") {
+    return source.database === dest.database;
   }
-  get kysely() {
-    if (!this.#connection) {
-      throw new Error("Not connected. Call connect() first.");
+  return true;
+}
+function quoteIdent(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+var postgresTransferOperations = {
+  getDisableFKSql() {
+    return "SET session_replication_role = replica";
+  },
+  getEnableFKSql() {
+    return "SET session_replication_role = DEFAULT";
+  },
+  getEnableIdentityInsertSql(_table) {
+    return null;
+  },
+  getDisableIdentityInsertSql(_table) {
+    return null;
+  },
+  getResetSequenceSql(table, column, schema) {
+    const fullTable = schema ? `${quoteIdent(schema)}.${quoteIdent(table)}` : quoteIdent(table);
+    return `
+            SELECT setval(
+                pg_get_serial_sequence('${schema ? schema + "." : ""}${table}', '${column}'),
+                COALESCE((SELECT MAX(${quoteIdent(column)}) FROM ${fullTable}), 0) + 1,
+                false
+            )
+        `.trim();
+  },
+  buildConflictInsert(table, columns, primaryKey, strategy) {
+    const quotedCols = columns.map(quoteIdent).join(", ");
+    const placeholders = columns.map((_, i) => `$${i + 1}`).join(", ");
+    const pkCols = primaryKey.map(quoteIdent).join(", ");
+    let insertSql = `INSERT INTO ${quoteIdent(table)} (${quotedCols}) OVERRIDING SYSTEM VALUE VALUES (${placeholders})`;
+    switch (strategy) {
+      case "fail":
+        break;
+      case "skip":
+        insertSql += ` ON CONFLICT (${pkCols}) DO NOTHING`;
+        break;
+      case "update": {
+        const updateCols = columns.filter((c) => !primaryKey.includes(c));
+        if (updateCols.length > 0) {
+          const setClauses = updateCols.map((c) => `${quoteIdent(c)} = EXCLUDED.${quoteIdent(c)}`).join(", ");
+          insertSql += ` ON CONFLICT (${pkCols}) DO UPDATE SET ${setClauses}`;
+        } else {
+          insertSql += ` ON CONFLICT (${pkCols}) DO NOTHING`;
+        }
+        break;
+      }
+      case "replace":
+        {
+          const setClauses = columns.map((c) => `${quoteIdent(c)} = EXCLUDED.${quoteIdent(c)}`).join(", ");
+          insertSql += ` ON CONFLICT (${pkCols}) DO UPDATE SET ${setClauses}`;
+        }
+        break;
     }
-    return this.#connection.db;
-  }
-  // ─────────────────────────────────────────────────────────
-  // Lifecycle
-  // ─────────────────────────────────────────────────────────
-  async connect() {
-    if (this.#connection) return;
-    this.#connection = await createConnection(
-      this.#config.connection,
-      this.#config.name
-    );
-  }
-  async disconnect() {
-    if (!this.#connection) return;
-    await this.#connection.destroy();
-    this.#connection = null;
-    this.#changeManager = null;
-  }
-  // ─────────────────────────────────────────────────────────
-  // SQL Execution
-  // ─────────────────────────────────────────────────────────
-  async query(sqlStr, _params) {
-    const db = this.kysely;
-    const result = await sql.raw(sqlStr).execute(db);
-    return result.rows ?? [];
-  }
-  async execute(sqlStr, _params) {
-    const db = this.kysely;
-    const result = await sql.raw(sqlStr).execute(db);
-    return {
-      rowsAffected: result.numAffectedRows ? Number(result.numAffectedRows) : void 0
-    };
+    return insertSql;
+  },
+  buildDirectTransfer(srcDb, srcTable, dstTable, columns, srcSchema = "public", dstSchema = "public") {
+    const quotedCols = columns.map(quoteIdent).join(", ");
+    const srcFull = `${quoteIdent(srcSchema)}.${quoteIdent(srcTable)}`;
+    const dstFull = `${quoteIdent(dstSchema)}.${quoteIdent(dstTable)}`;
+    return `INSERT INTO ${dstFull} (${quotedCols}) OVERRIDING SYSTEM VALUE SELECT ${quotedCols} FROM ${srcFull}`;
+  },
+  async executeDisableFK(db) {
+    await sql.raw(this.getDisableFKSql()).execute(db);
+  },
+  async executeEnableFK(db) {
+    await sql.raw(this.getEnableFKSql()).execute(db);
   }
-  async transaction(fn) {
-    const db = this.kysely;
-    return db.transaction().execute(async (trx) => {
-      const tx = {
-        async query(s, _p) {
-          const r = await sql.raw(s).execute(trx);
-          return r.rows ?? [];
-        },
-        async execute(s, _p) {
-          const r = await sql.raw(s).execute(trx);
-          return {
-            rowsAffected: r.numAffectedRows ? Number(r.numAffectedRows) : void 0
-          };
+};
+function quoteIdent2(name) {
+  return `\`${name.replace(/`/g, "``")}\``;
+}
+var mysqlTransferOperations = {
+  getDisableFKSql() {
+    return "SET FOREIGN_KEY_CHECKS = 0";
+  },
+  getEnableFKSql() {
+    return "SET FOREIGN_KEY_CHECKS = 1";
+  },
+  getEnableIdentityInsertSql(_table) {
+    return null;
+  },
+  getDisableIdentityInsertSql(_table) {
+    return null;
+  },
+  getResetSequenceSql(table, _column, _schema) {
+    return `ALTER TABLE ${quoteIdent2(table)} AUTO_INCREMENT = 1`;
+  },
+  buildConflictInsert(table, columns, primaryKey, strategy) {
+    const quotedCols = columns.map(quoteIdent2).join(", ");
+    const placeholders = columns.map(() => "?").join(", ");
+    switch (strategy) {
+      case "fail":
+        return `INSERT INTO ${quoteIdent2(table)} (${quotedCols}) VALUES (${placeholders})`;
+      case "skip":
+        return `INSERT IGNORE INTO ${quoteIdent2(table)} (${quotedCols}) VALUES (${placeholders})`;
+      case "update": {
+        const updateCols = columns.filter((c) => !primaryKey.includes(c));
+        if (updateCols.length > 0) {
+          const setClauses = updateCols.map((c) => `${quoteIdent2(c)} = VALUES(${quoteIdent2(c)})`).join(", ");
+          return `INSERT INTO ${quoteIdent2(table)} (${quotedCols}) VALUES (${placeholders}) ON DUPLICATE KEY UPDATE ${setClauses}`;
         }
-      };
-      return fn(tx);
-    });
-  }
+        return `INSERT IGNORE INTO ${quoteIdent2(table)} (${quotedCols}) VALUES (${placeholders})`;
+      }
+      case "replace":
+        return `REPLACE INTO ${quoteIdent2(table)} (${quotedCols}) VALUES (${placeholders})`;
+    }
+  },
+  buildDirectTransfer(srcDb, srcTable, dstTable, columns, _srcSchema, _dstSchema) {
+    const quotedCols = columns.map(quoteIdent2).join(", ");
+    const srcFull = `${quoteIdent2(srcDb)}.${quoteIdent2(srcTable)}`;
+    const dstFull = quoteIdent2(dstTable);
+    return `INSERT INTO ${dstFull} (${quotedCols}) SELECT ${quotedCols} FROM ${srcFull}`;
+  },
+  async executeDisableFK(db) {
+    await sql.raw(this.getDisableFKSql()).execute(db);
+  },
+  async executeEnableFK(db) {
+    await sql.raw(this.getEnableFKSql()).execute(db);
+  }
+};
+function quoteIdent3(name) {
+  return `[${name.replace(/\]/g, "]]")}]`;
+}
+var mssqlTransferOperations = {
+  getDisableFKSql() {
+    return "-- FK disable per-table";
+  },
+  getEnableFKSql() {
+    return "-- FK enable per-table";
+  },
+  getEnableIdentityInsertSql(table) {
+    return `SET IDENTITY_INSERT ${quoteIdent3(table)} ON`;
+  },
+  getDisableIdentityInsertSql(table) {
+    return `SET IDENTITY_INSERT ${quoteIdent3(table)} OFF`;
+  },
+  getResetSequenceSql(table, _column, _schema) {
+    return `DBCC CHECKIDENT ('${table}', RESEED)`;
+  },
+  buildConflictInsert(table, columns, primaryKey, strategy) {
+    const quotedCols = columns.map(quoteIdent3).join(", ");
+    const placeholders = columns.map((_, i) => `@p${i}`).join(", ");
+    switch (strategy) {
+      case "fail":
+        return `INSERT INTO ${quoteIdent3(table)} (${quotedCols}) VALUES (${placeholders})`;
+      case "skip":
+      case "update":
+      case "replace": {
+        const pkConditions = primaryKey.map((pk) => `target.${quoteIdent3(pk)} = source.${quoteIdent3(pk)}`).join(" AND ");
+        const sourceValues = columns.map((c, i) => `@p${i} AS ${quoteIdent3(c)}`).join(", ");
+        let mergeSql = `
+                MERGE INTO ${quoteIdent3(table)} AS target
+                USING (SELECT ${sourceValues}) AS source
+                ON (${pkConditions})
+            `.trim();
+        if (strategy === "skip") {
+          mergeSql += `
+                    WHEN NOT MATCHED THEN
+                        INSERT (${quotedCols})
+                        VALUES (${columns.map((c) => `source.${quoteIdent3(c)}`).join(", ")})
+                `;
+        } else if (strategy === "update") {
+          const updateCols = columns.filter((c) => !primaryKey.includes(c));
+          if (updateCols.length > 0) {
+            const setClauses = updateCols.map((c) => `target.${quoteIdent3(c)} = source.${quoteIdent3(c)}`).join(", ");
+            mergeSql += `
+                        WHEN MATCHED THEN
+                            UPDATE SET ${setClauses}
+                    `;
+          }
+          mergeSql += `
+                    WHEN NOT MATCHED THEN
+                        INSERT (${quotedCols})
+                        VALUES (${columns.map((c) => `source.${quoteIdent3(c)}`).join(", ")})
+                `;
+        } else {
+          const setClauses = columns.map((c) => `target.${quoteIdent3(c)} = source.${quoteIdent3(c)}`).join(", ");
+          mergeSql += `
+                    WHEN MATCHED THEN
+                        UPDATE SET ${setClauses}
+                    WHEN NOT MATCHED THEN
+                        INSERT (${quotedCols})
+                        VALUES (${columns.map((c) => `source.${quoteIdent3(c)}`).join(", ")})
+                `;
+        }
+        mergeSql += ";";
+        return mergeSql.trim();
+      }
+    }
+  },
+  buildDirectTransfer(srcDb, srcTable, dstTable, columns, srcSchema = "dbo", dstSchema = "dbo") {
+    const quotedCols = columns.map(quoteIdent3).join(", ");
+    const srcFull = `${quoteIdent3(srcDb)}.${quoteIdent3(srcSchema)}.${quoteIdent3(srcTable)}`;
+    const dstFull = `${quoteIdent3(dstSchema)}.${quoteIdent3(dstTable)}`;
+    return `INSERT INTO ${dstFull} (${quotedCols}) SELECT ${quotedCols} FROM ${srcFull}`;
+  },
+  async executeDisableFK(db, tables) {
+    for (const table of tables) {
+      await sql.raw(`ALTER TABLE ${quoteIdent3(table)} NOCHECK CONSTRAINT ALL`).execute(db);
+    }
+  },
+  async executeEnableFK(db, tables) {
+    for (const table of tables) {
+      await sql.raw(`ALTER TABLE ${quoteIdent3(table)} WITH CHECK CHECK CONSTRAINT ALL`).execute(db);
+    }
+  }
+};
+
+// src/core/transfer/dialects/index.ts
+var dialectOperations2 = {
+  postgres: postgresTransferOperations,
+  mysql: mysqlTransferOperations,
+  mssql: mssqlTransferOperations
+};
+var TRANSFER_SUPPORTED_DIALECTS = ["postgres", "mysql", "mssql"];
+function isTransferSupported(dialect) {
+  return TRANSFER_SUPPORTED_DIALECTS.includes(dialect);
+}
+function getTransferOperations(dialect) {
+  return dialectOperations2[dialect] ?? null;
+}
+
+// src/core/dt/dialects/postgres.ts
+var POSTGRES_TO_UNIVERSAL = [
+  // Boolean
+  { pattern: /^boolean$/i, universalType: "bool", native: true },
+  { pattern: /^bool$/i, universalType: "bool", native: true },
+  // Integer types
+  { pattern: /^smallint$/i, universalType: "int", native: true },
+  { pattern: /^int2$/i, universalType: "int", native: true },
+  { pattern: /^integer$/i, universalType: "int", native: true },
+  { pattern: /^int$/i, universalType: "int", native: true },
+  { pattern: /^int4$/i, universalType: "int", native: true },
+  { pattern: /^serial$/i, universalType: "int", native: true },
+  { pattern: /^smallserial$/i, universalType: "int", native: true },
+  // Bigint
+  { pattern: /^bigint$/i, universalType: "bigint", native: true },
+  { pattern: /^int8$/i, universalType: "bigint", native: true },
+  { pattern: /^bigserial$/i, universalType: "bigint", native: true },
+  // Float
+  { pattern: /^real$/i, universalType: "float", native: true },
+  { pattern: /^float4$/i, universalType: "float", native: true },
+  { pattern: /^double precision$/i, universalType: "float", native: true },
+  { pattern: /^float8$/i, universalType: "float", native: true },
+  // Decimal
+  { pattern: /^numeric/i, universalType: "decimal", native: true },
+  { pattern: /^decimal/i, universalType: "decimal", native: true },
+  // UUID
+  { pattern: /^uuid$/i, universalType: "uuid", native: true },
+  // Date/time
+  { pattern: /^timestamptz/i, universalType: "timestamp", native: true },
+  { pattern: /^timestamp/i, universalType: "timestamp", native: true },
+  { pattern: /^date$/i, universalType: "date", native: true },
+  { pattern: /^time/i, universalType: "string", native: true },
+  // JSON
+  { pattern: /^jsonb$/i, universalType: "json", native: true },
+  { pattern: /^json$/i, universalType: "json", native: true },
+  // Binary
+  { pattern: /^bytea$/i, universalType: "binary", native: true },
+  // Vector (pgvector extension)
+  { pattern: /^vector/i, universalType: "vector", native: true },
+  // Array types (e.g., integer[], text[], etc.)
+  { pattern: /\[\]$/i, universalType: "array", native: true },
+  { pattern: /^ARRAY$/i, universalType: "array", native: true },
+  // Text types (large variable-length text with smart compression)
+  { pattern: /^text$/i, universalType: "text", native: true },
+  // String types (short text-like types)
+  { pattern: /^varchar/i, universalType: "string", native: true },
+  { pattern: /^character varying/i, universalType: "string", native: true },
+  { pattern: /^char/i, universalType: "string", native: true },
+  { pattern: /^character\b/i, universalType: "string", native: true },
+  { pattern: /^citext$/i, universalType: "string", native: true },
+  { pattern: /^name$/i, universalType: "string", native: true },
+  // Everything else → custom
+  { pattern: /.*/, universalType: "custom", native: false }
+];
+var UNIVERSAL_TO_POSTGRES = {
+  string: "text",
+  text: "text",
+  int: "integer",
+  bigint: "bigint",
+  float: "double precision",
+  decimal: "numeric",
+  bool: "boolean",
+  timestamp: "timestamptz",
+  date: "date",
+  uuid: "uuid",
+  json: "jsonb",
+  binary: "bytea",
+  vector: "vector",
+  array: "text[]",
+  custom: "text"
+};
+
+// src/core/dt/dialects/mysql.ts
+var MYSQL_TO_UNIVERSAL = [
+  // Boolean (must come before generic TINYINT)
+  { pattern: /^tinyint\(1\)$/i, universalType: "bool", native: true },
+  { pattern: /^boolean$/i, universalType: "bool", native: true },
+  { pattern: /^bool$/i, universalType: "bool", native: true },
+  // Integer types
+  { pattern: /^tinyint/i, universalType: "int", native: true },
+  { pattern: /^smallint/i, universalType: "int", native: true },
+  { pattern: /^mediumint/i, universalType: "int", native: true },
+  { pattern: /^int\b/i, universalType: "int", native: true },
+  { pattern: /^integer/i, universalType: "int", native: true },
+  { pattern: /^year$/i, universalType: "int", native: true },
+  // Bigint
+  { pattern: /^bigint/i, universalType: "bigint", native: true },
+  // Float
+  { pattern: /^float/i, universalType: "float", native: true },
+  { pattern: /^double/i, universalType: "float", native: true },
+  // Decimal
+  { pattern: /^decimal/i, universalType: "decimal", native: true },
+  { pattern: /^numeric/i, universalType: "decimal", native: true },
+  // Date/time
+  { pattern: /^datetime/i, universalType: "timestamp", native: true },
+  { pattern: /^timestamp/i, universalType: "timestamp", native: true },
+  { pattern: /^date$/i, universalType: "date", native: true },
+  { pattern: /^time/i, universalType: "string", native: true },
+  // JSON
+  { pattern: /^json$/i, universalType: "json", native: true },
+  // Vector (MySQL 9.0+)
+  { pattern: /^vector/i, universalType: "vector", native: true },
+  // Binary types
+  { pattern: /^bit/i, universalType: "binary", native: true },
+  { pattern: /^binary/i, universalType: "binary", native: true },
+  { pattern: /^varbinary/i, universalType: "binary", native: true },
+  { pattern: /^tinyblob$/i, universalType: "binary", native: true },
+  { pattern: /^blob$/i, universalType: "binary", native: true },
+  { pattern: /^mediumblob$/i, universalType: "binary", native: true },
+  { pattern: /^longblob$/i, universalType: "binary", native: true },
+  // Enum/Set → custom
+  { pattern: /^enum/i, universalType: "custom", native: true },
+  { pattern: /^set/i, universalType: "custom", native: true },
+  // Text types (large variable-length text with smart compression)
+  { pattern: /^text$/i, universalType: "text", native: true },
+  { pattern: /^mediumtext$/i, universalType: "text", native: true },
+  { pattern: /^longtext$/i, universalType: "text", native: true },
+  // String types (short text-like types)
+  { pattern: /^char/i, universalType: "string", native: true },
+  { pattern: /^varchar/i, universalType: "string", native: true },
+  { pattern: /^tinytext$/i, universalType: "string", native: true },
+  // Everything else → custom
+  { pattern: /.*/, universalType: "custom", native: false }
+];
+function getUniversalToMysql(universalType, version) {
+  const major = version?.major ?? 8;
+  switch (universalType) {
+    case "string":
+      return "varchar(255)";
+    case "text":
+      return "longtext";
+    case "int":
+      return "int";
+    case "bigint":
+      return "bigint";
+    case "float":
+      return "double";
+    case "decimal":
+      return "decimal(38,10)";
+    case "bool":
+      return "tinyint(1)";
+    case "timestamp":
+      return "datetime(6)";
+    case "date":
+      return "date";
+    case "uuid":
+      return "char(36)";
+    case "json":
+      return "json";
+    case "binary":
+      return "longblob";
+    case "vector":
+      return major >= 9 ? "vector(2048)" : "json";
+    case "array":
+      return "json";
+    case "custom":
+      return "text";
+    default:
+      return "text";
+  }
+}
+
+// src/core/dt/dialects/mssql.ts
+var MSSQL_TO_UNIVERSAL = [
+  // Boolean
+  { pattern: /^bit$/i, universalType: "bool", native: true },
+  // Integer types
+  { pattern: /^tinyint$/i, universalType: "int", native: true },
+  { pattern: /^smallint$/i, universalType: "int", native: true },
+  { pattern: /^int$/i, universalType: "int", native: true },
+  // Bigint
+  { pattern: /^bigint$/i, universalType: "bigint", native: true },
+  // Float
+  { pattern: /^float/i, universalType: "float", native: true },
+  { pattern: /^real$/i, universalType: "float", native: true },
+  // Decimal
+  { pattern: /^decimal/i, universalType: "decimal", native: true },
+  { pattern: /^numeric/i, universalType: "decimal", native: true },
+  { pattern: /^money$/i, universalType: "decimal", native: true },
+  { pattern: /^smallmoney$/i, universalType: "decimal", native: true },
+  // UUID
+  { pattern: /^uniqueidentifier$/i, universalType: "uuid", native: true },
+  // Date/time
+  { pattern: /^datetime2/i, universalType: "timestamp", native: true },
+  { pattern: /^datetimeoffset/i, universalType: "timestamp", native: true },
+  { pattern: /^datetime$/i, universalType: "timestamp", native: true },
+  { pattern: /^smalldatetime$/i, universalType: "timestamp", native: true },
+  { pattern: /^date$/i, universalType: "date", native: true },
+  { pattern: /^time/i, universalType: "string", native: true },
+  // Native JSON (SQL Server 2025+)
+  { pattern: /^json$/i, universalType: "json", native: true },
+  // Native VECTOR (SQL Server 2025+)
+  { pattern: /^vector/i, universalType: "vector", native: true },
+  // Binary types
+  { pattern: /^binary/i, universalType: "binary", native: true },
+  { pattern: /^varbinary/i, universalType: "binary", native: true },
+  { pattern: /^image$/i, universalType: "binary", native: true },
+  { pattern: /^rowversion$/i, universalType: "binary", native: true },
+  { pattern: /^timestamp$/i, universalType: "binary", native: true },
+  // XML → custom
+  { pattern: /^xml$/i, universalType: "custom", native: true },
+  { pattern: /^sql_variant$/i, universalType: "custom", native: true },
+  { pattern: /^hierarchyid$/i, universalType: "custom", native: true },
+  // Text types (large variable-length text with smart compression)
+  { pattern: /^nvarchar\(max\)$/i, universalType: "text", native: true },
+  { pattern: /^varchar\(max\)$/i, universalType: "text", native: true },
+  { pattern: /^ntext$/i, universalType: "text", native: true },
+  { pattern: /^text$/i, universalType: "text", native: true },
+  // String types (short text-like types)
+  { pattern: /^nvarchar/i, universalType: "string", native: true },
+  { pattern: /^varchar/i, universalType: "string", native: true },
+  { pattern: /^nchar/i, universalType: "string", native: true },
+  { pattern: /^char/i, universalType: "string", native: true },
+  // Everything else → custom
+  { pattern: /.*/, universalType: "custom", native: false }
+];
+function getUniversalToMssql(universalType, version) {
+  const major = version?.major ?? 2022;
+  switch (universalType) {
+    case "string":
+      return "nvarchar(255)";
+    case "text":
+      return "nvarchar(max)";
+    case "int":
+      return "int";
+    case "bigint":
+      return "bigint";
+    case "float":
+      return "float";
+    case "decimal":
+      return "decimal(38,10)";
+    case "bool":
+      return "bit";
+    case "timestamp":
+      return "datetime2(7)";
+    case "date":
+      return "date";
+    case "uuid":
+      return "uniqueidentifier";
+    case "json":
+      return major >= 2025 ? "json" : "nvarchar(max)";
+    case "binary":
+      return "varbinary(max)";
+    case "vector":
+      return major >= 2025 ? "vector(1998)" : "nvarchar(max)";
+    case "array":
+      return "nvarchar(max)";
+    case "custom":
+      return "nvarchar(max)";
+    default:
+      return "nvarchar(max)";
+  }
+}
+
+// src/core/dt/dialects/index.ts
+function getDialectPatterns(dialect) {
+  switch (dialect) {
+    case "postgres":
+      return POSTGRES_TO_UNIVERSAL;
+    case "mysql":
+      return MYSQL_TO_UNIVERSAL;
+    case "mssql":
+      return MSSQL_TO_UNIVERSAL;
+    default:
+      return [];
+  }
+}
+function getDialectTargetType(universalType, dialect, version) {
+  switch (dialect) {
+    case "postgres":
+      return UNIVERSAL_TO_POSTGRES[universalType] ?? "text";
+    case "mysql":
+      return getUniversalToMysql(universalType, version);
+    case "mssql":
+      return getUniversalToMssql(universalType, version);
+    default:
+      return "text";
+  }
+}
+
+// src/core/dt/type-map.ts
+function toUniversalType(options) {
+  const { dbType, dialect } = options;
+  const patterns = getDialectPatterns(dialect);
+  for (const entry of patterns) {
+    if (entry.pattern.test(dbType)) {
+      return {
+        universalType: entry.universalType,
+        native: entry.native
+      };
+    }
+  }
+  return { universalType: "custom", native: false };
+}
+function toDialectType(options) {
+  const { universalType, dialect, version } = options;
+  return getDialectTargetType(universalType, dialect, version);
+}
+function isEncodedType(type) {
+  return ENCODED_TYPES[type] === true;
+}
+async function queryDatabaseVersion(options) {
+  const { db, dialect } = options;
+  switch (dialect) {
+    case "postgres":
+      return queryPostgresVersion(db);
+    case "mysql":
+      return queryMysqlVersion(db);
+    case "mssql":
+      return queryMssqlVersion(db);
+    default:
+      return [null, new Error(`Unsupported dialect for version detection: ${dialect}`)];
+  }
+}
+async function queryPostgresVersion(db) {
+  const [result, err] = await attempt(
+    () => sql`SELECT version() as version`.execute(db)
+  );
+  if (err) {
+    return [null, err];
+  }
+  const raw = result.rows[0]?.version ?? "";
+  const match = raw.match(/PostgreSQL\s+(\d+)\.(\d+)/i);
+  if (!match) {
+    return [null, new Error(`Cannot parse PostgreSQL version from: ${raw}`)];
+  }
+  return [{
+    dialect: "postgres",
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    raw
+  }, null];
+}
+async function queryMysqlVersion(db) {
+  const [result, err] = await attempt(
+    () => sql`SELECT version() as version`.execute(db)
+  );
+  if (err) {
+    return [null, err];
+  }
+  const raw = result.rows[0]?.version ?? "";
+  const match = raw.match(/^(\d+)\.(\d+)/);
+  if (!match) {
+    return [null, new Error(`Cannot parse MySQL version from: ${raw}`)];
+  }
+  return [{
+    dialect: "mysql",
+    major: parseInt(match[1], 10),
+    minor: parseInt(match[2], 10),
+    raw
+  }, null];
+}
+async function queryMssqlVersion(db) {
+  const [result, err] = await attempt(
+    () => sql`
+            SELECT
+                CAST(SERVERPROPERTY('ProductMajorVersion') AS VARCHAR(10)) as major,
+                CAST(SERVERPROPERTY('ProductMinorVersion') AS VARCHAR(10)) as minor,
+                CAST(SERVERPROPERTY('ProductVersion') AS VARCHAR(50)) as full_version
+        `.execute(db)
+  );
+  if (err) {
+    return [null, err];
+  }
+  const row = result.rows[0];
+  if (!row) {
+    return [null, new Error("No version info returned from MSSQL")];
+  }
+  const internalMajor = parseInt(row.major, 10);
+  const internalMinor = parseInt(row.minor, 10);
+  const marketingYear = mssqlInternalToYear(internalMajor);
+  return [{
+    dialect: "mssql",
+    major: marketingYear,
+    minor: internalMinor,
+    raw: row.full_version
+  }, null];
+}
+function mssqlInternalToYear(internalMajor) {
+  const mapping = {
+    11: 2012,
+    12: 2014,
+    13: 2016,
+    14: 2017,
+    15: 2019,
+    16: 2022,
+    17: 2025
+  };
+  return mapping[internalMajor] ?? internalMajor;
+}
+
+// src/core/dt/schema.ts
+async function buildDtSchema(options) {
+  const { db, dialect, tableName, schema } = options;
+  const kyselyDb = db;
+  let version = options.version;
+  if (!version) {
+    const [detected] = await queryDatabaseVersion({ db: kyselyDb, dialect });
+    version = detected ?? void 0;
+  }
+  const [columns, err] = await queryColumns(kyselyDb, dialect, tableName, schema);
+  if (err) {
+    return [null, err];
+  }
+  const dtColumns = columns.map((col) => {
+    const mapping = toUniversalType({
+      dbType: col.dataType,
+      dialect});
+    const dtCol = {
+      name: col.name,
+      type: mapping.universalType
+    };
+    if (col.dataType.toLowerCase() !== mapping.universalType) {
+      dtCol.sourceType = col.dataType;
+    }
+    if (!col.nullable) {
+      dtCol.nullable = false;
+    }
+    return dtCol;
+  });
+  const dtSchema = {
+    v: FORMAT_VERSION,
+    d: dialect === "postgres" ? "postgresql" : dialect,
+    dv: version ? `${version.major}.${version.minor}` : "unknown",
+    t: tableName,
+    columns: dtColumns
+  };
+  return [dtSchema, null];
+}
+async function validateSchema(options) {
+  const { dtSchema, targetDb, targetDialect, targetVersion } = options;
+  const kyselyDb = targetDb;
+  const tableName = dtSchema.t;
+  const errors = [];
+  const warnings = [];
+  if (!tableName) {
+    errors.push("Schema has no table name (t field)");
+    return [{ valid: false, errors, warnings }, null];
+  }
+  const [targetColumns, queryErr] = await queryColumns(kyselyDb, targetDialect, tableName);
+  if (queryErr) {
+    errors.push(`Target table "${tableName}" not found or inaccessible: ${queryErr.message}`);
+    return [{ valid: false, errors, warnings }, null];
+  }
+  if (targetColumns.length === 0) {
+    errors.push(`Target table "${tableName}" has no columns or does not exist`);
+    return [{ valid: false, errors, warnings }, null];
+  }
+  const targetByName = {};
+  for (const col of targetColumns) {
+    targetByName[col.name] = col;
+  }
+  for (const dtCol of dtSchema.columns) {
+    const targetCol = targetByName[dtCol.name];
+    if (!targetCol) {
+      errors.push(`Column "${dtCol.name}" exists in .dt but not in target table`);
+      continue;
+    }
+    const targetMapping = toUniversalType({
+      dbType: targetCol.dataType,
+      dialect: targetDialect
+    });
+    if (targetMapping.universalType !== dtCol.type) {
+      const targetTypeStr = toDialectType({
+        universalType: dtCol.type,
+        dialect: targetDialect,
+        version: targetVersion
+      });
+      warnings.push(
+        `Column "${dtCol.name}": source type "${dtCol.type}" maps to "${targetTypeStr}" in target, but target column is "${targetCol.dataType}" (${targetMapping.universalType})`
+      );
+    }
+  }
+  return [{
+    valid: errors.length === 0,
+    errors,
+    warnings
+  }, null];
+}
+async function queryColumns(db, dialect, tableName, schema) {
+  switch (dialect) {
+    case "postgres":
+      return queryPostgresColumns(db, tableName, schema ?? "public");
+    case "mysql":
+      return queryMysqlColumns(db, tableName);
+    case "mssql":
+      return queryMssqlColumns(db, tableName);
+    default:
+      return [[], new Error(`Unsupported dialect: ${dialect}`)];
+  }
+}
+async function queryPostgresColumns(db, tableName, schema) {
+  const [result, err] = await attempt(
+    () => sql`
+            SELECT column_name, data_type, udt_name, is_nullable
+            FROM information_schema.columns
+            WHERE table_schema = ${schema}
+            AND table_name = ${tableName}
+            ORDER BY ordinal_position
+        `.execute(db)
+  );
+  if (err) {
+    return [[], err];
+  }
+  return [result.rows.map((r) => ({
+    name: r.column_name,
+    // Use udt_name for more specific types (e.g., 'jsonb' vs 'USER-DEFINED')
+    dataType: r.data_type === "USER-DEFINED" ? r.udt_name : r.data_type,
+    nullable: r.is_nullable === "YES"
+  })), null];
+}
+async function queryMysqlColumns(db, tableName) {
+  const [result, err] = await attempt(
+    () => sql`
+            SELECT COLUMN_NAME, DATA_TYPE, COLUMN_TYPE, IS_NULLABLE
+            FROM INFORMATION_SCHEMA.COLUMNS
+            WHERE TABLE_SCHEMA = DATABASE()
+            AND TABLE_NAME = ${tableName}
+            ORDER BY ORDINAL_POSITION
+        `.execute(db)
+  );
+  if (err) {
+    return [[], err];
+  }
+  return [result.rows.map((r) => ({
+    name: r.COLUMN_NAME,
+    // Use COLUMN_TYPE for precision (e.g., 'tinyint(1)' for bool)
+    dataType: r.COLUMN_TYPE ?? r.DATA_TYPE,
+    nullable: r.IS_NULLABLE === "YES"
+  })), null];
+}
+async function queryMssqlColumns(db, tableName) {
+  const [result, err] = await attempt(
+    () => sql`
+            SELECT
+                c.name,
+                CASE
+                    WHEN TYPE_NAME(c.user_type_id) IN ('varchar', 'nvarchar', 'varbinary')
+                        AND c.max_length = -1
+                    THEN TYPE_NAME(c.user_type_id) + '(max)'
+                    ELSE TYPE_NAME(c.user_type_id)
+                END as type_name,
+                c.is_nullable
+            FROM sys.columns c
+            JOIN sys.tables t ON c.object_id = t.object_id
+            WHERE t.name = ${tableName}
+            ORDER BY c.column_id
+        `.execute(db)
+  );
+  if (err) {
+    return [[], err];
+  }
+  return [result.rows.map((r) => ({
+    name: r.name,
+    dataType: r.type_name,
+    nullable: r.is_nullable === 1
+  })), null];
+}
+
+// src/core/transfer/planner.ts
+async function planTransfer(ctx, options = {}) {
+  observer.emit("transfer:planning", {
+    source: ctx.source.config.name,
+    destination: ctx.destination.config.name
+  });
+  const { dialect } = ctx.source;
+  if (!isTransferSupported(dialect)) {
+    return [null, new Error(`Transfer not supported for dialect: ${dialect}`)];
+  }
+  const crossDialect = ctx.source.dialect !== ctx.destination.dialect;
+  if (!isTransferSupported(ctx.destination.dialect)) {
+    return [null, new Error(`Transfer not supported for dialect: ${ctx.destination.dialect}`)];
+  }
+  const warnings = [];
+  if (crossDialect) {
+    warnings.push(`Cross-dialect transfer: ${ctx.source.dialect} \u2192 ${ctx.destination.dialect}. Type conversion will be applied.`);
+  }
+  const [allTables, tablesErr] = await listUserTables(ctx.source.db, dialect, options);
+  if (tablesErr) {
+    return [null, tablesErr];
+  }
+  const [fkRelations, fkErr] = await getForeignKeyRelations(ctx.source.db, dialect);
+  if (fkErr) {
+    return [null, fkErr];
+  }
+  const dependencyMap = buildDependencyMap(allTables, fkRelations);
+  const [sortedNames, sortErr] = topologicalSort(allTables.map((t) => t.name), dependencyMap);
+  if (sortErr) {
+    warnings.push(`Circular FK dependency detected: ${sortErr.message}. Using original order.`);
+  }
+  const tablesByName = {};
+  for (const t of allTables) {
+    tablesByName[t.name] = t;
+  }
+  const orderedNames = sortErr ? allTables.map((t) => t.name) : sortedNames;
+  const tablePlans = [];
+  for (const name of orderedNames) {
+    const meta = tablesByName[name];
+    if (!meta) continue;
+    tablePlans.push({
+      name: meta.name,
+      schema: meta.schema,
+      rowCount: meta.rowCount,
+      hasIdentity: meta.hasIdentity,
+      identityColumn: meta.identityColumn,
+      primaryKey: meta.primaryKey,
+      columns: meta.columns,
+      dependsOn: dependencyMap.get(name) ?? []
+    });
+  }
+  const [destTables, destErr] = await listUserTables(ctx.destination.db, dialect, { tables: options.tables });
+  if (destErr) {
+    return [null, new Error(`Failed to read destination schema: ${destErr.message}`)];
+  }
+  const destTableNames = new Set(destTables.map((t) => t.name));
+  for (const plan2 of tablePlans) {
+    if (!destTableNames.has(plan2.name)) {
+      warnings.push(`Table "${plan2.name}" exists in source but not destination`);
+    }
+  }
+  if (crossDialect) {
+    for (const tablePlan of tablePlans) {
+      const [dtSchema] = await buildDtSchema({
+        db: ctx.source.db,
+        dialect: ctx.source.dialect,
+        tableName: tablePlan.name,
+        schema: tablePlan.schema
+      });
+      if (dtSchema) {
+        tablePlan.columnTypes = dtSchema.columns;
+      }
+    }
+  }
+  const sameServer = crossDialect ? false : isSameServer(ctx.source.config.connection, ctx.destination.config.connection);
+  const estimatedRows = tablePlans.reduce((sum, t) => sum + t.rowCount, 0);
+  const plan = {
+    tables: tablePlans,
+    sameServer,
+    estimatedRows,
+    warnings,
+    crossDialect,
+    sourceDialect: ctx.source.dialect,
+    destinationDialect: ctx.destination.dialect
+  };
+  observer.emit("transfer:plan:ready", {
+    sameServer,
+    tableCount: tablePlans.length,
+    estimatedRows,
+    warnings
+  });
+  return [plan, null];
+}
+async function listUserTables(db, dialect, options = {}) {
+  const [tables, err] = await attempt(() => queryTables(db, dialect));
+  if (err) {
+    return [[], err];
+  }
+  let filtered = tables.filter((t) => !t.name.startsWith("__noorm_"));
+  if (options.tables && options.tables.length > 0) {
+    const requested = new Set(options.tables);
+    filtered = filtered.filter((t) => requested.has(t.name));
+  }
+  return [filtered, null];
+}
+async function queryTables(db, dialect) {
+  switch (dialect) {
+    case "postgres":
+      return queryPostgresTables(db);
+    case "mysql":
+      return queryMysqlTables(db);
+    case "mssql":
+      return queryMssqlTables(db);
+    default:
+      return [];
+  }
+}
+async function queryPostgresTables(db) {
+  const result = await sql`
+        SELECT
+            t.table_name,
+            t.table_schema,
+            COALESCE(c.reltuples::bigint::text, '0') as row_estimate,
+            (
+                SELECT string_agg(column_name, ',' ORDER BY ordinal_position)
+                FROM information_schema.columns col
+                WHERE col.table_schema = t.table_schema
+                AND col.table_name = t.table_name
+            ) as column_names,
+            (
+                SELECT column_name
+                FROM information_schema.columns col
+                WHERE col.table_schema = t.table_schema
+                AND col.table_name = t.table_name
+                AND (col.column_default LIKE 'nextval%' OR col.is_identity = 'YES')
+                LIMIT 1
+            ) as identity_column,
+            (
+                SELECT string_agg(kcu.column_name, ',' ORDER BY kcu.ordinal_position)
+                FROM information_schema.table_constraints tc
+                JOIN information_schema.key_column_usage kcu
+                    ON tc.constraint_name = kcu.constraint_name
+                    AND tc.table_schema = kcu.table_schema
+                WHERE tc.constraint_type = 'PRIMARY KEY'
+                AND tc.table_schema = t.table_schema
+                AND tc.table_name = t.table_name
+            ) as pk_columns
+        FROM information_schema.tables t
+        LEFT JOIN pg_class c ON c.relname = t.table_name
+        LEFT JOIN pg_namespace n ON n.oid = c.relnamespace AND n.nspname = t.table_schema
+        WHERE t.table_schema NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+        AND t.table_type = 'BASE TABLE'
+        ORDER BY t.table_schema, t.table_name
+    `.execute(db);
+  return result.rows.map((row) => ({
+    name: row.table_name,
+    schema: row.table_schema,
+    rowCount: Math.max(0, parseInt(row.row_estimate, 10)),
+    hasIdentity: row.identity_column !== null,
+    identityColumn: row.identity_column ?? void 0,
+    primaryKey: row.pk_columns ? row.pk_columns.split(",") : [],
+    columns: row.column_names ? row.column_names.split(",") : []
+  }));
+}
+async function queryMysqlTables(db) {
+  const result = await sql`
+        SELECT
+            t.TABLE_NAME as table_name,
+            t.TABLE_ROWS as row_estimate,
+            (
+                SELECT GROUP_CONCAT(COLUMN_NAME ORDER BY ORDINAL_POSITION)
+                FROM INFORMATION_SCHEMA.COLUMNS c
+                WHERE c.TABLE_SCHEMA = t.TABLE_SCHEMA
+                AND c.TABLE_NAME = t.TABLE_NAME
+            ) as column_names,
+            (
+                SELECT COLUMN_NAME
+                FROM INFORMATION_SCHEMA.COLUMNS c
+                WHERE c.TABLE_SCHEMA = t.TABLE_SCHEMA
+                AND c.TABLE_NAME = t.TABLE_NAME
+                AND c.EXTRA LIKE '%auto_increment%'
+                LIMIT 1
+            ) as identity_column,
+            (
+                SELECT GROUP_CONCAT(COLUMN_NAME ORDER BY ORDINAL_POSITION)
+                FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+                WHERE kcu.TABLE_SCHEMA = t.TABLE_SCHEMA
+                AND kcu.TABLE_NAME = t.TABLE_NAME
+                AND kcu.CONSTRAINT_NAME = 'PRIMARY'
+            ) as pk_columns
+        FROM INFORMATION_SCHEMA.TABLES t
+        WHERE t.TABLE_SCHEMA = DATABASE()
+        AND t.TABLE_TYPE = 'BASE TABLE'
+        ORDER BY t.TABLE_NAME
+    `.execute(db);
+  return result.rows.map((row) => ({
+    name: row.table_name,
+    rowCount: Math.max(0, parseInt(row.row_estimate ?? "0", 10)),
+    hasIdentity: row.identity_column !== null,
+    identityColumn: row.identity_column ?? void 0,
+    primaryKey: row.pk_columns ? row.pk_columns.split(",") : [],
+    columns: row.column_names ? row.column_names.split(",") : []
+  }));
+}
+async function queryMssqlTables(db) {
+  const result = await sql`
+        SELECT
+            t.name as table_name,
+            s.name as table_schema,
+            COALESCE(SUM(p.rows), 0) as row_estimate,
+            (
+                SELECT STRING_AGG(c.name, ',') WITHIN GROUP (ORDER BY c.column_id)
+                FROM sys.columns c
+                WHERE c.object_id = t.object_id
+            ) as column_names,
+            (
+                SELECT c.name
+                FROM sys.columns c
+                WHERE c.object_id = t.object_id
+                AND c.is_identity = 1
+            ) as identity_column,
+            (
+                SELECT STRING_AGG(c.name, ',') WITHIN GROUP (ORDER BY ic.key_ordinal)
+                FROM sys.indexes i
+                JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+                JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+                WHERE i.object_id = t.object_id
+                AND i.is_primary_key = 1
+            ) as pk_columns
+        FROM sys.tables t
+        JOIN sys.schemas s ON t.schema_id = s.schema_id
+        LEFT JOIN sys.partitions p ON t.object_id = p.object_id AND p.index_id IN (0, 1)
+        WHERE t.is_ms_shipped = 0
+        GROUP BY t.object_id, t.name, s.name
+        ORDER BY s.name, t.name
+    `.execute(db);
+  return result.rows.map((row) => ({
+    name: row.table_name,
+    schema: row.table_schema,
+    rowCount: Math.max(0, parseInt(row.row_estimate ?? "0", 10)),
+    hasIdentity: row.identity_column !== null,
+    identityColumn: row.identity_column ?? void 0,
+    primaryKey: row.pk_columns ? row.pk_columns.split(",") : [],
+    columns: row.column_names ? row.column_names.split(",") : []
+  }));
+}
+async function getForeignKeyRelations(db, dialect) {
+  let queryFn;
+  switch (dialect) {
+    case "postgres":
+      queryFn = () => queryPostgresFKs(db);
+      break;
+    case "mysql":
+      queryFn = () => queryMysqlFKs(db);
+      break;
+    case "mssql":
+      queryFn = () => queryMssqlFKs(db);
+      break;
+    default:
+      return [[], null];
+  }
+  const [relations, err] = await attempt(queryFn);
+  if (err) {
+    return [[], err];
+  }
+  return [relations, null];
+}
+async function queryPostgresFKs(db) {
+  const result = await sql`
+        SELECT DISTINCT
+            tc.table_name as from_table,
+            ccu.table_name as to_table
+        FROM information_schema.table_constraints tc
+        JOIN information_schema.constraint_column_usage ccu
+            ON tc.constraint_name = ccu.constraint_name
+            AND tc.table_schema = ccu.table_schema
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_schema NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+    `.execute(db);
+  return result.rows.map((r) => ({
+    fromTable: r.from_table,
+    toTable: r.to_table
+  }));
+}
+async function queryMysqlFKs(db) {
+  const result = await sql`
+        SELECT DISTINCT
+            TABLE_NAME as from_table,
+            REFERENCED_TABLE_NAME as to_table
+        FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
+        WHERE TABLE_SCHEMA = DATABASE()
+        AND REFERENCED_TABLE_NAME IS NOT NULL
+    `.execute(db);
+  return result.rows.map((r) => ({
+    fromTable: r.from_table,
+    toTable: r.to_table
+  }));
+}
+async function queryMssqlFKs(db) {
+  const result = await sql`
+        SELECT DISTINCT
+            OBJECT_NAME(fk.parent_object_id) as from_table,
+            OBJECT_NAME(fk.referenced_object_id) as to_table
+        FROM sys.foreign_keys fk
+    `.execute(db);
+  return result.rows.map((r) => ({
+    fromTable: r.from_table,
+    toTable: r.to_table
+  }));
+}
+function buildDependencyMap(tables, relations) {
+  const tableNames = new Set(tables.map((t) => t.name));
+  const deps = /* @__PURE__ */ new Map();
+  for (const name of tableNames) {
+    deps.set(name, []);
+  }
+  for (const rel of relations) {
+    if (tableNames.has(rel.fromTable) && tableNames.has(rel.toTable)) {
+      const current = deps.get(rel.fromTable) ?? [];
+      if (!current.includes(rel.toTable) && rel.fromTable !== rel.toTable) {
+        current.push(rel.toTable);
+        deps.set(rel.fromTable, current);
+      }
+    }
+  }
+  return deps;
+}
+function topologicalSort(nodes, deps) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(node) {
+    if (visited.has(node)) return null;
+    if (visiting.has(node)) {
+      return new Error(`Circular dependency involving "${node}"`);
+    }
+    visiting.add(node);
+    const nodeDeps = deps.get(node) ?? [];
+    for (const dep of nodeDeps) {
+      const err = visit(dep);
+      if (err) return err;
+    }
+    visiting.delete(node);
+    visited.add(node);
+    result.push(node);
+    return null;
+  }
+  for (const node of nodes) {
+    const err = visit(node);
+    if (err) return [[], err];
+  }
+  return [result, null];
+}
+var DEFAULT_BATCH_SIZE = 100;
+var DEFAULT_MAX_BATCH_BYTES = gigabytes(1);
+var DtStreamer = class {
+  #sourceDialect;
+  #sourceVersion;
+  #targetDialect;
+  #targetVersion;
+  #columns;
+  #batchSize;
+  #maxBatchBytes;
+  /**
+   * Create a new DtStreamer for cross-dialect conversion.
+   *
+   * @param options - Source/target dialects, columns, and batch limits
+   */
+  constructor(options) {
+    this.#sourceDialect = options.sourceDialect;
+    this.#sourceVersion = options.sourceVersion;
+    this.#targetDialect = options.targetDialect;
+    this.#targetVersion = options.targetVersion;
+    this.#columns = options.columns;
+    this.#batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE;
+    this.#maxBatchBytes = options.maxBatchBytes ?? DEFAULT_MAX_BATCH_BYTES;
+  }
+  /**
+   * The soft batch size limit.
+   */
+  get batchSize() {
+    return this.#batchSize;
+  }
+  /**
+   * Convert a batch of source-dialect rows to target-dialect rows.
+   *
+   * Performs in-memory type conversion without any file I/O or encoding.
+   *
+   * @param rows - Source database rows
+   * @returns Target-dialect rows ready for insertion
+   */
+  convertBatch(rows) {
+    const result = [];
+    for (const row of rows) {
+      result.push(this.#convertRow(row));
+    }
+    return result;
+  }
+  /**
+   * Check if accumulated rows should be flushed.
+   *
+   * Returns true when row count exceeds batchSize OR estimated memory
+   * exceeds maxBatchBytes. Prevents OOM on tables with large values.
+   *
+   * @param rows - Currently accumulated rows
+   * @returns True if the batch should be flushed
+   */
+  shouldFlush(rows) {
+    if (rows.length >= this.#batchSize) {
+      return true;
+    }
+    return estimateRowsBytes(rows) >= this.#maxBatchBytes;
+  }
+  /**
+   * Convert a single row from source to target dialect.
+   */
+  #convertRow(row) {
+    const result = {};
+    for (const col of this.#columns) {
+      const value = row[col.name];
+      if (value === null || value === void 0) {
+        result[col.name] = null;
+        continue;
+      }
+      if (isEncodedType(col.type)) {
+        result[col.name] = this.#convertEncodedValue(value, col.type);
+      } else {
+        result[col.name] = this.#convertSimpleValue(value, col.type);
+      }
+    }
+    return result;
+  }
+  /**
+   * Convert an encoded-type value between dialects.
+   *
+   * No serialization overhead: works directly with native objects.
+   */
+  #convertEncodedValue(value, type) {
+    switch (type) {
+      case "json":
+        return this.#convertJson(value);
+      case "text":
+        return value;
+      case "binary":
+        return value;
+      case "vector":
+        return this.#convertVector(value);
+      case "array":
+        return this.#convertArray(value);
+      case "custom":
+        if (this.#targetDialect !== this.#sourceDialect && typeof value === "object") {
+          return JSON.stringify(value);
+        }
+        return value;
+      default:
+        return value;
+    }
+  }
+  /**
+   * Convert JSON between dialects.
+   */
+  #convertJson(value) {
+    if (this.#targetDialect === "mssql") {
+      const major = this.#targetVersion?.major ?? 2022;
+      if (major < 2025) {
+        return typeof value === "string" ? value : JSON.stringify(value);
+      }
+    }
+    if (this.#sourceDialect === "mssql" && typeof value === "string") {
+      const major = this.#sourceVersion?.major ?? 2022;
+      if (major < 2025) {
+        return JSON.parse(value);
+      }
+    }
+    return value;
+  }
+  /**
+   * Convert vector between dialects.
+   */
+  #convertVector(value) {
+    let arr;
+    if (typeof value === "string") {
+      const trimmed = value.replace(/^\[/, "").replace(/\]$/, "");
+      arr = trimmed.split(",").map(Number);
+    } else {
+      arr = value;
+    }
+    if (this.#targetDialect === "postgres") {
+      return Array.isArray(arr) ? `[${arr.join(",")}]` : String(value);
+    }
+    if (this.#targetDialect === "mysql") {
+      const major = this.#targetVersion?.major ?? 8;
+      if (major >= 9) {
+        return Array.isArray(arr) ? `[${arr.join(",")}]` : String(value);
+      }
+      return Array.isArray(arr) ? JSON.stringify(arr) : String(value);
+    }
+    return Array.isArray(arr) ? JSON.stringify(arr) : String(value);
+  }
+  /**
+   * Convert array between dialects.
+   */
+  #convertArray(value) {
+    if (this.#targetDialect === "postgres") {
+      if (typeof value === "string") return JSON.parse(value);
+      return value;
+    }
+    if (Array.isArray(value)) return JSON.stringify(value);
+    return value;
+  }
+  /**
+   * Convert a simple-type value between dialects.
+   */
+  #convertSimpleValue(value, type) {
+    switch (type) {
+      case "bool":
+        if (this.#targetDialect === "mssql" || this.#targetDialect === "mysql") {
+          if (typeof value === "boolean") return value ? 1 : 0;
+        } else if (this.#sourceDialect === "mssql" || this.#sourceDialect === "mysql") {
+          if (typeof value === "number") return value !== 0;
+        }
+        return value;
+      case "uuid":
+        return value;
+      default:
+        return value;
+    }
+  }
+};
+function estimateRowsBytes(rows) {
+  let total = 0;
+  for (const row of rows) {
+    for (const key in row) {
+      const val = row[key];
+      if (val === null || val === void 0) {
+        total += 8;
+      } else if (Buffer.isBuffer(val)) {
+        total += val.length;
+      } else if (typeof val === "string") {
+        total += val.length * 2;
+      } else if (typeof val === "object") {
+        total += JSON.stringify(val).length * 2;
+      } else {
+        total += 8;
+      }
+    }
+  }
+  return total;
+}
+
+// src/core/transfer/executor.ts
+var DEFAULT_BATCH_SIZE2 = 1e3;
+async function executeTransfer(ctx, plan, options = {}) {
+  const startTime = Date.now();
+  const { dialect: _srcDialect } = ctx.source;
+  const destDialect = ctx.destination.dialect;
+  const ops = getTransferOperations(destDialect);
+  if (!ops) {
+    return [null, new Error(`Unsupported dialect: ${destDialect}`)];
+  }
+  const tableResults = [];
+  let totalRows = 0;
+  let hasFailures = false;
+  observer.emit("transfer:starting", {
+    tableCount: plan.tables.length,
+    sameServer: plan.sameServer
+  });
+  if (options.disableForeignKeys !== false) {
+    const [, disableErr] = await attempt(
+      () => ops.executeDisableFK(
+        ctx.destination.db,
+        plan.tables.map((t) => t.name)
+      )
+    );
+    if (disableErr) {
+      return [null, new Error(`Failed to disable FK checks: ${disableErr.message}`)];
+    }
+  }
+  for (let i = 0; i < plan.tables.length; i++) {
+    const tablePlan = plan.tables[i];
+    observer.emit("transfer:table:before", {
+      table: tablePlan.name,
+      index: i,
+      total: plan.tables.length,
+      rowCount: tablePlan.rowCount
+    });
+    const tableStart = Date.now();
+    let result2;
+    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;
+    if (useSameServer) {
+      [tableResult, tableErr] = await transferTableSameServer(
+        ctx,
+        tablePlan,
+        options,
+        ops
+      );
+    } else if (useCrossDialect) {
+      [tableResult, tableErr] = await transferTableCrossDialect(
+        ctx,
+        tablePlan,
+        plan,
+        options
+      );
+    } else {
+      [tableResult, tableErr] = await transferTableCrossServer(
+        ctx,
+        tablePlan,
+        options,
+        ops
+      );
+    }
+    if (tableErr) {
+      result2 = {
+        table: tablePlan.name,
+        status: "failed",
+        rowsTransferred: 0,
+        rowsSkipped: 0,
+        durationMs: Date.now() - tableStart,
+        error: tableErr.message
+      };
+      hasFailures = true;
+    } else {
+      result2 = tableResult;
+    }
+    tableResults.push(result2);
+    totalRows += result2.rowsTransferred;
+    observer.emit("transfer:table:after", {
+      table: tablePlan.name,
+      status: result2.status,
+      rowsTransferred: result2.rowsTransferred,
+      rowsSkipped: result2.rowsSkipped,
+      durationMs: result2.durationMs,
+      error: result2.error
+    });
+  }
+  if (options.disableForeignKeys !== false) {
+    const [, enableErr] = await attempt(
+      () => ops.executeEnableFK(
+        ctx.destination.db,
+        plan.tables.map((t) => t.name)
+      )
+    );
+    if (enableErr) {
+      observer.emit("error", {
+        source: "transfer",
+        error: enableErr,
+        context: { phase: "enable-fk" }
+      });
+    }
+  }
+  const durationMs = Date.now() - startTime;
+  const allSuccess = tableResults.every((r) => r.status === "success");
+  const result = {
+    status: hasFailures ? allSuccess ? "partial" : "failed" : "success",
+    tables: tableResults,
+    totalRows,
+    durationMs
+  };
+  observer.emit("transfer:complete", {
+    status: result.status,
+    totalRows,
+    tableCount: plan.tables.length,
+    durationMs
+  });
+  return [result, null];
+}
+async function transferTableSameServer(ctx, plan, options, ops) {
+  const startTime = Date.now();
+  if (!ops) {
+    return [null, new Error("No dialect operations")];
+  }
+  if (options.truncateFirst) {
+    const [, truncateErr] = await truncateTable(
+      ctx.destination.db,
+      ctx.destination.dialect,
+      plan.name
+    );
+    if (truncateErr) {
+      return [null, new Error(`Failed to truncate: ${truncateErr.message}`)];
+    }
+  }
+  if (options.preserveIdentity !== false && plan.hasIdentity) {
+    const enableSql = ops.getEnableIdentityInsertSql(plan.name);
+    if (enableSql) {
+      const [, enableErr] = await attempt(
+        () => sql.raw(enableSql).execute(ctx.destination.db)
+      );
+      if (enableErr) {
+        return [null, new Error(`Failed to enable identity insert: ${enableErr.message}`)];
+      }
+    }
+  }
+  const transferSql = ops.buildDirectTransfer(
+    ctx.source.config.connection.database,
+    plan.name,
+    plan.name,
+    plan.columns,
+    plan.schema,
+    plan.schema
+  );
+  const [, transferErr] = await attempt(
+    () => sql.raw(transferSql).execute(ctx.destination.db)
+  );
+  if (options.preserveIdentity !== false && plan.hasIdentity) {
+    const disableSql = ops.getDisableIdentityInsertSql(plan.name);
+    if (disableSql) {
+      await attempt(() => sql.raw(disableSql).execute(ctx.destination.db));
+    }
+    if (plan.identityColumn) {
+      const resetSql = ops.getResetSequenceSql(plan.name, plan.identityColumn, plan.schema);
+      if (resetSql) {
+        await attempt(() => sql.raw(resetSql).execute(ctx.destination.db));
+      }
+    }
+  }
+  if (transferErr) {
+    return [null, new Error(`Transfer failed: ${transferErr.message}`)];
+  }
+  const rowsTransferred = plan.rowCount;
+  observer.emit("transfer:table:progress", {
+    table: plan.name,
+    rowsTransferred,
+    rowsTotal: plan.rowCount,
+    rowsSkipped: 0
+  });
+  return [{
+    table: plan.name,
+    status: "success",
+    rowsTransferred,
+    rowsSkipped: 0,
+    durationMs: Date.now() - startTime
+  }, null];
+}
+async function transferTableCrossServer(ctx, plan, options, ops) {
+  const startTime = Date.now();
+  const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE2;
+  const strategy = options.onConflict ?? "fail";
+  if (!ops) {
+    return [null, new Error("No dialect operations")];
+  }
+  if (options.truncateFirst) {
+    const [, truncateErr] = await truncateTable(
+      ctx.destination.db,
+      ctx.destination.dialect,
+      plan.name
+    );
+    if (truncateErr) {
+      return [null, new Error(`Failed to truncate: ${truncateErr.message}`)];
+    }
+  }
+  if (options.preserveIdentity !== false && plan.hasIdentity) {
+    const enableSql = ops.getEnableIdentityInsertSql(plan.name);
+    if (enableSql) {
+      const [, enableErr] = await attempt(
+        () => sql.raw(enableSql).execute(ctx.destination.db)
+      );
+      if (enableErr) {
+        return [null, new Error(`Failed to enable identity insert: ${enableErr.message}`)];
+      }
+    }
+  }
+  let rowsTransferred = 0;
+  let rowsSkipped = 0;
+  let offset = 0;
+  let transferError = null;
+  while (true) {
+    const [rows, fetchErr] = await attempt(
+      () => fetchBatch(
+        ctx.source.db,
+        ctx.source.dialect,
+        plan.name,
+        plan.columns,
+        batchSize,
+        offset,
+        plan.schema
+      )
+    );
+    if (fetchErr) {
+      transferError = new Error(`Failed to fetch batch: ${fetchErr.message}`);
+      break;
+    }
+    if (rows.length === 0) {
+      break;
+    }
+    const [batchResult, insertErr] = await insertBatch(
+      ctx.destination.db,
+      ctx.destination.dialect,
+      plan.name,
+      plan.columns,
+      plan.primaryKey,
+      rows,
+      strategy,
+      ops
+    );
+    if (insertErr) {
+      transferError = new Error(`Failed to insert batch: ${insertErr.message}`);
+      break;
+    }
+    rowsTransferred += batchResult.inserted;
+    rowsSkipped += batchResult.skipped;
+    offset += rows.length;
+    observer.emit("transfer:table:progress", {
+      table: plan.name,
+      rowsTransferred,
+      rowsTotal: plan.rowCount,
+      rowsSkipped
+    });
+    if (rows.length < batchSize) {
+      break;
+    }
+  }
+  if (options.preserveIdentity !== false && plan.hasIdentity) {
+    const disableSql = ops.getDisableIdentityInsertSql(plan.name);
+    if (disableSql) {
+      await attempt(() => sql.raw(disableSql).execute(ctx.destination.db));
+    }
+    if (plan.identityColumn) {
+      const resetSql = ops.getResetSequenceSql(plan.name, plan.identityColumn, plan.schema);
+      if (resetSql) {
+        await attempt(() => sql.raw(resetSql).execute(ctx.destination.db));
+      }
+    }
+  }
+  if (transferError) {
+    return [null, transferError];
+  }
+  return [{
+    table: plan.name,
+    status: "success",
+    rowsTransferred,
+    rowsSkipped,
+    durationMs: Date.now() - startTime
+  }, null];
+}
+async function transferTableCrossDialect(ctx, plan, transferPlan, options) {
+  const startTime = Date.now();
+  const batchSize = options.batchSize ?? DEFAULT_BATCH_SIZE2;
+  const destOps = getTransferOperations(ctx.destination.dialect);
+  if (!destOps || !plan.columnTypes) {
+    return [null, new Error("Missing dialect operations or column types for cross-dialect transfer")];
+  }
+  const [srcVersion] = await queryDatabaseVersion({ db: ctx.source.db, dialect: ctx.source.dialect });
+  const [dstVersion] = await queryDatabaseVersion({ db: ctx.destination.db, dialect: ctx.destination.dialect });
+  const streamer = new DtStreamer({
+    sourceDialect: ctx.source.dialect,
+    sourceVersion: srcVersion ?? void 0,
+    targetDialect: ctx.destination.dialect,
+    targetVersion: dstVersion ?? void 0,
+    columns: plan.columnTypes,
+    batchSize
+  });
+  if (options.truncateFirst) {
+    const [, truncateErr] = await truncateTable(
+      ctx.destination.db,
+      ctx.destination.dialect,
+      plan.name
+    );
+    if (truncateErr) {
+      return [null, new Error(`Failed to truncate: ${truncateErr.message}`)];
+    }
+  }
+  if (options.preserveIdentity !== false && plan.hasIdentity) {
+    const enableSql = destOps.getEnableIdentityInsertSql(plan.name);
+    if (enableSql) {
+      const [, enableErr] = await attempt(
+        () => sql.raw(enableSql).execute(ctx.destination.db)
+      );
+      if (enableErr) {
+        return [null, new Error(`Failed to enable identity insert: ${enableErr.message}`)];
+      }
+    }
+  }
+  let rowsTransferred = 0;
+  let rowsSkipped = 0;
+  let offset = 0;
+  let transferError = null;
+  observer.emit("dt:stream:start", {
+    table: plan.name,
+    sourceDialect: ctx.source.dialect,
+    targetDialect: ctx.destination.dialect
+  });
+  while (true) {
+    const [rows, fetchErr] = await attempt(
+      () => fetchBatch(
+        ctx.source.db,
+        ctx.source.dialect,
+        plan.name,
+        plan.columns,
+        batchSize,
+        offset,
+        plan.schema
+      )
+    );
+    if (fetchErr) {
+      transferError = new Error(`Failed to fetch batch: ${fetchErr.message}`);
+      break;
+    }
+    if (rows.length === 0) break;
+    const convertedRows = streamer.convertBatch(rows);
+    for (const row of convertedRows) {
+      const [, insertErr] = await attempt(
+        () => ctx.destination.db.insertInto(plan.name).values(row).execute()
+      );
+      if (insertErr) {
+        const lower = insertErr.message.toLowerCase();
+        const isDuplicate = lower.includes("duplicate") || lower.includes("unique") || lower.includes("primary key");
+        if (isDuplicate && options.onConflict === "skip") {
+          rowsSkipped++;
+        } else if (options.onConflict !== "fail") {
+          rowsSkipped++;
+        } else {
+          transferError = new Error(`Failed to insert row: ${insertErr.message}`);
+          break;
+        }
+      } else {
+        rowsTransferred++;
+      }
+    }
+    if (transferError) break;
+    offset += rows.length;
+    observer.emit("transfer:table:progress", {
+      table: plan.name,
+      rowsTransferred,
+      rowsTotal: plan.rowCount,
+      rowsSkipped
+    });
+    observer.emit("dt:stream:progress", {
+      table: plan.name,
+      rowsConverted: rowsTransferred + rowsSkipped
+    });
+    if (rows.length < batchSize) break;
+  }
+  if (options.preserveIdentity !== false && plan.hasIdentity) {
+    const disableSql = destOps.getDisableIdentityInsertSql(plan.name);
+    if (disableSql) {
+      await attempt(() => sql.raw(disableSql).execute(ctx.destination.db));
+    }
+  }
+  const durationMs = Date.now() - startTime;
+  observer.emit("dt:stream:complete", {
+    table: plan.name,
+    rowsConverted: rowsTransferred + rowsSkipped,
+    durationMs
+  });
+  if (transferError) {
+    return [null, transferError];
+  }
+  return [{
+    table: plan.name,
+    status: "success",
+    rowsTransferred,
+    rowsSkipped,
+    durationMs
+  }, null];
+}
+async function fetchBatch(db, dialect, table, columns, limit, offset, _schema) {
+  const quoteIdent4 = dialect === "mssql" ? (c) => `[${c}]` : dialect === "mysql" ? (c) => `\`${c}\`` : (c) => `"${c}"`;
+  const columnList = columns.map(quoteIdent4).join(", ");
+  if (dialect === "mssql") {
+    const orderCol = quoteIdent4(columns[0]);
+    const result2 = await sql`
+            SELECT ${sql.raw(columnList)}
+            FROM ${sql.table(table)}
+            ORDER BY ${sql.raw(orderCol)}
+            OFFSET ${offset} ROWS
+            FETCH NEXT ${limit} ROWS ONLY
+        `.execute(db);
+    return result2.rows;
+  }
+  const result = await sql`
+        SELECT ${sql.raw(columnList)}
+        FROM ${sql.table(table)}
+        LIMIT ${limit}
+        OFFSET ${offset}
+    `.execute(db);
+  return result.rows;
+}
+async function insertBatch(db, dialect, table, columns, primaryKey, rows, strategy, ops) {
+  if (rows.length === 0) {
+    return [{ inserted: 0, skipped: 0 }, null];
+  }
+  if ((dialect === "mssql" || dialect === "mysql") && strategy !== "fail" && primaryKey.length > 0 && ops) {
+    return insertBatchRawSql(db, dialect, table, columns, primaryKey, rows, strategy, ops);
+  }
+  let inserted = 0;
+  let skipped = 0;
+  for (const row of rows) {
+    const query = db.insertInto(table).values(row);
+    if (strategy === "skip" && primaryKey.length > 0) {
+      const [, err] = await attempt(
+        () => query.onConflict((oc) => oc.columns(primaryKey).doNothing()).execute()
+      );
+      if (err) {
+        if (isDuplicateKeyError(err.message)) {
+          skipped++;
+        } else {
+          return [{ inserted, skipped }, err];
+        }
+      } else {
+        inserted++;
+      }
+    } else if (strategy === "update" && primaryKey.length > 0) {
+      const updateSet = {};
+      for (const col of columns) {
+        if (!primaryKey.includes(col)) {
+          updateSet[col] = row[col];
+        }
+      }
+      const [, err] = await attempt(
+        () => query.onConflict((oc) => oc.columns(primaryKey).doUpdateSet(updateSet)).execute()
+      );
+      if (err) {
+        if (isDuplicateKeyError(err.message)) {
+          skipped++;
+        } else {
+          return [{ inserted, skipped }, err];
+        }
+      } else {
+        inserted++;
+      }
+    } else {
+      const [, err] = await attempt(() => query.execute());
+      if (err) {
+        if (strategy === "fail") {
+          return [{ inserted, skipped }, err];
+        }
+        skipped++;
+      } else {
+        inserted++;
+      }
+    }
+  }
+  return [{ inserted, skipped }, null];
+}
+async function insertBatchRawSql(db, dialect, table, columns, primaryKey, rows, strategy, ops) {
+  let inserted = 0;
+  let skipped = 0;
+  const sqlTemplate = ops.buildConflictInsert(table, columns, primaryKey, strategy);
+  for (const row of rows) {
+    const values = columns.map((col) => row[col]);
+    const sqlParts = [];
+    const sqlValues = [];
+    if (dialect === "mssql") {
+      let match;
+      const paramRegex = /@p(\d+)/g;
+      let lastIndex = 0;
+      paramRegex.lastIndex = 0;
+      while ((match = paramRegex.exec(sqlTemplate)) !== null) {
+        sqlParts.push(sqlTemplate.slice(lastIndex, match.index));
+        sqlValues.push(values[parseInt(match[1], 10)]);
+        lastIndex = match.index + match[0].length;
+      }
+      sqlParts.push(sqlTemplate.slice(lastIndex));
+    } else {
+      const parts = sqlTemplate.split("?");
+      let paramIdx = 0;
+      for (let i = 0; i < parts.length; i++) {
+        sqlParts.push(parts[i]);
+        if (i < parts.length - 1) {
+          sqlValues.push(values[paramIdx++]);
+        }
+      }
+    }
+    const finalSql = sql.join(
+      sqlParts.map((part, i) => {
+        if (i < sqlValues.length) {
+          return sql`${sql.raw(part)}${sql.val(sqlValues[i])}`;
+        }
+        return sql.raw(part);
+      }),
+      sql.raw("")
+    );
+    const [, err] = await attempt(() => finalSql.execute(db));
+    if (err) {
+      if (isDuplicateKeyError(err.message)) {
+        skipped++;
+      } else {
+        return [{ inserted, skipped }, err];
+      }
+    } else {
+      inserted++;
+    }
+  }
+  return [{ inserted, skipped }, null];
+}
+function isDuplicateKeyError(message) {
+  const lower = message.toLowerCase();
+  return lower.includes("duplicate") || lower.includes("unique constraint") || lower.includes("primary key") || lower.includes("violates unique") || lower.includes("cannot insert duplicate") || lower.includes("duplicate entry");
+}
+async function truncateTable(db, dialect, table) {
+  let truncateSql;
+  switch (dialect) {
+    case "postgres":
+      truncateSql = `TRUNCATE TABLE "${table}" CASCADE`;
+      break;
+    case "mssql":
+      truncateSql = `DELETE FROM [${table}]`;
+      break;
+    case "mysql":
+      truncateSql = `TRUNCATE TABLE \`${table}\``;
+      break;
+    default:
+      truncateSql = `TRUNCATE TABLE ${table}`;
+  }
+  const [, err] = await attempt(() => sql.raw(truncateSql).execute(db));
+  return [void 0, err];
+}
+
+// src/core/transfer/index.ts
+async function transferData(sourceConfig, destConfig, options = {}) {
+  const srcDialect = sourceConfig.connection.dialect;
+  const dstDialect = destConfig.connection.dialect;
+  if (!isTransferSupported(srcDialect)) {
+    return [null, new Error(`Transfer not supported for dialect: ${srcDialect}. Supported: ${TRANSFER_SUPPORTED_DIALECTS.join(", ")}`)];
+  }
+  if (!isTransferSupported(dstDialect)) {
+    return [null, new Error(`Transfer not supported for dialect: ${dstDialect}. Supported: ${TRANSFER_SUPPORTED_DIALECTS.join(", ")}`)];
+  }
+  return withDualConnection(
+    {
+      sourceConfig,
+      destConfig,
+      ensureSchema: false
+      // Don't create noorm tables on destination
+    },
+    async (ctx) => {
+      const [plan, planErr] = await planTransfer(ctx, options);
+      if (planErr) {
+        throw planErr;
+      }
+      if (!plan || plan.tables.length === 0) {
+        return {
+          status: "success",
+          tables: [],
+          totalRows: 0,
+          durationMs: 0
+        };
+      }
+      if (options.dryRun) {
+        return {
+          status: "success",
+          tables: plan.tables.map((t) => ({
+            table: t.name,
+            status: "skipped",
+            rowsTransferred: 0,
+            rowsSkipped: 0,
+            durationMs: 0
+          })),
+          totalRows: 0,
+          durationMs: 0
+        };
+      }
+      const [result, execErr] = await executeTransfer(ctx, plan, options);
+      if (execErr) {
+        throw execErr;
+      }
+      return result;
+    }
+  );
+}
+async function getTransferPlan(sourceConfig, destConfig, options = {}) {
+  const srcDialect = sourceConfig.connection.dialect;
+  const dstDialect = destConfig.connection.dialect;
+  if (!isTransferSupported(srcDialect)) {
+    return [null, new Error(`Transfer not supported for dialect: ${srcDialect}`)];
+  }
+  if (!isTransferSupported(dstDialect)) {
+    return [null, new Error(`Transfer not supported for dialect: ${dstDialect}`)];
+  }
+  return withDualConnection(
+    {
+      sourceConfig,
+      destConfig,
+      ensureSchema: false
+    },
+    async (ctx) => {
+      const [plan, err] = await planTransfer(ctx, options);
+      if (err) {
+        throw err;
+      }
+      return plan;
+    }
+  );
+}
+var DtWriter = class {
+  #filepath;
+  #schema;
+  #passphrase;
+  #extension;
+  #stream = null;
+  #passthrough = null;
+  #pipelinePromise = null;
+  #bytesWritten = 0;
+  #rowsWritten = 0;
+  #buffer = null;
+  /**
+   * Create a new DtWriter.
+   *
+   * @param options - File path, schema, and optional passphrase
+   */
+  constructor(options) {
+    this.#filepath = options.filepath;
+    this.#schema = options.schema;
+    this.#passphrase = options.passphrase;
+    this.#extension = path7.extname(options.filepath).toLowerCase();
+  }
+  /** Total bytes written to disk. */
+  get bytesWritten() {
+    return this.#bytesWritten;
+  }
+  /** Total rows written. */
+  get rowsWritten() {
+    return this.#rowsWritten;
+  }
+  /**
+   * Open the writer and write the schema header.
+   *
+   * Must be called before writing any rows.
+   */
+  async open() {
+    if (this.#extension === DT_EXTENSIONS.ENCRYPTED) {
+      if (!this.#passphrase) {
+        throw new Error("Passphrase required for .dtzx files");
+      }
+      this.#buffer = [];
+      const schemaLine2 = JSON5.stringify(this.#schema) + "\n";
+      this.#buffer.push(Buffer.from(schemaLine2, "utf8"));
+      return;
+    }
+    const fileStream = createWriteStream(this.#filepath);
+    const schemaLine = JSON5.stringify(this.#schema) + "\n";
+    if (this.#extension === DT_EXTENSIONS.COMPRESSED) {
+      this.#passthrough = new PassThrough();
+      const gzip = createGzip();
+      this.#pipelinePromise = pipeline(this.#passthrough, gzip, fileStream);
+      this.#stream = this.#passthrough;
+      this.#writeToStream(schemaLine);
+    } else {
+      this.#stream = fileStream;
+      this.#writeToStream(schemaLine);
+    }
+  }
+  /**
+   * Write a single serialized row.
+   *
+   * @param values - Serialized .dt values in column order
+   */
+  writeRow(values) {
+    const line = JSON5.stringify(values) + "\n";
+    if (this.#buffer) {
+      this.#buffer.push(Buffer.from(line, "utf8"));
+    } else {
+      this.#writeToStream(line);
+    }
+    this.#rowsWritten++;
+  }
+  /**
+   * Write multiple serialized rows.
+   *
+   * @param rows - Array of serialized row value arrays
+   */
+  writeRows(rows) {
+    for (const row of rows) {
+      this.writeRow(row);
+    }
+  }
+  /**
+   * Close the writer and finalize the file.
+   *
+   * For .dtzx files, this is where compression and encryption happen.
+   */
+  async close() {
+    if (this.#buffer) {
+      const { gzipSync: gzipSync2 } = await import('zlib');
+      const raw = Buffer.concat(this.#buffer);
+      const compressed = gzipSync2(raw);
+      const payload = encryptWithPassphrase(compressed, this.#passphrase);
+      const payloadJson = JSON.stringify(payload);
+      writeFileSync(this.#filepath, payloadJson, "utf8");
+      this.#bytesWritten = Buffer.byteLength(payloadJson, "utf8");
+      this.#buffer = null;
+      return;
+    }
+    if (this.#passthrough) {
+      this.#passthrough.end();
+      await this.#pipelinePromise;
+    } else if (this.#stream) {
+      await new Promise((resolve, reject) => {
+        this.#stream.end(() => resolve());
+        this.#stream.on("error", reject);
+      });
+    }
+  }
+  /**
+   * Write a string to the active stream and track bytes.
+   */
+  #writeToStream(data2) {
+    if (!this.#stream) {
+      throw new Error("Writer not opened");
+    }
+    const buf = Buffer.from(data2, "utf8");
+    this.#bytesWritten += buf.length;
+    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);
+}
+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;
+  }
+}
+
+// src/core/dt/index.ts
+async function exportTable(options) {
+  const startTime = Date.now();
+  const { db, dialect, tableName, filepath, passphrase, schema: schemaName } = options;
+  const kyselyDb = db;
+  const batchSize = options.batchSize ?? 1e3;
+  const [dtSchema, schemaErr] = await buildDtSchema({
+    db: kyselyDb,
+    dialect,
+    tableName,
+    version: options.version,
+    schema: schemaName
+  });
+  if (schemaErr || !dtSchema) {
+    return [null, schemaErr ?? new Error("Failed to build schema")];
+  }
+  observer.emit("dt:export:start", {
+    filepath,
+    table: tableName,
+    columnCount: dtSchema.columns.length
+  });
+  const writer = new DtWriter({ filepath, schema: dtSchema, passphrase });
+  const [, openErr] = await attempt(() => writer.open());
+  if (openErr) {
+    return [null, openErr];
+  }
+  let offset = 0;
+  const columns = dtSchema.columns.map((c) => c.name);
+  const quoteIdent4 = dialect === "mssql" ? (c) => `[${c}]` : dialect === "mysql" ? (c) => `\`${c}\`` : (c) => `"${c}"`;
+  const columnList = columns.map(quoteIdent4).join(", ");
+  while (true) {
+    const [rows, fetchErr] = await attempt(() => {
+      if (dialect === "mssql") {
+        const orderCol = quoteIdent4(columns[0]);
+        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)}
+                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);
+    }
+    offset += rows.rows.length;
+    observer.emit("dt:export:progress", {
+      filepath,
+      table: tableName,
+      rowsWritten: writer.rowsWritten,
+      bytesWritten: writer.bytesWritten
+    });
+    if (rows.rows.length < batchSize) break;
+  }
+  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) {
+  const startTime = Date.now();
+  const { filepath, db, dialect, passphrase, version } = options;
+  const kyselyDb = db;
+  const batchSize = options.batchSize ?? 1e3;
+  const reader = new DtReader({ filepath, passphrase });
+  const [, openErr] = await attempt(() => reader.open());
+  if (openErr) {
+    observer.emit("error", { source: "dt:import", error: openErr, context: { filepath } });
+    return [null, openErr];
+  }
+  const dtSchema = reader.schema;
+  if (!dtSchema) {
+    const err = new Error("Failed to read .dt schema");
+    observer.emit("error", { source: "dt:import", error: err, context: { filepath } });
+    return [null, err];
+  }
+  const tableName = dtSchema.t ?? "unknown";
+  observer.emit("dt:import:start", {
+    filepath,
+    sourceDialect: dtSchema.d,
+    sourceVersion: dtSchema.dv,
+    table: tableName
+  });
+  const [validation, validateErr] = await validateSchema({
+    dtSchema,
+    targetDb: kyselyDb,
+    targetDialect: dialect,
+    targetVersion: version
+  });
+  if (validateErr) {
+    reader.close();
+    observer.emit("error", { source: "dt:import", error: validateErr, context: { filepath, table: tableName } });
+    return [null, validateErr];
+  }
+  observer.emit("dt:import:schema", {
+    filepath,
+    table: tableName,
+    columns: dtSchema.columns.length,
+    validation
+  });
+  if (validation && !validation.valid) {
+    reader.close();
+    const err = new Error(`Schema validation failed: ${validation.errors.join("; ")}`);
+    observer.emit("error", { source: "dt:import", error: err, context: { filepath, table: tableName } });
+    return [null, err];
+  }
+  if (options.truncate && tableName !== "unknown") {
+    const truncateSql = dialect === "postgres" ? `TRUNCATE TABLE "${tableName}" CASCADE` : dialect === "mssql" ? `DELETE FROM [${tableName}]` : `TRUNCATE TABLE \`${tableName}\``;
+    const [, truncErr] = await attempt(() => sql.raw(truncateSql).execute(kyselyDb));
+    if (truncErr) {
+      reader.close();
+      const err = new Error(`Failed to truncate: ${truncErr.message}`);
+      observer.emit("error", { source: "dt:import", error: err, context: { filepath, table: tableName } });
+      return [null, err];
+    }
+  }
+  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);
+    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;
+  }
+  reader.close();
+  const durationMs = Date.now() - startTime;
+  observer.emit("dt:import:complete", {
+    filepath,
+    table: tableName,
+    rowsImported,
+    rowsSkipped,
+    durationMs
+  });
+  return [{ rowsImported, rowsSkipped }, null];
+}
+async function insertImportBatch(db, table, rows, onConflict, dialect, columns) {
+  let inserted = 0;
+  let skipped = 0;
+  let updated = 0;
+  for (const row of rows) {
+    const [, err] = await attempt(
+      () => db.insertInto(table).values(row).execute()
+    );
+    if (err) {
+      if (!isDuplicateError(err.message)) {
+        if (onConflict === "fail") {
+          return [{ inserted, skipped, updated }, err];
+        }
+        skipped++;
+        continue;
+      }
+      if (onConflict === "skip") {
+        skipped++;
+      } else if (onConflict === "update") {
+        const [updateResult, updateErr] = await attemptUpdate(db, table, row, dialect, columns);
+        if (updateErr) {
+          return [{ inserted, skipped, updated }, updateErr];
+        }
+        if (updateResult) {
+          updated++;
+        } else {
+          skipped++;
+        }
+      } else if (onConflict === "fail") {
+        return [{ inserted, skipped, updated }, err];
+      } else {
+        skipped++;
+      }
+    } else {
+      inserted++;
+    }
+  }
+  return [{ inserted, skipped, updated }, null];
+}
+async function attemptUpdate(db, table, row, _dialect, columns) {
+  const pkColumn = columns[0];
+  if (!pkColumn || row[pkColumn] === void 0) {
+    return [false, null];
+  }
+  const pkValue = row[pkColumn];
+  const updateValues = {};
+  for (const col of columns) {
+    if (col !== pkColumn && row[col] !== void 0) {
+      updateValues[col] = row[col];
+    }
+  }
+  if (Object.keys(updateValues).length === 0) {
+    return [true, null];
+  }
+  const [, err] = await attempt(
+    () => db.updateTable(table).set(updateValues).where(pkColumn, "=", pkValue).execute()
+  );
+  if (err) {
+    return [false, err];
+  }
+  return [true, null];
+}
+function isDuplicateError(message) {
+  const lower = message.toLowerCase();
+  return lower.includes("duplicate") || lower.includes("unique constraint") || lower.includes("primary key") || lower.includes("violates unique") || lower.includes("cannot insert duplicate") || lower.includes("duplicate entry");
+}
+
+// src/sdk/guards.ts
+var RequireTestError = class extends Error {
+  constructor(configName) {
+    super(`Config "${configName}" does not have isTest: true`);
+    this.configName = configName;
+  }
+  name = "RequireTestError";
+};
+var ProtectedConfigError = class extends Error {
+  constructor(configName, operation) {
+    super(`Cannot ${operation} on protected config "${configName}"`);
+    this.configName = configName;
+    this.operation = operation;
+  }
+  name = "ProtectedConfigError";
+};
+function checkRequireTest(config, options) {
+  if (options.requireTest && !config.isTest) {
+    throw new RequireTestError(config.name);
+  }
+}
+function checkProtectedConfig(config, operation, options) {
+  if (config.protected && !options.allowProtected) {
+    throw new ProtectedConfigError(config.name, operation);
+  }
+}
+
+// src/sdk/noorm-ops.ts
+var NoormOps = class {
+  #state;
+  constructor(state) {
+    this.#state = state;
+  }
+  // ─────────────────────────────────────────────────────────
+  // Read-only Properties
+  // ─────────────────────────────────────────────────────────
+  get config() {
+    return this.#state.config;
+  }
+  get settings() {
+    return this.#state.settings;
+  }
+  get identity() {
+    return this.#state.identity;
+  }
+  get observer() {
+    return observer;
+  }
+  // ─────────────────────────────────────────────────────────
+  // Private Accessors
+  // ─────────────────────────────────────────────────────────
+  get #kysely() {
+    if (!this.#state.connection) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    return this.#state.connection.db;
+  }
+  get #dialect() {
+    return this.#state.config.connection.dialect;
+  }
   // ─────────────────────────────────────────────────────────
   // Explore
   // ─────────────────────────────────────────────────────────
+  /**
+   * List all tables in the database.
+   *
+   * @example
+   * ```typescript
+   * const tables = await ctx.noorm.listTables()
+   * ```
+   */
   async listTables() {
-    return fetchList(this.kysely, this.dialect, "tables");
+    return fetchList(this.#kysely, this.#dialect, "tables");
   }
+  /**
+   * Get detailed information about a table.
+   *
+   * @example
+   * ```typescript
+   * const detail = await ctx.noorm.describeTable('users')
+   * ```
+   */
   async describeTable(name, schema) {
-    return fetchDetail(this.kysely, this.dialect, "tables", name, schema);
+    return fetchDetail(this.#kysely, this.#dialect, "tables", name, schema);
   }
+  /**
+   * Get database overview with counts of all object types.
+   *
+   * @example
+   * ```typescript
+   * const overview = await ctx.noorm.overview()
+   * ```
+   */
   async overview() {
-    return fetchOverview(this.kysely, this.dialect);
+    return fetchOverview(this.#kysely, this.#dialect);
   }
   // ─────────────────────────────────────────────────────────
   // Schema Operations
   // ─────────────────────────────────────────────────────────
+  /**
+   * Wipe all data, keeping the schema intact.
+   *
+   * @example
+   * ```typescript
+   * const result = await ctx.noorm.truncate()
+   * ```
+   */
   async truncate() {
-    checkProtectedConfig(this.#config, "truncate", this.#options);
-    return truncateData(this.kysely, this.dialect);
+    checkProtectedConfig(this.#state.config, "truncate", this.#state.options);
+    return truncateData(this.#kysely, this.#dialect);
   }
+  /**
+   * Drop all database objects except noorm tracking tables.
+   *
+   * @example
+   * ```typescript
+   * const result = await ctx.noorm.teardown()
+   * ```
+   */
   async teardown() {
-    checkProtectedConfig(this.#config, "teardown", this.#options);
-    return teardownSchema(this.kysely, this.dialect, {
-      configName: this.#config.name,
-      executedBy: formatIdentity(this.#identity)
+    checkProtectedConfig(this.#state.config, "teardown", this.#state.options);
+    return teardownSchema(this.#kysely, this.#dialect, {
+      configName: this.#state.config.name,
+      executedBy: formatIdentity(this.#state.identity)
     });
   }
+  /**
+   * Execute all SQL files in the schema directory.
+   *
+   * @example
+   * ```typescript
+   * const result = await ctx.noorm.build({ force: true })
+   * ```
+   */
   async build(options) {
     const runContext = this.#createRunContext();
-    const sqlPath = path6.join(
-      this.#projectRoot,
-      this.#config.paths.sql
+    const sqlPath = path7.join(
+      this.#state.projectRoot,
+      this.#state.config.paths.sql
     );
     return runBuild(runContext, sqlPath, { force: options?.force });
   }
+  /**
+   * Full rebuild: teardown + build.
+   *
+   * @example
+   * ```typescript
+   * await ctx.noorm.reset()
+   * ```
+   */
   async reset() {
-    checkProtectedConfig(this.#config, "reset", this.#options);
+    checkProtectedConfig(this.#state.config, "reset", this.#state.options);
     await this.teardown();
     await this.build({ force: true });
   }
   // ─────────────────────────────────────────────────────────
   // File Runner
   // ─────────────────────────────────────────────────────────
+  /**
+   * Execute a single SQL file.
+   *
+   * @example
+   * ```typescript
+   * await ctx.noorm.runFile('seeds/test-data.sql')
+   * ```
+   */
   async runFile(filepath, options) {
     const runContext = this.#createRunContext();
-    const absolutePath = path6.isAbsolute(filepath) ? filepath : path6.join(this.#projectRoot, filepath);
+    const absolutePath = path7.isAbsolute(filepath) ? filepath : path7.join(this.#state.projectRoot, filepath);
     return runFile(runContext, absolutePath, options);
   }
+  /**
+   * Execute multiple SQL files sequentially.
+   *
+   * @example
+   * ```typescript
+   * await ctx.noorm.runFiles(['functions/utils.sql', 'triggers/audit.sql'])
+   * ```
+   */
   async runFiles(filepaths, options) {
     const runContext = this.#createRunContext();
     const absolutePaths = filepaths.map(
-      (fp) => path6.isAbsolute(fp) ? fp : path6.join(this.#projectRoot, fp)
+      (fp) => path7.isAbsolute(fp) ? fp : path7.join(this.#state.projectRoot, fp)
     );
     return runFiles(runContext, absolutePaths, options);
   }
+  /**
+   * Execute all SQL files in a directory.
+   *
+   * @example
+   * ```typescript
+   * await ctx.noorm.runDir('seeds/')
+   * ```
+   */
   async runDir(dirpath, options) {
     const runContext = this.#createRunContext();
-    const absolutePath = path6.isAbsolute(dirpath) ? dirpath : path6.join(this.#projectRoot, dirpath);
+    const absolutePath = path7.isAbsolute(dirpath) ? dirpath : path7.join(this.#state.projectRoot, dirpath);
     return runDir(runContext, absolutePath, options);
   }
   // ─────────────────────────────────────────────────────────
   // Changes
   // ─────────────────────────────────────────────────────────
+  /**
+   * Apply a specific change.
+   *
+   * @example
+   * ```typescript
+   * const result = await ctx.noorm.applyChange('2024-01-15-add-users')
+   * ```
+   */
   async applyChange(name, options) {
     return this.#getChangeManager().run(name, options);
   }
+  /**
+   * Revert a specific change.
+   *
+   * @example
+   * ```typescript
+   * const result = await ctx.noorm.revertChange('2024-01-15-add-users')
+   * ```
+   */
   async revertChange(name, options) {
     return this.#getChangeManager().revert(name, options);
   }
+  /**
+   * Apply all pending changes.
+   *
+   * @example
+   * ```typescript
+   * const result = await ctx.noorm.fastForward()
+   * ```
+   */
   async fastForward() {
     return this.#getChangeManager().ff();
   }
+  /**
+   * Get status of all changes.
+   *
+   * @example
+   * ```typescript
+   * const changes = await ctx.noorm.getChangeStatus()
+   * ```
+   */
   async getChangeStatus() {
     return this.#getChangeManager().list();
   }
+  /**
+   * Get only pending changes.
+   *
+   * @example
+   * ```typescript
+   * const pending = await ctx.noorm.getPendingChanges()
+   * ```
+   */
   async getPendingChanges() {
     const all = await this.getChangeStatus();
     return all.filter(
@@ -8000,122 +11154,437 @@ var Context = class {
   // ─────────────────────────────────────────────────────────
   // Secrets
   // ─────────────────────────────────────────────────────────
+  /**
+   * Get a config-scoped secret.
+   *
+   * @example
+   * ```typescript
+   * const apiKey = ctx.noorm.getSecret('API_KEY')
+   * ```
+   */
   getSecret(key) {
-    const state = getStateManager(this.#projectRoot);
-    const value = state.getSecret(this.#config.name, key);
+    const state = getStateManager(this.#state.projectRoot);
+    const value = state.getSecret(this.#state.config.name, key);
     return value ?? void 0;
   }
   // ─────────────────────────────────────────────────────────
   // Locks
   // ─────────────────────────────────────────────────────────
+  /**
+   * Acquire a database lock.
+   *
+   * @example
+   * ```typescript
+   * const lock = await ctx.noorm.acquireLock({ timeout: 60000 })
+   * ```
+   */
   async acquireLock(options) {
     const lockManager = getLockManager();
-    const identityStr = formatIdentity(this.#identity);
+    const identityStr = formatIdentity(this.#state.identity);
     return lockManager.acquire(
-      this.kysely,
-      this.#config.name,
+      this.#kysely,
+      this.#state.config.name,
       identityStr,
-      { ...options, dialect: this.#config.connection.dialect }
+      { ...options, dialect: this.#state.config.connection.dialect }
     );
   }
+  /**
+   * Release the current lock.
+   *
+   * @example
+   * ```typescript
+   * await ctx.noorm.releaseLock()
+   * ```
+   */
   async releaseLock() {
     const lockManager = getLockManager();
-    const identityStr = formatIdentity(this.#identity);
+    const identityStr = formatIdentity(this.#state.identity);
     await lockManager.release(
-      this.kysely,
-      this.#config.name,
+      this.#kysely,
+      this.#state.config.name,
       identityStr
     );
   }
+  /**
+   * Get current lock status.
+   *
+   * @example
+   * ```typescript
+   * const status = await ctx.noorm.getLockStatus()
+   * ```
+   */
   async getLockStatus() {
     const lockManager = getLockManager();
     return lockManager.status(
-      this.kysely,
-      this.#config.name,
-      this.#config.connection.dialect
+      this.#kysely,
+      this.#state.config.name,
+      this.#state.config.connection.dialect
     );
   }
+  /**
+   * Execute an operation with automatic lock acquisition and release.
+   *
+   * @example
+   * ```typescript
+   * await ctx.noorm.withLock(async () => {
+   *     await ctx.noorm.build()
+   *     await ctx.noorm.fastForward()
+   * })
+   * ```
+   */
   async withLock(fn, options) {
     const lockManager = getLockManager();
-    const identityStr = formatIdentity(this.#identity);
+    const identityStr = formatIdentity(this.#state.identity);
     return lockManager.withLock(
-      this.kysely,
-      this.#config.name,
+      this.#kysely,
+      this.#state.config.name,
       identityStr,
       fn,
-      { ...options, dialect: this.#config.connection.dialect }
+      { ...options, dialect: this.#state.config.connection.dialect }
     );
   }
+  /**
+   * Force release any database lock regardless of ownership.
+   *
+   * @example
+   * ```typescript
+   * await ctx.noorm.forceReleaseLock()
+   * ```
+   */
   async forceReleaseLock() {
     const lockManager = getLockManager();
     return lockManager.forceRelease(
-      this.kysely,
-      this.#config.name
+      this.#kysely,
+      this.#state.config.name
     );
   }
   // ─────────────────────────────────────────────────────────
   // Templates
   // ─────────────────────────────────────────────────────────
+  /**
+   * Render a template file without executing.
+   *
+   * @example
+   * ```typescript
+   * const result = await ctx.noorm.renderTemplate('sql/001_users.sql.tmpl')
+   * ```
+   */
   async renderTemplate(filepath) {
-    const absolutePath = path6.isAbsolute(filepath) ? filepath : path6.join(this.#projectRoot, filepath);
-    const state = getStateManager(this.#projectRoot);
+    const absolutePath = path7.isAbsolute(filepath) ? filepath : path7.join(this.#state.projectRoot, filepath);
+    const state = getStateManager(this.#state.projectRoot);
     return processFile(absolutePath, {
-      projectRoot: this.#projectRoot,
-      config: this.#config,
-      secrets: state.getAllSecrets(this.#config.name),
+      projectRoot: this.#state.projectRoot,
+      config: this.#state.config,
+      secrets: state.getAllSecrets(this.#state.config.name),
       globalSecrets: state.getAllGlobalSecrets()
     });
   }
   // ─────────────────────────────────────────────────────────
   // History
   // ─────────────────────────────────────────────────────────
+  /**
+   * Get execution history.
+   *
+   * @example
+   * ```typescript
+   * const history = await ctx.noorm.getHistory(10)
+   * ```
+   */
   async getHistory(limit) {
     return this.#getChangeManager().getHistory(void 0, limit);
   }
   // ─────────────────────────────────────────────────────────
   // Utilities
   // ─────────────────────────────────────────────────────────
+  /**
+   * Compute SHA-256 checksum for a file.
+   *
+   * @example
+   * ```typescript
+   * const checksum = await ctx.noorm.computeChecksum('sql/001_users.sql')
+   * ```
+   */
   async computeChecksum(filepath) {
-    const absolutePath = path6.isAbsolute(filepath) ? filepath : path6.join(this.#projectRoot, filepath);
+    const absolutePath = path7.isAbsolute(filepath) ? filepath : path7.join(this.#state.projectRoot, filepath);
     return computeChecksum(absolutePath);
   }
+  /**
+   * Tests if the connection can be established.
+   *
+   * @example
+   * ```typescript
+   * const result = await ctx.noorm.testConnection()
+   * ```
+   */
   async testConnection() {
-    return testConnection(this.#config.connection);
+    return testConnection(this.#state.config.connection);
+  }
+  // ─────────────────────────────────────────────────────────
+  // Transfer
+  // ─────────────────────────────────────────────────────────
+  /**
+   * Transfer data from this context's database to a destination context.
+   *
+   * Both contexts must be connected. Uses each context's config for
+   * connection management.
+   *
+   * @example
+   * ```typescript
+   * const [result, err] = await source.noorm.transferTo(dest, {
+   *     tables: ['users', 'posts'],
+   *     onConflict: 'skip',
+   * })
+   * ```
+   */
+  async transferTo(destConfig, options) {
+    return transferData(this.#state.config, destConfig, options);
+  }
+  /**
+   * Generate a transfer plan without executing.
+   *
+   * @example
+   * ```typescript
+   * const [plan, err] = await source.noorm.transferPlan(destConfig)
+   * ```
+   */
+  async transferPlan(destConfig, options) {
+    return getTransferPlan(this.#state.config, destConfig, options);
+  }
+  // ─────────────────────────────────────────────────────────
+  // DT File Operations
+  // ─────────────────────────────────────────────────────────
+  /**
+   * Export a table to a .dt file.
+   *
+   * @example
+   * ```typescript
+   * const [result, err] = await ctx.noorm.exportTable('users', './exports/users.dtz')
+   * ```
+   */
+  async exportTable(tableName, filepath, options) {
+    return exportTable({
+      db: this.#kysely,
+      dialect: this.#dialect,
+      tableName,
+      filepath,
+      schema: options?.schema,
+      passphrase: options?.passphrase,
+      batchSize: options?.batchSize
+    });
+  }
+  /**
+   * Import a .dt file into the connected database.
+   *
+   * @example
+   * ```typescript
+   * const [result, err] = await ctx.noorm.importFile('./exports/users.dtz', {
+   *     onConflict: 'skip',
+   * })
+   * ```
+   */
+  async importFile(filepath, options) {
+    return importDtFile({
+      filepath,
+      db: this.#kysely,
+      dialect: this.#dialect,
+      passphrase: options?.passphrase,
+      batchSize: options?.batchSize,
+      onConflict: options?.onConflict,
+      truncate: options?.truncate
+    });
   }
   // ─────────────────────────────────────────────────────────
   // Private Helpers
   // ─────────────────────────────────────────────────────────
   #createRunContext() {
-    const state = getStateManager(this.#projectRoot);
+    const state = getStateManager(this.#state.projectRoot);
     return {
-      db: this.kysely,
-      configName: this.#config.name,
-      identity: this.#identity,
-      projectRoot: this.#projectRoot,
-      config: this.#config,
-      secrets: state.getAllSecrets(this.#config.name),
+      db: this.#kysely,
+      configName: this.#state.config.name,
+      identity: this.#state.identity,
+      projectRoot: this.#state.projectRoot,
+      config: this.#state.config,
+      secrets: state.getAllSecrets(this.#state.config.name),
       globalSecrets: state.getAllGlobalSecrets()
     };
   }
   #createChangeContext() {
-    const state = getStateManager(this.#projectRoot);
+    const state = getStateManager(this.#state.projectRoot);
     return {
-      db: this.kysely,
-      configName: this.#config.name,
-      identity: this.#identity,
-      projectRoot: this.#projectRoot,
-      changesDir: path6.join(this.#projectRoot, this.#config.paths.changes),
-      sqlDir: path6.join(this.#projectRoot, this.#config.paths.sql),
-      config: this.#config,
-      secrets: state.getAllSecrets(this.#config.name),
+      db: this.#kysely,
+      configName: this.#state.config.name,
+      identity: this.#state.identity,
+      projectRoot: this.#state.projectRoot,
+      changesDir: path7.join(this.#state.projectRoot, this.#state.config.paths.changes),
+      sqlDir: path7.join(this.#state.projectRoot, this.#state.config.paths.sql),
+      config: this.#state.config,
+      secrets: state.getAllSecrets(this.#state.config.name),
       globalSecrets: state.getAllGlobalSecrets()
     };
   }
   #getChangeManager() {
-    if (!this.#changeManager) {
-      this.#changeManager = new ChangeManager(this.#createChangeContext());
+    if (!this.#state.changeManager) {
+      this.#state.changeManager = new ChangeManager(this.#createChangeContext());
+    }
+    return this.#state.changeManager;
+  }
+};
+
+// src/sdk/context.ts
+var Context = class {
+  #state;
+  #noorm = null;
+  constructor(config, settings, identity, options, projectRoot) {
+    this.#state = {
+      connection: null,
+      config,
+      settings,
+      identity,
+      options,
+      projectRoot,
+      changeManager: null
+    };
+  }
+  // ─────────────────────────────────────────────────────────
+  // Read-only Properties
+  // ─────────────────────────────────────────────────────────
+  get dialect() {
+    return this.#state.config.connection.dialect;
+  }
+  get connected() {
+    return this.#state.connection !== null;
+  }
+  get kysely() {
+    if (!this.#state.connection) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    return this.#state.connection.db;
+  }
+  // ─────────────────────────────────────────────────────────
+  // Noorm Namespace
+  // ─────────────────────────────────────────────────────────
+  /**
+   * Noorm management operations.
+   *
+   * Lazily instantiated on first access. Returns the same instance
+   * on repeated access (singleton per Context).
+   *
+   * @example
+   * ```typescript
+   * await ctx.noorm.build()
+   * await ctx.noorm.fastForward()
+   * const tables = await ctx.noorm.listTables()
+   * ```
+   */
+  get noorm() {
+    if (!this.#noorm) {
+      this.#noorm = new NoormOps(this.#state);
+    }
+    return this.#noorm;
+  }
+  // ─────────────────────────────────────────────────────────
+  // Lifecycle
+  // ─────────────────────────────────────────────────────────
+  async connect() {
+    if (this.#state.connection) return;
+    this.#state.connection = await createConnection(
+      this.#state.config.connection,
+      this.#state.config.name
+    );
+  }
+  async disconnect() {
+    if (!this.#state.connection) return;
+    await this.#state.connection.destroy();
+    this.#state.connection = null;
+    this.#state.changeManager = null;
+  }
+  // ─────────────────────────────────────────────────────────
+  // Transactions
+  // ─────────────────────────────────────────────────────────
+  /**
+   * Execute operations within a database transaction.
+   *
+   * The callback receives a full Kysely Transaction instance with
+   * query builder, `sql` template literal, and all Kysely features.
+   *
+   * @example
+   * ```typescript
+   * await ctx.transaction(async (trx) => {
+   *     await trx
+   *         .updateTable('accounts')
+   *         .set({ balance: sql`balance - ${amount}` })
+   *         .where('id', '=', fromId)
+   *         .execute();
+   *     await trx
+   *         .updateTable('accounts')
+   *         .set({ balance: sql`balance + ${amount}` })
+   *         .where('id', '=', toId)
+   *         .execute();
+   * });
+   * ```
+   */
+  async transaction(fn) {
+    return this.kysely.transaction().execute(fn);
+  }
+  // ─────────────────────────────────────────────────────────
+  // Stored Procedures & Functions
+  // ─────────────────────────────────────────────────────────
+  /**
+   * Call a stored procedure and return the result set.
+   *
+   * Generates dialect-specific SQL: EXEC (MSSQL), CALL (PG/MySQL).
+   * Named params use dialect-appropriate syntax; MySQL falls back
+   * to positional. SQLite throws — no procedure support.
+   *
+   * @example
+   * ```typescript
+   * // Named params
+   * const users = await ctx.proc<User>('get_users', { department_id: 1 });
+   *
+   * // Positional params
+   * await ctx.proc('simple_proc', [42, 'hello']);
+   *
+   * // No params
+   * await ctx.proc('refresh_cache');
+   * ```
+   */
+  async proc(name, ...args) {
+    if (this.dialect === "sqlite") {
+      throw new Error("SQLite does not support stored procedures.");
+    }
+    const params = args[0];
+    const query = buildProcCall(this.dialect, name, params);
+    const result = await query.execute(this.kysely);
+    return result.rows ?? [];
+  }
+  /**
+   * Call a database function and return the scalar result.
+   *
+   * Generates SELECT name(...) AS column. Named params only on PG;
+   * other dialects fall back to positional. SQLite throws.
+   *
+   * @example
+   * ```typescript
+   * // Named params + column alias
+   * const result = await ctx.func<{ total: number }>('calc_total', { order_id: 42 }, 'total');
+   *
+   * // Positional params + column alias
+   * const sum = await ctx.func<{ result: number }>('add_numbers', [1, 2], 'result');
+   *
+   * // No params — just column alias
+   * const ver = await ctx.func<{ v: string }>('get_version', 'v');
+   * ```
+   */
+  async func(name, ...args) {
+    if (this.dialect === "sqlite") {
+      throw new Error("SQLite does not support database function calls.");
     }
-    return this.#changeManager;
+    const hasParams = !(args.length === 1 && typeof args[0] === "string");
+    const params = hasParams ? args[0] : void 0;
+    const column = hasParams ? args[1] : args[0];
+    const query = buildFuncCall(this.dialect, name, column, params);
+    const result = await query.execute(this.kysely);
+    return result.rows?.[0] ?? null;
   }
 };
 
@@ -8145,6 +11614,6 @@ async function createContext(options = {}) {
   return new Context(config, settings, identity, options, projectRoot);
 }
 
-export { Context, LockAcquireError, LockExpiredError, ProtectedConfigError, RequireTestError, createContext };
+export { Context, LockAcquireError, LockExpiredError, NoormOps, ProtectedConfigError, RequireTestError, createContext };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map