@envin/cli 1.1.12 → 1.1.14-canary.79c6253

package/dist/cli/index.mjs

@@ -1,894 +1,704 @@
 #!/usr/bin/env node
-
-// src/cli/index.ts
 import { program } from "commander";
-
-// package.json
-var package_default = {
-  name: "@envin/cli",
-  version: "1.1.12",
-  description: "Type-safe env validation with live previews",
-  keywords: [
-    "turbostarter",
-    "environment variables",
-    "validation",
-    "zod",
-    "arktype",
-    "valibot"
-  ],
-  homepage: "https://envin.turbostarter.dev",
-  bugs: {
-    url: "https://github.com/turbostarter/envin/issues"
-  },
-  repository: {
-    type: "git",
-    url: "git+https://github.com/turbostarter/envin.git",
-    directory: "packages/cli"
-  },
-  license: "MIT",
-  author: "Bartosz Zagrodzki",
-  bin: {
-    envin: "dist/cli/index.mjs"
-  },
-  scripts: {
-    build: "tsup-node && bun run build:preview",
-    "build:preview": "node ./scripts/build-preview-server.mjs",
-    clean: "rm -rf dist .turbo node_modules .next",
-    dev: "tsup-node --watch",
-    "dev:preview": "cd ../../apps/example && tsx ../../packages/cli/src/cli/index.ts dev",
-    start: "node dist/cli/index.mjs",
-    typecheck: "tsc --noEmit",
-    prepack: "bun ../../scripts/replace-workspace-protocol.ts && bun ../../scripts/populate-readme.ts"
-  },
-  dependencies: {
-    "@babel/parser": "^7.27.0",
-    "@babel/traverse": "^7.27.0",
-    "@hookform/resolvers": "^5.2.1",
-    "@radix-ui/react-slot": "1.2.4",
-    "radix-ui": "catalog:",
-    "@svgr/webpack": "^8.1.0",
-    chalk: "^5.4.1",
-    chokidar: "^4.0.3",
-    commander: "^13.1.0",
-    consola: "^3.4.2",
-    debounce: "^2.2.0",
-    dotenv: "^16.5.0",
-    envin: "workspace:*",
-    esbuild: "^0.25.10",
-    "log-symbols": "^7.0.0",
-    "mime-types": "^3.0.1",
-    next: "catalog:",
-    ora: "^8.2.0",
-    "react-hook-form": "^7.62.0",
-    "socket.io": "^4.8.1",
-    "socket.io-client": "^4.8.1",
-    "tsconfig-paths": "^4.2.0",
-    zod: "catalog:"
-  },
-  devDependencies: {
-    "@babel/core": "7.26.10",
-    "@swc/core": "1.11.21",
-    "@tailwindcss/postcss": "catalog:",
-    "@types/babel__core": "7.20.5",
-    "@types/babel__traverse": "7.20.7",
-    "@types/mime-types": "2.1.4",
-    "@types/node": "catalog:",
-    "@types/react": "catalog:",
-    "@types/react-dom": "catalog:",
-    "class-variance-authority": "catalog:",
-    clsx: "catalog:",
-    "lucide-react": "catalog:",
-    postcss: "catalog:",
-    react: "catalog:",
-    "react-dom": "catalog:",
-    "source-map-js": "1.2.1",
-    "stacktrace-parser": "0.1.11",
-    "tailwind-merge": "catalog:",
-    tailwindcss: "catalog:",
-    tsup: "catalog:",
-    tsx: "^4.19.4",
-    "tw-animate-css": "catalog:",
-    typescript: "catalog:"
-  }
-};
-
-// src/cli/commands/dev.ts
-import fs4 from "fs";
-
-// src/cli/utils/hot-reload/setup-hot-reloading.ts
-import { promises as fs3 } from "fs";
-import path6 from "path";
+import fs, { existsSync, promises, statSync } from "node:fs";
+import path from "node:path";
 import { watch } from "chokidar";
 import debounce from "debounce";
-import { Server as SocketServer } from "socket.io";
-
-// src/cli/utils/logger.ts
+import { Server } from "socket.io";
 import { createConsola } from "consola";
-var logger = createConsola({});
-
-// src/cli/utils/hot-reload/create-dependency-graph.ts
-import { existsSync as existsSync2, promises as fs2, statSync } from "fs";
-import path5 from "path";
-
-// src/cli/utils/preview/start-dev-server.ts
-import http from "http";
-import path3 from "path";
-import url from "url";
+import http from "node:http";
+import url from "node:url";
 import chalk from "chalk";
-import logSymbols2 from "log-symbols";
+import logSymbols from "log-symbols";
 import next from "next";
 import ora from "ora";
+import { lookup } from "mime-types";
+import { parse } from "@babel/parser";
+import traverseModule from "@babel/traverse";
+import { createMatchPath, loadConfig } from "tsconfig-paths";
 
-// src/utils/register-spinner-autostopping.ts
-import logSymbols from "log-symbols";
-var spinners = /* @__PURE__ */ new Set();
+//#region package.json
+var version = "1.1.13";
+
+//#endregion
+//#region src/lib/types.ts
+const Environment = {
+	DEVELOPMENT: "development",
+	PRODUCTION: "production"
+};
+const FILES = {
+	[Environment.DEVELOPMENT]: [
+		".env",
+		".env.local",
+		".env.development",
+		".env.development.local"
+	],
+	[Environment.PRODUCTION]: [
+		".env",
+		".env.local",
+		".env.production",
+		".env.production.local"
+	]
+};
+
+//#endregion
+//#region src/cli/utils/logger.ts
+const logger = createConsola({});
+
+//#endregion
+//#region src/utils/register-spinner-autostopping.ts
+const spinners = /* @__PURE__ */ new Set();
 process.on("SIGINT", () => {
-  spinners.forEach((spinner) => {
-    if (spinner.isSpinning) {
-      spinner.stop();
-    }
-  });
+	spinners.forEach((spinner) => {
+		if (spinner.isSpinning) spinner.stop();
+	});
 });
 process.on("exit", (code) => {
-  if (code !== 0) {
-    spinners.forEach((spinner) => {
-      if (spinner.isSpinning) {
-        spinner.stopAndPersist({
-          symbol: logSymbols.error
-        });
-      }
-    });
-  }
+	if (code !== 0) spinners.forEach((spinner) => {
+		if (spinner.isSpinning) spinner.stopAndPersist({ symbol: logSymbols.error });
+	});
 });
