@pattern-stack/codegen 0.8.1 → 0.9.0

package/dist/runtime/subsystems/jobs/job-orchestrator.bullmq-backend.js

@@ -0,0 +1,922 @@
+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-orchestrator.bullmq-backend.ts
+import { createHash } from "crypto";
+import { Inject as Inject2, Injectable as Injectable2, Logger as Logger2, Optional } from "@nestjs/common";
+import { eq as eq2 } from "drizzle-orm";
+
+// runtime/constants/tokens.ts
+var DRIZZLE = "DRIZZLE";
+
+// 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/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/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";
+};
+
+// runtime/subsystems/jobs/jobs-domain.tokens.ts
+var JOBS_MULTI_TENANT = /* @__PURE__ */ Symbol("JOBS_MULTI_TENANT");
+
+// 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/pool-config.loader.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { parse as parseYaml } from "yaml";
+var FRAMEWORK_POOLS = Object.freeze({
+  events_inbound: Object.freeze({
+    queue: "jobs-events-inbound",
+    concurrency: 20,
+    reserved: true,
+    description: "Inbound events drain (events subsystem outbox)."
+  }),
+  events_change: Object.freeze({
+    queue: "jobs-events-change",
+    concurrency: 30,
+    reserved: true,
+    description: "Change events drain (events subsystem outbox)."
+  }),
+  events_outbound: Object.freeze({
+    queue: "jobs-events-outbound",
+    concurrency: 10,
+    reserved: true,
+    description: "Outbound events drain (events subsystem outbox)."
+  }),
+  interactive: Object.freeze({
+    queue: "jobs-interactive",
+    concurrency: 20,
+    reserved: false,
+    description: "User-facing latency-sensitive jobs."
+  }),
+  batch: Object.freeze({
+    queue: "jobs-batch",
+    concurrency: 5,
+    reserved: false,
+    description: "Default pool for background jobs."
+  })
+});
+var RESERVED_POOL_NAMES = new Set(
+  Object.entries(FRAMEWORK_POOLS).filter(([, def]) => def.reserved).map(([name]) => name)
+);
+var cache = /* @__PURE__ */ new Map();
+function loadPoolConfig(configPath) {
+  const resolved = resolve(configPath ?? `${process.cwd()}/codegen.config.yaml`);
+  const cached = cache.get(resolved);
+  if (cached) return cached;
+  const merged = /* @__PURE__ */ new Map();
+  for (const [name, def] of Object.entries(FRAMEWORK_POOLS)) {
+    merged.set(name, { ...def });
+  }
+  if (!existsSync(resolved)) {
+    cache.set(resolved, merged);
+    return merged;
+  }
+  let raw;
+  try {
+    raw = parseYaml(readFileSync(resolved, "utf8"));
+  } catch (err) {
+    throw new Error(
+      `pool-config.loader: failed to parse YAML at ${resolved}: ${err.message}`
+    );
+  }
+  const userPools = extractUserPools(raw);
+  for (const [name, userDef] of Object.entries(userPools)) {
+    const existing = merged.get(name);
+    if (existing) {
+      const next = {
+        queue: existing.queue,
+        concurrency: typeof userDef.concurrency === "number" ? userDef.concurrency : existing.concurrency,
+        reserved: existing.reserved,
+        description: userDef.description ?? existing.description
+      };
+      merged.set(name, next);
+      continue;
+    }
+    if (typeof userDef.queue !== "string" || userDef.queue.length === 0) {
+      throw new Error(
+        `pool-config.loader: pool '${name}' must declare a non-empty 'queue'.`
+      );
+    }
+    if (typeof userDef.concurrency !== "number" || userDef.concurrency <= 0) {
+      throw new Error(
+        `pool-config.loader: pool '${name}' must declare a positive 'concurrency'.`
+      );
+    }
+    if (userDef.reserved === true) {
+      throw new Error(
+        `pool-config.loader: user-defined pool '${name}' cannot set 'reserved: true' \u2014 reserved is framework-only.`
+      );
+    }
+    merged.set(name, {
+      queue: userDef.queue,
+      concurrency: userDef.concurrency,
+      reserved: false,
+      description: userDef.description
+    });
+  }
+  cache.set(resolved, merged);
+  return merged;
+}
+function extractUserPools(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const jobs2 = raw.jobs;
+  if (!jobs2 || typeof jobs2 !== "object") return {};
+  const pools = jobs2.pools;
+  if (!pools || typeof pools !== "object") return {};
+  const out = {};
+  for (const [name, def] of Object.entries(pools)) {
+    if (!def || typeof def !== "object") continue;
+    out[name] = def;
+  }
+  return out;
+}
+
+// runtime/subsystems/jobs/bullmq.config.ts
+var BULLMQ_CONNECTION = /* @__PURE__ */ Symbol("BULLMQ_CONNECTION");
+var BULLMQ_RESOLVED_CONFIG = /* @__PURE__ */ Symbol("BULLMQ_RESOLVED_CONFIG");
+function resolvePoolQueueName(pool, config, poolConfig = loadPoolConfig()) {
+  const alias = poolConfig.get(pool)?.queue ?? pool;
+  const prefix = config?.queuePrefix;
+  return prefix ? `${prefix}:${alias}` : alias;
+}
+
+// runtime/subsystems/jobs/job-orchestrator.bullmq-backend.ts
+function sha1JobId(idempotencyKey) {
+  return createHash("sha1").update(idempotencyKey).digest("hex");
+}
+var BullMQJobOrchestrator = class extends DrizzleJobOrchestrator {
+  constructor(db, multiTenant, connection, bullConfig = null) {
+    super(db, multiTenant);
+    this.connection = connection;
+    this.bullConfig = bullConfig;
+    this.bullDb = db;
+  }
+  connection;
+  bullConfig;
+  // TODO(logging-subsystem): swap to ILogger once ADR-028 lands
+  bullLogger = new Logger2(BullMQJobOrchestrator.name);
+  /** Lazily-opened `Queue` handles, one per pool. */
+  queues = /* @__PURE__ */ new Map();
+  /** Single FlowProducer for parent/child hierarchies. Lazily opened. */
+  _flow = null;
+  /**
+   * Cached `bullmq` value constructors, populated by `loadBullMq()` on first
+   * use (the `start`/`cancel`/`replay` entrypoints `await` it before touching
+   * a queue). Kept off the import graph so a `drizzle`-only consumer never
+   * resolves the optional `'bullmq'` package.
+   */
+  QueueCtor = null;
+  FlowProducerCtor = null;
+  bullMqLoad = null;
+  /**
+   * Own reference to the Drizzle client. `DrizzleJobOrchestrator.db` is
+   * `private` (can't be redeclared even privately in a subclass), and the
+   * spec forbids touching that file — so the subclass keeps its own handle
+   * under a distinct name (same instance, passed through to `super`) for the
+   * cancel-cascade snapshot + definition/run loads below.
+   */
+  bullDb;
+  /**
+   * Lazily load the optional `bullmq` package and cache its value
+   * constructors. Idempotent (single in-flight promise). Throws a friendly,
+   * actionable error when the consumer selected `backend: 'bullmq'` but did
+   * not install the package — mirrors `createRedisClient` in the redis event
+   * backend. Must be `await`ed before any `queueFor`/`flow` access.
+   */
+  async loadBullMq() {
+    if (this.QueueCtor && this.FlowProducerCtor) return;
+    if (!this.bullMqLoad) {
+      this.bullMqLoad = (async () => {
+        try {
+          const mod = await import("bullmq");
+          this.QueueCtor = mod.Queue;
+          this.FlowProducerCtor = mod.FlowProducer;
+        } catch {
+          throw new Error(
+            'BullMQ backend requires the "bullmq" package. Install it with: npm install bullmq'
+          );
+        }
+      })();
+    }
+    await this.bullMqLoad;
+  }
+  /**
+   * Open (or reuse) the `Queue` for a pool. Synchronous — callers `await
+   * loadBullMq()` first so `QueueCtor` is populated.
+   */
+  queueFor(pool) {
+    if (!this.QueueCtor) {
+      throw new Error("BullMQJobOrchestrator: queueFor called before loadBullMq()");
+    }
+    const name = resolvePoolQueueName(pool, this.bullConfig);
+    let q = this.queues.get(name);
+    if (!q) {
+      q = new this.QueueCtor(name, { connection: this.connection });
+      this.queues.set(name, q);
+    }
+    return q;
+  }
+  flow() {
+    if (!this.FlowProducerCtor) {
+      throw new Error("BullMQJobOrchestrator: flow called before loadBullMq()");
+    }
+    if (!this._flow) {
+      this._flow = new this.FlowProducerCtor({ connection: this.connection });
+    }
+    return this._flow;
+  }
+  // ==========================================================================
+  // start — Postgres insert (super) + BullMQ dispatch
+  // ==========================================================================
+  async start(type, input, opts = {}, tx) {
+    const run = await super.start(type, input, opts, tx);
+    await this.dispatch(run, type);
+    return run;
+  }
+  /**
+   * Map a `job_run` row onto a BullMQ job via `queue.add`. When the run has a
+   * `parentRunId` we attach it to the parent's existing BullMQ job through the
+   * `parent: { id, queue }` opt — BullMQ then tracks the parent/child link in
+   * its own graph. (The FlowProducer is reserved for whole-tree atomic
+   * submits, exposed as an opt-in extension via `flowProducer()`; runtime
+   * `ctx.spawnChild` is incremental, so `queue.add` with a parent ref is the
+   * correct primitive here.)
+   *
+   * The `jobId` is colon-safe + stable: `sha1(dedupeKey)` when a dedupe key is
+   * present (so the same logical key dedups), else the `job_run.id` UUID
+   * (already colon-free).
+   *
+   * The domain `parentClosePolicy` cascade is still enforced in Postgres by
+   * the shared `cancel` path — BullMQ's parent link is dispatch bookkeeping,
+   * not the authority.
+   */
+  async dispatch(run, type) {
+    await this.loadBullMq();
+    const def = await this.loadDefinition(type);
+    const jobId = run.dedupeKey ? sha1JobId(run.dedupeKey) : run.id;
+    const jobOpts = {
+      jobId,
+      ...this.retryOpts(def),
+      ...this.dedupeOpts(run, def)
+    };
+    if (run.parentRunId) {
+      const parentRow = await this.loadRun(run.parentRunId);
+      if (parentRow) {
+        const parentJobId = parentRow.dedupeKey ? sha1JobId(parentRow.dedupeKey) : parentRow.id;
+        jobOpts.parent = {
+          id: parentJobId,
+          queue: resolvePoolQueueName(parentRow.pool, this.bullConfig)
+        };
+      }
+    }
+    const payload = { runId: run.id, type, input: run.input };
+    await this.queueFor(run.pool).add(type, payload, jobOpts);
+  }
+  /**
+   * Opt-in extension (spec §Extensions): expose the FlowProducer for
+   * consumers that want to submit a whole parent/child DAG atomically up
+   * front, rather than incrementally via `ctx.spawnChild`. Backend-specific —
+   * code using it is not portable to the Drizzle backend. Async because it
+   * lazily loads the optional `bullmq` package on first use.
+   */
+  async flowProducer() {
+    await this.loadBullMq();
+    return this.flow();
+  }
+  retryOpts(def) {
+    const policy = def.retryPolicy;
+    if (!policy) return {};
+    return {
+      attempts: policy.attempts,
+      backoff: {
+        type: policy.backoff === "exponential" ? "exponential" : "fixed",
+        delay: policy.baseMs
+      }
+    };
+  }
+  dedupeOpts(run, def) {
+    if (!run.dedupeKey || !def.dedupeWindowMs) return {};
+    return {
+      deduplication: {
+        id: sha1JobId(run.dedupeKey),
+        ttl: def.dedupeWindowMs
+      }
+    };
+  }
+  // ==========================================================================
+  // cancel — Postgres cascade (super) + remove from queue
+  // ==========================================================================
+  async cancel(runId, opts = {}) {
+    const target = await this.loadRun(runId);
+    await super.cancel(runId, opts);
+    if (!target) return;
+    await this.loadBullMq();
+    await this.removeFromQueue(target);
+    if (opts.cascade === false) return;
+    const descendants = await this.bullDb.select().from(jobRuns).where(eq2(jobRuns.rootRunId, target.rootRunId));
+    for (const child of descendants) {
+      if (child.id === runId) continue;
+      await this.removeFromQueue(child);
+    }
+  }
+  async removeFromQueue(run) {
+    const jobId = run.dedupeKey ? sha1JobId(run.dedupeKey) : run.id;
+    try {
+      const job = await this.queueFor(run.pool).getJob(jobId);
+      if (job) await job.remove();
+    } catch (err) {
+      this.bullLogger.warn(
+        `cancel: could not remove BullMQ job ${jobId} (pool=${run.pool}): ${err.message}`
+      );
+    }
+  }
+  // ==========================================================================
+  // replay — Postgres reset (super) + re-enqueue
+  // ==========================================================================
+  async replay(runId) {
+    const run = await super.replay(runId);
+    await this.dispatch(run, run.jobType);
+    return run;
+  }
+  // ==========================================================================
+  // Internals
+  // ==========================================================================
+  async loadDefinition(type) {
+    const [def] = await this.bullDb.select().from(jobs).where(eq2(jobs.type, type)).limit(1);
+    if (!def) {
+      throw new Error(`BullMQJobOrchestrator: no job definition for '${type}'`);
+    }
+    return def;
+  }
+  async loadRun(id) {
+    const [row] = await this.bullDb.select().from(jobRuns).where(eq2(jobRuns.id, id)).limit(1);
+    return row ?? null;
+  }
+  /** Close all open queue + flow connections. Called on module destroy. */
+  async closeConnections() {
+    for (const q of this.queues.values()) {
+      await q.close().catch(() => void 0);
+    }
+    this.queues.clear();
+    if (this._flow) {
+      await this._flow.close().catch(() => void 0);
+      this._flow = null;
+    }
+  }
+};
+BullMQJobOrchestrator = __decorateClass([
+  Injectable2(),
+  __decorateParam(0, Inject2(DRIZZLE)),
+  __decorateParam(1, Inject2(JOBS_MULTI_TENANT)),
+  __decorateParam(2, Inject2(BULLMQ_CONNECTION)),
+  __decorateParam(3, Optional()),
+  __decorateParam(3, Inject2(BULLMQ_RESOLVED_CONFIG))
+], BullMQJobOrchestrator);
+export {
+  BullMQJobOrchestrator,
+  sha1JobId
+};
+//# sourceMappingURL=job-orchestrator.bullmq-backend.js.map