@anvailabs/agentbrowser-mcp 1.8.16 → 1.8.18

package/dist/index.js

@@ -115,12 +115,24 @@ function IsAsyncIterator2(value) {
 function IsIterator2(value) {
   return IsObject2(value) && globalThis.Symbol.iterator in value;
 }
+function IsStandardObject(value) {
+  return IsObject2(value) && (globalThis.Object.getPrototypeOf(value) === Object.prototype || globalThis.Object.getPrototypeOf(value) === null);
+}
 function IsPromise(value) {
   return value instanceof globalThis.Promise;
 }
 function IsDate2(value) {
   return value instanceof Date && globalThis.Number.isFinite(value.getTime());
 }
+function IsMap(value) {
+  return value instanceof globalThis.Map;
+}
+function IsSet(value) {
+  return value instanceof globalThis.Set;
+}
+function IsTypedArray(value) {
+  return globalThis.ArrayBuffer.isView(value);
+}
 function IsUint8Array2(value) {
   return value instanceof globalThis.Uint8Array;
 }
@@ -2643,9 +2655,9 @@ var TransformEncodeBuilder = class {
     this.decode = decode;
   }
   EncodeTransform(encode, schema) {
-    const Encode = (value) => schema[TransformKind].Encode(encode(value));
-    const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
-    const Codec = { Encode, Decode };
+    const Encode2 = (value) => schema[TransformKind].Encode(encode(value));
+    const Decode2 = (value) => this.decode(schema[TransformKind].Decode(value));
+    const Codec = { Encode: Encode2, Decode: Decode2 };
     return { ...schema, [TransformKind]: Codec };
   }
   EncodeSchema(encode, schema) {
@@ -4028,202 +4040,1226 @@ function Errors(...args) {
   return new ValueErrorIterator(iterator);
 }
 
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/transform/decode.mjs
-var TransformDecodeCheckError = class extends TypeBoxError {
-  constructor(schema, value, error2) {
-    super(`Unable to decode value as it does not match the expected schema`);
-    this.schema = schema;
-    this.value = value;
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/assert/assert.mjs
+var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+};
+var __classPrivateFieldGet = function(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AssertError_instances;
+var _AssertError_iterator;
+var _AssertError_Iterator;
+var AssertError = class extends TypeBoxError {
+  constructor(iterator) {
+    const error2 = iterator.First();
+    super(error2 === void 0 ? "Invalid Value" : error2.message);
+    _AssertError_instances.add(this);
+    _AssertError_iterator.set(this, void 0);
+    __classPrivateFieldSet(this, _AssertError_iterator, iterator, "f");
     this.error = error2;
   }
+  /** Returns an iterator for each error in this value. */
+  Errors() {
+    return new ValueErrorIterator(__classPrivateFieldGet(this, _AssertError_instances, "m", _AssertError_Iterator).call(this));
+  }
 };
-var TransformDecodeError = class extends TypeBoxError {
-  constructor(schema, path, value, error2) {
-    super(error2 instanceof Error ? error2.message : "Unknown error");
+_AssertError_iterator = /* @__PURE__ */ new WeakMap(), _AssertError_instances = /* @__PURE__ */ new WeakSet(), _AssertError_Iterator = function* _AssertError_Iterator2() {
+  if (this.error)
+    yield this.error;
+  yield* __classPrivateFieldGet(this, _AssertError_iterator, "f");
+};
+function AssertValue(schema, references, value) {
+  if (Check(schema, references, value))
+    return;
+  throw new AssertError(Errors(schema, references, value));
+}
+function Assert(...args) {
+  return args.length === 3 ? AssertValue(args[0], args[1], args[2]) : AssertValue(args[0], [], args[1]);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/clone/clone.mjs
+function FromObject10(value) {
+  const Acc = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    Acc[key] = Clone2(value[key]);
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    Acc[key] = Clone2(value[key]);
+  }
+  return Acc;
+}
+function FromArray9(value) {
+  return value.map((element) => Clone2(element));
+}
+function FromTypedArray(value) {
+  return value.slice();
+}
+function FromMap(value) {
+  return new Map(Clone2([...value.entries()]));
+}
+function FromSet(value) {
+  return new Set(Clone2([...value.entries()]));
+}
+function FromDate4(value) {
+  return new Date(value.toISOString());
+}
+function FromValue2(value) {
+  return value;
+}
+function Clone2(value) {
+  if (IsArray2(value))
+    return FromArray9(value);
+  if (IsDate2(value))
+    return FromDate4(value);
+  if (IsTypedArray(value))
+    return FromTypedArray(value);
+  if (IsMap(value))
+    return FromMap(value);
+  if (IsSet(value))
+    return FromSet(value);
+  if (IsObject2(value))
+    return FromObject10(value);
+  if (IsValueType(value))
+    return FromValue2(value);
+  throw new Error("ValueClone: Unable to clone value");
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/create/create.mjs
+var ValueCreateError = class extends TypeBoxError {
+  constructor(schema, message) {
+    super(message);
     this.schema = schema;
-    this.path = path;
-    this.value = value;
-    this.error = error2;
   }
 };
-function Default(schema, path, value) {
-  try {
-    return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
-  } catch (error2) {
-    throw new TransformDecodeError(schema, path, value, error2);
+function FromDefault(value) {
+  return IsFunction2(value) ? value() : Clone2(value);
+}
+function FromAny4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return {};
+  }
+}
+function FromArgument4(schema, references) {
+  return {};
+}
+function FromArray10(schema, references) {
+  if (schema.uniqueItems === true && !HasPropertyKey2(schema, "default")) {
+    throw new ValueCreateError(schema, "Array with the uniqueItems constraint requires a default value");
+  } else if ("contains" in schema && !HasPropertyKey2(schema, "default")) {
+    throw new ValueCreateError(schema, "Array with the contains constraint requires a default value");
+  } else if ("default" in schema) {
+    return FromDefault(schema.default);
+  } else if (schema.minItems !== void 0) {
+    return Array.from({ length: schema.minItems }).map((item) => {
+      return Visit7(schema.items, references);
+    });
+  } else {
+    return [];
   }
 }
-function FromArray9(schema, references, path, value) {
-  return IsArray2(value) ? Default(schema, path, value.map((value2, index) => Visit7(schema.items, references, `${path}/${index}`, value2))) : Default(schema, path, value);
+function FromAsyncIterator6(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return (async function* () {
+    })();
+  }
 }
-function FromIntersect11(schema, references, path, value) {
-  if (!IsObject2(value) || IsValueType(value))
-    return Default(schema, path, value);
-  const knownEntries = KeyOfPropertyEntries(schema);
-  const knownKeys = knownEntries.map((entry) => entry[0]);
-  const knownProperties = { ...value };
-  for (const [knownKey, knownSchema] of knownEntries)
-    if (knownKey in knownProperties) {
-      knownProperties[knownKey] = Visit7(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
-    }
-  if (!IsTransform(schema.unevaluatedProperties)) {
-    return Default(schema, path, knownProperties);
+function FromBigInt4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return BigInt(0);
   }
-  const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-  const unevaluatedProperties = schema.unevaluatedProperties;
-  const unknownProperties = { ...knownProperties };
-  for (const key of unknownKeys)
-    if (!knownKeys.includes(key)) {
-      unknownProperties[key] = Default(unevaluatedProperties, `${path}/${key}`, unknownProperties[key]);
+}
+function FromBoolean4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return false;
+  }
+}
+function FromConstructor6(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    const value = Visit7(schema.returns, references);
+    if (typeof value === "object" && !Array.isArray(value)) {
+      return class {
+        constructor() {
+          for (const [key, val] of Object.entries(value)) {
+            const self = this;
+            self[key] = val;
+          }
+        }
+      };
+    } else {
+      return class {
+      };
     }
-  return Default(schema, path, unknownProperties);
+  }
 }
-function FromImport3(schema, references, path, value) {
-  const additional = globalThis.Object.values(schema.$defs);
+function FromDate5(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else if (schema.minimumTimestamp !== void 0) {
+    return new Date(schema.minimumTimestamp);
+  } else {
+    return /* @__PURE__ */ new Date();
+  }
+}
+function FromFunction6(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return () => Visit7(schema.returns, references);
+  }
+}
+function FromImport3(schema, references) {
+  const definitions = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  const result = Visit7(target, [...references, ...additional], path, value);
-  return Default(schema, path, result);
+  return Visit7(target, [...references, ...definitions]);
+}
+function FromInteger4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else if (schema.minimum !== void 0) {
+    return schema.minimum;
+  } else {
+    return 0;
+  }
 }
-function FromNot4(schema, references, path, value) {
-  return Default(schema, path, Visit7(schema.not, references, path, value));
+function FromIntersect11(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    const value = schema.allOf.reduce((acc, schema2) => {
+      const next = Visit7(schema2, references);
+      return typeof next === "object" ? { ...acc, ...next } : next;
+    }, {});
+    if (!Check(schema, references, value))
+      throw new ValueCreateError(schema, "Intersect produced invalid value. Consider using a default value.");
+    return value;
+  }
 }
-function FromObject10(schema, references, path, value) {
-  if (!IsObject2(value))
-    return Default(schema, path, value);
-  const knownKeys = KeyOfPropertyKeys(schema);
-  const knownProperties = { ...value };
-  for (const key of knownKeys) {
-    if (!HasPropertyKey2(knownProperties, key))
-      continue;
-    if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
-      continue;
-    knownProperties[key] = Visit7(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+function FromIterator6(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return (function* () {
+    })();
   }
-  if (!IsSchema(schema.additionalProperties)) {
-    return Default(schema, path, knownProperties);
+}
+function FromLiteral5(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return schema.const;
   }
-  const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-  const additionalProperties = schema.additionalProperties;
-  const unknownProperties = { ...knownProperties };
-  for (const key of unknownKeys)
-    if (!knownKeys.includes(key)) {
-      unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key]);
-    }
-  return Default(schema, path, unknownProperties);
 }
-function FromRecord6(schema, references, path, value) {
-  if (!IsObject2(value))
-    return Default(schema, path, value);
-  const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
-  const knownKeys = new RegExp(pattern);
-  const knownProperties = { ...value };
-  for (const key of Object.getOwnPropertyNames(value))
-    if (knownKeys.test(key)) {
-      knownProperties[key] = Visit7(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
+function FromNever4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    throw new ValueCreateError(schema, "Never types cannot be created. Consider using a default value.");
+  }
+}
+function FromNot4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    throw new ValueCreateError(schema, "Not types must have a default value");
+  }
+}
+function FromNull4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return null;
+  }
+}
+function FromNumber4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else if (schema.minimum !== void 0) {
+    return schema.minimum;
+  } else {
+    return 0;
+  }
+}
+function FromObject11(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    const required = new Set(schema.required);
+    const Acc = {};
+    for (const [key, subschema] of Object.entries(schema.properties)) {
+      if (!required.has(key))
+        continue;
+      Acc[key] = Visit7(subschema, references);
     }
-  if (!IsSchema(schema.additionalProperties)) {
-    return Default(schema, path, knownProperties);
+    return Acc;
   }
-  const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-  const additionalProperties = schema.additionalProperties;
-  const unknownProperties = { ...knownProperties };
-  for (const key of unknownKeys)
-    if (!knownKeys.test(key)) {
-      unknownProperties[key] = Default(additionalProperties, `${path}/${key}`, unknownProperties[key]);
+}
+function FromPromise6(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return Promise.resolve(Visit7(schema.item, references));
+  }
+}
+function FromRecord6(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return {};
+  }
+}
+function FromRef7(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return Visit7(Deref(schema, references), references);
+  }
+}
+function FromRegExp4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    throw new ValueCreateError(schema, "RegExp types cannot be created. Consider using a default value.");
+  }
+}
+function FromString4(schema, references) {
+  if (schema.pattern !== void 0) {
+    if (!HasPropertyKey2(schema, "default")) {
+      throw new ValueCreateError(schema, "String types with patterns must specify a default value");
+    } else {
+      return FromDefault(schema.default);
+    }
+  } else if (schema.format !== void 0) {
+    if (!HasPropertyKey2(schema, "default")) {
+      throw new ValueCreateError(schema, "String types with formats must specify a default value");
+    } else {
+      return FromDefault(schema.default);
     }
-  return Default(schema, path, unknownProperties);
+  } else {
+    if (HasPropertyKey2(schema, "default")) {
+      return FromDefault(schema.default);
+    } else if (schema.minLength !== void 0) {
+      return Array.from({ length: schema.minLength }).map(() => " ").join("");
+    } else {
+      return "";
+    }
+  }
 }
-function FromRef7(schema, references, path, value) {
-  const target = Deref(schema, references);
-  return Default(schema, path, Visit7(target, references, path, value));
+function FromSymbol4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else if ("value" in schema) {
+    return Symbol.for(schema.value);
+  } else {
+    return /* @__PURE__ */ Symbol();
+  }
 }
-function FromThis3(schema, references, path, value) {
-  const target = Deref(schema, references);
-  return Default(schema, path, Visit7(target, references, path, value));
+function FromTemplateLiteral6(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  }
+  if (!IsTemplateLiteralFinite(schema))
+    throw new ValueCreateError(schema, "Can only create template literals that produce a finite variants. Consider using a default value.");
+  const generated = TemplateLiteralGenerate(schema);
+  return generated[0];
 }
