@pattern-stack/codegen 0.19.0 → 0.20.0

package/dist/chunk-DUUCU77W.js

@@ -0,0 +1,211 @@
+import {
+  ScheduleConfigError
+} from "./chunk-DUBZOXJC.js";
+
+// runtime/subsystems/events/event-scheduler.ts
+import { Logger } from "@nestjs/common";
+var UNIT_MS = Object.freeze({
+  ms: 1,
+  s: 1e3,
+  m: 6e4,
+  h: 36e5,
+  d: 864e5
+});
+function parseEvery(every, eventType) {
+  const where = eventType ? ` (event '${eventType}')` : "";
+  let ms;
+  if (typeof every === "number") {
+    ms = every;
+  } else if (typeof every === "string") {
+    const match = /^\s*([0-9]*\.?[0-9]+)\s*(ms|s|m|h|d)\s*$/.exec(every);
+    const value = match?.[1];
+    const unit = match?.[2];
+    const unitMs = unit ? UNIT_MS[unit] : void 0;
+    if (value === void 0 || unitMs === void 0) {
+      throw new ScheduleConfigError(
+        `schedule.every '${every}'${where} is not a valid duration. Use a number of ms or '<n><unit>' with unit ms|s|m|h|d (e.g. '1h', '30m').`
+      );
+    }
+    ms = Number(value) * unitMs;
+  } else {
+    throw new ScheduleConfigError(
+      `schedule.every${where} must be a duration string or a number of ms; got ${typeof every}.`
+    );
+  }
+  if (!Number.isFinite(ms) || ms <= 0) {
+    throw new ScheduleConfigError(
+      `schedule.every${where} resolved to ${ms}ms \u2014 must be a finite, positive duration.`
+    );
+  }
+  return ms;
+}
+function slotStartFor(atMs, everyMs, align, anchorMs) {
+  if (align) return Math.floor(atMs / everyMs) * everyMs;
+  if (atMs < anchorMs) return anchorMs;
+  return anchorMs + Math.floor((atMs - anchorMs) / everyMs) * everyMs;
+}
+function nextSlotStart(atMs, everyMs, align, anchorMs) {
+  return slotStartFor(atMs, everyMs, align, anchorMs) + everyMs;
+}
+var SCHEDULE_KEY_PREFIX = "@schedule/";
+function slotKeyFor(type, slotStartMs) {
+  return `${SCHEDULE_KEY_PREFIX}${type}/${slotStartMs}`;
+}
+var DEFAULT_MAX_CATCH_UP_SLOTS = 1e3;
+var SCHEDULE_FLOOR_MS = 1e3;
+function resolveScheduledEvent(type, schedule, direction, pool) {
+  if (!direction || !pool) {
+    throw new ScheduleConfigError(
+      `event '${type}' declares a schedule but has no direction/pool \u2014 a scheduled event must be domain-tier so it can route to the bridge.`
+    );
+  }
+  return {
+    type,
+    everyMs: parseEvery(schedule.every, type),
+    align: schedule.align ?? true,
+    catchUp: schedule.catchUp ?? false,
+    maxCatchUpSlots: schedule.maxCatchUpSlots ?? DEFAULT_MAX_CATCH_UP_SLOTS,
+    direction,
+    pool
+  };
+}
+function scheduledEventsFromRegistry(registry) {
+  const out = [];
+  for (const [type, meta] of Object.entries(registry)) {
+    if (!meta?.schedule) continue;
+    out.push(resolveScheduledEvent(type, meta.schedule, meta.direction, meta.pool));
+  }
+  return out;
+}
+var EventScheduler = class _EventScheduler {
+  constructor(bus, schedules, opts = {}) {
+    this.bus = bus;
+    this.schedules = schedules;
+    this.now = opts.now ?? Date.now;
+    this.anchorMs = this.now();
+    const smallest = schedules.length ? Math.min(...schedules.map((s) => s.everyMs)) : SCHEDULE_FLOOR_MS;
+    this.tickIntervalMs = opts.tickIntervalMs ?? Math.max(smallest, SCHEDULE_FLOOR_MS);
+    for (const s of schedules) {
+      if (s.everyMs < SCHEDULE_FLOOR_MS) {
+        this.logger.warn(
+          `schedule for '${s.type}' is every ${s.everyMs}ms \u2014 below the ${SCHEDULE_FLOOR_MS}ms floor; materialise/drain latency dominates, so the cadence is not honoured to that precision.`
+        );
+      }
+    }
+    if (typeof bus.materializeScheduledEvent !== "function") {
+      this.logger.warn(
+        `the configured event bus does not support scheduled-event materialisation; ${schedules.length} schedule(s) will not fire.`
+      );
+    }
+  }
+  bus;
+  schedules;
+  logger = new Logger(_EventScheduler.name);
+  now;
+  timer = null;
+  anchorMs;
+  tickIntervalMs;
+  /** Reconcile-on-boot, then start the tick interval. Idempotent. */
+  async start() {
+    if (this.schedules.length === 0) return;
+    if (typeof this.bus.materializeScheduledEvent !== "function") return;
+    await this.materializeBoot();
+    if (this.timer) return;
+    this.timer = setInterval(() => {
+      void this.materializeTick();
+    }, this.tickIntervalMs);
+    this.timer.unref?.();
+    this.logger.log(
+      `EventScheduler started: ${this.schedules.length} scheduled event(s), tick=${this.tickIntervalMs}ms.`
+    );
+  }
+  /** Stop the tick interval. Idempotent. */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /** Boot pass — materialise the current slot (or bounded backfill) per event. */
+  async materializeBoot() {
+    const nowMs = this.now();
+    for (const s of this.schedules) {
+      try {
+        if (s.catchUp) {
+          await this.backfill(s, nowMs);
+        } else {
+          await this.materializeOne(s, slotStartFor(nowMs, s.everyMs, s.align, this.anchorMs));
+        }
+      } catch (err) {
+        this.logger.error(
+          `boot materialise for '${s.type}' failed: ${err.message}`
+        );
+      }
+    }
+  }
+  /** Tick pass — materialise the current + next slot per event (current covers a
+   *  tick landing in a fresh slot the boot pass missed). */
+  async materializeTick() {
+    const nowMs = this.now();
+    for (const s of this.schedules) {
+      try {
+        const current = slotStartFor(nowMs, s.everyMs, s.align, this.anchorMs);
+        await this.materializeOne(s, current);
+        await this.materializeOne(s, current + s.everyMs);
+      } catch (err) {
+        this.logger.error(
+          `tick materialise for '${s.type}' failed: ${err.message}`
+        );
+      }
+    }
+  }
+  async materializeOne(s, slotStartMs) {
+    const materialize = this.bus.materializeScheduledEvent;
+    if (!materialize) return;
+    const slotKey = slotKeyFor(s.type, slotStartMs);
+    const { created } = await materialize.call(this.bus, {
+      type: s.type,
+      slotKey,
+      slotStart: new Date(slotStartMs),
+      direction: s.direction,
+      pool: s.pool
+    });
+    if (created) {
+      this.logger.debug?.(
+        `materialised '${s.type}' slot ${new Date(slotStartMs).toISOString()}`
+      );
+    }
+  }
+  /** Backfill missed slots from the last emitted slot to the current one,
+   *  bounded by `maxCatchUpSlots`. */
+  async backfill(s, nowMs) {
+    const current = slotStartFor(nowMs, s.everyMs, s.align, this.anchorMs);
+    const lastMs = await this.bus.lastScheduledSlotMs?.(s.type) ?? null;
+    let from = lastMs !== null ? lastMs + s.everyMs : current;
+    if (from > current) from = current;
+    const total = Math.floor((current - from) / s.everyMs) + 1;
+    if (total > s.maxCatchUpSlots) {
+      const dropped = total - s.maxCatchUpSlots;
+      from = current - (s.maxCatchUpSlots - 1) * s.everyMs;
+      this.logger.warn(
+        `catchUp for '${s.type}' would backfill ${total} slots; capping at ${s.maxCatchUpSlots} (dropping ${dropped} oldest).`
+      );
+    }
+    for (let slot = from; slot <= current; slot += s.everyMs) {
+      await this.materializeOne(s, slot);
+    }
+  }
+};
+
+export {
+  parseEvery,
+  slotStartFor,
+  nextSlotStart,
+  SCHEDULE_KEY_PREFIX,
+  slotKeyFor,
+  SCHEDULE_FLOOR_MS,
+  resolveScheduledEvent,
+  scheduledEventsFromRegistry,
+  EventScheduler
+};
+//# sourceMappingURL=chunk-DUUCU77W.js.map

