@pattern-stack/codegen 0.8.0 → 0.9.0

package/dist/runtime/subsystems/jobs/jobs-domain.module.d.ts

@@ -1,4 +1,7 @@
 import { DynamicModule } from '@nestjs/common';
+import { BullMqExtensionsConfig } from './bullmq.config.js';
+import 'bullmq';
+import './pool-config.loader.js';
 
 /**
  * JobsDomainModule — `DynamicModule.forRoot({ backend })` factory wiring
@@ -32,7 +35,7 @@ interface DrizzleBackendExtensions {
     pollIntervalMs?: number;
 }
 interface JobsDomainModuleOptions {
-    backend: 'drizzle' | 'memory';
+    backend: 'drizzle' | 'memory' | 'bullmq';
     /**
      * Backend-specific extensions. Only the matching backend's extensions
      * are read at boot; non-matching keys are ignored. This is the
@@ -40,6 +43,12 @@ interface JobsDomainModuleOptions {
      */
     extensions?: {
         drizzle?: DrizzleBackendExtensions;
+        /**
+         * BullMQ backend extensions (BULLMQ-1). Snake_case mirrors the YAML
+         * under `jobs.extensions.bullmq`. `redis_url` falls back to
+         * `process.env.REDIS_URL` then `redis://localhost:6379`.
+         */
+        bullmq?: BullMqExtensionsConfig;
     };
     /** Multi-tenancy opt-in. Wired by JOB-8; module signature stays stable. */
     multiTenant?: boolean;

package/dist/runtime/subsystems/jobs/jobs-domain.module.js

@@ -565,7 +565,58 @@ function notInStatus(statuses) {
 
 // runtime/subsystems/jobs/job-run-service.drizzle-backend.ts
 import { Inject as Inject2, Injectable as Injectable2 } from "@nestjs/common";
-import { and as and2, asc, desc as desc2, eq as eq2, inArray as inArray2, isNull, sql as sql3 } from "drizzle-orm";
+import { and as and2, asc, desc as desc2, eq as eq2, gte, inArray as inArray2, isNull, lt, or, sql as sql3 } from "drizzle-orm";
+
+// runtime/subsystems/jobs/job-run-keyset-cursor.ts
+var DEFAULT_LIST_LIMIT = 50;
+var MAX_LIST_LIMIT = 200;
+function clampLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) {
+    return DEFAULT_LIST_LIMIT;
+  }
+  const floored = Math.floor(limit);
+  if (floored < 1) return 1;
+  if (floored > MAX_LIST_LIMIT) return MAX_LIST_LIMIT;
+  return floored;
+}
+function encodeKeysetCursor(keyset) {
+  const tuple = [keyset.createdAt.toISOString(), keyset.id];
+  return Buffer.from(JSON.stringify(tuple), "utf8").toString("base64url");
+}
+function decodeKeysetCursor(cursor) {
+  try {
+    const json = Buffer.from(cursor, "base64url").toString("utf8");
+    const parsed = JSON.parse(json);
+    if (!Array.isArray(parsed) || parsed.length !== 2) return null;
+    const [iso, id] = parsed;
+    if (typeof iso !== "string" || typeof id !== "string") return null;
+    const createdAt = new Date(iso);
+    if (Number.isNaN(createdAt.getTime())) return null;
+    return { createdAt, id };
+  } catch {
+    return null;
+  }
+}
+function toJobRunSummary(r) {
+  return {
+    runId: r.id,
+    rootRunId: r.rootRunId,
+    jobType: r.jobType,
+    pool: r.pool,
+    status: r.status,
+    scopeEntityType: r.scopeEntityType,
+    scopeEntityId: r.scopeEntityId,
+    tenantId: r.tenantId,
+    attempts: r.attempts,
+    errorMessage: r.error?.message ?? null,
+    runAt: r.runAt,
+    startedAt: r.startedAt,
+    finishedAt: r.finishedAt,
+    createdAt: r.createdAt
+  };
+}
+
+// runtime/subsystems/jobs/job-run-service.drizzle-backend.ts
 var NON_TERMINAL_STATUSES = [
   "pending",
   "running",
@@ -688,6 +739,37 @@ var DrizzleJobRunService = class {
       createdAt: r.createdAt
     }));
   }
