@docsalot/previewing 0.1.0-beta.1 → 0.1.0-beta.10

package/README.md

@@ -1,17 +1,13 @@
-# @mintlify/previewing
+# @docsalot/previewing
 
-Preview Mintlify docs locally.
+Preview DocsALot docs locally.
 
-## 🚀 Installation
+## Installation
 
-```
-npm install @mintlify/previewing
+```bash
+npm install @docsalot/previewing
 ```
 
 ## Community
 
-Join our Discord community if you have questions or just want to chat:
-
-[![](https://dcbadge.vercel.app/api/server/ACREKdwjG5)](https://discord.gg/ACREKdwjG5)
-
-_Built with 💚 by the Mintlify community._
+Discord: https://discord.gg/Dp6EpTv4BU

package/dist/constants.d.ts

@@ -1,7 +1,8 @@
-export declare const TARGET_MINT_VERSION = "v0.0.9";
+export declare const TARGET_CLIENT_VERSION = "v0.1.0-runtime.1";
 export declare const INSTALL_PATH: string;
+export declare const BUNDLED_CLIENT_TARBALL_PATH: string;
 export declare const HOME_DIR: string;
-export declare const DOT_MINTLIFY: string;
+export declare const DOT_DOCSALOT: string;
 export declare const VERSION_PATH: string;
 export declare const CLIENT_PATH: string;
 export declare const MINT_PATH: string;

package/dist/constants.js

@@ -3,19 +3,18 @@
 import path from "path";
 import * as url from "url";
 import os from "os";
-// Change this to bump to a newer version of mint's client
-export const TARGET_MINT_VERSION = "v0.0.9";
+// Change this to bump to a newer version of the bundled client.
+export const TARGET_CLIENT_VERSION = "v0.1.0-runtime.1";
 // package installation location
 export const INSTALL_PATH = url.fileURLToPath(new URL(".", import.meta.url));
+export const BUNDLED_CLIENT_TARBALL_PATH = path.join(INSTALL_PATH, "assets", "client.tar.gz");
 export const HOME_DIR = os.homedir();
-// DOT_MINTLIFY can be overridden via environment variable
-// Priority: DOCSALOT_PATH env var > hardcoded local path
-// Docker: Set DOCSALOT_PATH=/app/mint-main
-const HARDCODED_PATH = '/Users/faizank/workspace/experiments/live_projects/slashml/mint-main';
-export const DOT_MINTLIFY = process.env.DOCSALOT_PATH || HARDCODED_PATH;
-export const VERSION_PATH = path.join(DOT_MINTLIFY, "mint", "mint-version.txt");
-export const CLIENT_PATH = path.join(DOT_MINTLIFY, "client");
-export const MINT_PATH = path.join(DOT_MINTLIFY, "mint");
+// DOCSALOT_PATH can be overridden via environment variable.
+// Priority: DOCSALOT_PATH env var > ~/.docsalot
+export const DOT_DOCSALOT = process.env.DOCSALOT_PATH || path.join(HOME_DIR, ".docsalot");
+export const VERSION_PATH = path.join(DOT_DOCSALOT, "mint", "client-version.txt");
+export const CLIENT_PATH = path.join(DOT_DOCSALOT, "client");
+export const MINT_PATH = path.join(DOT_DOCSALOT, "mint");
 // command execution location
 export const CMD_EXEC_PATH = process.cwd();
 export const SUPPORTED_MEDIA_EXTENSIONS = [

package/dist/local-preview/helper-commands/installDepsCommand.js

@@ -1,11 +1,40 @@
 import shell from "shelljs";
-import { CLIENT_PATH } from "../../constants.js";
-import { buildLogger, ensureYarn } from "../../util.js";
+import fse, { pathExists } from "fs-extra";
+import { BUNDLED_CLIENT_TARBALL_PATH, CLIENT_PATH, MINT_PATH, TARGET_CLIENT_VERSION, VERSION_PATH, } from "../../constants.js";
+import { buildLogger } from "../../util.js";
+const bootstrapBundledClient = async (logger) => {
+    if (!(await pathExists(BUNDLED_CLIENT_TARBALL_PATH))) {
+        logger.fail(`Bundled client tarball is missing at: ${BUNDLED_CLIENT_TARBALL_PATH}`);
+        process.exit(1);
+    }
+    await fse.ensureDir(CLIENT_PATH);
+    logger.text = "Extracting bundled DocsALot client...";
+    const untarResult = shell.exec(`tar -xzf "${BUNDLED_CLIENT_TARBALL_PATH}" -C "${CLIENT_PATH}" --strip-components 1`, { silent: true });
+    if (untarResult.code !== 0) {
+        logger.fail("Failed to extract bundled DocsALot client.");
+        process.exit(1);
+    }
+    fse.writeFileSync(VERSION_PATH, TARGET_CLIENT_VERSION);
+};
+const shouldBootstrapClient = async () => {
+    const clientExists = await pathExists(CLIENT_PATH);
+    if (!clientExists)
+        return true;
+    if (!(await pathExists(VERSION_PATH)))
+        return true;
+    const installedVersion = fse.readFileSync(VERSION_PATH, "utf8").trim();
+    return installedVersion !== TARGET_CLIENT_VERSION;
+};
 const installDeps = async () => {
-    const logger = buildLogger("");
-    ensureYarn(logger);
-    shell.cd(CLIENT_PATH);
-    shell.exec("yarn");
-    logger.succeed("Dependencies installed.");
+    const logger = buildLogger("Preparing local DocsALot runtime...");
+    await fse.ensureDir(MINT_PATH);
+    const needsBootstrap = await shouldBootstrapClient();
+    if (needsBootstrap) {
+        await fse.remove(CLIENT_PATH);
+        await bootstrapBundledClient(logger);
+        logger.succeed("DocsALot runtime installed.");
+        return;
+    }
+    logger.succeed("DocsALot runtime already installed.");
 };
 export default installDeps;

package/dist/local-preview/helper-commands/syncLocalContentCommand.d.ts

@@ -0,0 +1,2 @@
+declare const syncLocalContentCommand: () => Promise<void>;
+export default syncLocalContentCommand;

package/dist/local-preview/helper-commands/syncLocalContentCommand.js

@@ -0,0 +1,75 @@
+import Chalk from "chalk";
+import mintValidation from "@docsalot/validation";
+import fse from "fs-extra";
+import path from "path";
+import { promises as _promises } from "fs";
+import { CLIENT_PATH, CMD_EXEC_PATH } from "../../constants.js";
+import { categorizeFiles } from "../listener/categorize.js";
+import { generateNav } from "../listener/generate.js";
+import { isFileSizeValid } from "../listener/utils.js";
+import createPage from "../listener/utils/createPage.js";
+import { getConfigPath } from "../listener/utils/mintConfigFile.js";
+const { readFile } = _promises;
+const PROPS_PATH = path.join(CLIENT_PATH, "src", "_props");
+const PUBLIC_PATH = path.join(CLIENT_PATH, "public");
+const writePages = async (contentFilenames, openApiFiles) => {
+    const writes = contentFilenames.map(async (filename) => {
+        const sourcePath = path.join(CMD_EXEC_PATH, filename);
+        const targetPath = path.join(PROPS_PATH, filename);
+        const contentStr = (await readFile(sourcePath)).toString();
+        const { pageContent } = await createPage(filename, contentStr, CMD_EXEC_PATH, openApiFiles);
+        await fse.outputFile(targetPath, pageContent, { flag: "w" });
+    });
+    await Promise.all(writes);
+};
+const writeSnippets = async (snippets) => {
+    const writes = snippets.map(async (filename) => {
+        const sourcePath = path.join(CMD_EXEC_PATH, filename);
+        const targetPath = path.join(PROPS_PATH, filename);
+        await fse.copy(sourcePath, targetPath);
+    });
+    await Promise.all(writes);
+};
+const writeStaticFiles = async (staticFilenames) => {
+    for (const filename of staticFilenames) {
+        const sourcePath = path.join(CMD_EXEC_PATH, filename);
+        if (!(await isFileSizeValid(sourcePath, 5))) {
+            console.error(Chalk.red(`🚨 The file at ${filename} is too big. The maximum file size is 5 mb.`));
+            continue;
+        }
+        const targetPath = path.join(PUBLIC_PATH, filename);
+        await fse.copy(sourcePath, targetPath);
+    }
+};
+const copyAndValidateLayout = async () => {
+    const configPath = await getConfigPath(CMD_EXEC_PATH);
+    if (configPath == null) {
+        throw new Error("Could not find layout.json in the docs directory.");
+    }
+    const rawConfig = (await readFile(configPath)).toString();
+    const config = JSON.parse(rawConfig);
+    const { status, errors, warnings } = mintValidation.validateMintConfig(config);
+    errors.forEach((error) => {
+        console.error(`🚨 ${Chalk.red(error)}`);
+    });
+    warnings.forEach((warning) => {
+        console.warn(`⚠️ ${Chalk.yellow(warning)}`);
+    });
+    if (status !== "success") {
+        throw new Error("layout.json is invalid. Fix validation errors and try again.");
+    }
+    await fse.copy(configPath, path.join(PROPS_PATH, "layout.json"));
+};
+const syncLocalContentCommand = async () => {
+    await fse.ensureDir(PROPS_PATH);
+    await fse.ensureDir(PUBLIC_PATH);
+    const { contentFilenames, staticFilenames, openApiFiles, snippets } = await categorizeFiles(CMD_EXEC_PATH);
+    await copyAndValidateLayout();
+    await writePages(contentFilenames, openApiFiles);
+    await writeSnippets(snippets);
+    await writeStaticFiles(staticFilenames);
+    await fse.outputFile(path.join(PROPS_PATH, "openApiFiles.json"), JSON.stringify(openApiFiles, null, 2), { flag: "w" });
+    const generatedNav = await generateNav();
+    await fse.outputFile(path.join(PROPS_PATH, "generatedNav.json"), JSON.stringify(generatedNav, null, 2), { flag: "w" });
+};
+export default syncLocalContentCommand;

package/dist/local-preview/index.js

@@ -2,158 +2,72 @@
 import Chalk from "chalk";
 import child_process from "child_process";
 import open from "open";
-import fse, { pathExists } from "fs-extra";
-import inquirer from "inquirer";
-import { isInternetAvailable } from "is-internet-available";
-import path from "path";
+import fse from "fs-extra";
 import shell from "shelljs";
-import { Octokit } from "@octokit/rest";
-import { CLIENT_PATH, HOME_DIR, DOT_MINTLIFY, CMD_EXEC_PATH, TARGET_MINT_VERSION, VERSION_PATH, MINT_PATH, } from "../constants.js";
-import { buildLogger, ensureYarn } from "../util.js";
+import { HOME_DIR, CLIENT_PATH, CMD_EXEC_PATH, MINT_PATH, } from "../constants.js";
+import { buildLogger } from "../util.js";
 import listener from "./listener/index.js";
 import { getConfigPath } from "./listener/utils/mintConfigFile.js";
-const nodeModulesExists = async () => {
-    // return pathExists(path.join(DOT_MINTLIFY, "mint", "client", "node_modules"));
-    return pathExists(path.join(DOT_MINTLIFY, "client", "node_modules"));
-};
-const promptForYarn = async () => {
-    const yarnInstalled = shell.which("yarn");
-    if (!yarnInstalled) {
-        await inquirer
-            .prompt([
-            {
-                type: "confirm",
-                name: "confirm",
-                message: "yarn must be globally installed. Install yarn?",
-                default: true,
-            },
-        ])
-            .then(({ confirm }) => {
-            if (confirm) {
-                shell.exec("npm install --global yarn");
-            }
-            else {
-                console.log("Installation cancelled.");
-            }
-        });
-    }
-};
-const downloadTargetMint = async (logger) => {
-    fse.emptyDirSync(MINT_PATH);
-    logger.text = "Downloading Mintlify framework...";
-    const octokit = new Octokit();
-    const downloadRes = await octokit.repos.downloadTarballArchive({
-        owner: "mintlify",
-        repo: "mint",
-        ref: TARGET_MINT_VERSION,
-    });
-    logger.text = "Extracting Mintlify framework...";
-    const TAR_PATH = path.join(MINT_PATH, "mint.tar.gz");
-    fse.writeFileSync(TAR_PATH, Buffer.from(downloadRes.data));
-    // strip-components 1 removes the top level directory from the unzipped content
-    // which is a folder with the release sha
-    fse.mkdirSync(path.join(MINT_PATH, "mint-tmp"));
-    shell.exec("tar -xzf mint.tar.gz -C mint-tmp --strip-components 1", {
-        silent: true,
-    });
-    fse.removeSync(TAR_PATH);
-    fse.moveSync(path.join(MINT_PATH, "mint-tmp", "client"), path.join(CLIENT_PATH));
-    fse.writeFileSync(VERSION_PATH, TARGET_MINT_VERSION);
-    // Delete unnecessary content downloaded from GitHub
-    fse.removeSync(path.join(MINT_PATH, "mint-tmp"));
-    logger.text = "Installing dependencies...";
-    ensureYarn(logger);
-    shell.cd(CLIENT_PATH);
-    shell.exec("yarn", { silent: true });
-};
-const checkForMintJson = async (logger) => {
+import installDepsCommand from "./helper-commands/installDepsCommand.js";
+import syncLocalContentCommand from "./helper-commands/syncLocalContentCommand.js";
+const checkForLayoutJson = async (logger) => {
     const configPath = await getConfigPath(CMD_EXEC_PATH);
     if (configPath == null) {
-        logger.fail("Must be ran in a directory where a mint.json file exists.");
+        logger.fail("Must be ran in a directory where a layout.json file exists.");
         process.exit(1);
     }
     return;
 };
 const dev = async (argv) => {
-    buildLogger("DEVS");
     shell.cd(HOME_DIR);
-    await promptForYarn();
     const logger = buildLogger("Preparing local Docsalot instance...");
     await fse.ensureDir(MINT_PATH);
-    shell.cd(MINT_PATH);
-    const internet = await isInternetAvailable();
-    if (!internet && !(await pathExists(CLIENT_PATH))) {
-        logger.fail("Running mintlify dev for the first time requires an internet connection.");
-        process.exit(1);
-    }
-    // if (internet) {
-    //   const mintVersionExists = await pathExists(VERSION_PATH);
-    //   let needToDownloadTargetMint = !mintVersionExists;
-    //   if (mintVersionExists) {
-    //     const currVersion = fse.readFileSync(VERSION_PATH, "utf8");
-    //     if (currVersion !== TARGET_MINT_VERSION) {
-    //       needToDownloadTargetMint = true;
-    //     }
-    //   }
-    //   if (needToDownloadTargetMint) {
-    //     await downloadTargetMint(logger);
-    //   }
-    // }
-    if (!(await nodeModulesExists())) {
-        if (!internet) {
-            logger.fail(`Dependencies are missing and you are offline. Connect to the internet and run
-  
-      mintlify install
-      
-      `);
-        }
-        else {
-            logger.fail(`Dependencies were not installed correctly, run
-  
-      mintlify install
-      
-      `);
-        }
-        process.exit(1);
-    }
-    await checkForMintJson(logger);
-    shell.cd(CLIENT_PATH);
-    const relativePath = path.relative(CLIENT_PATH, CMD_EXEC_PATH);
-    child_process.spawnSync("yarn preconfigure", [relativePath], { shell: true });
+    await installDepsCommand();
+    await checkForLayoutJson(logger);
+    logger.text = "Syncing docs content into local runtime...";
+    await syncLocalContentCommand();
     logger.succeed("Local instance is ready. Launching your site...");
     run(argv.port || "3000");
 };
 const run = (port) => {
     shell.cd(CLIENT_PATH);
-    console.log("CLIENT PATH", CLIENT_PATH);
-    // For Cloud Run/Docker, use dev-host (binds to 0.0.0.0, no file watching)
-    // For local development, use dev-watch (binds to localhost, with file watching)
-    const isProduction = process.env.BIND_ALL_INTERFACES === "true";
-    const devScript = isProduction ? "npm run dev-host" : "npm run dev-watch";
-    const mintlifyDevProcess = child_process.spawn(devScript, {
+    const host = process.env.BIND_ALL_INTERFACES === "true" ? "0.0.0.0" : "127.0.0.1";
+    const localAdminToken = process.env.ADMIN_TOKEN || "__docsalot_local_preview__";
+    process.env.ADMIN_TOKEN = localAdminToken;
+    process.env.DOCSALOT_LOCAL_PREVIEW = "true";
+    let browserOpened = false;
+    const docsalotDevProcess = child_process.spawn("node server.js", {
         env: {
             ...process.env,
             PORT: port,
+            HOSTNAME: host,
+            NODE_ENV: "production",
+            ADMIN_TOKEN: localAdminToken,
+            DOCSALOT_LOCAL_PREVIEW: "true",
         },
         cwd: CLIENT_PATH,
         stdio: "pipe",
         shell: true,
     });
-    mintlifyDevProcess.stdout.on("data", (data) => {
+    docsalotDevProcess.stdout.on("data", (data) => {
         const output = data.toString();
         console.log(output);
-        if (output.startsWith("> Ready on http://localhost:")) {
+        if (!browserOpened &&
+            (output.includes("Ready in") ||
+                output.includes("started server") ||
+                output.includes("http://localhost:"))) {
+            browserOpened = true;
             console.log(`🌿 ${Chalk.green(`Your local preview is available at http://localhost:${port}`)}`);
             console.log(`🌿 ${Chalk.green("Press Ctrl+C any time to stop the local preview.")}`);
             open(`http://localhost:${port}`);
         }
     });
     const onExit = () => {
-        mintlifyDevProcess.kill("SIGINT");
+        docsalotDevProcess.kill("SIGINT");
         process.exit(0);
     };
     process.on("SIGINT", onExit);
     process.on("SIGTERM", onExit);
