@dudousxd/nestjs-durable-core 0.45.0 → 0.46.1

package/dist/index.js

@@ -574,7 +574,7 @@ var Entities = class {
     let state = config.initialState();
     for (let i = 0; ; i += 1) {
       const msg = await ctx.waitForSignal(token);
-      const out = await ctx.step(`op:${i}`, async () => {
+      const out = await ctx.localStep(`op:${i}`, async () => {
         const handler = config.handlers[msg.op];
         if (!handler) throw new FatalError(`entity "${name}" has no handler for op "${msg.op}"`);
         const result = await handler(state, msg.arg);
@@ -586,7 +586,7 @@ var Entities = class {
       state = out.state;
       await ctx.setEvent("state", state);
       if (msg.reply) {
-        await ctx.step(`reply:${i}`, async () => {
+        await ctx.localStep(`reply:${i}`, async () => {
           await this.host.signal(msg.reply, out.result);
         });
       }
@@ -700,16 +700,28 @@ function eventMatches(payload, match) {
 }
 __name(eventMatches, "eventMatches");
 
+// src/tenant-group.ts
+function tenantGroup(baseGroup, tenant) {
+  return tenant !== void 0 && tenant !== "" && tenant !== "default" ? `${baseGroup}@${tenant}` : baseGroup;
+}
+__name(tenantGroup, "tenantGroup");
+function sanitizeQueueToken(name) {
+  return name.replace(/:/g, "-");
+}
+__name(sanitizeQueueToken, "sanitizeQueueToken");
+
 // src/remote-workflow-executor.ts
 var RemoteWorkflowExecutor = class {
   static {
     __name(this, "RemoteWorkflowExecutor");
   }
   transport;
-  group;
-  constructor(transport, group, _opts = {}) {
+  name;
+  partition;
+  constructor(transport, name, partition, _opts = {}) {
     this.transport = transport;
-    this.group = group;
+    this.name = name;
+    this.partition = partition;
   }
   /**
   * Enqueue one workflow turn under the engine-supplied `taskId`. Does NOT await the decision — the
@@ -729,7 +741,7 @@ var RemoteWorkflowExecutor = class {
       ...pendingSignals ? {
         pendingSignals
       } : {},
-      group: this.group,
+      group: tenantGroup(sanitizeQueueToken(this.name), this.partition),
       priority: run.priority,
       attempt: 1
     };
@@ -901,6 +913,16 @@ var TransportPool = class {
       liveWorkers: reports.flatMap((r) => r.liveWorkers)
     };
   }
+  /**
+  * Register a control-plane `start-run` consumer on every transport that carries the channel. Only
+  * control-plane-side transports implement {@link Transport.onStartRun}; a transport without it is
+  * skipped, so a plain worker/in-process pool is a no-op. Mirrors {@link bind}'s per-transport wiring.
+  */
+  onStartRun(handler) {
+    for (const { transport } of this.transports) {
+      transport.onStartRun?.(handler);
+    }
+  }
   /** Distinct worker groups with a live heartbeat, merged across every transport that can report it. */
   async listWorkerGroups() {
     const groups = /* @__PURE__ */ new Set();
@@ -946,6 +968,26 @@ function unwrapCompletion(payload, label) {
 }
 __name(unwrapCompletion, "unwrapCompletion");
 
+// src/step-name-symbol.ts
+var DURABLE_STEP_NAME = Symbol.for("durable.step.name");
+var DURABLE_STEP_CONFIG = Symbol.for("durable.step.config");
+function isStepConfig(value) {
+  return typeof value === "object" && value !== null;
+}
+__name(isStepConfig, "isStepConfig");
+function stepNameOf(ref) {
+  if (typeof ref !== "function") return void 0;
+  const stamped = ref[DURABLE_STEP_NAME];
+  return typeof stamped === "string" ? stamped : void 0;
+}
+__name(stepNameOf, "stepNameOf");
+function stepConfigOf(ref) {
+  if (typeof ref !== "function") return void 0;
+  const stamped = ref[DURABLE_STEP_CONFIG];
+  return isStepConfig(stamped) ? stamped : void 0;
+}
+__name(stepConfigOf, "stepConfigOf");
+
 // src/workflow-ref.ts
 var WORKFLOW_NAME_KEY = Symbol.for("nestjs-durable:workflow-name");
 function workflowName(ref) {
@@ -965,6 +1007,23 @@ function normalizeChildOptions(options) {
   } : options ?? {};
 }
 __name(normalizeChildOptions, "normalizeChildOptions");
+function resolveStepPolicy(config, opts) {
+  const policy = {};
+  const retries = opts?.retries ?? config?.retries;
+  if (retries !== void 0) policy.retries = retries;
+  const backoff = opts?.backoff ?? config?.backoff;
+  if (backoff !== void 0) policy.backoff = backoff;
+  const backoffMs = opts?.backoffMs ?? config?.backoffMs;
+  if (backoffMs !== void 0) policy.backoffMs = backoffMs;
+  const backoffMaxMs = opts?.backoffMaxMs ?? config?.backoffMaxMs;
+  if (backoffMaxMs !== void 0) policy.backoffMaxMs = backoffMaxMs;
+  const jitter = opts?.jitter ?? config?.jitter;
+  if (jitter !== void 0) policy.jitter = jitter;
+  const timeoutMs = opts?.timeoutMs ?? config?.timeoutMs;
+  if (timeoutMs !== void 0) policy.timeoutMs = timeoutMs;
+  return policy;
+}
+__name(resolveStepPolicy, "resolveStepPolicy");
 var Position = class Position2 {
   static {
     __name(this, "Position");
@@ -990,7 +1049,7 @@ function createWorkflowCtx(host, runId, compensations, workflow = "") {
     await store.saveCheckpoint(cp);
     replay?.set(cp.seq, cp);
   }, "writeCheckpoint");
-  const step = /* @__PURE__ */ __name(async (name, fn, options) => {
+  const localStep = /* @__PURE__ */ __name(async (name, fn, options) => {
     const current = pos.next();
     const existing = await readCheckpoint(current);
     if (existing && existing.name !== name) {
@@ -1064,7 +1123,7 @@ function createWorkflowCtx(host, runId, compensations, workflow = "") {
         if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
       }
     }
-  }, "step");
+  }, "localStep");
   const transaction = /* @__PURE__ */ __name(async (name, fn) => {
     if (!store.transaction) {
       throw new Error("ctx.transaction needs a store that supports transactions (the SQL adapters do). Use ctx.step for non-transactional work.");
@@ -1211,7 +1270,7 @@ function createWorkflowCtx(host, runId, compensations, workflow = "") {
     throw new WorkflowSuspended(deadline);
   }, "waitForEvent");
   const task = /* @__PURE__ */ __name(async (name, dispatch, options) => {
-    await step(`task:dispatch:${name}`, dispatch, options);
+    await localStep(`task:dispatch:${name}`, dispatch, options);
     return unwrapCompletion(await waitForSignal(`task:${runId}:${name}`), `task "${name}"`);
   }, "task");
   const child = /* @__PURE__ */ __name(async (workflow2, input, options) => {
@@ -1424,9 +1483,8 @@ function createWorkflowCtx(host, runId, compensations, workflow = "") {
       wait
     };
   }, "webhook");
-  const now = /* @__PURE__ */ __name(() => step("now", async () => host.clock()), "now");
-  const random = /* @__PURE__ */ __name(() => step("random", async () => Math.random()), "random");
-  const uuid = /* @__PURE__ */ __name(() => step("uuid", async () => globalThis.crypto.randomUUID()), "uuid");
+  const sideEffect = /* @__PURE__ */ __name((fn) => localStep("sideEffect", async () => fn()), "sideEffect");
+  const now = /* @__PURE__ */ __name(() => localStep("now", async () => host.clock()), "now");
   const upsertSearchAttributes = /* @__PURE__ */ __name(async (attrs) => {
     const current = pos.next();
     const existing = await readCheckpoint(current);
@@ -1445,9 +1503,26 @@ function createWorkflowCtx(host, runId, compensations, workflow = "") {
       output: attrs
     }));
   }, "upsertSearchAttributes");
+  function step(handlerOrName, input, opts) {
+    const name = typeof handlerOrName === "string" ? handlerOrName : stepNameOf(handlerOrName);
+    if (name === void 0) {
+      throw new Error("ctx.step: handler is not a @Step reference (no stamped step name) \u2014 pass a @Step-decorated method or a step name string");
+    }
+    const config = typeof handlerOrName === "string" ? void 0 : stepConfigOf(handlerOrName);
+    const def = {
+      name,
+      ...resolveStepPolicy(config, opts)
+    };
+    return host.callRemote(runId, pos.next(), def, input, opts?.queue, opts?.transport, {
+      priority: opts?.priority,
+      fairnessKey: opts?.fairnessKey
+    });
+  }
+  __name(step, "step");
   return {
     runId,
     step,
+    localStep,
     upsertSearchAttributes,
     transaction,
     callEntity,
@@ -1467,12 +1542,7 @@ function createWorkflowCtx(host, runId, compensations, workflow = "") {
     onUpdate,
     patched,
     now,
-    random,
-    uuid,
-    call: /* @__PURE__ */ __name((remote, input, opts) => host.callRemote(runId, pos.next(), remote, input, opts?.queue, opts?.transport, {
-      priority: opts?.priority,
-      fairnessKey: opts?.fairnessKey
-    }), "call")
+    sideEffect
   };
 }
 __name(createWorkflowCtx, "createWorkflowCtx");
@@ -1590,8 +1660,10 @@ var WorkflowEngine = class {
     this.admission = deps.admission ?? new InMemoryAdmissionBackend(this.clock);
     this.admission.onFreed?.((queue) => this.wakeQueueWaiters(queue));
     this.instanceId = deps.instanceId ?? globalThis.crypto.randomUUID();
-    this.namespace = deps.namespace ?? "default";
-    this.pool.useNamespace(this.namespace);
+    this.namespace = deps.namespace;
+    if (this.namespace !== void 0) {
+      this.pool.useNamespace(this.namespace);
+    }
     this.leaseMs = deps.leaseMs ?? 3e4;
     this.maxRecoveryAttempts = deps.maxRecoveryAttempts;
     this.remoteAdvanceSilenceMs = deps.remoteAdvanceSilenceMs;
@@ -1656,6 +1728,13 @@ var WorkflowEngine = class {
         await this.completeRemoteDecision(decision);
       }
     );
+    this.pool.onStartRun(async (message) => {
+      await this.start(message.workflow, message.input, message.runId ?? globalThis.crypto.randomUUID(), {
+        namespace: message.tenant,
+        tags: message.tags,
+        searchAttributes: message.searchAttributes
+      });
+    });
     this.controlPlane?.onControl((msg) => {
       if (msg.from === this.instanceId) return;
       if (msg.kind === "event") {
@@ -1820,7 +1899,7 @@ var WorkflowEngine = class {
     });
   }
   /**
-  * Register a flow-control queue referenced by `ctx.call(step, input, { queue })`. Caps concurrent
+  * Register a flow-control queue referenced by `ctx.step(step, input, { queue })`. Caps concurrent
   * in-flight steps and/or the admission rate; blocked calls re-suspend and retry, so the limit is
   * durable. Per engine instance (see {@link QueueConfig}). Registering the same name replaces it.
   */
@@ -1923,6 +2002,23 @@ var WorkflowEngine = class {
       const ancestor = await this.findRemoteAncestor(runId);
       if (ancestor) registered = this.synthesizeRemoteChild(name, ancestor.version, ancestor);
     }
+    if (!registered) {
+      const conventionRun = {
+        id: runId,
+        workflow: name,
+        workflowVersion: "1",
+        status: "pending",
+        // Stamp the namespace the REAL run will carry (below) so convention routing resolves the same
+        // tenant-suffixed group the run will dispatch to — an operator starting a tenant's run via the
+        // `onStartRun` wire (opts.namespace = tenant) must find the live `<workflow>@<tenant>` group,
+        // not the bare group. Without this the start-run entry path can't reach a suffixed-only worker.
+        namespace: opts?.namespace ?? this.namespace,
+        input,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      registered = await this.resolveRemoteByConvention(conventionRun);
+    }
     if (!registered) throw new Error(`workflow ${name} is not registered`);
     await registered.validateInput?.(input);
     const prior = await this.store.getRun(runId);
@@ -1947,7 +2043,7 @@ var WorkflowEngine = class {
       workflow: name,
       workflowVersion: registered.version,
       status: "pending",
-      namespace: this.namespace,
+      namespace: opts?.namespace ?? this.namespace,
       input,
       tags,
       searchAttributes: opts?.searchAttributes,
@@ -1984,11 +2080,11 @@ var WorkflowEngine = class {
         error: run.error
       };
     }
-    if (run.namespace !== void 0 && run.namespace !== this.namespace) {
+    if (this.namespace !== void 0 && run.namespace !== void 0 && run.namespace !== this.namespace) {
       await this.store.releaseRunLock(runId);
       throw new NamespaceMismatch();
     }
-    const registered = this.workflows.get(versionKey(run.workflow, run.workflowVersion)) ?? await this.findInheritedRegistration(run);
+    const registered = this.workflows.get(versionKey(run.workflow, run.workflowVersion)) ?? await this.findInheritedRegistration(run) ?? await this.resolveRemoteByConvention(run);
     if (!registered) {
       throw new Error(`workflow ${run.workflow}@${run.workflowVersion} is not registered \u2014 keep the prior version deployed so in-flight runs can drain (skew protection)`);
     }
@@ -2034,6 +2130,34 @@ var WorkflowEngine = class {
     };
   }
   /**
+  * Attempt to route an unregistered workflow to the live worker group of the same name: if the
+  * transport reports a live heartbeat for group `run.workflow`, synthesize a throwaway
+  * {@link RegisteredWorkflow} that dispatches to that group over the primary transport. Returns
+  * `undefined` when the group is not live. Always attempted — there is no opt-in flag; an explicit
+  * `register`/`registerRemote` still takes precedence (this only runs when nothing is registered).
+  *
+  * Recomputed per call (never memoized into `this.workflows`) so it stays correct if group
+  * liveness changes between calls, exactly as {@link synthesizeRemoteChild} does.
+  */
+  async resolveRemoteByConvention(run) {
+    const liveGroups = await this.pool.listWorkerGroups();
+    const group = tenantGroup(sanitizeQueueToken(run.workflow), run.namespace);
+    if (!liveGroups.includes(group)) return void 0;
+    const executor = new RemoteWorkflowExecutor(this.pool.primary, run.workflow, run.namespace);
+    return {
+      name: run.workflow,
+      version: run.workflowVersion,
+      fn: /* @__PURE__ */ __name(() => {
+        throw new Error(`remote workflow ${run.workflow} has no local body`);
+      }, "fn"),
+      hasBody: false,
+      remote: {
+        group,
+        executor
+      }
+    };
+  }
+  /**
   * Walk the parent chain of `childRunId` to the nearest ancestor registered as REMOTE, returning its
   * registration (or `undefined` if there is none). The parent of an awaited child is found via its
   * live `child:<childId>` signal waiter — present for as long as the parent is suspended awaiting the
@@ -2130,6 +2254,7 @@ var WorkflowEngine = class {
           type: "run.failed",
           runId: run.id,
           workflow: run.workflow,
+          namespace: run.namespace,
           error
         });
       }
@@ -2187,6 +2312,7 @@ var WorkflowEngine = class {
         type: "run.failed",
         runId: run.id,
         workflow: run.workflow,
+        namespace: run.namespace,
         error
       });
       this.notifyDead({
@@ -2261,7 +2387,8 @@ var WorkflowEngine = class {
     if (!run) return null;
     const id = newRunId ?? `${runId}~retry~${globalThis.crypto.randomUUID().slice(0, 8)}`;
     await this.start(run.workflow, input, id, {
-      tags: run.tags
+      tags: run.tags,
+      namespace: run.namespace
     });
     return {
       runId: id
@@ -2495,6 +2622,7 @@ var WorkflowEngine = class {
       type: "run.failed",
       runId,
       workflow: run.workflow,
+      namespace: run.namespace,
       error
     });
     await this.cancelChildren(runId, opts);
@@ -2771,7 +2899,7 @@ var WorkflowEngine = class {
     });
   }
   async execute(run, fn) {
-    const registered = this.workflows.get(versionKey(run.workflow, run.workflowVersion)) ?? await this.findInheritedRegistration(run);
+    const registered = this.workflows.get(versionKey(run.workflow, run.workflowVersion)) ?? await this.findInheritedRegistration(run) ?? await this.resolveRemoteByConvention(run);
     const lockNow = this.clock();
     if (run.lockedBy !== this.instanceId || (run.lockedUntil ?? 0) <= lockNow) {
       if (!await this.store.tryLockRun(run.id, this.instanceId, lockNow + this.leaseMs, lockNow)) {
@@ -2821,6 +2949,7 @@ var WorkflowEngine = class {
         type: "run.completed",
         runId: run.id,
         workflow: run.workflow,
+        namespace: run.namespace,
         output: outcome.output
       });
       void this.notifyParent(run.id, {
@@ -2843,6 +2972,7 @@ var WorkflowEngine = class {
         type: "run.failed",
         runId: run.id,
         workflow: run.workflow,
+        namespace: run.namespace,
         error: outcome.error
       });
       void this.notifyParent(run.id, {
@@ -2863,7 +2993,8 @@ var WorkflowEngine = class {
     this.emit({
       type: "run.suspended",
       runId: run.id,
-      workflow: run.workflow
+      workflow: run.workflow,
+      namespace: run.namespace
     });
     return {
       runId: run.id,
@@ -2884,6 +3015,7 @@ var WorkflowEngine = class {
         type: "run.failed",
         runId: run.id,
         workflow: run.workflow,
+        namespace: run.namespace,
         error
       });
       this.notifyCancelled(run.id);
@@ -2911,7 +3043,8 @@ var WorkflowEngine = class {
       this.emit({
         type: "run.started",
         runId: run.id,
-        workflow: run.workflow
+        workflow: run.workflow,
+        namespace: run.namespace
       });
     }
     if (registered.singleton && !await this.singletons.admit(run, registered.singleton)) {
@@ -2924,7 +3057,8 @@ var WorkflowEngine = class {
       this.emit({
         type: "run.suspended",
         runId: run.id,
-        workflow: run.workflow
+        workflow: run.workflow,
+        namespace: run.namespace
       });
       await this.store.releaseRunLock(run.id);
       return {
@@ -2946,7 +3080,8 @@ var WorkflowEngine = class {
       this.emit({
         type: "run.suspended",
         runId: run.id,
-        workflow: run.workflow
+        workflow: run.workflow,
+        namespace: run.namespace
       });
       await this.store.releaseRunLock(run.id);
       await remote.executor.dispatch(run, history, taskId);
@@ -2985,6 +3120,7 @@ var WorkflowEngine = class {
         type: "run.failed",
         runId: run.id,
         workflow: run.workflow,
+        namespace: run.namespace,
         error
       });
       return {
@@ -3135,13 +3271,16 @@ var WorkflowEngine = class {
           status: "pending",
           input: cmd.input,
           attempts: 1,
-          workerGroup: cmd.group,
+          // `cmd.group` is the routing declaration the worker's replay emitted (cross-SDK, or a
+          // group-served TS body) — treated as an isolation partition on top of the step's own
+          // name, mirroring the StepDef formula below (identical expression everywhere).
+          workerGroup: tenantGroup(sanitizeQueueToken(cmd.name), cmd.group),
           enqueuedAt: at,
           startedAt: at,
           finishedAt: at,
           // A `ctx.gather_calls([...])` fan-out stamps every dispatched `call` in the fan with the
-          // same group, so the dashboard renders the remote steps as one parallel fan (parity with
-          // the gathered `recordStep`/`startChild` tags). Undefined for a lone sequential `ctx.call`.
+          // same group, so the dashboard renders the dispatched steps as one parallel fan (parity
+          // with the gathered `recordStep`/`startChild` tags). Undefined for a lone sequential `ctx.step`.
           parallelGroup: cmd.parallelGroup
         }));
         await this.pool.dispatch({
@@ -3149,7 +3288,7 @@ var WorkflowEngine = class {
           seq: cmd.seq,
           name: cmd.name,
           stepId: id,
-          group: cmd.group,
+          group: tenantGroup(sanitizeQueueToken(cmd.name), cmd.group),
           input: cmd.input,
           traceparent: this.traceparent?.(),
           context: this.context?.(),
@@ -3208,7 +3347,9 @@ var WorkflowEngine = class {
           parallelGroup: cmd.parallelGroup
         });
         if (!await this.store.getRun(childId)) {
-          queueMicrotask(() => void this.start(cmd.workflow, cmd.input, childId).catch(() => void 0));
+          queueMicrotask(() => void this.start(cmd.workflow, cmd.input, childId, {
+            namespace: run.namespace
+          }).catch(() => void 0));
         }
       } else {
         throw new Error(`remote workflow command '${cmd.kind}' is not supported yet`);
@@ -3240,6 +3381,7 @@ var WorkflowEngine = class {
       type: "run.failed",
       runId: run.id,
       workflow: run.workflow,
+      namespace: run.namespace,
       error
     });
     return {
@@ -3260,7 +3402,8 @@ var WorkflowEngine = class {
       this.emit({
         type: "run.started",
         runId: run.id,
-        workflow: run.workflow
+        workflow: run.workflow,
+        namespace: run.namespace
       });
     }
     if (run.status !== "cancelling" && registered?.singleton && !await this.singletons.admit(run, registered.singleton)) {
@@ -3273,7 +3416,8 @@ var WorkflowEngine = class {
       this.emit({
         type: "run.suspended",
         runId: run.id,
-        workflow: run.workflow
+        workflow: run.workflow,
+        namespace: run.namespace
       });
       await this.store.releaseRunLock(run.id);
       return {
@@ -3285,7 +3429,7 @@ var WorkflowEngine = class {
     const snapshot = await this.store.listCheckpoints(run.id);
     const replay = /* @__PURE__ */ new Map();
     for (const cp of snapshot) replay.set(cp.seq, cp);
-    const ctx = createWorkflowCtx(this.ctxHostFor(replay), run.id, compensations, run.workflow);
+    const ctx = createWorkflowCtx(this.ctxHostFor(replay, run.namespace), run.id, compensations, run.workflow);
     try {
       const output = await fn(ctx, run.input);
       if (this.cancelRequested.has(run.id)) return this.compensateAndCancel(run, compensations);
@@ -3305,7 +3449,8 @@ var WorkflowEngine = class {
         this.emit({
           type: "run.completed",
           runId: run.id,
-          workflow: run.workflow
+          workflow: run.workflow,
+          namespace: run.namespace
         });
         void this.notifyParent(run.id, {
           ok: true,
@@ -3383,7 +3528,7 @@ var WorkflowEngine = class {
   /** The seam handed to {@link createWorkflowCtx}: the authoring API reaches durability + lifecycle
   *  (checkpointing, dispatch, child start) through this, so the ctx primitives live in their own
   *  module and the engine stays the orchestrator. */
-  ctxHostFor(replay) {
+  ctxHostFor(replay, parentNamespace) {
     return {
       store: this.store,
       replay,
@@ -3393,10 +3538,16 @@ var WorkflowEngine = class {
       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"),
-      // Defer so a fast child can't reentrantly resume a still-running parent.
+      // 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
+      // namespace) is the one executing the parent. Otherwise an operator recovery-resuming a
+      // `davi-local` pipeline would stamp its `processing` child `default` and it would leak off the
+      // tenant's worker pool onto the shared/dev workers.
       startChild: /* @__PURE__ */ __name((workflow, input, id, priority) => {
         queueMicrotask(() => void this.start(workflow, input, id, {
-          priority
+          priority,
+          namespace: parentNamespace
         }).catch(() => void 0));
       }, "startChild"),
       // Shallow-merge into the run's searchAttributes (the ctx primitive makes this exactly-once).
@@ -3524,7 +3675,6 @@ var WorkflowEngine = class {
       this.queueWaiters.get(queue)?.delete(runId);
       this.stepQueue.set(id, queue);
     }
-    const validInput = step.input.parse(input);
     const enqueuedAt = /* @__PURE__ */ new Date();
     await this.store.saveCheckpoint({
       runId,
@@ -3533,9 +3683,9 @@ var WorkflowEngine = class {
       kind: "remote",
       stepId: id,
       status: "pending",
-      input: validInput,
+      input,
       attempts: attempt,
-      workerGroup: step.group,
+      workerGroup: tenantGroup(sanitizeQueueToken(step.name), step.partition),
       enqueuedAt,
       startedAt: enqueuedAt,
       finishedAt: enqueuedAt
@@ -3545,8 +3695,8 @@ var WorkflowEngine = class {
       seq,
       name: step.name,
       stepId: id,
-      group: step.group,
-      input: validInput,
+      group: tenantGroup(sanitizeQueueToken(step.name), step.partition),
+      input,
       traceparent: this.traceparent?.(),
       context: this.context?.(),
       priority: admission?.priority,
@@ -3611,7 +3761,9 @@ var WorkflowEngine = class {
     const run = await this.store.getRun(decision.runId);
     if (!run || run.awaitingDecisionTaskId !== decision.taskId) return;
     if (run.status === "cancelled" || run.status === "completed" || run.status === "dead") return;
-    if (run.namespace !== void 0 && run.namespace !== this.namespace) return;
+    if (this.namespace !== void 0 && run.namespace !== void 0 && run.namespace !== this.namespace) {
+      return;
+    }
     const nowMs = this.clock();
     if (!await this.store.tryLockRun(decision.runId, this.instanceId, nowMs + this.leaseMs, nowMs)) {
       return;
@@ -3677,7 +3829,7 @@ var WorkflowEngine = class {
   /** In-memory await path for a remote step with a liveness `timeoutMs` (re-dispatch on timeout). */
   async callRemoteInMemory(runId, seq, step, input, transport) {
     if (this.pool.size === 0) throw new Error("remote steps require a Transport");
-    const validInput = step.input.parse(input);
+    const validInput = step.input ? step.input.parse(input) : input;
     const id = stepId(runId, seq);
     const enqueuedAt = /* @__PURE__ */ new Date();
     this.emit({
@@ -3700,7 +3852,7 @@ var WorkflowEngine = class {
         seq,
         name: step.name,
         stepId: id,
-        group: step.group,
+        group: tenantGroup(sanitizeQueueToken(step.name), step.partition),
         input: validInput,
         traceparent: this.traceparent?.(),
         context: this.context?.(),
@@ -3708,7 +3860,7 @@ var WorkflowEngine = class {
       }, transport);
       try {
         const resolution = step.timeoutMs ? await this.awaitWithHeartbeat(id, resultPromise, step.timeoutMs) : await resultPromise;
-        const output = step.output.parse(resolution.output);
+        const output = step.output ? step.output.parse(resolution.output) : resolution.output;
         const startedAt = resolution.startedAt ? new Date(resolution.startedAt) : enqueuedAt;
         await this.completeStep({
           runId,
@@ -3719,7 +3871,7 @@ var WorkflowEngine = class {
           output,
           events: resolution.events,
           attempts: attempt,
-          workerGroup: step.group,
+          workerGroup: tenantGroup(sanitizeQueueToken(step.name), step.partition),
           enqueuedAt,
           startedAt
         });
@@ -3795,16 +3947,6 @@ var TERMINAL_RUN_STATUSES = [
   "dead"
 ];
 
-// src/remote-step-factory.ts
-function remoteStep(config) {
-  return {
-    ...config,
-    group: config.group ?? config.name.split(".")[0] ?? config.name,
-    __remote: true
-  };
-}
-__name(remoteStep, "remoteStep");
-
 // src/codec-state-store.ts
 var CodecStateStore = class {
   static {
@@ -4528,6 +4670,8 @@ export {
   ContinueAsNew,
   DURABLE_OPTIONS,
   DURABLE_OPTIONS_CANONICAL,
+  DURABLE_STEP_CONFIG,
+  DURABLE_STEP_NAME,
   Entities,
   EventAccumulators,
   FatalError,
@@ -4565,12 +4709,15 @@ export {
   normalizeAttributeRows,
   parseDuration,
   prevCronFireMs,
-  remoteStep,
   runSchedules,
   runStepHandler,
+  sanitizeQueueToken,
   scheduledRunId,
   sqlComparator,
+  stepConfigOf,
   stepId,
+  stepNameOf,
+  tenantGroup,
   workflowName
 };
 //# sourceMappingURL=index.js.map