@caelo-cms/shared 0.10.23 → 0.10.26

package/src/preview-compose.ts

@@ -34,7 +34,6 @@ import {
   listSlotNames,
 } from "./preview-scanner.js";
 import { stripCdataGuards } from "./strip-cdata.js";
-import { type LanguageSelectorOverride, renderLanguageSelector } from "./structured-sets.js";
 import { renderTemplate, type TemplateField } from "./template-engine.js";
 import { renderThemeCss as renderThemeCssFromTokens } from "./theme-render.js";
 import type { ThemeDocument } from "./themes.js";
@@ -90,21 +89,6 @@ export interface ComposeStructuredSets {
   readonly byKindSlug: Readonly<Record<string, readonly unknown[]>>;
 }
 
-/**
- * P9 — language-selector context. The caller (preview op + static
- * generator) resolves the current page's per-locale URLs once and
- * threads them in. The composer renders the selector when a module
- * slug starts with `language-selector-`.
- */
-export interface ComposeLanguageSelector {
-  readonly availableLocales: ReadonlyArray<{
-    code: string;
-    displayName: string;
-    href: string;
-    isCurrent: boolean;
-  }>;
-}
-
 /**
  * v0.11.0 — Theme context resolved by the preview op + static generator
  * (#45 Phase 3). Carries the active theme's DTCG tokens jsonb plus the
@@ -147,7 +131,6 @@ export interface ComposeInput {
   readonly templateCss: string;
   readonly blocks: readonly ComposeBlock[];
   readonly structuredSets?: ComposeStructuredSets;
-  readonly languageSelector?: ComposeLanguageSelector;
   /**
    * v0.11.0 — active theme threaded through from the preview op + static
    * generator. Undefined when no theme row exists OR when the caller
@@ -157,6 +140,21 @@ export interface ComposeInput {
   readonly theme?: ComposeTheme;
   /** issue #150 — resolved web fonts; undefined = system stacks only. */
   readonly fonts?: ComposeFonts;
