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

package/dist/index.js

@@ -1,6 +1,6 @@
-import { processFile, DtReader, isTemplate, FORMAT_VERSION, DT_EXTENSIONS, encryptWithPassphrase, ENCODED_TYPES } from './chunk-KF7GE2VM.js';
-import { initializeVault, getVaultStatus, setVaultSecret, getVaultSecret, getAllVaultSecrets, listVaultSecretKeys, deleteVaultSecret, vaultSecretExists, getVaultKey, noormDb, getNoormTables, encryptVaultKey } from './chunk-LJDHQEWW.js';
-import { observer } from './chunk-4HW4CS2C.js';
+import { processFile, DtReader, isTemplate, FORMAT_VERSION, DT_EXTENSIONS, encryptWithPassphrase, ENCODED_TYPES } from './chunk-UZARPCOH.js';
+import { initializeVault, getVaultStatus, setVaultSecret, getVaultSecret, getAllVaultSecrets, listVaultSecretKeys, deleteVaultSecret, vaultSecretExists, getVaultKey, noormDb, getNoormTables, encryptVaultKey } from './chunk-HB3JXUJV.js';
+import { observer } from './chunk-BP4PMFJF.js';
 import { constants, existsSync, readFileSync, mkdirSync, writeFileSync, createWriteStream } from 'fs';
 import path, { join, dirname, resolve } from 'path';
 import { makeNestedConfig, gigabytes, attempt, retry, clone, merge, attemptSync } from '@logosdx/utils';
