book-cover-generator 1.6.0 → 1.8.0

package/README.md

@@ -5,9 +5,10 @@
 [![Website](https://img.shields.io/website?url=https%3A%2F%2Fcovers.otsirh.dev&label=covers.otsirh.dev)](https://covers.otsirh.dev)
 ![Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen)
 ![Types](https://img.shields.io/badge/types-included-blue)
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/otsirh/book-cover-generator/badge)](https://scorecard.dev/viewer/?uri=github.com/otsirh/book-cover-generator)
 [![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
 
-Generate book covers from a **title** and an **author**. 34 styles, 28 palettes or your own colours, a seeded randomizer, any size, and export to **SVG, PNG, JPEG or WebP**. The library has no dependencies and ships TypeScript types. It's written as plain ES modules, so it runs in the browser and in Node.
+Generate book covers from a **title** and an **author**. 39 styles, 28 palettes or your own colours, a seeded randomizer, any size, and export to **SVG, PNG, JPEG or WebP**. The library has no dependencies and ships TypeScript types. It's written as plain ES modules, so it runs in the browser, Node, Deno and Bun.
 
 **[▶ Open the generator](https://covers.otsirh.dev)**
 
@@ -15,9 +16,9 @@ Generate book covers from a **title** and an **author**. 34 styles, 28 palettes
 
 ## Features
 
-- **34 styles in six families.**
+- **39 styles in six families.**
   - Typographic: Big Type, Minimal, Big Letter, Swiss.
-  - Genre: Thriller, Botanical, Noir, Blueprint.
+  - Genre: Thriller, Botanical, Noir, Blueprint, Hollow (horror), Ribbon (romance), Crest (fantasy), Storybook (children's), Big Idea (non-fiction).
   - Vintage: Art Deco, Classic Paperback, Engraved, Sunburst, Typewriter.
   - Scenic: Landscape, Retro Sun, Silhouette, Constellation, Orbit, Waves, Aurora, Bookshelf.
   - Geometric: Bauhaus, Split, Blocks, Concentric, Stripes.
@@ -33,13 +34,13 @@ Generate book covers from a **title** and an **author**. 34 styles, 28 palettes
 
 On [covers.otsirh.dev](https://covers.otsirh.dev) you type a title and author (press Enter in the title to break its line where you want), and if you like a subtitle, a series line ("Book Two of the Ember Cycle"), a credit ("Translated by…") and a badge ("Winner of the Hugo Award", set as a seal in a corner clear of the text). Then you choose:
 
-- **a style**, from a rail that previews your book in all 34 styles. Eleven styles let you pin a choice the variation otherwise makes, such as Silhouette's city or forest, or where Aurora puts the title;
+- **a style**, from a rail that previews your book in all 39 styles (its Genre menu shows only those that suit a genre, and Randomize then stays in it). Fifteen styles let you pin a choice the variation otherwise makes, such as Silhouette's city or forest, or where Aurora puts the title;
 - **title type**: any of the nine fonts instead of the style's, and the title in capitals or as typed. It stays when you change style, so the rail shows every style in your type;
 - **a palette**, from swatches that show the background, text colour and accents, or **Custom** for your own five colours (it starts from the palette on the cover and shows the text contrast);
 - **a variation**, the seed behind the artwork: the strip under the preview shows six others to click;
 - **a format**: paperback, eBook, square, or **Custom** for any size in pixels, typed in or picked from common sizes (Kindle, print trim sizes at 300 dpi, audiobook, social posts).
 
-**Store size** shrinks the preview to the size a store lists covers at, to check the title still reads. **Randomize** reshuffles everything, except what you've locked. Undo and redo step back and forth through your designs, and so do the browser's Back and Forward buttons. **Copy link** shares the exact design, because the URL holds every setting. The export panel tells you which size suits Kindle, print or audiobook covers.
+**Store size** shrinks the preview to the size a store lists covers at, to check the title still reads. **Randomize** reshuffles everything, except what you've locked. Undo and redo step back and forth through your designs, and so do the browser's Back and Forward buttons. **Copy link** shares the exact design, because the URL holds every setting, and **Copy image link** gives the [HTTP API](#http-api) URL that draws it, to put in any page. The export panel tells you which size suits Kindle, print or audiobook covers.
 
 **Mockup** shows and downloads the cover as a 3D book, a flat shot, on an e-reader, or on a social card (a 1200 × 630 link preview, a square post or a story, with a line such as "Out now").
 
@@ -58,6 +59,66 @@ Keyboard shortcuts:
 
 The single-key shortcuts can be turned off under the controls (for example with speech input).
 
+## HTTP API
+
+The site draws covers from a URL too, so a page can show one with nothing installed:
+
+```html
+<img src="https://covers.otsirh.dev/api/cover.svg?title=Dune&author=Frank+Herbert&style=retro" alt="Dune" />
+```
+
+- `GET /api/cover.svg` answers with the cover as SVG.
+- `GET /api/mockup.svg` answers with a [mockup](#mockups) of it. Add `kind` (`book`, `flat`, `ereader`, `card`, `square`, `story`), `text` for the line on a card, square or story, and `background`.
+
+The query takes the options' own names (`title`, `author`, `subtitle`, `series`, `credit`, `badge`, `style`, `palette`, `seed`, `genre`, `font`, `lang`, `width`, `height`) and the app's link parameters, so the part of an app link after `#` draws the same design (the server measures text with the widths of the fonts as macOS draws them, so on another system a line can break a little differently from the app's preview):
+
+| parameter             | value                                                                                          |
+| --------------------- | ---------------------------------------------------------------------------------------------- |
+| `format`              | `paperback`, `ebook`, `square`, or a size in px such as `1600x2560`                            |
+| `case`                | the title `upper`, or `normal` (as typed)                                                      |
+| `texture`             | `1` (on) or `0` (off)                                                                          |
+| `variant`             | pinned choices as `name.value`, joined by `-`: `field.pale-emblem.sun`                         |
+| `palette`             | a palette id, or your own colours as `custom-0b132b-f8f9fa-ff6b6b` (background, text, accents) |
+| `bg`, `ink`, `accent` | your own colours, as hex (the `#` is optional; accents separated by commas)                    |
+
+A title breaks its line at `%0A`. Anyone may embed the answers (CORS and `Cross-Origin-Resource-Policy` allow it), and the headers `X-Cover-Style`, `X-Cover-Palette` and `X-Cover-Version` say what was drawn. The same URL always draws the same cover in a version of the library, so answers are cached for a day. Options the library rejects get a `400` with the reason as plain text.
+
+## On any page: `<book-cover>`
+
+One script, then a cover wherever you write the element:
+
+```html
+<script type="module" src="https://covers.otsirh.dev/src/element.js"></script>
+
+<book-cover cover-title="Dune" author="Frank Herbert" cover-style="retro" seed="1"></book-cover>
+```
+
+Its attributes are the app's link parameters, except the title and the style, which are `cover-title` and `cover-style` (`title` and `style` are HTML's own): `cover-title`, `author`, `subtitle`, `series`, `credit`, `badge`, `cover-style`, `genre`, `palette`, `seed`, `format`, `font`, `case`, `variant`, `texture` (present: on) and `lang` (the language of the text, such as `zh-Hant`). Styles, palettes and fonts may be named as the app's menus name them. The cover is 240 px wide unless you style the element's `width`; it draws again when an attribute changes, and fires `cover` (with the cover) or `cover-error` (with what's wrong). It is drawn in the page, measuring the text with the fonts installed there, and shown as an image, so a page with Trusted Types can show it (its CSP must allow `data:` images). An image can't use the page's web fonts: if the page loads one that a cover's font stack names (such as EB Garamond or Oswald), the text is measured in it but drawn in the system's font, and may fit less well. From npm: `import 'book-cover-generator/element'`.
+
+## From an AI assistant (MCP)
+
+Book Cover Generator is a [Model Context Protocol](https://modelcontextprotocol.io) server, so an assistant such as Claude can make covers for you: "a cover for my horror novel _The Hollow Night_, in red". It answers with a link to the image and one that opens the cover in the app to change and download.
+
+Add it to Claude Code:
+
+```sh
+claude mcp add book-covers -- npx -y book-cover-generator --mcp
+# or, with nothing installed, the hosted server:
+claude mcp add --transport http book-covers https://covers.otsirh.dev/mcp
+```
+
+Or to any client that takes a JSON configuration (Claude Desktop, Cursor and others):
+
+```json
+{
+  "mcpServers": {
+    "book-covers": { "command": "npx", "args": ["-y", "book-cover-generator", "--mcp"] }
+  }
+}
+```
+
+The tools: `create_cover` (a title, and any of author, subtitle, style, genre, palette or your own colours, seed, format, font, pins), `create_mockup` (the same, as a 3D book, on an e-reader or on a social card), `list_styles` and `list_palettes`. Run locally, `create_cover` can also save the SVG to a file (`output`).
+
 ## Library usage
 
 ### Browser (no install)
@@ -77,7 +138,7 @@ The single-key shortcuts can be turned off under the controls (for example with
 
 `@1` gives you the latest 1.x release. Pin an exact version (such as `@1.1.0`) if you need the artwork to never change.
 
-### Node / bundlers
+### Node, Deno, Bun and bundlers
 
 ```sh
 npm install book-cover-generator
@@ -98,6 +159,8 @@ const { svg, style, palette, seed } = createCover({
 writeFileSync('cover.svg', svg);
 ```
 
+In Deno, import `npm:book-cover-generator`; in Bun, `bun add book-cover-generator`. CI checks that Node, Deno and Bun draw the same covers byte for byte.
+
 ### CLI
 
 ```sh
@@ -116,7 +179,7 @@ npx book-cover-generator --batch books.csv --style minimal --seed series --out-d
 npx book-cover-generator "Salt and Static" --count 12 -o ideas/cover.svg
 ```
 
-Options: `-s/--style`, `-p/--palette`, `--bg`, `--ink`, `--accent`, `--subtitle`, `--texture`, `--seed`, `--format` (`paperback`, `ebook` or `square`), `--width`, `--height`, `--size`, `--lang`, `--series`, `--credit`, `--badge`, `--font`, `--case upper|normal`, `--variant name=value` (`--list` shows each style's), `-o/--out`, `--count`, `--batch <file|->`, `--out-dir`, `--json`, `--list`, `--help`.
+Options: `-s/--style`, `-p/--palette`, `--bg`, `--ink`, `--accent`, `--subtitle`, `--texture`, `--seed`, `--format` (`paperback`, `ebook` or `square`), `--width`, `--height`, `--size`, `--genre`, `--lang`, `--series`, `--credit`, `--badge`, `--font`, `--case upper|normal`, `--variant name=value` (`--list` shows each style's), `-o/--out`, `--count`, `--batch <file|->`, `--out-dir`, `--json`, `--list`, `--help`.
 
 ## API
 
@@ -144,9 +207,12 @@ Same as `generateCover`, but also tells you which style and palette were chosen.
 | `height`    | `number`           | `width × 1.5`          | px, 50–10000                                      |
 | `lang`      | `string`           | inferred               | language of the text, such as `'ja'`              |
 | `variants`  | `object`           | `{}`                   | pin a style's choices: `{ scene: 'forest' }`      |
+| `genre`     | `string`           |                        | with a random style, one that suits this genre    |
 | `font`      | `string`           | the style's            | the title's font, one of `FONTS`                  |
 | `titleCase` | `string`           | the style's            | `'upper'` (capitals) or `'normal'` (as typed)     |
 
+Styles, palettes, genres and fonts may be given by id or by name, in any case: `'artdeco'`, `'Art Deco'` and `'ART DECO'` are the same style, and a book list or a link can name them as the app's menus do.
+
 `lang` is set on the cover so Chinese characters get the right glyphs for the language. Without it, text with kana is marked Japanese and text with Hangul Korean; pass `'zh-Hans'`, `'zh-Hant'` or `'ja'` for text in Chinese characters only.
 
 Titles and subtitles longer than 300 characters (authors: 200) are cut. With `'random'`, the style and palette are picked from the seed, so you get the same result every time for the same seed. Some styles prefer dark or light palettes when they pick one themselves. Invalid options throw an error that says what's wrong.
@@ -154,13 +220,16 @@ Titles and subtitles longer than 300 characters (authors: 200) are cut. With `'r
 ### Other exports
 
 - `styles`: array of style ids
-- `listStyles()`: `[{ id, name, description, group, variants }]`. `variants` lists the choices a style lets you pin, as `[{ name, label, values: [{ value, label }] }]`; pin them with `createCover({ variants: { scene: 'forest' } })`, and `createCover` reports the ones it used in `variants`. Names a style lacks are ignored; a value it lacks throws
+- `genres`: `[{ id, name }]`, the genres styles suit: `literary`, `thriller`, `horror`, `romance`, `fantasy`, `children`, `nonfiction`
+- `listStyles()`: `[{ id, name, description, group, variants, genres }]`. `variants` lists the choices a style lets you pin, as `[{ name, label, values: [{ value, label }] }]`; pin them with `createCover({ variants: { scene: 'forest' } })`, and `createCover` reports the ones it used in `variants`. Names a style lacks are ignored. A value no style offers throws; with a style you name, so does a value that style lacks (a style picked at random takes only the pins it can)
 - `palettes`: `[{ id, name, bg, ink, accents, dark? }]`
 - `randomSeed()`: a short random seed string
 - `pickStyle(options)`: the style id `createCover` would use for these options (resolving `'random'` from the seed), without drawing the cover
 - `registerStyle({ id, name, description, group, prefer, render(ctx) })`: add your own style (see below). Replacing a built-in style takes `registerStyle(style, { replace: true })`; `unregisterStyle(id)` removes a style or brings the built-in back
 - `registerPalette({ id, name, bg, ink, accents })`: add a palette to use by id, as `palette: 'brand'` (`{ replace: true }` for a built-in id); `unregisterPalette(id)` removes it. Registered styles and palettes can also be picked by `'random'`, so registering one changes what a seed gives
 - `parseBookList(text)`: a list of books (CSV with commas, semicolons or tabs and a header row naming a `title` column, JSON lines, or one "Title | Author | Subtitle" per line) as cover options, one per book
+- `styleIdFor(name)`: the id of the style a name or id names, in any case (`'Art Deco'` → `'artdeco'`), or `undefined`
+- `optionsForBook(book, defaults)`: the options for one of those books over the options every book shares (its own values win; a genre the shared style doesn't suit picks a style that does)
 - `noteText(x0, y0, x1, y1)` and `recordText(draw)`: note where a custom style writes its own text (so a badge stays clear of it), and collect what `draw` notes
 - `version`: the library's version (artwork for a seed can change between minor versions)
 - `sizeLimits` (`{ min: 50, max: 10000, ratio: 3 }`) and `formats` (`paperback`, `ebook` and `square` as `[width, height]` at 600 px wide): the sizes covers can have, and the app's shapes
@@ -256,7 +325,7 @@ registerStyle({
 
 ## Notes
 
-- **Fonts.** Covers only use system font stacks (Georgia, Helvetica, Futura, Didot, Impact, Courier and others), each with close matches on Windows, Android and Linux. This is because an SVG drawn into a canvas for PNG/JPEG export can't load web fonts. In the browser, text is measured with a canvas, so it fits exactly. In Node, widths are estimated; plug in a real font engine with `setTextMeasurer` if you need exact fits there.
+- **Fonts.** Covers only use system font stacks (Georgia, Helvetica, Futura, Didot, Impact, Courier and others), each with close matches on Windows, Android and Linux. This is because an SVG drawn into a canvas for PNG/JPEG export can't load web fonts. In the browser, text is measured with a canvas, so it fits exactly. In Node (and the CLI and HTTP API), the built-in fonts are measured from their characters' widths as macOS draws them, so text fits much as it does in the app; fonts of your own are estimated. Plug in a real font engine with `setTextMeasurer` if you need exact fits there.
 - **Deterministic.** The same options always give the same artwork. In Node the SVG is identical every time. In the browser, text is measured with the fonts installed on that computer, so line breaks can differ slightly between machines. Registering a custom style changes which style `style: 'random'` picks for a given seed.
 - **Versioning.** Artwork for a given seed can change in minor releases (a style gets better). Pin an exact version if you need byte-identical covers forever.
 - **Browser support.** Current Chrome, Edge, Firefox and Safari. Every release is tested in Chromium, Firefox and WebKit, including PNG and JPEG export.
@@ -271,9 +340,10 @@ npm run dev                # http://127.0.0.1:4173
 
 | script                  | what it does                                                      |
 | ----------------------- | ----------------------------------------------------------------- |
-| `npm run check`         | lint, format check, type check, package check and unit tests      |
+| `npm run check`         | lint, format, type and package checks, unit tests and fuzzing     |
 | `npm test`              | unit tests (`node --test`)                                        |
 | `npm run test:coverage` | unit tests with coverage thresholds                               |
+| `npm run test:fuzz`     | property-based fuzzing (fast-check); `FUZZ_RUNS=20` for more      |
 | `npm run test:e2e`      | browser tests in Chromium, Firefox, WebKit and mobile Chrome      |
 | `npm run format`        | format everything with Prettier                                   |
 | `npm run assets`        | regenerate the app icons, the social preview and the README image |
@@ -285,7 +355,7 @@ Open `examples/contact-sheet.html?palettes=noir,mint&seeds=a,b` on the dev serve
 
 ```
 src/            the library (plain ES modules + .d.ts types)
-  styles/       the 34 styles, one file per family
+  styles/       the 39 styles, in a file per family
 bin/            the CLI
 site/           the web app (index.html is at the root)
 public/         files served at the site root: headers, 404, icons, manifest, service worker
@@ -293,9 +363,10 @@ test/           unit tests (node --test)
 test-d/         type tests (tsc)
 e2e/            browser tests (Playwright)
 scripts/        build, dev server and asset generation
+worker/         the HTTP API (the site's Worker)
 ```
 
-The site is a static [Cloudflare Workers](https://developers.cloudflare.com/workers/static-assets/) deployment configured in `wrangler.jsonc`, with security headers in `public/_headers`.
+The site is a [Cloudflare Workers](https://developers.cloudflare.com/workers/static-assets/) deployment configured in `wrangler.jsonc`: static assets, with security headers in `public/_headers`, and a Worker (`worker/index.js`) that answers `/api/*`. The dev server answers `/api/*` the same way.
 
 ## Contributing
 

package/bin/book-cover.js

@@ -1,14 +1,21 @@
 #!/usr/bin/env node
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
 import { parseArgs } from 'node:util';
-import { createCover, listStyles, palettes, formats, parseBookList } from '../src/index.js';
+import { createCover, listStyles, palettes, parseBookList, optionsForBook, genres } from '../src/index.js';
+import { hex, slug } from '../src/shared.js';
+import { px, formatSize } from '../src/link.js';
+import { handlePayload } from '../src/mcp.js';
 
 const HELP = `Usage: book-cover "<title>" ["<author>"] [options]
 
 Options:
   -s, --style <id>      style id or "random" (default: random from seed)
   -p, --palette <id>    palette id or "random" (default: random from seed)
+      --genre <id>      with a random style, one that suits this genre:
+                        literary, thriller, horror, romance, fantasy, children
+                        or nonfiction
       --bg <hex>        your own colours instead of a palette: background,
       --ink <hex>       text,
       --accent <hex>    and accents (repeat it, or separate them with commas)
@@ -23,14 +30,16 @@ Options:
       --badge <text>    a seal in a corner clear of the text ("Bestseller")
       --texture         add a fine film-grain texture
       --seed <value>    seed for the artwork (default: title + author)
-      --format <shape>  paperback (2:3, the default), ebook (5:8) or square
+      --format <shape>  paperback (2:3, the default), ebook (5:8), square, or a
+                        shape such as 1600x2560; with --width or --height, that
+                        shape at that width or height
       --width <px>      width  (default 600)
       --height <px>     height (default: from the format)
       --size <WxH>      width and height at once, e.g. 1600x2560
       --lang <tag>      language of the text, e.g. ja or zh-Hant (default: inferred)
       --batch <file>    a cover for each book in a list (- reads stdin): CSV or
                         TSV with a header row (title, author, subtitle, series,
-                        credit, badge, style, palette, seed, font, case, lang,
+                        credit, badge, style, genre, palette, seed, font, case, lang,
                         width, height, texture), JSON lines, or one book per
                         line as "Title | Author | Subtitle"; the other options
                         apply to every book the list doesn't say otherwise for
@@ -41,6 +50,8 @@ Options:
       --json            print the choices (and the SVG, without --out) as JSON,
                         one line per cover
       --list            list styles and palettes
+      --mcp             serve the Model Context Protocol on stdin and stdout, so an
+                        AI assistant can make covers (see the README)
       --help            show this help
 
 Examples:
@@ -57,6 +68,7 @@ try {
     options: {
       style: { type: 'string', short: 's' },
       palette: { type: 'string', short: 'p' },
+      genre: { type: 'string' },
       bg: { type: 'string' },
       ink: { type: 'string' },
       accent: { type: 'string', multiple: true },
@@ -81,6 +93,7 @@ try {
       json: { type: 'boolean' },
       list: { type: 'boolean' },
       help: { type: 'boolean' },
+      mcp: { type: 'boolean' },
     },
   });
 } catch (err) {
@@ -95,6 +108,10 @@ const { values, positionals } = args;
  * set, not exited with, so output piped elsewhere is written in full first.)
  */
 function preflight() {
+  if (values.mcp) {
+    serveMcp();
+    return false;
+  }
   if (values.help) {
     console.log(HELP);
     return false;
@@ -103,10 +120,13 @@ function preflight() {
     console.log('Styles:');
     for (const s of listStyles()) {
       console.log(`  ${s.id.padEnd(14)} ${s.description}`);
+      if (s.genres.length) console.log(`  ${''.padEnd(14)}   genres: ${s.genres.join(', ')}`);
       for (const v of s.variants) {
         console.log(`  ${''.padEnd(14)}   --variant ${v.name}=${v.values.map((x) => x.value).join('|')}`);
       }
     }
+    console.log('\nGenres (--genre):');
+    for (const g of genres) console.log(`  ${g.id.padEnd(14)} ${g.name}`);
     console.log('\nPalettes:');
     for (const p of palettes) console.log(`  ${p.id.padEnd(14)} ${p.name}${p.dark ? ' (dark)' : ''}`);
     return false;
@@ -129,17 +149,6 @@ function preflight() {
   return true;
 }
 
-/**
- * A --width/--height value as a number, reporting what was typed if it isn't one.
- * @param {string | undefined} value @param {string} name
- */
-function size(value, name) {
-  if (value === undefined) return undefined;
-  const number = Number(value);
-  if (!value.trim() || !Number.isFinite(number)) throw new RangeError(`--${name} must be a number, got "${value}"`);
-  return number;
-}
-
 /**
  * Width and height from --format, --width, --height and --size.
  * @returns {{ width?: number, height?: number }}
@@ -153,22 +162,14 @@ function dimensions() {
     if (!m) throw new RangeError(`--size must look like 1600x2560, got "${values.size}"`);
     return { width: Number(m[1]), height: Number(m[2]) };
   }
-  const width = size(values.width, 'width');
-  const height = size(values.height, 'height');
+  const width = values.width === undefined ? undefined : px('--width', values.width);
+  const height = values.height === undefined ? undefined : px('--height', values.height);
   if (values.format === undefined) return { width, height };
-  if (!Object.hasOwn(formats, values.format)) {
-    throw new Error(`Unknown format "${values.format}". Available: ${Object.keys(formats).join(', ')}`);
-  }
-  if (height !== undefined) throw new Error('--format sets the height from the width: use --size for both');
-  // The shape of the app's format, at the width asked for.
-  const [w, h] = formats[/** @type {keyof typeof formats} */ (values.format)];
-  const W = width ?? 600;
-  return { width: W, height: Math.round((W * h) / w) };
+  // A preset or a WxH shape, at the width or height asked for (as the HTTP API reads it).
+  const [w, h] = formatSize(values.format, width, height);
+  return { width: w, height: h };
 }
 
-/** A colour as typed, with the # added (it starts a comment in most shells). @param {string} c */
-const hex = (c) => (c.trim().startsWith('#') ? c.trim() : `#${c.trim()}`);
-
 /** The palette: an id, or your own colours from --bg, --ink and --accent. */
 function palette() {
   const custom = values.bg !== undefined || values.ink !== undefined || values.accent !== undefined;
@@ -231,18 +232,6 @@ function fileFor(out, n, total, seed) {
  */
 const safeName = (seed) => seed.replace(/[^\p{L}\p{N}._-]+/gu, '-').replace(/^[.-]+/, '') || 'cover';
 
-/** A title as part of a file name: lower case, accents off Latin letters, dashes between words. @param {string} title */
-function slug(title) {
-  const words = title
-    .normalize('NFKD')
-    .replace(/(\p{Script=Latin})[\u0300-\u036f]+/gu, '$1')
-    .normalize('NFC')
-    .toLowerCase()
-    .replace(/[^\p{L}\p{M}\p{N}]+/gu, '-')
-    .replace(/^-+/, '');
-  return Array.from(words).slice(0, 60).join('').replace(/-+$/, '') || 'cover';
-}
-
 /**
  * Write a cover for each book in the --batch list into --out-dir; the command line's options
  * apply to every book the list doesn't say otherwise for.
@@ -266,14 +255,9 @@ function batch(defaults) {
   books.forEach((book, i) => {
     const n = i + 1;
     try {
-      // A size in the list replaces the command line's.
-      const sized = book.width !== undefined || book.height !== undefined;
-      const cover = createCover({
-        ...defaults,
-        ...(sized ? { width: undefined, height: undefined } : {}),
-        ...book,
-        seed: book.seed ?? values.seed,
-      });
+      // (The book's own values win, a size in the list replaces the command line's, and a genre
+      // --style doesn't suit picks a style that does: see optionsForBook.)
+      const cover = createCover({ ...optionsForBook(book, defaults), seed: book.seed ?? values.seed });
       const file = join(dir, `${String(n).padStart(digits, '0')}-${slug(cover.title)}.svg`);
       writeFileSync(file, cover.svg);
       const { style, palette: paletteId, seed, width, height } = cover;
@@ -298,6 +282,7 @@ function run() {
         badge: values.badge,
         texture: values.texture,
         style: values.style,
+        genre: values.genre,
         palette: palette(),
         lang: values.lang,
         variants: variants(),
@@ -317,6 +302,7 @@ function run() {
       badge: values.badge,
       texture: values.texture,
       style: values.style,
+      genre: values.genre,
       palette: palette(),
       lang: values.lang,
       variants: variants(),
@@ -332,6 +318,7 @@ function run() {
       const choices = { style, palette: paletteId, seed: cover.seed, width, height, lang, variants: cover.variants };
       if (values.out) {
         const file = fileFor(values.out, n, total, cover.seed);
+        mkdirSync(dirname(file), { recursive: true });
         writeFileSync(file, cover.svg);
         if (values.json) process.stdout.write(JSON.stringify({ file, ...choices }) + '\n');
         else console.error(`Wrote ${file} (style: ${style}, palette: ${paletteId}, ${width}x${height})`);
@@ -347,4 +334,36 @@ function run() {
   }
 }
 
+/**
+ * Serve MCP over stdio: a JSON-RPC message per line in, an answer per line out (nothing else on
+ * stdout). A cover can be saved to a file, at an absolute path (the host picks the folder it runs in).
+ */
+function serveMcp() {
+  const lines = createInterface({ input: process.stdin });
+  /** @param {string} path @param {string} data */
+  const writeFile = (path, data) => {
+    // (A host starts the server in a folder of its own choosing: a relative path would land there.)
+    if (!isAbsolute(path)) throw new Error(`output must be an absolute path, got "${path}"`);
+    const file = resolve(path);
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, data);
+    return file;
+  };
+  /** @param {unknown} message */
+  const answer = (message) => {
+    if (message) process.stdout.write(`${JSON.stringify(message)}\n`);
+  };
+  lines.on('line', (line) => {
+    if (!line.trim()) return;
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      answer({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } });
+      return;
+    }
+    answer(handlePayload(message, { writeFile }));
+  });
+}
+
 if (preflight()) run();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "book-cover-generator",
-  "version": "1.6.0",
-  "description": "Generate SVG book covers from a title and an author. 34 styles, 28 palettes, seeded randomizer, zero dependencies.",
+  "version": "1.8.0",
+  "description": "Generate SVG book covers from a title and an author. 39 styles, 28 palettes, seeded randomizer, zero dependencies.",
   "keywords": [
     "book",
     "cover",
@@ -23,7 +23,9 @@
   "license": "MIT",
   "author": "otsirh (https://github.com/otsirh)",
   "type": "module",
-  "sideEffects": false,
+  "sideEffects": [
+    "./src/element.js"
+  ],
   "exports": {
     ".": {
       "types": "./src/index.d.ts",
@@ -33,6 +35,10 @@
       "types": "./src/browser.d.ts",
       "default": "./src/browser.js"
     },
+    "./element": {
+      "types": "./src/element.d.ts",
+      "default": "./src/element.js"
+    },
     "./package.json": "./package.json"
   },
   "main": "./src/index.js",
@@ -51,15 +57,17 @@
     "dev": "node scripts/serve.js 4173",
     "build": "node scripts/build.js",
     "lint": "eslint .",
-    "lint:package": "publint --strict && attw --pack . --profile esm-only",
+    "lint:package": "publint --strict && attw --pack . --profile esm-only && node scripts/check-bundle.js",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "typecheck": "tsc -p tsconfig.json",
     "test": "node --test",
     "test:coverage": "node --test --experimental-test-coverage --test-coverage-include=src/**/*.js --test-coverage-exclude=src/browser.js --test-coverage-lines=99 --test-coverage-branches=95 --test-coverage-functions=98",
+    "test:fuzz": "node --test fuzz/*.fuzz.js",
     "test:e2e": "playwright test",
-    "check": "npm run lint && npm run format:check && npm run typecheck && npm run lint:package && npm test",
+    "check": "npm run lint && npm run format:check && npm run typecheck && npm run lint:package && npm test && npm run test:fuzz",
     "assets": "node scripts/generate-assets.js",
+    "metrics": "node scripts/generate-metrics.js",
     "deploy": "npm run check && npm run test:e2e && wrangler deploy"
   },
   "devDependencies": {
@@ -68,7 +76,9 @@
     "@eslint/js": "10.0.1",
     "@playwright/test": "1.65.0",
     "@types/node": "26.6.6",
+    "esbuild": "0.28.2",
     "eslint": "10.14.0",
+    "fast-check": "4.10.2",
     "globals": "17.14.0",
     "prettier": "3.10.0",
     "publint": "0.3.25",

package/src/books.js

@@ -10,6 +10,7 @@ const COLUMNS = /** @type {const} */ ({
   credit: 'credit',
   badge: 'badge',
   style: 'style',
+  genre: 'genre',
   palette: 'palette',
   seed: 'seed',
   font: 'font',
@@ -21,8 +22,12 @@ const COLUMNS = /** @type {const} */ ({
   texture: 'texture',
 });
 
-/** Separators of a plain line: a tab, or a bar or dash with spaces around it. */
-const LINE_SEPARATOR = /\t| \| | — | – /;
+/**
+ * Separators of a plain line, by precedence: a tab, a bar, or a dash, with spaces around it. A line
+ * is split at the first kind it uses only, so "Harry Potter – The Stone | J. K. Rowling" keeps
+ * its dash in the title.
+ */
+const LINE_SEPARATORS = ['\t', ' | ', ' — ', ' – '];
 
 /**
  * Split CSV (or TSV) text into rows of fields: quoted fields may hold the delimiter, quotes ("")
@@ -84,7 +89,8 @@ function optionsFrom(named) {
     // (Numbers stay numbers for sizes and the seed; any other column is text, a title of 1984 too.)
     const value = typeof raw === 'number' && option !== 'title' ? raw : String(raw).trim();
     if (value === '') continue;
-    if (option === 'width' || option === 'height') out[option] = Number(value);
+    // (A size that isn't a number is kept as written, so the error says what the list says.)
+    if (option === 'width' || option === 'height') out[option] = Number.isFinite(Number(value)) ? Number(value) : value;
     else out[option] = option === 'seed' ? value : String(value);
   }
   return /** @type {import('./index.js').CoverOptions} */ (out);
@@ -94,8 +100,8 @@ function optionsFrom(named) {
  * Read a list of books into cover options, one per book (rows without a title are left out):
  *
  * - CSV or TSV whose first row names its columns (`title`, `author`, `subtitle`, `series`,
- *   `credit`, `badge`, `style`, `palette`, `seed`, `font`, `case`, `lang`, `width`, `height`,
- *   `texture`; others are ignored);
+ *   `credit`, `badge`, `style`, `genre`, `palette`, `seed`, `font`, `case`, `lang`, `width`,
+ *   `height`, `texture`; others are ignored);
  * - JSON lines, one object per book, with the same names;
  * - else one book per line: "Title | Author | Subtitle" (a tab, or " — " or " – ", also separates).
  *
@@ -134,7 +140,8 @@ export function parseBookList(text) {
       books = rows.map((row) => optionsFrom(Object.fromEntries(names.map((name, i) => [name, row[i] ?? '']))));
     } else {
       books = lines.map(({ line }) => {
-        const [title, author, subtitle] = line.split(LINE_SEPARATOR);
+        const separator = LINE_SEPARATORS.find((sep) => line.includes(sep));
+        const [title, author, subtitle] = separator ? line.split(separator) : [line];
         return optionsFrom({ title, author, subtitle });
       });
     }

package/src/element.d.ts

@@ -0,0 +1,21 @@
+import type { CoverOptions, createCover } from './index.js';
+
+/**
+ * `<book-cover>`: a cover on any page, from its attributes (cover-title, author, subtitle, series,
+ * credit, badge, cover-style, genre, palette, seed, format, font, case, texture, variant, lang). It
+ * fires `cover` (detail: the cover) when it draws, and `cover-error` (detail: the error) when the
+ * attributes can't make one.
+ */
+export declare class BookCover extends HTMLElement {
+  static observedAttributes: string[];
+  /** The cover drawn last, or null (before the first, or after an error). */
+  cover: ReturnType<typeof createCover> | null;
+  /** The cover's options, read from the attributes as the HTTP API reads a link. */
+  options(): CoverOptions;
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    'book-cover': BookCover;
+  }
+}