sst 4.6.11 → 4.7.0

package/dist/aws/bus.d.ts

@@ -1,4 +1,4 @@
-import { AwsOptions } from "../aws/client.js";
+import { aws } from "./client.js";
 import { Resource } from "../resource.js";
 import { event } from "../event/index.js";
 import { EventBridgeEvent, EventBridgeHandler, Context } from "aws-lambda";
@@ -19,7 +19,7 @@ export declare namespace bus {
         name: string;
     }, def: Definition | string, properties: Definition["$input"], options?: {
         metadata?: Definition["$metadata"];
-        aws?: AwsOptions;
+        aws?: aws.Options;
     }): Promise<any>;
     class PublishError extends Error {
         readonly response: Response;

package/dist/aws/bus.js

@@ -1,12 +1,7 @@
-import { client } from "../aws/client.js";
+import { aws } from "./client.js";
 import { Resource } from "../resource.js";
 export var bus;
 (function (bus) {
-    function url(region, options) {
-        if (options?.region)
-            region = options.region;
-        return `https://events.${region}.amazonaws.com/`;
-    }
     function subscriber(_events, cb) {
         return async function (event, context) {
             const payload = {
@@ -23,8 +18,6 @@ export var bus;
      * */
     bus.handler = subscriber;
     async function publish(name, def, properties, options) {
-        const c = await client();
-        const u = url(c.region, options?.aws);
         const evt = typeof def === "string"
             ? {
                 type: def,
@@ -32,10 +25,8 @@ export var bus;
                 metadata: options?.metadata || {},
             }
             : await def.create(properties, options?.metadata);
-        const res = await c
-            .fetch(u, {
+        const res = await aws.fetch("events", "/", {
             method: "POST",
-            aws: options?.aws,
             headers: {
                 "X-Amz-Target": "AWSEvents.PutEvents",
                 "Content-Type": "application/x-amz-json-1.1",
@@ -53,7 +44,7 @@ export var bus;
                     },
                 ],
             }),
-        })
+        }, options)
             .catch((e) => {
             if (e instanceof Error)
                 console.log("cause", e.cause);

package/dist/aws/client.d.ts

@@ -1,3 +1,12 @@
 import { AwsClient } from "aws4fetch";
+type AwsFetchOptions = Exclude<Parameters<AwsClient["fetch"]>[1], null | undefined>;
+export declare namespace aws {
+    type Options = Exclude<Parameters<AwsClient["fetch"]>[1], null | undefined>["aws"];
+    function client(): Promise<AwsClient>;
+    function fetch(service: string, path: string, init: Omit<AwsFetchOptions, "aws">, options?: {
+        aws?: Options;
+    }): Promise<Response>;
+}
 export declare function client(): Promise<AwsClient>;
-export type AwsOptions = Exclude<Parameters<AwsClient["fetch"]>[1], null | undefined>["aws"];
+export type AwsOptions = aws.Options;
+export {};

package/dist/aws/client.js

@@ -13,24 +13,40 @@ async function getCredentials(url) {
     cachedCredentials = credentials;
     return credentials;
 }
-export async function client() {
-    if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) {
-        return new AwsClient({
-            accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-            sessionToken: process.env.AWS_SESSION_TOKEN,
-            region: process.env.AWS_REGION,
-        });
+export var aws;
+(function (aws) {
+    async function client() {
+        if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) {
+            return new AwsClient({
+                accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+                secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+                sessionToken: process.env.AWS_SESSION_TOKEN,
+                region: process.env.AWS_REGION,
+            });
+        }
+        if (process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI) {
+            const credentials = await getCredentials("http://169.254.170.2" +
+                process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI);
+            return new AwsClient({
+                accessKeyId: credentials.AccessKeyId,
+                secretAccessKey: credentials.SecretAccessKey,
+                sessionToken: credentials.Token,
+                region: process.env.AWS_REGION,
+            });
+        }
+        throw new Error("No AWS credentials found");
     }
-    if (process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI) {
-        const credentials = await getCredentials("http://169.254.170.2" +
-            process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI);
-        return new AwsClient({
-            accessKeyId: credentials.AccessKeyId,
-            secretAccessKey: credentials.SecretAccessKey,
-            sessionToken: credentials.Token,
-            region: process.env.AWS_REGION,
+    aws.client = client;
+    async function fetch(service, path, init, options) {
+        const c = await client();
+        const region = options?.aws?.region ?? c.region;
+        return c.fetch(`https://${service}.${region}.amazonaws.com${path}`, {
+            ...init,
+            aws: options?.aws,
         });
     }
-    throw new Error("No AWS credentials found");
+    aws.fetch = fetch;
+})(aws || (aws = {}));
+export async function client() {
+    return aws.client();
 }

package/dist/aws/task.d.ts

@@ -1,4 +1,4 @@
-import { AwsOptions } from "./client.js";
+import { aws } from "./client.js";
 /**
  * The `task` client SDK is available through the following.
  *
@@ -61,7 +61,7 @@ export declare namespace task {
          * Configure the options for the [aws4fetch](https://github.com/mhart/aws4fetch)
          * [`AWSClient`](https://github.com/mhart/aws4fetch?tab=readme-ov-file#new-awsclientoptions) used internally by the SDK.
          */
-        aws?: AwsOptions;
+        aws?: aws.Options;
     }
     export interface RunOptions extends Options {
         /**

package/dist/aws/task.js

@@ -1,4 +1,4 @@
-import { client } from "./client.js";
+import { aws } from "./client.js";
 /**
  * The `task` client SDK is available through the following.
  *
@@ -13,11 +13,6 @@ import { client } from "./client.js";
  */
 export var task;
 (function (task_1) {
-    function url(region, options) {
-        if (options?.region)
-            region = options.region;
-        return `https://ecs.${region}.amazonaws.com/`;
-    }
     /**
      * Get the details of a given task.
      *
@@ -45,11 +40,8 @@ export var task;
      * [`DescribeTasks`](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html).
      */
     async function describe(resource, task, options) {
-        const c = await client();
-        const u = url(c.region, options?.aws);
-        const res = await c.fetch(u, {
+        const res = await aws.fetch("ecs", "/", {
             method: "POST",
-            aws: options?.aws,
             headers: {
                 "X-Amz-Target": "AmazonEC2ContainerServiceV20141113.DescribeTasks",
                 "Content-Type": "application/x-amz-json-1.1",
@@ -58,7 +50,7 @@ export var task;
                 cluster: resource.cluster,
                 tasks: [task],
             }),
-        });
+        }, options);
         if (!res.ok)
             throw new DescribeError(res);
         const data = (await res.json());
@@ -110,11 +102,8 @@ export var task;
      * [`RunTask`](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_RunTask.html).
      */
     async function run(resource, environment, options) {
-        const c = await client();
-        const u = url(c.region, options?.aws);
-        const res = await c.fetch(u, {
+        const res = await aws.fetch("ecs", "/", {
             method: "POST",
-            aws: options?.aws,
             headers: {
                 "X-Amz-Target": "AmazonEC2ContainerServiceV20141113.RunTask",
                 "Content-Type": "application/x-amz-json-1.1",
@@ -148,7 +137,7 @@ export var task;
                     })),
                 },
             }),
-        });
+        }, options);
         if (!res.ok)
             throw new RunError(res);
         const data = (await res.json());
@@ -193,11 +182,8 @@ export var task;
      * [`StopTask`](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_StopTask.html).
      */
     async function stop(resource, task, options) {
-        const c = await client();
-        const u = url(c.region, options?.aws);
-        const res = await c.fetch(u, {
+        const res = await aws.fetch("ecs", "/", {
             method: "POST",
-            aws: options?.aws,
             headers: {
                 "X-Amz-Target": "AmazonEC2ContainerServiceV20141113.StopTask",
                 "Content-Type": "application/x-amz-json-1.1",
@@ -206,7 +192,7 @@ export var task;
                 cluster: resource.cluster,
                 task,
             }),
-        });
+        }, options);
         if (!res.ok)
             throw new StopError(res);
         const data = (await res.json());
@@ -224,7 +210,6 @@ export var task;
         constructor(response) {
             super("Failed to describe task");
             this.response = response;
-            console.log(response);
         }
     }
     task_1.DescribeError = DescribeError;
@@ -233,7 +218,6 @@ export var task;
         constructor(response) {
             super("Failed to run task");
             this.response = response;
-            console.log(response);
         }
     }
     task_1.RunError = RunError;
@@ -242,7 +226,6 @@ export var task;
         constructor(response) {
             super("Failed to stop task");
             this.response = response;
-            console.log(response);
         }
     }
     task_1.StopError = StopError;

package/dist/aws/workflow.d.ts

@@ -0,0 +1,324 @@
+import * as durable from "@aws/durable-execution-sdk-js";
+import { aws } from "./client.js";
+/**
+ * The `workflow` SDK is a thin wrapper around the
+ * [`@aws/durable-execution-sdk-js`](https://www.npmjs.com/package/@aws/durable-execution-sdk-js)
+ * package and the AWS Lambda durable execution APIs.
+ *
+ * SST also adds a few helpers on top, including `ctx.stepWithRollback()`,
+ * `ctx.rollbackAll()`, and `ctx.waitUntil()`.
+ *
+ * @example
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ * ```
+ *
+ * @example
+ * Use `stepWithRollback()` and `rollbackAll()` to register compensating actions.
+ *
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ *
+ * export const handler = workflow.handler(async (_event, ctx) => {
+ *   try {
+ *     const order = await ctx.stepWithRollback("create-order", {
+ *       run: async () => ({ orderId: "order_123" }),
+ *       undo: async (error, result) => {
+ *         await fetch(`https://example.com/orders/${result.orderId}`, {
+ *           method: "DELETE",
+ *         });
+ *       },
+ *     });
+ *
+ *     await ctx.step("charge-card", async () => {
+ *       throw new Error("Card declined");
+ *     });
+ *
+ *     return order;
+ *   } catch (error) {
+ *     await ctx.rollbackAll(error);
+ *     throw error;
+ *   }
+ * });
+ * ```
+ *
+ * @example
+ * Use `waitUntil()` when you already know the exact time the workflow should resume.
+ *
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ *
+ * export const handler = workflow.handler(
+ *   async (_event, ctx) => {
+ *     const resumeAt = new Date();
+ *     resumeAt.setMinutes(resumeAt.getMinutes() + 10);
+ *
+ *     await ctx.waitUntil("wait-for-follow-up", resumeAt);
+ *
+ *     return ctx.step("send-follow-up", async () => {
+ *       return { delivered: true };
+ *     });
+ *   },
+ * );
+ * ```
+ */
+export declare namespace workflow {
+    interface Context<TLogger extends durable.DurableLogger = durable.DurableLogger> extends durable.DurableContext<TLogger> {
+        /**
+         * Execute a durable step and register a compensating rollback step if it succeeds.
+         * If `run` throws, nothing is added to the rollback stack for that step.
+         */
+        stepWithRollback<TOutput>(name: string, handler: StepWithRollbackHandler<TOutput, TLogger>, config?: StepConfig<TOutput>): durable.DurablePromise<TOutput>;
+        /**
+         * Wait until the provided time. Delays are rounded up to the nearest second.
+         */
+        waitUntil(name: string, until: Date): durable.DurablePromise<void>;
+        /**
+         * Execute all registered rollback steps in reverse order.
+         */
+        rollbackAll(error: unknown): Promise<void>;
+    }
+    type Handler<TEvent = any, TResult = any, TLogger extends durable.DurableLogger = durable.DurableLogger> = (event: TEvent, context: Context<TLogger>) => Promise<TResult>;
+    type Config = durable.DurableExecutionConfig;
+    type Duration = durable.Duration;
+    type StepConfig<TOutput = any> = durable.StepConfig<TOutput>;
+    type ExecutionStatus = "RUNNING" | "SUCCEEDED" | "FAILED" | "TIMED_OUT" | "STOPPED";
+    interface Resource {
+        /**
+         * The name of the workflow function.
+         */
+        name: string;
+        /**
+         * The version or alias qualifier to invoke.
+         *
+         * Linked `sst.aws.Workflow` resources include this automatically.
+         */
+        qualifier: string;
+    }
+    interface Options {
+        /**
+         * Configure the options for the [aws4fetch](https://github.com/mhart/aws4fetch)
+         * [`AWSClient`](https://github.com/mhart/aws4fetch?tab=readme-ov-file#new-awsclientoptions) used internally by the SDK.
+         */
+        aws?: aws.Options;
+    }
+    interface StartResponse {
+        /**
+         * The ARN of the durable execution.
+         */
+        arn?: string;
+        /**
+         * The HTTP status code from Lambda.
+         */
+        statusCode: number;
+        /**
+         * The function version that was executed.
+         */
+        version?: string;
+    }
+    interface Execution {
+        /**
+         * The ARN of the durable execution.
+         */
+        arn: string;
+        /**
+         * The durable execution name.
+         */
+        name: string;
+        /**
+         * The ARN of the workflow function.
+         */
+        functionArn: string;
+        /**
+         * The current execution status.
+         */
+        status: ExecutionStatus;
+        /**
+         * When the execution started.
+         */
+        createdAt: Date;
+        /**
+         * When the execution ended, if it has finished.
+         */
+        endedAt?: Date;
+    }
+    interface ListResponse {
+        /**
+         * The matching executions.
+         */
+        executions: Execution[];
+    }
+    interface DescribeResponse extends Execution {
+        /**
+         * The version that started the execution.
+         */
+        version?: string;
+    }
+    interface StopResponse {
+        /**
+         * The ARN of the durable execution.
+         */
+        arn: string;
+        /**
+         * The execution status after the stop call.
+         */
+        status: "STOPPED";
+        /**
+         * When the execution was stopped.
+         */
+        stoppedAt?: Date;
+    }
+    /**
+     * Create a durable workflow handler.
+     *
+     * @example
+     * ```ts title="src/workflow.ts"
+     * import { workflow } from "sst/aws/workflow";
+     *
+     * export const handler = workflow.handler(
+     *   async (_event, ctx) => {
+     *     const user = await ctx.step("load-user", async () => {
+     *       return { id: "user_123", email: "alice@example.com" };
+     *     });
+     *
+     *     await ctx.wait("pause-before-email", "1 minute");
+     *
+     *     return ctx.step("send-email", async () => {
+     *       return { sent: true, userId: user.id };
+     *     });
+     *   },
+     * );
+     * ```
+     */
+    function handler<TEvent = any, TResult = any, TLogger extends durable.DurableLogger = durable.DurableLogger>(input: Handler<TEvent, TResult, TLogger>, config?: Config): durable.DurableLambdaHandler;
+    /**
+     * Start a new workflow execution.
+     *
+     * This is the equivalent to calling
+     * [`Invoke`](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html)
+     * for a durable Lambda function, using the durable invocation flow described in
+     * [Invoking durable Lambda functions](https://docs.aws.amazon.com/lambda/latest/dg/durable-invoking.html).
+     */
+    function start<TPayload = unknown>(resource: Resource, input: StartInput<TPayload>, options?: Options): Promise<StartResponse>;
+    /**
+     * List workflow executions.
+     *
+     * The SDK returns only the first page of results.
+     */
+    function list(resource: Resource, query: ListQuery, options?: Options): Promise<ListResponse>;
+    /**
+     * Get the details for a single workflow execution.
+     */
+    function describe(arn: string, options?: Options): Promise<DescribeResponse>;
+    /**
+     * Stop a running workflow execution.
+     */
+    function stop(arn: string, input?: StopInput, options?: Options): Promise<StopResponse>;
+    /**
+     * Send a successful result for a pending workflow callback.
+     *
+     * This is the equivalent to calling
+     * [`SendDurableExecutionCallbackSuccess`](https://docs.aws.amazon.com/lambda/latest/api/API_SendDurableExecutionCallbackSuccess.html).
+     */
+    function succeed<TPayload = unknown>(token: string, input?: SucceedInput<TPayload>, options?: Options): Promise<void>;
+    /**
+     * Send a failure result for a pending workflow callback.
+     *
+     * This is the equivalent to calling
+     * [`SendDurableExecutionCallbackFailure`](https://docs.aws.amazon.com/lambda/latest/api/API_SendDurableExecutionCallbackFailure.html).
+     */
+    function fail(token: string, input: FailInput, options?: Options): Promise<void>;
+    /**
+     * Send a heartbeat for a pending workflow callback.
+     *
+     * This is useful when the external system handling the callback is still doing
+     * work and needs to prevent the callback from timing out.
+     *
+     * This is the equivalent to calling
+     * [`SendDurableExecutionCallbackHeartbeat`](https://docs.aws.amazon.com/lambda/latest/api/API_SendDurableExecutionCallbackHeartbeat.html).
+     */
+    function heartbeat(token: string, options?: Options): Promise<void>;
+    class StartError extends Error {
+        readonly response: Response;
+        constructor(response: Response);
+    }
+    class ListError extends Error {
+        readonly response: Response;
+        constructor(response: Response);
+    }
+    class DescribeError extends Error {
+        readonly response: Response;
+        constructor(response: Response);
+    }
+    class StopError extends Error {
+        readonly response: Response;
+        constructor(response: Response);
+    }
+    class SucceedError extends Error {
+        readonly response: Response;
+        constructor(response: Response);
+    }
+    class FailError extends Error {
+        readonly response: Response;
+        constructor(response: Response);
+    }
+    class HeartbeatError extends Error {
+        readonly response: Response;
+        constructor(response: Response);
+    }
+    class RollbackError extends Error {
+        readonly stepName: string;
+        readonly originalError: unknown;
+        readonly undoError: unknown;
+        constructor(stepName: string, originalError: unknown, undoError: unknown);
+    }
+}
+interface StepWithRollbackHandler<TOutput = any, TLogger extends durable.DurableLogger = durable.DurableLogger> {
+    /**
+     * The durable step to execute.
+     */
+    run: durable.StepFunc<TOutput, TLogger>;
+    /**
+     * Called during rollback with the original error, the step result, and step context.
+     */
+    undo: (error: unknown, value: TOutput, context: Parameters<durable.StepFunc<void, TLogger>>[0]) => Promise<void>;
+}
+interface StartInput<TPayload = unknown> {
+    /**
+     * The unique name for this workflow execution.
+     */
+    name: string;
+    /**
+     * The event payload passed to the workflow handler.
+     */
+    payload?: TPayload;
+}
+interface SucceedInput<TPayload = unknown> {
+    /**
+     * The payload to resolve the callback with.
+     */
+    payload?: TPayload;
+}
+interface FailInput {
+    /**
+     * The error to reject the callback with. Supports an `Error`, a string,
+     * or an object with camelCase fields like `message`, `type`, `data`, and `stack`.
+     */
+    error: unknown;
+}
+interface StopInput {
+    /**
+     * The error to reject the callback with. Supports an `Error`, a string,
+     * or an object with camelCase fields like `message`, `type`, `data`, and `stack`.
+     */
+    error?: unknown;
+}
+interface ListQuery {
+    status?: workflow.ExecutionStatus;
+    createdAt?: {
+        from?: Date;
+        to?: Date;
+        order?: "asc" | "desc";
+    };
+}
+export {};

package/dist/aws/workflow.js

@@ -0,0 +1,504 @@
+import * as durable from "@aws/durable-execution-sdk-js";
+import { aws } from "./client.js";
+/**
+ * The `workflow` SDK is a thin wrapper around the
+ * [`@aws/durable-execution-sdk-js`](https://www.npmjs.com/package/@aws/durable-execution-sdk-js)
+ * package and the AWS Lambda durable execution APIs.
+ *
+ * SST also adds a few helpers on top, including `ctx.stepWithRollback()`,
+ * `ctx.rollbackAll()`, and `ctx.waitUntil()`.
+ *
+ * @example
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ * ```
+ *
+ * @example
+ * Use `stepWithRollback()` and `rollbackAll()` to register compensating actions.
+ *
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ *
+ * export const handler = workflow.handler(async (_event, ctx) => {
+ *   try {
+ *     const order = await ctx.stepWithRollback("create-order", {
+ *       run: async () => ({ orderId: "order_123" }),
+ *       undo: async (error, result) => {
+ *         await fetch(`https://example.com/orders/${result.orderId}`, {
+ *           method: "DELETE",
+ *         });
+ *       },
+ *     });
+ *
+ *     await ctx.step("charge-card", async () => {
+ *       throw new Error("Card declined");
+ *     });
+ *
+ *     return order;
+ *   } catch (error) {
+ *     await ctx.rollbackAll(error);
+ *     throw error;
+ *   }
+ * });
+ * ```
+ *
+ * @example
+ * Use `waitUntil()` when you already know the exact time the workflow should resume.
+ *
+ * ```ts title="src/workflow.ts"
+ * import { workflow } from "sst/aws/workflow";
+ *
+ * export const handler = workflow.handler(
+ *   async (_event, ctx) => {
+ *     const resumeAt = new Date();
+ *     resumeAt.setMinutes(resumeAt.getMinutes() + 10);
+ *
+ *     await ctx.waitUntil("wait-for-follow-up", resumeAt);
+ *
+ *     return ctx.step("send-follow-up", async () => {
+ *       return { delivered: true };
+ *     });
+ *   },
+ * );
+ * ```
+ */
+export var workflow;
+(function (workflow) {
+    /**
+     * Create a durable workflow handler.
+     *
+     * @example
+     * ```ts title="src/workflow.ts"
+     * import { workflow } from "sst/aws/workflow";
+     *
+     * export const handler = workflow.handler(
+     *   async (_event, ctx) => {
+     *     const user = await ctx.step("load-user", async () => {
+     *       return { id: "user_123", email: "alice@example.com" };
+     *     });
+     *
+     *     await ctx.wait("pause-before-email", "1 minute");
+     *
+     *     return ctx.step("send-email", async () => {
+     *       return { sent: true, userId: user.id };
+     *     });
+     *   },
+     * );
+     * ```
+     */
+    function handler(input, config) {
+        return durable.withDurableExecution((event, context) => input(event, withRollback(context)), config);
+    }
+    workflow.handler = handler;
+    /**
+     * Start a new workflow execution.
+     *
+     * This is the equivalent to calling
+     * [`Invoke`](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html)
+     * for a durable Lambda function, using the durable invocation flow described in
+     * [Invoking durable Lambda functions](https://docs.aws.amazon.com/lambda/latest/dg/durable-invoking.html).
+     */
+    async function start(resource, input, options) {
+        const query = new URLSearchParams({
+            Qualifier: resource.qualifier,
+        });
+        const response = await aws.fetch("lambda", `/2015-03-31/functions/${encodeURIComponent(resource.name)}/invocations?${query.toString()}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Amz-Durable-Execution-Name": input.name,
+                "X-Amz-Invocation-Type": "Event",
+            },
+            body: input.payload === undefined
+                ? undefined
+                : JSON.stringify(input.payload),
+        }, options);
+        if (!response.ok)
+            throw new StartError(response);
+        return {
+            arn: response.headers.get("X-Amz-Durable-Execution-Arn") ?? undefined,
+            statusCode: response.status,
+            version: response.headers.get("X-Amz-Executed-Version") ?? undefined,
+        };
+    }
+    workflow.start = start;
+    /**
+     * List workflow executions.
+     *
+     * The SDK returns only the first page of results.
+     */
+    async function list(resource, query, options) {
+        const startedAfter = query.createdAt?.from?.toISOString();
+        const startedBefore = query.createdAt?.to?.toISOString();
+        const direction = query.createdAt?.order ?? "asc";
+        const status = query.status;
+        if (startedAfter && startedBefore && startedAfter > startedBefore) {
+            throw new TypeError("workflow.list createdAt.from must be before createdAt.to");
+        }
+        if (direction !== "asc" && direction !== "desc") {
+            throw new TypeError(`Unsupported workflow order direction '${direction}'`);
+        }
+        const params = new URLSearchParams({
+            MaxItems: String(workflowListPageSize),
+            Qualifier: resource.qualifier,
+        });
+        if (Array.isArray(status)) {
+            throw new TypeError("workflow.list status must be a single status");
+        }
+        if (status)
+            params.append("Statuses", status);
+        if (startedAfter)
+            params.set("StartedAfter", startedAfter);
+        if (startedBefore)
+            params.set("StartedBefore", startedBefore);
+        if (direction === "desc")
+            params.set("ReverseOrder", "true");
+        const response = await aws.fetch("lambda", `/2025-12-01/functions/${encodeURIComponent(resource.name)}/durable-executions?${params.toString()}`, {
+            method: "GET",
+        }, options);
+        if (!response.ok)
+            throw new ListError(response);
+        const data = (await response.json());
+        const executions = Array.isArray(data.DurableExecutions)
+            ? data.DurableExecutions
+            : [];
+        return {
+            executions: executions.map(parseExecution),
+        };
+    }
+    workflow.list = list;
+    /**
+     * Get the details for a single workflow execution.
+     */
+    async function describe(arn, options) {
+        const response = await aws.fetch("lambda", `/2025-12-01/durable-executions/${encodeURIComponent(arn)}`, {
+            method: "GET",
+        }, options);
+        if (!response.ok)
+            throw new DescribeError(response);
+        const data = (await response.json());
+        if (!data.DurableExecutionArn ||
+            !data.DurableExecutionName ||
+            !data.FunctionArn ||
+            data.StartTimestamp === undefined ||
+            data.Status === undefined) {
+            throw new DescribeError(response);
+        }
+        const execution = parseExecution(data);
+        return {
+            ...execution,
+            version: data.Version,
+        };
+    }
+    workflow.describe = describe;
+    /**
+     * Stop a running workflow execution.
+     */
+    async function stop(arn, input, options) {
+        const response = await aws.fetch("lambda", `/2025-12-01/durable-executions/${encodeURIComponent(arn)}/stop`, {
+            method: "POST",
+            headers: input?.error
+                ? {
+                    "Content-Type": "application/json",
+                }
+                : undefined,
+            body: input?.error === undefined
+                ? undefined
+                : JSON.stringify(normalizeError(input.error)),
+        }, options);
+        if (!response.ok)
+            throw new StopError(response);
+        const data = (await response.json());
+        return {
+            arn,
+            status: "STOPPED",
+            stoppedAt: data.StopTimestamp === undefined
+                ? undefined
+                : parseTimestamp(data.StopTimestamp),
+        };
+    }
+    workflow.stop = stop;
+    /**
+     * Send a successful result for a pending workflow callback.
+     *
+     * This is the equivalent to calling
+     * [`SendDurableExecutionCallbackSuccess`](https://docs.aws.amazon.com/lambda/latest/api/API_SendDurableExecutionCallbackSuccess.html).
+     */
+    async function succeed(token, input = {}, options) {
+        const response = await aws.fetch("lambda", `/2025-12-01/durable-execution-callbacks/${encodeURIComponent(token)}/succeed`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: input.payload === undefined
+                ? undefined
+                : JSON.stringify(input.payload),
+        }, options);
+        if (!response.ok)
+            throw new SucceedError(response);
+    }
+    workflow.succeed = succeed;
+    /**
+     * Send a failure result for a pending workflow callback.
+     *
+     * This is the equivalent to calling
+     * [`SendDurableExecutionCallbackFailure`](https://docs.aws.amazon.com/lambda/latest/api/API_SendDurableExecutionCallbackFailure.html).
+     */
+    async function fail(token, input, options) {
+        const response = await aws.fetch("lambda", `/2025-12-01/durable-execution-callbacks/${encodeURIComponent(token)}/fail`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(normalizeError(input.error)),
+        }, options);
+        if (!response.ok)
+            throw new FailError(response);
+    }
+    workflow.fail = fail;
+    /**
+     * Send a heartbeat for a pending workflow callback.
+     *
+     * This is useful when the external system handling the callback is still doing
+     * work and needs to prevent the callback from timing out.
+     *
+     * This is the equivalent to calling
+     * [`SendDurableExecutionCallbackHeartbeat`](https://docs.aws.amazon.com/lambda/latest/api/API_SendDurableExecutionCallbackHeartbeat.html).
+     */
+    async function heartbeat(token, options) {
+        const response = await aws.fetch("lambda", `/2025-12-01/durable-execution-callbacks/${encodeURIComponent(token)}/heartbeat`, {
+            method: "POST",
+        }, options);
+        if (!response.ok)
+            throw new HeartbeatError(response);
+    }
+    workflow.heartbeat = heartbeat;
+    class StartError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to start workflow");
+            this.response = response;
+        }
+    }
+    workflow.StartError = StartError;
+    class ListError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to list workflows");
+            this.response = response;
+        }
+    }
+    workflow.ListError = ListError;
+    class DescribeError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to describe workflow");
+            this.response = response;
+        }
+    }
+    workflow.DescribeError = DescribeError;
+    class StopError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to stop workflow");
+            this.response = response;
+        }
+    }
+    workflow.StopError = StopError;
+    class SucceedError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to succeed workflow callback");
+            this.response = response;
+        }
+    }
+    workflow.SucceedError = SucceedError;
+    class FailError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to fail workflow callback");
+            this.response = response;
+        }
+    }
+    workflow.FailError = FailError;
+    class HeartbeatError extends Error {
+        response;
+        constructor(response) {
+            super("Failed to heartbeat workflow callback");
+            this.response = response;
+        }
+    }
+    workflow.HeartbeatError = HeartbeatError;
+    class RollbackError extends Error {
+        stepName;
+        originalError;
+        undoError;
+        constructor(stepName, originalError, undoError) {
+            super(`Failed to rollback workflow step '${stepName}': ${undoError instanceof Error ? undoError.message : String(undoError)}`);
+            this.stepName = stepName;
+            this.originalError = originalError;
+            this.undoError = undoError;
+            this.name = "RollbackError";
+        }
+    }
+    workflow.RollbackError = RollbackError;
+})(workflow || (workflow = {}));
+const workflowListPageSize = 1000;
+const rollbackStateSymbol = Symbol("sst.workflow.rollback.state");
+function normalizeError(error) {
+    function serializeErrorData(input) {
+        if (input === undefined)
+            return undefined;
+        if (typeof input === "string")
+            return input;
+        try {
+            return JSON.stringify(input);
+        }
+        catch {
+            return String(input);
+        }
+    }
+    function normalizeStack(input) {
+        if (typeof input === "string") {
+            return input.split("\n").map((line) => line.trim());
+        }
+        if (Array.isArray(input))
+            return input.map(String);
+        return undefined;
+    }
+    if (error === undefined) {
+        return {
+            ErrorMessage: "Callback failed",
+            ErrorType: "Error",
+        };
+    }
+    if (error instanceof Error) {
+        const { message, name, stack, ...rest } = error;
+        return {
+            ErrorMessage: message,
+            ErrorType: name,
+            ErrorData: Object.keys(rest).length
+                ? serializeErrorData(rest)
+                : undefined,
+            StackTrace: normalizeStack(stack),
+        };
+    }
+    if (typeof error === "string") {
+        return {
+            ErrorMessage: error,
+            ErrorType: "Error",
+        };
+    }
+    if (error === null || typeof error !== "object") {
+        return {
+            ErrorMessage: String(error),
+            ErrorType: "Error",
+        };
+    }
+    const value = error;
+    const { data, message, name, stack, type, ...rest } = value;
+    const hasKnownFields = message !== undefined ||
+        name !== undefined ||
+        type !== undefined ||
+        data !== undefined ||
+        stack !== undefined;
+    return {
+        ErrorMessage: typeof message === "string" ? message : "Callback failed",
+        ErrorType: typeof type === "string"
+            ? type
+            : typeof name === "string"
+                ? name
+                : "Error",
+        ErrorData: data !== undefined
+            ? serializeErrorData(data)
+            : Object.keys(rest).length
+                ? serializeErrorData(rest)
+                : hasKnownFields
+                    ? undefined
+                    : serializeErrorData(error),
+        StackTrace: normalizeStack(stack),
+    };
+}
+function parseExecution(execution) {
+    return {
+        arn: execution.DurableExecutionArn,
+        name: execution.DurableExecutionName,
+        functionArn: execution.FunctionArn,
+        status: execution.Status,
+        createdAt: parseTimestamp(execution.StartTimestamp),
+        endedAt: execution.EndTimestamp === undefined
+            ? undefined
+            : parseTimestamp(execution.EndTimestamp),
+    };
+}
+function parseTimestamp(timestamp) {
+    const value = typeof timestamp === "number" ? timestamp : Number(timestamp);
+    if (Number.isFinite(value)) {
+        return new Date(value < 1_000_000_000_000 ? value * 1000 : value);
+    }
+    return new Date(timestamp);
+}
+function resolveWaitUntilDuration(until) {
+    const timestamp = until.getTime();
+    if (!Number.isFinite(timestamp)) {
+        throw new TypeError("waitUntil requires a valid Date");
+    }
+    return {
+        seconds: Math.max(0, Math.ceil((timestamp - Date.now()) / 1000)),
+    };
+}
+function withRollback(context) {
+    const wrapped = context;
+    if (wrapped[rollbackStateSymbol])
+        return wrapped;
+    const rollbackState = { undoStack: [] };
+    wrapped[rollbackStateSymbol] = rollbackState;
+    Object.defineProperty(wrapped, "stepWithRollback", {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: function (name, handler, config) {
+            const undoConfig = config?.retryStrategy || config?.semantics
+                ? {
+                    retryStrategy: config.retryStrategy,
+                    semantics: config.semantics,
+                }
+                : undefined;
+            return new durable.DurablePromise(async () => {
+                const result = await context.step(name, handler.run, config);
+                rollbackState.undoStack.push({
+                    name,
+                    execute: async (error, rollbackContext) => {
+                        await rollbackContext.step(`Undo '${name}'`, (stepContext) => handler.undo(error, result, stepContext), undoConfig);
+                    },
+                });
+                return result;
+            });
+        },
+    });
+    Object.defineProperty(wrapped, "waitUntil", {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: (name, until) => context.wait(name, resolveWaitUntilDuration(until)),
+    });
+    Object.defineProperty(wrapped, "rollbackAll", {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: async (error) => {
+            while (rollbackState.undoStack.length > 0) {
+                const rollbackStep = rollbackState.undoStack.pop();
+                if (!rollbackStep)
+                    continue;
+                try {
+                    await rollbackStep.execute(error, context);
+                }
+                catch (undoError) {
+                    throw new workflow.RollbackError(rollbackStep.name, error, undoError);
+                }
+            }
+        },
+    });
+    return wrapped;
+}

package/dist/vector/index.js

@@ -1,5 +1,5 @@
 import { Resource } from "../resource.js";
-import { client } from "../aws/client.js";
+import { aws } from "../aws/client.js";
 /**
  * Create a client to interact with the Vector database.
  * @example
@@ -48,7 +48,7 @@ export function VectorClient(name) {
 }
 async function invokeFunction(functionName, body, errorMessage, attempts = 0) {
     try {
-        const c = await client();
+        const c = await aws.client();
         const endpoint = `https://lambda.${process.env.AWS_REGION}.amazonaws.com/2015-03-31`;
         const response = await c.fetch(`${endpoint}/functions/${functionName}/invocations`, {
             method: "POST",

package/package.json

@@ -3,7 +3,7 @@
   "name": "sst",
   "type": "module",
   "sideEffects": false,
-  "version": "4.6.11",
+  "version": "4.7.0",
   "main": "./dist/index.js",
   "repository": {
     "type": "git",
@@ -27,6 +27,7 @@
     "release": "./scripts/release.ts"
   },
   "devDependencies": {
+    "@aws/durable-execution-sdk-js-testing": "^1.1.1",
     "@tsconfig/node20": "20.1.4",
     "@types/aws-lambda": "^8.10.155",
     "@types/node": "22.10.0",
@@ -44,16 +45,17 @@
     "sst": "./bin/sst.mjs"
   },
   "optionalDependencies": {
-    "sst-linux-x64": "4.6.11",
-    "sst-linux-x86": "4.6.11",
-    "sst-darwin-x64": "4.6.11",
-    "sst-linux-arm64": "4.6.11",
-    "sst-darwin-arm64": "4.6.11",
-    "sst-win32-x64": "4.6.11",
-    "sst-win32-x86": "4.6.11",
-    "sst-win32-arm64": "4.6.11"
+    "sst-linux-x64": "4.7.0",
+    "sst-linux-x86": "4.7.0",
+    "sst-darwin-x64": "4.7.0",
+    "sst-linux-arm64": "4.7.0",
+    "sst-darwin-arm64": "4.7.0",
+    "sst-win32-x64": "4.7.0",
+    "sst-win32-x86": "4.7.0",
+    "sst-win32-arm64": "4.7.0"
   },
   "dependencies": {
+    "@aws/durable-execution-sdk-js": "1.0.2",
     "aws4fetch": "1.0.18",
     "jose": "5.2.3",
     "openid-client": "5.6.4"