fix(sdk): extract customer event from stepData after pagination (#445)

Large payloads (~6MB) were being ignored during synchronous Lambda
invocations because the customer event was extracted from
event.InitialExecutionState.Operations[0] before pagination completed.

When payloads are large, InitialExecutionState.Operations is empty and
NextMarker indicates more data needs to be fetched. The fix extracts the
customer event from executionContext._stepData after pagination
completes in initializeExecutionContext, ensuring full payload access.

Fixes large payload truncation issue for durable Lambda functions.

*Issue #, if available:*
#442

Author: ParidelPooya

packages/aws-durable-execution-sdk-js-examples/src/examples/large-payload/large-payload.history.json

@@ -0,0 +1,58 @@
+[
+  {
+    "EventType": "ExecutionStarted",
+    "EventId": 1,
+    "Id": "ce4d4b85-8528-4b42-8198-9d2d0bb96926",
+    "EventTimestamp": "2026-02-19T21:38:35.633Z",
+    "ExecutionStartedDetails": {
+      "Input": {
+        "Payload": "{\"data\":\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\",\"metadata\":{\"size\":1000,\"description\":\"Small test payload\"}}"
+      }
+    }
+  },
+  {
+    "EventType": "StepStarted",
+    "SubType": "Step",
+    "EventId": 2,
+    "Id": "c4ca4238a0b92382",
+    "Name": "process-large-payload",
+    "EventTimestamp": "2026-02-19T21:38:35.641Z",
+    "StepStartedDetails": {}
+  },
+  {
+    "EventType": "StepSucceeded",
+    "SubType": "Step",
+    "EventId": 3,
+    "Id": "c4ca4238a0b92382",
+    "Name": "process-large-payload",
+    "EventTimestamp": "2026-02-19T21:38:35.641Z",
+    "StepSucceededDetails": {
+      "Result": {
+        "Payload": "{\"originalSize\":1000,\"first100Chars\":\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\",\"hasMetadata\":true,\"processedAt\":\"2026-02-19T21:38:35.637Z\"}"
+      },
+      "RetryDetails": {}
+    }
+  },
+  {
+    "EventType": "InvocationCompleted",
+    "EventId": 4,
+    "EventTimestamp": "2026-02-19T21:38:35.641Z",
+    "InvocationCompletedDetails": {
+      "StartTimestamp": "2026-02-19T21:38:35.633Z",
+      "EndTimestamp": "2026-02-19T21:38:35.641Z",
+      "Error": {},
+      "RequestId": "4f9f89ec-cc03-4d56-bf9d-8107fa2a7468"
+    }
+  },
+  {
+    "EventType": "ExecutionSucceeded",
+    "EventId": 5,
+    "Id": "ce4d4b85-8528-4b42-8198-9d2d0bb96926",
+    "EventTimestamp": "2026-02-19T21:38:35.642Z",
+    "ExecutionSucceededDetails": {
+      "Result": {
+        "Payload": "{\"success\":true,\"payload\":{\"originalSize\":1000,\"first100Chars\":\"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\",\"hasMetadata\":true,\"processedAt\":\"2026-02-19T21:38:35.637Z\"}}"
+      }
+    }
+  }
+]

packages/aws-durable-execution-sdk-js-examples/src/examples/large-payload/large-payload.test.ts

@@ -0,0 +1,113 @@
+import { handler } from "./large-payload";
+import { createTests } from "../../utils/test-helper";
+
+createTests({
+  handler,
+  tests: (runner, { assertEventSignatures }) => {
+    it("should handle small payload correctly", async () => {
+      const smallPayload = {
+        data: "A".repeat(1000), // 1KB
+        metadata: {
+          size: 1000,
+          description: "Small test payload",
+        },
+      };
+
+      const execution = await runner.run({ payload: smallPayload });
+
+      expect(execution.getResult()).toEqual({
+        success: true,
+        payload: {
+          originalSize: 1000,
+          first100Chars: "A".repeat(100),
+          hasMetadata: true,
+          processedAt: expect.any(String),
+        },
+      });
+
+      expect(execution.getOperations()).toHaveLength(1);
+      const step = runner.getOperation("process-large-payload");
+      expect(step.getStepDetails()?.result).toEqual({
+        originalSize: 1000,
+        first100Chars: "A".repeat(100),
+        hasMetadata: true,
+        processedAt: expect.any(String),
+      });
+
+      // Call assertEventSignatures only once to satisfy the test framework requirement
+      assertEventSignatures(execution);
+    });
+
+    it("should handle medium payload correctly", async () => {
+      const mediumPayload = {
+        data: "B".repeat(1000000), // 1MB
+        metadata: {
+          size: 1000000,
+          description: "Medium test payload",
+        },
+      };
+
+      const execution = await runner.run({ payload: mediumPayload });
+
+      expect(execution.getResult()).toEqual({
+        success: true,
+        payload: {
+          originalSize: 1000000,
+          first100Chars: "B".repeat(100),
+          hasMetadata: true,
+          processedAt: expect.any(String),
+        },
+      });
+
+      expect(execution.getOperations()).toHaveLength(1);
+      // Skip event signature validation for this test
+    });
+
+    it("should handle large payload correctly", async () => {
+      const largePayload = {
+        data: "C".repeat(6000000), // 6MB
+        metadata: {
+          size: 6000000,
+          description: "Large test payload that triggers pagination",
+        },
+      };
+
+      const execution = await runner.run({ payload: largePayload });
+
+      expect(execution.getResult()).toEqual({
+        success: true,
+        payload: {
+          originalSize: 6000000,
+          first100Chars: "C".repeat(100),
+          hasMetadata: true,
+          processedAt: expect.any(String),
+        },
+      });
+
+      expect(execution.getOperations()).toHaveLength(1);
+      const step = runner.getOperation("process-large-payload");
+      const stepResult = step.getStepDetails()?.result as any;
+      expect(stepResult.originalSize).toBe(6000000);
+      // Skip event signature validation for this test
+    });
+
+    it("should handle payload without metadata", async () => {
+      const payloadWithoutMetadata = {
+        data: "D".repeat(5000), // 5KB
+      };
+
+      const execution = await runner.run({ payload: payloadWithoutMetadata });
+
+      expect(execution.getResult()).toEqual({
+        success: true,
+        payload: {
+          originalSize: 5000,
+          first100Chars: "D".repeat(100),
+          hasMetadata: false,
+          processedAt: expect.any(String),
+        },
+      });
+      // Skip event signature validation for this test
+    });
+  },
+});

packages/aws-durable-execution-sdk-js-examples/src/examples/large-payload/large-payload.ts

@@ -0,0 +1,37 @@
+import {
+  DurableContext,
+  withDurableExecution,
+} from "@aws/durable-execution-sdk-js";
+import { ExampleConfig } from "../../types";
+
+export const config: ExampleConfig = {
+  name: "Large Payload",
+  description:
+    "Demonstrates handling of large payloads (>6MB) in durable functions",
+};
+
+interface LargePayloadEvent {
+  data: string;
+  metadata?: {
+    size: number;
+    description: string;
+  };
+}
+
+export const handler = withDurableExecution(
+  async (event: LargePayloadEvent, context: DurableContext) => {
+    const result = await context.step("process-large-payload", async () => {
+      return {
+        originalSize: event.data.length,
+        first100Chars: event.data.substring(0, 100),
+        hasMetadata: !!event.metadata,
+        processedAt: new Date().toISOString(),
+      };
+    });
+
+    return {
+      success: true,
+      payload: result,
+    };
+  },
+);

packages/aws-durable-execution-sdk-js/src/with-durable-execution.ts

@@ -75,8 +75,10 @@ async function runHandler<
     durableExecution,
   );
 
-  // Extract customerHandlerEvent from the original event
-  const initialExecutionEvent = event.InitialExecutionState.Operations?.[0];
+  // Extract customerHandlerEvent from the complete operations array (after pagination)
+  // This ensures we get the full payload even for large payloads that are paginated
+  const initialExecutionEvent =
+    executionContext._stepData[Object.keys(executionContext._stepData)[0]];
   const customerHandlerEvent = JSON.parse(
     initialExecutionEvent?.ExecutionDetails?.InputPayload ?? "{}",
   );