@senpiper/sp-agent 0.1.6 → 0.1.7

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

@@ -1,4 +1,4 @@
-import { Crc32 } from "@smithy/core/checksum";
+import { Crc32 } from "@aws-crypto/crc32";
 import { HeaderMarshaller } from "./HeaderMarshaller";
 import { splitMessage } from "./splitMessage";
 export class EventStreamCodec {
@@ -49,12 +49,10 @@ export class EventStreamCodec {
         const checksum = new Crc32();
         view.setUint32(0, length, false);
         view.setUint32(4, headers.byteLength, false);
-        checksum.update(out.subarray(0, 8));
-        view.setUint32(8, checksum.digestSync(), false);
+        view.setUint32(8, checksum.update(out.subarray(0, 8)).digest(), false);
         out.set(headers, 12);
         out.set(body, headers.byteLength + 12);
-        checksum.update(out.subarray(8, length - 4));
-        view.setUint32(length - 4, checksum.digestSync(), false);
+        view.setUint32(length - 4, checksum.update(out.subarray(8, length - 4)).digest(), false);
         return out;
     }
     decode(message) {

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

@@ -1,4 +1,3 @@
-import { hasOwn } from "@smithy/core/transport";
 import { fromHex, toHex } from "@smithy/core/serde";
 import { Int64 } from "./Int64";
 export class HeaderMarshaller {
@@ -10,9 +9,7 @@ export class HeaderMarshaller {
     }
     format(headers) {
         const chunks = [];
-        for (const headerName in headers) {
-            if (!hasOwn(headers, headerName))
-                continue;
+        for (const headerName of Object.keys(headers)) {
             const bytes = this.fromUtf8(headerName);
             chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName]));
         }
@@ -71,7 +68,7 @@ export class HeaderMarshaller {
                 }
                 const uuidBytes = new Uint8Array(17);
                 uuidBytes[0] = 9;
-                uuidBytes.set(fromHex(header.value.replace(/-/g, "")), 1);
+                uuidBytes.set(fromHex(header.value.replace(/\-/g, "")), 1);
                 return uuidBytes;
         }
     }

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