+  async listJobRuns(query = {}) {
+    const limit = clampLimit(query.limit);
+    const conditions = [];
+    const tenantCond = this.tenantCondition("listJobRuns", query.tenantId);
+    if (tenantCond) conditions.push(tenantCond);
+    if (query.poolId) conditions.push(eq2(jobRuns.pool, query.poolId));
+    if (query.rootRunId) conditions.push(eq2(jobRuns.rootRunId, query.rootRunId));
+    if (query.status) conditions.push(eq2(jobRuns.status, query.status));
+    if (query.since) conditions.push(gte(jobRuns.createdAt, query.since));
+    if (query.cursor) {
+      const keyset = decodeKeysetCursor(query.cursor);
+      if (keyset) {
+        conditions.push(
+          or(
+            lt(jobRuns.createdAt, keyset.createdAt),
+            and2(
+              eq2(jobRuns.createdAt, keyset.createdAt),
+              lt(jobRuns.id, keyset.id)
+            )
+          )
+        );
+      }
+    }
+    const rows = await this.db.select().from(jobRuns).where(conditions.length > 0 ? and2(...conditions) : void 0).orderBy(desc2(jobRuns.createdAt), desc2(jobRuns.id)).limit(limit + 1);
+    const hasMore = rows.length > limit;
+    const page = hasMore ? rows.slice(0, limit) : rows;
+    const items = page.map(toJobRunSummary);
+    const last = page[page.length - 1];
+    const nextCursor = hasMore && last ? encodeKeysetCursor({ createdAt: last.createdAt, id: last.id }) : null;
+    return { items, nextCursor };
+  }
   /**
    * Internal helper used by cascade paths (not on the public protocol).
    * Exposed as a public method on the concrete class so infrastructure
@@ -749,9 +831,384 @@ DrizzleJobStepService = __decorateClass([
   __decorateParam(0, Inject3(DRIZZLE))
 ], DrizzleJobStepService);
 
+// runtime/subsystems/jobs/job-orchestrator.bullmq-backend.ts
+import { createHash } from "crypto";
+import { Inject as Inject4, Injectable as Injectable4, Logger as Logger2, Optional } from "@nestjs/common";
+import { eq as eq4 } from "drizzle-orm";
+
+// runtime/subsystems/jobs/pool-config.loader.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { parse as parseYaml } from "yaml";
+var FRAMEWORK_POOLS = Object.freeze({
+  events_inbound: Object.freeze({
+    queue: "jobs-events-inbound",
+    concurrency: 20,
+    reserved: true,
+    description: "Inbound events drain (events subsystem outbox)."
+  }),
+  events_change: Object.freeze({
+    queue: "jobs-events-change",
+    concurrency: 30,
+    reserved: true,
+    description: "Change events drain (events subsystem outbox)."
+  }),
+  events_outbound: Object.freeze({
+    queue: "jobs-events-outbound",
+    concurrency: 10,
+    reserved: true,
+    description: "Outbound events drain (events subsystem outbox)."
+  }),
+  interactive: Object.freeze({
+    queue: "jobs-interactive",
+    concurrency: 20,
+    reserved: false,
+    description: "User-facing latency-sensitive jobs."
+  }),
+  batch: Object.freeze({
+    queue: "jobs-batch",
+    concurrency: 5,
+    reserved: false,
+    description: "Default pool for background jobs."
+  })
+});
+var RESERVED_POOL_NAMES = new Set(
+  Object.entries(FRAMEWORK_POOLS).filter(([, def]) => def.reserved).map(([name]) => name)
+);
+var cache = /* @__PURE__ */ new Map();
+function loadPoolConfig(configPath) {
+  const resolved = resolve(configPath ?? `${process.cwd()}/codegen.config.yaml`);
+  const cached = cache.get(resolved);
+  if (cached) return cached;
+  const merged = /* @__PURE__ */ new Map();
+  for (const [name, def] of Object.entries(FRAMEWORK_POOLS)) {
+    merged.set(name, { ...def });
+  }
+  if (!existsSync(resolved)) {
+    cache.set(resolved, merged);
+    return merged;
+  }
+  let raw;
+  try {
+    raw = parseYaml(readFileSync(resolved, "utf8"));
+  } catch (err) {
+    throw new Error(
+      `pool-config.loader: failed to parse YAML at ${resolved}: ${err.message}`
+    );
+  }
+  const userPools = extractUserPools(raw);
+  for (const [name, userDef] of Object.entries(userPools)) {
+    const existing = merged.get(name);
+    if (existing) {
+      const next = {
+        queue: existing.queue,
+        concurrency: typeof userDef.concurrency === "number" ? userDef.concurrency : existing.concurrency,
+        reserved: existing.reserved,
+        description: userDef.description ?? existing.description
+      };
+      merged.set(name, next);
+      continue;
+    }
+    if (typeof userDef.queue !== "string" || userDef.queue.length === 0) {
+      throw new Error(
+        `pool-config.loader: pool '${name}' must declare a non-empty 'queue'.`
+      );
+    }
+    if (typeof userDef.concurrency !== "number" || userDef.concurrency <= 0) {
+      throw new Error(
+        `pool-config.loader: pool '${name}' must declare a positive 'concurrency'.`
+      );
+    }
+    if (userDef.reserved === true) {
+      throw new Error(
+        `pool-config.loader: user-defined pool '${name}' cannot set 'reserved: true' \u2014 reserved is framework-only.`
+      );
+    }
+    merged.set(name, {
+      queue: userDef.queue,
+      concurrency: userDef.concurrency,
+      reserved: false,
+      description: userDef.description
+    });
+  }
+  cache.set(resolved, merged);
+  return merged;
+}
+function extractUserPools(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const jobs2 = raw.jobs;
+  if (!jobs2 || typeof jobs2 !== "object") return {};
+  const pools = jobs2.pools;
+  if (!pools || typeof pools !== "object") return {};
+  const out = {};
+  for (const [name, def] of Object.entries(pools)) {
+    if (!def || typeof def !== "object") continue;
+    out[name] = def;
+  }
+  return out;
+}
+
+// runtime/subsystems/jobs/bullmq.config.ts
+var BULLMQ_CONNECTION = /* @__PURE__ */ Symbol("BULLMQ_CONNECTION");
+var BULLMQ_RESOLVED_CONFIG = /* @__PURE__ */ Symbol("BULLMQ_RESOLVED_CONFIG");
+var DEFAULT_REDIS_URL = "redis://localhost:6379";
+var DEFAULT_BULL_BOARD_MOUNT = "/admin/queues";
+function resolveBullMqConfig(ext) {
+  const url = ext?.redis_url ?? process.env.REDIS_URL ?? DEFAULT_REDIS_URL;
+  const resolved = {
+    connection: { url },
+    queuePrefix: ext?.queue_prefix
+  };
+  if (ext?.bull_board?.enabled) {
+    resolved.bullBoard = {
+      enabled: true,
+      mountPath: ext.bull_board.mount_path ?? DEFAULT_BULL_BOARD_MOUNT
+    };
+  }
+  return resolved;
+}
+function resolvePoolQueueName(pool, config, poolConfig = loadPoolConfig()) {
+  const alias = poolConfig.get(pool)?.queue ?? pool;
+  const prefix = config?.queuePrefix;
+  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 Logger2(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(eq4(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(eq4(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(eq4(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([
+  Injectable4(),
+  __decorateParam(0, Inject4(DRIZZLE)),
+  __decorateParam(1, Inject4(JOBS_MULTI_TENANT)),
+  __decorateParam(2, Inject4(BULLMQ_CONNECTION)),
+  __decorateParam(3, Optional()),
+  __decorateParam(3, Inject4(BULLMQ_RESOLVED_CONFIG))
+], BullMQJobOrchestrator);
+
 // runtime/subsystems/jobs/job-orchestrator.memory-backend.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { Inject as Inject4, Injectable as Injectable4, Logger as Logger2, Optional } from "@nestjs/common";
+import { Inject as Inject5, Injectable as Injectable5, Logger as Logger3, Optional as Optional2 } from "@nestjs/common";
 
 // runtime/subsystems/jobs/job-handler.base.ts
 var JOB_HANDLER_REGISTRY = /* @__PURE__ */ new Map();
@@ -814,7 +1271,7 @@ var MemoryJobOrchestrator = class {
   stepService;
   multiTenant;
   moduleRef;
-  logger = new Logger2(MemoryJobOrchestrator.name);
+  logger = new Logger3(MemoryJobOrchestrator.name);
   mutex = new PromiseMutex();
   handlerRegistry = /* @__PURE__ */ new Map();
   /**
@@ -1163,7 +1620,7 @@ var MemoryJobOrchestrator = class {
       run,
       step: this.makeStepFn(run),
       spawnChild: this.makeSpawnFn(run),
-      logger: new Logger2(`JobRun:${run.id}`)
+      logger: new Logger3(`JobRun:${run.id}`)
     };
     const attemptsBefore = run.attempts ?? 0;
     try {
@@ -1336,9 +1793,9 @@ var MemoryJobOrchestrator = class {
   }
 };
 MemoryJobOrchestrator = __decorateClass([
-  Injectable4(),
-  __decorateParam(2, Inject4(JOBS_MULTI_TENANT)),
-  __decorateParam(3, Optional())
+  Injectable5(),
+  __decorateParam(2, Inject5(JOBS_MULTI_TENANT)),
+  __decorateParam(3, Optional2())
 ], MemoryJobOrchestrator);
 function classifyError(err, policy, currentAttempts) {
   if (!policy) return "fail";
@@ -1372,7 +1829,7 @@ function serialiseError(err, attempt, retryable) {
 }
 
 // runtime/subsystems/jobs/job-run-service.memory-backend.ts
-import { Inject as Inject5, Injectable as Injectable5 } from "@nestjs/common";
+import { Inject as Inject6, Injectable as Injectable6 } from "@nestjs/common";
 var NON_TERMINAL_STATUSES2 = [
   "pending",
   "running",
@@ -1489,6 +1946,38 @@ var MemoryJobRunService = class {
       createdAt: r.createdAt
     }));
   }
+  async listJobRuns(query = {}) {
+    const limit = clampLimit(query.limit);
+    const tenantCheck = this.tenantPredicate("listJobRuns", query.tenantId);
+    const keyset = query.cursor ? decodeKeysetCursor(query.cursor) : null;
+    const matched = [];
+    for (const r of this.store.runs.values()) {
+      if (tenantCheck && !tenantCheck(r)) continue;
+      if (query.poolId && r.pool !== query.poolId) continue;
+      if (query.rootRunId && r.rootRunId !== query.rootRunId) continue;
+      if (query.status && r.status !== query.status) continue;
+      if (query.since && r.createdAt.getTime() < query.since.getTime()) continue;
+      matched.push(r);
+    }
+    matched.sort((a, b) => {
+      const dt = b.createdAt.getTime() - a.createdAt.getTime();
+      if (dt !== 0) return dt;
+      return a.id < b.id ? 1 : a.id > b.id ? -1 : 0;
+    });
+    const seeked = keyset ? matched.filter((r) => {
+      const ct = r.createdAt.getTime();
+      const kt = keyset.createdAt.getTime();
+      if (ct < kt) return true;
+      if (ct > kt) return false;
+      return r.id < keyset.id;
+    }) : matched;
+    const hasMore = seeked.length > limit;
+    const page = hasMore ? seeked.slice(0, limit) : seeked;
+    const items = page.map(toJobRunSummary);
+    const last = page[page.length - 1];
+    const nextCursor = hasMore && last ? encodeKeysetCursor({ createdAt: last.createdAt, id: last.id }) : null;
+    return { items, nextCursor };
+  }
   /**
    * Direct lookup. Not on the protocol — concrete-class convenience for
    * tests. Matches `DrizzleJobRunService.findByRootRunId` in spirit; both
@@ -1507,9 +1996,9 @@ var MemoryJobRunService = class {
   }
 };
 MemoryJobRunService = __decorateClass([
-  Injectable5(),
-  __decorateParam(1, Inject5(JOB_ORCHESTRATOR)),
-  __decorateParam(2, Inject5(JOBS_MULTI_TENANT))
+  Injectable6(),
+  __decorateParam(1, Inject6(JOB_ORCHESTRATOR)),
+  __decorateParam(2, Inject6(JOBS_MULTI_TENANT))
 ], MemoryJobRunService);
 function compareBy(a, b, order) {
   switch (order) {
@@ -1527,7 +2016,7 @@ function compareBy(a, b, order) {
 
 // runtime/subsystems/jobs/job-step-service.memory-backend.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { Injectable as Injectable6 } from "@nestjs/common";
+import { Injectable as Injectable7 } from "@nestjs/common";
 var MemoryJobStepService = class {
   constructor(store) {
     this.store = store;
@@ -1620,7 +2109,7 @@ var MemoryJobStepService = class {
   }
 };
 MemoryJobStepService = __decorateClass([
-  Injectable6()
+  Injectable7()
 ], MemoryJobStepService);
 
 // runtime/subsystems/jobs/memory-job-store.ts
@@ -1642,7 +2131,6 @@ var MemoryJobStore = class {
 // runtime/subsystems/jobs/jobs-domain.module.ts
 var JobsDomainModule = class {
   static forRoot(opts) {
-    void opts.extensions;
     const multiTenant = opts.multiTenant ?? false;
     const providers = [
       // JOB-8 — boolean provider consumed by the four service-layer backends.
@@ -1661,21 +2149,32 @@ var JobsDomainModule = class {
       providers.push({ provide: JOB_ORCHESTRATOR, useExisting: MemoryJobOrchestrator });
       providers.push(MemoryJobRunService);
       providers.push({ provide: JOB_RUN_SERVICE, useExisting: MemoryJobRunService });
+    } else if (opts.backend === "bullmq") {
+      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_RUN_SERVICE, useClass: DrizzleJobRunService });
+      providers.push({ provide: JOB_STEP_SERVICE, useClass: DrizzleJobStepService });
     } else {
       providers.push({ provide: JOB_ORCHESTRATOR, useClass: DrizzleJobOrchestrator });
       providers.push({ provide: JOB_RUN_SERVICE, useClass: DrizzleJobRunService });
       providers.push({ provide: JOB_STEP_SERVICE, useClass: DrizzleJobStepService });
     }
+    const exports = [
+      JOB_ORCHESTRATOR,
+      JOB_RUN_SERVICE,
+      JOB_STEP_SERVICE,
+      JOBS_MULTI_TENANT
+    ];
+    if (opts.backend === "bullmq") {
+      exports.push(BULLMQ_CONNECTION, BULLMQ_RESOLVED_CONFIG);
+    }
     return {
       module: JobsDomainModule,
       global: true,
       providers,
-      exports: [
-        JOB_ORCHESTRATOR,
-        JOB_RUN_SERVICE,
-        JOB_STEP_SERVICE,
-        JOBS_MULTI_TENANT
-      ]
+      exports
     };
   }
 };