@anaemia/bundler 0.4.0 → 0.5.0

package/dist/router/manifest.d.ts

@@ -1,3 +1,4 @@
-import type { RouteManifestEntry } from "./scan.js";
-export declare function writeManifest(appRoot: string, routes: RouteManifestEntry[]): void;
+import type { RouteManifestEntry } from "../router/scan.js";
+import type { RouteMetadata } from "../analyzer/checks/route-metadata.js";
+export declare function writeManifest(appRoot: string, routes: RouteManifestEntry[], routeMetadata: RouteMetadata[]): void;
 //# sourceMappingURL=manifest.d.ts.map

package/dist/router/manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/router/manifest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAUpD,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,GAAG,IAAI,CAwBjF"}
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/router/manifest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sCAAsC,CAAC;AAE1E,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,EAAE,aAAa,EAAE,aAAa,EAAE,QAsB1G"}

package/dist/router/manifest.js

@@ -1,23 +1,23 @@
 import fs from "node:fs";
 import path from "node:path";
-export function writeManifest(appRoot, routes) {
-    const errors = {};
-    for (const route of routes) {
-        if (route.filePath.endsWith("404.tsx")) {
-            errors["404"] = route.urlPattern;
-        }
-        if (route.filePath.endsWith("500.tsx")) {
-            errors["500"] = route.urlPattern;
-        }
-    }
-    const conventionalRoutes = routes.filter((r) => !r.filePath.endsWith("404.tsx") && !r.filePath.endsWith("500.tsx"));
+export function writeManifest(appRoot, routes, routeMetadata) {
+    const metadataMap = new Map(routeMetadata.map((m) => [path.resolve(appRoot, m.filePath), m]));
     const manifest = {
-        routes: conventionalRoutes,
-        errors,
-        chunks: {}, // rspack fills this in via ManifestPlugin
-        buildTime: new Date().toISOString(),
+        routes: routes.map((route) => {
+            const meta = metadataMap.get(route.filePath);
+            return {
+                ...route,
+                isStatic: meta?.isStatic ?? false,
+                hasLoader: meta?.hasLoader ?? false,
+                hasGuard: meta?.hasGuard ?? false,
+                serverFunctionIds: meta?.serverFunctionIds ?? [],
+            };
+        }),
+        chunks: {},
     };
-    const outDir = path.resolve(appRoot, "./dist");
-    fs.mkdirSync(outDir, { recursive: true });
-    fs.writeFileSync(path.resolve(outDir, "route-manifest.json"), JSON.stringify(manifest, null, 2));
+    const manifestPath = path.resolve(appRoot, "./dist/route-manifest.json");
+    const manifestDir = path.dirname(manifestPath);
+    if (!fs.existsSync(manifestDir))
+        fs.mkdirSync(manifestDir, { recursive: true });
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anaemia/bundler",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -8,10 +8,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./analyzer": {
+      "types": "./dist/analyzer/index.d.ts",
+      "default": "./dist/analyzer/index.js"
     }
   },
   "dependencies": {
-    "@anaemia/core": "^0.4.0",
+    "@anaemia/core": "^0.5.0",
     "@babel/core": "^7.29.7",
     "@babel/preset-typescript": "^7.29.7",
     "@rspack/core": "^2.0.5",
@@ -21,6 +25,8 @@
     "dotenv-expand": "^13.0.0",
     "glob": "^13.0.6",
     "jiti": "^2.7.0",
+    "oxc-parser": "^0.133.0",
+    "picocolors": "^1.1.1",
     "sass": "^1.100.0",
     "sass-loader": "^17.0.0",
     "solid-refresh": "^0.7.8",

package/src/analyzer/ast-utils.ts

@@ -0,0 +1,22 @@
+import type { AstNode } from "./ast-walker.js";
+
+export function prop<T = unknown>(node: AstNode, key: string): T {
+  return (node as Record<string, unknown>)[key] as T;
+}
+
+export function child(node: AstNode, key: string): AstNode | null {
+  const value = (node as Record<string, unknown>)[key];
+  if (value && typeof value === "object" && typeof (value as AstNode).type === "string") {
+    return value as AstNode;
+  }
+  return null;
+}
+
+export function children(node: AstNode, key: string): AstNode[] {
+  const value = (node as Record<string, unknown>)[key];
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (v): v is AstNode =>
+      v !== null && v !== undefined && typeof v === "object" && typeof (v as Record<string, unknown>).type === "string",
+  );
+}

package/src/analyzer/ast-walker.ts

@@ -0,0 +1,63 @@
+import { visitorKeys } from "oxc-parser";
+import type { Program } from "oxc-parser";
+
+export type AstNode = {
+  type: string;
+  [key: string]: unknown;
+};
+
+type WalkController = {
+  skip: () => void;
+};
+
+export type AstWalker = {
+  enter?: (node: AstNode, parent: AstNode | null, controller: WalkController) => void;
+  leave?: (node: AstNode, parent: AstNode | null) => void;
+};
+
+function isAstNode(value: unknown): value is AstNode {
+  return Boolean(value && typeof value === "object" && typeof (value as { type?: unknown }).type === "string");
+}
+
+function childKeysForNode(node: AstNode): string[] {
+  const keysByNodeType = visitorKeys as Record<string, string[] | undefined>;
+  const configuredKeys = keysByNodeType[node.type];
+  if (configuredKeys) return configuredKeys;
+
+  return Object.keys(node).filter((key) => {
+    if (key === "type" || key === "start" || key === "end" || key === "range" || key === "loc") return false;
+    const value = node[key];
+    return isAstNode(value) || (Array.isArray(value) && value.some(isAstNode));
+  });
+}
+
+export function walkAst(root: AstNode | Program, walker: AstWalker): void {
+  const visit = (node: AstNode, parent: AstNode | null) => {
+    const state = { skipped: false };
+    const controller: WalkController = {
+      skip() {
+        state.skipped = true;
+      },
+    };
+
+    walker.enter?.(node, parent, controller);
+
+    if (!state.skipped) {
+      for (const key of childKeysForNode(node)) {
+        const value = node[key];
+
+        if (Array.isArray(value)) {
+          for (const child of value) {
+            if (isAstNode(child)) visit(child, node);
+          }
+        } else if (isAstNode(value)) {
+          visit(value, node);
+        }
+      }
+    }
+
+    walker.leave?.(node, parent);
+  };
+
+  visit(root as AstNode, null);
+}

package/src/analyzer/checks/env-access.ts

@@ -0,0 +1,77 @@
+import { walkAst } from "../ast-walker.js";
+import { prop, child } from "../ast-utils.js";
+import type { AstNode } from "../ast-walker.js";
+import type { AnalyzerDiagnostic, ParsedAnalyzerFile } from "../types.js";
+
+const SERVER_FILE_PATTERNS = [/\.server\.(ts|tsx|js|jsx)$/, /server\//, /\/api\//, /_route\.(ts|tsx|js|jsx)$/];
+
+function isClientFile(filePath: string): boolean {
+  return !SERVER_FILE_PATTERNS.some((p) => p.test(filePath));
+}
+
+const ALWAYS_SAFE = new Set(["NODE_ENV", "MODE", "DEV", "PROD"]);
+
+function startLine(node: AstNode): number | undefined {
+  const loc = prop<{ start: { line: number } } | undefined>(node, "loc");
+  return loc?.start.line;
+}
+
+export function checkEnvAccess(file: ParsedAnalyzerFile): AnalyzerDiagnostic[] {
+  if (!file.program || !isClientFile(file.relativePath)) return [];
+
+  const diagnostics: AnalyzerDiagnostic[] = [];
+
+  walkAst(file.program, {
+    enter(node: AstNode) {
+      if (node.type !== "MemberExpression") return;
+
+      const obj = child(node, "object");
+      const propNode = child(node, "property");
+      if (!obj || !propNode) return;
+
+      // process.env
+      if (
+        obj.type === "Identifier" &&
+        prop<string>(obj, "name") === "process" &&
+        propNode.type === "Identifier" &&
+        prop<string>(propNode, "name") === "env"
+      ) {
+        diagnostics.push({
+          code: "PROCESS_ENV_ACCESS",
+          severity: "warning",
+          message: "using process.env is not recommended in anaemia apps. Use import.meta.env instead.",
+          filePath: file.relativePath,
+          line: startLine(node),
+          help: "replace process.env with import.meta.env and ensure client variables are prefixed with PUBLIC_",
+        });
+        return;
+      }
+
+      // import.meta.env.KEY
+      if (obj.type === "MemberExpression") {
+        const innerObj = child(obj, "object");
+        const innerProp = child(obj, "property");
+        if (
+          innerObj?.type === "MetaProperty" &&
+          innerProp?.type === "Identifier" &&
+          prop<string>(innerProp, "name") === "env" &&
+          propNode.type === "Identifier"
+        ) {
+          const envKey = prop<string>(propNode, "name");
+          if (!envKey.startsWith("PUBLIC_") && !ALWAYS_SAFE.has(envKey)) {
+            diagnostics.push({
+              code: "ENV_NOT_PUBLIC",
+              severity: "warning",
+              message: `import.meta.env.${envKey} is not prefixed with PUBLIC_ and will be undefined on the client`,
+              filePath: file.relativePath,
+              line: startLine(node),
+              help: `rename to PUBLIC_${envKey} or move this code to a .server.ts file`,
+            });
+          }
+        }
+      }
+    },
+  });
+
+  return diagnostics;
+}

package/src/analyzer/checks/route-metadata.ts

@@ -0,0 +1,91 @@
+import { walkAst } from "../ast-walker.js";
+import { prop, child, children } from "../ast-utils.js";
+import type { AstNode } from "../ast-walker.js";
+import type { ParsedAnalyzerFile } from "../types.js";
+
+export interface RouteMetadata {
+  filePath: string;
+  hasServerFunctions: boolean;
+  hasLoader: boolean;
+  hasGuard: boolean;
+  isStatic: boolean;
+  serverFunctionIds: string[];
+  params: string[];
+}
+
+export function extractRouteMetadata(file: ParsedAnalyzerFile): RouteMetadata {
+  if (!file.program) {
+    return {
+      filePath: file.relativePath,
+      hasServerFunctions: false,
+      hasLoader: false,
+      hasGuard: false,
+      isStatic: true,
+      serverFunctionIds: [],
+      params: extractParamsFromPath(file.relativePath),
+    };
+  }
+
+  let hasServerFunctions = false;
+  let hasLoader = false;
+  let hasGuard = false;
+  const serverFunctionIds: string[] = [];
+
+  walkAst(file.program, {
+    enter(node: AstNode) {
+      if (node.type === "ImportDeclaration") {
+        const source = child(node, "source");
+        if (source && /\.server/.test(prop<string>(source, "value"))) {
+          hasServerFunctions = true;
+        }
+        return;
+      }
+
+      if (node.type === "ExportNamedDeclaration") {
+        const decl = child(node, "declaration");
+        if (decl?.type === "VariableDeclaration") {
+          for (const d of children(decl, "declarations")) {
+            const id = child(d, "id");
+            if (!id) continue;
+            const name = prop<string>(id, "name");
+            if (name === "loader") hasLoader = true;
+            if (name === "guard") hasGuard = true;
+          }
+        }
+        return;
+      }
+
+      if (node.type === "CallExpression") {
+        const callee = child(node, "callee");
+        const args = children(node, "arguments");
+        const idArg = args[1];
+
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!idArg) return;
+        if (
+          callee?.type === "Identifier" &&
+          prop<string>(callee, "name") === "runOnServer" &&
+          idArg.type === "Literal"
+        ) {
+          const value = prop<unknown>(idArg, "value");
+          if (typeof value === "string") serverFunctionIds.push(value);
+        }
+      }
+    },
+  });
+
+  return {
+    filePath: file.relativePath,
+    hasServerFunctions,
+    hasLoader,
+    hasGuard,
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    isStatic: !hasServerFunctions && !hasLoader && !hasGuard,
+    serverFunctionIds,
+    params: extractParamsFromPath(file.relativePath),
+  };
+}
+
+function extractParamsFromPath(filePath: string): string[] {
+  return [...filePath.matchAll(/\[([^\]]+)\]/g)].map((m) => m[1]);
+}

