@marktiderman/genesis-sites 0.0.0-stage → 0.2.0

package/dist/chunk-IXMY4B56.js

@@ -0,0 +1,877 @@
+import { getSection, PostSlug, PostDoc, ReleaseSnapshot, validatePostSlug, MAX_IMPORT_POSTS, MAX_LIVE_POSTS, postSummary, redirectsAfterMove, PageDoc, SiteDoc } from './chunk-ZGWGQGT2.js';
+import { pagePathProblems, isReservedPath, DEFAULT_RESERVED_PATHS, validatePagePath } from './chunk-3VKTBE7S.js';
+import { genesisBrand, themeFromBrand } from '@marktiderman/genesis-design-system';
+
+// src/core/migrate.ts
+function migrateNode(node, lookup = getSection) {
+  const def = lookup(node.type);
+  const where = { sectionId: node.id, type: node.type };
+  if (!def) {
+    return {
+      node: null,
+      changed: false,
+      issues: [{ ...where, severity: "error", code: "unknown-section", message: `No section "${node.type}" is registered; section ${node.id} can't be shown.` }]
+    };
+  }
+  if (node.v > def.version) {
+    return {
+      node: null,
+      changed: false,
+      issues: [
+        {
+          ...where,
+          severity: "error",
+          code: "newer-version",
+          message: `Section ${node.id} was saved by a newer "${node.type}" (v${node.v}) than this code knows (v${def.version}).`
+        }
+      ]
+    };
+  }
+  let props = node.props;
+  for (let n = node.v + 1; n <= def.version; n++) {
+    const step = def.migrations?.[n];
+    try {
+      props = step ? step(structuredClone(props)) : props;
+    } catch (err) {
+      return {
+        node: null,
+        changed: false,
+        issues: [{ ...where, severity: "error", code: "migration-failed", message: `Migrating section ${node.id} to v${n} failed: ${err.message}` }]
+      };
+    }
+  }
+  const parsed = def.schema.safeParse(props);
+  if (!parsed.success) {
+    return {
+      node: null,
+      changed: false,
+      issues: [
+        {
+          ...where,
+          severity: "error",
+          code: "invalid-props",
+          message: `Section ${node.id} (${def.label}): ${parsed.error.issues.map((i) => `${i.path.join(".") || "props"}: ${i.message}`).join("; ")}`
+        }
+      ]
+    };
+  }
+  const issues = [];
+  let variant = node.variant ?? def.defaultVariant;
+  if (!def.variants.some((v) => v.id === variant)) {
+    issues.push({ ...where, severity: "warning", code: "unknown-variant", message: `Section ${node.id} asks for variant "${variant}", which "${node.type}" doesn't have; showing "${def.defaultVariant}".` });
+    variant = def.defaultVariant;
+  }
+  const next = { ...node, v: def.version, variant, props: parsed.data };
+  const changed = node.v !== def.version || variant !== node.variant || JSON.stringify(parsed.data) !== JSON.stringify(node.props);
+  return { node: next, changed, issues };
+}
+function migratePage(doc, lookup) {
+  const issues = [];
+  let changed = false;
+  const content = doc.content.map((node) => {
+    const m = migrateNode(node, lookup);
+    issues.push(...m.issues);
+    if (m.node && m.changed) changed = true;
+    return m.node ?? node;
+  });
+  return { doc: changed ? { ...doc, content } : doc, changed, issues };
+}
+function migrateSite(site, lookup) {
+  const issues = [];
+  let changed = false;
+  const run = (nodes) => nodes.map((node) => {
+    const m = migrateNode(node, lookup);
+    issues.push(...m.issues);
+    if (m.node && m.changed) changed = true;
+    return m.node ?? node;
+  });
+  const header = run(site.header);
+  const footer = run(site.footer);
+  return { site: changed ? { ...site, header, footer } : site, changed, issues };
+}
+var FONT_CHOICES = Object.freeze({
+  system: { label: "System", stack: 'ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif' },
+  inter: { label: "Inter", stack: "Inter, ui-sans-serif, system-ui, sans-serif", google: "Inter:wght@400;500;600;700" },
+  "dm-sans": { label: "DM Sans", stack: '"DM Sans", ui-sans-serif, system-ui, sans-serif', google: "DM+Sans:wght@400;500;700" },
+  "work-sans": { label: "Work Sans", stack: '"Work Sans", ui-sans-serif, system-ui, sans-serif', google: "Work+Sans:wght@400;500;700" },
+  montserrat: { label: "Montserrat", stack: "Montserrat, ui-sans-serif, system-ui, sans-serif", google: "Montserrat:wght@400;600;700" },
+  poppins: { label: "Poppins", stack: "Poppins, ui-sans-serif, system-ui, sans-serif", google: "Poppins:wght@400;600;700" },
+  "space-grotesk": { label: "Space Grotesk", stack: '"Space Grotesk", ui-sans-serif, system-ui, sans-serif', google: "Space+Grotesk:wght@400;500;700" },
+  "source-serif": { label: "Source Serif", stack: '"Source Serif 4", Georgia, serif', google: "Source+Serif+4:wght@400;600;700" },
+  merriweather: { label: "Merriweather", stack: "Merriweather, Georgia, serif", google: "Merriweather:wght@400;700" },
+  "playfair-display": { label: "Playfair Display", stack: '"Playfair Display", Georgia, serif', google: "Playfair+Display:wght@400;600;700" },
+  lora: { label: "Lora", stack: "Lora, Georgia, serif", google: "Lora:wght@400;600;700" }
+});
+var RADIUS = { none: "0rem", sm: "0.25rem", md: "0.5rem", lg: "0.75rem", full: "1.25rem" };
+var HEX = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+function parseHex(hex) {
+  if (!HEX.test(hex)) throw new Error(`"${hex}" is not a #rgb or #rrggbb colour.`);
+  const h = hex.length === 4 ? [...hex.slice(1)].map((c) => c + c).join("") : hex.slice(1);
+  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+}
+var toHex = (rgb) => `#${rgb.map((c) => Math.round(Math.max(0, Math.min(255, c))).toString(16).padStart(2, "0")).join("")}`;
+function luminance(hex) {
+  const [r, g, b] = parseHex(hex).map((c) => {
+    const s = c / 255;
+    return s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+  });
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function contrastRatio(a, b) {
+  const la = luminance(a);
+  const lb = luminance(b);
+  return (Math.max(la, lb) + 0.05) / (Math.min(la, lb) + 0.05);
+}
+function mix(hex, amount) {
+  const target = amount >= 0 ? 255 : 0;
+  const t = Math.abs(amount);
+  return toHex(parseHex(hex).map((c) => c + (target - c) * t));
+}
+function hexToHslTriplet(hex) {
+  const [r, g, b] = parseHex(hex).map((c) => c / 255);
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  let h = 0;
+  let s = 0;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    if (max === r) h = (g - b) / d + (g < b ? 6 : 0);
+    else if (max === g) h = (b - r) / d + 2;
+    else h = (r - g) / d + 4;
+    h *= 60;
+  }
+  const round = (n) => Math.round(n * 10) / 10;
+  return `${round(h)} ${round(s * 100)}% ${round(l * 100)}%`;
+}
+function readableOn(background, a, b) {
+  return contrastRatio(background, a) >= contrastRatio(background, b) ? a : b;
+}
+function isSiteBrand(brand) {
+  return typeof brand.colors === "object" && !("neutral" in brand);
+}
+function toCanonicalBrand(brand) {
+  if (!isSiteBrand(brand)) {
+    const { logo: _logo, displayName: _displayName, ...canonical } = brand;
+    return canonical;
+  }
+  const primary = brand.colors.primary.toLowerCase();
+  parseHex(primary);
+  const primaryDark = (brand.colors.primaryDark ?? mix(primary, 0.35)).toLowerCase();
+  parseHex(primaryDark);
+  const heading = FONT_CHOICES[brand.fonts?.heading ?? "inter"] ?? FONT_CHOICES.inter;
+  const body = FONT_CHOICES[brand.fonts?.body ?? "inter"] ?? FONT_CHOICES.inter;
+  return {
+    ...genesisBrand,
+    name: brand.name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "site",
+    accent: { DEFAULT: primary, light: primary, dark: primaryDark },
+    typography: {
+      fontFamily: { body: body.stack.split(/,\s*/), display: heading.stack.split(/,\s*/) }
+    }
+  };
+}
+function brandDisplayName(brand) {
+  return isSiteBrand(brand) ? brand.name : brand.displayName ?? brand.name;
+}
+function modeColours(brand, mode) {
+  const n = brand.neutral;
+  const light = mode === "light";
+  const background = (light ? brand.surface.light : brand.surface.dark) ?? brand.surface.DEFAULT;
+  const foreground = (light ? brand.text.light : brand.text.dark) ?? brand.text.DEFAULT;
+  const primary = (light ? brand.accent.light : brand.accent.dark) ?? brand.accent.DEFAULT;
+  const muted = light ? n["100"] ?? mix(background, -0.04) : n["800"] ?? mix(background, 0.08);
+  const mutedForeground = light ? n["600"] ?? mix(foreground, 0.3) : n["400"] ?? mix(foreground, -0.3);
+  const border = light ? n["200"] ?? mix(background, -0.1) : n["700"] ?? mix(background, 0.15);
+  let primaryForeground = readableOn(primary, "#ffffff", n["900"] ?? "#09090b");
+  if (contrastRatio(primary, primaryForeground) < 4.5) primaryForeground = readableOn(primary, "#ffffff", "#000000");
+  const ring = contrastRatio(primary, background) >= 3 ? primary : foreground;
+  return { background, foreground, muted, mutedForeground, primary, primaryForeground, ring, border };
+}
+function roleVars(c) {
+  const hsl = hexToHslTriplet;
+  return {
+    "--background": hsl(c.background),
+    "--foreground": hsl(c.foreground),
+    "--card": hsl(c.background),
+    "--card-foreground": hsl(c.foreground),
+    "--popover": hsl(c.background),
+    "--popover-foreground": hsl(c.foreground),
+    "--primary": hsl(c.primary),
+    "--primary-foreground": hsl(c.primaryForeground),
+    "--secondary": hsl(c.muted),
+    "--secondary-foreground": hsl(c.foreground),
+    "--muted": hsl(c.muted),
+    "--muted-foreground": hsl(c.mutedForeground),
+    "--accent": hsl(c.muted),
+    "--accent-foreground": hsl(c.foreground),
+    "--border": hsl(c.border),
+    "--input": hsl(c.border),
+    "--ring": hsl(c.ring)
+  };
+}
+function pairsFor(c, mode) {
+  return [
+    { name: "body text on the page", mode, foreground: c.foreground, background: c.background, minimum: 4.5 },
+    { name: "quiet text on the page", mode, foreground: c.mutedForeground, background: c.background, minimum: 4.5 },
+    { name: "quiet text on a muted band", mode, foreground: c.mutedForeground, background: c.muted, minimum: 4.5 },
+    { name: "body text on a muted band", mode, foreground: c.foreground, background: c.muted, minimum: 4.5 },
+    { name: "button and accent-band text on the primary colour", mode, foreground: c.primaryForeground, background: c.primary, minimum: 4.5 },
+    { name: "text on an inverse band", mode, foreground: c.background, background: c.foreground, minimum: 4.5 },
+    { name: "the focus ring on the page", mode, foreground: c.ring, background: c.background, minimum: 3 },
+    // Non-text (1.4.11): the primary colour as a border or marker (a timetable chip, the picked day, a timeline's step).
+    // Every such mark also has text or a shape (a chip names its type, a marker shows a dot), so it warns.
+    { name: "the primary colour as a border or marker on the page", mode, foreground: c.primary, background: c.background, minimum: 3, severity: "warning" }
+  ];
+}
+function stableHash(value) {
+  const text = JSON.stringify(value, (_k, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort(([a], [b]) => a < b ? -1 : 1)) : v);
+  let h1 = 2166136261;
+  let h2 = 16777619 ^ text.length;
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 16777619) >>> 0;
+    h2 = Math.imul(h2 ^ c, 1540483477) >>> 0;
+  }
+  return h1.toString(16).padStart(8, "0") + h2.toString(16).padStart(8, "0");
+}
+function siteTheme(brand, theme = {}) {
+  const canonical = toCanonicalBrand(brand);
+  const overrides = theme.overrides ?? {};
+  const base = themeFromBrand(canonical).variables;
+  const fontStack = (family) => canonical.typography?.fontFamily?.[family]?.join(", ");
+  const headingFont = overrides.headingFont ? FONT_CHOICES[overrides.headingFont] : void 0;
+  const bodyFont = overrides.bodyFont ? FONT_CHOICES[overrides.bodyFont] : void 0;
+  const fontVars = {};
+  const sans = bodyFont?.stack ?? fontStack("body");
+  const display = headingFont?.stack ?? fontStack("display") ?? sans;
+  if (sans) fontVars["--font-sans"] = sans;
+  if (display) fontVars["--font-display"] = display;
+  if (overrides.radius) fontVars["--radius"] = RADIUS[overrides.radius];
+  const light = modeColours(canonical, "light");
+  const dark = modeColours(canonical, "dark");
+  const usedFonts = /* @__PURE__ */ new Map();
+  for (const stack of [sans, display]) {
+    const info = Object.values(FONT_CHOICES).find((f) => f.stack === stack);
+    if (info) usedFonts.set(info.label, info);
+  }
+  const colorScheme = theme.colorScheme ?? "light";
+  const pairs = colorScheme === "light" ? pairsFor(light, "light") : colorScheme === "dark" ? pairsFor(dark, "dark") : [...pairsFor(light, "light"), ...pairsFor(dark, "dark")];
+  return {
+    light: { ...base.light, ...roleVars(light), ...fontVars },
+    dark: { ...base.dark, ...roleVars(dark), ...fontVars },
+    colorScheme,
+    fonts: [...usedFonts.values()],
+    pairs,
+    brandHash: stableHash({ brand: canonical, overrides, colorScheme })
+  };
+}
+function cssValue(value) {
+  return value.replace(/[<>{};\\]/g, "");
+}
+function block(selector, vars) {
+  const lines = Object.entries(vars).filter(([name]) => /^--[a-z0-9-]+$/i.test(name)).map(([name, value]) => `${name}:${cssValue(value)}`);
+  return `${selector}{${lines.join(";")}}`;
+}
+function themeCss(theme) {
+  if (theme.colorScheme === "dark") return block(":root", theme.dark) + ":root{color-scheme:dark}";
+  if (theme.colorScheme === "auto") {
+    return `${block(":root", theme.light)}:root{color-scheme:light dark}@media (prefers-color-scheme: dark){${block(":root", theme.dark)}}`;
+  }
+  return block(":root", theme.light) + ":root{color-scheme:light}";
+}
+
+// src/core/a11y.ts
+var isPublishable = (issues) => !issues.some((i) => i.severity === "error");
+function images(value, path = []) {
+  if (!value || typeof value !== "object") return [];
+  if (Array.isArray(value)) return value.flatMap((v, i) => images(v, [...path, String(i)]));
+  const record = value;
+  const found = typeof record.src === "string" && !("mime" in record) && ("alt" in record || "decorative" in record || /\.(png|jpe?g|webp|avif|gif|svg)(\?|$)/i.test(record.src)) ? [{ path: path.join("."), image: record }] : [];
+  return [...found, ...Object.entries(record).flatMap(([k, v]) => k === "src" ? [] : images(v, [...path, k]))];
+}
+function richTextHeadings(value) {
+  if (!value || typeof value !== "object") return [];
+  if (Array.isArray(value)) return value.flatMap(richTextHeadings);
+  const node = value;
+  if (node.type === "heading") return typeof node.attrs?.level === "number" ? [node.attrs.level] : [];
+  if (node.type === "doc" || typeof node.type === "string") return richTextHeadings(node.content);
+  return Object.values(value).flatMap(richTextHeadings);
+}
+function nodeIssues(node, ctx, lookup) {
+  const base = { ...ctx.page ? { pageId: ctx.page.id, path: ctx.page.path } : {}, sectionId: node.id };
+  const at = ctx.page ? `${ctx.page.path}` : `the site ${ctx.where}`;
+  const migrated = migrateNode(node, lookup);
+  const issues = migrated.issues.map((i) => ({ ...base, severity: i.severity, code: i.code, message: `${at}: ${i.message}` }));
+  const def = lookup(node.type);
+  if (!def || !migrated.node) return issues;
+  if (node.placeholder) {
+    issues.push({ ...base, severity: "error", code: "placeholder", message: `${at}: the ${def.label} section still has the template's sample content. Replace it, or hide the section.` });
+  }
+  const placement = def.placement ?? "body";
+  if (placement !== ctx.where) {
+    issues.push({ ...base, severity: "error", code: "placement", message: `${at}: a ${def.label} section belongs in the ${placement === "body" ? "page" : `site ${placement}`}, not the ${ctx.where === "body" ? "page" : `site ${ctx.where}`}.` });
+  }
+  if (ctx.kind && def.enabledOn && !def.enabledOn.includes(ctx.kind)) {
+    issues.push({ ...base, severity: "error", code: "enabled-on", message: `${at}: a ${def.label} section can't go on a ${ctx.kind} page.` });
+  }
+  for (const { path, image } of images(migrated.node.props)) {
+    const alt = typeof image.alt === "string" ? image.alt.trim() : "";
+    if (!alt && image.decorative !== true) {
+      issues.push({ ...base, severity: "error", code: "image-alt", message: `${at}: an image in the ${def.label} section (${path || "image"}) needs alt text, or to be marked decorative.` });
+    }
+  }
+  const levels = richTextHeadings(migrated.node.props);
+  for (let i = 0; i < levels.length; i++) {
+    const level = levels[i];
+    const previous = i === 0 ? 2 : levels[i - 1];
+    if (level === 1) issues.push({ ...base, severity: "error", code: "heading-h1", message: `${at}: rich text can't hold a level 1 heading; the page has one already.` });
+    else if (level > previous + 1) {
+      issues.push({ ...base, severity: "error", code: "heading-order", message: `${at}: a level ${level} heading follows a level ${previous} in the ${def.label} section; don't skip a level.` });
+    }
+  }
+  return issues;
+}
+function checkPage(page, lookup = getSection, reserved) {
+  const issues = [];
+  const base = { pageId: page.id, path: page.path };
+  for (const problem of pagePathProblems(page.path, reserved)) issues.push({ ...base, severity: "error", code: "path", message: `${page.path}: ${problem}` });
+  const visible = page.doc.content.filter((n) => !n.hidden);
+  const counts = /* @__PURE__ */ new Map();
+  let h1 = 0;
+  for (const node of visible) {
+    issues.push(...nodeIssues(node, { where: "body", kind: page.kind, page }, lookup));
+    counts.set(node.type, (counts.get(node.type) ?? 0) + 1);
+    if (lookup(node.type)?.providesH1) h1++;
+  }
+  for (const [type, count] of counts) {
+    const def = lookup(type);
+    if (def?.limit && count > def.limit) {
+      issues.push({ ...base, severity: "error", code: "limit", message: `${page.path}: ${count} ${def.label} sections; a page has at most ${def.limit}.` });
+    }
+  }
+  if (h1 === 0) {
+    issues.push({ ...base, severity: "warning", code: "no-h1", message: `${page.path}: no hero, so the page title "${page.doc.root.props.title}" becomes its hidden main heading.` });
+  }
+  if (!page.doc.seo?.description) {
+    issues.push({ ...base, severity: "warning", code: "seo-description", message: `${page.path}: no description for search results and link previews.` });
+  }
+  return issues;
+}
+function checkSiteDoc(site, lookup = getSection) {
+  const issues = [];
+  for (const node of site.header.filter((n) => !n.hidden)) issues.push(...nodeIssues(node, { where: "header" }, lookup));
+  for (const node of site.footer.filter((n) => !n.hidden)) issues.push(...nodeIssues(node, { where: "footer" }, lookup));
+  const froms = /* @__PURE__ */ new Set();
+  for (const r of site.redirects) {
+    if (froms.has(r.from)) issues.push({ severity: "error", code: "redirect-duplicate", path: r.from, message: `Two redirects from ${r.from}.` });
+    froms.add(r.from);
+    if (r.to === r.from) issues.push({ severity: "error", code: "redirect-loop", path: r.from, message: `The redirect from ${r.from} points at itself.` });
+  }
+  return issues;
+}
+function checkContrast(theme) {
+  return theme.pairs.map((pair) => ({ pair, ratio: contrastRatio(pair.foreground, pair.background) })).filter(({ pair, ratio }) => ratio < pair.minimum).map(({ pair, ratio }) => ({
+    severity: pair.severity ?? "error",
+    code: "contrast",
+    message: `In ${pair.mode} mode, ${pair.name} is ${ratio.toFixed(2)}:1 (${pair.foreground} on ${pair.background}); it needs ${pair.minimum}:1. Adjust the brand colours.`
+  }));
+}
+function checkRelease(snapshot, options = {}) {
+  const lookup = options.lookup ?? getSection;
+  const issues = [...checkSiteDoc(snapshot.site, lookup)];
+  const paths = /* @__PURE__ */ new Map();
+  for (const page of snapshot.pages) {
+    const other = paths.get(page.path);
+    if (other) issues.push({ severity: "error", code: "path-duplicate", pageId: page.id, path: page.path, message: `Two pages at ${page.path}.` });
+    paths.set(page.path, page.id);
+    issues.push(...checkPage(page, lookup, options.reserved));
+  }
+  if (!paths.has("/")) issues.push({ severity: "error", code: "no-home", message: "The site has no home page (a page at /)." });
+  issues.push(...checkBlog(snapshot, lookup));
+  for (const r of snapshot.site.redirects) {
+    if (paths.has(r.from)) issues.push({ severity: "error", code: "redirect-shadows-page", path: r.from, message: `The redirect from ${r.from} hides the page there; remove the redirect.` });
+    const target = r.to.split(/[?#]/)[0];
+    if (r.to.startsWith("/") && !paths.has(target)) {
+      issues.push({ severity: "warning", code: "redirect-to-missing-page", path: r.from, message: `The redirect from ${r.from} goes to ${target}, where there's no page (was it deleted?).` });
+    }
+    if (options.reserved !== void 0 ? isReservedPath(r.from, options.reserved) : isReservedPath(r.from)) {
+      issues.push({ severity: "error", code: "redirect-reserved", path: r.from, message: `${r.from} is reserved for the app; a site can't redirect it.` });
+    }
+  }
+  if (options.theme) issues.push(...checkContrast(options.theme));
+  return issues;
+}
+function checkBlog(snapshot, lookup = getSection) {
+  const issues = [];
+  const postPages = snapshot.pages.filter((p) => p.kind === "post");
+  if (postPages.length > 1) {
+    issues.push({ severity: "error", code: "post-page-count", message: `The site has ${postPages.length} post pages (${postPages.map((p) => p.path).join(", ")}); posts render in one.` });
+  }
+  for (const page of postPages) {
+    const base = { pageId: page.id, path: page.path };
+    if (page.path === "/") issues.push({ ...base, severity: "error", code: "post-page-home", message: "The home page can't be the post page: posts would take over the site's paths. Put it at /blog." });
+    if (page.path.split("/").filter(Boolean).length >= 8) issues.push({ ...base, severity: "error", code: "post-page-depth", message: `${page.path}: the post page is too deep for posts to go below it.` });
+    if (!page.doc.content.some((n) => !n.hidden && n.type === "post-body")) {
+      issues.push({ ...base, severity: "error", code: "post-page-body", message: `${page.path}: the post page needs a Post section, where each post's title and text go.` });
+    }
+  }
+  if (!postPages.length) {
+    for (const page of snapshot.pages) {
+      for (const node of page.doc.content) {
+        if (!node.hidden && node.type === "blog-list" && lookup(node.type)) {
+          issues.push({ pageId: page.id, path: page.path, sectionId: node.id, severity: "error", code: "blog-list-no-post-page", message: `${page.path}: a post list needs the site's post page (a page of kind "post", such as /blog) for its links to open.` });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function checkPost(slug, doc) {
+  const issues = [];
+  const at = `The post ${JSON.stringify(slug)}`;
+  if (!PostSlug.safeParse(slug).success) issues.push({ severity: "error", code: "post-slug", message: `${at}: a slug is lowercase letters, digits and single hyphens.` });
+  const parsed = PostDoc.safeParse(doc);
+  if (!parsed.success) {
+    issues.push({ severity: "error", code: "post-invalid", message: `${at}: ${parsed.error.issues.map((i) => `${i.path.join(".") || "post"} ${i.message}`).join("; ")}` });
+    return issues;
+  }
+  for (const { path, image } of images(parsed.data)) {
+    if (path.startsWith("seo")) continue;
+    const alt = typeof image.alt === "string" ? image.alt.trim() : "";
+    if (!alt && image.decorative !== true) issues.push({ severity: "error", code: "image-alt", message: `${at}: an image (${path || "image"}) needs alt text, or to be marked decorative.` });
+  }
+  const levels = richTextHeadings(parsed.data.body);
+  for (let i = 0; i < levels.length; i++) {
+    const level = levels[i];
+    const previous = i === 0 ? 1 : levels[i - 1];
+    if (level === 1) issues.push({ severity: "error", code: "heading-h1", message: `${at}: the text can't hold a level 1 heading; the post's title is the page's.` });
+    else if (level > previous + 1) issues.push({ severity: "error", code: "heading-order", message: `${at}: a level ${level} heading follows a level ${previous}; don't skip a level.` });
+  }
+  if (!parsed.data.excerpt && !parsed.data.seo?.description) issues.push({ severity: "warning", code: "seo-description", message: `${at}: no excerpt for the list, search results and the feed.` });
+  return issues;
+}
+function checkHtmlOutline(html) {
+  const issues = [];
+  const body = html.replace(/<script\b[\s\S]*?<\/script>/gi, "").replace(/<style\b[\s\S]*?<\/style>/gi, "");
+  const levels = [...body.matchAll(/<h([1-6])\b/gi)].map((m) => Number(m[1]));
+  const h1 = levels.filter((l) => l === 1).length;
+  if (h1 !== 1) issues.push({ severity: "error", code: "h1-count", message: `The page has ${h1} h1 elements; it needs exactly one.` });
+  if (levels[0] !== void 0 && levels[0] !== 1) issues.push({ severity: "error", code: "heading-order", message: `The first heading is an h${levels[0]}, not the h1.` });
+  for (let i = 1; i < levels.length; i++) {
+    if (levels[i] > levels[i - 1] + 1) issues.push({ severity: "error", code: "heading-order", message: `An h${levels[i]} follows an h${levels[i - 1]}.` });
+  }
+  for (const m of body.matchAll(/<img\b[^>]*>/gi)) {
+    if (!/\salt=/.test(m[0])) issues.push({ severity: "error", code: "image-alt", message: `An image has no alt attribute: ${m[0].slice(0, 120)}` });
+  }
+  return issues;
+}
+
+// src/core/store.ts
+var isConflict = (result) => "conflict" in result;
+var ASSET_TYPES = Object.freeze(["image/png", "image/jpeg", "image/webp", "image/avif", "image/gif", "application/pdf"]);
+function assetPath(siteId, id, name, mime) {
+  const clean = (name ?? "file").toLowerCase().replace(/[^a-z0-9.]+/g, "-").replace(/\.{2,}/g, ".").replace(/^[.-]+/, "").slice(0, 80) || "file";
+  return `sites/${siteId}/${mime === "application/pdf" ? "files/" : ""}${id}-${clean}`;
+}
+var PublishBlockedError = class extends Error {
+  constructor(issues) {
+    const errors = issues.filter((i) => i.severity === "error");
+    super(`The site can't be published yet:
+${errors.map((i) => `  - ${i.message}`).join("\n")}`);
+    this.issues = issues;
+    this.name = "PublishBlockedError";
+  }
+  issues;
+};
+var SiteConflictError = class extends Error {
+  constructor(message = "Someone else changed this site; reload it and try again.") {
+    super(message);
+    this.name = "SiteConflictError";
+  }
+};
+function prepareRelease(site, pages, options = {}) {
+  const migratedSite = migrateSite(site);
+  const migratedPages = [];
+  const releasePages = pages.map((p) => {
+    const m = migratePage(p.doc);
+    if (m.changed) migratedPages.push({ id: p.id, doc: m.doc });
+    return { id: p.id, path: p.path, kind: p.kind, doc: m.doc };
+  });
+  const visible = (nodes) => nodes.filter((n) => !n.hidden);
+  const snapshot = ReleaseSnapshot.parse({
+    schemaVersion: 1,
+    site: { ...migratedSite.site, header: visible(migratedSite.site.header), footer: visible(migratedSite.site.footer) },
+    pages: releasePages.map((p) => ({ ...p, doc: { ...p.doc, content: visible(p.doc.content) } }))
+  });
+  const theme = options.brand ? siteTheme(options.brand, snapshot.site.theme) : void 0;
+  const issues = checkRelease(snapshot, { ...theme ? { theme } : {}, reserved: options.reserved ?? DEFAULT_RESERVED_PATHS });
+  if (!theme) issues.push({ severity: "error", code: "brand-missing", message: "Publish with the site's brand (`brand`), so its colours can be checked for contrast." });
+  if (!isPublishable(issues)) throw new PublishBlockedError(issues);
+  return { snapshot, issues, migratedPages, migratedSite: migratedSite.changed ? migratedSite.site : null, brandHash: theme?.brandHash ?? null };
+}
+function siteCacheTag(siteId) {
+  return `site:${siteId}`;
+}
+function formCacheTag(slug) {
+  return `form:${slug}`;
+}
+function withCacheInvalidation(store, invalidate) {
+  const purge = async (siteId, action) => {
+    try {
+      await invalidate([siteCacheTag(siteId)], { siteId, action });
+    } catch (err) {
+      console.error(`[genesis-sites] published site ${siteId}, but purging its cache failed; the old pages may be served until their cache expires.`, err);
+      throw err;
+    }
+  };
+  return {
+    ...store,
+    getLive: (id) => store.getLive(id),
+    getDraft: (id) => store.getDraft(id),
+    saveSiteDraft: (id, rev, site) => store.saveSiteDraft(id, rev, site),
+    listPages: (id) => store.listPages(id),
+    getPageDraft: (id) => store.getPageDraft(id),
+    savePageDraft: (id, rev, doc) => store.savePageDraft(id, rev, doc),
+    createPage: (id, page) => store.createPage(id, page),
+    movePage: (id, path) => store.movePage(id, path),
+    deletePage: (id) => store.deletePage(id),
+    listReleases: (id) => store.listReleases(id),
+    ...store.putAsset ? { putAsset: store.putAsset.bind(store) } : {},
+    ...store.listLivePosts ? { listLivePosts: store.listLivePosts.bind(store) } : {},
+    ...store.getLivePost ? { getLivePost: store.getLivePost.bind(store) } : {},
+    ...store.listPosts ? { listPosts: store.listPosts.bind(store) } : {},
+    ...store.getPost ? { getPost: store.getPost.bind(store) } : {},
+    ...store.savePost ? { savePost: store.savePost.bind(store) } : {},
+    ...store.publishPost ? {
+      async publishPost(postId) {
+        const meta = await store.publishPost(postId);
+        await purge(meta.siteId, "post");
+        return meta;
+      }
+    } : {},
+    ...store.unpublishPost ? {
+      async unpublishPost(postId) {
+        const meta = await store.unpublishPost(postId);
+        await purge(meta.siteId, "post");
+        return meta;
+      }
+    } : {},
+    ...store.deletePost ? {
+      async deletePost(postId) {
+        const deleted = await store.deletePost(postId);
+        if (deleted) await purge(deleted.siteId, "post");
+        return deleted;
+      }
+    } : {},
+    ...store.importPosts ? {
+      async importPosts(siteId, list) {
+        const result = await store.importPosts(siteId, list);
+        await purge(siteId, "post");
+        return result;
+      }
+    } : {},
+    async publish(siteId, options) {
+      const release = await store.publish(siteId, options);
+      await purge(siteId, "publish");
+      return release;
+    },
+    async rollback(siteId, releaseId) {
+      const release = await store.rollback(siteId, releaseId);
+      await purge(siteId, "rollback");
+      return release;
+    }
+  };
+}
+function prepareImportPost(item) {
+  const slug = typeof item?.slug === "string" ? item.slug : String(item?.slug);
+  try {
+    validatePostSlug(slug);
+  } catch (err) {
+    return { slug, reason: err.message };
+  }
+  const parsed = PostDoc.safeParse(item.doc);
+  if (!parsed.success) return { slug, reason: `The post doesn't parse: ${parsed.error.issues.map((i) => `${i.path.join(".") || "post"} ${i.message}`).join("; ")}` };
+  const now = Date.now();
+  const given = item.publishedAt ? new Date(item.publishedAt) : new Date(now);
+  if (Number.isNaN(given.getTime()) || given.getTime() < 0) return { slug, reason: `"${item.publishedAt}" isn't a usable publish date.` };
+  const date = new Date(Math.min(given.getTime(), now));
+  const errors = checkPost(slug, parsed.data).filter((i) => i.severity === "error").map((i) => i.message);
+  const status = item.status === "draft" || errors.length ? "draft" : "published";
+  return { doc: parsed.data, status, publishedAt: date.toISOString(), issues: errors };
+}
+var clone = (value) => structuredClone(value);
+function createMemorySiteStore(options = {}) {
+  const reserved = options.reserved ?? DEFAULT_RESERVED_PATHS;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const sites = /* @__PURE__ */ new Map();
+  const pages = /* @__PURE__ */ new Map();
+  const releases = /* @__PURE__ */ new Map();
+  const posts = /* @__PURE__ */ new Map();
+  let seq = 0;
+  const id = (prefix) => `${prefix}_${(++seq).toString(36).padStart(4, "0")}`;
+  const editable = (siteId) => {
+    const s = sites.get(siteId);
+    if (!s) throw new Error(`No site ${siteId}.`);
+    if (options.canEdit && !options.canEdit(siteId)) throw new Error(`Not allowed to edit site ${siteId}.`);
+    return s;
+  };
+  const livePages = (siteId) => [...pages.values()].filter((p) => p.siteId === siteId && !p.deleted).sort((a, b) => a.sort - b.sort || a.path.localeCompare(b.path));
+  const meta = (p) => ({ id: p.id, siteId: p.siteId, path: p.path, kind: p.kind, title: p.doc.root.props.title, sort: p.sort, rev: p.rev });
+  const releaseMeta = ({ snapshot: _s, ...m }) => clone(m);
+  const pathTaken = (siteId, path, except) => livePages(siteId).some((p) => p.path === path && p.id !== except);
+  const sitePosts = (siteId) => [...posts.values()].filter((p) => p.siteId === siteId && !p.deleted);
+  const postMeta = (p) => ({ id: p.id, siteId: p.siteId, slug: p.slug, title: p.doc.title, status: p.status, rev: p.rev, publishedAt: p.publishedAt, updatedAt: p.updatedAt });
+  const byNewest = (a, b) => (b.publishedAt ?? b.updatedAt).localeCompare(a.publishedAt ?? a.updatedAt);
+  const livePost = (p) => p.status === "published" && p.published && p.publishedAt ? { slug: p.slug, publishedAt: p.publishedAt, updatedAt: p.published.at, doc: clone(p.published.doc) } : null;
+  const siteIsLive = (siteId) => {
+    const s = sites.get(siteId);
+    return Boolean(s && s.status === "live" && s.liveReleaseId);
+  };
+  const editablePost = (postId) => {
+    const p = posts.get(postId);
+    if (!p || p.deleted) throw new Error(`No post ${postId}.`);
+    editable(p.siteId);
+    return p;
+  };
+  const store = {
+    async createSite(input) {
+      const siteId = input.id ?? id("site");
+      if (sites.has(siteId)) throw new Error(`Site ${siteId} exists.`);
+      const site = SiteDoc.parse(input.site);
+      sites.set(siteId, { id: siteId, site, rev: 1, liveReleaseId: null, status: "draft" });
+      const pageIds = [];
+      input.pages.forEach((p, i) => {
+        validatePagePath(p.path, reserved);
+        if (pathTaken(siteId, p.path)) throw new Error(`Two pages at ${p.path}.`);
+        const pageId = p.id ?? id("page");
+        pages.set(pageId, { id: pageId, siteId, path: p.path, kind: p.kind ?? "page", doc: PageDoc.parse(clone(p.doc)), rev: 1, sort: i, deleted: false });
+        pageIds.push(pageId);
+      });
+      return { siteId, pageIds };
+    },
+    async setStatus(siteId, status) {
+      editable(siteId).status = status;
+    },
+    async getLive(siteId) {
+      const s = sites.get(siteId);
+      if (!s || s.status !== "live" || !s.liveReleaseId) return null;
+      const r = releases.get(s.liveReleaseId);
+      return r ? clone(r) : null;
+    },
+    async getDraft(siteId) {
+      const s = sites.get(siteId);
+      if (!s || options.canEdit && !options.canEdit(siteId)) return null;
+      return { site: clone(s.site), rev: s.rev };
+    },
+    async saveSiteDraft(siteId, rev, doc) {
+      const s = editable(siteId);
+      if (s.rev !== rev) return { conflict: clone(s.site), rev: s.rev };
+      s.site = SiteDoc.parse(clone(doc));
+      s.rev += 1;
+      return { rev: s.rev };
+    },
+    async listPages(siteId) {
+      if (options.canEdit && !options.canEdit(siteId)) return [];
+      return livePages(siteId).map(meta);
+    },
+    async getPageDraft(pageId) {
+      const p = pages.get(pageId);
+      if (!p || p.deleted || options.canEdit && !options.canEdit(p.siteId)) return null;
+      return { doc: clone(p.doc), rev: p.rev, siteId: p.siteId, path: p.path, kind: p.kind };
+    },
+    async savePageDraft(pageId, rev, doc) {
+      const p = pages.get(pageId);
+      if (!p || p.deleted) throw new Error(`No page ${pageId}.`);
+      editable(p.siteId);
+      if (p.rev !== rev) return { conflict: clone(p.doc), rev: p.rev };
+      p.doc = PageDoc.parse(clone(doc));
+      p.rev += 1;
+      return { rev: p.rev };
+    },
+    async createPage(siteId, page) {
+      const s = editable(siteId);
+      validatePagePath(page.path, reserved);
+      if (pathTaken(siteId, page.path)) throw new Error(`A page is already at ${page.path}.`);
+      const pageId = id("page");
+      const sort = Math.max(-1, ...livePages(siteId).map((p2) => p2.sort)) + 1;
+      const p = { id: pageId, siteId, path: page.path, kind: page.kind ?? "page", doc: PageDoc.parse(clone(page.doc)), rev: 1, sort, deleted: false };
+      pages.set(pageId, p);
+      if (s.site.redirects.some((r) => r.from === page.path)) {
+        s.site = { ...s.site, redirects: s.site.redirects.filter((r) => r.from !== page.path) };
+        s.rev += 1;
+      }
+      return meta(p);
+    },
+    async movePage(pageId, path) {
+      const p = pages.get(pageId);
+      if (!p || p.deleted) throw new Error(`No page ${pageId}.`);
+      const s = editable(p.siteId);
+      validatePagePath(path, reserved);
+      if (p.path === "/") throw new Error("The home page stays at /.");
+      if (pathTaken(p.siteId, path, pageId)) throw new Error(`A page is already at ${path}.`);
+      const from = p.path;
+      p.path = path;
+      p.rev += 1;
+      s.site = { ...s.site, redirects: redirectsAfterMove(s.site.redirects, from, path) };
+      s.rev += 1;
+      return meta(p);
+    },
+    async deletePage(pageId) {
+      const p = pages.get(pageId);
+      if (!p || p.deleted) return;
+      editable(p.siteId);
+      if (p.path === "/") throw new Error("The home page can't be deleted; replace its content instead.");
+      p.deleted = true;
+    },
+    async publish(siteId, opts = {}) {
+      const s = editable(siteId);
+      const list = livePages(siteId);
+      const prepared = prepareRelease(s.site, list, { reserved, ...opts });
+      for (const { id: pid, doc } of prepared.migratedPages) {
+        const p = pages.get(pid);
+        p.doc = doc;
+        p.rev += 1;
+      }
+      if (prepared.migratedSite) {
+        s.site = prepared.migratedSite;
+        s.rev += 1;
+      }
+      const number = Math.max(0, ...[...releases.values()].filter((r) => r.siteId === siteId).map((r) => r.number)) + 1;
+      const at = now().toISOString();
+      const release = {
+        id: id("rel"),
+        siteId,
+        number,
+        note: opts.note ?? null,
+        createdAt: at,
+        publishedAt: at,
+        brandHash: prepared.brandHash,
+        snapshot: Object.freeze(clone(prepared.snapshot))
+      };
+      releases.set(release.id, release);
+      s.liveReleaseId = release.id;
+      s.status = "live";
+      return clone(release);
+    },
+    async rollback(siteId, releaseId) {
+      const s = editable(siteId);
+      const r = releases.get(releaseId);
+      if (!r || r.siteId !== siteId) throw new Error(`Release ${releaseId} isn't one of site ${siteId}'s.`);
+      s.liveReleaseId = r.id;
+      s.status = "live";
+      return clone(r);
+    },
+    async listReleases(siteId) {
+      if (options.canEdit && !options.canEdit(siteId)) return [];
+      return [...releases.values()].filter((r) => r.siteId === siteId).sort((a, b) => b.number - a.number).map(releaseMeta);
+    },
+    async putAsset(siteId, file, assetMeta = {}) {
+      editable(siteId);
+      const mime = file.type || "application/octet-stream";
+      if (!ASSET_TYPES.includes(mime)) throw new Error(`${mime} isn't an image (PNG, JPEG, WebP, AVIF, GIF) or a PDF.`);
+      const assetId = id("asset");
+      const path = assetPath(siteId, assetId, assetMeta.name, mime);
+      return { id: assetId, siteId, path, url: `/${path}`, mime, alt: assetMeta.alt ?? null, width: assetMeta.width ?? null, height: assetMeta.height ?? null };
+    },
+    async listLivePosts(siteId) {
+      if (!siteIsLive(siteId)) return [];
+      return sitePosts(siteId).map(livePost).filter((p) => p !== null).sort(byNewest).slice(0, MAX_LIVE_POSTS).map(postSummary);
+    },
+    async getLivePost(siteId, slug) {
+      if (!siteIsLive(siteId)) return null;
+      const p = sitePosts(siteId).find((x) => x.slug === slug);
+      return p ? livePost(p) : null;
+    },
+    async listPosts(siteId) {
+      if (options.canEdit && !options.canEdit(siteId)) return [];
+      return sitePosts(siteId).map(postMeta).sort(byNewest);
+    },
+    async getPost(postId) {
+      const p = posts.get(postId);
+      if (!p || p.deleted || options.canEdit && !options.canEdit(p.siteId)) return null;
+      return { ...postMeta(p), doc: clone(p.doc) };
+    },
+    async savePost(siteId, input) {
+      editable(siteId);
+      validatePostSlug(input.slug);
+      const doc = PostDoc.parse(clone(input.doc));
+      const at = now().toISOString();
+      if (!input.id) {
+        if (sitePosts(siteId).some((p2) => p2.slug === input.slug)) throw new Error(`A post is already at ${input.slug}.`);
+        const postId = id("post");
+        posts.set(postId, { id: postId, siteId, slug: input.slug, doc, rev: 1, status: "draft", published: null, publishedAt: null, updatedAt: at, deleted: false });
+        return { id: postId, rev: 1 };
+      }
+      const p = editablePost(input.id);
+      if (p.siteId !== siteId) throw new Error(`Post ${input.id} isn't one of site ${siteId}'s.`);
+      if (p.rev !== input.rev) return { id: p.id, conflict: clone(p.doc), rev: p.rev };
+      if (input.slug !== p.slug) {
+        if (p.publishedAt) throw new Error("A post keeps its slug once it has been published: its address is out in the world.");
+        if (sitePosts(siteId).some((x) => x.slug === input.slug && x.id !== p.id)) throw new Error(`A post is already at ${input.slug}.`);
+        p.slug = input.slug;
+      }
+      p.doc = doc;
+      p.rev += 1;
+      p.updatedAt = at;
+      return { id: p.id, rev: p.rev };
+    },
+    async publishPost(postId) {
+      const p = editablePost(postId);
+      if (sites.get(p.siteId)?.status === "archived") throw new Error("An archived site can't publish posts.");
+      const issues = checkPost(p.slug, p.doc);
+      if (!isPublishable(issues)) throw new PublishBlockedError(issues);
+      const at = now().toISOString();
+      p.published = { doc: clone(p.doc), at };
+      p.status = "published";
+      p.publishedAt ??= at;
+      p.updatedAt = at;
+      return postMeta(p);
+    },
+    async unpublishPost(postId) {
+      const p = editablePost(postId);
+      p.status = "draft";
+      p.published = null;
+      p.updatedAt = now().toISOString();
+      return postMeta(p);
+    },
+    async deletePost(postId) {
+      const p = posts.get(postId);
+      if (!p || p.deleted) return null;
+      editable(p.siteId);
+      p.deleted = true;
+      p.status = "draft";
+      p.published = null;
+      return { siteId: p.siteId };
+    },
+    async importPosts(siteId, list) {
+      if (editable(siteId).status === "archived") throw new Error(`No site ${siteId} to import into: it is archived.`);
+      if (list.length > MAX_IMPORT_POSTS) throw new Error(`Import at most ${MAX_IMPORT_POSTS} posts at a time.`);
+      const result = { imported: [], skipped: [] };
+      const seen = new Set(sitePosts(siteId).map((p) => p.slug));
+      for (const item of list) {
+        const prepared = prepareImportPost(item);
+        if ("reason" in prepared) {
+          result.skipped.push(prepared);
+          continue;
+        }
+        if (seen.has(item.slug)) {
+          result.skipped.push({ slug: item.slug, reason: "The site already has a post at this slug." });
+          continue;
+        }
+        seen.add(item.slug);
+        const postId = id("post");
+        const at = now().toISOString();
+        const published = prepared.status === "published" ? { doc: clone(prepared.doc), at: prepared.publishedAt } : null;
+        posts.set(postId, { id: postId, siteId, slug: item.slug, doc: prepared.doc, rev: 1, status: prepared.status, published, publishedAt: published ? prepared.publishedAt : null, updatedAt: at, deleted: false });
+        result.imported.push({ slug: item.slug, id: postId, status: prepared.status, ...prepared.issues.length ? { issues: prepared.issues } : {} });
+      }
+      return result;
+    }
+  };
+  return store;
+}
+
+export { ASSET_TYPES, FONT_CHOICES, PublishBlockedError, SiteConflictError, assetPath, brandDisplayName, checkBlog, checkContrast, checkHtmlOutline, checkPage, checkPost, checkRelease, checkSiteDoc, contrastRatio, createMemorySiteStore, formCacheTag, hexToHslTriplet, isConflict, isPublishable, isSiteBrand, luminance, migrateNode, migratePage, migrateSite, mix, parseHex, prepareImportPost, prepareRelease, siteCacheTag, siteTheme, stableHash, themeCss, toCanonicalBrand, withCacheInvalidation };
+//# sourceMappingURL=chunk-IXMY4B56.js.map
+//# sourceMappingURL=chunk-IXMY4B56.js.map