book-kit 0.0.0-stage → 0.6.0

package/commands/strip-property-rules.js

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+
+/**
+ * Strip CSS `@property` at-rules from the inlined stylesheet of the print HTML
+ * before it reaches WeasyPrint.
+ *
+ * Why: Tailwind v4 emits many `@property --tw-*` declarations (the CSS
+ * Properties and Values API) to type its utility custom properties. WeasyPrint
+ * doesn't implement that API, so it logs a `WARNING: Unknown rule <AtRule
+ * @property …>` for every one — hundreds of lines that bury any real warning.
+ * The rules only add type/inheritance/default metadata to custom properties;
+ * the properties still resolve as plain `var()` values without them, and the
+ * static print output doesn't depend on that metadata. Removing them is purely
+ * cosmetic for the rendered PDF and clears the log noise.
+ *
+ * Print-only: runs against the standalone print HTML in the `pdf` recipe. The
+ * HTML build keeps `@property` (browsers support it); the EPUB/Kindle builds
+ * already drop it via strip-page-rules.js.
+ *
+ * `@property` bodies contain only declarations (no nested rules), so the blocks
+ * are flat — but this still brace-counts to stay correct if that ever changes.
+ *
+ * Usage: book-kit strip-property-rules <file.html>
+ */
+
+import { readFileSync, writeFileSync } from 'node:fs';
+
+const file = process.argv[2];
+if (!file) {
+  console.error('Usage: book-kit strip-property-rules <file.html>');
+  process.exit(1);
+}
+
+/**
+ * Remove every `@property …{ … }` block from a CSS string, counting braces so
+ * the match ends at the rule's own closing brace.
+ * @param {string} css
+ * @returns {{ css: string, removed: number }}
+ */
+function stripPropertyRules(css) {
+  let out = '';
+  let removed = 0;
+  let i = 0;
+
+  while (i < css.length) {
+    const at = css.indexOf('@property', i);
+    if (at === -1) {
+      out += css.slice(i);
+      break;
+    }
+
+    // Copy everything up to the at-rule, then find its opening brace.
+    out += css.slice(i, at);
+    const open = css.indexOf('{', at);
+    if (open === -1) {
+      // Malformed/truncated rule — keep the rest verbatim and stop.
+      out += css.slice(at);
+      break;
+    }
+
+    // Walk to the matching close brace.
+    let depth = 0;
+    let j = open;
+    for (; j < css.length; j++) {
+      if (css[j] === '{') depth++;
+      else if (css[j] === '}' && --depth === 0) break;
+    }
+
+    removed++;
+    i = j + 1; // resume after the closing brace, dropping the block
+  }
+
+  return { css: out, removed };
+}
+
+const html = readFileSync(file, 'utf8');
+
+// Operate only on inlined <style> blocks (pandoc's embed-resources output).
+let total = 0;
+const updated = html.replace(
+  /(<style\b[^>]*>)([\s\S]*?)(<\/style>)/gi,
+  (_match, openTag, body, closeTag) => {
+    const { css, removed } = stripPropertyRules(body);
+    total += removed;
+    return openTag + css + closeTag;
+  },
+);
+
+if (total > 0) {
+  writeFileSync(file, updated);
+}
+
+console.log(`Stripped ${total} @property rule(s) from ${file}`);

