@cogenta/theme-entreprise 1.1.2

package/src/render/blocks/media-figure.ts

@@ -0,0 +1,43 @@
+import type { MediaFigureBlock } from '@cogenta/blocks'
+import { aspectRatio, type HtmlElement, h, image, type RenderContext } from '@cogenta/theme-kit'
+
+/**
+ * `<figure>`/`<figcaption>`, matching the pattern the HTML spec prescribes for
+ * an image and its own caption — a `<figcaption>` outside the `<figure>` would
+ * lose that association for assistive technology.
+ *
+ * The frame reads as a bordered plate with a small caption rule underneath,
+ * distinct from a floated/rounded treatment: the "structured, edged"
+ * language this theme uses everywhere a picture appears.
+ */
+export function renderMediaFigure(block: MediaFigureBlock, ctx: RenderContext): HtmlElement {
+  const ratio = aspectRatio(block.ratio)
+  const hasCaption = block.caption !== undefined || block.credit !== undefined
+  return h(
+    'figure',
+    {
+      class: 'cg-figure',
+      'data-block': 'mediaFigure',
+      'data-align': block.align ?? 'center',
+      style: ratio === undefined ? undefined : `--cg-ratio:${ratio}`,
+    },
+    h(
+      'div',
+      { class: 'cg-figure__frame' },
+      image(ctx, block.media, {
+        className: 'cg-figure__media',
+        sizes: '(min-width: 48rem) 42rem, 100vw',
+      }),
+    ),
+    hasCaption
+      ? h(
+          'figcaption',
+          { class: 'cg-figure__caption' },
+          block.caption,
+          block.credit === undefined
+            ? null
+            : h('span', { class: 'cg-figure__credit', 'data-field': 'credit' }, block.credit),
+        )
+      : null,
+  )
+}

package/src/render/blocks/pricing-table.ts

@@ -0,0 +1,77 @@
+import type { PricingTableBlock, PricingTier } from '@cogenta/blocks'
+import {
+  actionLink,
+  blockHeadingTag,
+  type HeadingTag,
+  type HtmlElement,
+  h,
+  heading,
+  nestedHeadingTag,
+  type RenderContext,
+} from '@cogenta/theme-kit'
+
+/**
+ * `blocks@2.0` (RFC 0001). A side-by-side plan comparison — the ledger-row
+ * language this theme uses for `featureGrid` would flatten the very
+ * distinction a pricing table exists to show, so tiers instead sit as a row
+ * of bordered plates, one plate lifted (border + a small "recommended" rule)
+ * when `highlighted` is set.
+ *
+ * `highlighted` is an editorial signal, never a colour: it becomes
+ * `data-highlighted` for the stylesheet to key off, and `aria-current` so the
+ * emphasis is announced, not only shown.
+ */
+function renderTier(tier: PricingTier, ctx: RenderContext, tag: HeadingTag): HtmlElement {
+  return h(
+    'li',
+    {
+      class: 'cg-pricing__tier',
+      'data-highlighted': tier.highlighted === true ? 'true' : undefined,
+      'aria-current': tier.highlighted === true ? 'true' : undefined,
+    },
+    heading(tag, { class: 'cg-pricing__name' }, tier.name),
+    h(
+      'p',
+      { class: 'cg-pricing__price' },
+      h('span', { class: 'cg-pricing__amount' }, tier.price),
+      tier.interval === undefined
+        ? null
+        : h('span', { class: 'cg-pricing__interval' }, tier.interval),
+    ),
+    tier.features.length === 0
+      ? null
+      : h(
+          'ul',
+          { class: 'cg-pricing__features' },
+          tier.features.map((feature) => h('li', { class: 'cg-pricing__feature' }, feature)),
+        ),
+    tier.action === undefined
+      ? null
+      : h(
+          'div',
+          { class: 'cg-pricing__action' },
+          actionLink(ctx, { ...tier.action, emphasis: tier.action.emphasis ?? 'primary' }),
+        ),
+  )
+}
+
+export function renderPricingTable(block: PricingTableBlock, ctx: RenderContext): HtmlElement {
+  const hasTitle = block.title !== undefined
+  const tierTag = nestedHeadingTag('pricingTable', hasTitle)
+  return h(
+    'section',
+    { class: 'cg-pricing', 'data-block': 'pricingTable' },
+    hasTitle
+      ? heading(
+          blockHeadingTag('pricingTable') ?? 'h2',
+          { class: 'cg-pricing__title', 'data-field': 'title' },
+          block.title ?? '',
+        )
+      : null,
+    h(
+      'ul',
+      { class: 'cg-pricing__tiers' },
+      block.tiers.map((tier) => renderTier(tier, ctx, tierTag)),
+    ),
+  )
+}

