@massa-ai/tools-api 1.17.0 → 1.19.0

package/dist/index.js

@@ -13461,6 +13461,16 @@ var init_index_manager = __esm(() => {
   globAsync = glob;
 });
 
+// ../../packages/core/dist/services/cache/lru-evict.js
+function evictOldest(cache, maxRetained) {
+  while (cache.size > maxRetained) {
+    const oldest = cache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    cache.delete(oldest);
+  }
+}
+
 // ../../packages/core/dist/services/search/file-filter-cache.js
 class FileFilterCache {
   cache = new Map;
@@ -13529,18 +13539,7 @@ class FileFilterCache {
     return parts.join("|");
   }
   evictOldest() {
-    let oldestKey = null;
-    let oldestTime = Infinity;
-    for (const [key, entry] of this.cache.entries()) {
-      if (entry.createdAt < oldestTime) {
-        oldestTime = entry.createdAt;
-        oldestKey = key;
-      }
-    }
-    if (oldestKey) {
-      this.cache.delete(oldestKey);
-      logger.debug("Evicted oldest filter cache entry", { key: oldestKey });
-    }
+    evictOldest(this.cache, this.MAX_CACHE_SIZE);
   }
   invalidateProject(projectId) {
     let removed = 0;
@@ -110963,7 +110962,7 @@ var init_memory_repository_factory = __esm(() => {
   init_memory_repository_pg();
 });
 
-// ../../packages/core/dist/services/graph/graph-store-pg.js
+// ../../packages/core/dist/services/memory-graph/graph-store-pg.js
 function metadataForEdge(edge) {
   return {
     autoExtracted: edge.autoExtracted ?? false,
@@ -111279,7 +111278,7 @@ var init_graph_store_pg = __esm(() => {
   graphStorePg = GraphStorePg.getInstance();
 });
 
-// ../../packages/core/dist/services/graph/graph-store-factory.js
+// ../../packages/core/dist/services/memory-graph/graph-store-factory.js
 function getGraphStore() {
   if (cachedStore2)
     return cachedStore2;
@@ -122213,16 +122212,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path18 = e.route;
-    if (!path18)
+    const path19 = e.route;
+    if (!path19)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path18;
+    const key = method + " " + path19;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path18,
+      path: path19,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -122233,12 +122232,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path18 = parsed?.path ?? d.name;
-    const key = method + " " + path18;
+    const path19 = parsed?.path ?? d.name;
+    const key = method + " " + path19;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path18, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path19, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -122459,7 +122458,7 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path18 from "path";
+import path19 from "path";
 import fs9 from "fs/promises";
 
 class SymbolGraphService {
@@ -122813,7 +122812,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path18.resolve(root, relativePath) : relativePath;
+    return root ? path19.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -122833,12 +122832,7 @@ class SymbolGraphService {
     return null;
   }
   evictOldestProjectRoot() {
-    while (this.projectRootCache.size >= this.PROJECT_ROOT_CACHE_MAX_ENTRIES) {
-      const oldest = this.projectRootCache.keys().next().value;
-      if (oldest === undefined)
-        break;
-      this.projectRootCache.delete(oldest);
-    }
+    evictOldest(this.projectRootCache, this.PROJECT_ROOT_CACHE_MAX_ENTRIES - 1);
   }
   clearProjectRoot(projectId) {
     this.projectRootCache.delete(projectId);
@@ -123130,7 +123124,7 @@ var init_memory_service = __esm(() => {
   init_decay();
 });
 
-// ../../packages/core/dist/services/graph/relation-extractor.js
+// ../../packages/core/dist/services/memory-graph/relation-extractor.js
 class RelationExtractor {
   graphStore;
   constructor(graphStore) {
@@ -123368,7 +123362,7 @@ var init_relation_extractor = __esm(() => {
   ];
 });
 
-// ../../packages/core/dist/services/graph/graph-queries.js
+// ../../packages/core/dist/services/memory-graph/graph-queries.js
 class GraphQueries {
   graphStore;
   constructor(graphStore) {
@@ -123588,7 +123582,7 @@ var init_graph_queries = __esm(() => {
   };
 });
 
-// ../../packages/core/dist/services/graph/memory-graph.service.js
+// ../../packages/core/dist/services/memory-graph/memory-graph.service.js
 class MemoryGraphService {
   static instance = null;
   store;
@@ -126808,31 +126802,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path21) => {
+    const walk = (fqn, path22) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path21.join("\u2192");
+      const key = path22.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path21.length > 1)
-          chains.push(path21.map((n2) => this.fqnToName(n2)).join(" \u2192 "));
+        if (path22.length > 1)
+          chains.push(path22.map((n2) => this.fqnToName(n2)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path21.includes(child)) {
-          const cycled = [...path21, `${this.fqnToName(child)}\u21BA`];
+        if (path22.includes(child)) {
+          const cycled = [...path22, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n2) => n2).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path21, child]);
+        walk(child, [...path22, child]);
       }
     };
     for (const seed of seeds) {
@@ -129976,7 +129970,7 @@ var init_l1_memory_cache = __esm(() => {
 // ../../packages/core/dist/services/health/local-health-checker.js
 import fs12 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path22 from "path";
+import path24 from "path";
 
 class LocalHealthChecker {
   ollamaBaseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
@@ -130011,7 +130005,7 @@ class LocalHealthChecker {
     try {
       if (!existsSync3(this.dataDir))
         await fs12.mkdir(this.dataDir, { recursive: true });
-      const probe2 = path22.join(this.dataDir, ".health-check-test");
+      const probe2 = path24.join(this.dataDir, ".health-check-test");
       await fs12.writeFile(probe2, "ok");
       await fs12.unlink(probe2);
       return { available: true, latency: Date.now() - start, details: { path: this.dataDir, writable: true } };
@@ -131925,7 +131919,7 @@ var init_scheduler2 = __esm(() => {
 // ../../packages/core/dist/services/pricing/models-dev-client.js
 import fs13 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path23 from "path";
+import path25 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -131945,7 +131939,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config.get("dataDir");
-      return path23.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path25.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -131980,7 +131974,7 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path23.dirname(cachePath);
+        const dir = path25.dirname(cachePath);
         await fs13.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
@@ -137871,33 +137865,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path24) {
-        if (!path24)
-          return path24;
+      function remove_dot_segments(path26) {
+        if (!path26)
+          return path26;
         var output = "";
-        while (path24.length > 0) {
-          if (path24 === "." || path24 === "..") {
-            path24 = "";
+        while (path26.length > 0) {
+          if (path26 === "." || path26 === "..") {
+            path26 = "";
             break;
           }
-          var twochars = path24.substring(0, 2);
-          var threechars = path24.substring(0, 3);
-          var fourchars = path24.substring(0, 4);
+          var twochars = path26.substring(0, 2);
+          var threechars = path26.substring(0, 3);
+          var fourchars = path26.substring(0, 4);
           if (threechars === "../") {
-            path24 = path24.substring(3);
+            path26 = path26.substring(3);
           } else if (twochars === "./") {
-            path24 = path24.substring(2);
+            path26 = path26.substring(2);
           } else if (threechars === "/./") {
-            path24 = "/" + path24.substring(3);
-          } else if (twochars === "/." && path24.length === 2) {
-            path24 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path24.length === 3) {
-            path24 = "/" + path24.substring(4);
+            path26 = "/" + path26.substring(3);
+          } else if (twochars === "/." && path26.length === 2) {
+            path26 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path26.length === 3) {
+            path26 = "/" + path26.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path24.match(/(\/?([^\/]*))/)[0];
+            var segment = path26.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path24 = path24.substring(segment.length);
+            path26 = path26.substring(segment.length);
           }
         }
         return output;
@@ -149967,21 +149961,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path24, out) {
+function walk(val, path26, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path24, content: `**${path24}** = _[]_` });
+      out.push({ path: path26, content: `**${path26}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path24}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path26}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path24, content: `**${path24}**
+    out.push({ path: path26, content: `**${path26}**
 
 ${items}` });
     return;
@@ -149989,16 +149983,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path24, content: `**${path24}** = _{}_` });
+      out.push({ path: path26, content: `**${path26}** = _{}_` });
       return;
     }
     for (const [k2, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k2) ? k2 : JSON.stringify(k2);
-      walk(v, `${path24}.${safeKey}`, out);
+      walk(v, `${path26}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path24, content: `**${path24}** = \`${String(val)}\`` });
+  out.push({ path: path26, content: `**${path26}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -150264,12 +150258,7 @@ class WebController {
       markIndexed: (key, ts) => {
         this.cache.delete(key);
         this.cache.set(key, ts);
-        while (this.cache.size > WEB_CACHE_MAX_ENTRIES) {
-          const oldest = this.cache.keys().next().value;
-          if (oldest === undefined)
-            break;
-          this.cache.delete(oldest);
-        }
+        evictOldest(this.cache, WEB_CACHE_MAX_ENTRIES);
       }
     };
   }
@@ -151103,70 +151092,199 @@ class TypeBoxError extends Error {
     super(message);
   }
 }
+
+// ../../node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
+var TransformKind = Symbol.for("TypeBox.Transform");
+var ReadonlyKind = Symbol.for("TypeBox.Readonly");
+var OptionalKind = Symbol.for("TypeBox.Optional");
+var Hint = Symbol.for("TypeBox.Hint");
+var Kind = 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 IsAsyncIterator3(value) {
+  return IsKindOf(value, "AsyncIterator");
+}
+function IsBigInt3(value) {
+  return IsKindOf(value, "BigInt");
+}
+function IsBoolean3(value) {
+  return IsKindOf(value, "Boolean");
+}
+function IsComputed(value) {
+  return IsKindOf(value, "Computed");
+}
+function IsConstructor(value) {
+  return IsKindOf(value, "Constructor");
+}
+function IsDate3(value) {
+  return IsKindOf(value, "Date");
+}
+function IsFunction3(value) {
+  return IsKindOf(value, "Function");
+}
+function IsInteger2(value) {
+  return IsKindOf(value, "Integer");
+}
+function IsIntersect(value) {
+  return IsKindOf(value, "Intersect");
+}
+function IsIterator3(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 IsNull3(value) {
+  return IsKindOf(value, "Null");
+}
+function IsNumber3(value) {
+  return IsKindOf(value, "Number");
+}
+function IsObject3(value) {
+  return IsKindOf(value, "Object");
+}
+function IsPromise2(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 IsString3(value) {
+  return IsKindOf(value, "String");
+}
+function IsSymbol3(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 IsUint8Array3(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) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsComputed(value) || IsConstructor(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect(value) || IsIterator3(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull3(value) || IsNumber3(value) || IsObject3(value) || IsPromise2(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined3(value) || IsUnion(value) || IsUint8Array3(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value);
+}
 // ../../node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
 var exports_type = {};
 __export(exports_type, {
   TypeGuardUnknownTypeError: () => TypeGuardUnknownTypeError,
-  IsVoid: () => IsVoid,
-  IsUnsafe: () => IsUnsafe,
-  IsUnknown: () => IsUnknown,
+  IsVoid: () => IsVoid2,
+  IsUnsafe: () => IsUnsafe2,
+  IsUnknown: () => IsUnknown2,
   IsUnionLiteral: () => IsUnionLiteral,
-  IsUnion: () => IsUnion,
-  IsUndefined: () => IsUndefined3,
-  IsUint8Array: () => IsUint8Array3,
-  IsTuple: () => IsTuple,
-  IsTransform: () => IsTransform,
-  IsThis: () => IsThis,
-  IsTemplateLiteral: () => IsTemplateLiteral,
-  IsSymbol: () => IsSymbol3,
-  IsString: () => IsString3,
-  IsSchema: () => IsSchema,
-  IsRegExp: () => IsRegExp2,
-  IsRef: () => IsRef,
+  IsUnion: () => IsUnion2,
+  IsUndefined: () => IsUndefined4,
+  IsUint8Array: () => IsUint8Array4,
+  IsTuple: () => IsTuple2,
+  IsTransform: () => IsTransform2,
+  IsThis: () => IsThis2,
+  IsTemplateLiteral: () => IsTemplateLiteral2,
+  IsSymbol: () => IsSymbol4,
+  IsString: () => IsString4,
+  IsSchema: () => IsSchema2,
+  IsRegExp: () => IsRegExp3,
+  IsRef: () => IsRef2,
   IsRecursive: () => IsRecursive,
-  IsRecord: () => IsRecord,
-  IsReadonly: () => IsReadonly,
+  IsRecord: () => IsRecord2,
+  IsReadonly: () => IsReadonly2,
   IsProperties: () => IsProperties,
-  IsPromise: () => IsPromise2,
-  IsOptional: () => IsOptional,
-  IsObject: () => IsObject3,
-  IsNumber: () => IsNumber3,
-  IsNull: () => IsNull3,
-  IsNot: () => IsNot,
-  IsNever: () => IsNever,
-  IsMappedResult: () => IsMappedResult,
-  IsMappedKey: () => IsMappedKey,
-  IsLiteralValue: () => IsLiteralValue,
+  IsPromise: () => IsPromise3,
+  IsOptional: () => IsOptional2,
+  IsObject: () => IsObject4,
+  IsNumber: () => IsNumber4,
+  IsNull: () => IsNull4,
+  IsNot: () => IsNot2,
+  IsNever: () => IsNever2,
+  IsMappedResult: () => IsMappedResult2,
+  IsMappedKey: () => IsMappedKey2,
+  IsLiteralValue: () => IsLiteralValue2,
   IsLiteralString: () => IsLiteralString,
   IsLiteralNumber: () => IsLiteralNumber,
   IsLiteralBoolean: () => IsLiteralBoolean,
-  IsLiteral: () => IsLiteral,
-  IsKindOf: () => IsKindOf,
-  IsKind: () => IsKind,
-  IsIterator: () => IsIterator3,
-  IsIntersect: () => IsIntersect,
-  IsInteger: () => IsInteger2,
+  IsLiteral: () => IsLiteral2,
+  IsKindOf: () => IsKindOf2,
+  IsKind: () => IsKind2,
+  IsIterator: () => IsIterator4,
+  IsIntersect: () => IsIntersect2,
+  IsInteger: () => IsInteger3,
   IsImport: () => IsImport,
-  IsFunction: () => IsFunction3,
-  IsDate: () => IsDate3,
-  IsConstructor: () => IsConstructor,
-  IsComputed: () => IsComputed,
-  IsBoolean: () => IsBoolean3,
-  IsBigInt: () => IsBigInt3,
-  IsAsyncIterator: () => IsAsyncIterator3,
-  IsArray: () => IsArray3,
-  IsArgument: () => IsArgument,
-  IsAny: () => IsAny
+  IsFunction: () => IsFunction4,
+  IsDate: () => IsDate4,
+  IsConstructor: () => IsConstructor2,
+  IsComputed: () => IsComputed2,
+  IsBoolean: () => IsBoolean4,
+  IsBigInt: () => IsBigInt4,
+  IsAsyncIterator: () => IsAsyncIterator4,
+  IsArray: () => IsArray4,
+  IsArgument: () => IsArgument2,
+  IsAny: () => IsAny2
 });
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
-var TransformKind = Symbol.for("TypeBox.Transform");
-var ReadonlyKind = Symbol.for("TypeBox.Readonly");
-var OptionalKind = Symbol.for("TypeBox.Optional");
-var Hint = Symbol.for("TypeBox.Hint");
-var Kind = Symbol.for("TypeBox.Kind");
-
-// ../../node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
 class TypeGuardUnknownTypeError extends TypeBoxError {
 }
 var KnownTypes = [
@@ -151226,7 +151344,7 @@ function IsControlCharacterFree(value) {
   return true;
 }
 function IsAdditionalProperties(value) {
-  return IsOptionalBoolean(value) || IsSchema(value);
+  return IsOptionalBoolean(value) || IsSchema2(value);
 }
 function IsOptionalBigInt(value) {
   return IsUndefined(value) || IsBigInt(value);
@@ -151247,160 +151365,160 @@ function IsOptionalFormat(value) {
   return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value);
 }
 function IsOptionalSchema(value) {
-  return IsUndefined(value) || IsSchema(value);
+  return IsUndefined(value) || IsSchema2(value);
 }
-function IsReadonly(value) {
+function IsReadonly2(value) {
   return IsObject(value) && value[ReadonlyKind] === "Readonly";
 }
-function IsOptional(value) {
+function IsOptional2(value) {
   return IsObject(value) && value[OptionalKind] === "Optional";
 }
-function IsAny(value) {
-  return IsKindOf(value, "Any") && IsOptionalString(value.$id);
+function IsAny2(value) {
+  return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
 }
-function IsArgument(value) {
-  return IsKindOf(value, "Argument") && IsNumber(value.index);
+function IsArgument2(value) {
+  return IsKindOf2(value, "Argument") && IsNumber(value.index);
 }
-function IsArray3(value) {
-  return IsKindOf(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
+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 IsKindOf(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema(value.items);
+function IsAsyncIterator4(value) {
+  return IsKindOf2(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
 }
-function IsBigInt3(value) {
-  return IsKindOf(value, "BigInt") && value.type === "bigint" && IsOptionalString(value.$id) && IsOptionalBigInt(value.exclusiveMaximum) && IsOptionalBigInt(value.exclusiveMinimum) && IsOptionalBigInt(value.maximum) && IsOptionalBigInt(value.minimum) && IsOptionalBigInt(value.multipleOf);
+function IsBigInt4(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 IsKindOf(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
+function IsBoolean4(value) {
+  return IsKindOf2(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
 }
-function IsComputed(value) {
-  return IsKindOf(value, "Computed") && IsString(value.target) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema(schema));
+function IsComputed2(value) {
+  return IsKindOf2(value, "Computed") && IsString(value.target) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema));
 }
-function IsConstructor(value) {
-  return IsKindOf(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema(schema)) && IsSchema(value.returns);
+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 IsKindOf(value, "Date") && value.type === "Date" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximumTimestamp) && IsOptionalNumber(value.exclusiveMinimumTimestamp) && IsOptionalNumber(value.maximumTimestamp) && IsOptionalNumber(value.minimumTimestamp) && IsOptionalNumber(value.multipleOfTimestamp);
+function IsDate4(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 IsKindOf(value, "Function") && value.type === "Function" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema(schema)) && IsSchema(value.returns);
+function IsFunction4(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 IsKindOf(value, "Import") && HasPropertyKey(value, "$defs") && IsObject(value.$defs) && IsProperties(value.$defs) && HasPropertyKey(value, "$ref") && IsString(value.$ref) && value.$ref in value.$defs;
+  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 IsKindOf(value, "Integer") && value.type === "integer" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+function IsInteger3(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) && IsSchema(schema));
+  return IsObject(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema2(schema));
 }
-function IsIntersect(value) {
-  return IsKindOf(value, "Intersect") && (IsString(value.type) && value.type !== "object" ? false : true) && IsArray(value.allOf) && value.allOf.every((schema) => IsSchema(schema) && !IsTransform(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
+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 IsKindOf(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema(value.items);
+function IsIterator4(value) {
+  return IsKindOf2(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
 }
-function IsKindOf(value, kind) {
+function IsKindOf2(value, kind) {
   return IsObject(value) && Kind in value && value[Kind] === kind;
 }
 function IsLiteralString(value) {
-  return IsLiteral(value) && IsString(value.const);
+  return IsLiteral2(value) && IsString(value.const);
 }
 function IsLiteralNumber(value) {
-  return IsLiteral(value) && IsNumber(value.const);
+  return IsLiteral2(value) && IsNumber(value.const);
 }
 function IsLiteralBoolean(value) {
-  return IsLiteral(value) && IsBoolean(value.const);
+  return IsLiteral2(value) && IsBoolean(value.const);
 }
-function IsLiteral(value) {
-  return IsKindOf(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue(value.const);
+function IsLiteral2(value) {
+  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue2(value.const);
 }
-function IsLiteralValue(value) {
+function IsLiteralValue2(value) {
   return IsBoolean(value) || IsNumber(value) || IsString(value);
 }
-function IsMappedKey(value) {
-  return IsKindOf(value, "MappedKey") && IsArray(value.keys) && value.keys.every((key) => IsNumber(key) || IsString(key));
+function IsMappedKey2(value) {
+  return IsKindOf2(value, "MappedKey") && IsArray(value.keys) && value.keys.every((key) => IsNumber(key) || IsString(key));
 }
-function IsMappedResult(value) {
-  return IsKindOf(value, "MappedResult") && IsProperties(value.properties);
+function IsMappedResult2(value) {
+  return IsKindOf2(value, "MappedResult") && IsProperties(value.properties);
 }
-function IsNever(value) {
-  return IsKindOf(value, "Never") && IsObject(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
+function IsNever2(value) {
+  return IsKindOf2(value, "Never") && IsObject(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
 }
-function IsNot(value) {
-  return IsKindOf(value, "Not") && IsSchema(value.not);
+function IsNot2(value) {
+  return IsKindOf2(value, "Not") && IsSchema2(value.not);
 }
-function IsNull3(value) {
-  return IsKindOf(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
+function IsNull4(value) {
+  return IsKindOf2(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
 }
-function IsNumber3(value) {
-  return IsKindOf(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+function IsNumber4(value) {
+  return IsKindOf2(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
 }
-function IsObject3(value) {
-  return IsKindOf(value, "Object") && value.type === "object" && IsOptionalString(value.$id) && IsProperties(value.properties) && IsAdditionalProperties(value.additionalProperties) && IsOptionalNumber(value.minProperties) && IsOptionalNumber(value.maxProperties);
+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 IsKindOf(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema(value.item);
+function IsPromise3(value) {
+  return IsKindOf2(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema2(value.item);
 }
-function IsRecord(value) {
-  return IsKindOf(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject(value.patternProperties) && ((schema) => {
+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) && IsSchema(schema.patternProperties[keys[0]]);
+    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 IsRef(value) {
-  return IsKindOf(value, "Ref") && IsOptionalString(value.$id) && IsString(value.$ref);
+function IsRef2(value) {
+  return IsKindOf2(value, "Ref") && IsOptionalString(value.$id) && IsString(value.$ref);
 }
-function IsRegExp2(value) {
-  return IsKindOf(value, "RegExp") && IsOptionalString(value.$id) && IsString(value.source) && IsString(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
+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 IsKindOf(value, "String") && value.type === "string" && IsOptionalString(value.$id) && IsOptionalNumber(value.minLength) && IsOptionalNumber(value.maxLength) && IsOptionalPattern(value.pattern) && IsOptionalFormat(value.format);
+function IsString4(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 IsKindOf(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
+function IsSymbol4(value) {
+  return IsKindOf2(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
 }
-function IsTemplateLiteral(value) {
-  return IsKindOf(value, "TemplateLiteral") && value.type === "string" && IsString(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
+function IsTemplateLiteral2(value) {
+  return IsKindOf2(value, "TemplateLiteral") && value.type === "string" && IsString(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
 }
-function IsThis(value) {
-  return IsKindOf(value, "This") && IsOptionalString(value.$id) && IsString(value.$ref);
+function IsThis2(value) {
+  return IsKindOf2(value, "This") && IsOptionalString(value.$id) && IsString(value.$ref);
 }
-function IsTransform(value) {
+function IsTransform2(value) {
   return IsObject(value) && TransformKind in value;
 }
-function IsTuple(value) {
-  return IsKindOf(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber(value.minItems) && IsNumber(value.maxItems) && value.minItems === value.maxItems && (IsUndefined(value.items) && IsUndefined(value.additionalItems) && value.minItems === 0 || IsArray(value.items) && value.items.every((schema) => IsSchema(schema)));
+function IsTuple2(value) {
+  return IsKindOf2(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber(value.minItems) && IsNumber(value.maxItems) && value.minItems === value.maxItems && (IsUndefined(value.items) && IsUndefined(value.additionalItems) && value.minItems === 0 || IsArray(value.items) && value.items.every((schema) => IsSchema2(schema)));
 }
-function IsUndefined3(value) {
-  return IsKindOf(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
+function IsUndefined4(value) {
+  return IsKindOf2(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
 }
 function IsUnionLiteral(value) {
-  return IsUnion(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
+  return IsUnion2(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
 }
-function IsUnion(value) {
-  return IsKindOf(value, "Union") && IsOptionalString(value.$id) && IsObject(value) && IsArray(value.anyOf) && value.anyOf.every((schema) => IsSchema(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 IsKindOf(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
+function IsUint8Array4(value) {
+  return IsKindOf2(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
 }
-function IsUnknown(value) {
-  return IsKindOf(value, "Unknown") && IsOptionalString(value.$id);
+function IsUnknown2(value) {
+  return IsKindOf2(value, "Unknown") && IsOptionalString(value.$id);
 }
-function IsUnsafe(value) {
-  return IsKindOf(value, "Unsafe");
+function IsUnsafe2(value) {
+  return IsKindOf2(value, "Unsafe");
 }
-function IsVoid(value) {
-  return IsKindOf(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
+function IsVoid2(value) {
+  return IsKindOf2(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
 }
-function IsKind(value) {
+function IsKind2(value) {
   return IsObject(value) && Kind in value && IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
 }
-function IsSchema(value) {
-  return IsObject(value) && (IsAny(value) || IsArgument(value) || IsArray3(value) || IsBoolean3(value) || IsBigInt3(value) || IsAsyncIterator3(value) || IsComputed(value) || IsConstructor(value) || IsDate3(value) || IsFunction3(value) || IsInteger2(value) || IsIntersect(value) || IsIterator3(value) || IsLiteral(value) || IsMappedKey(value) || IsMappedResult(value) || IsNever(value) || IsNot(value) || IsNull3(value) || IsNumber3(value) || IsObject3(value) || IsPromise2(value) || IsRecord(value) || IsRef(value) || IsRegExp2(value) || IsString3(value) || IsSymbol3(value) || IsTemplateLiteral(value) || IsThis(value) || IsTuple(value) || IsUndefined3(value) || IsUnion(value) || IsUint8Array3(value) || IsUnknown(value) || IsUnsafe(value) || IsVoid(value) || IsKind(value));
+function IsSchema2(value) {
+  return IsObject(value) && (IsAny2(value) || IsArgument2(value) || IsArray4(value) || IsBoolean4(value) || IsBigInt4(value) || IsAsyncIterator4(value) || IsComputed2(value) || IsConstructor2(value) || IsDate4(value) || IsFunction4(value) || IsInteger3(value) || IsIntersect2(value) || IsIterator4(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull4(value) || IsNumber4(value) || IsObject4(value) || IsPromise3(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString4(value) || IsSymbol4(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined4(value) || IsUnion2(value) || IsUint8Array4(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value));
 }
 // ../../node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
 var PatternBoolean = "(true|false)";
@@ -151557,143 +151675,12 @@ function UnionCreate(T2, options) {
   return CreateType({ [Kind]: "Union", anyOf: T2 }, options);
 }
 
-// ../../node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
-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");
-}
-function IsArgument2(value) {
-  return IsKindOf2(value, "Argument");
-}
-function IsArray4(value) {
-  return IsKindOf2(value, "Array");
-}
-function IsAsyncIterator4(value) {
-  return IsKindOf2(value, "AsyncIterator");
-}
-function IsBigInt4(value) {
-  return IsKindOf2(value, "BigInt");
-}
-function IsBoolean4(value) {
-  return IsKindOf2(value, "Boolean");
-}
-function IsComputed2(value) {
-  return IsKindOf2(value, "Computed");
-}
-function IsConstructor2(value) {
-  return IsKindOf2(value, "Constructor");
-}
-function IsDate4(value) {
-  return IsKindOf2(value, "Date");
-}
-function IsFunction4(value) {
-  return IsKindOf2(value, "Function");
-}
-function IsInteger3(value) {
-  return IsKindOf2(value, "Integer");
-}
-function IsIntersect2(value) {
-  return IsKindOf2(value, "Intersect");
-}
-function IsIterator4(value) {
-  return IsKindOf2(value, "Iterator");
-}
-function IsKindOf2(value, kind) {
-  return IsObject(value) && Kind in value && value[Kind] === kind;
-}
-function IsLiteralValue2(value) {
-  return IsBoolean(value) || IsNumber(value) || IsString(value);
-}
-function IsLiteral2(value) {
-  return IsKindOf2(value, "Literal");
-}
-function IsMappedKey2(value) {
-  return IsKindOf2(value, "MappedKey");
-}
-function IsMappedResult2(value) {
-  return IsKindOf2(value, "MappedResult");
-}
-function IsNever2(value) {
-  return IsKindOf2(value, "Never");
-}
-function IsNot2(value) {
-  return IsKindOf2(value, "Not");
-}
-function IsNull4(value) {
-  return IsKindOf2(value, "Null");
-}
-function IsNumber4(value) {
-  return IsKindOf2(value, "Number");
-}
-function IsObject4(value) {
-  return IsKindOf2(value, "Object");
-}
-function IsPromise3(value) {
-  return IsKindOf2(value, "Promise");
-}
-function IsRecord2(value) {
-  return IsKindOf2(value, "Record");
-}
-function IsRef2(value) {
-  return IsKindOf2(value, "Ref");
-}
-function IsRegExp3(value) {
-  return IsKindOf2(value, "RegExp");
-}
-function IsString4(value) {
-  return IsKindOf2(value, "String");
-}
-function IsSymbol4(value) {
-  return IsKindOf2(value, "Symbol");
-}
-function IsTemplateLiteral2(value) {
-  return IsKindOf2(value, "TemplateLiteral");
-}
-function IsThis2(value) {
-  return IsKindOf2(value, "This");
-}
-function IsTransform2(value) {
-  return IsObject(value) && TransformKind in value;
-}
-function IsTuple2(value) {
-  return IsKindOf2(value, "Tuple");
-}
-function IsUndefined4(value) {
-  return IsKindOf2(value, "Undefined");
-}
-function IsUnion2(value) {
-  return IsKindOf2(value, "Union");
-}
-function IsUint8Array4(value) {
-  return IsKindOf2(value, "Uint8Array");
-}
-function IsUnknown2(value) {
-  return IsKindOf2(value, "Unknown");
-}
-function IsUnsafe2(value) {
-  return IsKindOf2(value, "Unsafe");
-}
-function IsVoid2(value) {
-  return IsKindOf2(value, "Void");
-}
-function IsKind2(value) {
-  return IsObject(value) && Kind in value && IsString(value[Kind]);
-}
-function IsSchema2(value) {
-  return IsAny2(value) || IsArgument2(value) || IsArray4(value) || IsBoolean4(value) || IsBigInt4(value) || IsAsyncIterator4(value) || IsComputed2(value) || IsConstructor2(value) || IsDate4(value) || IsFunction4(value) || IsInteger3(value) || IsIntersect2(value) || IsIterator4(value) || IsLiteral2(value) || IsMappedKey2(value) || IsMappedResult2(value) || IsNever2(value) || IsNot2(value) || IsNull4(value) || IsNumber4(value) || IsObject4(value) || IsPromise3(value) || IsRecord2(value) || IsRef2(value) || IsRegExp3(value) || IsString4(value) || IsSymbol4(value) || IsTemplateLiteral2(value) || IsThis2(value) || IsTuple2(value) || IsUndefined4(value) || IsUnion2(value) || IsUint8Array4(value) || IsUnknown2(value) || IsUnsafe2(value) || IsVoid2(value) || IsKind2(value);
-}
-
 // ../../node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.mjs
 function IsUnionOptional(types) {
-  return types.some((type) => IsOptional2(type));
+  return types.some((type) => IsOptional(type));
 }
 function RemoveOptionalFromRest(types) {
-  return types.map((left) => IsOptional2(left) ? RemoveOptionalFromType(left) : left);
+  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
 }
 function RemoveOptionalFromType(T2) {
   return Discard(T2, [OptionalKind]);
@@ -151962,7 +151949,7 @@ function Escape(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function Visit2(schema, acc) {
-  return IsTemplateLiteral2(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion2(schema) ? `(${schema.anyOf.map((schema2) => Visit2(schema2, acc)).join("|")})` : IsNumber4(schema) ? `${acc}${PatternNumber}` : IsInteger3(schema) ? `${acc}${PatternNumber}` : IsBigInt4(schema) ? `${acc}${PatternNumber}` : IsString4(schema) ? `${acc}${PatternString}` : IsLiteral2(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean4(schema) ? `${acc}${PatternBoolean}` : (() => {
+  return IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit2(schema2, acc)).join("|")})` : IsNumber3(schema) ? `${acc}${PatternNumber}` : IsInteger2(schema) ? `${acc}${PatternNumber}` : IsBigInt3(schema) ? `${acc}${PatternNumber}` : IsString3(schema) ? `${acc}${PatternString}` : IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean3(schema) ? `${acc}${PatternBoolean}` : (() => {
     throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`);
   })();
 }
@@ -151998,7 +151985,7 @@ function FromLiteral(literalValue) {
   return [literalValue.toString()];
 }
 function IndexPropertyKeys(type) {
-  return [...new Set(IsTemplateLiteral2(type) ? FromTemplateLiteral(type) : IsUnion2(type) ? FromUnion2(type.anyOf) : IsLiteral2(type) ? FromLiteral(type.const) : IsNumber4(type) ? ["[number]"] : IsInteger3(type) ? ["[number]"] : [])];
+  return [...new Set(IsTemplateLiteral(type) ? FromTemplateLiteral(type) : IsUnion(type) ? FromUnion2(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : IsNumber3(type) ? ["[number]"] : IsInteger2(type) ? ["[number]"] : [])];
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.mjs
@@ -152022,13 +152009,13 @@ function FromRest(types, key) {
   return types.map((type) => IndexFromPropertyKey(type, key));
 }
 function FromIntersectRest(types) {
-  return types.filter((type) => !IsNever2(type));
+  return types.filter((type) => !IsNever(type));
 }
 function FromIntersect(types, key) {
   return IntersectEvaluated(FromIntersectRest(FromRest(types, key)));
 }
 function FromUnionRest(types) {
-  return types.some((L) => IsNever2(L)) ? [] : types;
+  return types.some((L) => IsNever(L)) ? [] : types;
 }
 function FromUnion3(types, key) {
   return UnionEvaluated(FromUnionRest(FromRest(types, key)));
@@ -152043,7 +152030,7 @@ function FromProperty(properties, propertyKey) {
   return propertyKey in properties ? properties[propertyKey] : Never();
 }
 function IndexFromPropertyKey(type, propertyKey) {
-  return IsIntersect2(type) ? FromIntersect(type.allOf, propertyKey) : IsUnion2(type) ? FromUnion3(type.anyOf, propertyKey) : IsTuple2(type) ? FromTuple(type.items ?? [], propertyKey) : IsArray4(type) ? FromArray(type.items, propertyKey) : IsObject4(type) ? FromProperty(type.properties, propertyKey) : Never();
+  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));
@@ -152052,17 +152039,17 @@ function FromSchema(type, propertyKeys) {
   return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
 }
 function Index(type, key, options) {
-  if (IsRef2(type) || IsRef2(key)) {
+  if (IsRef(type) || IsRef(key)) {
     const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
-    if (!IsSchema2(type) || !IsSchema2(key))
+    if (!IsSchema(type) || !IsSchema(key))
       throw new TypeBoxError(error);
     return Computed("Index", [type, key]);
   }
-  if (IsMappedResult2(key))
+  if (IsMappedResult(key))
     return IndexFromMappedResult(type, key, options);
-  if (IsMappedKey2(key))
+  if (IsMappedKey(key))
     return IndexFromMappedKey(type, key, options);
-  return CreateType(IsSchema2(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(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
@@ -152089,7 +152076,7 @@ function Iterator(items, options) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/object/object.mjs
 function RequiredArray(properties) {
-  return globalThis.Object.keys(properties).filter((key) => !IsOptional2(properties[key]));
+  return globalThis.Object.keys(properties).filter((key) => !IsOptional(properties[key]));
 }
 function _Object(properties, options) {
   const required = RequiredArray(properties);
@@ -152115,7 +152102,7 @@ function ReadonlyWithFlag(schema, F) {
 }
 function Readonly(schema, enable) {
   const F = enable ?? true;
-  return IsMappedResult2(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+  return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/readonly/readonly-from-mapped-result.mjs
@@ -152169,7 +152156,7 @@ function FromProperties3(K, T2) {
 }
 function FromSchemaType(K, T2) {
   const options = { ...T2 };
-  return IsOptional2(T2) ? Optional(FromSchemaType(K, Discard(T2, [OptionalKind]))) : IsReadonly2(T2) ? Readonly(FromSchemaType(K, Discard(T2, [ReadonlyKind]))) : IsMappedResult2(T2) ? FromMappedResult3(K, T2.properties) : IsMappedKey2(T2) ? FromMappedKey(K, T2.keys) : IsConstructor2(T2) ? Constructor(FromRest2(K, T2.parameters), FromSchemaType(K, T2.returns), options) : IsFunction4(T2) ? Function2(FromRest2(K, T2.parameters), FromSchemaType(K, T2.returns), options) : IsAsyncIterator4(T2) ? AsyncIterator(FromSchemaType(K, T2.items), options) : IsIterator4(T2) ? Iterator(FromSchemaType(K, T2.items), options) : IsIntersect2(T2) ? Intersect(FromRest2(K, T2.allOf), options) : IsUnion2(T2) ? Union(FromRest2(K, T2.anyOf), options) : IsTuple2(T2) ? Tuple(FromRest2(K, T2.items ?? []), options) : IsObject4(T2) ? Object2(FromProperties3(K, T2.properties), options) : IsArray4(T2) ? Array2(FromSchemaType(K, T2.items), options) : IsPromise3(T2) ? Promise2(FromSchemaType(K, T2.item), options) : T2;
+  return IsOptional(T2) ? Optional(FromSchemaType(K, Discard(T2, [OptionalKind]))) : IsReadonly(T2) ? Readonly(FromSchemaType(K, Discard(T2, [ReadonlyKind]))) : IsMappedResult(T2) ? FromMappedResult3(K, T2.properties) : IsMappedKey(T2) ? FromMappedKey(K, T2.keys) : IsConstructor(T2) ? Constructor(FromRest2(K, T2.parameters), FromSchemaType(K, T2.returns), options) : IsFunction3(T2) ? Function2(FromRest2(K, T2.parameters), FromSchemaType(K, T2.returns), options) : IsAsyncIterator3(T2) ? AsyncIterator(FromSchemaType(K, T2.items), options) : IsIterator3(T2) ? Iterator(FromSchemaType(K, T2.items), options) : IsIntersect(T2) ? Intersect(FromRest2(K, T2.allOf), options) : IsUnion(T2) ? Union(FromRest2(K, T2.anyOf), options) : IsTuple(T2) ? Tuple(FromRest2(K, T2.items ?? []), options) : IsObject3(T2) ? Object2(FromProperties3(K, T2.properties), options) : IsArray3(T2) ? Array2(FromSchemaType(K, T2.items), options) : IsPromise2(T2) ? Promise2(FromSchemaType(K, T2.item), options) : T2;
 }
 function MappedFunctionReturnType(K, T2) {
   const Acc = {};
@@ -152178,7 +152165,7 @@ function MappedFunctionReturnType(K, T2) {
   return Acc;
 }
 function Mapped(key, map3, options) {
-  const K = IsSchema2(key) ? IndexPropertyKeys(key) : key;
+  const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
   const RT = map3({ [Kind]: "MappedKey", keys: K });
   const R = MappedFunctionReturnType(K, RT);
   return Object2(R, options);
@@ -152196,7 +152183,7 @@ function OptionalWithFlag(schema, F) {
 }
 function Optional(schema, enable) {
   const F = enable ?? true;
-  return IsMappedResult2(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+  return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.mjs
@@ -152216,20 +152203,20 @@ function OptionalFromMappedResult(R, F) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-create.mjs
 function IntersectCreate(T2, options = {}) {
-  const allObjects = T2.every((schema) => IsObject4(schema));
-  const clonedUnevaluatedProperties = IsSchema2(options.unevaluatedProperties) ? { unevaluatedProperties: options.unevaluatedProperties } : {};
-  return CreateType(options.unevaluatedProperties === false || IsSchema2(options.unevaluatedProperties) || allObjects ? { ...clonedUnevaluatedProperties, [Kind]: "Intersect", type: "object", allOf: T2 } : { ...clonedUnevaluatedProperties, [Kind]: "Intersect", allOf: T2 }, options);
+  const allObjects = T2.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: T2 } : { ...clonedUnevaluatedProperties, [Kind]: "Intersect", allOf: T2 }, options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.mjs
 function IsIntersectOptional(types) {
-  return types.every((left) => IsOptional2(left));
+  return types.every((left) => IsOptional(left));
 }
 function RemoveOptionalFromType2(type) {
   return Discard(type, [OptionalKind]);
 }
 function RemoveOptionalFromRest2(types) {
-  return types.map((left) => IsOptional2(left) ? RemoveOptionalFromType2(left) : left);
+  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);
@@ -152239,7 +152226,7 @@ function IntersectEvaluated(types, options = {}) {
     return CreateType(types[0], options);
   if (types.length === 0)
     return Never(options);
-  if (types.some((schema) => IsTransform2(schema)))
+  if (types.some((schema) => IsTransform(schema)))
     throw new Error("Cannot intersect transform types");
   return ResolveIntersect(types, options);
 }
@@ -152250,7 +152237,7 @@ function Intersect(types, options) {
     return CreateType(types[0], options);
   if (types.length === 0)
     return Never(options);
-  if (types.some((schema) => IsTransform2(schema)))
+  if (types.some((schema) => IsTransform(schema)))
     throw new Error("Cannot intersect transform types");
   return IntersectCreate(types, options);
 }
@@ -152283,7 +152270,7 @@ function FromRest3(types) {
   return types.map((type) => Awaited(type));
 }
 function Awaited(type, options) {
-  return CreateType(IsComputed2(type) ? FromComputed(type.target, type.parameters) : IsIntersect2(type) ? FromIntersect2(type.allOf) : IsUnion2(type) ? FromUnion4(type.anyOf) : IsPromise3(type) ? FromPromise(type.item) : IsRef2(type) ? FromRef(type.$ref) : type, options);
+  return CreateType(IsComputed(type) ? FromComputed(type.target, type.parameters) : IsIntersect(type) ? FromIntersect2(type.allOf) : IsUnion(type) ? FromUnion4(type.anyOf) : IsPromise2(type) ? FromPromise(type.item) : IsRef(type) ? FromRef(type.$ref) : type, options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.mjs
@@ -152321,7 +152308,7 @@ function FromPatternProperties(patternProperties) {
   });
 }
 function KeyOfPropertyKeys(type) {
-  return IsIntersect2(type) ? FromIntersect3(type.allOf) : IsUnion2(type) ? FromUnion5(type.anyOf) : IsTuple2(type) ? FromTuple2(type.items ?? []) : IsArray4(type) ? FromArray2(type.items) : IsObject4(type) ? FromProperties5(type.properties) : IsRecord2(type) ? FromPatternProperties(type.patternProperties) : [];
+  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;
 function KeyOfPattern(schema) {
@@ -152349,7 +152336,7 @@ function KeyOfPropertyKeysToRest(propertyKeys) {
   return propertyKeys.map((L) => L === "[number]" ? Number2() : Literal(L));
 }
 function KeyOf(type, options) {
-  return IsComputed2(type) ? FromComputed2(type.target, type.parameters) : IsRef2(type) ? FromRef2(type.$ref) : IsMappedResult2(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(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
@@ -152382,7 +152369,7 @@ function CompositeKeys(T2) {
   return SetDistinct(Acc);
 }
 function FilterNever(T2) {
-  return T2.filter((L) => !IsNever2(L));
+  return T2.filter((L) => !IsNever(L));
 }
 function CompositeProperty(T2, K) {
   const Acc = [];
@@ -152456,7 +152443,7 @@ function Const(T2, options) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs
 function ConstructorParameters(schema, options) {
-  return IsConstructor2(schema) ? Tuple(schema.parameters, options) : Never(options);
+  return IsConstructor(schema) ? Tuple(schema.parameters, options) : Never(options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs
@@ -152735,7 +152722,7 @@ function ExtendsResolve(left, right, trueType, falseType) {
   return R === ExtendsResult.Union ? Union([trueType, falseType]) : R === ExtendsResult.True ? trueType : falseType;
 }
 function Extends(L, R, T2, F, options) {
-  return IsMappedResult2(L) ? ExtendsFromMappedResult(L, R, T2, F, options) : IsMappedKey2(L) ? CreateType(ExtendsFromMappedKey(L, R, T2, F, options)) : CreateType(ExtendsResolve(L, R, T2, F), options);
+  return IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T2, F, options) : IsMappedKey(L) ? CreateType(ExtendsFromMappedKey(L, R, T2, F, options)) : CreateType(ExtendsResolve(L, R, T2, F), options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-key.mjs
@@ -152782,11 +152769,11 @@ function ExcludeRest(L, R) {
   return excluded.length === 1 ? excluded[0] : Union(excluded);
 }
 function Exclude(L, R, options = {}) {
-  if (IsTemplateLiteral2(L))
+  if (IsTemplateLiteral(L))
     return CreateType(ExcludeFromTemplateLiteral(L, R), options);
-  if (IsMappedResult2(L))
+  if (IsMappedResult(L))
     return CreateType(ExcludeFromMappedResult(L, R), options);
-  return CreateType(IsUnion2(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, 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
@@ -152815,11 +152802,11 @@ function ExtractRest(L, R) {
   return extracted.length === 1 ? extracted[0] : Union(extracted);
 }
 function Extract(L, R, options) {
-  if (IsTemplateLiteral2(L))
+  if (IsTemplateLiteral(L))
     return CreateType(ExtractFromTemplateLiteral(L, R), options);
-  if (IsMappedResult2(L))
+  if (IsMappedResult(L))
     return CreateType(ExtractFromMappedResult(L, R), options);
-  return CreateType(IsUnion2(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), 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
@@ -152839,7 +152826,7 @@ function ExtractFromMappedResult(R, T2) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
 function InstanceType(schema, options) {
-  return IsConstructor2(schema) ? CreateType(schema.returns, options) : Never(options);
+  return IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
@@ -152889,7 +152876,7 @@ function FromNumberKey(_2, type, options) {
   return RecordCreateFromPattern(PatternNumberExact, type, options);
 }
 function Record(key, type, options = {}) {
-  return IsUnion2(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral2(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral2(key) ? FromLiteralKey(key.const, type, options) : IsBoolean4(key) ? FromBooleanKey(key, type, options) : IsInteger3(key) ? FromIntegerKey(key, type, options) : IsNumber4(key) ? FromNumberKey(key, type, options) : IsRegExp3(key) ? FromRegExpKey(key, type, options) : IsString4(key) ? FromStringKey(key, type, options) : IsAny2(key) ? FromAnyKey(key, type, options) : IsNever2(key) ? FromNeverKey(key, type, options) : Never(options);
+  return IsUnion(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral(key) ? FromLiteralKey(key.const, type, options) : IsBoolean3(key) ? FromBooleanKey(key, type, options) : IsInteger2(key) ? FromIntegerKey(key, type, options) : IsNumber3(key) ? FromNumberKey(key, type, options) : IsRegExp2(key) ? FromRegExpKey(key, type, options) : IsString3(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];
@@ -152957,8 +152944,8 @@ function FromArgument(args, argument) {
   return argument.index in args ? args[argument.index] : Unknown();
 }
 function FromProperty2(args, type) {
-  const isReadonly = IsReadonly2(type);
-  const isOptional = IsOptional2(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;
 }
@@ -152971,7 +152958,7 @@ function FromTypes(args, types) {
   return types.map((type) => FromType(args, type));
 }
 function FromType(args, type) {
-  return IsConstructor2(type) ? FromConstructor2(args, type) : IsFunction4(type) ? FromFunction2(args, type) : IsIntersect2(type) ? FromIntersect5(args, type) : IsUnion2(type) ? FromUnion7(args, type) : IsTuple2(type) ? FromTuple4(args, type) : IsArray4(type) ? FromArray5(args, type) : IsAsyncIterator4(type) ? FromAsyncIterator2(args, type) : IsIterator4(type) ? FromIterator2(args, type) : IsPromise3(type) ? FromPromise3(args, type) : IsObject4(type) ? FromObject2(args, type) : IsRecord2(type) ? FromRecord2(args, type) : IsArgument2(type) ? FromArgument(args, type) : type;
+  return IsConstructor(type) ? FromConstructor2(args, type) : IsFunction3(type) ? FromFunction2(args, type) : IsIntersect(type) ? FromIntersect5(args, type) : IsUnion(type) ? FromUnion7(args, type) : IsTuple(type) ? FromTuple4(args, type) : IsArray3(type) ? FromArray5(args, type) : IsAsyncIterator3(type) ? FromAsyncIterator2(args, type) : IsIterator3(type) ? FromIterator2(args, type) : IsPromise2(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));
@@ -153035,7 +153022,7 @@ function FromRest5(T2, M) {
   return T2.map((L) => Intrinsic(L, M));
 }
 function Intrinsic(schema, mode, options = {}) {
-  return IsMappedKey2(schema) ? IntrinsicFromMappedKey(schema, mode, options) : IsTemplateLiteral2(schema) ? FromTemplateLiteral3(schema, mode, options) : IsUnion2(schema) ? Union(FromRest5(schema.anyOf, mode), options) : IsLiteral2(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : CreateType(schema, options);
+  return IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) : IsTemplateLiteral(schema) ? FromTemplateLiteral3(schema, mode, options) : IsUnion(schema) ? Union(FromRest5(schema.anyOf, mode), options) : IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : CreateType(schema, options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/intrinsic/capitalize.mjs
@@ -153093,18 +153080,18 @@ function FromObject3(type, propertyKeys, properties) {
   return Object2(mappedProperties, options);
 }
 function UnionFromPropertyKeys(propertyKeys) {
-  const result = propertyKeys.reduce((result2, key) => IsLiteralValue2(key) ? [...result2, Literal(key)] : result2, []);
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
   return Union(result);
 }
 function OmitResolve(type, propertyKeys) {
-  return IsIntersect2(type) ? Intersect(FromIntersect6(type.allOf, propertyKeys)) : IsUnion2(type) ? Union(FromUnion8(type.anyOf, propertyKeys)) : IsObject4(type) ? FromObject3(type, propertyKeys, type.properties) : Object2({});
+  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 = IsSchema2(key) ? IndexPropertyKeys(key) : key;
-  const isTypeRef = IsRef2(type);
-  const isKeyRef = IsRef2(key);
-  return IsMappedResult2(type) ? OmitFromMappedResult(type, propertyKeys, options) : IsMappedKey2(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 });
+  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
@@ -153159,18 +153146,18 @@ function FromObject4(Type, keys, properties) {
   return Object2(mappedProperties, options);
 }
 function UnionFromPropertyKeys2(propertyKeys) {
-  const result = propertyKeys.reduce((result2, key) => IsLiteralValue2(key) ? [...result2, Literal(key)] : result2, []);
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
   return Union(result);
 }
 function PickResolve(type, propertyKeys) {
-  return IsIntersect2(type) ? Intersect(FromIntersect7(type.allOf, propertyKeys)) : IsUnion2(type) ? Union(FromUnion9(type.anyOf, propertyKeys)) : IsObject4(type) ? FromObject4(type, propertyKeys, type.properties) : Object2({});
+  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 = IsSchema2(key) ? IndexPropertyKeys(key) : key;
-  const isTypeRef = IsRef2(type);
-  const isKeyRef = IsRef2(key);
-  return IsMappedResult2(type) ? PickFromMappedResult(type, propertyKeys, options) : IsMappedKey2(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 });
+  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
@@ -153214,10 +153201,10 @@ function FromRest6(types) {
   return types.map((type) => PartialResolve(type));
 }
 function PartialResolve(type) {
-  return IsComputed2(type) ? FromComputed3(type.target, type.parameters) : IsRef2(type) ? FromRef3(type.$ref) : IsIntersect2(type) ? Intersect(FromRest6(type.allOf)) : IsUnion2(type) ? Union(FromRest6(type.anyOf)) : IsObject4(type) ? FromObject5(type, type.properties) : IsBigInt4(type) ? type : IsBoolean4(type) ? type : IsInteger3(type) ? type : IsLiteral2(type) ? type : IsNull4(type) ? type : IsNumber4(type) ? type : IsString4(type) ? type : IsSymbol4(type) ? type : IsUndefined4(type) ? type : Object2({});
+  return IsComputed(type) ? FromComputed3(type.target, type.parameters) : IsRef(type) ? FromRef3(type.$ref) : IsIntersect(type) ? Intersect(FromRest6(type.allOf)) : IsUnion(type) ? Union(FromRest6(type.anyOf)) : IsObject3(type) ? FromObject5(type, type.properties) : IsBigInt3(type) ? type : IsBoolean3(type) ? type : IsInteger2(type) ? type : IsLiteral(type) ? type : IsNull3(type) ? type : IsNumber3(type) ? type : IsString3(type) ? type : IsSymbol3(type) ? type : IsUndefined3(type) ? type : Object2({});
 }
 function Partial(type, options) {
-  if (IsMappedResult2(type)) {
+  if (IsMappedResult(type)) {
     return PartialFromMappedResult(type, options);
   } else {
     return CreateType({ ...PartialResolve(type), ...options });
@@ -153261,10 +153248,10 @@ function FromRest7(types) {
   return types.map((type) => RequiredResolve(type));
 }
 function RequiredResolve(type) {
-  return IsComputed2(type) ? FromComputed4(type.target, type.parameters) : IsRef2(type) ? FromRef4(type.$ref) : IsIntersect2(type) ? Intersect(FromRest7(type.allOf)) : IsUnion2(type) ? Union(FromRest7(type.anyOf)) : IsObject4(type) ? FromObject6(type, type.properties) : IsBigInt4(type) ? type : IsBoolean4(type) ? type : IsInteger3(type) ? type : IsLiteral2(type) ? type : IsNull4(type) ? type : IsNumber4(type) ? type : IsString4(type) ? type : IsSymbol4(type) ? type : IsUndefined4(type) ? type : Object2({});
+  return IsComputed(type) ? FromComputed4(type.target, type.parameters) : IsRef(type) ? FromRef4(type.$ref) : IsIntersect(type) ? Intersect(FromRest7(type.allOf)) : IsUnion(type) ? Union(FromRest7(type.anyOf)) : IsObject3(type) ? FromObject6(type, type.properties) : IsBigInt3(type) ? type : IsBoolean3(type) ? type : IsInteger2(type) ? type : IsLiteral(type) ? type : IsNull3(type) ? type : IsNumber3(type) ? type : IsString3(type) ? type : IsSymbol3(type) ? type : IsUndefined3(type) ? type : Object2({});
 }
 function Required(type, options) {
-  if (IsMappedResult2(type)) {
+  if (IsMappedResult(type)) {
     return RequiredFromMappedResult(type, options);
   } else {
     return CreateType({ ...RequiredResolve(type), ...options });
@@ -153289,11 +153276,11 @@ function RequiredFromMappedResult(R, options) {
 // ../../node_modules/@sinclair/typebox/build/esm/type/module/compute.mjs
 function DereferenceParameters(moduleProperties, types) {
   return types.map((type) => {
-    return IsRef2(type) ? Dereference(moduleProperties, type.$ref) : FromType2(moduleProperties, type);
+    return IsRef(type) ? Dereference(moduleProperties, type.$ref) : FromType2(moduleProperties, type);
   });
 }
 function Dereference(moduleProperties, ref) {
-  return ref in moduleProperties ? IsRef2(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType2(moduleProperties, moduleProperties[ref]) : Never();
+  return ref in moduleProperties ? IsRef(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType2(moduleProperties, moduleProperties[ref]) : Never();
 }
 function FromAwaited(parameters) {
   return Awaited(parameters[0]);
@@ -153350,7 +153337,7 @@ function FromRecord3(moduleProperties, type) {
   return result;
 }
 function FromTransform(moduleProperties, transform) {
-  return IsRef2(transform) ? { ...Dereference(moduleProperties, transform.$ref), [TransformKind]: transform[TransformKind] } : transform;
+  return IsRef(transform) ? { ...Dereference(moduleProperties, transform.$ref), [TransformKind]: transform[TransformKind] } : transform;
 }
 function FromTuple5(moduleProperties, types) {
   return Tuple(FromTypes2(moduleProperties, types));
@@ -153362,7 +153349,7 @@ function FromTypes2(moduleProperties, types) {
   return types.map((type) => FromType2(moduleProperties, type));
 }
 function FromType2(moduleProperties, type) {
-  return IsOptional2(type) ? CreateType(FromType2(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly2(type) ? CreateType(FromType2(moduleProperties, Discard(type, [ReadonlyKind])), type) : IsTransform2(type) ? CreateType(FromTransform(moduleProperties, type), type) : IsArray4(type) ? CreateType(FromArray6(moduleProperties, type.items), type) : IsAsyncIterator4(type) ? CreateType(FromAsyncIterator3(moduleProperties, type.items), type) : IsComputed2(type) ? CreateType(FromComputed5(moduleProperties, type.target, type.parameters)) : IsConstructor2(type) ? CreateType(FromConstructor3(moduleProperties, type.parameters, type.returns), type) : IsFunction4(type) ? CreateType(FromFunction3(moduleProperties, type.parameters, type.returns), type) : IsIntersect2(type) ? CreateType(FromIntersect8(moduleProperties, type.allOf), type) : IsIterator4(type) ? CreateType(FromIterator3(moduleProperties, type.items), type) : IsObject4(type) ? CreateType(FromObject7(moduleProperties, type.properties), type) : IsRecord2(type) ? CreateType(FromRecord3(moduleProperties, type)) : IsTuple2(type) ? CreateType(FromTuple5(moduleProperties, type.items || []), type) : IsUnion2(type) ? CreateType(FromUnion10(moduleProperties, type.anyOf), type) : type;
+  return IsOptional(type) ? CreateType(FromType2(moduleProperties, Discard(type, [OptionalKind])), type) : IsReadonly(type) ? CreateType(FromType2(moduleProperties, Discard(type, [ReadonlyKind])), type) : IsTransform(type) ? CreateType(FromTransform(moduleProperties, type), type) : IsArray3(type) ? CreateType(FromArray6(moduleProperties, type.items), type) : IsAsyncIterator3(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) : IsFunction3(type) ? CreateType(FromFunction3(moduleProperties, type.parameters, type.returns), type) : IsIntersect(type) ? CreateType(FromIntersect8(moduleProperties, type.allOf), type) : IsIterator3(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();
@@ -153401,7 +153388,7 @@ function Not2(type, options) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.mjs
 function Parameters(schema, options) {
-  return IsFunction4(schema) ? Tuple(schema.parameters, options) : Never();
+  return IsFunction3(schema) ? Tuple(schema.parameters, options) : Never();
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.mjs
@@ -153422,7 +153409,7 @@ function RegExp2(unresolved, options) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/rest/rest.mjs
 function RestResolve(T2) {
-  return IsIntersect2(T2) ? T2.allOf : IsUnion2(T2) ? T2.anyOf : IsTuple2(T2) ? T2.items ?? [] : [];
+  return IsIntersect(T2) ? T2.allOf : IsUnion(T2) ? T2.anyOf : IsTuple(T2) ? T2.items ?? [] : [];
 }
 function Rest(T2) {
   return RestResolve(T2);
@@ -153430,7 +153417,7 @@ function Rest(T2) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
 function ReturnType(schema, options) {
-  return IsFunction4(schema) ? CreateType(schema.returns, options) : Never(options);
+  return IsFunction3(schema) ? CreateType(schema.returns, options) : Never(options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
@@ -153459,7 +153446,7 @@ class TransformEncodeBuilder {
     return { ...schema, [TransformKind]: Codec };
   }
   Encode(encode) {
-    return IsTransform2(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
+    return IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
   }
 }
 function Transform(schema) {
@@ -153984,7 +153971,7 @@ function FromIntersect9(schema, references, value) {
     const keyPattern = new RegExp(KeyOfPattern(schema));
     const check2 = Object.getOwnPropertyNames(value).every((key) => keyPattern.test(key));
     return check1 && check2;
-  } else if (IsSchema2(schema.unevaluatedProperties)) {
+  } else if (IsSchema(schema.unevaluatedProperties)) {
     const keyCheck = new RegExp(KeyOfPattern(schema));
     const check2 = Object.getOwnPropertyNames(value).every((key) => keyCheck.test(key) || Visit5(schema.unevaluatedProperties, references, value[key]));
     return check1 && check2;
@@ -155509,7 +155496,7 @@ function Cast(...args) {
 }
 // ../../node_modules/@sinclair/typebox/build/esm/value/clean/clean.mjs
 function IsCheckable(schema) {
-  return IsKind2(schema) && schema[Kind] !== "Unsafe";
+  return IsKind(schema) && schema[Kind] !== "Unsafe";
 }
 function FromArray12(schema, references, value) {
   if (!IsArray2(value))
@@ -155525,7 +155512,7 @@ function FromIntersect13(schema, references, value) {
   const unevaluatedProperties = schema.unevaluatedProperties;
   const intersections = schema.allOf.map((schema2) => Visit9(schema2, references, Clone2(value)));
   const composite = intersections.reduce((acc, value2) => IsObject2(value2) ? { ...acc, ...value2 } : value2, {});
-  if (!IsObject2(value) || !IsObject2(composite) || !IsKind2(unevaluatedProperties))
+  if (!IsObject2(value) || !IsObject2(composite) || !IsKind(unevaluatedProperties))
     return composite;
   const knownkeys = KeyOfPropertyKeys(schema);
   for (const key of Object.getOwnPropertyNames(value)) {
@@ -155546,7 +155533,7 @@ function FromObject13(schema, references, value) {
       value[key] = Visit9(schema.properties[key], references, value[key]);
       continue;
     }
-    if (IsKind2(additionalProperties) && Check(additionalProperties, references, value[key])) {
+    if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
       value[key] = Visit9(additionalProperties, references, value[key]);
       continue;
     }
@@ -155566,7 +155553,7 @@ function FromRecord8(schema, references, value) {
       value[key] = Visit9(propertySchema, references, value[key]);
       continue;
     }
-    if (IsKind2(additionalProperties) && Check(additionalProperties, references, value[key])) {
+    if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
       value[key] = Visit9(additionalProperties, references, value[key]);
       continue;
     }
@@ -155860,7 +155847,7 @@ class TransformDecodeError extends TypeBoxError {
 }
 function Default3(schema, path6, value) {
   try {
-    return IsTransform2(schema) ? schema[TransformKind].Decode(value) : value;
+    return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
   } catch (error) {
     throw new TransformDecodeError(schema, path6, value, error);
   }
@@ -155878,7 +155865,7 @@ function FromIntersect15(schema, references, path6, value) {
     if (knownKey in knownProperties) {
       knownProperties[knownKey] = Visit11(knownSchema, references, `${path6}/${knownKey}`, knownProperties[knownKey]);
     }
-  if (!IsTransform2(schema.unevaluatedProperties)) {
+  if (!IsTransform(schema.unevaluatedProperties)) {
     return Default3(schema, path6, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -155907,11 +155894,11 @@ function FromObject15(schema, references, path6, value) {
   for (const key of knownKeys) {
     if (!HasPropertyKey2(knownProperties, key))
       continue;
-    if (IsUndefined2(knownProperties[key]) && (!IsUndefined4(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+    if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
     knownProperties[key] = Visit11(schema.properties[key], references, `${path6}/${key}`, knownProperties[key]);
   }
-  if (!IsSchema2(schema.additionalProperties)) {
+  if (!IsSchema(schema.additionalProperties)) {
     return Default3(schema, path6, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -155933,7 +155920,7 @@ function FromRecord10(schema, references, path6, value) {
     if (knownKeys.test(key)) {
       knownProperties[key] = Visit11(schema.patternProperties[pattern], references, `${path6}/${key}`, knownProperties[key]);
     }
-  if (!IsSchema2(schema.additionalProperties)) {
+  if (!IsSchema(schema.additionalProperties)) {
     return Default3(schema, path6, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -156020,7 +156007,7 @@ class TransformEncodeError extends TypeBoxError {
 }
 function Default4(schema, path6, value) {
   try {
-    return IsTransform2(schema) ? schema[TransformKind].Encode(value) : value;
+    return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
   } catch (error) {
     throw new TransformEncodeError(schema, path6, value, error);
   }
@@ -156046,7 +156033,7 @@ function FromIntersect16(schema, references, path6, value) {
     if (knownKey in knownProperties) {
       knownProperties[knownKey] = Visit12(knownSchema, references, `${path6}/${knownKey}`, knownProperties[knownKey]);
     }
-  if (!IsTransform2(schema.unevaluatedProperties)) {
+  if (!IsTransform(schema.unevaluatedProperties)) {
     return knownProperties;
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -156070,11 +156057,11 @@ function FromObject16(schema, references, path6, value) {
   for (const key of knownKeys) {
     if (!HasPropertyKey2(knownProperties, key))
       continue;
-    if (IsUndefined2(knownProperties[key]) && (!IsUndefined4(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+    if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
     knownProperties[key] = Visit12(schema.properties[key], references, `${path6}/${key}`, knownProperties[key]);
   }
-  if (!IsSchema2(schema.additionalProperties)) {
+  if (!IsSchema(schema.additionalProperties)) {
     return knownProperties;
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -156097,7 +156084,7 @@ function FromRecord11(schema, references, path6, value) {
     if (knownKeys.test(key)) {
       knownProperties[key] = Visit12(schema.patternProperties[pattern], references, `${path6}/${key}`, knownProperties[key]);
     }
-  if (!IsSchema2(schema.additionalProperties)) {
+  if (!IsSchema(schema.additionalProperties)) {
     return knownProperties;
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -156172,57 +156159,57 @@ function TransformEncode(schema, references, value) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/value/transform/has.mjs
 function FromArray16(schema, references) {
-  return IsTransform2(schema) || Visit13(schema.items, references);
+  return IsTransform(schema) || Visit13(schema.items, references);
 }
 function FromAsyncIterator7(schema, references) {
-  return IsTransform2(schema) || Visit13(schema.items, references);
+  return IsTransform(schema) || Visit13(schema.items, references);
 }
 function FromConstructor8(schema, references) {
-  return IsTransform2(schema) || Visit13(schema.returns, references) || schema.parameters.some((schema2) => Visit13(schema2, references));
+  return IsTransform(schema) || Visit13(schema.returns, references) || schema.parameters.some((schema2) => Visit13(schema2, references));
 }
 function FromFunction7(schema, references) {
-  return IsTransform2(schema) || Visit13(schema.returns, references) || schema.parameters.some((schema2) => Visit13(schema2, references));
+  return IsTransform(schema) || Visit13(schema.returns, references) || schema.parameters.some((schema2) => Visit13(schema2, references));
 }
 function FromIntersect17(schema, references) {
-  return IsTransform2(schema) || IsTransform2(schema.unevaluatedProperties) || schema.allOf.some((schema2) => Visit13(schema2, references));
+  return IsTransform(schema) || IsTransform(schema.unevaluatedProperties) || schema.allOf.some((schema2) => Visit13(schema2, references));
 }
 function FromImport9(schema, references) {
   const additional = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => [...result, schema.$defs[key]], []);
   const target = schema.$defs[schema.$ref];
-  return IsTransform2(schema) || Visit13(target, [...additional, ...references]);
+  return IsTransform(schema) || Visit13(target, [...additional, ...references]);
 }
 function FromIterator7(schema, references) {
-  return IsTransform2(schema) || Visit13(schema.items, references);
+  return IsTransform(schema) || Visit13(schema.items, references);
 }
 function FromNot7(schema, references) {
-  return IsTransform2(schema) || Visit13(schema.not, references);
+  return IsTransform(schema) || Visit13(schema.not, references);
 }
 function FromObject17(schema, references) {
-  return IsTransform2(schema) || Object.values(schema.properties).some((schema2) => Visit13(schema2, references)) || IsSchema2(schema.additionalProperties) && Visit13(schema.additionalProperties, references);
+  return IsTransform(schema) || Object.values(schema.properties).some((schema2) => Visit13(schema2, references)) || IsSchema(schema.additionalProperties) && Visit13(schema.additionalProperties, references);
 }
 function FromPromise7(schema, references) {
-  return IsTransform2(schema) || Visit13(schema.item, references);
+  return IsTransform(schema) || Visit13(schema.item, references);
 }
 function FromRecord12(schema, references) {
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
   const property = schema.patternProperties[pattern];
-  return IsTransform2(schema) || Visit13(property, references) || IsSchema2(schema.additionalProperties) && IsTransform2(schema.additionalProperties);
+  return IsTransform(schema) || Visit13(property, references) || IsSchema(schema.additionalProperties) && IsTransform(schema.additionalProperties);
 }
 function FromRef13(schema, references) {
-  if (IsTransform2(schema))
+  if (IsTransform(schema))
     return true;
   return Visit13(Deref(schema, references), references);
 }
 function FromThis9(schema, references) {
-  if (IsTransform2(schema))
+  if (IsTransform(schema))
     return true;
   return Visit13(Deref(schema, references), references);
 }
 function FromTuple14(schema, references) {
-  return IsTransform2(schema) || !IsUndefined2(schema.items) && schema.items.some((schema2) => Visit13(schema2, references));
+  return IsTransform(schema) || !IsUndefined2(schema.items) && schema.items.some((schema2) => Visit13(schema2, references));
 }
 function FromUnion19(schema, references) {
-  return IsTransform2(schema) || schema.anyOf.some((schema2) => Visit13(schema2, references));
+  return IsTransform(schema) || schema.anyOf.some((schema2) => Visit13(schema2, references));
 }
 function Visit13(schema, references) {
   const references_ = Pushref(schema, references);
@@ -156263,7 +156250,7 @@ function Visit13(schema, references) {
     case "Union":
       return FromUnion19(schema_, references_);
     default:
-      return IsTransform2(schema);
+      return IsTransform(schema);
   }
 }
 var visited = new Set;
@@ -156286,7 +156273,7 @@ function ValueOrDefault(schema, value) {
   return IsUndefined2(value) ? clone : IsObject2(value) && IsObject2(clone) ? Object.assign(clone, value) : value;
 }
 function HasDefaultProperty(schema) {
-  return IsKind2(schema) && "default" in schema;
+  return IsKind(schema) && "default" in schema;
 }
 function FromArray17(schema, references, value) {
   if (IsArray2(value)) {
@@ -157024,8 +157011,8 @@ var TypeCompiler;
       yield `${value}.length >= ${schema.minItems}`;
     const elementExpression = CreateExpression(schema.items, references, "value");
     yield `((array) => { for(const ${parameter} of array) if(!(${elementExpression})) { return false }; return true; })(${value})`;
-    if (IsSchema(schema.contains) || IsNumber2(schema.minContains) || IsNumber2(schema.maxContains)) {
-      const containsSchema = IsSchema(schema.contains) ? schema.contains : Never();
+    if (IsSchema2(schema.contains) || IsNumber2(schema.minContains) || IsNumber2(schema.maxContains)) {
+      const containsSchema = IsSchema2(schema.contains) ? schema.contains : Never();
       const checkExpression = CreateExpression(containsSchema, references, "value");
       const checkMinContains = IsNumber2(schema.minContains) ? [`(count >= ${schema.minContains})`] : [];
       const checkMaxContains = IsNumber2(schema.maxContains) ? [`(count <= ${schema.maxContains})`] : [];
@@ -157102,7 +157089,7 @@ var TypeCompiler;
       const keyCheck = CreateVariable(`${new RegExp(KeyOfPattern(schema))};`);
       const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key))`;
       yield `(${check1} && ${check2})`;
-    } else if (IsSchema(schema.unevaluatedProperties)) {
+    } else if (IsSchema2(schema.unevaluatedProperties)) {
       const keyCheck = CreateVariable(`${new RegExp(KeyOfPattern(schema))};`);
       const check2 = `Object.getOwnPropertyNames(${value}).every(key => ${keyCheck}.test(key) || ${CreateExpression(schema.unevaluatedProperties, references, `${value}[key]`)})`;
       yield `(${check1} && ${check2})`;
@@ -157188,7 +157175,7 @@ var TypeCompiler;
     const [patternKey, patternSchema] = Object.entries(schema.patternProperties)[0];
     const variable = CreateVariable(`${new RegExp(patternKey)}`);
     const check1 = CreateExpression(patternSchema, references, "value");
-    const check2 = IsSchema(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? "false" : "true";
+    const check2 = IsSchema2(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? "false" : "true";
     const expression = `(${variable}.test(key) ? ${check1} : ${check2})`;
     yield `(Object.entries(${value}).every(([key, value]) => ${expression}))`;
   }
@@ -157406,10 +157393,10 @@ var TypeCompiler;
     state.variables.clear();
     state.functions.clear();
     state.instances.clear();
-    if (!IsSchema(schema))
+    if (!IsSchema2(schema))
       throw new TypeCompilerTypeGuardError(schema);
     for (const schema2 of references)
-      if (!IsSchema(schema2))
+      if (!IsSchema2(schema2))
         throw new TypeCompilerTypeGuardError(schema2);
     return Build(schema, references, options);
   }
@@ -172886,14 +172873,113 @@ var cors = (config2) => {
 init_contextual_search_rlm();
 init_dist();
 init_index_job_tracker();
+
+// ../../packages/core/dist/services/indexing/execute-indexing.js
+init_dist();
+init_index_job_tracker();
 init_pipeline();
-init_workspace_manager();
-init_parser_readiness();
+async function executeIndexing(request) {
+  const { jobId, projectId, projectPath, forceReindex, warmCache, warmupQueries, include_tests = false, managedRunLease, warmupCache: warmupCache2 } = request;
+  const startTime = Date.now();
+  try {
+    indexJobTracker.updateStatus(jobId, "running");
+    logger.info("Starting project indexing via ETL Pipeline", {
+      jobId,
+      projectPath,
+      projectId,
+      forceReindex,
+      warmCache,
+      include_tests
+    });
+    const etlResult = await EtlPipeline.getInstance().run({
+      projectId,
+      projectPath,
+      jobId,
+      forceReindex,
+      include_tests,
+      managedRunLease
+    });
+    const duration3 = Date.now() - startTime;
+    logger.info("ETL Pipeline completed", {
+      jobId,
+      projectId,
+      duration: duration3,
+      filesIndexed: etlResult.filesIndexed,
+      filesSkipped: etlResult.filesSkipped,
+      chunksIndexed: etlResult.chunksIndexed,
+      symbolsIndexed: etlResult.symbolsIndexed,
+      errors: etlResult.errors,
+      stageTimings: etlResult.stageTimings
+    });
+    if (warmCache) {
+      logger.info("Starting cache warmup", { jobId, projectId });
+      const warmupStats = await warmupCache2(projectId, projectPath, warmupQueries);
+      logger.info("Cache warmup completed", { jobId, projectId, ...warmupStats });
+    }
+    indexJobTracker.updateProgress(jobId, etlResult.filesIndexed, etlResult.filesIndexed);
+    await indexJobTracker.setResultAndFlush(jobId, {
+      filesIndexed: etlResult.filesIndexed,
+      chunksIndexed: etlResult.chunksIndexed,
+      errors: etlResult.errors,
+      duration: duration3,
+      activatedGraphGenerationId: etlResult.activatedGraphGenerationId,
+      parserDiagnostics: etlResult.parserDiagnostics
+    });
+  } catch (error51) {
+    const duration3 = Date.now() - startTime;
+    logger.error("Project indexing failed", error51, {
+      jobId,
+      projectPath,
+      projectId,
+      duration: duration3
+    });
+    indexJobTracker.setResult(jobId, {
+      filesIndexed: 0,
+      chunksIndexed: 0,
+      errors: 1,
+      duration: duration3
+    }, error51.message);
+  }
+}
+
+// ../../packages/core/dist/services/indexing/acquire-indexing-lease.js
+init_dist();
+init_index_job_tracker();
 init_managed_run_repository_pg();
+async function acquireIndexingLease(request) {
+  const { jobId, projectId } = request;
+  const eventId = `index:${jobId}`;
+  const managedRunRepo = ManagedRunRepositoryPg.getInstance();
+  try {
+    const beginOutcome = await managedRunRepo.begin({
+      projectId,
+      runKind: "indexing",
+      eventId
+    });
+    if (beginOutcome.status === "busy") {
+      indexJobTracker.setResult(jobId, { filesIndexed: 0, chunksIndexed: 0, errors: 0, duration: 0 }, `indexing_busy:${beginOutcome.activeRunId}`);
+      return {
+        status: "busy",
+        activeRunId: beginOutcome.activeRunId,
+        leaseExpiresAt: beginOutcome.leaseExpiresAt
+      };
+    }
+    return { status: "acquired", lease: beginOutcome.lease };
+  } catch (beginError) {
+    logger.error("managed_runs begin failed", beginError, {
+      jobId,
+      projectId
+    });
+    indexJobTracker.setResult(jobId, { filesIndexed: 0, chunksIndexed: 0, errors: 1, duration: 0 }, `managed_runs_begin_failed:${beginError.message}`);
+    return { status: "failed", message: beginError.message };
+  }
+}
+
+// ../../packages/core/dist/services/project-identity/project-root-identity.js
 import { realpath as realpath2 } from "fs/promises";
-import path19 from "path";
+import path18 from "path";
 async function canonicalizeProjectRoot(projectPath, canonicalize = realpath2) {
-  return canonicalize(path19.resolve(projectPath));
+  return canonicalize(path18.resolve(projectPath));
 }
 async function assertProjectRootReuse(options) {
   if (!options.storedProjectPath || options.forceReindex)
@@ -172901,15 +172987,20 @@ async function assertProjectRootReuse(options) {
   const canonicalize = options.canonicalize ?? realpath2;
   let storedCanonical;
   try {
-    storedCanonical = await canonicalize(path19.resolve(options.storedProjectPath));
+    storedCanonical = await canonicalize(path18.resolve(options.storedProjectPath));
   } catch {
-    storedCanonical = path19.resolve(options.storedProjectPath);
+    storedCanonical = path18.resolve(options.storedProjectPath);
   }
   if (storedCanonical !== options.canonicalProjectPath) {
     throw new Error(`Project ID "${options.projectId}" already indexes canonical root ` + `"${storedCanonical}", not "${options.canonicalProjectPath}"; ` + "use forceReindex only after verifying ownership of the existing project");
   }
 }
 
+// ../../packages/core/dist/tools/index_project.js
+init_workspace_manager();
+init_parser_readiness();
+import path20 from "path";
+
 class IndexProjectTool {
   name = "index_project";
   description = "Index a project directory for contextual code search with semantic embeddings";
@@ -172956,7 +173047,7 @@ class IndexProjectTool {
     try {
       await assertParserReadyForIndexing();
       const canonicalProjectPath = await canonicalizeProjectRoot(projectPath);
-      const finalProjectId = projectId || path19.basename(canonicalProjectPath) || "default";
+      const finalProjectId = projectId || path20.basename(canonicalProjectPath) || "default";
       const existing = await workspaceManager.getWorkspace(finalProjectId);
       await assertProjectRootReuse({
         projectId: finalProjectId,
@@ -172970,40 +173061,42 @@ class IndexProjectTool {
         projectPath: canonicalProjectPath,
         projectId: finalProjectId
       });
-      const eventId = `index:${job.jobId}`;
-      const managedRunRepo = ManagedRunRepositoryPg.getInstance();
-      let lease;
-      try {
-        const beginOutcome = await managedRunRepo.begin({
-          projectId: finalProjectId,
-          runKind: "indexing",
-          eventId
-        });
-        if (beginOutcome.status === "busy") {
-          indexJobTracker.setResult(job.jobId, { filesIndexed: 0, chunksIndexed: 0, errors: 0, duration: 0 }, `indexing_busy:${beginOutcome.activeRunId}`);
-          return {
-            success: false,
-            error: `indexing_busy:${beginOutcome.activeRunId}`,
-            data: {
-              jobId: job.jobId,
-              projectId: finalProjectId,
-              status: "busy",
-              activeRunId: beginOutcome.activeRunId,
-              leaseExpiresAt: beginOutcome.leaseExpiresAt,
-              message: "Another indexing run is active for this project. Poll get_index_status(activeRunId)."
-            }
-          };
-        }
-        lease = beginOutcome.lease;
-      } catch (beginError) {
-        logger.error("managed_runs begin failed", beginError, { jobId: job.jobId, projectId: finalProjectId });
-        indexJobTracker.setResult(job.jobId, { filesIndexed: 0, chunksIndexed: 0, errors: 1, duration: 0 }, `managed_runs_begin_failed:${beginError.message}`);
+      const leaseOutcome = await acquireIndexingLease({
+        jobId: job.jobId,
+        projectId: finalProjectId
+      });
+      if (leaseOutcome.status === "busy") {
         return {
           success: false,
-          error: `Failed to acquire indexing lease: ${beginError.message}`
+          error: `indexing_busy:${leaseOutcome.activeRunId}`,
+          data: {
+            jobId: job.jobId,
+            projectId: finalProjectId,
+            status: "busy",
+            activeRunId: leaseOutcome.activeRunId,
+            leaseExpiresAt: leaseOutcome.leaseExpiresAt,
+            message: "Another indexing run is active for this project. Poll get_index_status(activeRunId)."
+          }
         };
       }
-      this.executeIndexing(job.jobId, finalProjectId, canonicalProjectPath, forceReindex, warmCache, warmupQueries, include_tests, lease).catch((error51) => {
+      if (leaseOutcome.status === "failed") {
+        return {
+          success: false,
+          error: `Failed to acquire indexing lease: ${leaseOutcome.message}`
+        };
+      }
+      const lease = leaseOutcome.lease;
+      executeIndexing({
+        jobId: job.jobId,
+        projectId: finalProjectId,
+        projectPath: canonicalProjectPath,
+        forceReindex,
+        warmCache,
+        warmupQueries,
+        include_tests,
+        managedRunLease: lease,
+        warmupCache: this.contextualSearch.warmupCache.bind(this.contextualSearch)
+      }).catch((error51) => {
         logger.error("Background indexing failed", error51, {
           jobId: job.jobId
         });
@@ -173030,68 +173123,6 @@ class IndexProjectTool {
       };
     }
   }
-  async executeIndexing(jobId, projectId, projectPath, forceReindex, warmCache, warmupQueries, include_tests = false, managedRunLease) {
-    const startTime = Date.now();
-    try {
-      indexJobTracker.updateStatus(jobId, "running");
-      logger.info("Starting project indexing via ETL Pipeline", {
-        jobId,
-        projectPath,
-        projectId,
-        forceReindex,
-        warmCache,
-        include_tests
-      });
-      const etlResult = await EtlPipeline.getInstance().run({
-        projectId,
-        projectPath,
-        jobId,
-        forceReindex,
-        include_tests,
-        managedRunLease
-      });
-      const duration3 = Date.now() - startTime;
-      logger.info("ETL Pipeline completed", {
-        jobId,
-        projectId,
-        duration: duration3,
-        filesIndexed: etlResult.filesIndexed,
-        filesSkipped: etlResult.filesSkipped,
-        chunksIndexed: etlResult.chunksIndexed,
-        symbolsIndexed: etlResult.symbolsIndexed,
-        errors: etlResult.errors,
-        stageTimings: etlResult.stageTimings
-      });
-      if (warmCache) {
-        logger.info("Starting cache warmup", { jobId, projectId });
-        const warmupStats = await this.contextualSearch.warmupCache(projectId, projectPath, warmupQueries);
-        logger.info("Cache warmup completed", { jobId, projectId, ...warmupStats });
-      }
-      indexJobTracker.updateProgress(jobId, etlResult.filesIndexed, etlResult.filesIndexed);
-      await indexJobTracker.setResultAndFlush(jobId, {
-        filesIndexed: etlResult.filesIndexed,
-        chunksIndexed: etlResult.chunksIndexed,
-        errors: etlResult.errors,
-        duration: duration3,
-        activatedGraphGenerationId: etlResult.activatedGraphGenerationId,
-        parserDiagnostics: etlResult.parserDiagnostics
-      });
-    } catch (error51) {
-      const duration3 = Date.now() - startTime;
-      logger.error("Project indexing failed", error51, {
-        jobId,
-        projectPath,
-        projectId,
-        duration: duration3
-      });
-      indexJobTracker.setResult(jobId, {
-        filesIndexed: 0,
-        chunksIndexed: 0,
-        errors: 1,
-        duration: duration3
-      }, error51.message);
-    }
-  }
 }
 // ../../packages/core/dist/tools/get_index_status.js
 init_index_job_tracker();
@@ -173570,17 +173601,17 @@ function applyReplacer(root, replacer) {
     return transformChildren(root, replacer, []);
   return transformChildren(normalizeValue(replacedRoot), replacer, []);
 }
-function transformChildren(value, replacer, path20) {
+function transformChildren(value, replacer, path21) {
   if (isJsonObject(value))
-    return transformObject(value, replacer, path20);
+    return transformObject(value, replacer, path21);
   if (isJsonArray(value))
-    return transformArray(value, replacer, path20);
+    return transformArray(value, replacer, path21);
   return value;
 }
-function transformObject(obj, replacer, path20) {
+function transformObject(obj, replacer, path21) {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
-    const childPath = [...path20, key];
+    const childPath = [...path21, key];
     const replacedValue = replacer(key, value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -173588,11 +173619,11 @@ function transformObject(obj, replacer, path20) {
   }
   return result;
 }
-function transformArray(arr, replacer, path20) {
+function transformArray(arr, replacer, path21) {
   const result = [];
   for (let i = 0;i < arr.length; i++) {
     const value = arr[i];
-    const childPath = [...path20, i];
+    const childPath = [...path21, i];
     const replacedValue = replacer(String(i), value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -174974,7 +175005,7 @@ init_db_connection();
 init_alias_resolver();
 import fs10 from "fs";
 import os3 from "os";
-import path20 from "path";
+import path21 from "path";
 
 // ../../packages/core/dist/services/hooks/session-pin-store.js
 var DEFAULT_MAX_SIZE = 1000;
@@ -175076,7 +175107,7 @@ class AttributionResolver {
     this.pins = options.pins ?? new SessionPinStore;
     this.canonicalize = options.canonicalize ?? defaultCanonicalize;
     this.homedir = options.homedir ?? os3.homedir;
-    this.fsRoot = options.fsRoot ?? (() => path20.parse(path20.sep).root);
+    this.fsRoot = options.fsRoot ?? (() => path21.parse(path21.sep).root);
   }
   async resolve(input) {
     const caller = input.callerProjectId;
@@ -175129,7 +175160,7 @@ class AttributionResolver {
     }
     let bestPath = null;
     for (const candidate2 of byPath.keys()) {
-      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path20.sep) ? candidate2 : candidate2 + path20.sep)) {
+      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path21.sep) ? candidate2 : candidate2 + path21.sep)) {
         if (bestPath === null || candidate2.length > bestPath.length) {
           bestPath = candidate2;
         }
@@ -175152,7 +175183,7 @@ class AttributionResolver {
       return projectPath2;
     const fsRoot = this.fsRoot();
     let normalized = projectPath2;
-    while (normalized.length > fsRoot.length && normalized.endsWith(path20.sep)) {
+    while (normalized.length > fsRoot.length && normalized.endsWith(path21.sep)) {
       normalized = normalized.slice(0, -1);
     }
     return normalized;
@@ -175163,7 +175194,7 @@ function defaultCanonicalize(cwd) {
     return fs10.realpathSync(cwd);
   } catch {
     try {
-      return path20.resolve(cwd);
+      return path21.resolve(cwd);
     } catch {
       return;
     }
@@ -175176,6 +175207,69 @@ function getAttributionResolver() {
   return sharedResolver2;
 }
 
+// ../../packages/core/dist/kernel/sanitize/credential-scrub.js
+function markerFor(id) {
+  return `[REDACTED:${id}]`;
+}
+function fullMatchRule(id, pattern) {
+  const marker26 = markerFor(id);
+  return {
+    id,
+    replace(text3) {
+      let count = 0;
+      const replaced = text3.replace(pattern, () => {
+        count++;
+        return marker26;
+      });
+      return { text: replaced, count };
+    }
+  };
+}
+var PEM_PATTERN = /-----BEGIN [A-Z ]{0,32}PRIVATE KEY-----[\s\S]{0,8192}?-----END [A-Z ]{0,32}PRIVATE KEY-----/g;
+var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g;
+var AWS_KEY_PATTERN = /\b(?:AKIA|ASIA|ABIA|ACCA)[A-Z0-9]{16}\b/g;
+var SK_KEY_PATTERN = /\bsk-[A-Za-z0-9_-]{20,}\b/g;
+var GITHUB_TOKEN_PATTERN = /\bgh[pousr]_[A-Za-z0-9]{36,}\b|\bgithub_pat_[A-Za-z0-9_]{22,}\b/g;
+var SLACK_TOKEN_PATTERN = /\bxox[baprs]-[A-Za-z0-9-]{18,}\b/g;
+var BEARER_PATTERN = /(Bearer\s+)([A-Za-z0-9._~+/=-]{20,})/g;
+var RULES = [
+  fullMatchRule("pem", PEM_PATTERN),
+  fullMatchRule("jwt", JWT_PATTERN),
+  fullMatchRule("aws-key", AWS_KEY_PATTERN),
+  fullMatchRule("sk-key", SK_KEY_PATTERN),
+  fullMatchRule("github-token", GITHUB_TOKEN_PATTERN),
+  fullMatchRule("slack-token", SLACK_TOKEN_PATTERN),
+  {
+    id: "bearer",
+    replace(text3) {
+      let count = 0;
+      const replaced = text3.replace(BEARER_PATTERN, (_m, prefix) => {
+        count++;
+        return `${prefix}${markerFor("bearer")}`;
+      });
+      return { text: replaced, count };
+    }
+  }
+];
+var RULE_IDS = RULES.map((r2) => r2.id);
+function scrubCredentials(payloadJson) {
+  const redactions = {};
+  for (const id of RULE_IDS)
+    redactions[id] = 0;
+  let text3 = payloadJson;
+  for (const rule of RULES) {
+    const { text: next, count } = rule.replace(text3);
+    text3 = next;
+    redactions[rule.id] += count;
+  }
+  const total = Object.values(redactions).reduce((sum, n2) => sum + n2, 0);
+  return {
+    sanitized: text3,
+    redactions,
+    total
+  };
+}
+
 // ../../packages/core/dist/tools/compact_snapshot.js
 class CompactSnapshotTool {
   name = "compact_snapshot";
@@ -175227,19 +175321,26 @@ class CompactSnapshotTool {
         persistedId = newObservationId();
         try {
           const attribution = await (this.resolverOverride ?? getAttributionResolver()).resolve({ callerProjectId: projectId, sessionId, cwd });
+          const scrub = scrubCredentials(JSON.stringify({
+            snapshot: snapshot.xml,
+            eventCount: snapshot.eventCount,
+            compactCount: snapshot.compactCount,
+            generatedAt: snapshot.generatedAt,
+            sectionCount: snapshot.sections.length
+          }));
+          if (scrub.total > 0) {
+            logger.debug("compact_snapshot payload redacted before persist", {
+              redactions: scrub.redactions,
+              total: scrub.total
+            });
+          }
           store4.insert({
             id: persistedId,
             projectId: attribution.projectId,
             sessionId,
             source: "pre-compact",
             category: "compaction-snapshots",
-            payloadJson: JSON.stringify({
-              snapshot: snapshot.xml,
-              eventCount: snapshot.eventCount,
-              compactCount: snapshot.compactCount,
-              generatedAt: snapshot.generatedAt,
-              sectionCount: snapshot.sections.length
-            }),
+            payloadJson: scrub.sanitized,
             importance: 0.8,
             createdAt: Date.now(),
             attributionSource: attribution.source
@@ -175684,310 +175785,22 @@ class GetArchitectureTool {
 }
 // ../../packages/core/dist/tools/read_file.js
 init_dist();
+
+// ../../packages/core/dist/services/file-read/read-file.service.js
 init_dist();
 init_code_compressor();
-init_event_bus();
-init_workspace_manager();
+
+// ../../packages/core/dist/services/file-read/file-content-cache.js
+init_dist();
 import fs11 from "fs/promises";
-import path21 from "path";
-var MASSA_AI_READ_FILE_MAX_LINES = (() => {
-  const v = Number(process.env.MASSA_AI_READ_FILE_MAX_LINES);
-  return Number.isFinite(v) && v > 0 ? Math.floor(v) : 500;
-})();
 
-class ReadFileTool {
-  name = "read_file";
-  description = "Read file with automatic compression, caching, and symbol metadata. " + "Use with search results for 60% token savings.";
-  inputSchema = {
-    type: "object",
-    properties: {
-      filePath: {
-        type: "string",
-        description: "File path (absolute or relative to project root)"
-      },
-      projectId: {
-        type: "string",
-        description: "Project ID for symbol metadata (optional)"
-      },
-      offset: {
-        type: "number",
-        description: "Start line number (1-indexed)"
-      },
-      limit: {
-        type: "number",
-        description: "Number of lines to read"
-      },
-      lineStart: {
-        type: "number",
-        description: "Start line (alternative to offset)"
-      },
-      lineEnd: {
-        type: "number",
-        description: "End line (alternative to limit)"
-      },
-      compress: {
-        type: "boolean",
-        description: "Auto-compress content > 100 lines (default: true)",
-        default: true
-      },
-      targetRatio: {
-        type: "number",
-        description: "Compression target ratio (0.3 = 70% reduction)",
-        default: 0.3
-      },
-      format: {
-        type: "string",
-        enum: ["json", "toon"],
-        description: "Output format",
-        default: "json"
-      },
-      fields: {
-        type: "array",
-        items: { type: "string" },
-        description: "Projection \u2014 keep only these keys (dotted paths supported, e.g. ['nodes.symbol']). Absent/empty \u2192 full data."
-      },
-      includeSymbols: {
-        type: "boolean",
-        description: "Include symbol metadata from graph (default: true)",
-        default: true
-      },
-      includeImports: {
-        type: "boolean",
-        description: "Extract and show import statements (default: true)",
-        default: true
-      }
-    },
-    required: ["filePath"]
-  };
-  compressor;
-  symbolGraph;
+class FileContentCache {
+  extractMetadata;
   fileCache = new Map;
-  projectRootCache = new Map;
   CACHE_TTL = 60000;
-  ROOT_CACHE_TTL = 300000;
   FILE_CACHE_MAX_ENTRIES = 512;
-  constructor(symbolGraph) {
-    this.compressor = new CodeCompressor;
-    this.symbolGraph = symbolGraph;
-    eventBus.subscribe("indexing:started", ({ projectId, projectPath: projectPath2 }) => {
-      this.projectRootCache.delete(projectId);
-      this.evictOldest(this.projectRootCache);
-      this.projectRootCache.set(projectId, projectPath2);
-    });
-  }
-  async handle(params) {
-    const p = params;
-    const shouldCompress = p.compress !== false;
-    const targetRatio = p.targetRatio || 0.3;
-    const format = p.format || "json";
-    const { fields } = p;
-    const includeSymbols = p.includeSymbols !== false;
-    const includeImports = p.includeImports !== false;
-    try {
-      const resolved = await this.resolveFilePath(p.filePath, p.projectId);
-      if (resolved === null) {
-        return {
-          success: false,
-          error: "Relative filePath requires a projectId (to resolve against the workspace) or an absolute path."
-        };
-      }
-      const filePath = resolved;
-      const containment = await this.checkPathContainment(filePath, p.projectId);
-      if (!containment.allowed) {
-        return {
-          success: false,
-          error: containment.error
-        };
-      }
-      const relativePath = p.filePath;
-      const range = this.calculateRange(p);
-      const { content, metadata } = await this.readFileWithCache(filePath, {
-        includeSymbols,
-        includeImports,
-        projectId: p.projectId,
-        relativePath
-      });
-      const lines = content.split(`
-`);
-      const totalLines = lines.length;
-      const adjustedRange = this.adjustRange(range, totalLines);
-      let selectedContent = this.extractLines(lines, adjustedRange);
-      let selectedLineCount = selectedContent.split(`
-`).length;
-      let source_clipped = false;
-      if (selectedLineCount > MASSA_AI_READ_FILE_MAX_LINES) {
-        const cappedLines = lines.slice(adjustedRange.start - 1, adjustedRange.start - 1 + MASSA_AI_READ_FILE_MAX_LINES);
-        selectedContent = cappedLines.join(`
-`);
-        selectedLineCount = selectedContent.split(`
-`).length;
-        source_clipped = true;
-      }
-      const shouldAutoCompress = shouldCompress && selectedLineCount > 100 && targetRatio < 1;
-      const result = {
-        filePath: p.filePath,
-        absolutePath: filePath,
-        lineRange: {
-          requested: {
-            start: range.start,
-            end: range.end === Infinity ? null : range.end
-          },
-          actual: {
-            start: adjustedRange.start,
-            end: source_clipped ? adjustedRange.start + selectedLineCount - 1 : adjustedRange.end,
-            total: totalLines
-          },
-          selected: selectedLineCount
-        },
-        source_clipped,
-        metadata: {
-          totalLines,
-          language: metadata.language,
-          ...metadata.symbols && { symbols: metadata.symbols },
-          ...metadata.imports && { imports: metadata.imports }
-        },
-        compressed: shouldAutoCompress,
-        recommendations: []
-      };
-      if (shouldAutoCompress) {
-        const compressed = await this.compressor.compress(selectedContent, "code_structure");
-        const originalTokens = estimateTokens(selectedContent, "code");
-        const compressedTokens = estimateTokens(compressed.compressed, "code");
-        const actualRatio = compressedTokens / originalTokens;
-        result.content = compressed.compressed;
-        result.tokens = {
-          original: originalTokens,
-          compressed: compressedTokens,
-          saved: originalTokens - compressedTokens,
-          savingsPercent: Math.round((1 - actualRatio) * 100)
-        };
-        result.compressionRatio = actualRatio;
-        result.recommendations.push(`\u2713 Auto-compressed ${selectedLineCount} lines (${result.tokens.savingsPercent}% reduction)`);
-      } else {
-        result.content = selectedContent;
-        result.tokens = {
-          original: estimateTokens(selectedContent, "code"),
-          compressed: estimateTokens(selectedContent, "code"),
-          saved: 0,
-          savingsPercent: 0
-        };
-        if (selectedLineCount > 100) {
-          result.recommendations.push("\uD83D\uDCA1 Content > 100 lines. Consider compress=true for token savings");
-        }
-      }
-      if (range.start === 1 && range.end === Infinity) {
-        result.recommendations.push("\uD83D\uDCA1 Use lineStart/lineEnd or offset/limit to read specific sections (60% token savings)");
-      }
-      if (metadata.symbols && metadata.symbols.definitions > 0) {
-        result.recommendations.push(`\uD83D\uDCA1 Use get_references() to find usages of ${metadata.symbols.definitions} symbols in this file`);
-      }
-      return serializeToolResponse(result, { format, fields });
-    } catch (error51) {
-      logger.error("Failed to read file", error51, {
-        filePath: p.filePath
-      });
-      return {
-        success: false,
-        error: `Failed to read file: ${error51.message}`
-      };
-    }
-  }
-  async resolveFilePath(filePath, projectId) {
-    if (path21.isAbsolute(filePath)) {
-      return path21.resolve(filePath);
-    }
-    if (projectId) {
-      const root = await this.getProjectRoot(projectId);
-      if (root) {
-        const cleaned = sanitizeFilePath(filePath);
-        return path21.resolve(root, cleaned);
-      }
-      return null;
-    }
-    return null;
-  }
-  async checkPathContainment(absoluteFilePath, projectId) {
-    const roots = [];
-    if (projectId) {
-      const root = await this.getProjectRoot(projectId);
-      if (root)
-        roots.push(path21.resolve(root));
-    }
-    roots.push(path21.resolve(process.cwd()));
-    const envRoots = (process.env.MASSA_AI_READ_FILE_ROOTS ?? "").split(":").map((s) => s.trim()).filter((s) => s.length > 0);
-    for (const extra of envRoots) {
-      roots.push(path21.resolve(extra));
-    }
-    const target = path21.resolve(absoluteFilePath);
-    for (const root of roots) {
-      const rel = path21.relative(root, target);
-      if (rel !== "" && !rel.startsWith("..") && !path21.isAbsolute(rel)) {
-        return { allowed: true };
-      }
-      if (rel === "")
-        return { allowed: true };
-    }
-    const validRootsList = roots.map((r2) => `  - ${r2}`).join(`
-`);
-    return {
-      allowed: false,
-      error: `read_file path containment: "${target}" is outside the allowed roots.
-` + `Valid roots (project root + cwd + MASSA_AI_READ_FILE_ROOTS):
-${validRootsList}
-` + `Provide a filePath that resolves under one of these roots.`
-    };
-  }
-  async getProjectRoot(projectId) {
-    const cached2 = this.projectRootCache.get(projectId);
-    if (cached2 !== undefined) {
-      this.projectRootCache.delete(projectId);
-      this.projectRootCache.set(projectId, cached2);
-      return cached2;
-    }
-    try {
-      const workspace = await workspaceManager.getWorkspace(projectId);
-      if (workspace?.project_path) {
-        this.evictOldest(this.projectRootCache);
-        this.projectRootCache.set(projectId, workspace.project_path);
-        return workspace.project_path;
-      }
-    } catch (error51) {
-      logger.warn("Failed to look up project root", { projectId, error: error51.message });
-    }
-    return null;
-  }
-  evictOldest(cache) {
-    while (cache.size >= this.FILE_CACHE_MAX_ENTRIES) {
-      const oldest = cache.keys().next().value;
-      if (oldest === undefined)
-        break;
-      cache.delete(oldest);
-    }
-  }
-  calculateRange(params) {
-    if (params.lineStart !== undefined && params.lineEnd !== undefined) {
-      return {
-        start: Math.max(1, params.lineStart),
-        end: params.lineEnd
-      };
-    }
-    if (params.offset !== undefined) {
-      const offset = Math.max(1, params.offset);
-      const limit = params.limit || 1000;
-      return {
-        start: offset,
-        end: offset + limit - 1
-      };
-    }
-    return {
-      start: 1,
-      end: Infinity
-    };
-  }
-  adjustRange(range, totalLines) {
-    const start = Math.max(1, Math.min(range.start, totalLines));
-    const end = range.end === Infinity ? totalLines : Math.min(range.end, totalLines);
-    return { start, end };
+  constructor(extractMetadata) {
+    this.extractMetadata = extractMetadata;
   }
   async readFileWithCache(filePath, options) {
     const cacheKey = JSON.stringify({
@@ -176014,7 +175827,7 @@ ${validRootsList}
     }
     const content = await fs11.readFile(filePath, "utf-8");
     const metadata = await this.extractMetadata(content, filePath, options);
-    this.evictOldest(this.fileCache);
+    evictOldest(this.fileCache, this.FILE_CACHE_MAX_ENTRIES - 1);
     this.fileCache.set(cacheKey, {
       content,
       timestamp: Date.now(),
@@ -176023,6 +175836,17 @@ ${validRootsList}
     logger.debug("File read and cached", { filePath });
     return { content, metadata };
   }
+}
+
+// ../../packages/core/dist/services/file-read/file-metadata.js
+init_dist();
+import path22 from "path";
+
+class FileMetadataExtractor {
+  symbolGraph;
+  constructor(symbolGraph) {
+    this.symbolGraph = symbolGraph;
+  }
   async extractMetadata(content, filePath, options) {
     const lines = content.split(`
 `);
@@ -176051,18 +175875,8 @@ ${validRootsList}
     }
     return metadata;
   }
-  extractLines(lines, range) {
-    const start = range.start - 1;
-    const end = range.end;
-    const selectedLines = lines.slice(start, end);
-    return selectedLines.map((line, index) => {
-      const lineNum = start + index + 1;
-      return `${lineNum.toString().padStart(6, " ")}: ${line}`;
-    }).join(`
-`);
-  }
   detectLanguage(filePath) {
-    const ext2 = path21.extname(filePath).toLowerCase();
+    const ext2 = path22.extname(filePath).toLowerCase();
     const languageMap2 = {
       ".ts": "TypeScript",
       ".tsx": "TypeScript",
@@ -176120,6 +175934,366 @@ ${validRootsList}
     return imports;
   }
 }
+
+// ../../packages/core/dist/services/file-read/line-range.js
+var MASSA_AI_READ_FILE_MAX_LINES = (() => {
+  const v = Number(process.env.MASSA_AI_READ_FILE_MAX_LINES);
+  return Number.isFinite(v) && v > 0 ? Math.floor(v) : 500;
+})();
+function calculateRange(params) {
+  if (params.lineStart !== undefined && params.lineEnd !== undefined) {
+    return {
+      start: Math.max(1, params.lineStart),
+      end: params.lineEnd
+    };
+  }
+  if (params.offset !== undefined) {
+    const offset = Math.max(1, params.offset);
+    const limit = params.limit || 1000;
+    return {
+      start: offset,
+      end: offset + limit - 1
+    };
+  }
+  return {
+    start: 1,
+    end: Infinity
+  };
+}
+function adjustRange(range, totalLines) {
+  const start = Math.max(1, Math.min(range.start, totalLines));
+  const end = range.end === Infinity ? totalLines : Math.min(range.end, totalLines);
+  return { start, end };
+}
+function extractLines(lines, range) {
+  const start = range.start - 1;
+  const end = range.end;
+  const selectedLines = lines.slice(start, end);
+  return selectedLines.map((line, index) => {
+    const lineNum = start + index + 1;
+    return `${lineNum.toString().padStart(6, " ")}: ${line}`;
+  }).join(`
+`);
+}
+function selectLines(lines, range) {
+  let content = extractLines(lines, range);
+  let lineCount = content.split(`
+`).length;
+  let clipped = false;
+  if (lineCount > MASSA_AI_READ_FILE_MAX_LINES) {
+    const cappedLines = lines.slice(range.start - 1, range.start - 1 + MASSA_AI_READ_FILE_MAX_LINES);
+    content = cappedLines.join(`
+`);
+    lineCount = content.split(`
+`).length;
+    clipped = true;
+  }
+  return { content, lineCount, clipped };
+}
+
+// ../../packages/core/dist/services/file-read/path-containment.js
+init_dist();
+import path23 from "path";
+
+class PathContainment {
+  projectRoots;
+  constructor(projectRoots) {
+    this.projectRoots = projectRoots;
+  }
+  async resolveFilePath(filePath, projectId) {
+    if (path23.isAbsolute(filePath)) {
+      return path23.resolve(filePath);
+    }
+    if (projectId) {
+      const root = await this.projectRoots.getProjectRoot(projectId);
+      if (root) {
+        const cleaned = sanitizeFilePath(filePath);
+        return path23.resolve(root, cleaned);
+      }
+      return null;
+    }
+    return null;
+  }
+  async checkPathContainment(absoluteFilePath, projectId) {
+    const roots = [];
+    if (projectId) {
+      const root = await this.projectRoots.getProjectRoot(projectId);
+      if (root)
+        roots.push(path23.resolve(root));
+    }
+    roots.push(path23.resolve(process.cwd()));
+    const envRoots = (process.env.MASSA_AI_READ_FILE_ROOTS ?? "").split(":").map((s) => s.trim()).filter((s) => s.length > 0);
+    for (const extra of envRoots) {
+      roots.push(path23.resolve(extra));
+    }
+    const target = path23.resolve(absoluteFilePath);
+    for (const root of roots) {
+      const rel = path23.relative(root, target);
+      if (rel !== "" && !rel.startsWith("..") && !path23.isAbsolute(rel)) {
+        return { allowed: true };
+      }
+      if (rel === "")
+        return { allowed: true };
+    }
+    const validRootsList = roots.map((r2) => `  - ${r2}`).join(`
+`);
+    return {
+      allowed: false,
+      error: `read_file path containment: "${target}" is outside the allowed roots.
+` + `Valid roots (project root + cwd + MASSA_AI_READ_FILE_ROOTS):
+${validRootsList}
+` + `Provide a filePath that resolves under one of these roots.`
+    };
+  }
+}
+
+// ../../packages/core/dist/services/file-read/project-root-cache.js
+init_dist();
+init_event_bus();
+init_workspace_manager();
+
+class ProjectRootCache {
+  projectRootCache = new Map;
+  ROOT_CACHE_TTL = 300000;
+  PROJECT_ROOT_CACHE_MAX_ENTRIES = 512;
+  constructor() {
+    eventBus.subscribe("indexing:started", ({ projectId, projectPath: projectPath2 }) => {
+      this.projectRootCache.delete(projectId);
+      evictOldest(this.projectRootCache, this.PROJECT_ROOT_CACHE_MAX_ENTRIES - 1);
+      this.projectRootCache.set(projectId, projectPath2);
+    });
+  }
+  async getProjectRoot(projectId) {
+    const cached2 = this.projectRootCache.get(projectId);
+    if (cached2 !== undefined) {
+      this.projectRootCache.delete(projectId);
+      this.projectRootCache.set(projectId, cached2);
+      return cached2;
+    }
+    try {
+      const workspace = await workspaceManager.getWorkspace(projectId);
+      if (workspace?.project_path) {
+        evictOldest(this.projectRootCache, this.PROJECT_ROOT_CACHE_MAX_ENTRIES - 1);
+        this.projectRootCache.set(projectId, workspace.project_path);
+        return workspace.project_path;
+      }
+    } catch (error51) {
+      logger.warn("Failed to look up project root", { projectId, error: error51.message });
+    }
+    return null;
+  }
+}
+
+// ../../packages/core/dist/services/file-read/read-file.service.js
+function readFileOptions(p) {
+  const shouldCompress = p.compress !== false;
+  const targetRatio = p.targetRatio || 0.3;
+  const format = p.format || "json";
+  const { fields } = p;
+  const includeSymbols = p.includeSymbols !== false;
+  const includeImports = p.includeImports !== false;
+  return { shouldCompress, targetRatio, format, fields, includeSymbols, includeImports };
+}
+
+class ReadFileService {
+  compressor;
+  symbolGraph;
+  projectRoots;
+  pathContainment;
+  fileMetadata;
+  fileContent;
+  constructor(symbolGraph) {
+    this.compressor = new CodeCompressor;
+    this.symbolGraph = symbolGraph;
+    this.projectRoots = new ProjectRootCache;
+    this.pathContainment = new PathContainment(this.projectRoots);
+    this.fileMetadata = new FileMetadataExtractor(symbolGraph);
+    this.fileContent = new FileContentCache((content, filePath, options) => this.fileMetadata.extractMetadata(content, filePath, options));
+  }
+  async read(p, options) {
+    const { shouldCompress, targetRatio, includeSymbols, includeImports } = options;
+    const resolved = await this.pathContainment.resolveFilePath(p.filePath, p.projectId);
+    if (resolved === null) {
+      return {
+        ok: false,
+        error: "Relative filePath requires a projectId (to resolve against the workspace) or an absolute path."
+      };
+    }
+    const filePath = resolved;
+    const containment = await this.pathContainment.checkPathContainment(filePath, p.projectId);
+    if (!containment.allowed) {
+      return {
+        ok: false,
+        error: containment.error
+      };
+    }
+    const relativePath = p.filePath;
+    const range = calculateRange(p);
+    const { content, metadata } = await this.fileContent.readFileWithCache(filePath, {
+      includeSymbols,
+      includeImports,
+      projectId: p.projectId,
+      relativePath
+    });
+    const lines = content.split(`
+`);
+    const totalLines = lines.length;
+    const adjustedRange = adjustRange(range, totalLines);
+    const { content: selectedContent, lineCount: selectedLineCount, clipped: source_clipped } = selectLines(lines, adjustedRange);
+    const shouldAutoCompress = shouldCompress && selectedLineCount > 100 && targetRatio < 1;
+    const result = {
+      filePath: p.filePath,
+      absolutePath: filePath,
+      lineRange: {
+        requested: {
+          start: range.start,
+          end: range.end === Infinity ? null : range.end
+        },
+        actual: {
+          start: adjustedRange.start,
+          end: source_clipped ? adjustedRange.start + selectedLineCount - 1 : adjustedRange.end,
+          total: totalLines
+        },
+        selected: selectedLineCount
+      },
+      source_clipped,
+      metadata: {
+        totalLines,
+        language: metadata.language,
+        ...metadata.symbols && { symbols: metadata.symbols },
+        ...metadata.imports && { imports: metadata.imports }
+      },
+      compressed: shouldAutoCompress,
+      recommendations: []
+    };
+    if (shouldAutoCompress) {
+      const compressed = await this.compressor.compress(selectedContent, "code_structure");
+      const originalTokens = estimateTokens(selectedContent, "code");
+      const compressedTokens = estimateTokens(compressed.compressed, "code");
+      const actualRatio = compressedTokens / originalTokens;
+      result.content = compressed.compressed;
+      result.tokens = {
+        original: originalTokens,
+        compressed: compressedTokens,
+        saved: originalTokens - compressedTokens,
+        savingsPercent: Math.round((1 - actualRatio) * 100)
+      };
+      result.compressionRatio = actualRatio;
+      result.recommendations.push(`\u2713 Auto-compressed ${selectedLineCount} lines (${result.tokens.savingsPercent}% reduction)`);
+    } else {
+      result.content = selectedContent;
+      result.tokens = {
+        original: estimateTokens(selectedContent, "code"),
+        compressed: estimateTokens(selectedContent, "code"),
+        saved: 0,
+        savingsPercent: 0
+      };
+      if (selectedLineCount > 100) {
+        result.recommendations.push("\uD83D\uDCA1 Content > 100 lines. Consider compress=true for token savings");
+      }
+    }
+    if (range.start === 1 && range.end === Infinity) {
+      result.recommendations.push("\uD83D\uDCA1 Use lineStart/lineEnd or offset/limit to read specific sections (60% token savings)");
+    }
+    if (metadata.symbols && metadata.symbols.definitions > 0) {
+      result.recommendations.push(`\uD83D\uDCA1 Use get_references() to find usages of ${metadata.symbols.definitions} symbols in this file`);
+    }
+    return { ok: true, data: result };
+  }
+}
+
+// ../../packages/core/dist/tools/read_file.js
+class ReadFileTool {
+  name = "read_file";
+  description = "Read file with automatic compression, caching, and symbol metadata. " + "Use with search results for 60% token savings.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      filePath: {
+        type: "string",
+        description: "File path (absolute or relative to project root)"
+      },
+      projectId: {
+        type: "string",
+        description: "Project ID for symbol metadata (optional)"
+      },
+      offset: {
+        type: "number",
+        description: "Start line number (1-indexed)"
+      },
+      limit: {
+        type: "number",
+        description: "Number of lines to read"
+      },
+      lineStart: {
+        type: "number",
+        description: "Start line (alternative to offset)"
+      },
+      lineEnd: {
+        type: "number",
+        description: "End line (alternative to limit)"
+      },
+      compress: {
+        type: "boolean",
+        description: "Auto-compress content > 100 lines (default: true)",
+        default: true
+      },
+      targetRatio: {
+        type: "number",
+        description: "Compression target ratio (0.3 = 70% reduction)",
+        default: 0.3
+      },
+      format: {
+        type: "string",
+        enum: ["json", "toon"],
+        description: "Output format",
+        default: "json"
+      },
+      fields: {
+        type: "array",
+        items: { type: "string" },
+        description: "Projection \u2014 keep only these keys (dotted paths supported, e.g. ['nodes.symbol']). Absent/empty \u2192 full data."
+      },
+      includeSymbols: {
+        type: "boolean",
+        description: "Include symbol metadata from graph (default: true)",
+        default: true
+      },
+      includeImports: {
+        type: "boolean",
+        description: "Extract and show import statements (default: true)",
+        default: true
+      }
+    },
+    required: ["filePath"]
+  };
+  service;
+  constructor(symbolGraph) {
+    this.service = new ReadFileService(symbolGraph);
+  }
+  async handle(params) {
+    const p = params;
+    const options = readFileOptions(p);
+    try {
+      const outcome2 = await this.service.read(p, options);
+      if (!outcome2.ok) {
+        return { success: false, error: outcome2.error };
+      }
+      return serializeToolResponse(outcome2.data, {
+        format: options.format,
+        fields: options.fields
+      });
+    } catch (error51) {
+      logger.error("Failed to read file", error51, {
+        filePath: p.filePath
+      });
+      return {
+        success: false,
+        error: `Failed to read file: ${error51.message}`
+      };
+    }
+  }
+}
 // ../../packages/core/dist/tools/execute.js
 class ExecuteTool {
   name = "execute";
@@ -176594,13 +176768,20 @@ class HookService {
     });
     const id = this.idFactory();
     this.queue.enqueue(async () => {
+      const scrub = scrubCredentials(JSON.stringify(ev.payload));
+      if (scrub.total > 0) {
+        logger.debug("hook payload redacted before persist", {
+          redactions: scrub.redactions,
+          total: scrub.total
+        });
+      }
       const obs = {
         id,
         projectId: attribution.projectId,
         sessionId: ev.sessionId,
         source: ev.event,
         category: extractCategory(ev.event, ev.payload),
-        payloadJson: JSON.stringify(ev.payload),
+        payloadJson: scrub.sanitized,
         importance: ev.importance,
         createdAt: ev.ts,
         agentId: ev.agentId,
@@ -176684,7 +176865,7 @@ init_llm_client();
 init_symbol_graph_service();
 import { randomUUID as randomUUID9 } from "crypto";
 import fs14 from "fs";
-import path24 from "path";
+import path26 from "path";
 import { spawn as spawn2 } from "child_process";
 var FALLBACK_BOOTSTRAP = {
   enabled: true,
@@ -176868,7 +177049,7 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of README_CANDIDATES) {
-      const p = path24.join(projectRoot, name26);
+      const p = path26.join(projectRoot, name26);
       if (fs14.existsSync(p) && fs14.statSync(p).isFile()) {
         const buf = fs14.readFileSync(p);
         signals.readme = buf.slice(0, MAX_README_BYTES).toString("utf8");
@@ -176879,14 +177060,14 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
     logger.debug("bootstrap scan: README read failed", { error: e.message });
   }
   try {
-    const docsDir = path24.join(projectRoot, "docs");
+    const docsDir = path26.join(projectRoot, "docs");
     if (fs14.existsSync(docsDir) && fs14.statSync(docsDir).isDirectory()) {
       const entries = walkMarkdown(docsDir).slice(0, MAX_DOCS);
       for (const rel of entries) {
         try {
           const buf = fs14.readFileSync(rel);
           signals.docs.push({
-            path: path24.relative(projectRoot, rel),
+            path: path26.relative(projectRoot, rel),
             snippet: buf.slice(0, MAX_DOC_BYTES).toString("utf8")
           });
         } catch {}
@@ -176897,7 +177078,7 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of MANIFEST_FILES) {
-      const p = path24.join(projectRoot, name26);
+      const p = path26.join(projectRoot, name26);
       if (!fs14.existsSync(p) || !fs14.statSync(p).isFile())
         continue;
       const raw2 = fs14.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
@@ -176945,7 +177126,7 @@ function walkMarkdown(dir) {
       continue;
     }
     for (const e of entries) {
-      const full = path24.join(cur, e.name);
+      const full = path26.join(cur, e.name);
       if (e.isDirectory()) {
         if (e.name === "node_modules" || e.name.startsWith("."))
           continue;
@@ -177979,7 +178160,7 @@ var checkpointRoutes = new Elysia({ prefix: "/api/v1/checkpoints" }).post("/list
 // src/routes/project.ts
 init_dist();
 import fs15 from "fs/promises";
-import path25 from "path";
+import path27 from "path";
 var indexProjectTool = null;
 var indexStatusTool = null;
 var projectIdentityService = null;
@@ -178188,21 +178369,21 @@ var projectRoutes = new Elysia({ prefix: "/api/v1/project" }).get("/list", async
 }).post("/upload-and-index", async ({ body }) => {
   const rawBase = body.projectId || body.projectPath.replace(/\\/g, "/").split("/").filter(Boolean).pop() || "default";
   const finalProjectId = rawBase.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 128);
-  const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path25.join(getGlobalDataDir(), "uploads");
-  const stagingDir = path25.resolve(uploadRoot, finalProjectId);
+  const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path27.join(getGlobalDataDir(), "uploads");
+  const stagingDir = path27.resolve(uploadRoot, finalProjectId);
   await fs15.rm(stagingDir, { recursive: true, force: true });
   await fs15.mkdir(stagingDir, { recursive: true });
   const WRITE_BATCH = 20;
   for (let i = 0;i < body.files.length; i += WRITE_BATCH) {
     await Promise.all(body.files.slice(i, i + WRITE_BATCH).map(async (file3) => {
-      if (path25.isAbsolute(file3.relativePath) || file3.relativePath.includes("..")) {
+      if (path27.isAbsolute(file3.relativePath) || file3.relativePath.includes("..")) {
         throw new Error(`Invalid file path: ${file3.relativePath}`);
       }
-      const dest = path25.resolve(stagingDir, file3.relativePath.replace(/\//g, path25.sep));
-      if (!dest.startsWith(stagingDir + path25.sep)) {
+      const dest = path27.resolve(stagingDir, file3.relativePath.replace(/\//g, path27.sep));
+      if (!dest.startsWith(stagingDir + path27.sep)) {
         throw new Error(`Path escapes staging directory: ${file3.relativePath}`);
       }
-      await fs15.mkdir(path25.dirname(dest), { recursive: true });
+      await fs15.mkdir(path27.dirname(dest), { recursive: true });
       await fs15.writeFile(dest, file3.content, "utf-8");
     }));
   }
@@ -178357,7 +178538,7 @@ var analyticsRoutes = new Elysia({ prefix: "/api/v1/analytics" }).post("/", asyn
 
 // src/routes/system.ts
 init_dist();
-import path26 from "path";
+import path28 from "path";
 import fs16 from "fs";
 import os4 from "os";
 function databaseUrlParts() {
@@ -178432,7 +178613,7 @@ var systemRoutes = new Elysia({ prefix: "/api/v1/system" }).get("/info", async (
     description: "Check PostgreSQL, pgvector, Ollama, and local artifact directory health"
   }
 }).get("/metrics", async () => {
-  const metricsPath = path26.join(process.cwd(), "data", "metrics.json");
+  const metricsPath = path28.join(process.cwd(), "data", "metrics.json");
   let metrics2 = {};
   if (fs16.existsSync(metricsPath)) {
     try {
@@ -178587,7 +178768,7 @@ var eventsRoutes = new Elysia({ prefix: "/api/v1" }).get("/events", async ({ que
 
 // src/routes/workspace.ts
 import fs17 from "fs/promises";
-import path27 from "path";
+import path29 from "path";
 import { realpathSync as realpathSync4 } from "fs";
 var indexProjectTool2 = null;
 function getIndexProjectTool2() {
@@ -178629,7 +178810,7 @@ function realpathSafe(p) {
   try {
     return realpathSync4(p);
   } catch {
-    return path27.resolve(p);
+    return path29.resolve(p);
   }
 }
 var graphController = null;
@@ -178980,8 +179161,8 @@ var workspaceRoutes = new Elysia({ prefix: "/api/v1" }).get("/workspace/list", a
     }
     const registeredRoot = realpathSafe(workspace.project_path);
     const callerRoot = realpathSafe(projectPath2);
-    const rel = path27.relative(registeredRoot, callerRoot);
-    const escapes = rel.startsWith("..") || path27.isAbsolute(rel);
+    const rel = path29.relative(registeredRoot, callerRoot);
+    const escapes = rel.startsWith("..") || path29.isAbsolute(rel);
     if (registeredRoot !== callerRoot && escapes) {
       return {
         success: false,
@@ -179111,7 +179292,7 @@ var workspaceRoutes = new Elysia({ prefix: "/api/v1" }).get("/workspace/list", a
     } else {
       end = start + 20;
     }
-    const absolutePath = path27.join(workspace.project_path, file3);
+    const absolutePath = path29.join(workspace.project_path, file3);
     const content = await fs17.readFile(absolutePath, "utf-8");
     const lines = content.split(/\r?\n/);
     const slice = lines.slice(start - 1, Math.min(lines.length, end));
@@ -180028,7 +180209,7 @@ var webRoutes = new Elysia({ prefix: "/api/v1/web" }).post("/fetch_and_index", a
 
 // src/routes/web-ui.ts
 import fs18 from "fs/promises";
-import path28 from "path";
+import path30 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/web-ui-trust.ts
@@ -180072,9 +180253,9 @@ function buildStaticDirCandidates(moduleDir, cwd) {
   for (const root2 of [moduleDir, cwd]) {
     let dir = root2;
     for (let i = 0;i < 10; i++) {
-      candidates2.push(path28.resolve(dir, "apps/web-ui/src/static"));
-      candidates2.push(path28.resolve(dir, "web-ui/src/static"));
-      const parent = path28.dirname(dir);
+      candidates2.push(path30.resolve(dir, "apps/web-ui/src/static"));
+      candidates2.push(path30.resolve(dir, "web-ui/src/static"));
+      const parent = path30.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -180082,7 +180263,7 @@ function buildStaticDirCandidates(moduleDir, cwd) {
   }
   return [...new Set(candidates2)];
 }
-var STATIC_DIR_CANDIDATES = buildStaticDirCandidates(path28.dirname(fileURLToPath3(import.meta.url)), process.cwd());
+var STATIC_DIR_CANDIDATES = buildStaticDirCandidates(path30.dirname(fileURLToPath3(import.meta.url)), process.cwd());
 async function resolveStaticDir() {
   for (const dir of STATIC_DIR_CANDIDATES) {
     try {
@@ -180107,7 +180288,7 @@ var CONTENT_TYPES = {
   ".woff2": "font/woff2"
 };
 function contentTypeFor(filePath) {
-  const ext2 = path28.extname(filePath).toLowerCase();
+  const ext2 = path30.extname(filePath).toLowerCase();
   return CONTENT_TYPES[ext2] ?? "application/octet-stream";
 }
 function webUiDisabled() {
@@ -180118,9 +180299,9 @@ function webUiDisabled() {
 }
 async function resolveSafePath(staticDir, sub) {
   const cleaned = sub.replace(/^\/+/, "");
-  const abs = path28.resolve(staticDir, cleaned);
-  const rel = path28.relative(staticDir, abs);
-  if (rel.startsWith("..") || path28.isAbsolute(rel)) {
+  const abs = path30.resolve(staticDir, cleaned);
+  const rel = path30.relative(staticDir, abs);
+  if (rel.startsWith("..") || path30.isAbsolute(rel)) {
     return null;
   }
   try {
@@ -180164,7 +180345,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
     set3.status = 500;
     return { status: 500, error: "web ui static dir not found" };
   }
-  const indexPath = path28.join(dir, "index.html");
+  const indexPath = path30.join(dir, "index.html");
   try {
     const body = await readShell(indexPath, remoteAddressOf(request));
     set3.headers["content-type"] = contentTypeFor(indexPath);
@@ -180206,7 +180387,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
     }
   }
   try {
-    const body = await readShell(path28.join(dir, "index.html"), remoteAddressOf(request));
+    const body = await readShell(path30.join(dir, "index.html"), remoteAddressOf(request));
     set3.headers["content-type"] = "text/html; charset=utf-8";
     return body;
   } catch {