@digitalforgestudios/openclaw-sulcus 6.6.2 → 6.6.3

package/index.js

@@ -1,4 +1,3 @@
-"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -38,7 +37,2614 @@ var import_node_fs = require("node:fs");
 var https = __toESM(require("node:https"));
 var http = __toESM(require("node:http"));
 var import_node_url = require("node:url");
-var import_typebox = require("@sinclair/typebox");
+
+// node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
+var value_exports = {};
+__export(value_exports, {
+  HasPropertyKey: () => HasPropertyKey,
+  IsArray: () => IsArray,
+  IsAsyncIterator: () => IsAsyncIterator,
+  IsBigInt: () => IsBigInt,
+  IsBoolean: () => IsBoolean,
+  IsDate: () => IsDate,
+  IsFunction: () => IsFunction,
+  IsIterator: () => IsIterator,
+  IsNull: () => IsNull,
+  IsNumber: () => IsNumber,
+  IsObject: () => IsObject,
+  IsRegExp: () => IsRegExp,
+  IsString: () => IsString,
+  IsSymbol: () => IsSymbol,
+  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;
+}
+function IsArray(value) {
+  return Array.isArray(value);
+}
+function IsBigInt(value) {
+  return typeof value === "bigint";
+}
+function IsBoolean(value) {
+  return typeof value === "boolean";
+}
+function IsDate(value) {
+  return value instanceof globalThis.Date;
+}
+function IsFunction(value) {
+  return typeof value === "function";
+}
+function IsIterator(value) {
+  return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
+}
+function IsNull(value) {
+  return value === null;
+}
+function IsNumber(value) {
+  return typeof value === "number";
+}
+function IsObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function IsRegExp(value) {
+  return value instanceof globalThis.RegExp;
+}
+function IsString(value) {
+  return typeof value === "string";
+}
+function IsSymbol(value) {
+  return typeof value === "symbol";
+}
+function IsUint8Array(value) {
+  return value instanceof globalThis.Uint8Array;
+}
+function IsUndefined(value) {
+  return value === void 0;
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
+function ArrayType(value) {
+  return value.map((value2) => Visit(value2));
+}
+function DateType(value) {
+  return new Date(value.getTime());
+}
+function Uint8ArrayType(value) {
+  return new Uint8Array(value);
+}
+function RegExpType(value) {
+  return new RegExp(value.source, value.flags);
+}
+function ObjectType(value) {
+  const result = {};
+  for (const key of Object.getOwnPropertyNames(value)) {
+    result[key] = Visit(value[key]);
+  }
+  for (const key of Object.getOwnPropertySymbols(value)) {
+    result[key] = Visit(value[key]);
+  }
+  return result;
+}
+function Visit(value) {
+  return IsArray(value) ? ArrayType(value) : IsDate(value) ? DateType(value) : IsUint8Array(value) ? Uint8ArrayType(value) : IsRegExp(value) ? RegExpType(value) : IsObject(value) ? ObjectType(value) : value;
+}
+function Clone(value) {
+  return Visit(value);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
+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 globalThis.Array.isArray(value) && !globalThis.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 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
+var TypeBoxError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+
+// node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
+var TransformKind = /* @__PURE__ */ Symbol.for("TypeBox.Transform");
+var ReadonlyKind = /* @__PURE__ */ Symbol.for("TypeBox.Readonly");
+var OptionalKind = /* @__PURE__ */ Symbol.for("TypeBox.Optional");
+var Hint = /* @__PURE__ */ Symbol.for("TypeBox.Hint");
+var Kind = /* @__PURE__ */ Symbol.for("TypeBox.Kind");
+
+// node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
+function IsReadonly(value) {
+  return IsObject(value) && value[ReadonlyKind] === "Readonly";
+}
+function IsOptional(value) {
+  return IsObject(value) && value[OptionalKind] === "Optional";
+}
+function IsAny(value) {
+  return IsKindOf(value, "Any");
+}
+function IsArgument(value) {
+  return IsKindOf(value, "Argument");
+}
+function IsArray3(value) {
+  return IsKindOf(value, "Array");
+}
+function IsAsyncIterator2(value) {
+  return IsKindOf(value, "AsyncIterator");
+}
+function IsBigInt2(value) {
+  return IsKindOf(value, "BigInt");
+}
+function IsBoolean2(value) {
+  return IsKindOf(value, "Boolean");
+}
+function IsComputed(value) {
+  return IsKindOf(value, "Computed");
+}
+function IsConstructor(value) {
+  return IsKindOf(value, "Constructor");
+}
+function IsDate2(value) {
+  return IsKindOf(value, "Date");
+}
+function IsFunction2(value) {
+  return IsKindOf(value, "Function");
+}
+function IsInteger(value) {
+  return IsKindOf(value, "Integer");
+}
+function IsIntersect(value) {
+  return IsKindOf(value, "Intersect");
+}
+function IsIterator2(value) {
+  return IsKindOf(value, "Iterator");
+}
+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");
+}
+function IsMappedKey(value) {
+  return IsKindOf(value, "MappedKey");
+}
+function IsMappedResult(value) {
+  return IsKindOf(value, "MappedResult");
+}
+function IsNever(value) {
+  return IsKindOf(value, "Never");
+}
+function IsNot(value) {
+  return IsKindOf(value, "Not");
+}
+function IsNull2(value) {
+  return IsKindOf(value, "Null");
+}
+function IsNumber3(value) {
+  return IsKindOf(value, "Number");
+}
+function IsObject3(value) {
+  return IsKindOf(value, "Object");
+}
+function IsPromise(value) {
+  return IsKindOf(value, "Promise");
+}
+function IsRecord(value) {
+  return IsKindOf(value, "Record");
+}
+function IsRef(value) {
+  return IsKindOf(value, "Ref");
+}
+function IsRegExp2(value) {
+  return IsKindOf(value, "RegExp");
+}
+function IsString2(value) {
+  return IsKindOf(value, "String");
+}
+function IsSymbol2(value) {
+  return IsKindOf(value, "Symbol");
+}
+function IsTemplateLiteral(value) {
+  return IsKindOf(value, "TemplateLiteral");
+}
+function IsThis(value) {
+  return IsKindOf(value, "This");
+}
+function IsTransform(value) {
+  return IsObject(value) && TransformKind in value;
+}
+function IsTuple(value) {
+  return IsKindOf(value, "Tuple");
+}
+function IsUndefined3(value) {
+  return IsKindOf(value, "Undefined");
+}
+function IsUnion(value) {
+  return IsKindOf(value, "Union");
+}
+function IsUint8Array2(value) {
+  return IsKindOf(value, "Uint8Array");
+}
+function IsUnknown(value) {
+  return IsKindOf(value, "Unknown");
+}
+function IsUnsafe(value) {
+  return IsKindOf(value, "Unsafe");
+}
+function IsVoid(value) {
+  return IsKindOf(value, "Void");
+}
+function IsKind(value) {
+  return IsObject(value) && Kind in value && IsString(value[Kind]);
+}
+function IsSchema(value) {
+  return IsAny(value) || IsArgument(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,
+  IsArgument: () => IsArgument2,
+  IsArray: () => IsArray4,
+  IsAsyncIterator: () => IsAsyncIterator3,
+  IsBigInt: () => IsBigInt3,
+  IsBoolean: () => IsBoolean3,
+  IsComputed: () => IsComputed2,
+  IsConstructor: () => IsConstructor2,
+  IsDate: () => IsDate3,
+  IsFunction: () => IsFunction3,
+  IsImport: () => IsImport,
+  IsInteger: () => IsInteger2,
+  IsIntersect: () => IsIntersect2,
+  IsIterator: () => IsIterator3,
+  IsKind: () => IsKind2,
+  IsKindOf: () => IsKindOf2,
+  IsLiteral: () => IsLiteral2,
+  IsLiteralBoolean: () => IsLiteralBoolean,
+  IsLiteralNumber: () => IsLiteralNumber,
+  IsLiteralString: () => IsLiteralString,
+  IsLiteralValue: () => IsLiteralValue2,
+  IsMappedKey: () => IsMappedKey2,
+  IsMappedResult: () => IsMappedResult2,
+  IsNever: () => IsNever2,
+  IsNot: () => IsNot2,
+  IsNull: () => IsNull3,
+  IsNumber: () => IsNumber4,
+  IsObject: () => IsObject4,
+  IsOptional: () => IsOptional2,
+  IsPromise: () => IsPromise2,
+  IsProperties: () => IsProperties,
+  IsReadonly: () => IsReadonly2,
+  IsRecord: () => IsRecord2,
+  IsRecursive: () => IsRecursive,
+  IsRef: () => IsRef2,
+  IsRegExp: () => IsRegExp3,
+  IsSchema: () => IsSchema2,
+  IsString: () => IsString3,
+  IsSymbol: () => IsSymbol3,
+  IsTemplateLiteral: () => IsTemplateLiteral2,
+  IsThis: () => IsThis2,
+  IsTransform: () => IsTransform2,
+  IsTuple: () => IsTuple2,
+  IsUint8Array: () => IsUint8Array3,
+  IsUndefined: () => IsUndefined4,
+  IsUnion: () => IsUnion2,
+  IsUnionLiteral: () => IsUnionLiteral,
+  IsUnknown: () => IsUnknown2,
+  IsUnsafe: () => IsUnsafe2,
+  IsVoid: () => IsVoid2,
+  TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError
+});
+var TypeGuardUnknownTypeError = class extends TypeBoxError {
+};
+var KnownTypes = [
+  "Argument",
+  "Any",
+  "Array",
+  "AsyncIterator",
+  "BigInt",
+  "Boolean",
+  "Computed",
+  "Constructor",
+  "Date",
+  "Enum",
+  "Function",
+  "Integer",
+  "Intersect",
+  "Iterator",
+  "Literal",
+  "MappedKey",
+  "MappedResult",
+  "Not",
+  "Null",
+  "Number",
+  "Object",
+  "Promise",
+  "Record",
+  "Ref",
+  "RegExp",
+  "String",
+  "Symbol",
+  "TemplateLiteral",
+  "This",
+  "Tuple",
+  "Undefined",
+  "Union",
+  "Uint8Array",
+  "Unknown",
+  "Void"
+];
+function IsPattern(value) {
+  try {
+    new RegExp(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function IsControlCharacterFree(value) {
+  if (!IsString(value))
+    return false;
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 7 && code <= 13 || code === 27 || code === 127) {
+      return false;
+    }
+  }
+  return true;
+}
+function IsAdditionalProperties(value) {
+  return IsOptionalBoolean(value) || IsSchema2(value);
+}
+function IsOptionalBigInt(value) {
+  return IsUndefined(value) || IsBigInt(value);
+}
+function IsOptionalNumber(value) {
+  return IsUndefined(value) || IsNumber(value);
+}
+function IsOptionalBoolean(value) {
+  return IsUndefined(value) || IsBoolean(value);
+}
+function IsOptionalString(value) {
+  return IsUndefined(value) || IsString(value);
+}
+function IsOptionalPattern(value) {
+  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value) && IsPattern(value);
+}
+function IsOptionalFormat(value) {
+  return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value);
+}
+function IsOptionalSchema(value) {
+  return IsUndefined(value) || IsSchema2(value);
+}
+function IsReadonly2(value) {
+  return IsObject(value) && value[ReadonlyKind] === "Readonly";
+}
+function IsOptional2(value) {
+  return IsObject(value) && value[OptionalKind] === "Optional";
+}
+function IsAny2(value) {
+  return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
+}
+function IsArgument2(value) {
+  return IsKindOf2(value, "Argument") && IsNumber(value.index);
+}
+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) {
+  return IsKindOf2(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+}
+function IsBigInt3(value) {
+  return IsKindOf2(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
+}
+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);
+}
+function IsDate3(value) {
+  return IsKindOf2(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
+}
+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);
+}
+function IsProperties(value) {
+  return IsObject(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema2(schema));
+}
+function IsIntersect2(value) {
+  return IsKindOf2(value, "Intersect") && (IsString(value.type) && value.type !== "object" ? false : true) && IsArray(value.allOf) && value.allOf.every((schema) => IsSchema2(schema) && !IsTransform2(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
+}
+function IsIterator3(value) {
+  return IsKindOf2(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+}
+function IsKindOf2(value, kind) {
+  return IsObject(value) && Kind in value && value[Kind] === kind;
+}
+function IsLiteralString(value) {
+  return IsLiteral2(value) && IsString(value.const);
+}
+function IsLiteralNumber(value) {
+  return IsLiteral2(value) && IsNumber(value.const);
+}
+function IsLiteralBoolean(value) {
+  return IsLiteral2(value) && IsBoolean(value.const);
+}
+function IsLiteral2(value) {
+  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue2(value.const);
+}
+function IsLiteralValue2(value) {
+  return IsBoolean(value) || IsNumber(value) || IsString(value);
+}
+function IsMappedKey2(value) {
+  return IsKindOf2(value, "MappedKey") && IsArray(value.keys) && value.keys.every((key) => IsNumber(key) || IsString(key));
+}
+function IsMappedResult2(value) {
+  return IsKindOf2(value, "MappedResult") && IsProperties(value.properties);
+}
+function IsNever2(value) {
+  return IsKindOf2(value, "Never") && IsObject(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
+}
+function IsNot2(value) {
+  return IsKindOf2(value, "Not") && IsSchema2(value.not);
+}
+function IsNull3(value) {
+  return IsKindOf2(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
+}
+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 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) {
+  return IsKindOf2(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema2(value.item);
+}
+function IsRecord2(value) {
+  return IsKindOf2(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject(value.patternProperties) && ((schema) => {
+    const keys = Object.getOwnPropertyNames(schema.patternProperties);
+    return keys.length === 1 && IsPattern(keys[0]) && IsObject(schema.patternProperties) && IsSchema2(schema.patternProperties[keys[0]]);
+  })(value);
+}
+function IsRecursive(value) {
+  return IsObject(value) && Hint in value && value[Hint] === "Recursive";
+}
+function IsRef2(value) {
+  return IsKindOf2(value, "Ref") && IsOptionalString(value.$id) && IsString(value.$ref);
+}
+function IsRegExp3(value) {
+  return IsKindOf2(value, "RegExp") && IsOptionalString(value.$id) && IsString(value.source) && IsString(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
+}
+function IsString3(value) {
+  return IsKindOf2(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
+}
+function IsSymbol3(value) {
+  return IsKindOf2(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
+}
+function IsTemplateLiteral2(value) {
+  return IsKindOf2(value, "TemplateLiteral") && value.type === "string" && IsString(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
+}
+function IsThis2(value) {
+  return IsKindOf2(value, "This") && IsOptionalString(value.$id) && IsString(value.$ref);
+}
+function IsTransform2(value) {
+  return IsObject(value) && TransformKind in value;
+}
+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 IsUndefined4(value) {
+  return IsKindOf2(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
+}
+function IsUnionLiteral(value) {
+  return IsUnion2(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
+}
+function IsUnion2(value) {
+  return IsKindOf2(value, "Union") && IsOptionalString(value.$id) && IsObject(value) && IsArray(value.anyOf) && value.anyOf.every((schema) => IsSchema2(schema));
+}
+function IsUint8Array3(value) {
+  return IsKindOf2(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
+}
+function IsUnknown2(value) {
+  return IsKindOf2(value, "Unknown") && IsOptionalString(value.$id);
+}
+function IsUnsafe2(value) {
+  return IsKindOf2(value, "Unsafe");
+}
+function IsVoid2(value) {
+  return IsKindOf2(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
+}
+function IsKind2(value) {
+  return IsObject(value) && Kind in value && IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
+}
+function IsSchema2(value) {
+  return IsObject(value) && (IsAny2(value) || IsArgument2(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) {
+  return T.includes(S);
+}
+function SetDistinct(T) {
+  return [...new Set(T)];
+}
+function SetIntersect(T, S) {
+  return T.filter((L) => S.includes(L));
+}
+function SetIntersectManyResolve(T, Init) {
+  return T.reduce((Acc, L) => {
+    return SetIntersect(Acc, L);
+  }, Init);
+}
+function SetIntersectMany(T) {
+  return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
+}
+function SetUnionMany(T) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...L);
+  return Acc;
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/any/any.mjs
+function Any(options) {
+  return CreateType({ [Kind]: "Any" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/array/array.mjs
+function Array2(items, options) {
+  return CreateType({ [Kind]: "Array", type: "array", items }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/argument/argument.mjs
+function Argument(index) {
+  return CreateType({ [Kind]: "Argument", index });
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs
+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
+function DiscardKey(value, key) {
+  const { [key]: _, ...rest } = value;
+  return rest;
+}
+function Discard(value, keys) {
+  return keys.reduce((acc, key) => DiscardKey(acc, key), value);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/never/never.mjs
+function Never(options) {
+  return CreateType({ [Kind]: "Never", not: {} }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-result.mjs
+function MappedResult(properties) {
+  return CreateType({
+    [Kind]: "MappedResult",
+    properties
+  });
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.mjs
+function Constructor(parameters, returns, options) {
+  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 CreateType({ [Kind]: "Function", type: "Function", parameters, returns }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/union/union-create.mjs
+function UnionCreate(T, options) {
+  return CreateType({ [Kind]: "Union", anyOf: T }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.mjs
+function IsUnionOptional(types) {
+  return types.some((type) => IsOptional(type));
+}
+function RemoveOptionalFromRest(types) {
+  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
+}
+function RemoveOptionalFromType(T) {
+  return Discard(T, [OptionalKind]);
+}
+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 === 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(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
+var TemplateLiteralParserError = class extends TypeBoxError {
+};
+function Unescape(pattern) {
+  return pattern.replace(/\\\$/g, "$").replace(/\\\*/g, "*").replace(/\\\^/g, "^").replace(/\\\|/g, "|").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
+}
+function IsNonEscaped(pattern, index, char) {
+  return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+}
+function IsOpenParen(pattern, index) {
+  return IsNonEscaped(pattern, index, "(");
+}
+function IsCloseParen(pattern, index) {
+  return IsNonEscaped(pattern, index, ")");
+}
+function IsSeparator(pattern, index) {
+  return IsNonEscaped(pattern, index, "|");
+}
+function IsGroup(pattern) {
+  if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
+    return false;
+  let count = 0;
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (count === 0 && index !== pattern.length - 1)
+      return false;
+  }
+  return true;
+}
+function InGroup(pattern) {
+  return pattern.slice(1, pattern.length - 1);
+}
+function IsPrecedenceOr(pattern) {
+  let count = 0;
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (IsSeparator(pattern, index) && count === 0)
+      return true;
+  }
+  return false;
+}
+function IsPrecedenceAnd(pattern) {
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      return true;
+  }
+  return false;
+}
+function Or(pattern) {
+  let [count, start] = [0, 0];
+  const expressions = [];
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      count += 1;
+    if (IsCloseParen(pattern, index))
+      count -= 1;
+    if (IsSeparator(pattern, index) && count === 0) {
+      const range2 = pattern.slice(start, index);
+      if (range2.length > 0)
+        expressions.push(TemplateLiteralParse(range2));
+      start = index + 1;
+    }
+  }
+  const range = pattern.slice(start);
+  if (range.length > 0)
+    expressions.push(TemplateLiteralParse(range));
+  if (expressions.length === 0)
+    return { type: "const", const: "" };
+  if (expressions.length === 1)
+    return expressions[0];
+  return { type: "or", expr: expressions };
+}
+function And(pattern) {
+  function Group(value, index) {
+    if (!IsOpenParen(value, index))
+      throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+    let count = 0;
+    for (let scan = index; scan < value.length; scan++) {
+      if (IsOpenParen(value, scan))
+        count += 1;
+      if (IsCloseParen(value, scan))
+        count -= 1;
+      if (count === 0)
+        return [index, scan];
+    }
+    throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+  }
+  function Range(pattern2, index) {
+    for (let scan = index; scan < pattern2.length; scan++) {
+      if (IsOpenParen(pattern2, scan))
+        return [index, scan];
+    }
+    return [index, pattern2.length];
+  }
+  const expressions = [];
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index)) {
+      const [start, end] = Group(pattern, index);
+      const range = pattern.slice(start, end + 1);
+      expressions.push(TemplateLiteralParse(range));
+      index = end;
+    } else {
+      const [start, end] = Range(pattern, index);
+      const range = pattern.slice(start, end);
+      if (range.length > 0)
+        expressions.push(TemplateLiteralParse(range));
+      index = end - 1;
+    }
+  }
+  return expressions.length === 0 ? { type: "const", const: "" } : expressions.length === 1 ? expressions[0] : { type: "and", expr: expressions };
+}
+function TemplateLiteralParse(pattern) {
+  return IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) : IsPrecedenceOr(pattern) ? Or(pattern) : IsPrecedenceAnd(pattern) ? And(pattern) : { type: "const", const: Unescape(pattern) };
+}
+function TemplateLiteralParseExact(pattern) {
+  return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.mjs
+var TemplateLiteralFiniteError = class extends TypeBoxError {
+};
+function IsNumberExpression(expression) {
+  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
+}
+function IsBooleanExpression(expression) {
+  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
+}
+function IsStringExpression(expression) {
+  return expression.type === "const" && expression.const === ".*";
+}
+function IsTemplateLiteralExpressionFinite(expression) {
+  return IsNumberExpression(expression) || IsStringExpression(expression) ? false : IsBooleanExpression(expression) ? true : expression.type === "and" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "or" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "const" ? true : (() => {
+    throw new TemplateLiteralFiniteError(`Unknown expression type`);
+  })();
+}
+function IsTemplateLiteralFinite(schema) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  return IsTemplateLiteralExpressionFinite(expression);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/generate.mjs
+var TemplateLiteralGenerateError = class extends TypeBoxError {
+};
+function* GenerateReduce(buffer) {
+  if (buffer.length === 1)
+    return yield* buffer[0];
+  for (const left of buffer[0]) {
+    for (const right of GenerateReduce(buffer.slice(1))) {
+      yield `${left}${right}`;
+    }
+  }
+}
+function* GenerateAnd(expression) {
+  return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
+}
+function* GenerateOr(expression) {
+  for (const expr of expression.expr)
+    yield* TemplateLiteralExpressionGenerate(expr);
+}
+function* GenerateConst(expression) {
+  return yield expression.const;
+}
+function* TemplateLiteralExpressionGenerate(expression) {
+  return expression.type === "and" ? yield* GenerateAnd(expression) : expression.type === "or" ? yield* GenerateOr(expression) : expression.type === "const" ? yield* GenerateConst(expression) : (() => {
+    throw new TemplateLiteralGenerateError("Unknown expression");
+  })();
+}
+function TemplateLiteralGenerate(schema) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  return IsTemplateLiteralExpressionFinite(expression) ? [...TemplateLiteralExpressionGenerate(expression)] : [];
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/literal/literal.mjs
+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 Boolean2(options) {
+  return CreateType({ [Kind]: "Boolean", type: "boolean" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/bigint/bigint.mjs
+function BigInt(options) {
+  return CreateType({ [Kind]: "BigInt", type: "bigint" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/number/number.mjs
+function Number2(options) {
+  return CreateType({ [Kind]: "Number", type: "number" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/string/string.mjs
+function String2(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 Boolean2() : trim === "number" ? yield Number2() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String2() : yield (() => {
+    const literals = trim.split("|").map((literal) => Literal(literal.trim()));
+    return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
+  })();
+}
+function* FromTerminal(syntax) {
+  if (syntax[1] !== "{") {
+    const L = Literal("$");
+    const R = FromSyntax(syntax.slice(1));
+    return yield* [L, ...R];
+  }
+  for (let i = 2; i < syntax.length; i++) {
+    if (syntax[i] === "}") {
+      const L = FromUnion(syntax.slice(2, i));
+      const R = FromSyntax(syntax.slice(i + 1));
+      return yield* [...L, ...R];
+    }
+  }
+  yield Literal(syntax);
+}
+function* FromSyntax(syntax) {
+  for (let i = 0; i < syntax.length; i++) {
+    if (syntax[i] === "$") {
+      const L = Literal(syntax.slice(0, i));
+      const R = FromTerminal(syntax.slice(i));
+      return yield* [L, ...R];
+    }
+  }
+  yield Literal(syntax);
+}
+function TemplateLiteralSyntax(syntax) {
+  return [...FromSyntax(syntax)];
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/pattern.mjs
+var TemplateLiteralPatternError = class extends TypeBoxError {
+};
+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("|")})` : 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]}'`);
+  })();
+}
+function TemplateLiteralPattern(kinds) {
+  return `^${kinds.map((schema) => Visit2(schema, "")).join("")}$`;
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/union.mjs
+function TemplateLiteralToUnion(schema) {
+  const R = TemplateLiteralGenerate(schema);
+  const L = R.map((S) => Literal(S));
+  return UnionEvaluated(L);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/template-literal/template-literal.mjs
+function TemplateLiteral(unresolved, options) {
+  const pattern = IsString(unresolved) ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) : TemplateLiteralPattern(unresolved);
+  return CreateType({ [Kind]: "TemplateLiteral", type: "string", pattern }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.mjs
+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(literalValue) {
+  return [literalValue.toString()];
+}
+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(type, properties, options) {
+  const result = {};
+  for (const K2 of Object.getOwnPropertyNames(properties)) {
+    result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
+  }
+  return result;
+}
+function FromMappedResult(type, mappedResult, options) {
+  return FromProperties(type, mappedResult.properties, options);
+}
+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(types, key) {
+  return types.map((type) => IndexFromPropertyKey(type, key));
+}
+function FromIntersectRest(types) {
+  return types.filter((type) => !IsNever(type));
+}
+function FromIntersect(types, key) {
+  return IntersectEvaluated(FromIntersectRest(FromRest(types, key)));
+}
+function FromUnionRest(types) {
+  return types.some((L) => IsNever(L)) ? [] : types;
+}
+function FromUnion3(types, key) {
+  return UnionEvaluated(FromUnionRest(FromRest(types, key)));
+}
+function FromTuple(types, key) {
+  return key in types ? types[key] : key === "[number]" ? UnionEvaluated(types) : Never();
+}
+function FromArray(type, key) {
+  return key === "[number]" ? type : Never();
+}
+function FromProperty(properties, propertyKey) {
+  return propertyKey in properties ? properties[propertyKey] : 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(type, propertyKeys) {
+  return propertyKeys.map((propertyKey) => IndexFromPropertyKey(type, propertyKey));
+}
+function FromSchema(type, propertyKeys) {
+  return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
+}
+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(type, key, options) {
+  return { [key]: Index(type, [key], Clone(options)) };
+}
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+  return propertyKeys.reduce((result, left) => {
+    return { ...result, ...MappedIndexPropertyKey(type, left, options) };
+  }, {});
+}
+function MappedIndexProperties(type, mappedKey, options) {
+  return MappedIndexPropertyKeys(type, mappedKey.keys, options);
+}
+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 CreateType({ [Kind]: "Iterator", type: "Iterator", items }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/object/object.mjs
+function RequiredArray(properties) {
+  return globalThis.Object.keys(properties).filter((key) => !IsOptional(properties[key]));
+}
+function _Object(properties, options) {
+  const required = RequiredArray(properties);
+  const schema = required.length > 0 ? { [Kind]: "Object", type: "object", required, properties } : { [Kind]: "Object", type: "object", properties };
+  return CreateType(schema, options);
+}
+var Object2 = _Object;
+
+// node_modules/@sinclair/typebox/build/esm/type/promise/promise.mjs
+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 CreateType(Discard(schema, [ReadonlyKind]));
+}
+function AddReadonly(schema) {
+  return CreateType({ ...schema, [ReadonlyKind]: "Readonly" });
+}
+function ReadonlyWithFlag(schema, F) {
+  return F === false ? RemoveReadonly(schema) : AddReadonly(schema);
+}
+function Readonly(schema, enable) {
+  const F = enable ?? true;
+  return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/readonly/readonly-from-mapped-result.mjs
+function FromProperties2(K, F) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+    Acc[K2] = Readonly(K[K2], F);
+  return Acc;
+}
+function FromMappedResult2(R, F) {
+  return FromProperties2(R.properties, F);
+}
+function ReadonlyFromMappedResult(R, F) {
+  const P = FromMappedResult2(R, F);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.mjs
+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
+function FromMappedResult3(K, P) {
+  return K in P ? FromSchemaType(K, P[K]) : MappedResult(P);
+}
+function MappedKeyToKnownMappedResultProperties(K) {
+  return { [K]: Literal(K) };
+}
+function MappedKeyToUnknownMappedResultProperties(P) {
+  const Acc = {};
+  for (const L of P)
+    Acc[L] = Literal(L);
+  return Acc;
+}
+function MappedKeyToMappedResultProperties(K, P) {
+  return SetIncludes(P, K) ? MappedKeyToKnownMappedResultProperties(K) : MappedKeyToUnknownMappedResultProperties(P);
+}
+function FromMappedKey(K, P) {
+  const R = MappedKeyToMappedResultProperties(K, P);
+  return FromMappedResult3(K, R);
+}
+function FromRest2(K, T) {
+  return T.map((L) => FromSchemaType(K, L));
+}
+function FromProperties3(K, T) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(T))
+    Acc[K2] = FromSchemaType(K, T[K2]);
+  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), 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
+      )
+    )
+  );
+}
+function MappedFunctionReturnType(K, T) {
+  const Acc = {};
+  for (const L of K)
+    Acc[L] = FromSchemaType(L, T);
+  return Acc;
+}
+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 Object2(R, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/optional/optional.mjs
+function RemoveOptional(schema) {
+  return CreateType(Discard(schema, [OptionalKind]));
+}
+function AddOptional(schema) {
+  return CreateType({ ...schema, [OptionalKind]: "Optional" });
+}
+function OptionalWithFlag(schema, F) {
+  return F === false ? RemoveOptional(schema) : AddOptional(schema);
+}
+function Optional(schema, enable) {
+  const F = enable ?? true;
+  return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.mjs
+function FromProperties4(P, F) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(P))
+    Acc[K2] = Optional(P[K2], F);
+  return Acc;
+}
+function FromMappedResult4(R, F) {
+  return FromProperties4(R.properties, F);
+}
+function OptionalFromMappedResult(R, F) {
+  const P = FromMappedResult4(R, F);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-create.mjs
+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(types) {
+  return types.every((left) => IsOptional(left));
+}
+function RemoveOptionalFromType2(type) {
+  return Discard(type, [OptionalKind]);
+}
+function RemoveOptionalFromRest2(types) {
+  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType2(left) : left);
+}
+function ResolveIntersect(types, options) {
+  return IsIntersectOptional(types) ? Optional(IntersectCreate(RemoveOptionalFromRest2(types), options)) : IntersectCreate(RemoveOptionalFromRest2(types), options);
+}
+function IntersectEvaluated(types, options = {}) {
+  if (types.length === 1)
+    return CreateType(types[0], options);
+  if (types.length === 0)
+    return Never(options);
+  if (types.some((schema) => IsTransform(schema)))
+    throw new Error("Cannot intersect transform types");
+  return ResolveIntersect(types, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.mjs
+function Intersect(types, options) {
+  if (types.length === 1)
+    return CreateType(types[0], options);
+  if (types.length === 0)
+    return Never(options);
+  if (types.some((schema) => IsTransform(schema)))
+    throw new Error("Cannot intersect transform types");
+  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 FromComputed(target, parameters) {
+  return Computed("Awaited", [Computed(target, parameters)]);
+}
+function FromRef($ref) {
+  return Computed("Awaited", [Ref($ref)]);
+}
+function FromIntersect2(types) {
+  return Intersect(FromRest3(types));
+}
+function FromUnion4(types) {
+  return Union(FromRest3(types));
+}
+function FromPromise(type) {
+  return Awaited(type);
+}
+function FromRest3(types) {
+  return types.map((type) => Awaited(type));
+}
+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(types) {
+  const result = [];
+  for (const L of types)
+    result.push(KeyOfPropertyKeys(L));
+  return result;
+}
+function FromIntersect3(types) {
+  const propertyKeysArray = FromRest4(types);
+  const propertyKeys = SetUnionMany(propertyKeysArray);
+  return propertyKeys;
+}
+function FromUnion5(types) {
+  const propertyKeysArray = FromRest4(types);
+  const propertyKeys = SetIntersectMany(propertyKeysArray);
+  return propertyKeys;
+}
+function FromTuple2(types) {
+  return types.map((_, indexer) => indexer.toString());
+}
+function FromArray2(_) {
+  return ["[number]"];
+}
+function FromProperties5(T) {
+  return globalThis.Object.getOwnPropertyNames(T);
+}
+function FromPatternProperties(patternProperties) {
+  if (!includePatternProperties)
+    return [];
+  const patternPropertyKeys = globalThis.Object.getOwnPropertyNames(patternProperties);
+  return patternPropertyKeys.map((key) => {
+    return key[0] === "^" && key[key.length - 1] === "$" ? key.slice(1, key.length - 1) : key;
+  });
+}
+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 FromComputed2(target, parameters) {
+  return Computed("KeyOf", [Computed(target, parameters)]);
+}
+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(properties, options) {
+  const result = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(properties))
+    result[K2] = KeyOf(properties[K2], Clone(options));
+  return result;
+}
+function FromMappedResult5(mappedResult, options) {
+  return FromProperties6(mappedResult.properties, options);
+}
+function KeyOfFromMappedResult(mappedResult, options) {
+  const properties = FromMappedResult5(mappedResult, options);
+  return MappedResult(properties);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/composite/composite.mjs
+function CompositeKeys(T) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...KeyOfPropertyKeys(L));
+  return SetDistinct(Acc);
+}
+function FilterNever(T) {
+  return T.filter((L) => !IsNever(L));
+}
+function CompositeProperty(T, K) {
+  const Acc = [];
+  for (const L of T)
+    Acc.push(...IndexFromPropertyKeys(L, [K]));
+  return FilterNever(Acc);
+}
+function CompositeProperties(T, K) {
+  const Acc = {};
+  for (const L of K) {
+    Acc[L] = IntersectEvaluated(CompositeProperty(T, L));
+  }
+  return Acc;
+}
+function Composite(T, options) {
+  const K = CompositeKeys(T);
+  const P = CompositeProperties(T, K);
+  const R = Object2(P, options);
+  return R;
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/date/date.mjs
+function Date2(options) {
+  return CreateType({ [Kind]: "Date", type: "Date" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/null/null.mjs
+function Null(options) {
+  return CreateType({ [Kind]: "Null", type: "null" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.mjs
+function Symbol2(options) {
+  return CreateType({ [Kind]: "Symbol", type: "symbol" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.mjs
+function Undefined(options) {
+  return CreateType({ [Kind]: "Undefined", type: "undefined" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.mjs
+function Uint8Array2(options) {
+  return CreateType({ [Kind]: "Uint8Array", type: "Uint8Array" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.mjs
+function Unknown(options) {
+  return CreateType({ [Kind]: "Unknown" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/const/const.mjs
+function FromArray3(T) {
+  return T.map((L) => FromValue(L, false));
+}
+function FromProperties7(value) {
+  const Acc = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(value))
+    Acc[K] = Readonly(FromValue(value[K], false));
+  return Acc;
+}
+function ConditionalReadonly(T, root) {
+  return root === true ? T : Readonly(T);
+}
+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 CreateType(FromValue(T, true), options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs
+function ConstructorParameters(schema, options) {
+  return IsConstructor(schema) ? Tuple(schema.parameters, options) : Never(options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs
+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]);
+  const values2 = [...new Set(values1)];
+  const anyOf = values2.map((value) => Literal(value));
+  return Union(anyOf, { ...options, [Hint]: "Enum" });
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extends/extends-check.mjs
+var ExtendsResolverError = class extends TypeBoxError {
+};
+var ExtendsResult;
+(function(ExtendsResult2) {
+  ExtendsResult2[ExtendsResult2["Union"] = 0] = "Union";
+  ExtendsResult2[ExtendsResult2["True"] = 1] = "True";
+  ExtendsResult2[ExtendsResult2["False"] = 2] = "False";
+})(ExtendsResult || (ExtendsResult = {}));
+function IntoBooleanResult(result) {
+  return result === ExtendsResult.False ? result : ExtendsResult.True;
+}
+function Throw(message) {
+  throw new ExtendsResolverError(message);
+}
+function IsStructuralRight(right) {
+  return type_exports.IsNever(right) || type_exports.IsIntersect(right) || type_exports.IsUnion(right) || type_exports.IsUnknown(right) || type_exports.IsAny(right);
+}
+function StructuralRight(left, right) {
+  return type_exports.IsNever(right) ? FromNeverRight(left, right) : type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) ? FromUnionRight(left, right) : type_exports.IsUnknown(right) ? FromUnknownRight(left, right) : type_exports.IsAny(right) ? FromAnyRight(left, right) : Throw("StructuralRight");
+}
+function FromAnyRight(left, right) {
+  return ExtendsResult.True;
+}
+function FromAny(left, right) {
+  return type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) && right.anyOf.some((schema) => type_exports.IsAny(schema) || type_exports.IsUnknown(schema)) ? ExtendsResult.True : type_exports.IsUnion(right) ? ExtendsResult.Union : type_exports.IsUnknown(right) ? ExtendsResult.True : type_exports.IsAny(right) ? ExtendsResult.True : ExtendsResult.Union;
+}
+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 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 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) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsBigInt(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromBooleanRight(left, right) {
+  return type_exports.IsLiteralBoolean(left) ? ExtendsResult.True : type_exports.IsBoolean(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+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 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 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) {
+  return type_exports.IsLiteral(left) && value_exports.IsNumber(left.const) ? ExtendsResult.True : type_exports.IsNumber(left) || type_exports.IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromInteger(left, right) {
+  return type_exports.IsInteger(right) || type_exports.IsNumber(right) ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : ExtendsResult.False;
+}
+function FromIntersectRight(left, right) {
+  return right.allOf.every((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromIntersect4(left, right) {
+  return left.allOf.some((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+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) {
+  return type_exports.IsLiteral(right) && right.const === left.const ? ExtendsResult.True : IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsString(right) ? FromStringRight(left, right) : type_exports.IsNumber(right) ? FromNumberRight(left, right) : type_exports.IsInteger(right) ? FromIntegerRight(left, right) : type_exports.IsBoolean(right) ? FromBooleanRight(left, right) : ExtendsResult.False;
+}
+function FromNeverRight(left, right) {
+  return ExtendsResult.False;
+}
+function FromNever(left, right) {
+  return ExtendsResult.True;
+}
+function UnwrapTNot(schema) {
+  let [current, depth] = [schema, 0];
+  while (true) {
+    if (!type_exports.IsNot(current))
+      break;
+    current = current.not;
+    depth += 1;
+  }
+  return depth % 2 === 0 ? current : Unknown();
+}
+function FromNot(left, right) {
+  return type_exports.IsNot(left) ? Visit3(UnwrapTNot(left), right) : type_exports.IsNot(right) ? Visit3(left, UnwrapTNot(right)) : Throw("Invalid fallthrough for Not");
+}
+function FromNull(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsNull(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumberRight(left, right) {
+  return type_exports.IsLiteralNumber(left) ? ExtendsResult.True : type_exports.IsNumber(left) || type_exports.IsInteger(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromNumber(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsInteger(right) || type_exports.IsNumber(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function IsObjectPropertyCount(schema, count) {
+  return Object.getOwnPropertyNames(schema.properties).length === count;
+}
+function IsObjectStringLike(schema) {
+  return IsObjectArrayLike(schema);
+}
+function IsObjectSymbolLike(schema) {
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "description" in schema.properties && type_exports.IsUnion(schema.properties.description) && schema.properties.description.anyOf.length === 2 && (type_exports.IsString(schema.properties.description.anyOf[0]) && type_exports.IsUndefined(schema.properties.description.anyOf[1]) || type_exports.IsString(schema.properties.description.anyOf[1]) && type_exports.IsUndefined(schema.properties.description.anyOf[0]));
+}
+function IsObjectNumberLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectBooleanLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectBigIntLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectDateLike(schema) {
+  return IsObjectPropertyCount(schema, 0);
+}
+function IsObjectUint8ArrayLike(schema) {
+  return IsObjectArrayLike(schema);
+}
+function IsObjectFunctionLike(schema) {
+  const length = 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 = Number2();
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "length" in schema.properties && IntoBooleanResult(Visit3(schema.properties["length"], length)) === ExtendsResult.True;
+}
+function IsObjectPromiseLike(schema) {
+  const then = Function([Any()], Any());
+  return IsObjectPropertyCount(schema, 0) || IsObjectPropertyCount(schema, 1) && "then" in schema.properties && IntoBooleanResult(Visit3(schema.properties["then"], then)) === ExtendsResult.True;
+}
+function Property(left, right) {
+  return Visit3(left, right) === ExtendsResult.False ? ExtendsResult.False : type_exports.IsOptional(left) && !type_exports.IsOptional(right) ? ExtendsResult.False : ExtendsResult.True;
+}
+function FromObjectRight(left, right) {
+  return type_exports.IsUnknown(left) ? ExtendsResult.False : type_exports.IsAny(left) ? ExtendsResult.Union : type_exports.IsNever(left) || type_exports.IsLiteralString(left) && IsObjectStringLike(right) || type_exports.IsLiteralNumber(left) && IsObjectNumberLike(right) || type_exports.IsLiteralBoolean(left) && IsObjectBooleanLike(right) || type_exports.IsSymbol(left) && IsObjectSymbolLike(right) || type_exports.IsBigInt(left) && IsObjectBigIntLike(right) || type_exports.IsString(left) && IsObjectStringLike(right) || type_exports.IsSymbol(left) && IsObjectSymbolLike(right) || type_exports.IsNumber(left) && IsObjectNumberLike(right) || type_exports.IsInteger(left) && IsObjectNumberLike(right) || type_exports.IsBoolean(left) && IsObjectBooleanLike(right) || type_exports.IsUint8Array(left) && IsObjectUint8ArrayLike(right) || type_exports.IsDate(left) && IsObjectDateLike(right) || type_exports.IsConstructor(left) && IsObjectConstructorLike(right) || type_exports.IsFunction(left) && IsObjectFunctionLike(right) ? ExtendsResult.True : type_exports.IsRecord(left) && type_exports.IsString(RecordKey(left)) ? (() => {
+    return right[Hint] === "Record" ? ExtendsResult.True : ExtendsResult.False;
+  })() : type_exports.IsRecord(left) && type_exports.IsNumber(RecordKey(left)) ? (() => {
+    return IsObjectPropertyCount(right, 0) ? ExtendsResult.True : ExtendsResult.False;
+  })() : ExtendsResult.False;
+}
+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])) {
+        return ExtendsResult.False;
+      }
+      if (type_exports.IsOptional(right.properties[key])) {
+        return ExtendsResult.True;
+      }
+      if (Property(left.properties[key], right.properties[key]) === ExtendsResult.False) {
+        return ExtendsResult.False;
+      }
+    }
+    return ExtendsResult.True;
+  })();
+}
+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 ? Number2() : PatternStringExact in schema.patternProperties ? String2() : 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");
+}
+function FromRecordRight(left, right) {
+  const [Key, Value] = [RecordKey(right), RecordValue(right)];
+  return type_exports.IsLiteralString(left) && type_exports.IsNumber(Key) && IntoBooleanResult(Visit3(left, Value)) === ExtendsResult.True ? ExtendsResult.True : type_exports.IsUint8Array(left) && type_exports.IsNumber(Key) ? Visit3(left, Value) : type_exports.IsString(left) && type_exports.IsNumber(Key) ? Visit3(left, Value) : type_exports.IsArray(left) && type_exports.IsNumber(Key) ? Visit3(left, Value) : type_exports.IsObject(left) ? (() => {
+    for (const key of Object.getOwnPropertyNames(left.properties)) {
+      if (Property(Value, left.properties[key]) === ExtendsResult.False) {
+        return ExtendsResult.False;
+      }
+    }
+    return ExtendsResult.True;
+  })() : ExtendsResult.False;
+}
+function FromRecord(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : !type_exports.IsRecord(right) ? ExtendsResult.False : Visit3(RecordValue(left), RecordValue(right));
+}
+function FromRegExp(left, right) {
+  const L = type_exports.IsRegExp(left) ? String2() : left;
+  const R = type_exports.IsRegExp(right) ? String2() : right;
+  return Visit3(L, R);
+}
+function FromStringRight(left, right) {
+  return type_exports.IsLiteral(left) && value_exports.IsString(left.const) ? ExtendsResult.True : type_exports.IsString(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromString(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsString(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromSymbol(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsSymbol(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromTemplateLiteral2(left, right) {
+  return type_exports.IsTemplateLiteral(left) ? Visit3(TemplateLiteralToUnion(left), right) : type_exports.IsTemplateLiteral(right) ? Visit3(left, TemplateLiteralToUnion(right)) : Throw("Invalid fallthrough for TemplateLiteral");
+}
+function IsArrayOfTuple(left, right) {
+  return type_exports.IsArray(right) && left.items !== void 0 && left.items.every((schema) => Visit3(schema, right.items) === ExtendsResult.True);
+}
+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 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) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsUint8Array(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUndefined(left, right) {
+  return IsStructuralRight(right) ? StructuralRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsRecord(right) ? FromRecordRight(left, right) : type_exports.IsVoid(right) ? FromVoidRight(left, right) : type_exports.IsUndefined(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnionRight(left, right) {
+  return right.anyOf.some((schema) => Visit3(left, schema) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnion6(left, right) {
+  return left.anyOf.every((schema) => Visit3(schema, right) === ExtendsResult.True) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromUnknownRight(left, right) {
+  return ExtendsResult.True;
+}
+function FromUnknown(left, right) {
+  return type_exports.IsNever(right) ? FromNeverRight(left, right) : type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) ? FromUnionRight(left, right) : type_exports.IsAny(right) ? FromAnyRight(left, right) : type_exports.IsString(right) ? FromStringRight(left, right) : type_exports.IsNumber(right) ? FromNumberRight(left, right) : type_exports.IsInteger(right) ? FromIntegerRight(left, right) : type_exports.IsBoolean(right) ? FromBooleanRight(left, right) : type_exports.IsArray(right) ? FromArrayRight(left, right) : type_exports.IsTuple(right) ? FromTupleRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsUnknown(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoidRight(left, right) {
+  return type_exports.IsUndefined(left) ? ExtendsResult.True : type_exports.IsUndefined(left) ? ExtendsResult.True : ExtendsResult.False;
+}
+function FromVoid(left, right) {
+  return type_exports.IsIntersect(right) ? FromIntersectRight(left, right) : type_exports.IsUnion(right) ? FromUnionRight(left, right) : type_exports.IsUnknown(right) ? FromUnknownRight(left, right) : type_exports.IsAny(right) ? FromAnyRight(left, right) : type_exports.IsObject(right) ? FromObjectRight(left, right) : type_exports.IsVoid(right) ? ExtendsResult.True : ExtendsResult.False;
+}
+function Visit3(left, right) {
+  return (
+    // 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) ? 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]}'`)
+    )
+  );
+}
+function ExtendsCheck(left, right) {
+  return Visit3(left, right);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.mjs
+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, Clone(options));
+  return Acc;
+}
+function FromMappedResult6(Left, 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);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extends/extends.mjs
+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) ? 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, Clone(options))
+  };
+}
+function FromPropertyKeys(K, U, L, R, options) {
+  return K.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey(LK, U, L, R, options) };
+  }, {});
+}
+function FromMappedKey2(K, U, L, R, options) {
+  return FromPropertyKeys(K.keys, U, L, R, options);
+}
+function ExtendsFromMappedKey(T, U, L, R, options) {
+  const P = FromMappedKey2(T, U, L, R, options);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/exclude/exclude-from-template-literal.mjs
+function ExcludeFromTemplateLiteral(L, R) {
+  return Exclude(TemplateLiteralToUnion(L), R);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/exclude/exclude.mjs
+function ExcludeRest(L, R) {
+  const excluded = L.filter((inner) => ExtendsCheck(inner, R) === ExtendsResult.False);
+  return excluded.length === 1 ? excluded[0] : Union(excluded);
+}
+function Exclude(L, R, options = {}) {
+  if (IsTemplateLiteral(L))
+    return CreateType(ExcludeFromTemplateLiteral(L, R), options);
+  if (IsMappedResult(L))
+    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 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 FromProperties9(R.properties, T);
+}
+function ExcludeFromMappedResult(R, T) {
+  const P = FromMappedResult7(R, T);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.mjs
+function ExtractFromTemplateLiteral(L, R) {
+  return Extract(TemplateLiteralToUnion(L), R);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/extract/extract.mjs
+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) {
+  if (IsTemplateLiteral(L))
+    return CreateType(ExtractFromTemplateLiteral(L, R), options);
+  if (IsMappedResult(L))
+    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 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 FromProperties10(R.properties, T);
+}
+function ExtractFromMappedResult(R, T) {
+  const P = FromMappedResult8(R, T);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
+function InstanceType(schema, options) {
+  return IsConstructor(schema) ? CreateType(schema.returns, options) : Never(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/record/record.mjs
+function RecordCreateFromPattern(pattern, T, options) {
+  return CreateType({ [Kind]: "Record", type: "object", patternProperties: { [pattern]: T } }, options);
+}
+function RecordCreateFromKeys(K, T, options) {
+  const result = {};
+  for (const K2 of K)
+    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(key, type, options) {
+  return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options);
+}
+function FromLiteralKey(key, type, options) {
+  return RecordCreateFromKeys([key.toString()], type, options);
+}
+function FromRegExpKey(key, type, options) {
+  return RecordCreateFromPattern(key.source, type, options);
+}
+function FromStringKey(key, type, options) {
+  const pattern = IsUndefined(key.pattern) ? PatternStringExact : key.pattern;
+  return RecordCreateFromPattern(pattern, type, options);
+}
+function FromAnyKey(_, type, options) {
+  return RecordCreateFromPattern(PatternStringExact, type, options);
+}
+function FromNeverKey(_key, type, options) {
+  return RecordCreateFromPattern(PatternNeverExact, type, options);
+}
+function FromBooleanKey(_key, type, options) {
+  return Object2({ true: type, false: type }, options);
+}
+function FromIntegerKey(_key, type, options) {
+  return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+function FromNumberKey(_, type, options) {
+  return RecordCreateFromPattern(PatternNumberExact, type, options);
+}
+function Record(key, type, options = {}) {
+  return IsUnion(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral(key) ? FromLiteralKey(key.const, type, options) : IsBoolean2(key) ? FromBooleanKey(key, 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);
+}
+function RecordPattern(record) {
+  return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
+}
+function RecordKey2(type) {
+  const pattern = RecordPattern(type);
+  return pattern === PatternStringExact ? String2() : pattern === PatternNumberExact ? Number2() : String2({ pattern });
+}
+function RecordValue2(type) {
+  return type.patternProperties[RecordPattern(type)];
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.mjs
+function FromConstructor2(args, type) {
+  type.parameters = FromTypes(args, type.parameters);
+  type.returns = FromType(args, type.returns);
+  return type;
+}
+function FromFunction2(args, type) {
+  type.parameters = FromTypes(args, type.parameters);
+  type.returns = FromType(args, type.returns);
+  return type;
+}
+function FromIntersect5(args, type) {
+  type.allOf = FromTypes(args, type.allOf);
+  return type;
+}
+function FromUnion7(args, type) {
+  type.anyOf = FromTypes(args, type.anyOf);
+  return type;
+}
+function FromTuple4(args, type) {
+  if (IsUndefined(type.items))
+    return type;
+  type.items = FromTypes(args, type.items);
+  return type;
+}
+function FromArray5(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromAsyncIterator2(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromIterator2(args, type) {
+  type.items = FromType(args, type.items);
+  return type;
+}
+function FromPromise3(args, type) {
+  type.item = FromType(args, type.item);
+  return type;
+}
+function FromObject2(args, type) {
+  const mappedProperties = FromProperties11(args, type.properties);
+  return { ...type, ...Object2(mappedProperties) };
+}
+function FromRecord2(args, type) {
+  const mappedKey = FromType(args, RecordKey2(type));
+  const mappedValue = FromType(args, RecordValue2(type));
+  const result = Record(mappedKey, mappedValue);
+  return { ...type, ...result };
+}
+function FromArgument(args, argument) {
+  return argument.index in args ? args[argument.index] : Unknown();
+}
+function FromProperty2(args, type) {
+  const isReadonly = IsReadonly(type);
+  const isOptional = IsOptional(type);
+  const mapped = FromType(args, type);
+  return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
+}
+function FromProperties11(args, properties) {
+  return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+    return { ...result, [key]: FromProperty2(args, properties[key]) };
+  }, {});
+}
+function FromTypes(args, types) {
+  return types.map((type) => FromType(args, type));
+}
+function FromType(args, type) {
+  return IsConstructor(type) ? FromConstructor2(args, type) : IsFunction2(type) ? FromFunction2(args, type) : IsIntersect(type) ? FromIntersect5(args, type) : IsUnion(type) ? FromUnion7(args, type) : IsTuple(type) ? FromTuple4(args, type) : IsArray3(type) ? FromArray5(args, type) : IsAsyncIterator2(type) ? FromAsyncIterator2(args, type) : IsIterator2(type) ? FromIterator2(args, type) : IsPromise(type) ? FromPromise3(args, type) : IsObject3(type) ? FromObject2(args, type) : IsRecord(type) ? FromRecord2(args, type) : IsArgument(type) ? FromArgument(args, type) : type;
+}
+function Instantiate(type, args) {
+  return FromType(args, CloneType(type));
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/integer/integer.mjs
+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, Clone(options))
+  };
+}
+function MappedIntrinsicPropertyKeys(K, M, options) {
+  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);
+}
+function IntrinsicFromMappedKey(T, M, options) {
+  const P = MappedIntrinsicProperties(T, M, options);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic.mjs
+function ApplyUncapitalize(value) {
+  const [first, rest] = [value.slice(0, 1), value.slice(1)];
+  return [first.toLowerCase(), rest].join("");
+}
+function ApplyCapitalize(value) {
+  const [first, rest] = [value.slice(0, 1), value.slice(1)];
+  return [first.toUpperCase(), rest].join("");
+}
+function ApplyUppercase(value) {
+  return value.toUpperCase();
+}
+function ApplyLowercase(value) {
+  return value.toLowerCase();
+}
+function FromTemplateLiteral3(schema, mode, options) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  const finite = IsTemplateLiteralExpressionFinite(expression);
+  if (!finite)
+    return { ...schema, pattern: FromLiteralValue(schema.pattern, mode) };
+  const strings = [...TemplateLiteralExpressionGenerate(expression)];
+  const literals = strings.map((value) => Literal(value));
+  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 FromRest5(T, M) {
+  return T.map((L) => Intrinsic(L, M));
+}
+function Intrinsic(schema, mode, options = {}) {
+  return (
+    // Intrinsic-Mapped-Inference
+    IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) : (
+      // Standard-Inference
+      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)
+      )
+    )
+  );
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intrinsic/capitalize.mjs
+function Capitalize(T, options = {}) {
+  return Intrinsic(T, "Capitalize", options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intrinsic/lowercase.mjs
+function Lowercase(T, options = {}) {
+  return Intrinsic(T, "Lowercase", options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intrinsic/uncapitalize.mjs
+function Uncapitalize(T, options = {}) {
+  return Intrinsic(T, "Uncapitalize", options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/intrinsic/uppercase.mjs
+function Uppercase(T, options = {}) {
+  return Intrinsic(T, "Uppercase", options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-result.mjs
+function FromProperties12(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(mappedResult, propertyKeys, options) {
+  return FromProperties12(mappedResult.properties, propertyKeys, options);
+}
+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(types, propertyKeys) {
+  return types.map((type) => OmitResolve(type, propertyKeys));
+}
+function FromUnion8(types, propertyKeys) {
+  return types.map((type) => OmitResolve(type, propertyKeys));
+}
+function FromProperty3(properties, key) {
+  const { [key]: _, ...R } = properties;
+  return R;
+}
+function FromProperties13(properties, propertyKeys) {
+  return propertyKeys.reduce((T, K2) => FromProperty3(T, K2), properties);
+}
+function FromObject3(type, propertyKeys, properties) {
+  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties13(properties, propertyKeys);
+  return Object2(mappedProperties, options);
+}
+function UnionFromPropertyKeys(propertyKeys) {
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
+  return Union(result);
+}
+function OmitResolve(type, propertyKeys) {
+  return IsIntersect(type) ? Intersect(FromIntersect6(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion8(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject3(type, propertyKeys, type.properties) : 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(type, key, options) {
+  return { [key]: Omit(type, [key], Clone(options)) };
+}
+function FromPropertyKeys2(type, propertyKeys, options) {
+  return propertyKeys.reduce((Acc, LK) => {
+    return { ...Acc, ...FromPropertyKey2(type, LK, options) };
+  }, {});
+}
+function FromMappedKey3(type, mappedKey, options) {
+  return FromPropertyKeys2(type, mappedKey.keys, options);
+}
+function OmitFromMappedKey(type, mappedKey, options) {
+  const properties = FromMappedKey3(type, mappedKey, options);
+  return MappedResult(properties);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-result.mjs
+function FromProperties14(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 FromProperties14(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/pick/pick.mjs
+function FromIntersect7(types, propertyKeys) {
+  return types.map((type) => PickResolve(type, propertyKeys));
+}
+function FromUnion9(types, propertyKeys) {
+  return types.map((type) => PickResolve(type, propertyKeys));
+}
+function FromProperties15(properties, propertyKeys) {
+  const result = {};
+  for (const K2 of propertyKeys)
+    if (K2 in properties)
+      result[K2] = properties[K2];
+  return result;
+}
+function FromObject4(Type2, keys, properties) {
+  const options = Discard(Type2, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties15(properties, keys);
+  return Object2(mappedProperties, options);
+}
+function UnionFromPropertyKeys2(propertyKeys) {
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
+  return Union(result);
+}
+function PickResolve(type, propertyKeys) {
+  return IsIntersect(type) ? Intersect(FromIntersect7(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion9(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject4(type, propertyKeys, type.properties) : Object2({});
+}
+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-key.mjs
+function FromPropertyKey3(type, key, options) {
+  return {
+    [key]: Pick(type, [key], Clone(options))
+  };
+}
+function FromPropertyKeys3(type, propertyKeys, options) {
+  return propertyKeys.reduce((result, leftKey) => {
+    return { ...result, ...FromPropertyKey3(type, leftKey, options) };
+  }, {});
+}
+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/partial/partial.mjs
+function FromComputed3(target, parameters) {
+  return Computed("Partial", [Computed(target, parameters)]);
+}
+function FromRef3($ref) {
+  return Computed("Partial", [Ref($ref)]);
+}
+function FromProperties16(properties) {
+  const partialProperties = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(properties))
+    partialProperties[K] = Optional(properties[K]);
+  return partialProperties;
+}
+function FromObject5(type, properties) {
+  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties16(properties);
+  return Object2(mappedProperties, options);
+}
+function FromRest6(types) {
+  return types.map((type) => PartialResolve(type));
+}
+function PartialResolve(type) {
+  return (
+    // Mappable
+    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) ? FromObject5(type, type.properties) : (
+      // Intrinsic
+      IsBigInt2(type) ? type : IsBoolean2(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull2(type) ? type : IsNumber3(type) ? type : IsString2(type) ? type : IsSymbol2(type) ? type : IsUndefined3(type) ? type : (
+        // Passthrough
+        Object2({})
+      )
+    )
+  );
+}
+function Partial(type, options) {
+  if (IsMappedResult(type)) {
+    return PartialFromMappedResult(type, options);
+  } else {
+    return CreateType({ ...PartialResolve(type), ...options });
+  }
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/partial/partial-from-mapped-result.mjs
+function FromProperties17(K, options) {
+  const Acc = {};
+  for (const K2 of globalThis.Object.getOwnPropertyNames(K))
+    Acc[K2] = Partial(K[K2], Clone(options));
+  return Acc;
+}
+function FromMappedResult11(R, options) {
+  return FromProperties17(R.properties, options);
+}
+function PartialFromMappedResult(R, options) {
+  const P = FromMappedResult11(R, options);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/required/required.mjs
+function FromComputed4(target, parameters) {
+  return Computed("Required", [Computed(target, parameters)]);
+}
+function FromRef4($ref) {
+  return Computed("Required", [Ref($ref)]);
+}
+function FromProperties18(properties) {
+  const requiredProperties = {};
+  for (const K of globalThis.Object.getOwnPropertyNames(properties))
+    requiredProperties[K] = Discard(properties[K], [OptionalKind]);
+  return requiredProperties;
+}
+function FromObject6(type, properties) {
+  const options = Discard(type, [TransformKind, "$id", "required", "properties"]);
+  const mappedProperties = FromProperties18(properties);
+  return Object2(mappedProperties, options);
+}
+function FromRest7(types) {
+  return types.map((type) => RequiredResolve(type));
+}
+function RequiredResolve(type) {
+  return (
+    // Mappable
+    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) ? FromObject6(type, type.properties) : (
+      // Intrinsic
+      IsBigInt2(type) ? type : IsBoolean2(type) ? type : IsInteger(type) ? type : IsLiteral(type) ? type : IsNull2(type) ? type : IsNumber3(type) ? type : IsString2(type) ? type : IsSymbol2(type) ? type : IsUndefined3(type) ? type : (
+        // Passthrough
+        Object2({})
+      )
+    )
+  );
+}
+function Required(type, options) {
+  if (IsMappedResult(type)) {
+    return RequiredFromMappedResult(type, options);
+  } else {
+    return CreateType({ ...RequiredResolve(type), ...options });
+  }
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/required/required-from-mapped-result.mjs
+function FromProperties19(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);
+}
+function RequiredFromMappedResult(R, options) {
+  const P = FromMappedResult12(R, options);
+  return MappedResult(P);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/module/compute.mjs
+function DereferenceParameters(moduleProperties, types) {
+  return types.map((type) => {
+    return IsRef(type) ? Dereference(moduleProperties, type.$ref) : FromType2(moduleProperties, type);
+  });
+}
+function Dereference(moduleProperties, ref) {
+  return ref in moduleProperties ? IsRef(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType2(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 FromRequired(parameters) {
+  return Required(parameters[0]);
+}
+function FromComputed5(moduleProperties, target, parameters) {
+  const dereferenced = DereferenceParameters(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 === "Required" ? FromRequired(dereferenced) : Never();
+}
+function FromArray6(moduleProperties, type) {
+  return Array2(FromType2(moduleProperties, type));
+}
+function FromAsyncIterator3(moduleProperties, type) {
+  return AsyncIterator(FromType2(moduleProperties, type));
+}
+function FromConstructor3(moduleProperties, parameters, instanceType) {
+  return Constructor(FromTypes2(moduleProperties, parameters), FromType2(moduleProperties, instanceType));
+}
+function FromFunction3(moduleProperties, parameters, returnType) {
+  return Function(FromTypes2(moduleProperties, parameters), FromType2(moduleProperties, returnType));
+}
+function FromIntersect8(moduleProperties, types) {
+  return Intersect(FromTypes2(moduleProperties, types));
+}
+function FromIterator3(moduleProperties, type) {
+  return Iterator(FromType2(moduleProperties, type));
+}
+function FromObject7(moduleProperties, properties) {
+  return Object2(globalThis.Object.keys(properties).reduce((result, key) => {
+    return { ...result, [key]: FromType2(moduleProperties, properties[key]) };
+  }, {}));
+}
+function FromRecord3(moduleProperties, type) {
+  const [value, pattern] = [FromType2(moduleProperties, RecordValue2(type)), RecordPattern(type)];
+  const result = CloneType(type);
+  result.patternProperties[pattern] = value;
+  return result;
+}
+function FromTransform(moduleProperties, transform) {
+  return IsRef(transform) ? { ...Dereference(moduleProperties, transform.$ref), [TransformKind]: transform[TransformKind] } : transform;
+}
+function FromTuple5(moduleProperties, types) {
+  return Tuple(FromTypes2(moduleProperties, types));
+}
+function FromUnion10(moduleProperties, types) {
+  return Union(FromTypes2(moduleProperties, types));
+}
+function FromTypes2(moduleProperties, types) {
+  return types.map((type) => FromType2(moduleProperties, type));
+}
+function FromType2(moduleProperties, type) {
+  return (
+    // Modifiers
+    IsOptional(type) ? CreateType(FromType2(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType2(moduleProperties, Discard(type, [ReadonlyKind])), type) : (
+      // Transform
+      IsTransform(type) ? CreateType(FromTransform(moduleProperties, type), type) : (
+        // Types
+        IsArray3(type) ? CreateType(FromArray6(moduleProperties, type.items), type) : IsAsyncIterator2(type) ? CreateType(FromAsyncIterator3(moduleProperties, type.items), type) : IsComputed(type) ? CreateType(FromComputed5(moduleProperties, type.target, type.parameters)) : IsConstructor(type) ? CreateType(FromConstructor3(moduleProperties, type.parameters, type.returns), type) : IsFunction2(type) ? CreateType(FromFunction3(moduleProperties, type.parameters, type.returns), type) : IsIntersect(type) ? CreateType(FromIntersect8(moduleProperties, type.allOf), type) : IsIterator2(type) ? CreateType(FromIterator3(moduleProperties, type.items), type) : IsObject3(type) ? CreateType(FromObject7(moduleProperties, type.properties), type) : IsRecord(type) ? CreateType(FromRecord3(moduleProperties, type)) : IsTuple(type) ? CreateType(FromTuple5(moduleProperties, type.items || []), type) : IsUnion(type) ? CreateType(FromUnion10(moduleProperties, type.anyOf), type) : type
+      )
+    )
+  );
+}
+function ComputeType(moduleProperties, key) {
+  return key in moduleProperties ? FromType2(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 IsFunction2(schema) ? Tuple(schema.parameters, options) : Never();
+}
+
+// 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) ? T.allOf : IsUnion(T) ? T.anyOf : IsTuple(T) ? T.items ?? [] : [];
+}
+function Rest(T) {
+  return RestResolve(T);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
+function ReturnType(schema, options) {
+  return IsFunction2(schema) ? CreateType(schema.returns, options) : Never(options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
+var TransformDecodeBuilder = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  Decode(decode) {
+    return new TransformEncodeBuilder(this.schema, decode);
+  }
+};
+var TransformEncodeBuilder = class {
+  constructor(schema, decode) {
+    this.schema = schema;
+    this.decode = decode;
+  }
+  EncodeTransform(encode, schema) {
+    const Encode = (value) => schema[TransformKind].Encode(encode(value));
+    const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
+    const Codec = { Encode, Decode };
+    return { ...schema, [TransformKind]: Codec };
+  }
+  EncodeSchema(encode, schema) {
+    const Codec = { Decode: this.decode, Encode: encode };
+    return { ...schema, [TransformKind]: Codec };
+  }
+  Encode(encode) {
+    return IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
+  }
+};
+function Transform(schema) {
+  return new TransformDecodeBuilder(schema);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.mjs
+function Unsafe(options = {}) {
+  return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/void/void.mjs
+function Void(options) {
+  return CreateType({ [Kind]: "Void", type: "void" }, options);
+}
+
+// node_modules/@sinclair/typebox/build/esm/type/type/type.mjs
+var type_exports2 = {};
+__export(type_exports2, {
+  Any: () => Any,
+  Argument: () => Argument,
+  Array: () => Array2,
+  AsyncIterator: () => AsyncIterator,
+  Awaited: () => Awaited,
+  BigInt: () => BigInt,
+  Boolean: () => Boolean2,
+  Capitalize: () => Capitalize,
+  Composite: () => Composite,
+  Const: () => Const,
+  Constructor: () => Constructor,
+  ConstructorParameters: () => ConstructorParameters,
+  Date: () => Date2,
+  Enum: () => Enum,
+  Exclude: () => Exclude,
+  Extends: () => Extends,
+  Extract: () => Extract,
+  Function: () => Function,
+  Index: () => Index,
+  InstanceType: () => InstanceType,
+  Instantiate: () => Instantiate,
+  Integer: () => Integer,
+  Intersect: () => Intersect,
+  Iterator: () => Iterator,
+  KeyOf: () => KeyOf,
+  Literal: () => Literal,
+  Lowercase: () => Lowercase,
+  Mapped: () => Mapped,
+  Module: () => Module,
+  Never: () => Never,
+  Not: () => Not,
+  Null: () => Null,
+  Number: () => Number2,
+  Object: () => Object2,
+  Omit: () => Omit,
+  Optional: () => Optional,
+  Parameters: () => Parameters,
+  Partial: () => Partial,
+  Pick: () => Pick,
+  Promise: () => Promise2,
+  Readonly: () => Readonly,
+  ReadonlyOptional: () => ReadonlyOptional,
+  Record: () => Record,
+  Recursive: () => Recursive,
+  Ref: () => Ref,
+  RegExp: () => RegExp2,
+  Required: () => Required,
+  Rest: () => Rest,
+  ReturnType: () => ReturnType,
+  String: () => String2,
+  Symbol: () => Symbol2,
+  TemplateLiteral: () => TemplateLiteral,
+  Transform: () => Transform,
+  Tuple: () => Tuple,
+  Uint8Array: () => Uint8Array2,
+  Uncapitalize: () => Uncapitalize,
+  Undefined: () => Undefined,
+  Union: () => Union,
+  Unknown: () => Unknown,
+  Unsafe: () => Unsafe,
+  Uppercase: () => Uppercase,
+  Void: () => Void
+});
+
+// node_modules/@sinclair/typebox/build/esm/type/type/index.mjs
+var Type = type_exports2;
+
+// index.ts
 function generateSessionId() {
   const ts = Date.now().toString(36);
   const rand = Math.random().toString(36).slice(2, 8);
@@ -2544,10 +5150,10 @@ var toolDefinitions = {
       name: "memory_recall",
       label: "Memory Recall",
       description: "Search Sulcus memory for relevant context",
-      parameters: import_typebox.Type.Object({
-        query: import_typebox.Type.String({ description: "Search query string." }),
-        limit: import_typebox.Type.Optional(import_typebox.Type.Number({ default: 5, description: "Maximum number of results to return (1-10)." })),
-        namespace: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Namespace to search. Defaults to your own namespace." }))
+      parameters: Type.Object({
+        query: Type.String({ description: "Search query string." }),
+        limit: Type.Optional(Type.Number({ default: 5, description: "Maximum number of results to return (1-10)." })),
+        namespace: Type.Optional(Type.String({ description: "Namespace to search. Defaults to your own namespace." }))
       })
     },
     options: { name: "memory_recall" },
@@ -2567,16 +5173,16 @@ var toolDefinitions = {
       name: "memory_store",
       label: "Memory Store",
       description: "Record information in Sulcus memory. Supports Markdown formatting. You control the memory type at creation time.",
-      parameters: import_typebox.Type.Object({
-        content: import_typebox.Type.String({ description: "Memory content. Supports Markdown formatting for structured content." }),
-        memory_type: import_typebox.Type.Optional(import_typebox.Type.Union([
-          import_typebox.Type.Literal("episodic"),
-          import_typebox.Type.Literal("semantic"),
-          import_typebox.Type.Literal("preference"),
-          import_typebox.Type.Literal("procedural"),
-          import_typebox.Type.Literal("fact")
+      parameters: Type.Object({
+        content: Type.String({ description: "Memory content. Supports Markdown formatting for structured content." }),
+        memory_type: Type.Optional(Type.Union([
+          Type.Literal("episodic"),
+          Type.Literal("semantic"),
+          Type.Literal("preference"),
+          Type.Literal("procedural"),
+          Type.Literal("fact")
         ], { description: "Memory type. Default: episodic" })),
-        train: import_typebox.Type.Optional(import_typebox.Type.Boolean({ description: "Signal the SIU to learn from this manual store. Default: false" }))
+        train: Type.Optional(Type.Boolean({ description: "Signal the SIU to learn from this manual store. Default: false" }))
       })
     },
     options: { name: "memory_store" },
@@ -2620,7 +5226,7 @@ var toolDefinitions = {
       name: "memory_status",
       label: "Memory Status",
       description: "Check Sulcus memory backend status: connection, namespace, capabilities, and hot nodes.",
-      parameters: import_typebox.Type.Object({})
+      parameters: Type.Object({})
     },
     options: { name: "memory_status" },
     makeExecute: ({ sulcusMem, backendMode, namespace, nativeLoader, storeLibPath, vectorsLibPath, wasmDir, isAvailable }) => async (_id, _params) => {
@@ -2694,7 +5300,7 @@ var toolDefinitions = {
       name: "consolidate",
       label: "Memory Consolidate",
       description: "Consolidate cold memories: merges, prunes, or archives nodes below the given heat threshold.",
-      parameters: import_typebox.Type.Object({ min_heat: import_typebox.Type.Optional(import_typebox.Type.Number({ default: 0.1, description: "Heat threshold (0.0\u20131.0)." })) })
+      parameters: Type.Object({ min_heat: Type.Optional(Type.Number({ default: 0.1, description: "Heat threshold (0.0\u20131.0)." })) })
     },
     options: { name: "consolidate" },
     makeExecute: ({ sulcusMem, backendMode, namespace, nativeLoader, isAvailable }) => async (_id, params) => {
@@ -2708,7 +5314,7 @@ var toolDefinitions = {
       name: "export_markdown",
       label: "Export Memory (Markdown)",
       description: "Export all memories in the current namespace as a Markdown document.",
-      parameters: import_typebox.Type.Object({})
+      parameters: Type.Object({})
     },
     options: { name: "export_markdown" },
     makeExecute: ({ sulcusMem, backendMode, namespace, nativeLoader, isAvailable }) => async (_id, _params) => {
@@ -2722,7 +5328,7 @@ var toolDefinitions = {
       name: "import_markdown",
       label: "Import Memory (Markdown)",
       description: "Import memories from a Markdown document into the current namespace.",
-      parameters: import_typebox.Type.Object({ text: import_typebox.Type.String({ description: "Markdown content to import." }) })
+      parameters: Type.Object({ text: Type.String({ description: "Markdown content to import." }) })
     },
     options: { name: "import_markdown" },
     makeExecute: ({ sulcusMem, backendMode, namespace, nativeLoader, isAvailable }) => async (_id, params) => {
@@ -2736,9 +5342,9 @@ var toolDefinitions = {
       name: "evaluate_triggers",
       label: "Evaluate Memory Triggers",
       description: "Evaluate reactive memory triggers against an event and context.",
-      parameters: import_typebox.Type.Object({
-        event: import_typebox.Type.String({ description: "Event name to evaluate triggers against (e.g. 'agent_end', 'user_message')." }),
-        context_json: import_typebox.Type.Optional(import_typebox.Type.String({ description: "JSON string of additional context." }))
+      parameters: Type.Object({
+        event: Type.String({ description: "Event name to evaluate triggers against (e.g. 'agent_end', 'user_message')." }),
+        context_json: Type.Optional(Type.String({ description: "JSON string of additional context." }))
       })
     },
     options: { name: "evaluate_triggers" },
@@ -2753,9 +5359,9 @@ var toolDefinitions = {
       name: "memory_delete",
       label: "Delete Memory",
       description: "Delete a memory node by ID. With train=true (default), trains SIVU to reject similar content.",
-      parameters: import_typebox.Type.Object({
-        id: import_typebox.Type.String({ description: "Memory node ID to delete." }),
-        train: import_typebox.Type.Optional(import_typebox.Type.Boolean({ default: true, description: "Train SIVU to reject similar content (default true)." }))
+      parameters: Type.Object({
+        id: Type.String({ description: "Memory node ID to delete." }),
+        train: Type.Optional(Type.Boolean({ default: true, description: "Train SIVU to reject similar content (default true)." }))
       })
     },
     options: { name: "memory_delete" },
@@ -2774,8 +5380,8 @@ var toolDefinitions = {
       name: "memory_get",
       label: "Get Memory",
       description: "Fetch a specific memory by its UUID. Returns full memory details including content, type, heat, graph edges, and metadata.",
-      parameters: import_typebox.Type.Object({
-        id: import_typebox.Type.String({ description: "Memory node UUID." })
+      parameters: Type.Object({
+        id: Type.String({ description: "Memory node UUID." })
       })
     },
     options: { name: "memory_get" },
@@ -2796,25 +5402,25 @@ var toolDefinitions = {
       name: "memory_list",
       label: "List Memories",
       description: "Browse memories with optional filters. Returns paginated results sorted by heat (hottest first). Use this to explore what Sulcus knows without a search query.",
-      parameters: import_typebox.Type.Object({
-        page: import_typebox.Type.Optional(import_typebox.Type.Number({ default: 1, description: "Page number (1-indexed)." })),
-        page_size: import_typebox.Type.Optional(import_typebox.Type.Number({ default: 20, description: "Results per page (1-100).", minimum: 1, maximum: 100 })),
-        memory_type: import_typebox.Type.Optional(import_typebox.Type.Union([
-          import_typebox.Type.Literal("episodic"),
-          import_typebox.Type.Literal("semantic"),
-          import_typebox.Type.Literal("preference"),
-          import_typebox.Type.Literal("procedural"),
-          import_typebox.Type.Literal("fact")
+      parameters: Type.Object({
+        page: Type.Optional(Type.Number({ default: 1, description: "Page number (1-indexed)." })),
+        page_size: Type.Optional(Type.Number({ default: 20, description: "Results per page (1-100).", minimum: 1, maximum: 100 })),
+        memory_type: Type.Optional(Type.Union([
+          Type.Literal("episodic"),
+          Type.Literal("semantic"),
+          Type.Literal("preference"),
+          Type.Literal("procedural"),
+          Type.Literal("fact")
         ], { description: "Filter by memory type." })),
-        pinned: import_typebox.Type.Optional(import_typebox.Type.Boolean({ description: "Filter by pinned status." })),
-        sort_by: import_typebox.Type.Optional(import_typebox.Type.Union([
-          import_typebox.Type.Literal("current_heat"),
-          import_typebox.Type.Literal("created_at"),
-          import_typebox.Type.Literal("updated_at")
+        pinned: Type.Optional(Type.Boolean({ description: "Filter by pinned status." })),
+        sort_by: Type.Optional(Type.Union([
+          Type.Literal("current_heat"),
+          Type.Literal("created_at"),
+          Type.Literal("updated_at")
         ], { description: "Sort field (default: current_heat)." })),
-        sort_order: import_typebox.Type.Optional(import_typebox.Type.Union([
-          import_typebox.Type.Literal("asc"),
-          import_typebox.Type.Literal("desc")
+        sort_order: Type.Optional(Type.Union([
+          Type.Literal("asc"),
+          Type.Literal("desc")
         ], { description: "Sort order (default: desc)." }))
       })
     },
@@ -2845,18 +5451,18 @@ var toolDefinitions = {
       name: "memory_update",
       label: "Update Memory",
       description: "Update fields on an existing memory in-place. Preserves graph edges and history. More surgical than delete+re-store.",
-      parameters: import_typebox.Type.Object({
-        id: import_typebox.Type.String({ description: "Memory node UUID to update." }),
-        content: import_typebox.Type.Optional(import_typebox.Type.String({ description: "New content text (replaces existing)." })),
-        memory_type: import_typebox.Type.Optional(import_typebox.Type.Union([
-          import_typebox.Type.Literal("episodic"),
-          import_typebox.Type.Literal("semantic"),
-          import_typebox.Type.Literal("preference"),
-          import_typebox.Type.Literal("procedural"),
-          import_typebox.Type.Literal("fact")
+      parameters: Type.Object({
+        id: Type.String({ description: "Memory node UUID to update." }),
+        content: Type.Optional(Type.String({ description: "New content text (replaces existing)." })),
+        memory_type: Type.Optional(Type.Union([
+          Type.Literal("episodic"),
+          Type.Literal("semantic"),
+          Type.Literal("preference"),
+          Type.Literal("procedural"),
+          Type.Literal("fact")
         ], { description: "New memory type classification." })),
-        is_pinned: import_typebox.Type.Optional(import_typebox.Type.Boolean({ description: "Pin (prevent decay) or unpin." })),
-        heat: import_typebox.Type.Optional(import_typebox.Type.Number({ description: "Set heat directly (0.0-1.0).", minimum: 0, maximum: 1 }))
+        is_pinned: Type.Optional(Type.Boolean({ description: "Pin (prevent decay) or unpin." })),
+        heat: Type.Optional(Type.Number({ description: "Set heat directly (0.0-1.0).", minimum: 0, maximum: 1 }))
       })
     },
     options: { name: "memory_update" },
@@ -2886,8 +5492,8 @@ var toolDefinitions = {
       name: "memory_profile",
       label: "Memory Profile",
       description: "Show a rich snapshot of this agent's memory health: type distribution, heat curve, top hot nodes, top preferences/facts, and graph stats. Call this to understand what Sulcus knows and how active the memory is.",
-      parameters: import_typebox.Type.Object({
-        limit: import_typebox.Type.Optional(import_typebox.Type.Number({ description: "Max hot nodes to surface (default 10).", minimum: 1, maximum: 50 }))
+      parameters: Type.Object({
+        limit: Type.Optional(Type.Number({ description: "Max hot nodes to surface (default 10).", minimum: 1, maximum: 50 }))
       })
     },
     options: { name: "memory_profile" },
@@ -2982,9 +5588,9 @@ var toolDefinitions = {
       name: "siu_label",
       label: "SIU Label",
       description: "Classify text using SIU v2 \u2014 returns SIVU store/reject decision and SICU memory type classification.",
-      parameters: import_typebox.Type.Object({
-        text: import_typebox.Type.String({ description: "Text to classify." }),
-        classify_only: import_typebox.Type.Optional(import_typebox.Type.Boolean({ description: "Skip SIVU quality gate, only run SICU type classification." }))
+      parameters: Type.Object({
+        text: Type.String({ description: "Text to classify." }),
+        classify_only: Type.Optional(Type.Boolean({ description: "Skip SIVU quality gate, only run SICU type classification." }))
       })
     },
     options: { name: "siu_label" },
@@ -3005,7 +5611,7 @@ var toolDefinitions = {
       name: "siu_status",
       label: "SIU Status",
       description: "Check SIU v2 model availability, deployed versions, and training signal statistics.",
-      parameters: import_typebox.Type.Object({})
+      parameters: Type.Object({})
     },
     options: { name: "siu_status" },
     makeExecute: ({ siuRequest, logger }) => async (_id, _params) => {
@@ -3025,7 +5631,7 @@ var toolDefinitions = {
       name: "siu_retrain",
       label: "SIU Retrain",
       description: "Trigger an async retrain of SIU v2 models using accumulated training signals.",
-      parameters: import_typebox.Type.Object({})
+      parameters: Type.Object({})
     },
     options: { name: "siu_retrain" },
     makeExecute: ({ siuRequest, logger }) => async (_id, _params) => {
@@ -3045,14 +5651,14 @@ var toolDefinitions = {
       name: "trigger_feedback",
       label: "Trigger Feedback",
       description: "Record feedback on a trigger fire (for SITU training).",
-      parameters: import_typebox.Type.Object({
-        feedback_type: import_typebox.Type.String({ description: 'One of: "false_positive", "false_negative", "correct", "wrong_action"' }),
-        trigger_id: import_typebox.Type.Optional(import_typebox.Type.String({ description: "UUID of the trigger rule" })),
-        trigger_log_id: import_typebox.Type.Optional(import_typebox.Type.String({ description: "UUID of the trigger fire log entry" })),
-        event_type: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Event type: memory_created, heat_threshold, recall, etc." })),
-        memory_id: import_typebox.Type.Optional(import_typebox.Type.String({ description: "UUID of the memory involved" })),
-        expected_action: import_typebox.Type.Optional(import_typebox.Type.String({ description: "What should have happened: fire, no_fire, different_action" })),
-        notes: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Free-text explanation of the feedback" }))
+      parameters: Type.Object({
+        feedback_type: Type.String({ description: 'One of: "false_positive", "false_negative", "correct", "wrong_action"' }),
+        trigger_id: Type.Optional(Type.String({ description: "UUID of the trigger rule" })),
+        trigger_log_id: Type.Optional(Type.String({ description: "UUID of the trigger fire log entry" })),
+        event_type: Type.Optional(Type.String({ description: "Event type: memory_created, heat_threshold, recall, etc." })),
+        memory_id: Type.Optional(Type.String({ description: "UUID of the memory involved" })),
+        expected_action: Type.Optional(Type.String({ description: "What should have happened: fire, no_fire, different_action" })),
+        notes: Type.Optional(Type.String({ description: "Free-text explanation of the feedback" }))
       })
     },
     options: { name: "trigger_feedback" },
@@ -3073,14 +5679,14 @@ var toolDefinitions = {
       name: "session_store",
       label: "Session Store",
       description: "Store ephemeral context for the current conversation only. Automatically purged when the session ends. Use this for short-term scratch-pad notes, intermediate reasoning, or context that's only relevant to this exchange.",
-      parameters: import_typebox.Type.Object({
-        content: import_typebox.Type.String({ description: "Content to store for this session." }),
-        memory_type: import_typebox.Type.Optional(import_typebox.Type.Union([
-          import_typebox.Type.Literal("episodic"),
-          import_typebox.Type.Literal("semantic"),
-          import_typebox.Type.Literal("preference"),
-          import_typebox.Type.Literal("procedural"),
-          import_typebox.Type.Literal("fact")
+      parameters: Type.Object({
+        content: Type.String({ description: "Content to store for this session." }),
+        memory_type: Type.Optional(Type.Union([
+          Type.Literal("episodic"),
+          Type.Literal("semantic"),
+          Type.Literal("preference"),
+          Type.Literal("procedural"),
+          Type.Literal("fact")
         ], { description: "Memory type classification. Default: episodic" }))
       })
     },
@@ -3116,9 +5722,9 @@ var toolDefinitions = {
       name: "session_recall",
       label: "Session Recall",
       description: "Search ephemeral context stored in the current conversation with session_store. Returns only memories from this session \u2014 nothing from prior sessions.",
-      parameters: import_typebox.Type.Object({
-        query: import_typebox.Type.String({ description: "Search query string." }),
-        limit: import_typebox.Type.Optional(import_typebox.Type.Number({ default: 5, description: "Maximum results (1-10)." }))
+      parameters: Type.Object({
+        query: Type.String({ description: "Search query string." }),
+        limit: Type.Optional(Type.Number({ default: 5, description: "Maximum results (1-10)." }))
       })
     },
     options: { name: "session_recall" },
@@ -3142,7 +5748,7 @@ var toolDefinitions = {
       name: "memory_inspect",
       label: "Memory Inspect",
       description: "Debug window into what Sulcus is actually doing. Shows what was injected in the last recall, what the output/tool guard scanned, what was blocked and why, and the last N guardrail events. Use this to verify Sulcus is working correctly.",
-      parameters: import_typebox.Type.Object({})
+      parameters: Type.Object({})
     },
     options: { name: "memory_inspect" },
     makeExecute: (_deps) => async (_id, _params) => {
@@ -3209,7 +5815,7 @@ var toolDefinitions = {
       name: "guardrail_status",
       label: "Guardrail Status",
       description: "Returns current guardrail configuration: outputGuard enabled/disabled, which rules are active (PII/preferences/custom), last 5 blocked events with reasons, preference keywords cached, negative prefs count. Use this to verify the guard is working and what it's watching.",
-      parameters: import_typebox.Type.Object({})
+      parameters: Type.Object({})
     },
     options: { name: "guardrail_status" },
     makeExecute: (_deps) => async (_id, _params) => {
@@ -3298,7 +5904,7 @@ var toolDefinitions = {
       name: "__sulcus_workflow__",
       label: "Sulcus Workflow",
       description: "Call this when you are unsure what to do next with Sulcus memory tools. Returns a step-by-step workflow checklist so you always know the right action.",
-      parameters: import_typebox.Type.Object({})
+      parameters: Type.Object({})
     },
     options: { name: "__sulcus_workflow__" },
     makeExecute: (_deps) => async (_id, _params) => {
@@ -3320,13 +5926,13 @@ var toolDefinitions = {
       name: "graph_explore",
       label: "Graph Explore",
       description: "Explore the knowledge graph around a memory (neighbors mode) or query temporal connections (temporal mode).",
-      parameters: import_typebox.Type.Object({
-        mode: import_typebox.Type.Union([import_typebox.Type.Literal("neighbors"), import_typebox.Type.Literal("temporal")], { description: "Exploration mode: 'neighbors' for graph edges around a memory, 'temporal' for time-based connections." }),
-        memory_id: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Memory node UUID. Required for neighbors mode." })),
-        query: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Search query for temporal mode." })),
-        time_from: import_typebox.Type.Optional(import_typebox.Type.String({ description: "ISO 8601 start time for temporal range filter." })),
-        time_to: import_typebox.Type.Optional(import_typebox.Type.String({ description: "ISO 8601 end time for temporal range filter." })),
-        limit: import_typebox.Type.Optional(import_typebox.Type.Number({ default: 10, description: "Max results to return (default 10).", minimum: 1, maximum: 50 }))
+      parameters: Type.Object({
+        mode: Type.Union([Type.Literal("neighbors"), Type.Literal("temporal")], { description: "Exploration mode: 'neighbors' for graph edges around a memory, 'temporal' for time-based connections." }),
+        memory_id: Type.Optional(Type.String({ description: "Memory node UUID. Required for neighbors mode." })),
+        query: Type.Optional(Type.String({ description: "Search query for temporal mode." })),
+        time_from: Type.Optional(Type.String({ description: "ISO 8601 start time for temporal range filter." })),
+        time_to: Type.Optional(Type.String({ description: "ISO 8601 end time for temporal range filter." })),
+        limit: Type.Optional(Type.Number({ default: 10, description: "Max results to return (default 10).", minimum: 1, maximum: 50 }))
       })
     },
     options: { name: "graph_explore" },
@@ -3364,16 +5970,16 @@ var toolDefinitions = {
       name: "memory_conflicts",
       label: "Memory Conflicts",
       description: "List detected memory conflicts or resolve a specific conflict.",
-      parameters: import_typebox.Type.Object({
-        action: import_typebox.Type.Union([import_typebox.Type.Literal("list"), import_typebox.Type.Literal("resolve")], { description: "Action: 'list' to see conflicts, 'resolve' to resolve one." }),
-        id: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Conflict UUID. Required for resolve action." })),
-        resolution: import_typebox.Type.Optional(import_typebox.Type.Union([
-          import_typebox.Type.Literal("keep_newer"),
-          import_typebox.Type.Literal("keep_older"),
-          import_typebox.Type.Literal("merge"),
-          import_typebox.Type.Literal("dismiss")
+      parameters: Type.Object({
+        action: Type.Union([Type.Literal("list"), Type.Literal("resolve")], { description: "Action: 'list' to see conflicts, 'resolve' to resolve one." }),
+        id: Type.Optional(Type.String({ description: "Conflict UUID. Required for resolve action." })),
+        resolution: Type.Optional(Type.Union([
+          Type.Literal("keep_newer"),
+          Type.Literal("keep_older"),
+          Type.Literal("merge"),
+          Type.Literal("dismiss")
         ], { description: "Resolution strategy. Required for resolve action." })),
-        limit: import_typebox.Type.Optional(import_typebox.Type.Number({ default: 10, description: "Max conflicts to return for list action (default 10).", minimum: 1, maximum: 100 }))
+        limit: Type.Optional(Type.Number({ default: 10, description: "Max conflicts to return for list action (default 10).", minimum: 1, maximum: 100 }))
       })
     },
     options: { name: "memory_conflicts" },
@@ -3407,7 +6013,7 @@ var toolDefinitions = {
       name: "core_memory_read",
       label: "Core Memory Read",
       description: "Read the current core memory block \u2014 the persistent structured identity context always injected into agent sessions. Contains identity, relationships, preferences, current_focus, and custom fields.",
-      parameters: import_typebox.Type.Object({})
+      parameters: Type.Object({})
     },
     options: { name: "core_memory_read" },
     makeExecute: ({ sulcusMem, backendMode, namespace, nativeLoader, isAvailable }) => async (_id, _params) => {
@@ -3431,12 +6037,12 @@ var toolDefinitions = {
       name: "core_memory_update",
       label: "Core Memory Update",
       description: "Update fields in the core memory block. Core memory is a persistent structured identity context always injected into agent sessions. Only provide the fields you want to update.",
-      parameters: import_typebox.Type.Object({
-        identity: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Who the agent is: name, role, and description." })),
-        relationships: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Key people and entities the agent works with." })),
-        preferences: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Agent preferences and communication style." })),
-        current_focus: import_typebox.Type.Optional(import_typebox.Type.String({ description: "What the agent is currently working on (mutable)." })),
-        custom: import_typebox.Type.Optional(import_typebox.Type.String({ description: "JSON string of additional freeform key-value pairs." }))
+      parameters: Type.Object({
+        identity: Type.Optional(Type.String({ description: "Who the agent is: name, role, and description." })),
+        relationships: Type.Optional(Type.String({ description: "Key people and entities the agent works with." })),
+        preferences: Type.Optional(Type.String({ description: "Agent preferences and communication style." })),
+        current_focus: Type.Optional(Type.String({ description: "What the agent is currently working on (mutable)." })),
+        custom: Type.Optional(Type.String({ description: "JSON string of additional freeform key-value pairs." }))
       })
     },
     options: { name: "core_memory_update" },
@@ -3471,11 +6077,11 @@ var toolDefinitions = {
       name: "memory_archive",
       label: "Memory Archive",
       description: "List archived memories or restore specific ones from the archive.",
-      parameters: import_typebox.Type.Object({
-        action: import_typebox.Type.Union([import_typebox.Type.Literal("list"), import_typebox.Type.Literal("restore")], { description: "Action: 'list' to browse archived memories, 'restore' to un-archive specific ones." }),
-        ids: import_typebox.Type.Optional(import_typebox.Type.Array(import_typebox.Type.String(), { description: "Memory UUIDs to restore. Required for restore action." })),
-        limit: import_typebox.Type.Optional(import_typebox.Type.Number({ default: 20, description: "Max archived memories to return for list action (default 20).", minimum: 1, maximum: 100 })),
-        offset: import_typebox.Type.Optional(import_typebox.Type.Number({ default: 0, description: "Pagination offset for list action (default 0).", minimum: 0 }))
+      parameters: Type.Object({
+        action: Type.Union([Type.Literal("list"), Type.Literal("restore")], { description: "Action: 'list' to browse archived memories, 'restore' to un-archive specific ones." }),
+        ids: Type.Optional(Type.Array(Type.String(), { description: "Memory UUIDs to restore. Required for restore action." })),
+        limit: Type.Optional(Type.Number({ default: 20, description: "Max archived memories to return for list action (default 20).", minimum: 1, maximum: 100 })),
+        offset: Type.Optional(Type.Number({ default: 0, description: "Pagination offset for list action (default 0).", minimum: 0 }))
       })
     },
     options: { name: "memory_archive" },
@@ -3507,9 +6113,9 @@ var toolDefinitions = {
       name: "memory_fold",
       label: "Memory Fold",
       description: "Merge multiple related memories into a single consolidated node. Collapses redundant or tightly related memories into one.",
-      parameters: import_typebox.Type.Object({
-        ids: import_typebox.Type.Array(import_typebox.Type.String(), { description: "Array of memory UUIDs to merge (minimum 2).", minItems: 2 }),
-        label: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Optional summary label for the merged memory node." }))
+      parameters: Type.Object({
+        ids: Type.Array(Type.String(), { description: "Array of memory UUIDs to merge (minimum 2).", minItems: 2 }),
+        label: Type.Optional(Type.String({ description: "Optional summary label for the merged memory node." }))
       })
     },
     options: { name: "memory_fold" },
@@ -3531,7 +6137,7 @@ var toolDefinitions = {
       name: "memory_dashboard",
       label: "Memory Dashboard",
       description: "Get a high-level dashboard of memory health, usage statistics, and storage information.",
-      parameters: import_typebox.Type.Object({})
+      parameters: Type.Object({})
     },
     options: { name: "memory_dashboard" },
     makeExecute: ({ sulcusMem, backendMode, namespace, nativeLoader, isAvailable }) => async (_id, _params) => {
@@ -3556,9 +6162,9 @@ var toolDefinitions = {
       name: "episode_recall",
       label: "Episode Recall",
       description: "Search past conversation episodes \u2014 structured session summaries including topic, decisions, files modified, and outcome. Use for questions like 'what did we discuss last time?' or 'when did we work on X?'",
-      parameters: import_typebox.Type.Object({
-        query: import_typebox.Type.String({ description: "Search query \u2014 topic, keyword, date, or question about past sessions." }),
-        limit: import_typebox.Type.Optional(import_typebox.Type.Number({ default: 5, minimum: 1, maximum: 20, description: "Max episodes to return." }))
+      parameters: Type.Object({
+        query: Type.String({ description: "Search query \u2014 topic, keyword, date, or question about past sessions." }),
+        limit: Type.Optional(Type.Number({ default: 5, minimum: 1, maximum: 20, description: "Max episodes to return." }))
       })
     },
     options: { name: "episode_recall" },
@@ -3605,9 +6211,9 @@ ${formatted}` }],
       name: "memory_namespace",
       label: "Memory Namespace",
       description: "Switch the active memory namespace at runtime. Useful for reading from project-specific or shared namespaces, or when serving multiple users. Affects all subsequent memory operations until switched again or the session ends.",
-      parameters: import_typebox.Type.Object({
-        namespace: import_typebox.Type.String({ description: "Target namespace to switch to. Use the base namespace name (e.g. 'ariadne', 'project-alpha')." }),
-        reason: import_typebox.Type.Optional(import_typebox.Type.String({ description: "Why you're switching namespace \u2014 logged for audit trail." }))
+      parameters: Type.Object({
+        namespace: Type.String({ description: "Target namespace to switch to. Use the base namespace name (e.g. 'ariadne', 'project-alpha')." }),
+        reason: Type.Optional(Type.String({ description: "Why you're switching namespace \u2014 logged for audit trail." }))
       })
     },
     options: { name: "memory_namespace" },
@@ -3631,7 +6237,7 @@ All subsequent memory operations will use namespace \`${target}\` until switched
       name: "namespace_list",
       label: "Namespace List",
       description: "List available memory namespaces and their stats (node count, last activity). Useful for multi-user setups or project-scoped memory. Cloud-only.",
-      parameters: import_typebox.Type.Object({})
+      parameters: Type.Object({})
     },
     options: { name: "namespace_list" },
     makeExecute: ({ sulcusMem, backendMode, namespace, nativeLoader, isAvailable }) => async (_id, _params) => {
@@ -3666,8 +6272,8 @@ ${formatted}` }],
       name: "sulcus_setup",
       label: "Sulcus Setup",
       description: "Run the Sulcus setup diagnostic \u2014 checks backend connectivity, configuration status, core memory state, and generates recommended cron job configurations for memory maintenance. Call this once when first setting up Sulcus.",
-      parameters: import_typebox.Type.Object({
-        init_core_memory: import_typebox.Type.Optional(import_typebox.Type.Boolean({ description: "If true and core memory is empty, initialize it with defaults based on the agent's namespace." }))
+      parameters: Type.Object({
+        init_core_memory: Type.Optional(Type.Boolean({ description: "If true and core memory is empty, initialize it with defaults based on the agent's namespace." }))
       })
     },
     options: { name: "sulcus_setup" },
@@ -4254,7 +6860,7 @@ var sulcusPlugin = {
     const dreamMinMemories = pluginConfig?.dreamMinMemories ?? 50;
     const dreamMinHeat = pluginConfig?.dreamConsolidateMinHeat ?? 0.1;
     if (dreamEnabled && isAvailable && sulcusMem instanceof SulcusCloudClient) {
-      let readDreamState2 = function() {
+      let readDreamState = function() {
         try {
           if ((0, import_node_fs.existsSync)(dreamStateFile)) {
             const raw = (0, import_node_fs.readFileSync)(dreamStateFile, "utf-8");
@@ -4267,12 +6873,12 @@ var sulcusPlugin = {
         } catch {
         }
         return { lastDreamMs: 0, lastSessionCount: 0 };
-      }, writeDreamState2 = function(state) {
+      }, writeDreamState = function(state) {
         try {
           (0, import_node_fs.writeFileSync)(dreamStateFile, JSON.stringify(state));
         } catch {
         }
-      }, acquireDreamLock2 = function() {
+      }, acquireDreamLock = function() {
         try {
           if ((0, import_node_fs.existsSync)(dreamLockFile)) {
             const lockAge = Date.now() - (JSON.parse((0, import_node_fs.readFileSync)(dreamLockFile, "utf-8")).ts ?? 0);
@@ -4283,13 +6889,12 @@ var sulcusPlugin = {
         } catch {
           return false;
         }
-      }, releaseDreamLock2 = function() {
+      }, releaseDreamLock = function() {
         try {
           if ((0, import_node_fs.existsSync)(dreamLockFile)) require("node:fs").unlinkSync(dreamLockFile);
         } catch {
         }
       };
-      var readDreamState = readDreamState2, writeDreamState = writeDreamState2, acquireDreamLock = acquireDreamLock2, releaseDreamLock = releaseDreamLock2;
       const stateDir = (0, import_node_path.resolve)(__dirname, ".sulcus-state");
       if (!(0, import_node_fs.existsSync)(stateDir)) (0, import_node_fs.mkdirSync)(stateDir, { recursive: true });
       const dreamStateFile = (0, import_node_path.resolve)(stateDir, "dream-state.json");
@@ -4303,7 +6908,7 @@ var sulcusPlugin = {
       dreamApiOn("agent_end", async () => {
         if (dreamSessionCount % dreamSessionInterval !== 0) return;
         if (dreamSessionCount === 0) return;
-        const state = readDreamState2();
+        const state = readDreamState();
         const elapsed = Date.now() - state.lastDreamMs;
         if (elapsed < dreamMinGapMs) {
           logger.info(`sulcus/dream: gate 2 skip \u2014 ${Math.round(elapsed / 36e5)}h since last dream (need ${Math.round(dreamMinGapMs / 36e5)}h)`);
@@ -4322,18 +6927,18 @@ var sulcusPlugin = {
           logger.warn(`sulcus/dream: gate 3 error \u2014 ${e instanceof Error ? e.message : e}`);
           return;
         }
-        if (!acquireDreamLock2()) {
+        if (!acquireDreamLock()) {
           logger.info("sulcus/dream: lock held \u2014 another consolidation in progress");
           return;
         }
         logger.info(`sulcus/dream: triggering consolidation (minHeat=${dreamMinHeat})`);
         sulcusMem.consolidate(dreamMinHeat).then((result) => {
-          writeDreamState2({ lastDreamMs: Date.now(), lastSessionCount: dreamSessionCount });
+          writeDreamState({ lastDreamMs: Date.now(), lastSessionCount: dreamSessionCount });
           logger.info(`sulcus/dream: consolidation complete \u2014 ${JSON.stringify(result)}`);
         }).catch((e) => {
           logger.warn(`sulcus/dream: consolidation failed \u2014 ${e instanceof Error ? e.message : e}`);
         }).finally(() => {
-          releaseDreamLock2();
+          releaseDreamLock();
         });
       });
       logger.info(`sulcus: dream auto-trigger enabled (every ${dreamSessionInterval} sessions, ${Math.round(dreamMinGapMs / 36e5)}h gap, min ${dreamMinMemories} memories)`);