package/commands/update-key-takeaways.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+
+/**
+ * Update key takeaways by combining TL;DRs from chapters into section key
+ * takeaway files: for each `# Section` comment in index.yml, collect its
+ * chapters' TL;DRs into src/<section><structure.takeaways_suffix>.md.
+ * Hand-written text around the generated block is preserved.
+ *
+ * Usage: book-kit update-key-takeaways
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadConfigOrDefaults } from '../lib/config.js';
+import { isMain } from '../lib/is-main.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const config = loadConfigOrDefaults();
+
+// Sections that don't get a takeaways chapter (structure.takeaways_skip_sections)
+const SKIP_SECTIONS = config.structure.takeaways_skip_sections;
+const TAKEAWAYS_SUFFIX = config.structure.takeaways_suffix;
+
+/**
+ * Parse sections from index.yml content
+ * @param {string} indexContent - Raw index.yml file content
+ * @returns {{sections: string[], sectionFiles: Object.<string, string[]>}}
+ */
+function parseSections(indexContent) {
+  const sections = [];
+  const sectionFiles = {};
+  let currentSection = null;
+  
+  for (const line of indexContent.split('\n')) {
+    // Match section comment lines
+    const commentMatch = line.match(/^\s*#\s+(.+)$/);
+    if (commentMatch) {
+      const sectionName = commentMatch[1].trim();
+      // Skip sections we don't want to process
+      if (!SKIP_SECTIONS.includes(sectionName)) {
+        currentSection = sectionName;
+        if (!sections.includes(currentSection)) {
+          sections.push(currentSection);
+          sectionFiles[currentSection] = [];
+        }
+      } else {
+        currentSection = null;
+      }
+      continue;
+    }
+    
+    // Match file entries under current section
+    const fileMatch = line.match(/^\s*-\s+(.+\.md)\s*$/);
+    if (fileMatch && currentSection) {
+      const filePath = fileMatch[1].trim();
+      sectionFiles[currentSection].push(filePath);
+    }
+  }
+  
+  return { sections, sectionFiles };
+}
+
+/**
+ * Extract TL;DR content from chapter file
+ * @param {string} filePath - Path to chapter file
+ * @returns {{text: string, disabledRules: string[]}|null} TL;DR content and disabled textlint rules, or null
+ */
+function extractTldr(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  
+  const content = fs.readFileSync(filePath, 'utf8');
+  
+  if (!content.includes('.tldr')) {
+    return null;
+  }
+  
+  // Extract content from tldr div block
+  const tldrMatch = content.match(/::: \{\.tldr[^}]*\}\n(.*?)\n:::/s);
+  if (tldrMatch) {
+    const text = tldrMatch[1].trim();
+
+    // Collect file-level textlint-disable rules so intentional
+    // rule violations (e.g. clichés used as examples) stay suppressed
+    // when the TL;DR is embedded in a key-takeaways file.
+    const disabledRules = [];
+    const disableMatch = content.match(/^<!--\s*textlint-disable\s+([^>]+?)(?:\s*)-->/m);
+    if (disableMatch) {
+      disabledRules.push(...disableMatch[1].trim().split(/,\s*/));
+    }
+
+    return { text, disabledRules };
+  }
+  
+  return null;
+}
+
+/**
+ * Convert section name to filename-safe format
+ * @param {string} sectionName - Section name
+ * @returns {string} Filename-safe section name
+ */
+function sectionToFilename(sectionName) {
+  return sectionName
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, '')  // Remove special characters
+    .replace(/\s+/g, '-')           // Replace spaces with hyphens
+    .replace(/-+/g, '-')            // Replace multiple hyphens with single
+    .trim();
+}
+
+// Phrases that work inside a chapter's TL;DR ("this chapter shows you…",
+// "read on to learn…") but dangle when the TL;DR is lifted into a section's
+// key takeaways list, where there is no "this chapter" to point at.
+const DEICTIC_PATTERNS = [
+  /\bthis chapter\b/i,
+  /\bread on\b/i,
+  /\bkeep reading\b/i,
+  /\bthe pages? that follows?\b/i,
+  /\bwhat follows\b/i
+];
+
+/**
+ * Strip sentences that reference the chapter itself ("This chapter shows
+ * you…", "Read on to learn…") so the remaining text stands alone as a key
+ * takeaway. TL;DRs keep their hook sentence in place; only the generated
+ * takeaways drop it.
+ * @param {string} text - TL;DR text
+ * @returns {string} Text with chapter-deictic sentences removed
+ */
+function stripChapterReferences(text) {
+  if (!DEICTIC_PATTERNS.some((pattern) => pattern.test(text))) {
+    return text;
+  }
+
+  const sentences = text.split(/(?<=[.!?])\s+/);
+  const kept = sentences.filter(
+    (sentence) => !DEICTIC_PATTERNS.some((pattern) => pattern.test(sentence))
+  );
+
+  // If every sentence references the chapter, keep the original rather than
+  // emit an empty takeaway — but flag it so the TL;DR gets fixed upstream.
+  if (kept.length === 0) {
+    console.warn(`Warning: TL;DR is entirely chapter-deictic; keeping as-is: "${text.slice(0, 80)}…"`);
+    return text;
+  }
+
+  const result = kept.join(' ');
+  if (DEICTIC_PATTERNS.some((pattern) => pattern.test(result))) {
+    console.warn(`Warning: chapter reference survived stripping: "${result.slice(0, 80)}…"`);
+  }
+  return result;
+}
+
+/**
+ * Generate key takeaways content
+ * @param {Array<{text: string, disabledRules: string[]}>} tldrs - Array of TL;DR objects
+ * @returns {string} Formatted key takeaways markdown
+ */
+function generateKeyTakeaways(tldrs) {
+  // Collect all disabled textlint rules across TL;DRs in this section
+  const allDisabledRules = [...new Set(tldrs.flatMap(t => t.disabledRules))];
+  
+  let contents = '';
+  if (allDisabledRules.length > 0) {
+    contents += `<!-- textlint-disable ${allDisabledRules.join(', ')} -->\n\n`;
+  }
+  contents += '::: {.takeaways custom-style="takeaways"}\n\n### Key takeaways\n\n';
+  contents += tldrs.map(t => `- ${stripChapterReferences(t.text)}`).join('\n');
+  contents += '\n\n:::\n';
+  return contents;
+}
+
+/**
+ * Collect TL;DRs for each section
+ * @param {string[]} sections - Array of section names
+ * @param {Object.<string, string[]>} sectionFiles - Map of section name to file paths
+ * @returns {Object.<string, Array<{text: string, disabledRules: string[]}>>} Map of section name to TL;DRs
+ */
+function collectTldrs(sections, sectionFiles) {
+  const sectionTldrs = {};
+  
+  for (const section of sections) {
+    sectionTldrs[section] = [];
+    
+    const files = sectionFiles[section] || [];
+    for (const chapter of files) {
+      const tldr = extractTldr(chapter);
+      if (tldr) {
+        sectionTldrs[section].push(tldr);
+      } else if (fs.existsSync(chapter)) {
+        console.log(`No TL;DR in ${chapter}`);
+      }
+    }
+  }
+  
+  return sectionTldrs;
+}
+
+/**
+ * Extract hand-written content before and after the takeaways block.
+ * Returns { before, after } strings, either of which may be empty.
+ * @param {string} filePath - Path to existing key takeaways file
+ * @returns {{before: string, after: string}} Content surrounding the takeaways block
+ */
+function extractBridgingContent(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return { before: '', after: '' };
+  }
+
+  const content = fs.readFileSync(filePath, 'utf8');
+
+  // Find the takeaways block boundaries, accounting for optional
+  // textlint-disable comments that precede it.
+  const takeawaysStart = content.search(/(?:<!--\s*textlint-disable[^>]*-->\s*\n*)?::: \{\.takeaways/);
+  const takeawaysEnd = content.indexOf('\n:::\n', takeawaysStart);
+
+  if (takeawaysStart === -1 || takeawaysEnd === -1) {
+    return { before: '', after: '' };
+  }
+
+  // "before" is everything up to the takeaways block (trimmed)
+  let before = content.slice(0, takeawaysStart).trim();
+
+  // "after" is everything following the closing ::: and optional
+  // textlint-enable comments (trimmed)
+  let after = content.slice(takeawaysEnd + '\n:::\n'.length).trim();
+  // Strip leading textlint-enable comment from "after" since the
+  // generated block already handles it via allDisabledRules
+  after = after.replace(/^<!--\s*textlint-enable[^>]*-->\s*\n*/, '').trim();
+
+  return { before, after };
+}
+
+/**
+ * Generate key takeaways files for each section
+ * @param {Object.<string, string[]>} sectionTldrs - Map of section name to TL;DRs
+ * @param {string} outputDir - Output directory for generated files
+ * @returns {string[]} Array of generated file paths
+ */
+function generateFiles(sectionTldrs, outputDir = config.paths.src) {
+  const generatedFiles = [];
+  
+  for (const [section, tldrs] of Object.entries(sectionTldrs)) {
+    if (tldrs.length === 0) {
+      continue;
+    }
+    
+    const filename = sectionToFilename(section);
+    const filePath = path.join(outputDir, `${filename}${TAKEAWAYS_SUFFIX}.md`);
+
+    // Preserve any hand-written bridging content around the block
+    const { before, after } = extractBridgingContent(filePath);
+    const takeawaysBlock = generateKeyTakeaways(tldrs);
+
+    let contents = '';
+    if (before) {
+      contents += before + '\n\n';
+    }
+    contents += takeawaysBlock;
+    if (after) {
+      contents += '\n' + after + '\n';
+    }
+    
+    fs.writeFileSync(filePath, contents);
+    console.log(`Generated ${filePath} with ${tldrs.length} takeaways`);
+    generatedFiles.push(filePath);
+  }
+  
+  return generatedFiles;
+}
+
+/**
+ * Main function to update key takeaways by combining TL;DRs
+ * @param {string} indexPath - Path to index.yml file
+ * @param {string} outputDir - Output directory for generated files
+ * @returns {string[]} Array of generated file paths
+ */
+function updateKeyTakeaways(indexPath = config.paths.index, outputDir = config.paths.src) {
+  // Read the index.yml file
+  const indexContent = fs.readFileSync(indexPath, 'utf8');
+  
+  // Parse sections from comments in index.yml
+  const { sections, sectionFiles } = parseSections(indexContent);
+  
+  // Collect TL;DRs for each section
+  const sectionTldrs = collectTldrs(sections, sectionFiles);
+  
+  // Generate key takeaways files
+  return generateFiles(sectionTldrs, outputDir);
+}
+
+// Export for testing
+export {
+  parseSections,
+  extractTldr,
+  extractBridgingContent,
+  stripChapterReferences,
+  sectionToFilename,
+  generateKeyTakeaways,
+  collectTldrs,
+  generateFiles,
+  updateKeyTakeaways,
+  SKIP_SECTIONS
+};
+
+// Run if executed directly
+if (isMain(import.meta.url)) {
+  updateKeyTakeaways();
+}

