@aws-cdk/toolkit-lib 0.3.0 → 0.3.2

package/lib/api/cloud-assembly/private/stack-assembly.js

@@ -1,14 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StackAssembly = void 0;
+require("../../../private/dispose-polyfill");
 const semver_1 = require("semver");
 const shared_private_1 = require("../../shared-private");
 const shared_public_1 = require("../../shared-public");
 const stack_selector_1 = require("../stack-selector");
-if (!Symbol.asyncDispose) {
-    // eslint-disable-next-line @cdklabs/no-throw-default-error
-    throw new Error('Symbol.asyncDispose is not defined on the current JavaScript platform!');
-}
 /**
  * A single Cloud Assembly wrapped to provide additional stack operations.
  */
@@ -109,4 +106,4 @@ function expandToExtendEnum(extend) {
             return undefined;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-assembly.js","sourceRoot":"","sources":["stack-assembly.ts"],"names":[],"mappings":"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","sourcesContent":["import { major } from 'semver';\nimport type { IoHelper } from '../../shared-private';\nimport { BaseStackAssembly, StackCollection, ExtendedStackSelection as CliExtendedStackSelection } from '../../shared-private';\nimport { ToolkitError } from '../../shared-public';\nimport type { StackSelector } from '../stack-selector';\nimport { ExpandStackSelection, StackSelectionStrategy } from '../stack-selector';\nimport type { IReadableCloudAssembly } from '../types';\n\nif (!Symbol.asyncDispose) {\n  // eslint-disable-next-line @cdklabs/no-throw-default-error\n  throw new Error('Symbol.asyncDispose is not defined on the current JavaScript platform!');\n}\n\n/**\n * A single Cloud Assembly wrapped to provide additional stack operations.\n */\nexport class StackAssembly extends BaseStackAssembly implements IReadableCloudAssembly {\n  constructor(private readonly _asm: IReadableCloudAssembly, ioHelper: IoHelper) {\n    super(_asm.cloudAssembly, ioHelper);\n  }\n\n  public get cloudAssembly() {\n    return this._asm.cloudAssembly;\n  }\n\n  public async _unlock() {\n    return this._asm._unlock();\n  }\n\n  public async dispose() {\n    return this._asm.dispose();\n  }\n\n  public async [Symbol.asyncDispose]() {\n    return this.dispose();\n  }\n\n  /**\n   * Improved stack selection interface with a single selector\n   * @throws when the assembly does not contain any stacks, unless `selector.failOnEmpty` is `false`\n   * @throws when individual selection strategies are not satisfied\n   */\n  public async selectStacksV2(selector: StackSelector): Promise<StackCollection> {\n    const asm = this.assembly;\n    const topLevelStacks = asm.stacks;\n    const allStacks = major(asm.version) < 10 ? asm.stacks : asm.stacksRecursively;\n\n    if (allStacks.length === 0 && (selector.failOnEmpty ?? true)) {\n      throw new ToolkitError('This app contains no stacks');\n    }\n\n    const extend = expandToExtendEnum(selector.expand);\n    const patterns = StackAssembly.sanitizePatterns(selector.patterns ?? []);\n\n    switch (selector.strategy) {\n      case StackSelectionStrategy.ALL_STACKS:\n        return new StackCollection(this, allStacks);\n      case StackSelectionStrategy.MAIN_ASSEMBLY:\n        if (topLevelStacks.length < 1) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError('No stack found in the main cloud assembly. Use \"list\" to print manifest');\n        }\n        return this.extendStacks(topLevelStacks, allStacks, extend);\n      case StackSelectionStrategy.ONLY_SINGLE:\n        if (topLevelStacks.length !== 1) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError('Since this app includes more than a single stack, specify which stacks to use (wildcards are supported) or specify `--all`\\n' +\n          `Stacks: ${allStacks.map(x => x.hierarchicalId).join(' · ')}`);\n        }\n        return new StackCollection(this, topLevelStacks);\n      default:\n        const matched = await this.selectMatchingStacks(allStacks, patterns, extend);\n        if (\n          selector.strategy === StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE\n          && matched.stackCount !== 1\n        ) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError(\n            `Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`,\n          );\n        }\n        if (\n          selector.strategy === StackSelectionStrategy.PATTERN_MUST_MATCH\n          && matched.stackCount < 1\n        ) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError(\n            `Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`,\n          );\n        }\n\n        return matched;\n    }\n  }\n\n  /**\n   * Select all stacks.\n   *\n   * This method never throws and can safely be used as a basis for other calculations.\n   *\n   * @returns a `StackCollection` of all stacks\n   */\n  public selectAllStacks() {\n    const allStacks = major(this.assembly.version) < 10 ? this.assembly.stacks : this.assembly.stacksRecursively;\n    return new StackCollection(this, allStacks);\n  }\n\n  /**\n   * Select all stacks that have the validateOnSynth flag et.\n   *\n   * @returns a `StackCollection` of all stacks that needs to be validated\n   */\n  public selectStacksForValidation() {\n    const allStacks = this.selectAllStacks();\n    return allStacks.filter((art) => art.validateOnSynth ?? false);\n  }\n}\n\nfunction expandToExtendEnum(extend?: ExpandStackSelection): CliExtendedStackSelection | undefined {\n  switch (extend) {\n    case ExpandStackSelection.DOWNSTREAM:\n      return CliExtendedStackSelection.Downstream;\n    case ExpandStackSelection.UPSTREAM:\n      return CliExtendedStackSelection.Upstream;\n    case ExpandStackSelection.NONE:\n      return CliExtendedStackSelection.None;\n    default:\n      return undefined;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stack-assembly.js","sourceRoot":"","sources":["stack-assembly.ts"],"names":[],"mappings":";;;AAAA,6CAA2C;AAC3C,mCAA+B;AAE/B,yDAA+H;AAC/H,uDAAmD;AAEnD,sDAAiF;AAGjF;;GAEG;AACH,MAAa,aAAc,SAAQ,kCAAiB;IACrB;IAA7B,YAA6B,IAA4B,EAAE,QAAkB;QAC3E,KAAK,CAAC,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;QADT,SAAI,GAAJ,IAAI,CAAwB;IAEzD,CAAC;IAED,IAAW,aAAa;QACtB,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;IACjC,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAEM,KAAK,CAAC,OAAO;QAClB,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAEM,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC;QAChC,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,cAAc,CAAC,QAAuB;QACjD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC;QAC1B,MAAM,cAAc,GAAG,GAAG,CAAC,MAAM,CAAC;QAClC,MAAM,SAAS,GAAG,IAAA,cAAK,EAAC,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,iBAAiB,CAAC;QAE/E,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,WAAW,IAAI,IAAI,CAAC,EAAE,CAAC;YAC7D,MAAM,IAAI,4BAAY,CAAC,6BAA6B,CAAC,CAAC;QACxD,CAAC;QAED,MAAM,MAAM,GAAG,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACnD,MAAM,QAAQ,GAAG,aAAa,CAAC,gBAAgB,CAAC,QAAQ,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC;QAEzE,QAAQ,QAAQ,CAAC,QAAQ,EAAE,CAAC;YAC1B,KAAK,uCAAsB,CAAC,UAAU;gBACpC,OAAO,IAAI,gCAAe,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;YAC9C,KAAK,uCAAsB,CAAC,aAAa;gBACvC,IAAI,cAAc,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBAC9B,mDAAmD;oBACnD,MAAM,IAAI,4BAAY,CAAC,yEAAyE,CAAC,CAAC;gBACpG,CAAC;gBACD,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;YAC9D,KAAK,uCAAsB,CAAC,WAAW;gBACrC,IAAI,cAAc,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;oBAChC,mDAAmD;oBACnD,MAAM,IAAI,4BAAY,CAAC,8HAA8H;wBACrJ,WAAW,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBACjE,CAAC;gBACD,OAAO,IAAI,gCAAe,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC;YACnD;gBACE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;gBAC7E,IACE,QAAQ,CAAC,QAAQ,KAAK,uCAAsB,CAAC,yBAAyB;uBACnE,OAAO,CAAC,UAAU,KAAK,CAAC,EAC3B,CAAC;oBACD,mDAAmD;oBACnD,MAAM,IAAI,4BAAY,CACpB,4EAA4E,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAC9H,CAAC;gBACJ,CAAC;gBACD,IACE,QAAQ,CAAC,QAAQ,KAAK,uCAAsB,CAAC,kBAAkB;uBAC5D,OAAO,CAAC,UAAU,GAAG,CAAC,EACzB,CAAC;oBACD,mDAAmD;oBACnD,MAAM,IAAI,4BAAY,CACpB,4EAA4E,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAC9H,CAAC;gBACJ,CAAC;gBAED,OAAO,OAAO,CAAC;QACnB,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACI,eAAe;QACpB,MAAM,SAAS,GAAG,IAAA,cAAK,EAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC;QAC7G,OAAO,IAAI,gCAAe,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACI,yBAAyB;QAC9B,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC;QACzC,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,eAAe,IAAI,KAAK,CAAC,CAAC;IACjE,CAAC;CACF;AApGD,sCAoGC;AAED,SAAS,kBAAkB,CAAC,MAA6B;IACvD,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,qCAAoB,CAAC,UAAU;YAClC,OAAO,uCAAyB,CAAC,UAAU,CAAC;QAC9C,KAAK,qCAAoB,CAAC,QAAQ;YAChC,OAAO,uCAAyB,CAAC,QAAQ,CAAC;QAC5C,KAAK,qCAAoB,CAAC,IAAI;YAC5B,OAAO,uCAAyB,CAAC,IAAI,CAAC;QACxC;YACE,OAAO,SAAS,CAAC;IACrB,CAAC;AACH,CAAC","sourcesContent":["import '../../../private/dispose-polyfill';\nimport { major } from 'semver';\nimport type { IoHelper } from '../../shared-private';\nimport { BaseStackAssembly, StackCollection, ExtendedStackSelection as CliExtendedStackSelection } from '../../shared-private';\nimport { ToolkitError } from '../../shared-public';\nimport type { StackSelector } from '../stack-selector';\nimport { ExpandStackSelection, StackSelectionStrategy } from '../stack-selector';\nimport type { IReadableCloudAssembly } from '../types';\n\n/**\n * A single Cloud Assembly wrapped to provide additional stack operations.\n */\nexport class StackAssembly extends BaseStackAssembly implements IReadableCloudAssembly {\n  constructor(private readonly _asm: IReadableCloudAssembly, ioHelper: IoHelper) {\n    super(_asm.cloudAssembly, ioHelper);\n  }\n\n  public get cloudAssembly() {\n    return this._asm.cloudAssembly;\n  }\n\n  public async _unlock() {\n    return this._asm._unlock();\n  }\n\n  public async dispose() {\n    return this._asm.dispose();\n  }\n\n  public async [Symbol.asyncDispose]() {\n    return this.dispose();\n  }\n\n  /**\n   * Improved stack selection interface with a single selector\n   * @throws when the assembly does not contain any stacks, unless `selector.failOnEmpty` is `false`\n   * @throws when individual selection strategies are not satisfied\n   */\n  public async selectStacksV2(selector: StackSelector): Promise<StackCollection> {\n    const asm = this.assembly;\n    const topLevelStacks = asm.stacks;\n    const allStacks = major(asm.version) < 10 ? asm.stacks : asm.stacksRecursively;\n\n    if (allStacks.length === 0 && (selector.failOnEmpty ?? true)) {\n      throw new ToolkitError('This app contains no stacks');\n    }\n\n    const extend = expandToExtendEnum(selector.expand);\n    const patterns = StackAssembly.sanitizePatterns(selector.patterns ?? []);\n\n    switch (selector.strategy) {\n      case StackSelectionStrategy.ALL_STACKS:\n        return new StackCollection(this, allStacks);\n      case StackSelectionStrategy.MAIN_ASSEMBLY:\n        if (topLevelStacks.length < 1) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError('No stack found in the main cloud assembly. Use \"list\" to print manifest');\n        }\n        return this.extendStacks(topLevelStacks, allStacks, extend);\n      case StackSelectionStrategy.ONLY_SINGLE:\n        if (topLevelStacks.length !== 1) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError('Since this app includes more than a single stack, specify which stacks to use (wildcards are supported) or specify `--all`\\n' +\n          `Stacks: ${allStacks.map(x => x.hierarchicalId).join(' · ')}`);\n        }\n        return new StackCollection(this, topLevelStacks);\n      default:\n        const matched = await this.selectMatchingStacks(allStacks, patterns, extend);\n        if (\n          selector.strategy === StackSelectionStrategy.PATTERN_MUST_MATCH_SINGLE\n          && matched.stackCount !== 1\n        ) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError(\n            `Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`,\n          );\n        }\n        if (\n          selector.strategy === StackSelectionStrategy.PATTERN_MUST_MATCH\n          && matched.stackCount < 1\n        ) {\n          // @todo text should probably be handled in io host\n          throw new ToolkitError(\n            `Stack selection is ambiguous, please choose a specific stack for import [${allStacks.map(x => x.hierarchicalId).join(',')}]`,\n          );\n        }\n\n        return matched;\n    }\n  }\n\n  /**\n   * Select all stacks.\n   *\n   * This method never throws and can safely be used as a basis for other calculations.\n   *\n   * @returns a `StackCollection` of all stacks\n   */\n  public selectAllStacks() {\n    const allStacks = major(this.assembly.version) < 10 ? this.assembly.stacks : this.assembly.stacksRecursively;\n    return new StackCollection(this, allStacks);\n  }\n\n  /**\n   * Select all stacks that have the validateOnSynth flag et.\n   *\n   * @returns a `StackCollection` of all stacks that needs to be validated\n   */\n  public selectStacksForValidation() {\n    const allStacks = this.selectAllStacks();\n    return allStacks.filter((art) => art.validateOnSynth ?? false);\n  }\n}\n\nfunction expandToExtendEnum(extend?: ExpandStackSelection): CliExtendedStackSelection | undefined {\n  switch (extend) {\n    case ExpandStackSelection.DOWNSTREAM:\n      return CliExtendedStackSelection.Downstream;\n    case ExpandStackSelection.UPSTREAM:\n      return CliExtendedStackSelection.Upstream;\n    case ExpandStackSelection.NONE:\n      return CliExtendedStackSelection.None;\n    default:\n      return undefined;\n  }\n}\n"]}

package/lib/api/shared-private.d.ts

@@ -2,4 +2,5 @@ export * from '../../../tmp-toolkit-helpers/src/api/io/private';
 export * from '../../../tmp-toolkit-helpers/src/private';
 export * from '../../../tmp-toolkit-helpers/src/api';
 export * as cfnApi from '../../../tmp-toolkit-helpers/src/api/deployments/cfn-api';
+export { makeRequestHandler } from '../../../tmp-toolkit-helpers/src/api/aws-auth/awscli-compatible';
 export * as contextproviders from '../../../tmp-toolkit-helpers/src/context-providers';

package/lib/api/shared-private.js

@@ -156,6 +156,7 @@ __export(shared_private_exports, {
   loadTree: () => loadTree,
   loadTreeFromDir: () => loadTreeFromDir,
   makeBodyParameter: () => makeBodyParameter,
+  makeRequestHandler: () => makeRequestHandler,
   markTesting: () => markTesting,
   nonHotswappableChange: () => nonHotswappableChange,
   nonHotswappableResource: () => nonHotswappableResource,
@@ -2468,8 +2469,20 @@ var DEFAULT_CONNECTION_TIMEOUT = 1e4;
 var DEFAULT_TIMEOUT = 3e5;
 var AwsCliCompatible = class {
   ioHelper;
-  constructor(ioHelper) {
+  requestHandler;
+  logger;
+  constructor(ioHelper, requestHandler, logger) {
     this.ioHelper = ioHelper;
+    this.requestHandler = requestHandler;
+    this.logger = logger;
+  }
+  async baseConfig(profile) {
+    const credentialProvider = await this.credentialChainBuilder({
+      profile,
+      logger: this.logger
+    });
+    const defaultRegion = await this.region(profile);
+    return { credentialProvider, defaultRegion };
   }
   /**
    * Build an AWS CLI-compatible credential chain provider
@@ -2478,7 +2491,7 @@ var AwsCliCompatible = class {
    */
   async credentialChainBuilder(options = {}) {
     const clientConfig = {
-      requestHandler: await this.requestHandlerBuilder(options.httpOptions),
+      requestHandler: this.requestHandler,
       customUserAgent: "aws-cdk",
       logger: options.logger
     };
@@ -2506,15 +2519,6 @@ var AwsCliCompatible = class {
     });
     return shouldPrioritizeEnv() ? (0, import_credential_providers.createCredentialChain)((0, import_credential_providers.fromEnv)(), nodeProviderChain).expireAfter(60 * 6e4) : nodeProviderChain;
   }
-  async requestHandlerBuilder(options = {}) {
-    const agent = await new ProxyAgentProvider(this.ioHelper).create(options);
-    return {
-      connectionTimeout: DEFAULT_CONNECTION_TIMEOUT,
-      requestTimeout: DEFAULT_TIMEOUT,
-      httpsAgent: agent,
-      httpAgent: agent
-    };
-  }
   /**
    * Attempts to get the region from a number of sources and falls back to us-east-1 if no region can be found,
    * as is done in the AWS CLI.
@@ -2614,17 +2618,24 @@ function shouldPrioritizeEnv() {
   }
   return false;
 }
+async function makeRequestHandler(ioHelper, options = {}) {
+  const agent = await new ProxyAgentProvider(ioHelper).create(options);
+  return {
+    connectionTimeout: DEFAULT_CONNECTION_TIMEOUT,
+    requestTimeout: DEFAULT_TIMEOUT,
+    httpsAgent: agent,
+    httpAgent: agent
+  };
+}
 
 // ../tmp-toolkit-helpers/src/api/aws-auth/credential-plugins.ts
 var import_util9 = require("util");
 var CredentialPlugins = class {
-  cache = {};
-  host;
-  ioHelper;
   constructor(host, ioHelper) {
     this.host = host;
     this.ioHelper = ioHelper;
   }
+  cache = {};
   async fetchCredentialsFor(awsAccountId, mode) {
     const key = `${awsAccountId}-${mode}`;
     if (!(key in this.cache)) {
@@ -2731,35 +2742,56 @@ var TESTING = false;
 function markTesting() {
   TESTING = true;
 }
-var PluginHost = class _PluginHost {
-  static instance = new _PluginHost();
+var PluginHost = class {
   /**
    * Access the currently registered CredentialProviderSources. New sources can
    * be registered using the +registerCredentialProviderSource+ method.
    */
   credentialProviderSources = new Array();
   contextProviderPlugins = {};
-  constructor() {
-    if (!TESTING && _PluginHost.instance && _PluginHost.instance !== this) {
-      throw new ToolkitError("New instances of PluginHost must not be built. Use PluginHost.instance instead!");
-    }
-  }
+  ioHost;
+  alreadyLoaded = /* @__PURE__ */ new Set();
   /**
    * Loads a plug-in into this PluginHost.
    *
+   * Will use `require.resolve()` to get the most accurate representation of what
+   * code will get loaded in error messages. As such, it will not work in
+   * unit tests with Jest virtual modules becauase of <https://github.com/jestjs/jest/issues/9543>.
+   *
    * @param moduleSpec the specification (path or name) of the plug-in module to be loaded.
+   * @param ioHost the I/O host to use for printing progress information
+   */
+  load(moduleSpec, ioHost) {
+    try {
+      const resolved = require.resolve(moduleSpec);
+      if (ioHost) {
+        new IoDefaultMessages(IoHelper.fromIoHost(ioHost, "init")).debug(`Loading plug-in: ${resolved} from ${moduleSpec}`);
+      }
+      return this._doLoad(resolved);
+    } catch (e) {
+      throw new ToolkitError(`Unable to resolve plug-in: Cannot find module '${moduleSpec}': ${e}`);
+    }
+  }
+  /**
+   * Do the loading given an already-resolved module name
+   *
+   * @internal
    */
-  load(moduleSpec) {
+  _doLoad(resolved) {
     try {
-      const plugin = require(moduleSpec);
+      if (this.alreadyLoaded.has(resolved)) {
+        return;
+      }
+      const plugin = require(resolved);
       if (!isPlugin(plugin)) {
-        throw new ToolkitError(`Module ${moduleSpec} is not a valid plug-in, or has an unsupported version.`);
+        throw new ToolkitError(`Module ${resolved} is not a valid plug-in, or has an unsupported version.`);
       }
       if (plugin.init) {
         plugin.init(this);
       }
+      this.alreadyLoaded.add(resolved);
     } catch (e) {
-      throw ToolkitError.withCause(`Unable to load plug-in '${moduleSpec}'`, e);
+      throw ToolkitError.withCause(`Unable to load plug-in '${resolved}'`, e);
     }
     function isPlugin(x) {
       return x != null && x.version === "1";
@@ -2823,14 +2855,6 @@ var Mode = /* @__PURE__ */ ((Mode2) => {
 // ../tmp-toolkit-helpers/src/api/aws-auth/sdk-provider.ts
 var CACHED_ACCOUNT = Symbol("cached_account");
 var SdkProvider = class {
-  constructor(defaultCredentialProvider, defaultRegion, requestHandler = {}, ioHelper, logger) {
-    this.defaultCredentialProvider = defaultCredentialProvider;
-    this.defaultRegion = defaultRegion;
-    this.requestHandler = requestHandler;
-    this.ioHelper = ioHelper;
-    this.logger = logger;
-    this.plugins = new CredentialPlugins(PluginHost.instance, ioHelper);
-  }
   /**
    * Create a new SdkProvider which gets its defaults in a way that behaves like the AWS CLI does
    *
@@ -2838,18 +2862,24 @@ var SdkProvider = class {
    * class `AwsCliCompatible` for the details.
    */
   static async withAwsCliCompatibleDefaults(options) {
-    const builder = new AwsCliCompatible(options.ioHelper);
     callTrace(SdkProvider.withAwsCliCompatibleDefaults.name, SdkProvider.constructor.name, options.logger);
-    const credentialProvider = await builder.credentialChainBuilder({
-      profile: options.profile,
-      httpOptions: options.httpOptions,
-      logger: options.logger
-    });
-    const region = await builder.region(options.profile);
-    const requestHandler = await builder.requestHandlerBuilder(options.httpOptions);
-    return new SdkProvider(credentialProvider, region, requestHandler, options.ioHelper, options.logger);
+    const config = await new AwsCliCompatible(options.ioHelper, options.requestHandler ?? {}, options.logger).baseConfig(options.profile);
+    return new SdkProvider(config.credentialProvider, config.defaultRegion, options);
   }
+  defaultRegion;
+  defaultCredentialProvider;
   plugins;
+  requestHandler;
+  ioHelper;
+  logger;
+  constructor(defaultCredentialProvider, defaultRegion, services) {
+    this.defaultCredentialProvider = defaultCredentialProvider;
+    this.defaultRegion = defaultRegion ?? "us-east-1";
+    this.requestHandler = services.requestHandler ?? {};
+    this.ioHelper = services.ioHelper;
+    this.logger = services.logger;
+    this.plugins = new CredentialPlugins(services.pluginHost ?? new PluginHost(), this.ioHelper);
+  }
   /**
    * Return an SDK which can do operations in the given environment
    *
@@ -2865,7 +2895,7 @@ var SdkProvider = class {
       if (baseCreds.source === "incorrectDefault") {
         throw new AuthenticationError(fmtObtainCredentialsError(env.account, baseCreds));
       }
-      const sdk = new SDK(baseCreds.credentials, env.region, this.requestHandler, this.ioHelper, this.logger);
+      const sdk = this._makeSdk(baseCreds.credentials, env.region);
       await sdk.validateCredentials();
       return { sdk, didAssumeRole: false };
     }
@@ -2889,7 +2919,7 @@ var SdkProvider = class {
           `${fmtObtainedCredentials(baseCreds)} could not be used to assume '${options.assumeRoleArn}', but are for the right account. Proceeding anyway.`
         ));
         return {
-          sdk: new SDK(baseCreds.credentials, env.region, this.requestHandler, this.ioHelper, this.logger),
+          sdk: this._makeSdk(baseCreds.credentials, env.region),
           didAssumeRole: false
         };
       }
@@ -2907,7 +2937,7 @@ var SdkProvider = class {
     if (baseCreds.source === "none") {
       return void 0;
     }
-    return (await new SDK(baseCreds.credentials, env.region, this.requestHandler, this.ioHelper, this.logger).currentAccount()).partition;
+    return (await this._makeSdk(baseCreds.credentials, env.region).currentAccount()).partition;
   }
   /**
    * Resolve the environment for a stack
@@ -2949,7 +2979,7 @@ var SdkProvider = class {
   async defaultAccount() {
     return cached(this, CACHED_ACCOUNT, async () => {
       try {
-        return await new SDK(this.defaultCredentialProvider, this.defaultRegion, this.requestHandler, this.ioHelper, this.logger).currentAccount();
+        return await this._makeSdk(this.defaultCredentialProvider, this.defaultRegion).currentAccount();
       } catch (e) {
         if (e.name === "ExpiredToken") {
           await this.ioHelper.notify(IO.DEFAULT_SDK_WARN.msg(
@@ -3026,7 +3056,7 @@ var SdkProvider = class {
         logger: this.logger
       }));
       await credentials();
-      return new SDK(credentials, region, this.requestHandler, this.ioHelper, this.logger);
+      return this._makeSdk(credentials, region);
     } catch (err) {
       if (err.name === "ExpiredToken") {
         throw err;
@@ -3042,6 +3072,25 @@ var SdkProvider = class {
       );
     }
   }
+  /**
+   * Factory function that creates a new SDK instance
+   *
+   * This is a function here, instead of all the places where this is used creating a `new SDK`
+   * instance, so that it is trivial to mock from tests.
+   *
+   * Use like this:
+   *
+   * ```ts
+   * const mockSdk = jest.spyOn(SdkProvider.prototype, '_makeSdk').mockReturnValue(new MockSdk());
+   * // ...
+   * mockSdk.mockRestore();
+   * ```
+   *
+   * @internal
+   */
+  _makeSdk(credProvider, region) {
+    return new SDK(credProvider, region, this.requestHandler, this.ioHelper, this.logger);
+  }
 };
 SdkProvider = __decorateClass([
   traceMemberMethods
@@ -12315,13 +12364,13 @@ var ContextProviderMessages = class {
     }));
   }
 };
-async function provideContextValues(missingValues, context, sdk, ioHelper) {
+async function provideContextValues(missingValues, context, sdk, pluginHost, ioHelper) {
   for (const missingContext of missingValues) {
     const key = missingContext.key;
     const providerName = missingContext.provider === cxschema4.ContextProvider.PLUGIN ? `${PLUGIN_PROVIDER_PREFIX}:${missingContext.props.pluginName}` : missingContext.provider;
     let factory;
     if (providerName.startsWith(`${PLUGIN_PROVIDER_PREFIX}:`)) {
-      const plugin = PluginHost.instance.contextProviderPlugins[providerName.substring(PLUGIN_PROVIDER_PREFIX.length + 1)];
+      const plugin = pluginHost.contextProviderPlugins[providerName.substring(PLUGIN_PROVIDER_PREFIX.length + 1)];
       if (!plugin) {
         throw new ContextProviderError(`Unrecognized plugin context provider name: ${missingContext.provider}.`);
       }
@@ -12490,6 +12539,7 @@ var availableContextProviders = {
   loadTree,
   loadTreeFromDir,
   makeBodyParameter,
+  makeRequestHandler,
   markTesting,
   nonHotswappableChange,
   nonHotswappableResource,