@pattern-stack/codegen 0.15.0 → 0.15.2

package/dist/chunk-EOLLMEAH.js

@@ -0,0 +1,155 @@
+import {
+  TypedEventBus
+} from "./chunk-GM3RMJIJ.js";
+import {
+  DrizzleEventBus
+} from "./chunk-4JLJYWJC.js";
+import {
+  MemoryEventBus
+} from "./chunk-Z7PQCAVK.js";
+import {
+  EVENTS_MODULE_OPTIONS,
+  EVENTS_MULTI_TENANT,
+  EVENT_BUS,
+  EVENT_READ_PORT,
+  REDIS_URL,
+  TYPED_EVENT_BUS
+} from "./chunk-H5NH7KPE.js";
+import {
+  DRIZZLE
+} from "./chunk-U64T4YZE.js";
+import {
+  __decorateClass
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/events/events.module.ts
+import { Module } from "@nestjs/common";
+async function loadRedisEventBus() {
+  const specifier = "./event-bus.redis-backend";
+  const mod = await import(specifier);
+  return mod.RedisEventBus;
+}
+function buildTypedBusProviders(multiTenant, typedBus) {
+  const BusClass = typedBus ?? TypedEventBus;
+  return [
+    BusClass,
+    { provide: TYPED_EVENT_BUS, useExisting: BusClass },
+    { provide: EVENTS_MULTI_TENANT, useValue: multiTenant }
+  ];
+}
+async function buildEventBusAsync(options, db, redisUrl) {
+  if (options.backend === "drizzle") {
+    if (!db) {
+      throw new Error(
+        "EventsModule.forRootAsync: backend: 'drizzle' selected but DRIZZLE provider is not available. Ensure DatabaseModule (or another provider exposing DRIZZLE) is imported before EventsModule.forRootAsync."
+      );
+    }
+    return new DrizzleEventBus(db, options);
+  }
+  if (options.backend === "redis") {
+    const RedisEventBus = await loadRedisEventBus();
+    return new RedisEventBus(redisUrl);
+  }
+  return new MemoryEventBus(options);
+}
+var EventsModule = class {
+  static forRootAsync(asyncOptions) {
+    return {
+      module: EventsModule,
+      global: true,
+      imports: asyncOptions.imports ?? [],
+      providers: [
+        {
+          provide: EVENTS_MODULE_OPTIONS,
+          useFactory: asyncOptions.useFactory,
+          inject: asyncOptions.inject ?? []
+        },
+        {
+          provide: EVENTS_MULTI_TENANT,
+          useFactory: (options) => options.multiTenant ?? false,
+          inject: [EVENTS_MODULE_OPTIONS]
+        },
+        {
+          provide: REDIS_URL,
+          useFactory: (options) => options.redisUrl ?? process.env["REDIS_URL"] ?? "redis://localhost:6379",
+          inject: [EVENTS_MODULE_OPTIONS]
+        },
+        {
+          provide: EVENT_BUS,
+          useFactory: (options, db, redisUrl) => buildEventBusAsync(options, db, redisUrl),
+          inject: [
+            EVENTS_MODULE_OPTIONS,
+            { token: DRIZZLE, optional: true },
+            REDIS_URL
+          ]
+        },
+        {
+          // Read port (OBS-LIST-1). Drizzle + memory backends implement
+          // IEventReadPort on the EVENT_BUS instance; the redis backend
+          // retains no history, so EVENT_READ_PORT resolves to `null` and
+          // optional consumers (the observability combiner) degrade to
+          // empty results.
+          provide: EVENT_READ_PORT,
+          useFactory: (options, bus) => options.backend === "redis" ? null : bus,
+          inject: [EVENTS_MODULE_OPTIONS, EVENT_BUS]
+        },
+        TypedEventBus,
+        { provide: TYPED_EVENT_BUS, useExisting: TypedEventBus }
+      ],
+      exports: [EVENT_BUS, EVENT_READ_PORT, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
+    };
+  }
+  static forRoot(options = { backend: "drizzle" }) {
+    const multiTenant = options.multiTenant ?? false;
+    if (options.backend === "redis") {
+      const resolvedUrl = options.redisUrl ?? process.env["REDIS_URL"] ?? "redis://localhost:6379";
+      return {
+        module: EventsModule,
+        global: true,
+        providers: [
+          { provide: EVENTS_MODULE_OPTIONS, useValue: options },
+          { provide: REDIS_URL, useValue: resolvedUrl },
+          {
+            // #6: useFactory + dynamic import so the consumer's tsc never
+            // needs to resolve `event-bus.redis-backend.ts` for drizzle/
+            // memory installs (the file is filtered out by
+            // `backendFileFilter`). Nest awaits async factories + manages
+            // lifecycle on the returned instance, so we drop the old bare
+            // `RedisEventBus` provider entry.
+            provide: EVENT_BUS,
+            useFactory: async (url) => {
+              const RedisEventBus = await loadRedisEventBus();
+              return new RedisEventBus(url);
+            },
+            inject: [REDIS_URL]
+          },
+          ...buildTypedBusProviders(multiTenant, options.typedBus)
+        ],
+        exports: [EVENT_BUS, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
+      };
+    }
+    const provider = options.backend === "drizzle" ? { provide: EVENT_BUS, useClass: DrizzleEventBus } : { provide: EVENT_BUS, useClass: MemoryEventBus };
+    return {
+      module: EventsModule,
+      global: true,
+      providers: [
+        { provide: EVENTS_MODULE_OPTIONS, useValue: options },
+        provider,
+        // Read port (OBS-LIST-1): drizzle + memory backends implement
+        // IEventReadPort on the same instance as EVENT_BUS. The redis
+        // backend retains no history and does not provide this token.
+        { provide: EVENT_READ_PORT, useExisting: EVENT_BUS },
+        ...buildTypedBusProviders(multiTenant, options.typedBus)
+      ],
+      exports: [EVENT_BUS, EVENT_READ_PORT, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
+    };
+  }
+};
+EventsModule = __decorateClass([
+  Module({})
+], EventsModule);
+
+export {
+  EventsModule
+};
+//# sourceMappingURL=chunk-EOLLMEAH.js.map

package/dist/chunk-EOLLMEAH.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 { Module, type DynamicModule, type Provider, type Type } 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';\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   * 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\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        ...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-EWYCWP4H.js

@@ -0,0 +1,14 @@
+// runtime/subsystems/observability/observability-errors.ts
+var ObservabilityError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "ObservabilityError";
+  }
+  cause;
+};
+
+export {
+  ObservabilityError
+};
+//# sourceMappingURL=chunk-EWYCWP4H.js.map

package/dist/chunk-EWYCWP4H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/observability/observability-errors.ts"],"sourcesContent":["/**\n * Base class for observability-specific errors.\n *\n * Phase-1 `IObservability` methods do not throw — missing sibling ports\n * degrade to empty shapes (see `ObservabilityService`). This class exists\n * so future extensions (OBS-6 reporter misconfiguration, phase-2 Drizzle\n * extensions for `pg_stat_*` sampling, etc.) have a named base without\n * churning the barrel when they land.\n */\nexport class ObservabilityError extends Error {\n  constructor(\n    message: string,\n    override readonly cause?: unknown,\n  ) {\n    super(message);\n    this.name = 'ObservabilityError';\n  }\n}\n"],"mappings":";AASO,IAAM,qBAAN,cAAiC,MAAM;AAAA,EAC5C,YACE,SACkB,OAClB;AACA,UAAM,OAAO;AAFK;AAGlB,SAAK,OAAO;AAAA,EACd;AAAA,EAJoB;AAKtB;","names":[]}

package/dist/chunk-EXVDJMIY.js

@@ -0,0 +1,33 @@
+// runtime/base-classes/base-read-use-cases.ts
+var BaseFindByIdUseCase = class {
+  constructor(service) {
+    this.service = service;
+  }
+  service;
+  /**
+   * Find a single entity by its primary key.
+   * Returns null if not found.
+   */
+  execute(id) {
+    return this.service.findById(id);
+  }
+};
+var BaseListUseCase = class {
+  constructor(service) {
+    this.service = service;
+  }
+  service;
+  /**
+   * List all entities (no filters).
+   * Controllers that need filtered lists should use a dedicated use case.
+   */
+  execute() {
+    return this.service.list();
+  }
+};
+
+export {
+  BaseFindByIdUseCase,
+  BaseListUseCase
+};
+//# sourceMappingURL=chunk-EXVDJMIY.js.map

package/dist/chunk-EXVDJMIY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/base-classes/base-read-use-cases.ts"],"sourcesContent":["/**\n * Base read use cases\n *\n * Abstract base classes for auto-generated per-entity read use cases.\n * Controllers always import use case classes — never services directly (ADR-003).\n *\n * Each entity gets a single generated file with two named exports:\n *   - ContactFindByIdUseCase extends BaseFindByIdUseCase<ContactService, Contact>\n *   - ContactListUseCase extends BaseListUseCase<ContactService, Contact>\n *\n * Note: @Injectable() is applied on concrete use case classes (not here),\n * matching the pattern established by BaseRepository and BaseService.\n */\n\n// ============================================================================\n// BaseFindByIdUseCase\n// ============================================================================\n\n/**\n * Structural interface for any service that supports findById.\n * Keeps base use cases decoupled from concrete service implementations.\n */\nexport interface IFindByIdService<TEntity> {\n  findById(id: string): Promise<TEntity | null>;\n}\n\n/**\n * Base class for generated FindById use cases.\n *\n * Generated usage:\n * ```typescript\n * @Injectable()\n * export class ContactFindByIdUseCase extends BaseFindByIdUseCase<ContactService, Contact> {\n *   constructor(service: ContactService) { super(service); }\n * }\n * ```\n */\nexport abstract class BaseFindByIdUseCase<\n  TService extends IFindByIdService<TEntity>,\n  TEntity,\n> {\n  constructor(protected readonly service: TService) {}\n\n  /**\n   * Find a single entity by its primary key.\n   * Returns null if not found.\n   */\n  execute(id: string): Promise<TEntity | null> {\n    return this.service.findById(id);\n  }\n}\n\n// ============================================================================\n// BaseListUseCase\n// ============================================================================\n\n/**\n * Structural interface for any service that supports list.\n */\nexport interface IListService<TEntity> {\n  list(options?: unknown): Promise<TEntity[]>;\n}\n\n/**\n * Base class for generated List use cases.\n *\n * Generated usage:\n * ```typescript\n * @Injectable()\n * export class ContactListUseCase extends BaseListUseCase<ContactService, Contact> {\n *   constructor(service: ContactService) { super(service); }\n * }\n * ```\n */\nexport abstract class BaseListUseCase<\n  TService extends IListService<TEntity>,\n  TEntity,\n> {\n  constructor(protected readonly service: TService) {}\n\n  /**\n   * List all entities (no filters).\n   * Controllers that need filtered lists should use a dedicated use case.\n   */\n  execute(): Promise<TEntity[]> {\n    return this.service.list();\n  }\n}\n"],"mappings":";AAqCO,IAAe,sBAAf,MAGL;AAAA,EACA,YAA+B,SAAmB;AAAnB;AAAA,EAAoB;AAAA,EAApB;AAAA;AAAA;AAAA;AAAA;AAAA,EAM/B,QAAQ,IAAqC;AAC3C,WAAO,KAAK,QAAQ,SAAS,EAAE;AAAA,EACjC;AACF;AAwBO,IAAe,kBAAf,MAGL;AAAA,EACA,YAA+B,SAAmB;AAAnB;AAAA,EAAoB;AAAA,EAApB;AAAA;AAAA;AAAA;AAAA;AAAA,EAM/B,UAA8B;AAC5B,WAAO,KAAK,QAAQ,KAAK;AAAA,EAC3B;AACF;","names":[]}

package/dist/chunk-FASRXRX5.js

@@ -0,0 +1,19 @@
+// runtime/subsystems/cache/cache.schema.ts
+import { pgTable, text, jsonb, timestamp } from "drizzle-orm/pg-core";
+var cacheEntries = pgTable(
+  "cache_entries",
+  {
+    /** Cache key — primary key, text (not uuid) to support arbitrary key namespacing. */
+    key: text("key").primaryKey(),
+    /** Cached value serialised as JSONB. */
+    value: jsonb("value").notNull(),
+    /** NULL means the entry never expires. */
+    expiresAt: timestamp("expires_at", { withTimezone: true })
+  }
+  // Index: add (expires_at) via migration for cleanup queries
+);
+
+export {
+  cacheEntries
+};
+//# sourceMappingURL=chunk-FASRXRX5.js.map

package/dist/chunk-FASRXRX5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/cache/cache.schema.ts"],"sourcesContent":["/**\n * Drizzle schema for the cache_entries table.\n *\n * This table backs the DrizzleCacheService. TTL is enforced by filtering\n * on expiresAt at read time; a periodic cleanup job removes stale rows.\n *\n * Indexes:\n * - PRIMARY KEY on key (point-lookup)\n * - (expiresAt) for the cleanup query\n */\nimport { pgTable, text, jsonb, timestamp } from 'drizzle-orm/pg-core';\nimport type { InferSelectModel } from 'drizzle-orm';\n\nexport const cacheEntries = pgTable(\n  'cache_entries',\n  {\n    /** Cache key — primary key, text (not uuid) to support arbitrary key namespacing. */\n    key: text('key').primaryKey(),\n    /** Cached value serialised as JSONB. */\n    value: jsonb('value').notNull(),\n    /** NULL means the entry never expires. */\n    expiresAt: timestamp('expires_at', { withTimezone: true }),\n  },\n  // Index: add (expires_at) via migration for cleanup queries\n);\n\nexport type CacheEntry = InferSelectModel<typeof cacheEntries>;\n"],"mappings":";AAUA,SAAS,SAAS,MAAM,OAAO,iBAAiB;AAGzC,IAAM,eAAe;AAAA,EAC1B;AAAA,EACA;AAAA;AAAA,IAEE,KAAK,KAAK,KAAK,EAAE,WAAW;AAAA;AAAA,IAE5B,OAAO,MAAM,OAAO,EAAE,QAAQ;AAAA;AAAA,IAE9B,WAAW,UAAU,cAAc,EAAE,cAAc,KAAK,CAAC;AAAA,EAC3D;AAAA;AAEF;","names":[]}

package/dist/chunk-FI34KYZ5.js

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

package/dist/chunk-FI34KYZ5.js.map

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

package/dist/chunk-FN2PYDPP.js

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

package/dist/chunk-FN2PYDPP.js.map

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

package/dist/chunk-GM3RMJIJ.js

@@ -0,0 +1,92 @@
+import {
+  getEventMetadata
+} from "./chunk-BGULBWKJ.js";
+import {
+  eventPayloadSchemas
+} from "./chunk-JRQO2IOF.js";
+import {
+  MissingTenantIdError
+} from "./chunk-V4AF6DI4.js";
+import {
+  EVENTS_MULTI_TENANT,
+  EVENT_BUS
+} from "./chunk-H5NH7KPE.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/events/generated/bus.ts
+import { Injectable, Inject } from "@nestjs/common";
+import { randomUUID } from "crypto";
+var TypedEventBus = class {
+  constructor(bus, multiTenant) {
+    this.bus = bus;
+    this.multiTenant = multiTenant;
+  }
+  bus;
+  multiTenant;
+  async publish(type, aggregateId, payload, opts) {
+    const meta = getEventMetadata(type);
+    const flag = process.env["CODEGEN_EVENT_VALIDATE"];
+    const shouldValidate = flag === void 0 ? true : flag !== "false" && flag !== "0";
+    if (shouldValidate) {
+      const schema = eventPayloadSchemas[type];
+      if (schema) {
+        const check = schema.safeParse(payload);
+        if (!check.success) {
+          console.warn(
+            `[TypedEventBus] payload validation failed for ${String(type)}:`,
+            check.error.issues
+          );
+        }
+      }
+    }
+    const tenantId = opts?.metadata?.["tenantId"];
+    if (this.multiTenant && (tenantId === void 0 || tenantId === null)) {
+      throw new MissingTenantIdError(type);
+    }
+    const aggregateType = meta.aggregate ?? meta.source ?? meta.destination ?? type;
+    const baseMetadata = { ...opts?.metadata ?? {} };
+    if (meta.tier === "audit") {
+      if (baseMetadata["pool"] !== void 0 || baseMetadata["direction"] !== void 0) {
+        console.debug(
+          `[TypedEventBus] tier:audit event '${String(type)}' had pool/direction in opts.metadata; overriding to null.`
+        );
+      }
+      baseMetadata["pool"] = null;
+      baseMetadata["direction"] = null;
+      baseMetadata["tier"] = "audit";
+    } else {
+      baseMetadata["pool"] = meta.pool;
+      baseMetadata["direction"] = meta.direction;
+      baseMetadata["tier"] = "domain";
+    }
+    baseMetadata["version"] = meta.version;
+    await this.bus.publish(
+      {
+        id: randomUUID(),
+        type,
+        aggregateId,
+        aggregateType,
+        payload,
+        occurredAt: /* @__PURE__ */ new Date(),
+        metadata: baseMetadata
+      },
+      opts?.tx
+    );
+  }
+  subscribe(type, handler) {
+    return this.bus.subscribe(type, handler);
+  }
+};
+TypedEventBus = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(EVENT_BUS)),
+  __decorateParam(1, Inject(EVENTS_MULTI_TENANT))
+], TypedEventBus);
+
+export {
+  TypedEventBus
+};
+//# sourceMappingURL=chunk-GM3RMJIJ.js.map

