@dudousxd/nestjs-durable-core 0.60.0 → 0.62.0

package/dist/index.cjs

@@ -71,8 +71,11 @@ __export(index_exports, {
   collectMetrics: () => collectMetrics,
   controlPlaneDescriptor: () => controlPlaneDescriptor,
   createStepLogger: () => createStepLogger,
+  currentStep: () => currentStep,
   currentWorkflowCtx: () => currentWorkflowCtx,
+  debug: () => debug,
   descriptorHash: () => descriptorHash,
+  error: () => error,
   eventMatchOf: () => eventMatchOf,
   eventMatches: () => eventMatches,
   eventNameOf: () => eventNameOf,
@@ -80,9 +83,11 @@ __export(index_exports, {
   eventToken: () => eventToken,
   heartbeatStatus: () => heartbeatStatus,
   indexWaitersByRun: () => indexWaitersByRun,
+  info: () => info,
   isEventToken: () => isEventToken,
   isLegacyDescriptor: () => isLegacyDescriptor,
   isWorkflowControlFlowSignal: () => isWorkflowControlFlowSignal,
+  log: () => log,
   matchesAttributes: () => matchesAttributes,
   missingCapabilities: () => missingCapabilities,
   negotiate: () => negotiate,
@@ -95,6 +100,7 @@ __export(index_exports, {
   requiredCapabilities: () => requiredCapabilities,
   resolveRouting: () => resolveRouting,
   resolveRunWaiting: () => resolveRunWaiting,
+  runInStepLogger: () => runInStepLogger,
   runInWorkflowCtx: () => runInWorkflowCtx,
   runSchedules: () => runSchedules,
   runStepHandler: () => runStepHandler,
@@ -104,7 +110,11 @@ __export(index_exports, {
   stepConfigOf: () => stepConfigOf,
   stepId: () => stepId,
   stepNameOf: () => stepNameOf,
+  sub: () => sub,
+  subEvent: () => subEvent,
+  subProcess: () => subProcess,
   tenantGroup: () => tenantGroup,
+  warn: () => warn,
   workflowName: () => workflowName
 });
 module.exports = __toCommonJS(index_exports);
@@ -281,10 +291,68 @@ function currentWorkflowCtx() {
 }
 __name(currentWorkflowCtx, "currentWorkflowCtx");
 
+// src/ambient-step.ts
+var import_node_async_hooks2 = require("async_hooks");
+var STORAGE_KEY2 = Symbol.for("nestjs-durable:ambient-step-logger");
+var globalRef2 = globalThis;
+if (!globalRef2[STORAGE_KEY2]) {
+  globalRef2[STORAGE_KEY2] = new import_node_async_hooks2.AsyncLocalStorage();
+}
+var storage2 = globalRef2[STORAGE_KEY2];
+function runInStepLogger(logger, fn) {
+  return storage2.run(logger, fn);
+}
+__name(runInStepLogger, "runInStepLogger");
+function currentStep() {
+  return storage2.getStore();
+}
+__name(currentStep, "currentStep");
+function log(level, message, data) {
+  currentStep()?.[level](message, data);
+}
+__name(log, "log");
+function debug(message, data) {
+  currentStep()?.debug(message, data);
+}
+__name(debug, "debug");
+function info(message, data) {
+  currentStep()?.info(message, data);
+}
+__name(info, "info");
+function warn(message, data) {
+  currentStep()?.warn(message, data);
+}
+__name(warn, "warn");
+function error(message, data) {
+  currentStep()?.error(message, data);
+}
+__name(error, "error");
+function sub(name, status, message, data) {
+  currentStep()?.sub(name, status, message, data);
+}
+__name(sub, "sub");
+function subEvent(e) {
+  currentStep()?.subEvent(e);
+}
+__name(subEvent, "subEvent");
+var noopSubProcessHandle = {
+  phase: /* @__PURE__ */ __name(() => noopSubProcessHandle, "phase"),
+  skip: /* @__PURE__ */ __name(() => {
+  }, "skip"),
+  fail: /* @__PURE__ */ __name(() => {
+  }, "fail")
+};
+function subProcess(name, body, opts) {
+  const logger = currentStep();
+  if (!logger) return Promise.resolve(body(noopSubProcessHandle));
+  return logger.subProcess(name, body, opts);
+}
+__name(subProcess, "subProcess");
+
 // src/control-flow-signal.ts
 var CONTROL_FLOW_SIGNAL = Symbol.for("aviary:durable:control-flow");
-function isWorkflowControlFlowSignal(error) {
-  return typeof error === "object" && error !== null && error[CONTROL_FLOW_SIGNAL] === true;
+function isWorkflowControlFlowSignal(error2) {
+  return typeof error2 === "object" && error2 !== null && error2[CONTROL_FLOW_SIGNAL] === true;
 }
 __name(isWorkflowControlFlowSignal, "isWorkflowControlFlowSignal");
 
@@ -421,11 +489,11 @@ __name(workflowName, "workflowName");
 
 // src/durable-workflow.ts
 var BINDINGS_KEY = Symbol.for("nestjs-durable:workflow-class-bindings");
-var globalRef2 = globalThis;
-if (!globalRef2[BINDINGS_KEY]) {
-  globalRef2[BINDINGS_KEY] = /* @__PURE__ */ new WeakMap();
+var globalRef3 = globalThis;
+if (!globalRef3[BINDINGS_KEY]) {
+  globalRef3[BINDINGS_KEY] = /* @__PURE__ */ new WeakMap();
 }
-var bindings = globalRef2[BINDINGS_KEY];
+var bindings = globalRef3[BINDINGS_KEY];
 function bindWorkflowClass(ctor, client) {
   bindings.set(ctor, client);
 }
@@ -556,7 +624,7 @@ function createStepLogger(events, now) {
       data
     }
   }), "push");
-  const subEvent = /* @__PURE__ */ __name((e) => events.push({
+  const subEvent2 = /* @__PURE__ */ __name((e) => events.push({
     at: now(),
     level: e.status === "failed" ? "error" : e.status === "skipped" ? "warn" : "info",
     message: e.message ?? e.phase ?? e.name,
@@ -575,7 +643,7 @@ function createStepLogger(events, now) {
       data: e.data
     }
   }), "subEvent");
-  const subProcess = /* @__PURE__ */ __name(async (name, body, opts) => {
+  const subProcess2 = /* @__PURE__ */ __name(async (name, body, opts) => {
     const id = opts?.id ?? globalThis.crypto.randomUUID();
     const group = opts?.group;
     const start = now();
@@ -587,7 +655,7 @@ function createStepLogger(events, now) {
     const emit = /* @__PURE__ */ __name((status, message, data) => {
       if (terminal) return;
       terminal = true;
-      subEvent({
+      subEvent2({
         id,
         name,
         group,
@@ -598,7 +666,7 @@ function createStepLogger(events, now) {
     }, "emit");
     const handle = {
       phase: /* @__PURE__ */ __name((phase, data) => {
-        if (!terminal) subEvent({
+        if (!terminal) subEvent2({
           id,
           name,
           group,
@@ -636,8 +704,8 @@ function createStepLogger(events, now) {
         data
       }
     }), "sub"),
-    subEvent,
-    subProcess
+    subEvent: subEvent2,
+    subProcess: subProcess2
   };
 }
 __name(createStepLogger, "createStepLogger");
@@ -671,7 +739,8 @@ async function runStepHandler(task, handler) {
     events
   } : result, "withEvents");
   try {
-    const output = await handler(task.input, createStepLogger(events, Date.now));
+    const logger = createStepLogger(events, Date.now);
+    const output = await runInStepLogger(logger, () => handler(task.input, logger));
     return withEvents({
       ...base,
       status: "completed",
@@ -1721,7 +1790,10 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
           seq: current,
           attempt
         };
-        const body = /* @__PURE__ */ __name(() => fn(createStepLogger(events, host.clock)), "body");
+        const body = /* @__PURE__ */ __name(() => {
+          const logger = createStepLogger(events, host.clock);
+          return runInStepLogger(logger, () => fn(logger));
+        }, "body");
         const output = host.interceptStep ? await host.interceptStep(invocation, body) : await body();
         await host.completeStep({
           runId,
@@ -2324,6 +2396,10 @@ __name(mergeTags, "mergeTags");
 var BREAKPOINT = "breakpoint";
 var isBreakpoint = /* @__PURE__ */ __name((cp) => cp.status === "pending" && cp.name.startsWith(BREAKPOINT), "isBreakpoint");
 var versionKey = /* @__PURE__ */ __name((name, version) => `${name}@${version}`, "versionKey");
+function stepGroup(step, runNamespace) {
+  return tenantGroup(sanitizeQueueToken(step.name), step.partition ?? runNamespace);
+}
+__name(stepGroup, "stepGroup");
 function nextContinuationId(runId) {
   const m = runId.match(/^(.*)~(\d+)$/);
   return m ? `${m[1]}~${Number(m[2]) + 1}` : `${runId}~1`;
@@ -3023,13 +3099,13 @@ var WorkflowEngine = class {
       ];
       for (const run of inflight) {
         if (run.createdAt.getTime() > deadline) continue;
-        const error = {
+        const error2 = {
           message: "execution timeout",
           code: "execution_timeout"
         };
         await this.store.updateRun(run.id, {
           status: "cancelled",
-          error,
+          error: error2,
           updatedAt: /* @__PURE__ */ new Date()
         });
         this.emit({
@@ -3037,7 +3113,7 @@ var WorkflowEngine = class {
           runId: run.id,
           workflow: run.workflow,
           namespace: run.namespace,
-          error
+          error: error2
         });
       }
     }
@@ -3052,6 +3128,22 @@ var WorkflowEngine = class {
     for (const run of await this.store.listIncompleteRuns(this.namespace)) {
       const acquired = await this.store.tryLockRun(run.id, this.instanceId, nowMs + this.leaseMs, nowMs);
       if (!acquired) continue;
+      if (run.status === "running") {
+        const dispatched = await this.inFlightRemoteStep(run.id);
+        if (dispatched) {
+          await this.store.updateRun(run.id, {
+            status: "suspended",
+            wakeAt: this.reconcileWakeAt(dispatched.wakeAt ?? void 0),
+            updatedAt: /* @__PURE__ */ new Date()
+          });
+          await this.store.releaseRunLock(run.id);
+          results.push({
+            runId: run.id,
+            status: "suspended"
+          });
+          continue;
+        }
+      }
       const settled = await this.countRecovery(run);
       if (settled) {
         results.push(settled);
@@ -3073,6 +3165,16 @@ var WorkflowEngine = class {
     return results;
   }
   /**
+  * The remote step this run dispatched and is still awaiting a result for, if any — the signature
+  * that tells {@link recoverIncomplete} "this run's work is ON THE TRANSPORT, not in a crashed
+  * process". A `pending` remote checkpoint is written BEFORE the dispatch and settled by the
+  * worker's result, so its presence is the durable marker of an in-flight dispatched step.
+  */
+  async inFlightRemoteStep(runId) {
+    const checkpoints = await this.store.listCheckpoints(runId);
+    return checkpoints.find((cp) => cp.kind === "remote" && cp.status === "pending");
+  }
+  /**
   * Per-recovery bookkeeping (called once the lease is held): count the attempt, or — past
   * `maxRecoveryAttempts` — move a poison pill to the `dead` dead-letter state. Returns a terminal
   * result to skip the resume, or `undefined` to proceed.
@@ -3080,13 +3182,13 @@ var WorkflowEngine = class {
   async countRecovery(run) {
     const attempts = (run.recoveryAttempts ?? 0) + 1;
     if (this.maxRecoveryAttempts != null && attempts > this.maxRecoveryAttempts) {
-      const error = {
+      const error2 = {
         message: `run exceeded maxRecoveryAttempts (${this.maxRecoveryAttempts}) \u2014 moved to dead-letter`,
         code: "max_recovery_attempts"
       };
       await this.store.updateRun(run.id, {
         status: "dead",
-        error,
+        error: error2,
         updatedAt: /* @__PURE__ */ new Date()
       });
       await this.store.releaseRunLock(run.id);
@@ -3095,18 +3197,18 @@ var WorkflowEngine = class {
         runId: run.id,
         workflow: run.workflow,
         namespace: run.namespace,
-        error
+        error: error2
       });
       this.notifyDead({
         ...run,
         status: "dead",
-        error,
+        error: error2,
         recoveryAttempts: attempts
       });
       return {
         runId: run.id,
         status: "dead",
-        error
+        error: error2
       };
     }
     await this.store.updateRun(run.id, {
@@ -3227,7 +3329,8 @@ var WorkflowEngine = class {
     seen.add(runId);
     const run = await this.store.getRun(runId);
     if (!run) return null;
-    if (run.status === "failed" || run.status === "dead") {
+    const resurrecting = run.status === "failed" || run.status === "dead";
+    if (resurrecting) {
       const isFailureCompletion = /* @__PURE__ */ __name((v) => typeof v === "object" && v !== null && v.ok === false, "isFailureCompletion");
       for (const cp of await this.store.listCheckpoints(runId)) {
         if (cp.status === "failed") {
@@ -3270,6 +3373,9 @@ var WorkflowEngine = class {
     await this.store.updateRun(runId, {
       status: "pending",
       error: void 0,
+      ...resurrecting ? {
+        recoveryAttempts: 0
+      } : {},
       updatedAt: /* @__PURE__ */ new Date()
     });
     await this.runDispatcher.dispatch(runId);
@@ -3282,9 +3388,11 @@ var WorkflowEngine = class {
   * Explicitly re-dispatch every remote step of `runId` stuck `pending` — the OPERATOR escape hatch for
   * a run whose dispatched step job was LOST (worker crashed with no result, or a transport that dropped
   * the job). No automatic recovery re-drives these: a reconcile re-drive re-suspends a still-pending
-  * step by design (unless `remoteRedispatchMs` is set), `recoverIncomplete` only reclaims LEASED runs,
-  * and `requeue` just replays back to the pending guard. This re-enqueues the same `stepId` so the
-  * (idempotent) step re-runs and its result resumes the run. Safe to call on a healthy run — it re-runs
+  * step by design (unless `remoteRedispatchMs` is set), `recoverIncomplete` explicitly SKIPS a run with
+  * an in-flight `pending` remote step (it re-asserts the durably-suspended invariant instead of counting
+  * a recovery attempt — see there), and `requeue` just replays back to the pending guard. This
+  * re-enqueues the same `stepId` so the (idempotent) step re-runs and its result resumes the run.
+  * Safe to call on a healthy run — it re-runs
   * only in-flight `pending` remote steps, which are idempotent by the durable contract. Returns the
   * run's current status (with the count re-dispatched), or null if the run is unknown.
   */
@@ -3576,10 +3684,10 @@ var WorkflowEngine = class {
     });
   }
   /** Report that a `ctx.task` failed — the run resumes and throws a FatalError at the task. */
-  async failTask(runId, name, error) {
+  async failTask(runId, name, error2) {
     return this.signal(`task:${runId}:${name}`, {
       ok: false,
-      error
+      error: error2
     });
   }
   /**
@@ -3661,12 +3769,12 @@ var WorkflowEngine = class {
         status: "cancelling"
       };
     }
-    const error = {
+    const error2 = {
       message: "cancelled"
     };
     await this.store.updateRun(runId, {
       status: "cancelled",
-      error,
+      error: error2,
       updatedAt: /* @__PURE__ */ new Date()
     });
     this.emit({
@@ -3674,7 +3782,7 @@ var WorkflowEngine = class {
       runId,
       workflow: run.workflow,
       namespace: run.namespace,
-      error
+      error: error2
     });
     await this.cancelChildren(runId, opts);
     this.notifyCancelled(runId);
@@ -3689,7 +3797,7 @@ var WorkflowEngine = class {
     return {
       runId,
       status: "cancelled",
-      error
+      error: error2
     };
   }
   /**
@@ -3792,7 +3900,8 @@ var WorkflowEngine = class {
   async workerHealth(extra = []) {
     const groups = /* @__PURE__ */ new Set([
       ...this.knownGroups(extra),
-      ...await this.pool.listWorkerGroups()
+      ...await this.pool.listWorkerGroups(),
+      ...await this.inflightStepGroups()
     ]);
     const workflowTokens = /* @__PURE__ */ new Set();
     for (const def of this.workflows.values()) {
@@ -3813,6 +3922,38 @@ var WorkflowEngine = class {
     return out;
   }
   /**
+  * The routing groups of every in-flight run's still-`pending` remote step — the queues where work is
+  * dispatched and awaiting a worker. Folded into {@link workerHealth} so a step waiting on a group
+  * that is NEITHER a registration NOR heartbeating (the exact shape of a run stuck on an offline
+  * tenant pool) still reports its backlog: without this the health scan can't "see" that queue, and
+  * the dashboard shows the run as running instead of no-worker. Only the BullMQ transport introspects
+  * health, so on any other transport this is harmless (the groups just resolve to no `groupHealth`).
+  *
+  * Cost: one `listRuns` over the non-terminal runs plus a checkpoint read each — a diagnostic-path
+  * scan, not a hot path. Scoped to `running`/`suspended`/`blocked` (a `pending` run has dispatched no
+  * step yet) and deduped to distinct groups.
+  */
+  async inflightStepGroups() {
+    const inflight = await this.store.listRuns({
+      statuses: [
+        "running",
+        "suspended",
+        "blocked"
+      ]
+    });
+    const groups = /* @__PURE__ */ new Set();
+    for (const run of inflight) {
+      for (const cp of await this.store.listCheckpoints(run.id)) {
+        if (cp.kind === "remote" && cp.status === "pending" && cp.workerGroup) {
+          groups.add(cp.workerGroup);
+        }
+      }
+    }
+    return [
+      ...groups
+    ];
+  }
+  /**
   * Persist a streamed local-step lifecycle event from a remote workflow worker (see
   * {@link WorkflowStepEvent}). A Python `@workflow` runs its `ctx.step`s inline over one turn that
   * can last minutes; the worker streams each step's start/finish so the engine checkpoints it LIVE —
@@ -4084,12 +4225,12 @@ var WorkflowEngine = class {
   }
   async runRemoteExecution(run, registered) {
     if (run.status === "cancelling") {
-      const error = {
+      const error2 = {
         message: "cancelled"
       };
       await this.store.updateRun(run.id, {
         status: "cancelled",
-        error,
+        error: error2,
         updatedAt: /* @__PURE__ */ new Date()
       });
       this.emit({
@@ -4097,7 +4238,7 @@ var WorkflowEngine = class {
         runId: run.id,
         workflow: run.workflow,
         namespace: run.namespace,
-        error
+        error: error2
       });
       this.notifyCancelled(run.id);
       if (this.controlPlane) {
@@ -4111,7 +4252,7 @@ var WorkflowEngine = class {
       return {
         runId: run.id,
         status: "cancelled",
-        error
+        error: error2
       };
     }
     const remote = registered.remote;
@@ -4190,13 +4331,13 @@ var WorkflowEngine = class {
           status: "running"
         };
       }
-      const error = {
+      const error2 = {
         message: err instanceof Error ? err.message : String(err),
         stack: err instanceof Error ? err.stack : void 0
       };
       await this.store.updateRun(run.id, {
         status: "failed",
-        error,
+        error: error2,
         updatedAt: /* @__PURE__ */ new Date()
       });
       this.emit({
@@ -4204,12 +4345,12 @@ var WorkflowEngine = class {
         runId: run.id,
         workflow: run.workflow,
         namespace: run.namespace,
-        error
+        error: error2
       });
       return {
         runId: run.id,
         status: "failed",
-        error
+        error: error2
       };
     }
     return this.applyDecision(run, decision);
@@ -4474,12 +4615,12 @@ var WorkflowEngine = class {
       status: "cancelling"
     };
     this.cancelRequested.delete(run.id);
-    const error = {
+    const error2 = {
       message: "cancelled"
     };
     await this.store.updateRun(run.id, {
       status: "cancelled",
-      error,
+      error: error2,
       updatedAt: /* @__PURE__ */ new Date()
     });
     this.emit({
@@ -4487,12 +4628,12 @@ var WorkflowEngine = class {
       runId: run.id,
       workflow: run.workflow,
       namespace: run.namespace,
-      error
+      error: error2
     });
     return {
       runId: run.id,
       status: "cancelled",
-      error
+      error: error2
     };
   }
   /** The run body, lease held + renewed by {@link execute}. */
@@ -4593,7 +4734,7 @@ var WorkflowEngine = class {
       if (this.cancelRequested.has(run.id)) {
         return this.compensateAndCancel(run, compensations, replay);
       }
-      const error = {
+      const error2 = {
         message: err instanceof Error ? err.message : String(err),
         stack: err instanceof Error ? err.stack : void 0
       };
@@ -4604,7 +4745,7 @@ var WorkflowEngine = class {
       });
       return this.settleRun(run, {
         kind: "failed",
-        error
+        error: error2
       });
     } finally {
       await this.store.releaseRunLock(run.id);
@@ -4693,7 +4834,7 @@ var WorkflowEngine = class {
         return;
       } catch (err) {
         if (attempt >= this.compensationRetries) {
-          const error = {
+          const error2 = {
             message: err instanceof Error ? err.message : String(err)
           };
           this.emit({
@@ -4702,7 +4843,7 @@ var WorkflowEngine = class {
             workflow: run.workflow,
             name,
             kind: "local",
-            error,
+            error: error2,
             durationMs: Date.now() - startedAt.getTime()
           });
           const cp = stepCheckpoint({
@@ -4712,7 +4853,7 @@ var WorkflowEngine = class {
             kind: "local",
             status: "failed",
             attempts: attempt,
-            error,
+            error: error2,
             enqueuedAt,
             startedAt,
             finishedAt: /* @__PURE__ */ new Date()
@@ -4776,7 +4917,7 @@ var WorkflowEngine = class {
   */
   async dispatchCompensationAttempt(run, seq, name, def, args, attempt, replay) {
     if (this.pool.size === 0) throw new Error("remote steps require a Transport");
-    const group = tenantGroup(sanitizeQueueToken(def.name), def.partition);
+    const group = stepGroup(def, run.namespace);
     const enqueuedAt = /* @__PURE__ */ new Date();
     const cp = stepCheckpoint({
       runId: run.id,
@@ -4824,7 +4965,12 @@ var WorkflowEngine = class {
       startStep: /* @__PURE__ */ __name((s) => this.startStep(s), "startStep"),
       completeStep: /* @__PURE__ */ __name((s) => this.completeStep(s), "completeStep"),
       failStep: /* @__PURE__ */ __name((s) => this.failStep(s), "failStep"),
-      callRemote: /* @__PURE__ */ __name((runId, seq, step, input, queue, transport, admission) => this.callRemote(runId, seq, step, input, queue, transport, replay, admission), "callRemote"),
+      // Route the dispatch by the RUN's tenant (same reason as `startChild` below): the executing
+      // engine may be an operator driving every namespace, so the token must come from the run, not
+      // from this engine. See {@link stepGroup}.
+      callRemote: /* @__PURE__ */ __name((runId, seq, step, input, queue, transport, admission) => this.callRemote(runId, seq, step, input, queue, transport, replay, admission, {
+        namespace: parentNamespace
+      }), "callRemote"),
       // Defer so a fast child can't reentrantly resume a still-running parent. Stamp the child with
       // the PARENT run's namespace (not this engine's) so a child belongs to the tenant/partition of
       // the run it was spawned from — even when an operator (namespace: undefined, drives every
@@ -4968,14 +5114,14 @@ var WorkflowEngine = class {
         error: current.error
       };
     }
-    const error = {
+    const error2 = {
       message: blocked.reason,
       code: blocked.code,
       retryable: true
     };
     await this.store.updateRun(run.id, {
       status: "blocked",
-      error,
+      error: error2,
       wakeAt: this.clock() + this.blockedPollMs,
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -4984,7 +5130,7 @@ var WorkflowEngine = class {
       runId: run.id,
       workflow: run.workflow,
       namespace: run.namespace,
-      error,
+      error: error2,
       requires: blocked.requires,
       diagnostics: blocked.diagnostics
     });
@@ -4992,7 +5138,7 @@ var WorkflowEngine = class {
     return {
       runId: run.id,
       status: "blocked",
-      error
+      error: error2
     };
   }
   /** Runs parked `blocked` whose recovery poll is due (`wakeAt <= nowMs`), namespace-scoped like
@@ -5006,14 +5152,15 @@ var WorkflowEngine = class {
     });
     return blocked.filter((r) => (this.namespace === void 0 || r.namespace === void 0 || r.namespace === this.namespace) && r.wakeAt !== void 0 && r.wakeAt <= nowMs);
   }
-  async callRemote(runId, seq, step, input, queue, transport, replay, admission) {
+  async callRemote(runId, seq, step, input, queue, transport, replay, admission, routing) {
+    const group = stepGroup(step, routing?.namespace);
     const existing = replay?.get(seq) ?? await this.store.getCheckpoint(runId, seq);
     if (existing && existing.name !== step.name) {
       throw new NonDeterminismError(runId, seq, step.name, existing.name);
     }
     if (existing?.status === "completed") return existing.output;
     if (this.pool.size === 0) throw new Error("remote steps require a Transport");
-    if (step.timeoutMs) return this.callRemoteInMemory(runId, seq, step, input, transport);
+    if (step.timeoutMs) return this.callRemoteInMemory(runId, seq, step, input, transport, group);
     if (existing?.status === "pending") {
       if (this.remoteRedispatchMs == null) throw new WorkflowSuspended();
       if (existing.wakeAt == null) {
@@ -5047,7 +5194,7 @@ var WorkflowEngine = class {
         seq,
         name: step.name,
         stepId: existing.stepId ?? stepId(runId, seq),
-        group: existing.workerGroup ?? tenantGroup(sanitizeQueueToken(step.name), step.partition),
+        group: existing.workerGroup ?? group,
         input: existing.input,
         priority: admission?.priority,
         attempt: reAttempt,
@@ -5071,7 +5218,7 @@ var WorkflowEngine = class {
       if (this.clock() < existing.wakeAt) throw new WorkflowSuspended(existing.wakeAt);
       attempt = existing.attempts + 1;
     }
-    await this.ensureRoutable(tenantGroup(sanitizeQueueToken(step.name), step.partition), step.requires);
+    await this.ensureRoutable(group, step.requires);
     const id = stepId(runId, seq);
     if (queue && this.admission.handles(queue)) {
       const decision = await this.admission.tryAdmit(queue, {
@@ -5098,7 +5245,7 @@ var WorkflowEngine = class {
       status: "pending",
       input,
       attempts: attempt,
-      workerGroup: tenantGroup(sanitizeQueueToken(step.name), step.partition),
+      workerGroup: group,
       enqueuedAt,
       startedAt: enqueuedAt,
       finishedAt: enqueuedAt
@@ -5108,7 +5255,7 @@ var WorkflowEngine = class {
       seq,
       name: step.name,
       stepId: id,
-      group: tenantGroup(sanitizeQueueToken(step.name), step.partition),
+      group,
       input,
       priority: admission?.priority,
       attempt,
@@ -5256,9 +5403,9 @@ var WorkflowEngine = class {
     await this.admission.release(queue, id);
   }
   /** In-memory await path for a remote step with a liveness `timeoutMs` (re-dispatch on timeout). */
-  async callRemoteInMemory(runId, seq, step, input, transport) {
+  async callRemoteInMemory(runId, seq, step, input, transport, group = stepGroup(step, void 0)) {
     if (this.pool.size === 0) throw new Error("remote steps require a Transport");
-    await this.ensureRoutable(tenantGroup(sanitizeQueueToken(step.name), step.partition), step.requires);
+    await this.ensureRoutable(group, step.requires);
     const validInput = step.input ? step.input.parse(input) : input;
     const id = stepId(runId, seq);
     const enqueuedAt = /* @__PURE__ */ new Date();
@@ -5282,7 +5429,7 @@ var WorkflowEngine = class {
         seq,
         name: step.name,
         stepId: id,
-        group: tenantGroup(sanitizeQueueToken(step.name), step.partition),
+        group,
         input: validInput,
         traceparent: this.traceparent?.(),
         context: this.context?.(),
@@ -5301,7 +5448,7 @@ var WorkflowEngine = class {
           output,
           events: resolution.events,
           attempts: attempt,
-          workerGroup: tenantGroup(sanitizeQueueToken(step.name), step.partition),
+          workerGroup: group,
           enqueuedAt,
           startedAt
         });
@@ -6213,8 +6360,11 @@ var InMemoryTransport = class {
   collectMetrics,
   controlPlaneDescriptor,
   createStepLogger,
+  currentStep,
   currentWorkflowCtx,
+  debug,
   descriptorHash,
+  error,
   eventMatchOf,
   eventMatches,
   eventNameOf,
@@ -6222,9 +6372,11 @@ var InMemoryTransport = class {
   eventToken,
   heartbeatStatus,
   indexWaitersByRun,
+  info,
   isEventToken,
   isLegacyDescriptor,
   isWorkflowControlFlowSignal,
+  log,
   matchesAttributes,
   missingCapabilities,
   negotiate,
@@ -6237,6 +6389,7 @@ var InMemoryTransport = class {
   requiredCapabilities,
   resolveRouting,
   resolveRunWaiting,
+  runInStepLogger,
   runInWorkflowCtx,
   runSchedules,
   runStepHandler,
@@ -6246,7 +6399,11 @@ var InMemoryTransport = class {
   stepConfigOf,
   stepId,
   stepNameOf,
+  sub,
+  subEvent,
+  subProcess,
   tenantGroup,
+  warn,
   workflowName
 });
 //# sourceMappingURL=index.cjs.map