@pattern-stack/codegen 0.15.0 → 0.15.2

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

@@ -1,827 +1,13 @@
-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 = (index, decorator) => (target, key) => decorator(target, key, index);
-
-// runtime/subsystems/jobs/job-orchestrator.memory-backend.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { Inject as Inject2, Injectable as Injectable2, Logger, Optional } from "@nestjs/common";
-import { ModuleRef } from "@nestjs/core";
-
-// runtime/subsystems/token-key.ts
-var PKG = "@pattern-stack/codegen";
-var tokenKey = (area, name) => `${PKG}.${area}.${name}`;
-
-// 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-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/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 } from "crypto";
-import { Inject, Injectable } 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: randomUUID(),
-      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([
-  Injectable(),
-  __decorateParam(0, Inject(MemoryJobStore))
-], MemoryJobStepService);
-
-// 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.memory-backend.ts
-var QUEUED_RUN_AT = /* @__PURE__ */ new Date(864e13);
-var TERMINAL_STATUSES = [
-  "completed",
-  "failed",
-  "timed_out",
-  "canceled"
-];
-var DEDUPE_EXCLUDED_STATUSES = ["canceled", "failed"];
-var IN_FLIGHT_STATUSES = ["pending", "running"];
-function isTerminal(status) {
-  return TERMINAL_STATUSES.includes(status);
-}
-function evaluateKeyTemplate(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 Logger(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 = evaluateKeyTemplate(
-          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 = evaluateKeyTemplate(
-          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 = randomUUID2();
-      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 ? evaluateKeyTemplate(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 Logger(`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_STATUSES.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_STATUSES.includes(r.status)) continue;
-      return r;
-    }
-    return null;
-  }
-};
-MemoryJobOrchestrator = __decorateClass([
-  Injectable2(),
-  __decorateParam(0, Inject2(MemoryJobStore)),
-  __decorateParam(1, Inject2(MemoryJobStepService)),
-  __decorateParam(2, Inject2(JOBS_MULTI_TENANT)),
-  __decorateParam(3, Optional()),
-  __decorateParam(3, Inject2(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
-  };
-}
+import {
+  MemoryJobOrchestrator
+} from "../../../chunk-4RFHUZXU.js";
+import "../../../chunk-PNZSGAB2.js";
+import "../../../chunk-SNQ3TOWP.js";
+import "../../../chunk-T4BIIU5E.js";
+import "../../../chunk-CO6LUM72.js";
+import "../../../chunk-BIO6F7YI.js";
+import "../../../chunk-GYGNEQSC.js";
+import "../../../chunk-2E224ZSN.js";
 export {
   MemoryJobOrchestrator
 };