sst 2.15.0 → 2.16.1

package/sst.mjs

@@ -2164,6 +2164,7 @@ import { AssetManifestBuilder } from "sst-aws-cdk/lib/util/asset-manifest-builde
 import { publishAssets } 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";
 import { tryHotswapDeployment } from "sst-aws-cdk/lib/api/hotswap-deployments.js";
 import {
   changeSetHasNoChanges,
@@ -2243,13 +2244,15 @@ async function deployStack(options) {
       parallel: options.assetParallelism
     }
   );
-  if (options.hotswap) {
+  const hotswapMode = options.hotswap;
+  if (hotswapMode && hotswapMode !== HotswapMode.FULL_DEPLOYMENT) {
     try {
       const hotswapDeploymentResult = await tryHotswapDeployment(
         options.sdkProvider,
-        assetParams,
+        stackParams.values,
         cloudFormationStack,
-        stackArtifact
+        stackArtifact,
+        hotswapMode
       );
       if (hotswapDeploymentResult) {
         return hotswapDeploymentResult;
@@ -2267,8 +2270,16 @@ async function deployStack(options) {
         e.message
       );
     }
-    print("Falling back to doing a full deployment");
-    options.sdk.appendCustomUserAgent("cdk-hotswap/fallback");
+    if (hotswapMode === HotswapMode.FALL_BACK) {
+      print("Falling back to doing a full deployment");
+      options.sdk.appendCustomUserAgent("cdk-hotswap/fallback");
+    } else {
+      return {
+        noOp: true,
+        stackArn: cloudFormationStack.stackId,
+        outputs: cloudFormationStack.outputs
+      };
+    }
   }
   const fullDeployment = new FullCloudFormationDeployment(
     options,
@@ -2673,18 +2684,21 @@ var init_deploy_stack = __esm({
   }
 });
 
-// src/cdk/cloudformation-deployments.ts
-var cloudformation_deployments_exports = {};
-__export(cloudformation_deployments_exports, {
+// src/cdk/deployments.ts
+var deployments_exports = {};
+__export(deployments_exports, {
   CloudFormationDeployments: () => CloudFormationDeployments,
-  prepareSdkWithLookupRoleFor: () => prepareSdkWithLookupRoleFor
+  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
+  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 {
@@ -2696,62 +2710,21 @@ import {
   CloudFormationStack as CloudFormationStack2
 } from "sst-aws-cdk/lib/api/util/cloudformation.js";
 import { replaceEnvPlaceholders } from "sst-aws-cdk/lib/api/util/placeholders.js";
-async function prepareSdkWithLookupRoleFor(sdkProvider, stack) {
-  const resolvedEnvironment = await sdkProvider.resolveEnvironment(
-    stack.environment
-  );
-  const arns = await replaceEnvPlaceholders(
-    {
-      lookupRoleArn: stack.lookupRole?.arn
-    },
-    resolvedEnvironment,
-    sdkProvider
-  );
-  const warningMessage = `Could not assume ${arns.lookupRoleArn}, proceeding anyway.`;
-  const upgradeMessage = `(To get rid of this warning, please upgrade to bootstrap version >= ${stack.lookupRole?.requiresBootstrapStackVersion})`;
-  try {
-    const stackSdk = await sdkProvider.forEnvironment(
-      resolvedEnvironment,
-      Mode.ForReading,
-      {
-        assumeRoleArn: arns.lookupRoleArn,
-        assumeRoleExternalId: stack.lookupRole?.assumeRoleExternalId
-      }
-    );
-    if (stackSdk.didAssumeRole && stack.lookupRole?.bootstrapStackVersionSsmParameter && stack.lookupRole.requiresBootstrapStackVersion) {
-      const version2 = await ToolkitInfo.versionFromSsmParameter(
-        stackSdk.sdk,
-        stack.lookupRole.bootstrapStackVersionSsmParameter
-      );
-      if (version2 < stack.lookupRole.requiresBootstrapStackVersion) {
-        throw new Error(
-          `Bootstrap stack version '${stack.lookupRole.requiresBootstrapStackVersion}' is required, found version '${version2}'.`
-        );
-      }
-    } else if (!stackSdk.didAssumeRole && stack.lookupRole?.requiresBootstrapStackVersion) {
-      warning(upgradeMessage);
-    }
-    return { ...stackSdk, resolvedEnvironment };
-  } catch (e) {
-    debug2(e);
-    if (stack.lookupRole && stack.lookupRole.requiresBootstrapStackVersion) {
-      warning(warningMessage);
-      warning(upgradeMessage);
-    }
-    throw e;
-  }
-}
-var CloudFormationDeployments;
-var init_cloudformation_deployments = __esm({
-  "src/cdk/cloudformation-deployments.ts"() {
+var Deployments, ParallelSafeAssetProgress, CloudFormationDeployments;
+var init_deployments = __esm({
+  "src/cdk/deployments.ts"() {
     "use strict";
     init_deploy_stack();
     init_util();
-    CloudFormationDeployments = class {
-      sdkProvider;
+    Deployments = class {
       constructor(props) {
+        this.props = props;
         this.sdkProvider = props.sdkProvider;
       }
+      sdkProvider;
+      toolkitInfoCache = /* @__PURE__ */ new Map();
+      sdkCache = /* @__PURE__ */ new Map();
+      publisherCache = /* @__PURE__ */ new Map();
       async readCurrentTemplateWithNestedStacks(rootStackArtifact, retrieveProcessedTemplate = false) {
         const sdk = (await this.prepareSdkWithLookupOrDeployRole(rootStackArtifact)).stackSdk;
         return (await loadCurrentTemplateWithNestedStacks(
@@ -2775,7 +2748,7 @@ var init_cloudformation_deployments = __esm({
           Mode.ForReading
         );
         const cfn = stackSdk.cloudFormation();
-        const toolkitInfo = await ToolkitInfo.lookup(
+        const toolkitInfo = await this.lookupToolkit(
           resolvedEnvironment,
           stackSdk,
           toolkitStackName
@@ -2809,29 +2782,31 @@ var init_cloudformation_deployments = __esm({
             execute: options.execute
           };
         }
-        const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await this.prepareSdkFor(options.stack, options.roleArn);
+        const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
         const toolkitInfo = await callWithRetry(
-          () => ToolkitInfo.lookup(
+          () => this.lookupToolkit(
             resolvedEnvironment,
             stackSdk,
             options.toolkitStackName
           )
         );
-        if (options.resourcesToImport === void 0) {
-          await this.publishStackAssets(options.stack, toolkitInfo, {
-            buildAssets: options.buildAssets ?? true,
-            publishOptions: {
-              quiet: options.quiet,
-              parallel: options.assetParallelism
-            }
-          });
-        }
         await this.validateBootstrapStackVersion(
           options.stack.stackName,
           options.stack.requiresBootstrapStackVersion,
           options.stack.bootstrapStackVersionSsmParameter,
           toolkitInfo
         );
+        const assetArtifacts = options.stack.dependencies.filter(
+          cxapi2.AssetManifestArtifact.isAssetManifestArtifact
+        );
+        for (const asset of assetArtifacts) {
+          const manifest = AssetManifest.fromFile(asset.file);
+          await publishAssets2(manifest, this.sdkProvider, resolvedEnvironment, {
+            buildAssets: true,
+            quiet: options.quiet,
+            parallel: options.assetParallelism
+          });
+        }
         return deployStack({
           stack: options.stack,
           noMonitor: true,
@@ -2860,7 +2835,7 @@ var init_cloudformation_deployments = __esm({
         });
       }
       async destroyStack(options) {
-        const { stackSdk, cloudFormationRoleArn: roleArn } = await this.prepareSdkFor(options.stack, options.roleArn);
+        const { stackSdk, cloudFormationRoleArn: roleArn } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
         return destroyStack({
           sdk: stackSdk,
           roleArn,
@@ -2884,10 +2859,7 @@ var init_cloudformation_deployments = __esm({
       }
       async prepareSdkWithLookupOrDeployRole(stackArtifact) {
         try {
-          const result = await prepareSdkWithLookupRoleFor(
-            this.sdkProvider,
-            stackArtifact
-          );
+          const result = await this.prepareSdkWithLookupRoleFor(stackArtifact);
           if (result.didAssumeRole) {
             return {
               resolvedEnvironment: result.resolvedEnvironment,
@@ -2898,7 +2870,7 @@ var init_cloudformation_deployments = __esm({
         }
         return this.prepareSdkFor(stackArtifact, void 0, Mode.ForReading);
       }
-      async prepareSdkFor(stack, roleArn, mode = Mode.ForWriting) {
+      async prepareSdkFor(stack, roleArn, mode) {
         if (!stack.environment) {
           throw new Error(
             `The stack ${stack.displayName} does not have an environment`
@@ -2915,7 +2887,7 @@ var init_cloudformation_deployments = __esm({
           resolvedEnvironment,
           this.sdkProvider
         );
-        const stackSdk = await this.sdkProvider.forEnvironment(
+        const stackSdk = await this.cachedSdkForEnvironment(
           resolvedEnvironment,
           mode,
           {
@@ -2929,12 +2901,72 @@ var init_cloudformation_deployments = __esm({
           cloudFormationRoleArn: arns.cloudFormationRoleArn
         };
       }
-      async buildStackAssets(options) {
+      async prepareSdkWithLookupRoleFor(stack) {
+        const resolvedEnvironment = await this.sdkProvider.resolveEnvironment(
+          stack.environment
+        );
+        const arns = await replaceEnvPlaceholders(
+          {
+            lookupRoleArn: stack.lookupRole?.arn
+          },
+          resolvedEnvironment,
+          this.sdkProvider
+        );
+        const warningMessage = `Could not assume ${arns.lookupRoleArn}, proceeding anyway.`;
+        const upgradeMessage = `(To get rid of this warning, please upgrade to bootstrap version >= ${stack.lookupRole?.requiresBootstrapStackVersion})`;
+        try {
+          const stackSdk = await this.cachedSdkForEnvironment(
+            resolvedEnvironment,
+            Mode.ForReading,
+            {
+              assumeRoleArn: arns.lookupRoleArn,
+              assumeRoleExternalId: stack.lookupRole?.assumeRoleExternalId
+            }
+          );
+          if (stackSdk.didAssumeRole && stack.lookupRole?.bootstrapStackVersionSsmParameter && stack.lookupRole.requiresBootstrapStackVersion) {
+            const version2 = await ToolkitInfo.versionFromSsmParameter(
+              stackSdk.sdk,
+              stack.lookupRole.bootstrapStackVersionSsmParameter
+            );
+            if (version2 < stack.lookupRole.requiresBootstrapStackVersion) {
+              throw new Error(
+                `Bootstrap stack version '${stack.lookupRole.requiresBootstrapStackVersion}' is required, found version '${version2}'.`
+              );
+            }
+          } else if (!stackSdk.didAssumeRole && stack.lookupRole?.requiresBootstrapStackVersion) {
+            warning(upgradeMessage);
+          }
+          return { ...stackSdk, resolvedEnvironment };
+        } catch (e) {
+          debug2(e);
+          if (stack.lookupRole && stack.lookupRole.requiresBootstrapStackVersion) {
+            warning(warningMessage);
+            warning(upgradeMessage);
+          }
+          throw e;
+        }
+      }
+      async lookupToolkit(resolvedEnvironment, sdk, toolkitStackName) {
+        const key = `${resolvedEnvironment.account}:${resolvedEnvironment.region}:${toolkitStackName}`;
+        const existing = this.toolkitInfoCache.get(key);
+        if (existing) {
+          return existing;
+        }
+        const ret = await ToolkitInfo.lookup(
+          resolvedEnvironment,
+          sdk,
+          toolkitStackName
+        );
+        this.toolkitInfoCache.set(key, ret);
+        return ret;
+      }
+      async prepareAndValidateAssets(asset, options) {
         const { stackSdk, resolvedEnvironment } = await this.prepareSdkFor(
           options.stack,
-          options.roleArn
+          options.roleArn,
+          Mode.ForWriting
         );
-        const toolkitInfo = await ToolkitInfo.lookup(
+        const toolkitInfo = await this.lookupToolkit(
           resolvedEnvironment,
           stackSdk,
           options.toolkitStackName
@@ -2942,45 +2974,84 @@ var init_cloudformation_deployments = __esm({
         const stackEnv = await this.sdkProvider.resolveEnvironment(
           options.stack.environment
         );
-        const assetArtifacts = options.stack.dependencies.filter(
-          cxapi2.AssetManifestArtifact.isAssetManifestArtifact
+        await this.validateBootstrapStackVersion(
+          options.stack.stackName,
+          asset.requiresBootstrapStackVersion,
+          asset.bootstrapStackVersionSsmParameter,
+          toolkitInfo
         );
-        for (const assetArtifact of assetArtifacts) {
-          await this.validateBootstrapStackVersion(
-            options.stack.stackName,
-            assetArtifact.requiresBootstrapStackVersion,
-            assetArtifact.bootstrapStackVersionSsmParameter,
-            toolkitInfo
-          );
-          const manifest = AssetManifest.fromFile(assetArtifact.file);
-          await buildAssets(
-            manifest,
-            this.sdkProvider,
-            stackEnv,
-            options.buildOptions
-          );
-        }
+        const manifest = AssetManifest.fromFile(asset.file);
+        return { manifest, stackEnv };
       }
-      async publishStackAssets(stack, toolkitInfo, options = {}) {
-        const stackEnv = await this.sdkProvider.resolveEnvironment(
-          stack.environment
+      async buildAssets(asset, options) {
+        const { manifest, stackEnv } = await this.prepareAndValidateAssets(
+          asset,
+          options
         );
-        const assetArtifacts = stack.dependencies.filter(
-          cxapi2.AssetManifestArtifact.isAssetManifestArtifact
+        await buildAssets(
+          manifest,
+          this.sdkProvider,
+          stackEnv,
+          options.buildOptions
         );
-        for (const assetArtifact of assetArtifacts) {
-          await this.validateBootstrapStackVersion(
-            stack.stackName,
-            assetArtifact.requiresBootstrapStackVersion,
-            assetArtifact.bootstrapStackVersionSsmParameter,
-            toolkitInfo
-          );
-          const manifest = AssetManifest.fromFile(assetArtifact.file);
-          await publishAssets2(manifest, this.sdkProvider, stackEnv, {
-            ...options.publishOptions,
-            buildAssets: options.buildAssets ?? true
-          });
-        }
+      }
+      async publishAssets(asset, options) {
+        const { manifest, stackEnv } = await this.prepareAndValidateAssets(
+          asset,
+          options
+        );
+        await publishAssets2(
+          manifest,
+          this.sdkProvider,
+          stackEnv,
+          options.publishOptions
+        );
+      }
+      async buildSingleAsset(assetArtifact, assetManifest, asset, options) {
+        const { stackSdk, resolvedEnvironment: stackEnv } = await this.prepareSdkFor(options.stack, options.roleArn, Mode.ForWriting);
+        const toolkitInfo = await this.lookupToolkit(
+          stackEnv,
+          stackSdk,
+          options.toolkitStackName
+        );
+        await this.validateBootstrapStackVersion(
+          options.stack.stackName,
+          assetArtifact.requiresBootstrapStackVersion,
+          assetArtifact.bootstrapStackVersionSsmParameter,
+          toolkitInfo
+        );
+        const publisher = this.cachedPublisher(
+          assetManifest,
+          stackEnv,
+          options.stackName
+        );
+        await publisher.buildEntry(asset);
+      }
+      async publishSingleAsset(assetManifest, asset, options) {
+        const { resolvedEnvironment: stackEnv } = await this.prepareSdkFor(
+          options.stack,
+          options.roleArn,
+          Mode.ForWriting
+        );
+        const publisher = this.cachedPublisher(
+          assetManifest,
+          stackEnv,
+          options.stackName
+        );
+        await publisher.publishEntry(asset);
+      }
+      async isSingleAssetPublished(assetManifest, asset, options) {
+        const { resolvedEnvironment: stackEnv } = await this.prepareSdkFor(
+          options.stack,
+          options.roleArn,
+          Mode.ForWriting
+        );
+        const publisher = this.cachedPublisher(
+          assetManifest,
+          stackEnv,
+          options.stackName
+        );
+        return publisher.isEntryPublished(asset);
       }
       async validateBootstrapStackVersion(stackName, requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter, toolkitInfo) {
         if (requiresBootstrapStackVersion === void 0) {
@@ -2995,21 +3066,72 @@ var init_cloudformation_deployments = __esm({
           throw new Error(`${stackName}: ${e.message}`);
         }
       }
+      async cachedSdkForEnvironment(environment, mode, options) {
+        const cacheKey = [
+          environment.account,
+          environment.region,
+          `${mode}`,
+          options?.assumeRoleArn ?? "",
+          options?.assumeRoleExternalId ?? ""
+        ].join(":");
+        const existing = this.sdkCache.get(cacheKey);
+        if (existing) {
+          return existing;
+        }
+        const ret = await this.sdkProvider.forEnvironment(
+          environment,
+          mode,
+          options
+        );
+        this.sdkCache.set(cacheKey, ret);
+        return ret;
+      }
+      cachedPublisher(assetManifest, env, stackName) {
+        const existing = this.publisherCache.get(assetManifest);
+        if (existing) {
+          return existing;
+        }
+        const prefix = stackName ? `${stackName}: ` : "";
+        const publisher = new cdk_assets.AssetPublishing(assetManifest, {
+          aws: new PublishingAws(this.sdkProvider, env),
+          progressListener: new ParallelSafeAssetProgress(
+            prefix,
+            this.props.quiet ?? false
+          )
+        });
+        this.publisherCache.set(assetManifest, publisher);
+        return publisher;
+      }
+    };
+    ParallelSafeAssetProgress = class {
+      constructor(prefix, quiet) {
+        this.prefix = prefix;
+        this.quiet = quiet;
+      }
+      onPublishEvent(type, event) {
+        const handler = this.quiet && type !== "fail" ? debug2 : EVENT_TO_LOGGER[type];
+        handler(`${this.prefix} ${type}: ${event.message}`);
+      }
+    };
+    CloudFormationDeployments = class extends Deployments {
     };
   }
 });
 
-// src/cdk/cloudformation-deployments-wrapper.ts
-var cloudformation_deployments_wrapper_exports = {};
-__export(cloudformation_deployments_wrapper_exports, {
+// src/cdk/deployments-wrapper.ts
+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 {
   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 { 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";
@@ -3022,13 +3144,17 @@ async function publishDeployAssets(sdkProvider, options) {
     resolvedEnvironment,
     cloudFormationRoleArn
   } = await useDeployment().get(sdkProvider, options);
-  await deployment.publishStackAssets(options.stack, toolkitInfo, {
-    buildAssets: options.buildAssets ?? true,
-    publishOptions: {
+  const assetArtifacts = options.stack.dependencies.filter(
+    cxapi3.AssetManifestArtifact.isAssetManifestArtifact
+  );
+  for (const asset of assetArtifacts) {
+    const manifest = AssetManifest2.fromFile(asset.file);
+    await publishAssets3(manifest, sdkProvider, resolvedEnvironment, {
+      buildAssets: true,
       quiet: options.quiet,
       parallel: options.assetParallelism
-    }
-  });
+    });
+  }
   return deployStack2({
     stack: options.stack,
     noMonitor: true,
@@ -3124,10 +3250,10 @@ async function deployStack2(options) {
   };
 }
 var useDeployment;
-var init_cloudformation_deployments_wrapper = __esm({
-  "src/cdk/cloudformation-deployments-wrapper.ts"() {
+var init_deployments_wrapper = __esm({
+  "src/cdk/deployments-wrapper.ts"() {
     "use strict";
-    init_cloudformation_deployments();
+    init_deployments();
     init_deploy_stack();
     init_context();
     useDeployment = Context.memo(() => {
@@ -3136,8 +3262,12 @@ var init_cloudformation_deployments_wrapper = __esm({
         async get(sdkProvider, options) {
           const region = options.stack.environment.region;
           if (!state2.has(region)) {
-            const deployment = new CloudFormationDeployments({ sdkProvider });
-            const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await deployment.prepareSdkFor(options.stack, options.roleArn);
+            const deployment = new Deployments({ sdkProvider });
+            const { stackSdk, resolvedEnvironment, cloudFormationRoleArn } = await deployment.prepareSdkFor(
+              options.stack,
+              options.roleArn,
+              Mode2.ForWriting
+            );
             const toolkitInfo = await ToolkitInfo2.lookup(
               resolvedEnvironment,
               stackSdk,
@@ -3168,7 +3298,7 @@ var init_cloudformation_deployments_wrapper = __esm({
 async function publishAssets4(stacks) {
   Logger.debug("Publishing assets");
   const provider = await useAWSProvider();
-  const { publishDeployAssets: publishDeployAssets2 } = await Promise.resolve().then(() => (init_cloudformation_deployments_wrapper(), cloudformation_deployments_wrapper_exports));
+  const { publishDeployAssets: publishDeployAssets2 } = await Promise.resolve().then(() => (init_deployments_wrapper(), deployments_wrapper_exports));
   const results = {};
   for (const stack of stacks) {
     const result = await publishDeployAssets2(provider, {
@@ -3239,10 +3369,8 @@ async function deploy(stack) {
   const bus = useBus();
   Logger.debug("Deploying stack", stack.id);
   const provider = await useAWSProvider();
-  const { CloudFormationDeployments: CloudFormationDeployments2 } = await Promise.resolve().then(() => (init_cloudformation_deployments(), cloudformation_deployments_exports));
-  const deployment = new CloudFormationDeployments2({
-    sdkProvider: provider
-  });
+  const { Deployments: Deployments2 } = await Promise.resolve().then(() => (init_deployments(), deployments_exports));
+  const deployment = new Deployments2({ sdkProvider: provider });
   const stackTags = Object.entries(stack.tags ?? {}).map(([Key, Value]) => ({
     Key,
     Value
@@ -5023,6 +5151,7 @@ async function synth(opts) {
         region: project.config.region,
         mode: opts.mode,
         debugIncreaseTimeout: opts.increaseTimeout,
+        debugScriptVersion: opts.scriptVersion,
         isActiveStack: opts.isActiveStack
       },
       {
@@ -7012,6 +7141,7 @@ var dev = (program2) => program2.command(
     const useStackBuilder = Context2.memo(async () => {
       const watcher = useWatcher2();
       const project = useProject2();
+      const scriptVersion = Date.now().toString();
       let lastDeployed;
       let isWorking = false;
       let isDirty = false;
@@ -7035,6 +7165,7 @@ var dev = (program2) => program2.command(
           project.stacks = sstConfig.stacks;
           const assembly = await Stacks.synth({
             increaseTimeout: args["increase-timeout"],
+            scriptVersion,
             fn: project.stacks,
             outDir: `.sst/cdk.out`,
             mode: "dev"

package/stacks/deploy.js

@@ -6,7 +6,7 @@ import { VisibleError } from "../error.js";
 export async function publishAssets(stacks) {
     Logger.debug("Publishing assets");
     const provider = await useAWSProvider();
-    const { publishDeployAssets } = await import("../cdk/cloudformation-deployments-wrapper.js");
+    const { publishDeployAssets } = await import("../cdk/deployments-wrapper.js");
     const results = {};
     for (const stack of stacks) {
         const result = await publishDeployAssets(provider, {
@@ -74,10 +74,8 @@ export async function deploy(stack) {
     const bus = useBus();
     Logger.debug("Deploying stack", stack.id);
     const provider = await useAWSProvider();
-    const { CloudFormationDeployments } = await import("../cdk/cloudformation-deployments.js");
-    const deployment = new CloudFormationDeployments({
-        sdkProvider: provider,
-    });
+    const { Deployments } = await import("../cdk/deployments.js");
+    const deployment = new Deployments({ sdkProvider: provider });
     const stackTags = Object.entries(stack.tags ?? {}).map(([Key, Value]) => ({
         Key,
         Value,

package/stacks/synth.d.ts

@@ -3,6 +3,7 @@ interface SynthOptions {
     buildDir?: string;
     outDir?: string;
     increaseTimeout?: boolean;
+    scriptVersion?: string;
     mode: App["mode"];
     fn: (app: App) => Promise<void> | void;
     isActiveStack?: (stackName: string) => boolean;

package/stacks/synth.js

@@ -46,6 +46,7 @@ export async function synth(opts) {
             region: project.config.region,
             mode: opts.mode,
             debugIncreaseTimeout: opts.increaseTimeout,
+            debugScriptVersion: opts.scriptVersion,
             isActiveStack: opts.isActiveStack,
         }, {
             outdir: opts.buildDir,