@pattern-stack/codegen 0.15.1 → 0.15.2

package/dist/runtime/subsystems/events/index.js

@@ -1,953 +1,36 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __decorateParam = (index2, decorator) => (target, key) => decorator(target, key, index2);
-
-// runtime/subsystems/token-key.ts
-var PKG = "@pattern-stack/codegen";
-var tokenKey = (area, name) => `${PKG}.${area}.${name}`;
-
-// runtime/subsystems/events/events.tokens.ts
-var EVENT_BUS = "EVENT_BUS";
-var EVENT_READ_PORT = "EVENT_READ_PORT";
-var TYPED_EVENT_BUS = "TYPED_EVENT_BUS";
-var EVENTS_MULTI_TENANT = "EVENTS_MULTI_TENANT";
-var REDIS_URL = Symbol.for(tokenKey("events", "redis-url"));
-var EVENTS_MODULE_OPTIONS = "EVENTS_MODULE_OPTIONS";
-
-// runtime/subsystems/events/generated/bus.ts
-import { Injectable, Inject } from "@nestjs/common";
-import { randomUUID } from "crypto";
-
-// runtime/subsystems/events/events-errors.ts
-var MissingTenantIdError = class extends Error {
-  constructor(eventType) {
-    super(
-      `Missing tenantId for event '${eventType}'. EventsModule is configured with multiTenant: true \u2014 every publish must include opts.metadata.tenantId. Either pass the tenantId or disable multi-tenancy on the module.`
-    );
-    this.eventType = eventType;
-  }
-  eventType;
-  name = "MissingTenantIdError";
-};
-
-// runtime/subsystems/events/generated/schemas.ts
-import { z } from "zod";
-var contactCreatedPayloadSchema = z.object({
-  accountId: z.string().uuid().nullable(),
-  contactId: z.string().uuid(),
-  createdBy: z.string().uuid()
-}).strict();
-var contactMarkedChampionPayloadSchema = z.object({
-  contactId: z.string().uuid(),
-  opportunityId: z.string().uuid()
-}).strict();
-var contactMergedPayloadSchema = z.object({
-  mergedBy: z.string().uuid(),
-  sourceId: z.string().uuid(),
-  targetId: z.string().uuid()
-}).strict();
-var crmSyncStartedPayloadSchema = z.object({
-  runId: z.string().uuid(),
-  source: z.string()
-}).strict();
-var dealCreatedPayloadSchema = z.object({
-  accountId: z.string().uuid(),
-  dealId: z.string().uuid(),
-  ownerId: z.string().uuid()
-}).strict();
-var dealStageChangedPayloadSchema = z.object({
-  dealId: z.string().uuid(),
-  newStage: z.string(),
-  oldStage: z.string()
-}).strict();
-var stripePaymentReceivedPayloadSchema = z.object({
-  amountCents: z.number(),
-  currency: z.string(),
-  customerId: z.string(),
-  eventId: z.string(),
-  receivedAt: z.coerce.date()
-}).strict();
-var webhookOutboundContactSyncPayloadSchema = z.object({
-  contactId: z.string().uuid(),
-  occurredAt: z.coerce.date(),
-  operation: z.string()
-}).strict();
-var eventPayloadSchemas = {
-  "contact_created": contactCreatedPayloadSchema,
-  "contact_marked_champion": contactMarkedChampionPayloadSchema,
-  "contact_merged": contactMergedPayloadSchema,
-  "crm_sync_started": crmSyncStartedPayloadSchema,
-  "deal_created": dealCreatedPayloadSchema,
-  "deal_stage_changed": dealStageChangedPayloadSchema,
-  "stripe_payment_received": stripePaymentReceivedPayloadSchema,
-  "webhook_outbound_contact_sync": webhookOutboundContactSyncPayloadSchema
-};
-
-// runtime/subsystems/events/generated/registry.ts
-var eventRegistry = {
-  "contact_created": {
-    type: "contact_created",
-    tier: "domain",
-    direction: "change",
-    pool: "events_change",
-    aggregate: "contact",
-    version: 1,
-    retry: { attempts: 3, backoff: "exponential" }
-  },
-  "contact_marked_champion": {
-    type: "contact_marked_champion",
-    tier: "domain",
-    direction: "change",
-    pool: "events_change",
-    aggregate: "contact",
-    version: 1,
-    retry: { attempts: 3, backoff: "exponential" }
-  },
-  "contact_merged": {
-    type: "contact_merged",
-    tier: "domain",
-    direction: "change",
-    pool: "events_change",
-    aggregate: "contact",
-    version: 1,
-    retry: { attempts: 3, backoff: "exponential" }
-  },
-  "crm_sync_started": {
-    type: "crm_sync_started",
-    tier: "audit",
-    direction: null,
-    pool: null,
-    version: 1,
-    retry: { attempts: 3, backoff: "exponential" }
-  },
-  "deal_created": {
-    type: "deal_created",
-    tier: "domain",
-    direction: "change",
-    pool: "events_change",
-    aggregate: "deal",
-    version: 1,
-    retry: { attempts: 3, backoff: "exponential" }
-  },
-  "deal_stage_changed": {
-    type: "deal_stage_changed",
-    tier: "domain",
-    direction: "change",
-    pool: "events_change",
-    aggregate: "deal",
-    version: 1,
-    retry: { attempts: 3, backoff: "exponential" }
-  },
-  "stripe_payment_received": {
-    type: "stripe_payment_received",
-    tier: "domain",
-    direction: "inbound",
-    pool: "events_inbound",
-    source: "stripe",
-    version: 1,
-    retry: { attempts: 5, backoff: "exponential" }
-  },
-  "webhook_outbound_contact_sync": {
-    type: "webhook_outbound_contact_sync",
-    tier: "domain",
-    direction: "outbound",
-    pool: "events_outbound",
-    aggregate: "contact",
-    destination: "crm",
-    version: 1,
-    retry: { attempts: 3, backoff: "exponential" }
-  }
-};
-function getEventMetadata(type) {
-  const meta = eventRegistry[type];
-  if (!meta) {
-    throw new Error(`No registry entry for event type '${String(type)}' \u2014 declare events under events/*.yaml and re-run \`codegen entity new --all\`.`);
-  }
-  return meta;
-}
-
-// runtime/subsystems/events/generated/bus.ts
-var TypedEventBus = class {
-  constructor(bus, multiTenant) {
-    this.bus = bus;
-    this.multiTenant = multiTenant;
-  }
-  bus;
-  multiTenant;
-  async publish(type, aggregateId, payload, opts) {
-    const meta = getEventMetadata(type);
-    const flag = process.env["CODEGEN_EVENT_VALIDATE"];
-    const shouldValidate = flag === void 0 ? true : flag !== "false" && flag !== "0";
-    if (shouldValidate) {
-      const schema = eventPayloadSchemas[type];
-      if (schema) {
-        const check2 = schema.safeParse(payload);
-        if (!check2.success) {
-          console.warn(
-            `[TypedEventBus] payload validation failed for ${String(type)}:`,
-            check2.error.issues
-          );
-        }
-      }
-    }
-    const tenantId = opts?.metadata?.["tenantId"];
-    if (this.multiTenant && (tenantId === void 0 || tenantId === null)) {
-      throw new MissingTenantIdError(type);
-    }
-    const aggregateType = meta.aggregate ?? meta.source ?? meta.destination ?? type;
-    const baseMetadata = { ...opts?.metadata ?? {} };
-    if (meta.tier === "audit") {
-      if (baseMetadata["pool"] !== void 0 || baseMetadata["direction"] !== void 0) {
-        console.debug(
-          `[TypedEventBus] tier:audit event '${String(type)}' had pool/direction in opts.metadata; overriding to null.`
-        );
-      }
-      baseMetadata["pool"] = null;
-      baseMetadata["direction"] = null;
-      baseMetadata["tier"] = "audit";
-    } else {
-      baseMetadata["pool"] = meta.pool;
-      baseMetadata["direction"] = meta.direction;
-      baseMetadata["tier"] = "domain";
-    }
-    baseMetadata["version"] = meta.version;
-    await this.bus.publish(
-      {
-        id: randomUUID(),
-        type,
-        aggregateId,
-        aggregateType,
-        payload,
-        occurredAt: /* @__PURE__ */ new Date(),
-        metadata: baseMetadata
-      },
-      opts?.tx
-    );
-  }
-  subscribe(type, handler) {
-    return this.bus.subscribe(type, handler);
-  }
-};
-TypedEventBus = __decorateClass([
-  Injectable(),
-  __decorateParam(0, Inject(EVENT_BUS)),
-  __decorateParam(1, Inject(EVENTS_MULTI_TENANT))
-], TypedEventBus);
-
-// runtime/subsystems/events/events.module.ts
-import { Module } from "@nestjs/common";
-
-// runtime/constants/tokens.ts
-var DRIZZLE = "DRIZZLE";
-
-// runtime/subsystems/events/event-bus.drizzle-backend.ts
-import { Injectable as Injectable2, Inject as Inject2, Logger, Optional } from "@nestjs/common";
-import { eq, and, inArray, asc, desc, gte, lt, or, sql as sql2 } from "drizzle-orm";
-
-// runtime/subsystems/events/event-keyset-cursor.ts
-var DEFAULT_EVENT_LIST_LIMIT = 50;
-var MAX_EVENT_LIST_LIMIT = 200;
-function clampEventLimit(limit) {
-  if (typeof limit !== "number" || !Number.isFinite(limit)) {
-    return DEFAULT_EVENT_LIST_LIMIT;
-  }
-  const floored = Math.floor(limit);
-  if (floored < 1) return 1;
-  if (floored > MAX_EVENT_LIST_LIMIT) return MAX_EVENT_LIST_LIMIT;
-  return floored;
-}
-function encodeEventCursor(keyset) {
-  const tuple = [keyset.occurredAt.toISOString(), keyset.id];
-  return Buffer.from(JSON.stringify(tuple), "utf8").toString("base64url");
-}
-function decodeEventCursor(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 occurredAt = new Date(iso);
-    if (Number.isNaN(occurredAt.getTime())) return null;
-    return { occurredAt, id };
-  } catch {
-    return null;
-  }
-}
-
-// runtime/subsystems/events/domain-events.schema.ts
+import "../../../chunk-FN2PYDPP.js";
 import {
-  check,
-  index,
-  jsonb,
-  pgTable,
-  text,
-  timestamp,
-  uuid
-} from "drizzle-orm/pg-core";
-import { sql } from "drizzle-orm";
-var domainEvents = pgTable(
-  "domain_events",
-  {
-    id: uuid("id").primaryKey(),
-    type: text("type").notNull(),
-    aggregateId: text("aggregate_id").notNull(),
-    aggregateType: text("aggregate_type").notNull(),
-    payload: jsonb("payload").notNull().$type(),
-    occurredAt: timestamp("occurred_at", { withTimezone: true }).notNull(),
-    processedAt: timestamp("processed_at", { withTimezone: true }),
-    /** Lifecycle status: pending | processed | failed */
-    status: text("status").notNull().default("pending"),
-    /** Error message from the last failed dispatch attempt. */
-    error: text("error"),
-    metadata: jsonb("metadata").$type(),
-    /** Routing pool (e.g. `events_inbound`, `events_change`, `events_outbound`). Populated by DrizzleEventBus.publish() in EVT-4. NULL when `tier='audit'`. */
-    pool: text("pool"),
-    /** Routing direction: `inbound` | `change` | `outbound`. Populated by DrizzleEventBus.publish() in EVT-4. NULL when `tier='audit'`. */
-    direction: text("direction"),
-    /**
-     * Event tier: `'domain'` (default) or `'audit'`. Audit-tier rows are
-     * observability-only and have null `pool`/`direction` by construction —
-     * enforced by the `domain_events_tier_routing_check` CHECK constraint
-     * declared below. (AUDIT-1)
-     */
-    tier: text("tier").notNull().default("domain"),
-    // conditional: emitted only when events.multi_tenant: true
-    tenantId: text("tenant_id")
-  },
-  (t) => ({
-    /** Polling drain filter (existing — promoted from comment to declaration in EVT-1). */
-    idxDomainEventsStatusOccurredAt: index("idx_domain_events_status_occurred_at").on(
-      t.status,
-      t.occurredAt
-    ),
-    /** Event replay per aggregate (existing — promoted from comment to declaration in EVT-1). */
-    idxDomainEventsAggregate: index("idx_domain_events_aggregate").on(
-      t.aggregateId,
-      t.aggregateType
-    ),
-    /** Per-pool drain filter (EVT-1). Enables DrizzleEventBus to drain a single pool without scanning all events. */
-    idxDomainEventsPoolStatusOccurredAt: index(
-      "idx_domain_events_pool_status_occurred_at"
-    ).on(t.pool, t.status, t.occurredAt),
-    /** Per-tier filter (AUDIT-1). Backs the observability viewer's tier toggle. */
-    idxDomainEventsTierStatusOccurredAt: index(
-      "idx_domain_events_tier_status_occurred_at"
-    ).on(t.tier, t.status, t.occurredAt),
-    /**
-     * Tier ↔ routing-fields invariant (AUDIT-1):
-     *   - `tier` is one of `'domain' | 'audit'`.
-     *   - `tier='audit'` ⇔ `pool IS NULL AND direction IS NULL`.
-     *   - `tier='domain'` ⇒ `pool` and `direction` are populated (the
-     *     DrizzleEventBus inserts always supply them; the bus stamps them
-     *     in AUDIT-3).
-     */
-    tierRoutingCheck: check(
-      "domain_events_tier_routing_check",
-      sql`${t.tier} in ('domain','audit') AND ((${t.tier} = 'audit') = (${t.pool} is null and ${t.direction} is null))`
-    )
-  })
-);
-
-// runtime/subsystems/bridge/bridge.tokens.ts
-var BRIDGE_OUTBOX_DRAIN_HOOK = "BRIDGE_OUTBOX_DRAIN_HOOK";
-
-// runtime/subsystems/events/event-bus.drizzle-backend.ts
-var POLL_INTERVAL_MS = 1e3;
-var POLL_BATCH_SIZE = 50;
-function toInsertValues(event, multiTenant) {
-  const metadata = event.metadata ?? void 0;
-  const pool = metadata?.["pool"] ?? null;
-  const direction = metadata?.["direction"] ?? null;
-  const tier = metadata?.["tier"] ?? "domain";
-  const base = {
-    id: event.id,
-    type: event.type,
-    aggregateId: event.aggregateId,
-    aggregateType: event.aggregateType,
-    payload: event.payload,
-    occurredAt: event.occurredAt,
-    processedAt: null,
-    status: "pending",
-    metadata: event.metadata,
-    pool,
-    direction,
-    tier
-  };
-  if (!multiTenant) return base;
-  const tenantId = metadata?.["tenantId"] ?? null;
-  return { ...base, tenantId };
-}
-function toEventSummary(r) {
-  const metadata = r.metadata ?? void 0;
-  const rootRunId = metadata?.["rootRunId"];
-  return {
-    id: r.id,
-    type: r.type,
-    aggregateId: r.aggregateId,
-    aggregateType: r.aggregateType,
-    status: r.status,
-    pool: r.pool,
-    direction: r.direction,
-    tier: r.tier,
-    rootRunId: typeof rootRunId === "string" ? rootRunId : null,
-    // EVT-8: `tenant_id` is a scaffold-time conditional column. Read it
-    // structurally so this projection typechecks against both the
-    // multi-tenant schema (column present) and the single-tenant schema
-    // (column absent → undefined → null).
-    tenantId: r.tenantId ?? null,
-    occurredAt: r.occurredAt instanceof Date ? r.occurredAt : new Date(r.occurredAt),
-    processedAt: r.processedAt == null ? null : r.processedAt instanceof Date ? r.processedAt : new Date(r.processedAt)
-  };
-}
-var DrizzleEventBus = class {
-  constructor(db, opts, bridgeHook = null) {
-    this.db = db;
-    this.bridgeHook = bridgeHook;
-    this.opts = opts ?? { backend: "drizzle" };
-  }
-  db;
-  bridgeHook;
-  logger = new Logger(DrizzleEventBus.name);
-  polling = false;
-  pollTimer = null;
-  handlers = /* @__PURE__ */ new Map();
-  opts;
-  // ============================================================================
-  // Lifecycle
-  // ============================================================================
-  async onModuleInit() {
-    this.polling = true;
-    this.schedulePoll();
-  }
-  async onModuleDestroy() {
-    this.polling = false;
-    if (this.pollTimer) {
-      clearTimeout(this.pollTimer);
-      this.pollTimer = null;
-    }
-  }
-  // ============================================================================
-  // IEventBus
-  // ============================================================================
-  async publish(event, tx) {
-    const client = tx ?? this.db;
-    const multiTenant = this.opts.multiTenant ?? false;
-    await client.insert(domainEvents).values(toInsertValues(event, multiTenant));
-  }
-  async publishMany(events, tx) {
-    if (events.length === 0) return;
-    const client = tx ?? this.db;
-    const multiTenant = this.opts.multiTenant ?? false;
-    await client.insert(domainEvents).values(events.map((e) => toInsertValues(e, multiTenant)));
-  }
-  async findById(eventId) {
-    const rows = await this.db.select().from(domainEvents).where(eq(domainEvents.id, eventId)).limit(1);
-    const row = rows[0];
-    if (!row) return null;
-    return {
-      id: row.id,
-      type: row.type,
-      aggregateId: row.aggregateId,
-      aggregateType: row.aggregateType,
-      payload: row.payload,
-      occurredAt: row.occurredAt instanceof Date ? row.occurredAt : new Date(row.occurredAt),
-      metadata: row.metadata ?? void 0
-    };
-  }
-  subscribe(eventType, handler) {
-    if (!this.handlers.has(eventType)) {
-      this.handlers.set(eventType, /* @__PURE__ */ new Set());
-    }
-    const set = this.handlers.get(eventType);
-    const h = handler;
-    set.add(h);
-    return () => {
-      set.delete(h);
-    };
-  }
-  // ============================================================================
-  // IEventReadPort (OBS-LIST-1)
-  // ============================================================================
-  async listEvents(query = {}) {
-    const limit = clampEventLimit(query.limit);
-    const conditions = [];
-    if (query.poolId) conditions.push(eq(domainEvents.pool, query.poolId));
-    if (query.direction)
-      conditions.push(eq(domainEvents.direction, query.direction));
-    if (query.since) conditions.push(gte(domainEvents.occurredAt, query.since));
-    if (query.rootRunId) {
-      conditions.push(
-        sql2`${domainEvents.metadata}->>'rootRunId' = ${query.rootRunId}`
-      );
-    }
-    if (this.opts.multiTenant && query.tenantId !== void 0) {
-      const tenantIdColumn = domainEvents.tenantId;
-      conditions.push(
-        query.tenantId === null ? sql2`${tenantIdColumn} is null` : eq(tenantIdColumn, query.tenantId)
-      );
-    }
-    if (query.cursor) {
-      const keyset = decodeEventCursor(query.cursor);
-      if (keyset) {
-        conditions.push(
-          or(
-            lt(domainEvents.occurredAt, keyset.occurredAt),
-            and(
-              eq(domainEvents.occurredAt, keyset.occurredAt),
-              lt(domainEvents.id, keyset.id)
-            )
-          )
-        );
-      }
-    }
-    const rows = await this.db.select().from(domainEvents).where(conditions.length > 0 ? and(...conditions) : void 0).orderBy(desc(domainEvents.occurredAt), desc(domainEvents.id)).limit(limit + 1);
-    const hasMore = rows.length > limit;
-    const page = hasMore ? rows.slice(0, limit) : rows;
-    const items = page.map(toEventSummary);
-    const last = page[page.length - 1];
-    const nextCursor = hasMore && last ? encodeEventCursor({ occurredAt: last.occurredAt, id: last.id }) : null;
-    return { items, nextCursor };
-  }
-  // ============================================================================
-  // Polling
-  // ============================================================================
-  /**
-   * Test-only hook. Runs exactly one drain cycle and returns. Production
-   * code goes through `onModuleInit` → `schedulePoll`, which calls the
-   * same `processBatch` under a timer.
-   */
-  async drainOnce() {
-    await this.processBatch();
-  }
-  schedulePoll() {
-    if (!this.polling) return;
-    this.pollTimer = setTimeout(async () => {
-      try {
-        await this.processBatch();
-      } catch (err) {
-        this.logger.error(`Poll cycle error: ${err}`);
-      } finally {
-        this.schedulePoll();
-      }
-    }, POLL_INTERVAL_MS);
-  }
-  /**
-   * Drain one batch (BRIDGE-4 restructure of EVT-4).
-   *
-   * Two-phase per drained event:
-   *
-   *   1. **Per-event transaction** — bridge fanout (`bridgeHook.processEvent`)
-   *      + `processed_at` stamp. Both write through the same `tx`. A throw
-   *      inside the tx (only infra-level failures should reach here, since
-   *      the hook tolerates null direction and registry misses inline)
-   *      rolls back the bridge inserts AND the `processed_at` stamp; the
-   *      event re-claims on the next drain cycle. Bridge `UNIQUE
-   *      (event_id, trigger_id)` makes the retry idempotent.
-   *
-   *   2. **After commit** — dispatch in-process subscribers (`IEventBus.subscribe`
-   *      handlers). This deliberately runs OUTSIDE the per-event tx (lead
-   *      decision 2026-04-22): subscribers are best-effort and must not
-   *      gate forward progress or roll back bridge fanout. Subscriber
-   *      errors are caught + logged; `processed_at` is already committed.
-   *      The old `MAX_RETRIES=3` in-process retry loop and the
-   *      `failed`-stamping path were removed in BRIDGE-4 along with their
-   *      coupling.
-   *
-   * The `processed_at` UPDATE carries `AND status='pending'` (BRIDGE-4
-   * tightening — without it, a hypothetical double-claim could double-stamp
-   * the timestamp). The per-event tx + `FOR UPDATE SKIP LOCKED` claim
-   * make this defensive belt-and-suspenders.
-   */
-  async processBatch() {
-    const pools = this.opts.pools;
-    const whereClause = pools && pools.length > 0 ? and(eq(domainEvents.status, "pending"), inArray(domainEvents.pool, pools)) : eq(domainEvents.status, "pending");
-    const rows = await this.db.transaction(async (tx) => {
-      return tx.select().from(domainEvents).where(whereClause).orderBy(asc(domainEvents.occurredAt)).limit(POLL_BATCH_SIZE).for("update", { skipLocked: true });
-    });
-    for (const row of rows) {
-      const event = {
-        id: row.id,
-        type: row.type,
-        aggregateId: row.aggregateId,
-        aggregateType: row.aggregateType,
-        payload: row.payload,
-        occurredAt: row.occurredAt instanceof Date ? row.occurredAt : new Date(row.occurredAt),
-        metadata: row.metadata ?? void 0
-      };
-      try {
-        await this.db.transaction(async (tx) => {
-          if (this.bridgeHook) {
-            await this.bridgeHook.processEvent(event, tx);
-          }
-          await tx.update(domainEvents).set({ status: "processed", processedAt: /* @__PURE__ */ new Date() }).where(
-            and(
-              eq(domainEvents.id, event.id),
-              eq(domainEvents.status, "pending")
-            )
-          );
-        });
-      } catch (err) {
-        this.logger.error(
-          `Per-event tx failed for event id=${event.id} type=${event.type}: ${err}`
-        );
-        continue;
-      }
-      try {
-        await this.dispatch(event);
-      } catch (err) {
-        this.logger.error(
-          `Subscriber dispatch failed for event id=${event.id} type=${event.type} (processed_at already committed; failure does not retry): ${err}`
-        );
-      }
-    }
-  }
-  async dispatch(event) {
-    const set = this.handlers.get(event.type);
-    if (!set) return;
-    let firstError;
-    for (const handler of set) {
-      try {
-        await handler(event);
-      } catch (err) {
-        this.logger.error(
-          `Handler error for event type "${event.type}" (id: ${event.id}): ${err}`
-        );
-        if (firstError === void 0) {
-          firstError = err;
-        }
-      }
-    }
-    if (firstError !== void 0) {
-      throw firstError;
-    }
-  }
-};
-DrizzleEventBus = __decorateClass([
-  Injectable2(),
-  __decorateParam(0, Inject2(DRIZZLE)),
-  __decorateParam(1, Optional()),
-  __decorateParam(1, Inject2(EVENTS_MODULE_OPTIONS)),
-  __decorateParam(2, Optional()),
-  __decorateParam(2, Inject2(BRIDGE_OUTBOX_DRAIN_HOOK))
-], DrizzleEventBus);
-
-// runtime/subsystems/events/event-bus.memory-backend.ts
-import { Inject as Inject3, Injectable as Injectable3, Logger as Logger2, Optional as Optional2 } from "@nestjs/common";
-function toEventSummary2(event) {
-  const metadata = event.metadata;
-  const str = (key) => {
-    const v = metadata?.[key];
-    return typeof v === "string" ? v : null;
-  };
-  return {
-    id: event.id,
-    type: event.type,
-    aggregateId: event.aggregateId,
-    aggregateType: event.aggregateType,
-    status: "processed",
-    pool: str("pool"),
-    direction: str("direction"),
-    tier: str("tier") ?? "domain",
-    rootRunId: str("rootRunId"),
-    tenantId: str("tenantId"),
-    occurredAt: event.occurredAt,
-    processedAt: event.occurredAt
-  };
-}
-var MemoryEventBus = class {
-  logger = new Logger2(MemoryEventBus.name);
-  /** All events published since construction (or last clear). */
-  publishedEvents = [];
-  handlers = /* @__PURE__ */ new Map();
-  opts;
-  constructor(opts) {
-    this.opts = opts ?? { backend: "memory" };
-  }
-  async publish(event) {
-    this.assertTierRouting(event);
-    this.publishedEvents.push(event);
-    if (this.shouldDispatch(event)) {
-      await this.dispatch(event);
-    }
-  }
-  async publishMany(events) {
-    for (const event of events) {
-      await this.publish(event);
-    }
-  }
-  async findById(eventId) {
-    return this.publishedEvents.find((e) => e.id === eventId) ?? null;
-  }
-  subscribe(eventType, handler) {
-    if (!this.handlers.has(eventType)) {
-      this.handlers.set(eventType, /* @__PURE__ */ new Set());
-    }
-    const set = this.handlers.get(eventType);
-    const h = handler;
-    set.add(h);
-    return () => {
-      set.delete(h);
-    };
-  }
-  // ============================================================================
-  // IEventReadPort (OBS-LIST-1)
-  // ============================================================================
-  async listEvents(query = {}) {
-    const limit = clampEventLimit(query.limit);
-    const keyset = query.cursor ? decodeEventCursor(query.cursor) : null;
-    const str = (e, key) => {
-      const v = e.metadata?.[key];
-      return typeof v === "string" ? v : null;
-    };
-    const matched = this.publishedEvents.filter((e) => {
-      if (query.poolId && str(e, "pool") !== query.poolId) return false;
-      if (query.direction && str(e, "direction") !== query.direction)
-        return false;
-      if (query.rootRunId && str(e, "rootRunId") !== query.rootRunId)
-        return false;
-      if (query.since && e.occurredAt.getTime() < query.since.getTime())
-        return false;
-      if (query.tenantId !== void 0) {
-        const t = str(e, "tenantId");
-        if (query.tenantId === null) {
-          if (t !== null) return false;
-        } else if (t !== query.tenantId) {
-          return false;
-        }
-      }
-      return true;
-    });
-    matched.sort((a, b) => {
-      const dt = b.occurredAt.getTime() - a.occurredAt.getTime();
-      if (dt !== 0) return dt;
-      return a.id < b.id ? 1 : a.id > b.id ? -1 : 0;
-    });
-    const seeked = keyset ? matched.filter((e) => {
-      const ct = e.occurredAt.getTime();
-      const kt = keyset.occurredAt.getTime();
-      if (ct < kt) return true;
-      if (ct > kt) return false;
-      return e.id < keyset.id;
-    }) : matched;
-    const hasMore = seeked.length > limit;
-    const page = hasMore ? seeked.slice(0, limit) : seeked;
-    const items = page.map(toEventSummary2);
-    const last = page[page.length - 1];
-    const nextCursor = hasMore && last ? encodeEventCursor({ occurredAt: last.occurredAt, id: last.id }) : null;
-    return { items, nextCursor };
-  }
-  /** Remove all published events and subscriptions. Useful in beforeEach. */
-  clear() {
-    this.publishedEvents.length = 0;
-    this.handlers.clear();
-  }
-  /** Filter published events by `metadata.pool`. */
-  publishedEventsForPool(pool) {
-    return this.publishedEvents.filter((e) => e.metadata?.["pool"] === pool);
-  }
-  /** Filter published events by `metadata.direction`. */
-  publishedEventsForDirection(direction) {
-    return this.publishedEvents.filter((e) => e.metadata?.["direction"] === direction);
-  }
-  /**
-   * Decide whether `event` should be dispatched to handlers given the
-   * current pool filter.
-   *
-   * Semantics (mirroring `DrizzleEventBus.processBatch`):
-   * - `opts.pools` undefined  → dispatch everything (no filter).
-   * - `opts.pools` empty array → treated as "no filter" to match the
-   *   Drizzle backend, where `pools && pools.length > 0` is the gate on
-   *   the `inArray` WHERE clause. Empty arrays dispatch everything.
-   * - `opts.pools` non-empty  → dispatch only when `event.metadata.pool`
-   *   is in the list. Events without `metadata.pool` do NOT match — they
-   *   are out of all configured pools by definition.
-   */
-  shouldDispatch(event) {
-    const pools = this.opts.pools;
-    if (!pools || pools.length === 0) return true;
-    const eventPool = event.metadata?.["pool"];
-    return typeof eventPool === "string" && pools.includes(eventPool);
-  }
-  /**
-   * Mirror the `domain_events_tier_routing_check` DB CHECK at the memory
-   * backend (AUDIT-1). Audit-tier events MUST have null/undefined
-   * `pool` and `direction` in metadata; the bridge dispatcher relies on
-   * this invariant.
-   */
-  assertTierRouting(event) {
-    const tier = event.metadata?.["tier"];
-    if (tier !== "audit") return;
-    const pool = event.metadata?.["pool"];
-    const direction = event.metadata?.["direction"];
-    const poolIsNull = pool === null || pool === void 0;
-    const directionIsNull = direction === null || direction === void 0;
-    if (!poolIsNull || !directionIsNull) {
-      throw new Error(
-        `MemoryEventBus: tier='audit' events must have null pool and direction (got pool=${String(pool)}, direction=${String(direction)}). This mirrors the domain_events CHECK constraint.`
-      );
-    }
-  }
-  async dispatch(event) {
-    const set = this.handlers.get(event.type);
-    if (!set) return;
-    let firstError;
-    for (const handler of set) {
-      try {
-        await handler(event);
-      } catch (err) {
-        this.logger.error(
-          `Handler error for event type "${event.type}" (id: ${event.id}): ${err}`
-        );
-        if (firstError === void 0) {
-          firstError = err;
-        }
-      }
-    }
-    if (firstError !== void 0) {
-      throw firstError;
-    }
-  }
-};
-MemoryEventBus = __decorateClass([
-  Injectable3(),
-  __decorateParam(0, Optional2()),
-  __decorateParam(0, Inject3(EVENTS_MODULE_OPTIONS))
-], MemoryEventBus);
-
-// runtime/subsystems/events/events.module.ts
-async function loadRedisEventBus() {
-  const specifier = "./event-bus.redis-backend";
-  const mod = await import(specifier);
-  return mod.RedisEventBus;
-}
-function buildTypedBusProviders(multiTenant, typedBus) {
-  const BusClass = typedBus ?? TypedEventBus;
-  return [
-    BusClass,
-    { provide: TYPED_EVENT_BUS, useExisting: BusClass },
-    { provide: EVENTS_MULTI_TENANT, useValue: multiTenant }
-  ];
-}
-async function buildEventBusAsync(options, db, redisUrl) {
-  if (options.backend === "drizzle") {
-    if (!db) {
-      throw new Error(
-        "EventsModule.forRootAsync: backend: 'drizzle' selected but DRIZZLE provider is not available. Ensure DatabaseModule (or another provider exposing DRIZZLE) is imported before EventsModule.forRootAsync."
-      );
-    }
-    return new DrizzleEventBus(db, options);
-  }
-  if (options.backend === "redis") {
-    const RedisEventBus = await loadRedisEventBus();
-    return new RedisEventBus(redisUrl);
-  }
-  return new MemoryEventBus(options);
-}
-var EventsModule = class {
-  static forRootAsync(asyncOptions) {
-    return {
-      module: EventsModule,
-      global: true,
-      imports: asyncOptions.imports ?? [],
-      providers: [
-        {
-          provide: EVENTS_MODULE_OPTIONS,
-          useFactory: asyncOptions.useFactory,
-          inject: asyncOptions.inject ?? []
-        },
-        {
-          provide: EVENTS_MULTI_TENANT,
-          useFactory: (options) => options.multiTenant ?? false,
-          inject: [EVENTS_MODULE_OPTIONS]
-        },
-        {
-          provide: REDIS_URL,
-          useFactory: (options) => options.redisUrl ?? process.env["REDIS_URL"] ?? "redis://localhost:6379",
-          inject: [EVENTS_MODULE_OPTIONS]
-        },
-        {
-          provide: EVENT_BUS,
-          useFactory: (options, db, redisUrl) => buildEventBusAsync(options, db, redisUrl),
-          inject: [
-            EVENTS_MODULE_OPTIONS,
-            { token: DRIZZLE, optional: true },
-            REDIS_URL
-          ]
-        },
-        {
-          // Read port (OBS-LIST-1). Drizzle + memory backends implement
-          // IEventReadPort on the EVENT_BUS instance; the redis backend
-          // retains no history, so EVENT_READ_PORT resolves to `null` and
-          // optional consumers (the observability combiner) degrade to
-          // empty results.
-          provide: EVENT_READ_PORT,
-          useFactory: (options, bus) => options.backend === "redis" ? null : bus,
-          inject: [EVENTS_MODULE_OPTIONS, EVENT_BUS]
-        },
-        TypedEventBus,
-        { provide: TYPED_EVENT_BUS, useExisting: TypedEventBus }
-      ],
-      exports: [EVENT_BUS, EVENT_READ_PORT, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
-    };
-  }
-  static forRoot(options = { backend: "drizzle" }) {
-    const multiTenant = options.multiTenant ?? false;
-    if (options.backend === "redis") {
-      const resolvedUrl = options.redisUrl ?? process.env["REDIS_URL"] ?? "redis://localhost:6379";
-      return {
-        module: EventsModule,
-        global: true,
-        providers: [
-          { provide: EVENTS_MODULE_OPTIONS, useValue: options },
-          { provide: REDIS_URL, useValue: resolvedUrl },
-          {
-            // #6: useFactory + dynamic import so the consumer's tsc never
-            // needs to resolve `event-bus.redis-backend.ts` for drizzle/
-            // memory installs (the file is filtered out by
-            // `backendFileFilter`). Nest awaits async factories + manages
-            // lifecycle on the returned instance, so we drop the old bare
-            // `RedisEventBus` provider entry.
-            provide: EVENT_BUS,
-            useFactory: async (url) => {
-              const RedisEventBus = await loadRedisEventBus();
-              return new RedisEventBus(url);
-            },
-            inject: [REDIS_URL]
-          },
-          ...buildTypedBusProviders(multiTenant, options.typedBus)
-        ],
-        exports: [EVENT_BUS, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
-      };
-    }
-    const provider = options.backend === "drizzle" ? { provide: EVENT_BUS, useClass: DrizzleEventBus } : { provide: EVENT_BUS, useClass: MemoryEventBus };
-    return {
-      module: EventsModule,
-      global: true,
-      providers: [
-        { provide: EVENTS_MODULE_OPTIONS, useValue: options },
-        provider,
-        // Read port (OBS-LIST-1): drizzle + memory backends implement
-        // IEventReadPort on the same instance as EVENT_BUS. The redis
-        // backend retains no history and does not provide this token.
-        { provide: EVENT_READ_PORT, useExisting: EVENT_BUS },
-        ...buildTypedBusProviders(multiTenant, options.typedBus)
-      ],
-      exports: [EVENT_BUS, EVENT_READ_PORT, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
-    };
-  }
-};
-EventsModule = __decorateClass([
-  Module({})
-], EventsModule);
+  EventsModule
+} from "../../../chunk-EOLLMEAH.js";
+import {
+  TypedEventBus
+} from "../../../chunk-GM3RMJIJ.js";
+import "../../../chunk-BGULBWKJ.js";
+import "../../../chunk-JRQO2IOF.js";
+import {
+  MissingTenantIdError
+} from "../../../chunk-V4AF6DI4.js";
+import {
+  DrizzleEventBus
+} from "../../../chunk-4JLJYWJC.js";
+import {
+  MemoryEventBus
+} from "../../../chunk-Z7PQCAVK.js";
+import "../../../chunk-UQ5EHOH2.js";
+import {
+  EVENTS_MODULE_OPTIONS,
+  EVENTS_MULTI_TENANT,
+  EVENT_BUS,
+  EVENT_READ_PORT,
+  TYPED_EVENT_BUS
+} from "../../../chunk-H5NH7KPE.js";
+import "../../../chunk-4LH67P4U.js";
+import {
+  domainEvents
+} from "../../../chunk-OFRRBC7M.js";
+import "../../../chunk-GYGNEQSC.js";
+import "../../../chunk-U64T4YZE.js";
+import "../../../chunk-2E224ZSN.js";
 export {
   DrizzleEventBus,
   EVENTS_MODULE_OPTIONS,