sst 2.18.4 → 2.19.0

package/sst.mjs

@@ -292,10 +292,10 @@ async function load(input, shallow) {
                 plugins: [ts]
               });
               babel.traverse(ast, {
-                ObjectMethod(path20) {
-                  const { key } = path20.node;
+                ObjectMethod(path22) {
+                  const { key } = path22.node;
                   if ("name" in key && key.name === "stacks") {
-                    path20.remove();
+                    path22.remove();
                   }
                 }
               });
@@ -471,7 +471,7 @@ async function promptPersonalStage(out, isRetry) {
     input: process.stdin,
     output: process.stdout
   });
-  const stage = await new Promise((resolve) => {
+  const stage = await new Promise((resolve2) => {
     const suggested = sanitizeStageName(os.userInfo().username) || "local";
     const instruction = !isRetry ? `Please enter a name you\u2019d like to use for your personal stage.` : `Please enter a name that starts with a letter, followed by letters, numbers, or hyphens.`;
     rl.question(
@@ -479,7 +479,7 @@ async function promptPersonalStage(out, isRetry) {
       async (input) => {
         rl.close();
         const result = input === "" ? suggested : input;
-        resolve(result);
+        resolve2(result);
       }
     );
   });
@@ -541,7 +541,7 @@ var init_project = __esm({
 // src/cli/telemetry/post-payload.ts
 import https from "https";
 function postPayload(endpoint, body) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     try {
       const req = https.request(
         endpoint,
@@ -555,7 +555,7 @@ function postPayload(endpoint, body) {
             reject(new Error(`Unexpected status code: ${resp.statusCode}`));
             return;
           }
-          resolve();
+          resolve2();
         }
       );
       req.write(JSON.stringify(body));
@@ -981,11 +981,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P, generator2) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve) {
-      resolve(value);
+    return value instanceof P ? value : new P(function(resolve2) {
+      resolve2(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve, reject) {
+  return new (P || (P = Promise))(function(resolve2, reject) {
     function fulfilled(value) {
       try {
         step(generator2.next(value));
@@ -1001,7 +1001,7 @@ function __awaiter(thisArg, _arguments, P, generator2) {
       }
     }
     function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator2 = generator2.apply(thisArg, _arguments || [])).next());
   });
@@ -1109,8 +1109,8 @@ function __read(o, n) {
   try {
     while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
       ar.push(r.value);
-  } catch (error2) {
-    e = { error: error2 };
+  } catch (error3) {
+    e = { error: error3 };
   } finally {
     try {
       if (r && !r.done && (m = i["return"]))
@@ -1207,14 +1207,14 @@ function __asyncValues(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve, reject) {
-        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      return new Promise(function(resolve2, reject) {
+        v = o[n](v), settle(resolve2, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve, reject, d, v) {
+  function settle(resolve2, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve({ value: v2, done: d });
+      resolve2({ value: v2, done: d });
     }, reject);
   }
 }
@@ -1714,11 +1714,11 @@ var init_credentials = __esm({
             input: process.stdin,
             output: process.stdout
           });
-          return new Promise((resolve) => {
+          return new Promise((resolve2) => {
             Logger.debug(`Require MFA token for serial ARN ${serialArn}`);
             const prompt = () => rl.question(`Enter MFA code for ${serialArn}: `, async (input) => {
               if (input.trim() !== "") {
-                resolve(input.trim());
+                resolve2(input.trim());
                 rl.close();
               } else {
                 prompt();
@@ -2084,7 +2084,7 @@ async function monitor(stack) {
       }
       throw ex;
     }
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
   }
 }
 function filterOutputs(input) {
@@ -2136,6 +2136,750 @@ var init_monitor = __esm({
   }
 });
 
+// src/cdk-assets/private/docker.ts
+import * as fs5 from "fs";
+import * as os3 from "os";
+import * as path5 from "path";
+import {
+  cdkCredentialsConfig,
+  obtainEcrCredentials
+} from "cdk-assets/lib/private/docker-credentials.js";
+import {
+  shell
+} from "cdk-assets/lib/private/shell.js";
+import { createCriticalSection } from "cdk-assets/lib/private/util.js";
+function getDockerCmd() {
+  return process.env.CDK_DOCKER ?? "docker";
+}
+function flatten(x) {
+  return Array.prototype.concat([], ...x);
+}
+var Docker, DockerFactory;
+var init_docker = __esm({
+  "src/cdk-assets/private/docker.ts"() {
+    "use strict";
+    Docker = class {
+      constructor(logger) {
+        this.logger = logger;
+      }
+      configDir = void 0;
+      async exists(tag) {
+        try {
+          await this.execute(["inspect", tag], { quiet: true });
+          return true;
+        } catch (e) {
+          const error3 = e;
+          if (error3.code !== "PROCESS_FAILED") {
+            throw error3;
+          }
+          switch (error3.exitCode) {
+            case 1 /* Docker */:
+            case 125 /* Podman */:
+              return false;
+            default:
+              throw error3;
+          }
+        }
+      }
+      async build(options) {
+        const buildCommand = [
+          "build",
+          ...flatten(
+            Object.entries(options.buildArgs || {}).map(([k, v]) => [
+              "--build-arg",
+              `${k}=${v}`
+            ])
+          ),
+          ...flatten(
+            Object.entries(options.buildSecrets || {}).map(([k, v]) => [
+              "--secret",
+              `id=${k},${v}`
+            ])
+          ),
+          "--tag",
+          options.tag,
+          ...options.target ? ["--target", options.target] : [],
+          ...options.file ? ["--file", options.file] : [],
+          ...options.networkMode ? ["--network", options.networkMode] : [],
+          ...options.platform ? ["--platform", options.platform] : [],
+          ...options.outputs ? options.outputs.map((output) => [`--output=${output}`]) : [],
+          ...options.cacheFrom ? [
+            ...options.cacheFrom.map((cacheFrom) => [
+              "--cache-from",
+              this.cacheOptionToFlag(cacheFrom)
+            ]).flat()
+          ] : [],
+          ...options.cacheTo ? ["--cache-to", this.cacheOptionToFlag(options.cacheTo)] : [],
+          "."
+        ];
+        await this.execute(buildCommand, {
+          cwd: options.directory,
+          quiet: options.quiet
+        });
+      }
+      async login(ecr) {
+        const credentials = await obtainEcrCredentials(ecr);
+        await this.execute(
+          [
+            "login",
+            "--username",
+            credentials.username,
+            "--password-stdin",
+            credentials.endpoint
+          ],
+          {
+            input: credentials.password,
+            quiet: true
+          }
+        );
+      }
+      async tag(sourceTag, targetTag) {
+        await this.execute(["tag", sourceTag, targetTag]);
+      }
+      async push(options) {
+        await this.execute(["push", options.tag], { quiet: options.quiet });
+      }
+      configureCdkCredentials() {
+        const config = cdkCredentialsConfig();
+        if (!config) {
+          return false;
+        }
+        this.configDir = fs5.mkdtempSync(path5.join(os3.tmpdir(), "cdkDockerConfig"));
+        const domains = Object.keys(config.domainCredentials);
+        const credHelpers = domains.reduce(
+          (map3, domain) => {
+            map3[domain] = "cdk-assets";
+            return map3;
+          },
+          {}
+        );
+        fs5.writeFileSync(
+          path5.join(this.configDir, "config.json"),
+          JSON.stringify({ credHelpers }),
+          { encoding: "utf-8" }
+        );
+        return true;
+      }
+      resetAuthPlugins() {
+        this.configDir = void 0;
+      }
+      async execute(args, options = {}) {
+        const configArgs = this.configDir ? ["--config", this.configDir] : [];
+        const pathToCdkAssets = "";
+        try {
+          await shell([getDockerCmd(), ...configArgs, ...args], {
+            logger: this.logger,
+            ...options,
+            env: {
+              ...process.env,
+              ...options.env,
+              PATH: `${pathToCdkAssets}${path5.delimiter}${options.env?.PATH ?? process.env.PATH}`
+            }
+          });
+        } catch (e) {
+          if (e.code === "ENOENT") {
+            throw new Error(
+              "Unable to execute 'docker' in order to build a container asset. Please install 'docker' and try again."
+            );
+          }
+          throw e;
+        }
+      }
+      cacheOptionToFlag(option) {
+        let flag = `type=${option.type}`;
+        if (option.params) {
+          flag += "," + Object.entries(option.params).map(([k, v]) => `${k}=${v}`).join(",");
+        }
+        return flag;
+      }
+    };
+    DockerFactory = class {
+      enterLoggedInDestinationsCriticalSection = createCriticalSection();
+      loggedInDestinations = /* @__PURE__ */ new Set();
+      async forBuild(options) {
+        const docker = new Docker(options.logger);
+        let cdkDockerCredentialsConfigured = docker.configureCdkCredentials();
+        if (!cdkDockerCredentialsConfigured) {
+          await this.loginOncePerDestination(docker, options);
+        }
+        return docker;
+      }
+      async forEcrPush(options) {
+        const docker = new Docker(options.logger);
+        await this.loginOncePerDestination(docker, options);
+        return docker;
+      }
+      async loginOncePerDestination(docker, options) {
+        const repositoryDomain = options.repoUri.split("/")[0];
+        await this.enterLoggedInDestinationsCriticalSection(async () => {
+          if (this.loggedInDestinations.has(repositoryDomain)) {
+            return;
+          }
+          await docker.login(options.ecr);
+          this.loggedInDestinations.add(repositoryDomain);
+        });
+      }
+    };
+  }
+});
+
+// src/cdk-assets/private/handlers/container-images.ts
+import * as path6 from "path";
+import { EventType } from "cdk-assets/lib/progress.js";
+import { replaceAwsPlaceholders } from "cdk-assets/lib/private/placeholders.js";
+import { shell as shell2 } from "cdk-assets/lib/private/shell.js";
+async function imageExists(ecr, repositoryName, imageTag) {
+  try {
+    await ecr.describeImages({ repositoryName, imageIds: [{ imageTag }] }).promise();
+    return true;
+  } catch (e) {
+    if (e.code !== "ImageNotFoundException") {
+      throw e;
+    }
+    return false;
+  }
+}
+async function repositoryUri(ecr, repositoryName) {
+  try {
+    const response = await ecr.describeRepositories({ repositoryNames: [repositoryName] }).promise();
+    return (response.repositories || [])[0]?.repositoryUri;
+  } catch (e) {
+    if (e.code !== "RepositoryNotFoundException") {
+      throw e;
+    }
+    return void 0;
+  }
+}
+var ContainerImageAssetHandler, ContainerImageBuilder;
+var init_container_images = __esm({
+  "src/cdk-assets/private/handlers/container-images.ts"() {
+    "use strict";
+    ContainerImageAssetHandler = class {
+      constructor(workDir, asset, host, options) {
+        this.workDir = workDir;
+        this.asset = asset;
+        this.host = host;
+        this.options = options;
+      }
+      init;
+      async build() {
+        const initOnce = await this.initOnce();
+        if (initOnce.destinationAlreadyExists) {
+          return;
+        }
+        if (this.host.aborted) {
+          return;
+        }
+        const dockerForBuilding = await this.host.dockerFactory.forBuild({
+          repoUri: initOnce.repoUri,
+          logger: (m) => this.host.emitMessage(EventType.DEBUG, m),
+          ecr: initOnce.ecr
+        });
+        const builder = new ContainerImageBuilder(
+          dockerForBuilding,
+          this.workDir,
+          this.asset,
+          this.host,
+          {
+            quiet: this.options.quiet
+          }
+        );
+        const localTagName = await builder.build();
+        if (localTagName === void 0 || this.host.aborted) {
+          return;
+        }
+        if (this.host.aborted) {
+          return;
+        }
+        await dockerForBuilding.tag(localTagName, initOnce.imageUri);
+      }
+      async isPublished() {
+        try {
+          const initOnce = await this.initOnce({ quiet: true });
+          return initOnce.destinationAlreadyExists;
+        } catch (e) {
+          this.host.emitMessage(EventType.DEBUG, `${e.message}`);
+        }
+        return false;
+      }
+      async publish() {
+        const initOnce = await this.initOnce();
+        if (initOnce.destinationAlreadyExists) {
+          return;
+        }
+        if (this.host.aborted) {
+          return;
+        }
+        const dockerForPushing = await this.host.dockerFactory.forEcrPush({
+          repoUri: initOnce.repoUri,
+          logger: (m) => this.host.emitMessage(EventType.DEBUG, m),
+          ecr: initOnce.ecr
+        });
+        if (this.host.aborted) {
+          return;
+        }
+        this.host.emitMessage(EventType.UPLOAD, `Push ${initOnce.imageUri}`);
+        await dockerForPushing.push({
+          tag: initOnce.imageUri,
+          quiet: this.options.quiet
+        });
+      }
+      async initOnce(options = {}) {
+        if (this.init) {
+          return this.init;
+        }
+        const destination = await replaceAwsPlaceholders(
+          this.asset.destination,
+          this.host.aws
+        );
+        const ecr = await this.host.aws.ecrClient({
+          ...destination,
+          quiet: options.quiet
+        });
+        const account = async () => (await this.host.aws.discoverCurrentAccount())?.accountId;
+        const repoUri = await repositoryUri(ecr, destination.repositoryName);
+        if (!repoUri) {
+          throw new Error(
+            `No ECR repository named '${destination.repositoryName}' in account ${await account()}. Is this account bootstrapped?`
+          );
+        }
+        const imageUri = `${repoUri}:${destination.imageTag}`;
+        this.init = {
+          imageUri,
+          ecr,
+          repoUri,
+          destinationAlreadyExists: await this.destinationAlreadyExists(
+            ecr,
+            destination,
+            imageUri
+          )
+        };
+        return this.init;
+      }
+      async destinationAlreadyExists(ecr, destination, imageUri) {
+        this.host.emitMessage(EventType.CHECK, `Check ${imageUri}`);
+        if (await imageExists(ecr, destination.repositoryName, destination.imageTag)) {
+          this.host.emitMessage(EventType.FOUND, `Found ${imageUri}`);
+          return true;
+        }
+        return false;
+      }
+    };
+    ContainerImageBuilder = class {
+      constructor(docker, workDir, asset, host, options) {
+        this.docker = docker;
+        this.workDir = workDir;
+        this.asset = asset;
+        this.host = host;
+        this.options = options;
+      }
+      async build() {
+        return this.asset.source.executable ? this.buildExternalAsset(this.asset.source.executable) : this.buildDirectoryAsset();
+      }
+      async buildDirectoryAsset() {
+        const localTagName = `cdkasset-${this.asset.id.assetId.toLowerCase()}`;
+        if (!await this.isImageCached(localTagName)) {
+          if (this.host.aborted) {
+            return void 0;
+          }
+          await this.buildImage(localTagName);
+        }
+        return localTagName;
+      }
+      async buildExternalAsset(executable, cwd) {
+        const assetPath = cwd ?? this.workDir;
+        this.host.emitMessage(
+          EventType.BUILD,
+          `Building Docker image using command '${executable}'`
+        );
+        if (this.host.aborted) {
+          return void 0;
+        }
+        return (await shell2(executable, { cwd: assetPath, quiet: true })).trim();
+      }
+      async buildImage(localTagName) {
+        const source = this.asset.source;
+        if (!source.directory) {
+          throw new Error(
+            `'directory' is expected in the DockerImage asset source, got: ${JSON.stringify(
+              source
+            )}`
+          );
+        }
+        const fullPath = path6.resolve(this.workDir, source.directory);
+        this.host.emitMessage(
+          EventType.BUILD,
+          `Building Docker image at ${fullPath}`
+        );
+        await this.docker.build({
+          directory: fullPath,
+          tag: localTagName,
+          buildArgs: source.dockerBuildArgs,
+          buildSecrets: source.dockerBuildSecrets,
+          target: source.dockerBuildTarget,
+          file: source.dockerFile,
+          networkMode: source.networkMode,
+          platform: source.platform,
+          outputs: source.dockerOutputs,
+          cacheFrom: source.cacheFrom,
+          cacheTo: source.cacheTo,
+          quiet: this.options.quiet
+        });
+      }
+      async isImageCached(localTagName) {
+        if (await this.docker.exists(localTagName)) {
+          this.host.emitMessage(EventType.CACHED, `Cached ${localTagName}`);
+          return true;
+        }
+        return false;
+      }
+    };
+  }
+});
+
+// src/cdk-assets/private/handlers/index.ts
+import { FileAssetHandler } from "cdk-assets/lib/private/handlers/files.js";
+import {
+  DockerImageManifestEntry,
+  FileManifestEntry
+} from "cdk-assets/lib/asset-manifest.js";
+function makeAssetHandler(manifest, asset, host, options) {
+  if (asset instanceof FileManifestEntry) {
+    return new FileAssetHandler(manifest.directory, asset, host);
+  }
+  if (asset instanceof DockerImageManifestEntry) {
+    return new ContainerImageAssetHandler(
+      manifest.directory,
+      asset,
+      host,
+      options
+    );
+  }
+  throw new Error(`Unrecognized asset type: '${asset}'`);
+}
+var init_handlers = __esm({
+  "src/cdk-assets/private/handlers/index.ts"() {
+    "use strict";
+    init_container_images();
+  }
+});
+
+// src/cdk-assets/publishing.ts
+import {
+  EventType as EventType2
+} from "cdk-assets/lib/progress.js";
+var AssetPublishing;
+var init_publishing = __esm({
+  "src/cdk-assets/publishing.ts"() {
+    "use strict";
+    init_docker();
+    init_handlers();
+    AssetPublishing = class {
+      constructor(manifest, options) {
+        this.manifest = manifest;
+        this.options = options;
+        this.assets = manifest.entries;
+        this.totalOperations = this.assets.length;
+        this.publishInParallel = options.publishInParallel ?? false;
+        this.buildAssets = options.buildAssets ?? true;
+        this.publishAssets = options.publishAssets ?? true;
+        const self = this;
+        this.handlerHost = {
+          aws: this.options.aws,
+          get aborted() {
+            return self.aborted;
+          },
+          emitMessage(t, m) {
+            self.progressEvent(t, m);
+          },
+          dockerFactory: new DockerFactory()
+        };
+      }
+      message = "Starting";
+      currentAsset;
+      failures = new Array();
+      assets;
+      totalOperations;
+      completedOperations = 0;
+      aborted = false;
+      handlerHost;
+      publishInParallel;
+      buildAssets;
+      publishAssets;
+      handlerCache = /* @__PURE__ */ new Map();
+      async publish() {
+        if (this.publishInParallel) {
+          await Promise.all(
+            this.assets.map(async (asset) => this.publishAsset(asset))
+          );
+        } else {
+          for (const asset of this.assets) {
+            if (!await this.publishAsset(asset)) {
+              break;
+            }
+          }
+        }
+        if ((this.options.throwOnError ?? true) && this.failures.length > 0) {
+          throw new Error(
+            `Error publishing: ${this.failures.map((e) => e.error.message)}`
+          );
+        }
+      }
+      async buildEntry(asset) {
+        try {
+          if (this.progressEvent(EventType2.START, `Building ${asset.id}`)) {
+            return false;
+          }
+          const handler = this.assetHandler(asset);
+          await handler.build();
+          if (this.aborted) {
+            throw new Error("Aborted");
+          }
+          this.completedOperations++;
+          if (this.progressEvent(EventType2.SUCCESS, `Built ${asset.id}`)) {
+            return false;
+          }
+        } catch (e) {
+          this.failures.push({ asset, error: e });
+          this.completedOperations++;
+          if (this.progressEvent(EventType2.FAIL, e.message)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      async publishEntry(asset) {
+        try {
+          if (this.progressEvent(EventType2.START, `Publishing ${asset.id}`)) {
+            return false;
+          }
+          const handler = this.assetHandler(asset);
+          await handler.publish();
+          if (this.aborted) {
+            throw new Error("Aborted");
+          }
+          this.completedOperations++;
+          if (this.progressEvent(EventType2.SUCCESS, `Published ${asset.id}`)) {
+            return false;
+          }
+        } catch (e) {
+          this.failures.push({ asset, error: e });
+          this.completedOperations++;
+          if (this.progressEvent(EventType2.FAIL, e.message)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      isEntryPublished(asset) {
+        const handler = this.assetHandler(asset);
+        return handler.isPublished();
+      }
+      async publishAsset(asset) {
+        try {
+          if (this.progressEvent(EventType2.START, `Publishing ${asset.id}`)) {
+            return false;
+          }
+          const handler = this.assetHandler(asset);
+          if (this.buildAssets) {
+            await handler.build();
+          }
+          if (this.publishAssets) {
+            await handler.publish();
+          }
+          if (this.aborted) {
+            throw new Error("Aborted");
+          }
+          this.completedOperations++;
+          if (this.progressEvent(EventType2.SUCCESS, `Published ${asset.id}`)) {
+            return false;
+          }
+        } catch (e) {
+          this.failures.push({ asset, error: e });
+          this.completedOperations++;
+          if (this.progressEvent(EventType2.FAIL, e.message)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      get percentComplete() {
+        if (this.totalOperations === 0) {
+          return 100;
+        }
+        return Math.floor(this.completedOperations / this.totalOperations * 100);
+      }
+      abort() {
+        this.aborted = true;
+      }
+      get hasFailures() {
+        return this.failures.length > 0;
+      }
+      progressEvent(event, message) {
+        this.message = message;
+        if (this.options.progressListener) {
+          this.options.progressListener.onPublishEvent(event, this);
+        }
+        return this.aborted;
+      }
+      assetHandler(asset) {
+        const existing = this.handlerCache.get(asset);
+        if (existing) {
+          return existing;
+        }
+        const ret = makeAssetHandler(this.manifest, asset, this.handlerHost, {
+          quiet: this.options.quiet
+        });
+        this.handlerCache.set(asset, ret);
+        return ret;
+      }
+    };
+  }
+});
+
+// src/cdk/asset-publishing.ts
+import * as cxapi from "@aws-cdk/cx-api";
+import * as cdk_assets from "cdk-assets";
+import { Mode } from "sst-aws-cdk/lib/api/aws-auth/credentials.js";
+import { debug, error, print } from "sst-aws-cdk/lib/logging.js";
+async function publishAssets(manifest, sdk, targetEnv, options = {}) {
+  if (targetEnv.account === void 0 || targetEnv.account === cxapi.UNKNOWN_ACCOUNT || targetEnv.region === void 0 || targetEnv.account === cxapi.UNKNOWN_REGION) {
+    throw new Error(
+      `Asset publishing requires resolved account and region, got ${JSON.stringify(
+        targetEnv
+      )}`
+    );
+  }
+  const publisher = new AssetPublishing(manifest, {
+    aws: new PublishingAws(sdk, targetEnv),
+    progressListener: new PublishingProgressListener(options.quiet ?? false),
+    throwOnError: false,
+    publishInParallel: options.parallel ?? true,
+    buildAssets: options.buildAssets ?? true,
+    publishAssets: true,
+    quiet: options.quiet
+  });
+  await publisher.publish();
+  if (publisher.hasFailures) {
+    console.log(publisher.failures);
+    throw new Error(
+      "Failed to publish one or more assets. See the error messages above for more information."
+    );
+  }
+}
+async function buildAssets(manifest, sdk, targetEnv, options = {}) {
+  if (targetEnv.account === void 0 || targetEnv.account === cxapi.UNKNOWN_ACCOUNT || targetEnv.region === void 0 || targetEnv.account === cxapi.UNKNOWN_REGION) {
+    throw new Error(
+      `Asset building requires resolved account and region, got ${JSON.stringify(
+        targetEnv
+      )}`
+    );
+  }
+  const publisher = new cdk_assets.AssetPublishing(manifest, {
+    aws: new PublishingAws(sdk, targetEnv),
+    progressListener: new PublishingProgressListener(options.quiet ?? false),
+    throwOnError: false,
+    publishInParallel: options.parallel ?? true,
+    buildAssets: true,
+    publishAssets: false
+  });
+  await publisher.publish();
+  if (publisher.hasFailures) {
+    throw new Error(
+      "Failed to build one or more assets. See the error messages above for more information."
+    );
+  }
+}
+var PublishingAws, EVENT_TO_LOGGER, PublishingProgressListener;
+var init_asset_publishing = __esm({
+  "src/cdk/asset-publishing.ts"() {
+    "use strict";
+    init_publishing();
+    PublishingAws = class {
+      constructor(aws2, targetEnv) {
+        this.aws = aws2;
+        this.targetEnv = targetEnv;
+      }
+      sdkCache = /* @__PURE__ */ new Map();
+      async discoverPartition() {
+        return await this.aws.baseCredentialsPartition(
+          this.targetEnv,
+          Mode.ForWriting
+        ) ?? "aws";
+      }
+      async discoverDefaultRegion() {
+        return this.targetEnv.region;
+      }
+      async discoverCurrentAccount() {
+        const account = await this.aws.defaultAccount();
+        return account ?? {
+          accountId: "<unknown account>",
+          partition: "aws"
+        };
+      }
+      async discoverTargetAccount(options) {
+        return (await this.sdk(options)).currentAccount();
+      }
+      async s3Client(options) {
+        return (await this.sdk(options)).s3();
+      }
+      async ecrClient(options) {
+        return (await this.sdk(options)).ecr();
+      }
+      async secretsManagerClient(options) {
+        return (await this.sdk(options)).secretsManager();
+      }
+      async sdk(options) {
+        const env = {
+          ...this.targetEnv,
+          region: options.region ?? this.targetEnv.region
+        };
+        const cacheKey = JSON.stringify({
+          env,
+          assumeRuleArn: options.assumeRoleArn,
+          assumeRoleExternalId: options.assumeRoleExternalId,
+          quiet: options.quiet
+        });
+        const maybeSdk = this.sdkCache.get(cacheKey);
+        if (maybeSdk) {
+          return maybeSdk;
+        }
+        const sdk = (await this.aws.forEnvironment(
+          env,
+          Mode.ForWriting,
+          {
+            assumeRoleArn: options.assumeRoleArn,
+            assumeRoleExternalId: options.assumeRoleExternalId
+          },
+          options.quiet
+        )).sdk;
+        this.sdkCache.set(cacheKey, sdk);
+        return sdk;
+      }
+    };
+    EVENT_TO_LOGGER = {
+      build: debug,
+      cached: debug,
+      check: debug,
+      debug,
+      fail: error,
+      found: debug,
+      start: print,
+      success: print,
+      upload: debug
+    };
+    PublishingProgressListener = class {
+      constructor(quiet) {
+        this.quiet = quiet;
+      }
+      onPublishEvent(type, event) {
+        const handler = this.quiet && type !== "fail" ? debug : EVENT_TO_LOGGER[type];
+        handler(`[${event.percentComplete}%] ${type}: ${event.message}`);
+      }
+    };
+  }
+});
+
 // src/cdk/util.ts
 async function callWithRetry(cb) {
   try {
@@ -2154,14 +2898,14 @@ var init_util = __esm({
 });
 
 // src/cdk/deploy-stack.ts
-import * as cxapi from "@aws-cdk/cx-api";
-import fs5 from "fs/promises";
+import * as cxapi2 from "@aws-cdk/cx-api";
+import fs6 from "fs/promises";
 import * as uuid from "uuid";
 import { addMetadataAssetsToManifest } from "sst-aws-cdk/lib/assets.js";
-import { debug, error, print } from "sst-aws-cdk/lib/logging.js";
+import { debug as debug2, error as error2, print as print2 } from "sst-aws-cdk/lib/logging.js";
 import { toYAML } from "sst-aws-cdk/lib/serialize.js";
 import { AssetManifestBuilder } from "sst-aws-cdk/lib/util/asset-manifest-builder.js";
-import { publishAssets } from "sst-aws-cdk/lib/util/asset-publishing.js";
+import { publishAssets as publishAssets2 } from "sst-aws-cdk/lib/util/asset-publishing.js";
 import { contentHash } from "sst-aws-cdk/lib/util/content-hash.js";
 import { CfnEvaluationException } from "sst-aws-cdk/lib/api/evaluate-cloudformation-template.js";
 import { HotswapMode } from "sst-aws-cdk/lib/api/hotswap/common.js";
@@ -2185,7 +2929,7 @@ async function deployStack(options) {
     () => CloudFormationStack.lookup(cfn, deployName)
   );
   if (cloudFormationStack.stackStatus.isCreationFailure) {
-    debug(
+    debug2(
       `Found existing stack ${deployName} that had previously failed creation. Deleting it before attempting to re-create it.`
     );
     await cfn.deleteStack({ StackName: deployName }).promise();
@@ -2217,7 +2961,7 @@ async function deployStack(options) {
     cloudFormationStack,
     stackParams.hasChanges(cloudFormationStack.parameters)
   )) {
-    debug(`${deployName}: skipping deployment (use --force to override)`);
+    debug2(`${deployName}: skipping deployment (use --force to override)`);
     if (options.hotswap) {
     }
     return {
@@ -2226,7 +2970,7 @@ async function deployStack(options) {
       stackArn: cloudFormationStack.stackId
     };
   } else {
-    debug(`${deployName}: deploying...`);
+    debug2(`${deployName}: deploying...`);
   }
   const bodyParameter = await makeBodyParameter(
     stackArtifact,
@@ -2236,7 +2980,7 @@ async function deployStack(options) {
     options.sdk,
     options.overrideTemplate
   );
-  await publishAssets(
+  await publishAssets2(
     legacyAssets.toManifest(stackArtifact.assembly.directory),
     options.sdkProvider,
     stackEnv,
@@ -2257,7 +3001,7 @@ async function deployStack(options) {
       if (hotswapDeploymentResult) {
         return hotswapDeploymentResult;
       }
-      print(
+      print2(
         "Could not perform a hotswap deployment, as the stack %s contains non-Asset changes",
         stackArtifact.displayName
       );
@@ -2265,13 +3009,13 @@ async function deployStack(options) {
       if (!(e instanceof CfnEvaluationException)) {
         throw e;
       }
-      print(
+      print2(
         "Could not perform a hotswap deployment, because the CloudFormation template could not be resolved: %s",
         e.message
       );
     }
     if (hotswapMode === HotswapMode.FALL_BACK) {
-      print("Falling back to doing a full deployment");
+      print2("Falling back to doing a full deployment");
       options.sdk.appendCustomUserAgent("cdk-hotswap/fallback");
     } else {
       return {
@@ -2305,7 +3049,7 @@ async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, tool
     return { TemplateBody: templateJson };
   }
   if (!toolkitInfo.found) {
-    error(
+    error2(
       `The template for stack "${stack.displayName}" is ${Math.round(
         templateJson.length / 1024
       )}KiB. Templates larger than ${LARGE_TEMPLATE_SIZE_KB}KiB must be uploaded to S3.
@@ -2324,7 +3068,7 @@ Run the following command in order to setup an S3 bucket in this environment, an
   let templateFile = stack.templateFile;
   if (overrideTemplate) {
     templateFile = `${stack.templateFile}-${templateHash}.yaml`;
-    await fs5.writeFile(templateFile, templateJson, { encoding: "utf-8" });
+    await fs6.writeFile(templateFile, templateJson, { encoding: "utf-8" });
   }
   assetManifest.addFileAsset(
     templateHash,
@@ -2337,7 +3081,7 @@ Run the following command in order to setup an S3 bucket in this environment, an
     }
   );
   const templateURL = `${toolkitInfo.bucketUrl}/${key}`;
-  debug("Storing template in S3 at:", templateURL);
+  debug2("Storing template in S3 at:", templateURL);
   return { TemplateURL: templateURL };
 }
 async function makeBodyParameterAndUpload(stack, resolvedEnvironment, toolkitInfo, sdkProvider, sdk, overrideTemplate) {
@@ -2354,7 +3098,7 @@ async function makeBodyParameterAndUpload(stack, resolvedEnvironment, toolkitInf
     overrideTemplate
   );
   const manifest = builder.toManifest(stack.assembly.directory);
-  await publishAssets(manifest, sdkProvider, resolvedEnvironment, {
+  await publishAssets2(manifest, sdkProvider, resolvedEnvironment, {
     quiet: true
   });
   return bodyparam;
@@ -2381,47 +3125,47 @@ async function destroyStack(options) {
 }
 async function canSkipDeploy(deployStackOptions, cloudFormationStack, parameterChanges) {
   const deployName = deployStackOptions.deployName || deployStackOptions.stack.stackName;
-  debug(`${deployName}: checking if we can skip deploy`);
+  debug2(`${deployName}: checking if we can skip deploy`);
   if (deployStackOptions.force) {
-    debug(`${deployName}: forced deployment`);
+    debug2(`${deployName}: forced deployment`);
     return false;
   }
   if (deployStackOptions.deploymentMethod?.method === "change-set" && deployStackOptions.deploymentMethod.execute === false) {
-    debug(`${deployName}: --no-execute, always creating change set`);
+    debug2(`${deployName}: --no-execute, always creating change set`);
     return false;
   }
   if (!cloudFormationStack.exists) {
-    debug(`${deployName}: no existing stack`);
+    debug2(`${deployName}: no existing stack`);
     return false;
   }
   if (cloudFormationStack.stackStatus.isInProgress) {
-    debug(`${deployName}: stack is busy`);
+    debug2(`${deployName}: stack is busy`);
     return false;
   }
   if (JSON.stringify(deployStackOptions.stack.template) !== JSON.stringify(await cloudFormationStack.template())) {
-    debug(`${deployName}: template has changed`);
+    debug2(`${deployName}: template has changed`);
     return false;
   }
   if (!compareTags(cloudFormationStack.tags, deployStackOptions.tags ?? [])) {
-    debug(`${deployName}: tags have changed`);
+    debug2(`${deployName}: tags have changed`);
     return false;
   }
   if (!!deployStackOptions.stack.terminationProtection !== !!cloudFormationStack.terminationProtection) {
-    debug(`${deployName}: termination protection has been updated`);
+    debug2(`${deployName}: termination protection has been updated`);
     return false;
   }
   if (parameterChanges) {
     if (parameterChanges === "ssm") {
-      debug(
+      debug2(
         `${deployName}: some parameters come from SSM so we have to assume they may have changed`
       );
     } else {
-      debug(`${deployName}: parameters have changed`);
+      debug2(`${deployName}: parameters have changed`);
     }
     return false;
   }
   if (cloudFormationStack.stackStatus.isFailure) {
-    debug(`${deployName}: stack is in a failure state`);
+    debug2(`${deployName}: stack is in a failure state`);
     return false;
   }
   return true;
@@ -2440,7 +3184,7 @@ function compareTags(a, b) {
 }
 function restUrlFromManifest(url10, environment, sdk) {
   const doNotUseMarker = "**DONOTUSE**";
-  url10 = cxapi.EnvironmentPlaceholders.replace(url10, {
+  url10 = cxapi2.EnvironmentPlaceholders.replace(url10, {
     accountId: environment.account,
     region: environment.region,
     partition: doNotUseMarker
@@ -2509,9 +3253,9 @@ var init_deploy_stack = __esm({
         );
         await this.updateTerminationProtection();
         if (changeSetHasNoChanges(changeSetDescription)) {
-          debug("No changes are to be performed on %s.", this.stackName);
+          debug2("No changes are to be performed on %s.", this.stackName);
           if (execute) {
-            debug("Deleting empty change set %s", changeSetDescription.ChangeSetId);
+            debug2("Deleting empty change set %s", changeSetDescription.ChangeSetId);
             await this.cfn.deleteChangeSet({
               StackName: this.stackName,
               ChangeSetName: changeSetName
@@ -2524,7 +3268,7 @@ var init_deploy_stack = __esm({
           };
         }
         if (!execute) {
-          print(
+          print2(
             "Changeset %s created and waiting in review for manual execution (--no-execute)",
             changeSetDescription.ChangeSetId
           );
@@ -2538,7 +3282,7 @@ var init_deploy_stack = __esm({
       }
       async createChangeSet(changeSetName, willExecute) {
         await this.cleanupOldChangeset(changeSetName);
-        debug(
+        debug2(
           `Attempting to create ChangeSet with name ${changeSetName} to ${this.verb} stack ${this.stackName}`
         );
         const changeSet = await this.cfn.createChangeSet({
@@ -2550,7 +3294,7 @@ var init_deploy_stack = __esm({
           ClientToken: `create${this.uuid}`,
           ...this.commonPrepareOptions()
         }).promise();
-        debug(
+        debug2(
           "Initiated creation of changeset: %s; waiting for it to finish creating...",
           changeSet.Id
         );
@@ -2559,7 +3303,7 @@ var init_deploy_stack = __esm({
         });
       }
       async executeChangeSet(changeSet) {
-        debug(
+        debug2(
           "Initiating execution of changeset %s on stack %s",
           changeSet.ChangeSetId,
           this.stackName
@@ -2570,7 +3314,7 @@ var init_deploy_stack = __esm({
           ClientRequestToken: `exec${this.uuid}`,
           ...this.commonExecuteOptions()
         }).promise();
-        debug(
+        debug2(
           "Execution of changeset %s on stack %s has started; waiting for the update to complete...",
           changeSet.ChangeSetId,
           this.stackName
@@ -2580,7 +3324,7 @@ var init_deploy_stack = __esm({
       }
       async cleanupOldChangeset(changeSetName) {
         if (this.cloudFormationStack.exists) {
-          debug(
+          debug2(
             `Removing existing change set with name ${changeSetName} if it exists`
           );
           await this.cfn.deleteChangeSet({
@@ -2592,7 +3336,7 @@ var init_deploy_stack = __esm({
       async updateTerminationProtection() {
         const terminationProtection = this.stackArtifact.terminationProtection ?? false;
         if (!!this.cloudFormationStack.terminationProtection !== terminationProtection) {
-          debug(
+          debug2(
             "Updating termination protection from %s to %s for stack %s",
             this.cloudFormationStack.terminationProtection,
             terminationProtection,
@@ -2602,7 +3346,7 @@ var init_deploy_stack = __esm({
             StackName: this.stackName,
             EnableTerminationProtection: terminationProtection
           }).promise();
-          debug(
+          debug2(
             "Termination protection updated to %s for stack %s",
             terminationProtection,
             this.stackName
@@ -2651,7 +3395,7 @@ var init_deploy_stack = __esm({
           throw new Error(suffixWithErrors(e.message));
         } finally {
         }
-        debug("Stack %s has completed updating", this.stackName);
+        debug2("Stack %s has completed updating", this.stackName);
         return {
           noOp: false,
           outputs: finalState.outputs,
@@ -2690,17 +3434,11 @@ __export(deployments_exports, {
   CloudFormationDeployments: () => CloudFormationDeployments,
   Deployments: () => Deployments
 });
-import * as cxapi2 from "@aws-cdk/cx-api";
-import * as cdk_assets from "cdk-assets";
-import { AssetManifest } from "cdk-assets";
-import { debug as debug2, warning } from "sst-aws-cdk/lib/logging.js";
-import {
-  buildAssets,
-  publishAssets as publishAssets2,
-  PublishingAws,
-  EVENT_TO_LOGGER
-} from "sst-aws-cdk/lib/util/asset-publishing.js";
-import { Mode } from "sst-aws-cdk/lib/api/aws-auth/credentials.js";
+import * as cxapi3 from "@aws-cdk/cx-api";
+import * as cdk_assets2 from "cdk-assets";
+import { AssetManifest as AssetManifest2 } from "cdk-assets";
+import { debug as debug3, warning } from "sst-aws-cdk/lib/logging.js";
+import { Mode as Mode2 } from "sst-aws-cdk/lib/api/aws-auth/credentials.js";
 import {
   loadCurrentTemplateWithNestedStacks,
   loadCurrentTemplate
@@ -2714,6 +3452,7 @@ var Deployments, ParallelSafeAssetProgress, CloudFormationDeployments;
 var init_deployments = __esm({
   "src/cdk/deployments.ts"() {
     "use strict";
+    init_asset_publishing();
     init_deploy_stack();
     init_util();
     Deployments = class {
@@ -2734,18 +3473,18 @@ var init_deployments = __esm({
         )).deployedTemplate;
       }
       async readCurrentTemplate(stackArtifact) {
-        debug2(`Reading existing template for stack ${stackArtifact.displayName}.`);
+        debug3(`Reading existing template for stack ${stackArtifact.displayName}.`);
         const sdk = (await this.prepareSdkWithLookupOrDeployRole(stackArtifact)).stackSdk;
         return loadCurrentTemplate(stackArtifact, sdk);
       }
       async resourceIdentifierSummaries(stackArtifact, toolkitStackName) {
-        debug2(
+        debug3(
           `Retrieving template summary for stack ${stackArtifact.displayName}.`
         );
         const { stackSdk, resolvedEnvironment } = await this.prepareSdkFor(
           stackArtifact,
           void 0,
-          Mode.ForReading
+          Mode2.ForReading
         );
         const cfn = stackSdk.cloudFormation();
         const toolkitInfo = await this.lookupToolkit(
@@ -2762,7 +3501,7 @@ var init_deployments = __esm({
         );
         const response = await cfn.getTemplateSummary(cfnParam).promise();
         if (!response.ResourceIdentifierSummaries) {
-          debug2(
+          debug3(
             'GetTemplateSummary API call did not return "ResourceIdentifierSummaries"'
           );
         }
@@ -2782,7 +3521,7 @@ var init_deployments = __esm({
             execute: options.execute
           };
         }
-        const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
+        const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await this.prepareSdkFor(options.stack, options.roleArn, Mode2.ForWriting);
         const toolkitInfo = await callWithRetry(
           () => this.lookupToolkit(
             resolvedEnvironment,
@@ -2797,11 +3536,11 @@ var init_deployments = __esm({
           toolkitInfo
         );
         const assetArtifacts = options.stack.dependencies.filter(
-          cxapi2.AssetManifestArtifact.isAssetManifestArtifact
+          cxapi3.AssetManifestArtifact.isAssetManifestArtifact
         );
         for (const asset of assetArtifacts) {
-          const manifest = AssetManifest.fromFile(asset.file);
-          await publishAssets2(manifest, this.sdkProvider, resolvedEnvironment, {
+          const manifest = AssetManifest2.fromFile(asset.file);
+          await publishAssets(manifest, this.sdkProvider, resolvedEnvironment, {
             buildAssets: true,
             quiet: options.quiet,
             parallel: options.assetParallelism
@@ -2835,7 +3574,7 @@ var init_deployments = __esm({
         });
       }
       async destroyStack(options) {
-        const { stackSdk, cloudFormationRoleArn: roleArn } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
+        const { stackSdk, cloudFormationRoleArn: roleArn } = await this.prepareSdkFor(options.stack, options.roleArn, Mode2.ForWriting);
         return destroyStack({
           sdk: stackSdk,
           roleArn,
@@ -2849,7 +3588,7 @@ var init_deployments = __esm({
         const { stackSdk } = await this.prepareSdkFor(
           options.stack,
           void 0,
-          Mode.ForReading
+          Mode2.ForReading
         );
         const stack = await CloudFormationStack2.lookup(
           stackSdk.cloudFormation(),
@@ -2868,7 +3607,7 @@ var init_deployments = __esm({
           }
         } catch {
         }
-        return this.prepareSdkFor(stackArtifact, void 0, Mode.ForReading);
+        return this.prepareSdkFor(stackArtifact, void 0, Mode2.ForReading);
       }
       async prepareSdkFor(stack, roleArn, mode) {
         if (!stack.environment) {
@@ -2917,7 +3656,7 @@ var init_deployments = __esm({
         try {
           const stackSdk = await this.cachedSdkForEnvironment(
             resolvedEnvironment,
-            Mode.ForReading,
+            Mode2.ForReading,
             {
               assumeRoleArn: arns.lookupRoleArn,
               assumeRoleExternalId: stack.lookupRole?.assumeRoleExternalId
@@ -2938,7 +3677,7 @@ var init_deployments = __esm({
           }
           return { ...stackSdk, resolvedEnvironment };
         } catch (e) {
-          debug2(e);
+          debug3(e);
           if (stack.lookupRole && stack.lookupRole.requiresBootstrapStackVersion) {
             warning(warningMessage);
             warning(upgradeMessage);
@@ -2964,7 +3703,7 @@ var init_deployments = __esm({
         const { stackSdk, resolvedEnvironment } = await this.prepareSdkFor(
           options.stack,
           options.roleArn,
-          Mode.ForWriting
+          Mode2.ForWriting
         );
         const toolkitInfo = await this.lookupToolkit(
           resolvedEnvironment,
@@ -2980,7 +3719,7 @@ var init_deployments = __esm({
           asset.bootstrapStackVersionSsmParameter,
           toolkitInfo
         );
-        const manifest = AssetManifest.fromFile(asset.file);
+        const manifest = AssetManifest2.fromFile(asset.file);
         return { manifest, stackEnv };
       }
       async buildAssets(asset, options) {
@@ -3000,7 +3739,7 @@ var init_deployments = __esm({
           asset,
           options
         );
-        await publishAssets2(
+        await publishAssets(
           manifest,
           this.sdkProvider,
           stackEnv,
@@ -3008,7 +3747,7 @@ var init_deployments = __esm({
         );
       }
       async buildSingleAsset(assetArtifact, assetManifest, asset, options) {
-        const { stackSdk, resolvedEnvironment: stackEnv } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
+        const { stackSdk, resolvedEnvironment: stackEnv } = await this.prepareSdkFor(options.stack, options.roleArn, Mode2.ForWriting);
         const toolkitInfo = await this.lookupToolkit(
           stackEnv,
           stackSdk,
@@ -3031,7 +3770,7 @@ var init_deployments = __esm({
         const { resolvedEnvironment: stackEnv } = await this.prepareSdkFor(
           options.stack,
           options.roleArn,
-          Mode.ForWriting
+          Mode2.ForWriting
         );
         const publisher = this.cachedPublisher(
           assetManifest,
@@ -3044,7 +3783,7 @@ var init_deployments = __esm({
         const { resolvedEnvironment: stackEnv } = await this.prepareSdkFor(
           options.stack,
           options.roleArn,
-          Mode.ForWriting
+          Mode2.ForWriting
         );
         const publisher = this.cachedPublisher(
           assetManifest,
@@ -3092,7 +3831,7 @@ var init_deployments = __esm({
           return existing;
         }
         const prefix = stackName ? `${stackName}: ` : "";
-        const publisher = new cdk_assets.AssetPublishing(assetManifest, {
+        const publisher = new cdk_assets2.AssetPublishing(assetManifest, {
           aws: new PublishingAws(this.sdkProvider, env),
           progressListener: new ParallelSafeAssetProgress(
             prefix,
@@ -3109,7 +3848,7 @@ var init_deployments = __esm({
         this.quiet = quiet;
       }
       onPublishEvent(type, event) {
-        const handler = this.quiet && type !== "fail" ? debug2 : EVENT_TO_LOGGER[type];
+        const handler = this.quiet && type !== "fail" ? debug3 : EVENT_TO_LOGGER[type];
         handler(`${this.prefix} ${type}: ${event.message}`);
       }
     };
@@ -3123,15 +3862,15 @@ var deployments_wrapper_exports = {};
 __export(deployments_wrapper_exports, {
   publishDeployAssets: () => publishDeployAssets
 });
-import * as cxapi3 from "@aws-cdk/cx-api";
-import { AssetManifest as AssetManifest2 } from "cdk-assets";
-import { debug as debug3 } from "sst-aws-cdk/lib/logging.js";
+import * as cxapi4 from "@aws-cdk/cx-api";
+import { AssetManifest as AssetManifest3 } from "cdk-assets";
+import { debug as debug4 } from "sst-aws-cdk/lib/logging.js";
 import {
   CloudFormationStack as CloudFormationStack3,
   TemplateParameters as TemplateParameters2,
   waitForStackDelete as waitForStackDelete2
 } from "sst-aws-cdk/lib/api/util/cloudformation.js";
-import { Mode as Mode2 } from "sst-aws-cdk/lib/api/aws-auth/credentials.js";
+import { Mode as Mode3 } from "sst-aws-cdk/lib/api/aws-auth/credentials.js";
 import { ToolkitInfo as ToolkitInfo2 } from "sst-aws-cdk/lib/api/toolkit-info.js";
 import { addMetadataAssetsToManifest as addMetadataAssetsToManifest2 } from "sst-aws-cdk/lib/assets.js";
 import { publishAssets as publishAssets3 } from "sst-aws-cdk/lib/util/asset-publishing.js";
@@ -3145,10 +3884,10 @@ async function publishDeployAssets(sdkProvider, options) {
     cloudFormationRoleArn
   } = await useDeployment().get(sdkProvider, options);
   const assetArtifacts = options.stack.dependencies.filter(
-    cxapi3.AssetManifestArtifact.isAssetManifestArtifact
+    cxapi4.AssetManifestArtifact.isAssetManifestArtifact
   );
   for (const asset of assetArtifacts) {
-    const manifest = AssetManifest2.fromFile(asset.file);
+    const manifest = AssetManifest3.fromFile(asset.file);
     await publishAssets3(manifest, sdkProvider, resolvedEnvironment, {
       buildAssets: true,
       quiet: options.quiet,
@@ -3190,7 +3929,7 @@ async function deployStack2(options) {
   const deployName = options.deployName || stackArtifact.stackName;
   let cloudFormationStack = await CloudFormationStack3.lookup(cfn, deployName);
   if (cloudFormationStack.stackStatus.isCreationFailure) {
-    debug3(
+    debug4(
       `Found existing stack ${deployName} that had previously failed creation. Deleting it before attempting to re-create it.`
     );
     await cfn.deleteStack({ StackName: deployName }).promise();
@@ -3266,7 +4005,7 @@ var init_deployments_wrapper = __esm({
             const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await deployment.prepareSdkFor(
               options.stack,
               options.roleArn,
-              Mode2.ForWriting
+              Mode3.ForWriting
             );
             const toolkitInfo = await ToolkitInfo2.lookup(
               resolvedEnvironment,
@@ -3326,7 +4065,7 @@ async function deployMany(stacks) {
   const complete = /* @__PURE__ */ new Set();
   const todo = new Set(stacks.map((s) => s.id));
   const results = {};
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     async function trigger() {
       for (const stack of stacks) {
         if (!todo.has(stack.id))
@@ -3355,7 +4094,7 @@ async function deployMany(stacks) {
               }
             });
           if (complete.size === stacks.length) {
-            resolve(results);
+            resolve2(results);
           }
           trigger();
         });
@@ -3491,13 +4230,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"() {
@@ -3566,8 +4305,8 @@ var init_diff = __esm({
 });
 
 // src/cache.ts
-import path5 from "path";
-import fs6 from "fs/promises";
+import path7 from "path";
+import fs7 from "fs/promises";
 var useCache;
 var init_cache = __esm({
   "src/cache.ts"() {
@@ -3577,19 +4316,19 @@ var init_cache = __esm({
     init_context();
     useCache = Context.memo(async () => {
       const project = useProject();
-      const cache = path5.join(project.paths.out, "cache");
-      await fs6.mkdir(cache, {
+      const cache = path7.join(project.paths.out, "cache");
+      await fs7.mkdir(cache, {
         recursive: true
       });
       async function write(key, data2) {
-        const full = path5.join(cache, key);
+        const full = path7.join(cache, key);
         Logger.debug("Writing cache", full, data2.length, "bytes");
-        await fs6.writeFile(full, data2);
+        await fs7.writeFile(full, data2);
       }
       async function read(key) {
-        const full = path5.join(cache, key);
+        const full = path7.join(cache, key);
         try {
-          const data2 = await fs6.readFile(full);
+          const data2 = await fs7.readFile(full);
           return data2.toString();
         } catch {
           return null;
@@ -3682,7 +4421,7 @@ var init_metadata = __esm({
           bus.publish("stacks.metadata", data2);
           return data2;
         } catch {
-          await new Promise((resolve) => setTimeout(resolve, 1e3));
+          await new Promise((resolve2) => setTimeout(resolve2, 1e3));
         }
       }
     });
@@ -3696,7 +4435,7 @@ __export(watcher_exports, {
   useWatcher: () => useWatcher
 });
 import chokidar from "chokidar";
-import path6 from "path";
+import path8 from "path";
 var useWatcher;
 var init_watcher = __esm({
   "src/watcher.ts"() {
@@ -3727,7 +4466,7 @@ var init_watcher = __esm({
       watcher.on("change", (file) => {
         bus.publish("file.changed", {
           file,
-          relative: path6.relative(project.paths.root, file)
+          relative: path8.relative(project.paths.root, file)
         });
       });
       return {
@@ -3738,11 +4477,11 @@ var init_watcher = __esm({
 });
 
 // src/runtime/handlers.ts
-import path7 from "path";
-import fs7 from "fs/promises";
+import path9 from "path";
+import fs8 from "fs/promises";
 import { useFunctions } from "../src/constructs/Function.js";
 var useRuntimeHandlers, useFunctionBuilder;
-var init_handlers = __esm({
+var init_handlers2 = __esm({
   "src/runtime/handlers.ts"() {
     "use strict";
     init_context();
@@ -3775,9 +4514,10 @@ var init_handlers = __esm({
                 errors: [`Function with ID "${functionID}" not found`]
               };
             const handler = result.for(func.runtime);
-            const out = path7.join(project.paths.artifacts, functionID);
-            await fs7.rm(out, { recursive: true, force: true });
-            await fs7.mkdir(out, { recursive: true });
+            const out = path9.join(project.paths.artifacts, functionID);
+            await fs8.rm(out, { recursive: true, force: true });
+            await fs8.mkdir(out, { recursive: true });
+            bus.publish("function.build.started", { functionID });
             if (func.hooks?.beforeBuild)
               await func.hooks.beforeBuild(func, out);
             const built = await handler.build({
@@ -3796,22 +4536,22 @@ var init_handlers = __esm({
             if (func.copyFiles) {
               await Promise.all(
                 func.copyFiles.map(async (entry) => {
-                  const fromPath = path7.join(project.paths.root, entry.from);
+                  const fromPath = path9.join(project.paths.root, entry.from);
                   const to = entry.to || entry.from;
-                  if (path7.isAbsolute(to))
+                  if (path9.isAbsolute(to))
                     throw new Error(
                       `Copy destination path "${to}" must be relative`
                     );
-                  const toPath = path7.join(out, to);
+                  const toPath = path9.join(out, to);
                   if (mode === "deploy")
-                    await fs7.cp(fromPath, toPath, {
+                    await fs8.cp(fromPath, toPath, {
                       recursive: true
                     });
                   if (mode === "start") {
                     try {
-                      const dir = path7.dirname(toPath);
-                      await fs7.mkdir(dir, { recursive: true });
-                      await fs7.symlink(fromPath, toPath);
+                      const dir = path9.dirname(toPath);
+                      await fs8.mkdir(dir, { recursive: true });
+                      await fs8.symlink(fromPath, toPath);
                     } catch (ex) {
                       Logger.debug("Failed to symlink", fromPath, toPath, ex);
                     }
@@ -3921,8 +4661,8 @@ var init_server = __esm({
         const value = queue?.shift();
         if (value)
           return value;
-        return new Promise((resolve, reject) => {
-          workersWaiting.set(workerID, resolve);
+        return new Promise((resolve2, reject) => {
+          workersWaiting.set(workerID, resolve2);
         });
       }
       workers.subscribe("worker.exited", async (evt) => {
@@ -4091,7 +4831,7 @@ var init_workers = __esm({
     "use strict";
     init_context();
     init_bus();
-    init_handlers();
+    init_handlers2();
     init_server();
     useRuntimeWorkers = Context.memo(async () => {
       const workers = /* @__PURE__ */ new Map();
@@ -4133,6 +4873,7 @@ var init_workers = __esm({
         await handler.startWorker({
           ...build2,
           workerID: evt.properties.workerID,
+          functionID: evt.properties.functionID,
           environment: evt.properties.env,
           url: `${server.url}/${evt.properties.workerID}/${server.API_VERSION}`,
           runtime: props.runtime
@@ -4198,7 +4939,7 @@ var FRAMEWORK_MAP, BOOTSTRAP_MAP, useDotnetHandler;
 var init_dotnet = __esm({
   "src/runtime/handlers/dotnet.ts"() {
     "use strict";
-    init_handlers();
+    init_handlers2();
     init_workers();
     init_context();
     init_server();
@@ -4326,8 +5067,8 @@ var node_exports = {};
 __export(node_exports, {
   useNodeHandler: () => useNodeHandler
 });
-import path8 from "path";
-import fs8 from "fs/promises";
+import path10 from "path";
+import fs9 from "fs/promises";
 import { exec as exec2 } from "child_process";
 import fsSync2 from "fs";
 import esbuild2 from "esbuild";
@@ -4338,7 +5079,7 @@ var init_node = __esm({
   "src/runtime/handlers/node.ts"() {
     "use strict";
     init_project();
-    init_handlers();
+    init_handlers2();
     init_workers();
     init_context();
     init_error();
@@ -4354,7 +5095,7 @@ var init_node = __esm({
           const result = cache[input.functionID];
           if (!result)
             return false;
-          const relative = path8.relative(project.paths.root, input.file).split(path8.sep).join(path8.posix.sep);
+          const relative = path10.relative(project.paths.root, input.file).split(path10.sep).join(path10.posix.sep);
           return Boolean(result.metafile?.inputs[relative]);
         },
         canHandle: (input) => input.startsWith("nodejs"),
@@ -4392,7 +5133,7 @@ var init_node = __esm({
         },
         build: async (input) => {
           const exists = cache[input.functionID];
-          const parsed = path8.parse(input.props.handler);
+          const parsed = path10.parse(input.props.handler);
           const file = [
             ".ts",
             ".tsx",
@@ -4402,7 +5143,7 @@ var init_node = __esm({
             ".jsx",
             ".mjs",
             ".cjs"
-          ].map((ext) => path8.join(parsed.dir, parsed.name + ext)).find((file2) => {
+          ].map((ext) => path10.join(parsed.dir, parsed.name + ext)).find((file2) => {
             return fsSync2.existsSync(file2);
           });
           if (!file)
@@ -4412,17 +5153,17 @@ var init_node = __esm({
             };
           const nodejs = input.props.nodejs || {};
           const isESM = (nodejs.format || "esm") === "esm";
-          const relative = path8.relative(
+          const relative = path10.relative(
             project.paths.root,
-            path8.resolve(parsed.dir)
+            path10.resolve(parsed.dir)
           );
           const extension = isESM ? ".mjs" : ".cjs";
-          const target = path8.join(
+          const target = path10.join(
             input.out,
-            !relative.startsWith("..") && !path8.isAbsolute(input.props.handler) ? relative : "",
+            !relative.startsWith("..") && !path10.isAbsolute(input.props.handler) ? relative : "",
             parsed.name + extension
           );
-          const handler = path8.relative(input.out, target.replace(extension, parsed.ext)).split(path8.sep).join(path8.posix.sep);
+          const handler = path10.relative(input.out, target.replace(extension, parsed.ext)).split(path10.sep).join(path10.posix.sep);
           if (exists?.rebuild) {
             const result = await exists.rebuild();
             cache[input.functionID] = result;
@@ -4481,32 +5222,32 @@ var init_node = __esm({
               ...nodejs.install || [],
               ...forceExternal.filter((pkg) => pkg !== "aws-sdk").filter((pkg) => !external?.includes(pkg)).filter(
                 (pkg) => Object.values(result.metafile?.inputs || {}).some(
-                  ({ imports }) => imports.some(({ path: path20 }) => path20 === pkg)
+                  ({ imports }) => imports.some(({ path: path22 }) => path22 === pkg)
                 )
               )
             ];
             const warnings = [];
             Object.entries(result.metafile?.inputs || {}).forEach(
-              ([inputPath, { imports }]) => imports.filter(({ path: path20 }) => path20.includes("sst/constructs")).forEach(({ path: path20 }) => {
+              ([inputPath, { imports }]) => imports.filter(({ path: path22 }) => path22.includes("sst/constructs")).forEach(({ path: path22 }) => {
                 warnings.push(
-                  `You are importing from "${path20}" in "${inputPath}". Did you mean to import from "sst/node"?`
+                  `You are importing from "${path22}" in "${inputPath}". Did you mean to import from "sst/node"?`
                 );
               })
             );
             async function find2(dir, target2) {
               if (dir === "/")
                 throw new VisibleError("Could not find a package.json file");
-              if (await fs8.access(path8.join(dir, target2)).then(() => true).catch(() => false))
+              if (await fs9.access(path10.join(dir, target2)).then(() => true).catch(() => false))
                 return dir;
-              return find2(path8.join(dir, ".."), target2);
+              return find2(path10.join(dir, ".."), target2);
             }
             if (input.mode === "deploy" && installPackages) {
               const src = await find2(parsed.dir, "package.json");
               const json = JSON.parse(
-                await fs8.readFile(path8.join(src, "package.json")).then((x) => x.toString())
+                await fs9.readFile(path10.join(src, "package.json")).then((x) => x.toString())
               );
-              await fs8.writeFile(
-                path8.join(input.out, "package.json"),
+              await fs9.writeFile(
+                path10.join(input.out, "package.json"),
                 JSON.stringify({
                   dependencies: Object.fromEntries(
                     installPackages.map((x) => [x, json.dependencies?.[x] || "*"])
@@ -4520,24 +5261,24 @@ var init_node = __esm({
                   input.props.architecture === "arm_64" ? "--arch=arm64" : "--arch=x64"
                 );
               }
-              await new Promise((resolve, reject) => {
-                exec2(cmd.join(" "), { cwd: input.out }, (error2) => {
-                  if (error2) {
-                    reject(error2);
+              await new Promise((resolve2, reject) => {
+                exec2(cmd.join(" "), { cwd: input.out }, (error3) => {
+                  if (error3) {
+                    reject(error3);
                   }
-                  resolve();
+                  resolve2();
                 });
               });
             }
             if (input.mode === "start") {
-              const dir = path8.join(
+              const dir = path10.join(
                 await find2(parsed.dir, "package.json"),
                 "node_modules"
               );
               try {
-                await fs8.symlink(
-                  path8.resolve(dir),
-                  path8.resolve(path8.join(input.out, "node_modules")),
+                await fs9.symlink(
+                  path10.resolve(dir),
+                  path10.resolve(path10.join(input.out, "node_modules")),
                   "dir"
                 );
               } catch {
@@ -4576,22 +5317,22 @@ var go_exports = {};
 __export(go_exports, {
   useGoHandler: () => useGoHandler
 });
-import path9 from "path";
-import fs9 from "fs/promises";
-import os3 from "os";
+import path11 from "path";
+import fs10 from "fs/promises";
+import os4 from "os";
 import { spawn as spawn2 } from "child_process";
 async function find(dir, target) {
   if (dir === "/")
     throw new VisibleError(`Could not find a ${target} file`);
-  if (await fs9.access(path9.join(dir, target)).then(() => true).catch(() => false))
+  if (await fs10.access(path11.join(dir, target)).then(() => true).catch(() => false))
     return dir;
-  return find(path9.join(dir, ".."), target);
+  return find(path11.join(dir, ".."), target);
 }
 var useGoHandler;
 var init_go = __esm({
   "src/runtime/handlers/go.ts"() {
     "use strict";
-    init_handlers();
+    init_handlers2();
     init_workers();
     init_context();
     init_error();
@@ -4614,7 +5355,7 @@ var init_go = __esm({
         },
         canHandle: (input) => input.startsWith("go"),
         startWorker: async (input) => {
-          const proc = spawn2(path9.join(input.out, handlerName), {
+          const proc = spawn2(path11.join(input.out, handlerName), {
             env: {
               ...process.env,
               ...input.environment,
@@ -4640,14 +5381,14 @@ var init_go = __esm({
           }
         },
         build: async (input) => {
-          const parsed = path9.parse(input.props.handler);
+          const parsed = path11.parse(input.props.handler);
           const project = await find(parsed.dir, "go.mod");
           sources.set(input.functionID, project);
-          const src = path9.relative(project, input.props.handler);
+          const src = path11.relative(project, input.props.handler);
           if (input.mode === "start") {
             try {
-              const target = path9.join(input.out, handlerName);
-              const srcPath = os3.platform() === "win32" ? src.replaceAll("\\", "\\\\") : src;
+              const target = path11.join(input.out, handlerName);
+              const srcPath = os4.platform() === "win32" ? src.replaceAll("\\", "\\\\") : src;
               const result = await execAsync(
                 `go build -ldflags "-s -w" -o "${target}" ./${srcPath}`,
                 {
@@ -4666,8 +5407,8 @@ var init_go = __esm({
           }
           if (input.mode === "deploy") {
             try {
-              const target = path9.join(input.out, "bootstrap");
-              const srcPath = os3.platform() === "win32" ? src.replaceAll("\\", "\\\\") : src;
+              const target = path11.join(input.out, "bootstrap");
+              const srcPath = os4.platform() === "win32" ? src.replaceAll("\\", "\\\\") : src;
               await execAsync(
                 `go build -ldflags "-s -w" -o "${target}" ./${srcPath}`,
                 {
@@ -4697,20 +5438,156 @@ var init_go = __esm({
   }
 });
 
+// src/runtime/handlers/container.ts
+var container_exports = {};
+__export(container_exports, {
+  useContainerHandler: () => useContainerHandler
+});
+import { spawn as spawn3 } from "child_process";
+var useContainerHandler;
+var init_container = __esm({
+  "src/runtime/handlers/container.ts"() {
+    "use strict";
+    init_handlers2();
+    init_workers();
+    init_context();
+    init_error();
+    init_server();
+    init_fs();
+    init_process();
+    useContainerHandler = Context.memo(async () => {
+      const workers = await useRuntimeWorkers();
+      const server = await useRuntimeServerConfig();
+      const handlers = useRuntimeHandlers();
+      const containers = /* @__PURE__ */ new Map();
+      const sources = /* @__PURE__ */ 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) => {
+          const name = `sst-workerID-${input.workerID}-${Date.now()}`;
+          const proc = spawn3(
+            "docker",
+            [
+              "run",
+              "--rm",
+              "--network=host",
+              `--name=${name}`,
+              ...Object.entries({
+                ...input.environment,
+                IS_LOCAL: "true",
+                AWS_LAMBDA_RUNTIME_API: `host.docker.internal:${server.port}/${input.workerID}`
+              }).map(([key, value]) => ["-e", `${key}=${value}`]).flat(),
+              `sst-dev:${input.functionID}`
+            ],
+            {
+              env: {
+                ...process.env
+              },
+              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());
+          });
+          containers.set(input.workerID, name);
+        },
+        stopWorker: async (workerID) => {
+          const name = containers.get(workerID);
+          if (name) {
+            try {
+              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} .`,
+                {
+                  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}`,
+                  `--platform ${platform}`,
+                  `.`
+                ].join(" "),
+                {
+                  cwd: project,
+                  env: {
+                    ...process.env
+                  }
+                }
+              );
+            } catch (ex) {
+              return {
+                type: "error",
+                errors: [String(ex)]
+              };
+            }
+          }
+          return {
+            type: "success",
+            handler: "not required for container"
+          };
+        }
+      });
+    });
+  }
+});
+
 // src/runtime/handlers/rust.ts
 var rust_exports = {};
 __export(rust_exports, {
   useRustHandler: () => useRustHandler
 });
-import path10 from "path";
-import fs10 from "fs/promises";
-import { exec as exec4, spawn as spawn3 } from "child_process";
+import path12 from "path";
+import fs11 from "fs/promises";
+import { exec as exec4, spawn as spawn4 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2, useRustHandler;
 var init_rust = __esm({
   "src/runtime/handlers/rust.ts"() {
     "use strict";
-    init_handlers();
+    init_handlers2();
     init_workers();
     init_context();
     init_error();
@@ -4736,7 +5613,7 @@ var init_rust = __esm({
         },
         canHandle: (input) => input.startsWith("rust"),
         startWorker: async (input) => {
-          const proc = spawn3(path10.join(input.out, handlerName), {
+          const proc = spawn4(path12.join(input.out, handlerName), {
             env: {
               ...process.env,
               ...input.environment,
@@ -4764,7 +5641,7 @@ var init_rust = __esm({
           }
         },
         build: async (input) => {
-          const parsed = path10.parse(input.props.handler);
+          const parsed = path12.parse(input.props.handler);
           const project = await findAbove(parsed.dir, "Cargo.toml");
           if (!project)
             return {
@@ -4780,9 +5657,9 @@ var init_rust = __esm({
                   ...process.env
                 }
               });
-              await fs10.cp(
-                path10.join(project, `target/debug`, parsed.name),
-                path10.join(input.out, "handler")
+              await fs11.cp(
+                path12.join(project, `target/debug`, parsed.name),
+                path12.join(input.out, "handler")
               );
             } catch (ex) {
               throw new VisibleError("Failed to build");
@@ -4796,9 +5673,9 @@ var init_rust = __esm({
                   ...process.env
                 }
               });
-              await fs10.cp(
-                path10.join(project, `target/lambda/`, parsed.name, "bootstrap"),
-                path10.join(input.out, "bootstrap")
+              await fs11.cp(
+                path12.join(project, `target/lambda/`, parsed.name, "bootstrap"),
+                path12.join(input.out, "bootstrap")
               );
             } catch (ex) {
               throw new VisibleError("Failed to build");
@@ -4815,9 +5692,9 @@ var init_rust = __esm({
 });
 
 // src/runtime/handlers/pythonBundling.ts
-import fs11 from "fs";
+import fs12 from "fs";
 import url5 from "url";
-import path11 from "path";
+import path13 from "path";
 import { DockerImage, FileSystem } from "aws-cdk-lib/core";
 function bundle(options) {
   const { entry, runtime, architecture, outputPathSuffix, installCommands } = options;
@@ -4828,9 +5705,9 @@ function bundle(options) {
     stagedir
   );
   const dockerfile = hasInstallCommands ? "Dockerfile.custom" : hasDeps ? "Dockerfile.dependencies" : "Dockerfile";
-  fs11.copyFileSync(
-    path11.join(__dirname, "../../support/python-runtime", dockerfile),
-    path11.join(stagedir, dockerfile)
+  fs12.copyFileSync(
+    path13.join(__dirname, "../../support/python-runtime", dockerfile),
+    path13.join(stagedir, dockerfile)
   );
   const image = DockerImage.fromBuild(stagedir, {
     buildArgs: {
@@ -4838,21 +5715,21 @@ function bundle(options) {
     },
     file: dockerfile
   });
-  const outputPath = path11.join(options.out, outputPathSuffix);
+  const outputPath = path13.join(options.out, outputPathSuffix);
   if (hasDeps || hasInstallCommands) {
     image.cp(`${BUNDLER_DEPENDENCIES_CACHE}/.`, outputPath);
   }
-  fs11.cpSync(entry, outputPath, {
+  fs12.cpSync(entry, outputPath, {
     recursive: true
   });
 }
 function stageDependencies(entry, stagedir) {
   const prefixes = ["Pipfile", "pyproject", "poetry", "requirements.txt"];
   let found = false;
-  for (const file of fs11.readdirSync(entry)) {
+  for (const file of fs12.readdirSync(entry)) {
     for (const prefix of prefixes) {
       if (file.startsWith(prefix)) {
-        fs11.copyFileSync(path11.join(entry, file), path11.join(stagedir, file));
+        fs12.copyFileSync(path13.join(entry, file), path13.join(stagedir, file));
         found = true;
       }
     }
@@ -4862,9 +5739,9 @@ function stageDependencies(entry, stagedir) {
 function stageInstallCommands(installCommands, stagedir) {
   let found = false;
   if (installCommands.length > 0) {
-    const filePath = path11.join(stagedir, "sst-deps-install-command.sh");
-    fs11.writeFileSync(filePath, installCommands.join(" && "));
-    fs11.chmodSync(filePath, "755");
+    const filePath = path13.join(stagedir, "sst-deps-install-command.sh");
+    fs12.writeFileSync(filePath, installCommands.join(" && "));
+    fs12.chmodSync(filePath, "755");
     found = true;
   }
   return found;
@@ -4873,7 +5750,7 @@ var __dirname, BUNDLER_DEPENDENCIES_CACHE;
 var init_pythonBundling = __esm({
   "src/runtime/handlers/pythonBundling.ts"() {
     "use strict";
-    __dirname = path11.dirname(url5.fileURLToPath(import.meta.url));
+    __dirname = path13.dirname(url5.fileURLToPath(import.meta.url));
     BUNDLER_DEPENDENCIES_CACHE = "/var/dependencies";
   }
 });
@@ -4883,17 +5760,17 @@ var python_exports = {};
 __export(python_exports, {
   usePythonHandler: () => usePythonHandler
 });
-import path12 from "path";
-import { exec as exec5, spawn as spawn4 } from "child_process";
+import path14 from "path";
+import { exec as exec5, spawn as spawn5 } from "child_process";
 import { promisify as promisify3 } from "util";
 import { Runtime } from "aws-cdk-lib/aws-lambda";
-import os4 from "os";
+import os5 from "os";
 import url6 from "url";
 var execAsync3, RUNTIME_MAP, usePythonHandler;
 var init_python = __esm({
   "src/runtime/handlers/python.ts"() {
     "use strict";
-    init_handlers();
+    init_handlers2();
     init_workers();
     init_context();
     init_server();
@@ -4934,10 +5811,10 @@ var init_python = __esm({
           const src = await findSrc(input.handler);
           if (!src)
             throw new Error(`Could not find src for ${input.handler}`);
-          const parsed = path12.parse(path12.relative(src, input.handler));
-          const target = [...parsed.dir.split(path12.sep), parsed.name].join(".");
-          const proc = spawn4(
-            os4.platform() === "win32" ? "python.exe" : "python3",
+          const parsed = path14.parse(path14.relative(src, input.handler));
+          const target = [...parsed.dir.split(path14.sep), parsed.name].join(".");
+          const proc = spawn5(
+            os5.platform() === "win32" ? "python.exe" : "python3",
             [
               "-u",
               url6.fileURLToPath(
@@ -4997,7 +5874,7 @@ var init_python = __esm({
           });
           return {
             type: "success",
-            handler: path12.relative(src, path12.resolve(input.props.handler)).split(path12.sep).join(path12.posix.sep)
+            handler: path14.relative(src, path14.resolve(input.props.handler)).split(path14.sep).join(path14.posix.sep)
           };
         }
       });
@@ -5010,21 +5887,21 @@ var java_exports = {};
 __export(java_exports, {
   useJavaHandler: () => useJavaHandler
 });
-import path13 from "path";
-import fs12 from "fs/promises";
-import os5 from "os";
-import { spawn as spawn5 } from "child_process";
+import path15 from "path";
+import fs13 from "fs/promises";
+import os6 from "os";
+import { spawn as spawn6 } from "child_process";
 import url7 from "url";
 import AdmZip from "adm-zip";
 async function getGradleBinary(srcPath) {
-  const gradleWrapperPath = path13.resolve(path13.join(srcPath, "gradlew"));
+  const gradleWrapperPath = path15.resolve(path15.join(srcPath, "gradlew"));
   return await existsAsync(gradleWrapperPath) ? gradleWrapperPath : "gradle";
 }
 var useJavaHandler;
 var init_java = __esm({
   "src/runtime/handlers/java.ts"() {
     "use strict";
-    init_handlers();
+    init_handlers2();
     init_workers();
     init_context();
     init_server();
@@ -5049,7 +5926,7 @@ var init_java = __esm({
         },
         canHandle: (input) => input.startsWith("java"),
         startWorker: async (input) => {
-          const proc = spawn5(
+          const proc = spawn6(
             `java`,
             [
               `-cp`,
@@ -5057,7 +5934,7 @@ var init_java = __esm({
                 url7.fileURLToPath(
                   new URL("../../support/java-runtime/release/*", import.meta.url)
                 )
-              ].join(os5.platform() === "win32" ? ";" : ":"),
+              ].join(os6.platform() === "win32" ? ";" : ":"),
               "com.amazonaws.services.lambda.runtime.api.client.AWSLambda",
               input.handler
             ],
@@ -5101,11 +5978,11 @@ var init_java = __esm({
                 cwd: srcPath
               }
             );
-            const buildOutput = path13.join(srcPath, "build", outputDir);
-            const zip = (await fs12.readdir(buildOutput)).find(
+            const buildOutput = path15.join(srcPath, "build", outputDir);
+            const zip = (await fs13.readdir(buildOutput)).find(
               (f) => f.endsWith(".zip")
             );
-            new AdmZip(path13.join(buildOutput, zip)).extractAllTo(input.out);
+            new AdmZip(path15.join(buildOutput, zip)).extractAllTo(input.out);
             return {
               type: "success",
               handler: input.props.handler
@@ -5124,17 +6001,19 @@ var init_java = __esm({
 
 // src/stacks/synth.ts
 import * as contextproviders from "sst-aws-cdk/lib/context-providers/index.js";
-import path14 from "path";
+import path16 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 { useContainerHandler: useContainerHandler2 } = await Promise.resolve().then(() => (init_container(), container_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();
   useGoHandler2();
+  useContainerHandler2();
   usePythonHandler2();
   useJavaHandler2();
   useDotnetHandler();
@@ -5144,7 +6023,7 @@ async function synth(opts) {
   const identity = await useSTSIdentity();
   opts = {
     ...opts,
-    buildDir: opts.buildDir || path14.join(project.paths.out, "dist")
+    buildDir: opts.buildDir || path16.join(project.paths.out, "dist")
   };
   const cfg = new Configuration();
   await cfg.load();
@@ -5229,7 +6108,7 @@ async function removeMany(stacks) {
   const complete = /* @__PURE__ */ new Set();
   const todo = new Set(stacks.map((s) => s.id));
   const results = {};
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     async function trigger() {
       for (const stack of stacks) {
         if (!todo.has(stack.id))
@@ -5268,7 +6147,7 @@ async function removeMany(stacks) {
               }
             });
           if (complete.size === stacks.length) {
-            resolve(results);
+            resolve2(results);
           }
           trigger();
         });
@@ -5357,9 +6236,9 @@ __export(bootstrap_exports, {
   useBootstrap: () => useBootstrap
 });
 import url8 from "url";
-import path15 from "path";
+import path17 from "path";
 import { bold, dim } from "colorette";
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 import {
   DescribeStacksCommand as DescribeStacksCommand2,
   CloudFormationClient as CloudFormationClient3
@@ -5486,7 +6365,7 @@ async function bootstrapSST() {
   });
   const fn = new Function(stack, "MetadataHandler", {
     code: Code.fromAsset(
-      path15.resolve(__dirname2, "support/bootstrap-metadata-function")
+      path17.resolve(__dirname2, "support/bootstrap-metadata-function")
     ),
     handler: "index.handler",
     runtime: region?.startsWith("us-gov-") ? Runtime2.NODEJS_16_X : Runtime2.NODEJS_18_X,
@@ -5547,8 +6426,8 @@ async function bootstrapCDK() {
   const identity = await useSTSIdentity();
   const credentials = await useAWSCredentials();
   const { region, profile, cdk } = useProject().config;
-  await new Promise((resolve, reject) => {
-    const proc = spawn6(
+  await new Promise((resolve2, reject) => {
+    const proc = spawn7(
       [
         "npx",
         "cdk",
@@ -5585,7 +6464,7 @@ async function bootstrapCDK() {
     proc.on("exit", (code) => {
       Logger.debug("CDK bootstrap exited with code " + code);
       if (code === 0) {
-        resolve();
+        resolve2();
       } else {
         console.log(bold(dim(stderr)));
         reject(new VisibleError(`Failed to bootstrap`));
@@ -5694,7 +6573,7 @@ __export(server_exports2, {
 });
 import { produceWithPatches, enablePatches } from "immer";
 import express2 from "express";
-import fs13 from "fs/promises";
+import fs14 from "fs/promises";
 import { WebSocketServer } from "ws";
 import https3 from "https";
 import http from "http";
@@ -5775,15 +6654,15 @@ async function useLocalServer(opts) {
     const CERT_PATH = ".sst/localhost.pem";
     if (result2.status === 0) {
       try {
-        await Promise.all([fs13.access(KEY_PATH), fs13.access(CERT_PATH)]);
+        await Promise.all([fs14.access(KEY_PATH), fs14.access(CERT_PATH)]);
       } catch (e) {
         sync("mkcert", ["localhost"], {
           cwd: ".sst"
         });
       }
       const [key, cert] = await Promise.all([
-        fs13.readFile(KEY_PATH),
-        fs13.readFile(CERT_PATH)
+        fs14.readFile(KEY_PATH),
+        fs14.readFile(CERT_PATH)
       ]);
       return https3.createServer(
         {
@@ -6206,10 +7085,10 @@ function printDeploymentResults(assembly, results, remove4) {
       Colors.line(
         `   ${Colors.dim(stackNameToId(stack))} ${Colors.dim(result.status)}`
       );
-      for (const [id, error2] of Object.entries(result.errors)) {
+      for (const [id, error3] of Object.entries(result.errors)) {
         const readable = logicalIdToCdkPath(assembly, stack, id) || id;
-        Colors.line(`   ${Colors.danger.bold(readable + ":")} ${error2}`);
-        const helper = getHelper(error2);
+        Colors.line(`   ${Colors.danger.bold(readable + ":")} ${error3}`);
+        const helper = getHelper(error3);
         if (helper) {
           Colors.line(`   ${Colors.warning.bold("\u2B91  Hint:")} ${helper}`);
         }
@@ -6234,30 +7113,30 @@ function logicalIdToCdkPath(assembly, stack, logicalId) {
   }
   return found.split("/").filter(Boolean).slice(1, -1).join("/");
 }
-function getHelper(error2) {
-  return getCloudFrontBehaviorLimitHelper(error2) || getApiAccessLogPermissionsHelper(error2) || getAppSyncMultiResolverHelper(error2) || getApiLogRoleHelper(error2);
+function getHelper(error3) {
+  return getCloudFrontBehaviorLimitHelper(error3) || getApiAccessLogPermissionsHelper(error3) || getAppSyncMultiResolverHelper(error3) || getApiLogRoleHelper(error3);
 }
-function getCloudFrontBehaviorLimitHelper(error2) {
-  if (error2.indexOf(
+function getCloudFrontBehaviorLimitHelper(error3) {
+  if (error3.indexOf(
     "Your request contains more CacheBehaviors than are allowed per distribution."
   ) > -1) {
     return `This error often occurs when deploying a frontend with a large number of top-level files and folders in the assets directory. Check out this doc on how to resolve the issue - https://docs.sst.dev/known-issues#cloudfront-cachebehaviors-limit-exceeded`;
   }
 }
-function getApiAccessLogPermissionsHelper(error2) {
-  if (error2.indexOf("Insufficient permissions to enable logging") > -1) {
+function getApiAccessLogPermissionsHelper(error3) {
+  if (error3.indexOf("Insufficient permissions to enable logging") > -1) {
     return `This is a common deploy error. Check out this GitHub issue for more details - https://github.com/serverless-stack/sst/issues/125`;
   }
 }
-function getAppSyncMultiResolverHelper(error2) {
-  if (error2.indexOf(
+function getAppSyncMultiResolverHelper(error3) {
+  if (error3.indexOf(
     "Only one resolver is allowed per field. (Service: AWSAppSync"
   ) > -1) {
     return `This is a common error for deploying AppSync APIs. Check out this GitHub issue for more details - https://github.com/aws/aws-cdk/issues/13269`;
   }
 }
-function getApiLogRoleHelper(error2) {
-  if (error2.indexOf(
+function getApiLogRoleHelper(error3) {
+  if (error3.indexOf(
     "CloudWatch Logs role ARN must be set in account settings to enable logging (Service: AmazonApiGatewayV2"
   ) > -1) {
     return `This is a common error when configuring Access Log for WebSocket APIs. The AWS API Gateway service in your AWS account does not have permissions to the CloudWatch logs service. Follow this article to create an IAM role for logging to CloudWatch - https://aws.amazon.com/premiumsupport/knowledge-center/api-gateway-cloudwatch-logs/`;
@@ -6337,16 +7216,16 @@ __export(pothos_exports, {
 import babel2 from "@babel/core";
 import generator from "@babel/generator";
 import esbuild3 from "esbuild";
-import fs14 from "fs/promises";
-import path16 from "path";
+import fs15 from "fs/promises";
+import path18 from "path";
 import url9 from "url";
 async function generate2(opts) {
   const { printSchema, lexicographicSortSchema } = await import("graphql");
   const contents = await extractSchema(opts);
-  const out = path16.join(path16.dirname(opts.schema), "out.mjs");
-  await fs14.writeFile(out, contents, "utf8");
+  const out = path18.join(path18.dirname(opts.schema), "out.mjs");
+  await fs15.writeFile(out, contents, "utf8");
   const { schema } = await import(url9.pathToFileURL(out).href + "?bust=" + Date.now());
-  await fs14.rm(out);
+  await fs15.rm(out);
   const schemaAsString = printSchema(lexicographicSortSchema(schema));
   return schemaAsString;
 }
@@ -6384,15 +7263,15 @@ async function extractSchema(opts) {
       {
         name: "pothos-extractor",
         visitor: {
-          Program(path20) {
-            const dummyResolverId = path20.scope.generateUidIdentifier("DUMMY_RESOLVER");
+          Program(path22) {
+            const dummyResolverId = path22.scope.generateUidIdentifier("DUMMY_RESOLVER");
             const resolverNode = dummyResolver({
               dummy_resolver: dummyResolverId
             });
-            path20.unshiftContainer("body", resolverNode);
-            path20.scope.crawl();
+            path22.unshiftContainer("body", resolverNode);
+            path22.scope.crawl();
             let schemaBuilder = null;
-            path20.traverse({
+            path22.traverse({
               ImportDeclaration(declarator) {
                 if (!declarator)
                   return;
@@ -6450,17 +7329,17 @@ async function extractSchema(opts) {
   );
   return contents.code;
 }
-function getBindings(path20, globalPaths) {
+function getBindings(path22, globalPaths) {
   const bindings = [];
-  path20.traverse({
+  path22.traverse({
     Expression(expressionPath) {
       if (!expressionPath.isIdentifier())
         return;
-      const binding = path20.scope.getBinding(expressionPath);
+      const binding = path22.scope.getBinding(expressionPath);
       if (!binding || globalPaths.has(binding.path) || bindings.includes(binding.path))
         return;
       const rootBinding = findRootBinding(binding.path);
-      if (path20 === rootBinding) {
+      if (path22 === rootBinding) {
         bindings.push(binding.path);
         return;
       }
@@ -6473,8 +7352,8 @@ function getBindings(path20, globalPaths) {
   }
   return bindings;
 }
-function findRootBinding(path20) {
-  let rootPath = path20;
+function findRootBinding(path22) {
+  let rootPath = path22;
   while (rootPath.parentPath?.node !== void 0 && !rootPath.parentPath?.isProgram()) {
     rootPath = rootPath.parentPath;
   }
@@ -6497,10 +7376,10 @@ var pothos_exports2 = {};
 __export(pothos_exports2, {
   usePothosBuilder: () => usePothosBuilder
 });
-import fs15 from "fs/promises";
+import fs16 from "fs/promises";
 import { exec as exec6 } from "child_process";
 import { promisify as promisify4 } from "util";
-import path17 from "path";
+import path19 from "path";
 var execAsync4, usePothosBuilder;
 var init_pothos2 = __esm({
   "src/cli/commands/plugins/pothos.ts"() {
@@ -6519,7 +7398,7 @@ var init_pothos2 = __esm({
             schema: route.schema,
             internalPackages: route.internalPackages
           });
-          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)));
           }
@@ -6535,9 +7414,9 @@ var init_pothos2 = __esm({
         if (evt.properties.file.endsWith("out.mjs"))
           return;
         for (const route of routes) {
-          const dir = path17.dirname(route.schema);
-          const relative = path17.relative(dir, evt.properties.file);
-          if (relative && !relative.startsWith("..") && !path17.isAbsolute(relative))
+          const dir = path19.dirname(route.schema);
+          const relative = path19.relative(dir, evt.properties.file);
+          if (relative && !relative.startsWith("..") && !path19.isAbsolute(relative))
             build2(route);
         }
       });
@@ -6563,7 +7442,7 @@ __export(kysely_exports, {
 import { Kysely } from "kysely";
 import { DataApiDialect } from "kysely-data-api";
 import { RDSData } from "@aws-sdk/client-rds-data";
-import * as fs16 from "fs/promises";
+import * as fs17 from "fs/promises";
 import {
   PostgresDialect,
   MysqlDialect,
@@ -6621,7 +7500,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();
@@ -6996,12 +7875,12 @@ var program = yargs(hideBin(process.argv)).scriptName("sst").option("stage", {
     const { trackCli: trackCli2 } = await Promise.resolve().then(() => (init_telemetry(), telemetry_exports));
     trackCli2(argv._[0]);
   }
-}).version(false).epilogue(`Join the SST community on Discord https://sst.dev/discord`).recommendCommands().demandCommand().strict().fail((_, error2, yargs2) => {
-  if (!error2) {
+}).version(false).epilogue(`Join the SST community on Discord https://sst.dev/discord`).recommendCommands().demandCommand().strict().fail((_, error3, yargs2) => {
+  if (!error3) {
     yargs2.showHelp();
     process.exit(1);
   }
-  throw error2;
+  throw error3;
 });
 
 // src/cli/sst.ts
@@ -7034,14 +7913,14 @@ var dev = (program2) => program2.command(
     const { Colors: Colors2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
     const { printHeader: printHeader2 } = await Promise.resolve().then(() => (init_header(), header_exports));
     const { mapValues } = await import("remeda");
-    const path20 = await import("path");
+    const path22 = await import("path");
     const { useRuntimeWorkers: useRuntimeWorkers2 } = await Promise.resolve().then(() => (init_workers(), workers_exports));
     const { useIOTBridge: useIOTBridge2 } = await Promise.resolve().then(() => (init_iot2(), iot_exports2));
     const { useRuntimeServer: useRuntimeServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
     const { useBus: useBus2 } = await Promise.resolve().then(() => (init_bus(), bus_exports));
     const { useWatcher: useWatcher2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
     const { useAppMetadata: useAppMetadata2, saveAppMetadata: saveAppMetadata2, Stacks } = await Promise.resolve().then(() => (init_stacks(), stacks_exports));
-    const { Logger: Logger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+    const { Logger: Logger3 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
     const { createSpinner: createSpinner2 } = await Promise.resolve().then(() => (init_spinner(), spinner_exports));
     const { bold: bold2, dim: dim2, yellow } = await import("colorette");
     const { render } = await import("ink");
@@ -7049,7 +7928,7 @@ 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_server2(), server_exports2));
-    const fs18 = await import("fs/promises");
+    const fs19 = await import("fs/promises");
     const crypto2 = await import("crypto");
     const { useFunctions: useFunctions3 } = await import("../src/constructs/Function.js");
     const { useSites } = await import("../src/constructs/SsrSite.js");
@@ -7101,9 +7980,16 @@ var dev = (program2) => program2.command(
         );
       });
       bus.subscribe("worker.stdout", async (evt) => {
+        const info = useFunctions3().fromID(evt.properties.functionID);
         prefix(evt.properties.requestID);
         const { started } = pending.get(evt.properties.requestID);
         for (let line of evt.properties.message.split("\n")) {
+          if (info?.runtime === "container") {
+            const parts = line.split("	");
+            if (parts.length >= 4 && Date.parse(parts[0]) && parts[1].length === 36) {
+              line = parts.slice(3).join("	");
+            }
+          }
           Colors2.line(
             prefix(evt.properties.requestID),
             Colors2.dim(("+" + (Date.now() - started) + "ms").padEnd(7)),
@@ -7111,13 +7997,27 @@ var dev = (program2) => program2.command(
           );
         }
       });
+      bus.subscribe("function.build.started", async (evt) => {
+        const info = useFunctions3().fromID(evt.properties.functionID);
+        if (!info)
+          return;
+        if (info.enableLiveDev === false)
+          return;
+        if (info.runtime !== "container")
+          return;
+        Colors2.line(
+          Colors2.dim(Colors2.prefix, "Building", info.handler, "container")
+        );
+      });
       bus.subscribe("function.build.success", async (evt) => {
         const info = useFunctions3().fromID(evt.properties.functionID);
         if (!info)
           return;
         if (info.enableLiveDev === false)
           return;
-        Colors2.line(Colors2.dim(Colors2.prefix, "Built", info.handler));
+        Colors2.line(
+          info.runtime === "container" ? Colors2.dim(Colors2.prefix, "Built", info.handler, "container") : Colors2.dim(Colors2.prefix, "Built", info.handler)
+        );
       });
       bus.subscribe("function.build.failed", async (evt) => {
         const info = useFunctions3().fromID(evt.properties.functionID);
@@ -7191,9 +8091,9 @@ var dev = (program2) => program2.command(
             outDir: `.sst/cdk.out`,
             mode: "dev"
           });
-          Logger2.debug("Directory", assembly.directory);
+          Logger3.debug("Directory", assembly.directory);
           const next = await checksum(assembly.directory);
-          Logger2.debug("Checksum", "next", next, "old", lastDeployed);
+          Logger3.debug("Checksum", "next", next, "old", lastDeployed);
           if (next === lastDeployed) {
             spinner.succeed(Colors2.dim(" Built with no changes"));
             isWorking = false;
@@ -7231,7 +8131,7 @@ var dev = (program2) => program2.command(
           useSites().all.filter(({ props }) => props.dev?.deploy !== true).forEach(({ type, props }) => {
             const framework = type === "AstroSite" ? "Astro" : type === "NextjsSite" ? "Next.js" : type === "RemixSite" ? "Remix" : type === "SolidStartSite" ? "SolidStart" : type === "SvelteKitSite" ? "SvelteKit" : void 0;
             if (framework) {
-              const cdCmd = path20.resolve(props.path) === process.cwd() ? "" : `cd ${props.path} && `;
+              const cdCmd = path22.resolve(props.path) === process.cwd() ? "" : `cd ${props.path} && `;
               Colors2.line(
                 Colors2.primary(`\u279C `),
                 Colors2.bold(`Start ${framework}:`),
@@ -7242,8 +8142,8 @@ var dev = (program2) => program2.command(
           });
         }
         lastDeployed = nextChecksum;
-        fs18.writeFile(
-          path20.join(project.paths.out, "outputs.json"),
+        fs19.writeFile(
+          path22.join(project.paths.out, "outputs.json"),
           JSON.stringify(
             mapValues(results, (val) => val.outputs),
             null,
@@ -7255,17 +8155,17 @@ var dev = (program2) => program2.command(
           build2();
       }
       async function checksum(cdkOutPath) {
-        const manifestPath = path20.join(cdkOutPath, "manifest.json");
+        const manifestPath = path22.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 = path20.join(cdkOutPath, templateFile);
-            const templateContent = await fs18.readFile(templatePath);
+            const templatePath = path22.join(cdkOutPath, templateFile);
+            const templateContent = await fs19.readFile(templatePath);
             return templateContent;
           })
         ).then((x) => x.join("\n"));
@@ -7275,7 +8175,7 @@ var dev = (program2) => program2.command(
       watcher.subscribe("file.changed", async (evt) => {
         if (!project.metafile)
           return;
-        if (!project.metafile.inputs[evt.properties.relative.split(path20.sep).join(path20.posix.sep)])
+        if (!project.metafile.inputs[evt.properties.relative.split(path22.sep).join(path22.posix.sep)])
           return;
         build2();
       });
@@ -7320,7 +8220,7 @@ var dev = (program2) => program2.command(
         input: process.stdin,
         output: process.stdout
       });
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         console.log("");
         rl.question(
           `You have previously deployed the stage "${useProject2().config.stage}" in production. It is recommended that you use a different stage for development. Read more here \u2014 https://docs.sst.dev/live-lambda-development
@@ -7328,7 +8228,7 @@ var dev = (program2) => program2.command(
 Are you sure you want to run this stage in dev mode? [y/N] `,
           async (input) => {
             rl.close();
-            resolve(input.trim() === "y");
+            resolve2(input.trim() === "y");
           }
         );
       });
@@ -7357,7 +8257,7 @@ Are you sure you want to run this stage in dev mode? [y/N] `,
 
 // src/cli/commands/bind.ts
 init_error();
-import path18 from "path";
+import path20 from "path";
 var MetadataNotFoundError = class extends Error {
 };
 var MetadataOutdatedError = class extends Error {
@@ -7376,13 +8276,13 @@ var bind = (program2) => program2.command(
     "Bind resources to your site before deployment"
   ),
   async (args) => {
-    const { spawn: spawn7 } = await import("child_process");
+    const { spawn: spawn8 } = await import("child_process");
     const kill = await import("tree-kill");
     const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
     const { useBus: useBus2 } = await Promise.resolve().then(() => (init_bus(), bus_exports));
     const { useIOT: useIOT2 } = await Promise.resolve().then(() => (init_iot(), iot_exports));
     const { Colors: Colors2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
-    const { Logger: Logger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+    const { Logger: Logger3 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
     if (args._[0] === "env") {
       Colors2.line(
         Colors2.warning(
@@ -7407,7 +8307,7 @@ var bind = (program2) => program2.command(
       );
     }
     if (args.script || !isSite && !args.site) {
-      Logger2.debug("Running in script mode.");
+      Logger3.debug("Running in script mode.");
       return await bindScript();
     }
     await bindSite("init");
@@ -7527,7 +8427,7 @@ var bind = (program2) => program2.command(
         if (!c.data.path || isSsr && !c.data.server || !isSsr && !c.data.environment) {
           throw new MetadataOutdatedError();
         }
-        return path18.resolve(project.paths.root, c.data.path) === process.cwd();
+        return path20.resolve(project.paths.root, c.data.path) === process.cwd();
       });
       if (!data2) {
         throw new MetadataNotFoundError();
@@ -7586,16 +8486,16 @@ var bind = (program2) => program2.command(
       Colors2.gap();
       if (p) {
         p.removeAllListeners("exit");
-        await new Promise((resolve, reject) => {
-          kill.default(p?.pid, (error2) => {
-            if (error2) {
-              return reject(error2);
+        await new Promise((resolve2, reject) => {
+          kill.default(p?.pid, (error3) => {
+            if (error3) {
+              return reject(error3);
             }
-            resolve(true);
+            resolve2(true);
           });
         });
       }
-      p = spawn7(command, {
+      p = spawn8(command, {
         env: {
           ...process.env,
           ...envs,
@@ -7641,7 +8541,7 @@ var bind = (program2) => program2.command(
       Colors2.line(
         "Using local IAM credentials since `sst dev` is not running."
       );
-      Logger2.debug(`Failed to assume ${roleArn}.`, err);
+      Logger3.debug(`Failed to assume ${roleArn}.`, err);
     }
   }
 ).strict(false);
@@ -7658,7 +8558,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 path20 = await import("path");
+    const path22 = await import("path");
     const project = useProject2();
     const [_metafile, sstConfig] = await Stacks.load(project.paths.config);
     const result = await Stacks.synth({
@@ -7670,7 +8570,7 @@ var build = (program2) => program2.command(
     Colors2.line(
       Colors2.success(`\u2714`),
       Colors2.bold(" Built:"),
-      `${result.stacks.length} stack${result.stacks.length > 1 ? "s" : ""} to ${path20.relative(process.cwd(), result.directory)}`
+      `${result.stacks.length} stack${result.stacks.length > 1 ? "s" : ""} to ${path22.relative(process.cwd(), result.directory)}`
     );
     process.exit(0);
   }
@@ -7679,8 +8579,8 @@ var build = (program2) => program2.command(
 // src/cli/commands/deploy.tsx
 init_credentials();
 init_colors();
-import fs17 from "fs/promises";
-import path19 from "path";
+import fs18 from "fs/promises";
+import path21 from "path";
 var deploy2 = (program2) => program2.command(
   "deploy [filter]",
   "Deploy your app to AWS",
@@ -7713,7 +8613,7 @@ var deploy2 = (program2) => program2.command(
         input: process.stdin,
         output: process.stdout
       });
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         console.log("");
         rl.question(
           `You were previously running the stage "${project.config.stage}" in dev mode. It is recommended that you use a different stage for production. Read more here \u2014 https://docs.sst.dev/live-lambda-development
@@ -7721,7 +8621,7 @@ var deploy2 = (program2) => program2.command(
 Are you sure you want to deploy to this stage? (y/N) `,
           async (input) => {
             rl.close();
-            resolve(input.trim() === "y");
+            resolve2(input.trim() === "y");
           }
         );
       });
@@ -7770,8 +8670,8 @@ Are you sure you want to deploy to this stage? (y/N) `,
     printDeploymentResults2(assembly, results);
     if (Object.values(results).some((stack) => Stacks.isFailed(stack.status)))
       process.exit(1);
-    fs17.writeFile(
-      path19.join(project.paths.out, "outputs.json"),
+    fs18.writeFile(
+      path21.join(project.paths.out, "outputs.json"),
       JSON.stringify(
         mapValues(results, (val) => val.outputs),
         null,
@@ -7988,8 +8888,8 @@ var load2 = (program2) => program2.command(
     const { blue: blue4 } = await import("colorette");
     const { createSpinner: createSpinner2 } = await Promise.resolve().then(() => (init_spinner(), spinner_exports));
     const { parse: parse2 } = await import("dotenv");
-    const fs18 = await import("fs/promises");
-    const fileContent = await fs18.readFile(args.filename, "utf-8");
+    const fs19 = await import("fs/promises");
+    const fileContent = await fs19.readFile(args.filename, "utf-8");
     const envVars = parse2(fileContent);
     const setting = createSpinner2(
       ` Setting secrets from "${args.filename}"`
@@ -8145,22 +9045,22 @@ var update = (program2) => program2.command(
   }),
   async (args) => {
     const { green, yellow } = await import("colorette");
-    const fs18 = await import("fs/promises");
-    const path20 = await import("path");
+    const fs19 = await import("fs/promises");
+    const path22 = 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 = path20.join(dir, item);
+        const full = path22.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 [];
@@ -8174,7 +9074,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)
@@ -8208,7 +9108,7 @@ var update = (program2) => program2.command(
         }
       }
       if (results.has(file)) {
-        await fs18.writeFile(file, JSON.stringify(data2, null, 2));
+        await fs19.writeFile(file, JSON.stringify(data2, null, 2));
       }
     });
     await Promise.all(tasks);
@@ -8219,7 +9119,7 @@ var update = (program2) => program2.command(
     for (const [file, pkgs] of results.entries()) {
       Colors2.line(
         Colors2.success(`\u2714 `),
-        Colors2.bold.dim(path20.relative(project.paths.root, file))
+        Colors2.bold.dim(path22.relative(project.paths.root, file))
       );
       for (const [pkg, version2] of pkgs) {
         Colors2.line(Colors2.dim(`   ${pkg}@${version2}`));