@cogenta/cli 0.2.2 → 0.4.0

package/dist/commands/theme-css.js

@@ -0,0 +1,121 @@
+/**
+ * The theme's stylesheet, flattened and minified for `cogenta serve`.
+ *
+ * `@cogenta/theme-canonical` ships `src/styles/theme.css` as three `@import`ed
+ * layers — tokens, base, blocks. A real Astro build flattens those; this
+ * fallback has no build, so it does the same one thing a bundler would and
+ * nothing more: resolve the relative imports, drop the comments, squeeze the
+ * whitespace. No rewriting of selectors, no reordering, no autoprefixing —
+ * anything cleverer than that would make the served CSS differ from the CSS the
+ * theme's own tests assert on.
+ *
+ * Until this existed, `cogenta serve` sent only the generated `--cogenta-*`
+ * custom properties and never the sheet that *uses* them, so every page was
+ * rendered by the browser's default stylesheet with a skin defined and unused.
+ */
+function squeeze(code) {
+    return (code
+        .replace(/\s+/g, ' ')
+        // Only around the three separators that can never be part of a value or a
+        // combinator. `:` is left alone: removing the space in `@media
+        // (min-width: 60rem)` is safe but removing it in a selector is not, and
+        // telling the two apart needs a parser this deliberately is not.
+        .replace(/\s*([{};,])\s*/g, '$1')
+        .replace(/;}/g, '}'));
+}
+/**
+ * One pass over the sheet, in which a comment, a string and code are three
+ * different things and none of them is found with a regular expression.
+ *
+ * Both halves of that matter and each was a real bug first: an apostrophe in a
+ * prose comment ("the editor's intent") opens a string for any scanner that
+ * looks at quotes before comments, and swallows the rest of the file; and a
+ * `content: " — "` whose spaces are squeezed loses the separator it draws.
+ */
+export function minifyCss(css) {
+    let out = '';
+    let code = '';
+    let index = 0;
+    while (index < css.length) {
+        if (css.startsWith('/*', index)) {
+            const end = css.indexOf('*/', index + 2);
+            index = end === -1 ? css.length : end + 2;
+            // A comment is whitespace, not nothing: `.a/* x */.b` must not become
+            // `.a.b`, which selects something else entirely.
+            code += ' ';
+            continue;
+        }
+        const character = css[index];
+        if (character !== '"' && character !== "'") {
+            code += character;
+            index += 1;
+            continue;
+        }
+        out += squeeze(code);
+        code = '';
+        let end = index + 1;
+        while (end < css.length && css[end] !== character) {
+            end += css[end] === '\\' ? 2 : 1;
+        }
+        out += css.slice(index, Math.min(end + 1, css.length));
+        index = end + 1;
+    }
+    return (out + squeeze(code)).trim();
+}
+const IMPORT = /@import\s+(?:url\()?["']([^"']+)["']\)?\s*;/g;
+/**
+ * Replaces every `@import "./x.css";` with the file's contents, recursively.
+ *
+ * Relative only, on purpose: a bare-specifier or `http(s)` import would let a
+ * theme's stylesheet pull in a third party at render time, which is exactly the
+ * kind of outside reach contract D refuses a theme elsewhere. Those are left
+ * untouched for the browser to refuse or fetch as it sees fit.
+ */
+export async function inlineImports(entry, options) {
+    const depth = options.depth ?? 8;
+    const css = await options.read(entry);
+    if (depth <= 0)
+        return css;
+    const parts = [];
+    let cursor = 0;
+    for (const match of css.matchAll(IMPORT)) {
+        const specifier = match[1];
+        if (!specifier.startsWith('.'))
+            continue;
+        const index = match.index ?? 0;
+        parts.push(css.slice(cursor, index));
+        parts.push(await inlineImports(new URL(specifier, entry), { read: options.read, depth: depth - 1 }));
+        cursor = index + match[0].length;
+    }
+    parts.push(css.slice(cursor));
+    return parts.join('\n');
+}
+/**
+ * The whole theme stylesheet as one minified string, or `null` when the theme
+ * package cannot be resolved — a site then renders with the skin's custom
+ * properties alone rather than refusing to serve, the same degradation
+ * `loadSkinCss` already chose for a missing `theme.tokens.json`.
+ */
+/**
+ * FNV-1a, 32 bits. A cache key, never a security boundary — and deliberately
+ * not `node:crypto`, to match the hash `@cogenta/render` already uses for the
+ * skin sheet's ETag rather than introduce a second convention beside it.
+ */
+export function cssEtag(css) {
+    let value = 0x811c9dc5;
+    for (let index = 0; index < css.length; index++) {
+        value ^= css.charCodeAt(index);
+        value = Math.imul(value, 0x01000193) >>> 0;
+    }
+    return `"${value.toString(16).padStart(8, '0')}"`;
+}
+export async function loadThemeCss(options) {
+    try {
+        const entry = new URL(import.meta.resolve('@cogenta/theme-canonical/styles/theme.css'));
+        return minifyCss(await inlineImports(entry, options));
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=theme-css.js.map

package/dist/commands/theme-css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-css.js","sourceRoot":"","sources":["../../src/commands/theme-css.ts"],"names":[],"mappings":"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"}

package/dist/commands/theme-render.d.ts

@@ -1,5 +1,6 @@
-import type { AccessContext, ContentGateway } from '@cogenta/api';
-import { type CollectionDefinition } from '@cogenta/schema';
+import { type AccessContext, type ContentGateway, type MenuRouter } from '@cogenta/api';
+import { type MediaAsset as RenderMediaAsset } from '@cogenta/render';
+import { type BlockZones, type CollectionDefinition } from '@cogenta/schema';
 /**
  * Real HTML for a matched route — the piece the lot's own gap notes named
  * honestly ("`cogenta build`/`theme` not built yet"): until a real Astro site
@@ -12,6 +13,8 @@ import { type CollectionDefinition } from '@cogenta/schema';
  * in-process. This is a deliberately scoped stand-in, not the Astro pipeline:
  * one theme, no build step, no static generation.
  */
+/** Where `cogenta serve` publishes image variants. Public: a visitor's browser fetches them. */
+export declare const DEFAULT_IMAGE_ENDPOINT = "/_image";
 export interface ThemeRenderOptions {
     readonly collections: readonly CollectionDefinition[];
     readonly gateway: ContentGateway;
@@ -21,9 +24,76 @@ export interface ThemeRenderOptions {
         readonly locales: readonly string[];
         readonly defaultLocale: string;
     };
-    /** `null` when the project has no `theme.tokens.json` — served unstyled rather than refused. */
-    readonly skinCss: string | null;
+    /**
+     * The whole stylesheet: the skin's generated `--cogenta-*` custom properties
+     * followed by the theme's own sheet, already flattened and minified (see
+     * `theme-css.ts`). `null` when neither could be loaded — served unstyled
+     * rather than refused.
+     *
+     * The sheet is *linked*, not inlined: only the presence of one is needed
+     * here, so that a site with no stylesheet emits no dead `<link>`.
+     */
+    readonly styles: string | null;
+    /**
+     * Loads the media a render references, in one batch, before rendering.
+     *
+     * It has to be a batch: `renderBlock` is pure and synchronous (contract D),
+     * and `@cogenta/seo`'s `SeoResolvers.media` is synchronous too, so neither
+     * `ctx.image()` nor an `og:image` can await a lookup. Which ids a page
+     * needs is answered by `collectDependencies` — the same walk `/api/content`
+     * already uses to declare a response's media dependencies — rather than by
+     * a fresh heuristic over block JSON.
+     *
+     * Absent means no images: `ctx.image()` refuses clearly, exactly as it did
+     * before the pipeline existed.
+     */
+    readonly loadMedia?: (ids: readonly string[]) => Promise<ReadonlyMap<string, RenderMediaAsset>>;
+    /** Where image variants are served from. Defaults to `/_image`. */
+    readonly imageEndpoint?: string;
+    /**
+     * Self-hosted, cookie-free page-view analytics (`@cogenta/analytics`, L10
+     * analytics gap). The `Referer` header of *this* request — the theme's own
+     * `<script>`-free policy (see `serve.test.ts`, "no executable client
+     * JavaScript anywhere on the page") rules out reading `document.referrer`
+     * from an inline script, so the referrer this page was reached from is
+     * read server-side, from the request that is rendering it, and baked
+     * straight into a collection `<img>` pixel — no client code needed to
+     * capture it (see `analyticsBeaconTag` below).
+     *
+     * Absent entirely means the beacon is left out of the page altogether.
+     * Callers pass `{}` (no `referrer`) rather than leaving this out when there
+     * is simply no `Referer` header to report — the page builder's draft
+     * preview does that, since its request is a `POST` with no navigation
+     * referrer of its own, and doing so keeps its `<body>` byte-identical to
+     * the published page's (`serve-builder.test.ts`'s fidelity test) rather
+     * than carving out an exception that would itself become a body difference.
+     */
+    readonly analyticsBeacon?: {
+        readonly referrer?: string | undefined;
+    };
+    /**
+     * Wires `GET /api/menus/by-name/{name}` into the render pipeline (audit
+     * follow-up to L13's menu system: the backend, API and admin were complete
+     * and tested, but no menu ever reached the public theme). Called
+     * in-process, through the very same `MenuRouter` `/api/menus/*` is mounted
+     * with — never a second lookup path.
+     *
+     * Convention (undeclared by contract A or D, since navigation is not
+     * content): a menu named `main` renders in the header, one named `footer`
+     * renders in the footer. A site with neither keeps today's empty slots;
+     * one with only `main` gets no footer navigation, and so on.
+     *
+     * Absent means no menu lookup at all — the same empty slots as before this
+     * was wired.
+     */
+    readonly menuRouter?: MenuRouter;
 }
+/**
+ * Where the served stylesheet lives. Under `/_cogenta/` for the same reason
+ * `Base.astro` puts the skin there: it is a namespace no collection route can
+ * ever claim, since every route pattern starts from a collection's own path.
+ */
+export declare const STYLESHEET_PATH = "/_cogenta/styles.css";
 /**
  * Resolves `pathname` against the site's real routes and renders the real
  * page, or returns `null` — never for "matched but nothing found", only for
@@ -32,6 +102,38 @@ export interface ThemeRenderOptions {
  * gets.
  */
 export declare function renderRequestedPage(pathname: string, options: ThemeRenderOptions, context: AccessContext): Promise<string | null>;
+/**
+ * An entry that is not what the database holds — the block list an editor has
+ * on screen and has not saved yet.
+ *
+ * `blocks` is the whole zone map, exactly the shape the admin already keeps
+ * and already sends to `PUT /api/content/:collection/:id`; nothing here is a
+ * second, builder-only serialisation of a page.
+ */
+export interface DraftPage {
+    readonly collection: string;
+    readonly entryId: string;
+    readonly blocks: BlockZones;
+    /** Only the typed fields that changed. Absent fields keep the stored value. */
+    readonly values?: Readonly<Record<string, unknown>>;
+}
+/**
+ * Renders an in-progress draft through the *same* function that renders the
+ * published page — the single reason this export exists.
+ *
+ * The visual page builder (L16 task 1) shows this HTML in an iframe rather
+ * than re-implementing the twelve blocks in React. The whole point of that
+ * choice is that there is no second renderer to drift, so this must not
+ * become one: it reads the stored entry through the same permission-checked
+ * gateway, overlays the unsaved blocks and values on it, and then hands the
+ * result to `renderEntryPage` unchanged. Handed a draft that equals what is
+ * stored, it returns the published page byte for byte — which is exactly what
+ * `theme-render-fidelity.test.ts` asserts.
+ *
+ * `null` means the entry does not exist or this actor may not read it. The
+ * caller turns both into the same 404, and neither says which.
+ */
+export declare function renderDraftPage(draft: DraftPage, options: ThemeRenderOptions, context: AccessContext): Promise<string | null>;
 /**
  * Reads `theme.tokens.json` next to the config and renders it through the
  * real, already-tested `renderSkin` (contract D validation + `--cogenta-*`
@@ -39,4 +141,13 @@ export declare function renderRequestedPage(pathname: string, options: ThemeRend
  * invalid tokens degrade to unstyled HTML rather than refusing to serve.
  */
 export declare function loadSkinCss(readFile: (path: string) => Promise<string>, tokensPath: string): Promise<string | null>;
+/**
+ * The two sheets a page needs, in the only order that works: the skin's
+ * generated custom properties first, then the theme's stylesheet that reads
+ * them. Either half may be missing — a project with no `theme.tokens.json`
+ * still gets the theme's layout, and a theme package that cannot be resolved
+ * still gets the skin's properties — and a page with neither is served
+ * unstyled rather than refused.
+ */
+export declare function joinStyles(skinCss: string | null, themeCss: string | null): string | null;
 //# sourceMappingURL=theme-render.d.ts.map

package/dist/commands/theme-render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"theme-render.d.ts","sourceRoot":"","sources":["../../src/commands/theme-render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAwB,MAAM,cAAc,CAAA;AAIvF,OAAO,EAAa,KAAK,oBAAoB,EAAgC,MAAM,iBAAiB,CAAA;AAgEpG;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,WAAW,EAAE,SAAS,oBAAoB,EAAE,CAAA;IACrD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,QAAQ,CAAC,IAAI,EAAE;QACb,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;QACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;QACpB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;QACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;KAC/B,CAAA;IACD,gGAAgG;IAChG,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAChC;AA0GD;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmHxB;AAED;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,EAC3C,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAOxB"}
+{"version":3,"file":"theme-render.d.ts","sourceRoot":"","sources":["../../src/commands/theme-render.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,cAAc,EAGnB,KAAK,UAAU,EAEhB,MAAM,cAAc,CAAA;AAGrB,OAAO,EAAiB,KAAK,UAAU,IAAI,gBAAgB,EAAc,MAAM,iBAAiB,CAAA;AAChG,OAAO,EACL,KAAK,UAAU,EAEf,KAAK,oBAAoB,EAG1B,MAAM,iBAAiB,CAAA;AAqExB;;;;;;;;;;;GAWG;AAEH,gGAAgG;AAChG,eAAO,MAAM,sBAAsB,YAAY,CAAA;AAE/C,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,WAAW,EAAE,SAAS,oBAAoB,EAAE,CAAA;IACrD,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,QAAQ,CAAC,IAAI,EAAE;QACb,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;QACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;QACpB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;QACnC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAA;KAC/B,CAAA;IACD;;;;;;;;OAQG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAA;IAC/F,mEAAmE;IACnE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAC/B;;;;;;;;;;;;;;;;;OAiBG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,CAAA;IACrE;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAA;CACjC;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,yBAAyB,CAAA;AA2LrD;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAIxB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;IAC3B,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACpD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA6BxB;AAqQD;;;;;GAKG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,EAC3C,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAOxB;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAMzF"}

package/dist/commands/theme-render.js

@@ -1,7 +1,10 @@
+import { collectDependencies, } from '@cogenta/api';
 import { CogentaError } from '@cogenta/core';
-import { renderSkin } from '@cogenta/render';
-import { buildPath, matchPath } from '@cogenta/schema';
-import { query as collectionListQuery, renderPage, serialize, } from '@cogenta/theme-canonical';
+import { describeMedia, renderSkin } from '@cogenta/render';
+import { buildPath, matchPath, } from '@cogenta/schema';
+import { query as collectionListQuery, escapeAttribute, escapeText, renderPage, serialize, } from '@cogenta/theme-canonical';
+import { alternatesForEntry, renderSeoHead, seoSiteFor } from './seo.js';
+import { minifyCss } from './theme-css.js';
 /**
  * The theme's own `ContentEntry`/`QueryRequest` (`theme-contract.ts`) are a
  * deliberately separate, minimal public contract — a theme never imports
@@ -46,6 +49,26 @@ async function listAsTheme(gateway, request, context) {
         nextCursor: page.nextCursor,
     };
 }
+/**
+ * Real HTML for a matched route — the piece the lot's own gap notes named
+ * honestly ("`cogenta build`/`theme` not built yet"): until a real Astro site
+ * exists (ADR-0008, contract D's actual intended delivery plane), `cogenta
+ * serve` renders the one theme this codebase has, `@cogenta/theme-canonical`,
+ * directly against the same permission-checked `ContentGateway` every REST
+ * and GraphQL request already goes through. No secret, config or DB handle
+ * ever reaches theme code — only the same `ContentEntry` shape a real HTTP
+ * client would receive, so the data boundary R5 cares about holds even
+ * in-process. This is a deliberately scoped stand-in, not the Astro pipeline:
+ * one theme, no build step, no static generation.
+ */
+/** Where `cogenta serve` publishes image variants. Public: a visitor's browser fetches them. */
+export const DEFAULT_IMAGE_ENDPOINT = '/_image';
+/**
+ * Where the served stylesheet lives. Under `/_cogenta/` for the same reason
+ * `Base.astro` puts the skin there: it is a namespace no collection route can
+ * ever claim, since every route pattern starts from a collection's own path.
+ */
+export const STYLESHEET_PATH = '/_cogenta/styles.css';
 function fieldOfKind(collection, kind) {
     return Object.entries(collection.fields).find(([, field]) => field.kind === kind)?.[0];
 }
@@ -77,9 +100,58 @@ function toVocabularyBlocks(entry, collection) {
     ];
 }
 function entryTitle(entry) {
-    const value = entry.values['title'];
+    const value = entry.values.title;
     return typeof value === 'string' && value.trim() !== '' ? value : entry.id;
 }
+/**
+ * Looks a menu up by name, through the exact same `MenuRouter` `/api/menus/*`
+ * is mounted with — an in-process call, `RestRequest` in and `RestResponse`
+ * out, never a second lookup path or a real HTTP round trip to itself.
+ *
+ * `null` for "no menu router wired" and "no menu by that name" alike: both
+ * mean the slot renders empty, exactly as it always has.
+ */
+async function fetchMenuLinks(name, locale, options, context) {
+    if (options.menuRouter === undefined)
+        return null;
+    const response = await options.menuRouter.handle({ method: 'GET', path: `/api/menus/by-name/${encodeURIComponent(name)}`, query: { locale } }, context);
+    if (response.status !== 200)
+        return null;
+    const body = response.body;
+    const items = body?.data?.items;
+    if (!Array.isArray(items))
+        return null;
+    return items.map((item) => ({
+        label: item.resolvedLabel ?? item.label,
+        href: item.kind === 'url' ? item.url : item.kind === 'entry' ? (item.resolvedRoute ?? null) : null,
+        openInNewTab: item.openInNewTab,
+    }));
+}
+/**
+ * A flat list of links (task 2's documented MVP): every item of the menu, in
+ * the order the store returns them, regardless of `parent`/`depth`. A real
+ * sub-menu render is left for later — the hierarchy is already in the data
+ * (`parent`, `depth`), so nothing here would need to change to add it, only
+ * this function's markup.
+ *
+ * `null`/empty renders nothing: the caller's slot stays exactly as empty as
+ * it was before this was wired, for a site with no menu by that name.
+ */
+function renderMenuLinks(links) {
+    if (links === null || links.length === 0)
+        return '';
+    const items = links
+        .map((link) => {
+        const label = escapeText(link.label);
+        if (link.href === null)
+            return `<li><span>${label}</span></li>`;
+        const href = escapeAttribute(link.href);
+        const target = link.openInNewTab ? ' target="_blank" rel="noopener"' : '';
+        return `<li><a href="${href}"${target}>${label}</a></li>`;
+    })
+        .join('');
+    return `<ul class="cg-menu">${items}</ul>`;
+}
 async function fetchOne(gateway, request, context) {
     const page = await gateway.list({ ...request, limit: 1 }, context);
     return page.items[0] ?? null;
@@ -136,7 +208,50 @@ export async function renderRequestedPage(pathname, options, context) {
     const resolved = await resolveEntry(pathname, options, context);
     if (resolved === null)
         return null;
-    const { collection, entry } = resolved;
+    return renderEntryPage(pathname, resolved.collection, resolved.entry, options, context);
+}
+/**
+ * Renders an in-progress draft through the *same* function that renders the
+ * published page — the single reason this export exists.
+ *
+ * The visual page builder (L16 task 1) shows this HTML in an iframe rather
+ * than re-implementing the twelve blocks in React. The whole point of that
+ * choice is that there is no second renderer to drift, so this must not
+ * become one: it reads the stored entry through the same permission-checked
+ * gateway, overlays the unsaved blocks and values on it, and then hands the
+ * result to `renderEntryPage` unchanged. Handed a draft that equals what is
+ * stored, it returns the published page byte for byte — which is exactly what
+ * `theme-render-fidelity.test.ts` asserts.
+ *
+ * `null` means the entry does not exist or this actor may not read it. The
+ * caller turns both into the same 404, and neither says which.
+ */
+export async function renderDraftPage(draft, options, context) {
+    const collection = options.collections.find((entry) => entry.name === draft.collection);
+    if (collection === undefined)
+        return null;
+    const stored = await options.gateway.read(draft.collection, draft.entryId, context);
+    if (stored === null)
+        return null;
+    const entry = {
+        ...stored,
+        values: { ...stored.values, ...(draft.values ?? {}) },
+        blocks: draft.blocks,
+    };
+    // The path the entry really lives at, built from the same `buildPath` the
+    // public route uses — never a synthetic `/preview/...` URL. A canonical
+    // link, an `og:url` and a `collectionList` link all have to come out of
+    // this render identical to the published page's, and they are all derived
+    // from this one string.
+    const pathname = buildPath(collection, Object.fromEntries(Object.entries(entry.values).filter((pair) => typeof pair[1] === 'string')), entry.locale ?? undefined);
+    return renderEntryPage(pathname, collection, entry, options, context);
+}
+/**
+ * The one page renderer. Both `renderRequestedPage` (published) and
+ * `renderDraftPage` (unsaved) end here, having only differed in how they got
+ * hold of an entry.
+ */
+async function renderEntryPage(pathname, collection, entry, options, context) {
     const blocks = toVocabularyBlocks(entry, collection);
     // Every entry a `collectionList` block needs is fetched up front — the
     // theme's own contract (`FetchedEntries`, `render-block.ts`) requires it:
@@ -145,16 +260,39 @@ export async function renderRequestedPage(pathname, options, context) {
     // either.
     const fetchedEntries = {};
     const knownEntries = new Map([[entry.id, entry]]);
+    /** Which collection each known entry came from — a `ContentEntry` does not say. */
+    const entryCollections = new Map([[entry.id, collection.name]]);
     for (const block of blocks) {
         if (block._type !== 'collectionList')
             continue;
         const themeQuery = collectionListQuery(block);
         const results = await options.gateway.list(toApiQueryRequest(themeQuery), context);
         fetchedEntries[block._key] = results.items.map((found) => toThemeEntry(found, themeQuery.collection));
-        for (const found of results.items)
+        for (const found of results.items) {
             knownEntries.set(found.id, found);
+            entryCollections.set(found.id, themeQuery.collection);
+        }
     }
     const collectionsByName = new Map(options.collections.map((entry) => [entry.name, entry]));
+    // Which media this page references, from the same walk `/api/content` uses
+    // to declare a response's dependencies (`collectDependencies`): declared
+    // `media` fields *and* the media inside every block, resolved through the
+    // block registry rather than guessed at from the JSON. A `ContentEntry`
+    // plus its collection name is exactly a `SerialisedEntry`, which is why
+    // this reuse costs nothing.
+    const mediaAssets = new Map();
+    if (options.loadMedia !== undefined) {
+        const dependencies = collectDependencies([...knownEntries].map(([id, found]) => ({
+            ...found,
+            collection: entryCollections.get(id) ?? collection.name,
+        })), { collection: (name) => collectionsByName.get(name) });
+        if (dependencies.media.length > 0) {
+            for (const [id, asset] of await options.loadMedia(dependencies.media)) {
+                mediaAssets.set(id, asset);
+            }
+        }
+    }
+    const imageEndpoint = options.imageEndpoint ?? DEFAULT_IMAGE_ENDPOINT;
     const link = (target) => {
         if (typeof target === 'string')
             return target;
@@ -176,14 +314,23 @@ export async function renderRequestedPage(pathname, options, context) {
         locale: entry.locale,
         url: new URL(pathname, options.site.url),
         t: (key) => key,
-        // No image pipeline exists yet (`@cogenta/render`'s `images/`) wired to
-        // this in-process path — a theme that asks for one gets a clear refusal,
-        // not a broken <img>.
-        image: () => {
-            throw new CogentaError({
-                code: 'THEME_IMAGE_UNSUPPORTED',
-                message: 'cogenta serve cannot render images yet.',
-                hint: 'No image pipeline is wired into this in-process rendering fallback (no real Astro build exists yet). Avoid mediaFigure/gallery blocks until it is.',
+        // The real `srcset`, from `@cogenta/render`'s own `describeMedia` (L10
+        // task 5). Pure and synchronous, as contract D requires: the asset was
+        // loaded before this render started, and this only builds URLs against
+        // the variants the upload already wrote.
+        image: (media, imageOptions) => {
+            const asset = mediaAssets.get(media);
+            if (asset === undefined) {
+                throw new CogentaError({
+                    code: 'THEME_IMAGE_UNSUPPORTED',
+                    message: `No media asset "${media}" is available to this render.`,
+                    hint: 'The image must be referenced by a media field or a block of this page — those are the ones loaded before rendering. Check that the asset still exists in the media library.',
+                    details: { media },
+                });
+            }
+            return describeMedia(asset, imageOptions ?? {}, {
+                endpoint: imageEndpoint,
+                mediaEndpoint: imageEndpoint,
             });
         },
         link,
@@ -219,20 +366,101 @@ export async function renderRequestedPage(pathname, options, context) {
     const pageContent = { title: entryTitle(entry), blocks };
     const node = renderPage(pageContent, themeContext, fetchedEntries);
     const bodyHtml = serialize(node);
+    // The head is `@cogenta/seo`'s, not this file's: title, description,
+    // canonical, hreflang, Open Graph, Twitter Card and JSON-LD, all derived
+    // from the real entry and the real collection (L10 task 1). Nothing here
+    // decides what is indexable — `buildMetaTags` asks `isPublished` itself, so
+    // a preview render carries `noindex` without this caller remembering to.
+    const seoSite = seoSiteFor(options.site);
+    const resource = { collection, entry };
+    const alternates = await alternatesForEntry(seoSite, collection, entry, options.gateway, context, options.site.locales);
+    // `og:image` and JSON-LD's `image` come from the same assets the page just
+    // rendered, resolved to an absolute URL — a social crawler never sends a
+    // session and never follows a relative path.
+    const seoMedia = (id) => {
+        const asset = mediaAssets.get(id);
+        if (asset === undefined || asset.kind !== 'image')
+            return null;
+        if (asset.width === undefined || asset.height === undefined)
+            return null;
+        const source = describeMedia(asset, {}, { endpoint: imageEndpoint, mediaEndpoint: imageEndpoint });
+        return {
+            url: new URL(source.src, options.site.url).toString(),
+            width: source.width,
+            height: source.height,
+            ...(source.alt === '' ? {} : { alt: source.alt }),
+        };
+    };
+    // `head` already carries a real `<title>` (`renderSeoHead`, above) — no
+    // second one is written into the template below.
+    const head = renderSeoHead(seoSite, resource, {
+        ...(alternates.length === 0 ? {} : { alternates }),
+        ...(mediaAssets.size === 0 ? {} : { media: seoMedia }),
+    });
+    const siteName = escapeAttribute(options.site.name);
+    // The navigation menus (audit follow-up to L13's menu system): `main` in
+    // the header, `footer` in the footer — see `ThemeRenderOptions.menuRouter`
+    // for the convention and why it lives here rather than in contract A/D.
+    // Both are `null`, rendering nothing, on a site with no menu router wired
+    // or no menu by that name — the same empty slots as before this was wired.
+    const [headerMenu, footerMenu] = await Promise.all([
+        fetchMenuLinks('main', themeContext.locale, options, context),
+        fetchMenuLinks('footer', themeContext.locale, options, context),
+    ]);
+    const headerNav = renderMenuLinks(headerMenu);
+    const footerNav = renderMenuLinks(footerMenu);
+    // The same frame `Base.astro` builds for a real Astro build: a skip link
+    // first, the site name as a header, the content, a footer. Rendering the
+    // `<main>` alone — which this did until the theme's own stylesheet started
+    // being served — left every page with no landmark to skip to and no way back
+    // to the home page.
     return `<!doctype html>
-<html lang="${themeContext.locale}">
+<html lang="${themeContext.locale}" dir="auto">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>${pageContent.title} — ${options.site.name}</title>
-${options.skinCss === null ? '' : `<style>${options.skinCss}</style>`}
+<meta name="color-scheme" content="light dark">
+${head}
+${options.styles === null ? '' : `<link rel="stylesheet" href="${STYLESHEET_PATH}">`}
 </head>
 <body>
+<a class="cg-skip-link" href="#cg-main">Skip to content</a>
+<header class="cg-site-header"><div class="cg-site-header__inner"><a class="cg-site-header__home" href="/">${siteName}</a>${headerNav === '' ? '' : `<nav class="cg-site-header__nav" aria-label="Primary">${headerNav}</nav>`}</div></header>
 ${bodyHtml}
+<footer class="cg-site-footer"><div class="cg-site-footer__inner"><span>${siteName}</span>${footerNav === '' ? '' : `<nav class="cg-site-footer__nav" aria-label="Footer">${footerNav}</nav>`}</div></footer>
+${analyticsBeaconTag(pathname, options.analyticsBeacon)}
 </body>
 </html>
 `;
 }
+/**
+ * Self-hosted, cookie-free page-view analytics (`@cogenta/analytics`), L10
+ * analytics gap. An invisible `<img>` pixel rather than any inline
+ * `<script>`: the theme's own policy is **zero executable client
+ * JavaScript** on a rendered page (enforced by `serve.test.ts`), so a script
+ * reading `document.referrer` is not an option here. Everything the pixel's
+ * URL needs — the path being viewed, and the `Referer` header of the request
+ * that is rendering this very page — is already known server-side, so
+ * nothing needs to run in the browser to capture it.
+ *
+ * `undefined` (no `analyticsBeacon` at all) omits the tag entirely — used
+ * for the page builder's draft preview, which must not be counted as a real
+ * visit. `alt=""` and the visually-hidden inline style keep it out of a
+ * screen reader and off the visible page without `display:none`, which some
+ * older ad-blocking heuristics treat as a signal to strip the element (and
+ * losing the pixel loses nothing here — it fails silently either way, R1/R2
+ * spirit: analytics is additive, never load-bearing).
+ */
+function analyticsBeaconTag(pathname, beacon) {
+    if (beacon === undefined)
+        return '';
+    const params = new URLSearchParams({ p: pathname });
+    if (beacon.referrer !== undefined && beacon.referrer !== '') {
+        params.set('r', beacon.referrer);
+    }
+    const src = escapeAttribute(`/api/analytics/beacon?${params.toString()}`);
+    return `<img src="${src}" alt="" width="1" height="1" loading="eager" decoding="async" style="position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0;">`;
+}
 /**
  * Reads `theme.tokens.json` next to the config and renders it through the
  * real, already-tested `renderSkin` (contract D validation + `--cogenta-*`
@@ -248,4 +476,19 @@ export async function loadSkinCss(readFile, tokensPath) {
         return null;
     }
 }
+/**
+ * The two sheets a page needs, in the only order that works: the skin's
+ * generated custom properties first, then the theme's stylesheet that reads
+ * them. Either half may be missing — a project with no `theme.tokens.json`
+ * still gets the theme's layout, and a theme package that cannot be resolved
+ * still gets the skin's properties — and a page with neither is served
+ * unstyled rather than refused.
+ */
+export function joinStyles(skinCss, themeCss) {
+    const sheets = [
+        skinCss === null ? null : minifyCss(skinCss),
+        themeCss === null ? null : minifyCss(themeCss),
+    ].filter((sheet) => sheet !== null);
+    return sheets.length === 0 ? null : sheets.join('\n');
+}
 //# sourceMappingURL=theme-render.js.map