package/dist/chunk-GM3RMJIJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/events/generated/bus.ts"],"sourcesContent":["// AUTO-GENERATED by @pattern-stack/codegen. Do not edit.\n// Run `codegen entity new --all` to refresh.\n\nimport { Injectable, Inject } from '@nestjs/common';\nimport { randomUUID } from 'crypto';\nimport { EVENT_BUS, EVENTS_MULTI_TENANT } from '../events.tokens';\nimport { MissingTenantIdError } from '../events-errors';\nimport type { IEventBus, DrizzleTransaction } from '../event-bus.protocol';\nimport { eventPayloadSchemas } from './schemas';\nimport { getEventMetadata } from './registry';\nimport type { EventTypeName, EventOfType, PayloadOfType } from './types';\n\n/**\n * Typed facade over IEventBus.\n *\n * Stamps `pool`, `direction`, `tier`, and `version` into `event.metadata`\n * from the generated `eventRegistry` before delegating to\n * `IEventBus.publish()`. Downstream backends (DrizzleEventBus) read those\n * values to populate the explicit `domain_events` columns.\n *\n * Tier stamping (AUDIT-3): every event carries `metadata.tier`, sourced\n * from the registry. For `tier: 'audit'` events, the bus FORCES\n * `metadata.pool = null` and `metadata.direction = null` regardless of\n * any caller-supplied values in `opts.metadata` — audit routing is\n * bus-stamped, not caller-controlled. Caller overrides are silently\n * dropped with a debug-level log (callers should not be specifying these\n * for audit events; see ai-docs/specs/issue-242/plan.md §AUDIT-3).\n *\n * Validation gating (EVT-Q5): `CODEGEN_EVENT_VALIDATE` env flag, default on.\n * Uses `safeParse` + `console.warn` — never throws, so a bad publish does\n * not crash a hot path.\n *\n * Multi-tenancy (EVT-6): when the EventsModule is configured with\n * `multiTenant: true`, every publish must supply `opts.metadata.tenantId`\n * — otherwise `publish()` throws `MissingTenantIdError`. When `multiTenant`\n * is `false` (default), no tenantId is required. If a tenantId IS supplied,\n * it is preserved on `event.metadata` and the Drizzle backend writes it to\n * `domain_events.tenant_id` (EVT-4).\n */\n@Injectable()\nexport class TypedEventBus {\n\tconstructor(\n\t\t@Inject(EVENT_BUS) private readonly bus: IEventBus,\n\t\t@Inject(EVENTS_MULTI_TENANT) private readonly multiTenant: boolean,\n\t) {}\n\n\tasync publish<T extends EventTypeName>(\n\t\ttype: T,\n\t\taggregateId: string,\n\t\tpayload: PayloadOfType<T>,\n\t\topts?: { tx?: DrizzleTransaction; metadata?: Record<string, unknown> },\n\t): Promise<void> {\n\t\tconst meta = getEventMetadata(type);\n\n\t\tconst flag = process.env['CODEGEN_EVENT_VALIDATE'];\n\t\tconst shouldValidate =\n\t\t\tflag === undefined ? true : flag !== 'false' && flag !== '0';\n\t\tif (shouldValidate) {\n\t\t\t// `eventPayloadSchemas` is typed as `Record<EventTypeName, z.ZodType>`,\n\t\t\t// so under `noUncheckedIndexedAccess` the indexed lookup widens\n\t\t\t// to `z.ZodType | undefined`. When no events are registered at\n\t\t\t// codegen time `EventTypeName` degrades to `string` and the\n\t\t\t// schemas object is literally `{}` — the guard below is the\n\t\t\t// honest handling of that empty-registry case (skip validation;\n\t\t\t// it's a warn-only best-effort check per the class docblock).\n\t\t\tconst schema = eventPayloadSchemas[type];\n\t\t\tif (schema) {\n\t\t\t\tconst check = schema.safeParse(payload);\n\t\t\t\tif (!check.success) {\n\t\t\t\t\tconsole.warn(\n\t\t\t\t\t\t`[TypedEventBus] payload validation failed for ${String(type)}:`,\n\t\t\t\t\t\tcheck.error.issues,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tconst tenantId = opts?.metadata?.['tenantId'];\n\t\tif (this.multiTenant && (tenantId === undefined || tenantId === null)) {\n\t\t\tthrow new MissingTenantIdError(type as string);\n\t\t}\n\n\t\tconst aggregateType =\n\t\t\tmeta.aggregate ?? meta.source ?? meta.destination ?? (type as string);\n\n\t\t// AUDIT-3: build metadata with tier-aware routing stamping. For\n\t\t// `tier: 'audit'` events the bus FORCES pool/direction to null,\n\t\t// even if the caller supplied them in opts.metadata. Audit routing\n\t\t// is bus-stamped, not caller-controlled (see plan §AUDIT-3).\n\t\tconst baseMetadata: Record<string, unknown> = { ...(opts?.metadata ?? {}) };\n\t\tif (meta.tier === 'audit') {\n\t\t\tif (\n\t\t\t\tbaseMetadata['pool'] !== undefined ||\n\t\t\t\tbaseMetadata['direction'] !== undefined\n\t\t\t) {\n\t\t\t\tconsole.debug(\n\t\t\t\t\t`[TypedEventBus] tier:audit event '${String(type)}' had pool/direction in opts.metadata; overriding to null.`,\n\t\t\t\t);\n\t\t\t}\n\t\t\tbaseMetadata['pool'] = null;\n\t\t\tbaseMetadata['direction'] = null;\n\t\t\tbaseMetadata['tier'] = 'audit';\n\t\t} else {\n\t\t\tbaseMetadata['pool'] = meta.pool;\n\t\t\tbaseMetadata['direction'] = meta.direction;\n\t\t\tbaseMetadata['tier'] = 'domain';\n\t\t}\n\t\tbaseMetadata['version'] = meta.version;\n\n\t\tawait this.bus.publish(\n\t\t\t{\n\t\t\t\tid: randomUUID(),\n\t\t\t\ttype,\n\t\t\t\taggregateId,\n\t\t\t\taggregateType,\n\t\t\t\tpayload: payload as Record<string, unknown>,\n\t\t\t\toccurredAt: new Date(),\n\t\t\t\tmetadata: baseMetadata,\n\t\t\t},\n\t\t\topts?.tx,\n\t\t);\n\t}\n\n\tsubscribe<T extends EventTypeName>(\n\t\ttype: T,\n\t\thandler: (event: EventOfType<T>) => Promise<void>,\n\t): () => void {\n\t\treturn this.bus.subscribe<EventOfType<T>>(type, handler as never);\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAGA,SAAS,YAAY,cAAc;AACnC,SAAS,kBAAkB;AAoCpB,IAAM,gBAAN,MAAoB;AAAA,EAC1B,YACqC,KACU,aAC7C;AAFmC;AACU;AAAA,EAC5C;AAAA,EAFkC;AAAA,EACU;AAAA,EAG/C,MAAM,QACL,MACA,aACA,SACA,MACgB;AAChB,UAAM,OAAO,iBAAiB,IAAI;AAElC,UAAM,OAAO,QAAQ,IAAI,wBAAwB;AACjD,UAAM,iBACL,SAAS,SAAY,OAAO,SAAS,WAAW,SAAS;AAC1D,QAAI,gBAAgB;AAQnB,YAAM,SAAS,oBAAoB,IAAI;AACvC,UAAI,QAAQ;AACX,cAAM,QAAQ,OAAO,UAAU,OAAO;AACtC,YAAI,CAAC,MAAM,SAAS;AACnB,kBAAQ;AAAA,YACP,iDAAiD,OAAO,IAAI,CAAC;AAAA,YAC7D,MAAM,MAAM;AAAA,UACb;AAAA,QACD;AAAA,MACD;AAAA,IACD;AAEA,UAAM,WAAW,MAAM,WAAW,UAAU;AAC5C,QAAI,KAAK,gBAAgB,aAAa,UAAa,aAAa,OAAO;AACtE,YAAM,IAAI,qBAAqB,IAAc;AAAA,IAC9C;AAEA,UAAM,gBACL,KAAK,aAAa,KAAK,UAAU,KAAK,eAAgB;AAMvD,UAAM,eAAwC,EAAE,GAAI,MAAM,YAAY,CAAC,EAAG;AAC1E,QAAI,KAAK,SAAS,SAAS;AAC1B,UACC,aAAa,MAAM,MAAM,UACzB,aAAa,WAAW,MAAM,QAC7B;AACD,gBAAQ;AAAA,UACP,qCAAqC,OAAO,IAAI,CAAC;AAAA,QAClD;AAAA,MACD;AACA,mBAAa,MAAM,IAAI;AACvB,mBAAa,WAAW,IAAI;AAC5B,mBAAa,MAAM,IAAI;AAAA,IACxB,OAAO;AACN,mBAAa,MAAM,IAAI,KAAK;AAC5B,mBAAa,WAAW,IAAI,KAAK;AACjC,mBAAa,MAAM,IAAI;AAAA,IACxB;AACA,iBAAa,SAAS,IAAI,KAAK;AAE/B,UAAM,KAAK,IAAI;AAAA,MACd;AAAA,QACC,IAAI,WAAW;AAAA,QACf;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,YAAY,oBAAI,KAAK;AAAA,QACrB,UAAU;AAAA,MACX;AAAA,MACA,MAAM;AAAA,IACP;AAAA,EACD;AAAA,EAEA,UACC,MACA,SACa;AACb,WAAO,KAAK,IAAI,UAA0B,MAAM,OAAgB;AAAA,EACjE;AACD;AAzFa,gBAAN;AAAA,EADN,WAAW;AAAA,EAGT,0BAAO,SAAS;AAAA,EAChB,0BAAO,mBAAmB;AAAA,GAHhB;","names":[]}

