lambda-live-debugger 1.12.7 → 1.12.9

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

@@ -1,7 +1,9 @@
 import { NoOpLogger } from "@smithy/core/client";
 import { HttpRequest } from "@smithy/core/protocols";
 import { v4 } from "@smithy/core/serde";
+import { SMITHY_CONTEXT_KEY } from "@smithy/types";
 import { isServerError, isThrottlingError, isTransientError, } from "../service-error-classification/service-error-classification";
+import { isAbortError, race } from "../util-retry/race";
 import { INVOCATION_ID_HEADER, REQUEST_HEADER } from "../util-retry/constants";
 import { parseRetryAfterHeader } from "./parseRetryAfterHeader";
 import { asSdkError } from "./util";
@@ -9,9 +11,11 @@ export function bindRetryMiddleware(isStreamingPayload) {
     return (options) => (next, context) => async (args) => {
         let retryStrategy = await options.retryStrategy();
         const maxAttempts = await options.maxAttempts();
+        const abortSignal = context[SMITHY_CONTEXT_KEY]?.abortSignal;
         if (isRetryStrategyV2(retryStrategy)) {
             retryStrategy = retryStrategy;
-            let retryToken = await retryStrategy.acquireInitialRetryToken((context["partition_id"] ?? "") + (context.__retryLongPoll ? ":longpoll" : ""));
+            const retryTokenScope = (context["partition_id"] ?? "") + (context.__retryLongPoll ? ":longpoll" : "");
+            let retryToken = await race(retryStrategy.acquireInitialRetryToken(retryTokenScope), abortSignal);
             let lastError = new Error();
             let attempts = 0;
             let totalRetryDelay = 0;
@@ -39,9 +43,12 @@ export function bindRetryMiddleware(isStreamingPayload) {
                         throw lastError;
                     }
                     try {
-                        retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
+                        retryToken = await race(retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo), abortSignal);
                     }
-                    catch (ignoredRefreshError) {
+                    catch (refreshError) {
+                        if (abortSignal?.aborted && isAbortError(refreshError)) {
+                            throw refreshError;
+                        }
                         if (!lastError.$metadata) {
                             lastError.$metadata = {};
                         }
@@ -53,7 +60,7 @@ export function bindRetryMiddleware(isStreamingPayload) {
                     const delay = retryToken.getRetryDelay();
                     totalRetryDelay += (retryToken?.$retryLog?.acquisitionDelay ?? 0) + delay;
                     if (delay > 0) {
-                        await cooldown(delay);
+                        await race(new Promise((resolve) => setTimeout(resolve, delay)), abortSignal);
                     }
                 }
             }
@@ -67,7 +74,6 @@ export function bindRetryMiddleware(isStreamingPayload) {
         }
     };
 }
-const cooldown = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" &&
     typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" &&
     typeof retryStrategy.recordSuccess !== "undefined";
@@ -83,12 +89,15 @@ const getRetryErrorInfo = (error, logger) => {
     return errorInfo;
 };
 const getRetryErrorType = (error) => {
-    if (isThrottlingError(error))
+    if (isThrottlingError(error)) {
         return "THROTTLING";
-    if (isTransientError(error))
+    }
+    if (isTransientError(error)) {
         return "TRANSIENT";
-    if (isServerError(error))
+    }
+    if (isServerError(error)) {
         return "SERVER_ERROR";
+    }
     return "CLIENT_ERROR";
 };
 export const retryMiddlewareOptions = {

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

@@ -1,9 +1,12 @@
 export const asSdkError = (error) => {
-    if (error instanceof Error)
+    if (error instanceof Error) {
         return error;
-    if (error instanceof Object)
+    }
+    if (error instanceof Object) {
         return Object.assign(new Error(), error);
-    if (typeof error === "string")
+    }
+    if (typeof error === "string") {
         return new Error(error);
+    }
     return new Error(`AWS SDK error wrapper for ${error}`);
 };

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

@@ -19,16 +19,17 @@ export const isBrowserNetworkError = (error) => {
 export const isThrottlingError = (error) => error.$metadata?.httpStatusCode === 429 ||
     THROTTLING_ERROR_CODES.includes(error.name) ||
     error.$retryable?.throttling == true;
-export const isTransientError = (error, depth = 0) => isRetryableByTrait(error) ||
-    isClockSkewCorrectedError(error) ||
-    (error.name === "InvalidSignatureException" && error.message?.includes("Signature expired")) ||
-    TRANSIENT_ERROR_CODES.includes(error.name) ||
-    NODEJS_TIMEOUT_ERROR_CODES.includes(error?.code || "") ||
-    NODEJS_NETWORK_ERROR_CODES.includes(error?.code || "") ||
-    TRANSIENT_ERROR_STATUS_CODES.includes(error.$metadata?.httpStatusCode || 0) ||
-    isBrowserNetworkError(error) ||
-    isNodeJsHttp2TransientError(error) ||
-    (error.cause !== undefined && depth <= 10 && isTransientError(error.cause, depth + 1));
+export const isTransientError = (error, depth = 0) => error?.name !== "AbortError" &&
+    (isRetryableByTrait(error) ||
+        isClockSkewCorrectedError(error) ||
+        (error.name === "InvalidSignatureException" && error.message?.includes("Signature expired")) ||
+        TRANSIENT_ERROR_CODES.includes(error.name) ||
+        NODEJS_TIMEOUT_ERROR_CODES.includes(error?.code || "") ||
+        NODEJS_NETWORK_ERROR_CODES.includes(error?.code || "") ||
+        TRANSIENT_ERROR_STATUS_CODES.includes(error.$metadata?.httpStatusCode || 0) ||
+        isBrowserNetworkError(error) ||
+        isNodeJsHttp2TransientError(error) ||
+        (error.cause !== undefined && depth <= 10 && isTransientError(error.cause, depth + 1)));
 export const isServerError = (error) => {
     if (error.$metadata?.httpStatusCode !== undefined) {
         const statusCode = error.$metadata.httpStatusCode;

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

@@ -0,0 +1,22 @@
+export const race = (promise, signal) => {
+    if (!signal) {
+        return promise;
+    }
+    let cleanup = () => { };
+    const aborted = new Promise((_, reject) => {
+        const handler = () => reject(createAbortError());
+        if (signal.aborted) {
+            handler();
+        }
+        else if (typeof signal.addEventListener === "function") {
+            signal.addEventListener("abort", handler, { once: true });
+            cleanup = () => signal.removeEventListener("abort", handler);
+        }
+        else {
+            signal.onabort = handler;
+        }
+    });
+    return Promise.race([promise, aborted]).finally(cleanup);
+};
+const createAbortError = () => Object.assign(new Error("Request aborted"), { name: "AbortError" });
+export const isAbortError = (error) => typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";

package/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js

@@ -7,12 +7,12 @@ export class TypeRegistry {
         this.namespace = namespace;
         this.schemas = schemas;
         this.exceptions = exceptions;
-    }
-    static for(namespace) {
         if (!TypeRegistry.registries.has(namespace)) {
-            TypeRegistry.registries.set(namespace, new TypeRegistry(namespace));
+            TypeRegistry.registries.set(namespace, this);
         }
-        return TypeRegistry.registries.get(namespace);
+    }
+    static for(namespace) {
+        return TypeRegistry.registries.get(namespace) ?? new TypeRegistry(namespace);
     }
     copyFrom(other) {
         const { schemas, exceptions } = this;
@@ -30,7 +30,9 @@ export class TypeRegistry {
     register(shapeId, schema) {
         const qualifiedName = this.normalizeShapeId(shapeId);
         for (const r of [this, TypeRegistry.for(qualifiedName.split("#")[0])]) {
-            r.schemas.set(qualifiedName, schema);
+            if (!r.schemas.has(qualifiedName)) {
+                r.schemas.set(qualifiedName, schema);
+            }
         }
     }
     getSchema(shapeId) {
@@ -55,9 +57,15 @@ export class TypeRegistry {
     registerError(es, ctor) {
         const $error = es;
         const ns = $error[1];
+        const qualifiedName = ns + "#" + $error[2];
+        if (!ctor.hasOwnProperty?.("shapeId")) {
+            ctor.shapeId = qualifiedName;
+        }
         for (const r of [this, TypeRegistry.for(ns)]) {
-            r.schemas.set(ns + "#" + $error[2], $error);
-            r.exceptions.set($error, ctor);
+            if (!r.schemas.has(qualifiedName) && !r.exceptions.has($error)) {
+                r.schemas.set(qualifiedName, $error);
+                r.exceptions.set($error, ctor);
+            }
         }
     }
     getErrorCtor(es) {

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

@@ -41,3 +41,5 @@ export { streamCollector } from "./util-stream/stream-collector.browser";
 const _getRandomValues = (array) => crypto.getRandomValues(array);
 export const v4 = bindV4(_getRandomValues);
 export const generateIdempotencyToken = v4;
+export { hasOwn } from "@smithy/core/transport";
+export { writeKey } from "./writeKey";

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

@@ -40,3 +40,5 @@ export { streamCollector } from "./util-stream/stream-collector";
 const _getRandomValues = getRandomValues;
 export const v4 = bindV4(_getRandomValues);
 export const generateIdempotencyToken = v4;
+export { hasOwn } from "@smithy/core/transport";
+export { writeKey } from "./writeKey";

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

@@ -43,3 +43,5 @@ export { streamCollector } from "./util-stream/stream-collector.browser";
 const _getRandomValues = (array) => crypto.getRandomValues(array);
 export const v4 = bindV4(_getRandomValues);
 export const generateIdempotencyToken = v4;
+export { hasOwn } from "@smithy/core/transport";
+export { writeKey } from "./writeKey";

package/node_modules/@smithy/core/dist-es/submodules/serde/parse-utils.js

@@ -1,3 +1,4 @@
+import { hasOwn } from "@smithy/core/transport";
 export const parseBoolean = (value) => {
     switch (value) {
         case "true":
@@ -137,6 +138,9 @@ export const expectUnion = (value) => {
     const asObject = expectObject(value);
     const setKeys = [];
     for (const k in asObject) {
+        if (!hasOwn(asObject, k)) {
+            continue;
+        }
         if (asObject[k] != null) {
             setKeys.push(k);
         }

package/node_modules/@smithy/core/dist-es/submodules/serde/util-body-length/calculateBodyLength.browser.js

@@ -7,12 +7,15 @@ export const calculateBodyLength = (body) => {
         let len = body.length;
         for (let i = len - 1; i >= 0; i--) {
             const code = body.charCodeAt(i);
-            if (code > 0x7f && code <= 0x7ff)
+            if (code > 0x7f && code <= 0x7ff) {
                 len++;
-            else if (code > 0x7ff && code <= 0xffff)
+            }
+            else if (code > 0x7ff && code <= 0xffff) {
                 len += 2;
-            if (code >= 0xdc00 && code <= 0xdfff)
+            }
+            if (code >= 0xdc00 && code <= 0xdfff) {
                 i--;
+            }
         }
         return len;
     }

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/getAwsChunkedEncodingStream.browser.js

@@ -6,6 +6,8 @@ export const getAwsChunkedEncodingStream = (readableStream, options) => {
         checksumLocationName !== undefined &&
         streamHasher !== undefined;
     const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readableStream) : undefined;
+    Promise.resolve(digest).catch(() => {
+    });
     const reader = readableStream.getReader();
     return new ReadableStream({
         async pull(controller) {

package/node_modules/@smithy/core/dist-es/submodules/serde/util-stream/getAwsChunkedEncodingStream.js

@@ -13,8 +13,12 @@ export function getAwsChunkedEncodingStream(stream, options) {
         checksumLocationName !== undefined &&
         streamHasher !== undefined;
     const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readable) : undefined;
+    Promise.resolve(digest).catch(() => {
+    });
     const awsChunkedEncodingStream = new Readable({
-        read: () => { },
+        read() {
+            readable.resume();
+        },
     });
     readable.on("data", (data) => {
         const length = bodyLengthChecker(data) || 0;
@@ -23,16 +27,27 @@ export function getAwsChunkedEncodingStream(stream, options) {
         }
         awsChunkedEncodingStream.push(`${length.toString(16)}\r\n`);
         awsChunkedEncodingStream.push(data);
-        awsChunkedEncodingStream.push("\r\n");
+        if (!awsChunkedEncodingStream.push("\r\n")) {
+            readable.pause();
+        }
     });
+    readable.on("error", (err) => {
+        awsChunkedEncodingStream.destroy(err);
+    });
+    readable.pause();
     readable.on("end", async () => {
-        awsChunkedEncodingStream.push(`0\r\n`);
-        if (checksumRequired) {
-            const checksum = base64Encoder(await digest);
-            awsChunkedEncodingStream.push(`${checksumLocationName}:${checksum}\r\n`);
-            awsChunkedEncodingStream.push(`\r\n`);
+        try {
+            awsChunkedEncodingStream.push(`0\r\n`);
+            if (checksumRequired) {
+                const checksum = base64Encoder(await digest);
+                awsChunkedEncodingStream.push(`${checksumLocationName}:${checksum}\r\n`);
+                awsChunkedEncodingStream.push(`\r\n`);
+            }
+            awsChunkedEncodingStream.push(null);
+        }
+        catch (err) {
+            awsChunkedEncodingStream.destroy(err);
         }
-        awsChunkedEncodingStream.push(null);
     });
     return awsChunkedEncodingStream;
 }

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

@@ -0,0 +1,3 @@
+export function writeKey(obj) {
+    Object.defineProperty(obj, "__proto__", { value: undefined, writable: true, enumerable: true, configurable: true });
+}

package/node_modules/@smithy/core/dist-es/submodules/transport/hasOwn.js

@@ -0,0 +1,3 @@
+export function hasOwn(o, k) {
+    return Object.prototype.hasOwnProperty.call(o, k);
+}

package/node_modules/@smithy/core/dist-es/submodules/transport/httpResponse.js

@@ -10,8 +10,9 @@ export class HttpResponse {
         this.body = options.body;
     }
     static isInstance(response) {
-        if (!response)
+        if (!response) {
             return false;
+        }
         const resp = response;
         return typeof resp.statusCode === "number" && typeof resp.headers === "object";
     }

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

@@ -1,4 +1,5 @@
 export { getSmithyContext } from "./getSmithyContext";
+export { hasOwn } from "./hasOwn";
 export { HttpRequest } from "./httpRequest";
 export { HttpResponse } from "./httpResponse";
 export { isValidHostLabel } from "./isValidHostLabel";

package/node_modules/@smithy/core/dist-es/submodules/transport/normalizeProvider.js

@@ -1,6 +1,7 @@
 export const normalizeProvider = (input) => {
-    if (typeof input === "function")
+    if (typeof input === "function") {
         return input;
+    }
     const promisified = Promise.resolve(input);
     return () => promisified;
 };

package/node_modules/@smithy/core/dist-es/submodules/transport/toEndpointV1.js

@@ -1,3 +1,4 @@
+import { hasOwn } from "./hasOwn";
 import { parseUrl } from "./parseUrl";
 export const toEndpointV1 = (endpoint) => {
     if (typeof endpoint === "object") {
@@ -6,6 +7,9 @@ export const toEndpointV1 = (endpoint) => {
             if (endpoint.headers) {
                 v1Endpoint.headers = {};
                 for (const name in endpoint.headers) {
+                    if (!hasOwn(endpoint.headers, name)) {
+                        continue;
+                    }
                     v1Endpoint.headers[name.toLowerCase()] = endpoint.headers[name].join(", ");
                 }
             }

package/node_modules/@smithy/core/dist-types/submodules/cbor/SmithyRpcV2CborProtocol.d.ts

@@ -1,28 +1,19 @@
-import { RpcProtocol } from "@smithy/core/protocols";
-import { TypeRegistry } from "@smithy/core/schema";
-import type { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, SerdeFunctions } from "@smithy/types";
+import { AbstractRpcV2Protocol } from "@smithy/core/protocols";
+import type { HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, OperationSchema, ResponseMetadata, SerdeFunctions } from "@smithy/types";
 import { CborCodec } from "./CborCodec";
 /**
  * Client protocol for Smithy RPCv2 CBOR.
  *
  * @public
  */
-export declare class SmithyRpcV2CborProtocol extends RpcProtocol {
-    /**
-     * @override
-     */
-    protected compositeErrorRegistry: TypeRegistry;
+export declare class SmithyRpcV2CborProtocol extends AbstractRpcV2Protocol {
     private codec;
     protected serializer: import(".").CborShapeSerializer2;
     protected deserializer: import(".").CborShapeDeserializer2;
-    constructor({ defaultNamespace, errorTypeRegistries, }: {
-        defaultNamespace: string;
-        errorTypeRegistries?: TypeRegistry[];
-    });
     getShapeId(): string;
     getPayloadCodec(): CborCodec;
-    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
-    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    protected getSmithyProtocolHeaderValue(): string;
+    protected applyEmptyBody(request: IHttpRequest): void;
     protected handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
     protected getDefaultContentType(): string;
 }

package/node_modules/@smithy/core/dist-types/submodules/cbor/parseCborBody.d.ts

@@ -18,6 +18,9 @@ export declare const dateToTag: (date: Date) => {
  */
 export declare const parseCborErrorBody: (errorBody: any, context: SerdeContext) => Promise<any>;
 /**
+ * Trims error.__type
+ * "com.a.b#Error:Sender,tag" -> "com.a.b#Error"
+ *
  * @internal
  */
 export declare const loadSmithyRpcV2CborErrorCode: (output: HttpResponse, data: any) => string | undefined;

package/node_modules/@smithy/core/dist-types/submodules/client/index.d.ts

@@ -5,7 +5,7 @@ export { invalidFunction } from "./invalid-dependency/invalidFunction";
 export { invalidProvider } from "./invalid-dependency/invalidProvider";
 export { createWaiter } from "./util-waiter/createWaiter";
 export { waiterServiceDefaults, WaiterState, checkExceptions, type WaiterConfiguration, type WaiterOptions, type WaiterResult, } from "./util-waiter/waiter";
-export { Client, type SmithyConfiguration, type SmithyResolvedConfiguration } from "./smithy-client/client";
+export { Client, type SmithyClientRequestOptions, type SmithyConfiguration, type SmithyResolvedConfiguration, } from "./smithy-client/client";
 export { Command, type CommandImpl } from "./smithy-client/command";
 export { SENSITIVE_STRING } from "./smithy-client/constants";
 export { createAggregatedClient } from "./smithy-client/create-aggregated-client";

package/node_modules/@smithy/core/dist-types/submodules/client/smithy-client/client.d.ts

@@ -1,4 +1,12 @@
-import type { $ClientProtocol, $ClientProtocolCtor, ClientProtocol, ClientProtocolCtor, Command, FetchHttpHandlerOptions, Client as IClient, MetadataBearer, MiddlewareStack, NodeHttpHandlerOptions, RequestHandler } from "@smithy/types";
+import type { $ClientProtocol, $ClientProtocolCtor, ClientProtocol, ClientProtocolCtor, Command, FetchHttpHandlerOptions, Client as IClient, MetadataBearer, MetricsRecorder, MiddlewareStack, NodeHttpHandlerOptions, RequestHandler } from "@smithy/types";
+/**
+ * Options accepted for an individual Smithy client request.
+ *
+ * @public
+ */
+export type SmithyClientRequestOptions<HandlerOptions> = unknown extends HandlerOptions ? HandlerOptions : HandlerOptions extends unknown ? keyof HandlerOptions extends never ? HandlerOptions : HandlerOptions & {
+    metricsRecorder?: MetricsRecorder<unknown>;
+} : never;
 /**
  * @public
  */
@@ -77,8 +85,8 @@ export declare class Client<HandlerOptions, ClientInput extends object, ClientOu
      */
     private handlers?;
     constructor(config: ResolvedClientConfiguration);
-    send<InputType extends ClientInput, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, SmithyResolvedConfiguration<HandlerOptions>>, options?: HandlerOptions): Promise<OutputType>;
+    send<InputType extends ClientInput, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, SmithyResolvedConfiguration<HandlerOptions>>, options?: SmithyClientRequestOptions<HandlerOptions>): Promise<OutputType>;
     send<InputType extends ClientInput, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, SmithyResolvedConfiguration<HandlerOptions>>, cb: (err: any, data?: OutputType) => void): void;
-    send<InputType extends ClientInput, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, SmithyResolvedConfiguration<HandlerOptions>>, options: HandlerOptions, cb: (err: any, data?: OutputType) => void): void;
+    send<InputType extends ClientInput, OutputType extends ClientOutput>(command: Command<ClientInput, InputType, ClientOutput, OutputType, SmithyResolvedConfiguration<HandlerOptions>>, options: SmithyClientRequestOptions<HandlerOptions>, cb: (err: any, data?: OutputType) => void): void;
     destroy(): void;
 }

package/node_modules/@smithy/core/dist-types/submodules/client/smithy-client/exceptions.d.ts

@@ -18,6 +18,7 @@ export interface ServiceExceptionOptions extends SmithyException, MetadataBearer
  * @public
  */
 export declare class ServiceException extends Error implements SmithyException, MetadataBearer {
+    static readonly shapeId: string;
     readonly $fault: "client" | "server";
     $response?: HttpResponse;
     $retryable?: RetryableTrait;

package/node_modules/@smithy/core/dist-types/submodules/errors/errors.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A general SDK error that does not fall into a more specific category.
+ *
+ * @public
+ */
+export declare class SmithyError extends Error {
+    name: string;
+    readonly $source: string;
+}
+/**
+ * A value had the wrong type or could not be interpreted as the expected type.
+ *
+ * @public
+ */
+export declare class SmithyTypeError extends TypeError {
+    name: string;
+    readonly $source: string;
+}
+/**
+ * A value was the correct type but fell outside its allowed range or bounds.
+ *
+ * @public
+ */
+export declare class SmithyRangeError extends RangeError {
+    name: string;
+    readonly $source: string;
+}
+/**
+ * @public
+ */
+export type ErrorConstructor<E extends Error = Error> = new (message?: string) => E;
+/**
+ * @public
+ */
+export interface ErrorContainer {
+    readonly $source: string;
+    readonly Error: ErrorConstructor<SmithyError>;
+    readonly TypeError: ErrorConstructor<SmithyTypeError>;
+    readonly RangeError: ErrorConstructor<SmithyRangeError>;
+}
+/**
+ * @public
+ */
+export declare const errors: ErrorContainer;

package/node_modules/@smithy/core/dist-types/submodules/errors/index.d.ts

@@ -0,0 +1 @@
+export { errors, type SmithyError, type SmithyRangeError, type SmithyTypeError } from "./errors";

package/node_modules/@smithy/core/dist-types/submodules/protocols/AbstractRpcV2Protocol.d.ts

@@ -0,0 +1,45 @@
+import type { EndpointBearer, HandlerExecutionContext, HttpRequest as IHttpRequest, OperationSchema, SerdeFunctions } from "@smithy/types";
+import type { TypeRegistry } from "@smithy/core/schema";
+import { RpcProtocol } from "./RpcProtocol";
+/**
+ * Shared abstract base for the Smithy RPC v2 client protocols (JSON and CBOR).
+ *
+ * Factors out the request-framing flow and response status handling that are
+ * identical across both RPC v2 protocols. Concrete protocols supply their
+ * codec, error handling, content type, shape id, and the two per-protocol
+ * request details via {@link getSmithyProtocolHeaderValue} and
+ * {@link applyEmptyBody}.
+ *
+ * @internal
+ */
+export declare abstract class AbstractRpcV2Protocol extends RpcProtocol {
+    /**
+     * @override
+     */
+    protected compositeErrorRegistry: TypeRegistry;
+    constructor({ defaultNamespace, errorTypeRegistries, }: {
+        defaultNamespace: string;
+        errorTypeRegistries?: TypeRegistry[];
+    });
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
+    /**
+     * @override
+     *
+     * Per the Smithy RPC v2 specification, the only successful response status
+     * code is 200; any other status code MUST be handled as an error.
+     */
+    protected isErrorResponse(statusCode: number): boolean;
+    /**
+     * @returns the value of the `smithy-protocol` header for this protocol,
+     * e.g. `rpc-v2-json` or `rpc-v2-cbor`.
+     */
+    protected abstract getSmithyProtocolHeaderValue(): string;
+    /**
+     * Applies this protocol's representation of an empty request body when the
+     * operation has a non-unit input but produced no serialized body. Called
+     * only for non-unit inputs.
+     *
+     * @param request - the request being serialized, mutated in place.
+     */
+    protected abstract applyEmptyBody(request: IHttpRequest): void;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/ConfigurableSerdeContext.d.ts

@@ -0,0 +1,8 @@
+import type { ConfigurableSerdeContext, SerdeFunctions } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare class SerdeContextConfig implements ConfigurableSerdeContext {
+    protected serdeContext?: SerdeFunctions;
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+}

package/node_modules/@smithy/core/dist-types/submodules/protocols/HttpProtocol.d.ts

@@ -1,6 +1,6 @@
 import type { EventStreamSerde } from "@smithy/core/event-streams";
 import { NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
-import type { ClientProtocol, Codec, Endpoint, EndpointBearer, EndpointV2, EventStreamMarshaller, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, Schema, SerdeFunctions, ShapeDeserializer, ShapeSerializer } from "@smithy/types";
+import type { ClientProtocol, Codec, Endpoint, EndpointBearer, EndpointV2, EventStreamMarshaller, HandlerExecutionContext, HttpRequest as IHttpRequest, HttpResponse as IHttpResponse, MetadataBearer, OperationSchema, ResponseMetadata, Schema, SerdeFunctions, ShapeDeserializer, ShapeSerializer, StaticErrorSchema } from "@smithy/types";
 import { SerdeContext } from "./SerdeContext";
 /**
  * Abstract base for HTTP-based client protocols.
@@ -43,6 +43,16 @@ export declare abstract class HttpProtocol extends SerdeContext implements Clien
     protected setHostPrefix<Input extends object>(request: IHttpRequest, operationSchema: OperationSchema, input: Input): void;
     protected abstract handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any, metadata: ResponseMetadata): Promise<never>;
     protected deserializeMetadata(output: IHttpResponse): ResponseMetadata;
+    /**
+     * For a given error short name, a list of preferred namespaces, and a list of preferred registries,
+     * find the error's schema and class.
+     *
+     * @param name - short error shape id.
+     * @param namespaces - must contain '*' to allow matching against an undeclared namespace.
+     * @param registries - in which to look.
+     * @returns matched error schema and constructor, with worst case being the least-descriptive DocumentSchema and native Error.
+     */
+    protected resolveError(name: string, namespaces: string[], registries: TypeRegistry[]): [StaticErrorSchema, any, "modeled" | "synthetic" | "native"];
     /**
      * @param eventStream - the iterable provided by the caller.
      * @param requestSchema - the schema of the event stream container (struct).
@@ -74,12 +84,6 @@ export declare abstract class HttpProtocol extends SerdeContext implements Clien
      * Loads eventStream capability async (for chunking).
      */
     protected loadEventStreamCapability(): Promise<EventStreamSerde>;
-    /**
-     * Returns a platform-specific EventStreamMarshaller.
-     * Prefers user-injected marshaller from serdeContext (via client config),
-     * falls back to the dynamically imported provider.
-     */
-    private resolveEventStreamMarshaller;
     /**
      * @returns content-type default header value for event stream events and other documents.
      */
@@ -92,4 +96,10 @@ export declare abstract class HttpProtocol extends SerdeContext implements Clien
     protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, headerBindings: Set<string>, dataObject: any): Promise<string[]>;
     protected deserializeHttpMessage(schema: Schema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse, dataObject: any): Promise<string[]>;
     protected getEventStreamMarshaller(): EventStreamMarshaller;
+    /**
+     * Returns a platform-specific EventStreamMarshaller.
+     * Prefers user-injected marshaller from serdeContext (via client config),
+     * falls back to the dynamically imported provider.
+     */
+    private resolveEventStreamMarshaller;
 }

package/node_modules/@smithy/core/dist-types/submodules/protocols/RpcProtocol.d.ts

@@ -13,4 +13,16 @@ export declare abstract class RpcProtocol extends HttpProtocol {
     protected compositeErrorRegistry: TypeRegistry;
     serializeRequest<Input extends object>(operationSchema: OperationSchema, _input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<IHttpRequest>;
     deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: IHttpResponse): Promise<Output>;
+    /**
+     * Determines whether a response status code indicates an error response that
+     * should be routed to {@link handleError} rather than deserialized as output.
+     *
+     * The default treats any status code of 300 or greater as an error,
+     * preserving the historical behavior for RPC-over-HTTP protocols. Subclasses
+     * whose specification is stricter SHOULD override this.
+     *
+     * @param statusCode - the HTTP response status code.
+     * @returns true if the response should be handled as an error.
+     */
+    protected isErrorResponse(statusCode: number): boolean;
 }