replicas-mcp 0.2.2 → 0.2.4

package/dist/{chunk-MO4EEYFW.js → chunk-Q6JESX2O.js}

@@ -12,7 +12,11 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 var __commonJS = (cb, mod) => function __require2() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {

package/dist/chunk-QIOBV22I.js

@@ -0,0 +1,436 @@
+#!/usr/bin/env node
+import {
+  HttpResponse,
+  buildQueryString
+} from "./chunk-3X3IL2A6.js";
+
+// ../node_modules/.bun/@smithy+node-http-handler@4.7.7/node_modules/@smithy/node-http-handler/dist-es/build-abort-error.js
+function buildAbortError(abortSignal) {
+  const reason = abortSignal && typeof abortSignal === "object" && "reason" in abortSignal ? abortSignal.reason : void 0;
+  if (reason) {
+    if (reason instanceof Error) {
+      const abortError3 = new Error("Request aborted");
+      abortError3.name = "AbortError";
+      abortError3.cause = reason;
+      return abortError3;
+    }
+    const abortError2 = new Error(String(reason));
+    abortError2.name = "AbortError";
+    return abortError2;
+  }
+  const abortError = new Error("Request aborted");
+  abortError.name = "AbortError";
+  return abortError;
+}
+
+// ../node_modules/.bun/@smithy+node-http-handler@4.7.7/node_modules/@smithy/node-http-handler/dist-es/constants.js
+var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"];
+
+// ../node_modules/.bun/@smithy+node-http-handler@4.7.7/node_modules/@smithy/node-http-handler/dist-es/get-transformed-headers.js
+var getTransformedHeaders = (headers) => {
+  const transformedHeaders = {};
+  for (const name in headers) {
+    const headerValues = headers[name];
+    transformedHeaders[name] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues;
+  }
+  return transformedHeaders;
+};
+
+// ../node_modules/.bun/@smithy+node-http-handler@4.7.7/node_modules/@smithy/node-http-handler/dist-es/node-https.js
+import node_https from "https";
+
+// ../node_modules/.bun/@smithy+node-http-handler@4.7.7/node_modules/@smithy/node-http-handler/dist-es/timing.js
+var timing = {
+  setTimeout: (cb, ms) => setTimeout(cb, ms),
+  clearTimeout: (timeoutId) => clearTimeout(timeoutId)
+};
+
+// ../node_modules/.bun/@smithy+node-http-handler@4.7.7/node_modules/@smithy/node-http-handler/dist-es/set-connection-timeout.js
+var DEFER_EVENT_LISTENER_TIME = 1e3;
+var setConnectionTimeout = (request, reject, timeoutInMs = 0) => {
+  if (!timeoutInMs) {
+    return -1;
+  }
+  const registerTimeout = (offset) => {
+    const timeoutId = timing.setTimeout(() => {
+      request.destroy();
+      reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket did not establish a connection with the server within the configured timeout of ${timeoutInMs} ms.`), {
+        name: "TimeoutError"
+      }));
+    }, timeoutInMs - offset);
+    const doWithSocket = (socket) => {
+      if (socket?.connecting) {
+        socket.on("connect", () => {
+          timing.clearTimeout(timeoutId);
+        });
+      } else {
+        timing.clearTimeout(timeoutId);
+      }
+    };
+    if (request.socket) {
+      doWithSocket(request.socket);
+    } else {
+      request.on("socket", doWithSocket);
+    }
+  };
+  if (timeoutInMs < 2e3) {
+    registerTimeout(0);
+    return 0;
+  }
+  return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
+};
+
+// ../node_modules/.bun/@smithy+node-http-handler@4.7.7/node_modules/@smithy/node-http-handler/dist-es/set-request-timeout.js
+var setRequestTimeout = (req, reject, timeoutInMs = 0, throwOnRequestTimeout, logger) => {
+  if (timeoutInMs) {
+    return timing.setTimeout(() => {
+      let msg = `@smithy/node-http-handler - [${throwOnRequestTimeout ? "ERROR" : "WARN"}] a request has exceeded the configured ${timeoutInMs} ms requestTimeout.`;
+      if (throwOnRequestTimeout) {
+        const error = Object.assign(new Error(msg), {
+          name: "TimeoutError",
+          code: "ETIMEDOUT"
+        });
+        req.destroy(error);
+        reject(error);
+      } else {
+        msg += ` Init client requestHandler with throwOnRequestTimeout=true to turn this into an error.`;
+        logger?.warn?.(msg);
+      }
+    }, timeoutInMs);
+  }
+  return -1;
+};
+
+// ../node_modules/.bun/@smithy+node-http-handler@4.7.7/node_modules/@smithy/node-http-handler/dist-es/set-socket-keep-alive.js
+var DEFER_EVENT_LISTENER_TIME2 = 3e3;
+var setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME2) => {
+  if (keepAlive !== true) {
+    return -1;
+  }
+  const registerListener = () => {
+    if (request.socket) {
+      request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+    } else {
+      request.on("socket", (socket) => {
+        socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
+      });
+    }
+  };
+  if (deferTimeMs === 0) {
+    registerListener();
+    return 0;
+  }
+  return timing.setTimeout(registerListener, deferTimeMs);
+};
+
+// ../node_modules/.bun/@smithy+node-http-handler@4.7.7/node_modules/@smithy/node-http-handler/dist-es/set-socket-timeout.js
+var DEFER_EVENT_LISTENER_TIME3 = 3e3;
+var setSocketTimeout = (request, reject, timeoutInMs = 0) => {
+  const registerTimeout = (offset) => {
+    const timeout = timeoutInMs - offset;
+    const onTimeout = () => {
+      request.destroy();
+      reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket timed out after ${timeoutInMs} ms of inactivity (configured by client requestHandler).`), { name: "TimeoutError" }));
+    };
+    if (request.socket) {
+      request.socket.setTimeout(timeout, onTimeout);
+      request.on("close", () => request.socket?.removeListener("timeout", onTimeout));
+    } else {
+      request.setTimeout(timeout, onTimeout);
+    }
+  };
+  if (0 < timeoutInMs && timeoutInMs < 6e3) {
+    registerTimeout(0);
+    return 0;
+  }
+  return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME3), DEFER_EVENT_LISTENER_TIME3);
+};
+
+// ../node_modules/.bun/@smithy+node-http-handler@4.7.7/node_modules/@smithy/node-http-handler/dist-es/write-request-body.js
+import { Readable } from "stream";
+var MIN_WAIT_TIME = 6e3;
+async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME, externalAgent = false) {
+  const headers = request.headers;
+  const expect = headers ? headers.Expect || headers.expect : void 0;
+  let timeoutId = -1;
+  let sendBody = true;
+  if (!externalAgent && expect === "100-continue") {
+    sendBody = await Promise.race([
+      new Promise((resolve) => {
+        timeoutId = Number(timing.setTimeout(() => resolve(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
+      }),
+      new Promise((resolve) => {
+        httpRequest.on("continue", () => {
+          timing.clearTimeout(timeoutId);
+          resolve(true);
+        });
+        httpRequest.on("response", () => {
+          timing.clearTimeout(timeoutId);
+          resolve(false);
+        });
+        httpRequest.on("error", () => {
+          timing.clearTimeout(timeoutId);
+          resolve(false);
+        });
+      })
+    ]);
+  }
+  if (sendBody) {
+    writeBody(httpRequest, request.body);
+  }
+}
+function writeBody(httpRequest, body) {
+  if (body instanceof Readable) {
+    body.pipe(httpRequest);
+    return;
+  }
+  if (body) {
+    const isBuffer = Buffer.isBuffer(body);
+    const isString = typeof body === "string";
+    if (isBuffer || isString) {
+      if (isBuffer && body.byteLength === 0) {
+        httpRequest.end();
+      } else {
+        httpRequest.end(body);
+      }
+      return;
+    }
+    const uint8 = body;
+    if (typeof uint8 === "object" && uint8.buffer && typeof uint8.byteOffset === "number" && typeof uint8.byteLength === "number") {
+      httpRequest.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength));
+      return;
+    }
+    httpRequest.end(Buffer.from(body));
+    return;
+  }
+  httpRequest.end();
+}
+
+// ../node_modules/.bun/@smithy+node-http-handler@4.7.7/node_modules/@smithy/node-http-handler/dist-es/node-http-handler.js
+var hAgent = void 0;
+var hRequest = void 0;
+var NodeHttpHandler = class _NodeHttpHandler {
+  config;
+  configProvider;
+  socketWarningTimestamp = 0;
+  externalAgent = false;
+  metadata = { handlerProtocol: "http/1.1" };
+  static create(instanceOrOptions) {
+    if (typeof instanceOrOptions?.handle === "function") {
+      return instanceOrOptions;
+    }
+    return new _NodeHttpHandler(instanceOrOptions);
+  }
+  static checkSocketUsage(agent, socketWarningTimestamp, logger = console) {
+    const { sockets, requests, maxSockets } = agent;
+    if (typeof maxSockets !== "number" || maxSockets === Infinity) {
+      return socketWarningTimestamp;
+    }
+    const interval = 15e3;
+    if (Date.now() - interval < socketWarningTimestamp) {
+      return socketWarningTimestamp;
+    }
+    if (sockets && requests) {
+      for (const origin in sockets) {
+        const socketsInUse = sockets[origin]?.length ?? 0;
+        const requestsEnqueued = requests[origin]?.length ?? 0;
+        if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
+          logger?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
+See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
+or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`);
+          return Date.now();
+        }
+      }
+    }
+    return socketWarningTimestamp;
+  }
+  constructor(options) {
+    this.configProvider = new Promise((resolve, reject) => {
+      if (typeof options === "function") {
+        options().then((_options) => {
+          resolve(this.resolveDefaultConfig(_options));
+        }).catch(reject);
+      } else {
+        resolve(this.resolveDefaultConfig(options));
+      }
+    });
+  }
+  destroy() {
+    this.config?.httpAgent?.destroy();
+    this.config?.httpsAgent?.destroy();
+  }
+  async handle(request, { abortSignal, requestTimeout } = {}) {
+    if (!this.config) {
+      this.config = await this.configProvider;
+    }
+    const config = this.config;
+    const isSSL = request.protocol === "https:";
+    if (!isSSL && !this.config.httpAgent) {
+      this.config.httpAgent = await this.config.httpAgentProvider();
+    }
+    return new Promise((_resolve, _reject) => {
+      let writeRequestBodyPromise = void 0;
+      let socketWarningTimeoutId = -1;
+      let connectionTimeoutId = -1;
+      let requestTimeoutId = -1;
+      let socketTimeoutId = -1;
+      let keepAliveTimeoutId = -1;
+      const clearTimeouts = () => {
+        timing.clearTimeout(socketWarningTimeoutId);
+        timing.clearTimeout(connectionTimeoutId);
+        timing.clearTimeout(requestTimeoutId);
+        timing.clearTimeout(socketTimeoutId);
+        timing.clearTimeout(keepAliveTimeoutId);
+      };
+      const resolve = async (arg) => {
+        await writeRequestBodyPromise;
+        clearTimeouts();
+        _resolve(arg);
+      };
+      const reject = async (arg) => {
+        await writeRequestBodyPromise;
+        clearTimeouts();
+        _reject(arg);
+      };
+      if (abortSignal?.aborted) {
+        const abortError = buildAbortError(abortSignal);
+        reject(abortError);
+        return;
+      }
+      const headers = request.headers;
+      const expectContinue = headers ? (headers.Expect ?? headers.expect) === "100-continue" : false;
+      let agent = isSSL ? config.httpsAgent : config.httpAgent;
+      if (expectContinue && !this.externalAgent) {
+        agent = new (isSSL ? node_https.Agent : hAgent)({
+          keepAlive: false,
+          maxSockets: Infinity
+        });
+      }
+      socketWarningTimeoutId = timing.setTimeout(() => {
+        this.socketWarningTimestamp = _NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, config.logger);
+      }, config.socketAcquisitionWarningTimeout ?? (config.requestTimeout ?? 2e3) + (config.connectionTimeout ?? 1e3));
+      const queryString = request.query ? buildQueryString(request.query) : "";
+      let auth = void 0;
+      if (request.username != null || request.password != null) {
+        const username = request.username ?? "";
+        const password = request.password ?? "";
+        auth = `${username}:${password}`;
+      }
+      let path = request.path;
+      if (queryString) {
+        path += `?${queryString}`;
+      }
+      if (request.fragment) {
+        path += `#${request.fragment}`;
+      }
+      let hostname = request.hostname ?? "";
+      if (hostname[0] === "[" && hostname.endsWith("]")) {
+        hostname = request.hostname.slice(1, -1);
+      } else {
+        hostname = request.hostname;
+      }
+      const nodeHttpsOptions = {
+        headers: request.headers,
+        host: hostname,
+        method: request.method,
+        path,
+        port: request.port,
+        agent,
+        auth
+      };
+      const requestFunc = isSSL ? node_https.request : hRequest;
+      const req = requestFunc(nodeHttpsOptions, (res) => {
+        const httpResponse = new HttpResponse({
+          statusCode: res.statusCode || -1,
+          reason: res.statusMessage,
+          headers: getTransformedHeaders(res.headers),
+          body: res
+        });
+        resolve({ response: httpResponse });
+      });
+      req.on("error", (err) => {
+        if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
+          reject(Object.assign(err, { name: "TimeoutError" }));
+        } else {
+          reject(err);
+        }
+      });
+      if (abortSignal) {
+        const onAbort = () => {
+          req.destroy();
+          const abortError = buildAbortError(abortSignal);
+          reject(abortError);
+        };
+        if (typeof abortSignal.addEventListener === "function") {
+          const signal = abortSignal;
+          signal.addEventListener("abort", onAbort, { once: true });
+          req.once("close", () => signal.removeEventListener("abort", onAbort));
+        } else {
+          abortSignal.onabort = onAbort;
+        }
+      }
+      const effectiveRequestTimeout = requestTimeout ?? config.requestTimeout;
+      connectionTimeoutId = setConnectionTimeout(req, reject, config.connectionTimeout);
+      requestTimeoutId = setRequestTimeout(req, reject, effectiveRequestTimeout, config.throwOnRequestTimeout, config.logger ?? console);
+      socketTimeoutId = setSocketTimeout(req, reject, config.socketTimeout);
+      const httpAgent = nodeHttpsOptions.agent;
+      if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
+        keepAliveTimeoutId = setSocketKeepAlive(req, {
+          keepAlive: httpAgent.keepAlive,
+          keepAliveMsecs: httpAgent.keepAliveMsecs
+        });
+      }
+      writeRequestBodyPromise = writeRequestBody(req, request, effectiveRequestTimeout, this.externalAgent).catch((e) => {
+        clearTimeouts();
+        return _reject(e);
+      });
+    });
+  }
+  updateHttpClientConfig(key, value) {
+    this.config = void 0;
+    this.configProvider = this.configProvider.then((config) => {
+      return {
+        ...config,
+        [key]: value
+      };
+    });
+  }
+  httpHandlerConfigs() {
+    return this.config ?? {};
+  }
+  resolveDefaultConfig(options) {
+    const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent, throwOnRequestTimeout, logger } = options || {};
+    const keepAlive = true;
+    const maxSockets = 50;
+    return {
+      connectionTimeout,
+      requestTimeout,
+      socketTimeout,
+      socketAcquisitionWarningTimeout,
+      throwOnRequestTimeout,
+      httpAgentProvider: async () => {
+        const node_http = await import("http");
+        const { Agent, request } = node_http.default ?? node_http;
+        hRequest = request;
+        hAgent = Agent;
+        if (httpAgent instanceof hAgent || typeof httpAgent?.destroy === "function") {
+          this.externalAgent = true;
+          return httpAgent;
+        }
+        return new hAgent({ keepAlive, maxSockets, ...httpAgent });
+      },
+      httpsAgent: (() => {
+        if (httpsAgent instanceof node_https.Agent || typeof httpsAgent?.destroy === "function") {
+          this.externalAgent = true;
+          return httpsAgent;
+        }
+        return new node_https.Agent({ keepAlive, maxSockets, ...httpsAgent });
+      })(),
+      logger
+    };
+  }
+};
+
+export {
+  NodeHttpHandler
+};