@@ -1757,11 +1757,17 @@ var ConnectionManager = class {
     }
     const trackedEntries = Array.from(this.#tracked.entries());
     for (const [id, entry] of trackedEntries) {
+      let timer;
       const destroyWithTimeout = Promise.race([
-        entry.conn.destroy(),
-        new Promise((resolve2) => setTimeout(resolve2, CLOSE_TIMEOUT))
+        entry.conn.destroy().then(() => {
+          clearTimeout(timer);
+        }),
+        new Promise((resolve2) => {
+          timer = setTimeout(resolve2, CLOSE_TIMEOUT);
+        })
       ]);
       const [, err] = await attempt(() => destroyWithTimeout);
+      clearTimeout(timer);
       this.#tracked.delete(id);
       if (err) {
         observer.emit("error", { source: "connection", error: err });
@@ -1841,7 +1847,7 @@ async function getDialectFactory(dialect) {
     case "mysql":
       return (await import('./mysql-C2DR4TF7.js')).createMysqlConnection;
     case "mssql":
-      return (await import('./mssql-7VB7EHRX.js')).createMssqlConnection;
+      return (await import('./mssql-65M7MY4Q.js')).createMssqlConnection;
     default:
       throw new Error(`Unsupported dialect: ${dialect}`);
   }
@@ -1915,7 +1921,6 @@ async function createConnection(config, configName = "__default__") {
     destroy: wrappedDestroy
   };
   observer.emit("connection:open", { configName, dialect: config.dialect });
-  await waitForIdentityToLoad(trackedConn.db, config.dialect);
   return trackedConn;
 }
 var SYSTEM_DATABASES = {
@@ -2061,79 +2066,170 @@ var INDEXES = [
   { name: "idx_change_name_config", table: "change", columns: ["name", "config_name"] },
   { name: "idx_vault_secret_key", table: "vault", columns: ["secret_key"] }
 ];
+var PREFIXED_TABLES = {
+  executions: "__noorm_executions__",
+  change: "__noorm_change__",
+  vault: "__noorm_vault__"
+};
 var v2 = {
   version: 2,
   description: "Move tracking tables to noorm schema",
   async up(db, dialect) {
     if (dialect === "sqlite" || dialect === "mysql") return;
     await db.transaction().execute(async (trx) => {
-      if (dialect === "postgres") {
-        await sql`CREATE SCHEMA IF NOT EXISTS noorm`.execute(trx);
-      } else {
-        await sql`IF NOT EXISTS (SELECT 1 FROM sys.schemas WHERE name = 'noorm') EXEC('CREATE SCHEMA noorm')`.execute(trx);
-      }
-      if (dialect === "postgres") {
+      const src = dialect === "postgres" ? "public" : "dbo";
+      async function tableExistsIn(schema, table) {
+        if (dialect === "postgres") {
+          const { rows: rows2 } = await sql`
+                        SELECT 1 AS n FROM information_schema.tables
+                        WHERE table_schema = ${schema} AND table_name = ${table}
+                    `.execute(trx);
+          return rows2.length > 0;
+        }
         const { rows } = await sql`
-                    SELECT constraint_name
-                    FROM information_schema.table_constraints
-                    WHERE table_name = '__noorm_executions__'
-                    AND constraint_type = 'FOREIGN KEY'
+                    SELECT 1 AS n FROM sys.tables t
+                    JOIN sys.schemas s ON t.schema_id = s.schema_id
+                    WHERE t.name = ${table} AND s.name = ${schema}
                 `.execute(trx);
-        for (const row of rows) {
-          await sql`ALTER TABLE __noorm_executions__ DROP CONSTRAINT ${sql.ref(row.constraint_name)}`.execute(trx);
+        return rows.length > 0;
+      }
+      async function getForeignKeys(schema, table) {
+        if (!await tableExistsIn(schema, table)) return [];
+        if (dialect === "postgres") {
+          const { rows: rows2 } = await sql`
+                        SELECT tc.constraint_name AS name
+                        FROM information_schema.table_constraints tc
+                        WHERE tc.table_schema = ${schema}
+                        AND tc.table_name = ${table}
+                        AND tc.constraint_type = 'FOREIGN KEY'
+                    `.execute(trx);
+          return rows2.map((r) => r.name);
         }
-      } else {
         const { rows } = await sql`
-                    SELECT fk.name AS fk_name
+                    SELECT fk.name
                     FROM sys.foreign_keys fk
                     JOIN sys.tables t ON fk.parent_object_id = t.object_id
-                    WHERE t.name = '__noorm_executions__'
+                    JOIN sys.schemas s ON t.schema_id = s.schema_id
+                    WHERE t.name = ${table} AND s.name = ${schema}
                 `.execute(trx);
-        for (const row of rows) {
-          await sql`ALTER TABLE __noorm_executions__ DROP CONSTRAINT ${sql.ref(row.fk_name)}`.execute(trx);
+        return rows.map((r) => r.name);
+      }
+      async function indexExistsIn(schema, idxName) {
+        if (dialect === "postgres") {
+          const { rows: rows2 } = await sql`
+                        SELECT 1 AS n FROM pg_indexes
+                        WHERE schemaname = ${schema} AND indexname = ${idxName}
+                    `.execute(trx);
+          return rows2.length > 0;
         }
+        const { rows } = await sql`
+                    SELECT 1 AS n FROM sys.indexes i
+                    JOIN sys.tables t ON i.object_id = t.object_id
+                    JOIN sys.schemas s ON t.schema_id = s.schema_id
+                    WHERE i.name = ${idxName} AND s.name = ${schema}
+                `.execute(trx);
+        return rows.length > 0;
       }
       if (dialect === "postgres") {
-        for (const idx of INDEXES) {
-          await sql`DROP INDEX IF EXISTS ${sql.ref(idx.name)}`.execute(trx);
-        }
+        await sql`CREATE SCHEMA IF NOT EXISTS noorm`.execute(trx);
       } else {
-        const prefixedTables = {
-          executions: "__noorm_executions__",
-          change: "__noorm_change__",
-          vault: "__noorm_vault__"
-        };
-        for (const idx of INDEXES) {
-          const tableName = prefixedTables[idx.table];
-          await sql`
-                        IF EXISTS (SELECT 1 FROM sys.indexes WHERE name = ${idx.name})
-                        DROP INDEX ${sql.ref(idx.name)} ON ${sql.table(tableName)}
-                    `.execute(trx);
+        await sql`IF NOT EXISTS (SELECT 1 FROM sys.schemas WHERE name = 'noorm') EXEC('CREATE SCHEMA noorm')`.execute(trx);
+      }
+      const fkLocations = [
+        { schema: src, table: "__noorm_executions__" },
+        { schema: "noorm", table: "__noorm_executions__" },
+        { schema: "noorm", table: "executions" }
+      ];
+      for (const loc of fkLocations) {
+        const fks = await getForeignKeys(loc.schema, loc.table);
+        for (const fkName of fks) {
+          await sql`ALTER TABLE ${sql.table(`${loc.schema}.${loc.table}`)} DROP CONSTRAINT ${sql.ref(fkName)}`.execute(trx);
         }
       }
-      for (const t of TABLE_MAP) {
-        if (dialect === "postgres") {
-          await sql`ALTER TABLE ${sql.table(t.old)} SET SCHEMA noorm`.execute(trx);
-        } else {
-          await sql`ALTER SCHEMA noorm TRANSFER ${sql.ref(`dbo.${t.old}`)}`.execute(trx);
+      for (const idx of INDEXES) {
+        if (await indexExistsIn(src, idx.name)) {
+          if (dialect === "postgres") {
+            await sql`DROP INDEX IF EXISTS ${sql.ref(idx.name)}`.execute(trx);
+          } else {
+            const tableName = PREFIXED_TABLES[idx.table];
+            await sql`
+                            IF EXISTS (SELECT 1 FROM sys.indexes WHERE name = ${idx.name})
+                            DROP INDEX ${sql.ref(idx.name)} ON ${sql.table(tableName)}
+                        `.execute(trx);
+          }
+        }
+        if (await indexExistsIn("noorm", idx.name)) {
+          if (dialect === "postgres") {
+            await sql`DROP INDEX IF EXISTS ${sql.ref(`noorm.${idx.name}`)}`.execute(trx);
+          } else {
+            const oldName = PREFIXED_TABLES[idx.table];
+            const onOldName = await tableExistsIn("noorm", oldName);
+            const tbl = onOldName ? `noorm.${oldName}` : `noorm.${idx.table}`;
+            await sql`
+                            IF EXISTS (SELECT 1 FROM sys.indexes WHERE name = ${idx.name})
+                            DROP INDEX ${sql.ref(idx.name)} ON ${sql.table(tbl)}
+                        `.execute(trx);
+          }
         }
       }
       for (const t of TABLE_MAP) {
+        const inNoormNew = await tableExistsIn("noorm", t.new);
+        const inNoormOld = await tableExistsIn("noorm", t.old);
+        const inSrc = await tableExistsIn(src, t.old);
+        if (inNoormNew) {
+          if (inSrc) {
+            if (dialect === "postgres") {
+              await sql`DROP TABLE ${sql.table(`${src}.${t.old}`)} CASCADE`.execute(trx);
+            } else {
+              await sql`DROP TABLE ${sql.table(`${src}.${t.old}`)}`.execute(trx);
+            }
+          }
+          if (inNoormOld) {
+            if (dialect === "postgres") {
+              await sql`DROP TABLE ${sql.table(`noorm.${t.old}`)} CASCADE`.execute(trx);
+            } else {
+              await sql`DROP TABLE ${sql.table(`noorm.${t.old}`)}`.execute(trx);
+            }
+          }
+          continue;
+        }
+        if (!inNoormOld && !inSrc) continue;
+        if (!inNoormOld && inSrc) {
+          if (dialect === "postgres") {
+            await sql`ALTER TABLE ${sql.table(t.old)} SET SCHEMA noorm`.execute(trx);
+          } else {
+            await sql`ALTER SCHEMA noorm TRANSFER ${sql.ref(`dbo.${t.old}`)}`.execute(trx);
+          }
+        }
         if (dialect === "postgres") {
           await sql`ALTER TABLE ${sql.table(`noorm.${t.old}`)} RENAME TO ${sql.ref(t.new)}`.execute(trx);
         } else {
           await sql`EXEC sp_rename ${sql.raw(`'noorm.${t.old}'`)}, ${sql.raw(`'${t.new}'`)}`.execute(trx);
         }
+        if (inSrc && inNoormOld) {
+          if (await tableExistsIn(src, t.old)) {
+            if (dialect === "postgres") {
+              await sql`DROP TABLE ${sql.table(`${src}.${t.old}`)} CASCADE`.execute(trx);
+            } else {
+              await sql`DROP TABLE ${sql.table(`${src}.${t.old}`)}`.execute(trx);
+            }
+          }
+        }
+      }
+      const fksOnExec = await getForeignKeys("noorm", "executions");
+      if (fksOnExec.length === 0) {
+        await sql`
+                    ALTER TABLE ${sql.table("noorm.executions")}
+                    ADD CONSTRAINT fk_executions_change_id
+                    FOREIGN KEY (change_id) REFERENCES ${sql.table("noorm.change")}(id)
+                    ON DELETE CASCADE
+                `.execute(trx);
       }
-      await sql`
-                ALTER TABLE ${sql.table("noorm.executions")}
-                ADD CONSTRAINT fk_executions_change_id
-                FOREIGN KEY (change_id) REFERENCES ${sql.table("noorm.change")}(id)
-                ON DELETE CASCADE
-            `.execute(trx);
       for (const idx of INDEXES) {
-        const cols = idx.columns.join(", ");
-        await sql`CREATE INDEX ${sql.ref(idx.name)} ON ${sql.table(`noorm.${idx.table}`)} (${sql.raw(cols)})`.execute(trx);
+        if (!await indexExistsIn("noorm", idx.name)) {
+          const cols = idx.columns.join(", ");
+          await sql`CREATE INDEX ${sql.ref(idx.name)} ON ${sql.table(`noorm.${idx.table}`)} (${sql.raw(cols)})`.execute(trx);
+        }
       }
     });
   },
@@ -2196,12 +2292,7 @@ var v2 = {
                 ON DELETE CASCADE
             `.execute(trx);
       for (const idx of INDEXES) {
-        const prefixedTables = {
-          executions: "__noorm_executions__",
-          change: "__noorm_change__",
-          vault: "__noorm_vault__"
-        };
-        const tableName = prefixedTables[idx.table];
+        const tableName = PREFIXED_TABLES[idx.table];
         const cols = idx.columns.join(", ");
         await sql`CREATE INDEX ${sql.ref(idx.name)} ON ${sql.table(tableName)} (${sql.raw(cols)})`.execute(trx);
       }
@@ -2332,17 +2423,22 @@ async function migrateSchema(db, dialect, options) {
     throw new VersionMismatchError("schema", status.current, status.expected);
   }
   if (!status.needsMigration) return;
-  if (status.current === 0) {
-    await bootstrapSchema(db, dialect);
-    return;
+  let currentVersion = status.current;
+  if (currentVersion === 0) {
+    const tableFound = await tablesExist(db, dialect);
+    if (!tableFound) {
+      await bootstrapSchema(db, dialect);
+      return;
+    }
+    currentVersion = 1;
   }
   const start = performance.now();
   observer.emit("version:schema:migrating", {
-    from: status.current,
+    from: currentVersion,
     to: CURRENT_VERSIONS.schema
   });
   const existing = await getLatestVersionRecord(db, dialect);
-  const pendingMigrations = MIGRATIONS.filter((m) => m.version > status.current);
+  const pendingMigrations = MIGRATIONS.filter((m) => m.version > currentVersion);
   for (const migration of pendingMigrations) {
     const [, err] = await attempt(() => migration.up(db, dialect));
     if (err) {
@@ -2359,7 +2455,7 @@ async function migrateSchema(db, dialect, options) {
   }).execute();
   const durationMs = performance.now() - start;
   observer.emit("version:schema:migrated", {
-    from: status.current,
+    from: currentVersion,
     to: CURRENT_VERSIONS.schema,
     durationMs
   });
@@ -3178,11 +3274,13 @@ var ChangeHistory = class {
   #ndb;
   #tables;
   #configName;
+  #dialect;
   constructor(db, configName, dialect = "sqlite") {
     this.#db = db;
     this.#ndb = noormDb(db, dialect);
     this.#tables = getNoormTables(dialect);
     this.#configName = configName;
+    this.#dialect = dialect;
   }
   // ─────────────────────────────────────────────────────────
   // Status Queries
@@ -3358,34 +3456,63 @@ var ChangeHistory = class {
    * @returns The created operation's ID
    */
   async createOperation(data2) {
-    const [result, err] = await attempt(
-      () => this.#ndb.insertInto(this.#tables.change).values({
-        name: data2.name,
-        change_type: "change",
-        direction: data2.direction,
-        status: "pending",
-        config_name: this.#configName,
-        executed_by: data2.executedBy
-      }).returning("id").executeTakeFirstOrThrow()
-    );
-    if (err) {
-      throw new Error("Failed to create change operation record", { cause: err });
-    }
-    let id = result?.id;
-    if (id === null || id === void 0) {
-      const [lastIdResult, lastIdErr] = await attempt(
-        () => sql`SELECT last_insert_rowid() as id`.execute(this.#db)
+    const insertQuery = this.#ndb.insertInto(this.#tables.change).values({
+      name: data2.name,
+      change_type: "change",
+      direction: data2.direction,
+      status: "pending",
+      config_name: this.#configName,
+      executed_by: data2.executedBy
+    });
+    let id;
+    if (this.#dialect === "mssql") {
+      const [result, insertErr] = await attempt(
+        () => insertQuery.output("inserted.id as id").executeTakeFirstOrThrow()
+      );
+      if (insertErr) {
+        throw new Error("Failed to create change operation record", { cause: insertErr });
+      }
+      id = result?.id;
+    } else {
+      const [result, err] = await attempt(
+        () => insertQuery.returning("id").executeTakeFirstOrThrow()
       );
-      if (lastIdErr || !lastIdResult?.rows?.[0]?.id) {
-        throw new Error("Failed to retrieve last insert row id");
+      if (err) {
+        throw new Error("Failed to create change operation record", { cause: err });
+      }
+      id = result?.id ?? void 0;
+      if (id === null || id === void 0) {
+        const lastIdQuery = this.#lastInsertIdQuery();
+        if (lastIdQuery) {
+          const [lastIdResult] = await attempt(() => lastIdQuery.execute(this.#db));
+          id = lastIdResult?.rows?.[0]?.id;
+        }
       }
-      id = lastIdResult.rows[0].id;
     }
     if (typeof id !== "number" || !Number.isFinite(id) || id <= 0) {
       throw new Error(`Invalid operation ID returned: ${id}`);
     }
     return id;
   }
+  /**
+   * Get dialect-specific last-insert-id query.
+   *
+   * Returns null if the dialect should always use RETURNING/OUTPUT.
+   */
+  #lastInsertIdQuery() {
+    switch (this.#dialect) {
+      case "sqlite":
+        return sql`SELECT last_insert_rowid() as id`;
+      case "mysql":
+        return sql`SELECT LAST_INSERT_ID() as id`;
+      case "mssql":
+        return sql`SELECT SCOPE_IDENTITY() as id`;
+      case "postgres":
+        return sql`SELECT lastval() as id`;
+      default:
+        return null;
+    }
+  }
   /**
    * Create pending file records for all files.
    *
@@ -3463,7 +3590,7 @@ var ChangeHistory = class {
     const [, err] = await attempt(
       () => this.#ndb.updateTable(this.#tables.executions).set({
         status: "skipped",
-        skip_reason: reason
+        skip_reason: reason.slice(0, 100)
       }).where("change_id", "=", operationId).where("status", "=", "pending").execute()
     );
     if (err) {
@@ -3524,18 +3651,33 @@ var ChangeHistory = class {
    * @returns The created record's ID
    */
   async recordReset(executedBy, reason) {
+    const insertQuery = this.#ndb.insertInto(this.#tables.change).values({
+      name: "__reset__",
+      change_type: "change",
+      direction: "change",
+      status: "success",
+      config_name: this.#configName,
+      executed_by: executedBy,
+      error_message: reason ?? "",
+      duration_ms: 0,
+      checksum: ""
+    });
+    if (this.#dialect === "mssql") {
+      const [result2, insertErr] = await attempt(
+        () => insertQuery.output("inserted.id as id").executeTakeFirstOrThrow()
+      );
+      if (insertErr) {
+        observer.emit("error", {
+          source: "change",
+          error: insertErr,
+          context: { operation: "record-reset" }
+        });
+        return 0;
+      }
+      return result2?.id ?? 0;
+    }
     const [result, err] = await attempt(
-      () => this.#ndb.insertInto(this.#tables.change).values({
-        name: "__reset__",
-        change_type: "change",
-        direction: "change",
-        status: "success",
-        config_name: this.#configName,
-        executed_by: executedBy,
-        error_message: reason ?? "",
-        duration_ms: 0,
-        checksum: ""
-      }).returning("id").executeTakeFirstOrThrow()
+      () => insertQuery.returning("id").executeTakeFirstOrThrow()
     );
     if (err) {
       observer.emit("error", {
@@ -3749,11 +3891,13 @@ var Tracker = class {
   #ndb;
   #tables;
   #configName;
+  #dialect;
   constructor(db, configName, dialect = "sqlite") {
     this.#db = db;
     this.#ndb = noormDb(db, dialect);
     this.#tables = getNoormTables(dialect);
     this.#configName = configName;
+    this.#dialect = dialect;
   }
   /**
    * Check if a file needs to run.
@@ -3839,34 +3983,63 @@ var Tracker = class {
   async createOperation(data2) {
     const direction = data2.direction ?? "commit";
     const dbDirection = direction === "commit" ? "change" : "revert";
-    const [result, err] = await attempt(
-      () => this.#ndb.insertInto(this.#tables.change).values({
-        name: data2.name,
-        change_type: data2.changeType,
-        direction: dbDirection,
-        status: "pending",
-        config_name: data2.configName,
-        executed_by: data2.executedBy
-      }).returning("id").executeTakeFirstOrThrow()
-    );
-    if (err) {
-      throw new Error("Failed to create operation record", { cause: err });
-    }
-    let id = result?.id;
-    if (id === null || id === void 0) {
-      const [lastIdResult, lastIdErr] = await attempt(
-        () => sql`SELECT last_insert_rowid() as id`.execute(this.#db)
+    const insertQuery = this.#ndb.insertInto(this.#tables.change).values({
+      name: data2.name,
+      change_type: data2.changeType,
+      direction: dbDirection,
+      status: "pending",
+      config_name: data2.configName,
+      executed_by: data2.executedBy
+    });
+    let id;
+    if (this.#dialect === "mssql") {
+      const [result, insertErr] = await attempt(
+        () => insertQuery.output("inserted.id as id").executeTakeFirstOrThrow()
+      );
+      if (insertErr) {
+        throw new Error("Failed to create operation record", { cause: insertErr });
+      }
+      id = result?.id;
+    } else {
+      const [result, err] = await attempt(
+        () => insertQuery.returning("id").executeTakeFirstOrThrow()
       );
-      if (lastIdErr || !lastIdResult?.rows?.[0]?.id) {
-        throw new Error("Failed to retrieve last insert row id");
+      if (err) {
+        throw new Error("Failed to create operation record", { cause: err });
+      }
+      id = result?.id ?? void 0;
+      if (id === null || id === void 0) {
+        const lastIdQuery = this.#lastInsertIdQuery();
+        if (lastIdQuery) {
+          const [lastIdResult] = await attempt(() => lastIdQuery.execute(this.#db));
+          id = lastIdResult?.rows?.[0]?.id;
+        }
       }
-      id = lastIdResult.rows[0].id;
     }
     if (typeof id !== "number" || !Number.isFinite(id) || id <= 0) {
       throw new Error(`Invalid operation ID returned: ${id}`);
     }
     return id;
   }
+  /**
+   * Get dialect-specific last-insert-id query.
+   *
+   * Returns null if the dialect should always use RETURNING/OUTPUT.
+   */
+  #lastInsertIdQuery() {
+    switch (this.#dialect) {
+      case "sqlite":
+        return sql`SELECT last_insert_rowid() as id`;
+      case "mysql":
+        return sql`SELECT LAST_INSERT_ID() as id`;
+      case "mssql":
+        return sql`SELECT SCOPE_IDENTITY() as id`;
+      case "postgres":
+        return sql`SELECT lastval() as id`;
+      default:
+        return null;
+    }
+  }
   /**
    * Record a file execution.
    *
@@ -4029,10 +4202,11 @@ var Tracker = class {
    * @returns Error message if skip failed, null on success
    */
   async skipRemainingFiles(operationId, reason) {
+    const truncatedReason = reason.slice(0, 100);
     const [, err] = await attempt(
       () => this.#ndb.updateTable(this.#tables.executions).set({
         status: "skipped",
-        skip_reason: reason
+        skip_reason: truncatedReason
       }).where("change_id", "=", operationId).where("status", "=", "pending").execute()
     );
     if (err) {
@@ -5746,7 +5920,10 @@ async function runBuild(context, sqlPath, options = {}, preFilteredFiles) {
         error: discoverErr,
         context: { sqlPath, operation: "discover-files" }
       });
-      return createFailedBatchResult(discoverErr.message, performance.now() - start);
+      return createFailedBatchResult(
+        `${discoverErr.message} (${sqlPath})`,
+        performance.now() - start
+      );
     }
     files = discovered;
   }
@@ -5754,13 +5931,14 @@ async function runBuild(context, sqlPath, options = {}, preFilteredFiles) {
     sqlPath,
     fileCount: files.length
   });
-  const result = await executeFilesInternal(context, files, opts, "build");
+  const result = await executeFilesInternal(context, files, opts, "build", sqlPath);
   observer.emit("build:complete", {
     status: result.status,
     filesRun: result.filesRun,
     filesSkipped: result.filesSkipped,
     filesFailed: result.filesFailed,
-    durationMs: result.durationMs
+    durationMs: result.durationMs,
+    error: result.error
   });
   return result;
 }
@@ -5813,14 +5991,17 @@ async function runDir(context, dirpath, options = {}) {
       error: discoverErr,
       context: { dirpath, operation: "discover-files" }
     });
-    return createFailedBatchResult(discoverErr.message, performance.now() - start);
+    return createFailedBatchResult(
+      `${discoverErr.message} (${dirpath})`,
+      performance.now() - start
+    );
   }
   observer.emit("run:dir", {
     dirpath,
     fileCount: files.length,
     configName: context.configName
   });
-  return executeFilesInternal(context, files, opts, "run");
+  return executeFilesInternal(context, files, opts, "run", dirpath);
 }
 async function runFiles(context, files, options = {}) {
   const opts = { ...DEFAULT_RUN_OPTIONS_INTERNAL, ...options };
@@ -5916,9 +6097,12 @@ async function executeFiles2(context, files, runOptions, execOptions) {
     observer.emit("error", {
       source: "runner:create-operation",
       error: createErr,
-      context: { operationName: execOptions.operationName }
+      context: { operationName: execOptions.operationName, sqlPath: execOptions.sqlPath }
     });
-    return createFailedBatchResult(createErr.message, performance.now() - start);
+    return createFailedBatchResult(
+      formatErrorChain(createErr),
+      performance.now() - start
+    );
   }
   const fileRecords = [];
   for (const file of files) {
@@ -5941,7 +6125,10 @@ async function executeFiles2(context, files, runOptions, execOptions) {
       context: { operationId }
     });
     await tracker.finalizeOperation(operationId, "failed", 0, "", createRecordsErr);
-    return createFailedBatchResult(createRecordsErr, performance.now() - start);
+    return createFailedBatchResult(
+      createRecordsErr,
+      performance.now() - start
+    );
   }
   const results = [];
   let failed = false;
@@ -5962,7 +6149,7 @@ async function executeFiles2(context, files, runOptions, execOptions) {
       failed = true;
       const skipErr = await tracker.skipRemainingFiles(
         operationId,
-        `Skipped due to failure in ${file.path}`
+        `Skipped: failure in ${path.basename(file.path)}`.slice(0, 100)
       );
       if (skipErr) {
         observer.emit("error", {
@@ -6008,7 +6195,7 @@ async function executeFiles2(context, files, runOptions, execOptions) {
     changeId: operationId
   };
 }
-async function executeFilesInternal(context, files, options, changeType) {
+async function executeFilesInternal(context, files, options, changeType, sqlPath) {
   const fileInputs = files.map((f) => ({
     path: f,
     type: "sql"
@@ -6016,7 +6203,8 @@ async function executeFilesInternal(context, files, options, changeType) {
   const execOptions = {
     changeType,
     direction: "commit",
-    operationName: `${changeType}:${(/* @__PURE__ */ new Date()).toISOString()}`
+    operationName: `${changeType}:${(/* @__PURE__ */ new Date()).toISOString()}`,
+    sqlPath
   };
   return executeFiles2(context, fileInputs, options, execOptions);
 }
@@ -6086,7 +6274,7 @@ async function executeSingleFileWithUpdate(context, filepath, checksum, options,
       filepath,
       checksum: finalChecksum,
       status: "failed",
-      error: execErr.message,
+      error: getErrorMessage(execErr),
       durationMs
     };
     await tracker.updateFileExecution(
@@ -6094,13 +6282,13 @@ async function executeSingleFileWithUpdate(context, filepath, checksum, options,
       relFilepath,
       "failed",
       Math.round(durationMs),
-      execErr.message
+      getErrorMessage(execErr)
     );
     observer.emit("file:after", {
       filepath,
       status: "failed",
       durationMs,
-      error: execErr.message
+      error: getErrorMessage(execErr)
     });
     return result2;
   }
@@ -6210,7 +6398,7 @@ async function executeSingleFile(context, filepath, options, tracker, operationI
       filepath,
       checksum,
       status: "failed",
-      error: execErr.message,
+      error: getErrorMessage(execErr),
       durationMs
     };
     await tracker.recordExecution({
@@ -6218,14 +6406,14 @@ async function executeSingleFile(context, filepath, options, tracker, operationI
       filepath: relFilepath,
       checksum,
       status: "failed",
-      errorMessage: execErr.message,
+      errorMessage: getErrorMessage(execErr),
       durationMs: Math.round(durationMs)
     });
     observer.emit("file:after", {
       filepath,
       status: "failed",
       durationMs,
-      error: execErr.message
+      error: getErrorMessage(execErr)
     });
     return result2;
   }
@@ -6368,9 +6556,40 @@ function createFailedBatchResult(error, durationMs) {
     filesRun: 0,
     filesSkipped: 0,
     filesFailed: 0,
-    durationMs
+    durationMs,
+    error
   };
 }
+function formatErrorChain(err) {
+  const parts = [err.message];
+  let current = err.cause;
+  while (current instanceof Error) {
+    parts.push(current.message);
+    current = current.cause;
+  }
+  return parts.join(": ");
+}
+function getErrorMessage(err) {
+  if (err instanceof AggregateError && err.errors?.length > 0) {
+    return err.errors.map((e) => getErrorMessage(e)).join("; ");
+  }
+  if (err instanceof Error && err.message) return err.message;
+  if (typeof err === "string") return err;
+  if (typeof err === "object" && err !== null) {
+    const e = err;
+    if (typeof e["message"] === "string" && e["message"]) return e["message"];
+    if (Array.isArray(e["errors"]) && e["errors"].length > 0) {
+      return e["errors"].map((inner) => getErrorMessage(inner)).join("; ");
+    }
+    if (typeof e["originalError"] === "object" && e["originalError"] !== null) {
+      const orig = e["originalError"];
+      if (typeof orig["message"] === "string" && orig["message"]) return orig["message"];
+    }
+    const str = String(err);
+    if (str !== "[object Object]") return str;
+  }
+  return "Unknown error";
+}
 
 // src/sdk/namespaces/run.ts
 var RunNamespace = class {