@pattern-stack/codegen 0.15.1 → 0.15.3

package/dist/chunk-K2I6XIK5.js

@@ -0,0 +1,122 @@
+import {
+  assertTenantId
+} from "./chunk-6DWFJNIK.js";
+import {
+  bridgeDelivery
+} from "./chunk-2TVVBC53.js";
+import {
+  BRIDGE_MULTI_TENANT
+} from "./chunk-4LH67P4U.js";
+import {
+  DRIZZLE
+} from "./chunk-U64T4YZE.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/bridge/bridge-delivery.drizzle-backend.ts
+import { Inject, Injectable, Optional } from "@nestjs/common";
+import { eq, and, gte, isNull, sql } from "drizzle-orm";
+var DrizzleBridgeDeliveryRepo = class {
+  constructor(db, multiTenant = false) {
+    this.db = db;
+    this.multiTenant = multiTenant;
+  }
+  db;
+  multiTenant;
+  async insertDelivery(row, tx) {
+    assertTenantId(
+      "DrizzleBridgeDeliveryRepo.insertDelivery",
+      this.multiTenant,
+      row.tenantId
+    );
+    const client = tx ?? this.db;
+    await client.insert(bridgeDelivery).values(row).onConflictDoNothing({
+      target: [bridgeDelivery.eventId, bridgeDelivery.triggerId]
+    });
+  }
+  async findDelivery(eventId, triggerId) {
+    const rows = await this.db.select().from(bridgeDelivery).where(
+      and(
+        eq(bridgeDelivery.eventId, eventId),
+        eq(bridgeDelivery.triggerId, triggerId)
+      )
+    ).limit(1);
+    return rows[0] ?? null;
+  }
+  async findDeliveryById(id) {
+    const rows = await this.db.select().from(bridgeDelivery).where(eq(bridgeDelivery.id, id)).limit(1);
+    return rows[0] ?? null;
+  }
+  async markDelivered(id, userRunId, tx) {
+    const client = tx ?? this.db;
+    await client.update(bridgeDelivery).set({
+      status: "delivered",
+      userRunId,
+      deliveredAt: /* @__PURE__ */ new Date()
+    }).where(eq(bridgeDelivery.id, id));
+  }
+  async markSkipped(id, reason, tx) {
+    const client = tx ?? this.db;
+    await client.update(bridgeDelivery).set({ status: "skipped", skipReason: reason }).where(eq(bridgeDelivery.id, id));
+  }
+  async markFailed(id, error, tx) {
+    const client = tx ?? this.db;
+    await client.update(bridgeDelivery).set({ status: "failed", error }).where(eq(bridgeDelivery.id, id));
+  }
+  /**
+   * Observability read — see `IJobBridge.getStatusHistogram` JSDoc for the
+   * tenant-filter and windowHours contract.
+   *
+   * Tenant-filter note: this method intentionally does NOT call
+   * `assertTenantId`. The write methods on this repo (`insertDelivery`)
+   * treat `tenantId === undefined` as a misconfiguration and fail fast.
+   * Reads are different — `undefined` is the supported "cross-tenant
+   * admin view" mode that OBS-5 uses to render a framework-wide health
+   * panel. Callers that need strict tenant scoping pass an explicit
+   * string or `null`.
+   *
+   * Cast note: `count(*)::int` is applied in SQL so the node-pg driver
+   * returns a `number` instead of the default `bigint → string` for
+   * `count(*)`. Don't relax this cast — consumers (and the protocol)
+   * type the result as `number`.
+   */
+  async getStatusHistogram(windowHours, tenantId) {
+    if (!Number.isFinite(windowHours) || windowHours <= 0) {
+      throw new RangeError("windowHours must be positive");
+    }
+    const cutoff = sql`now() - make_interval(hours => ${windowHours})`;
+    const conditions = [gte(bridgeDelivery.attemptedAt, cutoff)];
+    if (tenantId === null) {
+      conditions.push(isNull(bridgeDelivery.tenantId));
+    } else if (typeof tenantId === "string") {
+      conditions.push(eq(bridgeDelivery.tenantId, tenantId));
+    }
+    const rows = await this.db.select({
+      status: bridgeDelivery.status,
+      count: sql`count(*)::int`
+    }).from(bridgeDelivery).where(and(...conditions)).groupBy(bridgeDelivery.status);
+    const histogram = {
+      pending: 0,
+      delivered: 0,
+      skipped: 0,
+      failed: 0
+    };
+    for (const row of rows) {
+      histogram[row.status] = Number(row.count);
+    }
+    return histogram;
+  }
+};
+DrizzleBridgeDeliveryRepo = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(DRIZZLE)),
+  __decorateParam(1, Optional()),
+  __decorateParam(1, Inject(BRIDGE_MULTI_TENANT))
+], DrizzleBridgeDeliveryRepo);
+
+export {
+  DrizzleBridgeDeliveryRepo
+};
+//# sourceMappingURL=chunk-K2I6XIK5.js.map