-    listener();
+    listener(port);
 };
 export default dev;

package/dist/local-preview/listener/categorize.js

@@ -3,6 +3,17 @@
 import path from "path";
 import { getFileList } from "@docsalot/prebuild";
 import { getFileExtension, openApiCheck } from "./utils.js";
+const shouldIgnorePath = (filename) => {
+    const normalized = filename.replace(/\\/g, "/").toLowerCase();
+    return (normalized.startsWith("/node_modules/") ||
+        normalized.includes("/node_modules/") ||
+        normalized.startsWith("/.git/") ||
+        normalized.includes("/.git/") ||
+        normalized.startsWith("/.next/") ||
+        normalized.includes("/.next/") ||
+        normalized.startsWith("/.docsalot/") ||
+        normalized.includes("/.docsalot/"));
+};
 export const categorizeFiles = async (contentDirectoryPath) => {
     const allFilesInCmdExecutionPath = getFileList(contentDirectoryPath);
     const contentFilenames = [];
@@ -11,6 +22,9 @@ export const categorizeFiles = async (contentDirectoryPath) => {
     const openApiFiles = [];
     const snippets = [];
     allFilesInCmdExecutionPath.forEach((filename) => {
+        if (shouldIgnorePath(filename)) {
+            return;
+        }
         promises.push((async () => {
             const extension = getFileExtension(filename);
             let isOpenApi = false;
@@ -34,7 +48,9 @@ export const categorizeFiles = async (contentDirectoryPath) => {
                     });
                 }
             }
-            else if (!filename.endsWith("mint.json") && !isOpenApi) {
+            else if (!filename.endsWith("layout.json") &&
+                !filename.endsWith("docs.json") &&
+                !isOpenApi) {
                 // all other files
                 staticFilenames.push(filename);
             }
@@ -64,7 +80,7 @@ const supportedStaticFileExtensions = [
 export const getCategory = (filePath) => {
     filePath = filePath.toLowerCase();
     const parsed = path.parse(filePath);
-    if (parsed.base === "mint.json" || parsed.base === "layout.json") {
+    if (parsed.base === "layout.json") {
         return "mintConfig";
     }
     const fileName = parsed.name;

package/dist/local-preview/listener/generate.js

@@ -27,18 +27,31 @@ const pageMetadataKeys = [
 const generateDecoratedMintNavigationFromPages = (filenamePageMetadataMap, mintConfigNav) => {
     const filenames = Object.keys(filenamePageMetadataMap);
     const createNav = (nav) => {
+        if (!nav || !Array.isArray(nav.pages)) {
+            return null;
+        }
         return {
             group: nav.group,
             version: nav?.version,
-            pages: nav.pages.map((page) => {
-                if (typeof page === "string" && filenames.includes(page)) {
-                    return filenamePageMetadataMap[page];
+            pages: nav.pages
+                .map((page) => {
+                if (typeof page === "string") {
+                    if (filenames.includes(page)) {
+                        return filenamePageMetadataMap[page];
+                    }
+                    // Keep local preview resilient when navigation references missing pages.
+                    return null;
                 }
                 return createNav(page);
-            }),
+            })
+                .filter(Boolean)
+                .map((entry) => entry),
         };
     };
-    return mintConfigNav.map((nav) => createNav(nav));
+    return (mintConfigNav || [])
+        .map((nav) => createNav(nav))
+        .filter(Boolean)
+        .map((entry) => entry);
 };
 const createFilenamePageMetadataMap = async (contentDirectoryPath, contentFilenames, openApiFiles, clientPath, writeFiles = false) => {
     let pagesAcc = {};

package/dist/local-preview/listener/index.d.ts

@@ -1,2 +1,2 @@
-declare const listener: () => void;
+declare const listener: (port?: string) => void;
 export default listener;

package/dist/local-preview/listener/index.js

@@ -1,4 +1,5 @@
 // @ts-nocheck
+import axios from "axios";
 import chokidar from "chokidar";
 import fse from "fs-extra";
 import pathUtil from "path";
@@ -11,7 +12,49 @@ import { promises as _promises } from "fs";
 import createPage from "./utils/createPage.js";
 import { getCategory } from "./categorize.js";
 const { readFile } = _promises;
-const listener = () => {
+const isLocalPreviewMode = process.env.DOCSALOT_LOCAL_PREVIEW === "true";
+const localRevalidateSecret = process.env.ADMIN_TOKEN || "__docsalot_local_preview__";
+const toPagePath = (filename) => {
+    const normalized = filename.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!normalized.endsWith(".md") && !normalized.endsWith(".mdx")) {
+        return null;
+    }
+    const withoutExtension = normalized.replace(/\.mdx?$/i, "");
+    if (withoutExtension === "index") {
+        return "/";
+    }
+    if (withoutExtension.endsWith("/index")) {
+        return "/" + withoutExtension.slice(0, -"/index".length);
+    }
+    return "/" + withoutExtension;
+};
+const getRevalidatePaths = (category, filename) => {
+    const paths = ["/"];
+    if (category === "page") {
+        const pagePath = toPagePath(filename);
+        if (pagePath) {
+            paths.push(pagePath);
+        }
+    }
+    return [...new Set(paths)];
+};
+const revalidateLocalPaths = async (port, paths) => {
+    if (!isLocalPreviewMode || !port || paths.length === 0) {
+        return;
+    }
+    for (const path of paths) {
+        try {
+            await axios.post(`http://127.0.0.1:${port}/api/revalidate`, {
+                secret: localRevalidateSecret,
+                path,
+            }, { timeout: 2000 });
+        }
+        catch {
+            // Revalidation is best-effort; avoid failing file sync when server is restarting.
+        }
+    }
+};
+const listener = (port) => {
     chokidar
         .watch(CMD_EXEC_PATH, {
         ignoreInitial: true,
@@ -38,6 +81,7 @@ const listener = () => {
                     console.log("Static file added: ", filename);
                     break;
             }
+            await revalidateLocalPaths(port, getRevalidatePaths(category, filename));
         }
         catch (error) {
             console.error(error.message);
@@ -63,6 +107,7 @@ const listener = () => {
                     console.log("Static file edited: ", filename);
                     break;
             }
+            await revalidateLocalPaths(port, getRevalidatePaths(category, filename));
         }
         catch (error) {
             console.error(error.message);
@@ -86,7 +131,7 @@ const listener = () => {
                     console.log(`Snippet deleted: ${filename}`);
                     break;
                 case "mintConfig":
-                    console.log("⚠️ mint.json deleted. Please create a new mint.json file as it is mandatory.");
+                    console.log("⚠️ layout.json deleted. Please create a new layout.json file as it is mandatory.");
                     process.exit(1);
                 case "potentialJsonOpenApiSpec":
                 case "potentialYamlOpenApiSpec":
@@ -97,6 +142,7 @@ const listener = () => {
                     console.log("Static file deleted: ", filename);
                     break;
             }
+            await revalidateLocalPaths(port, getRevalidatePaths(potentialCategory, filename));
         }
         catch (error) {
             console.error(error.message);
@@ -147,9 +193,9 @@ const onUpdateEvent = async (filename) => {
             break;
         case "mintConfig":
             regenerateNav = true;
-            const mintJsonFileContent = (await readFile(filePath)).toString();
+            const layoutJsonFileContent = (await readFile(filePath)).toString();
             try {
-                const mintConfig = JSON.parse(mintJsonFileContent);
+                const mintConfig = JSON.parse(layoutJsonFileContent);
                 const { status, errors, warnings } = mintValidation.validateMintConfig(mintConfig);
                 errors.forEach((error) => {
                     console.error(`🚨 ${Chalk.red(error)}`);
@@ -163,7 +209,7 @@ const onUpdateEvent = async (filename) => {
             }
             catch (error) {
                 if (error.name === "SyntaxError") {
-                    console.error(`🚨 ${Chalk.red("mint.json has invalid JSON. You are likely missing a comma or a bracket. You can paste your mint.json file into https://jsonlint.com/ to get a more specific error message.")}`);
+                    console.error(`🚨 ${Chalk.red("layout.json has invalid JSON. You are likely missing a comma or a bracket. You can paste your layout.json file into https://jsonlint.com/ to get a more specific error message.")}`);
                 }
                 else {
                     console.error(`🚨 ${Chalk.red(error.message)}`);

package/dist/local-preview/listener/utils/mintConfigFile.js

@@ -4,10 +4,6 @@ import pathUtil from "path";
 const { readFile } = _promises;
 // TODO: Put in prebuild package
 export const getConfigPath = async (contentDirectoryPath) => {
-    // Prefer modern config filename, but keep backward compatibility.
-    if (await pathExists(pathUtil.join(contentDirectoryPath, "mint.json"))) {
-        return pathUtil.join(contentDirectoryPath, "mint.json");
-    }
     if (await pathExists(pathUtil.join(contentDirectoryPath, "layout.json"))) {
         return pathUtil.join(contentDirectoryPath, "layout.json");
     }