package/src/render/blocks/prose.ts

@@ -0,0 +1,11 @@
+import type { ProseBlock } from '@cogenta/blocks'
+import { type HtmlElement, h, type RenderContext, renderRichText } from '@cogenta/theme-kit'
+
+/**
+ * `prose` declares `headingLevel: 'none'`: it contributes no heading of its
+ * own. Whatever headings appear come from the rich text document, whose
+ * vocabulary starts at `h2`.
+ */
+export function renderProse(block: ProseBlock, ctx: RenderContext): HtmlElement {
+  return h('div', { class: 'cg-prose', 'data-block': 'prose' }, renderRichText(ctx, block.body))
+}

package/src/render/blocks/quote.ts

@@ -0,0 +1,48 @@
+import type { QuoteBlock } from '@cogenta/blocks'
+import { type HtmlElement, h, image, type RenderContext } from '@cogenta/theme-kit'
+
+/**
+ * A testimonial card, not a centred pull-quote: a bordered panel with a
+ * vertical accent rule beside the quotation and the attribution set below a
+ * thin divider — the shape a case-study or client-testimonial section takes
+ * on a serious B2B site.
+ *
+ * `<figure><blockquote>…</blockquote><figcaption>` is the attribution
+ * pattern the HTML spec prescribes: putting the author inside the
+ * `<blockquote>` would claim the author's name was part of what was said.
+ *
+ * The avatar is decorative here — the name sits right beside it in text —
+ * so its media entity's alt text is expected to be empty; `image` still
+ * writes the attribute either way (WCAG 1.1.1).
+ */
+export function renderQuote(block: QuoteBlock, ctx: RenderContext): HtmlElement {
+  const hasAttribution =
+    block.author !== undefined || block.role !== undefined || block.avatar !== undefined
+  return h(
+    'figure',
+    { class: 'cg-quote', 'data-block': 'quote' },
+    h('blockquote', { class: 'cg-quote__text' }, h('p', { 'data-field': 'text' }, block.text)),
+    hasAttribution
+      ? h(
+          'figcaption',
+          { class: 'cg-quote__attribution' },
+          block.avatar === undefined
+            ? null
+            : image(ctx, block.avatar, {
+                className: 'cg-quote__avatar',
+                variant: { width: 96, height: 96, fit: 'cover' },
+              }),
+          h(
+            'span',
+            { class: 'cg-quote__who' },
+            block.author === undefined
+              ? null
+              : h('span', { class: 'cg-quote__author', 'data-field': 'author' }, block.author),
+            block.role === undefined
+              ? null
+              : h('span', { class: 'cg-quote__role', 'data-field': 'role' }, block.role),
+          ),
+        )
+      : null,
+  )
+}

package/src/render/blocks/stat-counter.ts

