@pattern-stack/codegen 0.18.0 → 0.20.0

package/CHANGELOG.md

@@ -4,6 +4,94 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.20.0] — 2026-06-06
+
+**Declarative time-based scheduling: time as an event source** (ADR-039;
+swe-brain consumer-test finding — an hourly reconcile poll had to be hand-rolled
+as a self-perpetuating job chain because there was no time-based trigger, and
+its flat dedupe key collapsed the chain into the running parent).
+
+### Added
+
+- **`schedule:` on event YAML** (`definitions/events/<domain>/*.yaml`) —
+  `{ every, align?, catchUp?, maxCatchUpSlots? }`. Declares that the platform
+  emits this event on a cadence. `every` is a duration string (`'1h'`/`'30m'`/
+  `'15s'`/`'500ms'`/`'1d'`) or raw ms. Domain-tier only (audit rejected). Time
+  is a third event **source** (peer to use-case publishes + webhook receivers),
+  not a fourth activation tier — consumers react through ADR-023's existing
+  tiers (`subscribe` or `@JobHandler({ triggers })`); no new activation
+  mechanism. Carried into the generated `eventRegistry` + `EventMetadata`.
+- **`EventScheduler`** (`runtime/subsystems/events/event-scheduler.ts`) — a
+  strict producer that materialises **exactly one `domain_events` row per
+  (type, slot)** on a cadence; the existing outbox drain + bridge activate them.
+  Reconcile-on-boot (materialise the current slot, or bounded `catchUp`
+  backfill) + a tick pass for the next slot. Wired by `EventsModule.forRoot`
+  for the drizzle + memory backends (the Redis bus retains no outbox history, so
+  slot idempotency can't be enforced there). Pure helpers exported:
+  `parseEvery`, `slotStartFor`, `nextSlotStart`, `slotKeyFor`,
+  `scheduledEventsFromRegistry`.
+- **Partial UNIQUE expression index** `idx_domain_events_schedule_slot` on
+  `(type, metadata->>'scheduleSlot')` — the DB-level exactly-once-per-slot
+  invariant (no advisory lock, no leader election; multi-instance + boot/tick
+  races collapse on it). Partial on the slot key so ordinary events are
+  untouched. Additive Atlas migration.
+- **`ScheduleConfigError`** + `IEventBus.materializeScheduledEvent` /
+  `lastScheduledSlotMs` (both backends).
+
+### Misfire policy
+
+- Down across N slots → on recovery, materialise **one** tick for the current
+  slot (don't replay the misses). `catchUp: true` opts into bounded backfill.
+
+### Provenance
+
+- A scheduled tick carries `metadata.triggerSource = 'schedule'` +
+  `metadata.scheduleSlot`. A bridge run from it reads `job_run.trigger_source =
+  'event'`; the clock origin is joinable via `trigger_ref → domain_events.id`.
+  The dormant ADR-022 `triggerSource: 'schedule'` enum is the correct stamp for
+  the **direct-start** path (a Tier-1 subscriber calling `orchestrator.start(…,
+  { triggerSource: 'schedule' })`).
+
+### Retires
+
+- The self-perpetuating job-chain pattern (a handler enqueuing its own
+  successor) and its slot-keyed-dedupe workaround — replaced by a `schedule:`
+  YAML + a `triggers:` entry. Supersedes the dangling "ADR-025 scheduling
+  territory" pointer in `docs/specs/BULLMQ-1.md` (the future BullMQ backend maps
+  `schedule:` onto `upsertJobScheduler`; the YAML contract is identical).
+
+## [0.19.0] — 2026-06-05
+
+**Providers catalog emission + planned providers** (ADR-038 follow-on;
+swe-brain consumer-test finding — the Connections surface hand-duplicated
+provider knowledge that `definitions/providers/*.yaml` already owns).
+
+### Added
+
+- **Frontend providers catalog (`generated/providers.ts`)** — emitted by the
+  frontend whole-set emitter when `definitions/providers/` exists (entity-only
+  consumers see no new file; the root barrel gains the export conditionally).
+  `PROVIDERS` (flat, slug-sorted) + `PROVIDER_CATALOG` (grouped by
+  `display.category` into the ordered `frontend.catalog.categories`). Providers
+  are gen-time knowledge — the catalog is emitted, not queried.
+- **`display:` block on the provider schema** (`category`, `blurb`, `hint`) —
+  presentation metadata consumed only by the catalog emission; backend
+  provider/adapter codegen ignores it.
+- **`status: active | planned` on the provider schema** (default `active`).
+  `planned` providers are roadmap stubs: catalog tile only — `auth`/`client`
+  optional, surface closed-set + import pre-flight cross-checks skipped (slug
+  uniqueness still enforced), and ALL backend emission (provider modules,
+  adapters, assemblies) filters them out. Flip to `active` when the
+  integration lands.
+- **`frontend.catalog.categories`** in `codegen.config.yaml` — ordered display
+  groups (`id`, `name`, `blurb`) the catalog renders.
+
+### Changed
+
+- `generateProviderModule` / `generateAdapterScaffold` now take
+  `ActiveProviderDefinition` (auth/client guaranteed); use the exported
+  `isActiveProvider` guard to narrow.
+
 ## [0.17.2] — 2026-06-04
 
 **Shutdown leak fix** (LISTEN-NOTIFY-2; swe-brain dogfood). With

package/README.md

@@ -163,6 +163,7 @@ generated/
   entities/<entity>.ts     createEntityHooks({ collection, api }) wiring
   store/index.ts           createStore over the full set (+ resolvers, lookups)
   fields/<entity>.ts       field metadata (FieldMeta, <entity>Fields)
+  providers.ts             providers catalog — only when definitions/providers/ exists
 ```
 
 Entity types and Zod schemas are **imported** from `locations.dbEntities`
@@ -236,6 +237,56 @@ the **target entity's own YAML** via the registry — never re-pluralized from a
 string at emit time (so an explicit `plural:` like `person`→`persons` is honored
 by every consumer).
 
+### Providers catalog (`providers.ts`)
+
+Providers are gen-time knowledge (`definitions/providers/<slug>.yaml`,
+RFC-0001) — the provider set changes only when code deploys — so the frontend
+catalog is **emitted, not queried**. When the project has provider definitions,
+the emitter renders `generated/providers.ts`:
+
+- `PROVIDERS` — every provider, flat (active + planned), slug-sorted:
+  `{ provider, name, planned, surfaces, blurb?, hint? }`. Join live rows on
+  `provider` (the canonical slug, e.g. `Connection.provider`).
+- `PROVIDER_CATALOG` — grouped into `frontend.catalog.categories` (config
+  order) via each provider's `display.category`. Uncategorized providers
+  appear only in `PROVIDERS`.
+
+Two provider-YAML additions feed it:
+
+```yaml
+# definitions/providers/google.yaml (active — full definition)
+slug: google
+display_name: Google Workspace
+display:
+  category: google-workspace     # joins frontend.catalog.categories[].id
+  hint: connect                  # optional sub-line on an unconnected tile
+surfaces: [calendar, mail, transcript]
+auth: { ... }                    # required for active providers
+client: { ... }
+
+# definitions/providers/github.yaml (planned — roadmap stub)
+slug: github
+display_name: GitHub
+status: planned                  # catalog tile only; NO backend emission,
+display:                         # no auth/client required, surface + import
+  category: source-control       # cross-checks skipped
+surfaces: [source_control]
+```
+
+```yaml
+# codegen.config.yaml — the ordered display groups
+frontend:
+  catalog:
+    categories:
+      - id: source-control
+        name: Source Control & Issues
+        blurb: Repositories, pull requests, issues, and project planning
+```
+
+When the integration for a `planned` provider lands, flip it to `status:
+active` (or drop the key) and add `auth`/`client` — the definitions tree is
+the integration roadmap.
+
 ## Integration Codegen (provider/adapter + assembly + read primitive)
 
 When an entity carries a `surface:` tag and `definitions/providers/*.yaml` exist,

package/consumer-skills/codegen/SKILL.md

@@ -55,6 +55,38 @@ generation run the two barrels are rewritten and you wire them into
 | React to an event with a durable async job (the event-to-job bridge) | the `bridge` skill |
 | Pull/push data from an external system (`IChangeSource` / `IIntegrationSink`) | the `integration` skill |
 
+## Frontend generation (`generate.frontend: true`)
+
+When on, `entity new` (and `--all`) ends with a **whole-set frontend emitter**
+(ADR-038): the complete data layer is rendered into
+`locations.frontendGenerated` (default `apps/frontend/src/generated/`) from the
+full entity set — REST api client, TanStack DB collections (per-entity
+`sync: api | electric`), `createEntityHooks` wiring, field metadata, a
+plural-keyed `createStore`, `config.ts`, `query-client.ts`, root barrel. Every
+file is a complete write with a `@generated` banner; re-runs are byte-identical.
+
+Non-obvious bits:
+
+- **The dbEntities contract**: generated files import the plain `<Class>` type
+  AND a `<camel>Schema` Zod schema from `locations.dbEntities` per entity. If
+  the backend doesn't emit such a package (clean-lite-ps doesn't), the consumer
+  provides a shim barrel re-exporting each module's Output DTO.
+- **The consumer mounts two providers** in the app root, both from generated
+  code: `QueryClientProvider(queryClient)` ▸ `EntityStoreProvider(store)`
+  (`EntityStoreProvider` from `@pattern-stack/frontend-patterns`).
+- **Version pairing**: the emitted imports require
+  `@pattern-stack/frontend-patterns` + four TanStack packages — the exact
+  ranges are listed in the generated `index.ts` header comment.
+- **Path aliases are assumed**: default imports use `@/…` (and your
+  `locations.*.import` values) — wire tsconfig `paths` + the bundler alias.
+- **Providers catalog**: when `definitions/providers/` exists, the emitter also
+  renders `providers.ts` — `PROVIDERS` (flat) + `PROVIDER_CATALOG` (grouped by
+  each provider's `display.category` into `frontend.catalog.categories`).
+  Providers are gen-time knowledge: the catalog is emitted, never queried, and
+  never hand-duplicated in the frontend. `status: planned` provider YAMLs are
+  roadmap stubs — catalog tile only, no auth/client needed, skipped by all
+  backend emission.
+
 ## CLI quick reference
 
 ```bash

package/consumer-skills/entities/SKILL.md

@@ -48,6 +48,8 @@ module — plus an entry in the `GENERATED_MODULES` and schema barrels.
 entity:
   name: account            # singular snake_case
   pattern: Synced          # Base | Synced | Activity | Metadata | Knowledge (or app-defined)
+  # sync: api              # frontend collection mode (api | electric) — overrides
+  #                        # frontend.sync.mode; only meaningful with generate.frontend: true
 
 fields:
   name:

package/consumer-skills/events/authoring-events.md

@@ -65,6 +65,7 @@ After editing any `events/*.yaml`, re-run codegen (e.g. `codegen entity new --al
 | `payload` | yes | Map of snake_case keys → field specs. Keys become camelCase TS props. |
 | `pool` | no | Override the direction's default pool. Only valid within the same category (a `change` event can't opt into `events_inbound`). User pools are never valid. Rarely needed — if you reach for it, revisit the direction. **Must be omitted for `tier: audit`.** |
 | `retry` | no | `{ attempts, backoff }`; hints surfaced to the bus. |
+| `schedule` | no | `{ every, align?, catchUp?, maxCatchUpSlots? }` — the platform emits this event on a cadence (ADR-039). `every` is a duration (`'1h'`/`'30m'`/`'15s'`/`'500ms'`/`'1d'`) or raw ms. **Domain-tier only.** See §Scheduled events. |
 | `version` | no | Integer, defaults to 1. Stamped on every publish; multi-version coexistence is not exercised yet. |
 
 ### Payload field types
@@ -117,6 +118,36 @@ Codegen hard-errors on misuse:
 - `tier: audit` with a `direction` → error naming the event.
 - A job whose `@JobHandler.triggers` points at an audit event → `AuditEventTriggerError`. Use a domain event or remove the trigger.
 
+## Scheduled events (time as an event source)
+
+Add a `schedule:` block and the platform emits this event on a cadence — you react with the **same** tiers you use for any event (a `subscribe(...)` or a `@JobHandler({ triggers })`). There is no separate "cron handler" or schedule decorator; time is just a third way an event gets produced.
+
+```yaml
+# definitions/events/messaging/reconcile_due.yaml
+type: reconcile_due
+direction: inbound            # scheduled events are domain-tier; route by direction
+schedule:
+  every: 1h                   # '1h' | '30m' | '15s' | '500ms' | '1d' | raw ms
+  align: true                 # epoch-anchored boundaries (fires at :00) — default
+  # catchUp: false            # down across N slots → run ONCE on recovery (default)
+  # maxCatchUpSlots: 1000     # bound when catchUp: true
+payload: {}                   # scheduled events are payload-free facts
+```
+
+```ts
+// React via Tier 3 (bridge) — the cadence is on the event, the reaction on the job.
+@JobHandler<ReconcileInput>('reconcile-poll', {
+  pool: 'batch',
+  concurrency: { key: 'reconcile:{{provider}}', collisionMode: 'queue' }, // serialises overruns
+  triggers: [{ event: 'reconcile_due', map: () => ({ provider: 'slack', windowHours: 24 }) }],
+})
+export class ReconcilePollHandler extends JobHandlerBase<ReconcileInput, ReconcileOutput> { /* … */ }
+```
+
+Behavior: the framework emits **exactly one** `domain_events` row per slot (idempotent across instances + restarts), runs **reconcile-on-boot** (one tick on startup — healing any downtime gap), and by default does **not** replay missed slots. **This replaces the old "self-perpetuating job chain"** (a handler enqueuing its own successor with a slot-keyed dedupe) — delete that pattern; declare `schedule:` instead.
+
+Rules: domain-tier only; a malformed `every` fails `gen-validate`; available on the drizzle/memory backends. See ADR-039.
+
 ## Entity `events:` block is sugar for change events
 
 An entity's YAML may keep an `events:` block. At parse time each entry desugars into an equivalent `events/<name>.yaml` with `direction: change` and `aggregate: <entity>`. Both paths produce the same registry entry — inline blocks are convenience, not a second source of truth.

package/dist/{chunk-COGHTKXY.js → chunk-27ETSJ2X.js}

@@ -1,6 +1,6 @@
 import {
   DrizzleCacheService
-} from "./chunk-T6C4LFLC.js";
+} from "./chunk-7YGORYZD.js";
 import {
   MemoryCacheService
 } from "./chunk-IF5I3DAA.js";
@@ -81,4 +81,4 @@ CacheModule = __decorateClass([
 export {
   CacheModule
 };
-//# sourceMappingURL=chunk-COGHTKXY.js.map
+//# sourceMappingURL=chunk-27ETSJ2X.js.map

package/dist/{chunk-X6BP6LI5.js → chunk-3YCUIGPG.js}

@@ -1,13 +1,9 @@
 import {
   JobWorker
-} from "./chunk-C5E7H553.js";
+} from "./chunk-KBO5OOON.js";
 import {
   JobsDomainModule
-} from "./chunk-EWYI5GGJ.js";
-import {
-  BootValidationError,
-  ReservedPoolViolationError
-} from "./chunk-T4BIIU5E.js";
+} from "./chunk-NYJYK6J4.js";
 import {
   BULLMQ_CONNECTION,
   BULLMQ_RESOLVED_CONFIG,
@@ -18,14 +14,18 @@ import {
   allPoolNames,
   loadPoolConfig
 } from "./chunk-RHVN6NA7.js";
-import {
-  HandlerRegistry
-} from "./chunk-7P5ODGLA.js";
 import {
   JOB_ORCHESTRATOR,
   JOB_RUN_SERVICE,
   JOB_STEP_SERVICE
 } from "./chunk-ZPL74UQN.js";
+import {
+  BootValidationError,
+  ReservedPoolViolationError
+} from "./chunk-T4BIIU5E.js";
+import {
+  HandlerRegistry
+} from "./chunk-7P5ODGLA.js";
 import {
   tokenKey
 } from "./chunk-GYGNEQSC.js";
@@ -290,4 +290,4 @@ export {
   JobWorkerOrchestrator,
   JobWorkerModule
 };
-//# sourceMappingURL=chunk-X6BP6LI5.js.map
+//# sourceMappingURL=chunk-3YCUIGPG.js.map

package/dist/{chunk-BK5ICA2F.js → chunk-4MVGAMUA.js}

@@ -1,12 +1,12 @@
-import {
-  STORAGE
-} from "./chunk-NYBCQZC7.js";
 import {
   LocalStorageBackend
 } from "./chunk-JWNHNUYL.js";
 import {
   MemoryStorageBackend
 } from "./chunk-3SZFUTXE.js";
+import {
+  STORAGE
+} from "./chunk-NYBCQZC7.js";
 import {
   __decorateClass
 } from "./chunk-2E224ZSN.js";
@@ -37,4 +37,4 @@ StorageModule = __decorateClass([
 export {
   StorageModule
 };
-//# sourceMappingURL=chunk-BK5ICA2F.js.map
+//# sourceMappingURL=chunk-4MVGAMUA.js.map

package/dist/{chunk-LQ6PYFU6.js → chunk-4OC5MSHO.js}

@@ -12,6 +12,7 @@ import {
 } from "./chunk-2E224ZSN.js";
 
 // runtime/subsystems/events/event-bus.memory-backend.ts
+import { randomUUID } from "crypto";
 import { Inject, Injectable, Logger, Optional } from "@nestjs/common";
 function toEventSummary(event) {
   const metadata = event.metadata;
@@ -58,6 +59,51 @@ var MemoryEventBus = class {
   async findById(eventId) {
     return this.publishedEvents.find((e) => e.id === eventId) ?? null;
   }
+  // ============================================================================
+  // ADR-039 — scheduled-event materialisation (memory parity)
+  // ============================================================================
+  /** Slot keys already materialised — the in-memory mirror of the partial
+   *  UNIQUE expression index `idx_domain_events_schedule_slot`. */
+  materialisedSlots = /* @__PURE__ */ new Set();
+  /**
+   * Mirror of the Drizzle `ON CONFLICT DO NOTHING` insert: emit one payload-free
+   * tick event per slot key, no-op if the slot was already materialised. The
+   * "constraint" is the `materialisedSlots` set. The tick is published through
+   * the normal `publish` path so subscribers fire synchronously (the memory bus
+   * has no future-slot/poll concept — a materialised slot dispatches now, which
+   * is the behaviour the unit suite pins).
+   */
+  async materializeScheduledEvent(spec) {
+    if (this.materialisedSlots.has(spec.slotKey)) return { created: false };
+    this.materialisedSlots.add(spec.slotKey);
+    const event = {
+      id: randomUUID(),
+      type: spec.type,
+      aggregateId: spec.type,
+      aggregateType: spec.type,
+      payload: {},
+      occurredAt: spec.slotStart,
+      metadata: {
+        pool: spec.pool,
+        direction: spec.direction,
+        scheduleSlot: spec.slotKey,
+        triggerSource: "schedule"
+      }
+    };
+    await this.publish(event);
+    return { created: true };
+  }
+  /** Most recent scheduled tick's `occurred_at` (epoch ms) for `type`, or null. */
+  async lastScheduledSlotMs(type) {
+    let best = null;
+    for (const e of this.publishedEvents) {
+      if (e.type !== type) continue;
+      if (e.metadata?.["triggerSource"] !== "schedule") continue;
+      const ms = e.occurredAt.getTime();
+      if (best === null || ms > best) best = ms;
+    }
+    return best;
+  }
   subscribe(eventType, handler) {
     if (!this.handlers.has(eventType)) {
       this.handlers.set(eventType, /* @__PURE__ */ new Set());
@@ -197,4 +243,4 @@ MemoryEventBus = __decorateClass([
 export {
   MemoryEventBus
 };
-//# sourceMappingURL=chunk-LQ6PYFU6.js.map
+//# sourceMappingURL=chunk-4OC5MSHO.js.map

package/dist/chunk-4OC5MSHO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/events/event-bus.memory-backend.ts"],"sourcesContent":["/**\n * MemoryEventBus — in-memory backend for the event bus.\n *\n * Dispatches events synchronously to registered subscribers. The `tx`\n * parameter is ignored — all events are dispatched immediately.\n *\n * Use this backend in tests to assert event publication without a database.\n * Swap via EventsModule.forRoot({ backend: 'memory' }).\n *\n * Pool awareness (EVT-5):\n * - Mirrors the `DrizzleEventBus` per-process restriction (EVT-4). When\n *   `opts.pools` is set, `publish`/`publishMany` still push the event into\n *   `publishedEvents` (so test code can assert the full set of emitted\n *   events regardless of pool filter), but handlers are NOT invoked for\n *   events whose `metadata.pool` is outside the configured pools.\n * - `publishedEventsForPool(pool)` and `publishedEventsForDirection(dir)`\n *   helpers are provided for targeted assertions.\n * - Shares the `EventsModuleOptions` shape (same token as Drizzle) rather\n *   than introducing a memory-only options type — the surface is the same\n *   and keeping them unified avoids drift between backends.\n */\nimport { randomUUID } from 'node:crypto';\nimport { Inject, Injectable, Logger, Optional } from '@nestjs/common';\nimport type {\n  DomainEvent,\n  IEventBus,\n  ScheduledEventSpec,\n} from './event-bus.protocol';\nimport type {\n  EventPage,\n  EventSummary,\n  IEventReadPort,\n  ListEventsQuery,\n} from './event-read.protocol';\nimport {\n  clampEventLimit,\n  decodeEventCursor,\n  encodeEventCursor,\n} from './event-keyset-cursor';\nimport { EVENTS_MODULE_OPTIONS } from './events.tokens';\nimport type { EventsModuleOptions } from './events.module';\n\n/**\n * Project an in-memory `DomainEvent` into the narrow `EventSummary` shape.\n * The memory backend has no first-class columns, so `pool` / `direction` /\n * `tier` / `tenantId` / `rootRunId` are read from `metadata` (mirroring how\n * the Drizzle backend stamps them onto columns at publish time). `status`\n * is reported as `'processed'` — the memory bus dispatches synchronously,\n * so once an event is in `publishedEvents` it has been handled.\n */\nfunction toEventSummary(event: DomainEvent): EventSummary {\n  const metadata = event.metadata;\n  const str = (key: string): string | null => {\n    const v = metadata?.[key];\n    return typeof v === 'string' ? v : null;\n  };\n  return {\n    id: event.id,\n    type: event.type,\n    aggregateId: event.aggregateId,\n    aggregateType: event.aggregateType,\n    status: 'processed',\n    pool: str('pool'),\n    direction: str('direction'),\n    tier: str('tier') ?? 'domain',\n    rootRunId: str('rootRunId'),\n    tenantId: str('tenantId'),\n    occurredAt: event.occurredAt,\n    processedAt: event.occurredAt,\n  };\n}\n\n@Injectable()\nexport class MemoryEventBus implements IEventBus, IEventReadPort {\n  private readonly logger = new Logger(MemoryEventBus.name);\n\n  /** All events published since construction (or last clear). */\n  readonly publishedEvents: DomainEvent[] = [];\n\n  private readonly handlers = new Map<string, Set<(event: DomainEvent) => Promise<void>>>();\n  private readonly opts: EventsModuleOptions;\n\n  constructor(\n    @Optional() @Inject(EVENTS_MODULE_OPTIONS) opts?: EventsModuleOptions,\n  ) {\n    // Default so direct construction (e.g. `new MemoryEventBus()` from a\n    // unit test outside NestJS DI) keeps working without an explicit\n    // options object.\n    this.opts = opts ?? { backend: 'memory' };\n  }\n\n  async publish(event: DomainEvent): Promise<void> {\n    // Mirror the `domain_events_tier_routing_check` DB constraint at the\n    // memory backend boundary so misuse fails the same way regardless of\n    // backend (AUDIT-1).\n    this.assertTierRouting(event);\n\n    // Always record the event — even if this process is configured with a\n    // pool filter that excludes it. Test code relies on `publishedEvents`\n    // being a complete log of what was published, not a filtered view.\n    this.publishedEvents.push(event);\n\n    if (this.shouldDispatch(event)) {\n      await this.dispatch(event);\n    }\n  }\n\n  async publishMany(events: DomainEvent[]): Promise<void> {\n    for (const event of events) {\n      await this.publish(event);\n    }\n  }\n\n  async findById(eventId: string): Promise<DomainEvent | null> {\n    return this.publishedEvents.find((e) => e.id === eventId) ?? null;\n  }\n\n  // ============================================================================\n  // ADR-039 — scheduled-event materialisation (memory parity)\n  // ============================================================================\n\n  /** Slot keys already materialised — the in-memory mirror of the partial\n   *  UNIQUE expression index `idx_domain_events_schedule_slot`. */\n  private readonly materialisedSlots = new Set<string>();\n\n  /**\n   * Mirror of the Drizzle `ON CONFLICT DO NOTHING` insert: emit one payload-free\n   * tick event per slot key, no-op if the slot was already materialised. The\n   * \"constraint\" is the `materialisedSlots` set. The tick is published through\n   * the normal `publish` path so subscribers fire synchronously (the memory bus\n   * has no future-slot/poll concept — a materialised slot dispatches now, which\n   * is the behaviour the unit suite pins).\n   */\n  async materializeScheduledEvent(\n    spec: ScheduledEventSpec,\n  ): Promise<{ created: boolean }> {\n    if (this.materialisedSlots.has(spec.slotKey)) return { created: false };\n    this.materialisedSlots.add(spec.slotKey);\n    const event: DomainEvent = {\n      id: randomUUID(),\n      type: spec.type,\n      aggregateId: spec.type,\n      aggregateType: spec.type,\n      payload: {},\n      occurredAt: spec.slotStart,\n      metadata: {\n        pool: spec.pool,\n        direction: spec.direction,\n        scheduleSlot: spec.slotKey,\n        triggerSource: 'schedule',\n      },\n    };\n    await this.publish(event);\n    return { created: true };\n  }\n\n  /** Most recent scheduled tick's `occurred_at` (epoch ms) for `type`, or null. */\n  async lastScheduledSlotMs(type: string): Promise<number | null> {\n    let best: number | null = null;\n    for (const e of this.publishedEvents) {\n      if (e.type !== type) continue;\n      if (e.metadata?.['triggerSource'] !== 'schedule') continue;\n      const ms = e.occurredAt.getTime();\n      if (best === null || ms > best) best = ms;\n    }\n    return best;\n  }\n\n  subscribe<T extends DomainEvent = DomainEvent>(\n    eventType: string,\n    handler: (event: T) => Promise<void>,\n  ): () => void {\n    if (!this.handlers.has(eventType)) {\n      this.handlers.set(eventType, new Set());\n    }\n    // Cast is safe — callers pass a typed handler; we store as the base type\n    const set = this.handlers.get(eventType)!;\n    const h = handler as (event: DomainEvent) => Promise<void>;\n    set.add(h);\n\n    return () => {\n      set.delete(h);\n    };\n  }\n\n  // ============================================================================\n  // IEventReadPort (OBS-LIST-1)\n  // ============================================================================\n\n  async listEvents(query: ListEventsQuery = {}): Promise<EventPage> {\n    const limit = clampEventLimit(query.limit);\n    const keyset = query.cursor ? decodeEventCursor(query.cursor) : null;\n\n    const str = (e: DomainEvent, key: string): string | null => {\n      const v = e.metadata?.[key];\n      return typeof v === 'string' ? v : null;\n    };\n\n    const matched = this.publishedEvents.filter((e) => {\n      if (query.poolId && str(e, 'pool') !== query.poolId) return false;\n      if (query.direction && str(e, 'direction') !== query.direction)\n        return false;\n      if (query.rootRunId && str(e, 'rootRunId') !== query.rootRunId)\n        return false;\n      if (query.since && e.occurredAt.getTime() < query.since.getTime())\n        return false;\n      if (query.tenantId !== undefined) {\n        const t = str(e, 'tenantId');\n        if (query.tenantId === null) {\n          if (t !== null) return false;\n        } else if (t !== query.tenantId) {\n          return false;\n        }\n      }\n      return true;\n    });\n\n    // Order occurred_at DESC, id DESC to match the Drizzle backend keyset.\n    matched.sort((a, b) => {\n      const dt = b.occurredAt.getTime() - a.occurredAt.getTime();\n      if (dt !== 0) return dt;\n      return a.id < b.id ? 1 : a.id > b.id ? -1 : 0;\n    });\n\n    const seeked = keyset\n      ? matched.filter((e) => {\n          const ct = e.occurredAt.getTime();\n          const kt = keyset.occurredAt.getTime();\n          if (ct < kt) return true;\n          if (ct > kt) return false;\n          return e.id < keyset.id;\n        })\n      : matched;\n\n    const hasMore = seeked.length > limit;\n    const page = hasMore ? seeked.slice(0, limit) : seeked;\n    const items = page.map(toEventSummary);\n    const last = page[page.length - 1];\n    const nextCursor =\n      hasMore && last\n        ? encodeEventCursor({ occurredAt: last.occurredAt, id: last.id })\n        : null;\n\n    return { items, nextCursor };\n  }\n\n  /** Remove all published events and subscriptions. Useful in beforeEach. */\n  clear(): void {\n    this.publishedEvents.length = 0;\n    this.handlers.clear();\n  }\n\n  /** Filter published events by `metadata.pool`. */\n  publishedEventsForPool(pool: string): DomainEvent[] {\n    return this.publishedEvents.filter((e) => e.metadata?.['pool'] === pool);\n  }\n\n  /** Filter published events by `metadata.direction`. */\n  publishedEventsForDirection(direction: string): DomainEvent[] {\n    return this.publishedEvents.filter((e) => e.metadata?.['direction'] === direction);\n  }\n\n  /**\n   * Decide whether `event` should be dispatched to handlers given the\n   * current pool filter.\n   *\n   * Semantics (mirroring `DrizzleEventBus.processBatch`):\n   * - `opts.pools` undefined  → dispatch everything (no filter).\n   * - `opts.pools` empty array → treated as \"no filter\" to match the\n   *   Drizzle backend, where `pools && pools.length > 0` is the gate on\n   *   the `inArray` WHERE clause. Empty arrays dispatch everything.\n   * - `opts.pools` non-empty  → dispatch only when `event.metadata.pool`\n   *   is in the list. Events without `metadata.pool` do NOT match — they\n   *   are out of all configured pools by definition.\n   */\n  private shouldDispatch(event: DomainEvent): boolean {\n    const pools = this.opts.pools;\n    if (!pools || pools.length === 0) return true;\n    const eventPool = event.metadata?.['pool'];\n    return typeof eventPool === 'string' && pools.includes(eventPool);\n  }\n\n  /**\n   * Mirror the `domain_events_tier_routing_check` DB CHECK at the memory\n   * backend (AUDIT-1). Audit-tier events MUST have null/undefined\n   * `pool` and `direction` in metadata; the bridge dispatcher relies on\n   * this invariant.\n   */\n  private assertTierRouting(event: DomainEvent): void {\n    const tier = event.metadata?.['tier'];\n    if (tier !== 'audit') return;\n    const pool = event.metadata?.['pool'];\n    const direction = event.metadata?.['direction'];\n    const poolIsNull = pool === null || pool === undefined;\n    const directionIsNull = direction === null || direction === undefined;\n    if (!poolIsNull || !directionIsNull) {\n      throw new Error(\n        `MemoryEventBus: tier='audit' events must have null pool and direction ` +\n          `(got pool=${String(pool)}, direction=${String(direction)}). ` +\n          `This mirrors the domain_events CHECK constraint.`,\n      );\n    }\n  }\n\n  private async dispatch(event: DomainEvent): Promise<void> {\n    const set = this.handlers.get(event.type);\n    if (!set) return;\n\n    let firstError: unknown;\n    for (const handler of set) {\n      try {\n        await handler(event);\n      } catch (err) {\n        this.logger.error(\n          `Handler error for event type \"${event.type}\" (id: ${event.id}): ${err}`,\n        );\n        if (firstError === undefined) {\n          firstError = err;\n        }\n      }\n    }\n\n    if (firstError !== undefined) {\n      throw firstError;\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-3A34R6CI.js → chunk-5LXOJGO2.js}

