@pattern-stack/codegen 0.10.0 → 0.11.0

package/dist/runtime/subsystems/index.js

@@ -362,13 +362,12 @@ var BRIDGE_OUTBOX_DRAIN_HOOK = "BRIDGE_OUTBOX_DRAIN_HOOK";
 // runtime/subsystems/events/event-bus.drizzle-backend.ts
 var POLL_INTERVAL_MS = 1e3;
 var POLL_BATCH_SIZE = 50;
-function toInsertValues(event) {
+function toInsertValues(event, multiTenant) {
   const metadata = event.metadata ?? void 0;
   const pool = metadata?.["pool"] ?? null;
   const direction = metadata?.["direction"] ?? null;
-  const tenantId = metadata?.["tenantId"] ?? null;
   const tier = metadata?.["tier"] ?? "domain";
-  return {
+  const base = {
     id: event.id,
     type: event.type,
     aggregateId: event.aggregateId,
@@ -380,9 +379,11 @@ function toInsertValues(event) {
     metadata: event.metadata,
     pool,
     direction,
-    tier,
-    tenantId
+    tier
   };
+  if (!multiTenant) return base;
+  const tenantId = metadata?.["tenantId"] ?? null;
+  return { ...base, tenantId };
 }
 function toEventSummary(r) {
   const metadata = r.metadata ?? void 0;
@@ -397,7 +398,11 @@ function toEventSummary(r) {
     direction: r.direction,
     tier: r.tier,
     rootRunId: typeof rootRunId === "string" ? rootRunId : null,
-    tenantId: r.tenantId,
+    // EVT-8: `tenant_id` is a scaffold-time conditional column. Read it
+    // structurally so this projection typechecks against both the
+    // multi-tenant schema (column present) and the single-tenant schema
+    // (column absent → undefined → null).
+    tenantId: r.tenantId ?? null,
     occurredAt: r.occurredAt instanceof Date ? r.occurredAt : new Date(r.occurredAt),
     processedAt: r.processedAt == null ? null : r.processedAt instanceof Date ? r.processedAt : new Date(r.processedAt)
   };
@@ -434,12 +439,14 @@ var DrizzleEventBus = class {
   // ============================================================================
   async publish(event, tx) {
     const client = tx ?? this.db;
-    await client.insert(domainEvents).values(toInsertValues(event));
+    const multiTenant = this.opts.multiTenant ?? false;
+    await client.insert(domainEvents).values(toInsertValues(event, multiTenant));
   }
   async publishMany(events, tx) {
     if (events.length === 0) return;
     const client = tx ?? this.db;
-    await client.insert(domainEvents).values(events.map(toInsertValues));
+    const multiTenant = this.opts.multiTenant ?? false;
+    await client.insert(domainEvents).values(events.map((e) => toInsertValues(e, multiTenant)));
   }
   async findById(eventId) {
     const rows = await this.db.select().from(domainEvents).where(eq(domainEvents.id, eventId)).limit(1);
@@ -481,9 +488,10 @@ var DrizzleEventBus = class {
         sql2`${domainEvents.metadata}->>'rootRunId' = ${query.rootRunId}`
       );
     }
-    if (query.tenantId !== void 0) {
+    if (this.opts.multiTenant && query.tenantId !== void 0) {
+      const tenantIdColumn = domainEvents.tenantId;
       conditions.push(
-        query.tenantId === null ? sql2`${domainEvents.tenantId} is null` : eq(domainEvents.tenantId, query.tenantId)
+        query.tenantId === null ? sql2`${tenantIdColumn} is null` : eq(tenantIdColumn, query.tenantId)
       );
     }
     if (query.cursor) {
@@ -814,233 +822,12 @@ MemoryEventBus = __decorateClass([
   __decorateParam(0, Inject3(EVENTS_MODULE_OPTIONS))
 ], MemoryEventBus);
 
-// runtime/subsystems/events/event-bus.redis-backend.ts
-import { Injectable as Injectable4, Inject as Inject4, Logger as Logger3 } from "@nestjs/common";
-var CHANNEL_PREFIX = "events:";
-async function createRedisClient(url) {
-  let Redis;
-  try {
-    const mod = await import("ioredis");
-    Redis = mod.default ?? mod;
-  } catch {
-    throw new Error(
-      'RedisEventBus requires the "ioredis" package. Install it with: npm install ioredis'
-    );
-  }
-  return new Redis(url);
-}
-var RedisEventBus = class {
-  constructor(redisUrl) {
-    this.redisUrl = redisUrl;
-  }
-  redisUrl;
-  logger = new Logger3(RedisEventBus.name);
-  publisher = null;
-  subscriber = null;
-  connected = false;
-  /**
-   * In-process subscriber registry. Handlers registered here are called when
-   * a message arrives on the subscriber client — keeping fan-out within the
-   * same process without an extra round-trip through Redis.
-   */
-  handlers = /* @__PURE__ */ new Map();
-  /**
-   * Track which event types have active Redis subscriptions.
-   * Used to avoid subscribing multiple times to the same type channel.
-   */
-  subscribedTypes = /* @__PURE__ */ new Set();
-  // ============================================================================
-  // Lifecycle
-  // ============================================================================
-  async onModuleInit() {
-    this.publisher = await createRedisClient(this.redisUrl);
-    this.subscriber = await createRedisClient(this.redisUrl);
-    this.publisher.on(
-      "error",
-      (err) => this.logger.error(`Redis publisher error: ${err.message}`, err.stack)
-    );
-    this.subscriber.on(
-      "error",
-      (err) => this.logger.error(`Redis subscriber error: ${err.message}`, err.stack)
-    );
-    this.subscriber.on("message", (channel, message) => {
-      void this.handleMessage(channel, message);
-    });
-    this.connected = true;
-    this.logger.log(`RedisEventBus connected to ${this.redisUrl}`);
-  }
-  async onModuleDestroy() {
-    this.connected = false;
-    if (this.subscriber) {
-      await this.subscriber.unsubscribe();
-      this.subscriber.disconnect();
-      this.subscriber = null;
-    }
-    if (this.publisher) {
-      this.publisher.disconnect();
-      this.publisher = null;
-    }
-    this.subscribedTypes.clear();
-    this.logger.log("RedisEventBus disconnected");
-  }
-  // ============================================================================
-  // IEventBus
-  // ============================================================================
-  /**
-   * Publish a single event.
-   *
-   * `tx` is accepted but ignored — see module-level JSDoc for details.
-   */
-  async publish(event, tx) {
-    void tx;
-    this.assertConnected();
-    const payload = this.serialize(event);
-    const channel = `${CHANNEL_PREFIX}${event.type}`;
-    await this.publisher.publish(channel, payload);
-  }
-  /**
-   * Publish multiple events using a pipeline so all PUBLISH commands are sent
-   * in a single round-trip.
-   *
-   * `tx` is accepted but ignored — see module-level JSDoc for details.
-   */
-  async publishMany(events, tx) {
-    void tx;
-    if (events.length === 0) return;
-    this.assertConnected();
-    const pipeline = this.publisher.pipeline();
-    for (const event of events) {
-      const payload = this.serialize(event);
-      const channel = `${CHANNEL_PREFIX}${event.type}`;
-      pipeline.publish(channel, payload);
-    }
-    await pipeline.exec();
-  }
-  /**
-   * Register a handler for a specific event type.
-   * Returns an unsubscribe function — call it to remove the handler.
-   *
-   * On first handler for a type, subscribes to the per-type Redis channel.
-   * On removal of the last handler for a type, unsubscribes from the channel.
-   */
-  /**
-   * Lookup by id is unsupported on the Redis Pub/Sub backend — Pub/Sub
-   * does not retain history. Always returns `null`. Logs a warning the
-   * first time it's called so a misconfiguration surfaces visibly. Using
-   * the bridge with the Redis backend is unsupported (the bridge requires
-   * a durable event store).
-   */
-  warnedFindById = false;
-  async findById(_eventId) {
-    if (!this.warnedFindById) {
-      this.warnedFindById = true;
-      this.logger.warn(
-        "RedisEventBus.findById is unsupported (Pub/Sub has no history). The bridge subsystem requires a durable event store; switch to DrizzleEventBus if you need bridge fanout."
-      );
-    }
-    return null;
-  }
-  subscribe(eventType, handler) {
-    if (!this.handlers.has(eventType)) {
-      this.handlers.set(eventType, /* @__PURE__ */ new Set());
-      void this.subscribeToType(eventType);
-    }
-    const set = this.handlers.get(eventType);
-    const h = handler;
-    set.add(h);
-    return () => {
-      set.delete(h);
-      if (set.size === 0) {
-        this.handlers.delete(eventType);
-        void this.unsubscribeFromType(eventType);
-      }
-    };
-  }
-  // ============================================================================
-  // Internal helpers
-  // ============================================================================
-  assertConnected() {
-    if (!this.connected || !this.publisher) {
-      throw new Error(
-        "RedisEventBus is not connected. Ensure the module has been initialised before publishing."
-      );
-    }
-  }
-  serialize(event) {
-    return JSON.stringify({
-      ...event,
-      occurredAt: event.occurredAt.toISOString()
-    });
-  }
-  deserialize(raw) {
-    const parsed = JSON.parse(raw);
-    return {
-      ...parsed,
-      occurredAt: new Date(parsed.occurredAt)
-    };
-  }
-  async handleMessage(channel, message) {
-    let event;
-    try {
-      event = this.deserialize(message);
-    } catch (err) {
-      this.logger.warn(`Failed to deserialize event on channel "${channel}": ${err}`);
-      return;
-    }
-    await this.dispatch(event);
-  }
-  async dispatch(event) {
-    const set = this.handlers.get(event.type);
-    if (!set) return;
-    for (const handler of set) {
-      try {
-        await handler(event);
-      } catch (err) {
-        this.logger.error(
-          `Handler error for event type "${event.type}" (id: ${event.id}): ${err}`
-        );
-      }
-    }
-  }
-  /**
-   * Subscribe to a per-type Redis channel.
-   * Called lazily when the first handler is registered for a type.
-   */
-  async subscribeToType(eventType) {
-    if (this.subscribedTypes.has(eventType)) {
-      return;
-    }
-    const channel = `${CHANNEL_PREFIX}${eventType}`;
-    try {
-      await this.subscriber.subscribe(channel);
-      this.subscribedTypes.add(eventType);
-    } catch (err) {
-      this.logger.error(`Failed to subscribe to channel "${channel}": ${err}`);
-    }
-  }
-  /**
-   * Unsubscribe from a per-type Redis channel.
-   * Called when the last handler for a type is removed.
-   */
-  async unsubscribeFromType(eventType) {
-    if (!this.subscribedTypes.has(eventType)) {
-      return;
-    }
-    const channel = `${CHANNEL_PREFIX}${eventType}`;
-    try {
-      await this.subscriber.unsubscribe(channel);
-      this.subscribedTypes.delete(eventType);
-    } catch (err) {
-      this.logger.error(`Failed to unsubscribe from channel "${channel}": ${err}`);
-    }
-  }
-};
-RedisEventBus = __decorateClass([
-  Injectable4(),
-  __decorateParam(0, Inject4(REDIS_URL))
-], RedisEventBus);
-
 // runtime/subsystems/events/events.module.ts
+async function loadRedisEventBus() {
+  const specifier = "./event-bus.redis-backend";
+  const mod = await import(specifier);
+  return mod.RedisEventBus;
+}
 function buildTypedBusProviders(multiTenant) {
   return [
     TypedEventBus,
@@ -1048,7 +835,7 @@ function buildTypedBusProviders(multiTenant) {
     { provide: EVENTS_MULTI_TENANT, useValue: multiTenant }
   ];
 }
-function buildEventBusAsync(options, db, redisUrl) {
+async function buildEventBusAsync(options, db, redisUrl) {
   if (options.backend === "drizzle") {
     if (!db) {
       throw new Error(
@@ -1058,6 +845,7 @@ function buildEventBusAsync(options, db, redisUrl) {
     return new DrizzleEventBus(db, options);
   }
   if (options.backend === "redis") {
+    const RedisEventBus = await loadRedisEventBus();
     return new RedisEventBus(redisUrl);
   }
   return new MemoryEventBus(options);
@@ -1119,9 +907,20 @@ var EventsModule = class {
         providers: [
           { provide: EVENTS_MODULE_OPTIONS, useValue: options },
           { provide: REDIS_URL, useValue: resolvedUrl },
-          { provide: EVENT_BUS, useClass: RedisEventBus },
-          // Register concrete class so NestJS can resolve lifecycle hooks
-          RedisEventBus,
+          {
+            // #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)
         ],
         exports: [EVENT_BUS, TYPED_EVENT_BUS, EVENTS_MULTI_TENANT]
@@ -1324,7 +1123,7 @@ var HandlerRegistry;
 
 // runtime/subsystems/jobs/job-orchestrator.drizzle-backend.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { Inject as Inject5, Injectable as Injectable5, Logger as Logger4 } from "@nestjs/common";
+import { Inject as Inject4, Injectable as Injectable4, Logger as Logger3 } from "@nestjs/common";
 import { and as and2, desc as desc2, eq as eq2, gt, inArray as inArray2, isNotNull, ne, notInArray, sql as sql4 } from "drizzle-orm";
 
 // runtime/subsystems/jobs/jobs-errors.ts
@@ -1432,7 +1231,7 @@ var DrizzleJobOrchestrator = class {
   db;
   multiTenant;
   // TODO(logging-subsystem): swap to ILogger once ADR-028 lands
-  logger = new Logger4(DrizzleJobOrchestrator.name);
+  logger = new Logger3(DrizzleJobOrchestrator.name);
   /**
    * JOB-8 — resolve `tenantId` for a mutating / targeted-read call.
    * Returns the tenant value that should be written to the row (or compared
@@ -1721,9 +1520,9 @@ var DrizzleJobOrchestrator = class {
   }
 };
 DrizzleJobOrchestrator = __decorateClass([
-  Injectable5(),
-  __decorateParam(0, Inject5(DRIZZLE)),
-  __decorateParam(1, Inject5(JOBS_MULTI_TENANT))
+  Injectable4(),
+  __decorateParam(0, Inject4(DRIZZLE)),
+  __decorateParam(1, Inject4(JOBS_MULTI_TENANT))
 ], DrizzleJobOrchestrator);
 function notInStatus(statuses) {
   const negated = statuses.map((s) => ne(jobRuns.status, s));
@@ -1731,7 +1530,7 @@ function notInStatus(statuses) {
 }
 
 // runtime/subsystems/jobs/job-run-service.drizzle-backend.ts
-import { Inject as Inject6, Injectable as Injectable6 } from "@nestjs/common";
+import { Inject as Inject5, Injectable as Injectable5 } from "@nestjs/common";
 import { and as and3, asc as asc2, desc as desc3, eq as eq3, gte as gte2, inArray as inArray3, isNull, lt as lt2, or as or2, sql as sql5 } from "drizzle-orm";
 
 // runtime/subsystems/jobs/job-run-keyset-cursor.ts
@@ -1951,14 +1750,14 @@ var DrizzleJobRunService = class {
   }
 };
 DrizzleJobRunService = __decorateClass([
-  Injectable6(),
-  __decorateParam(0, Inject6(DRIZZLE)),
-  __decorateParam(1, Inject6(JOB_ORCHESTRATOR)),
-  __decorateParam(2, Inject6(JOBS_MULTI_TENANT))
+  Injectable5(),
+  __decorateParam(0, Inject5(DRIZZLE)),
+  __decorateParam(1, Inject5(JOB_ORCHESTRATOR)),
+  __decorateParam(2, Inject5(JOBS_MULTI_TENANT))
 ], DrizzleJobRunService);
 
 // runtime/subsystems/jobs/job-step-service.drizzle-backend.ts
-import { Inject as Inject7, Injectable as Injectable7 } from "@nestjs/common";
+import { Inject as Inject6, Injectable as Injectable6 } from "@nestjs/common";
 import { and as and4, eq as eq4 } from "drizzle-orm";
 var DrizzleJobStepService = class {
   constructor(db) {
@@ -1997,15 +1796,10 @@ var DrizzleJobStepService = class {
   }
 };
 DrizzleJobStepService = __decorateClass([
-  Injectable7(),
-  __decorateParam(0, Inject7(DRIZZLE))
+  Injectable6(),
+  __decorateParam(0, Inject6(DRIZZLE))
 ], DrizzleJobStepService);
 
-// runtime/subsystems/jobs/job-orchestrator.bullmq-backend.ts
-import { createHash } from "crypto";
-import { Inject as Inject8, Injectable as Injectable8, Logger as Logger5, Optional as Optional3 } from "@nestjs/common";
-import { eq as eq5 } from "drizzle-orm";
-
 // runtime/subsystems/jobs/pool-config.loader.ts
 import { existsSync, readFileSync } from "fs";
 import { resolve } from "path";
@@ -2153,443 +1947,9 @@ function resolvePoolQueueName(pool, config, poolConfig = loadPoolConfig()) {
   return prefix ? `${prefix}:${alias}` : alias;
 }
 
-// runtime/subsystems/jobs/job-orchestrator.bullmq-backend.ts
-function sha1JobId(idempotencyKey) {
-  return createHash("sha1").update(idempotencyKey).digest("hex");
-}
-var BullMQJobOrchestrator = class extends DrizzleJobOrchestrator {
-  constructor(db, multiTenant, connection, bullConfig = null) {
-    super(db, multiTenant);
-    this.connection = connection;
-    this.bullConfig = bullConfig;
-    this.bullDb = db;
-  }
-  connection;
-  bullConfig;
-  // TODO(logging-subsystem): swap to ILogger once ADR-028 lands
-  bullLogger = new Logger5(BullMQJobOrchestrator.name);
-  /** Lazily-opened `Queue` handles, one per pool. */
-  queues = /* @__PURE__ */ new Map();
-  /** Single FlowProducer for parent/child hierarchies. Lazily opened. */
-  _flow = null;
-  /**
-   * Cached `bullmq` value constructors, populated by `loadBullMq()` on first
-   * use (the `start`/`cancel`/`replay` entrypoints `await` it before touching
-   * a queue). Kept off the import graph so a `drizzle`-only consumer never
-   * resolves the optional `'bullmq'` package.
-   */
-  QueueCtor = null;
-  FlowProducerCtor = null;
-  bullMqLoad = null;
-  /**
-   * Own reference to the Drizzle client. `DrizzleJobOrchestrator.db` is
-   * `private` (can't be redeclared even privately in a subclass), and the
-   * spec forbids touching that file — so the subclass keeps its own handle
-   * under a distinct name (same instance, passed through to `super`) for the
-   * cancel-cascade snapshot + definition/run loads below.
-   */
-  bullDb;
-  /**
-   * Lazily load the optional `bullmq` package and cache its value
-   * constructors. Idempotent (single in-flight promise). Throws a friendly,
-   * actionable error when the consumer selected `backend: 'bullmq'` but did
-   * not install the package — mirrors `createRedisClient` in the redis event
-   * backend. Must be `await`ed before any `queueFor`/`flow` access.
-   */
-  async loadBullMq() {
-    if (this.QueueCtor && this.FlowProducerCtor) return;
-    if (!this.bullMqLoad) {
-      this.bullMqLoad = (async () => {
-        try {
-          const mod = await import("bullmq");
-          this.QueueCtor = mod.Queue;
-          this.FlowProducerCtor = mod.FlowProducer;
-        } catch {
-          throw new Error(
-            'BullMQ backend requires the "bullmq" package. Install it with: npm install bullmq'
-          );
-        }
-      })();
-    }
-    await this.bullMqLoad;
-  }
-  /**
-   * Open (or reuse) the `Queue` for a pool. Synchronous — callers `await
-   * loadBullMq()` first so `QueueCtor` is populated.
-   */
-  queueFor(pool) {
-    if (!this.QueueCtor) {
-      throw new Error("BullMQJobOrchestrator: queueFor called before loadBullMq()");
-    }
-    const name = resolvePoolQueueName(pool, this.bullConfig);
-    let q = this.queues.get(name);
-    if (!q) {
-      q = new this.QueueCtor(name, { connection: this.connection });
-      this.queues.set(name, q);
-    }
-    return q;
-  }
-  flow() {
-    if (!this.FlowProducerCtor) {
-      throw new Error("BullMQJobOrchestrator: flow called before loadBullMq()");
-    }
-    if (!this._flow) {
-      this._flow = new this.FlowProducerCtor({ connection: this.connection });
-    }
-    return this._flow;
-  }
-  // ==========================================================================
-  // start — Postgres insert (super) + BullMQ dispatch
-  // ==========================================================================
-  async start(type, input, opts = {}, tx) {
-    const run = await super.start(type, input, opts, tx);
-    await this.dispatch(run, type);
-    return run;
-  }
-  /**
-   * Map a `job_run` row onto a BullMQ job via `queue.add`. When the run has a
-   * `parentRunId` we attach it to the parent's existing BullMQ job through the
-   * `parent: { id, queue }` opt — BullMQ then tracks the parent/child link in
-   * its own graph. (The FlowProducer is reserved for whole-tree atomic
-   * submits, exposed as an opt-in extension via `flowProducer()`; runtime
-   * `ctx.spawnChild` is incremental, so `queue.add` with a parent ref is the
-   * correct primitive here.)
-   *
-   * The `jobId` is colon-safe + stable: `sha1(dedupeKey)` when a dedupe key is
-   * present (so the same logical key dedups), else the `job_run.id` UUID
-   * (already colon-free).
-   *
-   * The domain `parentClosePolicy` cascade is still enforced in Postgres by
-   * the shared `cancel` path — BullMQ's parent link is dispatch bookkeeping,
-   * not the authority.
-   */
-  async dispatch(run, type) {
-    await this.loadBullMq();
-    const def = await this.loadDefinition(type);
-    const jobId = run.dedupeKey ? sha1JobId(run.dedupeKey) : run.id;
-    const jobOpts = {
-      jobId,
-      ...this.retryOpts(def),
-      ...this.dedupeOpts(run, def)
-    };
-    if (run.parentRunId) {
-      const parentRow = await this.loadRun(run.parentRunId);
-      if (parentRow) {
-        const parentJobId = parentRow.dedupeKey ? sha1JobId(parentRow.dedupeKey) : parentRow.id;
-        jobOpts.parent = {
-          id: parentJobId,
-          queue: resolvePoolQueueName(parentRow.pool, this.bullConfig)
-        };
-      }
-    }
-    const payload = { runId: run.id, type, input: run.input };
-    await this.queueFor(run.pool).add(type, payload, jobOpts);
-  }
-  /**
-   * Opt-in extension (spec §Extensions): expose the FlowProducer for
-   * consumers that want to submit a whole parent/child DAG atomically up
-   * front, rather than incrementally via `ctx.spawnChild`. Backend-specific —
-   * code using it is not portable to the Drizzle backend. Async because it
-   * lazily loads the optional `bullmq` package on first use.
-   */
-  async flowProducer() {
-    await this.loadBullMq();
-    return this.flow();
-  }
-  retryOpts(def) {
-    const policy = def.retryPolicy;
-    if (!policy) return {};
-    return {
-      attempts: policy.attempts,
-      backoff: {
-        type: policy.backoff === "exponential" ? "exponential" : "fixed",
-        delay: policy.baseMs
-      }
-    };
-  }
-  dedupeOpts(run, def) {
-    if (!run.dedupeKey || !def.dedupeWindowMs) return {};
-    return {
-      deduplication: {
-        id: sha1JobId(run.dedupeKey),
-        ttl: def.dedupeWindowMs
-      }
-    };
-  }
-  // ==========================================================================
-  // cancel — Postgres cascade (super) + remove from queue
-  // ==========================================================================
-  async cancel(runId, opts = {}) {
-    const target = await this.loadRun(runId);
-    await super.cancel(runId, opts);
-    if (!target) return;
-    await this.loadBullMq();
-    await this.removeFromQueue(target);
-    if (opts.cascade === false) return;
-    const descendants = await this.bullDb.select().from(jobRuns).where(eq5(jobRuns.rootRunId, target.rootRunId));
-    for (const child of descendants) {
-      if (child.id === runId) continue;
-      await this.removeFromQueue(child);
-    }
-  }
-  async removeFromQueue(run) {
-    const jobId = run.dedupeKey ? sha1JobId(run.dedupeKey) : run.id;
-    try {
-      const job = await this.queueFor(run.pool).getJob(jobId);
-      if (job) await job.remove();
-    } catch (err) {
-      this.bullLogger.warn(
-        `cancel: could not remove BullMQ job ${jobId} (pool=${run.pool}): ${err.message}`
-      );
-    }
-  }
-  // ==========================================================================
-  // replay — Postgres reset (super) + re-enqueue
-  // ==========================================================================
-  async replay(runId) {
-    const run = await super.replay(runId);
-    await this.dispatch(run, run.jobType);
-    return run;
-  }
-  // ==========================================================================
-  // Internals
-  // ==========================================================================
-  async loadDefinition(type) {
-    const [def] = await this.bullDb.select().from(jobs).where(eq5(jobs.type, type)).limit(1);
-    if (!def) {
-      throw new Error(`BullMQJobOrchestrator: no job definition for '${type}'`);
-    }
-    return def;
-  }
-  async loadRun(id) {
-    const [row] = await this.bullDb.select().from(jobRuns).where(eq5(jobRuns.id, id)).limit(1);
-    return row ?? null;
-  }
-  /** Close all open queue + flow connections. Called on module destroy. */
-  async closeConnections() {
-    for (const q of this.queues.values()) {
-      await q.close().catch(() => void 0);
-    }
-    this.queues.clear();
-    if (this._flow) {
-      await this._flow.close().catch(() => void 0);
-      this._flow = null;
-    }
-  }
-};
-BullMQJobOrchestrator = __decorateClass([
-  Injectable8(),
-  __decorateParam(0, Inject8(DRIZZLE)),
-  __decorateParam(1, Inject8(JOBS_MULTI_TENANT)),
-  __decorateParam(2, Inject8(BULLMQ_CONNECTION)),
-  __decorateParam(3, Optional3()),
-  __decorateParam(3, Inject8(BULLMQ_RESOLVED_CONFIG))
-], BullMQJobOrchestrator);
-
-// runtime/subsystems/jobs/job-worker.bullmq-backend.ts
-import { Logger as Logger6 } from "@nestjs/common";
-import { eq as eq6 } from "drizzle-orm";
-function serialiseError(err, attempt, retryable) {
-  const e = err;
-  return {
-    message: e?.message ?? String(err),
-    stack: e?.stack,
-    retryable,
-    attempt
-  };
-}
-var BullMQJobWorker = class _BullMQJobWorker {
-  constructor(db, orchestrator, stepService, options, moduleRef) {
-    this.db = db;
-    this.orchestrator = orchestrator;
-    this.stepService = stepService;
-    this.options = options;
-    this.moduleRef = moduleRef;
-  }
-  db;
-  orchestrator;
-  stepService;
-  options;
-  moduleRef;
-  logger = new Logger6(_BullMQJobWorker.name);
-  worker = null;
-  async onModuleInit() {
-    let WorkerCtor;
-    try {
-      const mod = await import("bullmq");
-      WorkerCtor = mod.Worker;
-    } catch {
-      throw new Error(
-        'BullMQ backend requires the "bullmq" package. Install it with: npm install bullmq'
-      );
-    }
-    this.worker = new WorkerCtor(
-      this.options.queueName,
-      (job) => this.process(job),
-      {
-        connection: this.options.connection,
-        concurrency: this.options.concurrency
-      }
-    );
-    this.worker.on("failed", (job, err) => {
-      if (!job) return;
-      const attemptsMade = job.attemptsMade;
-      const maxAttempts = job.opts.attempts ?? 1;
-      if (attemptsMade >= maxAttempts) {
-        void this.markFailed(job.data.runId, err, attemptsMade);
-      }
-    });
-    this.logger.log(
-      `BullMQ worker started: pool='${this.options.pool}' queue='${this.options.queueName}' concurrency=${this.options.concurrency}`
-    );
-  }
-  async onModuleDestroy() {
-    if (this.worker) {
-      await this.worker.close();
-      this.worker = null;
-    }
-  }
-  /**
-   * Process one BullMQ job. Returns the handler output (stored by BullMQ as
-   * the job return value AND written to `job_run.output`). Throws on handler
-   * failure so BullMQ applies the retry policy.
-   */
-  async process(job) {
-    const { runId } = job.data;
-    const [row] = await this.db.select().from(jobRuns).where(eq6(jobRuns.id, runId)).limit(1);
-    if (!row) {
-      this.logger.warn(`process: job_run ${runId} not found; skipping`);
-      return {};
-    }
-    const run = row;
-    if (run.status === "canceled") {
-      return {};
-    }
-    const registryEntry = JOB_HANDLER_REGISTRY.get(run.jobType);
-    if (!registryEntry) {
-      throw new Error(
-        `No handler registered for jobType='${run.jobType}' (run ${run.id})`
-      );
-    }
-    await this.db.update(jobRuns).set({
-      status: "running",
-      claimedAt: /* @__PURE__ */ new Date(),
-      startedAt: /* @__PURE__ */ new Date(),
-      attempts: job.attemptsMade + 1,
-      updatedAt: /* @__PURE__ */ new Date()
-    }).where(eq6(jobRuns.id, run.id));
-    const HandlerClass = registryEntry.handlerClass;
-    const handler = this.moduleRef.get(
-      HandlerClass,
-      { strict: false }
-    );
-    const ctx = {
-      input: run.input,
-      run,
-      step: this.makeStepFn(run),
-      spawnChild: this.makeSpawnFn(run),
-      logger: new Logger6(`JobRun:${run.id}`)
-    };
-    const output = await handler.run(ctx);
-    await this.db.update(jobRuns).set({
-      status: "completed",
-      output: output ?? {},
-      finishedAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    }).where(eq6(jobRuns.id, run.id));
-    return output ?? {};
-  }
-  async markFailed(runId, err, finalAttempts) {
-    const [row] = await this.db.select().from(jobRuns).where(eq6(jobRuns.id, runId)).limit(1);
-    if (!row) return;
-    const run = row;
-    await this.db.update(jobRuns).set({
-      status: "failed",
-      attempts: finalAttempts,
-      finishedAt: /* @__PURE__ */ new Date(),
-      error: serialiseError(err, finalAttempts, false),
-      updatedAt: /* @__PURE__ */ new Date()
-    }).where(eq6(jobRuns.id, runId));
-    if (run.parentClosePolicy === "terminate") {
-      try {
-        await this.orchestrator.cancel(run.id, {
-          cascade: true,
-          reason: "parent-failed",
-          tenantId: run.tenantId
-        });
-      } catch (cascadeErr) {
-        this.logger.warn(
-          `cascade on failed run ${run.id}: ${cascadeErr.message}`
-        );
-      }
-    }
-  }
-  // ── ctx.step / ctx.spawnChild (mirror JobWorker) ──────────────────────────
-  makeStepFn(run) {
-    return async (stepId, fn, _opts) => {
-      void _opts;
-      const existing = await this.stepService.findStep(run.id, stepId);
-      if (existing?.status === "completed") {
-        return existing.output;
-      }
-      const nextAttempts = (existing?.attempts ?? 0) + 1;
-      const seq = nextAttempts;
-      await this.stepService.recordStep({
-        jobRunId: run.id,
-        stepId,
-        kind: "task",
-        seq,
-        status: "running",
-        startedAt: /* @__PURE__ */ new Date(),
-        attempts: nextAttempts
-      });
-      try {
-        const output = await fn();
-        await this.stepService.recordStep({
-          jobRunId: run.id,
-          stepId,
-          kind: "task",
-          seq,
-          status: "completed",
-          output,
-          finishedAt: /* @__PURE__ */ new Date(),
-          attempts: nextAttempts
-        });
-        return output;
-      } catch (err) {
-        await this.stepService.recordStep({
-          jobRunId: run.id,
-          stepId,
-          kind: "task",
-          seq,
-          status: "failed",
-          error: serialiseError(err, nextAttempts, false),
-          finishedAt: /* @__PURE__ */ new Date(),
-          attempts: nextAttempts
-        });
-        throw err;
-      }
-    };
-  }
-  makeSpawnFn(run) {
-    return async (type, input, opts) => {
-      return this.orchestrator.start(type, input, {
-        parentRunId: run.id,
-        parentClosePolicy: opts?.closePolicy,
-        runAt: opts?.runAt,
-        priority: opts?.priority,
-        tags: opts?.tags,
-        triggerSource: "parent",
-        triggerRef: run.id,
-        tenantId: run.tenantId
-      });
-    };
-  }
-};
-
 // runtime/subsystems/jobs/job-worker.ts
-import { Inject as Inject9, Injectable as Injectable9, Logger as Logger7 } from "@nestjs/common";
-import { and as and5, asc as asc3, desc as desc4, eq as eq7, inArray as inArray4, lt as lt3, lte, sql as sql6 } from "drizzle-orm";
+import { Inject as Inject7, Injectable as Injectable7, Logger as Logger4 } from "@nestjs/common";
+import { and as and5, asc as asc3, desc as desc4, eq as eq5, inArray as inArray4, lt as lt3, lte, sql as sql6 } from "drizzle-orm";
 var JOB_WORKER_OPTIONS = /* @__PURE__ */ Symbol("JOB_WORKER_OPTIONS");
 var DEFAULT_POLL_INTERVAL_MS = 1e3;
 var DEFAULT_STALE_SWEEPER_INTERVAL_MS = 6e4;
@@ -2618,7 +1978,7 @@ function classifyError(err, policy, currentAttempts) {
   if (currentAttempts + 1 >= policy.attempts) return "fail";
   return "retry";
 }
-function serialiseError2(err, attempt, retryable) {
+function serialiseError(err, attempt, retryable) {
   const e = err;
   return {
     message: e?.message ?? String(err),
@@ -2652,7 +2012,7 @@ var JobWorker = class {
   stepService;
   options;
   moduleRef;
-  logger = new Logger7(JobWorker.name);
+  logger = new Logger4(JobWorker.name);
   shuttingDown = false;
   inFlight = /* @__PURE__ */ new Set();
   pollTimer = null;
@@ -2693,7 +2053,7 @@ var JobWorker = class {
     await this.drainInFlight();
     try {
       await this.db.update(jobRuns).set({ status: "pending", claimedAt: null, startedAt: null }).where(
-        and5(eq7(jobRuns.status, "running"), eq7(jobRuns.pool, this.options.pool))
+        and5(eq5(jobRuns.status, "running"), eq5(jobRuns.pool, this.options.pool))
       );
     } catch (err) {
       this.logger.error(`shutdown reset failed: ${err.message}`);
@@ -2743,8 +2103,8 @@ var JobWorker = class {
     return this.db.transaction(async (tx) => {
       const candidates = await tx.select({ id: jobRuns.id }).from(jobRuns).where(
         and5(
-          eq7(jobRuns.status, "pending"),
-          eq7(jobRuns.pool, pool),
+          eq5(jobRuns.status, "pending"),
+          eq5(jobRuns.pool, pool),
           lte(jobRuns.runAt, /* @__PURE__ */ new Date())
         )
       ).orderBy(desc4(jobRuns.priority), asc3(jobRuns.runAt)).limit(1).for("update", { skipLocked: true });
@@ -2755,7 +2115,7 @@ var JobWorker = class {
         claimedAt: /* @__PURE__ */ new Date(),
         startedAt: /* @__PURE__ */ new Date(),
         updatedAt: /* @__PURE__ */ new Date()
-      }).where(eq7(jobRuns.id, candidate.id)).returning();
+      }).where(eq5(jobRuns.id, candidate.id)).returning();
       return claimed ?? null;
     });
   }
@@ -2773,7 +2133,7 @@ var JobWorker = class {
       await this.db.transaction(async (tx) => {
         const threshold = new Date(Date.now() - this.staleThresholdMs);
         const stale = await tx.select({ id: jobRuns.id }).from(jobRuns).where(
-          and5(eq7(jobRuns.status, "running"), lt3(jobRuns.claimedAt, threshold))
+          and5(eq5(jobRuns.status, "running"), lt3(jobRuns.claimedAt, threshold))
         ).for("update", { skipLocked: true });
         if (stale.length === 0) return;
         const ids = stale.map((r) => r.id);
@@ -2806,8 +2166,8 @@ var JobWorker = class {
     if (claimed.concurrencyKey) {
       const inflight = await this.db.select({ id: jobRuns.id }).from(jobRuns).where(
         and5(
-          eq7(jobRuns.concurrencyKey, claimed.concurrencyKey),
-          eq7(jobRuns.status, "running")
+          eq5(jobRuns.concurrencyKey, claimed.concurrencyKey),
+          eq5(jobRuns.status, "running")
         )
       );
       const other = inflight.find((r) => r.id !== claimed.id);
@@ -2817,7 +2177,7 @@ var JobWorker = class {
           claimedAt: null,
           startedAt: null,
           updatedAt: /* @__PURE__ */ new Date()
-        }).where(eq7(jobRuns.id, claimed.id));
+        }).where(eq5(jobRuns.id, claimed.id));
         return;
       }
     }
@@ -2832,7 +2192,7 @@ var JobWorker = class {
       run: claimed,
       step: this.makeStepFn(claimed),
       spawnChild: this.makeSpawnFn(claimed),
-      logger: new Logger7(`JobRun:${claimed.id}`)
+      logger: new Logger4(`JobRun:${claimed.id}`)
     };
     const attemptsBefore = claimed.attempts ?? 0;
     try {
@@ -2843,7 +2203,7 @@ var JobWorker = class {
         finishedAt: /* @__PURE__ */ new Date(),
         updatedAt: /* @__PURE__ */ new Date(),
         attempts: attemptsBefore + 1
-      }).where(eq7(jobRuns.id, claimed.id));
+      }).where(eq5(jobRuns.id, claimed.id));
     } catch (err) {
       const policy = meta.retry;
       const decision = classifyError(err, policy, attemptsBefore);
@@ -2856,9 +2216,9 @@ var JobWorker = class {
           runAt: new Date(Date.now() + delay),
           startedAt: null,
           claimedAt: null,
-          error: serialiseError2(err, nextAttempts, true),
+          error: serialiseError(err, nextAttempts, true),
           updatedAt: /* @__PURE__ */ new Date()
-        }).where(eq7(jobRuns.id, claimed.id));
+        }).where(eq5(jobRuns.id, claimed.id));
       } else {
         await this.markFailed(claimed, err, nextAttempts);
       }
@@ -2869,9 +2229,9 @@ var JobWorker = class {
       status: "failed",
       attempts: finalAttempts,
       finishedAt: /* @__PURE__ */ new Date(),
-      error: serialiseError2(err, finalAttempts, false),
+      error: serialiseError(err, finalAttempts, false),
       updatedAt: /* @__PURE__ */ new Date()
-    }).where(eq7(jobRuns.id, claimed.id));
+    }).where(eq5(jobRuns.id, claimed.id));
     if (claimed.parentClosePolicy === "terminate") {
       try {
         await this.orchestrator.cancel(claimed.id, {
@@ -2928,7 +2288,7 @@ var JobWorker = class {
           kind: "task",
           seq,
           status: "failed",
-          error: serialiseError2(err, nextAttempts, false),
+          error: serialiseError(err, nextAttempts, false),
           finishedAt: /* @__PURE__ */ new Date(),
           attempts: nextAttempts
         });
@@ -2974,12 +2334,12 @@ var JobWorker = class {
   // ============================================================================
 };
 JobWorker = __decorateClass([
-  Injectable9(),
-  __decorateParam(0, Inject9(DRIZZLE)),
-  __decorateParam(1, Inject9(JOB_ORCHESTRATOR)),
-  __decorateParam(2, Inject9(JOB_RUN_SERVICE)),
-  __decorateParam(3, Inject9(JOB_STEP_SERVICE)),
-  __decorateParam(4, Inject9(JOB_WORKER_OPTIONS))
+  Injectable7(),
+  __decorateParam(0, Inject7(DRIZZLE)),
+  __decorateParam(1, Inject7(JOB_ORCHESTRATOR)),
+  __decorateParam(2, Inject7(JOB_RUN_SERVICE)),
+  __decorateParam(3, Inject7(JOB_STEP_SERVICE)),
+  __decorateParam(4, Inject7(JOB_WORKER_OPTIONS))
 ], JobWorker);
 
 // runtime/subsystems/jobs/memory-job-store.ts
@@ -3000,7 +2360,7 @@ var MemoryJobStore = class {
 
 // runtime/subsystems/jobs/job-orchestrator.memory-backend.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { Inject as Inject10, Injectable as Injectable10, Logger as Logger8, Optional as Optional4 } from "@nestjs/common";
+import { Inject as Inject8, Injectable as Injectable8, Logger as Logger5, Optional as Optional3 } from "@nestjs/common";
 var QUEUED_RUN_AT = /* @__PURE__ */ new Date(864e13);
 var TERMINAL_STATUSES2 = [
   "completed",
@@ -3047,7 +2407,7 @@ var MemoryJobOrchestrator = class {
   stepService;
   multiTenant;
   moduleRef;
-  logger = new Logger8(MemoryJobOrchestrator.name);
+  logger = new Logger5(MemoryJobOrchestrator.name);
   mutex = new PromiseMutex();
   handlerRegistry = /* @__PURE__ */ new Map();
   /**
@@ -3396,7 +2756,7 @@ var MemoryJobOrchestrator = class {
       run,
       step: this.makeStepFn(run),
       spawnChild: this.makeSpawnFn(run),
-      logger: new Logger8(`JobRun:${run.id}`)
+      logger: new Logger5(`JobRun:${run.id}`)
     };
     const attemptsBefore = run.attempts ?? 0;
     try {
@@ -3453,7 +2813,7 @@ var MemoryJobOrchestrator = class {
           kind: "task",
           seq,
           status: "failed",
-          error: serialiseError3(err, nextAttempts, false),
+          error: serialiseError2(err, nextAttempts, false),
           finishedAt: /* @__PURE__ */ new Date(),
           attempts: nextAttempts
         });
@@ -3508,7 +2868,7 @@ var MemoryJobOrchestrator = class {
         finishedAt: now,
         updatedAt: now,
         attempts,
-        error: serialiseError3(err, attempts, false)
+        error: serialiseError2(err, attempts, false)
       });
       this.unblockQueuedDependents(run.id);
     });
@@ -3539,7 +2899,7 @@ var MemoryJobOrchestrator = class {
         startedAt: null,
         claimedAt: null,
         updatedAt: now,
-        error: serialiseError3(err, attempts, true)
+        error: serialiseError2(err, attempts, true)
       });
     });
   }
@@ -3569,9 +2929,9 @@ var MemoryJobOrchestrator = class {
   }
 };
 MemoryJobOrchestrator = __decorateClass([
-  Injectable10(),
-  __decorateParam(2, Inject10(JOBS_MULTI_TENANT)),
-  __decorateParam(3, Optional4())
+  Injectable8(),
+  __decorateParam(2, Inject8(JOBS_MULTI_TENANT)),
+  __decorateParam(3, Optional3())
 ], MemoryJobOrchestrator);
 function classifyError2(err, policy, currentAttempts) {
   if (!policy) return "fail";
@@ -3594,7 +2954,7 @@ function computeBackoff2(policy, attempts) {
   }
   return raw;
 }
-function serialiseError3(err, attempt, retryable) {
+function serialiseError2(err, attempt, retryable) {
   const e = err;
   return {
     message: e?.message ?? String(err),
@@ -3605,7 +2965,7 @@ function serialiseError3(err, attempt, retryable) {
 }
 
 // runtime/subsystems/jobs/job-run-service.memory-backend.ts
-import { Inject as Inject11, Injectable as Injectable11 } from "@nestjs/common";
+import { Inject as Inject9, Injectable as Injectable9 } from "@nestjs/common";
 var NON_TERMINAL_STATUSES2 = [
   "pending",
   "running",
@@ -3772,9 +3132,9 @@ var MemoryJobRunService = class {
   }
 };
 MemoryJobRunService = __decorateClass([
-  Injectable11(),
-  __decorateParam(1, Inject11(JOB_ORCHESTRATOR)),
-  __decorateParam(2, Inject11(JOBS_MULTI_TENANT))
+  Injectable9(),
+  __decorateParam(1, Inject9(JOB_ORCHESTRATOR)),
+  __decorateParam(2, Inject9(JOBS_MULTI_TENANT))
 ], MemoryJobRunService);
 function compareBy(a, b, order) {
   switch (order) {
@@ -3792,7 +3152,7 @@ function compareBy(a, b, order) {
 
 // runtime/subsystems/jobs/job-step-service.memory-backend.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { Injectable as Injectable12 } from "@nestjs/common";
+import { Injectable as Injectable10 } from "@nestjs/common";
 var MemoryJobStepService = class {
   constructor(store) {
     this.store = store;
@@ -3885,7 +3245,7 @@ var MemoryJobStepService = class {
   }
 };
 MemoryJobStepService = __decorateClass([
-  Injectable12()
+  Injectable10()
 ], MemoryJobStepService);
 
 // runtime/subsystems/jobs/jobs-domain.module.ts
@@ -3914,7 +3274,20 @@ var JobsDomainModule = class {
       const resolved = resolveBullMqConfig(opts.extensions?.bullmq);
       providers.push({ provide: BULLMQ_CONNECTION, useValue: resolved.connection });
       providers.push({ provide: BULLMQ_RESOLVED_CONFIG, useValue: resolved });
-      providers.push({ provide: JOB_ORCHESTRATOR, useClass: BullMQJobOrchestrator });
+      providers.push({
+        provide: JOB_ORCHESTRATOR,
+        useFactory: async (...args) => {
+          const specifier = "./job-orchestrator.bullmq-backend";
+          const mod = await import(specifier);
+          return new mod.BullMQJobOrchestrator(...args);
+        },
+        // The bullmq orchestrator constructor mirrors DrizzleJobOrchestrator's
+        // injection list: DRIZZLE + JOBS_MULTI_TENANT + the resolved BullMQ
+        // tokens. Importing token references would force a static dep on the
+        // tokens file in this module's import graph; using the existing
+        // symbols already in scope is sufficient.
+        inject: [DRIZZLE, JOBS_MULTI_TENANT, BULLMQ_CONNECTION, BULLMQ_RESOLVED_CONFIG]
+      });
       providers.push({ provide: JOB_RUN_SERVICE, useClass: DrizzleJobRunService });
       providers.push({ provide: JOB_STEP_SERVICE, useClass: DrizzleJobStepService });
     } else {
@@ -3945,11 +3318,11 @@ JobsDomainModule = __decorateClass([
 
 // runtime/subsystems/jobs/job-worker.module.ts
 import {
-  Inject as Inject12,
-  Injectable as Injectable13,
-  Logger as Logger9,
+  Inject as Inject10,
+  Injectable as Injectable11,
+  Logger as Logger6,
   Module as Module3,
-  Optional as Optional5
+  Optional as Optional4
 } from "@nestjs/common";
 var DEFAULT_SHUTDOWN_TIMEOUT_MS2 = 3e4;
 var JOB_WORKER_MODULE_OPTIONS = /* @__PURE__ */ Symbol("JOB_WORKER_MODULE_OPTIONS");
@@ -3972,7 +3345,7 @@ var JobWorkerOrchestrator = class {
   moduleRef;
   bullConnection;
   bullConfig;
-  logger = new Logger9(JobWorkerOrchestrator.name);
+  logger = new Logger6(JobWorkerOrchestrator.name);
   workers = [];
   // ============================================================================
   // Lifecycle
@@ -4002,7 +3375,7 @@ var JobWorkerOrchestrator = class {
         concurrency: def.concurrency,
         shutdownTimeoutMs: this.options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS2
       };
-      const worker = this.options.workerFactory ? this.options.workerFactory(workerOptions) : backend === "bullmq" ? this.spawnBullMQWorker(poolName, def.queue, def.concurrency, poolConfig) : this.spawnWorker(workerOptions);
+      const worker = this.options.workerFactory ? this.options.workerFactory(workerOptions) : backend === "bullmq" ? await this.spawnBullMQWorker(poolName, def.queue, def.concurrency, poolConfig) : this.spawnWorker(workerOptions);
       await worker.onModuleInit();
       this.workers.push(worker);
       this.logger.log(
@@ -4102,7 +3475,15 @@ var JobWorkerOrchestrator = class {
    * orchestrator's `dispatch` via `resolvePoolQueueName(pool, …)` so producer
    * and consumer agree.
    */
-  spawnBullMQWorker(pool, _queueAlias, concurrency, poolConfig) {
+  /**
+   * #6 — async + dynamic-import. The `job-worker.bullmq-backend.ts` file is
+   * filtered out of the vendor set for drizzle/memory installs (no `bullmq`
+   * peer dep needed). The non-literal import specifier makes TS treat the
+   * module as `any` so the consumer's tsc never tries to resolve an absent
+   * file. This method is only entered when `backend === 'bullmq'` — at which
+   * point the file IS vendored.
+   */
+  async spawnBullMQWorker(pool, _queueAlias, concurrency, poolConfig) {
     if (!this.db) {
       throw new Error(
         `JobWorkerModule: BullMQ worker spawning requires the Drizzle client (no DRIZZLE provider available) \u2014 job_run remains the source of truth.`
@@ -4119,7 +3500,9 @@ var JobWorkerOrchestrator = class {
       );
     }
     const queueName = resolvePoolQueueName(pool, this.bullConfig, poolConfig);
-    return new BullMQJobWorker(
+    const specifier = "./job-worker.bullmq-backend";
+    const mod = await import(specifier);
+    return new mod.BullMQJobWorker(
       this.db,
       this.orchestrator,
       this.stepService,
@@ -4134,17 +3517,17 @@ var JobWorkerOrchestrator = class {
   }
 };
 JobWorkerOrchestrator = __decorateClass([
-  Injectable13(),
-  __decorateParam(0, Inject12(JOB_ORCHESTRATOR)),
-  __decorateParam(1, Inject12(JOB_RUN_SERVICE)),
-  __decorateParam(2, Inject12(JOB_STEP_SERVICE)),
-  __decorateParam(3, Inject12(JOB_WORKER_MODULE_OPTIONS)),
-  __decorateParam(4, Optional5()),
-  __decorateParam(4, Inject12(DRIZZLE)),
-  __decorateParam(6, Optional5()),
-  __decorateParam(6, Inject12(BULLMQ_CONNECTION)),
-  __decorateParam(7, Optional5()),
-  __decorateParam(7, Inject12(BULLMQ_RESOLVED_CONFIG))
+  Injectable11(),
+  __decorateParam(0, Inject10(JOB_ORCHESTRATOR)),
+  __decorateParam(1, Inject10(JOB_RUN_SERVICE)),
+  __decorateParam(2, Inject10(JOB_STEP_SERVICE)),
+  __decorateParam(3, Inject10(JOB_WORKER_MODULE_OPTIONS)),
+  __decorateParam(4, Optional4()),
+  __decorateParam(4, Inject10(DRIZZLE)),
+  __decorateParam(6, Optional4()),
+  __decorateParam(6, Inject10(BULLMQ_CONNECTION)),
+  __decorateParam(7, Optional4()),
+  __decorateParam(7, Inject10(BULLMQ_RESOLVED_CONFIG))
 ], JobWorkerOrchestrator);
 var JobWorkerModule = class {
   static forRoot(opts) {
@@ -4184,8 +3567,8 @@ var CACHE_DEFAULT_TTL = /* @__PURE__ */ Symbol("CACHE_DEFAULT_TTL");
 import { Module as Module4 } from "@nestjs/common";
 
 // runtime/subsystems/cache/cache.drizzle-backend.ts
-import { Injectable as Injectable14, Inject as Inject13, Optional as Optional6 } from "@nestjs/common";
-import { gt as gt2, or as or3, like, sql as sql7, eq as eq8 } from "drizzle-orm";
+import { Injectable as Injectable12, Inject as Inject11, Optional as Optional5 } from "@nestjs/common";
+import { gt as gt2, or as or3, like, sql as sql7, eq as eq6 } from "drizzle-orm";
 
 // runtime/subsystems/cache/cache.schema.ts
 import { pgTable as pgTable3, text as text3, jsonb as jsonb3, timestamp as timestamp3 } from "drizzle-orm/pg-core";
@@ -4246,7 +3629,7 @@ var DrizzleCacheService = class {
     });
   }
   async delete(key) {
-    await this.db.delete(cacheEntries).where(eq8(cacheEntries.key, key));
+    await this.db.delete(cacheEntries).where(eq6(cacheEntries.key, key));
   }
   async invalidateByPrefix(prefix) {
     const escaped = prefix.replace(/%/g, "\\%").replace(/_/g, "\\_");
@@ -4288,14 +3671,14 @@ var DrizzleCacheService = class {
   }
 };
 DrizzleCacheService = __decorateClass([
-  Injectable14(),
-  __decorateParam(0, Inject13(DRIZZLE)),
-  __decorateParam(1, Optional6()),
-  __decorateParam(1, Inject13(CACHE_DEFAULT_TTL))
+  Injectable12(),
+  __decorateParam(0, Inject11(DRIZZLE)),
+  __decorateParam(1, Optional5()),
+  __decorateParam(1, Inject11(CACHE_DEFAULT_TTL))
 ], DrizzleCacheService);
 
 // runtime/subsystems/cache/cache.memory-backend.ts
-import { Injectable as Injectable15, Inject as Inject14, Optional as Optional7 } from "@nestjs/common";
+import { Injectable as Injectable13, Inject as Inject12, Optional as Optional6 } from "@nestjs/common";
 var MemoryCacheService = class {
   constructor(defaultTtl = null) {
     this.defaultTtl = defaultTtl;
@@ -4369,9 +3752,9 @@ var MemoryCacheService = class {
   }
 };
 MemoryCacheService = __decorateClass([
-  Injectable15(),
-  __decorateParam(0, Optional7()),
-  __decorateParam(0, Inject14(CACHE_DEFAULT_TTL))
+  Injectable13(),
+  __decorateParam(0, Optional6()),
+  __decorateParam(0, Inject12(CACHE_DEFAULT_TTL))
 ], MemoryCacheService);
 
 // runtime/subsystems/cache/cache.module.ts
@@ -4631,25 +4014,25 @@ var OBSERVABILITY_MODULE_OPTIONS = "OBSERVABILITY_MODULE_OPTIONS";
 import { Module as Module6 } from "@nestjs/common";
 
 // runtime/subsystems/observability/observability.service.ts
-import { Inject as Inject15, Injectable as Injectable16, Optional as Optional8 } from "@nestjs/common";
+import { Inject as Inject13, Injectable as Injectable14, Optional as Optional7 } from "@nestjs/common";
 
-// runtime/subsystems/sync/sync.tokens.ts
-var SYNC_CURSOR_STORE = "SYNC_CURSOR_STORE";
-var SYNC_RUN_RECORDER = "SYNC_RUN_RECORDER";
+// runtime/subsystems/integration/integration.tokens.ts
+var INTEGRATION_CURSOR_STORE = "INTEGRATION_CURSOR_STORE";
+var INTEGRATION_RUN_RECORDER = "INTEGRATION_RUN_RECORDER";
 
 // runtime/subsystems/observability/observability.service.ts
 var MAX_TIMELINE_PAGES = 50;
 var ObservabilityService = class {
-  constructor(jobRuns2, bridge, syncRuns, cursors, events) {
+  constructor(jobRuns2, bridge, integrationRuns, cursors, events) {
     this.jobRuns = jobRuns2;
     this.bridge = bridge;
-    this.syncRuns = syncRuns;
+    this.integrationRuns = integrationRuns;
     this.cursors = cursors;
     this.events = events;
   }
   jobRuns;
   bridge;
-  syncRuns;
+  integrationRuns;
   cursors;
   events;
   async getPoolDepths(tenantId) {
@@ -4664,9 +4047,9 @@ var ObservabilityService = class {
     if (!this.bridge) return { ...ObservabilityService.EMPTY_HISTOGRAM };
     return this.bridge.getStatusHistogram(windowHours, tenantId);
   }
-  async getRecentSyncRuns(limit, subscriptionId, tenantId) {
-    if (!this.syncRuns) return [];
-    return this.syncRuns.listRecent(limit, subscriptionId, tenantId);
+  async getRecentIntegrationRuns(limit, subscriptionId, tenantId) {
+    if (!this.integrationRuns) return [];
+    return this.integrationRuns.listRecent(limit, subscriptionId, tenantId);
   }
   async getCursors(tenantId) {
     if (!this.cursors) return [];
@@ -4784,24 +4167,24 @@ __publicField(ObservabilityService, "EMPTY_EVENT_PAGE", {
   nextCursor: null
 });
 ObservabilityService = __decorateClass([
-  Injectable16(),
-  __decorateParam(0, Optional8()),
-  __decorateParam(0, Inject15(JOB_RUN_SERVICE)),
-  __decorateParam(1, Optional8()),
-  __decorateParam(1, Inject15(BRIDGE_DELIVERY_REPO)),
-  __decorateParam(2, Optional8()),
-  __decorateParam(2, Inject15(SYNC_RUN_RECORDER)),
-  __decorateParam(3, Optional8()),
-  __decorateParam(3, Inject15(SYNC_CURSOR_STORE)),
-  __decorateParam(4, Optional8()),
-  __decorateParam(4, Inject15(EVENT_READ_PORT))
+  Injectable14(),
+  __decorateParam(0, Optional7()),
+  __decorateParam(0, Inject13(JOB_RUN_SERVICE)),
+  __decorateParam(1, Optional7()),
+  __decorateParam(1, Inject13(BRIDGE_DELIVERY_REPO)),
+  __decorateParam(2, Optional7()),
+  __decorateParam(2, Inject13(INTEGRATION_RUN_RECORDER)),
+  __decorateParam(3, Optional7()),
+  __decorateParam(3, Inject13(INTEGRATION_CURSOR_STORE)),
+  __decorateParam(4, Optional7()),
+  __decorateParam(4, Inject13(EVENT_READ_PORT))
 ], ObservabilityService);
 
 // runtime/subsystems/observability/reporters/bridge-metrics.reporter.ts
 import {
-  Inject as Inject16,
-  Injectable as Injectable17,
-  Logger as Logger10
+  Inject as Inject14,
+  Injectable as Injectable15,
+  Logger as Logger7
 } from "@nestjs/common";
 var BridgeMetricsReporter = class {
   constructor(observability, options) {
@@ -4809,7 +4192,7 @@ var BridgeMetricsReporter = class {
     this.config = options.reporters?.bridgeMetrics;
   }
   observability;
-  logger = new Logger10(BridgeMetricsReporter.name);
+  logger = new Logger7(BridgeMetricsReporter.name);
   handle = null;
   config;
   onModuleInit() {
@@ -4860,9 +4243,9 @@ var BridgeMetricsReporter = class {
   }
 };
 BridgeMetricsReporter = __decorateClass([
-  Injectable17(),
-  __decorateParam(0, Inject16(OBSERVABILITY)),
-  __decorateParam(1, Inject16(OBSERVABILITY_MODULE_OPTIONS))
+  Injectable15(),
+  __decorateParam(0, Inject14(OBSERVABILITY)),
+  __decorateParam(1, Inject14(OBSERVABILITY_MODULE_OPTIONS))
 ], BridgeMetricsReporter);
 
 // runtime/subsystems/observability/observability.module.ts
@@ -4917,25 +4300,25 @@ var OAuthStateError = class extends Error {
 // runtime/subsystems/auth/auth.tokens.ts
 var ENCRYPTION_KEY = /* @__PURE__ */ Symbol("ENCRYPTION_KEY");
 var OAUTH_STATE_STORE = /* @__PURE__ */ Symbol("OAUTH_STATE_STORE");
-var AUTH_INTEGRATION_READER = /* @__PURE__ */ Symbol("AUTH_INTEGRATION_READER");
-var AUTH_INTEGRATION_TOKEN_WRITER = /* @__PURE__ */ Symbol("AUTH_INTEGRATION_TOKEN_WRITER");
-var AUTH_INTEGRATION_GRANT_SINK = /* @__PURE__ */ Symbol("AUTH_INTEGRATION_GRANT_SINK");
+var AUTH_CONNECTION_READER = /* @__PURE__ */ Symbol("AUTH_CONNECTION_READER");
+var AUTH_CONNECTION_TOKEN_WRITER = /* @__PURE__ */ Symbol("AUTH_CONNECTION_TOKEN_WRITER");
+var AUTH_CONNECTION_GRANT_SINK = /* @__PURE__ */ Symbol("AUTH_CONNECTION_GRANT_SINK");
 var AUTH_USER_CONTEXT = /* @__PURE__ */ Symbol("AUTH_USER_CONTEXT");
 var STRATEGY_REGISTRY = /* @__PURE__ */ Symbol("STRATEGY_REGISTRY");
 var AUTH_OPTIONS = /* @__PURE__ */ Symbol("AUTH_OPTIONS");
 
-// runtime/subsystems/auth/runtime/integration-broken.error.ts
-var IntegrationBrokenError = class extends Error {
-  constructor(integrationId, errorCode, errorDescription) {
+// runtime/subsystems/auth/runtime/connection-broken.error.ts
+var ConnectionBrokenError = class extends Error {
+  constructor(connectionId, errorCode, errorDescription) {
     super(
-      `Integration ${integrationId} broken: ${errorCode} - ${errorDescription}`
+      `Connection ${connectionId} broken: ${errorCode} - ${errorDescription}`
     );
-    this.integrationId = integrationId;
+    this.connectionId = connectionId;
     this.errorCode = errorCode;
     this.errorDescription = errorDescription;
-    this.name = "IntegrationBrokenError";
+    this.name = "ConnectionBrokenError";
   }
-  integrationId;
+  connectionId;
   errorCode;
   errorDescription;
 };
@@ -4943,53 +4326,53 @@ var IntegrationBrokenError = class extends Error {
 // runtime/subsystems/auth/runtime/oauth2-refresh.strategy.ts
 var REFRESH_SAFETY_MS = 5 * 60 * 1e3;
 var OAuth2RefreshStrategy = class {
-  integrationReader;
+  connectionReader;
   tokenWriter;
   fetchImpl;
   now;
   constructor(opts) {
-    this.integrationReader = opts.integrationReader;
+    this.connectionReader = opts.connectionReader;
     this.tokenWriter = opts.tokenWriter;
     this.fetchImpl = opts.fetch ?? fetch;
     this.now = opts.now ?? Date.now;
   }
-  async resolve(integrationId, opts = {}) {
-    const integration = await this.integrationReader.findByIdDecrypted(integrationId);
-    if (!integration) {
-      throw new Error(`Integration ${integrationId} not found`);
+  async resolve(connectionId, opts = {}) {
+    const connection = await this.connectionReader.findByIdDecrypted(connectionId);
+    if (!connection) {
+      throw new Error(`Connection ${connectionId} not found`);
     }
-    if (integration.provider !== this.provider) {
+    if (connection.provider !== this.provider) {
       throw new Error(
-        `${this.constructor.name} called for non-${this.provider} integration ${integrationId} (provider=${integration.provider})`
+        `${this.constructor.name} called for non-${this.provider} connection ${connectionId} (provider=${connection.provider})`
       );
     }
-    const needsRefresh = opts.forceRefresh || this.isExpiring(integration.expiresAt) || !integration.accessToken;
+    const needsRefresh = opts.forceRefresh || this.isExpiring(connection.expiresAt) || !connection.accessToken;
     if (!needsRefresh) {
-      return this.buildCredentials(integration.accessToken, integration);
+      return this.buildCredentials(connection.accessToken, connection);
     }
-    if (!integration.refreshToken) {
-      throw new IntegrationBrokenError(
-        integrationId,
+    if (!connection.refreshToken) {
+      throw new ConnectionBrokenError(
+        connectionId,
         "no_refresh_token",
-        "Integration has no refresh token; user must reconnect"
+        "Connection has no refresh token; user must reconnect"
       );
     }
     const { parsed, raw } = await this.executeRefresh(
-      integrationId,
-      integration.refreshToken
+      connectionId,
+      connection.refreshToken
     );
     const newExpiresAt = new Date(
       this.now() + (parsed.expiresInSec ?? this.defaultExpiresInSec) * 1e3
     );
     await this.tokenWriter.persistRefresh({
-      integrationId,
+      connectionId,
       accessToken: parsed.accessToken,
       refreshToken: parsed.refreshToken ?? void 0,
       expiresAt: newExpiresAt
     });
-    return this.buildCredentials(parsed.accessToken, integration, raw);
+    return this.buildCredentials(parsed.accessToken, connection, raw);
   }
-  async executeRefresh(integrationId, refreshToken) {
+  async executeRefresh(connectionId, refreshToken) {
     const body = new URLSearchParams({
       grant_type: "refresh_token",
       refresh_token: refreshToken,
@@ -5003,8 +4386,8 @@ var OAuth2RefreshStrategy = class {
     if (!response.ok) {
       const err = await safeJson(response);
       if (response.status === 400 && (err.error === "invalid_grant" || err.error === "invalid_token")) {
-        throw new IntegrationBrokenError(
-          integrationId,
+        throw new ConnectionBrokenError(
+          connectionId,
           err.error ?? "invalid_grant",
           err.error_description ?? err.message ?? "refresh token rejected"
         );
@@ -5047,14 +4430,14 @@ function isSessionExpiredError(err) {
 }
 
 // runtime/subsystems/auth/runtime/with-auth-retry.ts
-async function withAuthRetry(authStrategy, integrationId, op, options = {}) {
+async function withAuthRetry(authStrategy, connectionId, op, options = {}) {
   const classify = options.isSessionExpired ?? isSessionExpiredError;
-  let creds = await authStrategy.resolve(integrationId);
+  let creds = await authStrategy.resolve(connectionId);
   try {
     return await op(creds);
   } catch (e) {
     if (!classify(e)) throw e;
-    creds = await authStrategy.resolve(integrationId, { forceRefresh: true });
+    creds = await authStrategy.resolve(connectionId, { forceRefresh: true });
     return op(creds);
   }
 }
@@ -5156,7 +4539,7 @@ var MemoryOAuthStateStore = class {
 
 // runtime/subsystems/auth/backends/state-store.drizzle-backend.ts
 import { randomBytes as randomBytes3 } from "crypto";
-import { eq as eq9 } from "drizzle-orm";
+import { eq as eq7 } from "drizzle-orm";
 var DrizzleOAuthStateStore = class {
   constructor(db, opts = {}) {
     this.db = db;
@@ -5180,7 +4563,7 @@ var DrizzleOAuthStateStore = class {
     return state;
   }
   async consume(state) {
-    const rows = await this.db.delete(authOAuthState).where(eq9(authOAuthState.state, state)).returning();
+    const rows = await this.db.delete(authOAuthState).where(eq7(authOAuthState.state, state)).returning();
     const row = rows[0];
     if (!row) {
       throw new OAuthStateError(
@@ -5202,7 +4585,7 @@ var DrizzleOAuthStateStore = class {
 import {
   Controller,
   Get,
-  Inject as Inject17,
+  Inject as Inject15,
   Param,
   Query,
   Req,
@@ -5264,7 +4647,7 @@ var AuthController = class {
     });
     return res.redirect(
       HttpStatus.FOUND,
-      redirect ?? `/settings/integrations?connected=${encodeURIComponent(slug)}`
+      redirect ?? `/settings/connections?connected=${encodeURIComponent(slug)}`
     );
   }
   requireStrategy(slug) {
@@ -5304,11 +4687,11 @@ __decorateClass([
 ], AuthController.prototype, "callback", 1);
 AuthController = __decorateClass([
   Controller("auth"),
-  __decorateParam(0, Inject17(STRATEGY_REGISTRY)),
-  __decorateParam(1, Inject17(AUTH_USER_CONTEXT)),
-  __decorateParam(2, Inject17(OAUTH_STATE_STORE)),
-  __decorateParam(3, Inject17(AUTH_INTEGRATION_GRANT_SINK)),
-  __decorateParam(4, Inject17(AUTH_OPTIONS))
+  __decorateParam(0, Inject15(STRATEGY_REGISTRY)),
+  __decorateParam(1, Inject15(AUTH_USER_CONTEXT)),
+  __decorateParam(2, Inject15(OAUTH_STATE_STORE)),
+  __decorateParam(3, Inject15(AUTH_CONNECTION_GRANT_SINK)),
+  __decorateParam(4, Inject15(AUTH_OPTIONS))
 ], AuthController);
 
 // runtime/base-classes/tenant-context.ts
@@ -5379,15 +4762,16 @@ AuthModule = __decorateClass([
   Module7({})
 ], AuthModule);
 export {
-  AUTH_INTEGRATION_GRANT_SINK,
-  AUTH_INTEGRATION_READER,
-  AUTH_INTEGRATION_TOKEN_WRITER,
+  AUTH_CONNECTION_GRANT_SINK,
+  AUTH_CONNECTION_READER,
+  AUTH_CONNECTION_TOKEN_WRITER,
   AUTH_OPTIONS,
   AUTH_USER_CONTEXT,
   AuthController,
   AuthModule,
   CACHE,
   CacheModule,
+  ConnectionBrokenError,
   DrizzleCacheService,
   DrizzleEventBus,
   DrizzleOAuthStateStore,
@@ -5395,7 +4779,6 @@ export {
   EVENT_BUS,
   EnvEncryptionKey,
   EventsModule,
-  IntegrationBrokenError,
   LocalStorageBackend,
   MemoryCacheService,
   MemoryEventBus,