package/dist/chunk-K2I6XIK5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/bridge/bridge-delivery.drizzle-backend.ts"],"sourcesContent":["/**\n * DrizzleBridgeDeliveryRepo — Postgres implementation of `IJobBridge`\n * (BRIDGE-4, ADR-023 Phase 2).\n *\n * Behavioral twin of `MemoryBridgeDeliveryRepo` (BRIDGE-3). The key\n * difference is `insertDelivery`: where the memory backend throws\n * `UniqueConstraintError` on a duplicate `(event_id, trigger_id)`, the\n * Drizzle backend uses `INSERT … ON CONFLICT (event_id, trigger_id) DO\n * NOTHING` and surfaces the dedup as a silent no-op. This matches the\n * BRIDGE-4 spec recommendation — a thrown error inside the per-event tx\n * would abort sibling triggers, which is exactly the failure mode the\n * facade's Case B pre-write was designed to prevent.\n *\n * Tests that need to assert \"the constraint fired\" use `findDelivery` to\n * confirm the existing row is the facade-eager pre-write (or the prior\n * drain attempt's row), not the one this call tried to insert. The\n * `UniqueConstraintError` branch from BRIDGE-3 is the memory-backend\n * fidelity path; the Drizzle backend models the same idempotency through\n * SQL semantics rather than a thrown error.\n *\n * The other four methods (`findDelivery`, `findDeliveryById`,\n * `mark{Delivered,Skipped,Failed}`) are straightforward\n * `SELECT … LIMIT 1` / `UPDATE … WHERE id = ?` queries.\n */\nimport { Inject, Injectable, Optional } from '@nestjs/common';\nimport { eq, and, gte, isNull, sql } from 'drizzle-orm';\n\nimport { DRIZZLE } from '../../constants/tokens';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport type { DrizzleTransaction } from '../events/event-bus.protocol';\n\nimport { bridgeDelivery } from './bridge-delivery.schema';\nimport type { BridgeDeliveryRecord } from './bridge-delivery.schema';\nimport type {\n  BridgeDeliveryInsert,\n  IJobBridge,\n  StatusHistogram,\n} from './bridge.protocol';\nimport { assertTenantId } from './assert-tenant-id';\nimport { BRIDGE_MULTI_TENANT } from './bridge.tokens';\n\n@Injectable()\nexport class DrizzleBridgeDeliveryRepo implements IJobBridge {\n  constructor(\n    @Inject(DRIZZLE) private readonly db: DrizzleClient,\n    /**\n     * Site (c) of the three ADR-023 §Multi-tenancy enforcement sites.\n     * `@Optional()` so unit tests / non-bridge mounts that don't provide\n     * the token still construct the repo cleanly; defaults to `false`,\n     * which makes `assertTenantId` a no-op.\n     */\n    @Optional()\n    @Inject(BRIDGE_MULTI_TENANT)\n    private readonly multiTenant: boolean = false,\n  ) {}\n\n  async insertDelivery(\n    row: BridgeDeliveryInsert,\n    tx?: DrizzleTransaction,\n  ): Promise<void> {\n    // Multi-tenancy gate — last-line defense. Even if callers skipped\n    // sites (a) `EventFlowService.publishAndStart` and (b)\n    // `BridgeDeliveryHandler.run`, a direct repo call still fails fast\n    // BEFORE any SQL is issued.\n    assertTenantId(\n      'DrizzleBridgeDeliveryRepo.insertDelivery',\n      this.multiTenant,\n      row.tenantId,\n    );\n    const client = (tx ?? this.db) as DrizzleClient;\n    // ON CONFLICT DO NOTHING — surfaces dedup as silent no-op so the\n    // per-event tx stays atomic across sibling triggers. RETURNING is\n    // omitted here: the public IJobBridge contract is `Promise<void>`,\n    // and the drain hook (BRIDGE-4) uses its own\n    // `tx.insert(...).onConflictDoNothing().returning({id})` pattern\n    // when it needs the rowcount discriminator. See class-level JSDoc.\n    await client\n      .insert(bridgeDelivery)\n      .values(row)\n      .onConflictDoNothing({\n        target: [bridgeDelivery.eventId, bridgeDelivery.triggerId],\n      });\n  }\n\n  async findDelivery(\n    eventId: string,\n    triggerId: string,\n  ): Promise<BridgeDeliveryRecord | null> {\n    const rows = await this.db\n      .select()\n      .from(bridgeDelivery)\n      .where(\n        and(\n          eq(bridgeDelivery.eventId, eventId),\n          eq(bridgeDelivery.triggerId, triggerId),\n        ),\n      )\n      .limit(1);\n    return (rows[0] as BridgeDeliveryRecord | undefined) ?? null;\n  }\n\n  async findDeliveryById(id: string): Promise<BridgeDeliveryRecord | null> {\n    const rows = await this.db\n      .select()\n      .from(bridgeDelivery)\n      .where(eq(bridgeDelivery.id, id))\n      .limit(1);\n    return (rows[0] as BridgeDeliveryRecord | undefined) ?? null;\n  }\n\n  async markDelivered(\n    id: string,\n    userRunId: string,\n    tx?: DrizzleTransaction,\n  ): Promise<void> {\n    const client = (tx ?? this.db) as DrizzleClient;\n    await client\n      .update(bridgeDelivery)\n      .set({\n        status: 'delivered',\n        userRunId,\n        deliveredAt: new Date(),\n      })\n      .where(eq(bridgeDelivery.id, id));\n  }\n\n  async markSkipped(\n    id: string,\n    reason: string,\n    tx?: DrizzleTransaction,\n  ): Promise<void> {\n    const client = (tx ?? this.db) as DrizzleClient;\n    await client\n      .update(bridgeDelivery)\n      .set({ status: 'skipped', skipReason: reason })\n      .where(eq(bridgeDelivery.id, id));\n  }\n\n  async markFailed(\n    id: string,\n    error: Record<string, unknown>,\n    tx?: DrizzleTransaction,\n  ): Promise<void> {\n    const client = (tx ?? this.db) as DrizzleClient;\n    await client\n      .update(bridgeDelivery)\n      .set({ status: 'failed', error })\n      .where(eq(bridgeDelivery.id, id));\n  }\n\n  /**\n   * Observability read — see `IJobBridge.getStatusHistogram` JSDoc for the\n   * tenant-filter and windowHours contract.\n   *\n   * Tenant-filter note: this method intentionally does NOT call\n   * `assertTenantId`. The write methods on this repo (`insertDelivery`)\n   * treat `tenantId === undefined` as a misconfiguration and fail fast.\n   * Reads are different — `undefined` is the supported \"cross-tenant\n   * admin view\" mode that OBS-5 uses to render a framework-wide health\n   * panel. Callers that need strict tenant scoping pass an explicit\n   * string or `null`.\n   *\n   * Cast note: `count(*)::int` is applied in SQL so the node-pg driver\n   * returns a `number` instead of the default `bigint → string` for\n   * `count(*)`. Don't relax this cast — consumers (and the protocol)\n   * type the result as `number`.\n   */\n  async getStatusHistogram(\n    windowHours: number,\n    tenantId?: string | null,\n  ): Promise<StatusHistogram> {\n    if (!Number.isFinite(windowHours) || windowHours <= 0) {\n      throw new RangeError('windowHours must be positive');\n    }\n\n    const cutoff = sql<Date>`now() - make_interval(hours => ${windowHours})`;\n\n    const conditions = [gte(bridgeDelivery.attemptedAt, cutoff)];\n    if (tenantId === null) {\n      conditions.push(isNull(bridgeDelivery.tenantId));\n    } else if (typeof tenantId === 'string') {\n      conditions.push(eq(bridgeDelivery.tenantId, tenantId));\n    }\n    // tenantId === undefined → no tenant filter (cross-tenant view).\n\n    const rows = await this.db\n      .select({\n        status: bridgeDelivery.status,\n        count: sql<number>`count(*)::int`,\n      })\n      .from(bridgeDelivery)\n      .where(and(...conditions))\n      .groupBy(bridgeDelivery.status);\n\n    const histogram: StatusHistogram = {\n      pending: 0,\n      delivered: 0,\n      skipped: 0,\n      failed: 0,\n    };\n    for (const row of rows) {\n      // row.status is typed as the enum union; narrow is safe because the\n      // enum values match StatusHistogram keys 1:1 (BRIDGE-1 schema).\n      histogram[row.status as keyof StatusHistogram] = Number(row.count);\n    }\n    return histogram;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-KVOWSC5S.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-KVOWSC5S.js.map

package/dist/chunk-KVOWSC5S.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-KYR3B3OW.js

@@ -0,0 +1,79 @@
+// runtime/base-classes/lifecycle-events.ts
+import { randomUUID } from "crypto";
+var SYSTEM_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "createdAt",
+  "updatedAt",
+  "deletedAt"
+]);
+function entitySnapshot(entity) {
+  const snap = {};
+  for (const [key, value] of Object.entries(entity)) {
+    if (!SYSTEM_FIELDS.has(key)) {
+      snap[key] = value;
+    }
+  }
+  return snap;
+}
+function diffSnapshots(before, after) {
+  const changes = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+  for (const key of allKeys) {
+    if (SYSTEM_FIELDS.has(key)) continue;
+    const oldVal = before[key];
+    const newVal = after[key];
+    if (oldVal !== newVal && JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+      changes.push({ field: key, oldValue: oldVal, newValue: newVal });
+    }
+  }
+  return changes;
+}
+function buildLifecycleEvent(entityName, action, entityId, snapshot) {
+  return {
+    id: randomUUID(),
+    type: `${entityName}.${action}`,
+    aggregateId: entityId,
+    aggregateType: entityName,
+    payload: snapshot ? { snapshot } : {},
+    occurredAt: /* @__PURE__ */ new Date(),
+    metadata: { category: "lifecycle" }
+  };
+}
+function buildChangeEvents(entityName, entityId, changes) {
+  return changes.map((c) => ({
+    id: randomUUID(),
+    type: `${entityName}.field_changed`,
+    aggregateId: entityId,
+    aggregateType: entityName,
+    payload: {
+      fieldName: c.field,
+      oldValue: c.oldValue,
+      newValue: c.newValue
+    },
+    occurredAt: /* @__PURE__ */ new Date(),
+    metadata: { category: "change" }
+  }));
+}
+async function emitSafely(eventBus, events) {
+  if (!eventBus || events.length === 0) return;
+  try {
+    if (events.length === 1) {
+      const only = events[0];
+      if (!only) return;
+      await eventBus.publish(only);
+    } else {
+      await eventBus.publishMany(events);
+    }
+  } catch {
+    console.warn(`[lifecycle-events] failed to emit ${events.length} event(s)`);
+  }
+}
+
+export {
+  entitySnapshot,
+  diffSnapshots,
+  buildLifecycleEvent,
+  buildChangeEvents,
+  emitSafely
+};
+//# sourceMappingURL=chunk-KYR3B3OW.js.map

