book-kit 0.0.0-stage → 0.6.0

package/commands/links-to-footnotes.js

@@ -0,0 +1,366 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { isMain } from '../lib/is-main.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Helper function to generate backup directory name with timestamp
+function generateBackupDirName(srcDirectory) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').replace(/T/, '_').slice(0, -5);
+  return `${srcDirectory}_backup_${timestamp}`;
+}
+
+class LinksToFootnotes {
+  // Regex pattern for markdown links: [text](url)
+  // Capture groups: 1=link text, 2=url (with optional angle brackets), 3=trailing punctuation
+  static LINK_PATTERN = /\[((?:[^[\]]|\[[^\]]*\])+)\]\((<[^>]+>|[^)]+)\)([).,;:!?]*)/g;
+  
+  // Regex pattern for footnote references that appear BEFORE sentence-ending punctuation
+  // Used to reorder "text[^1]." to "text.[^1]"
+  // Capture groups: 1=footnote reference, 2=punctuation
+  static FOOTNOTE_BEFORE_PUNCT_PATTERN = /(\[\^[^\]]+\])([.!?])/g;
+
+  // Regex pattern for heading attribute blocks containing an explicit ID, e.g., "{#id .class}"
+  // Uses \s\{ to require whitespace before {, so inline spans like [URL]{.smallcaps} aren't matched
+  static HEADING_ID_ATTR_PATTERN = /\s\{[^}]*#([A-Za-z0-9_:-]+)[^}]*\}\s*$/;
+  
+  // Regex pattern for any trailing heading attribute block, e.g., "{.class}" or "{epub:type=appendix}"
+  static HEADING_ATTR_PATTERN = /\s\{[^}]+\}\s*$/;
+
+  constructor(srcDirectory, createBackup = true, preserveInternalLinks = false, linkFootnoteUrls = false) {
+    this.srcDirectory = srcDirectory;
+    this.createBackup = createBackup;
+    this.preserveInternalLinks = preserveInternalLinks;
+    // E-readers can follow a link in a footnote, so the Kindle build keeps the
+    // URLs there clickable; print gets plain text, since paper can't.
+    this.linkFootnoteUrls = linkFootnoteUrls;
+    this.globalFootnoteCounter = 1;
+    this.anchorMap = {};
+  }
+
+  async processAllFiles() {
+    const files = fs.readdirSync(this.srcDirectory)
+      .filter(f => f.endsWith('.md'))
+      .sort()
+      .map(f => path.join(this.srcDirectory, f));
+    
+    console.log(`Found ${files.length} markdown files to process`);
+    
+    // First pass: build anchor mapping
+    this.buildAnchorMap(files);
+    
+    // Second pass: process files
+    for (const filePath of files) {
+      this.processFile(filePath);
+    }
+    
+    console.log('Finished processing all files');
+  }
+
+  // Helper method to pluralize a word based on count
+  pluralize(count, singular, plural = null) {
+    plural = plural || `${singular}s`;
+    return count === 1 ? singular : plural;
+  }
+
+  // Parse a raw heading string to extract the custom ID and cleaned title.
+  // Uses \s\{ (not \s*\{) to require whitespace before {, distinguishing
+  // heading attributes like {#id} from inline span attributes like [URL]{.smallcaps}.
+  parseHeading(rawHeading) {
+    const idMatch = rawHeading.match(LinksToFootnotes.HEADING_ID_ATTR_PATTERN);
+    if (idMatch) {
+      const customId = idMatch[1];
+      const title = rawHeading.replace(LinksToFootnotes.HEADING_ID_ATTR_PATTERN, '').trim();
+      return { customId, title };
+    }
+    const title = rawHeading.replace(LinksToFootnotes.HEADING_ATTR_PATTERN, '').trim();
+    return { customId: null, title };
+  }
+
+  buildAnchorMap(files) {
+    console.log('Building anchor map from headings...');
+    
+    // Track anchor usage to handle duplicates with Pandoc's numbering scheme
+    const anchorCounts = {};
+    
+    for (const filePath of files) {
+      const content = fs.readFileSync(filePath, 'utf8');
+      let currentChapter = null;
+      
+      for (const line of content.split('\n')) {
+        // Match headings at levels 1-4
+        const match = line.match(/^(#{1,4})\s+(.+)$/);
+        if (!match) continue;
+
+        const level = match[1].length;
+        const { customId, title } = this.parseHeading(match[2].trim());
+
+        let anchor = customId || this.generateAnchor(title);
+        anchor = this.handleDuplicateAnchor(anchor, anchorCounts);
+
+        if (level <= 2) currentChapter = title;
+
+        this.anchorMap[anchor] = {
+          title,
+          chapter: level <= 2 ? title : currentChapter,
+          level,
+        };
+      }
+    }
+    
+    console.log(`  Built map with ${Object.keys(this.anchorMap).length} anchors`);
+  }
+  
+  handleDuplicateAnchor(anchor, anchorCounts) {
+    // Track how many times we've seen this anchor
+    if (anchorCounts[anchor] > 0) {
+      // This is a duplicate - append the count like Pandoc does
+      const numberedAnchor = `${anchor}-${anchorCounts[anchor]}`;
+      anchorCounts[anchor]++;
+      return numberedAnchor;
+    } else {
+      // First occurrence
+      anchorCounts[anchor] = 1;
+      return anchor;
+    }
+  }
+
+  generateAnchor(title) {
+    // Approximate Pandoc's auto_identifiers algorithm:
+    // 1. Strip Markdown formatting (attribute blocks, spans, links, images, code, emphasis).
+    // 2. Normalize punctuation (some chars to hyphens).
+    // 3. Lowercase, collapse whitespace to hyphens, and trim extra hyphens.
+
+    let stripped = title;
+
+    // Remove trailing attribute block, e.g., "{#id .class}"
+    stripped = stripped.replace(LinksToFootnotes.HEADING_ATTR_PATTERN, '');
+
+    // Inline spans: "[text]{.class}" -> "text"
+    stripped = stripped.replace(/\[([^\]]+)\]\{[^}]*\}/g, '$1');
+
+    // Images: "![alt](url)" -> "alt"
+    stripped = stripped.replace(/!\[([^\]]*)\]\([^)]+\)/g, '$1');
+
+    // Links: "[text](url)" -> "text"
+    stripped = stripped.replace(/\[([^\]]+)\]\([^)]+\)/g, '$1');
+
+    // Inline code: "`code`" -> "code"
+    stripped = stripped.replace(/`([^`]*)`/g, '$1');
+
+    // Emphasis markers: "*text*", "_text_", "~text~", etc. -> "text"
+    stripped = stripped.replace(/[*_~^]+/g, '');
+
+    return stripped
+      .toLowerCase()
+      .replace(/[^\w\s-]/g, '')  // Strip punctuation (matches Pandoc auto_identifiers: apostrophes, colons, quotes etc. are removed, not hyphenated)
+      .replace(/\s+/g, '-')      // Replace spaces with hyphens
+      .replace(/-+/g, '-')       // Replace multiple hyphens with single hyphen
+      .replace(/^-|-$/g, '');    // Remove leading/trailing hyphens
+  }
+
+  // A footnote's URL: an autolink when the reader can tap it, else plain text.
+  // Pandoc's Markdown doesn't autolink bare URLs, so plain text stays plain.
+  formatFootnoteUrl(url) {
+    return this.linkFootnoteUrls ? `<${url}>` : url;
+  }
+
+  internalLink(url) {
+    return url.startsWith('#');
+  }
+
+  formatInternalLink(linkText, anchor) {
+    // Remove leading # from anchor
+    anchor = anchor.replace(/^#/, '');
+
+    // Look up the anchor in our map
+    const info = this.anchorMap[anchor];
+
+    if (!info) {
+      // If we can't find the anchor, fall back to the old behavior (footnote)
+      return null;
+    }
+
+    // When preserving internal links (e.g., Kindle EPUB), keep the markdown
+    // link so Pandoc converts it to a clickable internal navigation link.
+    // Kindle KF8 supports intra-book links, unlike printed PDF.
+    if (this.preserveInternalLinks) {
+      return `[${linkText}](#${anchor})`;
+    }
+
+    // For PDF: strip the link syntax and return just the link text
+    // (printed books can't have clickable links)
+    return linkText;
+  }
+
+  processFile(filePath) {
+    console.log(`Processing ${path.basename(filePath)}...`);
+    
+    const content = fs.readFileSync(filePath, 'utf8');
+    const originalContent = content;
+    
+    // Process content line by line to handle footnotes differently
+    const lines = content.split('\n');
+    const footnotes = [];
+    let parentheticalCount = 0;
+    
+    let inFencedCodeBlock = false;
+
+    const processedLines = lines.map(line => {
+      // Track fenced code blocks (``` or ~~~)
+      if (/^(`{3,}|~{3,})/.test(line)) {
+        inFencedCodeBlock = !inFencedCodeBlock;
+        return line;
+      }
+
+      // Skip lines inside fenced code blocks
+      if (inFencedCodeBlock) {
+        return line;
+      }
+
+      // Check if this line is a footnote definition
+      if (line.match(/^\[?\^[^\]]+\]:/)) {
+        // Within footnote definitions, convert links to parentheticals
+        return line.replace(LinksToFootnotes.LINK_PATTERN, (match, linkText, url, trailingPunct) => {
+          // Remove angle brackets if present
+          url = url.replace(/^<|>$/g, '');
+          
+          // Convert all links to parentheticals in footnotes
+          parentheticalCount++;
+          return `${linkText} (${this.formatFootnoteUrl(url)})${trailingPunct}`;
+        });
+      } else {
+        // Mask inline code spans so links inside them aren't converted.
+        // Replace each `...` span with a placeholder, apply link conversion,
+        // then restore the original code spans.
+        const codeSpans = [];
+        const masked = line.replace(/`[^`]+`/g, (m) => {
+          codeSpans.push(m);
+          return `\x00CODE${codeSpans.length - 1}\x00`;
+        });
+
+        // Outside footnote definitions, handle links
+        const processed = masked.replace(LinksToFootnotes.LINK_PATTERN, (match, linkText, url, trailingPunct) => {
+          // Remove angle brackets if present
+          url = url.replace(/^<|>$/g, '');
+          
+          // Check if this is an internal link
+          if (this.internalLink(url)) {
+            // Try to format as an internal reference
+            const formatted = this.formatInternalLink(linkText, url);
+            
+            if (formatted) {
+              return `${formatted}${trailingPunct}`;
+            } else {
+              // If we can't resolve it, create a footnote (fallback)
+              const footnoteId = this.globalFootnoteCounter++;
+              footnotes.push({ id: footnoteId, url });
+              // Footnote references should appear AFTER punctuation
+              return `${linkText}${trailingPunct}[^${footnoteId}]`;
+            }
+          } else {
+            // External link - create footnote
+            // Footnote references should appear AFTER punctuation
+            const footnoteId = this.globalFootnoteCounter++;
+            footnotes.push({ id: footnoteId, url });
+            return `${linkText}${trailingPunct}[^${footnoteId}]`;
+          }
+        });
+
+        // Restore inline code spans (NUL-delimited placeholders)
+        // eslint-disable-next-line no-control-regex
+        return processed.replace(/\x00CODE(\d+)\x00/g, (_, i) => codeSpans[i]);
+      }
+    });
+    
+    let newContent = processedLines.join('\n');
+    
+    // Fix existing footnote references where they appear before punctuation
+    // e.g., "text[^1]." should become "text.[^1]"
+    // This ensures consistent formatting for all footnotes (both existing and newly created)
+    let footnoteReorderCount = 0;
+    newContent = newContent.replace(LinksToFootnotes.FOOTNOTE_BEFORE_PUNCT_PATTERN, (match, footnoteRef, punct) => {
+      footnoteReorderCount++;
+      return `${punct}${footnoteRef}`;
+    });
+    
+    if (footnoteReorderCount > 0) {
+      console.log(`  Reordered ${footnoteReorderCount} footnote ${this.pluralize(footnoteReorderCount, 'reference')} to appear after punctuation`);
+    }
+    
+    // Add footnote definitions at the end of the file if we found any links
+    if (footnotes.length > 0) {
+      console.log(`  Found ${footnotes.length} ${this.pluralize(footnotes.length, 'link')} to convert to footnotes`);
+      
+      // Add footnotes at the end
+      newContent += '\n\n';
+      for (const footnote of footnotes) {
+        newContent += `[^${footnote.id}]: ${this.formatFootnoteUrl(footnote.url)}\n`;
+      }
+    }
+    
+    // Report parenthetical conversions
+    if (parentheticalCount > 0) {
+      console.log(`  Converted ${parentheticalCount} ${this.pluralize(parentheticalCount, 'link')} within footnotes to parentheticals`);
+    }
+    
+    // Only write if content changed
+    if (newContent !== originalContent) {
+      fs.writeFileSync(filePath, newContent);
+      console.log('  Updated successfully');
+    } else {
+      console.log('  No changes needed');
+    }
+  }
+}
+
+// Script execution
+if (isMain(import.meta.url)) {
+  (async () => {
+    const args = process.argv.slice(2);
+    
+    if (args.length < 1 || args.length > 4) {
+      console.error(`Usage: ${path.basename(process.argv[1])} <source_directory> [--no-backup] [--preserve-internal-links] [--link-footnote-urls]`);
+      console.error(`Example: ${path.basename(process.argv[1])} src`);
+      console.error(`Example: ${path.basename(process.argv[1])} src --no-backup`);
+      console.error(`Example: ${path.basename(process.argv[1])} src --no-backup --preserve-internal-links`);
+      console.error(`Example: ${path.basename(process.argv[1])} src --no-backup --preserve-internal-links --link-footnote-urls`);
+      process.exit(1);
+    }
+
+    const srcDirectory = args[0];
+    const flags = args.slice(1);
+    const createBackup = !flags.includes('--no-backup');
+    const preserveInternalLinks = flags.includes('--preserve-internal-links');
+    const linkFootnoteUrls = flags.includes('--link-footnote-urls');
+
+    if (!fs.existsSync(srcDirectory)) {
+      console.error(`Error: Directory '${srcDirectory}' does not exist`);
+      process.exit(1);
+    }
+
+    // Create a backup directory only if requested
+    if (createBackup) {
+      const backupDir = generateBackupDirName(srcDirectory);
+      console.log(`Creating backup in ${backupDir}...`);
+      fs.cpSync(srcDirectory, backupDir, { recursive: true });
+      console.log('Backup created successfully');
+      
+      // Process files
+      const converter = new LinksToFootnotes(srcDirectory, createBackup, preserveInternalLinks, linkFootnoteUrls);
+      await converter.processAllFiles();
+      
+      console.log(`\nDone! Original files backed up to ${backupDir}`);
+    } else {
+      // Process files
+      const converter = new LinksToFootnotes(srcDirectory, createBackup, preserveInternalLinks, linkFootnoteUrls);
+      await converter.processAllFiles();
+      
+      console.log('\nDone! No backup created (--no-backup specified)');
+    }
+  })();
+}

