pandorga 1.2.1

data/scripts/test/render-parity/load-runtime.mjs

@@ -0,0 +1,337 @@
+// load-runtime.mjs — assemble and evaluate the real content runtime in Node.
+//
+// Listings and detail views render in the browser from JS string templates
+// spread over _includes/content-runtime/*.html. A Ruby gate cannot see them
+// and a Jekyll build never executes them, which is how a block that renders
+// an element with no backing field ships green. This loader concatenates the
+// partials in the exact order _includes/page/content-runtime.html includes
+// them, evaluates the result beNewsreader a deliberately thin DOM shim, and hands
+// back the same object 90-bootstrap.html returns to the browser.
+//
+// The shim is small on purpose: createElement, className, setAttribute,
+// innerHTML, and just enough child-node traversal for textExcerpt(). No DOM
+// library is vendored, and pulling one in would hide which browser APIs the
+// runtime actually depends on. Anything a block starts using that is missing
+// here fails loudly rather than quietly returning undefined.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// marked lives in scripts/node_modules; the render-parity gate already runs
+// node from scripts/. Without it renderMarkdown falls back to a single
+// escaped paragraph, which is enough for the blocks but makes excerpt
+// assertions meaningless, so import it when it resolves.
+let marked;
+try {
+  ({ marked } = await import('marked'));
+} catch {
+  marked = undefined;
+}
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+export const REPO_ROOT = path.resolve(HERE, '..', '..', '..');
+const ASSEMBLY = path.join(REPO_ROOT, '_includes', 'page', 'content-runtime.html');
+const PARTIAL_DIR = path.join(REPO_ROOT, '_includes', 'content-runtime');
+
+const VOID_TAGS = new Set(['img', 'br', 'hr', 'input', 'meta', 'link', 'source']);
+
+const NODE = { ELEMENT_NODE: 1, TEXT_NODE: 3, COMMENT_NODE: 8 };
+
+const ENTITIES = {
+  '&': '&',
+  '&lt;': '<',
+  '&gt;': '>',
+  '&quot;': '"',
+  '&#39;': "'",
+  '&#96;': '`',
+  '&nbsp;': ' '
+};
+
+function decodeEntities(text) {
+  return String(text).replace(/&(?:amp|lt|gt|quot|nbsp|#39|#96);/g, (m) => ENTITIES[m] ?? m);
+}
+
+function makeTextNode(text) {
+  return { nodeType: NODE.TEXT_NODE, textContent: decodeEntities(text), childNodes: [] };
+}
+
+// A deliberately small HTML parser. textExcerpt() walks childNodes and reads
+// textContent, so a shim that only stored innerHTML as a string would make
+// every listing preview come back empty and the excerpt assertions vacuous.
+function parseHtml(html) {
+  const nodes = [];
+  const stack = [{ childNodes: nodes }];
+  const token = /<!--[\s\S]*?-->|<\/([a-zA-Z][\w-]*)\s*>|<([a-zA-Z][\w-]*)((?:"[^"]*"|'[^']*'|[^>"'])*?)(\/?)>/g;
+  let cursor = 0;
+  let match;
+
+  const push = (node) => stack[stack.length - 1].childNodes.push(node);
+  const text = (raw) => {
+    if (raw) push(makeTextNode(raw));
+  };
+
+  while ((match = token.exec(html)) !== null) {
+    text(html.slice(cursor, match.index));
+    cursor = token.lastIndex;
+    if (match[0].startsWith('<!--')) continue;
+
+    if (match[1]) {
+      const closing = match[1].toLowerCase();
+      for (let i = stack.length - 1; i > 0; i -= 1) {
+        if (stack[i].tagName && stack[i].tagName.toLowerCase() === closing) {
+          stack.length = i;
+          break;
+        }
+      }
+      continue;
+    }
+
+    const element = makeElement(match[2]);
+    const attrs = /([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+    let attr;
+    while ((attr = attrs.exec(match[3] || '')) !== null) {
+      element.setAttribute(attr[1], decodeEntities(attr[2] ?? attr[3] ?? ''));
+    }
+    push(element);
+    if (!match[4] && !VOID_TAGS.has(element.tagName.toLowerCase())) stack.push(element);
+  }
+  text(html.slice(cursor));
+  return nodes;
+}
+
+function collectText(node) {
+  if (node.nodeType === NODE.TEXT_NODE) return node.textContent;
+  return (node.childNodes || []).map(collectText).join('');
+}
+
+function serializeAttrs(element) {
+  const pairs = [];
+  if (element.className) pairs.push(['class', element.className]);
+  for (const [key, value] of element._attrs) {
+    if (key === 'class') continue;
+    pairs.push([key, value]);
+  }
+  return pairs.map(([k, v]) => ` ${k}="${v}"`).join('');
+}
+
+function makeElement(tagName) {
+  const tag = String(tagName).toLowerCase();
+  const element = {
+    nodeType: NODE.ELEMENT_NODE,
+    tagName: tag.toUpperCase(),
+    className: '',
+    _innerHTML: '',
+    childNodes: [],
+    children: [],
+    _attrs: new Map(),
+    get innerHTML() {
+      return this._innerHTML;
+    },
+    set innerHTML(value) {
+      this._innerHTML = String(value ?? '');
+      this._appended = [];
+      this._sync();
+    },
+    _appended: [],
+    _sync() {
+      this.childNodes = parseHtml(this._innerHTML).concat(this._appended);
+      this.children = this.childNodes.filter((n) => n.nodeType === NODE.ELEMENT_NODE);
+    },
+    get textContent() {
+      return collectText(this);
+    },
+    set textContent(value) {
+      this.innerHTML = String(value ?? '').replace(/[<>&]/g, (c) => `&#${c.charCodeAt(0)};`);
+    },
+    setAttribute(key, value) {
+      if (key === 'class') this.className = String(value);
+      else this._attrs.set(key, String(value));
+    },
+    getAttribute(key) {
+      if (key === 'class') return this.className;
+      return this._attrs.has(key) ? this._attrs.get(key) : null;
+    },
+    hasAttribute(key) {
+      return key === 'class' ? this.className !== '' : this._attrs.has(key);
+    },
+    removeAttribute(key) {
+      this._attrs.delete(key);
+    },
+    appendChild(child) {
+      this._appended.push(child);
+      this._sync();
+      return child;
+    },
+    addEventListener() { },
+    classList: {
+      add: (name) => {
+        const names = element.className.split(/\s+/).filter(Boolean);
+        if (!names.includes(name)) names.push(name);
+        element.className = names.join(' ');
+      },
+      remove: (name) => {
+        element.className = element.className
+          .split(/\s+/)
+          .filter((n) => n && n !== name)
+          .join(' ');
+      },
+      contains: (name) => element.className.split(/\s+/).includes(name)
+    },
+    querySelector() {
+      return null;
+    },
+    querySelectorAll() {
+      return [];
+    },
+    closest() {
+      return null;
+    },
+    get outerHTML() {
+      const attrs = serializeAttrs(this);
+      if (VOID_TAGS.has(tag)) return `<${tag}${attrs}>`;
+      const appended = this._appended.map((child) => child.outerHTML || '').join('');
+      return `<${tag}${attrs}>${this._innerHTML}${appended}</${tag}>`;
+    }
+  };
+  return element;
+}
+
+function makeSandbox(overrides = {}) {
+  const documentShim = {
+    readyState: 'loading',
+    createElement: makeElement,
+    createDocumentFragment: () => makeElement('div'),
+    addEventListener() { },
+    removeEventListener() { },
+    dispatchEvent() { },
+    querySelector() {
+      return null;
+    },
+    querySelectorAll() {
+      return [];
+    },
+    getElementById() {
+      return null;
+    },
+    body: makeElement('body'),
+    documentElement: makeElement('html')
+  };
+
+  const windowShim = {
+    ContentRuntimeConfig: {
+      contentBase: '',
+      includeUnpublished: false,
+      defaultAuthor: 'Test Author',
+      translations: {},
+      tocMinHeadings: 3
+    },
+    location: {
+      origin: 'https://example.test',
+      pathname: '/pages/articles/',
+      search: '',
+      href: 'https://example.test/pages/articles/'
+    },
+    document: documentShim,
+    marked,
+    matchMedia: () => ({ matches: false, addEventListener() { }, addListener() { } }),
+    addEventListener() { },
+    setTimeout,
+    clearTimeout,
+    requestAnimationFrame: (fn) => setTimeout(fn, 0),
+    ...overrides
+  };
+  windowShim.window = windowShim;
+
+  return { windowShim, documentShim };
+}
+
+function includeOrder() {
+  const assembly = fs.readFileSync(ASSEMBLY, 'utf8');
+  const names = [];
+  const pattern = /\{%\s*include\s+content-runtime\/([\w.-]+\.html)\s*%\}/g;
+  let match;
+  while ((match = pattern.exec(assembly)) !== null) {
+    // 00-config.html is a <script> tag outside the IIFE, not runtime source.
+    if (match[1] === '00-config.html') continue;
+    names.push(match[1]);
+  }
+  if (names.length === 0) {
+    throw new Error(`No content-runtime includes found in ${ASSEMBLY}`);
+  }
+  return names;
+}
+
+// Every runtime partial is wrapped in {% raw %} so Liquid leaves the JS alone.
+// The JS inside contains {% ... %} in regex literals, so the check has to be
+// "no Liquid outside a raw region", not "no braces anywhere".
+function stripRawMarkers(name, body) {
+  const parts = body.split(/\{%-?\s*(?:end)?raw\s*-?%\}/);
+  const outside = parts.filter((_, index) => index % 2 === 0).join('');
+  if (/\{[{%]/.test(outside)) {
+    throw new Error(`${name} contains Liquid outside {% raw %}; the loader cannot evaluate it`);
+  }
+  return parts.join('');
+}
+
+/** The assembled runtime source, in include order, with Liquid markers gone. */
+export function runtimeSource() {
+  return includeOrder()
+    .map((name) => {
+      const body = fs.readFileSync(path.join(PARTIAL_DIR, name), 'utf8');
+      return `/* ---- ${name} ---- */\n${stripRawMarkers(name, body)}`;
+    })
+    .join('\n');
+}
+
+// 90-bootstrap.html ends the IIFE with `return { ... }`, so nothing can be
+// appended after it. Some functions worth testing — hydrateFrontMatter above
+// all — are deliberately not on that export list. Getters prepended to the
+// body close over the whole scope and resolve on access, which works for
+// hoisted function declarations and for `var` bindings alike, and costs the
+// browser bundle nothing because it only exists here.
+function exposeInternals(names) {
+  if (!names.length) return '';
+  const props = names.map((name) => `  get ${name}() { return ${name}; }`).join(',\n');
+  return `window.__runtimeInternals = {\n${props}\n};\n`;
+}
+
+/**
+ * Evaluate the runtime and return the object 90-bootstrap.html exports,
+ * together with the shims so a caller can inspect what the runtime touched.
+ *
+ * @param {object} options
+ * @param {string[]} [options.expose] runtime-internal names to reach as well
+ */
+export function loadRuntime(options = {}) {
+  const { expose = [], ...overrides } = options;
+  const { windowShim, documentShim } = makeSandbox(overrides);
+  const factory = new Function(
+    'window',
+    'document',
+    'Node',
+    'DOMParser',
+    `'use strict';\n${exposeInternals(expose)}${runtimeSource()}`
+  );
+  const runtime = factory(windowShim, documentShim, NODE, function DOMParser() {
+    throw new Error('The runtime reached DOMParser; the loader has no XML parser');
+  });
+  if (!runtime || typeof runtime !== 'object') {
+    throw new Error('The content runtime did not return its export object');
+  }
+  const internals = windowShim.__runtimeInternals || {};
+  expose.forEach((name) => {
+    if (internals[name] === undefined) {
+      throw new Error(`The content runtime defines no "${name}" to expose`);
+    }
+  });
+  return { runtime, internals, window: windowShim, document: documentShim };
+}
+
+/** Render a block that returns a DOM node or a string, uniformly as HTML. */
+export function toHtml(result) {
+  if (result == null) return '';
+  if (typeof result === 'string') return result;
+  if (typeof result.outerHTML === 'string') return result.outerHTML;
+  throw new Error(`Cannot serialize block result of type ${typeof result}`);
+}

data/scripts/test/render-parity/ongoing-product.json

@@ -0,0 +1,5 @@
+{
+  "name": "ongoing-product",
+  "markdown": "{% include ongoing-product.html %}\n\nProduct description follows.",
+  "selectors": ["ongoing-product-badge"]
+}

data/scripts/test/render-parity/plotly.json

@@ -0,0 +1,5 @@
+{
+  "name": "plotly",
+  "markdown": "{% include plotly.html src=\"/media/plots/test-chart.html\" caption=\"Test chart\" width=\"90\" height=\"480\" alt=\"Alt text\" %}",
+  "selectors": ["figure.plotly-figure", "iframe.plotly-embed-frame", "figcaption"]
+}

data/scripts/test/render-parity/poem.json

@@ -0,0 +1,5 @@
+{
+  "name": "poem",
+  "markdown": "<div class=\"poem\" markdown=\"1\">\nLine one\n\nLine two\n</div>",
+  "selectors": ["poem"]
+}

data/scripts/test/render-parity/run-absent-field-checks.mjs

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+// run-absent-field-checks.mjs — the project's central invariant, executed.
+//
+//   An element renders only when the field backing it is present and
+//   non-empty. An absent field means an absent element: never a placeholder,
+//   never an em dash, never a derived stand-in, and never an empty wrapper
+//   whose CSS still paints a rule or a gap.
+//
+// Every case below is a shape real content produces. Roughly half the corpus
+// has no `language`; most posts have no `thumbnail`; `tags` arrived only with
+// the redesign, so older entries have none. The build succeeds either way,
+// which is exactly why this needs a test rather than an eye.
+//
+// Driven by scripts/test/test-absent-field-absent-element.rb.
+
+import { loadRuntime, toHtml } from './load-runtime.mjs';
+import { matchesSelector, countClass } from './selectors.mjs';
+
+const { runtime } = loadRuntime();
+const failures = [];
+let checked = 0;
+
+function record(label, problem) {
+  checked += 1;
+  if (problem) failures.push(`${label}: ${problem}`);
+}
+
+/** The block must render the empty string — not a wrapper, not whitespace. */
+function rendersNothing(label, block, args) {
+  let html;
+  try {
+    html = toHtml(runtime[block](...args));
+  } catch (error) {
+    record(label, `threw ${error.message}`);
+    return;
+  }
+  record(label, html === '' ? null : `rendered ${JSON.stringify(html)}`);
+}
+
+/** The block renders, but must not contain the element the absent field backs. */
+function omits(label, block, args, forbidden) {
+  let html;
+  try {
+    html = toHtml(runtime[block](...args));
+  } catch (error) {
+    record(label, `threw ${error.message}`);
+    return;
+  }
+  const rendered = forbidden.filter((selector) => matchesSelector(html, selector));
+  record(label, rendered.length ? `rendered ${rendered.join(', ')} in ${html}` : null);
+}
+
+function separatorCount(label, parts, expected) {
+  const html = toHtml(runtime.renderMetaStrip(parts));
+  const actual = countClass(html, 'ledger-meta-sep');
+  record(
+    label,
+    actual === expected ? null : `expected ${expected} separators, got ${actual} in ${html}`
+  );
+}
+
+// ── language ──────────────────────────────────────────────────────────────
+// Half the corpus never declared one; a neutral pill would be a lie.
+[
+  ['undefined', undefined],
+  ['null', null],
+  ['empty string', ''],
+  ['whitespace', '   '],
+  ['unknown code', 'de-DE'],
+  ['false', false],
+  ['number zero', 0]
+].forEach(([shape, value]) => {
+  rendersNothing(`renderLangPill / ${shape}`, 'renderLangPill', [value]);
+});
+
+// ── tags ──────────────────────────────────────────────────────────────────
+// `tags` replaced `category` in the redesign, so pre-redesign entries have
+// none, and a hand-edited file can leave an empty or blank-item list.
+[
+  ['undefined', undefined],
+  ['null', null],
+  ['empty array', []],
+  ['array of empty strings', ['', '']],
+  ['array of whitespace', ['  ', '\t']],
+  ['array of nulls', [null, undefined]],
+  ['not an array', 'Engineering'],
+  ['empty string', '']
+].forEach(([shape, value]) => {
+  rendersNothing(`renderTagChips / ${shape}`, 'renderTagChips', [value]);
+});
+
+// ── thumbnail ─────────────────────────────────────────────────────────────
+// Most posts have none. An empty <div class="ledger-poster"> is a bordered
+// plate with nothing in it, which reads as a broken image.
+[
+  ['undefined', undefined],
+  ['null', null],
+  ['empty string', ''],
+  ['whitespace', '  \n ']
+].forEach(([shape, value]) => {
+  rendersNothing(`renderPosterMedia / ${shape}`, 'renderPosterMedia', [value, 'Alt text']);
+});
+
+// ── url / label ───────────────────────────────────────────────────────────
+// A CTA with no destination is an arrow that goes nowhere.
+[
+  ['no href', ['', 'Read article']],
+  ['null href', [null, 'Read article']],
+  ['no label', ['/articles/wsl/', '']],
+  ['null label', ['/articles/wsl/', null]],
+  ['neither', ['', '']]
+].forEach(([shape, args]) => {
+  rendersNothing(`renderCtaLink / ${shape}`, 'renderCtaLink', args);
+});
+
+// ── section banner ────────────────────────────────────────────────────────
+// The title is the only required part; a kicker alone is furniture.
+[
+  ['no options', []],
+  ['empty options', [{}]],
+  ['kicker only', [{ kicker: '02' }]],
+  ['note only', [{ note: '12 entries' }]],
+  ['empty title', [{ title: '', kicker: '02', note: '12 entries' }]]
+].forEach(([shape, args]) => {
+  rendersNothing(`renderSectionBanner / ${shape}`, 'renderSectionBanner', args);
+});
+
+// Optional parts of a banner that does render must still stay absent.
+omits(
+  'renderSectionBanner / title only keeps kicker and note out',
+  'renderSectionBanner',
+  [{ title: 'Long-form inquiries' }],
+  ['ledger-kicker', 'ledger-section-note']
+);
+
+// ── meta strip separators ─────────────────────────────────────────────────
+// The strip is the block most exposed to the rule: it joins parts a caller
+// may or may not have. A dropped part must take its slash with it, or the
+// ledger line reads "02 Jan 2026 /" with nothing after the rule.
+rendersNothing('renderMetaStrip / no parts', 'renderMetaStrip', [[]]);
+rendersNothing('renderMetaStrip / undefined', 'renderMetaStrip', [undefined]);
+rendersNothing('renderMetaStrip / all parts empty', 'renderMetaStrip', [['', null, undefined, '  ']]);
+separatorCount('renderMetaStrip / one part has no separator', ['02 Jan 2026'], 0);
+separatorCount('renderMetaStrip / empty trailing part drops its separator', ['02 Jan 2026', ''], 0);
+separatorCount('renderMetaStrip / empty leading part drops its separator', ['', '02 Jan 2026'], 0);
+separatorCount('renderMetaStrip / empty middle part drops its separator', ['a', '', 'b'], 1);
+separatorCount('renderMetaStrip / null middle part drops its separator', ['a', null, 'b'], 1);
+separatorCount('renderMetaStrip / three survivors take two separators', ['a', 'b', 'c'], 2);
+separatorCount(
+  'renderMetaStrip / mixed absences keep one separator',
+  [null, 'a', '', undefined, 'b', '  '],
+  1
+);
+
+// ── cards and rows: the composed case ─────────────────────────────────────
+// A bare entry — title and nothing else — is what a freshly written draft
+// looks like before any optional field is filled in.
+const bare = { slug: 'bare-draft', front_matter: { title: 'A draft with nothing else' } };
+
+omits(
+  'renderLedgerRow / bare entry',
+  'renderLedgerRow',
+  [bare, { href: '/posts/bare-draft/' }],
+  ['lang-pill', 'ledger-chip-row', 'ledger-chip', 'ledger-row-copy', 'ledger-meta', 'ledger-row-head']
+);
+
+omits(
+  'renderLedgerRow / no cta label leaves no footer rule',
+  'renderLedgerRow',
+  [bare, { href: '/posts/bare-draft/' }],
+  ['ledger-row-foot', 'ledger-cta']
+);
+
+omits(
+  'renderArchiveCard / bare entry',
+  'renderArchiveCard',
+  [bare, { href: '/articles/bare-draft/' }],
+  ['lang-pill', 'ledger-chip-row', 'ledger-chip', 'ledger-card-copy', 'ledger-meta', 'date-evolution']
+);
+
+omits(
+  'renderArchiveCard / dates stay out of the footer unless asked',
+  'renderArchiveCard',
+  [
+    { front_matter: { title: 'Dated', date: '2026-02-24', last_updated: '2026-08-22' } },
+    { href: '/articles/dated/', ctaLabel: 'Read article' }
+  ],
+  ['date-evolution']
+);
+
+omits(
+  'renderSystemCard / project with no media, tags, or links',
+  'renderSystemCard',
+  [{ front_matter: { project: 'Bossa' } }, { href: '/projects/bossa/' }],
+  [
+    'ledger-poster',
+    'ledger-chip-row',
+    'ledger-chip',
+    'ledger-card-copy',
+    'ledger-meta',
+    'ledger-status',
+    // The footer draws a rule above itself, so a project with nothing to link
+    // out to must not render one. Its own page is reached from the title.
+    'ledger-card-foot'
+  ]
+);
+
+omits(
+  'renderSystemCard / label without status renders no status chip',
+  'renderSystemCard',
+  [{ front_matter: { project: 'Bossa', label: 'Simulation' } }, { href: '/projects/bossa/' }],
+  ['ledger-status']
+);
+
+separatorCount('renderSystemCard / label without status drops the separator', ['Simulation', ''], 0);
+
+// The listing preview is derived from description, then excerpt, then body.
+// With all three absent there is nothing to say, so there is no paragraph.
+omits(
+  'renderLedgerRow / no description, excerpt, or body renders no copy',
+  'renderLedgerRow',
+  [{ front_matter: { title: 'Silent' }, body_markdown: '' }, { href: '/posts/silent/' }],
+  ['ledger-row-copy']
+);
+
+if (failures.length) {
+  console.error(`Absent-field rule violated in ${failures.length} of ${checked} cases:`);
+  failures.forEach((line) => console.error(`  - ${line}`));
+  process.exit(1);
+}
+
+console.log(`  ${checked} absent-field cases rendered nothing, as required.`);

data/scripts/test/render-parity/run-block-fixture.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+// run-block-fixture.mjs — render one shared ledger block and check its HTML.
+//
+// Sibling of run-fixture.mjs, which covers the Markdown body pipeline. This
+// one covers _includes/content-runtime/43-blocks.html: the card, row, chip,
+// pill and meta-strip renderers every listing now shares. It calls the real
+// runtime through load-runtime.mjs rather than a second implementation, so a
+// fixture fails when the shipped block changes, not when a copy drifts.
+//
+// Fixture shape:
+//   name       label printed on success
+//   block      function name on the ContentRuntime export
+//   args       positional arguments; see hydrateArgs for the callable forms
+//   empty      true  → the block must render nothing at all
+//   selectors  must be present (see selectors.mjs for the vocabulary)
+//   forbidden  must be absent — this is where the hard rule lives
+//   contains   raw substrings that must appear (attributes, entities, text)
+//   excludes   raw substrings that must not appear
+//   counts     { "class-name": n } exact occurrence counts
+
+import fs from 'node:fs';
+import { loadRuntime, toHtml } from './load-runtime.mjs';
+import { missingSelectors, presentSelectors, countClass } from './selectors.mjs';
+
+// JSON cannot carry the callbacks the blocks accept, so fixtures declare them
+// declaratively and this turns them into functions.
+function hydrateArgs(value) {
+  if (Array.isArray(value)) return value.map(hydrateArgs);
+  if (value && typeof value === 'object') {
+    if (typeof value.$hrefTemplate === 'string') {
+      const template = value.$hrefTemplate;
+      return (input) => template.replace('{value}', encodeURIComponent(String(input)));
+    }
+    const out = {};
+    for (const [key, inner] of Object.entries(value)) out[key] = hydrateArgs(inner);
+    return out;
+  }
+  return value;
+}
+
+const fixturePath = process.argv[2];
+const fixture = JSON.parse(fs.readFileSync(fixturePath, 'utf8'));
+const { runtime } = loadRuntime();
+
+const block = runtime[fixture.block];
+if (typeof block !== 'function') {
+  console.error(`Fixture ${fixture.name}: the runtime exports no block named ${fixture.block}`);
+  process.exit(1);
+}
+
+const html = toHtml(block(...hydrateArgs(fixture.args || [])));
+const failures = [];
+
+if (fixture.empty === true && html !== '') {
+  failures.push(`expected no output, got ${JSON.stringify(html)}`);
+}
+
+const missing = missingSelectors(html, fixture.selectors);
+if (missing.length) failures.push(`missing selectors: ${missing.join(', ')}`);
+
+const present = presentSelectors(html, fixture.forbidden);
+if (present.length) failures.push(`forbidden selectors rendered: ${present.join(', ')}`);
+
+(fixture.contains || []).forEach((needle) => {
+  if (!html.includes(needle)) failures.push(`missing substring: ${JSON.stringify(needle)}`);
+});
+
+(fixture.excludes || []).forEach((needle) => {
+  if (html.includes(needle)) failures.push(`forbidden substring: ${JSON.stringify(needle)}`);
+});
+
+Object.entries(fixture.counts || {}).forEach(([className, expected]) => {
+  const actual = countClass(html, className);
+  if (actual !== expected) {
+    failures.push(`expected ${expected} .${className}, got ${actual}`);
+  }
+});
+
+if (failures.length) {
+  console.error(`Fixture ${fixture.name} (${fixture.block}):`);
+  failures.forEach((line) => console.error(`  - ${line}`));
+  console.error(`  rendered: ${html}`);
+  process.exit(1);
+}
+
+console.log(`Block ${fixture.name}: OK`);