package/dist/chunk-DUUCU77W.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/events/event-scheduler.ts"],"sourcesContent":["/**\n * EventScheduler — declarative time-based emission (ADR-039: time as an event\n * source). Materialises exactly one `domain_events` row per (scheduled event\n * type, slot) on a cadence; ADR-023's three activation tiers — unchanged — then\n * react. The scheduler is a STRICT PRODUCER: it emits facts and does no work\n * (the dealbrain `scheduler.service.ts` shape, generalised onto the outbox).\n *\n * Two entry points, both driven by `EventsModule`'s lifecycle:\n *\n *   - **reconcile-on-boot** (`materializeBoot`, at `onModuleInit`) — for every\n *     scheduled event type, materialise the CURRENT slot (catch-up off → run\n *     once on recovery) or bounded backfill (catch-up on). Boot is when a\n *     downtime-healing tick matters most. In the outbox model a removed\n *     `schedule:` simply stops being materialised — there's no broker scheduler\n *     entry to leave dangling, so the dealbrain ENG-605 \"zombie scheduler\" class\n *     of bug is structurally absent; the reconcile half is what we keep.\n *   - **tick pass** (`materializeTick` on an interval) — materialise each\n *     scheduled event's NEXT (and current) slot so ticks self-perpetuate.\n *\n * Exactly-one-per-slot lives in the DB (the partial UNIQUE expression index on\n * `(type, metadata->>'scheduleSlot')`), reached via\n * `IEventBus.materializeScheduledEvent` → `INSERT … ON CONFLICT DO NOTHING`.\n * The scheduler never READS for an existing slot event (that read is the\n * swe-brain dedupe trap — it matches the still-running incumbent). The slot key\n * is a pure function of (type, slot), so every instance computes the same key\n * and the constraint collapses the race.\n *\n * Drizzle + memory only. The Redis bus retains no outbox history, so slot-key\n * idempotency can't be enforced there (mirrors bridge-on-Redis being\n * unsupported); the scheduler is not wired under `backend: 'redis'`.\n */\nimport { Logger } from '@nestjs/common';\nimport type { IEventBus } from './event-bus.protocol';\nimport { ScheduleConfigError } from './events-errors';\n\n// ─── Duration grammar ────────────────────────────────────────────────────────\n\nconst UNIT_MS: Readonly<Record<string, number>> = Object.freeze({\n  ms: 1,\n  s: 1_000,\n  m: 60_000,\n  h: 3_600_000,\n  d: 86_400_000,\n});\n\n/**\n * Parse a `schedule.every` into milliseconds. Accepts a positive number (ms) or\n * a duration string `<number><unit>` (unit ∈ ms|s|m|h|d; decimals allowed).\n * Throws `ScheduleConfigError` synchronously on anything unparseable, ≤0, or\n * non-finite — so a bad schedule surfaces at boot before the tick loop starts.\n */\nexport function parseEvery(every: string | number, eventType?: string): number {\n  const where = eventType ? ` (event '${eventType}')` : '';\n  let ms: number;\n  if (typeof every === 'number') {\n    ms = every;\n  } else if (typeof every === 'string') {\n    const match = /^\\s*([0-9]*\\.?[0-9]+)\\s*(ms|s|m|h|d)\\s*$/.exec(every);\n    // Destructure the capture groups; under the consumer's stricter tsc\n    // (`noUncheckedIndexedAccess`) regex groups are `string | undefined` and\n    // the UNIT_MS lookup is `number | undefined`, so guard both explicitly\n    // rather than asserting. A truthy `match` always has both groups for this\n    // pattern, but the guard makes that provable (no non-null assertion).\n    const value = match?.[1];\n    const unit = match?.[2];\n    const unitMs = unit ? UNIT_MS[unit] : undefined;\n    if (value === undefined || unitMs === undefined) {\n      throw new ScheduleConfigError(\n        `schedule.every '${every}'${where} is not a valid duration. Use a ` +\n          `number of ms or '<n><unit>' with unit ms|s|m|h|d (e.g. '1h', '30m').`,\n      );\n    }\n    ms = Number(value) * unitMs;\n  } else {\n    throw new ScheduleConfigError(\n      `schedule.every${where} must be a duration string or a number of ms; ` +\n        `got ${typeof every}.`,\n    );\n  }\n  if (!Number.isFinite(ms) || ms <= 0) {\n    throw new ScheduleConfigError(\n      `schedule.every${where} resolved to ${ms}ms — must be a finite, positive ` +\n        `duration.`,\n    );\n  }\n  return ms;\n}\n\n// ─── Slot math ───────────────────────────────────────────────────────────────\n\n/**\n * The start of the slot containing `atMs`, for a schedule of `everyMs`.\n *   - `align: true` (default) — epoch-anchored: `floor(at / every) * every`.\n *   - `align: false` — anchored to `anchorMs` (the scheduler's first-run time).\n */\nexport function slotStartFor(\n  atMs: number,\n  everyMs: number,\n  align: boolean,\n  anchorMs: number,\n): number {\n  if (align) return Math.floor(atMs / everyMs) * everyMs;\n  if (atMs < anchorMs) return anchorMs;\n  return anchorMs + Math.floor((atMs - anchorMs) / everyMs) * everyMs;\n}\n\n/** The start of the slot AFTER the one containing `atMs`. */\nexport function nextSlotStart(\n  atMs: number,\n  everyMs: number,\n  align: boolean,\n  anchorMs: number,\n): number {\n  return slotStartFor(atMs, everyMs, align, anchorMs) + everyMs;\n}\n\n/** Prefix every scheduler-materialised `metadata.scheduleSlot` carries — the\n *  partial UNIQUE index is scoped to non-null slot keys; this prefix keeps the\n *  key namespace unambiguous and greppable. */\nexport const SCHEDULE_KEY_PREFIX = '@schedule/';\n\n/** Deterministic slot key. Pure function of (type, slotStart) — every instance\n *  computes the same value, which is what makes the idempotent insert\n *  exactly-once. */\nexport function slotKeyFor(type: string, slotStartMs: number): string {\n  return `${SCHEDULE_KEY_PREFIX}${type}/${slotStartMs}`;\n}\n\n// ─── Resolved schedule ───────────────────────────────────────────────────────\n\nconst DEFAULT_MAX_CATCH_UP_SLOTS = 1000;\n\n/** Below this floor (== the default outbox poll interval) materialise/drain\n *  latency dominates the cadence; allowed but warned once at boot. */\nexport const SCHEDULE_FLOOR_MS = 1_000;\n\n/** One scheduled event the scheduler will materialise. Built from the generated\n *  event registry (`schedule` block + direction/pool routing metadata). */\nexport interface ScheduledEvent {\n  type: string;\n  everyMs: number;\n  align: boolean;\n  catchUp: boolean;\n  maxCatchUpSlots: number;\n  /** Routing — from the event's registry metadata (a scheduled event is\n   *  domain-tier, so both are always present). */\n  direction: string;\n  pool: string;\n}\n\n/** The raw `schedule` block as it appears in the generated registry entry. */\nexport interface RegistrySchedule {\n  every: string | number;\n  align?: boolean;\n  catchUp?: boolean;\n  maxCatchUpSlots?: number;\n}\n\n/** Validate + normalise one registry entry's `schedule` into a `ScheduledEvent`.\n *  Throws `ScheduleConfigError` on a malformed `every` (boot backstop — codegen\n *  already validated, this catches hand-edits / version skew). */\nexport function resolveScheduledEvent(\n  type: string,\n  schedule: RegistrySchedule,\n  direction: string | null,\n  pool: string | null,\n): ScheduledEvent {\n  if (!direction || !pool) {\n    throw new ScheduleConfigError(\n      `event '${type}' declares a schedule but has no direction/pool — a ` +\n        `scheduled event must be domain-tier so it can route to the bridge.`,\n    );\n  }\n  return {\n    type,\n    everyMs: parseEvery(schedule.every, type),\n    align: schedule.align ?? true,\n    catchUp: schedule.catchUp ?? false,\n    maxCatchUpSlots: schedule.maxCatchUpSlots ?? DEFAULT_MAX_CATCH_UP_SLOTS,\n    direction,\n    pool,\n  };\n}\n\n/**\n * Read the scheduled-event set from a generated `eventRegistry`. The registry\n * value shape is structural (`{ schedule?, direction, pool }`) so this stays\n * decoupled from the generated `EventMetadata` type. Returns `[]` when nothing\n * declared `schedule:`.\n */\nexport function scheduledEventsFromRegistry(\n  registry: Record<\n    string,\n    { schedule?: RegistrySchedule; direction: string | null; pool: string | null }\n  >,\n): ScheduledEvent[] {\n  const out: ScheduledEvent[] = [];\n  for (const [type, meta] of Object.entries(registry)) {\n    if (!meta?.schedule) continue;\n    out.push(resolveScheduledEvent(type, meta.schedule, meta.direction, meta.pool));\n  }\n  return out;\n}\n\n// ─── EventScheduler ──────────────────────────────────────────────────────────\n\nexport interface EventSchedulerOptions {\n  /** Tick cadence (ms). Default = smallest scheduled `every`, floored. Test override. */\n  tickIntervalMs?: number;\n  /** Injectable clock for deterministic tests. Default `Date.now`. */\n  now?: () => number;\n}\n\nexport class EventScheduler {\n  private readonly logger = new Logger(EventScheduler.name);\n  private readonly now: () => number;\n  private timer: ReturnType<typeof setInterval> | null = null;\n  private readonly anchorMs: number;\n  private readonly tickIntervalMs: number;\n\n  constructor(\n    private readonly bus: IEventBus,\n    private readonly schedules: ReadonlyArray<ScheduledEvent>,\n    opts: EventSchedulerOptions = {},\n  ) {\n    this.now = opts.now ?? Date.now;\n    this.anchorMs = this.now();\n    const smallest = schedules.length\n      ? Math.min(...schedules.map((s) => s.everyMs))\n      : SCHEDULE_FLOOR_MS;\n    this.tickIntervalMs = opts.tickIntervalMs ?? Math.max(smallest, SCHEDULE_FLOOR_MS);\n    for (const s of schedules) {\n      if (s.everyMs < SCHEDULE_FLOOR_MS) {\n        this.logger.warn(\n          `schedule for '${s.type}' is every ${s.everyMs}ms — below the ` +\n            `${SCHEDULE_FLOOR_MS}ms floor; materialise/drain latency dominates, ` +\n            `so the cadence is not honoured to that precision.`,\n        );\n      }\n    }\n    if (typeof bus.materializeScheduledEvent !== 'function') {\n      // The backend (e.g. Redis) cannot enforce slot idempotency. Caller\n      // should not construct the scheduler for such backends; guard anyway.\n      this.logger.warn(\n        `the configured event bus does not support scheduled-event ` +\n          `materialisation; ${schedules.length} schedule(s) will not fire.`,\n      );\n    }\n  }\n\n  /** Reconcile-on-boot, then start the tick interval. Idempotent. */\n  async start(): Promise<void> {\n    if (this.schedules.length === 0) return;\n    if (typeof this.bus.materializeScheduledEvent !== 'function') return;\n    await this.materializeBoot();\n    if (this.timer) return;\n    this.timer = setInterval(() => {\n      void this.materializeTick();\n    }, this.tickIntervalMs);\n    (this.timer as { unref?: () => void }).unref?.();\n    this.logger.log(\n      `EventScheduler started: ${this.schedules.length} scheduled event(s), ` +\n        `tick=${this.tickIntervalMs}ms.`,\n    );\n  }\n\n  /** Stop the tick interval. Idempotent. */\n  stop(): void {\n    if (this.timer) {\n      clearInterval(this.timer);\n      this.timer = null;\n    }\n  }\n\n  /** Boot pass — materialise the current slot (or bounded backfill) per event. */\n  async materializeBoot(): Promise<void> {\n    const nowMs = this.now();\n    for (const s of this.schedules) {\n      try {\n        if (s.catchUp) {\n          await this.backfill(s, nowMs);\n        } else {\n          await this.materializeOne(s, slotStartFor(nowMs, s.everyMs, s.align, this.anchorMs));\n        }\n      } catch (err) {\n        this.logger.error(\n          `boot materialise for '${s.type}' failed: ${(err as Error).message}`,\n        );\n      }\n    }\n  }\n\n  /** Tick pass — materialise the current + next slot per event (current covers a\n   *  tick landing in a fresh slot the boot pass missed). */\n  async materializeTick(): Promise<void> {\n    const nowMs = this.now();\n    for (const s of this.schedules) {\n      try {\n        const current = slotStartFor(nowMs, s.everyMs, s.align, this.anchorMs);\n        await this.materializeOne(s, current);\n        await this.materializeOne(s, current + s.everyMs);\n      } catch (err) {\n        this.logger.error(\n          `tick materialise for '${s.type}' failed: ${(err as Error).message}`,\n        );\n      }\n    }\n  }\n\n  private async materializeOne(s: ScheduledEvent, slotStartMs: number): Promise<void> {\n    // `materialize*` only runs after `start()`/the boot path confirmed the bus\n    // supports materialisation; guard here too (no non-null assertion) so the\n    // optional-method call is provably defined.\n    const materialize = this.bus.materializeScheduledEvent;\n    if (!materialize) return;\n    const slotKey = slotKeyFor(s.type, slotStartMs);\n    const { created } = await materialize.call(this.bus, {\n      type: s.type,\n      slotKey,\n      slotStart: new Date(slotStartMs),\n      direction: s.direction,\n      pool: s.pool,\n    });\n    if (created) {\n      this.logger.debug?.(\n        `materialised '${s.type}' slot ${new Date(slotStartMs).toISOString()}`,\n      );\n    }\n  }\n\n  /** Backfill missed slots from the last emitted slot to the current one,\n   *  bounded by `maxCatchUpSlots`. */\n  private async backfill(s: ScheduledEvent, nowMs: number): Promise<void> {\n    const current = slotStartFor(nowMs, s.everyMs, s.align, this.anchorMs);\n    const lastMs = (await this.bus.lastScheduledSlotMs?.(s.type)) ?? null;\n    let from = lastMs !== null ? lastMs + s.everyMs : current;\n    if (from > current) from = current; // last >= current → just (re)try current\n    const total = Math.floor((current - from) / s.everyMs) + 1;\n    if (total > s.maxCatchUpSlots) {\n      const dropped = total - s.maxCatchUpSlots;\n      from = current - (s.maxCatchUpSlots - 1) * s.everyMs;\n      this.logger.warn(\n        `catchUp for '${s.type}' would backfill ${total} slots; capping at ` +\n          `${s.maxCatchUpSlots} (dropping ${dropped} oldest).`,\n      );\n    }\n    for (let slot = from; slot <= current; slot += s.everyMs) {\n      await this.materializeOne(s, slot);\n    }\n  }\n}\n"],"mappings":";;;;;AA+BA,SAAS,cAAc;AAMvB,IAAM,UAA4C,OAAO,OAAO;AAAA,EAC9D,IAAI;AAAA,EACJ,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AAAA,EACH,GAAG;AACL,CAAC;AAQM,SAAS,WAAW,OAAwB,WAA4B;AAC7E,QAAM,QAAQ,YAAY,YAAY,SAAS,OAAO;AACtD,MAAI;AACJ,MAAI,OAAO,UAAU,UAAU;AAC7B,SAAK;AAAA,EACP,WAAW,OAAO,UAAU,UAAU;AACpC,UAAM,QAAQ,2CAA2C,KAAK,KAAK;AAMnE,UAAM,QAAQ,QAAQ,CAAC;AACvB,UAAM,OAAO,QAAQ,CAAC;AACtB,UAAM,SAAS,OAAO,QAAQ,IAAI,IAAI;AACtC,QAAI,UAAU,UAAa,WAAW,QAAW;AAC/C,YAAM,IAAI;AAAA,QACR,mBAAmB,KAAK,IAAI,KAAK;AAAA,MAEnC;AAAA,IACF;AACA,SAAK,OAAO,KAAK,IAAI;AAAA,EACvB,OAAO;AACL,UAAM,IAAI;AAAA,MACR,iBAAiB,KAAK,qDACb,OAAO,KAAK;AAAA,IACvB;AAAA,EACF;AACA,MAAI,CAAC,OAAO,SAAS,EAAE,KAAK,MAAM,GAAG;AACnC,UAAM,IAAI;AAAA,MACR,iBAAiB,KAAK,gBAAgB,EAAE;AAAA,IAE1C;AAAA,EACF;AACA,SAAO;AACT;AASO,SAAS,aACd,MACA,SACA,OACA,UACQ;AACR,MAAI,MAAO,QAAO,KAAK,MAAM,OAAO,OAAO,IAAI;AAC/C,MAAI,OAAO,SAAU,QAAO;AAC5B,SAAO,WAAW,KAAK,OAAO,OAAO,YAAY,OAAO,IAAI;AAC9D;AAGO,SAAS,cACd,MACA,SACA,OACA,UACQ;AACR,SAAO,aAAa,MAAM,SAAS,OAAO,QAAQ,IAAI;AACxD;AAKO,IAAM,sBAAsB;AAK5B,SAAS,WAAW,MAAc,aAA6B;AACpE,SAAO,GAAG,mBAAmB,GAAG,IAAI,IAAI,WAAW;AACrD;AAIA,IAAM,6BAA6B;AAI5B,IAAM,oBAAoB;AA2B1B,SAAS,sBACd,MACA,UACA,WACA,MACgB;AAChB,MAAI,CAAC,aAAa,CAAC,MAAM;AACvB,UAAM,IAAI;AAAA,MACR,UAAU,IAAI;AAAA,IAEhB;AAAA,EACF;AACA,SAAO;AAAA,IACL;AAAA,IACA,SAAS,WAAW,SAAS,OAAO,IAAI;AAAA,IACxC,OAAO,SAAS,SAAS;AAAA,IACzB,SAAS,SAAS,WAAW;AAAA,IAC7B,iBAAiB,SAAS,mBAAmB;AAAA,IAC7C;AAAA,IACA;AAAA,EACF;AACF;AAQO,SAAS,4BACd,UAIkB;AAClB,QAAM,MAAwB,CAAC;AAC/B,aAAW,CAAC,MAAM,IAAI,KAAK,OAAO,QAAQ,QAAQ,GAAG;AACnD,QAAI,CAAC,MAAM,SAAU;AACrB,QAAI,KAAK,sBAAsB,MAAM,KAAK,UAAU,KAAK,WAAW,KAAK,IAAI,CAAC;AAAA,EAChF;AACA,SAAO;AACT;AAWO,IAAM,iBAAN,MAAM,gBAAe;AAAA,EAO1B,YACmB,KACA,WACjB,OAA8B,CAAC,GAC/B;AAHiB;AACA;AAGjB,SAAK,MAAM,KAAK,OAAO,KAAK;AAC5B,SAAK,WAAW,KAAK,IAAI;AACzB,UAAM,WAAW,UAAU,SACvB,KAAK,IAAI,GAAG,UAAU,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,IAC3C;AACJ,SAAK,iBAAiB,KAAK,kBAAkB,KAAK,IAAI,UAAU,iBAAiB;AACjF,eAAW,KAAK,WAAW;AACzB,UAAI,EAAE,UAAU,mBAAmB;AACjC,aAAK,OAAO;AAAA,UACV,iBAAiB,EAAE,IAAI,cAAc,EAAE,OAAO,uBACzC,iBAAiB;AAAA,QAExB;AAAA,MACF;AAAA,IACF;AACA,QAAI,OAAO,IAAI,8BAA8B,YAAY;AAGvD,WAAK,OAAO;AAAA,QACV,8EACsB,UAAU,MAAM;AAAA,MACxC;AAAA,IACF;AAAA,EACF;AAAA,EA3BmB;AAAA,EACA;AAAA,EARF,SAAS,IAAI,OAAO,gBAAe,IAAI;AAAA,EACvC;AAAA,EACT,QAA+C;AAAA,EACtC;AAAA,EACA;AAAA;AAAA,EAiCjB,MAAM,QAAuB;AAC3B,QAAI,KAAK,UAAU,WAAW,EAAG;AACjC,QAAI,OAAO,KAAK,IAAI,8BAA8B,WAAY;AAC9D,UAAM,KAAK,gBAAgB;AAC3B,QAAI,KAAK,MAAO;AAChB,SAAK,QAAQ,YAAY,MAAM;AAC7B,WAAK,KAAK,gBAAgB;AAAA,IAC5B,GAAG,KAAK,cAAc;AACtB,IAAC,KAAK,MAAiC,QAAQ;AAC/C,SAAK,OAAO;AAAA,MACV,2BAA2B,KAAK,UAAU,MAAM,6BACtC,KAAK,cAAc;AAAA,IAC/B;AAAA,EACF;AAAA;AAAA,EAGA,OAAa;AACX,QAAI,KAAK,OAAO;AACd,oBAAc,KAAK,KAAK;AACxB,WAAK,QAAQ;AAAA,IACf;AAAA,EACF;AAAA;AAAA,EAGA,MAAM,kBAAiC;AACrC,UAAM,QAAQ,KAAK,IAAI;AACvB,eAAW,KAAK,KAAK,WAAW;AAC9B,UAAI;AACF,YAAI,EAAE,SAAS;AACb,gBAAM,KAAK,SAAS,GAAG,KAAK;AAAA,QAC9B,OAAO;AACL,gBAAM,KAAK,eAAe,GAAG,aAAa,OAAO,EAAE,SAAS,EAAE,OAAO,KAAK,QAAQ,CAAC;AAAA,QACrF;AAAA,MACF,SAAS,KAAK;AACZ,aAAK,OAAO;AAAA,UACV,yBAAyB,EAAE,IAAI,aAAc,IAAc,OAAO;AAAA,QACpE;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA,EAIA,MAAM,kBAAiC;AACrC,UAAM,QAAQ,KAAK,IAAI;AACvB,eAAW,KAAK,KAAK,WAAW;AAC9B,UAAI;AACF,cAAM,UAAU,aAAa,OAAO,EAAE,SAAS,EAAE,OAAO,KAAK,QAAQ;AACrE,cAAM,KAAK,eAAe,GAAG,OAAO;AACpC,cAAM,KAAK,eAAe,GAAG,UAAU,EAAE,OAAO;AAAA,MAClD,SAAS,KAAK;AACZ,aAAK,OAAO;AAAA,UACV,yBAAyB,EAAE,IAAI,aAAc,IAAc,OAAO;AAAA,QACpE;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAc,eAAe,GAAmB,aAAoC;AAIlF,UAAM,cAAc,KAAK,IAAI;AAC7B,QAAI,CAAC,YAAa;AAClB,UAAM,UAAU,WAAW,EAAE,MAAM,WAAW;AAC9C,UAAM,EAAE,QAAQ,IAAI,MAAM,YAAY,KAAK,KAAK,KAAK;AAAA,MACnD,MAAM,EAAE;AAAA,MACR;AAAA,MACA,WAAW,IAAI,KAAK,WAAW;AAAA,MAC/B,WAAW,EAAE;AAAA,MACb,MAAM,EAAE;AAAA,IACV,CAAC;AACD,QAAI,SAAS;AACX,WAAK,OAAO;AAAA,QACV,iBAAiB,EAAE,IAAI,UAAU,IAAI,KAAK,WAAW,EAAE,YAAY,CAAC;AAAA,MACtE;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA,EAIA,MAAc,SAAS,GAAmB,OAA8B;AACtE,UAAM,UAAU,aAAa,OAAO,EAAE,SAAS,EAAE,OAAO,KAAK,QAAQ;AACrE,UAAM,SAAU,MAAM,KAAK,IAAI,sBAAsB,EAAE,IAAI,KAAM;AACjE,QAAI,OAAO,WAAW,OAAO,SAAS,EAAE,UAAU;AAClD,QAAI,OAAO,QAAS,QAAO;AAC3B,UAAM,QAAQ,KAAK,OAAO,UAAU,QAAQ,EAAE,OAAO,IAAI;AACzD,QAAI,QAAQ,EAAE,iBAAiB;AAC7B,YAAM,UAAU,QAAQ,EAAE;AAC1B,aAAO,WAAW,EAAE,kBAAkB,KAAK,EAAE;AAC7C,WAAK,OAAO;AAAA,QACV,gBAAgB,EAAE,IAAI,oBAAoB,KAAK,sBAC1C,EAAE,eAAe,cAAc,OAAO;AAAA,MAC7C;AAAA,IACF;AACA,aAAS,OAAO,MAAM,QAAQ,SAAS,QAAQ,EAAE,SAAS;AACxD,YAAM,KAAK,eAAe,GAAG,IAAI;AAAA,IACnC;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-OFRRBC7M.js → chunk-E2BRT5IB.js}