package/dist/chunk-GYGNEQSC.js

@@ -0,0 +1,9 @@
+// runtime/subsystems/token-key.ts
+var PKG = "@pattern-stack/codegen";
+var tokenKey = (area, name) => `${PKG}.${area}.${name}`;
+
+export {
+  PKG,
+  tokenKey
+};
+//# sourceMappingURL=chunk-GYGNEQSC.js.map

package/dist/chunk-GYGNEQSC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/token-key.ts"],"sourcesContent":["/** Canonical package namespace for cross-boundary DI token keys. MUST be a hardcoded\n *  constant (NOT derived from package.json) so a vendored copy — which lives inside the\n *  CONSUMER's package — produces the identical key and the two copies share the symbol. */\nexport const PKG = '@pattern-stack/codegen';\n// TODO(token-version): if/when a runtime contract version is adopted, inject it HERE only\n//   (e.g. `${PKG}#${ABI}.${area}.${name}`) — this helper is the single chokepoint.\nexport const tokenKey = (area: string, name: string): string => `${PKG}.${area}.${name}`;\n"],"mappings":";AAGO,IAAM,MAAM;AAGZ,IAAM,WAAW,CAAC,MAAc,SAAyB,GAAG,GAAG,IAAI,IAAI,IAAI,IAAI;","names":[]}

