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

package/dist-types/utils/checkpoint/checkpoint-manager.d.ts

@@ -0,0 +1,53 @@
+import { OperationUpdate, Operation } from "@aws-sdk/client-lambda";
+import { DurableExecutionClient } from "../../types/durable-execution";
+import { TerminationManager } from "../../termination-manager/termination-manager";
+import { EventEmitter } from "events";
+import { DurableLogger } from "../../types/durable-logger";
+import { Checkpoint } from "./checkpoint-helper";
+export declare const STEP_DATA_UPDATED_EVENT = "stepDataUpdated";
+interface ActiveOperationsTracker {
+    increment(): void;
+    decrement(): void;
+}
+export declare class CheckpointManager implements Checkpoint {
+    private durableExecutionArn;
+    private stepData;
+    private storage;
+    private terminationManager;
+    private activeOperationsTracker;
+    private stepDataEmitter;
+    private logger;
+    private pendingCompletions;
+    private queue;
+    private isProcessing;
+    private currentTaskToken;
+    private forceCheckpointPromises;
+    private queueCompletionResolver;
+    private queueCompletionTimeout;
+    private readonly MAX_PAYLOAD_SIZE;
+    private isTerminating;
+    private static textEncoder;
+    constructor(durableExecutionArn: string, stepData: Record<string, Operation>, storage: DurableExecutionClient, terminationManager: TerminationManager, activeOperationsTracker: ActiveOperationsTracker | undefined, initialTaskToken: string, stepDataEmitter: EventEmitter, logger: DurableLogger, pendingCompletions: Set<string>);
+    setTerminating(): void;
+    /**
+     * Checks if a step ID or any of its ancestors has a pending completion
+     */
+    hasPendingAncestorCompletion(stepId: string): boolean;
+    forceCheckpoint(): Promise<void>;
+    waitForQueueCompletion(): Promise<void>;
+    clearQueue(): void;
+    force(): Promise<void>;
+    checkpoint(stepId: string, data: Partial<OperationUpdate>): Promise<void>;
+    private hasFinishedAncestor;
+    private classifyCheckpointError;
+    private processQueue;
+    private notifyQueueCompletion;
+    private processBatch;
+    private updateStepDataFromCheckpointResponse;
+    getQueueStatus(): {
+        queueLength: number;
+        isProcessing: boolean;
+    };
+}
+export {};
+//# sourceMappingURL=checkpoint-manager.d.ts.map

package/dist-types/utils/checkpoint/checkpoint-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-manager.d.ts","sourceRoot":"","sources":["../../../src/utils/checkpoint/checkpoint-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EACf,SAAS,EAGV,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAEvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,+CAA+C,CAAC;AAGnF,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAKtC,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEjD,eAAO,MAAM,uBAAuB,oBAAoB,CAAC;AASzD,UAAU,uBAAuB;IAC/B,SAAS,IAAI,IAAI,CAAC;IAClB,SAAS,IAAI,IAAI,CAAC;CACnB;AAED,qBAAa,iBAAkB,YAAW,UAAU;IAehD,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,kBAAkB;IAC1B,OAAO,CAAC,uBAAuB;IAE/B,OAAO,CAAC,eAAe;IACvB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,kBAAkB;IAtB5B,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,uBAAuB,CAGvB;IACR,OAAO,CAAC,uBAAuB,CAA6B;IAC5D,OAAO,CAAC,sBAAsB,CAA+B;IAC7D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAc;IAC/C,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,MAAM,CAAC,WAAW,CAAqB;gBAGrC,mBAAmB,EAAE,MAAM,EAC3B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EACnC,OAAO,EAAE,sBAAsB,EAC/B,kBAAkB,EAAE,kBAAkB,EACtC,uBAAuB,EAAE,uBAAuB,GAAG,SAAS,EACpE,gBAAgB,EAAE,MAAM,EAChB,eAAe,EAAE,YAAY,EAC7B,MAAM,EAAE,aAAa,EACrB,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC;IAKzC,cAAc,IAAI,IAAI;IAKtB;;OAEG;IACH,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAe/C,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBhC,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;IAmBtC,UAAU,IAAI,IAAI;IASnB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAItB,UAAU,CACd,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,OAAO,CAAC,eAAe,CAAC,GAC7B,OAAO,CAAC,IAAI,CAAC;IAmDhB,OAAO,CAAC,mBAAmB;IAwB3B,OAAO,CAAC,uBAAuB;YAuDjB,YAAY;IA2G1B,OAAO,CAAC,qBAAqB;YAWf,YAAY;IA4C1B,OAAO,CAAC,oCAAoC;IAqB5C,cAAc,IAAI;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,YAAY,EAAE,OAAO,CAAC;KACvB;CAMF"}

