sst 2.19.2 → 2.20.0

package/sst.mjs

@@ -26,6 +26,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -123,7 +127,7 @@ var init_logger = __esm({
     "use strict";
     init_context();
     init_project();
-    previous = new Date();
+    previous = /* @__PURE__ */ new Date();
     useFile = Context.memo(async () => {
       const project = useProject();
       const filePath = path.join(project.paths.out, "debug.log");
@@ -132,11 +136,11 @@ var init_logger = __esm({
     });
     Logger = {
       debug(...parts) {
-        const now = new Date();
+        const now = /* @__PURE__ */ new Date();
         const diff3 = now.getTime() - previous.getTime();
         previous = now;
         const line = [
-          new Date().toISOString(),
+          (/* @__PURE__ */ new Date()).toISOString(),
           `+${diff3}ms`.padStart(8),
           "[debug]",
           ...parts.map((x) => {
@@ -315,6 +319,14 @@ async function load(input, shallow) {
           `const require = topLevelCreateRequire(import.meta.url);`
         ].join("")
       },
+      // The entry can have any file name (ie. "stacks/anything.ts"). We want the
+      // build output to be always named "lib/index.js". This allow us to always
+      // import from "buildDir" without needing to pass "anything" around.
+      //  stdin: {
+      //    contents,
+      //    loader: "ts",
+      //    resolveDir: path.dirname(input),
+      //  },
       entryPoints: [input]
     });
     const mod = await dynamicImport(outfile);
@@ -648,13 +660,16 @@ function getEnvironmentData() {
   const cpus = os2.cpus() || [];
   const ciInfo2 = getCiInfo();
   data = {
+    // Software information
     systemPlatform: os2.platform(),
     systemRelease: os2.release(),
     systemArchitecture: os2.arch(),
+    // Machine information
     cpuCount: cpus.length,
     cpuModel: cpus.length ? cpus[0].model : null,
     cpuSpeed: cpus.length ? cpus[0].speed : null,
     memoryInMb: Math.trunc(os2.totalmem() / Math.pow(1024, 2)),
+    // Environment information
     isCI: ciInfo2.isCI,
     ciName: ciInfo2.name,
     sstVersion: useProject().version
@@ -847,9 +862,10 @@ var init_spinner = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/tslib@2.5.0/node_modules/tslib/tslib.es6.js
+// ../../node_modules/.pnpm/tslib@2.6.0/node_modules/tslib/tslib.es6.mjs
 var tslib_es6_exports = {};
 __export(tslib_es6_exports, {
+  __addDisposableResource: () => __addDisposableResource,
   __assign: () => __assign,
   __asyncDelegator: () => __asyncDelegator,
   __asyncGenerator: () => __asyncGenerator,
@@ -861,6 +877,7 @@ __export(tslib_es6_exports, {
   __classPrivateFieldSet: () => __classPrivateFieldSet,
   __createBinding: () => __createBinding,
   __decorate: () => __decorate,
+  __disposeResources: () => __disposeResources,
   __esDecorate: () => __esDecorate,
   __exportStar: () => __exportStar,
   __extends: () => __extends,
@@ -878,7 +895,8 @@ __export(tslib_es6_exports, {
   __spread: () => __spread,
   __spreadArray: () => __spreadArray,
   __spreadArrays: () => __spreadArrays,
-  __values: () => __values
+  __values: () => __values,
+  default: () => tslib_es6_default
 });
 function __extends(d, b) {
   if (typeof b !== "function" && b !== null)
@@ -948,10 +966,10 @@ function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, e
       if (_ = accept(result.set))
         descriptor.set = _;
       if (_ = accept(result.init))
-        initializers.push(_);
+        initializers.unshift(_);
     } else if (_ = accept(result)) {
       if (kind === "field")
-        initializers.push(_);
+        initializers.unshift(_);
       else
         descriptor[key] = _;
     }
@@ -1262,9 +1280,56 @@ function __classPrivateFieldIn(state2, receiver) {
     throw new TypeError("Cannot use 'in' operator on non-object");
   return typeof state2 === "function" ? receiver === state2 : state2.has(receiver);
 }
-var extendStatics, __assign, __createBinding, __setModuleDefault;
+function __addDisposableResource(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object")
+      throw new TypeError("Object expected.");
+    var dispose;
+    if (async) {
+      if (!Symbol.asyncDispose)
+        throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose)
+        throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+    }
+    if (typeof dispose !== "function")
+      throw new TypeError("Object not disposable.");
+    env.stack.push({ value, dispose, async });
+  } else if (async) {
+    env.stack.push({ async: true });
+  }
+  return value;
+}
+function __disposeResources(env) {
+  function fail(e) {
+    env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+    env.hasError = true;
+  }
+  function next() {
+    while (env.stack.length) {
+      var rec = env.stack.pop();
+      try {
+        var result = rec.dispose && rec.dispose.call(rec.value);
+        if (rec.async)
+          return Promise.resolve(result).then(next, function(e) {
+            fail(e);
+            return next();
+          });
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (env.hasError)
+      throw env.error;
+  }
+  return next();
+}
+var extendStatics, __assign, __createBinding, __setModuleDefault, _SuppressedError, tslib_es6_default;
 var init_tslib_es6 = __esm({
-  "../../node_modules/.pnpm/tslib@2.5.0/node_modules/tslib/tslib.es6.js"() {
+  "../../node_modules/.pnpm/tslib@2.6.0/node_modules/tslib/tslib.es6.mjs"() {
     extendStatics = function(d, b) {
       extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
         d2.__proto__ = b2;
@@ -1307,6 +1372,39 @@ var init_tslib_es6 = __esm({
     } : function(o, v) {
       o["default"] = v;
     };
+    _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error3, suppressed, message) {
+      var e = new Error(message);
+      return e.name = "SuppressedError", e.error = error3, e.suppressed = suppressed, e;
+    };
+    tslib_es6_default = {
+      __extends,
+      __assign,
+      __rest,
+      __decorate,
+      __param,
+      __metadata,
+      __awaiter,
+      __generator,
+      __createBinding,
+      __exportStar,
+      __values,
+      __read,
+      __spread,
+      __spreadArrays,
+      __spreadArray,
+      __await,
+      __asyncGenerator,
+      __asyncDelegator,
+      __asyncValues,
+      __makeTemplateObject,
+      __importStar,
+      __importDefault,
+      __classPrivateFieldGet,
+      __classPrivateFieldSet,
+      __classPrivateFieldIn,
+      __addDisposableResource,
+      __disposeResources
+    };
   }
 });
 
@@ -1682,6 +1780,9 @@ function useAWSClient(client, force = false) {
       delayDecider: (_, attempts) => {
         return Math.min(1.5 ** attempts * 100, 5e3);
       },
+      // AWS SDK v3 has an idea of "retry tokens" which are used to
+      // prevent multiple retries from happening at the same time.
+      // This is a workaround to disable that.
       retryQuota: {
         hasRetryTokens: () => true,
         releaseRetryTokens: () => {
@@ -2018,7 +2119,8 @@ async function monitor(stack) {
                 "Resource update cancelled"
               ) || event.ResourceStatusReason.includes(
                 "Resource creation Initiated"
-              ) || event.ResourceStatusReason.startsWith(
+              ) || // ie. The following resource(s) failed to update: [MyResource10A5921D].
+              event.ResourceStatusReason.startsWith(
                 "The following resource(s) failed to"
               ))
                 continue;
@@ -2040,7 +2142,8 @@ async function monitor(stack) {
           "Resource update cancelled"
         ) || resource.ResourceStatusReason?.includes(
           "Resource creation Initiated"
-        ) || resource.ResourceStatusReason?.startsWith(
+        ) || // ie. The following resource(s) failed to update: [MyResource10A5921D].
+        resource.ResourceStatusReason?.startsWith(
           "The following resource(s) failed to"
         ))
           continue;
@@ -2163,6 +2266,9 @@ var init_docker = __esm({
         this.logger = logger;
       }
       configDir = void 0;
+      /**
+       * Whether an image with the given tag exists
+       */
       async exists(tag) {
         try {
           await this.execute(["inspect", tag], { quiet: true });
@@ -2214,9 +2320,13 @@ var init_docker = __esm({
         ];
         await this.execute(buildCommand, {
           cwd: options.directory,
+          // TODO: remove after PR is merged
           quiet: options.quiet
         });
       }
+      /**
+       * Get credentials from ECR and run docker login
+       */
       async login(ecr) {
         const credentials = await obtainEcrCredentials(ecr);
         await this.execute(
@@ -2229,6 +2339,9 @@ var init_docker = __esm({
           ],
           {
             input: credentials.password,
+            // Need to quiet otherwise Docker will complain
+            // 'WARNING! Your password will be stored unencrypted'
+            // doesn't really matter since it's a token.
             quiet: true
           }
         );
@@ -2236,9 +2349,19 @@ var init_docker = __esm({
       async tag(sourceTag, targetTag) {
         await this.execute(["tag", sourceTag, targetTag]);
       }
+      // TODO: remove after PR is merged
       async push(options) {
         await this.execute(["push", options.tag], { quiet: options.quiet });
       }
+      /**
+       * If a CDK Docker Credentials file exists, creates a new Docker config directory.
+       * Sets up `docker-credential-cdk-assets` to be the credential helper for each domain in the CDK config.
+       * All future commands (e.g., `build`, `push`) will use this config.
+       *
+       * See https://docs.docker.com/engine/reference/commandline/login/#credential-helpers for more details on cred helpers.
+       *
+       * @returns true if CDK config was found and configured, false otherwise
+       */
       configureCdkCredentials() {
         const config = cdkCredentialsConfig();
         if (!config) {
@@ -2260,6 +2383,12 @@ var init_docker = __esm({
         );
         return true;
       }
+      /**
+       * Removes any configured Docker config directory.
+       * All future commands (e.g., `build`, `push`) will use the default config.
+       *
+       * This is useful after calling `configureCdkCredentials` to reset to default credentials.
+       */
       resetAuthPlugins() {
         this.configDir = void 0;
       }
@@ -2296,6 +2425,9 @@ var init_docker = __esm({
     DockerFactory = class {
       enterLoggedInDestinationsCriticalSection = createCriticalSection();
       loggedInDestinations = /* @__PURE__ */ new Set();
+      /**
+       * Gets a Docker instance for building images.
+       */
       async forBuild(options) {
         const docker = new Docker(options.logger);
         let cdkDockerCredentialsConfigured = docker.configureCdkCredentials();
@@ -2304,6 +2436,9 @@ var init_docker = __esm({
         }
         return docker;
       }
+      /**
+       * Gets a Docker instance for pushing images to ECR.
+       */
       async forEcrPush(options) {
         const docker = new Docker(options.logger);
         await this.loginOncePerDestination(docker, options);
@@ -2380,6 +2515,7 @@ var init_container_images = __esm({
           this.workDir,
           this.asset,
           this.host,
+          // TODO: remove after PR is merged
           {
             quiet: this.options.quiet
           }
@@ -2456,6 +2592,13 @@ var init_container_images = __esm({
         };
         return this.init;
       }
+      /**
+       * Check whether the image already exists in the ECR repo
+       *
+       * Use the fields from the destination to do the actual check. The imageUri
+       * should correspond to that, but is only used to print Docker image location
+       * for user benefit (the format is slightly different).
+       */
       async destinationAlreadyExists(ecr, destination, imageUri) {
         this.host.emitMessage(EventType.CHECK, `Check ${imageUri}`);
         if (await imageExists(ecr, destination.repositoryName, destination.imageTag)) {
@@ -2476,6 +2619,12 @@ var init_container_images = __esm({
       async build() {
         return this.asset.source.executable ? this.buildExternalAsset(this.asset.source.executable) : this.buildDirectoryAsset();
       }
+      /**
+       * Build a (local) Docker asset from a directory with a Dockerfile
+       *
+       * Tags under a deterministic, unique, local identifier wich will skip
+       * the build if it already exists.
+       */
       async buildDirectoryAsset() {
         const localTagName = `cdkasset-${this.asset.id.assetId.toLowerCase()}`;
         if (!await this.isImageCached(localTagName)) {
@@ -2486,6 +2635,12 @@ var init_container_images = __esm({
         }
         return localTagName;
       }
+      /**
+       * Build a (local) Docker asset by running an external command
+       *
+       * External command is responsible for deduplicating the build if possible,
+       * and is expected to return the generated image identifier on stdout.
+       */
       async buildExternalAsset(executable, cwd) {
         const assetPath = cwd ?? this.workDir;
         this.host.emitMessage(
@@ -2523,6 +2678,7 @@ var init_container_images = __esm({
           outputs: source.dockerOutputs,
           cacheFrom: source.cacheFrom,
           cacheTo: source.cacheTo,
+          // TODO: remove after PR is merged
           quiet: this.options.quiet
         });
       }
@@ -2552,6 +2708,7 @@ function makeAssetHandler(manifest, asset, host, options) {
       manifest.directory,
       asset,
       host,
+      // TODO: remove after PR is merged
       options
     );
   }
@@ -2595,7 +2752,13 @@ var init_publishing = __esm({
           dockerFactory: new DockerFactory()
         };
       }
+      /**
+       * The message for the IPublishProgress interface
+       */
       message = "Starting";
+      /**
+       * The current asset for the IPublishProgress interface
+       */
       currentAsset;
       failures = new Array();
       assets;
@@ -2607,6 +2770,9 @@ var init_publishing = __esm({
       buildAssets;
       publishAssets;
       handlerCache = /* @__PURE__ */ new Map();
+      /**
+       * Publish all assets from the manifest
+       */
       async publish() {
         if (this.publishInParallel) {
           await Promise.all(
@@ -2625,6 +2791,9 @@ var init_publishing = __esm({
           );
         }
       }
+      /**
+       * Build a single asset from the manifest
+       */
       async buildEntry(asset) {
         try {
           if (this.progressEvent(EventType2.START, `Building ${asset.id}`)) {
@@ -2648,6 +2817,9 @@ var init_publishing = __esm({
         }
         return true;
       }
+      /**
+       * Publish a single asset from the manifest
+       */
       async publishEntry(asset) {
         try {
           if (this.progressEvent(EventType2.START, `Publishing ${asset.id}`)) {
@@ -2671,10 +2843,18 @@ var init_publishing = __esm({
         }
         return true;
       }
+      /**
+       * Return whether a single asset is published
+       */
       isEntryPublished(asset) {
         const handler = this.assetHandler(asset);
         return handler.isPublished();
       }
+      /**
+       * publish an asset (used by 'publish()')
+       * @param asset The asset to publish
+       * @returns false when publishing should stop
+       */
       async publishAsset(asset) {
         try {
           if (this.progressEvent(EventType2.START, `Publishing ${asset.id}`)) {
@@ -2715,6 +2895,11 @@ var init_publishing = __esm({
       get hasFailures() {
         return this.failures.length > 0;
       }
+      /**
+       * Publish a progress event to the listener, if present.
+       *
+       * Returns whether an abort is requested. Helper to get rid of repetitive code in publish().
+       */
       progressEvent(event, message) {
         this.message = message;
         if (this.options.progressListener) {
@@ -2728,6 +2913,7 @@ var init_publishing = __esm({
           return existing;
         }
         const ret = makeAssetHandler(this.manifest, asset, this.handlerHost, {
+          // TODO: remove after PR is merged
           quiet: this.options.quiet
         });
         this.handlerCache.set(asset, ret);
@@ -2757,6 +2943,7 @@ async function publishAssets(manifest, sdk, targetEnv, options = {}) {
     publishInParallel: options.parallel ?? true,
     buildAssets: options.buildAssets ?? true,
     publishAssets: true,
+    // TODO: remove after PR is merged
     quiet: options.quiet
   });
   await publisher.publish();
@@ -2829,13 +3016,18 @@ var init_asset_publishing = __esm({
       async secretsManagerClient(options) {
         return (await this.sdk(options)).secretsManager();
       }
+      /**
+       * Get an SDK appropriate for the given client options
+       */
       async sdk(options) {
         const env = {
           ...this.targetEnv,
           region: options.region ?? this.targetEnv.region
+          // Default: same region as the stack
         };
         const cacheKey = JSON.stringify({
           env,
+          // region, name, account
           assumeRuleArn: options.assumeRoleArn,
           assumeRoleExternalId: options.assumeRoleExternalId,
           quiet: options.quiet
@@ -3119,7 +3311,10 @@ async function destroyStack(options) {
       );
     }
   } catch (e) {
-    throw new Error(suffixWithErrors(e.message));
+    throw new Error(suffixWithErrors(
+      e.message
+      /* , monitor?.errors */
+    ));
   } finally {
   }
 }
@@ -3354,7 +3549,7 @@ var init_deploy_stack = __esm({
         }
       }
       async directDeployment() {
-        const startTime = new Date();
+        const startTime = /* @__PURE__ */ new Date();
         if (this.update) {
           await this.cfn.updateStack({
             StackName: this.stackName,
@@ -3392,7 +3587,10 @@ var init_deploy_stack = __esm({
           }
           finalState = successStack;
         } catch (e) {
-          throw new Error(suffixWithErrors(e.message));
+          throw new Error(suffixWithErrors(
+            e.message
+            /*, monitor?.errors*/
+          ));
         } finally {
         }
         debug2("Stack %s has completed updating", this.stackName);
@@ -3402,6 +3600,9 @@ var init_deploy_stack = __esm({
           stackArn: finalState.stackId
         };
       }
+      /**
+       * Return the options that are shared between CreateStack, UpdateStack and CreateChangeSet
+       */
       commonPrepareOptions() {
         return {
           Capabilities: [
@@ -3417,6 +3618,12 @@ var init_deploy_stack = __esm({
           Tags: this.options.tags
         };
       }
+      /**
+       * Return the options that are shared between UpdateStack and CreateChangeSet
+       *
+       * Be careful not to add in keys for options that aren't used, as the features may not have been
+       * deployed everywhere yet.
+       */
       commonExecuteOptions() {
         const shouldDisableRollback = this.options.rollback === false;
         return {
@@ -3609,6 +3816,15 @@ var init_deployments = __esm({
         }
         return this.prepareSdkFor(stackArtifact, void 0, Mode2.ForReading);
       }
+      /**
+       * Get the environment necessary for touching the given stack
+       *
+       * Returns the following:
+       *
+       * - The resolved environment for the stack (no more 'unknown-account/unknown-region')
+       * - SDK loaded with the right credentials for calling `CreateChangeSet`.
+       * - The Execution Role that should be passed to CloudFormation.
+       */
       async prepareSdkFor(stack, roleArn, mode) {
         if (!stack.environment) {
           throw new Error(
@@ -3621,6 +3837,7 @@ var init_deployments = __esm({
         const arns = await replaceEnvPlaceholders(
           {
             assumeRoleArn: stack.assumeRoleArn,
+            // Use the override if given, otherwise use the field from the stack
             cloudFormationRoleArn: roleArn ?? stack.cloudFormationExecutionRoleArn
           },
           resolvedEnvironment,
@@ -3640,6 +3857,24 @@ var init_deployments = __esm({
           cloudFormationRoleArn: arns.cloudFormationRoleArn
         };
       }
+      /**
+       * Try to use the bootstrap lookupRole. There are two scenarios that are handled here
+       *  1. The lookup role may not exist (it was added in bootstrap stack version 7)
+       *  2. The lookup role may not have the correct permissions (ReadOnlyAccess was added in
+       *      bootstrap stack version 8)
+       *
+       * In the case of 1 (lookup role doesn't exist) `forEnvironment` will either:
+       *   1. Return the default credentials if the default credentials are for the stack account
+       *   2. Throw an error if the default credentials are not for the stack account.
+       *
+       * If we successfully assume the lookup role we then proceed to 2 and check whether the bootstrap
+       * stack version is valid. If it is not we throw an error which should be handled in the calling
+       * function (and fallback to use a different role, etc)
+       *
+       * If we do not successfully assume the lookup role, but do get back the default credentials
+       * then return those and note that we are returning the default credentials. The calling
+       * function can then decide to use them or fallback to another role.
+       */
       async prepareSdkWithLookupRoleFor(stack) {
         const resolvedEnvironment = await this.sdkProvider.resolveEnvironment(
           stack.environment
@@ -3685,6 +3920,9 @@ var init_deployments = __esm({
           throw e;
         }
       }
+      /**
+       * Look up the toolkit for a given environment, using a given SDK
+       */
       async lookupToolkit(resolvedEnvironment, sdk, toolkitStackName) {
         const key = `${resolvedEnvironment.account}:${resolvedEnvironment.region}:${toolkitStackName}`;
         const existing = this.toolkitInfoCache.get(key);
@@ -3722,6 +3960,11 @@ var init_deployments = __esm({
         const manifest = AssetManifest2.fromFile(asset.file);
         return { manifest, stackEnv };
       }
+      /**
+       * Build all assets in a manifest
+       *
+       * @deprecated Use `buildSingleAsset` instead
+       */
       async buildAssets(asset, options) {
         const { manifest, stackEnv } = await this.prepareAndValidateAssets(
           asset,
@@ -3734,6 +3977,11 @@ var init_deployments = __esm({
           options.buildOptions
         );
       }
+      /**
+       * Publish all assets in a manifest
+       *
+       * @deprecated Use `publishSingleAsset` instead
+       */
       async publishAssets(asset, options) {
         const { manifest, stackEnv } = await this.prepareAndValidateAssets(
           asset,
@@ -3746,6 +3994,10 @@ var init_deployments = __esm({
           options.publishOptions
         );
       }
+      /**
+       * Build a single asset from an asset manifest
+       */
+      // eslint-disable-next-line max-len
       async buildSingleAsset(assetArtifact, assetManifest, asset, options) {
         const { stackSdk, resolvedEnvironment: stackEnv } = await this.prepareSdkFor(options.stack, options.roleArn, Mode2.ForWriting);
         const toolkitInfo = await this.lookupToolkit(
@@ -3766,6 +4018,10 @@ var init_deployments = __esm({
         );
         await publisher.buildEntry(asset);
       }
+      /**
+       * Publish a single asset from an asset manifest
+       */
+      // eslint-disable-next-line max-len
       async publishSingleAsset(assetManifest, asset, options) {
         const { resolvedEnvironment: stackEnv } = await this.prepareSdkFor(
           options.stack,
@@ -3779,6 +4035,9 @@ var init_deployments = __esm({
         );
         await publisher.publishEntry(asset);
       }
+      /**
+       * Return whether a single asset has been published already
+       */
       async isSingleAssetPublished(assetManifest, asset, options) {
         const { resolvedEnvironment: stackEnv } = await this.prepareSdkFor(
           options.stack,
@@ -3792,6 +4051,9 @@ var init_deployments = __esm({
         );
         return publisher.isEntryPublished(asset);
       }
+      /**
+       * Validate that the bootstrap stack has the right version for this stack
+       */
       async validateBootstrapStackVersion(stackName, requiresBootstrapStackVersion, bootstrapStackVersionSsmParameter, toolkitInfo) {
         if (requiresBootstrapStackVersion === void 0) {
           return;
@@ -5037,10 +5299,16 @@ var init_dotnet = __esm({
                 FRAMEWORK_MAP[input.props.runtime],
                 "/p:GenerateRuntimeConfigurationFiles=true",
                 "/clp:ForceConsoleColor",
+                // warnings are not reported for repeated builds by default and this flag
+                // does a clean before build. It takes a little longer to run, but the
+                // warnings are consistently printed on each build.
+                //"/target:Rebuild",
                 "--self-contained",
                 "false",
+                // do not print "Build Engine version"
                 "-nologo"
               ].join(" "),
+              // only print errors
               {
                 cwd: srcPath
               }
@@ -5096,7 +5364,7 @@ var init_node = __esm({
           if (!result)
             return false;
           const relative = path10.relative(project.paths.root, input.file).split(path10.sep).join(path10.posix.sep);
-          return Boolean(result.metafile?.inputs[relative]);
+          return Boolean(result.last.metafile?.inputs[relative]);
         },
         canHandle: (input) => input.startsWith("nodejs"),
         startWorker: async (input) => {
@@ -5164,9 +5432,12 @@ var init_node = __esm({
             parsed.name + extension
           );
           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;
+          if (exists) {
+            const result = await exists.ctx.rebuild();
+            cache[input.functionID] = {
+              ctx: exists.ctx,
+              last: result
+            };
             return {
               type: "success",
               handler
@@ -5217,7 +5488,8 @@ var init_node = __esm({
             ...override
           };
           try {
-            const result = await esbuild2.build(options);
+            const ctx = await esbuild2.context(options);
+            const result = await ctx.rebuild();
             const installPackages = [
               ...nodejs.install || [],
               ...forceExternal.filter((pkg) => pkg !== "aws-sdk").filter((pkg) => !external?.includes(pkg)).filter(
@@ -5284,7 +5556,10 @@ var init_node = __esm({
               } catch {
               }
             }
-            cache[input.functionID] = result;
+            cache[input.functionID] = {
+              ctx,
+              last: result
+            };
             return {
               type: "success",
               handler
@@ -5711,7 +5986,8 @@ function bundle(options) {
   );
   const image = DockerImage.fromBuild(stagedir, {
     buildArgs: {
-      IMAGE: runtime.bundlingImage.image + (architecture == "arm_64" ? ":latest-arm64" : "")
+      IMAGE: runtime.bundlingImage.image + // the default x86_64 doesn't need to be set explicitly
+      (architecture == "arm_64" ? ":latest-arm64" : "")
     },
     file: dockerfile
   });
@@ -7482,6 +7758,7 @@ var init_kysely = __esm({
         });
         const dialect = db.engine.includes("postgres") ? new PostgresDialect() : new MysqlDialect();
         const instrospection = await dialect.introspector.introspect({
+          // @ts-ignore
           db: k
         });
         logger("introspected tables");
@@ -8350,7 +8627,9 @@ var bind = (program2) => program2.command(
           match: /solid-start|plugin-vue|plugin-react|@preact\/preset-vite/
         },
         { file: "package.json", match: /react-scripts/ },
+        // CRA
         { file: "index.html" }
+        // plain HTML
       ];
       const results = await Promise.all(
         SITE_CONFIGS.map((site) => {