@caelo-cms/shared 0.10.22 → 0.10.24

package/src/design-manifest.ts

@@ -0,0 +1,93 @@
+// SPDX-License-Identifier: MPL-2.0
+
+/**
+ * issue #165 — the Design Manifest: a generated, versioned description
+ * of THIS site's design system (epic #149, growth-time convergence).
+ *
+ * The operator requirement is asymmetric: pages of the SAME site share
+ * one visual line, while different sites are free to look nothing
+ * alike. A global stylesheet solves the first at the cost of the
+ * second; the per-site manifest solves both — it captures what this
+ * site's tokens/patterns MEAN so the AI converges toward its own
+ * design, not a Caelo default.
+ *
+ * Written at Genesis materialisation (or curated later via chat);
+ * rendered as the `## Design system` system-prompt block.
+ */
+
+import { z } from "zod";
+
+export const designManifestPattern = z
+  .object({
+    /** Pattern name the AI reasons in ("hero", "card grid", "cta band"). */
+    name: z.string().min(1).max(80),
+    /** Stable module `type` implementing it — reuse target (#159 place mode). */
+    moduleType: z.string().max(64).optional(),
+    /** One-line spec: what makes this pattern THIS site's version of it. */
+    spec: z.string().min(1).max(500),
+  })
+  .strict();
+
+export const designManifestSchema = z
+  .object({
+    /** `--color-primary` → "CTAs and links only" — usage semantics per var. */
+    tokenRoles: z.record(z.string().min(3).max(64), z.string().min(1).max(300)).optional(),
+    /** Scale ratio, casing, measure rules. */
+    typography: z.string().min(1).max(1000).optional(),
+    /** Section padding, container width, grid gaps. */
+    rhythm: z.string().min(1).max(1000).optional(),
+    patterns: z.array(designManifestPattern).max(24).optional(),
+    imagery: z.string().min(1).max(500).optional(),
+    avoid: z.string().min(1).max(500).optional(),
+  })
+  .strict();
+export type DesignManifest = z.infer<typeof designManifestSchema>;
+
+/** Render the `## Design system` prompt block. Null when empty. */
+export function formatDesignSystemBlock(manifest: DesignManifest | null): string | null {
+  if (manifest === null) return null;
+  const lines: string[] = [
+    "## Design system",
+    "",
+    "THIS site's own design language — derived from the chosen design. Every module you author or restyle conforms to it unless the operator explicitly asks to break the line. Reuse the pattern's module type (place mode) before minting lookalikes.",
+    "",
+  ];
+  let hasContent = false;
+  const roles = manifest.tokenRoles ?? {};
+  const roleEntries = Object.entries(roles);
+  if (roleEntries.length > 0) {
+    hasContent = true;
+    lines.push("Token roles:");
+    for (const [token, role] of roleEntries.slice(0, 24)) lines.push(`- \`${token}\` — ${role}`);
+    lines.push("");
+  }
+  if (manifest.typography) {
+    hasContent = true;
+    lines.push(`Typography: ${manifest.typography}`, "");
+  }
+  if (manifest.rhythm) {
+    hasContent = true;
+    lines.push(`Rhythm: ${manifest.rhythm}`, "");
+  }
+  if (manifest.patterns && manifest.patterns.length > 0) {
+    hasContent = true;
+    lines.push("Patterns:");
+    for (const p of manifest.patterns) {
+      lines.push(
+        `- **${p.name}**${p.moduleType ? ` (module type \`${p.moduleType}\`)` : ""} — ${p.spec}`,
+      );
+    }
+    lines.push("");
+  }
+  if (manifest.imagery) {
+    hasContent = true;
+    lines.push(`Imagery: ${manifest.imagery}`, "");
+  }
+  if (manifest.avoid) {
+    hasContent = true;
+    lines.push(`Never: ${manifest.avoid}`, "");
+  }
+  if (!hasContent) return null;
+  while (lines[lines.length - 1] === "") lines.pop();
+  return lines.join("\n");
+}

package/src/fonts.test.ts

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MPL-2.0
+
+/**
+ * issue #150 — unit coverage for the pure web-font helpers: request
+ * extraction from typography tokens, system-stack classification, css2
+ * payload parsing, self-hosted @font-face emission, preload selection.
+ */
+
+import { describe, expect, it } from "bun:test";
+import {
+  buildFontFaceCss,
+  extractThemeFontRequests,
+  fontUnresolvableMarker,
+  googleFontsCssUrl,
+  isSystemFontFamily,
+  parseFontsCss,
+  type ResolvedFontFace,
+  selectPreloadFaces,
+} from "./fonts.js";
+import type { ThemeDocument } from "./themes.js";
+
+const TOKENS = {
+  typography: {
+    body: { $type: "typography", $value: { fontFamily: '"Inter", sans-serif', fontWeight: 400 } },
+    heading: {
+      $type: "typography",
+      $value: { fontFamily: "Playfair Display, serif", fontWeight: 700 },
+    },
+    emphasis: { $type: "typography", $value: { fontFamily: "Inter", fontWeight: "bold" } },
+    mono: { $type: "typography", $value: { fontFamily: "ui-monospace, Menlo, monospace" } },
+    aliasing: { $type: "typography", $value: "{typography.body}" },
+  },
+} as unknown as ThemeDocument;
+
+describe("extractThemeFontRequests (issue #150)", () => {
+  it("collects web families with merged weights + roles, skips system stacks and aliases", () => {
+    const reqs = extractThemeFontRequests(TOKENS);
+    const byFamily = new Map(reqs.map((r) => [r.family, r]));
+    expect([...byFamily.keys()].sort()).toEqual(["Inter", "Playfair Display"]);
+    // 400 from body + bold→700 from emphasis, merged and sorted.
+    expect(byFamily.get("Inter")?.weights).toEqual([400, 700]);
+    expect(byFamily.get("Inter")?.roles.sort()).toEqual(["body", "emphasis"]);
+    expect(byFamily.get("Playfair Display")?.weights).toEqual([700]);
+  });
+
+  it("defaults weights when the theme declares none", () => {
+    const reqs = extractThemeFontRequests({
+      typography: { body: { $value: { fontFamily: "Poppins" } } },
+    } as unknown as ThemeDocument);
+    expect(reqs[0]?.weights).toEqual([400, 700]);
+  });
+
+  it("returns [] for token documents without typography", () => {
+    expect(extractThemeFontRequests({} as ThemeDocument)).toEqual([]);
+  });
+});
+
+describe("isSystemFontFamily", () => {
+  it("classifies generic keywords and OS staples as system", () => {
+    for (const f of ["system-ui", "sans-serif", "Georgia", "  Menlo ", "SEGOE UI"]) {
+      expect(isSystemFontFamily(f)).toBe(true);
+    }
+  });
+  it("classifies hosted-web staples as web fonts", () => {
+    for (const f of ["Inter", "Poppins", "Playfair Display", "Roboto"]) {
+      expect(isSystemFontFamily(f)).toBe(false);
+    }
+  });
+});
+
+describe("googleFontsCssUrl", () => {
+  it("encodes the family and joins weights", () => {
+    expect(
+      googleFontsCssUrl({ family: "Playfair Display", weights: [400, 700], roles: ["heading"] }),
+    ).toBe("https://fonts.googleapis.com/css2?family=Playfair+Display:wght@400;700&display=swap");
+  });
+});
+
+const CSS2_FIXTURE = `
+/* latin-ext */
+@font-face {
+  font-family: 'Poppins';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/poppins/v23/pxiEyp8kv8JHgFVrJJnecmNE.woff2) format('woff2');
+  unicode-range: U+0100-02BA;
+}
+/* latin */
+@font-face {
+  font-family: 'Poppins';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/poppins/v23/pxiByp8kv8JHgFVrLCz7Z1xlEA.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131;
+}
+@font-face {
+  font-family: 'Poppins';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/poppins/v23/pxiEyp8kv8JHgFVrJJfecg.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153;
+}
+`;
+
+describe("parseFontsCss", () => {
+  it("parses css2 @font-face blocks into face records", () => {
+    const faces = parseFontsCss(CSS2_FIXTURE);
+    expect(faces).toHaveLength(3);
+    expect(faces[0]).toEqual({
+      family: "Poppins",
+      style: "normal",
+      weight: "400",
+      unicodeRange: "U+0100-02BA",
+      srcUrl: "https://fonts.gstatic.com/s/poppins/v23/pxiEyp8kv8JHgFVrJJnecmNE.woff2",
+    });
+  });
+
+  it("returns [] on payloads without woff URLs — the caller's loud-failure signal", () => {
+    expect(parseFontsCss("body{color:red}")).toEqual([]);
+  });
+});
+
+describe("buildFontFaceCss + selectPreloadFaces", () => {
+  const faces: ResolvedFontFace[] = parseFontsCss(CSS2_FIXTURE).map((f, i) => ({
+    family: f.family,
+    style: f.style,
+    weight: f.weight,
+    unicodeRange: f.unicodeRange,
+    publicUrl: `/_assets/fonts/poppins/${i}.woff2`,
+  }));
+
+  it("emits self-hosted @font-face with font-display: swap", () => {
+    const css = buildFontFaceCss(faces);
+    expect(css).toContain('font-family:"Poppins"');
+    expect(css).toContain("font-display:swap");
+    expect(css).toContain("url(/_assets/fonts/poppins/0.woff2) format('woff2')");
+    expect(css).toContain("unicode-range:U+0100-02BA;");
+    expect(css).not.toContain("fonts.gstatic.com");
+  });
+
+  it("preloads one latin normal-style face per family at the lowest weight", () => {
+    const picks = selectPreloadFaces(faces);
+    // Latin faces are weight 700 (index 1) and 400 (index 2) → lowest is 400.
+    expect(picks).toHaveLength(1);
+    expect(picks[0]?.weight).toBe("400");
+    expect(picks[0]?.publicUrl).toBe("/_assets/fonts/poppins/2.woff2");
+  });
+});
+
+describe("fontUnresolvableMarker", () => {
+  it("matches the theme-asset-unbound marker convention", () => {
+    expect(fontUnresolvableMarker("Poppins")).toBe("theme-font-unresolvable:Poppins");
+  });
+});

package/src/fonts.ts

@@ -0,0 +1,296 @@
+// SPDX-License-Identifier: MPL-2.0
+
+/**
+ * issue #150 — web-font resolution primitives.
+ *
+ * Theme typography tokens name font families (`--font-heading:
+ * "Poppins"`), but until #150 nothing delivered the font files to
+ * rendered pages — every site silently fell back to system fonts, the
+ * exact silent-degradation CLAUDE.md §2 forbids. These pure helpers are
+ * the shared half of the fix: extract the families a theme actually
+ * uses, classify system stacks (nothing to deliver) vs web fonts
+ * (self-hosted at deploy — hotlinking fonts.googleapis.com is both a
+ * GDPR liability, LG München I 3 O 17493/20, and a third-party request
+ * on the critical path), and build/parse the CSS involved.
+ *
+ * Network + disk live in `@caelo-cms/admin-core`'s font resolver; the
+ * static generator and the preview op share that resolver so preview
+ * and production render the same `@font-face` set (parity contract,
+ * apps/static-generator/src/generate.ts).
+ */
+
+import type { ThemeDocument } from "./themes.js";
+
+/** One family the theme needs delivered, with the weights it uses. */
+export interface FontRequest {
+  /** Primary family name, unquoted (`Poppins`), first entry of the stack. */
+  readonly family: string;
+  /** Distinct numeric weights, ascending. Always non-empty. */
+  readonly weights: readonly number[];
+  /** Typography token names that reference the family (`body`, `heading`). */
+  readonly roles: readonly string[];
+}
+
+/** A single @font-face declaration parsed from a fonts-CSS payload. */
+export interface ParsedFontFace {
+  readonly family: string;
+  readonly style: string;
+  readonly weight: string;
+  readonly unicodeRange: string | null;
+  /** Remote woff2 URL as served by the fonts source. */
+  readonly srcUrl: string;
+}
+
+/** A parsed face whose bytes now live at a self-hosted public URL. */
+export interface ResolvedFontFace extends Omit<ParsedFontFace, "srcUrl"> {
+  readonly publicUrl: string;
+}
+
+/**
+ * Families that ship with operating systems — nothing to download, no
+ * @font-face to emit. Generic CSS keywords included. Lowercased for
+ * case-insensitive membership tests.
+ */
+const SYSTEM_FONT_FAMILIES: ReadonlySet<string> = new Set(
+  [
+    // Generic keywords + UI stacks
+    "serif",
+    "sans-serif",
+    "monospace",
+    "cursive",
+    "fantasy",
+    "system-ui",
+    "ui-sans-serif",
+    "ui-serif",
+    "ui-monospace",
+    "ui-rounded",
+    "-apple-system",
+    "blinkmacsystemfont",
+    // Cross-platform classics
+    "arial",
+    "arial black",
+    "helvetica",
+    "helvetica neue",
+    "georgia",
+    "times",
+    "times new roman",
+    "courier",
+    "courier new",
+    "verdana",
+    "tahoma",
+    "trebuchet ms",
+    "impact",
+    "palatino",
+    "garamond",
+    // Platform UI/mono staples browsers resolve locally
+    "segoe ui",
+    "sf pro",
+    "sf pro text",
+    "sf pro display",
+    "sf mono",
+    "sfmono-regular",
+    "menlo",
+    "monaco",
+    "consolas",
+    "lucida console",
+    "lucida sans",
+  ].map((f) => f.toLowerCase()),
+);
+
+/** True when the family resolves locally on visitors' machines. */
+export function isSystemFontFamily(family: string): boolean {
+  return SYSTEM_FONT_FAMILIES.has(family.trim().toLowerCase());
+}
+
+/** Strip quotes + whitespace from one family in a font stack. */
+function cleanFamilyName(raw: string): string {
+  return raw
+    .trim()
+    .replace(/^["']|["']$/g, "")
+    .trim();
+}
+
+const KEYWORD_WEIGHTS: Record<string, number> = {
+  normal: 400,
+  bold: 700,
+  // Relative keywords have no absolute value; anchor to the common pair
+  // so the request still covers a usable range.
+  lighter: 300,
+  bolder: 700,
+};
+
+const DEFAULT_WEIGHTS = [400, 700] as const;
+
+/**
+ * Walk `typography.*` composites and collect every non-system family
+ * with the weights the theme declares for it. Alias entries (`$value`
+ * as `{other.token}` string) are skipped — they point at a concrete
+ * composite that is collected on its own.
+ *
+ * Only the FIRST family of a declared stack is requested: the rest of
+ * the stack is the author's fallback chain, which by definition is not
+ * delivered.
+ */
+export function extractThemeFontRequests(tokens: ThemeDocument): FontRequest[] {
+  const typography = (tokens as Record<string, unknown>).typography;
+  if (typography === undefined || typography === null || typeof typography !== "object") {
+    return [];
+  }
+  const byFamily = new Map<string, { weights: Set<number>; roles: string[] }>();
+  for (const [role, entry] of Object.entries(typography as Record<string, unknown>)) {
+    if (entry === null || typeof entry !== "object") continue;
+    const value = (entry as { $value?: unknown }).$value;
+    if (value === null || typeof value !== "object") continue; // alias or malformed
+    const composite = value as { fontFamily?: unknown; fontWeight?: unknown };
+    if (typeof composite.fontFamily !== "string") continue;
+    const primary = cleanFamilyName(composite.fontFamily.split(",")[0] ?? "");
+    if (primary === "" || isSystemFontFamily(primary)) continue;
+
+    const bucket = byFamily.get(primary) ?? { weights: new Set<number>(), roles: [] };
+    if (typeof composite.fontWeight === "number") {
+      bucket.weights.add(composite.fontWeight);
+    } else if (typeof composite.fontWeight === "string") {
+      const mapped = KEYWORD_WEIGHTS[composite.fontWeight];
+      if (mapped !== undefined) bucket.weights.add(mapped);
+    }
+    bucket.roles.push(role);
+    byFamily.set(primary, bucket);
+  }
+  return [...byFamily.entries()].map(([family, b]) => ({
+    family,
+    weights:
+      b.weights.size > 0
+        ? [...b.weights].sort((a, z) => a - z)
+        : ([...DEFAULT_WEIGHTS] as number[]),
+    roles: b.roles,
+  }));
+}
+
+/** css2 request URL for one family (woff2 negotiated via the UA header). */
+export function googleFontsCssUrl(request: FontRequest): string {
+  const family = encodeURIComponent(request.family).replace(/%20/g, "+");
+  const weights = request.weights.join(";");
+  return `https://fonts.googleapis.com/css2?family=${family}:wght@${weights}&display=swap`;
+}
+
+/**
+ * `[^{}]*` (not `[^}]*`): the char class excluding BOTH braces makes the
+ * pattern unambiguous — on adversarial payloads full of unclosed
+ * `@font-face{` starts, a failed match aborts at the next `{` instead of
+ * rescanning to end-of-input per start position (the polynomial-ReDoS
+ * shape CodeQL flags; this file parses remotely-served CSS).
+ */
+const FONT_FACE_BLOCK_RE = /@font-face\s*\{([^{}]*)\}/g;
+
+/** css2 responses are ~10–50 KB; anything past this is not a fonts CSS. */
+const MAX_FONTS_CSS_BYTES = 1_000_000;
+
+function declValue(block: string, prop: string): string | null {
+  const m = new RegExp(`${prop}\\s*:\\s*([^;]+);`, "i").exec(block);
+  return m ? (m[1] ?? "").trim() : null;
+}
+
+/**
+ * Parse a fonts-CSS payload (css2 response shape) into face records.
+ * Faces without a woff2/woff URL are dropped; a payload yielding zero
+ * faces is the caller's loud-failure signal, not a silent empty set.
+ * Oversized payloads short-circuit to [] for the same loud path —
+ * a legitimate css2 response is orders of magnitude smaller.
+ */
+export function parseFontsCss(cssText: string): ParsedFontFace[] {
+  if (cssText.length > MAX_FONTS_CSS_BYTES) return [];
+  const faces: ParsedFontFace[] = [];
+  for (const m of cssText.matchAll(FONT_FACE_BLOCK_RE)) {
+    const block = m[1] ?? "";
+    const familyRaw = declValue(block, "font-family");
+    const src = declValue(block, "src");
+    if (familyRaw === null || src === null) continue;
+    // Capture the whole url(...) argument with an unambiguous class,
+    // then check the extension in code — `[^)]+\.woff2?` is the classic
+    // ambiguous-suffix polynomial pattern.
+    const urlMatch = /url\(([^()]*)\)/i.exec(src);
+    if (!urlMatch) continue;
+    const srcUrl = (urlMatch[1] ?? "").trim().replace(/^["']|["']$/g, "");
+    const lower = srcUrl.toLowerCase();
+    if (!(lower.endsWith(".woff2") || lower.endsWith(".woff"))) continue;
+    faces.push({
+      family: cleanFamilyName(familyRaw),
+      style: declValue(block, "font-style") ?? "normal",
+      weight: declValue(block, "font-weight") ?? "400",
+      unicodeRange: declValue(block, "unicode-range"),
+      srcUrl,
+    });
+  }
+  return faces;
+}
+
+/**
+ * Emit self-hosted @font-face CSS. `font-display: swap` always — text
+ * must render in the fallback while the woff2 loads.
+ */
+export function buildFontFaceCss(faces: readonly ResolvedFontFace[]): string {
+  return faces
+    .map((f) => {
+      const range = f.unicodeRange !== null ? `unicode-range:${f.unicodeRange};` : "";
+      return (
+        `@font-face{font-family:${JSON.stringify(f.family)};` +
+        `font-style:${f.style};font-weight:${f.weight};font-display:swap;` +
+        `src:url(${f.publicUrl}) format('woff2');${range}}`
+      );
+    })
+    .join("\n");
+}
+
+/** Latin-subset heuristic: css2 marks it with a range starting U+0000. */
+function isLatinFace(f: ResolvedFontFace): boolean {
+  return f.unicodeRange === null || f.unicodeRange.toLowerCase().includes("u+0000");
+}
+
+/**
+ * Pick the faces worth a `<link rel="preload">`: one per family — the
+ * latin, normal-style face at the lowest declared weight (the body-copy
+ * face; heavier display cuts arrive via normal loading). Capped at two
+ * families so the preload budget stays sane on multi-family themes.
+ */
+export function selectPreloadFaces(faces: readonly ResolvedFontFace[]): ResolvedFontFace[] {
+  const byFamily = new Map<string, ResolvedFontFace[]>();
+  for (const f of faces) {
+    if (f.style !== "normal" || !isLatinFace(f)) continue;
+    const list = byFamily.get(f.family) ?? [];
+    list.push(f);
+    byFamily.set(f.family, list);
+  }
+  const picks: ResolvedFontFace[] = [];
+  for (const list of byFamily.values()) {
+    list.sort((a, z) => Number.parseInt(a.weight, 10) - Number.parseInt(z.weight, 10));
+    const first = list[0];
+    if (first !== undefined) picks.push(first);
+  }
+  return picks.slice(0, 2);
+}
+
+/**
+ * Structured marker for a family that could not be resolved. Lands in
+ * `missingSlots` (preview, soft) or a thrown deploy error (hard) — the
+ * same loud-signal convention as `theme-asset-unbound:<slot>`.
+ */
+export function fontUnresolvableMarker(family: string): string {
+  return `theme-font-unresolvable:${family}`;
+}
+
+/**
+ * Filesystem/URL-safe slug for a family name. Shared between the font
+ * resolver (writes `<cacheDir>/<slug>/…`) and the admin serve route
+ * (reads the same path from the URL) so the two can't drift.
+ */
+export function fontFamilySlug(family: string): string {
+  // After the collapse pass, dash RUNS no longer exist — at most one
+  // leading + one trailing dash remain, so the trim pattern needs no
+  // quantifier (a `-+$` here is the polynomial-ReDoS shape on
+  // adversarial all-dash input; this runs on library-supplied strings).
+  return family
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "");
+}

package/src/genesis-inventory.test.ts

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MPL-2.0
+
+/**
+ * issue #164 — inventory stage unit coverage: style extraction, color
+ * usage attribution (including gradient stops), typography + spacing
+ * histograms, outline scan, formatting, and the linear-parse budget on
+ * adversarial input (ReDoS discipline, issue #113).
+ */
+
+import { describe, expect, it } from "bun:test";
+import {
+  extractDraftCss,
+  formatGenesisInventory,
+  inventoryGenesisDraft,
+} from "./genesis-inventory.js";
+
+const DRAFT = `<!doctype html><html><head><style>
+  body { font-family: "Inter", sans-serif; color: #0f172a; background: #ffffff; margin: 0; }
+  h1, h2 { font-family: "Playfair Display", serif; }
+  h1 { font-size: clamp(2.5rem, 6vw, 4rem); }
+  .hero { background: linear-gradient(135deg, #4f46e5, #7c3aed); padding: 6rem 2rem; color: #ffffff; }
+  .card { background: #ffffff; border-radius: 12px; box-shadow: 0 4px 24px rgba(15,23,42,0.08); padding: 2rem; }
+  .cta { background: #4f46e5; color: #ffffff; padding: 0.75rem 1.5rem; border-radius: 9999px; }
+  .section-alt { background: #f5f3ff; padding: 6rem 2rem; }
+</style></head>
+<body>
+  <header><nav>Brand</nav></header>
+  <section class="hero"><h1>Bold headline for the brand</h1></section>
+  <section class="section-alt"><h2>What we do</h2></section>
+  <footer>© Brand</footer>
+</body></html>`;
+
+describe("inventoryGenesisDraft (issue #164)", () => {
+  const inv = inventoryGenesisDraft(DRAFT);
+
+  it("extracts style blocks linearly", () => {
+    expect(extractDraftCss(DRAFT)).toContain("linear-gradient");
+    expect(extractDraftCss("<p>no styles</p>")).toBe("");
+  });
+
+  it("attributes colors to properties with counts, including gradient stops", () => {
+    const primary = inv.colors.find((c) => c.value === "#4f46e5");
+    expect(primary).toBeDefined();
+    expect(primary?.count).toBe(2); // gradient stop + .cta background
+    expect(primary?.properties).toContain("background");
+    const white = inv.colors.find((c) => c.value === "#ffffff");
+    expect(white?.properties).toEqual(["background", "color"]);
+  });
+
+  it("collects gradients, fonts, sizes, spacing, radii, shadows", () => {
+    expect(inv.gradients[0]).toBe("linear-gradient(135deg, #4f46e5, #7c3aed)");
+    expect(inv.fontFamilies).toContain("Inter");
+    expect(inv.fontFamilies).toContain("Playfair Display");
+    expect(inv.fontSizes).toContain("clamp(2.5rem, 6vw, 4rem)");
+    expect(inv.spacingValues).toContain("6rem");
+    expect(inv.radiusValues).toContain("12px");
+    expect(inv.shadows[0]).toContain("0 4px 24px");
+  });
+
+  it("builds the section outline in document order", () => {
+    expect(inv.outline.map((o) => o.tag)).toEqual([
+      "header",
+      "nav",
+      "section",
+      "h1",
+      "section",
+      "h2",
+      "footer",
+    ]);
+    expect(inv.outline[3]?.text).toContain("Bold headline");
+  });
+
+  it("formats a compact prompt-friendly report", () => {
+    const report = formatGenesisInventory(inv);
+    expect(report).toContain("#4f46e5×2[background]");
+    expect(report).toContain("Font families: Inter, Playfair Display");
+    expect(report).toContain("Outline: <header>");
+  });
+
+  it("stays within budget on adversarial input (linear parse)", () => {
+    const evil = `<style>${"a{b:c;".repeat(30_000)}</style>${"<section>".repeat(5_000)}`;
+    const t0 = performance.now();
+    inventoryGenesisDraft(evil);
+    expect(performance.now() - t0).toBeLessThan(250);
+  });
+});