fix: guard sub-orchestration completion handler against missing pending tasks

Refactor handleSubOrchestrationCompleted to delegate to handleCompletedTask,
matching the pattern used by handleSubOrchestrationFailed -> handleFailedTask
and handleTaskCompleted -> handleCompletedTask.

Before this fix, handleSubOrchestrationCompleted called ctx.resume()
unconditionally, even when no matching pending task was found. This differs
from handleCompletedTask (the activity completion handler), which correctly
returns early with a warning log when no matching task exists.

The unconditional resume() could advance the generator incorrectly if
_previousTask happens to be complete from an unrelated event. Additionally,
orphaned sub-orchestration completion events were silently dropped without
any diagnostic logging, unlike the activity handler.

This change:
- Adds the missing guard clause (returns early when no task found)
- Adds warning logging for unexpected events (via WorkerLogs)
- Adds isEmpty normalization for empty results (consistent with activity handler)
- Reduces code duplication by reusing handleCompletedTask

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Copilot

packages/durabletask-js/src/worker/orchestration-executor.ts

@@ -386,25 +386,11 @@ export class OrchestrationExecutor {
   }
 
   private async handleSubOrchestrationCompleted(ctx: RuntimeOrchestrationContext, event: pb.HistoryEvent): Promise<void> {
-    const subOrchestrationInstanceCompletedEvent = event.getSuborchestrationinstancecompleted();
-    const taskId = subOrchestrationInstanceCompletedEvent
-      ? subOrchestrationInstanceCompletedEvent.getTaskscheduledid()
-      : undefined;
-
-    let subOrchTask;
-
-    if (taskId !== undefined) {
-      subOrchTask = ctx._pendingTasks[taskId];
-      delete ctx._pendingTasks[taskId];
-    }
-
-    const result = parseJsonField(subOrchestrationInstanceCompletedEvent?.getResult());
-
-    if (subOrchTask) {
-      subOrchTask.complete(result);
-    }
-
-    await ctx.resume();
+    const completedEvent = event.getSuborchestrationinstancecompleted();
+    const taskId = completedEvent ? completedEvent.getTaskscheduledid() : undefined;
+    const result = completedEvent?.getResult();
+    const normalizedResult = isEmpty(result) ? undefined : result;
+    await this.handleCompletedTask(ctx, taskId, normalizedResult, "subOrchestrationInstanceCompleted");
   }
 
   private async handleSubOrchestrationFailed(ctx: RuntimeOrchestrationContext, event: pb.HistoryEvent): Promise<void> {

packages/durabletask-js/test/orchestration_executor.spec.ts

@@ -570,6 +570,33 @@ describe("Orchestration Executor", () => {
     // assert user_code_statement in complete_action.failureDetails.stackTrace.value
   });
 
+  it("should not advance the generator when a sub-orchestration completion event has no matching pending task", async () => {
+    const subOrchestrator = async (_: OrchestrationContext) => {
+      // do nothing
+    };
+    const orchestrator: TOrchestrator = async function* (ctx: OrchestrationContext, _: any): any {
+      const res = yield ctx.callSubOrchestrator(subOrchestrator);
+      return res;
+    };
+    const registry = new Registry();
+    const subOrchestratorName = registry.addOrchestrator(subOrchestrator);
+    const orchestratorName = registry.addOrchestrator(orchestrator);
+    const oldEvents = [
+      newOrchestratorStartedEvent(),
+      newExecutionStartedEvent(orchestratorName, TEST_INSTANCE_ID, undefined),
+      newSubOrchestrationCreatedEvent(1, subOrchestratorName, "sub-orch-123"),
+    ];
+    // Send a completion event with a taskId (999) that does not match any pending task.
+    // Before the fix, this would call resume() unconditionally. After the fix, it returns
+    // early without advancing the generator, consistent with handleCompletedTask behavior.
+    const newEvents = [newSubOrchestrationCompletedEvent(999, JSON.stringify("unexpected"))];
+    const executor = new OrchestrationExecutor(registry, testLogger);
+    const result = await executor.execute(TEST_INSTANCE_ID, oldEvents, newEvents);
+    // The orchestration should still be waiting for the real sub-orchestration to complete.
+    // No complete action should be produced.
+    expect(result.actions.length).toEqual(0);
+  });
+
   it("should test that an orchestration can wait for and process an external event sent by a client", async () => {
     const orchestrator: TOrchestrator = async function* (ctx: OrchestrationContext, _: any): any {
       const res = yield ctx.waitForExternalEvent("my_event");