@caelo-cms/shared 0.10.23 → 0.10.24

package/src/design-draft-shell.ts

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: MPL-2.0
+
+/**
+ * issue #375 — theme shell for growth-time design-draft previews.
+ *
+ * Page/module-scope drafts are stored as FRAGMENTS bound to the site's
+ * `var(--…)` tokens; this composer wraps one in the site's real
+ * compiled theme at view time: web fonts (#150), theme CSS variables,
+ * and the invisible technical baseline (#151) — in the exact head
+ * order `composePagePreview` uses, so a draft previews in the same
+ * cascade it will materialise into. Pure / sync / no IO: the caller
+ * (the `genesis.render_draft` op) loads the theme row and resolves
+ * fonts, mirroring `pages.render_preview`.
+ */
+
+import { BASE_TECHNICAL_CSS } from "./base-css.js";
+import { type ComposeFonts, type ComposeTheme, fontsHeadFragment } from "./preview-compose.js";
+import { caeloMissingComment } from "./template-engine.js";
+import { renderThemeCss } from "./theme-render.js";
+
+/** Same four placeholders the template engine resolves (v0.11.1, #76). */
+const THEME_ASSET_KEY_TO_SLOT = {
+  theme_logo_url: "logo",
+  theme_logo_dark_url: "logoDark",
+  theme_favicon_url: "favicon",
+  theme_social_share_url: "socialShare",
+} as const;
+
+export interface DesignDraftShellInput {
+  /** The stored fragment (already script-stripped at the boundary). */
+  readonly fragmentHtml: string;
+  /** Active theme; undefined renders the shell without theme vars
+   *  (loud: the draft's `var(--…)` references fall to browser initial
+   *  values — visibly broken, per CLAUDE.md §2 no-fallbacks). */
+  readonly theme?: ComposeTheme;
+  /** Resolved web fonts; undefined = system stacks only. */
+  readonly fonts?: ComposeFonts;
+  /** Document title shown in the iframe (accessibility). */
+  readonly title: string;
+}
+
+export interface DesignDraftShellOutput {
+  readonly html: string;
+  /** `theme-asset-unbound:<slot>` markers, mirroring the template
+   *  engine's failure-marker contract. */
+  readonly missingSlots: readonly string[];
+}
+
+/**
+ * Resolve `{{theme_*_url}}` placeholders in a draft fragment. Bound
+ * slots substitute their URL; a placeholder on an unbound slot stays
+ * loud-raw IN PLACE (placeholders usually sit inside attribute values,
+ * where an appended comment would corrupt the URL string — PR-378
+ * review) and lands in `missingSlots`; the caller appends the real
+ * `caelo:missing` comment nodes at the end of the body so the marker
+ * tooling still sees them. Other `{{…}}` sequences are left untouched:
+ * a draft is not a fielded module.
+ */
+function substituteThemeAssetUrls(
+  html: string,
+  theme: ComposeTheme | undefined,
+  missing: string[],
+): string {
+  return html.replace(/\{\{\s*(theme_[a-z_]+)\s*\}\}/g, (match, key: string) => {
+    const slot = THEME_ASSET_KEY_TO_SLOT[key as keyof typeof THEME_ASSET_KEY_TO_SLOT];
+    if (slot === undefined) return match;
+    const url = theme?.assets[slot]?.url;
+    if (url === undefined) {
+      missing.push(`theme-asset-unbound:${slot}`);
+      return match;
+    }
+    return url;
+  });
+}
+
+export function composeDesignDraftShell(input: DesignDraftShellInput): DesignDraftShellOutput {
+  const missing: string[] = [];
+  const substituted = substituteThemeAssetUrls(input.fragmentHtml, input.theme, missing);
+  // Real comment NODES, after the fragment — never inside an attribute.
+  const markers = [...new Set(missing)].map((m) => caeloMissingComment(m)).join("");
+  const body = substituted + markers;
+
+  // Head order mirrors composePagePreview: fonts first (URL discovery),
+  // then theme vars (so fragment CSS can `var(--color-primary)`), then
+  // the technical baseline.
+  const head: string[] = [
+    `<meta charset="utf-8">`,
+    `<meta name="viewport" content="width=device-width, initial-scale=1">`,
+    `<title>${escapeHtml(input.title)}</title>`,
+  ];
+  const fonts = fontsHeadFragment(input.fonts);
+  if (fonts !== null) head.push(fonts);
+  const themeCss = input.theme !== undefined ? renderThemeCss(input.theme.tokens) : null;
+  if (themeCss !== null) head.push(`<style data-source="theme">${themeCss}</style>`);
+  head.push(`<style data-source="base">${BASE_TECHNICAL_CSS}</style>`);
+
+  return {
+    html: `<!doctype html>\n<html><head>${head.join("")}</head><body>${body}</body></html>`,
+    missingSlots: missing,
+  };
+}
+
+function escapeHtml(s: string): string {
+  return s
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+}