@@ -6,6 +6,7 @@ import {
   pgTable,
   text,
   timestamp,
+  uniqueIndex,
   uuid
 } from "drizzle-orm/pg-core";
 import { sql } from "drizzle-orm";
@@ -57,6 +58,19 @@ var domainEvents = pgTable(
     idxDomainEventsTierStatusOccurredAt: index(
       "idx_domain_events_tier_status_occurred_at"
     ).on(t.tier, t.status, t.occurredAt),
+    /**
+     * Scheduling idempotency — partial UNIQUE expression index (ADR-039). The
+     * `EventScheduler` materialises one tick per (event type, slot) by inserting
+     * with `metadata.scheduleSlot = @schedule/<type>/<slotStartMs>` and
+     * `ON CONFLICT DO NOTHING`; this constraint is what makes
+     * "exactly one event per slot" true across multi-instance deploys and
+     * boot/tick races — no advisory lock, no leader election. Partial on the
+     * extracted slot key so it only covers scheduler-materialised rows; ordinary
+     * (use-case / webhook) events carry no `scheduleSlot` and are untouched.
+     */
+    idxDomainEventsScheduleSlot: uniqueIndex(
+      "idx_domain_events_schedule_slot"
+    ).on(t.type, sql`(${t.metadata} ->> 'scheduleSlot')`).where(sql`${t.metadata} ->> 'scheduleSlot' IS NOT NULL`),
     /**
      * Tier ↔ routing-fields invariant (AUDIT-1):
      *   - `tier` is one of `'domain' | 'audit'`.
@@ -75,4 +89,4 @@ var domainEvents = pgTable(
 export {
   domainEvents
 };
-//# sourceMappingURL=chunk-OFRRBC7M.js.map
+//# sourceMappingURL=chunk-E2BRT5IB.js.map

package/dist/chunk-E2BRT5IB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/events/domain-events.schema.ts"],"sourcesContent":["/**\n * Drizzle schema for the domain_events outbox table.\n *\n * This table backs the DrizzleEventBus. Events are inserted within the\n * same database transaction as the domain write (outbox pattern). A\n * polling process reads unprocessed rows and dispatches to subscribers.\n *\n * First-class routing columns (EVT-1):\n *   - `pool`       — populated by DrizzleEventBus.publish() (EVT-4); enables\n *                    pool-filtered drain queries without unpacking metadata JSON.\n *                    NULL when `tier='audit'` (audit events are not routed).\n *   - `direction`  — `inbound` | `change` | `outbound`; mirrors the routing\n *                    dimension used by jobs' reserved `events_inbound` /\n *                    `events_change` / `events_outbound` pools.\n *                    NULL when `tier='audit'`.\n *   - `tenant_id`  — conditional: emitted only when `events.multi_tenant: true`\n *                    in `codegen.config.yaml`. The runtime source declares it\n *                    unconditionally; EVT-8's scaffold template handles the\n *                    config-driven include/exclude.\n *\n * Audit-tier column (AUDIT-1):\n *   - `tier`       — `'domain'` | `'audit'`. Defaults to `'domain'`. Audit-tier\n *                    rows are observability-only (subscribers may observe but\n *                    the bridge MUST NOT spawn jobs from them); they have null\n *                    `pool` and `direction` by construction. The CHECK\n *                    constraint `domain_events_tier_routing_check` enforces\n *                    `tier='audit' ⇔ (pool IS NULL AND direction IS NULL)`.\n *\n * The `metadata` JSON column continues to carry these values for protocol\n * stability; the first-class columns are an optimization for drain filtering.\n *\n * Indexes (declared below in the index callback):\n *   - (status, occurred_at)             — polling drain filter\n *   - (aggregate_id, aggregate_type)    — event replay per aggregate\n *   - (pool, status, occurred_at)       — per-pool drain filter (EVT-1)\n *   - (tier, status, occurred_at)       — per-tier filter for the observability\n *                                          viewer's tier toggle (AUDIT-1).\n */\nimport {\n  check,\n  index,\n  jsonb,\n  pgTable,\n  text,\n  timestamp,\n  uniqueIndex,\n  uuid,\n} from 'drizzle-orm/pg-core';\nimport { sql } from 'drizzle-orm';\nimport type { InferSelectModel } from 'drizzle-orm';\n\nexport const domainEvents = pgTable(\n  'domain_events',\n  {\n    id: uuid('id').primaryKey(),\n    type: text('type').notNull(),\n    aggregateId: text('aggregate_id').notNull(),\n    aggregateType: text('aggregate_type').notNull(),\n    payload: jsonb('payload').notNull().$type<Record<string, unknown>>(),\n    occurredAt: timestamp('occurred_at', { withTimezone: true }).notNull(),\n    processedAt: timestamp('processed_at', { withTimezone: true }),\n    /** Lifecycle status: pending | processed | failed */\n    status: text('status').notNull().default('pending'),\n    /** Error message from the last failed dispatch attempt. */\n    error: text('error'),\n    metadata: jsonb('metadata').$type<Record<string, unknown>>(),\n    /** Routing pool (e.g. `events_inbound`, `events_change`, `events_outbound`). Populated by DrizzleEventBus.publish() in EVT-4. NULL when `tier='audit'`. */\n    pool: text('pool'),\n    /** Routing direction: `inbound` | `change` | `outbound`. Populated by DrizzleEventBus.publish() in EVT-4. NULL when `tier='audit'`. */\n    direction: text('direction'),\n    /**\n     * Event tier: `'domain'` (default) or `'audit'`. Audit-tier rows are\n     * observability-only and have null `pool`/`direction` by construction —\n     * enforced by the `domain_events_tier_routing_check` CHECK constraint\n     * declared below. (AUDIT-1)\n     */\n    tier: text('tier').notNull().default('domain'),\n    // conditional: emitted only when events.multi_tenant: true\n    tenantId: text('tenant_id'),\n  },\n  (t) => ({\n    /** Polling drain filter (existing — promoted from comment to declaration in EVT-1). */\n    idxDomainEventsStatusOccurredAt: index('idx_domain_events_status_occurred_at').on(\n      t.status,\n      t.occurredAt,\n    ),\n    /** Event replay per aggregate (existing — promoted from comment to declaration in EVT-1). */\n    idxDomainEventsAggregate: index('idx_domain_events_aggregate').on(\n      t.aggregateId,\n      t.aggregateType,\n    ),\n    /** Per-pool drain filter (EVT-1). Enables DrizzleEventBus to drain a single pool without scanning all events. */\n    idxDomainEventsPoolStatusOccurredAt: index(\n      'idx_domain_events_pool_status_occurred_at',\n    ).on(t.pool, t.status, t.occurredAt),\n    /** Per-tier filter (AUDIT-1). Backs the observability viewer's tier toggle. */\n    idxDomainEventsTierStatusOccurredAt: index(\n      'idx_domain_events_tier_status_occurred_at',\n    ).on(t.tier, t.status, t.occurredAt),\n    /**\n     * Scheduling idempotency — partial UNIQUE expression index (ADR-039). The\n     * `EventScheduler` materialises one tick per (event type, slot) by inserting\n     * with `metadata.scheduleSlot = @schedule/<type>/<slotStartMs>` and\n     * `ON CONFLICT DO NOTHING`; this constraint is what makes\n     * \"exactly one event per slot\" true across multi-instance deploys and\n     * boot/tick races — no advisory lock, no leader election. Partial on the\n     * extracted slot key so it only covers scheduler-materialised rows; ordinary\n     * (use-case / webhook) events carry no `scheduleSlot` and are untouched.\n     */\n    idxDomainEventsScheduleSlot: uniqueIndex(\n      'idx_domain_events_schedule_slot',\n    )\n      .on(t.type, sql`(${t.metadata} ->> 'scheduleSlot')`)\n      .where(sql`${t.metadata} ->> 'scheduleSlot' IS NOT NULL`),\n    /**\n     * Tier ↔ routing-fields invariant (AUDIT-1):\n     *   - `tier` is one of `'domain' | 'audit'`.\n     *   - `tier='audit'` ⇔ `pool IS NULL AND direction IS NULL`.\n     *   - `tier='domain'` ⇒ `pool` and `direction` are populated (the\n     *     DrizzleEventBus inserts always supply them; the bus stamps them\n     *     in AUDIT-3).\n     */\n    tierRoutingCheck: check(\n      'domain_events_tier_routing_check',\n      sql`${t.tier} in ('domain','audit') AND ((${t.tier} = 'audit') = (${t.pool} is null and ${t.direction} is null))`,\n    ),\n  }),\n);\n\nexport type DomainEventRecord = InferSelectModel<typeof domainEvents>;\n"],"mappings":";AAsCA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,WAAW;AAGb,IAAM,eAAe;AAAA,EAC1B;AAAA,EACA;AAAA,IACE,IAAI,KAAK,IAAI,EAAE,WAAW;AAAA,IAC1B,MAAM,KAAK,MAAM,EAAE,QAAQ;AAAA,IAC3B,aAAa,KAAK,cAAc,EAAE,QAAQ;AAAA,IAC1C,eAAe,KAAK,gBAAgB,EAAE,QAAQ;AAAA,IAC9C,SAAS,MAAM,SAAS,EAAE,QAAQ,EAAE,MAA+B;AAAA,IACnE,YAAY,UAAU,eAAe,EAAE,cAAc,KAAK,CAAC,EAAE,QAAQ;AAAA,IACrE,aAAa,UAAU,gBAAgB,EAAE,cAAc,KAAK,CAAC;AAAA;AAAA,IAE7D,QAAQ,KAAK,QAAQ,EAAE,QAAQ,EAAE,QAAQ,SAAS;AAAA;AAAA,IAElD,OAAO,KAAK,OAAO;AAAA,IACnB,UAAU,MAAM,UAAU,EAAE,MAA+B;AAAA;AAAA,IAE3D,MAAM,KAAK,MAAM;AAAA;AAAA,IAEjB,WAAW,KAAK,WAAW;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAO3B,MAAM,KAAK,MAAM,EAAE,QAAQ,EAAE,QAAQ,QAAQ;AAAA;AAAA,IAE7C,UAAU,KAAK,WAAW;AAAA,EAC5B;AAAA,EACA,CAAC,OAAO;AAAA;AAAA,IAEN,iCAAiC,MAAM,sCAAsC,EAAE;AAAA,MAC7E,EAAE;AAAA,MACF,EAAE;AAAA,IACJ;AAAA;AAAA,IAEA,0BAA0B,MAAM,6BAA6B,EAAE;AAAA,MAC7D,EAAE;AAAA,MACF,EAAE;AAAA,IACJ;AAAA;AAAA,IAEA,qCAAqC;AAAA,MACnC;AAAA,IACF,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU;AAAA;AAAA,IAEnC,qCAAqC;AAAA,MACnC;AAAA,IACF,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAWnC,6BAA6B;AAAA,MAC3B;AAAA,IACF,EACG,GAAG,EAAE,MAAM,OAAO,EAAE,QAAQ,sBAAsB,EAClD,MAAM,MAAM,EAAE,QAAQ,iCAAiC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAS1D,kBAAkB;AAAA,MAChB;AAAA,MACA,MAAM,EAAE,IAAI,gCAAgC,EAAE,IAAI,kBAAkB,EAAE,IAAI,gBAAgB,EAAE,SAAS;AAAA,IACvG;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-XKWOJZZ4.js → chunk-E45CSC33.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-AQFQ4BYM.js";
 import {
   ObservabilityService
-} from "./chunk-CLWBNXKF.js";
+} from "./chunk-W2UIDI3R.js";
 import {
   OBSERVABILITY,
   OBSERVABILITY_MODULE_OPTIONS
@@ -45,4 +45,4 @@ ObservabilityModule = __decorateClass([
 export {
   ObservabilityModule
 };
-//# sourceMappingURL=chunk-XKWOJZZ4.js.map
+//# sourceMappingURL=chunk-E45CSC33.js.map

package/dist/{chunk-VQOAATIG.js → chunk-FLYF76CU.js}

@@ -4,6 +4,9 @@ import {
 import {
   MemoryJobStore
 } from "./chunk-SNQ3TOWP.js";
+import {
+  JOBS_MULTI_TENANT
+} from "./chunk-ZPL74UQN.js";
 import {
   JobCollisionError,
   JobNotReplayableError,
@@ -16,9 +19,6 @@ import {
   JobKeyFunctionUnavailableError,
   keySelectorToTemplate
 } from "./chunk-7P5ODGLA.js";
-import {
-  JOBS_MULTI_TENANT
-} from "./chunk-ZPL74UQN.js";
 import {
   __decorateClass,
   __decorateParam
@@ -663,4 +663,4 @@ function serialiseError(err, attempt, retryable) {
 export {
   MemoryJobOrchestrator
 };
-//# sourceMappingURL=chunk-VQOAATIG.js.map
+//# sourceMappingURL=chunk-FLYF76CU.js.map

package/dist/{chunk-43SBT72G.js → chunk-I6UXRJ3Q.js}

@@ -1,9 +1,9 @@
-import {
-  PollChangeSource
-} from "./chunk-4MF3HKJA.js";
 import {
   WebhookChangeSource
 } from "./chunk-TIZXQU26.js";
+import {
+  PollChangeSource
+} from "./chunk-4MF3HKJA.js";
 
 // runtime/subsystems/integration/build-change-source.ts
 function buildChangeSource(cfg, fetch, middlewares = []) {
@@ -26,4 +26,4 @@ function buildChangeSource(cfg, fetch, middlewares = []) {
 export {
   buildChangeSource
 };
-//# sourceMappingURL=chunk-43SBT72G.js.map
+//# sourceMappingURL=chunk-I6UXRJ3Q.js.map

package/dist/{chunk-GM3RMJIJ.js → chunk-INO47JXD.js}

@@ -1,12 +1,12 @@
 import {
   getEventMetadata
-} from "./chunk-BGULBWKJ.js";
+} from "./chunk-JOBQ6RUU.js";
 import {
   eventPayloadSchemas
 } from "./chunk-JRQO2IOF.js";
 import {
   MissingTenantIdError
-} from "./chunk-V4AF6DI4.js";
+} from "./chunk-DUBZOXJC.js";
 import {
   EVENTS_MULTI_TENANT,
   EVENT_BUS
@@ -89,4 +89,4 @@ TypedEventBus = __decorateClass([
 export {
   TypedEventBus
 };
-//# sourceMappingURL=chunk-GM3RMJIJ.js.map
+//# sourceMappingURL=chunk-INO47JXD.js.map

package/dist/{chunk-BGULBWKJ.js → chunk-JOBQ6RUU.js}

@@ -85,4 +85,4 @@ export {
   eventRegistry,
   getEventMetadata
 };
-//# sourceMappingURL=chunk-BGULBWKJ.js.map
+//# sourceMappingURL=chunk-JOBQ6RUU.js.map

package/dist/chunk-JOBQ6RUU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/events/generated/registry.ts"],"sourcesContent":["// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.\n// Run `codegen entity new --all` to refresh.\n\n\nimport type { EventTypeName } from './types';\n\nexport interface EventMetadata {\n\ttype: EventTypeName;\n\ttier: 'domain' | 'audit';\n\tdirection: 'inbound' | 'change' | 'outbound' | null;\n\tpool: 'events_inbound' | 'events_change' | 'events_outbound' | null;\n\taggregate?: string;\n\tsource?: string;\n\tdestination?: string;\n\tversion: number;\n\tretry: { attempts: number; backoff: 'linear' | 'exponential' };\n\tschedule?: { every: string | number; align: boolean; catchUp: boolean; maxCatchUpSlots: number };\n}\n\nexport const eventRegistry = {\n\t'contact_created': {\n\t\ttype: 'contact_created',\n\t\ttier: 'domain',\n\t\tdirection: 'change',\n\t\tpool: 'events_change',\n\t\taggregate: 'contact',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'contact_marked_champion': {\n\t\ttype: 'contact_marked_champion',\n\t\ttier: 'domain',\n\t\tdirection: 'change',\n\t\tpool: 'events_change',\n\t\taggregate: 'contact',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'contact_merged': {\n\t\ttype: 'contact_merged',\n\t\ttier: 'domain',\n\t\tdirection: 'change',\n\t\tpool: 'events_change',\n\t\taggregate: 'contact',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'crm_sync_started': {\n\t\ttype: 'crm_sync_started',\n\t\ttier: 'audit',\n\t\tdirection: null,\n\t\tpool: null,\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'deal_created': {\n\t\ttype: 'deal_created',\n\t\ttier: 'domain',\n\t\tdirection: 'change',\n\t\tpool: 'events_change',\n\t\taggregate: 'deal',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'deal_stage_changed': {\n\t\ttype: 'deal_stage_changed',\n\t\ttier: 'domain',\n\t\tdirection: 'change',\n\t\tpool: 'events_change',\n\t\taggregate: 'deal',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n\t'stripe_payment_received': {\n\t\ttype: 'stripe_payment_received',\n\t\ttier: 'domain',\n\t\tdirection: 'inbound',\n\t\tpool: 'events_inbound',\n\t\tsource: 'stripe',\n\t\tversion: 1,\n\t\tretry: { attempts: 5, backoff: 'exponential' },\n\t},\n\t'webhook_outbound_contact_sync': {\n\t\ttype: 'webhook_outbound_contact_sync',\n\t\ttier: 'domain',\n\t\tdirection: 'outbound',\n\t\tpool: 'events_outbound',\n\t\taggregate: 'contact',\n\t\tdestination: 'crm',\n\t\tversion: 1,\n\t\tretry: { attempts: 3, backoff: 'exponential' },\n\t},\n} as const satisfies Record<EventTypeName, EventMetadata>;\n\nexport function getEventMetadata<T extends EventTypeName>(type: T): EventMetadata {\n\tconst meta = eventRegistry[type];\n\tif (!meta) {\n\t\tthrow new Error(`No registry entry for event type '${String(type)}' — declare events under events/*.yaml and re-run \\`codegen entity new --all\\`.`);\n\t}\n\treturn meta;\n}\n"],"mappings":";AAmBO,IAAM,gBAAgB;AAAA,EAC5B,mBAAmB;AAAA,IAClB,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,2BAA2B;AAAA,IAC1B,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,kBAAkB;AAAA,IACjB,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,oBAAoB;AAAA,IACnB,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,gBAAgB;AAAA,IACf,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,sBAAsB;AAAA,IACrB,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,2BAA2B;AAAA,IAC1B,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,QAAQ;AAAA,IACR,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AAAA,EACA,iCAAiC;AAAA,IAChC,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,MAAM;AAAA,IACN,WAAW;AAAA,IACX,aAAa;AAAA,IACb,SAAS;AAAA,IACT,OAAO,EAAE,UAAU,GAAG,SAAS,cAAc;AAAA,EAC9C;AACD;AAEO,SAAS,iBAA0C,MAAwB;AACjF,QAAM,OAAO,cAAc,IAAI;AAC/B,MAAI,CAAC,MAAM;AACV,UAAM,IAAI,MAAM,qCAAqC,OAAO,IAAI,CAAC,sFAAiF;AAAA,EACnJ;AACA,SAAO;AACR;","names":[]}

package/dist/{chunk-VDL5CJ5C.js → chunk-KBO5OOON.js}

@@ -1,18 +1,18 @@
 import {
-  JOBS_WAKE_CHANNEL,
-  PgNotifyListener
-} from "./chunk-Q6LRJ4VI.js";
-import {
-  JOB_HANDLER_REGISTRY
-} from "./chunk-7P5ODGLA.js";
+  jobRuns
+} from "./chunk-OKXZ63IA.js";
 import {
   JOB_ORCHESTRATOR,
   JOB_RUN_SERVICE,
   JOB_STEP_SERVICE
 } from "./chunk-ZPL74UQN.js";
 import {
-  jobRuns
-} from "./chunk-OKXZ63IA.js";
+  JOB_HANDLER_REGISTRY
+} from "./chunk-7P5ODGLA.js";
+import {
+  JOBS_WAKE_CHANNEL,
+  PgNotifyListener
+} from "./chunk-Q6LRJ4VI.js";
 import {
   tokenKey
 } from "./chunk-GYGNEQSC.js";
@@ -528,4 +528,4 @@ export {
   buildStaleSweepQuery,
   JobWorker
 };
-//# sourceMappingURL=chunk-VDL5CJ5C.js.map
+//# sourceMappingURL=chunk-KBO5OOON.js.map

package/dist/{chunk-OZEPJGMA.js → chunk-KHQ72A5F.js}

@@ -1,12 +1,16 @@
 import {
   TypedEventBus
-} from "./chunk-GM3RMJIJ.js";
+} from "./chunk-INO47JXD.js";
+import {
+  EventScheduler,
+  scheduledEventsFromRegistry
+} from "./chunk-DUUCU77W.js";
 import {
   DrizzleEventBus
-} from "./chunk-B34G6PHD.js";
+} from "./chunk-LARB26EI.js";
 import {
   MemoryEventBus
-} from "./chunk-Z7PQCAVK.js";
+} from "./chunk-4OC5MSHO.js";
 import {
   EVENTS_MODULE_OPTIONS,
   EVENTS_MULTI_TENANT,
@@ -19,16 +23,55 @@ import {
   DRIZZLE
 } from "./chunk-U64T4YZE.js";
 import {
-  __decorateClass
+  __decorateClass,
+  __decorateParam
 } from "./chunk-2E224ZSN.js";
 
 // runtime/subsystems/events/events.module.ts
-import { Module } from "@nestjs/common";
+import {
+  Inject,
+  Injectable,
+  Logger,
+  Module,
+  Optional
+} from "@nestjs/common";
 async function loadRedisEventBus() {
   const specifier = "./event-bus.redis-backend";
   const mod = await import(specifier);
   return mod.RedisEventBus;
 }
+var EventSchedulerLifecycle = class {
+  constructor(bus, opts = null) {
+    this.bus = bus;
+    this.opts = opts;
+  }
+  bus;
+  opts;
+  logger = new Logger(EventSchedulerLifecycle.name);
+  scheduler = null;
+  async onModuleInit() {
+    const registry = this.opts?.eventRegistry;
+    if (!registry) return;
+    if (typeof this.bus.materializeScheduledEvent !== "function") return;
+    const schedules = scheduledEventsFromRegistry(registry);
+    if (schedules.length === 0) return;
+    this.scheduler = new EventScheduler(this.bus, schedules);
+    await this.scheduler.start();
+    this.logger.log(`EventScheduler wired for ${schedules.length} scheduled event(s).`);
+  }
+  async onModuleDestroy() {
+    if (this.scheduler) {
+      this.scheduler.stop();
+      this.scheduler = null;
+    }
+  }
+};
+EventSchedulerLifecycle = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(EVENT_BUS)),
+  __decorateParam(1, Optional()),
+  __decorateParam(1, Inject(EVENTS_MODULE_OPTIONS))
+], EventSchedulerLifecycle);
 function buildTypedBusProviders(multiTenant, typedBus) {
   const BusClass = typedBus ?? TypedEventBus;
   return [
@@ -139,6 +182,10 @@ var EventsModule = class {
         // 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 },
+        // ADR-039 — the scheduler lifecycle. No-op unless `eventRegistry` was
+        // threaded AND some event declared `schedule:`. Drizzle/memory only
+        // (the redis branch above never reaches here).
+        EventSchedulerLifecycle,
         ...buildTypedBusProviders(multiTenant, options.typedBus)
       ],
       exports: [EVENT_BUS, EVENT_READ_PORT, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
@@ -150,6 +197,7 @@ EventsModule = __decorateClass([
 ], EventsModule);
 
 export {
+  EventSchedulerLifecycle,
   EventsModule
 };
-//# sourceMappingURL=chunk-OZEPJGMA.js.map
+//# sourceMappingURL=chunk-KHQ72A5F.js.map

package/dist/chunk-KHQ72A5F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/events/events.module.ts"],"sourcesContent":["/**\n * EventsModule — DynamicModule factory for the event bus subsystem.\n *\n * Register once in AppModule:\n * ```typescript\n * @Module({\n *   imports: [\n *     EventsModule.forRoot({ backend: 'drizzle' }),\n *   ],\n * })\n * export class AppModule {}\n * ```\n *\n * Tests swap to the memory backend without touching application code:\n * ```typescript\n * Test.createTestingModule({\n *   imports: [EventsModule.forRoot({ backend: 'memory' })],\n * });\n * ```\n *\n * Per-pool drain isolation (EVT-4):\n * ```typescript\n * EventsModule.forRoot({ backend: 'drizzle', pools: ['events_change'] });\n * ```\n * Each process restricts its drain loop to the pools listed here. `pools`\n * is undefined by default → drain all pending rows (backwards-compatible).\n *\n * Typed facade + multi-tenancy (EVT-6):\n * - `TYPED_EVENT_BUS` resolves to the generated `TypedEventBus` wrapping\n *   whichever backend is selected.\n * - `multiTenant: true` makes `TypedEventBus.publish` throw\n *   `MissingTenantIdError` when the caller forgets `metadata.tenantId`.\n *\n * `global: true` means entity modules do not need to import EventsModule\n * individually — the EVENT_BUS and TYPED_EVENT_BUS tokens are available\n * project-wide.\n *\n * Async configuration (`forRootAsync`):\n * The async factory returns `EventsModuleOptions`; the EVENT_BUS provider\n * then receives its backend dependencies — DRIZZLE for the drizzle\n * backend, REDIS_URL for the redis backend, the resolved options for the\n * memory backend — through a proper `useFactory` so Nest DI wires them\n * correctly. Earlier revisions hand-constructed backends with\n * `new Class()` which silently left `db` / `redisUrl` undefined\n * (issue #108).\n */\nimport {\n  Inject,\n  Injectable,\n  Logger,\n  Module,\n  Optional,\n  type DynamicModule,\n  type OnModuleDestroy,\n  type OnModuleInit,\n  type Provider,\n  type Type,\n} from '@nestjs/common';\nimport {\n  EVENT_BUS,\n  EVENT_READ_PORT,\n  EVENTS_MODULE_OPTIONS,\n  EVENTS_MULTI_TENANT,\n  REDIS_URL,\n  TYPED_EVENT_BUS,\n} from './events.tokens';\nimport { DRIZZLE } from '../../constants/tokens';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport { DrizzleEventBus } from './event-bus.drizzle-backend';\nimport { MemoryEventBus } from './event-bus.memory-backend';\nimport type { IEventBus } from './event-bus.protocol';\nimport {\n  EventScheduler,\n  scheduledEventsFromRegistry,\n  type RegistrySchedule,\n} from './event-scheduler';\n// #6 — `RedisEventBus` is lazy-loaded only when `backend: 'redis'` is selected.\n// The file is filtered out of the vendor set for non-redis installs (see\n// `backendFileFilter` in src/cli/commands/subsystem.ts); the dynamic-string\n// import below makes TS treat the specifier as `any` so the consumer's tsc\n// never tries to resolve the absent file.\nimport { TypedEventBus } from './generated/bus';\n\n/**\n * Lazy-load the Redis backend. Routed through a non-literal specifier so\n * the consumer's `tsc` doesn't resolve `./event-bus.redis-backend` at type\n * check time — important because that file is filtered out of drizzle/\n * memory installs (#6).\n */\nasync function loadRedisEventBus(): Promise<new (url: string) => object> {\n  // Non-literal specifier — TS gives this an `any` module type, sidestepping\n  // resolution of a file that may not be vendored.\n  const specifier = './event-bus.redis-backend';\n  const mod = (await import(specifier)) as { RedisEventBus: new (url: string) => object };\n  return mod.RedisEventBus;\n}\n\nexport interface EventsModuleOptions {\n  backend: 'drizzle' | 'memory' | 'redis';\n  /**\n   * Redis connection URL used when `backend` is `'redis'`.\n   * Falls back to the REDIS_URL environment variable, then\n   * `redis://localhost:6379` if neither is set.\n   */\n  redisUrl?: string;\n  /**\n   * Restrict the drain loop to these pools. Each pool name matches the\n   * `domain_events.pool` column (populated from `event.metadata.pool` at\n   * publish time). Leave undefined to drain all pending rows.\n   *\n   * Typical lane split: one process per `events_inbound` /\n   * `events_change` / `events_outbound` so a slow outbound handler\n   * cannot stall change-event propagation (see ADR-022).\n   */\n  pools?: string[];\n  /**\n   * LISTEN-NOTIFY-1 — when `true` (drizzle backend only), the drainer holds a\n   * dedicated listener connection and LISTENs on `codegen_events_wake`. Each\n   * `publish`/`publishMany` emits an in-tx `pg_notify(codegen_events_wake,\n   * <pool>)` so the drainer wakes the moment the publishing transaction commits,\n   * instead of waiting for the next poll tick. Polling continues unchanged as\n   * the fallback heartbeat; a lost notify degrades to poll latency, never to\n   * lost work. Defaults to `false`.\n   *\n   * Ignored by the memory + redis backends (memory dispatches inline; redis has\n   * its own fan-out). Requires a direct (non-transaction-pooler) connection —\n   * see the events/jobs config block re: PgBouncer.\n   */\n  listenNotify?: boolean;\n  /**\n   * Multi-tenancy opt-in (EVT-6).\n   *\n   * When `true`, every `TypedEventBus.publish()` call must supply\n   * `opts.metadata.tenantId` — otherwise it throws `MissingTenantIdError`.\n   * The tenantId is preserved on `event.metadata` and, for the Drizzle\n   * backend, written to `domain_events.tenant_id` (EVT-4).\n   *\n   * Drain-side tenant filtering is deferred — the tenant-context model\n   * (per-process vs. per-request vs. async-local-storage) is still\n   * unsettled; see ADR-024 §Multi-tenancy. Only the publish-side\n   * requirement ships here.\n   *\n   * Defaults to `false`.\n   */\n  multiTenant?: boolean;\n  /**\n   * The generated `TypedEventBus` class to bind to `TYPED_EVENT_BUS`.\n   *\n   * **Package mode (ADR-037).** When the runtime is imported from\n   * `@pattern-stack/codegen` (not vendored), the bundled `./generated/bus`\n   * `TypedEventBus` is typed to an EMPTY event union and reads the bundled\n   * empty `eventRegistry` — a consumer's `events/*.yaml` are scanned into\n   * `src/generated/events/bus.ts` (typed to THEIR union, reading THEIR\n   * registry), which the package can't import. The generated subsystem barrel\n   * therefore threads that class in here:\n   * `EventsModule.forRoot({ ..., typedBus: TypedEventBus })`. Nest constructs\n   * it with this module's `EVENT_BUS` + `EVENTS_MULTI_TENANT` providers (the\n   * generated class injects the same string-valued tokens, which match across\n   * the package boundary).\n   *\n   * Omitted (vendored mode / tests) ⇒ falls back to the bundled\n   * `./generated/bus`, which in a vendored tree IS the consumer's generated\n   * file. Without this, a package-mode consumer's typed `publish<'…'>()` calls\n   * resolve against the empty union and their events never get the right\n   * `pool` / `direction` stamped.\n   *\n   * Only consulted by `forRoot` (the path the barrel emits); `forRootAsync`\n   * keeps the bundled bus.\n   */\n  typedBus?: Type<unknown>;\n  /**\n   * ADR-039 — the consumer's generated `eventRegistry`, threaded so the\n   * `EventScheduler` can read the `schedule:` block + routing metadata of every\n   * scheduled event. Package mode: the generated subsystem barrel passes the\n   * consumer's `eventRegistry` (the bundled one is the package's empty/fixture\n   * registry, which the package can't see the consumer's events through — same\n   * reason `typedBus` is threaded). Omitted ⇒ no scheduler is spawned (vendored\n   * tree reads its own bundled registry only if the barrel passes it; tests\n   * pass a registry directly).\n   *\n   * Structural shape: each value needs `schedule?` + `direction` + `pool`. The\n   * generated `EventMetadata` satisfies it; typing it loosely here avoids a\n   * runtime dependency on the generated types from the module file.\n   */\n  eventRegistry?: Record<\n    string,\n    { schedule?: RegistrySchedule; direction: string | null; pool: string | null }\n  >;\n}\n\n/**\n * Lifecycle holder for the `EventScheduler` (ADR-039). Registered as a provider\n * on the drizzle/memory `forRoot` branches; Nest drives `onModuleInit` (after\n * the bus is constructed) and `onModuleDestroy`. Reads the scheduled-event set\n * from the threaded `eventRegistry` and starts the materialiser. No-op when\n * nothing declared `schedule:`, or under the redis backend (no outbox history).\n */\n@Injectable()\nexport class EventSchedulerLifecycle implements OnModuleInit, OnModuleDestroy {\n  private readonly logger = new Logger(EventSchedulerLifecycle.name);\n  private scheduler: EventScheduler | null = null;\n\n  constructor(\n    @Inject(EVENT_BUS) private readonly bus: IEventBus,\n    @Optional()\n    @Inject(EVENTS_MODULE_OPTIONS)\n    private readonly opts: EventsModuleOptions | null = null,\n  ) {}\n\n  async onModuleInit(): Promise<void> {\n    const registry = this.opts?.eventRegistry;\n    if (!registry) return;\n    if (typeof this.bus.materializeScheduledEvent !== 'function') return; // redis\n    const schedules = scheduledEventsFromRegistry(registry);\n    if (schedules.length === 0) return;\n    this.scheduler = new EventScheduler(this.bus, schedules);\n    await this.scheduler.start();\n    this.logger.log(`EventScheduler wired for ${schedules.length} scheduled event(s).`);\n  }\n\n  async onModuleDestroy(): Promise<void> {\n    if (this.scheduler) {\n      this.scheduler.stop();\n      this.scheduler = null;\n    }\n  }\n}\n\nexport interface EventsModuleAsyncOptions {\n  useFactory: (...args: unknown[]) => Promise<EventsModuleOptions> | EventsModuleOptions;\n  inject?: unknown[];\n  imports?: unknown[];\n}\n\n/**\n * Shared provider set: `TypedEventBus` itself, the `TYPED_EVENT_BUS` token\n * binding, and the resolved `EVENTS_MULTI_TENANT` flag. Returned from one\n * place so every `forRoot` branch and `forRootAsync` agree.\n */\nfunction buildTypedBusProviders(\n  multiTenant: boolean,\n  typedBus?: Type<unknown>,\n): Provider[] {\n  // Package mode threads the consumer's generated `TypedEventBus` (typed to\n  // their event union, reading their registry) via `typedBus`; vendored mode\n  // omits it and we fall back to the bundled `./generated/bus` (which IS the\n  // consumer's generated file in a vendored tree). See `EventsModuleOptions.typedBus`.\n  const BusClass = typedBus ?? TypedEventBus;\n  return [\n    BusClass,\n    { provide: TYPED_EVENT_BUS, useExisting: BusClass },\n    { provide: EVENTS_MULTI_TENANT, useValue: multiTenant },\n  ];\n}\n\n/**\n * Construct the backend instance for the async path, routing constructor\n * arguments through Nest-resolved dependencies.\n *\n * DRIZZLE is declared optional at inject time so that memory-backend\n * consumers aren't required to also import `DatabaseModule`. If the\n * drizzle backend is selected but no DRIZZLE provider is registered, we\n * throw a clear error instead of silently constructing a broken bus.\n */\nasync function buildEventBusAsync(\n  options: EventsModuleOptions,\n  db: DrizzleClient | null,\n  redisUrl: string,\n): Promise<unknown> {\n  if (options.backend === 'drizzle') {\n    if (!db) {\n      throw new Error(\n        \"EventsModule.forRootAsync: backend: 'drizzle' selected but DRIZZLE provider is not available. \" +\n          'Ensure DatabaseModule (or another provider exposing DRIZZLE) is imported before EventsModule.forRootAsync.',\n      );\n    }\n    return new DrizzleEventBus(db, options);\n  }\n  if (options.backend === 'redis') {\n    // #6: lazy import — the redis backend ships only with `--backend redis`\n    // installs; drizzle/memory consumers never touch the file.\n    const RedisEventBus = await loadRedisEventBus();\n    return new RedisEventBus(redisUrl);\n  }\n  return new MemoryEventBus(options);\n}\n\n@Module({})\nexport class EventsModule {\n  static forRootAsync(asyncOptions: EventsModuleAsyncOptions): DynamicModule {\n    return {\n      module: EventsModule,\n      global: true,\n      imports: (asyncOptions.imports ?? []) as Parameters<typeof Module>[0]['imports'],\n      providers: [\n        {\n          provide: EVENTS_MODULE_OPTIONS,\n          useFactory: asyncOptions.useFactory,\n          inject: (asyncOptions.inject ?? []) as (string | symbol | Function)[],\n        },\n        {\n          provide: EVENTS_MULTI_TENANT,\n          useFactory: (options: EventsModuleOptions) => options.multiTenant ?? false,\n          inject: [EVENTS_MODULE_OPTIONS],\n        },\n        {\n          provide: REDIS_URL,\n          useFactory: (options: EventsModuleOptions) =>\n            options.redisUrl ?? process.env['REDIS_URL'] ?? 'redis://localhost:6379',\n          inject: [EVENTS_MODULE_OPTIONS],\n        },\n        {\n          provide: EVENT_BUS,\n          useFactory: (\n            options: EventsModuleOptions,\n            db: DrizzleClient | null,\n            redisUrl: string,\n          ) => buildEventBusAsync(options, db, redisUrl),\n          inject: [\n            EVENTS_MODULE_OPTIONS,\n            { token: DRIZZLE, optional: true },\n            REDIS_URL,\n          ],\n        },\n        {\n          // Read port (OBS-LIST-1). Drizzle + memory backends implement\n          // IEventReadPort on the EVENT_BUS instance; the redis backend\n          // retains no history, so EVENT_READ_PORT resolves to `null` and\n          // optional consumers (the observability combiner) degrade to\n          // empty results.\n          provide: EVENT_READ_PORT,\n          useFactory: (options: EventsModuleOptions, bus: unknown) =>\n            options.backend === 'redis' ? null : bus,\n          inject: [EVENTS_MODULE_OPTIONS, EVENT_BUS],\n        },\n        TypedEventBus,\n        { provide: TYPED_EVENT_BUS, useExisting: TypedEventBus },\n      ],\n      exports: [EVENT_BUS, EVENT_READ_PORT, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT],\n    };\n  }\n\n  static forRoot(\n    options: EventsModuleOptions = { backend: 'drizzle' },\n  ): DynamicModule {\n    const multiTenant = options.multiTenant ?? false;\n\n    if (options.backend === 'redis') {\n      const resolvedUrl =\n        options.redisUrl ?? process.env['REDIS_URL'] ?? 'redis://localhost:6379';\n\n      return {\n        module: EventsModule,\n        global: true,\n        providers: [\n          { provide: EVENTS_MODULE_OPTIONS, useValue: options },\n          { provide: REDIS_URL, useValue: resolvedUrl },\n          {\n            // #6: useFactory + dynamic import so the consumer's tsc never\n            // needs to resolve `event-bus.redis-backend.ts` for drizzle/\n            // memory installs (the file is filtered out by\n            // `backendFileFilter`). Nest awaits async factories + manages\n            // lifecycle on the returned instance, so we drop the old bare\n            // `RedisEventBus` provider entry.\n            provide: EVENT_BUS,\n            useFactory: async (url: string): Promise<object> => {\n              const RedisEventBus = await loadRedisEventBus();\n              return new RedisEventBus(url);\n            },\n            inject: [REDIS_URL],\n          },\n          ...buildTypedBusProviders(multiTenant, options.typedBus),\n        ],\n        exports: [EVENT_BUS, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT],\n      };\n    }\n\n    const provider =\n      options.backend === 'drizzle'\n        ? { provide: EVENT_BUS, useClass: DrizzleEventBus }\n        : { provide: EVENT_BUS, useClass: MemoryEventBus };\n\n    return {\n      module: EventsModule,\n      global: true,\n      providers: [\n        { provide: EVENTS_MODULE_OPTIONS, useValue: options },\n        provider,\n        // Read port (OBS-LIST-1): drizzle + memory backends implement\n        // IEventReadPort on the same instance as EVENT_BUS. The redis\n        // backend retains no history and does not provide this token.\n        { provide: EVENT_READ_PORT, useExisting: EVENT_BUS },\n        // ADR-039 — the scheduler lifecycle. No-op unless `eventRegistry` was\n        // threaded AND some event declared `schedule:`. Drizzle/memory only\n        // (the redis branch above never reaches here).\n        EventSchedulerLifecycle,\n        ...buildTypedBusProviders(multiTenant, options.typedBus),\n      ],\n      exports: [EVENT_BUS, EVENT_READ_PORT, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT],\n    };\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-F7KN3U6U.js → chunk-KK5A7B2T.js}

@@ -625,6 +625,22 @@ var RetrySchema = z2.object({
   attempts: z2.number().int().min(0).max(20),
   backoff: z2.enum(EVENT_BACKOFF_STRATEGIES)
 }).strict();
+var DURATION_RE = /^\s*[0-9]*\.?[0-9]+\s*(ms|s|m|h|d)\s*$/;
+var ScheduleSchema = z2.object({
+  every: z2.union([
+    z2.string().regex(
+      DURATION_RE,
+      "schedule.every must be a duration like '1h', '30m', '15s', '500ms', '1d'"
+    ),
+    z2.number().positive().finite()
+  ]),
+  /** Epoch-anchored slot boundaries (default true). */
+  align: z2.boolean().optional().default(true),
+  /** Backfill missed slots on recovery (default false → run once). */
+  catchUp: z2.boolean().optional().default(false),
+  /** Upper bound on `catchUp` backfill (default 1000). */
+  maxCatchUpSlots: z2.number().int().positive().optional().default(1e3)
+}).strict();
 var SNAKE_CASE_RE = /^[a-z][a-z0-9_]*$/;
 var EventDefinitionSchemaCore = z2.object({
   type: z2.string().regex(
@@ -645,6 +661,9 @@ var EventDefinitionSchemaCore = z2.object({
     attempts: 3,
     backoff: "exponential"
   }),
+  // ADR-039 — declarative time-based emission. Optional; when present the
+  // platform emits this event on the given cadence (see ScheduleSchema).
+  schedule: ScheduleSchema.optional(),
   version: z2.number().int().min(1).optional().default(1),
   description: z2.string().optional()
 }).strict();
@@ -665,6 +684,13 @@ var EventDefinitionSchemaRefined = EventDefinitionSchemaCore.superRefine(
           path: ["direction"]
         });
       }
+      if (data.schedule !== void 0) {
+        ctx.addIssue({
+          code: z2.ZodIssueCode.custom,
+          message: `Event '${data.type}' is tier:audit; 'schedule' is not allowed on audit events (they route to no pool and cannot drive the bridge). Make it a domain event with a direction. See ADR-039.`,
+          path: ["schedule"]
+        });
+      }
       return;
     }
     if (data.direction === void 0) {
@@ -4163,4 +4189,4 @@ export {
   analyzeDomain,
   validateEntities
 };
-//# sourceMappingURL=chunk-F7KN3U6U.js.map
+//# sourceMappingURL=chunk-KK5A7B2T.js.map