package/src/analyzer/checks/server-functions.ts

@@ -0,0 +1,85 @@
+import { walkAst } from "../ast-walker.js";
+import { prop, child, children } from "../ast-utils.js";
+import type { AstNode } from "../ast-walker.js";
+import type { AnalyzerDiagnostic, ParsedAnalyzerFile } from "../types.js";
+
+function collectServerFunctionDefinitions(
+  files: ParsedAnalyzerFile[],
+): Map<string, { filePath: string; line?: number }> {
+  const definitions = new Map<string, { filePath: string; line?: number }>();
+
+  for (const file of files) {
+    if (!file.program) continue;
+    walkAst(file.program, {
+      enter(node: AstNode) {
+        if (node.type !== "CallExpression") return;
+        const callee = child(node, "callee");
+        const args = children(node, "arguments");
+        const idArg = args[1];
+
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!idArg) return;
+
+        if (
+          callee?.type === "Identifier" &&
+          prop<string>(callee, "name") === "runOnServer" &&
+          idArg.type === "Literal"
+        ) {
+          const value = prop<unknown>(idArg, "value");
+          if (typeof value === "string") {
+            definitions.set(value, {
+              filePath: file.relativePath,
+              line: prop<{ start: { line: number } } | undefined>(node, "loc")?.start.line,
+            });
+          }
+        }
+      },
+    });
+  }
+
+  return definitions;
+}
+
+function collectServerFunctionImports(files: ParsedAnalyzerFile[]): Set<string> {
+  const imports = new Set<string>();
+
+  for (const file of files) {
+    if (!file.program) continue;
+    walkAst(file.program, {
+      enter(node: AstNode) {
+        if (node.type !== "ImportDeclaration") return;
+        const source = child(node, "source");
+        if (!source || !/\.server/.test(prop<string>(source, "value"))) return;
+        for (const specifier of children(node, "specifiers")) {
+          if (specifier.type === "ImportSpecifier") {
+            const local = child(specifier, "local");
+            if (local) imports.add(prop<string>(local, "name"));
+          }
+        }
+      },
+    });
+  }
+
+  return imports;
+}
+
+export function checkUnusedServerFunctions(files: ParsedAnalyzerFile[]): AnalyzerDiagnostic[] {
+  const definitions = collectServerFunctionDefinitions(files);
+  const imports = collectServerFunctionImports(files);
+  const diagnostics: AnalyzerDiagnostic[] = [];
+
+  for (const [id, { filePath, line }] of definitions) {
+    if (!imports.has(id)) {
+      diagnostics.push({
+        code: "UNUSED_SERVER_FUNCTION",
+        severity: "info",
+        message: `server function "${id}" is defined but never imported`,
+        filePath,
+        line,
+        help: `remove it or check if it's being imported under a different name`,
+      });
+    }
+  }
+
+  return diagnostics;
+}