@@ -4,9 +4,6 @@ import {
   encodeKeysetCursor,
   toJobRunSummary
 } from "./chunk-L3LZWWSX.js";
-import {
-  MissingTenantIdError
-} from "./chunk-T4BIIU5E.js";
 import {
   jobRuns
 } from "./chunk-OKXZ63IA.js";
@@ -14,6 +11,9 @@ import {
   JOBS_MULTI_TENANT,
   JOB_ORCHESTRATOR
 } from "./chunk-ZPL74UQN.js";
+import {
+  MissingTenantIdError
+} from "./chunk-T4BIIU5E.js";
 import {
   DRIZZLE
 } from "./chunk-U64T4YZE.js";
@@ -198,4 +198,4 @@ DrizzleJobRunService = __decorateClass([
 export {
   DrizzleJobRunService
 };
-//# sourceMappingURL=chunk-3A34R6CI.js.map
+//# sourceMappingURL=chunk-5LXOJGO2.js.map

package/dist/{chunk-T6C4LFLC.js → chunk-7YGORYZD.js}

@@ -1,9 +1,9 @@
-import {
-  cacheEntries
-} from "./chunk-FASRXRX5.js";
 import {
   CACHE_DEFAULT_TTL
 } from "./chunk-L6FTY45T.js";
+import {
+  cacheEntries
+} from "./chunk-FASRXRX5.js";
 import {
   DRIZZLE
 } from "./chunk-U64T4YZE.js";
@@ -109,4 +109,4 @@ DrizzleCacheService = __decorateClass([
 export {
   DrizzleCacheService
 };
-//# sourceMappingURL=chunk-T6C4LFLC.js.map
+//# sourceMappingURL=chunk-7YGORYZD.js.map

package/dist/{chunk-PKDS6QIJ.js → chunk-ATVGYF3D.js}

@@ -7,6 +7,12 @@ import {
 import {
   PostgresCursorStore
 } from "./chunk-XWBK3XJK.js";
+import {
+  MemoryCursorStore
+} from "./chunk-AHV4GDYM.js";
+import {
+  DeepEqualDiffer
+} from "./chunk-JEINYUJH.js";
 import {
   INTEGRATION_CURSOR_STORE,
   INTEGRATION_FIELD_DIFFER,
@@ -14,12 +20,6 @@ import {
   INTEGRATION_MULTI_TENANT,
   INTEGRATION_RUN_RECORDER
 } from "./chunk-S7C6TIIF.js";
-import {
-  MemoryCursorStore
-} from "./chunk-AHV4GDYM.js";
-import {
-  DeepEqualDiffer
-} from "./chunk-JEINYUJH.js";
 import {
   __decorateClass
 } from "./chunk-2E224ZSN.js";
@@ -84,4 +84,4 @@ IntegrationModule = __decorateClass([
 export {
   IntegrationModule
 };
-//# sourceMappingURL=chunk-PKDS6QIJ.js.map
+//# sourceMappingURL=chunk-ATVGYF3D.js.map

package/dist/{chunk-2TVVBC53.js → chunk-BORNCTH3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-OKXZ63IA.js";
 import {
   domainEvents
-} from "./chunk-OFRRBC7M.js";
+} from "./chunk-E2BRT5IB.js";
 
 // runtime/subsystems/bridge/bridge-delivery.schema.ts
 import {
@@ -89,4 +89,4 @@ export {
   bridgeDeliveryStatusEnum,
   bridgeDelivery
 };
-//# sourceMappingURL=chunk-2TVVBC53.js.map
+//# sourceMappingURL=chunk-BORNCTH3.js.map

package/dist/{chunk-7MMS36AN.js → chunk-CUSMC2KK.js}

@@ -1,3 +1,12 @@
+import {
+  jobRuns,
+  jobSteps,
+  jobs
+} from "./chunk-OKXZ63IA.js";
+import {
+  JOBS_LISTEN_NOTIFY,
+  JOBS_MULTI_TENANT
+} from "./chunk-ZPL74UQN.js";
 import {
   JobCollisionError,
   JobNotReplayableError,
@@ -9,15 +18,6 @@ import {
   keySelectorToTemplate,
   resolveJobKey
 } from "./chunk-7P5ODGLA.js";
-import {
-  jobRuns,
-  jobSteps,
-  jobs
-} from "./chunk-OKXZ63IA.js";
-import {
-  JOBS_LISTEN_NOTIFY,
-  JOBS_MULTI_TENANT
-} from "./chunk-ZPL74UQN.js";
 import {
   JOBS_WAKE_CHANNEL,
   pgNotify
@@ -393,4 +393,4 @@ export {
   evaluateKeyTemplate,
   DrizzleJobOrchestrator
 };
-//# sourceMappingURL=chunk-7MMS36AN.js.map
+//# sourceMappingURL=chunk-CUSMC2KK.js.map

package/dist/{chunk-V4AF6DI4.js → chunk-DUBZOXJC.js}

@@ -9,8 +9,15 @@ var MissingTenantIdError = class extends Error {
   eventType;
   name = "MissingTenantIdError";
 };
+var ScheduleConfigError = class extends Error {
+  name = "ScheduleConfigError";
+  constructor(message) {
+    super(`ScheduleConfigError: ${message}`);
+  }
+};
 
 export {
-  MissingTenantIdError
+  MissingTenantIdError,
+  ScheduleConfigError
 };
-//# sourceMappingURL=chunk-V4AF6DI4.js.map
+//# sourceMappingURL=chunk-DUBZOXJC.js.map

package/dist/{chunk-V4AF6DI4.js.map → chunk-DUBZOXJC.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../runtime/subsystems/events/events-errors.ts"],"sourcesContent":["/**\n * Typed errors for the events subsystem (ADR-024, EVT-6).\n *\n * All thrown from the publish path of `TypedEventBus`. They exist as\n * classes so consumers can `instanceof` them in catch blocks and\n * exception filters can map them to HTTP codes.\n */\n\n/**\n * Thrown by `TypedEventBus.publish()` when the EventsModule is configured\n * with `multiTenant: true` and the caller did not supply\n * `opts.metadata.tenantId`. Multi-tenant mode requires every outbox row to\n * be attributable to a tenant — the `domain_events.tenant_id` column is\n * populated from this value and the drain loop uses it for future\n * tenant-scoped filtering (deferred — see ADR-024 §Multi-tenancy).\n *\n * Disable multi-tenancy at the module level (`multiTenant: false`, the\n * default) to opt out of the requirement entirely.\n */\nexport class MissingTenantIdError extends Error {\n  override readonly name = 'MissingTenantIdError';\n  constructor(public readonly eventType: string) {\n    super(\n      `Missing tenantId for event '${eventType}'. EventsModule is configured ` +\n        `with multiTenant: true — every publish must include ` +\n        `opts.metadata.tenantId. Either pass the tenantId or disable ` +\n        `multi-tenancy on the module.`,\n    );\n  }\n}\n"],"mappings":";AAmBO,IAAM,uBAAN,cAAmC,MAAM;AAAA,EAE9C,YAA4B,WAAmB;AAC7C;AAAA,MACE,+BAA+B,SAAS;AAAA,IAI1C;AAN0B;AAAA,EAO5B;AAAA,EAP4B;AAAA,EADV,OAAO;AAS3B;","names":[]}
+{"version":3,"sources":["../runtime/subsystems/events/events-errors.ts"],"sourcesContent":["/**\n * Typed errors for the events subsystem (ADR-024, EVT-6).\n *\n * All thrown from the publish path of `TypedEventBus`. They exist as\n * classes so consumers can `instanceof` them in catch blocks and\n * exception filters can map them to HTTP codes.\n */\n\n/**\n * Thrown by `TypedEventBus.publish()` when the EventsModule is configured\n * with `multiTenant: true` and the caller did not supply\n * `opts.metadata.tenantId`. Multi-tenant mode requires every outbox row to\n * be attributable to a tenant — the `domain_events.tenant_id` column is\n * populated from this value and the drain loop uses it for future\n * tenant-scoped filtering (deferred — see ADR-024 §Multi-tenancy).\n *\n * Disable multi-tenancy at the module level (`multiTenant: false`, the\n * default) to opt out of the requirement entirely.\n */\nexport class MissingTenantIdError extends Error {\n  override readonly name = 'MissingTenantIdError';\n  constructor(public readonly eventType: string) {\n    super(\n      `Missing tenantId for event '${eventType}'. EventsModule is configured ` +\n        `with multiTenant: true — every publish must include ` +\n        `opts.metadata.tenantId. Either pass the tenantId or disable ` +\n        `multi-tenancy on the module.`,\n    );\n  }\n}\n\n/**\n * Thrown (ADR-039) when a scheduled event's `schedule` config is invalid at\n * runtime — a malformed `schedule.every` duration, or a scheduled event with no\n * direction/pool to route by. Codegen validates `schedule` at `gen-all` time;\n * this is the boot backstop for a hand-edited registry or version skew. Raised\n * by `EventScheduler` construction / `parseEvery`.\n */\nexport class ScheduleConfigError extends Error {\n  override readonly name = 'ScheduleConfigError';\n  constructor(message: string) {\n    super(`ScheduleConfigError: ${message}`);\n  }\n}\n"],"mappings":";AAmBO,IAAM,uBAAN,cAAmC,MAAM;AAAA,EAE9C,YAA4B,WAAmB;AAC7C;AAAA,MACE,+BAA+B,SAAS;AAAA,IAI1C;AAN0B;AAAA,EAO5B;AAAA,EAP4B;AAAA,EADV,OAAO;AAS3B;AASO,IAAM,sBAAN,cAAkC,MAAM;AAAA,EAC3B,OAAO;AAAA,EACzB,YAAY,SAAiB;AAC3B,UAAM,wBAAwB,OAAO,EAAE;AAAA,EACzC;AACF;","names":[]}