@faapi/faapi 0.0.0-canary.f08a14e → 1.0.0-canary.3a00f3e

package/dist/cli/index.js

@@ -235,7 +235,7 @@ async function compileDevRoutes(options) {
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
   const outbase = path3.resolve(rootDir, APP_DIR2);
-  await esbuild.build({
+  const result = await esbuild.build({
     entryPoints,
     outdir: absDist,
     outbase,
@@ -245,8 +245,19 @@ async function compileDevRoutes(options) {
     sourcemap: true,
     packages: "external",
     plugins,
-    logLevel
+    logLevel,
+    write: false
   });
+  if (result.outputFiles) {
+    await Promise.all(
+      result.outputFiles.map(async (file) => {
+        await fs3.promises.mkdir(path3.dirname(file.path), { recursive: true });
+        const tmp = `${file.path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+        await fs3.promises.writeFile(tmp, file.contents);
+        await fs3.promises.rename(tmp, file.path);
+      })
+    );
+  }
   return { compiledFiles: entryPoints };
 }
 var APP_DIR2;
@@ -258,35 +269,6 @@ var init_compileDevRoutes = __esm({
   }
 });
 
-// src/config/deepMerge.ts
-function deepMerge(base, override) {
-  const result = { ...base };
-  for (const key of Object.keys(override)) {
-    const baseVal = base[key];
-    const overVal = override[key];
-    if (baseVal instanceof Date || overVal instanceof Date || baseVal instanceof RegExp || overVal instanceof RegExp || baseVal instanceof Map || overVal instanceof Map || baseVal instanceof Set || overVal instanceof Set) {
-      result[key] = overVal;
-      continue;
-    }
-    if (baseVal !== null && overVal !== null && typeof baseVal === "object" && typeof overVal === "object" && !Array.isArray(baseVal) && !Array.isArray(overVal) && !(baseVal instanceof Function) && !(overVal instanceof Function)) {
-      result[key] = deepMerge(
-        baseVal,
-        overVal
-      );
-    } else {
-      result[key] = overVal;
-    }
-  }
-  return result;
-}
-var DEEP_MERGE_SOURCE;
-var init_deepMerge = __esm({
-  "src/config/deepMerge.ts"() {
-    "use strict";
-    DEEP_MERGE_SOURCE = `const deepMerge = ${deepMerge.toString()};`;
-  }
-});
-
 // src/cli/compileConfig.ts
 import path4 from "path";
 import fs4 from "fs";
@@ -301,9 +283,6 @@ function isInsideDir2(filePath, dir) {
   const rel = path4.relative(dir, filePath);
   return rel !== "" && !rel.startsWith("..") && !path4.isAbsolute(rel);
 }
-function getEnv() {
-  return process.env.FAAPI_ENV || process.env.NODE_ENV || "development";
-}
 function findBaseConfig(rootDir) {
   for (const f of BASE_CONFIG_FILES) {
     if (fs4.existsSync(path4.join(rootDir, f))) {
@@ -312,15 +291,6 @@ function findBaseConfig(rootDir) {
   }
   return null;
 }
-function findEnvConfig(rootDir, env) {
-  for (const ext of ENV_CONFIG_EXTS) {
-    const f = `faapi.config.${env}${ext}`;
-    if (fs4.existsSync(path4.join(rootDir, f))) {
-      return f;
-    }
-  }
-  return null;
-}
 function toProdExtension2(filePath) {
   if (filePath.endsWith(".ts")) return filePath.slice(0, -3) + ".js";
   if (filePath.endsWith(".tsx")) return filePath.slice(0, -4) + ".js";
@@ -394,14 +364,9 @@ async function compileConfig(options) {
   if (!baseConfigName) {
     return { generated: false, outputFile: "" };
   }
-  const env = getEnv();
-  const envConfigName = findEnvConfig(rootDir, env);
   const absDist = path4.resolve(rootDir, dist);
   await fs4.promises.mkdir(absDist, { recursive: true });
   const configEntryPoints = [path4.resolve(rootDir, baseConfigName)];
-  if (envConfigName) {
-    configEntryPoints.push(path4.resolve(rootDir, envConfigName));
-  }
   const { appDirFiles, nonAppDirFiles } = await collectRelativeImports(configEntryPoints, rootDir);
   const esbuild = await import("esbuild");
   const aliasPlugins = buildAliasPlugins(rootDir);
@@ -434,16 +399,8 @@ async function compileConfig(options) {
     });
   }
   const baseImport = `import base from './${toProdImport(baseConfigName)}';`;
-  const imports = [baseImport];
-  let exportDefault;
-  if (envConfigName) {
-    const envImport = `import env from './${toProdImport(envConfigName)}';`;
-    imports.push(envImport);
-    exportDefault = "export default deepMerge(base, env);";
-  } else {
-    exportDefault = "export default base;";
-  }
-  const entryCode = [...imports, DEEP_MERGE_SOURCE, exportDefault].join("\n");
+  const exportDefault = "export default base;";
+  const entryCode = [baseImport, exportDefault].join("\n");
   const outputFile = path4.resolve(absDist, "faapi-config.js");
   await esbuild.build({
     stdin: { contents: entryCode, resolveDir: absDist, loader: "ts" },
@@ -459,14 +416,12 @@ async function compileConfig(options) {
   });
   return { generated: true, outputFile };
 }
-var BASE_CONFIG_FILES, ENV_CONFIG_EXTS, SPEC_RE;
+var BASE_CONFIG_FILES, SPEC_RE;
 var init_compileConfig = __esm({
   "src/cli/compileConfig.ts"() {
     "use strict";
-    init_deepMerge();
     init_aliasPlugin();
     BASE_CONFIG_FILES = ["faapi.config.ts", "faapi.config.js"];
-    ENV_CONFIG_EXTS = [".ts", ".js"];
     SPEC_RE = /(\bfrom\s*|import\s*\(\s*)(['"])([^'"]+)\2/g;
   }
 });
@@ -1981,9 +1936,9 @@ var init_constants = __esm({
 });
 
 // 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("/")) {
@@ -2236,6 +2191,92 @@ var init_loadConfig = __esm({
   }
 });
 
+// src/cli/loadEnv.ts
+import fs9 from "fs";
+import path10 from "path";
+function resolveEnv() {
+  return process.env.NODE_ENV || "development";
+}
+function getEnvFiles(env) {
+  return [".env", ".env.local", `.env.${env}`, `.env.${env}.local`];
+}
+function parseEnvFile(content, fileVars) {
+  const result = {};
+  const lines = content.replace(/\r\n/g, "\n").split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(trimmed);
+    if (!match) continue;
+    const [, key, rawValue] = match;
+    const value = parseValue(rawValue, { ...fileVars, ...result });
+    result[key] = value;
+  }
+  return result;
+}
+function parseValue(raw, env) {
+  if (raw === "") return "";
+  if (raw[0] === "'") {
+    const end = raw.indexOf("'", 1);
+    return end === -1 ? raw.slice(1) : raw.slice(1, end);
+  }
+  if (raw[0] === '"') {
+    const match = /^"((?:\\.|[^"\\])*)"/.exec(raw);
+    const inner = match ? match[1] : raw.slice(1);
+    return expandEscapesAndVars(inner, env);
+  }
+  const commentMatch = /^(.*?)(\s+#.*)$/.exec(raw);
+  const value = commentMatch ? commentMatch[1] : raw;
+  return value.trim();
+}
+function expandEscapesAndVars(str, env) {
+  const escaped = str.replace(/\\(.)/g, (_, ch) => {
+    switch (ch) {
+      case "n":
+        return "\n";
+      case "r":
+        return "\r";
+      case "t":
+        return "	";
+      case "\\":
+        return "\\";
+      case '"':
+        return '"';
+      default:
+        return ch;
+    }
+  });
+  return escaped.replace(
+    /\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g,
+    (_, braced, plain) => {
+      const varName = braced || plain;
+      return env[varName] ?? process.env[varName] ?? "";
+    }
+  );
+}
+function loadEnv(rootDir) {
+  const env = resolveEnv();
+  const files = getEnvFiles(env);
+  const merged = {};
+  for (const file of files) {
+    const filePath = path10.join(rootDir, file);
+    if (!fs9.existsSync(filePath)) continue;
+    const content = fs9.readFileSync(filePath, "utf-8");
+    const parsed = parseEnvFile(content, merged);
+    Object.assign(merged, parsed);
+  }
+  for (const [key, value] of Object.entries(merged)) {
+    if (process.env[key] === void 0) {
+      process.env[key] = value;
+    }
+  }
+}
+var init_loadEnv = __esm({
+  "src/cli/loadEnv.ts"() {
+    "use strict";
+  }
+});
+
 // ../../node_modules/.pnpm/readdirp@4.1.2/node_modules/readdirp/esm/index.js
 import { stat, lstat, readdir, realpath } from "fs/promises";
 import { Readable } from "stream";
@@ -2326,7 +2367,7 @@ var init_esm = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? lstat : stat;
         if (wantBigintFsStats) {
-          this._stat = (path17) => statMethod(path17, { bigint: true });
+          this._stat = (path18) => statMethod(path18, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -2351,8 +2392,8 @@ var init_esm = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path17, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path17));
+              const { path: path18, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path18));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -2392,20 +2433,20 @@ var init_esm = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path17, depth) {
+      async _exploreDir(path18, depth) {
         let files;
         try {
-          files = await readdir(path17, this._rdOptions);
+          files = await readdir(path18, this._rdOptions);
         } catch (error) {
           this._onError(error);
         }
-        return { files, depth, path: path17 };
+        return { files, depth, path: path18 };
       }
-      async _formatEntry(dirent, path17) {
+      async _formatEntry(dirent, path18) {
         let entry;
         const basename3 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = presolve(pjoin(path17, basename3));
+          const fullPath = presolve(pjoin(path18, basename3));
           entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
@@ -2466,16 +2507,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(path17, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path18, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path17);
-    emitRaw(rawEvent, evPath, { watchedPath: path17 });
-    if (evPath && path17 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path17, evPath), KEY_LISTENERS, sysPath.join(path17, evPath));
+    listener(path18);
+    emitRaw(rawEvent, evPath, { watchedPath: path18 });
+    if (evPath && path18 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path18, evPath), KEY_LISTENERS, sysPath.join(path18, evPath));
     }
   };
   try {
-    return fs_watch(path17, {
+    return fs_watch(path18, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -2820,12 +2861,12 @@ var init_handler = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path17, fullPath, options, handlers) => {
+    setFsWatchListener = (path18, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path17, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path18, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -2836,7 +2877,7 @@ var init_handler = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path17,
+          path18,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -2851,7 +2892,7 @@ var init_handler = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error.code === "EPERM") {
             try {
-              const fd = await open(path17, "r");
+              const fd = await open(path18, "r");
               await fd.close();
               broadcastErr(error);
             } catch (err) {
@@ -2882,7 +2923,7 @@ var init_handler = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path17, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path18, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -2904,7 +2945,7 @@ var init_handler = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path17, curr));
+              foreach(cont.listeners, (listener2) => listener2(path18, curr));
             }
           })
         };
@@ -2932,13 +2973,13 @@ var init_handler = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path17, listener) {
+      _watchWithNodeFs(path18, listener) {
         const opts = this.fsw.options;
-        const directory = sysPath.dirname(path17);
-        const basename3 = sysPath.basename(path17);
+        const directory = sysPath.dirname(path18);
+        const basename3 = sysPath.basename(path18);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename3);
-        const absolutePath = sysPath.resolve(path17);
+        const absolutePath = sysPath.resolve(path18);
         const options = {
           persistent: opts.persistent
         };
@@ -2948,12 +2989,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(path17, absolutePath, options, {
+          closer = setFsWatchFileListener(path18, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path17, absolutePath, options, {
+          closer = setFsWatchListener(path18, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -2975,7 +3016,7 @@ var init_handler = __esm({
         let prevStats = stats;
         if (parent.has(basename3))
           return;
-        const listener = async (path17, newStats) => {
+        const listener = async (path18, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -2989,11 +3030,11 @@ var init_handler = __esm({
                 this.fsw._emit(EV.CHANGE, file, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path17);
+                this.fsw._closeFile(path18);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path17, closer2);
+                  this.fsw._addPathCloser(path18, closer2);
               } else {
                 prevStats = newStats2;
               }
@@ -3025,7 +3066,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, path17, item) {
+      async _handleSymlink(entry, directory, path18, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -3035,7 +3076,7 @@ var init_handler = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await fsrealpath(path17);
+            linkPath = await fsrealpath(path18);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -3045,12 +3086,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, path17, entry.stats);
+              this.fsw._emit(EV.CHANGE, path18, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path17, entry.stats);
+            this.fsw._emit(EV.ADD, path18, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -3079,9 +3120,9 @@ var init_handler = __esm({
             return;
           }
           const item = entry.path;
-          let path17 = sysPath.join(directory, item);
+          let path18 = sysPath.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path17, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path18, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -3090,8 +3131,8 @@ var init_handler = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path17 = sysPath.join(dir, sysPath.relative(dir, path17));
-            this._addToNodeFs(path17, initialAdd, wh, depth + 1);
+            path18 = sysPath.join(dir, sysPath.relative(dir, path18));
+            this._addToNodeFs(path18, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve3, reject) => {
@@ -3160,13 +3201,13 @@ var init_handler = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path17, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path18, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path17) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path18) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path17);
+        const wh = this.fsw._getWatchHelpers(path18);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -3182,8 +3223,8 @@ var init_handler = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sysPath.resolve(path17);
-            const targetPath = follow ? await fsrealpath(path17) : path17;
+            const absPath = sysPath.resolve(path18);
+            const targetPath = follow ? await fsrealpath(path18) : path18;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -3193,29 +3234,29 @@ var init_handler = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await fsrealpath(path17) : path17;
+            const targetPath = follow ? await fsrealpath(path18) : path18;
             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, path17, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path18, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sysPath.resolve(path17), targetPath);
+              this.fsw._symlinkPaths.set(sysPath.resolve(path18), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path17, closer);
+            this.fsw._addPathCloser(path18, closer);
           return false;
         } catch (error) {
           if (this.fsw._handleError(error)) {
             ready();
-            return path17;
+            return path18;
           }
         }
       }
@@ -3254,26 +3295,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath2(path17) {
-  if (typeof path17 !== "string")
+function normalizePath2(path18) {
+  if (typeof path18 !== "string")
     throw new Error("string expected");
-  path17 = sysPath2.normalize(path17);
-  path17 = path17.replace(/\\/g, "/");
+  path18 = sysPath2.normalize(path18);
+  path18 = path18.replace(/\\/g, "/");
   let prepend = false;
-  if (path17.startsWith("//"))
+  if (path18.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path17.match(DOUBLE_SLASH_RE2))
-    path17 = path17.replace(DOUBLE_SLASH_RE2, "/");
+  while (path18.match(DOUBLE_SLASH_RE2))
+    path18 = path18.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path17 = "/" + path17;
-  return path17;
+    path18 = "/" + path18;
+  return path18;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path17 = normalizePath2(testString);
+  const path18 = normalizePath2(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path17, stats)) {
+    if (pattern(path18, stats)) {
       return true;
     }
   }
@@ -3334,19 +3375,19 @@ var init_esm2 = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path17) => toUnix(sysPath2.normalize(toUnix(path17)));
-    normalizeIgnored = (cwd = "") => (path17) => {
-      if (typeof path17 === "string") {
-        return normalizePathToUnix(sysPath2.isAbsolute(path17) ? path17 : sysPath2.join(cwd, path17));
+    normalizePathToUnix = (path18) => toUnix(sysPath2.normalize(toUnix(path18)));
+    normalizeIgnored = (cwd = "") => (path18) => {
+      if (typeof path18 === "string") {
+        return normalizePathToUnix(sysPath2.isAbsolute(path18) ? path18 : sysPath2.join(cwd, path18));
       } else {
-        return path17;
+        return path18;
       }
     };
-    getAbsolutePath = (path17, cwd) => {
-      if (sysPath2.isAbsolute(path17)) {
-        return path17;
+    getAbsolutePath = (path18, cwd) => {
+      if (sysPath2.isAbsolute(path18)) {
+        return path18;
       }
-      return sysPath2.join(cwd, path17);
+      return sysPath2.join(cwd, path18);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -3401,10 +3442,10 @@ var init_esm2 = __esm({
     STAT_METHOD_F = "stat";
     STAT_METHOD_L = "lstat";
     WatchHelper = class {
-      constructor(path17, follow, fsw) {
+      constructor(path18, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path17;
-        this.path = path17 = path17.replace(REPLACER_RE, "");
+        const watchPath = path18;
+        this.path = path18 = path18.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sysPath2.resolve(watchPath);
         this.dirParts = [];
@@ -3526,20 +3567,20 @@ var init_esm2 = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path17) => {
-            const absPath = getAbsolutePath(path17, cwd);
+          paths = paths.map((path18) => {
+            const absPath = getAbsolutePath(path18, cwd);
             return absPath;
           });
         }
-        paths.forEach((path17) => {
-          this._removeIgnoredPath(path17);
+        paths.forEach((path18) => {
+          this._removeIgnoredPath(path18);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path17) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path17, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path18) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path18, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -3561,17 +3602,17 @@ var init_esm2 = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path17) => {
-          if (!sysPath2.isAbsolute(path17) && !this._closers.has(path17)) {
+        paths.forEach((path18) => {
+          if (!sysPath2.isAbsolute(path18) && !this._closers.has(path18)) {
             if (cwd)
-              path17 = sysPath2.join(cwd, path17);
-            path17 = sysPath2.resolve(path17);
+              path18 = sysPath2.join(cwd, path18);
+            path18 = sysPath2.resolve(path18);
           }
-          this._closePath(path17);
-          this._addIgnoredPath(path17);
-          if (this._watched.has(path17)) {
+          this._closePath(path18);
+          this._addIgnoredPath(path18);
+          if (this._watched.has(path18)) {
             this._addIgnoredPath({
-              path: path17,
+              path: path18,
               recursive: true
             });
           }
@@ -3635,38 +3676,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, path17, stats) {
+      async _emit(event, path18, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path17 = sysPath2.normalize(path17);
+          path18 = sysPath2.normalize(path18);
         if (opts.cwd)
-          path17 = sysPath2.relative(opts.cwd, path17);
-        const args = [path17];
+          path18 = sysPath2.relative(opts.cwd, path18);
+        const args = [path18];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path17))) {
+        if (awf && (pw = this._pendingWrites.get(path18))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path17, [event, ...args]);
+            this._pendingUnlinks.set(path18, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path18) => {
+              this._pendingUnlinks.forEach((entry, path19) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path18);
+                this._pendingUnlinks.delete(path19);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path17)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path18)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path17);
+            this._pendingUnlinks.delete(path18);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -3684,16 +3725,16 @@ var init_esm2 = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path17, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path18, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path17, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path18, 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, path17) : path17;
+          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path18) : path18;
           let stats2;
           try {
             stats2 = await stat3(fullPath);
@@ -3724,23 +3765,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, path17, timeout) {
+      _throttle(actionType, path18, 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(path17);
+        const actionPath = action.get(path18);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path17);
+          const item = action.get(path18);
           const count = item ? item.count : 0;
-          action.delete(path17);
+          action.delete(path18);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -3748,7 +3789,7 @@ var init_esm2 = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path17, thr);
+        action.set(path18, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -3762,44 +3803,44 @@ var init_esm2 = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path17, threshold, event, awfEmit) {
+      _awaitWriteFinish(path18, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path17;
-        if (this.options.cwd && !sysPath2.isAbsolute(path17)) {
-          fullPath = sysPath2.join(this.options.cwd, path17);
+        let fullPath = path18;
+        if (this.options.cwd && !sysPath2.isAbsolute(path18)) {
+          fullPath = sysPath2.join(this.options.cwd, path18);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           statcb(fullPath, (err, curStat) => {
-            if (err || !writes.has(path17)) {
+            if (err || !writes.has(path18)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path17).lastChange = now2;
+              writes.get(path18).lastChange = now2;
             }
-            const pw = writes.get(path17);
+            const pw = writes.get(path18);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path17);
+              writes.delete(path18);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path17)) {
-          writes.set(path17, {
+        if (!writes.has(path18)) {
+          writes.set(path18, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path17);
+              writes.delete(path18);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -3810,8 +3851,8 @@ var init_esm2 = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path17, stats) {
-        if (this.options.atomic && DOT_RE.test(path17))
+      _isIgnored(path18, stats) {
+        if (this.options.atomic && DOT_RE.test(path18))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -3821,17 +3862,17 @@ var init_esm2 = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path17, stats);
+        return this._userIgnored(path18, stats);
       }
-      _isntIgnored(path17, stat4) {
-        return !this._isIgnored(path17, stat4);
+      _isntIgnored(path18, stat4) {
+        return !this._isIgnored(path18, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path17) {
-        return new WatchHelper(path17, this.options.followSymlinks, this);
+      _getWatchHelpers(path18) {
+        return new WatchHelper(path18, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -3863,63 +3904,63 @@ var init_esm2 = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path17 = sysPath2.join(directory, item);
-        const fullPath = sysPath2.resolve(path17);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path17) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path17, 100))
+        const path18 = sysPath2.join(directory, item);
+        const fullPath = sysPath2.resolve(path18);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path18) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path18, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path17);
+        const wp = this._getWatchedDir(path18);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path17, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path18, 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 = path17;
+        let relPath = path18;
         if (this.options.cwd)
-          relPath = sysPath2.relative(this.options.cwd, path17);
+          relPath = sysPath2.relative(this.options.cwd, path18);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path17);
+        this._watched.delete(path18);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path17))
-          this._emit(eventName, path17);
-        this._closePath(path17);
+        if (wasTracked && !this._isIgnored(path18))
+          this._emit(eventName, path18);
+        this._closePath(path18);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path17) {
-        this._closeFile(path17);
-        const dir = sysPath2.dirname(path17);
-        this._getWatchedDir(dir).remove(sysPath2.basename(path17));
+      _closePath(path18) {
+        this._closeFile(path18);
+        const dir = sysPath2.dirname(path18);
+        this._getWatchedDir(dir).remove(sysPath2.basename(path18));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path17) {
-        const closers = this._closers.get(path17);
+      _closeFile(path18) {
+        const closers = this._closers.get(path18);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path17);
+        this._closers.delete(path18);
       }
-      _addPathCloser(path17, closer) {
+      _addPathCloser(path18, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path17);
+        let list = this._closers.get(path18);
         if (!list) {
           list = [];
-          this._closers.set(path17, list);
+          this._closers.set(path18, list);
         }
         list.push(closer);
       }
@@ -3946,7 +3987,7 @@ var init_esm2 = __esm({
 });
 
 // src/cli/watcher.ts
-import path10 from "path";
+import path11 from "path";
 function startWatcher(options) {
   const { rootDir, app, devDist } = options;
   let rebuildTimer = null;
@@ -3979,12 +4020,7 @@ function startWatcher(options) {
       void rebuildRoutes();
     }, 100);
   }
-  const CONFIG_FILES = [
-    "faapi.config.ts",
-    "faapi.config.js",
-    "faapi.config.production.ts",
-    "faapi.config.production.js"
-  ];
+  const CONFIG_FILES = ["faapi.config.ts", "faapi.config.js"];
   const watchPaths = ["src", ...CONFIG_FILES];
   const watcher = esm_default.watch(watchPaths, {
     cwd: rootDir,
@@ -3999,11 +4035,11 @@ function startWatcher(options) {
     }
   });
   watcher.on("add", (file) => {
-    pendingFiles.add(path10.resolve(rootDir, file));
+    pendingFiles.add(path11.resolve(rootDir, file));
     scheduleRebuild();
   });
   watcher.on("change", (file) => {
-    pendingFiles.add(path10.resolve(rootDir, file));
+    pendingFiles.add(path11.resolve(rootDir, file));
     scheduleRebuild();
   });
   watcher.on("unlink", () => {
@@ -4060,42 +4096,42 @@ var init_detectRouteConflicts = __esm({
 });
 
 // src/router/matchRoute.ts
-function matchRoute(routes, method, path17) {
+function matchRoute(routes, method, path18) {
   for (const route of routes) {
     if (route.method !== method) {
       continue;
     }
     if (!route.isDynamic) {
-      if (route.urlPath === path17) {
+      if (route.urlPath === path18) {
         return { route, params: {} };
       }
       continue;
     }
-    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 matchWsRoute(wsRoutes, path17) {
+function matchWsRoute(wsRoutes, path18) {
   for (const route of wsRoutes) {
     if (!route.isDynamic) {
-      if (route.urlPath === path17) {
+      if (route.urlPath === path18) {
         return { route, params: {} };
       }
       continue;
     }
-    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 matchDynamicPath(pattern, path17, paramNames, isCatchAll) {
+function matchDynamicPath(pattern, path18, paramNames, isCatchAll) {
   const patternSegments = pattern.split("/").filter(Boolean);
-  const pathSegments = path17.split("/").filter(Boolean);
+  const pathSegments = path18.split("/").filter(Boolean);
   if (isCatchAll) {
     const nonCatchAllCount = patternSegments.length - 1;
     if (pathSegments.length <= nonCatchAllCount) {
@@ -4522,14 +4558,14 @@ var init_httpErrors = __esm({
       issues;
     };
     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";
       }
     };
     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";
       }
@@ -4931,9 +4967,9 @@ async function validateInput(schemaPath, method, inputType, input) {
 function mapZodIssues(error) {
   return error.issues.map((issue) => {
     const code = mapZodCode(issue.code, issue.message);
-    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),
@@ -5292,7 +5328,7 @@ var init_wsHandler = __esm({
 
 // src/server/handleWsUpgrade.ts
 import { WebSocketServer, WebSocket } from "ws";
-import path11 from "path";
+import path12 from "path";
 function getPathname(req) {
   const url = req.url ?? "/";
   const idx = url.indexOf("?");
@@ -5374,7 +5410,7 @@ function attachWebSocket(options) {
     const finalHandler = async () => {
       let handlers;
       try {
-        const absoluteFilePath = path11.resolve(rootDir, route.filePath);
+        const absoluteFilePath = path12.resolve(rootDir, route.filePath);
         handlers = await loadWsHandler(absoluteFilePath, ctx);
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
@@ -5438,7 +5474,7 @@ import {
 import { createSecureServer as createHttp2SecureServer } from "http2";
 import { readFileSync } from "fs";
 import { Readable as Readable3 } from "stream";
-import path12 from "path";
+import path13 from "path";
 function toWebRequest(req, bodyLimit = DEFAULT_BODY_LIMIT) {
   const forwardedProto = req.headers["x-forwarded-proto"];
   const protocol = Array.isArray(forwardedProto) ? forwardedProto[0]?.split(",")[0]?.trim() ?? "http" : forwardedProto?.split(",")[0]?.trim() ?? "http";
@@ -5482,15 +5518,15 @@ function limitStreamSize(stream, maxSize) {
     }
   });
 }
-function findAllowedMethods(routes, path17) {
+function findAllowedMethods(routes, path18) {
   const methods = /* @__PURE__ */ new Set();
   for (const route of routes) {
-    if (route.urlPath === path17) {
+    if (route.urlPath === path18) {
       methods.add(route.method);
       continue;
     }
     if (route.isDynamic) {
-      const params = matchDynamicPath(route.urlPath, path17, route.paramNames, route.isCatchAll);
+      const params = matchDynamicPath(route.urlPath, path18, route.paramNames, route.isCatchAll);
       if (params !== null) {
         methods.add(route.method);
       }
@@ -5576,7 +5612,7 @@ async function handleRequest(routes, rootDir, dist, req, res, configMiddlewares,
     }
     ctx.params = match.params;
     const { route } = match;
-    const absoluteFilePath = path12.resolve(rootDir, route.filePath);
+    const absoluteFilePath = path13.resolve(rootDir, route.filePath);
     const routeModule = await loadRouteModule(absoluteFilePath, route.method);
     const input = await resolveInput(route.method, request);
     const inputType = getInputTypeForMethod(route.method);
@@ -5742,8 +5778,8 @@ var init_loadPlugins = __esm({
 });
 
 // src/cli/createAppCore.ts
-import fs9 from "fs";
-import path13 from "path";
+import fs10 from "fs";
+import path14 from "path";
 import { PassThrough } from "stream";
 function isFaapiConfigKey(key) {
   return FAAPI_CONFIG_KEYS.has(key);
@@ -5751,8 +5787,8 @@ function isFaapiConfigKey(key) {
 async function createAppBase(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const dist = options?.dist ?? process.env.FAAPI_DIST ?? DEFAULT_DIST;
-  const routesPath = path13.resolve(rootDir, dist, ROUTES_FILE);
-  if (!fs9.existsSync(routesPath)) {
+  const routesPath = path14.resolve(rootDir, dist, ROUTES_FILE);
+  if (!fs10.existsSync(routesPath)) {
     throw new Error(
       `[faapi] ${dist}/${ROUTES_FILE} \u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u6267\u884C \`faapi build\`\uFF08\u6216 \`faapi dev\`\uFF09\u751F\u6210\u4EA7\u7269\u3002`
     );
@@ -6019,12 +6055,13 @@ __export(devCommand_exports, {
   devCommand: () => devCommand,
   generateRouteArtifacts: () => generateRouteArtifacts
 });
-import path14 from "path";
+import path15 from "path";
 async function devCommand(options) {
   const rootDir = process.cwd();
+  if (!process.env.NODE_ENV) process.env.NODE_ENV = "development";
+  loadEnv(rootDir);
   const devDist = DEV_DIST;
   process.env.FAAPI_DIST = devDist;
-  if (!process.env.NODE_ENV) process.env.NODE_ENV = "development";
   console.log("- Development mode");
   console.log("- Compiling config...");
   await compileConfig({ rootDir, dist: devDist });
@@ -6041,7 +6078,7 @@ async function devCommand(options) {
 async function generateRouteArtifacts(rootDir, patterns, dist) {
   const { routes, wsRoutes } = await scanRoutes(rootDir, patterns, dist);
   const sorted = sortRoutes(routes);
-  const routesPath = path14.resolve(rootDir, dist, ROUTES_FILE2);
+  const routesPath = path15.resolve(rootDir, dist, ROUTES_FILE2);
   const serialized = serializeRoutes(sorted, wsRoutes, rootDir, dist);
   await writeRoutesModule(serialized, routesPath);
   await generateSchemaFiles(sorted, rootDir, dist);
@@ -6057,6 +6094,7 @@ var init_devCommand = __esm({
     init_scanRoutes();
     init_sortRoutes();
     init_loadConfig();
+    init_loadEnv();
     init_watcher();
     init_createDevApp();
     DEV_DIST = ".faapi";
@@ -6066,8 +6104,8 @@ var init_devCommand = __esm({
 });
 
 // src/cli/compileBuildRoutes.ts
-import path15 from "path";
-import fs10 from "fs";
+import path16 from "path";
+import fs11 from "fs";
 import fg3 from "fast-glob";
 async function compileBuildRoutes(options) {
   const { rootDir, dist, files, logLevel = "silent" } = options;
@@ -6080,11 +6118,11 @@ async function compileBuildRoutes(options) {
   if (entryPoints.length === 0) {
     return { compiledFiles: [] };
   }
-  const absDist = path15.resolve(rootDir, dist);
-  await fs10.promises.mkdir(absDist, { recursive: true });
+  const absDist = path16.resolve(rootDir, dist);
+  await fs11.promises.mkdir(absDist, { recursive: true });
   const plugins = buildAliasPlugins(rootDir);
   const esbuild = await import("esbuild");
-  const outbase = path15.resolve(rootDir, APP_DIR4);
+  const outbase = path16.resolve(rootDir, APP_DIR4);
   await esbuild.build({
     entryPoints,
     outdir: absDist,
@@ -6115,8 +6153,8 @@ var buildCommand_exports = {};
 __export(buildCommand_exports, {
   buildCommand: () => buildCommand
 });
-import path16 from "path";
-import fs11 from "fs";
+import path17 from "path";
+import fs12 from "fs";
 async function buildCommand(options) {
   const rootDir = options?.rootDir ?? process.cwd();
   const outdir = options?.dist ?? DEFAULT_DIST2;
@@ -6160,22 +6198,26 @@ async function buildCommand(options) {
   }
   console.log("\n[4/6] Generating schema...");
   await generateSchemaFiles(sorted, rootDir, outdir);
-  console.log(`  Schema: zod.js files under ${path16.resolve(rootDir, outdir)}`);
+  console.log(`  Schema: zod.js files under ${path17.resolve(rootDir, outdir)}`);
   console.log("\n[5/6] Generating routes manifest...");
-  const routesPath = path16.resolve(rootDir, outdir, "faapi-routes.js");
+  const routesPath = path17.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[6/6] Generating entry file...");
-  const mainPath = path16.resolve(rootDir, outdir, "main.js");
+  const mainPath = path17.resolve(rootDir, outdir, "main.js");
   const createProdAppArgs = options?.dist && options.dist !== DEFAULT_DIST2 ? `{ dist: '${outdir}' }` : "";
   const mainContent = `// \u7531 faapi build \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u7F16\u8F91
-import { createProdApp } from '@faapi/faapi';
+import { createProdApp, loadEnv } from '@faapi/faapi';
+
+// \u515C\u5E95 NODE_ENV\uFF08\u672A\u663E\u5F0F\u8BBE\u7F6E\u65F6\uFF09+ \u52A0\u8F7D .env \u7CFB\u5217\u6587\u4EF6\u5230 process.env
+if (!process.env.NODE_ENV) process.env.NODE_ENV = 'production';
+loadEnv(process.cwd());
 
 const app = await createProdApp(${createProdAppArgs});
 await app.listen();
 `;
-  await fs11.promises.writeFile(mainPath, mainContent, "utf-8");
+  await fs12.promises.writeFile(mainPath, mainContent, "utf-8");
   console.log(`  Written to ${mainPath}`);
   console.log("\nfaapi build completed");
 }