@aws/durable-execution-sdk-js 0.0.1 → 1.0.1

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":""}

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

@@ -0,0 +1,152 @@
+/**
+ * Context information passed to Serdes for external storage operations
+ *
+ * @public
+ */
+export interface SerdesContext {
+    /** Unique identifier for the step/entity being serialized */
+    entityId: string;
+    /** ARN of the durable execution to avoid collisions between executions */
+    durableExecutionArn: string;
+}
+/**
+ * Serdes (Serialization/Deserialization) interface for durable functions.
+ * This interface allows customizing how data is serialized and deserialized
+ * when persisting state in durable functions.
+ *
+ * Both methods are async to support custom implementations that need to
+ * interact with external services (e.g., AWS S3, DynamoDB, etc.)
+ *
+ * @public
+ */
+export interface Serdes<T> {
+    /**
+     * Serializes a value to a string representation
+     * @param value - The value to serialize
+     * @param context - Context information for external storage (entityId, durableExecutionArn)
+     * @returns A Promise that resolves to a string representation of the value or pointer
+     */
+    serialize: (value: T | undefined, context: SerdesContext) => Promise<string | undefined>;
+    /**
+     * Deserializes a string back to the original value
+     * @param data - The string to deserialize (could be actual data or a pointer)
+     * @param context - Context information for external storage (entityId, durableExecutionArn)
+     * @returns A Promise that resolves to the deserialized value
+     */
+    deserialize: (data: string | undefined, context: SerdesContext) => Promise<T | undefined>;
+}
+/**
+ * Default Serdes implementation using JSON.stringify and JSON.parse
+ * Wrapped in Promise.resolve() to maintain async interface compatibility
+ * Ignores context parameter since it uses inline JSON serialization
+ *
+ * Note: Uses 'any' type intentionally as this is a generic serializer that must
+ * handle arbitrary JavaScript values. JSON.stringify/parse work with any type,
+ * and using more restrictive types would break compatibility with the generic
+ * Serdes<T> interface when T can be any type.
+ *
+ * @public
+ */
+export declare const defaultSerdes: Serdes<any>;
+/**
+ * Creates a Serdes for a specific class that preserves the class type. This implementation
+ * is a basic class wrapper and does not support any complex class structures. If you need
+ * custom serialization, it is recommended to create your own custom serdes.
+ *
+ * @param cls - The class constructor (must have no required parameters)
+ * @returns A Serdes that maintains the class type during serialization/deserialization
+ *
+ * @example
+ * ```typescript
+ * class User {
+ *   name: string = "";
+ *   age: number = 0;
+ *
+ *   greet() {
+ *     return `Hello, ${this.name}`;
+ *   }
+ * }
+ *
+ * const userSerdes = createClassSerdes(User);
+ *
+ * // In a durable function:
+ * const user = await context.step("create-user", async () => {
+ *   const u = new User();
+ *   u.name = "Alice";
+ *   u.age = 30;
+ *   return u;
+ * }, { serdes: userSerdes });
+ *
+ * console.log(user.greet()); // "Hello, Alice" - methods are preserved
+ * ```
+ *
+ * Limitations:
+ * - Class instances becomes plain objects and loses all class information
+ * - Constructor must have no parameters
+ * - Constructor side-effects will re-run during deserialization
+ * - Private fields (#field) cannot be serialized
+ * - Getters/setters are not preserved
+ * - Nested class instances lose their prototype
+ *
+ * For classes with Date properties, use createClassSerdesWithDates instead.
+ *
+ * @beta
+ */
+export declare function createClassSerdes<T extends object>(cls: new () => T): Serdes<T>;
+/**
+ * Creates a custom Serdes for a class with special handling for Date properties. This implementation
+ * is a basic class wrapper and does not support any complex class structures. If you need
+ * custom serialization, it is recommended to create your own custom serdes.
+ *
+ * @param cls - The class constructor (must have no required parameters)
+ * @param dateProps - Array of property paths that should be converted to Date objects (supports nested paths like "metadata.createdAt")
+ * @returns A Serdes that maintains the class type and converts specified properties to Date objects
+ *
+ * @example
+ * ```typescript
+ * class Article {
+ *   title: string = "";
+ *   createdAt: Date = new Date();
+ *   metadata: {
+ *     publishedAt: Date;
+ *     updatedAt: Date;
+ *   } = {
+ *     publishedAt: new Date(),
+ *     updatedAt: new Date()
+ *   };
+ *
+ *   getAge() {
+ *     return Date.now() - this.createdAt.getTime();
+ *   }
+ * }
+ *
+ * const articleSerdes = createClassSerdesWithDates(Article, [
+ *   "createdAt",
+ *   "metadata.publishedAt",
+ *   "metadata.updatedAt"
+ * ]);
+ *
+ * // In a durable function:
+ * const article = await context.step("create-article", async () => {
+ *   const a = new Article();
+ *   a.title = "My Article";
+ *   return a;
+ * }, { serdes: articleSerdes });
+ *
+ * console.log(article.getAge()); // Works! Dates are properly restored
+ * ```
+ *
+ * Limitations:
+ * - Class instances becomes plain objects and loses all class information
+ * - Constructor must have no parameters
+ * - Constructor side-effects will re-run during deserialization
+ * - Private fields (#field) cannot be serialized
+ * - Getters/setters are not preserved
+ * - Nested class instances lose their prototype
+ *
+ * For classes with Date properties, use createClassSerdesWithDates instead.
+ *
+ * @beta
+ */
+export declare function createClassSerdesWithDates<T extends object>(cls: new () => T, dateProps: string[]): Serdes<T>;
+//# sourceMappingURL=serdes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serdes.d.ts","sourceRoot":"","sources":["../../../src/utils/serdes/serdes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB;;;;;OAKG;IACH,SAAS,EAAE,CACT,KAAK,EAAE,CAAC,GAAG,SAAS,EACpB,OAAO,EAAE,aAAa,KACnB,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IAEjC;;;;;OAKG;IACH,WAAW,EAAE,CACX,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,OAAO,EAAE,aAAa,KACnB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;CAC7B;AAED;;;;;;;;;;;GAWG;AAEH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,GAAG,CAYrC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,EAChD,GAAG,EAAE,UAAU,CAAC,GACf,MAAM,CAAC,CAAC,CAAC,CAeX;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,SAAS,MAAM,EACzD,GAAG,EAAE,UAAU,CAAC,EAChB,SAAS,EAAE,MAAM,EAAE,GAClB,MAAM,CAAC,CAAC,CAAC,CA2CX"}

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

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

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

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

