sst 2.2.7 → 2.3.0

package/sst.mjs

@@ -177,6 +177,13 @@ var init_module = __esm({
 });
 
 // src/util/fs.ts
+var fs_exports = {};
+__export(fs_exports, {
+  existsAsync: () => existsAsync,
+  findAbove: () => findAbove,
+  findBelow: () => findBelow,
+  isChild: () => isChild
+});
 import fs2 from "fs/promises";
 import path2 from "path";
 async function findAbove(dir, target) {
@@ -746,65 +753,6 @@ var init_spinner = __esm({
   }
 });
 
-// src/site-env.ts
-var site_env_exports = {};
-__export(site_env_exports, {
-  SiteEnv: () => site_env_exports,
-  append: () => append,
-  keys: () => keys,
-  reset: () => reset2,
-  values: () => values,
-  valuesFile: () => valuesFile,
-  writeValues: () => writeValues
-});
-import fs5 from "fs";
-import path5 from "path";
-function keysFile() {
-  return path5.join(useProject().paths.out, "site-environment-keys.jsonl");
-}
-function valuesFile() {
-  return path5.join(useProject().paths.out, "site-environment-values.json");
-}
-async function keys() {
-  try {
-    const file = keysFile();
-    const data2 = await fs5.promises.readFile(file).then((x) => x.toString().split("\n"));
-    return data2.filter(Boolean).map((x) => JSON.parse(x));
-  } catch {
-    return [];
-  }
-}
-async function values() {
-  try {
-    const file = valuesFile();
-    const data2 = await fs5.promises.readFile(file).then((x) => JSON.parse(x.toString()));
-    return data2;
-  } catch {
-    return {};
-  }
-}
-async function writeValues(input) {
-  const file = valuesFile();
-  await fs5.promises.writeFile(file, JSON.stringify(input));
-}
-function append(input) {
-  input.path = path5.resolve(useProject().paths.root, input.path);
-  fs5.appendFileSync(keysFile(), JSON.stringify(input) + "\n");
-}
-function reset2() {
-  fs5.rmSync(keysFile(), {
-    force: true,
-    recursive: true
-  });
-}
-var init_site_env = __esm({
-  "src/site-env.ts"() {
-    "use strict";
-    init_site_env();
-    init_project();
-  }
-});
-
 // ../../node_modules/.pnpm/tslib@2.5.0/node_modules/tslib/tslib.es6.js
 var tslib_es6_exports = {};
 __export(tslib_es6_exports, {
@@ -1742,6 +1690,110 @@ var init_credentials = __esm({
   }
 });
 
+// src/stacks/app-metadata.ts
+import {
+  S3Client,
+  GetObjectCommand,
+  PutObjectCommand,
+  DeleteObjectCommand
+} from "@aws-sdk/client-s3";
+async function metadata() {
+  Logger.debug("Fetching app metadata");
+  const [project, credentials, bootstrap2] = await Promise.all([
+    useProject(),
+    useAWSCredentials(),
+    useBootstrap()
+  ]);
+  const s3 = new S3Client({
+    region: project.config.region,
+    credentials
+  });
+  try {
+    const result = await s3.send(
+      new GetObjectCommand({
+        Key: useS3Key(),
+        Bucket: bootstrap2.bucket
+      })
+    );
+    const body = await result.Body.transformToString();
+    return JSON.parse(body);
+  } catch (ex) {
+    Logger.debug("Fetching app metadata: not found");
+  }
+}
+async function saveAppMetadata(data2) {
+  Logger.debug("Saving app metadata");
+  const [project, credentials, bootstrap2] = await Promise.all([
+    useProject(),
+    useAWSCredentials(),
+    useBootstrap()
+  ]);
+  const s3 = new S3Client({
+    region: project.config.region,
+    credentials
+  });
+  try {
+    await s3.send(
+      new PutObjectCommand({
+        Key: useS3Key(),
+        Bucket: bootstrap2.bucket,
+        Body: JSON.stringify(data2)
+      })
+    );
+  } catch (ex) {
+    Logger.debug("Saving app metadata: not found");
+  }
+}
+async function clearAppMetadata() {
+  Logger.debug("Clearing app metadata");
+  const [project, credentials, bootstrap2] = await Promise.all([
+    useProject(),
+    useAWSCredentials(),
+    useBootstrap()
+  ]);
+  const s3 = new S3Client({
+    region: project.config.region,
+    credentials
+  });
+  await s3.send(
+    new DeleteObjectCommand({
+      Key: useS3Key(),
+      Bucket: bootstrap2.bucket
+    })
+  );
+}
+function useS3Key() {
+  const project = useProject();
+  return `appMetadata/app.${project.config.name}/stage.${project.config.stage}.json`;
+}
+var MetadataContext, useAppMetadata;
+var init_app_metadata = __esm({
+  "src/stacks/app-metadata.ts"() {
+    "use strict";
+    init_bootstrap();
+    init_credentials();
+    init_context();
+    init_logger();
+    init_project();
+    MetadataContext = Context.create(async () => {
+      const data2 = await metadata();
+      return data2;
+    });
+    useAppMetadata = MetadataContext.use;
+  }
+});
+
+// src/stacks/assembly.ts
+async function loadAssembly(from) {
+  const { CloudAssembly } = await import("aws-cdk-lib/cx-api");
+  return new CloudAssembly(from);
+}
+var init_assembly = __esm({
+  "src/stacks/assembly.ts"() {
+    "use strict";
+  }
+});
+
 // src/bus.ts
 var bus_exports = {};
 __export(bus_exports, {
@@ -1806,1282 +1858,366 @@ var init_bus = __esm({
   }
 });
 
-// src/cli/local/router.ts
-import * as trpc from "@trpc/server";
-var router2;
-var init_router = __esm({
-  "src/cli/local/router.ts"() {
-    "use strict";
-    init_project();
-    init_bus();
-    init_credentials();
-    router2 = trpc.router().query("getCredentials", {
-      async resolve({ ctx }) {
-        const project = useProject();
-        const credentials = await useAWSCredentials();
-        return {
-          region: project.config.region,
-          credentials: {
-            accessKeyId: credentials.accessKeyId,
-            secretAccessKey: credentials.secretAccessKey,
-            sessionToken: credentials.sessionToken
+// src/stacks/monitor.ts
+import {
+  CloudFormationClient,
+  DescribeStackResourcesCommand,
+  DescribeStacksCommand,
+  DescribeStackEventsCommand
+} from "@aws-sdk/client-cloudformation";
+import { map, omitBy, pipe } from "remeda";
+function isFinal(input) {
+  return STATUSES_SUCCESS.includes(input) || STATUSES_FAILED.includes(input);
+}
+function isFailed(input) {
+  return STATUSES_FAILED.includes(input);
+}
+function isSuccess(input) {
+  return STATUSES_SUCCESS.includes(input);
+}
+function isPending(input) {
+  return STATUSES_PENDING.includes(input);
+}
+async function monitor(stack) {
+  const [cfn, bus] = await Promise.all([
+    useAWSClient(CloudFormationClient),
+    useBus()
+  ]);
+  let lastStatus;
+  const errors = {};
+  let lastEvent;
+  while (true) {
+    try {
+      const [describe, resources, events] = await Promise.all([
+        cfn.send(
+          new DescribeStacksCommand({
+            StackName: stack
+          })
+        ),
+        cfn.send(
+          new DescribeStackResourcesCommand({
+            StackName: stack
+          })
+        ),
+        cfn.send(
+          new DescribeStackEventsCommand({
+            StackName: stack
+          })
+        )
+      ]);
+      Logger.debug("Stack description", describe);
+      if (lastEvent) {
+        const eventsReversed = [...events.StackEvents ?? []].reverse();
+        for (const event of eventsReversed) {
+          if (!event.Timestamp)
+            continue;
+          if (event.Timestamp.getTime() > lastEvent.getTime()) {
+            bus.publish("stack.event", {
+              event,
+              stackID: stack
+            });
+            if (event.ResourceStatusReason) {
+              if (event.ResourceStatusReason.includes(
+                "Resource creation cancelled"
+              ) || event.ResourceStatusReason.includes(
+                "Resource update cancelled"
+              ) || event.ResourceStatusReason.includes(
+                "Resource creation Initiated"
+              ) || event.ResourceStatusReason.startsWith(
+                "The following resource(s) failed to"
+              ))
+                continue;
+              errors[event.LogicalResourceId] = event.ResourceStatusReason;
+            }
           }
-        };
-      }
-    }).query("getState", {
-      async resolve({ ctx }) {
-        return ctx.state;
+        }
+        Logger.debug("Last event set to", lastEvent);
       }
-    }).mutation("deploy", {
-      async resolve() {
-        return;
+      lastEvent = events.StackEvents?.at(0)?.Timestamp;
+      bus.publish("stack.resources", {
+        stackID: stack,
+        resources: resources.StackResources
+      });
+      for (const resource of resources.StackResources || []) {
+        if (resource.ResourceStatusReason?.includes(
+          "Resource creation cancelled"
+        ) || resource.ResourceStatusReason?.includes(
+          "Resource update cancelled"
+        ) || resource.ResourceStatusReason?.includes(
+          "Resource creation Initiated"
+        ) || resource.ResourceStatusReason?.startsWith(
+          "The following resource(s) failed to"
+        ))
+          continue;
+        if (resource.ResourceStatusReason)
+          errors[resource.LogicalResourceId] = resource.ResourceStatusReason;
       }
-    }).subscription("onStateChange", {
-      async resolve({ ctx }) {
-        const bus = useBus();
-        return new trpc.Subscription((emit) => {
-          const sub = bus.subscribe("local.patches", (evt) => {
-            emit.data(evt.properties);
+      const [first] = describe.Stacks || [];
+      if (first) {
+        if (lastStatus !== first.StackStatus && first.StackStatus) {
+          lastStatus = first.StackStatus;
+          bus.publish("stack.status", {
+            stackID: stack,
+            status: first.StackStatus
           });
-          return () => {
-            bus.unsubscribe(sub);
-          };
-        });
+          Logger.debug(first);
+          if (isFinal(first.StackStatus)) {
+            return {
+              status: first.StackStatus,
+              outputs: pipe(
+                first.Outputs || [],
+                map((o) => [o.OutputKey, o.OutputValue]),
+                Object.fromEntries,
+                filterOutputs
+              ),
+              errors: isFailed(first.StackStatus) ? errors : {}
+            };
+          }
+        }
       }
-    });
+    } catch (ex) {
+      if (ex.message.includes("does not exist")) {
+        bus.publish("stack.status", {
+          stackID: stack,
+          status: "DELETE_COMPLETE"
+        });
+        return {
+          status: "DELETE_COMPLETE",
+          outputs: {},
+          errors: {}
+        };
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+  }
+}
+function filterOutputs(input) {
+  return pipe(
+    input,
+    omitBy((_, key) => {
+      return key.startsWith("Export") || key === "SSTMetadata";
+    })
+  );
+}
+var STATUSES_PENDING, STATUSES_SUCCESS, STATUSES_FAILED, STATUSES;
+var init_monitor = __esm({
+  "src/stacks/monitor.ts"() {
+    "use strict";
+    init_bus();
+    init_credentials();
+    init_logger();
+    STATUSES_PENDING = [
+      "CREATE_IN_PROGRESS",
+      "DELETE_IN_PROGRESS",
+      "REVIEW_IN_PROGRESS",
+      "ROLLBACK_IN_PROGRESS",
+      "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS",
+      "UPDATE_IN_PROGRESS",
+      "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS",
+      "UPDATE_ROLLBACK_IN_PROGRESS"
+    ];
+    STATUSES_SUCCESS = [
+      "CREATE_COMPLETE",
+      "UPDATE_COMPLETE",
+      "DELETE_COMPLETE",
+      "SKIPPED"
+    ];
+    STATUSES_FAILED = [
+      "CREATE_FAILED",
+      "DELETE_FAILED",
+      "ROLLBACK_FAILED",
+      "ROLLBACK_COMPLETE",
+      "UPDATE_FAILED",
+      "UPDATE_ROLLBACK_COMPLETE",
+      "UPDATE_ROLLBACK_FAILED",
+      "DEPENDENCY_FAILED"
+    ];
+    STATUSES = [
+      ...STATUSES_PENDING,
+      ...STATUSES_SUCCESS,
+      ...STATUSES_FAILED
+    ];
   }
 });
 
-// src/cli/local/server.ts
-var server_exports = {};
-__export(server_exports, {
-  useLocalServer: () => useLocalServer,
-  useLocalServerConfig: () => useLocalServerConfig
+// src/cdk/util.ts
+async function callWithRetry(cb) {
+  try {
+    return await cb();
+  } catch (e) {
+    if (e.code === "ThrottlingException" && e.message === "Rate exceeded" || e.code === "Throttling" && e.message === "Rate exceeded" || e.code === "TooManyRequestsException" && e.message === "Too Many Requests" || e.code === "OperationAbortedException" || e.code === "TimeoutError" || e.code === "NetworkingError") {
+      return await callWithRetry(cb);
+    }
+    throw e;
+  }
+}
+var init_util = __esm({
+  "src/cdk/util.ts"() {
+    "use strict";
+  }
 });
-import { produceWithPatches, enablePatches } from "immer";
-import express from "express";
-import fs6 from "fs/promises";
-import { WebSocketServer } from "ws";
-import https2 from "https";
-import http from "http";
-import { applyWSSHandler } from "@trpc/server/adapters/ws/dist/trpc-server-adapters-ws.cjs.js";
-import { optimise } from "dendriform-immer-patch-optimiser";
-import { sync } from "cross-spawn";
-import getPort from "get-port";
-async function useLocalServer(opts) {
-  const cfg = await useLocalServerConfig();
-  const project = useProject();
-  let state2 = {
-    app: project.config.name,
-    stage: project.config.stage,
-    bootstrap: project.config.bootstrap,
-    live: opts.live,
-    stacks: {
-      status: "idle"
-    },
-    functions: {}
-  };
-  const rest = express();
-  rest.all(`/ping`, (req, res) => {
-    res.header("Access-Control-Allow-Origin", "*");
-    res.header("Access-Control-Allow-Methods", "GET, PUT, PATCH, POST, DELETE");
-    res.header(
-      "Access-Control-Allow-Headers",
-      req.header("access-control-request-headers")
+
+// src/cdk/deploy-stack.ts
+import * as cxapi from "@aws-cdk/cx-api";
+import fs5 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 { 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 { contentHash } from "sst-aws-cdk/lib/util/content-hash.js";
+import { CfnEvaluationException } from "sst-aws-cdk/lib/api/evaluate-cloudformation-template.js";
+import { tryHotswapDeployment } from "sst-aws-cdk/lib/api/hotswap-deployments.js";
+import {
+  changeSetHasNoChanges,
+  CloudFormationStack,
+  TemplateParameters,
+  waitForChangeSet,
+  waitForStackDeploy,
+  waitForStackDelete
+} from "sst-aws-cdk/lib/api/util/cloudformation.js";
+import { blue as blue2 } from "colorette";
+async function deployStack(options) {
+  const stackArtifact = options.stack;
+  const stackEnv = options.resolvedEnvironment;
+  options.sdk.appendCustomUserAgent(options.extraUserAgent);
+  const cfn = options.sdk.cloudFormation();
+  const deployName = options.deployName || stackArtifact.stackName;
+  let cloudFormationStack = await callWithRetry(
+    () => CloudFormationStack.lookup(cfn, deployName)
+  );
+  if (cloudFormationStack.stackStatus.isCreationFailure) {
+    debug(
+      `Found existing stack ${deployName} that had previously failed creation. Deleting it before attempting to re-create it.`
     );
-    res.sendStatus(200);
-  });
-  rest.all(
-    `/proxy*`,
-    express.raw({
-      type: "*/*",
-      limit: "1024mb"
-    }),
-    (req, res) => {
-      res.header("Access-Control-Allow-Origin", "*");
-      res.header(
-        "Access-Control-Allow-Methods",
-        "GET, PUT, PATCH, POST, DELETE"
-      );
-      res.header(
-        "Access-Control-Allow-Headers",
-        req.header("access-control-request-headers")
-      );
-      if (req.method === "OPTIONS")
-        return res.send();
-      const u = new URL(req.url.substring(7));
-      const forward = https2.request(
-        u,
-        {
-          headers: {
-            ...req.headers,
-            host: u.hostname
-          },
-          method: req.method
-        },
-        (proxied) => {
-          res.status(proxied.statusCode);
-          for (const [key, value] of Object.entries(proxied.headers)) {
-            res.header(key, value);
-          }
-          proxied.pipe(res);
-        }
+    await cfn.deleteStack({ StackName: deployName }).promise();
+    const deletedStack = await waitForStackDelete(cfn, deployName);
+    if (deletedStack && deletedStack.stackStatus.name !== "DELETE_COMPLETE") {
+      throw new Error(
+        `Failed deleting stack ${deployName} that had previously failed creation (current state: ${deletedStack.stackStatus})`
       );
-      if (req.method !== "GET" && req.method !== "DELETE" && req.method !== "HEAD" && req.body)
-        forward.write(req.body);
-      forward.end();
-      forward.on("error", (e) => {
-        console.log(e.message);
-      });
     }
+    cloudFormationStack = CloudFormationStack.doesNotExist(cfn, deployName);
+  }
+  const legacyAssets = new AssetManifestBuilder();
+  const assetParams = await addMetadataAssetsToManifest(
+    stackArtifact,
+    legacyAssets,
+    options.toolkitInfo,
+    options.reuseAssets
   );
-  const server = await (async () => {
-    const result2 = sync("mkcert", ["--help"]);
-    const KEY_PATH = ".sst/localhost-key.pem";
-    const CERT_PATH = ".sst/localhost.pem";
-    if (result2.status === 0) {
-      try {
-        await Promise.all([fs6.access(KEY_PATH), fs6.access(CERT_PATH)]);
-      } catch (e) {
-        sync("mkcert", ["localhost"], {
-          cwd: ".sst"
-        });
-      }
-      const [key, cert] = await Promise.all([
-        fs6.readFile(KEY_PATH),
-        fs6.readFile(CERT_PATH)
-      ]);
-      return https2.createServer(
-        {
-          key,
-          cert
-        },
-        rest
-      );
+  const finalParameterValues = { ...options.parameters, ...assetParams };
+  const templateParams = TemplateParameters.fromTemplate(
+    stackArtifact.template
+  );
+  const stackParams = options.usePreviousParameters ? templateParams.updateExisting(
+    finalParameterValues,
+    cloudFormationStack.parameters
+  ) : templateParams.supplyAll(finalParameterValues);
+  if (await canSkipDeploy(
+    options,
+    cloudFormationStack,
+    stackParams.hasChanges(cloudFormationStack.parameters)
+  )) {
+    debug(`${deployName}: skipping deployment (use --force to override)`);
+    if (options.hotswap) {
     }
-    return http.createServer({}, rest);
-  })();
-  const wss = new WebSocketServer({ server });
-  wss.on("connection", (socket, req) => {
-    if (req.headers.origin?.endsWith("localhost:3000"))
-      return;
-    if (req.headers.origin?.endsWith("localhost:3001"))
-      return;
-    if (req.headers.origin?.endsWith("console.serverless-stack.com"))
-      return;
-    if (req.headers.origin?.endsWith("console.sst.dev"))
-      return;
-    if (req.headers.origin?.endsWith("--sst-console.netlify.app"))
-      return;
-    console.log("Rejecting unauthorized connection from " + req.headers.origin);
-    socket.terminate();
-  });
-  server.listen(cfg.port);
-  const handler = applyWSSHandler({
-    wss,
-    router: router2,
-    createContext() {
-      return {
-        state: state2
-      };
-    }
-  });
-  process.on("SIGTERM", () => {
-    handler.broadcastReconnectNotification();
-    wss.close();
-  });
-  const bus = useBus();
-  const pending = [];
-  function updateState(cb) {
-    const [next, patches] = produceWithPatches(state2, cb);
-    if (!patches.length)
-      return;
-    const scheduled = pending.length;
-    pending.push(...optimise(state2, patches));
-    if (!scheduled)
-      setTimeout(() => {
-        bus.publish("local.patches", pending);
-        pending.splice(0, pending.length);
-      }, 0);
-    state2 = next;
-  }
-  function updateFunction(id, cb) {
-    return updateState((draft) => {
-      let func = draft.functions[id];
-      if (!func) {
-        func = {
-          warm: true,
-          state: "idle",
-          issues: {},
-          invocations: []
-        };
-        draft.functions[id] = func;
-      }
-      cb(func);
-    });
+    return {
+      noOp: true,
+      outputs: cloudFormationStack.outputs,
+      stackArn: cloudFormationStack.stackId
+    };
+  } else {
+    debug(`${deployName}: deploying...`);
   }
-  bus.subscribe("function.invoked", (evt) => {
-    updateFunction(evt.properties.functionID, (draft) => {
-      if (draft.invocations.length >= 25)
-        draft.invocations.pop();
-      draft.invocations.unshift({
-        id: evt.properties.context.awsRequestId,
-        request: evt.properties.event,
-        times: {
-          start: Date.now()
-        },
-        logs: []
-      });
-    });
-  });
-  bus.subscribe("worker.stdout", (evt) => {
-    updateFunction(evt.properties.functionID, (draft) => {
-      const entry = draft.invocations.find(
-        (i) => i.id === evt.properties.requestID
+  const bodyParameter = await makeBodyParameter(
+    stackArtifact,
+    options.resolvedEnvironment,
+    legacyAssets,
+    options.toolkitInfo,
+    options.sdk,
+    options.overrideTemplate
+  );
+  await publishAssets(
+    legacyAssets.toManifest(stackArtifact.assembly.directory),
+    options.sdkProvider,
+    stackEnv,
+    {
+      parallel: options.assetParallelism
+    }
+  );
+  if (options.hotswap) {
+    try {
+      const hotswapDeploymentResult = await tryHotswapDeployment(
+        options.sdkProvider,
+        assetParams,
+        cloudFormationStack,
+        stackArtifact
       );
-      if (!entry)
-        return;
-      entry.logs.push({
-        timestamp: Date.now(),
-        message: evt.properties.message
-      });
-    });
-  });
-  bus.subscribe("function.success", (evt) => {
-    updateFunction(evt.properties.functionID, (draft) => {
-      const invocation = draft.invocations.find(
-        (x) => x.id === evt.properties.requestID
+      if (hotswapDeploymentResult) {
+        return hotswapDeploymentResult;
+      }
+      print(
+        "Could not perform a hotswap deployment, as the stack %s contains non-Asset changes",
+        stackArtifact.displayName
       );
-      if (!invocation)
-        return;
-      invocation.response = {
-        type: "success",
-        data: evt.properties.body
-      };
-      invocation.times.end = Date.now();
-    });
-  });
-  bus.subscribe("function.error", (evt) => {
-    updateFunction(evt.properties.functionID, (draft) => {
-      const invocation = draft.invocations.find(
-        (x) => x.id === evt.properties.requestID
+    } catch (e) {
+      if (!(e instanceof CfnEvaluationException)) {
+        throw e;
+      }
+      print(
+        "Could not perform a hotswap deployment, because the CloudFormation template could not be resolved: %s",
+        e.message
       );
-      if (!invocation)
-        return;
-      invocation.response = {
-        type: "failure",
-        error: {
-          errorMessage: evt.properties.errorMessage,
-          stackTrace: evt.properties.trace || []
-        }
-      };
-      invocation.times.end = Date.now();
-    });
-  });
-  const result = {
-    updateState,
-    updateFunction
-  };
-  return result;
+    }
+    print("Falling back to doing a full deployment");
+    options.sdk.appendCustomUserAgent("cdk-hotswap/fallback");
+  }
+  const fullDeployment = new FullCloudFormationDeployment(
+    options,
+    cloudFormationStack,
+    stackArtifact,
+    stackParams,
+    bodyParameter
+  );
+  return fullDeployment.performDeployment();
 }
-var useLocalServerConfig;
-var init_server = __esm({
-  "src/cli/local/server.ts"() {
-    "use strict";
-    init_router();
-    init_project();
-    init_bus();
-    init_context();
-    enablePatches();
-    useLocalServerConfig = Context.memo(async () => {
-      const project = useProject();
-      const port = await getPort({
-        port: 13557
-      });
-      return {
-        port,
-        url: `https://console.sst.dev/${project.config.name}/${project.config.stage}${port !== 13557 ? `?_port=${port}` : ""}`
-      };
-    });
+async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, toolkitInfo, sdk, overrideTemplate) {
+  if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {
+    return {
+      TemplateURL: restUrlFromManifest(
+        stack.stackTemplateAssetObjectUrl,
+        resolvedEnvironment,
+        sdk
+      )
+    };
   }
-});
+  const templateJson = toYAML(overrideTemplate ?? stack.template);
+  if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {
+    return { TemplateBody: templateJson };
+  }
+  if (!toolkitInfo.found) {
+    error(
+      `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.
+Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:
 
-// src/cli/ui/header.ts
-var header_exports = {};
-__export(header_exports, {
-  printConsole: () => printConsole,
-  printHeader: () => printHeader
-});
-async function printHeader(input) {
-  const project = useProject();
-  Colors.line(
-    `${Colors.primary.bold(`SST v${project.version}`)}  ${input.hint ? Colors.dim(`ready!`) : ""}`
-  );
-  Colors.gap();
-  Colors.line(
-    `${Colors.primary(`\u279C`)}  ${Colors.bold("App:")}     ${project.config.name}`
-  );
-  Colors.line(
-    `${Colors.primary(` `)}  ${Colors.bold("Stage:")}   ${project.config.stage}`
-  );
-  if (input.console) {
-    const local = await useLocalServerConfig();
-    Colors.line(
-      `${Colors.primary(` `)}  ${Colors.bold("Console:")} ${Colors.link(
-        local.url
-      )}`
+`,
+      blue2(`	$ cdk bootstrap ${resolvedEnvironment.name}
+`)
+    );
+    throw new Error(
+      'Template too large to deploy ("cdk bootstrap" is required)'
     );
   }
-  Colors.gap();
-}
-function printConsole() {
-}
-var init_header = __esm({
-  "src/cli/ui/header.ts"() {
-    "use strict";
-    init_project();
-    init_colors();
-    init_server();
-  }
-});
-
-// src/watcher.ts
-var watcher_exports = {};
-__export(watcher_exports, {
-  useWatcher: () => useWatcher
-});
-import chokidar from "chokidar";
-import path6 from "path";
-var useWatcher;
-var init_watcher = __esm({
-  "src/watcher.ts"() {
-    "use strict";
-    init_context();
-    init_bus();
-    init_project();
-    useWatcher = Context.memo(() => {
-      const project = useProject();
-      const bus = useBus();
-      const watcher = chokidar.watch([project.paths.root], {
-        persistent: true,
-        ignoreInitial: true,
-        followSymlinks: false,
-        disableGlobbing: false,
-        ignored: [
-          "**/node_modules/**",
-          "**/.build/**",
-          "**/.sst/**",
-          "**/debug.log"
-        ],
-        awaitWriteFinish: {
-          pollInterval: 100,
-          stabilityThreshold: 20
-        }
-      });
-      watcher.on("change", (file) => {
-        bus.publish("file.changed", {
-          file,
-          relative: path6.relative(project.paths.root, file)
-        });
-      });
-      return {
-        subscribe: bus.forward("file.changed")
-      };
-    });
-  }
-});
-
-// src/runtime/handlers.ts
-import path7 from "path";
-import fs7 from "fs/promises";
-import { useFunctions } from "../src/constructs/Function.js";
-var useRuntimeHandlers, useFunctionBuilder;
-var init_handlers = __esm({
-  "src/runtime/handlers.ts"() {
-    "use strict";
-    init_context();
-    init_logger();
-    init_watcher();
-    init_bus();
-    init_project();
-    useRuntimeHandlers = Context.memo(() => {
-      const handlers = [];
-      const project = useProject();
-      const bus = useBus();
-      const pendingBuilds = /* @__PURE__ */ new Map();
-      const result = {
-        subscribe: bus.forward("function.build.success", "function.build.failed"),
-        register: (handler) => {
-          handlers.push(handler);
-        },
-        for: (runtime) => {
-          const result2 = handlers.find((x) => x.canHandle(runtime));
-          if (!result2)
-            throw new Error(`${runtime} runtime is unsupported`);
-          return result2;
-        },
-        async build(functionID, mode) {
-          async function task() {
-            const func = useFunctions().fromID(functionID);
-            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 });
-            if (func.hooks?.beforeBuild)
-              await func.hooks.beforeBuild(func, out);
-            const built = await handler.build({
-              functionID,
-              out,
-              mode,
-              props: func
-            });
-            if (built.type === "error") {
-              bus.publish("function.build.failed", {
-                functionID,
-                errors: built.errors
-              });
-              return built;
-            }
-            if (func.copyFiles) {
-              await Promise.all(
-                func.copyFiles.map(async (entry) => {
-                  const fromPath = path7.join(project.paths.root, entry.from);
-                  const to = entry.to || entry.from;
-                  if (path7.isAbsolute(to))
-                    throw new Error(
-                      `Copy destination path "${to}" must be relative`
-                    );
-                  const toPath = path7.join(out, to);
-                  if (mode === "deploy")
-                    await fs7.cp(fromPath, toPath, {
-                      recursive: true
-                    });
-                  if (mode === "start") {
-                    const dir = path7.dirname(toPath);
-                    await fs7.mkdir(dir, { recursive: true });
-                    await fs7.symlink(fromPath, toPath);
-                  }
-                })
-              );
-            }
-            if (func.hooks?.afterBuild)
-              await func.hooks.afterBuild(func, out);
-            bus.publish("function.build.success", { functionID });
-            return {
-              ...built,
-              out
-            };
-          }
-          if (pendingBuilds.has(functionID)) {
-            Logger.debug("Waiting on pending build", functionID);
-            return pendingBuilds.get(functionID);
-          }
-          const promise = task();
-          pendingBuilds.set(functionID, promise);
-          Logger.debug("Building function", functionID);
-          const r = await promise;
-          pendingBuilds.delete(functionID);
-          return r;
-        }
-      };
-      return result;
-    });
-    useFunctionBuilder = Context.memo(() => {
-      const artifacts = /* @__PURE__ */ new Map();
-      const handlers = useRuntimeHandlers();
-      const result = {
-        artifact: (functionID) => {
-          if (artifacts.has(functionID))
-            return artifacts.get(functionID);
-          return result.build(functionID);
-        },
-        build: async (functionID) => {
-          const result2 = await handlers.build(functionID, "start");
-          if (result2.type === "error")
-            return;
-          artifacts.set(functionID, result2);
-          return artifacts.get(functionID);
-        }
-      };
-      const watcher = useWatcher();
-      watcher.subscribe("file.changed", async (evt) => {
-        try {
-          const functions = useFunctions();
-          for (const [functionID, props] of Object.entries(functions.all)) {
-            const handler = handlers.for(props.runtime);
-            if (!handler?.shouldBuild({
-              functionID,
-              file: evt.properties.file
-            }))
-              continue;
-            await result.build(functionID);
-            Logger.debug("Rebuilt function", functionID);
-          }
-        } catch {
-        }
-      });
-      return result;
-    });
-  }
-});
-
-// src/runtime/server.ts
-var server_exports2 = {};
-__export(server_exports2, {
-  useRuntimeServer: () => useRuntimeServer,
-  useRuntimeServerConfig: () => useRuntimeServerConfig
-});
-import express2 from "express";
-import https3 from "https";
-import getPort2 from "get-port";
-var useRuntimeServerConfig, useRuntimeServer;
-var init_server2 = __esm({
-  "src/runtime/server.ts"() {
-    "use strict";
-    init_context();
-    init_bus();
-    init_logger();
-    init_workers();
-    useRuntimeServerConfig = Context.memo(async () => {
-      const port = await getPort2({
-        port: 12557
-      });
-      return {
-        API_VERSION: "2018-06-01",
-        port,
-        url: `http://localhost:${port}`
-      };
-    });
-    useRuntimeServer = Context.memo(async () => {
-      const bus = useBus();
-      const app = express2();
-      const workers = await useRuntimeWorkers();
-      const cfg = await useRuntimeServerConfig();
-      const workersWaiting = /* @__PURE__ */ new Map();
-      const invocationsQueued = /* @__PURE__ */ new Map();
-      function next(workerID) {
-        const queue = invocationsQueued.get(workerID);
-        const value = queue?.shift();
-        if (value)
-          return value;
-        return new Promise((resolve, reject) => {
-          workersWaiting.set(workerID, resolve);
-        });
-      }
-      workers.subscribe("worker.exited", async (evt) => {
-        const waiting = workersWaiting.get(evt.properties.workerID);
-        if (!waiting)
-          return;
-        workersWaiting.delete(evt.properties.workerID);
-      });
-      bus.subscribe("function.invoked", async (evt) => {
-        const worker = workersWaiting.get(evt.properties.workerID);
-        if (worker) {
-          workersWaiting.delete(evt.properties.workerID);
-          worker(evt.properties);
-          return;
-        }
-        let arr = invocationsQueued.get(evt.properties.workerID);
-        if (!arr) {
-          arr = [];
-          invocationsQueued.set(evt.properties.workerID, arr);
-        }
-        arr.push(evt.properties);
-      });
-      app.post(
-        `/:workerID/${cfg.API_VERSION}/runtime/init/error`,
-        express2.json({
-          strict: false,
-          type: ["application/json", "application/*+json"],
-          limit: "10mb"
-        }),
-        async (req, res) => {
-          const worker = workers.fromID(req.params.workerID);
-          bus.publish("function.error", {
-            requestID: workers.getCurrentRequestID(worker.workerID),
-            workerID: worker.workerID,
-            functionID: worker.functionID,
-            ...req.body
-          });
-          res.json("ok");
-        }
-      );
-      app.get(
-        `/:workerID/${cfg.API_VERSION}/runtime/invocation/next`,
-        async (req, res) => {
-          Logger.debug(
-            "Worker",
-            req.params.workerID,
-            "is waiting for next invocation"
-          );
-          const payload = await next(req.params.workerID);
-          Logger.debug("Worker", req.params.workerID, "sending next payload");
-          res.set({
-            "Lambda-Runtime-Aws-Request-Id": payload.context.awsRequestId,
-            "Lambda-Runtime-Deadline-Ms": Date.now() + payload.deadline,
-            "Lambda-Runtime-Invoked-Function-Arn": payload.context.invokedFunctionArn,
-            "Lambda-Runtime-Client-Context": JSON.stringify(
-              payload.context.clientContext || null
-            ),
-            "Lambda-Runtime-Cognito-Identity": JSON.stringify(
-              payload.context.identity || null
-            ),
-            "Lambda-Runtime-Log-Group-Name": payload.context.logGroupName,
-            "Lambda-Runtime-Log-Stream-Name": payload.context.logStreamName
-          });
-          res.json(payload.event);
-        }
-      );
-      app.post(
-        `/:workerID/${cfg.API_VERSION}/runtime/invocation/:awsRequestId/response`,
-        express2.json({
-          strict: false,
-          type() {
-            return true;
-          },
-          limit: "10mb"
-        }),
-        (req, res) => {
-          Logger.debug("Worker", req.params.workerID, "got response", req.body);
-          const worker = workers.fromID(req.params.workerID);
-          bus.publish("function.success", {
-            workerID: worker.workerID,
-            functionID: worker.functionID,
-            requestID: req.params.awsRequestId,
-            body: req.body
-          });
-          res.status(202).send();
-        }
-      );
-      app.all(
-        `/proxy*`,
-        express2.raw({
-          type: "*/*",
-          limit: "1024mb"
-        }),
-        (req, res) => {
-          res.header("Access-Control-Allow-Origin", "*");
-          res.header(
-            "Access-Control-Allow-Methods",
-            "GET, PUT, PATCH, POST, DELETE"
-          );
-          res.header(
-            "Access-Control-Allow-Headers",
-            req.header("access-control-request-headers")
-          );
-          if (req.method === "OPTIONS")
-            return res.send();
-          const u = new URL(req.url.substring(7));
-          const forward = https3.request(
-            u,
-            {
-              headers: {
-                ...req.headers,
-                host: u.hostname
-              },
-              method: req.method
-            },
-            (proxied) => {
-              res.status(proxied.statusCode);
-              for (const [key, value] of Object.entries(proxied.headers)) {
-                res.header(key, value);
-              }
-              proxied.pipe(res);
-            }
-          );
-          if (req.method !== "GET" && req.method !== "DELETE" && req.method !== "HEAD" && req.body)
-            forward.write(req.body);
-          forward.end();
-          forward.on("error", (e) => {
-            console.log(e.message);
-          });
-        }
-      );
-      app.post(
-        `/:workerID/${cfg.API_VERSION}/runtime/invocation/:awsRequestId/error`,
-        express2.json({
-          strict: false,
-          type: ["application/json", "application/*+json"],
-          limit: "10mb"
-        }),
-        (req, res) => {
-          const worker = workers.fromID(req.params.workerID);
-          bus.publish("function.error", {
-            workerID: worker.workerID,
-            functionID: worker.functionID,
-            errorType: req.body.errorType,
-            errorMessage: req.body.errorMessage,
-            requestID: req.params.awsRequestId,
-            trace: req.body.trace
-          });
-          res.status(202).send();
-        }
-      );
-      app.listen(cfg.port);
-    });
-  }
-});
-
-// src/runtime/workers.ts
-var workers_exports = {};
-__export(workers_exports, {
-  useRuntimeWorkers: () => useRuntimeWorkers
-});
-import { useFunctions as useFunctions2 } from "../src/constructs/Function.js";
-var useRuntimeWorkers;
-var init_workers = __esm({
-  "src/runtime/workers.ts"() {
-    "use strict";
-    init_context();
-    init_bus();
-    init_handlers();
-    init_server2();
-    useRuntimeWorkers = Context.memo(async () => {
-      const workers = /* @__PURE__ */ new Map();
-      const bus = useBus();
-      const handlers = useRuntimeHandlers();
-      const builder = useFunctionBuilder();
-      const server = await useRuntimeServerConfig();
-      handlers.subscribe("function.build.success", async (evt) => {
-        for (const [_, worker] of workers) {
-          if (worker.functionID === evt.properties.functionID) {
-            const props = useFunctions2().fromID(worker.functionID);
-            const handler = handlers.for(props.runtime);
-            await handler?.stopWorker(worker.workerID);
-            bus.publish("worker.stopped", worker);
-          }
-        }
-      });
-      const lastRequestId = /* @__PURE__ */ new Map();
-      bus.subscribe("function.invoked", async (evt) => {
-        bus.publish("function.ack", {
-          functionID: evt.properties.functionID,
-          workerID: evt.properties.workerID
-        });
-        lastRequestId.set(evt.properties.workerID, evt.properties.requestID);
-        let worker = workers.get(evt.properties.workerID);
-        if (worker)
-          return;
-        const props = useFunctions2().fromID(evt.properties.functionID);
-        const handler = handlers.for(props.runtime);
-        if (!handler)
-          return;
-        const build2 = await builder.artifact(evt.properties.functionID);
-        if (!build2)
-          return;
-        await handler.startWorker({
-          ...build2,
-          workerID: evt.properties.workerID,
-          environment: evt.properties.env,
-          url: `${server.url}/${evt.properties.workerID}/${server.API_VERSION}`
-        });
-        workers.set(evt.properties.workerID, {
-          workerID: evt.properties.workerID,
-          functionID: evt.properties.functionID
-        });
-        bus.publish("worker.started", {
-          workerID: evt.properties.workerID,
-          functionID: evt.properties.functionID
-        });
-      });
-      return {
-        fromID(workerID) {
-          return workers.get(workerID);
-        },
-        getCurrentRequestID(workerID) {
-          return lastRequestId.get(workerID);
-        },
-        stdout(workerID, message) {
-          const worker = workers.get(workerID);
-          bus.publish("worker.stdout", {
-            ...worker,
-            message: message.trim(),
-            requestID: lastRequestId.get(workerID)
-          });
-        },
-        exited(workerID) {
-          const existing = workers.get(workerID);
-          if (!existing)
-            return;
-          workers.delete(workerID);
-          lastRequestId.delete(workerID);
-          bus.publish("worker.exited", existing);
-        },
-        subscribe: bus.forward(
-          "worker.started",
-          "worker.stopped",
-          "worker.exited",
-          "worker.stdout"
-        )
-      };
-    });
-  }
-});
-
-// src/stacks/app-metadata.ts
-import {
-  S3Client,
-  GetObjectCommand,
-  PutObjectCommand,
-  DeleteObjectCommand
-} from "@aws-sdk/client-s3";
-async function metadata() {
-  Logger.debug("Fetching app metadata");
-  const [project, credentials, bootstrap] = await Promise.all([
-    useProject(),
-    useAWSCredentials(),
-    useBootstrap()
-  ]);
-  const s3 = new S3Client({
-    region: project.config.region,
-    credentials
-  });
-  try {
-    const result = await s3.send(
-      new GetObjectCommand({
-        Key: useS3Key(),
-        Bucket: bootstrap.bucket
-      })
-    );
-    const body = await result.Body.transformToString();
-    return JSON.parse(body);
-  } catch (ex) {
-    Logger.debug("Fetching app metadata: not found");
-  }
-}
-async function saveAppMetadata(data2) {
-  Logger.debug("Saving app metadata");
-  const [project, credentials, bootstrap] = await Promise.all([
-    useProject(),
-    useAWSCredentials(),
-    useBootstrap()
-  ]);
-  const s3 = new S3Client({
-    region: project.config.region,
-    credentials
-  });
-  try {
-    await s3.send(
-      new PutObjectCommand({
-        Key: useS3Key(),
-        Bucket: bootstrap.bucket,
-        Body: JSON.stringify(data2)
-      })
-    );
-  } catch (ex) {
-    Logger.debug("Saving app metadata: not found");
-  }
-}
-async function clearAppMetadata() {
-  Logger.debug("Clearing app metadata");
-  const [project, credentials, bootstrap] = await Promise.all([
-    useProject(),
-    useAWSCredentials(),
-    useBootstrap()
-  ]);
-  const s3 = new S3Client({
-    region: project.config.region,
-    credentials
-  });
-  await s3.send(
-    new DeleteObjectCommand({
-      Key: useS3Key(),
-      Bucket: bootstrap.bucket
-    })
-  );
-}
-function useS3Key() {
-  const project = useProject();
-  return `appMetadata/app.${project.config.name}/stage.${project.config.stage}.json`;
-}
-var MetadataContext, useAppMetadata;
-var init_app_metadata = __esm({
-  "src/stacks/app-metadata.ts"() {
-    "use strict";
-    init_bootstrap();
-    init_credentials();
-    init_context();
-    init_logger();
-    init_project();
-    MetadataContext = Context.create(async () => {
-      const data2 = await metadata();
-      return data2;
-    });
-    useAppMetadata = MetadataContext.use;
-  }
-});
-
-// src/stacks/assembly.ts
-async function loadAssembly(from) {
-  const { CloudAssembly } = await import("aws-cdk-lib/cx-api");
-  return new CloudAssembly(from);
-}
-var init_assembly = __esm({
-  "src/stacks/assembly.ts"() {
-    "use strict";
-  }
-});
-
-// src/stacks/monitor.ts
-import {
-  CloudFormationClient,
-  DescribeStackResourcesCommand,
-  DescribeStacksCommand,
-  DescribeStackEventsCommand
-} from "@aws-sdk/client-cloudformation";
-import { map, omitBy, pipe } from "remeda";
-function isFinal(input) {
-  return STATUSES_SUCCESS.includes(input) || STATUSES_FAILED.includes(input);
-}
-function isFailed(input) {
-  return STATUSES_FAILED.includes(input);
-}
-function isSuccess(input) {
-  return STATUSES_SUCCESS.includes(input);
-}
-function isPending(input) {
-  return STATUSES_PENDING.includes(input);
-}
-async function monitor(stack) {
-  const [cfn, bus] = await Promise.all([
-    useAWSClient(CloudFormationClient),
-    useBus()
-  ]);
-  let lastStatus;
-  const errors = {};
-  let lastEvent;
-  while (true) {
-    try {
-      const [describe, resources, events] = await Promise.all([
-        cfn.send(
-          new DescribeStacksCommand({
-            StackName: stack
-          })
-        ),
-        cfn.send(
-          new DescribeStackResourcesCommand({
-            StackName: stack
-          })
-        ),
-        cfn.send(
-          new DescribeStackEventsCommand({
-            StackName: stack
-          })
-        )
-      ]);
-      Logger.debug("Stack description", describe);
-      if (lastEvent) {
-        const eventsReversed = [...events.StackEvents ?? []].reverse();
-        for (const event of eventsReversed) {
-          if (!event.Timestamp)
-            continue;
-          if (event.Timestamp.getTime() > lastEvent.getTime()) {
-            bus.publish("stack.event", {
-              event,
-              stackID: stack
-            });
-            if (event.ResourceStatusReason) {
-              if (event.ResourceStatusReason.includes(
-                "Resource creation cancelled"
-              ) || event.ResourceStatusReason.includes(
-                "Resource update cancelled"
-              ) || event.ResourceStatusReason.includes(
-                "Resource creation Initiated"
-              ) || event.ResourceStatusReason.startsWith(
-                "The following resource(s) failed to"
-              ))
-                continue;
-              errors[event.LogicalResourceId] = event.ResourceStatusReason;
-            }
-          }
-        }
-        Logger.debug("Last event set to", lastEvent);
-      }
-      lastEvent = events.StackEvents?.at(0)?.Timestamp;
-      bus.publish("stack.resources", {
-        stackID: stack,
-        resources: resources.StackResources
-      });
-      for (const resource of resources.StackResources || []) {
-        if (resource.ResourceStatusReason?.includes(
-          "Resource creation cancelled"
-        ) || resource.ResourceStatusReason?.includes(
-          "Resource update cancelled"
-        ) || resource.ResourceStatusReason?.includes(
-          "Resource creation Initiated"
-        ) || resource.ResourceStatusReason?.startsWith(
-          "The following resource(s) failed to"
-        ))
-          continue;
-        if (resource.ResourceStatusReason)
-          errors[resource.LogicalResourceId] = resource.ResourceStatusReason;
-      }
-      const [first] = describe.Stacks || [];
-      if (first) {
-        if (lastStatus !== first.StackStatus && first.StackStatus) {
-          lastStatus = first.StackStatus;
-          bus.publish("stack.status", {
-            stackID: stack,
-            status: first.StackStatus
-          });
-          Logger.debug(first);
-          if (isFinal(first.StackStatus)) {
-            return {
-              status: first.StackStatus,
-              outputs: pipe(
-                first.Outputs || [],
-                map((o) => [o.OutputKey, o.OutputValue]),
-                Object.fromEntries,
-                filterOutputs
-              ),
-              errors: isFailed(first.StackStatus) ? errors : {}
-            };
-          }
-        }
-      }
-    } catch (ex) {
-      if (ex.message.includes("does not exist")) {
-        bus.publish("stack.status", {
-          stackID: stack,
-          status: "DELETE_COMPLETE"
-        });
-        return {
-          status: "DELETE_COMPLETE",
-          outputs: {},
-          errors: {}
-        };
-      }
-    }
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
-  }
-}
-function filterOutputs(input) {
-  return pipe(
-    input,
-    omitBy((_, key) => {
-      return key.startsWith("Export") || key === "SSTMetadata";
-    })
-  );
-}
-var STATUSES_PENDING, STATUSES_SUCCESS, STATUSES_FAILED, STATUSES;
-var init_monitor = __esm({
-  "src/stacks/monitor.ts"() {
-    "use strict";
-    init_bus();
-    init_credentials();
-    init_logger();
-    STATUSES_PENDING = [
-      "CREATE_IN_PROGRESS",
-      "DELETE_IN_PROGRESS",
-      "REVIEW_IN_PROGRESS",
-      "ROLLBACK_IN_PROGRESS",
-      "UPDATE_COMPLETE_CLEANUP_IN_PROGRESS",
-      "UPDATE_IN_PROGRESS",
-      "UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS",
-      "UPDATE_ROLLBACK_IN_PROGRESS"
-    ];
-    STATUSES_SUCCESS = [
-      "CREATE_COMPLETE",
-      "UPDATE_COMPLETE",
-      "DELETE_COMPLETE",
-      "SKIPPED"
-    ];
-    STATUSES_FAILED = [
-      "CREATE_FAILED",
-      "DELETE_FAILED",
-      "ROLLBACK_FAILED",
-      "ROLLBACK_COMPLETE",
-      "UPDATE_FAILED",
-      "UPDATE_ROLLBACK_COMPLETE",
-      "UPDATE_ROLLBACK_FAILED",
-      "DEPENDENCY_FAILED"
-    ];
-    STATUSES = [
-      ...STATUSES_PENDING,
-      ...STATUSES_SUCCESS,
-      ...STATUSES_FAILED
-    ];
-  }
-});
-
-// src/cdk/util.ts
-async function callWithRetry(cb) {
-  try {
-    return await cb();
-  } catch (e) {
-    if (e.code === "ThrottlingException" && e.message === "Rate exceeded" || e.code === "Throttling" && e.message === "Rate exceeded" || e.code === "TooManyRequestsException" && e.message === "Too Many Requests" || e.code === "OperationAbortedException" || e.code === "TimeoutError" || e.code === "NetworkingError") {
-      return await callWithRetry(cb);
-    }
-    throw e;
-  }
-}
-var init_util = __esm({
-  "src/cdk/util.ts"() {
-    "use strict";
-  }
-});
-
-// src/cdk/deploy-stack.ts
-import * as cxapi from "@aws-cdk/cx-api";
-import fs8 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 { 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 { contentHash } from "sst-aws-cdk/lib/util/content-hash.js";
-import { CfnEvaluationException } from "sst-aws-cdk/lib/api/evaluate-cloudformation-template.js";
-import { tryHotswapDeployment } from "sst-aws-cdk/lib/api/hotswap-deployments.js";
-import {
-  changeSetHasNoChanges,
-  CloudFormationStack,
-  TemplateParameters,
-  waitForChangeSet,
-  waitForStackDeploy,
-  waitForStackDelete
-} from "sst-aws-cdk/lib/api/util/cloudformation.js";
-import { blue as blue2 } from "colorette";
-async function deployStack(options) {
-  const stackArtifact = options.stack;
-  const stackEnv = options.resolvedEnvironment;
-  options.sdk.appendCustomUserAgent(options.extraUserAgent);
-  const cfn = options.sdk.cloudFormation();
-  const deployName = options.deployName || stackArtifact.stackName;
-  let cloudFormationStack = await callWithRetry(
-    () => CloudFormationStack.lookup(cfn, deployName)
-  );
-  if (cloudFormationStack.stackStatus.isCreationFailure) {
-    debug(
-      `Found existing stack ${deployName} that had previously failed creation. Deleting it before attempting to re-create it.`
-    );
-    await cfn.deleteStack({ StackName: deployName }).promise();
-    const deletedStack = await waitForStackDelete(cfn, deployName);
-    if (deletedStack && deletedStack.stackStatus.name !== "DELETE_COMPLETE") {
-      throw new Error(
-        `Failed deleting stack ${deployName} that had previously failed creation (current state: ${deletedStack.stackStatus})`
-      );
-    }
-    cloudFormationStack = CloudFormationStack.doesNotExist(cfn, deployName);
-  }
-  const legacyAssets = new AssetManifestBuilder();
-  const assetParams = await addMetadataAssetsToManifest(
-    stackArtifact,
-    legacyAssets,
-    options.toolkitInfo,
-    options.reuseAssets
-  );
-  const finalParameterValues = { ...options.parameters, ...assetParams };
-  const templateParams = TemplateParameters.fromTemplate(
-    stackArtifact.template
-  );
-  const stackParams = options.usePreviousParameters ? templateParams.updateExisting(
-    finalParameterValues,
-    cloudFormationStack.parameters
-  ) : templateParams.supplyAll(finalParameterValues);
-  if (await canSkipDeploy(
-    options,
-    cloudFormationStack,
-    stackParams.hasChanges(cloudFormationStack.parameters)
-  )) {
-    debug(`${deployName}: skipping deployment (use --force to override)`);
-    if (options.hotswap) {
-    }
-    return {
-      noOp: true,
-      outputs: cloudFormationStack.outputs,
-      stackArn: cloudFormationStack.stackId
-    };
-  } else {
-    debug(`${deployName}: deploying...`);
-  }
-  const bodyParameter = await makeBodyParameter(
-    stackArtifact,
-    options.resolvedEnvironment,
-    legacyAssets,
-    options.toolkitInfo,
-    options.sdk,
-    options.overrideTemplate
-  );
-  await publishAssets(
-    legacyAssets.toManifest(stackArtifact.assembly.directory),
-    options.sdkProvider,
-    stackEnv,
-    {
-      parallel: options.assetParallelism
-    }
-  );
-  if (options.hotswap) {
-    try {
-      const hotswapDeploymentResult = await tryHotswapDeployment(
-        options.sdkProvider,
-        assetParams,
-        cloudFormationStack,
-        stackArtifact
-      );
-      if (hotswapDeploymentResult) {
-        return hotswapDeploymentResult;
-      }
-      print(
-        "Could not perform a hotswap deployment, as the stack %s contains non-Asset changes",
-        stackArtifact.displayName
-      );
-    } catch (e) {
-      if (!(e instanceof CfnEvaluationException)) {
-        throw e;
-      }
-      print(
-        "Could not perform a hotswap deployment, because the CloudFormation template could not be resolved: %s",
-        e.message
-      );
-    }
-    print("Falling back to doing a full deployment");
-    options.sdk.appendCustomUserAgent("cdk-hotswap/fallback");
-  }
-  const fullDeployment = new FullCloudFormationDeployment(
-    options,
-    cloudFormationStack,
-    stackArtifact,
-    stackParams,
-    bodyParameter
-  );
-  return fullDeployment.performDeployment();
-}
-async function makeBodyParameter(stack, resolvedEnvironment, assetManifest, toolkitInfo, sdk, overrideTemplate) {
-  if (stack.stackTemplateAssetObjectUrl && !overrideTemplate) {
-    return {
-      TemplateURL: restUrlFromManifest(
-        stack.stackTemplateAssetObjectUrl,
-        resolvedEnvironment,
-        sdk
-      )
-    };
-  }
-  const templateJson = toYAML(overrideTemplate ?? stack.template);
-  if (templateJson.length <= LARGE_TEMPLATE_SIZE_KB * 1024) {
-    return { TemplateBody: templateJson };
-  }
-  if (!toolkitInfo.found) {
-    error(
-      `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.
-Run the following command in order to setup an S3 bucket in this environment, and then re-deploy:
-
-`,
-      blue2(`	$ cdk bootstrap ${resolvedEnvironment.name}
-`)
-    );
-    throw new Error(
-      'Template too large to deploy ("cdk bootstrap" is required)'
-    );
-  }
-  const templateHash = contentHash(templateJson);
-  const key = `cdk/${stack.id}/${templateHash}.yml`;
-  let templateFile = stack.templateFile;
-  if (overrideTemplate) {
-    templateFile = `${stack.templateFile}-${templateHash}.yaml`;
-    await fs8.writeFile(templateFile, templateJson, { encoding: "utf-8" });
+  const templateHash = contentHash(templateJson);
+  const key = `cdk/${stack.id}/${templateHash}.yml`;
+  let templateFile = stack.templateFile;
+  if (overrideTemplate) {
+    templateFile = `${stack.templateFile}-${templateHash}.yaml`;
+    await fs5.writeFile(templateFile, templateJson, { encoding: "utf-8" });
   }
   assetManifest.addFileAsset(
     templateHash,
@@ -4129,13 +3265,13 @@ async function listImports(exportName) {
   }
 }
 async function getLocalTemplate(stack) {
-  const fs19 = await import("fs/promises");
-  const fileContent = await fs19.readFile(stack.templateFullPath);
+  const fs18 = await import("fs/promises");
+  const fileContent = await fs18.readFile(stack.templateFullPath);
   return fileContent.toString();
 }
 async function saveLocalTemplate(stack, content) {
-  const fs19 = await import("fs/promises");
-  await fs19.writeFile(stack.templateFullPath, content);
+  const fs18 = await import("fs/promises");
+  await fs18.writeFile(stack.templateFullPath, content);
 }
 var init_deploy = __esm({
   "src/stacks/deploy.ts"() {
@@ -4194,157 +3330,603 @@ async function buildLogicalToPathMap(stack) {
   )) {
     map3[md.data] = md.path;
   }
-  return map3;
-}
-var init_diff = __esm({
-  "src/stacks/diff.ts"() {
+  return map3;
+}
+var init_diff = __esm({
+  "src/stacks/diff.ts"() {
+    "use strict";
+  }
+});
+
+// src/cache.ts
+import path5 from "path";
+import fs6 from "fs/promises";
+var useCache;
+var init_cache = __esm({
+  "src/cache.ts"() {
+    "use strict";
+    init_project();
+    init_logger();
+    init_context();
+    useCache = Context.memo(async () => {
+      const project = useProject();
+      const cache = path5.join(project.paths.out, "cache");
+      await fs6.mkdir(cache, {
+        recursive: true
+      });
+      async function write(key, data2) {
+        const full = path5.join(cache, key);
+        Logger.debug("Writing cache", full, data2.length, "bytes");
+        await fs6.writeFile(full, data2);
+      }
+      async function read(key) {
+        const full = path5.join(cache, key);
+        try {
+          const data2 = await fs6.readFile(full);
+          return data2.toString();
+        } catch {
+          return null;
+        }
+      }
+      return {
+        write,
+        read
+      };
+    });
+  }
+});
+
+// src/stacks/metadata.ts
+var metadata_exports = {};
+__export(metadata_exports, {
+  metadata: () => metadata2,
+  useMetadata: () => useMetadata
+});
+import {
+  S3Client as S3Client2,
+  GetObjectCommand as GetObjectCommand2,
+  ListObjectsV2Command
+} from "@aws-sdk/client-s3";
+async function metadata2() {
+  Logger.debug("Fetching all metadata");
+  const project = useProject();
+  const [credentials, bootstrap2] = await Promise.all([
+    useAWSCredentials(),
+    useBootstrap()
+  ]);
+  const s3 = new S3Client2({
+    region: project.config.region,
+    credentials
+  });
+  const key = `stackMetadata/app.${project.config.name}/stage.${project.config.stage}/`;
+  const list2 = await s3.send(
+    new ListObjectsV2Command({
+      Prefix: key,
+      Bucket: bootstrap2.bucket
+    })
+  );
+  const result = Object.fromEntries(
+    await Promise.all(
+      list2.Contents?.map(async (obj) => {
+        const stackID = obj.Key?.split("/").pop();
+        const result2 = await s3.send(
+          new GetObjectCommand2({
+            Key: obj.Key,
+            Bucket: bootstrap2.bucket
+          })
+        );
+        const body = await result2.Body.transformToString();
+        return [stackID, JSON.parse(body)];
+      }) || []
+    )
+  );
+  Logger.debug("Fetched metadata from", list2.KeyCount, "stacks");
+  return result;
+}
+var MetadataContext2, useMetadata;
+var init_metadata = __esm({
+  "src/stacks/metadata.ts"() {
+    "use strict";
+    init_bootstrap();
+    init_credentials();
+    init_cache();
+    init_context();
+    init_bus();
+    init_logger();
+    init_project();
+    MetadataContext2 = Context.create(async () => {
+      const bus = useBus();
+      const cache = await useCache();
+      const data2 = await metadata2();
+      bus.publish("stacks.metadata", data2);
+      bus.subscribe("stacks.metadata.updated", async () => {
+        const data3 = await metadata2();
+        await cache.write(`metadata.json`, JSON.stringify(data3));
+        bus.publish("stacks.metadata", data3);
+        MetadataContext2.provide(Promise.resolve(data3));
+      });
+      bus.subscribe("stacks.metadata.deleted", async () => {
+        const data3 = await metadata2();
+        await cache.write(`metadata.json`, JSON.stringify(data3));
+        bus.publish("stacks.metadata", data3);
+        MetadataContext2.provide(Promise.resolve(data3));
+      });
+      return data2;
+    });
+    useMetadata = MetadataContext2.use;
+  }
+});
+
+// src/watcher.ts
+var watcher_exports = {};
+__export(watcher_exports, {
+  useWatcher: () => useWatcher
+});
+import chokidar from "chokidar";
+import path6 from "path";
+var useWatcher;
+var init_watcher = __esm({
+  "src/watcher.ts"() {
+    "use strict";
+    init_context();
+    init_bus();
+    init_project();
+    useWatcher = Context.memo(() => {
+      const project = useProject();
+      const bus = useBus();
+      const watcher = chokidar.watch([project.paths.root], {
+        persistent: true,
+        ignoreInitial: true,
+        followSymlinks: false,
+        disableGlobbing: false,
+        ignored: [
+          "**/node_modules/**",
+          "**/.build/**",
+          "**/.sst/**",
+          "**/debug.log"
+        ],
+        awaitWriteFinish: {
+          pollInterval: 100,
+          stabilityThreshold: 20
+        }
+      });
+      watcher.on("change", (file) => {
+        bus.publish("file.changed", {
+          file,
+          relative: path6.relative(project.paths.root, file)
+        });
+      });
+      return {
+        subscribe: bus.forward("file.changed")
+      };
+    });
+  }
+});
+
+// src/runtime/handlers.ts
+import path7 from "path";
+import fs7 from "fs/promises";
+import { useFunctions } from "../src/constructs/Function.js";
+var useRuntimeHandlers, useFunctionBuilder;
+var init_handlers = __esm({
+  "src/runtime/handlers.ts"() {
     "use strict";
+    init_context();
+    init_logger();
+    init_watcher();
+    init_bus();
+    init_project();
+    useRuntimeHandlers = Context.memo(() => {
+      const handlers = [];
+      const project = useProject();
+      const bus = useBus();
+      const pendingBuilds = /* @__PURE__ */ new Map();
+      const result = {
+        subscribe: bus.forward("function.build.success", "function.build.failed"),
+        register: (handler) => {
+          handlers.push(handler);
+        },
+        for: (runtime) => {
+          const result2 = handlers.find((x) => x.canHandle(runtime));
+          if (!result2)
+            throw new Error(`${runtime} runtime is unsupported`);
+          return result2;
+        },
+        async build(functionID, mode) {
+          async function task() {
+            const func = useFunctions().fromID(functionID);
+            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 });
+            if (func.hooks?.beforeBuild)
+              await func.hooks.beforeBuild(func, out);
+            const built = await handler.build({
+              functionID,
+              out,
+              mode,
+              props: func
+            });
+            if (built.type === "error") {
+              bus.publish("function.build.failed", {
+                functionID,
+                errors: built.errors
+              });
+              return built;
+            }
+            if (func.copyFiles) {
+              await Promise.all(
+                func.copyFiles.map(async (entry) => {
+                  const fromPath = path7.join(project.paths.root, entry.from);
+                  const to = entry.to || entry.from;
+                  if (path7.isAbsolute(to))
+                    throw new Error(
+                      `Copy destination path "${to}" must be relative`
+                    );
+                  const toPath = path7.join(out, to);
+                  if (mode === "deploy")
+                    await fs7.cp(fromPath, toPath, {
+                      recursive: true
+                    });
+                  if (mode === "start") {
+                    const dir = path7.dirname(toPath);
+                    await fs7.mkdir(dir, { recursive: true });
+                    await fs7.symlink(fromPath, toPath);
+                  }
+                })
+              );
+            }
+            if (func.hooks?.afterBuild)
+              await func.hooks.afterBuild(func, out);
+            bus.publish("function.build.success", { functionID });
+            return {
+              ...built,
+              out
+            };
+          }
+          if (pendingBuilds.has(functionID)) {
+            Logger.debug("Waiting on pending build", functionID);
+            return pendingBuilds.get(functionID);
+          }
+          const promise = task();
+          pendingBuilds.set(functionID, promise);
+          Logger.debug("Building function", functionID);
+          const r = await promise;
+          pendingBuilds.delete(functionID);
+          return r;
+        }
+      };
+      return result;
+    });
+    useFunctionBuilder = Context.memo(() => {
+      const artifacts = /* @__PURE__ */ new Map();
+      const handlers = useRuntimeHandlers();
+      const result = {
+        artifact: (functionID) => {
+          if (artifacts.has(functionID))
+            return artifacts.get(functionID);
+          return result.build(functionID);
+        },
+        build: async (functionID) => {
+          const result2 = await handlers.build(functionID, "start");
+          if (result2.type === "error")
+            return;
+          artifacts.set(functionID, result2);
+          return artifacts.get(functionID);
+        }
+      };
+      const watcher = useWatcher();
+      watcher.subscribe("file.changed", async (evt) => {
+        try {
+          const functions = useFunctions();
+          for (const [functionID, props] of Object.entries(functions.all)) {
+            const handler = handlers.for(props.runtime);
+            if (!handler?.shouldBuild({
+              functionID,
+              file: evt.properties.file
+            }))
+              continue;
+            await result.build(functionID);
+            Logger.debug("Rebuilt function", functionID);
+          }
+        } catch {
+        }
+      });
+      return result;
+    });
   }
 });
 
-// src/cache.ts
-import path8 from "path";
-import fs9 from "fs/promises";
-var useCache;
-var init_cache = __esm({
-  "src/cache.ts"() {
+// src/runtime/server.ts
+var server_exports = {};
+__export(server_exports, {
+  useRuntimeServer: () => useRuntimeServer,
+  useRuntimeServerConfig: () => useRuntimeServerConfig
+});
+import express from "express";
+import https2 from "https";
+import getPort from "get-port";
+var useRuntimeServerConfig, useRuntimeServer;
+var init_server = __esm({
+  "src/runtime/server.ts"() {
     "use strict";
-    init_project();
-    init_logger();
     init_context();
-    useCache = Context.memo(async () => {
-      const project = useProject();
-      const cache = path8.join(project.paths.out, "cache");
-      await fs9.mkdir(cache, {
-        recursive: true
+    init_bus();
+    init_logger();
+    init_workers();
+    useRuntimeServerConfig = Context.memo(async () => {
+      const port = await getPort({
+        port: 12557
       });
-      async function write(key, data2) {
-        const full = path8.join(cache, key);
-        Logger.debug("Writing cache", full, data2.length, "bytes");
-        await fs9.writeFile(full, data2);
+      return {
+        API_VERSION: "2018-06-01",
+        port,
+        url: `http://localhost:${port}`
+      };
+    });
+    useRuntimeServer = Context.memo(async () => {
+      const bus = useBus();
+      const app = express();
+      const workers = await useRuntimeWorkers();
+      const cfg = await useRuntimeServerConfig();
+      const workersWaiting = /* @__PURE__ */ new Map();
+      const invocationsQueued = /* @__PURE__ */ new Map();
+      function next(workerID) {
+        const queue = invocationsQueued.get(workerID);
+        const value = queue?.shift();
+        if (value)
+          return value;
+        return new Promise((resolve, reject) => {
+          workersWaiting.set(workerID, resolve);
+        });
       }
-      async function read(key) {
-        const full = path8.join(cache, key);
-        try {
-          const data2 = await fs9.readFile(full);
-          return data2.toString();
-        } catch {
-          return null;
+      workers.subscribe("worker.exited", async (evt) => {
+        const waiting = workersWaiting.get(evt.properties.workerID);
+        if (!waiting)
+          return;
+        workersWaiting.delete(evt.properties.workerID);
+      });
+      bus.subscribe("function.invoked", async (evt) => {
+        const worker = workersWaiting.get(evt.properties.workerID);
+        if (worker) {
+          workersWaiting.delete(evt.properties.workerID);
+          worker(evt.properties);
+          return;
+        }
+        let arr = invocationsQueued.get(evt.properties.workerID);
+        if (!arr) {
+          arr = [];
+          invocationsQueued.set(evt.properties.workerID, arr);
+        }
+        arr.push(evt.properties);
+      });
+      app.post(
+        `/:workerID/${cfg.API_VERSION}/runtime/init/error`,
+        express.json({
+          strict: false,
+          type: ["application/json", "application/*+json"],
+          limit: "10mb"
+        }),
+        async (req, res) => {
+          const worker = workers.fromID(req.params.workerID);
+          bus.publish("function.error", {
+            requestID: workers.getCurrentRequestID(worker.workerID),
+            workerID: worker.workerID,
+            functionID: worker.functionID,
+            ...req.body
+          });
+          res.json("ok");
+        }
+      );
+      app.get(
+        `/:workerID/${cfg.API_VERSION}/runtime/invocation/next`,
+        async (req, res) => {
+          Logger.debug(
+            "Worker",
+            req.params.workerID,
+            "is waiting for next invocation"
+          );
+          const payload = await next(req.params.workerID);
+          Logger.debug("Worker", req.params.workerID, "sending next payload");
+          res.set({
+            "Lambda-Runtime-Aws-Request-Id": payload.context.awsRequestId,
+            "Lambda-Runtime-Deadline-Ms": Date.now() + payload.deadline,
+            "Lambda-Runtime-Invoked-Function-Arn": payload.context.invokedFunctionArn,
+            "Lambda-Runtime-Client-Context": JSON.stringify(
+              payload.context.clientContext || null
+            ),
+            "Lambda-Runtime-Cognito-Identity": JSON.stringify(
+              payload.context.identity || null
+            ),
+            "Lambda-Runtime-Log-Group-Name": payload.context.logGroupName,
+            "Lambda-Runtime-Log-Stream-Name": payload.context.logStreamName
+          });
+          res.json(payload.event);
+        }
+      );
+      app.post(
+        `/:workerID/${cfg.API_VERSION}/runtime/invocation/:awsRequestId/response`,
+        express.json({
+          strict: false,
+          type() {
+            return true;
+          },
+          limit: "10mb"
+        }),
+        (req, res) => {
+          Logger.debug("Worker", req.params.workerID, "got response", req.body);
+          const worker = workers.fromID(req.params.workerID);
+          bus.publish("function.success", {
+            workerID: worker.workerID,
+            functionID: worker.functionID,
+            requestID: req.params.awsRequestId,
+            body: req.body
+          });
+          res.status(202).send();
         }
-      }
-      return {
-        write,
-        read
-      };
+      );
+      app.all(
+        `/proxy*`,
+        express.raw({
+          type: "*/*",
+          limit: "1024mb"
+        }),
+        (req, res) => {
+          res.header("Access-Control-Allow-Origin", "*");
+          res.header(
+            "Access-Control-Allow-Methods",
+            "GET, PUT, PATCH, POST, DELETE"
+          );
+          res.header(
+            "Access-Control-Allow-Headers",
+            req.header("access-control-request-headers")
+          );
+          if (req.method === "OPTIONS")
+            return res.send();
+          const u = new URL(req.url.substring(7));
+          const forward = https2.request(
+            u,
+            {
+              headers: {
+                ...req.headers,
+                host: u.hostname
+              },
+              method: req.method
+            },
+            (proxied) => {
+              res.status(proxied.statusCode);
+              for (const [key, value] of Object.entries(proxied.headers)) {
+                res.header(key, value);
+              }
+              proxied.pipe(res);
+            }
+          );
+          if (req.method !== "GET" && req.method !== "DELETE" && req.method !== "HEAD" && req.body)
+            forward.write(req.body);
+          forward.end();
+          forward.on("error", (e) => {
+            console.log(e.message);
+          });
+        }
+      );
+      app.post(
+        `/:workerID/${cfg.API_VERSION}/runtime/invocation/:awsRequestId/error`,
+        express.json({
+          strict: false,
+          type: ["application/json", "application/*+json"],
+          limit: "10mb"
+        }),
+        (req, res) => {
+          const worker = workers.fromID(req.params.workerID);
+          bus.publish("function.error", {
+            workerID: worker.workerID,
+            functionID: worker.functionID,
+            errorType: req.body.errorType,
+            errorMessage: req.body.errorMessage,
+            requestID: req.params.awsRequestId,
+            trace: req.body.trace
+          });
+          res.status(202).send();
+        }
+      );
+      app.listen(cfg.port);
     });
   }
 });
 
-// src/stacks/metadata.ts
-var metadata_exports = {};
-__export(metadata_exports, {
-  metadata: () => metadata2,
-  metadataForStack: () => metadataForStack,
-  useMetadata: () => useMetadata
+// src/runtime/workers.ts
+var workers_exports = {};
+__export(workers_exports, {
+  useRuntimeWorkers: () => useRuntimeWorkers
 });
-import {
-  S3Client as S3Client2,
-  GetObjectCommand as GetObjectCommand2,
-  ListObjectsV2Command
-} from "@aws-sdk/client-s3";
-async function metadata2() {
-  Logger.debug("Fetching all metadata");
-  const project = useProject();
-  const [credentials, bootstrap] = await Promise.all([
-    useAWSCredentials(),
-    useBootstrap()
-  ]);
-  const s3 = new S3Client2({
-    region: project.config.region,
-    credentials
-  });
-  const key = `stackMetadata/app.${project.config.name}/stage.${project.config.stage}/`;
-  const list2 = await s3.send(
-    new ListObjectsV2Command({
-      Prefix: key,
-      Bucket: bootstrap.bucket
-    })
-  );
-  const result = Object.fromEntries(
-    await Promise.all(
-      list2.Contents?.map(async (obj) => {
-        const stackID = obj.Key?.split("/").pop();
-        const result2 = await s3.send(
-          new GetObjectCommand2({
-            Key: obj.Key,
-            Bucket: bootstrap.bucket
-          })
-        );
-        const body = await result2.Body.transformToString();
-        return [stackID, JSON.parse(body)];
-      }) || []
-    )
-  );
-  Logger.debug("Fetched metadata from", list2.KeyCount, "stacks");
-  return result;
-}
-async function metadataForStack(stackID) {
-  const [project, credentials, bootstrap] = await Promise.all([
-    useProject(),
-    useAWSCredentialsProvider(),
-    useBootstrap()
-  ]);
-  const s3 = new S3Client2({
-    region: project.config.region,
-    credentials
-  });
-  const key = `stackMetadata/app.${project.config.name}/stage.${project.config.stage}/stack.${stackID}.json`;
-  Logger.debug("Getting metadata", key, "from", bootstrap.bucket);
-  try {
-    const result = await s3.send(
-      new GetObjectCommand2({
-        Key: key,
-        Bucket: bootstrap.bucket
-      })
-    );
-    const body = await result.Body.transformToString();
-    return JSON.parse(body);
-  } catch (ex) {
-    console.error(ex);
-    return [];
-  }
-}
-var MetadataContext2, useMetadata;
-var init_metadata = __esm({
-  "src/stacks/metadata.ts"() {
+import { useFunctions as useFunctions2 } from "../src/constructs/Function.js";
+var useRuntimeWorkers;
+var init_workers = __esm({
+  "src/runtime/workers.ts"() {
     "use strict";
-    init_bootstrap();
-    init_credentials();
-    init_cache();
     init_context();
     init_bus();
-    init_logger();
-    init_project();
-    MetadataContext2 = Context.create(async () => {
+    init_handlers();
+    init_server();
+    useRuntimeWorkers = Context.memo(async () => {
+      const workers = /* @__PURE__ */ new Map();
       const bus = useBus();
-      const cache = await useCache();
-      const data2 = await metadata2();
-      bus.publish("stacks.metadata", data2);
-      bus.subscribe("stacks.metadata.updated", async () => {
-        const data3 = await metadata2();
-        await cache.write(`metadata.json`, JSON.stringify(data3));
-        bus.publish("stacks.metadata", data3);
-        MetadataContext2.provide(Promise.resolve(data3));
+      const handlers = useRuntimeHandlers();
+      const builder = useFunctionBuilder();
+      const server = await useRuntimeServerConfig();
+      handlers.subscribe("function.build.success", async (evt) => {
+        for (const [_, worker] of workers) {
+          if (worker.functionID === evt.properties.functionID) {
+            const props = useFunctions2().fromID(worker.functionID);
+            const handler = handlers.for(props.runtime);
+            await handler?.stopWorker(worker.workerID);
+            bus.publish("worker.stopped", worker);
+          }
+        }
       });
-      bus.subscribe("stacks.metadata.deleted", async () => {
-        const data3 = await metadata2();
-        await cache.write(`metadata.json`, JSON.stringify(data3));
-        bus.publish("stacks.metadata", data3);
-        MetadataContext2.provide(Promise.resolve(data3));
+      const lastRequestId = /* @__PURE__ */ new Map();
+      bus.subscribe("function.invoked", async (evt) => {
+        bus.publish("function.ack", {
+          functionID: evt.properties.functionID,
+          workerID: evt.properties.workerID
+        });
+        lastRequestId.set(evt.properties.workerID, evt.properties.requestID);
+        let worker = workers.get(evt.properties.workerID);
+        if (worker)
+          return;
+        const props = useFunctions2().fromID(evt.properties.functionID);
+        const handler = handlers.for(props.runtime);
+        if (!handler)
+          return;
+        const build2 = await builder.artifact(evt.properties.functionID);
+        if (!build2)
+          return;
+        await handler.startWorker({
+          ...build2,
+          workerID: evt.properties.workerID,
+          environment: evt.properties.env,
+          url: `${server.url}/${evt.properties.workerID}/${server.API_VERSION}`
+        });
+        workers.set(evt.properties.workerID, {
+          workerID: evt.properties.workerID,
+          functionID: evt.properties.functionID
+        });
+        bus.publish("worker.started", {
+          workerID: evt.properties.workerID,
+          functionID: evt.properties.functionID
+        });
       });
-      return data2;
+      return {
+        fromID(workerID) {
+          return workers.get(workerID);
+        },
+        getCurrentRequestID(workerID) {
+          return lastRequestId.get(workerID);
+        },
+        stdout(workerID, message) {
+          const worker = workers.get(workerID);
+          bus.publish("worker.stdout", {
+            ...worker,
+            message: message.trim(),
+            requestID: lastRequestId.get(workerID)
+          });
+        },
+        exited(workerID) {
+          const existing = workers.get(workerID);
+          if (!existing)
+            return;
+          workers.delete(workerID);
+          lastRequestId.delete(workerID);
+          bus.publish("worker.exited", existing);
+        },
+        subscribe: bus.forward(
+          "worker.started",
+          "worker.stopped",
+          "worker.exited",
+          "worker.stdout"
+        )
+      };
     });
-    useMetadata = MetadataContext2.use;
   }
 });
 
@@ -4369,7 +3951,7 @@ var init_dotnet = __esm({
     init_handlers();
     init_workers();
     init_context();
-    init_server2();
+    init_server();
     init_fs();
     init_project();
     init_process();
@@ -4493,8 +4075,8 @@ var node_exports = {};
 __export(node_exports, {
   useNodeHandler: () => useNodeHandler
 });
-import path9 from "path";
-import fs10 from "fs/promises";
+import path8 from "path";
+import fs8 from "fs/promises";
 import { exec as exec2 } from "child_process";
 import fsSync2 from "fs";
 import esbuild2 from "esbuild";
@@ -4521,7 +4103,7 @@ var init_node = __esm({
           const result = cache[input.functionID];
           if (!result)
             return false;
-          const relative = path9.relative(project.paths.root, input.file).split(path9.sep).join(path9.posix.sep);
+          const relative = path8.relative(project.paths.root, input.file).split(path8.sep).join(path8.posix.sep);
           return Boolean(result.metafile?.inputs[relative]);
         },
         canHandle: (input) => input.startsWith("nodejs"),
@@ -4559,7 +4141,7 @@ var init_node = __esm({
         },
         build: async (input) => {
           const exists = cache[input.functionID];
-          const parsed = path9.parse(input.props.handler);
+          const parsed = path8.parse(input.props.handler);
           const file = [
             ".ts",
             ".tsx",
@@ -4569,7 +4151,7 @@ var init_node = __esm({
             ".jsx",
             ".mjs",
             ".cjs"
-          ].map((ext) => path9.join(parsed.dir, parsed.name + ext)).find((file2) => {
+          ].map((ext) => path8.join(parsed.dir, parsed.name + ext)).find((file2) => {
             return fsSync2.existsSync(file2);
           });
           if (!file)
@@ -4579,17 +4161,17 @@ var init_node = __esm({
             };
           const nodejs = input.props.nodejs || {};
           const isESM = (nodejs.format || "esm") === "esm";
-          const relative = path9.relative(
+          const relative = path8.relative(
             project.paths.root,
-            path9.resolve(parsed.dir)
+            path8.resolve(parsed.dir)
           );
           const extension = isESM ? ".mjs" : ".cjs";
-          const target = path9.join(
+          const target = path8.join(
             input.out,
-            !relative.startsWith("..") && !path9.isAbsolute(input.props.handler) ? relative : "",
+            !relative.startsWith("..") && !path8.isAbsolute(input.props.handler) ? relative : "",
             parsed.name + extension
           );
-          const handler = path9.relative(input.out, target.replace(extension, parsed.ext)).split(path9.sep).join(path9.posix.sep);
+          const handler = path8.relative(input.out, target.replace(extension, parsed.ext)).split(path8.sep).join(path8.posix.sep);
           if (exists?.rebuild) {
             const result = await exists.rebuild();
             cache[input.functionID] = result;
@@ -4663,17 +4245,17 @@ var init_node = __esm({
             async function find2(dir, target2) {
               if (dir === "/")
                 throw new VisibleError("Could not find a package.json file");
-              if (await fs10.access(path9.join(dir, target2)).then(() => true).catch(() => false))
+              if (await fs8.access(path8.join(dir, target2)).then(() => true).catch(() => false))
                 return dir;
-              return find2(path9.join(dir, ".."), target2);
+              return find2(path8.join(dir, ".."), target2);
             }
             if (input.mode === "deploy" && installPackages) {
               const src = await find2(parsed.dir, "package.json");
               const json = JSON.parse(
-                await fs10.readFile(path9.join(src, "package.json")).then((x) => x.toString())
+                await fs8.readFile(path8.join(src, "package.json")).then((x) => x.toString())
               );
-              fs10.writeFile(
-                path9.join(input.out, "package.json"),
+              fs8.writeFile(
+                path8.join(input.out, "package.json"),
                 JSON.stringify({
                   dependencies: Object.fromEntries(
                     installPackages.map((x) => [x, json.dependencies?.[x] || "*"])
@@ -4695,14 +4277,14 @@ var init_node = __esm({
               });
             }
             if (input.mode === "start") {
-              const dir = path9.join(
+              const dir = path8.join(
                 await find2(parsed.dir, "package.json"),
                 "node_modules"
               );
               try {
-                await fs10.symlink(
-                  path9.resolve(dir),
-                  path9.resolve(path9.join(input.out, "node_modules")),
+                await fs8.symlink(
+                  path8.resolve(dir),
+                  path8.resolve(path8.join(input.out, "node_modules")),
                   "dir"
                 );
               } catch {
@@ -4741,15 +4323,15 @@ var go_exports = {};
 __export(go_exports, {
   useGoHandler: () => useGoHandler
 });
-import path10 from "path";
-import fs11 from "fs/promises";
+import path9 from "path";
+import fs9 from "fs/promises";
 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 fs11.access(path10.join(dir, target)).then(() => true).catch(() => false))
+  if (await fs9.access(path9.join(dir, target)).then(() => true).catch(() => false))
     return dir;
-  return find(path10.join(dir, ".."), target);
+  return find(path9.join(dir, ".."), target);
 }
 var useGoHandler;
 var init_go = __esm({
@@ -4759,7 +4341,7 @@ var init_go = __esm({
     init_workers();
     init_context();
     init_error();
-    init_server2();
+    init_server();
     init_fs();
     init_process();
     useGoHandler = Context.memo(async () => {
@@ -4778,7 +4360,7 @@ var init_go = __esm({
         },
         canHandle: (input) => input.startsWith("go"),
         startWorker: async (input) => {
-          const proc = spawn2(path10.join(input.out, handlerName), {
+          const proc = spawn2(path9.join(input.out, handlerName), {
             env: {
               ...process.env,
               ...input.environment,
@@ -4804,13 +4386,13 @@ var init_go = __esm({
           }
         },
         build: async (input) => {
-          const parsed = path10.parse(input.props.handler);
+          const parsed = path9.parse(input.props.handler);
           const project = await find(parsed.dir, "go.mod");
           sources.set(input.functionID, project);
-          const src = path10.relative(project, input.props.handler);
+          const src = path9.relative(project, input.props.handler);
           if (input.mode === "start") {
             try {
-              const target = path10.join(input.out, handlerName);
+              const target = path9.join(input.out, handlerName);
               const result = await execAsync(
                 `go build -ldflags '-s -w' -o '${target}' ./${src}`,
                 {
@@ -4826,7 +4408,7 @@ var init_go = __esm({
           }
           if (input.mode === "deploy") {
             try {
-              const target = path10.join(input.out, "bootstrap");
+              const target = path9.join(input.out, "bootstrap");
               await execAsync(`go build -ldflags '-s -w' -o '${target}' ./${src}`, {
                 cwd: project,
                 env: {
@@ -4855,8 +4437,8 @@ var rust_exports = {};
 __export(rust_exports, {
   useRustHandler: () => useRustHandler
 });
-import path11 from "path";
-import fs12 from "fs/promises";
+import path10 from "path";
+import fs10 from "fs/promises";
 import { exec as exec4, spawn as spawn3 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2, useRustHandler;
@@ -4867,7 +4449,7 @@ var init_rust = __esm({
     init_workers();
     init_context();
     init_error();
-    init_server2();
+    init_server();
     init_fs();
     execAsync2 = promisify2(exec4);
     useRustHandler = Context.memo(async () => {
@@ -4889,7 +4471,7 @@ var init_rust = __esm({
         },
         canHandle: (input) => input.startsWith("rust"),
         startWorker: async (input) => {
-          const proc = spawn3(path11.join(input.out, handlerName), {
+          const proc = spawn3(path10.join(input.out, handlerName), {
             env: {
               ...process.env,
               ...input.environment,
@@ -4917,7 +4499,7 @@ var init_rust = __esm({
           }
         },
         build: async (input) => {
-          const parsed = path11.parse(input.props.handler);
+          const parsed = path10.parse(input.props.handler);
           const project = await findAbove(parsed.dir, "Cargo.toml");
           if (!project)
             return {
@@ -4933,9 +4515,9 @@ var init_rust = __esm({
                   ...process.env
                 }
               });
-              await fs12.cp(
-                path11.join(project, `target/debug`, parsed.name),
-                path11.join(input.out, "handler")
+              await fs10.cp(
+                path10.join(project, `target/debug`, parsed.name),
+                path10.join(input.out, "handler")
               );
             } catch (ex) {
               throw new VisibleError("Failed to build");
@@ -4949,9 +4531,9 @@ var init_rust = __esm({
                   ...process.env
                 }
               });
-              await fs12.cp(
-                path11.join(project, `target/lambda/`, parsed.name, "bootstrap"),
-                path11.join(input.out, "bootstrap")
+              await fs10.cp(
+                path10.join(project, `target/lambda/`, parsed.name, "bootstrap"),
+                path10.join(input.out, "bootstrap")
               );
             } catch (ex) {
               throw new VisibleError("Failed to build");
@@ -4968,9 +4550,9 @@ var init_rust = __esm({
 });
 
 // src/runtime/handlers/pythonBundling.ts
-import fs13 from "fs";
+import fs11 from "fs";
 import url5 from "url";
-import path12 from "path";
+import path11 from "path";
 import {
   DockerImage,
   FileSystem
@@ -4984,9 +4566,9 @@ function bundle(options) {
     stagedir
   );
   const dockerfile = hasInstallCommands ? "Dockerfile.custom" : hasDeps ? "Dockerfile.dependencies" : "Dockerfile";
-  fs13.copyFileSync(
-    path12.join(__dirname, "../../support/python-runtime", dockerfile),
-    path12.join(stagedir, dockerfile)
+  fs11.copyFileSync(
+    path11.join(__dirname, "../../support/python-runtime", dockerfile),
+    path11.join(stagedir, dockerfile)
   );
   const image = DockerImage.fromBuild(stagedir, {
     buildArgs: {
@@ -4994,21 +4576,21 @@ function bundle(options) {
     },
     file: dockerfile
   });
-  const outputPath = path12.join(options.out, outputPathSuffix);
+  const outputPath = path11.join(options.out, outputPathSuffix);
   if (hasDeps || hasInstallCommands) {
     image.cp(`${BUNDLER_DEPENDENCIES_CACHE}/.`, outputPath);
   }
-  fs13.cpSync(entry, outputPath, {
+  fs11.cpSync(entry, outputPath, {
     recursive: true
   });
 }
 function stageDependencies(entry, stagedir) {
   const prefixes = ["Pipfile", "pyproject", "poetry", "requirements.txt"];
   let found = false;
-  for (const file of fs13.readdirSync(entry)) {
+  for (const file of fs11.readdirSync(entry)) {
     for (const prefix of prefixes) {
       if (file.startsWith(prefix)) {
-        fs13.copyFileSync(path12.join(entry, file), path12.join(stagedir, file));
+        fs11.copyFileSync(path11.join(entry, file), path11.join(stagedir, file));
         found = true;
       }
     }
@@ -5018,9 +4600,9 @@ function stageDependencies(entry, stagedir) {
 function stageInstallCommands(installCommands, stagedir) {
   let found = false;
   if (installCommands.length > 0) {
-    const filePath = path12.join(stagedir, "sst-deps-install-command.sh");
-    fs13.writeFileSync(filePath, installCommands.join(" && "));
-    fs13.chmodSync(filePath, "755");
+    const filePath = path11.join(stagedir, "sst-deps-install-command.sh");
+    fs11.writeFileSync(filePath, installCommands.join(" && "));
+    fs11.chmodSync(filePath, "755");
     found = true;
   }
   return found;
@@ -5029,7 +4611,7 @@ var __dirname, BUNDLER_DEPENDENCIES_CACHE;
 var init_pythonBundling = __esm({
   "src/runtime/handlers/pythonBundling.ts"() {
     "use strict";
-    __dirname = path12.dirname(url5.fileURLToPath(import.meta.url));
+    __dirname = path11.dirname(url5.fileURLToPath(import.meta.url));
     BUNDLER_DEPENDENCIES_CACHE = "/var/dependencies";
   }
 });
@@ -5039,7 +4621,7 @@ var python_exports = {};
 __export(python_exports, {
   usePythonHandler: () => usePythonHandler
 });
-import path13 from "path";
+import path12 from "path";
 import { exec as exec5, spawn as spawn4 } from "child_process";
 import { promisify as promisify3 } from "util";
 import { Runtime } from "aws-cdk-lib/aws-lambda";
@@ -5052,7 +4634,7 @@ var init_python = __esm({
     init_handlers();
     init_workers();
     init_context();
-    init_server2();
+    init_server();
     init_fs();
     init_pythonBundling();
     execAsync3 = promisify3(exec5);
@@ -5089,8 +4671,8 @@ var init_python = __esm({
           const src = await findSrc(input.handler);
           if (!src)
             throw new Error(`Could not find src for ${input.handler}`);
-          const parsed = path13.parse(path13.relative(src, input.handler));
-          const target = [...parsed.dir.split(path13.sep), parsed.name].join(".");
+          const parsed = path12.parse(path12.relative(src, input.handler));
+          const target = [...parsed.dir.split(path12.sep), parsed.name].join(".");
           const proc = spawn4(
             os3.platform() === "win32" ? "python.exe" : "python3",
             [
@@ -5151,7 +4733,7 @@ var init_python = __esm({
           });
           return {
             type: "success",
-            handler: path13.relative(src, path13.resolve(input.props.handler)).split(path13.sep).join(path13.posix.sep)
+            handler: path12.relative(src, path12.resolve(input.props.handler)).split(path12.sep).join(path12.posix.sep)
           };
         }
       });
@@ -5164,14 +4746,14 @@ var java_exports = {};
 __export(java_exports, {
   useJavaHandler: () => useJavaHandler
 });
-import path14 from "path";
-import fs14 from "fs/promises";
+import path13 from "path";
+import fs12 from "fs/promises";
 import os4 from "os";
 import zipLocal from "zip-local";
 import { spawn as spawn5 } from "child_process";
 import url7 from "url";
 async function getGradleBinary(srcPath) {
-  const gradleWrapperPath = path14.resolve(path14.join(srcPath, "gradlew"));
+  const gradleWrapperPath = path13.resolve(path13.join(srcPath, "gradlew"));
   return await existsAsync(gradleWrapperPath) ? gradleWrapperPath : "gradle";
 }
 var useJavaHandler;
@@ -5181,7 +4763,7 @@ var init_java = __esm({
     init_handlers();
     init_workers();
     init_context();
-    init_server2();
+    init_server();
     init_fs();
     init_project();
     init_process();
@@ -5255,11 +4837,11 @@ var init_java = __esm({
                 cwd: srcPath
               }
             );
-            const buildOutput = path14.join(srcPath, "build", outputDir);
-            const zip = (await fs14.readdir(buildOutput)).find(
+            const buildOutput = path13.join(srcPath, "build", outputDir);
+            const zip = (await fs12.readdir(buildOutput)).find(
               (f) => f.endsWith(".zip")
             );
-            zipLocal.sync.unzip(path14.join(buildOutput, zip)).save(input.out);
+            zipLocal.sync.unzip(path13.join(buildOutput, zip)).save(input.out);
             return {
               type: "success",
               handler: input.props.handler
@@ -5278,7 +4860,7 @@ var init_java = __esm({
 
 // src/stacks/synth.ts
 import * as contextproviders from "sst-aws-cdk/lib/context-providers/index.js";
-import path15 from "path";
+import path14 from "path";
 async function synth(opts) {
   Logger.debug("Synthesizing stacks...");
   const { App: App2 } = await import("../src/constructs/App.js");
@@ -5298,7 +4880,7 @@ async function synth(opts) {
   const identity = await useSTSIdentity();
   opts = {
     ...opts,
-    buildDir: opts.buildDir || path15.join(project.paths.out, "dist")
+    buildDir: opts.buildDir || path14.join(project.paths.out, "dist")
   };
   const cfg = new Configuration();
   await cfg.load();
@@ -5360,420 +4942,763 @@ function formatCustomDomainError(message) {
     `Please double check and make sure the zone exists, or pass in a different zone.`
   ].join(" ");
 }
-var init_synth = __esm({
-  "src/stacks/synth.ts"() {
-    "use strict";
-    init_logger();
-    init_project();
-    init_credentials();
-    init_error();
-    init_dotnet();
+var init_synth = __esm({
+  "src/stacks/synth.ts"() {
+    "use strict";
+    init_logger();
+    init_project();
+    init_credentials();
+    init_error();
+    init_dotnet();
+  }
+});
+
+// src/stacks/remove.ts
+import {
+  CloudFormationClient as CloudFormationClient2,
+  DeleteStackCommand
+} from "@aws-sdk/client-cloudformation";
+async function removeMany(stacks) {
+  await useAWSProvider();
+  const bus = useBus();
+  const complete = /* @__PURE__ */ new Set();
+  const todo = new Set(stacks.map((s) => s.id));
+  const results = {};
+  return new Promise((resolve) => {
+    async function trigger() {
+      for (const stack of stacks) {
+        if (!todo.has(stack.id))
+          continue;
+        Logger.debug("Checking if", stack.id, "can be removed");
+        const waiting = stacks.filter((dependant) => {
+          if (dependant.id === stack.id)
+            return false;
+          if (complete.has(dependant.id))
+            return false;
+          return dependant.dependencies?.some((d) => d.id === stack.id);
+        });
+        if (waiting.length) {
+          Logger.debug(
+            "Waiting on",
+            waiting.map((s) => s.id)
+          );
+          continue;
+        }
+        remove(stack).then((result) => {
+          results[stack.id] = result;
+          complete.add(stack.id);
+          if (isFailed(result.status))
+            stacks.forEach((s) => {
+              if (todo.delete(s.stackName)) {
+                complete.add(s.stackName);
+                results[s.id] = {
+                  status: "DEPENDENCY_FAILED",
+                  outputs: {},
+                  errors: {}
+                };
+                bus.publish("stack.status", {
+                  stackID: s.id,
+                  status: "DEPENDENCY_FAILED"
+                });
+              }
+            });
+          if (complete.size === stacks.length) {
+            resolve(results);
+          }
+          trigger();
+        });
+        todo.delete(stack.id);
+      }
+    }
+    trigger();
+  });
+}
+async function remove(stack) {
+  Logger.debug("Removing stack", stack.id);
+  const cfn = useAWSClient(CloudFormationClient2);
+  try {
+    await cfn.send(
+      new DeleteStackCommand({
+        StackName: stack.stackName
+      })
+    );
+    return monitor(stack.stackName);
+  } catch (ex) {
+    return {
+      errors: {
+        stack: ex.message
+      },
+      outputs: {},
+      status: "UPDATE_FAILED"
+    };
+  }
+}
+var init_remove = __esm({
+  "src/stacks/remove.ts"() {
+    "use strict";
+    init_bus();
+    init_credentials();
+    init_logger();
+    init_monitor();
+  }
+});
+
+// src/stacks/index.ts
+var stacks_exports = {};
+__export(stacks_exports, {
+  STATUSES: () => STATUSES,
+  Stacks: () => stacks_exports,
+  clearAppMetadata: () => clearAppMetadata,
+  deploy: () => deploy,
+  deployMany: () => deployMany,
+  diff: () => diff,
+  filterOutputs: () => filterOutputs,
+  isFailed: () => isFailed,
+  isFinal: () => isFinal,
+  isPending: () => isPending,
+  isSuccess: () => isSuccess,
+  load: () => load,
+  loadAssembly: () => loadAssembly,
+  metadata: () => metadata2,
+  monitor: () => monitor,
+  publishAssets: () => publishAssets4,
+  remove: () => remove,
+  removeMany: () => removeMany,
+  saveAppMetadata: () => saveAppMetadata,
+  synth: () => synth,
+  useAppMetadata: () => useAppMetadata,
+  useMetadata: () => useMetadata
+});
+var init_stacks = __esm({
+  "src/stacks/index.ts"() {
+    "use strict";
+    init_app_metadata();
+    init_assembly();
+    init_build();
+    init_deploy();
+    init_diff();
+    init_metadata();
+    init_synth();
+    init_monitor();
+    init_remove();
+    init_stacks();
+  }
+});
+
+// src/bootstrap.ts
+var bootstrap_exports = {};
+__export(bootstrap_exports, {
+  bootstrapSST: () => bootstrapSST,
+  useBootstrap: () => useBootstrap
+});
+import url8 from "url";
+import path15 from "path";
+import { bold, dim } from "colorette";
+import { spawn as spawn6 } from "child_process";
+import {
+  DescribeStacksCommand as DescribeStacksCommand2,
+  CloudFormationClient as CloudFormationClient3
+} from "@aws-sdk/client-cloudformation";
+import {
+  App,
+  DefaultStackSynthesizer,
+  CfnOutput,
+  Duration,
+  Tags,
+  Stack,
+  RemovalPolicy
+} from "aws-cdk-lib";
+import { Function, Runtime as Runtime2, Code } from "aws-cdk-lib/aws-lambda";
+import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
+import { PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { Queue } from "aws-cdk-lib/aws-sqs";
+import { Rule } from "aws-cdk-lib/aws-events";
+import { SqsQueue } from "aws-cdk-lib/aws-events-targets";
+import {
+  BlockPublicAccess,
+  Bucket,
+  BucketEncryption
+} from "aws-cdk-lib/aws-s3";
+async function loadCDKStatus() {
+  const { cdk } = useProject().config;
+  const client = useAWSClient(CloudFormationClient3);
+  const stackName = cdk?.toolkitStackName || CDK_STACK_NAME;
+  try {
+    const { Stacks: stacks } = await client.send(
+      new DescribeStacksCommand2({ StackName: stackName })
+    );
+    if (!stacks || stacks.length === 0)
+      return false;
+    if (!["CREATE_COMPLETE", "UPDATE_COMPLETE"].includes(stacks[0].StackStatus)) {
+      return false;
+    }
+    const output = stacks[0].Outputs?.find(
+      (o) => o.OutputKey === "BootstrapVersion"
+    );
+    if (!output || parseInt(output.OutputValue) < 14)
+      return false;
+    return true;
+  } catch (e) {
+    if (e.name === "ValidationError" && e.message === `Stack with id ${stackName} does not exist`) {
+      return false;
+    } else {
+      throw e;
+    }
+  }
+}
+async function loadSSTStatus() {
+  const { bootstrap: bootstrap2 } = useProject().config;
+  const cf = useAWSClient(CloudFormationClient3);
+  const stackName = bootstrap2?.stackName || SST_STACK_NAME;
+  let result;
+  try {
+    result = await cf.send(
+      new DescribeStacksCommand2({
+        StackName: stackName
+      })
+    );
+  } catch (e) {
+    if (e.Code === "ValidationError" && e.message === `Stack with id ${stackName} does not exist`) {
+      return null;
+    }
+    throw e;
+  }
+  let version2, bucket;
+  (result.Stacks[0].Outputs || []).forEach((o) => {
+    if (o.OutputKey === OUTPUT_VERSION) {
+      version2 = o.OutputValue;
+    } else if (o.OutputKey === OUTPUT_BUCKET) {
+      bucket = o.OutputValue;
+    }
+  });
+  if (!version2 || !bucket) {
+    return null;
+  }
+  return { version: version2, bucket };
+}
+async function bootstrapSST() {
+  const { region, bootstrap: bootstrap2, cdk } = useProject().config;
+  const app = new App();
+  const stackName = bootstrap2?.stackName || SST_STACK_NAME;
+  const stack = new Stack(app, stackName, {
+    env: {
+      region
+    },
+    synthesizer: new DefaultStackSynthesizer({
+      qualifier: cdk?.qualifier,
+      fileAssetsBucketName: cdk?.fileAssetsBucketName
+    })
+  });
+  for (const [key, value] of Object.entries(bootstrap2?.tags || {})) {
+    Tags.of(app).add(key, value);
   }
-});
-
-// src/stacks/remove.ts
-import {
-  CloudFormationClient as CloudFormationClient2,
-  DeleteStackCommand
-} from "@aws-sdk/client-cloudformation";
-async function removeMany(stacks) {
-  await useAWSProvider();
-  const bus = useBus();
-  const complete = /* @__PURE__ */ new Set();
-  const todo = new Set(stacks.map((s) => s.id));
-  const results = {};
-  return new Promise((resolve) => {
-    async function trigger() {
-      for (const stack of stacks) {
-        if (!todo.has(stack.id))
-          continue;
-        Logger.debug("Checking if", stack.id, "can be removed");
-        const waiting = stacks.filter((dependant) => {
-          if (dependant.id === stack.id)
-            return false;
-          if (complete.has(dependant.id))
-            return false;
-          return dependant.dependencies?.some((d) => d.id === stack.id);
-        });
-        if (waiting.length) {
-          Logger.debug(
-            "Waiting on",
-            waiting.map((s) => s.id)
-          );
-          continue;
+  const bucket = new Bucket(stack, region, {
+    encryption: BucketEncryption.S3_MANAGED,
+    removalPolicy: RemovalPolicy.DESTROY,
+    autoDeleteObjects: true,
+    blockPublicAccess: cdk?.publicAccessBlockConfiguration !== false ? BlockPublicAccess.BLOCK_ALL : void 0
+  });
+  const fn = new Function(stack, "MetadataHandler", {
+    code: Code.fromAsset(
+      path15.resolve(__dirname2, "support/bootstrap-metadata-function")
+    ),
+    handler: "index.handler",
+    runtime: region?.startsWith("us-gov-") || region?.startsWith("cn-") ? Runtime2.NODEJS_16_X : Runtime2.NODEJS_18_X,
+    environment: {
+      BUCKET_NAME: bucket.bucketName
+    },
+    initialPolicy: [
+      new PolicyStatement({
+        actions: ["cloudformation:DescribeStacks"],
+        resources: ["*"]
+      }),
+      new PolicyStatement({
+        actions: ["s3:PutObject", "s3:DeleteObject"],
+        resources: [bucket.bucketArn + "/*"]
+      }),
+      new PolicyStatement({
+        actions: ["iot:Publish"],
+        resources: [
+          `arn:${stack.partition}:iot:${stack.region}:${stack.account}:topic//sst/*`
+        ]
+      })
+    ]
+  });
+  const queue = new Queue(stack, "MetadataQueue", {
+    visibilityTimeout: Duration.seconds(30),
+    retentionPeriod: Duration.minutes(2)
+  });
+  fn.addEventSource(new SqsEventSource(queue));
+  const rule = new Rule(stack, "MetadataRule", {
+    eventPattern: {
+      source: ["aws.cloudformation"],
+      detailType: ["CloudFormation Stack Status Change"],
+      detail: {
+        "status-details": {
+          status: [
+            "CREATE_COMPLETE",
+            "UPDATE_COMPLETE",
+            "UPDATE_ROLLBACK_COMPLETE",
+            "ROLLBACK_COMPLETE",
+            "DELETE_COMPLETE"
+          ]
         }
-        remove(stack).then((result) => {
-          results[stack.id] = result;
-          complete.add(stack.id);
-          if (isFailed(result.status))
-            stacks.forEach((s) => {
-              if (todo.delete(s.stackName)) {
-                complete.add(s.stackName);
-                results[s.id] = {
-                  status: "DEPENDENCY_FAILED",
-                  outputs: {},
-                  errors: {}
-                };
-                bus.publish("stack.status", {
-                  stackID: s.id,
-                  status: "DEPENDENCY_FAILED"
-                });
-              }
-            });
-          if (complete.size === stacks.length) {
-            resolve(results);
-          }
-          trigger();
-        });
-        todo.delete(stack.id);
       }
     }
-    trigger();
   });
-}
-async function remove(stack) {
-  Logger.debug("Removing stack", stack.id);
-  const cfn = useAWSClient(CloudFormationClient2);
-  try {
-    await cfn.send(
-      new DeleteStackCommand({
-        StackName: stack.stackName
-      })
+  rule.addTarget(
+    new SqsQueue(queue, {
+      retryAttempts: 10
+    })
+  );
+  new CfnOutput(stack, OUTPUT_VERSION, { value: LATEST_VERSION });
+  new CfnOutput(stack, OUTPUT_BUCKET, { value: bucket.bucketName });
+  const asm = app.synth();
+  const result = await stacks_exports.deploy(asm.stacks[0]);
+  if (stacks_exports.isFailed(result.status)) {
+    throw new VisibleError(
+      `Failed to deploy bootstrap stack:
+${JSON.stringify(
+        result.errors,
+        null,
+        4
+      )}`
     );
-    return monitor(stack.stackName);
-  } catch (ex) {
-    return {
-      errors: {
-        stack: ex.message
-      },
-      outputs: {},
-      status: "UPDATE_FAILED"
-    };
   }
 }
-var init_remove = __esm({
-  "src/stacks/remove.ts"() {
+async function bootstrapCDK() {
+  const identity = await useSTSIdentity();
+  const credentials = await useAWSCredentials();
+  const { region, profile, cdk } = useProject().config;
+  cdk || {};
+  await new Promise((resolve, reject) => {
+    const proc = spawn6(
+      [
+        "npx",
+        "cdk",
+        "bootstrap",
+        `aws://${identity.Account}/${region}`,
+        "--no-version-reporting",
+        ...cdk?.publicAccessBlockConfiguration === false ? ["--public-access-block-configuration", "false"] : cdk?.publicAccessBlockConfiguration === true ? ["--public-access-block-configuration", "false"] : [],
+        ...cdk?.toolkitStackName ? ["--toolkit-stack-name", cdk.toolkitStackName] : [],
+        ...cdk?.qualifier ? ["--qualifier", cdk.qualifier] : [],
+        ...cdk?.fileAssetsBucketName ? ["--toolkit-bucket-name", cdk.fileAssetsBucketName] : []
+      ].join(" "),
+      {
+        env: {
+          ...process.env,
+          AWS_ACCESS_KEY_ID: credentials.accessKeyId,
+          AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
+          AWS_SESSION_TOKEN: credentials.sessionToken,
+          AWS_REGION: region,
+          AWS_PROFILE: profile
+        },
+        stdio: "pipe",
+        shell: true
+      }
+    );
+    let stderr = "";
+    proc.stdout.on("data", (data2) => {
+      Logger.debug(data2.toString());
+    });
+    proc.stderr.on("data", (data2) => {
+      Logger.debug(data2.toString());
+      stderr += data2;
+    });
+    proc.on("exit", (code) => {
+      Logger.debug("CDK bootstrap exited with code " + code);
+      if (code === 0) {
+        resolve();
+      } else {
+        console.log(bold(dim(stderr)));
+        reject(new VisibleError(`Failed to bootstrap`));
+      }
+    });
+  });
+}
+var CDK_STACK_NAME, SST_STACK_NAME, OUTPUT_VERSION, OUTPUT_BUCKET, LATEST_VERSION, __dirname2, useBootstrap;
+var init_bootstrap = __esm({
+  "src/bootstrap.ts"() {
     "use strict";
-    init_bus();
+    init_project();
+    init_spinner();
+    init_context();
     init_credentials();
+    init_error();
     init_logger();
-    init_monitor();
+    init_stacks();
+    CDK_STACK_NAME = "CDKToolkit";
+    SST_STACK_NAME = "SSTBootstrap";
+    OUTPUT_VERSION = "Version";
+    OUTPUT_BUCKET = "BucketName";
+    LATEST_VERSION = "7";
+    __dirname2 = url8.fileURLToPath(new URL(".", import.meta.url));
+    useBootstrap = Context.memo(async () => {
+      Logger.debug("Initializing bootstrap context");
+      let [cdkStatus, sstStatus] = await Promise.all([
+        loadCDKStatus(),
+        loadSSTStatus()
+      ]);
+      Logger.debug("Loaded bootstrap status");
+      const needToBootstrapCDK = !cdkStatus;
+      const needToBootstrapSST = !sstStatus || sstStatus.version !== LATEST_VERSION;
+      if (needToBootstrapCDK || needToBootstrapSST) {
+        const spinner = createSpinner(
+          "Deploying bootstrap stack, this only needs to happen once"
+        ).start();
+        if (needToBootstrapCDK) {
+          await bootstrapCDK();
+        }
+        if (needToBootstrapSST) {
+          await bootstrapSST();
+          sstStatus = await loadSSTStatus();
+          if (!sstStatus)
+            throw new VisibleError("Failed to load bootstrap stack status");
+        }
+        spinner.succeed();
+      }
+      Logger.debug("Bootstrap context initialized", sstStatus);
+      return sstStatus;
+    }, "Bootstrap");
   }
 });
 
-// src/stacks/index.ts
-var stacks_exports = {};
-__export(stacks_exports, {
-  STATUSES: () => STATUSES,
-  Stacks: () => stacks_exports,
-  clearAppMetadata: () => clearAppMetadata,
-  deploy: () => deploy,
-  deployMany: () => deployMany,
-  diff: () => diff,
-  filterOutputs: () => filterOutputs,
-  isFailed: () => isFailed,
-  isFinal: () => isFinal,
-  isPending: () => isPending,
-  isSuccess: () => isSuccess,
-  load: () => load,
-  loadAssembly: () => loadAssembly,
-  metadata: () => metadata2,
-  metadataForStack: () => metadataForStack,
-  monitor: () => monitor,
-  publishAssets: () => publishAssets4,
-  remove: () => remove,
-  removeMany: () => removeMany,
-  saveAppMetadata: () => saveAppMetadata,
-  synth: () => synth,
-  useAppMetadata: () => useAppMetadata,
-  useMetadata: () => useMetadata
-});
-var init_stacks = __esm({
-  "src/stacks/index.ts"() {
+// src/cli/local/router.ts
+import * as trpc from "@trpc/server";
+var router2;
+var init_router = __esm({
+  "src/cli/local/router.ts"() {
     "use strict";
-    init_app_metadata();
-    init_assembly();
-    init_build();
-    init_deploy();
-    init_diff();
-    init_metadata();
-    init_synth();
-    init_monitor();
-    init_remove();
-    init_stacks();
+    init_project();
+    init_bus();
+    init_credentials();
+    router2 = trpc.router().query("getCredentials", {
+      async resolve({ ctx }) {
+        const project = useProject();
+        const credentials = await useAWSCredentials();
+        return {
+          region: project.config.region,
+          credentials: {
+            accessKeyId: credentials.accessKeyId,
+            secretAccessKey: credentials.secretAccessKey,
+            sessionToken: credentials.sessionToken
+          }
+        };
+      }
+    }).query("getState", {
+      async resolve({ ctx }) {
+        return ctx.state;
+      }
+    }).mutation("deploy", {
+      async resolve() {
+        return;
+      }
+    }).subscription("onStateChange", {
+      async resolve({ ctx }) {
+        const bus = useBus();
+        return new trpc.Subscription((emit) => {
+          const sub = bus.subscribe("local.patches", (evt) => {
+            emit.data(evt.properties);
+          });
+          return () => {
+            bus.unsubscribe(sub);
+          };
+        });
+      }
+    });
   }
 });
 
-// src/bootstrap.ts
-import url8 from "url";
-import path16 from "path";
-import { bold, dim } from "colorette";
-import { spawn as spawn6 } from "child_process";
-import {
-  DescribeStacksCommand as DescribeStacksCommand2,
-  CloudFormationClient as CloudFormationClient3
-} from "@aws-sdk/client-cloudformation";
-import {
-  App,
-  DefaultStackSynthesizer,
-  CfnOutput,
-  Duration,
-  Tags,
-  Stack,
-  RemovalPolicy
-} from "aws-cdk-lib";
-import { Function, Runtime as Runtime2, Code } from "aws-cdk-lib/aws-lambda";
-import { SqsEventSource } from "aws-cdk-lib/aws-lambda-event-sources";
-import { PolicyStatement } from "aws-cdk-lib/aws-iam";
-import { Queue } from "aws-cdk-lib/aws-sqs";
-import { Rule } from "aws-cdk-lib/aws-events";
-import { SqsQueue } from "aws-cdk-lib/aws-events-targets";
-import {
-  BlockPublicAccess,
-  Bucket,
-  BucketEncryption
-} from "aws-cdk-lib/aws-s3";
-async function loadCDKStatus() {
-  const { cdk } = useProject().config;
-  const client = useAWSClient(CloudFormationClient3);
-  const stackName = cdk?.toolkitStackName || CDK_STACK_NAME;
-  try {
-    const { Stacks: stacks } = await client.send(
-      new DescribeStacksCommand2({ StackName: stackName })
-    );
-    if (!stacks || stacks.length === 0)
-      return false;
-    if (!["CREATE_COMPLETE", "UPDATE_COMPLETE"].includes(stacks[0].StackStatus)) {
-      return false;
-    }
-    const output = stacks[0].Outputs?.find(
-      (o) => o.OutputKey === "BootstrapVersion"
+// src/cli/local/server.ts
+var server_exports2 = {};
+__export(server_exports2, {
+  useLocalServer: () => useLocalServer,
+  useLocalServerConfig: () => useLocalServerConfig
+});
+import { produceWithPatches, enablePatches } from "immer";
+import express2 from "express";
+import fs13 from "fs/promises";
+import { WebSocketServer } from "ws";
+import https3 from "https";
+import http from "http";
+import { applyWSSHandler } from "@trpc/server/adapters/ws/dist/trpc-server-adapters-ws.cjs.js";
+import { optimise } from "dendriform-immer-patch-optimiser";
+import { sync } from "cross-spawn";
+import getPort2 from "get-port";
+async function useLocalServer(opts) {
+  const cfg = await useLocalServerConfig();
+  const project = useProject();
+  let state2 = {
+    app: project.config.name,
+    stage: project.config.stage,
+    bootstrap: project.config.bootstrap,
+    live: opts.live,
+    stacks: {
+      status: "idle"
+    },
+    functions: {}
+  };
+  const rest = express2();
+  rest.all(`/ping`, (req, res) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Methods", "GET, PUT, PATCH, POST, DELETE");
+    res.header(
+      "Access-Control-Allow-Headers",
+      req.header("access-control-request-headers")
     );
-    if (!output || parseInt(output.OutputValue) < 14)
-      return false;
-    return true;
-  } catch (e) {
-    if (e.name === "ValidationError" && e.message === `Stack with id ${stackName} does not exist`) {
-      return false;
-    } else {
-      throw e;
+    res.sendStatus(200);
+  });
+  rest.all(
+    `/proxy*`,
+    express2.raw({
+      type: "*/*",
+      limit: "1024mb"
+    }),
+    (req, res) => {
+      res.header("Access-Control-Allow-Origin", "*");
+      res.header(
+        "Access-Control-Allow-Methods",
+        "GET, PUT, PATCH, POST, DELETE"
+      );
+      res.header(
+        "Access-Control-Allow-Headers",
+        req.header("access-control-request-headers")
+      );
+      if (req.method === "OPTIONS")
+        return res.send();
+      const u = new URL(req.url.substring(7));
+      const forward = https3.request(
+        u,
+        {
+          headers: {
+            ...req.headers,
+            host: u.hostname
+          },
+          method: req.method
+        },
+        (proxied) => {
+          res.status(proxied.statusCode);
+          for (const [key, value] of Object.entries(proxied.headers)) {
+            res.header(key, value);
+          }
+          proxied.pipe(res);
+        }
+      );
+      if (req.method !== "GET" && req.method !== "DELETE" && req.method !== "HEAD" && req.body)
+        forward.write(req.body);
+      forward.end();
+      forward.on("error", (e) => {
+        console.log(e.message);
+      });
     }
-  }
-}
-async function loadSSTStatus() {
-  const { bootstrap } = useProject().config;
-  const cf = useAWSClient(CloudFormationClient3);
-  const stackName = bootstrap?.stackName || SST_STACK_NAME;
-  let result;
-  try {
-    result = await cf.send(
-      new DescribeStacksCommand2({
-        StackName: stackName
-      })
-    );
-  } catch (e) {
-    if (e.Code === "ValidationError" && e.message === `Stack with id ${stackName} does not exist`) {
-      return null;
+  );
+  const server = await (async () => {
+    const result2 = sync("mkcert", ["--help"]);
+    const KEY_PATH = ".sst/localhost-key.pem";
+    const CERT_PATH = ".sst/localhost.pem";
+    if (result2.status === 0) {
+      try {
+        await Promise.all([fs13.access(KEY_PATH), fs13.access(CERT_PATH)]);
+      } catch (e) {
+        sync("mkcert", ["localhost"], {
+          cwd: ".sst"
+        });
+      }
+      const [key, cert] = await Promise.all([
+        fs13.readFile(KEY_PATH),
+        fs13.readFile(CERT_PATH)
+      ]);
+      return https3.createServer(
+        {
+          key,
+          cert
+        },
+        rest
+      );
     }
-    throw e;
-  }
-  let version2, bucket;
-  (result.Stacks[0].Outputs || []).forEach((o) => {
-    if (o.OutputKey === OUTPUT_VERSION) {
-      version2 = o.OutputValue;
-    } else if (o.OutputKey === OUTPUT_BUCKET) {
-      bucket = o.OutputValue;
+    return http.createServer({}, rest);
+  })();
+  const wss = new WebSocketServer({ server });
+  wss.on("connection", (socket, req) => {
+    if (req.headers.origin?.endsWith("localhost:3000"))
+      return;
+    if (req.headers.origin?.endsWith("localhost:3001"))
+      return;
+    if (req.headers.origin?.endsWith("console.serverless-stack.com"))
+      return;
+    if (req.headers.origin?.endsWith("console.sst.dev"))
+      return;
+    if (req.headers.origin?.endsWith("--sst-console.netlify.app"))
+      return;
+    console.log("Rejecting unauthorized connection from " + req.headers.origin);
+    socket.terminate();
+  });
+  server.listen(cfg.port);
+  const handler = applyWSSHandler({
+    wss,
+    router: router2,
+    createContext() {
+      return {
+        state: state2
+      };
     }
   });
-  if (!version2 || !bucket) {
-    return null;
-  }
-  return { version: version2, bucket };
-}
-async function bootstrapSST() {
-  const { region, bootstrap, cdk } = useProject().config;
-  const app = new App();
-  const stackName = bootstrap?.stackName || SST_STACK_NAME;
-  const stack = new Stack(app, stackName, {
-    env: {
-      region
-    },
-    synthesizer: new DefaultStackSynthesizer({
-      qualifier: cdk?.qualifier,
-      fileAssetsBucketName: cdk?.fileAssetsBucketName
-    })
+  process.on("SIGTERM", () => {
+    handler.broadcastReconnectNotification();
+    wss.close();
   });
-  for (const [key, value] of Object.entries(bootstrap?.tags || {})) {
-    Tags.of(app).add(key, value);
+  const bus = useBus();
+  const pending = [];
+  function updateState(cb) {
+    const [next, patches] = produceWithPatches(state2, cb);
+    if (!patches.length)
+      return;
+    const scheduled = pending.length;
+    pending.push(...optimise(state2, patches));
+    if (!scheduled)
+      setTimeout(() => {
+        bus.publish("local.patches", pending);
+        pending.splice(0, pending.length);
+      }, 0);
+    state2 = next;
   }
-  const bucket = new Bucket(stack, region, {
-    encryption: BucketEncryption.S3_MANAGED,
-    removalPolicy: RemovalPolicy.DESTROY,
-    autoDeleteObjects: true,
-    blockPublicAccess: cdk?.publicAccessBlockConfiguration !== false ? BlockPublicAccess.BLOCK_ALL : void 0
+  function updateFunction(id, cb) {
+    return updateState((draft) => {
+      let func = draft.functions[id];
+      if (!func) {
+        func = {
+          warm: true,
+          state: "idle",
+          issues: {},
+          invocations: []
+        };
+        draft.functions[id] = func;
+      }
+      cb(func);
+    });
+  }
+  bus.subscribe("function.invoked", (evt) => {
+    updateFunction(evt.properties.functionID, (draft) => {
+      if (draft.invocations.length >= 25)
+        draft.invocations.pop();
+      draft.invocations.unshift({
+        id: evt.properties.context.awsRequestId,
+        request: evt.properties.event,
+        times: {
+          start: Date.now()
+        },
+        logs: []
+      });
+    });
   });
-  const fn = new Function(stack, "MetadataHandler", {
-    code: Code.fromAsset(
-      path16.resolve(__dirname2, "support/bootstrap-metadata-function")
-    ),
-    handler: "index.handler",
-    runtime: region?.startsWith("us-gov-") || region?.startsWith("cn-") ? Runtime2.NODEJS_16_X : Runtime2.NODEJS_18_X,
-    environment: {
-      BUCKET_NAME: bucket.bucketName
-    },
-    initialPolicy: [
-      new PolicyStatement({
-        actions: ["cloudformation:DescribeStacks"],
-        resources: ["*"]
-      }),
-      new PolicyStatement({
-        actions: ["s3:PutObject", "s3:DeleteObject"],
-        resources: [bucket.bucketArn + "/*"]
-      }),
-      new PolicyStatement({
-        actions: ["iot:Publish"],
-        resources: [
-          `arn:${stack.partition}:iot:${stack.region}:${stack.account}:topic//sst/*`
-        ]
-      })
-    ]
+  bus.subscribe("worker.stdout", (evt) => {
+    updateFunction(evt.properties.functionID, (draft) => {
+      const entry = draft.invocations.find(
+        (i) => i.id === evt.properties.requestID
+      );
+      if (!entry)
+        return;
+      entry.logs.push({
+        timestamp: Date.now(),
+        message: evt.properties.message
+      });
+    });
   });
-  const queue = new Queue(stack, "MetadataQueue", {
-    visibilityTimeout: Duration.seconds(30),
-    retentionPeriod: Duration.minutes(2)
+  bus.subscribe("function.success", (evt) => {
+    updateFunction(evt.properties.functionID, (draft) => {
+      const invocation = draft.invocations.find(
+        (x) => x.id === evt.properties.requestID
+      );
+      if (!invocation)
+        return;
+      invocation.response = {
+        type: "success",
+        data: evt.properties.body
+      };
+      invocation.times.end = Date.now();
+    });
   });
-  fn.addEventSource(new SqsEventSource(queue));
-  const rule = new Rule(stack, "MetadataRule", {
-    eventPattern: {
-      source: ["aws.cloudformation"],
-      detailType: ["CloudFormation Stack Status Change"],
-      detail: {
-        "status-details": {
-          status: [
-            "CREATE_COMPLETE",
-            "UPDATE_COMPLETE",
-            "UPDATE_ROLLBACK_COMPLETE",
-            "ROLLBACK_COMPLETE",
-            "DELETE_COMPLETE"
-          ]
+  bus.subscribe("function.error", (evt) => {
+    updateFunction(evt.properties.functionID, (draft) => {
+      const invocation = draft.invocations.find(
+        (x) => x.id === evt.properties.requestID
+      );
+      if (!invocation)
+        return;
+      invocation.response = {
+        type: "failure",
+        error: {
+          errorMessage: evt.properties.errorMessage,
+          stackTrace: evt.properties.trace || []
         }
-      }
-    }
+      };
+      invocation.times.end = Date.now();
+    });
   });
-  rule.addTarget(
-    new SqsQueue(queue, {
-      retryAttempts: 10
-    })
-  );
-  new CfnOutput(stack, OUTPUT_VERSION, { value: LATEST_VERSION });
-  new CfnOutput(stack, OUTPUT_BUCKET, { value: bucket.bucketName });
-  const asm = app.synth();
-  const result = await stacks_exports.deploy(asm.stacks[0]);
-  if (stacks_exports.isFailed(result.status)) {
-    throw new VisibleError(
-      `Failed to deploy bootstrap stack:
-${JSON.stringify(
-        result.errors,
-        null,
-        4
-      )}`
-    );
-  }
+  const result = {
+    updateState,
+    updateFunction
+  };
+  return result;
 }
-async function bootstrapCDK() {
-  const identity = await useSTSIdentity();
-  const credentials = await useAWSCredentials();
-  const { region, profile, cdk } = useProject().config;
-  cdk || {};
-  await new Promise((resolve, reject) => {
-    const proc = spawn6(
-      [
-        "npx",
-        "cdk",
-        "bootstrap",
-        `aws://${identity.Account}/${region}`,
-        "--no-version-reporting",
-        ...cdk?.publicAccessBlockConfiguration === false ? ["--public-access-block-configuration", "false"] : cdk?.publicAccessBlockConfiguration === true ? ["--public-access-block-configuration", "false"] : [],
-        ...cdk?.toolkitStackName ? ["--toolkit-stack-name", cdk.toolkitStackName] : [],
-        ...cdk?.qualifier ? ["--qualifier", cdk.qualifier] : [],
-        ...cdk?.fileAssetsBucketName ? ["--toolkit-bucket-name", cdk.fileAssetsBucketName] : []
-      ].join(" "),
-      {
-        env: {
-          ...process.env,
-          AWS_ACCESS_KEY_ID: credentials.accessKeyId,
-          AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
-          AWS_SESSION_TOKEN: credentials.sessionToken,
-          AWS_REGION: region,
-          AWS_PROFILE: profile
-        },
-        stdio: "pipe",
-        shell: true
-      }
-    );
-    let stderr = "";
-    proc.stdout.on("data", (data2) => {
-      Logger.debug(data2.toString());
-    });
-    proc.stderr.on("data", (data2) => {
-      Logger.debug(data2.toString());
-      stderr += data2;
-    });
-    proc.on("exit", (code) => {
-      Logger.debug("CDK bootstrap exited with code " + code);
-      if (code === 0) {
-        resolve();
-      } else {
-        console.log(bold(dim(stderr)));
-        reject(new VisibleError(`Failed to bootstrap`));
-      }
+var useLocalServerConfig;
+var init_server2 = __esm({
+  "src/cli/local/server.ts"() {
+    "use strict";
+    init_router();
+    init_project();
+    init_bus();
+    init_context();
+    enablePatches();
+    useLocalServerConfig = Context.memo(async () => {
+      const project = useProject();
+      const port = await getPort2({
+        port: 13557
+      });
+      return {
+        port,
+        url: `https://console.sst.dev/${project.config.name}/${project.config.stage}${port !== 13557 ? `?_port=${port}` : ""}`
+      };
     });
-  });
+  }
+});
+
+// src/cli/ui/header.ts
+var header_exports = {};
+__export(header_exports, {
+  printConsole: () => printConsole,
+  printHeader: () => printHeader
+});
+async function printHeader(input) {
+  const project = useProject();
+  Colors.line(
+    `${Colors.primary.bold(`SST v${project.version}`)}  ${input.hint ? Colors.dim(`ready!`) : ""}`
+  );
+  Colors.gap();
+  Colors.line(
+    `${Colors.primary(`\u279C`)}  ${Colors.bold("App:")}     ${project.config.name}`
+  );
+  Colors.line(
+    `${Colors.primary(` `)}  ${Colors.bold("Stage:")}   ${project.config.stage}`
+  );
+  if (input.console) {
+    const local = await useLocalServerConfig();
+    Colors.line(
+      `${Colors.primary(` `)}  ${Colors.bold("Console:")} ${Colors.link(
+        local.url
+      )}`
+    );
+  }
+  Colors.gap();
 }
-var CDK_STACK_NAME, SST_STACK_NAME, OUTPUT_VERSION, OUTPUT_BUCKET, LATEST_VERSION, __dirname2, useBootstrap;
-var init_bootstrap = __esm({
-  "src/bootstrap.ts"() {
+function printConsole() {
+}
+var init_header = __esm({
+  "src/cli/ui/header.ts"() {
     "use strict";
     init_project();
-    init_spinner();
-    init_context();
-    init_credentials();
-    init_error();
-    init_logger();
-    init_stacks();
-    CDK_STACK_NAME = "CDKToolkit";
-    SST_STACK_NAME = "SSTBootstrap";
-    OUTPUT_VERSION = "Version";
-    OUTPUT_BUCKET = "BucketName";
-    LATEST_VERSION = "7";
-    __dirname2 = url8.fileURLToPath(new URL(".", import.meta.url));
-    useBootstrap = Context.memo(async () => {
-      Logger.debug("Initializing bootstrap context");
-      let [cdkStatus, sstStatus] = await Promise.all([
-        loadCDKStatus(),
-        loadSSTStatus()
-      ]);
-      Logger.debug("Loaded bootstrap status");
-      const needToBootstrapCDK = !cdkStatus;
-      const needToBootstrapSST = !sstStatus || sstStatus.version !== LATEST_VERSION;
-      if (needToBootstrapCDK || needToBootstrapSST) {
-        const spinner = createSpinner(
-          "Deploying bootstrap stack, this only needs to happen once"
-        ).start();
-        if (needToBootstrapCDK) {
-          await bootstrapCDK();
-        }
-        if (needToBootstrapSST) {
-          await bootstrapSST();
-          sstStatus = await loadSSTStatus();
-          if (!sstStatus)
-            throw new VisibleError("Failed to load bootstrap stack status");
-        }
-        spinner.succeed();
-      }
-      Logger.debug("Bootstrap context initialized", sstStatus);
-      return sstStatus;
-    }, "Bootstrap");
+    init_colors();
+    init_server2();
   }
 });
 
@@ -5815,7 +5740,7 @@ var init_iot = __esm({
       const endpoint = await useIOTEndpoint();
       const creds = await useAWSCredentials();
       const project = useProject();
-      const bootstrap = await useBootstrap();
+      const bootstrap2 = await useBootstrap();
       const s3 = useAWSClient(S3Client3);
       async function encode(input) {
         const id = Math.random().toString();
@@ -5824,7 +5749,7 @@ var init_iot = __esm({
           const key = `pointers/${id}`;
           await s3.send(
             new PutObjectCommand2({
-              Bucket: bootstrap.bucket,
+              Bucket: bootstrap2.bucket,
               Key: key,
               Body: json
             })
@@ -5838,7 +5763,7 @@ var init_iot = __esm({
                 type: "pointer",
                 properties: {
                   key,
-                  bucket: bootstrap.bucket
+                  bucket: bootstrap2.bucket
                 }
               })
             }
@@ -5990,15 +5915,10 @@ function printDeploymentResults(assembly, results, remove4) {
       Colors.bold(remove4 ? ` Removed:` : ` Deployed:`)
     );
     for (const [stack, result] of success) {
-      const outputs = Object.entries(result.outputs).filter(
-        ([key, _]) => !key.includes("SstSiteEnv")
-      );
       Colors.line(`   ${Colors.dim(stackNameToId(stack))}`);
-      if (outputs.length > 0) {
-        for (const key of Object.keys(Object.fromEntries(outputs)).sort()) {
-          const value = result.outputs[key];
-          Colors.line(`   ${Colors.bold.dim(key + ":")} ${value}`);
-        }
+      for (const key of Object.keys(result.outputs).sort()) {
+        const value = result.outputs[key];
+        Colors.line(`   ${Colors.bold.dim(key + ":")} ${value}`);
       }
     }
     Colors.gap();
@@ -6137,16 +6057,16 @@ __export(pothos_exports, {
 import babel from "@babel/core";
 import generator from "@babel/generator";
 import esbuild3 from "esbuild";
-import fs15 from "fs/promises";
-import path17 from "path";
+import fs14 from "fs/promises";
+import path16 from "path";
 import url9 from "url";
 async function generate(opts) {
   const { printSchema, lexicographicSortSchema } = await import("graphql");
   const contents = await extractSchema(opts);
-  const out = path17.join(path17.dirname(opts.schema), "out.mjs");
-  await fs15.writeFile(out, contents, "utf8");
+  const out = path16.join(path16.dirname(opts.schema), "out.mjs");
+  await fs14.writeFile(out, contents, "utf8");
   const { schema } = await import(url9.pathToFileURL(out).href + "?bust=" + Date.now());
-  await fs15.rm(out);
+  await fs14.rm(out);
   const schemaAsString = printSchema(lexicographicSortSchema(schema));
   return schemaAsString;
 }
@@ -6294,10 +6214,10 @@ var pothos_exports2 = {};
 __export(pothos_exports2, {
   usePothosBuilder: () => usePothosBuilder
 });
-import fs16 from "fs/promises";
+import fs15 from "fs/promises";
 import { exec as exec6 } from "child_process";
 import { promisify as promisify4 } from "util";
-import path18 from "path";
+import path17 from "path";
 var execAsync4, usePothosBuilder;
 var init_pothos2 = __esm({
   "src/cli/commands/plugins/pothos.ts"() {
@@ -6315,7 +6235,7 @@ var init_pothos2 = __esm({
           const schema = await pothos_exports.generate({
             schema: route.schema
           });
-          await fs16.writeFile(route.output, schema);
+          await fs15.writeFile(route.output, schema);
           if (Array.isArray(route.commands) && route.commands.length > 0) {
             await Promise.all(route.commands.map((cmd) => execAsync4(cmd)));
           }
@@ -6331,9 +6251,9 @@ var init_pothos2 = __esm({
         if (evt.properties.file.endsWith("out.mjs"))
           return;
         for (const route of routes) {
-          const dir = path18.dirname(route.schema);
-          const relative = path18.relative(dir, evt.properties.file);
-          if (relative && !relative.startsWith("..") && !path18.isAbsolute(relative))
+          const dir = path17.dirname(route.schema);
+          const relative = path17.relative(dir, evt.properties.file);
+          if (relative && !relative.startsWith("..") && !path17.isAbsolute(relative))
             build2(route);
         }
       });
@@ -6359,7 +6279,7 @@ __export(kysely_exports, {
 import { Kysely } from "kysely";
 import { DataApiDialect } from "kysely-data-api";
 import { RDSData } from "@aws-sdk/client-rds-data";
-import * as fs17 from "fs/promises";
+import * as fs16 from "fs/promises";
 import {
   DatabaseMetadata,
   EnumCollection,
@@ -6431,7 +6351,7 @@ var init_kysely = __esm({
         };
         const serializer = new Serializer();
         const data2 = serializer.serialize(nodes);
-        await fs17.writeFile(db.types.path, data2);
+        await fs16.writeFile(db.types.path, data2);
       }
       bus.subscribe("stacks.metadata", (evt) => {
         const constructs = Object.values(evt.properties).flat();
@@ -6568,12 +6488,39 @@ function parse(ssmName) {
     prop: parts.slice(6).join("/")
   };
 }
+async function restartFunction(arn) {
+  const lambda = useAWSClient(LambdaClient);
+  try {
+    const config = await lambda.send(
+      new GetFunctionConfigurationCommand({
+        FunctionName: arn
+      })
+    );
+    await lambda.send(
+      new UpdateFunctionConfigurationCommand({
+        FunctionName: arn,
+        Environment: {
+          Variables: {
+            ...config.Environment?.Variables || {},
+            [SECRET_UPDATED_AT_ENV]: Date.now().toString()
+          }
+        }
+      })
+    );
+    return true;
+  } catch (e) {
+    if (e.name === "ResourceNotFoundException" && e.message.startsWith("Function not found")) {
+      return;
+    }
+  }
+}
 var Config, FALLBACK_STAGE, SECRET_UPDATED_AT_ENV, PREFIX;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     init_project();
     init_credentials();
+    init_iot();
     init_stacks();
     ((Config2) => {
       async function parameters() {
@@ -6628,10 +6575,10 @@ var init_config = __esm({
         return result;
       }
       Config2.secrets = secrets2;
-      async function env2() {
+      async function env() {
         const project = useProject();
         const parameters2 = await Config2.parameters();
-        const env3 = {
+        const env2 = {
           SST_APP: project.config.name,
           SST_STAGE: project.config.stage,
           ...pipe2(
@@ -6640,12 +6587,12 @@ var init_config = __esm({
             Object.fromEntries
           )
         };
-        return env3;
+        return env2;
       }
-      Config2.env = env2;
+      Config2.env = env;
       async function setSecret(input) {
         const ssm = useAWSClient(SSMClient);
-        const result = await ssm.send(
+        await ssm.send(
           new PutParameterCommand({
             Name: pathFor({
               id: input.key,
@@ -6658,6 +6605,9 @@ var init_config = __esm({
             Overwrite: true
           })
         );
+        const iot2 = await useIOT();
+        const topic = `${iot2.prefix}/events`;
+        await iot2.publish(topic, "config.secret.updated", { name: input.key });
       }
       Config2.setSecret = setSecret;
       async function getSecret(input) {
@@ -6691,37 +6641,35 @@ var init_config = __esm({
       }
       Config2.removeSecret = removeSecret;
       async function restart(key) {
-        const lambda = useAWSClient(LambdaClient);
         const metadata3 = await stacks_exports.metadata();
-        const filtered = Object.values(metadata3).flat().filter((f) => f.type === "Function").filter((f) => f.data.secrets.includes(key));
-        const restarted = await Promise.all(
-          filtered.map(async (f) => {
-            try {
-              const config = await lambda.send(
-                new GetFunctionConfigurationCommand({
-                  FunctionName: f.data.arn
-                })
-              );
-              await lambda.send(
-                new UpdateFunctionConfigurationCommand({
-                  FunctionName: f.data.arn,
-                  Environment: {
-                    Variables: {
-                      ...config.Environment?.Variables || {},
-                      [SECRET_UPDATED_AT_ENV]: Date.now().toString()
-                    }
-                  }
-                })
-              );
-              return true;
-            } catch (e) {
-              if (e.name === "ResourceNotFoundException" && e.message.startsWith("Function not found")) {
-                return;
-              }
-            }
-          })
+        const siteData = Object.values(metadata3).flat().filter(
+          (c) => c.type === "AstroSite" || c.type === "NextjsSite" || c.type === "RemixSite" || c.type === "SolidStartSite"
+        ).filter((c) => c.data.secrets.includes(key));
+        const siteDataPlaceholder = siteData.filter(
+          (c) => c.data.mode === "placeholder"
         );
-        return restarted.filter(Boolean).length;
+        const siteDataEdge = siteData.filter((c) => c.data.mode === "deployed").filter((c) => c.data.edge);
+        const siteDataRegional = siteData.filter((c) => c.data.mode === "deployed").filter((c) => !c.data.edge);
+        const regionalSiteArns = siteData.map((s) => s.data.server);
+        const functionData = Object.values(metadata3).flat().filter((c) => c.type === "Function").filter((c) => !regionalSiteArns.includes(c.data.arn)).filter((c) => c.data.secrets.includes(key));
+        const restartedSites = (await Promise.all(
+          siteDataRegional.map(async (s) => {
+            const restarted = await restartFunction(s.data.server);
+            return restarted ? s : restarted;
+          })
+        )).filter((c) => Boolean(c));
+        const restartedFunctions = (await Promise.all(
+          functionData.map(async (f) => {
+            const restarted = await restartFunction(f.data.arn);
+            return restarted ? f : restarted;
+          })
+        )).filter((c) => Boolean(c));
+        return {
+          edgeSites: siteDataEdge,
+          sites: restartedSites,
+          placeholderSites: siteDataPlaceholder,
+          functions: restartedFunctions
+        };
       }
       Config2.restart = restart;
     })(Config || (Config = {}));
@@ -6785,62 +6733,17 @@ init_spinner();
 init_logger();
 import dotenv2 from "dotenv";
 
-// src/cli/commands/env.ts
-init_error();
-var env = (program2) => program2.command(
-  "env <command..>",
-  "Load environment variables and start your frontend",
-  (yargs2) => yargs2.array("command").example(
-    `sst env "next dev"`,
-    "Start Next.js with your environment variables"
-  ).example(
-    `sst env "vite dev"`,
-    "Start Vite with your environment variables"
-  ),
-  async (args) => {
-    const { createSpinner: createSpinner2 } = await Promise.resolve().then(() => (init_spinner(), spinner_exports));
-    const fs19 = await import("fs/promises");
-    const { SiteEnv } = await Promise.resolve().then(() => (init_site_env(), site_env_exports));
-    const { spawnSync } = await import("child_process");
-    const { useAWSCredentials: useAWSCredentials3 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
-    const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
-    let spinner;
-    while (true) {
-      const exists = await fs19.access(SiteEnv.valuesFile()).then(() => true).catch(() => false);
-      if (!exists) {
-        spinner = createSpinner2(
-          "Cannot find SST environment variables. Waiting for SST to start..."
-        ).start();
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
-        continue;
-      }
-      spinner?.succeed();
-      const sites = await SiteEnv.values();
-      const env2 = sites[process.cwd()] || {};
-      const project = useProject2();
-      const credentials = await useAWSCredentials3();
-      const joined = args.command?.join(" ");
-      if (!joined)
-        throw new VisibleError(
-          "Command is required, e.g. sst env vite dev"
-        );
-      const result = spawnSync(joined, {
-        env: {
-          ...process.env,
-          ...env2,
-          AWS_ACCESS_KEY_ID: credentials.accessKeyId,
-          AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
-          AWS_SESSION_TOKEN: credentials.sessionToken,
-          AWS_REGION: project.config.region
-        },
-        stdio: "inherit",
-        shell: true
-      });
-      process.exitCode = result.status || void 0;
-      break;
-    }
+// src/cli/commands/bootstrap.ts
+var bootstrap = (program2) => program2.command(
+  "bootstrap",
+  "Create the SST bootstrap stack",
+  (yargs2) => yargs2,
+  async () => {
+    const { useBootstrap: useBootstrap2 } = await Promise.resolve().then(() => (init_bootstrap(), bootstrap_exports));
+    await useBootstrap2();
+    process.exit(0);
   }
-).strict(false);
+);
 
 // src/cli/commands/dev.tsx
 var dev = (program2) => program2.command(
@@ -6853,11 +6756,11 @@ var dev = (program2) => program2.command(
   async (args) => {
     const { Colors: Colors2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
     const { printHeader: printHeader2 } = await Promise.resolve().then(() => (init_header(), header_exports));
-    const { mapValues, omitBy: omitBy2, pipe: pipe3 } = await import("remeda");
+    const { mapValues } = await import("remeda");
     const path20 = 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_server2(), server_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));
@@ -6868,11 +6771,10 @@ var dev = (program2) => program2.command(
     const React2 = await import("react");
     const { Context: Context2 } = await Promise.resolve().then(() => (init_context(), context_exports));
     const { printDeploymentResults: printDeploymentResults2, DeploymentUI: DeploymentUI2 } = await Promise.resolve().then(() => (init_deploy2(), deploy_exports));
-    const { useLocalServer: useLocalServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
-    const fs19 = await import("fs/promises");
+    const { useLocalServer: useLocalServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
+    const fs18 = await import("fs/promises");
     const crypto2 = await import("crypto");
     const { useFunctions: useFunctions3 } = await import("../src/constructs/Function.js");
-    const { SiteEnv } = await Promise.resolve().then(() => (init_site_env(), site_env_exports));
     const { usePothosBuilder: usePothosBuilder2 } = await Promise.resolve().then(() => (init_pothos2(), pothos_exports2));
     const { useKyselyTypeGenerator: useKyselyTypeGenerator2 } = await Promise.resolve().then(() => (init_kysely(), kysely_exports));
     const { useRDSWarmer: useRDSWarmer2 } = await Promise.resolve().then(() => (init_warmer(), warmer_exports));
@@ -7044,27 +6946,10 @@ var dev = (program2) => program2.command(
           await saveAppMetadata2({ mode: "dev" });
         }
         lastDeployed = nextChecksum;
-        const keys2 = await SiteEnv.keys();
-        const result = {};
-        for (const key of keys2) {
-          const stack = results[key.stack];
-          const value = stack.outputs[key.output];
-          let existing = result[key.path];
-          if (!existing) {
-            result[key.path] = existing;
-            existing = result[key.path] = {};
-          }
-          existing[key.environment] = value;
-        }
-        await SiteEnv.writeValues(result);
-        fs19.writeFile(
+        fs18.writeFile(
           path20.join(project.paths.out, "outputs.json"),
           JSON.stringify(
-            pipe3(
-              results,
-              omitBy2((_, key) => key.includes("SstSiteEnv")),
-              mapValues((val) => val.outputs)
-            ),
+            mapValues(results, (val) => val.outputs),
             null,
             2
           )
@@ -7076,7 +6961,7 @@ var dev = (program2) => program2.command(
       async function checksum(cdkOutPath) {
         const manifestPath = path20.join(cdkOutPath, "manifest.json");
         const cdkManifest = JSON.parse(
-          await fs19.readFile(manifestPath).then((x) => x.toString())
+          await fs18.readFile(manifestPath).then((x) => x.toString())
         );
         const checksumData = await Promise.all(
           Object.keys(cdkManifest.artifacts).filter(
@@ -7084,7 +6969,7 @@ var dev = (program2) => program2.command(
           ).map(async (key) => {
             const { templateFile } = cdkManifest.artifacts[key].properties;
             const templatePath = path20.join(cdkOutPath, templateFile);
-            const templateContent = await fs19.readFile(templatePath);
+            const templateContent = await fs18.readFile(templatePath);
             return templateContent;
           })
         ).then((x) => x.join("\n"));
@@ -7175,37 +7060,231 @@ 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";
+var SITE_CONFIG = {
+  NextjsSite: "next.config",
+  AstroSite: "astro.config",
+  RemixSite: "remix.config",
+  SolidStartSite: "vite.config",
+  StaticSite: "vite.config",
+  SlsNextjsSite: "next.config"
+};
 var bind = (program2) => program2.command(
-  "bind <command..>",
+  ["bind <command..>", "env <command..>"],
   "Bind your app's resources to a command",
   (yargs2) => yargs2.array("command").example(`sst bind "vitest run"`, "Bind your resources to your tests").example(
     `sst bind "tsx scripts/myscript.ts"`,
     "Bind your resources to a script"
   ),
   async (args) => {
-    const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-    const { spawnSync } = await import("child_process");
-    const { useAWSCredentials: useAWSCredentials3 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+    const { spawn: spawn7 } = await import("child_process");
     const { useProject: useProject2 } = await Promise.resolve().then(() => (init_project(), project_exports));
-    const env2 = await Config2.env();
+    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));
+    if (args._[0] === "env") {
+      Colors2.line(
+        Colors2.warning(
+          `Warning: ${Colors2.bold(
+            `sst env`
+          )} has been renamed to ${Colors2.bold(`sst bind`)}`
+        )
+      );
+    }
+    await useIOT2();
+    const bus = useBus2();
     const project = useProject2();
-    const credentials = await useAWSCredentials3();
-    const joined = args.command?.join(" ");
-    if (!joined)
-      throw new VisibleError("Command is required, e.g. sst bind env");
-    const result = spawnSync(joined, {
-      env: {
-        ...process.env,
-        ...env2,
+    const command = args.command?.join(" ");
+    const isFrontend = await isRunningInFrontend();
+    let p;
+    let timer;
+    let metadataCache;
+    if (!command) {
+      throw new VisibleError(
+        `Command is required, e.g. sst bind ${isFrontend ? "next dev" : "env"}`
+      );
+    }
+    const initialMetadata = await getSiteMetadata();
+    if (!initialMetadata) {
+      return await bindScript();
+    }
+    await bindSite("init");
+    bus.subscribe(
+      "stacks.metadata.updated",
+      () => bindSite("metadata_updated")
+    );
+    bus.subscribe(
+      "stacks.metadata.deleted",
+      () => bindSite("metadata_updated")
+    );
+    bus.subscribe("config.secret.updated", (payload) => {
+      const secretName = payload.properties.name;
+      if (metadataCache?.secrets === void 0)
+        return;
+      if (!metadataCache.secrets.includes(secretName))
+        return;
+      Colors2.line(
+        `
+`,
+        `SST secrets have been updated. Restarting \`${command}\`...`
+      );
+      bindSite("secrets_updated");
+    });
+    async function isRunningInFrontend() {
+      const { existsAsync: existsAsync3 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+      const results = await Promise.all(
+        Object.values(SITE_CONFIG).map(
+          (config) => [".js", ".cjs", ".mjs", ".ts"].map(
+            (ext) => existsAsync3(`${config}${ext}`)
+          )
+        ).flat()
+      );
+      return results.some(Boolean);
+    }
+    async function bindSite(reason) {
+      const metadata3 = reason === "init" ? initialMetadata : await getSiteMetadata();
+      if (reason === "metadata_updated") {
+        if (areEnvsSame(metadata3.envs, metadataCache?.envs || {}))
+          return;
+        Colors2.line(
+          `
+`,
+          `SST resources have been updated. Restarting \`${command}\`...`
+        );
+      }
+      metadataCache = metadata3;
+      if (metadata3.role) {
+        const credentials = await assumeSsrRole(metadata3.role);
+        if (credentials) {
+          const expireAt = credentials.Expiration.getTime() - 6e4;
+          clearTimeout(timer);
+          timer = setTimeout(() => {
+            Colors2.line(
+              `
+`,
+              `Your AWS session is about to expire. Creating a new session and restarting \`${command}\`...`
+            );
+            bindSite("iam_expired");
+          }, expireAt - Date.now());
+          runCommand({
+            ...metadata3.envs,
+            AWS_ACCESS_KEY_ID: credentials.AccessKeyId,
+            AWS_SECRET_ACCESS_KEY: credentials.SecretAccessKey,
+            AWS_SESSION_TOKEN: credentials.SessionToken
+          });
+          return;
+        }
+      }
+      runCommand({
+        ...metadata3.envs,
+        ...await localIamCredentials()
+      });
+    }
+    async function bindScript() {
+      const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      runCommand({
+        ...await Config2.env(),
+        ...await localIamCredentials()
+      });
+    }
+    async function getSiteMetadata() {
+      const { metadata: metadata3 } = await Promise.resolve().then(() => (init_metadata(), metadata_exports));
+      const { createSpinner: createSpinner2 } = await Promise.resolve().then(() => (init_spinner(), spinner_exports));
+      const { LambdaClient: LambdaClient2, GetFunctionCommand } = await import("@aws-sdk/client-lambda");
+      const { useAWSClient: useAWSClient2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+      const spinner = createSpinner2({});
+      while (true) {
+        const metadataData = await metadata3();
+        const data2 = Object.values(metadataData).flat().filter(
+          (c) => Boolean(c)
+        ).filter((c) => Boolean(SITE_CONFIG[c.type])).find(
+          (c) => path18.resolve(project.paths.root, c.data.path) === process.cwd()
+        );
+        if (!data2 && !isFrontend) {
+          return;
+        }
+        if (!data2) {
+          spinner.start(
+            "Make sure `sst dev` is running..."
+          );
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+          continue;
+        }
+        const isBindSupported = data2.type !== "StaticSite" && data2.type !== "SlsNextjsSite";
+        if (isBindSupported && !data2.data.server || !isBindSupported && !data2.data.environment) {
+          spinner.start(
+            "This was deployed with an old version of SST. Make sure to restart `sst dev`..."
+          );
+          await new Promise((resolve) => setTimeout(resolve, 1e3));
+          continue;
+        }
+        spinner.isSpinning && spinner.stop().clear();
+        if (!isBindSupported) {
+          return { envs: data2.data.environment };
+        }
+        const lambda = useAWSClient2(LambdaClient2);
+        const { Configuration: functionConfig } = await lambda.send(
+          new GetFunctionCommand({
+            FunctionName: data2.data.server
+          })
+        );
+        return {
+          role: functionConfig?.Role,
+          envs: functionConfig?.Environment?.Variables || {},
+          secrets: data2.data.secrets
+        };
+      }
+    }
+    async function assumeSsrRole(roleArn) {
+      const { STSClient: STSClient2, AssumeRoleCommand } = await import("@aws-sdk/client-sts");
+      const { Logger: Logger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+      const { useAWSClient: useAWSClient2 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+      const sts = useAWSClient2(STSClient2);
+      try {
+        const { Credentials: credentials } = await sts.send(
+          new AssumeRoleCommand({
+            RoleArn: roleArn,
+            RoleSessionName: "dev-session",
+            DurationSeconds: 43200
+          })
+        );
+        return credentials;
+      } catch (e) {
+        Colors2.line(
+          Colors2.warning(
+            `Failed to assume SSR role ${roleArn}. Falling back to using local IAM credentials.`
+          )
+        );
+        Logger2.debug(`Failed to assume ${roleArn}.`, e);
+      }
+    }
+    async function localIamCredentials() {
+      const { useAWSCredentials: useAWSCredentials3 } = await Promise.resolve().then(() => (init_credentials(), credentials_exports));
+      const credentials = await useAWSCredentials3();
+      return {
         AWS_ACCESS_KEY_ID: credentials.accessKeyId,
         AWS_SECRET_ACCESS_KEY: credentials.secretAccessKey,
-        AWS_SESSION_TOKEN: credentials.sessionToken,
-        AWS_REGION: project.config.region
-      },
-      stdio: "inherit",
-      shell: true
-    });
-    process.exitCode = result.status || void 0;
+        AWS_SESSION_TOKEN: credentials.sessionToken
+      };
+    }
+    function runCommand(envs) {
+      Colors2.gap();
+      if (p) {
+        p.kill();
+      }
+      p = spawn7(command, {
+        env: {
+          ...process.env,
+          ...envs,
+          AWS_REGION: project.config.region
+        },
+        stdio: "inherit",
+        shell: true
+      });
+    }
+    function areEnvsSame(envs1, envs2) {
+      return Object.keys(envs1).length === Object.keys(envs2).length && Object.keys(envs1).every((key) => envs1[key] === envs2[key]);
+    }
   }
 ).strict(false);
 
@@ -7240,7 +7319,7 @@ var build = (program2) => program2.command(
 // src/cli/commands/deploy.tsx
 init_credentials();
 init_colors();
-import fs18 from "fs/promises";
+import fs17 from "fs/promises";
 import path19 from "path";
 var deploy2 = (program2) => program2.command(
   "deploy [filter]",
@@ -7329,7 +7408,7 @@ 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);
-    fs18.writeFile(
+    fs17.writeFile(
       path19.join(project.paths.out, "outputs.json"),
       JSON.stringify(
         mapValues(results, (val) => val.outputs),
@@ -7408,8 +7487,8 @@ var consoleCommand = async (program2) => program2.command(
   (yargs2) => yargs2,
   async () => {
     const { blue: blue4 } = await import("colorette");
-    const { useRuntimeServer: useRuntimeServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
-    const { useLocalServer: useLocalServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    const { useRuntimeServer: useRuntimeServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+    const { useLocalServer: useLocalServer2 } = await Promise.resolve().then(() => (init_server2(), server_exports2));
     const { printHeader: printHeader2 } = await Promise.resolve().then(() => (init_header(), header_exports));
     const { clear: clear2 } = await Promise.resolve().then(() => (init_terminal(), terminal_exports));
     await Promise.all([
@@ -7477,14 +7556,14 @@ var list = (program2) => program2.command(
         }
         break;
       case "table":
-        const keys2 = Object.keys(secrets2);
+        const keys = Object.keys(secrets2);
         const keyLen = Math.max(
           "Secrets".length,
-          ...keys2.map((key) => key.length)
+          ...keys.map((key) => key.length)
         );
         const valueLen = Math.max(
           "Values".length,
-          ...keys2.map(
+          ...keys.map(
             (key) => secrets2[key].value ? secrets2[key].value.length : `${secrets2[key].fallback} (fallback)`.length
           )
         );
@@ -7497,7 +7576,7 @@ var list = (program2) => program2.command(
         console.log(
           "\u251C".padEnd(keyLen + 3, "\u2500") + "\u253C" + "".padEnd(valueLen + 2, "\u2500") + "\u2524"
         );
-        keys2.sort().forEach((key) => {
+        keys.sort().forEach((key) => {
           const value = secrets2[key].value ? secrets2[key].value : `${secrets2[key].fallback} ${gray("(fallback)")}`;
           console.log(
             `\u2502 ${key.padEnd(keyLen)} \u2502 ${value.padEnd(valueLen)} \u2502`
@@ -7556,6 +7635,7 @@ var set = (program2) => program2.command(
   }),
   async (args) => {
     const { Config: Config2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const { Colors: Colors2 } = await Promise.resolve().then(() => (init_colors(), colors_exports));
     const { blue: blue4 } = await import("colorette");
     const { createSpinner: createSpinner2 } = await Promise.resolve().then(() => (init_spinner(), spinner_exports));
     const setting = createSpinner2(` Setting "${args.name}"`).start();
@@ -7566,12 +7646,31 @@ var set = (program2) => program2.command(
     });
     setting.succeed();
     const restarting = createSpinner2(
-      ` Restarting all functions using ${blue4(args.name)}...`
+      ` Reloading all resources using ${blue4(args.name)}...`
     ).start();
-    const count = await Config2.restart(args.name);
-    restarting.succeed(
-      count === 1 ? ` Restarted ${count} function` : ` Restarted ${count} functions`
-    );
+    const { edgeSites, sites, placeholderSites, functions } = await Config2.restart(args.name);
+    restarting.stop().clear();
+    const siteCount = sites.length + placeholderSites.length;
+    if (siteCount > 0) {
+      Colors2.line(
+        Colors2.success(`\u2714 `),
+        siteCount === 1 ? `Reloaded ${siteCount} site` : `Reloaded ${siteCount} sites`
+      );
+    }
+    const functionCount = functions.length;
+    if (functionCount > 0) {
+      Colors2.line(
+        Colors2.success(`\u2714 `),
+        functionCount === 1 ? `Reloaded ${functionCount} function` : `Reloaded ${functionCount} functions`
+      );
+    }
+    edgeSites.forEach(({ id, type }) => {
+      Colors2.line(
+        Colors2.danger(`\u279C `),
+        `Redeploy the "${id}" ${type} to use the new secret`
+      );
+    });
+    process.exit(0);
   }
 );
 
@@ -7599,13 +7698,13 @@ var update = (program2) => program2.command(
   }),
   async (args) => {
     const { green, yellow } = await import("colorette");
-    const fs19 = await import("fs/promises");
+    const fs18 = await import("fs/promises");
     const path20 = 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 fs19.readdir(dir);
+      const children = await fs18.readdir(dir);
       const tasks2 = children.map(async (item) => {
         if (item === "node_modules")
           return [];
@@ -7614,7 +7713,7 @@ var update = (program2) => program2.command(
         const full = path20.join(dir, item);
         if (item === "package.json")
           return [full];
-        const stat = await fs19.stat(full);
+        const stat = await fs18.stat(full);
         if (stat.isDirectory())
           return find2(full);
         return [];
@@ -7628,7 +7727,7 @@ var update = (program2) => program2.command(
     ).then((resp) => resp.json());
     const results = /* @__PURE__ */ new Map();
     const tasks = files.map(async (file) => {
-      const data2 = await fs19.readFile(file).then((x) => x.toString()).then(JSON.parse);
+      const data2 = await fs18.readFile(file).then((x) => x.toString()).then(JSON.parse);
       for (const field of FIELDS) {
         const deps = data2[field];
         if (!deps)
@@ -7657,7 +7756,7 @@ var update = (program2) => program2.command(
         }
       }
       if (results.has(file)) {
-        await fs19.writeFile(file, JSON.stringify(data2, null, 2));
+        await fs18.writeFile(file, JSON.stringify(data2, null, 2));
       }
     });
     await Promise.all(tasks);
@@ -7885,11 +7984,11 @@ dotenv2.config({
   path: ".env.local",
   override: true
 });
+bootstrap(program);
 dev(program);
 deploy2(program);
 build(program);
 bind(program);
-env(program);
 secrets(program);
 remove2(program);
 update(program);