package/dist-types/utils/checkpoint/checkpoint-queue-completion.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkpoint-queue-completion.test.d.ts.map

package/dist-types/utils/checkpoint/checkpoint-queue-completion.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-queue-completion.test.d.ts","sourceRoot":"","sources":["../../../src/utils/checkpoint/checkpoint-queue-completion.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/checkpoint/checkpoint-stepdata-update.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkpoint-stepdata-update.test.d.ts.map

package/dist-types/utils/checkpoint/checkpoint-stepdata-update.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-stepdata-update.test.d.ts","sourceRoot":"","sources":["../../../src/utils/checkpoint/checkpoint-stepdata-update.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/checkpoint/checkpoint-termination.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkpoint-termination.test.d.ts.map

package/dist-types/utils/checkpoint/checkpoint-termination.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-termination.test.d.ts","sourceRoot":"","sources":["../../../src/utils/checkpoint/checkpoint-termination.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/checkpoint/checkpoint.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=checkpoint.test.d.ts.map

package/dist-types/utils/checkpoint/checkpoint.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint.test.d.ts","sourceRoot":"","sources":["../../../src/utils/checkpoint/checkpoint.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/constants/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared constants to avoid circular dependencies
+ */
+export declare const OPERATIONS_COMPLETE_EVENT = "allOperationsComplete";
+/**
+ * Controls whether stack traces are stored in error objects
+ * TODO: Accept this as configuration parameter in the future
+ */
+export declare const STORE_STACK_TRACES = false;
+//# sourceMappingURL=constants.d.ts.map

package/dist-types/utils/constants/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/utils/constants/constants.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,eAAO,MAAM,yBAAyB,0BAA0B,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAQ,CAAC"}

package/dist-types/utils/context-tracker/context-tracker.d.ts

@@ -0,0 +1,13 @@
+import { TerminationManager } from "../../termination-manager/termination-manager";
+import { DurableExecutionMode } from "../../types";
+interface ContextInfo {
+    contextId: string;
+    parentId?: string;
+    attempt?: number;
+    durableExecutionMode?: DurableExecutionMode;
+}
+export declare const getActiveContext: () => ContextInfo | undefined;
+export declare const runWithContext: <T>(contextId: string, parentId: string | undefined, fn: () => T, attempt?: number, durableExecutionMode?: DurableExecutionMode) => T;
+export declare const validateContextUsage: (operationContextId: string | undefined, operationName: string, terminationManager: TerminationManager) => void;
+export {};
+//# sourceMappingURL=context-tracker.d.ts.map

package/dist-types/utils/context-tracker/context-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-tracker.d.ts","sourceRoot":"","sources":["../../../src/utils/context-tracker/context-tracker.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,+CAA+C,CAAC;AAEnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAEnD,UAAU,WAAW;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAID,eAAO,MAAM,gBAAgB,QAAO,WAAW,GAAG,SAEjD,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,CAAC,EAC9B,WAAW,MAAM,EACjB,UAAU,MAAM,GAAG,SAAS,EAC5B,IAAI,MAAM,CAAC,EACX,UAAU,MAAM,EAChB,uBAAuB,oBAAoB,KAC1C,CAKF,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,oBAAoB,MAAM,GAAG,SAAS,EACtC,eAAe,MAAM,EACrB,oBAAoB,kBAAkB,KACrC,IAkBF,CAAC"}

package/dist-types/utils/context-tracker/context-tracker.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=context-tracker.test.d.ts.map