package/dist-types/utils/step-id-utils/step-id-utils.d.ts

@@ -0,0 +1,16 @@
+import { Operation } from "@aws-sdk/client-lambda";
+/**
+ * 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
+ */
+export declare const hashId: (input: string) => string;
+/**
+ * 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
+ */
+export declare const getStepData: (stepData: Record<string, Operation>, stepId: string) => Operation | undefined;
+//# sourceMappingURL=step-id-utils.d.ts.map

package/dist-types/utils/step-id-utils/step-id-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-id-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/step-id-utils/step-id-utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAInD;;;;GAIG;AACH,eAAO,MAAM,MAAM,GAAI,OAAO,MAAM,KAAG,MAKtC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACtB,UAAU,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EACnC,QAAQ,MAAM,KACb,SAAS,GAAG,SAGd,CAAC"}

package/dist-types/utils/step-id-utils/step-id-utils.test.d.ts

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

package/dist-types/utils/step-id-utils/step-id-utils.test.d.ts.map

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

package/dist-types/utils/summary-generators/summary-generators.d.ts

@@ -0,0 +1,10 @@
+import { BatchResult } from "../../types";
+/**
+ * Creates a predefined summary generator for parallel operations
+ */
+export declare const createParallelSummaryGenerator: <T>() => (result: BatchResult<T>) => string;
+/**
+ * Creates a predefined summary generator for map operations
+ */
+export declare const createMapSummaryGenerator: <T>() => (result: BatchResult<T>) => string;
+//# sourceMappingURL=summary-generators.d.ts.map

package/dist-types/utils/summary-generators/summary-generators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary-generators.d.ts","sourceRoot":"","sources":["../../../src/utils/summary-generators/summary-generators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C;;GAEG;AACH,eAAO,MAAM,8BAA8B,GACxC,CAAC,QACD,QAAQ,WAAW,CAAC,CAAC,CAAC,KAAG,MAUzB,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,yBAAyB,GACnC,CAAC,QACD,QAAQ,WAAW,CAAC,CAAC,CAAC,KAAG,MASzB,CAAC"}

package/dist-types/utils/summary-generators/summary-generators.test.d.ts

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

package/dist-types/utils/summary-generators/summary-generators.test.d.ts.map

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

package/dist-types/utils/termination-helper/termination-deferral.test.d.ts

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

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

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

package/dist-types/utils/termination-helper/termination-helper.d.ts

