@pattern-stack/codegen 0.15.0 → 0.15.2

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

@@ -1,2651 +1,27 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
-var __decorateParam = (index2, decorator) => (target, key) => decorator(target, key, index2);
-
-// runtime/subsystems/jobs/job-worker.module.ts
-import {
-  Inject as Inject8,
-  Injectable as Injectable8,
-  Logger as Logger4,
-  Module as Module2,
-  Optional as Optional2
-} from "@nestjs/common";
-import { ModuleRef as ModuleRef2 } from "@nestjs/core";
-
-// runtime/subsystems/token-key.ts
-var PKG = "@pattern-stack/codegen";
-var tokenKey = (area, name) => `${PKG}.${area}.${name}`;
-
-// runtime/constants/tokens.ts
-var DRIZZLE = "DRIZZLE";
-
-// runtime/subsystems/jobs/job-handler.base.ts
-var JOB_HANDLER_REGISTRY = /* @__PURE__ */ new Map();
-var JOB_HANDLER_METADATA_KEY = Symbol.for(tokenKey("jobs", "handler-metadata"));
-var HandlerRegistry;
-((HandlerRegistry2) => {
-  function getAll() {
-    return Array.from(JOB_HANDLER_REGISTRY.values());
-  }
-  HandlerRegistry2.getAll = getAll;
-  function get(type) {
-    return JOB_HANDLER_REGISTRY.get(type);
-  }
-  HandlerRegistry2.get = get;
-})(HandlerRegistry || (HandlerRegistry = {}));
-
-// runtime/subsystems/jobs/jobs-domain.module.ts
-import { Module } from "@nestjs/common";
-
-// runtime/subsystems/jobs/jobs-domain.tokens.ts
-var JOB_ORCHESTRATOR = Symbol.for(tokenKey("jobs", "orchestrator"));
-var JOB_RUN_SERVICE = Symbol.for(tokenKey("jobs", "run-service"));
-var JOB_STEP_SERVICE = Symbol.for(tokenKey("jobs", "step-service"));
-var JOBS_MULTI_TENANT = Symbol.for(tokenKey("jobs", "multi-tenant"));
-
-// runtime/subsystems/jobs/job-orchestrator.drizzle-backend.ts
-import { randomUUID } from "crypto";
-import { Inject, Injectable, Logger } from "@nestjs/common";
-import { and, desc, eq, gt, inArray, isNotNull, ne, notInArray, sql as sql2 } from "drizzle-orm";
-
-// runtime/subsystems/jobs/job-orchestration.schema.ts
 import {
-  pgEnum,
-  pgTable,
-  uuid,
-  text,
-  jsonb,
-  integer,
-  timestamp,
-  index,
-  uniqueIndex
-} from "drizzle-orm/pg-core";
-import { sql } from "drizzle-orm";
-var jobRunStatusEnum = pgEnum("job_run_status", [
-  "pending",
-  "running",
-  "waiting",
-  "completed",
-  "failed",
-  "timed_out",
-  "canceled"
-]);
-var jobStepKindEnum = pgEnum("job_step_kind", ["task"]);
-var jobStepStatusEnum = pgEnum("job_step_status", [
-  "pending",
-  "running",
-  "completed",
-  "failed",
-  "skipped"
-]);
-var collisionModeEnum = pgEnum("job_collision_mode", [
-  "queue",
-  "reject",
-  "replace"
-]);
-var replayFromEnum = pgEnum("job_replay_from", [
-  "scratch",
-  "last_step",
-  "last_checkpoint"
-]);
-var parentClosePolicyEnum = pgEnum("job_parent_close_policy", [
-  "terminate",
-  "cancel",
-  "abandon"
-]);
-var waitKindEnum = pgEnum("job_wait_kind", ["signal"]);
-var triggerSourceEnum = pgEnum("job_trigger_source", [
-  "manual",
-  "schedule",
-  "event",
-  "parent"
-]);
-var jobs = pgTable("job", {
-  type: text("type").primaryKey(),
-  version: integer("version").notNull().default(1),
-  pool: text("pool").notNull(),
-  scopeEntityType: text("scope_entity_type"),
-  retryPolicy: jsonb("retry_policy").notNull().$type(),
-  timeoutMs: integer("timeout_ms"),
-  concurrencyKeyTemplate: text("concurrency_key_template"),
-  collisionMode: collisionModeEnum("collision_mode").notNull().default("queue"),
-  dedupeKeyTemplate: text("dedupe_key_template"),
-  dedupeWindowMs: integer("dedupe_window_ms"),
-  priorityDefault: integer("priority_default").notNull().default(0),
-  replayFrom: replayFromEnum("replay_from").notNull().default("last_checkpoint"),
-  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-});
-var jobRuns = pgTable(
-  "job_run",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    jobType: text("job_type").notNull().references(() => jobs.type),
-    jobVersion: integer("job_version").notNull(),
-    parentRunId: uuid("parent_run_id").references(() => jobRuns.id),
-    /**
-     * Service generates `id` client-side via randomUUID() and sets
-     * root_run_id = id for root runs (single INSERT, no self-FK race).
-     */
-    rootRunId: uuid("root_run_id").notNull(),
-    parentClosePolicy: parentClosePolicyEnum("parent_close_policy").notNull().default("terminate"),
-    scopeEntityType: text("scope_entity_type"),
-    scopeEntityId: text("scope_entity_id"),
-    tenantId: text("tenant_id"),
-    tags: jsonb("tags").notNull().default({}).$type(),
-    pool: text("pool").notNull(),
-    priority: integer("priority").notNull().default(0),
-    concurrencyKey: text("concurrency_key"),
-    dedupeKey: text("dedupe_key"),
-    status: jobRunStatusEnum("status").notNull().default("pending"),
-    input: jsonb("input").notNull().$type(),
-    output: jsonb("output").$type(),
-    error: jsonb("error").$type(),
-    triggerSource: triggerSourceEnum("trigger_source").notNull(),
-    triggerRef: text("trigger_ref"),
-    runAt: timestamp("run_at", { withTimezone: true }).notNull().defaultNow(),
-    startedAt: timestamp("started_at", { withTimezone: true }),
-    finishedAt: timestamp("finished_at", { withTimezone: true }),
-    claimedAt: timestamp("claimed_at", { withTimezone: true }),
-    attempts: integer("attempts").notNull().default(0),
-    // Phase 3 placeholder — see ADR-025
-    waitKind: waitKindEnum("wait_kind"),
-    // Phase 3 placeholder — see ADR-025
-    resumeToken: text("resume_token"),
-    // Phase 3 placeholder — see ADR-025
-    waitDeadline: timestamp("wait_deadline", { withTimezone: true }),
-    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
-    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow()
-  },
-  (t) => ({
-    /** Claim query: ORDER BY priority DESC, run_at ASC. */
-    idxJobRunClaim: index("idx_job_run_claim").on(t.status, t.pool, t.runAt),
-    /** Tree traversal / cascade cancel. */
-    idxJobRunRoot: index("idx_job_run_root").on(t.rootRunId),
-    /** listForScope query. */
-    idxJobRunScope: index("idx_job_run_scope").on(t.scopeEntityType, t.scopeEntityId),
-    /** Idempotency collapse — partial index. */
-    idxJobRunDedupe: index("idx_job_run_dedupe").on(t.jobType, t.dedupeKey).where(sql`${t.dedupeKey} IS NOT NULL`),
-    /** Collision check — partial index. */
-    idxJobRunConcurrency: index("idx_job_run_concurrency").on(t.concurrencyKey).where(
-      sql`${t.concurrencyKey} IS NOT NULL AND ${t.status} IN ('pending','running')`
-    )
-  })
-);
-var jobSteps = pgTable(
-  "job_step",
-  {
-    id: uuid("id").primaryKey().defaultRandom(),
-    jobRunId: uuid("job_run_id").notNull().references(() => jobRuns.id),
-    stepId: text("step_id").notNull(),
-    kind: jobStepKindEnum("kind").notNull().default("task"),
-    /**
-     * Monotonic within run. integer (max ~2B per run) is sufficient —
-     * downgraded from ADR-022's bigint; revisit only if a single run
-     * ever exceeds 2 billion steps.
-     */
-    seq: integer("seq").notNull(),
-    status: jobStepStatusEnum("status").notNull().default("pending"),
-    input: jsonb("input").$type(),
-    /** Memoised on success for replay. */
-    output: jsonb("output").$type(),
-    error: jsonb("error").$type(),
-    attempts: integer("attempts").notNull().default(0),
-    startedAt: timestamp("started_at", { withTimezone: true }),
-    finishedAt: timestamp("finished_at", { withTimezone: true })
-  },
-  (t) => ({
-    /** No duplicate step IDs per run. */
-    idxJobStepRunStep: uniqueIndex("idx_job_step_run_step").on(t.jobRunId, t.stepId),
-    /** Ordered timeline reads. */
-    idxJobStepTimeline: index("idx_job_step_timeline").on(t.jobRunId, t.seq)
-  })
-);
-
-// runtime/subsystems/jobs/jobs-errors.ts
-var JobTypeNotFoundError = class extends Error {
-  constructor(jobType) {
-    super(`No job definition registered for type '${jobType}'.`);
-    this.jobType = jobType;
-  }
-  jobType;
-  name = "JobTypeNotFoundError";
-};
-var JobCollisionError = class extends Error {
-  constructor(jobType, concurrencyKey, incumbent) {
-    super(
-      `Job type '${jobType}' has an in-flight run with concurrency_key '${concurrencyKey}' (incumbent ${incumbent.id}); collision_mode=reject.`
-    );
-    this.jobType = jobType;
-    this.concurrencyKey = concurrencyKey;
-    this.incumbent = incumbent;
-  }
-  jobType;
-  concurrencyKey;
-  incumbent;
-  name = "JobCollisionError";
-};
-var JobNotReplayableError = class extends Error {
-  constructor(runId, currentStatus) {
-    super(
-      `Run ${runId} is not replayable from status '${currentStatus}'. Only 'completed', 'failed', 'timed_out', and 'canceled' are eligible.`
-    );
-    this.runId = runId;
-    this.currentStatus = currentStatus;
-  }
-  runId;
-  currentStatus;
-  name = "JobNotReplayableError";
-};
-var JobTemplateFieldMissingError = class extends Error {
-  constructor(template, field) {
-    super(
-      `Template '${template}' references input field '${field}' which is missing or undefined on the payload.`
-    );
-    this.template = template;
-    this.field = field;
-  }
-  template;
-  field;
-  name = "JobTemplateFieldMissingError";
-};
-var MissingTenantIdError = class extends Error {
-  constructor(method) {
-    super(
-      `MissingTenantIdError: JobsDomainModule was configured with multiTenant=true but ${method} was called without tenantId (undefined). Pass an explicit tenantId, or pass null for cross-tenant work.`
-    );
-    this.method = method;
-  }
-  method;
-  name = "MissingTenantIdError";
-};
-var BootValidationError = class extends Error {
-  constructor(missingHandlers) {
-    super(
-      `BootValidationError: ${missingHandlers.length} orphaned job type(s) in 'job' table with no matching @JobHandler in the running process: [${missingHandlers.join(", ")}]. Either register the handler(s) or remove the rows.`
-    );
-    this.missingHandlers = missingHandlers;
-  }
-  missingHandlers;
-  name = "BootValidationError";
-};
-var ReservedPoolViolationError = class extends Error {
-  constructor(offenders) {
-    super(
-      `ReservedPoolViolationError: ${offenders.length} @JobHandler(s) target reserved pools \u2014 reserved pools are framework-only:
-` + offenders.map((o) => `  - ${o.handlerClass} \u2192 pool='${o.pool}'`).join("\n")
-    );
-    this.offenders = offenders;
-  }
-  offenders;
-  name = "ReservedPoolViolationError";
-};
-
-// runtime/subsystems/jobs/job-orchestrator.drizzle-backend.ts
-var TERMINAL_STATUSES = [
-  "completed",
-  "failed",
-  "timed_out",
-  "canceled"
-];
-var DEDUPE_EXCLUDED_STATUSES = ["canceled", "failed"];
-var IN_FLIGHT_STATUSES = ["pending", "running"];
-function evaluateKeyTemplate(template, input) {
-  return template.replace(/\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g, (_match, field) => {
-    const value = input[field];
-    if (value === void 0 || value === null) {
-      throw new JobTemplateFieldMissingError(template, field);
-    }
-    return String(value);
-  });
-}
-var DrizzleJobOrchestrator = class {
-  constructor(db, multiTenant) {
-    this.db = db;
-    this.multiTenant = multiTenant;
-  }
-  db;
-  multiTenant;
-  // TODO(logging-subsystem): swap to ILogger once ADR-028 lands
-  logger = new Logger(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
-   * against in a WHERE clause). When `multiTenant` is off, the column is
-   * forced to `null` regardless of what callers pass. When on, `undefined`
-   * throws; `null` and strings pass through untouched.
-   */
-  resolveTenantId(method, tenantId) {
-    if (!this.multiTenant) return null;
-    if (tenantId === void 0) throw new MissingTenantIdError(method);
-    return tenantId;
-  }
-  // ==========================================================================
-  // start
-  // ==========================================================================
-  async start(type, input, opts = {}, tx) {
-    const payload = input ?? {};
-    const tenantId = this.resolveTenantId("start", opts.tenantId);
-    const client = tx ?? this.db;
-    const [def] = await client.select().from(jobs).where(eq(jobs.type, type)).limit(1);
-    if (!def) throw new JobTypeNotFoundError(type);
-    const definition = def;
-    if (definition.dedupeKeyTemplate && definition.dedupeWindowMs) {
-      const dedupeKey2 = evaluateKeyTemplate(definition.dedupeKeyTemplate, payload);
-      const windowStart = new Date(Date.now() - definition.dedupeWindowMs);
-      const existing = await client.select().from(jobRuns).where(
-        and(
-          eq(jobRuns.jobType, type),
-          eq(jobRuns.dedupeKey, dedupeKey2),
-          gt(jobRuns.createdAt, windowStart),
-          // status NOT IN ('canceled', 'failed')
-          notInStatus(DEDUPE_EXCLUDED_STATUSES)
-        )
-      ).orderBy(desc(jobRuns.createdAt)).limit(1);
-      if (existing.length > 0) {
-        return existing[0];
-      }
-    }
-    let concurrencyKey = null;
-    if (definition.concurrencyKeyTemplate) {
-      concurrencyKey = evaluateKeyTemplate(
-        definition.concurrencyKeyTemplate,
-        payload
-      );
-      const inFlight = await client.select().from(jobRuns).where(
-        and(
-          eq(jobRuns.concurrencyKey, concurrencyKey),
-          inArray(jobRuns.status, IN_FLIGHT_STATUSES)
-        )
-      ).limit(1);
-      if (inFlight.length > 0) {
-        const incumbent = inFlight[0];
-        switch (definition.collisionMode) {
-          case "reject":
-            throw new JobCollisionError(type, concurrencyKey, incumbent);
-          case "replace":
-            await this.cancel(incumbent.id, {
-              cascade: true,
-              reason: "replaced",
-              tenantId: incumbent.tenantId
-            });
-            break;
-          case "queue":
-            break;
-        }
-      }
-    }
-    const newId = randomUUID();
-    let rootRunId = newId;
-    if (opts.parentRunId) {
-      const [parent] = await client.select({ rootRunId: jobRuns.rootRunId }).from(jobRuns).where(eq(jobRuns.id, opts.parentRunId)).limit(1);
-      if (!parent) {
-        throw new Error(
-          `parentRunId ${opts.parentRunId} does not reference an existing job_run`
-        );
-      }
-      rootRunId = parent.rootRunId;
-    }
-    const dedupeKey = definition.dedupeKeyTemplate ? evaluateKeyTemplate(definition.dedupeKeyTemplate, payload) : null;
-    const [inserted] = await client.insert(jobRuns).values({
-      id: newId,
-      jobType: type,
-      jobVersion: definition.version,
-      parentRunId: opts.parentRunId ?? null,
-      rootRunId,
-      parentClosePolicy: opts.parentClosePolicy ?? "terminate",
-      scopeEntityType: opts.scope?.entityType ?? null,
-      scopeEntityId: opts.scope?.entityId ?? null,
-      tenantId,
-      tags: opts.tags ?? {},
-      pool: opts.pool ?? definition.pool,
-      priority: opts.priority ?? definition.priorityDefault,
-      concurrencyKey,
-      dedupeKey,
-      status: "pending",
-      input: payload,
-      output: null,
-      error: null,
-      triggerSource: opts.triggerSource ?? "manual",
-      triggerRef: opts.triggerRef ?? null,
-      runAt: opts.runAt ?? /* @__PURE__ */ new Date(),
-      startedAt: null,
-      finishedAt: null,
-      claimedAt: null,
-      attempts: 0
-    }).returning();
-    return inserted;
-  }
-  // ==========================================================================
-  // cancel
-  // ==========================================================================
-  async cancel(runId, opts = {}) {
-    const tenantId = this.resolveTenantId("cancel", opts.tenantId);
-    const [target] = await this.db.select().from(jobRuns).where(eq(jobRuns.id, runId)).limit(1);
-    if (!target) return;
-    if (this.multiTenant && target.tenantId !== tenantId) return;
-    if (TERMINAL_STATUSES.includes(target.status)) {
-      return;
-    }
-    const [cancelled] = await this.db.update(jobRuns).set({
-      status: "canceled",
-      finishedAt: /* @__PURE__ */ new Date(),
-      updatedAt: /* @__PURE__ */ new Date()
-    }).where(
-      and(eq(jobRuns.id, runId), notInStatus([...TERMINAL_STATUSES]))
-    ).returning();
-    if (!cancelled) return;
-    if (opts.cascade === false) return;
-    const descendants = await this.db.select().from(jobRuns).where(
-      and(
-        eq(jobRuns.rootRunId, target.rootRunId),
-        ne(jobRuns.id, runId),
-        notInStatus([...TERMINAL_STATUSES])
-      )
-    );
-    for (const child of descendants) {
-      const policy = child.parentClosePolicy;
-      if (policy === "abandon") continue;
-      await this.db.update(jobRuns).set({
-        status: "canceled",
-        finishedAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      }).where(
-        and(
-          eq(jobRuns.id, child.id),
-          notInStatus([...TERMINAL_STATUSES])
-        )
-      );
-    }
-    void opts.reason;
-  }
-  // ==========================================================================
-  // replay
-  // ==========================================================================
-  async replay(runId) {
-    const [target] = await this.db.select().from(jobRuns).where(eq(jobRuns.id, runId)).limit(1);
-    if (!target) {
-      throw new Error(`replay: run ${runId} not found`);
-    }
-    const run = target;
-    if (!TERMINAL_STATUSES.includes(run.status)) {
-      throw new JobNotReplayableError(runId, run.status);
-    }
-    const [def] = await this.db.select().from(jobs).where(eq(jobs.type, run.jobType)).limit(1);
-    if (!def) throw new JobTypeNotFoundError(run.jobType);
-    const mode = def.replayFrom;
-    const result = await this.db.transaction(async (tx) => {
-      if (mode === "scratch") {
-        await tx.delete(jobSteps).where(eq(jobSteps.jobRunId, runId));
-      } else if (mode === "last_step") {
-        await tx.delete(jobSteps).where(
-          and(eq(jobSteps.jobRunId, runId), ne(jobSteps.status, "completed"))
-        );
-      } else {
-        await tx.delete(jobSteps).where(
-          and(eq(jobSteps.jobRunId, runId), ne(jobSteps.status, "completed"))
-        );
-      }
-      const [updated] = await tx.update(jobRuns).set({
-        status: "pending",
-        attempts: 0,
-        runAt: /* @__PURE__ */ new Date(),
-        startedAt: null,
-        finishedAt: null,
-        claimedAt: null,
-        error: null,
-        output: null,
-        updatedAt: /* @__PURE__ */ new Date()
-      }).where(eq(jobRuns.id, runId)).returning();
-      return updated;
-    });
-    return result;
-  }
-  // ==========================================================================
-  // upsertJobRows — boot-time materialisation of `job` definitions
-  // ==========================================================================
-  /**
-   * Hash-gated `INSERT … ON CONFLICT (type) DO UPDATE … WHERE` per Q3
-   * resolution (2026-04-19): the `UPDATE` branch executes only when one
-   * of the persisted metadata fields differs from the incoming payload;
-   * `version` bumps only on real change; concurrent boots with identical
-   * content are idempotent no-ops.
-   *
-   * Why this shape (not `DO NOTHING`, not advisory locks):
-   *   - `DO NOTHING` would let an old-version instance leave a stale row
-   *     that a new-version instance can't overwrite during a rolling deploy.
-   *   - Advisory locks add latency and leak risk under crashes.
-   *   - The `WHERE … IS DISTINCT FROM …` clause makes the conditional
-   *     atomic — no read-modify-write race on `version` between concurrent
-   *     boots.
-   *
-   * Orphan detection: a single `SELECT type FROM job WHERE type NOT IN (...)`
-   * returns the types present in DB but absent from `entries`. Caller (boot
-   * validator) decides whether to throw `BootValidationError`.
-   */
-  async upsertJobRows(entries, poolConfig) {
-    void poolConfig;
-    for (const entry of entries) {
-      const meta = entry.meta;
-      const pool = meta.pool ?? "batch";
-      const retryPolicy = meta.retry ?? {
-        attempts: 1,
-        backoff: "fixed",
-        baseMs: 0
-      };
-      const concurrencyKeyTemplate = meta.concurrency?.key;
-      const concurrencyKeyTemplateStr = typeof concurrencyKeyTemplate === "string" ? concurrencyKeyTemplate : null;
-      const collisionMode = meta.concurrency?.collisionMode ?? "queue";
-      const dedupeKeyTemplate = meta.dedupe?.key;
-      const dedupeKeyTemplateStr = typeof dedupeKeyTemplate === "string" ? dedupeKeyTemplate : null;
-      const dedupeWindowMs = meta.dedupe?.windowMs ?? null;
-      const timeoutMs = meta.timeoutMs ?? null;
-      const replayFrom = meta.replayFrom ?? "last_checkpoint";
-      const scopeEntityType = meta.scope?.entity ?? null;
-      const priorityDefault = 0;
-      await this.db.insert(jobs).values({
-        type: entry.type,
-        version: 1,
-        pool,
-        scopeEntityType,
-        retryPolicy,
-        timeoutMs,
-        concurrencyKeyTemplate: concurrencyKeyTemplateStr,
-        collisionMode,
-        dedupeKeyTemplate: dedupeKeyTemplateStr,
-        dedupeWindowMs,
-        priorityDefault,
-        replayFrom
-      }).onConflictDoUpdate({
-        target: jobs.type,
-        set: {
-          pool: sql2`EXCLUDED.pool`,
-          scopeEntityType: sql2`EXCLUDED.scope_entity_type`,
-          retryPolicy: sql2`EXCLUDED.retry_policy`,
-          timeoutMs: sql2`EXCLUDED.timeout_ms`,
-          concurrencyKeyTemplate: sql2`EXCLUDED.concurrency_key_template`,
-          collisionMode: sql2`EXCLUDED.collision_mode`,
-          dedupeKeyTemplate: sql2`EXCLUDED.dedupe_key_template`,
-          dedupeWindowMs: sql2`EXCLUDED.dedupe_window_ms`,
-          priorityDefault: sql2`EXCLUDED.priority_default`,
-          replayFrom: sql2`EXCLUDED.replay_from`,
-          version: sql2`${jobs.version} + 1`,
-          updatedAt: sql2`now()`
-        },
-        // The hash gate: every field listed in the Q3 resolution appears
-        // here. `IS DISTINCT FROM` is the null-safe inequality operator;
-        // jsonb cast to text gives stable comparison without invoking a
-        // dedicated hash column (avoids a JOB-1 schema migration).
-        setWhere: sql2`
-            ${jobs.pool} IS DISTINCT FROM EXCLUDED.pool OR
-            ${jobs.retryPolicy}::text IS DISTINCT FROM EXCLUDED.retry_policy::text OR
-            ${jobs.timeoutMs} IS DISTINCT FROM EXCLUDED.timeout_ms OR
-            ${jobs.concurrencyKeyTemplate} IS DISTINCT FROM EXCLUDED.concurrency_key_template OR
-            ${jobs.collisionMode} IS DISTINCT FROM EXCLUDED.collision_mode OR
-            ${jobs.dedupeKeyTemplate} IS DISTINCT FROM EXCLUDED.dedupe_key_template OR
-            ${jobs.dedupeWindowMs} IS DISTINCT FROM EXCLUDED.dedupe_window_ms OR
-            ${jobs.priorityDefault} IS DISTINCT FROM EXCLUDED.priority_default OR
-            ${jobs.replayFrom} IS DISTINCT FROM EXCLUDED.replay_from OR
-            ${jobs.scopeEntityType} IS DISTINCT FROM EXCLUDED.scope_entity_type
-          `
-      });
-    }
-    const types = entries.map((e) => e.type);
-    const orphans = types.length === 0 ? await this.db.select({ type: jobs.type }).from(jobs) : await this.db.select({ type: jobs.type }).from(jobs).where(notInArray(jobs.type, types));
-    return { orphaned: orphans.map((o) => o.type) };
-  }
-};
-DrizzleJobOrchestrator = __decorateClass([
-  Injectable(),
-  __decorateParam(0, Inject(DRIZZLE)),
-  __decorateParam(1, Inject(JOBS_MULTI_TENANT))
-], DrizzleJobOrchestrator);
-function notInStatus(statuses) {
-  const negated = statuses.map((s) => ne(jobRuns.status, s));
-  return and(...negated);
-}
-
-// 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, 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,
-    parentRunId: r.parentRunId,
-    triggerSource: r.triggerSource,
-    triggerRef: r.triggerRef,
-    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",
-  "waiting"
-];
-var DrizzleJobRunService = class {
-  constructor(db, orchestrator, multiTenant) {
-    this.db = db;
-    this.orchestrator = orchestrator;
-    this.multiTenant = multiTenant;
-  }
-  db;
-  orchestrator;
-  multiTenant;
-  /**
-   * JOB-8 — produce the tenant WHERE fragment (or `null` to opt out).
-   * Returns `null` when multi-tenancy is off (caller skips the predicate).
-   * Throws `MissingTenantIdError` when on + `undefined`.
-   * When on + explicit `null`, filters `tenant_id IS NULL`.
-   */
-  tenantCondition(method, tenantId) {
-    if (!this.multiTenant) return null;
-    if (tenantId === void 0) throw new MissingTenantIdError(method);
-    return tenantId === null ? isNull(jobRuns.tenantId) : eq2(jobRuns.tenantId, tenantId);
-  }
-  async listForScope(entityType, entityId, opts = {}) {
-    const conditions = [
-      eq2(jobRuns.scopeEntityType, entityType),
-      eq2(jobRuns.scopeEntityId, entityId)
-    ];
-    const tenantCond = this.tenantCondition("listForScope", opts.tenantId);
-    if (tenantCond) conditions.push(tenantCond);
-    if (opts.status) {
-      if (Array.isArray(opts.status)) {
-        conditions.push(inArray2(jobRuns.status, opts.status));
-      } else {
-        conditions.push(eq2(jobRuns.status, opts.status));
-      }
-    }
-    if (opts.jobType) {
-      conditions.push(eq2(jobRuns.jobType, opts.jobType));
-    }
-    const orderCol = (() => {
-      switch (opts.orderBy) {
-        case "created_at asc":
-          return asc(jobRuns.createdAt);
-        case "run_at desc":
-          return desc2(jobRuns.runAt);
-        case "run_at asc":
-          return asc(jobRuns.runAt);
-        case "created_at desc":
-        default:
-          return desc2(jobRuns.createdAt);
-      }
-    })();
-    let q = this.db.select().from(jobRuns).where(and2(...conditions)).orderBy(orderCol).$dynamic();
-    if (typeof opts.limit === "number") {
-      q = q.limit(opts.limit);
-    }
-    if (typeof opts.offset === "number") {
-      q = q.offset(opts.offset);
-    }
-    const rows = await q;
-    return rows;
-  }
-  async cancelForScope(entityType, entityId, opts = {}) {
-    const tenantCond = this.tenantCondition("cancelForScope", opts.tenantId);
-    const conditions = [
-      eq2(jobRuns.scopeEntityType, entityType),
-      eq2(jobRuns.scopeEntityId, entityId),
-      inArray2(jobRuns.status, NON_TERMINAL_STATUSES)
-    ];
-    if (tenantCond) conditions.push(tenantCond);
-    const rows = await this.db.select({ id: jobRuns.id }).from(jobRuns).where(and2(...conditions));
-    for (const { id } of rows) {
-      await this.orchestrator.cancel(id, {
-        cascade: true,
-        tenantId: opts.tenantId
-      });
-    }
-  }
-  async rescheduleForScope(entityType, entityId, newRunAt, opts = {}) {
-    const tenantCond = this.tenantCondition("rescheduleForScope", opts.tenantId);
-    const conditions = [
-      eq2(jobRuns.scopeEntityType, entityType),
-      eq2(jobRuns.scopeEntityId, entityId),
-      eq2(jobRuns.status, "pending")
-    ];
-    if (tenantCond) conditions.push(tenantCond);
-    await this.db.update(jobRuns).set({ runAt: newRunAt, updatedAt: /* @__PURE__ */ new Date() }).where(and2(...conditions));
-  }
-  async countByPoolAndStatus(tenantId) {
-    const tenantCond = this.tenantCondition("countByPoolAndStatus", tenantId);
-    const rows = await this.db.select({
-      pool: jobRuns.pool,
-      status: jobRuns.status,
-      count: sql3`count(*)::int`.as("count")
-    }).from(jobRuns).where(tenantCond ?? void 0).groupBy(jobRuns.pool, jobRuns.status);
-    return rows.map((r) => ({
-      pool: r.pool,
-      status: r.status,
-      count: Number(r.count)
-    }));
-  }
-  async listRecentFailed(limit, tenantId) {
-    const conditions = [eq2(jobRuns.status, "failed")];
-    const tenantCond = this.tenantCondition("listRecentFailed", tenantId);
-    if (tenantCond) conditions.push(tenantCond);
-    const rows = await this.db.select().from(jobRuns).where(and2(...conditions)).orderBy(desc2(jobRuns.finishedAt), desc2(jobRuns.updatedAt)).limit(limit);
-    return rows.map((r) => ({
-      runId: r.id,
-      jobType: r.jobType,
-      pool: r.pool,
-      scopeEntityType: r.scopeEntityType,
-      scopeEntityId: r.scopeEntityId,
-      tenantId: r.tenantId,
-      attempts: r.attempts,
-      errorMessage: r.error?.message ?? null,
-      failedAt: r.finishedAt ?? r.updatedAt,
-      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
-   * code (cascade tests, debug tools) can call it without a cast.
-   */
-  async findByRootRunId(rootRunId) {
-    const rows = await this.db.select().from(jobRuns).where(eq2(jobRuns.rootRunId, rootRunId));
-    return rows;
-  }
-};
-DrizzleJobRunService = __decorateClass([
-  Injectable2(),
-  __decorateParam(0, Inject2(DRIZZLE)),
-  __decorateParam(1, Inject2(JOB_ORCHESTRATOR)),
-  __decorateParam(2, Inject2(JOBS_MULTI_TENANT))
-], DrizzleJobRunService);
-
-// runtime/subsystems/jobs/job-step-service.drizzle-backend.ts
-import { Inject as Inject3, Injectable as Injectable3 } from "@nestjs/common";
-import { and as and3, eq as eq3 } from "drizzle-orm";
-var DrizzleJobStepService = class {
-  constructor(db) {
-    this.db = db;
-  }
-  db;
-  async recordStep(input) {
-    const values = {
-      jobRunId: input.jobRunId,
-      stepId: input.stepId,
-      kind: input.kind,
-      seq: input.seq,
-      status: input.status,
-      input: input.input ?? null,
-      output: input.output ?? null,
-      error: input.error ?? null,
-      attempts: input.attempts ?? 0,
-      startedAt: input.startedAt ?? null,
-      finishedAt: input.finishedAt ?? null
-    };
-    const [row] = await this.db.insert(jobSteps).values(values).onConflictDoUpdate({
-      target: [jobSteps.jobRunId, jobSteps.stepId],
-      set: {
-        status: values.status,
-        output: values.output,
-        error: values.error,
-        finishedAt: values.finishedAt,
-        attempts: values.attempts
-      }
-    }).returning();
-    return row;
-  }
-  async findStep(runId, stepId) {
-    const [row] = await this.db.select().from(jobSteps).where(and3(eq3(jobSteps.jobRunId, runId), eq3(jobSteps.stepId, stepId))).limit(1);
-    return row ?? null;
-  }
-};
-DrizzleJobStepService = __decorateClass([
-  Injectable3(),
-  __decorateParam(0, Inject3(DRIZZLE))
-], DrizzleJobStepService);
-
-// runtime/subsystems/jobs/job-orchestrator.memory-backend.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { Inject as Inject5, Injectable as Injectable5, Logger as Logger2, Optional } from "@nestjs/common";
-import { ModuleRef } from "@nestjs/core";
-
-// runtime/subsystems/jobs/memory-job-store.ts
-var MemoryJobStore = class {
-  /** Runs keyed by `id` (single source of truth for status/scope/lineage). */
-  runs = /* @__PURE__ */ new Map();
-  /** Steps keyed by `job_run_id`; array order matches insertion order. */
-  steps = /* @__PURE__ */ new Map();
-  /** Job definitions keyed by `type` — memory mirror of the `job` table. */
-  jobs = /* @__PURE__ */ new Map();
-  /** Reset everything. Tests call this in `beforeEach`. */
-  clear() {
-    this.runs.clear();
-    this.steps.clear();
-    this.jobs.clear();
-  }
-};
-
-// runtime/subsystems/jobs/job-step-service.memory-backend.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { Inject as Inject4, Injectable as Injectable4 } from "@nestjs/common";
-var MemoryJobStepService = class {
-  // ADR-037 (package-mode DI): explicit `@Inject(MemoryJobStore)` — the
-  // published bundle carries no `design:paramtypes`, so a by-type inject
-  // would resolve to `undefined` in package mode.
-  constructor(store) {
-    this.store = store;
-  }
-  store;
-  async findStep(runId, stepId) {
-    const rows = this.store.steps.get(runId);
-    if (!rows) return null;
-    const match = rows.find(
-      (r) => r.stepId === stepId && r.status === "completed"
-    );
-    return match ?? null;
-  }
-  async recordStep(input) {
-    const rows = this.getOrCreateRows(input.jobRunId);
-    const existingIdx = rows.findIndex((r) => r.stepId === input.stepId);
-    const normalisedInput = input.input ?? null;
-    const normalisedOutput = input.output ?? null;
-    if (existingIdx >= 0) {
-      const prev = rows[existingIdx];
-      const next = {
-        ...prev,
-        status: input.status,
-        input: normalisedInput ?? prev.input,
-        output: normalisedOutput ?? prev.output,
-        error: input.error ?? prev.error,
-        attempts: input.attempts ?? prev.attempts,
-        startedAt: input.startedAt ?? prev.startedAt,
-        finishedAt: input.finishedAt ?? prev.finishedAt
-      };
-      rows[existingIdx] = next;
-      return next;
-    }
-    const seq = input.seq ?? this.nextSeq(rows);
-    const row = {
-      id: randomUUID2(),
-      jobRunId: input.jobRunId,
-      stepId: input.stepId,
-      kind: input.kind,
-      seq,
-      status: input.status,
-      input: normalisedInput,
-      output: normalisedOutput,
-      error: input.error ?? null,
-      attempts: input.attempts ?? 0,
-      startedAt: input.startedAt ?? null,
-      finishedAt: input.finishedAt ?? null
-    };
-    rows.push(row);
-    return row;
-  }
-  /**
-   * Replay helper — wipe every step row for a run. Mirrors the `scratch`
-   * replay mode of the Drizzle backend (`DELETE FROM job_step WHERE job_run_id = …`).
-   */
-  clearStepsForRun(runId) {
-    this.store.steps.delete(runId);
-  }
-  /**
-   * Remove every non-`completed` row for the run. Memoized (`completed`)
-   * rows are preserved — this is the `last_checkpoint` / `last_step`
-   * semantics the Drizzle backend implements via
-   * `DELETE … WHERE status != 'completed'`. Both replay modes route here
-   * (Phase 1 collapses `last_step` onto this behaviour; see JOB-3 notes).
-   */
-  clearIncompleteSteps(runId) {
-    const rows = this.store.steps.get(runId);
-    if (!rows) return;
-    const kept = rows.filter((r) => r.status === "completed");
-    if (kept.length === 0) {
-      this.store.steps.delete(runId);
-    } else {
-      this.store.steps.set(runId, kept);
-    }
-  }
-  getOrCreateRows(runId) {
-    let rows = this.store.steps.get(runId);
-    if (!rows) {
-      rows = [];
-      this.store.steps.set(runId, rows);
-    }
-    return rows;
-  }
-  nextSeq(rows) {
-    let max = 0;
-    for (const r of rows) {
-      if (r.seq > max) max = r.seq;
-    }
-    return max + 1;
-  }
-};
-MemoryJobStepService = __decorateClass([
-  Injectable4(),
-  __decorateParam(0, Inject4(MemoryJobStore))
-], MemoryJobStepService);
-
-// runtime/subsystems/jobs/job-orchestrator.memory-backend.ts
-var QUEUED_RUN_AT = /* @__PURE__ */ new Date(864e13);
-var TERMINAL_STATUSES2 = [
-  "completed",
-  "failed",
-  "timed_out",
-  "canceled"
-];
-var DEDUPE_EXCLUDED_STATUSES2 = ["canceled", "failed"];
-var IN_FLIGHT_STATUSES2 = ["pending", "running"];
-function isTerminal(status) {
-  return TERMINAL_STATUSES2.includes(status);
-}
-function evaluateKeyTemplate2(template, input) {
-  return template.replace(
-    /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g,
-    (_m, field) => {
-      const value = input[field];
-      if (value === void 0 || value === null) {
-        throw new JobTemplateFieldMissingError(template, field);
-      }
-      return String(value);
-    }
-  );
-}
-var PromiseMutex = class {
-  queue = Promise.resolve();
-  async run(fn) {
-    const next = this.queue.then(() => fn());
-    this.queue = next.then(
-      () => void 0,
-      () => void 0
-    );
-    return next;
-  }
-};
-var MemoryJobOrchestrator = class {
-  constructor(store, stepService, multiTenant, moduleRef) {
-    this.store = store;
-    this.stepService = stepService;
-    this.multiTenant = multiTenant;
-    this.moduleRef = moduleRef;
-  }
-  store;
-  stepService;
-  multiTenant;
-  moduleRef;
-  logger = new Logger2(MemoryJobOrchestrator.name);
-  mutex = new PromiseMutex();
-  handlerRegistry = /* @__PURE__ */ new Map();
-  /**
-   * `runId → dependent runId[]` — when a run with `concurrencyKey = K`
-   * blocks on an incumbent, its id is added here under the incumbent's id.
-   * On incumbent terminal transition we advance every dependent's `runAt`
-   * back to `now()` so it becomes claimable.
-   */
-  queueBlockers = /* @__PURE__ */ new Map();
-  /**
-   * JOB-8 — mirror of the Drizzle backend's `resolveTenantId`. Returns the
-   * value to stamp on `tenant_id` / compare against in memory predicates.
-   * Off → always `null`. On + `undefined` → throw. On + `null`/string → pass.
-   */
-  resolveTenantId(method, tenantId) {
-    if (!this.multiTenant) return null;
-    if (tenantId === void 0) throw new MissingTenantIdError(method);
-    return tenantId;
-  }
-  // ==========================================================================
-  // registerHandler — replaces Drizzle's `job` table upsert
-  // ==========================================================================
-  /**
-   * Populate the in-memory job definition row plus handler class lookup.
-   * Called by `JobWorkerModule.onModuleInit` in memory mode, or directly by
-   * unit tests that want to seed the registry without NestJS.
-   */
-  registerHandler(type, meta, handlerClass) {
-    const concurrencyKeyTemplate = meta.concurrency?.key ?? null;
-    const dedupeKeyTemplate = meta.dedupe?.key ?? null;
-    const dedupeWindowMs = meta.dedupe?.windowMs ?? null;
-    const now = /* @__PURE__ */ new Date();
-    const def = {
-      type,
-      version: 1,
-      pool: meta.pool ?? "batch",
-      scopeEntityType: meta.scope?.entity ?? null,
-      retryPolicy: meta.retry ?? {
-        attempts: 1,
-        backoff: "fixed",
-        baseMs: 0
-      },
-      timeoutMs: meta.timeoutMs ?? null,
-      concurrencyKeyTemplate: typeof concurrencyKeyTemplate === "string" ? concurrencyKeyTemplate : null,
-      collisionMode: meta.concurrency?.collisionMode ?? "queue",
-      dedupeKeyTemplate: typeof dedupeKeyTemplate === "string" ? dedupeKeyTemplate : null,
-      dedupeWindowMs,
-      priorityDefault: 0,
-      replayFrom: meta.replayFrom ?? "last_checkpoint",
-      createdAt: now,
-      updatedAt: now
-    };
-    this.store.jobs.set(type, def);
-    this.handlerRegistry.set(type, {
-      type,
-      meta,
-      handlerClass
-    });
-  }
-  /** Test helper — look up a registered handler without exposing the map. */
-  getHandlerRegistration(type) {
-    return this.handlerRegistry.get(type);
-  }
-  /**
-   * Boot-time upsert per `IJobOrchestrator.upsertJobRows`. Memory backend
-   * just funnels each entry through `registerHandler`. The validator is
-   * skipped entirely in memory mode (Q4 resolution 2026-04-19), so the
-   * orphaned list is always empty — there are no DB rows to compare against.
-   */
-  async upsertJobRows(entries, poolConfig) {
-    void poolConfig;
-    for (const entry of entries) {
-      this.registerHandler(
-        entry.type,
-        entry.meta,
-        entry.handlerClass
-      );
-    }
-    return { orphaned: [] };
-  }
-  // ==========================================================================
-  // start
-  // ==========================================================================
-  async start(type, input, opts = {}, _tx) {
-    const tenantId = this.resolveTenantId("start", opts.tenantId);
-    return this.mutex.run(async () => {
-      const payload = input ?? {};
-      const definition = this.store.jobs.get(type);
-      if (!definition) throw new JobTypeNotFoundError(type);
-      if (definition.dedupeKeyTemplate && definition.dedupeWindowMs) {
-        const dedupeKey2 = evaluateKeyTemplate2(
-          definition.dedupeKeyTemplate,
-          payload
-        );
-        const windowStart = Date.now() - definition.dedupeWindowMs;
-        const existing = this.findDedupeCandidate(type, dedupeKey2, windowStart);
-        if (existing) return existing;
-      }
-      let concurrencyKey = null;
-      let queueBlockedBy = null;
-      if (definition.concurrencyKeyTemplate) {
-        concurrencyKey = evaluateKeyTemplate2(
-          definition.concurrencyKeyTemplate,
-          payload
-        );
-        const incumbent = this.findInFlightByConcurrencyKey(concurrencyKey);
-        if (incumbent) {
-          switch (definition.collisionMode) {
-            case "reject":
-              throw new JobCollisionError(type, concurrencyKey, incumbent);
-            case "replace":
-              this.cancelLocked(
-                incumbent.id,
-                { cascade: true, reason: "replaced" },
-                incumbent.tenantId
-              );
-              break;
-            case "queue":
-              queueBlockedBy = incumbent.id;
-              break;
-          }
-        }
-      }
-      const newId = randomUUID3();
-      let rootRunId = newId;
-      if (opts.parentRunId) {
-        const parent = this.store.runs.get(opts.parentRunId);
-        if (!parent) {
-          throw new Error(
-            `parentRunId ${opts.parentRunId} does not reference an existing job_run`
-          );
-        }
-        rootRunId = parent.rootRunId;
-      }
-      const dedupeKey = definition.dedupeKeyTemplate ? evaluateKeyTemplate2(definition.dedupeKeyTemplate, payload) : null;
-      const now = /* @__PURE__ */ new Date();
-      const runAt = queueBlockedBy ? QUEUED_RUN_AT : opts.runAt ?? now;
-      const row = {
-        id: newId,
-        jobType: type,
-        jobVersion: definition.version,
-        parentRunId: opts.parentRunId ?? null,
-        rootRunId,
-        parentClosePolicy: opts.parentClosePolicy ?? "terminate",
-        scopeEntityType: opts.scope?.entityType ?? null,
-        scopeEntityId: opts.scope?.entityId ?? null,
-        tenantId,
-        tags: opts.tags ?? {},
-        pool: opts.pool ?? definition.pool,
-        priority: opts.priority ?? definition.priorityDefault,
-        concurrencyKey,
-        dedupeKey,
-        status: "pending",
-        input: payload,
-        output: null,
-        error: null,
-        triggerSource: opts.triggerSource ?? "manual",
-        triggerRef: opts.triggerRef ?? null,
-        runAt,
-        startedAt: null,
-        finishedAt: null,
-        claimedAt: null,
-        attempts: 0,
-        waitKind: null,
-        resumeToken: null,
-        waitDeadline: null,
-        createdAt: now,
-        updatedAt: now
-      };
-      this.store.runs.set(newId, row);
-      if (queueBlockedBy) {
-        const list = this.queueBlockers.get(queueBlockedBy) ?? [];
-        list.push(newId);
-        this.queueBlockers.set(queueBlockedBy, list);
-      }
-      return row;
-    });
-  }
-  // ==========================================================================
-  // cancel
-  // ==========================================================================
-  async cancel(runId, opts = {}) {
-    const tenantId = this.resolveTenantId("cancel", opts.tenantId);
-    await this.mutex.run(async () => {
-      this.cancelLocked(runId, opts, tenantId);
-    });
-  }
-  /**
-   * Internal cancel that assumes the caller already holds the mutex.
-   * Synchronous because all store ops are in-memory. Idempotent.
-   *
-   * `tenantForGate` is the already-validated tenant id (or `null`). When
-   * non-null it gates the initial cancellation to that tenant's run; the
-   * cascade step then sweeps descendants on the same `rootRunId` without
-   * re-checking — children of a tenant-gated parent always share the
-   * tenant (enforced at `start` time).
-   */
-  cancelLocked(runId, opts, tenantForGate) {
-    const run = this.store.runs.get(runId);
-    if (!run) return;
-    if (this.multiTenant && run.tenantId !== tenantForGate) return;
-    if (isTerminal(run.status)) return;
-    const now = /* @__PURE__ */ new Date();
-    const descendants = opts.cascade === false ? [] : Array.from(this.store.runs.values()).filter(
-      (r) => r.rootRunId === run.rootRunId && r.id !== runId && !isTerminal(r.status)
-    );
-    const terminateChildren = descendants.filter(
-      (d) => d.parentClosePolicy === "terminate" /* Terminate */
-    );
-    const cancelChildren = descendants.filter(
-      (d) => d.parentClosePolicy === "cancel" /* Cancel */
-    );
-    for (const child of terminateChildren) {
-      this.transitionToCanceled(child.id, now);
-    }
-    for (const child of cancelChildren) {
-      this.transitionToCanceled(child.id, now);
-    }
-    this.transitionToCanceled(runId, now);
-    void opts.reason;
-  }
-  transitionToCanceled(runId, at) {
-    const run = this.store.runs.get(runId);
-    if (!run) return;
-    if (isTerminal(run.status)) return;
-    const next = {
-      ...run,
-      status: "canceled",
-      finishedAt: at,
-      updatedAt: at
-    };
-    this.store.runs.set(runId, next);
-    this.unblockQueuedDependents(runId);
-  }
-  /**
-   * When `runId` transitions to a terminal state, advance every dependent
-   * `queue`-blocked run's `run_at` back to `now()` so `claimNext` picks
-   * them up.
-   */
-  unblockQueuedDependents(runId) {
-    const dependents = this.queueBlockers.get(runId);
-    if (!dependents || dependents.length === 0) return;
-    const now = /* @__PURE__ */ new Date();
-    for (const dep of dependents) {
-      const depRun = this.store.runs.get(dep);
-      if (!depRun) continue;
-      if (depRun.status !== "pending") continue;
-      this.store.runs.set(dep, { ...depRun, runAt: now, updatedAt: now });
-    }
-    this.queueBlockers.delete(runId);
-  }
-  // ==========================================================================
-  // claimNext — consumed by JobWorker in memory mode (tests exercise directly)
-  // ==========================================================================
-  async claimNext(pool) {
-    return this.mutex.run(async () => {
-      const now = Date.now();
-      const candidates = Array.from(this.store.runs.values()).filter(
-        (r) => r.status === "pending" && r.pool === pool && r.runAt.getTime() <= now
-      );
-      if (candidates.length === 0) return null;
-      candidates.sort((a, b) => {
-        if (a.priority !== b.priority) return b.priority - a.priority;
-        return a.runAt.getTime() - b.runAt.getTime();
-      });
-      const winner = candidates[0];
-      const claimedAt = /* @__PURE__ */ new Date();
-      const next = {
-        ...winner,
-        status: "running",
-        claimedAt,
-        startedAt: claimedAt,
-        updatedAt: claimedAt
-      };
-      this.store.runs.set(winner.id, next);
-      return next;
-    });
-  }
-  // ==========================================================================
-  // replay
-  // ==========================================================================
-  async replay(runId) {
-    return this.mutex.run(async () => {
-      const run = this.store.runs.get(runId);
-      if (!run) throw new Error(`replay: run ${runId} not found`);
-      if (!isTerminal(run.status)) {
-        throw new JobNotReplayableError(runId, run.status);
-      }
-      const def = this.store.jobs.get(run.jobType);
-      if (!def) throw new JobTypeNotFoundError(run.jobType);
-      const mode = def.replayFrom;
-      if (mode === "scratch") {
-        this.stepService.clearStepsForRun(runId);
-      } else {
-        this.stepService.clearIncompleteSteps(runId);
-      }
-      const now = /* @__PURE__ */ new Date();
-      const next = {
-        ...run,
-        status: "pending",
-        attempts: 0,
-        runAt: now,
-        startedAt: null,
-        finishedAt: null,
-        claimedAt: null,
-        error: null,
-        output: null,
-        updatedAt: now
-      };
-      this.store.runs.set(runId, next);
-      return next;
-    });
-  }
-  // ==========================================================================
-  // tick — used by unit tests + memory-mode JobWorker
-  // ==========================================================================
-  /**
-   * Execute a single claimed run to completion, retry, or failure. Not on
-   * `IJobOrchestrator` — it's the memory equivalent of the Drizzle
-   * `JobWorker.processRun` code path. The unit tests drive it directly so
-   * they can assert memoization across ticks without spinning up a worker.
-   */
-  async tick(runId) {
-    const run = this.store.runs.get(runId);
-    if (!run) throw new Error(`tick: run ${runId} not found`);
-    if (run.status !== "running") {
-      throw new Error(
-        `tick: run ${runId} must be 'running' (got '${run.status}')`
-      );
-    }
-    const registration = this.handlerRegistry.get(run.jobType);
-    if (!registration) {
-      await this.markFailed(run, new Error(
-        `No handler registered for jobType='${run.jobType}'`
-      ), (run.attempts ?? 0) + 1);
-      return;
-    }
-    const meta = registration.meta;
-    const HandlerClass = registration.handlerClass;
-    const handler = this.moduleRef ? this.moduleRef.get(
-      HandlerClass,
-      { strict: false }
-    ) : new HandlerClass();
-    const ctx = {
-      input: run.input,
-      run,
-      step: this.makeStepFn(run),
-      spawnChild: this.makeSpawnFn(run),
-      logger: new Logger2(`JobRun:${run.id}`)
-    };
-    const attemptsBefore = run.attempts ?? 0;
-    try {
-      const output = await handler.run(ctx);
-      await this.markCompleted(run, output ?? {}, attemptsBefore + 1);
-    } catch (err) {
-      const policy = meta.retry;
-      const decision = classifyError(err, policy, attemptsBefore);
-      const nextAttempts = attemptsBefore + 1;
-      if (decision === "retry" && policy) {
-        const delay = computeBackoff(policy, nextAttempts);
-        await this.rescheduleForRetry(run, err, nextAttempts, delay);
-      } else {
-        await this.markFailed(run, err, nextAttempts);
-      }
-    }
-  }
-  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 seq = this.nextStepSeq(run.id);
-      const startedAt = /* @__PURE__ */ new Date();
-      const nextAttempts = (existing?.attempts ?? 0) + 1;
-      await this.stepService.recordStep({
-        jobRunId: run.id,
-        stepId,
-        kind: "task",
-        seq,
-        status: "running",
-        startedAt,
-        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.start(type, input, {
-        parentRunId: run.id,
-        parentClosePolicy: opts?.closePolicy,
-        runAt: opts?.runAt,
-        priority: opts?.priority,
-        tags: opts?.tags,
-        triggerSource: "parent",
-        triggerRef: run.id
-      });
-    };
-  }
-  nextStepSeq(runId) {
-    const rows = this.store.steps.get(runId);
-    if (!rows || rows.length === 0) return 1;
-    let max = 0;
-    for (const r of rows) if (r.seq > max) max = r.seq;
-    return max + 1;
-  }
-  async markCompleted(run, output, attempts) {
-    await this.mutex.run(async () => {
-      const current = this.store.runs.get(run.id);
-      if (!current || isTerminal(current.status)) return;
-      const now = /* @__PURE__ */ new Date();
-      this.store.runs.set(run.id, {
-        ...current,
-        status: "completed",
-        output,
-        finishedAt: now,
-        updatedAt: now,
-        attempts
-      });
-      this.unblockQueuedDependents(run.id);
-    });
-  }
-  async markFailed(run, err, attempts) {
-    await this.mutex.run(async () => {
-      const current = this.store.runs.get(run.id);
-      if (!current || isTerminal(current.status)) return;
-      const now = /* @__PURE__ */ new Date();
-      this.store.runs.set(run.id, {
-        ...current,
-        status: "failed",
-        finishedAt: now,
-        updatedAt: now,
-        attempts,
-        error: serialiseError(err, attempts, false)
-      });
-      this.unblockQueuedDependents(run.id);
-    });
-    if (run.parentClosePolicy === "terminate") {
-      try {
-        await this.cancel(run.id, {
-          cascade: true,
-          reason: "parent-failed",
-          tenantId: run.tenantId
-        });
-      } catch (cascadeErr) {
-        this.logger.warn(
-          `cascade on failed run ${run.id}: ${cascadeErr.message}`
-        );
-      }
-    }
-  }
-  async rescheduleForRetry(run, err, attempts, delayMs) {
-    await this.mutex.run(async () => {
-      const current = this.store.runs.get(run.id);
-      if (!current || isTerminal(current.status)) return;
-      const now = /* @__PURE__ */ new Date();
-      this.store.runs.set(run.id, {
-        ...current,
-        status: "pending",
-        attempts,
-        runAt: new Date(Date.now() + delayMs),
-        startedAt: null,
-        claimedAt: null,
-        updatedAt: now,
-        error: serialiseError(err, attempts, true)
-      });
-    });
-  }
-  // ==========================================================================
-  // Internal queries — used by start / cancel
-  // ==========================================================================
-  findDedupeCandidate(jobType, dedupeKey, windowStartMs) {
-    let best = null;
-    for (const r of this.store.runs.values()) {
-      if (r.jobType !== jobType) continue;
-      if (r.dedupeKey !== dedupeKey) continue;
-      if (DEDUPE_EXCLUDED_STATUSES2.includes(r.status)) continue;
-      if (r.createdAt.getTime() <= windowStartMs) continue;
-      if (!best || r.createdAt.getTime() > best.createdAt.getTime()) {
-        best = r;
-      }
-    }
-    return best;
-  }
-  findInFlightByConcurrencyKey(key) {
-    for (const r of this.store.runs.values()) {
-      if (r.concurrencyKey !== key) continue;
-      if (!IN_FLIGHT_STATUSES2.includes(r.status)) continue;
-      return r;
-    }
-    return null;
-  }
-};
-MemoryJobOrchestrator = __decorateClass([
-  Injectable5(),
-  __decorateParam(0, Inject5(MemoryJobStore)),
-  __decorateParam(1, Inject5(MemoryJobStepService)),
-  __decorateParam(2, Inject5(JOBS_MULTI_TENANT)),
-  __decorateParam(3, Optional()),
-  __decorateParam(3, Inject5(ModuleRef))
-], MemoryJobOrchestrator);
-function classifyError(err, policy, currentAttempts) {
-  if (!policy) return "fail";
-  const errObj = err;
-  const name = errObj?.name;
-  const code = errObj?.code;
-  const nonRetryable = policy.nonRetryableErrors ?? [];
-  if (nonRetryable.some((n) => n === name || n === code)) return "fail";
-  if (currentAttempts + 1 >= policy.attempts) return "fail";
-  return "retry";
-}
-function computeBackoff(policy, attempts) {
-  const base = Math.max(policy.baseMs, 0);
-  if (policy.backoff === "fixed") return base;
-  const exponent = Math.max(attempts - 1, 0);
-  if (exponent >= 53) return Number.MAX_SAFE_INTEGER;
-  const raw = base * Math.pow(2, exponent);
-  if (!Number.isFinite(raw) || raw >= Number.MAX_SAFE_INTEGER) {
-    return Number.MAX_SAFE_INTEGER;
-  }
-  return raw;
-}
-function serialiseError(err, attempt, retryable) {
-  const e = err;
-  return {
-    message: e?.message ?? String(err),
-    stack: e?.stack,
-    retryable,
-    attempt
-  };
-}
-
-// runtime/subsystems/jobs/job-run-service.memory-backend.ts
-import { Inject as Inject6, Injectable as Injectable6 } from "@nestjs/common";
-var NON_TERMINAL_STATUSES2 = [
-  "pending",
-  "running",
-  "waiting"
-];
-var MemoryJobRunService = class {
-  constructor(store, orchestrator, multiTenant) {
-    this.store = store;
-    this.orchestrator = orchestrator;
-    this.multiTenant = multiTenant;
-  }
-  store;
-  orchestrator;
-  multiTenant;
-  /**
-   * JOB-8 — produce a per-row predicate for the tenant gate.
-   * Returns `null` when multi-tenancy is off (caller doesn't check).
-   * Throws when on + `undefined`; matches `tenant_id IS NULL` on explicit
-   * `null` to support cross-tenant background work.
-   */
-  tenantPredicate(method, tenantId) {
-    if (!this.multiTenant) return null;
-    if (tenantId === void 0) throw new MissingTenantIdError(method);
-    return (r) => r.tenantId === tenantId;
-  }
-  async listForScope(entityType, entityId, opts = {}) {
-    const statusFilter = opts.status ? Array.isArray(opts.status) ? new Set(opts.status) : /* @__PURE__ */ new Set([opts.status]) : null;
-    const tenantCheck = this.tenantPredicate("listForScope", opts.tenantId);
-    const rows = [];
-    for (const r of this.store.runs.values()) {
-      if (r.scopeEntityType !== entityType) continue;
-      if (r.scopeEntityId !== entityId) continue;
-      if (statusFilter && !statusFilter.has(r.status)) continue;
-      if (opts.jobType && r.jobType !== opts.jobType) continue;
-      if (tenantCheck && !tenantCheck(r)) continue;
-      rows.push(r);
-    }
-    const orderBy = opts.orderBy ?? "created_at desc";
-    rows.sort((a, b) => compareBy(a, b, orderBy));
-    const offset = opts.offset ?? 0;
-    const limit = opts.limit;
-    const sliced = typeof limit === "number" ? rows.slice(offset, offset + limit) : rows.slice(offset);
-    return sliced;
-  }
-  async cancelForScope(entityType, entityId, opts = {}) {
-    const tenantCheck = this.tenantPredicate("cancelForScope", opts.tenantId);
-    const ids = [];
-    for (const r of this.store.runs.values()) {
-      if (r.scopeEntityType !== entityType) continue;
-      if (r.scopeEntityId !== entityId) continue;
-      if (!NON_TERMINAL_STATUSES2.includes(r.status)) continue;
-      if (tenantCheck && !tenantCheck(r)) continue;
-      ids.push(r.id);
-    }
-    for (const id of ids) {
-      await this.orchestrator.cancel(id, {
-        cascade: true,
-        tenantId: opts.tenantId
-      });
-    }
-  }
-  async rescheduleForScope(entityType, entityId, newRunAt, opts = {}) {
-    const tenantCheck = this.tenantPredicate("rescheduleForScope", opts.tenantId);
-    for (const r of this.store.runs.values()) {
-      if (r.scopeEntityType !== entityType) continue;
-      if (r.scopeEntityId !== entityId) continue;
-      if (r.status !== "pending") continue;
-      if (tenantCheck && !tenantCheck(r)) continue;
-      this.store.runs.set(r.id, {
-        ...r,
-        runAt: newRunAt,
-        updatedAt: /* @__PURE__ */ new Date()
-      });
-    }
-  }
-  async countByPoolAndStatus(tenantId) {
-    const tenantCheck = this.tenantPredicate("countByPoolAndStatus", tenantId);
-    const map = /* @__PURE__ */ new Map();
-    for (const r of this.store.runs.values()) {
-      if (tenantCheck && !tenantCheck(r)) continue;
-      const key = `${r.pool}\0${r.status}`;
-      const cur = map.get(key);
-      if (cur) {
-        cur.count += 1;
-      } else {
-        map.set(key, { pool: r.pool, status: r.status, count: 1 });
-      }
-    }
-    return Array.from(map.values());
-  }
-  async listRecentFailed(limit, tenantId) {
-    const tenantCheck = this.tenantPredicate("listRecentFailed", tenantId);
-    const failed = [];
-    for (const r of this.store.runs.values()) {
-      if (r.status !== "failed") continue;
-      if (tenantCheck && !tenantCheck(r)) continue;
-      failed.push(r);
-    }
-    failed.sort((a, b) => {
-      const at = (a.finishedAt ?? a.updatedAt).getTime();
-      const bt = (b.finishedAt ?? b.updatedAt).getTime();
-      return bt - at;
-    });
-    return failed.slice(0, limit).map((r) => ({
-      runId: r.id,
-      jobType: r.jobType,
-      pool: r.pool,
-      scopeEntityType: r.scopeEntityType,
-      scopeEntityId: r.scopeEntityId,
-      tenantId: r.tenantId,
-      attempts: r.attempts,
-      errorMessage: r.error?.message ?? null,
-      failedAt: r.finishedAt ?? r.updatedAt,
-      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
-   * are debug / test helpers that sidestep the orchestrator.
-   */
-  findById(runId) {
-    return this.store.runs.get(runId) ?? null;
-  }
-  /** Public counterpart to the Drizzle backend's `findByRootRunId` helper. */
-  findByRootRunId(rootRunId) {
-    const out = [];
-    for (const r of this.store.runs.values()) {
-      if (r.rootRunId === rootRunId) out.push(r);
-    }
-    return out;
-  }
-};
-MemoryJobRunService = __decorateClass([
-  Injectable6(),
-  __decorateParam(0, Inject6(MemoryJobStore)),
-  __decorateParam(1, Inject6(JOB_ORCHESTRATOR)),
-  __decorateParam(2, Inject6(JOBS_MULTI_TENANT))
-], MemoryJobRunService);
-function compareBy(a, b, order) {
-  switch (order) {
-    case "created_at asc":
-      return a.createdAt.getTime() - b.createdAt.getTime();
-    case "run_at desc":
-      return b.runAt.getTime() - a.runAt.getTime();
-    case "run_at asc":
-      return a.runAt.getTime() - b.runAt.getTime();
-    case "created_at desc":
-    default:
-      return b.createdAt.getTime() - a.createdAt.getTime();
-  }
-}
-
-// 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 = Symbol.for(tokenKey("jobs", "bullmq-connection"));
-var BULLMQ_RESOLVED_CONFIG = Symbol.for(tokenKey("jobs", "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 {
-      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
-    };
-  }
-};
-JobsDomainModule = __decorateClass([
-  Module({})
-], JobsDomainModule);
-
-// runtime/subsystems/jobs/job-worker.ts
-import { Inject as Inject7, 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 = Symbol.for(tokenKey("jobs", "worker-options"));
-var DEFAULT_POLL_INTERVAL_MS = 1e3;
-var DEFAULT_STALE_SWEEPER_INTERVAL_MS = 6e4;
-var DEFAULT_STALE_THRESHOLD_MS = 5 * 6e4;
-var DEFAULT_SHUTDOWN_TIMEOUT_MS = 3e4;
-function computeBackoff2(policy, attempts) {
-  const base = Math.max(policy.baseMs, 0);
-  if (policy.backoff === "fixed") {
-    return base;
-  }
-  const exponent = Math.max(attempts - 1, 0);
-  if (exponent >= 53) return Number.MAX_SAFE_INTEGER;
-  const raw = base * Math.pow(2, exponent);
-  if (!Number.isFinite(raw) || raw >= Number.MAX_SAFE_INTEGER) {
-    return Number.MAX_SAFE_INTEGER;
-  }
-  return raw;
-}
-function classifyError2(err, policy, currentAttempts) {
-  if (!policy) return "fail";
-  const errObj = err;
-  const name = errObj?.name;
-  const code = errObj?.code;
-  const nonRetryable = policy.nonRetryableErrors ?? [];
-  if (nonRetryable.some((n) => n === name || n === code)) return "fail";
-  if (currentAttempts + 1 >= policy.attempts) return "fail";
-  return "retry";
-}
-function serialiseError2(err, attempt, retryable) {
-  const e = err;
-  return {
-    message: e?.message ?? String(err),
-    stack: e?.stack,
-    retryable,
-    attempt
-  };
-}
-var JobWorker = class {
-  constructor(db, orchestrator, runService, stepService, options, moduleRef) {
-    this.db = db;
-    this.orchestrator = orchestrator;
-    this.runService = runService;
-    this.stepService = stepService;
-    this.options = options;
-    this.moduleRef = moduleRef;
-    this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-    this.staleSweeperIntervalMs = options.staleSweeperIntervalMs ?? DEFAULT_STALE_SWEEPER_INTERVAL_MS;
-    this.staleThresholdMs = options.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
-    this.shutdownTimeoutMs = options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS;
-    this.sigtermHandler = () => {
-      if (this.sigtermHandled) return;
-      this.sigtermHandled = true;
-      void this.onModuleDestroy();
-    };
-    void this.runService;
-  }
-  db;
-  orchestrator;
-  runService;
-  stepService;
-  options;
-  moduleRef;
-  logger = new Logger3(JobWorker.name);
-  shuttingDown = false;
-  inFlight = /* @__PURE__ */ new Set();
-  pollTimer = null;
-  sweeperTimer = null;
-  sigtermHandled = false;
-  sigtermHandler;
-  pollIntervalMs;
-  staleSweeperIntervalMs;
-  staleThresholdMs;
-  shutdownTimeoutMs;
-  // ============================================================================
-  // Lifecycle
-  // ============================================================================
-  onModuleInit() {
-    this.pollTimer = setInterval(() => {
-      void this.pollAndProcess();
-    }, this.pollIntervalMs);
-    this.sweeperTimer = setInterval(() => {
-      void this.sweepStaleClaims();
-    }, this.staleSweeperIntervalMs);
-    process.on("SIGTERM", this.sigtermHandler);
-  }
-  async onModuleDestroy() {
-    if (this.shuttingDown) {
-      await this.drainInFlight();
-      return;
-    }
-    this.shuttingDown = true;
-    if (this.pollTimer) {
-      clearInterval(this.pollTimer);
-      this.pollTimer = null;
-    }
-    if (this.sweeperTimer) {
-      clearInterval(this.sweeperTimer);
-      this.sweeperTimer = null;
-    }
-    process.removeListener("SIGTERM", this.sigtermHandler);
-    await this.drainInFlight();
-    try {
-      await this.db.update(jobRuns).set({ status: "pending", claimedAt: null, startedAt: null }).where(
-        and4(eq4(jobRuns.status, "running"), eq4(jobRuns.pool, this.options.pool))
-      );
-    } catch (err) {
-      this.logger.error(`shutdown reset failed: ${err.message}`);
-    }
-  }
-  async drainInFlight() {
-    if (this.inFlight.size === 0) return;
-    const timeout = new Promise(
-      (resolve2) => setTimeout(resolve2, this.shutdownTimeoutMs)
-    );
-    await Promise.race([
-      Promise.allSettled([...this.inFlight]).then(() => void 0),
-      timeout
-    ]);
-  }
-  // ============================================================================
-  // Poll loop
-  // ============================================================================
-  async pollAndProcess() {
-    if (this.shuttingDown) return;
-    if (this.inFlight.size >= this.options.concurrency) return;
-    let claimed;
-    try {
-      claimed = await this.claimNext(this.options.pool);
-    } catch (err) {
-      this.logger.error(`claimNext failed: ${err.message}`);
-      return;
-    }
-    if (!claimed) return;
-    const run = claimed;
-    const promise = this.processRun(run).catch((err) => {
-      this.logger.error(
-        `processRun(${run.id}) unhandled: ${err.message}`
-      );
-    });
-    this.inFlight.add(promise);
-    promise.finally(() => {
-      this.inFlight.delete(promise);
-    });
-  }
-  /**
-   * Claim the next runnable row from the pool. Transaction ensures the
-   * select-candidate + update-to-running pair is atomic; FOR UPDATE SKIP
-   * LOCKED lets multiple workers share the table without serialising.
-   */
-  async claimNext(pool) {
-    return this.db.transaction(async (tx) => {
-      const candidates = await tx.select({ id: jobRuns.id }).from(jobRuns).where(
-        and4(
-          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 });
-      const candidate = candidates[0];
-      if (!candidate) return null;
-      const [claimed] = await tx.update(jobRuns).set({
-        status: "running",
-        claimedAt: /* @__PURE__ */ new Date(),
-        startedAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      }).where(eq4(jobRuns.id, candidate.id)).returning();
-      return claimed ?? null;
-    });
-  }
-  // ============================================================================
-  // Stale claim sweeper
-  // ============================================================================
-  /**
-   * Release rows whose `claimed_at` is older than the threshold. Safe to
-   * run concurrently across workers — the two-phase tx (select-for-update
-   * then update) guarantees each stranded row is only reset once.
-   */
-  async sweepStaleClaims() {
-    if (this.shuttingDown) return;
-    try {
-      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(eq4(jobRuns.status, "running"), lt2(jobRuns.claimedAt, threshold))
-        ).for("update", { skipLocked: true });
-        if (stale.length === 0) return;
-        const ids = stale.map((r) => r.id);
-        await tx.update(jobRuns).set({ status: "pending", claimedAt: null, startedAt: null }).where(inArray3(jobRuns.id, ids));
-        for (const id of ids) {
-          this.logger.warn(`Recovered stale claim on run ${id}`);
-        }
-      });
-    } catch (err) {
-      this.logger.error(`sweepStaleClaims failed: ${err.message}`);
-    }
-  }
-  // ============================================================================
-  // processRun
-  // ============================================================================
-  async processRun(claimed) {
-    const registryEntry = JOB_HANDLER_REGISTRY.get(claimed.jobType);
-    if (!registryEntry) {
-      this.logger.error(
-        `No handler registered for jobType='${claimed.jobType}' (run ${claimed.id})`
-      );
-      await this.markFailed(
-        claimed,
-        new Error(`No handler registered for jobType='${claimed.jobType}'`),
-        /*finalAttempts*/
-        (claimed.attempts ?? 0) + 1
-      );
-      return;
-    }
-    if (claimed.concurrencyKey) {
-      const inflight = await this.db.select({ id: jobRuns.id }).from(jobRuns).where(
-        and4(
-          eq4(jobRuns.concurrencyKey, claimed.concurrencyKey),
-          eq4(jobRuns.status, "running")
-        )
-      );
-      const other = inflight.find((r) => r.id !== claimed.id);
-      if (other) {
-        await this.db.update(jobRuns).set({
-          status: "pending",
-          claimedAt: null,
-          startedAt: null,
-          updatedAt: /* @__PURE__ */ new Date()
-        }).where(eq4(jobRuns.id, claimed.id));
-        return;
-      }
-    }
-    const meta = registryEntry.meta;
-    const HandlerClass = registryEntry.handlerClass;
-    const handler = this.moduleRef.get(
-      HandlerClass,
-      { strict: false }
-    );
-    const ctx = {
-      input: claimed.input,
-      run: claimed,
-      step: this.makeStepFn(claimed),
-      spawnChild: this.makeSpawnFn(claimed),
-      logger: new Logger3(`JobRun:${claimed.id}`)
-    };
-    const attemptsBefore = claimed.attempts ?? 0;
-    try {
-      const output = await handler.run(ctx);
-      await this.db.update(jobRuns).set({
-        status: "completed",
-        output: output ?? {},
-        finishedAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date(),
-        attempts: attemptsBefore + 1
-      }).where(eq4(jobRuns.id, claimed.id));
-    } catch (err) {
-      const policy = meta.retry;
-      const decision = classifyError2(err, policy, attemptsBefore);
-      const nextAttempts = attemptsBefore + 1;
-      if (decision === "retry" && policy) {
-        const delay = computeBackoff2(policy, nextAttempts);
-        await this.db.update(jobRuns).set({
-          status: "pending",
-          attempts: nextAttempts,
-          runAt: new Date(Date.now() + delay),
-          startedAt: null,
-          claimedAt: null,
-          error: serialiseError2(err, nextAttempts, true),
-          updatedAt: /* @__PURE__ */ new Date()
-        }).where(eq4(jobRuns.id, claimed.id));
-      } else {
-        await this.markFailed(claimed, err, nextAttempts);
-      }
-    }
-  }
-  async markFailed(claimed, err, finalAttempts) {
-    await this.db.update(jobRuns).set({
-      status: "failed",
-      attempts: finalAttempts,
-      finishedAt: /* @__PURE__ */ new Date(),
-      error: serialiseError2(err, finalAttempts, false),
-      updatedAt: /* @__PURE__ */ new Date()
-    }).where(eq4(jobRuns.id, claimed.id));
-    if (claimed.parentClosePolicy === "terminate") {
-      try {
-        await this.orchestrator.cancel(claimed.id, {
-          cascade: true,
-          reason: "parent-failed",
-          tenantId: claimed.tenantId
-        });
-      } catch (cascadeErr) {
-        this.logger.warn(
-          `cascade on failed run ${claimed.id}: ${cascadeErr.message}`
-        );
-      }
-    }
-  }
-  // ============================================================================
-  // ctx.step / ctx.spawnChild builders
-  // ============================================================================
-  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 seq = await this.nextStepSeq(run.id);
-      const startedAt = /* @__PURE__ */ new Date();
-      const nextAttempts = (existing?.attempts ?? 0) + 1;
-      await this.stepService.recordStep({
-        jobRunId: run.id,
-        stepId,
-        kind: "task",
-        seq,
-        status: "running",
-        startedAt,
-        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: serialiseError2(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
-      });
-    };
-  }
-  /**
-   * Allocate the next `seq` for a given run. SELECT-max approach — runs
-   * typically have <100 steps so the scan is cheap, and correctness across
-   * retries is more important than the microseconds saved by an in-memory
-   * counter (which would drift if the worker crashes mid-run and another
-   * worker resumes via stale-claim sweep).
-   */
-  async nextStepSeq(runId) {
-    const [row] = await this.db.execute(
-      sql4`SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM job_step WHERE job_run_id = ${runId}`
-    );
-    const maybeRows = row?.rows;
-    if (Array.isArray(maybeRows) && maybeRows.length > 0) {
-      return Number(maybeRows[0].next ?? 1);
-    }
-    if (row && typeof row.next !== "undefined") {
-      return Number(row.next);
-    }
-    return 1;
-  }
-  // ============================================================================
-  // (suppress unused-import noise)
-  // ============================================================================
-};
-JobWorker = __decorateClass([
-  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/job-worker.module.ts
-var DEFAULT_SHUTDOWN_TIMEOUT_MS2 = 3e4;
-var JOB_WORKER_MODULE_OPTIONS = Symbol.for(tokenKey("jobs", "worker-module-options"));
-var JobWorkerOrchestrator = class {
-  constructor(orchestrator, runService, stepService, options, db = null, moduleRef, bullConnection = null, bullConfig = null) {
-    this.orchestrator = orchestrator;
-    this.runService = runService;
-    this.stepService = stepService;
-    this.options = options;
-    this.db = db;
-    this.moduleRef = moduleRef;
-    this.bullConnection = bullConnection;
-    this.bullConfig = bullConfig;
-  }
-  orchestrator;
-  runService;
-  stepService;
-  options;
-  db;
-  moduleRef;
-  bullConnection;
-  bullConfig;
-  logger = new Logger4(JobWorkerOrchestrator.name);
-  workers = [];
-  // ============================================================================
-  // Lifecycle
-  // ============================================================================
-  async onModuleInit() {
-    const backend = this.options.backend ?? "drizzle";
-    const poolConfig = loadPoolConfig(this.options.configPath);
-    const entries = HandlerRegistry.getAll();
-    this.assertNoReservedPoolHandlers(entries, poolConfig);
-    const { orphaned } = await this.orchestrator.upsertJobRows(
-      entries,
-      poolConfig
-    );
-    if (backend !== "memory" && orphaned.length > 0) {
-      throw new BootValidationError(orphaned);
-    }
-    const activePools = this.options.pools ? this.options.pools : this.options.allPools ? allPoolNames(poolConfig) : allNonReservedPoolNames(poolConfig);
-    for (const poolName of activePools) {
-      const def = poolConfig.get(poolName);
-      if (!def) {
-        throw new Error(
-          `JobWorkerModule: active pool '${poolName}' is not defined in the resolved pool config. Configured pools: [${[...poolConfig.keys()].join(", ")}].`
-        );
-      }
-      const workerOptions = {
-        pool: poolName,
-        concurrency: def.concurrency,
-        shutdownTimeoutMs: this.options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS2
-      };
-      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(
-        `JobWorker started: pool='${poolName}' (queue='${def.queue}') concurrency=${def.concurrency} backend='${backend}'`
-      );
-    }
-  }
-  async onModuleDestroy() {
-    for (let i = this.workers.length - 1; i >= 0; i--) {
-      const worker = this.workers[i];
-      if (!worker) continue;
-      try {
-        await worker.onModuleDestroy();
-      } catch (err) {
-        this.logger.error(
-          `JobWorker shutdown failed: ${err.message}`
-        );
-      }
-    }
-    this.workers.length = 0;
-    const orch = this.orchestrator;
-    if (typeof orch.closeConnections === "function") {
-      try {
-        await orch.closeConnections();
-      } catch (err) {
-        this.logger.error(
-          `BullMQ orchestrator connection close failed: ${err.message}`
-        );
-      }
-    }
-  }
-  // ============================================================================
-  // Internals
-  // ============================================================================
-  /**
-   * Walk every registered handler; collect any whose declared `pool`
-   * targets a reserved pool from the resolved config. If non-empty,
-   * throw `ReservedPoolViolationError` with the offender list so the
-   * operator sees every violating class on a single boot.
-   */
-  assertNoReservedPoolHandlers(entries, poolConfig) {
-    const offenders = [];
-    for (const entry of entries) {
-      if (entry.type.startsWith("@framework/")) continue;
-      const declaredPool = entry.meta.pool ?? "batch";
-      const def = poolConfig.get(declaredPool);
-      if (def?.reserved) {
-        offenders.push({
-          handlerClass: entry.handlerClass.name,
-          pool: declaredPool
-        });
-      }
-    }
-    if (offenders.length > 0) {
-      throw new ReservedPoolViolationError(offenders);
-    }
-  }
-  /**
-   * Production worker spawn. `JobWorker` requires `DRIZZLE` so this only
-   * succeeds when the module was booted with `backend: 'drizzle'`. Memory
-   * mode tests must supply `workerFactory` — the memory backend has no
-   * polling loop equivalent (`MemoryJobOrchestrator` is direct-invocation
-   * only).
-   *
-   * We instantiate outside the Nest container because the module spawns
-   * N workers from a single options shape, which doesn't fit Nest's
-   * "one provider per token" model. The dependencies are passed
-   * positionally; the constructor's `@Inject` decorators are unused on
-   * this path (Nest still uses them when `JobWorker` is a provider — e.g.
-   * in JOB-6's standalone `worker.ts` entrypoint).
-   */
-  spawnWorker(workerOptions) {
-    if (!this.db) {
-      throw new Error(
-        `JobWorkerModule: in-process worker spawning requires the Drizzle backend (no DRIZZLE provider available). Memory-mode tests must pass 'workerFactory' to inject a stub.`
-      );
-    }
-    if (!this.moduleRef) {
-      throw new Error(
-        `JobWorkerModule: ModuleRef not available \u2014 cannot construct JobWorker with handler DI support. Ensure the orchestrator is resolved through the Nest container (not instantiated manually in tests).`
-      );
-    }
-    return new JobWorker(
-      this.db,
-      this.orchestrator,
-      this.runService,
-      this.stepService,
-      workerOptions,
-      this.moduleRef
-    );
-  }
-  /**
-   * BULLMQ-1 — spawn a per-pool `BullMQJobWorker`. Requires the Drizzle
-   * client (the worker drives `job_run` as the source of truth) AND the
-   * resolved BullMQ connection (bound by `JobsDomainModule` when
-   * `backend: 'bullmq'`). The queue name is derived identically to the
-   * orchestrator's `dispatch` via `resolvePoolQueueName(pool, …)` so producer
-   * and consumer agree.
-   */
-  /**
-   * #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.`
-      );
-    }
-    if (!this.bullConnection) {
-      throw new Error(
-        `JobWorkerModule: BullMQ worker spawning requires a resolved BULLMQ_CONNECTION. Ensure JobsDomainModule was booted with backend: 'bullmq'.`
-      );
-    }
-    if (!this.moduleRef) {
-      throw new Error(
-        `JobWorkerModule: ModuleRef not available \u2014 cannot construct BullMQJobWorker with handler DI support.`
-      );
-    }
-    const queueName = resolvePoolQueueName(pool, this.bullConfig, poolConfig);
-    const specifier = "./job-worker.bullmq-backend";
-    const mod = await import(specifier);
-    return new mod.BullMQJobWorker(
-      this.db,
-      this.orchestrator,
-      this.stepService,
-      {
-        pool,
-        queueName,
-        concurrency,
-        connection: this.bullConnection
-      },
-      this.moduleRef
-    );
-  }
-};
-JobWorkerOrchestrator = __decorateClass([
-  Injectable8(),
-  __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, Optional2()),
-  __decorateParam(4, Inject8(DRIZZLE)),
-  __decorateParam(5, Inject8(ModuleRef2)),
-  __decorateParam(6, Optional2()),
-  __decorateParam(6, Inject8(BULLMQ_CONNECTION)),
-  __decorateParam(7, Optional2()),
-  __decorateParam(7, Inject8(BULLMQ_RESOLVED_CONFIG))
-], JobWorkerOrchestrator);
-var JobWorkerModule = class {
-  static forRoot(opts) {
-    return {
-      module: JobWorkerModule,
-      imports: [
-        JobsDomainModule.forRoot({
-          backend: opts.backend ?? "drizzle",
-          extensions: opts.domainModuleExtensions,
-          multiTenant: opts.multiTenant
-        })
-      ],
-      providers: [
-        { provide: JOB_WORKER_MODULE_OPTIONS, useValue: opts },
-        JobWorkerOrchestrator
-      ],
-      // BULLMQ-1 Phase 1 — export the options token so `BridgeModule`'s
-      // reserved-pool guard (`onModuleInit`) can actually inject it.
-      // Previously `exports: []` left the `@Optional()` inject resolving to
-      // `undefined` and the guard silently no-opped (a dead check). With the
-      // token exported the guard fires for real; consumers that omit the
-      // reserved pools (and don't set `allPools`) now fail fast with
-      // `BridgeReservedPoolsNotPolledError` — which is correct.
-      exports: [JOB_WORKER_MODULE_OPTIONS]
-    };
-  }
-};
-JobWorkerModule = __decorateClass([
-  Module2({})
-], JobWorkerModule);
+  JOB_WORKER_MODULE_OPTIONS,
+  JobWorkerModule,
+  JobWorkerOrchestrator
+} from "../../../chunk-WPXNN6QS.js";
+import "../../../chunk-RC23QROE.js";
+import "../../../chunk-KMZCQASO.js";
+import "../../../chunk-I6MG4M3F.js";
+import "../../../chunk-JRVNVKN6.js";
+import "../../../chunk-DV4RV2DC.js";
+import "../../../chunk-5Y7W3XR6.js";
+import "../../../chunk-4RFHUZXU.js";
+import "../../../chunk-PNZSGAB2.js";
+import "../../../chunk-SNQ3TOWP.js";
+import "../../../chunk-T4BIIU5E.js";
+import "../../../chunk-L3LZWWSX.js";
+import "../../../chunk-I6MVCB5A.js";
+import "../../../chunk-RHVN6NA7.js";
+import "../../../chunk-CO6LUM72.js";
+import "../../../chunk-BIO6F7YI.js";
+import "../../../chunk-OKXZ63IA.js";
+import "../../../chunk-GYGNEQSC.js";
+import "../../../chunk-U64T4YZE.js";
+import "../../../chunk-2E224ZSN.js";
 export {
   JOB_WORKER_MODULE_OPTIONS,
   JobWorkerModule,