package/src/genesis.ts

@@ -1,12 +1,17 @@
 // SPDX-License-Identifier: MPL-2.0
 
 /**
- * issue #163 — Site Genesis shared shapes.
+ * issue #163 — Site Genesis shared shapes; issue #375 generalises the
+ * same draft loop to growth-time.
  *
  * Design-time is divergent: the AI drafts complete freeform HTML pages
  * (one per design direction) and the operator picks one; the CMS
- * structure is derived FROM that choice (#164's compiler). These are
- * the boundary schemas for the brief + the draft rows.
+ * structure is derived FROM that choice (#164's compiler). Growth-time
+ * reuses the identical draft → present → select → materialise loop at
+ * smaller scope: `page` and `module` drafts are FRAGMENTS bound to the
+ * site's `var(--…)` theme tokens, composed into the real theme shell
+ * only at view time (never an AI approximation of the theme — #375).
+ * These are the boundary schemas for the brief + the draft rows.
  */
 
 import { z } from "zod";
@@ -41,14 +46,50 @@ export type GenesisDraftStatus = z.infer<typeof genesisDraftStatus>;
 export const genesisDraftSourceKind = z.enum(["genesis", "byod_image", "byod_html"]);
 export type GenesisDraftSourceKind = z.infer<typeof genesisDraftSourceKind>;
 
-export const genesisAddDraftInput = z
+/**
+ * issue #375 — what a draft covers. `site` is the Genesis case (a whole
+ * new design); `page` / `module` are growth-time variants of something
+ * that already exists.
+ */
+export const designDraftScope = z.enum(["site", "page", "module"]);
+export type DesignDraftScope = z.infer<typeof designDraftScope>;
+
+/**
+ * issue #375 — how a draft's HTML is stored. `site` drafts are complete
+ * standalone documents (Genesis, unchanged); `page`/`module` drafts are
+ * fragments that only become a renderable document when composed with
+ * the site's real theme shell at view time — so a stored variant never
+ * freezes a stale copy of the theme.
+ */
+export const designDraftFormat = z.enum(["document", "fragment"]);
+export type DesignDraftFormat = z.infer<typeof designDraftFormat>;
+
+/** The stored format is fully determined by the scope (see the paired
+ *  DB CHECK constraint): `site` → standalone document, else fragment. */
+export function draftFormatForScope(scope: DesignDraftScope): DesignDraftFormat {
+  return scope === "site" ? "document" : "fragment";
+}
+
+const addDraftBase = z
   .object({
     /** Human-readable design direction ("bold editorial"). */
     direction: z.string().min(3).max(120),
     /** Why this direction fits the brief — shown beside the preview. */
     rationale: z.string().max(1000).default(""),
-    /** Complete self-contained single-file HTML. */
+    /** Site scope: complete self-contained single-file HTML. Page/module
+     *  scope: an HTML fragment bound to the site's `var(--…)` tokens. */
     html: z.string().min(200).max(GENESIS_DRAFT_MAX_HTML_BYTES),
+    /** issue #375 — what this draft covers; `site` is the Genesis case. */
+    scope: designDraftScope.default("site"),
+    /** issue #375 — page scope: the page this variant redesigns. Module
+     *  scope: optional page context for "this module as used on …". */
+    targetPageId: z.string().uuid().optional(),
+    /** issue #375 — module scope: the module this variant restyles. */
+    targetModuleId: z.string().uuid().optional(),
+    /** issue #375 — groups one request's variants into one comparison.
+     *  Omit on the first save (the op mints and returns it); pass it on
+     *  every sibling save of the same round. */
+    variantSetId: z.string().uuid().optional(),
     /** issue #199 — 'byod_image' (AI reproduction of an operator
      *  mockup) / 'byod_html' (operator HTML, sanitised at the op). */
     sourceKind: genesisDraftSourceKind.default("genesis"),
@@ -57,6 +98,36 @@ export const genesisAddDraftInput = z
     referenceAssetId: z.string().uuid().optional(),
   })
   .strict();
