@pattern-stack/codegen 0.10.0 → 0.11.0

package/dist/runtime/subsystems/jobs/job-worker.module.js

@@ -12,11 +12,11 @@ var __decorateParam = (index2, decorator) => (target, key) => decorator(target,
 
 // runtime/subsystems/jobs/job-worker.module.ts
 import {
-  Inject as Inject8,
-  Injectable as Injectable9,
-  Logger as Logger6,
+  Inject as Inject7,
+  Injectable as Injectable8,
+  Logger as Logger4,
   Module as Module2,
-  Optional as Optional3
+  Optional as Optional2
 } from "@nestjs/common";
 
 // runtime/constants/tokens.ts
@@ -878,394 +878,9 @@ 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 allNonReservedPoolNames(config) {
-  const out = [];
-  for (const [name, def] of config) {
-    if (!def.reserved) out.push(name);
-  }
-  return out;
-}
-function allPoolNames(config) {
-  return [...config.keys()];
-}
-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 Inject5, Injectable as Injectable5, Logger as Logger3, Optional as Optional2 } from "@nestjs/common";
+import { Inject as Inject4, Injectable as Injectable4, Logger as Logger2, Optional } from "@nestjs/common";
 var QUEUED_RUN_AT = /* @__PURE__ */ new Date(864e13);
 var TERMINAL_STATUSES2 = [
   "completed",
@@ -1312,7 +927,7 @@ var MemoryJobOrchestrator = class {
   stepService;
   multiTenant;
   moduleRef;
-  logger = new Logger3(MemoryJobOrchestrator.name);
+  logger = new Logger2(MemoryJobOrchestrator.name);
   mutex = new PromiseMutex();
   handlerRegistry = /* @__PURE__ */ new Map();
   /**
@@ -1661,7 +1276,7 @@ var MemoryJobOrchestrator = class {
       run,
       step: this.makeStepFn(run),
       spawnChild: this.makeSpawnFn(run),
-      logger: new Logger3(`JobRun:${run.id}`)
+      logger: new Logger2(`JobRun:${run.id}`)
     };
     const attemptsBefore = run.attempts ?? 0;
     try {
@@ -1834,9 +1449,9 @@ var MemoryJobOrchestrator = class {
   }
 };
 MemoryJobOrchestrator = __decorateClass([
-  Injectable5(),
-  __decorateParam(2, Inject5(JOBS_MULTI_TENANT)),
-  __decorateParam(3, Optional2())
+  Injectable4(),
+  __decorateParam(2, Inject4(JOBS_MULTI_TENANT)),
+  __decorateParam(3, Optional())
 ], MemoryJobOrchestrator);
 function classifyError(err, policy, currentAttempts) {
   if (!policy) return "fail";
@@ -1870,7 +1485,7 @@ function serialiseError(err, attempt, retryable) {
 }
 
 // runtime/subsystems/jobs/job-run-service.memory-backend.ts
-import { Inject as Inject6, Injectable as Injectable6 } from "@nestjs/common";
+import { Inject as Inject5, Injectable as Injectable5 } from "@nestjs/common";
 var NON_TERMINAL_STATUSES2 = [
   "pending",
   "running",
@@ -2037,9 +1652,9 @@ var MemoryJobRunService = class {
   }
 };
 MemoryJobRunService = __decorateClass([
-  Injectable6(),
-  __decorateParam(1, Inject6(JOB_ORCHESTRATOR)),
-  __decorateParam(2, Inject6(JOBS_MULTI_TENANT))
+  Injectable5(),
+  __decorateParam(1, Inject5(JOB_ORCHESTRATOR)),
+  __decorateParam(2, Inject5(JOBS_MULTI_TENANT))
 ], MemoryJobRunService);
 function compareBy(a, b, order) {
   switch (order) {
@@ -2057,7 +1672,7 @@ function compareBy(a, b, order) {
 
 // runtime/subsystems/jobs/job-step-service.memory-backend.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { Injectable as Injectable7 } from "@nestjs/common";
+import { Injectable as Injectable6 } from "@nestjs/common";
 var MemoryJobStepService = class {
   constructor(store) {
     this.store = store;
@@ -2150,7 +1765,7 @@ var MemoryJobStepService = class {
   }
 };
 MemoryJobStepService = __decorateClass([
-  Injectable7()
+  Injectable6()
 ], MemoryJobStepService);
 
 // runtime/subsystems/jobs/memory-job-store.ts
@@ -2169,32 +1784,192 @@ var MemoryJobStore = class {
   }
 };
 
-// runtime/subsystems/jobs/jobs-domain.module.ts
-var JobsDomainModule = class {
-  static forRoot(opts) {
-    const multiTenant = opts.multiTenant ?? false;
-    const providers = [
-      // JOB-8 — boolean provider consumed by the four service-layer backends.
-      // Always provided (even when `multiTenant === false`) so `@Inject`
-      // always resolves; backends short-circuit the enforcement path when
-      // the value is `false`. See `jobs-domain.tokens.ts` for the claim-loop
-      // cross-tenant-by-design decision.
-      { provide: JOBS_MULTI_TENANT, useValue: multiTenant }
-    ];
-    if (opts.backend === "memory") {
-      const store = new MemoryJobStore();
-      providers.push({ provide: MemoryJobStore, useValue: store });
-      providers.push(MemoryJobStepService);
-      providers.push({ provide: JOB_STEP_SERVICE, useExisting: MemoryJobStepService });
-      providers.push(MemoryJobOrchestrator);
-      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 });
+// 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 allNonReservedPoolNames(config) {
+  const out = [];
+  for (const [name, def] of config) {
+    if (!def.reserved) out.push(name);
+  }
+  return out;
+}
+function allPoolNames(config) {
+  return [...config.keys()];
+}
+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/jobs-domain.module.ts
+var JobsDomainModule = class {
+  static forRoot(opts) {
+    const multiTenant = opts.multiTenant ?? false;
+    const providers = [
+      // JOB-8 — boolean provider consumed by the four service-layer backends.
+      // Always provided (even when `multiTenant === false`) so `@Inject`
+      // always resolves; backends short-circuit the enforcement path when
+      // the value is `false`. See `jobs-domain.tokens.ts` for the claim-loop
+      // cross-tenant-by-design decision.
+      { provide: JOBS_MULTI_TENANT, useValue: multiTenant }
+    ];
+    if (opts.backend === "memory") {
+      const store = new MemoryJobStore();
+      providers.push({ provide: MemoryJobStore, useValue: store });
+      providers.push(MemoryJobStepService);
+      providers.push({ provide: JOB_STEP_SERVICE, useExisting: MemoryJobStepService });
+      providers.push(MemoryJobOrchestrator);
+      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,
+        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 {
@@ -2224,8 +1999,8 @@ JobsDomainModule = __decorateClass([
 ], JobsDomainModule);
 
 // runtime/subsystems/jobs/job-worker.ts
-import { Inject as Inject7, Injectable as Injectable8, Logger as Logger4 } from "@nestjs/common";
-import { and as and4, asc as asc2, desc as desc3, eq as eq5, inArray as inArray3, lt as lt2, lte, sql as sql4 } from "drizzle-orm";
+import { Inject as Inject6, Injectable as Injectable7, Logger as Logger3 } from "@nestjs/common";
+import { and as and4, asc as asc2, desc as desc3, eq as eq4, inArray as inArray3, lt as lt2, lte, sql as sql4 } 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;
@@ -2288,7 +2063,7 @@ var JobWorker = class {
   stepService;
   options;
   moduleRef;
-  logger = new Logger4(JobWorker.name);
+  logger = new Logger3(JobWorker.name);
   shuttingDown = false;
   inFlight = /* @__PURE__ */ new Set();
   pollTimer = null;
@@ -2329,7 +2104,7 @@ var JobWorker = class {
     await this.drainInFlight();
     try {
       await this.db.update(jobRuns).set({ status: "pending", claimedAt: null, startedAt: null }).where(
-        and4(eq5(jobRuns.status, "running"), eq5(jobRuns.pool, this.options.pool))
+        and4(eq4(jobRuns.status, "running"), eq4(jobRuns.pool, this.options.pool))
       );
     } catch (err) {
       this.logger.error(`shutdown reset failed: ${err.message}`);
@@ -2379,8 +2154,8 @@ var JobWorker = class {
     return this.db.transaction(async (tx) => {
       const candidates = await tx.select({ id: jobRuns.id }).from(jobRuns).where(
         and4(
-          eq5(jobRuns.status, "pending"),
-          eq5(jobRuns.pool, pool),
+          eq4(jobRuns.status, "pending"),
+          eq4(jobRuns.pool, pool),
           lte(jobRuns.runAt, /* @__PURE__ */ new Date())
         )
       ).orderBy(desc3(jobRuns.priority), asc2(jobRuns.runAt)).limit(1).for("update", { skipLocked: true });
@@ -2391,7 +2166,7 @@ var JobWorker = class {
         claimedAt: /* @__PURE__ */ new Date(),
         startedAt: /* @__PURE__ */ new Date(),
         updatedAt: /* @__PURE__ */ new Date()
-      }).where(eq5(jobRuns.id, candidate.id)).returning();
+      }).where(eq4(jobRuns.id, candidate.id)).returning();
       return claimed ?? null;
     });
   }
@@ -2409,7 +2184,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(
-          and4(eq5(jobRuns.status, "running"), lt2(jobRuns.claimedAt, threshold))
+          and4(eq4(jobRuns.status, "running"), lt2(jobRuns.claimedAt, threshold))
         ).for("update", { skipLocked: true });
         if (stale.length === 0) return;
         const ids = stale.map((r) => r.id);
@@ -2442,8 +2217,8 @@ var JobWorker = class {
     if (claimed.concurrencyKey) {
       const inflight = await this.db.select({ id: jobRuns.id }).from(jobRuns).where(
         and4(
-          eq5(jobRuns.concurrencyKey, claimed.concurrencyKey),
-          eq5(jobRuns.status, "running")
+          eq4(jobRuns.concurrencyKey, claimed.concurrencyKey),
+          eq4(jobRuns.status, "running")
         )
       );
       const other = inflight.find((r) => r.id !== claimed.id);
@@ -2453,7 +2228,7 @@ var JobWorker = class {
           claimedAt: null,
           startedAt: null,
           updatedAt: /* @__PURE__ */ new Date()
-        }).where(eq5(jobRuns.id, claimed.id));
+        }).where(eq4(jobRuns.id, claimed.id));
         return;
       }
     }
