@pattern-stack/codegen 0.15.0 → 0.15.2

package/dist/chunk-BPARRK6F.js

@@ -0,0 +1,14 @@
+// runtime/subsystems/auth/protocols/oauth-state-store.ts
+var OAuthStateError = class extends Error {
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+    this.name = "OAuthStateError";
+  }
+  reason;
+};
+
+export {
+  OAuthStateError
+};
+//# sourceMappingURL=chunk-BPARRK6F.js.map

package/dist/chunk-BPARRK6F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/auth/protocols/oauth-state-store.ts"],"sourcesContent":["/**\n * Auth subsystem — `IOAuthStateStore` port.\n *\n * CSRF protection for the OAuth2 authorize-code callback. Generic across\n * providers. The store mints opaque state tokens at /connect time and\n * single-use consumes them at /callback time, returning the original\n * record (userId + optional post-callback redirect path).\n *\n * Concrete backends live under `../backends/`:\n *   - `state-store.memory-backend.ts` — in-process Map (tests/dev).\n *   - `state-store.drizzle-backend.ts` — Postgres (prod).\n *\n * Semantics:\n *   - `generate(record)` → returns an opaque state token; record is stored\n *     under that token until consumed or until TTL expires.\n *   - `consume(state)`   → atomically deletes the entry and returns the\n *     record. Throws on missing, expired, or replayed state. Never returns\n *     null — a missing/expired state is a CSRF signal.\n */\nexport interface OAuthStateRecord {\n  userId: string;\n  /** Optional post-callback redirect path (relative URL). */\n  redirect?: string;\n}\n\nexport interface IOAuthStateStore {\n  /** Mint an opaque state token bound to `record`. Single-use. */\n  generate(record: OAuthStateRecord): Promise<string>;\n  /**\n   * Atomically consume `state`, returning the bound record. Throws on\n   * missing / expired / replayed state.\n   */\n  consume(state: string): Promise<OAuthStateRecord>;\n}\n\n/**\n * Thrown by `IOAuthStateStore.consume` when the state token is unknown,\n * expired, or has already been consumed (replay attempt).\n */\nexport class OAuthStateError extends Error {\n  constructor(\n    message: string,\n    public readonly reason: 'missing' | 'expired',\n  ) {\n    super(message);\n    this.name = 'OAuthStateError';\n  }\n}\n"],"mappings":";AAuCO,IAAM,kBAAN,cAA8B,MAAM;AAAA,EACzC,YACE,SACgB,QAChB;AACA,UAAM,OAAO;AAFG;AAGhB,SAAK,OAAO;AAAA,EACd;AAAA,EAJkB;AAKpB;","names":[]}

package/dist/chunk-CO6LUM72.js

@@ -0,0 +1,59 @@
+import {
+  tokenKey
+} from "./chunk-GYGNEQSC.js";
+
+// runtime/subsystems/jobs/job-handler.base.ts
+var ParentClosePolicy = /* @__PURE__ */ ((ParentClosePolicy2) => {
+  ParentClosePolicy2["Terminate"] = "terminate";
+  ParentClosePolicy2["Cancel"] = "cancel";
+  ParentClosePolicy2["Abandon"] = "abandon";
+  return ParentClosePolicy2;
+})(ParentClosePolicy || {});
+var JobHandlerBase = class {
+};
+var JOB_HANDLER_REGISTRY = /* @__PURE__ */ new Map();
+var JOB_HANDLER_METADATA_KEY = Symbol.for(tokenKey("jobs", "handler-metadata"));
+function JobHandler(type, meta) {
+  return (target) => {
+    if (JOB_HANDLER_REGISTRY.has(type)) {
+      const env = process.env.NODE_ENV;
+      if (env === "production") {
+        throw new Error(
+          `[JobHandler] Duplicate registration for job type '${type}'. Each @JobHandler must declare a unique type.`
+        );
+      }
+      if (env !== "test") {
+        console.warn(
+          `[JobHandler] Duplicate registration for job type '${type}'. Overwriting previous handler \u2014 this is almost certainly a bug.`
+        );
+      }
+    }
+    Reflect.defineMetadata(JOB_HANDLER_METADATA_KEY, { type, meta }, target);
+    JOB_HANDLER_REGISTRY.set(type, {
+      type,
+      meta,
+      handlerClass: target
+    });
+  };
+}
+var HandlerRegistry;
+((HandlerRegistry2) => {
+  function getAll() {
+    return Array.from(JOB_HANDLER_REGISTRY.values());
+  }
+  HandlerRegistry2.getAll = getAll;
+  function get(type) {
+    return JOB_HANDLER_REGISTRY.get(type);
+  }
+  HandlerRegistry2.get = get;
+})(HandlerRegistry || (HandlerRegistry = {}));
+
+export {
+  ParentClosePolicy,
+  JobHandlerBase,
+  JOB_HANDLER_REGISTRY,
+  JOB_HANDLER_METADATA_KEY,
+  JobHandler,
+  HandlerRegistry
+};
+//# sourceMappingURL=chunk-CO6LUM72.js.map