@@ -0,0 +1,45 @@
+import type { StatCounterBlock, StatCounterItem } from '@cogenta/blocks'
+import {
+  blockHeadingTag,
+  type HtmlElement,
+  h,
+  heading,
+  type RenderContext,
+} from '@cogenta/theme-kit'
+
+/**
+ * `blocks@2.0` (RFC 0001). Narrower than `stats` (no `unit`), and treated
+ * that way here: `stats` reads as a quiet KPI strip on the page's own
+ * surface, while `statCounter` is this theme's confident "impact numbers"
+ * band — an accent-tinted panel of big, tabular figures, the instinct the
+ * aesthetic direction already asks for on `stats` pushed one step further
+ * for the narrower, single-figure shape this block offers.
+ *
+ * A `<dl>`, exactly like `stats`: each figure is the description of its
+ * label, which is what `<dt>`/`<dd>` mean. The label sits before the figure
+ * in markup, the same reading-order guarantee `stats` gives (WCAG 1.3.2);
+ * the stylesheet is free to paint the big figure first.
+ */
+function renderItem(item: StatCounterItem): HtmlElement {
+  return h(
+    'div',
+    { class: 'cg-kpi' },
+    h('dt', { class: 'cg-kpi__label' }, item.label),
+    h('dd', { class: 'cg-kpi__value' }, item.value),
+  )
+}
+
+export function renderStatCounter(block: StatCounterBlock, _ctx: RenderContext): HtmlElement {
+  return h(
+    'section',
+    { class: 'cg-kpis', 'data-block': 'statCounter' },
+    block.title === undefined
+      ? null
+      : heading(
+          blockHeadingTag('statCounter') ?? 'h2',
+          { class: 'cg-kpis__title', 'data-field': 'title' },
+          block.title,
+        ),
+    h('dl', { class: 'cg-kpis__items' }, block.stats.map(renderItem)),
+  )
+}

package/src/render/blocks/stats.ts

@@ -0,0 +1,50 @@
+import type { StatItem, StatsBlock } from '@cogenta/blocks'
+import {
+  blockHeadingTag,
+  type HtmlElement,
+  h,
+  heading,
+  type RenderContext,
+} from '@cogenta/theme-kit'
+
+/**
+ * The "by the numbers" strip. A description list, exactly as the canonical
+ * theme uses — each figure is the description of its label, which is what
+ * `<dt>`/`<dd>` mean, and it survives being read linearly — but laid out as
+ * one continuous row of big, confident figures separated by vertical rules
+ * (`border-inline-start` on every item but the first) rather than as
+ * separate shadowed tiles: the "real KPI strip" read the aesthetic
+ * direction asks for.
+ *
+ * The label sits above the figure in the markup and the skin is free to
+ * repaint the order visually; reading order and visual order stay
+ * independent either way (WCAG 1.3.2).
+ */
+function renderItem(item: StatItem): HtmlElement {
+  return h(
+    'div',
+    { class: 'cg-metric' },
+    h('dt', { class: 'cg-metric__label' }, item.label),
+    h(
+      'dd',
+      { class: 'cg-metric__value' },
+      item.value,
+      item.unit === undefined ? null : h('span', { class: 'cg-metric__unit' }, item.unit),
+    ),
+  )
+}
+
+export function renderStats(block: StatsBlock, _ctx: RenderContext): HtmlElement {
+  return h(
+    'section',
+    { class: 'cg-metrics', 'data-block': 'stats' },
+    block.title === undefined
+      ? null
+      : heading(
+          blockHeadingTag('stats') ?? 'h2',
+          { class: 'cg-metrics__title', 'data-field': 'title' },
+          block.title,
+        ),
+    h('dl', { class: 'cg-metrics__items' }, block.items.map(renderItem)),
+  )
+}

package/src/render/blocks/testimonial.ts

@@ -0,0 +1,41 @@
+import type { TestimonialBlock } from '@cogenta/blocks'
+import { type HtmlElement, h, image, type RenderContext, renderRichText } from '@cogenta/theme-kit'
+
+/**
+ * `blocks@2.0` (RFC 0001). This theme's "client success" panel — the same
+ * `<figure><blockquote>…</blockquote><figcaption>` pattern `quote` uses, kept
+ * consistent so the two read as siblings, but the quote itself is rich text
+ * (a testimonial may carry a link or emphasis the shorter, plain-text `quote`
+ * block cannot) and the attribution is the block's single grouped
+ * `attribution` field rather than three loose ones.
+ *
+ * The avatar is decorative, exactly like `quote`'s own: the name sits right
+ * beside it in text, so its media entity's alt text is expected to be empty;
+ * `image` still writes the attribute either way (WCAG 1.1.1).
+ */
+export function renderTestimonial(block: TestimonialBlock, ctx: RenderContext): HtmlElement {
+  const { attribution } = block
+  return h(
+    'figure',
+    { class: 'cg-testimonial', 'data-block': 'testimonial' },
+    h('blockquote', { class: 'cg-testimonial__quote' }, renderRichText(ctx, block.quote)),
+    h(
+      'figcaption',
+      { class: 'cg-testimonial__attribution' },
+      attribution.avatar === undefined
+        ? null
+        : image(ctx, attribution.avatar, {
+            className: 'cg-testimonial__avatar',
+            variant: { width: 96, height: 96, fit: 'cover' },
+          }),
+      h(
+        'span',
+        { class: 'cg-testimonial__who' },
+        h('span', { class: 'cg-testimonial__name' }, attribution.name),
+        attribution.role === undefined
+          ? null
+          : h('span', { class: 'cg-testimonial__role' }, attribution.role),
+      ),
+    ),
+  )
+}

