# A peek-a-boo board book with holes in register

> Four die-cut holes, placed with dieCuts where the next painting's telling part lies, a window that steps down to a smaller hole, rounded corners and a die line.

- HTML version: https://postext.dev/en/cookbook/peek-a-boo-board-book
- Recipe Nº 193 · Output & integration · Level 2 (Intermediate) · Outputs: Canvas, PDF, Live controls
- Genres: Single sheets & ephemera
- Requires postext ≥ 1.84.0, postext-pdf ≥ 1.84.0 · tested with 1.84.0, postext-pdf 1.84.0 on 2026-11-13
- Pages: [1](https://postext.dev/cookbook/peek-a-boo-board-book/en/p01.webp?v=de6bd325), [2](https://postext.dev/cookbook/peek-a-boo-board-book/en/p02.webp?v=de6bd325), [3](https://postext.dev/cookbook/peek-a-boo-board-book/en/p03.webp?v=de6bd325), [4](https://postext.dev/cookbook/peek-a-boo-board-book/en/p04.webp?v=de6bd325), [5](https://postext.dev/cookbook/peek-a-boo-board-book/en/p05.webp?v=de6bd325), [6](https://postext.dev/cookbook/peek-a-boo-board-book/en/p06.webp?v=de6bd325), [7](https://postext.dev/cookbook/peek-a-boo-board-book/en/p07.webp?v=de6bd325), [12](https://postext.dev/cookbook/peek-a-boo-board-book/en/p12.webp?v=de6bd325), [13](https://postext.dev/cookbook/peek-a-boo-board-book/en/p13.webp?v=de6bd325), [14](https://postext.dev/cookbook/peek-a-boo-board-book/en/p14.webp?v=de6bd325)
- PDF: https://postext.dev/cookbook/peek-a-boo-board-book/en/peek-a-boo-board-book.pdf?v=de6bd325
- Open in Sandbox: https://postext.dev/en/sandbox#recipe=peek-a-boo-board-book&lang=en (.postext: https://postext.dev/cookbook/peek-a-boo-board-book/en/peek-a-boo-board-book.postext)
- Last updated: 2026-11-13
- Other languages: [es](https://postext.dev/es/cookbook/peek-a-boo-board-book.md), [ca](https://postext.dev/ca/cookbook/peek-a-boo-board-book.md), [de](https://postext.dev/de/cookbook/peek-a-boo-board-book.md), [fr](https://postext.dev/fr/cookbook/peek-a-boo-board-book.md), [it](https://postext.dev/it/cookbook/peek-a-boo-board-book.md), [pt](https://postext.dev/pt/cookbook/peek-a-boo-board-book.md), [zh](https://postext.dev/zh/cookbook/peek-a-boo-board-book.md), [ja](https://postext.dev/ja/cookbook/peek-a-boo-board-book.md), [ar](https://postext.dev/ar/cookbook/peek-a-boo-board-book.md)

## In short

A cardboard picture book for toddlers. Each hole in a page shows a small piece of the next picture, the words make a guess, and turning the page shows what it really is.

## What you'll build

*Peek-a-boo! Who’s in the Garden?*, a fourteen-page board book on a 160 mm square, its corners rounded on all four sides. Each painting has a hole, and the hole is cut exactly where the next painting keeps the part that fools the eye: the striped flank of a sleeping cat that could be a tiger, a sheep's wool that could be a cloud, a lantern that could be the moon. The cover's window is wider than the hole behind it, so the first look goes two pages deep. The words on the left make the guess; the turn of the page answers it. The press file carries the die line on a plate of its own.

**This recipe answers:**

- How do I cut holes through a book’s pages, each showing part of the next picture?
- How do I send the die-maker a die line on its own plate in the PDF?

## The short answer

The dies, and the pages they cut.

```js
// script.js, lines 43–61
// Each painting is cut where the next one's telling part lies: the cat's striped flank, the
// sheep's wool, the lantern's glow. The cover's window is wider than the hedge's hole and
// holds it, so from the cover you see the hedge, and through the hedge the cat. A hole cuts
// both sides of its leaf, mirrored on the verso, and the words there run round it.
const circle = (id, name, cx, cy, d) => ({ id, name, shape: 'circle', x: mm(cx - d / 2),
  y: mm(cy - d / 2), width: mm(d), height: mm(d), wrap: { gap: mm(4) } });
const dieCuts = {
  shapes: [
    circle('window', t({ en: 'Cover window', es: 'Ventana de la cubierta' }), 112, 68, 60),
    circle('hedge', t({ en: 'Gap in the hedge', es: 'Hueco del seto' }), 112, 60, 36),
    { id: 'knot', name: t({ en: 'Knothole', es: 'Nudo de la valla' }), shape: 'ellipse',
      x: mm(102), y: mm(48), width: mm(32), height: mm(40), wrap: { gap: mm(4) } },
    circle('peephole', t({ en: 'Barn-door peephole', es: 'Mirilla del granero' }), 91, 29, 20),
  ],
  // By position in the book: page 1 is the cover, 3 the hedge, 7 the fence, 11 the door.
  pages: [{ pages: '1', die: 'window' }, { pages: '3', die: 'hedge' },
    { pages: '7', die: 'knot' }, { pages: '11', die: 'peephole' }],
  corners: { radius: mm(9), edges: 'all' }, // board books are rounded on all four corners
};
```

## Ingredients

**Teaches**

- [Die-cut holes](https://postext.dev/en/docs/special-inks-die-cuts.md#die-cuts): dieCuts.shapes and dieCuts.pages (or a :::diecut container) cut a hole through a page and its leaf; the text on both sides runs round it.
- [Rounded corners and shaped books](https://postext.dev/en/docs/special-inks-die-cuts.md#rounded-corners-and-shaped-books): dieCuts.corners rounds the corners of every leaf (the fore-edge ones or all four), and dieCuts.outline cuts every leaf to a shape.
- [Die line in the PDF](https://postext.dev/en/docs/special-inks-die-cuts.md#the-die-line-in-the-pdf): print.dieLine strokes every hole and shaped edge on a Separation plate of its own that overprints and is never inked, for the die-maker.

**Also uses**

- [Holes through several leaves](https://postext.dev/en/docs/special-inks-die-cuts.md#leaves-and-mirroring)
- [3D book viewer (Folio)](https://postext.dev/en/docs/configuration-html-folio-epub.md#a-3d-book-postext-folio)
- [Heading styles](https://postext.dev/en/docs/configuration-styles.md#heading-styles)
- [Pictures in page designs](https://postext.dev/en/docs/configuration-headers-footers.md#image-elements)
- [Heading attributes](https://postext.dev/en/docs/document-format.md#heading-attributes)
- [Paragraph styles](https://postext.dev/en/docs/configuration-styles.md#paragraph-styles)
- [Bleed and crop marks](https://postext.dev/en/docs/configuration-page-layout.md#cut-lines)
- [CMYK and grayscale PDFs](https://postext.dev/en/docs/configuration-fonts-colors-viewers.md#pdf-generation-config)
- [PDF export](https://postext.dev/en/docs/configuration-pdf-output.md#generating-pdfs)
- [Figures and tables as resources](https://postext.dev/en/docs/document-format-resources.md#resources)
- [Semantic colour palette](https://postext.dev/en/docs/configuration-fonts-colors-viewers.md#color-palette)
- [Pages on a canvas](https://postext.dev/en/docs/configuration-programmatic-usage.md#rendering-a-page-to-a-bitmap)
- [Paper, binding, desk and light (Folio)](https://postext.dev/en/docs/configuration-fonts-colors-viewers.md#folio-viewer-config)
- [Designed openers](https://postext.dev/en/docs/configuration-headings.md#span-and-advanced-design)
- [Paper colour](https://postext.dev/en/docs/configuration-page-layout.md#page)
- [Colours per part](https://postext.dev/en/docs/configuration-styles.md#the-part-container)
- [Fonts embedded in the PDF](https://postext.dev/en/docs/configuration-pdf-output.md#why-a-font-provider)
- [Section geometry](https://postext.dev/en/docs/configuration-styles.md#heading-styles)
- [Unnumbered chapters](https://postext.dev/en/docs/configuration-styles.md#heading-styles)

**Config at a glance**

- [`bodyText`](https://postext.dev/en/docs/configuration-text.md#body-text), [`colorPalette`](https://postext.dev/en/docs/configuration-fonts-colors-viewers.md#color-palette), [`dieCuts`](https://postext.dev/en/docs/special-inks-die-cuts.md#die-cuts), [`folio`](https://postext.dev/en/docs/configuration-html-folio-epub.md#appearance), [`footer`](https://postext.dev/en/docs/configuration-headers-footers.md#headers--footers), [`header`](https://postext.dev/en/docs/configuration-headers-footers.md#headers--footers), [`headingStyles`](https://postext.dev/en/docs/configuration-styles.md#heading-styles), [`headings`](https://postext.dev/en/docs/configuration-headings.md#headings), [`layout`](https://postext.dev/en/docs/configuration-page-layout.md#layout), [`locale`](https://postext.dev/en/docs/configuration-language.md#hyphenation), [`page`](https://postext.dev/en/docs/configuration-page-layout.md#page), [`paragraphStyles`](https://postext.dev/en/docs/configuration-styles.md#paragraph-styles), [`print`](https://postext.dev/en/docs/configuration-fonts-colors-viewers.md#print-production-config)

**APIs**

- [`buildDocumentWithFonts`](https://postext.dev/en/docs/configuration-programmatic-usage.md#loading-fonts-before-layout), [`createFolioFromDocument`](https://postext.dev/en/docs/configuration-html-folio-epub.md#a-3d-book-postext-folio), [`decompressWoff2`](https://postext.dev/en/docs/configuration-pdf-output.md#browser-font-provider-fontsource--woff2), [`registerResourceImage`](https://postext.dev/en/docs/architecture.md#api-surface), [`renderPageToCanvas`](https://postext.dev/en/docs/configuration-programmatic-usage.md#rendering-a-page-to-a-bitmap), [`renderToPdf`](https://postext.dev/en/docs/configuration-pdf-output.md#generating-pdfs)

**Typefaces**

- Andika (OFL-1.1), Fredoka (OFL-1.1), Nunito (OFL-1.1)

## Method

### 1 · Holes where the next picture tells

The code is [the short answer](https://postext.dev/en/cookbook/peek-a-boo-board-book.md#the-short-answer) above. Each shape is placed from the trim's top-left corner and `dieCuts.pages` names the page it cuts, counted from the book's first page. Measure the hole on the painting it reveals, not on the page it is cut in: the hedge, the fence and the door are textures that take a hole anywhere, the cat and the lantern are not.

### 2 · Paintings in register with the holes

```js
// script.js, lines 65–84
// Each painting hangs from the trim and runs BLEED past it on every side, so the holes hit it
// in the same place on screen and in print. A picture's section drops the foot margin, so its
// design reaches the foot of the page; the words on the verso behind it, in the same section,
// start TOP down.
const SHEET = { width: mm(TRIM + 2 * BLEED), height: mm(TRIM + 2 * BLEED) }; // trim + bleed
const painting = { kind: 'image', id: 'painting', resourceId: '{attr.picture}', fit: 'cover',
  placement: at('page', 'top-left', -BLEED, -BLEED, SHEET) };
const full = (elements) => ({ enabled: true, minHeight: mm(TRIM - TOP), slot: { elements } });
const flush = { margins: { top: mm(TOP), bottom: mm(0), left: mm(INNER), right: mm(OUTER) } };
const title = { kind: 'text', id: 'title', content: '{titleText}', fontFamily: DISPLAY,
  fontWeight: 600, fontSize: pt(40), lineHeight: 1, color: col('accent'), align: 'left',
  placement: at('page', 'top-left', 62, 8, { width: mm(88) }) };
const headingStyles = [
  { id: 'cover', numbered: false, toc: false, ...flush, advancedDesign: full([painting, title]) },
  { id: 'picture', numbered: false, ...flush, breakBefore: { enabled: true, parity: 'odd' },
    advancedDesign: full([painting]) },
  // The back cover: the board printed dusk blue (the section's palette), the type in cream.
  { id: 'back', numbered: false, toc: false, breakBefore: { enabled: true, parity: 'even' },
    color: col('cream'), palette: { paper: palette.dusk } },
];
```

The holes are in trim millimetres, so every painting hangs from the trim and runs the bleed past it on every side, on screen and in print alike. The picture style drops only the foot margin: its design reaches the foot of the page, and the words on the verso behind it keep their 44 mm top margin, which lowers them under the top of the small holes.

### 3 · The die line on its own plate

```js
// script.js, lines 96–99
  // The die line is stroked on a Separation plate of its own ('Die'), overprinting, that the
  // press never inks. PDF/X-4 on coated stock: the board is printed on coated paper.
  print: { standard: 'pdfx4', outputProfile: 'fogra51', convertImages: false,
    dieLine: { output: 'page', ink: 'Die', width: pt(0.5) } },
```

The PDF prints each page whole and strokes the outline of every hole, and of each rounded leaf, on a `Die` separation that overprints and is never inked. `convertImages: false` keeps the paintings as RGB JPEGs tagged sRGB, which PDF/X-4 allows, so the file stays small.

### 4 · The book in the hand

```js
// script.js, lines 122–128
  folio: {
    tilt: 50, yaw: -32,
    paper: { type: 'board', shade: '#fbf5e8' },
    binding: { type: 'hardcover', cover: 'pages', coverMaterial: 'paper' },
    surface: { type: 'oak' },
    lighting: { environment: 'daylight', intensity: 1.05 },
  },
```

Folio cuts the holes through each leaf and shows the pages beneath with the walls of the cut, so the stepped window reads as depth. Board stock turns stiff, and the rounded corners are cut on every leaf.

### 5 · Flat pages that look through

```js
// script.js, lines 242–252
// renderPageToCanvas cuts the holes; `beneath` hands it the pages under them, painted here
// at a lower scale (the composite stretches them to the page), each with its own holes.
const under = new Map();
const beneath = (i) => {
  if (!under.has(i) && doc.pages[i]) {
    const canvas = document.createElement('canvas');
    under.set(i, canvas);
    renderPageToCanvas(doc.pages[i], doc, canvas, { scale: 1, beneath });
  }
  return under.get(i);
};
```

On the canvas a hole shows what is behind the canvas unless the renderer gets the pages beneath. `beneath` returns them by index, each painted with its own holes, so the cover shows the hedge and, through the hedge, the cat.

## The whole recipe

One file, composed from the recipe's folder with the sample text and the Cookbook's shared kit inlined; it builds its own page. To run it, put it in a `<script type="module">` on an empty page, or paste it into the JS panel of a new CodePen (as a module). It imports postext from esm.sh, so there is nothing to install or build.

- Source folder: https://github.com/drnachio/postext/tree/main/cookbook/peek-a-boo-board-book

### script.js

```js
// ═══ Postext Cookbook · Nº 193 · A peek-a-boo board book with holes in register ════════
// https://postext.dev/en/cookbook/peek-a-boo-board-book
// Code: MIT · Text: original (CC BY 4.0) · Paintings: generated with diffusion models
// Fonts: Andika, Fredoka, Nunito (SIL OFL 1.1) · Needs postext ≥ 1.84.0
//
// A fourteen-page board book for toddlers: on every other recto a hole is cut through the
// painting, and what shows through it is a scrap of the next picture. The words on the left
// make a guess from the scrap; the turned page shows what it really is. The leaves have
// rounded corners, the holes step down from the cover, and the PDF carries the die line.
import {
  buildDocumentWithFonts, renderPageToCanvas, registerResourceImage,
} from 'https://esm.sh/postext';
import { renderToPdf, decompressWoff2 } from 'https://esm.sh/postext-pdf';
import { createFolioFromDocument } from 'https://esm.sh/postext-folio';

const LANG = 'en'; // @lang: the language of the sample document ('en' | 'es')
const RECIPE = 'peek-a-boo-board-book';

// ─── 1 · Design ─────────────────────────────────────────────────────────────
// #region palette: a cream board, a robin red for the title and the guesses, a dusk blue
const palette = {
  ink: '#2a2420', // text: a warm near-black
  accent: '#b8432c', // the cover title and the guesses: the robin's breast
  paper: '#fbf5e8', // the board the words are printed on
  dusk: '#253a63', // the back cover, the blue of the last painting's sky
  cream: '#fff9ec', // type on the cover and the back
  muted: '#7a6f64', // the colophon
};
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
const colorPalette = [
  ...Object.entries(palette).map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } })),
  { id: 'main-color', name: 'accent (defaults)', value: { hex: palette.accent, model: 'hex' } },
];
// #endregion
const [TRIM, BLEED] = [160, 3]; // mm: a square board book, and its bleed
const [TOP, FOOT, INNER, OUTER] = [44, 16, 18, 16]; // the words sit low, under the holes' tops
const [TEXT, DISPLAY, LABEL] = ['Andika', 'Fredoka', 'Nunito'];
const LEAD = 31; // pt: 24 pt type on a generous leading, for reading aloud
const at = (to, edge, x = 0, y = 0, size) => ({ anchor: { to, edge },
  offset: { x: mm(x), y: mm(y) }, ...(size && { size }) });

// #region answer: the dies, and the pages they cut
// Each painting is cut where the next one's telling part lies: the cat's striped flank, the
// sheep's wool, the lantern's glow. The cover's window is wider than the hedge's hole and
// holds it, so from the cover you see the hedge, and through the hedge the cat. A hole cuts
// both sides of its leaf, mirrored on the verso, and the words there run round it.
const circle = (id, name, cx, cy, d) => ({ id, name, shape: 'circle', x: mm(cx - d / 2),
  y: mm(cy - d / 2), width: mm(d), height: mm(d), wrap: { gap: mm(4) } });
const dieCuts = {
  shapes: [
    circle('window', t({ en: 'Cover window', es: 'Ventana de la cubierta' }), 112, 68, 60),
    circle('hedge', t({ en: 'Gap in the hedge', es: 'Hueco del seto' }), 112, 60, 36),
    { id: 'knot', name: t({ en: 'Knothole', es: 'Nudo de la valla' }), shape: 'ellipse',
      x: mm(102), y: mm(48), width: mm(32), height: mm(40), wrap: { gap: mm(4) } },
    circle('peephole', t({ en: 'Barn-door peephole', es: 'Mirilla del granero' }), 91, 29, 20),
  ],
  // By position in the book: page 1 is the cover, 3 the hedge, 7 the fence, 11 the door.
  pages: [{ pages: '1', die: 'window' }, { pages: '3', die: 'hedge' },
    { pages: '7', die: 'knot' }, { pages: '11', die: 'peephole' }],
  corners: { radius: mm(9), edges: 'all' }, // board books are rounded on all four corners
};
// #endregion

// #region pictures: a painting to the bleed, the page's heading naming it
// Each painting hangs from the trim and runs BLEED past it on every side, so the holes hit it
// in the same place on screen and in print. A picture's section drops the foot margin, so its
// design reaches the foot of the page; the words on the verso behind it, in the same section,
// start TOP down.
const SHEET = { width: mm(TRIM + 2 * BLEED), height: mm(TRIM + 2 * BLEED) }; // trim + bleed
const painting = { kind: 'image', id: 'painting', resourceId: '{attr.picture}', fit: 'cover',
  placement: at('page', 'top-left', -BLEED, -BLEED, SHEET) };
const full = (elements) => ({ enabled: true, minHeight: mm(TRIM - TOP), slot: { elements } });
const flush = { margins: { top: mm(TOP), bottom: mm(0), left: mm(INNER), right: mm(OUTER) } };
const title = { kind: 'text', id: 'title', content: '{titleText}', fontFamily: DISPLAY,
  fontWeight: 600, fontSize: pt(40), lineHeight: 1, color: col('accent'), align: 'left',
  placement: at('page', 'top-left', 62, 8, { width: mm(88) }) };
const headingStyles = [
  { id: 'cover', numbered: false, toc: false, ...flush, advancedDesign: full([painting, title]) },
  { id: 'picture', numbered: false, ...flush, breakBefore: { enabled: true, parity: 'odd' },
    advancedDesign: full([painting]) },
  // The back cover: the board printed dusk blue (the section's palette), the type in cream.
  { id: 'back', numbered: false, toc: false, breakBefore: { enabled: true, parity: 'even' },
    color: col('cream'), palette: { paper: palette.dusk } },
];
// #endregion

const config = {
  locale: t({ en: 'en-gb', es: 'es' }),
  colorPalette,
  page: { sizePreset: 'custom', width: mm(TRIM), height: mm(TRIM), dpi: 150,
    backgroundColor: col('paper'), cutLines: { enabled: false, bleed: mm(BLEED) },
    margins: { top: mm(TOP), bottom: mm(FOOT), left: mm(INNER), right: mm(OUTER), mirror: true } },
  layout: { layoutType: 'single' },
  dieCuts,
  // #region die-line: the die-maker's plate, and the press file around it
  // The die line is stroked on a Separation plate of its own ('Die'), overprinting, that the
  // press never inks. PDF/X-4 on coated stock: the board is printed on coated paper.
  print: { standard: 'pdfx4', outputProfile: 'fogra51', convertImages: false,
    dieLine: { output: 'page', ink: 'Die', width: pt(0.5) } },
  // #endregion
  bodyText: { fontFamily: TEXT, fontSize: pt(24), lineHeight: pt(LEAD), color: col('ink'),
    boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
    textAlign: 'left', firstLineIndent: pt(0), paragraphSpacing: pt(8),
    hyphenation: { enabled: false }, // a word read aloud is never broken
    optimalLineBreaking: true, avoidWidows: true, avoidOrphans: true, avoidRunts: true },
  headings: { fontFamily: DISPLAY, color: col('ink'), fontWeight: 600, levels: [
    { level: 1, fontSize: pt(30), lineHeight: pt(34), breakBefore: { enabled: true,
      parity: 'odd' }, marginTop: pt(0), marginBottom: pt(12) },
  ] },
  headingStyles,
  paragraphStyles: [
    // The guess, and the answer to it: the line a child shouts.
    { id: 'shout', fontFamily: DISPLAY, fontWeight: 600, fontSize: pt(32), lineHeight: pt(36),
      color: col('accent'), textAlign: 'left', firstLineIndent: pt(0), marginTop: pt(6),
      marginBottom: pt(6) },
    { id: 'colophon', fontFamily: LABEL, fontSize: pt(9), lineHeight: pt(12.5),
      color: col('cream'), textAlign: 'left', firstLineIndent: pt(0), marginTop: pt(8) },
  ],
  header: { elements: [] }, // a board book prints no running heads
  footer: { elements: [] }, // and no folios
  // #region folio: grey board, rounded leaves, seen low so the holes show their depth
  folio: {
    tilt: 50, yaw: -32,
    paper: { type: 'board', shade: '#fbf5e8' },
    binding: { type: 'hardcover', cover: 'pages', coverMaterial: 'paper' },
    surface: { type: 'oak' },
    lighting: { environment: 'daylight', intensity: 1.05 },
  },
  // #endregion
};

// ─── 2 · Content ────────────────────────────────────────────────────────────
// # The hedge {style="picture" picture="hedge"} names a painting; the words after it fill the
// verso behind that picture, the guess on the left of the hole that answers it.
const markdown = String.raw`---
title: "Peek-a-boo! Who’s in the Garden?"
---

# Peek-a-boo! {style="cover" picture="cover"}

What’s behind the hedge? Peep through the hole. Something orange and stripy is fast asleep in there.

:::paragraphs{style="shout"}
Is it a tiger?
:::

# The hedge {style="picture" picture="hedge"}

:::paragraphs{style="shout"}
No, it isn’t a tiger!
:::

It’s Marmalade the cat, snoozing in the sun.

# Marmalade the cat {style="picture" picture="cat"}

What’s behind the fence? Something white and woolly is standing there.

:::paragraphs{style="shout"}
Is it a cloud?
:::

# The fence {style="picture" picture="fence"}

:::paragraphs{style="shout"}
No, it isn’t a cloud!
:::

It’s Dolly the sheep, munching the long grass.

# Dolly the sheep {style="picture" picture="sheep"}

What’s behind the barn door? The sun has gone down. Something round and yellow is shining in there.

:::paragraphs{style="shout"}
Is it the moon?
:::

# The barn door {style="picture" picture="door"}

:::paragraphs{style="shout"}
No, it isn’t the moon!
:::

It’s Grandpa’s lantern. Time for bed. Goodnight, garden!

# Grandpa’s lantern {style="picture" picture="lantern"}

# Goodnight {style="back"}

:::paragraphs{style="colophon"}
A board book with four die-cut holes and rounded corners. Set in Andika, Fredoka and Nunito (SIL Open Font License). Words written for the Postext Cookbook, CC BY 4.0. Paintings generated with diffusion models.
:::
`; // content.<lang>.md, inlined by the Cookbook

const PICTURES = {
  cover: t({ en: 'A cottage garden: a tall hedge under a blue sky, hollyhocks and a robin.',
    es: 'Un jardín: un seto alto bajo el cielo azul, malvarrosas y un petirrojo.' }),
  hedge: t({ en: 'A green hedge of small leaves with white flowers and a ladybird.',
    es: 'Un seto verde de hojas pequeñas con flores blancas y una mariquita.' }),
  cat: t({ en: 'A ginger tabby cat asleep, curled up on the lawn among daisies.',
    es: 'Un gato atigrado pelirrojo dormido, hecho un ovillo en el césped entre margaritas.' }),
  fence: t({ en: 'A weathered wooden fence, buttercups growing at its foot.',
    es: 'Una valla de madera vieja, con botones de oro al pie.' }),
  sheep: t({ en: 'A woolly white sheep with a black face, standing in the meadow.',
    es: 'Una oveja blanca y lanuda de cara negra, de pie en el prado.' }),
  door: t({ en: 'The red plank door of a barn, with black iron hinges.',
    es: 'La puerta roja de tablas de un granero, con bisagras de hierro negro.' }),
  lantern: t({ en: 'Grandpa walks down the garden path at dusk, holding up a glowing lantern.',
    es: 'El abuelo baja por el jardín al anochecer con un farolillo encendido en alto.' }),
};
const resources = Object.entries(PICTURES).map(([id, alt]) => ({ id, typeId: 'figure', kind: 'bitmap',
  createdAt: 0, updatedAt: 0, altText: alt,
  bitmap: { fileId: `${id}.jpg`, format: 'jpeg', width: 900, height: 900 } }));
const FILES = { cover: asset('cover.jpg'), hedge: asset('hedge.jpg'), cat: asset('cat.jpg'),
  fence: asset('fence.jpg'), sheep: asset('sheep.jpg'), door: asset('door.jpg'),
  lantern: asset('lantern.jpg') };

// ─── 3 · Fonts ──────────────────────────────────────────────────────────────
const FONTS = { Andika: ['400', '700'], Fredoka: ['600'], Nunito: ['400', '700'] };

// ─── 4 · Build & show ───────────────────────────────────────────────────────
await Promise.all(Object.entries(FILES).map(([id, url]) => loadImage(`${id}.jpg`, url)));
// The press file is built first, with bleed and crop marks; the screen shows the trimmed
// pages, built last, with the corners and holes cut out against the desk.
const cut = { ...config.page.cutLines, enabled: true };
const pressConfig = { ...config, page: { ...config.page, cutLines: cut } };
const press = await buildDocumentWithFonts({ markdown, resources }, pressConfig, kitFonts(FONTS));
const doc = await buildDocumentWithFonts({ markdown, resources }, config, kitFonts(FONTS));

// #region folio-stage: the book closed on the desk, the cover's window first
const stage = document.createElement('section');
stage.id = 'folio';
stage.ariaLabel = t({ en: 'The board book in 3D', es: 'El libro de cartón en 3D' });
stage.style.cssText = 'height: min(78vh, 720px); margin: 0 auto; max-width: 1280px';
document.body.append(stage);
createFolioFromDocument(stage, doc, { at: 0,
  appearance: { textureBaseUrl: 'https://postext.dev/folio/textures' } });
// #endregion

// #region see-through: the flat pages show what lies beneath their holes
// renderPageToCanvas cuts the holes; `beneath` hands it the pages under them, painted here
// at a lower scale (the composite stretches them to the page), each with its own holes.
const under = new Map();
const beneath = (i) => {
  if (!under.has(i) && doc.pages[i]) {
    const canvas = document.createElement('canvas');
    under.set(i, canvas);
    renderPageToCanvas(doc.pages[i], doc, canvas, { scale: 1, beneath });
  }
  return under.get(i);
};
// #endregion
showPages(doc, { title: t({ en: 'Peek-a-boo! · a board book with holes',
  es: '¡Cucú! · un libro de cartón con agujeros' }), beneath });
document.getElementById('pages').before(stage);
offerPdf(() => renderToPdf(press, { fontProvider: fontsourceProvider, resourceBytes: imageBytes,
  profileBaseUrl: 'https://postext.dev/icc/' }), `${RECIPE}.pdf`);

// ─── Kit ── helpers shared by every Cookbook recipe · postext.dev/cookbook ─────

// ─── Kit · core v1 ── the same in every recipe · postext.dev/cookbook
function mm(value) { return { value, unit: 'mm' }; }
function pt(value) { return { value, unit: 'pt' }; }
function em(value) { return { value, unit: 'em' }; }
/** The sample language's string: t({ en: 'Figure', es: 'Figura' }). */
function t(strings) { return strings[LANG] ?? Object.values(strings)[0]; }
/** A file in this recipe's assets folder, served from the Postext repo by jsDelivr. */
function asset(file) { return `https://cdn.jsdelivr.net/gh/drnachio/postext@main/cookbook/${RECIPE}/assets/${file}`; }

// ─── Kit · fonts v3 ── the same in every recipe · postext.dev/cookbook
// Postext loads the faces a config asks for before layout and asks the kit
// for Fontsource's files, the ones the PDF embeds too.

/** buildDocumentWithFonts' options: the resolver, and FONTS' faces loaded
 *  with the config's. FONTS = { 'Family Name': ['400', '400i', '700'] }. */
function kitFonts(FONTS = {}) {
  const faces = Object.entries(FONTS).flatMap(([family, specs]) => specs.map((spec) =>
    ({ family, weight: parseInt(spec, 10), style: spec.endsWith('i') ? 'italic' : 'normal' })));
  return { resolve: fontsourceResolver, faces };
}

/** A face's files with their ranges: latin, then latin-ext and greek when
 *  `text` needs them (kitSubsetsFor). Null for a face Fontsource lacks. */
async function fontsourceResolver(family, weight, style, { text = '' } = {}) {
  const id = fontsourceId(family);
  const meta = await fontsourceMeta(family);
  if (meta && !(await fontsourceWeights(family, style)).includes(weight)) return null;
  kitStatus('Loading fonts…');
  const at = await fontsourceAt(id);
  return ['latin', ...kitSubsetsFor(text, meta)].map((subset) => ({
    source: `${at}files/${id}-${subset}-${weight}-${style}.woff2`,
    unicodeRange: kitRanges()[subset],
  }));
}

/** Each file's unicode-range (a function: the kit runs after the pen's code). */
function kitRanges() {
  return {
    latin: 'U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,'
      + 'U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD',
    'latin-ext': 'U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+0304,U+0308,U+0329,'
      + 'U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF',
    greek: 'U+0370-03FF',
  };
}

/** For the cjk, arabic and comics blocks: loads `faces` (as FONTS) for the
 *  sample `text`; `optional` skips a face Fontsource lacks. Files are added in
 *  the order asked, the last winning a shared character. Resolves to the count. */
async function loadFonts(faces, text = '', { optional = false } = {}) {
  kitStatus('Loading fonts…');
  const ranges = kitRanges();
  const jobs = [];
  for (const [family, specs] of Object.entries(faces)) {
    const id = fontsourceId(family);
    const todo = [...new Set(specs)].map((spec) => [parseInt(spec, 10), spec.endsWith('i') ? 'italic' : 'normal'])
      .filter(([weight, style]) => !hasFace(family, weight, style)); // before any await
    const at = fontsourceAt(id);
    const meta = optional || /[^\0-ÿ]/u.test(text) ? await fontsourceMeta(family) : null;
    const subsets = ['latin', ...kitSubsetsFor(text, meta)];
    for (const [weight, style] of todo) {
      if (optional && !(meta && (await fontsourceWeights(family, style)).includes(weight))) continue;
      for (const subset of subsets) {
        const url = `${await at}files/${id}-${subset}-${weight}-${style}.woff2`;
        const face = new FontFace(family, `url(${url}) format('woff2')`,
          { weight: String(weight), style, unicodeRange: ranges[subset] });
        jobs.push(face.load().catch(() => {
          if (subset === 'latin' && !optional) throw new Error(`Fontsource has no ${family} ${weight} ${style}`);
        }));
      }
    }
  }
  const ready = await Promise.all(jobs).catch((error) => { kitFail(error); throw error; });
  return ready.filter((face) => face && document.fonts.add(face)).length;
}

/** A loaded FontFace covers this face (fonts.check() says yes to any family). */
function hasFace(family, weight, style) {
  for (const face of document.fonts) {
    if (face.status !== 'loaded' || face.style !== style) continue;
    if (face.family.replace(/^["']|["']$/g, '') !== family) continue;
    const [low, high = low] = face.weight.split(' ').map(Number);
    if (weight >= low && weight <= high) return true;
  }
  return false;
}

/** The files beyond latin `text` needs that `meta`'s family ships. */
function kitSubsetsFor(text, meta) {
  return [[/[Ā-˿ᴀ-ᶿḀ-ỿ†ℓⱠ-Ɀ꜠-ꟿ]/u, 'latin-ext'], [/[Ͱ-Ͽ]/u, 'greek']]
    .filter(([re, x]) => re.test(text) && meta?.subsets?.includes(x)).map(([, x]) => x);
}

/** Fontsource's id for a family: 'Source Serif 4' → 'source-serif-4'. */
function fontsourceId(family) { return family.toLowerCase().replace(/\s+/g, '-'); }

/** A package's folder at the one version @5 names now (#766). */
function fontsourceAt(id, u = `https://cdn.jsdelivr.net/npm/@fontsource/${id}@`) {
  return (fontsourceAt.c ??= {})[id] ??= fetch(u + '5/package.json').then((r) => r.json())
    .then((p) => p.version || 5, () => 5).then((v) => `${u}${v}/`);
}

/** The family's Fontsource metadata (weights, styles, subsets), or null. */
function fontsourceMeta(family, id = fontsourceId(family)) {
  return (fontsourceMeta.c ??= {})[id] ??= fetch(`https://api.fontsource.org/v1/fonts/${id}`)
    .then((res) => (res.ok ? res.json() : null), () => null);
}

/** The weights the package ships in `style`: the API pairs none (no Libre
 *  Caslon 700 italic file), so italics are read from latin-italic.css. */
function fontsourceWeights(family, style, id = fontsourceId(family)) {
  return (fontsourceWeights.c ??= {})[id + style] ??= fontsourceMeta(family).then(async (m) => {
    if (!m?.styles.includes(style)) return m ? [] : [400, 700];
    const css = style === 'italic' ? await fetch(`${await fontsourceAt(id)}latin-italic.css`).then((r) => (r.ok ? r.text() : ''), () => '') : '';
    const w = [...css.matchAll(/weight: (\d+)/g)].map((x) => +x[1]);
    return w.length ? w : m.weights;
  });
}

// ─── Kit · viewer v2 ── the same in every recipe · postext.dev/cookbook
/** The pages as spreads on a dark desk, page 1 alone, then verso | recto,
 *  each painted when it scrolls near. Other options go to renderPageToCanvas. */
function showPages(docs, { title, width = 460, ...render } = {}) {
  const root = viewer(title);
  const pages = [docs].flat().flatMap((doc) =>
    doc.pages.map((page) => ({ doc, page, n: (doc.pageIndexOffset ?? 0) + page.index })));
  const spreads = [];
  let verso = null;
  for (const p of pages) {
    if (p.n % 2 === 1) { if (verso) spreads.push([verso, null]); verso = p; }
    else { spreads.push([verso, p]); verso = null; }
  }
  if (verso) spreads.push([verso, null]);
  const density = Math.min(window.devicePixelRatio || 1, 2);
  showPages.painter?.disconnect();
  const painter = new IntersectionObserver((entries) => {
    for (const { isIntersecting, target } of entries) {
      if (!isIntersecting) continue;
      painter.unobserve(target);
      const { doc, page } = target.postext;
      renderPageToCanvas(page, doc, target, { ...render, scale: (width * density) / page.width });
    }
  }, { rootMargin: '800px' });
  showPages.painter = painter;
  root.replaceChildren(...spreads.map((pair) => {
    const spread = document.createElement('div');
    spread.className = 'pt-spread';
    for (const p of pair) {
      const figure = document.createElement('figure');
      if (p) {
        const label = p.page.pageLabel || String(p.n + 1);
        const canvas = document.createElement('canvas');
        canvas.postext = p;
        canvas.style.aspectRatio = `${p.page.width} / ${p.page.height}`;
        canvas.setAttribute('role', 'img');
        canvas.setAttribute('aria-label', `Page ${label}`);
        const folio = document.createElement('figcaption');
        folio.textContent = label;
        figure.append(canvas, folio);
        painter.observe(canvas);
      } else figure.className = 'pt-blank';
      spread.append(figure);
    }
    return spread;
  }));
  kitStatus(`${pages.length} ${pages.length === 1 ? 'page' : 'pages'}`);
  document.documentElement.dataset.postext = 'ready';
  return pages.length;
}

/** The desk, the bar and the error reporting, created once. */
function viewer(title) {
  if (!document.getElementById('pt-kit')) {
    document.head.insertAdjacentHTML('beforeend', `<style id="pt-kit">
      :root { color-scheme: dark; }
      body { margin: 0; background: #0e1014; color: #b9bcc4; font: 13px/1.45 system-ui, sans-serif; }
      #pt-bar { position: sticky; top: 0; z-index: 1; display: flex; flex-wrap: wrap; align-items: center;
        gap: 6px 16px; padding: 10px 16px; background: rgb(14 16 20 / .92); backdrop-filter: blur(6px);
        border-bottom: 1px solid #23262d; }
      #pt-bar strong { color: #f4f1ea; font-weight: 600; }
      #pt-actions { display: flex; gap: 12px; margin-left: auto; }
      #pt-actions a, #pt-actions button { color: #d8a21a; font: inherit; background: none; border: 0; padding: 0; cursor: pointer; }
      #pages { display: grid; justify-items: center; gap: 48px; padding: 32px 16px 72px; }
      .pt-spread { display: flex; }
      .pt-spread figure { margin: 0; width: min(460px, 44vw); }
      .pt-spread canvas { display: block; width: 100%; background: #fff;
        box-shadow: 0 1px 2px rgb(0 0 0 / .5), 0 22px 44px -16px rgb(0 0 0 / .8); }
      .pt-spread figure:first-child canvas { box-shadow: inset -14px 0 14px -14px rgb(0 0 0 / .18), 0 1px 2px rgb(0 0 0 / .5), 0 22px 44px -16px rgb(0 0 0 / .8); }
      .pt-spread figcaption { margin-top: 10px; text-align: center; font: 600 10px/1 system-ui, sans-serif;
        letter-spacing: .18em; text-transform: uppercase; color: #6c7079; }
      .pt-blank { visibility: hidden; }
      @media (max-width: 760px) {
        .pt-spread { flex-direction: column; gap: 32px; }
        .pt-spread figure { width: min(460px, 92vw); }
        .pt-blank { display: none; }
      }
    </style>`);
    document.body.insertAdjacentHTML('afterbegin',
      '<header id="pt-bar"><strong id="pt-title"></strong><span id="pt-status" role="status"></span><span id="pt-actions"></span></header>');
    document.getElementById('pt-title').textContent = document.title || 'Postext';
    addEventListener('error', (event) => kitFail(event.error ?? event.message));
    addEventListener('unhandledrejection', (event) => kitFail(event.reason));
  }
  if (title) document.getElementById('pt-title').textContent = title;
  return document.getElementById('pages')
    ?? document.body.appendChild(Object.assign(document.createElement('main'), { id: 'pages' }));
}

function kitStatus(text) {
  viewer();
  document.getElementById('pt-status').textContent = text;
}

function kitFail(error) {
  document.documentElement.dataset.postext = 'error';
  kitStatus(`Error: ${error?.message ?? error}`);
}

// ─── Kit · pdf v3 ── the same in every recipe that exports a PDF
/** The Fontsource files the screen used, as TrueType, with their range and
 *  place: the nearest weight the family ships in that style, upright with no italic;
 *  latin, then what its letters need (kitSubsetsFor). */
async function fontsourceProvider(family, weight, style, request) {
  const id = fontsourceId(family);
  const meta = await fontsourceMeta(family);
  const s = style === 'italic' && meta && !meta.styles.includes('italic') ? 'normal' : style;
  const shipped = meta ? await fontsourceWeights(family, s) : [];
  const weights = shipped.length ? shipped : [400, 700];
  const w = weights.reduce((a, b) => (Math.abs(b - weight) < Math.abs(a - weight) ? b : a));
  const text = String.fromCodePoint(...(request?.codePoints ?? []));
  const files = await Promise.all(['latin', ...kitSubsetsFor(text, meta)].map(async (subset, order) => {
    const res = await fetch(`${await fontsourceAt(id)}files/${id}-${subset}-${w}-${s}.woff2`);
    if (!res.ok) throw new Error(`Fontsource has no ${family} ${w} ${s} ${subset}`);
    return Object.assign(await decompressWoff2(new Uint8Array(await res.arrayBuffer())),
      { unicodeRange: kitRanges()[subset], order });
  }));
  return files.length === 1 ? files[0] : files;
}

/** A "Build the PDF" button; then "Open the PDF" (a new tab: CodePen's frame
 *  shows no PDFs) and a download link. */
function offerPdf(makePdf, filename) {
  viewer();
  const button = Object.assign(document.createElement('button'), { type: 'button', textContent: 'Build the PDF' });
  button.dataset.postextPdf = filename;
  button.addEventListener('click', async () => {
    button.disabled = true;
    button.textContent = 'Building the PDF…';
    try {
      const bytes = await makePdf();
      const url = URL.createObjectURL(new Blob([bytes], { type: 'application/pdf' }));
      const size = `${Math.max(1, Math.round(bytes.length / 1024))} KB`;
      button.replaceWith(
        Object.assign(document.createElement('a'), { href: url, target: '_blank', rel: 'noopener', textContent: 'Open the PDF ↗' }),
        Object.assign(document.createElement('a'), { href: url, download: filename, textContent: `Download ${filename} · ${size}` }));
    } catch (error) {
      button.disabled = false;
      button.textContent = 'Build the PDF';
      kitFail(error);
    }
  });
  document.getElementById('pt-actions').append(button);
}

// ─── Kit · images v3 ── recipes with pictures · postext.dev/cookbook
/** Registers a photo or PNG for the canvas and keeps its bytes for the PDF.
 *  fetch → ImageBitmap never taints the canvas (a plain cross-origin <img> would). */
async function loadImage(fileId, url) {
  const res = await fetch(url);
  if (!res.ok) throw new Error(`Image not found (${res.status}): ${url}`);
  const bytes = new Uint8Array(await res.arrayBuffer());
  registerResourceImage(fileId, await createImageBitmap(new Blob([bytes])));
  (loadImage.bytes ??= new Map()).set(fileId, bytes);
}

/** Registers SVG markup as a vector image, its fonts inside (inlineSvgFonts, ≥ 1.25).
 *  `options` go to registerResourceImage: { singleInk: true } tints it on the canvas. */
async function loadSvg(fileId, svg, options) {
  if (typeof inlineSvgFonts === 'function') svg = await inlineSvgFonts(svg, svgFaces);
  const img = new Image();
  img.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
  await img.decode();
  registerResourceImage(fileId, img, options);
  (loadImage.bytes ??= new Map()).set(fileId, new TextEncoder().encode(svg));
}

/** A face's Fontsource files: nearest weight; latin + what the SVG sets. */
async function svgFaces(family, weight, style, { codePoints = [] } = {}) {
  const [id, m] = [fontsourceId(family), await fontsourceMeta(family)];
  const w = m?.weights.reduce((a, b) => (Math.abs(b - weight) < Math.abs(a - weight) ? b : a)) ?? weight;
  const s = m?.styles.includes(style) === false ? 'normal' : style;
  return Promise.all(['latin', ...kitSubsetsFor(String.fromCodePoint(...codePoints), m)].map(async (x) => new Uint8Array(
    await (await fetch(`${await fontsourceAt(id)}files/${id}-${x}-${w}-${s}.woff2`)).arrayBuffer())));
}

/** renderToPdf({ resourceBytes: imageBytes }) */
function imageBytes(fileId) { return loadImage.bytes?.get(fileId); }

/** renderToHtml({ resourceImageUrl: imageUrl }) */
function imageUrl(fileId) {
  const bytes = imageBytes(fileId);
  if (!bytes) return undefined;
  imageUrl.urls ??= new Map();
  if (!imageUrl.urls.has(fileId)) {
    const type = /\.svg$/i.test(fileId) ? 'image/svg+xml' : /\.png$/i.test(fileId) ? 'image/png' : 'image/jpeg';
    imageUrl.urls.set(fileId, URL.createObjectURL(new Blob([bytes], { type })));
  }
  return imageUrl.urls.get(fileId);
}

// ─── /Kit ───────────────────────────────────────────────────────────────────────
```

## Variations

### Round only the fore-edge corners

A trade picture book rounds the two corners away from the spine and keeps the spine square.

```diff
-  corners: { radius: mm(9), edges: 'all' }, // board books are rounded on all four corners
+  corners: { radius: mm(6), edges: 'fore' },
```

### Cut every leaf to a shape

An outline in `viewBox` units cuts every leaf to it, mirrored on the versos; it wins over the corners.

```diff
   corners: { radius: mm(9), edges: 'all' }, // board books are rounded on all four corners
+  outline: { d: 'M0 0.35 L0.5 0 L1 0.35 L1 1 L0 1 Z', viewBox: [1, 1] }, // a house
```

## Credits

- Recipe: Ignacio Ferro ([@drnachio](https://github.com/drnachio))
- Text: The words of the board book: Postext Cookbook, CC-BY-4.0
- Images: Cover painting: a cottage garden, a hedge, hollyhocks and a robin: Generated With Diffusion Models, original
- Images: Page 3: the hedge: Generated With Diffusion Models, original
- Images: Page 5: the ginger cat asleep: Generated With Diffusion Models, original
- Images: Page 7: the wooden fence: Generated With Diffusion Models, original
- Images: Page 9: the sheep: Generated With Diffusion Models, original
- Images: Page 11: the barn door: Generated With Diffusion Models, original
- Images: Page 13: Grandpa and his lantern at dusk: Generated With Diffusion Models, original
- Type: Andika (OFL-1.1), Fredoka (OFL-1.1), Nunito (OFL-1.1)
- Code: MIT · Sample content: CC-BY-4.0

## Related

- [Nº 195 · A tunnel book twenty leaves deep](https://postext.dev/en/cookbook/forest-tunnel-book.md): Nineteen round windows cut with dieCuts, each smaller than the last on one axis, so the cover looks through twenty painted planes of a wood to a deer at a pool. · Level 3 (Advanced) · Single sheets & ephemera
- [Nº 100 · A laid-out book on the desk, in 3D](https://postext.dev/en/cookbook/folio-book-on-a-desk.md): createFolioFromDocument from the postext-folio package opens a laid-out chapter as a cloth-bound book on a walnut desk, styled by config.folio. · Level 2 (Intermediate) · Fiction, drama & literary prose
- [Nº 191 · A bakery menu in white ink on kraft](https://postext.dev/en/cookbook/white-ink-kraft-menu.md): Opaque white as a spot ink on kraft: white type on the brown card, a white card under brown type, and white knocked out of a green panel. · Level 3 (Advanced) · Single sheets & ephemera
