@elysiajs/jwt 1.1.0 → 1.2.0-rc.0

package/dist/cjs/index.js

@@ -18,18 +18,19 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  default: () => src_default,
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
   jwt: () => jwt
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 var import_elysia = require("elysia");
 var import_jose = require("jose");
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var value_exports = {};
 __export(value_exports, {
+  HasPropertyKey: () => HasPropertyKey,
   IsArray: () => IsArray,
   IsAsyncIterator: () => IsAsyncIterator,
   IsBigInt: () => IsBigInt,
@@ -46,6 +47,9 @@ __export(value_exports, {
   IsUint8Array: () => IsUint8Array,
   IsUndefined: () => IsUndefined
 });
+function HasPropertyKey(value, key) {
+  return key in value;
+}
 function IsAsyncIterator(value) {
   return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
 }
@@ -123,11 +127,94 @@ function Clone(value) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
-function CloneRest(schemas) {
-  return schemas.map((schema) => CloneType(schema));
+function CloneType(schema, options) {
+  return options === void 0 ? Clone(schema) : Clone({ ...options, ...schema });
+}
+
+// node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
+function IsObject2(value) {
+  return value !== null && typeof value === "object";
+}
+function IsArray2(value) {
+  return Array.isArray(value) && !ArrayBuffer.isView(value);
+}
+function IsUndefined2(value) {
+  return value === void 0;
+}
+function IsNumber2(value) {
+  return typeof value === "number";
+}
+
+// node_modules/@sinclair/typebox/build/esm/system/policy.mjs
+var TypeSystemPolicy;
+(function(TypeSystemPolicy2) {
+  TypeSystemPolicy2.InstanceMode = "default";
+  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 = IsObject2(value);
+    return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !IsArray2(value);
+  }
+  TypeSystemPolicy2.IsObjectLike = IsObjectLike;
+  function IsRecordLike(value) {
+    return IsObjectLike(value) && !(value instanceof Date) && !(value instanceof Uint8Array);
+  }
+  TypeSystemPolicy2.IsRecordLike = IsRecordLike;
+  function IsNumberLike(value) {
+    return TypeSystemPolicy2.AllowNaN ? IsNumber2(value) : Number.isFinite(value);
+  }
+  TypeSystemPolicy2.IsNumberLike = IsNumberLike;
+  function IsVoidLike(value) {
+    const isUndefined = IsUndefined2(value);
+    return TypeSystemPolicy2.AllowNullVoid ? isUndefined || value === null : isUndefined;
+  }
+  TypeSystemPolicy2.IsVoidLike = IsVoidLike;
+})(TypeSystemPolicy || (TypeSystemPolicy = {}));
+
+// node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs
+function ImmutableArray(value) {
+  return globalThis.Object.freeze(value).map((value2) => Immutable(value2));
+}
+function ImmutableDate(value) {
+  return value;
+}
+function ImmutableUint8Array(value) {
+  return value;
 }
-function CloneType(schema, options = {}) {
-  return { ...Clone(schema), ...options };
+function ImmutableRegExp(value) {
+  return value;
+}
+function ImmutableObject(value) {
+  const result = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Immutable(value[key]);
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Immutable(value[key]);
+  }
+  return globalThis.Object.freeze(result);
+}
+function Immutable(value) {
+  return IsArray(value) ? ImmutableArray(value) : IsDate(value) ? ImmutableDate(value) : IsUint8Array(value) ? ImmutableUint8Array(value) : IsRegExp(value) ? ImmutableRegExp(value) : IsObject(value) ? ImmutableObject(value) : value;
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/create/type.mjs
+function CreateType(schema, options) {
+  const result = options !== void 0 ? { ...options, ...schema } : schema;
+  switch (TypeSystemPolicy.InstanceMode) {
+    case "freeze":
+      return Immutable(result);
+    case "clone":
+      return Clone(result);
+    default:
+      return result;
+  }
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
@@ -154,7 +241,7 @@ function IsOptional(value) {
 function IsAny(value) {
   return IsKindOf(value, "Any");
 }
-function IsArray2(value) {
+function IsArray3(value) {
   return IsKindOf(value, "Array");
 }
 function IsAsyncIterator2(value) {
@@ -166,6 +253,9 @@ function IsBigInt2(value) {
 function IsBoolean2(value) {
   return IsKindOf(value, "Boolean");
 }
+function IsComputed(value) {
+  return IsKindOf(value, "Computed");
+}
 function IsConstructor(value) {
   return IsKindOf(value, "Constructor");
 }
@@ -187,6 +277,9 @@ function IsIterator2(value) {
 function IsKindOf(value, kind) {
   return IsObject(value) && Kind in value && value[Kind] === kind;
 }
+function IsLiteralValue(value) {
+  return IsBoolean(value) || IsNumber(value) || IsString(value);
+}
 function IsLiteral(value) {
   return IsKindOf(value, "Literal");
 }
@@ -205,10 +298,10 @@ function IsNot(value) {
 function IsNull2(value) {
   return IsKindOf(value, "Null");
 }
-function IsNumber2(value) {
+function IsNumber3(value) {
   return IsKindOf(value, "Number");
 }
-function IsObject2(value) {
+function IsObject3(value) {
   return IsKindOf(value, "Object");
 }
 function IsPromise(value) {
@@ -241,7 +334,7 @@ function IsTransform(value) {
 function IsTuple(value) {
   return IsKindOf(value, "Tuple");
 }
-function IsUndefined2(value) {
+function IsUndefined3(value) {
   return IsKindOf(value, "Undefined");
 }
 function IsUnion(value) {
@@ -263,20 +356,22 @@ function IsKind(value) {
   return IsObject(value) && Kind in value && IsString(value[Kind]);
 }
 function IsSchema(value) {
-  return IsAny(value) || IsArray2(value) || IsBoolean2(value) || IsBigInt2(value) || IsAsyncIterator2(value) || IsConstructor(value) || IsDate2(value) || IsFunction2(value) || IsInteger(value) || IsIntersect(value) || IsIterator2(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull2(value) || IsNumber2(value) || IsObject2(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString2(value) || IsSymbol2(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined2(value) || IsUnion(value) || IsUint8Array2(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
+  return IsAny(value) || IsArray3(value) || IsBoolean2(value) || IsBigInt2(value) || IsAsyncIterator2(value) || IsComputed(value) || IsConstructor(value) || IsDate2(value) || IsFunction2(value) || IsInteger(value) || IsIntersect(value) || IsIterator2(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull2(value) || IsNumber3(value) || IsObject3(value) || IsPromise(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString2(value) || IsSymbol2(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined3(value) || IsUnion(value) || IsUint8Array2(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
 var type_exports = {};
 __export(type_exports, {
   IsAny: () => IsAny2,
-  IsArray: () => IsArray3,
+  IsArray: () => IsArray4,
   IsAsyncIterator: () => IsAsyncIterator3,
   IsBigInt: () => IsBigInt3,
   IsBoolean: () => IsBoolean3,
+  IsComputed: () => IsComputed2,
   IsConstructor: () => IsConstructor2,
   IsDate: () => IsDate3,
   IsFunction: () => IsFunction3,
+  IsImport: () => IsImport,
   IsInteger: () => IsInteger2,
   IsIntersect: () => IsIntersect2,
   IsIterator: () => IsIterator3,
@@ -286,14 +381,14 @@ __export(type_exports, {
   IsLiteralBoolean: () => IsLiteralBoolean,
   IsLiteralNumber: () => IsLiteralNumber,
   IsLiteralString: () => IsLiteralString,
-  IsLiteralValue: () => IsLiteralValue,
+  IsLiteralValue: () => IsLiteralValue2,
   IsMappedKey: () => IsMappedKey2,
   IsMappedResult: () => IsMappedResult2,
   IsNever: () => IsNever2,
   IsNot: () => IsNot2,
   IsNull: () => IsNull3,
-  IsNumber: () => IsNumber3,
-  IsObject: () => IsObject3,
+  IsNumber: () => IsNumber4,
+  IsObject: () => IsObject4,
   IsOptional: () => IsOptional2,
   IsPromise: () => IsPromise2,
   IsProperties: () => IsProperties,
@@ -310,7 +405,7 @@ __export(type_exports, {
   IsTransform: () => IsTransform2,
   IsTuple: () => IsTuple2,
   IsUint8Array: () => IsUint8Array3,
-  IsUndefined: () => IsUndefined3,
+  IsUndefined: () => IsUndefined4,
   IsUnion: () => IsUnion2,
   IsUnionLiteral: () => IsUnionLiteral,
   IsUnknown: () => IsUnknown2,
@@ -326,6 +421,7 @@ var KnownTypes = [
   "AsyncIterator",
   "BigInt",
   "Boolean",
+  "Computed",
   "Constructor",
   "Date",
   "Enum",
@@ -407,7 +503,7 @@ function IsOptional2(value) {
 function IsAny2(value) {
   return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
 }
-function IsArray3(value) {
+function IsArray4(value) {
   return IsKindOf2(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema2(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
 }
 function IsAsyncIterator3(value) {
@@ -419,6 +515,9 @@ function IsBigInt3(value) {
 function IsBoolean3(value) {
   return IsKindOf2(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
 }
+function IsComputed2(value) {
+  return IsKindOf2(value, "Computed") && IsString(value.target) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema));
+}
 function IsConstructor2(value) {
   return IsKindOf2(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
 }
@@ -428,6 +527,9 @@ function IsDate3(value) {
 function IsFunction3(value) {
   return IsKindOf2(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
 }
+function IsImport(value) {
+  return IsKindOf2(value, "Import") && HasPropertyKey(value, "$defs") && IsObject(value.$defs) && IsProperties(value.$defs) && HasPropertyKey(value, "$ref") && IsString(value.$ref) && value.$ref in value.$defs;
+}
 function IsInteger2(value) {
   return IsKindOf2(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
 }
@@ -453,9 +555,9 @@ function IsLiteralBoolean(value) {
   return IsLiteral2(value) && IsBoolean(value.const);
 }
 function IsLiteral2(value) {
-  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue(value.const);
+  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue2(value.const);
 }
-function IsLiteralValue(value) {
+function IsLiteralValue2(value) {
   return IsBoolean(value) || IsNumber(value) || IsString(value);
 }
 function IsMappedKey2(value) {
@@ -473,10 +575,10 @@ function IsNot2(value) {
 function IsNull3(value) {
   return IsKindOf2(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
 }
-function IsNumber3(value) {
+function IsNumber4(value) {
   return IsKindOf2(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
 }
-function IsObject3(value) {
+function IsObject4(value) {
   return IsKindOf2(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
 }
 function IsPromise2(value) {
@@ -516,7 +618,7 @@ function IsTuple2(value) {
   return IsKindOf2(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber(value.minItems) && IsNumber(value.maxItems) && value.minItems === value.maxItems && // empty
   (IsUndefined(value.items) && IsUndefined(value.additionalItems) && value.minItems === 0 || IsArray(value.items) && value.items.every((schema) => IsSchema2(schema)));
 }
-function IsUndefined3(value) {
+function IsUndefined4(value) {
   return IsKindOf2(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
 }
 function IsUnionLiteral(value) {
@@ -541,16 +643,18 @@ function IsKind2(value) {
   return IsObject(value) && Kind in value && IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
 }
 function IsSchema2(value) {
-  return IsObject(value) && (IsAny2(value) || IsArray3(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsConstructor2(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect2(value) || IsIterator3(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull3(value) || IsNumber3(value) || IsObject3(value) || IsPromise2(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined3(value) || IsUnion2(value) || IsUint8Array3(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
+  return IsObject(value) && (IsAny2(value) || IsArray4(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsComputed2(value) || IsConstructor2(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect2(value) || IsIterator3(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull3(value) || IsNumber4(value) || IsObject4(value) || IsPromise2(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined4(value) || IsUnion2(value) || IsUint8Array3(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
 var PatternBoolean = "(true|false)";
 var PatternNumber = "(0|[1-9][0-9]*)";
 var PatternString = "(.*)";
+var PatternNever = "(?!.*)";
 var PatternBooleanExact = `^${PatternBoolean}$`;
 var PatternNumberExact = `^${PatternNumber}$`;
 var PatternStringExact = `^${PatternString}$`;
+var PatternNeverExact = `^${PatternNever}$`;
 
 // node_modules/@sinclair/typebox/build/esm/type/sets/set.mjs
 function SetIncludes(T, S) {
@@ -578,28 +682,23 @@ function SetUnionMany(T) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/any/any.mjs
-function Any(options = {}) {
-  return { ...options, [Kind]: "Any" };
+function Any(options) {
+  return CreateType({ [Kind]: "Any" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/array/array.mjs
-function Array2(schema, options = {}) {
-  return {
-    ...options,
-    [Kind]: "Array",
-    type: "array",
-    items: CloneType(schema)
-  };
+function Array2(items, options) {
+  return CreateType({ [Kind]: "Array", type: "array", items }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs
-function AsyncIterator(items, options = {}) {
-  return {
-    ...options,
-    [Kind]: "AsyncIterator",
-    type: "AsyncIterator",
-    items: CloneType(items)
-  };
+function AsyncIterator(items, options) {
+  return CreateType({ [Kind]: "AsyncIterator", type: "AsyncIterator", items }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/computed/computed.mjs
+function Computed(target, parameters, options) {
+  return CreateType({ [Kind]: "Computed", target, parameters }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/discard/discard.mjs
@@ -612,69 +711,54 @@ function Discard(value, keys) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/never/never.mjs
-function Never(options = {}) {
-  return {
-    ...options,
-    [Kind]: "Never",
-    not: {}
-  };
+function Never(options) {
+  return CreateType({ [Kind]: "Never", not: {} }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-result.mjs
 function MappedResult(properties) {
-  return {
+  return CreateType({
     [Kind]: "MappedResult",
     properties
-  };
+  });
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.mjs
 function Constructor(parameters, returns, options) {
-  return {
-    ...options,
-    [Kind]: "Constructor",
-    type: "Constructor",
-    parameters: CloneRest(parameters),
-    returns: CloneType(returns)
-  };
+  return CreateType({ [Kind]: "Constructor", type: "Constructor", parameters, returns }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/function/function.mjs
 function Function(parameters, returns, options) {
-  return {
-    ...options,
-    [Kind]: "Function",
-    type: "Function",
-    parameters: CloneRest(parameters),
-    returns: CloneType(returns)
-  };
+  return CreateType({ [Kind]: "Function", type: "Function", parameters, returns }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/union/union-create.mjs
 function UnionCreate(T, options) {
-  return { ...options, [Kind]: "Union", anyOf: CloneRest(T) };
+  return CreateType({ [Kind]: "Union", anyOf: T }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.mjs
-function IsUnionOptional(T) {
-  return T.some((L) => IsOptional(L));
+function IsUnionOptional(types) {
+  return types.some((type) => IsOptional(type));
 }
-function RemoveOptionalFromRest(T) {
-  return T.map((L) => IsOptional(L) ? RemoveOptionalFromType(L) : L);
+function RemoveOptionalFromRest(types) {
+  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
 }
 function RemoveOptionalFromType(T) {
   return Discard(T, [OptionalKind]);
 }
-function ResolveUnion(T, options) {
-  return IsUnionOptional(T) ? Optional(UnionCreate(RemoveOptionalFromRest(T), options)) : UnionCreate(RemoveOptionalFromRest(T), options);
+function ResolveUnion(types, options) {
+  const isOptional = IsUnionOptional(types);
+  return isOptional ? Optional(UnionCreate(RemoveOptionalFromRest(types), options)) : UnionCreate(RemoveOptionalFromRest(types), options);
 }
-function UnionEvaluated(T, options = {}) {
-  return T.length === 0 ? Never(options) : T.length === 1 ? CloneType(T[0], options) : ResolveUnion(T, options);
+function UnionEvaluated(T, options) {
+  return T.length === 1 ? CreateType(T[0], options) : T.length === 0 ? Never(options) : ResolveUnion(T, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/union/union.mjs
-function Union(T, options = {}) {
-  return T.length === 0 ? Never(options) : T.length === 1 ? CloneType(T[0], options) : UnionCreate(T, options);
+function Union(types, options) {
+  return types.length === 0 ? Never(options) : types.length === 1 ? CreateType(types[0], options) : UnionCreate(types, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.mjs
@@ -856,51 +940,38 @@ function TemplateLiteralGenerate(schema) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/literal/literal.mjs
-function Literal(value, options = {}) {
-  return {
-    ...options,
+function Literal(value, options) {
+  return CreateType({
     [Kind]: "Literal",
     const: value,
     type: typeof value
-  };
+  }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/boolean/boolean.mjs
-function Boolean(options = {}) {
-  return {
-    ...options,
-    [Kind]: "Boolean",
-    type: "boolean"
-  };
+function Boolean(options) {
+  return CreateType({ [Kind]: "Boolean", type: "boolean" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.mjs
-function BigInt(options = {}) {
-  return {
-    ...options,
-    [Kind]: "BigInt",
-    type: "bigint"
-  };
+function BigInt(options) {
+  return CreateType({ [Kind]: "BigInt", type: "bigint" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/number/number.mjs
-function Number(options = {}) {
-  return {
-    ...options,
-    [Kind]: "Number",
-    type: "number"
-  };
+function Number2(options) {
+  return CreateType({ [Kind]: "Number", type: "number" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/string/string.mjs
-function String(options = {}) {
-  return { ...options, [Kind]: "String", type: "string" };
+function String(options) {
+  return CreateType({ [Kind]: "String", type: "string" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/template-literal/syntax.mjs
 function* FromUnion(syntax) {
   const trim = syntax.trim().replace(/"|'/g, "");
-  return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String() : yield (() => {
+  return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String() : yield (() => {
     const literals = trim.split("|").map((literal) => Literal(literal.trim()));
     return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
   })();
@@ -941,7 +1012,7 @@ function Escape(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function Visit2(schema, acc) {
-  return IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit2(schema2, acc)).join("|")})` : IsNumber2(schema) ? `${acc}${PatternNumber}` : IsInteger(schema) ? `${acc}${PatternNumber}` : IsBigInt2(schema) ? `${acc}${PatternNumber}` : IsString2(schema) ? `${acc}${PatternString}` : IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean2(schema) ? `${acc}${PatternBoolean}` : (() => {
+  return IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit2(schema2, acc)).join("|")})` : IsNumber3(schema) ? `${acc}${PatternNumber}` : IsInteger(schema) ? `${acc}${PatternNumber}` : IsBigInt2(schema) ? `${acc}${PatternNumber}` : IsString2(schema) ? `${acc}${PatternString}` : IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean2(schema) ? `${acc}${PatternBoolean}` : (() => {
     throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`);
   })();
 }
@@ -957,139 +1028,142 @@ function TemplateLiteralToUnion(schema) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/template-literal/template-literal.mjs
-function TemplateLiteral(unresolved, options = {}) {
+function TemplateLiteral(unresolved, options) {
   const pattern = IsString(unresolved) ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) : TemplateLiteralPattern(unresolved);
-  return { ...options, [Kind]: "TemplateLiteral", type: "string", pattern };
+  return CreateType({ [Kind]: "TemplateLiteral", type: "string", pattern }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.mjs
-function FromTemplateLiteral(T) {
-  const R = TemplateLiteralGenerate(T);
-  return R.map((S) => S.toString());
-}
-function FromUnion2(T) {
-  const Acc = [];
-  for (const L of T)
-    Acc.push(...IndexPropertyKeys(L));
-  return Acc;
+function FromTemplateLiteral(templateLiteral) {
+  const keys = TemplateLiteralGenerate(templateLiteral);
+  return keys.map((key) => key.toString());
+}
+function FromUnion2(types) {
+  const result = [];
+  for (const type of types)
+    result.push(...IndexPropertyKeys(type));
+  return result;
 }
-function FromLiteral(T) {
-  return [T.toString()];
+function FromLiteral(literalValue) {
+  return [literalValue.toString()];
 }
-function IndexPropertyKeys(T) {
-  return [...new Set(IsTemplateLiteral(T) ? FromTemplateLiteral(T) : IsUnion(T) ? FromUnion2(T.anyOf) : IsLiteral(T) ? FromLiteral(T.const) : IsNumber2(T) ? ["[number]"] : IsInteger(T) ? ["[number]"] : [])];
+function IndexPropertyKeys(type) {
+  return [...new Set(IsTemplateLiteral(type) ? FromTemplateLiteral(type) : IsUnion(type) ? FromUnion2(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : IsNumber3(type) ? ["[number]"] : IsInteger(type) ? ["[number]"] : [])];
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.mjs
-function FromProperties(T, P, options) {
-  const Acc = {};
-  for (const K2 of Object.getOwnPropertyNames(P)) {
-    Acc[K2] = Index(T, IndexPropertyKeys(P[K2]), options);
+function FromProperties(type, properties, options) {
+  const result = {};
+  for (const K2 of Object.getOwnPropertyNames(properties)) {
+    result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
   }
-  return Acc;
+  return result;
 }
-function FromMappedResult(T, R, options) {
-  return FromProperties(T, R.properties, options);
+function FromMappedResult(type, mappedResult, options) {
+  return FromProperties(type, mappedResult.properties, options);
 }
-function IndexFromMappedResult(T, R, options) {
-  const P = FromMappedResult(T, R, options);
-  return MappedResult(P);
+function IndexFromMappedResult(type, mappedResult, options) {
+  const properties = FromMappedResult(type, mappedResult, options);
+  return MappedResult(properties);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.mjs
-function FromRest(T, K) {
-  return T.map((L) => IndexFromPropertyKey(L, K));
+function FromRest(types, key) {
+  return types.map((type) => IndexFromPropertyKey(type, key));
 }
-function FromIntersectRest(T) {
-  return T.filter((L) => !IsNever(L));
+function FromIntersectRest(types) {
+  return types.filter((type) => !IsNever(type));
 }
-function FromIntersect(T, K) {
-  return IntersectEvaluated(FromIntersectRest(FromRest(T, K)));
+function FromIntersect(types, key) {
+  return IntersectEvaluated(FromIntersectRest(FromRest(types, key)));
 }
-function FromUnionRest(T) {
-  return T.some((L) => IsNever(L)) ? [] : T;
+function FromUnionRest(types) {
+  return types.some((L) => IsNever(L)) ? [] : types;
 }
-function FromUnion3(T, K) {
-  return UnionEvaluated(FromUnionRest(FromRest(T, K)));
+function FromUnion3(types, key) {
+  return UnionEvaluated(FromUnionRest(FromRest(types, key)));
 }
-function FromTuple(T, K) {
-  return K in T ? T[K] : K === "[number]" ? UnionEvaluated(T) : Never();
+function FromTuple(types, key) {
+  return key in types ? types[key] : key === "[number]" ? UnionEvaluated(types) : Never();
 }
-function FromArray(T, K) {
-  return K === "[number]" ? T : Never();
+function FromArray(type, key) {
+  return key === "[number]" ? type : Never();
 }
-function FromProperty(T, K) {
-  return K in T ? T[K] : Never();
+function FromProperty(properties, propertyKey) {
+  return propertyKey in properties ? properties[propertyKey] : Never();
 }
-function IndexFromPropertyKey(T, K) {
-  return IsIntersect(T) ? FromIntersect(T.allOf, K) : IsUnion(T) ? FromUnion3(T.anyOf, K) : IsTuple(T) ? FromTuple(T.items ?? [], K) : IsArray2(T) ? FromArray(T.items, K) : IsObject2(T) ? FromProperty(T.properties, K) : Never();
+function IndexFromPropertyKey(type, propertyKey) {
+  return IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) : IsUnion(type) ? FromUnion3(type.anyOf, propertyKey) : IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) : IsArray3(type) ? FromArray(type.items, propertyKey) : IsObject3(type) ? FromProperty(type.properties, propertyKey) : Never();
 }
-function IndexFromPropertyKeys(T, K) {
-  return K.map((L) => IndexFromPropertyKey(T, L));
+function IndexFromPropertyKeys(type, propertyKeys) {
+  return propertyKeys.map((propertyKey) => IndexFromPropertyKey(type, propertyKey));
 }
-function FromSchema(T, K) {
-  return UnionEvaluated(IndexFromPropertyKeys(T, K));
+function FromSchema(type, propertyKeys) {
+  return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
 }
-function Index(T, K, options = {}) {
-  return IsMappedResult(K) ? CloneType(IndexFromMappedResult(T, K, options)) : IsMappedKey(K) ? CloneType(IndexFromMappedKey(T, K, options)) : IsSchema(K) ? CloneType(FromSchema(T, IndexPropertyKeys(K)), options) : CloneType(FromSchema(T, K), options);
+function Index(type, key, options) {
+  if (IsRef(type) || IsRef(key)) {
+    const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+    if (!IsSchema(type) || !IsSchema(key))
+      throw new TypeBoxError(error);
+    return Computed("Index", [type, key]);
+  }
+  if (IsMappedResult(key))
+    return IndexFromMappedResult(type, key, options);
+  if (IsMappedKey(key))
+    return IndexFromMappedKey(type, key, options);
+  return CreateType(IsSchema(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(type, key), options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.mjs
-function MappedIndexPropertyKey(T, K, options) {
-  return { [K]: Index(T, [K], options) };
+function MappedIndexPropertyKey(type, key, options) {
+  return { [key]: Index(type, [key], Clone(options)) };
 }
-function MappedIndexPropertyKeys(T, K, options) {
-  return K.reduce((Acc, L) => {
-    return { ...Acc, ...MappedIndexPropertyKey(T, L, options) };
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+  return propertyKeys.reduce((result, left) => {
+    return { ...result, ...MappedIndexPropertyKey(type, left, options) };
   }, {});
 }
-function MappedIndexProperties(T, K, options) {
-  return MappedIndexPropertyKeys(T, K.keys, options);
+function MappedIndexProperties(type, mappedKey, options) {
+  return MappedIndexPropertyKeys(type, mappedKey.keys, options);
 }
-function IndexFromMappedKey(T, K, options) {
-  const P = MappedIndexProperties(T, K, options);
-  return MappedResult(P);
+function IndexFromMappedKey(type, mappedKey, options) {
+  const properties = MappedIndexProperties(type, mappedKey, options);
+  return MappedResult(properties);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/iterator/iterator.mjs
-function Iterator(items, options = {}) {
-  return {
-    ...options,
-    [Kind]: "Iterator",
-    type: "Iterator",
-    items: CloneType(items)
-  };
+function Iterator(items, options) {
+  return CreateType({ [Kind]: "Iterator", type: "Iterator", items }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/object/object.mjs
-function _Object(properties, options = {}) {
-  const propertyKeys = globalThis.Object.getOwnPropertyNames(properties);
-  const optionalKeys = propertyKeys.filter((key) => IsOptional(properties[key]));
-  const requiredKeys = propertyKeys.filter((name) => !optionalKeys.includes(name));
-  const clonedAdditionalProperties = IsSchema(options.additionalProperties) ? { additionalProperties: CloneType(options.additionalProperties) } : {};
-  const clonedProperties = {};
-  for (const key of propertyKeys)
-    clonedProperties[key] = CloneType(properties[key]);
-  return requiredKeys.length > 0 ? { ...options, ...clonedAdditionalProperties, [Kind]: "Object", type: "object", properties: clonedProperties, required: requiredKeys } : { ...options, ...clonedAdditionalProperties, [Kind]: "Object", type: "object", properties: clonedProperties };
+function RequiredKeys(properties) {
+  const keys = [];
+  for (let key in properties) {
+    if (!IsOptional(properties[key]))
+      keys.push(key);
+  }
+  return keys;
+}
+function _Object(properties, options) {
+  const required = RequiredKeys(properties);
+  const schematic = required.length > 0 ? { [Kind]: "Object", type: "object", properties, required } : { [Kind]: "Object", type: "object", properties };
+  return CreateType(schematic, options);
 }
 var Object2 = _Object;
 
 // node_modules/@sinclair/typebox/build/esm/type/promise/promise.mjs
-function Promise2(item, options = {}) {
-  return {
-    ...options,
-    [Kind]: "Promise",
-    type: "Promise",
-    item: CloneType(item)
-  };
+function Promise2(item, options) {
+  return CreateType({ [Kind]: "Promise", type: "Promise", item }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/readonly/readonly.mjs
 function RemoveReadonly(schema) {
-  return Discard(CloneType(schema), [ReadonlyKind]);
+  return CreateType(Discard(schema, [ReadonlyKind]));
 }
 function AddReadonly(schema) {
-  return { ...CloneType(schema), [ReadonlyKind]: "Readonly" };
+  return CreateType({ ...schema, [ReadonlyKind]: "Readonly" });
 }
 function ReadonlyWithFlag(schema, F) {
   return F === false ? RemoveReadonly(schema) : AddReadonly(schema);
@@ -1115,9 +1189,8 @@ function ReadonlyFromMappedResult(R, F) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.mjs
-function Tuple(items, options = {}) {
-  const [additionalItems, minItems, maxItems] = [false, items.length, items.length];
-  return items.length > 0 ? { ...options, [Kind]: "Tuple", type: "array", items: CloneRest(items), additionalItems, minItems, maxItems } : { ...options, [Kind]: "Tuple", type: "array", minItems, maxItems };
+function Tuple(types, options) {
+  return CreateType(types.length > 0 ? { [Kind]: "Tuple", type: "array", items: types, additionalItems: false, minItems: types.length, maxItems: types.length } : { [Kind]: "Tuple", type: "array", minItems: types.length, maxItems: types.length }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/mapped/mapped.mjs
@@ -1150,13 +1223,14 @@ function FromProperties3(K, T) {
   return Acc;
 }
 function FromSchemaType(K, T) {
+  const options = { ...T };
   return (
     // unevaluated modifier types
     IsOptional(T) ? Optional(FromSchemaType(K, Discard(T, [OptionalKind]))) : IsReadonly(T) ? Readonly(FromSchemaType(K, Discard(T, [ReadonlyKind]))) : (
       // unevaluated mapped types
       IsMappedResult(T) ? FromMappedResult3(K, T.properties) : IsMappedKey(T) ? FromMappedKey(K, T.keys) : (
         // unevaluated types
-        IsConstructor(T) ? Constructor(FromRest2(K, T.parameters), FromSchemaType(K, T.returns)) : IsFunction2(T) ? Function(FromRest2(K, T.parameters), FromSchemaType(K, T.returns)) : IsAsyncIterator2(T) ? AsyncIterator(FromSchemaType(K, T.items)) : IsIterator2(T) ? Iterator(FromSchemaType(K, T.items)) : IsIntersect(T) ? Intersect(FromRest2(K, T.allOf)) : IsUnion(T) ? Union(FromRest2(K, T.anyOf)) : IsTuple(T) ? Tuple(FromRest2(K, T.items ?? [])) : IsObject2(T) ? Object2(FromProperties3(K, T.properties)) : IsArray2(T) ? Array2(FromSchemaType(K, T.items)) : IsPromise(T) ? Promise2(FromSchemaType(K, T.item)) : T
+        IsConstructor(T) ? Constructor(FromRest2(K, T.parameters), FromSchemaType(K, T.returns), options) : IsFunction2(T) ? Function(FromRest2(K, T.parameters), FromSchemaType(K, T.returns), options) : IsAsyncIterator2(T) ? AsyncIterator(FromSchemaType(K, T.items), options) : IsIterator2(T) ? Iterator(FromSchemaType(K, T.items), options) : IsIntersect(T) ? Intersect(FromRest2(K, T.allOf), options) : IsUnion(T) ? Union(FromRest2(K, T.anyOf), options) : IsTuple(T) ? Tuple(FromRest2(K, T.items ?? []), options) : IsObject3(T) ? Object2(FromProperties3(K, T.properties), options) : IsArray3(T) ? Array2(FromSchemaType(K, T.items), options) : IsPromise(T) ? Promise2(FromSchemaType(K, T.item), options) : T
       )
     )
   );
@@ -1167,19 +1241,19 @@ function MappedFunctionReturnType(K, T) {
     Acc[L] = FromSchemaType(L, T);
   return Acc;
 }
-function Mapped(key, map, options = {}) {
+function Mapped(key, map, options) {
   const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
   const RT = map({ [Kind]: "MappedKey", keys: K });
   const R = MappedFunctionReturnType(K, RT);
-  return CloneType(Object2(R), options);
+  return Object2(R, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/optional/optional.mjs
 function RemoveOptional(schema) {
-  return Discard(CloneType(schema), [OptionalKind]);
+  return CreateType(Discard(schema, [OptionalKind]));
 }
 function AddOptional(schema) {
-  return { ...CloneType(schema), [OptionalKind]: "Optional" };
+  return CreateType({ ...schema, [OptionalKind]: "Optional" });
 }
 function OptionalWithFlag(schema, F) {
   return F === false ? RemoveOptional(schema) : AddOptional(schema);
@@ -1205,85 +1279,96 @@ function OptionalFromMappedResult(R, F) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-create.mjs
-function IntersectCreate(T, options) {
-  const allObjects = T.every((schema) => IsObject2(schema));
-  const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties) ? { unevaluatedProperties: CloneType(options.unevaluatedProperties) } : {};
-  return options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects ? { ...options, ...clonedUnevaluatedProperties, [Kind]: "Intersect", type: "object", allOf: CloneRest(T) } : { ...options, ...clonedUnevaluatedProperties, [Kind]: "Intersect", allOf: CloneRest(T) };
+function IntersectCreate(T, options = {}) {
+  const allObjects = T.every((schema) => IsObject3(schema));
+  const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties) ? { unevaluatedProperties: options.unevaluatedProperties } : {};
+  return CreateType(options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects ? { ...clonedUnevaluatedProperties, [Kind]: "Intersect", type: "object", allOf: T } : { ...clonedUnevaluatedProperties, [Kind]: "Intersect", allOf: T }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.mjs
-function IsIntersectOptional(T) {
-  return T.every((L) => IsOptional(L));
+function IsIntersectOptional(types) {
+  return types.every((left) => IsOptional(left));
 }
-function RemoveOptionalFromType2(T) {
-  return Discard(T, [OptionalKind]);
+function RemoveOptionalFromType2(type) {
+  return Discard(type, [OptionalKind]);
 }
-function RemoveOptionalFromRest2(T) {
-  return T.map((L) => IsOptional(L) ? RemoveOptionalFromType2(L) : L);
+function RemoveOptionalFromRest2(types) {
+  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType2(left) : left);
 }
-function ResolveIntersect(T, options) {
-  return IsIntersectOptional(T) ? Optional(IntersectCreate(RemoveOptionalFromRest2(T), options)) : IntersectCreate(RemoveOptionalFromRest2(T), options);
+function ResolveIntersect(types, options) {
+  return IsIntersectOptional(types) ? Optional(IntersectCreate(RemoveOptionalFromRest2(types), options)) : IntersectCreate(RemoveOptionalFromRest2(types), options);
 }
-function IntersectEvaluated(T, options = {}) {
-  if (T.length === 0)
+function IntersectEvaluated(types, options = {}) {
+  if (types.length === 1)
+    return CreateType(types[0], options);
+  if (types.length === 0)
     return Never(options);
-  if (T.length === 1)
-    return CloneType(T[0], options);
-  if (T.some((schema) => IsTransform(schema)))
+  if (types.some((schema) => IsTransform(schema)))
     throw new Error("Cannot intersect transform types");
-  return ResolveIntersect(T, options);
+  return ResolveIntersect(types, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.mjs
-function Intersect(T, options = {}) {
-  if (T.length === 0)
+function Intersect(types, options) {
+  if (types.length === 1)
+    return CreateType(types[0], options);
+  if (types.length === 0)
     return Never(options);
-  if (T.length === 1)
-    return CloneType(T[0], options);
-  if (T.some((schema) => IsTransform(schema)))
+  if (types.some((schema) => IsTransform(schema)))
     throw new Error("Cannot intersect transform types");
-  return IntersectCreate(T, options);
+  return IntersectCreate(types, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/ref/ref.mjs
+function Ref(...args) {
+  const [$ref, options] = typeof args[0] === "string" ? [args[0], args[1]] : [args[0].$id, args[1]];
+  if (typeof $ref !== "string")
+    throw new TypeBoxError("Ref: $ref must be a string");
+  return CreateType({ [Kind]: "Ref", $ref }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/awaited/awaited.mjs
-function FromRest3(T) {
-  return T.map((L) => AwaitedResolve(L));
+function FromComputed(target, parameters) {
+  return Computed("Awaited", [Computed(target, parameters)]);
+}
+function FromRef($ref) {
+  return Computed("Awaited", [Ref($ref)]);
 }
-function FromIntersect2(T) {
-  return Intersect(FromRest3(T));
+function FromIntersect2(types) {
+  return Intersect(FromRest3(types));
 }
-function FromUnion4(T) {
-  return Union(FromRest3(T));
+function FromUnion4(types) {
+  return Union(FromRest3(types));
 }
-function FromPromise(T) {
-  return AwaitedResolve(T);
+function FromPromise(type) {
+  return Awaited(type);
 }
-function AwaitedResolve(T) {
-  return IsIntersect(T) ? FromIntersect2(T.allOf) : IsUnion(T) ? FromUnion4(T.anyOf) : IsPromise(T) ? FromPromise(T.item) : T;
+function FromRest3(types) {
+  return types.map((type) => Awaited(type));
 }
-function Awaited(T, options = {}) {
-  return CloneType(AwaitedResolve(T), options);
+function Awaited(type, options) {
+  return CreateType(IsComputed(type) ? FromComputed(type.target, type.parameters) : IsIntersect(type) ? FromIntersect2(type.allOf) : IsUnion(type) ? FromUnion4(type.anyOf) : IsPromise(type) ? FromPromise(type.item) : IsRef(type) ? FromRef(type.$ref) : type, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.mjs
-function FromRest4(T) {
-  const Acc = [];
-  for (const L of T)
-    Acc.push(KeyOfPropertyKeys(L));
-  return Acc;
+function FromRest4(types) {
+  const result = [];
+  for (const L of types)
+    result.push(KeyOfPropertyKeys(L));
+  return result;
 }
-function FromIntersect3(T) {
-  const C = FromRest4(T);
-  const R = SetUnionMany(C);
-  return R;
+function FromIntersect3(types) {
+  const propertyKeysArray = FromRest4(types);
+  const propertyKeys = SetUnionMany(propertyKeysArray);
+  return propertyKeys;
 }
-function FromUnion5(T) {
-  const C = FromRest4(T);
-  const R = SetIntersectMany(C);
-  return R;
+function FromUnion5(types) {
+  const propertyKeysArray = FromRest4(types);
+  const propertyKeys = SetIntersectMany(propertyKeysArray);
+  return propertyKeys;
 }
-function FromTuple2(T) {
-  return T.map((_, I) => I.toString());
+function FromTuple2(types) {
+  return types.map((_, indexer) => indexer.toString());
 }
 function FromArray2(_) {
   return ["[number]"];
@@ -1299,39 +1384,44 @@ function FromPatternProperties(patternProperties) {
     return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
   });
 }
-function KeyOfPropertyKeys(T) {
-  return IsIntersect(T) ? FromIntersect3(T.allOf) : IsUnion(T) ? FromUnion5(T.anyOf) : IsTuple(T) ? FromTuple2(T.items ?? []) : IsArray2(T) ? FromArray2(T.items) : IsObject2(T) ? FromProperties5(T.properties) : IsRecord(T) ? FromPatternProperties(T.patternProperties) : [];
+function KeyOfPropertyKeys(type) {
+  return IsIntersect(type) ? FromIntersect3(type.allOf) : IsUnion(type) ? FromUnion5(type.anyOf) : IsTuple(type) ? FromTuple2(type.items ?? []) : IsArray3(type) ? FromArray2(type.items) : IsObject3(type) ? FromProperties5(type.properties) : IsRecord(type) ? FromPatternProperties(type.patternProperties) : [];
 }
 var includePatternProperties = false;
 
 // node_modules/@sinclair/typebox/build/esm/type/keyof/keyof.mjs
-function KeyOfPropertyKeysToRest(T) {
-  return T.map((L) => L === "[number]" ? Number() : Literal(L));
+function FromComputed2(target, parameters) {
+  return Computed("KeyOf", [Computed(target, parameters)]);
 }
-function KeyOf(T, options = {}) {
-  if (IsMappedResult(T)) {
-    return KeyOfFromMappedResult(T, options);
-  } else {
-    const K = KeyOfPropertyKeys(T);
-    const S = KeyOfPropertyKeysToRest(K);
-    const U = UnionEvaluated(S);
-    return CloneType(U, options);
-  }
+function FromRef2($ref) {
+  return Computed("KeyOf", [Ref($ref)]);
+}
+function KeyOfFromType(type, options) {
+  const propertyKeys = KeyOfPropertyKeys(type);
+  const propertyKeyTypes = KeyOfPropertyKeysToRest(propertyKeys);
+  const result = UnionEvaluated(propertyKeyTypes);
+  return CreateType(result, options);
+}
+function KeyOfPropertyKeysToRest(propertyKeys) {
+  return propertyKeys.map((L) => L === "[number]" ? Number2() : Literal(L));
+}
+function KeyOf(type, options) {
+  return IsComputed(type) ? FromComputed2(type.target, type.parameters) : IsRef(type) ? FromRef2(type.$ref) : IsMappedResult(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.mjs
-function FromProperties6(K, options) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
-    Acc[K2] = KeyOf(K[K2], options);
-  return Acc;
+function FromProperties6(properties, options) {
+  const result = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+    result[K2] = KeyOf(properties[K2], Clone(options));
+  return result;
 }
-function FromMappedResult5(R, options) {
-  return FromProperties6(R.properties, options);
+function FromMappedResult5(mappedResult, options) {
+  return FromProperties6(mappedResult.properties, options);
 }
-function KeyOfFromMappedResult(R, options) {
-  const P = FromMappedResult5(R, options);
-  return MappedResult(P);
+function KeyOfFromMappedResult(mappedResult, options) {
+  const properties = FromMappedResult5(mappedResult, options);
+  return MappedResult(properties);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/composite/composite.mjs
@@ -1357,7 +1447,7 @@ function CompositeProperties(T, K) {
   }
   return Acc;
 }
-function Composite(T, options = {}) {
+function Composite(T, options) {
   const K = CompositeKeys(T);
   const P = CompositeProperties(T, K);
   const R = Object2(P, options);
@@ -1365,44 +1455,33 @@ function Composite(T, options = {}) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/date/date.mjs
-function Date2(options = {}) {
-  return {
-    ...options,
-    [Kind]: "Date",
-    type: "Date"
-  };
+function Date2(options) {
+  return CreateType({ [Kind]: "Date", type: "Date" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/null/null.mjs
-function Null(options = {}) {
-  return {
-    ...options,
-    [Kind]: "Null",
-    type: "null"
-  };
+function Null(options) {
+  return CreateType({ [Kind]: "Null", type: "null" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.mjs
 function Symbol2(options) {
-  return { ...options, [Kind]: "Symbol", type: "symbol" };
+  return CreateType({ [Kind]: "Symbol", type: "symbol" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.mjs
-function Undefined(options = {}) {
-  return { ...options, [Kind]: "Undefined", type: "undefined" };
+function Undefined(options) {
+  return CreateType({ [Kind]: "Undefined", type: "undefined" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.mjs
-function Uint8Array2(options = {}) {
-  return { ...options, [Kind]: "Uint8Array", type: "Uint8Array" };
+function Uint8Array2(options) {
+  return CreateType({ [Kind]: "Uint8Array", type: "Uint8Array" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.mjs
-function Unknown(options = {}) {
-  return {
-    ...options,
-    [Kind]: "Unknown"
-  };
+function Unknown(options) {
+  return CreateType({ [Kind]: "Unknown" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/const/const.mjs
@@ -1421,86 +1500,17 @@ function ConditionalReadonly(T, root) {
 function FromValue(value, root) {
   return IsAsyncIterator(value) ? ConditionalReadonly(Any(), root) : IsIterator(value) ? ConditionalReadonly(Any(), root) : IsArray(value) ? Readonly(Tuple(FromArray3(value))) : IsUint8Array(value) ? Uint8Array2() : IsDate(value) ? Date2() : IsObject(value) ? ConditionalReadonly(Object2(FromProperties7(value)), root) : IsFunction(value) ? ConditionalReadonly(Function([], Unknown()), root) : IsUndefined(value) ? Undefined() : IsNull(value) ? Null() : IsSymbol(value) ? Symbol2() : IsBigInt(value) ? BigInt() : IsNumber(value) ? Literal(value) : IsBoolean(value) ? Literal(value) : IsString(value) ? Literal(value) : Object2({});
 }
-function Const(T, options = {}) {
-  return CloneType(FromValue(T, true), options);
+function Const(T, options) {
+  return CreateType(FromValue(T, true), options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs
-function ConstructorParameters(schema, options = {}) {
-  return Tuple(CloneRest(schema.parameters), { ...options });
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/deref/deref.mjs
-function FromRest5(schema, references) {
-  return schema.map((schema2) => Deref(schema2, references));
-}
-function FromProperties8(properties, references) {
-  const Acc = {};
-  for (const K of globalThis.Object.getOwnPropertyNames(properties)) {
-    Acc[K] = Deref(properties[K], references);
-  }
-  return Acc;
-}
-function FromConstructor(schema, references) {
-  schema.parameters = FromRest5(schema.parameters, references);
-  schema.returns = Deref(schema.returns, references);
-  return schema;
-}
-function FromFunction(schema, references) {
-  schema.parameters = FromRest5(schema.parameters, references);
-  schema.returns = Deref(schema.returns, references);
-  return schema;
-}
-function FromIntersect4(schema, references) {
-  schema.allOf = FromRest5(schema.allOf, references);
-  return schema;
-}
-function FromUnion6(schema, references) {
-  schema.anyOf = FromRest5(schema.anyOf, references);
-  return schema;
-}
-function FromTuple3(schema, references) {
-  if (IsUndefined(schema.items))
-    return schema;
-  schema.items = FromRest5(schema.items, references);
-  return schema;
-}
-function FromArray4(schema, references) {
-  schema.items = Deref(schema.items, references);
-  return schema;
-}
-function FromObject(schema, references) {
-  schema.properties = FromProperties8(schema.properties, references);
-  return schema;
-}
-function FromPromise2(schema, references) {
-  schema.item = Deref(schema.item, references);
-  return schema;
-}
-function FromAsyncIterator(schema, references) {
-  schema.items = Deref(schema.items, references);
-  return schema;
-}
-function FromIterator(schema, references) {
-  schema.items = Deref(schema.items, references);
-  return schema;
-}
-function FromRef(schema, references) {
-  const target = references.find((remote) => remote.$id === schema.$ref);
-  if (target === void 0)
-    throw Error(`Unable to dereference schema with $id ${schema.$ref}`);
-  const discard = Discard(target, ["$id"]);
-  return Deref(discard, references);
-}
-function DerefResolve(schema, references) {
-  return IsConstructor(schema) ? FromConstructor(schema, references) : IsFunction2(schema) ? FromFunction(schema, references) : IsIntersect(schema) ? FromIntersect4(schema, references) : IsUnion(schema) ? FromUnion6(schema, references) : IsTuple(schema) ? FromTuple3(schema, references) : IsArray2(schema) ? FromArray4(schema, references) : IsObject2(schema) ? FromObject(schema, references) : IsPromise(schema) ? FromPromise2(schema, references) : IsAsyncIterator2(schema) ? FromAsyncIterator(schema, references) : IsIterator2(schema) ? FromIterator(schema, references) : IsRef(schema) ? FromRef(schema, references) : schema;
-}
-function Deref(schema, references) {
-  return DerefResolve(CloneType(schema), CloneRest(references));
+function ConstructorParameters(schema, options) {
+  return Tuple(schema.parameters, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs
-function Enum(item, options = {}) {
+function Enum(item, options) {
   if (IsUndefined(item))
     throw new Error("Enum undefined or empty");
   const values1 = globalThis.Object.getOwnPropertyNames(item).filter((key) => isNaN(key)).map((key) => item[key]);
@@ -1539,10 +1549,10 @@ function FromAny(left, right) {
 function FromArrayRight(left, right) {
   return type_exports.IsUnknown(left) ? ExtendsResult.False : type_exports.IsAny(left) ? ExtendsResult.Union : type_exports.IsNever(left) ? ExtendsResult.True : ExtendsResult.False;
 }
-function FromArray5(left, right) {
+function FromArray4(left, right) {
   return type_exports.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : !type_exports.IsArray(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
 }
-function FromAsyncIterator2(left, right) {
+function FromAsyncIterator(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : !type_exports.IsAsyncIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
 }
 function FromBigInt(left, right) {
@@ -1554,13 +1564,13 @@ function FromBooleanRight(left, right) {
 function FromBoolean(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsBoolean(right) ? ExtendsResult.True : ExtendsResult.False;
 }
-function FromConstructor2(left, right) {
+function FromConstructor(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : !type_exports.IsConstructor(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit3(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.returns, right.returns));
 }
 function FromDate(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsDate(right) ? ExtendsResult.True : ExtendsResult.False;
 }
-function FromFunction2(left, right) {
+function FromFunction(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : !type_exports.IsFunction(right) ? ExtendsResult.False : left.parameters.length > right.parameters.length ? ExtendsResult.False : !left.parameters.every((schema, index) => IntoBooleanResult(Visit3(right.parameters[index], schema)) === ExtendsResult.True) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.returns, right.returns));
 }
 function FromIntegerRight(left, right) {
@@ -1572,10 +1582,10 @@ function FromInteger(left, right) {
 function FromIntersectRight(left, right) {
   return right.allOf.every((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
 }
-function FromIntersect5(left, right) {
+function FromIntersect4(left, right) {
   return left.allOf.some((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
 }
-function FromIterator2(left, right) {
+function FromIterator(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : !type_exports.IsIterator(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.items, right.items));
 }
 function FromLiteral2(left, right) {
@@ -1634,14 +1644,14 @@ function IsObjectUint8ArrayLike(schema) {
   return IsObjectArrayLike(schema);
 }
 function IsObjectFunctionLike(schema) {
-  const length = Number();
+  const length = Number2();
   return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit3(schema.properties["length"], length)) === ExtendsResult.True;
 }
 function IsObjectConstructorLike(schema) {
   return IsObjectPropertyCount(schema, 0);
 }
 function IsObjectArrayLike(schema) {
-  const length = Number();
+  const length = Number2();
   return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit3(schema.properties["length"], length)) === ExtendsResult.True;
 }
 function IsObjectPromiseLike(schema) {
@@ -1658,7 +1668,7 @@ function FromObjectRight(left, right) {
     return IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False;
   })() : ExtendsResult.False;
 }
-function FromObject2(left, right) {
+function FromObject(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : !type_exports.IsObject(right) ? ExtendsResult.False : (() => {
     for (const key of Object.getOwnPropertyNames(right.properties)) {
       if (!(key in left.properties) && !type_exports.IsOptional(right.properties[key])) {
@@ -1674,11 +1684,11 @@ function FromObject2(left, right) {
     return ExtendsResult.True;
   })();
 }
-function FromPromise3(left, right) {
+function FromPromise2(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) && IsObjectPromiseLike(right) ? ExtendsResult.True : !type_exports.IsPromise(right) ? ExtendsResult.False : IntoBooleanResult(Visit3(left.item, right.item));
 }
 function RecordKey(schema) {
-  return PatternNumberExact in schema.patternProperties ? Number() : PatternStringExact in schema.patternProperties ? String() : Throw("Unknown record key pattern");
+  return PatternNumberExact in schema.patternProperties ? Number2() : PatternStringExact in schema.patternProperties ? String() : Throw("Unknown record key pattern");
 }
 function RecordValue(schema) {
   return PatternNumberExact in schema.patternProperties ? schema.patternProperties[PatternNumberExact] : PatternStringExact in schema.patternProperties ? schema.patternProperties[PatternStringExact] : Throw("Unable to get record value schema");
@@ -1720,7 +1730,7 @@ function IsArrayOfTuple(left, right) {
 function FromTupleRight(left, right) {
   return type_exports.IsNever(left) ? ExtendsResult.True : type_exports.IsUnknown(left) ? ExtendsResult.False : type_exports.IsAny(left) ? ExtendsResult.Union : ExtendsResult.False;
 }
-function FromTuple4(left, right) {
+function FromTuple3(left, right) {
   return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) && IsObjectArrayLike(right) ? ExtendsResult.True : type_exports.IsArray(right) && IsArrayOfTuple(left, right) ? ExtendsResult.True : !type_exports.IsTuple(right) ? ExtendsResult.False : value_exports.IsUndefined(left.items) && !value_exports.IsUndefined(right.items) || !value_exports.IsUndefined(left.items) && value_exports.IsUndefined(right.items) ? ExtendsResult.False : value_exports.IsUndefined(left.items) && !value_exports.IsUndefined(right.items) ? ExtendsResult.True : left.items.every((schema, index) => Visit3(schema, right.items[index]) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
 }
 function FromUint8Array(left, right) {
@@ -1732,7 +1742,7 @@ function FromUndefined(left, right) {
 function FromUnionRight(left, right) {
   return right.anyOf.some((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
 }
-function FromUnion7(left, right) {
+function FromUnion6(left, right) {
   return left.anyOf.every((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
 }
 function FromUnknownRight(left, right) {
@@ -1752,7 +1762,7 @@ function Visit3(left, right) {
     // resolvable
     type_exports.IsTemplateLiteral(left) || type_exports.IsTemplateLiteral(right) ? FromTemplateLiteral2(left, right) : type_exports.IsRegExp(left) || type_exports.IsRegExp(right) ? FromRegExp(left, right) : type_exports.IsNot(left) || type_exports.IsNot(right) ? FromNot(left, right) : (
       // standard
-      type_exports.IsAny(left) ? FromAny(left, right) : type_exports.IsArray(left) ? FromArray5(left, right) : type_exports.IsBigInt(left) ? FromBigInt(left, right) : type_exports.IsBoolean(left) ? FromBoolean(left, right) : type_exports.IsAsyncIterator(left) ? FromAsyncIterator2(left, right) : type_exports.IsConstructor(left) ? FromConstructor2(left, right) : type_exports.IsDate(left) ? FromDate(left, right) : type_exports.IsFunction(left) ? FromFunction2(left, right) : type_exports.IsInteger(left) ? FromInteger(left, right) : type_exports.IsIntersect(left) ? FromIntersect5(left, right) : type_exports.IsIterator(left) ? FromIterator2(left, right) : type_exports.IsLiteral(left) ? FromLiteral2(left, right) : type_exports.IsNever(left) ? FromNever(left, right) : type_exports.IsNull(left) ? FromNull(left, right) : type_exports.IsNumber(left) ? FromNumber(left, right) : type_exports.IsObject(left) ? FromObject2(left, right) : type_exports.IsRecord(left) ? FromRecord(left, right) : type_exports.IsString(left) ? FromString(left, right) : type_exports.IsSymbol(left) ? FromSymbol(left, right) : type_exports.IsTuple(left) ? FromTuple4(left, right) : type_exports.IsPromise(left) ? FromPromise3(left, right) : type_exports.IsUint8Array(left) ? FromUint8Array(left, right) : type_exports.IsUndefined(left) ? FromUndefined(left, right) : type_exports.IsUnion(left) ? FromUnion7(left, right) : type_exports.IsUnknown(left) ? FromUnknown(left, right) : type_exports.IsVoid(left) ? FromVoid(left, right) : Throw(`Unknown left type operand '${left[Kind]}'`)
+      type_exports.IsAny(left) ? FromAny(left, right) : type_exports.IsArray(left) ? FromArray4(left, right) : type_exports.IsBigInt(left) ? FromBigInt(left, right) : type_exports.IsBoolean(left) ? FromBoolean(left, right) : type_exports.IsAsyncIterator(left) ? FromAsyncIterator(left, right) : type_exports.IsConstructor(left) ? FromConstructor(left, right) : type_exports.IsDate(left) ? FromDate(left, right) : type_exports.IsFunction(left) ? FromFunction(left, right) : type_exports.IsInteger(left) ? FromInteger(left, right) : type_exports.IsIntersect(left) ? FromIntersect4(left, right) : type_exports.IsIterator(left) ? FromIterator(left, right) : type_exports.IsLiteral(left) ? FromLiteral2(left, right) : type_exports.IsNever(left) ? FromNever(left, right) : type_exports.IsNull(left) ? FromNull(left, right) : type_exports.IsNumber(left) ? FromNumber(left, right) : type_exports.IsObject(left) ? FromObject(left, right) : type_exports.IsRecord(left) ? FromRecord(left, right) : type_exports.IsString(left) ? FromString(left, right) : type_exports.IsSymbol(left) ? FromSymbol(left, right) : type_exports.IsTuple(left) ? FromTuple3(left, right) : type_exports.IsPromise(left) ? FromPromise2(left, right) : type_exports.IsUint8Array(left) ? FromUint8Array(left, right) : type_exports.IsUndefined(left) ? FromUndefined(left, right) : type_exports.IsUnion(left) ? FromUnion6(left, right) : type_exports.IsUnknown(left) ? FromUnknown(left, right) : type_exports.IsVoid(left) ? FromVoid(left, right) : Throw(`Unknown left type operand '${left[Kind]}'`)
     )
   );
 }
@@ -1761,14 +1771,14 @@ function ExtendsCheck(left, right) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.mjs
-function FromProperties9(P, Right, True, False, options) {
+function FromProperties8(P, Right, True, False, options) {
   const Acc = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-    Acc[K2] = Extends(P[K2], Right, True, False, options);
+    Acc[K2] = Extends(P[K2], Right, True, False, Clone(options));
   return Acc;
 }
 function FromMappedResult6(Left, Right, True, False, options) {
-  return FromProperties9(Left.properties, Right, True, False, options);
+  return FromProperties8(Left.properties, Right, True, False, options);
 }
 function ExtendsFromMappedResult(Left, Right, True, False, options) {
   const P = FromMappedResult6(Left, Right, True, False, options);
@@ -1780,14 +1790,14 @@ function ExtendsResolve(left, right, trueType, falseType) {
   const R = ExtendsCheck(left, right);
   return R === ExtendsResult.Union ? Union([trueType, falseType]) : R === ExtendsResult.True ? trueType : falseType;
 }
-function Extends(L, R, T, F, options = {}) {
-  return IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) : IsMappedKey(L) ? CloneType(ExtendsFromMappedKey(L, R, T, F, options)) : CloneType(ExtendsResolve(L, R, T, F), options);
+function Extends(L, R, T, F, options) {
+  return IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) : IsMappedKey(L) ? CreateType(ExtendsFromMappedKey(L, R, T, F, options)) : CreateType(ExtendsResolve(L, R, T, F), options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-key.mjs
 function FromPropertyKey(K, U, L, R, options) {
   return {
-    [K]: Extends(Literal(K), U, L, R, options)
+    [K]: Extends(Literal(K), U, L, R, Clone(options))
   };
 }
 function FromPropertyKeys(K, U, L, R, options) {
@@ -1815,21 +1825,21 @@ function ExcludeRest(L, R) {
 }
 function Exclude(L, R, options = {}) {
   if (IsTemplateLiteral(L))
-    return CloneType(ExcludeFromTemplateLiteral(L, R), options);
+    return CreateType(ExcludeFromTemplateLiteral(L, R), options);
   if (IsMappedResult(L))
-    return CloneType(ExcludeFromMappedResult(L, R), options);
-  return CloneType(IsUnion(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
+    return CreateType(ExcludeFromMappedResult(L, R), options);
+  return CreateType(IsUnion(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-mapped-result.mjs
-function FromProperties10(P, U) {
+function FromProperties9(P, U) {
   const Acc = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(P))
     Acc[K2] = Exclude(P[K2], U);
   return Acc;
 }
 function FromMappedResult7(R, T) {
-  return FromProperties10(R.properties, T);
+  return FromProperties9(R.properties, T);
 }
 function ExcludeFromMappedResult(R, T) {
   const P = FromMappedResult7(R, T);
@@ -1846,23 +1856,23 @@ function ExtractRest(L, R) {
   const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
   return extracted.length === 1 ? extracted[0] : Union(extracted);
 }
-function Extract(L, R, options = {}) {
+function Extract(L, R, options) {
   if (IsTemplateLiteral(L))
-    return CloneType(ExtractFromTemplateLiteral(L, R), options);
+    return CreateType(ExtractFromTemplateLiteral(L, R), options);
   if (IsMappedResult(L))
-    return CloneType(ExtractFromMappedResult(L, R), options);
-  return CloneType(IsUnion(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
+    return CreateType(ExtractFromMappedResult(L, R), options);
+  return CreateType(IsUnion(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.mjs
-function FromProperties11(P, T) {
+function FromProperties10(P, T) {
   const Acc = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(P))
     Acc[K2] = Extract(P[K2], T);
   return Acc;
 }
 function FromMappedResult8(R, T) {
-  return FromProperties11(R.properties, T);
+  return FromProperties10(R.properties, T);
 }
 function ExtractFromMappedResult(R, T) {
   const P = FromMappedResult8(R, T);
@@ -1870,29 +1880,26 @@ function ExtractFromMappedResult(R, T) {
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
-function InstanceType(schema, options = {}) {
-  return CloneType(schema.returns, options);
+function InstanceType(schema, options) {
+  return CreateType(schema.returns, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/integer/integer.mjs
-function Integer(options = {}) {
-  return {
-    ...options,
-    [Kind]: "Integer",
-    type: "integer"
-  };
+function Integer(options) {
+  return CreateType({ [Kind]: "Integer", type: "integer" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic-from-mapped-key.mjs
 function MappedIntrinsicPropertyKey(K, M, options) {
   return {
-    [K]: Intrinsic(Literal(K), M, options)
+    [K]: Intrinsic(Literal(K), M, Clone(options))
   };
 }
 function MappedIntrinsicPropertyKeys(K, M, options) {
-  return K.reduce((Acc, L) => {
+  const result = K.reduce((Acc, L) => {
     return { ...Acc, ...MappedIntrinsicPropertyKey(L, M, options) };
   }, {});
+  return result;
 }
 function MappedIntrinsicProperties(T, M, options) {
   return MappedIntrinsicPropertyKeys(T["keys"], M, options);
@@ -1924,14 +1931,14 @@ function FromTemplateLiteral3(schema, mode, options) {
     return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
   const strings = [...TemplateLiteralExpressionGenerate(expression)];
   const literals = strings.map((value) => Literal(value));
-  const mapped = FromRest6(literals, mode);
+  const mapped = FromRest5(literals, mode);
   const union = Union(mapped);
   return TemplateLiteral([union], options);
 }
 function FromLiteralValue(value, mode) {
   return typeof value === "string" ? mode === "Uncapitalize" ? ApplyUncapitalize(value) : mode === "Capitalize" ? ApplyCapitalize(value) : mode === "Uppercase" ? ApplyUppercase(value) : mode === "Lowercase" ? ApplyLowercase(value) : value : value.toString();
 }
-function FromRest6(T, M) {
+function FromRest5(T, M) {
   return T.map((L) => Intrinsic(L, M));
 }
 function Intrinsic(schema, mode, options = {}) {
@@ -1939,7 +1946,10 @@ function Intrinsic(schema, mode, options = {}) {
     // Intrinsic-Mapped-Inference
     IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) : (
       // Standard-Inference
-      IsTemplateLiteral(schema) ? FromTemplateLiteral3(schema, mode, schema) : IsUnion(schema) ? Union(FromRest6(schema.anyOf, mode), options) : IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : schema
+      IsTemplateLiteral(schema) ? FromTemplateLiteral3(schema, mode, options) : IsUnion(schema) ? Union(FromRest5(schema.anyOf, mode), options) : IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : (
+        // Default Type
+        CreateType(schema, options)
+      )
     )
   );
 }
@@ -1964,309 +1974,428 @@ function Uppercase(T, options = {}) {
   return Intrinsic(T, "Uppercase", options);
 }
 
-// node_modules/@sinclair/typebox/build/esm/type/not/not.mjs
-function Not(schema, options) {
-  return {
-    ...options,
-    [Kind]: "Not",
-    not: CloneType(schema)
-  };
-}
-
 // node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-result.mjs
-function FromProperties12(P, K, options) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-    Acc[K2] = Omit(P[K2], K, options);
-  return Acc;
+function FromProperties11(properties, propertyKeys, options) {
+  const result = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+    result[K2] = Omit(properties[K2], propertyKeys, Clone(options));
+  return result;
 }
-function FromMappedResult9(R, K, options) {
-  return FromProperties12(R.properties, K, options);
+function FromMappedResult9(mappedResult, propertyKeys, options) {
+  return FromProperties11(mappedResult.properties, propertyKeys, options);
 }
-function OmitFromMappedResult(R, K, options) {
-  const P = FromMappedResult9(R, K, options);
-  return MappedResult(P);
+function OmitFromMappedResult(mappedResult, propertyKeys, options) {
+  const properties = FromMappedResult9(mappedResult, propertyKeys, options);
+  return MappedResult(properties);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/omit/omit.mjs
-function FromIntersect6(T, K) {
-  return T.map((T2) => OmitResolve(T2, K));
+function FromIntersect5(types, propertyKeys) {
+  return types.map((type) => OmitResolve(type, propertyKeys));
 }
-function FromUnion8(T, K) {
-  return T.map((T2) => OmitResolve(T2, K));
+function FromUnion7(types, propertyKeys) {
+  return types.map((type) => OmitResolve(type, propertyKeys));
 }
-function FromProperty2(T, K) {
-  const { [K]: _, ...R } = T;
+function FromProperty2(properties, key) {
+  const { [key]: _, ...R } = properties;
   return R;
 }
-function FromProperties13(T, K) {
-  return K.reduce((T2, K2) => FromProperty2(T2, K2), T);
+function FromProperties12(properties, propertyKeys) {
+  return propertyKeys.reduce((T, K2) => FromProperty2(T, K2), properties);
+}
+function FromObject2(properties, propertyKeys) {
+  const options = Discard(properties, [TransformKind, "$id", "required", "properties"]);
+  const omittedProperties = FromProperties12(properties["properties"], propertyKeys);
+  return Object2(omittedProperties, options);
 }
-function OmitResolve(T, K) {
-  return IsIntersect(T) ? Intersect(FromIntersect6(T.allOf, K)) : IsUnion(T) ? Union(FromUnion8(T.anyOf, K)) : IsObject2(T) ? Object2(FromProperties13(T.properties, K)) : Object2({});
+function UnionFromPropertyKeys(propertyKeys) {
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
+  return Union(result);
 }
-function Omit(T, K, options = {}) {
-  if (IsMappedKey(K))
-    return OmitFromMappedKey(T, K, options);
-  if (IsMappedResult(T))
-    return OmitFromMappedResult(T, K, options);
-  const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
-  const D = Discard(T, [TransformKind, "$id", "required"]);
-  const R = CloneType(OmitResolve(T, I), options);
-  return { ...D, ...R };
+function OmitResolve(properties, propertyKeys) {
+  return IsIntersect(properties) ? Intersect(FromIntersect5(properties.allOf, propertyKeys)) : IsUnion(properties) ? Union(FromUnion7(properties.anyOf, propertyKeys)) : IsObject3(properties) ? FromObject2(properties, propertyKeys) : Object2({});
+}
+function Omit(type, key, options) {
+  const typeKey = IsArray(key) ? UnionFromPropertyKeys(key) : key;
+  const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
+  const isTypeRef = IsRef(type);
+  const isKeyRef = IsRef(key);
+  return IsMappedResult(type) ? OmitFromMappedResult(type, propertyKeys, options) : IsMappedKey(key) ? OmitFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Omit", [type, typeKey], options) : CreateType({ ...OmitResolve(type, propertyKeys), ...options });
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-key.mjs
-function FromPropertyKey2(T, K, options) {
-  return {
-    [K]: Omit(T, [K], options)
-  };
+function FromPropertyKey2(type, key, options) {
+  return { [key]: Omit(type, [key], Clone(options)) };
 }
-function FromPropertyKeys2(T, K, options) {
-  return K.reduce((Acc, LK) => {
-    return { ...Acc, ...FromPropertyKey2(T, LK, options) };
+function FromPropertyKeys2(type, propertyKeys, options) {
+  return propertyKeys.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey2(type, LK, options) };
   }, {});
 }
-function FromMappedKey3(T, K, options) {
-  return FromPropertyKeys2(T, K.keys, options);
+function FromMappedKey3(type, mappedKey, options) {
+  return FromPropertyKeys2(type, mappedKey.keys, options);
 }
-function OmitFromMappedKey(T, K, options) {
-  const P = FromMappedKey3(T, K, options);
-  return MappedResult(P);
+function OmitFromMappedKey(type, mappedKey, options) {
+  const properties = FromMappedKey3(type, mappedKey, options);
+  return MappedResult(properties);
 }
 
-// node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.mjs
-function Parameters(schema, options = {}) {
-  return Tuple(CloneRest(schema.parameters), { ...options });
+// node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-result.mjs
+function FromProperties13(properties, propertyKeys, options) {
+  const result = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+    result[K2] = Pick(properties[K2], propertyKeys, Clone(options));
+  return result;
+}
+function FromMappedResult10(mappedResult, propertyKeys, options) {
+  return FromProperties13(mappedResult.properties, propertyKeys, options);
+}
+function PickFromMappedResult(mappedResult, propertyKeys, options) {
+  const properties = FromMappedResult10(mappedResult, propertyKeys, options);
+  return MappedResult(properties);
 }
 
-// node_modules/@sinclair/typebox/build/esm/type/partial/partial.mjs
-function FromRest7(T) {
-  return T.map((L) => PartialResolve(L));
+// node_modules/@sinclair/typebox/build/esm/type/pick/pick.mjs
+function FromIntersect6(types, propertyKeys) {
+  return types.map((type) => PickResolve(type, propertyKeys));
 }
-function FromProperties14(T) {
-  const Acc = {};
-  for (const K of globalThis.Object.getOwnPropertyNames(T))
-    Acc[K] = Optional(T[K]);
-  return Acc;
+function FromUnion8(types, propertyKeys) {
+  return types.map((type) => PickResolve(type, propertyKeys));
 }
-function PartialResolve(T) {
-  return IsIntersect(T) ? Intersect(FromRest7(T.allOf)) : IsUnion(T) ? Union(FromRest7(T.anyOf)) : IsObject2(T) ? Object2(FromProperties14(T.properties)) : Object2({});
+function FromProperties14(properties, propertyKeys) {
+  const result = {};
+  for (const K2 of propertyKeys)
+    if (K2 in properties)
+      result[K2] = properties[K2];
+  return result;
 }
-function Partial(T, options = {}) {
-  if (IsMappedResult(T))
-    return PartialFromMappedResult(T, options);
-  const D = Discard(T, [TransformKind, "$id", "required"]);
-  const R = CloneType(PartialResolve(T), options);
-  return { ...D, ...R };
+function FromObject3(T, K) {
+  const options = Discard(T, [TransformKind, "$id", "required", "properties"]);
+  const properties = FromProperties14(T["properties"], K);
+  return Object2(properties, options);
 }
-
-// node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.mjs
-function FromProperties15(K, options) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
-    Acc[K2] = Partial(K[K2], options);
-  return Acc;
+function UnionFromPropertyKeys2(propertyKeys) {
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
+  return Union(result);
 }
-function FromMappedResult10(R, options) {
-  return FromProperties15(R.properties, options);
+function PickResolve(properties, propertyKeys) {
+  return IsIntersect(properties) ? Intersect(FromIntersect6(properties.allOf, propertyKeys)) : IsUnion(properties) ? Union(FromUnion8(properties.anyOf, propertyKeys)) : IsObject3(properties) ? FromObject3(properties, propertyKeys) : Object2({});
 }
-function PartialFromMappedResult(R, options) {
-  const P = FromMappedResult10(R, options);
-  return MappedResult(P);
+function Pick(type, key, options) {
+  const typeKey = IsArray(key) ? UnionFromPropertyKeys2(key) : key;
+  const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
+  const isTypeRef = IsRef(type);
+  const isKeyRef = IsRef(key);
+  return IsMappedResult(type) ? PickFromMappedResult(type, propertyKeys, options) : IsMappedKey(key) ? PickFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Pick", [type, typeKey], options) : CreateType({ ...PickResolve(type, propertyKeys), ...options });
 }
 
-// node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-result.mjs
-function FromProperties16(P, K, options) {
-  const Acc = {};
-  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-    Acc[K2] = Pick(P[K2], K, options);
-  return Acc;
+// node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-key.mjs
+function FromPropertyKey3(type, key, options) {
+  return {
+    [key]: Pick(type, [key], Clone(options))
+  };
 }
-function FromMappedResult11(R, K, options) {
-  return FromProperties16(R.properties, K, options);
+function FromPropertyKeys3(type, propertyKeys, options) {
+  return propertyKeys.reduce((result, leftKey) => {
+    return { ...result, ...FromPropertyKey3(type, leftKey, options) };
+  }, {});
 }
-function PickFromMappedResult(R, K, options) {
-  const P = FromMappedResult11(R, K, options);
-  return MappedResult(P);
+function FromMappedKey4(type, mappedKey, options) {
+  return FromPropertyKeys3(type, mappedKey.keys, options);
+}
+function PickFromMappedKey(type, mappedKey, options) {
+  const properties = FromMappedKey4(type, mappedKey, options);
+  return MappedResult(properties);
 }
 
-// node_modules/@sinclair/typebox/build/esm/type/pick/pick.mjs
-function FromIntersect7(T, K) {
-  return T.map((T2) => PickResolve(T2, K));
+// node_modules/@sinclair/typebox/build/esm/type/partial/partial.mjs
+function FromComputed3(target, parameters) {
+  return Computed("Partial", [Computed(target, parameters)]);
 }
-function FromUnion9(T, K) {
-  return T.map((T2) => PickResolve(T2, K));
+function FromRef3($ref) {
+  return Computed("Partial", [Ref($ref)]);
 }
-function FromProperties17(T, K) {
-  const Acc = {};
-  for (const K2 of K)
-    if (K2 in T)
-      Acc[K2] = T[K2];
-  return Acc;
+function FromProperties15(properties) {
+  const partialProperties = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(properties))
+    partialProperties[K] = Optional(properties[K]);
+  return partialProperties;
 }
-function PickResolve(T, K) {
-  return IsIntersect(T) ? Intersect(FromIntersect7(T.allOf, K)) : IsUnion(T) ? Union(FromUnion9(T.anyOf, K)) : IsObject2(T) ? Object2(FromProperties17(T.properties, K)) : Object2({});
+function FromObject4(T) {
+  const options = Discard(T, [TransformKind, "$id", "required", "properties"]);
+  const properties = FromProperties15(T["properties"]);
+  return Object2(properties, options);
 }
-function Pick(T, K, options = {}) {
-  if (IsMappedKey(K))
-    return PickFromMappedKey(T, K, options);
-  if (IsMappedResult(T))
-    return PickFromMappedResult(T, K, options);
-  const I = IsSchema(K) ? IndexPropertyKeys(K) : K;
-  const D = Discard(T, [TransformKind, "$id", "required"]);
-  const R = CloneType(PickResolve(T, I), options);
-  return { ...D, ...R };
+function FromRest6(types) {
+  return types.map((type) => PartialResolve(type));
 }
-
-// node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-key.mjs
-function FromPropertyKey3(T, K, options) {
-  return {
-    [K]: Pick(T, [K], options)
-  };
+function PartialResolve(type) {
+  return IsComputed(type) ? FromComputed3(type.target, type.parameters) : IsRef(type) ? FromRef3(type.$ref) : IsIntersect(type) ? Intersect(FromRest6(type.allOf)) : IsUnion(type) ? Union(FromRest6(type.anyOf)) : IsObject3(type) ? FromObject4(type) : Object2({});
 }
-function FromPropertyKeys3(T, K, options) {
-  return K.reduce((Acc, LK) => {
-    return { ...Acc, ...FromPropertyKey3(T, LK, options) };
-  }, {});
+function Partial(type, options) {
+  if (IsMappedResult(type)) {
+    return PartialFromMappedResult(type, options);
+  } else {
+    return CreateType({ ...PartialResolve(type), ...options });
+  }
 }
-function FromMappedKey4(T, K, options) {
-  return FromPropertyKeys3(T, K.keys, options);
+
+// node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.mjs
+function FromProperties16(K, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+    Acc[K2] = Partial(K[K2], Clone(options));
+  return Acc;
 }
-function PickFromMappedKey(T, K, options) {
-  const P = FromMappedKey4(T, K, options);
-  return MappedResult(P);
+function FromMappedResult11(R, options) {
+  return FromProperties16(R.properties, options);
 }
-
-// node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
-function ReadonlyOptional(schema) {
-  return Readonly(Optional(schema));
+function PartialFromMappedResult(R, options) {
+  const P = FromMappedResult11(R, options);
+  return MappedResult(P);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/record/record.mjs
 function RecordCreateFromPattern(pattern, T, options) {
-  return {
-    ...options,
-    [Kind]: "Record",
-    type: "object",
-    patternProperties: { [pattern]: CloneType(T) }
-  };
+  return CreateType({ [Kind]: "Record", type: "object", patternProperties: { [pattern]: T } }, options);
 }
 function RecordCreateFromKeys(K, T, options) {
-  const Acc = {};
+  const result = {};
   for (const K2 of K)
-    Acc[K2] = CloneType(T);
-  return Object2(Acc, { ...options, [Hint]: "Record" });
+    result[K2] = T;
+  return Object2(result, { ...options, [Hint]: "Record" });
 }
 function FromTemplateLiteralKey(K, T, options) {
   return IsTemplateLiteralFinite(K) ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options) : RecordCreateFromPattern(K.pattern, T, options);
 }
-function FromUnionKey(K, T, options) {
-  return RecordCreateFromKeys(IndexPropertyKeys(Union(K)), T, options);
+function FromUnionKey(key, type, options) {
+  return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options);
 }
-function FromLiteralKey(K, T, options) {
-  return RecordCreateFromKeys([K.toString()], T, options);
+function FromLiteralKey(key, type, options) {
+  return RecordCreateFromKeys([key.toString()], type, options);
 }
-function FromRegExpKey(K, T, options) {
-  return RecordCreateFromPattern(K.source, T, options);
+function FromRegExpKey(key, type, options) {
+  return RecordCreateFromPattern(key.source, type, options);
 }
-function FromStringKey(K, T, options) {
-  const pattern = IsUndefined(K.pattern) ? PatternStringExact : K.pattern;
-  return RecordCreateFromPattern(pattern, T, options);
+function FromStringKey(key, type, options) {
+  const pattern = IsUndefined(key.pattern) ? PatternStringExact : key.pattern;
+  return RecordCreateFromPattern(pattern, type, options);
 }
-function FromIntegerKey(_, T, options) {
-  return RecordCreateFromPattern(PatternNumberExact, T, options);
+function FromAnyKey(_, type, options) {
+  return RecordCreateFromPattern(PatternStringExact, type, options);
 }
-function FromNumberKey(_, T, options) {
-  return RecordCreateFromPattern(PatternNumberExact, T, options);
+function FromNeverKey(_key, type, options) {
+  return RecordCreateFromPattern(PatternNeverExact, type, options);
 }
-function Record(K, T, options = {}) {
-  return IsUnion(K) ? FromUnionKey(K.anyOf, T, options) : IsTemplateLiteral(K) ? FromTemplateLiteralKey(K, T, options) : IsLiteral(K) ? FromLiteralKey(K.const, T, options) : IsInteger(K) ? FromIntegerKey(K, T, options) : IsNumber2(K) ? FromNumberKey(K, T, options) : IsRegExp2(K) ? FromRegExpKey(K, T, options) : IsString2(K) ? FromStringKey(K, T, options) : Never(options);
+function FromIntegerKey(_key, type, options) {
+  return RecordCreateFromPattern(PatternNumberExact, type, options);
 }
-
-// node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.mjs
-var Ordinal = 0;
-function Recursive(callback, options = {}) {
-  if (IsUndefined(options.$id))
-    options.$id = `T${Ordinal++}`;
-  const thisType = callback({ [Kind]: "This", $ref: `${options.$id}` });
-  thisType.$id = options.$id;
-  return CloneType({ ...options, [Hint]: "Recursive", ...thisType });
+function FromNumberKey(_, type, options) {
+  return RecordCreateFromPattern(PatternNumberExact, type, options);
 }
-
-// node_modules/@sinclair/typebox/build/esm/type/ref/ref.mjs
-function Ref(unresolved, options = {}) {
-  if (IsString(unresolved))
-    return { ...options, [Kind]: "Ref", $ref: unresolved };
-  if (IsUndefined(unresolved.$id))
-    throw new Error("Reference target type must specify an $id");
-  return {
-    ...options,
-    [Kind]: "Ref",
-    $ref: unresolved.$id
-  };
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.mjs
-function RegExp2(unresolved, options = {}) {
-  const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
-  return { ...options, [Kind]: "RegExp", type: "RegExp", source: expr.source, flags: expr.flags };
+function Record(key, type, options = {}) {
+  return IsComputed(type) ? Computed("Record", [key, Computed(type.target, type.parameters)], options) : IsComputed(key) ? Computed("Record", [Computed(type.target, type.parameters), type], options) : IsRef(key) ? Computed("Record", [Ref(key.$ref), type]) : IsUnion(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral(key) ? FromLiteralKey(key.const, type, options) : IsInteger(key) ? FromIntegerKey(key, type, options) : IsNumber3(key) ? FromNumberKey(key, type, options) : IsRegExp2(key) ? FromRegExpKey(key, type, options) : IsString2(key) ? FromStringKey(key, type, options) : IsAny(key) ? FromAnyKey(key, type, options) : IsNever(key) ? FromNeverKey(key, type, options) : Never(options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/required/required.mjs
-function FromRest8(T) {
-  return T.map((L) => RequiredResolve(L));
+function FromComputed4(target, parameters) {
+  return Computed("Required", [Computed(target, parameters)]);
 }
-function FromProperties18(T) {
-  const Acc = {};
-  for (const K of globalThis.Object.getOwnPropertyNames(T))
-    Acc[K] = Discard(T[K], [OptionalKind]);
-  return Acc;
+function FromRef4($ref) {
+  return Computed("Required", [Ref($ref)]);
+}
+function FromProperties17(properties) {
+  const requiredProperties = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(properties))
+    requiredProperties[K] = Discard(properties[K], [OptionalKind]);
+  return requiredProperties;
+}
+function FromObject5(type) {
+  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
+  const properties = FromProperties17(type["properties"]);
+  return Object2(properties, options);
+}
+function FromRest7(types) {
+  return types.map((type) => RequiredResolve(type));
 }
-function RequiredResolve(T) {
-  return IsIntersect(T) ? Intersect(FromRest8(T.allOf)) : IsUnion(T) ? Union(FromRest8(T.anyOf)) : IsObject2(T) ? Object2(FromProperties18(T.properties)) : Object2({});
+function RequiredResolve(type) {
+  return IsComputed(type) ? FromComputed4(type.target, type.parameters) : IsRef(type) ? FromRef4(type.$ref) : IsIntersect(type) ? Intersect(FromRest7(type.allOf)) : IsUnion(type) ? Union(FromRest7(type.anyOf)) : IsObject3(type) ? FromObject5(type) : Object2({});
 }
-function Required(T, options = {}) {
-  if (IsMappedResult(T)) {
-    return RequiredFromMappedResult(T, options);
+function Required(type, options) {
+  if (IsMappedResult(type)) {
+    return RequiredFromMappedResult(type, options);
   } else {
-    const D = Discard(T, [TransformKind, "$id", "required"]);
-    const R = CloneType(RequiredResolve(T), options);
-    return { ...D, ...R };
+    return CreateType({ ...RequiredResolve(type), ...options });
   }
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/required/required-from-mapped-result.mjs
-function FromProperties19(P, options) {
+function FromProperties18(P, options) {
   const Acc = {};
   for (const K2 of globalThis.Object.getOwnPropertyNames(P))
     Acc[K2] = Required(P[K2], options);
   return Acc;
 }
 function FromMappedResult12(R, options) {
-  return FromProperties19(R.properties, options);
+  return FromProperties18(R.properties, options);
 }
 function RequiredFromMappedResult(R, options) {
   const P = FromMappedResult12(R, options);
   return MappedResult(P);
 }
 
+// node_modules/@sinclair/typebox/build/esm/type/module/compute.mjs
+function DerefParameters(moduleProperties, types) {
+  return types.map((type) => {
+    return IsRef(type) ? Deref(moduleProperties, type.$ref) : FromType(moduleProperties, type);
+  });
+}
+function Deref(moduleProperties, ref) {
+  return ref in moduleProperties ? IsRef(moduleProperties[ref]) ? Deref(moduleProperties, moduleProperties[ref].$ref) : FromType(moduleProperties, moduleProperties[ref]) : Never();
+}
+function FromAwaited(parameters) {
+  return Awaited(parameters[0]);
+}
+function FromIndex(parameters) {
+  return Index(parameters[0], parameters[1]);
+}
+function FromKeyOf(parameters) {
+  return KeyOf(parameters[0]);
+}
+function FromPartial(parameters) {
+  return Partial(parameters[0]);
+}
+function FromOmit(parameters) {
+  return Omit(parameters[0], parameters[1]);
+}
+function FromPick(parameters) {
+  return Pick(parameters[0], parameters[1]);
+}
+function FromRecord2(parameters) {
+  return Record(parameters[0], parameters[1]);
+}
+function FromRequired(parameters) {
+  return Required(parameters[0]);
+}
+function FromComputed5(moduleProperties, target, parameters) {
+  const dereferenced = DerefParameters(moduleProperties, parameters);
+  return target === "Awaited" ? FromAwaited(dereferenced) : target === "Index" ? FromIndex(dereferenced) : target === "KeyOf" ? FromKeyOf(dereferenced) : target === "Partial" ? FromPartial(dereferenced) : target === "Omit" ? FromOmit(dereferenced) : target === "Pick" ? FromPick(dereferenced) : target === "Record" ? FromRecord2(dereferenced) : target === "Required" ? FromRequired(dereferenced) : Never();
+}
+function FromObject6(moduleProperties, properties) {
+  return Object2(globalThis.Object.keys(properties).reduce((result, key) => {
+    return { ...result, [key]: FromType(moduleProperties, properties[key]) };
+  }, {}));
+}
+function FromConstructor2(moduleProperties, parameters, instanceType) {
+  return Constructor(FromRest8(moduleProperties, parameters), FromType(moduleProperties, instanceType));
+}
+function FromFunction2(moduleProperties, parameters, returnType) {
+  return Function(FromRest8(moduleProperties, parameters), FromType(moduleProperties, returnType));
+}
+function FromTuple4(moduleProperties, types) {
+  return Tuple(FromRest8(moduleProperties, types));
+}
+function FromIntersect7(moduleProperties, types) {
+  return Intersect(FromRest8(moduleProperties, types));
+}
+function FromUnion9(moduleProperties, types) {
+  return Union(FromRest8(moduleProperties, types));
+}
+function FromArray5(moduleProperties, type) {
+  return Array2(FromType(moduleProperties, type));
+}
+function FromAsyncIterator2(moduleProperties, type) {
+  return AsyncIterator(FromType(moduleProperties, type));
+}
+function FromIterator2(moduleProperties, type) {
+  return Iterator(FromType(moduleProperties, type));
+}
+function FromRest8(moduleProperties, types) {
+  return types.map((type) => FromType(moduleProperties, type));
+}
+function FromType(moduleProperties, type) {
+  return (
+    // Modifier Unwrap - Reapplied via CreateType Options
+    IsOptional(type) ? CreateType(FromType(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType(moduleProperties, Discard(type, [ReadonlyKind])), type) : (
+      // Traveral
+      IsArray3(type) ? CreateType(FromArray5(moduleProperties, type.items), type) : IsAsyncIterator2(type) ? CreateType(FromAsyncIterator2(moduleProperties, type.items), type) : IsComputed(type) ? CreateType(FromComputed5(moduleProperties, type.target, type.parameters)) : IsConstructor(type) ? CreateType(FromConstructor2(moduleProperties, type.parameters, type.returns), type) : IsFunction2(type) ? CreateType(FromFunction2(moduleProperties, type.parameters, type.returns), type) : IsIntersect(type) ? CreateType(FromIntersect7(moduleProperties, type.allOf), type) : IsIterator2(type) ? CreateType(FromIterator2(moduleProperties, type.items), type) : IsObject3(type) ? CreateType(FromObject6(moduleProperties, type.properties), type) : IsTuple(type) ? CreateType(FromTuple4(moduleProperties, type.items || []), type) : IsUnion(type) ? CreateType(FromUnion9(moduleProperties, type.anyOf), type) : type
+    )
+  );
+}
+function ComputeType(moduleProperties, key) {
+  return key in moduleProperties ? FromType(moduleProperties, moduleProperties[key]) : Never();
+}
+function ComputeModuleProperties(moduleProperties) {
+  return globalThis.Object.getOwnPropertyNames(moduleProperties).reduce((result, key) => {
+    return { ...result, [key]: ComputeType(moduleProperties, key) };
+  }, {});
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/module/module.mjs
+var TModule = class {
+  constructor($defs) {
+    const computed = ComputeModuleProperties($defs);
+    const identified = this.WithIdentifiers(computed);
+    this.$defs = identified;
+  }
+  /** `[Json]` Imports a Type by Key. */
+  Import(key, options) {
+    const $defs = { ...this.$defs, [key]: CreateType(this.$defs[key], options) };
+    return CreateType({ [Kind]: "Import", $defs, $ref: key });
+  }
+  // prettier-ignore
+  WithIdentifiers($defs) {
+    return globalThis.Object.getOwnPropertyNames($defs).reduce((result, key) => {
+      return { ...result, [key]: { ...$defs[key], $id: key } };
+    }, {});
+  }
+};
+function Module(properties) {
+  return new TModule(properties);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/not/not.mjs
+function Not(type, options) {
+  return CreateType({ [Kind]: "Not", not: type }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.mjs
+function Parameters(schema, options) {
+  return Tuple(schema.parameters, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
+function ReadonlyOptional(schema) {
+  return Readonly(Optional(schema));
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.mjs
+var Ordinal = 0;
+function Recursive(callback, options = {}) {
+  if (IsUndefined(options.$id))
+    options.$id = `T${Ordinal++}`;
+  const thisType = CloneType(callback({ [Kind]: "This", $ref: `${options.$id}` }));
+  thisType.$id = options.$id;
+  return CreateType({ [Hint]: "Recursive", ...thisType }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/regexp/regexp.mjs
+function RegExp2(unresolved, options) {
+  const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
+  return CreateType({ [Kind]: "RegExp", type: "RegExp", source: expr.source, flags: expr.flags }, options);
+}
+
 // node_modules/@sinclair/typebox/build/esm/type/rest/rest.mjs
 function RestResolve(T) {
-  return IsIntersect(T) ? CloneRest(T.allOf) : IsUnion(T) ? CloneRest(T.anyOf) : IsTuple(T) ? CloneRest(T.items ?? []) : [];
+  return IsIntersect(T) ? T.allOf : IsUnion(T) ? T.anyOf : IsTuple(T) ? T.items ?? [] : [];
 }
 function Rest(T) {
-  return CloneRest(RestResolve(T));
+  return RestResolve(T);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
-function ReturnType(schema, options = {}) {
-  return CloneType(schema.returns, options);
-}
-
-// node_modules/@sinclair/typebox/build/esm/type/strict/strict.mjs
-function Strict(schema) {
-  return JSON.parse(JSON.stringify(schema));
+function ReturnType(schema, options) {
+  return CreateType(schema.returns, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
@@ -2294,8 +2423,7 @@ var TransformEncodeBuilder = class {
     return { ...schema, [TransformKind]: Codec };
   }
   Encode(encode) {
-    const schema = CloneType(this.schema);
-    return IsTransform(schema) ? this.EncodeTransform(encode, schema) : this.EncodeSchema(encode, schema);
+    return IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
   }
 };
 function Transform(schema) {
@@ -2304,24 +2432,17 @@ function Transform(schema) {
 
 // node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.mjs
 function Unsafe(options = {}) {
-  return {
-    ...options,
-    [Kind]: options[Kind] ?? "Unsafe"
-  };
+  return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
-function Void(options = {}) {
-  return {
-    ...options,
-    [Kind]: "Void",
-    type: "void"
-  };
+function Void(options) {
+  return CreateType({ [Kind]: "Void", type: "void" }, options);
 }
 
 // node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
-var type_exports3 = {};
-__export(type_exports3, {
+var type_exports2 = {};
+__export(type_exports2, {
   Any: () => Any,
   Array: () => Array2,
   AsyncIterator: () => AsyncIterator,
@@ -2334,7 +2455,6 @@ __export(type_exports3, {
   Constructor: () => Constructor,
   ConstructorParameters: () => ConstructorParameters,
   Date: () => Date2,
-  Deref: () => Deref,
   Enum: () => Enum,
   Exclude: () => Exclude,
   Extends: () => Extends,
@@ -2349,10 +2469,11 @@ __export(type_exports3, {
   Literal: () => Literal,
   Lowercase: () => Lowercase,
   Mapped: () => Mapped,
+  Module: () => Module,
   Never: () => Never,
   Not: () => Not,
   Null: () => Null,
-  Number: () => Number,
+  Number: () => Number2,
   Object: () => Object2,
   Omit: () => Omit,
   Optional: () => Optional,
@@ -2369,7 +2490,6 @@ __export(type_exports3, {
   Required: () => Required,
   Rest: () => Rest,
   ReturnType: () => ReturnType,
-  Strict: () => Strict,
   String: () => String,
   Symbol: () => Symbol2,
   TemplateLiteral: () => TemplateLiteral,
@@ -2386,7 +2506,7 @@ __export(type_exports3, {
 });
 
 // node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
-var Type = type_exports3;
+var Type = type_exports2;
 
 // src/index.ts
 var jwt = ({
@@ -2461,7 +2581,7 @@ var jwt = ({
     }
   });
 };
-var src_default = jwt;
+var index_default = jwt;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   jwt