@@ -0,0 +1,146 @@
+import { Int64 } from "./Int64";
+export const vectors = {
+    all_headers: {
+        expectation: "success",
+        encoded: Uint8Array.from([
+            0, 0, 0, 204, 0, 0, 0, 175, 15, 174, 100, 202, 10, 101, 118, 101, 110, 116, 45, 116, 121, 112, 101, 4, 0, 0, 160,
+            12, 12, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 7, 0, 16, 97, 112, 112, 108, 105, 99, 97, 116,
+            105, 111, 110, 47, 106, 115, 111, 110, 10, 98, 111, 111, 108, 32, 102, 97, 108, 115, 101, 1, 9, 98, 111, 111, 108,
+            32, 116, 114, 117, 101, 0, 4, 98, 121, 116, 101, 2, 207, 8, 98, 121, 116, 101, 32, 98, 117, 102, 6, 0, 20, 73, 39,
+            109, 32, 97, 32, 108, 105, 116, 116, 108, 101, 32, 116, 101, 97, 112, 111, 116, 33, 9, 116, 105, 109, 101, 115,
+            116, 97, 109, 112, 8, 0, 0, 0, 0, 0, 132, 95, 237, 5, 105, 110, 116, 49, 54, 3, 0, 42, 5, 105, 110, 116, 54, 52,
+            5, 0, 0, 0, 0, 2, 135, 87, 178, 4, 117, 117, 105, 100, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+            123, 39, 102, 111, 111, 39, 58, 39, 98, 97, 114, 39, 125, 171, 165, 241, 12,
+        ]),
+        decoded: {
+            headers: {
+                "event-type": {
+                    type: "integer",
+                    value: 40972,
+                },
+                "content-type": {
+                    type: "string",
+                    value: "application/json",
+                },
+                "bool false": {
+                    type: "boolean",
+                    value: false,
+                },
+                "bool true": {
+                    type: "boolean",
+                    value: true,
+                },
+                byte: {
+                    type: "byte",
+                    value: -49,
+                },
+                "byte buf": {
+                    type: "binary",
+                    value: Uint8Array.from([
+                        73, 39, 109, 32, 97, 32, 108, 105, 116, 116, 108, 101, 32, 116, 101, 97, 112, 111, 116, 33,
+                    ]),
+                },
+                timestamp: {
+                    type: "timestamp",
+                    value: new Date(8675309),
+                },
+                int16: {
+                    type: "short",
+                    value: 42,
+                },
+                int64: {
+                    type: "long",
+                    value: Int64.fromNumber(42424242),
+                },
+                uuid: {
+                    type: "uuid",
+                    value: "01020304-0506-0708-090a-0b0c0d0e0f10",
+                },
+            },
+            body: Uint8Array.from([123, 39, 102, 111, 111, 39, 58, 39, 98, 97, 114, 39, 125]),
+        },
+    },
+    empty_message: {
+        expectation: "success",
+        encoded: Uint8Array.from([0, 0, 0, 16, 0, 0, 0, 0, 5, 194, 72, 235, 125, 152, 200, 255]),
+        decoded: {
+            headers: {},
+            body: Uint8Array.from([]),
+        },
+    },
+    int32_header: {
+        expectation: "success",
+        encoded: Uint8Array.from([
+            0, 0, 0, 45, 0, 0, 0, 16, 65, 196, 36, 184, 10, 101, 118, 101, 110, 116, 45, 116, 121, 112, 101, 4, 0, 0, 160, 12,
+            123, 39, 102, 111, 111, 39, 58, 39, 98, 97, 114, 39, 125, 54, 244, 128, 160,
+        ]),
+        decoded: {
+            headers: {
+                "event-type": {
+                    type: "integer",
+                    value: 40972,
+                },
+            },
+            body: Uint8Array.from([123, 39, 102, 111, 111, 39, 58, 39, 98, 97, 114, 39, 125]),
+        },
+    },
+    payload_no_headers: {
+        expectation: "success",
+        encoded: Uint8Array.from([
+            0, 0, 0, 29, 0, 0, 0, 0, 253, 82, 140, 90, 123, 39, 102, 111, 111, 39, 58, 39, 98, 97, 114, 39, 125, 195, 101, 57,
+            54,
+        ]),
+        decoded: {
+            headers: {},
+            body: Uint8Array.from([123, 39, 102, 111, 111, 39, 58, 39, 98, 97, 114, 39, 125]),
+        },
+    },
+    payload_one_str_header: {
+        expectation: "success",
+        encoded: Uint8Array.from([
+            0, 0, 0, 61, 0, 0, 0, 32, 7, 253, 131, 150, 12, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 7, 0,
+            16, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 106, 115, 111, 110, 123, 39, 102, 111, 111, 39, 58,
+            39, 98, 97, 114, 39, 125, 141, 156, 8, 177,
+        ]),
+        decoded: {
+            headers: {
+                "content-type": {
+                    type: "string",
+                    value: "application/json",
+                },
+            },
+            body: Uint8Array.from([123, 39, 102, 111, 111, 39, 58, 39, 98, 97, 114, 39, 125]),
+        },
+    },
+    corrupted_headers: {
+        expectation: "failure",
+        encoded: Uint8Array.from([
+            0, 0, 0, 61, 0, 0, 0, 32, 7, 253, 131, 150, 12, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 7, 0,
+            16, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 106, 115, 111, 110, 123, 97, 102, 111, 111, 39, 58,
+            39, 98, 97, 114, 39, 125, 141, 156, 8, 177,
+        ]),
+    },
+    corrupted_header_len: {
+        expectation: "failure",
+        encoded: Uint8Array.from([
+            0, 0, 0, 61, 0, 0, 0, 33, 7, 253, 131, 150, 12, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 7, 0,
+            16, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 106, 115, 111, 110, 123, 39, 102, 111, 111, 39, 58,
+            39, 98, 97, 114, 39, 125, 141, 156, 8, 177,
+        ]),
+    },
+    corrupted_length: {
+        expectation: "failure",
+        encoded: Uint8Array.from([
+            0, 0, 0, 62, 0, 0, 0, 32, 7, 253, 131, 150, 12, 99, 111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 7, 0,
+            16, 97, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 47, 106, 115, 111, 110, 123, 39, 102, 111, 111, 39, 58,
+            39, 98, 97, 114, 39, 125, 141, 156, 8, 177,
+        ]),
+    },
+    corrupted_payload: {
+        expectation: "failure",
+        encoded: Uint8Array.from([
+            0, 0, 0, 29, 0, 0, 0, 0, 253, 82, 140, 90, 91, 39, 102, 111, 111, 39, 58, 39, 98, 97, 114, 39, 125, 195, 101, 57,
+            54,
+        ]),
+    },
+};

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