@@ -0,0 +1,11 @@
+import { ExecutionContext } from "../../types";
+import { UnrecoverableError } from "../../errors/unrecoverable-error/unrecoverable-error";
+/**
+ * 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
+ */
+export declare function terminateForUnrecoverableError<T>(context: ExecutionContext, error: UnrecoverableError, stepIdentifier: string): Promise<T>;
+//# sourceMappingURL=termination-helper.d.ts.map

package/dist-types/utils/termination-helper/termination-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"termination-helper.d.ts","sourceRoot":"","sources":["../../../src/utils/termination-helper/termination-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,EAC9C,OAAO,EAAE,gBAAgB,EACzB,KAAK,EAAE,kBAAkB,EACzB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,CAAC,CAAC,CAOZ"}

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

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

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

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

package/dist-types/utils/wait-strategy/wait-strategy-config.d.ts

@@ -0,0 +1,19 @@
+import { WaitForConditionDecision, JitterStrategy, Duration } from "../../types";
+/**
+ * @public
+ */
+interface WaitStrategyConfig<T> {
+    maxAttempts?: number;
+    initialDelay?: Duration;
+    maxDelay?: Duration;
+    backoffRate?: number;
+    jitter?: JitterStrategy;
+    shouldContinuePolling: (result: T) => boolean;
+    timeoutSeconds?: number;
+}
+/**
+ * @public
+ */
+export declare const createWaitStrategy: <T>(config: WaitStrategyConfig<T>) => (result: T, attemptsMade: number) => WaitForConditionDecision;
+export type { WaitStrategyConfig };
+//# sourceMappingURL=wait-strategy-config.d.ts.map

package/dist-types/utils/wait-strategy/wait-strategy-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-strategy-config.d.ts","sourceRoot":"","sources":["../../../src/utils/wait-strategy/wait-strategy-config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,cAAc,EACd,QAAQ,EACT,MAAM,aAAa,CAAC;AAGrB;;GAEG;AACH,UAAU,kBAAkB,CAAC,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,qBAAqB,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC;IAC9C,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAwBD;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,QAAQ,kBAAkB,CAAC,CAAC,CAAC,MAMzD,QAAQ,CAAC,EAAE,cAAc,MAAM,KAAG,wBA8B3C,CAAC;AAEF,YAAY,EAAE,kBAAkB,EAAE,CAAC"}

package/dist-types/utils/wait-strategy/wait-strategy-config.test.d.ts

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

package/dist-types/utils/wait-strategy/wait-strategy-config.test.d.ts.map

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

package/dist-types/with-durable-execution-queue-completion.test.d.ts

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

package/dist-types/with-durable-execution-queue-completion.test.d.ts.map

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

package/dist-types/with-durable-execution.d.ts

@@ -0,0 +1,75 @@
+import { DurableLogger } from "./types";
+import { DurableExecutionConfig, DurableExecutionHandler, DurableLambdaHandler } from "./types/durable-execution";
+/**
+ * Wraps a durable handler function to create a handler with automatic state persistence,
+ * retry logic, and workflow orchestration capabilities.
+ *
+ * This function transforms your durable handler into a function that integrates
+ * with the AWS Durable Execution service. The wrapped handler automatically manages execution state
+ * and checkpointing.
+ *
+ * @typeParam TEvent - The type of the input event your handler expects (defaults to any)
+ * @typeParam TResult - The type of the result your handler returns (defaults to any)
+ * @typeParam TLogger - The type of custom logger implementation (defaults to DurableLogger)
+ *
+ * @param handler - Your durable handler function that uses the DurableContext for operations
+ * @param config - Optional configuration for custom advanced settings
+ *
+ * @returns A handler function that automatically manages durability
+ *
+ * @example
+ * **Basic Usage:**
+ * ```typescript
+ * import { withDurableExecution, DurableExecutionHandler } from '@aws/durable-execution-sdk-js';
+ *
+ * const durableHandler: DurableExecutionHandler<MyEvent, MyResult> = async (event, context) => {
+ *   // Execute durable operations with automatic retry and checkpointing
+ *   const userData = await context.step("fetch-user", async () =>
+ *     fetchUserFromDB(event.userId)
+ *   );
+ *
+ *   // Wait for external approval
+ *   const approval = await context.waitForCallback("user-approval", async (callbackId) => {
+ *     await sendApprovalEmail(callbackId, userData);
+ *   });
+ *
+ *   // Process in parallel
+ *   const results = await context.parallel("process-data", [
+ *     async (ctx) => ctx.step("validate", () => validateData(userData)),
+ *     async (ctx) => ctx.step("transform", () => transformData(userData))
+ *   ]);
+ *
+ *   return { success: true, results };
+ * };
+ *
+ * export const handler = withDurableExecution(durableHandler);
+ * ```
+ *
+ * @example
+ * **With Custom Configuration:**
+ * ```typescript
+ * import { LambdaClient } from '@aws-sdk/client-lambda';
+ *
+ * const customClient = new LambdaClient({
+ *   region: 'us-west-2',
+ *   maxAttempts: 5
+ * });
+ *
+ * export const handler = withDurableExecution(durableHandler, {
+ *   client: customClient
+ * });
+ * ```
+ *
+ * @example
+ * **Passed Directly to the Handler:**
+ * ```typescript
+ * export const handler = withDurableExecution(async (event, context) => {
+ *   const result = await context.step(async () => processEvent(event));
+ *   return result;
+ * });
+ * ```
+ *
+ * @public
+ */
+export declare const withDurableExecution: <TEvent = any, TResult = any, TLogger extends DurableLogger = DurableLogger>(handler: DurableExecutionHandler<TEvent, TResult, TLogger>, config?: DurableExecutionConfig) => DurableLambdaHandler;
+//# sourceMappingURL=with-durable-execution.d.ts.map

