@senpiper/sp-agent 0.1.6 → 0.1.7

package/node_modules/@smithy/core/dist-cjs/submodules/cbor/index.js

@@ -1,7 +1,9 @@
-const { nv, NumericValue, calculateBodyLength, generateIdempotencyToken, fromBase64, _parseEpochTimestamp } = require("@smithy/core/serde");
-const { hasOwn, getSmithyContext } = require("@smithy/core/transport");
-const { HttpRequest, collectBody, SerdeContext, RpcProtocol } = require("@smithy/core/protocols");
-const { NormalizedSchema, deref, TypeRegistry } = require("@smithy/core/schema");
+'use strict';
+
+var serde = require('@smithy/core/serde');
+var protocols = require('@smithy/core/protocols');
+var client = require('@smithy/core/client');
+var schema = require('@smithy/core/schema');
 
 const majorUint64 = 0;
 const majorNegativeInt64 = 1;
@@ -29,30 +31,26 @@ function tag(data) {
     return data;
 }
 
-const USE_BUFFER$3 = typeof Buffer !== "undefined";
-const textDecoder$1 = new TextDecoder();
-let payload$1 = alloc(0);
-let isBuffer$1 = false;
-let dataView$2 = new DataView(payload$1.buffer, payload$1.byteOffset, payload$1.byteLength);
+const USE_TEXT_DECODER = typeof TextDecoder !== "undefined";
+const USE_BUFFER$1 = typeof Buffer !== "undefined";
+let payload = alloc(0);
+let dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+const textDecoder = USE_TEXT_DECODER ? new TextDecoder() : null;
 let _offset = 0;
 function setPayload(bytes) {
-    payload$1 = bytes;
-    isBuffer$1 = USE_BUFFER$3 && payload$1 instanceof Buffer;
-    dataView$2 = new DataView(payload$1.buffer, payload$1.byteOffset, payload$1.byteLength);
+    payload = bytes;
+    dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
 }
 function decode(at, to) {
     if (at >= to) {
         throw new Error("unexpected end of (decode) payload.");
     }
-    const major = (payload$1[at] & 0b1110_0000) >> 5;
-    const minor = payload$1[at] & 0b0001_1111;
-    if (minor === minorIndefinite && 2 <= major && major <= 5) {
-        return decodeIndefinite(at, to);
-    }
+    const major = (payload[at] & 0b1110_0000) >> 5;
+    const minor = payload[at] & 0b0001_1111;
     switch (major) {
         case majorUint64:
         case majorNegativeInt64:
-        case majorTag: {
+        case majorTag:
             let unsignedInt;
             let offset;
             if (minor < 24) {
@@ -62,48 +60,36 @@ function decode(at, to) {
             else {
                 switch (minor) {
                     case extendedOneByte:
-                        if (to - at < 2) {
-                            overflow$1(1);
-                        }
-                        unsignedInt = payload$1[at + 1];
-                        offset = 2;
-                        break;
                     case extendedFloat16:
-                        if (to - at < 3) {
-                            overflow$1(2);
-                        }
-                        unsignedInt = dataView$2.getUint16(at + 1);
-                        offset = 3;
-                        break;
                     case extendedFloat32:
-                        if (to - at < 5) {
-                            overflow$1(4);
-                        }
-                        unsignedInt = dataView$2.getUint32(at + 1);
-                        offset = 5;
-                        break;
                     case extendedFloat64:
-                        if (to - at < 9) {
-                            overflow$1(8);
+                        const countLength = minorValueToArgumentLength[minor];
+                        const countOffset = (countLength + 1);
+                        offset = countOffset;
+                        if (to - at < countOffset) {
+                            throw new Error(`countLength ${countLength} greater than remaining buf len.`);
+                        }
+                        const countIndex = at + 1;
+                        if (countLength === 1) {
+                            unsignedInt = payload[countIndex];
+                        }
+                        else if (countLength === 2) {
+                            unsignedInt = dataView$1.getUint16(countIndex);
                         }
-                        {
-                            const hi = dataView$2.getUint32(at + 1);
-                            if (hi < 0x00200000) {
-                                unsignedInt = hi * 4294967296 + dataView$2.getUint32(at + 5);
-                            }
-                            else {
-                                unsignedInt = dataView$2.getBigUint64(at + 1);
-                            }
+                        else if (countLength === 4) {
+                            unsignedInt = dataView$1.getUint32(countIndex);
+                        }
+                        else {
+                            unsignedInt = dataView$1.getBigUint64(countIndex);
                         }
-                        offset = 9;
                         break;
                     default:
-                        unexpectedMinor(minor);
+                        throw new Error(`unexpected minor value ${minor}.`);
                 }
             }
             if (major === majorUint64) {
                 _offset = offset;
-                return castBigInt$1(unsignedInt);
+                return castBigInt(unsignedInt);
             }
             else if (major === majorNegativeInt64) {
                 let negativeInt;
@@ -114,236 +100,317 @@ function decode(at, to) {
                     negativeInt = -1 - unsignedInt;
                 }
                 _offset = offset;
-                return castBigInt$1(negativeInt);
+                return castBigInt(negativeInt);
             }
             else {
-                return decodeTagValue(at, to, minor, unsignedInt, offset);
+                if (minor === 2 || minor === 3) {
+                    const length = decodeCount(at + offset, to);
+                    let b = BigInt(0);
+                    const start = at + offset + _offset;
+                    for (let i = start; i < start + length; ++i) {
+                        b = (b << BigInt(8)) | BigInt(payload[i]);
+                    }
+                    _offset = offset + _offset + length;
+                    return minor === 3 ? -b - BigInt(1) : b;
+                }
+                else if (minor === 4) {
+                    const decimalFraction = decode(at + offset, to);
+                    const [exponent, mantissa] = decimalFraction;
+                    const normalizer = mantissa < 0 ? -1 : 1;
+                    const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + String(BigInt(normalizer) * BigInt(mantissa));
+                    let numericString;
+                    const sign = mantissa < 0 ? "-" : "";
+                    numericString =
+                        exponent === 0
+                            ? mantissaStr
+                            : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
+                    numericString = numericString.replace(/^0+/g, "");
+                    if (numericString === "") {
+                        numericString = "0";
+                    }
+                    if (numericString[0] === ".") {
+                        numericString = "0" + numericString;
+                    }
+                    numericString = sign + numericString;
+                    _offset = offset + _offset;
+                    return serde.nv(numericString);
+                }
+                else {
+                    const value = decode(at + offset, to);
+                    const valueOffset = _offset;
+                    _offset = offset + valueOffset;
+                    return tag({ tag: castBigInt(unsignedInt), value });
+                }
             }
-        }
         case majorUtf8String:
-            return decodeUtf8String(at, to);
         case majorMap:
-            return decodeMap(at, to);
         case majorList:
-            return decodeList(at, to);
         case majorUnstructuredByteString:
-            return decodeUnstructuredByteString(at, to);
+            if (minor === minorIndefinite) {
+                switch (major) {
+                    case majorUtf8String:
+                        return decodeUtf8StringIndefinite(at, to);
+                    case majorMap:
+                        return decodeMapIndefinite(at, to);
+                    case majorList:
+                        return decodeListIndefinite(at, to);
+                    case majorUnstructuredByteString:
+                        return decodeUnstructuredByteStringIndefinite(at, to);
+                }
+            }
+            else {
+                switch (major) {
+                    case majorUtf8String:
+                        return decodeUtf8String(at, to);
+                    case majorMap:
+                        return decodeMap(at, to);
+                    case majorList:
+                        return decodeList(at, to);
+                    case majorUnstructuredByteString:
+                        return decodeUnstructuredByteString(at, to);
+                }
+            }
         default:
             return decodeSpecial(at, to);
     }
 }
-function decodeIndefinite(at, to) {
-    const major = (payload$1[at] & 0b1110_0000) >> 5;
-    const minor = payload$1[at] & 0b0001_1111;
-    if (minor === minorIndefinite) {
-        switch (major) {
-            case majorUtf8String:
-                return decodeUtf8StringIndefinite(at, to);
-            case majorMap:
-                return decodeMapIndefinite(at, to);
-            case majorList:
-                return decodeListIndefinite(at, to);
-            case majorUnstructuredByteString:
-                return decodeUnstructuredByteStringIndefinite(at, to);
-        }
+function bytesToUtf8(bytes, at, to) {
+    if (USE_BUFFER$1 && bytes.constructor?.name === "Buffer") {
+        return bytes.toString("utf-8", at, to);
+    }
+    if (textDecoder) {
+        return textDecoder.decode(bytes.subarray(at, to));
+    }
+    return serde.toUtf8(bytes.subarray(at, to));
+}
+function demote(bigInteger) {
+    const num = Number(bigInteger);
+    if (num < Number.MIN_SAFE_INTEGER || Number.MAX_SAFE_INTEGER < num) {
+        console.warn(new Error(`@smithy/core/cbor - truncating BigInt(${bigInteger}) to ${num} with loss of precision.`));
     }
+    return num;
 }
-function bytesToFloat16$1(a, b) {
+const minorValueToArgumentLength = {
+    [extendedOneByte]: 1,
+    [extendedFloat16]: 2,
+    [extendedFloat32]: 4,
+    [extendedFloat64]: 8,
+};
+function bytesToFloat16(a, b) {
     const sign = a >> 7;
     const exponent = (a & 0b0111_1100) >> 2;
     const fraction = ((a & 0b0000_0011) << 8) | b;
     const scalar = sign === 0 ? 1 : -1;
+    let exponentComponent;
+    let summation;
     if (exponent === 0b00000) {
-        if (fraction === 0) {
+        if (fraction === 0b00000_00000) {
             return 0;
         }
-        return scalar * (Math.pow(2, 1 - 15) * (fraction / 1024));
+        else {
+            exponentComponent = Math.pow(2, 1 - 15);
+            summation = 0;
+        }
     }
     else if (exponent === 0b11111) {
-        if (fraction === 0) {
+        if (fraction === 0b00000_00000) {
             return scalar * Infinity;
         }
-        return NaN;
+        else {
+            return NaN;
+        }
+    }
+    else {
+        exponentComponent = Math.pow(2, exponent - 15);
+        summation = 1;
     }
-    return scalar * (Math.pow(2, exponent - 15) * (1 + fraction / 1024));
+    summation += fraction / 1024;
+    return scalar * (exponentComponent * summation);
 }
-function decodeMap(at, to) {
-    const mapDataLength = decodeCount$1(at, to);
-    if (mapDataLength < 25) {
-        return decodeMapSmall(at, to, mapDataLength);
+function decodeCount(at, to) {
+    const minor = payload[at] & 0b0001_1111;
+    if (minor < 24) {
+        _offset = 1;
+        return minor;
+    }
+    if (minor === extendedOneByte ||
+        minor === extendedFloat16 ||
+        minor === extendedFloat32 ||
+        minor === extendedFloat64) {
+        const countLength = minorValueToArgumentLength[minor];
+        _offset = (countLength + 1);
+        if (to - at < _offset) {
+            throw new Error(`countLength ${countLength} greater than remaining buf len.`);
+        }
+        const countIndex = at + 1;
+        if (countLength === 1) {
+            return payload[countIndex];
+        }
+        else if (countLength === 2) {
+            return dataView$1.getUint16(countIndex);
+        }
+        else if (countLength === 4) {
+            return dataView$1.getUint32(countIndex);
+        }
+        return demote(dataView$1.getBigUint64(countIndex));
     }
-    return decodeMapLarge(at, to, mapDataLength);
+    throw new Error(`unexpected minor value ${minor}.`);
 }
-function decodeMapLarge(at, to, mapDataLength) {
+function decodeUtf8String(at, to) {
+    const length = decodeCount(at, to);
     const offset = _offset;
     at += offset;
-    const base = at;
-    const map = Object.create(null);
-    for (let i = 0; i < mapDataLength; ++i) {
-        const key = decodeUtf8String(at, to);
-        at += _offset;
-        const valMajor = (payload$1[at] & 0b1110_0000) >> 5;
-        if (valMajor === majorUtf8String) {
-            map[key] = decodeUtf8String(at, to);
+    if (to - at < length) {
+        throw new Error(`string len ${length} greater than remaining buf len.`);
+    }
+    const value = bytesToUtf8(payload, at, at + length);
+    _offset = offset + length;
+    return value;
+}
+function decodeUtf8StringIndefinite(at, to) {
+    at += 1;
+    const vector = [];
+    for (const base = at; at < to;) {
+        if (payload[at] === 0b1111_1111) {
+            const data = alloc(vector.length);
+            data.set(vector, 0);
+            _offset = at - base + 2;
+            return bytesToUtf8(data, 0, data.length);
         }
-        else {
-            map[key] = decode(at, to);
+        const major = (payload[at] & 0b1110_0000) >> 5;
+        const minor = payload[at] & 0b0001_1111;
+        if (major !== majorUtf8String) {
+            throw new Error(`unexpected major type ${major} in indefinite string.`);
+        }
+        if (minor === minorIndefinite) {
+            throw new Error("nested indefinite string.");
+        }
+        const bytes = decodeUnstructuredByteString(at, to);
+        const length = _offset;
+        at += length;
+        for (let i = 0; i < bytes.length; ++i) {
+            vector.push(bytes[i]);
         }
-        at += _offset;
     }
-    _offset = offset + (at - base);
-    Object.setPrototypeOf(map, Object.prototype);
-    return map;
+    throw new Error("expected break marker.");
 }
-function decodeMapSmall(at, to, mapDataLength) {
+function decodeUnstructuredByteString(at, to) {
+    const length = decodeCount(at, to);
     const offset = _offset;
     at += offset;
-    const base = at;
-    const map = {};
-    for (let i = 0; i < mapDataLength; ++i) {
-        const key = decodeUtf8String(at, to);
-        at += _offset;
-        map[key] = decode(at, to);
-        at += _offset;
+    if (to - at < length) {
+        throw new Error(`unstructured byte string len ${length} greater than remaining buf len.`);
     }
-    _offset = offset + (at - base);
-    return map;
+    const value = payload.subarray(at, at + length);
+    _offset = offset + length;
+    return value;
+}
+function decodeUnstructuredByteStringIndefinite(at, to) {
+    at += 1;
+    const vector = [];
+    for (const base = at; at < to;) {
+        if (payload[at] === 0b1111_1111) {
+            const data = alloc(vector.length);
+            data.set(vector, 0);
+            _offset = at - base + 2;
+            return data;
+        }
+        const major = (payload[at] & 0b1110_0000) >> 5;
+        const minor = payload[at] & 0b0001_1111;
+        if (major !== majorUnstructuredByteString) {
+            throw new Error(`unexpected major type ${major} in indefinite string.`);
+        }
+        if (minor === minorIndefinite) {
+            throw new Error("nested indefinite string.");
+        }
+        const bytes = decodeUnstructuredByteString(at, to);
+        const length = _offset;
+        at += length;
+        for (let i = 0; i < bytes.length; ++i) {
+            vector.push(bytes[i]);
+        }
+    }
+    throw new Error("expected break marker.");
 }
 function decodeList(at, to) {
-    const listDataLength = decodeCount$1(at, to);
+    const listDataLength = decodeCount(at, to);
     const offset = _offset;
     at += offset;
     const base = at;
     const list = Array(listDataLength);
     for (let i = 0; i < listDataLength; ++i) {
-        list[i] = decode(at, to);
-        at += _offset;
+        const item = decode(at, to);
+        const itemOffset = _offset;
+        list[i] = item;
+        at += itemOffset;
     }
     _offset = offset + (at - base);
     return list;
 }
-function decodeUtf8String(at, to) {
-    const length = decodeCount$1(at, to);
-    const offset = _offset;
-    at += offset;
-    if (to - at < length) {
-        overflow$1(length);
-    }
-    _offset = offset + length;
-    if (length < 24) {
-        return decodeUtf8StringCached(at, length);
-    }
-    if (isBuffer$1) {
-        return payload$1.toString("utf-8", at, at + length);
-    }
-    return textDecoder$1.decode(payload$1.subarray(at, at + length));
-}
-const stringCache$1 = new Array(2048);
-const stringCacheEpochs$1 = new Uint16Array(2048);
-let cacheEpoch$1 = 0;
-function advanceDecodingEpoch() {
-    cacheEpoch$1 = (cacheEpoch$1 + 1) & 0b1111_1111_1111_1111;
-}
-function decodeUtf8StringCached(at, length) {
-    let h = length;
-    for (let i = 0; i < length; ++i) {
-        h = (h * 31 + payload$1[at + i]) | 0;
-    }
-    const slot = (h >>> 0) & 2047;
-    const cached = stringCache$1[slot];
-    if (cached !== undefined) {
-        if (cached.length === length) {
-            let match = true;
-            for (let i = 0; i < length; ++i) {
-                if (cached.charCodeAt(i) !== payload$1[at + i]) {
-                    match = false;
-                    break;
-                }
-            }
-            if (match) {
-                stringCacheEpochs$1[slot] = cacheEpoch$1;
-                return cached;
-            }
+function decodeListIndefinite(at, to) {
+    at += 1;
+    const list = [];
+    for (const base = at; at < to;) {
+        if (payload[at] === 0b1111_1111) {
+            _offset = at - base + 2;
+            return list;
         }
+        const item = decode(at, to);
+        const n = _offset;
+        at += n;
+        list.push(item);
     }
-    const result = isBuffer$1
-        ? payload$1.toString("utf-8", at, at + length)
-        : textDecoder$1.decode(payload$1.subarray(at, at + length));
-    if (stringCacheEpochs$1[slot] !== cacheEpoch$1) {
-        stringCache$1[slot] = result;
-        stringCacheEpochs$1[slot] = cacheEpoch$1;
-    }
-    return result;
+    throw new Error("expected break marker.");
 }
-function decodeUnstructuredByteString(at, to) {
-    const length = decodeCount$1(at, to);
+function decodeMap(at, to) {
+    const mapDataLength = decodeCount(at, to);
     const offset = _offset;
     at += offset;
-    if (to - at < length) {
-        overflow$1(length);
+    const base = at;
+    const map = {};
+    for (let i = 0; i < mapDataLength; ++i) {
+        if (at >= to) {
+            throw new Error("unexpected end of map payload.");
+        }
+        const major = (payload[at] & 0b1110_0000) >> 5;
+        if (major !== majorUtf8String) {
+            throw new Error(`unexpected major type ${major} for map key at index ${at}.`);
+        }
+        const key = decode(at, to);
+        at += _offset;
+        const value = decode(at, to);
+        at += _offset;
+        map[key] = value;
     }
-    const value = payload$1.subarray(at, at + length);
-    _offset = offset + length;
-    return value;
+    _offset = offset + (at - base);
+    return map;
 }
-function decodeTagValue(at, to, minor, unsignedInt, offset) {
-    if (minor === 2 || minor === 3) {
-        const length = decodeCount$1(at + offset, to);
-        let b = BigInt(0);
-        const start = at + offset + _offset;
-        for (let i = start; i < start + length; ++i) {
-            b = (b << BigInt(8)) | BigInt(payload$1[i]);
+function decodeMapIndefinite(at, to) {
+    at += 1;
+    const base = at;
+    const map = {};
+    for (; at < to;) {
+        if (at >= to) {
+            throw new Error("unexpected end of map payload.");
         }
-        _offset = offset + _offset + length;
-        return minor === 3 ? -b - BigInt(1) : b;
-    }
-    else if (minor === 4) {
-        const decimalFraction = decode(at + offset, to);
-        const [rawExponent, mantissa] = decimalFraction;
-        const normalizer = mantissa < 0 ? -1 : 1;
-        const absMantissa = BigInt(normalizer) * BigInt(mantissa);
-        const mantissaDigits = String(absMantissa);
-        const sign = mantissa < 0 ? "-" : "";
-        let numericString;
-        const isSmallExponent = typeof rawExponent === "number" && Math.abs(rawExponent) <= 2 ** 28;
-        if (isSmallExponent) {
-            const exponent = rawExponent;
-            const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + mantissaDigits;
-            numericString =
-                exponent === 0
-                    ? mantissaStr
-                    : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
-            numericString = numericString.replace(/^0+/g, "");
-            if (numericString === "") {
-                numericString = "0";
-            }
-            if (numericString[0] === ".") {
-                numericString = "0" + numericString;
-            }
-            numericString = sign + numericString;
+        if (payload[at] === 0b1111_1111) {
+            _offset = at - base + 2;
+            return map;
         }
-        else {
-            const bigExponent = BigInt(rawExponent);
-            if (mantissaDigits.length === 1) {
-                numericString = sign + mantissaDigits + "e" + String(bigExponent);
-            }
-            else {
-                const adjustedExp = bigExponent + BigInt(mantissaDigits.length - 1);
-                numericString = sign + mantissaDigits[0] + "." + mantissaDigits.slice(1) + "e" + String(adjustedExp);
-            }
+        const major = (payload[at] & 0b1110_0000) >> 5;
+        if (major !== majorUtf8String) {
+            throw new Error(`unexpected major type ${major} for map key.`);
         }
-        _offset = offset + _offset;
-        return nv(numericString);
-    }
-    else {
-        const value = decode(at + offset, to);
-        const valueOffset = _offset;
-        _offset = offset + valueOffset;
-        return tag({ tag: castBigInt$1(unsignedInt), value });
+        const key = decode(at, to);
+        at += _offset;
+        const value = decode(at, to);
+        at += _offset;
+        map[key] = value;
     }
+    throw new Error("expected break marker.");
 }
 function decodeSpecial(at, to) {
-    const minor = payload$1[at] & 0b0001_1111;
+    const minor = payload[at] & 0b0001_1111;
     switch (minor) {
         case specialTrue:
         case specialFalse:
@@ -360,280 +427,171 @@ function decodeSpecial(at, to) {
                 throw new Error("incomplete float16 at end of buf.");
             }
             _offset = 3;
-            return bytesToFloat16$1(payload$1[at + 1], payload$1[at + 2]);
+            return bytesToFloat16(payload[at + 1], payload[at + 2]);
         case extendedFloat32:
             if (to - at < 5) {
                 throw new Error("incomplete float32 at end of buf.");
             }
             _offset = 5;
-            return dataView$2.getFloat32(at + 1);
+            return dataView$1.getFloat32(at + 1);
         case extendedFloat64:
             if (to - at < 9) {
                 throw new Error("incomplete float64 at end of buf.");
             }
             _offset = 9;
-            return dataView$2.getFloat64(at + 1);
+            return dataView$1.getFloat64(at + 1);
         default:
-            unexpectedMinor(minor);
+            throw new Error(`unexpected minor value ${minor}.`);
     }
 }
-function decodeCount$1(at, to) {
-    const minor = payload$1[at] & 0b0001_1111;
-    if (minor < 24) {
-        _offset = 1;
-        return minor;
+function castBigInt(bigInt) {
+    if (typeof bigInt === "number") {
+        return bigInt;
     }
-    switch (minor) {
-        case extendedOneByte:
-            if (to - at < 2) {
-                overflow$1(1);
-            }
-            _offset = 2;
-            return payload$1[at + 1];
-        case extendedFloat16:
-            if (to - at < 3) {
-                overflow$1(2);
-            }
-            _offset = 3;
-            return dataView$2.getUint16(at + 1);
-        case extendedFloat32:
-            if (to - at < 5) {
-                overflow$1(4);
-            }
-            _offset = 5;
-            return dataView$2.getUint32(at + 1);
-        case extendedFloat64:
-            if (to - at < 9) {
-                overflow$1(8);
-            }
-            _offset = 9;
-            return demote(dataView$2.getBigUint64(at + 1));
-        default:
-            unexpectedMinor(minor);
+    const num = Number(bigInt);
+    if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
+        return num;
     }
+    return bigInt;
 }
-function decodeMapIndefinite(at, to) {
-    at += 1;
-    const base = at;
-    const map = {};
-    for (; at < to;) {
-        if (payload$1[at] === 0b1111_1111) {
-            _offset = at - base + 2;
-            return map;
+
+const USE_BUFFER = typeof Buffer !== "undefined";
+const initialSize = 2048;
+let data = alloc(initialSize);
+let dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+let cursor = 0;
+function ensureSpace(bytes) {
+    const remaining = data.byteLength - cursor;
+    if (remaining < bytes) {
+        if (cursor < 16_000_000) {
+            resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
         }
-        const key = decodeUtf8String(at, to);
-        at += _offset;
-        map[key] = decode(at, to);
-        at += _offset;
-    }
-    throw new Error("expected break marker.");
-}
-function decodeListIndefinite(at, to) {
-    at += 1;
-    const list = [];
-    for (const base = at; at < to;) {
-        if (payload$1[at] === 0b1111_1111) {
-            _offset = at - base + 2;
-            return list;
+        else {
+            resize(data.byteLength + bytes + 16_000_000);
         }
-        list.push(decode(at, to));
-        at += _offset;
     }
-    throw new Error("expected break marker.");
 }
-function decodeUtf8StringIndefinite(at, to) {
-    at += 1;
-    const vector = [];
-    for (const base = at; at < to;) {
-        if (payload$1[at] === 0b1111_1111) {
-            const data = alloc(vector.length);
-            data.set(vector, 0);
-            _offset = at - base + 2;
-            if (USE_BUFFER$3) {
-                return data.toString("utf-8", 0, data.length);
-            }
-            return textDecoder$1.decode(data);
-        }
-        const major = (payload$1[at] & 0b1110_0000) >> 5;
-        const minor = payload$1[at] & 0b0001_1111;
-        if (major !== majorUtf8String) {
-            unexpectedMajorInIndefiniteString(major);
+function toUint8Array() {
+    const out = alloc(cursor);
+    out.set(data.subarray(0, cursor), 0);
+    cursor = 0;
+    return out;
+}
+function resize(size) {
+    const old = data;
+    data = alloc(size);
+    if (old) {
+        if (old.copy) {
+            old.copy(data, 0, 0, old.byteLength);
         }
-        if (minor === minorIndefinite) {
-            throw new Error("nested indefinite string.");
-        }
-        const bytes = decodeUnstructuredByteString(at, to);
-        const length = _offset;
-        at += length;
-        for (let i = 0; i < bytes.length; ++i) {
-            vector.push(bytes[i]);
+        else {
+            data.set(old, 0);
         }
     }
-    throw new Error("expected break marker.");
+    dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
 }
-function decodeUnstructuredByteStringIndefinite(at, to) {
-    at += 1;
-    const vector = [];
-    for (const base = at; at < to;) {
-        if (payload$1[at] === 0b1111_1111) {
-            const data = alloc(vector.length);
-            data.set(vector, 0);
-            _offset = at - base + 2;
-            return data;
-        }
-        const major = (payload$1[at] & 0b1110_0000) >> 5;
-        const minor = payload$1[at] & 0b0001_1111;
-        if (major !== majorUnstructuredByteString) {
-            unexpectedMajorInIndefiniteString(major);
-        }
-        if (minor === minorIndefinite) {
-            throw new Error("nested indefinite string.");
-        }
-        const bytes = decodeUnstructuredByteString(at, to);
-        const length = _offset;
-        at += length;
-        for (let i = 0; i < bytes.length; ++i) {
-            vector.push(bytes[i]);
-        }
+function encodeHeader(major, value) {
+    if (value < 24) {
+        data[cursor++] = (major << 5) | value;
     }
-    throw new Error("expected break marker.");
-}
-function castBigInt$1(bigInt) {
-    if (typeof bigInt === "number") {
-        return bigInt;
+    else if (value < 1 << 8) {
+        data[cursor++] = (major << 5) | 24;
+        data[cursor++] = value;
     }
-    const num = Number(bigInt);
-    if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
-        return num;
+    else if (value < 1 << 16) {
+        data[cursor++] = (major << 5) | extendedFloat16;
+        dataView.setUint16(cursor, value);
+        cursor += 2;
     }
-    return bigInt;
-}
-function demote(bigInteger) {
-    const num = Number(bigInteger);
-    if (num < Number.MIN_SAFE_INTEGER || Number.MAX_SAFE_INTEGER < num) {
-        console.warn(new Error(`@smithy/core/cbor - truncating BigInt(${bigInteger}) to ${num} with loss of precision.`));
+    else if (value < 2 ** 32) {
+        data[cursor++] = (major << 5) | extendedFloat32;
+        dataView.setUint32(cursor, value);
+        cursor += 4;
+    }
+    else {
+        data[cursor++] = (major << 5) | extendedFloat64;
+        dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(value));
+        cursor += 8;
     }
-    return num;
-}
-function overflow$1(n) {
-    throw new Error(`length ${n} greater than remaining buf len.`);
-}
-function unexpectedMinor(minor) {
-    throw new Error(`unexpected minor value ${minor}.`);
-}
-function unexpectedMajorInIndefiniteString(major) {
-    throw new Error(`unexpected major type ${major} in indefinite string.`);
 }
-
-const USE_BUFFER$2 = typeof Buffer !== "undefined";
-const encodeStringCache = new Map();
-let encodeCacheEpoch$1 = 0;
-let encodeCacheSaturated$1 = false;
-const initialSize = 2048;
-let data = alloc(initialSize);
-let dataView$1 = new DataView(data.buffer, data.byteOffset, data.byteLength);
-let cursor$1 = 0;
 function encode(_input) {
     const encodeStack = [_input];
     while (encodeStack.length) {
         const input = encodeStack.pop();
+        ensureSpace(typeof input === "string" ? input.length * 4 : 64);
         if (typeof input === "string") {
-            const len = input.length;
-            if (USE_BUFFER$2) {
-                ensureSpace(len * 3 + 9);
-                if (len > 23) {
-                    encodeHeader$1(majorUtf8String, Buffer.byteLength(input));
-                    cursor$1 += data.write(input, cursor$1);
-                }
-                else {
-                    encodeStringCached(input);
-                }
+            if (USE_BUFFER) {
+                encodeHeader(majorUtf8String, Buffer.byteLength(input));
+                cursor += data.write(input, cursor);
             }
             else {
-                const maxBytes = len * 3;
-                ensureSpace(maxBytes + 9);
-                const headerPos = cursor$1;
-                const result = new TextEncoder().encodeInto(input, data.subarray(cursor$1 + 9));
-                const byteLen = result.written;
-                let headerSize;
-                if (byteLen < 24) {
-                    headerSize = 1;
-                }
-                else if (byteLen < 256) {
-                    headerSize = 2;
-                }
-                else if (byteLen < 65536) {
-                    headerSize = 3;
-                }
-                else if (byteLen < 4294967296) {
-                    headerSize = 5;
-                }
-                else {
-                    headerSize = 9;
-                }
-                if (headerSize < 9) {
-                    data.copyWithin(headerPos + headerSize, headerPos + 9, headerPos + 9 + byteLen);
-                }
-                cursor$1 = headerPos;
-                encodeInteger(majorUtf8String, byteLen);
-                cursor$1 += byteLen;
+                const bytes = serde.fromUtf8(input);
+                encodeHeader(majorUtf8String, bytes.byteLength);
+                data.set(bytes, cursor);
+                cursor += bytes.byteLength;
             }
             continue;
         }
-        if (data.byteLength - cursor$1 < 9) {
-            ensureSpace(64);
-        }
-        if (typeof input === "number") {
-            if (Number.isInteger(input) && input >= -9007199254740992 && input <= 0x1fffffffffffff) {
+        else if (typeof input === "number") {
+            if (Number.isInteger(input)) {
                 const nonNegative = input >= 0;
                 const major = nonNegative ? majorUint64 : majorNegativeInt64;
                 const value = nonNegative ? input : -input - 1;
                 if (value < 24) {
-                    data[cursor$1++] = (major << 5) | value;
+                    data[cursor++] = (major << 5) | value;
                 }
                 else if (value < 256) {
-                    data[cursor$1++] = (major << 5) | 24;
-                    data[cursor$1++] = value;
+                    data[cursor++] = (major << 5) | 24;
+                    data[cursor++] = value;
                 }
                 else if (value < 65536) {
-                    data[cursor$1++] = (major << 5) | extendedFloat16;
-                    data[cursor$1++] = value >> 8;
-                    data[cursor$1++] = value & 0xff;
+                    data[cursor++] = (major << 5) | extendedFloat16;
+                    data[cursor++] = value >> 8;
+                    data[cursor++] = value;
                 }
                 else if (value < 4294967296) {
-                    data[cursor$1++] = (major << 5) | extendedFloat32;
-                    dataView$1.setUint32(cursor$1, value);
-                    cursor$1 += 4;
+                    data[cursor++] = (major << 5) | extendedFloat32;
+                    dataView.setUint32(cursor, value);
+                    cursor += 4;
                 }
                 else {
-                    data[cursor$1++] = (major << 5) | extendedFloat64;
-                    const hi = (value / 4294967296) | 0;
-                    const lo = (value - hi * 4294967296) | 0;
-                    dataView$1.setUint32(cursor$1, hi);
-                    dataView$1.setUint32(cursor$1 + 4, lo);
-                    cursor$1 += 8;
+                    data[cursor++] = (major << 5) | extendedFloat64;
+                    dataView.setBigUint64(cursor, BigInt(value));
+                    cursor += 8;
                 }
                 continue;
             }
-            data[cursor$1++] = (majorSpecial << 5) | extendedFloat64;
-            dataView$1.setFloat64(cursor$1, input);
-            cursor$1 += 8;
+            data[cursor++] = (majorSpecial << 5) | extendedFloat64;
+            dataView.setFloat64(cursor, input);
+            cursor += 8;
             continue;
         }
         else if (typeof input === "bigint") {
             const nonNegative = input >= 0;
             const major = nonNegative ? majorUint64 : majorNegativeInt64;
             const value = nonNegative ? input : -input - BigInt(1);
-            if (value < BigInt("18446744073709551616")) {
-                const n = Number(value);
-                if (n < 4294967296) {
-                    encodeInteger(major, n);
-                }
-                else {
-                    data[cursor$1++] = (major << 5) | extendedFloat64;
-                    dataView$1.setBigUint64(cursor$1, value);
-                    cursor$1 += 8;
-                }
+            const n = Number(value);
+            if (n < 24) {
+                data[cursor++] = (major << 5) | n;
+            }
+            else if (n < 256) {
+                data[cursor++] = (major << 5) | 24;
+                data[cursor++] = n;
+            }
+            else if (n < 65536) {
+                data[cursor++] = (major << 5) | extendedFloat16;
+                data[cursor++] = n >> 8;
+                data[cursor++] = n & 0b1111_1111;
+            }
+            else if (n < 4294967296) {
+                data[cursor++] = (major << 5) | extendedFloat32;
+                dataView.setUint32(cursor, n);
+                cursor += 4;
+            }
+            else if (value < BigInt("18446744073709551616")) {
+                data[cursor++] = (major << 5) | extendedFloat64;
+                dataView.setBigUint64(cursor, value);
+                cursor += 8;
             }
             else {
                 const binaryBigInt = value.toString(2);
@@ -644,63 +602,59 @@ function encode(_input) {
                     bigIntBytes[bigIntBytes.byteLength - i] = Number(b & BigInt(255));
                     b >>= BigInt(8);
                 }
-                ensureSpace(bigIntBytes.byteLength * 2 + 16);
-                data[cursor$1++] = nonNegative ? 0b110_00010 : 0b110_00011;
-                encodeHeader$1(majorUnstructuredByteString, bigIntBytes.byteLength);
-                data.set(bigIntBytes, cursor$1);
-                cursor$1 += bigIntBytes.byteLength;
+                ensureSpace(bigIntBytes.byteLength * 2);
+                data[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011;
+                if (USE_BUFFER) {
+                    encodeHeader(majorUnstructuredByteString, Buffer.byteLength(bigIntBytes));
+                }
+                else {
+                    encodeHeader(majorUnstructuredByteString, bigIntBytes.byteLength);
+                }
+                data.set(bigIntBytes, cursor);
+                cursor += bigIntBytes.byteLength;
             }
             continue;
         }
         else if (input === null) {
-            data[cursor$1++] = (majorSpecial << 5) | specialNull;
+            data[cursor++] = (majorSpecial << 5) | specialNull;
             continue;
         }
         else if (typeof input === "boolean") {
-            data[cursor$1++] = (majorSpecial << 5) | (input ? specialTrue : specialFalse);
+            data[cursor++] = (majorSpecial << 5) | (input ? specialTrue : specialFalse);
             continue;
         }
         else if (typeof input === "undefined") {
             throw new Error("@smithy/core/cbor: client may not serialize undefined value.");
         }
         else if (Array.isArray(input)) {
-            encodeInteger(majorList, input.length);
-            ensureSpace(input.length * 9 + 64);
             for (let i = input.length - 1; i >= 0; --i) {
                 encodeStack.push(input[i]);
             }
+            encodeHeader(majorList, input.length);
             continue;
         }
         else if (typeof input.byteLength === "number") {
-            ensureSpace(input.length * 2 + 9);
-            encodeInteger(majorUnstructuredByteString, input.length);
-            data.set(input, cursor$1);
-            cursor$1 += input.byteLength;
+            ensureSpace(input.length * 2);
+            encodeHeader(majorUnstructuredByteString, input.length);
+            data.set(input, cursor);
+            cursor += input.byteLength;
             continue;
         }
         else if (typeof input === "object") {
-            if (input instanceof NumericValue) {
-                let str = input.string;
-                let expOffset = BigInt(0);
-                const eIndex = str.search(/[eE]/);
-                if (eIndex !== -1) {
-                    expOffset = BigInt(str.slice(eIndex + 1));
-                    str = str.slice(0, eIndex);
-                }
-                const decimalIndex = str.indexOf(".");
-                const fractionDigits = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
-                const exponent = expOffset - BigInt(fractionDigits);
-                const mantissa = BigInt(str.replace(".", ""));
-                data[cursor$1++] = 0b110_00100;
-                encodeInteger(majorList, 2);
+            if (input instanceof serde.NumericValue) {
+                const decimalIndex = input.string.indexOf(".");
+                const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
+                const mantissa = BigInt(input.string.replace(".", ""));
+                data[cursor++] = 0b110_00100;
                 encodeStack.push(mantissa);
-                encodeStack.push(exponent >= -0x20000000000000n && exponent <= 0x1fffffffffffffn ? Number(exponent) : exponent);
+                encodeStack.push(exponent);
+                encodeHeader(majorList, 2);
                 continue;
             }
             if (input[tagSymbol]) {
                 if ("tag" in input && "value" in input) {
                     encodeStack.push(input.value);
-                    encodeHeader$1(majorTag, input.tag);
+                    encodeHeader(majorTag, input.tag);
                     continue;
                 }
                 else {
@@ -708,147 +662,24 @@ function encode(_input) {
                 }
             }
             const keys = Object.keys(input);
-            const len = keys.length;
-            encodeInteger(majorMap, len);
-            for (let i = len - 1; i >= 0; --i) {
-                encodeStack.push(input[keys[i]]);
-                encodeStack.push(keys[i]);
+            for (let i = keys.length - 1; i >= 0; --i) {
+                const key = keys[i];
+                encodeStack.push(input[key]);
+                encodeStack.push(key);
             }
+            encodeHeader(majorMap, keys.length);
             continue;
         }
         throw new Error(`data type ${input?.constructor?.name ?? typeof input} not compatible for encoding.`);
     }
 }
-function advanceEncodingEpoch() {
-    encodeCacheEpoch$1 = (encodeCacheEpoch$1 + 1) & 0b1111_1111_1111_1111;
-    encodeCacheSaturated$1 = false;
-}
-function toUint8Array() {
-    const out = alloc(cursor$1);
-    out.set(data.subarray(0, cursor$1), 0);
-    cursor$1 = 0;
-    return out;
-}
-function resize(size) {
-    const old = data;
-    data = alloc(size);
-    if (old) {
-        if (old.copy) {
-            old.copy(data, 0, 0, old.byteLength);
-        }
-        else {
-            data.set(old, 0);
-        }
-    }
-    dataView$1 = new DataView(data.buffer, data.byteOffset, data.byteLength);
-}
-function encodeStringCached(input) {
-    const cached = encodeStringCache.get(input);
-    if (cached !== undefined) {
-        data.set(cached.bytes, cursor$1);
-        cursor$1 += cached.bytes.length;
-        cached.epoch = encodeCacheEpoch$1;
-        return;
-    }
-    const start = cursor$1;
-    const byteLen = Buffer.byteLength(input);
-    encodeInteger(majorUtf8String, byteLen);
-    cursor$1 += data.write(input, cursor$1);
-    const bytes = Uint8Array.prototype.slice.call(data, start, cursor$1);
-    if (encodeStringCache.size >= 2048) {
-        if (encodeCacheSaturated$1) {
-            return;
-        }
-        let evicted = 0;
-        for (const [key, entry] of encodeStringCache) {
-            if (evicted >= 1024) {
-                break;
-            }
-            if (entry.epoch !== encodeCacheEpoch$1) {
-                encodeStringCache.delete(key);
-                evicted++;
-            }
-        }
-        if (evicted === 0) {
-            encodeCacheSaturated$1 = true;
-            return;
-        }
-    }
-    if (encodeStringCache.size < 2048) {
-        encodeStringCache.set(input, { epoch: encodeCacheEpoch$1, bytes });
-    }
-}
-function ensureSpace(bytes) {
-    const remaining = data.byteLength - cursor$1;
-    if (remaining < bytes) {
-        if (cursor$1 < 16_000_000) {
-            resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
-        }
-        else {
-            resize(data.byteLength + bytes + 16_000_000);
-        }
-    }
-}
-function encodeHeader$1(major, value) {
-    if (value < 24) {
-        data[cursor$1++] = (major << 5) | value;
-    }
-    else if (value < 256) {
-        data[cursor$1++] = (major << 5) | 24;
-        data[cursor$1++] = value;
-    }
-    else if (value < 65536) {
-        data[cursor$1++] = (major << 5) | extendedFloat16;
-        dataView$1.setUint16(cursor$1, value);
-        cursor$1 += 2;
-    }
-    else if (value < 4294967296) {
-        data[cursor$1++] = (major << 5) | extendedFloat32;
-        dataView$1.setUint32(cursor$1, value);
-        cursor$1 += 4;
-    }
-    else {
-        data[cursor$1++] = (major << 5) | extendedFloat64;
-        dataView$1.setBigUint64(cursor$1, typeof value === "bigint" ? value : BigInt(value));
-        cursor$1 += 8;
-    }
-}
-function encodeInteger(major, value) {
-    if (value < 24) {
-        data[cursor$1++] = (major << 5) | value;
-    }
-    else if (value < 256) {
-        data[cursor$1++] = (major << 5) | 24;
-        data[cursor$1++] = value;
-    }
-    else if (value < 65536) {
-        data[cursor$1++] = (major << 5) | extendedFloat16;
-        data[cursor$1++] = value >> 8;
-        data[cursor$1++] = value & 0xff;
-    }
-    else if (value < 4294967296) {
-        data[cursor$1++] = (major << 5) | extendedFloat32;
-        dataView$1.setUint32(cursor$1, value);
-        cursor$1 += 4;
-    }
-    else {
-        data[cursor$1++] = (major << 5) | extendedFloat64;
-        const hi = (value / 4294967296) | 0;
-        const lo = (value - hi * 4294967296) | 0;
-        dataView$1.setUint32(cursor$1, hi);
-        dataView$1.setUint32(cursor$1 + 4, lo);
-        cursor$1 += 8;
-    }
-}
 
 const cbor = {
     deserialize(payload) {
-        advanceDecodingEpoch();
         setPayload(payload);
         return decode(0, payload.length);
     },
     serialize(input) {
-        advanceEncodingEpoch();
         try {
             encode(input);
             return toUint8Array();
@@ -864,7 +695,7 @@ const cbor = {
 };
 
 const parseCborBody = (streamBody, context) => {
-    return collectBody(streamBody, context).then(async (bytes) => {
+    return protocols.collectBody(streamBody, context).then(async (bytes) => {
         if (bytes.length) {
             try {
                 return cbor.deserialize(bytes);
@@ -887,1460 +718,104 @@ const dateToTag = (date) => {
 };
 const parseCborErrorBody = async (errorBody, context) => {
     const value = await parseCborBody(errorBody, context);
-    value.message = value.message ?? value.Message;
-    return value;
-};
-const loadSmithyRpcV2CborErrorCode = (output, data) => {
-    const sanitizeErrorCode = (rawValue) => {
-        let cleanValue = rawValue;
-        if (typeof cleanValue === "number") {
-            cleanValue = cleanValue.toString();
-        }
-        if (cleanValue.indexOf(",") >= 0) {
-            cleanValue = cleanValue.split(",")[0];
-        }
-        if (cleanValue.indexOf(":") >= 0) {
-            cleanValue = cleanValue.split(":")[0];
-        }
-        if (cleanValue.indexOf("#") >= 0) {
-            cleanValue = cleanValue.split("#")[1];
-        }
-        return cleanValue;
-    };
-    if (data["__type"] !== undefined) {
-        return sanitizeErrorCode(data["__type"]);
-    }
-    let codeKey;
-    for (const key in data) {
-        if (!hasOwn(data, key))
-            continue;
-        if (key.toLowerCase() === "code") {
-            codeKey = key;
-            break;
-        }
-    }
-    if (codeKey && data[codeKey] !== undefined) {
-        return sanitizeErrorCode(data[codeKey]);
-    }
-};
-const checkCborResponse = (response) => {
-    if (String(response.headers["smithy-protocol"]).toLowerCase() !== "rpc-v2-cbor") {
-        throw new Error("Malformed RPCv2 CBOR response, status: " + response.statusCode);
-    }
-};
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const endpoint = await context.endpoint();
-    const { hostname, protocol = "https", port, path: basePath } = endpoint;
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers: {
-            ...headers,
-        },
-    };
-    if (resolvedHostname !== undefined) {
-        contents.hostname = resolvedHostname;
-    }
-    if (endpoint.headers) {
-        for (const name in endpoint.headers) {
-            if (!hasOwn(endpoint.headers, name))
-                continue;
-            contents.headers[name] = endpoint.headers[name];
-        }
-    }
-    if (body !== undefined) {
-        contents.body = body;
-        try {
-            contents.headers["content-length"] = String(calculateBodyLength(body));
-        }
-        catch (ignored) { }
-    }
-    return new HttpRequest(contents);
-};
-
-class CborShapeSerializer2 extends SerdeContext {
-    write(schema, value) {
-        cursor = 0;
-        const ns = NormalizedSchema.of(schema);
-        writeValue(ns, value, undefined, this.serdeContext);
-    }
-    flush() {
-        const result = buf.subarray(0, cursor);
-        cursor = 0;
-        buf = allocUnsafe(INITIAL_BUFFER_SIZE);
-        view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-        return result;
-    }
-}
-const CBOR_STRUCT_CACHE = Symbol.for("@smithy/cbor-struct-cache");
-function loadCborStructIterator(ns) {
-    const schema = ns.getSchema();
-    const existing = schema[CBOR_STRUCT_CACHE];
-    if (existing) {
-        return existing;
-    }
-    const memberNames = [];
-    const memberSchemas = [];
-    for (const [name, memberSchema] of ns.structIterator()) {
-        memberNames.push(name);
-        memberSchemas.push(memberSchema);
-    }
-    const encodedKeys = new Array(memberNames.length);
-    for (let i = 0; i < memberNames.length; ++i) {
-        encodedKeys[i] = encodeCborStringKey(memberNames[i]);
-    }
-    const cache = { memberNames, memberSchemas, encodedKeys };
-    schema[CBOR_STRUCT_CACHE] = cache;
-    return cache;
-}
-function encodeCborStringKey(s) {
-    let utf8Bytes;
-    if (USE_BUFFER$1) {
-        utf8Bytes = Buffer.from(s, "utf-8");
-    }
-    else {
-        utf8Bytes = new TextEncoder().encode(s);
-    }
-    const byteLen = utf8Bytes.length;
-    let headerSize;
-    if (byteLen < 24) {
-        headerSize = 1;
-    }
-    else if (byteLen < 256) {
-        headerSize = 2;
-    }
-    else {
-        headerSize = 3;
-    }
-    const result = new Uint8Array(headerSize + byteLen);
-    if (headerSize === 1) {
-        result[0] = (majorUtf8String << 5) | byteLen;
-    }
-    else if (headerSize === 2) {
-        result[0] = (majorUtf8String << 5) | 24;
-        result[1] = byteLen;
-    }
-    else {
-        result[0] = (majorUtf8String << 5) | extendedFloat16;
-        result[1] = byteLen >> 8;
-        result[2] = byteLen & 0xff;
-    }
-    result.set(utf8Bytes, headerSize);
-    return result;
-}
-const USE_BUFFER$1 = typeof Buffer !== "undefined";
-const textEncoder = new TextEncoder();
-const INITIAL_BUFFER_SIZE = 2048;
-let buf = USE_BUFFER$1 ? Buffer.allocUnsafe(INITIAL_BUFFER_SIZE) : new Uint8Array(INITIAL_BUFFER_SIZE);
-let view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-let cursor = 0;
-const STRING_CACHE_MAX = 2048;
-const stringEncodeCache = new Map();
-let encodeCacheEpoch = 0;
-let encodeCacheSaturated = false;
-function allocUnsafe(size) {
-    return USE_BUFFER$1 ? Buffer.allocUnsafe(size) : new Uint8Array(size);
-}
-function writeValue(ns, value, container, serdeContext) {
-    if (value == null) {
-        if (value === undefined && ns.isIdempotencyToken()) {
-            writeString(generateIdempotencyToken());
-            return;
-        }
-        ensure(1);
-        buf[cursor++] = (majorSpecial << 5) | specialNull;
-        return;
-    }
-    if (ns.isUnitSchema()) {
-        ensure(1);
-        encodeHeader(majorMap, 0);
-        return;
-    }
-    const isObject = typeof value === "object";
-    if (isObject) {
-        if (ns.isBlobSchema()) {
-            if (value instanceof Uint8Array) {
-                writeBytes(value);
-                return;
-            }
-        }
-        if (ns.isTimestampSchema()) {
-            if (value instanceof Date) {
-                writeTimestamp(value);
-                return;
-            }
-        }
-        if (ns.isStructSchema()) {
-            writeStruct(ns, value, serdeContext);
-            return;
-        }
-        if (Array.isArray(value) && (ns.isListSchema() || ns.isDocumentSchema())) {
-            writeList(ns, value, ns.isDocumentSchema(), serdeContext);
-            return;
-        }
-        if (ns.isMapSchema()) {
-            writeMap(ns, value, false, serdeContext);
-            return;
-        }
-        if (value instanceof Date) {
-            writeTimestamp(value);
-            return;
-        }
-        if (value instanceof Uint8Array) {
-            writeBytes(value);
-            return;
-        }
-        if (value instanceof NumericValue) {
-            writeNumericValue(value);
-            return;
-        }
-        if (value[tagSymbol]) {
-            const tagged = value;
-            writeTag(tagged.tag, tagged.value);
-            return;
-        }
-        if (ns.isDocumentSchema()) {
-            if (Array.isArray(value)) {
-                writeList(ns, value, true, serdeContext);
-            }
-            else {
-                writeMap(ns, value, true, serdeContext);
-            }
-            return;
-        }
-        if (ns.isBigDecimalSchema()) {
-            writeUntypedValue(value);
-            return;
-        }
-        writeMap(ns, value, true, serdeContext);
-        return;
-    }
-    if (typeof value === "string") {
-        if (ns.isBlobSchema()) {
-            const bytes = (serdeContext?.base64Decoder ?? fromBase64)(value);
-            writeBytes(bytes);
-            return;
-        }
-        writeString(value);
-        return;
-    }
-    if (typeof value === "number") {
-        ensure(9);
-        if (Number.isInteger(value) && value >= -9007199254740992 && value <= 0x1fffffffffffff) {
-            writeInteger(value);
-        }
-        else {
-            writeFloat64(value);
-        }
-        return;
-    }
-    if (typeof value === "boolean") {
-        ensure(1);
-        buf[cursor++] = (majorSpecial << 5) | (value ? specialTrue : specialFalse);
-        return;
-    }
-    if (typeof value === "bigint") {
-        writeBigInt(value);
-        return;
-    }
-    writeString(String(value));
-}
-function writeStruct(ns, value, serdeContext) {
-    if (ns.isUnionSchema()) {
-        let wrote = false;
-        for (const [memberName, memberSchema] of ns.structIterator()) {
-            const item = value[memberName];
-            if (item != null) {
-                ensure(9);
-                encodeHeader(majorMap, 1);
-                writeString(memberName);
-                writeValue(memberSchema, item, ns, serdeContext);
-                wrote = true;
-                break;
-            }
-        }
-        if (!wrote) {
-            const { $unknown } = value;
-            if (Array.isArray($unknown)) {
-                ensure(9);
-                encodeHeader(majorMap, 1);
-                writeString($unknown[0]);
-                writeUntypedValue($unknown[1]);
-            }
-            else {
-                ensure(9);
-                encodeHeader(majorMap, 0);
-            }
-        }
-        return;
-    }
-    const cache = loadCborStructIterator(ns);
-    const { memberNames, memberSchemas, encodedKeys } = cache;
-    const z = memberNames.length;
-    let headerSize;
-    if (z < 24) {
-        headerSize = 1;
-    }
-    else if (z < 256) {
-        headerSize = 2;
-    }
-    else {
-        headerSize = 3;
-    }
-    ensure(headerSize);
-    const headerPos = cursor;
-    cursor += headerSize;
-    let count = 0;
-    for (let i = 0; i < z; ++i) {
-        const item = value[memberNames[i]];
-        if (item == null && !memberSchemas[i].isIdempotencyToken()) {
-            continue;
-        }
-        const key = encodedKeys[i];
-        ensure(key.length);
-        buf.set(key, cursor);
-        cursor += key.length;
-        writeValue(memberSchemas[i], item, ns, serdeContext);
-        ++count;
-    }
-    if (typeof value.__type === "string") {
-        for (const k in value) {
-            if (!hasOwn(value, k))
-                continue;
-            if (!memberNames.includes(k)) {
-                writeString(k);
-                writeUntypedValue(value[k]);
-                ++count;
-            }
-        }
-    }
-    if (headerSize === 1) {
-        buf[headerPos] = (majorMap << 5) | count;
-    }
-    else if (headerSize === 2) {
-        buf[headerPos] = (majorMap << 5) | 24;
-        buf[headerPos + 1] = count;
-    }
-    else {
-        buf[headerPos] = (majorMap << 5) | extendedFloat16;
-        buf[headerPos + 1] = count >> 8;
-        buf[headerPos + 2] = count & 0xff;
-    }
-}
-function writeList(ns, value, isDocument, serdeContext) {
-    const sparse = !!ns.getMergedTraits().sparse;
-    const valueSchema = ns.getValueSchema();
-    if (isDocument || sparse) {
-        const items = [];
-        for (let i = 0; i < value.length; ++i) {
-            const item = value[i];
-            if (isDocument) {
-                if (item !== undefined) {
-                    items.push(item);
-                }
-            }
-            else {
-                if (item != null || sparse) {
-                    items.push(item);
-                }
-            }
-        }
-        ensure(9);
-        encodeHeader(majorList, items.length);
-        for (let i = 0; i < items.length; ++i) {
-            writeValue(valueSchema, items[i], undefined, serdeContext);
-        }
-    }
-    else {
-        let count = 0;
-        for (let i = 0; i < value.length; ++i) {
-            if (value[i] != null) {
-                ++count;
-            }
-        }
-        ensure(9);
-        encodeHeader(majorList, count);
-        for (let i = 0; i < value.length; ++i) {
-            if (value[i] != null) {
-                writeValue(valueSchema, value[i], undefined, serdeContext);
-            }
-        }
-    }
-}
-function writeMap(ns, value, isDocument, serdeContext) {
-    const sparse = !!ns.getMergedTraits().sparse;
-    const valueSchema = ns.getValueSchema();
-    const keys = [];
-    for (const k in value) {
-        if (!hasOwn(value, k))
-            continue;
-        const v = value[k];
-        if (isDocument ? v !== undefined : v != null || sparse) {
-            keys.push(k);
-        }
-    }
-    ensure(9);
-    encodeHeader(majorMap, keys.length);
-    for (let i = 0; i < keys.length; ++i) {
-        const k = keys[i];
-        writeString(k);
-        writeValue(valueSchema, value[k], undefined, serdeContext);
-    }
-}
-function writeUntypedValue(value) {
-    if (value == null) {
-        ensure(1);
-        buf[cursor++] = (majorSpecial << 5) | specialNull;
-        return;
-    }
-    if (typeof value === "string") {
-        writeString(value);
-        return;
-    }
-    if (typeof value === "number") {
-        ensure(9);
-        if (Number.isInteger(value) && value >= -9007199254740992 && value <= 0x1fffffffffffff) {
-            writeInteger(value);
-        }
-        else {
-            writeFloat64(value);
-        }
-        return;
-    }
-    if (typeof value === "boolean") {
-        ensure(1);
-        buf[cursor++] = (majorSpecial << 5) | (value ? specialTrue : specialFalse);
-        return;
-    }
-    if (typeof value === "bigint") {
-        writeBigInt(value);
-        return;
-    }
-    if (value instanceof Uint8Array) {
-        writeBytes(value);
-        return;
-    }
-    if (value instanceof Date) {
-        writeTimestamp(value);
-        return;
-    }
-    if (value instanceof NumericValue) {
-        writeNumericValue(value);
-        return;
-    }
-    if (value[tagSymbol]) {
-        const tagged = value;
-        writeTag(tagged.tag, tagged.value);
-        return;
-    }
-    if (Array.isArray(value)) {
-        ensure(9);
-        encodeHeader(majorList, value.length);
-        for (let i = 0; i < value.length; ++i) {
-            writeUntypedValue(value[i]);
-        }
-        return;
-    }
-    if (typeof value === "object") {
-        const keys = Object.keys(value);
-        ensure(9);
-        encodeHeader(majorMap, keys.length);
-        for (let i = 0; i < keys.length; ++i) {
-            writeString(keys[i]);
-            writeUntypedValue(value[keys[i]]);
-        }
-        return;
-    }
-    writeString(String(value));
-}
-function ensure(n) {
-    if (cursor + n > buf.length) {
-        let newSize = buf.length * 2;
-        while (newSize < cursor + n) {
-            newSize *= 2;
-        }
-        const next = allocUnsafe(newSize);
-        next.set(buf.subarray(0, cursor));
-        buf = next;
-        view = new DataView(next.buffer, next.byteOffset, next.byteLength);
-    }
-}
-function encodeHeader(major, value) {
-    if (value < 24) {
-        buf[cursor++] = (major << 5) | value;
-    }
-    else if (value < 256) {
-        buf[cursor++] = (major << 5) | 24;
-        buf[cursor++] = value;
-    }
-    else if (value < 65536) {
-        buf[cursor++] = (major << 5) | extendedFloat16;
-        buf[cursor++] = value >> 8;
-        buf[cursor++] = value & 0xff;
-    }
-    else if (value < 4294967296) {
-        buf[cursor++] = (major << 5) | extendedFloat32;
-        view.setUint32(cursor, value);
-        cursor += 4;
-    }
-    else {
-        buf[cursor++] = (major << 5) | extendedFloat64;
-        const hi = (value / 4294967296) | 0;
-        const lo = (value - hi * 4294967296) | 0;
-        view.setUint32(cursor, hi);
-        view.setUint32(cursor + 4, lo);
-        cursor += 8;
-    }
-}
-function encodeBigHeader(major, value) {
-    const n = Number(value);
-    if (n < 4294967296) {
-        encodeHeader(major, n);
-        return;
-    }
-    buf[cursor++] = (major << 5) | extendedFloat64;
-    view.setBigUint64(cursor, value);
-    cursor += 8;
-}
-function writeString(s) {
-    const len = s.length;
-    if (len <= 23) {
-        const cached = stringEncodeCache.get(s);
-        if (cached) {
-            ensure(cached.bytes.length);
-            buf.set(cached.bytes, cursor);
-            cursor += cached.bytes.length;
-            cached.epoch = encodeCacheEpoch;
-            return;
-        }
-        const start = cursor;
-        writeStringUncached(s, len);
-        const end = cursor;
-        const bytes = Uint8Array.prototype.slice.call(buf, start, end);
-        if (stringEncodeCache.size >= STRING_CACHE_MAX) {
-            if (encodeCacheSaturated) {
-                return;
-            }
-            let evicted = 0;
-            for (const [key, entry] of stringEncodeCache) {
-                if (evicted >= 1024) {
-                    break;
-                }
-                if (entry.epoch !== encodeCacheEpoch) {
-                    stringEncodeCache.delete(key);
-                    ++evicted;
-                }
-            }
-            if (evicted === 0) {
-                encodeCacheSaturated = true;
-                return;
-            }
-        }
-        if (stringEncodeCache.size < STRING_CACHE_MAX) {
-            stringEncodeCache.set(s, { epoch: encodeCacheEpoch, bytes });
-        }
-        return;
-    }
-    writeStringUncached(s, len);
-}
-function writeStringUncached(s, len) {
-    if (USE_BUFFER$1) {
-        const maxBytes = len * 3;
-        ensure(maxBytes + 9);
-        const byteLen = Buffer.byteLength(s);
-        encodeHeader(majorUtf8String, byteLen);
-        cursor += buf.write(s, cursor);
-    }
-    else {
-        const maxBytes = len * 3;
-        ensure(maxBytes + 9);
-        const headerPos = cursor;
-        const result = textEncoder.encodeInto(s, buf.subarray(headerPos + 9));
-        const byteLen = result.written;
-        let headerSize;
-        if (byteLen < 24) {
-            headerSize = 1;
-        }
-        else if (byteLen < 256) {
-            headerSize = 2;
-        }
-        else if (byteLen < 65536) {
-            headerSize = 3;
-        }
-        else if (byteLen < 4294967296) {
-            headerSize = 5;
-        }
-        else {
-            headerSize = 9;
-        }
-        if (headerSize < 9) {
-            buf.copyWithin(headerPos + headerSize, headerPos + 9, headerPos + 9 + byteLen);
-        }
-        cursor = headerPos;
-        encodeHeader(majorUtf8String, byteLen);
-        cursor += byteLen;
-    }
-}
-function writeFloat64(value) {
-    ensure(9);
-    buf[cursor++] = (majorSpecial << 5) | extendedFloat64;
-    view.setFloat64(cursor, value);
-    cursor += 8;
-}
-function writeInteger(value) {
-    ensure(9);
-    const nonNegative = value >= 0;
-    const major = nonNegative ? majorUint64 : majorNegativeInt64;
-    const abs = nonNegative ? value : -value - 1;
-    encodeHeader(major, abs);
-}
-function writeBigInt(value) {
-    const nonNegative = value >= 0;
-    const major = nonNegative ? majorUint64 : majorNegativeInt64;
-    const abs = nonNegative ? value : -value - BigInt(1);
-    if (abs < BigInt("18446744073709551616")) {
-        ensure(9);
-        encodeBigHeader(major, abs);
-    }
-    else {
-        const binaryStr = abs.toString(2);
-        const byteLen = Math.ceil(binaryStr.length / 8);
-        const bigIntBytes = new Uint8Array(byteLen);
-        let b = abs;
-        for (let i = byteLen - 1; i >= 0; --i) {
-            bigIntBytes[i] = Number(b & BigInt(255));
-            b >>= BigInt(8);
-        }
-        ensure(byteLen + 16);
-        buf[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011;
-        encodeHeader(majorUnstructuredByteString, byteLen);
-        buf.set(bigIntBytes, cursor);
-        cursor += byteLen;
-    }
-}
-function writeBytes(data) {
-    ensure(data.length + 9);
-    encodeHeader(majorUnstructuredByteString, data.length);
-    buf.set(data, cursor);
-    cursor += data.length;
-}
-function writeTag(tagValue, innerValue) {
-    ensure(9);
-    if (typeof tagValue === "bigint") {
-        encodeBigHeader(majorTag, tagValue);
-    }
-    else {
-        encodeHeader(majorTag, tagValue);
-    }
-    writeUntypedValue(innerValue);
-}
-function writeNumericValue(nv) {
-    let str = nv.string;
-    let expOffset = BigInt(0);
-    const eIndex = str.search(/[eE]/);
-    if (eIndex !== -1) {
-        expOffset = BigInt(str.slice(eIndex + 1));
-        str = str.slice(0, eIndex);
-    }
-    const decimalIndex = str.indexOf(".");
-    const fractionDigits = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
-    const exponent = expOffset - BigInt(fractionDigits);
-    const mantissa = BigInt(str.replace(".", ""));
-    ensure(9);
-    buf[cursor++] = 0b110_00100;
-    encodeHeader(majorList, 2);
-    ensure(9);
-    if (exponent >= -0x20000000000000n && exponent <= 0x1fffffffffffffn) {
-        writeInteger(Number(exponent));
-    }
-    else {
-        writeBigInt(exponent);
-    }
-    writeBigInt(mantissa);
-}
-function writeTimestamp(date) {
-    ensure(18);
-    encodeHeader(majorTag, 1);
-    const epochSecs = date.getTime() / 1000;
-    if (Number.isInteger(epochSecs)) {
-        writeInteger(epochSecs);
-    }
-    else {
-        writeFloat64(epochSecs);
-    }
-}
-
-class CborShapeDeserializer2 extends SerdeContext {
-    read(schema, bytes) {
-        payload = bytes;
-        isBuffer = USE_BUFFER && bytes instanceof Buffer;
-        dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        pos = 0;
-        end = bytes.length;
-        cacheEpoch = (cacheEpoch + 1) & 0xffff;
-        return readValue(NormalizedSchema.of(schema));
-    }
-    readValue(_schema, value) {
-        return transformObject(NormalizedSchema.of(_schema), value);
-    }
-}
-const USE_BUFFER = typeof Buffer !== "undefined";
-const textDecoder = new TextDecoder();
-let payload = new Uint8Array(0);
-let isBuffer = false;
-let dataView = new DataView(new ArrayBuffer(0));
-let pos = 0;
-let end = 0;
-const STRING_CACHE_SIZE = 2048;
-const stringCache = new Array(STRING_CACHE_SIZE);
-const stringCacheEpochs = new Uint16Array(STRING_CACHE_SIZE);
-let cacheEpoch = 0;
-function readValue(ns) {
-    if (pos >= end) {
-        throw new Error("unexpected end of CBOR payload.");
-    }
-    const major = (payload[pos] & 0b1110_0000) >> 5;
-    const minor = payload[pos] & 0b0001_1111;
-    if (minor === minorIndefinite && major >= 2 && major <= 5) {
-        return readIndefinite(ns, major);
-    }
-    switch (major) {
-        case majorUint64:
-            return readUnsignedInt();
-        case majorNegativeInt64:
-            return readNegativeInt();
-        case majorUnstructuredByteString:
-            return readByteString();
-        case majorUtf8String:
-            return readUtf8String();
-        case majorList:
-            return readList(ns);
-        case majorMap:
-            return readMap(ns);
-        case majorTag:
-            return readTag();
-        case majorSpecial:
-            return readSpecial();
-        default:
-            throw new Error(`unexpected CBOR major type ${major}.`);
-    }
-}
-function readList(ns) {
-    const count = decodeCount();
-    const memberSchema = ns.isListSchema() ? ns.getValueSchema() : ns;
-    const list = Array(count);
-    for (let i = 0; i < count; ++i) {
-        list[i] = readValue(memberSchema);
-    }
-    return list;
-}
-function readMap(ns) {
-    const count = decodeCount();
-    if (ns.isStructSchema()) {
-        const startPos = pos;
-        return readStruct(ns, count, startPos);
-    }
-    const valueSchema = ns.isMapSchema() ? ns.getValueSchema() : ns;
-    const map = {};
-    for (let i = 0; i < count; ++i) {
-        const key = readUtf8String();
-        map[key] = readValue(valueSchema);
-    }
-    return map;
-}
-function readStruct(ns, count, startPos) {
-    const isUnion = ns.isUnionSchema();
-    const cache = loadCborStructIterator(ns);
-    const { memberSchemas, encodedKeys, memberNames } = cache;
-    const z = encodedKeys.length;
-    const result = {};
-    let unknownKey;
-    let unknownValue;
-    let unknownCount = 0;
-    let hasType = false;
-    let hint = 0;
-    for (let i = 0; i < count; ++i) {
-        const matchIdx = matchStructKey(encodedKeys, z, hint);
-        if (matchIdx >= 0) {
-            hint = matchIdx + 1;
-            if (hint >= z) {
-                hint = 0;
-            }
-            const val = readValue(memberSchemas[matchIdx]);
-            if (val != null) {
-                result[memberNames[matchIdx]] = val;
-            }
-        }
-        else {
-            const key = readUtf8String();
-            const val = readValue(NormalizedSchema.of(15));
-            if (key === "__type" && typeof val === "string") {
-                hasType = true;
-            }
-            else {
-                unknownKey = key;
-                unknownValue = val;
-                ++unknownCount;
-            }
-        }
-    }
-    if (isUnion) {
-        let resultEmpty = true;
-        for (const _ in result) {
-            if (!hasOwn(result, _))
-                continue;
-            resultEmpty = false;
-            break;
-        }
-        if (resultEmpty && unknownCount === 1) {
-            result.$unknown = [unknownKey, unknownValue];
-        }
-    }
-    else if (hasType) {
-        pos = startPos;
-        const docSchema = NormalizedSchema.of(15);
-        for (let i = 0; i < count; ++i) {
-            const key = readUtf8String();
-            const val = readValue(docSchema);
-            if (!(key in result)) {
-                result[key] = val;
-            }
-        }
-    }
-    return result;
-}
-function readTag(ns) {
-    const tagNum = decodeArgument();
-    const tagNumber = typeof tagNum === "bigint" ? Number(tagNum) : tagNum;
-    if (tagNumber === 1) {
-        const docSchema = NormalizedSchema.of(15);
-        const epochValue = readValue(docSchema);
-        return _parseEpochTimestamp(epochValue);
-    }
-    if (tagNumber === 2 || tagNumber === 3) {
-        const byteStr = readByteString();
-        let b = BigInt(0);
-        for (let i = 0; i < byteStr.length; ++i) {
-            b = (b << BigInt(8)) | BigInt(byteStr[i]);
-        }
-        return tagNumber === 3 ? -b - BigInt(1) : b;
-    }
-    if (tagNumber === 4) {
-        const docSchema = NormalizedSchema.of(15);
-        const pair = readValue(docSchema);
-        const [rawExponent, mantissa] = pair;
-        const normalizer = mantissa < 0 ? -1 : 1;
-        const absMantissa = BigInt(normalizer) * BigInt(mantissa);
-        const mantissaDigits = String(absMantissa);
-        const sign = mantissa < 0 ? "-" : "";
-        let numericString;
-        const isSmallExponent = typeof rawExponent === "number" && Math.abs(rawExponent) <= 2 ** 28;
-        if (isSmallExponent) {
-            const exponent = rawExponent;
-            const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + mantissaDigits;
-            numericString =
-                exponent === 0
-                    ? mantissaStr
-                    : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
-            numericString = numericString.replace(/^0+/g, "");
-            if (numericString === "") {
-                numericString = "0";
-            }
-            if (numericString[0] === ".") {
-                numericString = "0" + numericString;
-            }
-            numericString = sign + numericString;
-        }
-        else {
-            const bigExponent = BigInt(rawExponent);
-            if (mantissaDigits.length === 1) {
-                numericString = sign + mantissaDigits + "e" + String(bigExponent);
-            }
-            else {
-                const adjustedExp = bigExponent + BigInt(mantissaDigits.length - 1);
-                numericString = sign + mantissaDigits[0] + "." + mantissaDigits.slice(1) + "e" + String(adjustedExp);
-            }
-        }
-        return nv(numericString);
-    }
-    const docSchema = NormalizedSchema.of(15);
-    const innerValue = readValue(docSchema);
-    return { tag: castBigInt(tagNum), value: innerValue };
-}
-function readIndefinite(ns, major) {
-    switch (major) {
-        case majorUtf8String:
-            return readUtf8StringIndefinite();
-        case majorUnstructuredByteString:
-            return readByteStringIndefinite();
-        case majorList:
-            return readListIndefinite(ns);
-        case majorMap:
-            return readMapIndefinite(ns);
-        default:
-            throw new Error(`unexpected indefinite length for major ${major}.`);
-    }
-}
-function readUtf8StringIndefinite() {
-    pos += 1;
-    const chunks = [];
-    let totalLen = 0;
-    while (pos < end) {
-        if (payload[pos] === 0xff) {
-            pos += 1;
-            const combined = new Uint8Array(totalLen);
-            let offset = 0;
-            for (let i = 0; i < chunks.length; ++i) {
-                combined.set(chunks[i], offset);
-                offset += chunks[i].length;
-            }
-            if (USE_BUFFER) {
-                return Buffer.from(combined.buffer, combined.byteOffset, combined.byteLength).toString("utf-8");
-            }
-            return textDecoder.decode(combined);
-        }
-        const bytes = readByteString();
-        chunks.push(bytes);
-        totalLen += bytes.length;
-    }
-    throw new Error("expected break marker.");
-}
-function readByteStringIndefinite() {
-    pos += 1;
-    const chunks = [];
-    let totalLen = 0;
-    while (pos < end) {
-        if (payload[pos] === 0xff) {
-            pos += 1;
-            const combined = new Uint8Array(totalLen);
-            let offset = 0;
-            for (let i = 0; i < chunks.length; ++i) {
-                combined.set(chunks[i], offset);
-                offset += chunks[i].length;
-            }
-            return combined;
-        }
-        const bytes = readByteString();
-        chunks.push(bytes);
-        totalLen += bytes.length;
-    }
-    throw new Error("expected break marker.");
-}
-function readListIndefinite(ns) {
-    pos += 1;
-    const memberSchema = ns.isListSchema() ? ns.getValueSchema() : ns;
-    const list = [];
-    while (pos < end) {
-        if (payload[pos] === 0xff) {
-            pos += 1;
-            return list;
-        }
-        list.push(readValue(memberSchema));
-    }
-    throw new Error("expected break marker.");
-}
-function readMapIndefinite(ns) {
-    pos += 1;
-    if (ns.isStructSchema()) {
-        const cache = loadCborStructIterator(ns);
-        const { memberSchemas, encodedKeys, memberNames } = cache;
-        const z = encodedKeys.length;
-        const isUnion = ns.isUnionSchema();
-        const result = {};
-        let unknownKey;
-        let unknownValue;
-        let unknownCount = 0;
-        let hint = 0;
-        while (pos < end) {
-            if (payload[pos] === 0xff) {
-                pos += 1;
-                if (isUnion) {
-                    let resultEmpty = true;
-                    for (const _ in result) {
-                        if (!hasOwn(result, _))
-                            continue;
-                        resultEmpty = false;
-                        break;
-                    }
-                    if (resultEmpty && unknownCount === 1) {
-                        result.$unknown = [unknownKey, unknownValue];
-                    }
-                }
-                return result;
-            }
-            const matchIdx = matchStructKey(encodedKeys, z, hint);
-            if (matchIdx >= 0) {
-                hint = matchIdx + 1;
-                if (hint >= z) {
-                    hint = 0;
-                }
-                const val = readValue(memberSchemas[matchIdx]);
-                if (val != null) {
-                    result[memberNames[matchIdx]] = val;
-                }
-            }
-            else {
-                const key = readUtf8String();
-                const val = readValue(NormalizedSchema.of(15));
-                if (key !== "__type") {
-                    unknownKey = key;
-                    unknownValue = val;
-                    ++unknownCount;
-                }
-            }
-        }
-        throw new Error("expected break marker.");
-    }
-    const valueSchema = ns.isMapSchema() ? ns.getValueSchema() : ns;
-    const map = {};
-    while (pos < end) {
-        if (payload[pos] === 0xff) {
-            pos += 1;
-            return map;
-        }
-        const key = readUtf8String();
-        map[key] = readValue(valueSchema);
-    }
-    throw new Error("expected break marker.");
-}
-function matchStructKey(encodedKeys, z, hint) {
-    const hintKey = encodedKeys[hint];
-    if (pos + hintKey.length <= end && bytesMatch(pos, hintKey)) {
-        pos += hintKey.length;
-        return hint;
-    }
-    for (let i = 0; i < z; ++i) {
-        if (i === hint) {
-            continue;
-        }
-        const ek = encodedKeys[i];
-        if (pos + ek.length <= end && bytesMatch(pos, ek)) {
-            pos += ek.length;
-            return i;
-        }
-    }
-    return -1;
-}
-function bytesMatch(at, expected) {
-    const len = expected.length;
-    if (payload[at] !== expected[0]) {
-        return false;
-    }
-    for (let i = 1; i < len; ++i) {
-        if (payload[at + i] !== expected[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-function decodeArgument() {
-    const minor = payload[pos] & 0b0001_1111;
-    if (minor < 24) {
-        pos += 1;
-        return minor;
-    }
-    switch (minor) {
-        case extendedOneByte:
-            if (end - pos < 2) {
-                overflow(1);
-            }
-            pos += 2;
-            return payload[pos - 1];
-        case extendedFloat16:
-            if (end - pos < 3) {
-                overflow(2);
-            }
-            pos += 3;
-            return dataView.getUint16(pos - 2);
-        case extendedFloat32:
-            if (end - pos < 5) {
-                overflow(4);
-            }
-            pos += 5;
-            return dataView.getUint32(pos - 4);
-        case extendedFloat64: {
-            if (end - pos < 9) {
-                overflow(8);
-            }
-            pos += 9;
-            const hi = dataView.getUint32(pos - 8);
-            if (hi < 0x00200000) {
-                return hi * 4294967296 + dataView.getUint32(pos - 4);
-            }
-            return dataView.getBigUint64(pos - 8);
-        }
-        default:
-            throw new Error(`unexpected minor value ${minor}.`);
-    }
-}
-function decodeCount() {
-    const val = decodeArgument();
-    return typeof val === "bigint" ? Number(val) : val;
-}
-function readUnsignedInt() {
-    const val = decodeArgument();
-    return castBigInt(val);
-}
-function readNegativeInt() {
-    const val = decodeArgument();
-    if (typeof val === "bigint") {
-        return BigInt(-1) - val;
-    }
-    return -1 - val;
-}
-function readByteString() {
-    const length = decodeCount();
-    if (end - pos < length) {
-        overflow(length);
-    }
-    const start = pos;
-    pos += length;
-    return payload.subarray(start, start + length);
-}
-function readUtf8String() {
-    const length = decodeCount();
-    if (end - pos < length) {
-        overflow(length);
-    }
-    const start = pos;
-    pos += length;
-    if (length < 24) {
-        return decodeUtf8Cached(start, length);
-    }
-    if (isBuffer) {
-        return payload.toString("utf-8", start, start + length);
-    }
-    return textDecoder.decode(payload.subarray(start, start + length));
-}
-function decodeUtf8Cached(at, length) {
-    let h = length;
-    for (let i = 0; i < length; ++i) {
-        h = (h * 31 + payload[at + i]) | 0;
-    }
-    const slot = (h >>> 0) & (STRING_CACHE_SIZE - 1);
-    const cached = stringCache[slot];
-    if (cached !== undefined && cached.length === length) {
-        let match = true;
-        for (let i = 0; i < length; ++i) {
-            if (cached.charCodeAt(i) !== payload[at + i]) {
-                match = false;
-                break;
-            }
-        }
-        if (match) {
-            stringCacheEpochs[slot] = cacheEpoch;
-            return cached;
-        }
-    }
-    const result = isBuffer
-        ? payload.toString("utf-8", at, at + length)
-        : textDecoder.decode(payload.subarray(at, at + length));
-    if (stringCacheEpochs[slot] !== cacheEpoch) {
-        stringCache[slot] = result;
-        stringCacheEpochs[slot] = cacheEpoch;
-    }
-    return result;
-}
-function readSpecial() {
-    const p = pos;
-    const minor = payload[p] & 0b0001_1111;
-    switch (minor) {
-        case specialTrue:
-            pos = p + 1;
-            return true;
-        case specialFalse:
-            pos = p + 1;
-            return false;
-        case specialNull:
-            pos = p + 1;
-            return null;
-        case specialUndefined:
-            pos = p + 1;
-            return null;
-        case extendedFloat16: {
-            if (end - p < 3) {
-                overflow(2);
-            }
-            pos = p + 3;
-            return bytesToFloat16(payload[p + 1], payload[p + 2]);
-        }
-        case extendedFloat32: {
-            if (end - p < 5) {
-                overflow(4);
-            }
-            pos = p + 5;
-            return dataView.getFloat32(p + 1);
-        }
-        case extendedFloat64: {
-            if (end - p < 9) {
-                overflow(8);
-            }
-            pos = p + 9;
-            return dataView.getFloat64(p + 1);
-        }
-        default:
-            throw new Error(`unexpected minor value ${minor} for major 7.`);
-    }
-}
-function bytesToFloat16(a, b) {
-    const sign = a >> 7;
-    const exponent = (a & 0b0111_1100) >> 2;
-    const fraction = ((a & 0b0000_0011) << 8) | b;
-    const scalar = sign === 0 ? 1 : -1;
-    if (exponent === 0b00000) {
-        if (fraction === 0) {
-            return 0;
-        }
-        return scalar * (Math.pow(2, 1 - 15) * (fraction / 1024));
-    }
-    else if (exponent === 0b11111) {
-        if (fraction === 0) {
-            return scalar * Infinity;
-        }
-        return NaN;
-    }
-    return scalar * (Math.pow(2, exponent - 15) * (1 + fraction / 1024));
-}
-function castBigInt(value) {
-    if (typeof value === "number") {
-        return value;
-    }
-    const num = Number(value);
-    if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
-        return num;
-    }
+    value.message = value.message ?? value.Message;
     return value;
-}
-function overflow(n) {
-    throw new Error(`CBOR: length ${n} greater than remaining buffer length.`);
-}
-function transformObject(ns, value) {
-    if (ns.isTimestampSchema()) {
-        if (typeof value === "number") {
-            return _parseEpochTimestamp(value);
+};
+const loadSmithyRpcV2CborErrorCode = (output, data) => {
+    const sanitizeErrorCode = (rawValue) => {
+        let cleanValue = rawValue;
+        if (typeof cleanValue === "number") {
+            cleanValue = cleanValue.toString();
         }
-        if (typeof value === "object" && value !== null) {
-            if (value.tag === 1 && "value" in value) {
-                return _parseEpochTimestamp(value.value);
-            }
+        if (cleanValue.indexOf(",") >= 0) {
+            cleanValue = cleanValue.split(",")[0];
         }
+        if (cleanValue.indexOf(":") >= 0) {
+            cleanValue = cleanValue.split(":")[0];
+        }
+        if (cleanValue.indexOf("#") >= 0) {
+            cleanValue = cleanValue.split("#")[1];
+        }
+        return cleanValue;
+    };
+    if (data["__type"] !== undefined) {
+        return sanitizeErrorCode(data["__type"]);
     }
-    if (ns.isBlobSchema()) {
-        return value;
-    }
-    if (typeof value === "undefined" ||
-        typeof value === "boolean" ||
-        typeof value === "number" ||
-        typeof value === "string" ||
-        typeof value === "bigint" ||
-        typeof value === "symbol") {
-        return value;
-    }
-    if (typeof value !== "object" || value === null) {
-        return value;
-    }
-    if ("byteLength" in value) {
-        return value;
-    }
-    if (value instanceof Date) {
-        return value;
+    let codeKey;
+    for (const key in data) {
+        if (key.toLowerCase() === "code") {
+            codeKey = key;
+            break;
+        }
     }
-    if (value instanceof NumericValue) {
-        return value;
+    if (codeKey && data[codeKey] !== undefined) {
+        return sanitizeErrorCode(data[codeKey]);
     }
-    if (ns.isDocumentSchema()) {
-        return value;
+};
+const checkCborResponse = (response) => {
+    if (String(response.headers["smithy-protocol"]).toLowerCase() !== "rpc-v2-cbor") {
+        throw new Error("Malformed RPCv2 CBOR response, status: " + response.statusCode);
     }
-    if (ns.isListSchema()) {
-        const memberSchema = ns.getValueSchema();
-        const out = [];
-        for (const item of value) {
-            out.push(transformObject(memberSchema, item));
-        }
-        return out;
+};
+const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
+    const endpoint = await context.endpoint();
+    const { hostname, protocol = "https", port, path: basePath } = endpoint;
+    const contents = {
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+        headers: {
+            ...headers,
+        },
+    };
+    if (resolvedHostname !== undefined) {
+        contents.hostname = resolvedHostname;
     }
-    const newObject = {};
-    if (ns.isMapSchema()) {
-        const targetSchema = ns.getValueSchema();
-        for (const key in value) {
-            if (!hasOwn(value, key))
-                continue;
-            newObject[key] = transformObject(targetSchema, value[key]);
+    if (endpoint.headers) {
+        for (const name in endpoint.headers) {
+            contents.headers[name] = endpoint.headers[name];
         }
     }
-    else if (ns.isStructSchema()) {
-        const isUnion = ns.isUnionSchema();
-        let keys;
-        if (isUnion) {
-            keys = new Set();
-            for (const k in value) {
-                if (!hasOwn(value, k))
-                    continue;
-                if (k !== "__type") {
-                    keys.add(k);
-                }
-            }
-        }
-        for (const [key, memberSchema] of ns.structIterator()) {
-            if (isUnion) {
-                keys.delete(key);
-            }
-            if (value[key] != null) {
-                newObject[key] = transformObject(memberSchema, value[key]);
-            }
-        }
-        if (isUnion && keys?.size === 1) {
-            let newObjectEmpty = true;
-            for (const _ in newObject) {
-                if (!hasOwn(newObject, _))
-                    continue;
-                newObjectEmpty = false;
-                break;
-            }
-            if (newObjectEmpty) {
-                const k = keys.values().next().value;
-                newObject.$unknown = [k, value[k]];
-            }
-        }
-        else if (typeof value.__type === "string") {
-            for (const k in value) {
-                if (!hasOwn(value, k))
-                    continue;
-                if (!(k in newObject)) {
-                    newObject[k] = value[k];
-                }
-            }
+    if (body !== undefined) {
+        contents.body = body;
+        try {
+            contents.headers["content-length"] = String(serde.calculateBodyLength(body));
         }
+        catch (e) { }
     }
-    return newObject;
-}
+    return new protocols.HttpRequest(contents);
+};
 
-class CborCodec extends SerdeContext {
+class CborCodec extends protocols.SerdeContext {
     createSerializer() {
-        const serializer = new CborShapeSerializer2();
+        const serializer = new CborShapeSerializer();
         serializer.setSerdeContext(this.serdeContext);
         return serializer;
     }
     createDeserializer() {
-        const deserializer = new CborShapeDeserializer2();
+        const deserializer = new CborShapeDeserializer();
         deserializer.setSerdeContext(this.serdeContext);
         return deserializer;
     }
 }
-
-class SmithyRpcV2CborProtocol extends RpcProtocol {
-    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);
-        }
-        else {
-            request.path += path;
-        }
-        return request;
-    }
-    async deserializeResponse(operationSchema, context, response) {
-        return super.deserializeResponse(operationSchema, context, response);
-    }
-    async handleError(operationSchema, context, response, dataObject, metadata) {
-        const errorName = loadSmithyRpcV2CborErrorCode(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 = {};
-        for (const [name, member] of ns.structIterator()) {
-            output[name] = this.deserializer.readValue(member, dataObject[name]);
-        }
-        throw Object.assign(exception, errorMetadata, {
-            $fault: ns.getMergedTraits().error,
-            message,
-        }, output);
-    }
-    getDefaultContentType() {
-        return "application/cbor";
-    }
-}
-
-class CborShapeSerializer extends SerdeContext {
+class CborShapeSerializer extends protocols.SerdeContext {
     value;
     write(schema, value) {
         this.value = this.serialize(schema, value);
     }
-    serialize(schema, source) {
-        const ns = NormalizedSchema.of(schema);
+    serialize(schema$1, source) {
+        const ns = schema.NormalizedSchema.of(schema$1);
         if (source == null) {
             if (ns.isIdempotencyToken()) {
-                return generateIdempotencyToken();
+                return serde.generateIdempotencyToken();
             }
             return source;
         }
         if (ns.isBlobSchema()) {
             if (typeof source === "string") {
-                return (this.serdeContext?.base64Decoder ?? fromBase64)(source);
+                return (this.serdeContext?.base64Decoder ?? serde.fromBase64)(source);
             }
             return source;
         }
@@ -2371,8 +846,6 @@ class CborShapeSerializer extends SerdeContext {
             if (ns.isMapSchema()) {
                 const sparse = !!ns.getMergedTraits().sparse;
                 for (const key in sourceObject) {
-                    if (!hasOwn(sourceObject, key))
-                        continue;
                     const value = this.serialize(ns.getValueSchema(), sourceObject[key]);
                     if (value != null || sparse) {
                         newObject[key] = value;
@@ -2393,8 +866,6 @@ class CborShapeSerializer extends SerdeContext {
                 }
                 else if (typeof sourceObject.__type === "string") {
                     for (const k in sourceObject) {
-                        if (!hasOwn(sourceObject, k))
-                            continue;
                         if (!(k in newObject)) {
                             newObject[k] = this.serialize(15, sourceObject[k]);
                         }
@@ -2402,17 +873,7 @@ class CborShapeSerializer extends SerdeContext {
                 }
             }
             else if (ns.isDocumentSchema()) {
-                if (Array.isArray(sourceObject)) {
-                    const newArray = [];
-                    let i = 0;
-                    for (const item of sourceObject) {
-                        newArray[i++] = this.serialize(ns.getValueSchema(), item);
-                    }
-                    return newArray;
-                }
                 for (const key in sourceObject) {
-                    if (!hasOwn(sourceObject, key))
-                        continue;
                     newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
                 }
             }
@@ -2429,27 +890,26 @@ class CborShapeSerializer extends SerdeContext {
         return buffer;
     }
 }
-
-class CborShapeDeserializer extends SerdeContext {
+class CborShapeDeserializer extends protocols.SerdeContext {
     read(schema, bytes) {
         const data = cbor.deserialize(bytes);
         return this.readValue(schema, data);
     }
     readValue(_schema, value) {
-        const ns = NormalizedSchema.of(_schema);
+        const ns = schema.NormalizedSchema.of(_schema);
         if (ns.isTimestampSchema()) {
             if (typeof value === "number") {
-                return _parseEpochTimestamp(value);
+                return serde._parseEpochTimestamp(value);
             }
             if (typeof value === "object") {
                 if (value.tag === 1 && "value" in value) {
-                    return _parseEpochTimestamp(value.value);
+                    return serde._parseEpochTimestamp(value.value);
                 }
             }
         }
         if (ns.isBlobSchema()) {
             if (typeof value === "string") {
-                return (this.serdeContext?.base64Decoder ?? fromBase64)(value);
+                return (this.serdeContext?.base64Decoder ?? serde.fromBase64)(value);
             }
             return value;
         }
@@ -2487,8 +947,6 @@ class CborShapeDeserializer extends SerdeContext {
             if (ns.isMapSchema()) {
                 const targetSchema = ns.getValueSchema();
                 for (const key in value) {
-                    if (!hasOwn(value, key))
-                        continue;
                     const itemValue = this.readValue(targetSchema, value[key]);
                     newObject[key] = itemValue;
                 }
@@ -2499,8 +957,6 @@ class CborShapeDeserializer extends SerdeContext {
                 if (isUnion) {
                     keys = new Set();
                     for (const k in value) {
-                        if (!hasOwn(value, k))
-                            continue;
                         if (k !== "__type") {
                             keys.add(k);
                         }
@@ -2517,8 +973,6 @@ class CborShapeDeserializer extends SerdeContext {
                 if (isUnion && keys?.size === 1) {
                     let newObjectEmpty = true;
                     for (const _ in newObject) {
-                        if (!hasOwn(newObject, _))
-                            continue;
                         newObjectEmpty = false;
                         break;
                     }
@@ -2529,15 +983,13 @@ class CborShapeDeserializer extends SerdeContext {
                 }
                 else if (typeof value.__type === "string") {
                     for (const k in value) {
-                        if (!hasOwn(value, k))
-                            continue;
                         if (!(k in newObject)) {
                             newObject[k] = value[k];
                         }
                     }
                 }
             }
-            else if (value instanceof NumericValue) {
+            else if (value instanceof serde.NumericValue) {
                 return value;
             }
             return newObject;
@@ -2548,11 +1000,104 @@ class CborShapeDeserializer extends SerdeContext {
     }
 }
 
+class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
+    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 (schema.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();
+            }
+            try {
+                request.headers["content-length"] = String(request.body.byteLength);
+            }
+            catch (e) { }
+        }
+        const { service, operation } = client.getSmithyContext(context);
+        const path = `/service/${service}/operation/${operation}`;
+        if (request.path.endsWith("/")) {
+            request.path += path.slice(1);
+        }
+        else {
+            request.path += path;
+        }
+        return request;
+    }
+    async deserializeResponse(operationSchema, context, response) {
+        return super.deserializeResponse(operationSchema, context, response);
+    }
+    async handleError(operationSchema, context, response, dataObject, metadata) {
+        const errorName = loadSmithyRpcV2CborErrorCode(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 = schema.TypeRegistry.for(namespace);
+        registry.copyFrom(nsRegistry);
+        let errorSchema;
+        try {
+            errorSchema = registry.getSchema(errorName);
+        }
+        catch (e) {
+            if (dataObject.Message) {
+                dataObject.message = dataObject.Message;
+            }
+            const syntheticRegistry = schema.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 = schema.NormalizedSchema.of(errorSchema);
+        const ErrorCtor = registry.getErrorCtor(errorSchema);
+        const message = dataObject.message ?? dataObject.Message ?? "Unknown";
+        const exception = new ErrorCtor({});
+        const output = {};
+        for (const [name, member] of ns.structIterator()) {
+            output[name] = this.deserializer.readValue(member, dataObject[name]);
+        }
+        throw Object.assign(exception, errorMetadata, {
+            $fault: ns.getMergedTraits().error,
+            message,
+        }, output);
+    }
+    getDefaultContentType() {
+        return "application/cbor";
+    }
+}
+
 exports.CborCodec = CborCodec;
 exports.CborShapeDeserializer = CborShapeDeserializer;
-exports.CborShapeDeserializer2 = CborShapeDeserializer2;
 exports.CborShapeSerializer = CborShapeSerializer;
-exports.CborShapeSerializer2 = CborShapeSerializer2;
 exports.SmithyRpcV2CborProtocol = SmithyRpcV2CborProtocol;
 exports.buildHttpRpcRequest = buildHttpRpcRequest;
 exports.cbor = cbor;