@@ -1,4 +1,4 @@
-import { Crc32 } from "@smithy/core/checksum";
+import { Crc32 } from "@aws-crypto/crc32";
 const PRELUDE_MEMBER_LENGTH = 4;
 const PRELUDE_LENGTH = PRELUDE_MEMBER_LENGTH * 2;
 const CHECKSUM_LENGTH = 4;
@@ -15,14 +15,13 @@ export function splitMessage({ byteLength, byteOffset, buffer }) {
     const headerLength = view.getUint32(PRELUDE_MEMBER_LENGTH, false);
     const expectedPreludeChecksum = view.getUint32(PRELUDE_LENGTH, false);
     const expectedMessageChecksum = view.getUint32(byteLength - CHECKSUM_LENGTH, false);
-    const checksummer = new Crc32();
-    checksummer.update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
-    if (expectedPreludeChecksum !== checksummer.digestSync()) {
-        throw new Error(`The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digestSync()})`);
+    const checksummer = new Crc32().update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
+    if (expectedPreludeChecksum !== checksummer.digest()) {
+        throw new Error(`The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digest()})`);
     }
     checksummer.update(new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH, byteLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH)));
-    if (expectedMessageChecksum !== checksummer.digestSync()) {
-        throw new Error(`The message checksum (${checksummer.digestSync()}) did not match the expected value of ${expectedMessageChecksum}`);
+    if (expectedMessageChecksum !== checksummer.digest()) {
+        throw new Error(`The message checksum (${checksummer.digest()}) did not match the expected value of ${expectedMessageChecksum}`);
     }
     return {
         headers: new DataView(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH, headerLength),

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

@@ -1,10 +1,9 @@
-import { hasOwn } from "@smithy/core/transport";
 import { NormalizedSchema, translateTraits } from "@smithy/core/schema";
 import { sdkStreamMixin, splitEvery, splitHeader } from "@smithy/core/serde";
-import { HttpRequest } from "@smithy/core/transport";
 import { HttpProtocol } from "./HttpProtocol";
 import { collectBody } from "./collect-stream-body";
 import { extendedEncodeURIComponent } from "./extended-encode-uri-component";
+import { HttpRequest } from "./protocol-http/httpRequest";
 export class HttpBindingProtocol extends HttpProtocol {
     async serializeRequest(operationSchema, _input, context) {
         const input = _input && typeof _input === "object" ? _input : {};
@@ -94,8 +93,6 @@ export class HttpBindingProtocol extends HttpProtocol {
             }
             else if (typeof memberTraits.httpPrefixHeaders === "string") {
                 for (const key in inputMemberValue) {
-                    if (!hasOwn(inputMemberValue, key))
-                        continue;
                     const val = inputMemberValue[key];
                     const amalgam = memberTraits.httpPrefixHeaders + key;
                     serializer.write([memberNs.getValueSchema(), { httpHeader: amalgam }], val);
@@ -142,8 +139,6 @@ export class HttpBindingProtocol extends HttpProtocol {
         const traits = ns.getMergedTraits();
         if (traits.httpQueryParams) {
             for (const key in data) {
-                if (!hasOwn(data, key))
-                    continue;
                 if (!(key in query)) {
                     const val = data[key];
                     const valueSchema = ns.getValueSchema();
@@ -187,8 +182,6 @@ export class HttpBindingProtocol extends HttpProtocol {
             throw new Error("@smithy/core/protocols - HTTP Protocol error handler failed to throw.");
         }
         for (const header in response.headers) {
-            if (!hasOwn(response.headers, header))
-                continue;
             const value = response.headers[header];
             delete response.headers[header];
             response.headers[header.toLowerCase()] = value;
@@ -276,8 +269,6 @@ export class HttpBindingProtocol extends HttpProtocol {
             else if (memberTraits.httpPrefixHeaders !== undefined) {
                 dataObject[memberName] = {};
                 for (const header in response.headers) {
-                    if (!hasOwn(response.headers, header))
-                        continue;
                     if (header.startsWith(memberTraits.httpPrefixHeaders)) {
                         const value = response.headers[header];
                         const valueSchema = memberSchema.getValueSchema();

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

@@ -1,7 +1,7 @@
-import { hasOwn } from "@smithy/core/transport";
 import { NormalizedSchema, TypeRegistry, translateTraits } from "@smithy/core/schema";
-import { HttpRequest, HttpResponse, isValidHostname } from "@smithy/core/transport";
 import { SerdeContext } from "./SerdeContext";
+import { HttpRequest } from "./protocol-http/httpRequest";
+import { HttpResponse } from "./protocol-http/httpResponse";
 export class HttpProtocol extends SerdeContext {
     options;
     compositeErrorRegistry;
@@ -44,8 +44,6 @@ export class HttpProtocol extends SerdeContext {
             }
             if (endpoint.headers) {
                 for (const name in endpoint.headers) {
-                    if (!hasOwn(endpoint.headers, name))
-                        continue;
                     request.headers[name] = endpoint.headers[name].join(", ");
                 }
             }
@@ -61,8 +59,6 @@ export class HttpProtocol extends SerdeContext {
             };
             if (endpoint.headers) {
                 for (const name in endpoint.headers) {
-                    if (!hasOwn(endpoint.headers, name))
-                        continue;
                     request.headers[name] = endpoint.headers[name];
                 }
             }
@@ -89,9 +85,6 @@ export class HttpProtocol extends SerdeContext {
                     hostPrefix = hostPrefix.replace(`{${name}}`, replacement);
                 }
                 request.hostname = hostPrefix + request.hostname;
-                if (!isValidHostname(request.hostname)) {
-                    throw new Error(`[${request.hostname}] is not a valid hostname.`);
-                }
             }
         }
     }
@@ -120,24 +113,15 @@ export class HttpProtocol extends SerdeContext {
         });
     }
     async loadEventStreamCapability() {
-        const { EventStreamSerde, eventStreamSerdeProvider } = await import("@smithy/core/event-streams");
-        const marshaller = this.resolveEventStreamMarshaller(eventStreamSerdeProvider);
+        const { EventStreamSerde } = await import("@smithy/core/event-streams");
         return new EventStreamSerde({
-            marshaller,
+            marshaller: this.getEventStreamMarshaller(),
             serializer: this.serializer,
             deserializer: this.deserializer,
             serdeContext: this.serdeContext,
             defaultContentType: this.getDefaultContentType(),
-            compositeErrorRegistry: this.compositeErrorRegistry,
         });
     }
-    resolveEventStreamMarshaller(importedProvider) {
-        const context = this.serdeContext;
-        if (context.eventStreamMarshaller) {
-            return context.eventStreamMarshaller;
-        }
-        return importedProvider(this.serdeContext);
-    }
     getDefaultContentType() {
         throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`);
     }

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

@@ -1,8 +1,7 @@
-import { hasOwn } from "@smithy/core/transport";
 import { NormalizedSchema } from "@smithy/core/schema";
-import { HttpRequest } from "@smithy/core/transport";
 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;
@@ -32,9 +31,10 @@ export class RpcProtocol extends HttpProtocol {
             if (eventStreamMember) {
                 if (input[eventStreamMember]) {
                     const initialRequest = {};
-                    for (const [memberName] of ns.structIterator()) {
-                        if (memberName !== eventStreamMember && input[memberName] != null) {
-                            initialRequest[memberName] = input[memberName];
+                    for (const [memberName, memberSchema] of ns.structIterator()) {
+                        if (memberName !== eventStreamMember && input[memberName]) {
+                            serializer.write(memberSchema, input[memberName]);
+                            initialRequest[memberName] = serializer.flush();
                         }
                     }
                     payload = await this.serializeEventStream({
@@ -68,8 +68,6 @@ export class RpcProtocol extends HttpProtocol {
             throw new Error("@smithy/core/protocols - RPC Protocol error handler failed to throw.");
         }
         for (const header in response.headers) {
-            if (!hasOwn(response.headers, header))
-                continue;
             const value = response.headers[header];
             delete response.headers[header];
             response.headers[header.toLowerCase()] = value;

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

@@ -1,25 +1,25 @@
-export { collectBody } from "./collect-stream-body";
-export { extendedEncodeURIComponent } from "./extended-encode-uri-component";
-export { HttpBindingProtocol } from "./HttpBindingProtocol";
-export { HttpProtocol } from "./HttpProtocol";
-export { RpcProtocol } from "./RpcProtocol";
-export { RequestBuilder, requestBuilder } from "./requestBuilder";
-export { resolvedPath } from "./resolve-path";
-export { FromStringShapeDeserializer } from "./serde/FromStringShapeDeserializer";
-export { HttpInterceptingShapeDeserializer } from "./serde/HttpInterceptingShapeDeserializer";
-export { HttpInterceptingShapeSerializer } from "./serde/HttpInterceptingShapeSerializer";
-export { ToStringShapeSerializer } from "./serde/ToStringShapeSerializer";
-export { determineTimestampFormat } from "./serde/determineTimestampFormat";
-export { SerdeContext } from "./SerdeContext";
+export * from "./collect-stream-body";
+export * from "./extended-encode-uri-component";
+export * from "./HttpBindingProtocol";
+export * from "./HttpProtocol";
+export * from "./RpcProtocol";
+export * from "./requestBuilder";
+export * from "./resolve-path";
+export * from "./serde/FromStringShapeDeserializer";
+export * from "./serde/HttpInterceptingShapeDeserializer";
+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 "@smithy/core/transport";
-export { HttpResponse } from "@smithy/core/transport";
-export { isValidHostname } from "@smithy/core/transport";
+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 "@smithy/core/transport";
-export { parseUrl } from "@smithy/core/transport";
+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

@@ -1,4 +1,4 @@
-import { HttpRequest } from "@smithy/core/transport";
+import { HttpRequest } from "../protocol-http/httpRequest";
 const CONTENT_LENGTH_HEADER = "content-length";
 export function contentLengthMiddleware(bodyLengthChecker) {
     return (next) => async (args) => {
@@ -11,14 +11,12 @@ export function contentLengthMiddleware(bodyLengthChecker) {
                     .indexOf(CONTENT_LENGTH_HEADER) === -1) {
                 try {
                     const length = bodyLengthChecker(body);
-                    if (length != null) {
-                        request.headers = {
-                            ...request.headers,
-                            [CONTENT_LENGTH_HEADER]: String(length),
-                        };
-                    }
+                    request.headers = {
+                        ...request.headers,
+                        [CONTENT_LENGTH_HEADER]: String(length),
+                    };
                 }
-                catch (ignored) {
+                catch (error) {
                 }
             }
         }

package/node_modules/@smithy/core/dist-es/submodules/protocols/protocol-http/extensions/httpExtensionConfiguration.js

@@ -1,24 +1,21 @@
 export const getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
-    if (runtimeConfig.logger && runtimeConfig.logger.constructor?.name !== "NoOpLogger") {
-        runtimeConfig.requestHandler?.updateHttpClientConfig?.(Symbol.for("logger"), runtimeConfig.logger);
-    }
     return {
         setHttpHandler(handler) {
-            runtimeConfig.requestHandler = handler;
+            runtimeConfig.httpHandler = handler;
         },
         httpHandler() {
-            return runtimeConfig.requestHandler;
+            return runtimeConfig.httpHandler;
         },
         updateHttpClientConfig(key, value) {
-            runtimeConfig.requestHandler?.updateHttpClientConfig(key, value);
+            runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
         },
         httpHandlerConfigs() {
-            return runtimeConfig.requestHandler.httpHandlerConfigs();
+            return runtimeConfig.httpHandler.httpHandlerConfigs();
         },
     };
 };
 export const resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
     return {
-        requestHandler: httpHandlerExtensionConfiguration.httpHandler(),
+        httpHandler: httpHandlerExtensionConfiguration.httpHandler(),
     };
 };

package/node_modules/@smithy/core/dist-es/submodules/protocols/protocol-http/isValidHostname.js

@@ -0,0 +1,4 @@
+export function isValidHostname(hostname) {
+    const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/;
+    return hostPattern.test(hostname);
+}

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

@@ -1,4 +1,4 @@
-import { HttpRequest } from "@smithy/core/transport";
+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/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/middleware-retry/configurations.js

@@ -2,7 +2,6 @@ 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";
-import { Retry } from "../util-retry/retries-2026-config";
 export const ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
 export const CONFIG_MAX_ATTEMPTS = "max_attempts";
 export const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
@@ -28,29 +27,17 @@ export const NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
     },
     default: DEFAULT_MAX_ATTEMPTS,
 };
-export const resolveRetryConfig = (input, defaults) => {
+export const resolveRetryConfig = (input) => {
     const { retryStrategy, retryMode } = input;
-    const { defaultMaxAttempts = DEFAULT_MAX_ATTEMPTS, defaultBaseDelay = Retry.delay() } = defaults ?? {};
-    const maxAttemptsProvider = normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
+    const maxAttempts = normalizeProvider(input.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
     let controller = retryStrategy
         ? Promise.resolve(retryStrategy)
         : undefined;
-    const getDefault = async () => {
-        const maxAttempts = await maxAttemptsProvider();
-        const adaptive = (await normalizeProvider(retryMode)()) === RETRY_MODES.ADAPTIVE;
-        if (adaptive) {
-            return new AdaptiveRetryStrategy(maxAttemptsProvider, {
-                maxAttempts,
-                baseDelay: defaultBaseDelay,
-            });
-        }
-        return new StandardRetryStrategy({
-            maxAttempts,
-            baseDelay: defaultBaseDelay,
-        });
-    };
+    const getDefault = async () => (await normalizeProvider(retryMode)()) === RETRY_MODES.ADAPTIVE
+        ? new AdaptiveRetryStrategy(maxAttempts)
+        : new StandardRetryStrategy(maxAttempts);
     return Object.assign(input, {
-        maxAttempts: maxAttemptsProvider,
+        maxAttempts,
         retryStrategy: () => (controller ??= getDefault()),
     });
 };

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

@@ -1,13 +1,10 @@
-import { hasOwn } from "@smithy/core/transport";
 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 in response.headers) {
-        if (!hasOwn(response.headers, header))
-            continue;
+    for (const header of Object.keys(response.headers)) {
         const h = header.toLowerCase();
         if (h === "retry-after") {
             const retryAfter = response.headers[header];

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

@@ -27,7 +27,7 @@ export class StandardRetryStrategy {
         try {
             maxAttempts = await this.maxAttemptsProvider();
         }
-        catch (ignored) {
+        catch (error) {
             maxAttempts = DEFAULT_MAX_ATTEMPTS;
         }
         return maxAttempts;
@@ -89,7 +89,7 @@ const getDelayFromRetryAfterHeader = (response) => {
     const retryAfter = response.headers[retryAfterHeaderName];
     const retryAfterSeconds = Number(retryAfter);
     if (!Number.isNaN(retryAfterSeconds))
-        return Math.min(retryAfterSeconds * 1000, 20_000);
+        return retryAfterSeconds * 1000;
     const retryAfterDate = new Date(retryAfter);
-    return Math.min(retryAfterDate.getTime() - Date.now(), 20_000);
+    return retryAfterDate.getTime() - Date.now();
 };

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

@@ -41,7 +41,10 @@ export function bindRetryMiddleware(isStreamingPayload) {
                     try {
                         retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
                     }
-                    catch (ignoredRefreshError) {
+                    catch (refreshError) {
+                        if (typeof refreshError.$backoff === "number") {
+                            await cooldown(refreshError.$backoff);
+                        }
                         if (!lastError.$metadata) {
                             lastError.$metadata = {};
                         }
@@ -51,10 +54,8 @@ export function bindRetryMiddleware(isStreamingPayload) {
                     }
                     attempts = retryToken.getRetryCount();
                     const delay = retryToken.getRetryDelay();
-                    totalRetryDelay += (retryToken?.$retryLog?.acquisitionDelay ?? 0) + delay;
-                    if (delay > 0) {
-                        await cooldown(delay);
-                    }
+                    totalRetryDelay += delay;
+                    await cooldown(delay);
                 }
             }
         }

package/node_modules/@smithy/core/dist-es/submodules/retry/service-error-classification/constants.js

@@ -1,5 +1,4 @@
 export const CLOCK_SKEW_ERROR_CODES = [
-    "AccessDeniedException",
     "AuthFailure",
     "InvalidSignatureException",
     "RequestExpired",
@@ -26,4 +25,4 @@ export const THROTTLING_ERROR_CODES = [
 export const TRANSIENT_ERROR_CODES = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"];
 export const TRANSIENT_ERROR_STATUS_CODES = [500, 502, 503, 504];
 export const NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"];
-export const NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND", "EAI_AGAIN"];
+export const NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND"];

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

@@ -10,9 +10,10 @@ export class ConfiguredRetryStrategy extends StandardRetryStrategy {
         else {
             this.computeNextBackoffDelay = computeNextBackoffDelay;
         }
-        this.retryBackoffStrategy.computeNextBackoffDelay = (completedAttempt) => {
-            const nextAttempt = completedAttempt + 1;
-            return this.computeNextBackoffDelay(nextAttempt);
-        };
+    }
+    async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
+        const token = await super.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
+        token.getRetryDelay = () => this.computeNextBackoffDelay(token.getRetryCount());
+        return token;
     }
 }

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

@@ -1,6 +1,6 @@
 import { isThrottlingError } from "../service-error-classification/service-error-classification";
 export class DefaultRateLimiter {
-    static setTimeoutFn = (fn, delay) => setTimeout(fn, delay);
+    static setTimeoutFn = setTimeout;
     beta;
     minCapacity;
     minFillRate;