@segnavia/html 0.37.0 → 0.39.0

package/dist/book/book-held.js

@@ -1,8 +1,24 @@
 import { elements, parse } from "../sanitize.js";
-import { flowPageStyle } from "./book-flow.js";
 import { element, linkChildren, textContent } from "./dom.js";
+import { flowPageStyle } from "./book-flow.js";
+import { namedRegionFitIssues, templateRegionFitIssues } from "./region-fit.js";
 import { BOOK_FURNITURE, MOTIF_ATTRIBUTE, REGION_NAME, motifFieldAttribute } from "@segnavia/format";
 //#region src/book/book-held.ts
+function authoredSection(section, id, build) {
+	const document = parse(section.html);
+	const runningHead = section.title;
+	const node = sectionNode("front", id, document.children, build, runningHead, flowAttribs(section.opens, section.parents));
+	return {
+		info: {
+			id,
+			kind: "front",
+			division: "front",
+			title: section.title,
+			runningHead
+		},
+		node
+	};
+}
 function flowAttribs(opens, parents, extra = {}) {
 	const attribs = { ...extra };
 	if (opens) attribs["data-opens"] = opens;
@@ -29,6 +45,25 @@ function sectionNode(kind, id, children = [], build, runningHead, extra = {}) {
 	if (build === "galley" && runningHead !== void 0) attribs["data-running-head"] = runningHead;
 	return element("section", attribs, children);
 }
+function partSection(entry, id, division, build, parts) {
+	const children = entry.html === void 0 ? [] : parse(entry.html).children;
+	const runningHead = entry.runningHead ?? entry.title;
+	const extra = flowAttribs(entry.opens, entry.parents, {
+		"data-segnavia-kind": "part",
+		"data-segnavia-parts": JSON.stringify(parts),
+		...division === "front" ? { "data-sequence": "front" } : {}
+	});
+	return {
+		info: {
+			id,
+			kind: "part",
+			division,
+			title: entry.title,
+			runningHead
+		},
+		node: sectionNode("part", id, children, build, runningHead, extra)
+	};
+}
 function flowPage(page, kind, children, geometry, recto) {
 	const paper = element("div", { "data-segnavia-flow-paper": "" }, children);
 	return element("figure", {
@@ -57,7 +92,7 @@ function collectHeadings(children, sectionId, depth, firstLevel, idFor, generate
 function heldHeadings(children, sectionId, depth, generated) {
 	return collectHeadings(children, sectionId, depth, 1, (n) => `segnavia-h-${sectionId.replace(/^segnavia-/, "")}-${n}`, generated);
 }
-function designedSection(entry, id, kind, build, depth, geometry) {
+function designedSection(entry, id, kind, division, build, depth, geometry) {
 	const extra = flowAttribs(entry.opens, entry.parents, {
 		"data-segnavia-kind": "fixed",
 		...kind === "front" ? { "data-sequence": "front" } : {}
@@ -85,6 +120,7 @@ function designedSection(entry, id, kind, build, depth, geometry) {
 			info: {
 				id,
 				kind,
+				division,
 				title: entry.title,
 				runningHead
 			},
@@ -93,12 +129,25 @@ function designedSection(entry, id, kind, build, depth, geometry) {
 		headings
 	};
 }
+function templateRegionElements(html) {
+	return elements(parse(html).children).filter((node) => node.attribs["data-region"]);
+}
 function declaredRegions(html) {
-	return new Set(elements(parse(html).children).flatMap((node) => node.attribs["data-region"] ? [node.attribs["data-region"]] : []));
+	return new Set(templateRegionElements(html).flatMap((node) => node.attribs["data-region"] ? [node.attribs["data-region"]] : []));
 }
 const regionNameClear = "use a letter followed by letters, digits, hyphens or underscores to clear this refusal";
-function templateRegionNameIssues(templates) {
-	return templates.flatMap((template) => [...declaredRegions(template.html)].flatMap((key) => REGION_NAME.test(key) ? [] : [`template "${template.name}" marks region "${key}" which is not an HTML name token; ${regionNameClear}`]));
+function templateRegionNameIssues(template, regions) {
+	return [...new Set(regions.flatMap((node) => node.attribs["data-region"] ? [node.attribs["data-region"]] : []))].flatMap((key) => REGION_NAME.test(key) ? [] : [`template "${template}" marks region "${key}" which is not an HTML name token; ${regionNameClear}`]);
+}
+function templateRegionIssues(templates) {
+	return templates.flatMap((template) => {
+		const regions = templateRegionElements(template.html);
+		return [...templateRegionNameIssues(template.name, regions), ...templateRegionFitIssues(template.name, regions)];
+	});
+}
+function templatedPageRegionFitIssues(entry, id) {
+	const label = entry.title ?? id;
+	return entry.pages.flatMap((page, index) => Object.values(page.regions).flatMap((html) => namedRegionFitIssues(`section ${label} page ${index + 1}`, templateRegionElements(html))));
 }
 const markFurniture = BOOK_FURNITURE.find((item) => item.key === "segnavia:mark");
 const markFields = new Set(markFurniture.fields.map((field) => motifFieldAttribute(field.key)));
@@ -137,7 +186,10 @@ function undeclaredRegionIssues(entry, id, templates) {
 		return Object.keys(page.regions).flatMap((region) => declared.has(region) ? [] : [`section ${label} page ${index + 1} fills region "${region}" which template "${name}" does not declare; add that region to the template or remove the fill to clear this refusal`]);
 	});
 }
-function templatedSection(entry, id, kind, build, depth, templates, geometry) {
+function templatedSectionIssues(entry, id, templates) {
+	return [...undeclaredRegionIssues(entry, id, templates), ...templatedPageRegionFitIssues(entry, id)];
+}
+function templatedSection(entry, id, kind, division, build, depth, templates, geometry) {
 	const extra = flowAttribs(entry.opens, entry.parents, {
 		"data-segnavia-kind": "templated",
 		"data-template": entry.template,
@@ -191,6 +243,7 @@ function templatedSection(entry, id, kind, build, depth, templates, geometry) {
 			info: {
 				id,
 				kind,
+				division,
 				title: entry.title,
 				runningHead
 			},
@@ -207,4 +260,4 @@ function templateHolders(templates) {
 	}, parse(template.html).children));
 }
 //#endregion
-export { collectHeadings, designedSection, flowAttribs, markPlacementIssues, sectionNode, templateHolders, templateRegionNameIssues, templatedSection, undeclaredRegionIssues };
+export { authoredSection, collectHeadings, designedSection, flowAttribs, markPlacementIssues, partSection, sectionNode, templateHolders, templateRegionElements, templateRegionIssues, templateRegionNameIssues, templatedSection, templatedSectionIssues };

package/dist/book/book-issues.js

@@ -0,0 +1,42 @@
+import { elements } from "../sanitize.js";
+import { pageReferenceNodes, pageReferenceTarget } from "./book-page-reference.js";
+//#region src/book/book-issues.ts
+function sectionIds(section) {
+	return [section.info.id, ...elements(section.node.children).flatMap((node) => node.attribs.id ? [node.attribs.id] : [])];
+}
+function sectionName(section) {
+	return `${section.title ?? section.id} (${section.id})`;
+}
+function ownersById(sections) {
+	const occurrences = /* @__PURE__ */ new Map();
+	for (const section of sections) for (const id of sectionIds(section)) occurrences.set(id, [...occurrences.get(id) ?? [], section.info]);
+	return occurrences;
+}
+function duplicateIdIssues(sections, headings) {
+	const listed = new Set(headings.map((heading) => heading.id));
+	return [...ownersById(sections)].flatMap(([id, owners]) => {
+		if (!listed.has(id) || owners.length < 2) return [];
+		const named = owners.slice(0, 2).map(sectionName);
+		return [`destination id ${id} is used in both ${named[0]} and ${named[1]}; listed heading and generated destination ids must be unique`];
+	});
+}
+function pageReferenceIssues(sections, scopes) {
+	const targets = ownersById(sections);
+	return scopes.flatMap((scope) => pageReferenceNodes(scope.roots).flatMap((node) => {
+		const id = pageReferenceTarget(node.attribs);
+		if (!id) return [];
+		const owners = targets.get(id) ?? [];
+		if (owners.length === 0) return [`page reference to ${id} in ${scope.owner} has no target; add the id or remove the reference`];
+		if (owners.length === 1) return [];
+		return [`page reference target ${id} is used in ${owners.length} sections: ${owners.map(sectionName).join(", ")}; make the target id unique to clear this refusal`];
+	}));
+}
+function reservedIdIssues(section) {
+	return elements(section.node.children).flatMap((node) => {
+		const id = node.attribs.id;
+		if (!id?.startsWith("segnavia-")) return [];
+		return [`authored id ${id} in ${sectionName(section.info)} uses the reserved segnavia- prefix`];
+	});
+}
+//#endregion
+export { duplicateIdIssues, pageReferenceIssues, reservedIdIssues };

package/dist/book/book-page-reference.d.ts

@@ -0,0 +1,7 @@
+import { Element } from "domhandler";
+//#region src/book/book-page-reference.d.ts
+export declare const PAGE_REFERENCE_ATTRIBUTE = "data-ref";
+export declare const PAGE_REFERENCE_VALUE = "page";
+export declare const PAGE_REFERENCE_SELECTOR = "a[data-ref=\"page\"]";
+export declare function pageReferenceTarget(attribs: Record<string, string>): string | undefined;
+//#endregion

package/dist/book/book-page-reference.js

@@ -0,0 +1,19 @@
+import { elements } from "../sanitize.js";
+//#region src/book/book-page-reference.ts
+const PAGE_REFERENCE_ATTRIBUTE = "data-ref";
+const PAGE_REFERENCE_VALUE = "page";
+const PAGE_REFERENCE_SELECTOR = "a[data-ref=\"page\"]";
+function pageReferenceTarget(attribs) {
+	if (attribs["data-ref"] !== "page") return void 0;
+	const href = attribs.href;
+	if (href?.startsWith("#") && href.length > 1) return href.slice(1);
+	return href?.startsWith("segnavia:target/") && href.length > 16 ? href.slice(16) : void 0;
+}
+function pageReferenceNodes(roots) {
+	return roots.flatMap((root) => [root, ...elements(root.children)]).filter((node) => node.name === "a" && pageReferenceTarget(node.attribs) !== void 0);
+}
+function pageReferenceTargets(roots) {
+	return [...new Set(pageReferenceNodes(roots).flatMap((node) => pageReferenceTarget(node.attribs) ?? []))];
+}
+//#endregion
+export { PAGE_REFERENCE_ATTRIBUTE, PAGE_REFERENCE_SELECTOR, PAGE_REFERENCE_VALUE, pageReferenceNodes, pageReferenceTarget, pageReferenceTargets };

package/dist/book/book-part-build.js

@@ -0,0 +1,50 @@
+import { partSection } from "./book-held.js";
+import { isPart } from "@segnavia/format";
+//#region src/book/book-part-build.ts
+function partNames(ancestry, own) {
+	return Object.fromEntries([...ancestry, ...own ? [own] : []].map((part) => [part.name, part.runningHead ?? part.title ?? ""]));
+}
+function addPart(sectionEntry, build) {
+	const { entry } = sectionEntry;
+	if (!isPart(entry)) return false;
+	const id = sectionEntry.id ?? "";
+	if (entry.html !== void 0) {
+		const parts = partNames(sectionEntry.ancestry, {
+			name: entry.name,
+			title: entry.title,
+			runningHead: entry.runningHead,
+			id
+		});
+		build.sections.push(partSection(entry, id, sectionEntry.division, build.build, parts));
+		attachPendingPartHeadings(build, sectionEntry, id);
+	}
+	if (entry.contents && entry.title !== void 0) {
+		const heading = {
+			level: 1,
+			depth: sectionEntry.depth,
+			text: entry.title
+		};
+		if (entry.html === void 0) build.pendingPartHeadings.push({
+			...heading,
+			partId: id
+		});
+		else build.headings.push({
+			...heading,
+			id,
+			sectionId: id
+		});
+	}
+	return true;
+}
+function attachPendingPartHeadings(build, sectionEntry, id) {
+	const ancestryIds = new Set(sectionEntry.ancestry.map((part) => part.id));
+	const attached = build.pendingPartHeadings.filter((heading) => ancestryIds.has(heading.partId));
+	build.headings.push(...attached.map(({ partId: _partId, ...heading }) => ({
+		...heading,
+		id,
+		sectionId: id
+	})));
+	build.pendingPartHeadings = build.pendingPartHeadings.filter((heading) => !ancestryIds.has(heading.partId));
+}
+//#endregion
+export { addPart, attachPendingPartHeadings, partNames };

package/dist/book/dom.d.ts

@@ -0,0 +1 @@
+import { Element, Text } from "domhandler";

package/dist/book/notes.d.ts

@@ -0,0 +1,2 @@
+import { Element } from "domhandler";
+import { Book } from "@segnavia/format";

package/dist/book/notes.js

@@ -32,18 +32,15 @@ const INSIDE_BLOCKS = /* @__PURE__ */ new Set([
 ]);
 function noteState() {
 	return {
-		footnotes: false,
-		endnotes: false,
-		globalFootnote: 0,
-		chapterFootnotes: /* @__PURE__ */ new Map(),
-		endnoteCount: 0,
-		chapterEndnotes: /* @__PURE__ */ new Map(),
-		footnoteParagraphs: []
+		used: /* @__PURE__ */ new Set(),
+		counters: /* @__PURE__ */ new Map(),
+		collected: /* @__PURE__ */ new Map(),
+		pageParagraphs: /* @__PURE__ */ new Map(),
+		authored: /* @__PURE__ */ new Map(),
+		repeatCount: 0,
+		issues: []
 	};
 }
-function endnotesInOrder(state) {
-	return [...state.chapterEndnotes.values()].flat();
-}
 function nearestBlock(note) {
 	for (let parent = note.parent; parent; parent = parent.parent) if (isTag(parent) && BLOCKS.has(parent.name)) return parent;
 }
@@ -63,59 +60,128 @@ function noteParagraph(className, noteId, refId, marker, content) {
 		...content
 	]);
 }
-function footnoteNumber(book, chapter, state) {
-	if (book.footnotes.restart === "book") {
-		state.globalFootnote += 1;
-		return state.globalFootnote;
-	}
-	const number = (state.chapterFootnotes.get(chapter) ?? 0) + 1;
-	state.chapterFootnotes.set(chapter, number);
-	return number;
+function scopeKey(series, context) {
+	if (series.numbering === "book") return "book";
+	if (series.numbering === "part") return context.part?.id ?? "book";
+	return String(context.chapter);
+}
+function placementKey(series, context) {
+	if (series.placement === "book") return "book";
+	if (series.placement === "part") return context.part?.id ?? "book";
+	return context.placementKey ?? String(context.chapter);
+}
+function nextNumber(series, context, state) {
+	const scope = scopeKey(series, context);
+	const key = `${series.name}:${scope}`;
+	const number = (state.counters.get(key) ?? 0) + 1;
+	state.counters.set(key, number);
+	return {
+		number,
+		scope
+	};
+}
+function noteIds(series, scope, chapter, number) {
+	const scopePart = series.idScope === "chapter" ? `-${chapter}` : series.numbering === "book" ? "" : `-${scope}`;
+	return {
+		noteId: `segnavia-${series.idStem}${scopePart}-${number}`,
+		refId: `segnavia-${series.idStem}ref${scopePart}-${number}`
+	};
 }
-function addFootnoteBlock(block, paragraph, blocks) {
-	const existing = blocks.get(block);
+function addPageBlock(block, paragraph, blocks, series, seriesOrder) {
+	const blockSeries = blocks.get(block) ?? /* @__PURE__ */ new Map();
+	const existing = blockSeries.get(series.name);
 	if (existing) {
 		append(existing, paragraph);
 		return;
 	}
-	const notes = element("div", { class: "segnavia-footnotes" }, [paragraph]);
-	blocks.set(block, notes);
-	if (INSIDE_BLOCKS.has(block.name)) append(block, notes);
-	else insertAfter(block, notes);
+	const attributes = {
+		class: series.blockClass,
+		...series.markBlockSeries ? { "data-segnavia-note-series": series.name } : {}
+	};
+	const notes = element("div", attributes, [paragraph]);
+	const index = seriesOrder.get(series.name) ?? seriesOrder.size;
+	const next = [...blockSeries.entries()].filter(([name]) => (seriesOrder.get(name) ?? seriesOrder.size) > index).sort(([left], [right]) => (seriesOrder.get(left) ?? seriesOrder.size) - (seriesOrder.get(right) ?? seriesOrder.size))[0]?.[1];
+	if (next?.prev) insertAfter(next.prev, notes);
+	else if (INSIDE_BLOCKS.has(block.name)) append(block, notes);
+	else {
+		const previous = [...blockSeries.entries()].filter(([name]) => (seriesOrder.get(name) ?? seriesOrder.size) < index).sort(([left], [right]) => (seriesOrder.get(right) ?? seriesOrder.size) - (seriesOrder.get(left) ?? seriesOrder.size))[0]?.[1];
+		insertAfter(previous ?? block, notes);
+	}
+	blockSeries.set(series.name, notes);
+	blocks.set(block, blockSeries);
 }
-function transformFootnote(note, book, chapter, state, blocks, galley) {
+function collectedNotes(series, context, state) {
+	const key = placementKey(series, context);
+	const mapKey = `${series.name}:${key}`;
+	const existing = state.collected.get(mapKey);
+	if (existing) return existing;
+	const scopeTitle = series.placement === "part" ? context.part?.title : series.placement === "chapter" ? context.title : void 0;
+	const collected = {
+		series,
+		placementKey: key,
+		targetId: series.placement === "book" || series.placement === "part" && context.part === void 0 || series.placement === "chapter" && context.division === "front" ? "book" : series.placement === "part" ? context.part?.id ?? context.targetId : context.targetId,
+		scopeTitle,
+		division: context.division,
+		paragraphs: []
+	};
+	state.collected.set(mapKey, collected);
+	return collected;
+}
+function transformAuthoredNote(note, series, context, state, blocks, seriesOrder, galley) {
 	const block = nearestBlock(note);
 	if (!block) return;
-	const number = footnoteNumber(book, chapter, state);
-	const noteId = `segnavia-fn-${chapter}-${number}`;
-	const refId = `segnavia-fnref-${chapter}-${number}`;
-	const marker = noteMarker(number, book.footnotes.marker);
+	const { number, scope } = nextNumber(series, context, state);
+	const { noteId, refId } = noteIds(series, scope, context.chapter, number);
+	const marker = noteMarker(number, series.marker);
+	const authoredId = note.attribs.id;
 	const content = [...note.children];
 	replace(note, element("sup", { class: "segnavia-note-ref" }, [markerLink(refId, noteId, marker)]));
-	const paragraph = noteParagraph("segnavia-footnote", noteId, refId, marker, content);
-	if (galley) state.footnoteParagraphs.push(paragraph);
-	else addFootnoteBlock(block, paragraph, blocks);
-	state.footnotes = true;
+	const paragraph = noteParagraph(series.bodyClass, noteId, refId, marker, content);
+	if (series.placement === "page") {
+		if (galley) {
+			const paragraphs = state.pageParagraphs.get(series.name) ?? [];
+			paragraphs.push(paragraph);
+			state.pageParagraphs.set(series.name, paragraphs);
+		} else addPageBlock(block, paragraph, blocks, series, seriesOrder);
+	} else collectedNotes(series, context, state).paragraphs.push(paragraph);
+	if (authoredId) state.authored.set(authoredId, {
+		noteId,
+		refId,
+		marker
+	});
+	state.used.add(series.name);
 }
-function transformEndnote(note, book, state, owner) {
-	state.endnoteCount += 1;
-	const number = state.endnoteCount;
-	const noteId = `segnavia-en-${number}`;
-	const refId = `segnavia-enref-${number}`;
-	const marker = noteMarker(number, book.endnotes.marker);
-	const content = [...note.children];
-	replace(note, element("sup", { class: "segnavia-note-ref" }, [markerLink(refId, noteId, marker)]));
-	const paragraph = noteParagraph("segnavia-endnote", noteId, refId, marker, content);
-	const held = state.chapterEndnotes.get(owner) ?? [];
-	held.push(paragraph);
-	state.chapterEndnotes.set(owner, held);
-	state.endnotes = true;
+function transformRepeat(node, state) {
+	const authoredId = node.attribs["data-note-ref"] ?? "";
+	const note = state.authored.get(authoredId);
+	if (!note) {
+		state.issues.push(`data-note-ref ${authoredId} names no earlier note; place the note before its repeated call`);
+		return;
+	}
+	state.repeatCount += 1;
+	replace(node, element("sup", {
+		class: "segnavia-note-ref",
+		"data-segnavia-note-repeat": ""
+	}, [markerLink(`${note.refId}-repeat-${state.repeatCount}`, note.noteId, note.marker)]));
 }
-function transformNotes(root, book, chapter, state, galley = false, notesOwner = chapter) {
+function transformNotes(root, book, context, state, galley = false) {
 	const blocks = /* @__PURE__ */ new Map();
-	const notes = elements(root.children).filter((node) => node.name === "span" && (node.attribs["data-note"] === "footnote" || node.attribs["data-note"] === "endnote"));
-	for (const note of notes) if (note.attribs["data-note"] === "footnote") transformFootnote(note, book, chapter, state, blocks, galley);
-	else transformEndnote(note, book, state, notesOwner);
+	const byName = new Map(book.notes.map((series) => [series.name, series]));
+	const seriesOrder = new Map(book.notes.map((series, index) => [series.name, index]));
+	const nodes = elements(root.children).filter((node) => node.name === "span" && node.attribs["data-note"] !== void 0 || node.name === "a" && node.attribs["data-note-ref"] !== void 0);
+	for (const node of nodes) {
+		if (node.name === "a") {
+			transformRepeat(node, state);
+			continue;
+		}
+		const name = node.attribs["data-note"] ?? "";
+		const series = byName.get(name);
+		if (!series) {
+			state.issues.push(`data-note names unknown note series ${name}; declare the series in notes or use a declared series name`);
+			continue;
+		}
+		transformAuthoredNote(node, series, context, state, blocks, seriesOrder, galley);
+	}
 }
 //#endregion
-export { endnotesInOrder, noteState, transformNotes };
+export { noteState, transformNotes };

package/dist/book/paginate-book.d.ts

@@ -1,4 +1,5 @@
 import { PaginateBookInput, PaginateBookResult } from "./paginate-types.js";
+import { printedPageAt, selectBookParent } from "../printed-pages.js";
 import { paginateColumns } from "./paginate-columns.js";
 import { paginateKeeps } from "./paginate-keeps.js";
 import { paginateMarks } from "./paginate-marks.js";
@@ -6,6 +7,6 @@ import { paginateNotes } from "./paginate-notes.js";
 import { paginateSequence } from "./paginate-sequence.js";
 //#region src/book/paginate-book.d.ts
 export declare function paginateBook(input: PaginateBookInput): PaginateBookResult;
-export declare const PAGINATE_FUNCTIONS: (typeof paginateColumns | typeof paginateNotes | typeof paginateKeeps | typeof paginateMarks | typeof paginateSequence)[];
+export declare const PAGINATE_FUNCTIONS: (typeof printedPageAt | typeof selectBookParent | typeof paginateColumns | typeof paginateNotes | typeof paginateKeeps | typeof paginateMarks | typeof paginateSequence)[];
 export declare function paginateScript(): string;
 //#endregion

package/dist/book/paginate-book.js

@@ -1,3 +1,4 @@
+import { printedPageAt, selectBookParent } from "../printed-pages.js";
 import { paginateColumns } from "./paginate-columns.js";
 import { paginateKeeps } from "./paginate-keeps.js";
 import { paginateMarks } from "./paginate-marks.js";
@@ -5,31 +6,36 @@ import { paginateNotes } from "./paginate-notes.js";
 import { paginateSequence } from "./paginate-sequence.js";
 //#region src/book/paginate-book.ts
 function paginateBook(input) {
-	const textHeight = input.geometry.textHeight;
 	const orphans = input.settings.orphans ?? 2;
 	const widows = input.settings.widows ?? 2;
-	function used(placed, fragments) {
+	function used(textHeight, placed, fragments) {
 		return paginateColumns(placed).height + paginateNotes({
 			op: "space",
 			notes: input.notes,
-			geometry: input.geometry,
+			geometry: {
+				...input.geometry,
+				textHeight
+			},
 			fragments
 		});
 	}
-	function withNotes(extra) {
+	function withNotes(textHeight, extra) {
 		return {
 			notes: input.notes,
-			geometry: input.geometry,
-			used,
+			geometry: {
+				...input.geometry,
+				textHeight
+			},
+			used: (placed, fragments) => used(textHeight, placed, fragments),
 			...extra
 		};
 	}
-	function refusal(block) {
+	function refusal(block, textArea = "the text area") {
 		const position = `chapter ${block.position.chapter} block ${block.position.block}`;
 		return {
 			tag: block.tag,
 			position: block.position,
-			message: `The ${block.tag} at ${position} could not establish a fit in the text area; shorten it or increase the text-area height to clear this refusal.`
+			message: `The ${block.tag} at ${position} could not establish a fit in ${textArea}; shorten it or increase the text-area height to clear this refusal.`
 		};
 	}
 	function blockForNote(id) {
@@ -52,16 +58,16 @@ function paginateBook(input) {
 			message: `The ${found.tag} at ${where} could not establish a fit for a note line in the text area; ${clears}`
 		};
 	}
-	function lineTooTall(unit) {
+	function lineTooTall(unit, textHeight) {
 		return unit.bottom - unit.top > textHeight;
 	}
-	function greedyFill(placed, fragments, units, index) {
+	function greedyFill(placed, fragments, units, index, textHeight) {
 		let next = index;
 		let notes = fragments;
 		while (next < units.length) {
 			const unit = units[next];
-			if (!unit || lineTooTall(unit)) break;
-			const allocated = paginateNotes(withNotes({
+			if (!unit || lineTooTall(unit, textHeight)) break;
+			const allocated = paginateNotes(withNotes(textHeight, {
 				op: "allocate",
 				placed,
 				fragments: notes,
@@ -78,15 +84,15 @@ function paginateBook(input) {
 			index: next
 		};
 	}
-	function forcePlace(unit) {
-		if (lineTooTall(unit)) return {
+	function forcePlace(unit, textHeight, textArea) {
+		if (lineTooTall(unit, textHeight)) return {
 			placed: [],
 			fragments: [],
 			index: 0,
 			pending: [],
-			refusal: refusal(unit.block)
+			refusal: refusal(unit.block, textArea)
 		};
-		const allocated = paginateNotes(withNotes({
+		const allocated = paginateNotes(withNotes(textHeight, {
 			op: "allocate",
 			placed: [],
 			fragments: [],
@@ -97,30 +103,30 @@ function paginateBook(input) {
 			fragments: [],
 			index: 0,
 			pending: [],
-			refusal: refusal(unit.block)
+			refusal: refusal(unit.block, textArea)
 		};
 		return {
 			placed: [unit],
 			fragments: allocated,
 			index: 0,
-			pending: paginateNotes(withNotes({
+			pending: paginateNotes(withNotes(textHeight, {
 				op: "leftover",
 				fragments: allocated
 			}))
 		};
 	}
-	function fillPage(units, index, pending) {
-		const held = paginateNotes(withNotes({
+	function fillPage(units, index, pending, textHeight, textArea) {
+		const held = paginateNotes(withNotes(textHeight, {
 			op: "continue",
 			pending
 		}));
 		const incoming = units[index];
-		if (held.leftover.length === 0 && incoming && lineTooTall(incoming)) return {
+		if (held.leftover.length === 0 && incoming && lineTooTall(incoming, textHeight)) return {
 			placed: [],
 			fragments: [],
 			index,
 			pending,
-			refusal: refusal(incoming.block)
+			refusal: refusal(incoming.block, textArea)
 		};
 		const stuck = held.fragments.length === 0 ? held.leftover[0] : void 0;
 		if (stuck) return {
@@ -136,10 +142,10 @@ function paginateBook(input) {
 			index,
 			pending: held.leftover
 		};
-		const filled = greedyFill([], held.fragments, units, index);
+		const filled = greedyFill([], held.fragments, units, index, textHeight);
 		const placed = paginateKeeps(filled.placed, units[filled.index], textHeight, orphans, widows, held.fragments.length > 0);
 		const nextIndex = filled.index - (filled.placed.length - placed.length);
-		const fragments = paginateNotes(withNotes({
+		const fragments = paginateNotes(withNotes(textHeight, {
 			op: "recompute",
 			placed,
 			seed: held.fragments
@@ -148,7 +154,7 @@ function paginateBook(input) {
 			placed,
 			fragments,
 			index: nextIndex,
-			pending: paginateNotes(withNotes({
+			pending: paginateNotes(withNotes(textHeight, {
 				op: "leftover",
 				fragments
 			}))
@@ -169,7 +175,7 @@ function paginateBook(input) {
 			pending,
 			done: true
 		};
-		const forced = forcePlace(unit);
+		const forced = forcePlace(unit, textHeight, textArea);
 		if (forced.refusal) return forced;
 		return {
 			placed: forced.placed,
@@ -181,6 +187,8 @@ function paginateBook(input) {
 	return paginateSequence(input, fillPage);
 }
 const PAGINATE_FUNCTIONS = [
+	printedPageAt,
+	selectBookParent,
 	paginateColumns,
 	paginateNotes,
 	paginateKeeps,