sst 2.25.3 → 2.25.4

package/constructs/App.js

@@ -195,7 +195,7 @@ export class App extends CDKApp {
                 // Tag stacks
                 Tags.of(child).add("sst:app", this.name);
                 Tags.of(child).add("sst:stage", this.stage);
-                if (child instanceof Stack && process.env.NODE_ENV !== "test") {
+                if (child instanceof Stack && !this.isRunningSSTTest()) {
                     const bootstrap = await useBootstrap();
                     const functions = useFunctions();
                     const sourcemaps = functions.sourcemaps.forStack(child.stackName);
@@ -240,8 +240,7 @@ export class App extends CDKApp {
         }
     }
     isRunningSSTTest() {
-        // Check the env var set inside test/setup-tests.js
-        return process.env.SST_RESOURCES_TESTS === "enabled";
+        return process.env.NODE_ENV === "test";
     }
     getInputFilesFromEsbuildMetafile(file) {
         let metaJson;

package/constructs/Function.js

@@ -176,6 +176,8 @@ export class Function extends CDKFunction {
             });
             this.addEnvironment("SST_FUNCTION_ID", this.node.addr);
             useDeferredTasks().add(async () => {
+                if (app.isRunningSSTTest())
+                    return;
                 const bootstrap = await useBootstrap();
                 const bootstrapBucketArn = `arn:${Stack.of(this).partition}:s3:::${bootstrap.bucket}`;
                 this.attachPermissions([

package/node/future/auth/handler.d.ts

@@ -25,7 +25,9 @@ export declare function AuthHandler<Providers extends Record<string, Adapter<any
 }[keyof Providers]>(input: {
     providers: Providers;
     sessions?: Sessions;
-    clients: () => Promise<Record<string, string>>;
+    /** @deprecated use allowClient callback instead */
+    clients?: () => Promise<Record<string, string>>;
+    allowClient?: (clientID: string, redirect: string) => Promise<boolean>;
     onAuthorize?: (event: APIGatewayProxyEventV2) => Promise<void | keyof Providers>;
     onSuccess: (input: Result, response: OnSuccessResponder<SessionValue | {
         [key in keyof Sessions["$type"]]: {

package/node/future/auth/handler.js

@@ -14,7 +14,7 @@ export function AuthHandler(input) {
             if (input.onIndex) {
                 return input.onIndex(evt);
             }
-            const clients = await input.clients();
+            const clients = (await input.clients?.()) || {};
             return {
                 statusCode: 200,
                 headers: {
@@ -107,6 +107,12 @@ export function AuthHandler(input) {
                 ...useCookies(),
                 ...useQueryParams(),
             };
+            if (!redirect_uri) {
+                return {
+                    statusCode: 400,
+                    body: "Missing redirect_uri",
+                };
+            }
             if (!provider) {
                 return {
                     statusCode: 400,
@@ -125,10 +131,20 @@ export function AuthHandler(input) {
                     body: "Missing client_id",
                 };
             }
-            if (!redirect_uri) {
+            if (input.clients) {
+                const clients = await input.clients();
+                if (clients[client_id] !== redirect_uri) {
+                    return {
+                        statusCode: 400,
+                        body: "Invalid redirect_uri",
+                    };
+                }
+            }
+            if (input.allowClient &&
+                !(await input.allowClient(client_id, redirect_uri))) {
                 return {
                     statusCode: 400,
-                    body: "Missing redirect_uri",
+                    body: "Invalid redirect_uri",
                 };
             }
             useResponse().cookies({

package/package.json

@@ -1,7 +1,7 @@
 {
   "sideEffects": false,
   "name": "sst",
-  "version": "2.25.3",
+  "version": "2.25.4",
   "bin": {
     "sst": "cli/sst.js"
   },

package/runtime/handlers/container.d.ts

@@ -1 +1,2 @@
-export declare const useContainerHandler: () => Promise<void>;
+import { RuntimeHandler } from "../handlers.js";
+export declare const useContainerHandler: () => RuntimeHandler;

package/runtime/handlers/container.js

@@ -1,114 +1,16 @@
 import http from "http";
 import { spawn } from "child_process";
-import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
 import { useRuntimeServerConfig } from "../server.js";
-import { Context } from "../../context/context.js";
 import { VisibleError } from "../../error.js";
 import { isChild } from "../../util/fs.js";
 import { execAsync } from "../../util/process.js";
 import { useFunctions } from "../../constructs/Function.js";
-export const useContainerHandler = Context.memo(async () => {
-    const workers = await useRuntimeWorkers();
-    const server = await useRuntimeServerConfig();
-    const handlers = useRuntimeHandlers();
+export const useContainerHandler = () => {
     const containers = new Map();
     const sources = new Map();
-    handlers.register({
-        shouldBuild: (input) => {
-            const parent = sources.get(input.functionID);
-            if (!parent)
-                return false;
-            return isChild(parent, input.file);
-        },
-        canHandle: (input) => input.startsWith("container"),
-        startWorker: async (input) => {
-            input.environment.SST_DEBUG_JOB
-                ? startJobWorker(input)
-                : startLambdaWorker(input);
-        },
-        stopWorker: async (workerID) => {
-            const name = containers.get(workerID);
-            if (name) {
-                try {
-                    // note:
-                    // - calling `docker kill` kills the docker process much faster than `docker stop`
-                    // - process.kill() does not work on docker processes
-                    await execAsync(`docker kill ${name}`, {
-                        env: {
-                            ...process.env,
-                        },
-                    });
-                }
-                catch (ex) {
-                    console.error(ex);
-                    throw new VisibleError(`Could not stop docker container ${name}`);
-                }
-                containers.delete(workerID);
-            }
-        },
-        build: async (input) => {
-            const project = input.props.handler;
-            sources.set(input.functionID, project);
-            if (input.mode === "start") {
-                try {
-                    const result = await execAsync([
-                        `docker build`,
-                        `-t sst-dev:${input.functionID}`,
-                        ...(input.props.container?.file
-                            ? [`-f ${input.props.container.file}`]
-                            : []),
-                        ...Object.entries(input.props.container?.buildArgs || {}).map(([k, v]) => `--build-arg ${k}=${v}`),
-                        `.`,
-                    ].join(" "), {
-                        cwd: project,
-                        env: {
-                            ...process.env,
-                        },
-                    });
-                }
-                catch (ex) {
-                    return {
-                        type: "error",
-                        errors: [String(ex)],
-                    };
-                }
-            }
-            if (input.mode === "deploy") {
-                try {
-                    const platform = input.props.architecture === "arm_64"
-                        ? "linux/arm64"
-                        : "linux/amd64";
-                    await execAsync([
-                        `docker build`,
-                        `-t sst-build:${input.functionID}`,
-                        ...(input.props.container?.file
-                            ? [`-f ${input.props.container.file}`]
-                            : []),
-                        ...Object.entries(input.props.container?.buildArgs || {}).map(([k, v]) => `--build-arg ${k}=${v}`),
-                        `--platform ${platform}`,
-                        `.`,
-                    ].join(" "), {
-                        cwd: project,
-                        env: {
-                            ...process.env,
-                        },
-                    });
-                }
-                catch (ex) {
-                    return {
-                        type: "error",
-                        errors: [String(ex)],
-                    };
-                }
-            }
-            return {
-                type: "success",
-                handler: "not required for container",
-            };
-        },
-    });
-    function dockerRun(input, opts, onExit) {
+    async function dockerRun(input, opts, onExit) {
+        const workers = await useRuntimeWorkers();
         const name = `sst-workerID-${input.workerID}-${Date.now()}`;
         const proc = spawn("docker", [
             "run",
@@ -144,7 +46,9 @@ export const useContainerHandler = Context.memo(async () => {
         });
         containers.set(input.workerID, name);
     }
-    function startLambdaWorker(input) {
+    async function startLambdaWorker(input) {
+        const server = await useRuntimeServerConfig();
+        const workers = await useRuntimeWorkers();
         const fn = useFunctions().fromID(input.functionID);
         dockerRun(input, {
             cmd: fn?.container?.cmd,
@@ -156,6 +60,7 @@ export const useContainerHandler = Context.memo(async () => {
         });
     }
     async function startJobWorker(input) {
+        const workers = await useRuntimeWorkers();
         // Job container is special:
         // 1. Not capable of receiving the `event` payload
         //    - on `sst deploy`, the CodeBuild job is started with `SST_PAYLOAD` env var
@@ -166,7 +71,7 @@ export const useContainerHandler = Context.memo(async () => {
         const awsRequestId = result.headers["lambda-runtime-aws-request-id"];
         const fn = useFunctions().fromID(input.functionID);
         try {
-            dockerRun(input, {
+            await dockerRun(input, {
                 entrypoint: "",
                 cmd: fn?.container?.cmd,
                 envs: {
@@ -261,4 +166,98 @@ export const useContainerHandler = Context.memo(async () => {
             });
         }
     }
-});
+    return {
+        shouldBuild: (input) => {
+            const parent = sources.get(input.functionID);
+            if (!parent)
+                return false;
+            return isChild(parent, input.file);
+        },
+        canHandle: (input) => input.startsWith("container"),
+        startWorker: async (input) => {
+            input.environment.SST_DEBUG_JOB
+                ? await startJobWorker(input)
+                : await startLambdaWorker(input);
+        },
+        stopWorker: async (workerID) => {
+            const name = containers.get(workerID);
+            if (name) {
+                try {
+                    // note:
+                    // - calling `docker kill` kills the docker process much faster than `docker stop`
+                    // - process.kill() does not work on docker processes
+                    await execAsync(`docker kill ${name}`, {
+                        env: {
+                            ...process.env,
+                        },
+                    });
+                }
+                catch (ex) {
+                    console.error(ex);
+                    throw new VisibleError(`Could not stop docker container ${name}`);
+                }
+                containers.delete(workerID);
+            }
+        },
+        build: async (input) => {
+            const project = input.props.handler;
+            sources.set(input.functionID, project);
+            if (input.mode === "start") {
+                try {
+                    const result = await execAsync([
+                        `docker build`,
+                        `-t sst-dev:${input.functionID}`,
+                        ...(input.props.container?.file
+                            ? [`-f ${input.props.container.file}`]
+                            : []),
+                        ...Object.entries(input.props.container?.buildArgs || {}).map(([k, v]) => `--build-arg ${k}=${v}`),
+                        `.`,
+                    ].join(" "), {
+                        cwd: project,
+                        env: {
+                            ...process.env,
+                        },
+                    });
+                }
+                catch (ex) {
+                    return {
+                        type: "error",
+                        errors: [String(ex)],
+                    };
+                }
+            }
+            if (input.mode === "deploy") {
+                try {
+                    const platform = input.props.architecture === "arm_64"
+                        ? "linux/arm64"
+                        : "linux/amd64";
+                    await execAsync([
+                        `docker build`,
+                        `-t sst-build:${input.functionID}`,
+                        ...(input.props.container?.file
+                            ? [`-f ${input.props.container.file}`]
+                            : []),
+                        ...Object.entries(input.props.container?.buildArgs || {}).map(([k, v]) => `--build-arg ${k}=${v}`),
+                        `--platform ${platform}`,
+                        `.`,
+                    ].join(" "), {
+                        cwd: project,
+                        env: {
+                            ...process.env,
+                        },
+                    });
+                }
+                catch (ex) {
+                    return {
+                        type: "error",
+                        errors: [String(ex)],
+                    };
+                }
+            }
+            return {
+                type: "success",
+                handler: "not required for container",
+            };
+        },
+    };
+};

package/runtime/handlers/dotnet.d.ts

@@ -1 +1,2 @@
-export declare const useDotnetHandler: () => Promise<void>;
+import { RuntimeHandler } from "../handlers.js";
+export declare const useDotnetHandler: () => RuntimeHandler;

package/runtime/handlers/dotnet.js

@@ -1,6 +1,4 @@
-import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
-import { Context } from "../../context/context.js";
 import { spawn } from "child_process";
 import { useRuntimeServerConfig } from "../server.js";
 import { findBelow, isChild } from "../../util/fs.js";
@@ -21,14 +19,11 @@ const BOOTSTRAP_MAP = {
     "dotnetcore3.1": "dotnet31-bootstrap",
     dotnet6: "dotnet6-bootstrap",
 };
-export const useDotnetHandler = Context.memo(async () => {
-    const workers = await useRuntimeWorkers();
-    const server = await useRuntimeServerConfig();
-    const handlers = useRuntimeHandlers();
+export const useDotnetHandler = () => {
     const processes = new Map();
     const sources = new Map();
     const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;
-    handlers.register({
+    return {
         shouldBuild: (input) => {
             if (!input.file.endsWith(".cs") && !input.file.endsWith(".fs"))
                 return false;
@@ -39,6 +34,8 @@ export const useDotnetHandler = Context.memo(async () => {
         },
         canHandle: (input) => input.startsWith("dotnet"),
         startWorker: async (input) => {
+            const workers = await useRuntimeWorkers();
+            const server = await useRuntimeServerConfig();
             const name = input.handler.split(":")[0];
             const proc = spawn(`dotnet`, [
                 `exec`,
@@ -114,5 +111,5 @@ export const useDotnetHandler = Context.memo(async () => {
                 };
             }
         },
-    });
-});
+    };
+};

package/runtime/handlers/go.d.ts

@@ -1 +1,2 @@
-export declare const useGoHandler: () => Promise<void>;
+import { RuntimeHandler } from "../handlers.js";
+export declare const useGoHandler: () => RuntimeHandler;

package/runtime/handlers/go.js

@@ -1,22 +1,17 @@
 import path from "path";
 import fs from "fs/promises";
 import os from "os";
-import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
-import { Context } from "../../context/context.js";
 import { VisibleError } from "../../error.js";
 import { spawn } from "child_process";
 import { useRuntimeServerConfig } from "../server.js";
 import { isChild } from "../../util/fs.js";
 import { execAsync } from "../../util/process.js";
-export const useGoHandler = Context.memo(async () => {
-    const workers = await useRuntimeWorkers();
-    const server = await useRuntimeServerConfig();
-    const handlers = useRuntimeHandlers();
+export const useGoHandler = () => {
     const processes = new Map();
     const sources = new Map();
     const handlerName = process.platform === "win32" ? `bootstrap.exe` : `bootstrap`;
-    handlers.register({
+    return {
         shouldBuild: (input) => {
             const parent = sources.get(input.functionID);
             if (!parent)
@@ -25,6 +20,8 @@ export const useGoHandler = Context.memo(async () => {
         },
         canHandle: (input) => input.startsWith("go"),
         startWorker: async (input) => {
+            const workers = await useRuntimeWorkers();
+            const server = await useRuntimeServerConfig();
             const proc = spawn(path.join(input.out, handlerName), {
                 env: {
                     ...process.env,
@@ -115,8 +112,8 @@ export const useGoHandler = Context.memo(async () => {
                 handler: "bootstrap",
             };
         },
-    });
-});
+    };
+};
 async function find(dir, target) {
     if (dir === "/")
         throw new VisibleError(`Could not find a ${target} file`);

package/runtime/handlers/java.d.ts

@@ -1 +1,2 @@
-export declare const useJavaHandler: () => Promise<void>;
+import { RuntimeHandler } from "../handlers.js";
+export declare const useJavaHandler: () => RuntimeHandler;

package/runtime/handlers/java.js

@@ -1,9 +1,7 @@
 import path from "path";
 import fs from "fs/promises";
 import os from "os";
-import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
-import { Context } from "../../context/context.js";
 import { spawn } from "child_process";
 import { useRuntimeServerConfig } from "../server.js";
 import { existsAsync, findBelow, isChild } from "../../util/fs.js";
@@ -11,14 +9,11 @@ import { useProject } from "../../project.js";
 import { execAsync } from "../../util/process.js";
 import url from "url";
 import AdmZip from "adm-zip";
-export const useJavaHandler = Context.memo(async () => {
-    const workers = await useRuntimeWorkers();
-    const server = await useRuntimeServerConfig();
-    const handlers = useRuntimeHandlers();
+export const useJavaHandler = () => {
     const processes = new Map();
     const sources = new Map();
     const runningBuilds = new Map();
-    handlers.register({
+    return {
         shouldBuild: (input) => {
             if (!input.file.endsWith(".java"))
                 return false;
@@ -29,6 +24,8 @@ export const useJavaHandler = Context.memo(async () => {
         },
         canHandle: (input) => input.startsWith("java"),
         startWorker: async (input) => {
+            const workers = await useRuntimeWorkers();
+            const server = await useRuntimeServerConfig();
             const proc = spawn(`java`, [
                 `-cp`,
                 [
@@ -96,8 +93,8 @@ export const useJavaHandler = Context.memo(async () => {
                 };
             }
         },
-    });
-});
+    };
+};
 async function getGradleBinary(srcPath) {
     // Use a gradle wrapper if provided in the folder, otherwise fall back
     // to system "gradle"

package/runtime/handlers/node.d.ts

@@ -1 +1,2 @@
-export declare const useNodeHandler: () => Promise<void>;
+import { RuntimeHandler } from "../handlers.js";
+export declare const useNodeHandler: () => RuntimeHandler;

package/runtime/handlers/node.js

@@ -7,15 +7,11 @@ import { useProject } from "../../project.js";
 import esbuild from "esbuild";
 import url from "url";
 import { Worker } from "worker_threads";
-import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
-import { Context } from "../../context/context.js";
 import { Colors } from "../../cli/colors.js";
 import { Logger } from "../../logger.js";
 import { findAbove } from "../../util/fs.js";
-export const useNodeHandler = Context.memo(async () => {
-    const workers = await useRuntimeWorkers();
-    const handlers = useRuntimeHandlers();
+export const useNodeHandler = () => {
     const rebuildCache = {};
     process.on("exit", () => {
         for (const { ctx } of Object.values(rebuildCache)) {
@@ -24,7 +20,7 @@ export const useNodeHandler = Context.memo(async () => {
     });
     const project = useProject();
     const threads = new Map();
-    handlers.register({
+    return {
         shouldBuild: (input) => {
             const cache = rebuildCache[input.functionID];
             if (!cache)
@@ -37,6 +33,7 @@ export const useNodeHandler = Context.memo(async () => {
         },
         canHandle: (input) => input.startsWith("nodejs"),
         startWorker: async (input) => {
+            const workers = await useRuntimeWorkers();
             new Promise(async () => {
                 const worker = new Worker(url.fileURLToPath(new URL("../../support/nodejs-runtime/index.mjs", import.meta.url)), {
                     env: {
@@ -253,8 +250,8 @@ export const useNodeHandler = Context.memo(async () => {
                 };
             }
         },
-    });
-});
+    };
+};
 function logMemoryUsage(functionID, handler) {
     const printInMB = (bytes) => `${Math.round(bytes / 1024 / 1024)} MB`;
     const used = process.memoryUsage();

package/runtime/handlers/python.d.ts

@@ -1 +1,2 @@
-export declare const usePythonHandler: () => Promise<void>;
+import { RuntimeHandler } from "../handlers.js";
+export declare const usePythonHandler: () => RuntimeHandler;

package/runtime/handlers/python.js

@@ -1,7 +1,5 @@
 import path from "path";
-import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
-import { Context } from "../../context/context.js";
 import { exec, spawn } from "child_process";
 import { promisify } from "util";
 import { useRuntimeServerConfig } from "../server.js";
@@ -20,10 +18,7 @@ const RUNTIME_MAP = {
     "python3.10": Runtime.PYTHON_3_10,
     "python3.11": Runtime.PYTHON_3_11,
 };
-export const usePythonHandler = Context.memo(async () => {
-    const workers = await useRuntimeWorkers();
-    const server = await useRuntimeServerConfig();
-    const handlers = useRuntimeHandlers();
+export const usePythonHandler = () => {
     const processes = new Map();
     const sources = new Map();
     async function findSrc(input) {
@@ -34,7 +29,7 @@ export const usePythonHandler = Context.memo(async () => {
                 return result;
         }
     }
-    handlers.register({
+    return {
         shouldBuild: (input) => {
             const parent = sources.get(input.functionID);
             if (!parent)
@@ -43,6 +38,8 @@ export const usePythonHandler = Context.memo(async () => {
         },
         canHandle: (input) => input.startsWith("python"),
         startWorker: async (input) => {
+            const workers = await useRuntimeWorkers();
+            const server = await useRuntimeServerConfig();
             const src = await findSrc(input.handler);
             if (!src)
                 throw new Error(`Could not find src for ${input.handler}`);
@@ -142,5 +139,5 @@ export const usePythonHandler = Context.memo(async () => {
                     .join(path.posix.sep),
             };
         },
-    });
-});
+    };
+};

package/runtime/handlers/rust.d.ts

@@ -1 +1,2 @@
-export declare const useRustHandler: () => Promise<void>;
+import { RuntimeHandler } from "../handlers.js";
+export declare const useRustHandler: () => RuntimeHandler;

package/runtime/handlers/rust.js

@@ -1,21 +1,16 @@
 import path from "path";
 import fs from "fs/promises";
-import { useRuntimeHandlers } from "../handlers.js";
 import { useRuntimeWorkers } from "../workers.js";
-import { Context } from "../../context/context.js";
 import { exec, spawn } from "child_process";
 import { promisify } from "util";
 import { useRuntimeServerConfig } from "../server.js";
 import { findAbove, isChild } from "../../util/fs.js";
 const execAsync = promisify(exec);
-export const useRustHandler = Context.memo(async () => {
-    const workers = await useRuntimeWorkers();
-    const server = await useRuntimeServerConfig();
-    const handlers = useRuntimeHandlers();
+export const useRustHandler = () => {
     const processes = new Map();
     const sources = new Map();
     const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;
-    handlers.register({
+    return {
         shouldBuild: (input) => {
             if (!input.file.endsWith(".rs"))
                 return false;
@@ -27,6 +22,8 @@ export const useRustHandler = Context.memo(async () => {
         },
         canHandle: (input) => input.startsWith("rust"),
         startWorker: async (input) => {
+            const workers = await useRuntimeWorkers();
+            const server = await useRuntimeServerConfig();
             const proc = spawn(path.join(input.out, handlerName), {
                 env: {
                     ...process.env,
@@ -109,5 +106,5 @@ export const useRustHandler = Context.memo(async () => {
                 handler: "handler",
             };
         },
-    });
-});
+    };
+};

package/runtime/handlers.js

@@ -6,8 +6,23 @@ import { useWatcher } from "../watcher.js";
 import { useBus } from "../bus.js";
 import { useProject } from "../project.js";
 import { useFunctions } from "../constructs/Function.js";
+import { useNodeHandler } from "./handlers/node.js";
+import { useContainerHandler } from "./handlers/container.js";
+import { useDotnetHandler } from "./handlers/dotnet.js";
+import { useGoHandler } from "./handlers/go.js";
+import { useJavaHandler } from "./handlers/java.js";
+import { usePythonHandler } from "./handlers/python.js";
+import { useRustHandler } from "./handlers/rust.js";
 export const useRuntimeHandlers = Context.memo(() => {
-    const handlers = [];
+    const handlers = [
+        useNodeHandler(),
+        useGoHandler(),
+        useContainerHandler(),
+        usePythonHandler(),
+        useJavaHandler(),
+        useDotnetHandler(),
+        useRustHandler(),
+    ];
     const project = useProject();
     const bus = useBus();
     const pendingBuilds = new Map();

package/stacks/synth.js

@@ -4,7 +4,6 @@ import { useAWSProvider, useSTSIdentity } from "../credentials.js";
 import * as contextproviders from "sst-aws-cdk/lib/context-providers/index.js";
 import path from "path";
 import { VisibleError } from "../error.js";
-import { useDotnetHandler } from "../runtime/handlers/dotnet.js";
 export async function synth(opts) {
     Logger.debug("Synthesizing stacks...");
     const { App } = await import("../constructs/App.js");
@@ -15,13 +14,6 @@ export async function synth(opts) {
     const { usePythonHandler } = await import("../runtime/handlers/python.js");
     const { useJavaHandler } = await import("../runtime/handlers/java.js");
     if (opts.mode !== "remove") {
-        useNodeHandler();
-        useGoHandler();
-        useContainerHandler();
-        usePythonHandler();
-        useJavaHandler();
-        useDotnetHandler();
-        useRustHandler();
     }
     const cxapi = await import("@aws-cdk/cx-api");
     const { Configuration } = await import("sst-aws-cdk/lib/settings.js");