@funnycode/myclaude 0.1.156 → 0.1.158

package/dist/myclaude.js

@@ -4,8 +4,8 @@
 // MACRO - build-time constants (injected by build.ts)
 // MACRO injected by build script
 globalThis.MACRO = {
-  VERSION: "0.1.156",
-  BUILD_TIME: "2026-07-29T08:07:27.596Z",
+  VERSION: "0.1.158",
+  BUILD_TIME: "2026-07-29T16:07:05.507Z",
   PACKAGE_URL: "@funnycode/myclaude",
   NATIVE_PACKAGE_URL: "@funnycode/myclaude",
   VERSION_CHANGELOG: '',
@@ -85149,9 +85149,6 @@ var require_schema = __commonJS((exports) => {
       }
       struct2[anno.it] = it;
     }
-    structIteratorCbor() {
-      throw new Error("@smithy/core/schema - structIteratorCbor not loaded.");
-    }
   }
   function member(memberSchema, memberName) {
     if (memberSchema instanceof NormalizedSchema) {
@@ -97310,23 +97307,23 @@ var require_cbor = __commonJS((exports) => {
     data2[tagSymbol] = true;
     return data2;
   }
-  var USE_BUFFER$1 = typeof Buffer !== "undefined";
-  var textDecoder2 = new TextDecoder;
-  var payload = alloc(0);
-  var isBuffer3 = false;
-  var dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+  var USE_BUFFER$3 = typeof Buffer !== "undefined";
+  var textDecoder$1 = new TextDecoder;
+  var payload$1 = alloc(0);
+  var isBuffer$1 = false;
+  var dataView$2 = new DataView(payload$1.buffer, payload$1.byteOffset, payload$1.byteLength);
   var _offset = 0;
   function setPayload(bytes) {
-    payload = bytes;
-    isBuffer3 = USE_BUFFER$1 && payload instanceof Buffer;
-    dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    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);
   }
   function decode3(at, to) {
     if (at >= to) {
       throw new Error("unexpected end of (decode) payload.");
     }
-    const major = (payload[at] & 224) >> 5;
-    const minor = payload[at] & 31;
+    const major = (payload$1[at] & 224) >> 5;
+    const minor = payload$1[at] & 31;
     if (minor === minorIndefinite && 2 <= major && major <= 5) {
       return decodeIndefinite(at, to);
     }
@@ -97343,35 +97340,35 @@ var require_cbor = __commonJS((exports) => {
           switch (minor) {
             case extendedOneByte:
               if (to - at < 2) {
-                overflow(1);
+                overflow$1(1);
               }
-              unsignedInt = payload[at + 1];
+              unsignedInt = payload$1[at + 1];
               offset = 2;
               break;
             case extendedFloat16:
               if (to - at < 3) {
-                overflow(2);
+                overflow$1(2);
               }
-              unsignedInt = dataView$1.getUint16(at + 1);
+              unsignedInt = dataView$2.getUint16(at + 1);
               offset = 3;
               break;
             case extendedFloat32:
               if (to - at < 5) {
-                overflow(4);
+                overflow$1(4);
               }
-              unsignedInt = dataView$1.getUint32(at + 1);
+              unsignedInt = dataView$2.getUint32(at + 1);
               offset = 5;
               break;
             case extendedFloat64:
               if (to - at < 9) {
-                overflow(8);
+                overflow$1(8);
               }
               {
-                const hi = dataView$1.getUint32(at + 1);
+                const hi = dataView$2.getUint32(at + 1);
                 if (hi < 2097152) {
-                  unsignedInt = hi * 4294967296 + dataView$1.getUint32(at + 5);
+                  unsignedInt = hi * 4294967296 + dataView$2.getUint32(at + 5);
                 } else {
-                  unsignedInt = dataView$1.getBigUint64(at + 1);
+                  unsignedInt = dataView$2.getBigUint64(at + 1);
                 }
               }
               offset = 9;
@@ -97382,7 +97379,7 @@ var require_cbor = __commonJS((exports) => {
         }
         if (major === majorUint64) {
           _offset = offset;
-          return castBigInt(unsignedInt);
+          return castBigInt$1(unsignedInt);
         } else if (major === majorNegativeInt64) {
           let negativeInt;
           if (typeof unsignedInt === "bigint") {
@@ -97391,7 +97388,7 @@ var require_cbor = __commonJS((exports) => {
             negativeInt = -1 - unsignedInt;
           }
           _offset = offset;
-          return castBigInt(negativeInt);
+          return castBigInt$1(negativeInt);
         } else {
           return decodeTagValue(at, to, minor, unsignedInt, offset);
         }
@@ -97409,8 +97406,8 @@ var require_cbor = __commonJS((exports) => {
     }
   }
   function decodeIndefinite(at, to) {
-    const major = (payload[at] & 224) >> 5;
-    const minor = payload[at] & 31;
+    const major = (payload$1[at] & 224) >> 5;
+    const minor = payload$1[at] & 31;
     if (minor === minorIndefinite) {
       switch (major) {
         case majorUtf8String:
@@ -97424,7 +97421,7 @@ var require_cbor = __commonJS((exports) => {
       }
     }
   }
-  function bytesToFloat16(a2, b) {
+  function bytesToFloat16$1(a2, b) {
     const sign = a2 >> 7;
     const exponent = (a2 & 124) >> 2;
     const fraction = (a2 & 3) << 8 | b;
@@ -97443,7 +97440,7 @@ var require_cbor = __commonJS((exports) => {
     return scalar * (Math.pow(2, exponent - 15) * (1 + fraction / 1024));
   }
   function decodeMap(at, to) {
-    const mapDataLength = decodeCount(at, to);
+    const mapDataLength = decodeCount$1(at, to);
     if (mapDataLength < 25) {
       return decodeMapSmall(at, to, mapDataLength);
     }
@@ -97457,7 +97454,7 @@ var require_cbor = __commonJS((exports) => {
     for (let i2 = 0;i2 < mapDataLength; ++i2) {
       const key = decodeUtf8String(at, to);
       at += _offset;
-      const valMajor = (payload[at] & 224) >> 5;
+      const valMajor = (payload$1[at] & 224) >> 5;
       if (valMajor === majorUtf8String) {
         map2[key] = decodeUtf8String(at, to);
       } else {
@@ -97484,7 +97481,7 @@ var require_cbor = __commonJS((exports) => {
     return map2;
   }
   function decodeList(at, to) {
-    const listDataLength = decodeCount(at, to);
+    const listDataLength = decodeCount$1(at, to);
     const offset = _offset;
     at += offset;
     const base2 = at;
@@ -97497,74 +97494,74 @@ var require_cbor = __commonJS((exports) => {
     return list;
   }
   function decodeUtf8String(at, to) {
-    const length = decodeCount(at, to);
+    const length = decodeCount$1(at, to);
     const offset = _offset;
     at += offset;
     if (to - at < length) {
-      overflow(length);
+      overflow$1(length);
     }
     _offset = offset + length;
     if (length < 24) {
       return decodeUtf8StringCached(at, length);
     }
-    if (isBuffer3) {
-      return payload.toString("utf-8", at, at + length);
+    if (isBuffer$1) {
+      return payload$1.toString("utf-8", at, at + length);
     }
-    return textDecoder2.decode(payload.subarray(at, at + length));
+    return textDecoder$1.decode(payload$1.subarray(at, at + length));
   }
-  var stringCache = new Array(2048);
-  var stringCacheEpochs = new Uint16Array(2048);
-  var cacheEpoch = 0;
+  var stringCache$1 = new Array(2048);
+  var stringCacheEpochs$1 = new Uint16Array(2048);
+  var cacheEpoch$1 = 0;
   function advanceDecodingEpoch() {
-    cacheEpoch = cacheEpoch + 1 & 65535;
+    cacheEpoch$1 = cacheEpoch$1 + 1 & 65535;
   }
   function decodeUtf8StringCached(at, length) {
     let h2 = length;
     for (let i2 = 0;i2 < length; ++i2) {
-      h2 = h2 * 31 + payload[at + i2] | 0;
+      h2 = h2 * 31 + payload$1[at + i2] | 0;
     }
     const slot = h2 >>> 0 & 2047;
-    const cached2 = stringCache[slot];
+    const cached2 = stringCache$1[slot];
     if (cached2 !== undefined) {
       if (cached2.length === length) {
         let match = true;
         for (let i2 = 0;i2 < length; ++i2) {
-          if (cached2.charCodeAt(i2) !== payload[at + i2]) {
+          if (cached2.charCodeAt(i2) !== payload$1[at + i2]) {
             match = false;
             break;
           }
         }
         if (match) {
-          stringCacheEpochs[slot] = cacheEpoch;
+          stringCacheEpochs$1[slot] = cacheEpoch$1;
           return cached2;
         }
       }
     }
-    const result = isBuffer3 ? payload.toString("utf-8", at, at + length) : textDecoder2.decode(payload.subarray(at, at + length));
-    if (stringCacheEpochs[slot] !== cacheEpoch) {
-      stringCache[slot] = result;
-      stringCacheEpochs[slot] = cacheEpoch;
+    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;
   }
   function decodeUnstructuredByteString(at, to) {
-    const length = decodeCount(at, to);
+    const length = decodeCount$1(at, to);
     const offset = _offset;
     at += offset;
     if (to - at < length) {
-      overflow(length);
+      overflow$1(length);
     }
-    const value = payload.subarray(at, at + length);
+    const value = payload$1.subarray(at, at + length);
     _offset = offset + length;
     return value;
   }
   function decodeTagValue(at, to, minor, unsignedInt, offset) {
     if (minor === 2 || minor === 3) {
-      const length = decodeCount(at + offset, to);
+      const length = decodeCount$1(at + offset, to);
       let b = BigInt(0);
       const start = at + offset + _offset;
       for (let i2 = start;i2 < start + length; ++i2) {
-        b = b << BigInt(8) | BigInt(payload[i2]);
+        b = b << BigInt(8) | BigInt(payload$1[i2]);
       }
       _offset = offset + _offset + length;
       return minor === 3 ? -b - BigInt(1) : b;
@@ -97590,11 +97587,11 @@ var require_cbor = __commonJS((exports) => {
       const value = decode3(at + offset, to);
       const valueOffset = _offset;
       _offset = offset + valueOffset;
-      return tag({ tag: castBigInt(unsignedInt), value });
+      return tag({ tag: castBigInt$1(unsignedInt), value });
     }
   }
   function decodeSpecial(at, to) {
-    const minor = payload[at] & 31;
+    const minor = payload$1[at] & 31;
     switch (minor) {
       case specialTrue:
       case specialFalse:
@@ -97611,25 +97608,25 @@ var require_cbor = __commonJS((exports) => {
           throw new Error("incomplete float16 at end of buf.");
         }
         _offset = 3;
-        return bytesToFloat16(payload[at + 1], payload[at + 2]);
+        return bytesToFloat16$1(payload$1[at + 1], payload$1[at + 2]);
       case extendedFloat32:
         if (to - at < 5) {
           throw new Error("incomplete float32 at end of buf.");
         }
         _offset = 5;
-        return dataView$1.getFloat32(at + 1);
+        return dataView$2.getFloat32(at + 1);
       case extendedFloat64:
         if (to - at < 9) {
           throw new Error("incomplete float64 at end of buf.");
         }
         _offset = 9;
-        return dataView$1.getFloat64(at + 1);
+        return dataView$2.getFloat64(at + 1);
       default:
         unexpectedMinor(minor);
     }
   }
-  function decodeCount(at, to) {
-    const minor = payload[at] & 31;
+  function decodeCount$1(at, to) {
+    const minor = payload$1[at] & 31;
     if (minor < 24) {
       _offset = 1;
       return minor;
@@ -97637,28 +97634,28 @@ var require_cbor = __commonJS((exports) => {
     switch (minor) {
       case extendedOneByte:
         if (to - at < 2) {
-          overflow(1);
+          overflow$1(1);
         }
         _offset = 2;
-        return payload[at + 1];
+        return payload$1[at + 1];
       case extendedFloat16:
         if (to - at < 3) {
-          overflow(2);
+          overflow$1(2);
         }
         _offset = 3;
-        return dataView$1.getUint16(at + 1);
+        return dataView$2.getUint16(at + 1);
       case extendedFloat32:
         if (to - at < 5) {
-          overflow(4);
+          overflow$1(4);
         }
         _offset = 5;
-        return dataView$1.getUint32(at + 1);
+        return dataView$2.getUint32(at + 1);
       case extendedFloat64:
         if (to - at < 9) {
-          overflow(8);
+          overflow$1(8);
         }
         _offset = 9;
-        return demote(dataView$1.getBigUint64(at + 1));
+        return demote(dataView$2.getBigUint64(at + 1));
       default:
         unexpectedMinor(minor);
     }
@@ -97668,7 +97665,7 @@ var require_cbor = __commonJS((exports) => {
     const base2 = at;
     const map2 = {};
     for (;at < to; ) {
-      if (payload[at] === 255) {
+      if (payload$1[at] === 255) {
         _offset = at - base2 + 2;
         return map2;
       }
@@ -97683,7 +97680,7 @@ var require_cbor = __commonJS((exports) => {
     at += 1;
     const list = [];
     for (const base2 = at;at < to; ) {
-      if (payload[at] === 255) {
+      if (payload$1[at] === 255) {
         _offset = at - base2 + 2;
         return list;
       }
@@ -97696,17 +97693,17 @@ var require_cbor = __commonJS((exports) => {
     at += 1;
     const vector = [];
     for (const base2 = at;at < to; ) {
-      if (payload[at] === 255) {
+      if (payload$1[at] === 255) {
         const data2 = alloc(vector.length);
         data2.set(vector, 0);
         _offset = at - base2 + 2;
-        if (USE_BUFFER$1) {
+        if (USE_BUFFER$3) {
           return data2.toString("utf-8", 0, data2.length);
         }
-        return textDecoder2.decode(data2);
+        return textDecoder$1.decode(data2);
       }
-      const major = (payload[at] & 224) >> 5;
-      const minor = payload[at] & 31;
+      const major = (payload$1[at] & 224) >> 5;
+      const minor = payload$1[at] & 31;
       if (major !== majorUtf8String) {
         unexpectedMajorInIndefiniteString(major);
       }
@@ -97726,14 +97723,14 @@ var require_cbor = __commonJS((exports) => {
     at += 1;
     const vector = [];
     for (const base2 = at;at < to; ) {
-      if (payload[at] === 255) {
+      if (payload$1[at] === 255) {
         const data2 = alloc(vector.length);
         data2.set(vector, 0);
         _offset = at - base2 + 2;
         return data2;
       }
-      const major = (payload[at] & 224) >> 5;
-      const minor = payload[at] & 31;
+      const major = (payload$1[at] & 224) >> 5;
+      const minor = payload$1[at] & 31;
       if (major !== majorUnstructuredByteString) {
         unexpectedMajorInIndefiniteString(major);
       }
@@ -97749,7 +97746,7 @@ var require_cbor = __commonJS((exports) => {
     }
     throw new Error("expected break marker.");
   }
-  function castBigInt(bigInt) {
+  function castBigInt$1(bigInt) {
     if (typeof bigInt === "number") {
       return bigInt;
     }
@@ -97766,7 +97763,7 @@ var require_cbor = __commonJS((exports) => {
     }
     return num;
   }
-  function overflow(n2) {
+  function overflow$1(n2) {
     throw new Error(`length ${n2} greater than remaining buf len.`);
   }
   function unexpectedMinor(minor) {
@@ -97775,33 +97772,33 @@ var require_cbor = __commonJS((exports) => {
   function unexpectedMajorInIndefiniteString(major) {
     throw new Error(`unexpected major type ${major} in indefinite string.`);
   }
-  var USE_BUFFER = typeof Buffer !== "undefined";
+  var USE_BUFFER$2 = typeof Buffer !== "undefined";
   var encodeStringCache = new Map;
-  var encodeCacheEpoch = 0;
-  var encodeCacheSaturated = false;
+  var encodeCacheEpoch$1 = 0;
+  var encodeCacheSaturated$1 = false;
   var initialSize = 2048;
   var data = alloc(initialSize);
-  var dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
-  var cursor = 0;
+  var dataView$1 = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  var cursor$1 = 0;
   function encode6(_input) {
     const encodeStack = [_input];
     while (encodeStack.length) {
       const input = encodeStack.pop();
       if (typeof input === "string") {
         const len = input.length;
-        if (USE_BUFFER) {
+        if (USE_BUFFER$2) {
           ensureSpace(len * 3 + 9);
           if (len > 23) {
-            encodeHeader(majorUtf8String, Buffer.byteLength(input));
-            cursor += data.write(input, cursor);
+            encodeHeader$1(majorUtf8String, Buffer.byteLength(input));
+            cursor$1 += data.write(input, cursor$1);
           } else {
             encodeStringCached(input);
           }
         } else {
           const maxBytes = len * 3;
           ensureSpace(maxBytes + 9);
-          const headerPos = cursor;
-          const result = new TextEncoder().encodeInto(input, data.subarray(cursor + 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) {
@@ -97818,46 +97815,46 @@ var require_cbor = __commonJS((exports) => {
           if (headerSize < 9) {
             data.copyWithin(headerPos + headerSize, headerPos + 9, headerPos + 9 + byteLen);
           }
-          cursor = headerPos;
+          cursor$1 = headerPos;
           encodeInteger(majorUtf8String, byteLen);
-          cursor += byteLen;
+          cursor$1 += byteLen;
         }
         continue;
       }
-      if (data.byteLength - cursor < 9) {
+      if (data.byteLength - cursor$1 < 9) {
         ensureSpace(64);
       }
       if (typeof input === "number") {
-        if (Number.isInteger(input)) {
+        if (Number.isInteger(input) && input >= -9007199254740992 && input <= 9007199254740991) {
           const nonNegative = input >= 0;
           const major = nonNegative ? majorUint64 : majorNegativeInt64;
           const value = nonNegative ? input : -input - 1;
           if (value < 24) {
-            data[cursor++] = major << 5 | value;
+            data[cursor$1++] = major << 5 | value;
           } else if (value < 256) {
-            data[cursor++] = major << 5 | 24;
-            data[cursor++] = value;
+            data[cursor$1++] = major << 5 | 24;
+            data[cursor$1++] = value;
           } else if (value < 65536) {
-            data[cursor++] = major << 5 | extendedFloat16;
-            data[cursor++] = value >> 8;
-            data[cursor++] = value & 255;
+            data[cursor$1++] = major << 5 | extendedFloat16;
+            data[cursor$1++] = value >> 8;
+            data[cursor$1++] = value & 255;
           } else if (value < 4294967296) {
-            data[cursor++] = major << 5 | extendedFloat32;
-            dataView.setUint32(cursor, value);
-            cursor += 4;
+            data[cursor$1++] = major << 5 | extendedFloat32;
+            dataView$1.setUint32(cursor$1, value);
+            cursor$1 += 4;
           } else {
-            data[cursor++] = major << 5 | extendedFloat64;
+            data[cursor$1++] = major << 5 | extendedFloat64;
             const hi = value / 4294967296 | 0;
             const lo = value - hi * 4294967296 | 0;
-            dataView.setUint32(cursor, hi);
-            dataView.setUint32(cursor + 4, lo);
-            cursor += 8;
+            dataView$1.setUint32(cursor$1, hi);
+            dataView$1.setUint32(cursor$1 + 4, lo);
+            cursor$1 += 8;
           }
           continue;
         }
-        data[cursor++] = majorSpecial << 5 | extendedFloat64;
-        dataView.setFloat64(cursor, input);
-        cursor += 8;
+        data[cursor$1++] = majorSpecial << 5 | extendedFloat64;
+        dataView$1.setFloat64(cursor$1, input);
+        cursor$1 += 8;
         continue;
       } else if (typeof input === "bigint") {
         const nonNegative = input >= 0;
@@ -97868,9 +97865,9 @@ var require_cbor = __commonJS((exports) => {
           if (n2 < 4294967296) {
             encodeInteger(major, n2);
           } else {
-            data[cursor++] = major << 5 | extendedFloat64;
-            dataView.setBigUint64(cursor, value);
-            cursor += 8;
+            data[cursor$1++] = major << 5 | extendedFloat64;
+            dataView$1.setBigUint64(cursor$1, value);
+            cursor$1 += 8;
           }
         } else {
           const binaryBigInt = value.toString(2);
@@ -97882,17 +97879,17 @@ var require_cbor = __commonJS((exports) => {
             b >>= BigInt(8);
           }
           ensureSpace(bigIntBytes.byteLength * 2 + 16);
-          data[cursor++] = nonNegative ? 194 : 195;
-          encodeHeader(majorUnstructuredByteString, bigIntBytes.byteLength);
-          data.set(bigIntBytes, cursor);
-          cursor += bigIntBytes.byteLength;
+          data[cursor$1++] = nonNegative ? 194 : 195;
+          encodeHeader$1(majorUnstructuredByteString, bigIntBytes.byteLength);
+          data.set(bigIntBytes, cursor$1);
+          cursor$1 += bigIntBytes.byteLength;
         }
         continue;
       } else if (input === null) {
-        data[cursor++] = majorSpecial << 5 | specialNull;
+        data[cursor$1++] = majorSpecial << 5 | specialNull;
         continue;
       } else if (typeof input === "boolean") {
-        data[cursor++] = majorSpecial << 5 | (input ? specialTrue : specialFalse);
+        data[cursor$1++] = majorSpecial << 5 | (input ? specialTrue : specialFalse);
         continue;
       } else if (typeof input === "undefined") {
         throw new Error("@smithy/core/cbor: client may not serialize undefined value.");
@@ -97906,15 +97903,15 @@ var require_cbor = __commonJS((exports) => {
       } else if (typeof input.byteLength === "number") {
         ensureSpace(input.length * 2 + 9);
         encodeInteger(majorUnstructuredByteString, input.length);
-        data.set(input, cursor);
-        cursor += input.byteLength;
+        data.set(input, cursor$1);
+        cursor$1 += input.byteLength;
         continue;
       } else if (typeof input === "object") {
         if (input instanceof NumericValue) {
           const decimalIndex = input.string.indexOf(".");
           const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
           const mantissa = BigInt(input.string.replace(".", ""));
-          data[cursor++] = 196;
+          data[cursor$1++] = 196;
           encodeInteger(majorList, 2);
           encodeStack.push(mantissa);
           encodeStack.push(exponent);
@@ -97923,7 +97920,7 @@ var require_cbor = __commonJS((exports) => {
         if (input[tagSymbol]) {
           if ("tag" in input && "value" in input) {
             encodeStack.push(input.value);
-            encodeHeader(majorTag, input.tag);
+            encodeHeader$1(majorTag, input.tag);
             continue;
           } else {
             throw new Error("tag encountered with missing fields, need 'tag' and 'value', found: " + JSON.stringify(input));
@@ -97942,13 +97939,13 @@ var require_cbor = __commonJS((exports) => {
     }
   }
   function advanceEncodingEpoch() {
-    encodeCacheEpoch = encodeCacheEpoch + 1 & 65535;
-    encodeCacheSaturated = false;
+    encodeCacheEpoch$1 = encodeCacheEpoch$1 + 1 & 65535;
+    encodeCacheSaturated$1 = false;
   }
   function toUint8Array() {
-    const out = alloc(cursor);
-    out.set(data.subarray(0, cursor), 0);
-    cursor = 0;
+    const out = alloc(cursor$1);
+    out.set(data.subarray(0, cursor$1), 0);
+    cursor$1 = 0;
     return out;
   }
   function resize(size) {
@@ -97961,23 +97958,23 @@ var require_cbor = __commonJS((exports) => {
         data.set(old, 0);
       }
     }
-    dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    dataView$1 = new DataView(data.buffer, data.byteOffset, data.byteLength);
   }
   function encodeStringCached(input) {
     const cached2 = encodeStringCache.get(input);
     if (cached2 !== undefined) {
-      data.set(cached2.bytes, cursor);
-      cursor += cached2.bytes.length;
-      cached2.epoch = encodeCacheEpoch;
+      data.set(cached2.bytes, cursor$1);
+      cursor$1 += cached2.bytes.length;
+      cached2.epoch = encodeCacheEpoch$1;
       return;
     }
-    const start = cursor;
+    const start = cursor$1;
     const byteLen = Buffer.byteLength(input);
     encodeInteger(majorUtf8String, byteLen);
-    cursor += data.write(input, cursor);
-    const bytes = Uint8Array.prototype.slice.call(data, start, cursor);
+    cursor$1 += data.write(input, cursor$1);
+    const bytes = Uint8Array.prototype.slice.call(data, start, cursor$1);
     if (encodeStringCache.size >= 2048) {
-      if (encodeCacheSaturated) {
+      if (encodeCacheSaturated$1) {
         return;
       }
       let evicted = 0;
@@ -97985,71 +97982,71 @@ var require_cbor = __commonJS((exports) => {
         if (evicted >= 1024) {
           break;
         }
-        if (entry.epoch !== encodeCacheEpoch) {
+        if (entry.epoch !== encodeCacheEpoch$1) {
           encodeStringCache.delete(key);
           evicted++;
         }
       }
       if (evicted === 0) {
-        encodeCacheSaturated = true;
+        encodeCacheSaturated$1 = true;
         return;
       }
     }
     if (encodeStringCache.size < 2048) {
-      encodeStringCache.set(input, { epoch: encodeCacheEpoch, bytes });
+      encodeStringCache.set(input, { epoch: encodeCacheEpoch$1, bytes });
     }
   }
   function ensureSpace(bytes) {
-    const remaining = data.byteLength - cursor;
+    const remaining = data.byteLength - cursor$1;
     if (remaining < bytes) {
-      if (cursor < 16000000) {
+      if (cursor$1 < 16000000) {
         resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
       } else {
         resize(data.byteLength + bytes + 16000000);
       }
     }
   }
-  function encodeHeader(major, value) {
+  function encodeHeader$1(major, value) {
     if (value < 24) {
-      data[cursor++] = major << 5 | value;
+      data[cursor$1++] = major << 5 | value;
     } else if (value < 256) {
-      data[cursor++] = major << 5 | 24;
-      data[cursor++] = value;
+      data[cursor$1++] = major << 5 | 24;
+      data[cursor$1++] = value;
     } else if (value < 65536) {
-      data[cursor++] = major << 5 | extendedFloat16;
-      dataView.setUint16(cursor, value);
-      cursor += 2;
+      data[cursor$1++] = major << 5 | extendedFloat16;
+      dataView$1.setUint16(cursor$1, value);
+      cursor$1 += 2;
     } else if (value < 4294967296) {
-      data[cursor++] = major << 5 | extendedFloat32;
-      dataView.setUint32(cursor, value);
-      cursor += 4;
+      data[cursor$1++] = major << 5 | extendedFloat32;
+      dataView$1.setUint32(cursor$1, value);
+      cursor$1 += 4;
     } else {
-      data[cursor++] = major << 5 | extendedFloat64;
-      dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(value));
-      cursor += 8;
+      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++] = major << 5 | value;
+      data[cursor$1++] = major << 5 | value;
     } else if (value < 256) {
-      data[cursor++] = major << 5 | 24;
-      data[cursor++] = value;
+      data[cursor$1++] = major << 5 | 24;
+      data[cursor$1++] = value;
     } else if (value < 65536) {
-      data[cursor++] = major << 5 | extendedFloat16;
-      data[cursor++] = value >> 8;
-      data[cursor++] = value & 255;
+      data[cursor$1++] = major << 5 | extendedFloat16;
+      data[cursor$1++] = value >> 8;
+      data[cursor$1++] = value & 255;
     } else if (value < 4294967296) {
-      data[cursor++] = major << 5 | extendedFloat32;
-      dataView.setUint32(cursor, value);
-      cursor += 4;
+      data[cursor$1++] = major << 5 | extendedFloat32;
+      dataView$1.setUint32(cursor$1, value);
+      cursor$1 += 4;
     } else {
-      data[cursor++] = major << 5 | extendedFloat64;
+      data[cursor$1++] = major << 5 | extendedFloat64;
       const hi = value / 4294967296 | 0;
       const lo = value - hi * 4294967296 | 0;
-      dataView.setUint32(cursor, hi);
-      dataView.setUint32(cursor + 4, lo);
-      cursor += 8;
+      dataView$1.setUint32(cursor$1, hi);
+      dataView$1.setUint32(cursor$1 + 4, lo);
+      cursor$1 += 8;
     }
   }
   var cbor = {
@@ -98164,6 +98161,1278 @@ var require_cbor = __commonJS((exports) => {
     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 = allocUnsafe2(INITIAL_BUFFER_SIZE);
+      view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+      return result;
+    }
+  }
+  var 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 i2 = 0;i2 < memberNames.length; ++i2) {
+      encodedKeys[i2] = encodeCborStringKey(memberNames[i2]);
+    }
+    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 & 255;
+    }
+    result.set(utf8Bytes, headerSize);
+    return result;
+  }
+  var USE_BUFFER$1 = typeof Buffer !== "undefined";
+  var textEncoder4 = new TextEncoder;
+  var INITIAL_BUFFER_SIZE = 2048;
+  var buf = USE_BUFFER$1 ? Buffer.allocUnsafe(INITIAL_BUFFER_SIZE) : new Uint8Array(INITIAL_BUFFER_SIZE);
+  var view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  var cursor = 0;
+  var STRING_CACHE_MAX = 2048;
+  var stringEncodeCache = new Map;
+  var encodeCacheEpoch = 0;
+  var encodeCacheSaturated = false;
+  function allocUnsafe2(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 isObject5 = typeof value === "object";
+    if (isObject5) {
+      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 <= 9007199254740991) {
+        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 z3 = memberNames.length;
+    let headerSize;
+    if (z3 < 24) {
+      headerSize = 1;
+    } else if (z3 < 256) {
+      headerSize = 2;
+    } else {
+      headerSize = 3;
+    }
+    ensure(headerSize);
+    const headerPos = cursor;
+    cursor += headerSize;
+    let count3 = 0;
+    for (let i2 = 0;i2 < z3; ++i2) {
+      const item = value[memberNames[i2]];
+      if (item == null && !memberSchemas[i2].isIdempotencyToken()) {
+        continue;
+      }
+      const key = encodedKeys[i2];
+      ensure(key.length);
+      buf.set(key, cursor);
+      cursor += key.length;
+      writeValue(memberSchemas[i2], item, ns, serdeContext);
+      ++count3;
+    }
+    if (typeof value.__type === "string") {
+      for (const k in value) {
+        if (!memberNames.includes(k)) {
+          writeString(k);
+          writeUntypedValue(value[k]);
+          ++count3;
+        }
+      }
+    }
+    if (headerSize === 1) {
+      buf[headerPos] = majorMap << 5 | count3;
+    } else if (headerSize === 2) {
+      buf[headerPos] = majorMap << 5 | 24;
+      buf[headerPos + 1] = count3;
+    } else {
+      buf[headerPos] = majorMap << 5 | extendedFloat16;
+      buf[headerPos + 1] = count3 >> 8;
+      buf[headerPos + 2] = count3 & 255;
+    }
+  }
+  function writeList(ns, value, isDocument, serdeContext) {
+    const sparse = !!ns.getMergedTraits().sparse;
+    const valueSchema = ns.getValueSchema();
+    if (isDocument || sparse) {
+      const items = [];
+      for (let i2 = 0;i2 < value.length; ++i2) {
+        const item = value[i2];
+        if (isDocument) {
+          if (item !== undefined) {
+            items.push(item);
+          }
+        } else {
+          if (item != null || sparse) {
+            items.push(item);
+          }
+        }
+      }
+      ensure(9);
+      encodeHeader(majorList, items.length);
+      for (let i2 = 0;i2 < items.length; ++i2) {
+        writeValue(valueSchema, items[i2], undefined, serdeContext);
+      }
+    } else {
+      let count3 = 0;
+      for (let i2 = 0;i2 < value.length; ++i2) {
+        if (value[i2] != null) {
+          ++count3;
+        }
+      }
+      ensure(9);
+      encodeHeader(majorList, count3);
+      for (let i2 = 0;i2 < value.length; ++i2) {
+        if (value[i2] != null) {
+          writeValue(valueSchema, value[i2], undefined, serdeContext);
+        }
+      }
+    }
+  }
+  function writeMap(ns, value, isDocument, serdeContext) {
+    const sparse = !!ns.getMergedTraits().sparse;
+    const valueSchema = ns.getValueSchema();
+    const keys2 = [];
+    for (const k in value) {
+      const v = value[k];
+      if (isDocument ? v !== undefined : v != null || sparse) {
+        keys2.push(k);
+      }
+    }
+    ensure(9);
+    encodeHeader(majorMap, keys2.length);
+    for (let i2 = 0;i2 < keys2.length; ++i2) {
+      const k = keys2[i2];
+      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 <= 9007199254740991) {
+        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 i2 = 0;i2 < value.length; ++i2) {
+        writeUntypedValue(value[i2]);
+      }
+      return;
+    }
+    if (typeof value === "object") {
+      const keys2 = Object.keys(value);
+      ensure(9);
+      encodeHeader(majorMap, keys2.length);
+      for (let i2 = 0;i2 < keys2.length; ++i2) {
+        writeString(keys2[i2]);
+        writeUntypedValue(value[keys2[i2]]);
+      }
+      return;
+    }
+    writeString(String(value));
+  }
+  function ensure(n2) {
+    if (cursor + n2 > buf.length) {
+      let newSize = buf.length * 2;
+      while (newSize < cursor + n2) {
+        newSize *= 2;
+      }
+      const next = allocUnsafe2(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 & 255;
+    } 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 n2 = Number(value);
+    if (n2 < 4294967296) {
+      encodeHeader(major, n2);
+      return;
+    }
+    buf[cursor++] = major << 5 | extendedFloat64;
+    view.setBigUint64(cursor, value);
+    cursor += 8;
+  }
+  function writeString(s) {
+    const len = s.length;
+    if (len <= 23) {
+      const cached2 = stringEncodeCache.get(s);
+      if (cached2) {
+        ensure(cached2.bytes.length);
+        buf.set(cached2.bytes, cursor);
+        cursor += cached2.bytes.length;
+        cached2.epoch = encodeCacheEpoch;
+        return;
+      }
+      const start = cursor;
+      writeStringUncached(s, len);
+      const end2 = cursor;
+      const bytes = Uint8Array.prototype.slice.call(buf, start, end2);
+      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 = textEncoder4.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 i2 = byteLen - 1;i2 >= 0; --i2) {
+        bigIntBytes[i2] = Number(b & BigInt(255));
+        b >>= BigInt(8);
+      }
+      ensure(byteLen + 16);
+      buf[cursor++] = nonNegative ? 194 : 195;
+      encodeHeader(majorUnstructuredByteString, byteLen);
+      buf.set(bigIntBytes, cursor);
+      cursor += byteLen;
+    }
+  }
+  function writeBytes(data2) {
+    ensure(data2.length + 9);
+    encodeHeader(majorUnstructuredByteString, data2.length);
+    buf.set(data2, cursor);
+    cursor += data2.length;
+  }
+  function writeTag(tagValue, innerValue) {
+    ensure(9);
+    if (typeof tagValue === "bigint") {
+      encodeBigHeader(majorTag, tagValue);
+    } else {
+      encodeHeader(majorTag, tagValue);
+    }
+    writeUntypedValue(innerValue);
+  }
+  function writeNumericValue(nv2) {
+    const decimalIndex = nv2.string.indexOf(".");
+    const exponent = decimalIndex === -1 ? 0 : decimalIndex - nv2.string.length + 1;
+    const mantissa = BigInt(nv2.string.replace(".", ""));
+    ensure(9);
+    buf[cursor++] = 196;
+    encodeHeader(majorList, 2);
+    ensure(9);
+    writeInteger(exponent);
+    writeBigInt(mantissa);
+  }
+  function writeTimestamp(date5) {
+    ensure(18);
+    encodeHeader(majorTag, 1);
+    const epochSecs = date5.getTime() / 1000;
+    if (Number.isInteger(epochSecs)) {
+      writeInteger(epochSecs);
+    } else {
+      writeFloat64(epochSecs);
+    }
+  }
+
+  class CborShapeDeserializer2 extends SerdeContext {
+    read(schema, bytes) {
+      payload = bytes;
+      isBuffer3 = USE_BUFFER && bytes instanceof Buffer;
+      dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      pos = 0;
+      end = bytes.length;
+      cacheEpoch = cacheEpoch + 1 & 65535;
+      return readValue(NormalizedSchema.of(schema));
+    }
+    readValue(_schema, value) {
+      return transformObject(NormalizedSchema.of(_schema), value);
+    }
+  }
+  var USE_BUFFER = typeof Buffer !== "undefined";
+  var textDecoder2 = new TextDecoder;
+  var payload = new Uint8Array(0);
+  var isBuffer3 = false;
+  var dataView = new DataView(new ArrayBuffer(0));
+  var pos = 0;
+  var end = 0;
+  var STRING_CACHE_SIZE = 2048;
+  var stringCache = new Array(STRING_CACHE_SIZE);
+  var stringCacheEpochs = new Uint16Array(STRING_CACHE_SIZE);
+  var cacheEpoch = 0;
+  function readValue(ns) {
+    if (pos >= end) {
+      throw new Error("unexpected end of CBOR payload.");
+    }
+    const major = (payload[pos] & 224) >> 5;
+    const minor = payload[pos] & 31;
+    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 count3 = decodeCount();
+    const memberSchema = ns.isListSchema() ? ns.getValueSchema() : ns;
+    const list = Array(count3);
+    for (let i2 = 0;i2 < count3; ++i2) {
+      list[i2] = readValue(memberSchema);
+    }
+    return list;
+  }
+  function readMap(ns) {
+    const count3 = decodeCount();
+    if (ns.isStructSchema()) {
+      const startPos = pos;
+      return readStruct(ns, count3, startPos);
+    }
+    const valueSchema = ns.isMapSchema() ? ns.getValueSchema() : ns;
+    const map2 = {};
+    for (let i2 = 0;i2 < count3; ++i2) {
+      const key = readUtf8String();
+      map2[key] = readValue(valueSchema);
+    }
+    return map2;
+  }
+  function readStruct(ns, count3, startPos) {
+    const isUnion = ns.isUnionSchema();
+    const cache = loadCborStructIterator(ns);
+    const { memberSchemas, encodedKeys, memberNames } = cache;
+    const z3 = encodedKeys.length;
+    const result = {};
+    let unknownKey;
+    let unknownValue;
+    let unknownCount = 0;
+    let hasType = false;
+    let hint = 0;
+    for (let i2 = 0;i2 < count3; ++i2) {
+      const matchIdx = matchStructKey(encodedKeys, z3, hint);
+      if (matchIdx >= 0) {
+        hint = matchIdx + 1;
+        if (hint >= z3) {
+          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) {
+        resultEmpty = false;
+        break;
+      }
+      if (resultEmpty && unknownCount === 1) {
+        result.$unknown = [unknownKey, unknownValue];
+      }
+    } else if (hasType) {
+      pos = startPos;
+      const docSchema = NormalizedSchema.of(15);
+      for (let i2 = 0;i2 < count3; ++i2) {
+        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 docSchema2 = NormalizedSchema.of(15);
+      const epochValue = readValue(docSchema2);
+      return _parseEpochTimestamp(epochValue);
+    }
+    if (tagNumber === 2 || tagNumber === 3) {
+      const byteStr = readByteString();
+      let b = BigInt(0);
+      for (let i2 = 0;i2 < byteStr.length; ++i2) {
+        b = b << BigInt(8) | BigInt(byteStr[i2]);
+      }
+      return tagNumber === 3 ? -b - BigInt(1) : b;
+    }
+    if (tagNumber === 4) {
+      const docSchema2 = NormalizedSchema.of(15);
+      const pair = readValue(docSchema2);
+      const [exponent, mantissa] = pair;
+      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;
+      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] === 255) {
+        pos += 1;
+        const combined = new Uint8Array(totalLen);
+        let offset = 0;
+        for (let i2 = 0;i2 < chunks.length; ++i2) {
+          combined.set(chunks[i2], offset);
+          offset += chunks[i2].length;
+        }
+        if (USE_BUFFER) {
+          return Buffer.from(combined.buffer, combined.byteOffset, combined.byteLength).toString("utf-8");
+        }
+        return textDecoder2.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] === 255) {
+        pos += 1;
+        const combined = new Uint8Array(totalLen);
+        let offset = 0;
+        for (let i2 = 0;i2 < chunks.length; ++i2) {
+          combined.set(chunks[i2], offset);
+          offset += chunks[i2].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] === 255) {
+        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 z3 = encodedKeys.length;
+      const isUnion = ns.isUnionSchema();
+      const result = {};
+      let unknownKey;
+      let unknownValue;
+      let unknownCount = 0;
+      let hint = 0;
+      while (pos < end) {
+        if (payload[pos] === 255) {
+          pos += 1;
+          if (isUnion) {
+            let resultEmpty = true;
+            for (const _ in result) {
+              resultEmpty = false;
+              break;
+            }
+            if (resultEmpty && unknownCount === 1) {
+              result.$unknown = [unknownKey, unknownValue];
+            }
+          }
+          return result;
+        }
+        const matchIdx = matchStructKey(encodedKeys, z3, hint);
+        if (matchIdx >= 0) {
+          hint = matchIdx + 1;
+          if (hint >= z3) {
+            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 map2 = {};
+    while (pos < end) {
+      if (payload[pos] === 255) {
+        pos += 1;
+        return map2;
+      }
+      const key = readUtf8String();
+      map2[key] = readValue(valueSchema);
+    }
+    throw new Error("expected break marker.");
+  }
+  function matchStructKey(encodedKeys, z3, hint) {
+    const hintKey = encodedKeys[hint];
+    if (pos + hintKey.length <= end && bytesMatch(pos, hintKey)) {
+      pos += hintKey.length;
+      return hint;
+    }
+    for (let i2 = 0;i2 < z3; ++i2) {
+      if (i2 === hint) {
+        continue;
+      }
+      const ek = encodedKeys[i2];
+      if (pos + ek.length <= end && bytesMatch(pos, ek)) {
+        pos += ek.length;
+        return i2;
+      }
+    }
+    return -1;
+  }
+  function bytesMatch(at, expected) {
+    const len = expected.length;
+    if (payload[at] !== expected[0]) {
+      return false;
+    }
+    for (let i2 = 1;i2 < len; ++i2) {
+      if (payload[at + i2] !== expected[i2]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function decodeArgument() {
+    const minor = payload[pos] & 31;
+    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 < 2097152) {
+          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 (isBuffer3) {
+      return payload.toString("utf-8", start, start + length);
+    }
+    return textDecoder2.decode(payload.subarray(start, start + length));
+  }
+  function decodeUtf8Cached(at, length) {
+    let h2 = length;
+    for (let i2 = 0;i2 < length; ++i2) {
+      h2 = h2 * 31 + payload[at + i2] | 0;
+    }
+    const slot = h2 >>> 0 & STRING_CACHE_SIZE - 1;
+    const cached2 = stringCache[slot];
+    if (cached2 !== undefined && cached2.length === length) {
+      let match = true;
+      for (let i2 = 0;i2 < length; ++i2) {
+        if (cached2.charCodeAt(i2) !== payload[at + i2]) {
+          match = false;
+          break;
+        }
+      }
+      if (match) {
+        stringCacheEpochs[slot] = cacheEpoch;
+        return cached2;
+      }
+    }
+    const result = isBuffer3 ? payload.toString("utf-8", at, at + length) : textDecoder2.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] & 31;
+    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(a2, b) {
+    const sign = a2 >> 7;
+    const exponent = (a2 & 124) >> 2;
+    const fraction = (a2 & 3) << 8 | b;
+    const scalar = sign === 0 ? 1 : -1;
+    if (exponent === 0) {
+      if (fraction === 0) {
+        return 0;
+      }
+      return scalar * (Math.pow(2, 1 - 15) * (fraction / 1024));
+    } else if (exponent === 31) {
+      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;
+    }
+    return value;
+  }
+  function overflow(n2) {
+    throw new Error(`CBOR: length ${n2} greater than remaining buffer length.`);
+  }
+  function transformObject(ns, value) {
+    if (ns.isTimestampSchema()) {
+      if (typeof value === "number") {
+        return _parseEpochTimestamp(value);
+      }
+      if (typeof value === "object" && value !== null) {
+        if (value.tag === 1 && "value" in value) {
+          return _parseEpochTimestamp(value.value);
+        }
+      }
+    }
+    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;
+    }
+    if (value instanceof NumericValue) {
+      return value;
+    }
+    if (ns.isDocumentSchema()) {
+      return value;
+    }
+    if (ns.isListSchema()) {
+      const memberSchema = ns.getValueSchema();
+      const out = [];
+      for (const item of value) {
+        out.push(transformObject(memberSchema, item));
+      }
+      return out;
+    }
+    const newObject = {};
+    if (ns.isMapSchema()) {
+      const targetSchema = ns.getValueSchema();
+      for (const key in value) {
+        newObject[key] = transformObject(targetSchema, value[key]);
+      }
+    } else if (ns.isStructSchema()) {
+      const isUnion = ns.isUnionSchema();
+      let keys2;
+      if (isUnion) {
+        keys2 = new Set;
+        for (const k in value) {
+          if (k !== "__type") {
+            keys2.add(k);
+          }
+        }
+      }
+      for (const [key, memberSchema] of ns.structIterator()) {
+        if (isUnion) {
+          keys2.delete(key);
+        }
+        if (value[key] != null) {
+          newObject[key] = transformObject(memberSchema, value[key]);
+        }
+      }
+      if (isUnion && keys2?.size === 1) {
+        let newObjectEmpty = true;
+        for (const _ in newObject) {
+          newObjectEmpty = false;
+          break;
+        }
+        if (newObjectEmpty) {
+          const k = keys2.values().next().value;
+          newObject.$unknown = [k, value[k]];
+        }
+      } else if (typeof value.__type === "string") {
+        for (const k in value) {
+          if (!(k in newObject)) {
+            newObject[k] = value[k];
+          }
+        }
+      }
+    }
+    return newObject;
+  }
+
+  class CborCodec extends SerdeContext {
+    createSerializer() {
+      const serializer = new CborShapeSerializer2;
+      serializer.setSerdeContext(this.serdeContext);
+      return serializer;
+    }
+    createDeserializer() {
+      const deserializer = new CborShapeDeserializer2;
+      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();
+        }
+        try {
+          request.headers["content-length"] = String(request.body.byteLength);
+        } catch (ignored) {}
+      }
+      const { service, operation } = getSmithyContext(context);
+      const path12 = `/service/${service}/operation/${operation}`;
+      if (request.path.endsWith("/")) {
+        request.path += path12.slice(1);
+      } else {
+        request.path += path12;
+      }
+      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 registry2 = this.compositeErrorRegistry;
+      const nsRegistry = TypeRegistry.for(namespace);
+      registry2.copyFrom(nsRegistry);
+      let errorSchema;
+      try {
+        errorSchema = registry2.getSchema(errorName);
+      } catch (ignored) {
+        if (dataObject.Message) {
+          dataObject.message = dataObject.Message;
+        }
+        const syntheticRegistry = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
+        registry2.copyFrom(syntheticRegistry);
+        const baseExceptionSchema = registry2.getBaseException();
+        if (baseExceptionSchema) {
+          const ErrorCtor2 = registry2.getErrorCtor(baseExceptionSchema);
+          throw Object.assign(new ErrorCtor2({ name: errorName }), errorMetadata, dataObject);
+        }
+        throw Object.assign(new Error(errorName), errorMetadata, dataObject);
+      }
+      const ns = NormalizedSchema.of(errorSchema);
+      const ErrorCtor = registry2.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 {
     value;
     write(schema, value) {
@@ -98234,6 +99503,14 @@ var require_cbor = __commonJS((exports) => {
             }
           }
         } else if (ns.isDocumentSchema()) {
+          if (Array.isArray(sourceObject)) {
+            const newArray = [];
+            let i2 = 0;
+            for (const item of sourceObject) {
+              newArray[i2++] = this.serialize(ns.getValueSchema(), item);
+            }
+            return newArray;
+          }
           for (const key in sourceObject) {
             newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
           }
@@ -98350,113 +99627,11 @@ var require_cbor = __commonJS((exports) => {
       }
     }
   }
-
-  class CborCodec extends SerdeContext {
-    createSerializer() {
-      const serializer = new CborShapeSerializer;
-      serializer.setSerdeContext(this.serdeContext);
-      return serializer;
-    }
-    createDeserializer() {
-      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();
-        }
-        try {
-          request.headers["content-length"] = String(request.body.byteLength);
-        } catch (ignored) {}
-      }
-      const { service, operation } = getSmithyContext(context);
-      const path12 = `/service/${service}/operation/${operation}`;
-      if (request.path.endsWith("/")) {
-        request.path += path12.slice(1);
-      } else {
-        request.path += path12;
-      }
-      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 registry2 = this.compositeErrorRegistry;
-      const nsRegistry = TypeRegistry.for(namespace);
-      registry2.copyFrom(nsRegistry);
-      let errorSchema;
-      try {
-        errorSchema = registry2.getSchema(errorName);
-      } catch (ignored) {
-        if (dataObject.Message) {
-          dataObject.message = dataObject.Message;
-        }
-        const syntheticRegistry = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
-        registry2.copyFrom(syntheticRegistry);
-        const baseExceptionSchema = registry2.getBaseException();
-        if (baseExceptionSchema) {
-          const ErrorCtor2 = registry2.getErrorCtor(baseExceptionSchema);
-          throw Object.assign(new ErrorCtor2({ name: errorName }), errorMetadata, dataObject);
-        }
-        throw Object.assign(new Error(errorName), errorMetadata, dataObject);
-      }
-      const ns = NormalizedSchema.of(errorSchema);
-      const ErrorCtor = registry2.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;
@@ -117990,7 +119165,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@funnycode/myclaude",
-    version: "0.1.156",
+    version: "0.1.158",
     private: false,
     description: "An open-source AI coding assistant in your terminal - powered by Claude",
     license: "MIT",
@@ -408175,6 +409350,7 @@ import { join as join105 } from "path";
 function clearCachedSteps() {
   cachedSteps = null;
   cachedClaudeMdMtime = null;
+  cachedDirMtime = null;
   cachedAt = null;
 }
 function isCacheValid() {
@@ -408190,6 +409366,13 @@ function isCacheValid() {
   } catch {
     return false;
   }
+  try {
+    const currentDirMtime = getFileModificationTime(cwd2);
+    if (currentDirMtime !== cachedDirMtime)
+      return false;
+  } catch {
+    return false;
+  }
   if (cachedAt !== null && Date.now() - cachedAt > CACHE_MAX_AGE_MS) {
     return false;
   }
@@ -408209,6 +409392,11 @@ function getSteps() {
   } catch {
     cachedClaudeMdMtime = -1;
   }
+  try {
+    cachedDirMtime = getFileModificationTime(cwd2);
+  } catch {
+    cachedDirMtime = -1;
+  }
   cachedAt = Date.now();
   cachedSteps = [
     {
@@ -408255,7 +409443,7 @@ function incrementProjectOnboardingSeenCount() {
     projectOnboardingSeenCount: current.projectOnboardingSeenCount + 1
   }));
 }
-var cachedSteps = null, cachedClaudeMdMtime = null, cachedAt = null, CACHE_MAX_AGE_MS = 30000;
+var cachedSteps = null, cachedClaudeMdMtime = null, cachedDirMtime = null, cachedAt = null, CACHE_MAX_AGE_MS = 30000;
 var init_projectOnboardingState = __esm(() => {
   init_config();
   init_cwd2();
@@ -564590,7 +565778,6 @@ function migrateEnableAllProjectMcpServersToSettings() {
     });
   } catch (error49) {
     logError2("Failed to migrate MCP server settings, rolling back", error49);
-    const currentSettings = getSettingsForSource("localSettings") || {};
     let rollbackFailed = false;
     const rollbackUpdates = {};
     const migratedFields = [
@@ -564624,13 +565811,7 @@ function migrateEnableAllProjectMcpServersToSettings() {
     } catch (rollbackError) {
       logError2("Rollback of project config failed", rollbackError);
       rollbackFailed = true;
-      if (settingsRollbackSucceeded) {
-        try {
-          updateSettingsForSource("localSettings", currentSettings);
-        } catch (undoError) {
-          logError2("Failed to undo settings rollback after project config rollback failure", undoError);
-        }
-      }
+      logError2("Settings rollback succeeded but project config rollback failed. " + "System is in an inconsistent state. Manual intervention may be required.", rollbackError);
     }
     if (rollbackFailed) {
       throw new Error("Migration failed and rollback was incomplete. The system may be in an inconsistent state. " + "Original error: " + (error49 instanceof Error ? error49.message : String(error49)));