package/dist/chunk-KYR3B3OW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/lifecycle-events.ts"],"sourcesContent":["/**\n * Lifecycle event emission for BaseService.\n *\n * Ported from pattern-stack/atoms/patterns/services/base.py — the Python\n * BaseService emits LIFECYCLE and CHANGE events on every CRUD operation.\n * This module provides the same capability for the TypeScript codegen stack.\n *\n * Design:\n *   - Fire-and-forget: event emission never fails the CRUD operation.\n *   - IEventBus is optional: if no EVENT_BUS is injected, emission is silently\n *     skipped. This means base classes work in projects that haven't installed\n *     the events subsystem.\n *   - LIFECYCLE events carry an entity snapshot in payload.\n *   - CHANGE events carry per-field old/new diffs.\n *   - Controlled per-entity via `emitLifecycleEvents` flag (default: true).\n *\n * @deprecated EVT-7 — Lifecycle events are untyped and emit outside of the\n *   CRUD transaction. New work should declare an `emits:` block on the entity\n *   and publish typed domain events from use-cases via TYPED_EVENT_BUS inside\n *   the same Drizzle transaction. See `docs/specs/EVT-7.md`. This helper is\n *   retained for BaseService backward compatibility until all entities have\n *   migrated to typed emits.\n */\n\nimport { randomUUID } from 'crypto';\nimport type { IEventBus, DomainEvent } from '../subsystems/events/event-bus.protocol';\n\n// ============================================================================\n// Event categories (subset of pattern-stack's EventCategory)\n// ============================================================================\n\nexport type EventCategory = 'lifecycle' | 'change';\n\n// ============================================================================\n// Helpers\n// ============================================================================\n\n/** System fields excluded from entity snapshots and change diffs. */\nconst SYSTEM_FIELDS = new Set([\n\t'id',\n\t'createdAt',\n\t'updatedAt',\n\t'deletedAt',\n]);\n\n/**\n * Snapshot an entity's field values, excluding system fields.\n * Mirrors pattern-stack's `_get_entity_snapshot()`.\n */\nexport function entitySnapshot(entity: Record<string, unknown>): Record<string, unknown> {\n\tconst snap: Record<string, unknown> = {};\n\tfor (const [key, value] of Object.entries(entity)) {\n\t\tif (!SYSTEM_FIELDS.has(key)) {\n\t\t\tsnap[key] = value;\n\t\t}\n\t}\n\treturn snap;\n}\n\n/**\n * Diff two entity snapshots, returning per-field old/new pairs.\n * Only includes fields that actually changed.\n */\nexport function diffSnapshots(\n\tbefore: Record<string, unknown>,\n\tafter: Record<string, unknown>,\n): Array<{ field: string; oldValue: unknown; newValue: unknown }> {\n\tconst changes: Array<{ field: string; oldValue: unknown; newValue: unknown }> = [];\n\tconst allKeys = new Set([...Object.keys(before), ...Object.keys(after)]);\n\n\tfor (const key of allKeys) {\n\t\tif (SYSTEM_FIELDS.has(key)) continue;\n\t\tconst oldVal = before[key];\n\t\tconst newVal = after[key];\n\t\t// Simple equality — good enough for primitives and nulls.\n\t\t// For deep objects, JSON.stringify comparison.\n\t\tif (oldVal !== newVal && JSON.stringify(oldVal) !== JSON.stringify(newVal)) {\n\t\t\tchanges.push({ field: key, oldValue: oldVal, newValue: newVal });\n\t\t}\n\t}\n\n\treturn changes;\n}\n\n// ============================================================================\n// Event builders\n// ============================================================================\n\nexport function buildLifecycleEvent(\n\tentityName: string,\n\taction: 'created' | 'updated' | 'deleted',\n\tentityId: string,\n\tsnapshot?: Record<string, unknown>,\n): DomainEvent {\n\treturn {\n\t\tid: randomUUID(),\n\t\ttype: `${entityName}.${action}`,\n\t\taggregateId: entityId,\n\t\taggregateType: entityName,\n\t\tpayload: snapshot ? { snapshot } : {},\n\t\toccurredAt: new Date(),\n\t\tmetadata: { category: 'lifecycle' as EventCategory },\n\t};\n}\n\nexport function buildChangeEvents(\n\tentityName: string,\n\tentityId: string,\n\tchanges: Array<{ field: string; oldValue: unknown; newValue: unknown }>,\n): DomainEvent[] {\n\treturn changes.map((c) => ({\n\t\tid: randomUUID(),\n\t\ttype: `${entityName}.field_changed`,\n\t\taggregateId: entityId,\n\t\taggregateType: entityName,\n\t\tpayload: {\n\t\t\tfieldName: c.field,\n\t\t\toldValue: c.oldValue,\n\t\t\tnewValue: c.newValue,\n\t\t},\n\t\toccurredAt: new Date(),\n\t\tmetadata: { category: 'change' as EventCategory },\n\t}));\n}\n\n// ============================================================================\n// Emission helper (fire-and-forget)\n// ============================================================================\n\n/**\n * Emit events to the bus, swallowing errors.\n * Mirrors pattern-stack's `_emit_lifecycle_event()` try/except.\n */\nexport async function emitSafely(\n\teventBus: IEventBus | undefined,\n\tevents: DomainEvent[],\n): Promise<void> {\n\tif (!eventBus || events.length === 0) return;\n\ttry {\n\t\tif (events.length === 1) {\n\t\t\tconst only = events[0];\n\t\t\tif (!only) return;\n\t\t\tawait eventBus.publish(only);\n\t\t} else {\n\t\t\tawait eventBus.publishMany(events);\n\t\t}\n\t} catch {\n\t\t// Log but never fail the CRUD operation.\n\t\t// In production, this would use a structured logger.\n\t\tconsole.warn(`[lifecycle-events] failed to emit ${events.length} event(s)`);\n\t}\n}\n"],"mappings":";AAwBA,SAAS,kBAAkB;AAc3B,IAAM,gBAAgB,oBAAI,IAAI;AAAA,EAC7B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACD,CAAC;AAMM,SAAS,eAAe,QAA0D;AACxF,QAAM,OAAgC,CAAC;AACvC,aAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AAClD,QAAI,CAAC,cAAc,IAAI,GAAG,GAAG;AAC5B,WAAK,GAAG,IAAI;AAAA,IACb;AAAA,EACD;AACA,SAAO;AACR;AAMO,SAAS,cACf,QACA,OACiE;AACjE,QAAM,UAA0E,CAAC;AACjF,QAAM,UAAU,oBAAI,IAAI,CAAC,GAAG,OAAO,KAAK,MAAM,GAAG,GAAG,OAAO,KAAK,KAAK,CAAC,CAAC;AAEvE,aAAW,OAAO,SAAS;AAC1B,QAAI,cAAc,IAAI,GAAG,EAAG;AAC5B,UAAM,SAAS,OAAO,GAAG;AACzB,UAAM,SAAS,MAAM,GAAG;AAGxB,QAAI,WAAW,UAAU,KAAK,UAAU,MAAM,MAAM,KAAK,UAAU,MAAM,GAAG;AAC3E,cAAQ,KAAK,EAAE,OAAO,KAAK,UAAU,QAAQ,UAAU,OAAO,CAAC;AAAA,IAChE;AAAA,EACD;AAEA,SAAO;AACR;AAMO,SAAS,oBACf,YACA,QACA,UACA,UACc;AACd,SAAO;AAAA,IACN,IAAI,WAAW;AAAA,IACf,MAAM,GAAG,UAAU,IAAI,MAAM;AAAA,IAC7B,aAAa;AAAA,IACb,eAAe;AAAA,IACf,SAAS,WAAW,EAAE,SAAS,IAAI,CAAC;AAAA,IACpC,YAAY,oBAAI,KAAK;AAAA,IACrB,UAAU,EAAE,UAAU,YAA6B;AAAA,EACpD;AACD;AAEO,SAAS,kBACf,YACA,UACA,SACgB;AAChB,SAAO,QAAQ,IAAI,CAAC,OAAO;AAAA,IAC1B,IAAI,WAAW;AAAA,IACf,MAAM,GAAG,UAAU;AAAA,IACnB,aAAa;AAAA,IACb,eAAe;AAAA,IACf,SAAS;AAAA,MACR,WAAW,EAAE;AAAA,MACb,UAAU,EAAE;AAAA,MACZ,UAAU,EAAE;AAAA,IACb;AAAA,IACA,YAAY,oBAAI,KAAK;AAAA,IACrB,UAAU,EAAE,UAAU,SAA0B;AAAA,EACjD,EAAE;AACH;AAUA,eAAsB,WACrB,UACA,QACgB;AAChB,MAAI,CAAC,YAAY,OAAO,WAAW,EAAG;AACtC,MAAI;AACH,QAAI,OAAO,WAAW,GAAG;AACxB,YAAM,OAAO,OAAO,CAAC;AACrB,UAAI,CAAC,KAAM;AACX,YAAM,SAAS,QAAQ,IAAI;AAAA,IAC5B,OAAO;AACN,YAAM,SAAS,YAAY,MAAM;AAAA,IAClC;AAAA,EACD,QAAQ;AAGP,YAAQ,KAAK,qCAAqC,OAAO,MAAM,WAAW;AAAA,EAC3E;AACD;","names":[]}