@@ -2468,7 +2243,7 @@ var JobWorker = class {
       run: claimed,
       step: this.makeStepFn(claimed),
       spawnChild: this.makeSpawnFn(claimed),
-      logger: new Logger4(`JobRun:${claimed.id}`)
+      logger: new Logger3(`JobRun:${claimed.id}`)
     };
     const attemptsBefore = claimed.attempts ?? 0;
     try {
@@ -2479,7 +2254,7 @@ var JobWorker = class {
         finishedAt: /* @__PURE__ */ new Date(),
         updatedAt: /* @__PURE__ */ new Date(),
         attempts: attemptsBefore + 1
-      }).where(eq5(jobRuns.id, claimed.id));
+      }).where(eq4(jobRuns.id, claimed.id));
     } catch (err) {
       const policy = meta.retry;
       const decision = classifyError2(err, policy, attemptsBefore);
@@ -2494,7 +2269,7 @@ var JobWorker = class {
           claimedAt: null,
           error: serialiseError2(err, nextAttempts, true),
           updatedAt: /* @__PURE__ */ new Date()
-        }).where(eq5(jobRuns.id, claimed.id));
+        }).where(eq4(jobRuns.id, claimed.id));
       } else {
         await this.markFailed(claimed, err, nextAttempts);
       }