package/dist/{dist-es-SCPV3ZCZ.js → dist-es-3DLRX4SC.js}

@@ -1,27 +1,24 @@
 #!/usr/bin/env node
 import {
-  sdkStreamMixin
-} from "./chunk-AAVVX4U5.js";
+  NodeHttpHandler
+} from "./chunk-QIOBV22I.js";
 import {
-  NodeHttpHandler,
-  parseRfc3339DateTime
-} from "./chunk-SGITM26Q.js";
+  setCredentialFeature
+} from "./chunk-NWBPSHNL.js";
 import {
+  CredentialsProviderError,
   HttpRequest
-} from "./chunk-SWX24AGM.js";
-import "./chunk-ERL3EC7G.js";
+} from "./chunk-3X3IL2A6.js";
 import {
-  setCredentialFeature
-} from "./chunk-ZNARSMJG.js";
-import {
-  CredentialsProviderError
-} from "./chunk-ST5JVROM.js";
-import "./chunk-MO4EEYFW.js";
+  parseRfc3339DateTime,
+  sdkStreamMixin
+} from "./chunk-C6IOMGXW.js";
+import "./chunk-Q6JESX2O.js";
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.36/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/fromHttp.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.46/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/fromHttp.js
 import fs from "fs/promises";
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.36/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/checkUrl.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.46/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/checkUrl.js
 var ECS_CONTAINER_HOST = "169.254.170.2";
 var EKS_CONTAINER_HOST_IPv4 = "169.254.170.23";
 var EKS_CONTAINER_HOST_IPv6 = "[fd00:ec2::23]";