package/dist-types/utils/context-tracker/context-tracker.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-tracker.test.d.ts","sourceRoot":"","sources":["../../../src/utils/context-tracker/context-tracker.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/durable-execution-invocation-input/durable-execution-invocation-input.d.ts

@@ -0,0 +1,20 @@
+import { Operation } from "@aws-sdk/client-lambda";
+import { DurableExecutionClient } from "../../types/durable-execution";
+import { DurableExecutionInvocationInput } from "../../types";
+/**
+ * Custom DurableExecutionInvocationInput which uses a custom durable
+ * execution client instead of the API-based LambdaClient.
+ *
+ * @internal
+ */
+export declare class DurableExecutionInvocationInputWithClient implements DurableExecutionInvocationInput {
+    readonly durableExecutionClient: DurableExecutionClient;
+    readonly InitialExecutionState: {
+        Operations: Operation[];
+        NextMarker: string;
+    };
+    readonly DurableExecutionArn: string;
+    readonly CheckpointToken: string;
+    constructor(params: DurableExecutionInvocationInput, durableExecutionClient: DurableExecutionClient);
+}
+//# sourceMappingURL=durable-execution-invocation-input.d.ts.map

package/dist-types/utils/durable-execution-invocation-input/durable-execution-invocation-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-execution-invocation-input.d.ts","sourceRoot":"","sources":["../../../src/utils/durable-execution-invocation-input/durable-execution-invocation-input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AACvE,OAAO,EAAE,+BAA+B,EAAE,MAAM,aAAa,CAAC;AAE9D;;;;;GAKG;AACH,qBAAa,yCACX,YAAW,+BAA+B;aAUxB,sBAAsB,EAAE,sBAAsB;IARhE,SAAgB,qBAAqB,EAAE;QACrC,UAAU,EAAE,SAAS,EAAE,CAAC;QACxB,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;IACF,SAAgB,mBAAmB,EAAE,MAAM,CAAC;IAC5C,SAAgB,eAAe,EAAE,MAAM,CAAC;gBAEtC,MAAM,EAAE,+BAA+B,EACvB,sBAAsB,EAAE,sBAAsB;CAMjE"}

package/dist-types/utils/duration/duration.d.ts

@@ -0,0 +1,8 @@
+import { Duration } from "../../types";
+/**
+ * Converts a Duration object to total seconds
+ * @param duration - Duration object with at least one time unit specified
+ * @returns Total duration in seconds
+ */
+export declare function durationToSeconds(duration: Duration): number;
+//# sourceMappingURL=duration.d.ts.map

package/dist-types/utils/duration/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../../src/utils/duration/duration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAO5D"}

package/dist-types/utils/duration/duration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=duration.test.d.ts.map

package/dist-types/utils/duration/duration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.test.d.ts","sourceRoot":"","sources":["../../../src/utils/duration/duration.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/error-object/error-object-coverage.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=error-object-coverage.test.d.ts.map

package/dist-types/utils/error-object/error-object-coverage.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-object-coverage.test.d.ts","sourceRoot":"","sources":["../../../src/utils/error-object/error-object-coverage.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/error-object/error-object.d.ts

@@ -0,0 +1,3 @@
+import { ErrorObject } from "@aws-sdk/client-lambda";
+export declare function createErrorObjectFromError(error: unknown, data?: string): ErrorObject;
+//# sourceMappingURL=error-object.d.ts.map

package/dist-types/utils/error-object/error-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-object.d.ts","sourceRoot":"","sources":["../../../src/utils/error-object/error-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAcrD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,EACd,IAAI,CAAC,EAAE,MAAM,GACZ,WAAW,CAuBb"}

package/dist-types/utils/error-object/error-object.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=error-object.test.d.ts.map

package/dist-types/utils/error-object/error-object.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-object.test.d.ts","sourceRoot":"","sources":["../../../src/utils/error-object/error-object.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/logger/default-logger.d.ts