package/src/render/chrome.ts

@@ -0,0 +1,128 @@
+import {
+  type ChromeInput,
+  type ChromeNavLink,
+  type ChromeResult,
+  escapeAttribute,
+  escapeText,
+  renderBrandMark,
+  renderSocialLinks,
+  renderThemeToggle,
+  serialize,
+} from '@cogenta/theme-kit'
+
+/**
+ * This theme's own header and footer (`theme@1.4`) — a structurally
+ * different chrome from the canonical theme's, not a recolour of it.
+ *
+ * Header: a sticky bar with the corporate wordmark/logo on the left, a real
+ * desktop `<nav>`, `headerAction` (`theme@1.4`) rendered as a filled button
+ * — the one place this hairline-first chrome spends a solid accent surface
+ * — and, below the breakpoint the stylesheet sets, a CSS-only mobile menu:
+ * a checkbox (`#cg-nav-toggle`, visually hidden but still focusable and
+ * Space-operable) paired with a `<label>` styled as a three-bar button. No
+ * `<script>` anywhere: the sibling combinator in `base.css` is what shows
+ * the nav panel when the box is checked. This replaces the previous
+ * "the last header link doubles as the call to action" convention — with a
+ * real `headerAction` field, inventing a role for a plain nav link is no
+ * longer the honest reading of the data.
+ *
+ * Footer: a real four-column layout — a brand column (site name + `tagline`,
+ * `theme@1.4`), the site's own footer navigation, `social` (`theme@1.4`, via
+ * `renderSocialLinks`), and a fourth column carrying `footerNote`
+ * (`theme@1.4`) above Cogenta's own credit (or its white-label replacement).
+ * `brandingHtml` is placed exactly once, inside the footer, exactly as
+ * received: never altered, never dropped.
+ *
+ * The manual light/dark/system control (`renderThemeToggle`, `@cogenta/
+ * theme-kit`, L26) sits beside the mobile menu button, outside the `<nav>`
+ * it controls the collapse of — the `<nav>` panel is hidden under the
+ * breakpoint until the checkbox is checked, but a visitor must be able to
+ * flip appearance without opening that panel first, on desktop or mobile.
+ * This module ships no CSS of its own for it (`base.css` owns
+ * `.cg-theme-toggle`, in this theme's own visual register, not canonical's).
+ */
+
+function navItems(links: readonly ChromeNavLink[]): string {
+  return links
+    .filter((link) => link.href !== null || link.kind === 'submenu-placeholder')
+    .map((link) => {
+      const label = escapeText(link.label)
+      const titleAttr = link.title === null ? '' : ` title="${escapeAttribute(link.title)}"`
+      if (link.href === null) return `<li><span${titleAttr}>${label}</span></li>`
+      const href = escapeAttribute(link.href)
+      const target = link.openInNewTab ? ' target="_blank" rel="noopener"' : ''
+      return `<li><a href="${href}"${target}${titleAttr}>${label}</a></li>`
+    })
+    .join('')
+}
+
+function renderNavList(links: readonly ChromeNavLink[]): string {
+  const items = navItems(links)
+  return items === '' ? '' : `<ul class="cg-nav__items">${items}</ul>`
+}
+
+/** The header's own call-to-action link (`theme@1.4`) — a filled button, distinct from the ordinary nav list. */
+function renderHeaderAction(action: ChromeInput['headerAction']): string {
+  if (action === undefined) return ''
+  return (
+    `<a class="cg-action cg-site-header__action" data-emphasis="primary" ` +
+    `href="${escapeAttribute(action.href)}">${escapeText(action.label)}</a>`
+  )
+}
+
+export function renderChrome(input: ChromeInput): ChromeResult {
+  const siteNameText = escapeText(input.site.name)
+  const headerNavList = renderNavList(input.headerNav)
+  const headerAction = renderHeaderAction(input.headerAction)
+  const footerNavList = renderNavList(input.footerNav)
+  // A B2B header is a corporate identity slot before it is a wordmark slot.
+  const mark = renderBrandMark(input.brand, { className: 'cg-site-header__logo' }) ?? siteNameText
+  const themeToggle = serialize(renderThemeToggle(input.locale, { className: 'cg-theme-toggle' }))
+
+  const header =
+    `<header class="cg-site-header"><div class="cg-site-header__inner">` +
+    `<a class="cg-site-header__home" href="${escapeAttribute(input.homeHref)}">${mark}</a>` +
+    `<input type="checkbox" id="cg-nav-toggle" class="cg-nav-toggle-input" aria-label="Menu">` +
+    `<label for="cg-nav-toggle" class="cg-nav-toggle-label" aria-hidden="true">` +
+    `<span class="cg-nav-toggle-bar"></span><span class="cg-nav-toggle-bar"></span><span class="cg-nav-toggle-bar"></span>` +
+    `</label>` +
+    `${themeToggle}` +
+    `<nav class="cg-site-header__nav" id="cg-nav" aria-label="Primary">` +
+    `${headerNavList}${headerAction}` +
+    `</nav>` +
+    `</div></header>`
+
+  const tagline =
+    input.tagline === undefined
+      ? ''
+      : `<p class="cg-site-footer__tagline" data-field="tagline">${escapeText(input.tagline)}</p>`
+  const social =
+    input.social === undefined
+      ? ''
+      : serialize(
+          renderSocialLinks(input.social, {
+            className: 'cg-site-footer__social',
+            itemClassName: 'cg-site-footer__social-item',
+          }) ?? { kind: 'text', value: '' },
+        )
+  const footerNote =
+    input.footerNote === undefined
+      ? ''
+      : `<p class="cg-site-footer__note">${escapeText(input.footerNote)}</p>`
+
+  const footer =
+    `<footer class="cg-site-footer"><div class="cg-site-footer__grid">` +
+    `<div class="cg-site-footer__brand">` +
+    `<a href="${escapeAttribute(input.homeHref)}">${siteNameText}</a>${tagline}` +
+    `</div>` +
+    `${
+      footerNavList === ''
+        ? ''
+        : `<nav class="cg-site-footer__nav" aria-label="Footer">${footerNavList}</nav>`
+    }` +
+    `${social === '' ? '' : `<div class="cg-site-footer__social-col">${social}</div>`}` +
+    `<div class="cg-site-footer__meta">${footerNote}<div class="cg-site-footer__branding">${input.brandingHtml}</div></div>` +
+    `</div><div class="cg-site-footer__bottom"><span>${siteNameText}</span></div></footer>`
+
+  return { header, footer }
+}

