@getstrata/core 2.2.6 → 2.2.8

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @getstrata/core changelog
 
+## 2.2.8
+
+- Add bounded read-only Postgres outbox metrics
+
+## 2.2.7
+
+- Where an ordinary operation needs SQL because the framework cannot express it
+
 ## 2.2.6
 
 -  fix(cli): relay shutdown to children and simplify container launcher

package/dist/core/database/types.d.ts

@@ -40,6 +40,8 @@ type ModelWriteValues<TEntity> = Partial<TEntity>;
 type QueryOrder<TEntity> = {
     column: keyof TEntity & string;
     direction?: "ASC" | "DESC" | "asc" | "desc";
+    /** Explicit placement; omitted retains the database's default. */
+    nulls?: "first" | "last";
 };
 type QueryOrderShorthand<TEntity> = Partial<Record<keyof TEntity & string, "ASC" | "DESC" | "asc" | "desc">>;
 type QueryJoinOn = {

package/dist/core/events/outbox/index.d.ts

@@ -50,6 +50,8 @@ declare class SqlOutbox {
     /** Operator operation: retains the event and atomically makes one failed delivery eligible. */
     replay(eventId: string, listenerName: string): Promise<void>;
 }
+export type { OutboxMetricState, OutboxMetricsCollector, OutboxMetricsOptions, OutboxMetricsSnapshot, } from "./metrics";
+export { createOutboxMetricsCollector, renderOutboxMetrics } from "./metrics";
 export { createOutboxMigration } from "./migration";
 export type { DurableEvent, DurableListener, SqlOutboxOptions };
 export { SqlOutbox };

package/dist/core/events/outbox/metrics.d.ts

@@ -0,0 +1,27 @@
+type OutboxMetricState = "pending_due" | "pending_waiting" | "processing_active" | "processing_expired" | "processing_unleased" | "failed";
+interface OutboxMetricsSnapshot {
+    sampleLimit: number;
+    states: readonly {
+        state: OutboxMetricState;
+        count: number;
+        capped: boolean;
+        actionableLatenessSeconds: number | null;
+    }[];
+}
+interface OutboxMetricsOptions {
+    timeoutMs?: number;
+    sampleLimit?: number;
+}
+interface OutboxMetricsCollector {
+    collect(): Promise<OutboxMetricsSnapshot>;
+    /** Stop new collection and wait for the underlying transaction to settle. */
+    close(): Promise<void>;
+}
+declare const snapshotQuery: string;
+/** Explicit platform observation, using the same transaction-local RLS bypass as coordination.
+ * Initially Postgres-only: other engines fail rather than receiving a false empty snapshot.
+ */
+declare function createOutboxMetricsCollector(options?: OutboxMetricsOptions): OutboxMetricsCollector;
+declare function renderOutboxMetrics(snapshot: OutboxMetricsSnapshot): string;
+export type { OutboxMetricState, OutboxMetricsCollector, OutboxMetricsOptions, OutboxMetricsSnapshot, };
+export { createOutboxMetricsCollector, renderOutboxMetrics, snapshotQuery };

package/dist/core/queue/queueMetrics.d.ts

@@ -13,3 +13,31 @@ declare function readRedisQueueDepth(redisUrl: string): Promise<QueueDepthMetric
 declare function collectQueueMetrics(): Promise<QueueMetricsSnapshot>;
 export type { QueueDepthMetrics, QueueMetricsSnapshot };
 export { collectQueueMetrics, readRedisQueueDepth };
+interface RedisQueueSnapshotOptions {
+    transport?: "lists" | "streams";
+    /** One deadline for all three priorities, including connection establishment. */
+    timeoutMs?: number;
+}
+interface QueuePrioritySnapshot {
+    priority: "high" | "default" | "low";
+    unfinished: number;
+    ready: number | null;
+    inflight: number;
+    inflightCapped: boolean;
+    retryDue: number;
+    retryWaiting: number;
+    quarantined: number;
+    /** Residence age of the oldest current stream entry, not original job age across retries. */
+    oldestStreamEntryAgeSeconds: number | null;
+}
+interface RedisQueueSnapshot {
+    transport: "lists" | "streams";
+    priorities: readonly QueuePrioritySnapshot[];
+}
+declare const INFLIGHT_SAMPLE_LIMIT = 500;
+/** Shared state, not per-process counters. Throws on missing configuration, failure or timeout. */
+declare function readRedisQueueSnapshot(redisUrl: string, options?: RedisQueueSnapshotOptions): Promise<RedisQueueSnapshot>;
+/** Fixed metric/label vocabulary; no job IDs, tenant IDs, payloads or credentials. */
+declare function renderRedisQueueMetrics(snapshot: RedisQueueSnapshot): string;
+export type { QueuePrioritySnapshot, RedisQueueSnapshot, RedisQueueSnapshotOptions };
+export { INFLIGHT_SAMPLE_LIMIT, readRedisQueueSnapshot, renderRedisQueueMetrics };

package/dist/entries/database/query.js

@@ -254,8 +254,18 @@ function normalizeOrderBy(orderBy) {
   }));
 }
 function buildOrderByClause(tableName, orderBy) {
-  const parts = normalizeOrderBy(orderBy).map(({ column, direction }) => {
-    return `${resolveQualifiedColumn(tableName, column)} ${normalizeDirection(direction)}`;
+  const parts = normalizeOrderBy(orderBy).map(({ column, direction, nulls }) => {
+    if (nulls !== undefined && nulls !== "first" && nulls !== "last") {
+      throw new TypeError("Invalid null ordering: expected first or last.");
+    }
+    const reference = resolveQualifiedColumn(tableName, column);
+    const ordered = `${reference} ${normalizeDirection(direction)}`;
+    if (nulls === undefined)
+      return ordered;
+    if (currentSqlDialect().driver === "mysql") {
+      return `(${reference} IS NULL) ${nulls === "first" ? "DESC" : "ASC"}, ${ordered}`;
+    }
+    return `${ordered} NULLS ${nulls.toUpperCase()}`;
   });
   return parts.length > 0 ? ` ORDER BY ${parts.join(", ")}` : "";
 }

package/dist/entries/database/repositoryQuery.js

@@ -278,8 +278,18 @@ function normalizeOrderBy(orderBy) {
   }));
 }
 function buildOrderByClause(tableName, orderBy) {
-  const parts = normalizeOrderBy(orderBy).map(({ column, direction }) => {
-    return `${resolveQualifiedColumn(tableName, column)} ${normalizeDirection(direction)}`;
+  const parts = normalizeOrderBy(orderBy).map(({ column, direction, nulls }) => {
+    if (nulls !== undefined && nulls !== "first" && nulls !== "last") {
+      throw new TypeError("Invalid null ordering: expected first or last.");
+    }
+    const reference = resolveQualifiedColumn(tableName, column);
+    const ordered = `${reference} ${normalizeDirection(direction)}`;
+    if (nulls === undefined)
+      return ordered;
+    if (currentSqlDialect().driver === "mysql") {
+      return `(${reference} IS NULL) ${nulls === "first" ? "DESC" : "ASC"}, ${ordered}`;
+    }
+    return `${ordered} NULLS ${nulls.toUpperCase()}`;
   });
   return parts.length > 0 ? ` ORDER BY ${parts.join(", ")}` : "";
 }

package/dist/entries/queue/queueMetrics.js

@@ -1377,7 +1377,134 @@ async function collectQueueMetrics() {
     failedCount
   };
 }
+var INFLIGHT_SAMPLE_LIMIT = 500;
+var STREAM_SNAPSHOT = `
+local now = redis.call('TIME')
+local ms = tonumber(now[1])*1000 + math.floor(tonumber(now[2])/1000)
+local size = redis.call('XLEN', KEYS[1])
+local pending = redis.pcall('XPENDING', KEYS[1], ARGV[1], '-', '+', tonumber(ARGV[2])+1)
+if pending.err then
+  if not string.find(pending.err, 'NOGROUP', 1, true) then return redis.error_reply(pending.err) end
+  pending = {}
+end
+local capped = #pending > tonumber(ARGV[2]) and 1 or 0
+local inflight = math.min(#pending, tonumber(ARGV[2]))
+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 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)}
+`;
+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'}
+`;
+async function readRedisQueueSnapshot(redisUrl, options = {}) {
+  if (!redisUrl.trim())
+    throw new TypeError("Queue metrics require a Redis URL.");
+  const transport = options.transport ?? resolveRedisQueueTransport();
+  if (transport !== "lists" && transport !== "streams")
+    throw new TypeError("Invalid queue metrics transport.");
+  const timeoutMs = options.timeoutMs ?? 1000;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 5000)
+    throw new TypeError("Queue metrics timeout must be between 1 and 5000 milliseconds.");
+  const client = new RedisClient3(redisUrl, { autoReconnect: false });
+  let timer;
+  try {
+    const work = Promise.all(defaultQueueKeys().map(async (key, index) => {
+      const keys = transport === "streams" ? [streamQueueKey(key), streamRetryKey(key), streamDeadLetterKey(key)] : [key, queueProcessingKey(key), queueInvalidKey(key)];
+      const raw = await client.send("EVAL", [
+        transport === "streams" ? STREAM_SNAPSHOT : LIST_SNAPSHOT,
+        "3",
+        ...keys,
+        STREAM_GROUP,
+        String(INFLIGHT_SAMPLE_LIMIT)
+      ]);
+      if (!Array.isArray(raw) || raw.length !== 8)
+        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))
+        throw new Error("Invalid queue metrics values.");
+      return {
+        priority: index === 0 ? "high" : index === 1 ? "default" : "low",
+        unfinished,
+        ready: ready === -1 ? null : ready,
+        inflight,
+        inflightCapped: capped === 1,
+        retryDue,
+        retryWaiting,
+        quarantined,
+        oldestStreamEntryAgeSeconds: transport === "streams" ? age : null
+      };
+    }));
+    const priorities = await Promise.race([
+      work,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("Queue metrics collection timed out.")), timeoutMs);
+      })
+    ]);
+    return { transport, priorities };
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    client.close();
+  }
+}
+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))
+      throw new TypeError("Invalid queue metrics snapshot.");
+  }
+  const lines = [
+    "# HELP strata_queue_collector_success Whether the configured queue collection succeeded.",
+    "# TYPE strata_queue_collector_success gauge",
+    "strata_queue_collector_success 1",
+    "# HELP strata_queue_unfinished_jobs Stream/list entries plus scheduled retries, excluding quarantine and persisted failures.",
+    "# TYPE strata_queue_unfinished_jobs gauge",
+    "# HELP strata_queue_jobs Queue state; inflight_sample is a lower bound when capped.",
+    "# TYPE strata_queue_jobs gauge",
+    "# 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"
+  ];
+  for (const priority of snapshot.priorities) {
+    const label = `priority="${priority.priority}"`;
+    lines.push(`strata_queue_unfinished_jobs{${label}} ${priority.unfinished}`);
+    const states = {
+      ready: priority.ready,
+      inflight_sample: priority.inflight,
+      retry_due: snapshot.transport === "streams" ? priority.retryDue : null,
+      retry_waiting: snapshot.transport === "streams" ? priority.retryWaiting : null,
+      quarantined: priority.quarantined
+    };
+    for (const [state, value] of Object.entries(states))
+      if (value !== null)
+        lines.push(`strata_queue_jobs{${label},state="${state}"} ${value}`);
+    lines.push(`strata_queue_inflight_sample_capped{${label}} ${Number(priority.inflightCapped)}`);
+    if (priority.oldestStreamEntryAgeSeconds !== null)
+      lines.push(`strata_queue_oldest_stream_entry_age_seconds{${label}} ${priority.oldestStreamEntryAgeSeconds}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
 export {
+  INFLIGHT_SAMPLE_LIMIT,
   collectQueueMetrics,
-  readRedisQueueDepth
+  readRedisQueueDepth,
+  readRedisQueueSnapshot,
+  renderRedisQueueMetrics
 };

package/dist/framework/public-api.d.ts

@@ -72,8 +72,8 @@ export { BadRequestError, ConflictError, ForbiddenError, HttpError, InternalServ
 export type { EventListener } from "../core/events/eventBus.ts";
 export { EventBus, eventBus, readSharedEventBus } from "../core/events/eventBus.ts";
 export { dispatchModelEvent, modelEventName, runWithDeferredModelEvents, } from "../core/events/index.ts";
-export type { DurableEvent, DurableListener, SqlOutboxOptions, } from "../core/events/outbox/index.ts";
-export { createOutboxMigration, SqlOutbox } from "../core/events/outbox/index.ts";
+export type { DurableEvent, DurableListener, OutboxMetricState, OutboxMetricsCollector, OutboxMetricsOptions, OutboxMetricsSnapshot, SqlOutboxOptions, } from "../core/events/outbox/index.ts";
+export { createOutboxMetricsCollector, createOutboxMigration, renderOutboxMetrics, SqlOutbox, } from "../core/events/outbox/index.ts";
 export { auth, cache, config, events, log, mail, policyGate, queue, storage, } from "../core/facades/index.ts";
 export { createBodySizeLimitMiddleware } from "../core/http/bodySizeLimitMiddleware.ts";
 export { readClientIp, trustForwardedFor } from "../core/http/clientIp.ts";

package/dist/index.js

@@ -4438,8 +4438,18 @@ function normalizeOrderBy(orderBy) {
   }));
 }
 function buildOrderByClause(tableName, orderBy) {
-  const parts = normalizeOrderBy(orderBy).map(({ column, direction }) => {
-    return `${resolveQualifiedColumn(tableName, column)} ${normalizeDirection(direction)}`;
+  const parts = normalizeOrderBy(orderBy).map(({ column, direction, nulls }) => {
+    if (nulls !== undefined && nulls !== "first" && nulls !== "last") {
+      throw new TypeError("Invalid null ordering: expected first or last.");
+    }
+    const reference = resolveQualifiedColumn(tableName, column);
+    const ordered = `${reference} ${normalizeDirection(direction)}`;
+    if (nulls === undefined)
+      return ordered;
+    if (currentSqlDialect().driver === "mysql") {
+      return `(${reference} IS NULL) ${nulls === "first" ? "DESC" : "ASC"}, ${ordered}`;
+    }
+    return `${ordered} NULLS ${nulls.toUpperCase()}`;
   });
   return parts.length > 0 ? ` ORDER BY ${parts.join(", ")}` : "";
 }
@@ -9154,6 +9164,162 @@ init_databaseTenantContext();
 init_tenantContext();
 init_tenantDatabaseScope();
 
+// ../../src/core/events/outbox/metrics.ts
+init_dialect();
+init_repositoryConnection();
+init_transaction();
+init_databaseTenantContext();
+var specifications = [
+  { state: "pending_due", status: "pending", column: "available_at", predicate: "<=", age: true },
+  {
+    state: "pending_waiting",
+    status: "pending",
+    column: "available_at",
+    predicate: ">",
+    age: false
+  },
+  {
+    state: "processing_active",
+    status: "processing",
+    column: "lease_until",
+    predicate: ">",
+    age: false
+  },
+  {
+    state: "processing_expired",
+    status: "processing",
+    column: "lease_until",
+    predicate: "<=",
+    age: true
+  },
+  {
+    state: "processing_unleased",
+    status: "processing",
+    column: "lease_until",
+    predicate: "IS NULL",
+    age: false
+  },
+  { state: "failed", status: "failed", column: "available_at", predicate: "", age: false }
+];
+var snapshotQuery = `WITH snapshot_clock AS MATERIALIZED (
+  SELECT CAST(EXTRACT(EPOCH FROM clock_timestamp()) * 1000 AS BIGINT) AS now_ms
+), ${specifications.map((spec, index) => `sample_${index} AS (
+  SELECT ${spec.column} AS timestamp_ms FROM strata_outbox_delivery
+  WHERE status = '${spec.status}'${spec.predicate ? ` AND ${spec.column} ${spec.predicate}${spec.predicate === "IS NULL" ? "" : " (SELECT now_ms FROM snapshot_clock)"}` : ""}
+  ORDER BY ${spec.column}, event_id, listener_name LIMIT $1
+)`).join(`,
+`)}
+${specifications.map((spec, index) => `SELECT '${spec.state}' AS state, COUNT(*) AS count,
+  ${spec.age ? `COALESCE(GREATEST(0, (SELECT now_ms FROM snapshot_clock) - MIN(timestamp_ms)), 0)` : "NULL::BIGINT"} AS lateness_ms
+  FROM sample_${index}`).join(`
+UNION ALL
+`)}`;
+function createOutboxMetricsCollector(options = {}) {
+  const timeoutMs = options.timeoutMs ?? 1000;
+  const sampleLimit = options.sampleLimit ?? 500;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 5000)
+    throw new TypeError("Outbox metrics timeout must be between 1 and 5000 milliseconds.");
+  if (!Number.isSafeInteger(sampleLimit) || sampleLimit < 1 || sampleLimit > 1000)
+    throw new TypeError("Outbox metrics sample limit must be between 1 and 1000.");
+  let active;
+  let closed = false;
+  return {
+    async collect() {
+      if (closed)
+        throw new Error("Outbox metrics collector is closed.");
+      if (hasActiveTransaction())
+        throw new Error("Outbox metrics require an independent transaction.");
+      if (currentSqlDialect().driver !== "pgsql")
+        throw new Error("Outbox metrics currently require Postgres.");
+      if (active)
+        throw new Error("Outbox metrics collection is still settling.");
+      const deadline = performance.now() + timeoutMs;
+      let expired = false;
+      let timer;
+      const remaining = () => {
+        const value = Math.floor(deadline - performance.now());
+        if (expired || value < 1)
+          throw new Error("Outbox metrics 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");
+        return runWithMigrationBypass(async () => {
+          remaining();
+          const rows = await repositoryConnection.unsafe(snapshotQuery, [sampleLimit + 1]);
+          remaining();
+          if (rows.length !== specifications.length)
+            throw new Error("Invalid outbox metrics response.");
+          const states = specifications.map((spec) => {
+            const row = rows.find((value) => value.state === spec.state);
+            const count = Number(row?.count);
+            const lateness = row?.lateness_ms == null ? null : Number(row.lateness_ms);
+            if (!Number.isSafeInteger(count) || count < 0 || count > sampleLimit + 1 || spec.age && (lateness === null || !Number.isFinite(lateness) || lateness < 0))
+              throw new Error("Invalid outbox metrics values.");
+            return {
+              state: spec.state,
+              count: Math.min(count, sampleLimit),
+              capped: count > sampleLimit,
+              actionableLatenessSeconds: lateness === null ? null : lateness / 1000
+            };
+          });
+          return { sampleLimit, states };
+        });
+      });
+      active = work;
+      work.finally(() => {
+        if (active === work)
+          active = undefined;
+      }).catch(() => {});
+      try {
+        return await Promise.race([
+          work,
+          new Promise((_, reject) => {
+            timer = setTimeout(() => {
+              expired = true;
+              reject(new Error("Outbox metrics collection timed out."));
+            }, timeoutMs);
+          })
+        ]);
+      } finally {
+        if (timer !== undefined)
+          clearTimeout(timer);
+      }
+    },
+    async close() {
+      closed = true;
+      await active?.catch(() => {});
+    }
+  };
+}
+function renderOutboxMetrics(snapshot) {
+  if (!Number.isSafeInteger(snapshot.sampleLimit) || snapshot.sampleLimit < 1 || snapshot.sampleLimit > 1000 || snapshot.states.length !== specifications.length)
+    throw new TypeError("Invalid outbox metrics snapshot.");
+  const lines = [
+    "# HELP strata_outbox_collector_success Whether outbox collection succeeded.",
+    "# TYPE strata_outbox_collector_success gauge",
+    "strata_outbox_collector_success 1",
+    "# HELP strata_outbox_deliveries_sample Bounded per-state delivery count; lower bound when capped.",
+    "# TYPE strata_outbox_deliveries_sample gauge",
+    "# HELP strata_outbox_sample_capped Whether the delivery sample is truncated.",
+    "# TYPE strata_outbox_sample_capped gauge",
+    "# HELP strata_outbox_actionable_lateness_seconds Oldest due-time or expired-lease lateness, not original event age.",
+    "# TYPE strata_outbox_actionable_lateness_seconds gauge"
+  ];
+  for (const spec of specifications) {
+    const row = snapshot.states.find((value) => value.state === spec.state);
+    if (!row || !Number.isSafeInteger(row.count) || row.count < 0 || row.count > snapshot.sampleLimit || typeof row.capped !== "boolean" || row.actionableLatenessSeconds !== null && (!Number.isFinite(row.actionableLatenessSeconds) || row.actionableLatenessSeconds < 0))
+      throw new TypeError("Invalid outbox metrics snapshot.");
+    lines.push(`strata_outbox_deliveries_sample{state="${spec.state}"} ${row.count}`);
+    lines.push(`strata_outbox_sample_capped{state="${spec.state}"} ${Number(row.capped)}`);
+    if (row.actionableLatenessSeconds !== null)
+      lines.push(`strata_outbox_actionable_lateness_seconds{state="${spec.state}"} ${row.actionableLatenessSeconds}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
 // ../../src/core/events/outbox/migration.ts
 function createOutboxMigration(name, driver, options = {}) {
   const identity = driver === "mysql" ? " CHARACTER SET ascii COLLATE ascii_bin" : "";
@@ -15234,6 +15400,7 @@ export {
   createMysqlPool,
   createNotificationDispatcher,
   createOidcHandshake,
+  createOutboxMetricsCollector,
   createOutboxMigration,
   createProductionQueue,
   createQueue,
@@ -15407,6 +15574,7 @@ export {
   registerShutdownHandler,
   renderKernelErrorChrome,
   renderMarkdownMail,
+  renderOutboxMetrics,
   renderWebErrorHtml,
   repositoryConnection,
   requestIdMiddleware,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "2.2.6",
+  "version": "2.2.8",
   "description": "Strata Bun framework public API",
   "type": "module",
   "license": "MIT",