package/src/analyzer/index.ts

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import path from "node:path";
+import { glob } from "glob";
+import { parseAnalyzerFile } from "./parser.js";
+import type { AnalyzeAppOptions, AnalyzerResult } from "./types.js";
+
+import { checkUnusedServerFunctions } from "./checks/server-functions.js";
+import { extractRouteMetadata } from "./checks/route-metadata.js";
+
+const DEFAULT_ANALYZER_PATTERNS = [
+  "anaemia.config.{ts,js,mjs,cjs}",
+  "src/root.{tsx,jsx}",
+  "src/routes/**/*.{ts,tsx,js,jsx}",
+  "src/**/*.{ts,tsx,js,jsx}",
+];
+
+function uniqueFilePaths(filePaths: string[]): string[] {
+  return [...new Set(filePaths.map((filePath) => path.resolve(filePath)))].sort();
+}
+
+export function collectAnalyzerFiles(appRoot: string, include = DEFAULT_ANALYZER_PATTERNS): string[] {
+  const files = include.flatMap((pattern) =>
+    glob.sync(pattern, {
+      cwd: appRoot,
+      absolute: true,
+      nodir: true,
+      posix: true,
+      ignore: ["node_modules/**", "dist/**", ".anaemia/**"],
+    }),
+  );
+
+  return uniqueFilePaths(files).filter((filePath) => fs.existsSync(filePath));
+}
+
+export async function analyzeApp(appRoot: string, options: AnalyzeAppOptions = {}): Promise<AnalyzerResult> {
+  const normalizedRoot = path.resolve(appRoot);
+  const files = collectAnalyzerFiles(normalizedRoot, options.include);
+  const parsedFiles = files.map((filePath) => parseAnalyzerFile(normalizedRoot, filePath));
+
+  // per-file diagnostics
+  const diagnostics = parsedFiles.flatMap((file) => file.diagnostics);
+
+  // cross-file diagnostics
+  const unusedServerFnDiagnostics = checkUnusedServerFunctions(parsedFiles);
+
+  // route metadata for manifest
+  const routeFiles = parsedFiles.filter((f) => /src\/routes\//.test(f.filePath));
+  const routeMetadata = routeFiles.map(extractRouteMetadata);
+
+  return {
+    appRoot: normalizedRoot,
+    build: {
+      mode: options.mode ?? process.env.NODE_ENV ?? "development",
+      analyzedAt: new Date().toISOString(),
+    },
+    files: parsedFiles,
+    diagnostics: [...diagnostics, ...unusedServerFnDiagnostics],
+    routeMetadata,
+  };
+}
+
+export { parseAnalyzerFile } from "./parser.js";
+export { walkAst } from "./ast-walker.js";
+export type {
+  AnalyzeAppOptions,
+  AnalyzerDiagnostic,
+  AnalyzerFileKind,
+  AnalyzerResult,
+  ParsedAnalyzerFile,
+} from "./types.js";

package/src/analyzer/parser.ts

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseSync } from "oxc-parser";
+import type { ParserOptions } from "oxc-parser";
+import type { AnalyzerDiagnostic, AnalyzerFileKind, ParsedAnalyzerFile, ParserError, SourceLocation } from "./types.js";
+import { checkEnvAccess } from "./checks/env-access.js";
+
+const DEFAULT_PARSE_OPTIONS: ParserOptions = {
+  sourceType: "module",
+  astType: "ts",
+  range: true,
+  preserveParens: false,
+};
+
+function offsetToLocation(source: string, offset: number): SourceLocation {
+  const boundedOffset = Math.max(0, Math.min(offset, source.length));
+  let line = 1;
+  let column = 1;
+
+  for (let i = 0; i < boundedOffset; i++) {
+    if (source.charCodeAt(i) === 10) {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+
+  return { line, column };
+}
+
+function severityFromOxc(error: ParserError): AnalyzerDiagnostic["severity"] {
+  if (error.severity === "Error") return "error";
+  if (error.severity === "Warning") return "warning";
+  return "info";
+}
+
+function diagnosticFromOxcError(filePath: string, source: string, error: ParserError): AnalyzerDiagnostic {
+  const label = error.labels[0];
+  const start = label.start;
+  const location = typeof start === "number" ? offsetToLocation(source, start) : undefined;
+
+  return {
+    code: "parse",
+    severity: severityFromOxc(error),
+    message: label.message ? `${error.message}: ${label.message}` : error.message,
+    filePath,
+    start,
+    end: label.end,
+    line: location?.line,
+    column: location?.column,
+    help: error.helpMessage ?? undefined,
+    codeframe: error.codeframe ?? undefined,
+  };
+}
+
+function inferAnalyzerFileKind(appRoot: string, filePath: string): AnalyzerFileKind {
+  const relativePath = path.relative(appRoot, filePath).replace(/\\/g, "/");
+
+  if (/^anaemia\.config\.[cm]?[jt]s$/.test(relativePath)) return "config";
+  if (relativePath === "src/root.tsx" || relativePath === "src/root.jsx") return "root";
+  if (/^src\/routes\/.*\/?_route\.[jt]sx?$/.test(relativePath)) return "server-route";
+  if (/^src\/routes\/.*\.[jt]sx$/.test(relativePath)) return "route";
+  return "source";
+}
+
+export function parseAnalyzerFile(appRoot: string, filePath: string, options: ParserOptions = {}): ParsedAnalyzerFile {
+  const source = fs.readFileSync(filePath, "utf-8");
+  const relativePath = path.relative(appRoot, filePath).replace(/\\/g, "/");
+  const kind = inferAnalyzerFileKind(appRoot, filePath);
+  const parseOptions = { ...DEFAULT_PARSE_OPTIONS, ...options };
+
+  try {
+    const result = parseSync(filePath, source, parseOptions);
+    const parseDiagnostics = result.errors.map((error) => diagnosticFromOxcError(filePath, source, error));
+    const file: ParsedAnalyzerFile = {
+      filePath,
+      relativePath,
+      kind,
+      source,
+      program: result.program,
+      comments: result.comments,
+      module: result.module,
+      diagnostics: [],
+    };
+
+    const diagnostics = [...parseDiagnostics, ...checkEnvAccess(file)];
+
+    return { ...file, diagnostics };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      filePath,
+      relativePath,
+      kind,
+      source,
+      program: null,
+      comments: [],
+      module: null,
+      diagnostics: [{ code: "parse:thrown", severity: "error", message, filePath }],
+    };
+  }
+}

package/src/analyzer/types.ts

@@ -0,0 +1,55 @@
+import type { Comment, EcmaScriptModule, OxcError, Program } from "oxc-parser";
+import type { RouteMetadata } from "./checks/route-metadata.js";
+
+type AnalyzerSeverity = "error" | "warning" | "info";
+
+export type AnalyzerDiagnostic = {
+  code: string;
+  severity: AnalyzerSeverity;
+  message: string;
+  filePath: string;
+  start?: number;
+  end?: number;
+  line?: number;
+  column?: number;
+  help?: string;
+  codeframe?: string;
+};
+
+export type AnalyzerFileKind = "config" | "route" | "server-route" | "root" | "source";
+
+export type SourceLocation = {
+  line: number;
+  column: number;
+};
+
+export type ParsedAnalyzerFile = {
+  filePath: string;
+  relativePath: string;
+  kind: AnalyzerFileKind;
+  source: string;
+  program: Program | null;
+  comments: Comment[];
+  module: EcmaScriptModule | null;
+  diagnostics: AnalyzerDiagnostic[];
+};
+
+export type AnalyzeAppOptions = {
+  mode?: string;
+  include?: string[];
+};
+
+type AnalyzerBuildInfo = {
+  mode: string;
+  analyzedAt: string;
+};
+
+export type AnalyzerResult = {
+  appRoot: string;
+  build: AnalyzerBuildInfo;
+  files: ParsedAnalyzerFile[];
+  diagnostics: AnalyzerDiagnostic[];
+  routeMetadata: RouteMetadata[];
+};
+
+export type ParserError = OxcError;

package/src/env-loader.ts

@@ -7,7 +7,7 @@ export default function loadEnvFiles(appRoot: string, mode: string) {
   const files = [`.env`, `.env.local`, `.env.${mode}`, `.env.${mode}.local`];
 
   for (const file of files) {
-    const result = loadDotenv({ path: path.resolve(appRoot, file), override: true });
+    const result = loadDotenv({ path: path.resolve(appRoot, file), override: true, quiet: true });
     expandDotenv(result);
   }
 }