@pattern-stack/codegen 0.15.1 → 0.15.3

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

@@ -1,696 +1,33 @@
-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/token-key.ts
-var PKG = "@pattern-stack/codegen";
-var tokenKey = (area, name) => `${PKG}.${area}.${name}`;
-
-// 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
-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 = Symbol.for(tokenKey("jobs", "bullmq-connection"));
-var BULLMQ_RESOLVED_CONFIG = Symbol.for(tokenKey("jobs", "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;
-}
+  BULLMQ_CONNECTION,
+  BULLMQ_RESOLVED_CONFIG,
+  resolvePoolQueueName
+} from "../../../chunk-I6MVCB5A.js";
+import "../../../chunk-RHVN6NA7.js";
+import {
+  DrizzleJobOrchestrator
+} from "../../../chunk-5Y7W3XR6.js";
+import "../../../chunk-T4BIIU5E.js";
+import {
+  JOBS_MULTI_TENANT
+} from "../../../chunk-BIO6F7YI.js";
+import {
+  jobRuns,
+  jobs
+} from "../../../chunk-OKXZ63IA.js";
+import "../../../chunk-GYGNEQSC.js";
+import {
+  DRIZZLE
+} from "../../../chunk-U64T4YZE.js";
+import {
+  __decorateClass,
+  __decorateParam
+} from "../../../chunk-2E224ZSN.js";
 
 // runtime/subsystems/jobs/job-orchestrator.bullmq-backend.ts
+import { createHash } from "crypto";
+import { Inject, Injectable, Logger, Optional } from "@nestjs/common";
+import { eq } from "drizzle-orm";
 function sha1JobId(idempotencyKey) {
   return createHash("sha1").update(idempotencyKey).digest("hex");
 }
@@ -704,7 +41,7 @@ var BullMQJobOrchestrator = class extends DrizzleJobOrchestrator {
   connection;
   bullConfig;
   // TODO(logging-subsystem): swap to ILogger once ADR-028 lands
-  bullLogger = new Logger2(BullMQJobOrchestrator.name);
+  bullLogger = new Logger(BullMQJobOrchestrator.name);
   /** Lazily-opened `Queue` handles, one per pool. */
   queues = /* @__PURE__ */ new Map();
   /** Single FlowProducer for parent/child hierarchies. Lazily opened. */
@@ -863,7 +200,7 @@ var BullMQJobOrchestrator = class extends DrizzleJobOrchestrator {
     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));
+    const descendants = await this.bullDb.select().from(jobRuns).where(eq(jobRuns.rootRunId, target.rootRunId));
     for (const child of descendants) {
       if (child.id === runId) continue;
       await this.removeFromQueue(child);
@@ -892,14 +229,14 @@ var BullMQJobOrchestrator = class extends DrizzleJobOrchestrator {
   // Internals
   // ==========================================================================
   async loadDefinition(type) {
-    const [def] = await this.bullDb.select().from(jobs).where(eq2(jobs.type, type)).limit(1);
+    const [def] = await this.bullDb.select().from(jobs).where(eq(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);
+    const [row] = await this.bullDb.select().from(jobRuns).where(eq(jobRuns.id, id)).limit(1);
     return row ?? null;
   }
   /** Close all open queue + flow connections. Called on module destroy. */
@@ -915,12 +252,12 @@ var BullMQJobOrchestrator = class extends DrizzleJobOrchestrator {
   }
 };
 BullMQJobOrchestrator = __decorateClass([
-  Injectable2(),
-  __decorateParam(0, Inject2(DRIZZLE)),
-  __decorateParam(1, Inject2(JOBS_MULTI_TENANT)),
-  __decorateParam(2, Inject2(BULLMQ_CONNECTION)),
+  Injectable(),
+  __decorateParam(0, Inject(DRIZZLE)),
+  __decorateParam(1, Inject(JOBS_MULTI_TENANT)),
+  __decorateParam(2, Inject(BULLMQ_CONNECTION)),
   __decorateParam(3, Optional()),
-  __decorateParam(3, Inject2(BULLMQ_RESOLVED_CONFIG))
+  __decorateParam(3, Inject(BULLMQ_RESOLVED_CONFIG))
 ], BullMQJobOrchestrator);
 export {
   BullMQJobOrchestrator,