@@ -0,0 +1,51 @@
+import { DurableLogLevel } from "../../types";
+import { DurableLogger, DurableLoggingContext } from "../../types/durable-logger";
+export interface LoggingExecutionContext {
+    durableExecutionArn: string;
+    requestId: string;
+    tenantId: string | undefined;
+}
+type DurableLogField = unknown;
+/**
+ * Default logger class that outputs structured logs to console.
+ *
+ * This logger emulates the AWS Lambda Runtime Interface Client (RIC) console patching
+ * behavior to maintain parity with standard Lambda function logging while providing
+ * structured output suitable for durable execution contexts.
+ *
+ * Key RIC behavior emulation:
+ * - Respects AWS_LAMBDA_LOG_LEVEL environment variable for log filtering
+ * - Uses priority-based level filtering (DEBUG=2, INFO=3, WARN=4, ERROR=5)
+ * - Outputs structured JSON with timestamp, requestId, executionArn, and other metadata
+ * - Handles Error objects with structured error information extraction
+ * - Uses Node.js Console instance for proper stdout/stderr routing
+ * - Applies util.format for message formatting (same as console.log behavior)
+ *
+ * Individual logger methods (info, error, warn, debug) are dynamically enabled/disabled
+ * based on the configured log level, defaulting to no-op functions when disabled.
+ * This mirrors how RIC patches console methods conditionally.
+ */
+export declare class DefaultLogger implements DurableLogger {
+    private consoleLogger;
+    private durableLoggingContext;
+    private executionContext;
+    private noOpLog;
+    constructor(executionContext?: LoggingExecutionContext);
+    private configureLogLevel;
+    private ensureDurableLoggingContext;
+    log(level: `${DurableLogLevel}`, message?: DurableLogField, ...optionalParams: DurableLogField[]): void;
+    info: (message?: DurableLogField, ...optionalParams: DurableLogField[]) => void;
+    error: (message?: DurableLogField, ...optionalParams: DurableLogField[]) => void;
+    warn: (message?: DurableLogField, ...optionalParams: DurableLogField[]) => void;
+    debug: (message?: DurableLogField, ...optionalParams: DurableLogField[]) => void;
+    configureDurableLoggingContext(durableLoggingContext: DurableLoggingContext): void;
+}
+/**
+ * Creates a default logger that outputs structured logs to console.
+ *
+ * @param executionContext - Optional execution context for logging
+ * @returns DefaultLogger instance
+ */
+export declare const createDefaultLogger: (executionContext?: LoggingExecutionContext) => DurableLogger;
+export {};
+//# sourceMappingURL=default-logger.d.ts.map

package/dist-types/utils/logger/default-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-logger.d.ts","sourceRoot":"","sources":["../../../src/utils/logger/default-logger.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAkB,MAAM,aAAa,CAAC;AAE9D,OAAO,EACL,aAAa,EACb,qBAAqB,EACtB,MAAM,4BAA4B,CAAC;AAEpC,MAAM,WAAW,uBAAuB;IACtC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAED,KAAK,eAAe,GAAG,OAAO,CAAC;AAyH/B;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,aAAc,YAAW,aAAa;IACjD,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,qBAAqB,CAAgD;IAC7E,OAAO,CAAC,gBAAgB,CAAsC;IAC9D,OAAO,CAAC,OAAO,CAAkB;gBAErB,gBAAgB,CAAC,EAAE,uBAAuB;IAkBtD,OAAO,CAAC,iBAAiB;IA8FzB,OAAO,CAAC,2BAA2B;IA4BnC,GAAG,CACD,KAAK,EAAE,GAAG,eAAe,EAAE,EAC3B,OAAO,CAAC,EAAE,eAAe,EACzB,GAAG,cAAc,EAAE,eAAe,EAAE,GACnC,IAAI;IAqBP,IAAI,EAAE,CACJ,OAAO,CAAC,EAAE,eAAe,EACzB,GAAG,cAAc,EAAE,eAAe,EAAE,KACjC,IAAI,CAAC;IACV,KAAK,EAAE,CACL,OAAO,CAAC,EAAE,eAAe,EACzB,GAAG,cAAc,EAAE,eAAe,EAAE,KACjC,IAAI,CAAC;IACV,IAAI,EAAE,CACJ,OAAO,CAAC,EAAE,eAAe,EACzB,GAAG,cAAc,EAAE,eAAe,EAAE,KACjC,IAAI,CAAC;IACV,KAAK,EAAE,CACL,OAAO,CAAC,EAAE,eAAe,EACzB,GAAG,cAAc,EAAE,eAAe,EAAE,KACjC,IAAI,CAAC;IAEV,8BAA8B,CAC5B,qBAAqB,EAAE,qBAAqB,GAC3C,IAAI;CAGR;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAC9B,mBAAmB,uBAAuB,KACzC,aAEF,CAAC"}

