@aws-cdk/toolkit-lib 0.1.6 → 0.1.8

package/lib/api/shared-public.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // lib/api/shared-public.ts
@@ -23,11 +33,14 @@ __export(shared_public_exports, {
   AssemblyError: () => AssemblyError,
   AuthenticationError: () => AuthenticationError,
   ContextProviderError: () => ContextProviderError,
+  DiffFormatter: () => DiffFormatter,
   ExpandStackSelection: () => ExpandStackSelection,
+  NonHotswappableReason: () => NonHotswappableReason,
   PermissionChangeType: () => PermissionChangeType,
   RequireApproval: () => RequireApproval,
   StackSelectionStrategy: () => StackSelectionStrategy,
-  ToolkitError: () => ToolkitError
+  ToolkitError: () => ToolkitError,
+  removeNonImportResources: () => removeNonImportResources
 });
 module.exports = __toCommonJS(shared_public_exports);
 
@@ -48,13 +61,19 @@ var ExpandStackSelection = /* @__PURE__ */ ((ExpandStackSelection2) => {
   return ExpandStackSelection2;
 })(ExpandStackSelection || {});
 
-// ../tmp-toolkit-helpers/src/api/io/payloads/diff.ts
-var PermissionChangeType = /* @__PURE__ */ ((PermissionChangeType2) => {
-  PermissionChangeType2["NONE"] = "none";
-  PermissionChangeType2["BROADENING"] = "broadening";
-  PermissionChangeType2["NON_BROADENING"] = "non-broadening";
-  return PermissionChangeType2;
-})(PermissionChangeType || {});
+// ../tmp-toolkit-helpers/src/api/diff/diff-formatter.ts
+var import_node_util = require("node:util");
+var import_stream = require("stream");
+var cxschema = __toESM(require("@aws-cdk/cloud-assembly-schema"));
+var import_cloudformation_diff = require("@aws-cdk/cloudformation-diff");
+var chalk = __toESM(require("chalk"));
+
+// ../tmp-toolkit-helpers/src/api/io/private/span.ts
+var uuid = __toESM(require("uuid"));
+
+// ../tmp-toolkit-helpers/src/util/archive.ts
+var glob = __toESM(require("glob"));
+var archiver = require("archiver");
 
 // ../tmp-toolkit-helpers/src/api/toolkit-error.ts
 var TOOLKIT_ERROR_SYMBOL = Symbol.for("@aws-cdk/toolkit-lib.ToolkitError");