package/src/render/render-block.ts

@@ -0,0 +1,144 @@
+import { type BlockRegistry, VOCABULARY_NAMES, type VocabularyBlock } from '@cogenta/blocks'
+import {
+  type FetchedEntries,
+  type HtmlElement,
+  h,
+  type PageContent,
+  pageHasOwnHeading,
+  type RenderContext,
+  renderEntryHeader,
+  resolveBlockForRender,
+  withBlockKey,
+  withBlockVariant,
+} from '@cogenta/theme-kit'
+import { renderAccordion } from './blocks/accordion.js'
+import { renderCollectionList } from './blocks/collection-list.js'
+import { renderCta } from './blocks/cta.js'
+import { renderEmbed } from './blocks/embed.js'
+import { renderFaq } from './blocks/faq.js'
+import { renderFeatureGrid } from './blocks/feature-grid.js'
+import { renderGallery } from './blocks/gallery.js'
+import { renderHero } from './blocks/hero.js'
+import { renderLogoStrip } from './blocks/logo-strip.js'
+import { renderLogos } from './blocks/logos.js'
+import { renderMediaFigure } from './blocks/media-figure.js'
+import { renderPricingTable } from './blocks/pricing-table.js'
+import { renderProse } from './blocks/prose.js'
+import { renderQuote } from './blocks/quote.js'
+import { renderStatCounter } from './blocks/stat-counter.js'
+import { renderStats } from './blocks/stats.js'
+import { renderTestimonial } from './blocks/testimonial.js'
+
+export type { FetchedEntries, PageContent }
+export { pageHasOwnHeading, renderEntryHeader, withBlockKey }
+
+export function renderBlock(
+  block: VocabularyBlock,
+  ctx: RenderContext,
+  entries: FetchedEntries = {},
+  registry?: BlockRegistry,
+): HtmlElement | null {
+  // `block`'s type says `VocabularyBlock`, but the value crossing this
+  // boundary from stored content is not always literally one of the shared
+  // vocabulary — resolving here is what turns an unimplemented theme-private
+  // block into its declared fallback instead of a silently blank slot.
+  const resolved = resolveBlockForRender(block, VOCABULARY_NAMES, registry)
+  if (resolved === null) return null
+  const known = resolved as unknown as VocabularyBlock
+  // `withBlockVariant` (blocks@2.0, RFC 0002) is applied once here, after
+  // dispatch, rather than inside each of the seventeen block renderers —
+  // `variant` is envelope data every block carries identically, exactly the
+  // same reasoning `withBlockKey` in `renderPage` already follows for `_key`.
+  return withBlockVariant(renderKnownBlock(known, ctx, entries), known.variant)
+}
+
+function renderKnownBlock(
+  known: VocabularyBlock,
+  ctx: RenderContext,
+  entries: FetchedEntries,
+): HtmlElement | null {
+  switch (known._type) {
+    case 'hero':
+      return renderHero(known, ctx)
+    case 'prose':
+      return renderProse(known, ctx)
+    case 'mediaFigure':
+      return renderMediaFigure(known, ctx)
+    case 'featureGrid':
+      return renderFeatureGrid(known, ctx)
+    case 'cta':
+      return renderCta(known, ctx)
+    case 'gallery':
+      return renderGallery(known, ctx)
+    case 'quote':
+      return renderQuote(known, ctx)
+    case 'faq':
+      return renderFaq(known, ctx)
+    case 'stats':
+      return renderStats(known, ctx)
+    case 'logos':
+      return renderLogos(known, ctx)
+    case 'collectionList':
+      return renderCollectionList(known, ctx, entries[known._key] ?? [])
+    case 'embed':
+      return renderEmbed(known, ctx)
+    case 'testimonial':
+      return renderTestimonial(known, ctx)
+    case 'pricingTable':
+      return renderPricingTable(known, ctx)
+    case 'accordion':
+      return renderAccordion(known, ctx)
+    case 'statCounter':
+      return renderStatCounter(known, ctx)
+    case 'logoStrip':
+      return renderLogoStrip(known, ctx)
+    default: {
+      // Exhaustive over contract B's vocabulary: `known` is `never` here, so
+      // a block this package does not implement stops it compiling until it
+      // is. Returning null rather than throwing is deliberate — a theme has
+      // no access to `@cogenta/core`'s error types (contract D refuses the
+      // import), and choosing a fallback block is the render layer's job,
+      // not the theme's.
+      const unreachable: never = known
+      void unreachable
+      return null
+    }
+  }
+}
+
+/**
+ * `<main id="cg-main">` is mandatory: it is the skip-link's target, written
+ * once by `@cogenta/cli`'s `theme-render.ts` outside any theme's control.
+ *
+ * `renderEntryHeader` (`theme@1.4`) draws the eyebrow/title/excerpt/meta/
+ * cover furniture for a page backed by a real content entry — a service or
+ * a plain page — and already returns `null` for a page with no `entry`
+ * meta *and* for one whose blocks draw their own heading (a `hero`), so the
+ * bare `<h1 class="cg-page__title">` fallback below is the right markup in
+ * both of those cases and only those — never a double heading, and never a
+ * page with none at all.
+ *
+ * `withBlockKey` stamps every rendered block with its contract-B `_key` —
+ * required so the visual page builder (L16) can map a clicked element in
+ * the rendered iframe back to the block that produced it, for this theme
+ * exactly as for every other one.
+ */
+export function renderPage(
+  page: PageContent,
+  ctx: RenderContext,
+  entries: FetchedEntries = {},
+  registry?: BlockRegistry,
+): HtmlElement {
+  const entryHeader = renderEntryHeader(page, ctx)
+  return h(
+    'main',
+    { class: 'cg-main', id: 'cg-main' },
+    entryHeader,
+    entryHeader === null && !pageHasOwnHeading(page.blocks)
+      ? h('h1', { class: 'cg-page__title' }, page.title)
+      : null,
+    page.blocks.map((block) =>
+      withBlockKey(renderBlock(block, ctx, entries, registry), block._key),
+    ),
+  )
+}

