@daz4126/swifty 3.1.0 → 4.1.0

package/src/pages.js

@@ -3,7 +3,6 @@ import fs from "fs/promises";
 import path from "path";
 
 import fsExtra from "fs-extra";
-import matter from "gray-matter";
 
 import { replacePlaceholders } from "./partials.js";
 import { dirs, defaultConfig, loadConfig } from "./config.js";
@@ -12,6 +11,13 @@ import { chunkPages, generatePaginationNav } from "./pagination.js";
 import { marked } from "./markdown.js";
 import { mapLimit } from "./concurrency.js";
 import { minifyHtml } from "./minify.js";
+import { parseFrontMatter } from "./frontmatter.js";
+import {
+  applyBasePathToHtml,
+  normalizePermalink,
+  routeToOutputPath,
+  withBasePath,
+} from "./urls.js";
 
 // Returns stats if valid (directory or .md file), null otherwise
 const getValidStats = async (filePath) => {
@@ -44,6 +50,67 @@ const parseDate = (dateValue) => {
   return isNaN(parsed.getTime()) ? null : parsed;
 };
 
+const applyMarkdownFileToPage = async (
+  page,
+  filePath,
+  { notFound = false, folderIndex = false } = {},
+) => {
+  let parsed;
+  try {
+    const markdownContent = await fs.readFile(filePath, "utf-8");
+    parsed = parseFrontMatter(markdownContent);
+  } catch (error) {
+    throw new Error(`Unable to parse Markdown file ${filePath}: ${error.message}`, {
+      cause: error,
+    });
+  }
+  const { data, content } = parsed;
+  Object.assign(page, { meta: { ...page.meta, ...data }, content });
+
+  if (data.permalink !== undefined) {
+    page.route = normalizePermalink(data.permalink);
+    page.url = withBasePath(page.route);
+  }
+
+  if (folderIndex) {
+    const stats = await fs.stat(filePath);
+    const { dateFormat } = page.meta;
+    page.hasIndexContent = true;
+    page.indexFilePath = filePath;
+    page.createdAtObj = stats.birthtime;
+    page.updatedAtObj = stats.mtime;
+    page.created_at = new Date(stats.birthtime).toLocaleDateString(
+      undefined,
+      dateFormat,
+    );
+    page.updated_at = new Date(stats.mtime).toLocaleDateString(
+      undefined,
+      dateFormat,
+    );
+    page.date = new Date(stats.birthtime).toLocaleDateString(undefined, dateFormat);
+  }
+
+  if (notFound && data.sitemap === undefined) {
+    page.meta.sitemap = false;
+  }
+
+  page.title = page.meta.title || page.title;
+  page.name = page.meta.title || page.name;
+
+  if (typeof data.nav === "boolean") {
+    page.nav = data.nav;
+  }
+
+  if (data.date) {
+    const parsedDate = parseDate(data.date);
+    if (parsedDate) {
+      page.dateObj = parsedDate;
+      page.date = parsedDate.toLocaleDateString(undefined, page.meta.dateFormat);
+      page.meta.date = page.date;
+    }
+  }
+};
+
 const tagsMap = new Map();
 const pageIndex = [];
 const pageIndexUrls = new Set();
@@ -78,6 +145,8 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
       files,
       async (file) => {
         const filePath = path.join(sourceDir, file.name);
+        if (parent && file.name === "index.md") return null;
+
         const stats = await getValidStats(filePath);
         if (!stats) return null;
 
@@ -98,13 +167,15 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
             ? parent.layout
             : config.default_layout_name;
 
+        const route = root ? "/" : finalPath;
         const page = {
           name,
           root,
           layout,
           filePath,
           filename: file.name.replace(/\.md$/, ""),
-          url: root ? "/" : finalPath,
+          route,
+          url: withBasePath(route),
           nav: !parent && !root && !notFound,
           parent: parent
             ? { title: parent.meta.title, url: parent.url }
@@ -130,28 +201,11 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
         };
 
         if (path.extname(file.name) === ".md") {
-          const markdownContent = await fs.readFile(filePath, "utf-8");
-          const { data, content } = matter(markdownContent);
-          Object.assign(page, { meta: { ...page.meta, ...data }, content });
-          if (notFound && data.sitemap === undefined) {
-            page.meta.sitemap = false;
-          }
-          page.title = page.meta.title || page.title;
-          page.name = page.meta.title || page.name;
-
-          // Allow front matter to override nav (opt in or opt out)
-          if (typeof data.nav === "boolean") {
-            page.nav = data.nav;
-          }
-
-          // If front matter has a date, parse and format it
-          if (data.date) {
-            const parsedDate = parseDate(data.date);
-            if (parsedDate) {
-              page.dateObj = parsedDate;
-              page.date = parsedDate.toLocaleDateString(undefined, dateFormat);
-              page.meta.date = page.date;
-            }
+          await applyMarkdownFileToPage(page, filePath, { notFound });
+        } else if (isDirectory) {
+          const indexPath = path.join(filePath, "index.md");
+          if (await fsExtra.pathExists(indexPath)) {
+            await applyMarkdownFileToPage(page, indexPath, { folderIndex: true });
           }
         }
 
@@ -178,11 +232,11 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
 
         // Load folder's own config for pagination settings
         const dirConfig = await loadConfig(page.filePath);
-        const mergedConfig = { 
-          ...page.meta, 
+        const mergedConfig = {
           ...dirConfig,
+          ...page.meta,
           // Only set default page_count if explicitly specified in either page meta or dir config
-          page_count: dirConfig.page_count || page.meta.page_count
+          page_count: page.meta.page_count ?? dirConfig.page_count,
         };
         page.meta = mergedConfig;
 
@@ -208,7 +262,9 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
           page.visiblePages = chunks[0];
 
           // First page content
-          page.content = await generateLinkList(page.filename, chunks[0]);
+          if (!page.hasIndexContent) {
+            page.content = await generateLinkList(page.filename, chunks[0]);
+          }
           page.meta.pagination = generatePaginationNav({
             currentPage: 1,
             totalPages,
@@ -223,6 +279,7 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
             const paginatedPage = {
               name: `${page.name} - Page ${pageNum}`,
               title: `${page.meta.title || page.name} - Page ${pageNum}`,
+              route: `${page.route}/page/${pageNum}`,
               url: `${page.url}/page/${pageNum}`,
               folder: false,
               layout: page.layout,
@@ -242,7 +299,9 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
             page.paginatedPages.push(paginatedPage);
           }
         } else {
-          page.content = await generateLinkList(page.filename, page.pages);
+          if (!page.hasIndexContent) {
+            page.content = await generateLinkList(page.filename, page.pages);
+          }
           page.meta.pagination = '';
         }
       }
@@ -258,15 +317,18 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
         pageIndex.push({ url: page.url, title: page.title, nav: page.nav });
       }
     }, getBuildConcurrency());
-  } catch (err) {
-    console.error("Error reading directory:", err);
+  } catch (error) {
+    throw new Error(`Unable to generate pages from ${sourceDir}: ${error.message}`, {
+      cause: error,
+    });
   }
 
   // Make Tags page
   if (!parent && tagsMap.size) {
     const tagLayout = await fsExtra.pathExists(`${dirs.layouts}/tags.html`);
     const tagPage = {
-      url: "/tags",
+      route: "/tags",
+      url: withBasePath("/tags"),
       nav: false,
       folder: true,
       name: "Tags",
@@ -281,6 +343,7 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
     };
 
     for (const [tag, pagesForTag] of tagsMap) {
+      const route = `/tags/${tag}`;
       const page = {
         name: tag,
         title: tag,
@@ -288,7 +351,8 @@ const generatePages = async (sourceDir, baseDir = sourceDir, parent) => {
           undefined,
           defaultConfig.dateFormat,
         ),
-        url: `/tags/${tag}`,
+        route,
+        url: withBasePath(route),
         layout: tagLayout ? "tags" : defaultConfig.default_layout_name,
         meta: { ...config, title: `Pages tagged with ${capitalize(tag)}` },
       };
@@ -335,17 +399,23 @@ const generateLinkList = async (name, pages) => {
 };
 
 const render = async (page) => {
-  const replacedContent = await replacePlaceholders(page.content, page);
-  const htmlContent = marked.parse(replacedContent); // Markdown processed once
-  const wrappedContent = await applyLayoutAndWrapContent(page, htmlContent);
-  // Use function to avoid $` special replacement patterns in content
-  const template = await getTemplate();
-  const htmlWithTemplate = template.replace(
-    /<%=\s*content\s*%>/g,
-    () => wrappedContent,
-  );
-  const finalContent = await replacePlaceholders(htmlWithTemplate, page);
-  return finalContent;
+  try {
+    const replacedContent = await replacePlaceholders(page.content, page);
+    const htmlContent = marked.parse(replacedContent); // Markdown processed once
+    const wrappedContent = await applyLayoutAndWrapContent(page, htmlContent);
+    // Use function to avoid $` special replacement patterns in content
+    const template = await getTemplate();
+    const htmlWithTemplate = template.replace(
+      /<%=\s*content\s*%>/g,
+      () => wrappedContent,
+    );
+    const finalContent = await replacePlaceholders(htmlWithTemplate, page);
+    return applyBasePathToHtml(finalContent);
+  } catch (error) {
+    throw new Error(`Unable to render page ${page.url}: ${error.message}`, {
+      cause: error,
+    });
+  }
 };
 
 const createPages = async (pages, distDir = dirs.dist) => {
@@ -353,12 +423,20 @@ const createPages = async (pages, distDir = dirs.dist) => {
     pages,
     async (page) => {
       const renderedHtml = await render(page);
-      const html = minificationEnabled() ? minifyHtml(renderedHtml) : renderedHtml;
-      const pageDir = page.notFound ? distDir : path.join(distDir, page.url);
+      let html = renderedHtml;
+      if (minificationEnabled()) {
+        try {
+          html = await minifyHtml(renderedHtml);
+        } catch (error) {
+          throw new Error(`Unable to minify HTML for ${page.url}: ${error.message}`, {
+            cause: error,
+          });
+        }
+      }
       const pagePath = page.notFound
         ? path.join(distDir, "404.html")
-        : path.join(distDir, page.url, "index.html");
-      await fsExtra.ensureDir(pageDir);
+        : path.join(distDir, routeToOutputPath(page.route || page.url));
+      await fsExtra.ensureDir(path.dirname(pagePath));
       await fs.writeFile(pagePath, html);
       if (page.folder) {
         await createPages(page.pages, distDir);
@@ -385,7 +463,7 @@ const addLinks = async (pages, parent) => {
         ? page.meta.tags
             .map(
               (tag) =>
-                `<a class="${defaultConfig.tag_class}" href="/tags/${tag}">${tag}</a>`,
+                `<a class="${defaultConfig.tag_class}" href="${withBasePath(`/tags/${tag}`)}">${tag}</a>`,
             )
             .join("")
         : "";
@@ -395,7 +473,7 @@ const addLinks = async (pages, parent) => {
         : ` ${defaultConfig.breadcrumb_separator} <a class="${defaultConfig.breadcrumb_class}" href="${page.url}">${crumbTitle}</a>`;
       page.meta.breadcrumbs = parent
         ? parent.meta.breadcrumbs + crumb
-        : `<a class="${defaultConfig.breadcrumb_class}" href="/">Home</a>` +
+        : `<a class="${defaultConfig.breadcrumb_class}" href="${withBasePath("/")}">Home</a>` +
           crumb;
 
       // Generate prev/next links based on sibling position (only for content pages, not folders or index)

package/src/partials.js

@@ -8,6 +8,7 @@ import { dirs, defaultConfig } from "./config.js";
 import { marked } from "./markdown.js";
 import { loadData } from "./data.js";
 import { getResponsiveImage } from "./assets.js";
+import { withBasePath, withoutBasePath } from "./urls.js";
 
 const partialCache = new Map();
 const imageExtensionRegex = /\.(png|jpe?g|webp)(?=([?#]|$))/i;
@@ -130,8 +131,7 @@ const loadPartialData = async (partialName) => {
     return partialData;
   }
 
-  console.warn(`Include "${partialName}" not found.`);
-  return { content: `<p>Include "${partialName}" not found.</p>`, raw: true };
+  throw new Error(`Partial "${partialName}" was not found in ${dirs.partials}`);
 };
 
 const loadPartial = async (partialName) => {
@@ -140,13 +140,14 @@ const loadPartial = async (partialName) => {
 };
 
 const shouldRewriteImageUrl = (url) => {
-  if (!url || !url.startsWith("/images/")) return false;
-  return imageExtensionRegex.test(url);
+  const route = withoutBasePath(url);
+  if (!route || !route.startsWith("/images/")) return false;
+  return imageExtensionRegex.test(route);
 };
 
 const rewriteImageUrl = (url) => {
   if (!shouldRewriteImageUrl(url)) return url;
-  return url.replace(imageExtensionRegex, ".webp");
+  return withBasePath(withoutBasePath(url).replace(imageExtensionRegex, ".webp"));
 };
 
 const rewriteSrcset = (srcset) =>
@@ -299,7 +300,10 @@ const replacePlaceholders = async (template, values) => {
   try {
     template = eta.renderString(template, templateData);
   } catch (error) {
-    console.warn(`Eta template error: ${error.message}`);
+    const source = values.filePath || values.url || values.title || "template";
+    throw new Error(`Unable to render ${source}: ${error.message}`, {
+      cause: error,
+    });
   }
 
   // Restore code blocks

package/src/rss.js

@@ -2,6 +2,7 @@ import fs from "fs/promises";
 import fsExtra from "fs-extra";
 import path from "path";
 import { defaultConfig } from "./config.js";
+import { withBasePath } from "./urls.js";
 
 // Escape XML special characters
 const escapeXml = (str) => {
@@ -40,8 +41,8 @@ const generateRssFeed = (feedConfig, pages, siteUrl) => {
     folder,
   } = typeof feedConfig === "string" ? { folder: feedConfig } : feedConfig;
 
-  const feedUrl = `${siteUrl}/${folder}/rss.xml`;
-  const feedLink = `${siteUrl}/${folder}`;
+  const feedUrl = `${siteUrl}${withBasePath(`/${folder}/rss.xml`)}`;
+  const feedLink = `${siteUrl}${withBasePath(`/${folder}`)}`;
 
   // Sort pages by date (newest first)
   const sortedPages = [...pages].sort((a, b) => {
@@ -94,7 +95,7 @@ const findPagesInFolder = (pages, folderName) => {
   const searchPages = (pageList) => {
     for (const page of pageList) {
       // Check if this page's URL starts with the folder path
-      if (page.url && page.url.startsWith(`/${folderName}/`) && !page.folder) {
+      if (page.route?.startsWith(`/${folderName}/`) && !page.folder) {
         found.push(page);
       }
       // Recursively search nested pages

package/src/server.js

@@ -0,0 +1,90 @@
+import fs from "fs/promises";
+import http from "http";
+import path from "path";
+
+import { baseDir, defaultConfig } from "./config.js";
+import { withoutBasePath } from "./urls.js";
+
+const contentTypes = {
+  ".css": "text/css; charset=utf-8",
+  ".gif": "image/gif",
+  ".html": "text/html; charset=utf-8",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".webmanifest": "application/manifest+json; charset=utf-8",
+  ".webp": "image/webp",
+  ".xml": "application/xml; charset=utf-8",
+};
+
+const readResponseFile = async (outputDirectory, pathname) => {
+  const route = withoutBasePath(pathname);
+  const relativePath = route.replace(/^\/+/, "");
+  const candidates = path.extname(relativePath)
+    ? [relativePath]
+    : [relativePath, path.join(relativePath, "index.html")];
+
+  for (const candidate of candidates) {
+    const filePath = path.resolve(outputDirectory, candidate);
+    if (!filePath.startsWith(`${outputDirectory}${path.sep}`)) continue;
+
+    try {
+      return { body: await fs.readFile(filePath), filePath, status: 200 };
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "EISDIR") throw error;
+    }
+  }
+
+  const notFoundPath = path.join(outputDirectory, "404.html");
+  try {
+    return { body: await fs.readFile(notFoundPath), filePath: notFoundPath, status: 404 };
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    return {
+      body: Buffer.from("Not Found"),
+      filePath: "404.txt",
+      status: 404,
+    };
+  }
+};
+
+const startServer = async (
+  outputDir = "dist",
+  port = defaultConfig.server_port || 3000,
+) => {
+  const outputDirectory = path.resolve(baseDir, outputDir);
+  const server = http.createServer(async (request, response) => {
+    try {
+      const url = new URL(request.url || "/", "http://localhost");
+      const pathname = decodeURIComponent(url.pathname);
+      const result = await readResponseFile(outputDirectory, pathname);
+      const contentType =
+        contentTypes[path.extname(result.filePath).toLowerCase()] ||
+        "application/octet-stream";
+
+      response.writeHead(result.status, { "Content-Type": contentType });
+      response.end(request.method === "HEAD" ? undefined : result.body);
+    } catch (error) {
+      response.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+      response.end(`Server error: ${error.message}`);
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", resolve);
+  });
+
+  const address = server.address();
+  const actualPort = typeof address === "object" ? address.port : port;
+  console.log(`Swifty server running at http://localhost:${actualPort}`);
+  return server;
+};
+
+export { readResponseFile, startServer };
+export default startServer;

package/src/sitemap.js

@@ -2,6 +2,7 @@ import fs from "fs/promises";
 import fsExtra from "fs-extra";
 import path from "path";
 import { defaultConfig } from "./config.js";
+import { withBasePath } from "./urls.js";
 
 const escapeXml = (str) =>
   String(str || "")
@@ -69,7 +70,9 @@ ${urls}
 const generateRobotsTxt = (siteUrl = "") => {
   const lines = ["User-agent: *", "Allow: /"];
   if (siteUrl) {
-    lines.push(`Sitemap: ${siteUrl.replace(/\/$/, "")}/sitemap.xml`);
+    lines.push(
+      `Sitemap: ${siteUrl.replace(/\/$/, "")}${withBasePath("/sitemap.xml")}`,
+    );
   }
   return `${lines.join("\n")}\n`;
 };

package/src/urls.js

@@ -0,0 +1,116 @@
+import path from "path";
+
+import { defaultConfig } from "./config.js";
+
+const normalizeBasePath = (value = defaultConfig.base_path) => {
+  if (!value || value === "/") return "";
+  if (typeof value !== "string") {
+    throw new TypeError("base_path must be a string");
+  }
+
+  const normalized = `/${value}`.replace(/\/+/g, "/").replace(/\/$/, "");
+  if (normalized.includes("..") || /[?#]/.test(normalized)) {
+    throw new Error(`Invalid base_path: ${value}`);
+  }
+  return normalized;
+};
+
+const withBasePath = (url, basePath = defaultConfig.base_path) => {
+  if (typeof url !== "string" || !url.startsWith("/") || url.startsWith("//")) {
+    return url;
+  }
+
+  const base = normalizeBasePath(basePath);
+  if (!base || url === base || url.startsWith(`${base}/`)) return url;
+  return url === "/" ? `${base}/` : `${base}${url}`;
+};
+
+const withoutBasePath = (url, basePath = defaultConfig.base_path) => {
+  const base = normalizeBasePath(basePath);
+  if (!base || typeof url !== "string") return url;
+  if (url === base || url === `${base}/`) return "/";
+  return url.startsWith(`${base}/`) ? url.slice(base.length) : url;
+};
+
+const normalizePermalink = (value) => {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new TypeError("permalink must be a non-empty string");
+  }
+  if (/^(?:[a-z]+:)?\/\//i.test(value.trim())) {
+    throw new Error(`Invalid permalink: ${value}`);
+  }
+
+  const route = `/${value.trim()}`
+    .replace(/\\/g, "/")
+    .replace(/\/{2,}/g, "/")
+    .replace(/\/$/, "") || "/";
+  if (route.split("/").includes("..") || /[?#]/.test(route)) {
+    throw new Error(`Invalid permalink: ${value}`);
+  }
+  return route;
+};
+
+const routeToOutputPath = (route) => {
+  const normalized = normalizePermalink(route);
+  if (normalized === "/") return "index.html";
+
+  const relativeRoute = normalized.replace(/^\/+/, "");
+  return path.extname(relativeRoute)
+    ? relativeRoute
+    : path.join(relativeRoute, "index.html");
+};
+
+const applyBasePathToHtml = (html, basePath = defaultConfig.base_path) => {
+  const base = normalizeBasePath(basePath);
+  if (!base) return html;
+
+  const protectedBlocks = [];
+  const protectedHtml = html.replace(
+    /(<(script|style|pre|code)\b[^>]*>)([\s\S]*?)(<\/\2>)/gi,
+    (block, opening, tagName, content, closing) => {
+      const token = `__SWIFTY_BASE_PATH_BLOCK_${protectedBlocks.length}__`;
+      protectedBlocks.push(content);
+      return `${opening}${token}${closing}`;
+    },
+  );
+
+  const rewritten = protectedHtml
+    .replace(
+      /\b(href|src|action|poster)=(['"])(\/(?!\/)[^'"]*)\2/gi,
+      (attribute, name, quote, url) =>
+        `${name}=${quote}${withBasePath(url, base)}${quote}`,
+    )
+    .replace(/\bsrcset=(['"])(.*?)\1/gi, (attribute, quote, value) => {
+      if (!/(?:^|,)\s*\//.test(value)) return attribute;
+      const nextValue = value.replace(
+        /(^|,\s*)(\/(?!\/)[^\s,]+)/g,
+        (candidate, prefix, url) => `${prefix}${withBasePath(url, base)}`,
+      );
+      return `srcset=${quote}${nextValue}${quote}`;
+    });
+
+  return rewritten.replace(
+    /__SWIFTY_BASE_PATH_BLOCK_(\d+)__/g,
+    (token, index) => protectedBlocks[index],
+  );
+};
+
+const applyBasePathToCss = (css, basePath = defaultConfig.base_path) => {
+  const base = normalizeBasePath(basePath);
+  if (!base) return css;
+
+  return css.replace(
+    /url\(\s*(['"]?)(\/(?!\/)[^)'"\s]+)\1\s*\)/gi,
+    (value, quote, url) => `url(${quote}${withBasePath(url, base)}${quote})`,
+  );
+};
+
+export {
+  applyBasePathToCss,
+  applyBasePathToHtml,
+  normalizeBasePath,
+  normalizePermalink,
+  routeToOutputPath,
+  withBasePath,
+  withoutBasePath,
+};

package/src/watcher.js

@@ -2,7 +2,7 @@ import chokidar from "chokidar";
 import livereload from "livereload";
 import path from "path";
 import fs from "fs";
-import { defaultConfig } from "./config.js";
+import { defaultConfig, reloadConfig } from "./config.js";
 
 // Directory to extension mapping for filtering
 const dirExtensions = {
@@ -13,6 +13,7 @@ const dirExtensions = {
   js: [".js"],
   partials: [".md", ".html"],
   data: [".json", ".yaml", ".yml"],
+  public: null,
 };
 
 // Build watch paths
@@ -80,6 +81,14 @@ function getChangeType(filePath) {
   return "full"; // pages, layouts, partials, config files
 }
 
+const isRootConfigFile = (filePath) => {
+  const relativePath = path.relative(process.cwd(), filePath);
+  return (
+    !relativePath.includes(path.sep) &&
+    ["config.yaml", "config.yml", "config.json"].includes(relativePath)
+  );
+};
+
 export default async function watch(outDir = "dist") {
   const build = await import("./build.js");
   const { copySingleAsset, optimizeSingleImage } = await import("./assets.js");
@@ -94,12 +103,13 @@ export default async function watch(outDir = "dist") {
   }
 
   // Start livereload server
+  const livereloadPort = defaultConfig.livereload_port || 35729;
   const lrServer = livereload.createServer({
+    port: livereloadPort,
     usePolling: true,
     delay: defaultConfig.watcher_delay || 100,
   });
   const outPath = path.join(process.cwd(), outDir);
-  const livereloadPort = defaultConfig.livereload_port || 35729;
   lrServer.watch(outPath);
   console.log(`LiveReload server started on port ${livereloadPort}`);
 
@@ -128,6 +138,10 @@ export default async function watch(outDir = "dist") {
     const filename = path.basename(filePath);
 
     try {
+      if (isRootConfigFile(filePath)) {
+        await reloadConfig();
+      }
+
       if (event === "deleted") {
         // For deletions, do a full rebuild to clean up
         console.log(`🗑️  File deleted: ${filename}. Running full build...`);