@faapi/faapi 6.24.0 → 6.26.0

package/dist/testing.js

@@ -312,14 +312,14 @@ var ValidationError = class extends FaapiError {
   issues;
 };
 var RouteNotFoundError = class extends FaapiError {
-  constructor(path17) {
-    super("ROUTE_NOT_FOUND", `Route not found: ${path17}`, 404);
+  constructor(path18) {
+    super("ROUTE_NOT_FOUND", `Route not found: ${path18}`, 404);
     this.name = "RouteNotFoundError";
   }
 };
 var MethodNotAllowedError = class extends FaapiError {
-  constructor(method, path17, allowedMethods) {
-    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path17}`, 405);
+  constructor(method, path18, allowedMethods) {
+    super("METHOD_NOT_ALLOWED", `Method ${method} not allowed for ${path18}`, 405);
     this.allowedMethods = allowedMethods;
     this.name = "MethodNotAllowedError";
   }
@@ -554,6 +554,50 @@ function queryToObject(params) {
   return result;
 }
 
+// src/utils/readResource.ts
+import path2 from "path";
+import fs2 from "fs/promises";
+
+// src/utils/prodPaths.ts
+import path from "path";
+import fs from "fs";
+var APP_DIR = "src";
+function toProdFilePath(filePath, dist) {
+  let rel = filePath.replace(/\\/g, "/");
+  if (rel.startsWith("src/")) {
+    rel = rel.slice(4);
+  }
+  const jsPath = rel.replace(/\.ts$/, ".js");
+  return jsPath.startsWith(`${dist}/`) ? jsPath : `${dist}/${jsPath}`;
+}
+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 toRealPath(p) {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function isInsideDir(filePath, dir) {
+  const rel = path.relative(dir, filePath);
+  return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+
+// src/utils/readResource.ts
+var ACTIVE_RESOURCES_DIR_KEY = /* @__PURE__ */ Symbol.for("faapi.resources.dir");
+function setActiveResourcesDir(dir) {
+  if (dir === null) {
+    delete globalThis[ACTIVE_RESOURCES_DIR_KEY];
+  } else {
+    globalThis[ACTIVE_RESOURCES_DIR_KEY] = dir;
+  }
+}
+
 // src/runtime/createContext.ts
 function resolveRequestId(request) {
   const header = request.headers.get("x-request-id");
@@ -731,7 +775,7 @@ function createContextFromUrl(request, url, params, config = {}, ip = "", regist
 function createTestContext(options) {
   const {
     method = "GET",
-    path: path17,
+    path: path18,
     query,
     headers,
     params = {},
@@ -740,7 +784,7 @@ function createTestContext(options) {
     registries,
     resourcesDir
   } = options;
-  const url = new URL(`http://localhost${path17}`);
+  const url = new URL(`http://localhost${path18}`);
   if (query) {
     for (const [key, value] of Object.entries(query)) {
       if (Array.isArray(value)) {
@@ -756,6 +800,9 @@ function createTestContext(options) {
     method,
     headers
   });
+  if (resourcesDir) {
+    setActiveResourcesDir(resourcesDir);
+  }
   return createContext(request, params, config, ip, registries, resourcesDir);
 }
 
@@ -1339,23 +1386,23 @@ async function invokeHandler(handler, ctx, body, middlewares, injectors) {
 }
 
 // src/testServer.ts
-import path16 from "path";
+import path17 from "path";
 import os from "os";
-import fs13 from "fs/promises";
+import fs14 from "fs/promises";
 
 // src/router/scanRoutes.ts
 import fg from "fast-glob";
-import path2 from "path";
-import fs3 from "fs";
+import path3 from "path";
+import fs4 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(path17) {
-  if (!path17) return "";
-  let result = path17.replace(/\\/g, "/");
+function normalizePath(path18) {
+  if (!path18) return "";
+  let result = path18.replace(/\\/g, "/");
   result = result.replace(/\/+/g, "/");
   result = result.replace(/\/+$/, "");
   if (result && !result.startsWith("/")) {
@@ -1402,7 +1449,7 @@ function filePathToUrlPath(filePath) {
 }
 
 // src/utils/importWithCacheBust.ts
-import fs from "fs";
+import fs3 from "fs";
 import { pathToFileURL } from "url";
 var loadTs;
 function getVitestImportActual() {
@@ -1418,7 +1465,7 @@ async function importWithCacheBust(filePath, bustViteCache = false) {
     if (bustViteCache) {
       let mtimeMs = 0;
       try {
-        mtimeMs = fs.statSync(filePath).mtimeMs;
+        mtimeMs = fs3.statSync(filePath).mtimeMs;
       } catch {
       }
       const cached = bustCache.get(filePath);
@@ -1515,36 +1562,6 @@ async function loadMergedMiddlewares(middlewarePaths) {
   return { middlewares: mergedMiddlewares, injectors: mergedInjectors };
 }
 
-// src/utils/prodPaths.ts
-import path from "path";
-import fs2 from "fs";
-var APP_DIR = "src";
-function toProdFilePath(filePath, dist) {
-  let rel = filePath.replace(/\\/g, "/");
-  if (rel.startsWith("src/")) {
-    rel = rel.slice(4);
-  }
-  const jsPath = rel.replace(/\.ts$/, ".js");
-  return jsPath.startsWith(`${dist}/`) ? jsPath : `${dist}/${jsPath}`;
-}
-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 toRealPath(p) {
-  try {
-    return fs2.realpathSync(p);
-  } catch {
-    return p;
-  }
-}
-function isInsideDir(filePath, dir) {
-  const rel = path.relative(dir, filePath);
-  return rel !== "" && !rel.startsWith("..") && !path.isAbsolute(rel);
-}
-
 // src/router/scanRoutes.ts
 var HTTP_OR_WS_EXPORT_RE = new RegExp(
   String.raw`export\s+(?:async\s+)?(?:function\s+|const\s+)(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|WS)\b`,
@@ -1560,34 +1577,34 @@ function extractExportsFromSource(source) {
   return names;
 }
 function collectMiddlewarePaths(routeFilePath, rootDir, dist) {
-  const routeDir = path2.dirname(routeFilePath);
-  const resolvedRoot = path2.resolve(rootDir);
+  const routeDir = path3.dirname(routeFilePath);
+  const resolvedRoot = path3.resolve(rootDir);
   const paths = [];
-  let currentDir = path2.resolve(rootDir, routeDir);
+  let currentDir = path3.resolve(rootDir, routeDir);
   while (true) {
     if (dist) {
-      const mwTsPath = path2.join(currentDir, "middlewares.ts");
-      const mwJsPath = path2.join(currentDir, "middlewares.js");
-      const absTsPath = path2.resolve(rootDir, mwTsPath);
-      const absJsPath = path2.resolve(rootDir, mwJsPath);
-      const absMwPath = fs3.existsSync(absTsPath) ? absTsPath : fs3.existsSync(absJsPath) ? absJsPath : null;
+      const mwTsPath = path3.join(currentDir, "middlewares.ts");
+      const mwJsPath = path3.join(currentDir, "middlewares.js");
+      const absTsPath = path3.resolve(rootDir, mwTsPath);
+      const absJsPath = path3.resolve(rootDir, mwJsPath);
+      const absMwPath = fs4.existsSync(absTsPath) ? absTsPath : fs4.existsSync(absJsPath) ? absJsPath : null;
       if (absMwPath) {
-        const relMwPath = path2.relative(rootDir, absMwPath);
-        const prodAbsPath = path2.resolve(rootDir, toProdFilePath(relMwPath, dist));
+        const relMwPath = path3.relative(rootDir, absMwPath);
+        const prodAbsPath = path3.resolve(rootDir, toProdFilePath(relMwPath, dist));
         paths.push(prodAbsPath);
       }
     } else {
       for (const ext of [".ts", ".js"]) {
-        const mwPath = path2.join(currentDir, `middlewares${ext}`);
-        const absMwPath = path2.resolve(rootDir, mwPath);
-        if (fs3.existsSync(absMwPath)) {
+        const mwPath = path3.join(currentDir, `middlewares${ext}`);
+        const absMwPath = path3.resolve(rootDir, mwPath);
+        if (fs4.existsSync(absMwPath)) {
           paths.push(absMwPath);
           break;
         }
       }
     }
     if (currentDir === resolvedRoot) break;
-    const parentDir = path2.dirname(currentDir);
+    const parentDir = path3.dirname(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
@@ -1606,7 +1623,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 = path2.resolve(rootDir, normalizedFile);
+      const absPath = path3.resolve(rootDir, normalizedFile);
       const urlPath = filePathToUrlPath(normalizedFile);
       const paramNames = extractParamNames(urlPath);
       const isDynamic = paramNames.length > 0;
@@ -1619,7 +1636,7 @@ async function scanRoutes(rootDir, patterns, dist) {
         const mwPaths = collectMiddlewarePaths(normalizedFile, rootDir);
         middlewareBundle = await loadMergedMiddlewares(mwPaths);
       }
-      const source = await fs3.promises.readFile(absPath, "utf8").catch(() => "");
+      const source = await fs4.promises.readFile(absPath, "utf8").catch(() => "");
       const exportNames = extractExportsFromSource(source);
       const methods = HTTP_METHODS.filter((m) => exportNames.has(m));
       for (const method of methods) {
@@ -1672,24 +1689,24 @@ function sortRoutes(routes) {
 }
 
 // src/cli/generateSchemaFiles.ts
-import path7 from "path";
+import path8 from "path";
 
 // src/ast/createProgram.ts
 import ts2 from "typescript";
-import fs4 from "fs";
-import path3 from "path";
+import fs5 from "fs";
+import path4 from "path";
 var programCache = /* @__PURE__ */ new Map();
 var tsConfigCache = /* @__PURE__ */ new Map();
 function findTsConfig(filePath) {
-  let dir = path3.dirname(filePath);
-  const root = path3.parse(dir).root;
+  let dir = path4.dirname(filePath);
+  const root = path4.parse(dir).root;
   while (true) {
-    const candidate = path3.join(dir, "tsconfig.json");
-    if (fs4.existsSync(candidate)) {
+    const candidate = path4.join(dir, "tsconfig.json");
+    if (fs5.existsSync(candidate)) {
       return candidate;
     }
     if (dir === root) return null;
-    const parent = path3.dirname(dir);
+    const parent = path4.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -1699,13 +1716,13 @@ function parseTsConfig(tsconfigPath) {
   if (cached) return cached;
   const result = { fileNames: [] };
   try {
-    const configFile = ts2.readConfigFile(tsconfigPath, (p) => fs4.readFileSync(p, "utf-8"));
+    const configFile = ts2.readConfigFile(tsconfigPath, (p) => fs5.readFileSync(p, "utf-8"));
     if (configFile.error) {
       tsConfigCache.set(tsconfigPath, result);
       return result;
     }
     const config = configFile.config ?? {};
-    const basePath = path3.dirname(tsconfigPath);
+    const basePath = path4.dirname(tsconfigPath);
     const parsed = ts2.parseJsonConfigFileContent(
       config,
       ts2.sys,
@@ -2705,7 +2722,7 @@ function extractSchema(typeNode, sourceFile) {
 }
 
 // src/cli/collectRouteSchemaSources.ts
-import path4 from "path";
+import path5 from "path";
 import ts6 from "typescript";
 function findExportedTypeName(sourceFile, name) {
   for (const statement of sourceFile.statements) {
@@ -2721,7 +2738,7 @@ function findExportedTypeName(sourceFile, name) {
 function collectRouteSchemaSources(routes, rootDir, wsRoutes) {
   const methodsByFile = /* @__PURE__ */ new Map();
   for (const route of routes) {
-    const filePath = rootDir ? path4.resolve(rootDir, route.filePath) : route.filePath;
+    const filePath = rootDir ? path5.resolve(rootDir, route.filePath) : route.filePath;
     let entry = methodsByFile.get(filePath);
     if (!entry) {
       entry = { urlPath: route.urlPath, methods: /* @__PURE__ */ new Set() };
@@ -2732,7 +2749,7 @@ function collectRouteSchemaSources(routes, rootDir, wsRoutes) {
   const wsFiles = [];
   for (const wsRoute of wsRoutes ?? []) {
     wsFiles.push({
-      filePath: rootDir ? path4.resolve(rootDir, wsRoute.filePath) : wsRoute.filePath,
+      filePath: rootDir ? path5.resolve(rootDir, wsRoute.filePath) : wsRoute.filePath,
       urlPath: wsRoute.urlPath
     });
   }
@@ -3127,17 +3144,17 @@ function generateZodSchemaSourceParts(typeInfo, resolveType, exportName, coerce
 }
 
 // src/cli/generateZodArtifacts.ts
-import path6 from "path";
+import path7 from "path";
 import { existsSync } from "fs";
 
 // src/utils/atomicWrite.ts
-import path5 from "path";
-import fs5 from "fs";
+import path6 from "path";
+import fs6 from "fs";
 async function atomicWriteFile(outputPath, content) {
-  await fs5.promises.mkdir(path5.dirname(outputPath), { recursive: true });
+  await fs6.promises.mkdir(path6.dirname(outputPath), { recursive: true });
   const tmp = `${outputPath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-  await fs5.promises.writeFile(tmp, content, "utf-8");
-  await fs5.promises.rename(tmp, outputPath);
+  await fs6.promises.writeFile(tmp, content, "utf-8");
+  await fs6.promises.rename(tmp, outputPath);
 }
 
 // src/cli/generateZodArtifacts.ts
@@ -3155,7 +3172,7 @@ async function generateZodArtifacts(sources, options) {
   }
   const fileEntries = [];
   for (const [filePath, fileSources] of sourcesByFile) {
-    const relFile = path6.relative(rootDir, filePath).replace(/\\/g, "/");
+    const relFile = path7.relative(rootDir, filePath).replace(/\\/g, "/");
     const outputPath = getSchemaOutputPath(relFile, dist, rootDir);
     const resolver = resolversByFile.get(filePath);
     let relForDir = relFile;
@@ -3173,7 +3190,7 @@ async function generateZodArtifacts(sources, options) {
   }
   const allSourceCode = fileEntries.map((e) => e.source).join("\n");
   if (usesCoerceHelpers(allSourceCode)) {
-    const helpersPath = path6.resolve(rootDir, dist, HELPERS_FILENAME);
+    const helpersPath = path7.resolve(rootDir, dist, HELPERS_FILENAME);
     if (!existsSync(helpersPath)) {
       await atomicWriteFile(helpersPath, generateHelpersFileSource());
     }
@@ -3191,7 +3208,7 @@ function getSchemaOutputPath(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 getRuntimeSchemaPath(filePath, dist, rootDir) {
   let rel = filePath.replace(/\\/g, "/");
@@ -3202,7 +3219,7 @@ function getRuntimeSchemaPath(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 getHelpersImportPath(relDir) {
   if (!relDir) return `./${HELPERS_FILENAME}`;
@@ -3259,18 +3276,18 @@ async function generateSchemaFiles(routes, rootDir, dist, wsRoutes) {
 }
 
 // src/cli/compileOnDemand.ts
-import path12 from "path";
-import fs10 from "fs";
+import path13 from "path";
+import fs11 from "fs";
 
 // src/cli/compileSourceFiles.ts
-import path10 from "path";
-import fs8 from "fs";
+import path11 from "path";
+import fs9 from "fs";
 import fg2 from "fast-glob";
 
 // src/cli/aliasPlugin.ts
 import ts8 from "typescript";
-import path9 from "path";
-import fs7 from "fs";
+import path10 from "path";
+import fs8 from "fs";
 
 // src/utils/resolveAlias.ts
 function resolveAlias(specifier, config) {
@@ -3297,15 +3314,15 @@ function resolveAlias(specifier, config) {
 
 // src/utils/readTsconfig.ts
 import ts7 from "typescript";
-import path8 from "path";
-import fs6 from "fs";
+import path9 from "path";
+import fs7 from "fs";
 var tsconfigCache = /* @__PURE__ */ new Map();
 function readTsconfig(rootDir) {
-  const tsconfigPath = path8.resolve(rootDir, "tsconfig.json");
-  if (!fs6.existsSync(tsconfigPath)) return null;
+  const tsconfigPath = path9.resolve(rootDir, "tsconfig.json");
+  if (!fs7.existsSync(tsconfigPath)) return null;
   let mtimeMs;
   try {
-    mtimeMs = fs6.statSync(tsconfigPath).mtimeMs;
+    mtimeMs = fs7.statSync(tsconfigPath).mtimeMs;
   } catch {
     return null;
   }
@@ -3321,7 +3338,7 @@ function readTsconfig(rootDir) {
   const config = rawPaths ? (() => {
     const paths = {};
     for (const [pattern, targets] of Object.entries(rawPaths)) {
-      paths[pattern] = targets.map((t) => path8.resolve(baseUrl, t));
+      paths[pattern] = targets.map((t) => path9.resolve(baseUrl, t));
     }
     return { baseUrl, paths };
   })() : null;
@@ -3331,26 +3348,26 @@ function readTsconfig(rootDir) {
 
 // src/cli/aliasPlugin.ts
 function toProdImportPath(sourceFile, importer) {
-  const importerDir = path9.dirname(importer);
-  let rel = path9.relative(importerDir, sourceFile);
-  rel = rel.split(path9.sep).join("/");
+  const importerDir = path10.dirname(importer);
+  let rel = path10.relative(importerDir, sourceFile);
+  rel = rel.split(path10.sep).join("/");
   if (!rel.startsWith(".")) rel = "./" + rel;
   return toProdExtension(rel);
 }
 function toStrippedProdImportPath(sourceFile, rootDir) {
-  const appDirAbs = toRealPath(path9.resolve(rootDir, APP_DIR));
+  const appDirAbs = toRealPath(path10.resolve(rootDir, APP_DIR));
   const sourceReal = toRealPath(sourceFile);
-  let rel = path9.relative(appDirAbs, sourceReal);
-  rel = rel.split(path9.sep).join("/");
+  let rel = path10.relative(appDirAbs, sourceReal);
+  rel = rel.split(path10.sep).join("/");
   if (!rel.startsWith(".")) rel = "./" + rel;
   return toProdExtension(rel);
 }
 function toProdImportFromImporter(importer, rootDir, relFromDist) {
-  const importerRel = path9.relative(toRealPath(path9.resolve(rootDir)), toRealPath(importer)).split(path9.sep).join("/");
-  const importerProdDir = path9.posix.dirname(toProdExtension(importerRel));
+  const importerRel = path10.relative(toRealPath(path10.resolve(rootDir)), toRealPath(importer)).split(path10.sep).join("/");
+  const importerProdDir = path10.posix.dirname(toProdExtension(importerRel));
   if (importerProdDir === ".") return relFromDist;
   const target = relFromDist.replace(/^\.\//, "");
-  let rel = path9.posix.relative(importerProdDir, target);
+  let rel = path10.posix.relative(importerProdDir, target);
   if (!rel.startsWith(".")) rel = "./" + rel;
   return rel;
 }
@@ -3365,41 +3382,41 @@ var INDEX_EXTS = [
   "/index.cjs"
 ];
 function resolveRelativeSpecifier(importer, specifier) {
-  const importerDir = path9.dirname(importer);
-  const base = path9.resolve(importerDir, specifier);
+  const importerDir = path10.dirname(importer);
+  const base = path10.resolve(importerDir, specifier);
   if (PROD_EXTS.some((ext) => specifier.endsWith(ext))) {
-    if (fs7.existsSync(base)) return base;
+    if (fs8.existsSync(base)) return base;
     if (base.endsWith(".js")) {
       for (const ext of [".ts", ".tsx", ".jsx"]) {
         const file = base.slice(0, -3) + ext;
-        if (fs7.existsSync(file)) return file;
+        if (fs8.existsSync(file)) return file;
       }
     }
     return null;
   }
   if (/\.(ts|tsx|jsx)$/.test(specifier)) {
-    return fs7.existsSync(base) ? base : null;
+    return fs8.existsSync(base) ? base : null;
   }
   for (const ext of SOURCE_EXTS) {
     const file = base + ext;
-    if (fs7.existsSync(file)) return file;
+    if (fs8.existsSync(file)) return file;
   }
   for (const indexExt of INDEX_EXTS) {
     const file = base + indexExt;
-    if (fs7.existsSync(file)) return file;
+    if (fs8.existsSync(file)) return file;
   }
   return null;
 }
 function createAliasPlugin(config, options) {
-  const appDirAbs = options?.rootDir ? toRealPath(path9.resolve(options.rootDir, APP_DIR)) : null;
+  const appDirAbs = options?.rootDir ? toRealPath(path10.resolve(options.rootDir, APP_DIR)) : null;
   const probeCandidateFile = (candidate) => {
     for (const ext of SOURCE_EXTS) {
       const file = candidate + ext;
-      if (fs7.existsSync(file)) return file;
+      if (fs8.existsSync(file)) return file;
     }
     for (const indexExt of INDEX_EXTS) {
       const file = candidate + indexExt;
-      if (fs7.existsSync(file)) return file;
+      if (fs8.existsSync(file)) return file;
     }
     return null;
   };
@@ -3409,7 +3426,7 @@ function createAliasPlugin(config, options) {
       build.onLoad({ filter: /\.(ts|tsx|js|jsx|mjs|cjs)$/ }, (args) => {
         let source;
         try {
-          source = fs7.readFileSync(args.path, "utf8");
+          source = fs8.readFileSync(args.path, "utf8");
         } catch {
           return void 0;
         }
@@ -3535,11 +3552,11 @@ async function compileSourceFiles(options) {
   if (entryPoints.length === 0) {
     return { compiledFiles: [] };
   }
-  const absDist = path10.resolve(rootDir, dist);
-  await fs8.promises.mkdir(absDist, { recursive: true });
+  const absDist = path11.resolve(rootDir, dist);
+  await fs9.promises.mkdir(absDist, { recursive: true });
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
-  const outbase = path10.resolve(rootDir, APP_DIR);
+  const outbase = path11.resolve(rootDir, APP_DIR);
   const result = await esbuild.build({
     entryPoints,
     outdir: absDist,
@@ -3559,10 +3576,10 @@ async function compileSourceFiles(options) {
   if (atomicWrite && result.outputFiles) {
     await Promise.all(
       result.outputFiles.map(async (file) => {
-        await fs8.promises.mkdir(path10.dirname(file.path), { recursive: true });
+        await fs9.promises.mkdir(path11.dirname(file.path), { recursive: true });
         const tmp = `${file.path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-        await fs8.promises.writeFile(tmp, file.contents);
-        await fs8.promises.rename(tmp, file.path);
+        await fs9.promises.writeFile(tmp, file.contents);
+        await fs9.promises.rename(tmp, file.path);
       })
     );
   }
@@ -3575,8 +3592,8 @@ async function compileDevRoutes(options) {
 }
 
 // src/cli/collectImports.ts
-import path11 from "path";
-import fs9 from "fs";
+import path12 from "path";
+import fs10 from "fs";
 var SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
 function extractImportSpecifiers(source) {
   const specifiers = [];
@@ -3588,10 +3605,10 @@ function extractImportSpecifiers(source) {
   return specifiers;
 }
 function resolveSpecifierFromDir(dir, specifier) {
-  return resolveRelativeSpecifier(path11.join(dir, "__faapi_probe__.ts"), specifier);
+  return resolveRelativeSpecifier(path12.join(dir, "__faapi_probe__.ts"), specifier);
 }
 async function collectRelativeImports(entryFiles, rootDir) {
-  const appDirAbs = toRealPath(path11.resolve(rootDir, "src"));
+  const appDirAbs = toRealPath(path12.resolve(rootDir, "src"));
   const tsconfig = readTsconfig(rootDir);
   const visited = /* @__PURE__ */ new Set();
   const insideFiles = /* @__PURE__ */ new Set();
@@ -3601,7 +3618,7 @@ async function collectRelativeImports(entryFiles, rootDir) {
     visited.add(filePath);
     let source;
     try {
-      source = await fs9.promises.readFile(filePath, "utf8");
+      source = await fs10.promises.readFile(filePath, "utf8");
     } catch {
       return;
     }
@@ -3623,7 +3640,7 @@ async function collectRelativeImports(entryFiles, rootDir) {
         resolved = null;
       }
       if (!resolved) continue;
-      if (!isInsideDir(toRealPath(resolved), toRealPath(path11.resolve(rootDir)))) continue;
+      if (!isInsideDir(toRealPath(resolved), toRealPath(path12.resolve(rootDir)))) continue;
       if (isInsideDir(toRealPath(resolved), appDirAbs)) {
         insideFiles.add(resolved);
       } else {
@@ -3644,8 +3661,8 @@ async function collectRelativeImports(entryFiles, rootDir) {
 // src/cli/compileOnDemand.ts
 function isProductFresh(sourceAbsPath, productAbsPath) {
   try {
-    const srcStat = fs10.statSync(sourceAbsPath);
-    const prodStat = fs10.statSync(productAbsPath);
+    const srcStat = fs11.statSync(sourceAbsPath);
+    const prodStat = fs11.statSync(productAbsPath);
     return prodStat.mtimeMs >= srcStat.mtimeMs;
   } catch {
     return false;
@@ -3671,7 +3688,7 @@ async function ensureCompiled(sourceAbsPath, rootDir, dist) {
   if (state.compiledFiles.has(sourceAbsPath)) {
     return false;
   }
-  if (!fs10.existsSync(sourceAbsPath)) {
+  if (!fs11.existsSync(sourceAbsPath)) {
     return false;
   }
   const productPath = prodSourcePathToProductPath(sourceAbsPath, rootDir, dist);
@@ -3721,11 +3738,11 @@ async function ensureMiddlewaresCompiled(middlewarePaths, rootDir) {
   }
 }
 function prodSourcePathToProductPath(sourceAbsPath, rootDir, dist) {
-  const rel = path12.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const rel = path13.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   if (!rel.startsWith("src/")) return null;
   const relWithoutSrc = rel.slice(4);
   const jsRel = relWithoutSrc.replace(/\.ts$/, ".js");
-  return path12.resolve(rootDir, dist, jsRel);
+  return path13.resolve(rootDir, dist, jsRel);
 }
 async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir, dist, wsRoutes) {
   const inFlight2 = state.inFlightSchemaGenerations.get(schemaPath);
@@ -3736,9 +3753,9 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   if (state.generatedSchemas.has(schemaPath)) {
     return false;
   }
-  const prodAbsPath = path12.resolve(rootDir, routeFilePath);
+  const prodAbsPath = path13.resolve(rootDir, routeFilePath);
   const sourceAbsPath = prodPathToSourcePath(prodAbsPath, rootDir, dist);
-  if (!fs10.existsSync(sourceAbsPath)) {
+  if (!fs11.existsSync(sourceAbsPath)) {
     return false;
   }
   if (isProductFresh(sourceAbsPath, schemaPath)) {
@@ -3750,7 +3767,7 @@ async function ensureSchemaGenerated(schemaPath, routeFilePath, routes, rootDir,
   if (fileRoutes.length === 0 && fileWsRoutes.length === 0) {
     return false;
   }
-  const sourceRelPath = path12.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
+  const sourceRelPath = path13.relative(rootDir, sourceAbsPath).replace(/\\/g, "/");
   const sourceRoutes = fileRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
   const sourceWsRoutes = fileWsRoutes.map((r) => ({ ...r, filePath: sourceRelPath }));
   const generatePromise = (async () => {
@@ -3769,19 +3786,19 @@ var sourcePathCache = /* @__PURE__ */ new Map();
 function prodPathToSourcePath(prodAbsPath, rootDir, dist) {
   const cached = sourcePathCache.get(prodAbsPath);
   if (cached) return cached;
-  const rel = path12.relative(rootDir, prodAbsPath).replace(/\\/g, "/");
+  const rel = path13.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 = path12.resolve(rootDir, tsRel);
+  const tsAbs = path13.resolve(rootDir, tsRel);
   let result;
-  if (fs10.existsSync(tsAbs)) {
+  if (fs11.existsSync(tsAbs)) {
     result = tsAbs;
   } else {
-    result = path12.resolve(rootDir, srcRel);
+    result = path13.resolve(rootDir, srcRel);
   }
   sourcePathCache.set(prodAbsPath, result);
   return result;
@@ -3834,9 +3851,9 @@ async function validateInput(schemaPath, method, inputType, input) {
 function mapZodIssues(error) {
   return error.issues.map((issue) => {
     const code = mapZodCode(issue);
-    const path17 = issue.path.map(String).join(".") || "";
+    const path18 = issue.path.map(String).join(".") || "";
     return {
-      path: path17,
+      path: path18,
       code,
       expected: issue.expected ?? mapExpectedFromMessage(issue.message),
       received: issue.received ?? mapReceivedFromMessage(issue.message),
@@ -3886,7 +3903,7 @@ import {
 import { createSecureServer as createHttp2SecureServer } from "http2";
 import { readFileSync } from "fs";
 import { Readable as Readable2 } from "stream";
-import path15 from "path";
+import path16 from "path";
 
 // src/router/matchRoute.ts
 var httpIndexCache = /* @__PURE__ */ new WeakMap();
@@ -3928,25 +3945,25 @@ function getWsIndex(routes) {
   wsIndexCache.set(routes, index);
   return index;
 }
-function matchRoute(routes, method, path17) {
+function matchRoute(routes, method, path18) {
   const index = getHttpIndex(routes);
   const upper = method.toUpperCase();
-  const hit = matchByMethod(index, upper, path17);
+  const hit = matchByMethod(index, upper, path18);
   if (hit) return hit;
   if (upper === "HEAD") {
-    return matchByMethod(index, "GET", path17);
+    return matchByMethod(index, "GET", path18);
   }
   return null;
 }
-function matchByMethod(index, method, path17) {
-  const staticHit = index.static.get(`${method}|${path17}`);
+function matchByMethod(index, method, path18) {
+  const staticHit = index.static.get(`${method}|${path18}`);
   if (staticHit) {
     return { route: staticHit, params: {} };
   }
   if (index.dynamics.length === 0) {
     return null;
   }
-  const pathSegments = path17.split("/").filter(Boolean);
+  const pathSegments = path18.split("/").filter(Boolean);
   for (const entry of index.dynamics) {
     const route = entry.route;
     if (route.method !== method) {
@@ -3959,31 +3976,31 @@ function matchByMethod(index, method, path17) {
   }
   return null;
 }
-function matchWsRoute(wsRoutes, path17) {
+function matchWsRoute(wsRoutes, path18) {
   const index = getWsIndex(wsRoutes);
-  const staticHit = index.static.get(path17);
+  const staticHit = index.static.get(path18);
   if (staticHit) {
     return { route: staticHit, params: {} };
   }
   for (const route of index.dynamics) {
-    const params = matchDynamicPath(route.urlPath, path17, route.paramNames, route.isCatchAll);
+    const params = matchDynamicPath(route.urlPath, path18, route.paramNames, route.isCatchAll);
     if (params !== null) {
       return { route, params };
     }
   }
   return null;
 }
-function findAllowedMethods(routes, path17) {
+function findAllowedMethods(routes, path18) {
   const index = getHttpIndex(routes);
   const methods = /* @__PURE__ */ new Set();
-  const staticMethods = index.methodsByStaticPath.get(path17);
+  const staticMethods = index.methodsByStaticPath.get(path18);
   if (staticMethods) {
     for (const method of staticMethods) {
       methods.add(method);
     }
   }
   if (index.dynamics.length > 0) {
-    const pathSegments = path17.split("/").filter(Boolean);
+    const pathSegments = path18.split("/").filter(Boolean);
     for (const entry of index.dynamics) {
       const params = matchSegments(
         entry.segments,
@@ -4001,10 +4018,10 @@ function findAllowedMethods(routes, path17) {
   }
   return Array.from(methods);
 }
-function matchDynamicPath(pattern, path17, paramNames, isCatchAll) {
+function matchDynamicPath(pattern, path18, paramNames, isCatchAll) {
   return matchSegments(
     pattern.split("/").filter(Boolean),
-    path17.split("/").filter(Boolean),
+    path18.split("/").filter(Boolean),
     paramNames,
     isCatchAll
   );
@@ -4626,16 +4643,16 @@ function logger(options = {}) {
 }
 
 // src/server/handleWsUpgrade.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import { WebSocketServer, WebSocket } from "ws";
-import path14 from "path";
+import path15 from "path";
 
 // src/cli/copyResources.ts
-import path13 from "path";
-import fs11 from "fs";
+import path14 from "path";
+import fs12 from "fs";
 var RESOURCES_OUTPUT_DIR = "resources";
 function resolveResourcesDir(rootDir, dist) {
-  return path13.resolve(rootDir, dist, RESOURCES_OUTPUT_DIR);
+  return path14.resolve(rootDir, dist, RESOURCES_OUTPUT_DIR);
 }
 
 // src/server/serverUtils.ts
@@ -4694,7 +4711,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);
       }
     }
@@ -4836,7 +4853,7 @@ function attachWebSocket(options) {
     let upgraded = false;
     const finalHandler = async () => {
       const schemaPath = getRuntimeSchemaPath(route.filePath, dist, rootDir);
-      if (fs12.existsSync(schemaPath)) {
+      if (fs13.existsSync(schemaPath)) {
         if (isDevOnDemandEnabled()) {
           const devDist = getDevDist();
           if (devDist) {
@@ -4875,7 +4892,7 @@ function attachWebSocket(options) {
       }
       let handlers;
       try {
-        const absoluteFilePath = path14.resolve(rootDir, route.filePath);
+        const absoluteFilePath = path15.resolve(rootDir, route.filePath);
         handlers = await loadWsHandler(absoluteFilePath, ctx, rootDir);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
@@ -5137,7 +5154,7 @@ function getRoutePaths(route, rootDir, dist) {
   let cached = routePathCache.get(route);
   if (!cached) {
     cached = {
-      absFilePath: path15.resolve(rootDir, route.filePath),
+      absFilePath: path16.resolve(rootDir, route.filePath),
       schemaPath: getRuntimeSchemaPath(route.filePath, dist, rootDir)
     };
     routePathCache.set(route, cached);
@@ -5346,7 +5363,7 @@ async function createTestServer(options) {
   } = options;
   const { routes, wsRoutes } = await scanRoutes(rootDir, patterns);
   const sorted = sortRoutes(routes);
-  const schemaDist = dist ? path16.isAbsolute(dist) ? dist : path16.resolve(rootDir, dist) : await fs13.mkdtemp(path16.join(os.tmpdir(), "faapi-test-schema-"));
+  const schemaDist = dist ? path17.isAbsolute(dist) ? dist : path17.resolve(rootDir, dist) : await fs14.mkdtemp(path17.join(os.tmpdir(), "faapi-test-schema-"));
   await generateSchemaFiles(sorted, rootDir, schemaDist);
   const { server } = createServer({
     routes: sorted,
@@ -5378,7 +5395,7 @@ async function createTestServer(options) {
       await new Promise((resolve) => {
         server.close(() => resolve());
       });
-      await fs13.rm(schemaDist, { recursive: true, force: true }).catch(() => {
+      await fs14.rm(schemaDist, { recursive: true, force: true }).catch(() => {
       });
       invalidateSchemaCache();
     }