-var registerSpinnerAutostopping = (spinner) => {
-  spinners.add(spinner);
+const registerSpinnerAutostopping = (spinner) => {
+	spinners.add(spinner);
 };
 
-// src/cli/utils/preview/get-env-variables.ts
-import path from "path";
-var getEnvVariablesForPreviewApp = (relativePathToEnvDirectory, cwd) => {
-  return {
-    ENV_DIR_RELATIVE_PATH: relativePathToEnvDirectory,
-    ENV_DIR_ABSOLUTE_PATH: path.resolve(cwd, relativePathToEnvDirectory),
-    USER_PROJECT_LOCATION: cwd,
-    NEXT_PUBLIC_IS_PREVIEW_DEVELOPMENT: isDev ? "true" : "false"
-  };
+//#endregion
+//#region src/cli/utils/preview/get-env-variables.ts
+const getEnvVariablesForPreviewApp = (relativePathToEnvDirectory, cwd, envDirAbsolutePaths, envFilePaths, envConfigPath) => {
+	return {
+		ENV_DIR_RELATIVE_PATH: relativePathToEnvDirectory,
+		ENV_DIR_ABSOLUTE_PATH: path.resolve(cwd, relativePathToEnvDirectory),
+		ENV_DIR_ABSOLUTE_PATHS: JSON.stringify(envDirAbsolutePaths),
+		ENV_FILE_PATHS: JSON.stringify(envFilePaths),
+		ENV_CONFIG_PATH: envConfigPath,
+		USER_PROJECT_LOCATION: cwd,
+		NEXT_PUBLIC_IS_PREVIEW_DEVELOPMENT: isDev ? "true" : "false"
+	};
 };
 
-// src/cli/utils/preview/serve-static-file.ts
-import { existsSync, promises as fs } from "fs";
-import path2 from "path";
-import { lookup } from "mime-types";
-var serveStaticFile = async (res, parsedUrl, staticDirRelativePath) => {
-  const pathname = parsedUrl.pathname?.replace("/static", "./static") ?? "";
-  const ext = path2.parse(pathname).ext;
-  const staticBaseDir = path2.resolve(process.cwd(), staticDirRelativePath);
-  const fileAbsolutePath = path2.resolve(staticBaseDir, pathname);
-  if (!fileAbsolutePath.startsWith(staticBaseDir)) {
-    res.statusCode = 403;
-    res.end();
-    return;
-  }
-  try {
-    const fileHandle = await fs.open(fileAbsolutePath, "r");
-    const fileData = await fs.readFile(fileHandle);
-    res.setHeader("Content-type", lookup(ext) || "text/plain");
-    res.end(fileData);
-    fileHandle.close();
-  } catch (exception) {
-    if (!existsSync(fileAbsolutePath)) {
-      res.statusCode = 404;
-      res.end();
-    } else {
-      const sanitizedFilePath = fileAbsolutePath.replace(/\n|\r/g, "");
-      logger.error(
-        new Error(
-          `Could not read file at ${sanitizedFilePath} to be served, here's the exception:`
-        ),
-        exception
-      );
-      res.statusCode = 500;
-      res.end(
-        "Could not read file to be served! Check your terminal for more information."
-      );
-    }
-  }
+//#endregion
+//#region src/cli/utils/preview/serve-static-file.ts
+const serveStaticFile = async (res, parsedUrl, staticDirRelativePath) => {
+	const pathname = parsedUrl.pathname?.replace("/static", "./static") ?? "";
+	const ext = path.parse(pathname).ext;
+	const staticBaseDir = path.resolve(process.cwd(), staticDirRelativePath);
+	const fileAbsolutePath = path.resolve(staticBaseDir, pathname);
+	if (!fileAbsolutePath.startsWith(staticBaseDir)) {
+		res.statusCode = 403;
+		res.end();
+		return;
+	}
+	try {
+		const fileHandle = await promises.open(fileAbsolutePath, "r");
+		const fileData = await promises.readFile(fileHandle);
+		res.setHeader("Content-type", lookup(ext) || "text/plain");
+		res.end(fileData);
+		fileHandle.close();
+	} catch (exception) {
+		if (!existsSync(fileAbsolutePath)) {
+			res.statusCode = 404;
+			res.end();
+		} else {
+			const sanitizedFilePath = fileAbsolutePath.replace(/\n|\r/g, "");
+			logger.error(/* @__PURE__ */ new Error(`Could not read file at ${sanitizedFilePath} to be served, here's the exception:`), exception);
+			res.statusCode = 500;
+			res.end("Could not read file to be served! Check your terminal for more information.");
+		}
+	}
 };
 
-// src/cli/utils/preview/start-dev-server.ts
-var devServer;
-var safeAsyncServerListen = (server, port) => {
-  return new Promise((resolve) => {
-    server.listen(port, () => {
-      resolve({ portAlreadyInUse: false });
-    });
-    server.on("error", (e) => {
-      if (e.code === "EADDRINUSE") {
-        resolve({ portAlreadyInUse: true });
-      }
-    });
-  });
+//#endregion
+//#region src/cli/utils/preview/start-dev-server.ts
+let devServer;
+const safeAsyncServerListen = (server, port) => {
+	return new Promise((resolve) => {
+		server.listen(port, () => {
+			resolve({ portAlreadyInUse: false });
+		});
+		server.on("error", (e) => {
+			if (e.code === "EADDRINUSE") resolve({ portAlreadyInUse: true });
+		});
+	});
 };
-var filename = url.fileURLToPath(import.meta.url);
-var dirname = path3.dirname(filename);
-var isDev = !filename.endsWith(path3.join("cli", "index.mjs"));
-var cliPackageLocation = isDev ? path3.resolve(dirname, "../../../..") : path3.resolve(dirname, "../..");
-var previewServerLocation = isDev ? path3.resolve(dirname, "../../../..") : path3.resolve(dirname, "../preview");
-var startDevServer = async ({
-  envDirRelativePath,
-  staticBaseDirRelativePath,
-  port,
-  verbose
-}) => {
-  const [majorNodeVersion] = process.versions.node.split(".");
-  if (majorNodeVersion && Number.parseInt(majorNodeVersion) < 18) {
-    logger.error(
-      `Node ${majorNodeVersion} is not supported. Please upgrade to Node 18 or higher.`
-    );
-    process.exit(1);
-  }
-  devServer = http.createServer((req, res) => {
-    if (!req.url) {
-      res.end(404);
-      return;
-    }
-    if (verbose) {
-      logger.debug("Creating HTTP server...", {
-        envDirRelativePath,
-        staticBaseDirRelativePath,
-        port
-      });
-    }
-    const parsedUrl = url.parse(req.url, true);
-    res.setHeader(
-      "Cache-Control",
-      "no-cache, max-age=0, must-revalidate, no-store"
-    );
-    res.setHeader("Pragma", "no-cache");
-    res.setHeader("Expires", "-1");
-    try {
-      if (parsedUrl.path?.includes("static/") && !parsedUrl.path.includes("_next/static/")) {
-        void serveStaticFile(res, parsedUrl, staticBaseDirRelativePath);
-      } else if (!isNextReady) {
-        void nextReadyPromise.then(
-          () => nextHandleRequest?.(req, res, parsedUrl)
-        );
-      } else {
-        void nextHandleRequest?.(req, res, parsedUrl);
-      }
-    } catch (e) {
-      logger.error(new Error("Error while handling request!"), e);
-      res.writeHead(500);
-      res.end();
-    }
-  });
-  const { portAlreadyInUse } = await safeAsyncServerListen(devServer, port);
-  if (!portAlreadyInUse) {
-    logger.log(chalk.greenBright(`
-  Envin ${package_default.version}`));
-    logger.log(`  Running preview at:    http://localhost:${port}
-`);
-  } else {
-    const nextPortToTry = port + 1;
-    logger.warn(`Port ${port} is already in use, trying ${nextPortToTry}...`);
-    return startDevServer({
-      envDirRelativePath,
-      staticBaseDirRelativePath,
-      port: nextPortToTry,
-      verbose
-    });
-  }
-  devServer.on("close", async () => {
-    await app.close();
-  });
-  devServer.on("error", (e) => {
-    logger.error(new Error("Preview server error!"), e);
-    process.exit(1);
-  });
-  const spinner = ora({
-    text: "Getting envin preview server ready...\n",
-    prefixText: " "
-  }).start();
-  registerSpinnerAutostopping(spinner);
-  const timeBeforeNextReady = performance.now();
-  process.env = {
-    NODE_ENV: "development",
-    ...process.env,
-    ...getEnvVariablesForPreviewApp(
-      path3.normalize(envDirRelativePath),
-      process.cwd()
-    )
-  };
-  const app = next({
-    // passing in env here does not get the environment variables there
-    dev: isDev,
-    conf: {
-      images: {
-        // This is to avoid the warning with sharp
-        unoptimized: true
-      }
-    },
-    hostname: "localhost",
-    port,
-    dir: previewServerLocation
-  });
-  let isNextReady = false;
-  const nextReadyPromise = app.prepare();
-  await nextReadyPromise;
-  isNextReady = true;
-  const nextHandleRequest = app.getRequestHandler();
-  const secondsToNextReady = ((performance.now() - timeBeforeNextReady) / 1e3).toFixed(1);
-  spinner.stopAndPersist({
-    text: `Ready in ${secondsToNextReady}s
-`,
-    symbol: logSymbols2.success
-  });
-  return devServer;
+const filename = url.fileURLToPath(import.meta.url);
+const dirname = path.dirname(filename);
+const isDev = !filename.endsWith(path.join("cli", "index.mjs"));
+const cliPackageLocation = isDev ? path.resolve(dirname, "../../../..") : path.resolve(dirname, "../..");
+const previewServerLocation = isDev ? path.resolve(dirname, "../../../..") : path.resolve(dirname, "../preview");
+const startDevServer = async ({ envDirRelativePath, staticBaseDirRelativePath, envDirAbsolutePaths, envFilePaths, envConfigPath, port, verbose }) => {
+	const [majorNodeVersion] = process.versions.node.split(".");
+	if (majorNodeVersion && Number.parseInt(majorNodeVersion) < 18) {
+		logger.error(`Node ${majorNodeVersion} is not supported. Please upgrade to Node 18 or higher.`);
+		process.exit(1);
+	}
+	devServer = http.createServer((req, res) => {
+		if (!req.url) {
+			res.end(404);
+			return;
+		}
+		if (verbose) logger.debug("Creating HTTP server...", {
+			envDirRelativePath,
+			staticBaseDirRelativePath,
+			envDirAbsolutePaths,
+			envFilePaths,
+			envConfigPath,
+			port
+		});
+		const parsedUrl = url.parse(req.url, true);
+		res.setHeader("Cache-Control", "no-cache, max-age=0, must-revalidate, no-store");
+		res.setHeader("Pragma", "no-cache");
+		res.setHeader("Expires", "-1");
+		try {
+			if (parsedUrl.path?.includes("static/") && !parsedUrl.path.includes("_next/static/")) serveStaticFile(res, parsedUrl, staticBaseDirRelativePath);
+			else if (!isNextReady) nextReadyPromise.then(() => nextHandleRequest?.(req, res, parsedUrl));
+			else nextHandleRequest?.(req, res, parsedUrl);
+		} catch (e) {
+			logger.error(/* @__PURE__ */ new Error("Error while handling request!"), e);
+			res.writeHead(500);
+			res.end();
+		}
+	});
+	const { portAlreadyInUse } = await safeAsyncServerListen(devServer, port);
+	if (!portAlreadyInUse) {
+		logger.log(chalk.greenBright(`\n  Envin ${version}`));
+		logger.log(`  Running preview at:    http://localhost:${port}\n`);
+	} else {
+		const nextPortToTry = port + 1;
+		logger.warn(`Port ${port} is already in use, trying ${nextPortToTry}...`);
+		return startDevServer({
+			envDirRelativePath,
+			staticBaseDirRelativePath,
+			envDirAbsolutePaths,
+			envFilePaths,
+			envConfigPath,
+			port: nextPortToTry,
+			verbose
+		});
+	}
+	devServer.on("close", async () => {
+		await app.close();
+	});
+	devServer.on("error", (e) => {
+		logger.error(/* @__PURE__ */ new Error("Preview server error!"), e);
+		process.exit(1);
+	});
+	const spinner = ora({
+		text: "Getting envin preview server ready...\n",
+		prefixText: " "
+	}).start();
+	registerSpinnerAutostopping(spinner);
+	const timeBeforeNextReady = performance.now();
+	process.env = {
+		NODE_ENV: "development",
+		...process.env,
+		...getEnvVariablesForPreviewApp(path.normalize(envDirRelativePath), process.cwd(), envDirAbsolutePaths, envFilePaths, envConfigPath)
+	};
+	const app = next({
+		dev: isDev,
+		conf: { images: { unoptimized: true } },
+		hostname: "localhost",
+		port,
+		dir: previewServerLocation
+	});
+	let isNextReady = false;
+	const nextReadyPromise = app.prepare();
+	await nextReadyPromise;
+	isNextReady = true;
+	const nextHandleRequest = app.getRequestHandler();
+	const secondsToNextReady = ((performance.now() - timeBeforeNextReady) / 1e3).toFixed(1);
+	spinner.stopAndPersist({
+		text: `Ready in ${secondsToNextReady}s\n`,
+		symbol: logSymbols.success
+	});
+	return devServer;
 };
-var makeExitHandler = (options) => (_codeOrSignal) => {
-  if (typeof devServer !== "undefined") {
-    logger.log("\nShutting down dev server...");
-    devServer.close();
-    devServer = void 0;
-  }
-  if (options?.shouldKillProcess) {
-    process.exit(options.killWithErrorCode ? 1 : 0);
-  }
+const makeExitHandler = (options) => (_codeOrSignal) => {
+	if (typeof devServer !== "undefined") {
+		logger.log("\nShutting down dev server...");
+		devServer.close();
+		devServer = void 0;
+	}
+	if (options?.shouldKillProcess) process.exit(options.killWithErrorCode ? 1 : 0);
 };
 process.on("exit", makeExitHandler());
-process.on(
-  "SIGINT",
-  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: false })
-);
-process.on(
-  "SIGUSR1",
-  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: false })
-);
-process.on(
-  "SIGUSR2",
-  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: false })
-);
-process.on(
-  "uncaughtException",
-  makeExitHandler({ shouldKillProcess: true, killWithErrorCode: true })
-);
+process.on("SIGINT", makeExitHandler({
+	shouldKillProcess: true,
+	killWithErrorCode: false
+}));
+process.on("SIGUSR1", makeExitHandler({
+	shouldKillProcess: true,
+	killWithErrorCode: false
+}));
+process.on("SIGUSR2", makeExitHandler({
+	shouldKillProcess: true,
+	killWithErrorCode: false
+}));
+process.on("uncaughtException", makeExitHandler({
+	shouldKillProcess: true,
+	killWithErrorCode: true
+}));
 
