@funnycode/myclaude 0.1.158 → 0.1.159

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.158",
-  BUILD_TIME: "2026-07-29T16:07:05.507Z",
+  VERSION: "0.1.159",
+  BUILD_TIME: "2026-07-29T23:20:13.620Z",
   PACKAGE_URL: "@funnycode/myclaude",
   NATIVE_PACKAGE_URL: "@funnycode/myclaude",
   VERSION_CHANGELOG: '',
@@ -100201,55 +100201,6 @@ var require_protocols2 = __commonJS((exports) => {
       }, output), dataObject);
     }
   }
-  var _toStr = (val) => {
-    if (val == null) {
-      return val;
-    }
-    if (typeof val === "number" || typeof val === "bigint") {
-      const warning = new Error(`Received number ${val} where a string was expected.`);
-      warning.name = "Warning";
-      console.warn(warning);
-      return String(val);
-    }
-    if (typeof val === "boolean") {
-      const warning = new Error(`Received boolean ${val} where a string was expected.`);
-      warning.name = "Warning";
-      console.warn(warning);
-      return String(val);
-    }
-    return val;
-  };
-  var _toBool = (val) => {
-    if (val == null) {
-      return val;
-    }
-    if (typeof val === "string") {
-      const lowercase2 = val.toLowerCase();
-      if (val !== "" && lowercase2 !== "false" && lowercase2 !== "true") {
-        const warning = new Error(`Received string "${val}" where a boolean was expected.`);
-        warning.name = "Warning";
-        console.warn(warning);
-      }
-      return val !== "" && lowercase2 !== "false";
-    }
-    return val;
-  };
-  var _toNum = (val) => {
-    if (val == null) {
-      return val;
-    }
-    if (typeof val === "string") {
-      const num = Number(val);
-      if (num.toString() !== val) {
-        const warning = new Error(`Received string "${val}" where a number was expected.`);
-        warning.name = "Warning";
-        console.warn(warning);
-        return val;
-      }
-      return num;
-    }
-    return val;
-  };
 
   class SerdeContextConfig {
     serdeContext;
@@ -101048,15 +100999,667 @@ var require_protocols2 = __commonJS((exports) => {
       return "application/json";
     }
   }
-  var awsExpectUnion = (value) => {
-    if (value == null) {
-      return;
+
+  class JsonShapeDeserializer2 extends SerdeContextConfig {
+    settings;
+    constructor(settings) {
+      super();
+      this.settings = settings;
     }
-    if (typeof value === "object" && "__type" in value) {
-      delete value.__type;
+    async read(schema, data) {
+      const reviver = needsReviver(schema) ? jsonReviver : undefined;
+      let parsed;
+      if (typeof data === "string") {
+        parsed = JSON.parse(data, reviver);
+      } else if (data instanceof Uint8Array && detectBufferParsing()) {
+        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+        parsed = JSON.parse(buf, reviver);
+      } else {
+        parsed = await parseJsonBody(data, this.serdeContext);
+      }
+      return this._read(schema, parsed);
     }
-    return expectUnion(value);
-  };
+    readObject(schema, data) {
+      return this._read(schema, data);
+    }
+    _read(schema, value) {
+      const isObject5 = value !== null && typeof value === "object";
+      const ns = NormalizedSchema.of(schema);
+      if (isObject5) {
+        if (ns.isStructSchema()) {
+          return this._readStruct(ns, value);
+        }
+        if (Array.isArray(value) && ns.isListSchema()) {
+          const listMember = ns.getValueSchema();
+          for (let i2 = 0;i2 < value.length; ++i2) {
+            value[i2] = this._read(listMember, value[i2]);
+          }
+          return value;
+        }
+        if (ns.isMapSchema()) {
+          const mapMember = ns.getValueSchema();
+          const map2 = value;
+          for (const k in map2) {
+            if (k === "__proto__") {
+              writeKey(map2);
+            }
+            map2[k] = this._read(mapMember, map2[k]);
+          }
+          return map2;
+        }
+      }
+      if (ns.isBlobSchema() && typeof value === "string") {
+        return fromBase64(value);
+      }
+      const mediaType = ns.getMergedTraits().mediaType;
+      if (ns.isStringSchema() && typeof value === "string" && mediaType) {
+        const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
+        if (isJson) {
+          return LazyJsonString.from(value);
+        }
+        return value;
+      }
+      if (ns.isTimestampSchema() && value != null) {
+        const format3 = determineTimestampFormat(ns, this.settings);
+        switch (format3) {
+          case 5:
+            return parseRfc3339DateTimeWithOffset(value);
+          case 6:
+            return parseRfc7231DateTime(value);
+          case 7:
+            return parseEpochTimestamp(value);
+          default:
+            console.warn("Missing timestamp format, parsing value with Date constructor:", value);
+            return new Date(value);
+        }
+      }
+      if (ns.isBigIntegerSchema() && (typeof value === "number" || typeof value === "string")) {
+        return BigInt(value);
+      }
+      if (ns.isBigDecimalSchema() && value != null) {
+        if (value instanceof NumericValue) {
+          return value;
+        }
+        const untyped = value;
+        if (untyped.type === "bigDecimal" && "string" in untyped) {
+          return new NumericValue(untyped.string, untyped.type);
+        }
+        return new NumericValue(String(value), "bigDecimal");
+      }
+      if (ns.isNumericSchema() && typeof value === "string") {
+        switch (value) {
+          case "Infinity":
+            return Infinity;
+          case "-Infinity":
+            return -Infinity;
+          case "NaN":
+            return NaN;
+        }
+        return value;
+      }
+      if (ns.isDocumentSchema()) {
+        if (isObject5) {
+          if (Array.isArray(value)) {
+            for (let i2 = 0;i2 < value.length; ++i2) {
+              const v = value[i2];
+              if (!(v instanceof NumericValue)) {
+                value[i2] = this._read(ns, v);
+              }
+            }
+          } else {
+            const doc2 = value;
+            for (const k in doc2) {
+              if (k === "__proto__") {
+                writeKey(doc2);
+              }
+              const v = doc2[k];
+              if (!(v instanceof NumericValue)) {
+                doc2[k] = this._read(ns, v);
+              }
+            }
+          }
+          return value;
+        } else {
+          return value;
+        }
+      }
+      return value;
+    }
+    _readStruct(ns, record2) {
+      const union2 = ns.isUnionSchema();
+      const out = {};
+      let nameMap = undefined;
+      const { jsonName } = this.settings;
+      if (jsonName) {
+        nameMap = {};
+      }
+      let unionSerde;
+      if (union2) {
+        unionSerde = new UnionSerde(record2, out);
+      }
+      for (const [memberName, memberSchema] of ns.structIterator()) {
+        let fromKey = memberName;
+        if (jsonName) {
+          fromKey = memberSchema.getMergedTraits().jsonName ?? fromKey;
+          nameMap[fromKey] = memberName;
+        }
+        if (union2) {
+          unionSerde.mark(fromKey);
+        }
+        if (record2[fromKey] != null) {
+          out[memberName] = this._read(memberSchema, record2[fromKey]);
+        }
+      }
+      if (union2) {
+        unionSerde.writeUnknown();
+      } else if (typeof record2.__type === "string") {
+        for (const k in record2) {
+          const v = record2[k];
+          const t = jsonName ? nameMap[k] ?? k : k;
+          if (!(t in out)) {
+            out[t] = v;
+          }
+        }
+      }
+      return out;
+    }
+  }
+  var encoder2 = new TextEncoder;
+  var OPEN_BRACE = 123;
+  var CLOSE_BRACE = 125;
+  var OPEN_BRACKET = 91;
+  var CLOSE_BRACKET = 93;
+  var QUOTE = 34;
+  var COLON = 58;
+  var COMMA = 44;
+  var BACKSLASH = 92;
+  var TRUE = new Uint8Array([116, 114, 117, 101]);
+  var FALSE = new Uint8Array([102, 97, 108, 115, 101]);
+  var NULL = new Uint8Array([110, 117, 108, 108]);
+  var ESCAPE_TABLE = new Array(128).fill(null);
+  ESCAPE_TABLE[8] = "b";
+  ESCAPE_TABLE[9] = "t";
+  ESCAPE_TABLE[10] = "n";
+  ESCAPE_TABLE[12] = "f";
+  ESCAPE_TABLE[13] = "r";
+  ESCAPE_TABLE[34] = '"';
+  ESCAPE_TABLE[92] = "\\";
+  for (let i2 = 0;i2 < 32; i2++) {
+    if (ESCAPE_TABLE[i2] === null) {
+      ESCAPE_TABLE[i2] = "u00" + i2.toString(16).padStart(2, "0");
+    }
+  }
+  var INITIAL_BUFFER_SIZE = 2048;
+  function alloc(size) {
+    return typeof Buffer !== "undefined" ? Buffer.allocUnsafe(size) : new Uint8Array(size);
+  }
+
+  class JsonShapeSerializer2 extends SerdeContextConfig {
+    settings;
+    json;
+    i = 0;
+    rootSchema;
+    rawValue;
+    passthrough = false;
+    constructor(settings) {
+      super();
+      this.settings = settings;
+      this.json = alloc(INITIAL_BUFFER_SIZE);
+    }
+    write(schema, value) {
+      this.i = 0;
+      this.rawValue = value;
+      this.rootSchema = NormalizedSchema.of(schema);
+      this.passthrough = !this.rootSchema.isStructSchema() && !this.rootSchema.isDocumentSchema() && (this.rootSchema.isBlobSchema() || this.rootSchema.isStringSchema());
+      if (!this.passthrough) {
+        this.writeValue(this.rootSchema, value, undefined);
+      }
+    }
+    writeDiscriminatedDocument(schema, value) {
+      this.i = 0;
+      this.rootSchema = NormalizedSchema.of(schema);
+      const ns = this.rootSchema;
+      if (ns.isStructSchema() && value != null && typeof value === "object") {
+        this.ensure(2);
+        this.json[this.i++] = OPEN_BRACE;
+        this.writeAsciiQuoted("__type");
+        this.json[this.i++] = COLON;
+        this.writeAsciiQuoted(ns.getName(true) ?? "Unknown");
+        let wroteAny = true;
+        const { jsonName } = this.settings;
+        for (const [memberName, memberSchema] of ns.structIterator()) {
+          const item = value[memberName];
+          if (item == null && !memberSchema.isIdempotencyToken()) {
+            continue;
+          }
+          if (wroteAny) {
+            this.ensure(1);
+            this.json[this.i++] = COMMA;
+          }
+          const targetKey = jsonName ? memberSchema.getMergedTraits().jsonName ?? memberName : memberName;
+          this.writeAsciiQuoted(targetKey);
+          this.json[this.i++] = COLON;
+          this.writeValue(memberSchema, item, ns);
+          wroteAny = true;
+        }
+        this.ensure(1);
+        this.json[this.i++] = CLOSE_BRACE;
+      } else {
+        this.writeValue(ns, value, undefined);
+      }
+    }
+    flush() {
+      this.rootSchema = undefined;
+      const finalPosition = this.i;
+      this.i = 0;
+      const raw = this.rawValue;
+      this.rawValue = undefined;
+      if (finalPosition === 0) {
+        return raw;
+      }
+      const result = this.json.subarray(0, finalPosition);
+      this.json = alloc(INITIAL_BUFFER_SIZE);
+      return result;
+    }
+    ensure(byteCount) {
+      const { i: i2, json: json2 } = this;
+      if (i2 + byteCount > json2.length) {
+        let newSize = json2.length * 2;
+        while (newSize < i2 + byteCount) {
+          newSize *= 2;
+        }
+        const next = alloc(newSize);
+        next.set(this.json);
+        this.json = next;
+      }
+    }
+    writeAscii(s) {
+      const z3 = s.length;
+      this.ensure(z3);
+      let { i: i2, json: json2 } = this;
+      for (let j = 0;j < z3; ++j) {
+        json2[i2] = s.charCodeAt(j);
+        i2 += 1;
+      }
+      this.i = i2;
+    }
+    writeAsciiQuoted(s) {
+      const z3 = s.length;
+      this.ensure(z3 + 4);
+      let { json: json2, i: i2 } = this;
+      json2[i2++] = QUOTE;
+      for (let j = 0;j < z3; ++j) {
+        json2[i2++] = s.charCodeAt(j);
+      }
+      json2[i2++] = QUOTE;
+      this.i = i2;
+    }
+    writeJsonString(s) {
+      this.ensure(s.length * 2 + 2);
+      this.json[this.i++] = QUOTE;
+      const z3 = s.length;
+      for (let j = 0;j < z3; ++j) {
+        const c5 = s.charCodeAt(j);
+        if (c5 > 34 && c5 < 92) {
+          this.json[this.i++] = c5;
+        } else if (c5 < 128) {
+          const esc2 = ESCAPE_TABLE[c5];
+          if (esc2 !== null) {
+            this.ensure(esc2.length + 1);
+            this.json[this.i++] = BACKSLASH;
+            for (let k = 0;k < esc2.length; k++) {
+              this.json[this.i++] = esc2.charCodeAt(k);
+            }
+          } else {
+            this.json[this.i++] = c5;
+          }
+        } else if (c5 >= 55296 && c5 <= 56319) {
+          const next = j + 1 < z3 ? s.charCodeAt(j + 1) : 0;
+          if (next >= 56320 && next <= 57343) {
+            this.ensure(4);
+            const { written } = encoder2.encodeInto(s.substring(j, j + 2), this.json.subarray(this.i));
+            this.i += written;
+            j++;
+          } else {
+            this.ensure(6);
+            this.writeUnicodeEscape(c5);
+          }
+        } else if (c5 >= 56320 && c5 <= 57343) {
+          this.ensure(6);
+          this.writeUnicodeEscape(c5);
+        } else {
+          let { i: i2, json: json2 } = this;
+          if (c5 < 2048) {
+            json2[i2++] = 192 | c5 >> 6;
+            json2[i2++] = 128 | c5 & 63;
+          } else {
+            json2[i2++] = 224 | c5 >> 12;
+            json2[i2++] = 128 | c5 >> 6 & 63;
+            json2[i2++] = 128 | c5 & 63;
+          }
+          this.i = i2;
+        }
+      }
+      this.json[this.i++] = QUOTE;
+    }
+    writeUnicodeEscape(code) {
+      let { json: json2, i: i2 } = this;
+      json2[i2++] = BACKSLASH;
+      json2[i2++] = 117;
+      const hex3 = code.toString(16).padStart(4, "0");
+      for (let j = 0;j < 4; ++j) {
+        json2[i2++] = hex3.charCodeAt(j);
+      }
+      this.i = i2;
+    }
+    static B64 = (() => {
+      const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+      const table = new Uint8Array(64);
+      for (let i2 = 0;i2 < 64; i2++)
+        table[i2] = chars.charCodeAt(i2);
+      return table;
+    })();
+    writeBase64(data) {
+      const b64Len = Math.ceil(data.length / 3) * 4;
+      this.ensure(b64Len + 2);
+      const json2 = this.json;
+      const B64 = JsonShapeSerializer2.B64;
+      let i2 = this.i;
+      json2[i2++] = QUOTE;
+      const len = data.length;
+      const remainder = len % 3;
+      const mainLen = len - remainder;
+      for (let j = 0;j < mainLen; j += 3) {
+        const a2 = data[j];
+        const b = data[j + 1];
+        const c5 = data[j + 2];
+        json2[i2++] = B64[a2 >> 2];
+        json2[i2++] = B64[(a2 & 3) << 4 | b >> 4];
+        json2[i2++] = B64[(b & 15) << 2 | c5 >> 6];
+        json2[i2++] = B64[c5 & 63];
+      }
+      if (remainder === 2) {
+        const a2 = data[mainLen];
+        const b = data[mainLen + 1];
+        json2[i2++] = B64[a2 >> 2];
+        json2[i2++] = B64[(a2 & 3) << 4 | b >> 4];
+        json2[i2++] = B64[(b & 15) << 2];
+        json2[i2++] = 61;
+      } else if (remainder === 1) {
+        const a2 = data[mainLen];
+        json2[i2++] = B64[a2 >> 2];
+        json2[i2++] = B64[(a2 & 3) << 4];
+        json2[i2++] = 61;
+        json2[i2++] = 61;
+      }
+      json2[i2++] = QUOTE;
+      this.i = i2;
+    }
+    writeValue(schema, value, container) {
+      if (value == null) {
+        if (container?.isStructSchema()) {
+          if (value === undefined) {
+            const ns2 = NormalizedSchema.of(schema);
+            if (ns2.isIdempotencyToken()) {
+              this.writeAsciiQuoted(generateIdempotencyToken());
+              return;
+            }
+          }
+          return;
+        }
+        this.ensure(4);
+        this.json.set(NULL, this.i);
+        this.i += 4;
+        return;
+      }
+      const ns = NormalizedSchema.of(schema);
+      const isObject5 = typeof value === "object";
+      if (ns.isStringSchema()) {
+        const mediaType = ns.getMergedTraits().mediaType;
+        if (mediaType) {
+          const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
+          if (isJson) {
+            this.writeJsonString(LazyJsonString.from(value).toString());
+            return;
+          }
+        }
+      }
+      if (isObject5) {
+        if (ns.isStructSchema()) {
+          this.writeStruct(ns, value);
+          return;
+        }
+        if (Array.isArray(value) && (ns.isListSchema() || ns.isDocumentSchema())) {
+          this.writeList(ns, value, ns.isDocumentSchema());
+          return;
+        }
+        if (ns.isMapSchema()) {
+          this.writeMap(ns, value, false);
+          return;
+        }
+        if (value instanceof Uint8Array && (ns.isBlobSchema() || ns.isDocumentSchema())) {
+          this.writeBase64(value);
+          return;
+        }
+        if (value instanceof Date && (ns.isTimestampSchema() || ns.isDocumentSchema())) {
+          this.writeTimestamp(ns, value);
+          return;
+        }
+        if (value instanceof NumericValue) {
+          this.writeAscii(value.string);
+          return;
+        }
+        if (ns.isDocumentSchema()) {
+          if (Array.isArray(value)) {
+            this.writeList(ns, value, true);
+          } else {
+            this.writeMap(ns, value, true);
+          }
+          return;
+        }
+        const json2 = JSON.stringify(value);
+        this.writeAscii(json2);
+        return;
+      }
+      if (typeof value === "string") {
+        if (ns.isBlobSchema()) {
+          const b64 = (this.serdeContext?.base64Encoder ?? toBase64)(value);
+          this.writeAsciiQuoted(b64);
+          return;
+        }
+        this.writeJsonString(value);
+        return;
+      }
+      if (typeof value === "number") {
+        if (ns.isNumericSchema() && (Math.abs(value) === Infinity || isNaN(value))) {
+          this.writeAsciiQuoted(String(value));
+          return;
+        }
+        const numStr = String(value);
+        this.writeAscii(numStr);
+        return;
+      }
+      if (typeof value === "boolean") {
+        this.ensure(5);
+        if (value) {
+          this.json.set(TRUE, this.i);
+          this.i += 4;
+        } else {
+          this.json.set(FALSE, this.i);
+          this.i += 5;
+        }
+        return;
+      }
+      if (typeof value === "bigint") {
+        this.writeAscii(value.toString());
+        return;
+      }
+      this.writeAscii(String(value));
+    }
+    writeStruct(ns, value) {
+      this.ensure(2);
+      this.json[this.i++] = OPEN_BRACE;
+      let first = true;
+      let wroteAny = false;
+      const hasType = typeof value.__type === "string";
+      let writtenKeys;
+      if (hasType) {
+        writtenKeys = new Set;
+      }
+      for (const [memberName, memberSchema] of ns.structIterator()) {
+        const item = value[memberName];
+        if (item == null && !memberSchema.isIdempotencyToken())
+          continue;
+        if (!first) {
+          this.ensure(1);
+          this.json[this.i++] = COMMA;
+        }
+        first = false;
+        wroteAny = true;
+        const targetKey = this.settings.jsonName ? memberSchema.getMergedTraits().jsonName ?? memberName : memberName;
+        if (writtenKeys) {
+          writtenKeys.add(memberName);
+          writtenKeys.add(targetKey);
+        }
+        this.writeAsciiQuoted(targetKey);
+        this.json[this.i++] = COLON;
+        this.writeValue(memberSchema, item, ns);
+      }
+      if (!wroteAny && ns.isUnionSchema()) {
+        const { $unknown } = value;
+        if (Array.isArray($unknown)) {
+          const [k, v] = $unknown;
+          this.writeAsciiQuoted(k);
+          this.ensure(1);
+          this.json[this.i++] = COLON;
+          this.writeValue(15, v, ns);
+        }
+      } else if (hasType) {
+        for (const k in value) {
+          const targetKey = this.settings.jsonName ? writtenKeys.has(k) ? k : k : k;
+          if (writtenKeys.has(targetKey))
+            continue;
+          writtenKeys.add(targetKey);
+          const v = value[k];
+          if (!first) {
+            this.ensure(1);
+            this.json[this.i++] = COMMA;
+          }
+          first = false;
+          this.writeAsciiQuoted(targetKey);
+          this.ensure(1);
+          this.json[this.i++] = COLON;
+          this.writeValue(15, v, undefined);
+        }
+      }
+      this.ensure(1);
+      this.json[this.i++] = CLOSE_BRACE;
+    }
+    writeList(ns, value, isDocument) {
+      this.ensure(2);
+      this.json[this.i++] = OPEN_BRACKET;
+      const sparse = !!ns.getMergedTraits().sparse;
+      const valueSchema = ns.getValueSchema();
+      for (let i2 = 0;i2 < value.length; ++i2) {
+        const item = value[i2];
+        if (isDocument ? item === undefined : item == null && !sparse) {
+          continue;
+        }
+        if (i2 !== 0) {
+          this.ensure(1);
+          this.json[this.i++] = COMMA;
+        }
+        this.writeValue(valueSchema, item, undefined);
+      }
+      this.ensure(1);
+      this.json[this.i++] = CLOSE_BRACKET;
+    }
+    writeMap(ns, value, isDocument) {
+      const sparse = !!ns.getMergedTraits().sparse;
+      const valueSchema = ns.getValueSchema();
+      if (!isDocument) {
+        if (valueSchema.isStringSchema() || valueSchema.isNumericSchema() || valueSchema.isBooleanSchema()) {
+          let input = value;
+          if (sparse) {
+            input = {};
+            for (const k in value) {
+              if (k === "__proto__") {
+                writeKey(input);
+              }
+              input[k] = value[k] ?? null;
+            }
+          }
+          const json2 = JSON.stringify(input);
+          this.ensure(json2.length * 3);
+          const { written } = encoder2.encodeInto(json2, this.json.subarray(this.i));
+          this.i += written;
+          return;
+        }
+      }
+      this.ensure(2);
+      this.json[this.i++] = OPEN_BRACE;
+      let first = true;
+      for (const k in value) {
+        const v = value[k];
+        if (isDocument ? v === undefined : v == null && !sparse) {
+          continue;
+        }
+        if (!first) {
+          this.ensure(1);
+          this.json[this.i++] = COMMA;
+        }
+        first = false;
+        this.writeJsonString(k);
+        this.ensure(1);
+        this.json[this.i++] = COLON;
+        this.writeValue(valueSchema, v, undefined);
+      }
+      this.ensure(1);
+      this.json[this.i++] = CLOSE_BRACE;
+    }
+    writeTimestamp(ns, value) {
+      const format3 = determineTimestampFormat(ns, this.settings);
+      switch (format3) {
+        case 5: {
+          const iso = value.toISOString().replace(".000Z", "Z");
+          this.writeAsciiQuoted(iso);
+          return;
+        }
+        case 6: {
+          this.writeAsciiQuoted(dateToUtcString(value));
+          return;
+        }
+        case 7: {
+          const epochSecs = String(value.getTime() / 1000);
+          this.writeAscii(epochSecs);
+          return;
+        }
+        default: {
+          const epochSecs = String(value.getTime() / 1000);
+          this.writeAscii(epochSecs);
+          return;
+        }
+      }
+    }
+  }
+
+  class JsonCodec2 extends SerdeContextConfig {
+    settings;
+    constructor(settings) {
+      super();
+      this.settings = settings;
+    }
+    createSerializer() {
+      const serializer = new JsonShapeSerializer2(this.settings);
+      serializer.setSerdeContext(this.serdeContext);
+      return serializer;
+    }
+    createDeserializer() {
+      const deserializer = new JsonShapeDeserializer2(this.settings);
+      deserializer.setSerdeContext(this.serdeContext);
+      return deserializer;
+    }
+  }
 
   class XmlShapeDeserializer extends SerdeContextConfig {
     settings;
@@ -101934,6 +102537,64 @@ var require_protocols2 = __commonJS((exports) => {
       return false;
     }
   }
+  var awsExpectUnion = (value) => {
+    if (value == null) {
+      return;
+    }
+    if (typeof value === "object" && "__type" in value) {
+      delete value.__type;
+    }
+    return expectUnion(value);
+  };
+  var _toStr = (val) => {
+    if (val == null) {
+      return val;
+    }
+    if (typeof val === "number" || typeof val === "bigint") {
+      const warning = new Error(`Received number ${val} where a string was expected.`);
+      warning.name = "Warning";
+      console.warn(warning);
+      return String(val);
+    }
+    if (typeof val === "boolean") {
+      const warning = new Error(`Received boolean ${val} where a string was expected.`);
+      warning.name = "Warning";
+      console.warn(warning);
+      return String(val);
+    }
+    return val;
+  };
+  var _toBool = (val) => {
+    if (val == null) {
+      return val;
+    }
+    if (typeof val === "string") {
+      const lowercase2 = val.toLowerCase();
+      if (val !== "" && lowercase2 !== "false" && lowercase2 !== "true") {
+        const warning = new Error(`Received string "${val}" where a boolean was expected.`);
+        warning.name = "Warning";
+        console.warn(warning);
+      }
+      return val !== "" && lowercase2 !== "false";
+    }
+    return val;
+  };
+  var _toNum = (val) => {
+    if (val == null) {
+      return val;
+    }
+    if (typeof val === "string") {
+      const num = Number(val);
+      if (num.toString() !== val) {
+        const warning = new Error(`Received string "${val}" where a number was expected.`);
+        warning.name = "Warning";
+        console.warn(warning);
+        return val;
+      }
+      return num;
+    }
+    return val;
+  };
   exports.AwsEc2QueryProtocol = AwsEc2QueryProtocol;
   exports.AwsJson1_0Protocol = AwsJson1_0Protocol;
   exports.AwsJson1_1Protocol = AwsJson1_1Protocol;
@@ -101943,8 +102604,11 @@ var require_protocols2 = __commonJS((exports) => {
   exports.AwsRestXmlProtocol = AwsRestXmlProtocol;
   exports.AwsSmithyRpcV2CborProtocol = AwsSmithyRpcV2CborProtocol;
   exports.JsonCodec = JsonCodec;
+  exports.JsonCodec2 = JsonCodec2;
   exports.JsonShapeDeserializer = JsonShapeDeserializer;
+  exports.JsonShapeDeserializer2 = JsonShapeDeserializer2;
   exports.JsonShapeSerializer = JsonShapeSerializer;
+  exports.JsonShapeSerializer2 = JsonShapeSerializer2;
   exports.QueryShapeSerializer = QueryShapeSerializer;
   exports.XmlCodec = XmlCodec;
   exports.XmlShapeDeserializer = XmlShapeDeserializer;
@@ -102040,7 +102704,7 @@ var require_sso_oidc = __commonJS((exports) => {
     Region: { type: "builtInParams", name: "region" },
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
   };
-  var version2 = "3.997.36";
+  var version2 = "3.997.37";
   var packageInfo = {
     version: version2
   };
@@ -102937,7 +103601,7 @@ var require_sso = __commonJS((exports) => {
     Region: { type: "builtInParams", name: "region" },
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
   };
-  var version2 = "3.997.36";
+  var version2 = "3.997.37";
   var packageInfo = {
     version: version2
   };
@@ -104031,7 +104695,7 @@ var require_sts = __commonJS((exports) => {
     Region: { type: "builtInParams", name: "region" },
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
   };
-  var version2 = "3.997.36";
+  var version2 = "3.997.37";
   var packageInfo = {
     version: version2
   };
@@ -104800,7 +105464,7 @@ var require_signin = __commonJS((exports) => {
     Region: { type: "builtInParams", name: "region" },
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
   };
-  var version2 = "3.997.36";
+  var version2 = "3.997.37";
   var packageInfo = {
     version: version2
   };
@@ -119165,7 +119829,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@funnycode/myclaude",
-    version: "0.1.158",
+    version: "0.1.159",
     private: false,
     description: "An open-source AI coding assistant in your terminal - powered by Claude",
     license: "MIT",
@@ -565705,9 +566369,9 @@ function migrateEnableAllProjectMcpServersToSettings() {
   const originalProjectConfig = { ...projectConfig };
   const originalSettingsKeys = new Set(Object.keys(originalSettings));
   const fieldsToRemove = [];
+  const updates = {};
   try {
     const existingSettings = originalSettings;
-    const updates = {};
     if (hasEnableAll) {
       updates.enableAllProjectMcpServers = projectConfig.enableAllProjectMcpServers;
       fieldsToRemove.push("enableAllProjectMcpServers");
@@ -565755,12 +566419,12 @@ function migrateEnableAllProjectMcpServersToSettings() {
     }
     const existingHadEnabledServers = Array.isArray(existingSettings.enabledMcpjsonServers);
     const existingHadDisabledServers = Array.isArray(existingSettings.disabledMcpjsonServers);
-    const hasNonEmptyEnabledServers = hasEnabledServers && Array.isArray(projectConfig.enabledMcpjsonServers) && projectConfig.enabledMcpjsonServers.length > 0;
-    const hasNonEmptyDisabledServers = hasDisabledServers && Array.isArray(projectConfig.disabledMcpjsonServers) && projectConfig.disabledMcpjsonServers.length > 0;
-    if (existingHadEnabledServers || hasNonEmptyEnabledServers) {
+    const hasEnabledServersArray = hasEnabledServers && Array.isArray(projectConfig.enabledMcpjsonServers);
+    const hasDisabledServersArray = hasDisabledServers && Array.isArray(projectConfig.disabledMcpjsonServers);
+    if (existingHadEnabledServers || hasEnabledServersArray) {
       updates.enabledMcpjsonServers = existingEnabledServers;
     }
-    if (existingHadDisabledServers || hasNonEmptyDisabledServers) {
+    if (existingHadDisabledServers || hasDisabledServersArray) {
       updates.disabledMcpjsonServers = existingDisabledServers;
     }
     updateSettingsForSource("localSettings", updates);
@@ -565811,7 +566475,22 @@ function migrateEnableAllProjectMcpServersToSettings() {
     } catch (rollbackError) {
       logError2("Rollback of project config failed", rollbackError);
       rollbackFailed = true;
-      logError2("Settings rollback succeeded but project config rollback failed. " + "System is in an inconsistent state. Manual intervention may be required.", rollbackError);
+      if (settingsRollbackSucceeded) {
+        try {
+          const reapplyUpdates = {};
+          for (const field of migratedFields) {
+            if (updates[field] !== undefined) {
+              reapplyUpdates[field] = updates[field];
+            }
+          }
+          updateSettingsForSource("localSettings", reapplyUpdates);
+          logError2("Re-applied migrated state to settings after project config rollback failure. " + "System is now consistent (migration state re-applied).", rollbackError);
+        } catch (reapplyError) {
+          logError2("Failed to re-apply migrated state to settings after project config rollback failure. " + "System is in an inconsistent state. Manual intervention may be required.", reapplyError);
+        }
+      } else {
+        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)));