package/dist-types/utils/logger/default-logger.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=default-logger.test.d.ts.map

package/dist-types/utils/logger/default-logger.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-logger.test.d.ts","sourceRoot":"","sources":["../../../src/utils/logger/default-logger.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/logger/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const log: (emoji: string, message: string, data?: unknown) => void;
+//# sourceMappingURL=logger.d.ts.map

package/dist-types/utils/logger/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/utils/logger/logger.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,EAAE,SAAS,MAAM,EAAE,OAAO,OAAO,KAAG,IAIpE,CAAC"}

package/dist-types/utils/logger/logger.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logger.test.d.ts.map

package/dist-types/utils/logger/logger.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.test.d.ts","sourceRoot":"","sources":["../../../src/utils/logger/logger.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/logger/structured-logger-integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=structured-logger-integration.test.d.ts.map

package/dist-types/utils/logger/structured-logger-integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-logger-integration.test.d.ts","sourceRoot":"","sources":["../../../src/utils/logger/structured-logger-integration.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/replay-validation/replay-validation.d.ts

@@ -0,0 +1,8 @@
+import { Operation, OperationType } from "@aws-sdk/client-lambda";
+import { OperationSubType, ExecutionContext } from "../../types";
+export declare const validateReplayConsistency: (stepId: string, currentOperation: {
+    type: OperationType;
+    name: string | undefined;
+    subType: OperationSubType;
+}, checkpointData: Operation | undefined, context: ExecutionContext) => void;
+//# sourceMappingURL=replay-validation.d.ts.map

package/dist-types/utils/replay-validation/replay-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-validation.d.ts","sourceRoot":"","sources":["../../../src/utils/replay-validation/replay-validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIjE,eAAO,MAAM,yBAAyB,GACpC,QAAQ,MAAM,EACd,kBAAkB;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,OAAO,EAAE,gBAAgB,CAAC;CAC3B,EACD,gBAAgB,SAAS,GAAG,SAAS,EACrC,SAAS,gBAAgB,KACxB,IAmCF,CAAC"}

package/dist-types/utils/replay-validation/replay-validation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=replay-validation.test.d.ts.map

package/dist-types/utils/replay-validation/replay-validation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-validation.test.d.ts","sourceRoot":"","sources":["../../../src/utils/replay-validation/replay-validation.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/retry/retry-config/index.d.ts

