@cdklabs/cdk-ecs-codedeploy 0.0.460 → 0.0.462

package/node_modules/@smithy/core/dist-es/submodules/cbor/SmithyRpcV2CborProtocol.js

@@ -1,53 +1,28 @@
-import { RpcProtocol } from "@smithy/core/protocols";
-import { NormalizedSchema, TypeRegistry, deref } from "@smithy/core/schema";
-import { getSmithyContext } from "@smithy/core/transport";
+import { AbstractRpcV2Protocol } from "@smithy/core/protocols";
+import { NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
 import { CborCodec } from "./CborCodec";
 import { loadSmithyRpcV2CborErrorCode } from "./parseCborBody";
-export class SmithyRpcV2CborProtocol extends RpcProtocol {
+export class SmithyRpcV2CborProtocol extends AbstractRpcV2Protocol {
     codec = new CborCodec();
     serializer = this.codec.createSerializer();
     deserializer = this.codec.createDeserializer();
-    constructor({ defaultNamespace, errorTypeRegistries, }) {
-        super({ defaultNamespace, errorTypeRegistries });
-    }
     getShapeId() {
         return "smithy.protocols#rpcv2Cbor";
     }
     getPayloadCodec() {
         return this.codec;
     }
-    async serializeRequest(operationSchema, input, context) {
-        const request = await super.serializeRequest(operationSchema, input, context);
-        Object.assign(request.headers, {
-            "content-type": this.getDefaultContentType(),
-            "smithy-protocol": "rpc-v2-cbor",
-            accept: this.getDefaultContentType(),
-        });
-        if (deref(operationSchema.input) === "unit") {
-            delete request.body;
-            delete request.headers["content-type"];
-        }
-        else {
-            if (!request.body) {
-                this.serializer.write(15, {});
-                request.body = this.serializer.flush();
-            }
-            if (request.body instanceof Uint8Array) {
-                request.headers["content-length"] = String(request.body.byteLength);
-            }
-        }
-        const { service, operation } = getSmithyContext(context);
-        const path = `/service/${service}/operation/${operation}`;
-        if (request.path.endsWith("/")) {
-            request.path += path.slice(1);
+    getSmithyProtocolHeaderValue() {
+        return "rpc-v2-cbor";
+    }
+    applyEmptyBody(request) {
+        if (!request.body) {
+            this.serializer.write(15, {});
+            request.body = this.serializer.flush();
         }
-        else {
-            request.path += path;
+        if (request.body instanceof Uint8Array) {
+            request.headers["content-length"] = String(request.body.byteLength);
         }
-        return request;
-    }
-    async deserializeResponse(operationSchema, context, response) {
-        return super.deserializeResponse(operationSchema, context, response);
     }
     async handleError(operationSchema, context, response, dataObject, metadata) {
         const errorIdentifier = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";

package/node_modules/@smithy/core/dist-es/submodules/client/smithy-client/command.js

@@ -1,6 +1,8 @@
 import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
 import { constructStack } from "../middleware-stack/MiddlewareStack";
 import { schemaLogFilter } from "./schemaLogFilter";
+import { NormalizedSchema } from "@smithy/core/schema";
+const operationEventStreamMarker = Symbol.for("@smithy/op-event-stream");
 export class Command {
     middlewareStack = constructStack();
     schema;
@@ -34,9 +36,21 @@ export class Command {
             requestOptions = { ...requestOptions };
             delete requestOptions.metricsRecorder;
         }
-        if (smithyContext.eventStream) {
+        let isEventStream;
+        const schema = this.schema;
+        const marker = schema?.[operationEventStreamMarker];
+        if (marker !== undefined) {
+            isEventStream = marker;
+        }
+        else if (schema) {
+            if (Array.isArray(schema) && schema[0] === 9) {
+                const [, , , , input$, output$] = schema;
+                isEventStream = schema[operationEventStreamMarker] = Boolean(NormalizedSchema.of(input$).getEventStreamMember() || NormalizedSchema.of(output$).getEventStreamMember());
+            }
+        }
+        if (isEventStream) {
             requestOptions = {
-                isEventStream: true,
+                isEventStream,
                 ...requestOptions,
             };
         }

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

@@ -14,6 +14,9 @@ export class HeaderMarshaller {
             if (!hasOwn(headers, headerName))
                 continue;
             const bytes = this.fromUtf8(headerName);
+            if (bytes.byteLength > 255) {
+                throw new Error(`@smithy/core/event-streams - header name exceeds 255 bytes: ${bytes.byteLength}`);
+            }
             chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName]));
         }
         const out = new Uint8Array(chunks.reduce((carry, bytes) => carry + bytes.byteLength, 0));
@@ -46,6 +49,9 @@ export class HeaderMarshaller {
                 longBytes.set(header.value.bytes, 1);
                 return longBytes;
             case "binary":
+                if (header.value.byteLength > MAX_HEADER_VALUE_BYTES) {
+                    throw new Error(`@smithy/core/event-streams - header value (binary) exceeds ${MAX_HEADER_VALUE_BYTES} bytes: ${header.value.byteLength}`);
+                }
                 const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
                 binView.setUint8(0, 6);
                 binView.setUint16(1, header.value.byteLength, false);
@@ -54,6 +60,9 @@ export class HeaderMarshaller {
                 return binBytes;
             case "string":
                 const utf8Bytes = this.fromUtf8(header.value);
+                if (utf8Bytes.byteLength > MAX_HEADER_VALUE_BYTES) {
+                    throw new Error(`@smithy/core/event-streams - header value (string) exceeds ${MAX_HEADER_VALUE_BYTES} bytes: ${utf8Bytes.byteLength}`);
+                }
                 const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
                 strView.setUint8(0, 7);
                 strView.setUint16(1, utf8Bytes.byteLength, false);
@@ -185,3 +194,4 @@ const STRING_TAG = "string";
 const TIMESTAMP_TAG = "timestamp";
 const UUID_TAG = "uuid";
 const UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const MAX_HEADER_VALUE_BYTES = 32767;

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

@@ -0,0 +1,35 @@
+import { deref } from "@smithy/core/schema";
+import { getSmithyContext } from "@smithy/core/transport";
+import { RpcProtocol } from "./RpcProtocol";
+export class AbstractRpcV2Protocol extends RpcProtocol {
+    constructor({ defaultNamespace, errorTypeRegistries, }) {
+        super({ defaultNamespace, errorTypeRegistries });
+    }
+    async serializeRequest(operationSchema, input, context) {
+        const request = await super.serializeRequest(operationSchema, input, context);
+        Object.assign(request.headers, {
+            "content-type": this.getDefaultContentType(),
+            "smithy-protocol": this.getSmithyProtocolHeaderValue(),
+            accept: this.getDefaultContentType(),
+        });
+        if (deref(operationSchema.input) === "unit") {
+            delete request.body;
+            delete request.headers["content-type"];
+        }
+        else {
+            this.applyEmptyBody(request);
+        }
+        const { service, operation } = getSmithyContext(context);
+        const path = `/service/${service}/operation/${operation}`;
+        if (request.path.endsWith("/")) {
+            request.path += path.slice(1);
+        }
+        else {
+            request.path += path;
+        }
+        return request;
+    }
+    isErrorResponse(statusCode) {
+        return statusCode !== 200;
+    }
+}

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

@@ -0,0 +1,6 @@
+export class SerdeContextConfig {
+    serdeContext;
+    setSerdeContext(serdeContext) {
+        this.serdeContext = serdeContext;
+    }
+}

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

@@ -59,7 +59,7 @@ export class RpcProtocol extends HttpProtocol {
         const deserializer = this.deserializer;
         const ns = NormalizedSchema.of(operationSchema.output);
         const dataObject = {};
-        if (response.statusCode >= 300) {
+        if (this.isErrorResponse(response.statusCode)) {
             const bytes = await collectBody(response.body, context);
             if (bytes.byteLength > 0) {
                 Object.assign(dataObject, await deserializer.read(15, bytes));
@@ -91,4 +91,7 @@ export class RpcProtocol extends HttpProtocol {
         dataObject.$metadata = this.deserializeMetadata(response);
         return dataObject;
     }
+    isErrorResponse(statusCode) {
+        return statusCode >= 300;
+    }
 }

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

@@ -0,0 +1,26 @@
+export class UnionSerde {
+    from;
+    to;
+    keys;
+    constructor(from, to) {
+        this.from = from;
+        this.to = to;
+        const keys = Object.keys(this.from);
+        const set = new Set(keys);
+        set.delete("__type");
+        this.keys = set;
+    }
+    mark(key) {
+        this.keys.delete(key);
+    }
+    hasUnknown() {
+        return this.keys.size === 1 && Object.keys(this.to).length === 0;
+    }
+    writeUnknown() {
+        if (this.hasUnknown()) {
+            const k = this.keys.values().next().value;
+            const v = this.from[k];
+            this.to.$unknown = [k, v];
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+import { collectBody } from "./collect-stream-body";
+import { toUtf8 } from "@smithy/core/serde";
+export const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => (context?.utf8Encoder ?? toUtf8)(body));

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

@@ -3,6 +3,7 @@ export { extendedEncodeURIComponent } from "./extended-encode-uri-component";
 export { HttpBindingProtocol } from "./HttpBindingProtocol";
 export { HttpProtocol } from "./HttpProtocol";
 export { RpcProtocol } from "./RpcProtocol";
+export { AbstractRpcV2Protocol } from "./AbstractRpcV2Protocol";
 export { RequestBuilder, requestBuilder } from "./requestBuilder";
 export { resolvedPath } from "./resolve-path";
 export { FromStringShapeDeserializer } from "./serde/FromStringShapeDeserializer";
@@ -23,3 +24,11 @@ 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 { SmithyRpcV2JsonProtocol } from "./json/SmithyRpcV2JsonProtocol";
+export { parseJsonBody, parseJsonErrorBody, loadJsonRpcErrorCode, loadRestJsonErrorCode, loadSmithyRpcV2JsonErrorCode, } from "./json/parseJsonBody";
+export { JsonCodec } from "./json/codec-v1/JsonCodec";
+export { JsonShapeSerializer } from "./json/codec-v1/JsonShapeSerializer";
+export { JsonShapeDeserializer } from "./json/codec-v1/JsonShapeDeserializer";
+export { JsonCodec2 } from "./json/codec-v2/JsonCodec2";
+export { JsonShapeSerializer2 } from "./json/codec-v2/JsonShapeSerializer2";
+export { JsonShapeDeserializer2 } from "./json/codec-v2/JsonShapeDeserializer2";

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

@@ -0,0 +1,79 @@
+import { AbstractRpcV2Protocol } from "../AbstractRpcV2Protocol";
+import { NormalizedSchema, TypeRegistry } from "@smithy/core/schema";
+import { JsonCodec2 } from "./codec-v2/JsonCodec2";
+import { loadSmithyRpcV2JsonErrorCode } from "./parseJsonBody";
+export class SmithyRpcV2JsonProtocol extends AbstractRpcV2Protocol {
+    codec = new JsonCodec2({
+        timestampFormat: {
+            useTrait: false,
+            default: 7,
+        },
+        jsonName: false,
+        bigNumberAsString: true,
+    });
+    serializer = this.codec.createSerializer();
+    deserializer = this.codec.createDeserializer();
+    getShapeId() {
+        return "smithy.protocols#rpcv2Json";
+    }
+    getPayloadCodec() {
+        return this.codec;
+    }
+    getSmithyProtocolHeaderValue() {
+        return "rpc-v2-json";
+    }
+    applyEmptyBody(request) {
+        if (!request.body) {
+            request.body = "{}";
+        }
+    }
+    async handleError(operationSchema, context, response, dataObject, metadata) {
+        const errorName = loadSmithyRpcV2JsonErrorCode(response, dataObject) ?? "Unknown";
+        const errorMetadata = {
+            $metadata: metadata,
+            $fault: response.statusCode <= 500 ? "client" : "server",
+        };
+        let namespace = this.options.defaultNamespace;
+        if (errorName.includes("#")) {
+            [namespace] = errorName.split("#");
+        }
+        const registry = this.compositeErrorRegistry;
+        const nsRegistry = TypeRegistry.for(namespace);
+        registry.copyFrom(nsRegistry);
+        let errorSchema;
+        try {
+            errorSchema = registry.getSchema(errorName);
+        }
+        catch (ignored) {
+            if (dataObject.Message) {
+                dataObject.message = dataObject.Message;
+            }
+            const syntheticRegistry = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+            registry.copyFrom(syntheticRegistry);
+            const baseExceptionSchema = registry.getBaseException();
+            if (baseExceptionSchema) {
+                const ErrorCtor = registry.getErrorCtor(baseExceptionSchema);
+                throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
+            }
+            throw Object.assign(new Error(errorName), errorMetadata, dataObject);
+        }
+        const ns = NormalizedSchema.of(errorSchema);
+        const ErrorCtor = registry.getErrorCtor(errorSchema);
+        const message = dataObject.message ?? dataObject.Message ?? "Unknown";
+        const exception = new ErrorCtor({});
+        const output = {};
+        const errorDeserializer = this.codec.createDeserializer();
+        for (const [name, member] of ns.structIterator()) {
+            if (dataObject[name] != null) {
+                output[name] = errorDeserializer.readObject(member, dataObject[name]);
+            }
+        }
+        throw Object.assign(exception, errorMetadata, {
+            $fault: ns.getMergedTraits().error,
+            message,
+        }, output);
+    }
+    getDefaultContentType() {
+        return "application/json";
+    }
+}

package/node_modules/{@aws-sdk → @smithy}/core/dist-es/submodules/protocols/json/codec-v1/JsonShapeDeserializer.js

@@ -1,7 +1,8 @@
-import { determineTimestampFormat } from "@smithy/core/protocols";
+import { determineTimestampFormat } from "../../serde/determineTimestampFormat";
 import { NormalizedSchema } from "@smithy/core/schema";
 import { LazyJsonString, NumericValue, parseEpochTimestamp, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, } from "@smithy/core/serde";
 import { fromBase64 } from "@smithy/core/serde";
+import { hasOwn } from "@smithy/core/transport";
 import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
 import { UnionSerde } from "../../UnionSerde";
 import { jsonReviver } from "../jsonReviver";
@@ -56,6 +57,8 @@ export class JsonShapeDeserializer extends SerdeContextConfig {
                 }
                 else if (typeof record.__type === "string") {
                     for (const k in record) {
+                        if (!hasOwn(record, k))
+                            continue;
                         const v = record[k];
                         const t = jsonName ? (nameMap[k] ?? k) : k;
                         if (!(t in out)) {
@@ -77,6 +80,8 @@ export class JsonShapeDeserializer extends SerdeContextConfig {
                 const mapMember = ns.getValueSchema();
                 const out = {};
                 for (const _k in value) {
+                    if (!hasOwn(value, _k))
+                        continue;
                     if (_k === "__proto__") {
                         writeKey(out);
                     }
@@ -138,6 +143,8 @@ export class JsonShapeDeserializer extends SerdeContextConfig {
             if (isObject) {
                 const out = Array.isArray(value) ? [] : {};
                 for (const k in value) {
+                    if (!hasOwn(value, k))
+                        continue;
                     if (k === "__proto__") {
                         writeKey(out);
                     }

package/node_modules/{@aws-sdk → @smithy}/core/dist-es/submodules/protocols/json/codec-v1/JsonShapeSerializer.js

@@ -1,9 +1,10 @@
-import { determineTimestampFormat } from "@smithy/core/protocols";
+import { determineTimestampFormat } from "../../serde/determineTimestampFormat";
 import { NormalizedSchema } from "@smithy/core/schema";
 import { dateToUtcString, generateIdempotencyToken, LazyJsonString, NumericValue, toBase64 } from "@smithy/core/serde";
 import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
 import { JsonReplacer } from "../jsonReplacer";
 import { writeKey } from "../../writeKey";
+import { hasOwn } from "@smithy/core/transport";
 export class JsonShapeSerializer extends SerdeContextConfig {
     settings;
     buffer;
@@ -73,6 +74,8 @@ export class JsonShapeSerializer extends SerdeContextConfig {
                 }
                 else if (typeof record.__type === "string") {
                     for (const k in record) {
+                        if (!hasOwn(record, k))
+                            continue;
                         const v = record[k];
                         const targetKey = jsonName ? (nameMap[k] ?? k) : k;
                         if (!(targetKey in out)) {
@@ -98,6 +101,8 @@ export class JsonShapeSerializer extends SerdeContextConfig {
                 const out = {};
                 const sparse = !!ns.getMergedTraits().sparse;
                 for (const _k in value) {
+                    if (!hasOwn(value, _k))
+                        continue;
                     const _v = value[_k];
                     if (sparse || _v != null) {
                         if (_k === "__proto__") {
@@ -170,6 +175,8 @@ export class JsonShapeSerializer extends SerdeContextConfig {
                 }
                 const out = Array.isArray(value) ? [] : {};
                 for (const k in value) {
+                    if (!hasOwn(value, k))
+                        continue;
                     const v = value[k];
                     if (k === "__proto__") {
                         writeKey(out);

package/node_modules/{@aws-sdk → @smithy}/core/dist-es/submodules/protocols/json/codec-v2/JsonShapeDeserializer2.js

@@ -1,4 +1,4 @@
-import { determineTimestampFormat } from "@smithy/core/protocols";
+import { determineTimestampFormat } from "../../serde/determineTimestampFormat";
 import { NormalizedSchema } from "@smithy/core/schema";
 import { fromBase64, LazyJsonString, NumericValue, parseEpochTimestamp, parseRfc3339DateTimeWithOffset, parseRfc7231DateTime, } from "@smithy/core/serde";
 import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
@@ -8,6 +8,7 @@ import { jsonReviver } from "../jsonReviver";
 import { needsReviver } from "../needsReviver";
 import { parseJsonBody } from "../parseJsonBody";
 import { writeKey } from "../../writeKey";
+import { hasOwn } from "@smithy/core/transport";
 export class JsonShapeDeserializer2 extends SerdeContextConfig {
     settings;
     constructor(settings) {
@@ -59,6 +60,8 @@ export class JsonShapeDeserializer2 extends SerdeContextConfig {
                 const map = value;
                 if (this.needsTransform(mapMember)) {
                     for (const k in map) {
+                        if (!hasOwn(map, k))
+                            continue;
                         if (k === "__proto__") {
                             writeKey(map);
                         }
@@ -130,6 +133,8 @@ export class JsonShapeDeserializer2 extends SerdeContextConfig {
                 else {
                     const doc = value;
                     for (const k in doc) {
+                        if (!hasOwn(doc, k))
+                            continue;
                         if (k === "__proto__") {
                             writeKey(doc);
                         }
@@ -176,6 +181,8 @@ export class JsonShapeDeserializer2 extends SerdeContextConfig {
         }
         else if (hasType) {
             for (const k in record) {
+                if (!hasOwn(record, k))
+                    continue;
                 const v = record[k];
                 const t = jsonName ? (nameMap[k] ?? k) : k;
                 if (!(t in out)) {
@@ -186,7 +193,11 @@ export class JsonShapeDeserializer2 extends SerdeContextConfig {
         return out;
     }
     needsTransform(ns) {
-        if (ns.isBlobSchema() || ns.isTimestampSchema() || ns.isBigIntegerSchema() || ns.isBigDecimalSchema()) {
+        if (ns.isBlobSchema() ||
+            ns.isTimestampSchema() ||
+            ns.isBigIntegerSchema() ||
+            ns.isBigDecimalSchema() ||
+            ns.isNumericSchema()) {
             return true;
         }
         if (ns.isDocumentSchema() || ns.isStructSchema() || ns.isListSchema() || ns.isMapSchema()) {

package/node_modules/{@aws-sdk → @smithy}/core/dist-es/submodules/protocols/json/codec-v2/JsonShapeSerializer2.js

@@ -1,7 +1,8 @@
-import { determineTimestampFormat } from "@smithy/core/protocols";
+import { determineTimestampFormat } from "../../serde/determineTimestampFormat";
 import { NormalizedSchema } from "@smithy/core/schema";
 import { dateToUtcString, generateIdempotencyToken, LazyJsonString, NumericValue, toBase64 } from "@smithy/core/serde";
 import { SerdeContextConfig } from "../../ConfigurableSerdeContext";
+import { hasOwn } from "@smithy/core/transport";
 import { JsonBytesStringAdapter } from "./JsonBytesStringAdapter";
 const encoder = new TextEncoder();
 const OPEN_BRACE = 0x7b;
@@ -117,9 +118,9 @@ export class JsonShapeSerializer2 extends SerdeContextConfig {
         this.i = i;
     }
     writeJsonString(s) {
-        this.ensure(s.length * 3 + 2);
-        this.json[this.i++] = QUOTE;
         const z = s.length;
+        this.ensure(z * 3 + 2);
+        this.json[this.i++] = QUOTE;
         for (let j = 0; j < z; ++j) {
             const c = s.charCodeAt(j);
             if (c > 0x22 && c < 0x5c) {
@@ -128,7 +129,7 @@ export class JsonShapeSerializer2 extends SerdeContextConfig {
             else if (c < 0x80) {
                 const esc = ESCAPE_TABLE[c];
                 if (esc !== null) {
-                    this.ensure(esc.length + 1);
+                    this.ensure(esc.length + 1 + (z - j - 1) * 3 + 1);
                     this.json[this.i++] = BACKSLASH;
                     for (let k = 0; k < esc.length; k++) {
                         this.json[this.i++] = esc.charCodeAt(k);
@@ -147,12 +148,12 @@ export class JsonShapeSerializer2 extends SerdeContextConfig {
                     ++j;
                 }
                 else {
-                    this.ensure(6);
+                    this.ensure(6 + (z - j - 1) * 3 + 1);
                     this.writeUnicodeEscape(c);
                 }
             }
             else if (c >= 0xdc00 && c <= 0xdfff) {
-                this.ensure(6);
+                this.ensure(6 + (z - j - 1) * 3 + 1);
                 this.writeUnicodeEscape(c);
             }
             else {
@@ -255,6 +256,11 @@ export class JsonShapeSerializer2 extends SerdeContextConfig {
                 }
             }
         }
+        if (this.settings.bigNumberAsString && value != null && (ns.isBigIntegerSchema() || ns.isBigDecimalSchema())) {
+            const asString = value instanceof NumericValue ? value.string : String(value);
+            this.writeAsciiQuoted(asString);
+            return;
+        }
         if (isObject) {
             if (ns.isStructSchema()) {
                 this.writeStruct(ns, value);
@@ -452,6 +458,8 @@ export class JsonShapeSerializer2 extends SerdeContextConfig {
             if (valueSchema.isStringSchema() || valueSchema.isNumericSchema() || valueSchema.isBooleanSchema()) {
                 let modifications;
                 for (const k in value) {
+                    if (!hasOwn(value, k))
+                        continue;
                     const v = value[k];
                     if (Number.isNaN(v) || v === Infinity || v === -Infinity) {
                         (modifications ??= {})[k] = v;
@@ -475,6 +483,8 @@ export class JsonShapeSerializer2 extends SerdeContextConfig {
         this.json[this.i++] = OPEN_BRACE;
         let first = true;
         for (const k in value) {
+            if (!hasOwn(value, k))
+                continue;
             const v = value[k];
             if (isDocument ? v === undefined : v == null && !sparse) {
                 continue;

package/node_modules/{@aws-sdk → @smithy}/core/dist-es/submodules/protocols/json/parseJsonBody.js

@@ -1,4 +1,4 @@
-import { collectBody } from "@smithy/core/protocols";
+import { collectBody } from "../collect-stream-body";
 import { collectBodyString } from "../common";
 import { detectBufferParsing } from "./detectBufferParsing";
 import { jsonReviver } from "./jsonReviver";
@@ -63,6 +63,21 @@ export const loadRestJsonErrorCode = (output, data) => {
 export const loadJsonRpcErrorCode = (output, data, queryCompat = false) => {
     return loadErrorCode(output, data, queryCompat ? ["code", "header", "type"] : ["type", "code", "header"]);
 };
+export const loadSmithyRpcV2JsonErrorCode = (output, data) => {
+    if (data?.__type !== undefined) {
+        let cleanValue = data.__type;
+        if (typeof cleanValue === "number") {
+            cleanValue = cleanValue.toString();
+        }
+        if (cleanValue.indexOf(",") >= 0) {
+            cleanValue = cleanValue.split(",")[0];
+        }
+        if (cleanValue.indexOf(":") >= 0) {
+            cleanValue = cleanValue.split(":")[0];
+        }
+        return cleanValue;
+    }
+};
 const loadErrorCode = ({ headers }, data, order) => {
     while (order.length > 0) {
         const location = order.shift();

package/node_modules/@smithy/core/dist-es/submodules/protocols/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-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/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;
+}