bunki 0.16.2 → 0.17.1

package/dist/index.js

@@ -26084,6 +26084,16 @@ async function copyFile(sourcePath, targetPath) {
 // src/utils/markdown-utils.ts
 var import_gray_matter = __toESM(require_gray_matter(), 1);
 
+// src/utils/date-utils.ts
+function toPacificTime(date) {
+  return new Date(new Date(date).toLocaleString("en-US", {
+    timeZone: "America/Los_Angeles"
+  }));
+}
+function getPacificYear(date) {
+  return toPacificTime(date).getFullYear();
+}
+
 // node_modules/highlight.js/es/core.js
 var import_core = __toESM(require_core2(), 1);
 var core_default = import_core.default;
@@ -30505,20 +30515,58 @@ function escape(html, encode) {
   return html;
 }
 
-// src/utils/markdown-utils.ts
+// src/utils/markdown/parser.ts
 var import_sanitize_html = __toESM(require_sanitize_html(), 1);
 
-// src/utils/date-utils.ts
-function toPacificTime(date) {
-  return new Date(new Date(date).toLocaleString("en-US", {
-    timeZone: "America/Los_Angeles"
-  }));
-}
-function getPacificYear(date) {
-  return toPacificTime(date).getFullYear();
-}
+// src/utils/markdown/constants.ts
+var RELATIVE_LINK_REGEX = /^(\.\.\/)+(\d{4})\/([a-zA-Z0-9_-]+?)(?:\.md)?(?:\/)?(#[^#]*)?$/;
+var IMAGE_PATH_REGEX = /^\.\.\/\.\.\/assets\/(\d{4})\/([^/]+)\/(.+)$/;
+var YOUTUBE_EMBED_REGEX = /<a href="(https?:\/\/(www\.)?(youtube\.com\/watch\?v=|youtu\.be\/)([\w-]+)[^"]*)"[^>]*>(.*?)<\/a>/g;
+var EXTERNAL_LINK_REGEX = /<a href="(https?:\/\/|\/\/)([^"]+)"/g;
+var SCHEMA_ORG_PLACE_TYPES = new Set([
+  "Accommodation",
+  "Apartment",
+  "Attraction",
+  "Beach",
+  "BodyOfWater",
+  "Bridge",
+  "Building",
+  "BusStation",
+  "Cafe",
+  "Campground",
+  "CivicStructure",
+  "EventVenue",
+  "Ferry",
+  "Garden",
+  "HistoricalSite",
+  "Hotel",
+  "Hostel",
+  "Landmark",
+  "LodgingBusiness",
+  "Market",
+  "Monument",
+  "Museum",
+  "NaturalFeature",
+  "Park",
+  "Playground",
+  "Restaurant",
+  "ServiceCenter",
+  "ShoppingCenter",
+  "Store",
+  "TouristAttraction",
+  "TrainStation",
+  "Viewpoint",
+  "Zoo"
+]);
+var ALERT_ICONS = {
+  note: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path fill-rule="evenodd" d="M18 10a8 8 0 1 1-16 0 8 8 0 0 1 16 0Zm-7-4a1 1 0 1 1-2 0 1 1 0 0 1 2 0ZM9 9a.75.75 0 0 0 0 1.5h.253a.25.25 0 0 1 .244.304l-.459 2.066A1.75 1.75 0 0 0 10.747 15H11a.75.75 0 0 0 0-1.5h-.253a.25.25 0 0 1-.244-.304l.459-2.066A1.75 1.75 0 0 0 9.253 9H9Z" clip-rule="evenodd" /></svg>',
+  tip: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path d="M10 1a6 6 0 0 0-3.815 10.631C7.237 12.5 8 13.443 8 14.456v.644a.75.75 0 0 0 .75.75h2.5a.75.75 0 0 0 .75-.75v-.644c0-1.013.762-1.957 1.815-2.825A6 6 0 0 0 10 1ZM8.863 17.414a.75.75 0 0 0-.226 1.483 9.066 9.066 0 0 0 2.726 0 .75.75 0 0 0-.226-1.483 7.553 7.553 0 0 1-2.274 0Z" /></svg>',
+  important: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path fill-rule="evenodd" d="M18 10a8 8 0 1 1-16 0 8 8 0 0 1 16 0Zm-8-5a.75.75 0 0 1 .75.75v4.5a.75.75 0 0 1-1.5 0v-4.5A.75.75 0 0 1 10 5Zm0 10a1 1 0 1 0 0-2 1 1 0 0 0 0 2Z" clip-rule="evenodd" /></svg>',
+  warning: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path fill-rule="evenodd" d="M8.485 2.495c.673-1.167 2.357-1.167 3.03 0l6.28 10.875c.673 1.167-.17 2.625-1.516 2.625H3.72c-1.347 0-2.189-1.458-1.515-2.625L8.485 2.495ZM10 5a.75.75 0 0 1 .75.75v3.5a.75.75 0 0 1-1.5 0v-3.5A.75.75 0 0 1 10 5Zm0 9a1 1 0 1 0 0-2 1 1 0 0 0 0 2Z" clip-rule="evenodd" /></svg>',
+  caution: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path fill-rule="evenodd" d="M18 10a8 8 0 1 1-16 0 8 8 0 0 1 16 0ZM8.28 7.22a.75.75 0 0 0-1.06 1.06L8.94 10l-1.72 1.72a.75.75 0 1 0 1.06 1.06L10 11.06l1.72 1.72a.75.75 0 1 0 1.06-1.06L11.06 10l1.72-1.72a.75.75 0 0 0-1.06-1.06L10 8.94 8.28 7.22Z" clip-rule="evenodd" /></svg>'
+};
 
-// src/utils/markdown-utils.ts
+// src/utils/markdown/parser.ts
 core_default.registerLanguage("javascript", javascript);
 core_default.registerLanguage("typescript", typescript);
 core_default.registerLanguage("markdown", markdown);
@@ -30528,8 +30576,11 @@ core_default.registerLanguage("python", python);
 core_default.registerLanguage("json", json);
 core_default.registerLanguage("swift", swift);
 var noFollowExceptions = new Set;