@@ -0,0 +1,167 @@
+import { RetryDecision, JitterStrategy, Duration } from "../../../types";
+/**
+ * Configuration options for creating a retry strategy
+ *
+ * @remarks
+ * When neither `retryableErrors` nor `retryableErrorTypes` is specified, all errors are retried by default.
+ * When either is specified, only errors matching the specified criteria are retried.
+ * When both are specified, errors matching either criteria are retried (OR logic).
+ *
+ * @example
+ * ```typescript
+ * // Retry all errors (default behavior)
+ * createRetryStrategy({ maxAttempts: 5 })
+ *
+ * // Retry only specific error types
+ * createRetryStrategy({ retryableErrorTypes: [TimeoutError, NetworkError] })
+ *
+ * // Retry only errors matching message patterns
+ * createRetryStrategy({ retryableErrors: [/timeout/i, /connection/i] })
+ *
+ * // Retry errors matching either type OR pattern
+ * createRetryStrategy({
+ *   retryableErrorTypes: [TimeoutError],
+ *   retryableErrors: [/network/i]
+ * })
+ * ```
+ *
+ * @public
+ */
+interface RetryStrategyConfig {
+    /**
+     * Maximum number of total attempts (including initial attempt).
+     * @defaultValue 3
+     */
+    maxAttempts?: number;
+    /**
+     * Initial delay before first retry.
+     * @defaultValue \{ seconds: 5 \}
+     */
+    initialDelay?: Duration;
+    /**
+     * Maximum delay between retries.
+     * @defaultValue \{ minutes: 5 \}
+     */
+    maxDelay?: Duration;
+    /**
+     * Multiplier for exponential backoff on each retry.
+     * @defaultValue 2
+     */
+    backoffRate?: number;
+    /**
+     * Jitter strategy to apply to retry delays.
+     * @defaultValue JitterStrategy.FULL
+     * @see {@link JitterStrategy}
+     */
+    jitter?: JitterStrategy;
+    /**
+     * List of error message patterns (strings or RegExp) that are retryable.
+     *
+     * @remarks
+     * - If undefined and `retryableErrorTypes` is also undefined: all errors are retried (default)
+     * - If specified: only errors with messages matching these patterns are retried
+     * - Strings are matched using `includes()`, RegExp patterns use `test()`
+     * - Combined with `retryableErrorTypes` using OR logic
+     *
+     * @defaultValue All errors when both filters are undefined, otherwise empty array
+     *
+     * @example
+     * ```typescript
+     * // Retry errors containing "timeout" or "connection"
+     * retryableErrors: ["timeout", "connection"]
+     *
+     * // Retry errors matching regex patterns (case-insensitive)
+     * retryableErrors: [/timeout/i, /network.*failed/i]
+     * ```
+     */
+    retryableErrors?: (string | RegExp)[];
+    /**
+     * List of error class types that are retryable.
+     *
+     * @remarks
+     * - If undefined and `retryableErrors` is also undefined: all errors are retried (default)
+     * - If specified: only errors that are instances of these types are retried
+     * - Combined with `retryableErrors` using OR logic
+     *
+     * @defaultValue Empty array
+     *
+     * @example
+     * ```typescript
+     * // Define custom error types
+     * class TimeoutError extends Error {}
+     * class NetworkError extends Error {}
+     *
+     * // Retry only these specific error types
+     * retryableErrorTypes: [TimeoutError, NetworkError]
+     * ```
+     */
+    retryableErrorTypes?: (new () => Error)[];
+}
+/**
+ * Creates a retry strategy function with exponential backoff and configurable jitter
+ *
+ * @param config - Configuration options for the retry strategy
+ * @returns A function that determines whether to retry and calculates delay based on error and attempt count
+ *
+ * @remarks
+ * The returned function takes an error and attempt count, and returns a {@link RetryDecision} indicating
+ * whether to retry and the delay before the next attempt.
+ *
+ * **Delay Calculation:**
+ * - Base delay = `initialDelay × backoffRate^(attemptsMade - 1)`
+ * - Capped at `maxDelay`
+ * - Jitter applied based on `jitter` strategy
+ * - Final delay rounded to nearest second, minimum 1 second
+ *
+ * **Error Filtering:**
+ * - If neither `retryableErrors` nor `retryableErrorTypes` is specified: all errors are retried
+ * - If either is specified: only matching errors are retried
+ * - If both are specified: errors matching either criteria are retried (OR logic)
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with defaults (retry all errors, 3 attempts, exponential backoff)
+ * const defaultRetry = createRetryStrategy();
+ *
+ * // Custom retry with more attempts and specific delays
+ * const customRetry = createRetryStrategy({
+ *   maxAttempts: 5,
+ *   initialDelay: { seconds: 10 },
+ *   maxDelay: { seconds: 60 },
+ *   backoffRate: 2,
+ *   jitter: JitterStrategy.HALF
+ * });
+ *
+ * // Retry only specific error types
+ * class TimeoutError extends Error {}
+ * const typeBasedRetry = createRetryStrategy({
+ *   retryableErrorTypes: [TimeoutError]
+ * });
+ *
+ * // Retry only errors matching message patterns
+ * const patternBasedRetry = createRetryStrategy({
+ *   retryableErrors: [/timeout/i, /connection/i, "rate limit"]
+ * });
+ *
+ * // Combine error types and patterns
+ * const combinedRetry = createRetryStrategy({
+ *   retryableErrorTypes: [TimeoutError],
+ *   retryableErrors: [/network/i]
+ * });
+ *
+ * // Use in step configuration
+ * await context.step('api-call', async () => {
+ *   return await callExternalAPI();
+ * }, { retryStrategy: customRetry });
+ * ```
+ *
+ * @see {@link RetryStrategyConfig} for configuration options
+ * @see {@link JitterStrategy} for jitter strategies
+ * @see {@link RetryDecision} for return type
+ *
+ * @public
+ */
+export declare const createRetryStrategy: (config?: RetryStrategyConfig) => (error: Error, attemptsMade: number) => RetryDecision;
+export type { RetryStrategyConfig };
+export { JitterStrategy };
+//# sourceMappingURL=index.d.ts.map

