@massa-ai/tools-api 1.16.0 → 1.17.0

package/dist/index.js

@@ -13109,7 +13109,7 @@ var init_ignore_patterns = __esm(() => {
   ];
 });
 
-// ../../packages/core/dist/data/db-connection.js
+// ../../packages/core/dist/kernel/db-connection.js
 import { Pool } from "pg";
 function getDbConfig() {
   return {
@@ -13137,7 +13137,7 @@ var init_db_connection = __esm(() => {
   init_config();
 });
 
-// ../../packages/core/dist/services/project-identity/alias-resolver.js
+// ../../packages/core/dist/kernel/alias-resolver.js
 class ProjectIdentityAliasResolver {
   ttlMs;
   resolveTimeoutMs;
@@ -104662,7 +104662,7 @@ model ManagedRun {
   Object.assign(exports, Prisma);
 });
 
-// ../../packages/core/dist/services/query/prisma-client.js
+// ../../packages/core/dist/kernel/prisma-client.js
 var exports_prisma_client = {};
 __export(exports_prisma_client, {
   getPrismaClient: () => getPrismaClient2,
@@ -105473,7 +105473,7 @@ var init_query_understanding = __esm(() => {
   HYDE_SYSTEM = "You write a hypothetical implementation paragraph that a code-knowledge " + "search system will embed and match against real documents. Write ONE " + "concise paragraph (3-6 sentences) of plausible implementation detail " + "(types, function signatures, control flow) that a relevant document would " + "contain. No preamble, no markdown.";
 });
 
-// ../../packages/core/dist/services/structural/types.js
+// ../../packages/core/dist/kernel/types.js
 var STRUCTURAL_TAXONOMY_VERSION = "1.0.0", SOURCE_SPAN_SCHEMA_VERSION = "1.0.0", STRUCTURAL_FQN_SCHEMA_VERSION = "1.0.0";
 var init_types3 = __esm(() => {
   init_dist();
@@ -106565,7 +106565,7 @@ answer = 42
   });
 });
 
-// ../../packages/core/dist/services/project-identity/registry.js
+// ../../packages/core/dist/kernel/registry.js
 function directStorePolicy(tableName, columnName) {
   if (/^vector_documents(?:_\d+d)?$/.test(tableName) && columnName === "project_id") {
     return { storeId: tableName, identityColumn: columnName, mutable: true };
@@ -106626,7 +106626,7 @@ var init_registry = __esm(() => {
   ];
 });
 
-// ../../packages/core/dist/services/project-identity/identity-guard-installer.js
+// ../../packages/core/dist/kernel/identity-guard-installer.js
 async function installGuardOnTable(client, schema, table, column) {
   try {
     await client.query(`SELECT project_identity_install_guard($1::regclass, $2)`, [`${schema}.${table}`, column]);
@@ -106691,7 +106691,7 @@ var init_identity_guard_installer = __esm(() => {
   init_registry();
 });
 
-// ../../packages/core/dist/services/search/lexical-search.js
+// ../../packages/core/dist/kernel/lexical-search.js
 function dedupeTokens(tokens) {
   const seen = new Set;
   const out = [];
@@ -107355,9 +107355,16 @@ var init_keyword_search_factory = __esm(() => {
 // ../../packages/core/dist/data/vector/base-vector-store.js
 class BaseVectorStore {
   embeddingProviderPromise = null;
+  embeddingProviderFactory;
+  constructor(options) {
+    this.embeddingProviderFactory = options?.embeddingProviderFactory;
+  }
   getEmbeddingProvider() {
     if (!this.embeddingProviderPromise) {
-      this.embeddingProviderPromise = createEmbeddingProvider({ cache: true });
+      if (!this.embeddingProviderFactory) {
+        throw new Error("BaseVectorStore: no embeddingProviderFactory was supplied. Construct this store " + "via services/vector/vector-store-factory.ts (getVectorStore), or pass an explicit " + "embeddingProviderFactory to the constructor.");
+      }
+      this.embeddingProviderPromise = this.embeddingProviderFactory();
     }
     return this.embeddingProviderPromise;
   }
@@ -107403,7 +107410,6 @@ class BaseVectorStore {
   }
 }
 var init_base_vector_store = __esm(() => {
-  init_embeddings();
   init_dist();
 });
 
@@ -107529,7 +107535,7 @@ var init_postgres_vector_store = __esm(() => {
     tableName = "vector_documents";
     bqEnabled = false;
     constructor(config3) {
-      super();
+      super(config3.embeddingProviderFactory ? { embeddingProviderFactory: config3.embeddingProviderFactory } : undefined);
       this.config = {
         poolSize: 10,
         indexType: "hnsw",
@@ -107985,7 +107991,7 @@ var init_postgres_vector_store = __esm(() => {
   };
 });
 
-// ../../packages/core/dist/data/vector/vector-store-factory.js
+// ../../packages/core/dist/services/vector/vector-store-factory.js
 async function getVectorStore(config3) {
   if (cachedStore)
     return cachedStore;
@@ -108002,6 +108008,7 @@ async function getVectorStore(config3) {
       ...ivfflatLists ? { lists: ivfflatLists } : {}
     };
     const store = new PostgresVectorStore({
+      embeddingProviderFactory: () => createEmbeddingProvider({ cache: true }),
       connectionString,
       poolSize: Number.parseInt(process.env.POSTGRES_VECTOR_POOL_SIZE || "10", 10),
       indexType: process.env.POSTGRES_VECTOR_INDEX || "hnsw",
@@ -108028,6 +108035,7 @@ var init_vector_store_factory = __esm(() => {
   init_dist();
   init_config();
   init_postgres_vector_store();
+  init_embeddings();
 });
 
 // ../../packages/core/dist/services/search/search-cache-pg.js
@@ -108599,7 +108607,7 @@ var init_analytics_factory = __esm(() => {
   init_dist();
 });
 
-// ../../packages/core/dist/services/structural/schema-version.js
+// ../../packages/core/dist/kernel/schema-version.js
 function parseSemver(version3) {
   const match2 = SEMVER_PATTERN.exec(version3.trim());
   if (!match2)
@@ -108638,7 +108646,7 @@ var init_schema_version = __esm(() => {
   SEMVER_PATTERN = /^(\d+)\.(\d+)\.(\d+)$/u;
 });
 
-// ../../packages/core/dist/services/structural/fqn-codec.js
+// ../../packages/core/dist/kernel/fqn-codec.js
 import { createHash as createHash3 } from "crypto";
 function normalizedNfcText(value, label) {
   const normalized = value.normalize("NFC").trim();
@@ -112877,7 +112885,7 @@ var init_reranker = __esm(() => {
   });
 });
 
-// ../../packages/core/dist/tools/enum-validation.js
+// ../../packages/core/dist/kernel/enum-validation.js
 function validateEnum(paramName, value, validValues) {
   if (typeof value !== "string" || !validValues.includes(value)) {
     throw new ToolError(`Invalid ${paramName} value: ${String(value)}. Valid values: ${validValues.join(", ")}.`);
@@ -112949,7 +112957,7 @@ var init_filter_validation = __esm(() => {
   init_enum_validation();
 });
 
-// ../../packages/core/dist/controllers/search-controller.js
+// ../../packages/core/dist/services/search/search-controller.js
 var exports_search_controller = {};
 __export(exports_search_controller, {
   SearchController: () => SearchController
@@ -113694,7 +113702,7 @@ var init_session_bias = __esm(() => {
   init_synapse();
 });
 
-// ../../packages/core/dist/services/search/search-diagnostics.js
+// ../../packages/core/dist/kernel/search-diagnostics.js
 function searchBackendUnavailable(component, cause) {
   return cause instanceof SearchServiceError ? cause : new SearchServiceError("SEARCH_BACKEND_UNAVAILABLE", component, { cause });
 }
@@ -124146,7 +124154,7 @@ var init_salience_judge = __esm(() => {
   });
 });
 
-// ../../packages/core/dist/controllers/memory-controller.js
+// ../../packages/core/dist/services/memory/memory-controller.js
 class MemoryController {
   static instance = null;
   repo;
@@ -124783,6 +124791,45 @@ var init_code_compressor = __esm(() => {
   init_llm_client();
 });
 
+// ../../packages/core/dist/services/compression/compress-with-metrics.js
+async function compressWithMetrics(compressor, content, strategy, options = {}) {
+  const { language, targetRatio } = options;
+  const unit = language || "code";
+  const originalTokens = estimateTokens(content, unit);
+  logger.info("Compressing context", {
+    originalTokens,
+    strategy,
+    targetRatio
+  });
+  const result = await compressor.compress(content, strategy);
+  const compressedTokens = estimateTokens(result.compressed, unit);
+  const compressionRatio = 1 - compressedTokens / originalTokens;
+  const tokensSaved = originalTokens - compressedTokens;
+  logger.info("Context compressed", {
+    originalTokens,
+    compressedTokens,
+    tokensSaved,
+    actualRatio: compressionRatio.toFixed(2),
+    targetRatio
+  });
+  return {
+    compressed: result.compressed,
+    originalTokens,
+    compressedTokens,
+    tokensSaved,
+    compressionRatio
+  };
+}
+var init_compress_with_metrics = __esm(() => {
+  init_dist();
+});
+
+// ../../packages/core/dist/services/compression/index.js
+var init_compression = __esm(() => {
+  init_code_compressor();
+  init_compress_with_metrics();
+});
+
 // ../../packages/core/dist/services/metrics/token-metrics.js
 class TokenMetrics {
   static instance = null;
@@ -125116,6 +125163,340 @@ var init_session_file_cache = __esm(() => {
   SESSION_TTL_MS = 4 * 60 * 60 * 1000;
 });
 
+// ../../packages/core/dist/services/context/context-controller.js
+class ContextController {
+  static instance = null;
+  searchCtrl;
+  memoryCtrl;
+  compressor;
+  sessionCache;
+  constructor() {
+    this.searchCtrl = SearchController.getInstance();
+    this.memoryCtrl = MemoryController.getInstance();
+    this.compressor = new CodeCompressor;
+    this.sessionCache = SessionFileCache.getInstance();
+  }
+  static getInstance() {
+    if (!ContextController.instance) {
+      ContextController.instance = new ContextController;
+    }
+    return ContextController.instance;
+  }
+  async getOptimizedContext(input) {
+    const { query, projectId, projectPath: projectPath2, maxTokens = 4000, maxResults = 5, workingMemoryBudget, userId, sessionId, includeMemories = true, memoryBudgetRatio = 0.2 } = input;
+    const clampedRatio = Math.max(0, Math.min(0.5, memoryBudgetRatio));
+    const memoryTokenBudget = includeMemories ? Math.floor(maxTokens * clampedRatio) : 0;
+    const codeTokenBudget = maxTokens - memoryTokenBudget;
+    const wmBudget = workingMemoryBudget || Math.floor(codeTokenBudget * 0.8);
+    logger.info("Getting optimized context", {
+      query: query.slice(0, 50),
+      projectId,
+      maxTokens,
+      includeMemories,
+      memoryTokenBudget,
+      codeTokenBudget,
+      workingMemoryBudget: wmBudget
+    });
+    let graphContextSection = "";
+    let graphBoostFiles = [];
+    if (projectId && await symbolGraphService.hasData(projectId) && looksLikeSymbol(query)) {
+      try {
+        const [defs, refs] = await Promise.all([
+          symbolGraphService.goToDefinition(projectId, query),
+          symbolGraphService.getReferences(projectId, query)
+        ]);
+        if (defs.length > 0) {
+          const graphTokenBudget = Math.floor(codeTokenBudget * 0.2);
+          graphContextSection = formatGraphContext(defs, refs, graphTokenBudget);
+          graphBoostFiles = [
+            ...new Set([
+              ...defs.map((d) => d.file),
+              ...refs.slice(0, 10).map((r2) => r2.fromFile)
+            ])
+          ];
+          logger.debug("Graph prefilter hit", {
+            query,
+            defs: defs.length,
+            refs: refs.length,
+            boostFiles: graphBoostFiles.length
+          });
+        }
+      } catch (err) {
+        logger.warn("Graph prefilter failed", { query, error: err.message });
+      }
+    }
+    const [searchResult, memories] = await Promise.all([
+      this.searchCtrl.searchProject({
+        query,
+        projectId,
+        projectPath: projectPath2,
+        maxResults,
+        responseMode: "full",
+        autoReindex: false,
+        minScore: 0.4,
+        boostFiles: graphBoostFiles.length > 0 ? graphBoostFiles : undefined
+      }),
+      includeMemories ? this.searchMemoriesSafe(query, {
+        projectId,
+        userId,
+        sessionId,
+        limit: 5
+      }) : Promise.resolve([])
+    ]);
+    const codeResults = searchResult.results;
+    const workingSet = this.selectWorkingSet(codeResults, wmBudget);
+    const memorySection = this.formatMemorySection(memories, memoryTokenBudget);
+    if (workingSet.length === 0 && memories.length === 0) {
+      return {
+        context: `No relevant code or memories found for query: "${query}"`,
+        sources: [],
+        resultsCount: 0,
+        memoriesCount: 0,
+        tokensSaved: 0,
+        compressionRatio: 0,
+        sessionCacheHits: 0,
+        tokensSavedBySessionCache: 0
+      };
+    }
+    let sessionCacheHits = 0;
+    let tokensSavedBySessionCache = 0;
+    const deliveryPlan = workingSet.map((r2) => {
+      if (!sessionId) {
+        return { result: r2, kind: "full", tokensSaved: 0 };
+      }
+      const content = r2.content || r2.preview || "";
+      const key = this.sessionCache.chunkKey(r2.filePath || "unknown", r2.lineStart ?? 0, r2.lineEnd ?? 0);
+      const check3 = this.sessionCache.check(sessionId, key, content);
+      if (check3.status === "unchanged") {
+        sessionCacheHits++;
+        tokensSavedBySessionCache += check3.tokensSaved;
+        return { result: r2, kind: "ref", tokensSaved: check3.tokensSaved };
+      }
+      if (check3.status === "changed" && check3.diff !== undefined) {
+        sessionCacheHits++;
+        tokensSavedBySessionCache += check3.tokensSaved;
+        return { result: r2, kind: "diff", diff: check3.diff, tokensSaved: check3.tokensSaved };
+      }
+      return { result: r2, kind: "full", tokensSaved: 0 };
+    });
+    const parts = [`# Context for: ${query}
+`];
+    if (graphContextSection) {
+      parts.push(graphContextSection, "");
+    }
+    if (memorySection) {
+      parts.push(memorySection, "");
+    }
+    if (deliveryPlan.length > 0) {
+      const fullCount = deliveryPlan.filter((d) => d.kind === "full").length;
+      const refCount = deliveryPlan.filter((d) => d.kind === "ref").length;
+      const diffCount = deliveryPlan.filter((d) => d.kind === "diff").length;
+      parts.push(`## Code (${deliveryPlan.length} sections \u2014 ${fullCount} full, ${refCount} cached, ${diffCount} diff | WM budget: ${wmBudget} tokens)
+`);
+      deliveryPlan.forEach(({ result: r2, kind, diff }, idx) => {
+        const filePath = r2.filePath || "Unknown";
+        const scoreLabel = (r2.score * 100).toFixed(1);
+        const lineRange = `${r2.lineStart ?? "?"}-${r2.lineEnd ?? "?"}`;
+        parts.push(`### ${idx + 1}. ${filePath} (score: ${scoreLabel}%)`);
+        parts.push(`Lines ${lineRange}
+`);
+        if (kind === "ref") {
+          parts.push(`[CACHED: ${filePath}:${lineRange}]
+`);
+        } else if (kind === "diff" && diff) {
+          parts.push("```diff");
+          parts.push(diff);
+          parts.push("```\n");
+        } else {
+          parts.push("```" + (r2.language || ""));
+          parts.push(r2.content || r2.preview || "(no content)");
+          parts.push("```\n");
+        }
+      });
+    }
+    const rawContext = parts.join(`
+`);
+    const rawTokens = estimateTokens(rawContext, "code");
+    let finalContext = rawContext;
+    let compressionRatio = 0;
+    let tokensSaved = 0;
+    if (rawTokens > maxTokens) {
+      logger.info("Context exceeds maxTokens, compressing", {
+        rawTokens,
+        maxTokens
+      });
+      try {
+        const metrics2 = await compressWithMetrics(this.compressor, rawContext, "code_structure", { targetRatio: 0.6 });
+        finalContext = metrics2.compressed;
+        compressionRatio = metrics2.compressionRatio || 0;
+        tokensSaved = metrics2.tokensSaved || 0;
+      } catch (error51) {
+        logger.error("Failed to compress context", error51, {
+          strategy: "code_structure",
+          contentLength: rawContext.length
+        });
+      }
+    }
+    const finalTokens = estimateTokens(finalContext, "code");
+    const totalTokensSaved = rawTokens - finalTokens;
+    const compressionSavings = tokensSaved;
+    TokenMetrics.getInstance().recordContextRequest(rawTokens, finalTokens, tokensSavedBySessionCache, compressionSavings);
+    logger.info("Optimized context retrieved", {
+      rawTokens,
+      finalTokens,
+      tokensSaved: totalTokensSaved,
+      compressionRatio,
+      codeSources: workingSet.length,
+      memoriesIncluded: memories.length,
+      wmBudget,
+      sessionCacheHits,
+      tokensSavedBySessionCache
+    });
+    return {
+      context: finalContext,
+      sources: workingSet.map((r2) => r2.filePath || "unknown"),
+      resultsCount: workingSet.length,
+      memoriesCount: memories.length,
+      tokensSaved: totalTokensSaved,
+      compressionRatio,
+      sessionCacheHits,
+      tokensSavedBySessionCache
+    };
+  }
+  async searchMemoriesSafe(query, opts) {
+    try {
+      const result = await this.memoryCtrl.search({
+        query,
+        projectId: opts.projectId,
+        userId: opts.userId,
+        sessionId: opts.sessionId,
+        includePersistent: true,
+        minImportance: 0.3,
+        limit: opts.limit
+      });
+      return result.memories;
+    } catch (error51) {
+      logger.warn("Memory search failed, continuing without memories", {
+        error: error51.message,
+        query: query.slice(0, 30)
+      });
+      return [];
+    }
+  }
+  formatMemorySection(memories, tokenBudget) {
+    if (memories.length === 0 || tokenBudget <= 0)
+      return null;
+    const parts = [
+      `## Relevant Memories (from previous sessions)
+`
+    ];
+    let usedTokens = estimateTokens(parts[0], "text");
+    for (const memory of memories) {
+      const typeLabel = (memory.type || "unknown").toUpperCase();
+      const score = memory.score ? ` (relevance: ${(memory.score * 100).toFixed(0)}%)` : "";
+      const importance = memory.importance ? ` [importance: ${(memory.importance * 100).toFixed(0)}%]` : "";
+      const agent = memory.agentId ? ` (by: ${memory.agentId})` : "";
+      const entry2 = `- **[${typeLabel}]**${score}${importance}${agent}: ${memory.content}`;
+      const entryTokens = estimateTokens(entry2, "text");
+      if (usedTokens + entryTokens > tokenBudget)
+        break;
+      parts.push(entry2);
+      usedTokens += entryTokens;
+    }
+    return parts.length <= 1 ? null : parts.join(`
+`);
+  }
+  selectWorkingSet(results, tokenBudget) {
+    if (!results.length || tokenBudget <= 0)
+      return [];
+    const selected = [];
+    const selectedFiles = new Set;
+    let usedTokens = 0;
+    const sorted = [...results].sort((a12, b) => (b.score || 0) - (a12.score || 0));
+    for (const result of sorted) {
+      const filePath = result.filePath || "unknown";
+      if (selectedFiles.has(filePath))
+        continue;
+      const content = result.content || result.preview || "";
+      const tokens = estimateTokens(content, "code");
+      if (usedTokens + tokens > tokenBudget)
+        continue;
+      selected.push(result);
+      selectedFiles.add(filePath);
+      usedTokens += tokens;
+    }
+    for (const result of sorted) {
+      if (selected.includes(result))
+        continue;
+      const content = result.content || result.preview || "";
+      const tokens = estimateTokens(content, "code");
+      if (usedTokens + tokens > tokenBudget)
+        continue;
+      selected.push(result);
+      usedTokens += tokens;
+    }
+    return selected;
+  }
+}
+function looksLikeSymbol(query) {
+  if (query.length > 80)
+    return false;
+  const words = query.trim().split(/\s+/);
+  if (words.length > 3)
+    return false;
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(words[0]);
+}
+function formatGraphContext(defs, refs, tokenBudget) {
+  const parts = [`## Symbol Graph
+`];
+  if (defs.length > 0) {
+    parts.push(`### Definition(s)
+`);
+    for (const def of defs.slice(0, 3)) {
+      parts.push(`- **${def.kind}** \`${def.name}\` \u2192 \`${def.file}\` L${def.lineStart}\u2013${def.lineEnd}`);
+      if (def.docComment)
+        parts.push(`  > ${def.docComment.slice(0, 120)}`);
+      if (def.snippet) {
+        parts.push("  ```");
+        parts.push(def.snippet.split(`
+`).slice(0, 8).join(`
+`));
+        parts.push("  ```");
+      }
+    }
+    parts.push("");
+  }
+  if (refs.length > 0) {
+    parts.push(`### References (${refs.length} total)
+`);
+    const byFile = new Map;
+    for (const r2 of refs.slice(0, 30)) {
+      const arr = byFile.get(r2.fromFile) ?? [];
+      arr.push(r2.fromLine);
+      byFile.set(r2.fromFile, arr);
+    }
+    for (const [file3, lines] of byFile) {
+      parts.push(`- \`${file3}\` L${lines.join(", ")}`);
+    }
+    parts.push("");
+  }
+  const section = parts.join(`
+`);
+  const charBudget = tokenBudget * 4;
+  return section.length > charBudget ? section.slice(0, charBudget) + `
+...
+` : section;
+}
+var init_context_controller = __esm(() => {
+  init_dist();
+  init_search_controller();
+  init_memory_controller();
+  init_compression();
+  init_session_file_cache();
+  init_symbol_graph_service();
+  init_token_metrics();
+});
+
 // ../../packages/core/dist/services/checkpoint/checkpoint-store-pg.js
 function toNum2(v) {
   if (v == null)
@@ -127847,6 +128228,319 @@ var init_executor2 = __esm(() => {
   init_intent_search();
 });
 
+// ../../packages/core/dist/services/executor/executor-controller.js
+import { cpus as cpus2 } from "os";
+function applyIntent(result, intent) {
+  if (!intent || !result.stdout)
+    return result;
+  const ir = intentSearch(result.stdout, intent);
+  if (!ir.searched)
+    return result;
+  const rendered = renderIntentResult(ir, intent);
+  return {
+    ...result,
+    stdout: `${rendered}
+
+--- tail (last 512 chars) ---
+${result.stdout.slice(-512)}`
+  };
+}
+
+class ExecutorController {
+  static instance = null;
+  executor;
+  constructor(executor) {
+    this.executor = executor ?? new PolyglotExecutor;
+  }
+  static getInstance() {
+    if (!ExecutorController.instance) {
+      ExecutorController.instance = new ExecutorController;
+    }
+    return ExecutorController.instance;
+  }
+  static resetInstance() {
+    ExecutorController.instance?.executor.cleanupBackgrounded();
+    ExecutorController.instance = null;
+  }
+  get runtimes() {
+    return this.executor.runtimes;
+  }
+  async execute(params) {
+    try {
+      const language = validateEnum("language", params.language, EXECUTOR_LANGUAGES);
+      const result = await this.executor.execute({
+        language,
+        code: params.code,
+        timeout: params.timeout,
+        background: params.background,
+        cwd: params.cwd
+      });
+      const finalResult = applyIntent(result, params.intent);
+      const ok = !finalResult.timedOut && finalResult.exitCode === 0;
+      return {
+        success: ok,
+        data: {
+          stdout: finalResult.stdout,
+          stderr: finalResult.stderr,
+          exitCode: finalResult.exitCode,
+          timedOut: finalResult.timedOut,
+          backgrounded: finalResult.backgrounded ?? false,
+          command: finalResult.command,
+          cwd: finalResult.cwd,
+          sandboxMode: finalResult.sandboxMode
+        }
+      };
+    } catch (error51) {
+      logger.error("execute failed", error51, {
+        language: params.language
+      });
+      return {
+        success: false,
+        error: `execute failed: ${error51.message}`
+      };
+    }
+  }
+  async executeFile(params) {
+    try {
+      const language = validateEnum("language", params.language, EXECUTOR_LANGUAGES);
+      const result = await this.executor.executeFile({
+        path: params.path,
+        language,
+        code: params.code,
+        timeout: params.timeout
+      });
+      const blocked = result.stderr?.startsWith("Blocked:");
+      if (blocked) {
+        return { success: false, error: result.stderr };
+      }
+      const finalResult = applyIntent(result, params.intent);
+      const ok = !finalResult.timedOut && finalResult.exitCode === 0;
+      return {
+        success: ok,
+        data: {
+          stdout: finalResult.stdout,
+          stderr: finalResult.stderr,
+          exitCode: finalResult.exitCode,
+          timedOut: finalResult.timedOut,
+          command: finalResult.command,
+          cwd: finalResult.cwd,
+          sandboxMode: finalResult.sandboxMode
+        }
+      };
+    } catch (error51) {
+      logger.error("execute_file failed", error51, {
+        path: params.path,
+        language: params.language
+      });
+      return {
+        success: false,
+        error: `execute_file failed: ${error51.message}`
+      };
+    }
+  }
+  async batchExecute(params) {
+    const { commands, concurrency, cwd, timeout } = params;
+    if (!Array.isArray(commands) || commands.length === 0) {
+      return { success: false, error: "commands must be a non-empty array." };
+    }
+    if (commands.length > MAX_BATCH_COMMANDS) {
+      return {
+        success: false,
+        error: `batch_execute accepts at most ${MAX_BATCH_COMMANDS} commands; received ${commands.length}. Split the batch or reduce the payload.`
+      };
+    }
+    const effectiveConcurrency = concurrency && concurrency > 0 ? concurrency : Math.max(1, cpus2().length);
+    const perTimeout = timeout ?? DEFAULT_TIMEOUT_MS2;
+    try {
+      const poolResult = await runPool(commands.map((cmd) => ({
+        run: () => this.executor.execute({
+          language: "shell",
+          code: cmd,
+          timeout: perTimeout,
+          cwd
+        })
+      })), { concurrency: effectiveConcurrency });
+      const results = poolResult.settled.map((s, i) => {
+        if (s.status === "fulfilled") {
+          const r2 = s.value;
+          return {
+            command: commands[i],
+            stdout: r2.stdout,
+            stderr: r2.stderr,
+            exitCode: r2.exitCode,
+            timedOut: r2.timedOut,
+            sandboxMode: r2.sandboxMode
+          };
+        }
+        return {
+          command: commands[i],
+          stdout: "",
+          stderr: String(s.reason ?? "unknown error"),
+          exitCode: null,
+          timedOut: false,
+          sandboxMode: getSandboxMode()
+        };
+      });
+      const anyFailed = results.some((r2) => r2.exitCode !== 0 || r2.timedOut);
+      return {
+        success: !anyFailed,
+        data: {
+          results,
+          concurrency: poolResult.effectiveConcurrency,
+          capped: poolResult.capped
+        }
+      };
+    } catch (error51) {
+      logger.error("batch_execute failed", error51);
+      return {
+        success: false,
+        error: `batch_execute failed: ${error51.message}`
+      };
+    }
+  }
+  static get MAX_TIMEOUT_MS() {
+    return MAX_TIMEOUT_MS;
+  }
+}
+var EXECUTOR_LANGUAGES, MAX_BATCH_COMMANDS = 256;
+var init_executor_controller = __esm(() => {
+  init_dist();
+  init_executor2();
+  init_enum_validation();
+  EXECUTOR_LANGUAGES = [
+    "javascript",
+    "typescript",
+    "python",
+    "shell",
+    "ruby",
+    "go",
+    "rust",
+    "php",
+    "perl",
+    "r"
+  ];
+});
+
+// ../../packages/core/dist/services/symbol/graph-controller.js
+class GraphController {
+  static instance = null;
+  constructor() {}
+  static getInstance() {
+    if (!GraphController.instance) {
+      GraphController.instance = new GraphController;
+    }
+    return GraphController.instance;
+  }
+  async tracePath(input) {
+    const projectId = input.projectId;
+    const seed = input.function_name ?? input.symbol ?? input.qualifiedName;
+    if (!projectId)
+      throw new Error("projectId is required");
+    if (!seed)
+      throw new Error("function_name (or symbol/qualifiedName) is required");
+    const t0 = performance.now();
+    const result = await tracePathService.tracePath({
+      symbol: input.function_name ?? input.symbol ?? "",
+      function_name: input.function_name,
+      qualifiedName: input.qualifiedName,
+      projectId,
+      direction: input.direction,
+      mode: input.mode,
+      depth: input.depth,
+      include_tests: input.include_tests,
+      edge_types: input.edge_types
+    });
+    logger.info("GraphController: trace_path", {
+      projectId,
+      symbol: seed,
+      mode: result.mode,
+      direction: result.direction,
+      seeds: result.seeds.length,
+      nodes: result.nodes.length,
+      edges: result.edges.length,
+      durationMs: Math.round(performance.now() - t0)
+    });
+    if (result.seeds.length === 0) {
+      return {
+        found: false,
+        symbol: seed,
+        projectId,
+        ...result.identityResolution ? { identityResolution: result.identityResolution } : {},
+        hint: "Use search_definitions(search=...) to find the exact name, or pass a fully-qualified name (qualifiedName='rel/path.ts#Name')."
+      };
+    }
+    return {
+      found: true,
+      result: {
+        projectId: result.projectId,
+        symbol: result.symbol,
+        mode: result.mode,
+        direction: result.direction,
+        edgeTypes: result.edgeTypes,
+        seeds: result.seeds,
+        truncated: result.truncated,
+        nodes_total: result.nodes_total,
+        nodes_shown: result.nodes_shown,
+        nodes_omitted: result.nodes_omitted,
+        nodeCount: result.nodes.length,
+        edgeCount: result.edges.length,
+        chains: result.chains,
+        nodes: result.nodes,
+        edges: result.edges,
+        ...result.identityResolution ? { identity: toSymbolIdentityResolution(result.identityResolution) } : {}
+      }
+    };
+  }
+  async analyzeImpact(input) {
+    if (!input.projectId)
+      throw new Error("projectId is required");
+    if (!input.projectPath)
+      throw new Error("projectPath is required");
+    const t0 = performance.now();
+    const result = await impactAnalysisService.analyze({
+      projectId: input.projectId,
+      projectPath: input.projectPath,
+      scope: input.scope ?? "unstaged",
+      baseBranch: input.base_branch,
+      since: input.since,
+      depth: input.depth,
+      paths: input.paths,
+      diffRunner: input.diffRunner
+    });
+    logger.info("GraphController: impact_analysis", {
+      projectId: input.projectId,
+      scope: result.scope,
+      changedFiles: result.changedFiles.length,
+      impacted: result.impacted.length,
+      truncated: result.truncated,
+      durationMs: Math.round(performance.now() - t0)
+    });
+    return {
+      projectId: result.projectId,
+      scope: result.scope,
+      baseBranch: result.baseBranch,
+      since: result.since,
+      depth: result.depth,
+      changedFileCount: result.changedFiles.length,
+      changedFiles: result.changedFiles,
+      impactedCount: result.impacted.length,
+      truncated: result.truncated,
+      impacted: result.impacted,
+      untrackedFiltered: result.untrackedFiltered,
+      impacted_total: result.impacted_total,
+      impacted_shown: result.impacted_shown,
+      impacted_omitted: result.impacted_omitted,
+      note: result.note
+    };
+  }
+}
+var init_graph_controller = __esm(() => {
+  init_dist();
+  init_trace_path();
+  init_impact_analysis();
+  init_definition_lookup();
+});
+
 // ../../packages/core/dist/services/project-identity/errors.js
 var ERROR_MESSAGES, ERROR_STATUS, ProjectIdentityError;
 var init_errors4 = __esm(() => {
@@ -149777,6 +150471,7 @@ __export(exports_services, {
   SessionFileCache: () => SessionFileCache,
   SearchSessionHook: () => SearchSessionHook,
   SearchServiceError: () => SearchServiceError,
+  SearchController: () => SearchController,
   SearchCachePg: () => SearchCachePg,
   SearchAnalyticsPg: () => SearchAnalyticsPg,
   Scheduler: () => Scheduler,
@@ -149810,6 +150505,7 @@ __export(exports_services, {
   ModelsDevClient: () => ModelsDevClient,
   MemoryService: () => MemoryService,
   MemoryGraphService: () => MemoryGraphService,
+  MemoryController: () => MemoryController,
   MemoryClustering: () => MemoryClustering,
   MAX_TIMEOUT_MS: () => MAX_TIMEOUT_MS,
   MAX_STRUCTURAL_PARSER_CAPACITY: () => MAX_STRUCTURAL_PARSER_CAPACITY,
@@ -149828,10 +150524,12 @@ __export(exports_services, {
   ImpactAnalysisService: () => ImpactAnalysisService,
   GraphStorePg: () => GraphStorePg,
   GraphQueries: () => GraphQueries,
+  GraphController: () => GraphController,
   GO_QUERY_PACK: () => GO_QUERY_PACK,
   FqnHashCollisionError: () => FqnHashCollisionError,
   FUNCTIONAL_QUERY_PACKS: () => FUNCTIONAL_QUERY_PACKS,
   FUNCTIONAL_LANGUAGE_RESOLVER: () => FUNCTIONAL_LANGUAGE_RESOLVER,
+  ExecutorController: () => ExecutorController,
   EventBus: () => TypedEventBus,
   EtlPipeline: () => EtlPipeline,
   EmbeddingCachePg: () => EmbeddingCachePg,
@@ -149853,6 +150551,7 @@ __export(exports_services, {
   DATA_DOCUMENT_QUERY_PACKS: () => DATA_DOCUMENT_QUERY_PACKS,
   DATA_DOCUMENT_LANGUAGE_RESOLVER: () => DATA_DOCUMENT_LANGUAGE_RESOLVER,
   ContextualSearchRLM: () => ContextualSearchRLM,
+  ContextController: () => ContextController,
   CompactionSnapshotService: () => CompactionSnapshotService,
   CodeCompressor: () => CodeCompressor,
   CoRetrievalHook: () => CoRetrievalHook,
@@ -149869,6 +150568,11 @@ var init_services = __esm(() => {
   init_search_analytics_pg();
   init_index_manager();
   init_search_diagnostics();
+  init_memory_controller();
+  init_search_controller();
+  init_context_controller();
+  init_executor_controller();
+  init_graph_controller();
   init_l1_memory_cache();
   init_embedding_cache_pg();
   init_code_compressor();
@@ -150399,199 +151103,70 @@ 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: () => IsVoid2,
-  IsUnsafe: () => IsUnsafe2,
-  IsUnknown: () => IsUnknown2,
+  IsVoid: () => IsVoid,
+  IsUnsafe: () => IsUnsafe,
+  IsUnknown: () => IsUnknown,
   IsUnionLiteral: () => IsUnionLiteral,
-  IsUnion: () => IsUnion2,
-  IsUndefined: () => IsUndefined4,
-  IsUint8Array: () => IsUint8Array4,
-  IsTuple: () => IsTuple2,
-  IsTransform: () => IsTransform2,
-  IsThis: () => IsThis2,
-  IsTemplateLiteral: () => IsTemplateLiteral2,
-  IsSymbol: () => IsSymbol4,
-  IsString: () => IsString4,
-  IsSchema: () => IsSchema2,
-  IsRegExp: () => IsRegExp3,
-  IsRef: () => IsRef2,
+  IsUnion: () => IsUnion,
+  IsUndefined: () => IsUndefined3,
+  IsUint8Array: () => IsUint8Array3,
+  IsTuple: () => IsTuple,
+  IsTransform: () => IsTransform,
+  IsThis: () => IsThis,
+  IsTemplateLiteral: () => IsTemplateLiteral,
+  IsSymbol: () => IsSymbol3,
+  IsString: () => IsString3,
+  IsSchema: () => IsSchema,
+  IsRegExp: () => IsRegExp2,
+  IsRef: () => IsRef,
   IsRecursive: () => IsRecursive,
-  IsRecord: () => IsRecord2,
-  IsReadonly: () => IsReadonly2,
+  IsRecord: () => IsRecord,
+  IsReadonly: () => IsReadonly,
   IsProperties: () => IsProperties,
-  IsPromise: () => IsPromise3,
-  IsOptional: () => IsOptional2,
-  IsObject: () => IsObject4,
-  IsNumber: () => IsNumber4,
-  IsNull: () => IsNull4,
-  IsNot: () => IsNot2,
-  IsNever: () => IsNever2,
-  IsMappedResult: () => IsMappedResult2,
-  IsMappedKey: () => IsMappedKey2,
-  IsLiteralValue: () => IsLiteralValue2,
+  IsPromise: () => IsPromise2,
+  IsOptional: () => IsOptional,
+  IsObject: () => IsObject3,
+  IsNumber: () => IsNumber3,
+  IsNull: () => IsNull3,
+  IsNot: () => IsNot,
+  IsNever: () => IsNever,
+  IsMappedResult: () => IsMappedResult,
+  IsMappedKey: () => IsMappedKey,
+  IsLiteralValue: () => IsLiteralValue,
   IsLiteralString: () => IsLiteralString,
   IsLiteralNumber: () => IsLiteralNumber,
   IsLiteralBoolean: () => IsLiteralBoolean,
-  IsLiteral: () => IsLiteral2,
-  IsKindOf: () => IsKindOf2,
-  IsKind: () => IsKind2,
-  IsIterator: () => IsIterator4,
-  IsIntersect: () => IsIntersect2,
-  IsInteger: () => IsInteger3,
+  IsLiteral: () => IsLiteral,
+  IsKindOf: () => IsKindOf,
+  IsKind: () => IsKind,
+  IsIterator: () => IsIterator3,
+  IsIntersect: () => IsIntersect,
+  IsInteger: () => IsInteger2,
   IsImport: () => IsImport,
-  IsFunction: () => IsFunction4,
-  IsDate: () => IsDate4,
-  IsConstructor: () => IsConstructor2,
-  IsComputed: () => IsComputed2,
-  IsBoolean: () => IsBoolean4,
-  IsBigInt: () => IsBigInt4,
-  IsAsyncIterator: () => IsAsyncIterator4,
-  IsArray: () => IsArray4,
-  IsArgument: () => IsArgument2,
-  IsAny: () => IsAny2
+  IsFunction: () => IsFunction3,
+  IsDate: () => IsDate3,
+  IsConstructor: () => IsConstructor,
+  IsComputed: () => IsComputed,
+  IsBoolean: () => IsBoolean3,
+  IsBigInt: () => IsBigInt3,
+  IsAsyncIterator: () => IsAsyncIterator3,
+  IsArray: () => IsArray3,
+  IsArgument: () => IsArgument,
+  IsAny: () => IsAny
 });
+
+// ../../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 = [
@@ -150651,7 +151226,7 @@ function IsControlCharacterFree(value) {
   return true;
 }
 function IsAdditionalProperties(value) {
-  return IsOptionalBoolean(value) || IsSchema2(value);
+  return IsOptionalBoolean(value) || IsSchema(value);
 }
 function IsOptionalBigInt(value) {
   return IsUndefined(value) || IsBigInt(value);
@@ -150672,160 +151247,160 @@ function IsOptionalFormat(value) {
   return IsUndefined(value) || IsString(value) && IsControlCharacterFree(value);
 }
 function IsOptionalSchema(value) {
-  return IsUndefined(value) || IsSchema2(value);
+  return IsUndefined(value) || IsSchema(value);
 }
-function IsReadonly2(value) {
+function IsReadonly(value) {
   return IsObject(value) && value[ReadonlyKind] === "Readonly";
 }
-function IsOptional2(value) {
+function IsOptional(value) {
   return IsObject(value) && value[OptionalKind] === "Optional";
 }
-function IsAny2(value) {
-  return IsKindOf2(value, "Any") && IsOptionalString(value.$id);
+function IsAny(value) {
+  return IsKindOf(value, "Any") && IsOptionalString(value.$id);
 }
-function IsArgument2(value) {
-  return IsKindOf2(value, "Argument") && IsNumber(value.index);
+function IsArgument(value) {
+  return IsKindOf(value, "Argument") && IsNumber(value.index);
 }
-function IsArray4(value) {
-  return IsKindOf2(value, "Array") && value.type === "array" && IsOptionalString(value.$id) && IsSchema2(value.items) && IsOptionalNumber(value.minItems) && IsOptionalNumber(value.maxItems) && IsOptionalBoolean(value.uniqueItems) && IsOptionalSchema(value.contains) && IsOptionalNumber(value.minContains) && IsOptionalNumber(value.maxContains);
+function 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 IsAsyncIterator4(value) {
-  return IsKindOf2(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+function IsAsyncIterator3(value) {
+  return IsKindOf(value, "AsyncIterator") && value.type === "AsyncIterator" && IsOptionalString(value.$id) && IsSchema(value.items);
 }
-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 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 IsBoolean4(value) {
-  return IsKindOf2(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
+function IsBoolean3(value) {
+  return IsKindOf(value, "Boolean") && value.type === "boolean" && IsOptionalString(value.$id);
 }
-function IsComputed2(value) {
-  return IsKindOf2(value, "Computed") && IsString(value.target) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema));
+function IsComputed(value) {
+  return IsKindOf(value, "Computed") && IsString(value.target) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema(schema));
 }
-function IsConstructor2(value) {
-  return IsKindOf2(value, "Constructor") && value.type === "Constructor" && IsOptionalString(value.$id) && IsArray(value.parameters) && value.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value.returns);
+function 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 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 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 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 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 IsImport(value) {
-  return IsKindOf2(value, "Import") && HasPropertyKey(value, "$defs") && IsObject(value.$defs) && IsProperties(value.$defs) && HasPropertyKey(value, "$ref") && IsString(value.$ref) && value.$ref in value.$defs;
+  return IsKindOf(value, "Import") && HasPropertyKey(value, "$defs") && IsObject(value.$defs) && IsProperties(value.$defs) && HasPropertyKey(value, "$ref") && IsString(value.$ref) && value.$ref in value.$defs;
 }
-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 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 IsProperties(value) {
-  return IsObject(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema2(schema));
+  return IsObject(value) && Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema(schema));
 }
-function IsIntersect2(value) {
-  return IsKindOf2(value, "Intersect") && (IsString(value.type) && value.type !== "object" ? false : true) && IsArray(value.allOf) && value.allOf.every((schema) => IsSchema2(schema) && !IsTransform2(schema)) && IsOptionalString(value.type) && (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) && IsOptionalString(value.$id);
+function 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 IsIterator4(value) {
-  return IsKindOf2(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema2(value.items);
+function IsIterator3(value) {
+  return IsKindOf(value, "Iterator") && value.type === "Iterator" && IsOptionalString(value.$id) && IsSchema(value.items);
 }
-function IsKindOf2(value, kind) {
+function IsKindOf(value, kind) {
   return IsObject(value) && Kind in value && value[Kind] === kind;
 }
 function IsLiteralString(value) {
-  return IsLiteral2(value) && IsString(value.const);
+  return IsLiteral(value) && IsString(value.const);
 }
 function IsLiteralNumber(value) {
-  return IsLiteral2(value) && IsNumber(value.const);
+  return IsLiteral(value) && IsNumber(value.const);
 }
 function IsLiteralBoolean(value) {
-  return IsLiteral2(value) && IsBoolean(value.const);
+  return IsLiteral(value) && IsBoolean(value.const);
 }
-function IsLiteral2(value) {
-  return IsKindOf2(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue2(value.const);
+function IsLiteral(value) {
+  return IsKindOf(value, "Literal") && IsOptionalString(value.$id) && IsLiteralValue(value.const);
 }
-function IsLiteralValue2(value) {
+function IsLiteralValue(value) {
   return IsBoolean(value) || IsNumber(value) || IsString(value);
 }
-function IsMappedKey2(value) {
-  return IsKindOf2(value, "MappedKey") && IsArray(value.keys) && value.keys.every((key) => IsNumber(key) || IsString(key));
+function IsMappedKey(value) {
+  return IsKindOf(value, "MappedKey") && IsArray(value.keys) && value.keys.every((key) => IsNumber(key) || IsString(key));
 }
-function IsMappedResult2(value) {
-  return IsKindOf2(value, "MappedResult") && IsProperties(value.properties);
+function IsMappedResult(value) {
+  return IsKindOf(value, "MappedResult") && IsProperties(value.properties);
 }
-function IsNever2(value) {
-  return IsKindOf2(value, "Never") && IsObject(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
+function IsNever(value) {
+  return IsKindOf(value, "Never") && IsObject(value.not) && Object.getOwnPropertyNames(value.not).length === 0;
 }
-function IsNot2(value) {
-  return IsKindOf2(value, "Not") && IsSchema2(value.not);
+function IsNot(value) {
+  return IsKindOf(value, "Not") && IsSchema(value.not);
 }
-function IsNull4(value) {
-  return IsKindOf2(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
+function IsNull3(value) {
+  return IsKindOf(value, "Null") && value.type === "null" && IsOptionalString(value.$id);
 }
-function IsNumber4(value) {
-  return IsKindOf2(value, "Number") && value.type === "number" && IsOptionalString(value.$id) && IsOptionalNumber(value.exclusiveMaximum) && IsOptionalNumber(value.exclusiveMinimum) && IsOptionalNumber(value.maximum) && IsOptionalNumber(value.minimum) && IsOptionalNumber(value.multipleOf);
+function 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 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 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 IsPromise3(value) {
-  return IsKindOf2(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema2(value.item);
+function IsPromise2(value) {
+  return IsKindOf(value, "Promise") && value.type === "Promise" && IsOptionalString(value.$id) && IsSchema(value.item);
 }
-function IsRecord2(value) {
-  return IsKindOf2(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject(value.patternProperties) && ((schema) => {
+function IsRecord(value) {
+  return IsKindOf(value, "Record") && value.type === "object" && IsOptionalString(value.$id) && IsAdditionalProperties(value.additionalProperties) && IsObject(value.patternProperties) && ((schema) => {
     const keys = Object.getOwnPropertyNames(schema.patternProperties);
-    return keys.length === 1 && IsPattern(keys[0]) && IsObject(schema.patternProperties) && IsSchema2(schema.patternProperties[keys[0]]);
+    return keys.length === 1 && IsPattern(keys[0]) && IsObject(schema.patternProperties) && IsSchema(schema.patternProperties[keys[0]]);
   })(value);
 }
 function IsRecursive(value) {
   return IsObject(value) && Hint in value && value[Hint] === "Recursive";
 }
-function IsRef2(value) {
-  return IsKindOf2(value, "Ref") && IsOptionalString(value.$id) && IsString(value.$ref);
+function IsRef(value) {
+  return IsKindOf(value, "Ref") && IsOptionalString(value.$id) && IsString(value.$ref);
 }
-function IsRegExp3(value) {
-  return IsKindOf2(value, "RegExp") && IsOptionalString(value.$id) && IsString(value.source) && IsString(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
+function IsRegExp2(value) {
+  return IsKindOf(value, "RegExp") && IsOptionalString(value.$id) && IsString(value.source) && IsString(value.flags) && IsOptionalNumber(value.maxLength) && IsOptionalNumber(value.minLength);
 }
-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 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 IsSymbol4(value) {
-  return IsKindOf2(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
+function IsSymbol3(value) {
+  return IsKindOf(value, "Symbol") && value.type === "symbol" && IsOptionalString(value.$id);
 }
-function IsTemplateLiteral2(value) {
-  return IsKindOf2(value, "TemplateLiteral") && value.type === "string" && IsString(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
+function IsTemplateLiteral(value) {
+  return IsKindOf(value, "TemplateLiteral") && value.type === "string" && IsString(value.pattern) && value.pattern[0] === "^" && value.pattern[value.pattern.length - 1] === "$";
 }
-function IsThis2(value) {
-  return IsKindOf2(value, "This") && IsOptionalString(value.$id) && IsString(value.$ref);
+function IsThis(value) {
+  return IsKindOf(value, "This") && IsOptionalString(value.$id) && IsString(value.$ref);
 }
-function IsTransform2(value) {
+function IsTransform(value) {
   return IsObject(value) && TransformKind in value;
 }
-function IsTuple2(value) {
-  return IsKindOf2(value, "Tuple") && value.type === "array" && IsOptionalString(value.$id) && IsNumber(value.minItems) && IsNumber(value.maxItems) && value.minItems === value.maxItems && (IsUndefined(value.items) && IsUndefined(value.additionalItems) && value.minItems === 0 || IsArray(value.items) && value.items.every((schema) => IsSchema2(schema)));
+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 IsUndefined4(value) {
-  return IsKindOf2(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
+function IsUndefined3(value) {
+  return IsKindOf(value, "Undefined") && value.type === "undefined" && IsOptionalString(value.$id);
 }
 function IsUnionLiteral(value) {
-  return IsUnion2(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
+  return IsUnion(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
 }
-function IsUnion2(value) {
-  return IsKindOf2(value, "Union") && IsOptionalString(value.$id) && IsObject(value) && IsArray(value.anyOf) && value.anyOf.every((schema) => IsSchema2(schema));
+function IsUnion(value) {
+  return IsKindOf(value, "Union") && IsOptionalString(value.$id) && IsObject(value) && IsArray(value.anyOf) && value.anyOf.every((schema) => IsSchema(schema));
 }
-function IsUint8Array4(value) {
-  return IsKindOf2(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
+function IsUint8Array3(value) {
+  return IsKindOf(value, "Uint8Array") && value.type === "Uint8Array" && IsOptionalString(value.$id) && IsOptionalNumber(value.minByteLength) && IsOptionalNumber(value.maxByteLength);
 }
-function IsUnknown2(value) {
-  return IsKindOf2(value, "Unknown") && IsOptionalString(value.$id);
+function IsUnknown(value) {
+  return IsKindOf(value, "Unknown") && IsOptionalString(value.$id);
 }
-function IsUnsafe2(value) {
-  return IsKindOf2(value, "Unsafe");
+function IsUnsafe(value) {
+  return IsKindOf(value, "Unsafe");
 }
-function IsVoid2(value) {
-  return IsKindOf2(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
+function IsVoid(value) {
+  return IsKindOf(value, "Void") && value.type === "void" && IsOptionalString(value.$id);
 }
-function IsKind2(value) {
+function IsKind(value) {
   return IsObject(value) && Kind in value && IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
 }
-function IsSchema2(value) {
-  return IsObject(value) && (IsAny2(value) || IsArgument2(value) || IsArray4(value) || 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));
+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));
 }
 // ../../node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
 var PatternBoolean = "(true|false)";
@@ -150982,12 +151557,143 @@ 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) => IsOptional(type));
+  return types.some((type) => IsOptional2(type));
 }
 function RemoveOptionalFromRest(types) {
-  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
+  return types.map((left) => IsOptional2(left) ? RemoveOptionalFromType(left) : left);
 }
 function RemoveOptionalFromType(T2) {
   return Discard(T2, [OptionalKind]);
@@ -151256,7 +151962,7 @@ function Escape(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function Visit2(schema, acc) {
-  return IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit2(schema2, acc)).join("|")})` : 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}` : (() => {
+  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}` : (() => {
     throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`);
   })();
 }
@@ -151292,7 +151998,7 @@ function FromLiteral(literalValue) {
   return [literalValue.toString()];
 }
 function IndexPropertyKeys(type) {
-  return [...new Set(IsTemplateLiteral(type) ? FromTemplateLiteral(type) : IsUnion(type) ? FromUnion2(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : IsNumber3(type) ? ["[number]"] : IsInteger2(type) ? ["[number]"] : [])];
+  return [...new Set(IsTemplateLiteral2(type) ? FromTemplateLiteral(type) : IsUnion2(type) ? FromUnion2(type.anyOf) : IsLiteral2(type) ? FromLiteral(type.const) : IsNumber4(type) ? ["[number]"] : IsInteger3(type) ? ["[number]"] : [])];
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.mjs
@@ -151316,13 +152022,13 @@ function FromRest(types, key) {
   return types.map((type) => IndexFromPropertyKey(type, key));
 }
 function FromIntersectRest(types) {
-  return types.filter((type) => !IsNever(type));
+  return types.filter((type) => !IsNever2(type));
 }
 function FromIntersect(types, key) {
   return IntersectEvaluated(FromIntersectRest(FromRest(types, key)));
 }
 function FromUnionRest(types) {
-  return types.some((L) => IsNever(L)) ? [] : types;
+  return types.some((L) => IsNever2(L)) ? [] : types;
 }
 function FromUnion3(types, key) {
   return UnionEvaluated(FromUnionRest(FromRest(types, key)));
@@ -151337,7 +152043,7 @@ function FromProperty(properties, propertyKey) {
   return propertyKey in properties ? properties[propertyKey] : Never();
 }
 function IndexFromPropertyKey(type, propertyKey) {
-  return IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) : IsUnion(type) ? FromUnion3(type.anyOf, propertyKey) : IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) : IsArray3(type) ? FromArray(type.items, propertyKey) : IsObject3(type) ? FromProperty(type.properties, propertyKey) : Never();
+  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();
 }
 function IndexFromPropertyKeys(type, propertyKeys) {
   return propertyKeys.map((propertyKey) => IndexFromPropertyKey(type, propertyKey));
@@ -151346,17 +152052,17 @@ function FromSchema(type, propertyKeys) {
   return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
 }
 function Index(type, key, options) {
-  if (IsRef(type) || IsRef(key)) {
+  if (IsRef2(type) || IsRef2(key)) {
     const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
-    if (!IsSchema(type) || !IsSchema(key))
+    if (!IsSchema2(type) || !IsSchema2(key))
       throw new TypeBoxError(error);
     return Computed("Index", [type, key]);
   }
-  if (IsMappedResult(key))
+  if (IsMappedResult2(key))
     return IndexFromMappedResult(type, key, options);
-  if (IsMappedKey(key))
+  if (IsMappedKey2(key))
     return IndexFromMappedKey(type, key, options);
-  return CreateType(IsSchema(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(type, key), options);
+  return CreateType(IsSchema2(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(type, key), options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.mjs
@@ -151383,7 +152089,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) => !IsOptional(properties[key]));
+  return globalThis.Object.keys(properties).filter((key) => !IsOptional2(properties[key]));
 }
 function _Object(properties, options) {
   const required = RequiredArray(properties);
@@ -151409,7 +152115,7 @@ function ReadonlyWithFlag(schema, F) {
 }
 function Readonly(schema, enable) {
   const F = enable ?? true;
-  return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
+  return IsMappedResult2(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/readonly/readonly-from-mapped-result.mjs
@@ -151463,7 +152169,7 @@ function FromProperties3(K, T2) {
 }
 function FromSchemaType(K, T2) {
   const 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;
+  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;
 }
 function MappedFunctionReturnType(K, T2) {
   const Acc = {};
@@ -151472,7 +152178,7 @@ function MappedFunctionReturnType(K, T2) {
   return Acc;
 }
 function Mapped(key, map3, options) {
-  const K = IsSchema(key) ? IndexPropertyKeys(key) : key;
+  const K = IsSchema2(key) ? IndexPropertyKeys(key) : key;
   const RT = map3({ [Kind]: "MappedKey", keys: K });
   const R = MappedFunctionReturnType(K, RT);
   return Object2(R, options);
@@ -151490,7 +152196,7 @@ function OptionalWithFlag(schema, F) {
 }
 function Optional(schema, enable) {
   const F = enable ?? true;
-  return IsMappedResult(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
+  return IsMappedResult2(schema) ? OptionalFromMappedResult(schema, F) : OptionalWithFlag(schema, F);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/optional/optional-from-mapped-result.mjs
@@ -151510,20 +152216,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) => 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);
+  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);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.mjs
 function IsIntersectOptional(types) {
-  return types.every((left) => IsOptional(left));
+  return types.every((left) => IsOptional2(left));
 }
 function RemoveOptionalFromType2(type) {
   return Discard(type, [OptionalKind]);
 }
 function RemoveOptionalFromRest2(types) {
-  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType2(left) : left);
+  return types.map((left) => IsOptional2(left) ? RemoveOptionalFromType2(left) : left);
 }
 function ResolveIntersect(types, options) {
   return IsIntersectOptional(types) ? Optional(IntersectCreate(RemoveOptionalFromRest2(types), options)) : IntersectCreate(RemoveOptionalFromRest2(types), options);
@@ -151533,7 +152239,7 @@ function IntersectEvaluated(types, options = {}) {
     return CreateType(types[0], options);
   if (types.length === 0)
     return Never(options);
-  if (types.some((schema) => IsTransform(schema)))
+  if (types.some((schema) => IsTransform2(schema)))
     throw new Error("Cannot intersect transform types");
   return ResolveIntersect(types, options);
 }
@@ -151544,7 +152250,7 @@ function Intersect(types, options) {
     return CreateType(types[0], options);
   if (types.length === 0)
     return Never(options);
-  if (types.some((schema) => IsTransform(schema)))
+  if (types.some((schema) => IsTransform2(schema)))
     throw new Error("Cannot intersect transform types");
   return IntersectCreate(types, options);
 }
@@ -151577,7 +152283,7 @@ function FromRest3(types) {
   return types.map((type) => Awaited(type));
 }
 function Awaited(type, options) {
-  return CreateType(IsComputed(type) ? FromComputed(type.target, type.parameters) : IsIntersect(type) ? FromIntersect2(type.allOf) : IsUnion(type) ? FromUnion4(type.anyOf) : IsPromise2(type) ? FromPromise(type.item) : IsRef(type) ? FromRef(type.$ref) : 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);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-keys.mjs
@@ -151615,7 +152321,7 @@ function FromPatternProperties(patternProperties) {
   });
 }
 function KeyOfPropertyKeys(type) {
-  return IsIntersect(type) ? FromIntersect3(type.allOf) : IsUnion(type) ? FromUnion5(type.anyOf) : IsTuple(type) ? FromTuple2(type.items ?? []) : IsArray3(type) ? FromArray2(type.items) : IsObject3(type) ? FromProperties5(type.properties) : IsRecord(type) ? FromPatternProperties(type.patternProperties) : [];
+  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) : [];
 }
 var includePatternProperties = false;
 function KeyOfPattern(schema) {
@@ -151643,7 +152349,7 @@ function KeyOfPropertyKeysToRest(propertyKeys) {
   return propertyKeys.map((L) => L === "[number]" ? Number2() : Literal(L));
 }
 function KeyOf(type, options) {
-  return IsComputed(type) ? FromComputed2(type.target, type.parameters) : IsRef(type) ? FromRef2(type.$ref) : IsMappedResult(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options);
+  return IsComputed2(type) ? FromComputed2(type.target, type.parameters) : IsRef2(type) ? FromRef2(type.$ref) : IsMappedResult2(type) ? KeyOfFromMappedResult(type, options) : KeyOfFromType(type, options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.mjs
@@ -151676,7 +152382,7 @@ function CompositeKeys(T2) {
   return SetDistinct(Acc);
 }
 function FilterNever(T2) {
-  return T2.filter((L) => !IsNever(L));
+  return T2.filter((L) => !IsNever2(L));
 }
 function CompositeProperty(T2, K) {
   const Acc = [];
@@ -151750,7 +152456,7 @@ function Const(T2, options) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/constructor-parameters/constructor-parameters.mjs
 function ConstructorParameters(schema, options) {
-  return IsConstructor(schema) ? Tuple(schema.parameters, options) : Never(options);
+  return IsConstructor2(schema) ? Tuple(schema.parameters, options) : Never(options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/enum/enum.mjs
@@ -152029,7 +152735,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 IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T2, F, options) : IsMappedKey(L) ? CreateType(ExtendsFromMappedKey(L, R, T2, F, options)) : CreateType(ExtendsResolve(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);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-key.mjs
@@ -152076,11 +152782,11 @@ function ExcludeRest(L, R) {
   return excluded.length === 1 ? excluded[0] : Union(excluded);
 }
 function Exclude(L, R, options = {}) {
-  if (IsTemplateLiteral(L))
+  if (IsTemplateLiteral2(L))
     return CreateType(ExcludeFromTemplateLiteral(L, R), options);
-  if (IsMappedResult(L))
+  if (IsMappedResult2(L))
     return CreateType(ExcludeFromMappedResult(L, R), options);
-  return CreateType(IsUnion(L) ? ExcludeRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? Never() : L, options);
+  return CreateType(IsUnion2(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
@@ -152109,11 +152815,11 @@ function ExtractRest(L, R) {
   return extracted.length === 1 ? extracted[0] : Union(extracted);
 }
 function Extract(L, R, options) {
-  if (IsTemplateLiteral(L))
+  if (IsTemplateLiteral2(L))
     return CreateType(ExtractFromTemplateLiteral(L, R), options);
-  if (IsMappedResult(L))
+  if (IsMappedResult2(L))
     return CreateType(ExtractFromMappedResult(L, R), options);
-  return CreateType(IsUnion(L) ? ExtractRest(L.anyOf, R) : ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
+  return CreateType(IsUnion2(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
@@ -152133,7 +152839,7 @@ function ExtractFromMappedResult(R, T2) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
 function InstanceType(schema, options) {
-  return IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options);
+  return IsConstructor2(schema) ? CreateType(schema.returns, options) : Never(options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs
@@ -152183,7 +152889,7 @@ function FromNumberKey(_2, type, options) {
   return RecordCreateFromPattern(PatternNumberExact, type, options);
 }
 function Record(key, type, options = {}) {
-  return IsUnion(key) ? FromUnionKey(key.anyOf, type, options) : IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) : IsLiteral(key) ? FromLiteralKey(key.const, type, options) : 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);
+  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);
 }
 function RecordPattern(record) {
   return globalThis.Object.getOwnPropertyNames(record.patternProperties)[0];
@@ -152251,8 +152957,8 @@ function FromArgument(args, argument) {
   return argument.index in args ? args[argument.index] : Unknown();
 }
 function FromProperty2(args, type) {
-  const isReadonly = IsReadonly(type);
-  const isOptional = IsOptional(type);
+  const isReadonly = IsReadonly2(type);
+  const isOptional = IsOptional2(type);
   const mapped = FromType(args, type);
   return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
 }
@@ -152265,7 +152971,7 @@ function FromTypes(args, types) {
   return types.map((type) => FromType(args, type));
 }
 function FromType(args, 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;
+  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;
 }
 function Instantiate(type, args) {
   return FromType(args, CloneType(type));
@@ -152329,7 +153035,7 @@ function FromRest5(T2, M) {
   return T2.map((L) => Intrinsic(L, M));
 }
 function Intrinsic(schema, mode, 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);
+  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);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/intrinsic/capitalize.mjs
@@ -152387,18 +153093,18 @@ function FromObject3(type, propertyKeys, properties) {
   return Object2(mappedProperties, options);
 }
 function UnionFromPropertyKeys(propertyKeys) {
-  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue2(key) ? [...result2, Literal(key)] : result2, []);
   return Union(result);
 }
 function OmitResolve(type, propertyKeys) {
-  return IsIntersect(type) ? Intersect(FromIntersect6(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion8(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject3(type, propertyKeys, type.properties) : Object2({});
+  return IsIntersect2(type) ? Intersect(FromIntersect6(type.allOf, propertyKeys)) : IsUnion2(type) ? Union(FromUnion8(type.anyOf, propertyKeys)) : IsObject4(type) ? FromObject3(type, propertyKeys, type.properties) : Object2({});
 }
 function Omit(type, key, options) {
   const typeKey = IsArray(key) ? UnionFromPropertyKeys(key) : key;
-  const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
-  const isTypeRef = IsRef(type);
-  const isKeyRef = IsRef(key);
-  return IsMappedResult(type) ? OmitFromMappedResult(type, propertyKeys, options) : IsMappedKey(key) ? OmitFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Omit", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Omit", [type, typeKey], options) : CreateType({ ...OmitResolve(type, propertyKeys), ...options });
+  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 });
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/omit/omit-from-mapped-key.mjs
@@ -152453,18 +153159,18 @@ function FromObject4(Type, keys, properties) {
   return Object2(mappedProperties, options);
 }
 function UnionFromPropertyKeys2(propertyKeys) {
-  const result = propertyKeys.reduce((result2, key) => IsLiteralValue(key) ? [...result2, Literal(key)] : result2, []);
+  const result = propertyKeys.reduce((result2, key) => IsLiteralValue2(key) ? [...result2, Literal(key)] : result2, []);
   return Union(result);
 }
 function PickResolve(type, propertyKeys) {
-  return IsIntersect(type) ? Intersect(FromIntersect7(type.allOf, propertyKeys)) : IsUnion(type) ? Union(FromUnion9(type.anyOf, propertyKeys)) : IsObject3(type) ? FromObject4(type, propertyKeys, type.properties) : Object2({});
+  return IsIntersect2(type) ? Intersect(FromIntersect7(type.allOf, propertyKeys)) : IsUnion2(type) ? Union(FromUnion9(type.anyOf, propertyKeys)) : IsObject4(type) ? FromObject4(type, propertyKeys, type.properties) : Object2({});
 }
 function Pick(type, key, options) {
   const typeKey = IsArray(key) ? UnionFromPropertyKeys2(key) : key;
-  const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
-  const isTypeRef = IsRef(type);
-  const isKeyRef = IsRef(key);
-  return IsMappedResult(type) ? PickFromMappedResult(type, propertyKeys, options) : IsMappedKey(key) ? PickFromMappedKey(type, key, options) : isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : !isTypeRef && isKeyRef ? Computed("Pick", [type, typeKey], options) : isTypeRef && !isKeyRef ? Computed("Pick", [type, typeKey], options) : CreateType({ ...PickResolve(type, propertyKeys), ...options });
+  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 });
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/pick/pick-from-mapped-key.mjs
@@ -152508,10 +153214,10 @@ function FromRest6(types) {
   return types.map((type) => PartialResolve(type));
 }
 function PartialResolve(type) {
-  return IsComputed(type) ? FromComputed3(type.target, type.parameters) : IsRef(type) ? FromRef3(type.$ref) : IsIntersect(type) ? Intersect(FromRest6(type.allOf)) : IsUnion(type) ? Union(FromRest6(type.anyOf)) : IsObject3(type) ? 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({});
+  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({});
 }
 function Partial(type, options) {
-  if (IsMappedResult(type)) {
+  if (IsMappedResult2(type)) {
     return PartialFromMappedResult(type, options);
   } else {
     return CreateType({ ...PartialResolve(type), ...options });
@@ -152555,10 +153261,10 @@ function FromRest7(types) {
   return types.map((type) => RequiredResolve(type));
 }
 function RequiredResolve(type) {
-  return IsComputed(type) ? FromComputed4(type.target, type.parameters) : IsRef(type) ? FromRef4(type.$ref) : IsIntersect(type) ? Intersect(FromRest7(type.allOf)) : IsUnion(type) ? Union(FromRest7(type.anyOf)) : IsObject3(type) ? 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({});
+  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({});
 }
 function Required(type, options) {
-  if (IsMappedResult(type)) {
+  if (IsMappedResult2(type)) {
     return RequiredFromMappedResult(type, options);
   } else {
     return CreateType({ ...RequiredResolve(type), ...options });
@@ -152583,11 +153289,11 @@ function RequiredFromMappedResult(R, options) {
 // ../../node_modules/@sinclair/typebox/build/esm/type/module/compute.mjs
 function DereferenceParameters(moduleProperties, types) {
   return types.map((type) => {
-    return IsRef(type) ? Dereference(moduleProperties, type.$ref) : FromType2(moduleProperties, type);
+    return IsRef2(type) ? Dereference(moduleProperties, type.$ref) : FromType2(moduleProperties, type);
   });
 }
 function Dereference(moduleProperties, ref) {
-  return ref in moduleProperties ? IsRef(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType2(moduleProperties, moduleProperties[ref]) : Never();
+  return ref in moduleProperties ? IsRef2(moduleProperties[ref]) ? Dereference(moduleProperties, moduleProperties[ref].$ref) : FromType2(moduleProperties, moduleProperties[ref]) : Never();
 }
 function FromAwaited(parameters) {
   return Awaited(parameters[0]);
@@ -152644,7 +153350,7 @@ function FromRecord3(moduleProperties, type) {
   return result;
 }
 function FromTransform(moduleProperties, transform) {
-  return IsRef(transform) ? { ...Dereference(moduleProperties, transform.$ref), [TransformKind]: transform[TransformKind] } : transform;
+  return IsRef2(transform) ? { ...Dereference(moduleProperties, transform.$ref), [TransformKind]: transform[TransformKind] } : transform;
 }
 function FromTuple5(moduleProperties, types) {
   return Tuple(FromTypes2(moduleProperties, types));
@@ -152656,7 +153362,7 @@ function FromTypes2(moduleProperties, types) {
   return types.map((type) => FromType2(moduleProperties, type));
 }
 function FromType2(moduleProperties, 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;
+  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;
 }
 function ComputeType(moduleProperties, key) {
   return key in moduleProperties ? FromType2(moduleProperties, moduleProperties[key]) : Never();
@@ -152695,7 +153401,7 @@ function Not2(type, options) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/parameters/parameters.mjs
 function Parameters(schema, options) {
-  return IsFunction3(schema) ? Tuple(schema.parameters, options) : Never();
+  return IsFunction4(schema) ? Tuple(schema.parameters, options) : Never();
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/recursive/recursive.mjs
@@ -152716,7 +153422,7 @@ function RegExp2(unresolved, options) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/rest/rest.mjs
 function RestResolve(T2) {
-  return IsIntersect(T2) ? T2.allOf : IsUnion(T2) ? T2.anyOf : IsTuple(T2) ? T2.items ?? [] : [];
+  return IsIntersect2(T2) ? T2.allOf : IsUnion2(T2) ? T2.anyOf : IsTuple2(T2) ? T2.items ?? [] : [];
 }
 function Rest(T2) {
   return RestResolve(T2);
@@ -152724,7 +153430,7 @@ function Rest(T2) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/return-type/return-type.mjs
 function ReturnType(schema, options) {
-  return IsFunction3(schema) ? CreateType(schema.returns, options) : Never(options);
+  return IsFunction4(schema) ? CreateType(schema.returns, options) : Never(options);
 }
 
 // ../../node_modules/@sinclair/typebox/build/esm/type/transform/transform.mjs
@@ -152753,7 +153459,7 @@ class TransformEncodeBuilder {
     return { ...schema, [TransformKind]: Codec };
   }
   Encode(encode) {
-    return IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
+    return IsTransform2(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
   }
 }
 function Transform(schema) {
@@ -153278,7 +153984,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 (IsSchema(schema.unevaluatedProperties)) {
+  } else if (IsSchema2(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;
@@ -154803,7 +155509,7 @@ function Cast(...args) {
 }
 // ../../node_modules/@sinclair/typebox/build/esm/value/clean/clean.mjs
 function IsCheckable(schema) {
-  return IsKind(schema) && schema[Kind] !== "Unsafe";
+  return IsKind2(schema) && schema[Kind] !== "Unsafe";
 }
 function FromArray12(schema, references, value) {
   if (!IsArray2(value))
@@ -154819,7 +155525,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) || !IsKind(unevaluatedProperties))
+  if (!IsObject2(value) || !IsObject2(composite) || !IsKind2(unevaluatedProperties))
     return composite;
   const knownkeys = KeyOfPropertyKeys(schema);
   for (const key of Object.getOwnPropertyNames(value)) {
@@ -154840,7 +155546,7 @@ function FromObject13(schema, references, value) {
       value[key] = Visit9(schema.properties[key], references, value[key]);
       continue;
     }
-    if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
+    if (IsKind2(additionalProperties) && Check(additionalProperties, references, value[key])) {
       value[key] = Visit9(additionalProperties, references, value[key]);
       continue;
     }
@@ -154860,7 +155566,7 @@ function FromRecord8(schema, references, value) {
       value[key] = Visit9(propertySchema, references, value[key]);
       continue;
     }
-    if (IsKind(additionalProperties) && Check(additionalProperties, references, value[key])) {
+    if (IsKind2(additionalProperties) && Check(additionalProperties, references, value[key])) {
       value[key] = Visit9(additionalProperties, references, value[key]);
       continue;
     }
@@ -155154,7 +155860,7 @@ class TransformDecodeError extends TypeBoxError {
 }
 function Default3(schema, path6, value) {
   try {
-    return IsTransform(schema) ? schema[TransformKind].Decode(value) : value;
+    return IsTransform2(schema) ? schema[TransformKind].Decode(value) : value;
   } catch (error) {
     throw new TransformDecodeError(schema, path6, value, error);
   }
@@ -155172,7 +155878,7 @@ function FromIntersect15(schema, references, path6, value) {
     if (knownKey in knownProperties) {
       knownProperties[knownKey] = Visit11(knownSchema, references, `${path6}/${knownKey}`, knownProperties[knownKey]);
     }
-  if (!IsTransform(schema.unevaluatedProperties)) {
+  if (!IsTransform2(schema.unevaluatedProperties)) {
     return Default3(schema, path6, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -155201,11 +155907,11 @@ function FromObject15(schema, references, path6, value) {
   for (const key of knownKeys) {
     if (!HasPropertyKey2(knownProperties, key))
       continue;
-    if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+    if (IsUndefined2(knownProperties[key]) && (!IsUndefined4(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
     knownProperties[key] = Visit11(schema.properties[key], references, `${path6}/${key}`, knownProperties[key]);
   }
-  if (!IsSchema(schema.additionalProperties)) {
+  if (!IsSchema2(schema.additionalProperties)) {
     return Default3(schema, path6, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -155227,7 +155933,7 @@ function FromRecord10(schema, references, path6, value) {
     if (knownKeys.test(key)) {
       knownProperties[key] = Visit11(schema.patternProperties[pattern], references, `${path6}/${key}`, knownProperties[key]);
     }
-  if (!IsSchema(schema.additionalProperties)) {
+  if (!IsSchema2(schema.additionalProperties)) {
     return Default3(schema, path6, knownProperties);
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -155314,7 +156020,7 @@ class TransformEncodeError extends TypeBoxError {
 }
 function Default4(schema, path6, value) {
   try {
-    return IsTransform(schema) ? schema[TransformKind].Encode(value) : value;
+    return IsTransform2(schema) ? schema[TransformKind].Encode(value) : value;
   } catch (error) {
     throw new TransformEncodeError(schema, path6, value, error);
   }
@@ -155340,7 +156046,7 @@ function FromIntersect16(schema, references, path6, value) {
     if (knownKey in knownProperties) {
       knownProperties[knownKey] = Visit12(knownSchema, references, `${path6}/${knownKey}`, knownProperties[knownKey]);
     }
-  if (!IsTransform(schema.unevaluatedProperties)) {
+  if (!IsTransform2(schema.unevaluatedProperties)) {
     return knownProperties;
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -155364,11 +156070,11 @@ function FromObject16(schema, references, path6, value) {
   for (const key of knownKeys) {
     if (!HasPropertyKey2(knownProperties, key))
       continue;
-    if (IsUndefined2(knownProperties[key]) && (!IsUndefined3(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
+    if (IsUndefined2(knownProperties[key]) && (!IsUndefined4(schema.properties[key]) || TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
       continue;
     knownProperties[key] = Visit12(schema.properties[key], references, `${path6}/${key}`, knownProperties[key]);
   }
-  if (!IsSchema(schema.additionalProperties)) {
+  if (!IsSchema2(schema.additionalProperties)) {
     return knownProperties;
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -155391,7 +156097,7 @@ function FromRecord11(schema, references, path6, value) {
     if (knownKeys.test(key)) {
       knownProperties[key] = Visit12(schema.patternProperties[pattern], references, `${path6}/${key}`, knownProperties[key]);
     }
-  if (!IsSchema(schema.additionalProperties)) {
+  if (!IsSchema2(schema.additionalProperties)) {
     return knownProperties;
   }
   const unknownKeys = Object.getOwnPropertyNames(knownProperties);
@@ -155466,57 +156172,57 @@ function TransformEncode(schema, references, value) {
 
 // ../../node_modules/@sinclair/typebox/build/esm/value/transform/has.mjs
 function FromArray16(schema, references) {
-  return IsTransform(schema) || Visit13(schema.items, references);
+  return IsTransform2(schema) || Visit13(schema.items, references);
 }
 function FromAsyncIterator7(schema, references) {
-  return IsTransform(schema) || Visit13(schema.items, references);
+  return IsTransform2(schema) || Visit13(schema.items, references);
 }
 function FromConstructor8(schema, references) {
-  return IsTransform(schema) || Visit13(schema.returns, references) || schema.parameters.some((schema2) => Visit13(schema2, references));
+  return IsTransform2(schema) || Visit13(schema.returns, references) || schema.parameters.some((schema2) => Visit13(schema2, references));
 }
 function FromFunction7(schema, references) {
-  return IsTransform(schema) || Visit13(schema.returns, references) || schema.parameters.some((schema2) => Visit13(schema2, references));
+  return IsTransform2(schema) || Visit13(schema.returns, references) || schema.parameters.some((schema2) => Visit13(schema2, references));
 }
 function FromIntersect17(schema, references) {
-  return IsTransform(schema) || IsTransform(schema.unevaluatedProperties) || schema.allOf.some((schema2) => Visit13(schema2, references));
+  return IsTransform2(schema) || IsTransform2(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 IsTransform(schema) || Visit13(target, [...additional, ...references]);
+  return IsTransform2(schema) || Visit13(target, [...additional, ...references]);
 }
 function FromIterator7(schema, references) {
-  return IsTransform(schema) || Visit13(schema.items, references);
+  return IsTransform2(schema) || Visit13(schema.items, references);
 }
 function FromNot7(schema, references) {
-  return IsTransform(schema) || Visit13(schema.not, references);
+  return IsTransform2(schema) || Visit13(schema.not, references);
 }
 function FromObject17(schema, references) {
-  return IsTransform(schema) || Object.values(schema.properties).some((schema2) => Visit13(schema2, references)) || IsSchema(schema.additionalProperties) && Visit13(schema.additionalProperties, references);
+  return IsTransform2(schema) || Object.values(schema.properties).some((schema2) => Visit13(schema2, references)) || IsSchema2(schema.additionalProperties) && Visit13(schema.additionalProperties, references);
 }
 function FromPromise7(schema, references) {
-  return IsTransform(schema) || Visit13(schema.item, references);
+  return IsTransform2(schema) || Visit13(schema.item, references);
 }
 function FromRecord12(schema, references) {
   const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
   const property = schema.patternProperties[pattern];
-  return IsTransform(schema) || Visit13(property, references) || IsSchema(schema.additionalProperties) && IsTransform(schema.additionalProperties);
+  return IsTransform2(schema) || Visit13(property, references) || IsSchema2(schema.additionalProperties) && IsTransform2(schema.additionalProperties);
 }
 function FromRef13(schema, references) {
-  if (IsTransform(schema))
+  if (IsTransform2(schema))
     return true;
   return Visit13(Deref(schema, references), references);
 }
 function FromThis9(schema, references) {
-  if (IsTransform(schema))
+  if (IsTransform2(schema))
     return true;
   return Visit13(Deref(schema, references), references);
 }
 function FromTuple14(schema, references) {
-  return IsTransform(schema) || !IsUndefined2(schema.items) && schema.items.some((schema2) => Visit13(schema2, references));
+  return IsTransform2(schema) || !IsUndefined2(schema.items) && schema.items.some((schema2) => Visit13(schema2, references));
 }
 function FromUnion19(schema, references) {
-  return IsTransform(schema) || schema.anyOf.some((schema2) => Visit13(schema2, references));
+  return IsTransform2(schema) || schema.anyOf.some((schema2) => Visit13(schema2, references));
 }
 function Visit13(schema, references) {
   const references_ = Pushref(schema, references);
@@ -155557,7 +156263,7 @@ function Visit13(schema, references) {
     case "Union":
       return FromUnion19(schema_, references_);
     default:
-      return IsTransform(schema);
+      return IsTransform2(schema);
   }
 }
 var visited = new Set;
@@ -155580,7 +156286,7 @@ function ValueOrDefault(schema, value) {
   return IsUndefined2(value) ? clone : IsObject2(value) && IsObject2(clone) ? Object.assign(clone, value) : value;
 }
 function HasDefaultProperty(schema) {
-  return IsKind(schema) && "default" in schema;
+  return IsKind2(schema) && "default" in schema;
 }
 function FromArray17(schema, references, value) {
   if (IsArray2(value)) {
@@ -156318,8 +157024,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 (IsSchema2(schema.contains) || IsNumber2(schema.minContains) || IsNumber2(schema.maxContains)) {
-      const containsSchema = IsSchema2(schema.contains) ? schema.contains : Never();
+    if (IsSchema(schema.contains) || IsNumber2(schema.minContains) || IsNumber2(schema.maxContains)) {
+      const containsSchema = IsSchema(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})`] : [];
@@ -156396,7 +157102,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 (IsSchema2(schema.unevaluatedProperties)) {
+    } else if (IsSchema(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})`;
@@ -156482,7 +157188,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 = IsSchema2(schema.additionalProperties) ? CreateExpression(schema.additionalProperties, references, value) : schema.additionalProperties === false ? "false" : "true";
+    const check2 = IsSchema(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}))`;
   }
@@ -156700,10 +157406,10 @@ var TypeCompiler;
     state.variables.clear();
     state.functions.clear();
     state.instances.clear();
-    if (!IsSchema2(schema))
+    if (!IsSchema(schema))
       throw new TypeCompilerTypeGuardError(schema);
     for (const schema2 of references)
-      if (!IsSchema2(schema2))
+      if (!IsSchema(schema2))
         throw new TypeCompilerTypeGuardError(schema2);
     return Build(schema, references, options);
   }
@@ -173418,438 +174124,7 @@ class GetAnalyticsTool {
 }
 // ../../packages/core/dist/tools/get_optimized_context.js
 init_dist();
-
-// ../../packages/core/dist/controllers/context-controller.js
-init_dist();
-init_search_controller();
-init_memory_controller();
-
-// ../../packages/core/dist/tools/compress_context.js
-init_code_compressor();
-init_dist();
-init_dist();
-init_enum_validation();
-
-class CompressContextTool {
-  name = "compress_context";
-  description = "Compress context using semantic compression (keeps structure, removes details)";
-  inputSchema = {
-    type: "object",
-    properties: {
-      content: {
-        type: "string",
-        description: "Content to compress"
-      },
-      strategy: {
-        type: "string",
-        enum: [
-          "code_structure",
-          "conversation_summary",
-          "semantic_dedup",
-          "hierarchical"
-        ],
-        description: "Compression strategy",
-        default: "code_structure"
-      },
-      language: {
-        type: "string",
-        description: "Programming language (for code compression)"
-      },
-      targetRatio: {
-        type: "number",
-        description: "Target compression ratio (0-1, e.g., 0.7 = 70% reduction)",
-        default: 0.7
-      }
-    },
-    required: ["content"]
-  };
-  compressor;
-  constructor() {
-    this.compressor = new CodeCompressor;
-  }
-  async handle(params) {
-    const { content, language, targetRatio = 0.7 } = params;
-    const strategy = validateEnum("strategy", params.strategy ?? "code_structure", [
-      "code_structure",
-      "conversation_summary",
-      "semantic_dedup",
-      "hierarchical"
-    ]);
-    try {
-      const originalTokens = estimateTokens(content, language || "code");
-      logger.info("Compressing context", {
-        originalTokens,
-        strategy,
-        targetRatio
-      });
-      const result = await this.compressor.compress(content, strategy);
-      const compressedTokens = estimateTokens(result.compressed, language || "code");
-      const actualRatio = 1 - compressedTokens / originalTokens;
-      const tokensSaved = originalTokens - compressedTokens;
-      logger.info("Context compressed", {
-        originalTokens,
-        compressedTokens,
-        tokensSaved,
-        actualRatio: actualRatio.toFixed(2),
-        targetRatio
-      });
-      return {
-        success: true,
-        data: {
-          compressed: result.compressed,
-          originalLength: content.length,
-          compressedLength: result.compressed.length,
-          originalTokens,
-          compressedTokens,
-          strategy
-        },
-        metadata: {
-          tokensSaved,
-          compressionRatio: actualRatio
-        }
-      };
-    } catch (error51) {
-      logger.error("Failed to compress context", error51, {
-        strategy,
-        contentLength: typeof content === "string" ? content.length : 0
-      });
-      return {
-        success: false,
-        error: `Failed to compress context: ${error51.message}`
-      };
-    }
-  }
-}
-
-// ../../packages/core/dist/controllers/context-controller.js
-init_session_file_cache();
-init_symbol_graph_service();
-init_token_metrics();
-
-class ContextController {
-  static instance = null;
-  searchCtrl;
-  memoryCtrl;
-  compressor;
-  sessionCache;
-  constructor() {
-    this.searchCtrl = SearchController.getInstance();
-    this.memoryCtrl = MemoryController.getInstance();
-    this.compressor = new CompressContextTool;
-    this.sessionCache = SessionFileCache.getInstance();
-  }
-  static getInstance() {
-    if (!ContextController.instance) {
-      ContextController.instance = new ContextController;
-    }
-    return ContextController.instance;
-  }
-  async getOptimizedContext(input) {
-    const { query, projectId, projectPath: projectPath2, maxTokens = 4000, maxResults = 5, workingMemoryBudget, userId, sessionId, includeMemories = true, memoryBudgetRatio = 0.2 } = input;
-    const clampedRatio = Math.max(0, Math.min(0.5, memoryBudgetRatio));
-    const memoryTokenBudget = includeMemories ? Math.floor(maxTokens * clampedRatio) : 0;
-    const codeTokenBudget = maxTokens - memoryTokenBudget;
-    const wmBudget = workingMemoryBudget || Math.floor(codeTokenBudget * 0.8);
-    logger.info("Getting optimized context", {
-      query: query.slice(0, 50),
-      projectId,
-      maxTokens,
-      includeMemories,
-      memoryTokenBudget,
-      codeTokenBudget,
-      workingMemoryBudget: wmBudget
-    });
-    let graphContextSection = "";
-    let graphBoostFiles = [];
-    if (projectId && await symbolGraphService.hasData(projectId) && looksLikeSymbol(query)) {
-      try {
-        const [defs, refs] = await Promise.all([
-          symbolGraphService.goToDefinition(projectId, query),
-          symbolGraphService.getReferences(projectId, query)
-        ]);
-        if (defs.length > 0) {
-          const graphTokenBudget = Math.floor(codeTokenBudget * 0.2);
-          graphContextSection = formatGraphContext(defs, refs, graphTokenBudget);
-          graphBoostFiles = [
-            ...new Set([
-              ...defs.map((d) => d.file),
-              ...refs.slice(0, 10).map((r2) => r2.fromFile)
-            ])
-          ];
-          logger.debug("Graph prefilter hit", {
-            query,
-            defs: defs.length,
-            refs: refs.length,
-            boostFiles: graphBoostFiles.length
-          });
-        }
-      } catch (err) {
-        logger.warn("Graph prefilter failed", { query, error: err.message });
-      }
-    }
-    const [searchResult, memories] = await Promise.all([
-      this.searchCtrl.searchProject({
-        query,
-        projectId,
-        projectPath: projectPath2,
-        maxResults,
-        responseMode: "full",
-        autoReindex: false,
-        minScore: 0.4,
-        boostFiles: graphBoostFiles.length > 0 ? graphBoostFiles : undefined
-      }),
-      includeMemories ? this.searchMemoriesSafe(query, {
-        projectId,
-        userId,
-        sessionId,
-        limit: 5
-      }) : Promise.resolve([])
-    ]);
-    const codeResults = searchResult.results;
-    const workingSet = this.selectWorkingSet(codeResults, wmBudget);
-    const memorySection = this.formatMemorySection(memories, memoryTokenBudget);
-    if (workingSet.length === 0 && memories.length === 0) {
-      return {
-        context: `No relevant code or memories found for query: "${query}"`,
-        sources: [],
-        resultsCount: 0,
-        memoriesCount: 0,
-        tokensSaved: 0,
-        compressionRatio: 0,
-        sessionCacheHits: 0,
-        tokensSavedBySessionCache: 0
-      };
-    }
-    let sessionCacheHits = 0;
-    let tokensSavedBySessionCache = 0;
-    const deliveryPlan = workingSet.map((r2) => {
-      if (!sessionId) {
-        return { result: r2, kind: "full", tokensSaved: 0 };
-      }
-      const content = r2.content || r2.preview || "";
-      const key = this.sessionCache.chunkKey(r2.filePath || "unknown", r2.lineStart ?? 0, r2.lineEnd ?? 0);
-      const check3 = this.sessionCache.check(sessionId, key, content);
-      if (check3.status === "unchanged") {
-        sessionCacheHits++;
-        tokensSavedBySessionCache += check3.tokensSaved;
-        return { result: r2, kind: "ref", tokensSaved: check3.tokensSaved };
-      }
-      if (check3.status === "changed" && check3.diff !== undefined) {
-        sessionCacheHits++;
-        tokensSavedBySessionCache += check3.tokensSaved;
-        return { result: r2, kind: "diff", diff: check3.diff, tokensSaved: check3.tokensSaved };
-      }
-      return { result: r2, kind: "full", tokensSaved: 0 };
-    });
-    const parts = [`# Context for: ${query}
-`];
-    if (graphContextSection) {
-      parts.push(graphContextSection, "");
-    }
-    if (memorySection) {
-      parts.push(memorySection, "");
-    }
-    if (deliveryPlan.length > 0) {
-      const fullCount = deliveryPlan.filter((d) => d.kind === "full").length;
-      const refCount = deliveryPlan.filter((d) => d.kind === "ref").length;
-      const diffCount = deliveryPlan.filter((d) => d.kind === "diff").length;
-      parts.push(`## Code (${deliveryPlan.length} sections \u2014 ${fullCount} full, ${refCount} cached, ${diffCount} diff | WM budget: ${wmBudget} tokens)
-`);
-      deliveryPlan.forEach(({ result: r2, kind, diff }, idx) => {
-        const filePath = r2.filePath || "Unknown";
-        const scoreLabel = (r2.score * 100).toFixed(1);
-        const lineRange = `${r2.lineStart ?? "?"}-${r2.lineEnd ?? "?"}`;
-        parts.push(`### ${idx + 1}. ${filePath} (score: ${scoreLabel}%)`);
-        parts.push(`Lines ${lineRange}
-`);
-        if (kind === "ref") {
-          parts.push(`[CACHED: ${filePath}:${lineRange}]
-`);
-        } else if (kind === "diff" && diff) {
-          parts.push("```diff");
-          parts.push(diff);
-          parts.push("```\n");
-        } else {
-          parts.push("```" + (r2.language || ""));
-          parts.push(r2.content || r2.preview || "(no content)");
-          parts.push("```\n");
-        }
-      });
-    }
-    const rawContext = parts.join(`
-`);
-    const rawTokens = estimateTokens(rawContext, "code");
-    let finalContext = rawContext;
-    let compressionRatio = 0;
-    let tokensSaved = 0;
-    if (rawTokens > maxTokens) {
-      logger.info("Context exceeds maxTokens, compressing", {
-        rawTokens,
-        maxTokens
-      });
-      const resp = await this.compressor.handle({
-        content: rawContext,
-        strategy: "code_structure",
-        targetRatio: 0.6
-      });
-      if (resp.success && resp.data) {
-        finalContext = resp.data.compressed;
-        compressionRatio = resp.metadata?.compressionRatio || 0;
-        tokensSaved = resp.metadata?.tokensSaved || 0;
-      }
-    }
-    const finalTokens = estimateTokens(finalContext, "code");
-    const totalTokensSaved = rawTokens - finalTokens;
-    const compressionSavings = tokensSaved;
-    TokenMetrics.getInstance().recordContextRequest(rawTokens, finalTokens, tokensSavedBySessionCache, compressionSavings);
-    logger.info("Optimized context retrieved", {
-      rawTokens,
-      finalTokens,
-      tokensSaved: totalTokensSaved,
-      compressionRatio,
-      codeSources: workingSet.length,
-      memoriesIncluded: memories.length,
-      wmBudget,
-      sessionCacheHits,
-      tokensSavedBySessionCache
-    });
-    return {
-      context: finalContext,
-      sources: workingSet.map((r2) => r2.filePath || "unknown"),
-      resultsCount: workingSet.length,
-      memoriesCount: memories.length,
-      tokensSaved: totalTokensSaved,
-      compressionRatio,
-      sessionCacheHits,
-      tokensSavedBySessionCache
-    };
-  }
-  async searchMemoriesSafe(query, opts) {
-    try {
-      const result = await this.memoryCtrl.search({
-        query,
-        projectId: opts.projectId,
-        userId: opts.userId,
-        sessionId: opts.sessionId,
-        includePersistent: true,
-        minImportance: 0.3,
-        limit: opts.limit
-      });
-      return result.memories;
-    } catch (error51) {
-      logger.warn("Memory search failed, continuing without memories", {
-        error: error51.message,
-        query: query.slice(0, 30)
-      });
-      return [];
-    }
-  }
-  formatMemorySection(memories, tokenBudget) {
-    if (memories.length === 0 || tokenBudget <= 0)
-      return null;
-    const parts = [
-      `## Relevant Memories (from previous sessions)
-`
-    ];
-    let usedTokens = estimateTokens(parts[0], "text");
-    for (const memory of memories) {
-      const typeLabel = (memory.type || "unknown").toUpperCase();
-      const score = memory.score ? ` (relevance: ${(memory.score * 100).toFixed(0)}%)` : "";
-      const importance = memory.importance ? ` [importance: ${(memory.importance * 100).toFixed(0)}%]` : "";
-      const agent = memory.agentId ? ` (by: ${memory.agentId})` : "";
-      const entry2 = `- **[${typeLabel}]**${score}${importance}${agent}: ${memory.content}`;
-      const entryTokens = estimateTokens(entry2, "text");
-      if (usedTokens + entryTokens > tokenBudget)
-        break;
-      parts.push(entry2);
-      usedTokens += entryTokens;
-    }
-    return parts.length <= 1 ? null : parts.join(`
-`);
-  }
-  selectWorkingSet(results, tokenBudget) {
-    if (!results.length || tokenBudget <= 0)
-      return [];
-    const selected = [];
-    const selectedFiles = new Set;
-    let usedTokens = 0;
-    const sorted = [...results].sort((a12, b) => (b.score || 0) - (a12.score || 0));
-    for (const result of sorted) {
-      const filePath = result.filePath || "unknown";
-      if (selectedFiles.has(filePath))
-        continue;
-      const content = result.content || result.preview || "";
-      const tokens = estimateTokens(content, "code");
-      if (usedTokens + tokens > tokenBudget)
-        continue;
-      selected.push(result);
-      selectedFiles.add(filePath);
-      usedTokens += tokens;
-    }
-    for (const result of sorted) {
-      if (selected.includes(result))
-        continue;
-      const content = result.content || result.preview || "";
-      const tokens = estimateTokens(content, "code");
-      if (usedTokens + tokens > tokenBudget)
-        continue;
-      selected.push(result);
-      usedTokens += tokens;
-    }
-    return selected;
-  }
-}
-function looksLikeSymbol(query) {
-  if (query.length > 80)
-    return false;
-  const words = query.trim().split(/\s+/);
-  if (words.length > 3)
-    return false;
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(words[0]);
-}
-function formatGraphContext(defs, refs, tokenBudget) {
-  const parts = [`## Symbol Graph
-`];
-  if (defs.length > 0) {
-    parts.push(`### Definition(s)
-`);
-    for (const def of defs.slice(0, 3)) {
-      parts.push(`- **${def.kind}** \`${def.name}\` \u2192 \`${def.file}\` L${def.lineStart}\u2013${def.lineEnd}`);
-      if (def.docComment)
-        parts.push(`  > ${def.docComment.slice(0, 120)}`);
-      if (def.snippet) {
-        parts.push("  ```");
-        parts.push(def.snippet.split(`
-`).slice(0, 8).join(`
-`));
-        parts.push("  ```");
-      }
-    }
-    parts.push("");
-  }
-  if (refs.length > 0) {
-    parts.push(`### References (${refs.length} total)
-`);
-    const byFile = new Map;
-    for (const r2 of refs.slice(0, 30)) {
-      const arr = byFile.get(r2.fromFile) ?? [];
-      arr.push(r2.fromLine);
-      byFile.set(r2.fromFile, arr);
-    }
-    for (const [file3, lines] of byFile) {
-      parts.push(`- \`${file3}\` L${lines.join(", ")}`);
-    }
-    parts.push("");
-  }
-  const section = parts.join(`
-`);
-  const charBudget = tokenBudget * 4;
-  return section.length > charBudget ? section.slice(0, charBudget) + `
-...
-` : section;
-}
-
-// ../../packages/core/dist/tools/get_optimized_context.js
+init_context_controller();
 class GetOptimizedContextTool {
   name = "get_optimized_context";
   description = "Retrieve code context + persistent memories with maximum token efficiency (search + memories + compress)";
@@ -173949,6 +174224,86 @@ class GetOptimizedContextTool {
     }
   }
 }
+// ../../packages/core/dist/tools/compress_context.js
+init_code_compressor();
+init_compress_with_metrics();
+init_dist();
+init_enum_validation();
+
+class CompressContextTool {
+  name = "compress_context";
+  description = "Compress context using semantic compression (keeps structure, removes details)";
+  inputSchema = {
+    type: "object",
+    properties: {
+      content: {
+        type: "string",
+        description: "Content to compress"
+      },
+      strategy: {
+        type: "string",
+        enum: [
+          "code_structure",
+          "conversation_summary",
+          "semantic_dedup",
+          "hierarchical"
+        ],
+        description: "Compression strategy",
+        default: "code_structure"
+      },
+      language: {
+        type: "string",
+        description: "Programming language (for code compression)"
+      },
+      targetRatio: {
+        type: "number",
+        description: "Target compression ratio (0-1, e.g., 0.7 = 70% reduction)",
+        default: 0.7
+      }
+    },
+    required: ["content"]
+  };
+  compressor;
+  constructor() {
+    this.compressor = new CodeCompressor;
+  }
+  async handle(params) {
+    const { content, language, targetRatio = 0.7 } = params;
+    const strategy = validateEnum("strategy", params.strategy ?? "code_structure", [
+      "code_structure",
+      "conversation_summary",
+      "semantic_dedup",
+      "hierarchical"
+    ]);
+    try {
+      const metrics2 = await compressWithMetrics(this.compressor, content, strategy, { language, targetRatio });
+      return {
+        success: true,
+        data: {
+          compressed: metrics2.compressed,
+          originalLength: content.length,
+          compressedLength: metrics2.compressed.length,
+          originalTokens: metrics2.originalTokens,
+          compressedTokens: metrics2.compressedTokens,
+          strategy
+        },
+        metadata: {
+          tokensSaved: metrics2.tokensSaved,
+          compressionRatio: metrics2.compressionRatio
+        }
+      };
+    } catch (error51) {
+      logger.error("Failed to compress context", error51, {
+        strategy,
+        contentLength: typeof content === "string" ? content.length : 0
+      });
+      return {
+        success: false,
+        error: `Failed to compress context: ${error51.message}`
+      };
+    }
+  }
+}
 // ../../packages/core/dist/tools/store_memory.js
 init_dist();
 init_memory_controller();
@@ -175963,331 +176318,12 @@ class FetchAndIndexTool {
     return this.run(params);
   }
 }
-// ../../packages/core/dist/controllers/index.js
-init_memory_controller();
-init_search_controller();
-
-// ../../packages/core/dist/controllers/executor-controller.js
-init_dist();
-init_executor2();
-init_enum_validation();
-import { cpus as cpus2 } from "os";
-var EXECUTOR_LANGUAGES = [
-  "javascript",
-  "typescript",
-  "python",
-  "shell",
-  "ruby",
-  "go",
-  "rust",
-  "php",
-  "perl",
-  "r"
-];
-var MAX_BATCH_COMMANDS = 256;
-function applyIntent(result, intent) {
-  if (!intent || !result.stdout)
-    return result;
-  const ir = intentSearch(result.stdout, intent);
-  if (!ir.searched)
-    return result;
-  const rendered = renderIntentResult(ir, intent);
-  return {
-    ...result,
-    stdout: `${rendered}
-
---- tail (last 512 chars) ---
-${result.stdout.slice(-512)}`
-  };
-}
-
-class ExecutorController {
-  static instance = null;
-  executor;
-  constructor(executor) {
-    this.executor = executor ?? new PolyglotExecutor;
-  }
-  static getInstance() {
-    if (!ExecutorController.instance) {
-      ExecutorController.instance = new ExecutorController;
-    }
-    return ExecutorController.instance;
-  }
-  static resetInstance() {
-    ExecutorController.instance?.executor.cleanupBackgrounded();
-    ExecutorController.instance = null;
-  }
-  get runtimes() {
-    return this.executor.runtimes;
-  }
-  async execute(params) {
-    try {
-      const language = validateEnum("language", params.language, EXECUTOR_LANGUAGES);
-      const result = await this.executor.execute({
-        language,
-        code: params.code,
-        timeout: params.timeout,
-        background: params.background,
-        cwd: params.cwd
-      });
-      const finalResult = applyIntent(result, params.intent);
-      const ok = !finalResult.timedOut && finalResult.exitCode === 0;
-      return {
-        success: ok,
-        data: {
-          stdout: finalResult.stdout,
-          stderr: finalResult.stderr,
-          exitCode: finalResult.exitCode,
-          timedOut: finalResult.timedOut,
-          backgrounded: finalResult.backgrounded ?? false,
-          command: finalResult.command,
-          cwd: finalResult.cwd,
-          sandboxMode: finalResult.sandboxMode
-        }
-      };
-    } catch (error51) {
-      logger.error("execute failed", error51, {
-        language: params.language
-      });
-      return {
-        success: false,
-        error: `execute failed: ${error51.message}`
-      };
-    }
-  }
-  async executeFile(params) {
-    try {
-      const language = validateEnum("language", params.language, EXECUTOR_LANGUAGES);
-      const result = await this.executor.executeFile({
-        path: params.path,
-        language,
-        code: params.code,
-        timeout: params.timeout
-      });
-      const blocked = result.stderr?.startsWith("Blocked:");
-      if (blocked) {
-        return { success: false, error: result.stderr };
-      }
-      const finalResult = applyIntent(result, params.intent);
-      const ok = !finalResult.timedOut && finalResult.exitCode === 0;
-      return {
-        success: ok,
-        data: {
-          stdout: finalResult.stdout,
-          stderr: finalResult.stderr,
-          exitCode: finalResult.exitCode,
-          timedOut: finalResult.timedOut,
-          command: finalResult.command,
-          cwd: finalResult.cwd,
-          sandboxMode: finalResult.sandboxMode
-        }
-      };
-    } catch (error51) {
-      logger.error("execute_file failed", error51, {
-        path: params.path,
-        language: params.language
-      });
-      return {
-        success: false,
-        error: `execute_file failed: ${error51.message}`
-      };
-    }
-  }
-  async batchExecute(params) {
-    const { commands, concurrency, cwd, timeout } = params;
-    if (!Array.isArray(commands) || commands.length === 0) {
-      return { success: false, error: "commands must be a non-empty array." };
-    }
-    if (commands.length > MAX_BATCH_COMMANDS) {
-      return {
-        success: false,
-        error: `batch_execute accepts at most ${MAX_BATCH_COMMANDS} commands; received ${commands.length}. Split the batch or reduce the payload.`
-      };
-    }
-    const effectiveConcurrency = concurrency && concurrency > 0 ? concurrency : Math.max(1, cpus2().length);
-    const perTimeout = timeout ?? DEFAULT_TIMEOUT_MS2;
-    try {
-      const poolResult = await runPool(commands.map((cmd) => ({
-        run: () => this.executor.execute({
-          language: "shell",
-          code: cmd,
-          timeout: perTimeout,
-          cwd
-        })
-      })), { concurrency: effectiveConcurrency });
-      const results = poolResult.settled.map((s, i) => {
-        if (s.status === "fulfilled") {
-          const r2 = s.value;
-          return {
-            command: commands[i],
-            stdout: r2.stdout,
-            stderr: r2.stderr,
-            exitCode: r2.exitCode,
-            timedOut: r2.timedOut,
-            sandboxMode: r2.sandboxMode
-          };
-        }
-        return {
-          command: commands[i],
-          stdout: "",
-          stderr: String(s.reason ?? "unknown error"),
-          exitCode: null,
-          timedOut: false,
-          sandboxMode: getSandboxMode()
-        };
-      });
-      const anyFailed = results.some((r2) => r2.exitCode !== 0 || r2.timedOut);
-      return {
-        success: !anyFailed,
-        data: {
-          results,
-          concurrency: poolResult.effectiveConcurrency,
-          capped: poolResult.capped
-        }
-      };
-    } catch (error51) {
-      logger.error("batch_execute failed", error51);
-      return {
-        success: false,
-        error: `batch_execute failed: ${error51.message}`
-      };
-    }
-  }
-  static get MAX_TIMEOUT_MS() {
-    return MAX_TIMEOUT_MS;
-  }
-}
-// ../../packages/core/dist/controllers/graph-controller.js
-init_dist();
-init_trace_path();
-init_impact_analysis();
-init_definition_lookup();
-
-class GraphController {
-  static instance = null;
-  constructor() {}
-  static getInstance() {
-    if (!GraphController.instance) {
-      GraphController.instance = new GraphController;
-    }
-    return GraphController.instance;
-  }
-  async tracePath(input) {
-    const projectId = input.projectId;
-    const seed = input.function_name ?? input.symbol ?? input.qualifiedName;
-    if (!projectId)
-      throw new Error("projectId is required");
-    if (!seed)
-      throw new Error("function_name (or symbol/qualifiedName) is required");
-    const t0 = performance.now();
-    const result = await tracePathService.tracePath({
-      symbol: input.function_name ?? input.symbol ?? "",
-      function_name: input.function_name,
-      qualifiedName: input.qualifiedName,
-      projectId,
-      direction: input.direction,
-      mode: input.mode,
-      depth: input.depth,
-      include_tests: input.include_tests,
-      edge_types: input.edge_types
-    });
-    logger.info("GraphController: trace_path", {
-      projectId,
-      symbol: seed,
-      mode: result.mode,
-      direction: result.direction,
-      seeds: result.seeds.length,
-      nodes: result.nodes.length,
-      edges: result.edges.length,
-      durationMs: Math.round(performance.now() - t0)
-    });
-    if (result.seeds.length === 0) {
-      return {
-        found: false,
-        symbol: seed,
-        projectId,
-        ...result.identityResolution ? { identityResolution: result.identityResolution } : {},
-        hint: "Use search_definitions(search=...) to find the exact name, or pass a fully-qualified name (qualifiedName='rel/path.ts#Name')."
-      };
-    }
-    return {
-      found: true,
-      result: {
-        projectId: result.projectId,
-        symbol: result.symbol,
-        mode: result.mode,
-        direction: result.direction,
-        edgeTypes: result.edgeTypes,
-        seeds: result.seeds,
-        truncated: result.truncated,
-        nodes_total: result.nodes_total,
-        nodes_shown: result.nodes_shown,
-        nodes_omitted: result.nodes_omitted,
-        nodeCount: result.nodes.length,
-        edgeCount: result.edges.length,
-        chains: result.chains,
-        nodes: result.nodes,
-        edges: result.edges,
-        ...result.identityResolution ? { identity: toSymbolIdentityResolution(result.identityResolution) } : {}
-      }
-    };
-  }
-  async analyzeImpact(input) {
-    if (!input.projectId)
-      throw new Error("projectId is required");
-    if (!input.projectPath)
-      throw new Error("projectPath is required");
-    const t0 = performance.now();
-    const result = await impactAnalysisService.analyze({
-      projectId: input.projectId,
-      projectPath: input.projectPath,
-      scope: input.scope ?? "unstaged",
-      baseBranch: input.base_branch,
-      since: input.since,
-      depth: input.depth,
-      paths: input.paths,
-      diffRunner: input.diffRunner
-    });
-    logger.info("GraphController: impact_analysis", {
-      projectId: input.projectId,
-      scope: result.scope,
-      changedFiles: result.changedFiles.length,
-      impacted: result.impacted.length,
-      truncated: result.truncated,
-      durationMs: Math.round(performance.now() - t0)
-    });
-    return {
-      projectId: result.projectId,
-      scope: result.scope,
-      baseBranch: result.baseBranch,
-      since: result.since,
-      depth: result.depth,
-      changedFileCount: result.changedFiles.length,
-      changedFiles: result.changedFiles,
-      impactedCount: result.impacted.length,
-      truncated: result.truncated,
-      impacted: result.impacted,
-      untrackedFiltered: result.untrackedFiltered,
-      impacted_total: result.impacted_total,
-      impacted_shown: result.impacted_shown,
-      impacted_omitted: result.impacted_omitted,
-      note: result.note
-    };
-  }
-}
 // ../../packages/core/dist/index.js
 init_memory_repository_pg();
 init_memory_repository_factory();
-init_services();
-
-// ../../packages/core/dist/data/vector/hybrid-search.js
 init_vector_store_factory();
-init_keyword_search_pg();
-init_dist();
+init_services();
 
-// ../../packages/core/dist/data/vector/index.js
-init_vector_store_factory();
-init_base_vector_store();
 // ../../packages/core/dist/data/graph-generation/index.js
 init_graph_generation_repository_pg();
 init_graph_generation_repository_factory();