+function setNoFollowExceptions(exceptions) {
+  noFollowExceptions = new Set(exceptions.map((domain) => domain.toLowerCase().replace(/^www\./, "")));
+}
 function transformImagePath(relativePath, config) {
-  const match = relativePath.match(/^\.\.\/\.\.\/assets\/(\d{4})\/([^/]+)\/(.+)$/);
+  const match = relativePath.match(IMAGE_PATH_REGEX);
   if (!match)
     return null;
   const [, year, slug, filename] = match;
@@ -30550,37 +30601,19 @@ function createMarked(cdnConfig) {
     breaks: true
   });
   marked.use(A({
-    variants: [
-      {
-        type: "note",
-        icon: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path fill-rule="evenodd" d="M18 10a8 8 0 1 1-16 0 8 8 0 0 1 16 0Zm-7-4a1 1 0 1 1-2 0 1 1 0 0 1 2 0ZM9 9a.75.75 0 0 0 0 1.5h.253a.25.25 0 0 1 .244.304l-.459 2.066A1.75 1.75 0 0 0 10.747 15H11a.75.75 0 0 0 0-1.5h-.253a.25.25 0 0 1-.244-.304l.459-2.066A1.75 1.75 0 0 0 9.253 9H9Z" clip-rule="evenodd" /></svg>'
-      },
-      {
-        type: "tip",
-        icon: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path d="M10 1a6 6 0 0 0-3.815 10.631C7.237 12.5 8 13.443 8 14.456v.644a.75.75 0 0 0 .75.75h2.5a.75.75 0 0 0 .75-.75v-.644c0-1.013.762-1.957 1.815-2.825A6 6 0 0 0 10 1ZM8.863 17.414a.75.75 0 0 0-.226 1.483 9.066 9.066 0 0 0 2.726 0 .75.75 0 0 0-.226-1.483 7.553 7.553 0 0 1-2.274 0Z" /></svg>'
-      },
-      {
-        type: "important",
-        icon: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path fill-rule="evenodd" d="M18 10a8 8 0 1 1-16 0 8 8 0 0 1 16 0Zm-8-5a.75.75 0 0 1 .75.75v4.5a.75.75 0 0 1-1.5 0v-4.5A.75.75 0 0 1 10 5Zm0 10a1 1 0 1 0 0-2 1 1 0 0 0 0 2Z" clip-rule="evenodd" /></svg>'
-      },
-      {
-        type: "warning",
-        icon: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path fill-rule="evenodd" d="M8.485 2.495c.673-1.167 2.357-1.167 3.03 0l6.28 10.875c.673 1.167-.17 2.625-1.516 2.625H3.72c-1.347 0-2.189-1.458-1.515-2.625L8.485 2.495ZM10 5a.75.75 0 0 1 .75.75v3.5a.75.75 0 0 1-1.5 0v-3.5A.75.75 0 0 1 10 5Zm0 9a1 1 0 1 0 0-2 1 1 0 0 0 0 2Z" clip-rule="evenodd" /></svg>'
-      },
-      {
-        type: "caution",
-        icon: '<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true"><path fill-rule="evenodd" d="M18 10a8 8 0 1 1-16 0 8 8 0 0 1 16 0ZM8.28 7.22a.75.75 0 0 0-1.06 1.06L8.94 10l-1.72 1.72a.75.75 0 1 0 1.06 1.06L10 11.06l1.72 1.72a.75.75 0 1 0 1.06-1.06L11.06 10l1.72-1.72a.75.75 0 0 0-1.06-1.06L10 8.94 8.28 7.22Z" clip-rule="evenodd" /></svg>'
-      }
-    ]
+    variants: Object.entries(ALERT_ICONS).map(([type, icon]) => ({
+      type,
+      icon
+    }))
   }));
   marked.use({
     walkTokens(token) {
       if (token.type === "link") {
         token.href = token.href || "";
-        let relativeMatch = token.href.match(/^(\.\.\/)+(\d{4})\/([a-zA-Z0-9_-]+?)(?:\.md)?(?:\/)?$/);
+        const relativeMatch = token.href.match(RELATIVE_LINK_REGEX);
         if (relativeMatch) {
-          const [, , year, slug] = relativeMatch;
-          token.href = `/${year}/${slug}/`;
+          const [, , year, slug, anchor = ""] = relativeMatch;
+          token.href = `/${year}/${slug}/${anchor}`;
         }
         const isExternal = token.href && (token.href.startsWith("http://") || token.href.startsWith("https://") || token.href.startsWith("//"));
         if (isExternal) {
@@ -30605,9 +30638,9 @@ function createMarked(cdnConfig) {
         return markdown2;
       },
       postprocess(html) {
-        html = html.replace(/<a href="(https?:\/\/(www\.)?(youtube\.com\/watch\?v=|youtu\.be\/)([\w-]+)[^"]*)"[^>]*>(.*?)<\/a>/g, '<div class="video-container"><iframe src="https://www.youtube.com/embed/$4" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen loading="lazy"></iframe></div>');
+        html = html.replace(YOUTUBE_EMBED_REGEX, '<div class="video-container"><iframe src="https://www.youtube.com/embed/$4" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen loading="lazy"></iframe></div>');
         html = html.replace(/<img /g, '<img loading="lazy" ');
-        return html.replace(/<a href="(https?:\/\/|\/\/)([^"]+)"/g, (match, protocol, rest) => {
+        return html.replace(EXTERNAL_LINK_REGEX, (match, protocol, rest) => {
           const fullUrl = protocol + rest;
           let relAttr = 'rel="noopener noreferrer';
           try {
@@ -30627,23 +30660,9 @@ function createMarked(cdnConfig) {
   });
   return marked;
 }
-var marked = createMarked();
-function setNoFollowExceptions(exceptions) {
-  noFollowExceptions = new Set(exceptions.map((domain) => domain.toLowerCase().replace(/^www\./, "")));
-  marked = createMarked();
-}
-function extractExcerpt(content, maxLength = 200) {
-  const plainText = content.replace(/^#.*$/gm, "").replace(/```[\s\S]*?```/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[*_]{1,2}([^*_]+)[*_]{1,2}/g, "$1").replace(/\n+/g, " ").trim();
-  if (plainText.length <= maxLength) {
-    return plainText;
-  }
-  const truncated = plainText.substring(0, maxLength);
-  const lastSpace = truncated.lastIndexOf(" ");
-  return truncated.substring(0, lastSpace) + "...";
-}
 function convertMarkdownToHtml(markdownContent, cdnConfig) {
-  const markedInstance = cdnConfig ? createMarked(cdnConfig) : marked;
-  const html = markedInstance.parse(markdownContent, { async: false });
+  const marked = createMarked(cdnConfig);
+  const html = marked.parse(markdownContent, { async: false });
   let sanitized = import_sanitize_html.default(html, {
     allowedTags: import_sanitize_html.default.defaults.allowedTags.concat([
       "img",
@@ -30709,6 +30728,17 @@ function convertMarkdownToHtml(markdownContent, cdnConfig) {
   sanitized = sanitized.replace(/javascript:/gi, "").replace(/vbscript:/gi, "");
   return sanitized;
 }
+function extractExcerpt(content, maxLength = 200) {
+  const plainText = content.replace(/^#.*$/gm, "").replace(/```[\s\S]*?```/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/[*_]{1,2}([^*_]+)[*_]{1,2}/g, "$1").replace(/\n+/g, " ").trim();
+  if (plainText.length <= maxLength) {
+    return plainText;
+  }
+  const truncated = plainText.substring(0, maxLength);
+  const lastSpace = truncated.lastIndexOf(" ");
+  return truncated.substring(0, lastSpace) + "...";
+}
+
+// src/utils/markdown/validators.ts
 function validateBusinessLocation(business, filePath) {
   if (!business)
     return null;
@@ -30724,47 +30754,13 @@ function validateBusinessLocation(business, filePath) {
         suggestion: "Add 'type: Restaurant' (or Market, Park, Hotel, Museum, Cafe, Zoo, etc.) to frontmatter"
       };
     }
-    const validTypes = [
-      "Accommodation",
-      "Apartment",
-      "Attraction",
-      "Beach",
-      "BodyOfWater",
-      "Bridge",
-      "Building",
-      "BusStation",
-      "Cafe",
-      "Campground",
-      "CivicStructure",
-      "EventVenue",
-      "Ferry",
-      "Garden",
-      "HistoricalSite",
-      "Hotel",
-      "Hostel",
-      "Landmark",
-      "LodgingBusiness",
-      "Market",
-      "Monument",
-      "Museum",
-      "NaturalFeature",
-      "Park",
-      "Playground",
-      "Restaurant",
-      "ServiceCenter",
-      "ShoppingCenter",
-      "Store",
-      "TouristAttraction",
-      "TrainStation",
-      "Viewpoint",
-      "Zoo"
-    ];
-    if (!validTypes.includes(loc.type)) {
+    if (!SCHEMA_ORG_PLACE_TYPES.has(loc.type)) {
+      const exampleTypes = Array.from(SCHEMA_ORG_PLACE_TYPES).slice(0, 10);
       return {
         file: filePath,
         type: "validation",
         message: `Invalid business type '${loc.type}' in business${locIndex}`,
-        suggestion: `Use a valid Schema.org Place type: ${validTypes.slice(0, 10).join(", ")}, etc.`
+        suggestion: `Use a valid Schema.org Place type: ${exampleTypes.join(", ")}, etc.`
       };
     }
     if (!loc.name) {
@@ -30795,6 +30791,33 @@ function validateBusinessLocation(business, filePath) {
   }
   return null;
 }
+function validateTags(tags, filePath) {
+  if (!tags || !Array.isArray(tags))
+    return null;
+  const tagsWithSpaces = tags.filter((tag) => tag.includes(" "));
+  if (tagsWithSpaces.length > 0) {
+    return {
+      file: filePath,
+      type: "validation",
+      message: `Tags must not contain spaces. Found: ${tagsWithSpaces.map((t) => `"${t}"`).join(", ")}`,
+      suggestion: `Use hyphens instead of spaces. Example: "new-york-city" instead of "new york city"`
+    };
+  }
+  return null;
+}
+function checkDeprecatedLocationField(data, filePath) {
+  if (data && data.location) {
+    return {
+      file: filePath,
+      type: "validation",
+      message: "Use 'business:' instead of deprecated 'location:' field",
+      suggestion: "Replace 'location:' with 'business:' in frontmatter (business requires type, name, lat, lng)"
+    };
+  }
+  return null;
+}
+
+// src/utils/markdown-utils.ts
 async function parseMarkdownFile(filePath, cdnConfig) {
   try {
     const fileContent = await readFileAsText(filePath);
@@ -30825,15 +30848,11 @@ async function parseMarkdownFile(filePath, cdnConfig) {
         }
       };
     }
-    if (data.location) {
+    const deprecatedFieldError = checkDeprecatedLocationField(data, filePath);
+    if (deprecatedFieldError) {
       return {
         post: null,
-        error: {
-          file: filePath,
-          type: "validation",
-          message: "Use 'business:' instead of deprecated 'location:' field",
-          suggestion: "Replace 'location:' with 'business:' in frontmatter (business requires type, name, lat, lng)"
-        }
+        error: deprecatedFieldError
       };
     }
     if (data.business) {
@@ -30846,20 +30865,15 @@ async function parseMarkdownFile(filePath, cdnConfig) {
       }
     }
     if (data.tags && Array.isArray(data.tags)) {
-      const tagsWithSpaces = data.tags.filter((tag) => tag.includes(" "));
-      if (tagsWithSpaces.length > 0) {
+      const tagsError = validateTags(data.tags, filePath);
+      if (tagsError) {
         return {
           post: null,
-          error: {
-            file: filePath,
-            type: "validation",
-            message: `Tags must not contain spaces. Found: ${tagsWithSpaces.map((t) => `"${t}"`).join(", ")}`,
-            suggestion: `Use hyphens instead of spaces. Example: "new-york-city" instead of "new york city"`
-          }
+          error: tagsError
         };
       }
     }
-    let slug = getBaseFilename(filePath);
+    const slug = getBaseFilename(filePath);
     const sanitizedHtml = convertMarkdownToHtml(content, cdnConfig);
     const pacificDate = toPacificTime(data.date);
     const postYear = getPacificYear(data.date);
@@ -30947,6 +30961,20 @@ function detectFileConflicts(files) {
   }
   return errors;
 }
+async function parseMarkdownFiles(filePaths, cdnConfig) {
+  const resultsPromises = filePaths.map((filePath) => parseMarkdownFile(filePath, cdnConfig).then((result) => ({
+    result,
+    filePath
+  })));
+  const results = await Promise.all(resultsPromises);
+  const postsWithPaths = [];
+  for (const { result, filePath } of results) {
+    if (result.post) {
+      postsWithPaths.push({ post: result.post, filePath });
+    }
+  }
+  return postsWithPaths;
+}
 async function parseMarkdownDirectory(contentDir, strictMode = false, cdnConfig) {
   try {
     const markdownFiles = await findFilesByPattern("**/*.md", contentDir, true);
@@ -31303,84 +31331,9 @@ async function startServer(outputDir = DEFAULT_OUTPUT_DIR, port = 3000) {
   return server;
 }
 // src/site-generator.ts
-var import_nunjucks = __toESM(require_nunjucks(), 1);
+var import_nunjucks2 = __toESM(require_nunjucks(), 1);
 var import_slugify = __toESM(require_slugify(), 1);
-var {Glob: Glob2 } = globalThis.Bun;
-import fs3 from "fs";
-import path6 from "path";
-
-// src/utils/css-processor.ts
-import { spawn } from "child_process";
-import fs2 from "fs";
-import path5 from "path";
-async function processCSS(options2) {
-  const { css, projectRoot, outputDir, verbose = false } = options2;
-  if (!css.enabled) {
-    if (verbose) {
-      console.log("CSS processing is disabled");
-    }
-    return;
-  }
-  const inputPath = path5.resolve(projectRoot, css.input);
-  const outputPath = path5.resolve(outputDir, css.output);
-  const postcssConfigPath = css.postcssConfig ? path5.resolve(projectRoot, css.postcssConfig) : path5.resolve(projectRoot, "postcss.config.js");
-  try {
-    await fs2.promises.access(inputPath);
-  } catch (error) {
-    throw new Error(`CSS input file not found: ${inputPath}`);
-  }
-  const outputDirPath = path5.dirname(outputPath);
-  await fs2.promises.mkdir(outputDirPath, { recursive: true });
-  if (verbose) {
-    console.log("\uD83C\uDFA8 Building CSS with PostCSS...");
-    console.log(`Input: ${inputPath}`);
-    console.log(`Output: ${outputPath}`);
-    console.log(`Config: ${postcssConfigPath}`);
-  }
-  await runPostCSS(inputPath, outputPath, postcssConfigPath, projectRoot, verbose);
-}
-function runPostCSS(inputPath, outputPath, configPath, projectRoot, verbose) {
-  return new Promise((resolve, reject) => {
-    const args = [
-      "postcss",
-      inputPath,
-      "-o",
-      outputPath,
-      "--config",
-      configPath
-    ];
-    const postcss = spawn("bunx", args, {
-      stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
-      cwd: projectRoot
-    });
-    let errorOutput = "";
-    if (!verbose) {
-      postcss.stderr?.on("data", (data) => {
-        errorOutput += data.toString();
-      });
-    }
-    postcss.on("close", (code) => {
-      if (code === 0) {
-        if (verbose)
-          console.log("\u2705 CSS build completed successfully!");
-        return resolve();
-      }
-      reject(new Error(`PostCSS failed with exit code ${code}: ${errorOutput.trim()}`));
-    });
-    postcss.on("error", (err) => {
-      reject(new Error(`Failed to start PostCSS: ${err.message}`));
-    });
-  });
-}
-function getDefaultCSSConfig() {
-  return {
-    input: "templates/styles/main.css",
-    output: "css/style.css",
-    postcssConfig: "postcss.config.js",
-    enabled: true,
-    watch: false
-  };
-}
+import path9 from "path";
 
 // src/utils/json-ld.ts
 function generateOrganizationSchema(site) {
@@ -31546,706 +31499,1080 @@ function generateHomePageSchemas(options2) {
   return schemas;
 }
 
-// src/site-generator.ts
-class SiteGenerator {
-  options;
-  site;
-  formatRSSDate(date) {
-    return toPacificTime(date).toUTCString();
+// src/utils/build-cache.ts
+var {hash } = globalThis.Bun;
+import path5 from "path";
+var CACHE_VERSION = "2.0.0";
+var CACHE_FILENAME = ".bunki-cache.json";
+async function hashFile(filePath) {
+  try {
+    const file = Bun.file(filePath);
+    const content = await file.arrayBuffer();
+    return hash(content).toString(36);
+  } catch (error) {
+    return "";
   }
-  groupPostsByYear(posts) {
-    const postsByYear = {};
-    for (const post of posts) {
-      const year = getPacificYear(post.date).toString();
-      if (!postsByYear[year]) {
-        postsByYear[year] = [];
+}
+async function getFileMtime(filePath) {
+  try {
+    const stat = await Bun.file(filePath).stat();
+    return stat?.mtime?.getTime() || 0;
+  } catch (error) {
+    return 0;
+  }
+}
+async function loadCache(cwd) {
+  const cachePath = path5.join(cwd, CACHE_FILENAME);
+  const cacheFile = Bun.file(cachePath);
+  try {
+    if (await cacheFile.exists()) {
+      const content = await cacheFile.text();
+      const cache = JSON.parse(content);
+      if (cache.version !== CACHE_VERSION) {
+        console.log(`Cache version mismatch (${cache.version} vs ${CACHE_VERSION}), rebuilding...`);
+        return createEmptyCache();
       }
-      postsByYear[year].push(post);
+      return cache;
     }
-    return postsByYear;
+  } catch (error) {
+    console.warn("Error loading cache, rebuilding:", error);
   }
-  getSortedTags(limit) {
-    const sorted = Object.values(this.site.tags).sort((a, b2) => b2.count - a.count);
-    return limit ? sorted.slice(0, limit) : sorted;
+  return createEmptyCache();
+}
+async function saveCache(cwd, cache) {
+  const cachePath = path5.join(cwd, CACHE_FILENAME);
+  try {
+    await Bun.write(cachePath, JSON.stringify(cache, null, 2));
+  } catch (error) {
+    console.warn("Error saving cache:", error);
   }
-  createPagination(items, currentPage, pageSize, pagePath) {
-    const totalItems = items.length;
-    const totalPages = Math.ceil(totalItems / pageSize);
-    return {
-      currentPage,
-      totalPages,
-      hasNextPage: currentPage < totalPages,
-      hasPrevPage: currentPage > 1,
-      nextPage: currentPage < totalPages ? currentPage + 1 : null,
-      prevPage: currentPage > 1 ? currentPage - 1 : null,
-      pageSize,
-      totalItems,
-      pagePath
-    };
+}
+function createEmptyCache() {
+  return {
+    version: CACHE_VERSION,
+    files: {}
+  };
+}
+async function hasFileChanged(filePath, cache) {
+  const cached = cache.files[filePath];
+  if (!cached) {
+    return true;
   }
-  constructor(options2) {
-    this.options = options2;
-    this.site = {
-      name: options2.config.domain,
-      posts: [],
-      tags: {},
-      postsByYear: {}
-    };
-    const env = import_nunjucks.default.configure(this.options.templatesDir, {
-      autoescape: true,
-      watch: false
-    });
-    env.addFilter("date", function(date, format) {
-      const d2 = toPacificTime(date);
-      const months = [
-        "January",
-        "February",
-        "March",
-        "April",
-        "May",
-        "June",
-        "July",
-        "August",
-        "September",
-        "October",
-        "November",
-        "December"
-      ];
-      if (format === "YYYY") {
-        return d2.getFullYear();
-      } else if (format === "MMMM D, YYYY") {
-        return `${months[d2.getMonth()]} ${d2.getDate()}, ${d2.getFullYear()}`;
-      } else if (format === "MMMM D, YYYY h:mm A") {
-        const hours = d2.getHours() % 12 || 12;
-        const ampm = d2.getHours() >= 12 ? "PM" : "AM";
-        return `${months[d2.getMonth()]} ${d2.getDate()}, ${d2.getFullYear()} @ ${hours} ${ampm}`;
-      } else {
-        return d2.toLocaleDateString("en-US", {
-          timeZone: "America/Los_Angeles"
-        });
-      }
-    });
+  const currentMtime = await getFileMtime(filePath);
+  if (currentMtime !== cached.mtime) {
+    const currentHash = await hashFile(filePath);
+    return currentHash !== cached.hash;
   }
-  async initialize() {
-    console.log("Initializing site generator...");
-    await ensureDir(this.options.outputDir);
-    if (this.options.config.noFollowExceptions) {
-      setNoFollowExceptions(this.options.config.noFollowExceptions);
+  return false;
+}
+async function updateCacheEntry(filePath, cache, options2) {
+  const currentHash = await hashFile(filePath);
+  const currentMtime = await getFileMtime(filePath);
+  cache.files[filePath] = {
+    hash: currentHash,
+    mtime: currentMtime,
+    post: options2?.post,
+    outputs: options2?.outputs
+  };
+}
+async function hasConfigChanged(configPath, cache) {
+  const currentHash = await hashFile(configPath);
+  if (!cache.configHash) {
+    cache.configHash = currentHash;
+    return true;
+  }
+  if (currentHash !== cache.configHash) {
+    cache.configHash = currentHash;
+    return true;
+  }
+  return false;
+}
+function loadCachedPosts(cache, filePaths) {
+  const posts = [];
+  for (const filePath of filePaths) {
+    const entry = cache.files[filePath];
+    if (entry?.post) {
+      posts.push(entry.post);
     }
-    let tagDescriptions = {};
-    const tagsTomlPath = path6.join(process.cwd(), "src", "tags.toml");
-    const tagsTomlFile = Bun.file(tagsTomlPath);
-    if (await tagsTomlFile.exists()) {
-      try {
-        tagDescriptions = __require(tagsTomlPath);
-        console.log("Loaded tag descriptions from tags.toml");
-      } catch (error) {
-        console.warn("Error loading tag descriptions:", error);
+  }
+  return posts;
+}
+
+// src/utils/change-detector.ts
+async function detectChanges(currentFiles, cache, options2 = {}) {
+  const changes = {
+    changedPosts: [],
+    deletedPosts: [],
+    stylesChanged: false,
+    configChanged: false,
+    templatesChanged: false,
+    fullRebuild: false
+  };
+  if (options2.configPath) {
+    const configChanged = await hasFileChanged(options2.configPath, cache);
+    if (configChanged) {
+      changes.configChanged = true;
+      changes.fullRebuild = true;
+      return changes;
+    }
+  }
+  if (options2.templatePaths && options2.templatePaths.length > 0) {
+    for (const templatePath of options2.templatePaths) {
+      const changed = await hasFileChanged(templatePath, cache);
+      if (changed) {
+        changes.templatesChanged = true;
+        changes.fullRebuild = true;
+        return changes;
+      }
+    }
+  }
+  if (options2.stylesPaths && options2.stylesPaths.length > 0) {
+    for (const stylePath of options2.stylesPaths) {
+      const changed = await hasFileChanged(stylePath, cache);
+      if (changed) {
+        changes.stylesChanged = true;
+        break;
       }
     }
-    const strictMode = this.options.config.strictMode ?? false;
-    const posts = await parseMarkdownDirectory(this.options.contentDir, strictMode, this.options.config.cdn);
-    const tags = {};
-    posts.forEach((post) => {
-      post.tagSlugs = {};
-      const imageUrl = extractFirstImageUrl(post.html, this.options.config.baseUrl);
-      if (imageUrl) {
-        post.image = imageUrl;
-      }
-      post.tags.forEach((tagName) => {
-        const tagSlug = import_slugify.default(tagName, { lower: true, strict: true });
-        post.tagSlugs[tagName] = tagSlug;
-        if (!tags[tagName]) {
-          const tagData = {
-            name: tagName,
-            slug: tagSlug,
-            count: 0,
-            posts: []
-          };
-          if (tagDescriptions[tagName.toLowerCase()]) {
-            tagData.description = tagDescriptions[tagName.toLowerCase()];
-          }
-          tags[tagName] = tagData;
-        }
-        tags[tagName].count += 1;
-        tags[tagName].posts.push(post);
-      });
-    });
-    this.site = {
-      name: this.options.config.domain,
-      posts,
-      tags,
-      postsByYear: this.groupPostsByYear(posts)
-    };
   }
-  async generate() {
-    console.log("Generating static site...");
-    await ensureDir(this.options.outputDir);
-    await this.generateStylesheet();
-    await Promise.all([
-      this.generateIndexPage(),
-      this.generatePostPages(),
-      this.generateTagPages(),
-      this.generateMapPage(),
-      this.generateYearArchives(),
-      this.generateRSSFeed(),
-      this.generateSitemap(),
-      this.generateRobotsTxt(),
-      this.generate404Page(),
-      this.copyStaticAssets()
-    ]);
-    console.log("Site generation complete!");
+  for (const filePath of currentFiles) {
+    const changed = await hasFileChanged(filePath, cache);
+    if (changed) {
+      changes.changedPosts.push(filePath);
+    }
   }
-  async generate404Page() {
-    try {
-      const notFoundHtml = import_nunjucks.default.render("404.njk", {
-        site: this.options.config
-      });
-      await Bun.write(path6.join(this.options.outputDir, "404.html"), notFoundHtml);
-      console.log("Generated 404.html");
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("404.njk")) {
-        console.log("No 404.njk template found, skipping 404 page generation");
-      } else {
-        console.warn("Error generating 404 page:", error);
-      }
-    }
-  }
-  async generateYearArchives() {
-    for (const [year, yearPosts] of Object.entries(this.site.postsByYear)) {
-      const yearDir = path6.join(this.options.outputDir, year);
-      await ensureDir(yearDir);
-      const pageSize = 10;
-      const totalPages = Math.ceil(yearPosts.length / pageSize);
-      for (let page = 1;page <= totalPages; page++) {
-        const startIndex = (page - 1) * pageSize;
-        const endIndex = startIndex + pageSize;
-        const paginatedPosts = yearPosts.slice(startIndex, endIndex);
-        const pagination = this.createPagination(yearPosts, page, pageSize, `/${year}/`);
-        let jsonLd = "";
-        if (page === 1) {
-          const schemas = [];
-          schemas.push(generateCollectionPageSchema({
-            title: `Posts from ${year}`,
-            description: `Articles published in ${year}`,
-            url: `${this.options.config.baseUrl}/${year}/`,
-            posts: yearPosts,
-            site: this.options.config
-          }));
-          schemas.push(generateBreadcrumbListSchema({
-            site: this.options.config,
-            items: [
-              { name: "Home", url: `${this.options.config.baseUrl}/` },
-              { name: year, url: `${this.options.config.baseUrl}/${year}/` }
-            ]
-          }));
-          jsonLd = schemas.map((schema) => toScriptTag(schema)).join(`
-`);
-        }
-        const yearPageHtml = import_nunjucks.default.render("archive.njk", {
-          site: this.options.config,
-          posts: paginatedPosts,
-          tags: this.getSortedTags(this.options.config.maxTagsOnHomepage),
-          year,
-          pagination,
-          noindex: page > 2,
-          jsonLd
-        });
-        if (page === 1) {
-          await Bun.write(path6.join(yearDir, "index.html"), yearPageHtml);
-        } else {
-          const pageDir = path6.join(yearDir, "page", page.toString());
-          await ensureDir(pageDir);
-          await Bun.write(path6.join(pageDir, "index.html"), yearPageHtml);
-        }
-      }
+  const cachedFiles = Object.keys(cache.files).filter((f) => f.endsWith(".md"));
+  for (const cachedFile of cachedFiles) {
+    if (!currentFiles.includes(cachedFile)) {
+      changes.deletedPosts.push(cachedFile);
     }
   }
-  async generateIndexPage() {
-    const pageSize = 10;
-    const totalPages = Math.ceil(this.site.posts.length / pageSize);
-    for (let page = 1;page <= totalPages; page++) {
-      const startIndex = (page - 1) * pageSize;
-      const endIndex = startIndex + pageSize;
-      const paginatedPosts = this.site.posts.slice(startIndex, endIndex);
-      const pagination = this.createPagination(this.site.posts, page, pageSize, "/");
-      let jsonLd = "";
-      if (page === 1) {
-        const schemas = generateHomePageSchemas({
-          site: this.options.config
-        });
-        jsonLd = schemas.map((schema) => toScriptTag(schema)).join(`
+  if (changes.deletedPosts.length > 0) {
+    changes.fullRebuild = true;
+  }
+  return changes;
+}
+function estimateTimeSaved(totalPosts, changedPosts) {
+  const avgTimePerPost = 6;
+  const skippedPosts = totalPosts - changedPosts;
+  return skippedPosts * avgTimePerPost;
+}
+
+// src/utils/xml-builder.ts
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function buildSitemapUrl(loc, lastmod, changefreq, priority) {
+  return `  <url>
+    <loc>${loc}</loc>
+    <lastmod>${lastmod}</lastmod>
+    <changefreq>${changefreq}</changefreq>
+    <priority>${priority.toFixed(1)}</priority>
+  </url>
+`;
+}
+function calculateFreshnessPriority(date, basePriority, now = Date.now()) {
+  const ONE_DAY = 24 * 60 * 60 * 1000;
+  const ONE_WEEK = 7 * ONE_DAY;
+  const ONE_MONTH = 30 * ONE_DAY;
+  const postTime = new Date(date).getTime();
+  const age = now - postTime;
+  if (age < ONE_WEEK) {
+    return Math.min(1, basePriority + 0.2);
+  } else if (age < ONE_MONTH) {
+    return Math.min(1, basePriority + 0.1);
+  }
+  return basePriority;
+}
+function buildRSSItem(params) {
+  const { title, link, pubDate, description, content, tags, author, image } = params;
+  const categoryTags = tags?.map((tag) => `      <category>${escapeXml(tag)}</category>`).join(`
+`) || "";
+  let itemXml = `    <item>
+      <title><![CDATA[${title}]]></title>
+      <link>${link}</link>
+      <guid isPermaLink="true">${link}</guid>
+      <pubDate>${pubDate}</pubDate>`;
+  if (author) {
+    itemXml += `
+      <author>${author}</author>`;
+  }
+  let fullDescription = description;
+  if (image) {
+    fullDescription = `<img src="${escapeXml(image)}" alt="" style="max-width:100%; height:auto;" /><br/><br/>${description}`;
+  }
+  itemXml += `
+      <description><![CDATA[${fullDescription}]]></description>`;
+  if (categoryTags) {
+    itemXml += `
+${categoryTags}`;
+  }
+  itemXml += `
+      <content:encoded><![CDATA[${content}]]></content:encoded>`;
+  if (image) {
+    itemXml += `
+      <media:thumbnail url="${escapeXml(image)}" />`;
+    itemXml += `
+      <enclosure url="${escapeXml(image)}" type="image/jpeg" length="0" />`;
+  }
+  itemXml += `
+    </item>`;
+  return itemXml;
+}
+
+// src/utils/pagination.ts
+function createPagination(items, currentPage, pageSize, pagePath) {
+  const totalItems = items.length;
+  const totalPages = Math.ceil(totalItems / pageSize);
+  return {
+    currentPage,
+    totalPages,
+    hasNextPage: currentPage < totalPages,
+    hasPrevPage: currentPage > 1,
+    nextPage: currentPage < totalPages ? currentPage + 1 : null,
+    prevPage: currentPage > 1 ? currentPage - 1 : null,
+    pageSize,
+    totalItems,
+    pagePath
+  };
+}
+function getPaginatedItems(items, page, pageSize) {
+  const startIndex = (page - 1) * pageSize;
+  const endIndex = startIndex + pageSize;
+  return items.slice(startIndex, endIndex);
+}
+function getTotalPages(totalItems, pageSize) {
+  return Math.ceil(totalItems / pageSize);
+}
+
+// src/generators/feeds.ts
+function extractFirstImageUrl2(html) {
+  const imgRegex = /<img[^>]+src=["']([^"']+)["']/;
+  const match = html.match(imgRegex);
+  return match ? match[1] : null;
+}
+function makeAbsoluteUrl(imageUrl, baseUrl) {
+  return imageUrl.startsWith("http") ? imageUrl : `${baseUrl}${imageUrl}`;
+}
+function formatRSSDate(date) {
+  return toPacificTime(date).toUTCString();
+}
+function generateRSSFeed(site, config) {
+  const posts = site.posts.slice(0, 15);
+  const now = toPacificTime(new Date);
+  const latestPostDate = posts.length > 0 ? posts[0].date : now.toISOString();
+  const lastBuildDate = formatRSSDate(latestPostDate);
+  const rssItems = posts.map((post) => {
+    const postUrl = `${config.baseUrl}${post.url}`;
+    const pubDate = formatRSSDate(post.date);
+    const featuredImage = extractFirstImageUrl2(post.html);
+    const absoluteImageUrl = featuredImage ? makeAbsoluteUrl(featuredImage, config.baseUrl) : null;
+    const author = config.authorEmail && config.authorName ? `${config.authorEmail} (${config.authorName})` : config.authorEmail || undefined;
+    return buildRSSItem({
+      title: post.title,
+      link: postUrl,
+      pubDate,
+      description: post.excerpt,
+      content: post.html,
+      tags: post.tags,
+      author,
+      image: absoluteImageUrl
+    });
+  }).join(`
+`);
+  let channelXml = `  <channel>
+    <title><![CDATA[${config.title}]]></title>
+    <link>${config.baseUrl}/</link>
+    <description><![CDATA[${config.description}]]></description>`;
+  const language = config.rssLanguage || "en-US";
+  channelXml += `
+    <language>${language}</language>`;
+  if (config.authorEmail && config.authorName) {
+    channelXml += `
+    <managingEditor>${config.authorEmail} (${config.authorName})</managingEditor>`;
+  } else if (config.authorEmail) {
+    channelXml += `
+    <managingEditor>${config.authorEmail}</managingEditor>`;
+  }
+  if (config.webMaster) {
+    channelXml += `
+    <webMaster>${config.webMaster}</webMaster>`;
+  }
+  if (config.copyright) {
+    channelXml += `
+    <copyright><![CDATA[${config.copyright}]]></copyright>`;
+  }
+  channelXml += `
+    <pubDate>${formatRSSDate(latestPostDate)}</pubDate>
+    <lastBuildDate>${lastBuildDate}</lastBuildDate>
+    <atom:link href="${config.baseUrl}/feed.xml" rel="self" type="application/rss+xml" />`;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:media="http://search.yahoo.com/mrss/">
+${channelXml}
+${rssItems}
+  </channel>
+</rss>`;
+}
+function generateSitemap(site, config, pageSize = 10) {
+  const currentDate = toPacificTime(new Date).toISOString();
+  const now = toPacificTime(new Date).getTime();
+  let sitemapContent = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+`;
+  sitemapContent += buildSitemapUrl(`${config.baseUrl}/`, currentDate, "daily", 1);
+  const totalHomePages = getTotalPages(site.posts.length, pageSize);
+  for (let page = 2;page <= totalHomePages; page++) {
+    sitemapContent += buildSitemapUrl(`${config.baseUrl}/page/${page}/`, currentDate, "daily", 0.8);
+  }
+  for (const post of site.posts) {
+    const postUrl = `${config.baseUrl}${post.url}`;
+    const postDate = new Date(post.date).toISOString();
+    const priority = calculateFreshnessPriority(post.date, 0.7, now);
+    const age = now - new Date(post.date).getTime();
+    const ONE_MONTH = 30 * 24 * 60 * 60 * 1000;
+    const changefreq = age < ONE_MONTH ? "weekly" : "monthly";
+    sitemapContent += buildSitemapUrl(postUrl, postDate, changefreq, priority);
+  }
+  sitemapContent += buildSitemapUrl(`${config.baseUrl}/tags/`, currentDate, "weekly", 0.5);
+  sitemapContent += buildSitemapUrl(`${config.baseUrl}/map/`, currentDate, "weekly", 0.6);
+  for (const [, tagData] of Object.entries(site.tags)) {
+    const tagUrl = `${config.baseUrl}/tags/${tagData.slug}/`;
+    const mostRecentPost = tagData.posts[0];
+    const tagPriority = mostRecentPost ? calculateFreshnessPriority(mostRecentPost.date, 0.4, now) : 0.4;
+    sitemapContent += buildSitemapUrl(tagUrl, currentDate, "weekly", tagPriority);
+    const totalTagPages = getTotalPages(tagData.posts.length, pageSize);
+    for (let page = 2;page <= totalTagPages; page++) {
+      sitemapContent += buildSitemapUrl(`${config.baseUrl}/tags/${tagData.slug}/page/${page}/`, currentDate, "weekly", Math.max(0.3, tagPriority - 0.1));
+    }
+  }
+  for (const [year, yearPosts] of Object.entries(site.postsByYear)) {
+    const currentYear = new Date().getFullYear();
+    const isCurrentYear = parseInt(year) === currentYear;
+    const yearPriority = isCurrentYear ? 0.7 : 0.5;
+    sitemapContent += buildSitemapUrl(`${config.baseUrl}/${year}/`, currentDate, isCurrentYear ? "weekly" : "monthly", yearPriority);
+    const totalYearPages = getTotalPages(yearPosts.length, pageSize);
+    for (let page = 2;page <= totalYearPages; page++) {
+      sitemapContent += buildSitemapUrl(`${config.baseUrl}/${year}/page/${page}/`, currentDate, isCurrentYear ? "weekly" : "monthly", yearPriority - 0.1);
+    }
+  }
+  sitemapContent += `</urlset>`;
+  return sitemapContent;
+}
+function generateSitemapIndex(config) {
+  const currentDate = toPacificTime(new Date).toISOString();
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  <sitemap>
+    <loc>${config.baseUrl}/sitemap.xml</loc>
+    <lastmod>${currentDate}</lastmod>
+  </sitemap>
+</sitemapindex>`;
+}
+function generateRobotsTxt(config) {
+  return `# Robots.txt for ${config.domain}
+# Generated by Bunki
+
+User-agent: *
+Allow: /
+
+# Sitemaps
+Sitemap: ${config.baseUrl}/sitemap.xml
+
+# Crawl-delay (optional, adjust as needed)
+# Crawl-delay: 1
+
+# Disallow specific paths (uncomment as needed)
+# Disallow: /private/
+# Disallow: /admin/
+# Disallow: /api/
+`;
+}
+
+// src/generators/pages.ts
+var import_nunjucks = __toESM(require_nunjucks(), 1);
+import path6 from "path";
+function getSortedTags(tags, limit) {
+  const sorted = Object.values(tags).sort((a, b2) => b2.count - a.count);
+  return limit ? sorted.slice(0, limit) : sorted;
+}
+async function writeHtmlFile(outputDir, relativePath, content) {
+  const fullPath = path6.join(outputDir, relativePath);
+  const dir = path6.dirname(fullPath);
+  await ensureDir(dir);
+  await Bun.write(fullPath, content);
+}
+async function generateIndexPages(site, config, outputDir, pageSize = 10) {
+  const totalPages = getTotalPages(site.posts.length, pageSize);
+  for (let page = 1;page <= totalPages; page++) {
+    const paginatedPosts = getPaginatedItems(site.posts, page, pageSize);
+    const pagination = createPagination(site.posts, page, pageSize, "/");
+    let jsonLd = "";
+    if (page === 1) {
+      const schemas = generateHomePageSchemas({ site: config });
+      jsonLd = schemas.map((schema) => toScriptTag(schema)).join(`
 `);
-      }
-      const pageHtml = import_nunjucks.default.render("index.njk", {
-        site: this.options.config,
-        posts: paginatedPosts,
-        tags: this.getSortedTags(this.options.config.maxTagsOnHomepage),
-        pagination,
-        jsonLd,
-        noindex: page > 2
-      });
-      if (page === 1) {
-        await Bun.write(path6.join(this.options.outputDir, "index.html"), pageHtml);
-      } else {
-        const pageDir = path6.join(this.options.outputDir, "page", page.toString());
-        await ensureDir(pageDir);
-        await Bun.write(path6.join(pageDir, "index.html"), pageHtml);
-      }
     }
+    const pageHtml = import_nunjucks.default.render("index.njk", {
+      site: config,
+      posts: paginatedPosts,
+      tags: getSortedTags(site.tags, config.maxTagsOnHomepage),
+      pagination,
+      jsonLd,
+      noindex: page > 2
+    });
+    const outputPath = page === 1 ? "index.html" : `page/${page}/index.html`;
+    await writeHtmlFile(outputDir, outputPath, pageHtml);
   }
-  async generatePostPages() {
-    for (const post of this.site.posts) {
+}
+async function generatePostPages(site, config, outputDir) {
+  const batchSize = 10;
+  for (let i = 0;i < site.posts.length; i += batchSize) {
+    const batch = site.posts.slice(i, i + batchSize);
+    await Promise.all(batch.map(async (post) => {
       const postPath = post.url.substring(1);
-      const postDir = path6.join(this.options.outputDir, postPath);
-      await ensureDir(postDir);
-      const imageUrl = extractFirstImageUrl(post.html, this.options.config.baseUrl);
+      const imageUrl = extractFirstImageUrl(post.html, config.baseUrl);
       const schemas = generatePostPageSchemas({
         post,
-        site: this.options.config,
+        site: config,
         imageUrl
       });
       const jsonLd = schemas.map((schema) => toScriptTag(schema)).join(`
 `);
       const postHtml = import_nunjucks.default.render("post.njk", {
-        site: this.options.config,
+        site: config,
         post,
         jsonLd
       });
-      await Bun.write(path6.join(postDir, "index.html"), postHtml);
-    }
+      await writeHtmlFile(outputDir, `${postPath}index.html`, postHtml);
+    }));
   }
-  async generateTagPages() {
-    const tagsDir = path6.join(this.options.outputDir, "tags");
-    await ensureDir(tagsDir);
-    const tagIndexHtml = import_nunjucks.default.render("tags.njk", {
-      site: this.options.config,
-      tags: this.getSortedTags()
-    });
-    await Bun.write(path6.join(tagsDir, "index.html"), tagIndexHtml);
-    for (const [tagName, tagData] of Object.entries(this.site.tags)) {
-      const tagDir = path6.join(tagsDir, tagData.slug);
-      await ensureDir(tagDir);
-      const pageSize = 10;
-      const totalPages = Math.ceil(tagData.posts.length / pageSize);
-      for (let page = 1;page <= totalPages; page++) {
-        const startIndex = (page - 1) * pageSize;
-        const endIndex = startIndex + pageSize;
-        const paginatedPosts = tagData.posts.slice(startIndex, endIndex);
-        const paginatedTagData = {
-          ...tagData,
-          posts: paginatedPosts
-        };
-        const pagination = this.createPagination(tagData.posts, page, pageSize, `/tags/${tagData.slug}/`);
-        let jsonLd = "";
-        if (page === 1) {
-          const schemas = [];
-          const description = tagData.description || `Articles tagged with ${tagName}`;
-          schemas.push(generateCollectionPageSchema({
-            title: `${tagName}`,
-            description,
-            url: `${this.options.config.baseUrl}/tags/${tagData.slug}/`,
-            posts: tagData.posts,
-            site: this.options.config
-          }));
-          schemas.push(generateBreadcrumbListSchema({
-            site: this.options.config,
-            items: [
-              { name: "Home", url: `${this.options.config.baseUrl}/` },
-              { name: tagName, url: `${this.options.config.baseUrl}/tags/${tagData.slug}/` }
-            ]
-          }));
-          jsonLd = schemas.map((schema) => toScriptTag(schema)).join(`
+}
+async function generateTagPages(site, config, outputDir, pageSize = 10) {
+  const tagIndexHtml = import_nunjucks.default.render("tags.njk", {
+    site: config,
+    tags: getSortedTags(site.tags)
+  });
+  await writeHtmlFile(outputDir, "tags/index.html", tagIndexHtml);
+  for (const [tagName, tagData] of Object.entries(site.tags)) {
+    const totalPages = getTotalPages(tagData.posts.length, pageSize);
+    for (let page = 1;page <= totalPages; page++) {
+      const paginatedPosts = getPaginatedItems(tagData.posts, page, pageSize);
+      const paginatedTagData = {
+        ...tagData,
+        posts: paginatedPosts
+      };
+      const pagination = createPagination(tagData.posts, page, pageSize, `/tags/${tagData.slug}/`);
+      let jsonLd = "";
+      if (page === 1) {
+        const schemas = [];
+        const description = tagData.description || `Articles tagged with ${tagName}`;
+        schemas.push(generateCollectionPageSchema({
+          title: `${tagName}`,
+          description,
+          url: `${config.baseUrl}/tags/${tagData.slug}/`,
+          posts: tagData.posts,
+          site: config
+        }));
+        schemas.push(generateBreadcrumbListSchema({
+          site: config,
+          items: [
+            { name: "Home", url: `${config.baseUrl}/` },
+            {
+              name: tagName,
+              url: `${config.baseUrl}/tags/${tagData.slug}/`
+            }
+          ]
+        }));
+        jsonLd = schemas.map((schema) => toScriptTag(schema)).join(`
 `);
-        }
-        const tagPageHtml = import_nunjucks.default.render("tag.njk", {
-          site: this.options.config,
-          tag: paginatedTagData,
-          tags: Object.values(this.site.tags),
-          pagination,
-          noindex: page > 2,
-          jsonLd
-        });
-        if (page === 1) {
-          await Bun.write(path6.join(tagDir, "index.html"), tagPageHtml);
-        } else {
-          const pageDir = path6.join(tagDir, "page", page.toString());
-          await ensureDir(pageDir);
-          await Bun.write(path6.join(pageDir, "index.html"), tagPageHtml);
-        }
       }
+      const tagPageHtml = import_nunjucks.default.render("tag.njk", {
+        site: config,
+        tag: paginatedTagData,
+        tags: Object.values(site.tags),
+        pagination,
+        noindex: page > 2,
+        jsonLd
+      });
+      const outputPath = page === 1 ? `tags/${tagData.slug}/index.html` : `tags/${tagData.slug}/page/${page}/index.html`;
+      await writeHtmlFile(outputDir, outputPath, tagPageHtml);
     }
   }
-  async generateMapPage() {
-    try {
-      const mapDir = path6.join(this.options.outputDir, "map");
-      await ensureDir(mapDir);
-      const mapHtml = import_nunjucks.default.render("map.njk", {
-        site: this.options.config,
-        posts: this.site.posts
-      });
-      await Bun.write(path6.join(mapDir, "index.html"), mapHtml);
-      console.log("Generated map page");
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("map.njk")) {
-        console.log("No map.njk template found, skipping map page generation");
-      } else {
-        console.warn("Error generating map page:", error);
+}
+async function generateYearArchives(site, config, outputDir, pageSize = 10) {
+  for (const [year, yearPosts] of Object.entries(site.postsByYear)) {
+    const totalPages = getTotalPages(yearPosts.length, pageSize);
+    for (let page = 1;page <= totalPages; page++) {
+      const paginatedPosts = getPaginatedItems(yearPosts, page, pageSize);
+      const pagination = createPagination(yearPosts, page, pageSize, `/${year}/`);
+      let jsonLd = "";
+      if (page === 1) {
+        const schemas = [];
+        schemas.push(generateCollectionPageSchema({
+          title: `Posts from ${year}`,
+          description: `Articles published in ${year}`,
+          url: `${config.baseUrl}/${year}/`,
+          posts: yearPosts,
+          site: config
+        }));
+        schemas.push(generateBreadcrumbListSchema({
+          site: config,
+          items: [
+            { name: "Home", url: `${config.baseUrl}/` },
+            { name: year, url: `${config.baseUrl}/${year}/` }
+          ]
+        }));
+        jsonLd = schemas.map((schema) => toScriptTag(schema)).join(`
+`);
       }
+      const yearPageHtml = import_nunjucks.default.render("archive.njk", {
+        site: config,
+        posts: paginatedPosts,
+        tags: getSortedTags(site.tags, config.maxTagsOnHomepage),
+        year,
+        pagination,
+        noindex: page > 2,
+        jsonLd
+      });
+      const outputPath = page === 1 ? `${year}/index.html` : `${year}/page/${page}/index.html`;
+      await writeHtmlFile(outputDir, outputPath, yearPageHtml);
     }
   }
-  async generateStylesheet() {
-    const cssConfig = this.options.config.css || getDefaultCSSConfig();
-    if (!cssConfig.enabled) {
-      console.log("CSS processing is disabled, skipping stylesheet generation.");
-      return;
-    }
-    try {
-      await processCSS({
-        css: cssConfig,
-        projectRoot: process.cwd(),
-        outputDir: this.options.outputDir,
-        verbose: true
-      });
-    } catch (error) {
-      console.error("Error processing CSS:", error);
-      console.log("Falling back to simple CSS file copying...");
-      await this.fallbackCSSGeneration(cssConfig);
+}
+async function generate404Page(config, outputDir) {
+  try {
+    const notFoundHtml = import_nunjucks.default.render("404.njk", {
+      site: config
+    });
+    await writeHtmlFile(outputDir, "404.html", notFoundHtml);
+    console.log("Generated 404.html");
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("404.njk")) {
+      console.log("No 404.njk template found, skipping 404 page generation");
+    } else {
+      console.warn("Error generating 404 page:", error);
     }
   }
-  async fallbackCSSGeneration(cssConfig) {
-    const cssFilePath = path6.resolve(process.cwd(), cssConfig.input);
-    const cssFile = Bun.file(cssFilePath);
-    if (!await cssFile.exists()) {
-      console.warn(`CSS input file not found: ${cssFilePath}`);
-      return;
+}
+async function generateMapPage(site, config, outputDir) {
+  try {
+    const mapHtml = import_nunjucks.default.render("map.njk", {
+      site: config,
+      posts: site.posts
+    });
+    await writeHtmlFile(outputDir, "map/index.html", mapHtml);
+    console.log("Generated map page");
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("map.njk")) {
+      console.log("No map.njk template found, skipping map page generation");
+    } else {
+      console.warn("Error generating map page:", error);
     }
-    try {
-      const cssContent = await cssFile.text();
-      const outputPath = path6.resolve(this.options.outputDir, cssConfig.output);
-      const outputDir = path6.dirname(outputPath);
-      await ensureDir(outputDir);
-      await Bun.write(outputPath, cssContent);
-      console.log("\u2705 CSS file copied successfully (fallback mode)");
-    } catch (error) {
-      console.error("Error in fallback CSS generation:", error);
+  }
+}
+
+// src/generators/assets.ts
+var {Glob: Glob2 } = globalThis.Bun;
+import path8 from "path";
+
+// src/utils/css-processor.ts
+import { spawn } from "child_process";
+var {hash: hash2 } = globalThis.Bun;
+import path7 from "path";
+async function processCSS(options2) {
+  const {
+    css,
+    projectRoot,
+    outputDir,
+    verbose = false,
+    enableHashing = false
+  } = options2;
+  if (!css.enabled) {
+    if (verbose) {
+      console.log("CSS processing is disabled");
     }
+    return { outputPath: "" };
   }
-  async copyStaticAssets() {
-    const assetsDir = path6.join(this.options.templatesDir, "assets");
-    const publicDir = path6.join(process.cwd(), "public");
-    async function dirExists(p) {
-      try {
-        const stat = await fs3.promises.stat(p);
-        return stat.isDirectory();
-      } catch {
-        return false;
-      }
+  const inputPath = path7.resolve(projectRoot, css.input);
+  const tempOutputPath = path7.resolve(outputDir, css.output);
+  const postcssConfigPath = css.postcssConfig ? path7.resolve(projectRoot, css.postcssConfig) : path7.resolve(projectRoot, "postcss.config.js");
+  const inputFile = Bun.file(inputPath);
+  if (!await inputFile.exists()) {
+    throw new Error(`CSS input file not found: ${inputPath}`);
+  }
+  const outputDirPath = path7.dirname(tempOutputPath);
+  await ensureDir(outputDirPath);
+  if (verbose) {
+    console.log("\uD83C\uDFA8 Building CSS with PostCSS...");
+    console.log(`Input: ${inputPath}`);
+    console.log(`Output: ${tempOutputPath}`);
+    console.log(`Config: ${postcssConfigPath}`);
+  }
+  await runPostCSS(inputPath, tempOutputPath, postcssConfigPath, projectRoot, verbose);
+  if (enableHashing) {
+    const cssFile = Bun.file(tempOutputPath);
+    const cssContent = await cssFile.arrayBuffer();
+    const contentHash = hash2(cssContent).toString(36).slice(0, 8);
+    const ext = path7.extname(tempOutputPath);
+    const basename = path7.basename(tempOutputPath, ext);
+    const dir = path7.dirname(tempOutputPath);
+    const hashedFilename = `${basename}.${contentHash}${ext}`;
+    const hashedOutputPath = path7.join(dir, hashedFilename);
+    await Bun.write(hashedOutputPath, cssFile);
+    if (verbose) {
+      console.log(`\u2705 CSS hashed: ${hashedFilename}`);
     }
-    const assetsDirFile = Bun.file(assetsDir);
-    if (await assetsDirFile.exists() && await dirExists(assetsDir)) {
-      const assetGlob = new Glob2("**/*.*");
-      const assetsOutputDir = path6.join(this.options.outputDir, "assets");
-      await ensureDir(assetsOutputDir);
-      for await (const file of assetGlob.scan({
-        cwd: assetsDir,
-        absolute: true
-      })) {
-        const relativePath = path6.relative(assetsDir, file);
-        const targetPath = path6.join(assetsOutputDir, relativePath);
-        const targetDir = path6.dirname(targetPath);
-        await ensureDir(targetDir);
-        await copyFile(file, targetPath);
-      }
+    return {
+      outputPath: hashedOutputPath,
+      hash: contentHash
+    };
+  }
+  return { outputPath: tempOutputPath };
+}
+function runPostCSS(inputPath, outputPath, configPath, projectRoot, verbose) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      "postcss",
+      inputPath,
+      "-o",
+      outputPath,
+      "--config",
+      configPath
+    ];
+    const postcss = spawn("bunx", args, {
+      stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
+      cwd: projectRoot
+    });
+    let errorOutput = "";
+    if (!verbose) {
+      postcss.stderr?.on("data", (data) => {
+        errorOutput += data.toString();
+      });
     }
-    if (await dirExists(publicDir)) {
-      const copyRecursive = async (srcDir) => {
-        const entries = await fs3.promises.readdir(srcDir, {
-          withFileTypes: true
-        });
-        for (const entry of entries) {
-          const srcPath = path6.join(srcDir, entry.name);
-          const relativePath = path6.relative(publicDir, srcPath);
-          const destPath = path6.join(this.options.outputDir, relativePath);
-          if (!relativePath)
-            continue;
-          if (entry.isDirectory()) {
-            await ensureDir(destPath);
-            await copyRecursive(srcPath);
-          } else if (entry.isFile()) {
-            const targetFile = Bun.file(destPath);
-            if (!await targetFile.exists()) {
-              const targetDir = path6.dirname(destPath);
-              await ensureDir(targetDir);
-              await copyFile(srcPath, destPath);
-            }
-          }
-        }
-      };
-      await copyRecursive(publicDir);
-      console.log("Copied public files to site (including extensionless & dotfiles)");
-    }
-  }
-  extractFirstImageUrl(html) {
-    const imgRegex = /<img[^>]+src=["']([^"']+)["']/;
-    const match = html.match(imgRegex);
-    return match ? match[1] : null;
-  }
-  escapeXml(text) {
-    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-  }
-  async generateRSSFeed() {
-    const posts = this.site.posts.slice(0, 15);
-    const config = this.options.config;
-    const now = toPacificTime(new Date);
-    const latestPostDate = posts.length > 0 ? posts[0].date : now.toISOString();
-    const lastBuildDate = this.formatRSSDate(latestPostDate);
-    const rssItems = posts.map((post) => {
-      const postUrl = `${config.baseUrl}${post.url}`;
-      const pubDate = this.formatRSSDate(post.date);
-      const featuredImage = this.extractFirstImageUrl(post.html);
-      const categoryTags = post.tags.map((tag) => `      <category>${this.escapeXml(tag)}</category>`).join(`
-`);
-      let itemXml = `    <item>
-      <title><![CDATA[${post.title}]]></title>
-      <link>${postUrl}</link>
-      <guid isPermaLink="true">${postUrl}</guid>
-      <pubDate>${pubDate}</pubDate>`;
-      if (config.authorEmail && config.authorName) {
-        itemXml += `
-      <author>${config.authorEmail} (${config.authorName})</author>`;
-      } else if (config.authorEmail) {
-        itemXml += `
-      <author>${config.authorEmail}</author>`;
-      }
-      let description = post.excerpt;
-      if (featuredImage) {
-        const absoluteImageUrl = featuredImage.startsWith("http") ? featuredImage : `${config.baseUrl}${featuredImage}`;
-        description = `<img src="${this.escapeXml(absoluteImageUrl)}" alt="" style="max-width:100%; height:auto;" /><br/><br/>${post.excerpt}`;
-      }
-      itemXml += `
-      <description><![CDATA[${description}]]></description>`;
-      if (post.tags.length > 0) {
-        itemXml += `
-${categoryTags}`;
-      }
-      itemXml += `
-      <content:encoded><![CDATA[${post.html}]]></content:encoded>`;
-      if (featuredImage) {
-        const absoluteImageUrl = featuredImage.startsWith("http") ? featuredImage : `${config.baseUrl}${featuredImage}`;
-        itemXml += `
-      <media:thumbnail url="${this.escapeXml(absoluteImageUrl)}" />`;
-        itemXml += `
-      <enclosure url="${this.escapeXml(absoluteImageUrl)}" type="image/jpeg" length="0" />`;
+    postcss.on("close", (code) => {
+      if (code === 0) {
+        if (verbose)
+          console.log("\u2705 CSS build completed successfully!");
+        return resolve();
       }
-      itemXml += `
-    </item>`;
-      return itemXml;
-    }).join(`
-`);
-    let channelXml = `  <channel>
-    <title><![CDATA[${config.title}]]></title>
-    <link>${config.baseUrl}/</link>
-    <description><![CDATA[${config.description}]]></description>`;
-    const language = config.rssLanguage || "en-US";
-    channelXml += `
-    <language>${language}</language>`;
-    if (config.authorEmail && config.authorName) {
-      channelXml += `
-    <managingEditor>${config.authorEmail} (${config.authorName})</managingEditor>`;
-    } else if (config.authorEmail) {
-      channelXml += `
-    <managingEditor>${config.authorEmail}</managingEditor>`;
+      reject(new Error(`PostCSS failed with exit code ${code}: ${errorOutput.trim()}`));
+    });
+    postcss.on("error", (err) => {
+      reject(new Error(`Failed to start PostCSS: ${err.message}`));
+    });
+  });
+}
+function getDefaultCSSConfig() {
+  return {
+    input: "templates/styles/main.css",
+    output: "css/style.css",
+    postcssConfig: "postcss.config.js",
+    enabled: true,
+    watch: false
+  };
+}
+
+// src/generators/assets.ts
+async function generateStylesheet(config, outputDir) {
+  const cssConfig = config.css || getDefaultCSSConfig();
+  if (!cssConfig.enabled) {
+    console.log("CSS processing is disabled, skipping stylesheet generation.");
+    return;
+  }
+  try {
+    await processCSS({
+      css: cssConfig,
+      projectRoot: process.cwd(),
+      outputDir,
+      verbose: true
+    });
+  } catch (error) {
+    console.error("Error processing CSS:", error);
+    console.log("Falling back to simple CSS file copying...");
+    await fallbackCSSGeneration(cssConfig, outputDir);
+  }
+}
+async function fallbackCSSGeneration(cssConfig, outputDir) {
+  const cssFilePath = path8.resolve(process.cwd(), cssConfig.input);
+  const cssFile = Bun.file(cssFilePath);
+  if (!await cssFile.exists()) {
+    console.warn(`CSS input file not found: ${cssFilePath}`);
+    return;
+  }
+  try {
+    const outputPath = path8.resolve(outputDir, cssConfig.output);
+    const outputDirPath = path8.dirname(outputPath);
+    await ensureDir(outputDirPath);
+    await Bun.write(outputPath, cssFile);
+    console.log("\u2705 CSS file copied successfully (fallback mode)");
+  } catch (error) {
+    console.error("Error in fallback CSS generation:", error);
+  }
+}
+async function copyStaticAssets(templatesDir, outputDir) {
+  const assetsDir = path8.join(templatesDir, "assets");
+  const publicDir = path8.join(process.cwd(), "public");
+  if (await isDirectory(assetsDir)) {
+    const assetGlob = new Glob2("**/*.*");
+    const assetsOutputDir = path8.join(outputDir, "assets");
+    await ensureDir(assetsOutputDir);
+    for await (const file of assetGlob.scan({
+      cwd: assetsDir,
+      absolute: true
+    })) {
+      const relativePath = path8.relative(assetsDir, file);
+      const targetPath = path8.join(assetsOutputDir, relativePath);
+      const targetDir = path8.dirname(targetPath);
+      await ensureDir(targetDir);
+      await copyFile(file, targetPath);
+    }
+  }
+  if (await isDirectory(publicDir)) {
+    const publicGlob = new Glob2("**/*");
+    for await (const file of publicGlob.scan({
+      cwd: publicDir,
+      absolute: true,
+      dot: true
+    })) {
+      if (await isDirectory(file))
+        continue;
+      const relativePath = path8.relative(publicDir, file);
+      const destPath = path8.join(outputDir, relativePath);
+      const targetDir = path8.dirname(destPath);
+      await ensureDir(targetDir);
+      await copyFile(file, destPath);
     }
-    if (config.webMaster) {
-      channelXml += `
-    <webMaster>${config.webMaster}</webMaster>`;
+    console.log("Copied public files to site (including extensionless & dotfiles)");
+  }
+}
+
+// src/utils/build-metrics.ts
+class MetricsCollector {
+  startTime;
+  stageTimings = new Map;
+  currentStage = null;
+  constructor() {
+    this.startTime = performance.now();
+  }
+  startStage(name) {
+    if (this.currentStage) {
+      this.endStage();
+    }
+    this.currentStage = {
+      name,
+      startTime: performance.now()
+    };
+  }
+  endStage() {
+    if (!this.currentStage) {
+      return;
     }
-    if (config.copyright) {
-      channelXml += `
-    <copyright><![CDATA[${config.copyright}]]></copyright>`;
+    const duration = performance.now() - this.currentStage.startTime;
+    this.stageTimings.set(this.currentStage.name, duration);
+    this.currentStage = null;
+  }
+  getMetrics(outputs) {
+    if (this.currentStage) {
+      this.endStage();
     }
-    channelXml += `
-    <pubDate>${this.formatRSSDate(latestPostDate)}</pubDate>
-    <lastBuildDate>${lastBuildDate}</lastBuildDate>
-    <atom:link href="${config.baseUrl}/feed.xml" rel="self" type="application/rss+xml" />`;
-    const rssContent = `<?xml version="1.0" encoding="UTF-8"?>
-<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:media="http://search.yahoo.com/mrss/">
-${channelXml}
-${rssItems}
-  </channel>
-</rss>`;
-    await Bun.write(path6.join(this.options.outputDir, "feed.xml"), rssContent);
+    const totalTime = performance.now() - this.startTime;
+    return {
+      totalTime,
+      stages: {
+        initialization: this.stageTimings.get("initialization") || 0,
+        cssProcessing: this.stageTimings.get("cssProcessing") || 0,
+        pageGeneration: this.stageTimings.get("pageGeneration") || 0,
+        feedGeneration: this.stageTimings.get("feedGeneration") || 0,
+        assetCopying: this.stageTimings.get("assetCopying") || 0
+      },
+      outputs
+    };
   }
-  async generateSitemap() {
-    const currentDate = toPacificTime(new Date).toISOString();
-    const pageSize = 10;
-    const config = this.options.config;
-    const now = toPacificTime(new Date).getTime();
-    const ONE_DAY = 24 * 60 * 60 * 1000;
-    const ONE_WEEK = 7 * ONE_DAY;
-    const ONE_MONTH = 30 * ONE_DAY;
-    const calculatePriority = (date, basePriority) => {
-      const postTime = new Date(date).getTime();
-      const age = now - postTime;
-      if (age < ONE_WEEK) {
-        return Math.min(1, basePriority + 0.2);
-      } else if (age < ONE_MONTH) {
-        return Math.min(1, basePriority + 0.1);
-      }
-      return basePriority;
-    };
-    let sitemapContent = `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-`;
-    sitemapContent += `  <url>
-    <loc>${config.baseUrl}/</loc>
-    <lastmod>${currentDate}</lastmod>
-    <changefreq>daily</changefreq>
-    <priority>1.0</priority>
-  </url>
-`;
-    const totalHomePages = Math.ceil(this.site.posts.length / pageSize);
-    if (totalHomePages > 1) {
-      for (let page = 2;page <= totalHomePages; page++) {
-        sitemapContent += `  <url>
-    <loc>${config.baseUrl}/page/${page}/</loc>
-    <lastmod>${currentDate}</lastmod>
-    <changefreq>daily</changefreq>
-    <priority>0.8</priority>
-  </url>
-`;
+}
+function formatBytes(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const k2 = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k2));
+  return `${(bytes / Math.pow(k2, i)).toFixed(2)} ${sizes[i]}`;
+}
+function displayMetrics(metrics) {
+  console.log(`
+\uD83D\uDCCA Build Complete in ${metrics.totalTime.toFixed(0)}ms
+`);
+  console.log("\u23F1\uFE0F  Timing Breakdown:");
+  console.log(`   Initialization:  ${metrics.stages.initialization.toFixed(0)}ms`);
+  console.log(`   CSS Processing:  ${metrics.stages.cssProcessing.toFixed(0)}ms`);
+  console.log(`   Page Generation: ${metrics.stages.pageGeneration.toFixed(0)}ms`);
+  console.log(`   Feed Generation: ${metrics.stages.feedGeneration.toFixed(0)}ms`);
+  console.log(`   Asset Copying:   ${metrics.stages.assetCopying.toFixed(0)}ms`);
+  console.log(`
+\uD83D\uDCE6 Output:`);
+  console.log(`   Posts:     ${metrics.outputs.posts}`);
+  console.log(`   Pages:     ${metrics.outputs.pages}`);
+  console.log(`   Total:     ${formatBytes(metrics.outputs.totalSize)}
+`);
+}
+
+// src/site-generator.ts
+class SiteGenerator {
+  options;
+  site;
+  metrics;
+  cache = null;
+  incrementalMode = false;
+  constructor(options2) {
+    this.options = options2;
+    this.site = {
+      name: options2.config.domain,
+      posts: [],
+      tags: {},
+      postsByYear: {}
+    };
+    this.metrics = new MetricsCollector;
+    const env = import_nunjucks2.default.configure(this.options.templatesDir, {
+      autoescape: true,
+      watch: false,
+      noCache: false
+    });
+    env.addFilter("date", (date, format) => {
+      const d2 = toPacificTime(date);
+      const months = [
+        "January",
+        "February",
+        "March",
+        "April",
+        "May",
+        "June",
+        "July",
+        "August",
+        "September",
+        "October",
+        "November",
+        "December"
+      ];
+      if (format === "YYYY") {
+        return d2.getFullYear();
+      } else if (format === "MMMM D, YYYY") {
+        return `${months[d2.getMonth()]} ${d2.getDate()}, ${d2.getFullYear()}`;
+      } else if (format === "MMMM D, YYYY h:mm A") {
+        const hours = d2.getHours() % 12 || 12;
+        const ampm = d2.getHours() >= 12 ? "PM" : "AM";
+        return `${months[d2.getMonth()]} ${d2.getDate()}, ${d2.getFullYear()} @ ${hours} ${ampm}`;
+      } else {
+        return d2.toLocaleDateString("en-US", {
+          timeZone: "America/Los_Angeles"
+        });
       }
+    });
+  }
+  enableIncrementalMode() {
+    this.incrementalMode = true;
+  }
+  async initialize() {
+    this.metrics.startStage("initialization");
+    console.log("Initializing site generator...");
+    await ensureDir(this.options.outputDir);
+    if (this.options.config.noFollowExceptions) {
+      setNoFollowExceptions(this.options.config.noFollowExceptions);
     }
-    for (const post of this.site.posts) {
-      const postUrl = `${config.baseUrl}${post.url}`;
-      const postDate = new Date(post.date).toISOString();
-      const priority = calculatePriority(post.date, 0.7);
-      const age = now - new Date(post.date).getTime();
-      const changefreq = age < ONE_MONTH ? "weekly" : "monthly";
-      sitemapContent += `  <url>
-    <loc>${postUrl}</loc>
-    <lastmod>${postDate}</lastmod>
-    <changefreq>${changefreq}</changefreq>
-    <priority>${priority.toFixed(1)}</priority>
-  </url>
-`;
-    }
-    sitemapContent += `  <url>
-    <loc>${config.baseUrl}/tags/</loc>
-    <lastmod>${currentDate}</lastmod>
-    <changefreq>weekly</changefreq>
-    <priority>0.5</priority>
-  </url>
-`;
-    sitemapContent += `  <url>
-    <loc>${config.baseUrl}/map/</loc>
-    <lastmod>${currentDate}</lastmod>
-    <changefreq>weekly</changefreq>
-    <priority>0.6</priority>
-  </url>
-`;
-    for (const [, tagData] of Object.entries(this.site.tags)) {
-      const tagUrl = `${config.baseUrl}/tags/${tagData.slug}/`;
-      const mostRecentPost = tagData.posts[0];
-      const tagPriority = mostRecentPost ? calculatePriority(mostRecentPost.date, 0.4) : 0.4;
-      sitemapContent += `  <url>
-    <loc>${tagUrl}</loc>
-    <lastmod>${currentDate}</lastmod>
-    <changefreq>weekly</changefreq>
-    <priority>${tagPriority.toFixed(1)}</priority>
-  </url>
-`;
-      const totalTagPages = Math.ceil(tagData.posts.length / pageSize);
-      if (totalTagPages > 1) {
-        for (let page = 2;page <= totalTagPages; page++) {
-          sitemapContent += `  <url>
-    <loc>${config.baseUrl}/tags/${tagData.slug}/page/${page}/</loc>
-    <lastmod>${currentDate}</lastmod>
-    <changefreq>weekly</changefreq>
-    <priority>${Math.max(0.3, tagPriority - 0.1).toFixed(1)}</priority>
-  </url>
-`;
-        }
+    let tagDescriptions = {};
+    const tagsTomlPath = path9.join(process.cwd(), "src", "tags.toml");
+    const tagsTomlFile = Bun.file(tagsTomlPath);
+    if (await tagsTomlFile.exists()) {
+      try {
+        tagDescriptions = __require(tagsTomlPath);
+        console.log("Loaded tag descriptions from tags.toml");
+      } catch (error) {
+        console.warn("Error loading tag descriptions:", error);
       }
     }
-    for (const [year, yearPosts] of Object.entries(this.site.postsByYear)) {
-      const currentYear = new Date().getFullYear();
-      const isCurrentYear = parseInt(year) === currentYear;
-      const yearPriority = isCurrentYear ? 0.7 : 0.5;
-      sitemapContent += `  <url>
-    <loc>${config.baseUrl}/${year}/</loc>
-    <lastmod>${currentDate}</lastmod>
-    <changefreq>${isCurrentYear ? "weekly" : "monthly"}</changefreq>
-    <priority>${yearPriority.toFixed(1)}</priority>
-  </url>
-`;
-      const totalYearPages = Math.ceil(yearPosts.length / pageSize);
-      if (totalYearPages > 1) {
-        for (let page = 2;page <= totalYearPages; page++) {
-          sitemapContent += `  <url>
-    <loc>${config.baseUrl}/${year}/page/${page}/</loc>
-    <lastmod>${currentDate}</lastmod>
-    <changefreq>${isCurrentYear ? "weekly" : "monthly"}</changefreq>
-    <priority>${(yearPriority - 0.1).toFixed(1)}</priority>
-  </url>
-`;
+    if (this.incrementalMode) {
+      this.cache = await loadCache(process.cwd());
+    }
+    const posts = await this.parseContent();
+    const tags = {};
+    posts.forEach((post) => {
+      post.tagSlugs = {};
+      const imageUrl = extractFirstImageUrl(post.html, this.options.config.baseUrl);
+      if (imageUrl) {
+        post.image = imageUrl;
+      }
+      post.tags.forEach((tagName) => {
+        const tagSlug = import_slugify.default(tagName, { lower: true, strict: true });
+        post.tagSlugs[tagName] = tagSlug;
+        if (!tags[tagName]) {
+          const tagData = {
+            name: tagName,
+            slug: tagSlug,
+            count: 0,
+            posts: []
+          };
+          if (tagDescriptions[tagName.toLowerCase()]) {
+            tagData.description = tagDescriptions[tagName.toLowerCase()];
+          }
+          tags[tagName] = tagData;
         }
+        tags[tagName].count += 1;
+        tags[tagName].posts.push(post);
+      });
+    });
+    this.site = {
+      name: this.options.config.domain,
+      posts,
+      tags,
+      postsByYear: this.groupPostsByYear(posts)
+    };
+  }
+  async generate() {
+    console.log("Generating static site...");
+    await ensureDir(this.options.outputDir);
+    this.metrics.startStage("cssProcessing");
+    let cssChanged = true;
+    if (this.cache && this.incrementalMode && this.options.config.css) {
+      const cssInputPath = path9.resolve(process.cwd(), this.options.config.css.input);
+      const cssOutputPath = path9.join(this.options.outputDir, this.options.config.css.output);
+      const cssOutputExists = await Bun.file(cssOutputPath).exists();
+      cssChanged = await hasFileChanged(cssInputPath, this.cache);
+      if (!cssChanged && cssOutputExists) {
+        console.log("\u23ED\uFE0F  Skipping CSS (unchanged)");
+      } else {
+        await generateStylesheet(this.options.config, this.options.outputDir);
+        await updateCacheEntry(cssInputPath, this.cache);
       }
+    } else {
+      await generateStylesheet(this.options.config, this.options.outputDir);
     }
-    sitemapContent += `</urlset>`;
-    await Bun.write(path6.join(this.options.outputDir, "sitemap.xml"), sitemapContent);
+    this.metrics.startStage("pageGeneration");
+    await Promise.all([
+      generateIndexPages(this.site, this.options.config, this.options.outputDir),
+      generatePostPages(this.site, this.options.config, this.options.outputDir),
+      generateTagPages(this.site, this.options.config, this.options.outputDir),
+      generateYearArchives(this.site, this.options.config, this.options.outputDir),
+      generateMapPage(this.site, this.options.config, this.options.outputDir),
+      generate404Page(this.options.config, this.options.outputDir)
+    ]);
+    this.metrics.startStage("assetCopying");
+    await copyStaticAssets(this.options.templatesDir, this.options.outputDir);
+    this.metrics.startStage("feedGeneration");
+    await this.generateFeeds();
+    const outputStats = await this.calculateOutputStats();
+    const buildMetrics = this.metrics.getMetrics(outputStats);
+    displayMetrics(buildMetrics);
+    if (this.cache) {
+      await saveCache(process.cwd(), this.cache);
+    }
+  }
+  async generateFeeds() {
+    const pageSize = 10;
+    const rssContent = generateRSSFeed(this.site, this.options.config);
+    await Bun.write(path9.join(this.options.outputDir, "feed.xml"), rssContent);
+    const sitemapContent = generateSitemap(this.site, this.options.config, pageSize);
+    await Bun.write(path9.join(this.options.outputDir, "sitemap.xml"), sitemapContent);
     console.log("Generated sitemap.xml");
     const urlCount = this.site.posts.length + Object.keys(this.site.tags).length + 10;
     const sitemapSize = sitemapContent.length;
     if (urlCount > 1000 || sitemapSize > 40000) {
-      await this.generateSitemapIndex();
+      const sitemapIndexContent = generateSitemapIndex(this.options.config);
+      await Bun.write(path9.join(this.options.outputDir, "sitemap_index.xml"), sitemapIndexContent);
+      console.log("Generated sitemap_index.xml");
     }
+    const robotsTxtContent = generateRobotsTxt(this.options.config);
+    await Bun.write(path9.join(this.options.outputDir, "robots.txt"), robotsTxtContent);
+    console.log("Generated robots.txt");
   }
-  async generateSitemapIndex() {
-    const currentDate = toPacificTime(new Date).toISOString();
-    const config = this.options.config;
-    let sitemapIndexContent = `<?xml version="1.0" encoding="UTF-8"?>
-<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-`;
-    sitemapIndexContent += `  <sitemap>
-    <loc>${config.baseUrl}/sitemap.xml</loc>
-    <lastmod>${currentDate}</lastmod>
-  </sitemap>
-`;
-    sitemapIndexContent += `</sitemapindex>`;
-    await Bun.write(path6.join(this.options.outputDir, "sitemap_index.xml"), sitemapIndexContent);
-    console.log("Generated sitemap_index.xml");
+  async parseContent() {
+    const strictMode = this.options.config.strictMode ?? false;
+    if (!this.incrementalMode || !this.cache) {
+      const posts = await parseMarkdownDirectory(this.options.contentDir, strictMode, this.options.config.cdn);
+      if (this.cache) {
+        const allFiles2 = await findFilesByPattern("**/*.md", this.options.contentDir, true);
+        const postsByPath = new Map(posts.map((p) => [p.url, p]));
+        for (let i = 0;i < allFiles2.length; i++) {
+          const filePath = allFiles2[i];
+          const post = posts[i];
+          await updateCacheEntry(filePath, this.cache, { post });
+        }
+      }
+      return posts;
+    }
+    const allFiles = await findFilesByPattern("**/*.md", this.options.contentDir, true);
+    const configPath = path9.join(process.cwd(), "bunki.config.ts");
+    const configChanged = await hasConfigChanged(configPath, this.cache);
+    if (configChanged) {
+      console.log("Config changed, full rebuild required");
+      return this.parseContent();
+    }
+    const changes = await detectChanges(allFiles, this.cache);
+    if (changes.fullRebuild) {
+      console.log("Full rebuild required");
+      this.incrementalMode = false;
+      return this.parseContent();
+    }
+    if (changes.changedPosts.length === 0) {
+      console.log("No content changes detected, using cached posts");
+      const cachedPosts2 = loadCachedPosts(this.cache, allFiles);
+      console.log(`\u2728 Loaded ${cachedPosts2.length} posts from cache (0ms parsing)`);
+      return cachedPosts2;
+    }
+    const timeSaved = estimateTimeSaved(allFiles.length, changes.changedPosts.length);
+    console.log(`\uD83D\uDCE6 Incremental build: ${changes.changedPosts.length}/${allFiles.length} files changed (~${timeSaved}ms saved)`);
+    const changedPostsWithPaths = await parseMarkdownFiles(changes.changedPosts, this.options.config.cdn);
+    const unchangedFiles = allFiles.filter((f) => !changes.changedPosts.includes(f));
+    const cachedPosts = loadCachedPosts(this.cache, unchangedFiles);
+    console.log(`   Parsed: ${changedPostsWithPaths.length} new/changed, loaded: ${cachedPosts.length} from cache`);
+    const changedPosts = changedPostsWithPaths.map((p) => p.post);
+    const allPosts = [...changedPosts, ...cachedPosts].sort((a, b2) => new Date(b2.date).getTime() - new Date(a.date).getTime());
+    for (const { post, filePath } of changedPostsWithPaths) {
+      await updateCacheEntry(filePath, this.cache, { post });
+    }
+    return allPosts;
   }
-  async generateRobotsTxt() {
-    const config = this.options.config;
-    const robotsTxtContent = `# Robots.txt for ${config.domain}
-# Generated by Bunki
-
-User-agent: *
-Allow: /
-
-# Sitemaps
-Sitemap: ${config.baseUrl}/sitemap.xml
-
-# Crawl-delay (optional, adjust as needed)
-# Crawl-delay: 1
-
-# Disallow specific paths (uncomment as needed)
-# Disallow: /private/
-# Disallow: /admin/
-# Disallow: /api/
-`;
-    await Bun.write(path6.join(this.options.outputDir, "robots.txt"), robotsTxtContent);
-    console.log("Generated robots.txt");
+  groupPostsByYear(posts) {
+    const postsByYear = {};
+    for (const post of posts) {
+      const year = getPacificYear(post.date).toString();
+      if (!postsByYear[year]) {
+        postsByYear[year] = [];
+      }
+      postsByYear[year].push(post);
+    }
+    return postsByYear;
+  }
+  async calculateOutputStats() {
+    const outputDir = this.options.outputDir;
+    let totalSize = 0;
+    let pageCount = 0;
+    try {
+      const { Glob: Glob3 } = await Promise.resolve(globalThis.Bun);
+      const glob = new Glob3("**/*.html");
+      for await (const filePath of glob.scan({
+        cwd: outputDir,
+        absolute: true
+      })) {
+        pageCount++;
+        const stat = await Bun.file(filePath).stat();
+        if (stat) {
+          totalSize += stat.size;
+        }
+      }
+    } catch (error) {
+      console.warn("Could not calculate output stats:", error);
+    }
+    return {
+      posts: this.site.posts.length,
+      pages: pageCount,
+      totalSize
+    };
   }
 }
 // src/utils/image-uploader.ts
-import path8 from "path";
+import path11 from "path";
 
 // src/utils/s3-uploader.ts
 var {S3Client } = globalThis.Bun;
-import path7 from "path";
+import path10 from "path";
 
 class S3Uploader {
   s3Config;
@@ -32368,8 +32695,8 @@ class S3Uploader {
       let failedCount = 0;
       const uploadTasks = imageFiles.map((imageFile) => async () => {
         try {
-          const imagePath = path7.join(imagesDir, imageFile);
-          const filename = path7.basename(imagePath);
+          const imagePath = path10.join(imagesDir, imageFile);
+          const filename = path10.basename(imagePath);
           const file = Bun.file(imagePath);
           const contentType = file.type;
           if (process.env.BUNKI_DRY_RUN === "true") {} else {
@@ -32403,10 +32730,10 @@ function createUploader(config) {
 }
 
 // src/utils/image-uploader.ts
-var DEFAULT_IMAGES_DIR = path8.join(process.cwd(), "assets");
+var DEFAULT_IMAGES_DIR = path11.join(process.cwd(), "assets");
 async function uploadImages(options2 = {}) {
   try {
-    const imagesDir = path8.resolve(options2.images || DEFAULT_IMAGES_DIR);
+    const imagesDir = path11.resolve(options2.images || DEFAULT_IMAGES_DIR);
     if (!await fileExists(imagesDir)) {
       console.log(`Creating images directory at ${imagesDir}...`);
       await ensureDir(imagesDir);
@@ -32443,7 +32770,7 @@ async function uploadImages(options2 = {}) {
     const uploader = createUploader(s3Config);
     const imageUrlMap = await uploader.uploadImages(imagesDir, options2.minYear);
     if (options2.outputJson) {
-      const outputFile = path8.resolve(options2.outputJson);
+      const outputFile = path11.resolve(options2.outputJson);
       await Bun.write(outputFile, JSON.stringify(imageUrlMap, null, 2));
       console.log(`Image URL mapping saved to ${outputFile}`);
     }