@getstrata/core 2.2.8 → 2.2.10

package/dist/entries/queue/queueMetrics.js

@@ -1,4 +1,877 @@
 // @bun
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// ../../src/core/runtime/asyncContextStore.ts
+import { AsyncLocalStorage } from "async_hooks";
+function createAsyncContextStore(key) {
+  const symbol = Symbol.for(key);
+  const globalRecord = globalThis;
+  const existing = globalRecord[symbol];
+  if (existing) {
+    return existing;
+  }
+  const store = new AsyncLocalStorage;
+  globalRecord[symbol] = store;
+  return store;
+}
+var init_asyncContextStore = () => {};
+
+// ../../src/core/database/connectionContext.ts
+function runWithDatabaseConnection(connection, callback) {
+  return activeConnection.run(connection, callback);
+}
+function getActiveDatabaseConnection(fallback) {
+  return activeConnection.getStore() ?? fallback;
+}
+function hasActiveDatabaseConnection() {
+  return activeConnection.getStore() !== undefined;
+}
+var activeConnection;
+var init_connectionContext = __esm(() => {
+  init_asyncContextStore();
+  activeConnection = createAsyncContextStore("@getstrata/databaseConnectionContext");
+});
+
+// ../../src/core/database/schema/driver.ts
+function normalizeConnectionName(connection) {
+  const normalized = connection.trim().toLowerCase();
+  if (normalized === "pgsql" || normalized === "postgres" || normalized === "postgresql") {
+    return "pgsql";
+  }
+  if (normalized === "mysql" || normalized === "mariadb") {
+    return "mysql";
+  }
+  if (normalized === "sqlite") {
+    return "sqlite";
+  }
+  throw new Error(`Unsupported DB_CONNECTION: ${connection}`);
+}
+function resolveDriverFromUrl(url) {
+  const normalized = url.trim().toLowerCase();
+  if (normalized.startsWith("postgres://") || normalized.startsWith("postgresql://") || normalized.startsWith("postgres:")) {
+    return "pgsql";
+  }
+  if (normalized.startsWith("mysql://") || normalized.startsWith("mysql:")) {
+    return "mysql";
+  }
+  if (normalized.startsWith("sqlite:")) {
+    return "sqlite";
+  }
+  return null;
+}
+function resolveDatabaseDriver(options = {}) {
+  const connection = options.connection ?? process.env.DB_CONNECTION;
+  if (connection) {
+    return normalizeConnectionName(connection);
+  }
+  const url = options.url ?? process.env.DATABASE_URL ?? "";
+  const fromUrl = resolveDriverFromUrl(url);
+  if (fromUrl) {
+    return fromUrl;
+  }
+  return "pgsql";
+}
+var init_driver = () => {};
+
+// ../../src/core/database/dialect.ts
+function assertSafeIdentifier(identifier) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+    throw new Error(`Invalid SQL identifier: ${identifier}`);
+  }
+  return identifier;
+}
+function quoteIdentifierFor(dialect, column) {
+  return dialect.quoteIdentifier(column);
+}
+function dialectFor(driver) {
+  return dialects[driver];
+}
+function currentSqlDialect() {
+  return dialectContext.getStore() ?? dialectOverride ?? dialectFor(resolveDatabaseDriver());
+}
+var postgresDialect, mysqlDialect, sqliteDialect, dialects, dialectContext, dialectOverride = null;
+var init_dialect = __esm(() => {
+  init_asyncContextStore();
+  init_driver();
+  postgresDialect = {
+    driver: "pgsql",
+    placeholder(index) {
+      return `$${index}`;
+    },
+    quoteIdentifier(identifier) {
+      return `"${assertSafeIdentifier(identifier)}"`;
+    },
+    nowExpression() {
+      return "NOW()";
+    },
+    epochMillisecondsExpression() {
+      return "CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT)";
+    },
+    rowLockClause(skipLocked = false) {
+      return ` FOR UPDATE${skipLocked ? " SKIP LOCKED" : ""}`;
+    },
+    timestampValue(value) {
+      return value.toISOString();
+    },
+    returningClause(columns) {
+      return ` RETURNING ${columns}`;
+    },
+    ilikeOperator() {
+      return "ILIKE";
+    },
+    nullsLastSuffix() {
+      return " NULLS LAST";
+    },
+    castToText(expression) {
+      return `${expression}::text`;
+    },
+    upsertSuffix(conflictColumns, updateColumns) {
+      const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
+      if (updateColumns.length === 0) {
+        return ` ON CONFLICT (${target}) DO NOTHING`;
+      }
+      const assignments = updateColumns.map((column) => {
+        const quoted = quoteIdentifierFor(this, column);
+        return `${quoted} = excluded.${quoted}`;
+      }).join(", ");
+      return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
+    }
+  };
+  mysqlDialect = {
+    driver: "mysql",
+    placeholder() {
+      return "?";
+    },
+    quoteIdentifier(identifier) {
+      return `\`${assertSafeIdentifier(identifier)}\``;
+    },
+    nowExpression() {
+      return "CURRENT_TIMESTAMP";
+    },
+    epochMillisecondsExpression() {
+      return "CAST(UNIX_TIMESTAMP(CURRENT_TIMESTAMP(3)) * 1000 AS UNSIGNED)";
+    },
+    rowLockClause(skipLocked = false) {
+      return ` FOR UPDATE${skipLocked ? " SKIP LOCKED" : ""}`;
+    },
+    timestampValue(value) {
+      return value.toISOString().slice(0, 19).replace("T", " ");
+    },
+    returningClause() {
+      return "";
+    },
+    ilikeOperator() {
+      return "LIKE";
+    },
+    nullsLastSuffix() {
+      return "";
+    },
+    castToText(expression) {
+      return `CAST(${expression} AS CHAR)`;
+    },
+    upsertSuffix(conflictColumns, updateColumns) {
+      if (updateColumns.length === 0) {
+        const anchor = quoteIdentifierFor(this, conflictColumns[0] ?? "");
+        return ` ON DUPLICATE KEY UPDATE ${anchor} = ${anchor}`;
+      }
+      const assignments = updateColumns.map((column) => {
+        const quoted = quoteIdentifierFor(this, column);
+        return `${quoted} = VALUES(${quoted})`;
+      }).join(", ");
+      return ` ON DUPLICATE KEY UPDATE ${assignments}`;
+    }
+  };
+  sqliteDialect = {
+    driver: "sqlite",
+    placeholder() {
+      return "?";
+    },
+    quoteIdentifier(identifier) {
+      return `"${assertSafeIdentifier(identifier)}"`;
+    },
+    nowExpression() {
+      return "strftime('%Y-%m-%dT%H:%M:%fZ', 'now')";
+    },
+    epochMillisecondsExpression() {
+      return "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
+    },
+    rowLockClause() {
+      return "";
+    },
+    timestampValue(value) {
+      return value.toISOString();
+    },
+    returningClause(columns) {
+      return ` RETURNING ${columns}`;
+    },
+    ilikeOperator() {
+      return "LIKE";
+    },
+    nullsLastSuffix() {
+      return "";
+    },
+    castToText(expression) {
+      return `CAST(${expression} AS TEXT)`;
+    },
+    upsertSuffix(conflictColumns, updateColumns) {
+      const target = conflictColumns.map((column) => quoteIdentifierFor(this, column)).join(", ");
+      if (updateColumns.length === 0) {
+        return ` ON CONFLICT (${target}) DO NOTHING`;
+      }
+      const assignments = updateColumns.map((column) => {
+        const quoted = quoteIdentifierFor(this, column);
+        return `${quoted} = excluded.${quoted}`;
+      }).join(", ");
+      return ` ON CONFLICT (${target}) DO UPDATE SET ${assignments}`;
+    }
+  };
+  dialects = {
+    pgsql: postgresDialect,
+    mysql: mysqlDialect,
+    sqlite: sqliteDialect
+  };
+  dialectContext = createAsyncContextStore("@getstrata/sqlDialect");
+});
+
+// ../../src/core/database/boundConnection.ts
+function boundConnectionState() {
+  const globalRecord = globalThis;
+  const existing = globalRecord[BOUND_CONNECTION_KEY];
+  if (existing) {
+    return existing;
+  }
+  const created = { connection: null };
+  globalRecord[BOUND_CONNECTION_KEY] = created;
+  return created;
+}
+function getBoundDatabaseConnection() {
+  return boundConnectionState().connection;
+}
+var BOUND_CONNECTION_KEY;
+var init_boundConnection = __esm(() => {
+  BOUND_CONNECTION_KEY = Symbol.for("@getstrata/boundDatabaseConnection");
+});
+
+// ../../src/core/database/queryProxy.ts
+var POOL_CONNECTION_METHODS;
+var init_queryProxy = __esm(() => {
+  init_connectionContext();
+  POOL_CONNECTION_METHODS = new Set(["begin", "close", "connect"]);
+});
+
+// ../../src/core/database/defaultConnection.ts
+function defaultConnectionState() {
+  const globalRecord = globalThis;
+  const existing = globalRecord[DEFAULT_CONNECTION_KEY];
+  if (existing) {
+    return existing;
+  }
+  const created = { pool: null, query: null };
+  globalRecord[DEFAULT_CONNECTION_KEY] = created;
+  return created;
+}
+function getDefaultDatabasePool() {
+  const pool = defaultConnectionState().pool;
+  if (!pool) {
+    throw new Error("Default database pool is not registered. Call registerDefaultDatabasePool() during app bootstrap.");
+  }
+  return pool;
+}
+function getDefaultDatabaseQuery() {
+  const query = defaultConnectionState().query;
+  if (!query) {
+    throw new Error("Default database query handle is not registered. Call registerDefaultDatabasePool() during app bootstrap.");
+  }
+  return query;
+}
+var DEFAULT_CONNECTION_KEY;
+var init_defaultConnection = __esm(() => {
+  init_queryProxy();
+  DEFAULT_CONNECTION_KEY = Symbol.for("@getstrata/defaultDatabaseConnection");
+});
+
+// ../../src/core/database/repositoryConnection.ts
+function resolveRepositoryConnection() {
+  return getActiveDatabaseConnection(getBoundDatabaseConnection() ?? getDefaultDatabaseQuery());
+}
+function compileTaggedSql(strings, values) {
+  const dialect = currentSqlDialect();
+  let query = strings[0] ?? "";
+  const params = [];
+  for (let index = 0;index < values.length; index += 1) {
+    params.push(values[index]);
+    query += `${dialect.placeholder(params.length)}${strings[index + 1] ?? ""}`;
+  }
+  return { query, params };
+}
+function isTaggedStrings(value) {
+  if (!Array.isArray(value) || typeof value[0] !== "string") {
+    return false;
+  }
+  return typeof value.raw !== "undefined";
+}
+function runOnConnection(connection, args) {
+  if (typeof connection === "function") {
+    return connection(...args);
+  }
+  if (typeof connection.unsafe !== "function") {
+    throw new Error("Database connection cannot run SQL.");
+  }
+  const strings = args[0];
+  if (!isTaggedStrings(strings)) {
+    throw new Error("Database connection cannot run tagged SQL.");
+  }
+  const compiled = compileTaggedSql(strings, args.slice(1));
+  return connection.unsafe(compiled.query, compiled.params);
+}
+var repositoryConnection;
+var init_repositoryConnection = __esm(() => {
+  init_boundConnection();
+  init_connectionContext();
+  init_defaultConnection();
+  init_dialect();
+  repositoryConnection = new Proxy(function repositoryConnection() {}, {
+    apply(_target, _thisArg, args) {
+      return runOnConnection(resolveRepositoryConnection(), args);
+    },
+    get(_target, property) {
+      const connection = resolveRepositoryConnection();
+      const value = connection[property];
+      return typeof value === "function" ? value.bind(connection) : value;
+    }
+  });
+});
+
+// ../../src/core/tenant/tenantContext.ts
+function runWithTenant(tenant, callback) {
+  return tenantContext.run(tenant, callback);
+}
+function currentTenant() {
+  return tenantContext.getStore() ?? null;
+}
+var tenantContext;
+var init_tenantContext = __esm(() => {
+  init_asyncContextStore();
+  tenantContext = createAsyncContextStore("@getstrata/tenantContext");
+});
+
+// ../../src/core/events/eventBus.ts
+class EventBus {
+  constructor() {}
+  transactionalListeners = new Map;
+  listenTransactional(event, listener) {
+    const handlers = this.transactionalListeners.get(event) ?? new Set;
+    handlers.add(listener);
+    this.transactionalListeners.set(event, handlers);
+    return () => {
+      handlers.delete(listener);
+      if (!handlers.size)
+        this.transactionalListeners.delete(event);
+    };
+  }
+  hasTransactionalListeners(event) {
+    return (this.transactionalListeners.get(event)?.size ?? 0) > 0;
+  }
+  async dispatchTransactional(event, payload) {
+    for (const listener of this.transactionalListeners.get(event) ?? [])
+      await listener(payload);
+  }
+  listeners = new Map;
+  on(event, listener) {
+    return this.listen(event, listener);
+  }
+  listen(event, listener) {
+    const handlers = this.listeners.get(event) ?? new Set;
+    handlers.add(listener);
+    this.listeners.set(event, handlers);
+    return () => {
+      handlers.delete(listener);
+      if (handlers.size === 0) {
+        this.listeners.delete(event);
+      }
+    };
+  }
+  async emit(event, payload) {
+    await this.dispatch(event, payload);
+  }
+  async dispatch(event, payload) {
+    const handlers = this.listeners.get(event);
+    if (!handlers || handlers.size === 0) {
+      return;
+    }
+    for (const handler of handlers) {
+      await handler(payload);
+    }
+  }
+}
+function readSharedEventBus() {
+  const globalBus = globalThis[EVENT_BUS_KEY];
+  if (globalBus) {
+    return globalBus;
+  }
+  const bus = new EventBus;
+  globalThis[EVENT_BUS_KEY] = bus;
+  return bus;
+}
+var EVENT_BUS_KEY, eventBus;
+var init_eventBus = __esm(() => {
+  EVENT_BUS_KEY = Symbol.for("@getstrata/eventBus");
+  eventBus = readSharedEventBus();
+});
+
+// ../../src/core/database/transactionControl.ts
+function unwrapTransactionRollback(error, depth = 0) {
+  if (error instanceof TransactionRollback) {
+    return error;
+  }
+  if (depth >= 5 || !(error instanceof Error) || error.cause === undefined) {
+    return null;
+  }
+  return unwrapTransactionRollback(error.cause, depth + 1);
+}
+function hasActiveTransaction() {
+  return hasActiveDatabaseConnection() && (transactionScopes.getStore()?.rollback.length ?? 0) > 0;
+}
+function requestTransactionRollback() {
+  const state = transactionScopes.getStore();
+  const index = state ? state.rollback.length - 1 : -1;
+  if (!state || index < 0) {
+    return;
+  }
+  const flags = state.rollback;
+  const current = flags[index];
+  if (current === undefined) {
+    return;
+  }
+  flags[index] = true;
+}
+function scopeRequestsRollback() {
+  const state = transactionScopes.getStore();
+  if (!state || state.rollback.length === 0) {
+    return false;
+  }
+  return state.rollback[state.rollback.length - 1] === true;
+}
+async function commitOrRollbackScope(result) {
+  if (scopeRequestsRollback()) {
+    throw new TransactionRollback(result);
+  }
+  return result;
+}
+async function settleTransaction(work) {
+  try {
+    return await work();
+  } catch (error) {
+    const rollback = unwrapTransactionRollback(error);
+    if (rollback) {
+      return rollback.result;
+    }
+    throw error;
+  }
+}
+async function runWithTransactionScope(callback) {
+  const existing = transactionScopes.getStore();
+  if (existing) {
+    existing.rollback.push(false);
+    try {
+      return await callback();
+    } finally {
+      existing.rollback.pop();
+    }
+  }
+  const state = { rollback: [false] };
+  return await transactionScopes.run(state, callback);
+}
+var TransactionRollback, transactionScopes;
+var init_transactionControl = __esm(() => {
+  init_asyncContextStore();
+  init_connectionContext();
+  TransactionRollback = class TransactionRollback extends Error {
+    result;
+    constructor(result) {
+      super("Transaction rolled back");
+      this.name = "TransactionRollback";
+      this.result = result;
+    }
+  };
+  transactionScopes = createAsyncContextStore("@getstrata/transactionScopes");
+});
+
+// ../../src/core/tenant/tenancyConfig.ts
+function readTenancyDriver(env = process.env) {
+  const raw = env.TENANCY_DRIVER?.trim();
+  if (raw === undefined || raw === "") {
+    return "rls";
+  }
+  if (TENANCY_DRIVERS.includes(raw)) {
+    return raw;
+  }
+  throw new Error(`TENANCY_DRIVER must be one of ${TENANCY_DRIVERS.join(", ")}; received "${raw}".`);
+}
+function isTenancyEnabled(env = process.env) {
+  return readTenancyDriver(env) !== "none";
+}
+function isRlsTenancy(env = process.env) {
+  return readTenancyDriver(env) === "rls";
+}
+var TENANCY_DRIVERS;
+var init_tenancyConfig = __esm(() => {
+  TENANCY_DRIVERS = ["rls", "column", "none"];
+});
+
+// ../../src/core/tenant/databaseTenantContext.ts
+import { getDefaultDatabasePool as getDefaultDatabasePool2 } from "@getstrata/core/database/defaultConnection";
+async function applyBypassToTransaction(transaction, bypass) {
+  await transaction.unsafe(`SELECT set_config('app.bypass_rls', $1, true)`, [
+    bypass ? "true" : "false"
+  ]);
+}
+function stringifyBypassIdentifier(identifier) {
+  if (typeof identifier === "number") {
+    return String(identifier);
+  }
+  return identifier.trim();
+}
+async function applyIdentifierToTransaction(transaction, identifier) {
+  await transaction.unsafe(`SELECT set_config('app.bypass_identifier', $1, true)`, [
+    stringifyBypassIdentifier(identifier)
+  ]);
+}
+function assertBypassIdentifier(identifier) {
+  if (typeof identifier === "number") {
+    if (!Number.isInteger(identifier) || identifier <= 0) {
+      throw new Error("RLS bypass requires a caller-supplied identifier that pins the row.");
+    }
+    return;
+  }
+  if (typeof identifier === "string" && identifier.trim() !== "") {
+    return;
+  }
+  throw new Error("RLS bypass requires a caller-supplied identifier that pins the row.");
+}
+async function runWithScopedTenantTransaction(apply, callback) {
+  if (!isRlsTenancy()) {
+    return await callback();
+  }
+  if (hasActiveDatabaseConnection()) {
+    const connection = getActiveDatabaseConnection(getDefaultDatabasePool2());
+    return await runInTransaction(async () => {
+      const [previous] = await connection.unsafe(`SELECT current_setting('app.tenant_id', true) AS tenant_id,
+        current_setting('app.bypass_rls', true) AS bypass_rls,
+        current_setting('app.bypass_identifier', true) AS bypass_identifier`);
+      await apply(connection);
+      const result = await callback();
+      await connection.unsafe(`SELECT set_config('app.tenant_id', $1, true),
+        set_config('app.bypass_rls', $2, true), set_config('app.bypass_identifier', $3, true)`, [previous?.tenant_id ?? "", previous?.bypass_rls ?? "", previous?.bypass_identifier ?? ""]);
+      return result;
+    });
+  }
+  const pool = getDefaultDatabasePool2();
+  const begin = pool.begin;
+  if (typeof begin !== "function") {
+    throw new Error("RLS migration bypass requires a pool that supports begin(). Session-scoped set_config is not used on pooled connections.");
+  }
+  return await settleTransaction(() => runWithDeferredModelEvents(async () => {
+    return await begin.bind(pool)(async (transaction) => {
+      await apply(transaction);
+      return await runWithDatabaseConnection(transaction, () => runWithTransactionScope(async () => commitOrRollbackScope(await callback())));
+    });
+  }));
+}
+async function runWithMigrationBypass(callback) {
+  return await runWithScopedTenantTransaction((transaction) => applyBypassToTransaction(transaction, true), callback);
+}
+async function runWithMigrationBypassForIdentifier(identifier, callback) {
+  assertBypassIdentifier(identifier);
+  return await runWithScopedTenantTransaction((transaction) => applyIdentifierToTransaction(transaction, identifier), callback);
+}
+var init_databaseTenantContext = __esm(() => {
+  init_connectionContext();
+  init_transaction();
+  init_transactionControl();
+  init_deferredModelEvents();
+  init_tenancyConfig();
+});
+
+// ../../src/core/tenant/tenantDatabaseScope.ts
+import { getDefaultDatabasePool as getDefaultDatabasePool3 } from "@getstrata/core/database/defaultConnection";
+async function applyTenantContextToTransaction(transaction, tenantId) {
+  await transaction.unsafe(`SELECT set_config('app.tenant_id', $1, true)`, [String(tenantId)]);
+  await transaction.unsafe(`SELECT set_config('app.bypass_rls', $1, true)`, ["false"]);
+}
+async function runWithTenantDatabase(tenant, callback) {
+  const outerTenant = currentTenant();
+  if (hasActiveDatabaseConnection() && outerTenant && outerTenant.id !== tenant.id) {
+    throw new Error("Cannot switch tenants inside an active database transaction.");
+  }
+  if (!isTenancyEnabled() || !isRlsTenancy()) {
+    return await runWithTenant(tenant, callback);
+  }
+  if (hasActiveDatabaseConnection()) {
+    const activeConnection = getActiveDatabaseConnection(getDefaultDatabasePool3());
+    return await runWithScopedTenantTransaction(() => applyTenantContextToTransaction(activeConnection, tenant.id), () => runWithTenant(tenant, callback));
+  }
+  const pool = getDefaultDatabasePool3();
+  const begin = pool.begin;
+  if (typeof begin !== "function") {
+    throw new Error("RLS tenant scope requires a pool that supports begin(). Session-scoped set_config is not used on pooled connections.");
+  }
+  return await settleTransaction(() => runWithDeferredModelEvents(async () => {
+    return await begin.bind(pool)(async (transaction) => {
+      await applyTenantContextToTransaction(transaction, tenant.id);
+      return await runWithDatabaseConnection(transaction, async () => {
+        return await runWithTransactionScope(async () => commitOrRollbackScope(await runWithTenant(tenant, callback)));
+      });
+    });
+  }));
+}
+function isInsideTenantDatabaseScope(tenantId = currentTenant()?.id) {
+  return hasActiveDatabaseConnection() && currentTenant()?.id === tenantId;
+}
+var init_tenantDatabaseScope = __esm(() => {
+  init_connectionContext();
+  init_transactionControl();
+  init_deferredModelEvents();
+  init_databaseTenantContext();
+  init_tenancyConfig();
+  init_tenantContext();
+});
+
+// ../../src/core/events/deferredModelEvents.ts
+function sameTenant(left, right) {
+  if (left === null && right === null) {
+    return true;
+  }
+  if (left === null || right === null) {
+    return false;
+  }
+  return left.id === right.id;
+}
+function groupQueuedModelEvents(queued) {
+  const groups = [];
+  for (const item of queued) {
+    const lastGroup = groups[groups.length - 1];
+    const last = lastGroup?.[lastGroup.length - 1];
+    if (!lastGroup || !last || !sameTenant(last.tenant, item.tenant)) {
+      groups.push([item]);
+    } else {
+      lastGroup.push(item);
+    }
+  }
+  return groups;
+}
+async function dispatchEventBatch(batch) {
+  for (const item of batch) {
+    await eventBus.dispatch(item.event, item.payload);
+  }
+}
+async function dispatchQueuedModelEvents(queued) {
+  if (queued.length === 0) {
+    return;
+  }
+  await Promise.resolve().then(() => init_tenantDatabaseScope());
+  for (const batch of groupQueuedModelEvents(queued)) {
+    const tenant = batch[0]?.tenant ?? null;
+    if (tenant) {
+      await runWithTenantDatabase(tenant, () => dispatchEventBatch(batch));
+    } else {
+      await dispatchEventBatch(batch);
+    }
+  }
+}
+async function runWithDeferredModelEvents(callback) {
+  const existing = deferredModelEvents.getStore();
+  if (existing) {
+    existing.frames.push([]);
+    existing.rollbackFrames.push([]);
+    try {
+      const result = await callback();
+      const nested = existing.frames.pop() ?? [];
+      const rollback = existing.rollbackFrames.pop() ?? [];
+      existing.rollbackFrames.at(-1)?.push(...rollback);
+      const parent = existing.frames[existing.frames.length - 1];
+      if (parent) {
+        parent.push(...nested);
+      }
+      return result;
+    } catch (error) {
+      existing.frames.pop();
+      for (const rollback of (existing.rollbackFrames.pop() ?? []).reverse())
+        rollback();
+      throw error;
+    }
+  }
+  const state = { frames: [[]], rollbackFrames: [[]] };
+  let result;
+  try {
+    result = await deferredModelEvents.run(state, callback);
+  } catch (error) {
+    for (const rollback of (state.rollbackFrames[0] ?? []).reverse())
+      rollback();
+    throw error;
+  }
+  await dispatchQueuedModelEvents(state.frames[0] ?? []);
+  return result;
+}
+var deferredModelEvents;
+var init_deferredModelEvents = __esm(() => {
+  init_asyncContextStore();
+  init_tenantContext();
+  init_eventBus();
+  deferredModelEvents = createAsyncContextStore("@getstrata/deferredModelEvents");
+});
+
+// ../../src/core/database/acquisitionMetrics.ts
+async function observeTransactionAcquisition(metrics, acquire, signal) {
+  const state = states.get(metrics);
+  if (!state)
+    throw new TypeError("Transaction acquisition metrics must be created by the framework factory.");
+  const started = performance.now();
+  state.inflight++;
+  let outcome = "acquired";
+  try {
+    return await acquire();
+  } catch (error) {
+    outcome = signal?.aborted ? "aborted" : "failed";
+    throw error;
+  } finally {
+    state.inflight--;
+    const elapsed = Math.max(0, performance.now() - started) / 1000;
+    const histogram = state.outcomes[outcomes.indexOf(outcome)];
+    if (histogram) {
+      histogram.count++;
+      histogram.sumSeconds += elapsed;
+      for (let index = 0;index < ACQUISITION_BUCKETS_SECONDS.length; index++) {
+        const bound = ACQUISITION_BUCKETS_SECONDS[index];
+        if (bound !== undefined && elapsed <= bound)
+          histogram.buckets[index] = (histogram.buckets[index] ?? 0) + 1;
+      }
+    }
+  }
+}
+var ACQUISITION_BUCKETS_SECONDS, outcomes, metricsBrand, states;
+var init_acquisitionMetrics = __esm(() => {
+  ACQUISITION_BUCKETS_SECONDS = [
+    0.001,
+    0.005,
+    0.01,
+    0.025,
+    0.05,
+    0.1,
+    0.25,
+    0.5,
+    1,
+    2.5,
+    5,
+    10
+  ];
+  outcomes = ["acquired", "failed", "aborted"];
+  metricsBrand = Symbol("transaction acquisition metrics");
+  states = new WeakMap;
+});
+
+// ../../src/core/database/connection.ts
+function createDatabaseConnection(source) {
+  return {
+    async unsafe(query, params = []) {
+      return await source.unsafe(query, params);
+    }
+  };
+}
+var init_connection = () => {};
+
+// ../../src/core/database/transaction.ts
+async function runInSavepoint(connection, operation) {
+  const inherited = transactionFrame.getStore();
+  let parent = inherited?.connection === connection ? inherited : outerFrames.get(connection);
+  if (!parent) {
+    parent = { connection, childActive: false };
+    outerFrames.set(connection, parent);
+  }
+  if (parent.childActive) {
+    throw new Error("Concurrent nested transactions on one connection are not supported. Await each transaction before starting the next.");
+  }
+  parent.childActive = true;
+  const name = `strata_${crypto.randomUUID().replaceAll("-", "")}`;
+  try {
+    return await settleTransaction(() => runWithDeferredModelEvents(async () => {
+      await connection.unsafe(`SAVEPOINT ${name}`);
+      try {
+        const result = await transactionFrame.run({ connection, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await operation(createDatabaseConnection(connection)))));
+        await connection.unsafe(`RELEASE SAVEPOINT ${name}`);
+        return result;
+      } catch (error) {
+        await connection.unsafe(`ROLLBACK TO SAVEPOINT ${name}`);
+        await connection.unsafe(`RELEASE SAVEPOINT ${name}`);
+        throw error;
+      }
+    }));
+  } finally {
+    parent.childActive = false;
+  }
+}
+function supportsTransactions(connection) {
+  return typeof connection.begin === "function";
+}
+async function runInTransaction(operation, options = {}) {
+  const signal = options.acquisitionSignal;
+  signal?.throwIfAborted();
+  const admittedOperation = (connection) => {
+    signal?.throwIfAborted();
+    return operation(connection);
+  };
+  const pool = resolveRepositoryConnection();
+  if (hasActiveDatabaseConnection()) {
+    return await runInSavepoint(getActiveDatabaseConnection(pool), admittedOperation);
+  }
+  if (!supportsTransactions(pool)) {
+    throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
+  }
+  return await settleTransaction(() => runWithDeferredModelEvents(async () => {
+    let reserved;
+    if (signal || options.acquisitionMetrics) {
+      if (!pool.reserve)
+        throw new Error(signal ? "Active database connection does not support cancellable transaction acquisition." : "Active database connection does not support observable transaction acquisition.");
+      const reserve = pool.reserve.bind(pool);
+      reserved = options.acquisitionMetrics ? await observeTransactionAcquisition(options.acquisitionMetrics, () => reserve({ signal }), signal) : await reserve({ signal });
+    }
+    const connection = reserved ?? pool;
+    try {
+      signal?.throwIfAborted();
+      if (!supportsTransactions(connection))
+        throw new Error("Reserved database connection does not support transactions.");
+      return await connection.begin(async (transaction) => {
+        return await runWithDatabaseConnection(transaction, () => transactionFrame.run({ connection: transaction, childActive: false }, () => runWithTransactionScope(async () => commitOrRollbackScope(await admittedOperation(createDatabaseConnection(transaction))))));
+      });
+    } finally {
+      await reserved?.release();
+    }
+  }));
+}
+var transactionFrame, outerFrames;
+var init_transaction = __esm(() => {
+  init_deferredModelEvents();
+  init_asyncContextStore();
+  init_acquisitionMetrics();
+  init_connection();
+  init_connectionContext();
+  init_repositoryConnection();
+  init_transactionControl();
+  init_acquisitionMetrics();
+  transactionFrame = createAsyncContextStore("@getstrata/transactionFrame");
+  outerFrames = new WeakMap;
+});
+
 // ../../src/core/queue/queueMetrics.ts
 var {RedisClient: RedisClient3 } = globalThis.Bun;
 