@@ -86,6 +105,12 @@ var ToolkitError = class _ToolkitError extends Error {
   static isContextProviderError(x) {
     return this.isToolkitError(x) && CONTEXT_PROVIDER_ERROR_SYMBOL in x;
   }
+  /**
+   * An AssemblyError with an original error as cause
+   */
+  static withCause(message2, error2) {
+    return new _ToolkitError(message2, "toolkit", error2);
+  }
   /**
    * The type of the error, defaults to "toolkit".
    */
@@ -94,13 +119,18 @@ var ToolkitError = class _ToolkitError extends Error {
    * Denotes the source of the error as the toolkit.
    */
   source;
-  constructor(message, type = "toolkit") {
-    super(message);
+  /**
+   * The specific original cause of the error, if available
+   */
+  cause;
+  constructor(message2, type = "toolkit", cause) {
+    super(message2);
     Object.setPrototypeOf(this, _ToolkitError.prototype);
     Object.defineProperty(this, TOOLKIT_ERROR_SYMBOL, { value: true });
     this.name = new.target.name;
     this.type = type;
     this.source = "toolkit";
+    this.cause = cause;
   }
 };
 var AuthenticationError = class _AuthenticationError extends ToolkitError {
@@ -108,8 +138,8 @@ var AuthenticationError = class _AuthenticationError extends ToolkitError {
    * Denotes the source of the error as user.
    */
   source = "user";
-  constructor(message) {
-    super(message, "authentication");
+  constructor(message2) {
+    super(message2, "authentication");
     Object.setPrototypeOf(this, _AuthenticationError.prototype);
     Object.defineProperty(this, AUTHENTICATION_ERROR_SYMBOL, { value: true });
   }
@@ -118,14 +148,14 @@ var AssemblyError = class _AssemblyError extends ToolkitError {
   /**
    * An AssemblyError with an original error as cause
    */
-  static withCause(message, error) {
-    return new _AssemblyError(message, void 0, error);
+  static withCause(message2, error2) {
+    return new _AssemblyError(message2, void 0, error2);
   }
   /**
    * An AssemblyError with a list of stacks as cause
    */
-  static withStacks(message, stacks) {
-    return new _AssemblyError(message, stacks);
+  static withStacks(message2, stacks) {
+    return new _AssemblyError(message2, stacks);
   }
   /**
    * Denotes the source of the error as user.
@@ -138,16 +168,11 @@ var AssemblyError = class _AssemblyError extends ToolkitError {
    * Absence indicates synthesis didn't fully complete.
    */
   stacks;
-  /**
-   * The specific original cause of the error, if available
-   */
-  cause;
-  constructor(message, stacks, cause) {
-    super(message, "assembly");
+  constructor(message2, stacks, cause) {
+    super(message2, "assembly", cause);
     Object.setPrototypeOf(this, _AssemblyError.prototype);
     Object.defineProperty(this, ASSEMBLY_ERROR_SYMBOL, { value: true });
     this.stacks = stacks;
-    this.cause = cause;
   }
 };
 var ContextProviderError = class _ContextProviderError extends ToolkitError {
@@ -155,13 +180,662 @@ var ContextProviderError = class _ContextProviderError extends ToolkitError {
    * Denotes the source of the error as user.
    */
   source = "user";
-  constructor(message) {
-    super(message, "context-provider");
+  constructor(message2) {
+    super(message2, "context-provider");
     Object.setPrototypeOf(this, _ContextProviderError.prototype);
     Object.defineProperty(this, CONTEXT_PROVIDER_ERROR_SYMBOL, { value: true });
   }
 };
 
+// ../tmp-toolkit-helpers/src/util/types.ts
+var isArray = Array.isArray;
+
+// ../tmp-toolkit-helpers/src/util/yaml-cfn.ts
+var yaml = __toESM(require("yaml"));
+var yaml_types = __toESM(require("yaml/types"));
+function makeTagForCfnIntrinsic(intrinsicName, addFnPrefix) {
+  return {
+    identify(value) {
+      return typeof value === "string";
+    },
+    tag: `!${intrinsicName}`,
+    resolve: (_doc, cstNode) => {
+      const ret = {};
+      ret[addFnPrefix ? `Fn::${intrinsicName}` : intrinsicName] = // the +1 is to account for the ! the short form begins with
+      parseYamlStrWithCfnTags(cstNode.toString().substring(intrinsicName.length + 1));
+      return ret;
+    }
+  };
+}
+var shortForms = [
+  "Base64",
+  "Cidr",
+  "FindInMap",
+  "GetAZs",
+  "ImportValue",
+  "Join",
+  "Sub",
+  "Select",
+  "Split",
+  "Transform",
+  "And",
+  "Equals",
+  "If",
+  "Not",
+  "Or",
+  "GetAtt"
+].map((name) => makeTagForCfnIntrinsic(name, true)).concat(
+  makeTagForCfnIntrinsic("Ref", false),
+  makeTagForCfnIntrinsic("Condition", false)
+);
+function parseYamlStrWithCfnTags(text) {
+  return yaml.parse(text, {
+    customTags: shortForms,
+    schema: "core"
+  });
+}
+
+// ../tmp-toolkit-helpers/src/util/version-range.ts
+var semver = __toESM(require("semver"));
+
+// ../tmp-toolkit-helpers/src/api/io/private/level-priority.ts
+var levels = [
+  "trace",
+  "debug",
+  "info",
+  "warn",
+  "result",
+  "error"
+];
+var orderedLevels = Object.fromEntries(Object.entries(levels).map((a) => a.reverse()));
+
+// ../tmp-toolkit-helpers/src/api/io/private/message-maker.ts
+function message(level, details) {
+  const maker = (text, data) => ({
+    time: /* @__PURE__ */ new Date(),
+    level,
+    code: details.code,
+    message: text,
+    data
+  });
+  return {
+    ...details,
+    level,
+    msg: maker,
+    is: (m) => m.code === details.code
+  };
+}
+var trace = (details) => message("trace", details);
+var debug = (details) => message("debug", details);
+var info = (details) => message("info", details);
+var warn = (details) => message("warn", details);
+var error = (details) => message("error", details);
+var result = (details) => message("result", details);
+function request(level, details) {
+  const maker = (text, data) => ({
+    time: /* @__PURE__ */ new Date(),
+    level,
+    code: details.code,
+    message: text,
+    data,
+    defaultResponse: details.defaultResponse
+  });
+  return {
+    ...details,
+    level,
+    req: maker
+  };
+}
+var confirm = (details) => request("info", {
+  ...details,
+  defaultResponse: true
+});
+
+// ../tmp-toolkit-helpers/src/api/io/private/messages.ts
+var IO = {
+  // Defaults (0000)
+  DEFAULT_TOOLKIT_INFO: info({
+    code: "CDK_TOOLKIT_I0000",
+    description: "Default info messages emitted from the Toolkit"
+  }),
+  DEFAULT_TOOLKIT_DEBUG: debug({
+    code: "CDK_TOOLKIT_I0000",
+    description: "Default debug messages emitted from the Toolkit"
+  }),
+  DEFAULT_TOOLKIT_WARN: warn({
+    code: "CDK_TOOLKIT_W0000",
+    description: "Default warning messages emitted from the Toolkit"
+  }),
+  DEFAULT_TOOLKIT_ERROR: error({
+    code: "CDK_TOOLKIT_E0000",
+    description: "Default error messages emitted from the Toolkit"
+  }),
+  DEFAULT_TOOLKIT_TRACE: trace({
+    code: "CDK_TOOLKIT_I0000",
+    description: "Default trace messages emitted from the Toolkit"
+  }),
+  // 1: Synth (1xxx)
+  CDK_TOOLKIT_I1000: info({
+    code: "CDK_TOOLKIT_I1000",
+    description: "Provides synthesis times.",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I1001: trace({
+    code: "CDK_TOOLKIT_I1001",
+    description: "Cloud Assembly synthesis is starting",
+    interface: "StackSelectionDetails"
+  }),
+  CDK_TOOLKIT_I1901: result({
+    code: "CDK_TOOLKIT_I1901",
+    description: "Provides stack data",
+    interface: "StackAndAssemblyData"
+  }),
+  CDK_TOOLKIT_I1902: result({
+    code: "CDK_TOOLKIT_I1902",
+    description: "Successfully deployed stacks",
+    interface: "AssemblyData"
+  }),
+  // 2: List (2xxx)
+  CDK_TOOLKIT_I2901: result({
+    code: "CDK_TOOLKIT_I2901",
+    description: "Provides details on the selected stacks and their dependencies",
+    interface: "StackDetailsPayload"
+  }),
+  // 3: Import & Migrate
+  CDK_TOOLKIT_E3900: error({
+    code: "CDK_TOOLKIT_E3900",
+    description: "Resource import failed",
+    interface: "ErrorPayload"
+  }),
+  // 4: Diff (4xxx)
+  CDK_TOOLKIT_I4000: trace({
+    code: "CDK_TOOLKIT_I4000",
+    description: "Diff stacks is starting",
+    interface: "StackSelectionDetails"
+  }),
+  CDK_TOOLKIT_I4001: info({
+    code: "CDK_TOOLKIT_I4001",
+    description: "Output of the diff command",
+    interface: "DiffResult"
+  }),
+  // 5: Deploy & Watch (5xxx)
+  CDK_TOOLKIT_I5000: info({
+    code: "CDK_TOOLKIT_I5000",
+    description: "Provides deployment times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I5001: info({
+    code: "CDK_TOOLKIT_I5001",
+    description: "Provides total time in deploy action, including synth and rollback",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I5002: info({
+    code: "CDK_TOOLKIT_I5002",
+    description: "Provides time for resource migration",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_W5021: warn({
+    code: "CDK_TOOLKIT_W5021",
+    description: "Empty non-existent stack, deployment is skipped"
+  }),
+  CDK_TOOLKIT_W5022: warn({
+    code: "CDK_TOOLKIT_W5022",
+    description: "Empty existing stack, stack will be destroyed"
+  }),
+  CDK_TOOLKIT_I5031: info({
+    code: "CDK_TOOLKIT_I5031",
+    description: "Informs about any log groups that are traced as part of the deployment"
+  }),
+  CDK_TOOLKIT_I5032: debug({
+    code: "CDK_TOOLKIT_I5032",
+    description: "Start monitoring log groups",
+    interface: "CloudWatchLogMonitorControlEvent"
+  }),
+  CDK_TOOLKIT_I5033: info({
+    code: "CDK_TOOLKIT_I5033",
+    description: "A log event received from Cloud Watch",
+    interface: "CloudWatchLogEvent"
+  }),
+  CDK_TOOLKIT_I5034: debug({
+    code: "CDK_TOOLKIT_I5034",
+    description: "Stop monitoring log groups",
+    interface: "CloudWatchLogMonitorControlEvent"
+  }),
+  CDK_TOOLKIT_E5035: error({
+    code: "CDK_TOOLKIT_E5035",
+    description: "A log monitoring error",
+    interface: "ErrorPayload"
+  }),
+  CDK_TOOLKIT_I5050: confirm({
+    code: "CDK_TOOLKIT_I5050",
+    description: "Confirm rollback during deployment",
+    interface: "ConfirmationRequest"
+  }),
+  CDK_TOOLKIT_I5060: confirm({
+    code: "CDK_TOOLKIT_I5060",
+    description: "Confirm deploy security sensitive changes",
+    interface: "DeployConfirmationRequest"
+  }),
+  CDK_TOOLKIT_I5100: info({
+    code: "CDK_TOOLKIT_I5100",
+    description: "Stack deploy progress",
+    interface: "StackDeployProgress"
+  }),
+  // Assets (52xx)
+  CDK_TOOLKIT_I5210: trace({
+    code: "CDK_TOOLKIT_I5210",
+    description: "Started building a specific asset",
+    interface: "BuildAsset"
+  }),
+  CDK_TOOLKIT_I5211: trace({
+    code: "CDK_TOOLKIT_I5211",
+    description: "Building the asset has completed",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I5220: trace({
+    code: "CDK_TOOLKIT_I5220",
+    description: "Started publishing a specific asset",
+    interface: "PublishAsset"
+  }),
+  CDK_TOOLKIT_I5221: trace({
+    code: "CDK_TOOLKIT_I5221",
+    description: "Publishing the asset has completed",
+    interface: "Duration"
+  }),
+  // Watch (53xx)
+  CDK_TOOLKIT_I5310: debug({
+    code: "CDK_TOOLKIT_I5310",
+    description: "The computed settings used for file watching",
+    interface: "WatchSettings"
+  }),
+  CDK_TOOLKIT_I5311: info({
+    code: "CDK_TOOLKIT_I5311",
+    description: "File watching started",
+    interface: "FileWatchEvent"
+  }),
+  CDK_TOOLKIT_I5312: info({
+    code: "CDK_TOOLKIT_I5312",
+    description: "File event detected, starting deployment",
+    interface: "FileWatchEvent"
+  }),
+  CDK_TOOLKIT_I5313: info({
+    code: "CDK_TOOLKIT_I5313",
+    description: "File event detected during active deployment, changes are queued",
+    interface: "FileWatchEvent"
+  }),
+  CDK_TOOLKIT_I5314: info({
+    code: "CDK_TOOLKIT_I5314",
+    description: "Initial watch deployment started"
+  }),
+  CDK_TOOLKIT_I5315: info({
+    code: "CDK_TOOLKIT_I5315",
+    description: "Queued watch deployment started"
+  }),
+  // Hotswap (54xx)
+  CDK_TOOLKIT_I5400: trace({
+    code: "CDK_TOOLKIT_I5400",
+    description: "Attempting a hotswap deployment",
+    interface: "HotswapDeploymentAttempt"
+  }),
+  CDK_TOOLKIT_I5401: trace({
+    code: "CDK_TOOLKIT_I5401",
+    description: "Computed details for the hotswap deployment",
+    interface: "HotswapDeploymentDetails"
+  }),
+  CDK_TOOLKIT_I5402: info({
+    code: "CDK_TOOLKIT_I5402",
+    description: "A hotswappable change is processed as part of a hotswap deployment",
+    interface: "HotswappableChange"
+  }),
+  CDK_TOOLKIT_I5403: info({
+    code: "CDK_TOOLKIT_I5403",
+    description: "The hotswappable change has completed processing",
+    interface: "HotswappableChange"
+  }),
+  CDK_TOOLKIT_I5410: info({
+    code: "CDK_TOOLKIT_I5410",
+    description: "Hotswap deployment has ended, a full deployment might still follow if needed",
+    interface: "HotswapResult"
+  }),
+  // Stack Monitor (55xx)
+  CDK_TOOLKIT_I5501: info({
+    code: "CDK_TOOLKIT_I5501",
+    description: "Stack Monitoring: Start monitoring of a single stack",
+    interface: "StackMonitoringControlEvent"
+  }),
+  CDK_TOOLKIT_I5502: info({
+    code: "CDK_TOOLKIT_I5502",
+    description: "Stack Monitoring: Activity event for a single stack",
+    interface: "StackActivity"
+  }),
+  CDK_TOOLKIT_I5503: info({
+    code: "CDK_TOOLKIT_I5503",
+    description: "Stack Monitoring: Finished monitoring of a single stack",
+    interface: "StackMonitoringControlEvent"
+  }),
+  // Success (59xx)
+  CDK_TOOLKIT_I5900: result({
+    code: "CDK_TOOLKIT_I5900",
+    description: "Deployment results on success",
+    interface: "SuccessfulDeployStackResult"
+  }),
+  CDK_TOOLKIT_I5901: info({
+    code: "CDK_TOOLKIT_I5901",
+    description: "Generic deployment success messages"
+  }),
+  CDK_TOOLKIT_W5400: warn({
+    code: "CDK_TOOLKIT_W5400",
+    description: "Hotswap disclosure message"
+  }),
+  // errors
+  CDK_TOOLKIT_E5001: error({
+    code: "CDK_TOOLKIT_E5001",
+    description: "No stacks found"
+  }),
+  CDK_TOOLKIT_E5500: error({
+    code: "CDK_TOOLKIT_E5500",
+    description: "Stack Monitoring error",
+    interface: "ErrorPayload"
+  }),
+  // 6: Rollback (6xxx)
+  CDK_TOOLKIT_I6000: info({
+    code: "CDK_TOOLKIT_I6000",
+    description: "Provides rollback times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I6100: info({
+    code: "CDK_TOOLKIT_I6100",
+    description: "Stack rollback progress",
+    interface: "StackRollbackProgress"
+  }),
+  CDK_TOOLKIT_E6001: error({
+    code: "CDK_TOOLKIT_E6001",
+    description: "No stacks found"
+  }),
+  CDK_TOOLKIT_E6900: error({
+    code: "CDK_TOOLKIT_E6900",
+    description: "Rollback failed",
+    interface: "ErrorPayload"
+  }),
+  // 7: Destroy (7xxx)
+  CDK_TOOLKIT_I7000: info({
+    code: "CDK_TOOLKIT_I7000",
+    description: "Provides destroy times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I7001: trace({
+    code: "CDK_TOOLKIT_I7001",
+    description: "Provides destroy time for a single stack",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I7010: confirm({
+    code: "CDK_TOOLKIT_I7010",
+    description: "Confirm destroy stacks",
+    interface: "ConfirmationRequest"
+  }),
+  CDK_TOOLKIT_I7100: info({
+    code: "CDK_TOOLKIT_I7100",
+    description: "Stack destroy progress",
+    interface: "StackDestroyProgress"
+  }),
+  CDK_TOOLKIT_I7101: trace({
+    code: "CDK_TOOLKIT_I7101",
+    description: "Start stack destroying",
+    interface: "StackDestroy"
+  }),
+  CDK_TOOLKIT_I7900: result({
+    code: "CDK_TOOLKIT_I7900",
+    description: "Stack deletion succeeded",
+    interface: "cxapi.CloudFormationStackArtifact"
+  }),
+  CDK_TOOLKIT_E7010: error({
+    code: "CDK_TOOLKIT_E7010",
+    description: "Action was aborted due to negative confirmation of request"
+  }),
+  CDK_TOOLKIT_E7900: error({
+    code: "CDK_TOOLKIT_E7900",
+    description: "Stack deletion failed",
+    interface: "ErrorPayload"
+  }),
+  // 9: Bootstrap (9xxx)
+  CDK_TOOLKIT_I9000: info({
+    code: "CDK_TOOLKIT_I9000",
+    description: "Provides bootstrap times",
+    interface: "Duration"
+  }),
+  CDK_TOOLKIT_I9100: info({
+    code: "CDK_TOOLKIT_I9100",
+    description: "Bootstrap progress",
+    interface: "BootstrapEnvironmentProgress"
+  }),
+  CDK_TOOLKIT_I9900: result({
+    code: "CDK_TOOLKIT_I9900",
+    description: "Bootstrap results on success",
+    interface: "cxapi.Environment"
+  }),
+  CDK_TOOLKIT_E9900: error({
+    code: "CDK_TOOLKIT_E9900",
+    description: "Bootstrap failed",
+    interface: "ErrorPayload"
+  }),
+  // Notices
+  CDK_TOOLKIT_I0100: info({
+    code: "CDK_TOOLKIT_I0100",
+    description: "Notices decoration (the header or footer of a list of notices)"
+  }),
+  CDK_TOOLKIT_W0101: warn({
+    code: "CDK_TOOLKIT_W0101",
+    description: "A notice that is marked as a warning"
+  }),
+  CDK_TOOLKIT_E0101: error({
+    code: "CDK_TOOLKIT_E0101",
+    description: "A notice that is marked as an error"
+  }),
+  CDK_TOOLKIT_I0101: info({
+    code: "CDK_TOOLKIT_I0101",
+    description: "A notice that is marked as informational"
+  }),
+  // Assembly codes
+  DEFAULT_ASSEMBLY_TRACE: trace({
+    code: "CDK_ASSEMBLY_I0000",
+    description: "Default trace messages emitted from Cloud Assembly operations"
+  }),
+  DEFAULT_ASSEMBLY_DEBUG: debug({
+    code: "CDK_ASSEMBLY_I0000",
+    description: "Default debug messages emitted from Cloud Assembly operations"
+  }),
+  DEFAULT_ASSEMBLY_INFO: info({
+    code: "CDK_ASSEMBLY_I0000",
+    description: "Default info messages emitted from Cloud Assembly operations"
+  }),
+  DEFAULT_ASSEMBLY_WARN: warn({
+    code: "CDK_ASSEMBLY_W0000",
+    description: "Default warning messages emitted from Cloud Assembly operations"
+  }),
+  CDK_ASSEMBLY_I0010: debug({
+    code: "CDK_ASSEMBLY_I0010",
+    description: "Generic environment preparation debug messages"
+  }),
+  CDK_ASSEMBLY_W0010: warn({
+    code: "CDK_ASSEMBLY_W0010",
+    description: "Emitted if the found framework version does not support context overflow"
+  }),
+  CDK_ASSEMBLY_I0042: debug({
+    code: "CDK_ASSEMBLY_I0042",
+    description: "Writing updated context",
+    interface: "UpdatedContext"
+  }),
+  CDK_ASSEMBLY_I0240: debug({
+    code: "CDK_ASSEMBLY_I0240",
+    description: "Context lookup was stopped as no further progress was made. ",
+    interface: "MissingContext"
+  }),
+  CDK_ASSEMBLY_I0241: debug({
+    code: "CDK_ASSEMBLY_I0241",
+    description: "Fetching missing context. This is an iterative message that may appear multiple times with different missing keys.",
+    interface: "MissingContext"
+  }),
+  CDK_ASSEMBLY_I1000: debug({
+    code: "CDK_ASSEMBLY_I1000",
+    description: "Cloud assembly output starts"
+  }),
+  CDK_ASSEMBLY_I1001: info({
+    code: "CDK_ASSEMBLY_I1001",
+    description: "Output lines emitted by the cloud assembly to stdout"
+  }),
+  CDK_ASSEMBLY_E1002: error({
+    code: "CDK_ASSEMBLY_E1002",
+    description: "Output lines emitted by the cloud assembly to stderr"
+  }),
+  CDK_ASSEMBLY_I1003: info({
+    code: "CDK_ASSEMBLY_I1003",
+    description: "Cloud assembly output finished"
+  }),
+  CDK_ASSEMBLY_E1111: error({
+    code: "CDK_ASSEMBLY_E1111",
+    description: "Incompatible CDK CLI version. Upgrade needed.",
+    interface: "ErrorPayload"
+  }),
+  CDK_ASSEMBLY_I0150: debug({
+    code: "CDK_ASSEMBLY_I0150",
+    description: "Indicates the use of a pre-synthesized cloud assembly directory"
+  }),
+  CDK_ASSEMBLY_I0300: info({
+    code: "CDK_ASSEMBLY_I0300",
+    description: "An info message emitted by a Context Provider",
+    interface: "ContextProviderMessageSource"
+  }),
+  CDK_ASSEMBLY_I0301: debug({
+    code: "CDK_ASSEMBLY_I0301",
+    description: "A debug message emitted by a Context Provider",
+    interface: "ContextProviderMessageSource"
+  }),
+  // Assembly Annotations
+  CDK_ASSEMBLY_I9999: info({
+    code: "CDK_ASSEMBLY_I9999",
+    description: "Annotations emitted by the cloud assembly",
+    interface: "cxapi.SynthesisMessage"
+  }),
+  CDK_ASSEMBLY_W9999: warn({
+    code: "CDK_ASSEMBLY_W9999",
+    description: "Warnings emitted by the cloud assembly",
+    interface: "cxapi.SynthesisMessage"
+  }),
+  CDK_ASSEMBLY_E9999: error({
+    code: "CDK_ASSEMBLY_E9999",
+    description: "Errors emitted by the cloud assembly",
+    interface: "cxapi.SynthesisMessage"
+  }),
+  // SDK codes
+  CDK_SDK_I0000: trace({
+    code: "CDK_SDK_I0000",
+    description: "An SDK message."
+  }),
+  CDK_SDK_I0100: trace({
+    code: "CDK_SDK_I0100",
+    description: "An SDK trace. SDK traces are emitted as traces to the IoHost, but contain the original SDK logging level.",
+    interface: "SdkTrace"
+  })
+};
+var SPAN = {
+  SYNTH_ASSEMBLY: {
+    name: "Synthesis",
+    start: IO.CDK_TOOLKIT_I1001,
+    end: IO.CDK_TOOLKIT_I1000
+  },
+  DEPLOY_STACK: {
+    name: "Deployment",
+    start: IO.CDK_TOOLKIT_I5100,
+    end: IO.CDK_TOOLKIT_I5001
+  },
+  ROLLBACK_STACK: {
+    name: "Rollback",
+    start: IO.CDK_TOOLKIT_I6100,
+    end: IO.CDK_TOOLKIT_I6000
+  },
+  DIFF_STACK: {
+    name: "Diff",
+    start: IO.CDK_TOOLKIT_I4000,
+    end: IO.CDK_TOOLKIT_I4001
+  },
+  DESTROY_STACK: {
+    name: "Destroy",
+    start: IO.CDK_TOOLKIT_I7100,
+    end: IO.CDK_TOOLKIT_I7001
+  },
+  DESTROY_ACTION: {
+    name: "Destroy",
+    start: IO.CDK_TOOLKIT_I7101,
+    end: IO.CDK_TOOLKIT_I7000
+  },
+  BOOTSTRAP_SINGLE: {
+    name: "Bootstrap",
+    start: IO.CDK_TOOLKIT_I9100,
+    end: IO.CDK_TOOLKIT_I9000
+  },
+  BUILD_ASSET: {
+    name: "Build Asset",
+    start: IO.CDK_TOOLKIT_I5210,
+    end: IO.CDK_TOOLKIT_I5211
+  },
+  PUBLISH_ASSET: {
+    name: "Publish Asset",
+    start: IO.CDK_TOOLKIT_I5220,
+    end: IO.CDK_TOOLKIT_I5221
+  },
+  HOTSWAP: {
+    name: "hotswap-deployment",
+    start: IO.CDK_TOOLKIT_I5400,
+    end: IO.CDK_TOOLKIT_I5410
+  }
+};
+
+// ../tmp-toolkit-helpers/src/api/io/private/io-default-messages.ts
+var util = __toESM(require("util"));
+var IoDefaultMessages = class {
+  constructor(ioHelper) {
+    this.ioHelper = ioHelper;
+  }
+  notify(msg) {
+    return this.ioHelper.notify(msg);
+  }
+  requestResponse(msg) {
+    return this.ioHelper.requestResponse(msg);
+  }
+  error(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_ERROR, input, ...args);
+  }
+  warn(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_WARN, input, ...args);
+  }
+  warning(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_WARN, input, ...args);
+  }
+  info(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_INFO, input, ...args);
+  }
+  debug(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_DEBUG, input, ...args);
+  }
+  trace(input, ...args) {
+    this.emitMessage(IO.DEFAULT_TOOLKIT_TRACE, input, ...args);
+  }
+  result(input, ...args) {
+    const message2 = args.length > 0 ? util.format(input, ...args) : input;
+    void this.ioHelper.notify({
+      time: /* @__PURE__ */ new Date(),
+      code: IO.DEFAULT_TOOLKIT_INFO.code,
+      level: "result",
+      message: message2,
+      data: void 0
+    });
+  }
+  emitMessage(maker, input, ...args) {
+    const message2 = args.length > 0 ? util.format(input, ...args) : input;
+    void this.ioHelper.notify(maker.msg(message2));
+  }
+};
+
 // ../tmp-toolkit-helpers/src/api/require-approval.ts
 var RequireApproval = /* @__PURE__ */ ((RequireApproval2) => {
   RequireApproval2["NEVER"] = "never";
@@ -169,15 +843,231 @@ var RequireApproval = /* @__PURE__ */ ((RequireApproval2) => {
   RequireApproval2["BROADENING"] = "broadening";
   return RequireApproval2;
 })(RequireApproval || {});
+
+// ../tmp-toolkit-helpers/src/api/diff/diff-formatter.ts
+var StringWriteStream = class extends import_stream.Writable {
+  buffer = [];
+  constructor() {
+    super();
+  }
+  _write(chunk, _encoding, callback) {
+    this.buffer.push(chunk.toString());
+    callback();
+  }
+  toString() {
+    return this.buffer.join("");
+  }
+};
+var DiffFormatter = class {
+  ioHelper;
+  oldTemplate;
+  newTemplate;
+  constructor(props) {
+    this.ioHelper = props.ioHelper;
+    this.oldTemplate = props.oldTemplate;
+    this.newTemplate = props.newTemplate;
+  }
+  /**
+   * Format the stack diff
+   */
+  formatStackDiff(options) {
+    const ioDefaultHelper = new IoDefaultMessages(this.ioHelper);
+    return this.formatStackDiffHelper(
+      this.oldTemplate,
+      options.stackName,
+      options.nestedStackTemplates,
+      {
+        ...options,
+        ioDefaultHelper
+      }
+    );
+  }
+  formatStackDiffHelper(oldTemplate, stackName, nestedStackTemplates, options) {
+    let diff = (0, import_cloudformation_diff.fullDiff)(oldTemplate, this.newTemplate.template, options.changeSet, options.isImport);
+    const stream = new StringWriteStream();
+    let numStacksWithChanges = 0;
+    let formattedDiff = "";
+    let filteredChangesCount = 0;
+    try {
+      if (stackName && (!options.quiet || !diff.isEmpty)) {
+        stream.write((0, import_node_util.format)(`Stack ${chalk.bold(stackName)}
+`));
+      }
+      if (!options.quiet && options.isImport) {
+        stream.write("Parameters and rules created during migration do not affect resource configuration.\n");
+      }
+      if (diff.differenceCount && !options.strict) {
+        const mangledNewTemplate = JSON.parse((0, import_cloudformation_diff.mangleLikeCloudFormation)(JSON.stringify(this.newTemplate.template)));
+        const mangledDiff = (0, import_cloudformation_diff.fullDiff)(this.oldTemplate, mangledNewTemplate, options.changeSet);
+        filteredChangesCount = Math.max(0, diff.differenceCount - mangledDiff.differenceCount);
+        if (filteredChangesCount > 0) {
+          diff = mangledDiff;
+        }
+      }
+      if (!options.strict) {
+        obscureDiff(diff);
+      }
+      if (!diff.isEmpty) {
+        numStacksWithChanges++;
+        (0, import_cloudformation_diff.formatDifferences)(stream, diff, {
+          ...logicalIdMapFromTemplate(this.oldTemplate),
+          ...buildLogicalToPathMap(this.newTemplate)
+        }, options.context);
+      } else if (!options.quiet) {
+        stream.write(chalk.green("There were no differences\n"));
+      }
+      if (filteredChangesCount > 0) {
+        stream.write(chalk.yellow(`Omitted ${filteredChangesCount} changes because they are likely mangled non-ASCII characters. Use --strict to print them.
+`));
+      }
+    } finally {
+      formattedDiff = stream.toString();
+      stream.end();
+    }
+    for (const nestedStackLogicalId of Object.keys(nestedStackTemplates ?? {})) {
+      if (!nestedStackTemplates) {
+        break;
+      }
+      const nestedStack = nestedStackTemplates[nestedStackLogicalId];
+      this.newTemplate._template = nestedStack.generatedTemplate;
+      const nextDiff = this.formatStackDiffHelper(
+        nestedStack.deployedTemplate,
+        nestedStack.physicalName ?? nestedStackLogicalId,
+        nestedStack.nestedStackTemplates,
+        options
+      );
+      numStacksWithChanges += nextDiff.numStacksWithChanges;
+      formattedDiff += nextDiff.formattedDiff;
+    }
+    return {
+      numStacksWithChanges,
+      formattedDiff
+    };
+  }
+  /**
+   * Format the security diff
+   */
+  formatSecurityDiff(options) {
+    const ioDefaultHelper = new IoDefaultMessages(this.ioHelper);
+    const diff = (0, import_cloudformation_diff.fullDiff)(this.oldTemplate, this.newTemplate.template, options.changeSet);
+    if (diffRequiresApproval(diff, options.requireApproval)) {
+      const stream = new StringWriteStream();
+      stream.write((0, import_node_util.format)(`Stack ${chalk.bold(options.stackName)}
+`));
+      ioDefaultHelper.warning(`This deployment will make potentially sensitive changes according to your current security approval level (--require-approval ${options.requireApproval}).`);
+      ioDefaultHelper.warning("Please confirm you intend to make the following modifications:\n");
+      try {
+        (0, import_cloudformation_diff.formatSecurityChanges)(stream, diff, buildLogicalToPathMap(this.newTemplate));
+      } finally {
+        stream.end();
+      }
+      const formattedDiff = stream.toString();
+      return { formattedDiff };
+    }
+    return {};
+  }
+};
+function diffRequiresApproval(diff, requireApproval) {
+  switch (requireApproval) {
+    case "never" /* NEVER */:
+      return false;
+    case "any-change" /* ANY_CHANGE */:
+      return diff.permissionsAnyChanges;
+    case "broadening" /* BROADENING */:
+      return diff.permissionsBroadened;
+    default:
+      throw new ToolkitError(`Unrecognized approval level: ${requireApproval}`);
+  }
+}
+function buildLogicalToPathMap(stack) {
+  const map = {};
+  for (const md of stack.findMetadataByType(cxschema.ArtifactMetadataEntryType.LOGICAL_ID)) {
+    map[md.data] = md.path;
+  }
+  return map;
+}
+function logicalIdMapFromTemplate(template) {
+  const ret = {};
+  for (const [logicalId, resource] of Object.entries(template.Resources ?? {})) {
+    const path = resource?.Metadata?.["aws:cdk:path"];
+    if (path) {
+      ret[logicalId] = path;
+    }
+  }
+  return ret;
+}
+function obscureDiff(diff) {
+  if (diff.unknown) {
+    diff.unknown = diff.unknown.filter((change) => {
+      if (!change) {
+        return true;
+      }
+      if (change.newValue?.CheckBootstrapVersion) {
+        return false;
+      }
+      if (change.oldValue?.CheckBootstrapVersion) {
+        return false;
+      }
+      return true;
+    });
+  }
+  if (diff.resources) {
+    diff.resources = diff.resources.filter((change) => {
+      if (!change) {
+        return true;
+      }
+      if (change.newResourceType === "AWS::CDK::Metadata") {
+        return false;
+      }
+      if (change.oldResourceType === "AWS::CDK::Metadata") {
+        return false;
+      }
+      return true;
+    });
+  }
+}
+
+// ../tmp-toolkit-helpers/src/api/io/payloads/diff.ts
+var PermissionChangeType = /* @__PURE__ */ ((PermissionChangeType2) => {
+  PermissionChangeType2["NONE"] = "none";
+  PermissionChangeType2["BROADENING"] = "broadening";
+  PermissionChangeType2["NON_BROADENING"] = "non-broadening";
+  return PermissionChangeType2;
+})(PermissionChangeType || {});
+
+// ../tmp-toolkit-helpers/src/api/io/payloads/hotswap.ts
+var NonHotswappableReason = /* @__PURE__ */ ((NonHotswappableReason2) => {
+  NonHotswappableReason2["TAGS"] = "tags";
+  NonHotswappableReason2["PROPERTIES"] = "properties";
+  NonHotswappableReason2["OUTPUT"] = "output";
+  NonHotswappableReason2["DEPENDENCY_UNSUPPORTED"] = "dependency-unsupported";
+  NonHotswappableReason2["RESOURCE_UNSUPPORTED"] = "resource-unsupported";
+  NonHotswappableReason2["RESOURCE_CREATION"] = "resource-creation";
+  NonHotswappableReason2["RESOURCE_DELETION"] = "resource-deletion";
+  NonHotswappableReason2["RESOURCE_TYPE_CHANGED"] = "resource-type-changed";
+  NonHotswappableReason2["NESTED_STACK_CREATION"] = "nested-stack-creation";
+  return NonHotswappableReason2;
+})(NonHotswappableReason || {});
+
+// ../tmp-toolkit-helpers/src/api/resource-import/importer.ts
+function removeNonImportResources(stack) {
+  const template = stack.template;
+  delete template.Resources.CDKMetadata;
+  delete template.Outputs;
+  return template;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AssemblyError,
   AuthenticationError,
   ContextProviderError,
+  DiffFormatter,
   ExpandStackSelection,
+  NonHotswappableReason,
   PermissionChangeType,
   RequireApproval,
   StackSelectionStrategy,
-  ToolkitError
+  ToolkitError,
+  removeNonImportResources
 });
 //# sourceMappingURL=shared-public.js.map