@kywi-software/core 0.15.0 → 0.15.1

package/dist/ax/layout-to-html.d.ts

@@ -0,0 +1,127 @@
+import type { ModuleRegistry } from '../layout/registry.js';
+import type { ComponentDetachSource } from '../layout/component-refs.js';
+/**
+ * layout-to-html.ts — the AX layer's projection of a stored LAYOUT DOCUMENT
+ * into semantic HTML (kywi-cms#195).
+ *
+ * WHY THIS EXISTS. Every AX surface (llms-full.txt, `/<path>.md`, the summary
+ * fallback chain, JSON-LD descriptions) reads a node's `body` column. A page
+ * composed in the layout editor — i.e. every page on a real Kywi site — has an
+ * empty or seed `body`, so those surfaces exported a title and a URL and nothing
+ * else. The page's actual copy lives in `layout`, and this is the one function
+ * that reads it out.
+ *
+ * It is PURE and DETERMINISTIC: same document in, same string out, no database,
+ * no React, no language model (the Tier-1 boundary). Callers that can resolve
+ * saved components and custom modules pass them in through {@link
+ * LayoutToHtmlOptions}; a caller with neither still gets every built-in
+ * module's copy.
+ *
+ * ─── THE SERIALIZATION RULES ────────────────────────────────────────────────
+ *
+ * READING ORDER. `layout.regions` in stored key order, each region's nodes in
+ * order, each section's columns left to right, each column's nodes top to
+ * bottom. `pageVariants` and `abExperiments` are NOT walked: they are alternate
+ * versions of the page, and an agent corpus that concatenated them would present
+ * contradictory copy as one document.
+ *
+ * THE ARM AN ANONYMOUS VISITOR IS SERVED. Both container kinds are resolved
+ * through `selectVariantArm(arms, container, null)` — the same precedence the
+ * renderer applies, with no personalization state. That answers Default for a
+ * personalization container and for a running experiment, and the WINNING ARM
+ * for an `ab_test` whose winner is locked, because a locked winner IS the public
+ * page: every visitor gets it, so exporting Default there would publish copy
+ * nobody can see. A targeted audience arm is never reachable without a resolved
+ * audience, so audience-specific copy can never leak into a public corpus.
+ *
+ * COMPONENTS. Linked placements (`componentId` on a module/section/container)
+ * are resolved through {@link resolveComponentPlacements} — the same
+ * materialisation the renderer and detach use — so the projection shows what the
+ * page shows, not the stale inline fallback copy. A `component` MODULE
+ * placement resolves through the same hook by `props.componentId` (or
+ * `props.slug`), or emits its pre-hydrated `props.content` when the host already
+ * filled it in. Unresolvable placements emit nothing, and resolution is
+ * cycle-guarded.
+ *
+ * ROBUSTNESS. Every walk site goes through {@link asArray}/{@link isRecord}, and
+ * component pre-resolution is wrapped. `setContentLayout` stores what it is
+ * handed — validation lives on the write ROUTES — so malformed documents exist
+ * in the wild (a hand-written INSERT, a restored dump, a pre-validation row),
+ * and these projections run on PUBLIC surfaces: `/search`, `llms-full.txt`,
+ * `/<slug>.md`, per-page JSON-LD. A `TypeError` here would be a 500 on all four,
+ * so a broken subtree is skipped and the sound part of the document still
+ * exports. Expansion is bounded three ways: a visited set (cycles), a depth cap,
+ * and an output budget (a diamond of components re-expands exponentially).
+ *
+ * MODULES. Built-ins with copy get a hand-written emitter (below). Anything else
+ * the registry knows — a CUSTOM module, or a built-in with no emitter — is
+ * serialized from its registered prop schema: the first `text` prop becomes an
+ * `<h2>`, every other `text`/`textarea` prop a `<p>`, every `richText` prop its
+ * (sanitized) HTML. Values that look like JSON are skipped, since a
+ * `textarea`-typed prop is how the palette stores structured item lists.
+ * Reference props are skipped too — a link target, id, slug or class named by a
+ * `text` prop because the palette has no reference type (`ctaHref`,
+ * `experimentId`, `feedSlug`) is a destination, not copy. A module the registry
+ * does not know is skipped SILENTLY — a host's unregistered module is not an
+ * error, it just has no schema to read.
+ *
+ * DELIBERATELY SKIPPED: `html` and `embed` (arbitrary markup, not authored
+ * copy), `form`/`formEmbed` (interaction, not content), every navigation and
+ * search module (site chrome repeated on every page, already covered by
+ * llms.txt/sitemap.xml), `cookieConsent` (compliance chrome), the pure-layout
+ * modules (`section`, `container`, `columns`, `spacer`, `divider`), and the
+ * decorative/interactive ones with no standalone copy (`icon`, `video`,
+ * `carousel`, `tagCloud`, `countdown`, `map`, `socialShare`, `categoryList`,
+ * `comments`, `personalizationBadge`, the retired `variantContainer` module).
+ *
+ * IMAGES emit their alt text as `<p><em>alt</em></p>` and their caption as a
+ * paragraph — the only human-readable copy an image carries — and nothing at all
+ * when both are empty. The image itself is not linked: an AX corpus is text.
+ *
+ * `feedDisplay` emits only its heading, when it has one: its items are other
+ * published nodes, which appear in the corpus in their own right.
+ */
+/**
+ * Resolve a saved component for the projection, by id (a linked placement) or by
+ * slug/name (a `component` module placement). Returns null/undefined when the
+ * component cannot be resolved — the placement is then skipped.
+ *
+ * The production implementation lives in the DB-backed AX content source; unit
+ * tests pass a plain map lookup.
+ */
+export type AxComponentResolver = (ref: {
+    componentId?: string;
+    slug?: string;
+}) => ComponentDetachSource | null | undefined;
+export interface LayoutToHtmlOptions {
+    /**
+     * The site's module registry, so CUSTOM modules serialize from their declared
+     * prop schema. Defaults to the built-ins alone.
+     */
+    modules?: ModuleRegistry;
+    /** Resolve saved components. Omitted → component placements emit nothing. */
+    resolveComponent?: AxComponentResolver;
+}
+/**
+ * Serialize a stored layout document to semantic HTML in reading order.
+ * Returns `''` for a null/empty/unrecognizable document.
+ */
+export declare function layoutToHtml(layout: unknown, opts?: LayoutToHtmlOptions): string;
+/**
+ * The module registry for a config's `modules`, memoised on the array itself.
+ *
+ * The per-NODE surfaces — `/<path>.md`, per-page JSON-LD — are handed a node by
+ * the host rather than by the AX content source, so nothing precomputed their
+ * layout projection and they must build the registry themselves. Doing it
+ * unmemoised would rebuild a ~45-entry map on every request; the config's
+ * `modules` array is a stable object for the process's lifetime, so it keys the
+ * cache exactly.
+ *
+ * NOTE what this deliberately does NOT carry: a component resolver. Resolving a
+ * saved component is a database read, and these two surfaces are synchronous and
+ * DB-free by contract. A linked placement on a node that did not come through
+ * the content source therefore contributes its inline fallback copy — the same
+ * copy the renderer falls back to when a link cannot be resolved.
+ */
+export declare function registryForModules(modules: unknown): ModuleRegistry;
+//# sourceMappingURL=layout-to-html.d.ts.map