package/dist/chunk-L3LZWWSX.js

@@ -0,0 +1,61 @@
+// runtime/subsystems/jobs/job-run-keyset-cursor.ts
+var DEFAULT_LIST_LIMIT = 50;
+var MAX_LIST_LIMIT = 200;
+function clampLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    return DEFAULT_LIST_LIMIT;
+  }
+  const floored = Math.floor(limit);
+  if (floored < 1) return 1;
+  if (floored > MAX_LIST_LIMIT) return MAX_LIST_LIMIT;
+  return floored;
+}
+function encodeKeysetCursor(keyset) {
+  const tuple = [keyset.createdAt.toISOString(), keyset.id];
+  return Buffer.from(JSON.stringify(tuple), "utf8").toString("base64url");
+}
+function decodeKeysetCursor(cursor) {
+  try {
+    const json = Buffer.from(cursor, "base64url").toString("utf8");
+    const parsed = JSON.parse(json);
+    if (!Array.isArray(parsed) || parsed.length !== 2) return null;
+    const [iso, id] = parsed;
+    if (typeof iso !== "string" || typeof id !== "string") return null;
+    const createdAt = new Date(iso);
+    if (Number.isNaN(createdAt.getTime())) return null;
+    return { createdAt, id };
+  } catch {
+    return null;
+  }
+}
+function toJobRunSummary(r) {
+  return {
+    runId: r.id,
+    rootRunId: r.rootRunId,
+    parentRunId: r.parentRunId,
+    triggerSource: r.triggerSource,
+    triggerRef: r.triggerRef,
+    jobType: r.jobType,
+    pool: r.pool,
+    status: r.status,
+    scopeEntityType: r.scopeEntityType,
+    scopeEntityId: r.scopeEntityId,
+    tenantId: r.tenantId,
+    attempts: r.attempts,
+    errorMessage: r.error?.message ?? null,
+    runAt: r.runAt,
+    startedAt: r.startedAt,
+    finishedAt: r.finishedAt,
+    createdAt: r.createdAt
+  };
+}
+
+export {
+  DEFAULT_LIST_LIMIT,
+  MAX_LIST_LIMIT,
+  clampLimit,
+  encodeKeysetCursor,
+  decodeKeysetCursor,
+  toJobRunSummary
+};
+//# sourceMappingURL=chunk-L3LZWWSX.js.map

