@aws/durable-execution-sdk-js 1.0.0 → 1.0.2

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { OperationStatus, OperationAction, OperationType, LambdaClient, GetDurableExecutionStateCommand, CheckpointDurableExecutionCommand } from '@aws-sdk/client-lambda';
+import { OperationType, OperationStatus, OperationAction, LambdaClient, GetDurableExecutionStateCommand, CheckpointDurableExecutionCommand } from '@aws-sdk/client-lambda';
 import { EventEmitter } from 'events';
 import { AsyncLocalStorage } from 'async_hooks';
 import { createHash } from 'crypto';
@@ -165,11 +165,56 @@ var DurableLogLevel;
 })(DurableLogLevel || (DurableLogLevel = {}));
 
 /**
+ * Execution semantics for step operations.
+ *
+ * @remarks
+ * These semantics control how step execution is checkpointed and replayed. **Important**: The guarantees apply *per
+ * retry attempt*, not per overall workflow execution.
+ *
+ * With retries enabled (the default), a step could execute multiple times across different retry attempts even when
+ * using `AtMostOncePerRetry`. To achieve step-level at-most-once execution, combine `AtMostOncePerRetry` with a retry
+ * strategy that disables retries (`shouldRetry: false`).
+ *
+ * @example
+ * ```typescript
+ * // At-least-once per retry (default) - safe for idempotent operations
+ * await context.step("send-notification", async () => sendEmail(), {
+ *   semantics: StepSemantics.AtLeastOncePerRetry,
+ * });
+ *
+ * // At-most-once per retry - for non-idempotent operations
+ * await context.step("charge-payment", async () => processPayment(), {
+ *   semantics: StepSemantics.AtMostOncePerRetry,
+ *   retryStrategy: () => ({ shouldRetry: false }),
+ * });
+ * ```
+ *
  * @public
  */
 var StepSemantics;
 (function (StepSemantics) {
+    /**
+     * At-most-once execution per retry attempt.
+     *
+     * @remarks
+     * A checkpoint is created before step execution. If a failure occurs after the checkpoint
+     * but before step completion, the previous step retry attempt is skipped on replay.
+     *
+     * **Note**: This is "at-most-once *per retry*". With multiple retry attempts, the step
+     * could still execute multiple times across different retries. To guarantee the step
+     * executes at most once, disable retries by returning
+     * `{ shouldRetry: false }` from your retry strategy.
+     */
     StepSemantics["AtMostOncePerRetry"] = "AT_MOST_ONCE_PER_RETRY";
+    /**
+     * At-least-once execution per retry attempt (default).
+     *
+     * @remarks
+     * The step will execute at least once on each retry attempt. If the step succeeds
+     * but the checkpoint fails (e.g., due to a sandbox crash), the step will re-execute
+     * on replay. This is the safer default for operations that are idempotent or can
+     * tolerate duplicate execution.
+     */
     StepSemantics["AtLeastOncePerRetry"] = "AT_LEAST_ONCE_PER_RETRY";
 })(StepSemantics || (StepSemantics = {}));
 /**
@@ -298,6 +343,34 @@ class DurablePromise {
     }
 }
 
+/**
+ * Represents the lifecycle state of an operation in the durable execution system.
+ * This is distinct from AWS SDK's OperationStatus (PENDING, SUCCEEDED, FAILED).
+ */
+var OperationLifecycleState;
+(function (OperationLifecycleState) {
+    /**
+     * Operation is currently executing user code (step function, waitForCondition check)
+     */
+    OperationLifecycleState["EXECUTING"] = "EXECUTING";
+    /**
+     * Operation is waiting for retry timer to expire before re-executing user code
+     */
+    OperationLifecycleState["RETRY_WAITING"] = "RETRY_WAITING";
+    /**
+     * Operation is waiting for external event (timer, callback, invoke) but not awaited yet (phase 1)
+     */
+    OperationLifecycleState["IDLE_NOT_AWAITED"] = "IDLE_NOT_AWAITED";
+    /**
+     * Operation is waiting for external event and has been awaited (phase 2)
+     */
+    OperationLifecycleState["IDLE_AWAITED"] = "IDLE_AWAITED";
+    /**
+     * Operation has completed (success or permanent failure)
+     */
+    OperationLifecycleState["COMPLETED"] = "COMPLETED";
+})(OperationLifecycleState || (OperationLifecycleState = {}));
+
 /**
  * Converts a Duration object to total seconds
  * @param duration - Duration object with at least one time unit specified
@@ -311,6 +384,21 @@ function durationToSeconds(duration) {
     return days * 24 * 60 * 60 + hours * 60 * 60 + minutes * 60 + seconds;
 }
 
+/**
+ * Terminates execution for unrecoverable errors and returns a never-resolving promise
+ * @param context - The execution context containing the termination manager
+ * @param error - The unrecoverable error that caused termination
+ * @param stepIdentifier - The step name or ID for error messaging
+ * @returns A never-resolving promise
+ */
+function terminateForUnrecoverableError(context, error, stepIdentifier) {
+    context.terminationManager.terminate({
+        reason: error.terminationReason,
+        message: `Unrecoverable error in step ${stepIdentifier}: ${error.message}`,
+    });
+    return new Promise(() => { }); // Never-resolving promise
+}
+
 const safeStringify = (data) => {
     try {
         const seen = new WeakSet();
@@ -344,238 +432,6 @@ const log = (emoji, message, data) => {
     }
 };
 
-var TerminationReason;
-(function (TerminationReason) {
-    // Default termination reason
-    TerminationReason["OPERATION_TERMINATED"] = "OPERATION_TERMINATED";
-    // Retry-related reasons
-    TerminationReason["RETRY_SCHEDULED"] = "RETRY_SCHEDULED";
-    TerminationReason["RETRY_INTERRUPTED_STEP"] = "RETRY_INTERRUPTED_STEP";
-    // Wait-related reasons
-    TerminationReason["WAIT_SCHEDULED"] = "WAIT_SCHEDULED";
-    // Callback-related reasons
-    TerminationReason["CALLBACK_PENDING"] = "CALLBACK_PENDING";
-    // Error-related reasons
-    TerminationReason["CHECKPOINT_FAILED"] = "CHECKPOINT_FAILED";
-    TerminationReason["SERDES_FAILED"] = "SERDES_FAILED";
-    TerminationReason["CONTEXT_VALIDATION_ERROR"] = "CONTEXT_VALIDATION_ERROR";
-    // Custom reason
-    TerminationReason["CUSTOM"] = "CUSTOM";
-})(TerminationReason || (TerminationReason = {}));
-
-const asyncLocalStorage = new AsyncLocalStorage();
-const getActiveContext = () => {
-    return asyncLocalStorage.getStore();
-};
-const runWithContext = (contextId, parentId, fn, attempt, durableExecutionMode) => {
-    return asyncLocalStorage.run({ contextId, parentId, attempt, durableExecutionMode }, fn);
-};
-const validateContextUsage = (operationContextId, operationName, terminationManager) => {
-    const contextId = operationContextId || "root";
-    const activeContext = getActiveContext();
-    if (!activeContext) {
-        return;
-    }
-    if (activeContext.contextId !== contextId) {
-        const errorMessage = `Context usage error in "${operationName}": You are using a parent or sibling context instead of the current child context. Expected context ID: "${activeContext.contextId}", but got: "${operationContextId}". When inside runInChildContext(), you must use the child context parameter, not the parent context.`;
-        terminationManager.terminate({
-            reason: TerminationReason.CONTEXT_VALIDATION_ERROR,
-            message: errorMessage,
-            error: new Error(errorMessage),
-        });
-        // Only call termination manager, don't throw or return promise
-    }
-};
-
-const HASH_LENGTH = 16;
-/**
- * Creates an MD5 hash of the input string for better performance than SHA-256
- * @param input - The string to hash
- * @returns The truncated hexadecimal hash string
- */
-const hashId = (input) => {
-    return createHash("md5")
-        .update(input)
-        .digest("hex")
-        .substring(0, HASH_LENGTH);
-};
-/**
- * Helper function to get step data using the original stepId
- * This function handles the hashing internally so callers don't need to worry about it
- * @param stepData - The stepData record from context
- * @param stepId - The original stepId (will be hashed internally)
- * @returns The operation data or undefined if not found
- */
-const getStepData = (stepData, stepId) => {
-    const hashedId = hashId(stepId);
-    return stepData[hashedId];
-};
-
-/**
- * Checks if any ancestor operation in the parent chain has finished (SUCCEEDED or FAILED)
- * or has a pending completion checkpoint
- */
-function hasFinishedAncestor(context, parentId) {
-    if (!parentId) {
-        log("🔍", "hasFinishedAncestor: No parentId provided");
-        return false;
-    }
-    // First check if any ancestor has a pending completion checkpoint
-    if (hasPendingAncestorCompletion(context, parentId)) {
-        log("🔍", "hasFinishedAncestor: Found ancestor with pending completion!", {
-            parentId,
-        });
-        return true;
-    }
-    let currentHashedId = hashId(parentId);
-    log("🔍", "hasFinishedAncestor: Starting check", {
-        parentId,
-        initialHashedId: currentHashedId,
-    });
-    while (currentHashedId) {
-        const parentOperation = context._stepData[currentHashedId];
-        log("🔍", "hasFinishedAncestor: Checking operation", {
-            hashedId: currentHashedId,
-            hasOperation: !!parentOperation,
-            status: parentOperation?.Status,
-            type: parentOperation?.Type,
-        });
-        if (parentOperation?.Status === OperationStatus.SUCCEEDED ||
-            parentOperation?.Status === OperationStatus.FAILED) {
-            log("🔍", "hasFinishedAncestor: Found finished ancestor!", {
-                hashedId: currentHashedId,
-                status: parentOperation.Status,
-            });
-            return true;
-        }
-        currentHashedId = parentOperation?.ParentId;
-    }
-    log("🔍", "hasFinishedAncestor: No finished ancestor found");
-    return false;
-}
-/**
- * Checks if any ancestor has a pending completion checkpoint
- */
-function hasPendingAncestorCompletion(context, stepId) {
-    let currentHashedId = hashId(stepId);
-    while (currentHashedId) {
-        if (context.pendingCompletions.has(currentHashedId)) {
-            return true;
-        }
-        const operation = context._stepData[currentHashedId];
-        currentHashedId = operation?.ParentId;
-    }
-    return false;
-}
-/**
- * Terminates execution and returns a never-resolving promise to prevent code progression
- * @param context - The execution context containing the termination manager
- * @param reason - The termination reason
- * @param message - The termination message
- * @returns A never-resolving promise
- */
-function terminate(context, reason, message) {
-    const activeContext = getActiveContext();
-    // If we have a parent context, add delay to let checkpoints process
-    if (activeContext?.parentId) {
-        return new Promise(async (_resolve, _reject) => {
-            // Wait a tick to let any pending checkpoints start processing
-            await new Promise((resolve) => setImmediate(resolve));
-            log("🔍", "Terminate called - checking context:", {
-                hasActiveContext: !!activeContext,
-                contextId: activeContext?.contextId,
-                parentId: activeContext?.parentId,
-                reason,
-                message,
-            });
-            const ancestorFinished = hasFinishedAncestor(context, activeContext.parentId);
-            log("🔍", "Ancestor check result:", {
-                parentId: activeContext.parentId,
-                ancestorFinished,
-            });
-            if (ancestorFinished) {
-                log("🛑", "Skipping termination - ancestor already finished:", {
-                    contextId: activeContext.contextId,
-                    parentId: activeContext.parentId,
-                    reason,
-                    message,
-                });
-                // Return never-resolving promise without terminating
-                return;
-            }
-            // Check if there are active operations before terminating
-            const tracker = context.activeOperationsTracker;
-            if (tracker && tracker.hasActive()) {
-                log("⏳", "Deferring termination - active operations in progress:", {
-                    activeCount: tracker.getCount(),
-                    reason,
-                    message,
-                });
-                // Wait for operations to complete, then terminate
-                const checkInterval = setInterval(() => {
-                    if (!tracker.hasActive()) {
-                        clearInterval(checkInterval);
-                        log("✅", "Active operations completed, proceeding with termination:", {
-                            reason,
-                            message,
-                        });
-                        context.terminationManager.terminate({
-                            reason,
-                            message,
-                        });
-                    }
-                }, 10);
-                return;
-            }
-            // No active operations, terminate immediately
-            context.terminationManager.terminate({
-                reason,
-                message,
-            });
-        });
-    }
-    // No parent context - check active operations and terminate
-    const tracker = context.activeOperationsTracker;
-    if (tracker && tracker.hasActive()) {
-        log("⏳", "Deferring termination - active operations in progress:", {
-            activeCount: tracker.getCount(),
-            reason,
-            message,
-        });
-        return new Promise((_resolve, _reject) => {
-            const checkInterval = setInterval(() => {
-                if (!tracker.hasActive()) {
-                    clearInterval(checkInterval);
-                    log("✅", "Active operations completed, proceeding with termination:", {
-                        reason,
-                        message,
-                    });
-                    context.terminationManager.terminate({
-                        reason,
-                        message,
-                    });
-                }
-            }, 10);
-        });
-    }
-    // No parent, no active operations - terminate immediately
-    context.terminationManager.terminate({
-        reason,
-        message,
-    });
-    return new Promise(() => { });
-}
-/**
- * Terminates execution for unrecoverable errors and returns a never-resolving promise
- * @param context - The execution context containing the termination manager
- * @param error - The unrecoverable error that caused termination
- * @param stepIdentifier - The step name or ID for error messaging
- * @returns A never-resolving promise
- */
-function terminateForUnrecoverableError(context, error, stepIdentifier) {
-    return terminate(context, error.terminationReason, `Unrecoverable error in step ${stepIdentifier}: ${error.message}`);
-}
-
 const DEFAULT_CONFIG$1 = {
     maxAttempts: 3,
     initialDelay: { seconds: 5 },
@@ -747,6 +603,7 @@ const retryPresets = {
 /**
  * Error thrown when a step with AT_MOST_ONCE_PER_RETRY semantics was started but interrupted
  * before completion.
+ * @public
  */
 class StepInterruptedError extends Error {
     constructor(_stepId, _stepName) {
@@ -755,13 +612,9 @@ class StepInterruptedError extends Error {
     }
 }
 
-/**
- * Shared constants to avoid circular dependencies
- */
-const OPERATIONS_COMPLETE_EVENT = "allOperationsComplete";
-
 /**
  * Base class for all durable operation errors
+ * @public
  */
 class DurableOperationError extends Error {
     cause;
@@ -810,6 +663,7 @@ class DurableOperationError extends Error {
 }
 /**
  * Error thrown when a step operation fails
+ * @public
  */
 class StepError extends DurableOperationError {
     errorType = "StepError";
@@ -819,6 +673,7 @@ class StepError extends DurableOperationError {
 }
 /**
  * Error thrown when a callback operation fails
+ * @public
  */
 class CallbackError extends DurableOperationError {
     errorType = "CallbackError";
@@ -828,6 +683,7 @@ class CallbackError extends DurableOperationError {
 }
 /**
  * Error thrown when an invoke operation fails
+ * @public
  */
 class InvokeError extends DurableOperationError {
     errorType = "InvokeError";
@@ -837,6 +693,7 @@ class InvokeError extends DurableOperationError {
 }
 /**
  * Error thrown when a child context operation fails
+ * @public
  */
 class ChildContextError extends DurableOperationError {
     errorType = "ChildContextError";
@@ -846,6 +703,7 @@ class ChildContextError extends DurableOperationError {
 }
 /**
  * Error thrown when a wait for condition operation fails
+ * @public
  */
 class WaitForConditionError extends DurableOperationError {
     errorType = "WaitForConditionError";
@@ -1013,6 +871,25 @@ function createClassSerdesWithDates(cls, dateProps) {
     };
 }
 
+var TerminationReason;
+(function (TerminationReason) {
+    // Default termination reason
+    TerminationReason["OPERATION_TERMINATED"] = "OPERATION_TERMINATED";
+    // Retry-related reasons
+    TerminationReason["RETRY_SCHEDULED"] = "RETRY_SCHEDULED";
+    TerminationReason["RETRY_INTERRUPTED_STEP"] = "RETRY_INTERRUPTED_STEP";
+    // Wait-related reasons
+    TerminationReason["WAIT_SCHEDULED"] = "WAIT_SCHEDULED";
+    // Callback-related reasons
+    TerminationReason["CALLBACK_PENDING"] = "CALLBACK_PENDING";
+    // Error-related reasons
+    TerminationReason["CHECKPOINT_FAILED"] = "CHECKPOINT_FAILED";
+    TerminationReason["SERDES_FAILED"] = "SERDES_FAILED";
+    TerminationReason["CONTEXT_VALIDATION_ERROR"] = "CONTEXT_VALIDATION_ERROR";
+    // Custom reason
+    TerminationReason["CUSTOM"] = "CUSTOM";
+})(TerminationReason || (TerminationReason = {}));
+
 /**
  * Base class for all unrecoverable errors
  * Any error that inherits from this class indicates a fatal condition
@@ -1133,6 +1010,30 @@ async function safeDeserialize(serdes, data, stepId, stepName, terminationManage
     }
 }
 
+const asyncLocalStorage = new AsyncLocalStorage();
+const getActiveContext = () => {
+    return asyncLocalStorage.getStore();
+};
+const runWithContext = (contextId, parentId, fn, attempt, durableExecutionMode) => {
+    return asyncLocalStorage.run({ contextId, parentId, attempt, durableExecutionMode }, fn);
+};
+const validateContextUsage = (operationContextId, operationName, terminationManager) => {
+    const contextId = operationContextId || "root";
+    const activeContext = getActiveContext();
+    if (!activeContext) {
+        return;
+    }
+    if (activeContext.contextId !== contextId) {
+        const errorMessage = `Context usage error in "${operationName}": You are using a parent or sibling context instead of the current child context. Expected context ID: "${activeContext.contextId}", but got: "${operationContextId}". When inside runInChildContext(), you must use the child context parameter, not the parent context.`;
+        terminationManager.terminate({
+            reason: TerminationReason.CONTEXT_VALIDATION_ERROR,
+            message: errorMessage,
+            error: new Error(errorMessage),
+        });
+        // Only call termination manager, don't throw or return promise
+    }
+};
+
 function isErrorLike(obj) {
     return (obj instanceof Error ||
         (obj != null &&
@@ -1161,525 +1062,426 @@ function createErrorObjectFromError(error, data) {
 }
 
 /**
- * Error thrown when a checkpoint operation fails due to invocation-level issues
- * (e.g., 5xx errors, invalid checkpoint token)
- * This will terminate the current Lambda invocation, but the execution can continue with a new invocation
- */
-class CheckpointUnrecoverableInvocationError extends UnrecoverableInvocationError {
-    terminationReason = TerminationReason.CHECKPOINT_FAILED;
-    constructor(message, originalError) {
-        super(message || "Checkpoint operation failed", originalError);
-    }
-}
-/**
- * Error thrown when a checkpoint operation fails due to execution-level issues
- * (e.g., 4xx errors other than invalid checkpoint token)
- * This will terminate the entire execution and cannot be recovered
+ * Error thrown when non-deterministic code is detected during replay
  */
-class CheckpointUnrecoverableExecutionError extends UnrecoverableExecutionError {
-    terminationReason = TerminationReason.CHECKPOINT_FAILED;
-    constructor(message, originalError) {
-        super(message || "Checkpoint operation failed", originalError);
+class NonDeterministicExecutionError extends UnrecoverableExecutionError {
+    terminationReason = TerminationReason.CUSTOM;
+    constructor(message) {
+        super(message);
+        this.name = "NonDeterministicExecutionError";
     }
 }
 
-const STEP_DATA_UPDATED_EVENT = "stepDataUpdated";
-class CheckpointManager {
-    durableExecutionArn;
-    stepData;
-    storage;
-    terminationManager;
-    activeOperationsTracker;
-    stepDataEmitter;
-    logger;
-    pendingCompletions;
-    queue = [];
-    isProcessing = false;
-    currentTaskToken;
-    forceCheckpointPromises = [];
-    queueCompletionResolver = null;
-    queueCompletionTimeout = null;
-    MAX_PAYLOAD_SIZE = 750 * 1024; // 750KB in bytes
-    isTerminating = false;
-    static textEncoder = new TextEncoder();
-    constructor(durableExecutionArn, stepData, storage, terminationManager, activeOperationsTracker, initialTaskToken, stepDataEmitter, logger, pendingCompletions) {
-        this.durableExecutionArn = durableExecutionArn;
-        this.stepData = stepData;
-        this.storage = storage;
-        this.terminationManager = terminationManager;
-        this.activeOperationsTracker = activeOperationsTracker;
-        this.stepDataEmitter = stepDataEmitter;
-        this.logger = logger;
-        this.pendingCompletions = pendingCompletions;
-        this.currentTaskToken = initialTaskToken;
-    }
-    setTerminating() {
-        this.isTerminating = true;
-        log("🛑", "Checkpoint manager marked as terminating");
-    }
-    /**
-     * Checks if a step ID or any of its ancestors has a pending completion
-     */
-    hasPendingAncestorCompletion(stepId) {
-        let currentHashedId = hashId(stepId);
-        while (currentHashedId) {
-            if (this.pendingCompletions.has(currentHashedId)) {
-                return true;
-            }
-            const operation = this.stepData[currentHashedId];
-            currentHashedId = operation?.ParentId;
-        }
-        return false;
-    }
-    async forceCheckpoint() {
-        if (this.isTerminating) {
-            log("⚠️", "Force checkpoint skipped - termination in progress");
-            return new Promise(() => { }); // Never resolves during termination
-        }
-        return new Promise((resolve, reject) => {
-            this.forceCheckpointPromises.push({ resolve, reject });
-            if (!this.isProcessing) {
-                setImmediate(() => {
-                    this.processQueue();
-                });
-            }
-        });
+const validateReplayConsistency = (stepId, currentOperation, checkpointData, context) => {
+    // Skip validation if no checkpoint data exists or if Type is undefined (first execution)
+    if (!checkpointData || !checkpointData.Type) {
+        return;
     }
-    async waitForQueueCompletion() {
-        if (this.queue.length === 0 && !this.isProcessing) {
-            return;
-        }
-        return new Promise((resolve, reject) => {
-            this.queueCompletionResolver = resolve;
-            // Set a timeout to prevent infinite waiting
-            this.queueCompletionTimeout = setTimeout(() => {
-                this.queueCompletionResolver = null;
-                this.queueCompletionTimeout = null;
-                // Clear the queue since it's taking too long
-                this.clearQueue();
-                reject(new Error("Timeout waiting for checkpoint queue completion"));
-            }, 3000); // 3 second timeout
-        });
+    // Validate operation type
+    if (checkpointData.Type !== currentOperation.type) {
+        const error = new NonDeterministicExecutionError(`Non-deterministic execution detected: Operation type mismatch for step "${stepId}". ` +
+            `Expected type "${checkpointData.Type}", but got "${currentOperation.type}". ` +
+            `This indicates non-deterministic control flow in your workflow code.`);
+        terminateForUnrecoverableError(context, error, stepId);
     }
-    clearQueue() {
-        // Silently clear queue - we're terminating so no need to reject promises
-        this.queue = [];
-        this.forceCheckpointPromises = [];
-        // Resolve any waiting queue completion promises since we're clearing
-        this.notifyQueueCompletion();
+    // Validate operation name (including undefined)
+    if (checkpointData.Name !== currentOperation.name) {
+        const error = new NonDeterministicExecutionError(`Non-deterministic execution detected: Operation name mismatch for step "${stepId}". ` +
+            `Expected name "${checkpointData.Name ?? "undefined"}", but got "${currentOperation.name ?? "undefined"}". ` +
+            `This indicates non-deterministic control flow in your workflow code.`);
+        terminateForUnrecoverableError(context, error, stepId);
     }
-    // Alias for backward compatibility with Checkpoint interface
-    async force() {
-        return this.forceCheckpoint();
+    // Validate operation subtype
+    if (checkpointData.SubType !== currentOperation.subType) {
+        const error = new NonDeterministicExecutionError(`Non-deterministic execution detected: Operation subtype mismatch for step "${stepId}". ` +
+            `Expected subtype "${checkpointData.SubType}", but got "${currentOperation.subType}". ` +
+            `This indicates non-deterministic control flow in your workflow code.`);
+        terminateForUnrecoverableError(context, error, stepId);
     }
-    async checkpoint(stepId, data) {
-        if (this.isTerminating) {
-            log("⚠️", "Checkpoint skipped - termination in progress:", { stepId });
-            return new Promise(() => { }); // Never resolves during termination
+};
+
+const createStepHandler = (context, checkpoint, parentContext, createStepId, logger, parentId) => {
+    return (nameOrFn, fnOrOptions, maybeOptions) => {
+        let name;
+        let fn;
+        let options;
+        if (typeof nameOrFn === "string" || nameOrFn === undefined) {
+            name = nameOrFn;
+            fn = fnOrOptions;
+            options = maybeOptions;
         }
-        if (this.activeOperationsTracker) {
-            this.activeOperationsTracker.increment();
+        else {
+            fn = nameOrFn;
+            options = fnOrOptions;
         }
-        return new Promise((resolve, reject) => {
-            if (data.Action === OperationAction.SUCCEED ||
-                data.Action === OperationAction.FAIL) {
-                this.pendingCompletions.add(stepId);
-            }
-            const queuedItem = {
-                stepId,
-                data,
-                resolve: () => {
-                    if (this.activeOperationsTracker) {
-                        this.activeOperationsTracker.decrement();
-                    }
-                    resolve();
-                },
-                reject: (error) => {
-                    if (this.activeOperationsTracker) {
-                        this.activeOperationsTracker.decrement();
-                    }
-                    reject(error);
-                },
-            };
-            this.queue.push(queuedItem);
-            log("📥", "Checkpoint queued:", {
-                stepId,
-                queueLength: this.queue.length,
-                isProcessing: this.isProcessing,
-            });
-            if (!this.isProcessing) {
-                setImmediate(() => {
-                    this.processQueue();
+        const stepId = createStepId();
+        const semantics = options?.semantics || StepSemantics.AtLeastOncePerRetry;
+        const serdes = options?.serdes || defaultSerdes;
+        // Phase 1: Execute step
+        const phase1Promise = (async () => {
+            let stepData = context.getStepData(stepId);
+            validateReplayConsistency(stepId, { type: OperationType.STEP, name, subType: OperationSubType.STEP }, stepData, context);
+            // Check if already completed
+            if (stepData?.Status === OperationStatus.SUCCEEDED) {
+                log("⏭️", "Step already completed:", { stepId });
+                checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED, {
+                    metadata: {
+                        stepId,
+                        name,
+                        type: OperationType.STEP,
+                        subType: OperationSubType.STEP,
+                        parentId,
+                    },
                 });
+                return await safeDeserialize(serdes, stepData.StepDetails?.Result, stepId, name, context.terminationManager, context.durableExecutionArn);
             }
-        });
-    }
-    hasFinishedAncestor(parentId) {
-        if (!parentId) {
-            return false;
-        }
-        let currentHashedId = hashId(parentId);
-        while (currentHashedId) {
-            const parentOperation = this.stepData[currentHashedId];
-            if (parentOperation?.Status === OperationStatus.SUCCEEDED ||
-                parentOperation?.Status === OperationStatus.FAILED) {
-                return true;
-            }
-            currentHashedId = parentOperation?.ParentId;
-        }
-        return false;
-    }
-    classifyCheckpointError(error) {
-        const originalError = error instanceof Error ? error : new Error(String(error));
-        const awsError = error;
-        const statusCode = awsError.$metadata?.httpStatusCode;
-        const errorName = awsError.name;
-        const errorMessage = awsError.message || originalError.message;
-        log("🔍", "Classifying checkpoint error:", {
-            statusCode,
-            errorName,
-            errorMessage,
-        });
-        if (statusCode &&
-            statusCode >= 400 &&
-            statusCode < 500 &&
-            errorName === "InvalidParameterValueException" &&
-            errorMessage.startsWith("Invalid Checkpoint Token")) {
-            return new CheckpointUnrecoverableInvocationError(`Checkpoint failed: ${errorMessage}`, originalError);
-        }
-        if (statusCode &&
-            statusCode >= 400 &&
-            statusCode < 500 &&
-            statusCode !== 429) {
-            return new CheckpointUnrecoverableExecutionError(`Checkpoint failed: ${errorMessage}`, originalError);
-        }
-        return new CheckpointUnrecoverableInvocationError(`Checkpoint failed: ${errorMessage}`, originalError);
-    }
-    async processQueue() {
-        if (this.isProcessing) {
-            return;
-        }
-        const hasQueuedItems = this.queue.length > 0;
-        const hasForceRequests = this.forceCheckpointPromises.length > 0;
-        if (!hasQueuedItems && !hasForceRequests) {
-            return;
-        }
-        this.isProcessing = true;
-        const batch = [];
-        let skippedCount = 0;
-        const baseSize = this.currentTaskToken.length + 100;
-        let currentSize = baseSize;
-        while (this.queue.length > 0) {
-            const nextItem = this.queue[0];
-            const itemSize = CheckpointManager.textEncoder.encode(JSON.stringify(nextItem)).length;
-            if (currentSize + itemSize > this.MAX_PAYLOAD_SIZE && batch.length > 0) {
-                break;
-            }
-            this.queue.shift();
-            if (this.hasFinishedAncestor(nextItem.data.ParentId)) {
-                log("⚠️", "Checkpoint skipped - ancestor finished:", {
-                    stepId: nextItem.stepId,
-                    parentId: nextItem.data.ParentId,
+            // Check if already failed
+            if (stepData?.Status === OperationStatus.FAILED) {
+                checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED, {
+                    metadata: {
+                        stepId,
+                        name,
+                        type: OperationType.STEP,
+                        subType: OperationSubType.STEP,
+                        parentId,
+                    },
                 });
-                skippedCount++;
-                continue;
+                if (stepData.StepDetails?.Error) {
+                    throw DurableOperationError.fromErrorObject(stepData.StepDetails.Error);
+                }
+                throw new StepError("Unknown error");
             }
-            batch.push(nextItem);
-            currentSize += itemSize;
-        }
-        log("🔄", "Processing checkpoint batch:", {
-            batchSize: batch.length,
-            remainingInQueue: this.queue.length,
-            estimatedSize: currentSize,
-            maxSize: this.MAX_PAYLOAD_SIZE,
-        });
-        try {
-            if (batch.length > 0 || this.forceCheckpointPromises.length > 0) {
-                await this.processBatch(batch);
+            // Check if pending retry
+            if (stepData?.Status === OperationStatus.PENDING) {
+                checkpoint.markOperationState(stepId, OperationLifecycleState.RETRY_WAITING, {
+                    metadata: {
+                        stepId,
+                        name,
+                        type: OperationType.STEP,
+                        subType: OperationSubType.STEP,
+                        parentId,
+                    },
+                    endTimestamp: stepData.StepDetails?.NextAttemptTimestamp,
+                });
+                return (async () => {
+                    await checkpoint.waitForRetryTimer(stepId);
+                    stepData = context.getStepData(stepId);
+                    return await executeStepLogic();
+                })();
             }
-            batch.forEach((item) => {
-                if (item.data.Action === OperationAction.SUCCEED ||
-                    item.data.Action === OperationAction.FAIL) {
-                    this.pendingCompletions.delete(item.stepId);
+            // Check for interrupted step with AT_MOST_ONCE_PER_RETRY
+            if (stepData?.Status === OperationStatus.STARTED &&
+                semantics === StepSemantics.AtMostOncePerRetry) {
+                const error = new StepInterruptedError(stepId, name);
+                const currentAttempt = (stepData.StepDetails?.Attempt || 0) + 1;
+                const retryDecision = options?.retryStrategy?.(error, currentAttempt) ??
+                    retryPresets.default(error, currentAttempt);
+                if (!retryDecision.shouldRetry) {
+                    await checkpoint.checkpoint(stepId, {
+                        Id: stepId,
+                        ParentId: parentId,
+                        Action: OperationAction.FAIL,
+                        SubType: OperationSubType.STEP,
+                        Type: OperationType.STEP,
+                        Error: createErrorObjectFromError(error),
+                        Name: name,
+                    });
+                    checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED);
+                    throw DurableOperationError.fromErrorObject(createErrorObjectFromError(error));
                 }
-                item.resolve();
-            });
-            const forcePromises = this.forceCheckpointPromises.splice(0);
-            forcePromises.forEach((promise) => {
-                promise.resolve();
-            });
-            log("✅", "Checkpoint batch processed successfully:", {
-                batchSize: batch.length,
-                skippedCount,
-                forceRequests: forcePromises.length,
-                newTaskToken: this.currentTaskToken,
-            });
-        }
-        catch (error) {
-            log("❌", "Checkpoint batch failed:", {
-                batchSize: batch.length,
-                error,
-            });
-            const checkpointError = this.classifyCheckpointError(error);
-            // Clear remaining queue silently - we're terminating
-            this.clearQueue();
-            this.terminationManager.terminate({
-                reason: TerminationReason.CHECKPOINT_FAILED,
-                message: checkpointError.message,
-                error: checkpointError,
-            });
-        }
-        finally {
-            this.isProcessing = false;
-            if (this.queue.length > 0) {
-                setImmediate(() => {
-                    this.processQueue();
+                await checkpoint.checkpoint(stepId, {
+                    Id: stepId,
+                    ParentId: parentId,
+                    Action: OperationAction.RETRY,
+                    SubType: OperationSubType.STEP,
+                    Type: OperationType.STEP,
+                    Error: createErrorObjectFromError(error),
+                    Name: name,
+                    StepOptions: {
+                        NextAttemptDelaySeconds: retryDecision.delay
+                            ? durationToSeconds(retryDecision.delay)
+                            : 1,
+                    },
                 });
+                checkpoint.markOperationState(stepId, OperationLifecycleState.RETRY_WAITING, {
+                    metadata: {
+                        stepId,
+                        name,
+                        type: OperationType.STEP,
+                        subType: OperationSubType.STEP,
+                        parentId,
+                    },
+                    endTimestamp: context.getStepData(stepId)?.StepDetails?.NextAttemptTimestamp,
+                });
+                return (async () => {
+                    await checkpoint.waitForRetryTimer(stepId);
+                    stepData = context.getStepData(stepId);
+                    return await executeStepLogic();
+                })();
             }
-            else {
-                // Queue is empty and processing is done - notify all waiting promises
-                this.notifyQueueCompletion();
-            }
-        }
-    }
-    notifyQueueCompletion() {
-        if (this.queueCompletionResolver) {
-            if (this.queueCompletionTimeout) {
-                clearTimeout(this.queueCompletionTimeout);
-                this.queueCompletionTimeout = null;
-            }
-            this.queueCompletionResolver();
-            this.queueCompletionResolver = null;
-        }
-    }
-    async processBatch(batch) {
-        const updates = batch.map((item) => {
-            const hashedStepId = hashId(item.stepId);
-            const update = {
-                Type: item.data.Type || "STEP",
-                Action: item.data.Action || "START",
-                ...item.data,
-                Id: hashedStepId,
-                ...(item.data.ParentId && { ParentId: hashId(item.data.ParentId) }),
-            };
-            return update;
-        });
-        const checkpointData = {
-            DurableExecutionArn: this.durableExecutionArn,
-            CheckpointToken: this.currentTaskToken,
-            Updates: updates,
-        };
-        log("⏺️", "Creating checkpoint batch:", {
-            batchSize: updates.length,
-            checkpointToken: this.currentTaskToken,
-            updates: updates.map((u) => ({
-                Id: u.Id,
-                Action: u.Action,
-                Type: u.Type,
-            })),
-        });
-        const response = await this.storage.checkpoint(checkpointData, this.logger);
-        if (response.CheckpointToken) {
-            this.currentTaskToken = response.CheckpointToken;
-        }
-        if (response.NewExecutionState?.Operations) {
-            this.updateStepDataFromCheckpointResponse(response.NewExecutionState.Operations);
-        }
-    }
-    updateStepDataFromCheckpointResponse(operations) {
-        log("🔄", "Updating stepData from checkpoint response:", {
-            operationCount: operations.length,
-            operationIds: operations.map((op) => op.Id).filter(Boolean),
-        });
-        operations.forEach((operation) => {
-            if (operation.Id) {
-                this.stepData[operation.Id] = operation;
-                log("📝", "Updated stepData entry:", operation);
-                this.stepDataEmitter.emit(STEP_DATA_UPDATED_EVENT, operation.Id);
+            return await executeStepLogic();
+            async function executeStepLogic() {
+                stepData = context.getStepData(stepId);
+                if (stepData?.Status !== OperationStatus.STARTED) {
+                    if (semantics === StepSemantics.AtMostOncePerRetry) {
+                        await checkpoint.checkpoint(stepId, {
+                            Id: stepId,
+                            ParentId: parentId,
+                            Action: OperationAction.START,
+                            SubType: OperationSubType.STEP,
+                            Type: OperationType.STEP,
+                            Name: name,
+                        });
+                    }
+                    else {
+                        checkpoint.checkpoint(stepId, {
+                            Id: stepId,
+                            ParentId: parentId,
+                            Action: OperationAction.START,
+                            SubType: OperationSubType.STEP,
+                            Type: OperationType.STEP,
+                            Name: name,
+                        });
+                    }
+                }
+                try {
+                    stepData = context.getStepData(stepId);
+                    const currentAttempt = stepData?.StepDetails?.Attempt || 0;
+                    const stepContext = { logger };
+                    // Mark operation as EXECUTING
+                    checkpoint.markOperationState(stepId, OperationLifecycleState.EXECUTING, {
+                        metadata: {
+                            stepId,
+                            name,
+                            type: OperationType.STEP,
+                            subType: OperationSubType.STEP,
+                            parentId,
+                        },
+                    });
+                    let result;
+                    result = await runWithContext(stepId, parentId, () => fn(stepContext), currentAttempt + 1, DurableExecutionMode.ExecutionMode);
+                    const serializedResult = await safeSerialize(serdes, result, stepId, name, context.terminationManager, context.durableExecutionArn);
+                    await checkpoint.checkpoint(stepId, {
+                        Id: stepId,
+                        ParentId: parentId,
+                        Action: OperationAction.SUCCEED,
+                        SubType: OperationSubType.STEP,
+                        Type: OperationType.STEP,
+                        Payload: serializedResult,
+                        Name: name,
+                    });
+                    checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED);
+                    return await safeDeserialize(serdes, serializedResult, stepId, name, context.terminationManager, context.durableExecutionArn);
+                }
+                catch (error) {
+                    if (isUnrecoverableError(error)) {
+                        return terminateForUnrecoverableError(context, error, name || stepId);
+                    }
+                    stepData = context.getStepData(stepId);
+                    const currentAttempt = (stepData?.StepDetails?.Attempt || 0) + 1;
+                    const retryDecision = options?.retryStrategy?.(error instanceof Error ? error : new Error("Unknown Error"), currentAttempt) ??
+                        retryPresets.default(error instanceof Error ? error : new Error("Unknown Error"), currentAttempt);
+                    if (!retryDecision.shouldRetry) {
+                        await checkpoint.checkpoint(stepId, {
+                            Id: stepId,
+                            ParentId: parentId,
+                            Action: OperationAction.FAIL,
+                            SubType: OperationSubType.STEP,
+                            Type: OperationType.STEP,
+                            Error: createErrorObjectFromError(error),
+                            Name: name,
+                        });
+                        checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED);
+                        throw DurableOperationError.fromErrorObject(createErrorObjectFromError(error));
+                    }
+                    await checkpoint.checkpoint(stepId, {
+                        Id: stepId,
+                        ParentId: parentId,
+                        Action: OperationAction.RETRY,
+                        SubType: OperationSubType.STEP,
+                        Type: OperationType.STEP,
+                        Error: createErrorObjectFromError(error),
+                        Name: name,
+                        StepOptions: {
+                            NextAttemptDelaySeconds: retryDecision.delay
+                                ? durationToSeconds(retryDecision.delay)
+                                : 1,
+                        },
+                    });
+                    checkpoint.markOperationState(stepId, OperationLifecycleState.RETRY_WAITING, {
+                        metadata: {
+                            stepId,
+                            name,
+                            type: OperationType.STEP,
+                            subType: OperationSubType.STEP,
+                            parentId,
+                        },
+                        endTimestamp: context.getStepData(stepId)?.StepDetails?.NextAttemptTimestamp,
+                    });
+                    await checkpoint.waitForRetryTimer(stepId);
+                    return await executeStepLogic();
+                }
             }
+        })();
+        phase1Promise.catch(() => { });
+        return new DurablePromise(async () => {
+            checkpoint.markOperationAwaited(stepId);
+            return await phase1Promise;
         });
-        log("✅", "StepData update completed:", {
-            totalStepDataEntries: Object.keys(this.stepData).length,
-        });
-    }
-    getQueueStatus() {
-        return {
-            queueLength: this.queue.length,
-            isProcessing: this.isProcessing,
-        };
-    }
-}
-
-/**
- * High-level helper that waits for conditions before continuing execution.
- * Uses event-driven approach for both operations completion and status changes.
- */
-async function waitBeforeContinue(options) {
-    const { checkHasRunningOperations, checkStepStatus, checkTimer, scheduledEndTimestamp, stepId, context, hasRunningOperations, operationsEmitter, checkpoint, onAwaitedChange, } = options;
-    const promises = [];
-    const timers = [];
-    const cleanupFns = [];
-    // Cleanup function to clear all timers and listeners
-    const cleanup = () => {
-        timers.forEach((timer) => clearTimeout(timer));
-        cleanupFns.forEach((fn) => fn());
     };
-    // Timer promise - resolves when scheduled time is reached
-    if (checkTimer && scheduledEndTimestamp) {
-        const timerPromise = new Promise((resolve) => {
-            const timeLeft = Number(scheduledEndTimestamp) - Date.now();
-            if (timeLeft > 0) {
-                const timer = setTimeout(() => resolve({ reason: "timer", timerExpired: true }), timeLeft);
-                timers.push(timer);
+};
+
+const createInvokeHandler = (context, checkpoint, createStepId, parentId, checkAndUpdateReplayMode) => {
+    function invokeHandler(nameOrFuncId, funcIdOrInput, inputOrConfig, maybeConfig) {
+        const isNameFirst = typeof funcIdOrInput === "string";
+        const name = isNameFirst ? nameOrFuncId : undefined;
+        const funcId = isNameFirst ? funcIdOrInput : nameOrFuncId;
+        const input = isNameFirst
+            ? inputOrConfig
+            : funcIdOrInput;
+        const config = isNameFirst
+            ? maybeConfig
+            : inputOrConfig;
+        const stepId = createStepId();
+        // Phase 1: Start invoke operation
+        let isCompleted = false;
+        const phase1Promise = (async () => {
+            log("🔗", "Invoke phase 1:", { stepId, name: name || funcId });
+            let stepData = context.getStepData(stepId);
+            // Validate replay consistency
+            validateReplayConsistency(stepId, {
+                type: OperationType.CHAINED_INVOKE,
+                name,
+                subType: OperationSubType.CHAINED_INVOKE,
+            }, stepData, context);
+            // Check if already completed
+            if (stepData?.Status === OperationStatus.SUCCEEDED) {
+                log("⏭️", "Invoke already completed:", { stepId });
+                checkAndUpdateReplayMode?.();
+                checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED, {
+                    metadata: {
+                        stepId,
+                        name,
+                        type: OperationType.CHAINED_INVOKE,
+                        subType: OperationSubType.CHAINED_INVOKE,
+                        parentId,
+                    },
+                });
+                isCompleted = true;
+                return;
             }
-            else {
-                resolve({ reason: "timer", timerExpired: true });
+            // Check if already failed
+            if (stepData?.Status === OperationStatus.FAILED ||
+                stepData?.Status === OperationStatus.TIMED_OUT ||
+                stepData?.Status === OperationStatus.STOPPED) {
+                log("❌", "Invoke already failed:", { stepId });
+                checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED, {
+                    metadata: {
+                        stepId,
+                        name,
+                        type: OperationType.CHAINED_INVOKE,
+                        subType: OperationSubType.CHAINED_INVOKE,
+                        parentId,
+                    },
+                });
+                isCompleted = true;
+                return;
             }
-        });
-        promises.push(timerPromise);
-    }
-    // Operations promise - event-driven approach
-    if (checkHasRunningOperations) {
-        const operationsPromise = new Promise((resolve) => {
-            if (!hasRunningOperations()) {
-                resolve({ reason: "operations" });
+            // Start invoke if not already started
+            if (!stepData) {
+                const serializedPayload = await safeSerialize(config?.payloadSerdes || defaultSerdes, input, stepId, name, context.terminationManager, context.durableExecutionArn);
+                await checkpoint.checkpoint(stepId, {
+                    Id: stepId,
+                    ParentId: parentId,
+                    Action: OperationAction.START,
+                    SubType: OperationSubType.CHAINED_INVOKE,
+                    Type: OperationType.CHAINED_INVOKE,
+                    Name: name,
+                    Payload: serializedPayload,
+                    ChainedInvokeOptions: {
+                        FunctionName: funcId,
+                    },
+                });
             }
-            else {
-                // Event-driven: listen for completion event
-                const handler = () => {
-                    resolve({ reason: "operations" });
-                };
-                operationsEmitter.once(OPERATIONS_COMPLETE_EVENT, handler);
-                cleanupFns.push(() => operationsEmitter.off(OPERATIONS_COMPLETE_EVENT, handler));
+            // Mark as IDLE_NOT_AWAITED
+            checkpoint.markOperationState(stepId, OperationLifecycleState.IDLE_NOT_AWAITED, {
+                metadata: {
+                    stepId,
+                    name,
+                    type: OperationType.CHAINED_INVOKE,
+                    subType: OperationSubType.CHAINED_INVOKE,
+                    parentId,
+                },
+            });
+            log("✅", "Invoke phase 1 complete:", { stepId });
+        })();
+        phase1Promise.catch(() => { });
+        // Phase 2: Wait for completion
+        return new DurablePromise(async () => {
+            await phase1Promise;
+            if (isCompleted) {
+                const stepData = context.getStepData(stepId);
+                if (stepData?.Status === OperationStatus.SUCCEEDED) {
+                    const invokeDetails = stepData.ChainedInvokeDetails;
+                    return await safeDeserialize(config?.resultSerdes || defaultSerdes, invokeDetails?.Result, stepId, name, context.terminationManager, context.durableExecutionArn);
+                }
+                // Handle failure
+                const invokeDetails = stepData?.ChainedInvokeDetails;
+                if (invokeDetails?.Error) {
+                    throw new InvokeError(invokeDetails.Error.ErrorMessage || "Invoke failed", invokeDetails.Error.ErrorMessage
+                        ? new Error(invokeDetails.Error.ErrorMessage)
+                        : undefined, invokeDetails.Error.ErrorData);
+                }
+                else {
+                    throw new InvokeError("Invoke failed");
+                }
             }
-        });
-        promises.push(operationsPromise);
-    }
-    // Step status promise - event-driven approach
-    if (checkStepStatus) {
-        const originalStatus = context.getStepData(stepId)?.Status;
-        const hashedStepId = hashId(stepId);
-        const stepStatusPromise = new Promise((resolve) => {
-            // Check if status already changed
-            const currentStatus = context.getStepData(stepId)?.Status;
-            if (originalStatus !== currentStatus) {
-                resolve({ reason: "status" });
+            log("🔗", "Invoke phase 2:", { stepId });
+            checkpoint.markOperationAwaited(stepId);
+            await checkpoint.waitForStatusChange(stepId);
+            const stepData = context.getStepData(stepId);
+            if (stepData?.Status === OperationStatus.SUCCEEDED) {
+                log("✅", "Invoke completed:", { stepId });
+                checkAndUpdateReplayMode?.();
+                checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED);
+                const invokeDetails = stepData.ChainedInvokeDetails;
+                return await safeDeserialize(config?.resultSerdes || defaultSerdes, invokeDetails?.Result, stepId, name, context.terminationManager, context.durableExecutionArn);
+            }
+            // Handle failure
+            log("❌", "Invoke failed:", { stepId, status: stepData?.Status });
+            checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED);
+            const invokeDetails = stepData?.ChainedInvokeDetails;
+            if (invokeDetails?.Error) {
+                throw new InvokeError(invokeDetails.Error.ErrorMessage || "Invoke failed", invokeDetails.Error.ErrorMessage
+                    ? new Error(invokeDetails.Error.ErrorMessage)
+                    : undefined, invokeDetails.Error.ErrorData);
             }
             else {
-                // Event-driven: listen for step data updates
-                const handler = (updatedStepId) => {
-                    if (updatedStepId === hashedStepId) {
-                        const newStatus = context.getStepData(stepId)?.Status;
-                        if (originalStatus !== newStatus) {
-                            resolve({ reason: "status" });
-                        }
-                    }
-                };
-                operationsEmitter.on(STEP_DATA_UPDATED_EVENT, handler);
-                cleanupFns.push(() => operationsEmitter.off(STEP_DATA_UPDATED_EVENT, handler));
+                throw new InvokeError("Invoke failed");
             }
         });
-        promises.push(stepStatusPromise);
-    }
-    // Awaited change promise - resolves when the callback we set is invoked
-    // Note: This is safe from race conditions because waitBeforeContinue is called
-    // during Phase 1 execution (inside stepHandler), which happens BEFORE the user
-    // can await the DurablePromise. The callback is registered before it can be invoked.
-    if (onAwaitedChange) {
-        const awaitedChangePromise = new Promise((resolve) => {
-            // Register a callback that will be invoked when the promise is awaited
-            onAwaitedChange(() => {
-                resolve({ reason: "status" });
-            });
-        });
-        promises.push(awaitedChangePromise);
-    }
-    // If no conditions provided, return immediately
-    if (promises.length === 0) {
-        return { reason: "timeout" };
-    }
-    // Wait for any condition to be met, then cleanup timers and listeners
-    const result = await Promise.race(promises);
-    cleanup();
-    // If timer expired, force checkpoint to get fresh data from API
-    if (result.reason === "timer" && result.timerExpired && checkpoint) {
-        if (checkpoint.force) {
-            await checkpoint.force();
-        }
-        else if (checkpoint.forceCheckpoint) {
-            await checkpoint.forceCheckpoint();
-        }
-    }
-    return result;
-}
-
-/**
- * Error thrown when non-deterministic code is detected during replay
- */
-class NonDeterministicExecutionError extends UnrecoverableExecutionError {
-    terminationReason = TerminationReason.CUSTOM;
-    constructor(message) {
-        super(message);
-        this.name = "NonDeterministicExecutionError";
     }
-}
+    return invokeHandler;
+};
 
-const validateReplayConsistency = (stepId, currentOperation, checkpointData, context) => {
-    // Skip validation if no checkpoint data exists or if Type is undefined (first execution)
-    if (!checkpointData || !checkpointData.Type) {
-        return;
-    }
-    // Validate operation type
-    if (checkpointData.Type !== currentOperation.type) {
-        const error = new NonDeterministicExecutionError(`Non-deterministic execution detected: Operation type mismatch for step "${stepId}". ` +
-            `Expected type "${checkpointData.Type}", but got "${currentOperation.type}". ` +
-            `This indicates non-deterministic control flow in your workflow code.`);
-        terminateForUnrecoverableError(context, error, stepId);
+// Checkpoint size limit in bytes (256KB)
+const CHECKPOINT_SIZE_LIMIT = 256 * 1024;
+const determineChildReplayMode = (context, stepId) => {
+    const stepData = context.getStepData(stepId);
+    if (!stepData) {
+        return DurableExecutionMode.ExecutionMode;
     }
-    // Validate operation name (including undefined)
-    if (checkpointData.Name !== currentOperation.name) {
-        const error = new NonDeterministicExecutionError(`Non-deterministic execution detected: Operation name mismatch for step "${stepId}". ` +
-            `Expected name "${checkpointData.Name ?? "undefined"}", but got "${currentOperation.name ?? "undefined"}". ` +
-            `This indicates non-deterministic control flow in your workflow code.`);
-        terminateForUnrecoverableError(context, error, stepId);
+    if (stepData.Status === OperationStatus.SUCCEEDED &&
+        stepData.ContextDetails?.ReplayChildren) {
+        return DurableExecutionMode.ReplaySucceededContext;
     }
-    // Validate operation subtype
-    if (checkpointData.SubType !== currentOperation.subType) {
-        const error = new NonDeterministicExecutionError(`Non-deterministic execution detected: Operation subtype mismatch for step "${stepId}". ` +
-            `Expected subtype "${checkpointData.SubType}", but got "${currentOperation.subType}". ` +
-            `This indicates non-deterministic control flow in your workflow code.`);
-        terminateForUnrecoverableError(context, error, stepId);
+    if (stepData.Status === OperationStatus.SUCCEEDED ||
+        stepData.Status === OperationStatus.FAILED) {
+        return DurableExecutionMode.ReplayMode;
     }
+    return DurableExecutionMode.ExecutionMode;
 };
-
-// Special symbol to indicate that the main loop should continue
-const CONTINUE_MAIN_LOOP$1 = Symbol("CONTINUE_MAIN_LOOP");
-const waitForContinuation$1 = async (context, stepId, name, hasRunningOperations, getOperationsEmitter, checkpoint, onAwaitedChange) => {
-    const stepData = context.getStepData(stepId);
-    // Check if there are any ongoing operations
-    if (!hasRunningOperations()) {
-        // No ongoing operations - safe to terminate
-        return terminate(context, TerminationReason.RETRY_SCHEDULED, `Retry scheduled for ${name || stepId}`);
-    }
-    // There are ongoing operations - wait before continuing
-    await waitBeforeContinue({
-        checkHasRunningOperations: true,
-        checkStepStatus: true,
-        checkTimer: true,
-        scheduledEndTimestamp: stepData?.StepDetails?.NextAttemptTimestamp,
-        stepId,
-        context,
-        hasRunningOperations,
-        operationsEmitter: getOperationsEmitter(),
-        checkpoint,
-        onAwaitedChange,
-    });
-    // Return to let the main loop re-evaluate step status
-};
-/**
- * Creates a step handler for executing durable steps with two-phase execution.
- */
-const createStepHandler = (context, checkpoint, parentContext, createStepId, logger, addRunningOperation, removeRunningOperation, hasRunningOperations, getOperationsEmitter, parentId) => {
+const createRunInChildContextHandler = (context, checkpoint, parentContext, createStepId, getParentLogger, createChildContext, parentId) => {
     return (nameOrFn, fnOrOptions, maybeOptions) => {
         let name;
         let fn;
@@ -1693,479 +1495,30 @@ const createStepHandler = (context, checkpoint, parentContext, createStepId, log
             fn = nameOrFn;
             options = fnOrOptions;
         }
-        const stepId = createStepId();
-        log("▶️", "Running step:", { stepId, name, options });
+        const entityId = createStepId();
+        log("🔄", "Running child context:", {
+            entityId,
+            name,
+        });
+        const stepData = context.getStepData(entityId);
+        // Validate replay consistency
+        validateReplayConsistency(entityId, {
+            type: OperationType.CONTEXT,
+            name,
+            subType: options?.subType ||
+                OperationSubType.RUN_IN_CHILD_CONTEXT,
+        }, stepData, context);
         // Two-phase execution: Phase 1 starts immediately, Phase 2 returns result when awaited
-        let isAwaited = false;
-        let waitingCallback;
-        const setWaitingCallback = (cb) => {
-            waitingCallback = cb;
-        };
-        // Phase 1: Start execution immediately and capture result/error
-        const phase1Promise = (async () => {
-            // Main step logic - can be re-executed if step status changes
-            while (true) {
-                try {
-                    const stepData = context.getStepData(stepId);
-                    // Validate replay consistency
-                    validateReplayConsistency(stepId, {
-                        type: OperationType.STEP,
-                        name,
-                        subType: OperationSubType.STEP,
-                    }, stepData, context);
-                    if (stepData?.Status === OperationStatus.SUCCEEDED) {
-                        return await handleCompletedStep(context, stepId, name, options?.serdes);
-                    }
-                    if (stepData?.Status === OperationStatus.FAILED) {
-                        // Return an async rejected promise to ensure it's handled asynchronously
-                        return (async () => {
-                            // Reconstruct the original error from stored ErrorObject
-                            if (stepData.StepDetails?.Error) {
-                                throw DurableOperationError.fromErrorObject(stepData.StepDetails.Error);
-                            }
-                            else {
-                                // Fallback for legacy data without Error field
-                                const errorMessage = stepData?.StepDetails?.Result;
-                                throw new StepError(errorMessage || "Unknown error");
-                            }
-                        })();
-                    }
-                    // If PENDING, wait for timer to complete
-                    if (stepData?.Status === OperationStatus.PENDING) {
-                        await waitForContinuation$1(context, stepId, name, hasRunningOperations, getOperationsEmitter, checkpoint, isAwaited ? undefined : setWaitingCallback);
-                        continue; // Re-evaluate step status after waiting
-                    }
-                    // Check for interrupted step with AT_MOST_ONCE_PER_RETRY semantics
-                    if (stepData?.Status === OperationStatus.STARTED) {
-                        const semantics = options?.semantics || StepSemantics.AtLeastOncePerRetry;
-                        if (semantics === StepSemantics.AtMostOncePerRetry) {
-                            log("⚠️", "Step was interrupted during execution:", {
-                                stepId,
-                                name,
-                            });
-                            const error = new StepInterruptedError(stepId, name);
-                            // Handle the interrupted step as a failure
-                            const currentAttempt = (stepData?.StepDetails?.Attempt || 0) + 1;
-                            let retryDecision;
-                            if (options?.retryStrategy !== undefined) {
-                                retryDecision = options.retryStrategy(error, currentAttempt);
-                            }
-                            else {
-                                retryDecision = retryPresets.default(error, currentAttempt);
-                            }
-                            log("⚠️", "Should Retry Interrupted Step:", {
-                                stepId,
-                                name,
-                                currentAttempt,
-                                shouldRetry: retryDecision.shouldRetry,
-                                delayInSeconds: retryDecision.shouldRetry
-                                    ? retryDecision.delay
-                                        ? durationToSeconds(retryDecision.delay)
-                                        : undefined
-                                    : undefined,
-                            });
-                            if (!retryDecision.shouldRetry) {
-                                // No retry, mark as failed
-                                await checkpoint.checkpoint(stepId, {
-                                    Id: stepId,
-                                    ParentId: parentId,
-                                    Action: OperationAction.FAIL,
-                                    SubType: OperationSubType.STEP,
-                                    Type: OperationType.STEP,
-                                    Error: createErrorObjectFromError(error),
-                                    Name: name,
-                                });
-                                // Reconstruct error from ErrorObject for deterministic behavior
-                                const errorObject = createErrorObjectFromError(error);
-                                throw DurableOperationError.fromErrorObject(errorObject);
-                            }
-                            else {
-                                // Retry
-                                await checkpoint.checkpoint(stepId, {
-                                    Id: stepId,
-                                    ParentId: parentId,
-                                    Action: OperationAction.RETRY,
-                                    SubType: OperationSubType.STEP,
-                                    Type: OperationType.STEP,
-                                    Error: createErrorObjectFromError(error),
-                                    Name: name,
-                                    StepOptions: {
-                                        NextAttemptDelaySeconds: retryDecision.delay
-                                            ? durationToSeconds(retryDecision.delay)
-                                            : 1,
-                                    },
-                                });
-                                await waitForContinuation$1(context, stepId, name, hasRunningOperations, getOperationsEmitter, checkpoint, isAwaited ? undefined : setWaitingCallback);
-                                continue; // Re-evaluate step status after waiting
-                            }
-                        }
-                    }
-                    // Execute step function for READY, STARTED (AtLeastOncePerRetry), or first time (undefined)
-                    const result = await executeStep(context, checkpoint, stepId, name, fn, logger, addRunningOperation, removeRunningOperation, hasRunningOperations, getOperationsEmitter, parentId, options, isAwaited ? undefined : setWaitingCallback);
-                    // If executeStep signals to continue the main loop, do so
-                    if (result === CONTINUE_MAIN_LOOP$1) {
-                        continue;
-                    }
-                    return result;
-                }
-                catch (error) {
-                    // Preserve DurableOperationError instances (StepInterruptedError is handled specifically where it's thrown)
-                    if (error instanceof DurableOperationError) {
-                        throw error;
-                    }
-                    // For any other error from executeStep, wrap it in StepError for consistency
-                    throw new StepError(error instanceof Error ? error.message : "Step failed", error instanceof Error ? error : undefined);
-                }
-            }
-        })();
-        // Attach catch handler to prevent unhandled promise rejections
-        // The error will still be thrown when the DurablePromise is awaited
-        phase1Promise.catch(() => { });
-        // Phase 2: Return DurablePromise that returns Phase 1 result when awaited
-        return new DurablePromise(async () => {
-            // When promise is awaited, mark as awaited and invoke waiting callback
-            isAwaited = true;
-            if (waitingCallback) {
-                waitingCallback();
-            }
-            return await phase1Promise;
-        });
-    };
-};
-const handleCompletedStep = async (context, stepId, stepName, serdes = defaultSerdes) => {
-    log("⏭️", "Step already finished, returning cached result:", { stepId });
-    const stepData = context.getStepData(stepId);
-    const result = stepData?.StepDetails?.Result;
-    return await safeDeserialize(serdes, result, stepId, stepName, context.terminationManager, context.durableExecutionArn);
-};
-const executeStep = async (context, checkpoint, stepId, name, fn, logger, addRunningOperation, removeRunningOperation, hasRunningOperations, getOperationsEmitter, parentId, options, onAwaitedChange) => {
-    // Determine step semantics (default to AT_LEAST_ONCE_PER_RETRY if not specified)
-    const semantics = options?.semantics || StepSemantics.AtLeastOncePerRetry;
-    const serdes = options?.serdes || defaultSerdes;
-    // Checkpoint at start for both semantics (only if not already started)
-    const stepData = context.getStepData(stepId);
-    if (stepData?.Status !== OperationStatus.STARTED) {
-        if (semantics === StepSemantics.AtMostOncePerRetry) {
-            // Wait for checkpoint to complete
-            await checkpoint.checkpoint(stepId, {
-                Id: stepId,
-                ParentId: parentId,
-                Action: OperationAction.START,
-                SubType: OperationSubType.STEP,
-                Type: OperationType.STEP,
-                Name: name,
-            });
-        }
-        else {
-            // Fire and forget for AtLeastOncePerRetry
-            checkpoint.checkpoint(stepId, {
-                Id: stepId,
-                ParentId: parentId,
-                Action: OperationAction.START,
-                SubType: OperationSubType.STEP,
-                Type: OperationType.STEP,
-                Name: name,
-            });
-        }
-    }
-    try {
-        // Get current attempt number for logger enrichment
-        const stepData = context.getStepData(stepId);
-        const currentAttempt = stepData?.StepDetails?.Attempt || 0;
-        // Create step context with enriched logger
-        const stepContext = {
-            logger,
-        };
-        // Execute the step function with stepContext
-        addRunningOperation(stepId);
-        let result;
-        try {
-            result = await runWithContext(stepId, parentId, () => fn(stepContext), 
-            // The attempt that is running is the attempt from the step data (previous step attempt) + 1
-            currentAttempt + 1, 
-            // Alwasy in execution mode when running step operations
-            DurableExecutionMode.ExecutionMode);
-        }
-        finally {
-            removeRunningOperation(stepId);
-        }
-        // Serialize the result for consistency
-        const serializedResult = await safeSerialize(serdes, result, stepId, name, context.terminationManager, context.durableExecutionArn);
-        // Always checkpoint on completion
-        await checkpoint.checkpoint(stepId, {
-            Id: stepId,
-            ParentId: parentId,
-            Action: OperationAction.SUCCEED,
-            SubType: OperationSubType.STEP,
-            Type: OperationType.STEP,
-            Payload: serializedResult,
-            Name: name,
-        });
-        log("✅", "Step completed successfully:", {
-            stepId,
-            name,
-            result,
-            semantics,
-        });
-        // Deserialize the result for consistency with replay behavior
-        return await safeDeserialize(serdes, serializedResult, stepId, name, context.terminationManager, context.durableExecutionArn);
-    }
-    catch (error) {
-        log("❌", "Step failed:", {
-            stepId,
-            name,
-            error,
-            semantics,
-        });
-        // Handle unrecoverable errors - these should not go through retry logic
-        if (isUnrecoverableError(error)) {
-            log("💥", "Unrecoverable error detected:", {
-                stepId,
-                name,
-                error: error.message,
-            });
-            return terminateForUnrecoverableError(context, error, name || stepId);
-        }
-        const stepData = context.getStepData(stepId);
-        const currentAttempt = (stepData?.StepDetails?.Attempt || 0) + 1;
-        let retryDecision;
-        if (options?.retryStrategy !== undefined) {
-            // Use provided retry configuration
-            retryDecision = options.retryStrategy(error instanceof Error ? error : new Error("Unknown Error"), currentAttempt);
-        }
-        else {
-            // Use default retry preset if no config provided
-            retryDecision = retryPresets.default(error instanceof Error ? error : new Error("Unknown Error"), currentAttempt);
-        }
-        log("⚠️", "Should Retry:", {
-            stepId,
-            name,
-            currentAttempt,
-            shouldRetry: retryDecision.shouldRetry,
-            delayInSeconds: retryDecision.shouldRetry
-                ? retryDecision.delay
-                    ? durationToSeconds(retryDecision.delay)
-                    : undefined
-                : undefined,
-            semantics,
-        });
-        if (!retryDecision.shouldRetry) {
-            // No retry
-            await checkpoint.checkpoint(stepId, {
-                Id: stepId,
-                ParentId: parentId,
-                Action: OperationAction.FAIL,
-                SubType: OperationSubType.STEP,
-                Type: OperationType.STEP,
-                Error: createErrorObjectFromError(error),
-                Name: name,
-            });
-            // Reconstruct error from ErrorObject for deterministic behavior
-            const errorObject = createErrorObjectFromError(error);
-            throw DurableOperationError.fromErrorObject(errorObject);
-        }
-        else {
-            // Retry
-            await checkpoint.checkpoint(stepId, {
-                Id: stepId,
-                ParentId: parentId,
-                Action: OperationAction.RETRY,
-                SubType: OperationSubType.STEP,
-                Type: OperationType.STEP,
-                Error: createErrorObjectFromError(error),
-                Name: name,
-                StepOptions: {
-                    NextAttemptDelaySeconds: retryDecision.delay
-                        ? durationToSeconds(retryDecision.delay)
-                        : 1,
-                },
-            });
-            // Wait for continuation and signal main loop to continue
-            await waitForContinuation$1(context, stepId, name, hasRunningOperations, getOperationsEmitter, checkpoint, onAwaitedChange);
-            return CONTINUE_MAIN_LOOP$1;
-        }
-    }
-};
-
-const createInvokeHandler = (context, checkpoint, createStepId, hasRunningOperations, getOperationsEmitter, parentId, checkAndUpdateReplayMode) => {
-    function invokeHandler(nameOrFuncId, funcIdOrInput, inputOrConfig, maybeConfig) {
-        const isNameFirst = typeof funcIdOrInput === "string";
-        const name = isNameFirst ? nameOrFuncId : undefined;
-        const funcId = isNameFirst ? funcIdOrInput : nameOrFuncId;
-        const input = isNameFirst
-            ? inputOrConfig
-            : funcIdOrInput;
-        const config = isNameFirst
-            ? maybeConfig
-            : inputOrConfig;
-        const stepId = createStepId();
-        // Phase 1: Only checkpoint if needed, don't execute full logic
-        const startInvokeOperation = async () => {
-            log("🔗", `Invoke ${name || funcId} (${stepId}) - phase 1`);
-            // Check initial step data for replay consistency validation
-            const initialStepData = context.getStepData(stepId);
-            // Validate replay consistency once before any execution
-            validateReplayConsistency(stepId, {
-                type: OperationType.CHAINED_INVOKE,
-                name,
-                subType: OperationSubType.CHAINED_INVOKE,
-            }, initialStepData, context);
-            // If stepData already exists, phase 1 has nothing to do
-            if (initialStepData) {
-                log("⏸️", `Invoke ${name || funcId} already exists (phase 1)`);
-                return;
-            }
-            // No stepData exists - need to start the invoke operation
-            // Serialize the input payload
-            const serializedPayload = await safeSerialize(config?.payloadSerdes || defaultSerdes, input, stepId, name, context.terminationManager, context.durableExecutionArn);
-            // Create checkpoint for the invoke operation
-            await checkpoint.checkpoint(stepId, {
-                Id: stepId,
-                ParentId: parentId,
-                Action: OperationAction.START,
-                SubType: OperationSubType.CHAINED_INVOKE,
-                Type: OperationType.CHAINED_INVOKE,
-                Name: name,
-                Payload: serializedPayload,
-                ChainedInvokeOptions: {
-                    FunctionName: funcId,
-                },
-            });
-            log("🚀", `Invoke ${name || funcId} started (phase 1)`);
-        };
-        // Phase 2: Execute full logic including waiting and termination
-        const continueInvokeOperation = async () => {
-            log("🔗", `Invoke ${name || funcId} (${stepId}) - phase 2`);
-            // Main invoke logic - can be re-executed if step status changes
-            while (true) {
-                // Check if we have existing step data
-                const stepData = context.getStepData(stepId);
-                if (stepData?.Status === OperationStatus.SUCCEEDED) {
-                    // Return cached result - no need to check for errors in successful operations
-                    const invokeDetails = stepData.ChainedInvokeDetails;
-                    checkAndUpdateReplayMode?.();
-                    return await safeDeserialize(config?.resultSerdes || defaultSerdes, invokeDetails?.Result, stepId, name, context.terminationManager, context.durableExecutionArn);
-                }
-                if (stepData?.Status === OperationStatus.FAILED ||
-                    stepData?.Status === OperationStatus.TIMED_OUT ||
-                    stepData?.Status === OperationStatus.STOPPED) {
-                    // Operation failed, return async rejected promise
-                    const invokeDetails = stepData.ChainedInvokeDetails;
-                    return (async () => {
-                        if (invokeDetails?.Error) {
-                            throw new InvokeError(invokeDetails.Error.ErrorMessage || "Invoke failed", invokeDetails.Error.ErrorMessage
-                                ? new Error(invokeDetails.Error.ErrorMessage)
-                                : undefined, invokeDetails.Error.ErrorData);
-                        }
-                        else {
-                            throw new InvokeError("Invoke failed");
-                        }
-                    })();
-                }
-                if (stepData?.Status === OperationStatus.STARTED) {
-                    // Operation is still running
-                    if (hasRunningOperations()) {
-                        // Phase 2: Wait for other operations
-                        log("⏳", `Invoke ${name || funcId} still in progress, waiting for other operations`);
-                        await waitBeforeContinue({
-                            checkHasRunningOperations: true,
-                            checkStepStatus: true,
-                            checkTimer: false,
-                            stepId,
-                            context,
-                            hasRunningOperations,
-                            operationsEmitter: getOperationsEmitter(),
-                        });
-                        continue; // Re-evaluate status after waiting
-                    }
-                    // No other operations running - terminate
-                    log("⏳", `Invoke ${name || funcId} still in progress, terminating`);
-                    return terminate(context, TerminationReason.OPERATION_TERMINATED, stepId);
-                }
-                // If stepData exists but has an unexpected status, break to avoid infinite loop
-                if (stepData && stepData.Status !== undefined) {
-                    throw new InvokeError(`Unexpected operation status: ${stepData.Status}`);
-                }
-                // This should not happen in phase 2 since phase 1 creates stepData
-                throw new InvokeError("No step data found in phase 2 - this should not happen");
-            }
-        };
-        // Create a promise that tracks phase 1 completion
-        const startInvokePromise = startInvokeOperation()
-            .then(() => {
-            log("✅", "Invoke phase 1 complete:", { stepId, name: name || funcId });
-        })
-            .catch((error) => {
-            log("❌", "Invoke phase 1 error:", { stepId, error: error.message });
-            throw error; // Re-throw to fail phase 1
-        });
-        // Attach catch handler to prevent unhandled promise rejections
-        // The error will still be thrown when the DurablePromise is awaited
-        startInvokePromise.catch(() => { });
-        // Return DurablePromise that will execute phase 2 when awaited
-        return new DurablePromise(async () => {
-            // Wait for phase 1 to complete first
-            await startInvokePromise;
-            // Then execute phase 2
-            return await continueInvokeOperation();
-        });
-    }
-    return invokeHandler;
-};
-
-// Checkpoint size limit in bytes (256KB)
-const CHECKPOINT_SIZE_LIMIT = 256 * 1024;
-const determineChildReplayMode = (context, stepId) => {
-    const stepData = context.getStepData(stepId);
-    if (!stepData) {
-        return DurableExecutionMode.ExecutionMode;
-    }
-    if (stepData.Status === OperationStatus.SUCCEEDED &&
-        stepData.ContextDetails?.ReplayChildren) {
-        return DurableExecutionMode.ReplaySucceededContext;
-    }
-    if (stepData.Status === OperationStatus.SUCCEEDED ||
-        stepData.Status === OperationStatus.FAILED) {
-        return DurableExecutionMode.ReplayMode;
-    }
-    return DurableExecutionMode.ExecutionMode;
-};
-const createRunInChildContextHandler = (context, checkpoint, parentContext, createStepId, getParentLogger, createChildContext, parentId) => {
-    return (nameOrFn, fnOrOptions, maybeOptions) => {
-        let name;
-        let fn;
-        let options;
-        if (typeof nameOrFn === "string" || nameOrFn === undefined) {
-            name = nameOrFn;
-            fn = fnOrOptions;
-            options = maybeOptions;
-        }
-        else {
-            fn = nameOrFn;
-            options = fnOrOptions;
-        }
-        const entityId = createStepId();
-        log("🔄", "Running child context:", {
-            entityId,
-            name,
-        });
-        const stepData = context.getStepData(entityId);
-        // Validate replay consistency
-        validateReplayConsistency(entityId, {
-            type: OperationType.CONTEXT,
-            name,
-            subType: options?.subType ||
-                OperationSubType.RUN_IN_CHILD_CONTEXT,
-        }, stepData, context);
-        // Two-phase execution: Phase 1 starts immediately, Phase 2 returns result when awaited
-        let phase1Result;
-        let phase1Error;
+        let phase1Result;
+        let phase1Error;
         // Phase 1: Start execution immediately and capture result/error
         const phase1Promise = (async () => {
             const currentStepData = context.getStepData(entityId);
             // If already completed, return cached result
             if (currentStepData?.Status === OperationStatus.SUCCEEDED ||
                 currentStepData?.Status === OperationStatus.FAILED) {
+                // Mark this run-in-child-context as finished to prevent descendant operations
+                checkpoint.markAncestorFinished(entityId);
                 return handleCompletedChildContext(context, parentContext, entityId, name, fn, options, getParentLogger, createChildContext);
             }
             // Execute if not completed
@@ -2255,8 +1608,10 @@ const executeChildContext = async (context, checkpoint, parentContext, entityId,
                 limit: CHECKPOINT_SIZE_LIMIT,
             });
         }
+        // Mark this run-in-child-context as finished to prevent descendant operations
+        checkpoint.markAncestorFinished(entityId);
         const subType = options?.subType || OperationSubType.RUN_IN_CHILD_CONTEXT;
-        await checkpoint.checkpoint(entityId, {
+        checkpoint.checkpoint(entityId, {
             Id: entityId,
             ParentId: parentId,
             Action: OperationAction.SUCCEED,
@@ -2278,9 +1633,11 @@ const executeChildContext = async (context, checkpoint, parentContext, entityId,
             name,
             error,
         });
+        // Mark this run-in-child-context as finished to prevent descendant operations
+        checkpoint.markAncestorFinished(entityId);
         // Always checkpoint failures
         const subType = options?.subType || OperationSubType.RUN_IN_CHILD_CONTEXT;
-        await checkpoint.checkpoint(entityId, {
+        checkpoint.checkpoint(entityId, {
             Id: entityId,
             ParentId: parentId,
             Action: OperationAction.FAIL,
@@ -2296,433 +1653,324 @@ const executeChildContext = async (context, checkpoint, parentContext, entityId,
     }
 };
 
-const createWaitHandler = (context, checkpoint, createStepId, hasRunningOperations, getOperationsEmitter, parentId, checkAndUpdateReplayMode) => {
+const createWaitHandler = (context, checkpoint, createStepId, parentId, checkAndUpdateReplayMode) => {
     function waitHandler(nameOrDuration, duration) {
         const isNameFirst = typeof nameOrDuration === "string";
         const actualName = isNameFirst ? nameOrDuration : undefined;
         const actualDuration = isNameFirst ? duration : nameOrDuration;
         const actualSeconds = durationToSeconds(actualDuration);
         const stepId = createStepId();
-        // Shared wait logic for both phases
-        const executeWaitLogic = async (canTerminate) => {
-            log("⏲️", `Wait executing (${canTerminate ? "phase 2" : "phase 1"}):`, {
+        // Phase 1: Start wait operation
+        let isCompleted = false;
+        const phase1Promise = (async () => {
+            log("⏲️", "Wait phase 1:", {
                 stepId,
                 name: actualName,
-                duration: actualDuration,
                 seconds: actualSeconds,
             });
             let stepData = context.getStepData(stepId);
-            // Validate replay consistency once before loop
+            // Validate replay consistency
             validateReplayConsistency(stepId, {
                 type: OperationType.WAIT,
                 name: actualName,
                 subType: OperationSubType.WAIT,
             }, stepData, context);
-            // Main wait logic - can be re-executed if step data changes
-            while (true) {
-                stepData = context.getStepData(stepId);
-                if (stepData?.Status === OperationStatus.SUCCEEDED) {
-                    log("⏭️", "Wait already completed:", { stepId });
-                    checkAndUpdateReplayMode?.();
-                    return;
-                }
-                // Only checkpoint START if we haven't started this wait before
-                if (!stepData) {
-                    await checkpoint.checkpoint(stepId, {
-                        Id: stepId,
-                        ParentId: parentId,
-                        Action: OperationAction.START,
-                        SubType: OperationSubType.WAIT,
-                        Type: OperationType.WAIT,
-                        Name: actualName,
-                        WaitOptions: {
-                            WaitSeconds: actualSeconds,
-                        },
-                    });
-                }
-                // Always refresh stepData to ensure it's up-to-date before proceeding
-                stepData = context.getStepData(stepId);
-                // Check if there are any ongoing operations
-                if (!hasRunningOperations()) {
-                    // Phase 1: Just return without terminating
-                    // Phase 2: Terminate
-                    if (canTerminate) {
-                        return terminate(context, TerminationReason.WAIT_SCHEDULED, `Operation ${actualName || stepId} scheduled to wait`);
-                    }
-                    else {
-                        log("⏸️", "Wait ready but not terminating (phase 1):", { stepId });
-                        return;
-                    }
-                }
-                // There are ongoing operations - wait before continuing
-                await waitBeforeContinue({
-                    checkHasRunningOperations: true,
-                    checkStepStatus: true,
-                    checkTimer: true,
-                    scheduledEndTimestamp: stepData?.WaitDetails?.ScheduledEndTimestamp,
-                    stepId,
-                    context,
-                    hasRunningOperations,
-                    operationsEmitter: getOperationsEmitter(),
-                    checkpoint,
+            // Check if already completed
+            if (stepData?.Status === OperationStatus.SUCCEEDED) {
+                log("⏭️", "Wait already completed:", { stepId });
+                checkAndUpdateReplayMode?.();
+                // Mark as completed
+                checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED, {
+                    metadata: {
+                        stepId,
+                        name: actualName,
+                        type: OperationType.WAIT,
+                        subType: OperationSubType.WAIT,
+                        parentId,
+                    },
                 });
-                // Continue the loop to re-evaluate all conditions from the beginning
+                isCompleted = true;
+                return;
             }
-        };
-        // Create a promise that tracks phase 1 completion
-        const phase1Promise = executeWaitLogic(false).then(() => {
-            log("✅", "Wait phase 1 complete:", { stepId, name: actualName });
-        });
-        // Attach catch handler to prevent unhandled promise rejections
-        // The error will still be thrown when the DurablePromise is awaited
+            // Start wait if not already started
+            if (!stepData) {
+                await checkpoint.checkpoint(stepId, {
+                    Id: stepId,
+                    ParentId: parentId,
+                    Action: OperationAction.START,
+                    SubType: OperationSubType.WAIT,
+                    Type: OperationType.WAIT,
+                    Name: actualName,
+                    WaitOptions: {
+                        WaitSeconds: actualSeconds,
+                    },
+                });
+            }
+            // Refresh stepData after checkpoint
+            stepData = context.getStepData(stepId);
+            // Mark as IDLE_NOT_AWAITED (phase 1 complete, not awaited yet)
+            checkpoint.markOperationState(stepId, OperationLifecycleState.IDLE_NOT_AWAITED, {
+                metadata: {
+                    stepId,
+                    name: actualName,
+                    type: OperationType.WAIT,
+                    subType: OperationSubType.WAIT,
+                    parentId,
+                },
+                endTimestamp: stepData?.WaitDetails?.ScheduledEndTimestamp,
+            });
+            log("✅", "Wait phase 1 complete:", { stepId });
+        })();
+        // Prevent unhandled rejection
         phase1Promise.catch(() => { });
-        // Return DurablePromise that will execute phase 2 when awaited
+        // Phase 2: Wait for completion
         return new DurablePromise(async () => {
-            // Wait for phase 1 to complete first
+            // Wait for phase 1
             await phase1Promise;
-            // Then execute phase 2
-            await executeWaitLogic(true);
+            // If already completed in phase 1, skip phase 2
+            if (isCompleted) {
+                return;
+            }
+            log("⏲️", "Wait phase 2:", { stepId });
+            // Mark as awaited
+            checkpoint.markOperationAwaited(stepId);
+            // Wait for status change
+            await checkpoint.waitForStatusChange(stepId);
+            // Check final status
+            const stepData = context.getStepData(stepId);
+            if (stepData?.Status === OperationStatus.SUCCEEDED) {
+                log("✅", "Wait completed:", { stepId });
+                checkAndUpdateReplayMode?.();
+                // Mark as completed
+                checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED);
+                return;
+            }
+            // Should not reach here, but handle gracefully
+            log("⚠️", "Wait ended with unexpected status:", {
+                stepId,
+                status: stepData?.Status,
+            });
         });
     }
     return waitHandler;
 };
 
-// Special symbol to indicate that the main loop should continue
-const CONTINUE_MAIN_LOOP = Symbol("CONTINUE_MAIN_LOOP");
-const waitForContinuation = async (context, stepId, name, hasRunningOperations, checkpoint, operationsEmitter, onAwaitedChange) => {
-    const stepData = context.getStepData(stepId);
-    // Check if there are any ongoing operations
-    if (!hasRunningOperations()) {
-        // No ongoing operations - safe to terminate
-        return terminate(context, TerminationReason.RETRY_SCHEDULED, `Retry scheduled for ${name || stepId}`);
-    }
-    // There are ongoing operations - wait before continuing
-    await waitBeforeContinue({
-        checkHasRunningOperations: true,
-        checkStepStatus: true,
-        checkTimer: true,
-        scheduledEndTimestamp: stepData?.StepDetails?.NextAttemptTimestamp,
-        stepId,
-        context,
-        hasRunningOperations,
-        operationsEmitter,
-        checkpoint,
-        onAwaitedChange,
-    });
-    // Return to let the main loop re-evaluate step status
-};
-const createWaitForConditionHandler = (context, checkpoint, createStepId, logger, addRunningOperation, removeRunningOperation, hasRunningOperations, getOperationsEmitter, parentId) => {
+const createWaitForConditionHandler = (context, checkpoint, createStepId, logger, parentId) => {
     return (nameOrCheck, checkOrConfig, maybeConfig) => {
-        // Two-phase execution: Phase 1 starts immediately, Phase 2 returns result when awaited
-        let isAwaited = false;
-        let waitingCallback;
-        const setWaitingCallback = (cb) => {
-            waitingCallback = cb;
-        };
-        // Phase 1: Start execution immediately and capture result/error
+        let name;
+        let check;
+        let config;
+        if (typeof nameOrCheck === "string" || nameOrCheck === undefined) {
+            name = nameOrCheck;
+            check = checkOrConfig;
+            config = maybeConfig;
+        }
+        else {
+            check = nameOrCheck;
+            config = checkOrConfig;
+        }
+        if (!config?.waitStrategy || config.initialState === undefined) {
+            throw new Error("waitForCondition requires config with waitStrategy and initialState");
+        }
+        const stepId = createStepId();
+        const serdes = config.serdes || defaultSerdes;
         const phase1Promise = (async () => {
-            let name;
-            let check;
-            let config;
-            // Parse overloaded parameters - validation errors thrown here are async
-            if (typeof nameOrCheck === "string" || nameOrCheck === undefined) {
-                name = nameOrCheck;
-                check = checkOrConfig;
-                config = maybeConfig;
+            let stepData = context.getStepData(stepId);
+            // Check if already completed
+            if (stepData?.Status === OperationStatus.SUCCEEDED) {
+                log("⏭️", "WaitForCondition already completed:", { stepId });
+                checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED, {
+                    metadata: {
+                        stepId,
+                        name,
+                        type: OperationType.STEP,
+                        subType: OperationSubType.WAIT_FOR_CONDITION,
+                        parentId,
+                    },
+                });
+                return await safeDeserialize(serdes, stepData.StepDetails?.Result, stepId, name, context.terminationManager, context.durableExecutionArn);
             }
-            else {
-                check = nameOrCheck;
-                config = checkOrConfig;
+            // Check if already failed
+            if (stepData?.Status === OperationStatus.FAILED) {
+                checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED, {
+                    metadata: {
+                        stepId,
+                        name,
+                        type: OperationType.STEP,
+                        subType: OperationSubType.WAIT_FOR_CONDITION,
+                        parentId,
+                    },
+                });
+                if (stepData.StepDetails?.Error) {
+                    throw DurableOperationError.fromErrorObject(stepData.StepDetails.Error);
+                }
+                throw new WaitForConditionError("waitForCondition failed");
             }
-            if (!config ||
-                !config.waitStrategy ||
-                config.initialState === undefined) {
-                throw new Error("waitForCondition requires config with waitStrategy and initialState");
+            // Check if pending retry
+            if (stepData?.Status === OperationStatus.PENDING) {
+                checkpoint.markOperationState(stepId, OperationLifecycleState.RETRY_WAITING, {
+                    metadata: {
+                        stepId,
+                        name,
+                        type: OperationType.STEP,
+                        subType: OperationSubType.WAIT_FOR_CONDITION,
+                        parentId,
+                    },
+                    endTimestamp: stepData.StepDetails?.NextAttemptTimestamp,
+                });
+                return (async () => {
+                    await checkpoint.waitForRetryTimer(stepId);
+                    stepData = context.getStepData(stepId);
+                    return await executeCheckLogic();
+                })();
             }
-            const stepId = createStepId();
-            log("🔄", "Running waitForCondition:", {
-                stepId,
-                name,
-                config,
-            });
-            // Main waitForCondition logic - can be re-executed if step status changes
-            while (true) {
-                try {
-                    const stepData = context.getStepData(stepId);
-                    // Check if already completed
-                    if (stepData?.Status === OperationStatus.SUCCEEDED) {
-                        return await handleCompletedWaitForCondition(context, stepId, name, config.serdes);
-                    }
-                    if (stepData?.Status === OperationStatus.FAILED) {
-                        // Return an async rejected promise to ensure it's handled asynchronously
-                        return (async () => {
-                            // Reconstruct the original error from stored ErrorObject
-                            if (stepData.StepDetails?.Error) {
-                                throw DurableOperationError.fromErrorObject(stepData.StepDetails.Error);
-                            }
-                            else {
-                                // Fallback for legacy data without Error field
-                                const errorMessage = stepData?.StepDetails?.Result;
-                                throw new WaitForConditionError(errorMessage || "waitForCondition failed");
-                            }
-                        })();
-                    }
-                    // If PENDING, wait for timer to complete
-                    if (stepData?.Status === OperationStatus.PENDING) {
-                        await waitForContinuation(context, stepId, name, hasRunningOperations, checkpoint, getOperationsEmitter(), isAwaited ? undefined : setWaitingCallback);
-                        continue; // Re-evaluate step status after waiting
+            return await executeCheckLogic();
+            async function executeCheckLogic() {
+                stepData = context.getStepData(stepId);
+                // Get current state
+                let currentState;
+                if (stepData?.Status === OperationStatus.STARTED ||
+                    stepData?.Status === OperationStatus.READY) {
+                    const checkpointData = stepData.StepDetails?.Result;
+                    if (checkpointData) {
+                        try {
+                            const serdesContext = {
+                                entityId: stepId,
+                                durableExecutionArn: context.durableExecutionArn,
+                            };
+                            currentState = await serdes.deserialize(checkpointData, serdesContext);
+                        }
+                        catch {
+                            currentState = config.initialState;
+                        }
                     }
-                    // Execute check function for READY, STARTED, or first time (undefined)
-                    const result = await executeWaitForCondition(context, checkpoint, stepId, name, check, config, logger, addRunningOperation, removeRunningOperation, hasRunningOperations, getOperationsEmitter, parentId, isAwaited ? undefined : setWaitingCallback);
-                    // If executeWaitForCondition signals to continue the main loop, do so
-                    if (result === CONTINUE_MAIN_LOOP) {
-                        continue;
+                    else {
+                        currentState = config.initialState;
                     }
-                    return result;
                 }
-                catch (error) {
-                    // For any error from executeWaitForCondition, re-throw it
-                    throw error;
+                else {
+                    currentState = config.initialState;
+                }
+                const currentAttempt = (stepData?.StepDetails?.Attempt ?? 0) + 1;
+                // Checkpoint START if not already started
+                if (stepData?.Status !== OperationStatus.STARTED) {
+                    checkpoint.checkpoint(stepId, {
+                        Id: stepId,
+                        ParentId: parentId,
+                        Action: OperationAction.START,
+                        SubType: OperationSubType.WAIT_FOR_CONDITION,
+                        Type: OperationType.STEP,
+                        Name: name,
+                    });
+                }
+                try {
+                    const waitForConditionContext = {
+                        logger,
+                    };
+                    // Mark operation as EXECUTING
+                    checkpoint.markOperationState(stepId, OperationLifecycleState.EXECUTING, {
+                        metadata: {
+                            stepId,
+                            name,
+                            type: OperationType.STEP,
+                            subType: OperationSubType.WAIT_FOR_CONDITION,
+                            parentId,
+                        },
+                    });
+                    const newState = await runWithContext(stepId, parentId, () => check(currentState, waitForConditionContext), currentAttempt, DurableExecutionMode.ExecutionMode);
+                    const serializedState = await safeSerialize(serdes, newState, stepId, name, context.terminationManager, context.durableExecutionArn);
+                    const deserializedState = await safeDeserialize(serdes, serializedState, stepId, name, context.terminationManager, context.durableExecutionArn);
+                    const decision = config.waitStrategy(deserializedState, currentAttempt);
+                    if (!decision.shouldContinue) {
+                        await checkpoint.checkpoint(stepId, {
+                            Id: stepId,
+                            ParentId: parentId,
+                            Action: OperationAction.SUCCEED,
+                            SubType: OperationSubType.WAIT_FOR_CONDITION,
+                            Type: OperationType.STEP,
+                            Payload: serializedState,
+                            Name: name,
+                        });
+                        checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED);
+                        return deserializedState;
+                    }
+                    await checkpoint.checkpoint(stepId, {
+                        Id: stepId,
+                        ParentId: parentId,
+                        Action: OperationAction.RETRY,
+                        SubType: OperationSubType.WAIT_FOR_CONDITION,
+                        Type: OperationType.STEP,
+                        Payload: serializedState,
+                        Name: name,
+                        StepOptions: {
+                            NextAttemptDelaySeconds: durationToSeconds(decision.delay),
+                        },
+                    });
+                    checkpoint.markOperationState(stepId, OperationLifecycleState.RETRY_WAITING, {
+                        metadata: {
+                            stepId,
+                            name,
+                            type: OperationType.STEP,
+                            subType: OperationSubType.WAIT_FOR_CONDITION,
+                            parentId,
+                        },
+                        endTimestamp: context.getStepData(stepId)?.StepDetails?.NextAttemptTimestamp,
+                    });
+                    await checkpoint.waitForRetryTimer(stepId);
+                    return await executeCheckLogic();
+                }
+                catch (error) {
+                    await checkpoint.checkpoint(stepId, {
+                        Id: stepId,
+                        ParentId: parentId,
+                        Action: OperationAction.FAIL,
+                        SubType: OperationSubType.WAIT_FOR_CONDITION,
+                        Type: OperationType.STEP,
+                        Error: createErrorObjectFromError(error),
+                        Name: name,
+                    });
+                    checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED);
+                    throw DurableOperationError.fromErrorObject(createErrorObjectFromError(error));
                 }
             }
-        })();
-        // Attach catch handler to prevent unhandled promise rejections
-        // The error will still be thrown when the DurablePromise is awaited
-        phase1Promise.catch(() => { });
-        // Phase 2: Return DurablePromise that returns Phase 1 result when awaited
-        return new DurablePromise(async () => {
-            // When promise is awaited, mark as awaited and invoke waiting callback
-            isAwaited = true;
-            if (waitingCallback) {
-                waitingCallback();
-            }
+        })();
+        phase1Promise.catch(() => { });
+        return new DurablePromise(async () => {
+            checkpoint.markOperationAwaited(stepId);
             return await phase1Promise;
         });
     };
 };
-const handleCompletedWaitForCondition = async (context, stepId, stepName, serdes = defaultSerdes) => {
-    log("⏭️", "waitForCondition already finished, returning cached result:", {
-        stepId,
-    });
-    const stepData = context.getStepData(stepId);
-    const result = stepData?.StepDetails?.Result;
-    return await safeDeserialize(serdes, result, stepId, stepName, context.terminationManager, context.durableExecutionArn);
-};
-const executeWaitForCondition = async (context, checkpoint, stepId, name, check, config, logger, addRunningOperation, removeRunningOperation, hasRunningOperations, getOperationsEmitter, parentId, onAwaitedChange) => {
-    const serdes = config.serdes || defaultSerdes;
-    // Get current state from previous checkpoint or use initial state
-    let currentState;
-    const existingOperation = context.getStepData(stepId);
-    if (existingOperation?.Status === OperationStatus.STARTED ||
-        existingOperation?.Status === OperationStatus.READY) {
-        // This is a retry - get state from previous checkpoint
-        const checkpointData = existingOperation.StepDetails?.Result;
-        if (checkpointData) {
-            try {
-                // Try to deserialize the checkpoint data directly
-                const serdesContext = {
-                    entityId: stepId,
-                    durableExecutionArn: context.durableExecutionArn,
-                };
-                currentState = await serdes.deserialize(checkpointData, serdesContext);
-            }
-            catch (error) {
-                log("⚠️", "Failed to deserialize checkpoint data, using initial state:", {
-                    stepId,
-                    name,
-                    error,
-                });
-                currentState = config.initialState;
-            }
-        }
-        else {
-            currentState = config.initialState;
-        }
-    }
-    else {
-        // First execution
-        currentState = config.initialState;
-    }
-    // Get the current attempt number (1-based for wait strategy consistency)
-    const currentAttempt = existingOperation?.StepDetails?.Attempt || 1;
-    // Checkpoint START for observability (fire and forget) - only if not already started
-    const stepData = context.getStepData(stepId);
-    if (stepData?.Status !== OperationStatus.STARTED) {
-        checkpoint.checkpoint(stepId, {
-            Id: stepId,
-            ParentId: parentId,
-            Action: OperationAction.START,
-            SubType: OperationSubType.WAIT_FOR_CONDITION,
-            Type: OperationType.STEP,
-            Name: name,
-        });
-    }
-    try {
-        // Create WaitForConditionContext with enriched logger for the check function
-        const waitForConditionContext = {
-            logger,
-        };
-        // Execute the check function
-        addRunningOperation(stepId);
-        let newState;
-        try {
-            newState = await runWithContext(stepId, parentId, () => check(currentState, waitForConditionContext), currentAttempt + 1, DurableExecutionMode.ExecutionMode);
-        }
-        finally {
-            removeRunningOperation(stepId);
-        }
-        // Serialize the new state for consistency
-        const serializedState = await safeSerialize(serdes, newState, stepId, name, context.terminationManager, context.durableExecutionArn);
-        // Deserialize for consistency with replay behavior
-        const deserializedState = await safeDeserialize(serdes, serializedState, stepId, name, context.terminationManager, context.durableExecutionArn);
-        // Check if condition is met using the wait strategy
-        const decision = config.waitStrategy(deserializedState, currentAttempt);
-        log("🔍", "waitForCondition check completed:", {
-            stepId,
-            name,
-            currentAttempt: currentAttempt,
-            shouldContinue: decision.shouldContinue,
-            delayInSeconds: decision.shouldContinue
-                ? durationToSeconds(decision.delay)
-                : undefined,
-        });
-        if (!decision.shouldContinue) {
-            // Condition is met - complete successfully
-            await checkpoint.checkpoint(stepId, {
-                Id: stepId,
-                ParentId: parentId,
-                Action: OperationAction.SUCCEED,
-                SubType: OperationSubType.WAIT_FOR_CONDITION,
-                Type: OperationType.STEP,
-                Payload: serializedState,
-                Name: name,
-            });
-            log("✅", "waitForCondition completed successfully:", {
-                stepId,
-                name,
-                result: deserializedState,
-                totalAttempts: currentAttempt,
-            });
-            return deserializedState;
-        }
-        else {
-            // Condition not met - schedule retry
-            // Only checkpoint the state, not the attempt number (system handles that)
-            await checkpoint.checkpoint(stepId, {
-                Id: stepId,
-                ParentId: parentId,
-                Action: OperationAction.RETRY,
-                SubType: OperationSubType.WAIT_FOR_CONDITION,
-                Type: OperationType.STEP,
-                Payload: serializedState, // Just the state, not wrapped in an object
-                Name: name,
-                StepOptions: {
-                    NextAttemptDelaySeconds: durationToSeconds(decision.delay),
-                },
-            });
-            // Wait for continuation and signal main loop to continue
-            await waitForContinuation(context, stepId, name, hasRunningOperations, checkpoint, getOperationsEmitter(), onAwaitedChange);
-            return CONTINUE_MAIN_LOOP;
-        }
-    }
-    catch (error) {
-        log("❌", "waitForCondition check function failed:", {
-            stepId,
-            name,
-            error,
-            currentAttempt: currentAttempt,
-        });
-        // Mark as failed - waitForCondition doesn't have its own retry logic for errors
-        // If the check function throws, it's considered a failure
-        await checkpoint.checkpoint(stepId, {
-            Id: stepId,
-            ParentId: parentId,
-            Action: OperationAction.FAIL,
-            SubType: OperationSubType.WAIT_FOR_CONDITION,
-            Type: OperationType.STEP,
-            Error: createErrorObjectFromError(error),
-            Name: name,
-        });
-        // Reconstruct error from ErrorObject for deterministic behavior
-        const errorObject = createErrorObjectFromError(error);
-        throw DurableOperationError.fromErrorObject(errorObject);
-    }
-};
 
-const createCallbackPromise = (context, stepId, stepName, serdes, hasRunningOperations, operationsEmitter, terminationMessage, checkAndUpdateReplayMode) => {
+const createCallbackPromise = (context, checkpoint, stepId, stepName, serdes, checkAndUpdateReplayMode) => {
     return new DurablePromise(async () => {
-        log("🔄", "Callback promise phase 2 executing:", { stepId, stepName });
-        // Main callback logic - can be re-executed if step status changes
-        while (true) {
-            const stepData = context.getStepData(stepId);
-            // Handle case where stepData doesn't exist yet
-            // While Phase 1 should create stepData via checkpoint before Phase 2 starts,
-            // this can be undefined in test scenarios
-            if (!stepData) {
-                log("⚠️", "Step data not found, waiting for callback creation:", {
-                    stepId,
-                });
-                if (hasRunningOperations()) {
-                    await waitBeforeContinue({
-                        checkHasRunningOperations: true,
-                        checkStepStatus: true,
-                        checkTimer: false,
-                        stepId,
-                        context,
-                        hasRunningOperations,
-                        operationsEmitter,
-                    });
-                    continue; // Re-evaluate after waiting
-                }
-                // No other operations and no step data - terminate gracefully
-                log("⏳", "No step data found and no running operations, terminating");
-                return terminate(context, TerminationReason.CALLBACK_PENDING, terminationMessage);
-            }
-            if (stepData.Status === OperationStatus.SUCCEEDED) {
-                const callbackData = stepData.CallbackDetails;
-                if (!callbackData?.CallbackId) {
-                    throw new CallbackError(`No callback ID found for completed callback: ${stepId}`);
-                }
-                const result = await safeDeserialize(serdes, callbackData.Result, stepId, stepName, context.terminationManager, context.durableExecutionArn);
-                // Check and update replay mode after callback completion
-                checkAndUpdateReplayMode();
-                return result;
-            }
-            if (stepData.Status === OperationStatus.FAILED ||
-                stepData.Status === OperationStatus.TIMED_OUT) {
-                const callbackData = stepData.CallbackDetails;
-                const error = callbackData?.Error;
-                if (error) {
-                    const cause = new Error(error.ErrorMessage);
-                    cause.name = error.ErrorType || "Error";
-                    cause.stack = error.StackTrace?.join("\n");
-                    throw new CallbackError(error.ErrorMessage || "Callback failed", cause, error.ErrorData);
-                }
-                throw new CallbackError("Callback failed");
-            }
-            if (stepData.Status === OperationStatus.STARTED) {
-                // Callback is still pending
-                if (hasRunningOperations()) {
-                    // Wait for other operations or callback completion
-                    log("⏳", "Callback still pending, waiting for other operations");
-                    await waitBeforeContinue({
-                        checkHasRunningOperations: true,
-                        checkStepStatus: true,
-                        checkTimer: false,
-                        stepId,
-                        context,
-                        hasRunningOperations,
-                        operationsEmitter,
-                    });
-                    continue; // Re-evaluate status after waiting
-                }
-                // No other operations running - terminate
-                log("⏳", "Callback still pending, terminating");
-                return terminate(context, TerminationReason.CALLBACK_PENDING, terminationMessage);
+        log("🔄", "Callback promise phase 2:", { stepId, stepName });
+        checkpoint.markOperationAwaited(stepId);
+        await checkpoint.waitForStatusChange(stepId);
+        const stepData = context.getStepData(stepId);
+        if (stepData?.Status === OperationStatus.SUCCEEDED) {
+            log("✅", "Callback completed:", { stepId });
+            checkAndUpdateReplayMode();
+            checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED);
+            const callbackData = stepData.CallbackDetails;
+            if (!callbackData) {
+                throw new CallbackError(`No callback data found for completed callback: ${stepId}`);
             }
-            // Should not reach here, but handle unexpected status
-            throw new CallbackError(`Unexpected callback status: ${stepData.Status}`);
+            const result = await safeDeserialize(serdes, callbackData.Result, stepId, stepName, context.terminationManager, context.durableExecutionArn);
+            return result;
         }
+        // Handle failure
+        log("❌", "Callback failed:", { stepId, status: stepData?.Status });
+        checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED);
+        const callbackData = stepData?.CallbackDetails;
+        const error = callbackData?.Error;
+        if (error) {
+            const cause = new Error(error.ErrorMessage);
+            cause.name = error.ErrorType || "Error";
+            cause.stack = error.StackTrace?.join("\n");
+            throw new CallbackError(error.ErrorMessage || "Callback failed", cause, error.ErrorData);
+        }
+        throw new CallbackError("Callback failed");
     });
 };
 
@@ -2730,7 +1978,7 @@ const createPassThroughSerdes = () => ({
     serialize: async (value) => value,
     deserialize: async (data) => data,
 });
-const createCallback = (context, checkpoint, createStepId, hasRunningOperations, getOperationsEmitter, checkAndUpdateReplayMode, parentId) => {
+const createCallback = (context, checkpoint, createStepId, checkAndUpdateReplayMode, parentId) => {
     return (nameOrConfig, maybeConfig) => {
         let name;
         let config;
@@ -2743,82 +1991,99 @@ const createCallback = (context, checkpoint, createStepId, hasRunningOperations,
         }
         const stepId = createStepId();
         const serdes = config?.serdes || createPassThroughSerdes();
-        // Validate replay consistency first
-        const stepData = context.getStepData(stepId);
-        validateReplayConsistency(stepId, {
-            type: OperationType.CALLBACK,
-            name,
-            subType: OperationSubType.CALLBACK,
-        }, stepData, context);
-        // Phase 1: Setup and checkpoint (immediate execution)
-        const setupPromise = (async () => {
-            log("📞", "Creating callback phase 1:", { stepId, name, config });
-            // Handle already completed callbacks
+        // Phase 1: Setup and checkpoint
+        let isCompleted = false;
+        const phase1Promise = (async () => {
+            log("📞", "Callback phase 1:", { stepId, name });
+            let stepData = context.getStepData(stepId);
+            // Validate replay consistency
+            validateReplayConsistency(stepId, {
+                type: OperationType.CALLBACK,
+                name,
+                subType: OperationSubType.CALLBACK,
+            }, stepData, context);
+            // Check if already completed
             if (stepData?.Status === OperationStatus.SUCCEEDED) {
-                log("⏭️", "Callback already completed in phase 1:", { stepId });
-                return { wasNewCallback: false };
+                log("⏭️", "Callback already completed:", { stepId });
+                checkAndUpdateReplayMode();
+                checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED, {
+                    metadata: {
+                        stepId,
+                        name,
+                        type: OperationType.CALLBACK,
+                        subType: OperationSubType.CALLBACK,
+                        parentId,
+                    },
+                });
+                isCompleted = true;
+                return;
             }
+            // Check if already failed
             if (stepData?.Status === OperationStatus.FAILED ||
                 stepData?.Status === OperationStatus.TIMED_OUT) {
-                log("❌", "Callback already failed in phase 1:", { stepId });
-                return { wasNewCallback: false };
+                log("❌", "Callback already failed:", { stepId });
+                checkpoint.markOperationState(stepId, OperationLifecycleState.COMPLETED, {
+                    metadata: {
+                        stepId,
+                        name,
+                        type: OperationType.CALLBACK,
+                        subType: OperationSubType.CALLBACK,
+                        parentId,
+                    },
+                });
+                isCompleted = true;
+                return;
             }
-            // Handle already started callbacks
-            if (stepData?.Status === OperationStatus.STARTED) {
-                log("⏳", "Callback already started in phase 1:", { stepId });
-                return { wasNewCallback: false };
+            // Start callback if not already started
+            if (!stepData) {
+                await checkpoint.checkpoint(stepId, {
+                    Id: stepId,
+                    ParentId: parentId,
+                    Action: "START",
+                    SubType: OperationSubType.CALLBACK,
+                    Type: OperationType.CALLBACK,
+                    Name: name,
+                    CallbackOptions: {
+                        TimeoutSeconds: config?.timeout
+                            ? durationToSeconds(config.timeout)
+                            : undefined,
+                        HeartbeatTimeoutSeconds: config?.heartbeatTimeout
+                            ? durationToSeconds(config.heartbeatTimeout)
+                            : undefined,
+                    },
+                });
+                // Refresh stepData after checkpoint
+                stepData = context.getStepData(stepId);
             }
-            // Create new callback - checkpoint START operation
-            log("🆕", "Creating new callback in phase 1:", { stepId, name });
-            await checkpoint.checkpoint(stepId, {
-                Id: stepId,
-                ParentId: parentId,
-                Action: "START",
-                SubType: OperationSubType.CALLBACK,
-                Type: OperationType.CALLBACK,
-                Name: name,
-                CallbackOptions: {
-                    TimeoutSeconds: config?.timeout
-                        ? durationToSeconds(config.timeout)
-                        : undefined,
-                    HeartbeatTimeoutSeconds: config?.heartbeatTimeout
-                        ? durationToSeconds(config.heartbeatTimeout)
-                        : undefined,
+            // Mark as IDLE_NOT_AWAITED
+            checkpoint.markOperationState(stepId, OperationLifecycleState.IDLE_NOT_AWAITED, {
+                metadata: {
+                    stepId,
+                    name,
+                    type: OperationType.CALLBACK,
+                    subType: OperationSubType.CALLBACK,
+                    parentId,
                 },
             });
-            log("✅", "Callback checkpoint completed in phase 1:", { stepId });
-            return { wasNewCallback: true };
-        })().catch((error) => {
-            log("❌", "Callback phase 1 error:", { stepId, error: error.message });
-            throw error;
-        });
-        // Return DurablePromise that executes phase 2 when awaited
+            log("✅", "Callback phase 1 complete:", { stepId });
+        })();
+        phase1Promise.catch(() => { });
+        // Phase 2: Handle results and create callback promise
         return new DurablePromise(async () => {
-            // Wait for phase 1 to complete
-            const { wasNewCallback } = await setupPromise;
-            // Phase 2: Handle results and create callback promise
-            log("🔄", "Callback phase 2 executing:", { stepId, name });
-            const stepData = context.getStepData(stepId);
-            // Handle completed callbacks
-            if (stepData?.Status === OperationStatus.SUCCEEDED) {
-                const callbackData = stepData.CallbackDetails;
+            await phase1Promise;
+            if (isCompleted) {
+                const stepData = context.getStepData(stepId);
+                const callbackData = stepData?.CallbackDetails;
                 if (!callbackData?.CallbackId) {
-                    throw new CallbackError(`No callback ID found for completed callback: ${stepId}`);
+                    throw new CallbackError(`No callback ID found for callback: ${stepId}`);
                 }
-                const deserializedResult = await safeDeserialize(serdes, callbackData.Result, stepId, name, context.terminationManager, context.durableExecutionArn);
-                const resolvedPromise = new DurablePromise(async () => deserializedResult);
-                // Check and update replay mode after callback completion
-                checkAndUpdateReplayMode();
-                return [resolvedPromise, callbackData.CallbackId];
-            }
-            // Handle failed callbacks
-            if (stepData?.Status === OperationStatus.FAILED ||
-                stepData?.Status === OperationStatus.TIMED_OUT) {
-                const callbackData = stepData.CallbackDetails;
-                if (!callbackData?.CallbackId) {
-                    throw new CallbackError(`No callback ID found for failed callback: ${stepId}`);
+                if (stepData?.Status === OperationStatus.SUCCEEDED) {
+                    const deserializedResult = await safeDeserialize(serdes, callbackData.Result, stepId, name, context.terminationManager, context.durableExecutionArn);
+                    const resolvedPromise = new DurablePromise(async () => deserializedResult);
+                    return [resolvedPromise, callbackData.CallbackId];
                 }
-                const error = stepData.CallbackDetails?.Error;
+                // Handle failure
+                const error = stepData?.CallbackDetails?.Error;
                 const callbackError = error
                     ? (() => {
                         const cause = new Error(error.ErrorMessage);
@@ -2832,25 +2097,15 @@ const createCallback = (context, checkpoint, createStepId, hasRunningOperations,
                 });
                 return [rejectedPromise, callbackData.CallbackId];
             }
-            // Handle started or new callbacks
+            log("📞", "Callback phase 2:", { stepId });
+            const stepData = context.getStepData(stepId);
             const callbackData = stepData?.CallbackDetails;
             if (!callbackData?.CallbackId) {
-                const errorMessage = wasNewCallback
-                    ? `Callback ID not found in stepData after checkpoint: ${stepId}`
-                    : `No callback ID found for started callback: ${stepId}`;
-                throw new CallbackError(errorMessage);
+                throw new CallbackError(`No callback ID found for started callback: ${stepId}`);
             }
             const callbackId = callbackData.CallbackId;
-            // Create callback promise that handles completion
-            const terminationMessage = wasNewCallback
-                ? `Callback ${name || stepId} created and pending external completion`
-                : `Callback ${name || stepId} is pending external completion`;
-            const callbackPromise = createCallbackPromise(context, stepId, name, serdes, hasRunningOperations, getOperationsEmitter(), terminationMessage, checkAndUpdateReplayMode);
-            log("✅", "Callback created successfully in phase 2:", {
-                stepId,
-                name,
-                callbackId,
-            });
+            const callbackPromise = createCallbackPromise(context, checkpoint, stepId, name, serdes, checkAndUpdateReplayMode);
+            log("✅", "Callback created:", { stepId, name, callbackId });
             return [callbackPromise, callbackId];
         });
     };
@@ -3307,6 +2562,42 @@ class ConcurrencyController {
             (childStepData.Status === OperationStatus.SUCCEEDED ||
                 childStepData.Status === OperationStatus.FAILED));
     }
+    getCompletionReason(failureCount, successCount, completedCount, items, config) {
+        // Check tolerance first, before checking if all completed
+        const completion = config.completionConfig;
+        // Handle fail-fast behavior (no completion config or empty completion config)
+        if (!completion) {
+            if (failureCount > 0)
+                return "FAILURE_TOLERANCE_EXCEEDED";
+        }
+        else {
+            const hasAnyCompletionCriteria = Object.values(completion).some((value) => value !== undefined);
+            if (!hasAnyCompletionCriteria) {
+                if (failureCount > 0)
+                    return "FAILURE_TOLERANCE_EXCEEDED";
+            }
+            else {
+                // Check specific tolerance thresholds
+                if (completion.toleratedFailureCount !== undefined &&
+                    failureCount > completion.toleratedFailureCount) {
+                    return "FAILURE_TOLERANCE_EXCEEDED";
+                }
+                if (completion.toleratedFailurePercentage !== undefined) {
+                    const failurePercentage = (failureCount / items.length) * 100;
+                    if (failurePercentage > completion.toleratedFailurePercentage) {
+                        return "FAILURE_TOLERANCE_EXCEEDED";
+                    }
+                }
+            }
+        }
+        // Check other completion reasons
+        if (completedCount === items.length)
+            return "ALL_COMPLETED";
+        if (config.completionConfig?.minSuccessful !== undefined &&
+            successCount >= config.completionConfig.minSuccessful)
+            return "MIN_SUCCESSFUL_REACHED";
+        return "ALL_COMPLETED";
+    }
     async executeItems(items, executor, parentContext, config, durableExecutionMode = DurableExecutionMode.ExecutionMode, entityId, executionContext) {
         // In replay mode, we're reconstructing the result from child contexts
         if (durableExecutionMode === DurableExecutionMode.ReplaySucceededContext) {
@@ -3420,17 +2711,9 @@ class ConcurrencyController {
             completedCount,
             totalCount: resultItems.length,
         });
-        // Reconstruct the completion reason based on replay results
         const successCount = resultItems.filter((item) => item.status === BatchItemStatus.SUCCEEDED).length;
-        const getCompletionReason = () => {
-            if (completedCount === items.length)
-                return "ALL_COMPLETED";
-            if (config.completionConfig?.minSuccessful !== undefined &&
-                successCount >= config.completionConfig.minSuccessful)
-                return "MIN_SUCCESSFUL_REACHED";
-            return "FAILURE_TOLERANCE_EXCEEDED";
-        };
-        return new BatchResultImpl(resultItems, getCompletionReason());
+        const failureCount = completedCount - successCount;
+        return new BatchResultImpl(resultItems, this.getCompletionReason(failureCount, successCount, completedCount, items, config));
     }
     async executeItemsConcurrently(items, executor, parentContext, config) {
         const maxConcurrency = config.maxConcurrency || Infinity;
@@ -3477,13 +2760,8 @@ class ConcurrencyController {
                 }
                 return false;
             };
-            const getCompletionReason = () => {
-                if (completedCount === items.length)
-                    return "ALL_COMPLETED";
-                if (config.completionConfig?.minSuccessful !== undefined &&
-                    successCount >= config.completionConfig.minSuccessful)
-                    return "MIN_SUCCESSFUL_REACHED";
-                return "FAILURE_TOLERANCE_EXCEEDED";
+            const getCompletionReason = (failureCount) => {
+                return this.getCompletionReason(failureCount, successCount, completedCount, items, config);
             };
             const tryStartNext = () => {
                 while (activeCount < maxConcurrency &&
@@ -3554,14 +2832,20 @@ class ConcurrencyController {
                         startedCount: finalBatchItems.filter((item) => item.status === BatchItemStatus.STARTED).length,
                         totalCount: finalBatchItems.length,
                     });
-                    const result = new BatchResultImpl(finalBatchItems, getCompletionReason());
+                    const result = new BatchResultImpl(finalBatchItems, getCompletionReason(failureCount));
                     resolve(result);
                 }
                 else {
                     tryStartNext();
                 }
             };
-            tryStartNext();
+            if (items.length === 0) {
+                log("🎉", `${this.operationName} completed with no items`);
+                resolve(new BatchResultImpl([], getCompletionReason(0)));
+            }
+            else {
+                tryStartNext();
+            }
         });
     }
 }
@@ -3635,338 +2919,992 @@ const createConcurrentExecutionHandler = (context, runInChildContext, skipNextOp
         return new DurablePromise(async () => {
             return await phase1Promise;
         });
-    };
-};
-
-class ModeManagement {
-    captureExecutionState;
-    checkAndUpdateReplayMode;
-    checkForNonResolvingPromise;
-    getDurableExecutionMode;
-    setDurableExecutionMode;
-    constructor(captureExecutionState, checkAndUpdateReplayMode, checkForNonResolvingPromise, getDurableExecutionMode, setDurableExecutionMode) {
-        this.captureExecutionState = captureExecutionState;
-        this.checkAndUpdateReplayMode = checkAndUpdateReplayMode;
-        this.checkForNonResolvingPromise = checkForNonResolvingPromise;
-        this.getDurableExecutionMode = getDurableExecutionMode;
-        this.setDurableExecutionMode = setDurableExecutionMode;
+    };
+};
+
+class ModeManagement {
+    captureExecutionState;
+    checkAndUpdateReplayMode;
+    checkForNonResolvingPromise;
+    getDurableExecutionMode;
+    setDurableExecutionMode;
+    constructor(captureExecutionState, checkAndUpdateReplayMode, checkForNonResolvingPromise, getDurableExecutionMode, setDurableExecutionMode) {
+        this.captureExecutionState = captureExecutionState;
+        this.checkAndUpdateReplayMode = checkAndUpdateReplayMode;
+        this.checkForNonResolvingPromise = checkForNonResolvingPromise;
+        this.getDurableExecutionMode = getDurableExecutionMode;
+        this.setDurableExecutionMode = setDurableExecutionMode;
+    }
+    withModeManagement(operation) {
+        const shouldSwitchToExecutionMode = this.captureExecutionState();
+        this.checkAndUpdateReplayMode();
+        const nonResolvingPromise = this.checkForNonResolvingPromise();
+        if (nonResolvingPromise)
+            return nonResolvingPromise;
+        try {
+            return operation();
+        }
+        finally {
+            if (shouldSwitchToExecutionMode) {
+                this.setDurableExecutionMode(DurableExecutionMode.ExecutionMode);
+            }
+        }
+    }
+    withDurableModeManagement(operation) {
+        const shouldSwitchToExecutionMode = this.captureExecutionState();
+        this.checkAndUpdateReplayMode();
+        const nonResolvingPromise = this.checkForNonResolvingPromise();
+        if (nonResolvingPromise) {
+            return new DurablePromise(async () => {
+                await nonResolvingPromise;
+                // This will never be reached
+                throw new Error("Unreachable code");
+            });
+        }
+        try {
+            return operation();
+        }
+        finally {
+            if (shouldSwitchToExecutionMode) {
+                this.setDurableExecutionMode(DurableExecutionMode.ExecutionMode);
+            }
+        }
+    }
+}
+
+const HASH_LENGTH = 16;
+/**
+ * Creates an MD5 hash of the input string for better performance than SHA-256
+ * @param input - The string to hash
+ * @returns The truncated hexadecimal hash string
+ */
+const hashId = (input) => {
+    return createHash("md5")
+        .update(input)
+        .digest("hex")
+        .substring(0, HASH_LENGTH);
+};
+/**
+ * Helper function to get step data using the original stepId
+ * This function handles the hashing internally so callers don't need to worry about it
+ * @param stepData - The stepData record from context
+ * @param stepId - The original stepId (will be hashed internally)
+ * @returns The operation data or undefined if not found
+ */
+const getStepData = (stepData, stepId) => {
+    const hashedId = hashId(stepId);
+    return stepData[hashedId];
+};
+
+class DurableContextImpl {
+    executionContext;
+    lambdaContext;
+    _stepPrefix;
+    _stepCounter = 0;
+    durableLogger;
+    modeAwareLoggingEnabled = true;
+    checkpoint;
+    durableExecutionMode;
+    _parentId;
+    modeManagement;
+    durableExecution;
+    logger;
+    constructor(executionContext, lambdaContext, durableExecutionMode, inheritedLogger, stepPrefix, durableExecution, parentId) {
+        this.executionContext = executionContext;
+        this.lambdaContext = lambdaContext;
+        this._stepPrefix = stepPrefix;
+        this._parentId = parentId;
+        this.durableExecution = durableExecution;
+        this.durableLogger = inheritedLogger;
+        this.durableLogger.configureDurableLoggingContext?.(this.getDurableLoggingContext());
+        this.logger = this.createModeAwareLogger(inheritedLogger);
+        this.durableExecutionMode = durableExecutionMode;
+        this.checkpoint = durableExecution.checkpointManager;
+        this.modeManagement = new ModeManagement(this.captureExecutionState.bind(this), this.checkAndUpdateReplayMode.bind(this), this.checkForNonResolvingPromise.bind(this), () => this.durableExecutionMode, (mode) => {
+            this.durableExecutionMode = mode;
+        });
+    }
+    getDurableLoggingContext() {
+        return {
+            getDurableLogData: () => {
+                const activeContext = getActiveContext();
+                const result = {
+                    executionArn: this.executionContext.durableExecutionArn,
+                    requestId: this.executionContext.requestId,
+                    tenantId: this.executionContext.tenantId,
+                    operationId: !activeContext || activeContext?.contextId === "root"
+                        ? undefined
+                        : hashId(activeContext.contextId),
+                };
+                if (activeContext?.attempt !== undefined) {
+                    result.attempt = activeContext.attempt;
+                }
+                return result;
+            },
+        };
+    }
+    shouldLog() {
+        const activeContext = getActiveContext();
+        if (!this.modeAwareLoggingEnabled || !activeContext) {
+            return true;
+        }
+        if (activeContext.contextId === "root") {
+            return this.durableExecutionMode === DurableExecutionMode.ExecutionMode;
+        }
+        return (activeContext.durableExecutionMode === DurableExecutionMode.ExecutionMode);
+    }
+    createModeAwareLogger(logger) {
+        const durableContextLogger = {
+            warn: (...args) => {
+                if (this.shouldLog()) {
+                    return logger.warn(...args);
+                }
+            },
+            debug: (...args) => {
+                if (this.shouldLog()) {
+                    return logger.debug(...args);
+                }
+            },
+            info: (...args) => {
+                if (this.shouldLog()) {
+                    return logger.info(...args);
+                }
+            },
+            error: (...args) => {
+                if (this.shouldLog()) {
+                    return logger.error(...args);
+                }
+            },
+        };
+        if ("log" in logger) {
+            durableContextLogger.log = (level, ...args) => {
+                if (this.shouldLog()) {
+                    return logger.log?.(level, ...args);
+                }
+            };
+        }
+        return durableContextLogger;
+    }
+    createStepId() {
+        this._stepCounter++;
+        return this._stepPrefix
+            ? `${this._stepPrefix}-${this._stepCounter}`
+            : `${this._stepCounter}`;
+    }
+    getNextStepId() {
+        const nextCounter = this._stepCounter + 1;
+        return this._stepPrefix
+            ? `${this._stepPrefix}-${nextCounter}`
+            : `${nextCounter}`;
+    }
+    /**
+     * Skips the next operation by incrementing the step counter.
+     * Used internally by concurrent execution handler during replay to skip incomplete items.
+     * @internal
+     */
+    skipNextOperation() {
+        this._stepCounter++;
+    }
+    checkAndUpdateReplayMode() {
+        if (this.durableExecutionMode === DurableExecutionMode.ReplayMode) {
+            const nextStepId = this.getNextStepId();
+            const nextStepData = this.executionContext.getStepData(nextStepId);
+            if (!nextStepData) {
+                this.durableExecutionMode = DurableExecutionMode.ExecutionMode;
+            }
+        }
+    }
+    captureExecutionState() {
+        const wasInReplayMode = this.durableExecutionMode === DurableExecutionMode.ReplayMode;
+        const nextStepId = this.getNextStepId();
+        const stepData = this.executionContext.getStepData(nextStepId);
+        const wasNotFinished = !!(stepData &&
+            stepData.Status !== OperationStatus.SUCCEEDED &&
+            stepData.Status !== OperationStatus.FAILED);
+        return wasInReplayMode && wasNotFinished;
+    }
+    checkForNonResolvingPromise() {
+        if (this.durableExecutionMode === DurableExecutionMode.ReplaySucceededContext) {
+            const nextStepId = this.getNextStepId();
+            const nextStepData = this.executionContext.getStepData(nextStepId);
+            if (nextStepData &&
+                nextStepData.Status !== OperationStatus.SUCCEEDED &&
+                nextStepData.Status !== OperationStatus.FAILED) {
+                return new Promise(() => { }); // Non-resolving promise
+            }
+        }
+        return null;
+    }
+    withModeManagement(operation) {
+        return this.modeManagement.withModeManagement(operation);
+    }
+    withDurableModeManagement(operation) {
+        return this.modeManagement.withDurableModeManagement(operation);
+    }
+    step(nameOrFn, fnOrOptions, maybeOptions) {
+        validateContextUsage(this._stepPrefix, "step", this.executionContext.terminationManager);
+        return this.withDurableModeManagement(() => {
+            const stepHandler = createStepHandler(this.executionContext, this.checkpoint, this.lambdaContext, this.createStepId.bind(this), this.durableLogger, this._parentId);
+            return stepHandler(nameOrFn, fnOrOptions, maybeOptions);
+        });
+    }
+    invoke(nameOrFuncId, funcIdOrInput, inputOrConfig, maybeConfig) {
+        validateContextUsage(this._stepPrefix, "invoke", this.executionContext.terminationManager);
+        return this.withDurableModeManagement(() => {
+            const invokeHandler = createInvokeHandler(this.executionContext, this.checkpoint, this.createStepId.bind(this), this._parentId, this.checkAndUpdateReplayMode.bind(this));
+            return invokeHandler(...[
+                nameOrFuncId,
+                funcIdOrInput,
+                inputOrConfig,
+                maybeConfig,
+            ]);
+        });
+    }
+    runInChildContext(nameOrFn, fnOrOptions, maybeOptions) {
+        validateContextUsage(this._stepPrefix, "runInChildContext", this.executionContext.terminationManager);
+        return this.withDurableModeManagement(() => {
+            const blockHandler = createRunInChildContextHandler(this.executionContext, this.checkpoint, this.lambdaContext, this.createStepId.bind(this), () => this.durableLogger, 
+            // Adapter function to maintain compatibility
+            (executionContext, parentContext, durableExecutionMode, inheritedLogger, stepPrefix, _checkpointToken, parentId) => createDurableContext(executionContext, parentContext, durableExecutionMode, inheritedLogger, stepPrefix, this.durableExecution, parentId), this._parentId);
+            return blockHandler(nameOrFn, fnOrOptions, maybeOptions);
+        });
+    }
+    wait(nameOrDuration, maybeDuration) {
+        validateContextUsage(this._stepPrefix, "wait", this.executionContext.terminationManager);
+        return this.withDurableModeManagement(() => {
+            const waitHandler = createWaitHandler(this.executionContext, this.checkpoint, this.createStepId.bind(this), this._parentId, this.checkAndUpdateReplayMode.bind(this));
+            return typeof nameOrDuration === "string"
+                ? waitHandler(nameOrDuration, maybeDuration)
+                : waitHandler(nameOrDuration);
+        });
+    }
+    /**
+     * Configure logger behavior for this context
+     *
+     * This method allows partial configuration - only the properties provided will be updated.
+     * For example, calling configureLogger(\{ modeAware: false \}) will only change the modeAware
+     * setting without affecting any previously configured custom logger.
+     *
+     * @param config - Logger configuration options including customLogger and modeAware settings (default: modeAware=true)
+     * @example
+     * // Set custom logger and enable mode-aware logging
+     * context.configureLogger(\{ customLogger: myLogger, modeAware: true \});
+     *
+     * // Later, disable mode-aware logging without changing the custom logger
+     * context.configureLogger(\{ modeAware: false \});
+     */
+    configureLogger(config) {
+        if (config.customLogger !== undefined) {
+            this.durableLogger = config.customLogger;
+            this.durableLogger.configureDurableLoggingContext?.(this.getDurableLoggingContext());
+            this.logger = this.createModeAwareLogger(this.durableLogger);
+        }
+        if (config.modeAware !== undefined) {
+            this.modeAwareLoggingEnabled = config.modeAware;
+        }
+    }
+    createCallback(nameOrConfig, maybeConfig) {
+        validateContextUsage(this._stepPrefix, "createCallback", this.executionContext.terminationManager);
+        return this.withDurableModeManagement(() => {
+            const callbackFactory = createCallback(this.executionContext, this.checkpoint, this.createStepId.bind(this), this.checkAndUpdateReplayMode.bind(this), this._parentId);
+            return callbackFactory(nameOrConfig, maybeConfig);
+        });
+    }
+    waitForCallback(nameOrSubmitter, submitterOrConfig, maybeConfig) {
+        validateContextUsage(this._stepPrefix, "waitForCallback", this.executionContext.terminationManager);
+        return this.withDurableModeManagement(() => {
+            const waitForCallbackHandler = createWaitForCallbackHandler(this.executionContext, this.getNextStepId.bind(this), this.runInChildContext.bind(this));
+            return waitForCallbackHandler(nameOrSubmitter, submitterOrConfig, maybeConfig);
+        });
+    }
+    waitForCondition(nameOrCheckFunc, checkFuncOrConfig, maybeConfig) {
+        validateContextUsage(this._stepPrefix, "waitForCondition", this.executionContext.terminationManager);
+        return this.withDurableModeManagement(() => {
+            const waitForConditionHandler = createWaitForConditionHandler(this.executionContext, this.checkpoint, this.createStepId.bind(this), this.durableLogger, this._parentId);
+            return typeof nameOrCheckFunc === "string" ||
+                nameOrCheckFunc === undefined
+                ? waitForConditionHandler(nameOrCheckFunc, checkFuncOrConfig, maybeConfig)
+                : waitForConditionHandler(nameOrCheckFunc, checkFuncOrConfig);
+        });
+    }
+    map(nameOrItems, itemsOrMapFunc, mapFuncOrConfig, maybeConfig) {
+        validateContextUsage(this._stepPrefix, "map", this.executionContext.terminationManager);
+        return this.withDurableModeManagement(() => {
+            const mapHandler = createMapHandler(this.executionContext, this._executeConcurrently.bind(this));
+            return mapHandler(nameOrItems, itemsOrMapFunc, mapFuncOrConfig, maybeConfig);
+        });
+    }
+    parallel(nameOrBranches, branchesOrConfig, maybeConfig) {
+        validateContextUsage(this._stepPrefix, "parallel", this.executionContext.terminationManager);
+        return this.withDurableModeManagement(() => {
+            const parallelHandler = createParallelHandler(this.executionContext, this._executeConcurrently.bind(this));
+            return parallelHandler(nameOrBranches, branchesOrConfig, maybeConfig);
+        });
+    }
+    _executeConcurrently(nameOrItems, itemsOrExecutor, executorOrConfig, maybeConfig) {
+        validateContextUsage(this._stepPrefix, "_executeConcurrently", this.executionContext.terminationManager);
+        return this.withDurableModeManagement(() => {
+            const concurrentExecutionHandler = createConcurrentExecutionHandler(this.executionContext, this.runInChildContext.bind(this), this.skipNextOperation.bind(this));
+            const promise = concurrentExecutionHandler(nameOrItems, itemsOrExecutor, executorOrConfig, maybeConfig);
+            // Prevent unhandled promise rejections
+            promise?.catch(() => { });
+            return promise;
+        });
+    }
+    get promise() {
+        return createPromiseHandler(this.step.bind(this));
+    }
+}
+const createDurableContext = (executionContext, parentContext, durableExecutionMode, inheritedLogger, stepPrefix, durableExecution, parentId) => {
+    return new DurableContextImpl(executionContext, parentContext, durableExecutionMode, inheritedLogger, stepPrefix, durableExecution, parentId);
+};
+
+/**
+ * Error thrown when a checkpoint operation fails due to invocation-level issues
+ * (e.g., 5xx errors, invalid checkpoint token)
+ * This will terminate the current Lambda invocation, but the execution can continue with a new invocation
+ */
+class CheckpointUnrecoverableInvocationError extends UnrecoverableInvocationError {
+    terminationReason = TerminationReason.CHECKPOINT_FAILED;
+    constructor(message, originalError) {
+        super(message || "Checkpoint operation failed", originalError);
+    }
+}
+/**
+ * Error thrown when a checkpoint operation fails due to execution-level issues
+ * (e.g., 4xx errors other than invalid checkpoint token)
+ * This will terminate the entire execution and cannot be recovered
+ */
+class CheckpointUnrecoverableExecutionError extends UnrecoverableExecutionError {
+    terminationReason = TerminationReason.CHECKPOINT_FAILED;
+    constructor(message, originalError) {
+        super(message || "Checkpoint operation failed", originalError);
+    }
+}
+
+const STEP_DATA_UPDATED_EVENT = "stepDataUpdated";
+const TERMINAL_STATUSES = [
+    OperationStatus.SUCCEEDED,
+    OperationStatus.CANCELLED,
+    OperationStatus.FAILED,
+    OperationStatus.STOPPED,
+    OperationStatus.TIMED_OUT,
+];
+class CheckpointManager {
+    durableExecutionArn;
+    stepData;
+    storage;
+    terminationManager;
+    stepDataEmitter;
+    logger;
+    finishedAncestors;
+    queue = [];
+    isProcessing = false;
+    currentTaskToken;
+    forceCheckpointPromises = [];
+    queueCompletionResolver = null;
+    MAX_PAYLOAD_SIZE = 750 * 1024; // 750KB in bytes
+    MAX_ITEMS_IN_BATCH = 250;
+    isTerminating = false;
+    static textEncoder = new TextEncoder();
+    // Operation lifecycle tracking
+    operations = new Map();
+    // Termination cooldown
+    terminationTimer = null;
+    terminationReason = null;
+    TERMINATION_COOLDOWN_MS = 50;
+    constructor(durableExecutionArn, stepData, storage, terminationManager, initialTaskToken, stepDataEmitter, logger, finishedAncestors) {
+        this.durableExecutionArn = durableExecutionArn;
+        this.stepData = stepData;
+        this.storage = storage;
+        this.terminationManager = terminationManager;
+        this.stepDataEmitter = stepDataEmitter;
+        this.logger = logger;
+        this.finishedAncestors = finishedAncestors;
+        this.currentTaskToken = initialTaskToken;
+    }
+    setTerminating() {
+        this.isTerminating = true;
+        log("🛑", "Checkpoint manager marked as terminating");
+    }
+    /**
+     * Mark an ancestor as finished (for run-in-child-context operations)
+     */
+    markAncestorFinished(stepId) {
+        this.finishedAncestors.add(stepId);
+    }
+    /**
+     * Extract parent ID from hierarchical stepId (e.g., "1-2-3" -\> "1-2")
+     */
+    getParentId(stepId) {
+        const lastDashIndex = stepId.lastIndexOf("-");
+        return lastDashIndex > 0 ? stepId.substring(0, lastDashIndex) : undefined;
+    }
+    /**
+     * Checks if any ancestor of the given stepId is finished
+     * Only applies to operations that are descendants of run-in-child-context operations
+     */
+    hasFinishedAncestor(stepId) {
+        // Only use getParentId to avoid mixing hashed and original stepIds
+        let currentParentId = this.getParentId(stepId);
+        while (currentParentId) {
+            // Check if this ancestor is finished
+            if (this.finishedAncestors.has(currentParentId)) {
+                return true;
+            }
+            // Move up to the next ancestor using hierarchical stepId
+            currentParentId = this.getParentId(currentParentId);
+        }
+        return false;
+    }
+    async forceCheckpoint() {
+        if (this.isTerminating) {
+            log("⚠️", "Force checkpoint skipped - termination in progress");
+            return new Promise(() => { }); // Never resolves during termination
+        }
+        return new Promise((resolve, reject) => {
+            this.forceCheckpointPromises.push({ resolve, reject });
+            if (!this.isProcessing) {
+                setImmediate(() => {
+                    this.processQueue();
+                });
+            }
+        });
+    }
+    async waitForQueueCompletion() {
+        if (this.queue.length === 0 && !this.isProcessing) {
+            return;
+        }
+        return new Promise((resolve) => {
+            this.queueCompletionResolver = resolve;
+        });
+    }
+    clearQueue() {
+        // Silently clear queue - we're terminating so no need to reject promises
+        this.queue = [];
+        this.forceCheckpointPromises = [];
+        // Resolve any waiting queue completion promises since we're clearing
+        this.notifyQueueCompletion();
+    }
+    // Alias for backward compatibility with Checkpoint interface
+    async force() {
+        return this.forceCheckpoint();
+    }
+    async checkpoint(stepId, data) {
+        if (this.isTerminating) {
+            log("⚠️", "Checkpoint skipped - termination in progress:", { stepId });
+            return new Promise(() => { }); // Never resolves during termination
+        }
+        // Check if any ancestor is finished - if so, don't queue and don't resolve
+        if (this.hasFinishedAncestor(stepId)) {
+            log("⚠️", "Checkpoint skipped - ancestor already finished:", { stepId });
+            return new Promise(() => { }); // Never resolves when ancestor is finished
+        }
+        return new Promise((resolve, reject) => {
+            const queuedItem = {
+                stepId,
+                data,
+                resolve: () => {
+                    resolve();
+                },
+                reject: (error) => {
+                    reject(error);
+                },
+            };
+            this.queue.push(queuedItem);
+            log("📥", "Checkpoint queued:", {
+                stepId,
+                queueLength: this.queue.length,
+                isProcessing: this.isProcessing,
+            });
+            if (!this.isProcessing) {
+                setImmediate(() => {
+                    this.processQueue();
+                });
+            }
+        });
+    }
+    classifyCheckpointError(error) {
+        const originalError = error instanceof Error ? error : new Error(String(error));
+        const awsError = error;
+        const statusCode = awsError.$metadata?.httpStatusCode;
+        const errorName = awsError.name;
+        const errorMessage = awsError.message || originalError.message;
+        log("🔍", "Classifying checkpoint error:", {
+            statusCode,
+            errorName,
+            errorMessage,
+        });
+        if (statusCode &&
+            statusCode >= 400 &&
+            statusCode < 500 &&
+            errorName === "InvalidParameterValueException" &&
+            errorMessage.startsWith("Invalid Checkpoint Token")) {
+            return new CheckpointUnrecoverableInvocationError(`Checkpoint failed: ${errorMessage}`, originalError);
+        }
+        if (statusCode &&
+            statusCode >= 400 &&
+            statusCode < 500 &&
+            statusCode !== 429) {
+            return new CheckpointUnrecoverableExecutionError(`Checkpoint failed: ${errorMessage}`, originalError);
+        }
+        return new CheckpointUnrecoverableInvocationError(`Checkpoint failed: ${errorMessage}`, originalError);
     }
-    withModeManagement(operation) {
-        const shouldSwitchToExecutionMode = this.captureExecutionState();
-        this.checkAndUpdateReplayMode();
-        const nonResolvingPromise = this.checkForNonResolvingPromise();
-        if (nonResolvingPromise)
-            return nonResolvingPromise;
-        try {
-            return operation();
+    async processQueue() {
+        if (this.isProcessing) {
+            return;
         }
-        finally {
-            if (shouldSwitchToExecutionMode) {
-                this.setDurableExecutionMode(DurableExecutionMode.ExecutionMode);
+        const hasQueuedItems = this.queue.length > 0;
+        const hasForceRequests = this.forceCheckpointPromises.length > 0;
+        if (!hasQueuedItems && !hasForceRequests) {
+            return;
+        }
+        this.isProcessing = true;
+        const batch = [];
+        const baseSize = this.currentTaskToken.length + 100;
+        let currentSize = baseSize;
+        while (this.queue.length > 0) {
+            const nextItem = this.queue[0];
+            const itemSize = CheckpointManager.textEncoder.encode(JSON.stringify(nextItem)).length;
+            if ((currentSize + itemSize > this.MAX_PAYLOAD_SIZE ||
+                batch.length >= this.MAX_ITEMS_IN_BATCH) &&
+                batch.length > 0) {
+                break;
             }
+            this.queue.shift();
+            batch.push(nextItem);
+            currentSize += itemSize;
         }
-    }
-    withDurableModeManagement(operation) {
-        const shouldSwitchToExecutionMode = this.captureExecutionState();
-        this.checkAndUpdateReplayMode();
-        const nonResolvingPromise = this.checkForNonResolvingPromise();
-        if (nonResolvingPromise) {
-            return new DurablePromise(async () => {
-                await nonResolvingPromise;
-                // This will never be reached
-                throw new Error("Unreachable code");
+        log("🔄", "Processing checkpoint batch:", {
+            batchSize: batch.length,
+            remainingInQueue: this.queue.length,
+            estimatedSize: currentSize,
+            maxSize: this.MAX_PAYLOAD_SIZE,
+        });
+        try {
+            if (batch.length > 0 || this.forceCheckpointPromises.length > 0) {
+                await this.processBatch(batch);
+            }
+            batch.forEach((item) => {
+                item.resolve();
+            });
+            const forcePromises = this.forceCheckpointPromises.splice(0);
+            forcePromises.forEach((promise) => {
+                promise.resolve();
+            });
+            log("✅", "Checkpoint batch processed successfully:", {
+                batchSize: batch.length,
+                forceRequests: forcePromises.length,
+                newTaskToken: this.currentTaskToken,
             });
         }
-        try {
-            return operation();
+        catch (error) {
+            log("❌", "Checkpoint batch failed:", {
+                batchSize: batch.length,
+                error,
+            });
+            const checkpointError = this.classifyCheckpointError(error);
+            // Clear remaining queue silently - we're terminating
+            this.clearQueue();
+            this.terminationManager.terminate({
+                reason: TerminationReason.CHECKPOINT_FAILED,
+                message: checkpointError.message,
+                error: checkpointError,
+            });
         }
         finally {
-            if (shouldSwitchToExecutionMode) {
-                this.setDurableExecutionMode(DurableExecutionMode.ExecutionMode);
+            this.isProcessing = false;
+            if (this.queue.length > 0) {
+                setImmediate(() => {
+                    this.processQueue();
+                });
+            }
+            else {
+                // Queue is empty and processing is done - notify all waiting promises
+                this.notifyQueueCompletion();
             }
         }
     }
-}
-
-class DurableContextImpl {
-    executionContext;
-    lambdaContext;
-    _stepPrefix;
-    _stepCounter = 0;
-    durableLogger;
-    modeAwareLoggingEnabled = true;
-    runningOperations = new Set();
-    operationsEmitter = new EventEmitter();
-    checkpoint;
-    durableExecutionMode;
-    _parentId;
-    modeManagement;
-    durableExecution;
-    logger;
-    constructor(executionContext, lambdaContext, durableExecutionMode, inheritedLogger, stepPrefix, durableExecution, parentId) {
-        this.executionContext = executionContext;
-        this.lambdaContext = lambdaContext;
-        this._stepPrefix = stepPrefix;
-        this._parentId = parentId;
-        this.durableExecution = durableExecution;
-        this.durableLogger = inheritedLogger;
-        this.durableLogger.configureDurableLoggingContext?.(this.getDurableLoggingContext());
-        this.logger = this.createModeAwareLogger(inheritedLogger);
-        this.durableExecutionMode = durableExecutionMode;
-        this.checkpoint = durableExecution.checkpointManager;
-        this.modeManagement = new ModeManagement(this.captureExecutionState.bind(this), this.checkAndUpdateReplayMode.bind(this), this.checkForNonResolvingPromise.bind(this), () => this.durableExecutionMode, (mode) => {
-            this.durableExecutionMode = mode;
-        });
-    }
-    getDurableLoggingContext() {
-        return {
-            getDurableLogData: () => {
-                const activeContext = getActiveContext();
-                const result = {
-                    executionArn: this.executionContext.durableExecutionArn,
-                    requestId: this.executionContext.requestId,
-                    tenantId: this.executionContext.tenantId,
-                    operationId: !activeContext || activeContext?.contextId === "root"
-                        ? undefined
-                        : hashId(activeContext.contextId),
-                };
-                if (activeContext?.attempt !== undefined) {
-                    result.attempt = activeContext.attempt;
-                }
-                return result;
-            },
-        };
-    }
-    shouldLog() {
-        const activeContext = getActiveContext();
-        if (!this.modeAwareLoggingEnabled || !activeContext) {
-            return true;
-        }
-        if (activeContext.contextId === "root") {
-            return this.durableExecutionMode === DurableExecutionMode.ExecutionMode;
+    notifyQueueCompletion() {
+        if (this.queueCompletionResolver) {
+            this.queueCompletionResolver();
+            this.queueCompletionResolver = null;
         }
-        return (activeContext.durableExecutionMode === DurableExecutionMode.ExecutionMode);
     }
-    createModeAwareLogger(logger) {
-        const durableContextLogger = {
-            warn: (...args) => {
-                if (this.shouldLog()) {
-                    return logger.warn(...args);
-                }
-            },
-            debug: (...args) => {
-                if (this.shouldLog()) {
-                    return logger.debug(...args);
-                }
-            },
-            info: (...args) => {
-                if (this.shouldLog()) {
-                    return logger.info(...args);
-                }
-            },
-            error: (...args) => {
-                if (this.shouldLog()) {
-                    return logger.error(...args);
-                }
-            },
-        };
-        if ("log" in logger) {
-            durableContextLogger.log = (level, ...args) => {
-                if (this.shouldLog()) {
-                    return logger.log?.(level, ...args);
-                }
+    async processBatch(batch) {
+        const updates = batch.map((item) => {
+            const hashedStepId = hashId(item.stepId);
+            const update = {
+                Type: item.data.Type || "STEP",
+                Action: item.data.Action || "START",
+                ...item.data,
+                Id: hashedStepId,
+                ...(item.data.ParentId && { ParentId: hashId(item.data.ParentId) }),
             };
+            return update;
+        });
+        const checkpointData = {
+            DurableExecutionArn: this.durableExecutionArn,
+            CheckpointToken: this.currentTaskToken,
+            Updates: updates,
+        };
+        log("⏺️", "Creating checkpoint batch:", {
+            batchSize: updates.length,
+            checkpointToken: this.currentTaskToken,
+            updates: updates.map((u) => ({
+                Id: u.Id,
+                Action: u.Action,
+                Type: u.Type,
+            })),
+        });
+        const response = await this.storage.checkpoint(checkpointData, this.logger);
+        if (response.CheckpointToken) {
+            this.currentTaskToken = response.CheckpointToken;
+        }
+        if (response.NewExecutionState?.Operations) {
+            this.updateStepDataFromCheckpointResponse(response.NewExecutionState.Operations);
         }
-        return durableContextLogger;
-    }
-    createStepId() {
-        this._stepCounter++;
-        return this._stepPrefix
-            ? `${this._stepPrefix}-${this._stepCounter}`
-            : `${this._stepCounter}`;
-    }
-    getNextStepId() {
-        const nextCounter = this._stepCounter + 1;
-        return this._stepPrefix
-            ? `${this._stepPrefix}-${nextCounter}`
-            : `${nextCounter}`;
     }
-    /**
-     * Skips the next operation by incrementing the step counter.
-     * Used internally by concurrent execution handler during replay to skip incomplete items.
-     * @internal
-     */
-    skipNextOperation() {
-        this._stepCounter++;
+    updateStepDataFromCheckpointResponse(operations) {
+        log("🔄", "Updating stepData from checkpoint response:", {
+            operationCount: operations.length,
+            operationIds: operations.map((op) => op.Id).filter(Boolean),
+        });
+        operations.forEach((operation) => {
+            if (operation.Id) {
+                // Check if status changed
+                const oldStatus = this.stepData[operation.Id]?.Status;
+                const newStatus = operation.Status;
+                this.stepData[operation.Id] = operation;
+                log("📝", "Updated stepData entry:", operation);
+                this.stepDataEmitter.emit(STEP_DATA_UPDATED_EVENT, operation.Id);
+                // If status changed and we have a waiting promise, resolve it
+                if (oldStatus !== newStatus) {
+                    this.resolveWaitingOperation(operation.Id);
+                }
+            }
+        });
+        log("✅", "StepData update completed:", {
+            totalStepDataEntries: Object.keys(this.stepData).length,
+        });
     }
-    checkAndUpdateReplayMode() {
-        if (this.durableExecutionMode === DurableExecutionMode.ReplayMode) {
-            const nextStepId = this.getNextStepId();
-            const nextStepData = this.executionContext.getStepData(nextStepId);
-            if (!nextStepData) {
-                this.durableExecutionMode = DurableExecutionMode.ExecutionMode;
+    resolveWaitingOperation(hashedStepId) {
+        // Find operation by hashed ID in our operations map
+        for (const [stepId, op] of this.operations.entries()) {
+            if (hashId(stepId) === hashedStepId && op.resolver) {
+                log("✅", `Resolving waiting operation ${stepId} due to status change`);
+                op.resolver();
+                op.resolver = undefined;
+                if (op.timer) {
+                    clearTimeout(op.timer);
+                    op.timer = undefined;
+                }
+                break;
             }
         }
     }
-    captureExecutionState() {
-        const wasInReplayMode = this.durableExecutionMode === DurableExecutionMode.ReplayMode;
-        const nextStepId = this.getNextStepId();
-        const stepData = this.executionContext.getStepData(nextStepId);
-        const wasNotFinished = !!(stepData &&
-            stepData.Status !== OperationStatus.SUCCEEDED &&
-            stepData.Status !== OperationStatus.FAILED);
-        return wasInReplayMode && wasNotFinished;
+    getQueueStatus() {
+        return {
+            queueLength: this.queue.length,
+            isProcessing: this.isProcessing,
+        };
     }
-    checkForNonResolvingPromise() {
-        if (this.durableExecutionMode === DurableExecutionMode.ReplaySucceededContext) {
-            const nextStepId = this.getNextStepId();
-            const nextStepData = this.executionContext.getStepData(nextStepId);
-            if (nextStepData &&
-                nextStepData.Status !== OperationStatus.SUCCEEDED &&
-                nextStepData.Status !== OperationStatus.FAILED) {
-                return new Promise(() => { }); // Non-resolving promise
+    // ===== New Lifecycle & Termination Methods =====
+    markOperationState(stepId, state, options) {
+        let op = this.operations.get(stepId);
+        if (!op) {
+            // First call - create operation
+            if (!options?.metadata) {
+                throw new Error(`metadata required on first call for ${stepId}`);
             }
+            op = {
+                stepId,
+                state,
+                metadata: options.metadata,
+                endTimestamp: options.endTimestamp,
+            };
+            this.operations.set(stepId, op);
         }
-        return null;
-    }
-    addRunningOperation(stepId) {
-        this.runningOperations.add(stepId);
-    }
-    removeRunningOperation(stepId) {
-        this.runningOperations.delete(stepId);
-        if (this.runningOperations.size === 0) {
-            this.operationsEmitter.emit(OPERATIONS_COMPLETE_EVENT);
+        else {
+            // Update existing operation
+            op.state = state;
+            if (options?.endTimestamp !== undefined) {
+                op.endTimestamp = options.endTimestamp;
+            }
+        }
+        // Cleanup if transitioning to COMPLETED
+        if (state === OperationLifecycleState.COMPLETED) {
+            this.cleanupOperation(stepId);
+        }
+        // Check if we should terminate
+        // Don't check for IDLE_NOT_AWAITED - operation might be awaited later or intentionally not awaited
+        if (state !== OperationLifecycleState.IDLE_NOT_AWAITED) {
+            this.checkAndTerminate();
         }
     }
-    hasRunningOperations() {
-        return this.runningOperations.size > 0;
-    }
-    getOperationsEmitter() {
-        return this.operationsEmitter;
-    }
-    withModeManagement(operation) {
-        return this.modeManagement.withModeManagement(operation);
-    }
-    withDurableModeManagement(operation) {
-        return this.modeManagement.withDurableModeManagement(operation);
-    }
-    step(nameOrFn, fnOrOptions, maybeOptions) {
-        validateContextUsage(this._stepPrefix, "step", this.executionContext.terminationManager);
-        return this.withDurableModeManagement(() => {
-            const stepHandler = createStepHandler(this.executionContext, this.checkpoint, this.lambdaContext, this.createStepId.bind(this), this.durableLogger, this.addRunningOperation.bind(this), this.removeRunningOperation.bind(this), this.hasRunningOperations.bind(this), this.getOperationsEmitter.bind(this), this._parentId);
-            return stepHandler(nameOrFn, fnOrOptions, maybeOptions);
+    waitForRetryTimer(stepId) {
+        const op = this.operations.get(stepId);
+        if (!op) {
+            throw new Error(`Operation ${stepId} not found`);
+        }
+        if (op.state !== OperationLifecycleState.RETRY_WAITING) {
+            throw new Error(`Operation ${stepId} must be in RETRY_WAITING state, got ${op.state}`);
+        }
+        // Resolve immediately if the step was completed already
+        const stepData = this.stepData[hashId(stepId)];
+        if (stepData?.Status && TERMINAL_STATUSES.includes(stepData.Status)) {
+            return Promise.resolve();
+        }
+        // Start timer with polling
+        this.startTimerWithPolling(stepId, op.endTimestamp);
+        // Return promise that resolves when status changes
+        return new Promise((resolve) => {
+            op.resolver = resolve;
         });
     }
-    invoke(nameOrFuncId, funcIdOrInput, inputOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "invoke", this.executionContext.terminationManager);
-        return this.withDurableModeManagement(() => {
-            const invokeHandler = createInvokeHandler(this.executionContext, this.checkpoint, this.createStepId.bind(this), this.hasRunningOperations.bind(this), this.getOperationsEmitter.bind(this), this._parentId, this.checkAndUpdateReplayMode.bind(this));
-            return invokeHandler(...[
-                nameOrFuncId,
-                funcIdOrInput,
-                inputOrConfig,
-                maybeConfig,
-            ]);
+    waitForStatusChange(stepId) {
+        const op = this.operations.get(stepId);
+        if (!op) {
+            throw new Error(`Operation ${stepId} not found`);
+        }
+        if (op.state !== OperationLifecycleState.IDLE_AWAITED) {
+            throw new Error(`Operation ${stepId} must be in IDLE_AWAITED state, got ${op.state}`);
+        }
+        // Resolve immediately if the step was completed already
+        const stepData = this.stepData[hashId(stepId)];
+        if (stepData?.Status && TERMINAL_STATUSES.includes(stepData.Status)) {
+            return Promise.resolve();
+        }
+        // Start timer with polling
+        this.startTimerWithPolling(stepId, op.endTimestamp);
+        // Return promise that resolves when status changes
+        return new Promise((resolve) => {
+            op.resolver = resolve;
         });
     }
-    runInChildContext(nameOrFn, fnOrOptions, maybeOptions) {
-        validateContextUsage(this._stepPrefix, "runInChildContext", this.executionContext.terminationManager);
-        return this.withDurableModeManagement(() => {
-            const blockHandler = createRunInChildContextHandler(this.executionContext, this.checkpoint, this.lambdaContext, this.createStepId.bind(this), () => this.durableLogger, 
-            // Adapter function to maintain compatibility
-            (executionContext, parentContext, durableExecutionMode, inheritedLogger, stepPrefix, _checkpointToken, parentId) => createDurableContext(executionContext, parentContext, durableExecutionMode, inheritedLogger, stepPrefix, this.durableExecution, parentId), this._parentId);
-            return blockHandler(nameOrFn, fnOrOptions, maybeOptions);
-        });
+    markOperationAwaited(stepId) {
+        const op = this.operations.get(stepId);
+        if (!op) {
+            log("⚠️", `Cannot mark operation as awaited: ${stepId} not found`);
+            return;
+        }
+        // Transition IDLE_NOT_AWAITED → IDLE_AWAITED
+        if (op.state === OperationLifecycleState.IDLE_NOT_AWAITED) {
+            op.state = OperationLifecycleState.IDLE_AWAITED;
+            log("📍", `Operation marked as awaited: ${stepId}`);
+            // Check if we should terminate now that operation is awaited
+            this.checkAndTerminate();
+        }
     }
-    wait(nameOrDuration, maybeDuration) {
-        validateContextUsage(this._stepPrefix, "wait", this.executionContext.terminationManager);
-        return this.withDurableModeManagement(() => {
-            const waitHandler = createWaitHandler(this.executionContext, this.checkpoint, this.createStepId.bind(this), this.hasRunningOperations.bind(this), this.getOperationsEmitter.bind(this), this._parentId, this.checkAndUpdateReplayMode.bind(this));
-            return typeof nameOrDuration === "string"
-                ? waitHandler(nameOrDuration, maybeDuration)
-                : waitHandler(nameOrDuration);
-        });
+    getOperationState(stepId) {
+        return this.operations.get(stepId)?.state;
+    }
+    getAllOperations() {
+        return new Map(this.operations);
+    }
+    // ===== Private Helper Methods =====
+    cleanupOperation(stepId) {
+        const op = this.operations.get(stepId);
+        if (!op)
+            return;
+        // Clear timer
+        if (op.timer) {
+            clearTimeout(op.timer);
+            op.timer = undefined;
+        }
+        // Clear resolver
+        op.resolver = undefined;
+    }
+    cleanupAllOperations() {
+        for (const op of this.operations.values()) {
+            if (op.timer) {
+                clearTimeout(op.timer);
+                op.timer = undefined;
+            }
+            op.resolver = undefined;
+        }
     }
     /**
-     * Configure logger behavior for this context
-     *
-     * This method allows partial configuration - only the properties provided will be updated.
-     * For example, calling configureLogger(\{ modeAware: false \}) will only change the modeAware
-     * setting without affecting any previously configured custom logger.
-     *
-     * @param config - Logger configuration options including customLogger and modeAware settings (default: modeAware=true)
-     * @example
-     * // Set custom logger and enable mode-aware logging
-     * context.configureLogger(\{ customLogger: myLogger, modeAware: true \});
-     *
-     * // Later, disable mode-aware logging without changing the custom logger
-     * context.configureLogger(\{ modeAware: false \});
+     * Determines if the function should terminate.
+     * @returns TerminationReason if the function should terminate, or undefined if the function should not terminate
      */
-    configureLogger(config) {
-        if (config.customLogger !== undefined) {
-            this.durableLogger = config.customLogger;
-            this.durableLogger.configureDurableLoggingContext?.(this.getDurableLoggingContext());
-            this.logger = this.createModeAwareLogger(this.durableLogger);
+    shouldTerminate() {
+        // Rule 1: Can't terminate if checkpoint queue is not empty
+        if (this.queue.length > 0) {
+            return undefined;
         }
-        if (config.modeAware !== undefined) {
-            this.modeAwareLoggingEnabled = config.modeAware;
+        // Rule 2: Can't terminate if checkpoint is currently processing
+        if (this.isProcessing) {
+            return undefined;
         }
+        // Rule 3: Can't terminate if there are pending force checkpoint promises
+        if (this.forceCheckpointPromises.length > 0) {
+            return undefined;
+        }
+        const allOps = Array.from(this.operations.values());
+        // Rule 4: Can't terminate if any operation is EXECUTING
+        const hasExecuting = allOps.some((op) => op.state === OperationLifecycleState.EXECUTING);
+        if (hasExecuting) {
+            return undefined;
+        }
+        // Rule 5: Clean up operations whose ancestors are complete or pending completion
+        for (const op of allOps) {
+            if (op.state === OperationLifecycleState.RETRY_WAITING ||
+                op.state === OperationLifecycleState.IDLE_NOT_AWAITED ||
+                op.state === OperationLifecycleState.IDLE_AWAITED) {
+                // Use the original stepId from metadata, not the potentially hashed op.stepId
+                const originalStepId = op.metadata.stepId;
+                if (this.hasFinishedAncestor(originalStepId)) {
+                    log("🧹", `Cleaning up operation with completed ancestor: ${originalStepId}`);
+                    this.cleanupOperation(op.stepId);
+                    this.operations.delete(op.stepId);
+                }
+            }
+        }
+        // Re-check operations after cleanup
+        const remainingOps = Array.from(this.operations.values());
+        // Determine if we should terminate
+        const hasWaiting = remainingOps.some((op) => op.state === OperationLifecycleState.RETRY_WAITING ||
+            op.state === OperationLifecycleState.IDLE_NOT_AWAITED ||
+            op.state === OperationLifecycleState.IDLE_AWAITED);
+        if (hasWaiting) {
+            return this.determineTerminationReason(remainingOps);
+        }
+        return undefined;
     }
-    createCallback(nameOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "createCallback", this.executionContext.terminationManager);
-        return this.withDurableModeManagement(() => {
-            const callbackFactory = createCallback(this.executionContext, this.checkpoint, this.createStepId.bind(this), this.hasRunningOperations.bind(this), this.getOperationsEmitter.bind(this), this.checkAndUpdateReplayMode.bind(this), this._parentId);
-            return callbackFactory(nameOrConfig, maybeConfig);
-        });
-    }
-    waitForCallback(nameOrSubmitter, submitterOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "waitForCallback", this.executionContext.terminationManager);
-        return this.withDurableModeManagement(() => {
-            const waitForCallbackHandler = createWaitForCallbackHandler(this.executionContext, this.getNextStepId.bind(this), this.runInChildContext.bind(this));
-            return waitForCallbackHandler(nameOrSubmitter, submitterOrConfig, maybeConfig);
-        });
-    }
-    waitForCondition(nameOrCheckFunc, checkFuncOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "waitForCondition", this.executionContext.terminationManager);
-        return this.withDurableModeManagement(() => {
-            const waitForConditionHandler = createWaitForConditionHandler(this.executionContext, this.checkpoint, this.createStepId.bind(this), this.durableLogger, this.addRunningOperation.bind(this), this.removeRunningOperation.bind(this), this.hasRunningOperations.bind(this), this.getOperationsEmitter.bind(this), this._parentId);
-            return typeof nameOrCheckFunc === "string" ||
-                nameOrCheckFunc === undefined
-                ? waitForConditionHandler(nameOrCheckFunc, checkFuncOrConfig, maybeConfig)
-                : waitForConditionHandler(nameOrCheckFunc, checkFuncOrConfig);
-        });
-    }
-    map(nameOrItems, itemsOrMapFunc, mapFuncOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "map", this.executionContext.terminationManager);
-        return this.withDurableModeManagement(() => {
-            const mapHandler = createMapHandler(this.executionContext, this._executeConcurrently.bind(this));
-            return mapHandler(nameOrItems, itemsOrMapFunc, mapFuncOrConfig, maybeConfig);
-        });
+    checkAndTerminate() {
+        const terminationReason = this.shouldTerminate();
+        if (terminationReason) {
+            this.scheduleTermination(terminationReason);
+            return;
+        }
+        this.abortTermination();
+    }
+    abortTermination() {
+        if (this.terminationTimer) {
+            clearTimeout(this.terminationTimer);
+            this.terminationTimer = null;
+            this.terminationReason = null;
+            log("🔄", "Termination aborted - conditions changed");
+        }
     }
-    parallel(nameOrBranches, branchesOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "parallel", this.executionContext.terminationManager);
-        return this.withDurableModeManagement(() => {
-            const parallelHandler = createParallelHandler(this.executionContext, this._executeConcurrently.bind(this));
-            return parallelHandler(nameOrBranches, branchesOrConfig, maybeConfig);
+    scheduleTermination(reason) {
+        // If already scheduled with same reason, don't reschedule
+        if (this.terminationTimer && this.terminationReason === reason) {
+            return;
+        }
+        // Clear any existing timer
+        this.abortTermination();
+        // Schedule new termination
+        this.terminationReason = reason;
+        log("⏱️", "Scheduling termination", {
+            reason,
+            cooldownMs: this.TERMINATION_COOLDOWN_MS,
         });
+        this.terminationTimer = setTimeout(() => {
+            if (!this.shouldTerminate()) {
+                log("🔄", "Termination conditions no longer valid after cooldown, aborting termination");
+                this.abortTermination();
+                return;
+            }
+            this.executeTermination(reason);
+        }, this.TERMINATION_COOLDOWN_MS);
+    }
+    executeTermination(reason) {
+        log("🛑", "Executing termination after cooldown", { reason });
+        // Clear timer
+        this.terminationTimer = null;
+        this.terminationReason = null;
+        // Cleanup all operations before terminating
+        this.cleanupAllOperations();
+        // Call termination manager directly
+        this.terminationManager.terminate({ reason });
+    }
+    determineTerminationReason(ops) {
+        // Priority: RETRY_SCHEDULED > WAIT_SCHEDULED > CALLBACK_PENDING
+        if (ops.some((op) => op.state === OperationLifecycleState.RETRY_WAITING &&
+            op.metadata.subType === "Step")) {
+            return TerminationReason.RETRY_SCHEDULED;
+        }
+        if (ops.some((op) => (op.state === OperationLifecycleState.IDLE_NOT_AWAITED ||
+            op.state === OperationLifecycleState.IDLE_AWAITED) &&
+            op.metadata.subType === "Wait")) {
+            return TerminationReason.WAIT_SCHEDULED;
+        }
+        return TerminationReason.CALLBACK_PENDING;
     }
-    _executeConcurrently(nameOrItems, itemsOrExecutor, executorOrConfig, maybeConfig) {
-        validateContextUsage(this._stepPrefix, "_executeConcurrently", this.executionContext.terminationManager);
-        return this.withDurableModeManagement(() => {
-            const concurrentExecutionHandler = createConcurrentExecutionHandler(this.executionContext, this.runInChildContext.bind(this), this.skipNextOperation.bind(this));
-            const promise = concurrentExecutionHandler(nameOrItems, itemsOrExecutor, executorOrConfig, maybeConfig);
-            // Prevent unhandled promise rejections
-            promise?.catch(() => { });
-            return promise;
-        });
+    startTimerWithPolling(stepId, endTimestamp) {
+        const op = this.operations.get(stepId);
+        if (!op)
+            return;
+        let delay;
+        if (endTimestamp) {
+            // Ensure endTimestamp is a Date object
+            const timestamp = endTimestamp instanceof Date ? endTimestamp : new Date(endTimestamp);
+            // Wait until endTimestamp
+            delay = Math.max(0, timestamp.getTime() - Date.now());
+        }
+        else {
+            // No timestamp, start polling immediately (1 second delay)
+            delay = 1000;
+        }
+        // Initialize poll count and start time for this operation
+        if (!op.pollCount) {
+            op.pollCount = 0;
+            op.pollStartTime = Date.now();
+        }
+        op.timer = setTimeout(() => {
+            this.forceRefreshAndCheckStatus(stepId);
+        }, delay);
     }
-    get promise() {
-        return createPromiseHandler(this.step.bind(this));
+    async forceRefreshAndCheckStatus(stepId) {
+        const op = this.operations.get(stepId);
+        if (!op)
+            return;
+        // Check if we've exceeded max polling duration (15 minutes)
+        const MAX_POLL_DURATION_MS = 15 * 60 * 1000; // 15 minutes
+        if (op.pollStartTime &&
+            Date.now() - op.pollStartTime > MAX_POLL_DURATION_MS) {
+            // Stop polling after 15 minutes to prevent indefinite resource consumption.
+            // We don't resolve or reject the promise because the handler cannot continue
+            // without a status change. The execution will remain suspended until the
+            // operation completes or the Lambda times out.
+            log("⏱️", `Max polling duration (15 min) exceeded for ${stepId}, stopping poll`);
+            if (op.timer) {
+                clearTimeout(op.timer);
+                op.timer = undefined;
+            }
+            return;
+        }
+        // Get old status before refresh
+        const oldStatus = this.stepData[hashId(stepId)]?.Status;
+        // Force checkpoint to refresh state from backend
+        await this.forceCheckpoint();
+        // Get new status after refresh
+        const newStatus = this.stepData[hashId(stepId)]?.Status;
+        // Check if status changed
+        if (newStatus !== oldStatus) {
+            // Status changed, resolve the waiting promise
+            log("✅", `Status changed for ${stepId}: ${oldStatus} → ${newStatus}`);
+            op.resolver?.();
+            op.resolver = undefined;
+            // Clear timer
+            if (op.timer) {
+                clearTimeout(op.timer);
+                op.timer = undefined;
+            }
+        }
+        else {
+            // Status not changed yet, poll again with incremental backoff
+            // Start at 1s, increase by 1s each poll, max 10s
+            op.pollCount = (op.pollCount || 0) + 1;
+            const nextDelay = Math.min(op.pollCount * 1000, 10000);
+            op.timer = setTimeout(() => {
+                this.forceRefreshAndCheckStatus(stepId);
+            }, nextDelay);
+        }
     }
 }
-const createDurableContext = (executionContext, parentContext, durableExecutionMode, inheritedLogger, stepPrefix, durableExecution, parentId) => {
-    return new DurableContextImpl(executionContext, parentContext, durableExecutionMode, inheritedLogger, stepPrefix, durableExecution, parentId);
-};
 
 /*
 Second Approach (Promise-based):
@@ -4260,43 +4198,6 @@ const createDefaultLogger = (executionContext) => {
     return new DefaultLogger(executionContext);
 };
 
-/**
- * Tracks active async operations to prevent premature termination
- */
-class ActiveOperationsTracker {
-    activeCount = 0;
-    /**
-     * Increment the counter when starting an async operation
-     */
-    increment() {
-        this.activeCount++;
-    }
-    /**
-     * Decrement the counter when an async operation completes
-     */
-    decrement() {
-        this.activeCount = Math.max(0, this.activeCount - 1);
-    }
-    /**
-     * Check if there are any active operations
-     */
-    hasActive() {
-        return this.activeCount > 0;
-    }
-    /**
-     * Get the current count of active operations
-     */
-    getCount() {
-        return this.activeCount;
-    }
-    /**
-     * Reset the counter (useful for testing)
-     */
-    reset() {
-        this.activeCount = 0;
-    }
-}
-
 let defaultLambdaClient;
 /**
  * Durable execution client which uses an API-based LambdaClient
@@ -4416,6 +4317,20 @@ class DurableExecutionInvocationInputWithClient {
         this.DurableExecutionArn = params.DurableExecutionArn;
         this.CheckpointToken = params.CheckpointToken;
     }
+    static isInstance(event) {
+        if (event instanceof DurableExecutionInvocationInputWithClient) {
+            return true;
+        }
+        return !!(typeof event === "object" &&
+            event &&
+            event.toString() ===
+                "[object DurableExecutionInvocationInputWithClient]" &&
+            "durableExecutionClient" in event &&
+            event.constructor.name === "DurableExecutionInvocationInputWithClient");
+    }
+    get [Symbol.toStringTag]() {
+        return "DurableExecutionInvocationInputWithClient";
+    }
 }
 
 const initializeExecutionContext = async (event, context, lambdaClient) => {
@@ -4425,7 +4340,7 @@ const initializeExecutionContext = async (event, context, lambdaClient) => {
     const durableExecutionArn = event.DurableExecutionArn;
     const durableExecutionClient = 
     // Allow passing arbitrary durable clients if the input is a custom class
-    event instanceof DurableExecutionInvocationInputWithClient
+    DurableExecutionInvocationInputWithClient.isInstance(event)
         ? event.durableExecutionClient
         : new DurableExecutionApiClient(lambdaClient);
     // Create logger for initialization errors using existing logger factory
@@ -4464,7 +4379,6 @@ const initializeExecutionContext = async (event, context, lambdaClient) => {
             durableExecutionClient,
             _stepData: stepData,
             terminationManager: new TerminationManager(),
-            activeOperationsTracker: new ActiveOperationsTracker(),
             durableExecutionArn,
             pendingCompletions: new Set(),
             getStepData(stepId) {
@@ -4483,7 +4397,7 @@ const LAMBDA_RESPONSE_SIZE_LIMIT = 6 * 1024 * 1024 - 50; // 6MB in bytes, minus
 async function runHandler(event, context, executionContext, durableExecutionMode, checkpointToken, handler) {
     // Create checkpoint manager and step data emitter
     const stepDataEmitter = new EventEmitter();
-    const checkpointManager = new CheckpointManager(executionContext.durableExecutionArn, executionContext._stepData, executionContext.durableExecutionClient, executionContext.terminationManager, executionContext.activeOperationsTracker, checkpointToken, stepDataEmitter, createDefaultLogger(executionContext), executionContext.pendingCompletions);
+    const checkpointManager = new CheckpointManager(executionContext.durableExecutionArn, executionContext._stepData, executionContext.durableExecutionClient, executionContext.terminationManager, checkpointToken, stepDataEmitter, createDefaultLogger(executionContext), new Set());
     // Set the checkpoint terminating callback on the termination manager
     executionContext.terminationManager.setCheckpointTerminatingCallback(() => {
         checkpointManager.setTerminating();
@@ -4585,6 +4499,14 @@ async function runHandler(event, context, executionContext, durableExecutionMode
                     Payload: serializedResult, // Reuse the already serialized result
                 });
                 log("✅", "Large result successfully checkpointed");
+                // Wait for any pending checkpoints to complete before returning
+                try {
+                    await durableExecution.checkpointManager.waitForQueueCompletion();
+                }
+                catch (waitError) {
+                    log("⚠️", "Error waiting for checkpoint queue completion:", waitError);
+                    // Continue anyway - the checkpoint will be retried on next invocation
+                }
                 // Return a response indicating the result was checkpointed
                 return {
                     Status: InvocationStatus.SUCCEEDED,
@@ -4598,6 +4520,14 @@ async function runHandler(event, context, executionContext, durableExecutionMode
             }
         }
         // If response size is acceptable, return the response
+        // Wait for any pending checkpoints to complete before returning
+        try {
+            await durableExecution.checkpointManager.waitForQueueCompletion();
+        }
+        catch (waitError) {
+            log("⚠️", "Error waiting for checkpoint queue completion:", waitError);
+            // Continue anyway - the checkpoint will be retried on next invocation
+        }
         return {
             Status: InvocationStatus.SUCCEEDED,
             Result: serializedResult,
@@ -4610,6 +4540,14 @@ async function runHandler(event, context, executionContext, durableExecutionMode
             log("🛑", "Unrecoverable invocation error - terminating Lambda execution");
             throw error; // Re-throw the error to terminate Lambda execution
         }
+        // Wait for any pending checkpoints to complete before returning error
+        try {
+            await durableExecution.checkpointManager.waitForQueueCompletion();
+        }
+        catch (waitError) {
+            log("⚠️", "Error waiting for checkpoint queue completion:", waitError);
+            // Continue anyway - the checkpoint will be retried on next invocation
+        }
         return {
             Status: InvocationStatus.FAILED,
             Error: createErrorObjectFromError(error),
@@ -4620,16 +4558,10 @@ async function runHandler(event, context, executionContext, durableExecutionMode
  * Validates that the event is a proper durable execution input
  */
 function validateDurableExecutionEvent(event) {
-    try {
-        const eventObj = event;
-        if (!eventObj?.DurableExecutionArn || !eventObj?.CheckpointToken) {
-            throw new Error("Missing required durable execution fields");
-        }
-    }
-    catch {
-        const msg = `Unexpected payload provided to start the durable execution. 
-Check your resource configurations to confirm the durability is set.`;
-        throw new Error(msg);
+    const eventObj = event;
+    if (!eventObj?.DurableExecutionArn || !eventObj?.CheckpointToken) {
+        throw new Error("Unexpected payload provided to start the durable execution.\n" +
+            "Check your resource configurations to confirm the durability is set.");
     }
 }
 /**
@@ -4707,14 +4639,7 @@ const withDurableExecution = (handler, config) => {
     return async (event, context) => {
         validateDurableExecutionEvent(event);
         const { executionContext, durableExecutionMode, checkpointToken } = await initializeExecutionContext(event, context, config?.client);
-        let response = null;
-        try {
-            response = await runHandler(event, context, executionContext, durableExecutionMode, checkpointToken, handler);
-            return response;
-        }
-        catch (err) {
-            throw err;
-        }
+        return runHandler(event, context, executionContext, durableExecutionMode, checkpointToken, handler);
     };
 };