@noormdev/sdk 1.4.2 → 1.5.0

package/dist/{chunk-A2OYZAVT.js → chunk-6LG4ENOJ.js}

@@ -1519,5 +1519,5 @@ var observer = new ObserverEngine({
 });
 
 export { ObserverRelay, getEnvConfigName, isDebug, observer, shouldSkipConfirmations };
-//# sourceMappingURL=chunk-A2OYZAVT.js.map
-//# sourceMappingURL=chunk-A2OYZAVT.js.map
+//# sourceMappingURL=chunk-6LG4ENOJ.js.map
+//# sourceMappingURL=chunk-6LG4ENOJ.js.map

package/dist/{chunk-CDTFXLXU.js → chunk-M7Q44VFJ.js}

@@ -1,5 +1,5 @@
 import { createRequire } from 'module';
-import { observer } from './chunk-A2OYZAVT.js';
+import { observer } from './chunk-6LG4ENOJ.js';
 import { attemptSync, attempt } from './chunk-TXDGFA44.js';
 import { dist_default } from './chunk-TBRUDUBQ.js';
 import { readFile as readFile$1, readdir, stat } from 'fs/promises';
@@ -2506,7 +2506,7 @@ function createIncludeHelper(templateDir, projectRoot, options) {
       throw new Error(`Include path escapes project root: ${includePath}`);
     }
     if (resolved.endsWith(".tmpl")) {
-      const { processFile: processFile2 } = await import('./engine-6ALQ5YTN.js');
+      const { processFile: processFile2 } = await import('./engine-P74UTJQO.js');
       const result = await processFile2(resolved, options);
       return result.sql;
     }
@@ -2588,5 +2588,5 @@ voca/es/index.js:
 */
 
 export { DT_EXTENSIONS, DtReader, ENCODED_TYPES, FORMAT_VERSION, encryptWithPassphrase, es_default, eta, isTemplate, processFile, processFiles, renderTemplate };
-//# sourceMappingURL=chunk-CDTFXLXU.js.map
-//# sourceMappingURL=chunk-CDTFXLXU.js.map
+//# sourceMappingURL=chunk-M7Q44VFJ.js.map
+//# sourceMappingURL=chunk-M7Q44VFJ.js.map

package/dist/{chunk-OMY6CKR4.js → chunk-WUMCIKEQ.js}

@@ -1,5 +1,5 @@
 import { createRequire } from 'module';
-import { observer, shouldSkipConfirmations } from './chunk-A2OYZAVT.js';
+import { observer, shouldSkipConfirmations } from './chunk-6LG4ENOJ.js';
 import { attempt, attemptSync } from './chunk-TXDGFA44.js';
 import { __commonJS, __toESM } from './chunk-D2XW2UOP.js';
 import { generateKeyPairSync, randomBytes, createCipheriv, createPrivateKey, createPublicKey, diffieHellman, hkdfSync, createDecipheriv } from 'crypto';
@@ -97661,5 +97661,5 @@ async function listVaultSecretKeysChecked(gate, db, dialect) {
 }
 
 export { assertPolicy, assertVaultPolicy, checkConfigPolicy, deleteVaultSecret, deleteVaultSecretChecked, detectAgentHarness, encryptVaultKey, getAllVaultSecrets, getNoormTables, getVaultKey, getVaultKeyChecked, getVaultSecret, getVaultStatus, guarded, initializeVault, initializeVaultChecked, listVaultSecretKeys, listVaultSecretKeysChecked, noormDb, resolveLegacyAccess, setVaultSecret, setVaultSecretChecked, vaultSecretExists };
-//# sourceMappingURL=chunk-OMY6CKR4.js.map
-//# sourceMappingURL=chunk-OMY6CKR4.js.map
+//# sourceMappingURL=chunk-WUMCIKEQ.js.map
+//# sourceMappingURL=chunk-WUMCIKEQ.js.map

package/dist/{engine-6ALQ5YTN.js → engine-P74UTJQO.js}

@@ -1,12 +1,12 @@
 import { createRequire } from 'module';
-export { eta, isTemplate, processFile, processFiles, renderTemplate } from './chunk-CDTFXLXU.js';
+export { eta, isTemplate, processFile, processFiles, renderTemplate } from './chunk-M7Q44VFJ.js';
 import './chunk-UOFJT5PY.js';