@@ -1319,6 +2192,117 @@ function createAppQueue(driver, redisUrl, failedJobs = createFailedJobService(),
   });
 }
 
+// ../../src/core/database/postgresReadOnlyCollector.ts
+init_connectionContext();
+init_dialect();
+init_repositoryConnection();
+init_transaction();
+function createPostgresReadOnlyCollector(name, timeoutMs, collect) {
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 5000)
+    throw new TypeError(`${name} timeout must be between 1 and 5000 milliseconds.`);
+  let active;
+  let closed = false;
+  return {
+    async collect() {
+      if (closed)
+        throw new Error(`${name} collector is closed.`);
+      if (hasActiveTransaction() || hasActiveDatabaseConnection())
+        throw new Error(`${name} require an independent transaction.`);
+      if (currentSqlDialect().driver !== "pgsql")
+        throw new Error(`${name} currently require Postgres.`);
+      if (active)
+        throw new Error(`${name} collection is still settling.`);
+      const deadline = performance.now() + timeoutMs;
+      let expired = false;
+      const acquisition = new AbortController;
+      let timer;
+      const remaining = () => {
+        const value = Math.floor(deadline - performance.now());
+        if (expired || value < 1)
+          throw new Error(`${name} collection timed out.`);
+        return value;
+      };
+      const work = runInTransaction(async () => {
+        await repositoryConnection.unsafe("SELECT set_config('statement_timeout', $1, true)", [`${remaining()}ms`]);
+        await repositoryConnection.unsafe("SET TRANSACTION READ ONLY");
+        remaining();
+        const result = await collect(remaining);
+        remaining();
+        return result;
+      }, { acquisitionSignal: acquisition.signal });
+      active = work;
+      work.finally(() => {
+        if (active === work)
+          active = undefined;
+      }).catch(() => {});
+      try {
+        return await Promise.race([
+          work,
+          new Promise((_, reject) => {
+            timer = setTimeout(() => {
+              expired = true;
+              const error = new Error(`${name} collection timed out.`);
+              acquisition.abort(error);
+              reject(error);
+            }, timeoutMs);
+          })
+        ]);
+      } finally {
+        if (timer !== undefined)
+          clearTimeout(timer);
+      }
+    },
+    async close() {
+      closed = true;
+      await active?.catch(() => {});
+    }
+  };
+}
+
+// ../../src/core/queue/failedJobMetrics.ts
+init_repositoryConnection();
+var schemaQuery = `SELECT c.relkind = 'r' AND c.relpersistence = 'p' AND NOT c.relrowsecurity AND EXISTS (
+  SELECT 1 FROM pg_index i JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = i.indkey[0]
+  WHERE i.indrelid = c.oid AND i.indisprimary AND i.indisvalid AND i.indisready
+    AND i.indnkeyatts = 1 AND a.attname = 'id' AND NOT a.attisdropped
+    AND a.atttypid IN ('int2'::regtype, 'int4'::regtype, 'int8'::regtype)
+) AS supported FROM pg_class c WHERE c.oid = 'failed_job'::regclass`;
+function createFailedJobMetricsCollector(options = {}) {
+  const sampleLimit = options.sampleLimit ?? 500;
+  if (!Number.isSafeInteger(sampleLimit) || sampleLimit < 1 || sampleLimit > 1000)
+    throw new TypeError("Failed-job metrics sample limit must be between 1 and 1000.");
+  const repository = new failedJobRepository_default;
+  return createPostgresReadOnlyCollector("Failed-job metrics", options.timeoutMs ?? 1000, async (remaining) => {
+    await repositoryConnection.unsafe('LOCK TABLE "failed_job" IN ACCESS SHARE MODE');
+    const schema = await repositoryConnection.unsafe(schemaQuery);
+    if (schema.length !== 1 || schema[0]?.supported !== true)
+      throw new Error("Failed-job metrics require the standard global table with an ID primary key and no RLS.");
+    remaining();
+    const rows = await repository.query().orderBy({ column: "id", direction: "ASC" }).project(["id"], sampleLimit + 1);
+    if (rows.length > sampleLimit + 1 || rows.some((row) => row.id == null))
+      throw new Error("Invalid failed-job metrics response.");
+    return {
+      sampleLimit,
+      count: Math.min(rows.length, sampleLimit),
+      capped: rows.length > sampleLimit
+    };
+  });
+}
+function renderFailedJobMetrics(snapshot) {
+  if (!Number.isSafeInteger(snapshot.sampleLimit) || snapshot.sampleLimit < 1 || snapshot.sampleLimit > 1000 || !Number.isSafeInteger(snapshot.count) || snapshot.count < 0 || snapshot.count > snapshot.sampleLimit || typeof snapshot.capped !== "boolean" || snapshot.capped && snapshot.count !== snapshot.sampleLimit)
+    throw new TypeError("Invalid failed-job metrics snapshot.");
+  return `# HELP strata_queue_failed_job_collector_success Whether failed-job collection succeeded.
+# TYPE strata_queue_failed_job_collector_success gauge
+strata_queue_failed_job_collector_success 1
+# HELP strata_queue_failed_jobs_sample Capped retained failed-job count; a lower bound when capped.
+# TYPE strata_queue_failed_jobs_sample gauge
+strata_queue_failed_jobs_sample ${snapshot.count}
+# HELP strata_queue_failed_jobs_sample_capped Whether the failed-job sample is truncated.
+# TYPE strata_queue_failed_jobs_sample_capped gauge
+strata_queue_failed_jobs_sample_capped ${Number(snapshot.capped)}
+`;
+}
+
 // ../../src/core/queue/queueMetrics.ts
 async function readRedisQueueDepth(redisUrl) {
   const client = new RedisClient3(redisUrl);
@@ -1393,18 +2377,28 @@ local ready = capped == 1 and -1 or size-inflight
 if ready < 0 and capped == 0 then return redis.error_reply('Inconsistent stream pending state') end
 local retries = redis.call('ZCARD', KEYS[2])
 local due = redis.call('ZCOUNT', KEYS[2], '-inf', ms)
+local lateness = 0
+if due > 0 then
+  local oldest = redis.call('ZRANGE', KEYS[2], 0, 0, 'WITHSCORES')
+  local score = tonumber(oldest[2])
+  if not score or score < 0 or score ~= math.floor(score) or score > ms then
+    return redis.error_reply('Invalid retry due score')
+  end
+  -- Cancellation sets score zero to request immediate promotion/cleanup; it is not a timestamp.
+  lateness = score == 0 and -1 or (ms-score)/1000
+end
 local first = redis.call('XRANGE', KEYS[1], '-', '+', 'COUNT', 1)
 local age = 0
 if #first > 0 then
   local timestamp = tonumber(string.match(first[1][1], '^(%d+)-'))
   age = math.max(0, ms-timestamp)/1000
 end
-return {size+retries, ready, inflight, capped, due, retries-due, redis.call('LLEN', KEYS[3]), tostring(age)}
+return {size+retries, ready, inflight, capped, due, retries-due, redis.call('LLEN', KEYS[3]), tostring(age), tostring(lateness)}
 `;
 var LIST_SNAPSHOT = `
 local ready = redis.call('LLEN', KEYS[1])
 local inflight = redis.call('LLEN', KEYS[2])
-return {ready+inflight, ready, inflight, 0, 0, 0, redis.call('LLEN', KEYS[3]), '-1'}
+return {ready+inflight, ready, inflight, 0, 0, 0, redis.call('LLEN', KEYS[3]), '-1', '-1'}
 `;
 async function readRedisQueueSnapshot(redisUrl, options = {}) {
   if (!redisUrl.trim())
@@ -1427,13 +2421,23 @@ async function readRedisQueueSnapshot(redisUrl, options = {}) {
         STREAM_GROUP,
         String(INFLIGHT_SAMPLE_LIMIT)
       ]);
-      if (!Array.isArray(raw) || raw.length !== 8)
+      if (!Array.isArray(raw) || raw.length !== 9)
         throw new Error("Invalid queue metrics response.");
       const values = raw.map(Number);
       if (values.some((value) => !Number.isFinite(value)) || values.slice(0, 7).some((value, i) => !Number.isSafeInteger(value) || value < (i === 1 ? -1 : 0)))
         throw new Error("Invalid queue metrics values.");
-      const [unfinished, ready, inflight, capped, retryDue, retryWaiting, quarantined, age] = values;
-      if (unfinished === undefined || ready === undefined || inflight === undefined || capped === undefined || retryDue === undefined || retryWaiting === undefined || quarantined === undefined || age === undefined || capped !== 0 && capped !== 1 || age < (transport === "lists" ? -1 : 0))
+      const [
+        unfinished,
+        ready,
+        inflight,
+        capped,
+        retryDue,
+        retryWaiting,
+        quarantined,
+        age,
+        lateness
+      ] = values;
+      if (unfinished === undefined || ready === undefined || inflight === undefined || capped === undefined || retryDue === undefined || retryWaiting === undefined || quarantined === undefined || age === undefined || lateness === undefined || lateness < 0 && lateness !== -1 || capped !== 0 && capped !== 1 || age < (transport === "lists" ? -1 : 0))
         throw new Error("Invalid queue metrics values.");
       return {
         priority: index === 0 ? "high" : index === 1 ? "default" : "low",
@@ -1443,6 +2447,7 @@ async function readRedisQueueSnapshot(redisUrl, options = {}) {
         inflightCapped: capped === 1,
         retryDue,
         retryWaiting,
+        retryActionableLatenessSeconds: lateness === -1 ? null : lateness,
         quarantined,
         oldestStreamEntryAgeSeconds: transport === "streams" ? age : null
       };
@@ -1464,7 +2469,7 @@ function renderRedisQueueMetrics(snapshot) {
   if (snapshot.transport !== "streams" && snapshot.transport !== "lists" || snapshot.priorities.length !== 3 || new Set(snapshot.priorities.map((row) => row.priority)).size !== 3)
     throw new TypeError("Invalid queue metrics snapshot.");
   for (const row of snapshot.priorities) {
-    if (!["high", "default", "low"].includes(row.priority) || typeof row.inflightCapped !== "boolean" || [row.unfinished, row.inflight, row.retryDue, row.retryWaiting, row.quarantined].some((value) => !Number.isSafeInteger(value) || value < 0) || row.ready !== null && (!Number.isSafeInteger(row.ready) || row.ready < 0) || row.oldestStreamEntryAgeSeconds !== null && (!Number.isFinite(row.oldestStreamEntryAgeSeconds) || row.oldestStreamEntryAgeSeconds < 0))
+    if (!["high", "default", "low"].includes(row.priority) || typeof row.inflightCapped !== "boolean" || [row.unfinished, row.inflight, row.retryDue, row.retryWaiting, row.quarantined].some((value) => !Number.isSafeInteger(value) || value < 0) || row.ready !== null && (!Number.isSafeInteger(row.ready) || row.ready < 0) || row.retryActionableLatenessSeconds != null && (!Number.isFinite(row.retryActionableLatenessSeconds) || row.retryActionableLatenessSeconds < 0) || row.oldestStreamEntryAgeSeconds !== null && (!Number.isFinite(row.oldestStreamEntryAgeSeconds) || row.oldestStreamEntryAgeSeconds < 0))
       throw new TypeError("Invalid queue metrics snapshot.");
   }
   const lines = [
@@ -1478,7 +2483,9 @@ function renderRedisQueueMetrics(snapshot) {
     "# HELP strata_queue_inflight_sample_capped Whether the inflight sample was truncated; ready is omitted when truncated.",
     "# TYPE strata_queue_inflight_sample_capped gauge",
     "# HELP strata_queue_oldest_stream_entry_age_seconds Oldest current stream entry residence age; resets when a retry is promoted.",
-    "# TYPE strata_queue_oldest_stream_entry_age_seconds gauge"
+    "# TYPE strata_queue_oldest_stream_entry_age_seconds gauge",
+    "# HELP strata_queue_retry_actionable_lateness_seconds Oldest retry due-score lateness; unavailable for cancellation sentinels or lists.",
+    "# TYPE strata_queue_retry_actionable_lateness_seconds gauge"
   ];
   for (const priority of snapshot.priorities) {
     const label = `priority="${priority.priority}"`;
@@ -1494,6 +2501,8 @@ function renderRedisQueueMetrics(snapshot) {
       if (value !== null)
         lines.push(`strata_queue_jobs{${label},state="${state}"} ${value}`);
     lines.push(`strata_queue_inflight_sample_capped{${label}} ${Number(priority.inflightCapped)}`);
+    if (snapshot.transport === "streams" && priority.retryActionableLatenessSeconds != null)
+      lines.push(`strata_queue_retry_actionable_lateness_seconds{${label}} ${priority.retryActionableLatenessSeconds}`);
     if (priority.oldestStreamEntryAgeSeconds !== null)
       lines.push(`strata_queue_oldest_stream_entry_age_seconds{${label}} ${priority.oldestStreamEntryAgeSeconds}`);
   }
@@ -1504,7 +2513,9 @@ function renderRedisQueueMetrics(snapshot) {
 export {
   INFLIGHT_SAMPLE_LIMIT,
   collectQueueMetrics,
+  createFailedJobMetricsCollector,
   readRedisQueueDepth,
   readRedisQueueSnapshot,
+  renderFailedJobMetrics,
   renderRedisQueueMetrics
 };