+  /**
+   * Plugin-provided lists for the page being composed, plus the names
+   * declared by installed-but-inactive plugins. Threaded so a module
+   * iterating `{{#language_links}}` renders the same on deploy as in
+   * the editor — including the loud marker when its plugin is off.
+   */
+  readonly dataLists?: Readonly<Record<string, ReadonlyArray<Readonly<Record<string, string>>>>>;
+  readonly dormantDataLists?: Readonly<Record<string, string>>;
+  /**
+   * #450 — modules withheld by a plugin, keyed by module id. Resolved
+   * by the host before composing; absent means the module renders
+   * normally, which is the case for every module on a site with no
+   * gating plugin active.
+   */
+  readonly deferredModules?: Readonly<Record<string, ComposeDeferral>>;
 }
 
 export interface ComposeOutput {
@@ -180,11 +178,16 @@ function injectBefore(source: string, marker: RegExp, fragment: string): string
  * `crossorigin` attribute is REQUIRED for font preloads even same-origin,
  * per the fetch spec's font-destination CORS rule) + the @font-face
  * block. Empty css with no preloads → null (system-stack-only theme).
+ * Exported for the design-draft theme shell (#375) so draft previews
+ * load the identical fonts as the page preview.
  */
-function fontsHeadFragment(fonts: ComposeFonts | undefined): string | null {
+export function fontsHeadFragment(fonts: ComposeFonts | undefined): string | null {
   if (fonts === undefined) return null;
   const links = fonts.preloads
-    .map((href) => `<link rel="preload" as="font" type="font/woff2" crossorigin href="${href}">`)
+    .map((href) => {
+      const format = /\.(woff2?|ttf|otf)(?:[?#]|$)/.exec(href)?.[1];
+      return `<link rel="preload" as="font"${format ? ` type="font/${format}"` : ""} crossorigin href="${href}">`;
+    })
     .join("");
   const style =
     fonts.css.trim().length > 0 ? `<style data-source="fonts">${fonts.css}</style>` : "";
@@ -193,6 +196,13 @@ function fontsHeadFragment(fonts: ComposeFonts | undefined): string | null {
 }
 
 export function composePagePreview(input: ComposeInput): ComposeOutput {
+  // No withholding path here; rendering a withheld module would ship it
+  // ungated, so refuse instead of degrading silently (CLAUDE.md §2).
+  if (input.deferredModules && Object.keys(input.deferredModules).length > 0) {
+    throw new Error(
+      "composePagePreview cannot withhold modules; compose pages with deferrals through composePageWithLayout",
+    );
+  }
   const contentByName = new Map<string, string>();
   const allCss: string[] = [];
   const allJs: string[] = [];
@@ -214,15 +224,12 @@ export function composePagePreview(input: ComposeInput): ComposeOutput {
     // module HTML.
     const renderedModuleHtml = block.modules.map((m) => {
       const navMenuItems = lookupNavMenuItems(m.slug, input.structuredSets);
-      const langSelector = lookupLanguageSelector(m.slug, input);
       let baseHtml: string;
       if (navMenuItems !== null) {
         navRendered = true;
         baseHtml = renderNavMenuHtml(navMenuItems);
-      } else if (langSelector !== null) {
-        baseHtml = langSelector;
       } else {
-        baseHtml = applyFieldSubstitution(m.html, m.fields, m.contentValues, input.theme);
+        baseHtml = applyFieldSubstitution(m.html, m.fields, m.contentValues, input.theme, input);
       }
       return tagModuleId(baseHtml, m.moduleId);
     });
@@ -314,35 +321,6 @@ function lookupNavMenuItems(
   return items ?? null;
 }
 
-/**
- * P9 — return rendered language-selector HTML when a module's slug
- * starts with `language-selector-`. The set's items act as overrides
- * (relabel a locale, hide one); the available-locale list comes from
- * the caller via `input.languageSelector`. Returns null when the
- * module is not a language selector.
- *
- * Convention: a module slug `language-selector-header` resolves to
- * structuredSets[`language-selector/header`] for overrides, and the
- * rendered HTML lists every locale that has a published variant of
- * the current page.
- */
-function lookupLanguageSelector(moduleSlug: string, input: ComposeInput): string | null {
-  const prefix = "language-selector-";
-  if (!moduleSlug.startsWith(prefix)) return null;
-  if (!input.languageSelector || input.languageSelector.availableLocales.length === 0) {
-    return null;
-  }
-  const setSlug = moduleSlug.slice(prefix.length);
-  const overridesUnknown = input.structuredSets?.byKindSlug[`language-selector/${setSlug}`];
-  const overrides = Array.isArray(overridesUnknown)
-    ? (overridesUnknown as LanguageSelectorOverride[])
-    : undefined;
-  return renderLanguageSelector({
-    availableLocales: input.languageSelector.availableLocales,
-    overrides,
-  });
-}
-
 interface NavMenuItem {
   label: string;
   href: string;
@@ -436,11 +414,18 @@ function applyFieldSubstitution(
   fields: readonly { name: string; kind?: ModuleFieldKind; default?: unknown }[] | undefined,
   contentValues: Readonly<Record<string, unknown>> | undefined,
   theme: ComposeTheme | undefined,
+  lists: {
+    readonly dataLists?: Readonly<Record<string, ReadonlyArray<Readonly<Record<string, string>>>>>;
+    readonly dormantDataLists?: Readonly<Record<string, string>>;
+  },
 ): string {
   // The substitution engine (renderTemplate) already unwraps CDATA
   // guards; cover the no-op early-return path so a chrome module with no
   // fields/values/theme is cleaned too.
-  if (!fields && !contentValues && !theme) return stripCdataGuards(html);
+  const hasLists =
+    Object.keys(lists.dataLists ?? {}).length > 0 ||
+    Object.keys(lists.dormantDataLists ?? {}).length > 0;
+  if (!fields && !contentValues && !theme && !hasLists) return stripCdataGuards(html);
   const engineFields: TemplateField[] = (fields ?? []).map((f) => ({
     name: f.name,
     kind: f.kind ?? "text",
@@ -450,6 +435,8 @@ function applyFieldSubstitution(
     html,
     fields: engineFields,
     contentValues,
+    dataLists: lists.dataLists,
+    dormantDataLists: lists.dormantDataLists,
     // v0.11.1 (issue #76) — thread the active theme's asset URLs so
     // module HTML carrying `{{theme_logo_url}}` etc. resolves. Unbound
     // slots emit loud-raw + `theme-asset-unbound:<slot>` markers.
@@ -492,6 +479,58 @@ export function tagModuleId(html: string, moduleId: string): string {
  * static generator) surface it as a structured failure rather than
  * silently emitting broken HTML.
  */
+/**
+ * A module withheld from this render, as resolved by the plugin host
+ * (#450). The composer never decides this — it only knows the verdict.
+ */
+export interface ComposeDeferral {
+  readonly pluginSlug: string;
+  readonly reason: string;
+  readonly placeholderModuleSlug: string;
+  readonly placeholderHtml: string;
+  readonly placeholderCss: string;
+}
+
+/**
+ * Emit a withheld module: the visible placeholder, plus the real markup
+ * parked in an inert `<template>`.
+ *
+ * `<template>` is the whole point. Browsers parse its contents but
+ * instantiate nothing — no image, iframe, script or stylesheet inside
+ * one is ever fetched. So a video module behind a consent gate does not
+ * touch YouTube until the plugin's runtime clones the content out,
+ * which is a fact about the network rather than a promise about the
+ * DOM. Hiding the module with CSS or stripping attributes in script
+ * would both leave the request already sent.
+ *
+ * The module's CSS and JS go into the same `<template>` and NEVER into
+ * the page-wide bundles: a `url(https://maps.gstatic.com/…)` in its CSS
+ * or a `fetch()` in its JS reaches the vendor exactly as surely as an
+ * `<iframe src>` does. The JS is parked as `type="text/plain"` (inert
+ * even once cloned) and the plugin runtime executes it once per module,
+ * after the markup it expects is in the DOM.
+ */
+function wrapDeferredModule(
+  moduleHtml: string,
+  module: Pick<ComposeModule, "moduleId" | "slug" | "css" | "js">,
+  deferral: ComposeDeferral,
+): string {
+  const attr = (v: string): string =>
+    v.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;");
+  const css =
+    module.css.trim().length > 0 ? `<style data-source="module">${module.css}</style>` : "";
+  const js =
+    module.js.trim().length > 0
+      ? `<script type="text/plain" data-caelo-deferred-script="${attr(module.moduleId)}">${module.js}</script>`
+      : "";
+  return [
+    `<div data-caelo-deferred="${attr(deferral.pluginSlug)}" data-reason="${attr(deferral.reason)}" data-module="${attr(module.slug)}">`,
+    `<div data-caelo-deferred-placeholder>${deferral.placeholderHtml}</div>`,
+    `<template data-caelo-deferred-content>${css}${moduleHtml}${js}</template>`,
+    `</div>`,
+  ].join("");
+}
+
 export interface ComposeLayoutBlock {
   readonly blockName: string;
   readonly modules: readonly ComposeModule[];
@@ -584,34 +623,44 @@ export function composePageWithLayout(input: ComposeWithLayoutInput): ComposeOut
   // Duplicate rule blocks made the cascade order-dependent and bloated
   // every page the same module appeared on twice.
   const seenAssetModules = new Set<string>();
+  // Placeholder CSS, keyed by placeholder slug: one withheld module's
+  // placeholder used on five placements is emitted once.
+  const deferredCss = new Map<string, string>();
   if (input.layoutCss.trim().length > 0) cssParts.push(input.layoutCss);
   if (input.templateCss.trim().length > 0) cssParts.push(input.templateCss);
 
   // 1. Render the page modules into the template (slot replacement only;
   //    no head/body manipulation here — that belongs to the layout).
   const templateContentByName = new Map<string, string>();
+  const renderPlaced = (m: ComposeModule): string => {
+    const navMenuItems = lookupNavMenuItems(m.slug, input.structuredSets);
+    let baseHtml: string;
+    if (navMenuItems !== null) {
+      navRendered = true;
+      baseHtml = renderNavMenuHtml(navMenuItems);
+    } else {
+      baseHtml = applyFieldSubstitution(m.html, m.fields, m.contentValues, input.theme, input);
+    }
+    const tagged = tagModuleId(baseHtml, m.moduleId);
+    const deferral = input.deferredModules?.[m.moduleId];
+    if (!deferral) return tagged;
+    deferredCss.set(deferral.placeholderModuleSlug, deferral.placeholderCss);
+    return wrapDeferredModule(tagged, m, deferral);
+  };
+  // A withheld module's CSS/JS travel inside its <template> (see
+  // wrapDeferredModule); only modules that render normally feed the
+  // page-wide bundles.
+  const collectAssets = (m: ComposeModule): void => {
+    if (seenAssetModules.has(m.moduleId)) return;
+    seenAssetModules.add(m.moduleId);
+    if (input.deferredModules?.[m.moduleId]) return;
+    if (m.css.trim().length > 0) cssParts.push(m.css);
+    if (m.js.trim().length > 0) jsParts.push(m.js);
+  };
   for (const block of input.blocks) {
-    const renderedModuleHtml = block.modules.map((m) => {
-      const navMenuItems = lookupNavMenuItems(m.slug, input.structuredSets);
-      const langSelector = lookupLanguageSelector(m.slug, input);
-      let baseHtml: string;
-      if (navMenuItems !== null) {
-        navRendered = true;
-        baseHtml = renderNavMenuHtml(navMenuItems);
-      } else if (langSelector !== null) {
-        baseHtml = langSelector;
-      } else {
-        baseHtml = applyFieldSubstitution(m.html, m.fields, m.contentValues, input.theme);
-      }
-      return tagModuleId(baseHtml, m.moduleId);
-    });
+    const renderedModuleHtml = block.modules.map(renderPlaced);
     templateContentByName.set(block.blockName, renderedModuleHtml.join("\n"));
-    for (const m of block.modules) {
-      if (seenAssetModules.has(m.moduleId)) continue;
-      seenAssetModules.add(m.moduleId);
-      if (m.css.trim().length > 0) cssParts.push(m.css);
-      if (m.js.trim().length > 0) jsParts.push(m.js);
-    }
+    for (const m of block.modules) collectAssets(m);
   }
   const renderedTemplate = applySlotReplacements(input.templateHtml, {
     contentByName: templateContentByName,
@@ -626,27 +675,13 @@ export function composePageWithLayout(input: ComposeWithLayoutInput): ComposeOut
   layoutContentByName.set("content", innerBody);
   for (const block of input.layoutBlocks) {
     if (block.blockName === "content") continue; // reserved for the page body
-    const renderedModuleHtml = block.modules.map((m) => {
-      const navMenuItems = lookupNavMenuItems(m.slug, input.structuredSets);
-      const langSelector = lookupLanguageSelector(m.slug, input);
-      let baseHtml: string;
-      if (navMenuItems !== null) {
-        navRendered = true;
-        baseHtml = renderNavMenuHtml(navMenuItems);
-      } else if (langSelector !== null) {
-        baseHtml = langSelector;
-      } else {
-        baseHtml = applyFieldSubstitution(m.html, m.fields, m.contentValues, input.theme);
-      }
-      return tagModuleId(baseHtml, m.moduleId);
-    });
+    const renderedModuleHtml = block.modules.map(renderPlaced);
     layoutContentByName.set(block.blockName, renderedModuleHtml.join("\n"));
-    for (const m of block.modules) {
-      if (seenAssetModules.has(m.moduleId)) continue;
-      seenAssetModules.add(m.moduleId);
-      if (m.css.trim().length > 0) cssParts.push(m.css);
-      if (m.js.trim().length > 0) jsParts.push(m.js);
-    }
+    for (const m of block.modules) collectAssets(m);
+  }
+
+  for (const css of deferredCss.values()) {
+    if (css.trim().length > 0) cssParts.push(css);
   }
 
   if (navRendered) {

package/src/responsive-images.ts

@@ -37,11 +37,12 @@ export function variantFamily(variant: string): string {
  * Pick the variant tag AI-facing surfaces should hand out for an
  * asset, given the variant tags that ACTUALLY exist on it.
  *
- * Run #10 D4: `find_media` and the `## Media` system-prompt block
- * advertised `webp-800` for every raster mime, but the pipeline never
- * emits `webp-800` for sources narrower than 800px (no upscaling) or
- * for animated GIFs — the AI wrote those URLs into module HTML and the
- * static generator's media pass failed the whole staging build on
+ * Run #10 D4: `find_media` (and the since-removed `## Media`
+ * system-prompt block) advertised `webp-800` for every raster mime, but
+ * the pipeline never emits `webp-800` for sources narrower than 800px
+ * (no upscaling) or for animated GIFs — the AI wrote those URLs into
+ * module HTML and the static generator's media pass failed the whole
+ * staging build on
  * "asset/variant pairs missing". Advertising must be grounded in the
  * `media_variants` rows, not in the mime.
  *

package/src/seo.test.ts

@@ -16,19 +16,17 @@ describe("resolveCanonicalUrl", () => {
     expect(
       resolveCanonicalUrl({
         siteBaseUrl: "https://example.com",
-        pageSlug: "anything",
-        pageLocale: "en",
+        pagePath: "/anything",
         override: "https://canonical.example.com/x",
       }),
     ).toBe("https://canonical.example.com/x");
   });
 
-  it("renders home as the root path", () => {
+  it("renders the composed root path as the bare base URL", () => {
     expect(
       resolveCanonicalUrl({
         siteBaseUrl: "https://example.com",
-        pageSlug: "home",
-        pageLocale: "en",
+        pagePath: "/",
         override: null,
       }),
     ).toBe("https://example.com/");
@@ -38,8 +36,7 @@ describe("resolveCanonicalUrl", () => {
     expect(
       resolveCanonicalUrl({
         siteBaseUrl: "https://example.com/",
-        pageSlug: "about",
-        pageLocale: "en",
+        pagePath: "/about",
         override: null,
       }),
     ).toBe("https://example.com/about/");
@@ -50,50 +47,29 @@ describe("resolveCanonicalUrl", () => {
       expect(
         resolveCanonicalUrl({
           siteBaseUrl: "https://example.com",
-          pageSlug: "about",
-          pageLocale: "en",
+          pagePath: "/about",
           override: null,
           pageUrlStyle: "no-extension",
         }),
       ).toBe("https://example.com/about");
     });
 
-    it("keeps the root URL for the home page", () => {
+    it("keeps the root URL for the composed root path", () => {
       expect(
         resolveCanonicalUrl({
           siteBaseUrl: "https://example.com",
-          pageSlug: "home",
-          pageLocale: "en",
+          pagePath: "/",
           override: null,
           pageUrlStyle: "no-extension",
         }),
       ).toBe("https://example.com/");
     });
 
-    it("subdirectory locale strategy keeps the locale prefix, no trailing slash on slug", () => {
-      expect(
-        resolveCanonicalUrl({
-          siteBaseUrl: "https://example.com",
-          pageSlug: "about",
-          pageLocale: "de",
-          override: null,
-          pageUrlStyle: "no-extension",
-          localeConfig: {
-            code: "de",
-            urlStrategy: "subdirectory",
-            urlHost: null,
-            isDefault: false,
-          },
-        }),
-      ).toBe("https://example.com/de/about");
-    });
-
     it("default style preserves pre-v0.2.85 trailing-slash behavior", () => {
       expect(
         resolveCanonicalUrl({
           siteBaseUrl: "https://example.com",
-          pageSlug: "about",
-          pageLocale: "en",
+          pagePath: "/about",
           override: null,
         }),
       ).toBe("https://example.com/about/");
@@ -108,7 +84,6 @@ describe("renderSeoHead", () => {
     canonical: "https://example.com/",
     noindex: false,
     ogImageUrl: null,
-    hreflang: [] as { locale: string; url: string }[],
     organization: {},
   };
 
@@ -136,21 +111,6 @@ describe("renderSeoHead", () => {
     expect(head).toContain('<meta name="twitter:card" content="summary_large_image" />');
   });
 
-  it("emits hreflang per row + x-default when any rows are present", () => {
-    const head = renderSeoHead({
-      ...base,
-      hreflang: [
-        { locale: "de", url: "https://example.com/de/" },
-        { locale: "fr", url: "https://example.com/fr/" },
-      ],
-    });
-    expect(head).toContain('<link rel="alternate" hreflang="de" href="https://example.com/de/" />');
-    expect(head).toContain('<link rel="alternate" hreflang="fr" href="https://example.com/fr/" />');
-    expect(head).toContain(
-      '<link rel="alternate" hreflang="x-default" href="https://example.com/" />',
-    );
-  });
-
   it("emits a JSON-LD WebPage block; encodes the < character to avoid script-tag breaks", () => {
     const head = renderSeoHead({
       ...base,

package/src/seo.ts

@@ -8,7 +8,7 @@
  */
 
 import { z } from "zod";
-import { isHomeSlug } from "./i18n.js";
+import { trimSlashes } from "./url.js";
 
 export const CHANGEFREQ_VALUES = [
   "always",
@@ -108,58 +108,31 @@ export interface SiteSeoSettings {
 
 /**
  * Resolve the canonical URL for a page. If `pages_seo.canonical_url`
- * is set it wins; otherwise build `<siteBaseUrl>/<page-path>` from
- * the page's slug + locale. Locale strategy is single-locale (no
- * prefix) until P9 i18n.
+ * is set it wins; otherwise `<siteBaseUrl><pagePath>` — where
+ * `pagePath` is the COMPOSED public path from `pages.current_path`
+ * (#390: the URL composition point materializes prefixes, slug
+ * formats, and the home designation into that one column; canonical
+ * simply follows it).
  */
 export function resolveCanonicalUrl(args: {
   siteBaseUrl: string;
-  pageSlug: string;
-  pageLocale: string;
+  /** The page's composed path (`pages.current_path`): leading slash,
+   *  "/" for the site root. */
+  pagePath: string;
   override: string | null;
-  /** P9 — when present, the locale's url_strategy decides the URL shape. */
-  localeConfig?: {
-    code: string;
-    urlStrategy: "none" | "subdirectory" | "subdomain" | "domain";
-    urlHost: string | null;
-    isDefault: boolean;
-  };
   /**
    * v0.2.85 — page emission style. 'directory' (default) → URLs end
-   * in `/<slug>/`; 'no-extension' → URLs end in `/<slug>` (no
-   * trailing slash) to match what the bucket actually serves when
-   * pages are emitted as bare slugs.
+   * in `/…/`; 'no-extension' → no trailing slash, matching what the
+   * bucket serves when pages are emitted as bare files.
    */
   pageUrlStyle?: "directory" | "no-extension";
-  /**
-   * 0184 — explicit homepage designation (`locales.home_page_id`). When
-   * true this page IS the locale root and canonicalizes to `<base>/`
-   * regardless of its slug. Uses the same predicate (`isHomeSlug`) as
-   * the magic-slug fallback so canonical agrees with hreflang + the
-   * emitted output path.
-   */
-  isHomePage?: boolean;
 }): string {
   if (args.override && args.override.length > 0) return args.override;
-  const base = args.siteBaseUrl.replace(/\/$/, "");
-  const isHome = args.isHomePage === true || isHomeSlug(args.pageSlug);
-  const cleanSlug = isHome ? "" : args.pageSlug;
+  const base = args.siteBaseUrl.endsWith("/") ? args.siteBaseUrl.slice(0, -1) : args.siteBaseUrl;
+  const trimmed = trimSlashes(args.pagePath);
+  if (trimmed.length === 0) return `${base}/`;
   const style = args.pageUrlStyle ?? "directory";
-  // Tail = the slug portion of the canonical URL, with the trailing
-  // shape dictated by the page-emission style. Home pages always
-  // resolve to the base URL (no tail) regardless of style.
-  const tail = cleanSlug ? (style === "no-extension" ? cleanSlug : `${cleanSlug}/`) : "";
-  const cfg = args.localeConfig;
-  if (cfg && cfg.urlStrategy !== "none") {
-    if (cfg.urlStrategy === "subdirectory") {
-      return tail ? `${base}/${cfg.code}/${tail}` : `${base}/${cfg.code}/`;
-    }
-    if ((cfg.urlStrategy === "subdomain" || cfg.urlStrategy === "domain") && cfg.urlHost) {
-      const protocol = base.startsWith("http://") ? "http://" : "https://";
-      return tail ? `${protocol}${cfg.urlHost}/${tail}` : `${protocol}${cfg.urlHost}/`;
-    }
-  }
-  return tail ? `${base}/${tail}` : `${base}/`;
+  return style === "no-extension" ? `${base}/${trimmed}` : `${base}/${trimmed}/`;
 }
 
 export interface SeoMetaInput {
@@ -168,7 +141,6 @@ export interface SeoMetaInput {
   canonical: string;
   noindex: boolean;
   ogImageUrl: string | null;
-  hreflang: { locale: string; url: string }[];
   organization: SiteSeoSettings["organization"];
 }
 
@@ -177,7 +149,7 @@ export interface SeoMetaInput {
  * the renderer injects just before </head>. Order is canonical
  * (W3C-recommended): charset / viewport stay in the layout; meta
  * description + canonical + robots + Open Graph + Twitter card +
- * hreflang + JSON-LD.
+ * JSON-LD.
  *
  * No raw HTML escape hatch — every variable is HTML-attribute-encoded.
  */
@@ -208,14 +180,6 @@ export function renderSeoHead(input: SeoMetaInput): string {
   lines.push(
     `<meta name="twitter:card" content="${input.ogImageUrl ? "summary_large_image" : "summary"}" />`,
   );
-  // Hreflang per locale + x-default. P8 ships zero rows; P9 i18n
-  // populates pages_hreflang and the existing renderer iterates.
-  for (const h of input.hreflang) {
-    lines.push(`<link rel="alternate" hreflang="${enc(h.locale)}" href="${enc(h.url)}" />`);
-  }
-  if (input.hreflang.length > 0) {
-    lines.push(`<link rel="alternate" hreflang="x-default" href="${enc(input.canonical)}" />`);
-  }
   // JSON-LD WebPage block referencing the Organization (when set).
   const ld: Record<string, unknown> = {
     "@context": "https://schema.org",

package/src/structured-sets.ts

@@ -75,38 +75,13 @@ export const linkListItem = z
   })
   .strict();
 
-/**
- * P9 review-pass — `language-selector` kind. Items are user-supplied
- * overrides (e.g. force a specific display label per locale); empty
- * array means "auto-populate from the locale registry at render time."
- * The renderer (apps/static-generator + preview op) reads the locale
- * registry + the current page's slug + resolveLocaleUrl to emit
- * `<a hreflang lang href>` rows. Closes CMS_REQUIREMENTS §7.8.
- */
-export const languageSelectorOverride = z
-  .object({
-    /** BCP-47 locale code; must match a row in the locales registry. */
-    locale: z.string().min(2).max(10),
-    /** Override the locale's display_name when rendering this entry. */
-    label: z.string().min(1).max(120).optional(),
-    /** Hide this locale from the rendered selector even if it has a published page. */
-    hidden: z.boolean().optional(),
-  })
-  .strict();
-
 /** Discriminated kind → items array. The Query API op picks the
  *  validator at runtime by reading `kind` first.
  *
  *  v0.11.0 (#45) — `theme` is no longer a structured-set kind. The
  *  theme primitive moved to its own `themes` table with DTCG-shaped
  *  jsonb tokens; see `themes.ts` + `theme-render.ts`. */
-export const structuredSetKind = z.enum([
-  "nav-menu",
-  "taxonomy",
-  "tags",
-  "link-list",
-  "language-selector",
-]);
+export const structuredSetKind = z.enum(["nav-menu", "taxonomy", "tags", "link-list"]);
 export type StructuredSetKind = z.infer<typeof structuredSetKind>;
 
 /** Validate `items` against the right schema for `kind`. Throws a
@@ -130,8 +105,6 @@ export function validateStructuredSetItems(kind: StructuredSetKind, items: unkno
       return items.map((it) => tagItem.parse(it));
     case "link-list":
       return items.map((it) => linkListItem.parse(it));
-    case "language-selector":
-      return items.map((it) => languageSelectorOverride.parse(it));
   }
 }
 
@@ -139,42 +112,3 @@ export type NavMenuItem = z.infer<typeof navMenuItem>;
 export type TaxonomyItem = z.infer<typeof taxonomyItem>;
 export type TagItem = z.infer<typeof tagItem>;
 export type LinkListItem = z.infer<typeof linkListItem>;
-export type LanguageSelectorOverride = z.infer<typeof languageSelectorOverride>;
-
-/**
- * Render a `<nav class="caelo-language-selector">` with one `<a>`
- * per locale that has a published variant of the current page. Pure
- * function — caller threads the page's published-locale list and a
- * URL resolver. Used by `composePagePreview` (admin) and the static
- * generator (deploy) so byte-for-byte output parity holds.
- *
- * Per CMS_REQUIREMENTS §7.8: locales with no published variant for the
- * current page are excluded.
- */
-export function renderLanguageSelector(args: {
-  /** Each locale that has a published variant of the current page. */
-  readonly availableLocales: ReadonlyArray<{
-    code: string;
-    displayName: string;
-    href: string;
-    isCurrent: boolean;
-  }>;
-  /** Owner-supplied overrides (relabel a locale, hide one). */
-  readonly overrides?: ReadonlyArray<LanguageSelectorOverride>;
-}): string {
-  const overrideByLocale = new Map<string, LanguageSelectorOverride>(
-    (args.overrides ?? []).map((o) => [o.locale, o]),
-  );
-  const enc = (s: string): string =>
-    s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-  const items = args.availableLocales
-    .filter((l) => !overrideByLocale.get(l.code)?.hidden)
-    .map((l) => {
-      const override = overrideByLocale.get(l.code);
-      const label = override?.label ?? l.displayName;
-      const aria = l.isCurrent ? ' aria-current="true"' : "";
-      return `<a hreflang="${enc(l.code)}" lang="${enc(l.code)}" href="${enc(l.href)}"${aria}>${enc(label)}</a>`;
-    });
-  if (items.length === 0) return "";
-  return `<nav class="caelo-language-selector" aria-label="Language">${items.join("")}</nav>`;
-}