-import './chunk-A2OYZAVT.js';
+import './chunk-6LG4ENOJ.js';
 import './chunk-TXDGFA44.js';
 import './chunk-TBRUDUBQ.js';
 import './chunk-YJBKNUTP.js';
 import './chunk-D2XW2UOP.js';
 
 createRequire(import.meta.url);
-//# sourceMappingURL=engine-6ALQ5YTN.js.map
-//# sourceMappingURL=engine-6ALQ5YTN.js.map
+//# sourceMappingURL=engine-P74UTJQO.js.map
+//# sourceMappingURL=engine-P74UTJQO.js.map

package/dist/index.d.ts

@@ -2541,6 +2541,42 @@ export declare class ChangesNamespace {
 	 */
 	getFileHistory(operationId: number): Promise<FileHistoryRecord[]>;
 }
+/**
+ * A session holding a lock the watched statement is waiting on.
+ */
+export interface BlockingSession {
+	pid: number;
+	/** Start of the blocker's statement text, or its command/status when no text is visible. */
+	query: string | null;
+	/** How long the blocker has been in its current transaction or request. */
+	ageMs: number | null;
+}
+/**
+ * Progress an operation reports about itself, from the dialect's progress views.
+ */
+export interface OperationProgress {
+	/** What is running, e.g. `CREATE INDEX`, `VACUUM`, `COPY FROM`. */
+	operation: string;
+	/** Phase within the operation, e.g. `building index: loading tuples`. */
+	phase: string | null;
+	relation: string | null;
+	done: number | null;
+	total: number | null;
+	/** 0-100, when the dialect reports enough to compute it. */
+	percent: number | null;
+}
+/**
+ * What the server says about a running statement at one point in time.
+ */
+export interface StatementStatus {
+	/** Session state, e.g. `active`, `suspended`, a mysql thread state. */
+	state: string | null;
+	/** What the session is waiting on, e.g. `Lock: transactionid`. Null when it is working. */
+	waitEvent: string | null;
+	blockedBy: BlockingSession[];
+	workers: number;
+	progress: OperationProgress | null;
+}
 export declare class RunNamespace {
 	#private;
 	constructor(state: ContextState);
@@ -4484,6 +4520,17 @@ export interface NoormEvents extends SettingsEvents, UpdateEvents, VaultEvents,
 		filepath: string;
 		reason: "unchanged" | "already-run";
 	};