package/dist/chunk-L3LZWWSX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/jobs/job-run-keyset-cursor.ts"],"sourcesContent":["/**\n * Keyset (seek) cursor codec for `IJobRunService.listJobRuns` (OBS-LIST-1).\n *\n * The list is ordered `created_at DESC, id DESC`. The cursor encodes the\n * `(createdAt, id)` of the last row on the previous page so the next page\n * can seek with `WHERE (created_at, id) < (cursorCreatedAt, cursorId)`\n * rather than an `OFFSET`. Keyset pagination stays O(log n) on deep pages\n * and is stable as new rows arrive at the head.\n *\n * The cursor is opaque to consumers: a base64url-encoded JSON tuple. Shape\n * is an implementation detail — never parse it outside this module.\n *\n * Also hosts `toJobRunSummary`, the single `JobRunRow → JobRunSummary`\n * projection shared by both backends so the narrow shape stays in sync.\n */\nimport type { JobRunRow } from './job-orchestration.schema';\nimport type { JobRunSummary } from './job-run-service.protocol';\n\nexport interface JobRunKeyset {\n  /** `created_at` of the last row on the previous page. */\n  createdAt: Date;\n  /** `id` (UUID) tie-break of the last row on the previous page. */\n  id: string;\n}\n\n/** Default page size when `limit` is omitted. */\nexport const DEFAULT_LIST_LIMIT = 50;\n/** Hard upper bound on page size to keep a single read bounded. */\nexport const MAX_LIST_LIMIT = 200;\n\n/** Clamp a caller-supplied `limit` into `[1, MAX_LIST_LIMIT]`. */\nexport function clampLimit(limit: number | undefined): number {\n  if (typeof limit !== 'number' || !Number.isFinite(limit)) {\n    return DEFAULT_LIST_LIMIT;\n  }\n  const floored = Math.floor(limit);\n  if (floored < 1) return 1;\n  if (floored > MAX_LIST_LIMIT) return MAX_LIST_LIMIT;\n  return floored;\n}\n\nexport function encodeKeysetCursor(keyset: JobRunKeyset): string {\n  const tuple = [keyset.createdAt.toISOString(), keyset.id];\n  return Buffer.from(JSON.stringify(tuple), 'utf8').toString('base64url');\n}\n\n/**\n * Decode an opaque cursor back into its `(createdAt, id)` keyset. Returns\n * `null` for a malformed cursor so callers can treat garbage input as\n * \"start from the beginning\" rather than throwing on user-supplied data.\n */\nexport function decodeKeysetCursor(cursor: string): JobRunKeyset | null {\n  try {\n    const json = Buffer.from(cursor, 'base64url').toString('utf8');\n    const parsed = JSON.parse(json) as unknown;\n    if (!Array.isArray(parsed) || parsed.length !== 2) return null;\n    const [iso, id] = parsed;\n    if (typeof iso !== 'string' || typeof id !== 'string') return null;\n    const createdAt = new Date(iso);\n    if (Number.isNaN(createdAt.getTime())) return null;\n    return { createdAt, id };\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Project a raw `job_run` row into the narrow `JobRunSummary` shape exposed\n * by `listJobRuns`. `errorMessage` is pulled from the jsonb `error.message`.\n */\nexport function toJobRunSummary(r: JobRunRow): JobRunSummary {\n  return {\n    runId: r.id,\n    rootRunId: r.rootRunId,\n    parentRunId: r.parentRunId,\n    triggerSource: r.triggerSource,\n    triggerRef: r.triggerRef,\n    jobType: r.jobType,\n    pool: r.pool,\n    status: r.status,\n    scopeEntityType: r.scopeEntityType,\n    scopeEntityId: r.scopeEntityId,\n    tenantId: r.tenantId,\n    attempts: r.attempts,\n    errorMessage: r.error?.message ?? null,\n    runAt: r.runAt,\n    startedAt: r.startedAt,\n    finishedAt: r.finishedAt,\n    createdAt: r.createdAt,\n  };\n}\n"],"mappings":";AA0BO,IAAM,qBAAqB;AAE3B,IAAM,iBAAiB;AAGvB,SAAS,WAAW,OAAmC;AAC5D,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,GAAG;AACxD,WAAO;AAAA,EACT;AACA,QAAM,UAAU,KAAK,MAAM,KAAK;AAChC,MAAI,UAAU,EAAG,QAAO;AACxB,MAAI,UAAU,eAAgB,QAAO;AACrC,SAAO;AACT;AAEO,SAAS,mBAAmB,QAA8B;AAC/D,QAAM,QAAQ,CAAC,OAAO,UAAU,YAAY,GAAG,OAAO,EAAE;AACxD,SAAO,OAAO,KAAK,KAAK,UAAU,KAAK,GAAG,MAAM,EAAE,SAAS,WAAW;AACxE;AAOO,SAAS,mBAAmB,QAAqC;AACtE,MAAI;AACF,UAAM,OAAO,OAAO,KAAK,QAAQ,WAAW,EAAE,SAAS,MAAM;AAC7D,UAAM,SAAS,KAAK,MAAM,IAAI;AAC9B,QAAI,CAAC,MAAM,QAAQ,MAAM,KAAK,OAAO,WAAW,EAAG,QAAO;AAC1D,UAAM,CAAC,KAAK,EAAE,IAAI;AAClB,QAAI,OAAO,QAAQ,YAAY,OAAO,OAAO,SAAU,QAAO;AAC9D,UAAM,YAAY,IAAI,KAAK,GAAG;AAC9B,QAAI,OAAO,MAAM,UAAU,QAAQ,CAAC,EAAG,QAAO;AAC9C,WAAO,EAAE,WAAW,GAAG;AAAA,EACzB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAMO,SAAS,gBAAgB,GAA6B;AAC3D,SAAO;AAAA,IACL,OAAO,EAAE;AAAA,IACT,WAAW,EAAE;AAAA,IACb,aAAa,EAAE;AAAA,IACf,eAAe,EAAE;AAAA,IACjB,YAAY,EAAE;AAAA,IACd,SAAS,EAAE;AAAA,IACX,MAAM,EAAE;AAAA,IACR,QAAQ,EAAE;AAAA,IACV,iBAAiB,EAAE;AAAA,IACnB,eAAe,EAAE;AAAA,IACjB,UAAU,EAAE;AAAA,IACZ,UAAU,EAAE;AAAA,IACZ,cAAc,EAAE,OAAO,WAAW;AAAA,IAClC,OAAO,EAAE;AAAA,IACT,WAAW,EAAE;AAAA,IACb,YAAY,EAAE;AAAA,IACd,WAAW,EAAE;AAAA,EACf;AACF;","names":[]}

package/dist/chunk-L4SDDEEU.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-L4SDDEEU.js.map

package/dist/chunk-L4SDDEEU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-L6FTY45T.js

@@ -0,0 +1,13 @@
+import {
+  tokenKey
+} from "./chunk-GYGNEQSC.js";
+
+// runtime/subsystems/cache/cache.tokens.ts
+var CACHE = Symbol.for(tokenKey("cache", "cache"));
+var CACHE_DEFAULT_TTL = Symbol.for(tokenKey("cache", "default-ttl"));
+
+export {
+  CACHE,
+  CACHE_DEFAULT_TTL
+};
+//# sourceMappingURL=chunk-L6FTY45T.js.map

package/dist/chunk-L6FTY45T.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/cache/cache.tokens.ts"],"sourcesContent":["/**\n * Injection token for the cache service.\n *\n * Usage in use cases:\n * ```typescript\n * constructor(@Inject(CACHE) private readonly cache: ICacheService) {}\n * ```\n *\n * Services may also inject CACHE for reads (get, has) per ADR-003.\n *\n * ADR-037: namespaced `Symbol.for(...)` key (via `tokenKey()`) so the token matches\n * by value across import boundaries (package vs vendored runtime copy).\n */\nimport { tokenKey } from '../token-key';\n\nexport const CACHE = Symbol.for(tokenKey('cache', 'cache'));\n\n/**\n * Injection token for the default TTL (in seconds) passed from CacheModule.forRoot().\n * Optional — omit for no-expiry behavior.\n */\nexport const CACHE_DEFAULT_TTL = Symbol.for(tokenKey('cache', 'default-ttl'));\n"],"mappings":";;;;;AAeO,IAAM,QAAQ,OAAO,IAAI,SAAS,SAAS,OAAO,CAAC;AAMnD,IAAM,oBAAoB,OAAO,IAAI,SAAS,SAAS,aAAa,CAAC;","names":[]}

package/dist/chunk-L7BNNRGI.js

@@ -0,0 +1,134 @@
+import {
+  BRIDGE_DELIVERY_JOB_TYPE
+} from "./chunk-YTN6BKWA.js";
+import {
+  bridgeDelivery
+} from "./chunk-2TVVBC53.js";
+import {
+  BRIDGE_REGISTRY
+} from "./chunk-4LH67P4U.js";
+import {
+  jobRuns
+} from "./chunk-OKXZ63IA.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/bridge/bridge-outbox-drain-hook.ts
+import { Inject, Injectable, Logger, Optional } from "@nestjs/common";
+import { randomUUID } from "crypto";
+import { eq } from "drizzle-orm";
+var POOL_BY_DIRECTION = {
+  inbound: "events_inbound",
+  change: "events_change",
+  outbound: "events_outbound"
+};
+var BridgeOutboxDrainHook = class {
+  constructor(registry = {}) {
+    this.registry = registry;
+  }
+  registry;
+  logger = new Logger(BridgeOutboxDrainHook.name);
+  warnedNullDirection = false;
+  warnedAuditTypes = /* @__PURE__ */ new Set();
+  async processEvent(event, tx) {
+    if (event.metadata?.["tier"] === "audit") {
+      this.warnAuditBlockedOnce(event);
+      return {
+        delivered: 0,
+        dedupSkips: 0,
+        triggerCount: 0,
+        auditBlocked: 1
+      };
+    }
+    const triggers = this.lookupTriggers(event.type);
+    if (triggers.length === 0) {
+      return {
+        delivered: 0,
+        dedupSkips: 0,
+        triggerCount: 0,
+        auditBlocked: 0
+      };
+    }
+    const direction = event.metadata?.["direction"] ?? null;
+    const tenantId = event.metadata?.["tenantId"] ?? null;
+    const wrapperPool = direction ? POOL_BY_DIRECTION[direction] : void 0;
+    if (!wrapperPool) {
+      if (!this.warnedNullDirection) {
+        this.warnedNullDirection = true;
+        this.logger.warn(
+          `Skipping bridge fanout for events with null/unknown direction. event.id=${event.id} event.type=${event.type} direction=${String(direction)}. The wrapper pool is derived from direction (events_<direction>); publishers must use TypedEventBus.publish() so direction is stamped on the outbox row.`
+        );
+      }
+      return {
+        delivered: 0,
+        dedupSkips: 0,
+        triggerCount: triggers.length,
+        auditBlocked: 0
+      };
+    }
+    let delivered = 0;
+    let dedupSkips = 0;
+    const client = tx;
+    for (const trigger of triggers) {
+      const deliveryId = randomUUID();
+      const wrapperRunId = randomUUID();
+      await tx.insert(jobRuns).values({
+        id: wrapperRunId,
+        jobType: BRIDGE_DELIVERY_JOB_TYPE,
+        jobVersion: 1,
+        rootRunId: wrapperRunId,
+        pool: wrapperPool,
+        status: "pending",
+        input: { deliveryId },
+        triggerSource: "event",
+        triggerRef: event.id,
+        tenantId
+      });
+      const inserted = await tx.insert(bridgeDelivery).values({
+        id: deliveryId,
+        eventId: event.id,
+        triggerId: trigger.triggerId,
+        wrapperRunId,
+        status: "pending",
+        tenantId
+      }).onConflictDoNothing({
+        target: [bridgeDelivery.eventId, bridgeDelivery.triggerId]
+      }).returning({ id: bridgeDelivery.id });
+      if (inserted.length === 0) {
+        await tx.delete(jobRuns).where(eq(jobRuns.id, wrapperRunId));
+        dedupSkips++;
+        continue;
+      }
+      delivered++;
+    }
+    return {
+      delivered,
+      dedupSkips,
+      triggerCount: triggers.length,
+      auditBlocked: 0
+    };
+  }
+  warnAuditBlockedOnce(event) {
+    if (this.warnedAuditTypes.has(event.type)) return;
+    this.warnedAuditTypes.add(event.type);
+    this.logger.warn(
+      `Bridge guard blocked audit-tier event '${event.type}' (event.id=${event.id}). Registry says this event is not bridge-eligible; a bridge_trigger row exists out-of-band. Investigate registry/runtime drift.`
+    );
+  }
+  lookupTriggers(eventType) {
+    const candidates = this.registry[eventType];
+    return candidates ?? [];
+  }
+};
+BridgeOutboxDrainHook = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Optional()),
+  __decorateParam(0, Inject(BRIDGE_REGISTRY))
+], BridgeOutboxDrainHook);
+
+export {
+  BridgeOutboxDrainHook
+};
+//# sourceMappingURL=chunk-L7BNNRGI.js.map