-function FromTuple8(schema, references, path, value) {
-  return IsArray2(value) && IsArray2(schema.items) ? Default(schema, path, schema.items.map((schema2, index) => Visit7(schema2, references, `${path}/${index}`, value[index]))) : Default(schema, path, value);
+function FromThis3(schema, references) {
+  if (recursiveDepth++ > recursiveMaxDepth)
+    throw new ValueCreateError(schema, "Cannot create recursive type as it appears possibly infinite. Consider using a default.");
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return Visit7(Deref(schema, references), references);
+  }
 }
-function FromUnion13(schema, references, path, value) {
-  for (const subschema of schema.anyOf) {
-    if (!Check(subschema, references, value))
-      continue;
-    const decoded = Visit7(subschema, references, path, value);
-    return Default(schema, path, decoded);
+function FromTuple8(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  }
+  if (schema.items === void 0) {
+    return [];
+  } else {
+    return Array.from({ length: schema.minItems }).map((_, index) => Visit7(schema.items[index], references));
+  }
+}
+function FromUndefined4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return void 0;
+  }
+}
+function FromUnion13(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else if (schema.anyOf.length === 0) {
+    throw new Error("ValueCreate.Union: Cannot create Union with zero variants");
+  } else {
+    return Visit7(schema.anyOf[0], references);
+  }
+}
+function FromUint8Array4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else if (schema.minByteLength !== void 0) {
+    return new Uint8Array(schema.minByteLength);
+  } else {
+    return new Uint8Array(0);
+  }
+}
+function FromUnknown4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return {};
+  }
+}
+function FromVoid4(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return void 0;
+  }
+}
+function FromKind3(schema, references) {
+  if (HasPropertyKey2(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    throw new Error("User defined types must specify a default value");
   }
-  return Default(schema, path, value);
 }
-function Visit7(schema, references, path, value) {
+function Visit7(schema, references) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
-  switch (schema[Kind]) {
+  switch (schema_[Kind]) {
+    case "Any":
+      return FromAny4(schema_, references_);
+    case "Argument":
+      return FromArgument4(schema_, references_);
     case "Array":
-      return FromArray9(schema_, references_, path, value);
+      return FromArray10(schema_, references_);
+    case "AsyncIterator":
+      return FromAsyncIterator6(schema_, references_);
+    case "BigInt":
+      return FromBigInt4(schema_, references_);
+    case "Boolean":
+      return FromBoolean4(schema_, references_);
+    case "Constructor":
+      return FromConstructor6(schema_, references_);
+    case "Date":
+      return FromDate5(schema_, references_);
+    case "Function":
+      return FromFunction6(schema_, references_);
     case "Import":
-      return FromImport3(schema_, references_, path, value);
+      return FromImport3(schema_, references_);
+    case "Integer":
+      return FromInteger4(schema_, references_);
     case "Intersect":
-      return FromIntersect11(schema_, references_, path, value);
+      return FromIntersect11(schema_, references_);
+    case "Iterator":
+      return FromIterator6(schema_, references_);
+    case "Literal":
+      return FromLiteral5(schema_, references_);
+    case "Never":
+      return FromNever4(schema_, references_);
     case "Not":
-      return FromNot4(schema_, references_, path, value);
+      return FromNot4(schema_, references_);
+    case "Null":
+      return FromNull4(schema_, references_);
+    case "Number":
+      return FromNumber4(schema_, references_);
     case "Object":
-      return FromObject10(schema_, references_, path, value);
+      return FromObject11(schema_, references_);
+    case "Promise":
+      return FromPromise6(schema_, references_);
     case "Record":
-      return FromRecord6(schema_, references_, path, value);
+      return FromRecord6(schema_, references_);
     case "Ref":
-      return FromRef7(schema_, references_, path, value);
+      return FromRef7(schema_, references_);
+    case "RegExp":
+      return FromRegExp4(schema_, references_);
+    case "String":
+      return FromString4(schema_, references_);
     case "Symbol":
-      return Default(schema_, path, value);
+      return FromSymbol4(schema_, references_);
+    case "TemplateLiteral":
+      return FromTemplateLiteral6(schema_, references_);
     case "This":
-      return FromThis3(schema_, references_, path, value);
+      return FromThis3(schema_, references_);
     case "Tuple":
-      return FromTuple8(schema_, references_, path, value);
+      return FromTuple8(schema_, references_);
+    case "Undefined":
+      return FromUndefined4(schema_, references_);
     case "Union":
-      return FromUnion13(schema_, references_, path, value);
+      return FromUnion13(schema_, references_);
+    case "Uint8Array":
+      return FromUint8Array4(schema_, references_);
+    case "Unknown":
+      return FromUnknown4(schema_, references_);
+    case "Void":
+      return FromVoid4(schema_, references_);
     default:
-      return Default(schema_, path, value);
+      if (!type_exports2.Has(schema_[Kind]))
+        throw new ValueCreateError(schema_, "Unknown type");
+      return FromKind3(schema_, references_);
   }
 }
-function TransformDecode(schema, references, value) {
-  return Visit7(schema, references, "", value);
+var recursiveMaxDepth = 512;
+var recursiveDepth = 0;
+function Create2(...args) {
+  recursiveDepth = 0;
+  return args.length === 2 ? Visit7(args[0], args[1]) : Visit7(args[0], []);
 }
 
-// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/transform/encode.mjs
-var TransformEncodeCheckError = class extends TypeBoxError {
-  constructor(schema, value, error2) {
-    super(`The encoded value does not match the expected schema`);
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/cast/cast.mjs
+var ValueCastError = class extends TypeBoxError {
+  constructor(schema, message) {
+    super(message);
     this.schema = schema;
-    this.value = value;
-    this.error = error2;
   }
 };
-var TransformEncodeError = class extends TypeBoxError {
-  constructor(schema, path, value, error2) {
-    super(`${error2 instanceof Error ? error2.message : "Unknown error"}`);
-    this.schema = schema;
-    this.path = path;
-    this.value = value;
-    this.error = error2;
+function ScoreUnion(schema, references, value) {
+  if (schema[Kind] === "Object" && typeof value === "object" && !IsNull2(value)) {
+    const object = schema;
+    const keys = Object.getOwnPropertyNames(value);
+    const entries = Object.entries(object.properties);
+    return entries.reduce((acc, [key, schema2]) => {
+      const literal = schema2[Kind] === "Literal" && schema2.const === value[key] ? 100 : 0;
+      const checks = Check(schema2, references, value[key]) ? 10 : 0;
+      const exists = keys.includes(key) ? 1 : 0;
+      return acc + (literal + checks + exists);
+    }, 0);
+  } else if (schema[Kind] === "Union") {
+    const schemas = schema.anyOf.map((schema2) => Deref(schema2, references));
+    const scores = schemas.map((schema2) => ScoreUnion(schema2, references, value));
+    return Math.max(...scores);
+  } else {
+    return Check(schema, references, value) ? 1 : 0;
   }
-};
-function Default2(schema, path, value) {
-  try {
-    return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
-  } catch (error2) {
-    throw new TransformEncodeError(schema, path, value, error2);
+}
+function SelectUnion(union, references, value) {
+  const schemas = union.anyOf.map((schema) => Deref(schema, references));
+  let [select, best] = [schemas[0], 0];
+  for (const schema of schemas) {
+    const score = ScoreUnion(schema, references, value);
+    if (score > best) {
+      select = schema;
+      best = score;
+    }
   }
+  return select;
 }
-function FromArray10(schema, references, path, value) {
-  const defaulted = Default2(schema, path, value);
-  return IsArray2(defaulted) ? defaulted.map((value2, index) => Visit8(schema.items, references, `${path}/${index}`, value2)) : defaulted;
+function CastUnion(union, references, value) {
+  if ("default" in union) {
+    return typeof value === "function" ? union.default : Clone2(union.default);
+  } else {
+    const schema = SelectUnion(union, references, value);
+    return Cast(schema, references, value);
+  }
 }
-function FromImport4(schema, references, path, value) {
+function DefaultClone(schema, references, value) {
+  return Check(schema, references, value) ? Clone2(value) : Create2(schema, references);
+}
+function Default(schema, references, value) {
+  return Check(schema, references, value) ? value : Create2(schema, references);
+}
+function FromArray11(schema, references, value) {
+  if (Check(schema, references, value))
+    return Clone2(value);
+  const created = IsArray2(value) ? Clone2(value) : Create2(schema, references);
+  const minimum = IsNumber2(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created;
+  const maximum = IsNumber2(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
+  const casted = maximum.map((value2) => Visit8(schema.items, references, value2));
+  if (schema.uniqueItems !== true)
+    return casted;
+  const unique = [...new Set(casted)];
+  if (!Check(schema, references, unique))
+    throw new ValueCastError(schema, "Array cast produced invalid data due to uniqueItems constraint");
+  return unique;
+}
+function FromConstructor7(schema, references, value) {
+  if (Check(schema, references, value))
+    return Create2(schema, references);
+  const required = new Set(schema.returns.required || []);
+  const result = function() {
+  };
+  for (const [key, property] of Object.entries(schema.returns.properties)) {
+    if (!required.has(key) && value.prototype[key] === void 0)
+      continue;
+    result.prototype[key] = Visit8(property, references, value.prototype[key]);
+  }
+  return result;
+}
+function FromImport4(schema, references, value) {
+  const definitions = globalThis.Object.values(schema.$defs);
+  const target = schema.$defs[schema.$ref];
+  return Visit8(target, [...references, ...definitions], value);
+}
+function IntersectAssign(correct, value) {
+  if (IsObject2(correct) && !IsObject2(value) || !IsObject2(correct) && IsObject2(value))
+    return correct;
+  if (!IsObject2(correct) || !IsObject2(value))
+    return value;
+  return globalThis.Object.getOwnPropertyNames(correct).reduce((result, key) => {
+    const property = key in value ? IntersectAssign(correct[key], value[key]) : correct[key];
+    return { ...result, [key]: property };
+  }, {});
+}
+function FromIntersect12(schema, references, value) {
+  if (Check(schema, references, value))
+    return value;
+  const correct = Create2(schema, references);
+  const assigned = IntersectAssign(correct, value);
+  return Check(schema, references, assigned) ? assigned : correct;
+}
+function FromNever5(schema, references, value) {
+  throw new ValueCastError(schema, "Never types cannot be cast");
+}
+function FromObject12(schema, references, value) {
+  if (Check(schema, references, value))
+    return value;
+  if (value === null || typeof value !== "object")
+    return Create2(schema, references);
+  const required = new Set(schema.required || []);
+  const result = {};
+  for (const [key, property] of Object.entries(schema.properties)) {
+    if (!required.has(key) && value[key] === void 0)
+      continue;
+    result[key] = Visit8(property, references, value[key]);
+  }
+  if (typeof schema.additionalProperties === "object") {
+    const propertyNames = Object.getOwnPropertyNames(schema.properties);
+    for (const propertyName of Object.getOwnPropertyNames(value)) {
+      if (propertyNames.includes(propertyName))
+        continue;
+      result[propertyName] = Visit8(schema.additionalProperties, references, value[propertyName]);
+    }
+  }
+  return result;
+}
+function FromRecord7(schema, references, value) {
+  if (Check(schema, references, value))
+    return Clone2(value);
+  if (value === null || typeof value !== "object" || Array.isArray(value) || value instanceof Date)
+    return Create2(schema, references);
+  const subschemaPropertyName = Object.getOwnPropertyNames(schema.patternProperties)[0];
+  const subschema = schema.patternProperties[subschemaPropertyName];
+  const result = {};
+  for (const [propKey, propValue] of Object.entries(value)) {
+    result[propKey] = Visit8(subschema, references, propValue);
+  }
+  return result;
+}
+function FromRef8(schema, references, value) {
+  return Visit8(Deref(schema, references), references, value);
+}
+function FromThis4(schema, references, value) {
+  return Visit8(Deref(schema, references), references, value);
+}
+function FromTuple9(schema, references, value) {
+  if (Check(schema, references, value))
+    return Clone2(value);
+  if (!IsArray2(value))
+    return Create2(schema, references);
+  if (schema.items === void 0)
+    return [];
+  return schema.items.map((schema2, index) => Visit8(schema2, references, value[index]));
+}
+function FromUnion14(schema, references, value) {
+  return Check(schema, references, value) ? Clone2(value) : CastUnion(schema, references, value);
+}
+function Visit8(schema, references, value) {
+  const references_ = IsString2(schema.$id) ? Pushref(schema, references) : references;
+  const schema_ = schema;
+  switch (schema[Kind]) {
+    // --------------------------------------------------------------
+    // Structural
+    // --------------------------------------------------------------
+    case "Array":
+      return FromArray11(schema_, references_, value);
+    case "Constructor":
+      return FromConstructor7(schema_, references_, value);
+    case "Import":
+      return FromImport4(schema_, references_, value);
+    case "Intersect":
+      return FromIntersect12(schema_, references_, value);
+    case "Never":
+      return FromNever5(schema_, references_, value);
+    case "Object":
+      return FromObject12(schema_, references_, value);
+    case "Record":
+      return FromRecord7(schema_, references_, value);
+    case "Ref":
+      return FromRef8(schema_, references_, value);
+    case "This":
+      return FromThis4(schema_, references_, value);
+    case "Tuple":
+      return FromTuple9(schema_, references_, value);
+    case "Union":
+      return FromUnion14(schema_, references_, value);
+    // --------------------------------------------------------------
+    // DefaultClone
+    // --------------------------------------------------------------
+    case "Date":
+    case "Symbol":
+    case "Uint8Array":
+      return DefaultClone(schema, references, value);
+    // --------------------------------------------------------------
+    // Default
+    // --------------------------------------------------------------
+    default:
+      return Default(schema_, references_, value);
+  }
+}
+function Cast(...args) {
+  return args.length === 3 ? Visit8(args[0], args[1], args[2]) : Visit8(args[0], [], args[1]);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/clean/clean.mjs
+function IsCheckable(schema) {
+  return IsKind(schema) && schema[Kind] !== "Unsafe";
+}
+function FromArray12(schema, references, value) {
+  if (!IsArray2(value))
+    return value;
+  return value.map((value2) => Visit9(schema.items, references, value2));
+}
+function FromImport5(schema, references, value) {
+  const definitions = globalThis.Object.values(schema.$defs);
+  const target = schema.$defs[schema.$ref];
+  return Visit9(target, [...references, ...definitions], value);
+}
+function FromIntersect13(schema, references, value) {
+  const unevaluatedProperties = schema.unevaluatedProperties;
+  const intersections = schema.allOf.map((schema2) => Visit9(schema2, references, Clone2(value)));
+  const composite = intersections.reduce((acc, value2) => IsObject2(value2) ? { ...acc, ...value2 } : value2, {});
+  if (!IsObject2(value) || !IsObject2(composite) || !IsKind(unevaluatedProperties))
+    return composite;
+  const knownkeys = KeyOfPropertyKeys(schema);
+  for (const key of Object.getOwnPropertyNames(value)) {
+    if (knownkeys.includes(key))
+      continue;
+    if (Check(unevaluatedProperties, references, value[key])) {
+      composite[key] = Visit9(unevaluatedProperties, references, value[key]);
+    }
+  }
+  return composite;
+}
+function FromObject13(schema, references, value) {
+  if (!IsObject2(value) || IsArray2(value))
+    return value;
+  const additionalProperties = schema.additionalProperties;
+  for (const key of Object.getOwnPropertyNames(value)) {
+    if (HasPropertyKey2(schema.properties, key)) {
+      value[key] = Visit9(schema.properties[key], references, value[key]);
+      continue;
+    }
+    if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
+      value[key] = Visit9(additionalProperties, references, value[key]);
+      continue;
+    }
+    delete value[key];
+  }
+  return value;
+}
+function FromRecord8(schema, references, value) {
+  if (!IsObject2(value))
+    return value;
+  const additionalProperties = schema.additionalProperties;
+  const propertyKeys = Object.getOwnPropertyNames(value);
+  const [propertyKey, propertySchema] = Object.entries(schema.patternProperties)[0];
+  const propertyKeyTest = new RegExp(propertyKey);
+  for (const key of propertyKeys) {
+    if (propertyKeyTest.test(key)) {
+      value[key] = Visit9(propertySchema, references, value[key]);
+      continue;
+    }
+    if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
+      value[key] = Visit9(additionalProperties, references, value[key]);
+      continue;
+    }
+    delete value[key];
+  }
+  return value;
+}
+function FromRef9(schema, references, value) {
+  return Visit9(Deref(schema, references), references, value);
+}
+function FromThis5(schema, references, value) {
+  return Visit9(Deref(schema, references), references, value);
+}
+function FromTuple10(schema, references, value) {
+  if (!IsArray2(value))
+    return value;
+  if (IsUndefined2(schema.items))
+    return [];
+  const length = Math.min(value.length, schema.items.length);
+  for (let i = 0; i < length; i++) {
+    value[i] = Visit9(schema.items[i], references, value[i]);
+  }
+  return value.length > length ? value.slice(0, length) : value;
+}
+function FromUnion15(schema, references, value) {
+  for (const inner of schema.anyOf) {
+    if (IsCheckable(inner) && Check(inner, references, value)) {
+      return Visit9(inner, references, value);
+    }
+  }
+  return value;
+}
+function Visit9(schema, references, value) {
+  const references_ = IsString2(schema.$id) ? Pushref(schema, references) : references;
+  const schema_ = schema;
+  switch (schema_[Kind]) {
+    case "Array":
+      return FromArray12(schema_, references_, value);
+    case "Import":
+      return FromImport5(schema_, references_, value);
+    case "Intersect":
+      return FromIntersect13(schema_, references_, value);
+    case "Object":
+      return FromObject13(schema_, references_, value);
+    case "Record":
+      return FromRecord8(schema_, references_, value);
+    case "Ref":
+      return FromRef9(schema_, references_, value);
+    case "This":
+      return FromThis5(schema_, references_, value);
+    case "Tuple":
+      return FromTuple10(schema_, references_, value);
+    case "Union":
+      return FromUnion15(schema_, references_, value);
+    default:
+      return value;
+  }
+}
+function Clean(...args) {
+  return args.length === 3 ? Visit9(args[0], args[1], args[2]) : Visit9(args[0], [], args[1]);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/convert/convert.mjs
+function IsStringNumeric(value) {
+  return IsString2(value) && !isNaN(value) && !isNaN(parseFloat(value));
+}
+function IsValueToString(value) {
+  return IsBigInt2(value) || IsBoolean2(value) || IsNumber2(value);
+}
+function IsValueTrue(value) {
+  return value === true || IsNumber2(value) && value === 1 || IsBigInt2(value) && value === BigInt("1") || IsString2(value) && (value.toLowerCase() === "true" || value === "1");
+}
+function IsValueFalse(value) {
+  return value === false || IsNumber2(value) && (value === 0 || Object.is(value, -0)) || IsBigInt2(value) && value === BigInt("0") || IsString2(value) && (value.toLowerCase() === "false" || value === "0" || value === "-0");
+}
+function IsTimeStringWithTimeZone(value) {
+  return IsString2(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+}
+function IsTimeStringWithoutTimeZone(value) {
+  return IsString2(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+}
+function IsDateTimeStringWithTimeZone(value) {
+  return IsString2(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)(?:\.\d+)?(?:z|[+-]\d\d(?::?\d\d)?)$/i.test(value);
+}
+function IsDateTimeStringWithoutTimeZone(value) {
+  return IsString2(value) && /^\d\d\d\d-[0-1]\d-[0-3]\dt(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+}
+function IsDateString(value) {
+  return IsString2(value) && /^\d\d\d\d-[0-1]\d-[0-3]\d$/i.test(value);
+}
+function TryConvertLiteralString(value, target) {
+  const conversion = TryConvertString(value);
+  return conversion === target ? conversion : value;
+}
+function TryConvertLiteralNumber(value, target) {
+  const conversion = TryConvertNumber(value);
+  return conversion === target ? conversion : value;
+}
+function TryConvertLiteralBoolean(value, target) {
+  const conversion = TryConvertBoolean(value);
+  return conversion === target ? conversion : value;
+}
+function TryConvertLiteral(schema, value) {
+  return IsString2(schema.const) ? TryConvertLiteralString(value, schema.const) : IsNumber2(schema.const) ? TryConvertLiteralNumber(value, schema.const) : IsBoolean2(schema.const) ? TryConvertLiteralBoolean(value, schema.const) : value;
+}
+function TryConvertBoolean(value) {
+  return IsValueTrue(value) ? true : IsValueFalse(value) ? false : value;
+}
+function TryConvertBigInt(value) {
+  const truncateInteger = (value2) => value2.split(".")[0];
+  return IsStringNumeric(value) ? BigInt(truncateInteger(value)) : IsNumber2(value) ? BigInt(Math.trunc(value)) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
+}
+function TryConvertString(value) {
+  return IsSymbol2(value) && value.description !== void 0 ? value.description.toString() : IsValueToString(value) ? value.toString() : value;
+}
+function TryConvertNumber(value) {
+  return IsStringNumeric(value) ? parseFloat(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
+}
+function TryConvertInteger(value) {
+  return IsStringNumeric(value) ? parseInt(value) : IsNumber2(value) ? Math.trunc(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
+}
+function TryConvertNull(value) {
+  return IsString2(value) && value.toLowerCase() === "null" ? null : value;
+}
+function TryConvertUndefined(value) {
+  return IsString2(value) && value === "undefined" ? void 0 : value;
+}
+function TryConvertDate(value) {
+  return IsDate2(value) ? value : IsNumber2(value) ? new Date(value) : IsValueTrue(value) ? /* @__PURE__ */ new Date(1) : IsValueFalse(value) ? /* @__PURE__ */ new Date(0) : IsStringNumeric(value) ? new Date(parseInt(value)) : IsTimeStringWithoutTimeZone(value) ? /* @__PURE__ */ new Date(`1970-01-01T${value}.000Z`) : IsTimeStringWithTimeZone(value) ? /* @__PURE__ */ new Date(`1970-01-01T${value}`) : IsDateTimeStringWithoutTimeZone(value) ? /* @__PURE__ */ new Date(`${value}.000Z`) : IsDateTimeStringWithTimeZone(value) ? new Date(value) : IsDateString(value) ? /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`) : value;
+}
+function Default2(value) {
+  return value;
+}
+function FromArray13(schema, references, value) {
+  const elements = IsArray2(value) ? value : [value];
+  return elements.map((element) => Visit10(schema.items, references, element));
+}
+function FromBigInt5(schema, references, value) {
+  return TryConvertBigInt(value);
+}
+function FromBoolean5(schema, references, value) {
+  return TryConvertBoolean(value);
+}
+function FromDate6(schema, references, value) {
+  return TryConvertDate(value);
+}
+function FromImport6(schema, references, value) {
+  const definitions = globalThis.Object.values(schema.$defs);
+  const target = schema.$defs[schema.$ref];
+  return Visit10(target, [...references, ...definitions], value);
+}
+function FromInteger5(schema, references, value) {
+  return TryConvertInteger(value);
+}
+function FromIntersect14(schema, references, value) {
+  return schema.allOf.reduce((value2, schema2) => Visit10(schema2, references, value2), value);
+}
+function FromLiteral6(schema, references, value) {
+  return TryConvertLiteral(schema, value);
+}
+function FromNull5(schema, references, value) {
+  return TryConvertNull(value);
+}
+function FromNumber5(schema, references, value) {
+  return TryConvertNumber(value);
+}
+function FromObject14(schema, references, value) {
+  if (!IsObject2(value) || IsArray2(value))
+    return value;
+  for (const propertyKey of Object.getOwnPropertyNames(schema.properties)) {
+    if (!HasPropertyKey2(value, propertyKey))
+      continue;
+    value[propertyKey] = Visit10(schema.properties[propertyKey], references, value[propertyKey]);
+  }
+  return value;
+}
+function FromRecord9(schema, references, value) {
+  const isConvertable = IsObject2(value) && !IsArray2(value);
+  if (!isConvertable)
+    return value;
+  const propertyKey = Object.getOwnPropertyNames(schema.patternProperties)[0];
+  const property = schema.patternProperties[propertyKey];
+  for (const [propKey, propValue] of Object.entries(value)) {
+    value[propKey] = Visit10(property, references, propValue);
+  }
+  return value;
+}
+function FromRef10(schema, references, value) {
+  return Visit10(Deref(schema, references), references, value);
+}
+function FromString5(schema, references, value) {
+  return TryConvertString(value);
+}
+function FromSymbol5(schema, references, value) {
+  return IsString2(value) || IsNumber2(value) ? Symbol(value) : value;
+}
+function FromThis6(schema, references, value) {
+  return Visit10(Deref(schema, references), references, value);
+}
+function FromTuple11(schema, references, value) {
+  const isConvertable = IsArray2(value) && !IsUndefined2(schema.items);
+  if (!isConvertable)
+    return value;
+  return value.map((value2, index) => {
+    return index < schema.items.length ? Visit10(schema.items[index], references, value2) : value2;
+  });
+}
+function FromUndefined5(schema, references, value) {
+  return TryConvertUndefined(value);
+}
+function FromUnion16(schema, references, value) {
+  for (const subschema of schema.anyOf) {
+    if (Check(subschema, references, value)) {
+      return value;
+    }
+  }
+  for (const subschema of schema.anyOf) {
+    const converted = Visit10(subschema, references, Clone2(value));
+    if (!Check(subschema, references, converted))
+      continue;
+    return converted;
+  }
+  return value;
+}
+function Visit10(schema, references, value) {
+  const references_ = Pushref(schema, references);
+  const schema_ = schema;
+  switch (schema[Kind]) {
+    case "Array":
+      return FromArray13(schema_, references_, value);
+    case "BigInt":
+      return FromBigInt5(schema_, references_, value);
+    case "Boolean":
+      return FromBoolean5(schema_, references_, value);
+    case "Date":
+      return FromDate6(schema_, references_, value);
+    case "Import":
+      return FromImport6(schema_, references_, value);
+    case "Integer":
+      return FromInteger5(schema_, references_, value);
+    case "Intersect":
+      return FromIntersect14(schema_, references_, value);
+    case "Literal":
+      return FromLiteral6(schema_, references_, value);
+    case "Null":
+      return FromNull5(schema_, references_, value);
+    case "Number":
+      return FromNumber5(schema_, references_, value);
+    case "Object":
+      return FromObject14(schema_, references_, value);
+    case "Record":
+      return FromRecord9(schema_, references_, value);
+    case "Ref":
+      return FromRef10(schema_, references_, value);
+    case "String":
+      return FromString5(schema_, references_, value);
+    case "Symbol":
+      return FromSymbol5(schema_, references_, value);
+    case "This":
+      return FromThis6(schema_, references_, value);
+    case "Tuple":
+      return FromTuple11(schema_, references_, value);
+    case "Undefined":
+      return FromUndefined5(schema_, references_, value);
+    case "Union":
+      return FromUnion16(schema_, references_, value);
+    default:
+      return Default2(value);
+  }
+}
+function Convert(...args) {
+  return args.length === 3 ? Visit10(args[0], args[1], args[2]) : Visit10(args[0], [], args[1]);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/transform/decode.mjs
+var TransformDecodeCheckError = class extends TypeBoxError {
+  constructor(schema, value, error2) {
+    super(`Unable to decode value as it does not match the expected schema`);
+    this.schema = schema;
+    this.value = value;
+    this.error = error2;
+  }
+};
+var TransformDecodeError = class extends TypeBoxError {
+  constructor(schema, path, value, error2) {
+    super(error2 instanceof Error ? error2.message : "Unknown error");
+    this.schema = schema;
+    this.path = path;
+    this.value = value;
+    this.error = error2;
+  }
+};
+function Default3(schema, path, value) {
+  try {
+    return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
+  } catch (error2) {
+    throw new TransformDecodeError(schema, path, value, error2);
+  }
+}
+function FromArray14(schema, references, path, value) {
+  return IsArray2(value) ? Default3(schema, path, value.map((value2, index) => Visit11(schema.items, references, `${path}/${index}`, value2))) : Default3(schema, path, value);
+}
+function FromIntersect15(schema, references, path, value) {
+  if (!IsObject2(value) || IsValueType(value))
+    return Default3(schema, path, value);
+  const knownEntries = KeyOfPropertyEntries(schema);
+  const knownKeys = knownEntries.map((entry) => entry[0]);
+  const knownProperties = { ...value };
+  for (const [knownKey, knownSchema] of knownEntries)
+    if (knownKey in knownProperties) {
+      knownProperties[knownKey] = Visit11(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
+    }
+  if (!IsTransform(schema.unevaluatedProperties)) {
+    return Default3(schema, path, knownProperties);
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+  const unevaluatedProperties = schema.unevaluatedProperties;
+  const unknownProperties = { ...knownProperties };
+  for (const key of unknownKeys)
+    if (!knownKeys.includes(key)) {
+      unknownProperties[key] = Default3(unevaluatedProperties, `${path}/${key}`, unknownProperties[key]);
+    }
+  return Default3(schema, path, unknownProperties);
+}
+function FromImport7(schema, references, path, value) {
+  const additional = globalThis.Object.values(schema.$defs);
+  const target = schema.$defs[schema.$ref];
+  const result = Visit11(target, [...references, ...additional], path, value);
+  return Default3(schema, path, result);
+}
+function FromNot5(schema, references, path, value) {
+  return Default3(schema, path, Visit11(schema.not, references, path, value));
+}
+function FromObject15(schema, references, path, value) {
+  if (!IsObject2(value))
+    return Default3(schema, path, value);
+  const knownKeys = KeyOfPropertyKeys(schema);
+  const knownProperties = { ...value };
+  for (const key of knownKeys) {
+    if (!HasPropertyKey2(knownProperties, key))
+      continue;
+    if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+      continue;
+    knownProperties[key] = Visit11(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+  }
+  if (!IsSchema(schema.additionalProperties)) {
+    return Default3(schema, path, knownProperties);
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+  const additionalProperties = schema.additionalProperties;
+  const unknownProperties = { ...knownProperties };
+  for (const key of unknownKeys)
+    if (!knownKeys.includes(key)) {
+      unknownProperties[key] = Default3(additionalProperties, `${path}/${key}`, unknownProperties[key]);
+    }
+  return Default3(schema, path, unknownProperties);
+}
+function FromRecord10(schema, references, path, value) {
+  if (!IsObject2(value))
+    return Default3(schema, path, value);
+  const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+  const knownKeys = new RegExp(pattern);
+  const knownProperties = { ...value };
+  for (const key of Object.getOwnPropertyNames(value))
+    if (knownKeys.test(key)) {
+      knownProperties[key] = Visit11(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
+    }
+  if (!IsSchema(schema.additionalProperties)) {
+    return Default3(schema, path, knownProperties);
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+  const additionalProperties = schema.additionalProperties;
+  const unknownProperties = { ...knownProperties };
+  for (const key of unknownKeys)
+    if (!knownKeys.test(key)) {
+      unknownProperties[key] = Default3(additionalProperties, `${path}/${key}`, unknownProperties[key]);
+    }
+  return Default3(schema, path, unknownProperties);
+}
+function FromRef11(schema, references, path, value) {
+  const target = Deref(schema, references);
+  return Default3(schema, path, Visit11(target, references, path, value));
+}
+function FromThis7(schema, references, path, value) {
+  const target = Deref(schema, references);
+  return Default3(schema, path, Visit11(target, references, path, value));
+}
+function FromTuple12(schema, references, path, value) {
+  return IsArray2(value) && IsArray2(schema.items) ? Default3(schema, path, schema.items.map((schema2, index) => Visit11(schema2, references, `${path}/${index}`, value[index]))) : Default3(schema, path, value);
+}
+function FromUnion17(schema, references, path, value) {
+  for (const subschema of schema.anyOf) {
+    if (!Check(subschema, references, value))
+      continue;
+    const decoded = Visit11(subschema, references, path, value);
+    return Default3(schema, path, decoded);
+  }
+  return Default3(schema, path, value);
+}
+function Visit11(schema, references, path, value) {
+  const references_ = Pushref(schema, references);
+  const schema_ = schema;
+  switch (schema[Kind]) {
+    case "Array":
+      return FromArray14(schema_, references_, path, value);
+    case "Import":
+      return FromImport7(schema_, references_, path, value);
+    case "Intersect":
+      return FromIntersect15(schema_, references_, path, value);
+    case "Not":
+      return FromNot5(schema_, references_, path, value);
+    case "Object":
+      return FromObject15(schema_, references_, path, value);
+    case "Record":
+      return FromRecord10(schema_, references_, path, value);
+    case "Ref":
+      return FromRef11(schema_, references_, path, value);
+    case "Symbol":
+      return Default3(schema_, path, value);
+    case "This":
+      return FromThis7(schema_, references_, path, value);
+    case "Tuple":
+      return FromTuple12(schema_, references_, path, value);
+    case "Union":
+      return FromUnion17(schema_, references_, path, value);
+    default:
+      return Default3(schema_, path, value);
+  }
+}
+function TransformDecode(schema, references, value) {
+  return Visit11(schema, references, "", value);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/transform/encode.mjs
+var TransformEncodeCheckError = class extends TypeBoxError {
+  constructor(schema, value, error2) {
+    super(`The encoded value does not match the expected schema`);
+    this.schema = schema;
+    this.value = value;
+    this.error = error2;
+  }
+};
+var TransformEncodeError = class extends TypeBoxError {
+  constructor(schema, path, value, error2) {
+    super(`${error2 instanceof Error ? error2.message : "Unknown error"}`);
+    this.schema = schema;
+    this.path = path;
+    this.value = value;
+    this.error = error2;
+  }
+};
+function Default4(schema, path, value) {
+  try {
+    return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
+  } catch (error2) {
+    throw new TransformEncodeError(schema, path, value, error2);
+  }
+}
+function FromArray15(schema, references, path, value) {
+  const defaulted = Default4(schema, path, value);
+  return IsArray2(defaulted) ? defaulted.map((value2, index) => Visit12(schema.items, references, `${path}/${index}`, value2)) : defaulted;
+}
+function FromImport8(schema, references, path, value) {
   const additional = globalThis.Object.values(schema.$defs);
   const target = schema.$defs[schema.$ref];
-  const result = Default2(schema, path, value);
-  return Visit8(target, [...references, ...additional], path, result);
+  const result = Default4(schema, path, value);
+  return Visit12(target, [...references, ...additional], path, result);
 }
-function FromIntersect12(schema, references, path, value) {
-  const defaulted = Default2(schema, path, value);
+function FromIntersect16(schema, references, path, value) {
+  const defaulted = Default4(schema, path, value);
   if (!IsObject2(value) || IsValueType(value))
     return defaulted;
   const knownEntries = KeyOfPropertyEntries(schema);
@@ -4231,7 +5267,7 @@ function FromIntersect12(schema, references, path, value) {
   const knownProperties = { ...defaulted };
   for (const [knownKey, knownSchema] of knownEntries)
     if (knownKey in knownProperties) {
-      knownProperties[knownKey] = Visit8(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
+      knownProperties[knownKey] = Visit12(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
     }
   if (!IsTransform(schema.unevaluatedProperties)) {
     return knownProperties;
@@ -4241,15 +5277,15 @@ function FromIntersect12(schema, references, path, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      properties[key] = Default2(unevaluatedProperties, `${path}/${key}`, properties[key]);
+      properties[key] = Default4(unevaluatedProperties, `${path}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromNot5(schema, references, path, value) {
-  return Default2(schema.not, path, Default2(schema, path, value));
+function FromNot6(schema, references, path, value) {
+  return Default4(schema.not, path, Default4(schema, path, value));
 }
-function FromObject11(schema, references, path, value) {
-  const defaulted = Default2(schema, path, value);
+function FromObject16(schema, references, path, value) {
+  const defaulted = Default4(schema, path, value);
   if (!IsObject2(defaulted))
     return defaulted;
   const knownKeys = KeyOfPropertyKeys(schema);
@@ -4259,7 +5295,7 @@ function FromObject11(schema, references, path, value) {
       continue;
     if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
-    knownProperties[key] = Visit8(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+    knownProperties[key] = Visit12(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
   }
   if (!IsSchema(schema.additionalProperties)) {
     return knownProperties;
@@ -4269,12 +5305,12 @@ function FromObject11(schema, references, path, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.includes(key)) {
-      properties[key] = Default2(additionalProperties, `${path}/${key}`, properties[key]);
+      properties[key] = Default4(additionalProperties, `${path}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRecord7(schema, references, path, value) {
-  const defaulted = Default2(schema, path, value);
+function FromRecord11(schema, references, path, value) {
+  const defaulted = Default4(schema, path, value);
   if (!IsObject2(value))
     return defaulted;
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
@@ -4282,7 +5318,7 @@ function FromRecord7(schema, references, path, value) {
   const knownProperties = { ...defaulted };
   for (const key of Object.getOwnPropertyNames(value))
     if (knownKeys.test(key)) {
-      knownProperties[key] = Visit8(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
+      knownProperties[key] = Visit12(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
     }
   if (!IsSchema(schema.additionalProperties)) {
     return knownProperties;
@@ -4292,126 +5328,126 @@ function FromRecord7(schema, references, path, value) {
   const properties = { ...knownProperties };
   for (const key of unknownKeys)
     if (!knownKeys.test(key)) {
-      properties[key] = Default2(additionalProperties, `${path}/${key}`, properties[key]);
+      properties[key] = Default4(additionalProperties, `${path}/${key}`, properties[key]);
     }
   return properties;
 }
-function FromRef8(schema, references, path, value) {
+function FromRef12(schema, references, path, value) {
   const target = Deref(schema, references);
-  const resolved = Visit8(target, references, path, value);
-  return Default2(schema, path, resolved);
+  const resolved = Visit12(target, references, path, value);
+  return Default4(schema, path, resolved);
 }
-function FromThis4(schema, references, path, value) {
+function FromThis8(schema, references, path, value) {
   const target = Deref(schema, references);
-  const resolved = Visit8(target, references, path, value);
-  return Default2(schema, path, resolved);
+  const resolved = Visit12(target, references, path, value);
+  return Default4(schema, path, resolved);
 }
-function FromTuple9(schema, references, path, value) {
-  const value1 = Default2(schema, path, value);
-  return IsArray2(schema.items) ? schema.items.map((schema2, index) => Visit8(schema2, references, `${path}/${index}`, value1[index])) : [];
+function FromTuple13(schema, references, path, value) {
+  const value1 = Default4(schema, path, value);
+  return IsArray2(schema.items) ? schema.items.map((schema2, index) => Visit12(schema2, references, `${path}/${index}`, value1[index])) : [];
 }
-function FromUnion14(schema, references, path, value) {
+function FromUnion18(schema, references, path, value) {
   for (const subschema of schema.anyOf) {
     if (!Check(subschema, references, value))
       continue;
-    const value1 = Visit8(subschema, references, path, value);
-    return Default2(schema, path, value1);
+    const value1 = Visit12(subschema, references, path, value);
+    return Default4(schema, path, value1);
   }
   for (const subschema of schema.anyOf) {
-    const value1 = Visit8(subschema, references, path, value);
+    const value1 = Visit12(subschema, references, path, value);
     if (!Check(schema, references, value1))
       continue;
-    return Default2(schema, path, value1);
+    return Default4(schema, path, value1);
   }
-  return Default2(schema, path, value);
+  return Default4(schema, path, value);
 }
-function Visit8(schema, references, path, value) {
+function Visit12(schema, references, path, value) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   switch (schema[Kind]) {
     case "Array":
-      return FromArray10(schema_, references_, path, value);
+      return FromArray15(schema_, references_, path, value);
     case "Import":
-      return FromImport4(schema_, references_, path, value);
+      return FromImport8(schema_, references_, path, value);
     case "Intersect":
-      return FromIntersect12(schema_, references_, path, value);
+      return FromIntersect16(schema_, references_, path, value);
     case "Not":
-      return FromNot5(schema_, references_, path, value);
+      return FromNot6(schema_, references_, path, value);
     case "Object":
-      return FromObject11(schema_, references_, path, value);
+      return FromObject16(schema_, references_, path, value);
     case "Record":
-      return FromRecord7(schema_, references_, path, value);
+      return FromRecord11(schema_, references_, path, value);
     case "Ref":
-      return FromRef8(schema_, references_, path, value);
+      return FromRef12(schema_, references_, path, value);
     case "This":
-      return FromThis4(schema_, references_, path, value);
+      return FromThis8(schema_, references_, path, value);
     case "Tuple":
-      return FromTuple9(schema_, references_, path, value);
+      return FromTuple13(schema_, references_, path, value);
     case "Union":
-      return FromUnion14(schema_, references_, path, value);
+      return FromUnion18(schema_, references_, path, value);
     default:
-      return Default2(schema_, path, value);
+      return Default4(schema_, path, value);
   }
 }
 function TransformEncode(schema, references, value) {
-  return Visit8(schema, references, "", value);
+  return Visit12(schema, references, "", value);
 }
 
 // ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/transform/has.mjs
-function FromArray11(schema, references) {
-  return IsTransform(schema) || Visit9(schema.items, references);
+function FromArray16(schema, references) {
+  return IsTransform(schema) || Visit13(schema.items, references);
 }
-function FromAsyncIterator6(schema, references) {
-  return IsTransform(schema) || Visit9(schema.items, references);
+function FromAsyncIterator7(schema, references) {
+  return IsTransform(schema) || Visit13(schema.items, references);
 }
-function FromConstructor6(schema, references) {
-  return IsTransform(schema) || Visit9(schema.returns, references) || schema.parameters.some((schema2) => Visit9(schema2, references));
+function FromConstructor8(schema, references) {
+  return IsTransform(schema) || Visit13(schema.returns, references) || schema.parameters.some((schema2) => Visit13(schema2, references));
 }
-function FromFunction6(schema, references) {
-  return IsTransform(schema) || Visit9(schema.returns, references) || schema.parameters.some((schema2) => Visit9(schema2, references));
+function FromFunction7(schema, references) {
+  return IsTransform(schema) || Visit13(schema.returns, references) || schema.parameters.some((schema2) => Visit13(schema2, references));
 }
-function FromIntersect13(schema, references) {
-  return IsTransform(schema) || IsTransform(schema.unevaluatedProperties) || schema.allOf.some((schema2) => Visit9(schema2, references));
+function FromIntersect17(schema, references) {
+  return IsTransform(schema) || IsTransform(schema.unevaluatedProperties) || schema.allOf.some((schema2) => Visit13(schema2, references));
 }
-function FromImport5(schema, references) {
+function FromImport9(schema, references) {
   const additional = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => [...result, schema.$defs[key]], []);
   const target = schema.$defs[schema.$ref];
-  return IsTransform(schema) || Visit9(target, [...additional, ...references]);
+  return IsTransform(schema) || Visit13(target, [...additional, ...references]);
 }
-function FromIterator6(schema, references) {
-  return IsTransform(schema) || Visit9(schema.items, references);
+function FromIterator7(schema, references) {
+  return IsTransform(schema) || Visit13(schema.items, references);
 }
-function FromNot6(schema, references) {
-  return IsTransform(schema) || Visit9(schema.not, references);
+function FromNot7(schema, references) {
+  return IsTransform(schema) || Visit13(schema.not, references);
 }
-function FromObject12(schema, references) {
-  return IsTransform(schema) || Object.values(schema.properties).some((schema2) => Visit9(schema2, references)) || IsSchema(schema.additionalProperties) && Visit9(schema.additionalProperties, references);
+function FromObject17(schema, references) {
+  return IsTransform(schema) || Object.values(schema.properties).some((schema2) => Visit13(schema2, references)) || IsSchema(schema.additionalProperties) && Visit13(schema.additionalProperties, references);
 }
-function FromPromise6(schema, references) {
-  return IsTransform(schema) || Visit9(schema.item, references);
+function FromPromise7(schema, references) {
+  return IsTransform(schema) || Visit13(schema.item, references);
 }
-function FromRecord8(schema, references) {
+function FromRecord12(schema, references) {
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
   const property = schema.patternProperties[pattern];
-  return IsTransform(schema) || Visit9(property, references) || IsSchema(schema.additionalProperties) && IsTransform(schema.additionalProperties);
+  return IsTransform(schema) || Visit13(property, references) || IsSchema(schema.additionalProperties) && IsTransform(schema.additionalProperties);
 }
-function FromRef9(schema, references) {
+function FromRef13(schema, references) {
   if (IsTransform(schema))
     return true;
-  return Visit9(Deref(schema, references), references);
+  return Visit13(Deref(schema, references), references);
 }
-function FromThis5(schema, references) {
+function FromThis9(schema, references) {
   if (IsTransform(schema))
     return true;
-  return Visit9(Deref(schema, references), references);
+  return Visit13(Deref(schema, references), references);
 }
-function FromTuple10(schema, references) {
-  return IsTransform(schema) || !IsUndefined2(schema.items) && schema.items.some((schema2) => Visit9(schema2, references));
+function FromTuple14(schema, references) {
+  return IsTransform(schema) || !IsUndefined2(schema.items) && schema.items.some((schema2) => Visit13(schema2, references));
 }
-function FromUnion15(schema, references) {
-  return IsTransform(schema) || schema.anyOf.some((schema2) => Visit9(schema2, references));
+function FromUnion19(schema, references) {
+  return IsTransform(schema) || schema.anyOf.some((schema2) => Visit13(schema2, references));
 }
-function Visit9(schema, references) {
+function Visit13(schema, references) {
   const references_ = Pushref(schema, references);
   const schema_ = schema;
   if (schema.$id && visited.has(schema.$id))
@@ -4420,35 +5456,35 @@ function Visit9(schema, references) {
     visited.add(schema.$id);
   switch (schema[Kind]) {
     case "Array":
-      return FromArray11(schema_, references_);
+      return FromArray16(schema_, references_);
     case "AsyncIterator":
-      return FromAsyncIterator6(schema_, references_);
+      return FromAsyncIterator7(schema_, references_);
     case "Constructor":
-      return FromConstructor6(schema_, references_);
+      return FromConstructor8(schema_, references_);
     case "Function":
-      return FromFunction6(schema_, references_);
+      return FromFunction7(schema_, references_);
     case "Import":
-      return FromImport5(schema_, references_);
+      return FromImport9(schema_, references_);
     case "Intersect":
-      return FromIntersect13(schema_, references_);
+      return FromIntersect17(schema_, references_);
     case "Iterator":
-      return FromIterator6(schema_, references_);
+      return FromIterator7(schema_, references_);
     case "Not":
-      return FromNot6(schema_, references_);
+      return FromNot7(schema_, references_);
     case "Object":
-      return FromObject12(schema_, references_);
+      return FromObject17(schema_, references_);
     case "Promise":
-      return FromPromise6(schema_, references_);
+      return FromPromise7(schema_, references_);
     case "Record":
-      return FromRecord8(schema_, references_);
+      return FromRecord12(schema_, references_);
     case "Ref":
-      return FromRef9(schema_, references_);
+      return FromRef13(schema_, references_);
     case "This":
-      return FromThis5(schema_, references_);
+      return FromThis9(schema_, references_);
     case "Tuple":
-      return FromTuple10(schema_, references_);
+      return FromTuple14(schema_, references_);
     case "Union":
-      return FromUnion15(schema_, references_);
+      return FromUnion19(schema_, references_);
     default:
       return IsTransform(schema);
   }
@@ -4456,8 +5492,604 @@ function Visit9(schema, references) {
 var visited = /* @__PURE__ */ new Set();
 function HasTransform(schema, references) {
   visited.clear();
-  return Visit9(schema, references);
+  return Visit13(schema, references);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/decode/decode.mjs
+function Decode(...args) {
+  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+  if (!Check(schema, references, value))
+    throw new TransformDecodeCheckError(schema, value, Errors(schema, references, value).First());
+  return HasTransform(schema, references) ? TransformDecode(schema, references, value) : value;
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/default/default.mjs
+function ValueOrDefault(schema, value) {
+  const defaultValue = HasPropertyKey2(schema, "default") ? schema.default : void 0;
+  const clone = IsFunction2(defaultValue) ? defaultValue() : Clone2(defaultValue);
+  return IsUndefined2(value) ? clone : IsObject2(value) && IsObject2(clone) ? Object.assign(clone, value) : value;
+}
+function HasDefaultProperty(schema) {
+  return IsKind(schema) && "default" in schema;
+}
+function FromArray17(schema, references, value) {
+  if (IsArray2(value)) {
+    for (let i = 0; i < value.length; i++) {
+      value[i] = Visit14(schema.items, references, value[i]);
+    }
+    return value;
+  }
+  const defaulted = ValueOrDefault(schema, value);
+  if (!IsArray2(defaulted))
+    return defaulted;
+  for (let i = 0; i < defaulted.length; i++) {
+    defaulted[i] = Visit14(schema.items, references, defaulted[i]);
+  }
+  return defaulted;
+}
+function FromDate7(schema, references, value) {
+  return IsDate2(value) ? value : ValueOrDefault(schema, value);
+}
+function FromImport10(schema, references, value) {
+  const definitions = globalThis.Object.values(schema.$defs);
+  const target = schema.$defs[schema.$ref];
+  return Visit14(target, [...references, ...definitions], value);
+}
+function FromIntersect18(schema, references, value) {
+  const defaulted = ValueOrDefault(schema, value);
+  return schema.allOf.reduce((acc, schema2) => {
+    const next = Visit14(schema2, references, defaulted);
+    return IsObject2(next) ? { ...acc, ...next } : next;
+  }, {});
+}
+function FromObject18(schema, references, value) {
+  const defaulted = ValueOrDefault(schema, value);
+  if (!IsObject2(defaulted))
+    return defaulted;
+  const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties);
+  for (const key of knownPropertyKeys) {
+    const propertyValue = Visit14(schema.properties[key], references, defaulted[key]);
+    if (IsUndefined2(propertyValue))
+      continue;
+    defaulted[key] = Visit14(schema.properties[key], references, defaulted[key]);
+  }
+  if (!HasDefaultProperty(schema.additionalProperties))
+    return defaulted;
+  for (const key of Object.getOwnPropertyNames(defaulted)) {
+    if (knownPropertyKeys.includes(key))
+      continue;
+    defaulted[key] = Visit14(schema.additionalProperties, references, defaulted[key]);
+  }
+  return defaulted;
+}
+function FromRecord13(schema, references, value) {
+  const defaulted = ValueOrDefault(schema, value);
+  if (!IsObject2(defaulted))
+    return defaulted;
+  const additionalPropertiesSchema = schema.additionalProperties;
+  const [propertyKeyPattern, propertySchema] = Object.entries(schema.patternProperties)[0];
+  const knownPropertyKey = new RegExp(propertyKeyPattern);
+  for (const key of Object.getOwnPropertyNames(defaulted)) {
+    if (!(knownPropertyKey.test(key) && HasDefaultProperty(propertySchema)))
+      continue;
+    defaulted[key] = Visit14(propertySchema, references, defaulted[key]);
+  }
+  if (!HasDefaultProperty(additionalPropertiesSchema))
+    return defaulted;
+  for (const key of Object.getOwnPropertyNames(defaulted)) {
+    if (knownPropertyKey.test(key))
+      continue;
+    defaulted[key] = Visit14(additionalPropertiesSchema, references, defaulted[key]);
+  }
+  return defaulted;
+}
+function FromRef14(schema, references, value) {
+  return Visit14(Deref(schema, references), references, ValueOrDefault(schema, value));
+}
+function FromThis10(schema, references, value) {
+  return Visit14(Deref(schema, references), references, value);
+}
+function FromTuple15(schema, references, value) {
+  const defaulted = ValueOrDefault(schema, value);
+  if (!IsArray2(defaulted) || IsUndefined2(schema.items))
+    return defaulted;
+  const [items, max] = [schema.items, Math.max(schema.items.length, defaulted.length)];
+  for (let i = 0; i < max; i++) {
+    if (i < items.length)
+      defaulted[i] = Visit14(items[i], references, defaulted[i]);
+  }
+  return defaulted;
+}
+function FromUnion20(schema, references, value) {
+  const defaulted = ValueOrDefault(schema, value);
+  for (const inner of schema.anyOf) {
+    const result = Visit14(inner, references, Clone2(defaulted));
+    if (Check(inner, references, result)) {
+      return result;
+    }
+  }
+  return defaulted;
+}
+function Visit14(schema, references, value) {
+  const references_ = Pushref(schema, references);
+  const schema_ = schema;
+  switch (schema_[Kind]) {
+    case "Array":
+      return FromArray17(schema_, references_, value);
+    case "Date":
+      return FromDate7(schema_, references_, value);
+    case "Import":
+      return FromImport10(schema_, references_, value);
+    case "Intersect":
+      return FromIntersect18(schema_, references_, value);
+    case "Object":
+      return FromObject18(schema_, references_, value);
+    case "Record":
+      return FromRecord13(schema_, references_, value);
+    case "Ref":
+      return FromRef14(schema_, references_, value);
+    case "This":
+      return FromThis10(schema_, references_, value);
+    case "Tuple":
+      return FromTuple15(schema_, references_, value);
+    case "Union":
+      return FromUnion20(schema_, references_, value);
+    default:
+      return ValueOrDefault(schema_, value);
+  }
+}
+function Default5(...args) {
+  return args.length === 3 ? Visit14(args[0], args[1], args[2]) : Visit14(args[0], [], args[1]);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/pointer/pointer.mjs
+var pointer_exports = {};
+__export(pointer_exports, {
+  Delete: () => Delete3,
+  Format: () => Format,
+  Get: () => Get3,
+  Has: () => Has3,
+  Set: () => Set4,
+  ValuePointerRootDeleteError: () => ValuePointerRootDeleteError,
+  ValuePointerRootSetError: () => ValuePointerRootSetError
+});
+var ValuePointerRootSetError = class extends TypeBoxError {
+  constructor(value, path, update) {
+    super("Cannot set root value");
+    this.value = value;
+    this.path = path;
+    this.update = update;
+  }
+};
+var ValuePointerRootDeleteError = class extends TypeBoxError {
+  constructor(value, path) {
+    super("Cannot delete root value");
+    this.value = value;
+    this.path = path;
+  }
+};
+function Escape2(component) {
+  return component.indexOf("~") === -1 ? component : component.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function* Format(pointer) {
+  if (pointer === "")
+    return;
+  let [start, end] = [0, 0];
+  for (let i = 0; i < pointer.length; i++) {
+    const char = pointer.charAt(i);
+    if (char === "/") {
+      if (i === 0) {
+        start = i + 1;
+      } else {
+        end = i;
+        yield Escape2(pointer.slice(start, end));
+        start = i + 1;
+      }
+    } else {
+      end = i;
+    }
+  }
+  yield Escape2(pointer.slice(start));
+}
+function Set4(value, pointer, update) {
+  if (pointer === "")
+    throw new ValuePointerRootSetError(value, pointer, update);
+  let [owner, next, key] = [null, value, ""];
+  for (const component of Format(pointer)) {
+    if (next[component] === void 0)
+      next[component] = {};
+    owner = next;
+    next = next[component];
+    key = component;
+  }
+  owner[key] = update;
+}
+function Delete3(value, pointer) {
+  if (pointer === "")
+    throw new ValuePointerRootDeleteError(value, pointer);
+  let [owner, next, key] = [null, value, ""];
+  for (const component of Format(pointer)) {
+    if (next[component] === void 0 || next[component] === null)
+      return;
+    owner = next;
+    next = next[component];
+    key = component;
+  }
+  if (Array.isArray(owner)) {
+    const index = parseInt(key);
+    owner.splice(index, 1);
+  } else {
+    delete owner[key];
+  }
+}
+function Has3(value, pointer) {
+  if (pointer === "")
+    return true;
+  let [owner, next, key] = [null, value, ""];
+  for (const component of Format(pointer)) {
+    if (next[component] === void 0)
+      return false;
+    owner = next;
+    next = next[component];
+    key = component;
+  }
+  return Object.getOwnPropertyNames(owner).includes(key);
+}
+function Get3(value, pointer) {
+  if (pointer === "")
+    return value;
+  let current = value;
+  for (const component of Format(pointer)) {
+    if (current[component] === void 0)
+      return void 0;
+    current = current[component];
+  }
+  return current;
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/equal/equal.mjs
+function ObjectType3(left, right) {
+  if (!IsObject2(right))
+    return false;
+  const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
+  const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
+  if (leftKeys.length !== rightKeys.length)
+    return false;
+  return leftKeys.every((key) => Equal(left[key], right[key]));
+}
+function DateType3(left, right) {
+  return IsDate2(right) && left.getTime() === right.getTime();
+}
+function ArrayType3(left, right) {
+  if (!IsArray2(right) || left.length !== right.length)
+    return false;
+  return left.every((value, index) => Equal(value, right[index]));
+}
+function TypedArrayType(left, right) {
+  if (!IsTypedArray(right) || left.length !== right.length || Object.getPrototypeOf(left).constructor.name !== Object.getPrototypeOf(right).constructor.name)
+    return false;
+  return left.every((value, index) => Equal(value, right[index]));
+}
+function ValueType(left, right) {
+  return left === right;
+}
+function Equal(left, right) {
+  if (IsDate2(left))
+    return DateType3(left, right);
+  if (IsTypedArray(left))
+    return TypedArrayType(left, right);
+  if (IsArray2(left))
+    return ArrayType3(left, right);
+  if (IsObject2(left))
+    return ObjectType3(left, right);
+  if (IsValueType(left))
+    return ValueType(left, right);
+  throw new Error("ValueEquals: Unable to compare value");
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/delta/delta.mjs
+var Insert = Object2({
+  type: Literal("insert"),
+  path: String2(),
+  value: Unknown()
+});
+var Update = Object2({
+  type: Literal("update"),
+  path: String2(),
+  value: Unknown()
+});
+var Delete4 = Object2({
+  type: Literal("delete"),
+  path: String2()
+});
+var Edit = Union([Insert, Update, Delete4]);
+var ValueDiffError = class extends TypeBoxError {
+  constructor(value, message) {
+    super(message);
+    this.value = value;
+  }
+};
+function CreateUpdate(path, value) {
+  return { type: "update", path, value };
+}
+function CreateInsert(path, value) {
+  return { type: "insert", path, value };
+}
+function CreateDelete(path) {
+  return { type: "delete", path };
+}
+function AssertDiffable(value) {
+  if (globalThis.Object.getOwnPropertySymbols(value).length > 0)
+    throw new ValueDiffError(value, "Cannot diff objects with symbols");
+}
+function* ObjectType4(path, current, next) {
+  AssertDiffable(current);
+  AssertDiffable(next);
+  if (!IsStandardObject(next))
+    return yield CreateUpdate(path, next);
+  const currentKeys = globalThis.Object.getOwnPropertyNames(current);
+  const nextKeys = globalThis.Object.getOwnPropertyNames(next);
+  for (const key of nextKeys) {
+    if (HasPropertyKey2(current, key))
+      continue;
+    yield CreateInsert(`${path}/${key}`, next[key]);
+  }
+  for (const key of currentKeys) {
+    if (!HasPropertyKey2(next, key))
+      continue;
+    if (Equal(current, next))
+      continue;
+    yield* Visit15(`${path}/${key}`, current[key], next[key]);
+  }
+  for (const key of currentKeys) {
+    if (HasPropertyKey2(next, key))
+      continue;
+    yield CreateDelete(`${path}/${key}`);
+  }
+}
+function* ArrayType4(path, current, next) {
+  if (!IsArray2(next))
+    return yield CreateUpdate(path, next);
+  for (let i = 0; i < Math.min(current.length, next.length); i++) {
+    yield* Visit15(`${path}/${i}`, current[i], next[i]);
+  }
+  for (let i = 0; i < next.length; i++) {
+    if (i < current.length)
+      continue;
+    yield CreateInsert(`${path}/${i}`, next[i]);
+  }
+  for (let i = current.length - 1; i >= 0; i--) {
+    if (i < next.length)
+      continue;
+    yield CreateDelete(`${path}/${i}`);
+  }
+}
+function* TypedArrayType2(path, current, next) {
+  if (!IsTypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name)
+    return yield CreateUpdate(path, next);
+  for (let i = 0; i < Math.min(current.length, next.length); i++) {
+    yield* Visit15(`${path}/${i}`, current[i], next[i]);
+  }
+}
+function* ValueType2(path, current, next) {
+  if (current === next)
+    return;
+  yield CreateUpdate(path, next);
+}
+function* Visit15(path, current, next) {
+  if (IsStandardObject(current))
+    return yield* ObjectType4(path, current, next);
+  if (IsArray2(current))
+    return yield* ArrayType4(path, current, next);
+  if (IsTypedArray(current))
+    return yield* TypedArrayType2(path, current, next);
+  if (IsValueType(current))
+    return yield* ValueType2(path, current, next);
+  throw new ValueDiffError(current, "Unable to diff value");
+}
+function Diff(current, next) {
+  return [...Visit15("", current, next)];
+}
+function IsRootUpdate(edits) {
+  return edits.length > 0 && edits[0].path === "" && edits[0].type === "update";
+}
+function IsIdentity(edits) {
+  return edits.length === 0;
+}
+function Patch(current, edits) {
+  if (IsRootUpdate(edits)) {
+    return Clone2(edits[0].value);
+  }
+  if (IsIdentity(edits)) {
+    return Clone2(current);
+  }
+  const clone = Clone2(current);
+  for (const edit of edits) {
+    switch (edit.type) {
+      case "insert": {
+        pointer_exports.Set(clone, edit.path, edit.value);
+        break;
+      }
+      case "update": {
+        pointer_exports.Set(clone, edit.path, edit.value);
+        break;
+      }
+      case "delete": {
+        pointer_exports.Delete(clone, edit.path);
+        break;
+      }
+    }
+  }
+  return clone;
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/encode/encode.mjs
+function Encode(...args) {
+  const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
+  const encoded = HasTransform(schema, references) ? TransformEncode(schema, references, value) : value;
+  if (!Check(schema, references, encoded))
+    throw new TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First());
+  return encoded;
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/mutate/mutate.mjs
+function IsStandardObject2(value) {
+  return IsObject2(value) && !IsArray2(value);
+}
+var ValueMutateError = class extends TypeBoxError {
+  constructor(message) {
+    super(message);
+  }
+};
+function ObjectType5(root, path, current, next) {
+  if (!IsStandardObject2(current)) {
+    pointer_exports.Set(root, path, Clone2(next));
+  } else {
+    const currentKeys = Object.getOwnPropertyNames(current);
+    const nextKeys = Object.getOwnPropertyNames(next);
+    for (const currentKey of currentKeys) {
+      if (!nextKeys.includes(currentKey)) {
+        delete current[currentKey];
+      }
+    }
+    for (const nextKey of nextKeys) {
+      if (!currentKeys.includes(nextKey)) {
+        current[nextKey] = null;
+      }
+    }
+    for (const nextKey of nextKeys) {
+      Visit16(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
+    }
+  }
+}
+function ArrayType5(root, path, current, next) {
+  if (!IsArray2(current)) {
+    pointer_exports.Set(root, path, Clone2(next));
+  } else {
+    for (let index = 0; index < next.length; index++) {
+      Visit16(root, `${path}/${index}`, current[index], next[index]);
+    }
+    current.splice(next.length);
+  }
+}
+function TypedArrayType3(root, path, current, next) {
+  if (IsTypedArray(current) && current.length === next.length) {
+    for (let i = 0; i < current.length; i++) {
+      current[i] = next[i];
+    }
+  } else {
+    pointer_exports.Set(root, path, Clone2(next));
+  }
 }
+function ValueType3(root, path, current, next) {
+  if (current === next)
+    return;
+  pointer_exports.Set(root, path, next);
+}
+function Visit16(root, path, current, next) {
+  if (IsArray2(next))
+    return ArrayType5(root, path, current, next);
+  if (IsTypedArray(next))
+    return TypedArrayType3(root, path, current, next);
+  if (IsStandardObject2(next))
+    return ObjectType5(root, path, current, next);
+  if (IsValueType(next))
+    return ValueType3(root, path, current, next);
+}
+function IsNonMutableValue(value) {
+  return IsTypedArray(value) || IsValueType(value);
+}
+function IsMismatchedValue(current, next) {
+  return IsStandardObject2(current) && IsArray2(next) || IsArray2(current) && IsStandardObject2(next);
+}
+function Mutate(current, next) {
+  if (IsNonMutableValue(current) || IsNonMutableValue(next))
+    throw new ValueMutateError("Only object and array types can be mutated at the root level");
+  if (IsMismatchedValue(current, next))
+    throw new ValueMutateError("Cannot assign due type mismatch of assignable values");
+  Visit16(current, "", current, next);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/parse/parse.mjs
+var ParseError = class extends TypeBoxError {
+  constructor(message) {
+    super(message);
+  }
+};
+var ParseRegistry;
+(function(ParseRegistry2) {
+  const registry = /* @__PURE__ */ new Map([
+    ["Assert", (type, references, value) => {
+      Assert(type, references, value);
+      return value;
+    }],
+    ["Cast", (type, references, value) => Cast(type, references, value)],
+    ["Clean", (type, references, value) => Clean(type, references, value)],
+    ["Clone", (_type, _references, value) => Clone2(value)],
+    ["Convert", (type, references, value) => Convert(type, references, value)],
+    ["Decode", (type, references, value) => HasTransform(type, references) ? TransformDecode(type, references, value) : value],
+    ["Default", (type, references, value) => Default5(type, references, value)],
+    ["Encode", (type, references, value) => HasTransform(type, references) ? TransformEncode(type, references, value) : value]
+  ]);
+  function Delete5(key) {
+    registry.delete(key);
+  }
+  ParseRegistry2.Delete = Delete5;
+  function Set5(key, callback) {
+    registry.set(key, callback);
+  }
+  ParseRegistry2.Set = Set5;
+  function Get4(key) {
+    return registry.get(key);
+  }
+  ParseRegistry2.Get = Get4;
+})(ParseRegistry || (ParseRegistry = {}));
+var ParseDefault = [
+  "Clone",
+  "Clean",
+  "Default",
+  "Convert",
+  "Assert",
+  "Decode"
+];
+function ParseValue(operations, type, references, value) {
+  return operations.reduce((value2, operationKey) => {
+    const operation = ParseRegistry.Get(operationKey);
+    if (IsUndefined2(operation))
+      throw new ParseError(`Unable to find Parse operation '${operationKey}'`);
+    return operation(type, references, value2);
+  }, value);
+}
+function Parse(...args) {
+  const [operations, schema, references, value] = args.length === 4 ? [args[0], args[1], args[2], args[3]] : args.length === 3 ? IsArray2(args[0]) ? [args[0], args[1], [], args[2]] : [ParseDefault, args[0], args[1], args[2]] : args.length === 2 ? [ParseDefault, args[0], [], args[1]] : (() => {
+    throw new ParseError("Invalid Arguments");
+  })();
+  return ParseValue(operations, schema, references, value);
+}
+
+// ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/value/value.mjs
+var value_exports2 = {};
+__export(value_exports2, {
+  Assert: () => Assert,
+  Cast: () => Cast,
+  Check: () => Check,
+  Clean: () => Clean,
+  Clone: () => Clone2,
+  Convert: () => Convert,
+  Create: () => Create2,
+  Decode: () => Decode,
+  Default: () => Default5,
+  Diff: () => Diff,
+  Edit: () => Edit,
+  Encode: () => Encode,
+  Equal: () => Equal,
+  Errors: () => Errors,
+  Hash: () => Hash,
+  Mutate: () => Mutate,
+  Parse: () => Parse,
+  Patch: () => Patch,
+  ValueErrorIterator: () => ValueErrorIterator
+});
 
 // ../protocol/dist/types.js
 var REF_PATTERN = /^e\d+_\d+$/;
@@ -5042,7 +6674,7 @@ var Character;
 })(Character || (Character = {}));
 var Identifier;
 (function(Identifier2) {
-  function Encode($id) {
+  function Encode2($id) {
     const buffer = [];
     for (let i = 0; i < $id.length; i++) {
       const code = $id.charCodeAt(i);
@@ -5054,7 +6686,7 @@ var Identifier;
     }
     return buffer.join("").replace(/__/g, "_");
   }
-  Identifier2.Encode = Encode;
+  Identifier2.Encode = Encode2;
 })(Identifier || (Identifier = {}));
 function StringConstant(value) {
   if (!IsString2(value))
@@ -5106,13 +6738,13 @@ var TypeCompiler;
   function IsAnyOrUnknown2(schema) {
     return schema[Kind] === "Any" || schema[Kind] === "Unknown";
   }
-  function* FromAny4(schema, references, value) {
+  function* FromAny5(schema, references, value) {
     yield "true";
   }
-  function* FromArgument4(schema, references, value) {
+  function* FromArgument5(schema, references, value) {
     yield "true";
   }
-  function* FromArray12(schema, references, value) {
+  function* FromArray18(schema, references, value) {
     yield `Array.isArray(${value})`;
     const [parameter, accumulator] = [CreateParameter("value", "any"), CreateParameter("acc", "number")];
     if (IsNumber2(schema.maxItems))
@@ -5136,10 +6768,10 @@ var TypeCompiler;
       yield `((${parameter}) => { ${block} )(${value})`;
     }
   }
-  function* FromAsyncIterator7(schema, references, value) {
+  function* FromAsyncIterator8(schema, references, value) {
     yield `(typeof value === 'object' && Symbol.asyncIterator in ${value})`;
   }
-  function* FromBigInt4(schema, references, value) {
+  function* FromBigInt6(schema, references, value) {
     yield `(typeof ${value} === 'bigint')`;
     if (IsBigInt2(schema.exclusiveMaximum))
       yield `${value} < BigInt(${schema.exclusiveMaximum})`;
@@ -5152,13 +6784,13 @@ var TypeCompiler;
     if (IsBigInt2(schema.multipleOf))
       yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
   }
-  function* FromBoolean4(schema, references, value) {
+  function* FromBoolean6(schema, references, value) {
     yield `(typeof ${value} === 'boolean')`;
   }
-  function* FromConstructor7(schema, references, value) {
-    yield* Visit10(schema.returns, references, `${value}.prototype`);
+  function* FromConstructor9(schema, references, value) {
+    yield* Visit17(schema.returns, references, `${value}.prototype`);
   }
-  function* FromDate4(schema, references, value) {
+  function* FromDate8(schema, references, value) {
     yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
     if (IsNumber2(schema.exclusiveMaximumTimestamp))
       yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
@@ -5171,16 +6803,16 @@ var TypeCompiler;
     if (IsNumber2(schema.multipleOfTimestamp))
       yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`;
   }
-  function* FromFunction7(schema, references, value) {
+  function* FromFunction8(schema, references, value) {
     yield `(typeof ${value} === 'function')`;
   }
-  function* FromImport6(schema, references, value) {
+  function* FromImport11(schema, references, value) {
     const members = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => {
       return [...result, schema.$defs[key]];
     }, []);
-    yield* Visit10(Ref(schema.$ref), [...references, ...members], value);
+    yield* Visit17(Ref(schema.$ref), [...references, ...members], value);
   }
-  function* FromInteger4(schema, references, value) {
+  function* FromInteger6(schema, references, value) {
     yield `Number.isInteger(${value})`;
     if (IsNumber2(schema.exclusiveMaximum))
       yield `${value} < ${schema.exclusiveMaximum}`;
@@ -5193,7 +6825,7 @@ var TypeCompiler;
     if (IsNumber2(schema.multipleOf))
       yield `(${value} % ${schema.multipleOf}) === 0`;
   }
-  function* FromIntersect14(schema, references, value) {
+  function* FromIntersect19(schema, references, value) {
     const check1 = schema.allOf.map((schema2) => CreateExpression(schema2, references, value)).join(" && ");
     if (schema.unevaluatedProperties === false) {
       const keyCheck = CreateVariable(`${new RegExp(KeyOfPattern(schema))};`);
@@ -5207,10 +6839,10 @@ var TypeCompiler;
       yield `(${check1})`;
     }
   }
-  function* FromIterator7(schema, references, value) {
+  function* FromIterator8(schema, references, value) {
     yield `(typeof value === 'object' && Symbol.iterator in ${value})`;
   }
-  function* FromLiteral5(schema, references, value) {
+  function* FromLiteral7(schema, references, value) {
     if (typeof schema.const === "number" || typeof schema.const === "boolean") {
       yield `(${value} === ${schema.const})`;
     } else if (typeof schema.const === "string") {
@@ -5219,17 +6851,17 @@ var TypeCompiler;
       throw Error("Invalid Literal Value");
     }
   }
-  function* FromNever4(schema, references, value) {
+  function* FromNever6(schema, references, value) {
     yield `false`;
   }
-  function* FromNot7(schema, references, value) {
+  function* FromNot8(schema, references, value) {
     const expression = CreateExpression(schema.not, references, value);
     yield `(!${expression})`;
   }
-  function* FromNull4(schema, references, value) {
+  function* FromNull6(schema, references, value) {
     yield `(${value} === null)`;
   }
-  function* FromNumber4(schema, references, value) {
+  function* FromNumber6(schema, references, value) {
     yield Policy.IsNumberLike(value);
     if (IsNumber2(schema.exclusiveMaximum))
       yield `${value} < ${schema.exclusiveMaximum}`;
@@ -5242,7 +6874,7 @@ var TypeCompiler;
     if (IsNumber2(schema.multipleOf))
       yield `(${value} % ${schema.multipleOf}) === 0`;
   }
-  function* FromObject13(schema, references, value) {
+  function* FromObject19(schema, references, value) {
     yield Policy.IsObjectLike(value);
     if (IsNumber2(schema.minProperties))
       yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
@@ -5253,7 +6885,7 @@ var TypeCompiler;
       const memberExpression = MemberExpression(value, knownKey);
       const property = schema.properties[knownKey];
       if (schema.required && schema.required.includes(knownKey)) {
-        yield* Visit10(property, references, memberExpression);
+        yield* Visit17(property, references, memberExpression);
         if (ExtendsUndefinedCheck(property) || IsAnyOrUnknown2(property))
           yield `(${StringConstant(knownKey)} in ${value})`;
       } else {
@@ -5275,10 +6907,10 @@ var TypeCompiler;
       yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
     }
   }
-  function* FromPromise7(schema, references, value) {
+  function* FromPromise8(schema, references, value) {
     yield `${value} instanceof Promise`;
   }
-  function* FromRecord9(schema, references, value) {
+  function* FromRecord14(schema, references, value) {
     yield Policy.IsRecordLike(value);
     if (IsNumber2(schema.minProperties))
       yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
@@ -5291,13 +6923,13 @@ var TypeCompiler;
     const expression = `(${variable}.test(key) ? ${check1} : ${check2})`;
     yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`;
   }
-  function* FromRef10(schema, references, value) {
+  function* FromRef15(schema, references, value) {
     const target = Deref(schema, references);
     if (state.functions.has(schema.$ref))
       return yield `${CreateFunctionName(schema.$ref)}(${value})`;
-    yield* Visit10(target, references, value);
+    yield* Visit17(target, references, value);
   }
-  function* FromRegExp4(schema, references, value) {
+  function* FromRegExp5(schema, references, value) {
     const variable = CreateVariable(`${new RegExp(schema.source, schema.flags)};`);
     yield `(typeof ${value} === 'string')`;
     if (IsNumber2(schema.maxLength))
@@ -5306,7 +6938,7 @@ var TypeCompiler;
       yield `${value}.length >= ${schema.minLength}`;
     yield `${variable}.test(${value})`;
   }
-  function* FromString4(schema, references, value) {
+  function* FromString6(schema, references, value) {
     yield `(typeof ${value} === 'string')`;
     if (IsNumber2(schema.maxLength))
       yield `${value}.length <= ${schema.maxLength}`;
@@ -5320,18 +6952,18 @@ var TypeCompiler;
       yield `format(${StringConstant(schema.format)}, ${value})`;
     }
   }
-  function* FromSymbol4(schema, references, value) {
+  function* FromSymbol6(schema, references, value) {
     yield `(typeof ${value} === 'symbol')`;
   }
-  function* FromTemplateLiteral6(schema, references, value) {
+  function* FromTemplateLiteral7(schema, references, value) {
     yield `(typeof ${value} === 'string')`;
     const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
     yield `${variable}.test(${value})`;
   }
-  function* FromThis6(schema, references, value) {
+  function* FromThis11(schema, references, value) {
     yield `${CreateFunctionName(schema.$ref)}(${value})`;
   }
-  function* FromTuple11(schema, references, value) {
+  function* FromTuple16(schema, references, value) {
     yield `Array.isArray(${value})`;
     if (schema.items === void 0)
       return yield `${value}.length === 0`;
@@ -5341,32 +6973,32 @@ var TypeCompiler;
       yield `${expression}`;
     }
   }
-  function* FromUndefined4(schema, references, value) {
+  function* FromUndefined6(schema, references, value) {
     yield `${value} === undefined`;
   }
-  function* FromUnion16(schema, references, value) {
+  function* FromUnion21(schema, references, value) {
     const expressions = schema.anyOf.map((schema2) => CreateExpression(schema2, references, value));
     yield `(${expressions.join(" || ")})`;
   }
-  function* FromUint8Array4(schema, references, value) {
+  function* FromUint8Array5(schema, references, value) {
     yield `${value} instanceof Uint8Array`;
     if (IsNumber2(schema.maxByteLength))
       yield `(${value}.length <= ${schema.maxByteLength})`;
     if (IsNumber2(schema.minByteLength))
       yield `(${value}.length >= ${schema.minByteLength})`;
   }
-  function* FromUnknown4(schema, references, value) {
+  function* FromUnknown5(schema, references, value) {
     yield "true";
   }
-  function* FromVoid4(schema, references, value) {
+  function* FromVoid5(schema, references, value) {
     yield Policy.IsVoidLike(value);
   }
-  function* FromKind3(schema, references, value) {
+  function* FromKind4(schema, references, value) {
     const instance = state.instances.size;
     state.instances.set(instance, schema);
     yield `kind(${StringConstant(schema[Kind])}, ${instance}, ${value})`;
   }
-  function* Visit10(schema, references, value, useHoisting = true) {
+  function* Visit17(schema, references, value, useHoisting = true) {
     const references_ = IsString2(schema.$id) ? [...references, schema] : references;
     const schema_ = schema;
     if (useHoisting && IsString2(schema.$id)) {
@@ -5382,75 +7014,75 @@ var TypeCompiler;
     }
     switch (schema_[Kind]) {
       case "Any":
-        return yield* FromAny4(schema_, references_, value);
+        return yield* FromAny5(schema_, references_, value);
       case "Argument":
-        return yield* FromArgument4(schema_, references_, value);
+        return yield* FromArgument5(schema_, references_, value);
       case "Array":
-        return yield* FromArray12(schema_, references_, value);
+        return yield* FromArray18(schema_, references_, value);
       case "AsyncIterator":
-        return yield* FromAsyncIterator7(schema_, references_, value);
+        return yield* FromAsyncIterator8(schema_, references_, value);
       case "BigInt":
-        return yield* FromBigInt4(schema_, references_, value);
+        return yield* FromBigInt6(schema_, references_, value);
       case "Boolean":
-        return yield* FromBoolean4(schema_, references_, value);
+        return yield* FromBoolean6(schema_, references_, value);
       case "Constructor":
-        return yield* FromConstructor7(schema_, references_, value);
+        return yield* FromConstructor9(schema_, references_, value);
       case "Date":
-        return yield* FromDate4(schema_, references_, value);
+        return yield* FromDate8(schema_, references_, value);
       case "Function":
-        return yield* FromFunction7(schema_, references_, value);
+        return yield* FromFunction8(schema_, references_, value);
       case "Import":
-        return yield* FromImport6(schema_, references_, value);
+        return yield* FromImport11(schema_, references_, value);
       case "Integer":
-        return yield* FromInteger4(schema_, references_, value);
+        return yield* FromInteger6(schema_, references_, value);
       case "Intersect":
-        return yield* FromIntersect14(schema_, references_, value);
+        return yield* FromIntersect19(schema_, references_, value);
       case "Iterator":
-        return yield* FromIterator7(schema_, references_, value);
+        return yield* FromIterator8(schema_, references_, value);
       case "Literal":
-        return yield* FromLiteral5(schema_, references_, value);
+        return yield* FromLiteral7(schema_, references_, value);
       case "Never":
-        return yield* FromNever4(schema_, references_, value);
+        return yield* FromNever6(schema_, references_, value);
       case "Not":
-        return yield* FromNot7(schema_, references_, value);
+        return yield* FromNot8(schema_, references_, value);
       case "Null":
-        return yield* FromNull4(schema_, references_, value);
+        return yield* FromNull6(schema_, references_, value);
       case "Number":
-        return yield* FromNumber4(schema_, references_, value);
+        return yield* FromNumber6(schema_, references_, value);
       case "Object":
-        return yield* FromObject13(schema_, references_, value);
+        return yield* FromObject19(schema_, references_, value);
       case "Promise":
-        return yield* FromPromise7(schema_, references_, value);
+        return yield* FromPromise8(schema_, references_, value);
       case "Record":
-        return yield* FromRecord9(schema_, references_, value);
+        return yield* FromRecord14(schema_, references_, value);
       case "Ref":
-        return yield* FromRef10(schema_, references_, value);
+        return yield* FromRef15(schema_, references_, value);
       case "RegExp":
-        return yield* FromRegExp4(schema_, references_, value);
+        return yield* FromRegExp5(schema_, references_, value);
       case "String":
-        return yield* FromString4(schema_, references_, value);
+        return yield* FromString6(schema_, references_, value);
       case "Symbol":
-        return yield* FromSymbol4(schema_, references_, value);
+        return yield* FromSymbol6(schema_, references_, value);
       case "TemplateLiteral":
-        return yield* FromTemplateLiteral6(schema_, references_, value);
+        return yield* FromTemplateLiteral7(schema_, references_, value);
       case "This":
-        return yield* FromThis6(schema_, references_, value);
+        return yield* FromThis11(schema_, references_, value);
       case "Tuple":
-        return yield* FromTuple11(schema_, references_, value);
+        return yield* FromTuple16(schema_, references_, value);
       case "Undefined":
-        return yield* FromUndefined4(schema_, references_, value);
+        return yield* FromUndefined6(schema_, references_, value);
       case "Union":
-        return yield* FromUnion16(schema_, references_, value);
+        return yield* FromUnion21(schema_, references_, value);
       case "Uint8Array":
-        return yield* FromUint8Array4(schema_, references_, value);
+        return yield* FromUint8Array5(schema_, references_, value);
       case "Unknown":
-        return yield* FromUnknown4(schema_, references_, value);
+        return yield* FromUnknown5(schema_, references_, value);
       case "Void":
-        return yield* FromVoid4(schema_, references_, value);
+        return yield* FromVoid5(schema_, references_, value);
       default:
         if (!type_exports2.Has(schema_[Kind]))
           throw new TypeCompilerUnknownTypeError(schema);
-        return yield* FromKind3(schema_, references_, value);
+        return yield* FromKind4(schema_, references_, value);
     }
   }
   const state = {
@@ -5464,7 +7096,7 @@ var TypeCompiler;
     // exterior kind instances
   };
   function CreateExpression(schema, references, value, useHoisting = true) {
-    return `(${[...Visit10(schema, references, value, useHoisting)].join(" && ")})`;
+    return `(${[...Visit17(schema, references, value, useHoisting)].join(" && ")})`;
   }
   function CreateFunctionName($id) {
     return `check_${Identifier.Encode($id)}`;
@@ -5478,7 +7110,7 @@ var TypeCompiler;
     const [newline, pad] = ["\n", (length) => "".padStart(length, " ")];
     const parameter = CreateParameter("value", "any");
     const returns = CreateReturns("boolean");
-    const expression = [...Visit10(schema, references, value, useHoisting)].map((expression2) => `${pad(4)}${expression2}`).join(` &&${newline}`);
+    const expression = [...Visit17(schema, references, value, useHoisting)].map((expression2) => `${pad(4)}${expression2}`).join(` &&${newline}`);
     return `function ${name}(${parameter})${returns} {${newline}${pad(2)}return (${newline}${expression}${newline}${pad(2)})
 }`;
   }
@@ -5724,6 +7356,95 @@ var ControlGrantSchema = Type.Intersect([
   Type.Object({ token: Type.String() })
 ]);
 
+// ../protocol/dist/autofill.js
+var text = () => Type.String({ minLength: 1, maxLength: 512 });
+var strict = { additionalProperties: false };
+var AutofillMatchSchema = Type.Object({
+  role: Type.Optional(text()),
+  label: Type.Optional(text()),
+  labelRegex: Type.Optional(text()),
+  dataAutomationId: Type.Optional(text()),
+  block: Type.Optional(Type.Object({ id: Type.Optional(text()), label: Type.Optional(text()) }, { ...strict, minProperties: 1 }))
+}, { ...strict, minProperties: 1 });
+var AutofillRequestSchema = Type.Object({
+  fields: Type.Array(Type.Object({
+    match: AutofillMatchSchema,
+    value: Type.Optional(Type.String({ maxLength: 8192 })),
+    option: Type.Optional(Type.Object({ value: Type.String({ maxLength: 8192 }) }, strict)),
+    verify: Type.Optional(Type.Union([Type.Literal("exact"), Type.Literal("none")])),
+    strategy: Type.Optional(Type.Union([Type.Literal("native-input"), Type.Literal("native-select")]))
+  }, strict), { minItems: 1, maxItems: 50 }),
+  policy: Type.Optional(Type.Object({
+    onAmbiguous: Type.Optional(Type.Union([Type.Literal("fail"), Type.Literal("skip")])),
+    onVerifyFail: Type.Optional(Type.Union([Type.Literal("fail"), Type.Literal("skip"), Type.Literal("retry")])),
+    maxReobserve: Type.Optional(Type.Integer({ minimum: 0, maximum: 5 })),
+    settleMs: Type.Optional(Type.Integer({ minimum: 0, maximum: 2e3 })),
+    timeoutMs: Type.Optional(Type.Integer({ minimum: 1, maximum: 24e4 }))
+  }, strict))
+}, strict);
+var AutofillReceiptSchema = Type.Object({
+  field: Type.Integer({ minimum: 0, maximum: 49 }),
+  match: AutofillMatchSchema,
+  resolvedRef: Type.Optional(Type.String()),
+  blockIdentity: Type.Optional(Type.String()),
+  actionId: Type.Optional(Type.String()),
+  status: Type.Union(["verified", "unverified", "skipped", "failed", "uncertain", "not_attempted"].map((value) => Type.Literal(value))),
+  verified: Type.Boolean(),
+  actual: Type.Optional(Type.String({ maxLength: 512 })),
+  actualTruncated: Type.Optional(Type.Boolean()),
+  error: Type.Optional(Type.Object({ code: Type.String(), message: Type.String() }, strict))
+}, strict);
+var AutofillReportSchema = Type.Object({
+  ok: Type.Boolean(),
+  receipts: Type.Array(AutofillReceiptSchema, { maxItems: 50 }),
+  elapsedMs: Type.Number({ minimum: 0 }),
+  snapshot: Type.Optional(Type.Object({
+    artifactId: Type.String(),
+    contentType: Type.Optional(Type.String()),
+    sizeBytes: Type.Optional(Type.Integer({ minimum: 0 })),
+    warnings: Type.Optional(Type.Array(Type.String()))
+  }, strict)),
+  snapshotError: Type.Optional(Type.String())
+}, strict);
+function labelPattern(pattern) {
+  const start = pattern.startsWith("^");
+  const end = pattern.endsWith("$");
+  const body = pattern.slice(start ? 1 : 0, end ? -1 : void 0);
+  const parts = body.split(".*");
+  if (parts.some((p) => /[\\[\]{}()+?*|.^$]/.test(p)))
+    throw new Error("labelRegex supports only literals, .* and optional ^/$ anchors");
+  return (label) => {
+    let offset = 0;
+    for (const [index, part] of parts.entries()) {
+      const at = label.indexOf(part, offset);
+      if (at < 0 || index === 0 && start && at !== 0)
+        return false;
+      offset = at + part.length;
+    }
+    if (!end)
+      return true;
+    const last = parts[parts.length - 1] ?? "";
+    return label.endsWith(last) && (parts.length > 1 || !start || offset === label.length);
+  };
+}
+function parseAutofillRequest(input) {
+  if (!value_exports2.Check(AutofillRequestSchema, input))
+    throw new Error("Invalid autofill request: bounded fields[] and policy required; unknown properties are rejected");
+  const request = structuredClone(input);
+  for (const field of request.fields) {
+    if (field.value === void 0 === (field.option === void 0))
+      throw new Error("Each autofill field requires exactly one of value or option.value");
+    const match = field.match;
+    if (!match.label && !match.labelRegex && !match.dataAutomationId)
+      throw new Error("Each autofill match requires label, labelRegex or dataAutomationId");
+    if (match.labelRegex !== void 0)
+      labelPattern(match.labelRegex);
+    if (field.strategy === "native-input" && field.value === void 0 || field.strategy === "native-select" && field.option === void 0)
+      throw new Error("Autofill strategy does not match value/option");
+  }
+  return request;
+}
+
 // dist/mcp-server.js
 var PROTOCOL_VERSION = "2024-11-05";
 function sessionAndPage(args) {
@@ -5851,6 +7572,35 @@ function buildTools(client) {
         return await client.sessions.snapshot(sessionId, pageId);
       }
     },
+    {
+      name: "browser_autofill",
+      description: "Fill and verify structured fields in one serial server operation. Match labels within a unique fieldset block (id or legend label). Supports native text inputs and single selects; custom widgets are refused. Verification retries only read; uncertain writes stop the batch. Returns per-field receipts and an authorized raw HTML artifact. Performs no explicit submit action; page input/change handlers may commit effects. After a lost response, inspect browser_operation before any further write.",
+      inputSchema: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          sessionId: { type: "string" },
+          pageId: { type: "string" },
+          ...AutofillRequestSchema.properties
+        },
+        required: ["sessionId", "pageId", "fields"]
+      },
+      handler: async (args) => {
+        const [sessionId, pageId] = sessionAndPage(args);
+        if (!client.sessions.autofill)
+          throw new UsageError("Client does not support autofill");
+        let payload;
+        try {
+          payload = parseAutofillRequest({
+            fields: args.fields,
+            ...args.policy !== void 0 ? { policy: args.policy } : {}
+          });
+        } catch (error2) {
+          throw new UsageError(error2 instanceof Error ? error2.message : "Invalid autofill request");
+        }
+        return await client.sessions.autofill(sessionId, pageId, payload, ...operationOptions(args));
+      }
+    },
     {
       name: "browser_plan",
       description: "Execute a batched action plan in one call (TD-BROWSER-8). Each action: {action: fill|click|press|scroll, target?: {ref}, value?, key?}. Steps run sequentially; the first hard failure aborts with per-step results. Best paired with browser_snapshot: address refs from its `fields` in one round trip. A step for a field that only appears after a prior step (Phase 2) may declare `waitForLabel` (substring match on the element name) instead of `target` - the executor waits for it to appear (bounded by `waitMs`, default 5000) and resolves the ref itself; a miss aborts the plan with a typed PLAN_WAIT_TIMEOUT. On forms with repeated field labels (multi-section layouts, generically-labeled toggles), keep a plan to one section or logical group and re-observe between sections: self-heal matches stale refs by role and label, so identical labels make long plans abort mid-way even when every ref was valid at plan start.",
@@ -6145,7 +7895,7 @@ function buildMcpServer(deps) {
   for (const tool of tools) {
     if (deps.sessionId && Array.isArray(tool.inputSchema.required))
       tool.inputSchema.required = tool.inputSchema.required.filter((name) => name !== "sessionId");
-    if (["browser_act", "browser_plan", "browser_navigate"].includes(tool.name)) {
+    if (["browser_act", "browser_plan", "browser_autofill", "browser_navigate"].includes(tool.name)) {
       tool.inputSchema.properties.operationId = {
         type: "string",
         pattern: "^[a-zA-Z0-9_-]{1,128}$",
@@ -6229,7 +7979,7 @@ function buildMcpServer(deps) {
             try {
               if (deps.sessionId && args.sessionId !== void 0 && args.sessionId !== deps.sessionId)
                 throw new UsageError("This MCP connection is bound to another session");
-              if (deps.sessionId && ["browser_act", "browser_plan", "browser_navigate"].includes(name) && args.operationId === void 0)
+              if (deps.sessionId && ["browser_act", "browser_plan", "browser_autofill", "browser_navigate"].includes(name) && args.operationId === void 0)
                 throw new UsageError("operationId is required for a delegated mutation; choose it before dispatch so a lost response can be reconciled");
               const result = await tool.handler(deps.sessionId ? { ...args, sessionId: deps.sessionId } : args);
               return ok(message.id, textResult(result));