package/dist/chunk-H5NH7KPE.js

@@ -0,0 +1,21 @@
+import {
+  tokenKey
+} from "./chunk-GYGNEQSC.js";
+
+// runtime/subsystems/events/events.tokens.ts
+var EVENT_BUS = "EVENT_BUS";
+var EVENT_READ_PORT = "EVENT_READ_PORT";
+var TYPED_EVENT_BUS = "TYPED_EVENT_BUS";
+var EVENTS_MULTI_TENANT = "EVENTS_MULTI_TENANT";
+var REDIS_URL = Symbol.for(tokenKey("events", "redis-url"));
+var EVENTS_MODULE_OPTIONS = "EVENTS_MODULE_OPTIONS";
+
+export {
+  EVENT_BUS,
+  EVENT_READ_PORT,
+  TYPED_EVENT_BUS,
+  EVENTS_MULTI_TENANT,
+  REDIS_URL,
+  EVENTS_MODULE_OPTIONS
+};
+//# sourceMappingURL=chunk-H5NH7KPE.js.map

package/dist/chunk-H5NH7KPE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/events/events.tokens.ts"],"sourcesContent":["/**\n * Injection token for the event bus.\n *\n * String constant (not Symbol) so it matches by value across import boundaries.\n * Matches the token in runtime/constants/tokens.ts — both are 'EVENT_BUS'.\n *\n * Usage in use cases:\n * ```typescript\n * constructor(@Inject(EVENT_BUS) private readonly eventBus: IEventBus) {}\n * ```\n */\nimport { tokenKey } from '../token-key';\n\nexport const EVENT_BUS = 'EVENT_BUS' as const;\n\n/**\n * Injection token for the read-side `IEventReadPort` over `domain_events`\n * (OBS-LIST-1).\n *\n * Bound by `EventsModule.forRoot` to the same backend instance as\n * `EVENT_BUS` for the `drizzle` and `memory` backends (both implement\n * `IEventReadPort`). The `redis` backend retains no history and therefore\n * does NOT provide this token — consumers composing it (e.g. the\n * observability combiner) inject it `@Optional()` and degrade to empty\n * results.\n *\n * String constant (not Symbol) so it matches by value across import\n * boundaries — same convention as `EVENT_BUS`.\n */\nexport const EVENT_READ_PORT = 'EVENT_READ_PORT' as const;\n\n/**\n * Injection token for the generated `TypedEventBus` facade.\n *\n * `TypedEventBus` lives in `runtime/subsystems/events/generated/bus.ts` and\n * wraps `IEventBus` with project-specific `AppDomainEvent`-typed `publish<T>()`\n * and `subscribe<T>()`. Use cases inject this token in preference to\n * `EVENT_BUS` when they want compile-time type safety on event shapes.\n *\n * String constant (not Symbol) so it matches by value across import\n * boundaries — same convention as `EVENT_BUS`.\n *\n * Provider registration lands in EVT-6 (EventsModule wiring); the token is\n * declared here so generated code can import it without depending on the\n * still-being-formalised module.\n */\nexport const TYPED_EVENT_BUS = 'TYPED_EVENT_BUS' as const;\n\n/**\n * Injection token for the resolved multi-tenancy flag.\n *\n * Provided by `EventsModule.forRoot(...)` as `options.multiTenant ?? false`.\n * Consumed by `TypedEventBus` to enforce the tenantId-is-required rule at\n * publish time.\n *\n * String constant (not Symbol) so it matches by value across import\n * boundaries — same convention as the other events tokens. (The jobs\n * subsystem uses Symbols for the analogous token; events chose strings\n * from the start and we keep the file internally consistent.)\n */\nexport const EVENTS_MULTI_TENANT = 'EVENTS_MULTI_TENANT' as const;\n\n/**\n * Injection token for the Redis connection URL used by RedisEventBus.\n * Provided automatically by EventsModule.forRoot({ backend: 'redis' }).\n *\n * ADR-037: namespaced `Symbol.for(...)` (via `tokenKey()`) so it matches by value\n * across runtime copies (the sibling string tokens above are already value-stable).\n * Note the jobs subsystem defines its own `REDIS_URL`-equivalent; this is the\n * events one.\n */\nexport const REDIS_URL = Symbol.for(tokenKey('events', 'redis-url'));\n\n/**\n * Injection token for the resolved `EventsModuleOptions` object.\n *\n * Provided automatically by `EventsModule.forRoot(...)` /\n * `EventsModule.forRootAsync(...)`. Backends that need to observe module\n * configuration (e.g. `DrizzleEventBus` reading `opts.pools` for\n * pool-filtered drain) inject via this token.\n *\n * String-valued (not `Symbol`) so it matches by value across import\n * boundaries — same convention as `EVENT_BUS`.\n */\nexport const EVENTS_MODULE_OPTIONS = 'EVENTS_MODULE_OPTIONS' as const;\n"],"mappings":";;;;;AAaO,IAAM,YAAY;AAgBlB,IAAM,kBAAkB;AAiBxB,IAAM,kBAAkB;AAcxB,IAAM,sBAAsB;AAW5B,IAAM,YAAY,OAAO,IAAI,SAAS,UAAU,WAAW,CAAC;AAa5D,IAAM,wBAAwB;","names":[]}