package/src/render/term-archive.ts

@@ -0,0 +1,80 @@
+import { type HtmlElement, h, type TermArchiveInput } from '@cogenta/theme-kit'
+
+/**
+ * The taxonomy-term archive (contract D `theme@1.3`) — a resource index.
+ *
+ * Built from the same `cg-list__row` rows `collectionList` already renders
+ * here: a date rail on the left, the title and its summary on the right,
+ * which is the shape a B2B insights or resources index takes. Reusing the
+ * block's own classes is what keeps an archive looking like the rest of the
+ * site without a second stylesheet to maintain.
+ */
+export function renderTermArchive(input: TermArchiveInput): HtmlElement {
+  const rows = input.entries.map((entry) =>
+    h(
+      'li',
+      { class: 'cg-list__row' },
+      entry.publishedAt === null
+        ? null
+        : h(
+            'time',
+            { class: 'cg-list__date', datetime: entry.publishedAt },
+            entry.publishedAt.slice(0, 10),
+          ),
+      h(
+        'div',
+        { class: 'cg-list__body' },
+        h(
+          'h2',
+          { class: 'cg-list__title' },
+          entry.href === null
+            ? entry.title
+            : h('a', { class: 'cg-list__link', href: entry.href }, entry.title),
+        ),
+        entry.summary === null ? null : h('p', { class: 'cg-list__excerpt' }, entry.summary),
+      ),
+    ),
+  )
+
+  return h(
+    'main',
+    { class: 'cg-main cg-archive', id: 'cg-main' },
+    input.ancestors.length === 0
+      ? null
+      : h(
+          'nav',
+          { class: 'cg-archive__breadcrumb', 'aria-label': input.labels.breadcrumb },
+          h(
+            'ol',
+            {},
+            ...input.ancestors.map((l) => h('li', {}, h('a', { href: l.href }, l.label))),
+          ),
+        ),
+    h('h1', { class: 'cg-list__title-heading' }, input.term.label),
+    input.children.length === 0
+      ? null
+      : h(
+          'ul',
+          { class: 'cg-archive__children', 'aria-label': input.labels.subterms },
+          ...input.children.map((c) => h('li', {}, h('a', { href: c.href }, c.label))),
+        ),
+    rows.length === 0
+      ? h('p', { class: 'cg-list__empty' }, input.labels.empty)
+      : h('ul', { class: 'cg-list__items' }, ...rows),
+    pager(input),
+  )
+}
+
+function pager(input: TermArchiveInput): HtmlElement | null {
+  if (input.page.previousHref === null && input.page.nextHref === null) return null
+  return h(
+    'nav',
+    { class: 'cg-archive__pager', 'aria-label': input.labels.pagination },
+    input.page.previousHref === null
+      ? null
+      : h('a', { rel: 'prev', href: input.page.previousHref }, input.labels.previous),
+    input.page.nextHref === null
+      ? null
+      : h('a', { rel: 'next', href: input.page.nextHref }, input.labels.next),
+  )
+}