sst 2.0.18 → 2.0.20

package/sst.mjs

@@ -2291,9 +2291,11 @@ var init_server2 = __esm({
             "Lambda-Runtime-Client-Context": JSON.stringify(
               payload.context.clientContext || {}
             ),
-            "Lambda-Runtime-Cognito-Identity": JSON.stringify(
-              payload.context.identity || {}
-            )
+            ...payload.context.identity ? {
+              "Lambda-Runtime-Cognito-Identity": JSON.stringify(
+                payload.context.identity
+              )
+            } : {}
           });
           res.json(payload.event);
         }
@@ -2302,10 +2304,13 @@ var init_server2 = __esm({
         `/:workerID/${cfg.API_VERSION}/runtime/invocation/:awsRequestId/response`,
         express2.json({
           strict: false,
-          type: ["application/json", "application/*+json"],
+          type() {
+            return true;
+          },
           limit: "10mb"
         }),
         (req, res) => {
+          console.log(JSON.stringify(req.body, null, 4));
           Logger.debug("Worker", req.params.workerID, "got response", req.body);
           const worker = workers.fromID(req.params.workerID);
           bus.publish("function.success", {
@@ -4180,6 +4185,9 @@ async function publishAssets4(stacks) {
   return results;
 }
 async function deployMany(stacks) {
+  if (stacks.length === 0) {
+    throw new VisibleError("No stacks to deploy");
+  }
   Logger.debug(
     "Deploying stacks",
     stacks.map((s) => s.stackName)
@@ -4355,13 +4363,13 @@ async function listImports(exportName) {
   }
 }
 async function getLocalTemplate(stack) {
-  const fs18 = await import("fs/promises");
-  const fileContent = await fs18.readFile(stack.templateFullPath);
+  const fs19 = await import("fs/promises");
+  const fileContent = await fs19.readFile(stack.templateFullPath);
   return fileContent.toString();
 }
 async function saveLocalTemplate(stack, content) {
-  const fs18 = await import("fs/promises");
-  await fs18.writeFile(stack.templateFullPath, content);
+  const fs19 = await import("fs/promises");
+  await fs19.writeFile(stack.templateFullPath, content);
 }
 var init_deploy = __esm({
   "src/stacks/deploy.ts"() {
@@ -4370,6 +4378,7 @@ var init_deploy = __esm({
     init_credentials();
     init_logger();
     init_monitor();
+    init_error();
   }
 });
 
@@ -5048,19 +5057,131 @@ var init_go = __esm({
   }
 });
 
+// src/runtime/handlers/rust.ts
+var rust_exports = {};
+__export(rust_exports, {
+  useRustHandler: () => useRustHandler
+});
+import path12 from "path";
+import fs12 from "fs/promises";
+import { exec as exec4, spawn as spawn4 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execAsync3, useRustHandler;
+var init_rust = __esm({
+  "src/runtime/handlers/rust.ts"() {
+    "use strict";
+    init_handlers();
+    init_workers();
+    init_context();
+    init_error();
+    init_server2();
+    init_fs();
+    execAsync3 = promisify3(exec4);
+    useRustHandler = Context.memo(async () => {
+      const workers = await useRuntimeWorkers();
+      const server = await useRuntimeServerConfig();
+      const handlers = useRuntimeHandlers();
+      const processes = /* @__PURE__ */ new Map();
+      const sources = /* @__PURE__ */ new Map();
+      const handlerName = process.platform === "win32" ? `handler.exe` : `handler`;
+      handlers.register({
+        shouldBuild: (input) => {
+          if (!input.file.endsWith(".rs"))
+            return false;
+          const parent = sources.get(input.functionID);
+          if (!parent)
+            return false;
+          const result = isChild(parent, input.file);
+          return result;
+        },
+        canHandle: (input) => input.startsWith("rust"),
+        startWorker: async (input) => {
+          const proc = spawn4(path12.join(input.out, handlerName), {
+            env: {
+              ...process.env,
+              ...input.environment,
+              IS_LOCAL: "true",
+              RUST_BACKTRACE: "1",
+              AWS_LAMBDA_RUNTIME_API: `http://localhost:${server.port}/${input.workerID}`,
+              AWS_LAMBDA_FUNCTION_MEMORY_SIZE: "1024"
+            },
+            cwd: input.out
+          });
+          proc.on("exit", () => workers.exited(input.workerID));
+          proc.stdout.on("data", (data2) => {
+            workers.stdout(input.workerID, data2.toString());
+          });
+          proc.stderr.on("data", (data2) => {
+            workers.stdout(input.workerID, data2.toString());
+          });
+          processes.set(input.workerID, proc);
+        },
+        stopWorker: async (workerID) => {
+          const proc = processes.get(workerID);
+          if (proc) {
+            proc.kill();
+            processes.delete(workerID);
+          }
+        },
+        build: async (input) => {
+          const parsed = path12.parse(input.props.handler);
+          const project = await findAbove(parsed.dir, "Cargo.toml");
+          sources.set(input.functionID, project);
+          if (input.mode === "start") {
+            try {
+              await execAsync3(`cargo build --bin ${parsed.name}`, {
+                cwd: project,
+                env: {
+                  ...process.env
+                }
+              });
+              await fs12.cp(
+                path12.join(project, `target/debug`, parsed.name),
+                path12.join(input.out, "handler")
+              );
+            } catch (ex) {
+              throw new VisibleError("Failed to build");
+            }
+          }
+          if (input.mode === "deploy") {
+            try {
+              await execAsync3(`cargo lambda build --release --bin ${parsed.name}`, {
+                cwd: project,
+                env: {
+                  ...process.env
+                }
+              });
+              await fs12.cp(
+                path12.join(project, `target/lambda/`, parsed.name, "bootstrap"),
+                path12.join(input.out, "bootstrap")
+              );
+            } catch (ex) {
+              throw new VisibleError("Failed to build");
+            }
+          }
+          return {
+            type: "success",
+            handler: "handler"
+          };
+        }
+      });
+    });
+  }
+});
+
 // src/runtime/handlers/python.ts
 var python_exports = {};
 __export(python_exports, {
   usePythonHandler: () => usePythonHandler
 });
-import path12 from "path";
-import { exec as exec4, spawn as spawn4 } from "child_process";
-import { promisify as promisify3 } from "util";
+import path13 from "path";
+import { exec as exec5, spawn as spawn5 } from "child_process";
+import { promisify as promisify4 } from "util";
 import { Runtime as Runtime2 } from "aws-cdk-lib/aws-lambda";
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 import os3 from "os";
 import url6 from "url";
-var execAsync3, RUNTIME_MAP, usePythonHandler;
+var execAsync4, RUNTIME_MAP, usePythonHandler;
 var init_python = __esm({
   "src/runtime/handlers/python.ts"() {
     "use strict";
@@ -5069,7 +5190,7 @@ var init_python = __esm({
     init_context();
     init_server2();
     init_fs();
-    execAsync3 = promisify3(exec4);
+    execAsync4 = promisify4(exec5);
     RUNTIME_MAP = {
       "python2.7": Runtime2.PYTHON_2_7,
       "python3.6": Runtime2.PYTHON_3_6,
@@ -5093,9 +5214,9 @@ var init_python = __esm({
         canHandle: (input) => input.startsWith("python"),
         startWorker: async (input) => {
           const src = await findAbove(input.handler, "requirements.txt");
-          const parsed = path12.parse(path12.relative(src, input.handler));
-          const target = [...parsed.dir.split(path12.sep), parsed.name].join(".");
-          const proc = spawn4(
+          const parsed = path13.parse(path13.relative(src, input.handler));
+          const target = [...parsed.dir.split(path13.sep), parsed.name].join(".");
+          const proc = spawn5(
             os3.platform() === "win32" ? "python.exe" : "python3",
             [
               "-u",
@@ -5141,18 +5262,18 @@ var init_python = __esm({
               handler: input.props.handler
             };
           const src = await findAbove(input.props.handler, "requirements.txt");
-          await fs12.cp(src, input.out, {
+          await fs13.cp(src, input.out, {
             recursive: true,
             filter: (src2) => !src2.includes(".sst")
           });
           if (input.props.python?.installCommands) {
             for (const cmd of input.props.python.installCommands) {
-              await execAsync3(cmd);
+              await execAsync4(cmd);
             }
           }
           const result = {
             type: "success",
-            handler: path12.relative(src, path12.resolve(input.props.handler))
+            handler: path13.relative(src, path13.resolve(input.props.handler))
           };
           return result;
         }
@@ -5166,14 +5287,14 @@ var java_exports = {};
 __export(java_exports, {
   useJavaHandler: () => useJavaHandler
 });
-import path13 from "path";
-import fs13 from "fs/promises";
+import path14 from "path";
+import fs14 from "fs/promises";
 import os4 from "os";
 import zipLocal from "zip-local";
-import { spawn as spawn5 } from "child_process";
+import { spawn as spawn6 } from "child_process";
 import url7 from "url";
 async function getGradleBinary(srcPath) {
-  const gradleWrapperPath = path13.resolve(path13.join(srcPath, "gradlew"));
+  const gradleWrapperPath = path14.resolve(path14.join(srcPath, "gradlew"));
   return await existsAsync(gradleWrapperPath) ? gradleWrapperPath : "gradle";
 }
 var useJavaHandler;
@@ -5205,7 +5326,7 @@ var init_java = __esm({
         },
         canHandle: (input) => input.startsWith("java"),
         startWorker: async (input) => {
-          const proc = spawn5(
+          const proc = spawn6(
             `java`,
             [
               `-cp`,
@@ -5257,11 +5378,11 @@ var init_java = __esm({
                 cwd: srcPath
               }
             );
-            const buildOutput = path13.join(srcPath, "build", outputDir);
-            const zip = (await fs13.readdir(buildOutput)).find(
+            const buildOutput = path14.join(srcPath, "build", outputDir);
+            const zip = (await fs14.readdir(buildOutput)).find(
               (f) => f.endsWith(".zip")
             );
-            zipLocal.sync.unzip(path13.join(buildOutput, zip)).save(input.out);
+            zipLocal.sync.unzip(path14.join(buildOutput, zip)).save(input.out);
             return {
               type: "success",
               handler: input.props.handler
@@ -5280,12 +5401,13 @@ var init_java = __esm({
 
 // src/stacks/synth.ts
 import * as contextproviders from "aws-cdk/lib/context-providers/index.js";
-import path14 from "path";
+import path15 from "path";
 async function synth(opts) {
   Logger.debug("Synthesizing stacks...");
   const { App: App2 } = await import("../src/constructs/App.js");
   const { useNodeHandler: useNodeHandler2 } = await Promise.resolve().then(() => (init_node(), node_exports));
   const { useGoHandler: useGoHandler2 } = await Promise.resolve().then(() => (init_go(), go_exports));
+  const { useRustHandler: useRustHandler2 } = await Promise.resolve().then(() => (init_rust(), rust_exports));
   const { usePythonHandler: usePythonHandler2 } = await Promise.resolve().then(() => (init_python(), python_exports));
   const { useJavaHandler: useJavaHandler2 } = await Promise.resolve().then(() => (init_java(), java_exports));
   useNodeHandler2();
@@ -5293,12 +5415,13 @@ async function synth(opts) {
   usePythonHandler2();
   useJavaHandler2();
   useDotnetHandler();
+  useRustHandler2();
   const { Configuration } = await import("aws-cdk/lib/settings.js");
   const project = useProject();
   const identity = await useSTSIdentity();
   opts = {
     ...opts,
-    buildDir: opts.buildDir || path14.join(project.paths.out, "dist")
+    buildDir: opts.buildDir || path15.join(project.paths.out, "dist")
   };
   const cfg = new Configuration();
   await cfg.load();
@@ -5672,16 +5795,16 @@ __export(pothos_exports, {
 import babel from "@babel/core";
 import generator from "@babel/generator";
 import esbuild3 from "esbuild";
-import fs14 from "fs/promises";
-import path15 from "path";
+import fs15 from "fs/promises";
+import path16 from "path";
 import url8 from "url";
 async function generate(opts) {
   const { printSchema, lexicographicSortSchema } = await import("graphql");
   const contents = await extractSchema(opts);
-  const out = path15.join(path15.dirname(opts.schema), "out.mjs");
-  await fs14.writeFile(out, contents, "utf8");
+  const out = path16.join(path16.dirname(opts.schema), "out.mjs");
+  await fs15.writeFile(out, contents, "utf8");
   const { schema } = await import(url8.pathToFileURL(out).href + "?bust=" + Date.now());
-  await fs14.rm(out);
+  await fs15.rm(out);
   const schemaAsString = printSchema(lexicographicSortSchema(schema));
   return schemaAsString;
 }
@@ -5716,15 +5839,15 @@ async function extractSchema(opts) {
       {
         name: "pothos-extractor",
         visitor: {
-          Program(path18) {
-            const dummyResolverId = path18.scope.generateUidIdentifier("DUMMY_RESOLVER");
+          Program(path19) {
+            const dummyResolverId = path19.scope.generateUidIdentifier("DUMMY_RESOLVER");
             const resolverNode = dummyResolver({
               dummy_resolver: dummyResolverId
             });
-            path18.unshiftContainer("body", resolverNode);
-            path18.scope.crawl();
+            path19.unshiftContainer("body", resolverNode);
+            path19.scope.crawl();
             let schemaBuilder = null;
-            path18.traverse({
+            path19.traverse({
               ImportDeclaration(declarator) {
                 if (!declarator)
                   return;
@@ -5782,17 +5905,17 @@ async function extractSchema(opts) {
   );
   return contents.code;
 }
-function getBindings(path18, globalPaths) {
+function getBindings(path19, globalPaths) {
   const bindings = [];
-  path18.traverse({
+  path19.traverse({
     Expression(expressionPath) {
       if (!expressionPath.isIdentifier())
         return;
-      const binding = path18.scope.getBinding(expressionPath);
+      const binding = path19.scope.getBinding(expressionPath);
       if (!binding || globalPaths.has(binding.path) || bindings.includes(binding.path))
         return;
       const rootBinding = findRootBinding(binding.path);
-      if (path18 === rootBinding) {
+      if (path19 === rootBinding) {
         bindings.push(binding.path);
         return;
       }
@@ -5805,8 +5928,8 @@ function getBindings(path18, globalPaths) {
   }
   return bindings;
 }
-function findRootBinding(path18) {
-  let rootPath = path18;
+function findRootBinding(path19) {
+  let rootPath = path19;
   while (rootPath.parentPath?.node !== void 0 && !rootPath.parentPath?.isProgram()) {
     rootPath = rootPath.parentPath;
   }
@@ -5829,11 +5952,11 @@ var pothos_exports2 = {};
 __export(pothos_exports2, {
   usePothosBuilder: () => usePothosBuilder
 });
-import fs15 from "fs/promises";
-import { exec as exec5 } from "child_process";
-import { promisify as promisify4 } from "util";
-import path16 from "path";
-var execAsync4, usePothosBuilder;
+import fs16 from "fs/promises";
+import { exec as exec6 } from "child_process";
+import { promisify as promisify5 } from "util";
+import path17 from "path";
+var execAsync5, usePothosBuilder;
 var init_pothos2 = __esm({
   "src/cli/commands/plugins/pothos.ts"() {
     "use strict";
@@ -5841,7 +5964,7 @@ var init_pothos2 = __esm({
     init_context();
     init_pothos();
     init_colors();
-    execAsync4 = promisify4(exec5);
+    execAsync5 = promisify5(exec6);
     usePothosBuilder = Context.memo(() => {
       let routes = [];
       const bus = useBus();
@@ -5850,9 +5973,9 @@ var init_pothos2 = __esm({
           const schema = await pothos_exports.generate({
             schema: route.schema
           });
-          await fs15.writeFile(route.output, schema);
+          await fs16.writeFile(route.output, schema);
           if (Array.isArray(route.commands) && route.commands.length > 0) {
-            await Promise.all(route.commands.map((cmd) => execAsync4(cmd)));
+            await Promise.all(route.commands.map((cmd) => execAsync5(cmd)));
           }
           Colors.line(Colors.success(`\u2714`), " Pothos: Extracted pothos schema");
         } catch (ex) {
@@ -5866,9 +5989,9 @@ var init_pothos2 = __esm({
         if (evt.properties.file.endsWith("out.mjs"))
           return;
         for (const route of routes) {
-          const dir = path16.dirname(route.schema);
-          const relative = path16.relative(dir, evt.properties.file);
-          if (relative && !relative.startsWith("..") && !path16.isAbsolute(relative))
+          const dir = path17.dirname(route.schema);
+          const relative = path17.relative(dir, evt.properties.file);
+          if (relative && !relative.startsWith("..") && !path17.isAbsolute(relative))
             build2(route);
         }
       });
@@ -5894,7 +6017,7 @@ __export(kysely_exports, {
 import { Kysely } from "kysely";
 import { DataApiDialect } from "kysely-data-api";
 import RDSDataService from "aws-sdk/clients/rdsdataservice.js";
-import * as fs16 from "fs/promises";
+import * as fs17 from "fs/promises";
 import {
   DatabaseMetadata,
   EnumCollection,
@@ -5970,7 +6093,7 @@ var init_kysely = __esm({
         };
         const serializer = new Serializer();
         const data2 = serializer.serialize(nodes);
-        await fs16.writeFile(db.types.path, data2);
+        await fs17.writeFile(db.types.path, data2);
       }
       bus.subscribe("stacks.metadata", (evt) => {
         const constructs = Object.values(evt.properties).flat();
@@ -6329,14 +6452,14 @@ var env = (program2) => program2.command(
   ),
   async (args) => {
     const { createSpinner: createSpinner2 } = await Promise.resolve().then(() => (init_spinner(), spinner_exports));
-    const fs18 = await import("fs/promises");
+    const fs19 = await import("fs/promises");
     const { SiteEnv } = await Promise.resolve().then(() => (init_site_env(), site_env_exports));
     const { spawnSync } = await import("child_process");
     const { useAWSCredentials: useAWSCredentials2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
     const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
     let spinner;
     while (true) {
-      const exists = await fs18.access(SiteEnv.valuesFile()).then(() => true).catch(() => false);
+      const exists = await fs19.access(SiteEnv.valuesFile()).then(() => true).catch(() => false);
       if (!exists) {
         spinner = createSpinner2(
           "Cannot find SST environment variables. Waiting for SST to start..."
@@ -6398,8 +6521,8 @@ var dev = (program2) => program2.command(
     const { Context: Context2 } = await Promise.resolve().then(() => (init_context(), context_exports));
     const { printDeploymentResults: printDeploymentResults2, DeploymentUI: DeploymentUI2 } = await Promise.resolve().then(() => (init_deploy2(), deploy_exports));
     const { useLocalServer: useLocalServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
-    const path18 = await import("path");
-    const fs18 = await import("fs/promises");
+    const path19 = await import("path");
+    const fs19 = await import("fs/promises");
     const crypto2 = await import("crypto");
     const { useFunctions: useFunctions3 } = await import("../src/constructs/Function.js");
     const { SiteEnv } = await Promise.resolve().then(() => (init_site_env(), site_env_exports));
@@ -6588,8 +6711,8 @@ var dev = (program2) => program2.command(
           }
           await SiteEnv.writeValues(result);
         }
-        fs18.writeFile(
-          path18.join(project.paths.out, "outputs.json"),
+        fs19.writeFile(
+          path19.join(project.paths.out, "outputs.json"),
           JSON.stringify(
             pipe2(
               results,
@@ -6605,17 +6728,17 @@ var dev = (program2) => program2.command(
           build2();
       }
       async function checksum(cdkOutPath) {
-        const manifestPath = path18.join(cdkOutPath, "manifest.json");
+        const manifestPath = path19.join(cdkOutPath, "manifest.json");
         const cdkManifest = JSON.parse(
-          await fs18.readFile(manifestPath).then((x) => x.toString())
+          await fs19.readFile(manifestPath).then((x) => x.toString())
         );
         const checksumData = await Promise.all(
           Object.keys(cdkManifest.artifacts).filter(
             (key) => cdkManifest.artifacts[key].type === "aws:cloudformation:stack"
           ).map(async (key) => {
             const { templateFile } = cdkManifest.artifacts[key].properties;
-            const templatePath = path18.join(cdkOutPath, templateFile);
-            const templateContent = await fs18.readFile(templatePath);
+            const templatePath = path19.join(cdkOutPath, templateFile);
+            const templateContent = await fs19.readFile(templatePath);
             return templateContent;
           })
         ).then((x) => x.join("\n"));
@@ -6725,7 +6848,7 @@ var build = (program2) => program2.command(
     const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
     const { Stacks } = await Promise.resolve().then(() => (init_stacks(), stacks_exports));
     const { Colors: Colors2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
-    const path18 = await import("path");
+    const path19 = await import("path");
     const result = await Stacks.synth({
       fn: useProject2().stacks,
       buildDir: args.to,
@@ -6735,7 +6858,7 @@ var build = (program2) => program2.command(
     Colors2.line(
       Colors2.success(`\u2714`),
       Colors2.bold(" Built:"),
-      `${result.stacks.length} stack${result.stacks.length > 1 ? "s" : ""} to ${path18.relative(process.cwd(), result.directory)}`
+      `${result.stacks.length} stack${result.stacks.length > 1 ? "s" : ""} to ${path19.relative(process.cwd(), result.directory)}`
     );
     process.exit(0);
   }
@@ -6744,8 +6867,8 @@ var build = (program2) => program2.command(
 // src/cli/commands/deploy.tsx
 init_credentials();
 init_colors();
-import fs17 from "fs/promises";
-import path17 from "path";
+import fs18 from "fs/promises";
+import path18 from "path";
 var deploy2 = (program2) => program2.command(
   "deploy [filter]",
   "Deploy your app to AWS",
@@ -6814,8 +6937,8 @@ var deploy2 = (program2) => program2.command(
     printDeploymentResults2(assembly, results);
     if (Object.values(results).some((stack) => Stacks.isFailed(stack.status)))
       process.exit(1);
-    fs17.writeFile(
-      path17.join(project.paths.out, "outputs.json"),
+    fs18.writeFile(
+      path18.join(project.paths.out, "outputs.json"),
       JSON.stringify(
         mapValues2(results, (val) => val.outputs),
         null,
@@ -7099,22 +7222,22 @@ var update = (program2) => program2.command(
   }),
   async (args) => {
     const { green, yellow } = await import("colorette");
-    const fs18 = await import("fs/promises");
-    const path18 = await import("path");
+    const fs19 = await import("fs/promises");
+    const path19 = await import("path");
     const { fetch } = await import("undici");
     const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
     const { Colors: Colors2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
     async function find2(dir) {
-      const children = await fs18.readdir(dir);
+      const children = await fs19.readdir(dir);
       const tasks2 = children.map(async (item) => {
         if (item === "node_modules")
           return [];
         if (/(^|\/)\.[^\/\.]/g.test(item))
           return [];
-        const full = path18.join(dir, item);
+        const full = path19.join(dir, item);
         if (item === "package.json")
           return [full];
-        const stat = await fs18.stat(full);
+        const stat = await fs19.stat(full);
         if (stat.isDirectory())
           return find2(full);
         return [];
@@ -7128,7 +7251,7 @@ var update = (program2) => program2.command(
     ).then((resp) => resp.json());
     const results = /* @__PURE__ */ new Map();
     const tasks = files.map(async (file) => {
-      const data2 = await fs18.readFile(file).then((x) => x.toString()).then(JSON.parse);
+      const data2 = await fs19.readFile(file).then((x) => x.toString()).then(JSON.parse);
       for (const field of FIELDS) {
         const deps = data2[field];
         if (!deps)
@@ -7156,7 +7279,7 @@ var update = (program2) => program2.command(
           deps[pkg] = desired;
         }
       }
-      await fs18.writeFile(file, JSON.stringify(data2, null, 2));
+      await fs19.writeFile(file, JSON.stringify(data2, null, 2));
     });
     await Promise.all(tasks);
     if (results.size === 0) {
@@ -7166,7 +7289,7 @@ var update = (program2) => program2.command(
     for (const [file, pkgs] of results.entries()) {
       Colors2.line(
         Colors2.success(`\u2714 `),
-        Colors2.bold.dim(path18.relative(project.paths.root, file))
+        Colors2.bold.dim(path19.relative(project.paths.root, file))
       );
       for (const [pkg, version2] of pkgs) {
         Colors2.line(Colors2.dim(`   ${pkg}@${version2}`));

package/stacks/deploy.js

@@ -2,6 +2,7 @@ import { useBus } from "../bus.js";
 import { useAWSClient, useAWSProvider } from "../credentials.js";
 import { Logger } from "../logger.js";
 import { filterOutputs, isFailed, monitor, } from "./monitor.js";
+import { VisibleError } from "../error.js";
 export async function publishAssets(stacks) {
     Logger.debug("Publishing assets");
     const provider = await useAWSProvider();
@@ -20,6 +21,9 @@ export async function publishAssets(stacks) {
     return results;
 }
 export async function deployMany(stacks) {
+    if (stacks.length === 0) {
+        throw new VisibleError("No stacks to deploy");
+    }
     Logger.debug("Deploying stacks", stacks.map((s) => s.stackName));
     const { CloudFormationStackArtifact } = await import("aws-cdk-lib/cx-api");
     await useAWSProvider();

package/stacks/synth.js

@@ -10,6 +10,7 @@ export async function synth(opts) {
     const { App } = await import("../constructs/App.js");
     const { useNodeHandler } = await import("../runtime/handlers/node.js");
     const { useGoHandler } = await import("../runtime/handlers/go.js");
+    const { useRustHandler } = await import("../runtime/handlers/rust.js");
     const { usePythonHandler } = await import("../runtime/handlers/python.js");
     const { useJavaHandler } = await import("../runtime/handlers/java.js");
     useNodeHandler();
@@ -17,6 +18,7 @@ export async function synth(opts) {
     usePythonHandler();
     useJavaHandler();
     useDotnetHandler();
+    useRustHandler();
     const { Configuration } = await import("aws-cdk/lib/settings.js");
     const project = useProject();
     const identity = await useSTSIdentity();