package/dist/chunk-CO6LUM72.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/jobs/job-handler.base.ts"],"sourcesContent":["/**\n * Handler base class, JobContext, @JobHandler decorator, and policy types\n * for the job orchestration domain (ADR-022, JOB-2).\n *\n * User-authored jobs subclass `JobHandlerBase<TInput, TOutput>` and decorate\n * the class with `@JobHandler<TInput>('job_type', meta)`. The decorator\n *   1. stores metadata via `Reflect.defineMetadata` so Nest's reflector can\n *      pick it up at module boot, and\n *   2. populates `JOB_HANDLER_REGISTRY` — a module-singleton map consumed by\n *      `JobWorkerModule` (JOB-5) to materialise `job` rows and resolve\n *      handler classes during claim/execute.\n *\n * No runtime orchestration lives here; this file is a pure type + decorator\n * surface so downstream PRs (JOB-3..JOB-5) can implement against a stable\n * shape.\n */\n// TODO(logging-subsystem): swap to ILogger once ADR-028 lands\nimport type { Logger } from '@nestjs/common';\nimport { tokenKey } from '../token-key';\nimport type { EventOfType, EventTypeName } from '../events/event-registry';\nimport type { JobRun } from './job-orchestrator.protocol';\n\n// ─── ParentClosePolicy ──────────────────────────────────────────────────────\n\n/**\n * What happens to running child runs when a parent enters a terminal state.\n * Stored on the child at spawn; changes to the parent after spawn do NOT\n * retroactively rewrite children.\n */\nexport enum ParentClosePolicy {\n  Terminate = 'terminate',\n  Cancel = 'cancel',\n  Abandon = 'abandon',\n}\n\n// ─── Policy types ───────────────────────────────────────────────────────────\n\nexport interface RetryPolicy {\n  attempts: number;\n  backoff: 'fixed' | 'exponential';\n  baseMs: number;\n  nonRetryableErrors?: string[];\n}\n\nexport interface ConcurrencyPolicy<TInput> {\n  key: (input: TInput) => string;\n  collisionMode: 'queue' | 'reject' | 'replace';\n}\n\nexport interface DedupePolicy<TInput> {\n  key: (input: TInput) => string;\n  windowMs: number;\n}\n\n/**\n * Declarative scope reference. `TScope` is parameterised so JOB-7 can narrow\n * `entity` to the generated `ScopeEntityType` union at the call site without\n * modifying this file (OQ-1 resolution, 2026-04-20).\n */\nexport interface ScopeRef<TInput, TScope extends string = string> {\n  entity: TScope;\n  from: (input: TInput) => string;\n}\n\n/**\n * Bridge trigger authoring shape (BRIDGE-6 follow-up — BRIDGE-6 shipped the\n * generator + runtime for `@JobHandler({ triggers })` but never added the\n * authoring field to this type; the generator's tests scan source as strings,\n * so a real decorator was never compiled and the gap went uncaught).\n *\n * Declared on `@JobHandler({ triggers })`; the codegen bridge-registry\n * generator (`src/cli/shared/bridge-registry-generator.ts`) scans these from\n * source and emits `bridge/generated/registry.ts`, validating each `event`\n * against the generated `eventRegistry` at `gen-all`. The distributed union\n * narrows `map`/`when` per `event`, so callbacks are typed against the event\n * payload (ADR-023, \"typed against PayloadOfType<T>\").\n *\n * Typed against events' generated types — the same `import type` coupling the\n * bridge already has (erased at runtime). `jobs` must NOT import `bridge`, so\n * the post-gen `BridgeTriggerEntry` is deliberately not referenced here;\n * `triggerId`/`jobType` are computed by the generator, not authored.\n */\nexport type JobTrigger<TInput> = {\n  [T in EventTypeName]: {\n    /** Event type that fires this trigger. Validated against `eventRegistry`. */\n    event: T;\n    /** Maps the event to the job input. Inlined verbatim into the registry. */\n    map: (event: EventOfType<T>) => TInput;\n    /** Optional guard; `false` → wrapper records `status='skipped'`. */\n    when?: (event: EventOfType<T>) => boolean;\n  };\n}[EventTypeName];\n\nexport interface JobHandlerMeta<TInput> {\n  pool?: string;\n  scope?: ScopeRef<TInput>;\n  retry?: RetryPolicy;\n  concurrency?: ConcurrencyPolicy<TInput>;\n  dedupe?: DedupePolicy<TInput>;\n  timeoutMs?: number;\n  replayFrom?: 'scratch' | 'last_step' | 'last_checkpoint';\n  /**\n   * Bridge triggers (ADR-023 Tier 3). Codegen scans these into `bridgeRegistry`;\n   * the framework `BridgeDeliveryHandler` starts this job per matched event.\n   * Absent for jobs started directly or via `IEventFlow.publishAndStart`.\n   */\n  triggers?: readonly JobTrigger<TInput>[];\n}\n\n// ─── Runtime option shapes ──────────────────────────────────────────────────\n\nexport interface StepOptions {\n  retry?: RetryPolicy;\n  timeoutMs?: number;\n}\n\nexport interface SpawnChildOptions {\n  closePolicy?: ParentClosePolicy;\n  runAt?: Date;\n  priority?: number;\n  tags?: Record<string, string>;\n}\n\n// ─── JobContext ─────────────────────────────────────────────────────────────\n\nexport interface JobContext<TInput> {\n  readonly input: TInput;\n  readonly run: JobRun;\n  step<TOutput>(\n    stepId: string,\n    fn: () => Promise<TOutput>,\n    opts?: StepOptions,\n  ): Promise<TOutput>;\n  spawnChild(type: string, input: unknown, opts?: SpawnChildOptions): Promise<JobRun>;\n  readonly logger: Logger;\n  // NOT in Phase 1 — deferred to ADR-025:\n  //   waitFor(kind, token, opts)\n  //   signal(token, payload)\n  //   sleep(ms)\n}\n\n// ─── JobHandlerBase ─────────────────────────────────────────────────────────\n\nexport abstract class JobHandlerBase<TInput, TOutput = unknown> {\n  abstract run(ctx: JobContext<TInput>): Promise<TOutput>;\n}\n\n// ─── Registry + decorator ───────────────────────────────────────────────────\n\n/**\n * Module-singleton map keyed by job type. Populated by the `@JobHandler`\n * decorator at class definition time; consumed by `JobWorkerModule` (JOB-5)\n * to upsert `job` rows and resolve handler classes during claim/execute.\n */\nexport const JOB_HANDLER_REGISTRY = new Map<\n  string,\n  {\n    type: string;\n    meta: JobHandlerMeta<unknown>;\n    handlerClass: new (...args: unknown[]) => JobHandlerBase<unknown>;\n  }\n>();\n\n// ADR-037: namespaced `Symbol.for(...)` (via `tokenKey()`) so the reflection-metadata\n// key matches by value across import boundaries (the @JobHandler decorator and the\n// reader may resolve different runtime copies). Distinct from the DI tokens but\n// subject to the same dual-package identity hazard.\nexport const JOB_HANDLER_METADATA_KEY = Symbol.for(tokenKey('jobs', 'handler-metadata'));\n\n/**\n * Class decorator that registers a handler with the job type, the full\n * metadata shape, and the target class constructor.\n *\n * Duplicate-type behaviour (OQ-3, resolved 2026-04-18):\n *   - `NODE_ENV === 'production'` → throw; silent overwrite in prod is a\n *     correctness bug.\n *   - `NODE_ENV === 'test'`       → silent overwrite (tests intentionally\n *     re-register handlers).\n *   - otherwise (dev)             → `console.warn` + overwrite. `console`\n *     is used intentionally instead of the Nest `Logger` — decorators run\n *     at module-load time before any Nest container exists.\n */\nexport function JobHandler<TInput>(\n  type: string,\n  meta: JobHandlerMeta<TInput>,\n): ClassDecorator {\n  return (target) => {\n    if (JOB_HANDLER_REGISTRY.has(type)) {\n      const env = process.env.NODE_ENV;\n      if (env === 'production') {\n        throw new Error(\n          `[JobHandler] Duplicate registration for job type '${type}'. ` +\n            `Each @JobHandler must declare a unique type.`,\n        );\n      }\n      if (env !== 'test') {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `[JobHandler] Duplicate registration for job type '${type}'. ` +\n            `Overwriting previous handler — this is almost certainly a bug.`,\n        );\n      }\n    }\n\n    Reflect.defineMetadata(JOB_HANDLER_METADATA_KEY, { type, meta }, target);\n    JOB_HANDLER_REGISTRY.set(type, {\n      type,\n      meta: meta as JobHandlerMeta<unknown>,\n      handlerClass: target as unknown as new (\n        ...args: unknown[]\n      ) => JobHandlerBase<unknown>,\n    });\n  };\n}\n\n// ─── HandlerRegistry — read helpers consumed by JobWorkerModule (JOB-5) ─────\n\n/**\n * Single entry shape returned by `HandlerRegistry.getAll()` / `.get()` and\n * exposed to `JobWorkerModule.onModuleInit` for boot-time upserts.\n *\n * Structurally compatible with `IJobOrchestrator.upsertJobRows`'s\n * `JobUpsertEntry` so the worker module can pass entries through verbatim\n * without re-mapping.\n */\nexport interface HandlerRegistryEntry {\n  type: string;\n  meta: JobHandlerMeta<unknown>;\n  handlerClass: new (...args: unknown[]) => JobHandlerBase<unknown>;\n}\n\n/**\n * Read facade over `JOB_HANDLER_REGISTRY`. The decorator's write path is\n * unchanged; this namespace exists so consumers (the worker module, tests)\n * don't import the raw `Map` and accidentally mutate it.\n */\nexport namespace HandlerRegistry {\n  /** All registered entries in insertion order. */\n  export function getAll(): HandlerRegistryEntry[] {\n    return Array.from(JOB_HANDLER_REGISTRY.values());\n  }\n\n  /** Lookup by job type, or `undefined` if no `@JobHandler` is registered. */\n  export function get(type: string): HandlerRegistryEntry | undefined {\n    return JOB_HANDLER_REGISTRY.get(type);\n  }\n}\n"],"mappings":";;;;;AA6BO,IAAK,oBAAL,kBAAKA,uBAAL;AACL,EAAAA,mBAAA,eAAY;AACZ,EAAAA,mBAAA,YAAS;AACT,EAAAA,mBAAA,aAAU;AAHA,SAAAA;AAAA,GAAA;AAkHL,IAAe,iBAAf,MAAyD;AAEhE;AASO,IAAM,uBAAuB,oBAAI,IAOtC;AAMK,IAAM,2BAA2B,OAAO,IAAI,SAAS,QAAQ,kBAAkB,CAAC;AAehF,SAAS,WACd,MACA,MACgB;AAChB,SAAO,CAAC,WAAW;AACjB,QAAI,qBAAqB,IAAI,IAAI,GAAG;AAClC,YAAM,MAAM,QAAQ,IAAI;AACxB,UAAI,QAAQ,cAAc;AACxB,cAAM,IAAI;AAAA,UACR,qDAAqD,IAAI;AAAA,QAE3D;AAAA,MACF;AACA,UAAI,QAAQ,QAAQ;AAElB,gBAAQ;AAAA,UACN,qDAAqD,IAAI;AAAA,QAE3D;AAAA,MACF;AAAA,IACF;AAEA,YAAQ,eAAe,0BAA0B,EAAE,MAAM,KAAK,GAAG,MAAM;AACvE,yBAAqB,IAAI,MAAM;AAAA,MAC7B;AAAA,MACA;AAAA,MACA,cAAc;AAAA,IAGhB,CAAC;AAAA,EACH;AACF;AAuBO,IAAU;AAAA,CAAV,CAAUC,qBAAV;AAEE,WAAS,SAAiC;AAC/C,WAAO,MAAM,KAAK,qBAAqB,OAAO,CAAC;AAAA,EACjD;AAFO,EAAAA,iBAAS;AAKT,WAAS,IAAI,MAAgD;AAClE,WAAO,qBAAqB,IAAI,IAAI;AAAA,EACtC;AAFO,EAAAA,iBAAS;AAAA,GAPD;","names":["ParentClosePolicy","HandlerRegistry"]}

package/dist/chunk-COGHTKXY.js

