@wovin/core 0.0.1-RC20 → 0.0.1-RC21

package/dist/chunk-MTQJBBHB.js

@@ -0,0 +1,4586 @@
+import {
+  ApplogStream,
+  MappedApplogStream,
+  action,
+  applogStreamComparer,
+  autorun,
+  comparer,
+  computed,
+  computedFnDeepCompare,
+  computedStructuralComparer,
+  createDebugName,
+  dateNowIso,
+  isInitEvent,
+  isTsBefore,
+  makeObservable,
+  observable,
+  observableArrayMap,
+  onBecomeObserved,
+  queryNodesComparer,
+  removeDuplicateAppLogs,
+  resolveOrRemoveVariables,
+  rollingFilter,
+  rollingMapper,
+  sortApplogsByTs,
+  toJS,
+  untracked,
+  wrapper_default
+} from "./chunk-YJXKRB2D.js";
+import {
+  Logger,
+  encodeApplogAndGetCid
+} from "./chunk-JHX2WWYS.js";
+import {
+  __commonJS,
+  __toESM,
+  init_dirname
+} from "./chunk-TIIA4ZAI.js";
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/typebox.js
+var require_typebox = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/typebox.js"(exports) {
+    "use strict";
+    init_dirname();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Type = exports.JsonType = exports.JavaScriptTypeBuilder = exports.JsonTypeBuilder = exports.TypeBuilder = exports.TypeBuilderError = exports.TransformEncodeBuilder = exports.TransformDecodeBuilder = exports.TemplateLiteralDslParser = exports.TemplateLiteralGenerator = exports.TemplateLiteralGeneratorError = exports.TemplateLiteralFinite = exports.TemplateLiteralFiniteError = exports.TemplateLiteralParser = exports.TemplateLiteralParserError = exports.TemplateLiteralResolver = exports.TemplateLiteralPattern = exports.TemplateLiteralPatternError = exports.UnionResolver = exports.KeyArrayResolver = exports.KeyArrayResolverError = exports.KeyResolver = exports.ObjectMap = exports.Intrinsic = exports.IndexedAccessor = exports.TypeClone = exports.TypeExtends = exports.TypeExtendsResult = exports.TypeExtendsError = exports.ExtendsUndefined = exports.TypeGuard = exports.TypeGuardUnknownTypeError = exports.ValueGuard = exports.FormatRegistry = exports.TypeBoxError = exports.TypeRegistry = exports.PatternStringExact = exports.PatternNumberExact = exports.PatternBooleanExact = exports.PatternString = exports.PatternNumber = exports.PatternBoolean = exports.Kind = exports.Hint = exports.Optional = exports.Readonly = exports.Transform = void 0;
+    exports.Transform = Symbol.for("TypeBox.Transform");
+    exports.Readonly = Symbol.for("TypeBox.Readonly");
+    exports.Optional = Symbol.for("TypeBox.Optional");
+    exports.Hint = Symbol.for("TypeBox.Hint");
+    exports.Kind = Symbol.for("TypeBox.Kind");
+    exports.PatternBoolean = "(true|false)";
+    exports.PatternNumber = "(0|[1-9][0-9]*)";
+    exports.PatternString = "(.*)";
+    exports.PatternBooleanExact = `^${exports.PatternBoolean}$`;
+    exports.PatternNumberExact = `^${exports.PatternNumber}$`;
+    exports.PatternStringExact = `^${exports.PatternString}$`;
+    var TypeRegistry;
+    (function(TypeRegistry2) {
+      const map = /* @__PURE__ */ new Map();
+      function Entries() {
+        return new Map(map);
+      }
+      TypeRegistry2.Entries = Entries;
+      function Clear() {
+        return map.clear();
+      }
+      TypeRegistry2.Clear = Clear;
+      function Delete(kind) {
+        return map.delete(kind);
+      }
+      TypeRegistry2.Delete = Delete;
+      function Has(kind) {
+        return map.has(kind);
+      }
+      TypeRegistry2.Has = Has;
+      function Set2(kind, func) {
+        map.set(kind, func);
+      }
+      TypeRegistry2.Set = Set2;
+      function Get(kind) {
+        return map.get(kind);
+      }
+      TypeRegistry2.Get = Get;
+    })(TypeRegistry || (exports.TypeRegistry = TypeRegistry = {}));
+    var TypeBoxError = class extends Error {
+      constructor(message) {
+        super(message);
+      }
+    };
+    exports.TypeBoxError = TypeBoxError;
+    var FormatRegistry2;
+    (function(FormatRegistry3) {
+      const map = /* @__PURE__ */ new Map();
+      function Entries() {
+        return new Map(map);
+      }
+      FormatRegistry3.Entries = Entries;
+      function Clear() {
+        return map.clear();
+      }
+      FormatRegistry3.Clear = Clear;
+      function Delete(format) {
+        return map.delete(format);
+      }
+      FormatRegistry3.Delete = Delete;
+      function Has(format) {
+        return map.has(format);
+      }
+      FormatRegistry3.Has = Has;
+      function Set2(format, func) {
+        map.set(format, func);
+      }
+      FormatRegistry3.Set = Set2;
+      function Get(format) {
+        return map.get(format);
+      }
+      FormatRegistry3.Get = Get;
+    })(FormatRegistry2 || (exports.FormatRegistry = FormatRegistry2 = {}));
+    var ValueGuard;
+    (function(ValueGuard2) {
+      function IsArray(value) {
+        return Array.isArray(value);
+      }
+      ValueGuard2.IsArray = IsArray;
+      function IsBigInt(value) {
+        return typeof value === "bigint";
+      }
+      ValueGuard2.IsBigInt = IsBigInt;
+      function IsBoolean(value) {
+        return typeof value === "boolean";
+      }
+      ValueGuard2.IsBoolean = IsBoolean;
+      function IsDate(value) {
+        return value instanceof globalThis.Date;
+      }
+      ValueGuard2.IsDate = IsDate;
+      function IsNull(value) {
+        return value === null;
+      }
+      ValueGuard2.IsNull = IsNull;
+      function IsNumber(value) {
+        return typeof value === "number";
+      }
+      ValueGuard2.IsNumber = IsNumber;
+      function IsObject(value) {
+        return typeof value === "object" && value !== null;
+      }
+      ValueGuard2.IsObject = IsObject;
+      function IsString(value) {
+        return typeof value === "string";
+      }
+      ValueGuard2.IsString = IsString;
+      function IsUint8Array(value) {
+        return value instanceof globalThis.Uint8Array;
+      }
+      ValueGuard2.IsUint8Array = IsUint8Array;
+      function IsUndefined(value) {
+        return value === void 0;
+      }
+      ValueGuard2.IsUndefined = IsUndefined;
+    })(ValueGuard || (exports.ValueGuard = ValueGuard = {}));
+    var TypeGuardUnknownTypeError = class extends TypeBoxError {
+    };
+    exports.TypeGuardUnknownTypeError = TypeGuardUnknownTypeError;
+    var TypeGuard;
+    (function(TypeGuard2) {
+      function IsPattern(value) {
+        try {
+          new RegExp(value);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      function IsControlCharacterFree(value) {
+        if (!ValueGuard.IsString(value))
+          return false;
+        for (let i = 0; i < value.length; i++) {
+          const code = value.charCodeAt(i);
+          if (code >= 7 && code <= 13 || code === 27 || code === 127) {
+            return false;
+          }
+        }
+        return true;
+      }
+      function IsAdditionalProperties(value) {
+        return IsOptionalBoolean(value) || TSchema2(value);
+      }
+      function IsOptionalBigInt(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value);
+      }
+      function IsOptionalNumber(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsNumber(value);
+      }
+      function IsOptionalBoolean(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsBoolean(value);
+      }
+      function IsOptionalString(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value);
+      }
+      function IsOptionalPattern(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value) && IsControlCharacterFree(value) && IsPattern(value);
+      }
+      function IsOptionalFormat(value) {
+        return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value) && IsControlCharacterFree(value);
+      }
+      function IsOptionalSchema(value) {
+        return ValueGuard.IsUndefined(value) || TSchema2(value);
+      }
+      function TAny(schema) {
+        return TKindOf(schema, "Any") && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TAny = TAny;
+      function TArray(schema) {
+        return TKindOf(schema, "Array") && schema.type === "array" && IsOptionalString(schema.$id) && TSchema2(schema.items) && IsOptionalNumber(schema.minItems) && IsOptionalNumber(schema.maxItems) && IsOptionalBoolean(schema.uniqueItems) && IsOptionalSchema(schema.contains) && IsOptionalNumber(schema.minContains) && IsOptionalNumber(schema.maxContains);
+      }
+      TypeGuard2.TArray = TArray;
+      function TAsyncIterator(schema) {
+        return TKindOf(schema, "AsyncIterator") && schema.type === "AsyncIterator" && IsOptionalString(schema.$id) && TSchema2(schema.items);
+      }
+      TypeGuard2.TAsyncIterator = TAsyncIterator;
+      function TBigInt(schema) {
+        return TKindOf(schema, "BigInt") && schema.type === "bigint" && IsOptionalString(schema.$id) && IsOptionalBigInt(schema.exclusiveMaximum) && IsOptionalBigInt(schema.exclusiveMinimum) && IsOptionalBigInt(schema.maximum) && IsOptionalBigInt(schema.minimum) && IsOptionalBigInt(schema.multipleOf);
+      }
+      TypeGuard2.TBigInt = TBigInt;
+      function TBoolean(schema) {
+        return TKindOf(schema, "Boolean") && schema.type === "boolean" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TBoolean = TBoolean;
+      function TConstructor(schema) {
+        return TKindOf(schema, "Constructor") && schema.type === "Constructor" && IsOptionalString(schema.$id) && ValueGuard.IsArray(schema.parameters) && schema.parameters.every((schema2) => TSchema2(schema2)) && TSchema2(schema.returns);
+      }
+      TypeGuard2.TConstructor = TConstructor;
+      function TDate(schema) {
+        return TKindOf(schema, "Date") && schema.type === "Date" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.exclusiveMaximumTimestamp) && IsOptionalNumber(schema.exclusiveMinimumTimestamp) && IsOptionalNumber(schema.maximumTimestamp) && IsOptionalNumber(schema.minimumTimestamp) && IsOptionalNumber(schema.multipleOfTimestamp);
+      }
+      TypeGuard2.TDate = TDate;
+      function TFunction(schema) {
+        return TKindOf(schema, "Function") && schema.type === "Function" && IsOptionalString(schema.$id) && ValueGuard.IsArray(schema.parameters) && schema.parameters.every((schema2) => TSchema2(schema2)) && TSchema2(schema.returns);
+      }
+      TypeGuard2.TFunction = TFunction;
+      function TInteger(schema) {
+        return TKindOf(schema, "Integer") && schema.type === "integer" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.exclusiveMaximum) && IsOptionalNumber(schema.exclusiveMinimum) && IsOptionalNumber(schema.maximum) && IsOptionalNumber(schema.minimum) && IsOptionalNumber(schema.multipleOf);
+      }
+      TypeGuard2.TInteger = TInteger;
+      function TIntersect(schema) {
+        return TKindOf(schema, "Intersect") && (ValueGuard.IsString(schema.type) && schema.type !== "object" ? false : true) && ValueGuard.IsArray(schema.allOf) && schema.allOf.every((schema2) => TSchema2(schema2) && !TTransform(schema2)) && IsOptionalString(schema.type) && (IsOptionalBoolean(schema.unevaluatedProperties) || IsOptionalSchema(schema.unevaluatedProperties)) && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TIntersect = TIntersect;
+      function TIterator(schema) {
+        return TKindOf(schema, "Iterator") && schema.type === "Iterator" && IsOptionalString(schema.$id) && TSchema2(schema.items);
+      }
+      TypeGuard2.TIterator = TIterator;
+      function TKindOf(schema, kind) {
+        return TKind(schema) && schema[exports.Kind] === kind;
+      }
+      TypeGuard2.TKindOf = TKindOf;
+      function TKind(schema) {
+        return ValueGuard.IsObject(schema) && exports.Kind in schema && ValueGuard.IsString(schema[exports.Kind]);
+      }
+      TypeGuard2.TKind = TKind;
+      function TLiteralString(schema) {
+        return TLiteral(schema) && ValueGuard.IsString(schema.const);
+      }
+      TypeGuard2.TLiteralString = TLiteralString;
+      function TLiteralNumber(schema) {
+        return TLiteral(schema) && ValueGuard.IsNumber(schema.const);
+      }
+      TypeGuard2.TLiteralNumber = TLiteralNumber;
+      function TLiteralBoolean(schema) {
+        return TLiteral(schema) && ValueGuard.IsBoolean(schema.const);
+      }
+      TypeGuard2.TLiteralBoolean = TLiteralBoolean;
+      function TLiteral(schema) {
+        return TKindOf(schema, "Literal") && IsOptionalString(schema.$id) && (ValueGuard.IsBoolean(schema.const) || ValueGuard.IsNumber(schema.const) || ValueGuard.IsString(schema.const));
+      }
+      TypeGuard2.TLiteral = TLiteral;
+      function TNever(schema) {
+        return TKindOf(schema, "Never") && ValueGuard.IsObject(schema.not) && Object.getOwnPropertyNames(schema.not).length === 0;
+      }
+      TypeGuard2.TNever = TNever;
+      function TNot(schema) {
+        return TKindOf(schema, "Not") && TSchema2(schema.not);
+      }
+      TypeGuard2.TNot = TNot;
+      function TNull(schema) {
+        return TKindOf(schema, "Null") && schema.type === "null" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TNull = TNull;
+      function TNumber(schema) {
+        return TKindOf(schema, "Number") && schema.type === "number" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.exclusiveMaximum) && IsOptionalNumber(schema.exclusiveMinimum) && IsOptionalNumber(schema.maximum) && IsOptionalNumber(schema.minimum) && IsOptionalNumber(schema.multipleOf);
+      }
+      TypeGuard2.TNumber = TNumber;
+      function TObject(schema) {
+        return TKindOf(schema, "Object") && schema.type === "object" && IsOptionalString(schema.$id) && ValueGuard.IsObject(schema.properties) && IsAdditionalProperties(schema.additionalProperties) && IsOptionalNumber(schema.minProperties) && IsOptionalNumber(schema.maxProperties) && Object.entries(schema.properties).every(([key, schema2]) => IsControlCharacterFree(key) && TSchema2(schema2));
+      }
+      TypeGuard2.TObject = TObject;
+      function TPromise(schema) {
+        return TKindOf(schema, "Promise") && schema.type === "Promise" && IsOptionalString(schema.$id) && TSchema2(schema.item);
+      }
+      TypeGuard2.TPromise = TPromise;
+      function TRecord(schema) {
+        return TKindOf(schema, "Record") && schema.type === "object" && IsOptionalString(schema.$id) && IsAdditionalProperties(schema.additionalProperties) && ValueGuard.IsObject(schema.patternProperties) && ((schema2) => {
+          const keys = Object.getOwnPropertyNames(schema2.patternProperties);
+          return keys.length === 1 && IsPattern(keys[0]) && ValueGuard.IsObject(schema2.patternProperties) && TSchema2(schema2.patternProperties[keys[0]]);
+        })(schema);
+      }
+      TypeGuard2.TRecord = TRecord;
+      function TRecursive(schema) {
+        return ValueGuard.IsObject(schema) && exports.Hint in schema && schema[exports.Hint] === "Recursive";
+      }
+      TypeGuard2.TRecursive = TRecursive;
+      function TRef(schema) {
+        return TKindOf(schema, "Ref") && IsOptionalString(schema.$id) && ValueGuard.IsString(schema.$ref);
+      }
+      TypeGuard2.TRef = TRef;
+      function TString(schema) {
+        return TKindOf(schema, "String") && schema.type === "string" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minLength) && IsOptionalNumber(schema.maxLength) && IsOptionalPattern(schema.pattern) && IsOptionalFormat(schema.format);
+      }
+      TypeGuard2.TString = TString;
+      function TSymbol(schema) {
+        return TKindOf(schema, "Symbol") && schema.type === "symbol" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TSymbol = TSymbol;
+      function TTemplateLiteral(schema) {
+        return TKindOf(schema, "TemplateLiteral") && schema.type === "string" && ValueGuard.IsString(schema.pattern) && schema.pattern[0] === "^" && schema.pattern[schema.pattern.length - 1] === "$";
+      }
+      TypeGuard2.TTemplateLiteral = TTemplateLiteral;
+      function TThis(schema) {
+        return TKindOf(schema, "This") && IsOptionalString(schema.$id) && ValueGuard.IsString(schema.$ref);
+      }
+      TypeGuard2.TThis = TThis;
+      function TTransform(schema) {
+        return ValueGuard.IsObject(schema) && exports.Transform in schema;
+      }
+      TypeGuard2.TTransform = TTransform;
+      function TTuple(schema) {
+        return TKindOf(schema, "Tuple") && schema.type === "array" && IsOptionalString(schema.$id) && ValueGuard.IsNumber(schema.minItems) && ValueGuard.IsNumber(schema.maxItems) && schema.minItems === schema.maxItems && // empty
+        (ValueGuard.IsUndefined(schema.items) && ValueGuard.IsUndefined(schema.additionalItems) && schema.minItems === 0 || ValueGuard.IsArray(schema.items) && schema.items.every((schema2) => TSchema2(schema2)));
+      }
+      TypeGuard2.TTuple = TTuple;
+      function TUndefined(schema) {
+        return TKindOf(schema, "Undefined") && schema.type === "undefined" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TUndefined = TUndefined;
+      function TUnionLiteral(schema) {
+        return TUnion(schema) && schema.anyOf.every((schema2) => TLiteralString(schema2) || TLiteralNumber(schema2));
+      }
+      TypeGuard2.TUnionLiteral = TUnionLiteral;
+      function TUnion(schema) {
+        return TKindOf(schema, "Union") && IsOptionalString(schema.$id) && ValueGuard.IsObject(schema) && ValueGuard.IsArray(schema.anyOf) && schema.anyOf.every((schema2) => TSchema2(schema2));
+      }
+      TypeGuard2.TUnion = TUnion;
+      function TUint8Array(schema) {
+        return TKindOf(schema, "Uint8Array") && schema.type === "Uint8Array" && IsOptionalString(schema.$id) && IsOptionalNumber(schema.minByteLength) && IsOptionalNumber(schema.maxByteLength);
+      }
+      TypeGuard2.TUint8Array = TUint8Array;
+      function TUnknown(schema) {
+        return TKindOf(schema, "Unknown") && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TUnknown = TUnknown;
+      function TUnsafe(schema) {
+        return TKindOf(schema, "Unsafe");
+      }
+      TypeGuard2.TUnsafe = TUnsafe;
+      function TVoid(schema) {
+        return TKindOf(schema, "Void") && schema.type === "void" && IsOptionalString(schema.$id);
+      }
+      TypeGuard2.TVoid = TVoid;
+      function TReadonly(schema) {
+        return ValueGuard.IsObject(schema) && schema[exports.Readonly] === "Readonly";
+      }
+      TypeGuard2.TReadonly = TReadonly;
+      function TOptional(schema) {
+        return ValueGuard.IsObject(schema) && schema[exports.Optional] === "Optional";
+      }
+      TypeGuard2.TOptional = TOptional;
+      function TSchema2(schema) {
+        return ValueGuard.IsObject(schema) && (TAny(schema) || TArray(schema) || TBoolean(schema) || TBigInt(schema) || TAsyncIterator(schema) || TConstructor(schema) || TDate(schema) || TFunction(schema) || TInteger(schema) || TIntersect(schema) || TIterator(schema) || TLiteral(schema) || TNever(schema) || TNot(schema) || TNull(schema) || TNumber(schema) || TObject(schema) || TPromise(schema) || TRecord(schema) || TRef(schema) || TString(schema) || TSymbol(schema) || TTemplateLiteral(schema) || TThis(schema) || TTuple(schema) || TUndefined(schema) || TUnion(schema) || TUint8Array(schema) || TUnknown(schema) || TUnsafe(schema) || TVoid(schema) || TKind(schema) && TypeRegistry.Has(schema[exports.Kind]));
+      }
+      TypeGuard2.TSchema = TSchema2;
+    })(TypeGuard || (exports.TypeGuard = TypeGuard = {}));
+    var ExtendsUndefined;
+    (function(ExtendsUndefined2) {
+      function Check(schema) {
+        return schema[exports.Kind] === "Intersect" ? schema.allOf.every((schema2) => Check(schema2)) : schema[exports.Kind] === "Union" ? schema.anyOf.some((schema2) => Check(schema2)) : schema[exports.Kind] === "Undefined" ? true : schema[exports.Kind] === "Not" ? !Check(schema.not) : false;
+      }
+      ExtendsUndefined2.Check = Check;
+    })(ExtendsUndefined || (exports.ExtendsUndefined = ExtendsUndefined = {}));
+    var TypeExtendsError = class extends TypeBoxError {
+    };
+    exports.TypeExtendsError = TypeExtendsError;
+    var TypeExtendsResult;
+    (function(TypeExtendsResult2) {
+      TypeExtendsResult2[TypeExtendsResult2["Union"] = 0] = "Union";
+      TypeExtendsResult2[TypeExtendsResult2["True"] = 1] = "True";
+      TypeExtendsResult2[TypeExtendsResult2["False"] = 2] = "False";
+    })(TypeExtendsResult || (exports.TypeExtendsResult = TypeExtendsResult = {}));
+    var TypeExtends;
+    (function(TypeExtends2) {
+      function IntoBooleanResult(result) {
+        return result === TypeExtendsResult.False ? result : TypeExtendsResult.True;
+      }
+      function Throw(message) {
+        throw new TypeExtendsError(message);
+      }
+      function IsStructuralRight(right) {
+        return TypeGuard.TNever(right) || TypeGuard.TIntersect(right) || TypeGuard.TUnion(right) || TypeGuard.TUnknown(right) || TypeGuard.TAny(right);
+      }
+      function StructuralRight(left, right) {
+        return TypeGuard.TNever(right) ? TNeverRight(left, right) : TypeGuard.TIntersect(right) ? TIntersectRight(left, right) : TypeGuard.TUnion(right) ? TUnionRight(left, right) : TypeGuard.TUnknown(right) ? TUnknownRight(left, right) : TypeGuard.TAny(right) ? TAnyRight(left, right) : Throw("StructuralRight");
+      }
+      function TAnyRight(left, right) {
+        return TypeExtendsResult.True;
+      }
+      function TAny(left, right) {
+        return TypeGuard.TIntersect(right) ? TIntersectRight(left, right) : TypeGuard.TUnion(right) && right.anyOf.some((schema) => TypeGuard.TAny(schema) || TypeGuard.TUnknown(schema)) ? TypeExtendsResult.True : TypeGuard.TUnion(right) ? TypeExtendsResult.Union : TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeGuard.TAny(right) ? TypeExtendsResult.True : TypeExtendsResult.Union;
+      }
+      function TArrayRight(left, right) {
+        return TypeGuard.TUnknown(left) ? TypeExtendsResult.False : TypeGuard.TAny(left) ? TypeExtendsResult.Union : TypeGuard.TNever(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TArray(left, right) {
+        return TypeGuard.TObject(right) && IsObjectArrayLike(right) ? TypeExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : !TypeGuard.TArray(right) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+      }
+      function TAsyncIterator(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : !TypeGuard.TAsyncIterator(right) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+      }
+      function TBigInt(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TBigInt(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TBooleanRight(left, right) {
+        return TypeGuard.TLiteral(left) && ValueGuard.IsBoolean(left.const) ? TypeExtendsResult.True : TypeGuard.TBoolean(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TBoolean(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TBoolean(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TConstructor(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : !TypeGuard.TConstructor(right) ? TypeExtendsResult.False : left.parameters.length > right.parameters.length ? TypeExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.returns, right.returns));
+      }
+      function TDate(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TDate(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TFunction(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : !TypeGuard.TFunction(right) ? TypeExtendsResult.False : left.parameters.length > right.parameters.length ? TypeExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit(right.parameters[index], schema)) === TypeExtendsResult.True) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.returns, right.returns));
+      }
+      function TIntegerRight(left, right) {
+        return TypeGuard.TLiteral(left) && ValueGuard.IsNumber(left.const) ? TypeExtendsResult.True : TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TInteger(left, right) {
+        return TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeExtendsResult.False;
+      }
+      function TIntersectRight(left, right) {
+        return right.allOf.every((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TIntersect(left, right) {
+        return left.allOf.some((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TIterator(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : !TypeGuard.TIterator(right) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.items, right.items));
+      }
+      function TLiteral(left, right) {
+        return TypeGuard.TLiteral(right) && right.const === left.const ? TypeExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TString(right) ? TStringRight(left, right) : TypeGuard.TNumber(right) ? TNumberRight(left, right) : TypeGuard.TInteger(right) ? TIntegerRight(left, right) : TypeGuard.TBoolean(right) ? TBooleanRight(left, right) : TypeExtendsResult.False;
+      }
+      function TNeverRight(left, right) {
+        return TypeExtendsResult.False;
+      }
+      function TNever(left, right) {
+        return TypeExtendsResult.True;
+      }
+      function UnwrapTNot(schema) {
+        let [current, depth] = [schema, 0];
+        while (true) {
+          if (!TypeGuard.TNot(current))
+            break;
+          current = current.not;
+          depth += 1;
+        }
+        return depth % 2 === 0 ? current : exports.Type.Unknown();
+      }
+      function TNot(left, right) {
+        return TypeGuard.TNot(left) ? Visit(UnwrapTNot(left), right) : TypeGuard.TNot(right) ? Visit(left, UnwrapTNot(right)) : Throw("Invalid fallthrough for Not");
+      }
+      function TNull(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TNull(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TNumberRight(left, right) {
+        return TypeGuard.TLiteralNumber(left) ? TypeExtendsResult.True : TypeGuard.TNumber(left) || TypeGuard.TInteger(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TNumber(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TInteger(right) || TypeGuard.TNumber(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function IsObjectPropertyCount(schema, count) {
+        return Object.getOwnPropertyNames(schema.properties).length === count;
+      }
+      function IsObjectStringLike(schema) {
+        return IsObjectArrayLike(schema);
+      }
+      function IsObjectSymbolLike(schema) {
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "description" in schema.properties && TypeGuard.TUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && (TypeGuard.TString(schema.properties.description.anyOf[0]) && TypeGuard.TUndefined(schema.properties.description.anyOf[1]) || TypeGuard.TString(schema.properties.description.anyOf[1]) && TypeGuard.TUndefined(schema.properties.description.anyOf[0]));
+      }
+      function IsObjectNumberLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectBooleanLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectBigIntLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectDateLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectUint8ArrayLike(schema) {
+        return IsObjectArrayLike(schema);
+      }
+      function IsObjectFunctionLike(schema) {
+        const length = exports.Type.Number();
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === TypeExtendsResult.True;
+      }
+      function IsObjectConstructorLike(schema) {
+        return IsObjectPropertyCount(schema, 0);
+      }
+      function IsObjectArrayLike(schema) {
+        const length = exports.Type.Number();
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit(schema.properties["length"], length)) === TypeExtendsResult.True;
+      }
+      function IsObjectPromiseLike(schema) {
+        const then = exports.Type.Function([exports.Type.Any()], exports.Type.Any());
+        return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "then" in schema.properties && IntoBooleanResult(Visit(schema.properties["then"], then)) === TypeExtendsResult.True;
+      }
+      function Property(left, right) {
+        return Visit(left, right) === TypeExtendsResult.False ? TypeExtendsResult.False : TypeGuard.TOptional(left) && !TypeGuard.TOptional(right) ? TypeExtendsResult.False : TypeExtendsResult.True;
+      }
+      function TObjectRight(left, right) {
+        return TypeGuard.TUnknown(left) ? TypeExtendsResult.False : TypeGuard.TAny(left) ? TypeExtendsResult.Union : TypeGuard.TNever(left) || TypeGuard.TLiteralString(left) && IsObjectStringLike(right) || TypeGuard.TLiteralNumber(left) && IsObjectNumberLike(right) || TypeGuard.TLiteralBoolean(left) && IsObjectBooleanLike(right) || TypeGuard.TSymbol(left) && IsObjectSymbolLike(right) || TypeGuard.TBigInt(left) && IsObjectBigIntLike(right) || TypeGuard.TString(left) && IsObjectStringLike(right) || TypeGuard.TSymbol(left) && IsObjectSymbolLike(right) || TypeGuard.TNumber(left) && IsObjectNumberLike(right) || TypeGuard.TInteger(left) && IsObjectNumberLike(right) || TypeGuard.TBoolean(left) && IsObjectBooleanLike(right) || TypeGuard.TUint8Array(left) && IsObjectUint8ArrayLike(right) || TypeGuard.TDate(left) && IsObjectDateLike(right) || TypeGuard.TConstructor(left) && IsObjectConstructorLike(right) || TypeGuard.TFunction(left) && IsObjectFunctionLike(right) ? TypeExtendsResult.True : TypeGuard.TRecord(left) && TypeGuard.TString(RecordKey(left)) ? (() => {
+          return right[exports.Hint] === "Record" ? TypeExtendsResult.True : TypeExtendsResult.False;
+        })() : TypeGuard.TRecord(left) && TypeGuard.TNumber(RecordKey(left)) ? (() => {
+          return IsObjectPropertyCount(right, 0) ? TypeExtendsResult.True : TypeExtendsResult.False;
+        })() : TypeExtendsResult.False;
+      }
+      function TObject(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : !TypeGuard.TObject(right) ? TypeExtendsResult.False : (() => {
+          for (const key of Object.getOwnPropertyNames(right.properties)) {
+            if (!(key in left.properties) && !TypeGuard.TOptional(right.properties[key])) {
+              return TypeExtendsResult.False;
+            }
+            if (TypeGuard.TOptional(right.properties[key])) {
+              return TypeExtendsResult.True;
+            }
+            if (Property(left.properties[key], right.properties[key]) === TypeExtendsResult.False) {
+              return TypeExtendsResult.False;
+            }
+          }
+          return TypeExtendsResult.True;
+        })();
+      }
+      function TPromise(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) && IsObjectPromiseLike(right) ? TypeExtendsResult.True : !TypeGuard.TPromise(right) ? TypeExtendsResult.False : IntoBooleanResult(Visit(left.item, right.item));
+      }
+      function RecordKey(schema) {
+        return exports.PatternNumberExact in schema.patternProperties ? exports.Type.Number() : exports.PatternStringExact in schema.patternProperties ? exports.Type.String() : Throw("Unknown record key pattern");
+      }
+      function RecordValue(schema) {
+        return exports.PatternNumberExact in schema.patternProperties ? schema.patternProperties[exports.PatternNumberExact] : exports.PatternStringExact in schema.patternProperties ? schema.patternProperties[exports.PatternStringExact] : Throw("Unable to get record value schema");
+      }
+      function TRecordRight(left, right) {
+        const [Key, Value] = [RecordKey(right), RecordValue(right)];
+        return TypeGuard.TLiteralString(left) && TypeGuard.TNumber(Key) && IntoBooleanResult(Visit(left, Value)) === TypeExtendsResult.True ? TypeExtendsResult.True : TypeGuard.TUint8Array(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) : TypeGuard.TString(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) : TypeGuard.TArray(left) && TypeGuard.TNumber(Key) ? Visit(left, Value) : TypeGuard.TObject(left) ? (() => {
+          for (const key of Object.getOwnPropertyNames(left.properties)) {
+            if (Property(Value, left.properties[key]) === TypeExtendsResult.False) {
+              return TypeExtendsResult.False;
+            }
+          }
+          return TypeExtendsResult.True;
+        })() : TypeExtendsResult.False;
+      }
+      function TRecord(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : !TypeGuard.TRecord(right) ? TypeExtendsResult.False : Visit(RecordValue(left), RecordValue(right));
+      }
+      function TStringRight(left, right) {
+        return TypeGuard.TLiteral(left) && ValueGuard.IsString(left.const) ? TypeExtendsResult.True : TypeGuard.TString(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TString(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TString(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TSymbol(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TSymbol(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TTemplateLiteral(left, right) {
+        return TypeGuard.TTemplateLiteral(left) ? Visit(TemplateLiteralResolver.Resolve(left), right) : TypeGuard.TTemplateLiteral(right) ? Visit(left, TemplateLiteralResolver.Resolve(right)) : Throw("Invalid fallthrough for TemplateLiteral");
+      }
+      function IsArrayOfTuple(left, right) {
+        return TypeGuard.TArray(right) && left.items !== void 0 && left.items.every((schema) => Visit(schema, right.items) === TypeExtendsResult.True);
+      }
+      function TTupleRight(left, right) {
+        return TypeGuard.TNever(left) ? TypeExtendsResult.True : TypeGuard.TUnknown(left) ? TypeExtendsResult.False : TypeGuard.TAny(left) ? TypeExtendsResult.Union : TypeExtendsResult.False;
+      }
+      function TTuple(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) && IsObjectArrayLike(right) ? TypeExtendsResult.True : TypeGuard.TArray(right) && IsArrayOfTuple(left, right) ? TypeExtendsResult.True : !TypeGuard.TTuple(right) ? TypeExtendsResult.False : ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items) || !ValueGuard.IsUndefined(left.items) && ValueGuard.IsUndefined(right.items) ? TypeExtendsResult.False : ValueGuard.IsUndefined(left.items) && !ValueGuard.IsUndefined(right.items) ? TypeExtendsResult.True : left.items.every((schema, index) => Visit(schema, right.items[index]) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TUint8Array(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TUint8Array(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TUndefined(left, right) {
+        return IsStructuralRight(right) ? StructuralRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TRecord(right) ? TRecordRight(left, right) : TypeGuard.TVoid(right) ? VoidRight(left, right) : TypeGuard.TUndefined(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TUnionRight(left, right) {
+        return right.anyOf.some((schema) => Visit(left, schema) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TUnion(left, right) {
+        return left.anyOf.every((schema) => Visit(schema, right) === TypeExtendsResult.True) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TUnknownRight(left, right) {
+        return TypeExtendsResult.True;
+      }
+      function TUnknown(left, right) {
+        return TypeGuard.TNever(right) ? TNeverRight(left, right) : TypeGuard.TIntersect(right) ? TIntersectRight(left, right) : TypeGuard.TUnion(right) ? TUnionRight(left, right) : TypeGuard.TAny(right) ? TAnyRight(left, right) : TypeGuard.TString(right) ? TStringRight(left, right) : TypeGuard.TNumber(right) ? TNumberRight(left, right) : TypeGuard.TInteger(right) ? TIntegerRight(left, right) : TypeGuard.TBoolean(right) ? TBooleanRight(left, right) : TypeGuard.TArray(right) ? TArrayRight(left, right) : TypeGuard.TTuple(right) ? TTupleRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TUnknown(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function VoidRight(left, right) {
+        return TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeGuard.TUndefined(left) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function TVoid(left, right) {
+        return TypeGuard.TIntersect(right) ? TIntersectRight(left, right) : TypeGuard.TUnion(right) ? TUnionRight(left, right) : TypeGuard.TUnknown(right) ? TUnknownRight(left, right) : TypeGuard.TAny(right) ? TAnyRight(left, right) : TypeGuard.TObject(right) ? TObjectRight(left, right) : TypeGuard.TVoid(right) ? TypeExtendsResult.True : TypeExtendsResult.False;
+      }
+      function Visit(left, right) {
+        return (
+          // resolvable
+          TypeGuard.TTemplateLiteral(left) || TypeGuard.TTemplateLiteral(right) ? TTemplateLiteral(left, right) : TypeGuard.TNot(left) || TypeGuard.TNot(right) ? TNot(left, right) : (
+            // standard
+            TypeGuard.TAny(left) ? TAny(left, right) : TypeGuard.TArray(left) ? TArray(left, right) : TypeGuard.TBigInt(left) ? TBigInt(left, right) : TypeGuard.TBoolean(left) ? TBoolean(left, right) : TypeGuard.TAsyncIterator(left) ? TAsyncIterator(left, right) : TypeGuard.TConstructor(left) ? TConstructor(left, right) : TypeGuard.TDate(left) ? TDate(left, right) : TypeGuard.TFunction(left) ? TFunction(left, right) : TypeGuard.TInteger(left) ? TInteger(left, right) : TypeGuard.TIntersect(left) ? TIntersect(left, right) : TypeGuard.TIterator(left) ? TIterator(left, right) : TypeGuard.TLiteral(left) ? TLiteral(left, right) : TypeGuard.TNever(left) ? TNever(left, right) : TypeGuard.TNull(left) ? TNull(left, right) : TypeGuard.TNumber(left) ? TNumber(left, right) : TypeGuard.TObject(left) ? TObject(left, right) : TypeGuard.TRecord(left) ? TRecord(left, right) : TypeGuard.TString(left) ? TString(left, right) : TypeGuard.TSymbol(left) ? TSymbol(left, right) : TypeGuard.TTuple(left) ? TTuple(left, right) : TypeGuard.TPromise(left) ? TPromise(left, right) : TypeGuard.TUint8Array(left) ? TUint8Array(left, right) : TypeGuard.TUndefined(left) ? TUndefined(left, right) : TypeGuard.TUnion(left) ? TUnion(left, right) : TypeGuard.TUnknown(left) ? TUnknown(left, right) : TypeGuard.TVoid(left) ? TVoid(left, right) : Throw(`Unknown left type operand '${left[exports.Kind]}'`)
+          )
+        );
+      }
+      function Extends(left, right) {
+        return Visit(left, right);
+      }
+      TypeExtends2.Extends = Extends;
+    })(TypeExtends || (exports.TypeExtends = TypeExtends = {}));
+    var TypeClone;
+    (function(TypeClone2) {
+      function ArrayType(value) {
+        return value.map((value2) => Visit(value2));
+      }
+      function DateType(value) {
+        return new Date(value.getTime());
+      }
+      function Uint8ArrayType(value) {
+        return new Uint8Array(value);
+      }
+      function ObjectType(value) {
+        const clonedProperties = Object.getOwnPropertyNames(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
+        const clonedSymbols = Object.getOwnPropertySymbols(value).reduce((acc, key) => ({ ...acc, [key]: Visit(value[key]) }), {});
+        return { ...clonedProperties, ...clonedSymbols };
+      }
+      function Visit(value) {
+        return ValueGuard.IsArray(value) ? ArrayType(value) : ValueGuard.IsDate(value) ? DateType(value) : ValueGuard.IsUint8Array(value) ? Uint8ArrayType(value) : ValueGuard.IsObject(value) ? ObjectType(value) : value;
+      }
+      function Rest(schemas) {
+        return schemas.map((schema) => Type2(schema));
+      }
+      TypeClone2.Rest = Rest;
+      function Type2(schema, options = {}) {
+        return { ...Visit(schema), ...options };
+      }
+      TypeClone2.Type = Type2;
+    })(TypeClone || (exports.TypeClone = TypeClone = {}));
+    var IndexedAccessor;
+    (function(IndexedAccessor2) {
+      function OptionalUnwrap(schema) {
+        return schema.map((schema2) => {
+          const { [exports.Optional]: _, ...clone } = TypeClone.Type(schema2);
+          return clone;
+        });
+      }
+      function IsIntersectOptional(schema) {
+        return schema.every((schema2) => TypeGuard.TOptional(schema2));
+      }
+      function IsUnionOptional(schema) {
+        return schema.some((schema2) => TypeGuard.TOptional(schema2));
+      }
+      function ResolveIntersect(schema) {
+        return IsIntersectOptional(schema.allOf) ? exports.Type.Optional(exports.Type.Intersect(OptionalUnwrap(schema.allOf))) : schema;
+      }
+      function ResolveUnion(schema) {
+        return IsUnionOptional(schema.anyOf) ? exports.Type.Optional(exports.Type.Union(OptionalUnwrap(schema.anyOf))) : schema;
+      }
+      function ResolveOptional(schema) {
+        return schema[exports.Kind] === "Intersect" ? ResolveIntersect(schema) : schema[exports.Kind] === "Union" ? ResolveUnion(schema) : schema;
+      }
+      function TIntersect(schema, key) {
+        const resolved = schema.allOf.reduce((acc, schema2) => {
+          const indexed = Visit(schema2, key);
+          return indexed[exports.Kind] === "Never" ? acc : [...acc, indexed];
+        }, []);
+        return ResolveOptional(exports.Type.Intersect(resolved));
+      }
+      function TUnion(schema, key) {
+        const resolved = schema.anyOf.map((schema2) => Visit(schema2, key));
+        return ResolveOptional(exports.Type.Union(resolved));
+      }
+      function TObject(schema, key) {
+        const property = schema.properties[key];
+        return ValueGuard.IsUndefined(property) ? exports.Type.Never() : exports.Type.Union([property]);
+      }
+      function TTuple(schema, key) {
+        const items = schema.items;
+        if (ValueGuard.IsUndefined(items))
+          return exports.Type.Never();
+        const element = items[key];
+        if (ValueGuard.IsUndefined(element))
+          return exports.Type.Never();
+        return element;
+      }
+      function Visit(schema, key) {
+        return schema[exports.Kind] === "Intersect" ? TIntersect(schema, key) : schema[exports.Kind] === "Union" ? TUnion(schema, key) : schema[exports.Kind] === "Object" ? TObject(schema, key) : schema[exports.Kind] === "Tuple" ? TTuple(schema, key) : exports.Type.Never();
+      }
+      function Resolve(schema, keys, options = {}) {
+        const resolved = keys.map((key) => Visit(schema, key.toString()));
+        return ResolveOptional(exports.Type.Union(resolved, options));
+      }
+      IndexedAccessor2.Resolve = Resolve;
+    })(IndexedAccessor || (exports.IndexedAccessor = IndexedAccessor = {}));
+    var Intrinsic;
+    (function(Intrinsic2) {
+      function Uncapitalize(value) {
+        const [first, rest] = [value.slice(0, 1), value.slice(1)];
+        return `${first.toLowerCase()}${rest}`;
+      }
+      function Capitalize(value) {
+        const [first, rest] = [value.slice(0, 1), value.slice(1)];
+        return `${first.toUpperCase()}${rest}`;
+      }
+      function Uppercase(value) {
+        return value.toUpperCase();
+      }
+      function Lowercase(value) {
+        return value.toLowerCase();
+      }
+      function IntrinsicTemplateLiteral(schema, mode) {
+        const expression = TemplateLiteralParser.ParseExact(schema.pattern);
+        const finite = TemplateLiteralFinite.Check(expression);
+        if (!finite)
+          return { ...schema, pattern: IntrinsicLiteral(schema.pattern, mode) };
+        const strings = [...TemplateLiteralGenerator.Generate(expression)];
+        const literals = strings.map((value) => exports.Type.Literal(value));
+        const mapped = IntrinsicRest(literals, mode);
+        const union = exports.Type.Union(mapped);
+        return exports.Type.TemplateLiteral([union]);
+      }
+      function IntrinsicLiteral(value, mode) {
+        return typeof value === "string" ? mode === "Uncapitalize" ? Uncapitalize(value) : mode === "Capitalize" ? Capitalize(value) : mode === "Uppercase" ? Uppercase(value) : mode === "Lowercase" ? Lowercase(value) : value : value.toString();
+      }
+      function IntrinsicRest(schema, mode) {
+        if (schema.length === 0)
+          return [];
+        const [L, ...R] = schema;
+        return [Map2(L, mode), ...IntrinsicRest(R, mode)];
+      }
+      function Visit(schema, mode) {
+        return TypeGuard.TTemplateLiteral(schema) ? IntrinsicTemplateLiteral(schema, mode) : TypeGuard.TUnion(schema) ? exports.Type.Union(IntrinsicRest(schema.anyOf, mode)) : TypeGuard.TLiteral(schema) ? exports.Type.Literal(IntrinsicLiteral(schema.const, mode)) : schema;
+      }
+      function Map2(schema, mode) {
+        return Visit(schema, mode);
+      }
+      Intrinsic2.Map = Map2;
+    })(Intrinsic || (exports.Intrinsic = Intrinsic = {}));
+    var ObjectMap;
+    (function(ObjectMap2) {
+      function TIntersect(schema, callback) {
+        return exports.Type.Intersect(schema.allOf.map((inner) => Visit(inner, callback)), { ...schema });
+      }
+      function TUnion(schema, callback) {
+        return exports.Type.Union(schema.anyOf.map((inner) => Visit(inner, callback)), { ...schema });
+      }
+      function TObject(schema, callback) {
+        return callback(schema);
+      }
+      function Visit(schema, callback) {
+        return schema[exports.Kind] === "Intersect" ? TIntersect(schema, callback) : schema[exports.Kind] === "Union" ? TUnion(schema, callback) : schema[exports.Kind] === "Object" ? TObject(schema, callback) : schema;
+      }
+      function Map2(schema, callback, options) {
+        return { ...Visit(TypeClone.Type(schema), callback), ...options };
+      }
+      ObjectMap2.Map = Map2;
+    })(ObjectMap || (exports.ObjectMap = ObjectMap = {}));
+    var KeyResolver;
+    (function(KeyResolver2) {
+      function UnwrapPattern(key) {
+        return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
+      }
+      function TIntersect(schema, options) {
+        return schema.allOf.reduce((acc, schema2) => [...acc, ...Visit(schema2, options)], []);
+      }
+      function TUnion(schema, options) {
+        const sets = schema.anyOf.map((inner) => Visit(inner, options));
+        return [...sets.reduce((set, outer) => outer.map((key) => sets.every((inner) => inner.includes(key)) ? set.add(key) : set)[0], /* @__PURE__ */ new Set())];
+      }
+      function TObject(schema, options) {
+        return Object.getOwnPropertyNames(schema.properties);
+      }
+      function TRecord(schema, options) {
+        return options.includePatterns ? Object.getOwnPropertyNames(schema.patternProperties) : [];
+      }
+      function Visit(schema, options) {
+        return TypeGuard.TIntersect(schema) ? TIntersect(schema, options) : TypeGuard.TUnion(schema) ? TUnion(schema, options) : TypeGuard.TObject(schema) ? TObject(schema, options) : TypeGuard.TRecord(schema) ? TRecord(schema, options) : [];
+      }
+      function ResolveKeys(schema, options) {
+        return [...new Set(Visit(schema, options))];
+      }
+      KeyResolver2.ResolveKeys = ResolveKeys;
+      function ResolvePattern(schema) {
+        const keys = ResolveKeys(schema, { includePatterns: true });
+        const pattern = keys.map((key) => `(${UnwrapPattern(key)})`);
+        return `^(${pattern.join("|")})$`;
+      }
+      KeyResolver2.ResolvePattern = ResolvePattern;
+    })(KeyResolver || (exports.KeyResolver = KeyResolver = {}));
+    var KeyArrayResolverError = class extends TypeBoxError {
+    };
+    exports.KeyArrayResolverError = KeyArrayResolverError;
+    var KeyArrayResolver;
+    (function(KeyArrayResolver2) {
+      function Resolve(schema) {
+        return Array.isArray(schema) ? schema : TypeGuard.TUnionLiteral(schema) ? schema.anyOf.map((schema2) => schema2.const.toString()) : TypeGuard.TLiteral(schema) ? [schema.const] : TypeGuard.TTemplateLiteral(schema) ? (() => {
+          const expression = TemplateLiteralParser.ParseExact(schema.pattern);
+          if (!TemplateLiteralFinite.Check(expression))
+            throw new KeyArrayResolverError("Cannot resolve keys from infinite template expression");
+          return [...TemplateLiteralGenerator.Generate(expression)];
+        })() : [];
+      }
+      KeyArrayResolver2.Resolve = Resolve;
+    })(KeyArrayResolver || (exports.KeyArrayResolver = KeyArrayResolver = {}));
+    var UnionResolver;
+    (function(UnionResolver2) {
+      function* TUnion(union) {
+        for (const schema of union.anyOf) {
+          if (schema[exports.Kind] === "Union") {
+            yield* TUnion(schema);
+          } else {
+            yield schema;
+          }
+        }
+      }
+      function Resolve(union) {
+        return exports.Type.Union([...TUnion(union)], { ...union });
+      }
+      UnionResolver2.Resolve = Resolve;
+    })(UnionResolver || (exports.UnionResolver = UnionResolver = {}));
+    var TemplateLiteralPatternError = class extends TypeBoxError {
+    };
+    exports.TemplateLiteralPatternError = TemplateLiteralPatternError;
+    var TemplateLiteralPattern;
+    (function(TemplateLiteralPattern2) {
+      function Throw(message) {
+        throw new TemplateLiteralPatternError(message);
+      }
+      function Escape(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      }
+      function Visit(schema, acc) {
+        return TypeGuard.TTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : TypeGuard.TUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit(schema2, acc)).join("|")})` : TypeGuard.TNumber(schema) ? `${acc}${exports.PatternNumber}` : TypeGuard.TInteger(schema) ? `${acc}${exports.PatternNumber}` : TypeGuard.TBigInt(schema) ? `${acc}${exports.PatternNumber}` : TypeGuard.TString(schema) ? `${acc}${exports.PatternString}` : TypeGuard.TLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : TypeGuard.TBoolean(schema) ? `${acc}${exports.PatternBoolean}` : Throw(`Unexpected Kind '${schema[exports.Kind]}'`);
+      }
+      function Create(kinds) {
+        return `^${kinds.map((schema) => Visit(schema, "")).join("")}$`;
+      }
+      TemplateLiteralPattern2.Create = Create;
+    })(TemplateLiteralPattern || (exports.TemplateLiteralPattern = TemplateLiteralPattern = {}));
+    var TemplateLiteralResolver;
+    (function(TemplateLiteralResolver2) {
+      function Resolve(template) {
+        const expression = TemplateLiteralParser.ParseExact(template.pattern);
+        if (!TemplateLiteralFinite.Check(expression))
+          return exports.Type.String();
+        const literals = [...TemplateLiteralGenerator.Generate(expression)].map((value) => exports.Type.Literal(value));
+        return exports.Type.Union(literals);
+      }
+      TemplateLiteralResolver2.Resolve = Resolve;
+    })(TemplateLiteralResolver || (exports.TemplateLiteralResolver = TemplateLiteralResolver = {}));
+    var TemplateLiteralParserError = class extends TypeBoxError {
+    };
+    exports.TemplateLiteralParserError = TemplateLiteralParserError;
+    var TemplateLiteralParser;
+    (function(TemplateLiteralParser2) {
+      function IsNonEscaped(pattern, index, char) {
+        return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+      }
+      function IsOpenParen(pattern, index) {
+        return IsNonEscaped(pattern, index, "(");
+      }
+      function IsCloseParen(pattern, index) {
+        return IsNonEscaped(pattern, index, ")");
+      }
+      function IsSeparator(pattern, index) {
+        return IsNonEscaped(pattern, index, "|");
+      }
+      function IsGroup(pattern) {
+        if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
+          return false;
+        let count = 0;
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            count += 1;
+          if (IsCloseParen(pattern, index))
+            count -= 1;
+          if (count === 0 && index !== pattern.length - 1)
+            return false;
+        }
+        return true;
+      }
+      function InGroup(pattern) {
+        return pattern.slice(1, pattern.length - 1);
+      }
+      function IsPrecedenceOr(pattern) {
+        let count = 0;
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            count += 1;
+          if (IsCloseParen(pattern, index))
+            count -= 1;
+          if (IsSeparator(pattern, index) && count === 0)
+            return true;
+        }
+        return false;
+      }
+      function IsPrecedenceAnd(pattern) {
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            return true;
+        }
+        return false;
+      }
+      function Or(pattern) {
+        let [count, start] = [0, 0];
+        const expressions = [];
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index))
+            count += 1;
+          if (IsCloseParen(pattern, index))
+            count -= 1;
+          if (IsSeparator(pattern, index) && count === 0) {
+            const range2 = pattern.slice(start, index);
+            if (range2.length > 0)
+              expressions.push(Parse(range2));
+            start = index + 1;
+          }
+        }
+        const range = pattern.slice(start);
+        if (range.length > 0)
+          expressions.push(Parse(range));
+        if (expressions.length === 0)
+          return { type: "const", const: "" };
+        if (expressions.length === 1)
+          return expressions[0];
+        return { type: "or", expr: expressions };
+      }
+      function And(pattern) {
+        function Group(value, index) {
+          if (!IsOpenParen(value, index))
+            throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+          let count = 0;
+          for (let scan = index; scan < value.length; scan++) {
+            if (IsOpenParen(value, scan))
+              count += 1;
+            if (IsCloseParen(value, scan))
+              count -= 1;
+            if (count === 0)
+              return [index, scan];
+          }
+          throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+        }
+        function Range(pattern2, index) {
+          for (let scan = index; scan < pattern2.length; scan++) {
+            if (IsOpenParen(pattern2, scan))
+              return [index, scan];
+          }
+          return [index, pattern2.length];
+        }
+        const expressions = [];
+        for (let index = 0; index < pattern.length; index++) {
+          if (IsOpenParen(pattern, index)) {
+            const [start, end] = Group(pattern, index);
+            const range = pattern.slice(start, end + 1);
+            expressions.push(Parse(range));
+            index = end;
+          } else {
+            const [start, end] = Range(pattern, index);
+            const range = pattern.slice(start, end);
+            if (range.length > 0)
+              expressions.push(Parse(range));
+            index = end - 1;
+          }
+        }
+        return expressions.length === 0 ? { type: "const", const: "" } : expressions.length === 1 ? expressions[0] : { type: "and", expr: expressions };
+      }
+      function Parse(pattern) {
+        return IsGroup(pattern) ? Parse(InGroup(pattern)) : IsPrecedenceOr(pattern) ? Or(pattern) : IsPrecedenceAnd(pattern) ? And(pattern) : { type: "const", const: pattern };
+      }
+      TemplateLiteralParser2.Parse = Parse;
+      function ParseExact(pattern) {
+        return Parse(pattern.slice(1, pattern.length - 1));
+      }
+      TemplateLiteralParser2.ParseExact = ParseExact;
+    })(TemplateLiteralParser || (exports.TemplateLiteralParser = TemplateLiteralParser = {}));
+    var TemplateLiteralFiniteError = class extends TypeBoxError {
+    };
+    exports.TemplateLiteralFiniteError = TemplateLiteralFiniteError;
+    var TemplateLiteralFinite;
+    (function(TemplateLiteralFinite2) {
+      function Throw(message) {
+        throw new TemplateLiteralFiniteError(message);
+      }
+      function IsNumber(expression) {
+        return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
+      }
+      function IsBoolean(expression) {
+        return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
+      }
+      function IsString(expression) {
+        return expression.type === "const" && expression.const === ".*";
+      }
+      function Check(expression) {
+        return IsBoolean(expression) ? true : IsNumber(expression) || IsString(expression) ? false : expression.type === "and" ? expression.expr.every((expr) => Check(expr)) : expression.type === "or" ? expression.expr.every((expr) => Check(expr)) : expression.type === "const" ? true : Throw(`Unknown expression type`);
+      }
+      TemplateLiteralFinite2.Check = Check;
+    })(TemplateLiteralFinite || (exports.TemplateLiteralFinite = TemplateLiteralFinite = {}));
+    var TemplateLiteralGeneratorError = class extends TypeBoxError {
+    };
+    exports.TemplateLiteralGeneratorError = TemplateLiteralGeneratorError;
+    var TemplateLiteralGenerator;
+    (function(TemplateLiteralGenerator2) {
+      function* Reduce(buffer) {
+        if (buffer.length === 1)
+          return yield* buffer[0];
+        for (const left of buffer[0]) {
+          for (const right of Reduce(buffer.slice(1))) {
+            yield `${left}${right}`;
+          }
+        }
+      }
+      function* And(expression) {
+        return yield* Reduce(expression.expr.map((expr) => [...Generate(expr)]));
+      }
+      function* Or(expression) {
+        for (const expr of expression.expr)
+          yield* Generate(expr);
+      }
+      function* Const(expression) {
+        return yield expression.const;
+      }
+      function* Generate(expression) {
+        return expression.type === "and" ? yield* And(expression) : expression.type === "or" ? yield* Or(expression) : expression.type === "const" ? yield* Const(expression) : (() => {
+          throw new TemplateLiteralGeneratorError("Unknown expression");
+        })();
+      }
+      TemplateLiteralGenerator2.Generate = Generate;
+    })(TemplateLiteralGenerator || (exports.TemplateLiteralGenerator = TemplateLiteralGenerator = {}));
+    var TemplateLiteralDslParser;
+    (function(TemplateLiteralDslParser2) {
+      function* ParseUnion(template) {
+        const trim = template.trim().replace(/"|'/g, "");
+        return trim === "boolean" ? yield exports.Type.Boolean() : trim === "number" ? yield exports.Type.Number() : trim === "bigint" ? yield exports.Type.BigInt() : trim === "string" ? yield exports.Type.String() : yield (() => {
+          const literals = trim.split("|").map((literal) => exports.Type.Literal(literal.trim()));
+          return literals.length === 0 ? exports.Type.Never() : literals.length === 1 ? literals[0] : exports.Type.Union(literals);
+        })();
+      }
+      function* ParseTerminal(template) {
+        if (template[1] !== "{") {
+          const L = exports.Type.Literal("$");
+          const R = ParseLiteral(template.slice(1));
+          return yield* [L, ...R];
+        }
+        for (let i = 2; i < template.length; i++) {
+          if (template[i] === "}") {
+            const L = ParseUnion(template.slice(2, i));
+            const R = ParseLiteral(template.slice(i + 1));
+            return yield* [...L, ...R];
+          }
+        }
+        yield exports.Type.Literal(template);
+      }
+      function* ParseLiteral(template) {
+        for (let i = 0; i < template.length; i++) {
+          if (template[i] === "$") {
+            const L = exports.Type.Literal(template.slice(0, i));
+            const R = ParseTerminal(template.slice(i));
+            return yield* [L, ...R];
+          }
+        }
+        yield exports.Type.Literal(template);
+      }
+      function Parse(template_dsl) {
+        return [...ParseLiteral(template_dsl)];
+      }
+      TemplateLiteralDslParser2.Parse = Parse;
+    })(TemplateLiteralDslParser || (exports.TemplateLiteralDslParser = TemplateLiteralDslParser = {}));
+    var TransformDecodeBuilder = class {
+      constructor(schema) {
+        this.schema = schema;
+      }
+      Decode(decode) {
+        return new TransformEncodeBuilder(this.schema, decode);
+      }
+    };
+    exports.TransformDecodeBuilder = TransformDecodeBuilder;
+    var TransformEncodeBuilder = class {
+      constructor(schema, decode) {
+        this.schema = schema;
+        this.decode = decode;
+      }
+      Encode(encode) {
+        const schema = TypeClone.Type(this.schema);
+        return TypeGuard.TTransform(schema) ? (() => {
+          const Encode = (value) => schema[exports.Transform].Encode(encode(value));
+          const Decode = (value) => this.decode(schema[exports.Transform].Decode(value));
+          const Codec = { Encode, Decode };
+          return { ...schema, [exports.Transform]: Codec };
+        })() : (() => {
+          const Codec = { Decode: this.decode, Encode: encode };
+          return { ...schema, [exports.Transform]: Codec };
+        })();
+      }
+    };
+    exports.TransformEncodeBuilder = TransformEncodeBuilder;
+    var TypeOrdinal = 0;
+    var TypeBuilderError = class extends TypeBoxError {
+    };
+    exports.TypeBuilderError = TypeBuilderError;
+    var TypeBuilder = class {
+      /** `[Internal]` Creates a schema without `static` and `params` types */
+      Create(schema) {
+        return schema;
+      }
+      /** `[Internal]` Throws a TypeBuilder error with the given message */
+      Throw(message) {
+        throw new TypeBuilderError(message);
+      }
+      /** `[Internal]` Discards property keys from the given record type */
+      Discard(record, keys) {
+        return keys.reduce((acc, key) => {
+          const { [key]: _, ...rest } = acc;
+          return rest;
+        }, record);
+      }
+      /** `[Json]` Omits compositing symbols from this schema */
+      Strict(schema) {
+        return JSON.parse(JSON.stringify(schema));
+      }
+    };
+    exports.TypeBuilder = TypeBuilder;
+    var JsonTypeBuilder = class extends TypeBuilder {
+      // ------------------------------------------------------------------------
+      // Modifiers
+      // ------------------------------------------------------------------------
+      /** `[Json]` Creates a Readonly and Optional property */
+      ReadonlyOptional(schema) {
+        return this.Readonly(this.Optional(schema));
+      }
+      /** `[Json]` Creates a Readonly property */
+      Readonly(schema) {
+        return { ...TypeClone.Type(schema), [exports.Readonly]: "Readonly" };
+      }
+      /** `[Json]` Creates an Optional property */
+      Optional(schema) {
+        return { ...TypeClone.Type(schema), [exports.Optional]: "Optional" };
+      }
+      // ------------------------------------------------------------------------
+      // Types
+      // ------------------------------------------------------------------------
+      /** `[Json]` Creates an Any type */
+      Any(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Any" });
+      }
+      /** `[Json]` Creates an Array type */
+      Array(schema, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Array", type: "array", items: TypeClone.Type(schema) });
+      }
+      /** `[Json]` Creates a Boolean type */
+      Boolean(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Boolean", type: "boolean" });
+      }
+      /** `[Json]` Intrinsic function to Capitalize LiteralString types */
+      Capitalize(schema, options = {}) {
+        return { ...Intrinsic.Map(TypeClone.Type(schema), "Capitalize"), ...options };
+      }
+      /** `[Json]` Creates a Composite object type */
+      Composite(objects, options) {
+        const intersect = exports.Type.Intersect(objects, {});
+        const keys = KeyResolver.ResolveKeys(intersect, { includePatterns: false });
+        const properties = keys.reduce((acc, key) => ({ ...acc, [key]: exports.Type.Index(intersect, [key]) }), {});
+        return exports.Type.Object(properties, options);
+      }
+      /** `[Json]` Creates a Enum type */
+      Enum(item, options = {}) {
+        if (ValueGuard.IsUndefined(item))
+          return this.Throw("Enum undefined or empty");
+        const values1 = Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
+        const values2 = [...new Set(values1)];
+        const anyOf = values2.map((value) => exports.Type.Literal(value));
+        return this.Union(anyOf, { ...options, [exports.Hint]: "Enum" });
+      }
+      /** `[Json]` Creates a Conditional type */
+      Extends(left, right, trueType, falseType, options = {}) {
+        switch (TypeExtends.Extends(left, right)) {
+          case TypeExtendsResult.Union:
+            return this.Union([TypeClone.Type(trueType, options), TypeClone.Type(falseType, options)]);
+          case TypeExtendsResult.True:
+            return TypeClone.Type(trueType, options);
+          case TypeExtendsResult.False:
+            return TypeClone.Type(falseType, options);
+        }
+      }
+      /** `[Json]` Constructs a type by excluding from unionType all union members that are assignable to excludedMembers */
+      Exclude(unionType, excludedMembers, options = {}) {
+        return TypeGuard.TTemplateLiteral(unionType) ? this.Exclude(TemplateLiteralResolver.Resolve(unionType), excludedMembers, options) : TypeGuard.TTemplateLiteral(excludedMembers) ? this.Exclude(unionType, TemplateLiteralResolver.Resolve(excludedMembers), options) : TypeGuard.TUnion(unionType) ? (() => {
+          const narrowed = unionType.anyOf.filter((inner) => TypeExtends.Extends(inner, excludedMembers) === TypeExtendsResult.False);
+          return narrowed.length === 1 ? TypeClone.Type(narrowed[0], options) : this.Union(narrowed, options);
+        })() : TypeExtends.Extends(unionType, excludedMembers) !== TypeExtendsResult.False ? this.Never(options) : TypeClone.Type(unionType, options);
+      }
+      /** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
+      Extract(type, union, options = {}) {
+        return TypeGuard.TTemplateLiteral(type) ? this.Extract(TemplateLiteralResolver.Resolve(type), union, options) : TypeGuard.TTemplateLiteral(union) ? this.Extract(type, TemplateLiteralResolver.Resolve(union), options) : TypeGuard.TUnion(type) ? (() => {
+          const narrowed = type.anyOf.filter((inner) => TypeExtends.Extends(inner, union) !== TypeExtendsResult.False);
+          return narrowed.length === 1 ? TypeClone.Type(narrowed[0], options) : this.Union(narrowed, options);
+        })() : TypeExtends.Extends(type, union) !== TypeExtendsResult.False ? TypeClone.Type(type, options) : this.Never(options);
+      }
+      /** `[Json]` Returns an Indexed property type for the given keys */
+      Index(schema, unresolved, options = {}) {
+        return TypeGuard.TArray(schema) && TypeGuard.TNumber(unresolved) ? (() => {
+          return TypeClone.Type(schema.items, options);
+        })() : TypeGuard.TTuple(schema) && TypeGuard.TNumber(unresolved) ? (() => {
+          const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
+          const cloned = items.map((schema2) => TypeClone.Type(schema2));
+          return this.Union(cloned, options);
+        })() : (() => {
+          const keys = KeyArrayResolver.Resolve(unresolved);
+          const clone = TypeClone.Type(schema);
+          return IndexedAccessor.Resolve(clone, keys, options);
+        })();
+      }
+      /** `[Json]` Creates an Integer type */
+      Integer(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Integer", type: "integer" });
+      }
+      /** `[Json]` Creates an Intersect type */
+      Intersect(allOf, options = {}) {
+        if (allOf.length === 0)
+          return exports.Type.Never();
+        if (allOf.length === 1)
+          return TypeClone.Type(allOf[0], options);
+        if (allOf.some((schema) => TypeGuard.TTransform(schema)))
+          this.Throw("Cannot intersect transform types");
+        const objects = allOf.every((schema) => TypeGuard.TObject(schema));
+        const cloned = TypeClone.Rest(allOf);
+        const clonedUnevaluatedProperties = TypeGuard.TSchema(options.unevaluatedProperties) ? { unevaluatedProperties: TypeClone.Type(options.unevaluatedProperties) } : {};
+        return options.unevaluatedProperties === false || TypeGuard.TSchema(options.unevaluatedProperties) || objects ? this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: "Intersect", type: "object", allOf: cloned }) : this.Create({ ...options, ...clonedUnevaluatedProperties, [exports.Kind]: "Intersect", allOf: cloned });
+      }
+      /** `[Json]` Creates a KeyOf type */
+      KeyOf(schema, options = {}) {
+        return TypeGuard.TRecord(schema) ? (() => {
+          const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+          return pattern === exports.PatternNumberExact ? this.Number(options) : pattern === exports.PatternStringExact ? this.String(options) : this.Throw("Unable to resolve key type from Record key pattern");
+        })() : TypeGuard.TTuple(schema) ? (() => {
+          const items = ValueGuard.IsUndefined(schema.items) ? [] : schema.items;
+          const literals = items.map((_, index) => exports.Type.Literal(index.toString()));
+          return this.Union(literals, options);
+        })() : TypeGuard.TArray(schema) ? (() => {
+          return this.Number(options);
+        })() : (() => {
+          const keys = KeyResolver.ResolveKeys(schema, { includePatterns: false });
+          if (keys.length === 0)
+            return this.Never(options);
+          const literals = keys.map((key) => this.Literal(key));
+          return this.Union(literals, options);
+        })();
+      }
+      /** `[Json]` Creates a Literal type */
+      Literal(value, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Literal", const: value, type: typeof value });
+      }
+      /** `[Json]` Intrinsic function to Lowercase LiteralString types */
+      Lowercase(schema, options = {}) {
+        return { ...Intrinsic.Map(TypeClone.Type(schema), "Lowercase"), ...options };
+      }
+      /** `[Json]` Creates a Never type */
+      Never(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Never", not: {} });
+      }
+      /** `[Json]` Creates a Not type */
+      Not(schema, options) {
+        return this.Create({ ...options, [exports.Kind]: "Not", not: TypeClone.Type(schema) });
+      }
+      /** `[Json]` Creates a Null type */
+      Null(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Null", type: "null" });
+      }
+      /** `[Json]` Creates a Number type */
+      Number(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Number", type: "number" });
+      }
+      /** `[Json]` Creates an Object type */
+      Object(properties, options = {}) {
+        const propertyKeys = Object.getOwnPropertyNames(properties);
+        const optionalKeys = propertyKeys.filter((key) => TypeGuard.TOptional(properties[key]));
+        const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
+        const clonedAdditionalProperties = TypeGuard.TSchema(options.additionalProperties) ? { additionalProperties: TypeClone.Type(options.additionalProperties) } : {};
+        const clonedProperties = propertyKeys.reduce((acc, key) => ({ ...acc, [key]: TypeClone.Type(properties[key]) }), {});
+        return requiredKeys.length > 0 ? this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: "Object", type: "object", properties: clonedProperties, required: requiredKeys }) : this.Create({ ...options, ...clonedAdditionalProperties, [exports.Kind]: "Object", type: "object", properties: clonedProperties });
+      }
+      /** `[Json]` Constructs a type whose keys are omitted from the given type */
+      Omit(schema, unresolved, options = {}) {
+        const keys = KeyArrayResolver.Resolve(unresolved);
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ["$id", exports.Transform]), (object) => {
+          if (ValueGuard.IsArray(object.required)) {
+            object.required = object.required.filter((key) => !keys.includes(key));
+            if (object.required.length === 0)
+              delete object.required;
+          }
+          for (const key of Object.getOwnPropertyNames(object.properties)) {
+            if (keys.includes(key))
+              delete object.properties[key];
+          }
+          return this.Create(object);
+        }, options);
+      }
+      /** `[Json]` Constructs a type where all properties are optional */
+      Partial(schema, options = {}) {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ["$id", exports.Transform]), (object) => {
+          const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
+            return { ...acc, [key]: this.Optional(object.properties[key]) };
+          }, {});
+          return this.Object(
+            properties,
+            this.Discard(object, ["required"])
+            /* object used as options to retain other constraints */
+          );
+        }, options);
+      }
+      /** `[Json]` Constructs a type whose keys are picked from the given type */
+      Pick(schema, unresolved, options = {}) {
+        const keys = KeyArrayResolver.Resolve(unresolved);
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ["$id", exports.Transform]), (object) => {
+          if (ValueGuard.IsArray(object.required)) {
+            object.required = object.required.filter((key) => keys.includes(key));
+            if (object.required.length === 0)
+              delete object.required;
+          }
+          for (const key of Object.getOwnPropertyNames(object.properties)) {
+            if (!keys.includes(key))
+              delete object.properties[key];
+          }
+          return this.Create(object);
+        }, options);
+      }
+      /** `[Json]` Creates a Record type */
+      Record(key, schema, options = {}) {
+        return TypeGuard.TTemplateLiteral(key) ? (() => {
+          const expression = TemplateLiteralParser.ParseExact(key.pattern);
+          return TemplateLiteralFinite.Check(expression) ? this.Object([...TemplateLiteralGenerator.Generate(expression)].reduce((acc, key2) => ({ ...acc, [key2]: TypeClone.Type(schema) }), {}), options) : this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [key.pattern]: TypeClone.Type(schema) } });
+        })() : TypeGuard.TUnion(key) ? (() => {
+          const union = UnionResolver.Resolve(key);
+          if (TypeGuard.TUnionLiteral(union)) {
+            const properties = union.anyOf.reduce((acc, literal) => ({ ...acc, [literal.const]: TypeClone.Type(schema) }), {});
+            return this.Object(properties, { ...options, [exports.Hint]: "Record" });
+          } else
+            this.Throw("Record key of type union contains non-literal types");
+        })() : TypeGuard.TLiteral(key) ? (() => {
+          return ValueGuard.IsString(key.const) || ValueGuard.IsNumber(key.const) ? this.Object({ [key.const]: TypeClone.Type(schema) }, options) : this.Throw("Record key of type literal is not of type string or number");
+        })() : TypeGuard.TInteger(key) || TypeGuard.TNumber(key) ? (() => {
+          return this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [exports.PatternNumberExact]: TypeClone.Type(schema) } });
+        })() : TypeGuard.TString(key) ? (() => {
+          const pattern = ValueGuard.IsUndefined(key.pattern) ? exports.PatternStringExact : key.pattern;
+          return this.Create({ ...options, [exports.Kind]: "Record", type: "object", patternProperties: { [pattern]: TypeClone.Type(schema) } });
+        })() : this.Never();
+      }
+      /** `[Json]` Creates a Recursive type */
+      Recursive(callback, options = {}) {
+        if (ValueGuard.IsUndefined(options.$id))
+          options.$id = `T${TypeOrdinal++}`;
+        const thisType = callback({ [exports.Kind]: "This", $ref: `${options.$id}` });
+        thisType.$id = options.$id;
+        return this.Create({ ...options, [exports.Hint]: "Recursive", ...thisType });
+      }
+      /** `[Json]` Creates a Ref type. */
+      Ref(unresolved, options = {}) {
+        if (ValueGuard.IsString(unresolved))
+          return this.Create({ ...options, [exports.Kind]: "Ref", $ref: unresolved });
+        if (ValueGuard.IsUndefined(unresolved.$id))
+          this.Throw("Reference target type must specify an $id");
+        return this.Create({ ...options, [exports.Kind]: "Ref", $ref: unresolved.$id });
+      }
+      /** `[Json]` Constructs a type where all properties are required */
+      Required(schema, options = {}) {
+        return ObjectMap.Map(this.Discard(TypeClone.Type(schema), ["$id", exports.Transform]), (object) => {
+          const properties = Object.getOwnPropertyNames(object.properties).reduce((acc, key) => {
+            return { ...acc, [key]: this.Discard(object.properties[key], [exports.Optional]) };
+          }, {});
+          return this.Object(
+            properties,
+            object
+            /* object used as options to retain other constraints  */
+          );
+        }, options);
+      }
+      /** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
+      Rest(schema) {
+        return TypeGuard.TTuple(schema) && !ValueGuard.IsUndefined(schema.items) ? TypeClone.Rest(schema.items) : TypeGuard.TIntersect(schema) ? TypeClone.Rest(schema.allOf) : TypeGuard.TUnion(schema) ? TypeClone.Rest(schema.anyOf) : [];
+      }
+      /** `[Json]` Creates a String type */
+      String(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "String", type: "string" });
+      }
+      /** `[Json]` Creates a TemplateLiteral type */
+      TemplateLiteral(unresolved, options = {}) {
+        const pattern = ValueGuard.IsString(unresolved) ? TemplateLiteralPattern.Create(TemplateLiteralDslParser.Parse(unresolved)) : TemplateLiteralPattern.Create(unresolved);
+        return this.Create({ ...options, [exports.Kind]: "TemplateLiteral", type: "string", pattern });
+      }
+      /** `[Json]` Creates a Transform type */
+      Transform(schema) {
+        return new TransformDecodeBuilder(schema);
+      }
+      /** `[Json]` Creates a Tuple type */
+      Tuple(items, options = {}) {
+        const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
+        const clonedItems = TypeClone.Rest(items);
+        const schema = items.length > 0 ? { ...options, [exports.Kind]: "Tuple", type: "array", items: clonedItems, additionalItems, minItems, maxItems } : { ...options, [exports.Kind]: "Tuple", type: "array", minItems, maxItems };
+        return this.Create(schema);
+      }
+      /** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+      Uncapitalize(schema, options = {}) {
+        return { ...Intrinsic.Map(TypeClone.Type(schema), "Uncapitalize"), ...options };
+      }
+      /** `[Json]` Creates a Union type */
+      Union(union, options = {}) {
+        return TypeGuard.TTemplateLiteral(union) ? TemplateLiteralResolver.Resolve(union) : (() => {
+          const anyOf = union;
+          if (anyOf.length === 0)
+            return this.Never(options);
+          if (anyOf.length === 1)
+            return this.Create(TypeClone.Type(anyOf[0], options));
+          const clonedAnyOf = TypeClone.Rest(anyOf);
+          return this.Create({ ...options, [exports.Kind]: "Union", anyOf: clonedAnyOf });
+        })();
+      }
+      /** `[Json]` Creates an Unknown type */
+      Unknown(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Unknown" });
+      }
+      /** `[Json]` Creates a Unsafe type that will infers as the generic argument T */
+      Unsafe(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: options[exports.Kind] || "Unsafe" });
+      }
+      /** `[Json]` Intrinsic function to Uppercase LiteralString types */
+      Uppercase(schema, options = {}) {
+        return { ...Intrinsic.Map(TypeClone.Type(schema), "Uppercase"), ...options };
+      }
+    };
+    exports.JsonTypeBuilder = JsonTypeBuilder;
+    var JavaScriptTypeBuilder = class extends JsonTypeBuilder {
+      /** `[JavaScript]` Creates a AsyncIterator type */
+      AsyncIterator(items, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "AsyncIterator", type: "AsyncIterator", items: TypeClone.Type(items) });
+      }
+      /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
+      Awaited(schema, options = {}) {
+        const Unwrap = (rest) => rest.length > 0 ? (() => {
+          const [L, ...R] = rest;
+          return [this.Awaited(L), ...Unwrap(R)];
+        })() : rest;
+        return TypeGuard.TIntersect(schema) ? exports.Type.Intersect(Unwrap(schema.allOf)) : TypeGuard.TUnion(schema) ? exports.Type.Union(Unwrap(schema.anyOf)) : TypeGuard.TPromise(schema) ? this.Awaited(schema.item) : TypeClone.Type(schema, options);
+      }
+      /** `[JavaScript]` Creates a BigInt type */
+      BigInt(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "BigInt", type: "bigint" });
+      }
+      /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
+      ConstructorParameters(schema, options = {}) {
+        return this.Tuple([...schema.parameters], { ...options });
+      }
+      /** `[JavaScript]` Creates a Constructor type */
+      Constructor(parameters, returns, options) {
+        const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)];
+        return this.Create({ ...options, [exports.Kind]: "Constructor", type: "Constructor", parameters: clonedParameters, returns: clonedReturns });
+      }
+      /** `[JavaScript]` Creates a Date type */
+      Date(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Date", type: "Date" });
+      }
+      /** `[JavaScript]` Creates a Function type */
+      Function(parameters, returns, options) {
+        const [clonedParameters, clonedReturns] = [TypeClone.Rest(parameters), TypeClone.Type(returns)];
+        return this.Create({ ...options, [exports.Kind]: "Function", type: "Function", parameters: clonedParameters, returns: clonedReturns });
+      }
+      /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+      InstanceType(schema, options = {}) {
+        return TypeClone.Type(schema.returns, options);
+      }
+      /** `[JavaScript]` Creates an Iterator type */
+      Iterator(items, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Iterator", type: "Iterator", items: TypeClone.Type(items) });
+      }
+      /** `[JavaScript]` Extracts the Parameters from the given Function type */
+      Parameters(schema, options = {}) {
+        return this.Tuple(schema.parameters, { ...options });
+      }
+      /** `[JavaScript]` Creates a Promise type */
+      Promise(item, options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Promise", type: "Promise", item: TypeClone.Type(item) });
+      }
+      /** `[Extended]` Creates a String type */
+      RegExp(unresolved, options = {}) {
+        const pattern = ValueGuard.IsString(unresolved) ? unresolved : unresolved.source;
+        return this.Create({ ...options, [exports.Kind]: "String", type: "string", pattern });
+      }
+      /**
+       * @deprecated Use `Type.RegExp`
+       */
+      RegEx(regex, options = {}) {
+        return this.RegExp(regex, options);
+      }
+      /** `[JavaScript]` Extracts the ReturnType from the given Function type */
+      ReturnType(schema, options = {}) {
+        return TypeClone.Type(schema.returns, options);
+      }
+      /** `[JavaScript]` Creates a Symbol type */
+      Symbol(options) {
+        return this.Create({ ...options, [exports.Kind]: "Symbol", type: "symbol" });
+      }
+      /** `[JavaScript]` Creates a Undefined type */
+      Undefined(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Undefined", type: "undefined" });
+      }
+      /** `[JavaScript]` Creates a Uint8Array type */
+      Uint8Array(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Uint8Array", type: "Uint8Array" });
+      }
+      /** `[JavaScript]` Creates a Void type */
+      Void(options = {}) {
+        return this.Create({ ...options, [exports.Kind]: "Void", type: "void" });
+      }
+    };
+    exports.JavaScriptTypeBuilder = JavaScriptTypeBuilder;
+    exports.JsonType = new JsonTypeBuilder();
+    exports.Type = new JavaScriptTypeBuilder();
+  }
+});
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/value/guard.js
+var require_guard = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/value/guard.js"(exports) {
+    "use strict";
+    init_dirname();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.IsValueType = exports.IsSymbol = exports.IsFunction = exports.IsString = exports.IsBigInt = exports.IsInteger = exports.IsNumber = exports.IsBoolean = exports.IsNull = exports.IsUndefined = exports.IsArray = exports.IsObject = exports.IsPlainObject = exports.HasPropertyKey = exports.IsDate = exports.IsUint8Array = exports.IsPromise = exports.IsTypedArray = exports.IsIterator = exports.IsAsyncIterator = void 0;
+    function IsAsyncIterator(value) {
+      return IsObject(value) && Symbol.asyncIterator in value;
+    }
+    exports.IsAsyncIterator = IsAsyncIterator;
+    function IsIterator(value) {
+      return IsObject(value) && Symbol.iterator in value;
+    }
+    exports.IsIterator = IsIterator;
+    function IsTypedArray(value) {
+      return ArrayBuffer.isView(value);
+    }
+    exports.IsTypedArray = IsTypedArray;
+    function IsPromise(value) {
+      return value instanceof Promise;
+    }
+    exports.IsPromise = IsPromise;
+    function IsUint8Array(value) {
+      return value instanceof Uint8Array;
+    }
+    exports.IsUint8Array = IsUint8Array;
+    function IsDate(value) {
+      return value instanceof Date && Number.isFinite(value.getTime());
+    }
+    exports.IsDate = IsDate;
+    function HasPropertyKey(value, key) {
+      return key in value;
+    }
+    exports.HasPropertyKey = HasPropertyKey;
+    function IsPlainObject(value) {
+      return IsObject(value) && IsFunction(value.constructor) && value.constructor.name === "Object";
+    }
+    exports.IsPlainObject = IsPlainObject;
+    function IsObject(value) {
+      return value !== null && typeof value === "object";
+    }
+    exports.IsObject = IsObject;
+    function IsArray(value) {
+      return Array.isArray(value) && !ArrayBuffer.isView(value);
+    }
+    exports.IsArray = IsArray;
+    function IsUndefined(value) {
+      return value === void 0;
+    }
+    exports.IsUndefined = IsUndefined;
+    function IsNull(value) {
+      return value === null;
+    }
+    exports.IsNull = IsNull;
+    function IsBoolean(value) {
+      return typeof value === "boolean";
+    }
+    exports.IsBoolean = IsBoolean;
+    function IsNumber(value) {
+      return typeof value === "number";
+    }
+    exports.IsNumber = IsNumber;
+    function IsInteger(value) {
+      return IsNumber(value) && Number.isInteger(value);
+    }
+    exports.IsInteger = IsInteger;
+    function IsBigInt(value) {
+      return typeof value === "bigint";
+    }
+    exports.IsBigInt = IsBigInt;
+    function IsString(value) {
+      return typeof value === "string";
+    }
+    exports.IsString = IsString;
+    function IsFunction(value) {
+      return typeof value === "function";
+    }
+    exports.IsFunction = IsFunction;
+    function IsSymbol(value) {
+      return typeof value === "symbol";
+    }
+    exports.IsSymbol = IsSymbol;
+    function IsValueType(value) {
+      return IsBigInt(value) || IsBoolean(value) || IsNull(value) || IsNumber(value) || IsString(value) || IsSymbol(value) || IsUndefined(value);
+    }
+    exports.IsValueType = IsValueType;
+  }
+});
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/system/system.js
+var require_system = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/system/system.js"(exports) {
+    "use strict";
+    init_dirname();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DefaultErrorFunction = exports.TypeSystemPolicy = exports.TypeSystemErrorFunction = exports.TypeSystem = exports.TypeSystemDuplicateFormat = exports.TypeSystemDuplicateTypeKind = void 0;
+    var guard_1 = require_guard();
+    var errors_1 = require_errors();
+    var Types = require_typebox();
+    var TypeSystemDuplicateTypeKind = class extends Types.TypeBoxError {
+      constructor(kind) {
+        super(`Duplicate type kind '${kind}' detected`);
+      }
+    };
+    exports.TypeSystemDuplicateTypeKind = TypeSystemDuplicateTypeKind;
+    var TypeSystemDuplicateFormat = class extends Types.TypeBoxError {
+      constructor(kind) {
+        super(`Duplicate string format '${kind}' detected`);
+      }
+    };
+    exports.TypeSystemDuplicateFormat = TypeSystemDuplicateFormat;
+    var TypeSystem;
+    (function(TypeSystem2) {
+      function Type2(kind, check) {
+        if (Types.TypeRegistry.Has(kind))
+          throw new TypeSystemDuplicateTypeKind(kind);
+        Types.TypeRegistry.Set(kind, check);
+        return (options = {}) => Types.Type.Unsafe({ ...options, [Types.Kind]: kind });
+      }
+      TypeSystem2.Type = Type2;
+      function Format(format, check) {
+        if (Types.FormatRegistry.Has(format))
+          throw new TypeSystemDuplicateFormat(format);
+        Types.FormatRegistry.Set(format, check);
+        return format;
+      }
+      TypeSystem2.Format = Format;
+    })(TypeSystem || (exports.TypeSystem = TypeSystem = {}));
+    var TypeSystemErrorFunction;
+    (function(TypeSystemErrorFunction2) {
+      let errorMessageFunction = DefaultErrorFunction;
+      function Reset() {
+        errorMessageFunction = DefaultErrorFunction;
+      }
+      TypeSystemErrorFunction2.Reset = Reset;
+      function Set2(callback) {
+        errorMessageFunction = callback;
+      }
+      TypeSystemErrorFunction2.Set = Set2;
+      function Get() {
+        return errorMessageFunction;
+      }
+      TypeSystemErrorFunction2.Get = Get;
+    })(TypeSystemErrorFunction || (exports.TypeSystemErrorFunction = TypeSystemErrorFunction = {}));
+    var TypeSystemPolicy;
+    (function(TypeSystemPolicy2) {
+      TypeSystemPolicy2.ExactOptionalPropertyTypes = false;
+      TypeSystemPolicy2.AllowArrayObject = false;
+      TypeSystemPolicy2.AllowNaN = false;
+      TypeSystemPolicy2.AllowNullVoid = false;
+      function IsExactOptionalProperty(value, key) {
+        return TypeSystemPolicy2.ExactOptionalPropertyTypes ? key in value : value[key] !== void 0;
+      }
+      TypeSystemPolicy2.IsExactOptionalProperty = IsExactOptionalProperty;
+      function IsObjectLike(value) {
+        const isObject = (0, guard_1.IsObject)(value);
+        return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !(0, guard_1.IsArray)(value);
+      }
+      TypeSystemPolicy2.IsObjectLike = IsObjectLike;
+      function IsRecordLike(value) {
+        return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+      }
+      TypeSystemPolicy2.IsRecordLike = IsRecordLike;
+      function IsNumberLike(value) {
+        const isNumber = (0, guard_1.IsNumber)(value);
+        return TypeSystemPolicy2.AllowNaN ? isNumber : isNumber && Number.isFinite(value);
+      }
+      TypeSystemPolicy2.IsNumberLike = IsNumberLike;
+      function IsVoidLike(value) {
+        const isUndefined = (0, guard_1.IsUndefined)(value);
+        return TypeSystemPolicy2.AllowNullVoid ? isUndefined || value === null : isUndefined;
+      }
+      TypeSystemPolicy2.IsVoidLike = IsVoidLike;
+    })(TypeSystemPolicy || (exports.TypeSystemPolicy = TypeSystemPolicy = {}));
+    function DefaultErrorFunction(schema, errorType) {
+      switch (errorType) {
+        case errors_1.ValueErrorType.ArrayContains:
+          return "Expected array to contain at least one matching value";
+        case errors_1.ValueErrorType.ArrayMaxContains:
+          return `Expected array to contain no more than ${schema.maxContains} matching values`;
+        case errors_1.ValueErrorType.ArrayMinContains:
+          return `Expected array to contain at least ${schema.minContains} matching values`;
+        case errors_1.ValueErrorType.ArrayMaxItems:
+          return `Expected array length to be less or equal to ${schema.maxItems}`;
+        case errors_1.ValueErrorType.ArrayMinItems:
+          return `Expected array length to be greater or equal to ${schema.minItems}`;
+        case errors_1.ValueErrorType.ArrayUniqueItems:
+          return "Expected array elements to be unique";
+        case errors_1.ValueErrorType.Array:
+          return "Expected array";
+        case errors_1.ValueErrorType.AsyncIterator:
+          return "Expected AsyncIterator";
+        case errors_1.ValueErrorType.BigIntExclusiveMaximum:
+          return `Expected bigint to be less than ${schema.exclusiveMaximum}`;
+        case errors_1.ValueErrorType.BigIntExclusiveMinimum:
+          return `Expected bigint to be greater than ${schema.exclusiveMinimum}`;
+        case errors_1.ValueErrorType.BigIntMaximum:
+          return `Expected bigint to be less or equal to ${schema.maximum}`;
+        case errors_1.ValueErrorType.BigIntMinimum:
+          return `Expected bigint to be greater or equal to ${schema.minimum}`;
+        case errors_1.ValueErrorType.BigIntMultipleOf:
+          return `Expected bigint to be a multiple of ${schema.multipleOf}`;
+        case errors_1.ValueErrorType.BigInt:
+          return "Expected bigint";
+        case errors_1.ValueErrorType.Boolean:
+          return "Expected boolean";
+        case errors_1.ValueErrorType.DateExclusiveMinimumTimestamp:
+          return `Expected Date timestamp to be greater than ${schema.exclusiveMinimumTimestamp}`;
+        case errors_1.ValueErrorType.DateExclusiveMaximumTimestamp:
+          return `Expected Date timestamp to be less than ${schema.exclusiveMaximumTimestamp}`;
+        case errors_1.ValueErrorType.DateMinimumTimestamp:
+          return `Expected Date timestamp to be greater or equal to ${schema.minimumTimestamp}`;
+        case errors_1.ValueErrorType.DateMaximumTimestamp:
+          return `Expected Date timestamp to be less or equal to ${schema.maximumTimestamp}`;
+        case errors_1.ValueErrorType.DateMultipleOfTimestamp:
+          return `Expected Date timestamp to be a multiple of ${schema.multipleOfTimestamp}`;
+        case errors_1.ValueErrorType.Date:
+          return "Expected Date";
+        case errors_1.ValueErrorType.Function:
+          return "Expected function";
+        case errors_1.ValueErrorType.IntegerExclusiveMaximum:
+          return `Expected integer to be less than ${schema.exclusiveMaximum}`;
+        case errors_1.ValueErrorType.IntegerExclusiveMinimum:
+          return `Expected integer to be greater than ${schema.exclusiveMinimum}`;
+        case errors_1.ValueErrorType.IntegerMaximum:
+          return `Expected integer to be less or equal to ${schema.maximum}`;
+        case errors_1.ValueErrorType.IntegerMinimum:
+          return `Expected integer to be greater or equal to ${schema.minimum}`;
+        case errors_1.ValueErrorType.IntegerMultipleOf:
+          return `Expected integer to be a multiple of ${schema.multipleOf}`;
+        case errors_1.ValueErrorType.Integer:
+          return "Expected integer";
+        case errors_1.ValueErrorType.IntersectUnevaluatedProperties:
+          return "Unexpected property";
+        case errors_1.ValueErrorType.Intersect:
+          return "Expected all values to match";
+        case errors_1.ValueErrorType.Iterator:
+          return "Expected Iterator";
+        case errors_1.ValueErrorType.Literal:
+          return `Expected ${typeof schema.const === "string" ? `'${schema.const}'` : schema.const}`;
+        case errors_1.ValueErrorType.Never:
+          return "Never";
+        case errors_1.ValueErrorType.Not:
+          return "Value should not match";
+        case errors_1.ValueErrorType.Null:
+          return "Expected null";
+        case errors_1.ValueErrorType.NumberExclusiveMaximum:
+          return `Expected number to be less than ${schema.exclusiveMaximum}`;
+        case errors_1.ValueErrorType.NumberExclusiveMinimum:
+          return `Expected number to be greater than ${schema.exclusiveMinimum}`;
+        case errors_1.ValueErrorType.NumberMaximum:
+          return `Expected number to be less or equal to ${schema.maximum}`;
+        case errors_1.ValueErrorType.NumberMinimum:
+          return `Expected number to be greater or equal to ${schema.minimum}`;
+        case errors_1.ValueErrorType.NumberMultipleOf:
+          return `Expected number to be a multiple of ${schema.multipleOf}`;
+        case errors_1.ValueErrorType.Number:
+          return "Expected number";
+        case errors_1.ValueErrorType.Object:
+          return "Expected object";
+        case errors_1.ValueErrorType.ObjectAdditionalProperties:
+          return "Unexpected property";
+        case errors_1.ValueErrorType.ObjectMaxProperties:
+          return `Expected object to have no more than ${schema.maxProperties} properties`;
+        case errors_1.ValueErrorType.ObjectMinProperties:
+          return `Expected object to have at least ${schema.minProperties} properties`;
+        case errors_1.ValueErrorType.ObjectRequiredProperty:
+          return "Required property";
+        case errors_1.ValueErrorType.Promise:
+          return "Expected Promise";
+        case errors_1.ValueErrorType.StringFormatUnknown:
+          return `Unknown format '${schema.format}'`;
+        case errors_1.ValueErrorType.StringFormat:
+          return `Expected string to match '${schema.format}' format`;
+        case errors_1.ValueErrorType.StringMaxLength:
+          return `Expected string length less or equal to ${schema.maxLength}`;
+        case errors_1.ValueErrorType.StringMinLength:
+          return `Expected string length greater or equal to ${schema.minLength}`;
+        case errors_1.ValueErrorType.StringPattern:
+          return `Expected string to match '${schema.pattern}'`;
+        case errors_1.ValueErrorType.String:
+          return "Expected string";
+        case errors_1.ValueErrorType.Symbol:
+          return "Expected symbol";
+        case errors_1.ValueErrorType.TupleLength:
+          return `Expected tuple to have ${schema.maxItems || 0} elements`;
+        case errors_1.ValueErrorType.Tuple:
+          return "Expected tuple";
+        case errors_1.ValueErrorType.Uint8ArrayMaxByteLength:
+          return `Expected byte length less or equal to ${schema.maxByteLength}`;
+        case errors_1.ValueErrorType.Uint8ArrayMinByteLength:
+          return `Expected byte length greater or equal to ${schema.minByteLength}`;
+        case errors_1.ValueErrorType.Uint8Array:
+          return "Expected Uint8Array";
+        case errors_1.ValueErrorType.Undefined:
+          return "Expected undefined";
+        case errors_1.ValueErrorType.Union:
+          return "Expected union value";
+        case errors_1.ValueErrorType.Void:
+          return "Expected void";
+        case errors_1.ValueErrorType.Kind:
+          return `Expected kind '${schema[Types.Kind]}'`;
+        default:
+          return "Unknown error type";
+      }
+    }
+    exports.DefaultErrorFunction = DefaultErrorFunction;
+  }
+});
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/value/deref.js
+var require_deref = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/value/deref.js"(exports) {
+    "use strict";
+    init_dirname();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Deref = exports.TypeDereferenceError = void 0;
+    var typebox_1 = require_typebox();
+    var TypeDereferenceError = class extends typebox_1.TypeBoxError {
+      constructor(schema) {
+        super(`Unable to dereference schema with $id '${schema.$id}'`);
+        this.schema = schema;
+      }
+    };
+    exports.TypeDereferenceError = TypeDereferenceError;
+    function Deref(schema, references) {
+      const index = references.findIndex((target) => target.$id === schema.$ref);
+      if (index === -1)
+        throw new TypeDereferenceError(schema);
+      return references[index];
+    }
+    exports.Deref = Deref;
+  }
+});
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/value/hash.js
+var require_hash = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/value/hash.js"(exports) {
+    "use strict";
+    init_dirname();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Hash = exports.ByteMarker = exports.ValueHashError = void 0;
+    var guard_1 = require_guard();
+    var ValueHashError = class extends Error {
+      constructor(value) {
+        super(`Unable to hash value`);
+        this.value = value;
+      }
+    };
+    exports.ValueHashError = ValueHashError;
+    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 || (exports.ByteMarker = ByteMarker = {}));
+    var Accumulator = BigInt("14695981039346656037");
+    var [Prime, Size] = [BigInt("1099511628211"), BigInt("2") ** BigInt("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.keys(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 ((0, guard_1.IsArray)(value))
+        return ArrayType(value);
+      if ((0, guard_1.IsBoolean)(value))
+        return BooleanType(value);
+      if ((0, guard_1.IsBigInt)(value))
+        return BigIntType(value);
+      if ((0, guard_1.IsDate)(value))
+        return DateType(value);
+      if ((0, guard_1.IsNull)(value))
+        return NullType(value);
+      if ((0, guard_1.IsNumber)(value))
+        return NumberType(value);
+      if ((0, guard_1.IsPlainObject)(value))
+        return ObjectType(value);
+      if ((0, guard_1.IsString)(value))
+        return StringType(value);
+      if ((0, guard_1.IsSymbol)(value))
+        return SymbolType(value);
+      if ((0, guard_1.IsUint8Array)(value))
+        return Uint8ArrayType(value);
+      if ((0, guard_1.IsUndefined)(value))
+        return UndefinedType(value);
+      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;
+    }
+    exports.Hash = Hash;
+  }
+});
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/errors/errors.js
+var require_errors = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/errors/errors.js"(exports) {
+    "use strict";
+    init_dirname();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Errors = exports.ValueErrorIterator = exports.EscapeKey = exports.ValueErrorsUnknownTypeError = exports.ValueErrorType = void 0;
+    var guard_1 = require_guard();
+    var system_1 = require_system();
+    var deref_1 = require_deref();
+    var hash_1 = require_hash();
+    var Types = require_typebox();
+    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["StringFormatUnknown"] = 48] = "StringFormatUnknown";
+      ValueErrorType2[ValueErrorType2["StringFormat"] = 49] = "StringFormat";
+      ValueErrorType2[ValueErrorType2["StringMaxLength"] = 50] = "StringMaxLength";
+      ValueErrorType2[ValueErrorType2["StringMinLength"] = 51] = "StringMinLength";
+      ValueErrorType2[ValueErrorType2["StringPattern"] = 52] = "StringPattern";
+      ValueErrorType2[ValueErrorType2["String"] = 53] = "String";
+      ValueErrorType2[ValueErrorType2["Symbol"] = 54] = "Symbol";
+      ValueErrorType2[ValueErrorType2["TupleLength"] = 55] = "TupleLength";
+      ValueErrorType2[ValueErrorType2["Tuple"] = 56] = "Tuple";
+      ValueErrorType2[ValueErrorType2["Uint8ArrayMaxByteLength"] = 57] = "Uint8ArrayMaxByteLength";
+      ValueErrorType2[ValueErrorType2["Uint8ArrayMinByteLength"] = 58] = "Uint8ArrayMinByteLength";
+      ValueErrorType2[ValueErrorType2["Uint8Array"] = 59] = "Uint8Array";
+      ValueErrorType2[ValueErrorType2["Undefined"] = 60] = "Undefined";
+      ValueErrorType2[ValueErrorType2["Union"] = 61] = "Union";
+      ValueErrorType2[ValueErrorType2["Void"] = 62] = "Void";
+    })(ValueErrorType || (exports.ValueErrorType = ValueErrorType = {}));
+    var ValueErrorsUnknownTypeError = class extends Types.TypeBoxError {
+      constructor(schema) {
+        super("Unknown type");
+        this.schema = schema;
+      }
+    };
+    exports.ValueErrorsUnknownTypeError = ValueErrorsUnknownTypeError;
+    function EscapeKey(key) {
+      return key.replace(/~/g, "~0").replace(/\//g, "~1");
+    }
+    exports.EscapeKey = EscapeKey;
+    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;
+      }
+    };
+    exports.ValueErrorIterator = ValueErrorIterator;
+    function Create(type, schema, path, value) {
+      return { type, schema, path, value, message: system_1.TypeSystemErrorFunction.Get()(schema, type) };
+    }
+    function* TAny(schema, references, path, value) {
+    }
+    function* TArray(schema, references, path, value) {
+      if (!(0, guard_1.IsArray)(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 = (0, hash_1.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 : Types.Type.Never();
+      const containsCount = value.reduce((acc, value2, index) => Visit(containsSchema, references, `${path}${index}`, value2).next().done === true ? acc + 1 : acc, 0);
+      if (containsCount === 0) {
+        yield Create(ValueErrorType.ArrayContains, schema, path, value);
+      }
+      if ((0, guard_1.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
+        yield Create(ValueErrorType.ArrayMinContains, schema, path, value);
+      }
+      if ((0, guard_1.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
+        yield Create(ValueErrorType.ArrayMaxContains, schema, path, value);
+      }
+    }
+    function* TAsyncIterator(schema, references, path, value) {
+      if (!(0, guard_1.IsAsyncIterator)(value))
+        yield Create(ValueErrorType.AsyncIterator, schema, path, value);
+    }
+    function* TBigInt(schema, references, path, value) {
+      if (!(0, guard_1.IsBigInt)(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* TBoolean(schema, references, path, value) {
+      if (!(0, guard_1.IsBoolean)(value))
+        yield Create(ValueErrorType.Boolean, schema, path, value);
+    }
+    function* TConstructor(schema, references, path, value) {
+      yield* Visit(schema.returns, references, path, value.prototype);
+    }
+    function* TDate(schema, references, path, value) {
+      if (!(0, guard_1.IsDate)(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* TFunction(schema, references, path, value) {
+      if (!(0, guard_1.IsFunction)(value))
+        yield Create(ValueErrorType.Function, schema, path, value);
+    }
+    function* TInteger(schema, references, path, value) {
+      if (!(0, guard_1.IsInteger)(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* TIntersect(schema, references, path, value) {
+      for (const inner of schema.allOf) {
+        const next = Visit(inner, references, path, value).next();
+        if (!next.done) {
+          yield Create(ValueErrorType.Intersect, schema, path, value);
+          yield next.value;
+        }
+      }
+      if (schema.unevaluatedProperties === false) {
+        const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(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(Types.KeyResolver.ResolvePattern(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* TIterator(schema, references, path, value) {
+      if (!(0, guard_1.IsIterator)(value))
+        yield Create(ValueErrorType.Iterator, schema, path, value);
+    }
+    function* TLiteral(schema, references, path, value) {
+      if (!(value === schema.const))
+        yield Create(ValueErrorType.Literal, schema, path, value);
+    }
+    function* TNever(schema, references, path, value) {
+      yield Create(ValueErrorType.Never, schema, path, value);
+    }
+    function* TNot(schema, references, path, value) {
+      if (Visit(schema.not, references, path, value).next().done === true)
+        yield Create(ValueErrorType.Not, schema, path, value);
+    }
+    function* TNull(schema, references, path, value) {
+      if (!(0, guard_1.IsNull)(value))
+        yield Create(ValueErrorType.Null, schema, path, value);
+    }
+    function* TNumber(schema, references, path, value) {
+      if (!system_1.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* TObject(schema, references, path, value) {
+      if (!system_1.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 (Types.ExtendsUndefined.Check(schema) && !(knownKey in value)) {
+            yield Create(ValueErrorType.ObjectRequiredProperty, property, `${path}/${EscapeKey(knownKey)}`, void 0);
+          }
+        } else {
+          if (system_1.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey)) {
+            yield* Visit(property, references, `${path}/${EscapeKey(knownKey)}`, value[knownKey]);
+          }
+        }
+      }
+    }
+    function* TPromise(schema, references, path, value) {
+      if (!(0, guard_1.IsPromise)(value))
+        yield Create(ValueErrorType.Promise, schema, path, value);
+    }
+    function* TRecord(schema, references, path, value) {
+      if (!system_1.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* TRef(schema, references, path, value) {
+      yield* Visit((0, deref_1.Deref)(schema, references), references, path, value);
+    }
+    function* TString(schema, references, path, value) {
+      if (!(0, guard_1.IsString)(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 ((0, guard_1.IsString)(schema.pattern)) {
+        const regex = new RegExp(schema.pattern);
+        if (!regex.test(value)) {
+          yield Create(ValueErrorType.StringPattern, schema, path, value);
+        }
+      }
+      if ((0, guard_1.IsString)(schema.format)) {
+        if (!Types.FormatRegistry.Has(schema.format)) {
+          yield Create(ValueErrorType.StringFormatUnknown, schema, path, value);
+        } else {
+          const format = Types.FormatRegistry.Get(schema.format);
+          if (!format(value)) {
+            yield Create(ValueErrorType.StringFormat, schema, path, value);
+          }
+        }
+      }
+    }
+    function* TSymbol(schema, references, path, value) {
+      if (!(0, guard_1.IsSymbol)(value))
+        yield Create(ValueErrorType.Symbol, schema, path, value);
+    }
+    function* TTemplateLiteral(schema, references, path, value) {
+      if (!(0, guard_1.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* TThis(schema, references, path, value) {
+      yield* Visit((0, deref_1.Deref)(schema, references), references, path, value);
+    }
+    function* TTuple(schema, references, path, value) {
+      if (!(0, guard_1.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* Visit(schema.items[i], references, `${path}/${i}`, value[i]);
+      }
+    }
+    function* TUndefined(schema, references, path, value) {
+      if (!(0, guard_1.IsUndefined)(value))
+        yield Create(ValueErrorType.Undefined, schema, path, value);
+    }
+    function* TUnion(schema, references, path, value) {
+      let count = 0;
+      for (const subschema of schema.anyOf) {
+        const errors = [...Visit(subschema, references, path, value)];
+        if (errors.length === 0)
+          return;
+        count += errors.length;
+      }
+      if (count > 0) {
+        yield Create(ValueErrorType.Union, schema, path, value);
+      }
+    }
+    function* TUint8Array(schema, references, path, value) {
+      if (!(0, guard_1.IsUint8Array)(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* TUnknown(schema, references, path, value) {
+    }
+    function* TVoid(schema, references, path, value) {
+      if (!system_1.TypeSystemPolicy.IsVoidLike(value))
+        yield Create(ValueErrorType.Void, schema, path, value);
+    }
+    function* TKind(schema, references, path, value) {
+      const check = Types.TypeRegistry.Get(schema[Types.Kind]);
+      if (!check(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_[Types.Kind]) {
+        case "Any":
+          return yield* TAny(schema_, references_, path, value);
+        case "Array":
+          return yield* TArray(schema_, references_, path, value);
+        case "AsyncIterator":
+          return yield* TAsyncIterator(schema_, references_, path, value);
+        case "BigInt":
+          return yield* TBigInt(schema_, references_, path, value);
+        case "Boolean":
+          return yield* TBoolean(schema_, references_, path, value);
+        case "Constructor":
+          return yield* TConstructor(schema_, references_, path, value);
+        case "Date":
+          return yield* TDate(schema_, references_, path, value);
+        case "Function":
+          return yield* TFunction(schema_, references_, path, value);
+        case "Integer":
+          return yield* TInteger(schema_, references_, path, value);
+        case "Intersect":
+          return yield* TIntersect(schema_, references_, path, value);
+        case "Iterator":
+          return yield* TIterator(schema_, references_, path, value);
+        case "Literal":
+          return yield* TLiteral(schema_, references_, path, value);
+        case "Never":
+          return yield* TNever(schema_, references_, path, value);
+        case "Not":
+          return yield* TNot(schema_, references_, path, value);
+        case "Null":
+          return yield* TNull(schema_, references_, path, value);
+        case "Number":
+          return yield* TNumber(schema_, references_, path, value);
+        case "Object":
+          return yield* TObject(schema_, references_, path, value);
+        case "Promise":
+          return yield* TPromise(schema_, references_, path, value);
+        case "Record":
+          return yield* TRecord(schema_, references_, path, value);
+        case "Ref":
+          return yield* TRef(schema_, references_, path, value);
+        case "String":
+          return yield* TString(schema_, references_, path, value);
+        case "Symbol":
+          return yield* TSymbol(schema_, references_, path, value);
+        case "TemplateLiteral":
+          return yield* TTemplateLiteral(schema_, references_, path, value);
+        case "This":
+          return yield* TThis(schema_, references_, path, value);
+        case "Tuple":
+          return yield* TTuple(schema_, references_, path, value);
+        case "Undefined":
+          return yield* TUndefined(schema_, references_, path, value);
+        case "Union":
+          return yield* TUnion(schema_, references_, path, value);
+        case "Uint8Array":
+          return yield* TUint8Array(schema_, references_, path, value);
+        case "Unknown":
+          return yield* TUnknown(schema_, references_, path, value);
+        case "Void":
+          return yield* TVoid(schema_, references_, path, value);
+        default:
+          if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+            throw new ValueErrorsUnknownTypeError(schema);
+          return yield* TKind(schema_, references_, path, value);
+      }
+    }
+    function Errors(...args) {
+      const iterator = args.length === 3 ? Visit(args[0], args[1], "", args[2]) : Visit(args[0], [], "", args[1]);
+      return new ValueErrorIterator(iterator);
+    }
+    exports.Errors = Errors;
+  }
+});
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/errors/index.js
+var require_errors2 = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/errors/index.js"(exports) {
+    "use strict";
+    init_dirname();
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_errors(), exports);
+  }
+});
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/system/index.js
+var require_system2 = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/system/index.js"(exports) {
+    "use strict";
+    init_dirname();
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ValueErrorType = void 0;
+    var errors_1 = require_errors();
+    Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function() {
+      return errors_1.ValueErrorType;
+    } });
+    __exportStar(require_system(), exports);
+  }
+});
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/value/check.js
+var require_check = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/value/check.js"(exports) {
+    "use strict";
+    init_dirname();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Check = exports.ValueCheckUnknownTypeError = void 0;
+    var guard_1 = require_guard();
+    var index_1 = require_system2();
+    var deref_1 = require_deref();
+    var hash_1 = require_hash();
+    var Types = require_typebox();
+    var ValueCheckUnknownTypeError = class extends Types.TypeBoxError {
+      constructor(schema) {
+        super(`Unknown type`);
+        this.schema = schema;
+      }
+    };
+    exports.ValueCheckUnknownTypeError = ValueCheckUnknownTypeError;
+    function IsAnyOrUnknown(schema) {
+      return schema[Types.Kind] === "Any" || schema[Types.Kind] === "Unknown";
+    }
+    function IsDefined(value) {
+      return value !== void 0;
+    }
+    function TAny(schema, references, value) {
+      return true;
+    }
+    function TArray(schema, references, value) {
+      if (!(0, guard_1.IsArray)(value))
+        return false;
+      if (IsDefined(schema.minItems) && !(value.length >= schema.minItems)) {
+        return false;
+      }
+      if (IsDefined(schema.maxItems) && !(value.length <= schema.maxItems)) {
+        return false;
+      }
+      if (!value.every((value2) => Visit(schema.items, references, value2))) {
+        return false;
+      }
+      if (schema.uniqueItems === true && !function() {
+        const set = /* @__PURE__ */ new Set();
+        for (const element of value) {
+          const hashed = (0, hash_1.Hash)(element);
+          if (set.has(hashed)) {
+            return false;
+          } else {
+            set.add(hashed);
+          }
+        }
+        return true;
+      }()) {
+        return false;
+      }
+      if (!(IsDefined(schema.contains) || (0, guard_1.IsNumber)(schema.minContains) || (0, guard_1.IsNumber)(schema.maxContains))) {
+        return true;
+      }
+      const containsSchema = IsDefined(schema.contains) ? schema.contains : Types.Type.Never();
+      const containsCount = value.reduce((acc, value2) => Visit(containsSchema, references, value2) ? acc + 1 : acc, 0);
+      if (containsCount === 0) {
+        return false;
+      }
+      if ((0, guard_1.IsNumber)(schema.minContains) && containsCount < schema.minContains) {
+        return false;
+      }
+      if ((0, guard_1.IsNumber)(schema.maxContains) && containsCount > schema.maxContains) {
+        return false;
+      }
+      return true;
+    }
+    function TAsyncIterator(schema, references, value) {
+      return (0, guard_1.IsAsyncIterator)(value);
+    }
+    function TBigInt(schema, references, value) {
+      if (!(0, guard_1.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 TBoolean(schema, references, value) {
+      return (0, guard_1.IsBoolean)(value);
+    }
+    function TConstructor(schema, references, value) {
+      return Visit(schema.returns, references, value.prototype);
+    }
+    function TDate(schema, references, value) {
+      if (!(0, guard_1.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 TFunction(schema, references, value) {
+      return (0, guard_1.IsFunction)(value);
+    }
+    function TInteger(schema, references, value) {
+      if (!(0, guard_1.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 TIntersect(schema, references, value) {
+      const check1 = schema.allOf.every((schema2) => Visit(schema2, references, value));
+      if (schema.unevaluatedProperties === false) {
+        const keyPattern = new RegExp(Types.KeyResolver.ResolvePattern(schema));
+        const check2 = Object.getOwnPropertyNames(value).every((key) => keyPattern.test(key));
+        return check1 && check2;
+      } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
+        const keyCheck = new RegExp(Types.KeyResolver.ResolvePattern(schema));
+        const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit(schema.unevaluatedProperties, references, value[key]));
+        return check1 && check2;
+      } else {
+        return check1;
+      }
+    }
+    function TIterator(schema, references, value) {
+      return (0, guard_1.IsIterator)(value);
+    }
+    function TLiteral(schema, references, value) {
+      return value === schema.const;
+    }
+    function TNever(schema, references, value) {
+      return false;
+    }
+    function TNot(schema, references, value) {
+      return !Visit(schema.not, references, value);
+    }
+    function TNull(schema, references, value) {
+      return (0, guard_1.IsNull)(value);
+    }
+    function TNumber(schema, references, value) {
+      if (!index_1.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 TObject(schema, references, value) {
+      if (!index_1.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 (!Visit(property, references, value[knownKey])) {
+            return false;
+          }
+          if ((Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property)) && !(knownKey in value)) {
+            return false;
+          }
+        } else {
+          if (index_1.TypeSystemPolicy.IsExactOptionalProperty(value, knownKey) && !Visit(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) || Visit(schema.additionalProperties, references, value[key]));
+      } else {
+        return true;
+      }
+    }
+    function TPromise(schema, references, value) {
+      return (0, guard_1.IsPromise)(value);
+    }
+    function TRecord(schema, references, value) {
+      if (!index_1.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) ? Visit(patternSchema, references, value2) : true;
+      });
+      const check2 = typeof schema.additionalProperties === "object" ? Object.entries(value).every(([key, value2]) => {
+        return !regex.test(key) ? Visit(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 TRef(schema, references, value) {
+      return Visit((0, deref_1.Deref)(schema, references), references, value);
+    }
+    function TString(schema, references, value) {
+      if (!(0, guard_1.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 (!Types.FormatRegistry.Has(schema.format))
+          return false;
+        const func = Types.FormatRegistry.Get(schema.format);
+        return func(value);
+      }
+      return true;
+    }
+    function TSymbol(schema, references, value) {
+      return (0, guard_1.IsSymbol)(value);
+    }
+    function TTemplateLiteral(schema, references, value) {
+      return (0, guard_1.IsString)(value) && new RegExp(schema.pattern).test(value);
+    }
+    function TThis(schema, references, value) {
+      return Visit((0, deref_1.Deref)(schema, references), references, value);
+    }
+    function TTuple(schema, references, value) {
+      if (!(0, guard_1.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 (!Visit(schema.items[i], references, value[i]))
+          return false;
+      }
+      return true;
+    }
+    function TUndefined(schema, references, value) {
+      return (0, guard_1.IsUndefined)(value);
+    }
+    function TUnion(schema, references, value) {
+      return schema.anyOf.some((inner) => Visit(inner, references, value));
+    }
+    function TUint8Array(schema, references, value) {
+      if (!(0, guard_1.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 TUnknown(schema, references, value) {
+      return true;
+    }
+    function TVoid(schema, references, value) {
+      return index_1.TypeSystemPolicy.IsVoidLike(value);
+    }
+    function TKind(schema, references, value) {
+      if (!Types.TypeRegistry.Has(schema[Types.Kind]))
+        return false;
+      const func = Types.TypeRegistry.Get(schema[Types.Kind]);
+      return func(schema, value);
+    }
+    function Visit(schema, references, value) {
+      const references_ = IsDefined(schema.$id) ? [...references, schema] : references;
+      const schema_ = schema;
+      switch (schema_[Types.Kind]) {
+        case "Any":
+          return TAny(schema_, references_, value);
+        case "Array":
+          return TArray(schema_, references_, value);
+        case "AsyncIterator":
+          return TAsyncIterator(schema_, references_, value);
+        case "BigInt":
+          return TBigInt(schema_, references_, value);
+        case "Boolean":
+          return TBoolean(schema_, references_, value);
+        case "Constructor":
+          return TConstructor(schema_, references_, value);
+        case "Date":
+          return TDate(schema_, references_, value);
+        case "Function":
+          return TFunction(schema_, references_, value);
+        case "Integer":
+          return TInteger(schema_, references_, value);
+        case "Intersect":
+          return TIntersect(schema_, references_, value);
+        case "Iterator":
+          return TIterator(schema_, references_, value);
+        case "Literal":
+          return TLiteral(schema_, references_, value);
+        case "Never":
+          return TNever(schema_, references_, value);
+        case "Not":
+          return TNot(schema_, references_, value);
+        case "Null":
+          return TNull(schema_, references_, value);
+        case "Number":
+          return TNumber(schema_, references_, value);
+        case "Object":
+          return TObject(schema_, references_, value);
+        case "Promise":
+          return TPromise(schema_, references_, value);
+        case "Record":
+          return TRecord(schema_, references_, value);
+        case "Ref":
+          return TRef(schema_, references_, value);
+        case "String":
+          return TString(schema_, references_, value);
+        case "Symbol":
+          return TSymbol(schema_, references_, value);
+        case "TemplateLiteral":
+          return TTemplateLiteral(schema_, references_, value);
+        case "This":
+          return TThis(schema_, references_, value);
+        case "Tuple":
+          return TTuple(schema_, references_, value);
+        case "Undefined":
+          return TUndefined(schema_, references_, value);
+        case "Union":
+          return TUnion(schema_, references_, value);
+        case "Uint8Array":
+          return TUint8Array(schema_, references_, value);
+        case "Unknown":
+          return TUnknown(schema_, references_, value);
+        case "Void":
+          return TVoid(schema_, references_, value);
+        default:
+          if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+            throw new ValueCheckUnknownTypeError(schema_);
+          return TKind(schema_, references_, value);
+      }
+    }
+    function Check(...args) {
+      return args.length === 3 ? Visit(args[0], args[1], args[2]) : Visit(args[0], [], args[1]);
+    }
+    exports.Check = Check;
+  }
+});
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/value/transform.js
+var require_transform = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/value/transform.js"(exports) {
+    "use strict";
+    init_dirname();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EncodeTransform = exports.DecodeTransform = exports.HasTransform = exports.TransformEncodeError = exports.TransformDecodeError = exports.TransformEncodeCheckError = exports.TransformDecodeCheckError = void 0;
+    var guard_1 = require_guard();
+    var deref_1 = require_deref();
+    var check_1 = require_check();
+    var Types = require_typebox();
+    var TransformDecodeCheckError = class extends Types.TypeBoxError {
+      constructor(schema, value, error) {
+        super(`Unable to decode due to invalid value`);
+        this.schema = schema;
+        this.value = value;
+        this.error = error;
+      }
+    };
+    exports.TransformDecodeCheckError = TransformDecodeCheckError;
+    var TransformEncodeCheckError = class extends Types.TypeBoxError {
+      constructor(schema, value, error) {
+        super(`Unable to encode due to invalid value`);
+        this.schema = schema;
+        this.value = value;
+        this.error = error;
+      }
+    };
+    exports.TransformEncodeCheckError = TransformEncodeCheckError;
+    var TransformDecodeError = class extends Types.TypeBoxError {
+      constructor(schema, value, error) {
+        super(`${error instanceof Error ? error.message : "Unknown error"}`);
+        this.schema = schema;
+        this.value = value;
+      }
+    };
+    exports.TransformDecodeError = TransformDecodeError;
+    var TransformEncodeError = class extends Types.TypeBoxError {
+      constructor(schema, value, error) {
+        super(`${error instanceof Error ? error.message : "Unknown error"}`);
+        this.schema = schema;
+        this.value = value;
+      }
+    };
+    exports.TransformEncodeError = TransformEncodeError;
+    var HasTransform;
+    (function(HasTransform2) {
+      function TArray(schema, references) {
+        return Types.TypeGuard.TTransform(schema) || Visit(schema.items, references);
+      }
+      function TAsyncIterator(schema, references) {
+        return Types.TypeGuard.TTransform(schema) || Visit(schema.items, references);
+      }
+      function TConstructor(schema, references) {
+        return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema2) => Visit(schema2, references));
+      }
+      function TFunction(schema, references) {
+        return Types.TypeGuard.TTransform(schema) || Visit(schema.returns, references) || schema.parameters.some((schema2) => Visit(schema2, references));
+      }
+      function TIntersect(schema, references) {
+        return Types.TypeGuard.TTransform(schema) || Types.TypeGuard.TTransform(schema.unevaluatedProperties) || schema.allOf.some((schema2) => Visit(schema2, references));
+      }
+      function TIterator(schema, references) {
+        return Types.TypeGuard.TTransform(schema) || Visit(schema.items, references);
+      }
+      function TNot(schema, references) {
+        return Types.TypeGuard.TTransform(schema) || Visit(schema.not, references);
+      }
+      function TObject(schema, references) {
+        return Types.TypeGuard.TTransform(schema) || Object.values(schema.properties).some((schema2) => Visit(schema2, references)) || Types.TypeGuard.TSchema(schema.additionalProperties) && Visit(schema.additionalProperties, references);
+      }
+      function TPromise(schema, references) {
+        return Types.TypeGuard.TTransform(schema) || Visit(schema.item, references);
+      }
+      function TRecord(schema, references) {
+        const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+        const property = schema.patternProperties[pattern];
+        return Types.TypeGuard.TTransform(schema) || Visit(property, references) || Types.TypeGuard.TSchema(schema.additionalProperties) && Types.TypeGuard.TTransform(schema.additionalProperties);
+      }
+      function TRef(schema, references) {
+        if (Types.TypeGuard.TTransform(schema))
+          return true;
+        return Visit((0, deref_1.Deref)(schema, references), references);
+      }
+      function TThis(schema, references) {
+        if (Types.TypeGuard.TTransform(schema))
+          return true;
+        return Visit((0, deref_1.Deref)(schema, references), references);
+      }
+      function TTuple(schema, references) {
+        return Types.TypeGuard.TTransform(schema) || !(0, guard_1.IsUndefined)(schema.items) && schema.items.some((schema2) => Visit(schema2, references));
+      }
+      function TUnion(schema, references) {
+        return Types.TypeGuard.TTransform(schema) || schema.anyOf.some((schema2) => Visit(schema2, references));
+      }
+      function Visit(schema, references) {
+        const references_ = (0, guard_1.IsString)(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
+        if (schema.$id && visited.has(schema.$id))
+          return false;
+        if (schema.$id)
+          visited.add(schema.$id);
+        switch (schema[Types.Kind]) {
+          case "Array":
+            return TArray(schema_, references_);
+          case "AsyncIterator":
+            return TAsyncIterator(schema_, references_);
+          case "Constructor":
+            return TConstructor(schema_, references_);
+          case "Function":
+            return TFunction(schema_, references_);
+          case "Intersect":
+            return TIntersect(schema_, references_);
+          case "Iterator":
+            return TIterator(schema_, references_);
+          case "Not":
+            return TNot(schema_, references_);
+          case "Object":
+            return TObject(schema_, references_);
+          case "Promise":
+            return TPromise(schema_, references_);
+          case "Record":
+            return TRecord(schema_, references_);
+          case "Ref":
+            return TRef(schema_, references_);
+          case "This":
+            return TThis(schema_, references_);
+          case "Tuple":
+            return TTuple(schema_, references_);
+          case "Union":
+            return TUnion(schema_, references_);
+          default:
+            return Types.TypeGuard.TTransform(schema);
+        }
+      }
+      const visited = /* @__PURE__ */ new Set();
+      function Has(schema, references) {
+        visited.clear();
+        return Visit(schema, references);
+      }
+      HasTransform2.Has = Has;
+    })(HasTransform || (exports.HasTransform = HasTransform = {}));
+    var DecodeTransform;
+    (function(DecodeTransform2) {
+      function Default(schema, value) {
+        try {
+          return Types.TypeGuard.TTransform(schema) ? schema[Types.Transform].Decode(value) : value;
+        } catch (error) {
+          throw new TransformDecodeError(schema, value, error);
+        }
+      }
+      function TArray(schema, references, value) {
+        return (0, guard_1.IsArray)(value) ? Default(schema, value.map((value2) => Visit(schema.items, references, value2))) : Default(schema, value);
+      }
+      function TIntersect(schema, references, value) {
+        if (!(0, guard_1.IsPlainObject)(value) || (0, guard_1.IsValueType)(value))
+          return Default(schema, value);
+        const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false });
+        const knownProperties = knownKeys.reduce((value2, key) => {
+          return key in value2 ? { ...value2, [key]: Visit(Types.IndexedAccessor.Resolve(schema, [key]), references, value2[key]) } : value2;
+        }, value);
+        if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) {
+          return Default(schema, knownProperties);
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+        const unevaluatedProperties = schema.unevaluatedProperties;
+        const unknownProperties = unknownKeys.reduce((value2, key) => {
+          return !knownKeys.includes(key) ? { ...value2, [key]: Default(unevaluatedProperties, value2[key]) } : value2;
+        }, knownProperties);
+        return Default(schema, unknownProperties);
+      }
+      function TNot(schema, references, value) {
+        return Default(schema, Visit(schema.not, references, value));
+      }
+      function TObject(schema, references, value) {
+        if (!(0, guard_1.IsPlainObject)(value))
+          return Default(schema, value);
+        const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false });
+        const knownProperties = knownKeys.reduce((value2, key) => {
+          return key in value2 ? { ...value2, [key]: Visit(schema.properties[key], references, value2[key]) } : value2;
+        }, value);
+        if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+          return Default(schema, knownProperties);
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+        const additionalProperties = schema.additionalProperties;
+        const unknownProperties = unknownKeys.reduce((value2, key) => {
+          return !knownKeys.includes(key) ? { ...value2, [key]: Default(additionalProperties, value2[key]) } : value2;
+        }, knownProperties);
+        return Default(schema, unknownProperties);
+      }
+      function TRecord(schema, references, value) {
+        if (!(0, guard_1.IsPlainObject)(value))
+          return Default(schema, value);
+        const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+        const knownKeys = new RegExp(pattern);
+        const knownProperties = Object.getOwnPropertyNames(value).reduce((value2, key) => {
+          return knownKeys.test(key) ? { ...value2, [key]: Visit(schema.patternProperties[pattern], references, value2[key]) } : value2;
+        }, value);
+        if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+          return Default(schema, knownProperties);
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+        const additionalProperties = schema.additionalProperties;
+        const unknownProperties = unknownKeys.reduce((value2, key) => {
+          return !knownKeys.test(key) ? { ...value2, [key]: Default(additionalProperties, value2[key]) } : value2;
+        }, knownProperties);
+        return Default(schema, unknownProperties);
+      }
+      function TRef(schema, references, value) {
+        const target = (0, deref_1.Deref)(schema, references);
+        return Default(schema, Visit(target, references, value));
+      }
+      function TThis(schema, references, value) {
+        const target = (0, deref_1.Deref)(schema, references);
+        return Default(schema, Visit(target, references, value));
+      }
+      function TTuple(schema, references, value) {
+        return (0, guard_1.IsArray)(value) && (0, guard_1.IsArray)(schema.items) ? Default(schema, schema.items.map((schema2, index) => Visit(schema2, references, value[index]))) : Default(schema, value);
+      }
+      function TUnion(schema, references, value) {
+        const defaulted = Default(schema, value);
+        for (const subschema of schema.anyOf) {
+          if (!(0, check_1.Check)(subschema, references, defaulted))
+            continue;
+          return Visit(subschema, references, defaulted);
+        }
+        return defaulted;
+      }
+      function Visit(schema, references, value) {
+        const references_ = typeof schema.$id === "string" ? [...references, schema] : references;
+        const schema_ = schema;
+        switch (schema[Types.Kind]) {
+          case "Array":
+            return TArray(schema_, references_, value);
+          case "Intersect":
+            return TIntersect(schema_, references_, value);
+          case "Not":
+            return TNot(schema_, references_, value);
+          case "Object":
+            return TObject(schema_, references_, value);
+          case "Record":
+            return TRecord(schema_, references_, value);
+          case "Ref":
+            return TRef(schema_, references_, value);
+          case "Symbol":
+            return Default(schema_, value);
+          case "This":
+            return TThis(schema_, references_, value);
+          case "Tuple":
+            return TTuple(schema_, references_, value);
+          case "Union":
+            return TUnion(schema_, references_, value);
+          default:
+            return Default(schema_, value);
+        }
+      }
+      function Decode(schema, references, value) {
+        return Visit(schema, references, value);
+      }
+      DecodeTransform2.Decode = Decode;
+    })(DecodeTransform || (exports.DecodeTransform = DecodeTransform = {}));
+    var EncodeTransform;
+    (function(EncodeTransform2) {
+      function Default(schema, value) {
+        try {
+          return Types.TypeGuard.TTransform(schema) ? schema[Types.Transform].Encode(value) : value;
+        } catch (error) {
+          throw new TransformEncodeError(schema, value, error);
+        }
+      }
+      function TArray(schema, references, value) {
+        const defaulted = Default(schema, value);
+        return (0, guard_1.IsArray)(defaulted) ? defaulted.map((value2) => Visit(schema.items, references, value2)) : defaulted;
+      }
+      function TIntersect(schema, references, value) {
+        const defaulted = Default(schema, value);
+        if (!(0, guard_1.IsPlainObject)(value) || (0, guard_1.IsValueType)(value))
+          return defaulted;
+        const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false });
+        const knownProperties = knownKeys.reduce((value2, key) => {
+          return key in defaulted ? { ...value2, [key]: Visit(Types.IndexedAccessor.Resolve(schema, [key]), references, value2[key]) } : value2;
+        }, defaulted);
+        if (!Types.TypeGuard.TTransform(schema.unevaluatedProperties)) {
+          return Default(schema, knownProperties);
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+        const unevaluatedProperties = schema.unevaluatedProperties;
+        return unknownKeys.reduce((value2, key) => {
+          return !knownKeys.includes(key) ? { ...value2, [key]: Default(unevaluatedProperties, value2[key]) } : value2;
+        }, knownProperties);
+      }
+      function TNot(schema, references, value) {
+        return Default(schema.not, Default(schema, value));
+      }
+      function TObject(schema, references, value) {
+        const defaulted = Default(schema, value);
+        if (!(0, guard_1.IsPlainObject)(value))
+          return defaulted;
+        const knownKeys = Types.KeyResolver.ResolveKeys(schema, { includePatterns: false });
+        const knownProperties = knownKeys.reduce((value2, key) => {
+          return key in value2 ? { ...value2, [key]: Visit(schema.properties[key], references, value2[key]) } : value2;
+        }, defaulted);
+        if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+          return knownProperties;
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+        const additionalProperties = schema.additionalProperties;
+        return unknownKeys.reduce((value2, key) => {
+          return !knownKeys.includes(key) ? { ...value2, [key]: Default(additionalProperties, value2[key]) } : value2;
+        }, knownProperties);
+      }
+      function TRecord(schema, references, value) {
+        const defaulted = Default(schema, value);
+        if (!(0, guard_1.IsPlainObject)(value))
+          return defaulted;
+        const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
+        const knownKeys = new RegExp(pattern);
+        const knownProperties = Object.getOwnPropertyNames(value).reduce((value2, key) => {
+          return knownKeys.test(key) ? { ...value2, [key]: Visit(schema.patternProperties[pattern], references, value2[key]) } : value2;
+        }, defaulted);
+        if (!Types.TypeGuard.TSchema(schema.additionalProperties)) {
+          return Default(schema, knownProperties);
+        }
+        const unknownKeys = Object.getOwnPropertyNames(knownProperties);
+        const additionalProperties = schema.additionalProperties;
+        return unknownKeys.reduce((value2, key) => {
+          return !knownKeys.test(key) ? { ...value2, [key]: Default(additionalProperties, value2[key]) } : value2;
+        }, knownProperties);
+      }
+      function TRef(schema, references, value) {
+        const target = (0, deref_1.Deref)(schema, references);
+        const resolved = Visit(target, references, value);
+        return Default(schema, resolved);
+      }
+      function TThis(schema, references, value) {
+        const target = (0, deref_1.Deref)(schema, references);
+        const resolved = Visit(target, references, value);
+        return Default(schema, resolved);
+      }
+      function TTuple(schema, references, value) {
+        const value1 = Default(schema, value);
+        return (0, guard_1.IsArray)(schema.items) ? schema.items.map((schema2, index) => Visit(schema2, references, value1[index])) : [];
+      }
+      function TUnion(schema, references, value) {
+        for (const subschema of schema.anyOf) {
+          if (!(0, check_1.Check)(subschema, references, value))
+            continue;
+          const value1 = Visit(subschema, references, value);
+          return Default(schema, value1);
+        }
+        for (const subschema of schema.anyOf) {
+          const value1 = Visit(subschema, references, value);
+          if (!(0, check_1.Check)(schema, references, value1))
+            continue;
+          return Default(schema, value1);
+        }
+        return Default(schema, value);
+      }
+      function Visit(schema, references, value) {
+        const references_ = typeof schema.$id === "string" ? [...references, schema] : references;
+        const schema_ = schema;
+        switch (schema[Types.Kind]) {
+          case "Array":
+            return TArray(schema_, references_, value);
+          case "Intersect":
+            return TIntersect(schema_, references_, value);
+          case "Not":
+            return TNot(schema_, references_, value);
+          case "Object":
+            return TObject(schema_, references_, value);
+          case "Record":
+            return TRecord(schema_, references_, value);
+          case "Ref":
+            return TRef(schema_, references_, value);
+          case "This":
+            return TThis(schema_, references_, value);
+          case "Tuple":
+            return TTuple(schema_, references_, value);
+          case "Union":
+            return TUnion(schema_, references_, value);
+          default:
+            return Default(schema_, value);
+        }
+      }
+      function Encode(schema, references, value) {
+        return Visit(schema, references, value);
+      }
+      EncodeTransform2.Encode = Encode;
+    })(EncodeTransform || (exports.EncodeTransform = EncodeTransform = {}));
+  }
+});
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/compiler/compiler.js
+var require_compiler = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/compiler/compiler.js"(exports) {
+    "use strict";
+    init_dirname();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TypeCompiler = exports.Policy = exports.TypeCompilerTypeGuardError = exports.TypeCompilerUnknownTypeError = exports.TypeCheck = void 0;
+    var transform_1 = require_transform();
+    var guard_1 = require_guard();
+    var errors_1 = require_errors();
+    var index_1 = require_system2();
+    var deref_1 = require_deref();
+    var hash_1 = require_hash();
+    var Types = require_typebox();
+    var TypeCheck = class {
+      constructor(schema, references, checkFunc, code) {
+        this.schema = schema;
+        this.references = references;
+        this.checkFunc = checkFunc;
+        this.code = code;
+        this.hasTransform = transform_1.HasTransform.Has(schema, references);
+      }
+      /** Returns the generated assertion code used to validate this type. */
+      Code() {
+        return this.code;
+      }
+      /** Returns an iterator for each error in this value. */
+      Errors(value) {
+        return (0, errors_1.Errors)(this.schema, this.references, value);
+      }
+      /** Returns true if the value matches the compiled type. */
+      Check(value) {
+        return this.checkFunc(value);
+      }
+      /** Decodes a value or throws if error */
+      Decode(value) {
+        if (!this.checkFunc(value))
+          throw new transform_1.TransformDecodeCheckError(this.schema, value, this.Errors(value).First());
+        return this.hasTransform ? transform_1.DecodeTransform.Decode(this.schema, this.references, value) : value;
+      }
+      /** Encodes a value or throws if error */
+      Encode(value) {
+        const encoded = this.hasTransform ? transform_1.EncodeTransform.Encode(this.schema, this.references, value) : value;
+        if (!this.checkFunc(encoded))
+          throw new transform_1.TransformEncodeCheckError(this.schema, value, this.Errors(value).First());
+        return encoded;
+      }
+    };
+    exports.TypeCheck = TypeCheck;
+    var Character;
+    (function(Character2) {
+      function DollarSign(code) {
+        return code === 36;
+      }
+      Character2.DollarSign = DollarSign;
+      function IsUnderscore(code) {
+        return code === 95;
+      }
+      Character2.IsUnderscore = IsUnderscore;
+      function IsAlpha(code) {
+        return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+      }
+      Character2.IsAlpha = IsAlpha;
+      function IsNumeric(code) {
+        return code >= 48 && code <= 57;
+      }
+      Character2.IsNumeric = IsNumeric;
+    })(Character || (Character = {}));
+    var MemberExpression;
+    (function(MemberExpression2) {
+      function IsFirstCharacterNumeric(value) {
+        if (value.length === 0)
+          return false;
+        return Character.IsNumeric(value.charCodeAt(0));
+      }
+      function IsAccessor(value) {
+        if (IsFirstCharacterNumeric(value))
+          return false;
+        for (let i = 0; i < value.length; i++) {
+          const code = value.charCodeAt(i);
+          const check = Character.IsAlpha(code) || Character.IsNumeric(code) || Character.DollarSign(code) || Character.IsUnderscore(code);
+          if (!check)
+            return false;
+        }
+        return true;
+      }
+      function EscapeHyphen(key) {
+        return key.replace(/'/g, "\\'");
+      }
+      function Encode(object, key) {
+        return IsAccessor(key) ? `${object}.${key}` : `${object}['${EscapeHyphen(key)}']`;
+      }
+      MemberExpression2.Encode = Encode;
+    })(MemberExpression || (MemberExpression = {}));
+    var Identifier;
+    (function(Identifier2) {
+      function Encode($id) {
+        const buffer = [];
+        for (let i = 0; i < $id.length; i++) {
+          const code = $id.charCodeAt(i);
+          if (Character.IsNumeric(code) || Character.IsAlpha(code)) {
+            buffer.push($id.charAt(i));
+          } else {
+            buffer.push(`_${code}_`);
+          }
+        }
+        return buffer.join("").replace(/__/g, "_");
+      }
+      Identifier2.Encode = Encode;
+    })(Identifier || (Identifier = {}));
+    var LiteralString;
+    (function(LiteralString2) {
+      function Escape(content) {
+        return content.replace(/'/g, "\\'");
+      }
+      LiteralString2.Escape = Escape;
+    })(LiteralString || (LiteralString = {}));
+    var TypeCompilerUnknownTypeError = class extends Types.TypeBoxError {
+      constructor(schema) {
+        super("Unknown type");
+        this.schema = schema;
+      }
+    };
+    exports.TypeCompilerUnknownTypeError = TypeCompilerUnknownTypeError;
+    var TypeCompilerTypeGuardError = class extends Types.TypeBoxError {
+      constructor(schema) {
+        super("Preflight validation check failed to guard for the given schema");
+        this.schema = schema;
+      }
+    };
+    exports.TypeCompilerTypeGuardError = TypeCompilerTypeGuardError;
+    var Policy;
+    (function(Policy2) {
+      function IsExactOptionalProperty(value, key, expression) {
+        return index_1.TypeSystemPolicy.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`;
+      }
+      Policy2.IsExactOptionalProperty = IsExactOptionalProperty;
+      function IsObjectLike(value) {
+        return !index_1.TypeSystemPolicy.AllowArrayObject ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
+      }
+      Policy2.IsObjectLike = IsObjectLike;
+      function IsRecordLike(value) {
+        return !index_1.TypeSystemPolicy.AllowArrayObject ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))` : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`;
+      }
+      Policy2.IsRecordLike = IsRecordLike;
+      function IsNumberLike(value) {
+        return !index_1.TypeSystemPolicy.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
+      }
+      Policy2.IsNumberLike = IsNumberLike;
+      function IsVoidLike(value) {
+        return index_1.TypeSystemPolicy.AllowNullVoid ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
+      }
+      Policy2.IsVoidLike = IsVoidLike;
+    })(Policy || (exports.Policy = Policy = {}));
+    var TypeCompiler2;
+    (function(TypeCompiler3) {
+      function IsAnyOrUnknown(schema) {
+        return schema[Types.Kind] === "Any" || schema[Types.Kind] === "Unknown";
+      }
+      function* TAny(schema, references, value) {
+        yield "true";
+      }
+      function* TArray(schema, references, value) {
+        yield `Array.isArray(${value})`;
+        const [parameter, accumulator] = [CreateParameter("value", "any"), CreateParameter("acc", "number")];
+        if ((0, guard_1.IsNumber)(schema.maxItems))
+          yield `${value}.length <= ${schema.maxItems}`;
+        if ((0, guard_1.IsNumber)(schema.minItems))
+          yield `${value}.length >= ${schema.minItems}`;
+        const elementExpression = CreateExpression(schema.items, references, "value");
+        yield `${value}.every((${parameter}) => ${elementExpression})`;
+        if (Types.TypeGuard.TSchema(schema.contains) || (0, guard_1.IsNumber)(schema.minContains) || (0, guard_1.IsNumber)(schema.maxContains)) {
+          const containsSchema = Types.TypeGuard.TSchema(schema.contains) ? schema.contains : Types.Type.Never();
+          const checkExpression = CreateExpression(containsSchema, references, "value");
+          const checkMinContains = (0, guard_1.IsNumber)(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
+          const checkMaxContains = (0, guard_1.IsNumber)(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
+          const checkCount = `const count = value.reduce((${accumulator}, ${parameter}) => ${checkExpression} ? acc + 1 : acc, 0)`;
+          const check = [`(count > 0)`, ...checkMinContains, ...checkMaxContains].join(" && ");
+          yield `((${parameter}) => { ${checkCount}; return ${check}})(${value})`;
+        }
+        if (schema.uniqueItems === true) {
+          const check = `const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true`;
+          const block = `const set = new Set(); for(const element of value) { ${check} }`;
+          yield `((${parameter}) => { ${block} )(${value})`;
+        }
+      }
+      function* TAsyncIterator(schema, references, value) {
+        yield `(typeof value === 'object' && Symbol.asyncIterator in ${value})`;
+      }
+      function* TBigInt(schema, references, value) {
+        yield `(typeof ${value} === 'bigint')`;
+        if ((0, guard_1.IsBigInt)(schema.exclusiveMaximum))
+          yield `${value} < BigInt(${schema.exclusiveMaximum})`;
+        if ((0, guard_1.IsBigInt)(schema.exclusiveMinimum))
+          yield `${value} > BigInt(${schema.exclusiveMinimum})`;
+        if ((0, guard_1.IsBigInt)(schema.maximum))
+          yield `${value} <= BigInt(${schema.maximum})`;
+        if ((0, guard_1.IsBigInt)(schema.minimum))
+          yield `${value} >= BigInt(${schema.minimum})`;
+        if ((0, guard_1.IsBigInt)(schema.multipleOf))
+          yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
+      }
+      function* TBoolean(schema, references, value) {
+        yield `(typeof ${value} === 'boolean')`;
+      }
+      function* TConstructor(schema, references, value) {
+        yield* Visit(schema.returns, references, `${value}.prototype`);
+      }
+      function* TDate(schema, references, value) {
+        yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
+        if ((0, guard_1.IsNumber)(schema.exclusiveMaximumTimestamp))
+          yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
+        if ((0, guard_1.IsNumber)(schema.exclusiveMinimumTimestamp))
+          yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
+        if ((0, guard_1.IsNumber)(schema.maximumTimestamp))
+          yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
+        if ((0, guard_1.IsNumber)(schema.minimumTimestamp))
+          yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
+        if ((0, guard_1.IsNumber)(schema.multipleOfTimestamp))
+          yield `(${value}.getTime() % ${schema.multipleOfTimestamp}) === 0`;
+      }
+      function* TFunction(schema, references, value) {
+        yield `(typeof ${value} === 'function')`;
+      }
+      function* TInteger(schema, references, value) {
+        yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
+        if ((0, guard_1.IsNumber)(schema.exclusiveMaximum))
+          yield `${value} < ${schema.exclusiveMaximum}`;
+        if ((0, guard_1.IsNumber)(schema.exclusiveMinimum))
+          yield `${value} > ${schema.exclusiveMinimum}`;
+        if ((0, guard_1.IsNumber)(schema.maximum))
+          yield `${value} <= ${schema.maximum}`;
+        if ((0, guard_1.IsNumber)(schema.minimum))
+          yield `${value} >= ${schema.minimum}`;
+        if ((0, guard_1.IsNumber)(schema.multipleOf))
+          yield `(${value} % ${schema.multipleOf}) === 0`;
+      }
+      function* TIntersect(schema, references, value) {
+        const check1 = schema.allOf.map((schema2) => CreateExpression(schema2, references, value)).join(" && ");
+        if (schema.unevaluatedProperties === false) {
+          const keyCheck = CreateVariable(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`);
+          const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`;
+          yield `(${check1} && ${check2})`;
+        } else if (Types.TypeGuard.TSchema(schema.unevaluatedProperties)) {
+          const keyCheck = CreateVariable(`${new RegExp(Types.KeyResolver.ResolvePattern(schema))};`);
+          const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`;
+          yield `(${check1} && ${check2})`;
+        } else {
+          yield `(${check1})`;
+        }
+      }
+      function* TIterator(schema, references, value) {
+        yield `(typeof value === 'object' && Symbol.iterator in ${value})`;
+      }
+      function* TLiteral(schema, references, value) {
+        if (typeof schema.const === "number" || typeof schema.const === "boolean") {
+          yield `(${value} === ${schema.const})`;
+        } else {
+          yield `(${value} === '${LiteralString.Escape(schema.const)}')`;
+        }
+      }
+      function* TNever(schema, references, value) {
+        yield `false`;
+      }
+      function* TNot(schema, references, value) {
+        const expression = CreateExpression(schema.not, references, value);
+        yield `(!${expression})`;
+      }
+      function* TNull(schema, references, value) {
+        yield `(${value} === null)`;
+      }
+      function* TNumber(schema, references, value) {
+        yield Policy.IsNumberLike(value);
+        if ((0, guard_1.IsNumber)(schema.exclusiveMaximum))
+          yield `${value} < ${schema.exclusiveMaximum}`;
+        if ((0, guard_1.IsNumber)(schema.exclusiveMinimum))
+          yield `${value} > ${schema.exclusiveMinimum}`;
+        if ((0, guard_1.IsNumber)(schema.maximum))
+          yield `${value} <= ${schema.maximum}`;
+        if ((0, guard_1.IsNumber)(schema.minimum))
+          yield `${value} >= ${schema.minimum}`;
+        if ((0, guard_1.IsNumber)(schema.multipleOf))
+          yield `(${value} % ${schema.multipleOf}) === 0`;
+      }
+      function* TObject(schema, references, value) {
+        yield Policy.IsObjectLike(value);
+        if ((0, guard_1.IsNumber)(schema.minProperties))
+          yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
+        if ((0, guard_1.IsNumber)(schema.maxProperties))
+          yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
+        const knownKeys = Object.getOwnPropertyNames(schema.properties);
+        for (const knownKey of knownKeys) {
+          const memberExpression = MemberExpression.Encode(value, knownKey);
+          const property = schema.properties[knownKey];
+          if (schema.required && schema.required.includes(knownKey)) {
+            yield* Visit(property, references, memberExpression);
+            if (Types.ExtendsUndefined.Check(property) || IsAnyOrUnknown(property))
+              yield `('${knownKey}' in ${value})`;
+          } else {
+            const expression = CreateExpression(property, references, memberExpression);
+            yield Policy.IsExactOptionalProperty(value, knownKey, expression);
+          }
+        }
+        if (schema.additionalProperties === false) {
+          if (schema.required && schema.required.length === knownKeys.length) {
+            yield `Object.getOwnPropertyNames(${value}).length === ${knownKeys.length}`;
+          } else {
+            const keys = `[${knownKeys.map((key) => `'${key}'`).join(", ")}]`;
+            yield `Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key))`;
+          }
+        }
+        if (typeof schema.additionalProperties === "object") {
+          const expression = CreateExpression(schema.additionalProperties, references, `${value}[key]`);
+          const keys = `[${knownKeys.map((key) => `'${key}'`).join(", ")}]`;
+          yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
+        }
+      }
+      function* TPromise(schema, references, value) {
+        yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
+      }
+      function* TRecord(schema, references, value) {
+        yield Policy.IsRecordLike(value);
+        if ((0, guard_1.IsNumber)(schema.minProperties))
+          yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
+        if ((0, guard_1.IsNumber)(schema.maxProperties))
+          yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
+        const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
+        const variable = CreateVariable(`${new RegExp(patternKey)}`);
+        const check1 = CreateExpression(patternSchema, references, "value");
+        const check2 = Types.TypeGuard.TSchema(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? "false" : "true";
+        const expression = `(${variable}.test(key) ? ${check1} : ${check2})`;
+        yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`;
+      }
+      function* TRef(schema, references, value) {
+        const target = (0, deref_1.Deref)(schema, references);
+        if (state.functions.has(schema.$ref))
+          return yield `${CreateFunctionName(schema.$ref)}(${value})`;
+        yield* Visit(target, references, value);
+      }
+      function* TString(schema, references, value) {
+        yield `(typeof ${value} === 'string')`;
+        if ((0, guard_1.IsNumber)(schema.maxLength))
+          yield `${value}.length <= ${schema.maxLength}`;
+        if ((0, guard_1.IsNumber)(schema.minLength))
+          yield `${value}.length >= ${schema.minLength}`;
+        if (schema.pattern !== void 0) {
+          const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
+          yield `${variable}.test(${value})`;
+        }
+        if (schema.format !== void 0) {
+          yield `format('${schema.format}', ${value})`;
+        }
+      }
+      function* TSymbol(schema, references, value) {
+        yield `(typeof ${value} === 'symbol')`;
+      }
+      function* TTemplateLiteral(schema, references, value) {
+        yield `(typeof ${value} === 'string')`;
+        const variable = CreateVariable(`${new RegExp(schema.pattern)};`);
+        yield `${variable}.test(${value})`;
+      }
+      function* TThis(schema, references, value) {
+        yield `${CreateFunctionName(schema.$ref)}(${value})`;
+      }
+      function* TTuple(schema, references, value) {
+        yield `Array.isArray(${value})`;
+        if (schema.items === void 0)
+          return yield `${value}.length === 0`;
+        yield `(${value}.length === ${schema.maxItems})`;
+        for (let i = 0; i < schema.items.length; i++) {
+          const expression = CreateExpression(schema.items[i], references, `${value}[${i}]`);
+          yield `${expression}`;
+        }
+      }
+      function* TUndefined(schema, references, value) {
+        yield `${value} === undefined`;
+      }
+      function* TUnion(schema, references, value) {
+        const expressions = schema.anyOf.map((schema2) => CreateExpression(schema2, references, value));
+        yield `(${expressions.join(" || ")})`;
+      }
+      function* TUint8Array(schema, references, value) {
+        yield `${value} instanceof Uint8Array`;
+        if ((0, guard_1.IsNumber)(schema.maxByteLength))
+          yield `(${value}.length <= ${schema.maxByteLength})`;
+        if ((0, guard_1.IsNumber)(schema.minByteLength))
+          yield `(${value}.length >= ${schema.minByteLength})`;
+      }
+      function* TUnknown(schema, references, value) {
+        yield "true";
+      }
+      function* TVoid(schema, references, value) {
+        yield Policy.IsVoidLike(value);
+      }
+      function* TKind(schema, references, value) {
+        const instance = state.instances.size;
+        state.instances.set(instance, schema);
+        yield `kind('${schema[Types.Kind]}', ${instance}, ${value})`;
+      }
+      function* Visit(schema, references, value, useHoisting = true) {
+        const references_ = (0, guard_1.IsString)(schema.$id) ? [...references, schema] : references;
+        const schema_ = schema;
+        if (useHoisting && (0, guard_1.IsString)(schema.$id)) {
+          const functionName = CreateFunctionName(schema.$id);
+          if (state.functions.has(functionName)) {
+            return yield `${functionName}(${value})`;
+          } else {
+            const functionCode = CreateFunction(functionName, schema, references, "value", false);
+            state.functions.set(functionName, functionCode);
+            return yield `${functionName}(${value})`;
+          }
+        }
+        switch (schema_[Types.Kind]) {
+          case "Any":
+            return yield* TAny(schema_, references_, value);
+          case "Array":
+            return yield* TArray(schema_, references_, value);
+          case "AsyncIterator":
+            return yield* TAsyncIterator(schema_, references_, value);
+          case "BigInt":
+            return yield* TBigInt(schema_, references_, value);
+          case "Boolean":
+            return yield* TBoolean(schema_, references_, value);
+          case "Constructor":
+            return yield* TConstructor(schema_, references_, value);
+          case "Date":
+            return yield* TDate(schema_, references_, value);
+          case "Function":
+            return yield* TFunction(schema_, references_, value);
+          case "Integer":
+            return yield* TInteger(schema_, references_, value);
+          case "Intersect":
+            return yield* TIntersect(schema_, references_, value);
+          case "Iterator":
+            return yield* TIterator(schema_, references_, value);
+          case "Literal":
+            return yield* TLiteral(schema_, references_, value);
+          case "Never":
+            return yield* TNever(schema_, references_, value);
+          case "Not":
+            return yield* TNot(schema_, references_, value);
+          case "Null":
+            return yield* TNull(schema_, references_, value);
+          case "Number":
+            return yield* TNumber(schema_, references_, value);
+          case "Object":
+            return yield* TObject(schema_, references_, value);
+          case "Promise":
+            return yield* TPromise(schema_, references_, value);
+          case "Record":
+            return yield* TRecord(schema_, references_, value);
+          case "Ref":
+            return yield* TRef(schema_, references_, value);
+          case "String":
+            return yield* TString(schema_, references_, value);
+          case "Symbol":
+            return yield* TSymbol(schema_, references_, value);
+          case "TemplateLiteral":
+            return yield* TTemplateLiteral(schema_, references_, value);
+          case "This":
+            return yield* TThis(schema_, references_, value);
+          case "Tuple":
+            return yield* TTuple(schema_, references_, value);
+          case "Undefined":
+            return yield* TUndefined(schema_, references_, value);
+          case "Union":
+            return yield* TUnion(schema_, references_, value);
+          case "Uint8Array":
+            return yield* TUint8Array(schema_, references_, value);
+          case "Unknown":
+            return yield* TUnknown(schema_, references_, value);
+          case "Void":
+            return yield* TVoid(schema_, references_, value);
+          default:
+            if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
+              throw new TypeCompilerUnknownTypeError(schema);
+            return yield* TKind(schema_, references_, value);
+        }
+      }
+      const state = {
+        language: "javascript",
+        functions: /* @__PURE__ */ new Map(),
+        variables: /* @__PURE__ */ new Map(),
+        instances: /* @__PURE__ */ new Map()
+        // exterior kind instances
+      };
+      function CreateExpression(schema, references, value, useHoisting = true) {
+        return `(${[...Visit(schema, references, value, useHoisting)].join(" && ")})`;
+      }
+      function CreateFunctionName($id) {
+        return `check_${Identifier.Encode($id)}`;
+      }
+      function CreateVariable(expression) {
+        const variableName = `local_${state.variables.size}`;
+        state.variables.set(variableName, `const ${variableName} = ${expression}`);
+        return variableName;
+      }
+      function CreateFunction(name, schema, references, value, useHoisting = true) {
+        const [newline, pad] = ["\n", (length) => "".padStart(length, " ")];
+        const parameter = CreateParameter("value", "any");
+        const returns = CreateReturns("boolean");
+        const expression = [...Visit(schema, references, value, useHoisting)].map((expression2) => `${pad(4)}${expression2}`).join(` &&${newline}`);
+        return `function ${name}(${parameter})${returns} {${newline}${pad(2)}return (${newline}${expression}${newline}${pad(2)})
+}`;
+      }
+      function CreateParameter(name, type) {
+        const annotation = state.language === "typescript" ? `: ${type}` : "";
+        return `${name}${annotation}`;
+      }
+      function CreateReturns(type) {
+        return state.language === "typescript" ? `: ${type}` : "";
+      }
+      function Build(schema, references, options) {
+        const functionCode = CreateFunction("check", schema, references, "value");
+        const parameter = CreateParameter("value", "any");
+        const returns = CreateReturns("boolean");
+        const functions = [...state.functions.values()];
+        const variables = [...state.variables.values()];
+        const checkFunction = (0, guard_1.IsString)(schema.$id) ? `return function check(${parameter})${returns} {
+  return ${CreateFunctionName(schema.$id)}(value)
+}` : `return ${functionCode}`;
+        return [...variables, ...functions, checkFunction].join("\n");
+      }
+      function Code(...args) {
+        const defaults = { language: "javascript" };
+        const [schema, references, options] = args.length === 2 && (0, guard_1.IsArray)(args[1]) ? [args[0], args[1], defaults] : args.length === 2 && !(0, guard_1.IsArray)(args[1]) ? [args[0], [], args[1]] : args.length === 3 ? [args[0], args[1], args[2]] : args.length === 1 ? [args[0], [], defaults] : [null, [], defaults];
+        state.language = options.language;
+        state.variables.clear();
+        state.functions.clear();
+        state.instances.clear();
+        if (!Types.TypeGuard.TSchema(schema))
+          throw new TypeCompilerTypeGuardError(schema);
+        for (const schema2 of references)
+          if (!Types.TypeGuard.TSchema(schema2))
+            throw new TypeCompilerTypeGuardError(schema2);
+        return Build(schema, references, options);
+      }
+      TypeCompiler3.Code = Code;
+      function Compile(schema, references = []) {
+        const generatedCode = Code(schema, references, { language: "javascript" });
+        const compiledFunction = globalThis.Function("kind", "format", "hash", generatedCode);
+        const instances = new Map(state.instances);
+        function typeRegistryFunction(kind, instance, value) {
+          if (!Types.TypeRegistry.Has(kind) || !instances.has(instance))
+            return false;
+          const checkFunc = Types.TypeRegistry.Get(kind);
+          const schema2 = instances.get(instance);
+          return checkFunc(schema2, value);
+        }
+        function formatRegistryFunction(format, value) {
+          if (!Types.FormatRegistry.Has(format))
+            return false;
+          const checkFunc = Types.FormatRegistry.Get(format);
+          return checkFunc(value);
+        }
+        function hashFunction(value) {
+          return (0, hash_1.Hash)(value);
+        }
+        const checkFunction = compiledFunction(typeRegistryFunction, formatRegistryFunction, hashFunction);
+        return new TypeCheck(schema, references, checkFunction, generatedCode);
+      }
+      TypeCompiler3.Compile = Compile;
+    })(TypeCompiler2 || (exports.TypeCompiler = TypeCompiler2 = {}));
+  }
+});
+
+// ../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/compiler/index.js
+var require_compiler2 = __commonJS({
+  "../../../node_modules/.pnpm/@sinclair+typebox@0.31.28/node_modules/@sinclair/typebox/compiler/index.js"(exports) {
+    "use strict";
+    init_dirname();
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    } : function(o, m, k, k2) {
+      if (k2 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ValueErrorIterator = exports.ValueErrorType = void 0;
+    var index_1 = require_errors2();
+    Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function() {
+      return index_1.ValueErrorType;
+    } });
+    Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function() {
+      return index_1.ValueErrorIterator;
+    } });
+    __exportStar(require_compiler(), exports);
+  }
+});
+
+// src/stream.ts
+init_dirname();
+
+// src/stream/writeable.ts
+init_dirname();
+
+// src/applog/applog-helpers.ts
+init_dirname();
+
+// src/query/basic.ts
+init_dirname();
+var { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO, { prefix: "[q]" });
+var QueryNode = class {
+  constructor(logsOfThisNode, variables, prev = null) {
+    this.logsOfThisNode = logsOfThisNode;
+    this.variables = variables;
+    this.prev = prev;
+    makeObservable(this, {
+      allApplogs: computed
+      // ? intuitively only put the ones here that felt expensive to compute (join)
+    });
+  }
+  get record() {
+    return this.variables;
+  }
+  get allApplogs() {
+    if (!this.prev)
+      return this.logsOfThisNode;
+    return joinStreams([
+      this.logsOfThisNode,
+      this.prev.allApplogs
+    ]);
+  }
+};
+var QueryNodes = class {
+  constructor(nodes) {
+    this.nodes = nodes;
+    makeObservable(this, {
+      allApplogs: computed,
+      // ? intuitively only put the ones here that felt expensive to compute (join)
+      size: computed,
+      // ... or cheap to cache
+      isEmpty: computed
+    });
+  }
+  get size() {
+    return this.records.length;
+  }
+  get isEmpty() {
+    return this.records.length === 0;
+  }
+  get untrackedSize() {
+    return untracked(() => this.records.length);
+  }
+  get records() {
+    return this.nodes.map(({ variables }) => variables);
+  }
+  get applogSets() {
+    return this.nodes.map(({ logsOfThisNode: stream }) => stream.applogs);
+  }
+  get applogStreams() {
+    return this.nodes.map(({ logsOfThisNode: stream }) => stream);
+  }
+  get allApplogs() {
+    return joinStreams(this.nodes.map((node) => node.allApplogs));
+  }
+};
+var withoutHistory = computedFnDeepCompare(function withoutHistory2(stream, { inverseToOnlyReturnFirstLogs, tolerateAlreadyFiltered } = {}) {
+  VERBOSE(`withoutHistory${inverseToOnlyReturnFirstLogs ? ".inversed" : ""} < ${stream.nameAndSizeUntracked} > initializing`);
+  if (stream.filters.includes("withoutHistory")) {
+    if (tolerateAlreadyFiltered) {
+      DEBUG(`[withoutHistory] already filtered, but tolerateAlreadyFiltered=true, so returning`);
+      return stream;
+    }
+    throw ERROR(`stream already filtered withoutHistory:`, stream.filters, { name: stream.name });
+  }
+  let rollingMap;
+  const mappedStream = rollingMapper(stream, function(event, sourceStream) {
+    const isInitial = isInitEvent(event);
+    let newLogs;
+    const toAdd = [];
+    const toRemove = isInitial ? null : [];
+    if (isInitial) {
+      rollingMap = /* @__PURE__ */ new Map();
+      newLogs = event.init;
+    } else {
+      newLogs = event.added;
+    }
+    let tsCheck;
+    for (let i = inverseToOnlyReturnFirstLogs ? 0 : newLogs.length - 1; inverseToOnlyReturnFirstLogs ? i < newLogs.length : i >= 0; inverseToOnlyReturnFirstLogs ? i++ : i--) {
+      const log = newLogs[i];
+      const key = wrapper_default([log.en, log.at]);
+      if (tsCheck && (inverseToOnlyReturnFirstLogs ? tsCheck > log.ts : tsCheck < log.ts)) {
+        throw ERROR(`withoutHistory.mapper logs not sorted:`, tsCheck, inverseToOnlyReturnFirstLogs ? ">" : "<", log.ts, {
+          log,
+          i,
+          newLogs,
+          inverseToOnlyReturnFirstLogs
+        });
+      }
+      tsCheck = log.ts;
+      const existing = rollingMap.get(key);
+      if (!existing || (inverseToOnlyReturnFirstLogs ? existing.ts > log.ts : existing.ts < log.ts)) {
+        if (existing && !isInitial)
+          toRemove.push(existing);
+        toAdd.push(log);
+        rollingMap.set(key, log);
+      }
+    }
+    sortApplogsByTs(toAdd);
+    VERBOSE.isDisabled || VERBOSE(
+      `withoutHistory${inverseToOnlyReturnFirstLogs ? ".inversed" : ""}<${stream.nameAndSizeUntracked}> mapped event`,
+      isInitial ? { ...Object.fromEntries(Object.entries(event).map(([k, v]) => [k, v?.length])), toAdd: toAdd.length, toRemove } : { ...event, toAdd, toRemove }
+    );
+    return isInitial ? { init: toAdd } : { added: toAdd, removed: toRemove };
+  }, { name: `withoutHistory${inverseToOnlyReturnFirstLogs ? ".inversed" : ""}`, extraFilterName: "withoutHistory" });
+  VERBOSE.isDisabled || autorun(() => {
+    VERBOSE(`withoutHistory<${stream.nameAndSizeUntracked}> filtered down to`, mappedStream.applogs.length);
+  });
+  return mappedStream;
+}, { equals: applogStreamComparer });
+var withoutDeleted = computedFnDeepCompare(function withoutDeleted2(stream) {
+  VERBOSE(`withoutDeleted<${stream.nameAndSizeUntracked}>`);
+  if (stream.filters.includes("withoutDeleted")) {
+    throw ERROR(`stream already filtered withoutDeleted:`, stream.filters, { name: stream.name });
+  }
+  const deletionLogs = rollingFilter(
+    stream,
+    // TODO: handle un-delection
+    { at: ["isDeleted", "relation/isDeleted", "block/isDeleted"], vl: true },
+    { name: "isDeleted" }
+  );
+  VERBOSE(`withoutDeleted<${stream.nameAndSizeUntracked}> deletionLogs:`, untracked(() => [...deletionLogs.applogs]));
+  const obsArrMapName = createDebugName({ caller: "allDeletedEntities", stream });
+  const deleted = observableArrayMap(() => deletionLogs.map((log) => log.en), { name: obsArrMapName });
+  VERBOSE.isDisabled || autorun(() => {
+    VERBOSE(`withoutDeleted<${stream.nameAndSizeUntracked}> deleted:`, [...deleted]);
+  });
+  return rollingFilter(stream, { "!en": deleted }, { name: `withoutDeleted`, extraFilterName: "withoutDeleted" });
+}, { equals: applogStreamComparer });
+var query = computedFnDeepCompare(function query2(stream, patternOrPatterns, startVariables = {}, opts = {}) {
+  DEBUG(`query<${stream.nameAndSizeUntracked}>:`, patternOrPatterns);
+  const patterns = Array.isArray(patternOrPatterns) ? patternOrPatterns : [patternOrPatterns];
+  let nodes;
+  if (patterns.length === 1) {
+    nodes = null;
+  } else {
+    const pattersExceptLast = patterns.slice(0, -1);
+    nodes = query2(stream, pattersExceptLast, startVariables, opts);
+  }
+  const lastPattern = patterns[patterns.length - 1];
+  const stepResult = queryStep(stream, nodes, lastPattern, opts);
+  VERBOSE.isDisabled || autorun(() => VERBOSE(`query result:`, toJS(stepResult)));
+  return stepResult;
+}, { equals: queryNodesComparer });
+var queryStep = computedFnDeepCompare(function queryStep2(stream, nodeSet, pattern, opts = {}) {
+  DEBUG(`queryStep<${stream.nameAndSizeUntracked}> with`, nodeSet?.untrackedSize ?? "all", "nodes, pattern:", pattern);
+  if (!Object.entries(pattern).length)
+    throw new Error(`Pattern is empty`);
+  const observableResultNodes = observableArrayMap(
+    () => {
+      function doQuery(node) {
+        const [patternWithResolvedVars, variablesToFill] = resolveOrRemoveVariables(pattern, node?.variables ?? {});
+        VERBOSE(`[queryStep] patternWithoutVars: `, patternWithResolvedVars);
+        const applogsMatchingStatic = rollingFilter(stream, patternWithResolvedVars);
+        const varMapper = mapTo(variablesToFill);
+        const newVarsAndTheirLog = applogsMatchingStatic.map((log) => ({ log, vars: varMapper(log) }));
+        VERBOSE.isDisabled || VERBOSE(
+          `[queryStep] step node:`,
+          node?.variables,
+          " =>",
+          newVarsAndTheirLog,
+          "from:",
+          untracked(() => applogsMatchingStatic.applogs)
+        );
+        const resultNodes = newVarsAndTheirLog.map(({ log, vars }) => {
+          const nodeVars = Object.assign({}, node?.variables, vars);
+          return new QueryNode(
+            new ApplogStreamInMemory(
+              [log],
+              stream.filters,
+              createDebugName({
+                caller: "QueryNode",
+                stream: applogsMatchingStatic,
+                pattern: `${wrapper_default(nodeVars)}@${wrapper_default(patternWithResolvedVars)}`
+              }),
+              true,
+              applogsMatchingStatic
+            ),
+            nodeVars,
+            node
+          );
+        });
+        if (opts.debug) {
+          LOG(
+            `[queryStep] step result:`,
+            untracked(
+              () => resultNodes.map(({ variables, logsOfThisNode: stream2 }) => ({
+                variables,
+                stream: (
+                  /* util.inspect( */
+                  stream2.applogs
+                )
+                /* , { showHidden: false, depth: null }) */
+              }))
+            )
+          );
+        }
+        return resultNodes;
+      }
+      if (nodeSet) {
+        return nodeSet.nodes.flatMap(doQuery);
+      } else {
+        return doQuery(null);
+      }
+    },
+    { name: createDebugName({ caller: "queryStep", stream, pattern }) }
+  );
+  VERBOSE(`queryStep result:`, observableResultNodes);
+  return new QueryNodes(observableResultNodes);
+}, { equals: queryNodesComparer });
+var queryNot = computedFnDeepCompare(function queryNot2(stream, startNodes, patternOrPatterns, opts = {}) {
+  let nodes = startNodes.nodes;
+  DEBUG(`queryNot<${stream.nameAndSizeUntracked}> from: ${nodes.length} nodes`);
+  const patterns = Array.isArray(patternOrPatterns) ? patternOrPatterns : [patternOrPatterns];
+  for (const pattern of patterns) {
+    if (!Object.entries(patternOrPatterns).length)
+      throw new Error(`Pattern is empty`);
+    nodes = nodes.filter(({
+      /* applogs, */
+      variables
+    }) => {
+      const [patternWithResolvedVars, _variablesToFill] = resolveOrRemoveVariables(pattern, variables ?? {});
+      VERBOSE(`[queryNot] patternWithoutVars: `, patternWithResolvedVars);
+      const newApplogs = rollingFilter(stream, patternWithResolvedVars);
+      VERBOSE(`[queryNot] step node:`, variables, " =>", newApplogs.size, "applogs");
+      VERBOSE.isDisabled || VERBOSE(`[queryNot] step node:`, variables, " => empty?", untracked(() => newApplogs.applogs));
+      if (opts.debug)
+        LOG(`[queryNot] node result:`, variables, "=>", newApplogs.applogs);
+      return newApplogs.isEmpty;
+    });
+  }
+  return new QueryNodes(nodes);
+}, { equals: queryNodesComparer });
+var filterAndMap = computedFnDeepCompare(function filterAndMap2(stream, pattern, mapper) {
+  DEBUG(`filterAndMap<${stream.nameAndSizeUntracked}>`, pattern);
+  const filtered = rollingFilter(stream, pattern);
+  VERBOSE(`[filterAndMap] filtered:`, filtered.untrackedSize);
+  VERBOSE.isDisabled || autorun(() => VERBOSE(`[filterAndMap] filtered:`, filtered.applogs));
+  const mapperFX = function filterAndMapGetterFx() {
+    if (typeof mapper === "function") {
+      return filtered.map(mapper);
+    } else if (typeof mapper === "string") {
+      return filtered.map((log) => log[mapper]);
+    } else {
+      return filtered.map(mapTo(mapper));
+    }
+  };
+  const name = createDebugName({ stream, pattern, caller: "filterAndMap" });
+  const mapped = observableArrayMap(mapperFX, { name });
+  VERBOSE.isDisabled || autorun(() => VERBOSE(`[filterAndMap] mapped:`, mapped));
+  return mapped;
+}, { equals: comparer.structural });
+var queryAndMap = computedFnDeepCompare(function queryAndMap2(stream, patternOrPatterns, map, variables = {}) {
+  DEBUG(`queryAndMap<${stream.nameAndSizeUntracked}>`, { patternOrPatterns, variables, map });
+  const debugName = createDebugName({ stream, caller: "queryAndMap" });
+  const filtered = query(stream, patternOrPatterns);
+  VERBOSE(`[queryAndMap] filtered count:`, filtered.untrackedSize);
+  const mapped = observableArrayMap(
+    () => {
+      if (typeof map === "function") {
+        return filtered.records.map(map);
+      } else if (typeof map === "string") {
+        return filtered.records.map((log) => log[map]);
+      } else {
+        throw new Error("what's this map param about?");
+      }
+    },
+    { name: debugName }
+  );
+  VERBOSE.isDisabled || autorun(() => VERBOSE(`[queryAndMap] result:`, toJS(mapped)));
+  return mapped;
+}, { equals: comparer.structural });
+var queryEntity = computedFnDeepCompare(function queryEntity2(stream, name, entityID, attributes) {
+  DEBUG(`queryEntity<${stream.nameAndSizeUntracked}>`, entityID, name);
+  const filtered = rollingFilter(stream, { en: entityID, at: prefixAttrs(name, attributes) });
+  VERBOSE(`queryEntity applogs:`, filtered.applogs);
+  return computed(
+    () => filtered.isEmpty ? null : Object.fromEntries(
+      filtered.map(({ at, vl }) => [at.slice(name.length + 1), vl])
+    )
+  );
+}, { equals: computedStructuralComparer });
+var agentsOfStream = computedFnDeepCompare(function agentsOfStream2(stream) {
+  LOG(`agentsOfStream<${stream.nameAndSizeUntracked}>`);
+  const mapped = observable.map();
+  function onEvent(event) {
+    for (const log of isInitEvent(event) ? event.init : event.added) {
+      const prev = mapped.get(log.ag) ?? 0;
+      mapped.set(log.ag, prev + 1);
+    }
+    for (const log of !isInitEvent(event) && event.removed || []) {
+      const prev = mapped.get(log.ag);
+      if (!prev || prev < 1)
+        throw ERROR(`[agentsOfStream] number is now negative`, { log, event, mapped, prev });
+      mapped.set(log.ag, prev - 1);
+    }
+    LOG(`agentsOfStream<${stream.nameAndSizeUntracked}> processed event`, { event, mapped });
+  }
+  untracked(() => onEvent({ init: stream.applogs }));
+  stream.subscribe(onEvent);
+  onBecomeObserved(mapped, () => stream.unsubscribe(onEvent));
+  return mapped;
+});
+var entityOverlap = computedFnDeepCompare(function entityOverlapCount(streamA, streamB) {
+  LOG(`entityOverlap<${streamA.nameAndSizeUntracked}, ${streamB.nameAndSizeUntracked}>`);
+  return computed(() => {
+    const entitiesA = new Set(streamA.map((log) => log.en));
+    const entitiesB = new Set(streamB.map((log) => log.en));
+    return [...entitiesA].filter((en) => entitiesB.has(en));
+  });
+});
+var entityOverlapCount2 = computedFnDeepCompare(function entityOverlapCount3(streamA, streamB) {
+  return computed(() => entityOverlap(streamA, streamB).get().length);
+});
+function mapTo(applogFieldMap) {
+  return (applog) => {
+    return Object.entries(applogFieldMap).reduce((acc, [key, value]) => {
+      acc[value] = applog[key];
+      return acc;
+    }, {});
+  };
+}
+function startsWith(str) {
+  return (value) => value.startsWith(str);
+}
+function prefixAttrs(prefix, attrs) {
+  return attrs.map((at) => prefixAt(prefix, at));
+}
+function prefixAt(prefix, attr) {
+  return `${prefix}/${attr}`;
+}
+
+// src/applog/applog-helpers.ts
+var { WARN: WARN2, LOG: LOG2, DEBUG: DEBUG2, VERBOSE: VERBOSE2, ERROR: ERROR2 } = Logger.setup(Logger.INFO);
+function hasAg(log) {
+  return !!log.ag;
+}
+function hasTs(log) {
+  return !!log.ts;
+}
+function hasPv(log) {
+  return !!log.pv;
+}
+function withTs(log, ts) {
+  return hasTs(log) ? log : { ...log, ts };
+}
+function withPv(log, ds) {
+  const { en, at } = log;
+  const pvs = filterAndMap(withoutHistory(ds), { en, at }, "cid");
+  if (pvs.length > 1)
+    WARN2(`[withPv] unexpected result count:`, pvs.length);
+  let pv = pvs.length ? pvs[0] : null;
+  const isMatchingPv = !!(pv === log.pv);
+  if (log.pv && !isMatchingPv)
+    WARN2(`[withPv] different than pre-set pv:`, { queriedPv: pv, logPv: log.pv });
+  pv = log.pv ?? pv;
+  return { ...log, pv: pv ?? null };
+}
+function joinStreams(streams) {
+  if (streams.length === 0)
+    throw ERROR2(`joinStreams called with empty array`);
+  if (streams.length === 1)
+    return streams[0];
+  const fullJoin = () => sortApplogsByTs(
+    removeDuplicateAppLogs(streams.flatMap((s) => {
+      const logs = s.applogs;
+      if (!logs) {
+        ERROR2(`falsy applogs of stream`, s);
+        throw new Error(`falsy applogs of stream`);
+      }
+      return logs;
+    }))
+  );
+  const initialMergeResult = untracked(() => fullJoin());
+  const eventMapper = action(function(event, sourceStream) {
+    if (isInitEvent(event)) {
+      return { init: untracked(() => fullJoin()) };
+    } else {
+      return {
+        // TODO: test this stuff
+        added: event.added.filter((addedLog) => !this.hasApplog(addedLog, true)),
+        removed: event.added.filter(
+          (addedLog) => !this.parents.some((parent) => {
+            if (parent === sourceStream)
+              return false;
+            return parent.hasApplog(addedLog, true);
+          })
+        )
+      };
+    }
+  });
+  return new MappedApplogStream(streams, ["?"], initialMergeResult, eventMapper, `join(${streams.map((s) => s.name).join(", ")})`);
+}
+
+// src/applog/datom-types.ts
+init_dirname();
+var import_typebox = __toESM(require_typebox(), 1);
+var import_compiler = __toESM(require_compiler2(), 1);
+var Nullable = (schema) => import_typebox.Type.Union([schema, import_typebox.Type.Null()]);
+var EntityID_LENGTH = 7;
+var isCID = /^(k51qz|baguq)[0-9a-z]{56,57}$/;
+var isShortHash = /^[0-9A-Fa-f]{7,8}$/g;
+import_typebox.FormatRegistry.Set("EntityID", (value) => !!value.match(isShortHash) || !!value.match(isCID));
+var EntityID = import_typebox.Type.String();
+import_typebox.FormatRegistry.Set("CID", (value) => !!value.match(isCID));
+var CIDTB = import_typebox.Type.String({ format: "EntityID" });
+var isURL = /^http([s]?):\/\/.*\..*/;
+import_typebox.FormatRegistry.Set("URL", (value) => !!value.match(isURL));
+var URL = import_typebox.Type.String({ format: "URL" });
+var AppLogTB = import_typebox.Type.Object({
+  en: EntityID,
+  // EntityID
+  at: import_typebox.Type.String(),
+  // Attribute
+  vl: Nullable(import_typebox.Type.Union([import_typebox.Type.String(), import_typebox.Type.Boolean(), import_typebox.Type.Number()])),
+  // TODO refactor to semantic typesafe ApplogValue
+  ts: import_typebox.Type.String(),
+  // Timestamp
+  ag: import_typebox.Type.String()
+  // AgentHash
+});
+var AppLogTBC = import_compiler.TypeCompiler.Compile(AppLogTB);
+var getApplogTypeErrors = (obj) => Array.from(AppLogTBC.Errors(obj));
+var isValidApplog = AppLogTBC.Check.bind(AppLogTBC);
+
+// src/stream/writeable.ts
+var { WARN: WARN3, LOG: LOG3, DEBUG: DEBUG3, VERBOSE: VERBOSE3, ERROR: ERROR3 } = Logger.setup(Logger.INFO);
+var WriteableApplogStream = class extends ApplogStream {
+  constructor(parents, filters, applogs = [], name) {
+    super(parents, filters, applogs, name);
+    makeObservable(this, {
+      insert: action
+      // ? is there an advantage to do this here instead of wrapping the fx in action below?
+    });
+  }
+  insert(appLogsToInsert) {
+    const ts = dateNowIso();
+    const mapped = appLogsToInsert.map((log) => {
+      const logWithTs = withTs(log, ts);
+      if (!isValidApplog(logWithTs)) {
+        throw ERROR3(`Bogus Applog ${JSON.stringify(logWithTs)}`, getApplogTypeErrors(logWithTs));
+      }
+      const logWithPv = withPv(logWithTs, this);
+      const cid = encodeApplogAndGetCid(logWithPv).toString();
+      const logWithCid = { ...logWithPv, cid };
+      return Object.freeze(logWithCid);
+    });
+    const mappedLogs = removeDuplicateAppLogs(mapped);
+    if (appLogsToInsert.length !== mappedLogs.length) {
+      WARN3("request to insert duplicate log, inserting mappedLogs:", { appLogsToInsert, mappedLogs });
+    } else if (!appLogsToInsert.length) {
+      WARN3("request to insert empty logs array");
+    } else {
+      LOG3("Inserting:", mappedLogs.length === 1 ? mappedLogs[0] : mappedLogs, { ds: this });
+    }
+    if (!mappedLogs.length)
+      return [];
+    sortApplogsByTs(mappedLogs);
+    const sortNeeded = this._applogs.length && isTsBefore(mappedLogs[0], this._applogs[this._applogs.length - 1]);
+    this._applogs.push(...mappedLogs);
+    if (sortNeeded) {
+      sortApplogsByTs(this._applogs);
+    }
+    this.notifySubscribers({ added: mappedLogs, removed: null });
+    void this.persist(mappedLogs);
+    return mappedLogs;
+  }
+  get readOnly() {
+    return false;
+  }
+};
+var ApplogStreamInMemory = class extends WriteableApplogStream {
+  constructor(applogs, filters, name, _readOnly, parents = null) {
+    super(parents, filters, applogs, name);
+    this._readOnly = _readOnly;
+    makeObservable(this, {
+      // @ts-expect-error bc it's private
+      _applogs: observable.shallow
+    });
+  }
+  get readOnly() {
+    return this._readOnly;
+  }
+  persist(logs) {
+    VERBOSE3(`[InMem.persist] no persist for`, logs);
+    if (this.readOnly) {
+      throw ERROR3(`[persist] called for readOnly stream`);
+    }
+  }
+};
+
+export {
+  require_typebox,
+  require_system2 as require_system,
+  Nullable,
+  EntityID_LENGTH,
+  EntityID,
+  CIDTB,
+  URL,
+  AppLogTB,
+  AppLogTBC,
+  getApplogTypeErrors,
+  isValidApplog,
+  WriteableApplogStream,
+  ApplogStreamInMemory,
+  QueryNode,
+  QueryNodes,
+  withoutHistory,
+  withoutDeleted,
+  query,
+  queryStep,
+  queryNot,
+  filterAndMap,
+  queryAndMap,
+  queryEntity,
+  agentsOfStream,
+  entityOverlap,
+  entityOverlapCount2 as entityOverlapCount,
+  mapTo,
+  startsWith,
+  prefixAttrs,
+  prefixAt,
+  hasAg,
+  hasTs,
+  hasPv,
+  withTs,
+  withPv,
+  joinStreams
+};
+//# sourceMappingURL=chunk-MTQJBBHB.js.map