package/dist/ax/layout-to-html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-to-html.d.ts","sourceRoot":"","sources":["../../src/ax/layout-to-html.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAE3D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAA;AAaxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AAIH;;;;;;;GAOG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAChC,GAAG,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,KACzC,qBAAqB,GAAG,IAAI,GAAG,SAAS,CAAA;AAE7C,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,OAAO,CAAC,EAAE,cAAc,CAAA;IACxB,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,mBAAmB,CAAA;CACvC;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,GAAE,mBAAwB,GAAG,MAAM,CAiCpF;AAibD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,cAAc,CAOnE"}

package/dist/ax/layout-to-html.js

@@ -0,0 +1,545 @@
+import { sanitizeHtml } from '../util/sanitize.js';
+import { createModuleRegistry } from '../layout/registry.js';
+import { resolveComponentPlacements } from '../layout/component-refs.js';
+import { isModuleVariantContainer } from '../layout/types.js';
+import { selectVariantArm } from '../layout/variant-selection.js';
+/**
+ * Serialize a stored layout document to semantic HTML in reading order.
+ * Returns `''` for a null/empty/unrecognizable document.
+ */
+export function layoutToHtml(layout, opts = {}) {
+    const doc = asLayoutDocument(layout);
+    if (!doc)
+        return '';
+    const resolver = opts.resolveComponent;
+    // Pre-resolve linked placements exactly as the renderer does, so the
+    // projection reads the definition rather than a placement's fallback copy.
+    // A malformed subtree (or a resolver that throws) degrades to the UNRESOLVED
+    // document rather than to no output at all — the inline fallback copy a
+    // placement carries is still the page's copy.
+    let resolved = doc;
+    if (resolver) {
+        try {
+            resolved = resolveComponentPlacements(doc, (componentId) => resolver({ componentId }));
+        }
+        catch {
+            resolved = doc;
+        }
+    }
+    const ctx = {
+        registry: opts.modules ?? builtInRegistry(),
+        ...(resolver ? { resolveComponent: resolver } : {}),
+        visitedComponents: new Set(),
+        depth: 0,
+    };
+    const sink = createSink();
+    if (isRecord(resolved.regions)) {
+        for (const nodes of Object.values(resolved.regions)) {
+            for (const node of asArray(nodes))
+                emitRegionNode(node, ctx, sink);
+        }
+    }
+    return sink.blocks.join('\n');
+}
+// ─── Output sink (the budget lives here) ─────────────────────────────────────
+/**
+ * Total characters one projection may emit. Generous for any real page (a long
+ * article body is a few tens of KB) and small enough that a pathological
+ * document — a deep diamond of components, a machine-generated layout — cannot
+ * turn one uncached `/search` hit into a memory event.
+ */
+const MAX_OUTPUT_CHARS = 262_144;
+function createSink() {
+    const blocks = [];
+    let used = 0;
+    return {
+        blocks,
+        push(html) {
+            if (used >= MAX_OUTPUT_CHARS)
+                return;
+            blocks.push(html);
+            used += html.length + 1;
+        },
+        full() {
+            return used >= MAX_OUTPUT_CHARS;
+        },
+    };
+}
+// ─── Walking ──────────────────────────────────────────────────────────────────
+/** How many component expansions may nest before the walk gives up. */
+const MAX_COMPONENT_DEPTH = 10;
+function emitRegionNode(node, ctx, out) {
+    if (!isRecord(node) || out.full())
+        return;
+    if (node.type === 'section') {
+        emitSection(node, ctx, out);
+        return;
+    }
+    if (node.type === 'variantContainer') {
+        for (const section of servedSections(node)) {
+            emitSection(section, ctx, out);
+        }
+    }
+}
+/**
+ * The sections a section-level container serves an anonymous visitor: the
+ * locked winner's arm for an `ab_test`, otherwise Default. `selectVariantArm` is
+ * the renderer's own precedence — one implementation, so the corpus and the page
+ * cannot disagree about which arm is public.
+ */
+function servedSections(container) {
+    const arms = asArray(container.variants);
+    const arm = selectVariantArm(arms, container, null);
+    return arm ? asArray(arm.sections) : asArray(container.defaultSections);
+}
+/** {@link servedSections} for a MODULE-level container: one module, not sections. */
+function servedModule(container) {
+    const arms = asArray(container.variants);
+    const arm = selectVariantArm(arms, container, null);
+    return arm ? arm.module : container.defaultModule;
+}
+function emitSection(section, ctx, out) {
+    if (!isRecord(section) || out.full())
+        return;
+    for (const column of asArray(section.columns)) {
+        if (!isRecord(column))
+            continue;
+        for (const node of asArray(column['nodes']))
+            emitColumnNode(node, ctx, out);
+    }
+}
+function emitColumnNode(node, ctx, out) {
+    if (!isRecord(node) || out.full())
+        return;
+    if (isModuleVariantContainer(node)) {
+        emitModule(servedModule(node), ctx, out);
+        return;
+    }
+    emitModule(node, ctx, out);
+}
+function emitModule(node, ctx, out) {
+    if (!isRecord(node) || typeof node.type !== 'string' || out.full())
+        return;
+    const props = isRecord(node.props) ? node.props : {};
+    if (node.type === 'component') {
+        emitComponentPlacement(props, ctx, out);
+        return;
+    }
+    emitModuleOfType(node.type, props, ctx, out);
+}
+function emitModuleOfType(type, props, ctx, out) {
+    const entry = ctx.registry.get(type);
+    // A host that OVERRIDES a built-in name owns its prop shape, so the built-in
+    // emitter would be reading props that no longer exist. Its declared schema is
+    // the only trustworthy description of it.
+    //
+    // This runs BEFORE the skip list on purpose: the skip list describes KYWI's
+    // built-ins, and a host that registers its own `video` (with a transcript) or
+    // `carousel` (with slide copy) under that name has authored real content the
+    // built-in never carried.
+    if (entry && !entry.isBuiltIn) {
+        emitFromPropSchema(entry.props, props, out);
+        return;
+    }
+    if (SKIPPED_MODULES.has(type))
+        return;
+    const emitter = BUILT_IN_EMITTERS[type];
+    if (emitter) {
+        emitter(props, out);
+        return;
+    }
+    // Unregistered → skip silently. Registered but with no emitter (a built-in
+    // that carries copy in plain props) → read its schema.
+    if (entry)
+        emitFromPropSchema(entry.props, props, out);
+}
+/**
+ * A `component` MODULE placement (the "Saved → Component" palette entry), whose
+ * target lives in `props`, not in a node-level `componentId`.
+ */
+function emitComponentPlacement(props, ctx, out) {
+    // A host that already hydrated the placement wins: that HTML is what rendered.
+    const content = str(props['content']);
+    if (content) {
+        pushHtml(content, out);
+        return;
+    }
+    const resolve = ctx.resolveComponent;
+    if (!resolve)
+        return;
+    const componentId = str(props['componentId']);
+    const slug = str(props['slug']);
+    if (!componentId && !slug)
+        return;
+    const key = componentId || `slug:${slug}`;
+    // The visited set catches a definition that points back at ITSELF; the depth
+    // cap catches a chain that never repeats a key (A→B→C→…), which a visited set
+    // alone cannot bound.
+    if (ctx.visitedComponents.has(key) || ctx.depth >= MAX_COMPONENT_DEPTH)
+        return;
+    ctx.visitedComponents.add(key);
+    ctx.depth += 1;
+    try {
+        const source = resolve({
+            ...(componentId ? { componentId } : {}),
+            ...(slug ? { slug } : {}),
+        });
+        if (!source)
+            return;
+        emitComponentSource(source, ctx, out);
+    }
+    finally {
+        ctx.depth -= 1;
+        ctx.visitedComponents.delete(key);
+    }
+}
+function emitComponentSource(source, ctx, out) {
+    switch (source.kind) {
+        case 'module':
+            emitModuleOfType(source.moduleType, isRecord(source.props) ? source.props : {}, ctx, out);
+            return;
+        case 'section':
+            emitSection(source.section, ctx, out);
+            return;
+        case 'variantContainer':
+            if (!isRecord(source.container))
+                return;
+            for (const section of servedSections(source.container))
+                emitSection(section, ctx, out);
+            return;
+        case 'moduleVariantContainer':
+            if (!isRecord(source.container))
+                return;
+            emitModule(servedModule(source.container), ctx, out);
+            return;
+        default:
+            // 'unresolvable' — the renderer shows the placement's own (empty) props.
+            return;
+    }
+}
+// ─── Prop-schema projection (custom modules + schema-only built-ins) ──────────
+function emitFromPropSchema(schema, props, out) {
+    if (!schema)
+        return;
+    let headingUsed = false;
+    for (const [key, def] of Object.entries(schema)) {
+        const value = str(props[key]);
+        if (!value)
+            continue;
+        if (def.type === 'richText') {
+            pushHtml(value, out);
+            continue;
+        }
+        if (def.type !== 'text' && def.type !== 'textarea')
+            continue;
+        if (isReferenceProp(key))
+            continue;
+        // A textarea prop is also how the palette stores JSON item lists; a serialized
+        // array is data, not copy.
+        if (looksLikeJson(value) || looksLikeLinkTarget(value))
+            continue;
+        if (!headingUsed && def.type === 'text') {
+            headingUsed = true;
+            out.push(`<h2>${esc(value)}</h2>`);
+        }
+        else {
+            out.push(`<p>${esc(value)}</p>`);
+        }
+    }
+}
+const HEADING_LEVELS = new Set(['h1', 'h2', 'h3', 'h4', 'h5', 'h6']);
+const BUILT_IN_EMITTERS = {
+    heading(props, out) {
+        const text = str(props['text']);
+        if (!text)
+            return;
+        const level = str(props['level']);
+        const tag = HEADING_LEVELS.has(level) ? level : 'h2';
+        out.push(`<${tag}>${esc(text)}</${tag}>`);
+    },
+    richText(props, out) {
+        pushHtml(str(props['content']), out);
+    },
+    text(props, out) {
+        pushParagraph(str(props['content']), out);
+    },
+    button(props, out) {
+        pushLinkParagraph(str(props['label']), str(props['href']), out);
+    },
+    image(props, out) {
+        const alt = str(props['alt']);
+        if (alt)
+            out.push(`<p><em>${esc(alt)}</em></p>`);
+        pushParagraph(str(props['caption']), out);
+    },
+    card(props, out) {
+        const title = str(props['title']);
+        const href = safeHref(str(props['href']));
+        if (title) {
+            out.push(href ? `<h3><a href="${escAttr(href)}">${esc(title)}</a></h3>` : `<h3>${esc(title)}</h3>`);
+        }
+        pushParagraph(str(props['body']), out);
+        pushParagraph(str(props['footer']), out);
+    },
+    cta(props, out) {
+        pushHeading(2, str(props['headline']), out);
+        pushParagraph(str(props['subtext']), out);
+        pushLinkParagraph(str(props['buttonLabel']), str(props['buttonHref']), out);
+    },
+    hero(props, out) {
+        // h1 to match what HeroModule renders.
+        pushHeading(1, str(props['headline']), out);
+        pushParagraph(str(props['subtext']), out);
+        pushLinkParagraph(str(props['buttonLabel']), str(props['buttonHref']), out);
+    },
+    testimonial(props, out) {
+        pushQuote(str(props['quote']), out);
+        const author = str(props['author']);
+        const role = str(props['role']);
+        if (author)
+            pushParagraph(role ? `${author}, ${role}` : author, out);
+    },
+    blockquote(props, out) {
+        pushQuote(str(props['content']), out);
+        pushParagraph(str(props['author']), out);
+    },
+    faq(props, out) {
+        pushHeading(3, str(props['question']), out);
+        pushHtml(str(props['answer']), out);
+    },
+    accordion(props, out) {
+        pushHeading(3, str(props['title']), out);
+        pushHtml(str(props['content']), out);
+    },
+    pricing(props, out) {
+        pushHeading(3, str(props['planName']), out);
+        const price = str(props['price']);
+        const period = str(props['period']);
+        if (price)
+            pushParagraph(period ? `${price}/${period}` : price, out);
+        const features = parseJsonArray(props['features']).map(str).filter(Boolean);
+        if (features.length > 0) {
+            out.push(`<ul>${features.map(f => `<li>${esc(f)}</li>`).join('')}</ul>`);
+        }
+        pushLinkParagraph(str(props['buttonLabel']), str(props['buttonHref']), out);
+    },
+    alert(props, out) {
+        pushParagraph(str(props['message']), out);
+    },
+    badge(props, out) {
+        const label = str(props['label']);
+        if (!label)
+            return;
+        const href = str(props['href']);
+        if (href)
+            pushLinkParagraph(label, href, out);
+        else
+            pushParagraph(label, out);
+    },
+    tabs(props, out) {
+        for (const raw of parseJsonArray(props['tabs'])) {
+            if (!isRecord(raw))
+                continue;
+            pushHeading(3, str(raw['label']), out);
+            pushHtml(str(raw['content']), out);
+        }
+    },
+    feedDisplay(props, out) {
+        // Items are other published nodes — they enter the corpus on their own.
+        pushHeading(2, str(props['heading']) || str(props['title']), out);
+    },
+};
+/**
+ * Modules that carry no standalone authored copy, or whose copy is site chrome
+ * repeated on every page. See the module docblock for the reasoning per group.
+ */
+const SKIPPED_MODULES = new Set([
+    // Layout scaffolding
+    'section', 'container', 'columns', 'spacer', 'divider',
+    // Arbitrary markup / embeds
+    'html', 'embed', 'video',
+    // Interaction
+    'form', 'formEmbed', 'comments',
+    // Navigation + search chrome
+    'breadcrumbs', 'navMenu', 'navigation', 'siteMap', 'searchBox', 'search',
+    // Compliance chrome
+    'cookieConsent',
+    // Decorative / structured-data-only
+    'icon', 'map', 'socialShare', 'countdown', 'carousel', 'tagCloud', 'categoryList',
+    // Personalization chrome + the retired container MODULE (the real container is
+    // a layout NODE, handled in the walk above).
+    'personalizationBadge', 'variantContainer',
+]);
+// ─── Emit helpers ─────────────────────────────────────────────────────────────
+function pushHeading(level, text, out) {
+    if (!text)
+        return;
+    out.push(`<h${level}>${esc(text)}</h${level}>`);
+}
+function pushParagraph(text, out) {
+    if (!text)
+        return;
+    out.push(`<p>${esc(text)}</p>`);
+}
+function pushLinkParagraph(label, rawHref, out) {
+    if (!label)
+        return;
+    const href = safeHref(rawHref);
+    out.push(href ? `<p><a href="${escAttr(href)}">${esc(label)}</a></p>` : `<p>${esc(label)}</p>`);
+}
+/**
+ * The href allowlist for links this module ASSEMBLES.
+ *
+ * Rich text goes through `sanitizeHtml`, which enforces its own scheme list, but
+ * a `button`/`cta`/`card` href is interpolated straight into markup built here.
+ * A stored `javascript:` or `data:` href is inert in an agent corpus and live in
+ * anything that renders this HTML, and there is no reason for a projection to
+ * carry one. Relative targets (`/`, `#`, `?`, `.`, a bare path) pass; an
+ * absolute one must be http(s)/mailto/tel. Dropped → the label still emits as
+ * plain copy, since the words are the content.
+ */
+const SAFE_SCHEME = /^(https?|mailto|tel):/i;
+const HAS_SCHEME = /^[a-z][a-z0-9+.-]*:/i;
+function safeHref(href) {
+    if (!href)
+        return '';
+    // Control characters are how `java\0script:` style bypasses are written.
+    const cleaned = href.replace(/[\u0000-\u001f\u007f]/g, '');
+    if (!cleaned)
+        return '';
+    if (!HAS_SCHEME.test(cleaned))
+        return cleaned;
+    return SAFE_SCHEME.test(cleaned) ? cleaned : '';
+}
+function pushQuote(text, out) {
+    if (!text)
+        return;
+    out.push(`<blockquote><p>${esc(text)}</p></blockquote>`);
+}
+/** Stored rich text is CMS-authored HTML: sanitize it exactly as the renderer does. */
+function pushHtml(html, out) {
+    if (!html)
+        return;
+    const clean = sanitizeHtml(html).trim();
+    if (clean)
+        out.push(clean);
+}
+// ─── Small pure helpers ───────────────────────────────────────────────────────
+let cachedBuiltInRegistry = null;
+/** The built-ins-only registry, built once (it is immutable and stateless). */
+function builtInRegistry() {
+    cachedBuiltInRegistry ??= createModuleRegistry([]);
+    return cachedBuiltInRegistry;
+}
+const registryByModules = new WeakMap();
+/**
+ * The module registry for a config's `modules`, memoised on the array itself.
+ *
+ * The per-NODE surfaces — `/<path>.md`, per-page JSON-LD — are handed a node by
+ * the host rather than by the AX content source, so nothing precomputed their
+ * layout projection and they must build the registry themselves. Doing it
+ * unmemoised would rebuild a ~45-entry map on every request; the config's
+ * `modules` array is a stable object for the process's lifetime, so it keys the
+ * cache exactly.
+ *
+ * NOTE what this deliberately does NOT carry: a component resolver. Resolving a
+ * saved component is a database read, and these two surfaces are synchronous and
+ * DB-free by contract. A linked placement on a node that did not come through
+ * the content source therefore contributes its inline fallback copy — the same
+ * copy the renderer falls back to when a link cannot be resolved.
+ */
+export function registryForModules(modules) {
+    if (!Array.isArray(modules) || modules.length === 0)
+        return builtInRegistry();
+    const hit = registryByModules.get(modules);
+    if (hit)
+        return hit;
+    const built = createModuleRegistry(modules);
+    registryByModules.set(modules, built);
+    return built;
+}
+function asLayoutDocument(value) {
+    if (!isRecord(value))
+        return null;
+    const regions = value['regions'];
+    if (!isRecord(regions))
+        return null;
+    return value;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * THE guard for every walk site. A stored layout is raw JSONB that
+ * `setContentLayout` never validated, so any of `regions.main`, `columns`,
+ * `nodes`, `defaultSections` and `variants` may be an object, a string, or
+ * absent. `for (const x of somethingNotIterable)` is a TypeError, and these
+ * projections run on public routes.
+ */
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function str(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+/**
+ * Structured data stored in a `textarea` prop (the palette's item lists). The
+ * `JSON.parse` is not decoration: prose legitimately opens with a brace
+ * ("{curly} quotes", "[draft] title"), and dropping it would silently lose real
+ * copy.
+ */
+function looksLikeJson(value) {
+    const first = value[0];
+    if (first !== '[' && first !== '{')
+        return false;
+    try {
+        JSON.parse(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A prop that NAMES something rather than saying something: a link target, an
+ * id, a slug, a CSS class.
+ *
+ * The palette has no "reference" prop type, so a custom module's `ctaHref`,
+ * `experimentId` or `videoSrc` is declared `text` alongside its `headline`. Emitting those as
+ * paragraphs fills an agent corpus with bare paths and UUIDs, and the schema
+ * path is the only projection that cannot tell them apart from copy (a built-in
+ * emitter names the props it reads). Matching on the name is the cheap, stable
+ * half of that; {@link looksLikeLinkTarget} catches the rest by value.
+ */
+function isReferenceProp(name) {
+    // Whole name, or a camelCase suffix. The camelCase half must require the
+    // capital: a plain `/id$/i` would also swallow `valid`, `grid` and `hybrid`.
+    return (/^(href|url|uri|id|slug|class|classname|link|path|route|target|src)$/i.test(name) ||
+        /[a-z](Href|Url|Uri|Id|Slug|Class|ClassName|Link|Path|Route|Target|Src)$/.test(name));
+}
+/** A bare path, anchor, or absolute URL — a destination, not a sentence. */
+function looksLikeLinkTarget(value) {
+    if (/\s/.test(value))
+        return false;
+    return /^(\/|#|https?:\/\/|mailto:|tel:)/i.test(value);
+}
+function parseJsonArray(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (typeof raw !== 'string')
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function esc(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function escAttr(text) {
+    return esc(text).replace(/"/g, '&quot;');
+}
+//# sourceMappingURL=layout-to-html.js.map