package/commands/markdownlint.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+// book-kit markdownlint [markdownlint-cli2 options] [globs]
+//
+// Markdown lint with markdownlint-cli2 and the book's resolved config
+// (lib/lint.js): the kit's base config with lint.markdownlint merged in.
+// Globs default to every chapter in paths.src.
+
+import { spawnSync } from 'node:child_process';
+import { loadConfig } from '../lib/config.js';
+import { namesFiles, prepareMarkdownlint } from '../lib/lint.js';
+
+const config = loadConfig();
+const configFile = prepareMarkdownlint(config);
+
+// Arguments pass through in order; the chapters glob is added only when none names files.
+const args = process.argv.slice(2);
+
+const result = spawnSync(
+  'npx',
+  ['markdownlint-cli2', '--config', configFile, ...(namesFiles(args, config.root) ? [] : [`${config.paths.src}/*.md`]), ...args],
+  { stdio: 'inherit', cwd: config.root },
+);
+if (result.error) throw result.error;
+process.exit(result.status ?? 1);

package/commands/minify-css.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+/**
+ * Minify CSS files using cssnano.
+ * Runs AFTER strip-page-rules.js so variable resolution isn't disrupted.
+ *
+ * Usage: book-kit minify-css [file1.css] [file2.css] ...
+ *   If no files given, minifies dist/style-epub.css and dist/style-kindle.css
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs';
+import postcss from 'postcss';
+import cssnano from 'cssnano';
+
+const files = process.argv.slice(2).length > 0
+  ? process.argv.slice(2)
+  : ['dist/style-epub.css', 'dist/style-kindle.css'];
+
+const processor = postcss([
+  cssnano({ preset: ['default', { discardComments: { removeAll: true } }] })
+]);
+
+let totalSaved = 0;
+
+for (const file of files) {
+  try {
+    const input = readFileSync(file, 'utf8');
+    const result = await processor.process(input, { from: file, to: file });
+    writeFileSync(file, result.css);
+    const saved = input.length - result.css.length;
+    totalSaved += saved;
+    const pct = ((saved / input.length) * 100).toFixed(1);
+    console.log(`  ${file}: ${input.length} → ${result.css.length} bytes (−${pct}%)`);
+  } catch (e) {
+    if (e.code === 'ENOENT') {
+      console.log(`  ${file}: skipped (not found)`);
+    } else {
+      throw e;
+    }
+  }
+}
+
+console.log(`Minified ${files.length} files, saved ${totalSaved} bytes total`);

package/commands/optimize-images.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+/**
+ * Optimize images for EPUB/Kindle builds using sharp.
+ * - Losslessly recompresses PNGs (emoji and img/)
+ * - Reports size savings, and exits non-zero if any image failed
+ *
+ * Usage: book-kit optimize-images
+ */
+
+import sharp from 'sharp';
+import { readdirSync, readFileSync, writeFileSync, statSync } from 'node:fs';
+import { join, extname } from 'node:path';
+import { pathFor } from '../lib/config.js';
+
+const imgDir = pathFor('img');
+
+// PNG only. The cover JPEG is deliberately excluded: sharp/libvips writes JPEGs
+// without the JFIF APP0 marker (they start FF D8 FF DB, not FF D8 FF E0), and
+// pandoc's image reader needs that marker — without it the EPUB build warns
+// "could not determine image size" and embeds the cover with no dimensions.
+// Optimize the cover out-of-band with a JFIF-preserving encoder instead, e.g.:
+//   magick cover.jpeg -strip -interlace none -quality 85 cover.jpeg
+const targets = [
+  { dir: join(imgDir, 'emoji'), glob: '.png' },
+  { dir: imgDir, glob: '.png' },
+];
+
+let totalBefore = 0;
+let totalAfter = 0;
+let filesProcessed = 0;
+
+for (const { dir, glob } of targets) {
+  let files;
+  try {
+    files = readdirSync(dir).filter(f => extname(f).toLowerCase() === glob);
+  } catch {
+    continue;
+  }
+
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const before = statSync(filePath).size;
+
+    try {
+      const buffer = readFileSync(filePath);
+      const optimized = await sharp(buffer)
+        .png({ compressionLevel: 9, adaptiveFiltering: true, effort: 10 })
+        .toBuffer();
+
+      if (optimized.length < before) {
+        writeFileSync(filePath, optimized);
+        const after = optimized.length;
+        const pct = ((1 - after / before) * 100).toFixed(1);
+        console.log(`  ${file}: ${before} → ${after} bytes (−${pct}%)`);
+        totalBefore += before;
+        totalAfter += after;
+      } else {
+        console.log(`  ${file}: already optimal (${before} bytes)`);
+        totalBefore += before;
+        totalAfter += before;
+      }
+      filesProcessed++;
+    } catch (e) {
+      console.error(`  ${file}: error — ${e.message}`);
+      process.exitCode = 1;
+    }
+  }
+}
+
+const saved = totalBefore - totalAfter;
+const pct = totalBefore > 0 ? ((saved / totalBefore) * 100).toFixed(1) : '0.0';
+console.log(`\nOptimized ${filesProcessed} images, saved ${saved} bytes (${pct}%)`);

