meno-core 1.1.1 → 1.1.3

package/dist/lib/server/index.js

@@ -1,5 +1,6 @@
 import {
   CMS_DRAFT_SUFFIX,
+  VARIABLE_GROUPS,
   buildSlugIndex,
   collectComponentLibraries,
   createLogger,
@@ -8,6 +9,7 @@ import {
   fontFaceCss,
   fontPreloadLinks,
   generateLibraryTags,
+  getDefaultScalingType,
   getLocaleLinks,
   isPathWithinRoot,
   isReservedDraftFilename,
@@ -18,7 +20,7 @@ import {
   resolveSlugToPageId,
   rewriteComponentRefs,
   translatePath
-} from "../../chunks/chunk-QWTQZHG3.js";
+} from "../../chunks/chunk-FQBIC2OB.js";
 import {
   syncNetlifyLocale404Block
 } from "../../chunks/chunk-2AR55GYH.js";
@@ -31,7 +33,7 @@ import {
   processStructure,
   resolveHtmlMapping,
   skipEmptyTemplateAttributes
-} from "../../chunks/chunk-7ZLF4NE5.js";
+} from "../../chunks/chunk-3JXK2QFU.js";
 import {
   DEFAULT_BREAKPOINTS,
   DEFAULT_FLUID_RANGE,
@@ -90,7 +92,7 @@ import {
   validateCMSDraftItem,
   validateCMSItem,
   validateComponentDefinition
-} from "../../chunks/chunk-J4IPTP5X.js";
+} from "../../chunks/chunk-LOZL5HOF.js";
 import {
   DEFAULT_I18N_CONFIG,
   buildLocalizedPath,
@@ -282,7 +284,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
 };
@@ -457,13 +459,13 @@ async function bundleWithBun(entrypoint, opts) {
       const code = await result.outputs[0].text();
       return { code, success: true, errors: [] };
     }