package/commands/validate.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+
+// book-kit validate: run the book's validators and print what they find.
+//
+// Validators come from three places, run in this order:
+//   1. the kit's built-ins (validators/, in BUILTIN_VALIDATORS order)
+//   2. preset validators: every *.js file in <preset>/validators/, for each
+//      preset the book extends, in merge order, files sorted by name
+//   3. the book's plugins (validators.plugins in book.config.yml)
+//
+// All three share one shape: an ES module whose default export is
+// { name, tags?, defaults?, run(ctx) }, where run (sync or async) returns
+// { errors, warnings }. ctx has the resolved config, the index.yml file list
+// (indexFiles), the chapter files under paths.src (chapters), the validator's
+// options (its defaults deep-merged with validators.options.<name>), and its
+// intentional exceptions (allow, a Set from validators.allow.<name>).
+//
+//   book-kit validate                 run every validator
+//   book-kit validate --list          print the built-in validator names
+//   book-kit validate --list --verbose  name, severity, tags, and source of every validator
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { isMain } from '../lib/is-main.js';
+import { config, getChapters, getIndexFiles, optionsFor } from '../lib/validate.js';
+import { BUILTIN_VALIDATORS } from '../validators/index.js';
+
+/**
+ * The ctx a validator's run() gets.
+ * @param {{name: string, defaults?: object}} validator
+ * @param {{config: object, indexFiles: string[], chapters: string[]}} base
+ * @returns {{config: object, indexFiles: string[], chapters: string[], options: object, allow: Set<string>}}
+ */
+function contextFor(validator, base) {
+  return {
+    ...base,
+    options: optionsFor(validator.name, validator.defaults ?? {}, base.config),
+    allow: new Set(base.config.validators.allow?.[validator.name] ?? []),
+  };
+}
+
+// The built-ins other than `chapter`, as [name, fn] pairs where fn takes the
+// index.yml file list. Kept for callers of the pre-module API.
+const VALIDATORS = BUILTIN_VALIDATORS
+  .filter((validator) => validator.name !== 'chapter')
+  .map((validator) => [
+    validator.name,
+    (indexFiles) => validator.run(contextFor(validator, { config, indexFiles, chapters: getChapters() })),
+  ]);
+
+/**
+ * Apply a validator's configured severity to its results. Severity per name
+ * comes from validators.severity in book.config.yml: "error" promotes
+ * warnings to errors, "warn" demotes errors to warnings, and "on" (or no
+ * entry) passes results through as written. ("off" skips the validator
+ * before it runs.)
+ * @param {string} name - Validator name (a validators.severity key)
+ * @param {{errors?: string[], warnings?: string[]}} result
+ * @param {object} [cfg] - Resolved config
+ * @returns {{errors: string[], warnings: string[]}}
+ */
+function applySeverity(name, { errors = [], warnings = [] }, cfg = config) {
+  const severity = cfg.validators.severity?.[name];
+  if (severity === 'error') return { errors: [...errors, ...warnings], warnings: [] };
+  if (severity === 'warn') return { errors: [], warnings: [...errors, ...warnings] };
+  return { errors, warnings };
+}
+
+/**
+ * Import a validator module and check its shape.
+ * @param {string} file - Absolute path to the module
+ * @param {string} what - How to name it in an error
+ */
+async function importValidator(file, what) {
+  const mod = await import(pathToFileURL(file).href);
+  const validator = mod.default;
+  if (!validator?.name || typeof validator.run !== 'function') {
+    throw new Error(`${what} must export default { name, run(ctx) }`);
+  }
+  return validator;
+}
+
+/**
+ * Where a validators.plugins entry lives. A path (starting with "." or "/",
+ * or ending in .js or .mjs) is relative to the book root; anything else is an
+ * npm package, resolved from the book root as Node would.
+ * @param {string} spec - The validators.plugins entry
+ * @param {string} root - Book root
+ * @returns {string} Absolute path to the module
+ */
+function resolvePlugin(spec, root) {
+  if (spec.startsWith('.') || spec.startsWith('/') || /\.m?js$/.test(spec)) {
+    return path.resolve(root, spec);
+  }
+  try {
+    return createRequire(path.join(root, 'package.json')).resolve(spec);
+  } catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND') throw error;
+    throw new Error(
+      `Validator plugin "${spec}" isn't installed in the book (npm install ${spec}), ` +
+        `or use a path like ./validators/${spec}.js`,
+      { cause: error },
+    );
+  }
+}
+
+/**
+ * Load the validators shipped by the presets the book extends: every *.js
+ * file in <preset>/validators/, presets in merge order, files sorted.
+ * @param {object} [cfg] - Resolved config (its non-enumerable `presets`)
+ * @returns {Promise<Array<{validator: object, source: string}>>}
+ */
+async function loadPresetValidators(cfg = config) {
+  const entries = [];
+  for (const { name, dir } of cfg.presets ?? []) {
+    const validatorsDir = path.join(dir, 'validators');
+    if (!fs.existsSync(validatorsDir)) continue;
+    for (const file of fs.readdirSync(validatorsDir).filter((f) => f.endsWith('.js')).sort()) {
+      const validator = await importValidator(path.join(validatorsDir, file), `Validator ${file} in preset ${name}`);
+      entries.push({ validator, source: `preset ${name}` });
+    }
+  }
+  return entries;
+}
+
+/**
+ * Load the book's own validators (validators.plugins).
+ * @param {object} [cfg] - Resolved config
+ * @returns {Promise<Array<{validator: object, source: string}>>}
+ */
+async function loadPlugins(cfg = config) {
+  const entries = [];
+  for (const spec of cfg.validators.plugins ?? []) {
+    const validator = await importValidator(resolvePlugin(spec, cfg.root), `Validator plugin ${spec}`);
+    entries.push({ validator, source: `plugin ${spec}` });
+  }
+  return entries;
+}
+
+/**
+ * Every validator in run order: built-ins, preset validators, plugins.
+ * @param {{plugins?: object[], cfg?: object}} [options] - Injected plugin
+ *   objects replace validators.plugins (for tests)
+ * @returns {Promise<Array<{validator: object, source: string}>>}
+ */
+async function allValidators({ plugins, cfg = config } = {}) {
+  return [
+    ...BUILTIN_VALIDATORS.map((validator) => ({ validator, source: 'kit' })),
+    ...(await loadPresetValidators(cfg)),
+    ...(plugins ? plugins.map((validator) => ({ validator, source: 'plugin' })) : await loadPlugins(cfg)),
+  ];
+}
+
+/**
+ * Run every validator and print the results.
+ * @param {{plugins?: Array<{name: string, run: Function}>}} [options]
+ * @returns {Promise<number>} Exit status: 1 if any errors, else 0
+ */
+async function runValidation({ plugins } = {}) {
+  const chapters = getChapters();
+  const indexFiles = getIndexFiles();
+  const validators = await allValidators({ plugins });
+
+  const allErrors = [];
+  const allWarnings = [];
+  const report = ({ errors, warnings }) => {
+    for (const error of errors) {
+      console.log(error);
+      allErrors.push(error);
+    }
+    for (const warning of warnings) {
+      console.log(`Warning: ${warning}`);
+      allWarnings.push(warning);
+    }
+  };
+
+  for (const { validator } of validators) {
+    if (config.validators.severity?.[validator.name] === 'off') continue;
+    const ctx = contextFor(validator, { config, indexFiles, chapters });
+    report(applySeverity(validator.name, await validator.run(ctx)));
+  }
+
+  if (allErrors.length === 0) {
+    console.log('✓ All chapters validated successfully');
+  } else {
+    console.log(`\n✗ Found ${allErrors.length} error(s)`);
+  }
+
+  if (allWarnings.length > 0) {
+    console.log(`ℹ ${allWarnings.length} warning(s)`);
+  }
+
+  return allErrors.length > 0 ? 1 : 0;
+}
+
+/**
+ * The `--list` output. Plain: one built-in name per line. Verbose: every
+ * validator (presets' and plugins' too) in aligned columns of name,
+ * effective severity (error, warn, off, or "default" for on or unset),
+ * tags, and source (kit, preset <name>, or plugin <spec>).
+ * @param {{verbose?: boolean, cfg?: object}} [options]
+ * @returns {Promise<string>}
+ */
+async function listValidators({ verbose = false, cfg = config } = {}) {
+  if (!verbose) return BUILTIN_VALIDATORS.map((validator) => validator.name).join('\n');
+  const rows = (await allValidators({ cfg })).map(({ validator, source }) => {
+    const severity = cfg.validators.severity?.[validator.name];
+    return [
+      validator.name,
+      ['error', 'warn', 'off'].includes(severity) ? severity : 'default',
+      (validator.tags ?? []).join(',') || '-',
+      source,
+    ];
+  });
+  const widths = [0, 1, 2].map((i) => Math.max(...rows.map((row) => row[i].length)));
+  return rows.map((row) => row.map((cell, i) => (i < 3 ? cell.padEnd(widths[i]) : cell)).join('  ')).join('\n');
+}
+
+// Built-in validator functions, re-exported for tests and older callers.
+export { validateChapter } from '../validators/chapter.js';
+export { validateSectionIntros } from '../validators/section-intros.js';
+export { validateSectionIntroNoTldr } from '../validators/section-intro-no-tldr.js';
+export { validateSectionIntroHasLead } from '../validators/section-intro-has-lead.js';
+export { validateSectionIntroFinalLead } from '../validators/section-intro-final-lead.js';
+export { validateNoTransitionTodos } from '../validators/no-transition-todos.js';
+export { validateNoTodoMarkers } from '../validators/no-todo-markers.js';
+export { validateMinOpenerLength } from '../validators/min-opener-length.js';
+export { validateNoBareUrlLinkText } from '../validators/no-bare-url-link-text.js';
+export { validateCrossReferences } from '../validators/cross-references.js';
+export { validateIndexIntegrity } from '../validators/index-integrity.js';
+export { validateSmallcaps } from '../validators/smallcaps.js';
+export { validateEscapedSmallcaps } from '../validators/escaped-smallcaps.js';
+export { validateCalloutBalance } from '../validators/callout-balance.js';
+export { validateTldrLength } from '../validators/tldr-length.js';
+export { validateDuplicateHeadings } from '../validators/duplicate-headings.js';
+export { validateAcronymExpansion } from '../validators/acronym-expansion.js';
+export { validateEmDashes } from '../validators/em-dashes.js';
+export { validateNumberRangeDashes } from '../validators/number-range-dashes.js';
+export { validateQuotePunctuation } from '../validators/quote-punctuation.js';
+export { validateDoubledWords } from '../validators/doubled-words.js';
+export { validateCalloutDivs } from '../validators/callout-divs.js';
+export { validateRoleCalloutLabels } from '../validators/callout-labels.js';
+export { validateFootnotes } from '../validators/footnotes.js';
+export { validateHeadingHierarchy } from '../validators/heading-hierarchy.js';
+export { validateSentenceStarters } from '../validators/sentence-starters.js';
+export { validateListPunctuation } from '../validators/list-punctuation.js';
+export { validateBoldKeywords } from '../validators/bold-keywords.js';
+export { validateHypotheticalHooks } from '../validators/hypothetical-hooks.js';
+export { validateParagraphLength } from '../validators/paragraph-length.js';
+export {
+  getChapters,
+  getIndexFiles,
+  getSectionIntros,
+  isExcluded,
+  headingToAnchor,
+  collectAllAnchors,
+  EXCLUDE_PATTERNS,
+  KNOWN_ACRONYMS,
+  UNIVERSALLY_KNOWN_ACRONYMS,
+} from '../lib/validate.js';
+export { BUILTIN_VALIDATORS };
+export {
+  runValidation,
+  applySeverity,
+  listValidators,
+  loadPlugins,
+  loadPresetValidators,
+  resolvePlugin,
+  VALIDATORS,
+};
+
+// Run if executed directly
+if (isMain(import.meta.url)) {
+  if (process.argv.includes('--list')) {
+    const verbose = process.argv.includes('--verbose') || process.argv.includes('-v');
+    console.log(await listValidators({ verbose }));
+    process.exit(0);
+  }
+  const exitCode = await runValidation();
+  process.exit(exitCode);
+}