@bryanhu/codexly 0.1.0

package/dist/chunk-TEPSAXZZ.js

@@ -0,0 +1,3360 @@
+import { createRequire } from 'node:module';
+import { IsArray, IsDate, IsTypedArray, IsMap, IsSet, IsObject, IsValueType, TypeBoxError, Object as Object$1, Unknown, String, Literal, Union, IsBoolean, IsBigInt, IsNull, IsNumber, IsString, IsSymbol, IsUint8Array, IsUndefined, Kind, type_exports, IsStandardObject, TypeSystemPolicy, format_exports, IsPromise, IsIterator, KeyOfPattern, IsSchema, IsInteger, IsFunction, IsAsyncIterator, Never, HasPropertyKey, IsTemplateLiteralFinite, TemplateLiteralGenerate, IsKind, KeyOfPropertyKeys, IsTransform, TransformKind, IsUndefined2, IndexFromPropertyKeys } from './chunk-MH54VCZJ.js';
+import { __export } from './chunk-K6J42667.js';
+
+createRequire(import.meta.url);
+
+// node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/value/value.mjs
+var value_exports = {};
+__export(value_exports, {
+  Assert: () => Assert,
+  Cast: () => Cast,
+  Check: () => Check,
+  Clean: () => Clean,
+  Clone: () => Clone,
+  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
+});
+
+// node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-entries.mjs
+function KeyOfPropertyEntries(schema) {
+  const keys = KeyOfPropertyKeys(schema);
+  const schemas = IndexFromPropertyKeys(schema, keys);
+  return keys.map((_, index) => [keys[index], schemas[index]]);
+}
+
+// node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/extends/extends-undefined.mjs
+function Intersect(schema) {
+  return schema.allOf.every((schema2) => ExtendsUndefinedCheck(schema2));
+}
+function Union2(schema) {
+  return schema.anyOf.some((schema2) => ExtendsUndefinedCheck(schema2));
+}
+function Not(schema) {
+  return !ExtendsUndefinedCheck(schema.not);
+}
+function ExtendsUndefinedCheck(schema) {
+  return schema[Kind] === "Intersect" ? Intersect(schema) : schema[Kind] === "Union" ? Union2(schema) : schema[Kind] === "Not" ? Not(schema) : schema[Kind] === "Undefined" ? true : false;
+}
+
+// node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/errors/function.mjs
+function DefaultErrorFunction(error) {
+  switch (error.errorType) {
+    case ValueErrorType.ArrayContains:
+      return "Expected array to contain at least one matching value";
+    case ValueErrorType.ArrayMaxContains:
+      return `Expected array to contain no more than ${error.schema.maxContains} matching values`;
+    case ValueErrorType.ArrayMinContains:
+      return `Expected array to contain at least ${error.schema.minContains} matching values`;
+    case ValueErrorType.ArrayMaxItems:
+      return `Expected array length to be less or equal to ${error.schema.maxItems}`;
+    case ValueErrorType.ArrayMinItems:
+      return `Expected array length to be greater or equal to ${error.schema.minItems}`;
+    case ValueErrorType.ArrayUniqueItems:
+      return "Expected array elements to be unique";
+    case ValueErrorType.Array:
+      return "Expected array";
+    case ValueErrorType.AsyncIterator:
+      return "Expected AsyncIterator";
+    case ValueErrorType.BigIntExclusiveMaximum:
+      return `Expected bigint to be less than ${error.schema.exclusiveMaximum}`;
+    case ValueErrorType.BigIntExclusiveMinimum:
+      return `Expected bigint to be greater than ${error.schema.exclusiveMinimum}`;
+    case ValueErrorType.BigIntMaximum:
+      return `Expected bigint to be less or equal to ${error.schema.maximum}`;
+    case ValueErrorType.BigIntMinimum:
+      return `Expected bigint to be greater or equal to ${error.schema.minimum}`;
+    case ValueErrorType.BigIntMultipleOf:
+      return `Expected bigint to be a multiple of ${error.schema.multipleOf}`;
+    case ValueErrorType.BigInt:
+      return "Expected bigint";
+    case ValueErrorType.Boolean:
+      return "Expected boolean";
+    case ValueErrorType.DateExclusiveMinimumTimestamp:
+      return `Expected Date timestamp to be greater than ${error.schema.exclusiveMinimumTimestamp}`;
+    case ValueErrorType.DateExclusiveMaximumTimestamp:
+      return `Expected Date timestamp to be less than ${error.schema.exclusiveMaximumTimestamp}`;
+    case ValueErrorType.DateMinimumTimestamp:
+      return `Expected Date timestamp to be greater or equal to ${error.schema.minimumTimestamp}`;
+    case ValueErrorType.DateMaximumTimestamp:
+      return `Expected Date timestamp to be less or equal to ${error.schema.maximumTimestamp}`;
+    case ValueErrorType.DateMultipleOfTimestamp:
+      return `Expected Date timestamp to be a multiple of ${error.schema.multipleOfTimestamp}`;
+    case ValueErrorType.Date:
+      return "Expected Date";
+    case ValueErrorType.Function:
+      return "Expected function";
+    case ValueErrorType.IntegerExclusiveMaximum:
+      return `Expected integer to be less than ${error.schema.exclusiveMaximum}`;
+    case ValueErrorType.IntegerExclusiveMinimum:
+      return `Expected integer to be greater than ${error.schema.exclusiveMinimum}`;
+    case ValueErrorType.IntegerMaximum:
+      return `Expected integer to be less or equal to ${error.schema.maximum}`;
+    case ValueErrorType.IntegerMinimum:
+      return `Expected integer to be greater or equal to ${error.schema.minimum}`;
+    case ValueErrorType.IntegerMultipleOf:
+      return `Expected integer to be a multiple of ${error.schema.multipleOf}`;
+    case ValueErrorType.Integer:
+      return "Expected integer";
+    case ValueErrorType.IntersectUnevaluatedProperties:
+      return "Unexpected property";
+    case ValueErrorType.Intersect:
+      return "Expected all values to match";
+    case ValueErrorType.Iterator:
+      return "Expected Iterator";
+    case ValueErrorType.Literal:
+      return `Expected ${typeof error.schema.const === "string" ? `'${error.schema.const}'` : error.schema.const}`;
+    case ValueErrorType.Never:
+      return "Never";
+    case ValueErrorType.Not:
+      return "Value should not match";
+    case ValueErrorType.Null:
+      return "Expected null";
+    case ValueErrorType.NumberExclusiveMaximum:
+      return `Expected number to be less than ${error.schema.exclusiveMaximum}`;
+    case ValueErrorType.NumberExclusiveMinimum:
+      return `Expected number to be greater than ${error.schema.exclusiveMinimum}`;
+    case ValueErrorType.NumberMaximum:
+      return `Expected number to be less or equal to ${error.schema.maximum}`;
+    case ValueErrorType.NumberMinimum:
+      return `Expected number to be greater or equal to ${error.schema.minimum}`;
+    case ValueErrorType.NumberMultipleOf:
+      return `Expected number to be a multiple of ${error.schema.multipleOf}`;
+    case ValueErrorType.Number:
+      return "Expected number";
+    case ValueErrorType.Object:
+      return "Expected object";
+    case ValueErrorType.ObjectAdditionalProperties:
+      return "Unexpected property";
+    case ValueErrorType.ObjectMaxProperties:
+      return `Expected object to have no more than ${error.schema.maxProperties} properties`;
+    case ValueErrorType.ObjectMinProperties:
+      return `Expected object to have at least ${error.schema.minProperties} properties`;
+    case ValueErrorType.ObjectRequiredProperty:
+      return "Expected required property";
+    case ValueErrorType.Promise:
+      return "Expected Promise";
+    case ValueErrorType.RegExp:
+      return "Expected string to match regular expression";
+    case ValueErrorType.StringFormatUnknown:
+      return `Unknown format '${error.schema.format}'`;
+    case ValueErrorType.StringFormat:
+      return `Expected string to match '${error.schema.format}' format`;
+    case ValueErrorType.StringMaxLength:
+      return `Expected string length less or equal to ${error.schema.maxLength}`;
+    case ValueErrorType.StringMinLength:
+      return `Expected string length greater or equal to ${error.schema.minLength}`;
+    case ValueErrorType.StringPattern:
+      return `Expected string to match '${error.schema.pattern}'`;
+    case ValueErrorType.String:
+      return "Expected string";
+    case ValueErrorType.Symbol:
+      return "Expected symbol";
+    case ValueErrorType.TupleLength:
+      return `Expected tuple to have ${error.schema.maxItems || 0} elements`;
+    case ValueErrorType.Tuple:
+      return "Expected tuple";
+    case ValueErrorType.Uint8ArrayMaxByteLength:
+      return `Expected byte length less or equal to ${error.schema.maxByteLength}`;
+    case ValueErrorType.Uint8ArrayMinByteLength:
+      return `Expected byte length greater or equal to ${error.schema.minByteLength}`;
+    case ValueErrorType.Uint8Array:
+      return "Expected Uint8Array";
+    case ValueErrorType.Undefined:
+      return "Expected undefined";
+    case ValueErrorType.Union:
+      return "Expected union value";
+    case ValueErrorType.Void:
+      return "Expected void";
+    case ValueErrorType.Kind:
+      return `Expected kind '${error.schema[Kind]}'`;
+    default:
+      return "Unknown error type";
+  }
+}
+var errorFunction = DefaultErrorFunction;
+function GetErrorFunction() {
+  return errorFunction;
+}
+
+// node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/deref/deref.mjs
+var TypeDereferenceError = class extends TypeBoxError {
+  constructor(schema) {
+    super(`Unable to dereference schema with $id '${schema.$ref}'`);
+    this.schema = schema;
+  }
+};
+function Resolve(schema, references) {
+  const target = references.find((target2) => target2.$id === schema.$ref);
+  if (target === void 0)
+    throw new TypeDereferenceError(schema);
+  return Deref(target, references);
+}
+function Pushref(schema, references) {
+  if (!IsString(schema.$id) || references.some((target) => target.$id === schema.$id))
+    return references;
+  references.push(schema);
+  return references;
+}
+function Deref(schema, references) {
+  return schema[Kind] === "This" || schema[Kind] === "Ref" ? Resolve(schema, references) : schema;
+}
+
+// node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/hash/hash.mjs
+var ValueHashError = class extends TypeBoxError {
+  constructor(value) {
+    super(`Unable to hash value`);
+    this.value = value;
+  }
+};
+var ByteMarker;
+(function(ByteMarker2) {
+  ByteMarker2[ByteMarker2["Undefined"] = 0] = "Undefined";
+  ByteMarker2[ByteMarker2["Null"] = 1] = "Null";
+  ByteMarker2[ByteMarker2["Boolean"] = 2] = "Boolean";
+  ByteMarker2[ByteMarker2["Number"] = 3] = "Number";
+  ByteMarker2[ByteMarker2["String"] = 4] = "String";
+  ByteMarker2[ByteMarker2["Object"] = 5] = "Object";
+  ByteMarker2[ByteMarker2["Array"] = 6] = "Array";
+  ByteMarker2[ByteMarker2["Date"] = 7] = "Date";
+  ByteMarker2[ByteMarker2["Uint8Array"] = 8] = "Uint8Array";
+  ByteMarker2[ByteMarker2["Symbol"] = 9] = "Symbol";
+  ByteMarker2[ByteMarker2["BigInt"] = 10] = "BigInt";
+})(ByteMarker || (ByteMarker = {}));
+var Accumulator = BigInt("14695981039346656037");
+var [Prime, Size] = [BigInt("1099511628211"), BigInt(
+  "18446744073709551616"
+  /* 2 ^ 64 */
+)];
+var Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
+var F64 = new Float64Array(1);
+var F64In = new DataView(F64.buffer);
+var F64Out = new Uint8Array(F64.buffer);
+function* NumberToBytes(value) {
+  const byteCount = value === 0 ? 1 : Math.ceil(Math.floor(Math.log2(value) + 1) / 8);
+  for (let i = 0; i < byteCount; i++) {
+    yield value >> 8 * (byteCount - 1 - i) & 255;
+  }
+}
+function ArrayType(value) {
+  FNV1A64(ByteMarker.Array);
+  for (const item of value) {
+    Visit(item);
+  }
+}
+function BooleanType(value) {
+  FNV1A64(ByteMarker.Boolean);
+  FNV1A64(value ? 1 : 0);
+}
+function BigIntType(value) {
+  FNV1A64(ByteMarker.BigInt);
+  F64In.setBigInt64(0, value);
+  for (const byte of F64Out) {
+    FNV1A64(byte);
+  }
+}
+function DateType(value) {
+  FNV1A64(ByteMarker.Date);
+  Visit(value.getTime());
+}
+function NullType(value) {
+  FNV1A64(ByteMarker.Null);
+}
+function NumberType(value) {
+  FNV1A64(ByteMarker.Number);
+  F64In.setFloat64(0, value);
+  for (const byte of F64Out) {
+    FNV1A64(byte);
+  }
+}
+function ObjectType(value) {
+  FNV1A64(ByteMarker.Object);
+  for (const key of globalThis.Object.getOwnPropertyNames(value).sort()) {
+    Visit(key);
+    Visit(value[key]);
+  }
+}
+function StringType(value) {
+  FNV1A64(ByteMarker.String);
+  for (let i = 0; i < value.length; i++) {
+    for (const byte of NumberToBytes(value.charCodeAt(i))) {
+      FNV1A64(byte);
+    }
+  }
+}
+function SymbolType(value) {
+  FNV1A64(ByteMarker.Symbol);
+  Visit(value.description);
+}
+function Uint8ArrayType(value) {
+  FNV1A64(ByteMarker.Uint8Array);
+  for (let i = 0; i < value.length; i++) {
+    FNV1A64(value[i]);
+  }
+}
+function UndefinedType(value) {
+  return FNV1A64(ByteMarker.Undefined);
+}
+function Visit(value) {
+  if (IsArray(value))
+    return ArrayType(value);
+  if (IsBoolean(value))
+    return BooleanType(value);
+  if (IsBigInt(value))
+    return BigIntType(value);
+  if (IsDate(value))
+    return DateType(value);
+  if (IsNull(value))
+    return NullType();
+  if (IsNumber(value))
+    return NumberType(value);
+  if (IsObject(value))
+    return ObjectType(value);
+  if (IsString(value))
+    return StringType(value);
+  if (IsSymbol(value))
+    return SymbolType(value);
+  if (IsUint8Array(value))
+    return Uint8ArrayType(value);
+  if (IsUndefined(value))
+    return UndefinedType();
+  throw new ValueHashError(value);
+}
+function FNV1A64(byte) {
+  Accumulator = Accumulator ^ Bytes[byte];
+  Accumulator = Accumulator * Prime % Size;
+}
+function Hash(value) {
+  Accumulator = BigInt("14695981039346656037");
+  Visit(value);
+  return Accumulator;
+}
+
+// node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/check/check.mjs
+var ValueCheckUnknownTypeError = class extends TypeBoxError {
+  constructor(schema) {
+    super(`Unknown type`);
+    this.schema = schema;
+  }
+};
+function IsAnyOrUnknown(schema) {
+  return schema[Kind] === "Any" || schema[Kind] === "Unknown";
+}
+function IsDefined(value) {
+  return value !== void 0;
+}
+function FromAny(schema, references, value) {
+  return true;
+}
+function FromArgument(schema, references, value) {
+  return true;
+}
+function FromArray(schema, references, value) {
+  if (!IsArray(value))
+    return false;
+  if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
+    return false;
+  }
+  if (IsDefined(schema.maxItems) && !(value.length <= schema.maxItems)) {
+    return false;
+  }
+  for (const element of value) {
+    if (!Visit2(schema.items, references, element))
+      return false;
+  }
+  if (schema.uniqueItems === true && !(function() {
+    const set = /* @__PURE__ */ new Set();
+    for (const element of value) {
+      const hashed = Hash(element);
+      if (set.has(hashed)) {
+        return false;
+      } else {
+        set.add(hashed);
+      }
+    }
+    return true;
+  })()) {
+    return false;
+  }
+  if (!(IsDefined(schema.contains) || IsNumber(schema.minContains) || IsNumber(schema.maxContains))) {
+    return true;
+  }
+  const containsSchema = IsDefined(schema.contains) ? schema.contains : Never();
+  const containsCount = value.reduce((acc, value2) => Visit2(containsSchema, references, value2) ? acc + 1 : acc, 0);
+  if (containsCount === 0) {
+    return false;
+  }
+  if (IsNumber(schema.minContains) && containsCount < schema.minContains) {
+    return false;
+  }
+  if (IsNumber(schema.maxContains) && containsCount > schema.maxContains) {
+    return false;
+  }
+  return true;
+}
+function FromAsyncIterator(schema, references, value) {
+  return IsAsyncIterator(value);
+}
+function FromBigInt(schema, references, value) {
+  if (!IsBigInt(value))
+    return false;
+  if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    return false;
+  }
+  if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    return false;
+  }
+  if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
+    return false;
+  }
+  if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
+    return false;
+  }
+  if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
+    return false;
+  }
+  return true;
+}
+function FromBoolean(schema, references, value) {
+  return IsBoolean(value);
+}
+function FromConstructor(schema, references, value) {
+  return Visit2(schema.returns, references, value.prototype);
+}
+function FromDate(schema, references, value) {
+  if (!IsDate(value))
+    return false;
+  if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+    return false;
+  }
+  if (IsDefined(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+    return false;
+  }
+  if (IsDefined(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+    return false;
+  }
+  if (IsDefined(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
+    return false;
+  }
+  if (IsDefined(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) {
+    return false;
+  }
+  return true;
+}
+function FromFunction(schema, references, value) {
+  return IsFunction(value);
+}
+function FromImport(schema, references, value) {
+  const definitions = globalThis.Object.values(schema.$defs);
+  const target = schema.$defs[schema.$ref];
+  return Visit2(target, [...references, ...definitions], value);
+}
+function FromInteger(schema, references, value) {
+  if (!IsInteger(value)) {
+    return false;
+  }
+  if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    return false;
+  }
+  if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    return false;
+  }
+  if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
+    return false;
+  }
+  if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
+    return false;
+  }
+  if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    return false;
+  }
+  return true;
+}
+function FromIntersect(schema, references, value) {
+  const check1 = schema.allOf.every((schema2) => Visit2(schema2, references, value));
+  if (schema.unevaluatedProperties === false) {
+    const keyPattern = new RegExp(KeyOfPattern(schema));
+    const check2 = Object.getOwnPropertyNames(value).every((key) => keyPattern.test(key));
+    return check1 && check2;
+  } else if (IsSchema(schema.unevaluatedProperties)) {
+    const keyCheck = new RegExp(KeyOfPattern(schema));
+    const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit2(schema.unevaluatedProperties, references, value[key]));
+    return check1 && check2;
+  } else {
+    return check1;
+  }
+}
+function FromIterator(schema, references, value) {
+  return IsIterator(value);
+}
+function FromLiteral(schema, references, value) {
+  return value === schema.const;
+}
+function FromNever(schema, references, value) {
+  return false;
+}
+function FromNot(schema, references, value) {
+  return !Visit2(schema.not, references, value);
+}
+function FromNull(schema, references, value) {
+  return IsNull(value);
+}
+function FromNumber(schema, references, value) {
+  if (!TypeSystemPolicy.IsNumberLike(value))
+    return false;
+  if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    return false;
+  }
+  if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    return false;
+  }
+  if (IsDefined(schema.minimum) && !(value >= schema.minimum)) {
+    return false;
+  }
+  if (IsDefined(schema.maximum) && !(value <= schema.maximum)) {
+    return false;
+  }
+  if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    return false;
+  }
+  return true;
+}
+function FromObject(schema, references, value) {
+  if (!TypeSystemPolicy.IsObjectLike(value))
+    return false;
+  if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+    return false;
+  }
+  if (IsDefined(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+    return false;
+  }
+  const knownKeys = Object.getOwnPropertyNames(schema.properties);
+  for (const knownKey of knownKeys) {
+    const property = schema.properties[knownKey];
+    if (schema.required && schema.required.includes(knownKey)) {
+      if (!Visit2(property, references, value[knownKey])) {
+        return false;
+      }
+      if ((ExtendsUndefinedCheck(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
+        return false;
+      }
+    } else {
+      if (TypeSystemPolicy.IsExactOptionalProperty(value, knownKey) && !Visit2(property, references, value[knownKey])) {
+        return false;
+      }
+    }
+  }
+  if (schema.additionalProperties === false) {
+    const valueKeys = Object.getOwnPropertyNames(value);
+    if (schema.required && schema.required.length === knownKeys.length && valueKeys.length === knownKeys.length) {
+      return true;
+    } else {
+      return valueKeys.every((valueKey) => knownKeys.includes(valueKey));
+    }
+  } else if (typeof schema.additionalProperties === "object") {
+    const valueKeys = Object.getOwnPropertyNames(value);
+    return valueKeys.every((key) => knownKeys.includes(key) || Visit2(schema.additionalProperties, references, value[key]));
+  } else {
+    return true;
+  }
+}
+function FromPromise(schema, references, value) {
+  return IsPromise(value);
+}
+function FromRecord(schema, references, value) {
+  if (!TypeSystemPolicy.IsRecordLike(value)) {
+    return false;
+  }
+  if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+    return false;
+  }
+  if (IsDefined(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+    return false;
+  }
+  const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
+  const regex = new RegExp(patternKey);
+  const check1 = Object.entries(value).every(([key, value2]) => {
+    return regex.test(key) ? Visit2(patternSchema, references, value2) : true;
+  });
+  const check2 = typeof schema.additionalProperties === "object" ? Object.entries(value).every(([key, value2]) => {
+    return !regex.test(key) ? Visit2(schema.additionalProperties, references, value2) : true;
+  }) : true;
+  const check3 = schema.additionalProperties === false ? Object.getOwnPropertyNames(value).every((key) => {
+    return regex.test(key);
+  }) : true;
+  return check1 && check2 && check3;
+}
+function FromRef(schema, references, value) {
+  return Visit2(Deref(schema, references), references, value);
+}
+function FromRegExp(schema, references, value) {
+  const regex = new RegExp(schema.source, schema.flags);
+  if (IsDefined(schema.minLength)) {
+    if (!(value.length >= schema.minLength))
+      return false;
+  }
+  if (IsDefined(schema.maxLength)) {
+    if (!(value.length <= schema.maxLength))
+      return false;
+  }
+  return regex.test(value);
+}
+function FromString(schema, references, value) {
+  if (!IsString(value)) {
+    return false;
+  }
+  if (IsDefined(schema.minLength)) {
+    if (!(value.length >= schema.minLength))
+      return false;
+  }
+  if (IsDefined(schema.maxLength)) {
+    if (!(value.length <= schema.maxLength))
+      return false;
+  }
+  if (IsDefined(schema.pattern)) {
+    const regex = new RegExp(schema.pattern);
+    if (!regex.test(value))
+      return false;
+  }
+  if (IsDefined(schema.format)) {
+    if (!format_exports.Has(schema.format))
+      return false;
+    const func = format_exports.Get(schema.format);
+    return func(value);
+  }
+  return true;
+}
+function FromSymbol(schema, references, value) {
+  return IsSymbol(value);
+}
+function FromTemplateLiteral(schema, references, value) {
+  return IsString(value) && new RegExp(schema.pattern).test(value);
+}
+function FromThis(schema, references, value) {
+  return Visit2(Deref(schema, references), references, value);
+}
+function FromTuple(schema, references, value) {
+  if (!IsArray(value)) {
+    return false;
+  }
+  if (schema.items === void 0 && !(value.length === 0)) {
+    return false;
+  }
+  if (!(value.length === schema.maxItems)) {
+    return false;
+  }
+  if (!schema.items) {
+    return true;
+  }
+  for (let i = 0; i < schema.items.length; i++) {
+    if (!Visit2(schema.items[i], references, value[i]))
+      return false;
+  }
+  return true;
+}
+function FromUndefined(schema, references, value) {
+  return IsUndefined(value);
+}
+function FromUnion(schema, references, value) {
+  return schema.anyOf.some((inner) => Visit2(inner, references, value));
+}
+function FromUint8Array(schema, references, value) {
+  if (!IsUint8Array(value)) {
+    return false;
+  }
+  if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
+    return false;
+  }
+  if (IsDefined(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
+    return false;
+  }
+  return true;
+}
+function FromUnknown(schema, references, value) {
+  return true;
+}
+function FromVoid(schema, references, value) {
+  return TypeSystemPolicy.IsVoidLike(value);
+}
+function FromKind(schema, references, value) {
+  if (!type_exports.Has(schema[Kind]))
+    return false;
+  const func = type_exports.Get(schema[Kind]);
+  return func(schema, value);
+}
+function Visit2(schema, references, value) {
+  const references_ = IsDefined(schema.$id) ? Pushref(schema, references) : references;
+  const schema_ = schema;
+  switch (schema_[Kind]) {
+    case "Any":
+      return FromAny();
+    case "Argument":
+      return FromArgument();
+    case "Array":
+      return FromArray(schema_, references_, value);
+    case "AsyncIterator":
+      return FromAsyncIterator(schema_, references_, value);
+    case "BigInt":
+      return FromBigInt(schema_, references_, value);
+    case "Boolean":
+      return FromBoolean(schema_, references_, value);
+    case "Constructor":
+      return FromConstructor(schema_, references_, value);
+    case "Date":
+      return FromDate(schema_, references_, value);
+    case "Function":
+      return FromFunction(schema_, references_, value);
+    case "Import":
+      return FromImport(schema_, references_, value);
+    case "Integer":
+      return FromInteger(schema_, references_, value);
+    case "Intersect":
+      return FromIntersect(schema_, references_, value);
+    case "Iterator":
+      return FromIterator(schema_, references_, value);
+    case "Literal":
+      return FromLiteral(schema_, references_, value);
+    case "Never":
+      return FromNever();
+    case "Not":
+      return FromNot(schema_, references_, value);
+    case "Null":
+      return FromNull(schema_, references_, value);
+    case "Number":
+      return FromNumber(schema_, references_, value);
+    case "Object":
+      return FromObject(schema_, references_, value);
+    case "Promise":
+      return FromPromise(schema_, references_, value);
+    case "Record":
+      return FromRecord(schema_, references_, value);
+    case "Ref":
+      return FromRef(schema_, references_, value);
+    case "RegExp":
+      return FromRegExp(schema_, references_, value);
+    case "String":
+      return FromString(schema_, references_, value);
+    case "Symbol":
+      return FromSymbol(schema_, references_, value);
+    case "TemplateLiteral":
+      return FromTemplateLiteral(schema_, references_, value);
+    case "This":
+      return FromThis(schema_, references_, value);
+    case "Tuple":
+      return FromTuple(schema_, references_, value);
+    case "Undefined":
+      return FromUndefined(schema_, references_, value);
+    case "Union":
+      return FromUnion(schema_, references_, value);
+    case "Uint8Array":
+      return FromUint8Array(schema_, references_, value);
+    case "Unknown":
+      return FromUnknown();
+    case "Void":
+      return FromVoid(schema_, references_, value);
+    default:
+      if (!type_exports.Has(schema_[Kind]))
+        throw new ValueCheckUnknownTypeError(schema_);
+      return FromKind(schema_, references_, value);
+  }
+}
+function Check(...args) {
+  return args.length === 3 ? Visit2(args[0], args[1], args[2]) : Visit2(args[0], [], args[1]);
+}
+
+// node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/errors/errors.mjs
+var ValueErrorType;
+(function(ValueErrorType2) {
+  ValueErrorType2[ValueErrorType2["ArrayContains"] = 0] = "ArrayContains";
+  ValueErrorType2[ValueErrorType2["ArrayMaxContains"] = 1] = "ArrayMaxContains";
+  ValueErrorType2[ValueErrorType2["ArrayMaxItems"] = 2] = "ArrayMaxItems";
+  ValueErrorType2[ValueErrorType2["ArrayMinContains"] = 3] = "ArrayMinContains";
+  ValueErrorType2[ValueErrorType2["ArrayMinItems"] = 4] = "ArrayMinItems";
+  ValueErrorType2[ValueErrorType2["ArrayUniqueItems"] = 5] = "ArrayUniqueItems";
+  ValueErrorType2[ValueErrorType2["Array"] = 6] = "Array";
+  ValueErrorType2[ValueErrorType2["AsyncIterator"] = 7] = "AsyncIterator";
+  ValueErrorType2[ValueErrorType2["BigIntExclusiveMaximum"] = 8] = "BigIntExclusiveMaximum";
+  ValueErrorType2[ValueErrorType2["BigIntExclusiveMinimum"] = 9] = "BigIntExclusiveMinimum";
+  ValueErrorType2[ValueErrorType2["BigIntMaximum"] = 10] = "BigIntMaximum";
+  ValueErrorType2[ValueErrorType2["BigIntMinimum"] = 11] = "BigIntMinimum";
+  ValueErrorType2[ValueErrorType2["BigIntMultipleOf"] = 12] = "BigIntMultipleOf";
+  ValueErrorType2[ValueErrorType2["BigInt"] = 13] = "BigInt";
+  ValueErrorType2[ValueErrorType2["Boolean"] = 14] = "Boolean";
+  ValueErrorType2[ValueErrorType2["DateExclusiveMaximumTimestamp"] = 15] = "DateExclusiveMaximumTimestamp";
+  ValueErrorType2[ValueErrorType2["DateExclusiveMinimumTimestamp"] = 16] = "DateExclusiveMinimumTimestamp";
+  ValueErrorType2[ValueErrorType2["DateMaximumTimestamp"] = 17] = "DateMaximumTimestamp";
+  ValueErrorType2[ValueErrorType2["DateMinimumTimestamp"] = 18] = "DateMinimumTimestamp";
+  ValueErrorType2[ValueErrorType2["DateMultipleOfTimestamp"] = 19] = "DateMultipleOfTimestamp";
+  ValueErrorType2[ValueErrorType2["Date"] = 20] = "Date";
+  ValueErrorType2[ValueErrorType2["Function"] = 21] = "Function";
+  ValueErrorType2[ValueErrorType2["IntegerExclusiveMaximum"] = 22] = "IntegerExclusiveMaximum";
+  ValueErrorType2[ValueErrorType2["IntegerExclusiveMinimum"] = 23] = "IntegerExclusiveMinimum";
+  ValueErrorType2[ValueErrorType2["IntegerMaximum"] = 24] = "IntegerMaximum";
+  ValueErrorType2[ValueErrorType2["IntegerMinimum"] = 25] = "IntegerMinimum";
+  ValueErrorType2[ValueErrorType2["IntegerMultipleOf"] = 26] = "IntegerMultipleOf";
+  ValueErrorType2[ValueErrorType2["Integer"] = 27] = "Integer";
+  ValueErrorType2[ValueErrorType2["IntersectUnevaluatedProperties"] = 28] = "IntersectUnevaluatedProperties";
+  ValueErrorType2[ValueErrorType2["Intersect"] = 29] = "Intersect";
+  ValueErrorType2[ValueErrorType2["Iterator"] = 30] = "Iterator";
+  ValueErrorType2[ValueErrorType2["Kind"] = 31] = "Kind";
+  ValueErrorType2[ValueErrorType2["Literal"] = 32] = "Literal";
+  ValueErrorType2[ValueErrorType2["Never"] = 33] = "Never";
+  ValueErrorType2[ValueErrorType2["Not"] = 34] = "Not";
+  ValueErrorType2[ValueErrorType2["Null"] = 35] = "Null";
+  ValueErrorType2[ValueErrorType2["NumberExclusiveMaximum"] = 36] = "NumberExclusiveMaximum";
+  ValueErrorType2[ValueErrorType2["NumberExclusiveMinimum"] = 37] = "NumberExclusiveMinimum";
+  ValueErrorType2[ValueErrorType2["NumberMaximum"] = 38] = "NumberMaximum";
+  ValueErrorType2[ValueErrorType2["NumberMinimum"] = 39] = "NumberMinimum";
+  ValueErrorType2[ValueErrorType2["NumberMultipleOf"] = 40] = "NumberMultipleOf";
+  ValueErrorType2[ValueErrorType2["Number"] = 41] = "Number";
+  ValueErrorType2[ValueErrorType2["ObjectAdditionalProperties"] = 42] = "ObjectAdditionalProperties";
+  ValueErrorType2[ValueErrorType2["ObjectMaxProperties"] = 43] = "ObjectMaxProperties";
+  ValueErrorType2[ValueErrorType2["ObjectMinProperties"] = 44] = "ObjectMinProperties";
+  ValueErrorType2[ValueErrorType2["ObjectRequiredProperty"] = 45] = "ObjectRequiredProperty";
+  ValueErrorType2[ValueErrorType2["Object"] = 46] = "Object";
+  ValueErrorType2[ValueErrorType2["Promise"] = 47] = "Promise";
+  ValueErrorType2[ValueErrorType2["RegExp"] = 48] = "RegExp";
+  ValueErrorType2[ValueErrorType2["StringFormatUnknown"] = 49] = "StringFormatUnknown";
+  ValueErrorType2[ValueErrorType2["StringFormat"] = 50] = "StringFormat";
+  ValueErrorType2[ValueErrorType2["StringMaxLength"] = 51] = "StringMaxLength";
+  ValueErrorType2[ValueErrorType2["StringMinLength"] = 52] = "StringMinLength";
+  ValueErrorType2[ValueErrorType2["StringPattern"] = 53] = "StringPattern";
+  ValueErrorType2[ValueErrorType2["String"] = 54] = "String";
+  ValueErrorType2[ValueErrorType2["Symbol"] = 55] = "Symbol";
+  ValueErrorType2[ValueErrorType2["TupleLength"] = 56] = "TupleLength";
+  ValueErrorType2[ValueErrorType2["Tuple"] = 57] = "Tuple";
+  ValueErrorType2[ValueErrorType2["Uint8ArrayMaxByteLength"] = 58] = "Uint8ArrayMaxByteLength";
+  ValueErrorType2[ValueErrorType2["Uint8ArrayMinByteLength"] = 59] = "Uint8ArrayMinByteLength";
+  ValueErrorType2[ValueErrorType2["Uint8Array"] = 60] = "Uint8Array";
+  ValueErrorType2[ValueErrorType2["Undefined"] = 61] = "Undefined";
+  ValueErrorType2[ValueErrorType2["Union"] = 62] = "Union";
+  ValueErrorType2[ValueErrorType2["Void"] = 63] = "Void";
+})(ValueErrorType || (ValueErrorType = {}));
+var ValueErrorsUnknownTypeError = class extends TypeBoxError {
+  constructor(schema) {
+    super("Unknown type");
+    this.schema = schema;
+  }
+};
+function EscapeKey(key) {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function IsDefined2(value) {
+  return value !== void 0;
+}
+var ValueErrorIterator = class {
+  constructor(iterator) {
+    this.iterator = iterator;
+  }
+  [Symbol.iterator]() {
+    return this.iterator;
+  }
+  /** Returns the first value error or undefined if no errors */
+  First() {
+    const next = this.iterator.next();
+    return next.done ? void 0 : next.value;
+  }
+};
+function Create(errorType, schema, path, value, errors = []) {
+  return {
+    type: errorType,
+    schema,
+    path,
+    value,
+    message: GetErrorFunction()({ errorType, path, schema, value, errors }),
+    errors
+  };
+}
+function* FromAny2(schema, references, path, value) {
+}
+function* FromArgument2(schema, references, path, value) {
+}
+function* FromArray2(schema, references, path, value) {
+  if (!IsArray(value)) {
+    return yield Create(ValueErrorType.Array, schema, path, value);
+  }
+  if (IsDefined2(schema.minItems) && !(value.length >= schema.minItems)) {
+    yield Create(ValueErrorType.ArrayMinItems, schema, path, value);
+  }
+  if (IsDefined2(schema.maxItems) && !(value.length <= schema.maxItems)) {
+    yield Create(ValueErrorType.ArrayMaxItems, schema, path, value);
+  }
+  for (let i = 0; i < value.length; i++) {
+    yield* Visit3(schema.items, references, `${path}/${i}`, value[i]);
+  }
+  if (schema.uniqueItems === true && !(function() {
+    const set = /* @__PURE__ */ new Set();
+    for (const element of value) {
+      const hashed = Hash(element);
+      if (set.has(hashed)) {
+        return false;
+      } else {
+        set.add(hashed);
+      }
+    }
+    return true;
+  })()) {
+    yield Create(ValueErrorType.ArrayUniqueItems, schema, path, value);
+  }
+  if (!(IsDefined2(schema.contains) || IsDefined2(schema.minContains) || IsDefined2(schema.maxContains))) {
+    return;
+  }
+  const containsSchema = IsDefined2(schema.contains) ? schema.contains : Never();
+  const containsCount = value.reduce((acc, value2, index) => Visit3(containsSchema, references, `${path}${index}`, value2).next().done === true ? acc + 1 : acc, 0);
+  if (containsCount === 0) {
+    yield Create(ValueErrorType.ArrayContains, schema, path, value);
+  }
+  if (IsNumber(schema.minContains) && containsCount < schema.minContains) {
+    yield Create(ValueErrorType.ArrayMinContains, schema, path, value);
+  }
+  if (IsNumber(schema.maxContains) && containsCount > schema.maxContains) {
+    yield Create(ValueErrorType.ArrayMaxContains, schema, path, value);
+  }
+}
+function* FromAsyncIterator2(schema, references, path, value) {
+  if (!IsAsyncIterator(value))
+    yield Create(ValueErrorType.AsyncIterator, schema, path, value);
+}
+function* FromBigInt2(schema, references, path, value) {
+  if (!IsBigInt(value))
+    return yield Create(ValueErrorType.BigInt, schema, path, value);
+  if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path, value);
+  }
+  if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path, value);
+  }
+  if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
+    yield Create(ValueErrorType.BigIntMaximum, schema, path, value);
+  }
+  if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
+    yield Create(ValueErrorType.BigIntMinimum, schema, path, value);
+  }
+  if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) {
+    yield Create(ValueErrorType.BigIntMultipleOf, schema, path, value);
+  }
+}
+function* FromBoolean2(schema, references, path, value) {
+  if (!IsBoolean(value))
+    yield Create(ValueErrorType.Boolean, schema, path, value);
+}
+function* FromConstructor2(schema, references, path, value) {
+  yield* Visit3(schema.returns, references, path, value.prototype);
+}
+function* FromDate2(schema, references, path, value) {
+  if (!IsDate(value))
+    return yield Create(ValueErrorType.Date, schema, path, value);
+  if (IsDefined2(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) {
+    yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value);
+  }
+  if (IsDefined2(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) {
+    yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value);
+  }
+  if (IsDefined2(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) {
+    yield Create(ValueErrorType.DateMaximumTimestamp, schema, path, value);
+  }
+  if (IsDefined2(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) {
+    yield Create(ValueErrorType.DateMinimumTimestamp, schema, path, value);
+  }
+  if (IsDefined2(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) {
+    yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path, value);
+  }
+}
+function* FromFunction2(schema, references, path, value) {
+  if (!IsFunction(value))
+    yield Create(ValueErrorType.Function, schema, path, value);
+}
+function* FromImport2(schema, references, path, value) {
+  const definitions = globalThis.Object.values(schema.$defs);
+  const target = schema.$defs[schema.$ref];
+  yield* Visit3(target, [...references, ...definitions], path, value);
+}
+function* FromInteger2(schema, references, path, value) {
+  if (!IsInteger(value))
+    return yield Create(ValueErrorType.Integer, schema, path, value);
+  if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path, value);
+  }
+  if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path, value);
+  }
+  if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
+    yield Create(ValueErrorType.IntegerMaximum, schema, path, value);
+  }
+  if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
+    yield Create(ValueErrorType.IntegerMinimum, schema, path, value);
+  }
+  if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    yield Create(ValueErrorType.IntegerMultipleOf, schema, path, value);
+  }
+}
+function* FromIntersect2(schema, references, path, value) {
+  let hasError = false;
+  for (const inner of schema.allOf) {
+    for (const error of Visit3(inner, references, path, value)) {
+      hasError = true;
+      yield error;
+    }
+  }
+  if (hasError) {
+    return yield Create(ValueErrorType.Intersect, schema, path, value);
+  }
+  if (schema.unevaluatedProperties === false) {
+    const keyCheck = new RegExp(KeyOfPattern(schema));
+    for (const valueKey of Object.getOwnPropertyNames(value)) {
+      if (!keyCheck.test(valueKey)) {
+        yield Create(ValueErrorType.IntersectUnevaluatedProperties, schema, `${path}/${valueKey}`, value);
+      }
+    }
+  }
+  if (typeof schema.unevaluatedProperties === "object") {
+    const keyCheck = new RegExp(KeyOfPattern(schema));
+    for (const valueKey of Object.getOwnPropertyNames(value)) {
+      if (!keyCheck.test(valueKey)) {
+        const next = Visit3(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next();
+        if (!next.done)
+          yield next.value;
+      }
+    }
+  }
+}
+function* FromIterator2(schema, references, path, value) {
+  if (!IsIterator(value))
+    yield Create(ValueErrorType.Iterator, schema, path, value);
+}
+function* FromLiteral2(schema, references, path, value) {
+  if (!(value === schema.const))
+    yield Create(ValueErrorType.Literal, schema, path, value);
+}
+function* FromNever2(schema, references, path, value) {
+  yield Create(ValueErrorType.Never, schema, path, value);
+}
+function* FromNot2(schema, references, path, value) {
+  if (Visit3(schema.not, references, path, value).next().done === true)
+    yield Create(ValueErrorType.Not, schema, path, value);
+}
+function* FromNull2(schema, references, path, value) {
+  if (!IsNull(value))
+    yield Create(ValueErrorType.Null, schema, path, value);
+}
+function* FromNumber2(schema, references, path, value) {
+  if (!TypeSystemPolicy.IsNumberLike(value))
+    return yield Create(ValueErrorType.Number, schema, path, value);
+  if (IsDefined2(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) {
+    yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path, value);
+  }
+  if (IsDefined2(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) {
+    yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path, value);
+  }
+  if (IsDefined2(schema.maximum) && !(value <= schema.maximum)) {
+    yield Create(ValueErrorType.NumberMaximum, schema, path, value);
+  }
+  if (IsDefined2(schema.minimum) && !(value >= schema.minimum)) {
+    yield Create(ValueErrorType.NumberMinimum, schema, path, value);
+  }
+  if (IsDefined2(schema.multipleOf) && !(value % schema.multipleOf === 0)) {
+    yield Create(ValueErrorType.NumberMultipleOf, schema, path, value);
+  }
+}
+function* FromObject2(schema, references, path, value) {
+  if (!TypeSystemPolicy.IsObjectLike(value))
+    return yield Create(ValueErrorType.Object, schema, path, value);
+  if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path, value);
+  }
+  if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path, value);
+  }
+  const requiredKeys = Array.isArray(schema.required) ? schema.required : [];
+  const knownKeys = Object.getOwnPropertyNames(schema.properties);
+  const unknownKeys = Object.getOwnPropertyNames(value);
+  for (const requiredKey of requiredKeys) {
+    if (unknownKeys.includes(requiredKey))
+      continue;
+    yield Create(ValueErrorType.ObjectRequiredProperty, schema.properties[requiredKey], `${path}/${EscapeKey(requiredKey)}`, void 0);
+  }
+  if (schema.additionalProperties === false) {
+    for (const valueKey of unknownKeys) {
+      if (!knownKeys.includes(valueKey)) {
+        yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${EscapeKey(valueKey)}`, value[valueKey]);
+      }
+    }
+  }
+  if (typeof schema.additionalProperties === "object") {
+    for (const valueKey of unknownKeys) {
+      if (knownKeys.includes(valueKey))
+        continue;
+      yield* Visit3(schema.additionalProperties, references, `${path}/${EscapeKey(valueKey)}`, value[valueKey]);
+    }
+  }
+  for (const knownKey of knownKeys) {
+    const property = schema.properties[knownKey];
+    if (schema.required && schema.required.includes(knownKey)) {
+      yield* Visit3(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey]);
+      if (ExtendsUndefinedCheck(schema) && !(knownKey in value)) {
+        yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path}/${EscapeKey(knownKey)}`, void 0);
+      }
+    } else {
+      if (TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
+        yield* Visit3(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey]);
+      }
+    }
+  }
+}
+function* FromPromise2(schema, references, path, value) {
+  if (!IsPromise(value))
+    yield Create(ValueErrorType.Promise, schema, path, value);
+}
+function* FromRecord2(schema, references, path, value) {
+  if (!TypeSystemPolicy.IsRecordLike(value))
+    return yield Create(ValueErrorType.Object, schema, path, value);
+  if (IsDefined2(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) {
+    yield Create(ValueErrorType.ObjectMinProperties, schema, path, value);
+  }
+  if (IsDefined2(schema.maxProperties) && !(Object.getOwnPropertyNames(value).length <= schema.maxProperties)) {
+    yield Create(ValueErrorType.ObjectMaxProperties, schema, path, value);
+  }
+  const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
+  const regex = new RegExp(patternKey);
+  for (const [propertyKey, propertyValue] of Object.entries(value)) {
+    if (regex.test(propertyKey))
+      yield* Visit3(patternSchema, references, `${path}/${EscapeKey(propertyKey)}`, propertyValue);
+  }
+  if (typeof schema.additionalProperties === "object") {
+    for (const [propertyKey, propertyValue] of Object.entries(value)) {
+      if (!regex.test(propertyKey))
+        yield* Visit3(schema.additionalProperties, references, `${path}/${EscapeKey(propertyKey)}`, propertyValue);
+    }
+  }
+  if (schema.additionalProperties === false) {
+    for (const [propertyKey, propertyValue] of Object.entries(value)) {
+      if (regex.test(propertyKey))
+        continue;
+      return yield Create(ValueErrorType.ObjectAdditionalProperties, schema, `${path}/${EscapeKey(propertyKey)}`, propertyValue);
+    }
+  }
+}
+function* FromRef2(schema, references, path, value) {
+  yield* Visit3(Deref(schema, references), references, path, value);
+}
+function* FromRegExp2(schema, references, path, value) {
+  if (!IsString(value))
+    return yield Create(ValueErrorType.String, schema, path, value);
+  if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
+    yield Create(ValueErrorType.StringMinLength, schema, path, value);
+  }
+  if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
+    yield Create(ValueErrorType.StringMaxLength, schema, path, value);
+  }
+  const regex = new RegExp(schema.source, schema.flags);
+  if (!regex.test(value)) {
+    return yield Create(ValueErrorType.RegExp, schema, path, value);
+  }
+}
+function* FromString2(schema, references, path, value) {
+  if (!IsString(value))
+    return yield Create(ValueErrorType.String, schema, path, value);
+  if (IsDefined2(schema.minLength) && !(value.length >= schema.minLength)) {
+    yield Create(ValueErrorType.StringMinLength, schema, path, value);
+  }
+  if (IsDefined2(schema.maxLength) && !(value.length <= schema.maxLength)) {
+    yield Create(ValueErrorType.StringMaxLength, schema, path, value);
+  }
+  if (IsString(schema.pattern)) {
+    const regex = new RegExp(schema.pattern);
+    if (!regex.test(value)) {
+      yield Create(ValueErrorType.StringPattern, schema, path, value);
+    }
+  }
+  if (IsString(schema.format)) {
+    if (!format_exports.Has(schema.format)) {
+      yield Create(ValueErrorType.StringFormatUnknown, schema, path, value);
+    } else {
+      const format = format_exports.Get(schema.format);
+      if (!format(value)) {
+        yield Create(ValueErrorType.StringFormat, schema, path, value);
+      }
+    }
+  }
+}
+function* FromSymbol2(schema, references, path, value) {
+  if (!IsSymbol(value))
+    yield Create(ValueErrorType.Symbol, schema, path, value);
+}
+function* FromTemplateLiteral2(schema, references, path, value) {
+  if (!IsString(value))
+    return yield Create(ValueErrorType.String, schema, path, value);
+  const regex = new RegExp(schema.pattern);
+  if (!regex.test(value)) {
+    yield Create(ValueErrorType.StringPattern, schema, path, value);
+  }
+}
+function* FromThis2(schema, references, path, value) {
+  yield* Visit3(Deref(schema, references), references, path, value);
+}
+function* FromTuple2(schema, references, path, value) {
+  if (!IsArray(value))
+    return yield Create(ValueErrorType.Tuple, schema, path, value);
+  if (schema.items === void 0 && !(value.length === 0)) {
+    return yield Create(ValueErrorType.TupleLength, schema, path, value);
+  }
+  if (!(value.length === schema.maxItems)) {
+    return yield Create(ValueErrorType.TupleLength, schema, path, value);
+  }
+  if (!schema.items) {
+    return;
+  }
+  for (let i = 0; i < schema.items.length; i++) {
+    yield* Visit3(schema.items[i], references, `${path}/${i}`, value[i]);
+  }
+}
+function* FromUndefined2(schema, references, path, value) {
+  if (!IsUndefined(value))
+    yield Create(ValueErrorType.Undefined, schema, path, value);
+}
+function* FromUnion2(schema, references, path, value) {
+  if (Check(schema, references, value))
+    return;
+  const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit3(variant, references, path, value)));
+  yield Create(ValueErrorType.Union, schema, path, value, errors);
+}
+function* FromUint8Array2(schema, references, path, value) {
+  if (!IsUint8Array(value))
+    return yield Create(ValueErrorType.Uint8Array, schema, path, value);
+  if (IsDefined2(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) {
+    yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value);
+  }
+  if (IsDefined2(schema.minByteLength) && !(value.length >= schema.minByteLength)) {
+    yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path, value);
+  }
+}
+function* FromUnknown2(schema, references, path, value) {
+}
+function* FromVoid2(schema, references, path, value) {
+  if (!TypeSystemPolicy.IsVoidLike(value))
+    yield Create(ValueErrorType.Void, schema, path, value);
+}
+function* FromKind2(schema, references, path, value) {
+  const check = type_exports.Get(schema[Kind]);
+  if (!check(schema, value))
+    yield Create(ValueErrorType.Kind, schema, path, value);
+}
+function* Visit3(schema, references, path, value) {
+  const references_ = IsDefined2(schema.$id) ? [...references, schema] : references;
+  const schema_ = schema;
+  switch (schema_[Kind]) {
+    case "Any":
+      return yield* FromAny2();
+    case "Argument":
+      return yield* FromArgument2();
+    case "Array":
+      return yield* FromArray2(schema_, references_, path, value);
+    case "AsyncIterator":
+      return yield* FromAsyncIterator2(schema_, references_, path, value);
+    case "BigInt":
+      return yield* FromBigInt2(schema_, references_, path, value);
+    case "Boolean":
+      return yield* FromBoolean2(schema_, references_, path, value);
+    case "Constructor":
+      return yield* FromConstructor2(schema_, references_, path, value);
+    case "Date":
+      return yield* FromDate2(schema_, references_, path, value);
+    case "Function":
+      return yield* FromFunction2(schema_, references_, path, value);
+    case "Import":
+      return yield* FromImport2(schema_, references_, path, value);
+    case "Integer":
+      return yield* FromInteger2(schema_, references_, path, value);
+    case "Intersect":
+      return yield* FromIntersect2(schema_, references_, path, value);
+    case "Iterator":
+      return yield* FromIterator2(schema_, references_, path, value);
+    case "Literal":
+      return yield* FromLiteral2(schema_, references_, path, value);
+    case "Never":
+      return yield* FromNever2(schema_, references_, path, value);
+    case "Not":
+      return yield* FromNot2(schema_, references_, path, value);
+    case "Null":
+      return yield* FromNull2(schema_, references_, path, value);
+    case "Number":
+      return yield* FromNumber2(schema_, references_, path, value);
+    case "Object":
+      return yield* FromObject2(schema_, references_, path, value);
+    case "Promise":
+      return yield* FromPromise2(schema_, references_, path, value);
+    case "Record":
+      return yield* FromRecord2(schema_, references_, path, value);
+    case "Ref":
+      return yield* FromRef2(schema_, references_, path, value);
+    case "RegExp":
+      return yield* FromRegExp2(schema_, references_, path, value);
+    case "String":
+      return yield* FromString2(schema_, references_, path, value);
+    case "Symbol":
+      return yield* FromSymbol2(schema_, references_, path, value);
+    case "TemplateLiteral":
+      return yield* FromTemplateLiteral2(schema_, references_, path, value);
+    case "This":
+      return yield* FromThis2(schema_, references_, path, value);
+    case "Tuple":
+      return yield* FromTuple2(schema_, references_, path, value);
+    case "Undefined":
+      return yield* FromUndefined2(schema_, references_, path, value);
+    case "Union":
+      return yield* FromUnion2(schema_, references_, path, value);
+    case "Uint8Array":
+      return yield* FromUint8Array2(schema_, references_, path, value);
+    case "Unknown":
+      return yield* FromUnknown2();
+    case "Void":
+      return yield* FromVoid2(schema_, references_, path, value);
+    default:
+      if (!type_exports.Has(schema_[Kind]))
+        throw new ValueErrorsUnknownTypeError(schema);
+      return yield* FromKind2(schema_, references_, path, value);
+  }
+}
+function Errors(...args) {
+  const iterator = args.length === 3 ? Visit3(args[0], args[1], "", args[2]) : Visit3(args[0], [], "", args[1]);
+  return new ValueErrorIterator(iterator);
+}
+
+// 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 (typeof state === "function" ? receiver !== state || true : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return 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 error = iterator.First();
+    super(error === void 0 ? "Invalid Value" : error.message);
+    _AssertError_instances.add(this);
+    _AssertError_iterator.set(this, void 0);
+    __classPrivateFieldSet(this, _AssertError_iterator, iterator);
+    this.error = error;
+  }
+  /** Returns an iterator for each error in this value. */
+  Errors() {
+    return new ValueErrorIterator(__classPrivateFieldGet(this, _AssertError_instances, "m", _AssertError_Iterator).call(this));
+  }
+};
+_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 FromObject3(value) {
+  const Acc = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    Acc[key] = Clone(value[key]);
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    Acc[key] = Clone(value[key]);
+  }
+  return Acc;
+}
+function FromArray3(value) {
+  return value.map((element) => Clone(element));
+}
+function FromTypedArray(value) {
+  return value.slice();
+}
+function FromMap(value) {
+  return new Map(Clone([...value.entries()]));
+}
+function FromSet(value) {
+  return new Set(Clone([...value.entries()]));
+}
+function FromDate3(value) {
+  return new Date(value.toISOString());
+}
+function FromValue(value) {
+  return value;
+}
+function Clone(value) {
+  if (IsArray(value))
+    return FromArray3(value);
+  if (IsDate(value))
+    return FromDate3(value);
+  if (IsTypedArray(value))
+    return FromTypedArray(value);
+  if (IsMap(value))
+    return FromMap(value);
+  if (IsSet(value))
+    return FromSet(value);
+  if (IsObject(value))
+    return FromObject3(value);
+  if (IsValueType(value))
+    return FromValue(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;
+  }
+};
+function FromDefault(value) {
+  return IsFunction(value) ? value() : Clone(value);
+}
+function FromAny3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return {};
+  }
+}
+function FromArgument3(schema, references) {
+  return {};
+}
+function FromArray4(schema, references) {
+  if (schema.uniqueItems === true && !HasPropertyKey(schema, "default")) {
+    throw new ValueCreateError(schema, "Array with the uniqueItems constraint requires a default value");
+  } else if ("contains" in schema && !HasPropertyKey(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 Visit4(schema.items, references);
+    });
+  } else {
+    return [];
+  }
+}
+function FromAsyncIterator3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return (async function* () {
+    })();
+  }
+}
+function FromBigInt3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return BigInt(0);
+  }
+}
+function FromBoolean3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return false;
+  }
+}
+function FromConstructor3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    const value = Visit4(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 {
+      };
+    }
+  }
+}
+function FromDate4(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else if (schema.minimumTimestamp !== void 0) {
+    return new Date(schema.minimumTimestamp);
+  } else {
+    return /* @__PURE__ */ new Date();
+  }
+}
+function FromFunction3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return () => Visit4(schema.returns, references);
+  }
+}
+function FromImport3(schema, references) {
+  const definitions = globalThis.Object.values(schema.$defs);
+  const target = schema.$defs[schema.$ref];
+  return Visit4(target, [...references, ...definitions]);
+}
+function FromInteger3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else if (schema.minimum !== void 0) {
+    return schema.minimum;
+  } else {
+    return 0;
+  }
+}
+function FromIntersect3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    const value = schema.allOf.reduce((acc, schema2) => {
+      const next = Visit4(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 FromIterator3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return (function* () {
+    })();
+  }
+}
+function FromLiteral3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return schema.const;
+  }
+}
+function FromNever3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    throw new ValueCreateError(schema, "Never types cannot be created. Consider using a default value.");
+  }
+}
+function FromNot3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    throw new ValueCreateError(schema, "Not types must have a default value");
+  }
+}
+function FromNull3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return null;
+  }
+}
+function FromNumber3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else if (schema.minimum !== void 0) {
+    return schema.minimum;
+  } else {
+    return 0;
+  }
+}
+function FromObject4(schema, references) {
+  if (HasPropertyKey(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] = Visit4(subschema, references);
+    }
+    return Acc;
+  }
+}
+function FromPromise3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return Promise.resolve(Visit4(schema.item, references));
+  }
+}
+function FromRecord3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return {};
+  }
+}
+function FromRef3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return Visit4(Deref(schema, references), references);
+  }
+}
+function FromRegExp3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    throw new ValueCreateError(schema, "RegExp types cannot be created. Consider using a default value.");
+  }
+}
+function FromString3(schema, references) {
+  if (schema.pattern !== void 0) {
+    if (!HasPropertyKey(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 (!HasPropertyKey(schema, "default")) {
+      throw new ValueCreateError(schema, "String types with formats must specify a default value");
+    } else {
+      return FromDefault(schema.default);
+    }
+  } else {
+    if (HasPropertyKey(schema, "default")) {
+      return FromDefault(schema.default);
+    } else if (schema.minLength !== void 0) {
+      return Array.from({ length: schema.minLength }).map(() => " ").join("");
+    } else {
+      return "";
+    }
+  }
+}
+function FromSymbol3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else if ("value" in schema) {
+    return Symbol.for(schema.value);
+  } else {
+    return /* @__PURE__ */ Symbol();
+  }
+}
+function FromTemplateLiteral3(schema, references) {
+  if (HasPropertyKey(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 FromThis3(schema, references) {
+  if (recursiveDepth++ > recursiveMaxDepth)
+    throw new ValueCreateError(schema, "Cannot create recursive type as it appears possibly infinite. Consider using a default.");
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return Visit4(Deref(schema, references), references);
+  }
+}
+function FromTuple3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  }
+  if (schema.items === void 0) {
+    return [];
+  } else {
+    return Array.from({ length: schema.minItems }).map((_, index) => Visit4(schema.items[index], references));
+  }
+}
+function FromUndefined3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return void 0;
+  }
+}
+function FromUnion3(schema, references) {
+  if (HasPropertyKey(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 Visit4(schema.anyOf[0], references);
+  }
+}
+function FromUint8Array3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else if (schema.minByteLength !== void 0) {
+    return new Uint8Array(schema.minByteLength);
+  } else {
+    return new Uint8Array(0);
+  }
+}
+function FromUnknown3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return {};
+  }
+}
+function FromVoid3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    return void 0;
+  }
+}
+function FromKind3(schema, references) {
+  if (HasPropertyKey(schema, "default")) {
+    return FromDefault(schema.default);
+  } else {
+    throw new Error("User defined types must specify a default value");
+  }
+}
+function Visit4(schema, references) {
+  const references_ = Pushref(schema, references);
+  const schema_ = schema;
+  switch (schema_[Kind]) {
+    case "Any":
+      return FromAny3(schema_);
+    case "Argument":
+      return FromArgument3();
+    case "Array":
+      return FromArray4(schema_, references_);
+    case "AsyncIterator":
+      return FromAsyncIterator3(schema_);
+    case "BigInt":
+      return FromBigInt3(schema_);
+    case "Boolean":
+      return FromBoolean3(schema_);
+    case "Constructor":
+      return FromConstructor3(schema_, references_);
+    case "Date":
+      return FromDate4(schema_);
+    case "Function":
+      return FromFunction3(schema_, references_);
+    case "Import":
+      return FromImport3(schema_, references_);
+    case "Integer":
+      return FromInteger3(schema_);
+    case "Intersect":
+      return FromIntersect3(schema_, references_);
+    case "Iterator":
+      return FromIterator3(schema_);
+    case "Literal":
+      return FromLiteral3(schema_);
+    case "Never":
+      return FromNever3(schema_);
+    case "Not":
+      return FromNot3(schema_);
+    case "Null":
+      return FromNull3(schema_);
+    case "Number":
+      return FromNumber3(schema_);
+    case "Object":
+      return FromObject4(schema_, references_);
+    case "Promise":
+      return FromPromise3(schema_, references_);
+    case "Record":
+      return FromRecord3(schema_);
+    case "Ref":
+      return FromRef3(schema_, references_);
+    case "RegExp":
+      return FromRegExp3(schema_);
+    case "String":
+      return FromString3(schema_);
+    case "Symbol":
+      return FromSymbol3(schema_);
+    case "TemplateLiteral":
+      return FromTemplateLiteral3(schema_);
+    case "This":
+      return FromThis3(schema_, references_);
+    case "Tuple":
+      return FromTuple3(schema_, references_);
+    case "Undefined":
+      return FromUndefined3(schema_);
+    case "Union":
+      return FromUnion3(schema_, references_);
+    case "Uint8Array":
+      return FromUint8Array3(schema_);
+    case "Unknown":
+      return FromUnknown3(schema_);
+    case "Void":
+      return FromVoid3(schema_);
+    default:
+      if (!type_exports.Has(schema_[Kind]))
+        throw new ValueCreateError(schema_, "Unknown type");
+      return FromKind3(schema_);
+  }
+}
+var recursiveMaxDepth = 512;
+var recursiveDepth = 0;
+function Create2(...args) {
+  recursiveDepth = 0;
+  return args.length === 2 ? Visit4(args[0], args[1]) : Visit4(args[0], []);
+}
+
+// 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;
+  }
+};
+function ScoreUnion(schema, references, value) {
+  if (schema[Kind] === "Object" && typeof value === "object" && !IsNull(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 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 CastUnion(union, references, value) {
+  if ("default" in union) {
+    return typeof value === "function" ? union.default : Clone(union.default);
+  } else {
+    const schema = SelectUnion(union, references, value);
+    return Cast(schema, references, value);
+  }
+}
+function DefaultClone(schema, references, value) {
+  return Check(schema, references, value) ? Clone(value) : Create2(schema, references);
+}
+function Default(schema, references, value) {
+  return Check(schema, references, value) ? value : Create2(schema, references);
+}
+function FromArray5(schema, references, value) {
+  if (Check(schema, references, value))
+    return Clone(value);
+  const created = IsArray(value) ? Clone(value) : Create2(schema, references);
+  const minimum = IsNumber(schema.minItems) && created.length < schema.minItems ? [...created, ...Array.from({ length: schema.minItems - created.length }, () => null)] : created;
+  const maximum = IsNumber(schema.maxItems) && minimum.length > schema.maxItems ? minimum.slice(0, schema.maxItems) : minimum;
+  const casted = maximum.map((value2) => Visit5(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 FromConstructor4(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] = Visit5(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 Visit5(target, [...references, ...definitions], value);
+}
+function IntersectAssign(correct, value) {
+  if (IsObject(correct) && !IsObject(value) || !IsObject(correct) && IsObject(value))
+    return correct;
+  if (!IsObject(correct) || !IsObject(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 FromIntersect4(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 FromNever4(schema, references, value) {
+  throw new ValueCastError(schema, "Never types cannot be cast");
+}
+function FromObject5(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] = Visit5(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] = Visit5(schema.additionalProperties, references, value[propertyName]);
+    }
+  }
+  return result;
+}
+function FromRecord4(schema, references, value) {
+  if (Check(schema, references, value))
+    return Clone(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] = Visit5(subschema, references, propValue);
+  }
+  return result;
+}
+function FromRef4(schema, references, value) {
+  return Visit5(Deref(schema, references), references, value);
+}
+function FromThis4(schema, references, value) {
+  return Visit5(Deref(schema, references), references, value);
+}
+function FromTuple4(schema, references, value) {
+  if (Check(schema, references, value))
+    return Clone(value);
+  if (!IsArray(value))
+    return Create2(schema, references);
+  if (schema.items === void 0)
+    return [];
+  return schema.items.map((schema2, index) => Visit5(schema2, references, value[index]));
+}
+function FromUnion4(schema, references, value) {
+  return Check(schema, references, value) ? Clone(value) : CastUnion(schema, references, value);
+}
+function Visit5(schema, references, value) {
+  const references_ = IsString(schema.$id) ? Pushref(schema, references) : references;
+  const schema_ = schema;
+  switch (schema[Kind]) {
+    // --------------------------------------------------------------
+    // Structural
+    // --------------------------------------------------------------
+    case "Array":
+      return FromArray5(schema_, references_, value);
+    case "Constructor":
+      return FromConstructor4(schema_, references_, value);
+    case "Import":
+      return FromImport4(schema_, references_, value);
+    case "Intersect":
+      return FromIntersect4(schema_, references_, value);
+    case "Never":
+      return FromNever4(schema_);
+    case "Object":
+      return FromObject5(schema_, references_, value);
+    case "Record":
+      return FromRecord4(schema_, references_, value);
+    case "Ref":
+      return FromRef4(schema_, references_, value);
+    case "This":
+      return FromThis4(schema_, references_, value);
+    case "Tuple":
+      return FromTuple4(schema_, references_, value);
+    case "Union":
+      return FromUnion4(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 ? Visit5(args[0], args[1], args[2]) : Visit5(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 FromArray6(schema, references, value) {
+  if (!IsArray(value))
+    return value;
+  return value.map((value2) => Visit6(schema.items, references, value2));
+}
+function FromImport5(schema, references, value) {
+  const definitions = globalThis.Object.values(schema.$defs);
+  const target = schema.$defs[schema.$ref];
+  return Visit6(target, [...references, ...definitions], value);
+}
+function FromIntersect5(schema, references, value) {
+  const unevaluatedProperties = schema.unevaluatedProperties;
+  const intersections = schema.allOf.map((schema2) => Visit6(schema2, references, Clone(value)));
+  const composite = intersections.reduce((acc, value2) => IsObject(value2) ? { ...acc, ...value2 } : value2, {});
+  if (!IsObject(value) || !IsObject(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] = Visit6(unevaluatedProperties, references, value[key]);
+    }
+  }
+  return composite;
+}
+function FromObject6(schema, references, value) {
+  if (!IsObject(value) || IsArray(value))
+    return value;
+  const additionalProperties = schema.additionalProperties;
+  for (const key of Object.getOwnPropertyNames(value)) {
+    if (HasPropertyKey(schema.properties, key)) {
+      value[key] = Visit6(schema.properties[key], references, value[key]);
+      continue;
+    }
+    if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
+      value[key] = Visit6(additionalProperties, references, value[key]);
+      continue;
+    }
+    delete value[key];
+  }
+  return value;
+}
+function FromRecord5(schema, references, value) {
+  if (!IsObject(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] = Visit6(propertySchema, references, value[key]);
+      continue;
+    }
+    if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
+      value[key] = Visit6(additionalProperties, references, value[key]);
+      continue;
+    }
+    delete value[key];
+  }
+  return value;
+}
+function FromRef5(schema, references, value) {
+  return Visit6(Deref(schema, references), references, value);
+}
+function FromThis5(schema, references, value) {
+  return Visit6(Deref(schema, references), references, value);
+}
+function FromTuple5(schema, references, value) {
+  if (!IsArray(value))
+    return value;
+  if (IsUndefined(schema.items))
+    return [];
+  const length = Math.min(value.length, schema.items.length);
+  for (let i = 0; i < length; i++) {
+    value[i] = Visit6(schema.items[i], references, value[i]);
+  }
+  return value.length > length ? value.slice(0, length) : value;
+}
+function FromUnion5(schema, references, value) {
+  for (const inner of schema.anyOf) {
+    if (IsCheckable(inner) && Check(inner, references, value)) {
+      return Visit6(inner, references, value);
+    }
+  }
+  return value;
+}
+function Visit6(schema, references, value) {
+  const references_ = IsString(schema.$id) ? Pushref(schema, references) : references;
+  const schema_ = schema;
+  switch (schema_[Kind]) {
+    case "Array":
+      return FromArray6(schema_, references_, value);
+    case "Import":
+      return FromImport5(schema_, references_, value);
+    case "Intersect":
+      return FromIntersect5(schema_, references_, value);
+    case "Object":
+      return FromObject6(schema_, references_, value);
+    case "Record":
+      return FromRecord5(schema_, references_, value);
+    case "Ref":
+      return FromRef5(schema_, references_, value);
+    case "This":
+      return FromThis5(schema_, references_, value);
+    case "Tuple":
+      return FromTuple5(schema_, references_, value);
+    case "Union":
+      return FromUnion5(schema_, references_, value);
+    default:
+      return value;
+  }
+}
+function Clean(...args) {
+  return args.length === 3 ? Visit6(args[0], args[1], args[2]) : Visit6(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 IsString(value) && !isNaN(value) && !isNaN(parseFloat(value));
+}
+function IsValueToString(value) {
+  return IsBigInt(value) || IsBoolean(value) || IsNumber(value);
+}
+function IsValueTrue(value) {
+  return value === true || IsNumber(value) && value === 1 || IsBigInt(value) && value === BigInt("1") || IsString(value) && (value.toLowerCase() === "true" || value === "1");
+}
+function IsValueFalse(value) {
+  return value === false || IsNumber(value) && (value === 0 || Object.is(value, -0)) || IsBigInt(value) && value === BigInt("0") || IsString(value) && (value.toLowerCase() === "false" || value === "0" || value === "-0");
+}
+function IsTimeStringWithTimeZone(value) {
+  return IsString(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 IsString(value) && /^(?:[0-2]\d:[0-5]\d:[0-5]\d|23:59:60)?$/i.test(value);
+}
+function IsDateTimeStringWithTimeZone(value) {
+  return IsString(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 IsString(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 IsString(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 IsString(schema.const) ? TryConvertLiteralString(value, schema.const) : IsNumber(schema.const) ? TryConvertLiteralNumber(value, schema.const) : IsBoolean(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)) : IsNumber(value) ? BigInt(Math.trunc(value)) : IsValueFalse(value) ? BigInt(0) : IsValueTrue(value) ? BigInt(1) : value;
+}
+function TryConvertString(value) {
+  return IsSymbol(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) : IsNumber(value) ? Math.trunc(value) : IsValueTrue(value) ? 1 : IsValueFalse(value) ? 0 : value;
+}
+function TryConvertNull(value) {
+  return IsString(value) && value.toLowerCase() === "null" ? null : value;
+}
+function TryConvertUndefined(value) {
+  return IsString(value) && value === "undefined" ? void 0 : value;
+}
+function TryConvertDate(value) {
+  return IsDate(value) ? value : IsNumber(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 FromArray7(schema, references, value) {
+  const elements = IsArray(value) ? value : [value];
+  return elements.map((element) => Visit7(schema.items, references, element));
+}
+function FromBigInt4(schema, references, value) {
+  return TryConvertBigInt(value);
+}
+function FromBoolean4(schema, references, value) {
+  return TryConvertBoolean(value);
+}
+function FromDate5(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 Visit7(target, [...references, ...definitions], value);
+}
+function FromInteger4(schema, references, value) {
+  return TryConvertInteger(value);
+}
+function FromIntersect6(schema, references, value) {
+  return schema.allOf.reduce((value2, schema2) => Visit7(schema2, references, value2), value);
+}
+function FromLiteral4(schema, references, value) {
+  return TryConvertLiteral(schema, value);
+}
+function FromNull4(schema, references, value) {
+  return TryConvertNull(value);
+}
+function FromNumber4(schema, references, value) {
+  return TryConvertNumber(value);
+}
+function FromObject7(schema, references, value) {
+  if (!IsObject(value) || IsArray(value))
+    return value;
+  for (const propertyKey of Object.getOwnPropertyNames(schema.properties)) {
+    if (!HasPropertyKey(value, propertyKey))
+      continue;
+    value[propertyKey] = Visit7(schema.properties[propertyKey], references, value[propertyKey]);
+  }
+  return value;
+}
+function FromRecord6(schema, references, value) {
+  const isConvertable = IsObject(value) && !IsArray(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] = Visit7(property, references, propValue);
+  }
+  return value;
+}
+function FromRef6(schema, references, value) {
+  return Visit7(Deref(schema, references), references, value);
+}
+function FromString4(schema, references, value) {
+  return TryConvertString(value);
+}
+function FromSymbol4(schema, references, value) {
+  return IsString(value) || IsNumber(value) ? Symbol(value) : value;
+}
+function FromThis6(schema, references, value) {
+  return Visit7(Deref(schema, references), references, value);
+}
+function FromTuple6(schema, references, value) {
+  const isConvertable = IsArray(value) && !IsUndefined(schema.items);
+  if (!isConvertable)
+    return value;
+  return value.map((value2, index) => {
+    return index < schema.items.length ? Visit7(schema.items[index], references, value2) : value2;
+  });
+}
+function FromUndefined4(schema, references, value) {
+  return TryConvertUndefined(value);
+}
+function FromUnion6(schema, references, value) {
+  for (const subschema of schema.anyOf) {
+    if (Check(subschema, references, value)) {
+      return value;
+    }
+  }
+  for (const subschema of schema.anyOf) {
+    const converted = Visit7(subschema, references, Clone(value));
+    if (!Check(subschema, references, converted))
+      continue;
+    return converted;
+  }
+  return value;
+}
+function Visit7(schema, references, value) {
+  const references_ = Pushref(schema, references);
+  const schema_ = schema;
+  switch (schema[Kind]) {
+    case "Array":
+      return FromArray7(schema_, references_, value);
+    case "BigInt":
+      return FromBigInt4(schema_, references_, value);
+    case "Boolean":
+      return FromBoolean4(schema_, references_, value);
+    case "Date":
+      return FromDate5(schema_, references_, value);
+    case "Import":
+      return FromImport6(schema_, references_, value);
+    case "Integer":
+      return FromInteger4(schema_, references_, value);
+    case "Intersect":
+      return FromIntersect6(schema_, references_, value);
+    case "Literal":
+      return FromLiteral4(schema_, references_, value);
+    case "Null":
+      return FromNull4(schema_, references_, value);
+    case "Number":
+      return FromNumber4(schema_, references_, value);
+    case "Object":
+      return FromObject7(schema_, references_, value);
+    case "Record":
+      return FromRecord6(schema_, references_, value);
+    case "Ref":
+      return FromRef6(schema_, references_, value);
+    case "String":
+      return FromString4(schema_, references_, value);
+    case "Symbol":
+      return FromSymbol4(schema_, references_, value);
+    case "This":
+      return FromThis6(schema_, references_, value);
+    case "Tuple":
+      return FromTuple6(schema_, references_, value);
+    case "Undefined":
+      return FromUndefined4(schema_, references_, value);
+    case "Union":
+      return FromUnion6(schema_, references_, value);
+    default:
+      return Default2(value);
+  }
+}
+function Convert(...args) {
+  return args.length === 3 ? Visit7(args[0], args[1], args[2]) : Visit7(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, error) {
+    super(`Unable to decode value as it does not match the expected schema`);
+    this.schema = schema;
+    this.value = value;
+    this.error = error;
+  }
+};
+var TransformDecodeError = class extends TypeBoxError {
+  constructor(schema, path, value, error) {
+    super(error instanceof Error ? error.message : "Unknown error");
+    this.schema = schema;
+    this.path = path;
+    this.value = value;
+    this.error = error;
+  }
+};
+function Default3(schema, path, value) {
+  try {
+    return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
+  } catch (error) {
+    throw new TransformDecodeError(schema, path, value, error);
+  }
+}
+function FromArray8(schema, references, path, value) {
+  return IsArray(value) ? Default3(schema, path, value.map((value2, index) => Visit8(schema.items, references, `${path}/${index}`, value2))) : Default3(schema, path, value);
+}
+function FromIntersect7(schema, references, path, value) {
+  if (!IsObject(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] = Visit8(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 = Visit8(target, [...references, ...additional], path, value);
+  return Default3(schema, path, result);
+}
+function FromNot4(schema, references, path, value) {
+  return Default3(schema, path, Visit8(schema.not, references, path, value));
+}
+function FromObject8(schema, references, path, value) {
+  if (!IsObject(value))
+    return Default3(schema, path, value);
+  const knownKeys = KeyOfPropertyKeys(schema);
+  const knownProperties = { ...value };
+  for (const key of knownKeys) {
+    if (!HasPropertyKey(knownProperties, key))
+      continue;
+    if (IsUndefined(knownProperties[key]) && (!IsUndefined2(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+      continue;
+    knownProperties[key] = Visit8(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 FromRecord7(schema, references, path, value) {
+  if (!IsObject(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] = Visit8(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 FromRef7(schema, references, path, value) {
+  const target = Deref(schema, references);
+  return Default3(schema, path, Visit8(target, references, path, value));
+}
+function FromThis7(schema, references, path, value) {
+  const target = Deref(schema, references);
+  return Default3(schema, path, Visit8(target, references, path, value));
+}
+function FromTuple7(schema, references, path, value) {
+  return IsArray(value) && IsArray(schema.items) ? Default3(schema, path, schema.items.map((schema2, index) => Visit8(schema2, references, `${path}/${index}`, value[index]))) : Default3(schema, path, value);
+}
+function FromUnion7(schema, references, path, value) {
+  for (const subschema of schema.anyOf) {
+    if (!Check(subschema, references, value))
+      continue;
+    const decoded = Visit8(subschema, references, path, value);
+    return Default3(schema, path, decoded);
+  }
+  return Default3(schema, path, value);
+}
+function Visit8(schema, references, path, value) {
+  const references_ = Pushref(schema, references);
+  const schema_ = schema;
+  switch (schema[Kind]) {
+    case "Array":
+      return FromArray8(schema_, references_, path, value);
+    case "Import":
+      return FromImport7(schema_, references_, path, value);
+    case "Intersect":
+      return FromIntersect7(schema_, references_, path, value);
+    case "Not":
+      return FromNot4(schema_, references_, path, value);
+    case "Object":
+      return FromObject8(schema_, references_, path, value);
+    case "Record":
+      return FromRecord7(schema_, references_, path, value);
+    case "Ref":
+      return FromRef7(schema_, references_, path, value);
+    case "Symbol":
+      return Default3(schema_, path, value);
+    case "This":
+      return FromThis7(schema_, references_, path, value);
+    case "Tuple":
+      return FromTuple7(schema_, references_, path, value);
+    case "Union":
+      return FromUnion7(schema_, references_, path, value);
+    default:
+      return Default3(schema_, path, value);
+  }
+}
+function TransformDecode(schema, references, value) {
+  return Visit8(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, error) {
+    super(`The encoded value does not match the expected schema`);
+    this.schema = schema;
+    this.value = value;
+    this.error = error;
+  }
+};
+var TransformEncodeError = class extends TypeBoxError {
+  constructor(schema, path, value, error) {
+    super(`${error instanceof Error ? error.message : "Unknown error"}`);
+    this.schema = schema;
+    this.path = path;
+    this.value = value;
+    this.error = error;
+  }
+};
+function Default4(schema, path, value) {
+  try {
+    return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
+  } catch (error) {
+    throw new TransformEncodeError(schema, path, value, error);
+  }
+}
+function FromArray9(schema, references, path, value) {
+  const defaulted = Default4(schema, path, value);
+  return IsArray(defaulted) ? defaulted.map((value2, index) => Visit9(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 = Default4(schema, path, value);
+  return Visit9(target, [...references, ...additional], path, result);
+}
+function FromIntersect8(schema, references, path, value) {
+  const defaulted = Default4(schema, path, value);
+  if (!IsObject(value) || IsValueType(value))
+    return defaulted;
+  const knownEntries = KeyOfPropertyEntries(schema);
+  const knownKeys = knownEntries.map((entry) => entry[0]);
+  const knownProperties = { ...defaulted };
+  for (const [knownKey, knownSchema] of knownEntries)
+    if (knownKey in knownProperties) {
+      knownProperties[knownKey] = Visit9(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
+    }
+  if (!IsTransform(schema.unevaluatedProperties)) {
+    return knownProperties;
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+  const unevaluatedProperties = schema.unevaluatedProperties;
+  const properties = { ...knownProperties };
+  for (const key of unknownKeys)
+    if (!knownKeys.includes(key)) {
+      properties[key] = Default4(unevaluatedProperties, `${path}/${key}`, properties[key]);
+    }
+  return properties;
+}
+function FromNot5(schema, references, path, value) {
+  return Default4(schema.not, path, Default4(schema, path, value));
+}
+function FromObject9(schema, references, path, value) {
+  const defaulted = Default4(schema, path, value);
+  if (!IsObject(defaulted))
+    return defaulted;
+  const knownKeys = KeyOfPropertyKeys(schema);
+  const knownProperties = { ...defaulted };
+  for (const key of knownKeys) {
+    if (!HasPropertyKey(knownProperties, key))
+      continue;
+    if (IsUndefined(knownProperties[key]) && (!IsUndefined2(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+      continue;
+    knownProperties[key] = Visit9(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
+  }
+  if (!IsSchema(schema.additionalProperties)) {
+    return knownProperties;
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+  const additionalProperties = schema.additionalProperties;
+  const properties = { ...knownProperties };
+  for (const key of unknownKeys)
+    if (!knownKeys.includes(key)) {
+      properties[key] = Default4(additionalProperties, `${path}/${key}`, properties[key]);
+    }
+  return properties;
+}
+function FromRecord8(schema, references, path, value) {
+  const defaulted = Default4(schema, path, value);
+  if (!IsObject(value))
+    return defaulted;
+  const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+  const knownKeys = new RegExp(pattern);
+  const knownProperties = { ...defaulted };
+  for (const key of Object.getOwnPropertyNames(value))
+    if (knownKeys.test(key)) {
+      knownProperties[key] = Visit9(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
+    }
+  if (!IsSchema(schema.additionalProperties)) {
+    return knownProperties;
+  }
+  const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+  const additionalProperties = schema.additionalProperties;
+  const properties = { ...knownProperties };
+  for (const key of unknownKeys)
+    if (!knownKeys.test(key)) {
+      properties[key] = Default4(additionalProperties, `${path}/${key}`, properties[key]);
+    }
+  return properties;
+}
+function FromRef8(schema, references, path, value) {
+  const target = Deref(schema, references);
+  const resolved = Visit9(target, references, path, value);
+  return Default4(schema, path, resolved);
+}
+function FromThis8(schema, references, path, value) {
+  const target = Deref(schema, references);
+  const resolved = Visit9(target, references, path, value);
+  return Default4(schema, path, resolved);
+}
+function FromTuple8(schema, references, path, value) {
+  const value1 = Default4(schema, path, value);
+  return IsArray(schema.items) ? schema.items.map((schema2, index) => Visit9(schema2, references, `${path}/${index}`, value1[index])) : [];
+}
+function FromUnion8(schema, references, path, value) {
+  for (const subschema of schema.anyOf) {
+    if (!Check(subschema, references, value))
+      continue;
+    const value1 = Visit9(subschema, references, path, value);
+    return Default4(schema, path, value1);
+  }
+  for (const subschema of schema.anyOf) {
+    const value1 = Visit9(subschema, references, path, value);
+    if (!Check(schema, references, value1))
+      continue;
+    return Default4(schema, path, value1);
+  }
+  return Default4(schema, path, value);
+}
+function Visit9(schema, references, path, value) {
+  const references_ = Pushref(schema, references);
+  const schema_ = schema;
+  switch (schema[Kind]) {
+    case "Array":
+      return FromArray9(schema_, references_, path, value);
+    case "Import":
+      return FromImport8(schema_, references_, path, value);
+    case "Intersect":
+      return FromIntersect8(schema_, references_, path, value);
+    case "Not":
+      return FromNot5(schema_, references_, path, value);
+    case "Object":
+      return FromObject9(schema_, references_, path, value);
+    case "Record":
+      return FromRecord8(schema_, references_, path, value);
+    case "Ref":
+      return FromRef8(schema_, references_, path, value);
+    case "This":
+      return FromThis8(schema_, references_, path, value);
+    case "Tuple":
+      return FromTuple8(schema_, references_, path, value);
+    case "Union":
+      return FromUnion8(schema_, references_, path, value);
+    default:
+      return Default4(schema_, path, value);
+  }
+}
+function TransformEncode(schema, references, value) {
+  return Visit9(schema, references, "", value);
+}
+
+// node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/transform/has.mjs
+function FromArray10(schema, references) {
+  return IsTransform(schema) || Visit10(schema.items, references);
+}
+function FromAsyncIterator4(schema, references) {
+  return IsTransform(schema) || Visit10(schema.items, references);
+}
+function FromConstructor5(schema, references) {
+  return IsTransform(schema) || Visit10(schema.returns, references) || schema.parameters.some((schema2) => Visit10(schema2, references));
+}
+function FromFunction4(schema, references) {
+  return IsTransform(schema) || Visit10(schema.returns, references) || schema.parameters.some((schema2) => Visit10(schema2, references));
+}
+function FromIntersect9(schema, references) {
+  return IsTransform(schema) || IsTransform(schema.unevaluatedProperties) || schema.allOf.some((schema2) => Visit10(schema2, 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) || Visit10(target, [...additional, ...references]);
+}
+function FromIterator4(schema, references) {
+  return IsTransform(schema) || Visit10(schema.items, references);
+}
+function FromNot6(schema, references) {
+  return IsTransform(schema) || Visit10(schema.not, references);
+}
+function FromObject10(schema, references) {
+  return IsTransform(schema) || Object.values(schema.properties).some((schema2) => Visit10(schema2, references)) || IsSchema(schema.additionalProperties) && Visit10(schema.additionalProperties, references);
+}
+function FromPromise4(schema, references) {
+  return IsTransform(schema) || Visit10(schema.item, references);
+}
+function FromRecord9(schema, references) {
+  const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+  const property = schema.patternProperties[pattern];
+  return IsTransform(schema) || Visit10(property, references) || IsSchema(schema.additionalProperties) && IsTransform(schema.additionalProperties);
+}
+function FromRef9(schema, references) {
+  if (IsTransform(schema))
+    return true;
+  return Visit10(Deref(schema, references), references);
+}
+function FromThis9(schema, references) {
+  if (IsTransform(schema))
+    return true;
+  return Visit10(Deref(schema, references), references);
+}
+function FromTuple9(schema, references) {
+  return IsTransform(schema) || !IsUndefined(schema.items) && schema.items.some((schema2) => Visit10(schema2, references));
+}
+function FromUnion9(schema, references) {
+  return IsTransform(schema) || schema.anyOf.some((schema2) => Visit10(schema2, references));
+}
+function Visit10(schema, references) {
+  const references_ = Pushref(schema, references);
+  const schema_ = schema;
+  if (schema.$id && visited.has(schema.$id))
+    return false;
+  if (schema.$id)
+    visited.add(schema.$id);
+  switch (schema[Kind]) {
+    case "Array":
+      return FromArray10(schema_, references_);
+    case "AsyncIterator":
+      return FromAsyncIterator4(schema_, references_);
+    case "Constructor":
+      return FromConstructor5(schema_, references_);
+    case "Function":
+      return FromFunction4(schema_, references_);
+    case "Import":
+      return FromImport9(schema_, references_);
+    case "Intersect":
+      return FromIntersect9(schema_, references_);
+    case "Iterator":
+      return FromIterator4(schema_, references_);
+    case "Not":
+      return FromNot6(schema_, references_);
+    case "Object":
+      return FromObject10(schema_, references_);
+    case "Promise":
+      return FromPromise4(schema_, references_);
+    case "Record":
+      return FromRecord9(schema_, references_);
+    case "Ref":
+      return FromRef9(schema_, references_);
+    case "This":
+      return FromThis9(schema_, references_);
+    case "Tuple":
+      return FromTuple9(schema_, references_);
+    case "Union":
+      return FromUnion9(schema_, references_);
+    default:
+      return IsTransform(schema);
+  }
+}
+var visited = /* @__PURE__ */ new Set();
+function HasTransform(schema, references) {
+  visited.clear();
+  return Visit10(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 = HasPropertyKey(schema, "default") ? schema.default : void 0;
+  const clone = IsFunction(defaultValue) ? defaultValue() : Clone(defaultValue);
+  return IsUndefined(value) ? clone : IsObject(value) && IsObject(clone) ? Object.assign(clone, value) : value;
+}
+function HasDefaultProperty(schema) {
+  return IsKind(schema) && "default" in schema;
+}
+function FromArray11(schema, references, value) {
+  if (IsArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      value[i] = Visit11(schema.items, references, value[i]);
+    }
+    return value;
+  }
+  const defaulted = ValueOrDefault(schema, value);
+  if (!IsArray(defaulted))
+    return defaulted;
+  for (let i = 0; i < defaulted.length; i++) {
+    defaulted[i] = Visit11(schema.items, references, defaulted[i]);
+  }
+  return defaulted;
+}
+function FromDate6(schema, references, value) {
+  return IsDate(value) ? value : ValueOrDefault(schema, value);
+}
+function FromImport10(schema, references, value) {
+  const definitions = globalThis.Object.values(schema.$defs);
+  const target = schema.$defs[schema.$ref];
+  return Visit11(target, [...references, ...definitions], value);
+}
+function FromIntersect10(schema, references, value) {
+  const defaulted = ValueOrDefault(schema, value);
+  return schema.allOf.reduce((acc, schema2) => {
+    const next = Visit11(schema2, references, defaulted);
+    return IsObject(next) ? { ...acc, ...next } : next;
+  }, {});
+}
+function FromObject11(schema, references, value) {
+  const defaulted = ValueOrDefault(schema, value);
+  if (!IsObject(defaulted))
+    return defaulted;
+  const knownPropertyKeys = Object.getOwnPropertyNames(schema.properties);
+  for (const key of knownPropertyKeys) {
+    const propertyValue = Visit11(schema.properties[key], references, defaulted[key]);
+    if (IsUndefined(propertyValue))
+      continue;
+    defaulted[key] = Visit11(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] = Visit11(schema.additionalProperties, references, defaulted[key]);
+  }
+  return defaulted;
+}
+function FromRecord10(schema, references, value) {
+  const defaulted = ValueOrDefault(schema, value);
+  if (!IsObject(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] = Visit11(propertySchema, references, defaulted[key]);
+  }
+  if (!HasDefaultProperty(additionalPropertiesSchema))
+    return defaulted;
+  for (const key of Object.getOwnPropertyNames(defaulted)) {
+    if (knownPropertyKey.test(key))
+      continue;
+    defaulted[key] = Visit11(additionalPropertiesSchema, references, defaulted[key]);
+  }
+  return defaulted;
+}
+function FromRef10(schema, references, value) {
+  return Visit11(Deref(schema, references), references, ValueOrDefault(schema, value));
+}
+function FromThis10(schema, references, value) {
+  return Visit11(Deref(schema, references), references, value);
+}
+function FromTuple10(schema, references, value) {
+  const defaulted = ValueOrDefault(schema, value);
+  if (!IsArray(defaulted) || IsUndefined(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] = Visit11(items[i], references, defaulted[i]);
+  }
+  return defaulted;
+}
+function FromUnion10(schema, references, value) {
+  const defaulted = ValueOrDefault(schema, value);
+  for (const inner of schema.anyOf) {
+    const result = Visit11(inner, references, Clone(defaulted));
+    if (Check(inner, references, result)) {
+      return result;
+    }
+  }
+  return defaulted;
+}
+function Visit11(schema, references, value) {
+  const references_ = Pushref(schema, references);
+  const schema_ = schema;
+  switch (schema_[Kind]) {
+    case "Array":
+      return FromArray11(schema_, references_, value);
+    case "Date":
+      return FromDate6(schema_, references_, value);
+    case "Import":
+      return FromImport10(schema_, references_, value);
+    case "Intersect":
+      return FromIntersect10(schema_, references_, value);
+    case "Object":
+      return FromObject11(schema_, references_, value);
+    case "Record":
+      return FromRecord10(schema_, references_, value);
+    case "Ref":
+      return FromRef10(schema_, references_, value);
+    case "This":
+      return FromThis10(schema_, references_, value);
+    case "Tuple":
+      return FromTuple10(schema_, references_, value);
+    case "Union":
+      return FromUnion10(schema_, references_, value);
+    default:
+      return ValueOrDefault(schema_, value);
+  }
+}
+function Default5(...args) {
+  return args.length === 3 ? Visit11(args[0], args[1], args[2]) : Visit11(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: () => Delete,
+  Format: () => Format,
+  Get: () => Get,
+  Has: () => Has,
+  Set: () => Set2,
+  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 Escape(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 Escape(pointer.slice(start, end));
+        start = i + 1;
+      }
+    } else {
+      end = i;
+    }
+  }
+  yield Escape(pointer.slice(start));
+}
+function Set2(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 Delete(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 Has(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 Get(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 ObjectType2(left, right) {
+  if (!IsObject(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 DateType2(left, right) {
+  return IsDate(right) && left.getTime() === right.getTime();
+}
+function ArrayType2(left, right) {
+  if (!IsArray(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 (IsDate(left))
+    return DateType2(left, right);
+  if (IsTypedArray(left))
+    return TypedArrayType(left, right);
+  if (IsArray(left))
+    return ArrayType2(left, right);
+  if (IsObject(left))
+    return ObjectType2(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 = Object$1({
+  type: Literal("insert"),
+  path: String(),
+  value: Unknown()
+});
+var Update = Object$1({
+  type: Literal("update"),
+  path: String(),
+  value: Unknown()
+});
+var Delete2 = Object$1({
+  type: Literal("delete"),
+  path: String()
+});
+var Edit = Union([Insert, Update, Delete2]);
+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* ObjectType3(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 (HasPropertyKey(current, key))
+      continue;
+    yield CreateInsert(`${path}/${key}`, next[key]);
+  }
+  for (const key of currentKeys) {
+    if (!HasPropertyKey(next, key))
+      continue;
+    if (Equal(current, next))
+      continue;
+    yield* Visit12(`${path}/${key}`, current[key], next[key]);
+  }
+  for (const key of currentKeys) {
+    if (HasPropertyKey(next, key))
+      continue;
+    yield CreateDelete(`${path}/${key}`);
+  }
+}
+function* ArrayType3(path, current, next) {
+  if (!IsArray(next))
+    return yield CreateUpdate(path, next);
+  for (let i = 0; i < Math.min(current.length, next.length); i++) {
+    yield* Visit12(`${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* Visit12(`${path}/${i}`, current[i], next[i]);
+  }
+}
+function* ValueType2(path, current, next) {
+  if (current === next)
+    return;
+  yield CreateUpdate(path, next);
+}
+function* Visit12(path, current, next) {
+  if (IsStandardObject(current))
+    return yield* ObjectType3(path, current, next);
+  if (IsArray(current))
+    return yield* ArrayType3(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 [...Visit12("", 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 Clone(edits[0].value);
+  }
+  if (IsIdentity(edits)) {
+    return Clone(current);
+  }
+  const clone = Clone(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 IsObject(value) && !IsArray(value);
+}
+var ValueMutateError = class extends TypeBoxError {
+  constructor(message) {
+    super(message);
+  }
+};
+function ObjectType4(root, path, current, next) {
+  if (!IsStandardObject2(current)) {
+    pointer_exports.Set(root, path, Clone(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) {
+      Visit13(root, `${path}/${nextKey}`, current[nextKey], next[nextKey]);
+    }
+  }
+}
+function ArrayType4(root, path, current, next) {
+  if (!IsArray(current)) {
+    pointer_exports.Set(root, path, Clone(next));
+  } else {
+    for (let index = 0; index < next.length; index++) {
+      Visit13(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, Clone(next));
+  }
+}
+function ValueType3(root, path, current, next) {
+  if (current === next)
+    return;
+  pointer_exports.Set(root, path, next);
+}
+function Visit13(root, path, current, next) {
+  if (IsArray(next))
+    return ArrayType4(root, path, current, next);
+  if (IsTypedArray(next))
+    return TypedArrayType3(root, path, current, next);
+  if (IsStandardObject2(next))
+    return ObjectType4(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) && IsArray(next) || IsArray(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");
+  Visit13(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) => Clone(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 Delete3(key) {
+    registry.delete(key);
+  }
+  ParseRegistry2.Delete = Delete3;
+  function Set3(key, callback) {
+    registry.set(key, callback);
+  }
+  ParseRegistry2.Set = Set3;
+  function Get2(key) {
+    return registry.get(key);
+  }
+  ParseRegistry2.Get = Get2;
+})(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 (IsUndefined(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 ? IsArray(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);
+}
+
+export { value_exports };