@dudousxd/nestjs-durable-core 0.46.0 → 0.46.1

package/dist/index.cjs

@@ -2085,7 +2085,7 @@ var WorkflowEngine = class {
         workflow: name,
         workflowVersion: "1",
         status: "pending",
-        // Stamp the namespace the REAL run will carry (:893) so convention routing resolves the same
+        // 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.
@@ -3424,7 +3424,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`);
@@ -3504,7 +3506,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);
@@ -3603,7 +3605,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,
@@ -3613,10 +3615,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).