meno-core 1.1.2 → 1.1.4

package/dist/lib/server/index.js

@@ -33,7 +33,7 @@ import {
   processStructure,
   resolveHtmlMapping,
   skipEmptyTemplateAttributes
-} from "../../chunks/chunk-7ZLF4NE5.js";
+} from "../../chunks/chunk-ZEDLSHYQ.js";
 import {
   DEFAULT_BREAKPOINTS,
   DEFAULT_FLUID_RANGE,
@@ -86,13 +86,14 @@ import {
   resolveTemplateRawValue,
   responsiveStylesToClasses,
   rewriteViewportUnits,
+  rewriteViewportUnitsInStylesheet,
   scalePropertyValue,
   singularize,
   toFriendlyError,
   validateCMSDraftItem,
   validateCMSItem,
   validateComponentDefinition
-} from "../../chunks/chunk-J4IPTP5X.js";
+} from "../../chunks/chunk-UOF4MCAD.js";
 import {
   DEFAULT_I18N_CONFIG,
   buildLocalizedPath,
@@ -165,10 +166,10 @@ var WebSocketManager = class {
   /**
    * Broadcast update notification
    */
-  broadcastUpdate(path3) {
+  broadcastUpdate(path5) {
     this.broadcast({
       type: "hmr:update",
-      path: path3 || "all"
+      path: path5 || "all"
     });
   }
   /**
@@ -284,7 +285,7 @@ init_constants();
 // lib/server/middleware/cors.ts
 var DEFAULT_OPTIONS = {
   origin: "*",
-  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+  methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
   allowedHeaders: ["Content-Type", "Authorization"],
   credentials: false
 };
@@ -1518,8 +1519,8 @@ function cachedJsonResponse(req, body, options = {}) {
 }
 
 // lib/server/routes/api/pages.ts
-function handlePagesRoute(pageService) {
-  const pages = pageService.getAllPagesWithInfo();
+async function handlePagesRoute(pageService) {
+  const pages = await pageService.getAllPagesWithInfo();
   return jsonResponse({ pages });
 }
 function handlePageDataRoute(url, pageService) {
@@ -1641,11 +1642,11 @@ function handleComponentUsageRoute(pageService, componentService) {
     }
   }
   const pagePaths = pageService.getAllPagePaths();
-  for (const path3 of pagePaths) {
-    const pageData = pageService.getPageData(path3);
+  for (const path5 of pagePaths) {
+    const pageData = pageService.getPageData(path5);
     if (pageData && "root" in pageData && pageData.root) {
-      const name = path3 === "/" ? "index" : path3.replace(/^\//, "").replace(/\//g, "-");
-      walkTree(pageData.root, name, path3, "page");
+      const name = path5 === "/" ? "index" : path5.replace(/^\//, "").replace(/\//g, "-");
+      walkTree(pageData.root, name, path5, "page");
     }
   }
   const allComponents = componentService.getAllComponents();
@@ -1755,9 +1756,24 @@ function sectionLabelForGroup(group) {
   if (!group || group === "other") return OTHER_LABEL;
   return VARIABLE_GROUPS.find((g) => g.value === group)?.label ?? OTHER_LABEL;
 }
-var LABEL_TO_GROUP = new Map(VARIABLE_GROUPS.map((g) => [g.label.toLowerCase(), g.value]));
+function normalizeSectionLabel(s) {
+  return s.trim().toLowerCase().replace(/[-–—]+/g, " ").replace(/\s+/g, " ").trim();
+}
+var NORMALIZED_LABEL_TO_GROUP = new Map(
+  VARIABLE_GROUPS.map((g) => [normalizeSectionLabel(g.label), g.value])
+);
+var PREFIX_LABELS = VARIABLE_GROUPS.filter((g) => g.value !== "other").map((g) => ({ norm: normalizeSectionLabel(g.label), group: g.value })).sort((a, b) => b.norm.length - a.norm.length);
 function groupForSectionLabel(label) {
-  return LABEL_TO_GROUP.get(label.trim().toLowerCase()) ?? null;
+  const norm = normalizeSectionLabel(label);
+  const exact = NORMALIZED_LABEL_TO_GROUP.get(norm);
+  if (exact) return exact;
+  for (const { norm: labelNorm, group } of PREFIX_LABELS) {
+    if (norm.startsWith(labelNorm)) {
+      const next = norm.charAt(labelNorm.length);
+      if (next === "" || !/[a-z0-9]/.test(next)) return group;
+    }
+  }
+  return null;
 }
 function isColorValue(value) {
   const v = value.trim().toLowerCase();
@@ -1766,6 +1782,11 @@ function isColorValue(value) {
   if (v === "transparent" || v === "currentcolor") return true;
   return false;
 }
+var NAME_HINT_GROUPS = [
+  { needle: /(^|[-_])tracking([-_]|$)/, group: "letter-spacing" },
+  { needle: /(^|[-_])leading([-_]|$)/, group: "line-height" },
+  { needle: /(^|[-_])(radius|rounded)([-_]|$)/, group: "border-radius" }
+];
 function inferGroup(cssVar, value) {
   const v = value.trim().toLowerCase();
   if (/^\d+(\.\d+)?m?s$/.test(v)) return "duration";
@@ -1776,6 +1797,9 @@ function inferGroup(cssVar, value) {
   }
   if (/^\d*\.\d+$/.test(v) || /^[1-9](\.\d+)?$/.test(v)) return "line-height";
   const name = cssVar.replace(/^--/, "").toLowerCase();
+  for (const { needle, group } of NAME_HINT_GROUPS) {
+    if (needle.test(name)) return group;
+  }
   for (const g of VARIABLE_GROUPS) {
     if (g.value !== "other" && name.includes(g.value)) return g.value;
   }
@@ -2057,8 +2081,7 @@ function parseThemeCss(css, breakpoints) {
             const dn = inner.match(/^colors\s*:\s*([\w-]+)/i);
             if (dn) defaultName = dn[1];
           } else {
-            const g = groupForSectionLabel(inner);
-            if (g) section = g;
+            section = groupForSectionLabel(inner);
           }
           continue;
         }
@@ -2134,9 +2157,9 @@ function enqueue(fn) {
   );
   return run;
 }
-async function readJsonSafe(path3) {
+async function readJsonSafe(path5) {
   try {
-    return JSON.parse(await readTextFile(path3));
+    return JSON.parse(await readTextFile(path5));
   } catch {
     return null;
   }
@@ -2148,9 +2171,9 @@ function emptyModel() {
   return { themes: { default: "default", themes: { default: { colors: {} } } }, variables: [], raw: [] };
 }
 async function readModel(root) {
-  const path3 = themeCssPath(root);
-  if (!await fileExists(path3)) return emptyModel();
-  return parseThemeCss(await readTextFile(path3), configService.getBreakpoints());
+  const path5 = themeCssPath(root);
+  if (!await fileExists(path5)) return emptyModel();
+  return parseThemeCss(await readTextFile(path5), configService.getBreakpoints());
 }
 async function writeModel(root, model) {
   const css = serializeThemeCss(model, scaleConfig());
@@ -2880,8 +2903,880 @@ async function handleItemRoute(collection, slug, cmsService) {
   return jsonResponse({ item: match.item });
 }
 
-// lib/server/routes/api/functions.ts
+// lib/server/routes/api/cssAudit.ts
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync } from "node:fs";
 import path from "node:path";
+
+// lib/server/cssAudit.ts
+import * as csstree from "css-tree";
+var DEFAULT_UTILITY_HINTS = [
+  // Spacing / sizing
+  "^(margin|padding|gap)(-|$)",
+  "^no-(padding|margin|overflow)",
+  "(^|-)auto-margin$",
+  "^(max|min)-(w|h|width|height)",
+  "^(w|h)-[0-9]",
+  "^size-[0-9]",
+  "^(small|medium|large)(-|$)",
+  // Layout / display
+  "^align(-|$)",
+  "^justify(-|$)",
+  "^(grid|col|flex)-",
+  "^container(-|$)",
+  "(^|-)(overflow|opacity|relative|absolute|sticky|inline|centered)(-|$)",
+  "^(hide|show|hidden|visible)$",
+  // State / Webflow combo classes
+  "^is--?",
+  "^has--?",
+  "^on-h[0-9]",
+  "^type-[0-9]+$",
+  "(^|-)active$",
+  // Colors
+  "(^|-)(white|black|dark|light|primary|secondary|grey|gray)(-|$)",
+  // Cross-cutting UI
+  "(^|-)arrow",
+  // Relume / newer-Webflow utility families (text-size-*, heading-style-*, spacer-*, max-width-*)
+  "^text-(size|align|color|weight|style)",
+  "^heading-style",
+  "^(spacer|max-width|background-color)(-|$)"
+];
+var DEFAULT_WEBFLOW_AUTO = [
+  "^(div-block|text-block|link-block|bold-text|block-quote|rich-text-block|html-embed)(-\\d+)?$",
+  "^(heading|paragraph|image|list|list-item|figure|grid|columns?|field-label|text-field)-\\d+$"
+];
+var CLASS_TOKEN_RE = /\.(-?[_a-zA-Z][\w-]*)/g;
+var FUNCTIONAL_PSEUDO_RE = /:(not|is|where|has|matches)\([^()]*\)/gi;
+function emptyBucket() {
+  return { classes: 0, rules: 0, declarations: 0, approxBytes: 0 };
+}
+function classTokens(selector) {
+  const out = [];
+  let m;
+  CLASS_TOKEN_RE.lastIndex = 0;
+  while ((m = CLASS_TOKEN_RE.exec(selector)) !== null) {
+    if (m[1]) out.push(m[1]);
+  }
+  return out;
+}
+function sectionPrefix(name) {
+  const seg = name.split(/[-_]/)[0] ?? name;
+  const stripped = seg.replace(/\d+$/, "");
+  return stripped.length > 0 ? stripped : seg;
+}
+function commonPrefixLength(a, b) {
+  const max = Math.min(a.length, b.length);
+  let i = 0;
+  while (i < max && a[i] === b[i]) i++;
+  return i;
+}
+function editDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = Array.from({ length: n + 1 }, (_, i) => i);
+  let curr = new Array(n + 1).fill(0);
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min((prev[j] ?? 0) + 1, (curr[j - 1] ?? 0) + 1, (prev[j - 1] ?? 0) + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n] ?? 0;
+}
+function nearestKeptPrefix(prefix, kept) {
+  let best = null;
+  let bestShared = -1;
+  for (const candidate of kept) {
+    if (Math.abs(candidate.length - prefix.length) > 1) continue;
+    const shared = commonPrefixLength(prefix, candidate);
+    if (shared < 2) continue;
+    if (editDistance(prefix, candidate) !== 1) continue;
+    if (shared > bestShared) {
+      bestShared = shared;
+      best = candidate;
+    }
+  }
+  return best;
+}
+function analyzeSelector(selector) {
+  const cleaned = selector.replace(FUNCTIONAL_PSEUDO_RE, " ");
+  const segments = cleaned.split(/\s*[>+~]\s*|\s+/).filter((s) => s.trim().length > 0);
+  const subject = segments[segments.length - 1] ?? cleaned;
+  const subjectClasses = classTokens(subject);
+  const allClasses = classTokens(selector);
+  const compound = segments.length > 1 || subjectClasses.length > 1;
+  return { allClasses, subjectClasses, compound };
+}
+function countDeclarations(block) {
+  let count = 0;
+  if (block && block.type === "Block") {
+    block.children.forEach((child) => {
+      if (child.type === "Declaration") count++;
+    });
+  }
+  return count;
+}
+function extractRules(css) {
+  const ast = csstree.parse(css, { parseValue: false, parseCustomProperty: false });
+  const out = [];
+  const visit = (container, media, insideSkippedAtrule) => {
+    const children = "children" in container ? container.children : null;
+    if (!children) return;
+    children.forEach((node) => {
+      if (node.type === "Atrule") {
+        const name = node.name.toLowerCase();
+        if (name === "media") {
+          const prelude = node.prelude ? csstree.generate(node.prelude) : "";
+          if (node.block) visit(node.block, prelude, false);
+        } else if (name === "supports") {
+          if (node.block) visit(node.block, media, false);
+        } else if (node.block) {
+          visit(node.block, media, true);
+        }
+        return;
+      }
+      if (node.type !== "Rule" || insideSkippedAtrule) return;
+      if (node.prelude?.type !== "SelectorList") return;
+      const decls = countDeclarations(node.block);
+      const ruleBytes = csstree.generate(node).length;
+      const classSelectors = [];
+      node.prelude.children.forEach((selectorNode) => {
+        const text = csstree.generate(selectorNode);
+        const shape = analyzeSelector(text);
+        if (shape.allClasses.length > 0) classSelectors.push({ text, shape });
+      });
+      if (classSelectors.length === 0) return;
+      const perBytes = Math.max(1, Math.round(ruleBytes / classSelectors.length));
+      for (const { text, shape } of classSelectors) {
+        out.push({
+          selector: text,
+          media,
+          classes: shape.allClasses,
+          subjectClasses: shape.subjectClasses,
+          declarations: decls,
+          bytes: perBytes,
+          compound: shape.compound
+        });
+      }
+    });
+  };
+  visit(ast, null, false);
+  return out;
+}
+function auditStylesheet(input) {
+  const { css, pages, options = {} } = input;
+  const selectorSampleLimit = options.selectorSampleLimit ?? 5;
+  const flagLimit = options.flagLimit ?? 200;
+  const minSectionClasses = options.minSectionClasses ?? 3;
+  const miscBucketName = options.miscBucketName ?? "misc";
+  const mergeTypos = options.mergeTypos ?? true;
+  const utilityHints = (options.utilityHints ?? DEFAULT_UTILITY_HINTS).map((s) => new RegExp(s));
+  const webflowAutoPatterns = (options.webflowAuto ?? DEFAULT_WEBFLOW_AUTO).map((s) => new RegExp(s));
+  const pageCount = pages.length;
+  const sharedMinPages = options.sharedMinPages ?? Math.max(2, Math.ceil(pageCount / 2));
+  const pageUseCount = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    for (const cls of new Set(page.classes)) {
+      pageUseCount.set(cls, (pageUseCount.get(cls) ?? 0) + 1);
+    }
+  }
+  const ast = csstree.parse(css, { parseValue: false, parseCustomProperty: false });
+  const classMap = /* @__PURE__ */ new Map();
+  const rules = [];
+  const breakpoints = [];
+  const seenMedia = /* @__PURE__ */ new Set();
+  const base = emptyBucket();
+  let totalRules = 0;
+  let totalSelectors = 0;
+  let totalDeclarations = 0;
+  const accumFor = (name) => {
+    let a = classMap.get(name);
+    if (!a) {
+      a = { name, ruleCount: 0, declarations: 0, breakpoints: /* @__PURE__ */ new Set(), selectors: [], ownsSimple: false };
+      classMap.set(name, a);
+    }
+    return a;
+  };
+  const visit = (container, media, insideSkippedAtrule) => {
+    const children = "children" in container ? container.children : null;
+    if (!children) return;
+    children.forEach((node) => {
+      if (node.type === "Atrule") {
+        const name = node.name.toLowerCase();
+        if (name === "media") {
+          const prelude = node.prelude ? csstree.generate(node.prelude) : "";
+          if (!seenMedia.has(prelude)) {
+            seenMedia.add(prelude);
+            breakpoints.push(prelude);
+          }
+          if (node.block) visit(node.block, prelude, false);
+        } else if (name === "supports") {
+          if (node.block) visit(node.block, media, false);
+        } else if (node.block) {
+          visit(node.block, media, true);
+        }
+        return;
+      }
+      if (node.type !== "Rule" || insideSkippedAtrule) return;
+      if (node.prelude?.type !== "SelectorList") return;
+      const ruleBytes = csstree.generate(node).length;
+      const decls = countDeclarations(node.block);
+      totalDeclarations += decls;
+      totalRules += 1;
+      const ruleAllClasses = /* @__PURE__ */ new Set();
+      const ruleSubjectClasses = /* @__PURE__ */ new Set();
+      let hasAnyClass = false;
+      node.prelude.children.forEach((selectorNode) => {
+        totalSelectors += 1;
+        const selectorText = csstree.generate(selectorNode);
+        const shape = analyzeSelector(selectorText);
+        if (shape.allClasses.length === 0) return;
+        hasAnyClass = true;
+        for (const c of shape.allClasses) ruleAllClasses.add(c);
+        for (const c of shape.subjectClasses) ruleSubjectClasses.add(c);
+        const subjectSet = new Set(shape.subjectClasses);
+        for (const cls of shape.allClasses) {
+          const a = accumFor(cls);
+          a.ruleCount += 1;
+          a.declarations += decls;
+          a.breakpoints.add(media ?? "");
+          if (a.selectors.length < selectorSampleLimit && !a.selectors.includes(selectorText)) {
+            a.selectors.push(selectorText);
+          }
+          if (subjectSet.size === 1 && subjectSet.has(cls)) a.ownsSimple = true;
+        }
+      });
+      if (!hasAnyClass) {
+        base.rules += 1;
+        base.declarations += decls;
+        base.approxBytes += ruleBytes;
+        return;
+      }
+      rules.push({
+        media,
+        bytes: ruleBytes,
+        declarations: decls,
+        classes: [...ruleAllClasses],
+        subjectClasses: [...ruleSubjectClasses]
+      });
+    });
+  };
+  visit(ast, null, false);
+  const prelim = /* @__PURE__ */ new Map();
+  const sectionSizes = /* @__PURE__ */ new Map();
+  for (const a of classMap.values()) {
+    const pagesUsedIn = pageUseCount.get(a.name) ?? 0;
+    let category;
+    let bucket;
+    if (/^w-/.test(a.name)) {
+      category = "vendor";
+      bucket = "vendor";
+    } else if (webflowAutoPatterns.some((re) => re.test(a.name))) {
+      category = "webflow-auto";
+      bucket = "webflow-auto";
+    } else if (utilityHints.some((re) => re.test(a.name)) || pagesUsedIn >= sharedMinPages) {
+      category = "shared";
+      bucket = "shared";
+    } else {
+      category = "section";
+      bucket = sectionPrefix(a.name);
+      sectionSizes.set(bucket, (sectionSizes.get(bucket) ?? 0) + 1);
+    }
+    prelim.set(a.name, { category, bucket, pagesUsedIn, accum: a });
+  }
+  const keptSections = /* @__PURE__ */ new Set();
+  for (const [prefix, count] of sectionSizes) {
+    if (count >= minSectionClasses) keptSections.add(prefix);
+  }
+  const sectionRemap = /* @__PURE__ */ new Map();
+  for (const [prefix, count] of sectionSizes) {
+    if (keptSections.has(prefix) || count === 0) continue;
+    const near = mergeTypos && prefix.length >= 4 ? nearestKeptPrefix(prefix, keptSections) : null;
+    sectionRemap.set(prefix, near ? { bucket: near, reason: "typo" } : { bucket: miscBucketName, reason: "small" });
+  }
+  const foldedAgg = /* @__PURE__ */ new Map();
+  const classified = /* @__PURE__ */ new Map();
+  const classes = [];
+  for (const [name, p] of prelim) {
+    let bucket = p.bucket;
+    if (p.category === "section") {
+      const remap = sectionRemap.get(p.bucket);
+      if (remap) {
+        bucket = remap.bucket;
+        const key = `${p.bucket}\u2192${remap.bucket}`;
+        const agg = foldedAgg.get(key) ?? { from: p.bucket, into: remap.bucket, reason: remap.reason, classes: 0 };
+        agg.classes += 1;
+        foldedAgg.set(key, agg);
+      }
+    }
+    classified.set(name, { category: p.category, bucket });
+    classes.push({
+      name,
+      category: p.category,
+      proposedBucket: bucket,
+      ruleCount: p.accum.ruleCount,
+      declarations: p.accum.declarations,
+      breakpoints: [...p.accum.breakpoints].sort(),
+      pagesUsedIn: p.pagesUsedIn,
+      selectors: p.accum.selectors,
+      compoundOnly: !p.accum.ownsSimple
+    });
+  }
+  classes.sort((x, y) => y.declarations - x.declarations || x.name.localeCompare(y.name));
+  const foldedSections = [...foldedAgg.values()].map(({ from, into, classes: c, reason }) => ({ from, into, classes: c, reason })).sort((a, b) => b.classes - a.classes || a.from.localeCompare(b.from));
+  const vendor = emptyBucket();
+  const webflowAuto = emptyBucket();
+  const shared = emptyBucket();
+  const sections = {};
+  const crossBoundary = [];
+  const bucketStat = (bucket) => {
+    if (bucket === "vendor") return vendor;
+    if (bucket === "webflow-auto") return webflowAuto;
+    if (bucket === "shared") return shared;
+    let stat = sections[bucket];
+    if (!stat) {
+      stat = emptyBucket();
+      sections[bucket] = stat;
+    }
+    return stat;
+  };
+  for (const rule of rules) {
+    const ownerPool = rule.subjectClasses.length > 0 ? rule.subjectClasses : rule.classes;
+    let owner = "base";
+    let bestRank = -1;
+    const sectionBucketsTouched = /* @__PURE__ */ new Set();
+    for (const cls of rule.classes) {
+      const c = classified.get(cls);
+      if (c?.category === "section" && c.bucket !== miscBucketName) sectionBucketsTouched.add(c.bucket);
+    }
+    for (const cls of ownerPool) {
+      const c = classified.get(cls);
+      if (!c) continue;
+      const rank = c.category === "section" ? 4 : c.category === "shared" ? 3 : c.category === "webflow-auto" ? 2 : 1;
+      if (rank > bestRank) {
+        bestRank = rank;
+        owner = c.bucket;
+      }
+    }
+    const stat = bucketStat(owner);
+    stat.rules += 1;
+    stat.declarations += rule.declarations;
+    stat.approxBytes += rule.bytes;
+    if (sectionBucketsTouched.size >= 2 && crossBoundary.length < flagLimit) {
+      crossBoundary.push({
+        selector: rule.classes.map((c) => `.${c}`).join(""),
+        media: rule.media,
+        classes: rule.classes,
+        buckets: [...sectionBucketsTouched].sort()
+      });
+    }
+  }
+  for (const info of classes) {
+    bucketStat(info.proposedBucket).classes += 1;
+  }
+  const fuzzyMiddle = [];
+  const deadClasses = [];
+  for (const info of classes) {
+    if (info.category === "section" && info.pagesUsedIn >= 2 && info.pagesUsedIn < sharedMinPages) {
+      fuzzyMiddle.push(info.name);
+    }
+    if (info.category !== "vendor" && info.pagesUsedIn === 0) {
+      deadClasses.push(info.name);
+    }
+  }
+  const pageOnlyClasses = [];
+  for (const cls of pageUseCount.keys()) {
+    if (!classMap.has(cls)) pageOnlyClasses.push(cls);
+  }
+  pageOnlyClasses.sort();
+  deadClasses.sort();
+  return {
+    source: {
+      bytes: css.length,
+      rules: totalRules,
+      selectors: totalSelectors,
+      declarations: totalDeclarations,
+      pageCount,
+      sharedMinPages
+    },
+    breakpoints,
+    buckets: { base, vendor, webflowAuto, shared, sections },
+    classes,
+    flags: {
+      crossBoundarySelectors: crossBoundary,
+      fuzzyMiddle: fuzzyMiddle.slice(0, flagLimit),
+      deadClasses: deadClasses.slice(0, flagLimit),
+      pageOnlyClasses: pageOnlyClasses.slice(0, flagLimit),
+      foldedSections
+    }
+  };
+}
+function collectClassesFromPageData(pageData) {
+  const out = /* @__PURE__ */ new Set();
+  const walk = (value) => {
+    if (!value) return;
+    if (Array.isArray(value)) {
+      for (const item of value) walk(item);
+      return;
+    }
+    if (typeof value === "object") {
+      for (const [key, v] of Object.entries(value)) {
+        if ((key === "class" || key === "className") && typeof v === "string") {
+          for (const token of v.split(/\s+/)) {
+            if (token) out.add(token);
+          }
+        } else {
+          walk(v);
+        }
+      }
+    }
+  };
+  walk(pageData);
+  return [...out];
+}
+function renderAuditMarkdown(report) {
+  const { source, buckets, breakpoints, flags } = report;
+  const kb = (n) => `${(n / 1024).toFixed(1)} KB`;
+  const lines = [];
+  lines.push("# CSS audit");
+  lines.push("");
+  lines.push(
+    `**${kb(source.bytes)}** \xB7 ${source.rules} rules \xB7 ${source.selectors} selectors \xB7 ${source.declarations} declarations \xB7 ${source.pageCount} pages \xB7 shared threshold = ${source.sharedMinPages} pages`
+  );
+  lines.push("");
+  lines.push(`Breakpoints: ${breakpoints.length ? breakpoints.map((b) => `\`${b}\``).join(", ") : "(none)"}`);
+  lines.push("");
+  lines.push("## Proposed buckets");
+  lines.push("");
+  lines.push("| bucket | classes | rules | declarations | ~size |");
+  lines.push("| --- | --- | --- | --- | --- |");
+  const row = (name, b) => `| ${name} | ${b.classes} | ${b.rules} | ${b.declarations} | ${kb(b.approxBytes)} |`;
+  lines.push(row("base (reset/typography)", buckets.base));
+  lines.push(row("vendor (.w-*)", buckets.vendor));
+  lines.push(row("webflow-auto (div-block/text-block/\u2026)", buckets.webflowAuto));
+  lines.push(row("shared", buckets.shared));
+  const sectionEntries = Object.entries(buckets.sections).sort((a, b) => b[1].approxBytes - a[1].approxBytes);
+  for (const [prefix, stat] of sectionEntries) {
+    if (prefix === "misc") continue;
+    lines.push(row(`section: ${prefix}`, stat));
+  }
+  const misc = buckets.sections.misc;
+  if (misc) lines.push(row("misc (folded small/orphan)", misc));
+  lines.push("");
+  lines.push(`_${sectionEntries.filter(([p]) => p !== "misc").length} real sections + ${misc ? "misc" : "no misc"}_`);
+  lines.push("");
+  lines.push("## Flags");
+  lines.push("");
+  lines.push(`- Cross-boundary selectors (touch \u22652 sections): **${flags.crossBoundarySelectors.length}**`);
+  lines.push(`- Fuzzy-middle classes (near shared threshold): **${flags.fuzzyMiddle.length}**`);
+  lines.push(`- Dead classes (defined, unused on any page): **${flags.deadClasses.length}**`);
+  lines.push(`- Page-only classes (used in pages, not in this sheet): **${flags.pageOnlyClasses.length}**`);
+  const foldedClasses = flags.foldedSections.reduce((n, f) => n + f.classes, 0);
+  lines.push(
+    `- Folded section buckets (small/typo \u2192 misc/kept): **${flags.foldedSections.length}** (${foldedClasses} classes)`
+  );
+  const typos = flags.foldedSections.filter((f) => f.reason === "typo");
+  if (typos.length) {
+    lines.push("");
+    lines.push("Typo merges:");
+    for (const f of typos) lines.push(`- \`${f.from}\` \u2192 \`${f.into}\` (${f.classes})`);
+  }
+  if (flags.crossBoundarySelectors.length) {
+    lines.push("");
+    lines.push("Sample cross-boundary selectors:");
+    for (const f of flags.crossBoundarySelectors.slice(0, 10)) {
+      lines.push(`- \`${f.selector}\`${f.media ? ` @ ${f.media}` : ""} \u2192 ${f.buckets.join(" + ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// lib/server/routes/api/cssAudit.ts
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".meno", "rendered-websites"]);
+function findMirrorCss(root, maxDepth = 6) {
+  const found = [];
+  const walk = (dir, depth) => {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = readdirSync2(dir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry);
+      let isDir = false;
+      try {
+        isDir = statSync(full).isDirectory();
+      } catch {
+        continue;
+      }
+      if (isDir) {
+        if (SKIP_DIRS.has(entry)) continue;
+        walk(full, depth + 1);
+      } else if (entry.endsWith(".css") && full.replace(/\\/g, "/").includes("/_mirror/css/")) {
+        found.push(full);
+      }
+    }
+  };
+  walk(root, 0);
+  return found.sort();
+}
+function resolveCssParam(root, rel) {
+  const resolved = path.resolve(root, rel);
+  const normalizedRoot = path.resolve(root);
+  if (resolved !== normalizedRoot && !resolved.startsWith(normalizedRoot + path.sep)) return null;
+  return existsSync5(resolved) ? resolved : null;
+}
+function handleCssAuditRoute(url, pageService) {
+  const root = getProjectRoot();
+  const cssParam = url.searchParams.get("css");
+  let cssFiles;
+  if (cssParam) {
+    const resolved = resolveCssParam(root, cssParam);
+    if (!resolved) {
+      return jsonResponse({ error: `Stylesheet not found or outside project: ${cssParam}` }, { status: 404 });
+    }
+    cssFiles = [resolved];
+  } else {
+    cssFiles = findMirrorCss(root);
+    if (cssFiles.length === 0) {
+      return jsonResponse(
+        {
+          error: "No mirror stylesheet found",
+          hint: "Expected a Webflow export at public/_mirror/css/*.css. Pass ?css=<relative path> to audit a specific stylesheet."
+        },
+        { status: 404 }
+      );
+    }
+  }
+  const css = cssFiles.map((f) => readFileSync2(f, "utf8")).join("\n");
+  const pages = [];
+  for (const pagePath of pageService.getAllPagePaths()) {
+    const data = pageService.getPageData(pagePath);
+    if (!data) continue;
+    pages.push({ path: pagePath, classes: collectClassesFromPageData(data) });
+  }
+  const intParam = (name) => {
+    const raw = url.searchParams.get(name);
+    if (!raw) return void 0;
+    const n = Number.parseInt(raw, 10);
+    return Number.isFinite(n) ? n : void 0;
+  };
+  const options = {};
+  const sharedMinPages = intParam("sharedMinPages");
+  const minSectionClasses = intParam("minSectionClasses");
+  if (sharedMinPages !== void 0) options.sharedMinPages = sharedMinPages;
+  if (minSectionClasses !== void 0) options.minSectionClasses = minSectionClasses;
+  const report = auditStylesheet({
+    css,
+    pages,
+    options: Object.keys(options).length > 0 ? options : void 0
+  });
+  const cssFilesRel = cssFiles.map((f) => path.relative(root, f));
+  const format = url.searchParams.get("format");
+  if (format === "md" || format === "markdown") {
+    const md = `${renderAuditMarkdown(report)}
+
+_Audited: ${cssFilesRel.join(", ")}_
+`;
+    return new Response(md, {
+      headers: { "Content-Type": "text/markdown; charset=utf-8", "Cache-Control": "no-store, max-age=0" }
+    });
+  }
+  return jsonResponse({ ...report, cssFiles: cssFilesRel });
+}
+
+// lib/server/routes/api/deMirror.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import path2 from "node:path";
+
+// lib/server/deMirror.ts
+import * as csstree2 from "css-tree";
+var CLASS_TOKEN_RE2 = /\.(-?[_a-zA-Z][\w-]*)/g;
+var FUNCTIONAL_PSEUDO_RE2 = /:(not|is|where|has|matches)\([^()]*\)/gi;
+function classTokens2(selector) {
+  const out = [];
+  let m;
+  CLASS_TOKEN_RE2.lastIndex = 0;
+  while ((m = CLASS_TOKEN_RE2.exec(selector)) !== null) {
+    if (m[1]) out.push(m[1]);
+  }
+  return out;
+}
+function subjectClassesOf(selector) {
+  const cleaned = selector.replace(FUNCTIONAL_PSEUDO_RE2, " ");
+  const segments = cleaned.split(/\s*[>+~]\s*|\s+/).filter((s) => s.trim().length > 0);
+  const subject = segments[segments.length - 1] ?? cleaned;
+  return classTokens2(subject);
+}
+function declBlock(block) {
+  const lines = [];
+  if (block && block.type === "Block") {
+    block.children.forEach((child) => {
+      if (child.type !== "Declaration") return;
+      const g = csstree2.generate(child);
+      const i = g.indexOf(":");
+      lines.push(`  ${i > 0 ? `${g.slice(0, i)}: ${g.slice(i + 1)}` : g};`);
+    });
+  }
+  return { text: lines.join("\n"), count: lines.length };
+}
+function captureClassRules(css) {
+  const ast = csstree2.parse(css, { parseValue: false, parseCustomProperty: false });
+  const out = [];
+  const visit = (container, media, skip) => {
+    const children = "children" in container ? container.children : null;
+    if (!children) return;
+    children.forEach((node) => {
+      if (node.type === "Atrule") {
+        const name = node.name.toLowerCase();
+        if (name === "media") {
+          const prelude = node.prelude ? csstree2.generate(node.prelude) : "";
+          if (node.block) visit(node.block, prelude, false);
+        } else if (name === "supports") {
+          if (node.block) visit(node.block, media, false);
+        } else if (node.block) {
+          visit(node.block, media, true);
+        }
+        return;
+      }
+      if (node.type !== "Rule" || skip) return;
+      if (node.prelude?.type !== "SelectorList") return;
+      const selectors = [];
+      const subject = /* @__PURE__ */ new Set();
+      const all = /* @__PURE__ */ new Set();
+      node.prelude.children.forEach((sel) => {
+        const text = csstree2.generate(sel);
+        const cls = classTokens2(text);
+        if (cls.length === 0) return;
+        selectors.push(text);
+        for (const c of cls) all.add(c);
+        for (const c of subjectClassesOf(text)) subject.add(c);
+      });
+      if (selectors.length === 0) return;
+      const { text: decls, count } = declBlock(node.block);
+      out.push({
+        selector: selectors.join(", "),
+        media,
+        subjectClasses: [...subject],
+        allClasses: [...all],
+        declarations: count,
+        bytes: csstree2.generate(node).length,
+        text: `${selectors.join(",\n")} {
+${decls}
+}`
+      });
+    });
+  };
+  visit(ast, null, false);
+  return out;
+}
+function assembleSlice(rules) {
+  const base = rules.filter((r) => r.media === null);
+  const byMedia = /* @__PURE__ */ new Map();
+  for (const r of rules) {
+    if (r.media === null) continue;
+    const list = byMedia.get(r.media) ?? [];
+    list.push(r);
+    byMedia.set(r.media, list);
+  }
+  const parts = [];
+  for (const r of base) parts.push(r.text);
+  for (const [media, list] of byMedia) {
+    const inner = list.map((r) => r.text.replace(/^/gm, "  ")).join("\n");
+    parts.push(`@media ${media} {
+${inner}
+}`);
+  }
+  return parts.join("\n\n");
+}
+function planDeMirror(input) {
+  const { css, components, options = {} } = input;
+  const warningSampleLimit = options.warningSampleLimit ?? 40;
+  const compClasses = components.map((c) => ({ name: c.name, set: new Set(c.classes) }));
+  const rules = captureClassRules(css);
+  const perComponent = /* @__PURE__ */ new Map();
+  const sharedSelectors = [];
+  const deadSelectors = [];
+  let movedRules = 0;
+  let movedBytes = 0;
+  let sharedRules = 0;
+  let deadRules = 0;
+  let sharedBytes = 0;
+  let deadBytes = 0;
+  let totalBytes = 0;
+  for (const rule of rules) {
+    totalBytes += rule.bytes;
+    const need = rule.subjectClasses.length > 0 ? rule.subjectClasses : rule.allClasses;
+    const owners = [];
+    for (const c of compClasses) {
+      if (need.every((cls) => c.set.has(cls))) owners.push(c.name);
+    }
+    if (owners.length === 1) {
+      const name = owners[0];
+      const list = perComponent.get(name) ?? [];
+      list.push(rule);
+      perComponent.set(name, list);
+      movedRules += 1;
+      movedBytes += rule.bytes;
+    } else if (owners.length === 0) {
+      deadRules += 1;
+      deadBytes += rule.bytes;
+      if (deadSelectors.length < warningSampleLimit) deadSelectors.push(rule.selector);
+    } else {
+      sharedRules += 1;
+      sharedBytes += rule.bytes;
+      if (sharedSelectors.length < warningSampleLimit) sharedSelectors.push(rule.selector);
+    }
+  }
+  const componentsOut = [];
+  for (const [name, list] of perComponent) {
+    const breakpoints = [...new Set(list.map((r) => r.media ?? ""))].sort();
+    componentsOut.push({
+      name,
+      ruleCount: list.length,
+      declarations: list.reduce((n, r) => n + r.declarations, 0),
+      approxBytes: list.reduce((n, r) => n + r.bytes, 0),
+      breakpoints,
+      css: assembleSlice(list)
+    });
+  }
+  componentsOut.sort((a, b) => b.approxBytes - a.approxBytes || a.name.localeCompare(b.name));
+  const roundTrip = movedRules + sharedRules + deadRules === rules.length;
+  return {
+    source: { classRules: rules.length, classRuleBytes: totalBytes, componentCount: components.length },
+    components: componentsOut,
+    global: { sharedRules, deadRules, approxBytes: sharedBytes + deadBytes },
+    moved: { rules: movedRules, approxBytes: movedBytes, components: componentsOut.length },
+    warnings: { sharedSelectors, deadSelectors },
+    roundTrip
+  };
+}
+function renderDeMirrorMarkdown(plan) {
+  const kb = (n) => `${(n / 1024).toFixed(1)} KB`;
+  const lines = [];
+  lines.push("# De-mirror plan");
+  lines.push("");
+  lines.push(
+    `${plan.source.classRules} class rules (${kb(plan.source.classRuleBytes)}) across ${plan.source.componentCount} components \xB7 round-trip ${plan.roundTrip ? "\u2705 lossless" : "\u274C FAILED"}`
+  );
+  lines.push("");
+  lines.push(
+    `**Moves onto components:** ${plan.moved.rules} rules \u2192 ${plan.moved.components} components (${kb(plan.moved.approxBytes)})`
+  );
+  lines.push(
+    `**Stays global:** ${plan.global.sharedRules} shared + ${plan.global.deadRules} dead = ${kb(plan.global.approxBytes)}`
+  );
+  lines.push("");
+  lines.push("## Slices (largest first)");
+  lines.push("");
+  lines.push("| component | rules | declarations | ~size | breakpoints |");
+  lines.push("| --- | --- | --- | --- | --- |");
+  for (const c of plan.components.slice(0, 40)) {
+    lines.push(`| ${c.name} | ${c.ruleCount} | ${c.declarations} | ${kb(c.approxBytes)} | ${c.breakpoints.length} |`);
+  }
+  if (plan.components.length > 40) lines.push(`| \u2026 +${plan.components.length - 40} more | | | | |`);
+  lines.push("");
+  lines.push(
+    `_Shared (kept global): ${plan.warnings.sharedSelectors.slice(0, 6).join(", ") || "none"}${plan.warnings.sharedSelectors.length > 6 ? " \u2026" : ""}_`
+  );
+  return lines.join("\n");
+}
+
+// lib/server/routes/api/deMirror.ts
+function componentsUsedByPage(pageData, allNames) {
+  const hay = JSON.stringify(pageData ?? "");
+  const used = /* @__PURE__ */ new Set();
+  for (const name of allNames) {
+    if (hay.includes(`"${name}"`)) used.add(name);
+  }
+  return used;
+}
+function handleDeMirrorRoute(url, pageService, componentService) {
+  const root = getProjectRoot();
+  const cssParam = url.searchParams.get("css");
+  let cssFiles;
+  if (cssParam) {
+    const resolved = resolveCssParam(root, cssParam);
+    if (!resolved) {
+      return jsonResponse({ error: `Stylesheet not found or outside project: ${cssParam}` }, { status: 404 });
+    }
+    cssFiles = [resolved];
+  } else {
+    cssFiles = findMirrorCss(root);
+    if (cssFiles.length === 0) {
+      return jsonResponse(
+        {
+          error: "No mirror stylesheet found",
+          hint: "Expected a Webflow export at public/_mirror/css/*.css. Pass ?css=<relative path> to target a specific stylesheet."
+        },
+        { status: 404 }
+      );
+    }
+  }
+  const css = cssFiles.map((f) => readFileSync3(f, "utf8")).join("\n");
+  const all = componentService.getAllComponents();
+  const components = Object.entries(all).map(([name, def]) => ({
+    name,
+    classes: collectClassesFromPageData(def)
+  }));
+  if (components.length === 0) {
+    return jsonResponse(
+      {
+        error: "No components found",
+        hint: "Componentize the project first (e.g. /componentize-mirror), then de-mirror."
+      },
+      { status: 422 }
+    );
+  }
+  const plan = planDeMirror({ css, components });
+  const slug = url.searchParams.get("slug");
+  let scoped = plan.components;
+  let scopedNote;
+  if (slug) {
+    const pagePath = slug === "index" ? "/" : `/${slug.replace(/^\//, "")}`;
+    const pageData = pageService.getPageData(pagePath);
+    if (!pageData) {
+      return jsonResponse({ error: `Page not found: ${slug}` }, { status: 404 });
+    }
+    const used = componentsUsedByPage(
+      pageData,
+      components.map((c) => c.name)
+    );
+    scoped = plan.components.filter((c) => used.has(c.name));
+    scopedNote = `filtered to ${scoped.length} component(s) used by /${slug} (ownership computed project-wide)`;
+  }
+  const cssFilesRel = cssFiles.map((f) => path2.relative(root, f));
+  const view = { ...plan, components: scoped };
+  const format = url.searchParams.get("format");
+  if (format === "md" || format === "markdown") {
+    const md = `${renderDeMirrorMarkdown(view)}
+${scopedNote ? `
+_${scopedNote}_
+` : ""}
+_Sheet: ${cssFilesRel.join(", ")}_
+`;
+    return new Response(md, {
+      headers: { "Content-Type": "text/markdown; charset=utf-8", "Cache-Control": "no-store, max-age=0" }
+    });
+  }
+  const includeSlices = url.searchParams.get("slices") === "true";
+  const responseComponents = includeSlices ? scoped : scoped.map(({ css: _css, ...meta }) => meta);
+  return jsonResponse({
+    ...view,
+    components: responseComponents,
+    cssFiles: cssFilesRel,
+    ...scopedNote ? { scopedNote } : {},
+    dryRun: true
+  });
+}
+
+// lib/server/routes/api/functions.ts
+import path3 from "node:path";
 async function loadProjectEnv() {
   const envPath = projectPaths.env();
   const env = {};
@@ -2915,7 +3810,7 @@ async function handleFunctionsRoute(req, url) {
     return void 0;
   }
   const functionPath = url.pathname.replace("/api/", "");
-  const functionFilePath = path.join(projectPaths.functions(), "api", `${functionPath}.ts`);
+  const functionFilePath = path3.join(projectPaths.functions(), "api", `${functionPath}.ts`);
   if (!await fileExists(functionFilePath)) {
     const jsFilePath = functionFilePath.replace(".ts", ".js");
     if (!await fileExists(jsFilePath)) {
@@ -2950,7 +3845,7 @@ async function handleFunctionsRoute(req, url) {
     const response = await handler(context);
     const headers = new Headers(response.headers);
     headers.set("Access-Control-Allow-Origin", "*");
-    headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+    headers.set("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS");
     headers.set("Access-Control-Allow-Headers", "Content-Type");
     return new Response(response.body, {
       status: response.status,
@@ -2976,7 +3871,7 @@ function handleFunctionsPreflight(req, url) {
     status: 204,
     headers: {
       "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+      "Access-Control-Allow-Methods": "GET, POST, PUT, PATCH, DELETE, OPTIONS",
       "Access-Control-Allow-Headers": "Content-Type",
       "Access-Control-Max-Age": "86400"
     }
@@ -3072,6 +3967,18 @@ async function handleCoreApiRoutes(req, url, context) {
   if (url.pathname === "/api/enums" && req.method === "GET") {
     return await handleRouteError(() => handleEnumsRoute(), "Failed to fetch enums");
   }
+  if (url.pathname === "/api/css-audit" && req.method === "GET") {
+    return await handleRouteError(
+      () => Promise.resolve(handleCssAuditRoute(url, pageService)),
+      "Failed to generate CSS audit"
+    );
+  }
+  if (url.pathname === "/api/de-mirror" && req.method === "GET") {
+    return await handleRouteError(
+      () => Promise.resolve(handleDeMirrorRoute(url, pageService, componentService)),
+      "Failed to generate de-mirror plan"
+    );
+  }
   if (url.pathname === "/api/usage" && req.method === "GET") {
     return await handleRouteError(() => {
       const cmsCollections = cmsService ? cmsService.getAllSchemas().size : 0;
@@ -3647,21 +4554,21 @@ function processCMSPropsTemplate(props, cmsItem, locale, i18nConfig) {
 }
 
 // lib/server/ssr/imageMetadata.ts
-import * as path2 from "node:path";
+import * as path4 from "node:path";
 var RESPONSIVE_WIDTHS = [500, 800, 1080, 1600, 2400];
 var DEFAULT_SIZES = "100vw";
 async function buildImageMetadataMap() {
   const metadataMap = /* @__PURE__ */ new Map();
   try {
     const imagesDir = projectPaths.images();
-    const manifestPath = path2.join(imagesDir, "manifest.json");
+    const manifestPath = path4.join(imagesDir, "manifest.json");
     if (!await fileExists(manifestPath)) {
       return metadataMap;
     }
     const manifestContent = await readTextFile(manifestPath);
     const manifest = JSON.parse(manifestContent);
     for (const [filename, entry] of Object.entries(manifest.images)) {
-      const baseName = path2.basename(filename, path2.extname(filename));
+      const baseName = path4.basename(filename, path4.extname(filename));
       const webpSrcsetParts = [];
       const avifSrcsetParts = [];
       for (const variant of entry.variants) {
@@ -3839,8 +4746,8 @@ function resolveFilterValue(value, scope) {
   if (typeof value !== "string" || !value.startsWith("{{") || !value.endsWith("}}")) {
     return value;
   }
-  const path3 = value.slice(2, -2).trim();
-  const resolved = scope ? getNestedValue(scope, path3) : void 0;
+  const path5 = value.slice(2, -2).trim();
+  const resolved = scope ? getNestedValue(scope, path5) : void 0;
   return resolved !== void 0 ? resolved : UNRESOLVED_FILTER_VALUE;
 }
 function resolveFilterTemplates(filter, scope, collection) {
@@ -4250,8 +5157,8 @@ function getPropItems(source, ctx) {
   if (source.startsWith("{{") && source.endsWith("}}")) {
     const templateCtx = ctx.templateContext;
     if (templateCtx) {
-      const path3 = source.slice(2, -2).trim();
-      const resolved = getNestedValue(templateCtx, path3);
+      const path5 = source.slice(2, -2).trim();
+      const resolved = getNestedValue(templateCtx, path5);
       if (Array.isArray(resolved)) {
         return resolved;
       } else if (resolved !== void 0) {
@@ -4288,12 +5195,12 @@ function buildNodeElementClass(ctx, label, isSlotContent2) {
   const effectiveFileType = useComponentContext ? "component" : "page";
   const effectiveFileName = useComponentContext ? ctx.componentContext : pagePath ? pagePath.replace(/^\//, "").replace(/\//g, "_") || "index" : "page";
   const rawPath = ctx.elementPath || [];
-  const path3 = useComponentContext && ctx.componentRootPath ? rawPath.slice(ctx.componentRootPath.length) : rawPath;
+  const path5 = useComponentContext && ctx.componentRootPath ? rawPath.slice(ctx.componentRootPath.length) : rawPath;
   const elementClassCtx = {
     fileType: effectiveFileType,
     fileName: effectiveFileName || "page",
     label,
-    path: path3
+    path: path5
   };
   return generateElementClassName(elementClassCtx);
 }
@@ -5279,7 +6186,23 @@ var formHandlerScript = `
   // Find all forms with fetch handler
   const forms = document.querySelectorAll('form[data-submit-handler="fetch"]');
 
+  // Spam protection (server-enforced at /api/send-email): inject a hidden honeypot
+  // field bots fill but humans never see, and stamp a clock-skew-free dwell time on
+  // submit. Fields named with a leading "_" are control/meta and are not emailed.
+  const loadedAt = Date.now();
+
   forms.forEach(function(form) {
+    if (!form.querySelector('input[name="_honey"]')) {
+      const hp = document.createElement('input');
+      hp.type = 'text';
+      hp.name = '_honey';
+      hp.tabIndex = -1;
+      hp.setAttribute('autocomplete', 'off');
+      hp.setAttribute('aria-hidden', 'true');
+      hp.style.cssText = 'position:absolute;left:-9999px;width:1px;height:1px;opacity:0';
+      form.appendChild(hp);
+    }
+
     form.addEventListener('submit', async function(e) {
       e.preventDefault();
 
@@ -5314,6 +6237,7 @@ var formHandlerScript = `
 
       try {
         const formData = new FormData(form);
+        formData.append('_elapsed', String(Date.now() - loadedAt));
 
         const response = await fetch(action, {
           method: method.toUpperCase(),
@@ -5437,6 +6361,7 @@ function generateAllInlineDataScripts(collections) {
 }
 
 // lib/server/ssr/htmlGenerator.ts
+import { posix } from "node:path";
 function generateImagePreloadTags(preloadImages) {
   if (preloadImages.length === 0) return "";
   return preloadImages.map(
@@ -5447,6 +6372,43 @@ function minifyCSS(code) {
   if (!code.trim()) return code;
   return code.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s*([{};:,>~])\s*/g, "$1").replace(/\s+/g, " ").replace(/\{\s+/g, "{").replace(/\s+\}/g, "}").replace(/;}/g, "}").trim();
 }
+async function collectPageCssImports(frontmatter, pagePath, nonceAttr) {
+  if (!frontmatter?.includes(".css")) return "";
+  const seen = /* @__PURE__ */ new Set();
+  const specs = [];
+  const re = /import\b[^'"]*['"]([^'"]+\.css)(?:\?[^'"]*)?['"]/g;
+  let m;
+  while ((m = re.exec(frontmatter)) !== null) {
+    const spec = m[1];
+    if (!spec || seen.has(spec)) continue;
+    seen.add(spec);
+    if (spec.endsWith("styles/theme.css")) continue;
+    specs.push(spec);
+  }
+  if (specs.length === 0) return "";
+  const pageDir = posix.join("src/pages", posix.dirname(pagePath || "/"));
+  const tags = [];
+  for (const spec of specs) {
+    if (/^(?:https?:)?\/\//.test(spec)) {
+      tags.push(`<link rel="stylesheet" href="${escapeHtml(spec)}">`);
+      continue;
+    }
+    const candidates = spec.startsWith("/") ? [spec.slice(1)] : [posix.normalize(posix.join(pageDir, spec)), `src/${spec.replace(/^(?:\.\.?\/)+/, "")}`];
+    let css = null;
+    for (const rel of candidates) {
+      if (rel.startsWith("..")) continue;
+      try {
+        css = await readTextFile(resolveProjectPath(rel));
+        break;
+      } catch {
+      }
+    }
+    if (css == null) continue;
+    const content = rewriteViewportUnitsInStylesheet(css).replace(/<\/style/gi, "<\\/style");
+    tags.push(`<style${nonceAttr} data-meno-page-css="${escapeHtml(spec)}">${content}</style>`);
+  }
+  return tags.join("\n  ");
+}
 async function generateSSRHTML(pageDataOrOptions, globalComponents = {}, pagePath = "/", baseUrl = "", useBuiltBundle = false, locale, slugMappings, cmsContext, cmsService, externalScriptPath) {
   let options;
   if ("pageData" in pageDataOrOptions) {
@@ -5468,7 +6430,7 @@ async function generateSSRHTML(pageDataOrOptions, globalComponents = {}, pagePat
   const {
     pageData,
     globalComponents: components = {},
-    pagePath: path3 = "/",
+    pagePath: path5 = "/",
     baseUrl: base = "",
     useBuiltBundle: useBundled = false,
     locale: loc,
@@ -5492,7 +6454,7 @@ async function generateSSRHTML(pageDataOrOptions, globalComponents = {}, pagePat
   const rendered = await renderPageSSR(
     pageData,
     components,
-    path3,
+    path5,
     base,
     loc,
     void 0,
@@ -5679,7 +6641,7 @@ picture {
   line-height: normal;
 }`;
   const combinedCSS = [fontCSS, themeColorVariablesCSS, variablesCSS, baseCSS, componentCSS, utilityCSS, interactiveCSS].filter(Boolean).join("\n");
-  const cssWithStableViewport = rewriteViewportUnits(combinedCSS);
+  const cssWithStableViewport = rewriteViewportUnitsInStylesheet(combinedCSS);
   const finalCSS = useBundled ? minifyCSS(cssWithStableViewport) : cssWithStableViewport;
   const prefetchConfig = await loadPrefetchConfig();
   const menoConfig = prefetchConfig.enabled ? { prefetch: prefetchConfig } : {};
@@ -5708,6 +6670,7 @@ ${externalJavaScript}`;
   const styleContent = useBundled ? finalCSS : `
     ${combinedCSS.split("\n").join("\n    ")}
   `;
+  const pageCssTags = await collectPageCssImports(pageData._frontmatter, pagePath, nonceAttr);
   const htmlDocument = `<!DOCTYPE html>
 <html lang="${rendered.locale}" theme="${themeConfig.default}">
 <head>
@@ -5721,7 +6684,8 @@ ${externalJavaScript}`;
   ` : ""}${libraryTags.headCSS ? `${libraryTags.headCSS}
   ` : ""}${libraryTags.headJS ? `${libraryTags.headJS}
   ` : ""}${rendered.meta}
-  ${configInlineScript}${cmsInlineScript}${clientDataScripts}<style id="meno-styles"${nonceAttr}>${styleContent}</style>${mergedCustomCode.head ? `
+  ${configInlineScript}${cmsInlineScript}${clientDataScripts}<style id="meno-styles"${nonceAttr}>${styleContent}</style>${pageCssTags ? `
+  ${pageCssTags}` : ""}${mergedCustomCode.head ? `
   ${mergedCustomCode.head}` : ""}
 </head>
 <body>${mergedCustomCode.bodyStart ? `
@@ -7129,8 +8093,8 @@ function singularizeWord(word) {
   if (word.endsWith("s")) return word.slice(0, -1);
   return word;
 }
-function getNestedValue2(obj, path3) {
-  return path3.split(".").reduce((current, key) => {
+function getNestedValue2(obj, path5) {
+  return path5.split(".").reduce((current, key) => {
     return current && typeof current === "object" ? current[key] : void 0;
   }, obj);
 }
@@ -8611,7 +9575,11 @@ async function createServer(config) {
     try {
       const server = await createRuntimeServer({
         port: currentPort,
-        hostname: "localhost",
+        // Default `localhost` resolves to IPv6 `::1` only on macOS, so a
+        // conventional `127.0.0.1 meno.local` hosts alias can't reach it. MENO_HOST
+        // lets the standalone launcher bind broadly (e.g. `::` dual-stack) so both
+        // IPv4 and IPv6 aliases work. Unset → unchanged `localhost` behavior.
+        hostname: process.env.MENO_HOST || "localhost",
         wsPath: HMR_ROUTE,
         async fetch(req, upgradeWebSocket) {
           const url = new URL(req.url);
@@ -9006,8 +9974,8 @@ ${plainTextErrors}`;
 }
 
 // lib/server/services/pageService.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2, mkdirSync, rmdirSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync3, mkdirSync, rmdirSync } from "node:fs";
+import { join as join4, relative, sep } from "node:path";
 
 // lib/server/utils/jsonLineMapper.ts
 function buildLineMap(jsonText) {
@@ -9051,13 +10019,13 @@ function buildLineMap(jsonText) {
       pos++;
     }
   }
-  function parseValue(path3, trackChildren) {
+  function parseValue(path5, trackChildren) {
     skipWhitespace();
     const startPos = pos;
     if (jsonText[pos] === "{") {
-      parseObject(path3, trackChildren);
+      parseObject(path5, trackChildren);
     } else if (jsonText[pos] === "[") {
-      parseArray(path3, trackChildren);
+      parseArray(path5, trackChildren);
     } else if (jsonText[pos] === '"') {
       parseString();
     } else if (jsonText[pos] === "t") {
@@ -9071,14 +10039,14 @@ function buildLineMap(jsonText) {
     }
     return { start: startPos, end: pos };
   }
-  function recordTrackedRoot(path3) {
-    const { start, end } = parseValue(path3, true);
+  function recordTrackedRoot(path5) {
+    const { start, end } = parseValue(path5, true);
     lineMap.set("", {
       startLine: charToLine[start] ?? 0,
       endLine: charToLine[end - 1] || charToLine[start] || 0
     });
   }
-  function parseObject(path3, trackChildren) {
+  function parseObject(path5, trackChildren) {
     pos++;
     skipWhitespace();
     while (pos < jsonText.length && jsonText[pos] !== "}") {
@@ -9087,14 +10055,14 @@ function buildLineMap(jsonText) {
       skipWhitespace();
       pos++;
       skipWhitespace();
-      if (key === "root" && path3.length === 0) {
-        recordTrackedRoot(path3);
-      } else if (key === "component" && path3.length === 0) {
-        parseComponentWrapper(path3);
+      if (key === "root" && path5.length === 0) {
+        recordTrackedRoot(path5);
+      } else if (key === "component" && path5.length === 0) {
+        parseComponentWrapper(path5);
       } else if (key === "children" && trackChildren) {
-        parseValue(path3, true);
+        parseValue(path5, true);
       } else {
-        parseValue(path3, false);
+        parseValue(path5, false);
       }
       skipWhitespace();
       if (jsonText[pos] === ",") pos++;
@@ -9102,9 +10070,9 @@ function buildLineMap(jsonText) {
     }
     pos++;
   }
-  function parseComponentWrapper(path3) {
+  function parseComponentWrapper(path5) {
     if (jsonText[pos] !== "{") {
-      parseValue(path3, false);
+      parseValue(path5, false);
       return;
     }
     pos++;
@@ -9116,9 +10084,9 @@ function buildLineMap(jsonText) {
       pos++;
       skipWhitespace();
       if (key === "structure") {
-        recordTrackedRoot(path3);
+        recordTrackedRoot(path5);
       } else {
-        parseValue(path3, false);
+        parseValue(path5, false);
       }
       skipWhitespace();
       if (jsonText[pos] === ",") pos++;
@@ -9126,12 +10094,12 @@ function buildLineMap(jsonText) {
     }
     pos++;
   }
-  function parseArray(path3, trackChildren) {
+  function parseArray(path5, trackChildren) {
     pos++;
     skipWhitespace();
     let index = 0;
     while (pos < jsonText.length && jsonText[pos] !== "]") {
-      const childPath = [...path3, index];
+      const childPath = [...path5, index];
       const { start, end } = parseValue(childPath, trackChildren);
       if (trackChildren) {
         const pathStr = childPath.join(",");
@@ -9204,9 +10172,12 @@ var PageService = class {
       return;
     }
     const pages = await this.provider.loadAll();
-    for (const [path3, content] of pages) {
+    for (const [path5, content] of pages) {
       const lineMap = buildLineMap(content);
-      this.pageCache.set(path3, content, lineMap);
+      this.pageCache.set(path5, content, lineMap);
+    }
+    for (const path5 of this.pageCache.keys()) {
+      if (!pages.has(path5)) this.pageCache.delete(path5);
     }
   }
   /**
@@ -9223,8 +10194,8 @@ var PageService = class {
    * }
    * ```
    */
-  getPage(path3) {
-    return this.pageCache.getContent(path3);
+  getPage(path5) {
+    return this.pageCache.getContent(path5);
   }
   /**
    * Get parsed page data
@@ -9243,8 +10214,8 @@ var PageService = class {
    * }
    * ```
    */
-  getPageData(path3) {
-    const content = this.pageCache.getContent(path3);
+  getPageData(path5) {
+    const content = this.pageCache.getContent(path5);
     if (!content) {
       return null;
     }
@@ -9274,15 +10245,15 @@ var PageService = class {
    * });
    * ```
    */
-  async savePage(path3, data) {
+  async savePage(path5, data) {
     if (!this.provider) {
       throw new Error("PageProvider not set");
     }
     const { _lineMap, ...dataToSave } = data;
     const content = JSON.stringify(dataToSave, null, 2);
-    await this.provider.save(path3, content);
+    await this.provider.save(path5, content);
     const lineMap = buildLineMap(content);
-    this.pageCache.set(path3, content, lineMap);
+    this.pageCache.set(path5, content, lineMap);
   }
   /**
    * Re-read a single page from disk via the provider and refresh the cache.
@@ -9296,22 +10267,22 @@ var PageService = class {
    *   partial mid-write or parse error), in which case the cache is left intact and
    *   the next watcher event retries.
    */
-  async reloadPageFromDisk(path3) {
+  async reloadPageFromDisk(path5) {
     if (!this.provider) return false;
     let content = null;
     try {
-      content = await this.provider.get(path3);
+      content = await this.provider.get(path5);
     } catch (error) {
-      logRuntimeError("pageService.reloadPageFromDisk", error, { path: path3 });
+      logRuntimeError("pageService.reloadPageFromDisk", error, { path: path5 });
       return false;
     }
     if (content) {
-      this.pageCache.set(path3, content, buildLineMap(content));
+      this.pageCache.set(path5, content, buildLineMap(content));
       return true;
     }
     try {
-      if (!await this.provider.exists(path3)) {
-        this.pageCache.delete(path3);
+      if (!await this.provider.exists(path5)) {
+        this.pageCache.delete(path5);
         return true;
       }
     } catch {
@@ -9334,10 +10305,10 @@ var PageService = class {
    * await pageService.deletePage('/old-page', true);
    * ```
    */
-  async deletePage(path3, deleteFromStorage = false) {
-    this.pageCache.delete(path3);
+  async deletePage(path5, deleteFromStorage = false) {
+    this.pageCache.delete(path5);
     if (deleteFromStorage && this.provider) {
-      await this.provider.delete(path3);
+      await this.provider.delete(path5);
     }
   }
   /**
@@ -9365,26 +10336,34 @@ var PageService = class {
    *
    * @example
    * ```typescript
-   * const pages = pageService.getAllPagesWithInfo();
+   * const pages = await pageService.getAllPagesWithInfo();
    * // [{ path: "/", isDraft: false }, { path: "/about", isDraft: true }]
    * ```
    */
-  getAllPagesWithInfo() {
+  async getAllPagesWithInfo() {
     const paths = this.pageCache.keys().filter((p) => !p.startsWith("/_sketch/"));
-    return paths.map((path3) => {
-      const pageData = this.getPageData(path3);
-      const pathWithoutSlash = path3 === "/" ? "index" : path3.substring(1);
-      const slashIndex = pathWithoutSlash.lastIndexOf("/");
-      const folder = slashIndex > 0 ? pathWithoutSlash.substring(0, slashIndex) : void 0;
-      const metaSource = pageData?.meta?.source;
-      const source = metaSource === "cms" || metaSource === "ssr" ? metaSource : void 0;
-      return {
-        path: path3,
-        isDraft: pageData?.meta?.draft === true,
-        ...folder ? { folder } : {},
-        ...source ? { source } : {}
-      };
-    });
+    return Promise.all(
+      paths.map(async (path5) => {
+        const pageData = this.getPageData(path5);
+        const pathWithoutSlash = path5 === "/" ? "index" : path5.substring(1);
+        const slashIndex = pathWithoutSlash.lastIndexOf("/");
+        const folder = slashIndex > 0 ? pathWithoutSlash.substring(0, slashIndex) : void 0;
+        const metaSource = pageData?.meta?.source;
+        const source = metaSource === "cms" || metaSource === "ssr" ? metaSource : void 0;
+        let sourcePath;
+        if (source === "cms" && this.provider?.resolveSourcePath) {
+          const abs = await this.provider.resolveSourcePath(path5);
+          if (abs) sourcePath = relative(getProjectRoot(), abs).split(sep).join("/");
+        }
+        return {
+          path: path5,
+          isDraft: pageData?.meta?.draft === true,
+          ...folder ? { folder } : {},
+          ...source ? { source } : {},
+          ...sourcePath ? { sourcePath } : {}
+        };
+      })
+    );
   }
   /**
    * Get line map for a page
@@ -9394,8 +10373,8 @@ var PageService = class {
    * @param path - Page path (e.g., "/" or "/about")
    * @returns LineMap object or undefined if page not found
    */
-  getLineMap(path3) {
-    return this.pageCache.getLineMap(path3);
+  getLineMap(path5) {
+    return this.pageCache.getLineMap(path5);
   }
   /**
    * Pages base directory — provider-aware (e.g. `src/pages` for astro projects),
@@ -9419,12 +10398,12 @@ var PageService = class {
    */
   getAllFolders() {
     const pagesDir = this.pagesBaseDir();
-    if (!existsSync5(pagesDir)) {
+    if (!existsSync6(pagesDir)) {
       return [];
     }
     const collectFolders = (dir, prefix) => {
       try {
-        const entries = readdirSync2(dir, { withFileTypes: true });
+        const entries = readdirSync3(dir, { withFileTypes: true });
         const result = [];
         for (const entry of entries) {
           if (!entry.isDirectory()) continue;
@@ -9462,7 +10441,7 @@ var PageService = class {
     }
     const pagesDir = this.pagesBaseDir();
     const folderPath = join4(pagesDir, trimmed);
-    if (existsSync5(folderPath)) {
+    if (existsSync6(folderPath)) {
       throw new Error("Folder already exists");
     }
     mkdirSync(folderPath, { recursive: true });
@@ -9490,11 +10469,11 @@ var PageService = class {
     }
     if (newFolder) {
       const targetDir = join4(pagesDir, newFolder);
-      if (!existsSync5(targetDir)) {
+      if (!existsSync6(targetDir)) {
         mkdirSync(targetDir, { recursive: true });
       }
     }
-    if (!existsSync5(sourceFile)) {
+    if (!existsSync6(sourceFile)) {
       throw new Error(`Page not found: ${pagePath}`);
     }
     await rename2(sourceFile, targetFile);
@@ -9509,7 +10488,7 @@ var PageService = class {
     const sourceDir = slashIndex >= 0 ? join4(pagesDir, pageName.substring(0, slashIndex)) : null;
     if (sourceDir && sourceDir !== pagesDir) {
       try {
-        const remaining = readdirSync2(sourceDir);
+        const remaining = readdirSync3(sourceDir);
         if (remaining.length === 0) {
           rmdirSync(sourceDir);
         }
@@ -9557,10 +10536,10 @@ var PageService = class {
     const ext = this.pageExt();
     const sourceFile = join4(pagesDir, `${oldName}${ext}`);
     const targetFile = join4(pagesDir, `${newName}${ext}`);
-    if (!existsSync5(sourceFile)) {
+    if (!existsSync6(sourceFile)) {
       throw new Error(`Page not found: ${oldPath}`);
     }
-    if (existsSync5(targetFile)) {
+    if (existsSync6(targetFile)) {
       throw new Error(`Page already exists: ${newPath}`);
     }
     await rename2(sourceFile, targetFile);
@@ -9588,17 +10567,17 @@ var PageService = class {
   getSlugMappings() {
     const mappings = [];
     const paths = this.pageCache.keys();
-    for (const path3 of paths) {
-      const pageData = this.getPageData(path3);
+    for (const path5 of paths) {
+      const pageData = this.getPageData(path5);
       if (pageData?.meta?.slugs) {
-        const pageId = path3 === "/" ? "index" : path3.substring(1);
+        const pageId = path5 === "/" ? "index" : path5.substring(1);
         mappings.push({
           pageId,
           slugs: pageData.meta.slugs
         });
       } else {
-        const pageId = path3 === "/" ? "index" : path3.substring(1);
-        const defaultSlug = path3 === "/" ? "" : path3.substring(1);
+        const pageId = path5 === "/" ? "index" : path5.substring(1);
+        const defaultSlug = path5 === "/" ? "" : path5.substring(1);
         mappings.push({
           pageId,
           slugs: { _default: defaultSlug }
@@ -9611,7 +10590,7 @@ var PageService = class {
 
 // lib/server/services/componentService.ts
 import { join as join5 } from "node:path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync3, rmdirSync as rmdirSync2 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readdirSync as readdirSync4, rmdirSync as rmdirSync2 } from "node:fs";
 var ComponentService = class {
   components = /* @__PURE__ */ new Map();
   componentCategories = /* @__PURE__ */ new Map();
@@ -9620,6 +10599,36 @@ var ComponentService = class {
   writer;
   loadErrors = /* @__PURE__ */ new Map();
   loadWarnings = [];
+  /** Per-component serialization of whole-file re-emits. @see withComponentWriteLock */
+  writeLocks = /* @__PURE__ */ new Map();
+  /**
+   * Serialize whole-file re-emits for one component.
+   *
+   * `saveComponentCSS` and `saveComponentJavaScript` each read the in-memory
+   * definition, re-emit the ENTIRE `.astro` file, then write the result back.
+   * Fired concurrently — the Custom Code modal's Save issues a JS save AND a CSS
+   * save together — their read-modify-write races: each reads a snapshot taken
+   * before the other's `components.set`, so the writer that lands last clobbers
+   * the other field with a stale value (a fresh CSS edit silently reverting is
+   * the visible symptom). Chaining per component name makes each op observe the
+   * previous op's committed state. Prior failures are swallowed on the chain tail
+   * so one bad write can't wedge the queue.
+   */
+  withComponentWriteLock(name, fn) {
+    const prev = this.writeLocks.get(name) ?? Promise.resolve();
+    const run = prev.then(fn, fn);
+    const tail = run.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    this.writeLocks.set(name, tail);
+    tail.finally(() => {
+      if (this.writeLocks.get(name) === tail) this.writeLocks.delete(name);
+    });
+    return run;
+  }
   /**
    * Creates a new ComponentService instance
    *
@@ -9874,12 +10883,12 @@ var ComponentService = class {
    */
   findComponentCategoryOnDisk(name) {
     const componentsDir = this.componentsBaseDir();
-    if (!existsSync6(componentsDir)) return void 0;
+    if (!existsSync7(componentsDir)) return void 0;
     const ext = this.writer ? null : ".json";
     const existsAt = (dir) => {
-      if (ext) return existsSync6(join5(dir, `${name}${ext}`));
+      if (ext) return existsSync7(join5(dir, `${name}${ext}`));
       try {
-        return readdirSync3(dir, { withFileTypes: true }).some(
+        return readdirSync4(dir, { withFileTypes: true }).some(
           (e) => e.isFile() && (e.name === `${name}.json` || e.name === `${name}.astro`)
         );
       } catch {
@@ -9888,7 +10897,7 @@ var ComponentService = class {
     };
     if (existsAt(componentsDir)) return void 0;
     try {
-      for (const entry of readdirSync3(componentsDir, { withFileTypes: true })) {
+      for (const entry of readdirSync4(componentsDir, { withFileTypes: true })) {
         if (entry.isDirectory() && existsAt(join5(componentsDir, entry.name))) {
           return entry.name;
         }
@@ -9969,7 +10978,7 @@ var ComponentService = class {
       await this.writer.writeComponent(componentDir, name, dataWithJS);
     } else {
       const writeFile3 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("node:fs/promises")).writeFile;
-      if (targetCategory && !existsSync6(componentDir)) {
+      if (targetCategory && !existsSync7(componentDir)) {
         mkdirSync2(componentDir, { recursive: true });
       }
       const filePath = join5(componentDir, `${name}.json`);
@@ -9998,10 +11007,12 @@ var ComponentService = class {
   async saveComponentJavaScript(name, javascript) {
     const componentDir = this.getComponentDir(name);
     if (this.writer) {
-      const current = this.components.get(name);
-      await this.writer.writeJavaScript(componentDir, name, javascript || "", current);
-      const next = current ? { ...current, component: { ...current.component, javascript: javascript || "" } } : { component: { javascript: javascript || "" } };
-      this.components.set(name, next);
+      await this.withComponentWriteLock(name, async () => {
+        const current = this.components.get(name);
+        await this.writer.writeJavaScript(componentDir, name, javascript || "", current);
+        const next = current ? { ...current, component: { ...current.component, javascript: javascript || "" } } : { component: { javascript: javascript || "" } };
+        this.components.set(name, next);
+      });
       return;
     }
     const writeFile3 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("node:fs/promises")).writeFile;
@@ -10044,10 +11055,12 @@ var ComponentService = class {
   async saveComponentCSS(name, css) {
     const componentDir = this.getComponentDir(name);
     if (this.writer) {
-      const current = this.components.get(name);
-      await this.writer.writeCSS(componentDir, name, css || "", current);
-      const next = current ? { ...current, component: { ...current.component, css: css || "" } } : { component: { css: css || "" } };
-      this.components.set(name, next);
+      await this.withComponentWriteLock(name, async () => {
+        const current = this.components.get(name);
+        await this.writer.writeCSS(componentDir, name, css || "", current);
+        const next = current ? { ...current, component: { ...current.component, css: css || "" } } : { component: { css: css || "" } };
+        this.components.set(name, next);
+      });
       return;
     }
     const writeFile3 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("node:fs/promises")).writeFile;
@@ -10086,11 +11099,11 @@ var ComponentService = class {
    */
   getAllFolders() {
     const componentsDir = this.componentsBaseDir();
-    if (!existsSync6(componentsDir)) {
+    if (!existsSync7(componentsDir)) {
       return [];
     }
     try {
-      const entries = readdirSync3(componentsDir, { withFileTypes: true });
+      const entries = readdirSync4(componentsDir, { withFileTypes: true });
       return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
     } catch {
       return [];
@@ -10122,7 +11135,7 @@ var ComponentService = class {
     }
     const componentsDir = this.componentsBaseDir();
     const folderPath = join5(componentsDir, folderName);
-    if (existsSync6(folderPath)) {
+    if (existsSync7(folderPath)) {
       throw new Error("Folder already exists");
     }
     mkdirSync2(folderPath, { recursive: true });
@@ -10160,7 +11173,7 @@ var ComponentService = class {
     if (this.writer) {
       await this.writer.moveComponent(sourceDir, targetDir, name);
     } else {
-      if (targetCategory && !existsSync6(targetDir)) {
+      if (targetCategory && !existsSync7(targetDir)) {
         mkdirSync2(targetDir, { recursive: true });
       }
       const extensions = [".json", ".js", ".css"];
@@ -10168,7 +11181,7 @@ var ComponentService = class {
       for (const ext of extensions) {
         const sourcePath = join5(sourceDir, `${name}${ext}`);
         const targetPath = join5(targetDir, `${name}${ext}`);
-        if (existsSync6(sourcePath)) {
+        if (existsSync7(sourcePath)) {
           await rename2(sourcePath, targetPath);
         }
       }
@@ -10176,7 +11189,7 @@ var ComponentService = class {
     this.componentCategories.set(name, targetCategory);
     if (currentCategory) {
       try {
-        const remaining = readdirSync3(sourceDir);
+        const remaining = readdirSync4(sourceDir);
         if (remaining.length === 0) {
           rmdirSync2(sourceDir);
         }
@@ -10231,7 +11244,7 @@ var ComponentService = class {
       await this.writer.moveComponent(dir, dir, oldName, trimmedNew);
     } else {
       for (const ext of [".json", ".js", ".css"]) {
-        if (existsSync6(join5(dir, `${trimmedNew}${ext}`))) {
+        if (existsSync7(join5(dir, `${trimmedNew}${ext}`))) {
           throw new Error(`File "${trimmedNew}${ext}" already exists in components/${category ?? ""}`);
         }
       }
@@ -10239,7 +11252,7 @@ var ComponentService = class {
       for (const ext of [".json", ".js", ".css"]) {
         const src = join5(dir, `${oldName}${ext}`);
         const dst = join5(dir, `${trimmedNew}${ext}`);
-        if (existsSync6(src)) {
+        if (existsSync7(src)) {
           await rename2(src, dst);
         }
       }
@@ -10273,11 +11286,11 @@ var ComponentService = class {
     let pageRefs = 0;
     if (pageService) {
       const pagePaths = pageService.getAllPagePaths();
-      for (const path3 of pagePaths) {
-        const pageData = pageService.getPageData(path3);
+      for (const path5 of pagePaths) {
+        const pageData = pageService.getPageData(path5);
         if (!pageData || !("root" in pageData) || !pageData.root) continue;
         if (rewriteComponentRefs(pageData.root, oldName, trimmedNew)) {
-          await pageService.savePage(path3, pageData);
+          await pageService.savePage(path5, pageData);
           pageRefs++;
         }
       }
@@ -10435,12 +11448,12 @@ var CMSService = class {
    * @param locale - Optional locale for i18n slug matching
    * @returns CMSRouteMatch if matched, null otherwise
    */
-  async matchRoute(path3, locale) {
+  async matchRoute(path5, locale) {
     if (!this.provider) {
       return null;
     }
     for (const route of this.routePatterns) {
-      const match = path3.match(route.regex);
+      const match = path5.match(route.regex);
       if (match) {
         const urlSlug = match[route.slugGroup];
         if (urlSlug === void 0) continue;
@@ -10549,11 +11562,11 @@ var CMSService = class {
           if (options?.excludeDrafts && isItemDraftForLocale(item, locale)) continue;
           const localizedSlug = slugValue[locale];
           if (localizedSlug) {
-            const path3 = urlPattern.replace("{{slug}}", localizedSlug);
+            const path5 = urlPattern.replace("{{slug}}", localizedSlug);
             if (locale === defaultLocale) {
-              urls.push(path3);
+              urls.push(path5);
             } else {
-              urls.push(`/${locale}${path3}`);
+              urls.push(`/${locale}${path5}`);
             }
           }
         }
@@ -10805,7 +11818,7 @@ var CMSService = class {
 };
 
 // lib/server/providers/fileSystemCMSProvider.ts
-import { existsSync as existsSync7, readdirSync as readdirSync4, mkdirSync as mkdirSync3 } from "node:fs";
+import { existsSync as existsSync8, readdirSync as readdirSync5, mkdirSync as mkdirSync3 } from "node:fs";
 import { join as join6 } from "node:path";
 var log6 = createLogger("FileSystemCMSProvider");
 var DRAFT_FILE_SUFFIX = `${CMS_DRAFT_SUFFIX}.json`;
@@ -10878,10 +11891,10 @@ var FileSystemCMSProvider = class {
       return this.schemaCache;
     }
     const schemas = /* @__PURE__ */ new Map();
-    if (!existsSync7(this.templatesDir)) {
+    if (!existsSync8(this.templatesDir)) {
       return schemas;
     }
-    const files = readdirSync4(this.templatesDir);
+    const files = readdirSync5(this.templatesDir);
     const jsonFiles = files.filter((f) => f.endsWith(".json"));
     const results = await Promise.all(
       jsonFiles.map(async (file) => {
@@ -10911,10 +11924,10 @@ var FileSystemCMSProvider = class {
   async getItems(collection) {
     this.validateCollection(collection);
     const collectionDir = join6(this.cmsDir, collection);
-    if (!existsSync7(collectionDir)) {
+    if (!existsSync8(collectionDir)) {
       return [];
     }
-    const files = readdirSync4(collectionDir);
+    const files = readdirSync5(collectionDir);
     const jsonFiles = files.filter((f) => f.endsWith(".json") && !f.endsWith(DRAFT_FILE_SUFFIX));
     const results = await Promise.all(
       jsonFiles.map(async (file) => {
@@ -11004,7 +12017,7 @@ var FileSystemCMSProvider = class {
     }
     this.validateFilename(filename);
     const collectionDir = join6(this.cmsDir, collection);
-    if (!existsSync7(collectionDir)) {
+    if (!existsSync8(collectionDir)) {
       mkdirSync3(collectionDir, { recursive: true });
     }
     const itemData = stripTransient(item);
@@ -11019,11 +12032,11 @@ var FileSystemCMSProvider = class {
     this.validateFilename(filename);
     const { unlink } = await import("node:fs/promises");
     const publishedPath = join6(this.cmsDir, collection, `${filename}.json`);
-    if (existsSync7(publishedPath)) {
+    if (existsSync8(publishedPath)) {
       await unlink(publishedPath);
     }
     const draftPath = this.draftPath(collection, filename);
-    if (existsSync7(draftPath)) {
+    if (existsSync8(draftPath)) {
       await unlink(draftPath);
     }
   }
@@ -11057,8 +12070,8 @@ var FileSystemCMSProvider = class {
   async getAllDrafts(collection) {
     this.validateCollection(collection);
     const collectionDir = join6(this.cmsDir, collection);
-    if (!existsSync7(collectionDir)) return [];
-    const files = readdirSync4(collectionDir).filter((f) => f.endsWith(DRAFT_FILE_SUFFIX));
+    if (!existsSync8(collectionDir)) return [];
+    const files = readdirSync5(collectionDir).filter((f) => f.endsWith(DRAFT_FILE_SUFFIX));
     const results = await Promise.all(
       files.map(async (file) => {
         const filePath = join6(collectionDir, file);
@@ -11083,7 +12096,7 @@ var FileSystemCMSProvider = class {
   async hasDraft(collection, filename) {
     this.validateCollection(collection);
     this.validateFilename(filename);
-    return existsSync7(this.draftPath(collection, filename));
+    return existsSync8(this.draftPath(collection, filename));
   }
   /**
    * Save the draft version of an item. Loose validation — drafts may have
@@ -11118,7 +12131,7 @@ var FileSystemCMSProvider = class {
     }
     this.validateFilename(filename);
     const collectionDir = join6(this.cmsDir, collection);
-    if (!existsSync7(collectionDir)) {
+    if (!existsSync8(collectionDir)) {
       mkdirSync3(collectionDir, { recursive: true });
     }
     const itemData = stripTransient(item);
@@ -11138,7 +12151,7 @@ var FileSystemCMSProvider = class {
     this.validateFilename(filename);
     const { unlink } = await import("node:fs/promises");
     const filePath = this.draftPath(collection, filename);
-    if (existsSync7(filePath)) {
+    if (existsSync8(filePath)) {
       await unlink(filePath);
     }
   }
@@ -11167,13 +12180,13 @@ var FileSystemCMSProvider = class {
       throw new Error(`Cannot publish invalid draft: ${messages}`);
     }
     const collectionDir = join6(this.cmsDir, collection);
-    if (!existsSync7(collectionDir)) {
+    if (!existsSync8(collectionDir)) {
       mkdirSync3(collectionDir, { recursive: true });
     }
     const itemData = stripTransient(validation.data);
     const publishedPath = join6(collectionDir, `${filename}.json`);
     await writeFile3(publishedPath, JSON.stringify(itemData, null, 2), "utf-8");
-    if (existsSync7(draftFilePath)) {
+    if (existsSync8(draftFilePath)) {
       await unlink(draftFilePath);
     }
     return normalizeItem(itemData, filename);
@@ -11194,18 +12207,18 @@ var FileSystemCMSProvider = class {
       );
     }
     const { writeFile: writeFile3, mkdir } = await import("node:fs/promises");
-    if (!existsSync7(this.templatesDir)) {
+    if (!existsSync8(this.templatesDir)) {
       await mkdir(this.templatesDir, { recursive: true });
     }
     const pageFilePath = join6(this.templatesDir, `${collectionId}.json`);
-    if (existsSync7(pageFilePath)) {
+    if (existsSync8(pageFilePath)) {
       throw new Error(`Page file already exists: templates/${collectionId}.json`);
     }
     await writeFile3(pageFilePath, JSON.stringify(pageData, null, 2), "utf-8");
     const schemaSource = pageData?.meta?.cms?.source;
     if (schemaSource !== "sanity") {
       const collectionDir = join6(this.cmsDir, collectionId);
-      if (!existsSync7(collectionDir)) {
+      if (!existsSync8(collectionDir)) {
         await mkdir(collectionDir, { recursive: true });
       }
     }
@@ -11221,12 +12234,12 @@ var FileSystemCMSProvider = class {
         `Invalid collection ID: "${collectionId}". Collection IDs must contain only letters, numbers, hyphens, and underscores.`
       );
     }
-    const { readFile: readFile2, writeFile: writeFile3 } = await import("node:fs/promises");
+    const { readFile: readFile3, writeFile: writeFile3 } = await import("node:fs/promises");
     const pageFilePath = join6(this.templatesDir, `${collectionId}.json`);
-    if (!existsSync7(pageFilePath)) {
+    if (!existsSync8(pageFilePath)) {
       throw new Error(`Collection not found: ${collectionId}`);
     }
-    const content = await readFile2(pageFilePath, "utf-8");
+    const content = await readFile3(pageFilePath, "utf-8");
     const pageData = JSON.parse(content);
     pageData.meta.cms = {
       ...pageData.meta.cms,
@@ -11245,26 +12258,26 @@ var PageCache = class {
   /**
    * Store page content and line map in cache
    */
-  set(path3, content, lineMap) {
-    this.cache.set(path3, { content, lineMap });
+  set(path5, content, lineMap) {
+    this.cache.set(path5, { content, lineMap });
   }
   /**
    * Get cached page data
    */
-  get(path3) {
-    return this.cache.get(path3);
+  get(path5) {
+    return this.cache.get(path5);
   }
   /**
    * Get page content from cache
    */
-  getContent(path3) {
-    return this.cache.get(path3)?.content;
+  getContent(path5) {
+    return this.cache.get(path5)?.content;
   }
   /**
    * Get line map from cache
    */
-  getLineMap(path3) {
-    return this.cache.get(path3)?.lineMap;
+  getLineMap(path5) {
+    return this.cache.get(path5)?.lineMap;
   }
   /**
    * Get line range for a specific element path
@@ -11275,14 +12288,14 @@ var PageCache = class {
   /**
    * Delete page from cache
    */
-  delete(path3) {
-    this.cache.delete(path3);
+  delete(path5) {
+    this.cache.delete(path5);
   }
   /**
    * Check if page exists in cache
    */
-  has(path3) {
-    return this.cache.has(path3);
+  has(path5) {
+    return this.cache.has(path5);
   }
   /**
    * Get all page paths
@@ -11321,21 +12334,21 @@ var DraftPageStore = class {
    * Store a draft for a page path. The value is the raw JSON string the
    * SSR pipeline expects, matching PageService.getPage()'s contract.
    */
-  set(path3, content) {
-    this.drafts.set(path3, content);
+  set(path5, content) {
+    this.drafts.set(path5, content);
   }
   /**
    * Get the current draft string for a page path, if any.
    */
-  get(path3) {
-    return this.drafts.get(path3);
+  get(path5) {
+    return this.drafts.get(path5);
   }
   /**
    * Drop the draft for a specific path. Called when the page is saved to
    * disk so subsequent renders read the persisted version.
    */
-  clear(path3) {
-    this.drafts.delete(path3);
+  clear(path5) {
+    this.drafts.delete(path5);
   }
   /**
    * Drop every draft. Used on shutdown / project switch.
@@ -11343,14 +12356,19 @@ var DraftPageStore = class {
   clearAll() {
     this.drafts.clear();
   }
-  has(path3) {
-    return this.drafts.has(path3);
+  has(path5) {
+    return this.drafts.has(path5);
   }
 };
 
 // lib/server/fileWatcher.ts
-import { watch, existsSync as existsSync8, statSync, readdirSync as readdirSync5 } from "node:fs";
-import { basename as basename2, dirname as dirname2, join as join7, relative } from "node:path";
+import { watch, existsSync as existsSync9, statSync as statSync2, readdirSync as readdirSync6 } from "node:fs";
+import { basename as basename2, dirname as dirname2, join as join7, relative as relative2 } from "node:path";
+
+// lib/shared/utils/fileUtils.ts
+var collapseFolderIndex = (name) => name.endsWith("/index") ? name.slice(0, -"/index".length) : name;
+
+// lib/server/fileWatcher.ts
 function watchRecursive(root, listener) {
   const nested = [];
   const watchedDirs = /* @__PURE__ */ new Set();
@@ -11358,17 +12376,17 @@ function watchRecursive(root, listener) {
   const coverNewDir = (abs) => {
     let isDir = false;
     try {
-      isDir = statSync(abs).isDirectory();
+      isDir = statSync2(abs).isDirectory();
     } catch {
       return;
     }
     if (!isDir || watchedDirs.has(abs)) return;
     attachDir(abs);
     try {
-      for (const e of readdirSync5(abs, { withFileTypes: true })) {
+      for (const e of readdirSync6(abs, { withFileTypes: true })) {
         const child = join7(abs, e.name);
         if (e.isDirectory()) coverNewDir(child);
-        else listener("rename", relative(root, child));
+        else listener("rename", relative2(root, child));
       }
     } catch {
     }
@@ -11381,7 +12399,7 @@ function watchRecursive(root, listener) {
       w = watch(absDir, { recursive: true }, (event, filename) => {
         if (!filename) return;
         const abs = join7(absDir, filename);
-        listener(event, relative(root, abs));
+        listener(event, relative2(root, abs));
         coverNewDir(abs);
       });
     } catch {
@@ -11406,19 +12424,19 @@ function watchRecursive(root, listener) {
   return handle;
 }
 function attachWhenDirExists(dirPath, attach, setWatcher) {
-  if (existsSync8(dirPath)) {
+  if (existsSync9(dirPath)) {
     setWatcher(attach());
     return;
   }
   const parentDir = dirname2(dirPath);
   const targetName = basename2(dirPath);
-  if (!existsSync8(parentDir)) {
+  if (!existsSync9(parentDir)) {
     return;
   }
   let parentWatcher = null;
   parentWatcher = watch(parentDir, (_event, filename) => {
     if (filename !== targetName) return;
-    if (!existsSync8(dirPath)) return;
+    if (!existsSync9(dirPath)) return;
     parentWatcher?.close();
     parentWatcher = null;
     setWatcher(attach());
@@ -11448,7 +12466,7 @@ var FileWatcher = class {
    * Watches both .json and .js files to detect component definition and JavaScript changes
    */
   watchComponents(dirPath = projectPaths.components()) {
-    if (!existsSync8(dirPath)) {
+    if (!existsSync9(dirPath)) {
       return;
     }
     this.componentsWatcher = watchRecursive(dirPath, async (_event, filename) => {
@@ -11464,7 +12482,7 @@ var FileWatcher = class {
    * Start watching pages directory
    */
   watchPages(dirPath = projectPaths.pages()) {
-    if (!existsSync8(dirPath)) {
+    if (!existsSync9(dirPath)) {
       return;
     }
     this.pagesWatcher = watchRecursive(dirPath, async (_event, filename) => {
@@ -11504,7 +12522,7 @@ var FileWatcher = class {
    * Start watching colors.json file
    */
   watchColors(filePath = projectPaths.colors()) {
-    if (!existsSync8(filePath)) {
+    if (!existsSync9(filePath)) {
       return;
     }
     const dirPath = getProjectRoot();
@@ -11561,7 +12579,7 @@ var FileWatcher = class {
    * Start watching images directory for new source images
    */
   watchImages(dirPath = projectPaths.images()) {
-    if (!existsSync8(dirPath)) {
+    if (!existsSync9(dirPath)) {
       return;
     }
     this.imagesWatcher = watch(dirPath, { recursive: false }, async (event, filename) => {
@@ -11588,7 +12606,7 @@ var FileWatcher = class {
    * Start watching libraries directory for CSS/JS changes
    */
   watchLibraries(dirPath = projectPaths.libraries()) {
-    if (!existsSync8(dirPath)) {
+    if (!existsSync9(dirPath)) {
       return;
     }
     this.librariesWatcher = watchRecursive(dirPath, async (_event, filename) => {
@@ -11621,7 +12639,8 @@ var FileWatcher = class {
           if (this.callbacks.onCMSTemplateChange) await this.callbacks.onCMSTemplateChange();
           return;
         }
-        const pagePath = mapPageNameToPath(filename.replace(/\.astro$/, ""));
+        const pageName = collapseFolderIndex(filename.replace(/\.astro$/, ""));
+        const pagePath = mapPageNameToPath(pageName);
         if (this.callbacks.onPageChange) await this.callbacks.onPageChange(pagePath);
       }),
       (w) => {
@@ -11789,9 +12808,9 @@ var FileWatcherService = class {
           this.refreshSchemasTimer = null;
           await cmsService.refreshSchemas();
           const ids = new Set(cmsService.getAllSchemas().keys());
-          for (const path3 of pageService.getAllPagePaths()) {
-            if (path3.startsWith("/templates/") && !ids.has(path3.slice("/templates/".length))) {
-              await pageService.deletePage(path3);
+          for (const path5 of pageService.getAllPagePaths()) {
+            if (path5.startsWith("/templates/") && !ids.has(path5.slice("/templates/".length))) {
+              await pageService.deletePage(path5);
             }
           }
           for (const id of ids) {
@@ -11845,20 +12864,20 @@ var FileWatcherService = class {
 };
 
 // lib/server/migrateTemplates.ts
-import { existsSync as existsSync9 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import { rename } from "node:fs/promises";
 import { join as join8 } from "node:path";
 async function migrateTemplatesDirectory() {
   const oldDir = join8(projectPaths.pages(), "templates");
   const newDir = projectPaths.templates();
-  if (!existsSync9(oldDir)) return;
-  if (existsSync9(newDir)) return;
+  if (!existsSync10(oldDir)) return;
+  if (existsSync10(newDir)) return;
   await rename(oldDir, newDir);
   console.log("Migrated CMS templates: pages/templates/ \u2192 templates/");
 }
 
 // build-astro.ts
-import { existsSync as existsSync10, readdirSync as readdirSync6, mkdirSync as mkdirSync4, rmSync, statSync as statSync2, copyFileSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync11, readdirSync as readdirSync7, mkdirSync as mkdirSync4, rmSync, statSync as statSync3, copyFileSync, writeFileSync } from "node:fs";
 import { writeFile as writeFile2, readFile } from "node:fs/promises";
 import { join as join9 } from "node:path";
 import { createHash } from "node:crypto";
@@ -12944,8 +13963,8 @@ function injectInlineStyle(styleAttr, extraCss) {
   if (dynLiteralMatch) {
     const existing = dynLiteralMatch[1] ?? "";
     const trimmed = existing.trimEnd();
-    const sep = trimmed.length > 0 && !trimmed.endsWith(";") ? ";" : "";
-    return ` style={\`${existing}${sep}${extraCss}\`}`;
+    const sep2 = trimmed.length > 0 && !trimmed.endsWith(";") ? ";" : "";
+    return ` style={\`${existing}${sep2}${extraCss}\`}`;
   }
   const dynExprMatch = styleAttr.match(/^ style=\{([\s\S]*)\}$/);
   if (dynExprMatch) {
@@ -12953,8 +13972,8 @@ function injectInlineStyle(styleAttr, extraCss) {
   }
   return styleAttr.replace(/style="([^"]*)"/, (_, existing) => {
     const trimmed = existing.trimEnd();
-    const sep = trimmed.length > 0 && !trimmed.endsWith(";") ? ";" : "";
-    return `style="${existing}${sep}${extraCss}"`;
+    const sep2 = trimmed.length > 0 && !trimmed.endsWith(";") ? ";" : "";
+    return `style="${existing}${sep2}${extraCss}"`;
   });
 }
 var PICTURE_WIDTHS = [500, 800, 1080, 1600, 2400];
@@ -13680,7 +14699,7 @@ function emitLocaleListNode(node, ctx) {
     const code = localeConfig.code;
     const isCurrent = code === currentLocale;
     if (!showCurrent && isCurrent) continue;
-    const path3 = slugMap[code] || "/";
+    const path5 = slugMap[code] || "/";
     const classes = isCurrent ? activeItemClasses : itemClasses;
     const classAttr = classes.length > 0 ? ` class="${classes.join(" ")}"` : "";
     const currentAttr = isCurrent ? ' data-current="true"' : ' data-current="false"';
@@ -13705,7 +14724,7 @@ function emitLocaleListNode(node, ctx) {
     }
     linkContent += `<div>${escapeJSX(displayText)}</div>`;
     links.push(
-      `${ind(ctx)}  <a href="${escapeJSX(path3)}"${hreflangAttr}${currentAttr} data-locale="${escapeJSX(code)}"${classAttr}>${linkContent}</a>`
+      `${ind(ctx)}  <a href="${escapeJSX(path5)}"${hreflangAttr}${currentAttr} data-locale="${escapeJSX(code)}"${classAttr}>${linkContent}</a>`
     );
   }
   let linksContent;
@@ -14199,8 +15218,8 @@ function emitAstroPage(options) {
   }
   const componentImports = Array.from(ctx.imports).sort();
   for (const comp of componentImports) {
-    const path3 = componentImportPath(fileDepth, comp);
-    importLines.push(`import ${astroComponentName(comp)} from '${path3}';`);
+    const path5 = componentImportPath(fileDepth, comp);
+    importLines.push(`import ${astroComponentName(comp)} from '${path5}';`);
   }
   const scriptsArrayLiteral = scriptPaths.length > 0 ? `[${scriptPaths.map((s) => `"${s}"`).join(", ")}]` : "[]";
   const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral2(libraryTags.headCSS || "")}\`, headJS: \`${escapeTemplateLiteral2(libraryTags.headJS || "")}\`, bodyEndJS: \`${escapeTemplateLiteral2(libraryTags.bodyEndJS || "")}\` }`;
@@ -14539,8 +15558,8 @@ function emitCMSPage(options) {
   }
   const componentImports = Array.from(ctx.imports).sort();
   for (const comp of componentImports) {
-    const path3 = componentImportPath2(fileDepth, comp);
-    importLines.push(`import ${astroComponentName(comp)} from '${path3}';`);
+    const path5 = componentImportPath2(fileDepth, comp);
+    importLines.push(`import ${astroComponentName(comp)} from '${path5}';`);
   }
   const staticPaths = buildGetStaticPaths(cmsSchema, isMultiLocale, i18nConfig, locale);
   const scriptsArrayLiteral = scriptPaths.length > 0 ? `[${scriptPaths.map((s) => `"${s}"`).join(", ")}]` : "[]";
@@ -14713,24 +15732,24 @@ function writePageScript(javascript, scriptsDir) {
   if (!javascript) return [];
   const hash = hashContent3(javascript);
   const scriptFile = `${hash}.js`;
-  if (!existsSync10(scriptsDir)) {
+  if (!existsSync11(scriptsDir)) {
     mkdirSync4(scriptsDir, { recursive: true });
   }
   const fullScriptPath = join9(scriptsDir, scriptFile);
-  if (!existsSync10(fullScriptPath)) {
+  if (!existsSync11(fullScriptPath)) {
     writeFileSync(fullScriptPath, javascript, "utf-8");
   }
   return [`/_scripts/${scriptFile}`];
 }
 function copyDirectory(src, dest, filter) {
-  if (!existsSync10(src)) return;
-  if (!existsSync10(dest)) mkdirSync4(dest, { recursive: true });
-  const files = readdirSync6(src);
+  if (!existsSync11(src)) return;
+  if (!existsSync11(dest)) mkdirSync4(dest, { recursive: true });
+  const files = readdirSync7(src);
   for (const file of files) {
     if (filter && !filter(file)) continue;
     const srcPath = join9(src, file);
     const destPath = join9(dest, file);
-    const stat = statSync2(srcPath);
+    const stat = statSync3(srcPath);
     if (stat.isDirectory()) copyDirectory(srcPath, destPath, filter);
     else copyFileSync(srcPath, destPath);
   }
@@ -14746,8 +15765,8 @@ function isCMSPage(pageData) {
 }
 function scanJSONFiles(dir, prefix = "") {
   const results = [];
-  if (!existsSync10(dir)) return results;
-  const entries = readdirSync6(dir, { withFileTypes: true });
+  if (!existsSync11(dir)) return results;
+  const entries = readdirSync7(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".json")) {
       results.push(prefix ? `${prefix}/${entry.name}` : entry.name);
@@ -14919,7 +15938,7 @@ async function buildAstroProject(_projectRoot, outputDir) {
   const componentLibraries = collectComponentLibraries(globalComponents);
   const imageMetadataMap = await buildImageMetadataMap();
   const outDir = outputDir || join9(projectPaths.project, "astro-export");
-  if (existsSync10(outDir)) {
+  if (existsSync11(outDir)) {
     rmSync(outDir, { recursive: true, force: true });
   }
   mkdirSync4(outDir, { recursive: true });
@@ -14934,7 +15953,7 @@ async function buildAstroProject(_projectRoot, outputDir) {
     mkdirSync4(d, { recursive: true });
   }
   const pagesDir = projectPaths.pages();
-  if (!existsSync10(pagesDir)) {
+  if (!existsSync11(pagesDir)) {
     console.error("Pages directory not found!");
     return { pages: 0, cmsPages: 0, collections: 0, errors: 1 };
   }
@@ -15065,7 +16084,7 @@ async function buildAstroProject(_projectRoot, outputDir) {
     const shouldInline = css.inline !== false;
     const relPath = css.url.slice(1);
     const srcPath = join9(projectPaths.project, relPath);
-    if (!existsSync10(srcPath)) continue;
+    if (!existsSync11(srcPath)) continue;
     if (shouldInline) {
       try {
         inlineContents.set(css.url, await readFile(srcPath, "utf-8"));
@@ -15079,7 +16098,7 @@ async function buildAstroProject(_projectRoot, outputDir) {
   for (const js of buildLibraries.js || []) {
     if (js.url.startsWith("/")) {
       const relPath = js.url.slice(1);
-      if (existsSync10(join9(projectPaths.project, relPath))) {
+      if (existsSync11(join9(projectPaths.project, relPath))) {
         localLibsToCopy.push(relPath);
       }
     }
@@ -15100,8 +16119,8 @@ async function buildAstroProject(_projectRoot, outputDir) {
   const cmsConsumerComponents = computeCmsConsumerComponents(globalComponents);
   const collectionUrlExpr = /* @__PURE__ */ new Map();
   const mergedRichTextFields = /* @__PURE__ */ new Set();
-  if (existsSync10(templatesDir)) {
-    for (const file of readdirSync6(templatesDir).filter((f) => f.endsWith(".json"))) {
+  if (existsSync11(templatesDir)) {
+    for (const file of readdirSync7(templatesDir).filter((f) => f.endsWith(".json"))) {
       const tc = await loadJSONFile(join9(templatesDir, file));
       if (!tc) continue;
       try {
@@ -15116,8 +16135,8 @@ async function buildAstroProject(_projectRoot, outputDir) {
       }
     }
   }
-  if (existsSync10(templatesDir)) {
-    const templateFiles = readdirSync6(templatesDir).filter((f) => f.endsWith(".json"));
+  if (existsSync11(templatesDir)) {
+    const templateFiles = readdirSync7(templatesDir).filter((f) => f.endsWith(".json"));
     for (const file of templateFiles) {
       const templateContent = await loadJSONFile(join9(templatesDir, file));
       if (!templateContent) continue;
@@ -15210,7 +16229,7 @@ async function buildAstroProject(_projectRoot, outputDir) {
           });
           const astroFileFull = join9(pagesOutDir, astroFilePath);
           const astroFileDir = astroFileFull.substring(0, astroFileFull.lastIndexOf("/"));
-          if (!existsSync10(astroFileDir)) {
+          if (!existsSync11(astroFileDir)) {
             mkdirSync4(astroFileDir, { recursive: true });
           }
           await writeFile2(astroFileFull, astroContent, "utf-8");
@@ -15361,7 +16380,7 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
     }
     const astroFileFull = join9(pagesOutDir, result.astroFilePath);
     const astroFileDir = astroFileFull.substring(0, astroFileFull.lastIndexOf("/"));
-    if (!existsSync10(astroFileDir)) {
+    if (!existsSync11(astroFileDir)) {
       mkdirSync4(astroFileDir, { recursive: true });
     }
     await writeFile2(astroFileFull, astroContent, "utf-8");
@@ -15393,9 +16412,9 @@ export const GET: APIRoute = () => {
       mkdirSync4(collectionDir, { recursive: true });
       const richTextFieldNames = Object.entries(schema.fields || {}).filter(([, fd]) => fd.type === "rich-text").map(([fn]) => fn);
       const cmsItemsDir = join9(projectPaths.cms(), schema.id);
-      if (existsSync10(cmsItemsDir)) {
+      if (existsSync11(cmsItemsDir)) {
         const isDevBuild = process.env.MENO_DEV_BUILD === "true";
-        const itemFiles = readdirSync6(cmsItemsDir).filter(
+        const itemFiles = readdirSync7(cmsItemsDir).filter(
           (f) => f.endsWith(".json") && (isDevBuild || !f.endsWith(`${CMS_DRAFT_SUFFIX}.json`))
         );
         for (const itemFile of itemFiles) {
@@ -15442,26 +16461,26 @@ export { collections };
     await writeFile2(join9(srcDir, "content.config.ts"), configContent, "utf-8");
   }
   const imagesSrcDir = join9(projectPaths.project, "images");
-  if (existsSync10(imagesSrcDir)) {
+  if (existsSync11(imagesSrcDir)) {
     copyDirectory(imagesSrcDir, join9(srcDir, "assets", "images"), shouldCopyImageForAstro);
     copyDirectory(imagesSrcDir, join9(publicDir, "images"));
   }
   const publicAssetDirs = ["fonts", "icons", "videos", "assets"];
   for (const dir of publicAssetDirs) {
     const srcAssetDir = join9(projectPaths.project, dir);
-    if (existsSync10(srcAssetDir)) {
+    if (existsSync11(srcAssetDir)) {
       copyDirectory(srcAssetDir, join9(publicDir, dir));
     }
   }
   const librariesDir = join9(projectPaths.project, "libraries");
-  if (existsSync10(librariesDir)) {
+  if (existsSync11(librariesDir)) {
     copyDirectory(librariesDir, join9(publicDir, "libraries"));
   }
   for (const relPath of localLibsToCopy) {
     const srcPath = join9(projectPaths.project, relPath);
     const destPath = join9(publicDir, relPath);
     const destDir = destPath.substring(0, destPath.lastIndexOf("/"));
-    if (destDir && !existsSync10(destDir)) mkdirSync4(destDir, { recursive: true });
+    if (destDir && !existsSync11(destDir)) mkdirSync4(destDir, { recursive: true });
     copyFileSync(srcPath, destPath);
   }
   const packageJson = {
@@ -15531,6 +16550,32 @@ export default defineConfig({${siteUrl ? `
 
 // lib/server/index.ts
 init_constants();
+
+// lib/server/webflow/templateWrapper.ts
+import { readFile as readFile2 } from "node:fs/promises";
+var cachedTemplate = null;
+async function getWebflowTemplate(appName) {
+  if (cachedTemplate) return cachedTemplate;
+  const url = `https://webflow-ext.com/template/v2?name=${encodeURIComponent(appName)}`;
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`Failed to fetch Webflow template: ${res.status}`);
+  cachedTemplate = await res.text();
+  return cachedTemplate;
+}
+async function wrapInWebflowTemplate(html, manifestPath) {
+  try {
+    const manifest = JSON.parse(await readFile2(manifestPath, "utf-8"));
+    const template = await getWebflowTemplate(manifest.name || "Export to Meno");
+    const headMatch = html.match(/<head[^>]*>([\s\S]*?)<\/head>/i);
+    const bodyMatch = html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+    const headContent = headMatch?.[1] ?? "";
+    const bodyContent = bodyMatch?.[1] ?? "";
+    return template.replace("{{ui}}", headContent + bodyContent);
+  } catch (err) {
+    console.warn("Could not fetch Webflow wrapper template:", err.message);
+    return html;
+  }
+}
 export {
   CMSService,
   ColorService,
@@ -15550,6 +16595,7 @@ export {
   SERVE_PORT,
   VariableService,
   WebSocketManager,
+  auditStylesheet,
   buildAstroProject,
   buildAttributes,
   buildComponentHTML,
@@ -15557,6 +16603,7 @@ export {
   buildLineMap,
   bundleFile,
   clearJSValidationCache,
+  collectClassesFromPageData,
   collectComponentCSS,
   collectComponentJavaScript,
   colorService,
@@ -15571,6 +16618,7 @@ export {
   errorResponse,
   escapeHtml,
   extractPageMeta,
+  extractRules,
   fileExists,
   formHandlerScript,
   generateBuildErrorPage,
@@ -15617,12 +16665,14 @@ export {
   readJsonFile,
   readTextFile,
   regenerateThemeCss,
+  renderAuditMarkdown,
   renderPageSSR,
   resetFontConfig,
   resolvePackagePath,
   resolveProjectPath,
   saveColors,
   saveVariables,
+  sectionPrefix,
   serializeThemeCss,
   serveFile,
   setProjectRoot,
@@ -15634,6 +16684,7 @@ export {
   watchRecursive,
   withErrorHandling,
   withLogging,
+  wrapInWebflowTemplate,
   writeFile
 };
 //# sourceMappingURL=index.js.map