+
+/** Scope/target pairing rules shared by the op and the AI tool. */
+export const genesisAddDraftInput = addDraftBase.superRefine((v, ctx) => {
+  if (v.scope === "site") {
+    if (v.targetPageId !== undefined || v.targetModuleId !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "site-scope drafts take no target — drop targetPageId/targetModuleId",
+      });
+    }
+  } else if (v.sourceKind !== "genesis") {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message:
+        "byod drafts are site-scope only (issue #199); growth-time variants use sourceKind 'genesis'",
+    });
+  } else if (v.scope === "page") {
+    if (v.targetPageId === undefined || v.targetModuleId !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "page-scope drafts need targetPageId (and no targetModuleId)",
+      });
+    }
+  } else if (v.targetModuleId === undefined) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "module-scope drafts need targetModuleId (targetPageId is optional page context)",
+    });
+  }
+});
 export type GenesisAddDraftInput = z.infer<typeof genesisAddDraftInput>;
 
 /**

package/src/i18n.test.ts

@@ -1,116 +1,7 @@
 // SPDX-License-Identifier: MPL-2.0
 
 import { describe, expect, it } from "bun:test";
-import {
-  buildHreflangLinks,
-  computeContentHash,
-  isHomeSlug,
-  type LocaleConfig,
-  lintLocaleConfig,
-  pageIsLocaleHome,
-  resolveLocaleUrl,
-} from "./i18n.js";
-
-const ENG: LocaleConfig = {
-  code: "en",
-  displayName: "English",
-  urlStrategy: "none",
-  urlHost: null,
-  isDefault: true,
-};
-
-const DE_SUBDIR: LocaleConfig = {
-  code: "de",
-  displayName: "Deutsch",
-  urlStrategy: "subdirectory",
-  urlHost: null,
-  isDefault: false,
-};
-
-const DE_SUBDOMAIN: LocaleConfig = {
-  code: "de",
-  displayName: "Deutsch",
-  urlStrategy: "subdomain",
-  urlHost: "de.example.com",
-  isDefault: false,
-};
-
-const DE_DOMAIN: LocaleConfig = {
-  code: "de",
-  displayName: "Deutsch",
-  urlStrategy: "domain",
-  urlHost: "example.de",
-  isDefault: false,
-};
-
-describe("resolveLocaleUrl", () => {
-  it("strategy=none yields bare slug under siteBaseUrl with trailing slash", () => {
-    expect(resolveLocaleUrl(ENG, "about", "https://example.com")).toBe(
-      "https://example.com/about/",
-    );
-  });
-
-  it("strategy=subdirectory prefixes the locale code", () => {
-    expect(resolveLocaleUrl(DE_SUBDIR, "about", "https://example.com")).toBe(
-      "https://example.com/de/about/",
-    );
-  });
-
-  it("strategy=subdomain uses urlHost", () => {
-    expect(resolveLocaleUrl(DE_SUBDOMAIN, "about", "https://example.com")).toBe(
-      "https://de.example.com/about/",
-    );
-  });
-
-  it("strategy=domain uses urlHost", () => {
-    expect(resolveLocaleUrl(DE_DOMAIN, "about", "https://example.com")).toBe(
-      "https://example.de/about/",
-    );
-  });
-
-  it("strategy=subdomain throws when urlHost missing", () => {
-    expect(() =>
-      resolveLocaleUrl({ ...DE_SUBDOMAIN, urlHost: null }, "about", "https://example.com"),
-    ).toThrow(/url_host/);
-  });
-
-  it("trailing slashes on baseUrl are normalised", () => {
-    expect(resolveLocaleUrl(ENG, "about", "https://example.com//")).toBe(
-      "https://example.com/about/",
-    );
-  });
-
-  it("leading slashes on slug are stripped", () => {
-    expect(resolveLocaleUrl(ENG, "/about", "https://example.com")).toBe(
-      "https://example.com/about/",
-    );
-  });
-
-  it("home slug renders as the locale root (no extra path segment)", () => {
-    expect(resolveLocaleUrl(ENG, "home", "https://example.com")).toBe("https://example.com/");
-    expect(resolveLocaleUrl(DE_SUBDIR, "home", "https://example.com")).toBe(
-      "https://example.com/de/",
-    );
-    expect(resolveLocaleUrl(DE_SUBDOMAIN, "home", "https://example.com")).toBe(
-      "https://de.example.com/",
-    );
-  });
-
-  it("explicit isHomePage collapses a NON-magic slug to the locale root (0184)", () => {
-    // slug "en" is a normal nested page without the designation...
-    expect(resolveLocaleUrl(ENG, "en", "https://example.com")).toBe("https://example.com/en/");
-    // ...and the locale root once designated, per url strategy.
-    expect(resolveLocaleUrl(ENG, "en", "https://example.com", "directory", true)).toBe(
-      "https://example.com/",
-    );
-    expect(resolveLocaleUrl(DE_SUBDIR, "en", "https://example.com", "directory", true)).toBe(
-      "https://example.com/de/",
-    );
-    expect(resolveLocaleUrl(DE_SUBDOMAIN, "en", "https://example.com", "directory", true)).toBe(
-      "https://de.example.com/",
-    );
-  });
-});
+import { computeContentHash, isHomeSlug, pageIsLocaleHome } from "./i18n.js";
 
 describe("isHomeSlug", () => {
   it("recognises the magic-slug sentinels regardless of surrounding slashes", () => {
@@ -145,90 +36,6 @@ describe("pageIsLocaleHome (0184 shared predicate)", () => {
   });
 });
 
-// renderLanguageSelector lives in structured-sets.ts but exercises the
-// same i18n primitives (resolveLocaleUrl produces hrefs the test feeds
-// in pre-resolved). Cover the three paths: vanilla render, override
-// relabel, hidden locale.
-import { renderLanguageSelector } from "./structured-sets.js";
-
-describe("renderLanguageSelector", () => {
-  const ENGLISH = {
-    code: "en",
-    displayName: "English",
-    href: "https://example.com/about/",
-    isCurrent: true,
-  };
-  const GERMAN = {
-    code: "de",
-    displayName: "Deutsch",
-    href: "https://example.com/de/about/",
-    isCurrent: false,
-  };
-
-  it("emits one anchor per locale + aria-current on the current page", () => {
-    const html = renderLanguageSelector({ availableLocales: [ENGLISH, GERMAN] });
-    expect(html).toContain('hreflang="en"');
-    expect(html).toContain('hreflang="de"');
-    expect(html).toContain('aria-current="true"');
-    expect(html).toContain("English");
-    expect(html).toContain("Deutsch");
-  });
-
-  it("override relabels a locale", () => {
-    const html = renderLanguageSelector({
-      availableLocales: [ENGLISH, GERMAN],
-      overrides: [{ locale: "de", label: "DE 🇩🇪" }],
-    });
-    expect(html).toContain("DE 🇩🇪");
-    expect(html).not.toContain("Deutsch");
-  });
-
-  it("hidden override drops the locale entirely", () => {
-    const html = renderLanguageSelector({
-      availableLocales: [ENGLISH, GERMAN],
-      overrides: [{ locale: "de", hidden: true }],
-    });
-    expect(html).toContain('hreflang="en"');
-    expect(html).not.toContain('hreflang="de"');
-  });
-
-  it("empty available list returns empty string", () => {
-    expect(renderLanguageSelector({ availableLocales: [] })).toBe("");
-  });
-
-  it("escapes attribute special chars", () => {
-    const html = renderLanguageSelector({
-      availableLocales: [{ code: "en", displayName: "EN&Co", href: "/?a=1&b=2", isCurrent: false }],
-    });
-    expect(html).toContain("a=1&b=2");
-    expect(html).toContain("EN&Co");
-  });
-});
-
-describe("buildHreflangLinks", () => {
-  it("emits one link per locale + x-default for the default", () => {
-    const html = buildHreflangLinks([
-      { localeCode: "en", url: "https://example.com/about", isDefault: true },
-      { localeCode: "de", url: "https://example.com/de/about", isDefault: false },
-    ]);
-    expect(html).toContain('hreflang="en"');
-    expect(html).toContain('hreflang="de"');
-    expect(html).toContain('hreflang="x-default"');
-    expect(html).toContain('href="https://example.com/about"');
-  });
-
-  it("returns empty string when no entries", () => {
-    expect(buildHreflangLinks([])).toBe("");
-  });
-
-  it("escapes attribute special characters", () => {
-    const html = buildHreflangLinks([
-      { localeCode: "en", url: "https://example.com/?a=1&b=2", isDefault: true },
-    ]);
-    expect(html).toContain("a=1&b=2");
-  });
-});
-
 describe("computeContentHash", () => {
   it("is stable across runs for the same input", async () => {
     const a = await computeContentHash({ x: 1, y: [1, 2] });
@@ -249,26 +56,3 @@ describe("computeContentHash", () => {
     expect(a).not.toBe(b);
   });
 });
-
-describe("lintLocaleConfig", () => {
-  it("warns when subdomain/domain used while advanced toggle is off", () => {
-    const warnings = lintLocaleConfig([ENG, DE_SUBDOMAIN], false);
-    expect(warnings.find((w) => w.code === "advanced-routing-disabled")).toBeTruthy();
-  });
-
-  it("does not warn when toggle matches usage", () => {
-    const warnings = lintLocaleConfig([ENG, DE_SUBDOMAIN], true);
-    expect(warnings.find((w) => w.code === "advanced-routing-disabled")).toBeFalsy();
-  });
-
-  it("warns when subdomain locale lacks urlHost", () => {
-    const broken: LocaleConfig = { ...DE_SUBDOMAIN, urlHost: null };
-    const warnings = lintLocaleConfig([ENG, broken], true);
-    expect(warnings.find((w) => w.code === "missing-url-host")).toBeTruthy();
-  });
-
-  it("warns about mixed default-none + subdir-sibling configs", () => {
-    const warnings = lintLocaleConfig([ENG, DE_SUBDIR], true);
-    expect(warnings.find((w) => w.code === "mixed-default-none-subdir")).toBeTruthy();
-  });
-});

package/src/i18n.ts

@@ -1,28 +1,15 @@
 // SPDX-License-Identifier: MPL-2.0
 
 /**
- * P9 — i18n primitives shared between the static generator, the
- * preview op, and the admin UI:
+ * Slug/URL primitives shared between the static generator, the preview
+ * op, and the admin UI. Epic #380 Phase A (#383): locale URL shaping
+ * (resolveLocaleUrl, buildHreflangLinks) is deleted — URL shape beyond
+ * base + slug becomes a plugin contribution on the URL composition
+ * point (#390). What survives until the page-identity cut (#384):
  *
- *   computeContentHash(page, modules) — sha256 of canonical-JSON
- *     content. Drives `pages.content_hash` + the translation_status
- *     recompute path.
- *
- *   resolveLocaleUrl(locale, slug, siteBaseUrl, pageUrlStyle?, isHomePage?) —
- *     builds the public URL for a (locale, slug) tuple given the
- *     locale's url_strategy + url_host. `isHomePage` forces the locale
- *     root (0184 explicit designation). Used by:
- *       - hreflang emitter
- *       - sitemap.xml emitter (when extended for i18n)
- *       - language-selector module
- *
- *   buildHreflangLinks(currentLocale, perLocaleUrls, defaultLocaleCode) —
- *     emits the `<link rel="alternate" hreflang=...>` markup.
- *
- *   lintLocaleConfig(locales, advancedUrlRouting) — surfaces config
- *     warnings (mixed strategies, missing url_host for subdomain/
- *     domain, default locale using `none` alongside subdirectory
- *     siblings, advanced strategy chosen while toggle is off).
+ *   isHomeSlug / pageIsLocaleHome — the home-decision predicate.
+ *   computeContentHash — drives `pages.content_hash` (removed in #384).
+ *   trimSlashes / trimTrailingSlashes — linear-scan slug hygiene.
  */
 
 const TEXT_ENCODER = new TextEncoder();
