@faapi/faapi 3.1.0 → 3.2.1

package/dist/index.js

@@ -10,35 +10,107 @@ var __export = (target, all) => {
 
 // src/ast/createProgram.ts
 import ts from "typescript";
+import fs from "fs";
+import path from "path";
 function invalidateProgramCache() {
   programCache.clear();
+  tsConfigCache.clear();
+}
+function findTsConfig(filePath) {
+  let dir = path.dirname(filePath);
+  const root = path.parse(dir).root;
+  while (true) {
+    const candidate = path.join(dir, "tsconfig.json");
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    if (dir === root) return null;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function parseTsConfig(tsconfigPath) {
+  const cached = tsConfigCache.get(tsconfigPath);
+  if (cached) return cached;
+  const result = { fileNames: [] };
+  try {
+    const configFile = ts.readConfigFile(tsconfigPath, (p) => fs.readFileSync(p, "utf-8"));
+    if (configFile.error) {
+      tsConfigCache.set(tsconfigPath, result);
+      return result;
+    }
+    const config = configFile.config ?? {};
+    const basePath = path.dirname(tsconfigPath);
+    const parsed = ts.parseJsonConfigFileContent(
+      config,
+      ts.sys,
+      basePath,
+      /* existingOptions */
+      void 0,
+      tsconfigPath
+    );
+    result.fileNames = parsed.fileNames;
+    if (parsed.options.module !== void 0) {
+      result.module = parsed.options.module;
+    }
+    if (parsed.options.moduleResolution !== void 0) {
+      result.moduleResolution = parsed.options.moduleResolution;
+    }
+  } catch {
+  }
+  tsConfigCache.set(tsconfigPath, result);
+  return result;
 }
 function createProgram(filePath) {
   const cached = programCache.get(filePath);
   if (cached) {
     return cached;
   }
-  const program = ts.createProgram([filePath], {
+  const options = {
     strict: true,
     target: ts.ScriptTarget.ES2022,
     module: ts.ModuleKind.NodeNext,
     moduleResolution: ts.ModuleResolutionKind.NodeNext,
     skipLibCheck: true,
     noEmit: true
-  });
+  };
+  let rootNames = [filePath];
+  const tsconfigPath = findTsConfig(filePath);
+  if (tsconfigPath) {
+    const tsOptions = parseTsConfig(tsconfigPath);
+    if (tsOptions.module !== void 0) {
+      options.module = tsOptions.module;
+    }
+    if (tsOptions.moduleResolution !== void 0) {
+      options.moduleResolution = tsOptions.moduleResolution;
+    }
+    if (tsOptions.fileNames.length > 0) {
+      if (!tsOptions.fileNames.includes(filePath)) {
+        rootNames = [filePath, ...tsOptions.fileNames];
+      } else {
+        rootNames = tsOptions.fileNames;
+      }
+    }
+  }
+  const program = ts.createProgram(rootNames, options);
   programCache.set(filePath, program);
   return program;
 }
-var programCache;
+var programCache, tsConfigCache;
 var init_createProgram = __esm({
   "src/ast/createProgram.ts"() {
     "use strict";
     programCache = /* @__PURE__ */ new Map();
+    tsConfigCache = /* @__PURE__ */ new Map();
   }
 });
 
 // src/ast/resolveTypeNode.ts
 import ts2 from "typescript";
+function setProgramContext(program) {
+  currentProgram = program;
+}
 function resolveTypeNode(typeNode, checker, visited = /* @__PURE__ */ new Set()) {
   const kind = typeNode.kind;
   switch (kind) {
@@ -351,11 +423,69 @@ function resolveTypeReference(typeNode, checker, visited = /* @__PURE__ */ new S
         if (ts2.isEnumDeclaration(declaration)) {
           return resolveEnumDeclaration(declaration);
         }
+        if (ts2.isImportSpecifier(declaration) || ts2.isImportClause(declaration)) {
+          const resolved = resolveImportAlias(typeNode, symbol, checker, visited);
+          if (resolved) return resolved;
+        }
       }
     }
   }
   throw new SchemaExtractionError(typeNode.getText(), `\u65E0\u6CD5\u89E3\u6790\u7684\u5F15\u7528\u7C7B\u578B "${typeName}"`);
 }
+function resolveImportAlias(typeNode, symbol, checker, visited) {
+  const typeName = typeNode.typeName.getText();
+  try {
+    const aliased = checker.getAliasedSymbol(symbol);
+    if (aliased && aliased.declarations && aliased.declarations.length > 0) {
+      const decl = aliased.declarations[0];
+      if (ts2.isInterfaceDeclaration(decl)) {
+        return resolveInterfaceDeclaration(decl, checker, visited);
+      }
+      if (ts2.isTypeAliasDeclaration(decl)) {
+        return resolveTypeNode(decl.type, checker, visited);
+      }
+      if (ts2.isEnumDeclaration(decl)) {
+        return resolveEnumDeclaration(decl);
+      }
+    }
+  } catch {
+  }
+  const program = currentProgram;
+  if (!program) return null;
+  const allSFs = program.getSourceFiles();
+  for (const sourceFile of allSFs) {
+    if (sourceFile.fileName.includes("/node_modules/") || sourceFile.fileName.includes("typescript/lib/")) {
+      continue;
+    }
+    const found = findTopLevelDecl(sourceFile, typeName);
+    if (found) {
+      if (found.kind === "interface") {
+        return resolveInterfaceDeclaration(found.node, checker, visited);
+      }
+      if (found.kind === "typeAlias") {
+        return resolveTypeNode(found.node.type, checker, visited);
+      }
+      if (found.kind === "enum") {
+        return resolveEnumDeclaration(found.node);
+      }
+    }
+  }
+  return null;
+}
+function findTopLevelDecl(sourceFile, typeName) {
+  let found = null;
+  ts2.forEachChild(sourceFile, (node) => {
+    if (found) return;
+    if (ts2.isInterfaceDeclaration(node) && node.name.text === typeName) {
+      found = { kind: "interface", node };
+    } else if (ts2.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+      found = { kind: "typeAlias", node };
+    } else if (ts2.isEnumDeclaration(node) && node.name.text === typeName) {
+      found = { kind: "enum", node };
+    }
+  });
+  return found;
+}
 function resolveEnumDeclaration(node) {
   const members = [];
   let nextNumericValue = 0;
@@ -534,10 +664,11 @@ function validateConstraints(constraints, type, fieldName) {
     }
   }
 }
-var SchemaExtractionError, NUMBER_CONSTRAINT_KINDS, LENGTH_CONSTRAINT_KINDS, STRING_FORMAT_CONSTRAINT_KINDS;
+var currentProgram, SchemaExtractionError, NUMBER_CONSTRAINT_KINDS, LENGTH_CONSTRAINT_KINDS, STRING_FORMAT_CONSTRAINT_KINDS;
 var init_resolveTypeNode = __esm({
   "src/ast/resolveTypeNode.ts"() {
     "use strict";
+    currentProgram = null;
     SchemaExtractionError = class extends Error {
       constructor(typeText, reason, options) {
         super(`\u65E0\u6CD5\u89E3\u6790\u7C7B\u578B "${typeText}": ${reason}`, options);
@@ -577,80 +708,90 @@ function extractTypeInfo(program, filePath, typeName) {
   const sourceFile = program.getSourceFile(filePath);
   if (!sourceFile) return null;
   const checker = program.getTypeChecker();
-  let result = null;
-  ts3.forEachChild(sourceFile, (node) => {
-    if (result) return;
-    if (ts3.isInterfaceDeclaration(node) && node.name.text === typeName) {
-      const visited = /* @__PURE__ */ new Set();
-      visited.add(typeName);
-      const runtimeType = withFileContext(
-        filePath,
-        typeName,
-        () => resolveInterfaceDeclaration(node, checker, visited)
-      );
-      result = {
-        name: typeName,
-        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
-        runtimeType
-      };
-      return;
-    }
-    if (ts3.isTypeAliasDeclaration(node) && node.name.text === typeName) {
-      const visited = /* @__PURE__ */ new Set();
-      visited.add(typeName);
-      const runtimeType = withFileContext(
-        filePath,
-        typeName,
-        () => resolveTypeNode(node.type, checker, visited)
-      );
-      result = {
-        name: typeName,
-        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
-        runtimeType
-      };
-      return;
-    }
-  });
-  return result;
+  setProgramContext(program);
+  try {
+    let result = null;
+    ts3.forEachChild(sourceFile, (node) => {
+      if (result) return;
+      if (ts3.isInterfaceDeclaration(node) && node.name.text === typeName) {
+        const visited = /* @__PURE__ */ new Set();
+        visited.add(typeName);
+        const runtimeType = withFileContext(
+          filePath,
+          typeName,
+          () => resolveInterfaceDeclaration(node, checker, visited)
+        );
+        result = {
+          name: typeName,
+          properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+          runtimeType
+        };
+        return;
+      }
+      if (ts3.isTypeAliasDeclaration(node) && node.name.text === typeName) {
+        const visited = /* @__PURE__ */ new Set();
+        visited.add(typeName);
+        const runtimeType = withFileContext(
+          filePath,
+          typeName,
+          () => resolveTypeNode(node.type, checker, visited)
+        );
+        result = {
+          name: typeName,
+          properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+          runtimeType
+        };
+        return;
+      }
+    });
+    return result;
+  } finally {
+    setProgramContext(null);
+  }
 }
 function extractAllTypes(program, filePath) {
   const sourceFile = program.getSourceFile(filePath);
   if (!sourceFile) return /* @__PURE__ */ new Map();
   const checker = program.getTypeChecker();
-  const result = /* @__PURE__ */ new Map();
-  ts3.forEachChild(sourceFile, (node) => {
-    if (ts3.isInterfaceDeclaration(node)) {
-      const visited = /* @__PURE__ */ new Set();
-      visited.add(node.name.text);
-      const runtimeType = withFileContext(
-        filePath,
-        node.name.text,
-        () => resolveInterfaceDeclaration(node, checker, visited)
-      );
-      result.set(node.name.text, {
-        name: node.name.text,
-        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
-        runtimeType
-      });
-      return;
-    }
-    if (ts3.isTypeAliasDeclaration(node)) {
-      const visited = /* @__PURE__ */ new Set();
-      visited.add(node.name.text);
-      const runtimeType = withFileContext(
-        filePath,
-        node.name.text,
-        () => resolveTypeNode(node.type, checker, visited)
-      );
-      result.set(node.name.text, {
-        name: node.name.text,
-        properties: runtimeType.kind === "object" ? runtimeType.properties : [],
-        runtimeType
-      });
-      return;
-    }
-  });
-  return result;
+  setProgramContext(program);
+  try {
+    const result = /* @__PURE__ */ new Map();
+    ts3.forEachChild(sourceFile, (node) => {
+      if (ts3.isInterfaceDeclaration(node)) {
+        const visited = /* @__PURE__ */ new Set();
+        visited.add(node.name.text);
+        const runtimeType = withFileContext(
+          filePath,
+          node.name.text,
+          () => resolveInterfaceDeclaration(node, checker, visited)
+        );
+        result.set(node.name.text, {
+          name: node.name.text,
+          properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+          runtimeType
+        });
+        return;
+      }
+      if (ts3.isTypeAliasDeclaration(node)) {
+        const visited = /* @__PURE__ */ new Set();
+        visited.add(node.name.text);
+        const runtimeType = withFileContext(
+          filePath,
+          node.name.text,
+          () => resolveTypeNode(node.type, checker, visited)
+        );
+        result.set(node.name.text, {
+          name: node.name.text,
+          properties: runtimeType.kind === "object" ? runtimeType.properties : [],
+          runtimeType
+        });
+        return;
+      }
+    });
+    return result;
+  } finally {
+    setProgramContext(null);
+  }
 }
 function withFileContext(filePath, typeName, fn) {
   try {
@@ -851,11 +992,11 @@ var init_analyzeInjection = __esm({
 });
 
 // src/cli/collectRouteSchemaSources.ts
-import path from "path";
+import path2 from "path";
 function collectRouteSchemaSources(routes, rootDir) {
   const methodsByFile = /* @__PURE__ */ new Map();
   for (const route of routes) {
-    const filePath = rootDir ? path.resolve(rootDir, route.filePath) : route.filePath;
+    const filePath = rootDir ? path2.resolve(rootDir, route.filePath) : route.filePath;
     let entry = methodsByFile.get(filePath);
     if (!entry) {
       entry = { urlPath: route.urlPath, methods: /* @__PURE__ */ new Set() };
@@ -1223,8 +1364,8 @@ __export(generateSchemaFiles_exports, {
   getRuntimeSchemaPath: () => getRuntimeSchemaPath,
   getSchemaOutputPath: () => getSchemaOutputPath
 });
-import path5 from "path";
-import fs4 from "fs/promises";
+import path6 from "path";
+import fs5 from "fs/promises";
 function getSchemaOutputPath(sourceFile, dist, rootDir) {
   let rel = sourceFile.replace(/\\/g, "/");
   if (rel.startsWith("src/")) {
@@ -1232,7 +1373,7 @@ function getSchemaOutputPath(sourceFile, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path5.resolve(rootDir, dist, relDir, "zod.js");
+  return path6.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getRuntimeSchemaPath(filePath, dist, rootDir) {
   let rel = filePath.replace(/\\/g, "/");
@@ -1243,7 +1384,7 @@ function getRuntimeSchemaPath(filePath, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path5.resolve(rootDir, dist, relDir, "zod.js");
+  return path6.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getHelpersImportPath(relDir) {
   if (!relDir) return `./${HELPERS_FILENAME}`;
@@ -1293,7 +1434,7 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   }
   const fileEntries = [];
   for (const [filePath, fileSources] of sourcesByFile) {
-    const relFile = path5.relative(rootDir, filePath).replace(/\\/g, "/");
+    const relFile = path6.relative(rootDir, filePath).replace(/\\/g, "/");
     const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
     const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
     let relForDir = relFile;
@@ -1308,7 +1449,7 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   }
   const allSourceCode = fileEntries.map((e) => e.source).join("\n");
   if (usesCoerceHelpers(allSourceCode)) {
-    const helpersPath = path5.resolve(rootDir, dist, HELPERS_FILENAME);
+    const helpersPath = path6.resolve(rootDir, dist, HELPERS_FILENAME);
     await writeSchemaFile(helpersPath, generateHelpersFileSource());
   }
   await Promise.all(
@@ -1316,8 +1457,8 @@ async function generateSchemaFiles(routes, rootDir, dist) {
   );
 }
 async function writeSchemaFile(outputPath, source) {
-  await fs4.mkdir(path5.dirname(outputPath), { recursive: true });
-  await fs4.writeFile(outputPath, source, "utf-8");
+  await fs5.mkdir(path6.dirname(outputPath), { recursive: true });
+  await fs5.writeFile(outputPath, source, "utf-8");
 }
 var init_generateSchemaFiles = __esm({
   "src/cli/generateSchemaFiles.ts"() {
@@ -1350,53 +1491,27 @@ function getTool(name) {
   return registry.get(name);
 }
 
-// src/injection/skillRegistry.ts
-var registry2 = /* @__PURE__ */ new Map();
-function hydrateSkillRegistry(skills) {
-  const next = /* @__PURE__ */ new Map();
-  for (const skill of skills) {
-    next.set(skill.name, skill);
-  }
-  registry2 = next;
-}
-function clearSkillRegistry() {
-  registry2 = /* @__PURE__ */ new Map();
-}
-function upsertSkill(core) {
-  registry2.set(core.name, core);
-}
-function removeSkill(name) {
-  registry2.delete(name);
-}
-function getSkill(name) {
-  return registry2.get(name);
-}
-function listSkills() {
-  return Array.from(registry2.values());
-}
-
 // src/injection/agentRegistry.ts
-var registry3 = /* @__PURE__ */ new Map();
+var registry2 = /* @__PURE__ */ new Map();
 function hydrateAgentRegistry(agents) {
   const next = /* @__PURE__ */ new Map();
   for (const agent of agents) {
     next.set(agent.name, agent);
   }
-  registry3 = next;
+  registry2 = next;
 }
 function clearAgentRegistry() {
-  registry3 = /* @__PURE__ */ new Map();
+  registry2 = /* @__PURE__ */ new Map();
 }
 function getAgent(name) {
-  return getSkill(name) ?? registry3.get(name);
+  return registry2.get(name);
 }
 function getAgentEntry(name) {
-  return registry3.get(name);
+  return registry2.get(name);
 }
 function listAgents() {
   const merged = /* @__PURE__ */ new Map();
-  for (const agent of registry3.values()) merged.set(agent.name, agent);
-  for (const skill of listSkills()) merged.set(skill.name, skill);
+  for (const agent of registry2.values()) merged.set(agent.name, agent);
   return Array.from(merged.values());
 }
 function resolveAgentTools(name) {
@@ -1422,8 +1537,33 @@ function resolveSubAgents(name) {
   return result;
 }
 
+// src/injection/skillRegistry.ts
+var registry3 = /* @__PURE__ */ new Map();
+function hydrateSkillRegistry(skills) {
+  const next = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    next.set(skill.name, skill);
+  }
+  registry3 = next;
+}
+function clearSkillRegistry() {
+  registry3 = /* @__PURE__ */ new Map();
+}
+function upsertSkill(core) {
+  registry3.set(core.name, core);
+}
+function removeSkill(name) {
+  registry3.delete(name);
+}
+function getSkill(name) {
+  return registry3.get(name);
+}
+function listSkills() {
+  return Array.from(registry3.values());
+}
+
 // src/loader/loadAgentModule.ts
-import fs6 from "fs";
+import fs7 from "fs";
 
 // src/loader/resolveExports.ts
 function resolveExport(module, exportName) {
@@ -1469,17 +1609,17 @@ async function importWithCacheBust(filePath, bustViteCache = false) {
 }
 
 // src/cli/compileOnDemand.ts
-import path6 from "path";
-import fs5 from "fs";
+import path7 from "path";
+import fs6 from "fs";
 
 // src/cli/compileDevRoutes.ts
-import path4 from "path";
-import fs3 from "fs";
+import path5 from "path";
+import fs4 from "fs";
 import fg from "fast-glob";
 
 // src/cli/aliasPlugin.ts
-import path3 from "path";
-import fs2 from "fs";
+import path4 from "path";
+import fs3 from "fs";
 
 // src/utils/resolveAlias.ts
 function resolveAlias(specifier, config) {
@@ -1506,11 +1646,11 @@ function resolveAlias(specifier, config) {
 
 // src/utils/readTsconfig.ts
 import ts6 from "typescript";
-import path2 from "path";
-import fs from "fs";
+import path3 from "path";
+import fs2 from "fs";
 function readTsconfig(rootDir) {
-  const tsconfigPath = path2.resolve(rootDir, "tsconfig.json");
-  if (!fs.existsSync(tsconfigPath)) return null;
+  const tsconfigPath = path3.resolve(rootDir, "tsconfig.json");
+  if (!fs2.existsSync(tsconfigPath)) return null;
   const configFile = ts6.readConfigFile(tsconfigPath, ts6.sys.readFile);
   if (configFile.error || !configFile.config) return null;
   const parsed = ts6.parseJsonConfigFileContent(configFile.config, ts6.sys, rootDir);
@@ -1519,7 +1659,7 @@ function readTsconfig(rootDir) {
   if (!rawPaths) return null;
   const paths = {};
   for (const [pattern, targets] of Object.entries(rawPaths)) {
-    paths[pattern] = targets.map((t) => path2.resolve(baseUrl, t));
+    paths[pattern] = targets.map((t) => path3.resolve(baseUrl, t));
   }
   return { baseUrl, paths };
 }
@@ -1532,29 +1672,29 @@ function toProdExtension(filePath) {
   return filePath;
 }
 function toProdImportPath(sourceFile, importer) {
-  const importerDir = path3.dirname(importer);
-  let rel = path3.relative(importerDir, sourceFile);
-  rel = rel.split(path3.sep).join("/");
+  const importerDir = path4.dirname(importer);
+  let rel = path4.relative(importerDir, sourceFile);
+  rel = rel.split(path4.sep).join("/");
   if (!rel.startsWith(".")) rel = "./" + rel;
   return toProdExtension(rel);
 }
 function toRealPath(p) {
   try {
-    return fs2.realpathSync(p);
+    return fs3.realpathSync(p);
   } catch {
     return p;
   }
 }
 function isInsideDir(filePath, dir) {
-  const rel = path3.relative(dir, filePath);
-  return rel !== "" && !rel.startsWith("..") && !path3.isAbsolute(rel);
+  const rel = path4.relative(dir, filePath);
+  return rel !== "" && !rel.startsWith("..") && !path4.isAbsolute(rel);
 }
 var APP_DIR = "src";
 function toStrippedProdImportPath(sourceFile, rootDir) {
-  const appDirAbs = toRealPath(path3.resolve(rootDir, APP_DIR));
+  const appDirAbs = toRealPath(path4.resolve(rootDir, APP_DIR));
   const sourceReal = toRealPath(sourceFile);
-  let rel = path3.relative(appDirAbs, sourceReal);
-  rel = rel.split(path3.sep).join("/");
+  let rel = path4.relative(appDirAbs, sourceReal);
+  rel = rel.split(path4.sep).join("/");
   if (!rel.startsWith(".")) rel = "./" + rel;
   return toProdExtension(rel);
 }
@@ -1569,34 +1709,34 @@ var INDEX_EXTS = [
   "/index.cjs"
 ];
 function resolveRelativeSpecifier(importer, specifier) {
-  const importerDir = path3.dirname(importer);
-  const base = path3.resolve(importerDir, specifier);
+  const importerDir = path4.dirname(importer);
+  const base = path4.resolve(importerDir, specifier);
   if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
-    return fs2.existsSync(base) ? base : null;
+    return fs3.existsSync(base) ? base : null;
   }
   if (/\.(ts|tsx|jsx)$/.test(specifier)) {
-    return fs2.existsSync(base) ? base : null;
+    return fs3.existsSync(base) ? base : null;
   }
   for (const ext of SOURCE_EXTS) {
     const file = base + ext;
-    if (fs2.existsSync(file)) return file;
+    if (fs3.existsSync(file)) return file;
   }
   for (const indexExt of INDEX_EXTS) {
     const file = base + indexExt;
-    if (fs2.existsSync(file)) return file;
+    if (fs3.existsSync(file)) return file;
   }
   return null;
 }
 function createAliasPlugin(config, options) {
   const SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
-  const appDirAbs = options?.rootDir ? toRealPath(path3.resolve(options.rootDir, APP_DIR)) : null;
+  const appDirAbs = options?.rootDir ? toRealPath(path4.resolve(options.rootDir, APP_DIR)) : null;
   return {
     name: "faapi-alias",
     setup(build) {
       build.onLoad({ filter: /\.(ts|tsx|js|jsx|mjs|cjs)$/ }, (args) => {
         let source;
         try {
-          source = fs2.readFileSync(args.path, "utf8");
+          source = fs3.readFileSync(args.path, "utf8");
         } catch {
           return void 0;
         }
@@ -1629,7 +1769,7 @@ function createAliasPlugin(config, options) {
           for (const candidate of candidates) {
             for (const ext of SOURCE_EXTS) {
               const file = candidate + ext;
-              if (fs2.existsSync(file)) {
+              if (fs3.existsSync(file)) {
                 modified = true;
                 if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
                   return `${prefix}${quote}${toStrippedProdImportPath(
@@ -1642,7 +1782,7 @@ function createAliasPlugin(config, options) {
             }
             for (const indexExt of INDEX_EXTS) {
               const file = candidate + indexExt;
-              if (fs2.existsSync(file)) {
+              if (fs3.existsSync(file)) {
                 modified = true;
                 if (appDirAbs && importerOutsideAppDir && isInsideDir(file, appDirAbs)) {
                   return `${prefix}${quote}${toStrippedProdImportPath(
@@ -1680,11 +1820,11 @@ async function compileDevRoutes(options) {
   if (entryPoints.length === 0) {
     return { compiledFiles: [] };
   }
-  const absDist = path4.resolve(rootDir, dist);
-  await fs3.promises.mkdir(absDist, { recursive: true });
+  const absDist = path5.resolve(rootDir, dist);
+  await fs4.promises.mkdir(absDist, { recursive: true });
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
-  const outbase = path4.resolve(rootDir, APP_DIR2);
+  const outbase = path5.resolve(rootDir, APP_DIR2);
   const result = await esbuild.build({
     entryPoints,
     outdir: absDist,
@@ -1701,10 +1841,10 @@ async function compileDevRoutes(options) {
   if (result.outputFiles) {
     await Promise.all(
       result.outputFiles.map(async (file) => {
-        await fs3.promises.mkdir(path4.dirname(file.path), { recursive: true });
+        await fs4.promises.mkdir(path5.dirname(file.path), { recursive: true });
         const tmp = `${file.path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-        await fs3.promises.writeFile(tmp, file.contents);
-        await fs3.promises.rename(tmp, file.path);
+        await fs4.promises.writeFile(tmp, file.contents);
+        await fs4.promises.rename(tmp, file.path);
       })
     );
   }
@@ -1716,8 +1856,8 @@ init_generateSchemaFiles();
 init_generateSchemaFiles();
 function isProductFresh(sourceAbsPath, productAbsPath) {
   try {
-    const srcStat = fs5.statSync(sourceAbsPath);
-    const prodStat = fs5.statSync(productAbsPath);
+    const srcStat = fs6.statSync(sourceAbsPath);
+    const prodStat = fs6.statSync(productAbsPath);
     return prodStat.mtimeMs >= srcStat.mtimeMs;
   } catch {
     return false;
@@ -1748,7 +1888,7 @@ async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   if (state.compiledFiles.has(sourceAbsPath)) {
     return false;
   }
-  if (!fs5.existsSync(sourceAbsPath)) {
+  if (!fs6.existsSync(sourceAbsPath)) {
     return false;
   }
   const productPath = prodSourcePathToProductPath(sourceAbsPath, rootDir, dist);
@@ -1774,11 +1914,11 @@ async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   }
 }
 function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
-  const rel = path6.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const rel = path7.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   if (!rel.startsWith("src/")) return null;
   const relWithoutSrc = rel.slice(4);
   const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
-  return path6.resolve(rootDir, dist, jsRel);
+  return path7.resolve(rootDir, dist, jsRel);
 }
 function clearGeneratedSchemas() {
   state.generatedSchemas.clear();
@@ -1794,9 +1934,9 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   if (state.generatedSchemas.has(schemaPath)) {
     return false;
   }
-  const prodAbsPath = path6.resolve(rootDir, routeFilePath);
+  const prodAbsPath = path7.resolve(rootDir, routeFilePath);
   const sourceAbsPath = prodPathToSourcePath(prodAbsPath, rootDir, dist);
-  if (!fs5.existsSync(sourceAbsPath)) {
+  if (!fs6.existsSync(sourceAbsPath)) {
     return false;
   }
   if (isProductFresh(sourceAbsPath, schemaPath)) {
@@ -1807,7 +1947,7 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   if (fileRoutes.length === 0) {
     return false;
   }
-  const sourceRelPath = path6.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const sourceRelPath = path7.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
   const generatePromise = (async () => {
     await generateSchemaFiles(sourceRoutes, rootDir, dist);
@@ -1828,22 +1968,22 @@ async function deleteSchemaFiles(routes, rootDir, dist) {
     if (deleted.has(schemaPath)) continue;
     deleted.add(schemaPath);
     try {
-      await fs5.promises.unlink(schemaPath);
+      await fs6.promises.unlink(schemaPath);
     } catch {
     }
   }
 }
 function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
-  const rel = path6.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
+  const rel = path7.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
   let relWithoutDist = rel;
   if (relWithoutDist.startsWith(`${dist}/`)) {
     relWithoutDist = relWithoutDist.slice(dist.length + 1);
   }
   const srcRel = `src/${relWithoutDist}`;
   const tsRel = srcRel.replace(/\.js$/, ".ts");
-  const tsAbs = path6.resolve(rootDir, tsRel);
-  if (fs5.existsSync(tsAbs)) return tsAbs;
-  return path6.resolve(rootDir, srcRel);
+  const tsAbs = path7.resolve(rootDir, tsRel);
+  if (fs6.existsSync(tsAbs)) return tsAbs;
+  return path7.resolve(rootDir, srcRel);
 }
 function isDevOnDemandEnabled() {
   return state.enabled;
@@ -1858,7 +1998,7 @@ async function loadAgentModule(filePath, hasRun, rootDir) {
     const dist = getDevDist();
     if (dist) {
       const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-      if (sourcePath && fs6.existsSync(sourcePath)) {
+      if (sourcePath && fs7.existsSync(sourcePath)) {
         try {
           await ensureCompiled(sourcePath, rootDir, dist);
         } catch (compileErr) {
@@ -1891,13 +2031,13 @@ async function loadAgentModule(filePath, hasRun, rootDir) {
 }
 
 // src/loader/loadToolModule.ts
-import fs7 from "fs";
+import fs8 from "fs";
 async function loadToolModule(filePath, functionName, rootDir) {
   if (isDevOnDemandEnabled() && rootDir) {
     const dist = getDevDist();
     if (dist) {
       const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-      if (sourcePath && fs7.existsSync(sourcePath)) {
+      if (sourcePath && fs8.existsSync(sourcePath)) {
         try {
           await ensureCompiled(sourcePath, rootDir, dist);
         } catch (compileErr) {
@@ -1929,8 +2069,8 @@ async function loadToolModule(filePath, functionName, rootDir) {
 import { existsSync as existsSync2 } from "fs";
 
 // src/cli/generateToolArtifacts.ts
-import path7 from "path";
-import fs8 from "fs/promises";
+import path8 from "path";
+import fs9 from "fs/promises";
 import { existsSync } from "fs";
 
 // src/ast/extractToolMetadata.ts
@@ -2025,7 +2165,7 @@ function getToolSchemaOutputPath(sourceFile, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path7.resolve(rootDir, dist, relDir, "zod.js");
+  return path8.resolve(rootDir, dist, relDir, "zod.js");
 }
 function getRuntimeToolSchemaPath(filePath, dist, rootDir) {
   let rel = filePath.replace(/\\/g, "/");
@@ -2036,7 +2176,7 @@ function getRuntimeToolSchemaPath(filePath, dist, rootDir) {
   }
   const idx = rel.lastIndexOf("/");
   const relDir = idx >= 0 ? rel.slice(0, idx) : "";
-  return path7.resolve(rootDir, dist, relDir, "zod.js");
+  return path8.resolve(rootDir, dist, relDir, "zod.js");
 }
 function toProdFilePath(filePath, dist) {
   let rel = filePath.replace(/\\/g, "/");
@@ -2056,12 +2196,12 @@ function serializeTools(tools, dist = "dist") {
   }));
 }
 async function writeToolsModule(manifest, outputPath) {
-  const dir = path7.dirname(outputPath);
-  await fs8.mkdir(dir, { recursive: true });
+  const dir = path8.dirname(outputPath);
+  await fs9.mkdir(dir, { recursive: true });
   const content = `// \u81EA\u52A8\u751F\u6210,\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91(faapi build/dev \u4EA7\u7269)
 export const tools = ${JSON.stringify(manifest, null, 2)};
 `;
-  await fs8.writeFile(outputPath, content, "utf-8");
+  await fs9.writeFile(outputPath, content, "utf-8");
 }
 function hydrateTools(manifest) {
   return manifest.map((t) => ({
@@ -2076,7 +2216,7 @@ function collectToolSchemaSources(tools, rootDir) {
   const toolsByFile = /* @__PURE__ */ new Map();
   for (const tool of tools) {
     if (!tool.inputTypeName) continue;
-    const absPath = path7.resolve(rootDir, tool.filePath);
+    const absPath = path8.resolve(rootDir, tool.filePath);
     let list = toolsByFile.get(absPath);
     if (!list) {
       list = [];
@@ -2138,15 +2278,15 @@ function generateToolSchemaFileSource(sources, allTypes, helpersImportPath) {
 }
 async function maybeGenerateHelpers(allSourceCode, distDir) {
   if (!usesCoerceHelpers(allSourceCode)) return;
-  const helpersPath = path7.resolve(distDir, HELPERS_FILENAME);
+  const helpersPath = path8.resolve(distDir, HELPERS_FILENAME);
   if (existsSync(helpersPath)) return;
-  await fs8.mkdir(path7.dirname(helpersPath), { recursive: true });
-  await fs8.writeFile(helpersPath, generateHelpersFileSource(), "utf-8");
+  await fs9.mkdir(path8.dirname(helpersPath), { recursive: true });
+  await fs9.writeFile(helpersPath, generateHelpersFileSource(), "utf-8");
 }
 async function generateToolArtifacts(tools, rootDir, dist, options) {
   const metadata = [];
   for (const manifest of tools) {
-    const absPath = path7.resolve(rootDir, manifest.filePath);
+    const absPath = path8.resolve(rootDir, manifest.filePath);
     const program = createProgram(absPath);
     const result = extractToolMetadata(program, absPath, manifest.functionName, {
       name: manifest.name,
@@ -2157,7 +2297,7 @@ async function generateToolArtifacts(tools, rootDir, dist, options) {
     }
   }
   const serialized = serializeTools(metadata, dist);
-  const toolsPath = path7.resolve(rootDir, dist, TOOLS_FILE);
+  const toolsPath = path8.resolve(rootDir, dist, TOOLS_FILE);
   await writeToolsModule(serialized, toolsPath);
   if (options?.skipSchema) {
     return metadata;
@@ -2180,7 +2320,7 @@ async function generateToolArtifacts(tools, rootDir, dist, options) {
   }
   const fileEntries = [];
   for (const [filePath, fileSources] of sourcesByFile) {
-    const relFile = path7.relative(rootDir, filePath).replace(/\\/g, "/");
+    const relFile = path8.relative(rootDir, filePath).replace(/\\/g, "/");
     const outputPath = getToolSchemaOutputPath(relFile, dist, rootDir);
     const allTypes = allTypesByFile.get(filePath) ?? /* @__PURE__ */ new Map();
     let relForDir = relFile;
@@ -2194,7 +2334,7 @@ async function generateToolArtifacts(tools, rootDir, dist, options) {
     fileEntries.push({ outputPath, source });
   }
   const allSourceCode = fileEntries.map((e) => e.source).join("\n");
-  const distDir = path7.resolve(rootDir, dist);
+  const distDir = path8.resolve(rootDir, dist);
   await maybeGenerateHelpers(allSourceCode, distDir);
   await Promise.all(
     fileEntries.map(({ outputPath, source }) => writeToolSchemaFile(outputPath, source))
@@ -2202,8 +2342,8 @@ async function generateToolArtifacts(tools, rootDir, dist, options) {
   return metadata;
 }
 async function writeToolSchemaFile(outputPath, source) {
-  await fs8.mkdir(path7.dirname(outputPath), { recursive: true });
-  await fs8.writeFile(outputPath, source, "utf-8");
+  await fs9.mkdir(path8.dirname(outputPath), { recursive: true });
+  await fs9.writeFile(outputPath, source, "utf-8");
 }
 
 // src/loader/loadToolSchema.ts
@@ -2403,16 +2543,16 @@ function helmet(options = {}) {
 }
 
 // src/config/loadConfig.ts
-import path8 from "path";
-import fs9 from "fs";
+import path9 from "path";
+import fs10 from "fs";
 var CONFIG_PRODUCT_FILE = "faapi-config.js";
 async function loadConfig(rootDir, dist) {
-  const configProductPath = path8.resolve(rootDir, dist, CONFIG_PRODUCT_FILE);
-  if (fs9.existsSync(configProductPath)) {
+  const configProductPath = path9.resolve(rootDir, dist, CONFIG_PRODUCT_FILE);
+  if (fs10.existsSync(configProductPath)) {
     const module = await importWithCacheBust(configProductPath);
     return module.default ?? {};
   }
-  const hasSourceConfig = fs9.existsSync(path8.join(rootDir, "faapi.config.ts")) || fs9.existsSync(path8.join(rootDir, "faapi.config.js"));
+  const hasSourceConfig = fs10.existsSync(path9.join(rootDir, "faapi.config.ts")) || fs10.existsSync(path9.join(rootDir, "faapi.config.js"));
   if (hasSourceConfig) {
     throw new Error(
       `[faapi] ${dist}/${CONFIG_PRODUCT_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
@@ -2422,8 +2562,8 @@ async function loadConfig(rootDir, dist) {
 }
 
 // src/cli/loadEnv.ts
-import fs10 from "fs";
-import path9 from "path";
+import fs11 from "fs";
+import path10 from "path";
 function resolveEnv() {
   return process.env.NODE_ENV || "development";
 }
@@ -2489,9 +2629,9 @@ function loadEnv(rootDir) {
   const files = getEnvFiles(env);
   const merged = {};
   for (const file of files) {
-    const filePath = path9.join(rootDir, file);
-    if (!fs10.existsSync(filePath)) continue;
-    const content = fs10.readFileSync(filePath, "utf-8");
+    const filePath = path10.join(rootDir, file);
+    if (!fs11.existsSync(filePath)) continue;
+    const content = fs11.readFileSync(filePath, "utf-8");
     const parsed = parseEnvFile(content, merged);
     Object.assign(merged, parsed);
   }
@@ -2528,14 +2668,14 @@ var ValidationError = class extends FaapiError {
   issues;
 };
 var RouteNotFoundError = class extends FaapiError {
-  constructor(path18) {
-    super("ROUTE_NOT_FOUND", `Route not found: ${path18}`, 404);
+  constructor(path19) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path19}`, 404);
     this.name = "RouteNotFoundError";
   }
 };
 var MethodNotAllowedError = class extends FaapiError {
-  constructor(method, path18, allowedMethods) {
-    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path18}`, 405);
+  constructor(method, path19, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path19}`, 405);
     this.allowedMethods = allowedMethods;
     this.name = "MethodNotAllowedError";
   }
@@ -2561,8 +2701,8 @@ var PayloadTooLargeError = class extends FaapiError {
 };
 
 // src/cli/createAppCore.ts
-import fs15 from "fs";
-import path14 from "path";
+import fs16 from "fs";
+import path15 from "path";
 import { PassThrough, Readable as Readable3 } from "stream";
 
 // src/router/sortRoutes.ts
@@ -2615,45 +2755,45 @@ import {
 import { createSecureServer as createHttp2SecureServer } from "http2";
 import { readFileSync } from "fs";
 import { Readable as Readable2 } from "stream";
-import path11 from "path";
+import path12 from "path";
 
 // src/router/matchRoute.ts
-function matchRoute(routes, method, path18) {
+function matchRoute(routes, method, path19) {
   for (const route of routes) {
     if (route.method !== method) {
       continue;
     }
     if (!route.isDynamic) {
-      if (route.urlPath === path18) {
+      if (route.urlPath === path19) {
         return { route, params: {} };
       }
       continue;
     }
-    const params = matchDynamicPath(route.urlPath, path18, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path19, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchWsRoute(wsRoutes, path18) {
+function matchWsRoute(wsRoutes, path19) {
   for (const route of wsRoutes) {
     if (!route.isDynamic) {
-      if (route.urlPath === path18) {
+      if (route.urlPath === path19) {
         return { route, params: {} };
       }
       continue;
     }
-    const params = matchDynamicPath(route.urlPath, path18, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path19, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchDynamicPath(pattern, path18, paramNames, isCatchAll) {
+function matchDynamicPath(pattern, path19, paramNames, isCatchAll) {
   const patternSegments = pattern.split("/").filter(Boolean);
-  const pathSegments = path18.split("/").filter(Boolean);
+  const pathSegments = path19.split("/").filter(Boolean);
   if (isCatchAll) {
     const nonCatchAllCount = patternSegments.length - 1;
     if (pathSegments.length <= nonCatchAllCount) {
@@ -2699,7 +2839,7 @@ function matchDynamicPath(pattern, path18, paramNames, isCatchAll) {
 }
 
 // src/loader/loadRouteModule.ts
-import fs11 from "fs";
+import fs12 from "fs";
 
 // src/loader/validateRouteModule.ts
 function validateRouteModule(value, method, filePath) {
@@ -2716,7 +2856,7 @@ async function loadRouteModule(filePath, method, rootDir) {
     const dist = getDevDist();
     if (dist) {
       const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-      if (sourcePath && fs11.existsSync(sourcePath)) {
+      if (sourcePath && fs12.existsSync(sourcePath)) {
         try {
           await ensureCompiled(sourcePath, rootDir, dist);
         } catch (compileErr) {
@@ -3471,9 +3611,9 @@ async function validateInput(schemaPath, method, inputType, input) {
 function mapZodIssues(error) {
   return error.issues.map((issue) => {
     const code = mapZodCode(issue.code, issue.message);
-    const path18 = issue.path.map(String).join(".") || "";
+    const path19 = issue.path.map(String).join(".") || "";
     return {
-      path: path18,
+      path: path19,
       code,
       expected: issue.expected ?? mapExpectedFromMessage(issue.message),
       received: issue.received ?? mapReceivedFromMessage(issue.message),
@@ -3535,9 +3675,9 @@ function getClientIp(req) {
 }
 
 // src/server/handleWsUpgrade.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
-import path10 from "path";
+import path11 from "path";
 
 // src/server/serverUtils.ts
 function nodeHttpToWebHeaders(req) {
@@ -3663,7 +3803,7 @@ async function loadWsHandler(filePath, ctx, rootDir) {
     const dist = getDevDist();
     if (dist) {
       const sourcePath = prodPathToSourcePath(filePath, rootDir, dist);
-      if (sourcePath && fs12.existsSync(sourcePath)) {
+      if (sourcePath && fs13.existsSync(sourcePath)) {
         await ensureCompiled(sourcePath, rootDir, dist);
       }
     }
@@ -3743,7 +3883,7 @@ function attachWebSocket(options) {
     const finalHandler = async () => {
       let handlers;
       try {
-        const absoluteFilePath = path10.resolve(rootDir, route.filePath);
+        const absoluteFilePath = path11.resolve(rootDir, route.filePath);
         handlers = await loadWsHandler(absoluteFilePath, ctx, rootDir);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
@@ -3868,15 +4008,15 @@ function limitStreamSize(stream, maxSize) {
     }
   });
 }
-function findAllowedMethods(routes, path18) {
+function findAllowedMethods(routes, path19) {
   const methods = /* @__PURE__ */ new Set();
   for (const route of routes) {
-    if (route.urlPath === path18) {
+    if (route.urlPath === path19) {
       methods.add(route.method);
       continue;
     }
     if (route.isDynamic) {
-      const params = matchDynamicPath(route.urlPath, path18, route.paramNames, route.isCatchAll);
+      const params = matchDynamicPath(route.urlPath, path19, route.paramNames, route.isCatchAll);
       if (params !== null) {
         methods.add(route.method);
       }
@@ -3968,7 +4108,7 @@ function createRoutePipeline(opts) {
     const match = resolveRouteOrThrow(routes, method, urlPath);
     ctx.params = match.params;
     const { route } = match;
-    const absoluteFilePath = path11.resolve(rootDir, route.filePath);
+    const absoluteFilePath = path12.resolve(rootDir, route.filePath);
     const routeModule = await loadRouteModule(absoluteFilePath, route.method, rootDir);
     const input = await resolveInput(route.method, request);
     const inputType = getInputTypeForMethod(route.method);
@@ -4065,8 +4205,8 @@ function applyPluginWrappers(server, handlerWrappers, upgradeWrappers) {
 }
 
 // src/cli/generateRoutes.ts
-import fs13 from "fs";
-import path12 from "path";
+import fs14 from "fs";
+import path13 from "path";
 async function hydrateRoutes(manifest) {
   const hydrateRoute = (serialized) => ({
     method: serialized.method,
@@ -4091,8 +4231,8 @@ async function hydrateRoutes(manifest) {
 }
 
 // src/cli/generateAgentArtifacts.ts
-import path13 from "path";
-import fs14 from "fs/promises";
+import path14 from "path";
+import fs15 from "fs/promises";
 
 // src/ast/extractAgentMetadata.ts
 import ts8 from "typescript";
@@ -4306,12 +4446,12 @@ function serializeAgents(agents, dist = "dist") {
   }));
 }
 async function writeAgentsModule(manifest, outputPath) {
-  const dir = path13.dirname(outputPath);
-  await fs14.mkdir(dir, { recursive: true });
+  const dir = path14.dirname(outputPath);
+  await fs15.mkdir(dir, { recursive: true });
   const content = `// \u81EA\u52A8\u751F\u6210,\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91(faapi build/dev \u4EA7\u7269)
 export const agents = ${JSON.stringify(manifest, null, 2)};
 `;
-  await fs14.writeFile(outputPath, content, "utf-8");
+  await fs15.writeFile(outputPath, content, "utf-8");
 }
 function hydrateAgents(manifest) {
   return manifest.map((a) => ({
@@ -4329,7 +4469,7 @@ function hydrateAgents(manifest) {
 async function generateAgentArtifacts(agents, rootDir, dist) {
   const metadata = [];
   for (const manifest of agents) {
-    const absPath = path13.resolve(rootDir, manifest.filePath);
+    const absPath = path14.resolve(rootDir, manifest.filePath);
     const program = createProgram(absPath);
     const result = extractAgentMetadata(program, absPath, {
       name: manifest.name,
@@ -4341,7 +4481,7 @@ async function generateAgentArtifacts(agents, rootDir, dist) {
     }
   }
   const serialized = serializeAgents(metadata, dist);
-  const agentsPath = path13.resolve(rootDir, dist, AGENTS_FILE);
+  const agentsPath = path14.resolve(rootDir, dist, AGENTS_FILE);
   await writeAgentsModule(serialized, agentsPath);
   return metadata;
 }
@@ -4413,8 +4553,8 @@ var TOOLS_FILE2 = "faapi-tools.js";
 var AGENTS_FILE2 = "faapi-agents.js";
 var PATTERNS = ["src/api/**/*.ts"];
 async function loadAndHydrateTools(rootDir, dist) {
-  const toolsPath = path14.resolve(rootDir, dist, TOOLS_FILE2);
-  if (!fs15.existsSync(toolsPath)) {
+  const toolsPath = path15.resolve(rootDir, dist, TOOLS_FILE2);
+  if (!fs16.existsSync(toolsPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(toolsPath);
@@ -4423,8 +4563,8 @@ async function loadAndHydrateTools(rootDir, dist) {
   return hydrated;
 }
 async function loadAndHydrateAgents(rootDir, dist) {
-  const agentsPath = path14.resolve(rootDir, dist, AGENTS_FILE2);
-  if (!fs15.existsSync(agentsPath)) {
+  const agentsPath = path15.resolve(rootDir, dist, AGENTS_FILE2);
+  if (!fs16.existsSync(agentsPath)) {
     return [];
   }
   const serialized = await importWithCacheBust(agentsPath);
@@ -4471,8 +4611,8 @@ function isFaapiConfigKey(key) {
 async function createAppBase(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const dist = options?.dist ?? process.env.FAAPI_DIST ?? DEFAULT_DIST;
-  const routesPath = path14.resolve(rootDir, dist, ROUTES_FILE);
-  if (!fs15.existsSync(routesPath)) {
+  const routesPath = path15.resolve(rootDir, dist, ROUTES_FILE);
+  if (!fs16.existsSync(routesPath)) {
     throw new Error(
       `[faapi] ${dist}/${ROUTES_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
     );
@@ -4693,17 +4833,17 @@ async function createAppBase(options) {
 
 // src/router/scanRoutes.ts
 import fg2 from "fast-glob";
-import path15 from "path";
-import fs16 from "fs";
+import path16 from "path";
+import fs17 from "fs";
 
 // src/router/constants.ts
 var HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"];
 var HTTP_METHOD_SET = new Set(HTTP_METHODS);
 
 // src/utils/normalizePath.ts
-function normalizePath(path18) {
-  if (!path18) return "";
-  let result = path18.replace(/\\/g, "/");
+function normalizePath(path19) {
+  if (!path19) return "";
+  let result = path19.replace(/\\/g, "/");
   result = result.replace(/\/+/g, "/");
   result = result.replace(/\/+$/, "");
   if (result && !result.startsWith("/")) {
@@ -4764,34 +4904,34 @@ function extractExportsFromSource(source) {
   return names;
 }
 function collectMiddlewarePaths(routeFilePath, rootDir, dist) {
-  const routeDir = path15.dirname(routeFilePath);
-  const resolvedRoot = path15.resolve(rootDir);
+  const routeDir = path16.dirname(routeFilePath);
+  const resolvedRoot = path16.resolve(rootDir);
   const paths = [];
-  let currentDir = path15.resolve(rootDir, routeDir);
+  let currentDir = path16.resolve(rootDir, routeDir);
   while (true) {
     if (dist) {
-      const mwTsPath = path15.join(currentDir, "middlewares.ts");
-      const mwJsPath = path15.join(currentDir, "middlewares.js");
-      const absTsPath = path15.resolve(rootDir, mwTsPath);
-      const absJsPath = path15.resolve(rootDir, mwJsPath);
-      const absMwPath = fs16.existsSync(absTsPath) ? absTsPath : fs16.existsSync(absJsPath) ? absJsPath : null;
+      const mwTsPath = path16.join(currentDir, "middlewares.ts");
+      const mwJsPath = path16.join(currentDir, "middlewares.js");
+      const absTsPath = path16.resolve(rootDir, mwTsPath);
+      const absJsPath = path16.resolve(rootDir, mwJsPath);
+      const absMwPath = fs17.existsSync(absTsPath) ? absTsPath : fs17.existsSync(absJsPath) ? absJsPath : null;
       if (absMwPath) {
-        const relMwPath = path15.relative(rootDir, absMwPath);
-        const prodAbsPath = path15.resolve(rootDir, toProdFilePath3(relMwPath, dist));
+        const relMwPath = path16.relative(rootDir, absMwPath);
+        const prodAbsPath = path16.resolve(rootDir, toProdFilePath3(relMwPath, dist));
         paths.push(prodAbsPath);
       }
     } else {
       for (const ext of [".ts", ".js"]) {
-        const mwPath = path15.join(currentDir, `middlewares${ext}`);
-        const absMwPath = path15.resolve(rootDir, mwPath);
-        if (fs16.existsSync(absMwPath)) {
+        const mwPath = path16.join(currentDir, `middlewares${ext}`);
+        const absMwPath = path16.resolve(rootDir, mwPath);
+        if (fs17.existsSync(absMwPath)) {
           paths.push(absMwPath);
           break;
         }
       }
     }
     if (currentDir === resolvedRoot) break;
-    const parentDir = path15.dirname(currentDir);
+    const parentDir = path16.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -4818,7 +4958,7 @@ async function scanRoutes(rootDir, patterns, dist) {
     const normalizedFile = file.replace(/\\/g, "/");
     const fileName = normalizedFile.split("/").pop();
     if (fileName === "handler.ts" || fileName === "handler.js") {
-      const absPath = path15.resolve(rootDir, normalizedFile);
+      const absPath = path16.resolve(rootDir, normalizedFile);
       const urlPath = filePathToUrlPath(normalizedFile);
       const paramNames = extractParamNames(urlPath);
       const isDynamic = paramNames.length > 0;
@@ -4831,7 +4971,7 @@ async function scanRoutes(rootDir, patterns, dist) {
         const mwPaths = collectMiddlewarePaths(normalizedFile, rootDir);
         middlewareBundle = await loadMergedMiddlewares(mwPaths);
       }
-      const source = await fs16.promises.readFile(absPath, "utf8").catch(() => "");
+      const source = await fs17.promises.readFile(absPath, "utf8").catch(() => "");
       const exportNames = extractExportsFromSource(source);
       const methods = HTTP_METHODS.filter((m) => exportNames.has(m));
       for (const method of methods) {
@@ -4867,8 +5007,8 @@ async function scanRoutes(rootDir, patterns, dist) {
 
 // src/tools/scanTools.ts
 import fg3 from "fast-glob";
-import path16 from "path";
-import fs17 from "fs";
+import path17 from "path";
+import fs18 from "fs";
 var TOOL_PATTERNS = ["src/tools/**/*.ts"];
 var TOOL_EXPORT_RE = new RegExp(
   String.raw`export\s+(?:async\s+)?(?:function\s+|const\s+)([A-Za-z_$][\w$]*)\s*(?:\(|=)`,
@@ -4918,8 +5058,8 @@ async function scanTools(rootDir, patterns) {
     if (fileName !== "handler.ts" && fileName !== "handler.js") {
       continue;
     }
-    const absPath = path16.resolve(rootDir, normalizedFile);
-    const source = await fs17.promises.readFile(absPath, "utf8").catch(() => "");
+    const absPath = path17.resolve(rootDir, normalizedFile);
+    const source = await fs18.promises.readFile(absPath, "utf8").catch(() => "");
     const exportNames = extractToolExportsFromSource(source);
     const namespace = filePathToToolNamespace(normalizedFile);
     for (const fnName of exportNames) {
@@ -4943,8 +5083,8 @@ async function scanTools(rootDir, patterns) {
 
 // src/agents/scanAgents.ts
 import fg4 from "fast-glob";
-import path17 from "path";
-import fs18 from "fs";
+import path18 from "path";
+import fs19 from "fs";
 var DEFAULT_AGENT_PATTERNS = ["src/agents/*/handler.ts"];
 var RUN_EXPORT_RE = /export\s+(?:async\s+)?(?:function\s+|const\s+)run\b/;
 function extractAgentNameFromPath(filePath) {
@@ -4976,8 +5116,8 @@ async function scanAgents(rootDir, patterns) {
     if (fileName !== "handler.ts" && fileName !== "handler.js") {
       continue;
     }
-    const absPath = path17.resolve(rootDir, normalizedFile);
-    const source = await fs18.promises.readFile(absPath, "utf8").catch(() => "");
+    const absPath = path18.resolve(rootDir, normalizedFile);
+    const source = await fs19.promises.readFile(absPath, "utf8").catch(() => "");
     const { hasRun } = detectAgentExports(source);
     const name = extractAgentNameFromPath(normalizedFile);
     const prevFile = seen.get(name);