@dynamicalsystems/idl-conformance 0.6.1

package/dist/reference-adapter-CaAo2iIH.mjs

@@ -0,0 +1,1441 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { jcsStringify } from "@dynamicalsystems/orn-schemas";
+import { PROFILES } from "@dynamicalsystems/idl";
+//#region src/runner.ts
+/** Runs every vector under `assetsDir` through the adapter. The checklist
+* is the coverage floor: a profile listed there with fewer vectors on disk
+* than promised fails the run, so a silently deleted directory cannot pass. */
+function runVectors(adapter, assetsDir, checklist) {
+	const verdicts = [];
+	for (const [profile, expectedCount] of Object.entries(checklist.profiles)) {
+		const dir = join(assetsDir, profile.replaceAll("/", "_"));
+		let files = [];
+		for (const verdict of [
+			"accept",
+			"reject",
+			"digest"
+		]) {
+			let names = [];
+			try {
+				names = readdirSync(join(dir, verdict)).filter((f) => f.endsWith(".json"));
+			} catch {
+				names = [];
+			}
+			files = files.concat(names.map((n) => join(dir, verdict, n)));
+		}
+		if (files.length < expectedCount) {
+			verdicts.push({
+				id: profile,
+				expected: "accept",
+				outcome: "fail",
+				detail: `checklist promises ${expectedCount} vectors, found ${files.length}`
+			});
+			continue;
+		}
+		for (const file of files) {
+			const vector = JSON.parse(readFileSync(file, "utf8"));
+			const isDigest = file.includes("/digest/");
+			const key = isDigest ? `${vector.profile}#digest.${vector.shape}` : `${vector.profile}#${vector.shape}`;
+			const parse = adapter[key];
+			if (parse === void 0 && vector.obligation === "semantic") continue;
+			if (parse === void 0) {
+				verdicts.push({
+					id: `${key}/${vector.name}`,
+					expected: vector.verdict,
+					outcome: "fail",
+					detail: "adapter has no parser for this shape"
+				});
+				continue;
+			}
+			const result = parse(Buffer.from(vector.bytes, "base64"));
+			const agreed = isDigest ? result.ok && result.digest === vector.sha256 : result.ok === (vector.verdict === "accept");
+			verdicts.push({
+				id: `${vector.profile}#${vector.shape}/${vector.name}`,
+				expected: vector.verdict,
+				outcome: agreed ? "pass" : "fail",
+				detail: agreed ? vector.rule ?? "" : isDigest ? result.ok ? `digest mismatch: computed ${result.digest ?? "nothing"}, vector pins ${vector.sha256 ?? "nothing"}` : `could not digest: ${result.reason}` : result.ok ? `accepted but must reject: ${vector.rule ?? "unnamed rule"}` : `rejected but must accept: ${result.reason}`
+			});
+		}
+	}
+	const failed = verdicts.filter((v) => v.outcome === "fail").length;
+	return {
+		passed: verdicts.length - failed,
+		failed,
+		verdicts
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
+/** Returns true if this value is an async iterator */
+function IsAsyncIterator$1(value) {
+	return IsObject$2(value) && globalThis.Symbol.asyncIterator in value;
+}
+/** Returns true if this value is an iterator */
+function IsIterator$1(value) {
+	return IsObject$2(value) && globalThis.Symbol.iterator in value;
+}
+/** Returns true if this value is a Promise */
+function IsPromise$1(value) {
+	return value instanceof globalThis.Promise;
+}
+/** Returns true if this value is a Date */
+function IsDate$2(value) {
+	return value instanceof Date && globalThis.Number.isFinite(value.getTime());
+}
+/** Returns true if the value is a Uint8Array */
+function IsUint8Array$2(value) {
+	return value instanceof globalThis.Uint8Array;
+}
+/** Returns true of this value is an object type */
+function IsObject$2(value) {
+	return value !== null && typeof value === "object";
+}
+/** Returns true if this value is an array, but not a typed array */
+function IsArray$2(value) {
+	return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
+}
+/** Returns true if this value is an undefined */
+function IsUndefined$1(value) {
+	return value === void 0;
+}
+/** Returns true if this value is an null */
+function IsNull$1(value) {
+	return value === null;
+}
+/** Returns true if this value is an boolean */
+function IsBoolean$1(value) {
+	return typeof value === "boolean";
+}
+/** Returns true if this value is an number */
+function IsNumber$1(value) {
+	return typeof value === "number";
+}
+/** Returns true if this value is an integer */
+function IsInteger$1(value) {
+	return globalThis.Number.isInteger(value);
+}
+/** Returns true if this value is bigint */
+function IsBigInt$1(value) {
+	return typeof value === "bigint";
+}
+/** Returns true if this value is string */
+function IsString$2(value) {
+	return typeof value === "string";
+}
+/** Returns true if this value is a function */
+function IsFunction$1(value) {
+	return typeof value === "function";
+}
+/** Returns true if this value is a symbol */
+function IsSymbol$1(value) {
+	return typeof value === "symbol";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/system/policy.mjs
+var TypeSystemPolicy;
+(function(TypeSystemPolicy) {
+	/**
+	* Configures the instantiation behavior of TypeBox types. The `default` option assigns raw JavaScript
+	* references for embedded types, which may cause side effects if type properties are explicitly updated
+	* outside the TypeBox type builder. The `clone` option creates copies of any shared types upon creation,
+	* preventing unintended side effects. The `freeze` option applies `Object.freeze()` to the type, making
+	* it fully readonly and immutable. Implementations should use `default` whenever possible, as it is the
+	* fastest way to instantiate types. The default setting is `default`.
+	*/
+	TypeSystemPolicy.InstanceMode = "default";
+	/** Sets whether TypeBox should assert optional properties using the TypeScript `exactOptionalPropertyTypes` assertion policy. The default is `false` */
+	TypeSystemPolicy.ExactOptionalPropertyTypes = false;
+	/** Sets whether arrays should be treated as a kind of objects. The default is `false` */
+	TypeSystemPolicy.AllowArrayObject = false;
+	/** Sets whether `NaN` or `Infinity` should be treated as valid numeric values. The default is `false` */
+	TypeSystemPolicy.AllowNaN = false;
+	/** Sets whether `null` should validate for void types. The default is `false` */
+	TypeSystemPolicy.AllowNullVoid = false;
+	/** Checks this value using the ExactOptionalPropertyTypes policy */
+	function IsExactOptionalProperty(value, key) {
+		return TypeSystemPolicy.ExactOptionalPropertyTypes ? key in value : value[key] !== void 0;
+	}
+	TypeSystemPolicy.IsExactOptionalProperty = IsExactOptionalProperty;
+	/** Checks this value using the AllowArrayObjects policy */
+	function IsObjectLike(value) {
+		const isObject = IsObject$2(value);
+		return TypeSystemPolicy.AllowArrayObject ? isObject : isObject && !IsArray$2(value);
+	}
+	TypeSystemPolicy.IsObjectLike = IsObjectLike;
+	/** Checks this value as a record using the AllowArrayObjects policy */
+	function IsRecordLike(value) {
+		return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+	}
+	TypeSystemPolicy.IsRecordLike = IsRecordLike;
+	/** Checks this value using the AllowNaN policy */
+	function IsNumberLike(value) {
+		return TypeSystemPolicy.AllowNaN ? IsNumber$1(value) : Number.isFinite(value);
+	}
+	TypeSystemPolicy.IsNumberLike = IsNumberLike;
+	/** Checks this value using the AllowVoidNull policy */
+	function IsVoidLike(value) {
+		const isUndefined = IsUndefined$1(value);
+		return TypeSystemPolicy.AllowNullVoid ? isUndefined || value === null : isUndefined;
+	}
+	TypeSystemPolicy.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (TypeSystemPolicy = {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/registry/format.mjs
+/** A registry for user defined string formats */
+const map$1 = /* @__PURE__ */ new Map();
+/** Returns true if the user defined string format exists */
+function Has$1(format) {
+	return map$1.has(format);
+}
+/** Gets a validation function for a user defined string format */
+function Get$1(format) {
+	return map$1.get(format);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/registry/type.mjs
+/** A registry for user defined types */
+const map = /* @__PURE__ */ new Map();
+/** Returns true if this registry contains this kind */
+function Has(kind) {
+	return map.has(kind);
+}
+/** Gets a custom validation function for a user defined type */
+function Get(kind) {
+	return map.get(kind);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
+/** Returns true if this value is an array */
+function IsArray$1(value) {
+	return Array.isArray(value);
+}
+/** Returns true if this value is a Date object */
+function IsDate$1(value) {
+	return value instanceof globalThis.Date;
+}
+/** Returns true if this value is an object */
+function IsObject$1(value) {
+	return typeof value === "object" && value !== null;
+}
+/** Returns true if this value is RegExp */
+function IsRegExp$1(value) {
+	return value instanceof globalThis.RegExp;
+}
+/** Returns true if this value is string */
+function IsString$1(value) {
+	return typeof value === "string";
+}
+/** Returns true if this value is a Uint8Array */
+function IsUint8Array$1(value) {
+	return value instanceof globalThis.Uint8Array;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs
+function ImmutableArray(value) {
+	return globalThis.Object.freeze(value).map((value) => Immutable(value));
+}
+function ImmutableDate(value) {
+	return value;
+}
+function ImmutableUint8Array(value) {
+	return value;
+}
+function ImmutableRegExp(value) {
+	return value;
+}
+function ImmutableObject(value) {
+	const result = {};
+	for (const key of Object.getOwnPropertyNames(value)) result[key] = Immutable(value[key]);
+	for (const key of Object.getOwnPropertySymbols(value)) result[key] = Immutable(value[key]);
+	return globalThis.Object.freeze(result);
+}
+/** Specialized deep immutable value. Applies freeze recursively to the given value */
+function Immutable(value) {
+	return IsArray$1(value) ? ImmutableArray(value) : IsDate$1(value) ? ImmutableDate(value) : IsUint8Array$1(value) ? ImmutableUint8Array(value) : IsRegExp$1(value) ? ImmutableRegExp(value) : IsObject$1(value) ? ImmutableObject(value) : value;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
+function ArrayType$1(value) {
+	return value.map((value) => Visit$3(value));
+}
+function DateType$1(value) {
+	return new Date(value.getTime());
+}
+function Uint8ArrayType$1(value) {
+	return new Uint8Array(value);
+}
+function RegExpType(value) {
+	return new RegExp(value.source, value.flags);
+}
+function ObjectType$1(value) {
+	const result = {};
+	for (const key of Object.getOwnPropertyNames(value)) result[key] = Visit$3(value[key]);
+	for (const key of Object.getOwnPropertySymbols(value)) result[key] = Visit$3(value[key]);
+	return result;
+}
+function Visit$3(value) {
+	return IsArray$1(value) ? ArrayType$1(value) : IsDate$1(value) ? DateType$1(value) : IsUint8Array$1(value) ? Uint8ArrayType$1(value) : IsRegExp$1(value) ? RegExpType(value) : IsObject$1(value) ? ObjectType$1(value) : value;
+}
+/** Clones a value */
+function Clone(value) {
+	return Visit$3(value);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/create/type.mjs
+/** Creates TypeBox schematics using the configured InstanceMode */
+function CreateType(schema, options) {
+	const result = options !== void 0 ? {
+		...options,
+		...schema
+	} : schema;
+	switch (TypeSystemPolicy.InstanceMode) {
+		case "freeze": return Immutable(result);
+		case "clone": return Clone(result);
+		default: return result;
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
+/** Symbol key applied to types */
+const Kind = Symbol.for("TypeBox.Kind");
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
+/** The base Error type thrown for all TypeBox exceptions  */
+var TypeBoxError = class extends Error {
+	constructor(message) {
+		super(message);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/never/never.mjs
+/** `[Json]` Creates a Never type */
+function Never(options) {
+	return CreateType({
+		[Kind]: "Never",
+		not: {}
+	}, options);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
+/** `[Kind-Only]` Returns true if the given value is TAny */
+function IsAny(value) {
+	return IsKindOf(value, "Any");
+}
+/** `[Kind-Only]` Returns true if the given value is TArgument */
+function IsArgument(value) {
+	return IsKindOf(value, "Argument");
+}
+/** `[Kind-Only]` Returns true if the given value is TArray */
+function IsArray(value) {
+	return IsKindOf(value, "Array");
+}
+/** `[Kind-Only]` Returns true if the given value is TAsyncIterator */
+function IsAsyncIterator(value) {
+	return IsKindOf(value, "AsyncIterator");
+}
+/** `[Kind-Only]` Returns true if the given value is TBigInt */
+function IsBigInt(value) {
+	return IsKindOf(value, "BigInt");
+}
+/** `[Kind-Only]` Returns true if the given value is TBoolean */
+function IsBoolean(value) {
+	return IsKindOf(value, "Boolean");
+}
+/** `[Kind-Only]` Returns true if the given value is TComputed */
+function IsComputed(value) {
+	return IsKindOf(value, "Computed");
+}
+/** `[Kind-Only]` Returns true if the given value is TConstructor */
+function IsConstructor(value) {
+	return IsKindOf(value, "Constructor");
+}
+/** `[Kind-Only]` Returns true if the given value is TDate */
+function IsDate(value) {
+	return IsKindOf(value, "Date");
+}
+/** `[Kind-Only]` Returns true if the given value is TFunction */
+function IsFunction(value) {
+	return IsKindOf(value, "Function");
+}
+/** `[Kind-Only]` Returns true if the given value is TInteger */
+function IsInteger(value) {
+	return IsKindOf(value, "Integer");
+}
+/** `[Kind-Only]` Returns true if the given value is TIntersect */
+function IsIntersect(value) {
+	return IsKindOf(value, "Intersect");
+}
+/** `[Kind-Only]` Returns true if the given value is TIterator */
+function IsIterator(value) {
+	return IsKindOf(value, "Iterator");
+}
+/** `[Kind-Only]` Returns true if the given value is a TKind with the given name. */
+function IsKindOf(value, kind) {
+	return IsObject$1(value) && Kind in value && value[Kind] === kind;
+}
+/** `[Kind-Only]` Returns true if the given value is TLiteral */
+function IsLiteral(value) {
+	return IsKindOf(value, "Literal");
+}
+/** `[Kind-Only]` Returns true if the given value is a TMappedKey */
+function IsMappedKey(value) {
+	return IsKindOf(value, "MappedKey");
+}
+/** `[Kind-Only]` Returns true if the given value is TMappedResult */
+function IsMappedResult(value) {
+	return IsKindOf(value, "MappedResult");
+}
+/** `[Kind-Only]` Returns true if the given value is TNever */
+function IsNever(value) {
+	return IsKindOf(value, "Never");
+}
+/** `[Kind-Only]` Returns true if the given value is TNot */
+function IsNot(value) {
+	return IsKindOf(value, "Not");
+}
+/** `[Kind-Only]` Returns true if the given value is TNull */
+function IsNull(value) {
+	return IsKindOf(value, "Null");
+}
+/** `[Kind-Only]` Returns true if the given value is TNumber */
+function IsNumber(value) {
+	return IsKindOf(value, "Number");
+}
+/** `[Kind-Only]` Returns true if the given value is TObject */
+function IsObject(value) {
+	return IsKindOf(value, "Object");
+}
+/** `[Kind-Only]` Returns true if the given value is TPromise */
+function IsPromise(value) {
+	return IsKindOf(value, "Promise");
+}
+/** `[Kind-Only]` Returns true if the given value is TRecord */
+function IsRecord(value) {
+	return IsKindOf(value, "Record");
+}
+/** `[Kind-Only]` Returns true if the given value is TRef */
+function IsRef(value) {
+	return IsKindOf(value, "Ref");
+}
+/** `[Kind-Only]` Returns true if the given value is TRegExp */
+function IsRegExp(value) {
+	return IsKindOf(value, "RegExp");
+}
+/** `[Kind-Only]` Returns true if the given value is TString */
+function IsString(value) {
+	return IsKindOf(value, "String");
+}
+/** `[Kind-Only]` Returns true if the given value is TSymbol */
+function IsSymbol(value) {
+	return IsKindOf(value, "Symbol");
+}
+/** `[Kind-Only]` Returns true if the given value is TTemplateLiteral */
+function IsTemplateLiteral(value) {
+	return IsKindOf(value, "TemplateLiteral");
+}
+/** `[Kind-Only]` Returns true if the given value is TThis */
+function IsThis(value) {
+	return IsKindOf(value, "This");
+}
+/** `[Kind-Only]` Returns true if the given value is TTuple */
+function IsTuple(value) {
+	return IsKindOf(value, "Tuple");
+}
+/** `[Kind-Only]` Returns true if the given value is TUndefined */
+function IsUndefined(value) {
+	return IsKindOf(value, "Undefined");
+}
+/** `[Kind-Only]` Returns true if the given value is TUnion */
+function IsUnion(value) {
+	return IsKindOf(value, "Union");
+}
+/** `[Kind-Only]` Returns true if the given value is TUint8Array */
+function IsUint8Array(value) {
+	return IsKindOf(value, "Uint8Array");
+}
+/** `[Kind-Only]` Returns true if the given value is TUnknown */
+function IsUnknown(value) {
+	return IsKindOf(value, "Unknown");
+}
+/** `[Kind-Only]` Returns true if the given value is a raw TUnsafe */
+function IsUnsafe(value) {
+	return IsKindOf(value, "Unsafe");
+}
+/** `[Kind-Only]` Returns true if the given value is TVoid */
+function IsVoid(value) {
+	return IsKindOf(value, "Void");
+}
+/** `[Kind-Only]` Returns true if the given value is TKind */
+function IsKind(value) {
+	return IsObject$1(value) && Kind in value && IsString$1(value[Kind]);
+}
+/** `[Kind-Only]` Returns true if the given value is TSchema */
+function IsSchema(value) {
+	return IsAny(value) || IsArgument(value) || IsArray(value) || IsBoolean(value) || IsBigInt(value) || IsAsyncIterator(value) || IsComputed(value) || IsConstructor(value) || IsDate(value) || IsFunction(value) || IsInteger(value) || IsIntersect(value) || IsIterator(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull(value) || IsNumber(value) || IsObject(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp(value) || IsString(value) || IsSymbol(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined(value) || IsUnion(value) || IsUint8Array(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/sets/set.mjs
+/** Returns the Intersect of the given sets */
+function SetIntersect(T, S) {
+	return T.filter((L) => S.includes(L));
+}
+function SetIntersectManyResolve(T, Init) {
+	return T.reduce((Acc, L) => {
+		return SetIntersect(Acc, L);
+	}, Init);
+}
+function SetIntersectMany(T) {
+	return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
+}
+/** Returns the Union of multiple sets */
+function SetUnionMany(T) {
+	const Acc = [];
+	for (const L of T) Acc.push(...L);
+	return Acc;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.mjs
+function FromRest(types) {
+	const result = [];
+	for (const L of types) result.push(KeyOfPropertyKeys(L));
+	return result;
+}
+function FromIntersect$2(types) {
+	return SetUnionMany(FromRest(types));
+}
+function FromUnion$2(types) {
+	return SetIntersectMany(FromRest(types));
+}
+function FromTuple$2(types) {
+	return types.map((_, indexer) => indexer.toString());
+}
+function FromArray$2(_) {
+	return ["[number]"];
+}
+function FromProperties(T) {
+	return globalThis.Object.getOwnPropertyNames(T);
+}
+function FromPatternProperties(patternProperties) {
+	if (!includePatternProperties) return [];
+	return globalThis.Object.getOwnPropertyNames(patternProperties).map((key) => {
+		return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
+	});
+}
+/** Returns a tuple of PropertyKeys derived from the given TSchema. */
+function KeyOfPropertyKeys(type) {
+	return IsIntersect(type) ? FromIntersect$2(type.allOf) : IsUnion(type) ? FromUnion$2(type.anyOf) : IsTuple(type) ? FromTuple$2(type.items ?? []) : IsArray(type) ? FromArray$2(type.items) : IsObject(type) ? FromProperties(type.properties) : IsRecord(type) ? FromPatternProperties(type.patternProperties) : [];
+}
+let includePatternProperties = false;
+/** Returns a regular expression pattern derived from the given TSchema */
+function KeyOfPattern(schema) {
+	includePatternProperties = true;
+	const keys = KeyOfPropertyKeys(schema);
+	includePatternProperties = false;
+	return `^(${keys.map((key) => `(${key})`).join("|")})$`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/type/extends/extends-undefined.mjs
+/** Fast undefined check used for properties of type undefined */
+function Intersect(schema) {
+	return schema.allOf.every((schema) => ExtendsUndefinedCheck(schema));
+}
+function Union(schema) {
+	return schema.anyOf.some((schema) => ExtendsUndefinedCheck(schema));
+}
+function Not(schema) {
+	return !ExtendsUndefinedCheck(schema.not);
+}
+/** Fast undefined check used for properties of type undefined */
+function ExtendsUndefinedCheck(schema) {
+	return schema[Kind] === "Intersect" ? Intersect(schema) : schema[Kind] === "Union" ? Union(schema) : schema[Kind] === "Not" ? Not(schema) : schema[Kind] === "Undefined" ? true : false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/errors/function.mjs
+/** Creates an error message using en-US as the default locale */
+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";
+	}
+}
+/** Manages error message providers */
+let errorFunction = DefaultErrorFunction;
+/** Gets the error function used to generate error messages */
+function GetErrorFunction() {
+	return errorFunction;
+}
+//#endregion
+//#region ../../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((target) => target.$id === schema.$ref);
+	if (target === void 0) throw new TypeDereferenceError(schema);
+	return Deref(target, references);
+}
+/** `[Internal]` Pushes a schema onto references if the schema has an $id and does not exist on references */
+function Pushref(schema, references) {
+	if (!IsString$2(schema.$id) || references.some((target) => target.$id === schema.$id)) return references;
+	references.push(schema);
+	return references;
+}
+/** `[Internal]` Dereferences a schema from the references array or throws if not found */
+function Deref(schema, references) {
+	return schema[Kind] === "This" || schema[Kind] === "Ref" ? Resolve(schema, references) : schema;
+}
+//#endregion
+//#region ../../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(ByteMarker) {
+	ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
+	ByteMarker[ByteMarker["Null"] = 1] = "Null";
+	ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+	ByteMarker[ByteMarker["Number"] = 3] = "Number";
+	ByteMarker[ByteMarker["String"] = 4] = "String";
+	ByteMarker[ByteMarker["Object"] = 5] = "Object";
+	ByteMarker[ByteMarker["Array"] = 6] = "Array";
+	ByteMarker[ByteMarker["Date"] = 7] = "Date";
+	ByteMarker[ByteMarker["Uint8Array"] = 8] = "Uint8Array";
+	ByteMarker[ByteMarker["Symbol"] = 9] = "Symbol";
+	ByteMarker[ByteMarker["BigInt"] = 10] = "BigInt";
+})(ByteMarker || (ByteMarker = {}));
+let Accumulator = BigInt("14695981039346656037");
+const [Prime, Size] = [BigInt("1099511628211"), BigInt("18446744073709551616")];
+const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
+const F64 = /* @__PURE__ */ new Float64Array(1);
+const F64In = new DataView(F64.buffer);
+const 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$2(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$2(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$2(key);
+		Visit$2(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$2(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$2(value) {
+	if (IsArray$2(value)) return ArrayType(value);
+	if (IsBoolean$1(value)) return BooleanType(value);
+	if (IsBigInt$1(value)) return BigIntType(value);
+	if (IsDate$2(value)) return DateType(value);
+	if (IsNull$1(value)) return NullType(value);
+	if (IsNumber$1(value)) return NumberType(value);
+	if (IsObject$2(value)) return ObjectType(value);
+	if (IsString$2(value)) return StringType(value);
+	if (IsSymbol$1(value)) return SymbolType(value);
+	if (IsUint8Array$2(value)) return Uint8ArrayType(value);
+	if (IsUndefined$1(value)) return UndefinedType(value);
+	throw new ValueHashError(value);
+}
+function FNV1A64(byte) {
+	Accumulator = Accumulator ^ Bytes[byte];
+	Accumulator = Accumulator * Prime % Size;
+}
+/** Creates a FNV1A-64 non cryptographic hash of the given value */
+function Hash(value) {
+	Accumulator = BigInt("14695981039346656037");
+	Visit$2(value);
+	return Accumulator;
+}
+//#endregion
+//#region ../../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$1(value) {
+	return value !== void 0;
+}
+function FromAny$1(schema, references, value) {
+	return true;
+}
+function FromArgument$1(schema, references, value) {
+	return true;
+}
+function FromArray$1(schema, references, value) {
+	if (!IsArray$2(value)) return false;
+	if (IsDefined$1(schema.minItems) && !(value.length >= schema.minItems)) return false;
+	if (IsDefined$1(schema.maxItems) && !(value.length <= schema.maxItems)) return false;
+	for (const element of value) if (!Visit$1(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$1(schema.contains) || IsNumber$1(schema.minContains) || IsNumber$1(schema.maxContains))) return true;
+	const containsSchema = IsDefined$1(schema.contains) ? schema.contains : Never();
+	const containsCount = value.reduce((acc, value) => Visit$1(containsSchema, references, value) ? acc + 1 : acc, 0);
+	if (containsCount === 0) return false;
+	if (IsNumber$1(schema.minContains) && containsCount < schema.minContains) return false;
+	if (IsNumber$1(schema.maxContains) && containsCount > schema.maxContains) return false;
+	return true;
+}
+function FromAsyncIterator$1(schema, references, value) {
+	return IsAsyncIterator$1(value);
+}
+function FromBigInt$1(schema, references, value) {
+	if (!IsBigInt$1(value)) return false;
+	if (IsDefined$1(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) return false;
+	if (IsDefined$1(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) return false;
+	if (IsDefined$1(schema.maximum) && !(value <= schema.maximum)) return false;
+	if (IsDefined$1(schema.minimum) && !(value >= schema.minimum)) return false;
+	if (IsDefined$1(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) return false;
+	return true;
+}
+function FromBoolean$1(schema, references, value) {
+	return IsBoolean$1(value);
+}
+function FromConstructor$1(schema, references, value) {
+	return Visit$1(schema.returns, references, value.prototype);
+}
+function FromDate$1(schema, references, value) {
+	if (!IsDate$2(value)) return false;
+	if (IsDefined$1(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) return false;
+	if (IsDefined$1(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) return false;
+	if (IsDefined$1(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) return false;
+	if (IsDefined$1(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) return false;
+	if (IsDefined$1(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) return false;
+	return true;
+}
+function FromFunction$1(schema, references, value) {
+	return IsFunction$1(value);
+}
+function FromImport$1(schema, references, value) {
+	const definitions = globalThis.Object.values(schema.$defs);
+	const target = schema.$defs[schema.$ref];
+	return Visit$1(target, [...references, ...definitions], value);
+}
+function FromInteger$1(schema, references, value) {
+	if (!IsInteger$1(value)) return false;
+	if (IsDefined$1(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) return false;
+	if (IsDefined$1(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) return false;
+	if (IsDefined$1(schema.maximum) && !(value <= schema.maximum)) return false;
+	if (IsDefined$1(schema.minimum) && !(value >= schema.minimum)) return false;
+	if (IsDefined$1(schema.multipleOf) && !(value % schema.multipleOf === 0)) return false;
+	return true;
+}
+function FromIntersect$1(schema, references, value) {
+	const check1 = schema.allOf.every((schema) => Visit$1(schema, 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) || Visit$1(schema.unevaluatedProperties, references, value[key]));
+		return check1 && check2;
+	} else return check1;
+}
+function FromIterator$1(schema, references, value) {
+	return IsIterator$1(value);
+}
+function FromLiteral$1(schema, references, value) {
+	return value === schema.const;
+}
+function FromNever$1(schema, references, value) {
+	return false;
+}
+function FromNot$1(schema, references, value) {
+	return !Visit$1(schema.not, references, value);
+}
+function FromNull$1(schema, references, value) {
+	return IsNull$1(value);
+}
+function FromNumber$1(schema, references, value) {
+	if (!TypeSystemPolicy.IsNumberLike(value)) return false;
+	if (IsDefined$1(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) return false;
+	if (IsDefined$1(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) return false;
+	if (IsDefined$1(schema.minimum) && !(value >= schema.minimum)) return false;
+	if (IsDefined$1(schema.maximum) && !(value <= schema.maximum)) return false;
+	if (IsDefined$1(schema.multipleOf) && !(value % schema.multipleOf === 0)) return false;
+	return true;
+}
+function FromObject$1(schema, references, value) {
+	if (!TypeSystemPolicy.IsObjectLike(value)) return false;
+	if (IsDefined$1(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) return false;
+	if (IsDefined$1(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 (!Visit$1(property, references, value[knownKey])) return false;
+			if ((ExtendsUndefinedCheck(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) return false;
+		} else if (TypeSystemPolicy.IsExactOptionalProperty(value, knownKey) && !Visit$1(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") return Object.getOwnPropertyNames(value).every((key) => knownKeys.includes(key) || Visit$1(schema.additionalProperties, references, value[key]));
+	else return true;
+}
+function FromPromise$1(schema, references, value) {
+	return IsPromise$1(value);
+}
+function FromRecord$1(schema, references, value) {
+	if (!TypeSystemPolicy.IsRecordLike(value)) return false;
+	if (IsDefined$1(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) return false;
+	if (IsDefined$1(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, value]) => {
+		return regex.test(key) ? Visit$1(patternSchema, references, value) : true;
+	});
+	const check2 = typeof schema.additionalProperties === "object" ? Object.entries(value).every(([key, value]) => {
+		return !regex.test(key) ? Visit$1(schema.additionalProperties, references, value) : true;
+	}) : true;
+	const check3 = schema.additionalProperties === false ? Object.getOwnPropertyNames(value).every((key) => {
+		return regex.test(key);
+	}) : true;
+	return check1 && check2 && check3;
+}
+function FromRef$1(schema, references, value) {
+	return Visit$1(Deref(schema, references), references, value);
+}
+function FromRegExp$1(schema, references, value) {
+	const regex = new RegExp(schema.source, schema.flags);
+	if (IsDefined$1(schema.minLength)) {
+		if (!(value.length >= schema.minLength)) return false;
+	}
+	if (IsDefined$1(schema.maxLength)) {
+		if (!(value.length <= schema.maxLength)) return false;
+	}
+	return regex.test(value);
+}
+function FromString$1(schema, references, value) {
+	if (!IsString$2(value)) return false;
+	if (IsDefined$1(schema.minLength)) {
+		if (!(value.length >= schema.minLength)) return false;
+	}
+	if (IsDefined$1(schema.maxLength)) {
+		if (!(value.length <= schema.maxLength)) return false;
+	}
+	if (IsDefined$1(schema.pattern)) {
+		if (!new RegExp(schema.pattern).test(value)) return false;
+	}
+	if (IsDefined$1(schema.format)) {
+		if (!Has$1(schema.format)) return false;
+		return Get$1(schema.format)(value);
+	}
+	return true;
+}
+function FromSymbol$1(schema, references, value) {
+	return IsSymbol$1(value);
+}
+function FromTemplateLiteral$1(schema, references, value) {
+	return IsString$2(value) && new RegExp(schema.pattern).test(value);
+}
+function FromThis$1(schema, references, value) {
+	return Visit$1(Deref(schema, references), references, value);
+}
+function FromTuple$1(schema, references, value) {
+	if (!IsArray$2(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 (!Visit$1(schema.items[i], references, value[i])) return false;
+	return true;
+}
+function FromUndefined$1(schema, references, value) {
+	return IsUndefined$1(value);
+}
+function FromUnion$1(schema, references, value) {
+	return schema.anyOf.some((inner) => Visit$1(inner, references, value));
+}
+function FromUint8Array$1(schema, references, value) {
+	if (!IsUint8Array$2(value)) return false;
+	if (IsDefined$1(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) return false;
+	if (IsDefined$1(schema.minByteLength) && !(value.length >= schema.minByteLength)) return false;
+	return true;
+}
+function FromUnknown$1(schema, references, value) {
+	return true;
+}
+function FromVoid$1(schema, references, value) {
+	return TypeSystemPolicy.IsVoidLike(value);
+}
+function FromKind$1(schema, references, value) {
+	if (!Has(schema[Kind])) return false;
+	return Get(schema[Kind])(schema, value);
+}
+function Visit$1(schema, references, value) {
+	const references_ = IsDefined$1(schema.$id) ? Pushref(schema, references) : references;
+	const schema_ = schema;
+	switch (schema_[Kind]) {
+		case "Any": return FromAny$1(schema_, references_, value);
+		case "Argument": return FromArgument$1(schema_, references_, value);
+		case "Array": return FromArray$1(schema_, references_, value);
+		case "AsyncIterator": return FromAsyncIterator$1(schema_, references_, value);
+		case "BigInt": return FromBigInt$1(schema_, references_, value);
+		case "Boolean": return FromBoolean$1(schema_, references_, value);
+		case "Constructor": return FromConstructor$1(schema_, references_, value);
+		case "Date": return FromDate$1(schema_, references_, value);
+		case "Function": return FromFunction$1(schema_, references_, value);
+		case "Import": return FromImport$1(schema_, references_, value);
+		case "Integer": return FromInteger$1(schema_, references_, value);
+		case "Intersect": return FromIntersect$1(schema_, references_, value);
+		case "Iterator": return FromIterator$1(schema_, references_, value);
+		case "Literal": return FromLiteral$1(schema_, references_, value);
+		case "Never": return FromNever$1(schema_, references_, value);
+		case "Not": return FromNot$1(schema_, references_, value);
+		case "Null": return FromNull$1(schema_, references_, value);
+		case "Number": return FromNumber$1(schema_, references_, value);
+		case "Object": return FromObject$1(schema_, references_, value);
+		case "Promise": return FromPromise$1(schema_, references_, value);
+		case "Record": return FromRecord$1(schema_, references_, value);
+		case "Ref": return FromRef$1(schema_, references_, value);
+		case "RegExp": return FromRegExp$1(schema_, references_, value);
+		case "String": return FromString$1(schema_, references_, value);
+		case "Symbol": return FromSymbol$1(schema_, references_, value);
+		case "TemplateLiteral": return FromTemplateLiteral$1(schema_, references_, value);
+		case "This": return FromThis$1(schema_, references_, value);
+		case "Tuple": return FromTuple$1(schema_, references_, value);
+		case "Undefined": return FromUndefined$1(schema_, references_, value);
+		case "Union": return FromUnion$1(schema_, references_, value);
+		case "Uint8Array": return FromUint8Array$1(schema_, references_, value);
+		case "Unknown": return FromUnknown$1(schema_, references_, value);
+		case "Void": return FromVoid$1(schema_, references_, value);
+		default:
+			if (!Has(schema_[Kind])) throw new ValueCheckUnknownTypeError(schema_);
+			return FromKind$1(schema_, references_, value);
+	}
+}
+/** Returns true if the value matches the given type. */
+function Check(...args) {
+	return args.length === 3 ? Visit$1(args[0], args[1], args[2]) : Visit$1(args[0], [], args[1]);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@sinclair+typebox@0.34.52/node_modules/@sinclair/typebox/build/esm/errors/errors.mjs
+var ValueErrorType;
+(function(ValueErrorType) {
+	ValueErrorType[ValueErrorType["ArrayContains"] = 0] = "ArrayContains";
+	ValueErrorType[ValueErrorType["ArrayMaxContains"] = 1] = "ArrayMaxContains";
+	ValueErrorType[ValueErrorType["ArrayMaxItems"] = 2] = "ArrayMaxItems";
+	ValueErrorType[ValueErrorType["ArrayMinContains"] = 3] = "ArrayMinContains";
+	ValueErrorType[ValueErrorType["ArrayMinItems"] = 4] = "ArrayMinItems";
+	ValueErrorType[ValueErrorType["ArrayUniqueItems"] = 5] = "ArrayUniqueItems";
+	ValueErrorType[ValueErrorType["Array"] = 6] = "Array";
+	ValueErrorType[ValueErrorType["AsyncIterator"] = 7] = "AsyncIterator";
+	ValueErrorType[ValueErrorType["BigIntExclusiveMaximum"] = 8] = "BigIntExclusiveMaximum";
+	ValueErrorType[ValueErrorType["BigIntExclusiveMinimum"] = 9] = "BigIntExclusiveMinimum";
+	ValueErrorType[ValueErrorType["BigIntMaximum"] = 10] = "BigIntMaximum";
+	ValueErrorType[ValueErrorType["BigIntMinimum"] = 11] = "BigIntMinimum";
+	ValueErrorType[ValueErrorType["BigIntMultipleOf"] = 12] = "BigIntMultipleOf";
+	ValueErrorType[ValueErrorType["BigInt"] = 13] = "BigInt";
+	ValueErrorType[ValueErrorType["Boolean"] = 14] = "Boolean";
+	ValueErrorType[ValueErrorType["DateExclusiveMaximumTimestamp"] = 15] = "DateExclusiveMaximumTimestamp";
+	ValueErrorType[ValueErrorType["DateExclusiveMinimumTimestamp"] = 16] = "DateExclusiveMinimumTimestamp";
+	ValueErrorType[ValueErrorType["DateMaximumTimestamp"] = 17] = "DateMaximumTimestamp";
+	ValueErrorType[ValueErrorType["DateMinimumTimestamp"] = 18] = "DateMinimumTimestamp";
+	ValueErrorType[ValueErrorType["DateMultipleOfTimestamp"] = 19] = "DateMultipleOfTimestamp";
+	ValueErrorType[ValueErrorType["Date"] = 20] = "Date";
+	ValueErrorType[ValueErrorType["Function"] = 21] = "Function";
+	ValueErrorType[ValueErrorType["IntegerExclusiveMaximum"] = 22] = "IntegerExclusiveMaximum";
+	ValueErrorType[ValueErrorType["IntegerExclusiveMinimum"] = 23] = "IntegerExclusiveMinimum";
+	ValueErrorType[ValueErrorType["IntegerMaximum"] = 24] = "IntegerMaximum";
+	ValueErrorType[ValueErrorType["IntegerMinimum"] = 25] = "IntegerMinimum";
+	ValueErrorType[ValueErrorType["IntegerMultipleOf"] = 26] = "IntegerMultipleOf";
+	ValueErrorType[ValueErrorType["Integer"] = 27] = "Integer";
+	ValueErrorType[ValueErrorType["IntersectUnevaluatedProperties"] = 28] = "IntersectUnevaluatedProperties";
+	ValueErrorType[ValueErrorType["Intersect"] = 29] = "Intersect";
+	ValueErrorType[ValueErrorType["Iterator"] = 30] = "Iterator";
+	ValueErrorType[ValueErrorType["Kind"] = 31] = "Kind";
+	ValueErrorType[ValueErrorType["Literal"] = 32] = "Literal";
+	ValueErrorType[ValueErrorType["Never"] = 33] = "Never";
+	ValueErrorType[ValueErrorType["Not"] = 34] = "Not";
+	ValueErrorType[ValueErrorType["Null"] = 35] = "Null";
+	ValueErrorType[ValueErrorType["NumberExclusiveMaximum"] = 36] = "NumberExclusiveMaximum";
+	ValueErrorType[ValueErrorType["NumberExclusiveMinimum"] = 37] = "NumberExclusiveMinimum";
+	ValueErrorType[ValueErrorType["NumberMaximum"] = 38] = "NumberMaximum";
+	ValueErrorType[ValueErrorType["NumberMinimum"] = 39] = "NumberMinimum";
+	ValueErrorType[ValueErrorType["NumberMultipleOf"] = 40] = "NumberMultipleOf";
+	ValueErrorType[ValueErrorType["Number"] = 41] = "Number";
+	ValueErrorType[ValueErrorType["ObjectAdditionalProperties"] = 42] = "ObjectAdditionalProperties";
+	ValueErrorType[ValueErrorType["ObjectMaxProperties"] = 43] = "ObjectMaxProperties";
+	ValueErrorType[ValueErrorType["ObjectMinProperties"] = 44] = "ObjectMinProperties";
+	ValueErrorType[ValueErrorType["ObjectRequiredProperty"] = 45] = "ObjectRequiredProperty";
+	ValueErrorType[ValueErrorType["Object"] = 46] = "Object";
+	ValueErrorType[ValueErrorType["Promise"] = 47] = "Promise";
+	ValueErrorType[ValueErrorType["RegExp"] = 48] = "RegExp";
+	ValueErrorType[ValueErrorType["StringFormatUnknown"] = 49] = "StringFormatUnknown";
+	ValueErrorType[ValueErrorType["StringFormat"] = 50] = "StringFormat";
+	ValueErrorType[ValueErrorType["StringMaxLength"] = 51] = "StringMaxLength";
+	ValueErrorType[ValueErrorType["StringMinLength"] = 52] = "StringMinLength";
+	ValueErrorType[ValueErrorType["StringPattern"] = 53] = "StringPattern";
+	ValueErrorType[ValueErrorType["String"] = 54] = "String";
+	ValueErrorType[ValueErrorType["Symbol"] = 55] = "Symbol";
+	ValueErrorType[ValueErrorType["TupleLength"] = 56] = "TupleLength";
+	ValueErrorType[ValueErrorType["Tuple"] = 57] = "Tuple";
+	ValueErrorType[ValueErrorType["Uint8ArrayMaxByteLength"] = 58] = "Uint8ArrayMaxByteLength";
+	ValueErrorType[ValueErrorType["Uint8ArrayMinByteLength"] = 59] = "Uint8ArrayMinByteLength";
+	ValueErrorType[ValueErrorType["Uint8Array"] = 60] = "Uint8Array";
+	ValueErrorType[ValueErrorType["Undefined"] = 61] = "Undefined";
+	ValueErrorType[ValueErrorType["Union"] = 62] = "Union";
+	ValueErrorType[ValueErrorType["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 IsDefined(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* FromAny(schema, references, path, value) {}
+function* FromArgument(schema, references, path, value) {}
+function* FromArray(schema, references, path, value) {
+	if (!IsArray$2(value)) return yield Create(ValueErrorType.Array, schema, path, value);
+	if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) yield Create(ValueErrorType.ArrayMinItems, schema, path, value);
+	if (IsDefined(schema.maxItems) && !(value.length <= schema.maxItems)) yield Create(ValueErrorType.ArrayMaxItems, schema, path, value);
+	for (let i = 0; i < value.length; i++) yield* Visit(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 (!(IsDefined(schema.contains) || IsDefined(schema.minContains) || IsDefined(schema.maxContains))) return;
+	const containsSchema = IsDefined(schema.contains) ? schema.contains : Never();
+	const containsCount = value.reduce((acc, value, index) => Visit(containsSchema, references, `${path}${index}`, value).next().done === true ? acc + 1 : acc, 0);
+	if (containsCount === 0) yield Create(ValueErrorType.ArrayContains, schema, path, value);
+	if (IsNumber$1(schema.minContains) && containsCount < schema.minContains) yield Create(ValueErrorType.ArrayMinContains, schema, path, value);
+	if (IsNumber$1(schema.maxContains) && containsCount > schema.maxContains) yield Create(ValueErrorType.ArrayMaxContains, schema, path, value);
+}
+function* FromAsyncIterator(schema, references, path, value) {
+	if (!IsAsyncIterator$1(value)) yield Create(ValueErrorType.AsyncIterator, schema, path, value);
+}
+function* FromBigInt(schema, references, path, value) {
+	if (!IsBigInt$1(value)) return yield Create(ValueErrorType.BigInt, schema, path, value);
+	if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) yield Create(ValueErrorType.BigIntExclusiveMaximum, schema, path, value);
+	if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) yield Create(ValueErrorType.BigIntExclusiveMinimum, schema, path, value);
+	if (IsDefined(schema.maximum) && !(value <= schema.maximum)) yield Create(ValueErrorType.BigIntMaximum, schema, path, value);
+	if (IsDefined(schema.minimum) && !(value >= schema.minimum)) yield Create(ValueErrorType.BigIntMinimum, schema, path, value);
+	if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === BigInt(0))) yield Create(ValueErrorType.BigIntMultipleOf, schema, path, value);
+}
+function* FromBoolean(schema, references, path, value) {
+	if (!IsBoolean$1(value)) yield Create(ValueErrorType.Boolean, schema, path, value);
+}
+function* FromConstructor(schema, references, path, value) {
+	yield* Visit(schema.returns, references, path, value.prototype);
+}
+function* FromDate(schema, references, path, value) {
+	if (!IsDate$2(value)) return yield Create(ValueErrorType.Date, schema, path, value);
+	if (IsDefined(schema.exclusiveMaximumTimestamp) && !(value.getTime() < schema.exclusiveMaximumTimestamp)) yield Create(ValueErrorType.DateExclusiveMaximumTimestamp, schema, path, value);
+	if (IsDefined(schema.exclusiveMinimumTimestamp) && !(value.getTime() > schema.exclusiveMinimumTimestamp)) yield Create(ValueErrorType.DateExclusiveMinimumTimestamp, schema, path, value);
+	if (IsDefined(schema.maximumTimestamp) && !(value.getTime() <= schema.maximumTimestamp)) yield Create(ValueErrorType.DateMaximumTimestamp, schema, path, value);
+	if (IsDefined(schema.minimumTimestamp) && !(value.getTime() >= schema.minimumTimestamp)) yield Create(ValueErrorType.DateMinimumTimestamp, schema, path, value);
+	if (IsDefined(schema.multipleOfTimestamp) && !(value.getTime() % schema.multipleOfTimestamp === 0)) yield Create(ValueErrorType.DateMultipleOfTimestamp, schema, path, value);
+}
+function* FromFunction(schema, references, path, value) {
+	if (!IsFunction$1(value)) yield Create(ValueErrorType.Function, schema, path, value);
+}
+function* FromImport(schema, references, path, value) {
+	const definitions = globalThis.Object.values(schema.$defs);
+	const target = schema.$defs[schema.$ref];
+	yield* Visit(target, [...references, ...definitions], path, value);
+}
+function* FromInteger(schema, references, path, value) {
+	if (!IsInteger$1(value)) return yield Create(ValueErrorType.Integer, schema, path, value);
+	if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) yield Create(ValueErrorType.IntegerExclusiveMaximum, schema, path, value);
+	if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) yield Create(ValueErrorType.IntegerExclusiveMinimum, schema, path, value);
+	if (IsDefined(schema.maximum) && !(value <= schema.maximum)) yield Create(ValueErrorType.IntegerMaximum, schema, path, value);
+	if (IsDefined(schema.minimum) && !(value >= schema.minimum)) yield Create(ValueErrorType.IntegerMinimum, schema, path, value);
+	if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) yield Create(ValueErrorType.IntegerMultipleOf, schema, path, value);
+}
+function* FromIntersect(schema, references, path, value) {
+	let hasError = false;
+	for (const inner of schema.allOf) for (const error of Visit(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 = Visit(schema.unevaluatedProperties, references, `${path}/${valueKey}`, value[valueKey]).next();
+			if (!next.done) yield next.value;
+		}
+	}
+}
+function* FromIterator(schema, references, path, value) {
+	if (!IsIterator$1(value)) yield Create(ValueErrorType.Iterator, schema, path, value);
+}
+function* FromLiteral(schema, references, path, value) {
+	if (!(value === schema.const)) yield Create(ValueErrorType.Literal, schema, path, value);
+}
+function* FromNever(schema, references, path, value) {
+	yield Create(ValueErrorType.Never, schema, path, value);
+}
+function* FromNot(schema, references, path, value) {
+	if (Visit(schema.not, references, path, value).next().done === true) yield Create(ValueErrorType.Not, schema, path, value);
+}
+function* FromNull(schema, references, path, value) {
+	if (!IsNull$1(value)) yield Create(ValueErrorType.Null, schema, path, value);
+}
+function* FromNumber(schema, references, path, value) {
+	if (!TypeSystemPolicy.IsNumberLike(value)) return yield Create(ValueErrorType.Number, schema, path, value);
+	if (IsDefined(schema.exclusiveMaximum) && !(value < schema.exclusiveMaximum)) yield Create(ValueErrorType.NumberExclusiveMaximum, schema, path, value);
+	if (IsDefined(schema.exclusiveMinimum) && !(value > schema.exclusiveMinimum)) yield Create(ValueErrorType.NumberExclusiveMinimum, schema, path, value);
+	if (IsDefined(schema.maximum) && !(value <= schema.maximum)) yield Create(ValueErrorType.NumberMaximum, schema, path, value);
+	if (IsDefined(schema.minimum) && !(value >= schema.minimum)) yield Create(ValueErrorType.NumberMinimum, schema, path, value);
+	if (IsDefined(schema.multipleOf) && !(value % schema.multipleOf === 0)) yield Create(ValueErrorType.NumberMultipleOf, schema, path, value);
+}
+function* FromObject(schema, references, path, value) {
+	if (!TypeSystemPolicy.IsObjectLike(value)) return yield Create(ValueErrorType.Object, schema, path, value);
+	if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) yield Create(ValueErrorType.ObjectMinProperties, schema, path, value);
+	if (IsDefined(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* Visit(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* Visit(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* Visit(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey]);
+	}
+}
+function* FromPromise(schema, references, path, value) {
+	if (!IsPromise$1(value)) yield Create(ValueErrorType.Promise, schema, path, value);
+}
+function* FromRecord(schema, references, path, value) {
+	if (!TypeSystemPolicy.IsRecordLike(value)) return yield Create(ValueErrorType.Object, schema, path, value);
+	if (IsDefined(schema.minProperties) && !(Object.getOwnPropertyNames(value).length >= schema.minProperties)) yield Create(ValueErrorType.ObjectMinProperties, schema, path, value);
+	if (IsDefined(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* Visit(patternSchema, references, `${path}/${EscapeKey(propertyKey)}`, propertyValue);
+	if (typeof schema.additionalProperties === "object") {
+		for (const [propertyKey, propertyValue] of Object.entries(value)) if (!regex.test(propertyKey)) yield* Visit(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* FromRef(schema, references, path, value) {
+	yield* Visit(Deref(schema, references), references, path, value);
+}
+function* FromRegExp(schema, references, path, value) {
+	if (!IsString$2(value)) return yield Create(ValueErrorType.String, schema, path, value);
+	if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) yield Create(ValueErrorType.StringMinLength, schema, path, value);
+	if (IsDefined(schema.maxLength) && !(value.length <= schema.maxLength)) yield Create(ValueErrorType.StringMaxLength, schema, path, value);
+	if (!new RegExp(schema.source, schema.flags).test(value)) return yield Create(ValueErrorType.RegExp, schema, path, value);
+}
+function* FromString(schema, references, path, value) {
+	if (!IsString$2(value)) return yield Create(ValueErrorType.String, schema, path, value);
+	if (IsDefined(schema.minLength) && !(value.length >= schema.minLength)) yield Create(ValueErrorType.StringMinLength, schema, path, value);
+	if (IsDefined(schema.maxLength) && !(value.length <= schema.maxLength)) yield Create(ValueErrorType.StringMaxLength, schema, path, value);
+	if (IsString$2(schema.pattern)) {
+		if (!new RegExp(schema.pattern).test(value)) yield Create(ValueErrorType.StringPattern, schema, path, value);
+	}
+	if (IsString$2(schema.format)) {
+		if (!Has$1(schema.format)) yield Create(ValueErrorType.StringFormatUnknown, schema, path, value);
+		else if (!Get$1(schema.format)(value)) yield Create(ValueErrorType.StringFormat, schema, path, value);
+	}
+}
+function* FromSymbol(schema, references, path, value) {
+	if (!IsSymbol$1(value)) yield Create(ValueErrorType.Symbol, schema, path, value);
+}
+function* FromTemplateLiteral(schema, references, path, value) {
+	if (!IsString$2(value)) return yield Create(ValueErrorType.String, schema, path, value);
+	if (!new RegExp(schema.pattern).test(value)) yield Create(ValueErrorType.StringPattern, schema, path, value);
+}
+function* FromThis(schema, references, path, value) {
+	yield* Visit(Deref(schema, references), references, path, value);
+}
+function* FromTuple(schema, references, path, value) {
+	if (!IsArray$2(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* Visit(schema.items[i], references, `${path}/${i}`, value[i]);
+}
+function* FromUndefined(schema, references, path, value) {
+	if (!IsUndefined$1(value)) yield Create(ValueErrorType.Undefined, schema, path, value);
+}
+function* FromUnion(schema, references, path, value) {
+	if (Check(schema, references, value)) return;
+	const errors = schema.anyOf.map((variant) => new ValueErrorIterator(Visit(variant, references, path, value)));
+	yield Create(ValueErrorType.Union, schema, path, value, errors);
+}
+function* FromUint8Array(schema, references, path, value) {
+	if (!IsUint8Array$2(value)) return yield Create(ValueErrorType.Uint8Array, schema, path, value);
+	if (IsDefined(schema.maxByteLength) && !(value.length <= schema.maxByteLength)) yield Create(ValueErrorType.Uint8ArrayMaxByteLength, schema, path, value);
+	if (IsDefined(schema.minByteLength) && !(value.length >= schema.minByteLength)) yield Create(ValueErrorType.Uint8ArrayMinByteLength, schema, path, value);
+}
+function* FromUnknown(schema, references, path, value) {}
+function* FromVoid(schema, references, path, value) {
+	if (!TypeSystemPolicy.IsVoidLike(value)) yield Create(ValueErrorType.Void, schema, path, value);
+}
+function* FromKind(schema, references, path, value) {
+	if (!Get(schema[Kind])(schema, value)) yield Create(ValueErrorType.Kind, schema, path, value);
+}
+function* Visit(schema, references, path, value) {
+	const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
+	const schema_ = schema;
+	switch (schema_[Kind]) {
+		case "Any": return yield* FromAny(schema_, references_, path, value);
+		case "Argument": return yield* FromArgument(schema_, references_, path, value);
+		case "Array": return yield* FromArray(schema_, references_, path, value);
+		case "AsyncIterator": return yield* FromAsyncIterator(schema_, references_, path, value);
+		case "BigInt": return yield* FromBigInt(schema_, references_, path, value);
+		case "Boolean": return yield* FromBoolean(schema_, references_, path, value);
+		case "Constructor": return yield* FromConstructor(schema_, references_, path, value);
+		case "Date": return yield* FromDate(schema_, references_, path, value);
+		case "Function": return yield* FromFunction(schema_, references_, path, value);
+		case "Import": return yield* FromImport(schema_, references_, path, value);
+		case "Integer": return yield* FromInteger(schema_, references_, path, value);
+		case "Intersect": return yield* FromIntersect(schema_, references_, path, value);
+		case "Iterator": return yield* FromIterator(schema_, references_, path, value);
+		case "Literal": return yield* FromLiteral(schema_, references_, path, value);
+		case "Never": return yield* FromNever(schema_, references_, path, value);
+		case "Not": return yield* FromNot(schema_, references_, path, value);
+		case "Null": return yield* FromNull(schema_, references_, path, value);
+		case "Number": return yield* FromNumber(schema_, references_, path, value);
+		case "Object": return yield* FromObject(schema_, references_, path, value);
+		case "Promise": return yield* FromPromise(schema_, references_, path, value);
+		case "Record": return yield* FromRecord(schema_, references_, path, value);
+		case "Ref": return yield* FromRef(schema_, references_, path, value);
+		case "RegExp": return yield* FromRegExp(schema_, references_, path, value);
+		case "String": return yield* FromString(schema_, references_, path, value);
+		case "Symbol": return yield* FromSymbol(schema_, references_, path, value);
+		case "TemplateLiteral": return yield* FromTemplateLiteral(schema_, references_, path, value);
+		case "This": return yield* FromThis(schema_, references_, path, value);
+		case "Tuple": return yield* FromTuple(schema_, references_, path, value);
+		case "Undefined": return yield* FromUndefined(schema_, references_, path, value);
+		case "Union": return yield* FromUnion(schema_, references_, path, value);
+		case "Uint8Array": return yield* FromUint8Array(schema_, references_, path, value);
+		case "Unknown": return yield* FromUnknown(schema_, references_, path, value);
+		case "Void": return yield* FromVoid(schema_, references_, path, value);
+		default:
+			if (!Has(schema_[Kind])) throw new ValueErrorsUnknownTypeError(schema);
+			return yield* FromKind(schema_, references_, path, value);
+	}
+}
+/** Returns an iterator for each error in this value. */
+function Errors(...args) {
+	return new ValueErrorIterator(args.length === 3 ? Visit(args[0], args[1], "", args[2]) : Visit(args[0], [], "", args[1]));
+}
+//#endregion
+//#region src/reference-adapter.ts
+function referenceAdapter() {
+	const adapter = {};
+	for (const entry of Object.values(PROFILES)) {
+		adapter[`${entry.literal}#digest.envelope`] = (bytes) => {
+			let parsed;
+			try {
+				parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+			} catch (error) {
+				return {
+					ok: false,
+					reason: `not UTF-8 JSON: ${String(error)}`
+				};
+			}
+			return {
+				ok: true,
+				digest: createHash("sha256").update(jcsStringify(parsed)).digest("hex")
+			};
+		};
+		for (const [shapeName, shape] of Object.entries(entry.shapes)) adapter[`${entry.literal}#${shapeName}`] = (bytes) => {
+			let parsed;
+			try {
+				parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+			} catch (error) {
+				return {
+					ok: false,
+					reason: `not UTF-8 JSON: ${String(error)}`
+				};
+			}
+			if (Check(shape, parsed)) return { ok: true };
+			const first = Errors(shape, parsed).First();
+			return {
+				ok: false,
+				reason: `${first?.path ?? ""}: ${first?.message ?? "schema mismatch"}`
+			};
+		};
+	}
+	return adapter;
+}
+//#endregion
+export { runVectors as n, referenceAdapter as t };
+
+//# sourceMappingURL=reference-adapter-CaAo2iIH.mjs.map