pandorga 1.2.1

data/scripts/test/render-parity/run-detail-parity-checks.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+// run-detail-parity-checks.mjs — the two detail paths must agree.
+//
+// A detail page is built twice. The public site renders it in the browser
+// from _includes/content-runtime/50-detail.html, which delegates to the
+// shared blocks; the private/studio build renders the same page at build time
+// from _layouts/text.html, which reimplements the tag chips and the language
+// pill in Liquid because Liquid cannot call the JS. That layout's own comment
+// promises it emits "exactly the class contract" the runtime emits, and
+// assets/css/ledger/detail.css styles both from one set of rules — so the day
+// the two disagree, one of them loses its styling and the build says nothing.
+//
+// Prints the contract it found, for the Ruby gate to relay.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadRuntime, toHtml, REPO_ROOT } from './load-runtime.mjs';
+
+const LIQUID_DETAIL = path.join(REPO_ROOT, '_layouts', 'text.html');
+const RUNTIME_DETAIL = path.join(REPO_ROOT, '_includes', 'content-runtime', '50-detail.html');
+const BLOCKS = path.join(REPO_ROOT, '_includes', 'content-runtime', '43-blocks.html');
+
+const { runtime } = loadRuntime();
+const failures = [];
+
+const liquid = fs.readFileSync(LIQUID_DETAIL, 'utf8');
+const sidebar = fs.readFileSync(RUNTIME_DETAIL, 'utf8');
+
+// The runtime detail view must delegate, not grow its own copy.
+['renderTagChips'].forEach((block) => {
+  if (!new RegExp(`${block}\\s*\\(`).test(sidebar)) {
+    failures.push(
+      `50-detail.html no longer calls ${block}; the detail sidebar has forked from the block library`
+    );
+  }
+});
+
+// Class contract: whatever the shared block emits, the Liquid copy must emit.
+function classesIn(html) {
+  const found = new Set();
+  const attr = /class="([^"]*)"/g;
+  let match;
+  while ((match = attr.exec(html)) !== null) {
+    match[1].split(/\s+/).filter(Boolean).forEach((name) => found.add(name));
+  }
+  return [...found];
+}
+
+const contract = [
+  { label: 'tag chips (linked)', html: toHtml(runtime.renderTagChips(['Engineering'], { hrefFor: () => '/pages/articles/?tag=Engineering' })) },
+  { label: 'tag chips (plain)', html: toHtml(runtime.renderTagChips(['Engineering'])) }
+];
+
+// A BEM-style modifier is interpolated on the Liquid side
+// (`lang-pill--{{ page.language }}`), so the stem is what can be compared.
+function emittedByLiquid(name) {
+  if (liquid.includes(name)) return true;
+  const stem = name.split('--')[0];
+  return stem !== name && liquid.includes(`${stem}--`);
+}
+
+const reported = new Set();
+contract.forEach(({ label, html }) => {
+  if (!html) {
+    failures.push(`${label}: the block rendered nothing for a populated field`);
+    return;
+  }
+  classesIn(html).forEach((name) => {
+    reported.add(name);
+    if (!emittedByLiquid(name)) {
+      failures.push(
+        `_layouts/text.html never emits "${name}", which the runtime ${label} does. ` +
+          'The private detail build would lose that styling.'
+      );
+    }
+  });
+});
+
+// Language vocabulary: one table in JS, one chain of Liquid conditionals.
+const blocks = fs.readFileSync(BLOCKS, 'utf8');
+const table = blocks.match(/var LANGUAGE_LABELS = \{([\s\S]*?)\};/);
+if (!table) {
+  failures.push('could not find LANGUAGE_LABELS in 43-blocks.html');
+} else {
+  const runtimeLabels = {};
+  table[1].replace(/(\w+)\s*:\s*'([^']*)'/g, (_, code, label) => {
+    runtimeLabels[code] = label;
+    return '';
+  });
+
+  const liquidLabels = {};
+  liquid.replace(
+    /page\.language\s*==\s*"(\w+)"\s*%\}\{%\s*assign\s+lang_label\s*=\s*"([^"]*)"/g,
+    (_, code, label) => {
+      liquidLabels[code] = label;
+      return '';
+    }
+  );
+
+  if (Object.keys(liquidLabels).length === 0) {
+    failures.push('found no lang_label assignments in _layouts/text.html; the scan has drifted');
+  }
+
+  const codes = new Set([...Object.keys(runtimeLabels), ...Object.keys(liquidLabels)]);
+  codes.forEach((code) => {
+    if (runtimeLabels[code] !== liquidLabels[code]) {
+      failures.push(
+        `language "${code}" reads ${JSON.stringify(runtimeLabels[code])} in 43-blocks.html but ` +
+          `${JSON.stringify(liquidLabels[code])} in _layouts/text.html`
+      );
+    }
+  });
+
+  console.log(`  language vocabulary agrees on ${[...codes].sort().join(', ')}`);
+}
+
+if (failures.length) {
+  console.error(`The two detail paths disagree (${failures.length} problem(s)):`);
+  failures.forEach((line) => console.error(`  - ${line}`));
+  process.exit(1);
+}
+
+console.log(`  shared class contract: ${[...reported].sort().join(', ')}`);

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

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+// run-field-flow-checks.mjs — every exported field must reach the view.
+//
+// Two silent-drop traps sit between the exporter and the page, and neither
+// shows up in a build:
+//
+//  1. writingIndexAsListingItem() copies writing_index entries into the
+//     { front_matter } shape the blocks read, through an explicit field
+//     whitelist. A newly exported field is invisible until someone adds a
+//     line there, and nothing complains — that is how `language` reached
+//     writing_index.json and still never made it onto a card.
+//
+//  2. hydrateFrontMatter() merges the detail payload's top-level date and
+//     last_updated into front_matter. It used to do that after an early
+//     return that always fired for exported content, so no detail page ever
+//     showed a date.
+//
+// This walks the real export rather than a fixture, so a field added to
+// scripts/content/export-content-json.rb is covered the day it lands.
+//
+// Usage: node run-field-flow-checks.mjs <exportDir>
+// Driven by scripts/test/test-exported-fields-reach-the-view.rb.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadRuntime } from './load-runtime.mjs';
+
+// Keys the exporter writes into a writing_index entry that a listing item is
+// allowed to drop. Every entry needs a reason; an exclusion that turns out to
+// survive is reported too, so the list cannot rot into a rubber stamp.
+const LISTING_EXCLUSIONS = {
+  xcites:
+    'Cross-reference resolution reads writing_index.json directly ' +
+    '(30-includes-xcite.html). A listing card never renders a citation list.'
+};
+
+const exportDir = process.argv[2];
+if (!exportDir) {
+  console.error('usage: run-field-flow-checks.mjs <exportDir>');
+  process.exit(1);
+}
+
+// hydrateFrontMatter is internal to the runtime; 90-bootstrap.html does not
+// export it, but every detail page depends on what it does.
+const { runtime, internals } = loadRuntime({ expose: ['hydrateFrontMatter'] });
+const hydrateFrontMatter = internals.hydrateFrontMatter;
+const failures = [];
+let checked = 0;
+
+const same = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+
+// ── 1. writing_index entry → listing item ─────────────────────────────────
+
+const entries = JSON.parse(
+  fs.readFileSync(path.join(exportDir, 'data', 'writing_index.json'), 'utf8')
+);
+if (!Array.isArray(entries) || entries.length === 0) {
+  console.error('writing_index.json is empty; nothing to check');
+  process.exit(1);
+}
+
+const exportedKeys = new Set();
+entries.forEach((entry) => Object.keys(entry).forEach((key) => exportedKeys.add(key)));
+
+Object.keys(LISTING_EXCLUSIONS).forEach((key) => {
+  if (!exportedKeys.has(key)) {
+    failures.push(
+      `exclusion list names "${key}", which the exporter no longer writes — remove it`
+    );
+  }
+});
+
+// One entry per key is enough to prove the whitelist covers it, but which
+// entry matters: an entry whose value is empty would pass a whitelist that
+// dropped the key. Prefer an entry with a populated value.
+function witnessFor(key) {
+  return (
+    entries.find((entry) => {
+      const value = entry[key];
+      if (value == null || value === '') return false;
+      return !(Array.isArray(value) && value.length === 0);
+    }) || entries[0]
+  );
+}
+
+[...exportedKeys].sort().forEach((key) => {
+  checked += 1;
+  const entry = witnessFor(key);
+  const item = runtime.writingIndexAsListingItem(entry);
+  const fm = item.front_matter || {};
+  const survives = same(item[key], entry[key]) || same(fm[key], entry[key]);
+
+  if (Object.prototype.hasOwnProperty.call(LISTING_EXCLUSIONS, key)) {
+    if (survives && !same(entry[key], undefined)) {
+      failures.push(
+        `"${key}" is on the exclusion list but now survives into the listing item — ` +
+          'delete the exclusion rather than leaving it stale'
+      );
+    }
+    return;
+  }
+
+  if (!survives) {
+    failures.push(
+      `writingIndexAsListingItem drops "${key}" (exporter value ` +
+        `${JSON.stringify(entry[key])} for ${entry.key || entry.slug}). ` +
+        'Add it to the whitelist in _includes/content-runtime/60-fragments.html, ' +
+        'or to LISTING_EXCLUSIONS here with a reason.'
+    );
+  }
+});
+
+// The whitelist must not invent values either: a key the exporter never wrote
+// has no business appearing on a listing item.
+const listingKeys = new Set();
+{
+  const item = runtime.writingIndexAsListingItem(entries[0]);
+  Object.keys(item).forEach((key) => key !== 'front_matter' && listingKeys.add(key));
+  Object.keys(item.front_matter || {}).forEach((key) => listingKeys.add(key));
+}
+[...listingKeys].sort().forEach((key) => {
+  checked += 1;
+  if (!exportedKeys.has(key)) {
+    failures.push(
+      `writingIndexAsListingItem reads "${key}", which no writing_index entry carries — ` +
+        'the field is always undefined on a card'
+    );
+  }
+});
+
+// ── 2. collection payload → hydrated detail front matter ──────────────────
+
+function collectionPayloads() {
+  const root = path.join(exportDir, 'collections');
+  return fs
+    .readdirSync(root, { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .flatMap((dirent) => {
+      const dir = path.join(root, dirent.name);
+      return fs
+        .readdirSync(dir)
+        .filter((name) => name.endsWith('.json'))
+        .map((name) => ({
+          label: `${dirent.name}/${name}`,
+          payload: JSON.parse(fs.readFileSync(path.join(dir, name), 'utf8'))
+        }));
+    });
+}
+
+const payloads = collectionPayloads();
+if (payloads.length === 0) {
+  console.error('no exported collection objects; nothing to hydrate');
+  process.exit(1);
+}
+
+let datedPayloads = 0;
+payloads.forEach(({ label, payload }) => {
+  const before = JSON.parse(JSON.stringify(payload.front_matter || {}));
+  const hydrated = hydrateFrontMatter(JSON.parse(JSON.stringify(payload)));
+  const fm = hydrated.front_matter || {};
+  checked += 1;
+
+  if (payload.date) {
+    datedPayloads += 1;
+    if (fm.date !== payload.date) {
+      failures.push(
+        `${label}: hydrateFrontMatter left front_matter.date as ${JSON.stringify(fm.date)} ` +
+          `for a payload dated ${payload.date} — the detail view shows no date`
+      );
+    }
+  }
+  if (payload.last_updated && fm.last_updated !== payload.last_updated) {
+    failures.push(
+      `${label}: hydrateFrontMatter dropped last_updated ` +
+        `(${payload.last_updated} → ${JSON.stringify(fm.last_updated)})`
+    );
+  }
+  Object.entries(before).forEach(([key, value]) => {
+    if (key === 'date' || key === 'last_updated') return;
+    if (!same(fm[key], value)) {
+      failures.push(
+        `${label}: hydrateFrontMatter changed front_matter.${key} ` +
+          `from ${JSON.stringify(value)} to ${JSON.stringify(fm[key])}`
+      );
+    }
+  });
+});
+
+if (datedPayloads === 0) {
+  failures.push('no exported payload carried a date; the date-promotion check proved nothing');
+}
+
+// Raw Markdown that has not been through the exporter still has its block
+// parsed — that path is why the early return existed in the first place.
+{
+  checked += 1;
+  const raw = hydrateFrontMatter({
+    body_markdown: '---\ntitle: Raw\nlanguage: enus\n---\nBody text.\n',
+    date: '2026-03-01'
+  });
+  const fm = raw.front_matter || {};
+  if (fm.title !== 'Raw' || fm.language !== 'enus') {
+    failures.push(
+      `hydrateFrontMatter stopped parsing inline front matter (got ${JSON.stringify(fm)})`
+    );
+  }
+  if (fm.date !== '2026-03-01') {
+    failures.push('hydrateFrontMatter dropped the payload date when a block was parsed');
+  }
+  if (raw.body_markdown.trim() !== 'Body text.') {
+    failures.push(`hydrateFrontMatter left the block in body_markdown: ${JSON.stringify(raw.body_markdown)}`);
+  }
+}
+
+if (failures.length) {
+  console.error(`Exported fields did not reach the view (${failures.length} problem(s)):`);
+  failures.forEach((line) => console.error(`  - ${line}`));
+  process.exit(1);
+}
+
+const excluded = Object.keys(LISTING_EXCLUSIONS);
+console.log(
+  `  ${exportedKeys.size} writing_index keys reach a listing item ` +
+    `(${excluded.length} documented exclusion: ${excluded.join(', ')}).`
+);
+console.log(`  ${payloads.length} detail payloads hydrate with their dates and front matter intact.`);
+console.log(`  ${checked} field-flow checks.`);

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

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { marked } from 'marked';
+import { missingSelectors } from './selectors.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function parseIncludeAttrs(raw) {
+  const attrs = {};
+  let text = String(raw || '');
+  text = text.replace(/([\w-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g, (_, key, dbl, sgl) => {
+    attrs[key] = dbl != null ? dbl : sgl;
+    return '';
+  });
+  text.replace(/([\w-]+)\s*=\s*([^\s]+)/g, (_, key, val) => {
+    if (!(key in attrs)) attrs[key] = val;
+    return '';
+  });
+  return attrs;
+}
+
+function escapeAttr(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function unwrapMediaSrc(path) {
+  const value = String(path == null ? '' : path).trim();
+  if (!value) return '';
+  const md = value.match(/^\[([^\]]*)\]\(([^)\s]+)\)\s*$/);
+  if (md) return String(md[2] || '').trim();
+  const angle = value.match(/^<([^>\s]+)>\s*$/);
+  if (angle) return String(angle[1] || '').trim();
+  return value;
+}
+
+function cutInHtml(attrs) {
+  const src = unwrapMediaSrc(attrs.src);
+  if (!src) return '';
+  const sideClass = attrs.side === 'right' ? ' article-cut-in--right' : '';
+  return `<figure class="article-cut-in-plate${sideClass}"><img class="article-cut-in${sideClass}" src="${escapeAttr(src)}" alt="${escapeAttr(attrs.alt || '')}" width="120" loading="lazy"></figure>`;
+}
+
+function figureHtml(attrs) {
+  const src = unwrapMediaSrc(attrs.src);
+  if (!src) return '';
+  const width = attrs.width ? `max-width:${escapeAttr(attrs.width)}%;` : 'max-width:100%;';
+  const caption = attrs.caption || '';
+  const lbAttr = caption ? ` data-lightbox-caption="${escapeAttr(caption)}"` : '';
+  return [
+    `<figure class="my-8 mx-auto text-center w-full" style="display:block;${width}">`,
+    `<img class="figure-lightbox-trigger" src="${escapeAttr(src)}" alt="${escapeAttr(attrs.alt || caption)}" loading="lazy" tabindex="0" role="button" aria-label="Enlarge image"${lbAttr}>`,
+    caption ? `<figcaption class="mt-3">${escapeAttr(caption)}</figcaption>` : '',
+    '</figure>'
+  ].join('');
+}
+
+function plotlyHtml(attrs) {
+  const src = unwrapMediaSrc(attrs.src);
+  if (!src) return '';
+  const width = attrs.width ? String(attrs.width).trim() : '100';
+  const height = attrs.height && /^\d+$/.test(String(attrs.height).trim())
+    ? String(attrs.height).trim()
+    : '480';
+  const caption = attrs.caption || '';
+  const title = attrs.alt || caption || 'Interactive chart';
+  return [
+    `<figure class="plotly-figure my-8 mx-auto text-center w-full" style="display:block;max-width:${escapeAttr(width)}%;">`,
+    `<iframe class="plotly-embed-frame" src="${escapeAttr(src)}" title="${escapeAttr(title)}" loading="lazy" scrolling="no" style="width:100%;height:${escapeAttr(height)}px;border:0;display:block;"></iframe>`,
+    caption ? `<figcaption class="mt-3">${escapeAttr(caption)}</figcaption>` : '',
+    '</figure>'
+  ].join('');
+}
+
+function youtubeHtml(attrs, isShort) {
+  const id = attrs.id || attrs.youtube_id || (isShort ? attrs.src : '');
+  if (!id) return '';
+  const aspect = isShort ? 'aspect-ratio: 9 / 16;' : 'aspect-ratio: 16 / 9;';
+  return `<figure class="my-8 mx-auto text-center w-full"><div style="${aspect}"><iframe src="https://www.youtube.com/embed/${escapeAttr(id)}"></iframe></div></figure>`;
+}
+
+function youtubeShortHtml(attrs) {
+  const src = attrs.src || attrs.id || attrs.id1;
+  const src2 = attrs.src2 || attrs.id2;
+  if (!src) return '';
+  const frame = (id) =>
+    `<iframe width="315" height="560" src="https://www.youtube.com/embed/${escapeAttr(id)}" title="YouTube short"></iframe>`;
+  return `<figure class="my-8 mx-auto text-center w-full"><div class="article-youtube-short${src2 ? ' article-youtube-short--pair' : ''}">${frame(src)}${src2 ? frame(src2) : ''}</div></figure>`;
+}
+
+function videoHtml(attrs) {
+  const src = unwrapMediaSrc(attrs.src);
+  if (!src) return '';
+  return `<figure><video controls src="${escapeAttr(src)}"></video>${attrs.caption ? `<figcaption>${escapeAttr(attrs.caption)}</figcaption>` : ''}</figure>`;
+}
+
+function ongoingProductHtml() {
+  return '<span class="ongoing-product-badge" style="display: inline-block; padding: 0.15rem 0.5rem; background: var(--color-surface-container-low); border-radius: 0.25rem; font-size: 0.8rem; color: var(--color-on-surface-variant);">Currently active</span>';
+}
+
+function preprocessLiquid(markdown) {
+  return String(markdown)
+    .replace(/\{%-?\s*include\s+cut-in\.html\s+([\s\S]*?)-?%\}/g, (_, raw) => cutInHtml(parseIncludeAttrs(raw)))
+    .replace(/\{%-?\s*include\s+figure\.html\s+([\s\S]*?)-?%\}/g, (_, raw) => figureHtml(parseIncludeAttrs(raw)))
+    .replace(/\{%-?\s*include\s+plotly\.html\s+([\s\S]*?)-?%\}/g, (_, raw) => plotlyHtml(parseIncludeAttrs(raw)))
+    .replace(/\{%-?\s*include\s+youtube-short\.html\s+([\s\S]*?)-?%\}/g, (_, raw) => youtubeShortHtml(parseIncludeAttrs(raw)))
+    .replace(/\{%-?\s*include\s+youtube\.html\s+([\s\S]*?)-?%\}/g, (_, raw) => youtubeHtml(parseIncludeAttrs(raw), false))
+    .replace(/\{%-?\s*include\s+video\.html\s+([\s\S]*?)-?%\}/g, (_, raw) => videoHtml(parseIncludeAttrs(raw)))
+    .replace(/\{%-?\s*include\s+ongoing-product\.html\s*-?%\}/g, () => ongoingProductHtml());
+}
+
+function hasMarkdownAttr(openTag) {
+  return /\bmarkdown\s*=\s*["']1["']/i.test(String(openTag || ''));
+}
+
+function preprocessMarkdownDivs(markdown) {
+  let text = String(markdown || '');
+  text = text.replace(/<div\s+([^>]*class="[^"]*\barticle-note\b[^"]*"[^>]*)>([\s\S]*?)<\/div>/gi, (match, openTag, inner) => {
+    if (!hasMarkdownAttr(openTag)) return match;
+    return `<div class="article-note">${marked.parse(inner.trim())}</div>`;
+  });
+  text = text.replace(/<div\s+([^>]*class="[^"]*\bpoem\b[^"]*"[^>]*)>([\s\S]*?)<\/div>/gi, (match, openTag, inner) => {
+    if (!hasMarkdownAttr(openTag)) return match;
+    return `<div class="poem"><p>${inner.trim()}</p></div>`;
+  });
+  return text;
+}
+
+function render(markdown) {
+  const prepared = preprocessMarkdownDivs(preprocessLiquid(markdown));
+  return marked.parse(prepared, { gfm: true, breaks: false });
+}
+
+const fixturePath = process.argv[2];
+const fixture = JSON.parse(fs.readFileSync(fixturePath, 'utf8'));
+const html = render(fixture.markdown);
+const missing = missingSelectors(html, fixture.selectors);
+
+if (missing.length) {
+  console.error(`Fixture ${fixture.name}: missing selectors ${missing.join(', ')}`);
+  console.error(html);
+  process.exit(1);
+}
+
+if (fixture.paragraphCount != null) {
+  const count = (html.match(/<p\b/gi) || []).length;
+  if (count !== fixture.paragraphCount) {
+    console.error(`Fixture ${fixture.name}: expected ${fixture.paragraphCount} <p>, got ${count}`);
+    console.error(html);
+    process.exit(1);
+  }
+}
+
+console.log(`Fixture ${fixture.name}: OK`);

data/scripts/test/render-parity/selectors.mjs

@@ -0,0 +1,43 @@
+// selectors.mjs — the fixture selector vocabulary, shared by both runners.
+//
+// Fixtures describe expectations as selector-ish strings rather than parsing
+// the HTML, so a fixture stays readable and the runners stay dependency-free.
+// Supported forms:
+//   "iframe" / "img" / "video" / "blockquote"  bare tag
+//   "span.lang-pill"                           tag with class
+//   "ledger-chip-row"                          class name, or a tag name
+//
+// Class matching is whole-token, not \b-delimited: a hyphen is a word
+// boundary, so `\bledger-chip\b` also matches class="ledger-chip-row" and
+// every count comes out one too high.
+
+function classPattern(name, flags = 'i') {
+  return new RegExp(`class="(?:[^"]*\\s)?${name}(?:\\s[^"]*)?"`, flags);
+}
+
+export function matchesSelector(html, selector) {
+  if (selector === 'iframe') return /<iframe\b/i.test(html);
+  if (selector === 'img') return /<img\b/i.test(html);
+  if (selector === 'video') return /<video\b/i.test(html);
+  if (selector === 'blockquote') return /<blockquote\b/i.test(html);
+  const tagClass = String(selector).match(/^([a-z][\w-]*)\.([a-z][\w-]*)$/i);
+  if (tagClass) {
+    const [, tag, cls] = tagClass;
+    return new RegExp(`<${tag}\\b[^>]*class="(?:[^"]*\\s)?${cls}(?:\\s[^"]*)?"`, 'i').test(html);
+  }
+  return classPattern(selector).test(html) || new RegExp(`<${selector}\\b`, 'i').test(html);
+}
+
+export function missingSelectors(html, selectors) {
+  return (selectors || []).filter((selector) => !matchesSelector(html, selector));
+}
+
+export function presentSelectors(html, selectors) {
+  return (selectors || []).filter((selector) => matchesSelector(html, selector));
+}
+
+/** How many elements carry the class, for "exactly one separator" assertions. */
+export function countClass(html, className) {
+  const matches = html.match(classPattern(className, 'gi'));
+  return matches ? matches.length : 0;
+}

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

@@ -0,0 +1,5 @@
+{
+  "name": "video",
+  "markdown": "{% include video.html src=\"/media/videos/sample.mp4\" caption=\"Sample\" %}",
+  "selectors": ["figure", "video"]
+}

data/scripts/test/render-parity/youtube-short.json

@@ -0,0 +1,10 @@
+{
+  "name": "youtube-short",
+  "markdown": "{% include youtube-short.html src=\"abc123\" src2=\"def456\" %}",
+  "selectors": [
+    "figure",
+    "article-youtube-short",
+    "article-youtube-short--pair",
+    "iframe"
+  ]
+}

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

@@ -0,0 +1,8 @@
+{
+  "name": "youtube",
+  "markdown": "{% include youtube.html id=\"dQw4w9WgXcQ\" caption=\"Test video\" %}",
+  "selectors": [
+    "figure",
+    "iframe"
+  ]
+}

data/scripts/test/test-absent-field-absent-element.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Gate: an element renders only when the field backing it is present.
+#
+# This is the site's central editorial invariant, and the one the build cannot
+# see. The shared ledger blocks run in the browser, so `jekyll build` succeeds
+# whether a card shows a language pill for a piece that never declared one, an
+# empty poster plate where there is no thumbnail, or a meta strip that ends in
+# a dangling slash. Every failure of this kind has to be caught by executing
+# the blocks, which is what scripts/test/render-parity/run-absent-field-checks.mjs
+# does against the real _includes/content-runtime/43-blocks.html.
+#
+# The positive half of the contract — present field, present element — lives in
+# scripts/test/render-parity/blocks/*.json, so a block cannot pass this gate by
+# rendering nothing at all.
+
+require "open3"
+require "pathname"
+
+ROOT = Pathname.new(__dir__).join("..", "..").expand_path
+CHECKS = Pathname.new(__dir__).join("render-parity", "run-absent-field-checks.mjs")
+
+def fail!(message)
+  warn message
+  exit 1
+end
+
+puts "Testing the absent-field / absent-element rule..."
+
+fail!("missing #{CHECKS}") unless CHECKS.file?
+
+stdout, stderr, status = Open3.capture3(
+  "node", CHECKS.to_s, chdir: ROOT.join("scripts").to_s
+)
+
+print stdout
+unless status.success?
+  warn stderr unless stderr.strip.empty?
+  fail!("Absent fields rendered elements. An absent field means an absent element.")
+end
+
+puts "All absent-field / absent-element checks passed."

data/scripts/test/test-cdn-pins.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "json"
+require "pathname"
+require "set"
+
+ROOT = Pathname.new(__dir__).join("..", "..").expand_path
+ALLOWLIST = JSON.parse(File.read(ROOT.join("scripts/cdn-allowlist.json")))
+ALLOWED = ALLOWLIST.fetch("allowed_urls").to_set
+SCAN_DIRS = ALLOWLIST.fetch("scan_globs")
+
+CDN_ATTR_RE = /
+  (?:src|href)\s*=\s*["']
+  (https?:\/\/[^"']+)
+  ["']
+/ix
+
+errors = []
+
+SCAN_DIRS.each do |relative|
+  dir = ROOT.join(relative)
+  next unless dir.directory?
+
+  Dir.glob(dir.join("**/*.{html,js,liquid}")).sort.each do |file|
+    path = Pathname.new(file)
+    text = path.read
+    text.scan(CDN_ATTR_RE).flatten.each do |url|
+      next unless url.include?("cdn.jsdelivr.net") || url.include?("cdn.tailwindcss.com")
+
+      next if ALLOWED.include?(url)
+
+      errors << "#{path.relative_path_from(ROOT)}: unlisted CDN URL #{url}"
+    end
+  end
+end
+
+if errors.any?
+  warn "CDN pin validation failed:"
+  errors.each { |line| warn "  - #{line}" }
+  exit 1
+end
+
+puts "CDN pin validation OK (#{ALLOWED.size} allowed URLs)."