@@ -2507,7 +2282,7 @@ var JobWorker = class {
       finishedAt: /* @__PURE__ */ new Date(),
       error: serialiseError2(err, finalAttempts, false),
       updatedAt: /* @__PURE__ */ new Date()
-    }).where(eq5(jobRuns.id, claimed.id));
+    }).where(eq4(jobRuns.id, claimed.id));
     if (claimed.parentClosePolicy === "terminate") {
       try {
         await this.orchestrator.cancel(claimed.id, {
@@ -2610,215 +2385,14 @@ var JobWorker = class {
   // ============================================================================
 };
 JobWorker = __decorateClass([
-  Injectable8(),
-  __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))
+  Injectable7(),
+  __decorateParam(0, Inject6(DRIZZLE)),
+  __decorateParam(1, Inject6(JOB_ORCHESTRATOR)),
+  __decorateParam(2, Inject6(JOB_RUN_SERVICE)),
+  __decorateParam(3, Inject6(JOB_STEP_SERVICE)),
+  __decorateParam(4, Inject6(JOB_WORKER_OPTIONS))
 ], JobWorker);
 
-// runtime/subsystems/jobs/job-worker.bullmq-backend.ts
-import { Logger as Logger5 } from "@nestjs/common";
-import { eq as eq6 } from "drizzle-orm";
-function serialiseError3(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 Logger5(_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 Logger5(`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: serialiseError3(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: serialiseError3(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.module.ts
 var DEFAULT_SHUTDOWN_TIMEOUT_MS2 = 3e4;
 var JOB_WORKER_MODULE_OPTIONS = /* @__PURE__ */ Symbol("JOB_WORKER_MODULE_OPTIONS");
@@ -2841,7 +2415,7 @@ var JobWorkerOrchestrator = class {
   moduleRef;
   bullConnection;
   bullConfig;
-  logger = new Logger6(JobWorkerOrchestrator.name);
+  logger = new Logger4(JobWorkerOrchestrator.name);
   workers = [];
   // ============================================================================
   // Lifecycle
@@ -2871,7 +2445,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(
@@ -2971,7 +2545,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.`
@@ -2988,7 +2570,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,
@@ -3003,17 +2587,17 @@ var JobWorkerOrchestrator = class {
   }
 };
 JobWorkerOrchestrator = __decorateClass([
-  Injectable9(),
-  __decorateParam(0, Inject8(JOB_ORCHESTRATOR)),
-  __decorateParam(1, Inject8(JOB_RUN_SERVICE)),
-  __decorateParam(2, Inject8(JOB_STEP_SERVICE)),
-  __decorateParam(3, Inject8(JOB_WORKER_MODULE_OPTIONS)),
-  __decorateParam(4, Optional3()),
-  __decorateParam(4, Inject8(DRIZZLE)),
-  __decorateParam(6, Optional3()),
-  __decorateParam(6, Inject8(BULLMQ_CONNECTION)),
-  __decorateParam(7, Optional3()),
-  __decorateParam(7, Inject8(BULLMQ_RESOLVED_CONFIG))
+  Injectable8(),
+  __decorateParam(0, Inject7(JOB_ORCHESTRATOR)),
+  __decorateParam(1, Inject7(JOB_RUN_SERVICE)),
+  __decorateParam(2, Inject7(JOB_STEP_SERVICE)),
+  __decorateParam(3, Inject7(JOB_WORKER_MODULE_OPTIONS)),
+  __decorateParam(4, Optional2()),
+  __decorateParam(4, Inject7(DRIZZLE)),
+  __decorateParam(6, Optional2()),
+  __decorateParam(6, Inject7(BULLMQ_CONNECTION)),
+  __decorateParam(7, Optional2()),
+  __decorateParam(7, Inject7(BULLMQ_RESOLVED_CONFIG))
 ], JobWorkerOrchestrator);
 var JobWorkerModule = class {
   static forRoot(opts) {