-    const errors = (result.logs || []).map((log6) => {
+    const errors = (result.logs || []).map((log7) => {
       const parts = [];
-      if (log6.position?.file) parts.push(`File: ${log6.position.file}`);
-      if (log6.position?.line) parts.push(`Line ${log6.position.line}:${log6.position.column || 0}`);
-      if (log6.position?.lineText) parts.push(log6.position.lineText);
-      if (log6.message) parts.push(log6.message);
-      return parts.length > 0 ? parts.join("\n") : String(log6);
+      if (log7.position?.file) parts.push(`File: ${log7.position.file}`);
+      if (log7.position?.line) parts.push(`Line ${log7.position.line}:${log7.position.column || 0}`);
+      if (log7.position?.lineText) parts.push(log7.position.lineText);
+      if (log7.message) parts.push(log7.message);
+      return parts.length > 0 ? parts.join("\n") : String(log7);
     });
     return { code: "", success: false, errors };
   } catch (err) {
@@ -471,12 +473,12 @@ async function bundleWithBun(entrypoint, opts) {
     if (opts.throw) throw err;
     const errors = [];
     if (be.logs && Array.isArray(be.logs)) {
-      for (const log6 of be.logs) {
+      for (const log7 of be.logs) {
         const parts = [];
-        if (log6.position?.line) parts.push(`Line ${log6.position.line}:${log6.position.column || 0}`);
-        if (log6.position?.lineText) parts.push(log6.position.lineText);
-        if (log6.message) parts.push(log6.message);
-        errors.push(parts.length > 0 ? parts.join("\n") : String(log6));
+        if (log7.position?.line) parts.push(`Line ${log7.position.line}:${log7.position.column || 0}`);
+        if (log7.position?.lineText) parts.push(log7.position.lineText);
+        if (log7.message) parts.push(log7.message);
+        errors.push(parts.length > 0 ? parts.join("\n") : String(log7));
       }
     } else {
       errors.push(be.message || String(err));
@@ -486,8 +488,8 @@ async function bundleWithBun(entrypoint, opts) {
 }
 async function minifyWithBun(code) {
   const { writeFile: writeFile3, rm: _rm } = await import("node:fs/promises");
-  const { join: join9 } = await import("node:path");
-  const tempFile = join9("/tmp", `meno-minify-${Date.now()}.js`);
+  const { join: join10 } = await import("node:path");
+  const tempFile = join10("/tmp", `meno-minify-${Date.now()}.js`);
   try {
     await writeFile3(tempFile, code, "utf-8");
     const result = await Bun.build({
@@ -506,12 +508,12 @@ async function minifyWithBun(code) {
     const { inspect: inspect2 } = await import("../../chunks/fs-G3ANWEFP.js");
     let details = "";
     if (be.logs && Array.isArray(be.logs)) {
-      details = be.logs.map((log6) => {
+      details = be.logs.map((log7) => {
         const parts = [];
-        if (log6.position?.line) parts.push(`Line ${log6.position.line}:${log6.position.column || 0}`);
-        if (log6.position?.lineText) parts.push(log6.position.lineText);
-        if (log6.message) parts.push(log6.message);
-        return parts.length > 0 ? parts.join("\n") : String(log6);
+        if (log7.position?.line) parts.push(`Line ${log7.position.line}:${log7.position.column || 0}`);
+        if (log7.position?.lineText) parts.push(log7.position.lineText);
+        if (log7.message) parts.push(log7.message);
+        return parts.length > 0 ? parts.join("\n") : String(log7);
       }).join("\n\n");
     }
     if (!details) {
@@ -524,16 +526,16 @@ async function minifyWithBun(code) {
     return { code: "", success: false, errors: [details] };
   } finally {
     try {
-      const { rm } = await import("node:fs/promises");
-      await rm(tempFile, { force: true });
+      const { rm: rm2 } = await import("node:fs/promises");
+      await rm2(tempFile, { force: true });
     } catch {
     }
   }
 }
 async function validateWithBun(code) {
-  const { writeFile: writeFile3, rm } = await import("node:fs/promises");
-  const { join: join9 } = await import("node:path");
-  const tempFile = join9("/tmp", `meno-validate-${Date.now()}-${Math.random().toString(36).slice(2)}.js`);
+  const { writeFile: writeFile3, rm: rm2 } = await import("node:fs/promises");
+  const { join: join10 } = await import("node:path");
+  const tempFile = join10("/tmp", `meno-validate-${Date.now()}-${Math.random().toString(36).slice(2)}.js`);
   try {
     await writeFile3(tempFile, code, "utf-8");
     await Bun.build({
@@ -547,12 +549,12 @@ async function validateWithBun(code) {
     const { inspect: inspect2 } = await import("../../chunks/fs-G3ANWEFP.js");
     let details = "";
     if (be.logs && Array.isArray(be.logs)) {
-      details = be.logs.map((log6) => {
+      details = be.logs.map((log7) => {
         const parts = [];
-        if (log6.position?.line) parts.push(`Line ${log6.position.line}:${log6.position.column || 0}`);
-        if (log6.position?.lineText) parts.push(log6.position.lineText);
-        if (log6.message) parts.push(log6.message);
-        return parts.length > 0 ? parts.join("\n") : String(log6);
+        if (log7.position?.line) parts.push(`Line ${log7.position.line}:${log7.position.column || 0}`);
+        if (log7.position?.lineText) parts.push(log7.position.lineText);
+        if (log7.message) parts.push(log7.message);
+        return parts.length > 0 ? parts.join("\n") : String(log7);
       }).join("\n\n");
     }
     if (!details) {
@@ -565,7 +567,7 @@ async function validateWithBun(code) {
     return details || "Unknown JavaScript error";
   } finally {
     try {
-      await rm(tempFile, { force: true });
+      await rm2(tempFile, { force: true });
     } catch {
     }
   }
@@ -1690,6 +1692,9 @@ async function handleComponentsConfigRoute() {
   }
 }
 
+// lib/server/services/ColorService.ts
+import { existsSync as existsSync3 } from "node:fs";
+
 // lib/server/services/CachedConfigLoader.ts
 var CachedConfigLoader = class {
   config = null;
@@ -1730,8 +1735,511 @@ var CachedConfigLoader = class {
   }
 };
 
+// lib/server/themeCssStore.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join as join2 } from "node:path";
+
+// lib/server/themeCssCodec.ts
+var COLORS_LABEL = "Colors";
+var OTHER_LABEL = "Other";
+var HEADER_BANNER = `/*
+ * Meno design tokens \u2014 theme.css is the source of truth for this project's colors and
+ * variables. Edit values here, or use the Studio color/variable panels. Variables are
+ * grouped by the comment sections below; the @media regions are regenerated on save
+ * (responsive scaling is configured in project.config.json).
+ */`;
+var AUTO_BANNER = "/* === Responsive scaling \u2014 auto-generated from project.config.json; regenerated on save === */";
+var OVERRIDES_BANNER = "/* === Responsive overrides \u2014 per-variable; preserved across regen === */";
+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 groupForSectionLabel(label) {
+  return LABEL_TO_GROUP.get(label.trim().toLowerCase()) ?? null;
+}
+function isColorValue(value) {
+  const v = value.trim().toLowerCase();
+  if (/^#[0-9a-f]{3,8}$/.test(v)) return true;
+  if (/^(rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color)\(/.test(v)) return true;
+  if (v === "transparent" || v === "currentcolor") return true;
+  return false;
+}
+function inferGroup(cssVar, value) {
+  const v = value.trim().toLowerCase();
+  if (/^\d+(\.\d+)?m?s$/.test(v)) return "duration";
+  if (/^(normal|bold|lighter|bolder)$/.test(v)) return "font-weight";
+  if (/^\d+$/.test(v)) {
+    const n = Number(v);
+    if (n >= 100 && n <= 900 && n % 100 === 0) return "font-weight";
+  }
+  if (/^\d*\.\d+$/.test(v) || /^[1-9](\.\d+)?$/.test(v)) return "line-height";
+  const name = cssVar.replace(/^--/, "").toLowerCase();
+  for (const g of VARIABLE_GROUPS) {
+    if (g.value !== "other" && name.includes(g.value)) return g.value;
+  }
+  return "other";
+}
+function groupVariables(variables) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const v of variables) {
+    const label = sectionLabelForGroup(v.group);
+    (buckets.get(label) ?? buckets.set(label, []).get(label)).push(v);
+  }
+  const ordered = [];
+  for (const g of VARIABLE_GROUPS) {
+    if (g.value === "other") continue;
+    const vars = buckets.get(g.label);
+    if (vars?.length) {
+      ordered.push({ label: g.label, vars });
+      buckets.delete(g.label);
+    }
+  }
+  for (const [label, vars] of buckets) if (vars.length) ordered.push({ label, vars });
+  return ordered;
+}
+function buildAutoMediaBlocks(scalable, cfg) {
+  const { breakpoints, responsiveScales } = cfg;
+  const baseRef = responsiveScales.baseReference || 16;
+  const sorted = Object.entries(breakpoints).sort((a, b) => b[1].breakpoint - a[1].breakpoint);
+  const blocks = [];
+  for (const [bpName, bp] of sorted) {
+    const lines = [];
+    for (const v of scalable) {
+      if (v.scales?.[bpName] !== void 0) continue;
+      const categoryScales = responsiveScales[v.type];
+      const scale = categoryScales?.[bpName];
+      if (scale == null) continue;
+      const scaled = scalePropertyValue(v.value, baseRef, scale);
+      if (scaled !== null && scaled !== v.value) lines.push(`    ${v.cssVar}: ${scaled};`);
+    }
+    if (lines.length) blocks.push(`@media (max-width: ${bp.breakpoint}px) {
+  :root {
+${lines.join("\n")}
+  }
+}`);
+  }
+  return blocks.join("\n\n");
+}
+function buildOverrideMediaBlocks(variables, breakpoints) {
+  const sorted = Object.entries(breakpoints).sort((a, b) => b[1].breakpoint - a[1].breakpoint);
+  const blocks = [];
+  for (const [bpName, bp] of sorted) {
+    const lines = [];
+    for (const v of variables) {
+      const override = v.scales?.[bpName];
+      if (override !== void 0 && override !== v.value) lines.push(`    ${v.cssVar}: ${override};`);
+    }
+    if (lines.length) blocks.push(`@media (max-width: ${bp.breakpoint}px) {
+  :root {
+${lines.join("\n")}
+  }
+}`);
+  }
+  return blocks.join("\n\n");
+}
+function serializeThemeCss(model, scaleConfig2) {
+  const { themes, variables, raw = [] } = model;
+  const palette = themes?.palette;
+  const defaultName = themes?.default ?? "default";
+  const defaultTheme = themes?.themes?.[defaultName];
+  const sections = [];
+  const colorEntries = Object.entries(defaultTheme?.colors ?? {});
+  if (colorEntries.length) {
+    sections.push(
+      [
+        `  /* ${COLORS_LABEL}: ${defaultName} */`,
+        ...colorEntries.map(([k, val]) => `  --${k}: ${resolvePaletteColor(val, palette)};`)
+      ].join("\n")
+    );
+  }
+  for (const { label, vars } of groupVariables(variables)) {
+    sections.push([`  /* ${label} */`, ...vars.map((v) => `  ${v.cssVar}: ${v.value};`)].join("\n"));
+  }
+  const blocks = [HEADER_BANNER];
+  blocks.push(sections.length ? `:root {
+${sections.join("\n\n")}
+}` : ":root {}");
+  for (const [name, theme] of Object.entries(themes?.themes ?? {})) {
+    if (name === defaultName) continue;
+    const lines = Object.entries(theme.colors ?? {}).map(
+      ([k, val]) => `  --${k}: ${resolvePaletteColor(val, palette)};`
+    );
+    if (lines.length) blocks.push(`[theme="${name}"] {
+${lines.join("\n")}
+}`);
+  }
+  if (scaleConfig2.responsiveScales?.enabled) {
+    const auto = buildAutoMediaBlocks(
+      variables.filter((v) => v.type && v.type !== "none"),
+      scaleConfig2
+    );
+    if (auto) blocks.push(AUTO_BANNER, auto);
+  }
+  const overrides = buildOverrideMediaBlocks(variables, scaleConfig2.breakpoints);
+  if (overrides) blocks.push(OVERRIDES_BANNER, overrides);
+  for (const r of raw) {
+    const t = r.trim();
+    if (t) blocks.push(t);
+  }
+  return `${blocks.join("\n\n")}
+`;
+}
+function skipString(s, i) {
+  const q = s[i];
+  i++;
+  while (i < s.length) {
+    if (s[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (s[i] === q) return i + 1;
+    i++;
+  }
+  return i;
+}
+function readBlock(s, open) {
+  let i = open + 1;
+  let depth = 1;
+  const bodyStart = i;
+  while (i < s.length && depth > 0) {
+    if (s[i] === "/" && s[i + 1] === "*") {
+      const e = s.indexOf("*/", i + 2);
+      i = e === -1 ? s.length : e + 2;
+      continue;
+    }
+    if (s[i] === '"' || s[i] === "'") {
+      i = skipString(s, i);
+      continue;
+    }
+    if (s[i] === "{") depth++;
+    else if (s[i] === "}") {
+      depth--;
+      if (depth === 0) break;
+    }
+    i++;
+  }
+  return { body: s.slice(bodyStart, i), end: i < s.length ? i + 1 : s.length };
+}
+function scanTopLevel(css) {
+  const nodes = [];
+  let i = 0;
+  while (i < css.length) {
+    while (i < css.length && /\s/.test(css[i])) i++;
+    if (i >= css.length) break;
+    if (css[i] === "/" && css[i + 1] === "*") {
+      const e = css.indexOf("*/", i + 2);
+      const stop = e === -1 ? css.length : e + 2;
+      const text = css.slice(i, stop);
+      nodes.push({ kind: "comment", text, raw: text });
+      i = stop;
+      continue;
+    }
+    const start = i;
+    while (i < css.length) {
+      const c = css[i];
+      if (c === "/" && css[i + 1] === "*") {
+        const e = css.indexOf("*/", i + 2);
+        i = e === -1 ? css.length : e + 2;
+        continue;
+      }
+      if (c === '"' || c === "'") {
+        i = skipString(css, i);
+        continue;
+      }
+      if (c === "{" || c === ";") break;
+      i++;
+    }
+    if (i < css.length && css[i] === "{") {
+      const prelude = css.slice(start, i).trim();
+      const { body, end } = readBlock(css, i);
+      nodes.push({ kind: "block", prelude, body, raw: css.slice(start, end) });
+      i = end;
+    } else {
+      const stop = i < css.length ? i + 1 : css.length;
+      const raw = css.slice(start, stop).trim();
+      if (raw) nodes.push({ kind: "statement", raw });
+      i = stop;
+    }
+  }
+  return nodes;
+}
+function scanDeclarations(body) {
+  const items = [];
+  let i = 0;
+  while (i < body.length) {
+    while (i < body.length && /\s/.test(body[i])) i++;
+    if (i >= body.length) break;
+    if (body[i] === "/" && body[i + 1] === "*") {
+      const e = body.indexOf("*/", i + 2);
+      const stop = e === -1 ? body.length : e + 2;
+      items.push({ kind: "comment", text: body.slice(i, stop) });
+      i = stop;
+      continue;
+    }
+    const start = i;
+    while (i < body.length) {
+      const c = body[i];
+      if (c === "/" && body[i + 1] === "*") {
+        const e = body.indexOf("*/", i + 2);
+        i = e === -1 ? body.length : e + 2;
+        continue;
+      }
+      if (c === '"' || c === "'") {
+        i = skipString(body, i);
+        continue;
+      }
+      if (c === ";") break;
+      i++;
+    }
+    const text = body.slice(start, i).trim();
+    i = i < body.length ? i + 1 : body.length;
+    const colon = text.indexOf(":");
+    if (colon > 0) {
+      items.push({ kind: "decl", prop: text.slice(0, colon).trim(), value: text.slice(colon + 1).trim() });
+    }
+  }
+  return items;
+}
+function commentInner(text) {
+  return text.replace(/^\/\*+/, "").replace(/\*+\/$/, "").trim();
+}
+function isHeaderBanner(text) {
+  const t = commentInner(text);
+  return /meno design tokens/i.test(t) || /AUTO-GENERATED by meno-astro/i.test(t);
+}
+function prettifyName(name) {
+  return name.replace(/[-_]/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function maxWidthPx(prelude) {
+  const m = prelude.match(/max-width:\s*(\d+)px/i);
+  return m ? Number(m[1]) : null;
+}
+function bpNameForPx(px, breakpoints) {
+  for (const [name, entry] of Object.entries(breakpoints)) if (entry.breakpoint === px) return name;
+  return null;
+}
+function parseThemeCss(css, breakpoints) {
+  const themesMap = {};
+  const variables = [];
+  const varByCssVar = /* @__PURE__ */ new Map();
+  const raw = [];
+  let defaultName = null;
+  let region = null;
+  for (const node of scanTopLevel(css)) {
+    if (node.kind === "comment") {
+      if (isHeaderBanner(node.text)) continue;
+      const inner = commentInner(node.text);
+      if (/responsive overrides/i.test(inner)) {
+        region = "overrides";
+        continue;
+      }
+      if (/responsive scaling|auto-generated from project\.config/i.test(inner)) {
+        region = "auto";
+        continue;
+      }
+      raw.push(node.raw);
+      continue;
+    }
+    if (node.kind === "statement") {
+      raw.push(node.raw);
+      continue;
+    }
+    const sel = node.prelude;
+    if (sel === ":root") {
+      let section = null;
+      for (const it of scanDeclarations(node.body)) {
+        if (it.kind === "comment") {
+          const inner = commentInner(it.text);
+          if (/^colors\b/i.test(inner)) {
+            section = "colors";
+            const dn = inner.match(/^colors\s*:\s*([\w-]+)/i);
+            if (dn) defaultName = dn[1];
+          } else {
+            const g = groupForSectionLabel(inner);
+            if (g) section = g;
+          }
+          continue;
+        }
+        if (!it.prop.startsWith("--")) continue;
+        const name = it.prop.slice(2);
+        if (section === "colors" || section === null && isColorValue(it.value)) {
+          const dn = defaultName ??= "default";
+          (themesMap[dn] ??= { colors: {} }).colors[name] = it.value;
+        } else {
+          const group = section ?? inferGroup(it.prop, it.value);
+          const v = { cssVar: it.prop, value: it.value, type: getDefaultScalingType(group), group };
+          variables.push(v);
+          varByCssVar.set(it.prop, v);
+        }
+      }
+      continue;
+    }
+    const themeMatch = sel.match(/^\[theme=["']?([^"'\]]+)["']?\]$/);
+    if (themeMatch) {
+      const theme = themesMap[themeMatch[1]] ??= { colors: {} };
+      for (const it of scanDeclarations(node.body)) {
+        if (it.kind === "decl" && it.prop.startsWith("--")) theme.colors[it.prop.slice(2)] = it.value;
+      }
+      continue;
+    }
+    if (/^@media\b/i.test(sel)) {
+      const px = maxWidthPx(sel);
+      if (region === "auto") continue;
+      const bpName = px != null && breakpoints ? bpNameForPx(px, breakpoints) : null;
+      if (!bpName) {
+        raw.push(node.raw);
+        continue;
+      }
+      for (const inner of scanTopLevel(node.body)) {
+        if (inner.kind !== "block" || inner.prelude !== ":root") continue;
+        for (const it of scanDeclarations(inner.body)) {
+          if (it.kind !== "decl" || !it.prop.startsWith("--")) continue;
+          const v = varByCssVar.get(it.prop);
+          if (v) (v.scales ??= {})[bpName] = it.value;
+        }
+      }
+      continue;
+    }
+    raw.push(node.raw);
+  }
+  if (!defaultName) defaultName = Object.keys(themesMap)[0] ?? "default";
+  (themesMap[defaultName] ??= { colors: {} }).label ??= prettifyName(defaultName);
+  for (const [name, t] of Object.entries(themesMap)) t.label ??= prettifyName(name);
+  return { themes: { default: defaultName, themes: themesMap }, variables, raw };
+}
+
+// lib/server/themeCssStore.ts
+var log2 = createLogger("themeCssStore");
+function themeCssPath(root = getProjectRoot()) {
+  return join2(root, "src", "styles", "theme.css");
+}
+function isThemeCssProject(root = getProjectRoot()) {
+  if (existsSync2(themeCssPath(root))) return true;
+  if (existsSync2(join2(root, "src", "pages"))) return true;
+  try {
+    const cfg = JSON.parse(readFileSync(join2(root, "project.config.json"), "utf8"));
+    if (cfg.format === "astro") return true;
+  } catch {
+  }
+  return false;
+}
+var writeChain = Promise.resolve();
+function enqueue(fn) {
+  const run = writeChain.then(fn, fn);
+  writeChain = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+async function readJsonSafe(path3) {
+  try {
+    return JSON.parse(await readTextFile(path3));
+  } catch {
+    return null;
+  }
+}
+function scaleConfig() {
+  return { breakpoints: configService.getBreakpoints(), responsiveScales: configService.getResponsiveScales() };
+}
+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());
+}
+async function writeModel(root, model) {
+  const css = serializeThemeCss(model, scaleConfig());
+  await ensureDir(join2(root, "src", "styles"));
+  await writeFile(themeCssPath(root), css);
+}
+function hasColors(themes) {
+  return Object.values(themes.themes ?? {}).some((t) => Object.keys(t.colors ?? {}).length > 0);
+}
+function mergeThemes(current, incoming) {
+  if (!incoming?.themes) return current;
+  if (!hasColors(current)) return incoming;
+  const out = { default: current.default, palette: current.palette, themes: { ...current.themes } };
+  for (const [name, theme] of Object.entries(incoming.themes)) {
+    const existing = out.themes[name];
+    out.themes[name] = existing ? { ...existing, colors: { ...theme.colors, ...existing.colors } } : theme;
+  }
+  return out;
+}
+function mergeVariables(current, incoming) {
+  if (!incoming?.length) return current;
+  const seen = new Set(current.map((v) => v.cssVar));
+  return [...current, ...incoming.filter((v) => !seen.has(v.cssVar))];
+}
+var AUTHORED_MARKER = "Meno design tokens";
+async function migrateIfNeeded(root) {
+  const colorsJson = join2(root, "colors.json");
+  const variablesJson = join2(root, "variables.json");
+  const hasColorsJson = existsSync2(colorsJson);
+  const hasVarsJson = existsSync2(variablesJson);
+  if (!hasColorsJson && !hasVarsJson) return;
+  try {
+    const jsonColors = hasColorsJson ? await readJsonSafe(colorsJson) : null;
+    const jsonVars = hasVarsJson ? await readJsonSafe(variablesJson) : null;
+    let current = emptyModel();
+    let authored = false;
+    if (await fileExists(themeCssPath(root))) {
+      const text = await readTextFile(themeCssPath(root));
+      authored = text.includes(AUTHORED_MARKER);
+      current = parseThemeCss(text, configService.getBreakpoints());
+    }
+    const base = authored ? current : emptyModel();
+    const merged = {
+      themes: mergeThemes(base.themes, jsonColors?.themes ? jsonColors : null),
+      variables: mergeVariables(base.variables, jsonVars?.variables),
+      raw: current.raw
+    };
+    await writeModel(root, merged);
+    await rm(colorsJson, { force: true });
+    await rm(variablesJson, { force: true });
+    log2.info("Folded colors.json / variables.json into src/styles/theme.css");
+  } catch (err) {
+    log2.warn("theme.css migration failed; keeping JSON files:", err);
+  }
+}
+async function loadThemeModel(root = getProjectRoot()) {
+  await configService.load();
+  return enqueue(async () => {
+    await migrateIfNeeded(root);
+    return readModel(root);
+  });
+}
+async function saveColors(themes, root = getProjectRoot()) {
+  await configService.load();
+  return enqueue(async () => {
+    await migrateIfNeeded(root);
+    const current = await readModel(root);
+    await writeModel(root, { themes, variables: current.variables, raw: current.raw });
+  });
+}
+async function saveVariables(variables, root = getProjectRoot()) {
+  await configService.load();
+  return enqueue(async () => {
+    await migrateIfNeeded(root);
+    const current = await readModel(root);
+    await writeModel(root, { themes: current.themes, variables, raw: current.raw });
+  });
+}
+async function regenerateThemeCss(root = getProjectRoot()) {
+  await configService.load();
+  return enqueue(async () => {
+    await migrateIfNeeded(root);
+    if (!await fileExists(themeCssPath(root))) return;
+    await writeModel(root, await readModel(root));
+  });
+}
+
 // lib/server/services/ColorService.ts
-var log2 = createLogger("ColorService");
+var log3 = createLogger("ColorService");
 var ColorService = class extends CachedConfigLoader {
   /**
    * Load theme configuration from colors.json
@@ -1740,9 +2248,19 @@ var ColorService = class extends CachedConfigLoader {
     return this.load();
   }
   /**
-   * Perform the actual loading from file
+   * Perform the actual loading from file.
+   * Astro projects read colors from `src/styles/theme.css` (the token source of truth);
+   * legacy JSON projects read `colors.json`.
    */
   async performLoad() {
+    if (isThemeCssProject()) {
+      try {
+        return (await loadThemeModel()).themes;
+      } catch (error) {
+        log3.warn("Failed to load colors from theme.css:", error);
+        return this.getDefaultThemeConfig();
+      }
+    }
     try {
       const content = await loadJSONFile(projectPaths.colors());
       if (content) {
@@ -1752,7 +2270,7 @@ var ColorService = class extends CachedConfigLoader {
         }
       }
     } catch (error) {
-      log2.warn("Failed to load colors.json:", error);
+      log3.warn("Failed to load colors.json:", error);
     }
     return this.getDefaultThemeConfig();
   }
@@ -1832,6 +2350,23 @@ var ColorService = class extends CachedConfigLoader {
    * Distinguishes between missing file, invalid JSON, and valid config
    */
   async getConfigWithStatus() {
+    if (isThemeCssProject()) {
+      const filePath2 = themeCssPath();
+      if (!existsSync3(filePath2)) {
+        return { status: "missing", config: this.getMinimalConfig(), filePath: filePath2 };
+      }
+      try {
+        const model = await loadThemeModel();
+        return { status: "valid", config: model.themes, filePath: filePath2 };
+      } catch (error) {
+        return {
+          status: "invalid",
+          config: this.getMinimalConfig(),
+          error: error instanceof Error ? error.message : "Parse error",
+          filePath: filePath2
+        };
+      }
+    }
     const filePath = projectPaths.colors();
     try {
       const content = await loadJSONFile(filePath);
@@ -1882,7 +2417,7 @@ var ColorService = class extends CachedConfigLoader {
     const config = await this.loadThemeConfig();
     return Object.entries(config.themes).map(([name, theme]) => ({
       name,
-      label: theme.label
+      label: theme.label ?? name
     }));
   }
   /**
@@ -1916,12 +2451,15 @@ var ColorService = class extends CachedConfigLoader {
     return this.loadThemeConfig();
   }
   /**
-   * Save theme configuration to colors.json
+   * Save theme configuration. Astro projects write the colors half of
+   * `src/styles/theme.css` (preserving variables); legacy JSON projects write `colors.json`.
    */
   async saveThemeConfig(config) {
-    const colorsPath = projectPaths.colors();
-    const content = JSON.stringify(config, null, 2);
-    await writeFile(colorsPath, content);
+    if (isThemeCssProject()) {
+      await saveColors(config);
+    } else {
+      await writeFile(projectPaths.colors(), JSON.stringify(config, null, 2));
+    }
     this.setCache(config);
   }
 };
@@ -1948,7 +2486,8 @@ async function handleColorsStatusRoute() {
 }
 
 // lib/server/services/VariableService.ts
-var log3 = createLogger("VariableService");
+import { existsSync as existsSync4 } from "node:fs";
+var log4 = createLogger("VariableService");
 var VariableService = class extends CachedConfigLoader {
   /**
    * Load variables configuration from variables.json
@@ -1957,6 +2496,14 @@ var VariableService = class extends CachedConfigLoader {
     return this.load();
   }
   async performLoad() {
+    if (isThemeCssProject()) {
+      try {
+        return { variables: (await loadThemeModel()).variables };
+      } catch (error) {
+        log4.warn("Failed to load variables from theme.css:", error);
+        return this.getDefaultConfig();
+      }
+    }
     try {
       const content = await loadJSONFile(projectPaths.variables());
       if (content) {
@@ -1966,7 +2513,7 @@ var VariableService = class extends CachedConfigLoader {
         }
       }
     } catch (error) {
-      log3.warn("Failed to load variables.json:", error);
+      log4.warn("Failed to load variables.json:", error);
     }
     return this.getDefaultConfig();
   }
@@ -1979,7 +2526,7 @@ var VariableService = class extends CachedConfigLoader {
   migrateConfig(config) {
     for (const variable of config.variables) {
       if (variable.group === "spacing") {
-        const lower = `${variable.cssVar} ${variable.name}`.toLowerCase();
+        const lower = `${variable.cssVar} ${variable.name ?? ""}`.toLowerCase();
         if (lower.includes("margin")) {
           variable.group = "margin";
         } else if (lower.includes("gap")) {
@@ -1995,6 +2542,22 @@ var VariableService = class extends CachedConfigLoader {
    * Get config with status info (for editor UI)
    */
   async getConfigWithStatus() {
+    if (isThemeCssProject()) {
+      const filePath2 = themeCssPath();
+      if (!existsSync4(filePath2)) {
+        return { status: "missing", config: this.getDefaultConfig(), filePath: filePath2 };
+      }
+      try {
+        return { status: "valid", config: { variables: (await loadThemeModel()).variables }, filePath: filePath2 };
+      } catch (error) {
+        return {
+          status: "invalid",
+          config: this.getDefaultConfig(),
+          error: error instanceof Error ? error.message : "Parse error",
+          filePath: filePath2
+        };
+      }
+    }
     const filePath = projectPaths.variables();
     try {
       const content = await loadJSONFile(filePath);
@@ -2021,12 +2584,15 @@ var VariableService = class extends CachedConfigLoader {
     }
   }
   /**
-   * Save variables configuration to variables.json
+   * Save variables configuration. Astro projects write the variables half of
+   * `src/styles/theme.css` (preserving colors); legacy JSON projects write `variables.json`.
    */
   async saveConfig(config) {
-    const variablesPath = projectPaths.variables();
-    const content = JSON.stringify(config, null, 2);
-    await writeFile(variablesPath, content);
+    if (isThemeCssProject()) {
+      await saveVariables(config.variables);
+    } else {
+      await writeFile(projectPaths.variables(), JSON.stringify(config, null, 2));
+    }
     this.setCache(config);
   }
 };
@@ -2142,7 +2708,7 @@ async function handleVariablesCSSRoute() {
 }
 
 // lib/server/services/EnumService.ts
-var log4 = createLogger("EnumService");
+var log5 = createLogger("EnumService");
 var EnumService = class extends CachedConfigLoader {
   /**
    * Load enums configuration from enums.json
@@ -2162,7 +2728,7 @@ var EnumService = class extends CachedConfigLoader {
           return this.validateEnums(data);
         }
       } catch (error) {
-        log4.warn("Failed to parse enums.json:", error);
+        log5.warn("Failed to parse enums.json:", error);
       }
     }
     if (configContent) {
@@ -2384,7 +2950,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,
@@ -2410,7 +2976,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"
     }
@@ -4713,7 +5279,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();
 
@@ -4748,6 +5330,7 @@ var formHandlerScript = `
 
       try {
         const formData = new FormData(form);
+        formData.append('_elapsed', String(Date.now() - loadedAt));
 
         const response = await fetch(action, {
           method: method.toUpperCase(),
@@ -8440,8 +9023,8 @@ ${plainTextErrors}`;
 }
 
 // lib/server/services/pageService.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, mkdirSync, rmdirSync } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, mkdirSync, rmdirSync } from "node:fs";
+import { join as join4 } from "node:path";
 
 // lib/server/utils/jsonLineMapper.ts
 function buildLineMap(jsonText) {
@@ -8853,7 +9436,7 @@ var PageService = class {
    */
   getAllFolders() {
     const pagesDir = this.pagesBaseDir();
-    if (!existsSync2(pagesDir)) {
+    if (!existsSync5(pagesDir)) {
       return [];
     }
     const collectFolders = (dir, prefix) => {
@@ -8864,7 +9447,7 @@ var PageService = class {
           if (!entry.isDirectory()) continue;
           const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
           result.push(relativePath);
-          result.push(...collectFolders(join3(dir, entry.name), relativePath));
+          result.push(...collectFolders(join4(dir, entry.name), relativePath));
         }
         return result;
       } catch {
@@ -8895,8 +9478,8 @@ var PageService = class {
       }
     }
     const pagesDir = this.pagesBaseDir();
-    const folderPath = join3(pagesDir, trimmed);
-    if (existsSync2(folderPath)) {
+    const folderPath = join4(pagesDir, trimmed);
+    if (existsSync5(folderPath)) {
       throw new Error("Folder already exists");
     }
     mkdirSync(folderPath, { recursive: true });
@@ -8917,18 +9500,18 @@ var PageService = class {
     const pageName = pagePath === "/" ? "index" : pagePath.substring(1);
     const slashIndex = pageName.lastIndexOf("/");
     const baseName = slashIndex >= 0 ? pageName.substring(slashIndex + 1) : pageName;
-    const sourceFile = join3(pagesDir, `${pageName}${ext}`);
-    const targetFile = newFolder ? join3(pagesDir, newFolder, `${baseName}${ext}`) : join3(pagesDir, `${baseName}${ext}`);
+    const sourceFile = join4(pagesDir, `${pageName}${ext}`);
+    const targetFile = newFolder ? join4(pagesDir, newFolder, `${baseName}${ext}`) : join4(pagesDir, `${baseName}${ext}`);
     if (!isPathWithinRoot(sourceFile, pagesDir) || !isPathWithinRoot(targetFile, pagesDir)) {
       throw new Error(`movePage path escapes pages dir: ${pagePath} -> ${newFolder}`);
     }
     if (newFolder) {
-      const targetDir = join3(pagesDir, newFolder);
-      if (!existsSync2(targetDir)) {
+      const targetDir = join4(pagesDir, newFolder);
+      if (!existsSync5(targetDir)) {
         mkdirSync(targetDir, { recursive: true });
       }
     }
-    if (!existsSync2(sourceFile)) {
+    if (!existsSync5(sourceFile)) {
       throw new Error(`Page not found: ${pagePath}`);
     }
     await rename2(sourceFile, targetFile);
@@ -8940,7 +9523,7 @@ var PageService = class {
       const lineMap = buildLineMap(content);
       this.pageCache.set(newPath, content, lineMap);
     }
-    const sourceDir = slashIndex >= 0 ? join3(pagesDir, pageName.substring(0, slashIndex)) : null;
+    const sourceDir = slashIndex >= 0 ? join4(pagesDir, pageName.substring(0, slashIndex)) : null;
     if (sourceDir && sourceDir !== pagesDir) {
       try {
         const remaining = readdirSync2(sourceDir);
@@ -8989,12 +9572,12 @@ var PageService = class {
     const { rename: rename2 } = await import("node:fs/promises");
     const pagesDir = this.pagesBaseDir();
     const ext = this.pageExt();
-    const sourceFile = join3(pagesDir, `${oldName}${ext}`);
-    const targetFile = join3(pagesDir, `${newName}${ext}`);
-    if (!existsSync2(sourceFile)) {
+    const sourceFile = join4(pagesDir, `${oldName}${ext}`);
+    const targetFile = join4(pagesDir, `${newName}${ext}`);
+    if (!existsSync5(sourceFile)) {
       throw new Error(`Page not found: ${oldPath}`);
     }
-    if (existsSync2(targetFile)) {
+    if (existsSync5(targetFile)) {
       throw new Error(`Page already exists: ${newPath}`);
     }
     await rename2(sourceFile, targetFile);
@@ -9044,8 +9627,8 @@ var PageService = class {
 };
 
 // lib/server/services/componentService.ts
-import { join as join4 } from "node:path";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync3, rmdirSync as rmdirSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync as readdirSync3, rmdirSync as rmdirSync2 } from "node:fs";
 var ComponentService = class {
   components = /* @__PURE__ */ new Map();
   componentCategories = /* @__PURE__ */ new Map();
@@ -9277,7 +9860,7 @@ var ComponentService = class {
     const componentsDir = this.componentsBaseDir();
     if (!isSafePathSegment(name)) throw new Error(`unsafe component name: ${name}`);
     const cat = this.resolveComponentCategory(name, category);
-    const dir = cat ? join4(componentsDir, cat) : componentsDir;
+    const dir = cat ? join5(componentsDir, cat) : componentsDir;
     if (!isPathWithinRoot(dir, componentsDir)) throw new Error(`component category escapes components dir: ${cat}`);
     return dir;
   }
@@ -9308,10 +9891,10 @@ var ComponentService = class {
    */
   findComponentCategoryOnDisk(name) {
     const componentsDir = this.componentsBaseDir();
-    if (!existsSync3(componentsDir)) return void 0;
+    if (!existsSync6(componentsDir)) return void 0;
     const ext = this.writer ? null : ".json";
     const existsAt = (dir) => {
-      if (ext) return existsSync3(join4(dir, `${name}${ext}`));
+      if (ext) return existsSync6(join5(dir, `${name}${ext}`));
       try {
         return readdirSync3(dir, { withFileTypes: true }).some(
           (e) => e.isFile() && (e.name === `${name}.json` || e.name === `${name}.astro`)
@@ -9323,7 +9906,7 @@ var ComponentService = class {
     if (existsAt(componentsDir)) return void 0;
     try {
       for (const entry of readdirSync3(componentsDir, { withFileTypes: true })) {
-        if (entry.isDirectory() && existsAt(join4(componentsDir, entry.name))) {
+        if (entry.isDirectory() && existsAt(join5(componentsDir, entry.name))) {
           return entry.name;
         }
       }
@@ -9350,7 +9933,7 @@ var ComponentService = class {
    */
   async getComponentJavaScript(name) {
     const componentDir = this.getComponentDir(name);
-    const jsFilePath = join4(componentDir, `${name}.js`);
+    const jsFilePath = join5(componentDir, `${name}.js`);
     try {
       if (await fileExists(jsFilePath)) {
         return await readTextFile(jsFilePath);
@@ -9398,15 +9981,15 @@ var ComponentService = class {
     const dataWithJS = javascript !== void 0 ? { ...dataWithoutJS, component: { ...dataWithoutJS.component, javascript } } : dataWithoutJS;
     const targetCategory = this.resolveComponentCategory(name, category);
     const componentsDir = this.componentsBaseDir();
-    const componentDir = targetCategory ? join4(componentsDir, targetCategory) : componentsDir;
+    const componentDir = targetCategory ? join5(componentsDir, targetCategory) : componentsDir;
     if (this.writer) {
       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 && !existsSync3(componentDir)) {
+      if (targetCategory && !existsSync6(componentDir)) {
         mkdirSync2(componentDir, { recursive: true });
       }
-      const filePath = join4(componentDir, `${name}.json`);
+      const filePath = join5(componentDir, `${name}.json`);
       await writeFile3(filePath, JSON.stringify(dataWithoutJS, null, 2), "utf-8");
     }
     this.components.set(name, dataWithJS);
@@ -9439,9 +10022,9 @@ var ComponentService = class {
       return;
     }
     const writeFile3 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("node:fs/promises")).writeFile;
-    const jsFilePath = join4(componentDir, `${name}.js`);
+    const jsFilePath = join5(componentDir, `${name}.js`);
     await writeFile3(jsFilePath, javascript || "", "utf-8");
-    const componentPath = join4(componentDir, `${name}.json`);
+    const componentPath = join5(componentDir, `${name}.json`);
     const componentData = await loadJSONFile(componentPath);
     if (componentData) {
       const parsed = parseJSON(componentData);
@@ -9485,9 +10068,9 @@ var ComponentService = class {
       return;
     }
     const writeFile3 = this.fs ? this.fs.writeFile.bind(this.fs) : (await import("node:fs/promises")).writeFile;
-    const cssFilePath = join4(componentDir, `${name}.css`);
+    const cssFilePath = join5(componentDir, `${name}.css`);
     await writeFile3(cssFilePath, css || "", "utf-8");
-    const componentPath = join4(componentDir, `${name}.json`);
+    const componentPath = join5(componentDir, `${name}.json`);
     const componentData = await loadJSONFile(componentPath);
     if (componentData) {
       const parsed = parseJSON(componentData);
@@ -9520,7 +10103,7 @@ var ComponentService = class {
    */
   getAllFolders() {
     const componentsDir = this.componentsBaseDir();
-    if (!existsSync3(componentsDir)) {
+    if (!existsSync6(componentsDir)) {
       return [];
     }
     try {
@@ -9555,8 +10138,8 @@ var ComponentService = class {
       throw new Error("Folder name can only contain lowercase letters, numbers, dashes, and underscores");
     }
     const componentsDir = this.componentsBaseDir();
-    const folderPath = join4(componentsDir, folderName);
-    if (existsSync3(folderPath)) {
+    const folderPath = join5(componentsDir, folderName);
+    if (existsSync6(folderPath)) {
       throw new Error("Folder already exists");
     }
     mkdirSync2(folderPath, { recursive: true });
@@ -9589,20 +10172,20 @@ var ComponentService = class {
       return;
     }
     const componentsDir = this.componentsBaseDir();
-    const sourceDir = currentCategory ? join4(componentsDir, currentCategory) : componentsDir;
-    const targetDir = targetCategory ? join4(componentsDir, targetCategory) : componentsDir;
+    const sourceDir = currentCategory ? join5(componentsDir, currentCategory) : componentsDir;
+    const targetDir = targetCategory ? join5(componentsDir, targetCategory) : componentsDir;
     if (this.writer) {
       await this.writer.moveComponent(sourceDir, targetDir, name);
     } else {
-      if (targetCategory && !existsSync3(targetDir)) {
+      if (targetCategory && !existsSync6(targetDir)) {
         mkdirSync2(targetDir, { recursive: true });
       }
       const extensions = [".json", ".js", ".css"];
       const { rename: rename2 } = await import("node:fs/promises");
       for (const ext of extensions) {
-        const sourcePath = join4(sourceDir, `${name}${ext}`);
-        const targetPath = join4(targetDir, `${name}${ext}`);
-        if (existsSync3(sourcePath)) {
+        const sourcePath = join5(sourceDir, `${name}${ext}`);
+        const targetPath = join5(targetDir, `${name}${ext}`);
+        if (existsSync6(sourcePath)) {
           await rename2(sourcePath, targetPath);
         }
       }
@@ -9657,7 +10240,7 @@ var ComponentService = class {
     }
     const category = this.componentCategories.get(oldName);
     const componentsDir = this.componentsBaseDir();
-    const dir = category ? join4(componentsDir, category) : componentsDir;
+    const dir = category ? join5(componentsDir, category) : componentsDir;
     if (this.writer) {
       if (await this.writer.componentExists(dir, trimmedNew)) {
         throw new Error(`Component "${trimmedNew}" already exists in components/${category ?? ""}`);
@@ -9665,15 +10248,15 @@ var ComponentService = class {
       await this.writer.moveComponent(dir, dir, oldName, trimmedNew);
     } else {
       for (const ext of [".json", ".js", ".css"]) {
-        if (existsSync3(join4(dir, `${trimmedNew}${ext}`))) {
+        if (existsSync6(join5(dir, `${trimmedNew}${ext}`))) {
           throw new Error(`File "${trimmedNew}${ext}" already exists in components/${category ?? ""}`);
         }
       }
       const { rename: rename2 } = await import("node:fs/promises");
       for (const ext of [".json", ".js", ".css"]) {
-        const src = join4(dir, `${oldName}${ext}`);
-        const dst = join4(dir, `${trimmedNew}${ext}`);
-        if (existsSync3(src)) {
+        const src = join5(dir, `${oldName}${ext}`);
+        const dst = join5(dir, `${trimmedNew}${ext}`);
+        if (existsSync6(src)) {
           await rename2(src, dst);
         }
       }
@@ -9691,7 +10274,7 @@ var ComponentService = class {
       if (!structure) continue;
       if (rewriteComponentRefs(structure, oldName, trimmedNew)) {
         const otherCategory = this.componentCategories.get(name);
-        const otherDir = otherCategory ? join4(componentsDir, otherCategory) : componentsDir;
+        const otherDir = otherCategory ? join5(componentsDir, otherCategory) : componentsDir;
         const persisted = JSON.parse(JSON.stringify(otherDef));
         if (persisted?.component?.javascript !== void 0) {
           delete persisted.component.javascript;
@@ -9699,7 +10282,7 @@ var ComponentService = class {
         if (this.writer) {
           await this.writer.writeComponent(otherDir, name, persisted);
         } else {
-          await writeFile3(join4(otherDir, `${name}.json`), JSON.stringify(persisted, null, 2), "utf-8");
+          await writeFile3(join5(otherDir, `${name}.json`), JSON.stringify(persisted, null, 2), "utf-8");
         }
         componentRefs++;
       }
@@ -10239,9 +10822,9 @@ var CMSService = class {
 };
 
 // lib/server/providers/fileSystemCMSProvider.ts
-import { existsSync as existsSync4, readdirSync as readdirSync4, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join5 } from "node:path";
-var log5 = createLogger("FileSystemCMSProvider");
+import { existsSync as existsSync7, readdirSync as readdirSync4, 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`;
 async function loadJSONFile2(filePath) {
   try {
@@ -10250,7 +10833,7 @@ async function loadJSONFile2(filePath) {
     }
     return null;
   } catch (error) {
-    log5.warn(`Failed to parse JSON at ${filePath}:`, error instanceof Error ? error.message : error);
+    log6.warn(`Failed to parse JSON at ${filePath}:`, error instanceof Error ? error.message : error);
     return null;
   }
 }
@@ -10312,14 +10895,14 @@ var FileSystemCMSProvider = class {
       return this.schemaCache;
     }
     const schemas = /* @__PURE__ */ new Map();
-    if (!existsSync4(this.templatesDir)) {
+    if (!existsSync7(this.templatesDir)) {
       return schemas;
     }
     const files = readdirSync4(this.templatesDir);
     const jsonFiles = files.filter((f) => f.endsWith(".json"));
     const results = await Promise.all(
       jsonFiles.map(async (file) => {
-        const filePath = join5(this.templatesDir, file);
+        const filePath = join6(this.templatesDir, file);
         const content = await loadJSONFile2(filePath);
         return { filePath, content };
       })
@@ -10344,15 +10927,15 @@ var FileSystemCMSProvider = class {
    */
   async getItems(collection) {
     this.validateCollection(collection);
-    const collectionDir = join5(this.cmsDir, collection);
-    if (!existsSync4(collectionDir)) {
+    const collectionDir = join6(this.cmsDir, collection);
+    if (!existsSync7(collectionDir)) {
       return [];
     }
     const files = readdirSync4(collectionDir);
     const jsonFiles = files.filter((f) => f.endsWith(".json") && !f.endsWith(DRAFT_FILE_SUFFIX));
     const results = await Promise.all(
       jsonFiles.map(async (file) => {
-        const filePath = join5(collectionDir, file);
+        const filePath = join6(collectionDir, file);
         const content = await loadJSONFile2(filePath);
         return { file, filePath, content };
       })
@@ -10366,7 +10949,7 @@ var FileSystemCMSProvider = class {
         if (validation.valid) {
           items.push(validation.data);
         } else {
-          log5.warn(`Invalid CMS item at ${filePath}:`, validation.errors);
+          log6.warn(`Invalid CMS item at ${filePath}:`, validation.errors);
         }
       }
     }
@@ -10385,7 +10968,7 @@ var FileSystemCMSProvider = class {
   async getItemByFilename(collection, filename) {
     this.validateCollection(collection);
     this.validateFilename(filename);
-    const filePath = join5(this.cmsDir, collection, `${filename}.json`);
+    const filePath = join6(this.cmsDir, collection, `${filename}.json`);
     const content = await loadJSONFile2(filePath);
     if (!content || typeof content !== "object") {
       return null;
@@ -10395,7 +10978,7 @@ var FileSystemCMSProvider = class {
     if (validation.valid) {
       return validation.data;
     }
-    log5.warn(`Invalid CMS item at ${filePath}:`, validation.errors);
+    log6.warn(`Invalid CMS item at ${filePath}:`, validation.errors);
     return null;
   }
   /**
@@ -10437,12 +11020,12 @@ var FileSystemCMSProvider = class {
       throw new Error("Cannot derive filename: item is missing _id, _filename, and a usable slug-field value.");
     }
     this.validateFilename(filename);
-    const collectionDir = join5(this.cmsDir, collection);
-    if (!existsSync4(collectionDir)) {
+    const collectionDir = join6(this.cmsDir, collection);
+    if (!existsSync7(collectionDir)) {
       mkdirSync3(collectionDir, { recursive: true });
     }
     const itemData = stripTransient(item);
-    const filePath = join5(collectionDir, `${filename}.json`);
+    const filePath = join6(collectionDir, `${filename}.json`);
     await writeFile3(filePath, JSON.stringify(itemData, null, 2), "utf-8");
   }
   /**
@@ -10452,18 +11035,18 @@ var FileSystemCMSProvider = class {
     this.validateCollection(collection);
     this.validateFilename(filename);
     const { unlink } = await import("node:fs/promises");
-    const publishedPath = join5(this.cmsDir, collection, `${filename}.json`);
-    if (existsSync4(publishedPath)) {
+    const publishedPath = join6(this.cmsDir, collection, `${filename}.json`);
+    if (existsSync7(publishedPath)) {
       await unlink(publishedPath);
     }
     const draftPath = this.draftPath(collection, filename);
-    if (existsSync4(draftPath)) {
+    if (existsSync7(draftPath)) {
       await unlink(draftPath);
     }
   }
   // ---- Draft helpers ----------------------------------------------------
   draftPath(collection, filename) {
-    return join5(this.cmsDir, collection, `${filename}${DRAFT_FILE_SUFFIX}`);
+    return join6(this.cmsDir, collection, `${filename}${DRAFT_FILE_SUFFIX}`);
   }
   /**
    * Get the draft version of an item, or null if no draft file exists.
@@ -10490,12 +11073,12 @@ var FileSystemCMSProvider = class {
    */
   async getAllDrafts(collection) {
     this.validateCollection(collection);
-    const collectionDir = join5(this.cmsDir, collection);
-    if (!existsSync4(collectionDir)) return [];
+    const collectionDir = join6(this.cmsDir, collection);
+    if (!existsSync7(collectionDir)) return [];
     const files = readdirSync4(collectionDir).filter((f) => f.endsWith(DRAFT_FILE_SUFFIX));
     const results = await Promise.all(
       files.map(async (file) => {
-        const filePath = join5(collectionDir, file);
+        const filePath = join6(collectionDir, file);
         const content = await loadJSONFile2(filePath);
         return { file, content };
       })
@@ -10517,7 +11100,7 @@ var FileSystemCMSProvider = class {
   async hasDraft(collection, filename) {
     this.validateCollection(collection);
     this.validateFilename(filename);
-    return existsSync4(this.draftPath(collection, filename));
+    return existsSync7(this.draftPath(collection, filename));
   }
   /**
    * Save the draft version of an item. Loose validation — drafts may have
@@ -10551,8 +11134,8 @@ var FileSystemCMSProvider = class {
       throw new Error("Cannot derive draft filename: item is missing _id, _filename, and a usable slug-field value.");
     }
     this.validateFilename(filename);
-    const collectionDir = join5(this.cmsDir, collection);
-    if (!existsSync4(collectionDir)) {
+    const collectionDir = join6(this.cmsDir, collection);
+    if (!existsSync7(collectionDir)) {
       mkdirSync3(collectionDir, { recursive: true });
     }
     const itemData = stripTransient(item);
@@ -10572,7 +11155,7 @@ var FileSystemCMSProvider = class {
     this.validateFilename(filename);
     const { unlink } = await import("node:fs/promises");
     const filePath = this.draftPath(collection, filename);
-    if (existsSync4(filePath)) {
+    if (existsSync7(filePath)) {
       await unlink(filePath);
     }
   }
@@ -10600,14 +11183,14 @@ var FileSystemCMSProvider = class {
       const messages = validation.errors.map((e) => `${e.path}: ${e.message}`).join(", ");
       throw new Error(`Cannot publish invalid draft: ${messages}`);
     }
-    const collectionDir = join5(this.cmsDir, collection);
-    if (!existsSync4(collectionDir)) {
+    const collectionDir = join6(this.cmsDir, collection);
+    if (!existsSync7(collectionDir)) {
       mkdirSync3(collectionDir, { recursive: true });
     }
     const itemData = stripTransient(validation.data);
-    const publishedPath = join5(collectionDir, `${filename}.json`);
+    const publishedPath = join6(collectionDir, `${filename}.json`);
     await writeFile3(publishedPath, JSON.stringify(itemData, null, 2), "utf-8");
-    if (existsSync4(draftFilePath)) {
+    if (existsSync7(draftFilePath)) {
       await unlink(draftFilePath);
     }
     return normalizeItem(itemData, filename);
@@ -10628,18 +11211,18 @@ var FileSystemCMSProvider = class {
       );
     }
     const { writeFile: writeFile3, mkdir } = await import("node:fs/promises");
-    if (!existsSync4(this.templatesDir)) {
+    if (!existsSync7(this.templatesDir)) {
       await mkdir(this.templatesDir, { recursive: true });
     }
-    const pageFilePath = join5(this.templatesDir, `${collectionId}.json`);
-    if (existsSync4(pageFilePath)) {
+    const pageFilePath = join6(this.templatesDir, `${collectionId}.json`);
+    if (existsSync7(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 = join5(this.cmsDir, collectionId);
-      if (!existsSync4(collectionDir)) {
+      const collectionDir = join6(this.cmsDir, collectionId);
+      if (!existsSync7(collectionDir)) {
         await mkdir(collectionDir, { recursive: true });
       }
     }
@@ -10656,8 +11239,8 @@ var FileSystemCMSProvider = class {
       );
     }
     const { readFile: readFile2, writeFile: writeFile3 } = await import("node:fs/promises");
-    const pageFilePath = join5(this.templatesDir, `${collectionId}.json`);
-    if (!existsSync4(pageFilePath)) {
+    const pageFilePath = join6(this.templatesDir, `${collectionId}.json`);
+    if (!existsSync7(pageFilePath)) {
       throw new Error(`Collection not found: ${collectionId}`);
     }
     const content = await readFile2(pageFilePath, "utf-8");
@@ -10783,8 +11366,8 @@ var DraftPageStore = class {
 };
 
 // lib/server/fileWatcher.ts
-import { watch, existsSync as existsSync5, statSync, readdirSync as readdirSync5 } from "node:fs";
-import { basename as basename2, dirname as dirname2, join as join6, relative } from "node:path";
+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";
 function watchRecursive(root, listener) {
   const nested = [];
   const watchedDirs = /* @__PURE__ */ new Set();
@@ -10800,7 +11383,7 @@ function watchRecursive(root, listener) {
     attachDir(abs);
     try {
       for (const e of readdirSync5(abs, { withFileTypes: true })) {
-        const child = join6(abs, e.name);
+        const child = join7(abs, e.name);
         if (e.isDirectory()) coverNewDir(child);
         else listener("rename", relative(root, child));
       }
@@ -10814,7 +11397,7 @@ function watchRecursive(root, listener) {
     try {
       w = watch(absDir, { recursive: true }, (event, filename) => {
         if (!filename) return;
-        const abs = join6(absDir, filename);
+        const abs = join7(absDir, filename);
         listener(event, relative(root, abs));
         coverNewDir(abs);
       });
@@ -10840,19 +11423,19 @@ function watchRecursive(root, listener) {
   return handle;
 }
 function attachWhenDirExists(dirPath, attach, setWatcher) {
-  if (existsSync5(dirPath)) {
+  if (existsSync8(dirPath)) {
     setWatcher(attach());
     return;
   }
   const parentDir = dirname2(dirPath);
   const targetName = basename2(dirPath);
-  if (!existsSync5(parentDir)) {
+  if (!existsSync8(parentDir)) {
     return;
   }
   let parentWatcher = null;
   parentWatcher = watch(parentDir, (_event, filename) => {
     if (filename !== targetName) return;
-    if (!existsSync5(dirPath)) return;
+    if (!existsSync8(dirPath)) return;
     parentWatcher?.close();
     parentWatcher = null;
     setWatcher(attach());
@@ -10882,7 +11465,7 @@ var FileWatcher = class {
    * Watches both .json and .js files to detect component definition and JavaScript changes
    */
   watchComponents(dirPath = projectPaths.components()) {
-    if (!existsSync5(dirPath)) {
+    if (!existsSync8(dirPath)) {
       return;
     }
     this.componentsWatcher = watchRecursive(dirPath, async (_event, filename) => {
@@ -10898,7 +11481,7 @@ var FileWatcher = class {
    * Start watching pages directory
    */
   watchPages(dirPath = projectPaths.pages()) {
-    if (!existsSync5(dirPath)) {
+    if (!existsSync8(dirPath)) {
       return;
     }
     this.pagesWatcher = watchRecursive(dirPath, async (_event, filename) => {
@@ -10938,7 +11521,7 @@ var FileWatcher = class {
    * Start watching colors.json file
    */
   watchColors(filePath = projectPaths.colors()) {
-    if (!existsSync5(filePath)) {
+    if (!existsSync8(filePath)) {
       return;
     }
     const dirPath = getProjectRoot();
@@ -10995,7 +11578,7 @@ var FileWatcher = class {
    * Start watching images directory for new source images
    */
   watchImages(dirPath = projectPaths.images()) {
-    if (!existsSync5(dirPath)) {
+    if (!existsSync8(dirPath)) {
       return;
     }
     this.imagesWatcher = watch(dirPath, { recursive: false }, async (event, filename) => {
@@ -11022,7 +11605,7 @@ var FileWatcher = class {
    * Start watching libraries directory for CSS/JS changes
    */
   watchLibraries(dirPath = projectPaths.libraries()) {
-    if (!existsSync5(dirPath)) {
+    if (!existsSync8(dirPath)) {
       return;
     }
     this.librariesWatcher = watchRecursive(dirPath, async (_event, filename) => {
@@ -11046,7 +11629,7 @@ var FileWatcher = class {
    * early-out and the first collection's item edits wouldn't live-reload until a
    * dev-server restart.
    */
-  watchAstroPages(dirPath = join6(getProjectRoot(), "src", "pages")) {
+  watchAstroPages(dirPath = join7(getProjectRoot(), "src", "pages")) {
     attachWhenDirExists(
       dirPath,
       () => watchRecursive(dirPath, async (_event, filename) => {
@@ -11063,7 +11646,7 @@ var FileWatcher = class {
       }
     );
   }
-  watchAstroComponents(dirPath = join6(getProjectRoot(), "src", "components")) {
+  watchAstroComponents(dirPath = join7(getProjectRoot(), "src", "components")) {
     attachWhenDirExists(
       dirPath,
       () => watchRecursive(dirPath, async (_event, filename) => {
@@ -11076,7 +11659,7 @@ var FileWatcher = class {
       }
     );
   }
-  watchAstroContent(dirPath = join6(getProjectRoot(), "src", "content")) {
+  watchAstroContent(dirPath = join7(getProjectRoot(), "src", "content")) {
     attachWhenDirExists(
       dirPath,
       () => watchRecursive(dirPath, async (_event, filename) => {
@@ -11279,22 +11862,22 @@ var FileWatcherService = class {
 };
 
 // lib/server/migrateTemplates.ts
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync9 } from "node:fs";
 import { rename } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 async function migrateTemplatesDirectory() {
-  const oldDir = join7(projectPaths.pages(), "templates");
+  const oldDir = join8(projectPaths.pages(), "templates");
   const newDir = projectPaths.templates();
-  if (!existsSync6(oldDir)) return;
-  if (existsSync6(newDir)) return;
+  if (!existsSync9(oldDir)) return;
+  if (existsSync9(newDir)) return;
   await rename(oldDir, newDir);
   console.log("Migrated CMS templates: pages/templates/ \u2192 templates/");
 }
 
 // build-astro.ts
-import { existsSync as existsSync7, readdirSync as readdirSync6, mkdirSync as mkdirSync4, rmSync, statSync as statSync2, copyFileSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync6, mkdirSync as mkdirSync4, rmSync, statSync as statSync2, copyFileSync, writeFileSync } from "node:fs";
 import { writeFile as writeFile2, readFile } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 import { createHash } from "node:crypto";
 
 // lib/server/astro/tailwindMapper.ts
@@ -14147,23 +14730,23 @@ function writePageScript(javascript, scriptsDir) {
   if (!javascript) return [];
   const hash = hashContent3(javascript);
   const scriptFile = `${hash}.js`;
-  if (!existsSync7(scriptsDir)) {
+  if (!existsSync10(scriptsDir)) {
     mkdirSync4(scriptsDir, { recursive: true });
   }
-  const fullScriptPath = join8(scriptsDir, scriptFile);
-  if (!existsSync7(fullScriptPath)) {
+  const fullScriptPath = join9(scriptsDir, scriptFile);
+  if (!existsSync10(fullScriptPath)) {
     writeFileSync(fullScriptPath, javascript, "utf-8");
   }
   return [`/_scripts/${scriptFile}`];
 }
 function copyDirectory(src, dest, filter) {
-  if (!existsSync7(src)) return;
-  if (!existsSync7(dest)) mkdirSync4(dest, { recursive: true });
+  if (!existsSync10(src)) return;
+  if (!existsSync10(dest)) mkdirSync4(dest, { recursive: true });
   const files = readdirSync6(src);
   for (const file of files) {
     if (filter && !filter(file)) continue;
-    const srcPath = join8(src, file);
-    const destPath = join8(dest, file);
+    const srcPath = join9(src, file);
+    const destPath = join9(dest, file);
     const stat = statSync2(srcPath);
     if (stat.isDirectory()) copyDirectory(srcPath, destPath, filter);
     else copyFileSync(srcPath, destPath);
@@ -14180,13 +14763,13 @@ function isCMSPage(pageData) {
 }
 function scanJSONFiles(dir, prefix = "") {
   const results = [];
-  if (!existsSync7(dir)) return results;
+  if (!existsSync10(dir)) return results;
   const entries = readdirSync6(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".json")) {
       results.push(prefix ? `${prefix}/${entry.name}` : entry.name);
     } else if (entry.isDirectory()) {
-      results.push(...scanJSONFiles(join8(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name));
+      results.push(...scanJSONFiles(join9(dir, entry.name), prefix ? `${prefix}/${entry.name}` : entry.name));
     }
   }
   return results;
@@ -14352,23 +14935,23 @@ async function buildAstroProject(_projectRoot, outputDir) {
   const globalLibraries = configService.getLibraries();
   const componentLibraries = collectComponentLibraries(globalComponents);
   const imageMetadataMap = await buildImageMetadataMap();
-  const outDir = outputDir || join8(projectPaths.project, "astro-export");
-  if (existsSync7(outDir)) {
+  const outDir = outputDir || join9(projectPaths.project, "astro-export");
+  if (existsSync10(outDir)) {
     rmSync(outDir, { recursive: true, force: true });
   }
   mkdirSync4(outDir, { recursive: true });
-  const srcDir = join8(outDir, "src");
-  const pagesOutDir = join8(srcDir, "pages");
-  const layoutsDir = join8(srcDir, "layouts");
-  const stylesDir = join8(srcDir, "styles");
-  const componentsOutDir = join8(srcDir, "components");
-  const publicDir = join8(outDir, "public");
-  const scriptsDir = join8(publicDir, "_scripts");
+  const srcDir = join9(outDir, "src");
+  const pagesOutDir = join9(srcDir, "pages");
+  const layoutsDir = join9(srcDir, "layouts");
+  const stylesDir = join9(srcDir, "styles");
+  const componentsOutDir = join9(srcDir, "components");
+  const publicDir = join9(outDir, "public");
+  const scriptsDir = join9(publicDir, "_scripts");
   for (const d of [srcDir, pagesOutDir, layoutsDir, stylesDir, componentsOutDir, publicDir]) {
     mkdirSync4(d, { recursive: true });
   }
   const pagesDir = projectPaths.pages();
-  if (!existsSync7(pagesDir)) {
+  if (!existsSync10(pagesDir)) {
     console.error("Pages directory not found!");
     return { pages: 0, cmsPages: 0, collections: 0, errors: 1 };
   }
@@ -14381,7 +14964,7 @@ async function buildAstroProject(_projectRoot, outputDir) {
   for (const file of pageFiles) {
     const pageName = file.replace(".json", "");
     const basePath = mapPageNameToPath(pageName);
-    const pageContent = await loadJSONFile(join8(pagesDir, file));
+    const pageContent = await loadJSONFile(join9(pagesDir, file));
     if (!pageContent) continue;
     try {
       const pageData = parseJSON(pageContent);
@@ -14440,7 +15023,7 @@ async function buildAstroProject(_projectRoot, outputDir) {
   for (const file of pageFiles) {
     const pageName = file.replace(".json", "");
     const basePath = mapPageNameToPath(pageName);
-    const pageContent = await loadJSONFile(join8(pagesDir, file));
+    const pageContent = await loadJSONFile(join9(pagesDir, file));
     if (!pageContent) {
       console.warn(`  Skipping ${basePath} (empty file)`);
       errorCount++;
@@ -14498,8 +15081,8 @@ async function buildAstroProject(_projectRoot, outputDir) {
     if (!css.url.startsWith("/")) continue;
     const shouldInline = css.inline !== false;
     const relPath = css.url.slice(1);
-    const srcPath = join8(projectPaths.project, relPath);
-    if (!existsSync7(srcPath)) continue;
+    const srcPath = join9(projectPaths.project, relPath);
+    if (!existsSync10(srcPath)) continue;
     if (shouldInline) {
       try {
         inlineContents.set(css.url, await readFile(srcPath, "utf-8"));
@@ -14513,7 +15096,7 @@ async function buildAstroProject(_projectRoot, outputDir) {
   for (const js of buildLibraries.js || []) {
     if (js.url.startsWith("/")) {
       const relPath = js.url.slice(1);
-      if (existsSync7(join8(projectPaths.project, relPath))) {
+      if (existsSync10(join9(projectPaths.project, relPath))) {
         localLibsToCopy.push(relPath);
       }
     }
@@ -14534,9 +15117,9 @@ async function buildAstroProject(_projectRoot, outputDir) {
   const cmsConsumerComponents = computeCmsConsumerComponents(globalComponents);
   const collectionUrlExpr = /* @__PURE__ */ new Map();
   const mergedRichTextFields = /* @__PURE__ */ new Set();
-  if (existsSync7(templatesDir)) {
+  if (existsSync10(templatesDir)) {
     for (const file of readdirSync6(templatesDir).filter((f) => f.endsWith(".json"))) {
-      const tc = await loadJSONFile(join8(templatesDir, file));
+      const tc = await loadJSONFile(join9(templatesDir, file));
       if (!tc) continue;
       try {
         const pd = parseJSON(tc);
@@ -14550,10 +15133,10 @@ async function buildAstroProject(_projectRoot, outputDir) {
       }
     }
   }
-  if (existsSync7(templatesDir)) {
+  if (existsSync10(templatesDir)) {
     const templateFiles = readdirSync6(templatesDir).filter((f) => f.endsWith(".json"));
     for (const file of templateFiles) {
-      const templateContent = await loadJSONFile(join8(templatesDir, file));
+      const templateContent = await loadJSONFile(join9(templatesDir, file));
       if (!templateContent) continue;
       try {
         const pageData = parseJSON(templateContent);
@@ -14642,9 +15225,9 @@ async function buildAstroProject(_projectRoot, outputDir) {
             cmsConsumers: cmsConsumerComponents,
             collectionUrlExpr
           });
-          const astroFileFull = join8(pagesOutDir, astroFilePath);
+          const astroFileFull = join9(pagesOutDir, astroFilePath);
           const astroFileDir = astroFileFull.substring(0, astroFileFull.lastIndexOf("/"));
-          if (!existsSync7(astroFileDir)) {
+          if (!existsSync10(astroFileDir)) {
             mkdirSync4(astroFileDir, { recursive: true });
           }
           await writeFile2(astroFileFull, astroContent, "utf-8");
@@ -14676,7 +15259,7 @@ async function buildAstroProject(_projectRoot, outputDir) {
 
 ${safelistDirectives}` : `@import "tailwindcss";`;
   const globalCSS = [tailwindDirectives, fontCSS, themeColorCSS, variablesCSS, baseCSS, componentCSSCombined].filter(Boolean).join("\n\n");
-  await writeFile2(join8(stylesDir, "global.css"), globalCSS, "utf-8");
+  await writeFile2(join9(stylesDir, "global.css"), globalCSS, "utf-8");
   const escForTemplateLiteral = (s) => s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
   const customHeadLiteral = escForTemplateLiteral(customCode.head || "");
   const customBodyStartLiteral = escForTemplateLiteral(customCode.bodyStart || "");
@@ -14723,7 +15306,7 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
 </body>
 </html>
 `;
-  await writeFile2(join8(layoutsDir, "BaseLayout.astro"), baseLayoutContent, "utf-8");
+  await writeFile2(join9(layoutsDir, "BaseLayout.astro"), baseLayoutContent, "utf-8");
   const emittableComponents = normalizeOrphanTemplateProps(globalComponents);
   let _componentFileCount = 0;
   for (const [compName, compDef] of Object.entries(emittableComponents)) {
@@ -14742,7 +15325,7 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
           collectionUrlExpr
         }
       );
-      await writeFile2(join8(componentsOutDir, `${compName}.astro`), astroContent, "utf-8");
+      await writeFile2(join9(componentsOutDir, `${compName}.astro`), astroContent, "utf-8");
       _componentFileCount++;
     } catch (error) {
       console.warn(
@@ -14793,9 +15376,9 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
       scriptPaths = writePageScript(result.javascript, scriptsDir);
       astroContent = buildSSRFallbackPage(result, importPath, fontPreloads, libraryTags, defaultTheme, scriptPaths);
     }
-    const astroFileFull = join8(pagesOutDir, result.astroFilePath);
+    const astroFileFull = join9(pagesOutDir, result.astroFilePath);
     const astroFileDir = astroFileFull.substring(0, astroFileFull.lastIndexOf("/"));
-    if (!existsSync7(astroFileDir)) {
+    if (!existsSync10(astroFileDir)) {
       mkdirSync4(astroFileDir, { recursive: true });
     }
     await writeFile2(astroFileFull, astroContent, "utf-8");
@@ -14816,31 +15399,31 @@ export const GET: APIRoute = () => {
   });
 };
 `;
-  await writeFile2(join8(pagesOutDir, "robots.txt.ts"), robotsTsContent, "utf-8");
+  await writeFile2(join9(pagesOutDir, "robots.txt.ts"), robotsTsContent, "utf-8");
   let collectionCount = 0;
   if (templateSchemas.length > 0) {
-    const contentDir = join8(srcDir, "content");
+    const contentDir = join9(srcDir, "content");
     mkdirSync4(contentDir, { recursive: true });
     const collectionDefs = [];
     for (const schema of templateSchemas) {
-      const collectionDir = join8(contentDir, schema.id);
+      const collectionDir = join9(contentDir, schema.id);
       mkdirSync4(collectionDir, { recursive: true });
       const richTextFieldNames = Object.entries(schema.fields || {}).filter(([, fd]) => fd.type === "rich-text").map(([fn]) => fn);
-      const cmsItemsDir = join8(projectPaths.cms(), schema.id);
-      if (existsSync7(cmsItemsDir)) {
+      const cmsItemsDir = join9(projectPaths.cms(), schema.id);
+      if (existsSync10(cmsItemsDir)) {
         const isDevBuild = process.env.MENO_DEV_BUILD === "true";
         const itemFiles = readdirSync6(cmsItemsDir).filter(
           (f) => f.endsWith(".json") && (isDevBuild || !f.endsWith(`${CMS_DRAFT_SUFFIX}.json`))
         );
         for (const itemFile of itemFiles) {
           try {
-            const rawContent = await readFile(join8(cmsItemsDir, itemFile), "utf-8");
+            const rawContent = await readFile(join9(cmsItemsDir, itemFile), "utf-8");
             const item = JSON.parse(rawContent);
             const resolved = { ...item };
             for (const fieldName of richTextFieldNames) {
               resolved[fieldName] = serializeRichTextValue(resolved[fieldName]);
             }
-            await writeFile2(join8(collectionDir, itemFile), JSON.stringify(resolved, null, 2), "utf-8");
+            await writeFile2(join9(collectionDir, itemFile), JSON.stringify(resolved, null, 2), "utf-8");
           } catch (err) {
             console.warn(
               `    Warning: could not process CMS item ${itemFile}: ${err instanceof Error ? err.message : String(err)}`
@@ -14873,29 +15456,29 @@ ${collectionDefs.join(",\n")}
 
 export { collections };
 `;
-    await writeFile2(join8(srcDir, "content.config.ts"), configContent, "utf-8");
+    await writeFile2(join9(srcDir, "content.config.ts"), configContent, "utf-8");
   }
-  const imagesSrcDir = join8(projectPaths.project, "images");
-  if (existsSync7(imagesSrcDir)) {
-    copyDirectory(imagesSrcDir, join8(srcDir, "assets", "images"), shouldCopyImageForAstro);
-    copyDirectory(imagesSrcDir, join8(publicDir, "images"));
+  const imagesSrcDir = join9(projectPaths.project, "images");
+  if (existsSync10(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 = join8(projectPaths.project, dir);
-    if (existsSync7(srcAssetDir)) {
-      copyDirectory(srcAssetDir, join8(publicDir, dir));
+    const srcAssetDir = join9(projectPaths.project, dir);
+    if (existsSync10(srcAssetDir)) {
+      copyDirectory(srcAssetDir, join9(publicDir, dir));
     }
   }
-  const librariesDir = join8(projectPaths.project, "libraries");
-  if (existsSync7(librariesDir)) {
-    copyDirectory(librariesDir, join8(publicDir, "libraries"));
+  const librariesDir = join9(projectPaths.project, "libraries");
+  if (existsSync10(librariesDir)) {
+    copyDirectory(librariesDir, join9(publicDir, "libraries"));
   }
   for (const relPath of localLibsToCopy) {
-    const srcPath = join8(projectPaths.project, relPath);
-    const destPath = join8(publicDir, relPath);
+    const srcPath = join9(projectPaths.project, relPath);
+    const destPath = join9(publicDir, relPath);
     const destDir = destPath.substring(0, destPath.lastIndexOf("/"));
-    if (destDir && !existsSync7(destDir)) mkdirSync4(destDir, { recursive: true });
+    if (destDir && !existsSync10(destDir)) mkdirSync4(destDir, { recursive: true });
     copyFileSync(srcPath, destPath);
   }
   const packageJson = {
@@ -14918,7 +15501,7 @@ export { collections };
       tailwindcss: "^4.0.0"
     }
   };
-  await writeFile2(join8(outDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf-8");
+  await writeFile2(join9(outDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf-8");
   const localeCodes = i18nConfig.locales.map((l) => l.code);
   const i18nBlock = i18nConfig.locales.length > 1 ? `
   i18n: {
@@ -14938,11 +15521,11 @@ export default defineConfig({${siteUrl ? `
   },
 });
 `;
-  await writeFile2(join8(outDir, "astro.config.mjs"), astroConfig, "utf-8");
+  await writeFile2(join9(outDir, "astro.config.mjs"), astroConfig, "utf-8");
   const tsConfig = {
     extends: "astro/tsconfigs/strict"
   };
-  await writeFile2(join8(outDir, "tsconfig.json"), JSON.stringify(tsConfig, null, 2), "utf-8");
+  await writeFile2(join9(outDir, "tsconfig.json"), JSON.stringify(tsConfig, null, 2), "utf-8");
   const baseNetlifyToml = `# Generated by Meno's Astro build.
 [build]
   command = "npm run build"
@@ -14952,8 +15535,8 @@ export default defineConfig({${siteUrl ? `
   NODE_VERSION = "22"
 `;
   const netlifyToml = syncNetlifyLocale404Block(baseNetlifyToml, i18nConfig, pageFiles.includes("404.json"));
-  await writeFile2(join8(outDir, "netlify.toml"), netlifyToml, "utf-8");
-  await writeFile2(join8(outDir, "src", "env.d.ts"), '/// <reference path="../.astro/types.d.ts" />\n', "utf-8");
+  await writeFile2(join9(outDir, "netlify.toml"), netlifyToml, "utf-8");
+  await writeFile2(join9(outDir, "src", "env.d.ts"), '/// <reference path="../.astro/types.d.ts" />\n', "utf-8");
   const totalPages = allResults.length;
   return {
     pages: totalPages - cmsPageCount,
@@ -15017,6 +15600,7 @@ export {
   getModuleDir,
   getPackageRoot,
   getProjectRoot,
+  groupForSectionLabel,
   handleCollectionSchemaRoute,
   handleCollectionsRoute,
   handleCoreApiRoutes,
@@ -15025,11 +15609,15 @@ export {
   handleItemsRoute,
   handleRouteError,
   hashContent,
+  inferGroup,
   inspect,
   isBun3 as isBun,
+  isColorValue,
+  isThemeCssProject,
   jsonResponse,
   lineMapToObject,
   loadProjectConfig,
+  loadThemeModel,
   logError,
   logRequest,
   logResponseTime,
@@ -15039,19 +15627,25 @@ export {
   needsFormHandler,
   needsMenoFilter,
   packagePaths,
+  parseThemeCss,
   processCMSPropsTemplate,
   processCMSTemplate,
   projectPaths,
   readJsonFile,
   readTextFile,
+  regenerateThemeCss,
   renderPageSSR,
   resetFontConfig,
   resolvePackagePath,
   resolveProjectPath,
+  saveColors,
+  saveVariables,
+  serializeThemeCss,
   serveFile,
   setProjectRoot,
   spawnProcess,
   styleToString,
+  themeCssPath,
   validateJS,
   variableService,
   watchRecursive,