@@ -0,0 +1,84 @@
+import {
+  DrizzleCacheService
+} from "./chunk-T6C4LFLC.js";
+import {
+  MemoryCacheService
+} from "./chunk-IF5I3DAA.js";
+import {
+  CACHE,
+  CACHE_DEFAULT_TTL
+} from "./chunk-L6FTY45T.js";
+import {
+  DRIZZLE
+} from "./chunk-U64T4YZE.js";
+import {
+  __decorateClass
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/cache/cache.module.ts
+import { Module } from "@nestjs/common";
+var CACHE_MODULE_OPTIONS = "CACHE_MODULE_OPTIONS";
+function buildCacheAsync(options, db) {
+  const defaultTtl = options.defaultTtl ?? null;
+  if (options.backend === "drizzle") {
+    if (!db) {
+      throw new Error(
+        "CacheModule.forRootAsync: backend: 'drizzle' selected but DRIZZLE provider is not available. Ensure DatabaseModule (or another provider exposing DRIZZLE) is imported before CacheModule.forRootAsync."
+      );
+    }
+    return new DrizzleCacheService(db, defaultTtl);
+  }
+  return new MemoryCacheService(defaultTtl);
+}
+var CacheModule = class {
+  static forRootAsync(asyncOptions) {
+    return {
+      module: CacheModule,
+      global: true,
+      imports: asyncOptions.imports ?? [],
+      providers: [
+        {
+          provide: CACHE_MODULE_OPTIONS,
+          useFactory: asyncOptions.useFactory,
+          inject: asyncOptions.inject ?? []
+        },
+        {
+          provide: CACHE,
+          useFactory: (options, db) => buildCacheAsync(options, db),
+          inject: [CACHE_MODULE_OPTIONS, { token: DRIZZLE, optional: true }]
+        },
+        // Alias the concrete classes to CACHE for typed injection.
+        { provide: DrizzleCacheService, useExisting: CACHE },
+        { provide: MemoryCacheService, useExisting: CACHE }
+      ],
+      exports: [CACHE]
+    };
+  }
+  static forRoot(options = { backend: "drizzle" }) {
+    const ConcreteClass = options.backend === "drizzle" ? DrizzleCacheService : MemoryCacheService;
+    const providers = options.defaultTtl !== void 0 ? [
+      // Register the concrete class as the canonical instance
+      ConcreteClass,
+      { provide: CACHE_DEFAULT_TTL, useValue: options.defaultTtl },
+      // CACHE token points to the same instance — no duplicate
+      { provide: CACHE, useExisting: ConcreteClass }
+    ] : [
+      ConcreteClass,
+      { provide: CACHE, useExisting: ConcreteClass }
+    ];
+    return {
+      module: CacheModule,
+      global: true,
+      providers,
+      exports: [CACHE]
+    };
+  }
+};
+CacheModule = __decorateClass([
+  Module({})
+], CacheModule);
+
+export {
+  CacheModule
+};
+//# sourceMappingURL=chunk-COGHTKXY.js.map

package/dist/chunk-COGHTKXY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/cache/cache.module.ts"],"sourcesContent":["/**\n * CacheModule — DynamicModule factory for the cache subsystem.\n *\n * Usage in AppModule:\n * ```typescript\n * CacheModule.forRoot({ backend: 'drizzle', defaultTtl: 300 })\n * ```\n *\n * Usage in tests:\n * ```typescript\n * CacheModule.forRoot({ backend: 'memory' })\n * ```\n *\n * `global: true` means any module that needs ICacheService can inject CACHE\n * directly without importing CacheModule. Register once in AppModule.\n *\n * The drizzle backend requires DRIZZLE to be provided globally (e.g., via DatabaseModule).\n *\n * Async configuration (`forRootAsync`):\n * The async factory returns `CacheModuleOptions`; the CACHE provider then\n * receives DRIZZLE (for the drizzle backend) through Nest DI rather than\n * hand-constructing with `null` — see issue #108 which flagged the same\n * shape in `EventsModule.forRootAsync`. DRIZZLE is injected as optional\n * so memory-backend consumers are not required to wire DatabaseModule.\n */\nimport { Module, type DynamicModule } from '@nestjs/common';\nimport { CACHE, CACHE_DEFAULT_TTL } from './cache.tokens';\nimport { DRIZZLE } from '../../constants/tokens';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport { DrizzleCacheService } from './cache.drizzle-backend';\nimport { MemoryCacheService } from './cache.memory-backend';\n\nexport interface CacheModuleOptions {\n  backend: 'drizzle' | 'memory';\n  /** Default TTL in seconds for entries that don't specify their own TTL. Null = no expiry. */\n  defaultTtl?: number;\n}\n\nexport interface CacheModuleAsyncOptions {\n  useFactory: (...args: unknown[]) => Promise<CacheModuleOptions> | CacheModuleOptions;\n  inject?: unknown[];\n  imports?: unknown[];\n}\n\n/** String token for the resolved CacheModuleOptions in the async path. */\nconst CACHE_MODULE_OPTIONS = 'CACHE_MODULE_OPTIONS' as const;\n\nfunction buildCacheAsync(\n  options: CacheModuleOptions,\n  db: DrizzleClient | null,\n): DrizzleCacheService | MemoryCacheService {\n  const defaultTtl = options.defaultTtl ?? null;\n  if (options.backend === 'drizzle') {\n    if (!db) {\n      throw new Error(\n        \"CacheModule.forRootAsync: backend: 'drizzle' selected but DRIZZLE provider is not available. \" +\n          'Ensure DatabaseModule (or another provider exposing DRIZZLE) is imported before CacheModule.forRootAsync.',\n      );\n    }\n    return new DrizzleCacheService(db, defaultTtl);\n  }\n  return new MemoryCacheService(defaultTtl);\n}\n\n@Module({})\nexport class CacheModule {\n  static forRootAsync(asyncOptions: CacheModuleAsyncOptions): DynamicModule {\n    return {\n      module: CacheModule,\n      global: true,\n      imports: (asyncOptions.imports ?? []) as Parameters<typeof Module>[0]['imports'],\n      providers: [\n        {\n          provide: CACHE_MODULE_OPTIONS,\n          useFactory: asyncOptions.useFactory,\n          inject: (asyncOptions.inject ?? []) as (string | symbol | Function)[],\n        },\n        {\n          provide: CACHE,\n          useFactory: (options: CacheModuleOptions, db: DrizzleClient | null) =>\n            buildCacheAsync(options, db),\n          inject: [CACHE_MODULE_OPTIONS, { token: DRIZZLE, optional: true }],\n        },\n        // Alias the concrete classes to CACHE for typed injection.\n        { provide: DrizzleCacheService, useExisting: CACHE },\n        { provide: MemoryCacheService, useExisting: CACHE },\n      ],\n      exports: [CACHE],\n    };\n  }\n\n  static forRoot(options: CacheModuleOptions = { backend: 'drizzle' }): DynamicModule {\n    const ConcreteClass = options.backend === 'drizzle' ? DrizzleCacheService : MemoryCacheService;\n\n    const providers = options.defaultTtl !== undefined\n      ? [\n          // Register the concrete class as the canonical instance\n          ConcreteClass,\n          { provide: CACHE_DEFAULT_TTL, useValue: options.defaultTtl },\n          // CACHE token points to the same instance — no duplicate\n          { provide: CACHE, useExisting: ConcreteClass },\n        ]\n      : [\n          ConcreteClass,\n          { provide: CACHE, useExisting: ConcreteClass },\n        ];\n\n    return {\n      module: CacheModule,\n      global: true,\n      providers,\n      exports: [CACHE],\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAyBA,SAAS,cAAkC;AAoB3C,IAAM,uBAAuB;AAE7B,SAAS,gBACP,SACA,IAC0C;AAC1C,QAAM,aAAa,QAAQ,cAAc;AACzC,MAAI,QAAQ,YAAY,WAAW;AACjC,QAAI,CAAC,IAAI;AACP,YAAM,IAAI;AAAA,QACR;AAAA,MAEF;AAAA,IACF;AACA,WAAO,IAAI,oBAAoB,IAAI,UAAU;AAAA,EAC/C;AACA,SAAO,IAAI,mBAAmB,UAAU;AAC1C;AAGO,IAAM,cAAN,MAAkB;AAAA,EACvB,OAAO,aAAa,cAAsD;AACxE,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,SAAU,aAAa,WAAW,CAAC;AAAA,MACnC,WAAW;AAAA,QACT;AAAA,UACE,SAAS;AAAA,UACT,YAAY,aAAa;AAAA,UACzB,QAAS,aAAa,UAAU,CAAC;AAAA,QACnC;AAAA,QACA;AAAA,UACE,SAAS;AAAA,UACT,YAAY,CAAC,SAA6B,OACxC,gBAAgB,SAAS,EAAE;AAAA,UAC7B,QAAQ,CAAC,sBAAsB,EAAE,OAAO,SAAS,UAAU,KAAK,CAAC;AAAA,QACnE;AAAA;AAAA,QAEA,EAAE,SAAS,qBAAqB,aAAa,MAAM;AAAA,QACnD,EAAE,SAAS,oBAAoB,aAAa,MAAM;AAAA,MACpD;AAAA,MACA,SAAS,CAAC,KAAK;AAAA,IACjB;AAAA,EACF;AAAA,EAEA,OAAO,QAAQ,UAA8B,EAAE,SAAS,UAAU,GAAkB;AAClF,UAAM,gBAAgB,QAAQ,YAAY,YAAY,sBAAsB;AAE5E,UAAM,YAAY,QAAQ,eAAe,SACrC;AAAA;AAAA,MAEE;AAAA,MACA,EAAE,SAAS,mBAAmB,UAAU,QAAQ,WAAW;AAAA;AAAA,MAE3D,EAAE,SAAS,OAAO,aAAa,cAAc;AAAA,IAC/C,IACA;AAAA,MACE;AAAA,MACA,EAAE,SAAS,OAAO,aAAa,cAAc;AAAA,IAC/C;AAEJ,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR;AAAA,MACA,SAAS,CAAC,KAAK;AAAA,IACjB;AAAA,EACF;AACF;AAjDa,cAAN;AAAA,EADN,OAAO,CAAC,CAAC;AAAA,GACG;","names":[]}

package/dist/chunk-DCCZB4UC.js

@@ -0,0 +1,100 @@
+import {
+  assertTenantId
+} from "./chunk-MZ6GV4YF.js";
+import {
+  integrationSubscriptions
+} from "./chunk-HNWZFNKP.js";
+import {
+  INTEGRATION_MULTI_TENANT
+} from "./chunk-S7C6TIIF.js";
+import {
+  DRIZZLE
+} from "./chunk-U64T4YZE.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/integration/integration-cursor-store.drizzle-backend.ts
+import { Inject, Injectable, Optional } from "@nestjs/common";
+import { and, desc, eq } from "drizzle-orm";
+var PostgresCursorStore = class {
+  constructor(db, multiTenant) {
+    this.db = db;
+    this.multiTenant = multiTenant ?? false;
+  }
+  db;
+  multiTenant;
+  async get(subscriptionId, tenantId) {
+    const where = this.buildWhere(subscriptionId, tenantId, "cursor.get");
+    const rows = await this.db.select({ cursor: integrationSubscriptions.cursor }).from(integrationSubscriptions).where(where).limit(1);
+    if (rows.length === 0) return null;
+    return rows[0]?.cursor ?? null;
+  }
+  async put(subscriptionId, cursor, tenantId) {
+    const where = this.buildWhere(subscriptionId, tenantId, "cursor.put");
+    await this.db.update(integrationSubscriptions).set({
+      cursor,
+      lastIntegrationAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    }).where(where);
+  }
+  async listAll(tenantId) {
+    assertTenantId(tenantId, {
+      multiTenant: this.multiTenant,
+      operation: "cursor.listAll"
+    });
+    const where = this.multiTenant ? eq(integrationSubscriptions.tenantId, tenantId) : void 0;
+    const rows = await this.db.select({
+      id: integrationSubscriptions.id,
+      connectionId: integrationSubscriptions.connectionId,
+      adapter: integrationSubscriptions.adapter,
+      domain: integrationSubscriptions.domain,
+      externalRef: integrationSubscriptions.externalRef,
+      cursor: integrationSubscriptions.cursor,
+      lastIntegrationAt: integrationSubscriptions.lastIntegrationAt,
+      updatedAt: integrationSubscriptions.updatedAt,
+      tenantId: integrationSubscriptions.tenantId
+    }).from(integrationSubscriptions).where(where).orderBy(desc(integrationSubscriptions.updatedAt));
+    return rows.map((row) => ({
+      subscriptionId: row.id,
+      connectionId: row.connectionId,
+      adapter: row.adapter,
+      domain: row.domain,
+      externalRef: row.externalRef,
+      cursor: row.cursor ?? null,
+      lastIntegrationAt: row.lastIntegrationAt,
+      updatedAt: row.updatedAt,
+      tenantId: row.tenantId
+    }));
+  }
+  /**
+   * Centralized WHERE clause — `get` and `put` share identical semantics.
+   * Drift here would let a caller read under one tenancy rule and write
+   * under another.
+   */
+  buildWhere(subscriptionId, tenantId, operation) {
+    assertTenantId(tenantId, {
+      multiTenant: this.multiTenant,
+      operation
+    });
+    if (this.multiTenant) {
+      return and(
+        eq(integrationSubscriptions.id, subscriptionId),
+        eq(integrationSubscriptions.tenantId, tenantId)
+      );
+    }
+    return eq(integrationSubscriptions.id, subscriptionId);
+  }
+};
+PostgresCursorStore = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(DRIZZLE)),
+  __decorateParam(1, Optional()),
+  __decorateParam(1, Inject(INTEGRATION_MULTI_TENANT))
+], PostgresCursorStore);
+
+export {
+  PostgresCursorStore
+};
+//# sourceMappingURL=chunk-DCCZB4UC.js.map

package/dist/chunk-DCCZB4UC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/integration/integration-cursor-store.drizzle-backend.ts"],"sourcesContent":["/**\n * PostgresCursorStore — Drizzle-backed `ICursorStore` (SYNC-4).\n *\n * Reads/writes `integration_subscriptions.cursor` directly — no service\n * composition. Consumers that want a service layer around subscriptions\n * wire it themselves; the port's contract is just cursor persistence.\n *\n * ## What `put` stamps\n *\n * `put` writes three columns in one statement: `cursor`, `last_integration_at`,\n * and `updated_at`. Rationale: SYNC-1's scheduling index\n * `(enabled, last_integration_at)` is useless if `last_integration_at` doesn't advance\n * with every cursor put. Every real consumer needs this stamped, so\n * bundling it here avoids every consumer wrapping the port in a service\n * layer just to stamp a timestamp.\n *\n * ## Multi-tenancy\n *\n * When `INTEGRATION_MULTI_TENANT` is true (SYNC-6):\n *   - every read/write is scoped by `AND tenant_id = $tenantId`\n *   - a null/missing `tenantId` throws `MissingTenantIdError` via the\n *     shared `assertTenantId` helper (one message shape across the\n *     orchestrator + both backends, SYNC-6)\n *   - explicit `null` also throws — matches JOB-8 / EVT-6 strict-enforcement\n *\n * When the flag is off, `tenantId` is ignored. Cross-tenant isolation is\n * the caller's problem in single-tenant deployments.\n */\nimport { Inject, Injectable, Optional } from '@nestjs/common';\nimport { and, desc, eq, type SQL } from 'drizzle-orm';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport { DRIZZLE } from '../../constants/tokens';\nimport type {\n  CursorSnapshot,\n  ICursorStore,\n} from './integration-cursor-store.protocol';\nimport { integrationSubscriptions } from './integration-audit.schema';\nimport { INTEGRATION_MULTI_TENANT } from './integration.tokens';\nimport { assertTenantId } from './integration-errors';\n\n@Injectable()\nexport class PostgresCursorStore implements ICursorStore {\n  private readonly multiTenant: boolean;\n\n  constructor(\n    @Inject(DRIZZLE) private readonly db: DrizzleClient,\n    @Optional() @Inject(INTEGRATION_MULTI_TENANT) multiTenant?: boolean,\n  ) {\n    this.multiTenant = multiTenant ?? false;\n  }\n\n  async get(\n    subscriptionId: string,\n    tenantId?: string | null,\n  ): Promise<unknown | null> {\n    const where = this.buildWhere(subscriptionId, tenantId, 'cursor.get');\n\n    const rows = await this.db\n      .select({ cursor: integrationSubscriptions.cursor })\n      .from(integrationSubscriptions)\n      .where(where)\n      .limit(1);\n\n    if (rows.length === 0) return null;\n    return rows[0]?.cursor ?? null;\n  }\n\n  async put(\n    subscriptionId: string,\n    cursor: unknown,\n    tenantId?: string | null,\n  ): Promise<void> {\n    const where = this.buildWhere(subscriptionId, tenantId, 'cursor.put');\n\n    await this.db\n      .update(integrationSubscriptions)\n      .set({\n        cursor,\n        lastIntegrationAt: new Date(),\n        updatedAt: new Date(),\n      })\n      .where(where);\n  }\n\n  async listAll(tenantId?: string | null): Promise<CursorSnapshot[]> {\n    assertTenantId(tenantId, {\n      multiTenant: this.multiTenant,\n      operation: 'cursor.listAll',\n    });\n\n    const where = this.multiTenant\n      ? eq(integrationSubscriptions.tenantId, tenantId as string)\n      : undefined;\n\n    const rows = await this.db\n      .select({\n        id: integrationSubscriptions.id,\n        connectionId: integrationSubscriptions.connectionId,\n        adapter: integrationSubscriptions.adapter,\n        domain: integrationSubscriptions.domain,\n        externalRef: integrationSubscriptions.externalRef,\n        cursor: integrationSubscriptions.cursor,\n        lastIntegrationAt: integrationSubscriptions.lastIntegrationAt,\n        updatedAt: integrationSubscriptions.updatedAt,\n        tenantId: integrationSubscriptions.tenantId,\n      })\n      .from(integrationSubscriptions)\n      .where(where)\n      .orderBy(desc(integrationSubscriptions.updatedAt));\n\n    return rows.map((row) => ({\n      subscriptionId: row.id,\n      connectionId: row.connectionId,\n      adapter: row.adapter,\n      domain: row.domain,\n      externalRef: row.externalRef,\n      cursor: row.cursor ?? null,\n      lastIntegrationAt: row.lastIntegrationAt,\n      updatedAt: row.updatedAt,\n      tenantId: row.tenantId,\n    }));\n  }\n\n  /**\n   * Centralized WHERE clause — `get` and `put` share identical semantics.\n   * Drift here would let a caller read under one tenancy rule and write\n   * under another.\n   */\n  private buildWhere(\n    subscriptionId: string,\n    tenantId: string | null | undefined,\n    operation: string,\n  ): SQL | undefined {\n    assertTenantId(tenantId, {\n      multiTenant: this.multiTenant,\n      operation,\n    });\n    if (this.multiTenant) {\n      return and(\n        eq(integrationSubscriptions.id, subscriptionId),\n        eq(integrationSubscriptions.tenantId, tenantId as string),\n      );\n    }\n    return eq(integrationSubscriptions.id, subscriptionId);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA4BA,SAAS,QAAQ,YAAY,gBAAgB;AAC7C,SAAS,KAAK,MAAM,UAAoB;AAYjC,IAAM,sBAAN,MAAkD;AAAA,EAGvD,YACoC,IACY,aAC9C;AAFkC;AAGlC,SAAK,cAAc,eAAe;AAAA,EACpC;AAAA,EAJoC;AAAA,EAHnB;AAAA,EASjB,MAAM,IACJ,gBACA,UACyB;AACzB,UAAM,QAAQ,KAAK,WAAW,gBAAgB,UAAU,YAAY;AAEpE,UAAM,OAAO,MAAM,KAAK,GACrB,OAAO,EAAE,QAAQ,yBAAyB,OAAO,CAAC,EAClD,KAAK,wBAAwB,EAC7B,MAAM,KAAK,EACX,MAAM,CAAC;AAEV,QAAI,KAAK,WAAW,EAAG,QAAO;AAC9B,WAAO,KAAK,CAAC,GAAG,UAAU;AAAA,EAC5B;AAAA,EAEA,MAAM,IACJ,gBACA,QACA,UACe;AACf,UAAM,QAAQ,KAAK,WAAW,gBAAgB,UAAU,YAAY;AAEpE,UAAM,KAAK,GACR,OAAO,wBAAwB,EAC/B,IAAI;AAAA,MACH;AAAA,MACA,mBAAmB,oBAAI,KAAK;AAAA,MAC5B,WAAW,oBAAI,KAAK;AAAA,IACtB,CAAC,EACA,MAAM,KAAK;AAAA,EAChB;AAAA,EAEA,MAAM,QAAQ,UAAqD;AACjE,mBAAe,UAAU;AAAA,MACvB,aAAa,KAAK;AAAA,MAClB,WAAW;AAAA,IACb,CAAC;AAED,UAAM,QAAQ,KAAK,cACf,GAAG,yBAAyB,UAAU,QAAkB,IACxD;AAEJ,UAAM,OAAO,MAAM,KAAK,GACrB,OAAO;AAAA,MACN,IAAI,yBAAyB;AAAA,MAC7B,cAAc,yBAAyB;AAAA,MACvC,SAAS,yBAAyB;AAAA,MAClC,QAAQ,yBAAyB;AAAA,MACjC,aAAa,yBAAyB;AAAA,MACtC,QAAQ,yBAAyB;AAAA,MACjC,mBAAmB,yBAAyB;AAAA,MAC5C,WAAW,yBAAyB;AAAA,MACpC,UAAU,yBAAyB;AAAA,IACrC,CAAC,EACA,KAAK,wBAAwB,EAC7B,MAAM,KAAK,EACX,QAAQ,KAAK,yBAAyB,SAAS,CAAC;AAEnD,WAAO,KAAK,IAAI,CAAC,SAAS;AAAA,MACxB,gBAAgB,IAAI;AAAA,MACpB,cAAc,IAAI;AAAA,MAClB,SAAS,IAAI;AAAA,MACb,QAAQ,IAAI;AAAA,MACZ,aAAa,IAAI;AAAA,MACjB,QAAQ,IAAI,UAAU;AAAA,MACtB,mBAAmB,IAAI;AAAA,MACvB,WAAW,IAAI;AAAA,MACf,UAAU,IAAI;AAAA,IAChB,EAAE;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOQ,WACN,gBACA,UACA,WACiB;AACjB,mBAAe,UAAU;AAAA,MACvB,aAAa,KAAK;AAAA,MAClB;AAAA,IACF,CAAC;AACD,QAAI,KAAK,aAAa;AACpB,aAAO;AAAA,QACL,GAAG,yBAAyB,IAAI,cAAc;AAAA,QAC9C,GAAG,yBAAyB,UAAU,QAAkB;AAAA,MAC1D;AAAA,IACF;AACA,WAAO,GAAG,yBAAyB,IAAI,cAAc;AAAA,EACvD;AACF;AAxGa,sBAAN;AAAA,EADN,WAAW;AAAA,EAKP,0BAAO,OAAO;AAAA,EACd,4BAAS;AAAA,EAAG,0BAAO,wBAAwB;AAAA,GALnC;","names":[]}

package/dist/chunk-DKKFTHHI.js

@@ -0,0 +1,53 @@
+import {
+  NoopAnalyticsBackend
+} from "./chunk-J37YWU7Y.js";
+import {
+  CubeAnalyticsBackend
+} from "./chunk-7B3RYX45.js";
+import {
+  ANALYTICS_QUERY,
+  CUBE_API_SECRET,
+  CUBE_API_URL
+} from "./chunk-6I7ULIN6.js";
+import {
+  __decorateClass
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/analytics/analytics.module.ts
+import { Module } from "@nestjs/common";
+var AnalyticsModule = class {
+  static forRoot(options = { backend: "noop" }) {
+    if (options.backend === "cube") {
+      return {
+        module: AnalyticsModule,
+        global: true,
+        providers: [
+          {
+            provide: CUBE_API_URL,
+            useValue: process.env["CUBE_API_URL"] ?? "http://localhost:4000/cubejs-api/v1"
+          },
+          {
+            provide: CUBE_API_SECRET,
+            useValue: process.env["CUBE_API_SECRET"] ?? ""
+          },
+          { provide: ANALYTICS_QUERY, useClass: CubeAnalyticsBackend }
+        ],
+        exports: [ANALYTICS_QUERY]
+      };
+    }
+    return {
+      module: AnalyticsModule,
+      global: true,
+      providers: [{ provide: ANALYTICS_QUERY, useClass: NoopAnalyticsBackend }],
+      exports: [ANALYTICS_QUERY]
+    };
+  }
+};
+AnalyticsModule = __decorateClass([
+  Module({})
+], AnalyticsModule);
+
+export {
+  AnalyticsModule
+};
+//# sourceMappingURL=chunk-DKKFTHHI.js.map

package/dist/chunk-DKKFTHHI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/analytics/analytics.module.ts"],"sourcesContent":["/**\n * AnalyticsModule — DynamicModule factory for the analytics query subsystem.\n *\n * Register once in AppModule:\n * ```typescript\n * @Module({\n *   imports: [\n *     AnalyticsModule.forRoot({ backend: 'cube' }),\n *   ],\n * })\n * export class AppModule {}\n * ```\n *\n * Tests swap to the noop backend without touching application code:\n * ```typescript\n * Test.createTestingModule({\n *   imports: [AnalyticsModule.forRoot({ backend: 'noop' })],\n * });\n * ```\n *\n * `global: true` means entity modules do not need to import AnalyticsModule\n * individually — the ANALYTICS_QUERY token is available project-wide.\n */\nimport { Module, type DynamicModule } from '@nestjs/common';\nimport { ANALYTICS_QUERY, CUBE_API_URL, CUBE_API_SECRET } from './analytics.tokens';\nimport { CubeAnalyticsBackend } from './cube-backend';\nimport { NoopAnalyticsBackend } from './noop-backend';\n\nexport interface AnalyticsModuleOptions {\n  backend: 'cube' | 'noop';\n}\n\n@Module({})\nexport class AnalyticsModule {\n  static forRoot(\n    options: AnalyticsModuleOptions = { backend: 'noop' },\n  ): DynamicModule {\n    if (options.backend === 'cube') {\n      return {\n        module: AnalyticsModule,\n        global: true,\n        providers: [\n          {\n            provide: CUBE_API_URL,\n            useValue: process.env['CUBE_API_URL'] ?? 'http://localhost:4000/cubejs-api/v1',\n          },\n          {\n            provide: CUBE_API_SECRET,\n            useValue: process.env['CUBE_API_SECRET'] ?? '',\n          },\n          { provide: ANALYTICS_QUERY, useClass: CubeAnalyticsBackend },\n        ],\n        exports: [ANALYTICS_QUERY],\n      };\n    }\n\n    return {\n      module: AnalyticsModule,\n      global: true,\n      providers: [{ provide: ANALYTICS_QUERY, useClass: NoopAnalyticsBackend }],\n      exports: [ANALYTICS_QUERY],\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAuBA,SAAS,cAAkC;AAUpC,IAAM,kBAAN,MAAsB;AAAA,EAC3B,OAAO,QACL,UAAkC,EAAE,SAAS,OAAO,GACrC;AACf,QAAI,QAAQ,YAAY,QAAQ;AAC9B,aAAO;AAAA,QACL,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,WAAW;AAAA,UACT;AAAA,YACE,SAAS;AAAA,YACT,UAAU,QAAQ,IAAI,cAAc,KAAK;AAAA,UAC3C;AAAA,UACA;AAAA,YACE,SAAS;AAAA,YACT,UAAU,QAAQ,IAAI,iBAAiB,KAAK;AAAA,UAC9C;AAAA,UACA,EAAE,SAAS,iBAAiB,UAAU,qBAAqB;AAAA,QAC7D;AAAA,QACA,SAAS,CAAC,eAAe;AAAA,MAC3B;AAAA,IACF;AAEA,WAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,WAAW,CAAC,EAAE,SAAS,iBAAiB,UAAU,qBAAqB,CAAC;AAAA,MACxE,SAAS,CAAC,eAAe;AAAA,IAC3B;AAAA,EACF;AACF;AA9Ba,kBAAN;AAAA,EADN,OAAO,CAAC,CAAC;AAAA,GACG;","names":[]}

package/dist/chunk-DV4RV2DC.js

@@ -0,0 +1,59 @@
+import {
+  jobSteps
+} from "./chunk-OKXZ63IA.js";
+import {
+  DRIZZLE
+} from "./chunk-U64T4YZE.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/jobs/job-step-service.drizzle-backend.ts
+import { Inject, Injectable } from "@nestjs/common";
+import { and, eq } from "drizzle-orm";
+var DrizzleJobStepService = class {
+  constructor(db) {
+    this.db = db;
+  }
+  db;
+  async recordStep(input) {
+    const values = {
+      jobRunId: input.jobRunId,
+      stepId: input.stepId,
+      kind: input.kind,
+      seq: input.seq,
+      status: input.status,
+      input: input.input ?? null,
+      output: input.output ?? null,
+      error: input.error ?? null,
+      attempts: input.attempts ?? 0,
+      startedAt: input.startedAt ?? null,
+      finishedAt: input.finishedAt ?? null
+    };
+    const [row] = await this.db.insert(jobSteps).values(values).onConflictDoUpdate({
+      target: [jobSteps.jobRunId, jobSteps.stepId],
+      set: {
+        status: values.status,
+        output: values.output,
+        error: values.error,
+        finishedAt: values.finishedAt,
+        attempts: values.attempts
+      }
+    }).returning();
+    return row;
+  }
+  async findStep(runId, stepId) {
+    const [row] = await this.db.select().from(jobSteps).where(and(eq(jobSteps.jobRunId, runId), eq(jobSteps.stepId, stepId))).limit(1);
+    return row ?? null;
+  }
+};
+DrizzleJobStepService = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject(DRIZZLE))
+], DrizzleJobStepService);
+
+export {
+  DrizzleJobStepService
+};
+//# sourceMappingURL=chunk-DV4RV2DC.js.map

package/dist/chunk-DV4RV2DC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/jobs/job-step-service.drizzle-backend.ts"],"sourcesContent":["/**\n * DrizzleJobStepService — upsert + lookup on `job_step` for replay-safe\n * memoization (ADR-022, JOB-3).\n *\n * `recordStep` upserts on the `(job_run_id, step_id)` unique index — each\n * step row is written as `running` first, then transitioned to a terminal\n * state (`completed` / `failed` / `skipped`). `findStep` is the hot path\n * that `ctx.step()` consults on every invocation; null on miss.\n */\nimport { Inject, Injectable } from '@nestjs/common';\nimport { and, eq } from 'drizzle-orm';\nimport type { DrizzleClient } from '../../types/drizzle';\nimport { DRIZZLE } from '../../constants/tokens';\nimport { jobSteps, type JobStepRow } from './job-orchestration.schema';\nimport type {\n  IJobStepService,\n  JobStep,\n  RecordStepInput,\n} from './job-step-service.protocol';\n\n@Injectable()\nexport class DrizzleJobStepService implements IJobStepService {\n  constructor(@Inject(DRIZZLE) private readonly db: DrizzleClient) {}\n\n  async recordStep(input: RecordStepInput): Promise<JobStep> {\n    const values = {\n      jobRunId: input.jobRunId,\n      stepId: input.stepId,\n      kind: input.kind,\n      seq: input.seq,\n      status: input.status,\n      input: (input.input ?? null) as Record<string, unknown> | null,\n      output: (input.output ?? null) as Record<string, unknown> | null,\n      error: input.error ?? null,\n      attempts: input.attempts ?? 0,\n      startedAt: input.startedAt ?? null,\n      finishedAt: input.finishedAt ?? null,\n    };\n\n    const [row] = await this.db\n      .insert(jobSteps)\n      .values(values)\n      .onConflictDoUpdate({\n        target: [jobSteps.jobRunId, jobSteps.stepId],\n        set: {\n          status: values.status,\n          output: values.output,\n          error: values.error,\n          finishedAt: values.finishedAt,\n          attempts: values.attempts,\n        },\n      })\n      .returning();\n\n    return row as JobStep;\n  }\n\n  async findStep(runId: string, stepId: string): Promise<JobStep | null> {\n    const [row] = await this.db\n      .select()\n      .from(jobSteps)\n      .where(and(eq(jobSteps.jobRunId, runId), eq(jobSteps.stepId, stepId)))\n      .limit(1);\n    return ((row as JobStepRow | undefined) ?? null) as JobStep | null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;AASA,SAAS,QAAQ,kBAAkB;AACnC,SAAS,KAAK,UAAU;AAWjB,IAAM,wBAAN,MAAuD;AAAA,EAC5D,YAA8C,IAAmB;AAAnB;AAAA,EAAoB;AAAA,EAApB;AAAA,EAE9C,MAAM,WAAW,OAA0C;AACzD,UAAM,SAAS;AAAA,MACb,UAAU,MAAM;AAAA,MAChB,QAAQ,MAAM;AAAA,MACd,MAAM,MAAM;AAAA,MACZ,KAAK,MAAM;AAAA,MACX,QAAQ,MAAM;AAAA,MACd,OAAQ,MAAM,SAAS;AAAA,MACvB,QAAS,MAAM,UAAU;AAAA,MACzB,OAAO,MAAM,SAAS;AAAA,MACtB,UAAU,MAAM,YAAY;AAAA,MAC5B,WAAW,MAAM,aAAa;AAAA,MAC9B,YAAY,MAAM,cAAc;AAAA,IAClC;AAEA,UAAM,CAAC,GAAG,IAAI,MAAM,KAAK,GACtB,OAAO,QAAQ,EACf,OAAO,MAAM,EACb,mBAAmB;AAAA,MAClB,QAAQ,CAAC,SAAS,UAAU,SAAS,MAAM;AAAA,MAC3C,KAAK;AAAA,QACH,QAAQ,OAAO;AAAA,QACf,QAAQ,OAAO;AAAA,QACf,OAAO,OAAO;AAAA,QACd,YAAY,OAAO;AAAA,QACnB,UAAU,OAAO;AAAA,MACnB;AAAA,IACF,CAAC,EACA,UAAU;AAEb,WAAO;AAAA,EACT;AAAA,EAEA,MAAM,SAAS,OAAe,QAAyC;AACrE,UAAM,CAAC,GAAG,IAAI,MAAM,KAAK,GACtB,OAAO,EACP,KAAK,QAAQ,EACb,MAAM,IAAI,GAAG,SAAS,UAAU,KAAK,GAAG,GAAG,SAAS,QAAQ,MAAM,CAAC,CAAC,EACpE,MAAM,CAAC;AACV,WAAS,OAAkC;AAAA,EAC7C;AACF;AA5Ca,wBAAN;AAAA,EADN,WAAW;AAAA,EAEG,0BAAO,OAAO;AAAA,GADhB;","names":[]}

package/dist/chunk-EDKJU5BO.js

@@ -0,0 +1,11 @@
+// runtime/subsystems/bridge/reserved-pools.ts
+var BRIDGE_RESERVED_POOLS = [
+  "events_inbound",
+  "events_change",
+  "events_outbound"
+];
+
+export {
+  BRIDGE_RESERVED_POOLS
+};
+//# sourceMappingURL=chunk-EDKJU5BO.js.map

package/dist/chunk-EDKJU5BO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/bridge/reserved-pools.ts"],"sourcesContent":["/**\n * `BRIDGE_RESERVED_POOLS` — the three reserved bridge pools that workers\n * must claim from for bridge fanout to function (BRIDGE-8, ADR-022 +\n * ADR-023).\n *\n * Consumers spread this into their `JobWorkerModule.forRoot({ pools })`\n * configuration to ensure bridge wrappers are picked up:\n *\n * ```ts\n * import { BRIDGE_RESERVED_POOLS } from '@/runtime/subsystems/bridge';\n *\n * JobWorkerModule.forRoot({\n *   mode: 'embedded',\n *   pools: ['interactive', 'batch', ...BRIDGE_RESERVED_POOLS],\n * });\n * ```\n *\n * Cross-link: `BridgeModule.onModuleInit` (BRIDGE-8) compares this list\n * against the worker module's active pools and throws\n * `BridgeReservedPoolsNotPolledError` when any are missing — this turns\n * the silent footgun (\"wrappers sit pending forever\") into a fail-fast\n * at boot.\n *\n * Lives in its own file (re-exported from the barrel) to keep the\n * `BridgeModule` import graph acyclic — `bridge.module.ts` imports from\n * here, and the barrel re-exports both. Consumers only ever import from\n * the barrel.\n */\n\nexport const BRIDGE_RESERVED_POOLS = [\n  'events_inbound',\n  'events_change',\n  'events_outbound',\n] as const;\n\nexport type BridgeReservedPool = (typeof BRIDGE_RESERVED_POOLS)[number];\n"],"mappings":";AA6BO,IAAM,wBAAwB;AAAA,EACnC;AAAA,EACA;AAAA,EACA;AACF;","names":[]}

package/dist/chunk-EO2QPOKH.js

@@ -0,0 +1,116 @@
+import {
+  FieldDiffSchema
+} from "./chunk-SQDOBLBP.js";
+import {
+  __decorateClass
+} from "./chunk-2E224ZSN.js";
+
+// runtime/subsystems/integration/integration-run-recorder.memory-backend.ts
+import { Injectable } from "@nestjs/common";
+var MemoryRunRecorder = class {
+  /**
+   * All started runs keyed by id. Public so tests can inspect lifecycle
+   * transitions without poking through recording methods.
+   */
+  runs = /* @__PURE__ */ new Map();
+  /**
+   * Items keyed by `integration_run_id`, array order matches insertion order —
+   * mirrors the timeline the `(integration_run_id, created_at)` index produces
+   * in Postgres.
+   */
+  items = /* @__PURE__ */ new Map();
+  /**
+   * Seedable subscription metadata — tests populate this to make
+   * `listRecent` return meaningful `connectionId` values. The memory
+   * backend doesn't track subscriptions on its own (only runs + items), so
+   * this map is the intentional extension point: tests write entries for
+   * the subscription ids they use, production code never touches it.
+   */
+  subscriptions = /* @__PURE__ */ new Map();
+  async startRun(input) {
+    const id = crypto.randomUUID();
+    this.runs.set(id, {
+      id,
+      subscriptionId: input.subscriptionId,
+      direction: input.direction,
+      action: input.action,
+      status: "running",
+      cursorBefore: input.cursorBefore ?? null,
+      cursorAfter: null,
+      recordsFound: 0,
+      recordsProcessed: 0,
+      durationMs: null,
+      error: null,
+      tenantId: input.tenantId ?? null,
+      startedAt: /* @__PURE__ */ new Date(),
+      completedAt: null
+    });
+    this.items.set(id, []);
+    return { id };
+  }
+  async recordItem(input) {
+    FieldDiffSchema.parse(input.changedFields);
+    const bucket = this.items.get(input.integrationRunId);
+    if (!bucket) {
+      throw new Error(
+        `MemoryRunRecorder.recordItem: no run started for id '${input.integrationRunId}'. Call startRun(...) first.`
+      );
+    }
+    bucket.push(input);
+  }
+  async completeRun(runId, input) {
+    const run = this.runs.get(runId);
+    if (!run) {
+      throw new Error(
+        `MemoryRunRecorder.completeRun: no run started for id '${runId}'.`
+      );
+    }
+    run.status = input.status;
+    run.recordsFound = input.recordsFound;
+    run.recordsProcessed = input.recordsProcessed;
+    run.cursorAfter = input.cursorAfter ?? null;
+    run.durationMs = input.durationMs;
+    run.error = input.error ?? null;
+    run.completedAt = /* @__PURE__ */ new Date();
+  }
+  async listRecent(limit, subscriptionId, _tenantId) {
+    const all = Array.from(this.runs.values());
+    const filtered = subscriptionId === void 0 ? all : all.filter((r) => r.subscriptionId === subscriptionId);
+    return filtered.sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime()).slice(0, limit).map((r) => ({
+      id: r.id,
+      subscriptionId: r.subscriptionId,
+      // connectionId is only knowable if the test seeded subscriptions
+      // metadata; empty string otherwise. The Drizzle backend resolves
+      // it via JOIN, which is the production path.
+      connectionId: this.subscriptions.get(r.subscriptionId)?.connectionId ?? "",
+      status: r.status,
+      startedAt: r.startedAt,
+      completedAt: r.completedAt,
+      recordsProcessed: r.recordsProcessed,
+      tenantId: r.tenantId
+    }));
+  }
+  /** Reset state. Tests call this in `beforeEach`. */
+  clear() {
+    this.runs.clear();
+    this.items.clear();
+    this.subscriptions.clear();
+  }
+  // ─── test ergonomics ─────────────────────────────────────────────────
+  /** All runs for a subscription, newest first. Timeline reads. */
+  getRunsForSubscription(subscriptionId) {
+    return Array.from(this.runs.values()).filter((r) => r.subscriptionId === subscriptionId).sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());
+  }
+  /** All item rows for a run, insertion-ordered. */
+  getItemsForRun(runId) {
+    return this.items.get(runId) ?? [];
+  }
+};
+MemoryRunRecorder = __decorateClass([
+  Injectable()
+], MemoryRunRecorder);
+
+export {
+  MemoryRunRecorder
+};
+//# sourceMappingURL=chunk-EO2QPOKH.js.map

package/dist/chunk-EO2QPOKH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../runtime/subsystems/integration/integration-run-recorder.memory-backend.ts"],"sourcesContent":["/**\n * MemoryRunRecorder — in-memory backend for `IIntegrationRunRecorder` (SYNC-6).\n *\n * Test double so `IntegrationModule.forRoot({ backend: 'memory' })` is genuinely\n * end-to-end runnable without Postgres. Mirrors the role of\n * `MemoryCursorStore`: plain keyed state, `clear()` helper for\n * `beforeEach` resets, public inspection surface so tests can assert on\n * the recorded run + item timeline without scraping logs.\n *\n * Validates `changedFields` through `FieldDiffSchema.parse` on every\n * `recordItem` call — same ADR-0003 contract as the Drizzle backend. An\n * in-memory recorder that skipped the validation would be a silently\n * weaker contract than production.\n *\n * `startRun` generates a uuid via `crypto.randomUUID()` (Node 19+ / Bun).\n * We don't import `uuid` because the subsystem has no other use for it.\n *\n * ## Multi-tenancy\n *\n * `tenantId` is accepted (and recorded on the in-memory row so tests can\n * assert it) but enforcement lives at the module boundary. The memory\n * backend intentionally does not throw on missing `tenantId` — that's\n * the orchestrator's job when `multiTenant=true` (SYNC-6). A permissive\n * memory recorder lets tests exercise error paths where the orchestrator\n * short-circuits before ever reaching the recorder.\n */\nimport { Injectable } from '@nestjs/common';\nimport type {\n  CompleteRunInput,\n  IIntegrationRunRecorder,\n  RecordItemInput,\n  StartRunInput,\n  IntegrationRunSummary,\n} from './integration-run-recorder.protocol';\nimport { FieldDiffSchema } from './integration-field-diff.protocol';\n\n/**\n * Optional per-subscription metadata a test can seed on the memory backend\n * so `listRecent` can surface `connectionId`. The memory recorder's write\n * path never persists subscription rows (it only stores runs + items), so\n * `listRecent` has no way to derive `connectionId` on its own. Tests that\n * care about the field should populate `subscriptions` before calling\n * `listRecent`; calls that don't seed get an empty string and a stable\n * shape (see `listRecent` below).\n */\nexport interface MemoryIntegrationSubscription {\n  connectionId: string;\n  adapter: string;\n  domain: string;\n  externalRef: string | null;\n  lastIntegrationAt?: Date | null;\n  updatedAt: Date;\n}\n\n/**\n * Concrete run row as held in memory. Shape mirrors the interesting\n * columns on `integration_runs` so assertions read like DB queries.\n */\nexport interface MemoryRunRecord {\n  id: string;\n  subscriptionId: string;\n  direction: 'inbound' | 'outbound';\n  action: 'poll' | 'cdc' | 'webhook' | 'manual' | 'writeback';\n  status: 'running' | 'success' | 'no_changes' | 'failed';\n  cursorBefore: unknown | null;\n  cursorAfter: unknown | null;\n  recordsFound: number;\n  recordsProcessed: number;\n  durationMs: number | null;\n  error: string | null;\n  tenantId: string | null;\n  startedAt: Date;\n  completedAt: Date | null;\n}\n\n@Injectable()\nexport class MemoryRunRecorder implements IIntegrationRunRecorder {\n  /**\n   * All started runs keyed by id. Public so tests can inspect lifecycle\n   * transitions without poking through recording methods.\n   */\n  readonly runs: Map<string, MemoryRunRecord> = new Map();\n\n  /**\n   * Items keyed by `integration_run_id`, array order matches insertion order —\n   * mirrors the timeline the `(integration_run_id, created_at)` index produces\n   * in Postgres.\n   */\n  readonly items: Map<string, RecordItemInput[]> = new Map();\n\n  /**\n   * Seedable subscription metadata — tests populate this to make\n   * `listRecent` return meaningful `connectionId` values. The memory\n   * backend doesn't track subscriptions on its own (only runs + items), so\n   * this map is the intentional extension point: tests write entries for\n   * the subscription ids they use, production code never touches it.\n   */\n  readonly subscriptions: Map<string, MemoryIntegrationSubscription> = new Map();\n\n  async startRun(input: StartRunInput): Promise<{ id: string }> {\n    const id = crypto.randomUUID();\n    this.runs.set(id, {\n      id,\n      subscriptionId: input.subscriptionId,\n      direction: input.direction,\n      action: input.action,\n      status: 'running',\n      cursorBefore: input.cursorBefore ?? null,\n      cursorAfter: null,\n      recordsFound: 0,\n      recordsProcessed: 0,\n      durationMs: null,\n      error: null,\n      tenantId: input.tenantId ?? null,\n      startedAt: new Date(),\n      completedAt: null,\n    });\n    this.items.set(id, []);\n    return { id };\n  }\n\n  async recordItem(input: RecordItemInput): Promise<void> {\n    // Same ADR-0003 contract as the Drizzle backend.\n    FieldDiffSchema.parse(input.changedFields);\n\n    const bucket = this.items.get(input.integrationRunId);\n    if (!bucket) {\n      throw new Error(\n        `MemoryRunRecorder.recordItem: no run started for id '${input.integrationRunId}'. ` +\n          `Call startRun(...) first.`,\n      );\n    }\n    bucket.push(input);\n  }\n\n  async completeRun(runId: string, input: CompleteRunInput): Promise<void> {\n    const run = this.runs.get(runId);\n    if (!run) {\n      throw new Error(\n        `MemoryRunRecorder.completeRun: no run started for id '${runId}'.`,\n      );\n    }\n    run.status = input.status;\n    run.recordsFound = input.recordsFound;\n    run.recordsProcessed = input.recordsProcessed;\n    run.cursorAfter = input.cursorAfter ?? null;\n    run.durationMs = input.durationMs;\n    run.error = input.error ?? null;\n    run.completedAt = new Date();\n  }\n\n  async listRecent(\n    limit: number,\n    subscriptionId?: string,\n    _tenantId?: string | null,\n  ): Promise<IntegrationRunSummary[]> {\n    // Memory backend accepts tenantId for contract symmetry but does not\n    // filter on it — state is process-local and cross-tenant isolation is\n    // not meaningful here (matches MemoryCursorStore behavior).\n    const all = Array.from(this.runs.values());\n    const filtered =\n      subscriptionId === undefined\n        ? all\n        : all.filter((r) => r.subscriptionId === subscriptionId);\n    return filtered\n      .sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime())\n      .slice(0, limit)\n      .map((r) => ({\n        id: r.id,\n        subscriptionId: r.subscriptionId,\n        // connectionId is only knowable if the test seeded subscriptions\n        // metadata; empty string otherwise. The Drizzle backend resolves\n        // it via JOIN, which is the production path.\n        connectionId:\n          this.subscriptions.get(r.subscriptionId)?.connectionId ?? '',\n        status: r.status,\n        startedAt: r.startedAt,\n        completedAt: r.completedAt,\n        recordsProcessed: r.recordsProcessed,\n        tenantId: r.tenantId,\n      }));\n  }\n\n  /** Reset state. Tests call this in `beforeEach`. */\n  clear(): void {\n    this.runs.clear();\n    this.items.clear();\n    this.subscriptions.clear();\n  }\n\n  // ─── test ergonomics ─────────────────────────────────────────────────\n\n  /** All runs for a subscription, newest first. Timeline reads. */\n  getRunsForSubscription(subscriptionId: string): MemoryRunRecord[] {\n    return Array.from(this.runs.values())\n      .filter((r) => r.subscriptionId === subscriptionId)\n      .sort((a, b) => b.startedAt.getTime() - a.startedAt.getTime());\n  }\n\n  /** All item rows for a run, insertion-ordered. */\n  getItemsForRun(runId: string): RecordItemInput[] {\n    return this.items.get(runId) ?? [];\n  }\n}\n"],"mappings":";;;;;;;;AA0BA,SAAS,kBAAkB;AAkDpB,IAAM,oBAAN,MAA2D;AAAA;AAAA;AAAA;AAAA;AAAA,EAKvD,OAAqC,oBAAI,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO7C,QAAwC,oBAAI,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAShD,gBAA4D,oBAAI,IAAI;AAAA,EAE7E,MAAM,SAAS,OAA+C;AAC5D,UAAM,KAAK,OAAO,WAAW;AAC7B,SAAK,KAAK,IAAI,IAAI;AAAA,MAChB;AAAA,MACA,gBAAgB,MAAM;AAAA,MACtB,WAAW,MAAM;AAAA,MACjB,QAAQ,MAAM;AAAA,MACd,QAAQ;AAAA,MACR,cAAc,MAAM,gBAAgB;AAAA,MACpC,aAAa;AAAA,MACb,cAAc;AAAA,MACd,kBAAkB;AAAA,MAClB,YAAY;AAAA,MACZ,OAAO;AAAA,MACP,UAAU,MAAM,YAAY;AAAA,MAC5B,WAAW,oBAAI,KAAK;AAAA,MACpB,aAAa;AAAA,IACf,CAAC;AACD,SAAK,MAAM,IAAI,IAAI,CAAC,CAAC;AACrB,WAAO,EAAE,GAAG;AAAA,EACd;AAAA,EAEA,MAAM,WAAW,OAAuC;AAEtD,oBAAgB,MAAM,MAAM,aAAa;AAEzC,UAAM,SAAS,KAAK,MAAM,IAAI,MAAM,gBAAgB;AACpD,QAAI,CAAC,QAAQ;AACX,YAAM,IAAI;AAAA,QACR,wDAAwD,MAAM,gBAAgB;AAAA,MAEhF;AAAA,IACF;AACA,WAAO,KAAK,KAAK;AAAA,EACnB;AAAA,EAEA,MAAM,YAAY,OAAe,OAAwC;AACvE,UAAM,MAAM,KAAK,KAAK,IAAI,KAAK;AAC/B,QAAI,CAAC,KAAK;AACR,YAAM,IAAI;AAAA,QACR,yDAAyD,KAAK;AAAA,MAChE;AAAA,IACF;AACA,QAAI,SAAS,MAAM;AACnB,QAAI,eAAe,MAAM;AACzB,QAAI,mBAAmB,MAAM;AAC7B,QAAI,cAAc,MAAM,eAAe;AACvC,QAAI,aAAa,MAAM;AACvB,QAAI,QAAQ,MAAM,SAAS;AAC3B,QAAI,cAAc,oBAAI,KAAK;AAAA,EAC7B;AAAA,EAEA,MAAM,WACJ,OACA,gBACA,WACkC;AAIlC,UAAM,MAAM,MAAM,KAAK,KAAK,KAAK,OAAO,CAAC;AACzC,UAAM,WACJ,mBAAmB,SACf,MACA,IAAI,OAAO,CAAC,MAAM,EAAE,mBAAmB,cAAc;AAC3D,WAAO,SACJ,KAAK,CAAC,GAAG,MAAM,EAAE,UAAU,QAAQ,IAAI,EAAE,UAAU,QAAQ,CAAC,EAC5D,MAAM,GAAG,KAAK,EACd,IAAI,CAAC,OAAO;AAAA,MACX,IAAI,EAAE;AAAA,MACN,gBAAgB,EAAE;AAAA;AAAA;AAAA;AAAA,MAIlB,cACE,KAAK,cAAc,IAAI,EAAE,cAAc,GAAG,gBAAgB;AAAA,MAC5D,QAAQ,EAAE;AAAA,MACV,WAAW,EAAE;AAAA,MACb,aAAa,EAAE;AAAA,MACf,kBAAkB,EAAE;AAAA,MACpB,UAAU,EAAE;AAAA,IACd,EAAE;AAAA,EACN;AAAA;AAAA,EAGA,QAAc;AACZ,SAAK,KAAK,MAAM;AAChB,SAAK,MAAM,MAAM;AACjB,SAAK,cAAc,MAAM;AAAA,EAC3B;AAAA;AAAA;AAAA,EAKA,uBAAuB,gBAA2C;AAChE,WAAO,MAAM,KAAK,KAAK,KAAK,OAAO,CAAC,EACjC,OAAO,CAAC,MAAM,EAAE,mBAAmB,cAAc,EACjD,KAAK,CAAC,GAAG,MAAM,EAAE,UAAU,QAAQ,IAAI,EAAE,UAAU,QAAQ,CAAC;AAAA,EACjE;AAAA;AAAA,EAGA,eAAe,OAAkC;AAC/C,WAAO,KAAK,MAAM,IAAI,KAAK,KAAK,CAAC;AAAA,EACnC;AACF;AA/Ha,oBAAN;AAAA,EADN,WAAW;AAAA,GACC;","names":[]}