+	/**
+	 * A file has run past the watch delay. Repeats every watch interval until
+	 * it finishes. `status` is null when the dialect has no probe (sqlite) or
+	 * the server could not be asked.
+	 */
+	"file:progress": {
+		filepath: string;
+		elapsedMs: number;
+		sessionId: number | null;
+		status: StatementStatus | null;
+	};
 	"file:dry-run": {
 		filepath: string;
 		status: "success" | "failed";

package/dist/index.js

@@ -1,9 +1,9 @@
 import { createRequire } from 'module';
-import { processFile, es_default, DtReader, isTemplate, FORMAT_VERSION, DT_EXTENSIONS, encryptWithPassphrase, ENCODED_TYPES } from './chunk-CDTFXLXU.js';
+import { processFile, es_default, DtReader, isTemplate, FORMAT_VERSION, DT_EXTENSIONS, encryptWithPassphrase, ENCODED_TYPES } from './chunk-M7Q44VFJ.js';
 import './chunk-UOFJT5PY.js';
-import { resolveLegacyAccess, checkConfigPolicy, initializeVault, getVaultStatus, setVaultSecret, getVaultSecret, getAllVaultSecrets, listVaultSecretKeys, deleteVaultSecret, vaultSecretExists, getVaultKey, noormDb, getNoormTables, encryptVaultKey, assertVaultPolicy, assertPolicy, detectAgentHarness, guarded } from './chunk-OMY6CKR4.js';
-import { observer, getEnvConfigName, ObserverRelay, isDebug } from './chunk-A2OYZAVT.js';
-export { observer as noormObserver } from './chunk-A2OYZAVT.js';
+import { resolveLegacyAccess, checkConfigPolicy, initializeVault, getVaultStatus, setVaultSecret, getVaultSecret, getAllVaultSecrets, listVaultSecretKeys, deleteVaultSecret, vaultSecretExists, getVaultKey, noormDb, getNoormTables, encryptVaultKey, assertVaultPolicy, assertPolicy, detectAgentHarness, guarded } from './chunk-WUMCIKEQ.js';
+import { observer, getEnvConfigName, ObserverRelay, isDebug } from './chunk-6LG4ENOJ.js';
+export { observer as noormObserver } from './chunk-6LG4ENOJ.js';
 import { explainConnectionError, DatabaseConnectionError } from './chunk-OXTXFKWJ.js';
 import { makeNestedConfig, gigabytes, attempt, attemptSync, clone, merge, equals, retry, runWithTimeout, isTimeoutError, wait } from './chunk-TXDGFA44.js';
 import { external_exports, PortSchema, connectTimeoutFor, DEFAULT_PORTS } from './chunk-WE2JLJMT.js';
@@ -6019,6 +6019,349 @@ function computeCombinedChecksum(checksums) {
   const combined = sorted.join("");
   return createHash("sha256").update(combined, "utf-8").digest("hex");
 }
+var SESSION_ID_SQL = {
+  postgres: "select pg_backend_pid() as id",
+  mysql: "select connection_id() as id",
+  mssql: "select @@SPID as id"
+};
+var SERVER_CANCEL = {
+  postgres: (db, sessionId) => sql`select pg_cancel_backend(${sessionId})`.execute(db),
+  // KILL cannot be prepared, so the id is interpolated. It comes from
+  // connection_id() and is checked by readSessionId before it gets here,
+  // never from user input.
+  mysql: (db, sessionId) => sql.raw(`kill query ${sessionId}`).execute(db)
+};
+function readSessionId(rows) {
+  const raw = rows[0]?.id;
+  const id = Number(raw);
+  if (!Number.isInteger(id) || id <= 0) return void 0;
+  return id;
+}
+function percentOf(done, total) {
+  if (done === null || total === null || total <= 0) return null;
+  return Math.min(100, done / total * 100);
+}
+function toNumber(value) {
+  if (value === null || value === void 0) return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+function toText(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  return String(value);
+}
+async function rowsOrEmpty(query) {
+  const [result, err] = await attempt(query);
+  return err ? [] : result.rows;
+}
+function toBlockers(rows) {
+  return rows.map((row) => ({
+    pid: Number(row.pid),
+    query: toText(row.query),
+    ageMs: toNumber(row.age_ms)
+  }));
+}
+var postgresProbe = async (side, pid) => {
+  const [activity] = await rowsOrEmpty(() => sql`
+        select a.state, a.wait_event_type, a.wait_event,
+               pg_blocking_pids(a.pid) as blockers,
+               (select count(*)::int from pg_stat_activity w
+                 where w.leader_pid = a.pid and w.pid <> a.pid) as workers
+          from pg_stat_activity a
+         where a.pid = ${pid}
+    `.execute(side));
+  const blockerPids = (activity?.blockers ?? []).map(Number);
+  const blockers = blockerPids.length === 0 ? [] : await rowsOrEmpty(() => sql`
+        select pid, left(query, 120) as query,
+               (extract(epoch from now() - coalesce(xact_start, query_start)) * 1000)::float8 as age_ms
+          from pg_stat_activity
+         where pid = any(${blockerPids}::int[])
+    `.execute(side));
+  const [progress] = await rowsOrEmpty(() => sql`
+        select command as operation, phase,
+               nullif(relid, 0)::regclass::text as relation,
+               (case when tuples_total > 0 then tuples_done else blocks_done end)::float8 as done,
+               (case when tuples_total > 0 then tuples_total else blocks_total end)::float8 as total
+          from pg_stat_progress_create_index where pid = ${pid}
+        union all
+        select 'VACUUM', phase, nullif(relid, 0)::regclass::text,
+               heap_blks_scanned::float8, heap_blks_total::float8
+          from pg_stat_progress_vacuum where pid = ${pid}
+        union all
+        select command, phase, nullif(relid, 0)::regclass::text,
+               heap_blks_scanned::float8, heap_blks_total::float8
+          from pg_stat_progress_cluster where pid = ${pid}
+        union all
+        select command, null, nullif(relid, 0)::regclass::text,
+               bytes_processed::float8, nullif(bytes_total, 0)::float8
+          from pg_stat_progress_copy where pid = ${pid}
+        union all
+        select 'ANALYZE', phase, nullif(relid, 0)::regclass::text,
+               sample_blks_scanned::float8, sample_blks_total::float8
+          from pg_stat_progress_analyze where pid = ${pid}
+        limit 1
+    `.execute(side));
+  const waitEvent = activity?.wait_event ? `${activity.wait_event_type ?? "Wait"}: ${activity.wait_event}` : null;
+  return {
+    state: toText(activity?.state),
+    waitEvent,
+    blockedBy: toBlockers(blockers),
+    workers: toNumber(activity?.workers) ?? 0,
+    progress: progress ? {
+      operation: progress.operation,
+      phase: toText(progress.phase),
+      relation: toText(progress.relation),
+      done: toNumber(progress.done),
+      total: toNumber(progress.total),
+      percent: percentOf(toNumber(progress.done), toNumber(progress.total))
+    } : null
+  };
+};
+var mssqlProbe = async (side, spid) => {
+  const [request] = await rowsOrEmpty(() => sql`
+        select status, wait_type, blocking_session_id, percent_complete, command
+          from sys.dm_exec_requests
+         where session_id = ${spid}
+    `.execute(side));
+  const blockerId = toNumber(request?.blocking_session_id);
+  const blockers = !blockerId ? [] : await rowsOrEmpty(() => sql`
+        select s.session_id as pid,
+               coalesce(left(t.text, 120), r.command, s.status) as query,
+               datediff_big(millisecond, coalesce(r.start_time, s.last_request_start_time), sysdatetime()) as age_ms
+          from sys.dm_exec_sessions s
+          left join sys.dm_exec_requests r on r.session_id = s.session_id
+          outer apply sys.dm_exec_sql_text(r.sql_handle) t
+         where s.session_id = ${blockerId}
+    `.execute(side));
+  const percent = toNumber(request?.percent_complete);
+  return {
+    state: toText(request?.status),
+    waitEvent: toText(request?.wait_type),
+    blockedBy: toBlockers(blockers),
+    workers: 0,
+    progress: request?.command && percent ? { operation: request.command, phase: null, relation: null, done: null, total: null, percent } : null
+  };
+};
+var mysqlProbe = async (side, id) => {
+  const [process2] = await rowsOrEmpty(() => sql`
+        select state from information_schema.processlist where id = ${id}
+    `.execute(side));
+  const blockerIds = await rowsOrEmpty(() => sql`
+        select blocking_pid as pid from sys.innodb_lock_waits where waiting_pid = ${id}
+        union
+        select blocking_pid from sys.schema_table_lock_waits where waiting_pid = ${id}
+    `.execute(side));
+  const ids = blockerIds.map((row) => Number(row.pid));
+  const blockers = ids.length === 0 ? [] : await rowsOrEmpty(() => sql`
+        select id as pid, left(coalesce(info, command), 120) as query, time * 1000 as age_ms
+          from information_schema.processlist
+         where id in (${sql.join(ids)})
+    `.execute(side));
+  const [stage] = await rowsOrEmpty(() => sql`
+        select s.event_name, s.work_completed, s.work_estimated
+          from performance_schema.events_stages_current s
+          join performance_schema.threads t on t.thread_id = s.thread_id
+         where t.processlist_id = ${id}
+    `.execute(side));
+  const state = toText(process2?.state);
+  const done = toNumber(stage?.work_completed);
+  const total = toNumber(stage?.work_estimated);
+  return {
+    state,
+    waitEvent: state?.startsWith("Waiting") ? state : null,
+    blockedBy: toBlockers(blockers),
+    workers: 0,
+    progress: stage ? {
+      operation: stage.event_name.replace(/^stage\/\w+\//, ""),
+      phase: null,
+      relation: null,
+      done,
+      total,
+      percent: percentOf(done, total)
+    } : null
+  };
+};
+var STATEMENT_PROBES = {
+  postgres: postgresProbe,
+  mssql: mssqlProbe,
+  mysql: mysqlProbe
+};
+
+// src/core/runner/statement-watcher.ts
+var DEFAULT_WATCH_DELAY_MS = 1e4;
+var DEFAULT_WATCH_INTERVAL_MS = 1e4;
+var SIDE_CONNECTION_WAIT_MS = 5e3;
+var StatementWatcher = class {
+  #pool;
+  #dialect;
+  #signal;
+  #delayMs;
+  #intervalMs;
+  #active = null;
+  #side = null;
+  #sideAbandoned = false;
+  #releaseSide = null;
+  #sideHeld = Promise.resolve();
+  #closed = false;
+  #onAbort = () => {
+    const statement = this.#active;
+    if (statement) void this.#cancel(statement);
+  };
+  /**
+   * @param pool - Root connection pool the side connection is checked out
+   *   from. Never a transaction: the side connection must be a separate session.
+   */
+  constructor(pool, options = {}) {
+    this.#pool = pool;
+    this.#dialect = options.dialect;
+    this.#signal = options.signal;
+    this.#delayMs = options.delayMs ?? DEFAULT_WATCH_DELAY_MS;
+    this.#intervalMs = options.intervalMs ?? DEFAULT_WATCH_INTERVAL_MS;
+    this.#signal?.addEventListener("abort", this.#onAbort, { once: true });
+  }
+  /**
+   * Run `fn` on one pinned connection while watching it.
+   *
+   * A transaction is already one connection, so it is used as is; anything
+   * else is pinned with `connection()` so the session id read up front is
+   * the session the SQL runs on.
+   *
+   * @throws OperationAbortedError when the signal aborted before `fn` started
+   */
+  async run(filepath, executor, fn) {
+    if (executor.isTransaction) {
+      return this.#watch(filepath, executor, fn);
+    }
+    return executor.connection().execute((conn) => this.#watch(filepath, conn, fn));
+  }
+  /**
+   * Stop watching and return the side connection to the pool.
+   */
+  async close() {
+    this.#closed = true;
+    this.#signal?.removeEventListener("abort", this.#onAbort);
+    this.#releaseSide?.();
+    await this.#sideHeld;
+  }
+  async #watch(filepath, conn, fn) {
+    const sessionId = await this.#readSessionId(conn);
+    const statement = {
+      filepath,
+      sessionId,
+      startedAt: performance.now(),
+      timer: void 0,
+      finished: false,
+      cancelling: null
+    };
+    if (this.#signal?.aborted) {
+      throw new OperationAbortedError("Run cancelled before the file started");
+    }
+    this.#active = statement;
+    statement.timer = setTimeout(() => void this.#report(statement), this.#delayMs);
+    try {
+      return await fn(conn);
+    } finally {
+      clearTimeout(statement.timer);
+      this.#active = null;
+      statement.finished = true;
+      await statement.cancelling;
+    }
+  }
+  async #readSessionId(conn) {
+    const query = this.#dialect ? SESSION_ID_SQL[this.#dialect] : void 0;
+    if (!query) return null;
+    const [result, err] = await attempt(() => sql.raw(query).execute(conn));
+    if (err) return null;
+    return readSessionId(result.rows) ?? null;
+  }
+  async #report(statement) {
+    if (this.#active !== statement) return;
+    const status = await this.#poll(statement);
+    if (this.#active !== statement) return;
+    observer.emit("file:progress", {
+      filepath: statement.filepath,
+      elapsedMs: performance.now() - statement.startedAt,
+      sessionId: statement.sessionId,
+      status
+    });
+    statement.timer = setTimeout(() => void this.#report(statement), this.#intervalMs);
+  }
+  async #poll(statement) {
+    const probe = this.#dialect ? STATEMENT_PROBES[this.#dialect] : void 0;
+    const sessionId = statement.sessionId;
+    if (!probe || sessionId === null) return null;
+    const side = await this.#sideConnection();
+    if (!side) return null;
+    const [status, err] = await attempt(() => probe(side, sessionId));
+    return err ? null : status;
+  }
+  async #cancel(statement) {
+    const cancel = this.#dialect ? SERVER_CANCEL[this.#dialect] : void 0;
+    const sessionId = statement.sessionId;
+    if (sessionId === null || !cancel) return;
+    const side = await this.#sideConnection();
+    if (statement.finished || this.#closed) return;
+    if (!side) {
+      observer.emit("error", {
+        source: "runner:cancel",
+        error: new Error("No free connection to send the cancel from"),
+        context: { filepath: statement.filepath, sessionId }
+      });
+      return;
+    }
+    const sending = attempt(() => cancel(side, sessionId));
+    statement.cancelling = sending.then(() => void 0);
+    const [, err] = await sending;
+    if (err) {
+      observer.emit("error", {
+        source: "runner:cancel",
+        error: err,
+        context: { filepath: statement.filepath, sessionId }
+      });
+    }
+  }
+  async #sideConnection() {
+    if (this.#closed || this.#sideAbandoned) return null;
+    this.#side ??= this.#checkoutSide();
+    const pending = this.#side;
+    const [side] = await attempt(() => runWithTimeout(() => pending, { timeout: SIDE_CONNECTION_WAIT_MS }));
+    if (!side && this.#side === pending) this.#sideAbandoned = true;
+    return side ?? null;
+  }
+  /**
+   * Check a connection out of the pool and hold it until `close()`.
+   *
+   * Kysely only lends a dedicated connection for the duration of a callback,
+   * so the callback parks on a promise that `close()` resolves. A checkout
+   * that arrives after the watcher gave up on it returns at once.
+   */
+  #checkoutSide() {
+    return new Promise((resolveSide) => {
+      const released = new Promise((release) => {
+        this.#releaseSide = release;
+      });
+      this.#sideHeld = attempt(() => this.#pool.connection().execute(async (side) => {
+        if (this.#sideAbandoned || this.#closed) return;
+        if (this.#active === null) {
+          this.#side = null;
+          resolveSide(null);
+          return;
+        }
+        resolveSide(side);
+        await released;
+      })).then(([, err]) => {
+        if (err) {
+          resolveSide(null);
+          observer.emit("error", {
+            source: "runner:watch",
+            error: err,
+            context: { operation: "side-connection" }
+          });
+        }
+      });
+    });
+  }
+};
 
 // src/core/lock/types.ts
 var DEFAULT_LOCK_OPTIONS = {
@@ -6618,6 +6961,7 @@ var ChangeRollback = class extends Error {
 async function executeFiles(context, change, files, direction, checksum, force, history, startTime) {
   const dialect = context.dialect ?? "postgres";
   const expandedFiles = await expandFiles(files, context.sqlDir);
+  const watcher = new StatementWatcher(context.db, { dialect });
   if (!TRANSACTIONAL_DIALECTS.has(dialect)) {
     return runFileBatch(
       context,
@@ -6628,8 +6972,9 @@ async function executeFiles(context, change, files, direction, checksum, force,
       force,
       history,
       context.db,
-      startTime
-    );
+      startTime,
+      watcher
+    ).finally(() => watcher.close());
   }
   const [result, err] = await attempt(
     () => context.db.transaction().execute(async (trx) => {
@@ -6643,7 +6988,8 @@ async function executeFiles(context, change, files, direction, checksum, force,
         force,
         trxHistory,
         trx,
-        startTime
+        startTime,
+        watcher
       );
       if (batchResult.status !== "success") {
         throw new ChangeRollback(batchResult);
@@ -6651,6 +6997,7 @@ async function executeFiles(context, change, files, direction, checksum, force,
       return batchResult;
     })
   );
+  await watcher.close();
   if (err) {
     if (err instanceof ChangeRollback) {
       return { ...err.result, operationId: void 0 };
@@ -6659,7 +7006,7 @@ async function executeFiles(context, change, files, direction, checksum, force,
   }
   return result;
 }
-async function runFileBatch(context, change, expandedFiles, direction, checksum, force, history, executor, startTime) {
+async function runFileBatch(context, change, expandedFiles, direction, checksum, force, history, executor, startTime, watcher) {
   const [operationId, createErr] = await attempt(
     () => history.createOperation({
       name: change.name,
@@ -6783,7 +7130,9 @@ async function runFileBatch(context, change, expandedFiles, direction, checksum,
         }
         break;
       }
-      const [, execErr] = await attempt(() => sql.raw(sqlContent).execute(executor));
+      const [, execErr] = await attempt(
+        () => watcher.run(file.path, executor, (conn) => sql.raw(sqlContent).execute(conn))
+      );
       const durationMs = performance.now() - fileStart;
       if (execErr) {
         const errorMessage2 = getSqlErrorMessage(execErr);
@@ -7554,7 +7903,7 @@ async function resolveVaultKey(db, dialect) {
 async function buildSecretsContext(stateManager, configName, db, vaultKey, dialect) {
   const secrets = {};
   if (db && vaultKey) {
-    const { getAllVaultSecrets: getAllVaultSecrets2 } = await import('./storage-V6BHWNS3.js');
+    const { getAllVaultSecrets: getAllVaultSecrets2 } = await import('./storage-FBDOY3MC.js');
     const vaultSecrets = await getAllVaultSecrets2(db, vaultKey, dialect ?? "postgres");
     for (const [key, secret] of Object.entries(vaultSecrets)) {
       secrets[key] = secret.value;
@@ -8358,10 +8707,11 @@ async function runFile(context, filepath, options = {}) {
       error: createErr.message
     };
   }
-  const result = await executeSingleFile(context, filepath, opts, tracker, operationId);
+  const watcher = createWatcher(context);
+  const result = await executeSingleFile(context, filepath, opts, tracker, operationId, watcher).finally(() => watcher.close());
   await tracker.finalizeOperation(
     operationId,
-    result.status === "failed" ? "failed" : "success",
+    result.status === "failed" || result.error ? "failed" : "success",
     Math.round(result.durationMs ?? 0),
     result.checksum,
     result.error
@@ -8445,6 +8795,31 @@ var DEFAULT_RUN_OPTIONS_INTERNAL = {
   preview: false,
   output: null
 };
+var RUN_CANCELLED = "Run cancelled";
+function createWatcher(context) {
+  return new StatementWatcher(context.db, {
+    dialect: context.dialect ?? "postgres",
+    signal: context.signal
+  });
+}
+var NOT_STARTED = /* @__PURE__ */ Symbol("not-started");
+async function runWatched(context, watcher, filepath, sqlContent) {
+  const [execErrMsg, err] = await attempt(
+    () => watcher.run(filepath, context.db, (conn) => executeSqlBody({ ...context, db: conn }, sqlContent))
+  );
+  if (err instanceof OperationAbortedError) return NOT_STARTED;
+  return err ? getSqlErrorMessage(err) : execErrMsg;
+}
+async function skipRemaining(tracker, operationId, reason) {
+  const skipErr = await tracker.skipRemainingFiles(operationId, reason.slice(0, 100));
+  if (skipErr) {
+    observer.emit("error", {
+      source: "runner:skip-remaining",
+      error: new Error(skipErr),
+      context: { operationId }
+    });
+  }
+}
 async function executeFiles2(context, files, runOptions, execOptions) {
   const start = performance.now();
   const opts = { ...DEFAULT_RUN_OPTIONS_INTERNAL, ...runOptions };
@@ -8532,34 +8907,48 @@ async function executeFiles2(context, files, runOptions, execOptions) {
   }
   const results = [];
   let failed = false;
-  for (let i = 0; i < files.length; i++) {
-    const file = files[i];
-    const fileRecord = fileRecords[i];
-    const result = await executeSingleFileWithUpdate(
-      context,
-      file.path,
-      fileRecord.checksum,
-      opts,
-      tracker,
-      operationId,
-      execOptions.changeType
-    );
-    results.push(result);
-    if (result.status === "failed" && opts.abortOnError) {
-      failed = true;
-      const skipErr = await tracker.skipRemainingFiles(
+  let cancelled = false;
+  const watcher = createWatcher(context);
+  try {
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      const fileRecord = fileRecords[i];
+      if (context.signal?.aborted) {
+        failed = true;
+        cancelled = true;
+        await skipRemaining(tracker, operationId, RUN_CANCELLED);
+        break;
+      }
+      const result = await executeSingleFileWithUpdate(
+        context,
+        file.path,
+        fileRecord.checksum,
+        opts,
+        tracker,
         operationId,
-        `Skipped: failure in ${path.basename(file.path)}`.slice(0, 100)
+        execOptions.changeType,
+        watcher
       );
-      if (skipErr) {
-        observer.emit("error", {
-          source: "runner:skip-remaining",
-          error: new Error(skipErr),
-          context: { operationId }
-        });
+      if (!result) {
+        failed = true;
+        cancelled = true;
+        await skipRemaining(tracker, operationId, RUN_CANCELLED);
+        break;
+      }
+      results.push(result);
+      cancelled = (context.signal?.aborted ?? false) && (i < files.length - 1 || result.status === "failed");
+      if (cancelled || result.status === "failed" && opts.abortOnError) {
+        failed = true;
+        await skipRemaining(
+          tracker,
+          operationId,
+          cancelled ? RUN_CANCELLED : `Skipped: failure in ${path.basename(file.path)}`
+        );
+        break;
       }
-      break;
     }
+  } finally {
+    await watcher.close();
   }
   if (!failed && results.length !== files.length) {
     throw new Error(
@@ -8581,7 +8970,7 @@ async function executeFiles2(context, files, runOptions, execOptions) {
     finalStatus,
     Math.round(durationMs),
     combinedChecksum,
-    failed ? results.find((r) => r.status === "failed")?.error : void 0
+    cancelled ? RUN_CANCELLED : failed ? results.find((r) => r.status === "failed")?.error : void 0
   );
   if (finalizeErr) {
     observer.emit("error", {
@@ -8597,7 +8986,8 @@ async function executeFiles2(context, files, runOptions, execOptions) {
     filesSkipped,
     filesFailed,
     durationMs,
-    changeId: operationId
+    changeId: operationId,
+    error: cancelled ? RUN_CANCELLED : void 0
   };
 }
 async function executeFilesInternal(context, files, options, changeType, sqlPath) {
@@ -8613,7 +9003,7 @@ async function executeFilesInternal(context, files, options, changeType, sqlPath
   };
   return executeFiles2(context, fileInputs, options, execOptions);
 }
-async function executeSingleFileWithUpdate(context, filepath, checksum, options, tracker, operationId, changeType) {
+async function executeSingleFileWithUpdate(context, filepath, checksum, options, tracker, operationId, changeType, watcher) {
   const start = performance.now();
   const relFilepath = path.relative(context.projectRoot, filepath);
   const [sqlContent, loadErr] = await attempt(() => loadAndRenderFile2(context, filepath));
@@ -8673,7 +9063,8 @@ async function executeSingleFileWithUpdate(context, filepath, checksum, options,
       return result2;
     }
   }
-  const execErrMsg = await executeSqlBody(context, sqlContent);
+  const execErrMsg = await runWatched(context, watcher, filepath, sqlContent);
+  if (execErrMsg === NOT_STARTED) return null;
   const durationMs = performance.now() - start;
   if (execErrMsg) {
     const error = execErrMsg + await describePriorSuccesses(tracker, relFilepath, operationId);
@@ -8723,7 +9114,7 @@ async function executeSingleFileWithUpdate(context, filepath, checksum, options,
   });
   return result;
 }
-async function executeSingleFile(context, filepath, options, tracker, operationId) {
+async function executeSingleFile(context, filepath, options, tracker, operationId, watcher) {
   const start = performance.now();
   const relFilepath = path.relative(context.projectRoot, filepath);
   const [sqlContent, loadErr] = await attempt(() => loadAndRenderFile2(context, filepath));
@@ -8803,8 +9194,18 @@ async function executeSingleFile(context, filepath, options, tracker, operationI
     });
     return result2;
   }
-  const execErrMsg = await executeSqlBody(context, sqlContent);
+  const execErrMsg = await runWatched(context, watcher, filepath, sqlContent);
   const durationMs = performance.now() - start;
+  if (execErrMsg === NOT_STARTED) {
+    await tracker.recordExecution({
+      changeId: operationId,
+      filepath: relFilepath,
+      checksum,
+      status: "skipped",
+      skipReason: RUN_CANCELLED
+    });
+    return { filepath, checksum, status: "skipped", error: RUN_CANCELLED };
+  }
   if (execErrMsg) {
     const error = execErrMsg + await describePriorSuccesses(tracker, relFilepath, operationId);
     const result2 = {

package/dist/{storage-V6BHWNS3.js → storage-FBDOY3MC.js}

@@ -1,9 +1,9 @@
 import { createRequire } from 'module';
-export { deleteVaultSecret, deleteVaultSecretChecked, getAllVaultSecrets, getVaultKey, getVaultKeyChecked, getVaultSecret, getVaultStatus, initializeVault, initializeVaultChecked, listVaultSecretKeys, listVaultSecretKeysChecked, setVaultSecret, setVaultSecretChecked, vaultSecretExists } from './chunk-OMY6CKR4.js';
-import './chunk-A2OYZAVT.js';
+export { deleteVaultSecret, deleteVaultSecretChecked, getAllVaultSecrets, getVaultKey, getVaultKeyChecked, getVaultSecret, getVaultStatus, initializeVault, initializeVaultChecked, listVaultSecretKeys, listVaultSecretKeysChecked, setVaultSecret, setVaultSecretChecked, vaultSecretExists } from './chunk-WUMCIKEQ.js';
+import './chunk-6LG4ENOJ.js';
 import './chunk-TXDGFA44.js';
 import './chunk-D2XW2UOP.js';
 
 createRequire(import.meta.url);
-//# sourceMappingURL=storage-V6BHWNS3.js.map
-//# sourceMappingURL=storage-V6BHWNS3.js.map
+//# sourceMappingURL=storage-FBDOY3MC.js.map
+//# sourceMappingURL=storage-FBDOY3MC.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noormdev/sdk",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "Database schema & changeset manager SDK",
   "type": "module",
   "main": "./dist/index.js",