@envin/cli 0.0.1 → 1.1.1

package/dist/cli/index.mjs

@@ -6,7 +6,8 @@ import { program } from "commander";
 // package.json
 var package_default = {
   name: "@envin/cli",
-  version: "0.0.1",
+  version: "1.1.1",
+  description: "Type-safe env validation with live previews",
   keywords: [
     "turbostarter",
     "environment variables",
@@ -15,6 +16,10 @@ var package_default = {
     "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",
@@ -32,7 +37,8 @@ var package_default = {
     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"
+    typecheck: "tsc --noEmit",
+    prepack: "bun ../../scripts/replace-workspace-protocol.ts && bun ../../scripts/populate-readme.ts"
   },
   dependencies: {
     "@babel/parser": "^7.27.0",
@@ -47,16 +53,21 @@ var package_default = {
     "@radix-ui/react-tooltip": "^1.2.4",
     "@svgr/webpack": "^8.1.0",
     chalk: "^5.4.1",
+    chokidar: "^4.0.3",
     commander: "^13.1.0",
+    debounce: "^2.2.0",
     dotenv: "^16.5.0",
     envin: "workspace:*",
     esbuild: "^0.25.0",
     "log-symbols": "^7.0.0",
     "mime-types": "^3.0.1",
-    next: "^15.3.1",
+    next: "^15.3.3",
     ora: "^8.2.0",
     "react-hook-form": "^7.56.4",
-    zod: "^3.25.17"
+    "socket.io": "^4.8.1",
+    "socket.io-client": "^4.8.1",
+    "tsconfig-paths": "^4.2.0",
+    zod: "^3.25.56"
   },
   devDependencies: {
     "@babel/core": "7.26.10",
@@ -90,45 +101,17 @@ var package_default = {
 };
 
 // src/cli/commands/dev.ts
-import fs2 from "fs";
+import fs3 from "fs";
 
-// src/cli/utils/preview/serve-static-file.ts
-import { existsSync, promises as fs } from "fs";
-import path from "path";
-import { lookup } from "mime-types";
-var 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 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, "");
-      console.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/hot-reload/setup-hot-reloading.ts
+import path6 from "path";
+import { watch } from "chokidar";
+import debounce from "debounce";
+import { Server as SocketServer } from "socket.io";
+
+// 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";
@@ -165,16 +148,54 @@ var registerSpinnerAutostopping = (spinner) => {
 };
 
 // src/cli/utils/preview/get-env-variables.ts
-import path2 from "path";
+import path from "path";
 var getEnvVariablesForPreviewApp = (relativePathToEnvDirectory, cwd) => {
   return {
     ENV_DIR_RELATIVE_PATH: relativePathToEnvDirectory,
-    ENV_DIR_ABSOLUTE_PATH: path2.resolve(cwd, relativePathToEnvDirectory),
+    ENV_DIR_ABSOLUTE_PATH: path.resolve(cwd, relativePathToEnvDirectory),
     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, "");
+      console.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) => {
@@ -194,7 +215,7 @@ 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 (emailsDirRelativePath, staticBaseDirRelativePath, port) => {
+var startDevServer = async (envDirRelativePath, staticBaseDirRelativePath, port) => {
   devServer = http.createServer((req, res) => {
     if (!req.url) {
       res.end(404);
@@ -234,7 +255,7 @@ var startDevServer = async (emailsDirRelativePath, staticBaseDirRelativePath, po
       ` ${logSymbols2.warning} Port ${port} is already in use, trying ${nextPortToTry}`
     );
     return startDevServer(
-      emailsDirRelativePath,
+      envDirRelativePath,
       staticBaseDirRelativePath,
       nextPortToTry
     );
@@ -259,7 +280,7 @@ var startDevServer = async (emailsDirRelativePath, staticBaseDirRelativePath, po
     NODE_ENV: "development",
     ...process.env,
     ...getEnvVariablesForPreviewApp(
-      path3.normalize(emailsDirRelativePath),
+      path3.normalize(envDirRelativePath),
       process.cwd()
     )
   };
@@ -317,19 +338,403 @@ process.on(
   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;
+};
+
+// 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;
+};
+
+// 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;
+};
+var isJavascriptModule = (filePath) => {
+  const extensionName = path5.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`;
+  }
+};
+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) {
+            console.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) {
+          console.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;
+      }
+    }
+  ];
+};
+
+// src/cli/utils/hot-reload/setup-hot-reloading.ts
+var setupHotreloading = async (devServer2, envDirRelativePath) => {
+  let clients = [];
+  const io = new SocketServer(devServer2);
+  io.on("connection", (client) => {
+    clients.push(client);
+    client.on("disconnect", () => {
+      clients = clients.filter((item) => item !== client);
+    });
+  });
+  let changes = [];
+  const reload = debounce(() => {
+    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);
+  const watcher = watch("", {
+    ignoreInitial: true,
+    cwd: absolutePathToEnvDirectory
+  });
+  const getFilesOutsideEnvDirectory = () => Object.keys(dependencyGraph).filter(
+    (p) => path6.relative(absolutePathToEnvDirectory, p).startsWith("..")
+  );
+  let filesOutsideEnvDirectory = getFilesOutsideEnvDirectory();
+  for (const p of filesOutsideEnvDirectory) {
+    watcher.add(p);
+  }
+  const exit = async () => {
+    await watcher.close();
+  };
+  process.on("SIGINT", exit);
+  process.on("uncaughtException", exit);
+  watcher.on("all", async (event, 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)) {
+        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;
+};
+
 // src/cli/commands/dev.ts
-var dev = async ({ dir: emailsDirRelativePath, port }) => {
+var dev = async ({ dir: envDirRelativePath, port }) => {
   try {
-    if (!fs2.existsSync(emailsDirRelativePath)) {
-      console.error(`Missing ${emailsDirRelativePath} folder`);
+    if (!fs3.existsSync(envDirRelativePath)) {
+      console.error(`Missing ${envDirRelativePath} folder`);
       process.exit(1);
     }
-    const _devServer = await startDevServer(
-      emailsDirRelativePath,
-      emailsDirRelativePath,
-      // defaults to ./emails/static for the static files that are served to the preview
+    const devServer2 = await startDevServer(
+      envDirRelativePath,
+      envDirRelativePath,
       Number.parseInt(port)
     );
+    await setupHotreloading(devServer2, envDirRelativePath);
   } catch (error) {
     console.log(error);
     process.exit(1);
@@ -341,5 +746,9 @@ 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 email templates", "./").option("-p --port <port>", "Port to run dev server on", "3000").action(dev);
+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").action(dev);
 program.parse();

package/dist/preview/.next/BUILD_ID

@@ -1 +1 @@
-v9TlUn5liPNhAPJYeB3QH
+ti02qYR7TtWD2j2orEzoT

package/dist/preview/.next/app-build-manifest.json

@@ -1,27 +1,27 @@
 {
   "pages": {
     "/_not-found/page": [
-      "static/chunks/webpack-e84142516ca52ef7.js",
+      "static/chunks/webpack-464ea5083b838c17.js",
       "static/chunks/87c73c54-a773d57d245aca41.js",
       "static/chunks/315-850927f416f0524a.js",
       "static/chunks/main-app-fd962d6f95339794.js",
       "static/chunks/app/_not-found/page-60c07ed561e86dd9.js"
     ],
     "/layout": [
-      "static/chunks/webpack-e84142516ca52ef7.js",
+      "static/chunks/webpack-464ea5083b838c17.js",
       "static/chunks/87c73c54-a773d57d245aca41.js",
       "static/chunks/315-850927f416f0524a.js",
       "static/chunks/main-app-fd962d6f95339794.js",
-      "static/css/6842db20c57f3076.css",
+      "static/css/8b2927e38b2520cf.css",
       "static/chunks/app/layout-199c3536e64e10fd.js"
     ],
     "/page": [
-      "static/chunks/webpack-e84142516ca52ef7.js",
+      "static/chunks/webpack-464ea5083b838c17.js",
       "static/chunks/87c73c54-a773d57d245aca41.js",
       "static/chunks/315-850927f416f0524a.js",
       "static/chunks/main-app-fd962d6f95339794.js",
-      "static/chunks/174-5a80ff32c1746c12.js",
-      "static/chunks/app/page-5dac690b5d4c8e8b.js"
+      "static/chunks/985-f32f025f8cdc74d3.js",
+      "static/chunks/app/page-781d5c4076d3b10d.js"
     ]
   }
 }

package/dist/preview/.next/build-manifest.json

@@ -5,11 +5,11 @@
   "devFiles": [],
   "ampDevFiles": [],
   "lowPriorityFiles": [
-    "static/v9TlUn5liPNhAPJYeB3QH/_buildManifest.js",
-    "static/v9TlUn5liPNhAPJYeB3QH/_ssgManifest.js"
+    "static/ti02qYR7TtWD2j2orEzoT/_buildManifest.js",
+    "static/ti02qYR7TtWD2j2orEzoT/_ssgManifest.js"
   ],
   "rootMainFiles": [
-    "static/chunks/webpack-e84142516ca52ef7.js",
+    "static/chunks/webpack-464ea5083b838c17.js",
     "static/chunks/87c73c54-a773d57d245aca41.js",
     "static/chunks/315-850927f416f0524a.js",
     "static/chunks/main-app-fd962d6f95339794.js"
@@ -17,13 +17,13 @@
   "rootMainFilesTree": {},
   "pages": {
     "/_app": [
-      "static/chunks/webpack-e84142516ca52ef7.js",
+      "static/chunks/webpack-464ea5083b838c17.js",
       "static/chunks/framework-82b0332477a76245.js",
       "static/chunks/main-c9e901861bf9798e.js",
       "static/chunks/pages/_app-a48f070af90c9683.js"
     ],
     "/_error": [
-      "static/chunks/webpack-e84142516ca52ef7.js",
+      "static/chunks/webpack-464ea5083b838c17.js",
       "static/chunks/framework-82b0332477a76245.js",
       "static/chunks/main-c9e901861bf9798e.js",
       "static/chunks/pages/_error-b8c2e08355edc3b4.js"