@entelligentsia/forgecli 0.2.0 → 0.6.6

package/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/Int64.js

@@ -0,0 +1,44 @@
+import { toHex } from "@smithy/core/serde";
+export class Int64 {
+    bytes;
+    constructor(bytes) {
+        this.bytes = bytes;
+        if (bytes.byteLength !== 8) {
+            throw new Error("Int64 buffers must be exactly 8 bytes");
+        }
+    }
+    static fromNumber(number) {
+        if (number > 9_223_372_036_854_775_807 || number < -9_223_372_036_854_775_808) {
+            throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`);
+        }
+        const bytes = new Uint8Array(8);
+        for (let i = 7, remaining = Math.abs(Math.round(number)); i > -1 && remaining > 0; i--, remaining /= 256) {
+            bytes[i] = remaining;
+        }
+        if (number < 0) {
+            negate(bytes);
+        }
+        return new Int64(bytes);
+    }
+    valueOf() {
+        const bytes = this.bytes.slice(0);
+        const negative = bytes[0] & 0b10000000;
+        if (negative) {
+            negate(bytes);
+        }
+        return parseInt(toHex(bytes), 16) * (negative ? -1 : 1);
+    }
+    toString() {
+        return String(this.valueOf());
+    }
+}
+function negate(bytes) {
+    for (let i = 0; i < 8; i++) {
+        bytes[i] ^= 0xff;
+    }
+    for (let i = 7; i > -1; i--) {
+        bytes[i]++;
+        if (bytes[i] !== 0)
+            break;
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde/EventStreamMarshaller.browser.js

@@ -0,0 +1,21 @@
+import { EventStreamMarshaller as UniversalEventStreamMarshaller } from "../eventstream-serde-universal/EventStreamMarshaller";
+import { iterableToReadableStream, readableStreamToIterable } from "./utils";
+export class EventStreamMarshaller {
+    universalMarshaller;
+    constructor({ utf8Encoder, utf8Decoder }) {
+        this.universalMarshaller = new UniversalEventStreamMarshaller({
+            utf8Decoder,
+            utf8Encoder,
+        });
+    }
+    deserialize(body, deserializer) {
+        const bodyIterable = isReadableStream(body) ? readableStreamToIterable(body) : body;
+        return this.universalMarshaller.deserialize(bodyIterable, deserializer);
+    }
+    serialize(input, serializer) {
+        const serializedIterable = this.universalMarshaller.serialize(input, serializer);
+        return typeof ReadableStream === "function" ? iterableToReadableStream(serializedIterable) : serializedIterable;
+    }
+}
+const isReadableStream = (body) => typeof ReadableStream === "function" && body instanceof ReadableStream;
+export const eventStreamSerdeProvider = (options) => new EventStreamMarshaller(options);

package/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde/EventStreamMarshaller.js

@@ -0,0 +1,45 @@
+import { Readable } from "node:stream";
+import { EventStreamMarshaller as UniversalEventStreamMarshaller } from "../eventstream-serde-universal/EventStreamMarshaller";
+export class EventStreamMarshaller {
+    universalMarshaller;
+    constructor({ utf8Encoder, utf8Decoder }) {
+        this.universalMarshaller = new UniversalEventStreamMarshaller({
+            utf8Decoder,
+            utf8Encoder,
+        });
+    }
+    deserialize(body, deserializer) {
+        const bodyIterable = typeof body[Symbol.asyncIterator] === "function" ? body : readableToIterable(body);
+        return this.universalMarshaller.deserialize(bodyIterable, deserializer);
+    }
+    serialize(input, serializer) {
+        return Readable.from(this.universalMarshaller.serialize(input, serializer));
+    }
+}
+export const eventStreamSerdeProvider = (options) => new EventStreamMarshaller(options);
+export async function* readableToIterable(readStream) {
+    let streamEnded = false;
+    let generationEnded = false;
+    const records = new Array();
+    readStream.on("error", (err) => {
+        if (!streamEnded) {
+            streamEnded = true;
+        }
+        if (err) {
+            throw err;
+        }
+    });
+    readStream.on("data", (data) => {
+        records.push(data);
+    });
+    readStream.on("end", () => {
+        streamEnded = true;
+    });
+    while (!generationEnded) {
+        const value = await new Promise((resolve) => setTimeout(() => resolve(records.shift()), 0));
+        if (value) {
+            yield value;
+        }
+        generationEnded = streamEnded && records.length === 0;
+    }
+}

package/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde/utils.js

@@ -0,0 +1,28 @@
+export const readableStreamToIterable = (readableStream) => ({
+    [Symbol.asyncIterator]: async function* () {
+        const reader = readableStream.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    return;
+                yield value;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    },
+});
+export const iterableToReadableStream = (asyncIterable) => {
+    const iterator = asyncIterable[Symbol.asyncIterator]();
+    return new ReadableStream({
+        async pull(controller) {
+            const { done, value } = await iterator.next();
+            if (done) {
+                return controller.close();
+            }
+            controller.enqueue(value);
+        },
+    });
+};

package/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-universal/EventStreamMarshaller.js

@@ -0,0 +1,30 @@
+import { EventStreamCodec } from "../eventstream-codec/EventStreamCodec";
+import { MessageDecoderStream } from "../eventstream-codec/MessageDecoderStream";
+import { MessageEncoderStream } from "../eventstream-codec/MessageEncoderStream";
+import { SmithyMessageDecoderStream } from "../eventstream-codec/SmithyMessageDecoderStream";
+import { SmithyMessageEncoderStream } from "../eventstream-codec/SmithyMessageEncoderStream";
+import { getChunkedStream } from "./getChunkedStream";
+import { getMessageUnmarshaller } from "./getUnmarshalledStream";
+export class EventStreamMarshaller {
+    eventStreamCodec;
+    utfEncoder;
+    constructor({ utf8Encoder, utf8Decoder }) {
+        this.eventStreamCodec = new EventStreamCodec(utf8Encoder, utf8Decoder);
+        this.utfEncoder = utf8Encoder;
+    }
+    deserialize(body, deserializer) {
+        const inputStream = getChunkedStream(body);
+        return new SmithyMessageDecoderStream({
+            messageStream: new MessageDecoderStream({ inputStream, decoder: this.eventStreamCodec }),
+            deserializer: getMessageUnmarshaller(deserializer, this.utfEncoder),
+        });
+    }
+    serialize(inputStream, serializer) {
+        return new MessageEncoderStream({
+            messageStream: new SmithyMessageEncoderStream({ inputStream, serializer }),
+            encoder: this.eventStreamCodec,
+            includeEndFrame: true,
+        });
+    }
+}
+export const eventStreamSerdeProvider = (options) => new EventStreamMarshaller(options);

package/node_modules/@smithy/core/dist-es/submodules/event-streams/index.browser.js

@@ -0,0 +1,14 @@
+export { EventStreamCodec } from "./eventstream-codec/EventStreamCodec";
+export { HeaderMarshaller } from "./eventstream-codec/HeaderMarshaller";
+export { Int64 } from "./eventstream-codec/Int64";
+export { MessageDecoderStream } from "./eventstream-codec/MessageDecoderStream";
+export { MessageEncoderStream } from "./eventstream-codec/MessageEncoderStream";
+export { SmithyMessageDecoderStream } from "./eventstream-codec/SmithyMessageDecoderStream";
+export { SmithyMessageEncoderStream } from "./eventstream-codec/SmithyMessageEncoderStream";
+export { EventStreamMarshaller, eventStreamSerdeProvider } from "./eventstream-serde/EventStreamMarshaller.browser";
+export { readableStreamToIterable, iterableToReadableStream } from "./eventstream-serde/utils";
+export { EventStreamMarshaller as UniversalEventStreamMarshaller, eventStreamSerdeProvider as universalEventStreamSerdeProvider, } from "./eventstream-serde-universal/EventStreamMarshaller";
+export { getChunkedStream } from "./eventstream-serde-universal/getChunkedStream";
+export { getUnmarshalledStream, getMessageUnmarshaller } from "./eventstream-serde-universal/getUnmarshalledStream";
+export { resolveEventStreamSerdeConfig } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export { EventStreamSerde } from "./EventStreamSerde";

package/node_modules/@smithy/core/dist-es/submodules/event-streams/index.js

@@ -1 +1,14 @@
-export * from "./EventStreamSerde";
+export { EventStreamCodec } from "./eventstream-codec/EventStreamCodec";
+export { HeaderMarshaller } from "./eventstream-codec/HeaderMarshaller";
+export { Int64 } from "./eventstream-codec/Int64";
+export { MessageDecoderStream } from "./eventstream-codec/MessageDecoderStream";
+export { MessageEncoderStream } from "./eventstream-codec/MessageEncoderStream";
+export { SmithyMessageDecoderStream } from "./eventstream-codec/SmithyMessageDecoderStream";
+export { SmithyMessageEncoderStream } from "./eventstream-codec/SmithyMessageEncoderStream";
+export { EventStreamMarshaller, eventStreamSerdeProvider } from "./eventstream-serde/EventStreamMarshaller";
+export { readableStreamToIterable, iterableToReadableStream } from "./eventstream-serde/utils";
+export { EventStreamMarshaller as UniversalEventStreamMarshaller, eventStreamSerdeProvider as universalEventStreamSerdeProvider, } from "./eventstream-serde-universal/EventStreamMarshaller";
+export { getChunkedStream } from "./eventstream-serde-universal/getChunkedStream";
+export { getUnmarshalledStream, getMessageUnmarshaller } from "./eventstream-serde-universal/getUnmarshalledStream";
+export { resolveEventStreamSerdeConfig } from "./eventstream-serde-config-resolver/EventStreamSerdeConfig";
+export { EventStreamSerde } from "./EventStreamSerde";

package/node_modules/@smithy/core/dist-es/submodules/protocols/HttpBindingProtocol.js

@@ -1,10 +1,9 @@
 import { NormalizedSchema, translateTraits } from "@smithy/core/schema";
-import { splitEvery, splitHeader } from "@smithy/core/serde";
-import { HttpRequest } from "@smithy/protocol-http";
-import { sdkStreamMixin } from "@smithy/util-stream";
+import { sdkStreamMixin, splitEvery, splitHeader } from "@smithy/core/serde";
+import { HttpProtocol } from "./HttpProtocol";
 import { collectBody } from "./collect-stream-body";
 import { extendedEncodeURIComponent } from "./extended-encode-uri-component";
-import { HttpProtocol } from "./HttpProtocol";
+import { HttpRequest } from "./protocol-http/httpRequest";
 export class HttpBindingProtocol extends HttpProtocol {
     async serializeRequest(operationSchema, _input, context) {
         const input = _input && typeof _input === "object" ? _input : {};

package/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js

@@ -1,6 +1,7 @@
-import { NormalizedSchema, translateTraits, TypeRegistry } from "@smithy/core/schema";
-import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
+import { NormalizedSchema, TypeRegistry, translateTraits } from "@smithy/core/schema";
 import { SerdeContext } from "./SerdeContext";
+import { HttpRequest } from "./protocol-http/httpRequest";
+import { HttpResponse } from "./protocol-http/httpResponse";
 export class HttpProtocol extends SerdeContext {
     options;
     compositeErrorRegistry;

package/node_modules/@smithy/core/dist-es/submodules/protocols/RpcProtocol.js

@@ -1,7 +1,7 @@
 import { NormalizedSchema } from "@smithy/core/schema";
-import { HttpRequest } from "@smithy/protocol-http";
-import { collectBody } from "./collect-stream-body";
 import { HttpProtocol } from "./HttpProtocol";
+import { collectBody } from "./collect-stream-body";
+import { HttpRequest } from "./protocol-http/httpRequest";
 export class RpcProtocol extends HttpProtocol {
     async serializeRequest(operationSchema, _input, context) {
         const serializer = this.serializer;

package/node_modules/@smithy/core/dist-es/submodules/protocols/collect-stream-body.js

@@ -1,4 +1,4 @@
-import { Uint8ArrayBlobAdapter } from "@smithy/util-stream";
+import { Uint8ArrayBlobAdapter } from "@smithy/core/serde";
 export const collectBody = async (streamBody = new Uint8Array(), context) => {
     if (streamBody instanceof Uint8Array) {
         return Uint8ArrayBlobAdapter.mutate(streamBody);

package/node_modules/@smithy/core/dist-es/submodules/protocols/index.js

@@ -11,3 +11,15 @@ export * from "./serde/HttpInterceptingShapeSerializer";
 export * from "./serde/ToStringShapeSerializer";
 export * from "./serde/determineTimestampFormat";
 export * from "./SerdeContext";
+export { Field } from "./protocol-http/Field";
+export { Fields } from "./protocol-http/Fields";
+export { HttpRequest } from "./protocol-http/httpRequest";
+export { HttpResponse } from "./protocol-http/httpResponse";
+export { isValidHostname } from "./protocol-http/isValidHostname";
+export { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, } from "./protocol-http/extensions/httpExtensionConfiguration";
+export { contentLengthMiddleware, contentLengthMiddlewareOptions, getContentLengthPlugin, } from "./middleware-content-length/contentLengthMiddleware";
+export { escapeUri } from "./util-uri-escape/escape-uri";
+export { escapeUriPath } from "./util-uri-escape/escape-uri-path";
+export { buildQueryString } from "./querystring-builder/buildQueryString";
+export { parseQueryString } from "./querystring-parser/parseQueryString";
+export { parseUrl } from "./url-parser/parseUrl";

package/node_modules/@smithy/core/dist-es/submodules/protocols/middleware-content-length/contentLengthMiddleware.js

@@ -0,0 +1,39 @@
+import { HttpRequest } from "../protocol-http/httpRequest";
+const CONTENT_LENGTH_HEADER = "content-length";
+export function contentLengthMiddleware(bodyLengthChecker) {
+    return (next) => async (args) => {
+        const request = args.request;
+        if (HttpRequest.isInstance(request)) {
+            const { body, headers } = request;
+            if (body &&
+                Object.keys(headers)
+                    .map((str) => str.toLowerCase())
+                    .indexOf(CONTENT_LENGTH_HEADER) === -1) {
+                try {
+                    const length = bodyLengthChecker(body);
+                    request.headers = {
+                        ...request.headers,
+                        [CONTENT_LENGTH_HEADER]: String(length),
+                    };
+                }
+                catch (error) {
+                }
+            }
+        }
+        return next({
+            ...args,
+            request,
+        });
+    };
+}
+export const contentLengthMiddlewareOptions = {
+    step: "build",
+    tags: ["SET_CONTENT_LENGTH", "CONTENT_LENGTH"],
+    name: "contentLengthMiddleware",
+    override: true,
+};
+export const getContentLengthPlugin = (options) => ({
+    applyToStack: (clientStack) => {
+        clientStack.add(contentLengthMiddleware(options.bodyLengthChecker), contentLengthMiddlewareOptions);
+    },
+});

package/node_modules/@smithy/core/dist-es/submodules/protocols/querystring-builder/buildQueryString.js

@@ -0,0 +1,21 @@
+import { escapeUri } from "../util-uri-escape/escape-uri";
+export function buildQueryString(query) {
+    const parts = [];
+    for (let key of Object.keys(query).sort()) {
+        const value = query[key];
+        key = escapeUri(key);
+        if (Array.isArray(value)) {
+            for (let i = 0, iLen = value.length; i < iLen; i++) {
+                parts.push(`${key}=${escapeUri(value[i])}`);
+            }
+        }
+        else {
+            let qsEntry = key;
+            if (value || typeof value === "string") {
+                qsEntry += `=${escapeUri(value)}`;
+            }
+            parts.push(qsEntry);
+        }
+    }
+    return parts.join("&");
+}

package/node_modules/@smithy/core/dist-es/submodules/protocols/requestBuilder.js

@@ -1,4 +1,4 @@
-import { HttpRequest } from "@smithy/protocol-http";
+import { HttpRequest } from "./protocol-http/httpRequest";
 import { resolvedPath } from "./resolve-path";
 export function requestBuilder(input, context) {
     return new RequestBuilder(input, context);

package/node_modules/@smithy/core/dist-es/submodules/protocols/serde/FromStringShapeDeserializer.js

@@ -1,7 +1,5 @@
 import { NormalizedSchema } from "@smithy/core/schema";
-import { _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime, LazyJsonString, NumericValue, splitHeader, } from "@smithy/core/serde";
-import { fromBase64 } from "@smithy/util-base64";
-import { toUtf8 } from "@smithy/util-utf8";
+import { LazyJsonString, NumericValue, _parseEpochTimestamp, _parseRfc3339DateTimeWithOffset, _parseRfc7231DateTime, fromBase64, splitHeader, toUtf8, } from "@smithy/core/serde";
 import { SerdeContext } from "../SerdeContext";
 import { determineTimestampFormat } from "./determineTimestampFormat";
 export class FromStringShapeDeserializer extends SerdeContext {

package/node_modules/@smithy/core/dist-es/submodules/protocols/serde/HttpInterceptingShapeDeserializer.js

@@ -1,5 +1,5 @@
 import { NormalizedSchema } from "@smithy/core/schema";
-import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
+import { fromUtf8, toUtf8 } from "@smithy/core/serde";
 import { SerdeContext } from "../SerdeContext";
 import { FromStringShapeDeserializer } from "./FromStringShapeDeserializer";
 export class HttpInterceptingShapeDeserializer extends SerdeContext {

package/node_modules/@smithy/core/dist-es/submodules/protocols/serde/ToStringShapeSerializer.js

@@ -1,6 +1,5 @@
 import { NormalizedSchema } from "@smithy/core/schema";
-import { dateToUtcString, generateIdempotencyToken, LazyJsonString, quoteHeader } from "@smithy/core/serde";
-import { toBase64 } from "@smithy/util-base64";
+import { LazyJsonString, dateToUtcString, generateIdempotencyToken, quoteHeader, toBase64 } from "@smithy/core/serde";
 import { SerdeContext } from "../SerdeContext";
 import { determineTimestampFormat } from "./determineTimestampFormat";
 export class ToStringShapeSerializer extends SerdeContext {

package/node_modules/@smithy/core/dist-es/submodules/protocols/url-parser/parseUrl.js

@@ -0,0 +1,18 @@
+import { parseQueryString } from "../querystring-parser/parseQueryString";
+export const parseUrl = (url) => {
+    if (typeof url === "string") {
+        return parseUrl(new URL(url));
+    }
+    const { hostname, pathname, port, protocol, search } = url;
+    let query;
+    if (search) {
+        query = parseQueryString(search);
+    }
+    return {
+        hostname,
+        port: port ? parseInt(port) : undefined,
+        protocol,
+        path: pathname,
+        query,
+    };
+};

package/node_modules/@smithy/core/dist-es/submodules/retry/index.browser.js

@@ -0,0 +1,27 @@
+import { isStreamingPayload } from "./middleware-retry/isStreamingPayload/isStreamingPayload.browser";
+import { bindGetRetryPlugin, bindRetryMiddleware } from "./middleware-retry/retryMiddleware";
+const no = Symbol.for("node-only");
+export { isRetryableByTrait, isClockSkewError, isClockSkewCorrectedError, isBrowserNetworkError, isThrottlingError, isTransientError, isServerError, isNodeJsHttp2TransientError, } from "./service-error-classification/service-error-classification";
+export { AdaptiveRetryStrategy } from "./util-retry/AdaptiveRetryStrategy";
+export { ConfiguredRetryStrategy } from "./util-retry/ConfiguredRetryStrategy";
+export { DefaultRateLimiter } from "./util-retry/DefaultRateLimiter";
+export { StandardRetryStrategy } from "./util-retry/StandardRetryStrategy";
+export { RETRY_MODES, DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE } from "./util-retry/config";
+export { DEFAULT_RETRY_DELAY_BASE, MAXIMUM_RETRY_DELAY, THROTTLING_RETRY_DELAY_BASE, INITIAL_RETRY_TOKENS, RETRY_COST, TIMEOUT_RETRY_COST, NO_RETRY_INCREMENT, INVOCATION_ID_HEADER, REQUEST_HEADER, } from "./util-retry/constants";
+export { Retry } from "./util-retry/retries-2026-config";
+export { AdaptiveRetryStrategy as DeprecatedAdaptiveRetryStrategy, } from "./middleware-retry/retry-pre-sra-deprecated/AdaptiveRetryStrategy";
+export { StandardRetryStrategy as DeprecatedStandardRetryStrategy, } from "./middleware-retry/retry-pre-sra-deprecated/StandardRetryStrategy";
+export { defaultDelayDecider } from "./middleware-retry/retry-pre-sra-deprecated/delayDecider";
+export { defaultRetryDecider } from "./middleware-retry/retry-pre-sra-deprecated/retryDecider";
+export const ENV_MAX_ATTEMPTS = no;
+export const CONFIG_MAX_ATTEMPTS = no;
+export const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = no;
+export const ENV_RETRY_MODE = no;
+export const CONFIG_RETRY_MODE = no;
+export const NODE_RETRY_MODE_CONFIG_OPTIONS = no;
+export { resolveRetryConfig } from "./middleware-retry/configurations";
+export { omitRetryHeadersMiddleware, omitRetryHeadersMiddlewareOptions, getOmitRetryHeadersPlugin, } from "./middleware-retry/omitRetryHeadersMiddleware";
+export { retryMiddlewareOptions } from "./middleware-retry/retryMiddleware";
+export { getRetryAfterHint } from "./middleware-retry/parseRetryAfterHeader";
+export const retryMiddleware = bindRetryMiddleware(isStreamingPayload);
+export const getRetryPlugin = bindGetRetryPlugin(isStreamingPayload);

package/node_modules/@smithy/core/dist-es/submodules/retry/index.js

@@ -0,0 +1,20 @@
+import { isStreamingPayload } from "./middleware-retry/isStreamingPayload/isStreamingPayload";
+import { bindGetRetryPlugin, bindRetryMiddleware } from "./middleware-retry/retryMiddleware";
+export { isRetryableByTrait, isClockSkewError, isClockSkewCorrectedError, isBrowserNetworkError, isThrottlingError, isTransientError, isServerError, isNodeJsHttp2TransientError, } from "./service-error-classification/service-error-classification";
+export { AdaptiveRetryStrategy } from "./util-retry/AdaptiveRetryStrategy";
+export { ConfiguredRetryStrategy } from "./util-retry/ConfiguredRetryStrategy";
+export { DefaultRateLimiter } from "./util-retry/DefaultRateLimiter";
+export { StandardRetryStrategy } from "./util-retry/StandardRetryStrategy";
+export { RETRY_MODES, DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE } from "./util-retry/config";
+export { DEFAULT_RETRY_DELAY_BASE, MAXIMUM_RETRY_DELAY, THROTTLING_RETRY_DELAY_BASE, INITIAL_RETRY_TOKENS, RETRY_COST, TIMEOUT_RETRY_COST, NO_RETRY_INCREMENT, INVOCATION_ID_HEADER, REQUEST_HEADER, } from "./util-retry/constants";
+export { Retry } from "./util-retry/retries-2026-config";
+export { AdaptiveRetryStrategy as DeprecatedAdaptiveRetryStrategy, } from "./middleware-retry/retry-pre-sra-deprecated/AdaptiveRetryStrategy";
+export { StandardRetryStrategy as DeprecatedStandardRetryStrategy, } from "./middleware-retry/retry-pre-sra-deprecated/StandardRetryStrategy";
+export { defaultDelayDecider } from "./middleware-retry/retry-pre-sra-deprecated/delayDecider";
+export { defaultRetryDecider } from "./middleware-retry/retry-pre-sra-deprecated/retryDecider";
+export { ENV_MAX_ATTEMPTS, CONFIG_MAX_ATTEMPTS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, ENV_RETRY_MODE, CONFIG_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, resolveRetryConfig, } from "./middleware-retry/configurations";
+export { omitRetryHeadersMiddleware, omitRetryHeadersMiddlewareOptions, getOmitRetryHeadersPlugin, } from "./middleware-retry/omitRetryHeadersMiddleware";
+export { retryMiddlewareOptions } from "./middleware-retry/retryMiddleware";
+export { getRetryAfterHint } from "./middleware-retry/parseRetryAfterHeader";
+export const retryMiddleware = bindRetryMiddleware(isStreamingPayload);
+export const getRetryPlugin = bindGetRetryPlugin(isStreamingPayload);

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/configurations.js

@@ -0,0 +1,50 @@
+import { normalizeProvider } from "@smithy/core/client";
+import { AdaptiveRetryStrategy } from "../util-retry/AdaptiveRetryStrategy";
+import { StandardRetryStrategy } from "../util-retry/StandardRetryStrategy";
+import { DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE, RETRY_MODES } from "../util-retry/config";
+export const ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
+export const CONFIG_MAX_ATTEMPTS = "max_attempts";
+export const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => {
+        const value = env[ENV_MAX_ATTEMPTS];
+        if (!value)
+            return undefined;
+        const maxAttempt = parseInt(value);
+        if (Number.isNaN(maxAttempt)) {
+            throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`);
+        }
+        return maxAttempt;
+    },
+    configFileSelector: (profile) => {
+        const value = profile[CONFIG_MAX_ATTEMPTS];
+        if (!value)
+            return undefined;
+        const maxAttempt = parseInt(value);
+        if (Number.isNaN(maxAttempt)) {
+            throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`);
+        }
+        return maxAttempt;
+    },
+    default: DEFAULT_MAX_ATTEMPTS,
+};
+export const resolveRetryConfig = (input) => {
+    const { retryStrategy, retryMode } = input;
+    const maxAttempts = normalizeProvider(input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+    let controller = retryStrategy
+        ? Promise.resolve(retryStrategy)
+        : undefined;
+    const getDefault = async () => (await normalizeProvider(retryMode)()) === RETRY_MODES.ADAPTIVE
+        ? new AdaptiveRetryStrategy(maxAttempts)
+        : new StandardRetryStrategy(maxAttempts);
+    return Object.assign(input, {
+        maxAttempts,
+        retryStrategy: () => (controller ??= getDefault()),
+    });
+};
+export const ENV_RETRY_MODE = "AWS_RETRY_MODE";
+export const CONFIG_RETRY_MODE = "retry_mode";
+export const NODE_RETRY_MODE_CONFIG_OPTIONS = {
+    environmentVariableSelector: (env) => env[ENV_RETRY_MODE],
+    configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
+    default: DEFAULT_RETRY_MODE,
+};

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/isStreamingPayload/isStreamingPayload.js

@@ -0,0 +1,3 @@
+import { Readable } from "node:stream";
+export const isStreamingPayload = (request) => request?.body instanceof Readable ||
+    (typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream);

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/omitRetryHeadersMiddleware.js

@@ -0,0 +1,22 @@
+import { HttpRequest } from "@smithy/core/protocols";
+import { INVOCATION_ID_HEADER, REQUEST_HEADER } from "../util-retry/constants";
+export const omitRetryHeadersMiddleware = () => (next) => async (args) => {
+    const { request } = args;
+    if (HttpRequest.isInstance(request)) {
+        delete request.headers[INVOCATION_ID_HEADER];
+        delete request.headers[REQUEST_HEADER];
+    }
+    return next(args);
+};
+export const omitRetryHeadersMiddlewareOptions = {
+    name: "omitRetryHeadersMiddleware",
+    tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"],
+    relation: "before",
+    toMiddleware: "awsAuthMiddleware",
+    override: true,
+};
+export const getOmitRetryHeadersPlugin = (options) => ({
+    applyToStack: (clientStack) => {
+        clientStack.addRelativeTo(omitRetryHeadersMiddleware(), omitRetryHeadersMiddlewareOptions);
+    },
+});

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/parseRetryAfterHeader.js

@@ -0,0 +1,49 @@
+import { HttpResponse } from "@smithy/core/protocols";
+import { parseRfc7231DateTime } from "@smithy/core/serde";
+export function parseRetryAfterHeader(response, logger) {
+    if (!HttpResponse.isInstance(response)) {
+        return;
+    }
+    for (const header of Object.keys(response.headers)) {
+        const h = header.toLowerCase();
+        if (h === "retry-after") {
+            const retryAfter = response.headers[header];
+            let retryAfterSeconds = NaN;
+            if (retryAfter.endsWith("GMT")) {
+                try {
+                    const date = parseRfc7231DateTime(retryAfter);
+                    retryAfterSeconds = (date.getTime() - Date.now()) / 1000;
+                }
+                catch (e) {
+                    logger?.trace?.("Failed to parse retry-after header");
+                    logger?.trace?.(e);
+                }
+            }
+            else if (retryAfter.match(/ GMT, ((\d+)|(\d+\.\d+))$/)) {
+                retryAfterSeconds = Number(retryAfter.match(/ GMT, ([\d.]+)$/)?.[1]);
+            }
+            else if (retryAfter.match(/^((\d+)|(\d+\.\d+))$/)) {
+                retryAfterSeconds = Number(retryAfter);
+            }
+            else if (Date.parse(retryAfter) >= Date.now()) {
+                retryAfterSeconds = (Date.parse(retryAfter) - Date.now()) / 1000;
+            }
+            if (isNaN(retryAfterSeconds)) {
+                return;
+            }
+            return new Date(Date.now() + retryAfterSeconds * 1000);
+        }
+        else if (h === "x-amz-retry-after") {
+            const v = response.headers[header];
+            const backoffMilliseconds = Number(v);
+            if (isNaN(backoffMilliseconds)) {
+                logger?.trace?.(`Failed to parse x-amz-retry-after=${v}`);
+                return;
+            }
+            return new Date(Date.now() + backoffMilliseconds);
+        }
+    }
+}
+export function getRetryAfterHint(response, logger) {
+    return parseRetryAfterHeader(response, logger);
+}

package/node_modules/@smithy/core/dist-es/submodules/retry/middleware-retry/retry-pre-sra-deprecated/AdaptiveRetryStrategy.js

@@ -0,0 +1,22 @@
+import { DefaultRateLimiter } from "../../util-retry/DefaultRateLimiter";
+import { RETRY_MODES } from "../../util-retry/config";
+import { StandardRetryStrategy } from "./StandardRetryStrategy";
+export class AdaptiveRetryStrategy extends StandardRetryStrategy {
+    rateLimiter;
+    constructor(maxAttemptsProvider, options) {
+        const { rateLimiter, ...superOptions } = options ?? {};
+        super(maxAttemptsProvider, superOptions);
+        this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
+        this.mode = RETRY_MODES.ADAPTIVE;
+    }
+    async retry(next, args) {
+        return super.retry(next, args, {
+            beforeRequest: async () => {
+                return this.rateLimiter.getSendToken();
+            },
+            afterRequest: (response) => {
+                this.rateLimiter.updateClientSendingRate(response);
+            },
+        });
+    }
+}