book-kit 0.0.0-stage → 0.6.0

package/fonts/LICENSE-source-serif.md

@@ -0,0 +1,93 @@
+Copyright 2014 - 2023 Adobe (http://www.adobe.com/), with Reserved Font Name ‘Source’. All Rights Reserved. Source is a trademark of Adobe in the United States and/or other countries.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+
+This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/fonts/recipe.json

@@ -0,0 +1,41 @@
+{
+  "$comment": "How `book-kit fonts` builds the theme's fonts from the unmodified upstream files pinned in toolchain.json `fonts`: Adobe's Source Serif 4 release, and Google Fonts' builds of Source Sans 3 and Source Code Pro, whose vertical metrics and hinting set the theme's line heights. The kit ships only this recipe, never the derived files: the fonts are OFL-licensed with the Reserved Font Name 'Source', which bars redistributing modified versions under that name, while subsetting them for your own build and embedding them in a book is fine. Output names are what css/theme.css, commands/kindle-fonts.js, and the pandoc defaults load. Changing anything here or in toolchain.json `fonts` can reflow a locked print page count.",
+  "unicodes": {
+    "serif": "U+0020-007E,U+00A0-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2002-2007,U+2009-200B,U+2010,U+2012-2015,U+2018-201A,U+201C-201E,U+2020-2022,U+2025-2026,U+202F-2030,U+2032-2033,U+2039-203A,U+203C,U+2044,U+2047-2049,U+2074,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215",
+    "sans": "U+0020-007E,U+00A0-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0300-0301,U+0303-0304,U+0308-0309,U+0323,U+0329,U+2009,U+200B,U+2013-2014,U+2018-201A,U+201C-201E,U+2022,U+2026,U+2032-2033,U+2039-203A,U+2044,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF",
+    "code": "U+0020-007E,U+00A0-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0300-0301,U+0303-0304,U+0308-0309,U+0323,U+0329,U+2013-2014,U+2018-201A,U+201C-201E,U+2022,U+2026,U+2032-2033,U+2039-203A,U+2044,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF",
+    "not-equal": "U+2260"
+  },
+  "features": {
+    "serif": ["aalt", "c2sc", "case", "ccmp", "dnom", "frac", "kern", "liga", "lnum", "locl", "mark", "mkmk", "numr", "onum", "ordn", "pnum", "sinf", "smcp", "ss03", "subs", "sups", "tnum", "zero"],
+    "sans": ["ccmp", "dnom", "frac", "kern", "liga", "locl", "mark", "mkmk", "numr", "pnum"],
+    "code": ["ccmp", "dnom", "frac", "locl", "mark", "mkmk", "numr"],
+    "not-equal": ["kern"]
+  },
+  "$drop_tables": "Tables to remove after subsetting (Source Serif's BASE never shipped in the theme).",
+  "$names": "Name-table records to overwrite (nameID: string). They keep the ≠ faces' embedded font names distinct: WeasyPrint draws the wrong glyph when the ≠ face shares the main face's name.",
+  "subsets": [
+    { "out": "SourceSerif4-Variable-Latin.woff2", "source": "source-serif", "member": "source-serif-4.005_Desktop/VAR/SourceSerif4Variable-Roman.ttf", "unicodes": "serif", "features": "serif", "drop_tables": ["BASE"] },
+    { "out": "SourceSerif4-Italic-Variable-Latin.woff2", "source": "source-serif", "member": "source-serif-4.005_Desktop/VAR/SourceSerif4Variable-Italic.ttf", "unicodes": "serif", "features": "serif", "drop_tables": ["BASE"] },
+    { "out": "SourceSerif4-NotEqual.woff2", "source": "source-serif", "member": "source-serif-4.005_Desktop/VAR/SourceSerif4Variable-Roman.ttf", "unicodes": "not-equal", "features": "not-equal", "names": {"1": "Source Serif 4 NotEqual", "3": "SourceSerif4NotEqual;4.005", "4": "Source Serif 4 NotEqual", "6": "SourceSerif4NotEqual"} },
+    { "out": "SourceSerif4-Italic-NotEqual.woff2", "source": "source-serif", "member": "source-serif-4.005_Desktop/VAR/SourceSerif4Variable-Italic.ttf", "unicodes": "not-equal", "features": "not-equal", "names": {"1": "Source Serif 4 NotEqual Italic", "3": "SourceSerif4NotEqual-Italic;4.005", "4": "Source Serif 4 NotEqual Italic", "6": "SourceSerif4NotEqual-Italic"} },
+    { "out": "SourceSans3-Variable-Latin.woff2", "source": "source-sans-3", "unicodes": "sans", "features": "sans" },
+    { "out": "SourceSans3-Italic-Variable-Latin.woff2", "source": "source-sans-3-italic", "unicodes": "sans", "features": "sans" },
+    { "out": "SourceCodePro-Variable-Latin.woff2", "source": "source-code-pro", "unicodes": "code", "features": "code" },
+    { "out": "SourceCodePro-Italic-Variable-Latin.woff2", "source": "source-code-pro-italic", "unicodes": "code", "features": "code" }
+  ],
+  "$instances": "Static instances for Kindle, which ignores variable fonts. Each pins every axis of a subset above; axes left out are pinned at their default. Source Serif uses optical size 16, tuned for body text at e-reader sizes.",
+  "instances": [
+    { "out": "kindle/SourceSerif4-Regular.woff2", "from": "SourceSerif4-Variable-Latin.woff2", "axes": { "wght": 400, "opsz": 16 } },
+    { "out": "kindle/SourceSerif4-Bold.woff2", "from": "SourceSerif4-Variable-Latin.woff2", "axes": { "wght": 700, "opsz": 16 } },
+    { "out": "kindle/SourceSerif4-Italic.woff2", "from": "SourceSerif4-Italic-Variable-Latin.woff2", "axes": { "wght": 400, "opsz": 16 } },
+    { "out": "kindle/SourceSerif4-BoldItalic.woff2", "from": "SourceSerif4-Italic-Variable-Latin.woff2", "axes": { "wght": 700, "opsz": 16 } },
+    { "out": "kindle/SourceSans3-Regular.woff2", "from": "SourceSans3-Variable-Latin.woff2", "axes": { "wght": 400 } },
+    { "out": "kindle/SourceSans3-SemiBold.woff2", "from": "SourceSans3-Variable-Latin.woff2", "axes": { "wght": 600 } },
+    { "out": "kindle/SourceSans3-Bold.woff2", "from": "SourceSans3-Variable-Latin.woff2", "axes": { "wght": 700 } },
+    { "out": "kindle/SourceSans3-Italic.woff2", "from": "SourceSans3-Italic-Variable-Latin.woff2", "axes": { "wght": 400 } },
+    { "out": "kindle/SourceCodePro-Regular.woff2", "from": "SourceCodePro-Variable-Latin.woff2", "axes": { "wght": 400 } },
+    { "out": "kindle/SourceCodePro-Bold.woff2", "from": "SourceCodePro-Variable-Latin.woff2", "axes": { "wght": 700 } },
+    { "out": "kindle/SourceCodePro-Italic.woff2", "from": "SourceCodePro-Italic-Variable-Latin.woff2", "axes": { "wght": 400 } }
+  ]
+}

package/just/book-kit.just

@@ -0,0 +1,229 @@
+# book-kit recipes. A book's justfile imports this file:
+#
+#   set allow-duplicate-recipes
+#   import 'node_modules/book-kit/just/book-kit.just'
+#
+# Recipes run from the book's directory. Any recipe the book's justfile defines
+# with the same name replaces the one here (that's what allow-duplicate-recipes
+# is for), so a book can override a single step without forking the kit.
+#
+# Settings come from book.config.yml (defaults: the kit's defaults/book.config.yml).
+
+set shell := ["bash", "-eu", "-o", "pipefail", "-c"]
+
+kit      := source_directory() / ".."
+bk       := "node " + kit / "bin/book-kit.js"
+kit_defs := kit / "defaults"
+dist     := shell(bk + ' config paths.dist')
+name     := shell(bk + ' config output.basename')
+work     := dist / ".book-kit"
+pdfx_file := dist / (name + shell(bk + ' config output.pdfx_suffix') + ".pdf")
+# Extra pandoc options for the epub, kindle, and html builds, e.g.
+#   BOOK_KIT_PANDOC_ARGS='--toc-depth=3' just epub
+# An environment variable rather than recipe arguments, so `just epub kindle
+# html` runs three recipes instead of passing "kindle html" to pandoc.
+pandoc_args := env('BOOK_KIT_PANDOC_ARGS', '')
+# Build time: the book's last commit, so every build of a commit is
+# byte-identical. pandoc stamps EPUB dcterms:modified, DOCX properties, and zip
+# entries with it; postprocess-epub's repack and the dc:date of a book with no
+# metadata.pub_date use it too. A SOURCE_DATE_EPOCH already in the environment
+# wins. Outside a git checkout it's empty, and everything uses the current time.
+export SOURCE_DATE_EPOCH := env('SOURCE_DATE_EPOCH', `git log -1 --format=%ct 2>/dev/null || true`)
+
+# ─── Build ──────────────────────────────────────────────────────────────────
+
+# Full build: every format, then the format checks.
+[group('build')]
+all: css epub kindle html pdf pdfx check
+
+# Compile the Tailwind stylesheet (book's paths.css, which imports the kit theme).
+# Skips when nothing Tailwind scans is newer than the output: a chapter-only edit
+# still rebuilds, because Tailwind v4 generates utilities from the content.
+[group('build')]
+css: _setup
+    @if [ -f {{dist}}/style.css ] && [ -z "$(find "$({{bk}} config paths.css)" "$({{bk}} config paths.src)" "$({{bk}} config paths.index)" {{kit}}/css {{kit}}/templates {{kit}}/filters -newer {{dist}}/style.css 2>/dev/null | head -1)" ]; then \
+        echo "{{dist}}/style.css is up to date"; \
+    else \
+        npx @tailwindcss/cli -i "$({{bk}} config paths.css)" -o {{dist}}/style.css --minify; \
+    fi
+
+# EPUB 3 for Apple Books, Kobo, Google Play, D2D, IngramSpark (and KDP).
+[group('build')]
+epub: css _strip-css (_prepare "epub")
+    {{bk}} minify-css {{dist}}/style-epub.css
+    pandoc --defaults {{kit_defs}}/pandoc-epub.yml --defaults {{kit_defs}}/pandoc-epub-fonts.yml \
+        --defaults "$({{bk}} config paths.index)" --defaults {{work}}/pandoc-epub.yml \
+        {{pandoc_args}} --output {{dist}}/{{name}}.epub
+    {{bk}} postprocess-epub {{dist}}/{{name}}.epub
+
+# Kindle-optimized EPUB: static fonts, Twemoji images for e-ink, links as
+# footnotes whose URLs stay tappable.
+[group('build')]
+kindle: css _strip-css (_prepare "kindle") _emoji
+    {{bk}} kindle-fonts
+    {{bk}} minify-css {{dist}}/style-epub.css {{dist}}/style-kindle.css
+    {{bk}} prep-print-src --preserve-internal-links --link-footnote-urls >/dev/null
+    pandoc --defaults {{kit_defs}}/pandoc-epub.yml --defaults {{kit_defs}}/pandoc-kindle.yml \
+        --defaults {{work}}/print-index.yml --defaults {{work}}/pandoc-kindle.yml \
+        --metadata kindle=true {{pandoc_args}} --output {{dist}}/{{name}}-kindle.epub
+    {{bk}} postprocess-epub {{dist}}/{{name}}-kindle.epub
+
+# Web edition (also what the link checker and accessibility tests run against).
+[group('build')]
+html: css (_prepare "html")
+    pandoc --defaults {{kit_defs}}/pandoc-base.yml --defaults "$({{bk}} config paths.index)" \
+        --defaults {{work}}/pandoc-html.yml {{pandoc_args}} --output {{dist}}/{{name}}.html
+
+# DOCX for editorial workflows (track changes with an editor).
+[group('build')]
+docx: (_prepare "docx")
+    pandoc --defaults {{kit_defs}}/pandoc-docx.yml --defaults "$({{bk}} config paths.index)" \
+        --defaults {{work}}/pandoc-docx.yml --output {{dist}}/{{name}}.docx
+
+# Generate a reference.docx (heading and body styles for the DOCX build).
+[group('build')]
+reference-docx:
+    {{bk}} generate-reference-docx
+
+# Print-ready PDF (6x9 trade paperback by default; links become footnotes).
+[group('build')]
+pdf: css (_prepare "pdf") _emoji
+    {{bk}} prep-print-src --inject >/dev/null
+    pandoc --defaults {{kit_defs}}/pandoc-base.yml --defaults {{work}}/print-index.yml \
+        --defaults {{work}}/pandoc-pdf.yml --metadata pdf=true \
+        --to=html5 --standalone --output {{dist}}/{{name}}.print.html
+    {{bk}} reorder-print-frontmatter {{dist}}/{{name}}.print.html
+    {{bk}} strip-property-rules {{dist}}/{{name}}.print.html
+    weasyprint --base-url {{dist}}/ --pdf-version 1.4 --dpi 300 --optimize-images \
+        {{dist}}/{{name}}.print.html {{dist}}/{{name}}.pdf
+    @rm -f {{dist}}/{{name}}.print.html
+
+# PDF/X-1a:2001 (CMYK, no transparency) for IngramSpark and other print services.
+[group('build')]
+pdfx: pdf
+    {{bk}} convert-pdfx {{dist}}/{{name}}.pdf {{pdfx_file}} "$({{bk}} config print.pdfx_title)"
+
+# Advance reader copies: <name>-arc.epub and <name>-kindle-arc.epub, the retail
+# EPUBs plus a "not for redistribution" notice on the copyright page
+# (filters/arc-notice.lua). Not part of `all`.
+[group('build')]
+arc: arc-epub arc-kindle
+
+# ARC EPUB. Builds the retail EPUB first for its prepared CSS and pandoc
+# defaults, then reruns pandoc with arc=true into its own file.
+[group('build')]
+arc-epub: epub
+    pandoc --defaults {{kit_defs}}/pandoc-epub.yml --defaults {{kit_defs}}/pandoc-epub-fonts.yml \
+        --defaults "$({{bk}} config paths.index)" --defaults {{work}}/pandoc-epub.yml \
+        --metadata arc=true {{pandoc_args}} --output {{dist}}/{{name}}-arc.epub
+    {{bk}} postprocess-epub {{dist}}/{{name}}-arc.epub
+
+# ARC Kindle EPUB (see arc-epub).
+[group('build')]
+arc-kindle: kindle
+    pandoc --defaults {{kit_defs}}/pandoc-epub.yml --defaults {{kit_defs}}/pandoc-kindle.yml \
+        --defaults {{work}}/print-index.yml --defaults {{work}}/pandoc-kindle.yml \
+        --metadata kindle=true --metadata arc=true {{pandoc_args}} --output {{dist}}/{{name}}-kindle-arc.epub
+    {{bk}} postprocess-epub {{dist}}/{{name}}-kindle-arc.epub
+
+# Release files: copies of the built formats named for the version in
+# <dist>/release/ (book-v1.2.0.epub, book-kindle-v1.2.0.epub, ...) with a
+# checksums.txt. Pass the release tag to fail on a mismatch with VERSION.
+[group('build')]
+release-files tag="":
+    {{bk}} release-files {{ if tag != "" { "--tag " + tag } else { "" } }}
+
+# ─── Validate ───────────────────────────────────────────────────────────────
+
+# Everything a pull request should pass: chapter validators, Markdown lint, prose lint.
+[group('validate')]
+check-all: validate lint prose
+
+# Chapter structure and house-style validators (book.config.yml `validators`).
+[group('validate')]
+validate:
+    {{bk}} validate
+
+# Markdown lint: the kit's config with lint.markdownlint merged in (or the
+# book's own .markdownlint-cli2.jsonc).
+[group('validate')]
+lint *args:
+    @{{bk}} markdownlint {{args}}
+
+# Prose lint with textlint: the kit's base rules, lint.textlint, and the kit
+# and preset rules lint.rules turns on (or the book's own .textlintrc). On
+# GitHub Actions, findings are reported as annotations on each file and line.
+[group('validate')]
+prose *args:
+    @{{bk}} prose {{args}}
+
+
+# Format checks on built output: page-count lock and EPUB size budgets.
+[group('validate')]
+check:
+    @if [ -f {{dist}}/{{name}}.pdf ]; then {{bk}} check-pdf-page-count {{dist}}/{{name}}.pdf; fi
+    @if [ -f {{pdfx_file}} ]; then {{bk}} check-pdf-page-count {{pdfx_file}}; fi
+    {{bk}} check-epub-size --ci
+
+# EPUBCheck on the built EPUBs (needs Java and an epubcheck on PATH or $EPUBCHECK_JAR).
+[group('validate')]
+epubcheck:
+    @for f in {{dist}}/{{name}}.epub {{dist}}/{{name}}-kindle.epub {{dist}}/{{name}}-arc.epub {{dist}}/{{name}}-kindle-arc.epub; do \
+        [ -f "$f" ] || continue; \
+        if [ -n "${EPUBCHECK_JAR:-}" ]; then java -jar "$EPUBCHECK_JAR" "$f"; else epubcheck "$f"; fi; \
+    done
+
+# ─── Maintenance ────────────────────────────────────────────────────────────
+
+# Regenerate each section's key takeaways chapter from its chapters' TL;DRs.
+[group('maintenance')]
+key-takeaways:
+    {{bk}} update-key-takeaways
+
+# Print the build stamp ("<version> (<sha>)").
+[group('maintenance')]
+revision:
+    @{{bk}} revision
+
+# Losslessly recompress PNGs under paths.img.
+[group('maintenance')]
+optimize-images:
+    {{bk}} optimize-images
+
+# Remove build output.
+[group('maintenance')]
+clean:
+    rm -rf {{dist}}
+
+# ─── Internals ──────────────────────────────────────────────────────────────
+
+# Create dist/ and, unless the book brings its own fonts directory, build the
+# theme's fonts (`book-kit fonts`, cached after the first run) and link them
+# there: the theme's @font-face rules load ../fonts/ relative to dist/. A link
+# book-kit made (into an older cache entry, or to the kit's fonts/ from before
+# the kit stopped bundling them) is re-pointed; anything else is the book's own.
+[private]
+_setup:
+    @mkdir -p {{work}}
+    @{{bk}} fonts --link "$({{bk}} config paths.fonts)"
+
+# Write the resolved config (for Lua filters) and per-format pandoc defaults.
+[private]
+_prepare format: _setup
+    @{{bk}} prepare {{format}} >/dev/null
+
+# EPUB stylesheet: strip print-only and e-reader-unsupported CSS. Minifying is
+# left to each recipe: kindle-fonts must read the unminified output.
+[private]
+_strip-css:
+    {{bk}} strip-page-rules {{dist}}/style.css {{dist}}/style-epub.css
+
+# Twemoji PNG variants for Kindle (white under alpha) and print (flattened opaque).
+[private]
+_emoji:
+    @src="$({{bk}} config emoji.source_dir)"; src="${src:-{{kit}}/emoji}"; \
+        kdir="$({{bk}} config emoji.kindle_dir)"; \
+        cdir="{{dist}}/$({{bk}} config emoji.pdf_callout_dir)"; \
+        bdir="{{dist}}/$({{bk}} config emoji.pdf_body_dir)"; \
+        python3 {{kit}}/commands/composite-kindle-emoji.py "$src" "$kdir" >/dev/null; \
+        python3 {{kit}}/commands/composite-print-emoji.py "$src" "$cdir" "$bdir" >/dev/null

package/lib/acronyms.js

@@ -0,0 +1,47 @@
+// The kit's built-in acronym lists, shared by `book-kit validate` and the
+// no-bare-acronyms textlint rule so the two can't drift apart. Books extend
+// them with lint.acronyms and lint.universal_acronyms in book.config.yml.
+
+// Acronyms that should always be written [ACRONYM]{.smallcaps}.
+export const SMALLCAPS_ACRONYMS = [
+  'AI', 'API', 'URL', 'PR', 'CI', 'CD', 'HR', 'IC', 'DM', 'PM', 'VP',
+  'UI', 'UX', 'RFC', 'ADR', 'OKR', 'REST', 'SSH', 'VPN', 'DNS',
+  'HTTP', 'HTTPS', 'CSS', 'HTML', 'PDF', 'EPUB', 'YAML', 'JSON', 'XML',
+  'SQL', 'GIF', 'Q&A',
+];
+
+// Acronyms readers know without a parenthetical expansion on first use.
+export const UNIVERSAL_ACRONYMS = [
+  // Titles and roles
+  'CEO', 'CTO', 'COO', 'CFO', 'VP', 'IC', 'PM', 'HR', 'EM',
+  // Core tech concepts
+  'AI', 'API', 'CLI', 'URL', 'PR', 'CI', 'CD', 'UI', 'UX',
+  'HTTP', 'HTTPS', 'CSS', 'HTML', 'PDF', 'DNS', 'SSH', 'VPN',
+  'JSON', 'YAML', 'XML', 'SQL', 'REST', 'GIF', 'LLM', 'IDE',
+  'CPU', 'PC', 'IT', 'README', 'I/O',
+  // Common business/communication
+  'FYI', 'CC', 'CSV', 'DM', 'ROI', 'FAQ', 'RSVP', 'HQ', 'OKR', 'GDP',
+  // Book format
+  'EPUB',
+  // Globally recognized references
+  'US', 'UK', 'EU', 'DC', 'COVID', 'DNA', 'ISO',
+  // Software licenses
+  'MIT', 'BSD', 'GPL', 'LGPL', 'SaaS', 'GNU',
+  // Publishing
+  'ISBN',
+  // Open source nomenclature
+  'OSS', 'FOSS',
+  // Expanded in non-parenthetical context
+  'DoS', // "denial-of-service" spelled out on same line
+  // Time
+  'AM', 'PM', 'UTC',
+];
+
+// The lists above plus the book's own, from a resolved config.
+export function smallcapsAcronyms(config) {
+  return [...SMALLCAPS_ACRONYMS, ...(config.lint.acronyms ?? [])];
+}
+
+export function universalAcronyms(config) {
+  return [...UNIVERSAL_ACRONYMS, ...(config.lint.universal_acronyms ?? [])];
+}

package/lib/callouts.js

@@ -0,0 +1,17 @@
+// The callout registry (book.config.yml `callouts`), with helpers for the CSS
+// post-processors. Outside a book (e.g. unit tests) it falls back to the kit
+// defaults, so importing a command never requires a book.config.yml.
+
+import { loadConfigOrDefaults } from './config.js';
+
+export const callouts = loadConfigOrDefaults().callouts;
+
+// All callout classes, as selectors: ['.tldr', '.pro-tip', ...]
+export const calloutSelectors = callouts.map((c) => `.${c.class}`);
+
+// Callouts whose label CSS draws with ::before (the build injects the label
+// as text for EPUB, so those pseudo-elements are stripped there).
+export const labelledSelectors = callouts.filter((c) => c.label).map((c) => `.${c.class}`);
+
+// Callouts whose label carries an emoji.
+export const emojiSelectors = callouts.filter((c) => c.emoji).map((c) => `.${c.class}`);

package/lib/config.js

@@ -0,0 +1,211 @@
+// Config loader shared by every book-kit command.
+//
+// Two roots matter, and conflating them is the classic bug when scripts move
+// into a package:
+//   KIT_ROOT  - this package (filters, templates, theme, fonts, defaults)
+//   BOOK_ROOT - the book being built (src/, dist/, index.yml, book.config.yml)
+//
+// BOOK_ROOT is $BOOK_ROOT when set, otherwise the nearest directory at or
+// above the working directory that contains book.config.yml.
+
+import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as yaml from 'js-yaml';
+
+export const CONFIG_FILENAME = 'book.config.yml';
+export const PRESET_FILENAME = 'preset.yml';
+export const KIT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+export function kitPath(...parts) {
+  return join(KIT_ROOT, ...parts);
+}
+
+export function findBookRoot(start = process.cwd()) {
+  if (process.env.BOOK_ROOT) return resolve(process.env.BOOK_ROOT);
+  let dir = resolve(start);
+  for (;;) {
+    if (existsSync(join(dir, CONFIG_FILENAME))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) {
+      throw new Error(
+        `No ${CONFIG_FILENAME} found in ${start} or any parent directory. ` +
+          `Run book-kit from inside a book, or set BOOK_ROOT.`,
+      );
+    }
+    dir = parent;
+  }
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+// Maps merge recursively; lists and scalars from `override` replace `base`.
+export function deepMerge(base, override) {
+  if (!isPlainObject(base) || !isPlainObject(override)) {
+    return override === undefined ? base : override;
+  }
+  const out = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    out[key] = key in base ? deepMerge(base[key], value) : value;
+  }
+  return out;
+}
+
+function readYaml(path) {
+  return yaml.load(readFileSync(path, 'utf8')) ?? {};
+}
+
+// Derived defaults that point at other keys.
+function applyDerivedDefaults(config) {
+  config.llm.title ||= config.metadata.title;
+  if (config.accessibility.conforms_to) config.accessibility.certified_by ||= config.metadata.publisher;
+  config.print.pdfx_title ||= config.metadata.title;
+  return config;
+}
+
+// A preset is a directory holding a preset.yml: config that sits between the
+// kit defaults and the book, so one house style can be shared by many books.
+// A book names presets in `extends`; presets can extend other presets.
+//
+// An `extends` entry is a path (relative to the file that names it), a kit
+// preset (presets/<name>/), or an npm package with a preset.yml at its root,
+// found in node_modules at or above the book.
+export function kitPresets() {
+  const dir = kitPath('presets');
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((name) => existsSync(join(dir, name, PRESET_FILENAME))).sort();
+}
+
+export function resolvePreset(spec, fromDir, bookRoot) {
+  if (typeof spec !== 'string' || spec === '') {
+    throw new Error(`extends entries must be preset names or paths, got ${JSON.stringify(spec)}`);
+  }
+  if (spec.startsWith('.') || isAbsolute(spec)) {
+    const dir = resolve(fromDir, spec);
+    if (existsSync(join(dir, PRESET_FILENAME))) return dir;
+    throw new Error(`Preset "${spec}" in extends has no ${PRESET_FILENAME} (looked in ${dir})`);
+  }
+  const kit = kitPath('presets', spec);
+  if (existsSync(join(kit, PRESET_FILENAME))) return kit;
+  for (let dir = bookRoot; ; dir = dirname(dir)) {
+    const pkg = join(dir, 'node_modules', spec);
+    if (existsSync(join(pkg, PRESET_FILENAME))) return pkg;
+    if (dirname(dir) === dir) break;
+  }
+  throw new Error(
+    `Unknown preset "${spec}" in extends. Kit presets: ${kitPresets().join(', ') || 'none'}. ` +
+      `Otherwise use a path (./my-preset) or install an npm package with a ${PRESET_FILENAME}.`,
+  );
+}
+
+// The presets `specs` names, parents first. Each is applied once, the first
+// time it's reached, so a preset shared by two others can't re-override them.
+function presetLayers(specs, fromDir, bookRoot, chain = [], applied = new Set()) {
+  const layers = [];
+  for (const spec of [].concat(specs ?? [])) {
+    const dir = resolvePreset(spec, fromDir, bookRoot);
+    if (chain.includes(dir)) {
+      throw new Error(`Preset cycle in extends: ${[...chain, dir].join(' -> ')}`);
+    }
+    if (applied.has(dir)) continue;
+    const { extends: parents, ...data } = readYaml(join(dir, PRESET_FILENAME));
+    layers.push(...presetLayers(parents, dir, bookRoot, [...chain, dir], applied));
+    applied.add(dir);
+    layers.push({ source: `preset ${spec}`, name: spec, dir, data });
+  }
+  return layers;
+}
+
+// Every layer of a book's config, lowest first: kit defaults, presets, book.
+function configLayers(bookRoot) {
+  const { extends: specs, ...own } = readYaml(join(bookRoot, CONFIG_FILENAME));
+  return [
+    { source: 'kit defaults', data: readYaml(kitPath('defaults', CONFIG_FILENAME)) },
+    ...presetLayers(specs, bookRoot, bookRoot),
+    { source: CONFIG_FILENAME, data: own },
+  ];
+}
+
+const cache = new Map();
+
+export function loadConfig({ root, fresh = false } = {}) {
+  const bookRoot = root ? resolve(root) : findBookRoot();
+  if (!fresh && cache.has(bookRoot)) return cache.get(bookRoot);
+
+  const layers = configLayers(bookRoot);
+  const config = layers.reduce((merged, layer) => deepMerge(merged, layer.data), {});
+
+  applyDerivedDefaults(config);
+
+  Object.defineProperty(config, 'root', { value: bookRoot, enumerable: false });
+  // The presets in effect, in merge order, so commands can find their files.
+  const presets = layers.filter((l) => l.dir).map(({ name, dir }) => ({ name, dir }));
+  Object.defineProperty(config, 'presets', { value: presets, enumerable: false });
+  cache.set(bookRoot, config);
+  return config;
+}
+
+// Which layer set each key: { 'metadata.title': 'book.config.yml', ... }.
+// A list is one value, since a later layer replaces it wholesale. Keys filled
+// in by derived defaults (e.g. print.pdfx_title) report the layer that set
+// them explicitly.
+export function configSources({ root } = {}) {
+  const bookRoot = root ? resolve(root) : findBookRoot();
+  const sources = {};
+  const walk = (node, prefix, source) => {
+    for (const [key, value] of Object.entries(node)) {
+      const dotted = prefix ? `${prefix}.${key}` : key;
+      if (isPlainObject(value) && Object.keys(value).length > 0) walk(value, dotted, source);
+      else sources[dotted] = source;
+    }
+  };
+  for (const layer of configLayers(bookRoot)) walk(layer.data, '', layer.source);
+  return sources;
+}
+
+// loadConfig(), or the kit defaults when there's no book (e.g. unit tests that
+// import a command module). Never use this for a build: it hides a missing
+// book.config.yml.
+export function loadConfigOrDefaults() {
+  try {
+    return loadConfig();
+  } catch (error) {
+    if (!String(error.message).includes(CONFIG_FILENAME)) throw error;
+    const config = readYaml(kitPath('defaults', CONFIG_FILENAME));
+    return applyDerivedDefaults(config);
+  }
+}
+
+// Absolute path inside the book. bookPath('src', 'intro.md'), or a configured
+// path key: bookPath(config.paths.dist).
+export function bookPath(...parts) {
+  return join(loadConfig().root, ...parts);
+}
+
+// Resolve a configured path key (e.g. 'dist', 'src', 'index') to an absolute path.
+export function pathFor(key, config = loadConfig()) {
+  const rel = config.paths[key];
+  if (rel === undefined) throw new Error(`Unknown paths.${key} in ${CONFIG_FILENAME}`);
+  return join(config.root, rel);
+}
+
+// dist/<basename><suffix>, e.g. outputFile('.epub') or outputFile('-kindle.epub').
+export function outputFile(suffix, config = loadConfig()) {
+  return join(pathFor('dist', config), `${config.output.basename}${suffix}`);
+}
+
+// Dotted lookup for the CLI: get('output.basename').
+export function get(config, dotted) {
+  return dotted.split('.').reduce((node, key) => (node == null ? undefined : node[key]), config);
+}
+
+// Lua filters can't parse YAML, so the build writes the resolved config as JSON
+// and points filters at it with $BOOK_KIT_CONFIG.
+export function writeConfigJson(config = loadConfig()) {
+  const out = join(pathFor('dist', config), '.book-kit', 'config.json');
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, `${JSON.stringify(config, null, 2)}\n`);
+  return out;
+}