package/dist/chunk-L7BNNRGI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/bridge/bridge-outbox-drain-hook.ts"],"sourcesContent":["/**\n * BridgeOutboxDrainHook — drains-time bridge fanout writer (BRIDGE-4,\n * ADR-023 Phase 2).\n *\n * Implements `IBridgeOutboxDrainHook`. Called by `DrizzleEventBus`'s\n * modified `processBatch` once per drained event, INSIDE the per-event\n * transaction. For every trigger registered against the event's type in\n * the codegen-emitted `bridgeRegistry`, writes:\n *\n *   1. `bridge_delivery` ledger row — `INSERT … ON CONFLICT (event_id,\n *      trigger_id) DO NOTHING RETURNING id`. Empty result ⇒ Case B\n *      facade-eager pre-write OR drain-replay collision; skip wrapper\n *      insert for that trigger; sibling triggers still fire.\n *   2. `job_run` wrapper row — `type='@framework/bridge_delivery'`,\n *      `pool='events_<direction>'`, `input={ deliveryId }`,\n *      `trigger_source='event'`, `trigger_ref=event.id`. The wrapper is\n *      what the framework `BridgeDeliveryHandler` (BRIDGE-5) eventually\n *      claims via the worker that polls the corresponding reserved pool.\n *\n * Null `event.metadata.direction` is tolerated: the hook logs a one-line\n * warning per event and returns zeros without writing rows. The drain's\n * `processed_at` stamp + subscriber dispatch still fire normally.\n * Direction is null only for events published via the legacy\n * `IEventBus.publish(...)` path (`TypedEventBus.publish` always sets it);\n * such events are out of scope for bridge fanout.\n *\n * The wrapper insert generates its own `id` via Drizzle's `defaultRandom`\n * — we don't `RETURNING id` because nobody needs it at drain time;\n * `BridgeDeliveryHandler` later looks up the wrapper via the\n * `bridge_delivery.wrapper_run_id` link if needed. This keeps the drain\n * one-round-trip-per-trigger.\n */\nimport { Inject, Injectable, Logger, Optional } from '@nestjs/common';\nimport { randomUUID } from 'node:crypto';\nimport { eq } from 'drizzle-orm';\n\nimport type { DomainEvent, DrizzleTransaction } from '../events/event-bus.protocol';\nimport { bridgeDelivery } from './bridge-delivery.schema';\nimport { jobRuns } from '../jobs/job-orchestration.schema';\n\nimport { BRIDGE_REGISTRY } from './bridge.tokens';\nimport type {\n  BridgeOutboxDrainResult,\n  BridgeRegistry,\n  BridgeTriggerEntry,\n  IBridgeOutboxDrainHook,\n} from './bridge.protocol';\nimport { BRIDGE_DELIVERY_JOB_TYPE } from './bridge-delivery-handler';\nimport type { EventTypeName } from '../events/event-registry';\n\n/** Reserved pools the wrapper rows route into; ADR-022 / ADR-024. */\nconst POOL_BY_DIRECTION: Record<string, string> = {\n  inbound: 'events_inbound',\n  change: 'events_change',\n  outbound: 'events_outbound',\n};\n\n@Injectable()\nexport class BridgeOutboxDrainHook implements IBridgeOutboxDrainHook {\n  private readonly logger = new Logger(BridgeOutboxDrainHook.name);\n  private warnedNullDirection = false;\n  private readonly warnedAuditTypes = new Set<string>();\n\n  constructor(\n    @Optional()\n    @Inject(BRIDGE_REGISTRY)\n    private readonly registry: BridgeRegistry = {},\n  ) {}\n\n  async processEvent(\n    event: DomainEvent,\n    tx: DrizzleTransaction,\n  ): Promise<BridgeOutboxDrainResult> {\n    // Audit-tier guard (defense-in-depth — AUDIT-4). Audit events are not\n    // bridge-eligible: the codegen-side validator (AUDIT-2) blocks the\n    // registry from listing them as triggers. Reaching this branch means\n    // registry/runtime drift — an out-of-band `bridge_trigger` insert, or\n    // version skew during deploy. Refuse fanout, surface drift via WARN.\n    if (event.metadata?.['tier'] === 'audit') {\n      this.warnAuditBlockedOnce(event);\n      return {\n        delivered: 0,\n        dedupSkips: 0,\n        triggerCount: 0,\n        auditBlocked: 1,\n      };\n    }\n\n    const triggers = this.lookupTriggers(event.type);\n    if (triggers.length === 0) {\n      return {\n        delivered: 0,\n        dedupSkips: 0,\n        triggerCount: 0,\n        auditBlocked: 0,\n      };\n    }\n\n    const direction =\n      (event.metadata?.['direction'] as string | undefined) ?? null;\n    const tenantId =\n      (event.metadata?.['tenantId'] as string | null | undefined) ?? null;\n    const wrapperPool = direction ? POOL_BY_DIRECTION[direction] : undefined;\n\n    if (!wrapperPool) {\n      // Null direction (or an unrecognised one — defensive). Bridge\n      // fanout requires a routed wrapper pool; without one we can't\n      // spawn. Log once per process so misconfiguration surfaces.\n      if (!this.warnedNullDirection) {\n        this.warnedNullDirection = true;\n        this.logger.warn(\n          `Skipping bridge fanout for events with null/unknown direction. ` +\n            `event.id=${event.id} event.type=${event.type} ` +\n            `direction=${String(direction)}. The wrapper pool is derived ` +\n            `from direction (events_<direction>); publishers must use ` +\n            `TypedEventBus.publish() so direction is stamped on the ` +\n            `outbox row.`,\n        );\n      }\n      return {\n        delivered: 0,\n        dedupSkips: 0,\n        triggerCount: triggers.length,\n        auditBlocked: 0,\n      };\n    }\n\n    let delivered = 0;\n    let dedupSkips = 0;\n    const client = tx as unknown as {\n      insert: (table: unknown) => {\n        values: (v: unknown) => {\n          onConflictDoNothing: (opts: unknown) => {\n            returning: (cols: unknown) => Promise<{ id: string }[]>;\n          };\n        } & {\n          // wrapper insert path — no ON CONFLICT\n          // (typed loosely via the same helper return shape)\n        };\n      };\n    };\n\n    for (const trigger of triggers) {\n      const deliveryId = randomUUID();\n      const wrapperRunId = randomUUID();\n\n      // FK ORDER (BRIDGE / 0.15.2): `bridge_delivery.wrapper_run_id` REFERENCES\n      // `job_run(id)` is a plain (non-deferrable) FK, so the referenced\n      // wrapper `job_run` MUST exist before the delivery row that points at it\n      // is inserted — otherwise Postgres rejects the delivery insert\n      // immediately. (The codegen unit tests mock `tx`, so they never\n      // exercised this ordering against a real FK; package-mode bridge\n      // deliveries are the first to do so.) We therefore insert the wrapper\n      // run FIRST, then the delivery. Idempotency is unchanged: the delivery\n      // keeps its `ON CONFLICT (event_id, trigger_id) DO NOTHING RETURNING`,\n      // and when the delivery conflicts (outbox replay or facade-eager Case B)\n      // we DELETE the just-inserted orphan wrapper run in the same tx, so a\n      // skipped delivery leaves no stray `job_run` for a worker to claim.\n\n      // 1. Wrapper job_run insert. We carry the deliveryId into the wrapper\n      //    input so BridgeDeliveryHandler.run(ctx) can locate the row via\n      //    repo.findDeliveryById(ctx.input.deliveryId).\n      await (tx as unknown as { insert: typeof client.insert })\n        .insert(jobRuns)\n        .values({\n          id: wrapperRunId,\n          jobType: BRIDGE_DELIVERY_JOB_TYPE,\n          jobVersion: 1,\n          rootRunId: wrapperRunId,\n          pool: wrapperPool,\n          status: 'pending',\n          input: { deliveryId },\n          triggerSource: 'event',\n          triggerRef: event.id,\n          tenantId,\n        });\n\n      // 2. bridge_delivery insert with ON CONFLICT DO NOTHING + RETURNING.\n      const inserted = await (tx as unknown as {\n        insert: typeof client.insert;\n      })\n        .insert(bridgeDelivery)\n        .values({\n          id: deliveryId,\n          eventId: event.id,\n          triggerId: trigger.triggerId,\n          wrapperRunId,\n          status: 'pending',\n          tenantId,\n        })\n        .onConflictDoNothing({\n          target: [bridgeDelivery.eventId, bridgeDelivery.triggerId],\n        })\n        .returning({ id: bridgeDelivery.id });\n\n      if (inserted.length === 0) {\n        // Case B (facade pre-wrote `delivered`) or drain replay — the delivery\n        // already exists, so this trigger is a no-op. Remove the orphan wrapper\n        // run we speculatively inserted above so no worker claims it. Sibling\n        // triggers still fire.\n        await (tx as unknown as {\n          delete: (table: unknown) => {\n            where: (cond: unknown) => Promise<unknown>;\n          };\n        })\n          .delete(jobRuns)\n          .where(eq(jobRuns.id, wrapperRunId));\n        dedupSkips++;\n        continue;\n      }\n\n      delivered++;\n    }\n\n    return {\n      delivered,\n      dedupSkips,\n      triggerCount: triggers.length,\n      auditBlocked: 0,\n    };\n  }\n\n  private warnAuditBlockedOnce(event: DomainEvent): void {\n    if (this.warnedAuditTypes.has(event.type)) return;\n    this.warnedAuditTypes.add(event.type);\n    this.logger.warn(\n      `Bridge guard blocked audit-tier event '${event.type}' (event.id=${event.id}). ` +\n        `Registry says this event is not bridge-eligible; a bridge_trigger row exists ` +\n        `out-of-band. Investigate registry/runtime drift.`,\n    );\n  }\n\n  private lookupTriggers(\n    eventType: string,\n  ): BridgeTriggerEntry[] {\n    const candidates = this.registry[eventType as EventTypeName];\n    return (candidates ?? []) as BridgeTriggerEntry[];\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-LG57S2SC.js

@@ -0,0 +1,150 @@
+// runtime/subsystems/integration/incremental-read.ts
+async function mapConcurrent(ids, fn, limit) {
+  const out = /* @__PURE__ */ new Map();
+  if (ids.length === 0) return out;
+  const width = Math.max(1, Math.min(limit, ids.length));
+  let next = 0;
+  const worker = async () => {
+    while (next < ids.length) {
+      const idx = next++;
+      const id = ids[idx];
+      out.set(id, await fn(id));
+    }
+  };
+  await Promise.all(Array.from({ length: width }, worker));
+  return out;
+}
+var IncrementalReadBase = class {
+  /**
+   * Whether the vendor takes the request predicate server-side. Declared, not
+   * enforced here — surfaced into the emission manifest (R3) so the falsifier
+   * suite (R4) can record which adapters filter post-hydrate. `false` is the
+   * honest floor (e.g. Gmail without `q=`), handled via `matchesRecord`.
+   */
+  filterPushdown = false;
+  /** Max concurrent in-flight calls for a `mapConcurrent`-built `hydrate`. */
+  hydrateConcurrency = 10;
+  /** `Change<T>.source` provenance stamped by `listChanges`. */
+  changeSource = "poll";
+  /**
+   * Whether this source's cursor strategy is divisible (RFC-0003 §3). When
+   * `true` (default — sortable watermarks like `systemModstamp`/`timestamp`/
+   * `replayId`), `listChanges` emits each record's per-ref cursor, so the
+   * orchestrator may checkpoint mid-walk and a crash resumes from the last
+   * delivered ref.
+   *
+   * When `false` (atomic opaque tokens — Gmail `historyId`, Calendar
+   * `syncToken`), `listChanges` WITHHOLDS per-ref cursors and emits the
+   * end-of-walk token only on the final record, so the orchestrator's
+   * persist-last-yielded lifecycle can never persist an unresumable mid-walk
+   * token. The cost is blast-radius: an interrupted atomic run resumes
+   * all-or-nothing from the prior persisted token. For atomic *backfills* that
+   * radius is the whole enumerate walk — bound it with `ReadRequest.pageSize`
+   * (smaller pages ⇒ shorter walks per run). Per-page atomic checkpointing is a
+   * future refinement; R2 gates at end-of-walk.
+   *
+   * Codegen (R3) sets this from the strategy kind via `isDivisibleCursor`.
+   */
+  cursorDivisible = true;
+  // ---- Optional filter hooks — exactly one is live per `filterPushdown` ----
+  /** Pre-hydrate predicate over the cheap ref (preferred — avoids hydration). */
+  matchesRef(_ref, _filter) {
+    return true;
+  }
+  /** Post-hydrate predicate over the canonical record (the no-pushdown floor). */
+  matchesRecord(_record, _filter) {
+    return true;
+  }
+  /**
+   * Resolve the filter for a subscription when adapting to `listChanges`
+   * (which has no filter argument). Defaults to none; codegen wiring (R3)
+   * overrides this to thread `DetectionConfig.filters`.
+   */
+  filterFor(_subscription) {
+    return void 0;
+  }
+  // ---- PROVIDED by the base ----
+  /**
+   * Stream canonical records for a request. Filter is applied BEFORE hydrate
+   * (structural: a kept ref is hydrated, a rejected one never is), so an
+   * adapter cannot hydrate-then-discard. A hydrate miss (deleted mid-run) is
+   * skipped, never fabricated.
+   */
+  async *read(req, ctx) {
+    for await (const refPage of this.enumerate(req.mode, req.filter, req.pageSize, ctx)) {
+      const kept = refPage.filter((ref) => this.matchesRef(ref, req.filter));
+      if (kept.length === 0) continue;
+      const raws = await this.hydrate(
+        kept.map((ref) => ref.externalId),
+        ctx
+      );
+      for (const ref of kept) {
+        const raw = raws.get(ref.externalId);
+        if (raw === void 0 || raw === null) continue;
+        const record = this.toCanonical(raw);
+        if (record !== null && this.matchesRecord(record, req.filter)) {
+          yield { externalId: ref.externalId, record, raw, cursor: ref.cursor };
+        }
+      }
+    }
+  }
+  /**
+   * `RandomRead<T>` — single-record read, provided for free as
+   * `toCanonical ∘ hydrate([id])`. Reuses the adapter's batched fetch + miss
+   * tolerance; returns `null` for a missing or undecodable record.
+   */
+  async get(id, ctx) {
+    const raws = await this.hydrate([id], ctx);
+    const raw = raws.get(id);
+    if (raw === void 0 || raw === null) return null;
+    return this.toCanonical(raw);
+  }
+  /**
+   * `IChangeSource<T>` adaptation. Maps the orchestrator's by-value cursor to a
+   * `ReadMode` (`null` → `full` backfill, else `delta`), streams `read()`, and
+   * stamps each `SourcedRecord` into a `Change<T>`. All records surface as
+   * `'updated'`; the orchestrator's diff stage classifies create-vs-update and
+   * deletes arrive as tombstone refs (`toCanonical` may flag them).
+   *
+   * Cursor emission honors `cursorDivisible` (RFC-0003 §3). Divisible: each
+   * record carries its own per-ref cursor. Atomic: per-ref cursors are withheld
+   * (`undefined`, which the orchestrator skips persisting) and the end-of-walk
+   * token rides only on the final record — so a mid-walk crash never persists
+   * an unresumable token. If an atomic run yields no surviving records, no
+   * cursor is persisted and the next run re-reads the same (empty) delta — a
+   * bounded inefficiency, never data loss.
+   */
+  async *listChanges(subscription, cursor) {
+    const mode = cursor === null || cursor === void 0 ? { kind: "full" } : { kind: "delta", cursor };
+    const filter = this.filterFor(subscription);
+    const stream = this.read({ mode, filter }, { subscription });
+    if (this.cursorDivisible) {
+      for await (const sourced of stream) {
+        yield this.toChange(sourced, sourced.cursor);
+      }
+      return;
+    }
+    let prev = null;
+    for await (const sourced of stream) {
+      if (prev !== null) yield this.toChange(prev, void 0);
+      prev = sourced;
+    }
+    if (prev !== null) yield this.toChange(prev, prev.cursor);
+  }
+  /** Stamp a `SourcedRecord` into a `Change<T>` with an explicit emitted cursor. */
+  toChange(sourced, cursor) {
+    return {
+      externalId: sourced.externalId,
+      operation: "updated",
+      record: sourced.record,
+      cursor,
+      source: this.changeSource
+    };
+  }
+};
+
+export {
+  mapConcurrent,
+  IncrementalReadBase
+};
+//# sourceMappingURL=chunk-LG57S2SC.js.map