@faapi/faapi 0.0.0-canary.c6dc0f7 → 0.0.0-canary.e2ee43b

package/dist/cli/index.js

@@ -23,9 +23,9 @@ var init_constants = __esm({
 });
 
 // src/utils/normalizePath.ts
-function normalizePath(path12) {
-  if (!path12) return "";
-  let result = path12.replace(/\\/g, "/");
+function normalizePath(path15) {
+  if (!path15) return "";
+  let result = path15.replace(/\\/g, "/");
   result = result.replace(/\/+/g, "/");
   result = result.replace(/\/+$/, "");
   if (result && !result.startsWith("/")) {
@@ -89,9 +89,9 @@ function getLoadTimestamp() {
 }
 async function importWithCacheBust(filePath) {
   let url = pathToFileURL(filePath).href;
-  const ts6 = getLoadTimestamp();
-  if (ts6 !== void 0) {
-    url += `?t=${ts6}`;
+  const ts7 = getLoadTimestamp();
+  if (ts7 !== void 0) {
+    url += `?t=${ts7}`;
   }
   return await import(url);
 }
@@ -157,18 +157,32 @@ var init_loadMiddlewares = __esm({
 import fg from "fast-glob";
 import path from "path";
 import fs from "fs";
-async function findMergedMiddlewares(routeFilePath, rootDir) {
+function toProdAbsPath(sourceAbsPath, rootDir, prodDir) {
+  const rel = path.relative(rootDir, sourceAbsPath);
+  const prodRel = `${prodDir}/${rel.replace(/\.ts$/, ".js")}`;
+  return path.resolve(rootDir, prodRel);
+}
+async function findMergedMiddlewares(routeFilePath, rootDir, prodDir) {
   const routeDir = path.dirname(routeFilePath);
   const resolvedRoot = path.resolve(rootDir);
   const mwPaths = [];
   let currentDir = path.resolve(rootDir, routeDir);
   while (true) {
-    for (const ext of [".ts", ".js"]) {
-      const mwPath = path.join(currentDir, `middlewares${ext}`);
+    if (prodDir) {
+      const mwPath = path.join(currentDir, "middlewares.js");
       const absMwPath = path.resolve(rootDir, mwPath);
-      if (fs.existsSync(absMwPath)) {
-        mwPaths.push(absMwPath);
-        break;
+      const prodAbsMwPath = toProdAbsPath(absMwPath, rootDir, prodDir);
+      if (fs.existsSync(prodAbsMwPath)) {
+        mwPaths.push(prodAbsMwPath);
+      }
+    } else {
+      for (const ext of [".ts", ".js"]) {
+        const mwPath = path.join(currentDir, `middlewares${ext}`);
+        const absMwPath = path.resolve(rootDir, mwPath);
+        if (fs.existsSync(absMwPath)) {
+          mwPaths.push(absMwPath);
+          break;
+        }
       }
     }
     if (currentDir === resolvedRoot) break;
@@ -222,7 +236,7 @@ async function hasWsExport(absPath) {
     return false;
   }
 }
-async function scanRoutes(rootDir, patterns, appDir) {
+async function scanRoutes(rootDir, patterns, appDir, prodDir) {
   const dir = appDir ?? ".";
   const files = await fg(patterns, {
     cwd: rootDir,
@@ -236,12 +250,13 @@ async function scanRoutes(rootDir, patterns, appDir) {
     const fileName = normalizedFile.split("/").pop();
     if (fileName === "handler.ts" || fileName === "handler.js") {
       const absPath = path.resolve(rootDir, normalizedFile);
+      const importPath = prodDir ? toProdAbsPath(absPath, rootDir, prodDir) : absPath;
       const urlPath = filePathToUrlPath(normalizedFile, dir);
       const paramNames = extractParamNames(urlPath);
       const isDynamic = paramNames.length > 0;
       const isCatchAll = normalizedFile.split("/").some(isCatchAllSegment);
-      const middlewareBundle = await findMergedMiddlewares(normalizedFile, rootDir);
-      const methods = await extractMethodsFromHandler(absPath);
+      const middlewareBundle = await findMergedMiddlewares(normalizedFile, rootDir, prodDir);
+      const methods = await extractMethodsFromHandler(importPath);
       for (const method of methods) {
         routes.push({
           method,
@@ -254,7 +269,7 @@ async function scanRoutes(rootDir, patterns, appDir) {
           injectors: middlewareBundle?.injectors
         });
       }
-      const hasWs = await hasWsExport(absPath);
+      const hasWs = await hasWsExport(importPath);
       if (hasWs) {
         wsRoutes.push({
           urlPath,
@@ -1122,35 +1137,35 @@ function generateObjectValidation(type, varName, issuesVar, ctx, pathExpr) {
   return lines.join("\n");
 }
 function generateValueValidation(type, varName, issuesVar, ctx, pathExpr) {
-  const path12 = pathExpr ?? "''";
+  const path15 = pathExpr ?? "''";
   switch (type.kind) {
     case "any":
     case "unknown":
       return "";
     // 不校验
     case "string":
-      return `if (typeof ${varName} !== 'string') ${issuesVar}.push({ path: ${path12}, code: 'TYPE_MISMATCH', expected: 'string', received: typeof ${varName}, message: '\u671F\u671B string\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`;
+      return `if (typeof ${varName} !== 'string') ${issuesVar}.push({ path: ${path15}, code: 'TYPE_MISMATCH', expected: 'string', received: typeof ${varName}, message: '\u671F\u671B string\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`;
     case "number":
-      return `if (typeof ${varName} !== 'number' || Number.isNaN(${varName})) ${issuesVar}.push({ path: ${path12}, code: 'TYPE_MISMATCH', expected: 'number', received: typeof ${varName}, message: '\u671F\u671B number\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`;
+      return `if (typeof ${varName} !== 'number' || Number.isNaN(${varName})) ${issuesVar}.push({ path: ${path15}, code: 'TYPE_MISMATCH', expected: 'number', received: typeof ${varName}, message: '\u671F\u671B number\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`;
     case "boolean":
-      return `if (typeof ${varName} !== 'boolean') ${issuesVar}.push({ path: ${path12}, code: 'TYPE_MISMATCH', expected: 'boolean', received: typeof ${varName}, message: '\u671F\u671B boolean\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`;
+      return `if (typeof ${varName} !== 'boolean') ${issuesVar}.push({ path: ${path15}, code: 'TYPE_MISMATCH', expected: 'boolean', received: typeof ${varName}, message: '\u671F\u671B boolean\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`;
     case "bigint":
-      return `if (typeof ${varName} !== 'bigint') ${issuesVar}.push({ path: ${path12}, code: 'TYPE_MISMATCH', expected: 'bigint', received: typeof ${varName}, message: '\u671F\u671B bigint\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`;
+      return `if (typeof ${varName} !== 'bigint') ${issuesVar}.push({ path: ${path15}, code: 'TYPE_MISMATCH', expected: 'bigint', received: typeof ${varName}, message: '\u671F\u671B bigint\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`;
     case "null":
-      return `if (${varName} !== null) ${issuesVar}.push({ path: ${path12}, code: 'TYPE_MISMATCH', expected: 'null', received: typeof ${varName}, message: '\u671F\u671B null\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`;
+      return `if (${varName} !== null) ${issuesVar}.push({ path: ${path15}, code: 'TYPE_MISMATCH', expected: 'null', received: typeof ${varName}, message: '\u671F\u671B null\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`;
     case "undefined":
-      return `if (${varName} !== undefined) ${issuesVar}.push({ path: ${path12}, code: 'TYPE_MISMATCH', expected: 'undefined', received: typeof ${varName}, message: '\u671F\u671B undefined' });`;
+      return `if (${varName} !== undefined) ${issuesVar}.push({ path: ${path15}, code: 'TYPE_MISMATCH', expected: 'undefined', received: typeof ${varName}, message: '\u671F\u671B undefined' });`;
     case "literal":
-      return `if (${varName} !== ${JSON.stringify(type.value)}) ${issuesVar}.push({ path: ${path12}, code: 'INVALID_VALUE', expected: ${JSON.stringify(JSON.stringify(type.value))}, received: JSON.stringify(${varName}), message: '\u671F\u671B\u5B57\u9762\u91CF ${JSON.stringify(type.value)}\uFF0C\u5B9E\u9645 ' + JSON.stringify(${varName}) });`;
+      return `if (${varName} !== ${JSON.stringify(type.value)}) ${issuesVar}.push({ path: ${path15}, code: 'INVALID_VALUE', expected: ${JSON.stringify(JSON.stringify(type.value))}, received: JSON.stringify(${varName}), message: '\u671F\u671B\u5B57\u9762\u91CF ${JSON.stringify(type.value)}\uFF0C\u5B9E\u9645 ' + JSON.stringify(${varName}) });`;
     case "date":
       return `if (${varName} instanceof Date) { /* Date \u5B9E\u4F8B,\u901A\u8FC7 */ }
-else if (typeof ${varName} !== 'string') ${issuesVar}.push({ path: ${path12}, code: 'TYPE_MISMATCH', expected: 'Date | ISO 8601 string', received: typeof ${varName}, message: '\u671F\u671B Date \u6216 ISO 8601 \u5B57\u7B26\u4E32\uFF0C\u5B9E\u9645 ' + typeof ${varName} });
-else if (!/^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?(Z|[+-]\\d{2}:?\\d{2})?)?$/.test(${varName}) || isNaN(new Date(${varName}).getTime())) ${issuesVar}.push({ path: ${path12}, code: 'INVALID_FORMAT', expected: 'ISO 8601', received: String(${varName}), message: '\u4E0D\u662F\u5408\u6CD5\u7684 ISO 8601 \u65E5\u671F\u5B57\u7B26\u4E32: ' + ${varName} });`;
+else if (typeof ${varName} !== 'string') ${issuesVar}.push({ path: ${path15}, code: 'TYPE_MISMATCH', expected: 'Date | ISO 8601 string', received: typeof ${varName}, message: '\u671F\u671B Date \u6216 ISO 8601 \u5B57\u7B26\u4E32\uFF0C\u5B9E\u9645 ' + typeof ${varName} });
+else if (!/^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?(Z|[+-]\\d{2}:?\\d{2})?)?$/.test(${varName}) || isNaN(new Date(${varName}).getTime())) ${issuesVar}.push({ path: ${path15}, code: 'INVALID_FORMAT', expected: 'ISO 8601', received: String(${varName}), message: '\u4E0D\u662F\u5408\u6CD5\u7684 ISO 8601 \u65E5\u671F\u5B57\u7B26\u4E32: ' + ${varName} });`;
     case "array": {
       const id = ctx.nextVarId();
       const itemVar = `item${id}`;
       const indexVar = `i${id}`;
-      const elemPath = `${path12} + '[' + ${indexVar} + ']'`;
+      const elemPath = `${path15} + '[' + ${indexVar} + ']'`;
       const elemValidation = generateValueValidation(
         type.element,
         itemVar,
@@ -1158,7 +1173,7 @@ else if (!/^\\d{4}-\\d{2}-\\d{2}(T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?(Z|[+-]\\d{2
         ctx,
         elemPath
       );
-      return `if (!Array.isArray(${varName})) ${issuesVar}.push({ path: ${path12}, code: 'TYPE_MISMATCH', expected: 'array', received: typeof ${varName}, message: '\u671F\u671B\u6570\u7EC4\uFF0C\u5B9E\u9645 ' + typeof ${varName} });
+      return `if (!Array.isArray(${varName})) ${issuesVar}.push({ path: ${path15}, code: 'TYPE_MISMATCH', expected: 'array', received: typeof ${varName}, message: '\u671F\u671B\u6570\u7EC4\uFF0C\u5B9E\u9645 ' + typeof ${varName} });
 else for (let ${indexVar} = 0; ${indexVar} < ${varName}.length; ${indexVar}++) { const ${itemVar} = ${varName}[${indexVar}]; ${elemValidation} }`;
     }
     case "tuple": {
@@ -1170,21 +1185,21 @@ else for (let ${indexVar} = 0; ${indexVar} < ${varName}.length; ${indexVar}++) {
       const indexVar = `ti${id}`;
       const lines = [];
       lines.push(
-        `if (!Array.isArray(${varName})) ${issuesVar}.push({ path: ${path12}, code: 'TYPE_MISMATCH', expected: 'tuple', received: typeof ${varName}, message: '\u671F\u671B\u5143\u7EC4\uFF08\u6570\u7EC4\uFF09\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`
+        `if (!Array.isArray(${varName})) ${issuesVar}.push({ path: ${path15}, code: 'TYPE_MISMATCH', expected: 'tuple', received: typeof ${varName}, message: '\u671F\u671B\u5143\u7EC4\uFF08\u6570\u7EC4\uFF09\uFF0C\u5B9E\u9645 ' + typeof ${varName} });`
       );
       lines.push(`else {`);
       lines.push(
-        `if (${varName}.length < ${minRequired}) ${issuesVar}.push({ path: ${path12}, code: 'MISSING_FIELD', expected: 'tuple length >= ${minRequired}', received: 'length ' + ${varName}.length, message: '\u5143\u7EC4\u957F\u5EA6\u4E0D\u8DB3\uFF0C\u671F\u671B\u81F3\u5C11 ${minRequired}\uFF0C\u5B9E\u9645 ' + ${varName}.length });`
+        `if (${varName}.length < ${minRequired}) ${issuesVar}.push({ path: ${path15}, code: 'MISSING_FIELD', expected: 'tuple length >= ${minRequired}', received: 'length ' + ${varName}.length, message: '\u5143\u7EC4\u957F\u5EA6\u4E0D\u8DB3\uFF0C\u671F\u671B\u81F3\u5C11 ${minRequired}\uFF0C\u5B9E\u9645 ' + ${varName}.length });`
       );
       if (!restElement) {
         lines.push(
-          `if (${varName}.length > ${fixedCount}) ${issuesVar}.push({ path: ${path12}, code: 'INVALID_VALUE', expected: 'tuple length = ${fixedCount}', received: 'length ' + ${varName}.length, message: '\u5143\u7EC4\u957F\u5EA6\u8D85\u51FA\uFF0C\u671F\u671B ${fixedCount}\uFF0C\u5B9E\u9645 ' + ${varName}.length });`
+          `if (${varName}.length > ${fixedCount}) ${issuesVar}.push({ path: ${path15}, code: 'INVALID_VALUE', expected: 'tuple length = ${fixedCount}', received: 'length ' + ${varName}.length, message: '\u5143\u7EC4\u957F\u5EA6\u8D85\u51FA\uFF0C\u671F\u671B ${fixedCount}\uFF0C\u5B9E\u9645 ' + ${varName}.length });`
         );
       }
       for (let i = 0; i < type.elements.length; i++) {
         const elem = type.elements[i];
         if (elem.rest) continue;
-        const elemPath = `${path12} + '[' + ${i} + ']'`;
+        const elemPath = `${path15} + '[' + ${i} + ']'`;
         const elemAccess = `${varName}[${i}]`;
         if (elem.optional) {
           lines.push(`if (${i} < ${varName}.length && ${elemAccess} !== undefined) {`);
@@ -1195,7 +1210,7 @@ else for (let ${indexVar} = 0; ${indexVar} < ${varName}.length; ${indexVar}++) {
         lines.push(`}`);
       }
       if (restElement) {
-        const restPath = `${path12} + '[' + ${indexVar} + ']'`;
+        const restPath = `${path15} + '[' + ${indexVar} + ']'`;
         const restValidation = generateValueValidation(
           restElement.type,
           itemVar,
@@ -1213,23 +1228,23 @@ else for (let ${indexVar} = 0; ${indexVar} < ${varName}.length; ${indexVar}++) {
     case "union": {
       const tempVar = `tempIssues_${Math.random().toString(36).slice(2, 8)}`;
       const memberChecks = type.members.map((member) => {
-        const check = generateValueValidation(member, varName, tempVar, ctx, path12);
+        const check = generateValueValidation(member, varName, tempVar, ctx, path15);
         return `(() => { const ${tempVar} = []; ${check}; return ${tempVar}.length === 0; })()`;
       });
       const expected = runtimeTypeToExpected(type);
-      return `if (!(${memberChecks.join(" || ")})) ${issuesVar}.push({ path: ${path12}, code: 'TYPE_MISMATCH', expected: ${JSON.stringify(expected)}, received: typeof ${varName}, message: '\u503C ' + JSON.stringify(${varName}) + ' \u4E0D\u5339\u914D\u8054\u5408\u7C7B\u578B ${expected.replace(/'/g, "\\'")}' });`;
+      return `if (!(${memberChecks.join(" || ")})) ${issuesVar}.push({ path: ${path15}, code: 'TYPE_MISMATCH', expected: ${JSON.stringify(expected)}, received: typeof ${varName}, message: '\u503C ' + JSON.stringify(${varName}) + ' \u4E0D\u5339\u914D\u8054\u5408\u7C7B\u578B ${expected.replace(/'/g, "\\'")}' });`;
     }
     case "record": {
-      const valuePath = `${path12} + '.' + key`;
+      const valuePath = `${path15} + '.' + key`;
       const valueValidation = generateValueValidation(type.value, "val", issuesVar, ctx, valuePath);
-      return `if (typeof ${varName} !== 'object' || ${varName} === null || Array.isArray(${varName})) ${issuesVar}.push({ path: ${path12}, code: 'TYPE_MISMATCH', expected: 'object', received: typeof ${varName}, message: '\u671F\u671B\u5BF9\u8C61\uFF0C\u5B9E\u9645 ' + typeof ${varName} });
+      return `if (typeof ${varName} !== 'object' || ${varName} === null || Array.isArray(${varName})) ${issuesVar}.push({ path: ${path15}, code: 'TYPE_MISMATCH', expected: 'object', received: typeof ${varName}, message: '\u671F\u671B\u5BF9\u8C61\uFF0C\u5B9E\u9645 ' + typeof ${varName} });
 else for (const [key, val] of Object.entries(${varName})) { ${valueValidation} }`;
     }
     case "object": {
-      return generateInlineObjectValidation(type, varName, issuesVar, ctx, path12);
+      return generateInlineObjectValidation(type, varName, issuesVar, ctx, path15);
     }
     case "ref": {
-      return `validate_${type.name}(${varName}, ${path12}, ${issuesVar});`;
+      return `validate_${type.name}(${varName}, ${path15}, ${issuesVar});`;
     }
   }
 }
@@ -1289,6 +1304,75 @@ var init_generateValidatorCode = __esm({
   }
 });
 
+// src/validator/schemaRegistry.ts
+var SchemaRegistry, schemaRegistry;
+var init_schemaRegistry = __esm({
+  "src/validator/schemaRegistry.ts"() {
+    "use strict";
+    SchemaRegistry = class {
+      manifest = /* @__PURE__ */ new Map();
+      /**
+       * 批量加载 manifest
+       * 覆盖已有数据
+       */
+      loadManifest(manifest) {
+        this.manifest.clear();
+        for (const [filePath, fileSchemas] of manifest) {
+          const copy = /* @__PURE__ */ new Map();
+          fileSchemas.forEach((value, key) => copy.set(key, value));
+          this.manifest.set(filePath, copy);
+        }
+      }
+      /**
+       * 查询单条 schema
+       * @returns SchemaEntry | null | undefined
+       *          - SchemaEntry：有类型声明
+       *          - null：无类型声明（跳过校验）
+       *          - undefined：manifest 不完整（抛错）
+       */
+      get(filePath, schemaName) {
+        const fileSchemas = this.manifest.get(filePath);
+        if (!fileSchemas) return void 0;
+        return fileSchemas.get(schemaName);
+      }
+      /**
+       * 设置单个文件的所有 schema
+       * 覆盖该文件的已有数据
+       */
+      set(filePath, schemas) {
+        const copy = /* @__PURE__ */ new Map();
+        schemas.forEach((value, key) => copy.set(key, value));
+        this.manifest.set(filePath, copy);
+      }
+      /**
+       * 删除单个文件（文件被删除时）
+       */
+      delete(filePath) {
+        this.manifest.delete(filePath);
+      }
+      /**
+       * 判断文件是否已注册
+       */
+      hasFile(filePath) {
+        return this.manifest.has(filePath);
+      }
+      /**
+       * 清空（测试用 / watch 全量重建前）
+       */
+      clear() {
+        this.manifest.clear();
+      }
+      /**
+       * 已注册的文件数量
+       */
+      get size() {
+        return this.manifest.size;
+      }
+    };
+    schemaRegistry = new SchemaRegistry();
+  }
+});
+
 // src/ast/createProgram.ts
 import ts4 from "typescript";
 function invalidateProgramCache() {
@@ -1521,9 +1605,17 @@ async function writeSchemaModule(entries, allTypesMap, outputPath) {
   await fs3.mkdir(path4.dirname(outputPath), { recursive: true });
   await fs3.writeFile(outputPath, source, "utf-8");
 }
+async function generateSchemaFile(routes, rootDir, outputPath) {
+  const { sources, allTypesByFile } = collectRouteSchemaSources(routes, rootDir);
+  const entries = sources.map(({ filePath, schemaName, typeInfo }) => ({
+    filePath,
+    schemaName,
+    typeInfo
+  }));
+  await writeSchemaModule(entries, allTypesByFile, outputPath);
+}
 async function readManifestFile(inputPath) {
-  const fileUrl = `file://${inputPath}`;
-  const mod = await import(fileUrl);
+  const mod = await importWithCacheBust(inputPath);
   const validators = mod.validators;
   const properties = mod.properties ?? {};
   const manifest = /* @__PURE__ */ new Map();
@@ -1546,27 +1638,51 @@ async function readManifestFile(inputPath) {
   }
   return manifest;
 }
+function remapManifestKeys(manifest, rootDir, prodDir) {
+  const remapped = /* @__PURE__ */ new Map();
+  const rootPrefix = rootDir + path4.sep;
+  for (const [filePath, fileSchemas] of manifest) {
+    let rel = filePath;
+    if (filePath.startsWith(rootPrefix)) {
+      rel = filePath.slice(rootPrefix.length);
+    } else if (filePath.startsWith(rootDir)) {
+      rel = filePath.slice(rootDir.length).replace(/^[/\\]/, "");
+    }
+    const prodRel = `${prodDir}/${rel.replace(/\.ts$/, ".js")}`;
+    const prodAbs = path4.resolve(rootDir, prodRel);
+    remapped.set(prodAbs, fileSchemas);
+  }
+  return remapped;
+}
+async function loadSchemaToRegistry(schemaPath, rootDir, prodDir, remap = true) {
+  const manifest = await readManifestFile(schemaPath);
+  const finalManifest = remap ? remapManifestKeys(manifest, rootDir, prodDir) : manifest;
+  schemaRegistry.loadManifest(finalManifest);
+  return finalManifest;
+}
 var init_generateSchema = __esm({
   "src/cli/generateSchema.ts"() {
     "use strict";
     init_generateValidatorCode();
+    init_schemaRegistry();
     init_collectRouteSchemaSources();
+    init_importWithCacheBust();
   }
 });
 
 // src/cli/generateRoutes.ts
 import fs4 from "fs";
 import path5 from "path";
-function toProdFilePath(filePath) {
+function toProdFilePath(filePath, prodDir) {
   const jsPath = filePath.replace(/\.ts$/, ".js");
-  return jsPath.startsWith("dist/") ? jsPath : `dist/${jsPath}`;
+  return jsPath.startsWith(`${prodDir}/`) ? jsPath : `${prodDir}/${jsPath}`;
 }
-function serializeRoutes(routes, wsRoutes, rootDir) {
+function serializeRoutes(routes, wsRoutes, rootDir, prodDir = "dist") {
   const serialize = (route) => {
-    const middlewarePaths = extractMiddlewarePaths(route.filePath, rootDir);
+    const middlewarePaths = extractMiddlewarePaths(route.filePath, rootDir, prodDir);
     const serialized = {
       urlPath: route.urlPath,
-      filePath: toProdFilePath(route.filePath),
+      filePath: toProdFilePath(route.filePath, prodDir),
       paramNames: route.paramNames,
       isDynamic: route.isDynamic,
       isCatchAll: route.isCatchAll,
@@ -1582,21 +1698,21 @@ function serializeRoutes(routes, wsRoutes, rootDir) {
     wsRoutes: wsRoutes.map(serialize)
   };
 }
-function extractMiddlewarePaths(routeFilePath, rootDir) {
+function extractMiddlewarePaths(routeFilePath, rootDir, prodDir) {
   const routeDir = path5.dirname(routeFilePath);
   const resolvedRoot = path5.resolve(rootDir);
   const paths = [];
   let currentDir = path5.resolve(rootDir, routeDir);
   while (true) {
-    for (const ext of [".ts", ".js"]) {
-      const mwPath = path5.join(currentDir, `middlewares${ext}`);
-      const absMwPath = path5.resolve(rootDir, mwPath);
-      if (fs4.existsSync(absMwPath)) {
-        const relMwPath = path5.relative(rootDir, absMwPath);
-        const prodAbsPath = path5.resolve(rootDir, toProdFilePath(relMwPath));
-        paths.push(prodAbsPath);
-        break;
-      }
+    const mwTsPath = path5.join(currentDir, "middlewares.ts");
+    const mwJsPath = path5.join(currentDir, "middlewares.js");
+    const absTsPath = path5.resolve(rootDir, mwTsPath);
+    const absJsPath = path5.resolve(rootDir, mwJsPath);
+    const absMwPath = fs4.existsSync(absTsPath) ? absTsPath : fs4.existsSync(absJsPath) ? absJsPath : null;
+    if (absMwPath) {
+      const relMwPath = path5.relative(rootDir, absMwPath);
+      const prodAbsPath = path5.resolve(rootDir, toProdFilePath(relMwPath, prodDir));
+      paths.push(prodAbsPath);
     }
     if (currentDir === resolvedRoot) break;
     const parentDir = path5.dirname(currentDir);
@@ -1669,23 +1785,184 @@ var init_generateRoutes = __esm({
   }
 });
 
+// src/utils/readTsconfig.ts
+import ts6 from "typescript";
+import path6 from "path";
+import fs5 from "fs";
+function readTsconfig(rootDir) {
+  const tsconfigPath = path6.resolve(rootDir, "tsconfig.json");
+  if (!fs5.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);
+  const baseUrl = parsed.options.baseUrl ?? rootDir;
+  const rawPaths = parsed.options.paths;
+  if (!rawPaths) return null;
+  const paths = {};
+  for (const [pattern, targets] of Object.entries(rawPaths)) {
+    paths[pattern] = targets.map((t) => path6.resolve(baseUrl, t));
+  }
+  return { baseUrl, paths };
+}
+var init_readTsconfig = __esm({
+  "src/utils/readTsconfig.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/resolveAlias.ts
+function resolveAlias(specifier, config) {
+  const candidates = [];
+  for (const [pattern, targets] of Object.entries(config.paths)) {
+    const wildcardIndex = pattern.indexOf("*");
+    if (wildcardIndex === -1) {
+      if (specifier === pattern) {
+        candidates.push(...targets);
+      }
+      continue;
+    }
+    const prefix = pattern.slice(0, wildcardIndex);
+    const suffix = pattern.slice(wildcardIndex + 1);
+    if (specifier.startsWith(prefix) && specifier.endsWith(suffix) && specifier.length >= prefix.length + suffix.length) {
+      const captured = specifier.slice(prefix.length, specifier.length - suffix.length);
+      for (const target of targets) {
+        candidates.push(target.replace("*", captured));
+      }
+    }
+  }
+  return candidates;
+}
+var init_resolveAlias = __esm({
+  "src/utils/resolveAlias.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/compileRoutes.ts
+import path7 from "path";
+import fs6 from "fs";
+import fg2 from "fast-glob";
+function toProdExtension(filePath) {
+  if (filePath.endsWith(".ts")) return filePath.slice(0, -3) + ".js";
+  if (filePath.endsWith(".tsx")) return filePath.slice(0, -4) + ".js";
+  if (filePath.endsWith(".jsx")) return filePath.slice(0, -4) + ".js";
+  return filePath;
+}
+function toProdImportPath(sourceFile, importer) {
+  const importerDir = path7.dirname(importer);
+  let rel = path7.relative(importerDir, sourceFile);
+  rel = rel.split(path7.sep).join("/");
+  if (!rel.startsWith(".")) rel = "./" + rel;
+  return toProdExtension(rel);
+}
+function createAliasPlugin(config) {
+  const EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
+  const INDEX_EXTS = [
+    "/index.ts",
+    "/index.tsx",
+    "/index.js",
+    "/index.jsx",
+    "/index.mjs",
+    "/index.cjs"
+  ];
+  const SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
+  return {
+    name: "faapi-alias",
+    setup(build) {
+      build.onLoad({ filter: /\.(ts|tsx|js|jsx|mjs|cjs)$/ }, (args) => {
+        let source;
+        try {
+          source = fs6.readFileSync(args.path, "utf8");
+        } catch {
+          return void 0;
+        }
+        const importer = args.path;
+        let modified = false;
+        const newSource = source.replace(SPEC_RE, (full, prefix, quote, specifier) => {
+          if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("file:") || specifier.startsWith("node:")) {
+            return full;
+          }
+          const candidates = resolveAlias(specifier, config);
+          for (const candidate of candidates) {
+            for (const ext of EXTS) {
+              const file = candidate + ext;
+              if (fs6.existsSync(file)) {
+                modified = true;
+                return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
+              }
+            }
+            for (const indexExt of INDEX_EXTS) {
+              const file = candidate + indexExt;
+              if (fs6.existsSync(file)) {
+                modified = true;
+                return `${prefix}${quote}${toProdImportPath(file, importer)}${quote}`;
+              }
+            }
+          }
+          return full;
+        });
+        if (!modified) return void 0;
+        return { contents: newSource, loader: "default" };
+      });
+    }
+  };
+}
+async function compileRoutes(options) {
+  const { rootDir, appDir, outDir, files, logLevel = "silent" } = options;
+  const allFiles = files ?? await fg2([`${appDir}/**/*.ts`], {
+    cwd: rootDir,
+    onlyFiles: true,
+    absolute: true,
+    ignore: ["**/*.test.ts", "**/*.e2e.test.ts", "**/*.d.ts"]
+  });
+  if (allFiles.length === 0) {
+    return { compiledFiles: [] };
+  }
+  const absOutDir = path7.resolve(rootDir, outDir);
+  await fs6.promises.mkdir(absOutDir, { recursive: true });
+  const tsconfig = readTsconfig(rootDir);
+  const plugins = tsconfig ? [createAliasPlugin(tsconfig)] : [];
+  const esbuild = await import("esbuild");
+  await esbuild.build({
+    entryPoints: allFiles,
+    outdir: absOutDir,
+    outbase: rootDir,
+    bundle: false,
+    platform: "node",
+    format: "esm",
+    sourcemap: true,
+    packages: "external",
+    plugins,
+    logLevel
+  });
+  return { compiledFiles: allFiles };
+}
+var init_compileRoutes = __esm({
+  "src/cli/compileRoutes.ts"() {
+    "use strict";
+    init_readTsconfig();
+    init_resolveAlias();
+  }
+});
+
 // src/cli/buildCommand.ts
 var buildCommand_exports = {};
 __export(buildCommand_exports, {
   buildCommand: () => buildCommand,
   parseBuildArgs: () => parseBuildArgs
 });
-import path6 from "path";
-import fs5 from "fs";
-import fg2 from "fast-glob";
+import path8 from "path";
 async function buildCommand(options) {
   const { rootDir, patterns, appDir, outdir, types } = options;
   console.log("faapi build started");
   console.log(`- Root: ${rootDir}`);
   console.log(`- Patterns: ${patterns.join(", ")}`);
   console.log(`- Output: ${outdir}`);
-  console.log("\n[1/5] Scanning routes...");
-  const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, appDir);
+  console.log("\n[1/5] Compiling TypeScript...");
+  const result = await compileRoutes({ rootDir, appDir, outDir: outdir, logLevel: "silent" });
+  console.log(`  Compiled ${result.compiledFiles.length} file(s)`);
+  console.log("\n[2/5] Scanning routes...");
+  const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, appDir, outdir);
   const sorted = sortRoutes(routes);
   console.log(`  Found ${sorted.length} routes, ${wsRoutes.length} WS routes`);
   const conflicts = detectRouteConflicts(sorted);
@@ -1698,62 +1975,21 @@ async function buildCommand(options) {
       }
     }
   }
-  console.log("\n[2/5] Generating types...");
-  const typesPath = types ? path6.resolve(rootDir, types) : path6.resolve(rootDir, "faapi-types.ts");
+  console.log("\n[3/5] Generating types...");
+  const typesPath = types ? path8.resolve(rootDir, types) : path8.resolve(rootDir, "faapi-types.ts");
   await generateTypes(sorted, rootDir, typesPath);
   console.log(`  Written to ${typesPath}`);
-  console.log("\n[3/5] Generating schema module...");
-  const schemaPath = path6.resolve(rootDir, outdir, "faapi-schema.js");
-  const { entries, allTypesByFile } = extractSchemaEntries(sorted, rootDir);
-  await writeSchemaModule(entries, allTypesByFile, schemaPath);
+  console.log("\n[4/5] Generating schema module...");
+  const schemaPath = path8.resolve(rootDir, outdir, "faapi-schema.js");
+  await generateSchemaFile(sorted, rootDir, schemaPath);
   console.log(`  Written to ${schemaPath}`);
-  console.log("\n[4/5] Generating routes manifest...");
-  const routesPath = path6.resolve(rootDir, outdir, "faapi-routes.js");
-  const serialized = serializeRoutes(sorted, wsRoutes, rootDir);
+  console.log("\n[5/5] Generating routes manifest...");
+  const routesPath = path8.resolve(rootDir, outdir, "faapi-routes.js");
+  const serialized = serializeRoutes(sorted, wsRoutes, rootDir, outdir);
   await writeRoutesModule(serialized, routesPath);
   console.log(`  Written to ${routesPath}`);
-  console.log("\n[5/5] Compiling TypeScript...");
-  await compileTypeScript(rootDir, patterns, appDir, outdir);
-  console.log("  Done");
   console.log("\nfaapi build completed");
 }
-async function compileTypeScript(rootDir, patterns, appDir, outdir) {
-  const esbuild = await import("esbuild");
-  const allPatterns = [...patterns, `${appDir}/**/middlewares.ts`];
-  const files = await fg2(allPatterns, {
-    cwd: rootDir,
-    onlyFiles: true,
-    absolute: true
-  });
-  if (files.length === 0) {
-    console.log("  No TypeScript files to compile");
-    return;
-  }
-  const absOutdir = path6.resolve(rootDir, outdir);
-  await fs5.promises.mkdir(absOutdir, { recursive: true });
-  await esbuild.build({
-    entryPoints: files,
-    outdir: absOutdir,
-    outbase: rootDir,
-    bundle: false,
-    // 不 bundle，逐文件编译
-    platform: "node",
-    format: "esm",
-    sourcemap: true,
-    packages: "external",
-    // 依赖保持外部引用
-    logLevel: "info"
-  });
-}
-function extractSchemaEntries(routes, rootDir) {
-  const { sources, allTypesByFile } = collectRouteSchemaSources(routes, rootDir);
-  const entries = sources.map(({ filePath, schemaName, typeInfo }) => ({
-    filePath,
-    schemaName,
-    typeInfo
-  }));
-  return { entries, allTypesByFile };
-}
 function parseBuildArgs(argv) {
   const rootDir = process.cwd();
   let outdir = "dist";
@@ -1790,7 +2026,7 @@ var init_buildCommand = __esm({
     init_generateTypes();
     init_generateSchema();
     init_generateRoutes();
-    init_collectRouteSchemaSources();
+    init_compileRoutes();
   }
 });
 
@@ -2441,42 +2677,42 @@ var init_parseArgs = __esm({
 });
 
 // src/router/matchRoute.ts
-function matchRoute(routes, method, path12) {
+function matchRoute(routes, method, path15) {
   for (const route of routes) {
     if (route.method !== method) {
       continue;
     }
     if (!route.isDynamic) {
-      if (route.urlPath === path12) {
+      if (route.urlPath === path15) {
         return { route, params: {} };
       }
       continue;
     }
-    const params = matchDynamicPath(route.urlPath, path12, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchWsRoute(wsRoutes, path12) {
+function matchWsRoute(wsRoutes, path15) {
   for (const route of wsRoutes) {
     if (!route.isDynamic) {
-      if (route.urlPath === path12) {
+      if (route.urlPath === path15) {
         return { route, params: {} };
       }
       continue;
     }
-    const params = matchDynamicPath(route.urlPath, path12, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function matchDynamicPath(pattern, path12, paramNames, isCatchAll) {
+function matchDynamicPath(pattern, path15, paramNames, isCatchAll) {
   const patternSegments = pattern.split("/").filter(Boolean);
-  const pathSegments = path12.split("/").filter(Boolean);
+  const pathSegments = path15.split("/").filter(Boolean);
   if (isCatchAll) {
     const nonCatchAllCount = patternSegments.length - 1;
     if (pathSegments.length <= nonCatchAllCount) {
@@ -2895,14 +3131,14 @@ var init_httpErrors = __esm({
       issues;
     };
     RouteNotFoundError = class extends FaapiError {
-      constructor(path12) {
-        super("ROUTE_NOT_FOUND", `Route not found: ${path12}`, 404);
+      constructor(path15) {
+        super("ROUTE_NOT_FOUND", `Route not found: ${path15}`, 404);
         this.name = "RouteNotFoundError";
       }
     };
     MethodNotAllowedError = class extends FaapiError {
-      constructor(method, path12, allowedMethods) {
-        super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path12}`, 405);
+      constructor(method, path15, allowedMethods) {
+        super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path15}`, 405);
         this.allowedMethods = allowedMethods;
         this.name = "MethodNotAllowedError";
       }
@@ -3261,75 +3497,6 @@ var init_sendNodeResponse = __esm({
   }
 });
 
-// src/validator/schemaRegistry.ts
-var SchemaRegistry, schemaRegistry;
-var init_schemaRegistry = __esm({
-  "src/validator/schemaRegistry.ts"() {
-    "use strict";
-    SchemaRegistry = class {
-      manifest = /* @__PURE__ */ new Map();
-      /**
-       * 批量加载 manifest
-       * 覆盖已有数据
-       */
-      loadManifest(manifest) {
-        this.manifest.clear();
-        for (const [filePath, fileSchemas] of manifest) {
-          const copy = /* @__PURE__ */ new Map();
-          fileSchemas.forEach((value, key) => copy.set(key, value));
-          this.manifest.set(filePath, copy);
-        }
-      }
-      /**
-       * 查询单条 schema
-       * @returns SchemaEntry | null | undefined
-       *          - SchemaEntry：有类型声明
-       *          - null：无类型声明（跳过校验）
-       *          - undefined：manifest 不完整（抛错）
-       */
-      get(filePath, schemaName) {
-        const fileSchemas = this.manifest.get(filePath);
-        if (!fileSchemas) return void 0;
-        return fileSchemas.get(schemaName);
-      }
-      /**
-       * 设置单个文件的所有 schema
-       * 覆盖该文件的已有数据
-       */
-      set(filePath, schemas) {
-        const copy = /* @__PURE__ */ new Map();
-        schemas.forEach((value, key) => copy.set(key, value));
-        this.manifest.set(filePath, copy);
-      }
-      /**
-       * 删除单个文件（文件被删除时）
-       */
-      delete(filePath) {
-        this.manifest.delete(filePath);
-      }
-      /**
-       * 判断文件是否已注册
-       */
-      hasFile(filePath) {
-        return this.manifest.has(filePath);
-      }
-      /**
-       * 清空（测试用 / watch 全量重建前）
-       */
-      clear() {
-        this.manifest.clear();
-      }
-      /**
-       * 已注册的文件数量
-       */
-      get size() {
-        return this.manifest.size;
-      }
-    };
-    schemaRegistry = new SchemaRegistry();
-  }
-});
-
 // src/validator/coerceInput.ts
 function coerceInput(input, properties) {
   const issues = [];
@@ -3342,16 +3509,16 @@ function coerceInput(input, properties) {
   }
   return { data, issues };
 }
-function coerceValue(value, type, path12, issues) {
+function coerceValue(value, type, path15, issues) {
   switch (type.kind) {
     case "number":
       if (typeof value === "string") {
-        return coerceStringToNumber(value, path12, issues);
+        return coerceStringToNumber(value, path15, issues);
       }
       return value;
     case "boolean":
       if (typeof value === "string") {
-        return coerceStringToBoolean(value, path12, issues);
+        return coerceStringToBoolean(value, path15, issues);
       }
       return value;
     case "array":
@@ -3359,7 +3526,7 @@ function coerceValue(value, type, path12, issues) {
         return value;
       }
       if (Array.isArray(value)) {
-        return value.map((item, i) => coerceValue(item, type.element, `${path12}[${i}]`, issues));
+        return value.map((item, i) => coerceValue(item, type.element, `${path15}[${i}]`, issues));
       }
       return value;
     case "tuple": {
@@ -3368,10 +3535,10 @@ function coerceValue(value, type, path12, issues) {
       return value.map((item, i) => {
         const elem = type.elements[i];
         if (elem && !elem.rest) {
-          return coerceValue(item, elem.type, `${path12}[${i}]`, issues);
+          return coerceValue(item, elem.type, `${path15}[${i}]`, issues);
         }
         if (restElement) {
-          return coerceValue(item, restElement.type, `${path12}[${i}]`, issues);
+          return coerceValue(item, restElement.type, `${path15}[${i}]`, issues);
         }
         return item;
       });
@@ -3379,7 +3546,7 @@ function coerceValue(value, type, path12, issues) {
     case "union":
       for (const member of type.members) {
         const tempIssues = [];
-        const coerced = coerceValue(value, member, path12, tempIssues);
+        const coerced = coerceValue(value, member, path15, tempIssues);
         if (tempIssues.length === 0) {
           return coerced;
         }
@@ -3400,7 +3567,7 @@ function coerceValue(value, type, path12, issues) {
             result[prop.name] = coerceValue(
               obj[prop.name],
               prop.type,
-              `${path12}.${prop.name}`,
+              `${path15}.${prop.name}`,
               issues
             );
           }
@@ -3412,31 +3579,31 @@ function coerceValue(value, type, path12, issues) {
       return value;
   }
 }
-function coerceStringToNumber(value, path12, issues) {
+function coerceStringToNumber(value, path15, issues) {
   if (value.trim() === "") {
     issues.push({
-      path: path12,
+      path: path15,
       code: "COERCE_FAILED",
       expected: "number",
       received: "string",
-      message: `\u5B57\u6BB5 "${path12}" \u7C7B\u578B\u8F6C\u6362\u5931\u8D25\uFF1A\u65E0\u6CD5\u5C06 "${value}" \u8F6C\u4E3A number`
+      message: `\u5B57\u6BB5 "${path15}" \u7C7B\u578B\u8F6C\u6362\u5931\u8D25\uFF1A\u65E0\u6CD5\u5C06 "${value}" \u8F6C\u4E3A number`
     });
     return value;
   }
   const num = Number(value);
   if (Number.isNaN(num)) {
     issues.push({
-      path: path12,
+      path: path15,
       code: "COERCE_FAILED",
       expected: "number",
       received: "string",
-      message: `\u5B57\u6BB5 "${path12}" \u7C7B\u578B\u8F6C\u6362\u5931\u8D25\uFF1A\u65E0\u6CD5\u5C06 "${value}" \u8F6C\u4E3A number`
+      message: `\u5B57\u6BB5 "${path15}" \u7C7B\u578B\u8F6C\u6362\u5931\u8D25\uFF1A\u65E0\u6CD5\u5C06 "${value}" \u8F6C\u4E3A number`
     });
     return value;
   }
   return num;
 }
-function coerceStringToBoolean(value, path12, issues) {
+function coerceStringToBoolean(value, path15, issues) {
   if (value === "true" || value === "1") {
     return true;
   }
@@ -3444,11 +3611,11 @@ function coerceStringToBoolean(value, path12, issues) {
     return false;
   }
   issues.push({
-    path: path12,
+    path: path15,
     code: "COERCE_FAILED",
     expected: "boolean",
     received: "string",
-    message: `\u5B57\u6BB5 "${path12}" \u7C7B\u578B\u8F6C\u6362\u5931\u8D25\uFF1A\u65E0\u6CD5\u5C06 "${value}" \u8F6C\u4E3A boolean`
+    message: `\u5B57\u6BB5 "${path15}" \u7C7B\u578B\u8F6C\u6362\u5931\u8D25\uFF1A\u65E0\u6CD5\u5C06 "${value}" \u8F6C\u4E3A boolean`
   });
   return value;
 }
@@ -3588,26 +3755,26 @@ var init_cors = __esm({
 });
 
 // src/server/serveStatic.ts
-import fs6 from "fs";
-import path7 from "path";
+import fs7 from "fs";
+import path9 from "path";
 import { createReadStream } from "fs";
 import { Readable as Readable2 } from "stream";
 async function serveStatic(urlPath, staticDir) {
-  const resolved = path7.resolve(staticDir, "." + urlPath);
-  const relative3 = path7.relative(staticDir, resolved);
-  if (relative3.startsWith("..") || path7.isAbsolute(relative3)) {
+  const resolved = path9.resolve(staticDir, "." + urlPath);
+  const relative3 = path9.relative(staticDir, resolved);
+  if (relative3.startsWith("..") || path9.isAbsolute(relative3)) {
     return null;
   }
   let stat4;
   try {
-    stat4 = await fs6.promises.stat(resolved);
+    stat4 = await fs7.promises.stat(resolved);
   } catch {
     return null;
   }
   if (stat4.isDirectory()) {
-    const indexPath = path7.join(resolved, "index.html");
+    const indexPath = path9.join(resolved, "index.html");
     try {
-      const indexStat = await fs6.promises.stat(indexPath);
+      const indexStat = await fs7.promises.stat(indexPath);
       if (indexStat.isFile()) {
         return serveFile(indexPath, indexStat.size);
       }
@@ -3621,7 +3788,7 @@ async function serveStatic(urlPath, staticDir) {
   return serveFile(resolved, stat4.size);
 }
 function serveFile(filePath, size) {
-  const ext = path7.extname(filePath).toLowerCase();
+  const ext = path9.extname(filePath).toLowerCase();
   const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
   const stream = createReadStream(filePath);
   const webStream = Readable2.toWeb(stream);
@@ -3821,7 +3988,7 @@ var init_wsHandler = __esm({
 
 // src/server/handleWsUpgrade.ts
 import { WebSocketServer, WebSocket } from "ws";
-import path8 from "path";
+import path10 from "path";
 function getPathname(req) {
   const url = req.url ?? "/";
   const idx = url.indexOf("?");
@@ -3904,7 +4071,7 @@ function attachWebSocket(options) {
     const finalHandler = async () => {
       let handlers;
       try {
-        const absoluteFilePath = path8.resolve(rootDir, route.filePath);
+        const absoluteFilePath = path10.resolve(rootDir, route.filePath);
         handlers = await loadWsHandler(absoluteFilePath, ctx);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
@@ -3966,7 +4133,7 @@ import {
   createServer as createHttpServer
 } from "http";
 import { Readable as Readable3 } from "stream";
-import path9 from "path";
+import path11 from "path";
 function toWebRequest(req) {
   const forwardedProto = req.headers["x-forwarded-proto"];
   const protocol = Array.isArray(forwardedProto) ? forwardedProto[0]?.split(",")[0]?.trim() ?? "http" : forwardedProto?.split(",")[0]?.trim() ?? "http";
@@ -4010,15 +4177,15 @@ function limitStreamSize(stream, maxSize) {
     }
   });
 }
-function findAllowedMethods(routes, path12) {
+function findAllowedMethods(routes, path15) {
   const methods = /* @__PURE__ */ new Set();
   for (const route of routes) {
-    if (route.urlPath === path12) {
+    if (route.urlPath === path15) {
       methods.add(route.method);
       continue;
     }
     if (route.isDynamic) {
-      const params = matchDynamicPath(route.urlPath, path12, route.paramNames, route.isCatchAll);
+      const params = matchDynamicPath(route.urlPath, path15, route.paramNames, route.isCatchAll);
       if (params !== null) {
         methods.add(route.method);
       }
@@ -4085,7 +4252,7 @@ async function handleRequest(routes, rootDir, req, res, corsMiddleware, staticDi
     const match = matchRoute(routes, method, urlPath);
     if (!match) {
       if (staticDir) {
-        const absStaticDir = path9.resolve(rootDir, staticDir);
+        const absStaticDir = path11.resolve(rootDir, staticDir);
         const staticResponse = await serveStatic(urlPath, absStaticDir);
         if (staticResponse) {
           return mergeMeta(staticResponse, meta);
@@ -4099,7 +4266,7 @@ async function handleRequest(routes, rootDir, req, res, corsMiddleware, staticDi
     }
     ctx.params = match.params;
     const { route } = match;
-    const absoluteFilePath = path9.resolve(rootDir, route.filePath);
+    const absoluteFilePath = path11.resolve(rootDir, route.filePath);
     const routeModule = await loadRouteModule(absoluteFilePath, route.method);
     const input = await resolveInput(route.method, request);
     const inputType = getInputTypeForMethod(route.method);
@@ -4354,7 +4521,7 @@ var init_esm = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? lstat : stat;
         if (wantBigintFsStats) {
-          this._stat = (path12) => statMethod(path12, { bigint: true });
+          this._stat = (path15) => statMethod(path15, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -4379,8 +4546,8 @@ var init_esm = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path12, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path12));
+              const { path: path15, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path15));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -4420,20 +4587,20 @@ var init_esm = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path12, depth) {
+      async _exploreDir(path15, depth) {
         let files;
         try {
-          files = await readdir(path12, this._rdOptions);
+          files = await readdir(path15, this._rdOptions);
         } catch (error) {
           this._onError(error);
         }
-        return { files, depth, path: path12 };
+        return { files, depth, path: path15 };
       }
-      async _formatEntry(dirent, path12) {
+      async _formatEntry(dirent, path15) {
         let entry;
         const basename3 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = presolve(pjoin(path12, basename3));
+          const fullPath = presolve(pjoin(path15, basename3));
           entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
@@ -4494,16 +4661,16 @@ import { watchFile, unwatchFile, watch as fs_watch } from "fs";
 import { open, stat as stat2, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
 import * as sysPath from "path";
 import { type as osType } from "os";
-function createFsWatchInstance(path12, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path15, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path12);
-    emitRaw(rawEvent, evPath, { watchedPath: path12 });
-    if (evPath && path12 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path12, evPath), KEY_LISTENERS, sysPath.join(path12, evPath));
+    listener(path15);
+    emitRaw(rawEvent, evPath, { watchedPath: path15 });
+    if (evPath && path15 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path15, evPath), KEY_LISTENERS, sysPath.join(path15, evPath));
     }
   };
   try {
-    return fs_watch(path12, {
+    return fs_watch(path15, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -4848,12 +5015,12 @@ var init_handler = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path12, fullPath, options, handlers) => {
+    setFsWatchListener = (path15, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path12, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path15, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -4864,7 +5031,7 @@ var init_handler = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path12,
+          path15,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -4879,7 +5046,7 @@ var init_handler = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error.code === "EPERM") {
             try {
-              const fd = await open(path12, "r");
+              const fd = await open(path15, "r");
               await fd.close();
               broadcastErr(error);
             } catch (err) {
@@ -4910,7 +5077,7 @@ var init_handler = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path12, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path15, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -4932,7 +5099,7 @@ var init_handler = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path12, curr));
+              foreach(cont.listeners, (listener2) => listener2(path15, curr));
             }
           })
         };
@@ -4960,13 +5127,13 @@ var init_handler = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path12, listener) {
+      _watchWithNodeFs(path15, listener) {
         const opts = this.fsw.options;
-        const directory = sysPath.dirname(path12);
-        const basename3 = sysPath.basename(path12);
+        const directory = sysPath.dirname(path15);
+        const basename3 = sysPath.basename(path15);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename3);
-        const absolutePath = sysPath.resolve(path12);
+        const absolutePath = sysPath.resolve(path15);
         const options = {
           persistent: opts.persistent
         };
@@ -4976,12 +5143,12 @@ var init_handler = __esm({
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
           options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path12, absolutePath, options, {
+          closer = setFsWatchFileListener(path15, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path12, absolutePath, options, {
+          closer = setFsWatchListener(path15, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -5003,7 +5170,7 @@ var init_handler = __esm({
         let prevStats = stats;
         if (parent.has(basename3))
           return;
-        const listener = async (path12, newStats) => {
+        const listener = async (path15, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -5017,11 +5184,11 @@ var init_handler = __esm({
                 this.fsw._emit(EV.CHANGE, file, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path12);
+                this.fsw._closeFile(path15);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path12, closer2);
+                  this.fsw._addPathCloser(path15, closer2);
               } else {
                 prevStats = newStats2;
               }
@@ -5053,7 +5220,7 @@ var init_handler = __esm({
        * @param item basename of this item
        * @returns true if no more processing is needed for this entry.
        */
-      async _handleSymlink(entry, directory, path12, item) {
+      async _handleSymlink(entry, directory, path15, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -5063,7 +5230,7 @@ var init_handler = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await fsrealpath(path12);
+            linkPath = await fsrealpath(path15);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -5073,12 +5240,12 @@ var init_handler = __esm({
           if (dir.has(item)) {
             if (this.fsw._symlinkPaths.get(full) !== linkPath) {
               this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, path12, entry.stats);
+              this.fsw._emit(EV.CHANGE, path15, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path12, entry.stats);
+            this.fsw._emit(EV.ADD, path15, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -5107,9 +5274,9 @@ var init_handler = __esm({
             return;
           }
           const item = entry.path;
-          let path12 = sysPath.join(directory, item);
+          let path15 = sysPath.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path12, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path15, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -5118,8 +5285,8 @@ var init_handler = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path12 = sysPath.join(dir, sysPath.relative(dir, path12));
-            this._addToNodeFs(path12, initialAdd, wh, depth + 1);
+            path15 = sysPath.join(dir, sysPath.relative(dir, path15));
+            this._addToNodeFs(path15, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve3, reject) => {
@@ -5188,13 +5355,13 @@ var init_handler = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path12, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path15, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path12) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path15) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path12);
+        const wh = this.fsw._getWatchHelpers(path15);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -5210,8 +5377,8 @@ var init_handler = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sysPath.resolve(path12);
-            const targetPath = follow ? await fsrealpath(path12) : path12;
+            const absPath = sysPath.resolve(path15);
+            const targetPath = follow ? await fsrealpath(path15) : path15;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -5221,29 +5388,29 @@ var init_handler = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await fsrealpath(path12) : path12;
+            const targetPath = follow ? await fsrealpath(path15) : path15;
             if (this.fsw.closed)
               return;
             const parent = sysPath.dirname(wh.watchPath);
             this.fsw._getWatchedDir(parent).add(wh.watchPath);
             this.fsw._emit(EV.ADD, wh.watchPath, stats);
-            closer = await this._handleDir(parent, stats, initialAdd, depth, path12, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path15, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sysPath.resolve(path12), targetPath);
+              this.fsw._symlinkPaths.set(sysPath.resolve(path15), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path12, closer);
+            this.fsw._addPathCloser(path15, closer);
           return false;
         } catch (error) {
           if (this.fsw._handleError(error)) {
             ready();
-            return path12;
+            return path15;
           }
         }
       }
@@ -5282,26 +5449,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath2(path12) {
-  if (typeof path12 !== "string")
+function normalizePath2(path15) {
+  if (typeof path15 !== "string")
     throw new Error("string expected");
-  path12 = sysPath2.normalize(path12);
-  path12 = path12.replace(/\\/g, "/");
+  path15 = sysPath2.normalize(path15);
+  path15 = path15.replace(/\\/g, "/");
   let prepend = false;
-  if (path12.startsWith("//"))
+  if (path15.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path12.match(DOUBLE_SLASH_RE2))
-    path12 = path12.replace(DOUBLE_SLASH_RE2, "/");
+  while (path15.match(DOUBLE_SLASH_RE2))
+    path15 = path15.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path12 = "/" + path12;
-  return path12;
+    path15 = "/" + path15;
+  return path15;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path12 = normalizePath2(testString);
+  const path15 = normalizePath2(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path12, stats)) {
+    if (pattern(path15, stats)) {
       return true;
     }
   }
@@ -5362,19 +5529,19 @@ var init_esm2 = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path12) => toUnix(sysPath2.normalize(toUnix(path12)));
-    normalizeIgnored = (cwd = "") => (path12) => {
-      if (typeof path12 === "string") {
-        return normalizePathToUnix(sysPath2.isAbsolute(path12) ? path12 : sysPath2.join(cwd, path12));
+    normalizePathToUnix = (path15) => toUnix(sysPath2.normalize(toUnix(path15)));
+    normalizeIgnored = (cwd = "") => (path15) => {
+      if (typeof path15 === "string") {
+        return normalizePathToUnix(sysPath2.isAbsolute(path15) ? path15 : sysPath2.join(cwd, path15));
       } else {
-        return path12;
+        return path15;
       }
     };
-    getAbsolutePath = (path12, cwd) => {
-      if (sysPath2.isAbsolute(path12)) {
-        return path12;
+    getAbsolutePath = (path15, cwd) => {
+      if (sysPath2.isAbsolute(path15)) {
+        return path15;
       }
-      return sysPath2.join(cwd, path12);
+      return sysPath2.join(cwd, path15);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -5429,10 +5596,10 @@ var init_esm2 = __esm({
     STAT_METHOD_F = "stat";
     STAT_METHOD_L = "lstat";
     WatchHelper = class {
-      constructor(path12, follow, fsw) {
+      constructor(path15, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path12;
-        this.path = path12 = path12.replace(REPLACER_RE, "");
+        const watchPath = path15;
+        this.path = path15 = path15.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sysPath2.resolve(watchPath);
         this.dirParts = [];
@@ -5554,20 +5721,20 @@ var init_esm2 = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path12) => {
-            const absPath = getAbsolutePath(path12, cwd);
+          paths = paths.map((path15) => {
+            const absPath = getAbsolutePath(path15, cwd);
             return absPath;
           });
         }
-        paths.forEach((path12) => {
-          this._removeIgnoredPath(path12);
+        paths.forEach((path15) => {
+          this._removeIgnoredPath(path15);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path12) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path12, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path15) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path15, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -5589,17 +5756,17 @@ var init_esm2 = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path12) => {
-          if (!sysPath2.isAbsolute(path12) && !this._closers.has(path12)) {
+        paths.forEach((path15) => {
+          if (!sysPath2.isAbsolute(path15) && !this._closers.has(path15)) {
             if (cwd)
-              path12 = sysPath2.join(cwd, path12);
-            path12 = sysPath2.resolve(path12);
+              path15 = sysPath2.join(cwd, path15);
+            path15 = sysPath2.resolve(path15);
           }
-          this._closePath(path12);
-          this._addIgnoredPath(path12);
-          if (this._watched.has(path12)) {
+          this._closePath(path15);
+          this._addIgnoredPath(path15);
+          if (this._watched.has(path15)) {
             this._addIgnoredPath({
-              path: path12,
+              path: path15,
               recursive: true
             });
           }
@@ -5663,38 +5830,38 @@ var init_esm2 = __esm({
        * @param stats arguments to be passed with event
        * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
        */
-      async _emit(event, path12, stats) {
+      async _emit(event, path15, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path12 = sysPath2.normalize(path12);
+          path15 = sysPath2.normalize(path15);
         if (opts.cwd)
-          path12 = sysPath2.relative(opts.cwd, path12);
-        const args = [path12];
+          path15 = sysPath2.relative(opts.cwd, path15);
+        const args = [path15];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path12))) {
+        if (awf && (pw = this._pendingWrites.get(path15))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path12, [event, ...args]);
+            this._pendingUnlinks.set(path15, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path13) => {
+              this._pendingUnlinks.forEach((entry, path16) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path13);
+                this._pendingUnlinks.delete(path16);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path12)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path15)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path12);
+            this._pendingUnlinks.delete(path15);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -5712,16 +5879,16 @@ var init_esm2 = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path12, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path15, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path12, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path15, 50);
           if (isThrottled)
             return this;
         }
         if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path12) : path12;
+          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path15) : path15;
           let stats2;
           try {
             stats2 = await stat3(fullPath);
@@ -5752,23 +5919,23 @@ var init_esm2 = __esm({
        * @param timeout duration of time to suppress duplicate actions
        * @returns tracking object or false if action should be suppressed
        */
-      _throttle(actionType, path12, timeout) {
+      _throttle(actionType, path15, timeout) {
         if (!this._throttled.has(actionType)) {
           this._throttled.set(actionType, /* @__PURE__ */ new Map());
         }
         const action = this._throttled.get(actionType);
         if (!action)
           throw new Error("invalid throttle");
-        const actionPath = action.get(path12);
+        const actionPath = action.get(path15);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path12);
+          const item = action.get(path15);
           const count = item ? item.count : 0;
-          action.delete(path12);
+          action.delete(path15);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -5776,7 +5943,7 @@ var init_esm2 = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path12, thr);
+        action.set(path15, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -5790,44 +5957,44 @@ var init_esm2 = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path12, threshold, event, awfEmit) {
+      _awaitWriteFinish(path15, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path12;
-        if (this.options.cwd && !sysPath2.isAbsolute(path12)) {
-          fullPath = sysPath2.join(this.options.cwd, path12);
+        let fullPath = path15;
+        if (this.options.cwd && !sysPath2.isAbsolute(path15)) {
+          fullPath = sysPath2.join(this.options.cwd, path15);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           statcb(fullPath, (err, curStat) => {
-            if (err || !writes.has(path12)) {
+            if (err || !writes.has(path15)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path12).lastChange = now2;
+              writes.get(path15).lastChange = now2;
             }
-            const pw = writes.get(path12);
+            const pw = writes.get(path15);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path12);
+              writes.delete(path15);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path12)) {
-          writes.set(path12, {
+        if (!writes.has(path15)) {
+          writes.set(path15, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path12);
+              writes.delete(path15);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -5838,8 +6005,8 @@ var init_esm2 = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path12, stats) {
-        if (this.options.atomic && DOT_RE.test(path12))
+      _isIgnored(path15, stats) {
+        if (this.options.atomic && DOT_RE.test(path15))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -5849,17 +6016,17 @@ var init_esm2 = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path12, stats);
+        return this._userIgnored(path15, stats);
       }
-      _isntIgnored(path12, stat4) {
-        return !this._isIgnored(path12, stat4);
+      _isntIgnored(path15, stat4) {
+        return !this._isIgnored(path15, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path12) {
-        return new WatchHelper(path12, this.options.followSymlinks, this);
+      _getWatchHelpers(path15) {
+        return new WatchHelper(path15, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -5891,63 +6058,63 @@ var init_esm2 = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path12 = sysPath2.join(directory, item);
-        const fullPath = sysPath2.resolve(path12);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path12) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path12, 100))
+        const path15 = sysPath2.join(directory, item);
+        const fullPath = sysPath2.resolve(path15);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path15) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path15, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path12);
+        const wp = this._getWatchedDir(path15);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path12, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path15, nested));
         const parent = this._getWatchedDir(directory);
         const wasTracked = parent.has(item);
         parent.remove(item);
         if (this._symlinkPaths.has(fullPath)) {
           this._symlinkPaths.delete(fullPath);
         }
-        let relPath = path12;
+        let relPath = path15;
         if (this.options.cwd)
-          relPath = sysPath2.relative(this.options.cwd, path12);
+          relPath = sysPath2.relative(this.options.cwd, path15);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path12);
+        this._watched.delete(path15);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path12))
-          this._emit(eventName, path12);
-        this._closePath(path12);
+        if (wasTracked && !this._isIgnored(path15))
+          this._emit(eventName, path15);
+        this._closePath(path15);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path12) {
-        this._closeFile(path12);
-        const dir = sysPath2.dirname(path12);
-        this._getWatchedDir(dir).remove(sysPath2.basename(path12));
+      _closePath(path15) {
+        this._closeFile(path15);
+        const dir = sysPath2.dirname(path15);
+        this._getWatchedDir(dir).remove(sysPath2.basename(path15));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path12) {
-        const closers = this._closers.get(path12);
+      _closeFile(path15) {
+        const closers = this._closers.get(path15);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path12);
+        this._closers.delete(path15);
       }
-      _addPathCloser(path12, closer) {
+      _addPathCloser(path15, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path12);
+        let list = this._closers.get(path15);
         if (!list) {
           list = [];
-          this._closers.set(path12, list);
+          this._closers.set(path15, list);
         }
         list.push(closer);
       }
@@ -5974,23 +6141,36 @@ var init_esm2 = __esm({
 });
 
 // src/cli/watcher.ts
+import path12 from "path";
 function startWatcher(options) {
   const { rootDir, patterns, appDir } = options;
   let rebuildTimer = null;
+  let pendingFiles = /* @__PURE__ */ new Set();
   async function rebuildRoutes() {
     try {
       const timestamp = Date.now();
       globalThis.__FAAPI_LOAD_TS__ = timestamp;
       invalidateMiddlewareCache();
       invalidateProgramCache();
-      const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, appDir);
+      const filesToCompile = Array.from(pendingFiles);
+      pendingFiles = /* @__PURE__ */ new Set();
+      if (filesToCompile.length > 0) {
+        await compileRoutes({
+          rootDir,
+          appDir,
+          outDir: DEV_OUT_DIR,
+          files: filesToCompile
+        });
+      }
+      const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, appDir, DEV_OUT_DIR);
       const sorted = sortRoutes(routes);
-      const manifest = extractSchemasForRoutes(sorted, rootDir);
-      schemaRegistry.loadManifest(manifest);
+      const schemaPath = path12.resolve(rootDir, DEV_OUT_DIR, "faapi-schema.js");
+      await generateSchemaFile(sorted, rootDir, schemaPath);
+      await loadSchemaToRegistry(schemaPath, rootDir, DEV_OUT_DIR, false);
       updateServerRoutes(sorted, wsRoutes);
-      const wsCount = wsRoutes.length;
+      const recompiledCount = filesToCompile.length;
       console.log(
-        `- Routes rebuilt: ${sorted.length} route(s), ${wsCount} WS route(s), ${manifest.size} file(s)`
+        `- Routes rebuilt: ${sorted.length} route(s), ${wsRoutes.length} WS route(s)${recompiledCount > 0 ? `, ${recompiledCount} file(s) recompiled` : ""}`
       );
     } catch (err) {
       console.error("- Error rebuilding routes:", err instanceof Error ? err.message : String(err));
@@ -6003,21 +6183,45 @@ function startWatcher(options) {
       void rebuildRoutes();
     }, 100);
   }
-  const watchPatterns = [...patterns, `${appDir}/**/middlewares.ts`];
-  const watcher = esm_default.watch(watchPatterns, {
+  const watcher = esm_default.watch(appDir, {
     cwd: rootDir,
     ignoreInitial: true,
-    ignored: ["**/node_modules/**", "**/.faapi/**", "**/dist/**"]
+    ignored: (filePath, stats) => {
+      if (filePath.includes("node_modules") || filePath.includes(".faapi") || filePath.includes("dist") || filePath.includes(".git")) {
+        return true;
+      }
+      if (!stats) return false;
+      if (stats.isDirectory()) return false;
+      return !filePath.endsWith(".ts");
+    }
+  });
+  watcher.on("add", (file) => {
+    pendingFiles.add(path12.resolve(rootDir, file));
+    scheduleRebuild();
+  });
+  watcher.on("change", (file) => {
+    pendingFiles.add(path12.resolve(rootDir, file));
+    scheduleRebuild();
+  });
+  watcher.on("unlink", () => {
+    scheduleRebuild();
+  });
+  watcher.on("error", (err) => {
+    console.error("- Watcher error:", err instanceof Error ? err.message : String(err));
+  });
+  watcher.on("ready", () => {
+    const watched = watcher.getWatched();
+    const dirCount = Object.keys(watched).length;
+    const fileCount = Object.values(watched).reduce((sum, files) => sum + files.length, 0);
+    console.log(`- Watcher ready: ${dirCount} dir(s), ${fileCount} file(s) watched`);
   });
-  watcher.on("add", () => scheduleRebuild());
-  watcher.on("change", () => scheduleRebuild());
-  watcher.on("unlink", () => scheduleRebuild());
   console.log("- Watch mode enabled");
 }
 function updateServerRoutes(routes, wsRoutes) {
   globalThis.__FAAPI_ROUTES__ = routes;
   globalThis.__FAAPI_WS_ROUTES__ = wsRoutes;
 }
+var DEV_OUT_DIR;
 var init_watcher = __esm({
   "src/cli/watcher.ts"() {
     "use strict";
@@ -6026,14 +6230,15 @@ var init_watcher = __esm({
     init_sortRoutes();
     init_loadMiddlewares();
     init_createProgram();
-    init_schemaRegistry();
     init_generateSchema();
+    init_compileRoutes();
+    DEV_OUT_DIR = ".faapi/dev";
   }
 });
 
 // src/config/loadConfig.ts
-import path10 from "path";
-import fs7 from "fs";
+import path13 from "path";
+import fs8 from "fs";
 import { pathToFileURL as pathToFileURL2 } from "url";
 function getEnv() {
   return process.env.FAAPI_ENV || process.env.NODE_ENV || "development";
@@ -6059,7 +6264,7 @@ function deepMerge(base, override) {
   return result;
 }
 async function loadConfigFile(filePath) {
-  if (!fs7.existsSync(filePath)) {
+  if (!fs8.existsSync(filePath)) {
     return null;
   }
   try {
@@ -6075,15 +6280,15 @@ async function loadConfigFile(filePath) {
 }
 async function loadConfig(rootDir, configPath) {
   if (configPath) {
-    const resolvedPath = path10.resolve(rootDir, configPath);
-    if (!fs7.existsSync(resolvedPath)) {
+    const resolvedPath = path13.resolve(rootDir, configPath);
+    if (!fs8.existsSync(resolvedPath)) {
       throw new Error(`Config file not found: ${configPath}`);
     }
     return loadConfigFile(resolvedPath);
   }
   let baseConfig = null;
   for (const fileName of BASE_CONFIG_FILES) {
-    const filePath = path10.join(rootDir, fileName);
+    const filePath = path13.join(rootDir, fileName);
     baseConfig = await loadConfigFile(filePath);
     if (baseConfig) break;
   }
@@ -6093,7 +6298,7 @@ async function loadConfig(rootDir, configPath) {
   const env = getEnv();
   const envFiles = [`faapi.config.${env}.ts`, `faapi.config.${env}.js`];
   for (const envFile of envFiles) {
-    const envConfig = await loadConfigFile(path10.join(rootDir, envFile));
+    const envConfig = await loadConfigFile(path13.join(rootDir, envFile));
     if (envConfig) {
       baseConfig = deepMerge(baseConfig, envConfig);
       break;
@@ -6178,17 +6383,17 @@ var startCommand_exports = {};
 __export(startCommand_exports, {
   startCommand: () => startCommand
 });
-import fs8 from "fs";
-import path11 from "path";
-import { pathToFileURL as pathToFileURL3 } from "url";
+import fs9 from "fs";
+import path14 from "path";
 async function startCommand(argv) {
   const args = parseArgs(argv);
   const rootDir = process.cwd();
   const isProd = args.mode === "start";
+  const prodDir = isProd ? PROD_OUT_DIR : DEV_OUT_DIR2;
   if (isProd) {
-    const routesPath = path11.resolve(rootDir, "dist", "faapi-routes.js");
-    const schemaPath = path11.resolve(rootDir, "dist", "faapi-schema.js");
-    if (!fs8.existsSync(routesPath) || !fs8.existsSync(schemaPath)) {
+    const routesPath = path14.resolve(rootDir, PROD_OUT_DIR, "faapi-routes.js");
+    const schemaPath2 = path14.resolve(rootDir, PROD_OUT_DIR, "faapi-schema.js");
+    if (!fs9.existsSync(routesPath) || !fs9.existsSync(schemaPath2)) {
       console.error(
         "[faapi] dist/faapi-routes.js \u6216 dist/faapi-schema.js \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C `faapi build` \u6784\u5EFA\u751F\u4EA7\u4EA7\u7269\u3002"
       );
@@ -6210,15 +6415,16 @@ async function startCommand(argv) {
   let routes;
   let wsRoutes;
   if (isProd) {
-    const routesPath = path11.resolve(rootDir, "dist", "faapi-routes.js");
-    const serialized = await import(pathToFileURL3(routesPath).href);
+    const routesPath = path14.resolve(rootDir, PROD_OUT_DIR, "faapi-routes.js");
+    const serialized = await importWithCacheBust(routesPath);
     const hydrated = await hydrateRoutes(serialized);
     routes = hydrated.routes;
     wsRoutes = hydrated.wsRoutes;
     console.log(`- Routes loaded: ${routes.length} routes, ${wsRoutes.length} WS routes`);
   } else {
-    const { patterns, appDir } = { patterns: args.patterns, appDir: args.appDir };
-    const scanned = await scanRoutes(rootDir, patterns, appDir);
+    console.log("- Compiling TypeScript...");
+    await compileRoutes({ rootDir, appDir: args.appDir, outDir: DEV_OUT_DIR2 });
+    const scanned = await scanRoutes(rootDir, args.patterns, args.appDir, DEV_OUT_DIR2);
     routes = scanned.routes;
     wsRoutes = scanned.wsRoutes;
     console.log(`- Routes scanned: ${routes.length} routes, ${wsRoutes.length} WS routes`);
@@ -6233,19 +6439,14 @@ async function startCommand(argv) {
       }
     }
   }
-  if (isProd) {
-    const schemaPath = path11.resolve(rootDir, "dist", "faapi-schema.js");
-    const manifest = await readManifestFile(schemaPath);
-    const remapped = remapManifestKeys(manifest, rootDir);
-    schemaRegistry.loadManifest(remapped);
-    console.log(`- Schema loaded: ${schemaPath}`);
-  } else {
-    const manifest = extractSchemasForRoutes(sorted, rootDir);
-    schemaRegistry.loadManifest(manifest);
-    console.log(`- Schema extracted: ${manifest.size} file(s)`);
+  const schemaPath = path14.resolve(rootDir, prodDir, "faapi-schema.js");
+  if (!isProd) {
+    await generateSchemaFile(sorted, rootDir, schemaPath);
   }
+  await loadSchemaToRegistry(schemaPath, rootDir, prodDir, isProd);
+  console.log(`- Schema loaded: ${schemaPath}`);
   if (!isProd && args.types) {
-    const typesPath = path11.resolve(rootDir, args.types);
+    const typesPath = path14.resolve(rootDir, args.types);
     await generateTypes(sorted, rootDir, typesPath);
     console.log(`- Types generated: ${typesPath}`);
   }
@@ -6309,23 +6510,7 @@ async function startCommand(argv) {
 function isFaapiConfigKey(key) {
   return FAAPI_CONFIG_KEYS.has(key);
 }
-function remapManifestKeys(manifest, rootDir) {
-  const remapped = /* @__PURE__ */ new Map();
-  const rootPrefix = rootDir + path11.sep;
-  for (const [filePath, fileSchemas] of manifest) {
-    let rel = filePath;
-    if (filePath.startsWith(rootPrefix)) {
-      rel = filePath.slice(rootPrefix.length);
-    } else if (filePath.startsWith(rootDir)) {
-      rel = filePath.slice(rootDir.length).replace(/^[/\\]/, "");
-    }
-    const prodRel = `dist/${rel.replace(/\.ts$/, ".js")}`;
-    const prodAbs = path11.resolve(rootDir, prodRel);
-    remapped.set(prodAbs, fileSchemas);
-  }
-  return remapped;
-}
-var FAAPI_CONFIG_KEYS;
+var DEV_OUT_DIR2, PROD_OUT_DIR, FAAPI_CONFIG_KEYS;
 var init_startCommand = __esm({
   "src/cli/startCommand.ts"() {
     "use strict";
@@ -6337,10 +6522,13 @@ var init_startCommand = __esm({
     init_generateTypes();
     init_watcher();
     init_loadConfig();
-    init_schemaRegistry();
     init_generateSchema();
     init_generateRoutes();
+    init_compileRoutes();
     init_loadPlugins();
+    init_importWithCacheBust();
+    DEV_OUT_DIR2 = ".faapi/dev";
+    PROD_OUT_DIR = "dist";
     FAAPI_CONFIG_KEYS = /* @__PURE__ */ new Set([
       "port",
       "staticDir",
@@ -6360,25 +6548,32 @@ var init_startCommand = __esm({
 function isTsxPreloaded() {
   return process.execArgv.some((arg) => arg.includes("tsx")) || (process.env.NODE_OPTIONS ?? "").includes("tsx");
 }
+async function ensureTsx() {
+  if (isTsxPreloaded()) return true;
+  try {
+    const { register } = await import("tsx/esm/api");
+    register();
+    return true;
+  } catch {
+    console.warn(
+      "[faapi] tsx \u672A\u5B89\u88C5\uFF0C\u65E0\u6CD5\u52A0\u8F7D faapi.config.ts\u3002\u8BF7\u5B89\u88C5 tsx \u6216\u4F7F\u7528 faapi.config.js\u3002"
+    );
+    return false;
+  }
+}
 async function main() {
   const argv = process.argv.slice(2);
   const firstArg = argv.find((a) => !a.startsWith("-"));
+  const isBuildMode = firstArg === "build";
+  if (!isBuildMode) {
+    await ensureTsx();
+  }
   if (firstArg === "build") {
     const { parseBuildArgs: parseBuildArgs2, buildCommand: buildCommand2 } = await Promise.resolve().then(() => (init_buildCommand(), buildCommand_exports));
     const options = parseBuildArgs2(argv.filter((a) => a !== "build"));
     await buildCommand2(options);
     return;
   }
-  const isStartMode = firstArg === "start";
-  if (!isStartMode && !isTsxPreloaded()) {
-    try {
-      const { register } = await import("tsx/esm/api");
-      register();
-    } catch (err) {
-      console.error("[faapi] tsx \u52A0\u8F7D\u5931\u8D25\uFF0C\u8BF7\u786E\u8BA4\u5DF2\u5B89\u88C5 tsx\uFF1A", err);
-      process.exit(1);
-    }
-  }
   const { startCommand: startCommand2 } = await Promise.resolve().then(() => (init_startCommand(), startCommand_exports));
   await startCommand2(argv);
 }