package/dist-types/with-durable-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-durable-execution.d.ts","sourceRoot":"","sources":["../src/with-durable-execution.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,aAAa,EAMd,MAAM,SAAS,CAAC;AAKjB,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,2BAA2B,CAAC;AA+PnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH,eAAO,MAAM,oBAAoB,GAE/B,MAAM,GAAG,GAAG,EAEZ,OAAO,GAAG,GAAG,EACb,OAAO,SAAS,aAAa,GAAG,aAAa,EAE7C,SAAS,uBAAuB,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,EAC1D,SAAS,sBAAsB,KAC9B,oBAuBF,CAAC"}

package/dist-types/with-durable-execution.test.d.ts

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

package/dist-types/with-durable-execution.test.d.ts.map

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

package/package.json

@@ -1,7 +1,73 @@
 {
   "name": "@aws/durable-execution-sdk-js",
-  "version": "0.0.1",
+  "description": "AWS Durable Execution Language SDK for TypeScript",
+  "license": "Apache-2.0",
+  "version": "1.0.1",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/aws/aws-durable-execution-sdk-js.git",
+    "directory": "packages/aws-durable-execution-sdk-js"
+  },
+  "homepage": "https://github.com/aws/aws-durable-execution-sdk-js/tree/main/packages/aws-durable-execution-sdk-js",
+  "engines": {
+    "node": ">=22"
+  },
+  "main": "./dist-cjs/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist-types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist-types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist-cjs/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "dist-cjs/",
+    "dist-types/"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 0"
-  }
+    "prebuild": "npm run lint:fix",
+    "build": "concurrently npm:build:esm npm:build:cjs npm:build:types",
+    "build:esm": "rollup --config rollup.config.mjs --environment MODE:esm",
+    "build:cjs": "rollup --config rollup.config.mjs --environment MODE:cjs",
+    "build:types": "tsc --emitDeclarationOnly --declaration --declarationMap --outDir dist-types",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:scripts": "jest --config jest.scripts.config.js",
+    "test:scripts:watch": "jest --config jest.scripts.config.js --watch",
+    "test:scripts:coverage": "jest --config jest.scripts.config.js --coverage",
+    "test:all": "jest --config jest.all.config.js",
+    "test:all:coverage": "jest --config jest.all.config.js --coverage",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "prepublishOnly": "npm test && npm run lint && npm run build",
+    "run-locally": "tsx ./src/run-durable.ts",
+    "clean": "rm -rf node_modules dist dist-cjs dist-types coverage .tsbuildinfo .rollup.cache",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.29.0",
+    "@microsoft/api-extractor": "^7.55.1",
+    "@types/aws-lambda": "^8.10.147",
+    "@typescript-eslint/eslint-plugin": "^8.25.0",
+    "@typescript-eslint/parser": "^8.25.0",
+    "aws-lambda": "^1.0.7",
+    "eslint": "^9.21.0",
+    "eslint-plugin-filename-convention": "file:scripts/eslint-plugin-filename-convention",
+    "eslint-plugin-tsdoc": "^0.4.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.5.2",
+    "rimraf": "^5.0.10",
+    "ts-jest": "^29.2.6",
+    "tsx": "^4.19.3",
+    "typescript": "^5.7.3"
+  },
+  "dependencies": {
+    "@aws-sdk/client-lambda": "^3.943.0"
+  },
+  "private": false
 }