@@ -55,7 +52,7 @@ var checkUrl = (url, logger) => {
   - EKS container host 169.254.170.23 or [fd00:ec2::23]`, { logger });
 };
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.36/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/requestHelpers.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.46/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/requestHelpers.js
 function createGetRequest(url) {
   return new HttpRequest({
     protocol: url.protocol,
@@ -98,7 +95,7 @@ async function getCredentials(response, logger) {
   throw new CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger });
 }
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.36/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/retry-wrapper.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.46/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/retry-wrapper.js
 var retryWrapper = (toRetry, maxRetries, delayMs) => {
   return async () => {
     for (let i = 0; i < maxRetries; ++i) {
@@ -112,7 +109,7 @@ var retryWrapper = (toRetry, maxRetries, delayMs) => {
   };
 };
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.36/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/fromHttp.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.46/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/fromHttp.js
 var AWS_CONTAINER_CREDENTIALS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI";
 var DEFAULT_LINK_LOCAL_HOST = "http://169.254.170.2";
 var AWS_CONTAINER_CREDENTIALS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI";
@@ -144,11 +141,9 @@ Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI
   }
   const url = new URL(host);
   checkUrl(url, options.logger);
-  const requestHandler = NodeHttpHandler.create({
-    requestTimeout: options.timeout ?? 1e3,
-    connectionTimeout: options.timeout ?? 1e3
-  });
-  return retryWrapper(async () => {
+  const requestHandler = NodeHttpHandler.create({ connectionTimeout: options.timeout ?? 1e3 });
+  const requestTimeout = options.timeout ?? 1e3;
+  const provider = retryWrapper(async () => {
     const request = createGetRequest(url);
     if (token) {
       request.headers.Authorization = token;
@@ -156,12 +151,19 @@ Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI
       request.headers.Authorization = (await fs.readFile(tokenFile)).toString();
     }
     try {
-      const result = await requestHandler.handle(request);
+      const result = await requestHandler.handle(request, { requestTimeout });
       return getCredentials(result.response).then((creds) => setCredentialFeature(creds, "CREDENTIALS_HTTP", "z"));
     } catch (e) {
       throw new CredentialsProviderError(String(e), { logger: options.logger });
     }
   }, options.maxRetries ?? 3, options.timeout ?? 1e3);
+  return async () => {
+    try {
+      return await provider();
+    } finally {
+      requestHandler.destroy?.();
+    }
+  };
 };
 export {
   fromHttp

package/dist/{dist-es-HU5E5HQ2.js → dist-es-7DMTLQRJ.js}

@@ -1,25 +1,24 @@
 #!/usr/bin/env node
-import {
-  externalDataInterceptor
-} from "./chunk-5VUQ55WW.js";
 import {
   setCredentialFeature
-} from "./chunk-ZNARSMJG.js";
+} from "./chunk-NWBPSHNL.js";
 import {
-  CredentialsProviderError
-} from "./chunk-ST5JVROM.js";
-import "./chunk-MO4EEYFW.js";
+  CredentialsProviderError,
+  externalDataInterceptor
+} from "./chunk-3X3IL2A6.js";
+import "./chunk-C6IOMGXW.js";
+import "./chunk-Q6JESX2O.js";
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.38/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.49/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js
 import { readFileSync } from "fs";
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.38/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromWebToken.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.49/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromWebToken.js
 var fromWebToken = (init) => async (awsIdentityProperties) => {
   init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
   const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;
   let { roleAssumerWithWebIdentity } = init;
   if (!roleAssumerWithWebIdentity) {
-    const { getDefaultRoleAssumerWithWebIdentity } = await import("./sts-UFAVCISZ.js");
+    const { getDefaultRoleAssumerWithWebIdentity } = await import("./sts-WSDR725H.js");
     roleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity({
       ...init.clientConfig,
       credentialProviderLogger: init.logger,
@@ -40,7 +39,7 @@ var fromWebToken = (init) => async (awsIdentityProperties) => {
   });
 };
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.38/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.49/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js
 var ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE";
 var ENV_ROLE_ARN = "AWS_ROLE_ARN";
 var ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME";

package/dist/{dist-es-VRURAF5E.js → dist-es-B6XNMCQ4.js}

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import {
   setCredentialFeature
-} from "./chunk-ZNARSMJG.js";
+} from "./chunk-NWBPSHNL.js";
 import {
   CredentialsProviderError
-} from "./chunk-ST5JVROM.js";
-import "./chunk-MO4EEYFW.js";
+} from "./chunk-3X3IL2A6.js";
+import "./chunk-C6IOMGXW.js";
+import "./chunk-Q6JESX2O.js";
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-env@3.972.34/node_modules/@aws-sdk/credential-provider-env/dist-es/fromEnv.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-env@3.972.44/node_modules/@aws-sdk/credential-provider-env/dist-es/fromEnv.js
 var ENV_KEY = "AWS_ACCESS_KEY_ID";
 var ENV_SECRET = "AWS_SECRET_ACCESS_KEY";
 var ENV_SESSION = "AWS_SESSION_TOKEN";

package/dist/{dist-es-7T436X7S.js → dist-es-KLEKEXIP.js}

@@ -1,22 +1,21 @@
 #!/usr/bin/env node
 import {
+  setCredentialFeature
+} from "./chunk-NWBPSHNL.js";
+import {
+  CredentialsProviderError,
   externalDataInterceptor,
   getProfileName,
   parseKnownFiles
-} from "./chunk-5VUQ55WW.js";
-import {
-  setCredentialFeature
-} from "./chunk-ZNARSMJG.js";
-import {
-  CredentialsProviderError
-} from "./chunk-ST5JVROM.js";
-import "./chunk-MO4EEYFW.js";
+} from "./chunk-3X3IL2A6.js";
+import "./chunk-C6IOMGXW.js";
+import "./chunk-Q6JESX2O.js";
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.34/node_modules/@aws-sdk/credential-provider-process/dist-es/resolveProcessCredentials.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.44/node_modules/@aws-sdk/credential-provider-process/dist-es/resolveProcessCredentials.js
 import { exec } from "child_process";
 import { promisify } from "util";
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.34/node_modules/@aws-sdk/credential-provider-process/dist-es/getValidatedProcessCredentials.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.44/node_modules/@aws-sdk/credential-provider-process/dist-es/getValidatedProcessCredentials.js
 var getValidatedProcessCredentials = (profileName, data, profiles) => {
   if (data.Version !== 1) {
     throw Error(`Profile ${profileName} credential_process did not return Version 1.`);
@@ -47,7 +46,7 @@ var getValidatedProcessCredentials = (profileName, data, profiles) => {
   return credentials;
 };
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.34/node_modules/@aws-sdk/credential-provider-process/dist-es/resolveProcessCredentials.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.44/node_modules/@aws-sdk/credential-provider-process/dist-es/resolveProcessCredentials.js
 var resolveProcessCredentials = async (profileName, profiles, logger) => {
   const profile = profiles[profileName];
   if (profiles[profileName]) {
@@ -76,7 +75,7 @@ var resolveProcessCredentials = async (profileName, profiles, logger) => {
   }
 };
 
-// ../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.34/node_modules/@aws-sdk/credential-provider-process/dist-es/fromProcess.js
+// ../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.44/node_modules/@aws-sdk/credential-provider-process/dist-es/fromProcess.js
 var fromProcess = (init = {}) => async ({ callerClientConfig } = {}) => {
   init.logger?.debug("@aws-sdk/credential-provider-process - fromProcess");
   const profiles = await parseKnownFiles(init);