@@ -55,14 +42,6 @@ export function trimTrailingSlashes(s: string): string {
   return s.slice(0, end);
 }
 
-export interface LocaleConfig {
-  code: string;
-  displayName: string;
-  urlStrategy: "none" | "subdirectory" | "subdomain" | "domain";
-  urlHost: string | null;
-  isDefault: boolean;
-}
-
 /**
  * The "magic slug" sentinel test: a page whose slug is empty, `home`,
  * or `index` is the locale root by convention even without an explicit
@@ -93,111 +72,6 @@ export function pageIsLocaleHome(
   return (localeHomePageId != null && pageId === localeHomePageId) || isHomeSlug(slug);
 }
 
-/**
- * Build a public-facing URL for a (locale, slug) tuple. Pure function —
- * no DB access — so the static generator can call it for every page
- * without round-trips.
- *
- * @param locale       The target locale's full config row.
- * @param slug         Path component (e.g. "about", "blog/post-1"). No leading slash.
- * @param siteBaseUrl  Default base URL when the strategy is `none` or
- *                     `subdirectory` (e.g. "https://example.com").
- * @param pageUrlStyle Page emission style (see below).
- * @param isHomePage   Explicit homepage designation (0184 —
- *                     `locales.home_page_id`). When true this page IS the
- *                     locale root and resolves to `<base>/` regardless of
- *                     its own slug. The explicit flag WINS over the slug
- *                     sentinel below; the sentinel stays as a back-compat
- *                     fallback for callers that can't cheaply surface the
- *                     designation.
- * @returns Absolute URL, including scheme + host.
- */
-export function resolveLocaleUrl(
-  locale: LocaleConfig,
-  slug: string,
-  siteBaseUrl: string,
-  // v0.2.85 — page emission style. 'directory' (default) builds
-  // URLs ending in `/<slug>/`; 'no-extension' builds URLs ending
-  // in `/<slug>` (no trailing slash) to match what the bucket
-  // actually serves when pages are emitted as bare slugs. Home
-  // page is always `<base>/` regardless of style.
-  pageUrlStyle: "directory" | "no-extension" = "directory",
-  isHomePage?: boolean,
-): string {
-  const stripped = trimSlashes(slug);
-  // 0184 — the explicit designation wins; the slug sentinel
-  // (""/`home`/`index`) survives as a back-compat fallback so a page the
-  // AI never ran set_home_page on still resolves to the root. Shared
-  // `isHomeSlug` keeps this test identical across every home-decision site.
-  const isHome = isHomePage === true || isHomeSlug(stripped);
-  // tail: the path component appended after `<base>/` or `<base>/<locale>/`.
-  // 'directory' style: trailing slash for non-home so the URL points at
-  // the directory the bucket serves index.html from.
-  // 'no-extension' style: no trailing slash, no extension — the URL
-  // points at the bare-slug object the bucket serves directly.
-  const tail = isHome ? "" : pageUrlStyle === "no-extension" ? stripped : `${stripped}/`;
-  const base = trimTrailingSlashes(siteBaseUrl);
-  switch (locale.urlStrategy) {
-    case "none":
-      return tail ? `${base}/${tail}` : `${base}/`;
-    case "subdirectory":
-      // Default locale with strategy `subdirectory` still gets the prefix
-      // unless the migration set strategy=none for it. The decision is
-      // explicit per locale row, not implicit on isDefault.
-      return tail ? `${base}/${locale.code}/${tail}` : `${base}/${locale.code}/`;
-    case "subdomain": {
-      if (!locale.urlHost) {
-        throw new Error(
-          `locale '${locale.code}' uses url_strategy='subdomain' without url_host — config invalid`,
-        );
-      }
-      const protocol = base.startsWith("http://") ? "http://" : "https://";
-      return tail ? `${protocol}${locale.urlHost}/${tail}` : `${protocol}${locale.urlHost}/`;
-    }
-    case "domain": {
-      if (!locale.urlHost) {
-        throw new Error(
-          `locale '${locale.code}' uses url_strategy='domain' without url_host — config invalid`,
-        );
-      }
-      const protocol = base.startsWith("http://") ? "http://" : "https://";
-      return tail ? `${protocol}${locale.urlHost}/${tail}` : `${protocol}${locale.urlHost}/`;
-    }
-  }
-}
-
-/**
- * Emit `<link rel="alternate" hreflang="…">` tags for every locale
- * that has a published variant of this page. The default locale also
- * gets an `x-default` entry per Google's i18n guidance.
- *
- * Returned as a single string suitable for splicing into <head>.
- */
-export function buildHreflangLinks(
-  perLocaleUrls: ReadonlyArray<{ localeCode: string; url: string; isDefault: boolean }>,
-): string {
-  if (perLocaleUrls.length === 0) return "";
-  const lines: string[] = [];
-  for (const v of perLocaleUrls) {
-    lines.push(
-      `<link rel="alternate" hreflang="${escapeAttr(v.localeCode)}" href="${escapeAttr(v.url)}" />`,
-    );
-  }
-  const def = perLocaleUrls.find((v) => v.isDefault);
-  if (def) {
-    lines.push(`<link rel="alternate" hreflang="x-default" href="${escapeAttr(def.url)}" />`);
-  }
-  return lines.join("\n");
-}
-
-function escapeAttr(s: string): string {
-  return s
-    .replace(/&/g, "&amp;")
-    .replace(/"/g, "&quot;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
-}
-
 /**
  * Canonical-JSON serializer + sha256 → hex. Stable across runs because
  * keys are sorted. The output is used for `pages.content_hash` so that
@@ -215,55 +89,3 @@ export async function computeContentHash(value: unknown): Promise<string> {
   const digest = await crypto.subtle.digest("SHA-256", TEXT_ENCODER.encode(canonical));
   return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
 }
-
-export interface LocaleLintWarning {
-  code: string;
-  message: string;
-}
-
-/**
- * Cross-row config sanity checks. Run at:
- *   - propose-time (warnings stored on the proposal preview)
- *   - render-time (no fail-loudly per CLAUDE.md §2 since the renderer
- *     can still emit; surfaced in admin UI as banners)
- */
-export function lintLocaleConfig(
-  locales: ReadonlyArray<LocaleConfig>,
-  advancedUrlRouting: boolean,
-): LocaleLintWarning[] {
-  const warnings: LocaleLintWarning[] = [];
-  const usingAdvanced = locales.some(
-    (l) => l.urlStrategy === "subdomain" || l.urlStrategy === "domain",
-  );
-  if (usingAdvanced && !advancedUrlRouting) {
-    warnings.push({
-      code: "advanced-routing-disabled",
-      message:
-        "one or more locales use 'subdomain' or 'domain' strategy but Advanced URL Routing is disabled — enable it under /security/locales",
-    });
-  }
-  for (const l of locales) {
-    if ((l.urlStrategy === "subdomain" || l.urlStrategy === "domain") && !l.urlHost) {
-      warnings.push({
-        code: "missing-url-host",
-        message: `locale '${l.code}' uses url_strategy='${l.urlStrategy}' without url_host`,
-      });
-    }
-  }
-  // Default-locale 'none' alongside subdirectory siblings is a common
-  // mixed config; surface it so users know the default's URL stays bare
-  // while siblings get prefixed.
-  const def = locales.find((l) => l.isDefault);
-  const subdirSiblings = locales.filter((l) => !l.isDefault && l.urlStrategy === "subdirectory");
-  if (def && def.urlStrategy === "none" && subdirSiblings.length > 0) {
-    warnings.push({
-      code: "mixed-default-none-subdir",
-      message: `default locale '${def.code}' uses 'none' while ${subdirSiblings
-        .map((l) => l.code)
-        .join(
-          ", ",
-        )} use 'subdirectory' — this is valid but unusual; verify hreflang renders correctly`,
-    });
-  }
-  return warnings;
-}