package/dist/chunk-HNWZFNKP.js

@@ -0,0 +1,168 @@
+// runtime/subsystems/integration/integration-audit.schema.ts
+import {
+  pgEnum,
+  pgTable,
+  uuid,
+  text,
+  jsonb,
+  integer,
+  boolean,
+  timestamp,
+  index,
+  uniqueIndex
+} from "drizzle-orm/pg-core";
+var integrationRunDirectionEnum = pgEnum("integration_run_direction", [
+  "inbound",
+  "outbound"
+]);
+var integrationRunActionEnum = pgEnum("integration_run_action", [
+  "poll",
+  "cdc",
+  "webhook",
+  "manual",
+  "writeback"
+]);
+var integrationRunStatusEnum = pgEnum("integration_run_status", [
+  "running",
+  "success",
+  "no_changes",
+  "failed"
+]);
+var integrationRunItemOperationEnum = pgEnum("integration_run_item_operation", [
+  "created",
+  "updated",
+  "deleted",
+  "noop"
+]);
+var integrationRunItemStatusEnum = pgEnum("integration_run_item_status", [
+  "success",
+  "failed",
+  "skipped"
+]);
+var integrationSubscriptions = pgTable(
+  "integration_subscriptions",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    connectionId: text("connection_id").notNull(),
+    adapter: text("adapter").notNull(),
+    domain: text("domain").notNull(),
+    externalRef: text("external_ref"),
+    enabled: boolean("enabled").notNull().default(true),
+    /**
+     * Per-subscription configuration bag. Strategies type it internally;
+     * e.g. polling strategies stash `{ batchSize, highWatermark }` here.
+     */
+    config: jsonb("config").notNull().default({}).$type(),
+    /**
+     * Opaque cursor persisted by `ICursorStore.put()`. NULL until the first
+     * successful run advances it.
+     */
+    cursor: jsonb("cursor").$type(),
+    lastIntegrationAt: timestamp("last_integration_at", { withTimezone: true }),
+    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text("tenant_id"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
+  },
+  (t) => ({
+    /**
+     * Composite uniqueness per the epic shape. `external_ref` is nullable;
+     * Postgres treats NULLs as distinct in a UNIQUE constraint, which means
+     * two rows with the same `(connection_id, adapter, domain)` and NULL
+     * external_ref are allowed. That's intentional — a subscription with
+     * NULL external_ref covers the full domain, and duplicates there would
+     * be a consumer-layer modeling issue, not a schema concern.
+     */
+    uqIntegrationSubscriptionTuple: uniqueIndex("uq_integration_subscriptions_tuple").on(
+      t.connectionId,
+      t.adapter,
+      t.domain,
+      t.externalRef
+    ),
+    /** Scheduling query: list enabled subscriptions ordered by staleness. */
+    idxIntegrationSubscriptionsEnabledLastIntegration: index(
+      "idx_integration_subscriptions_enabled_last_integration"
+    ).on(t.enabled, t.lastIntegrationAt)
+  })
+);
+var integrationRuns = pgTable(
+  "integration_runs",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    subscriptionId: uuid("subscription_id").notNull().references(() => integrationSubscriptions.id, { onDelete: "cascade" }),
+    direction: integrationRunDirectionEnum("direction").notNull(),
+    action: integrationRunActionEnum("action").notNull(),
+    status: integrationRunStatusEnum("status").notNull().default("running"),
+    recordsFound: integer("records_found").notNull().default(0),
+    recordsProcessed: integer("records_processed").notNull().default(0),
+    cursorBefore: jsonb("cursor_before").$type(),
+    cursorAfter: jsonb("cursor_after").$type(),
+    durationMs: integer("duration_ms"),
+    error: text("error"),
+    startedAt: timestamp("started_at", { withTimezone: true }).notNull().defaultNow(),
+    completedAt: timestamp("completed_at", { withTimezone: true }),
+    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text("tenant_id")
+  },
+  (t) => ({
+    /** Timeline read: "most recent runs for this subscription". */
+    idxIntegrationRunsSubscriptionStartedAt: index(
+      "idx_integration_runs_subscription_started_at"
+    ).on(t.subscriptionId, t.startedAt),
+    /** Stale-run sweeper: "runs that started > N minutes ago and are still running". */
+    idxIntegrationRunsStatusStartedAt: index("idx_integration_runs_status_started_at").on(
+      t.status,
+      t.startedAt
+    )
+  })
+);
+var integrationRunItems = pgTable(
+  "integration_run_items",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    integrationRunId: uuid("integration_run_id").notNull().references(() => integrationRuns.id, { onDelete: "cascade" }),
+    entityType: text("entity_type").notNull(),
+    externalId: text("external_id").notNull(),
+    localId: text("local_id"),
+    operation: integrationRunItemOperationEnum("operation").notNull(),
+    status: integrationRunItemStatusEnum("status").notNull(),
+    /**
+     * Structured per-field diff — ADR-0003 shape enforced by
+     * `FieldDiffSchema.parse` at the recorder service layer.
+     *
+     * Shape: `{ [fieldName]: { from: unknown, to: unknown } }`.
+     * Empty `{}` for `noop` items; `{ [field]: { from: null, to: <value> } }`
+     * for created items; `{ [field]: { from: <value>, to: null } }` for
+     * deleted items.
+     */
+    changedFields: jsonb("changed_fields").notNull().default({}).$type(),
+    title: text("title"),
+    error: text("error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    /** Runtime-enforced when `INTEGRATION_MULTI_TENANT` is true; see SYNC-6. */
+    tenantId: text("tenant_id")
+  },
+  (t) => ({
+    /** Ordered timeline within a run. */
+    idxIntegrationRunItemsRunCreatedAt: index("idx_integration_run_items_run_created_at").on(
+      t.integrationRunId,
+      t.createdAt
+    ),
+    /** Per-record history: "every integration that touched opportunity/$extId". */
+    idxIntegrationRunItemsEntityExternal: index(
+      "idx_integration_run_items_entity_external"
+    ).on(t.entityType, t.externalId)
+  })
+);
+
+export {
+  integrationRunDirectionEnum,
+  integrationRunActionEnum,
+  integrationRunStatusEnum,
+  integrationRunItemOperationEnum,
+  integrationRunItemStatusEnum,
+  integrationSubscriptions,
+  integrationRuns,
+  integrationRunItems
+};
+//# sourceMappingURL=chunk-HNWZFNKP.js.map