package/commands/parity.sh

@@ -0,0 +1,150 @@
+#!/usr/bin/env bash
+# Compare two builds of a book format by format and fail on any real
+# difference. Use it to prove a change that shouldn't touch the output (a kit
+# upgrade, a toolchain bump, moving a book onto the kit) really doesn't.
+#
+#   book-kit parity BEFORE_DIST AFTER_DIST [WORK_DIR]
+#
+# WORK_DIR keeps the unpacked files for inspection; it must be new or empty,
+# so a typo can't wipe a real directory. Without it, a temp dir is used and
+# removed afterwards.
+#
+# Compares every output both directories have, named from book.config.yml:
+# <basename>.epub, -kindle.epub, -arc.epub, -kindle-arc.epub, .html, .docx,
+# .pdf, and <basename><output.pdfx_suffix>.pdf. A file in one directory but
+# not the other fails. Differences that carry no content are ignored:
+#   - EPUB/DOCX build timestamps (dcterms:modified, dcterms:created)
+#   - PNG bytes when the decoded pixels match (re-encoded, not a new image)
+#   - Ghostscript's random six-letter font-subset prefixes
+# PDFs are checked for page count (and print.page_count, if locked), extracted
+# text, embedded fonts, and every page's rendering; the PDF/X also for its
+# PDF/X-1a:2001 marker and output intent.
+#
+# Needs unzip, poppler (pdfinfo, pdftotext, pdffonts, pdftoppm), and a python3
+# with Pillow and pikepdf. Run from the book (book-kit runs commands there).
+
+set -uo pipefail
+export LC_ALL=C
+
+usage="usage: book-kit parity BEFORE_DIST AFTER_DIST [WORK_DIR]"
+BEFORE=${1:?$usage}
+AFTER=${2:?$usage}
+if [ -n "${3:-}" ]; then
+  WORK=$3
+  if [ -e "$WORK" ] && [ -n "$(ls -A "$WORK" 2>/dev/null)" ]; then
+    echo "book-kit parity: $WORK isn't empty; pass a new or empty WORK_DIR" >&2
+    exit 2
+  fi
+  mkdir -p "$WORK"
+else
+  WORK=$(mktemp -d)
+  trap 'rm -rf "$WORK"' EXIT
+fi
+BK=(node "$(dirname "$0")/../bin/book-kit.js")
+NAME=$("${BK[@]}" config output.basename)
+PDFX_SUFFIX=$("${BK[@]}" config output.pdfx_suffix)
+fail=0
+
+bad() { echo "  ✗ $*"; fail=1; }
+ok() { echo "  ✓ $*"; }
+
+same_pixels() {
+  python3 - "$1" "$2" <<'PY'
+import sys
+from PIL import Image, ImageChops
+a, b = (Image.open(p) for p in sys.argv[1:3])
+same = a.size == b.size and ImageChops.difference(a.convert("RGBA"), b.convert("RGBA")).getbbox(alpha_only=False) is None
+sys.exit(0 if same else 1)
+PY
+}
+
+strip_timestamps() {
+  sed -E \
+    -e 's|<meta property="dcterms:modified">[^<]*</meta>|<meta property="dcterms:modified"/>|' \
+    -e 's#<dcterms:(created|modified)([^>]*)>[^<]*</dcterms:[a-z]+>#<dcterms:\1\2/>#g' "$1"
+}
+
+# Unzip both sides and compare member by member.
+compare_zip() {
+  local file=$1 dir="$WORK/$1"
+  mkdir -p "$dir/before" "$dir/after"
+  if ! { unzip -q "$BEFORE/$file" -d "$dir/before" && unzip -q "$AFTER/$file" -d "$dir/after"; }; then bad "can't unzip"; return; fi
+  (cd "$dir/before" && find . -type f | sort) > "$dir/files.before"
+  (cd "$dir/after" && find . -type f | sort) > "$dir/files.after"
+  if ! diff -u "$dir/files.before" "$dir/files.after"; then bad "member lists differ"; return; fi
+  local n=0 reencoded=0 f
+  while read -r f; do
+    cmp -s "$dir/before/$f" "$dir/after/$f" && continue
+    case "$f" in
+      *.png)
+        if same_pixels "$dir/before/$f" "$dir/after/$f"; then reencoded=$((reencoded + 1)); continue; fi ;;
+      *.opf|*core.xml)
+        if diff -q <(strip_timestamps "$dir/before/$f") <(strip_timestamps "$dir/after/$f") >/dev/null; then continue; fi ;;
+    esac
+    bad "$f differs"; n=$((n + 1))
+    case "$f" in *.png|*.jpg|*.jpeg|*.gif|*.woff2|*.ttf|*.otf) ;; *) diff -u "$dir/before/$f" "$dir/after/$f" | head -20 ;; esac
+  done < "$dir/files.before"
+  [ "$n" -eq 0 ] && ok "$(wc -l < "$dir/files.before" | tr -d ' ') members match (ignoring timestamps; $reencoded PNGs re-encoded with identical pixels)"
+}
+
+fonts() {
+  pdffonts "$1" | tail -n +3 | awk '{ sub(/^[A-Z]{6}\+/, "", $1); print $1, $(NF-4), $(NF-3) }' | sort | uniq -c
+}
+
+compare_pdf() {
+  local file=$1 dir="$WORK/$1"
+  mkdir -p "$dir/before" "$dir/after"
+  local pb pa
+  pb=$(pdfinfo "$BEFORE/$file" | awk '/^Pages:/ { print $2 }')
+  pa=$(pdfinfo "$AFTER/$file" | awk '/^Pages:/ { print $2 }')
+  if [ "$pb" = "$pa" ]; then ok "$pa pages in both"; else bad "page count: $pb before, $pa after"; fi
+  if "${BK[@]}" config print.page_count 2>/dev/null | grep -qvx null; then
+    if "${BK[@]}" check-pdf-page-count "$AFTER/$file" >/dev/null; then ok "matches print.page_count"; else bad "doesn't match print.page_count"; fi
+  fi
+  pdftotext -layout "$BEFORE/$file" "$dir/before.txt"; pdftotext -layout "$AFTER/$file" "$dir/after.txt"
+  if diff -q "$dir/before.txt" "$dir/after.txt" >/dev/null; then ok "text identical"; else bad "text differs"; diff -u "$dir/before.txt" "$dir/after.txt" | head -20; fi
+  if diff -q <(fonts "$BEFORE/$file") <(fonts "$AFTER/$file") >/dev/null; then ok "same fonts"; else bad "fonts differ"; diff <(fonts "$BEFORE/$file") <(fonts "$AFTER/$file"); fi
+  local unembedded
+  unembedded=$(pdffonts "$AFTER/$file" | tail -n +3 | awk '$(NF-4) == "no"' | wc -l | tr -d ' ')
+  if [ "$unembedded" -eq 0 ]; then ok "all fonts embedded"; else bad "$unembedded fonts not embedded"; fi
+  # Every page at low resolution: enough to catch a layout, image, or color
+  # change without diffing hundreds of full-size bitmaps.
+  pdftoppm -r 40 -gray -png "$BEFORE/$file" "$dir/before/p" &
+  pdftoppm -r 40 -gray -png "$AFTER/$file" "$dir/after/p" &
+  wait
+  local d=0 page
+  for page in "$dir"/before/*.png; do
+    cmp -s "$page" "$dir/after/$(basename "$page")" || { d=$((d + 1)); echo "    page differs: $(basename "$page")"; }
+  done
+  if [ "$d" -eq 0 ]; then ok "every page renders identically"; else bad "$d pages render differently"; fi
+}
+
+check_pdfx() {
+  if python3 - "$1" <<'PY'
+import sys
+import pikepdf
+pdf = pikepdf.open(sys.argv[1])
+version = str(pdf.trailer.Info.get("/GTS_PDFXVersion", ""))
+sys.exit(0 if version == "PDF/X-1a:2001" and pdf.Root.get("/OutputIntents") else 1)
+PY
+  then ok "PDF/X-1a:2001 with an output intent"; else bad "not marked PDF/X-1a:2001 with an output intent"; fi
+}
+
+compared=0
+for file in "$NAME.epub" "$NAME-kindle.epub" "$NAME-arc.epub" "$NAME-kindle-arc.epub" "$NAME.html" "$NAME.docx" "$NAME.pdf" "$NAME$PDFX_SUFFIX.pdf"; do
+  if [ ! -f "$BEFORE/$file" ] && [ ! -f "$AFTER/$file" ]; then continue; fi
+  echo "### $file"
+  if [ ! -f "$BEFORE/$file" ] || [ ! -f "$AFTER/$file" ]; then bad "only in $([ -f "$BEFORE/$file" ] && echo before || echo after)"; continue; fi
+  compared=$((compared + 1))
+  case "$file" in
+    *.epub|*.docx) compare_zip "$file" ;;
+    *.html) if cmp -s "$BEFORE/$file" "$AFTER/$file"; then ok "identical"; else bad "differs"; diff <(tr '>' '\n' < "$BEFORE/$file") <(tr '>' '\n' < "$AFTER/$file") | head -20; fi ;;
+    "$NAME$PDFX_SUFFIX.pdf") compare_pdf "$file"; check_pdfx "$AFTER/$file" ;;
+    *.pdf) compare_pdf "$file" ;;
+  esac
+done
+
+echo
+if [ "$compared" -eq 0 ]; then echo "Parity: no outputs to compare in $BEFORE and $AFTER."; exit 1; fi
+if [ "$fail" -eq 0 ]; then echo "Parity: all $compared outputs match."; else echo "Parity: FAILED (see ✗ above)."; fi
+exit "$fail"