-// src/cli/utils/hot-reload/get-imported-modules.ts
-import { parse } from "@babel/parser";
-import traverseModule from "@babel/traverse";
-var traverse = (
-  // we keep this check here so that this still works with the dev:preview
-  // script's use of tsx
-  typeof traverseModule === "function" ? traverseModule : (
-    // @ts-expect-error - this is a valid use case
-    traverseModule.default
-  )
-);
-var getImportedModules = (contents) => {
-  const importedPaths = [];
-  const parsedContents = parse(contents, {
-    sourceType: "unambiguous",
-    strictMode: false,
-    errorRecovery: true,
-    plugins: ["jsx", "typescript", "decorators"]
-  });
-  traverse(parsedContents, {
-    ImportDeclaration({ node }) {
-      importedPaths.push(node.source.value);
-    },
-    ExportAllDeclaration({ node }) {
-      importedPaths.push(node.source.value);
-    },
-    ExportNamedDeclaration({ node }) {
-      if (node.source) {
-        importedPaths.push(node.source.value);
-      }
-    },
-    TSExternalModuleReference({ node }) {
-      importedPaths.push(node.expression.value);
-    },
-    CallExpression({ node }) {
-      if ("name" in node.callee && node.callee.name === "require") {
-        if (node.arguments.length === 1) {
-          const importPathNode = node.arguments[0];
-          if (importPathNode?.type === "StringLiteral") {
-            importedPaths.push(importPathNode.value);
-          }
-        }
-      }
-    }
-  });
-  return importedPaths;
+//#endregion
+//#region src/cli/utils/hot-reload/get-imported-modules.ts
+const traverse = typeof traverseModule === "function" ? traverseModule : traverseModule.default;
+const getImportedModules = (contents) => {
+	const importedPaths = [];
+	traverse(parse(contents, {
+		sourceType: "unambiguous",
+		strictMode: false,
+		errorRecovery: true,
+		plugins: [
+			"jsx",
+			"typescript",
+			"decorators"
+		]
+	}), {
+		ImportDeclaration({ node }) {
+			importedPaths.push(node.source.value);
+		},
+		ExportAllDeclaration({ node }) {
+			importedPaths.push(node.source.value);
+		},
+		ExportNamedDeclaration({ node }) {
+			if (node.source) importedPaths.push(node.source.value);
+		},
+		TSExternalModuleReference({ node }) {
+			importedPaths.push(node.expression.value);
+		},
+		CallExpression({ node }) {
+			if ("name" in node.callee && node.callee.name === "require") {
+				if (node.arguments.length === 1) {
+					const importPathNode = node.arguments[0];
+					if (importPathNode?.type === "StringLiteral") importedPaths.push(importPathNode.value);
+				}
+			}
+		}
+	});
+	return importedPaths;
 };
 
-// src/cli/utils/hot-reload/resolve-path-aliases.ts
-import path4 from "path";
-import { createMatchPath, loadConfig } from "tsconfig-paths";
-var resolvePathAliases = (importPaths, projectPath) => {
-  const configLoadResult = loadConfig(projectPath);
-  if (configLoadResult.resultType === "success") {
-    const matchPath = createMatchPath(
-      configLoadResult.absoluteBaseUrl,
-      configLoadResult.paths
-    );
-    return importPaths.map((importedPath) => {
-      const unaliasedPath = matchPath(importedPath, void 0, void 0, [
-        ".tsx",
-        ".ts",
-        ".js",
-        ".jsx",
-        ".cjs",
-        ".mjs"
-      ]);
-      if (unaliasedPath) {
-        return `./${path4.relative(projectPath, unaliasedPath)}`;
-      }
-      return importedPath;
-    });
-  }
-  return importPaths;
+//#endregion
+//#region src/cli/utils/hot-reload/resolve-path-aliases.ts
+const resolvePathAliases = (importPaths, projectPath) => {
+	const configLoadResult = loadConfig(projectPath);
+	if (configLoadResult.resultType === "success") {
+		const matchPath = createMatchPath(configLoadResult.absoluteBaseUrl, configLoadResult.paths);
+		return importPaths.map((importedPath) => {
+			const unaliasedPath = matchPath(importedPath, void 0, void 0, [
+				".tsx",
+				".ts",
+				".js",
+				".jsx",
+				".cjs",
+				".mjs"
+			]);
+			if (unaliasedPath) return `./${path.relative(projectPath, unaliasedPath)}`;
+			return importedPath;
+		});
+	}
+	return importPaths;
 };
 
-// src/cli/utils/hot-reload/create-dependency-graph.ts
-var readAllFilesInsideDirectory = async (directory) => {
-  let allFilePaths = [];
-  const topLevelDirents = await fs2.readdir(directory, { withFileTypes: true });
-  for await (const dirent of topLevelDirents) {
-    const pathToDirent = path5.join(directory, dirent.name);
-    if (dirent.isDirectory()) {
-      allFilePaths = allFilePaths.concat(
-        await readAllFilesInsideDirectory(pathToDirent)
-      );
-    } else {
-      allFilePaths.push(pathToDirent);
-    }
-  }
-  return allFilePaths;
+//#endregion
+//#region src/cli/utils/hot-reload/create-dependency-graph.ts
+const readAllFilesInsideDirectory = async (directory) => {
+	let allFilePaths = [];
+	const topLevelDirents = await promises.readdir(directory, { withFileTypes: true });
+	for await (const dirent of topLevelDirents) {
+		const pathToDirent = path.join(directory, dirent.name);
+		if (dirent.isDirectory()) allFilePaths = allFilePaths.concat(await readAllFilesInsideDirectory(pathToDirent));
+		else allFilePaths.push(pathToDirent);
+	}
+	return allFilePaths;
 };
-var isJavascriptModule = (filePath) => {
-  const extensionName = path5.extname(filePath);
-  return [".js", ".ts", ".jsx", ".tsx", ".mjs", ".cjs"].includes(extensionName);
+const isJavascriptModule = (filePath) => {
+	const extensionName = path.extname(filePath);
+	return [
+		".js",
+		".ts",
+		".jsx",
+		".tsx",
+		".mjs",
+		".cjs"
+	].includes(extensionName);
 };
-var checkFileExtensionsUntilItExists = (pathWithoutExtension) => {
-  if (existsSync2(`${pathWithoutExtension}.ts`)) {
-    return `${pathWithoutExtension}.ts`;
-  }
-  if (existsSync2(`${pathWithoutExtension}.tsx`)) {
-    return `${pathWithoutExtension}.tsx`;
-  }
-  if (existsSync2(`${pathWithoutExtension}.js`)) {
-    return `${pathWithoutExtension}.js`;
-  }
-  if (existsSync2(`${pathWithoutExtension}.jsx`)) {
-    return `${pathWithoutExtension}.jsx`;
-  }
-  if (existsSync2(`${pathWithoutExtension}.mjs`)) {
-    return `${pathWithoutExtension}.mjs`;
-  }
-  if (existsSync2(`${pathWithoutExtension}.cjs`)) {
-    return `${pathWithoutExtension}.cjs`;
-  }
+const checkFileExtensionsUntilItExists = (pathWithoutExtension) => {
+	if (existsSync(`${pathWithoutExtension}.ts`)) return `${pathWithoutExtension}.ts`;
+	if (existsSync(`${pathWithoutExtension}.tsx`)) return `${pathWithoutExtension}.tsx`;
+	if (existsSync(`${pathWithoutExtension}.js`)) return `${pathWithoutExtension}.js`;
+	if (existsSync(`${pathWithoutExtension}.jsx`)) return `${pathWithoutExtension}.jsx`;
+	if (existsSync(`${pathWithoutExtension}.mjs`)) return `${pathWithoutExtension}.mjs`;
+	if (existsSync(`${pathWithoutExtension}.cjs`)) return `${pathWithoutExtension}.cjs`;
 };
-var createDependencyGraph = async (directory) => {
-  const filePaths = await readAllFilesInsideDirectory(directory);
-  const modulePaths = filePaths.filter(isJavascriptModule);
-  const graph = Object.fromEntries(
-    modulePaths.map((path7) => [
-      path7,
-      {
-        path: path7,
-        dependencyPaths: [],
-        dependentPaths: [],
-        moduleDependencies: []
-      }
-    ])
-  );
-  const getDependencyPaths = async (filePath) => {
-    const contents = await fs2.readFile(filePath, "utf8");
-    const importedPaths = isJavascriptModule(filePath) ? resolvePathAliases(getImportedModules(contents), path5.dirname(filePath)) : [];
-    const importedPathsRelativeToDirectory = importedPaths.map(
-      (dependencyPath) => {
-        const isModulePath = !dependencyPath.startsWith(".");
-        if (isModulePath || path5.isAbsolute(dependencyPath)) {
-          return dependencyPath;
-        }
-        let pathToDependencyFromDirectory = path5.resolve(
-          /*
-                      path.resolve resolves paths differently from what imports on javascript do.
-          
-                      So if we wouldn't do this, for an email at "/path/to/email.tsx" with a dependency path of "./other-email" 
-                      would end up going into /path/to/email.tsx/other-email instead of /path/to/other-email which is the
-                      one the import is meant to go to
-                    */
-          path5.dirname(filePath),
-          dependencyPath
-        );
-        let isDirectory = false;
-        try {
-          isDirectory = statSync(pathToDependencyFromDirectory).isDirectory();
-        } catch (_) {
-        }
-        if (isDirectory) {
-          const pathToSubDirectory = pathToDependencyFromDirectory;
-          const pathWithExtension = checkFileExtensionsUntilItExists(
-            `${pathToSubDirectory}/index`
-          );
-          if (pathWithExtension) {
-            pathToDependencyFromDirectory = pathWithExtension;
-          } else if (isDev) {
-            logger.warn(
-              `Could not find index file for directory at ${pathToDependencyFromDirectory}. This is probably going to cause issues with both hot reloading and your code.`
-            );
-          }
-        }
-        const extension = path5.extname(pathToDependencyFromDirectory);
-        const pathWithEnsuredExtension = (() => {
-          if (extension.length > 0 && existsSync2(pathToDependencyFromDirectory)) {
-            return pathToDependencyFromDirectory;
-          }
-          return checkFileExtensionsUntilItExists(
-            pathToDependencyFromDirectory.replace(extension, "")
-          );
-        })();
-        if (pathWithEnsuredExtension) {
-          pathToDependencyFromDirectory = pathWithEnsuredExtension;
-        } else if (isDev) {
-          logger.warn(
-            `Could not find file at ${pathToDependencyFromDirectory}`
-          );
-        }
-        return pathToDependencyFromDirectory;
-      }
-    );
-    const moduleDependencies = importedPathsRelativeToDirectory.filter(
-      (dependencyPath) => !dependencyPath.startsWith(".") && !path5.isAbsolute(dependencyPath)
-    );
-    const nonNodeModuleImportPathsRelativeToDirectory = importedPathsRelativeToDirectory.filter(
-      (dependencyPath) => dependencyPath.startsWith(".") || path5.isAbsolute(dependencyPath)
-    );
-    return {
-      dependencyPaths: nonNodeModuleImportPathsRelativeToDirectory,
-      moduleDependencies
-    };
-  };
-  const updateModuleDependenciesInGraph = async (moduleFilePath) => {
-    if (graph[moduleFilePath] === void 0) {
-      graph[moduleFilePath] = {
-        path: moduleFilePath,
-        dependencyPaths: [],
-        dependentPaths: [],
-        moduleDependencies: []
-      };
-    }
-    const { moduleDependencies, dependencyPaths: newDependencyPaths } = await getDependencyPaths(moduleFilePath);
-    graph[moduleFilePath].moduleDependencies = moduleDependencies;
-    for (const dependencyPath of graph[moduleFilePath].dependencyPaths) {
-      if (newDependencyPaths.includes(dependencyPath)) continue;
-      const dependencyModule = graph[dependencyPath];
-      if (dependencyModule !== void 0) {
-        dependencyModule.dependentPaths = dependencyModule.dependentPaths.filter(
-          (dependentPath) => dependentPath !== moduleFilePath
-        );
-      }
-    }
-    graph[moduleFilePath].dependencyPaths = newDependencyPaths;
-    for await (const dependencyPath of newDependencyPaths) {
-      if (graph[dependencyPath] === void 0) {
-        await updateModuleDependenciesInGraph(dependencyPath);
-      }
-      const dependencyModule = graph[dependencyPath];
-      if (dependencyModule === void 0) {
-        throw new Error(
-          `Loading the dependency path ${dependencyPath} did not initialize it at all. This is a bug in React Email.`
-        );
-      }
-      if (!dependencyModule.dependentPaths.includes(moduleFilePath)) {
-        dependencyModule.dependentPaths.push(moduleFilePath);
-      }
-    }
-  };
-  const removeModuleFromGraph = (filePath) => {
-    const module = graph[filePath];
-    if (module) {
-      for (const dependencyPath of module.dependencyPaths) {
-        if (graph[dependencyPath]) {
-          graph[dependencyPath].dependentPaths = graph[dependencyPath].dependentPaths.filter(
-            (dependentPath) => dependentPath !== filePath
-          );
-        }
-      }
-      delete graph[filePath];
-    }
-  };
-  return [
-    graph,
-    async (event, pathToModified) => {
-      switch (event) {
-        case "change":
-          if (isJavascriptModule(pathToModified)) {
-            await updateModuleDependenciesInGraph(pathToModified);
-          }
-          break;
-        case "add":
-          if (isJavascriptModule(pathToModified)) {
-            await updateModuleDependenciesInGraph(pathToModified);
-          }
-          break;
-        case "addDir": {
-          const filesInsideAddedDirectory = await readAllFilesInsideDirectory(pathToModified);
-          const modulesInsideAddedDirectory = filesInsideAddedDirectory.filter(isJavascriptModule);
-          for await (const filePath of modulesInsideAddedDirectory) {
-            await updateModuleDependenciesInGraph(filePath);
-          }
-          break;
-        }
-        case "unlink":
-          if (isJavascriptModule(pathToModified)) {
-            removeModuleFromGraph(pathToModified);
-          }
-          break;
-        case "unlinkDir": {
-          const filesInsideDeletedDirectory = await readAllFilesInsideDirectory(pathToModified);
-          const modulesInsideDeletedDirectory = filesInsideDeletedDirectory.filter(isJavascriptModule);
-          for await (const filePath of modulesInsideDeletedDirectory) {
-            removeModuleFromGraph(filePath);
-          }
-          break;
-        }
-      }
-    },
-    {
-      resolveDependentsOf: function resolveDependentsOf(pathToModule) {
-        const moduleEntry = graph[pathToModule];
-        const dependentPaths = [];
-        if (moduleEntry) {
-          for (const dependentPath of moduleEntry.dependentPaths) {
-            const dependentsOfDependent = resolveDependentsOf(dependentPath);
-            dependentPaths.push(...dependentsOfDependent);
-            dependentPaths.push(dependentPath);
-          }
-        }
-        return dependentPaths;
-      }
-    }
-  ];
+/**
+* Creates a stateful dependency graph that is structured in a way that you can get
+* the dependents of a module from its path.
+*
+* Stateful in the sense that it provides a `getter` and an "`updater`". The updater
+* will receive changes to the files, that can be perceived through some file watching mechanism,
+* so that it doesn't need to recompute the entire dependency graph but only the parts changed.
+*/
+const createDependencyGraph = async (directory) => {
+	const modulePaths = (await readAllFilesInsideDirectory(directory)).filter(isJavascriptModule);
+	const graph = Object.fromEntries(modulePaths.map((path$1) => [path$1, {
+		path: path$1,
+		dependencyPaths: [],
+		dependentPaths: [],
+		moduleDependencies: []
+	}]));
+	const getDependencyPaths = async (filePath) => {
+		const contents = await promises.readFile(filePath, "utf8");
+		const importedPathsRelativeToDirectory = (isJavascriptModule(filePath) ? resolvePathAliases(getImportedModules(contents), path.dirname(filePath)) : []).map((dependencyPath) => {
+			if (!dependencyPath.startsWith(".") || path.isAbsolute(dependencyPath)) return dependencyPath;
+			let pathToDependencyFromDirectory = path.resolve(path.dirname(filePath), dependencyPath);
+			let isDirectory = false;
+			try {
+				isDirectory = statSync(pathToDependencyFromDirectory).isDirectory();
+			} catch (_) {}
+			if (isDirectory) {
+				const pathWithExtension = checkFileExtensionsUntilItExists(`${pathToDependencyFromDirectory}/index`);
+				if (pathWithExtension) pathToDependencyFromDirectory = pathWithExtension;
+				else if (isDev) logger.warn(`Could not find index file for directory at ${pathToDependencyFromDirectory}. This is probably going to cause issues with both hot reloading and your code.`);
+			}
+			const extension = path.extname(pathToDependencyFromDirectory);
+			const pathWithEnsuredExtension = (() => {
+				if (extension.length > 0 && existsSync(pathToDependencyFromDirectory)) return pathToDependencyFromDirectory;
+				return checkFileExtensionsUntilItExists(pathToDependencyFromDirectory.replace(extension, ""));
+			})();
+			if (pathWithEnsuredExtension) pathToDependencyFromDirectory = pathWithEnsuredExtension;
+			else if (isDev) logger.warn(`Could not find file at ${pathToDependencyFromDirectory}`);
+			return pathToDependencyFromDirectory;
+		});
+		const moduleDependencies = importedPathsRelativeToDirectory.filter((dependencyPath) => !dependencyPath.startsWith(".") && !path.isAbsolute(dependencyPath));
+		return {
+			dependencyPaths: importedPathsRelativeToDirectory.filter((dependencyPath) => dependencyPath.startsWith(".") || path.isAbsolute(dependencyPath)),
+			moduleDependencies
+		};
+	};
+	const updateModuleDependenciesInGraph = async (moduleFilePath) => {
+		if (graph[moduleFilePath] === void 0) graph[moduleFilePath] = {
+			path: moduleFilePath,
+			dependencyPaths: [],
+			dependentPaths: [],
+			moduleDependencies: []
+		};
+		const { moduleDependencies, dependencyPaths: newDependencyPaths } = await getDependencyPaths(moduleFilePath);
+		graph[moduleFilePath].moduleDependencies = moduleDependencies;
+		for (const dependencyPath of graph[moduleFilePath].dependencyPaths) {
+			if (newDependencyPaths.includes(dependencyPath)) continue;
+			const dependencyModule = graph[dependencyPath];
+			if (dependencyModule !== void 0) dependencyModule.dependentPaths = dependencyModule.dependentPaths.filter((dependentPath) => dependentPath !== moduleFilePath);
+		}
+		graph[moduleFilePath].dependencyPaths = newDependencyPaths;
+		for await (const dependencyPath of newDependencyPaths) {
+			if (graph[dependencyPath] === void 0) await updateModuleDependenciesInGraph(dependencyPath);
+			const dependencyModule = graph[dependencyPath];
+			if (dependencyModule === void 0) throw new Error(`Loading the dependency path ${dependencyPath} did not initialize it at all. This is a bug in React Email.`);
+			if (!dependencyModule.dependentPaths.includes(moduleFilePath)) dependencyModule.dependentPaths.push(moduleFilePath);
+		}
+	};
+	const removeModuleFromGraph = (filePath) => {
+		const module = graph[filePath];
+		if (module) {
+			for (const dependencyPath of module.dependencyPaths) if (graph[dependencyPath]) graph[dependencyPath].dependentPaths = graph[dependencyPath].dependentPaths.filter((dependentPath) => dependentPath !== filePath);
+			delete graph[filePath];
+		}
+	};
+	return [
+		graph,
+		async (event, pathToModified) => {
+			switch (event) {
+				case "change":
+					if (isJavascriptModule(pathToModified)) await updateModuleDependenciesInGraph(pathToModified);
+					break;
+				case "add":
+					if (isJavascriptModule(pathToModified)) await updateModuleDependenciesInGraph(pathToModified);
+					break;
+				case "addDir": {
+					const modulesInsideAddedDirectory = (await readAllFilesInsideDirectory(pathToModified)).filter(isJavascriptModule);
+					for await (const filePath of modulesInsideAddedDirectory) await updateModuleDependenciesInGraph(filePath);
+					break;
+				}
+				case "unlink":
+					if (isJavascriptModule(pathToModified)) removeModuleFromGraph(pathToModified);
+					break;
+				case "unlinkDir": {
+					const modulesInsideDeletedDirectory = (await readAllFilesInsideDirectory(pathToModified)).filter(isJavascriptModule);
+					for await (const filePath of modulesInsideDeletedDirectory) removeModuleFromGraph(filePath);
+					break;
+				}
+			}
+		},
+		{ resolveDependentsOf: function resolveDependentsOf(pathToModule) {
+			const moduleEntry = graph[pathToModule];
+			const dependentPaths = [];
+			if (moduleEntry) for (const dependentPath of moduleEntry.dependentPaths) {
+				const dependentsOfDependent = resolveDependentsOf(dependentPath);
+				dependentPaths.push(...dependentsOfDependent);
+				dependentPaths.push(dependentPath);
+			}
+			return dependentPaths;
+		} }
+	];
 };
 
-// src/cli/utils/hot-reload/setup-hot-reloading.ts
-var IGNORED_DIR_NAMES = [
-  "node_modules",
-  ".git",
-  "dist",
-  "build",
-  "out",
-  "coverage",
-  ".cache",
-  "tmp"
+//#endregion
+//#region src/cli/utils/hot-reload/setup-hot-reloading.ts
+const IGNORED_DIR_NAMES = [
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	"out",
+	"coverage",
+	".cache",
+	"tmp"
 ];
-var normalizePath = (p) => p.split(path6.sep).join("/");
-var isPathInIgnoredDir = (p) => {
-  const normalized = normalizePath(p);
-  return IGNORED_DIR_NAMES.some(
-    (dir) => normalized.includes(`/${dir}/`) || normalized.endsWith(`/${dir}`) || normalized.startsWith(`${dir}/`)
-  );
+const normalizePath = (p) => p.split(path.sep).join("/");
+const isPathInIgnoredDir = (p) => {
+	const normalized = normalizePath(p);
+	return IGNORED_DIR_NAMES.some((dir) => normalized.includes(`/${dir}/`) || normalized.endsWith(`/${dir}`) || normalized.startsWith(`${dir}/`));
 };
-var toDirGlob = (dir) => [`**/${dir}/**`, `${dir}/**`];
-var readGitignoreGlobs = async (baseDir) => {
-  try {
-    const gitignorePath = path6.join(baseDir, ".gitignore");
-    const data = await fs3.readFile(gitignorePath, "utf8");
-    const lines = data.split(/\r?\n/);
-    const globs = [];
-    for (const rawLine of lines) {
-      const line = rawLine.trim();
-      if (line.length === 0 || line.startsWith("#") || line.startsWith("!")) {
-        continue;
-      }
-      let pattern = line.replace(/^\//, "");
-      if (pattern.endsWith("/")) {
-        pattern = pattern.slice(0, -1);
-        globs.push(`**/${pattern}/**`, `${pattern}/**`);
-        continue;
-      }
-      if (pattern.includes("*") || pattern.includes("?")) {
-        globs.push(`**/${pattern}`, pattern);
-      } else {
-        globs.push(
-          `**/${pattern}/**`,
-          `${pattern}/**`,
-          `**/${pattern}`,
-          pattern
-        );
-      }
-    }
-    return globs;
-  } catch {
-    return [];
-  }
+const toDirGlob = (dir) => [`**/${dir}/**`, `${dir}/**`];
+const readGitignoreGlobs = async (baseDir) => {
+	try {
+		const gitignorePath = path.join(baseDir, ".gitignore");
+		const lines = (await promises.readFile(gitignorePath, "utf8")).split(/\r?\n/);
+		const globs = [];
+		for (const rawLine of lines) {
+			const line = rawLine.trim();
+			if (line.length === 0 || line.startsWith("#") || line.startsWith("!")) continue;
+			let pattern = line.replace(/^\//, "");
+			if (pattern.endsWith("/")) {
+				pattern = pattern.slice(0, -1);
+				globs.push(`**/${pattern}/**`, `${pattern}/**`);
+				continue;
+			}
+			if (pattern.includes("*") || pattern.includes("?")) globs.push(`**/${pattern}`, pattern);
+			else globs.push(`**/${pattern}/**`, `${pattern}/**`, `**/${pattern}`, pattern);
+		}
+		return globs;
+	} catch {
+		return [];
+	}
 };
-var buildIgnoredGlobs = async (baseDir) => {
-  const defaultIgnoredGlobs = IGNORED_DIR_NAMES.flatMap(toDirGlob);
-  const gitignoreGlobs = await readGitignoreGlobs(baseDir);
-  return [...defaultIgnoredGlobs, ...gitignoreGlobs];
+const buildIgnoredGlobs = async (baseDir) => {
+	const defaultIgnoredGlobs = IGNORED_DIR_NAMES.flatMap(toDirGlob);
+	const gitignoreGlobs = await readGitignoreGlobs(baseDir);
+	return [...defaultIgnoredGlobs, ...gitignoreGlobs];
 };
-var createEnvWatcher = async (baseDir) => {
-  const ignoredGlobs = await buildIgnoredGlobs(baseDir);
-  return watch(["**/*.{js,ts,jsx,tsx,mjs,cjs}"], {
-    cwd: baseDir,
-    ignoreInitial: true,
-    ignored: ignoredGlobs,
-    ignorePermissionErrors: true,
-    awaitWriteFinish: { stabilityThreshold: 50, pollInterval: 10 }
-  });
+const createEnvWatcher = async (baseDir) => {
+	return watch(["**/*.{js,ts,jsx,tsx,mjs,cjs}"], {
+		cwd: baseDir,
+		ignoreInitial: true,
+		ignored: await buildIgnoredGlobs(baseDir),
+		ignorePermissionErrors: true,
+		awaitWriteFinish: {
+			stabilityThreshold: 50,
+			pollInterval: 10
+		}
+	});
 };
-var addExternalFilesToWatcher = (w, files) => {
-  for (const p of files) {
-    if (!isPathInIgnoredDir(p)) {
-      w.add(p);
-    }
-  }
+const addExternalFilesToWatcher = (w, files) => {
+	for (const p of files) if (!isPathInIgnoredDir(p)) w.add(p);
 };
-var attachShutdownHandlers = (w, verbose) => {
-  const exit = async () => {
-    if (verbose) {
-      logger.info("Stopping file watcher and cleaning up...");
-    }
-    await w.close();
-  };
-  process.on("SIGINT", exit);
-  process.on("uncaughtException", exit);
+const attachShutdownHandlers = (w, verbose) => {
+	const exit = async () => {
+		if (verbose) logger.info("Stopping file watcher and cleaning up...");
+		await w.close();
+	};
+	process.on("SIGINT", exit);
+	process.on("uncaughtException", exit);
 };
-var setupHotreloading = async ({
-  devServer: devServer2,
-  envDirRelativePath,
-  verbose
-}) => {
-  if (verbose) {
-    logger.start("Initializing socket.io server for hot reloading...");
-  }
-  let clients = [];
-  const io = new SocketServer(devServer2);
-  io.on("connection", (client) => {
-    if (verbose) {
-      logger.debug("Client connected to hot reload socket");
-    }
-    clients.push(client);
-    client.on("disconnect", () => {
-      if (verbose) {
-        logger.debug("Client disconnected from hot reload socket");
-      }
-      clients = clients.filter((item) => item !== client);
-    });
-  });
-  let changes = [];
-  const reload = debounce(() => {
-    if (verbose) {
-      logger.debug(
-        "Emitting reload event to",
-        clients.length,
-        "clients",
-        changes
-      );
-    }
-    clients.forEach((client) => {
-      client.emit(
-        "reload",
-        changes.filter(
-          (change) => (
-            // Ensures only changes inside the emails directory are emitted
-            path6.resolve(absolutePathToEnvDirectory, change.filename).startsWith(absolutePathToEnvDirectory)
-          )
-        )
-      );
-    });
-    changes = [];
-  }, 150);
-  const absolutePathToEnvDirectory = path6.resolve(
-    process.cwd(),
-    envDirRelativePath
-  );
-  const [dependencyGraph, updateDependencyGraph, { resolveDependentsOf }] = await createDependencyGraph(absolutePathToEnvDirectory);
-  if (verbose) {
-    logger.info("Dependency graph created", {
-      modules: Object.keys(dependencyGraph).length,
-      root: absolutePathToEnvDirectory
-    });
-  }
-  const watcher = await createEnvWatcher(absolutePathToEnvDirectory);
-  const getFilesOutsideEnvDirectory = () => Object.keys(dependencyGraph).filter(
-    (p) => path6.relative(absolutePathToEnvDirectory, p).startsWith("..")
-  );
-  let filesOutsideEnvDirectory = getFilesOutsideEnvDirectory();
-  addExternalFilesToWatcher(watcher, filesOutsideEnvDirectory);
-  attachShutdownHandlers(watcher, verbose);
-  watcher.on("all", async (event, relativePathToChangeTarget) => {
-    if (verbose) {
-      logger.debug("File system event", {
-        event,
-        file: relativePathToChangeTarget
-      });
-    }
-    const file = relativePathToChangeTarget.split(path6.sep);
-    if (file.length === 0) {
-      return;
-    }
-    const pathToChangeTarget = path6.resolve(
-      absolutePathToEnvDirectory,
-      relativePathToChangeTarget
-    );
-    await updateDependencyGraph(event, pathToChangeTarget);
-    const newFilesOutsideEnvDirectory = getFilesOutsideEnvDirectory();
-    for (const p of filesOutsideEnvDirectory) {
-      if (!newFilesOutsideEnvDirectory.includes(p)) {
-        watcher.unwatch(p);
-      }
-    }
-    for (const p of newFilesOutsideEnvDirectory) {
-      if (!filesOutsideEnvDirectory.includes(p) && !isPathInIgnoredDir(p)) {
-        watcher.add(p);
-      }
-    }
-    filesOutsideEnvDirectory = newFilesOutsideEnvDirectory;
-    changes.push({
-      event,
-      filename: relativePathToChangeTarget
-    });
-    for (const dependentPath of resolveDependentsOf(pathToChangeTarget)) {
-      changes.push({
-        event: "change",
-        filename: path6.relative(absolutePathToEnvDirectory, dependentPath)
-      });
-    }
-    reload();
-  });
-  return watcher;
+const setupHotreloading = async ({ devServer: devServer$1, envDirRelativePath, envDirAbsolutePaths, envFilePaths, verbose }) => {
+	if (verbose) logger.start("Initializing socket.io server for hot reloading...");
+	let clients = [];
+	new Server(devServer$1).on("connection", (client) => {
+		if (verbose) logger.debug("Client connected to hot reload socket");
+		clients.push(client);
+		client.on("disconnect", () => {
+			if (verbose) logger.debug("Client disconnected from hot reload socket");
+			clients = clients.filter((item) => item !== client);
+		});
+	});
+	let changes = [];
+	const reload = debounce(() => {
+		if (verbose) logger.debug("Emitting reload event to", clients.length, "clients", changes);
+		clients.forEach((client) => {
+			client.emit("reload", changes.filter((change) => path.resolve(absolutePathToEnvDirectory, change.filename).startsWith(absolutePathToEnvDirectory)));
+		});
+		changes = [];
+	}, 150);
+	const absolutePathToEnvDirectory = path.resolve(process.cwd(), envDirRelativePath);
+	const [dependencyGraph, updateDependencyGraph, { resolveDependentsOf }] = await createDependencyGraph(absolutePathToEnvDirectory);
+	if (verbose) logger.info("Dependency graph created", {
+		modules: Object.keys(dependencyGraph).length,
+		root: absolutePathToEnvDirectory
+	});
+	const watcher = await createEnvWatcher(absolutePathToEnvDirectory);
+	const existingExtraEnvFiles = (envFilePaths.length ? envFilePaths : envDirAbsolutePaths.flatMap((dir) => [...FILES[Environment.DEVELOPMENT], ...FILES[Environment.PRODUCTION]].map((file) => path.join(dir, file)))).filter((filePath) => fs.existsSync(filePath));
+	const getFilesOutsideEnvDirectory = () => Object.keys(dependencyGraph).filter((p) => path.relative(absolutePathToEnvDirectory, p).startsWith(".."));
+	let filesOutsideEnvDirectory = getFilesOutsideEnvDirectory();
+	addExternalFilesToWatcher(watcher, [...filesOutsideEnvDirectory, ...existingExtraEnvFiles]);
+	attachShutdownHandlers(watcher, verbose);
+	watcher.on("all", async (event, relativePathToChangeTarget) => {
+		if (verbose) logger.debug("File system event", {
+			event,
+			file: relativePathToChangeTarget
+		});
+		if (relativePathToChangeTarget.split(path.sep).length === 0) return;
+		const pathToChangeTarget = path.resolve(absolutePathToEnvDirectory, relativePathToChangeTarget);
+		await updateDependencyGraph(event, pathToChangeTarget);
+		const newFilesOutsideEnvDirectory = getFilesOutsideEnvDirectory();
+		for (const p of filesOutsideEnvDirectory) if (!newFilesOutsideEnvDirectory.includes(p)) watcher.unwatch(p);
+		for (const p of newFilesOutsideEnvDirectory) if (!filesOutsideEnvDirectory.includes(p) && !isPathInIgnoredDir(p)) watcher.add(p);
+		filesOutsideEnvDirectory = newFilesOutsideEnvDirectory;
+		changes.push({
+			event,
+			filename: relativePathToChangeTarget
+		});
+		for (const dependentPath of resolveDependentsOf(pathToChangeTarget)) changes.push({
+			event: "change",
+			filename: path.relative(absolutePathToEnvDirectory, dependentPath)
+		});
+		reload();
+	});
+	return watcher;
 };
 
-// src/cli/commands/dev.ts
-var dev = async ({ dir: envDirRelativePath, port, verbose }) => {
-  try {
-    if (verbose) {
-      logger.debug("Starting dev command...", {
-        cwd: process.cwd(),
-        dir: envDirRelativePath,
-        port
-      });
-    }
-    if (!fs4.existsSync(envDirRelativePath)) {
-      logger.error(`Missing ${envDirRelativePath} folder!`);
-      process.exit(1);
-    }
-    const devServer2 = await startDevServer({
-      envDirRelativePath,
-      staticBaseDirRelativePath: envDirRelativePath,
-      port: Number.parseInt(port),
-      verbose
-    });
-    if (verbose) {
-      logger.start("Dev server started, setting up hot reloading...");
-    }
-    await setupHotreloading({
-      devServer: devServer2,
-      envDirRelativePath,
-      verbose
-    });
-    if (verbose) {
-      logger.success("Hot reloading setup complete");
-    }
-  } catch (error) {
-    logger.error(new Error("Error while running dev!"), error);
-    process.exit(1);
-  }
+//#endregion
+//#region src/cli/commands/dev.ts
+const WORKSPACE_ROOT_FILE_MARKERS = [
+	"pnpm-workspace.yaml",
+	"turbo.json",
+	"nx.json",
+	"lerna.json",
+	"rush.json",
+	"WORKSPACE",
+	"WORKSPACE.bazel"
+];
+const findWorkspaceRoot = (startDir) => {
+	const readPackageJson = (candidateDir) => {
+		try {
+			const packageJsonPath = path.join(candidateDir, "package.json");
+			if (!fs.existsSync(packageJsonPath)) return null;
+			const raw = fs.readFileSync(packageJsonPath, "utf8");
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	};
+	const hasWorkspacePackageJson = (candidateDir) => {
+		const parsed = readPackageJson(candidateDir);
+		return Boolean(parsed?.workspaces);
+	};
+	const hasWorkspaceMarkers = (candidateDir) => WORKSPACE_ROOT_FILE_MARKERS.some((marker) => fs.existsSync(path.join(candidateDir, marker))) || hasWorkspacePackageJson(candidateDir);
+	const hasMonorepoFolderHints = (candidateDir) => {
+		const hasApps = fs.existsSync(path.join(candidateDir, "apps"));
+		const hasPackages = fs.existsSync(path.join(candidateDir, "packages"));
+		const packageJson = readPackageJson(candidateDir);
+		return (hasApps || hasPackages) && Boolean(packageJson?.private ?? false);
+	};
+	let currentDir = startDir;
+	let bestCandidate = null;
+	while (true) {
+		if (hasWorkspaceMarkers(currentDir)) return currentDir;
+		if (hasMonorepoFolderHints(currentDir)) bestCandidate = currentDir;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir || fs.existsSync(path.join(currentDir, ".git")) || fs.existsSync(path.join(currentDir, "node_modules"))) return bestCandidate ?? startDir;
+		currentDir = parentDir;
+	}
+};
+const uniquePaths = (paths) => {
+	const seen = /* @__PURE__ */ new Set();
+	return paths.filter((candidate) => {
+		const normalized = path.normalize(candidate);
+		if (seen.has(normalized)) return false;
+		seen.add(normalized);
+		return true;
+	});
+};
+const dev = async ({ dir: envDirRelativePath, config, env, cascade = false, port, verbose }) => {
+	try {
+		if (verbose) logger.debug("Starting dev command...", {
+			cwd: process.cwd(),
+			dir: envDirRelativePath,
+			config,
+			env,
+			cascade,
+			port
+		});
+		const cwd = process.cwd();
+		const resolveFromCwd = (targetPath) => path.isAbsolute(targetPath) ? targetPath : path.resolve(cwd, targetPath);
+		const workspaceRoot = findWorkspaceRoot(cwd);
+		let envFilePaths = [];
+		let envDirPaths = [];
+		let primaryEnvDir = cwd;
+		if (env) {
+			const resolvedEnvPath = resolveFromCwd(env);
+			if (!fs.existsSync(resolvedEnvPath)) {
+				logger.error(`Missing ${resolvedEnvPath} path!`);
+				process.exit(1);
+			}
+			if (fs.statSync(resolvedEnvPath).isFile()) {
+				envFilePaths = [resolvedEnvPath];
+				primaryEnvDir = path.dirname(resolvedEnvPath);
+			} else {
+				envDirPaths = [resolvedEnvPath];
+				primaryEnvDir = resolvedEnvPath;
+			}
+		} else if (cascade) {
+			envDirPaths = uniquePaths([workspaceRoot, cwd]);
+			primaryEnvDir = envDirPaths[envDirPaths.length - 1] ?? cwd;
+		} else {
+			const resolvedDir = resolveFromCwd(envDirRelativePath);
+			envDirPaths = [resolvedDir];
+			primaryEnvDir = resolvedDir;
+		}
+		const resolvedEnvDirRelativePath = path.relative(cwd, primaryEnvDir) || ".";
+		if (!fs.existsSync(primaryEnvDir)) {
+			logger.error(`Missing ${primaryEnvDir} folder!`);
+			process.exit(1);
+		}
+		const resolveConfigPath = () => {
+			if (config) return resolveFromCwd(config);
+			if (!cascade) return path.join(primaryEnvDir, "env.config.ts");
+			return uniquePaths([path.join(primaryEnvDir, "env.config.ts"), path.join(workspaceRoot, "env.config.ts")]).find((candidate) => fs.existsSync(candidate));
+		};
+		const resolvedConfigPath = resolveConfigPath();
+		if (!resolvedConfigPath || !fs.existsSync(resolvedConfigPath)) {
+			logger.error("Missing env.config.ts file!");
+			process.exit(1);
+		}
+		const devServer$1 = await startDevServer({
+			envDirRelativePath: resolvedEnvDirRelativePath,
+			staticBaseDirRelativePath: resolvedEnvDirRelativePath,
+			envDirAbsolutePaths: envDirPaths.length ? envDirPaths : [primaryEnvDir],
+			envFilePaths,
+			envConfigPath: resolvedConfigPath,
+			port: Number.parseInt(port),
+			verbose
+		});
+		if (verbose) logger.start("Dev server started, setting up hot reloading...");
+		await setupHotreloading({
+			devServer: devServer$1,
+			envDirRelativePath: resolvedEnvDirRelativePath,
+			envDirAbsolutePaths: envDirPaths.length ? envDirPaths : [primaryEnvDir],
+			envFilePaths,
+			verbose
+		});
+		if (verbose) logger.success("Hot reloading setup complete");
+	} catch (error) {
+		logger.error(/* @__PURE__ */ new Error("Error while running dev!"), error);
+		process.exit(1);
+	}
 };
 
-// src/cli/index.ts
-var PACKAGE_NAME = "@envin/cli";
-program.name(PACKAGE_NAME).description(
-  "A live preview of your environment variables right in your browser"
-).version(package_default.version);
-program.command("dev").description("Starts the live preview of your environment variables").option(
-  "-d, --dir <path>",
-  "Directory with your envin configuration and .env files",
-  "./"
-).option("-p --port <port>", "Port to run dev server on", "3000").option("-v, --verbose", "Enable verbose logging", false).action(dev);
+//#endregion
+//#region src/cli/index.ts
+program.name("@envin/cli").description("A live preview of your environment variables right in your browser").version(version);
+program.command("dev").description("Starts the live preview of your environment variables").option("-d, --dir <path>", "Directory with your envin configuration and .env files", "./").option("-c, --config <path>", "Path to env.config.ts").option("-e, --env <path>", "Path to .env file or directory").option("--cascade", "Enable workspace env/config cascading", false).option("-p --port <port>", "Port to run dev server on", "3000").option("-v, --verbose", "Enable verbose logging", false).action(dev);
 program.parse();
+
+//#endregion
+export {  };