package/dist-types/utils/retry/retry-config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/retry/retry-config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAGzE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,UAAU,mBAAmB;IAC3B;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,YAAY,CAAC,EAAE,QAAQ,CAAC;IAExB;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAEpB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;OAIG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC;IAExB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAAe,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC;IAEtC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,mBAAmB,CAAC,EAAE,CAAC,UAAU,KAAK,CAAC,EAAE,CAAC;CAC3C;AA2BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAQ,mBAAwB,MAa1D,OAAO,KAAK,EAAE,cAAc,MAAM,KAAG,aA0C9C,CAAC;AAEF,YAAY,EAAE,mBAAmB,EAAE,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist-types/utils/retry/retry-config/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist-types/utils/retry/retry-config/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../../src/utils/retry/retry-config/index.test.ts"],"names":[],"mappings":""}

package/dist-types/utils/retry/retry-presets/retry-presets.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Pre-configured retry strategies for common use cases
+ * @example
+ * ```typescript
+ * // Use default retry preset (3 attempts with exponential backoff)
+ * await context.step('my-step', async () => {
+ *   return await someOperation();
+ * }, { retryStrategy: retryPresets.default });
+ *
+ * // Use no-retry preset (fail immediately on error)
+ * await context.step('critical-step', async () => {
+ *   return await criticalOperation();
+ * }, { retryStrategy: retryPresets.noRetry });
+ * ```
+ *
+ * @public
+ */
+export declare const retryPresets: {
+    /**
+     * Default retry strategy with exponential backoff
+     * - 6 total attempts (1 initial + 5 retries)
+     * - Initial delay: 5 seconds
+     * - Max delay: 60 seconds
+     * - Backoff rate: 2x
+     * - Jitter: FULL (randomizes delay between 0 and calculated delay)
+     * - Total max wait time less than 150 seconds (2:30)
+     */
+    default: (error: Error, attemptsMade: number) => import("../../..").RetryDecision;
+    /**
+     * No retry strategy - fails immediately on first error
+     * - 1 total attempt (no retries)
+     */
+    noRetry: (error: Error, attemptsMade: number) => import("../../..").RetryDecision;
+};
+//# sourceMappingURL=retry-presets.d.ts.map

package/dist-types/utils/retry/retry-presets/retry-presets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-presets.d.ts","sourceRoot":"","sources":["../../../../src/utils/retry/retry-presets/retry-presets.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY;IACvB;;;;;;;;OAQG;;IASH;;;OAGG;;CAIJ,CAAC"}

package/dist-types/utils/safe-stringify/safe-stringify.d.ts

@@ -0,0 +1,2 @@
+export declare const safeStringify: (data: unknown) => string;
+//# sourceMappingURL=safe-stringify.d.ts.map

package/dist-types/utils/safe-stringify/safe-stringify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-stringify.d.ts","sourceRoot":"","sources":["../../../src/utils/safe-stringify/safe-stringify.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,GAAI,MAAM,OAAO,KAAG,MA2B7C,CAAC"}

package/dist-types/utils/safe-stringify/safe-stringify.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=safe-stringify.test.d.ts.map

package/dist-types/utils/safe-stringify/safe-stringify.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-stringify.test.d.ts","sourceRoot":"","sources":["../../../src/utils/safe-stringify/safe-stringify.test.ts"],"names":[],"mappings":""}