@segnavia/render 0.5.0 → 0.7.0

package/dist/book-pdf.js

@@ -5,10 +5,11 @@ import { Book, formatNumber, resolveDirection, sheetMm } from "@segnavia/format"
 import { PDFDocument } from "pdf-lib";
 import { bookDocument, bookPrintPart } from "@segnavia/html";
 //#region src/book-pdf.ts
-async function inspect(bytes) {
-	const document = await PDFDocument.load(bytes);
+async function inspect(output) {
+	const document = await PDFDocument.load(output.bytes);
 	return {
-		bytes,
+		bytes: output.bytes,
+		overflow: output.overflow,
 		pages: document.getPageCount(),
 		destinations: namedDestinations(document)
 	};
@@ -127,7 +128,7 @@ async function printBody(book, options, adapter) {
 		targets: true
 	});
 	if (firstDocument.issues.length > 0) throw new RenderRefusedError(`The book cannot be printed: ${firstDocument.issues.join("; ")}.`);
-	let part = await inspect(await adapter.print(firstDocument.html, book, options));
+	let part = await inspect(await adapter.print(firstDocument.html, book, options, "body"));
 	requireTargets(part, hashTargets(firstDocument));
 	const plan = book.rectoOpenings ? planBlanks(firstDocument.sections, part.destinations) : {
 		ids: [],
@@ -139,7 +140,7 @@ async function printBody(book, options, adapter) {
 			targets: true,
 			blankBefore: plan.ids
 		});
-		part = await inspect(await adapter.print(finalDocument.html, book, options));
+		part = await inspect(await adapter.print(finalDocument.html, book, options, "body"));
 		requireTargets(part, hashTargets(finalDocument));
 		verifyStarts("body", sectionsFor(firstDocument.sections, "body"), plan.predicted, part.destinations);
 	}
@@ -169,7 +170,7 @@ async function printFront(book, source, body, options, adapter) {
 			crossLinks: true,
 			pageNumbers: numbers
 		});
-		const printed = await inspect(await adapter.print(document.html, book, options));
+		const printed = await inspect(await adapter.print(document.html, book, options, "front"));
 		if (ids.length === 0) ids.push(...hashTargets(document));
 		requireTargets(printed, ids);
 		prints.push(printed);
@@ -219,8 +220,14 @@ async function renderBookPdf(input, options, adapter) {
 	const bodyBlankPages = new Set(printedBody.blankBefore.map((id) => (printedBody.part.destinations.get(id)?.page ?? 1) - 1));
 	const frontBlankPages = new Set(printedFront.trailingBlank ? [front.pages] : []);
 	const marginPages = [...marginsFor(book, sectionsFor(printedBody.document.sections, "front"), front.destinations, front.pages, 0, frontBlankPages, book.numbering.frontMatter), ...marginsFor(book, sectionsFor(printedBody.document.sections, "body"), printedBody.part.destinations, printedBody.part.pages, front.pages, bodyBlankPages, book.numbering.body)];
-	const marginBytes = await adapter.print(marginDocument(book, marginPages), book, options, true);
-	return adapter.finish(await join(front, printedBody.part, marginBytes), options);
+	const margin = await adapter.print(marginDocument(book, marginPages), book, options, "margin");
+	const output = await adapter.finish(await join(front, printedBody.part, margin.bytes), options);
+	options.overflow?.report?.({ entries: [
+		front.overflow,
+		printedBody.part.overflow,
+		margin.overflow
+	].filter((entry) => entry !== void 0) });
+	return output;
 }
 function bookPageCss(book, marginLayer = false) {
 	if (!book.page) return "";

package/dist/book-render.js

@@ -6,9 +6,10 @@ import { frameDocument, newNonce } from "@segnavia/frame/bridge";
 //#region src/book-render.ts
 function renderBrowserBookPdf(input, options, dependencies) {
 	return renderBookPdf(input, options, {
-		print: (html, book, renderOptions, marginLayer = false) => {
+		print: (html, book, renderOptions, part) => {
 			if (!book.page) throw new RenderRefusedError("Printing a continuous book needs page; set page before calling bookPdf.");
 			const size = sheetMm(book.page);
+			const marginLayer = part === "margin";
 			const css = `${bookPageCss(book, marginLayer)}${marginLayer ? marginCss(book) : ""}${dependencies.fontFaces(renderOptions)}${renderOptions.css ?? ""}`;
 			return dependencies.render({
 				viewport: {
@@ -39,7 +40,7 @@ function renderBrowserBookPdf(input, options, dependencies) {
 					bottom: "0mm",
 					left: "0mm"
 				}
-			});
+			}, Math.round(size.width * PX_PER_MM), part);
 		},
 		finish: dependencies.finish
 	});

package/dist/browser-jpeg.js

@@ -0,0 +1,42 @@
+//#region src/browser-jpeg.ts
+function browserJpegDecoder(tab) {
+	return async (bytes) => {
+		const encoded = Buffer.from(bytes).toString("base64");
+		const decoded = await tab.evaluate(async (base64) => {
+			const binary = atob(base64);
+			const source = Uint8Array.from(binary, (value) => value.charCodeAt(0));
+			const bitmap = await createImageBitmap(new Blob([source], { type: "image/jpeg" }), {
+				colorSpaceConversion: "none",
+				premultiplyAlpha: "none"
+			});
+			try {
+				const context = new OffscreenCanvas(bitmap.width, bitmap.height).getContext("2d");
+				if (!context) throw new Error("Chromium could not create a 2D canvas for JPEG decoding");
+				context.drawImage(bitmap, 0, 0);
+				const rgba = context.getImageData(0, 0, bitmap.width, bitmap.height).data;
+				const rgb = new Uint8Array(bitmap.width * bitmap.height * 3);
+				for (let pixel = 0; pixel < bitmap.width * bitmap.height; pixel++) {
+					rgb[pixel * 3] = rgba[pixel * 4] ?? 0;
+					rgb[pixel * 3 + 1] = rgba[pixel * 4 + 1] ?? 0;
+					rgb[pixel * 3 + 2] = rgba[pixel * 4 + 2] ?? 0;
+				}
+				let value = "";
+				for (let offset = 0; offset < rgb.length; offset += 32768) value += String.fromCharCode(...rgb.subarray(offset, Math.min(rgb.length, offset + 32768)));
+				return {
+					width: bitmap.width,
+					height: bitmap.height,
+					rgb: btoa(value)
+				};
+			} finally {
+				bitmap.close();
+			}
+		}, encoded);
+		return {
+			width: decoded.width,
+			height: decoded.height,
+			rgb: new Uint8Array(Buffer.from(decoded.rgb, "base64"))
+		};
+	};
+}
+//#endregion
+export { browserJpegDecoder };

package/dist/color/black-point.js

@@ -2,7 +2,7 @@ import { checked } from "./types.js";
 import { D50, labToXyz, matrix3, tableDecode, tableEncode, tryInvert3, xyzToLab } from "./spaces.js";
 //#region src/color/black-point.ts
 function detectSourceBlackPoint(colorSpace, pcs, major, relativeA2b, perceptualB2a) {
-	if (colorSpace !== "CMYK") return [
+	if (colorSpace !== "CMYK" && colorSpace !== "GRAY") return [
 		0,
 		0,
 		0
@@ -19,11 +19,12 @@ function detectSourceBlackPoint(colorSpace, pcs, major, relativeA2b, perceptualB
 		checked(result, 2, "black-point A2B result")
 	]);
 	const lab = pcs === "Lab " ? returned : xyzToLab(returned);
-	return [
+	const black = [
 		Math.min(50, lab[0]),
 		0,
 		0
 	];
+	return pcs === "Lab " ? black : labToXyz(black);
 }
 function quadraticRoot(x, y) {
 	if (x.length < 4) return 0;
@@ -61,14 +62,15 @@ function quadraticRoot(x, y) {
 	return discriminant <= 0 ? 0 : Math.max(0, Math.min(50, (-b + Math.sqrt(discriminant)) / (2 * a)));
 }
 function destinationBlackPoint(colorSpace, pcs, major, relativeA2b, relativeB2a, sourceBlack) {
-	if (colorSpace !== "CMYK") return [...sourceBlack];
+	if (colorSpace !== "CMYK" && colorSpace !== "GRAY") return [...sourceBlack];
+	const sourceLab = pcs === "Lab " ? sourceBlack : xyzToLab(sourceBlack);
 	const inputRamp = [], outputRamp = [];
 	for (let index = 0; index < 256; index++) {
 		const lightness = index * 100 / 255;
 		const lab = [
 			lightness,
-			Math.max(-50, Math.min(50, sourceBlack[1])),
-			Math.max(-50, Math.min(50, sourceBlack[2]))
+			Math.max(-50, Math.min(50, sourceLab[1])),
+			Math.max(-50, Math.min(50, sourceLab[2]))
 		];
 		const value = pcs === "Lab " ? lab : labToXyz(lab);
 		const device = relativeB2a.run(tableEncode(pcs, relativeB2a.encoding, major, value, false));
@@ -97,11 +99,12 @@ function destinationBlackPoint(colorSpace, pcs, major, relativeA2b, relativeB2a,
 			y.push(normalized);
 		}
 	}
-	return [
+	const result = [
 		x.length < 3 ? 0 : quadraticRoot(x, y),
-		sourceBlack[1],
-		sourceBlack[2]
+		sourceLab[1],
+		sourceLab[2]
 	];
+	return pcs === "Lab " ? result : labToXyz(result);
 }
 function compensateBlackPoint(profile, lab, reverse) {
 	const point = reverse ? profile.sourceBlackPoint : profile.destinationBlackPoint;

package/dist/color/engine.js

@@ -1,4 +1,4 @@
-import { clamp, color4, refuse } from "./types.js";
+import { clamp, color1, color4, refuse } from "./types.js";
 import { labToXyz, srgbToLab, tableEncode } from "./spaces.js";
 import { compensateBlackPoint } from "./black-point.js";
 //#region src/color/engine.ts
@@ -14,5 +14,12 @@ function toPress(profile, rgb) {
 		clamp(black)
 	];
 }
+function toGray(profile, rgb) {
+	if (profile.colorSpace !== "GRAY") refuse(`destination color space ${profile.colorSpace}`, "GRAY");
+	const lab = compensateBlackPoint(profile, srgbToLab(rgb), false);
+	const pcs = profile.pcs === "Lab " ? lab : labToXyz(lab);
+	const [gray] = color1(profile.b2a.run(tableEncode(profile.pcs, profile.b2a.encoding, profile.majorVersion, pcs, true)), "B2A result");
+	return [clamp(gray)];
+}
 //#endregion
-export { toPress };
+export { toGray, toPress };

package/dist/color/interpolation.js

@@ -34,6 +34,16 @@ function multilinear(grid, points, outputs, input) {
 	}
 	return result;
 }
+function linearGrid(grid, points, outputs, input) {
+	const count = checked(points, 0, "CLUT dimensions");
+	const position = clamp(checked(input, 0, "CLUT input")) * (count - 1);
+	const low = Math.min(count - 2, Math.floor(position));
+	const fraction = position - low;
+	return Array.from({ length: outputs }, (_, channel) => {
+		const lower = grid.get(low * outputs + channel);
+		return lower + (grid.get((low + 1) * outputs + channel) - lower) * fraction;
+	});
+}
 function tetrahedral4(grid, points, outputs, input) {
 	const { base, fractions, stride } = layout(points, outputs, input);
 	const order = [
@@ -71,4 +81,4 @@ function matrixInput(values) {
 	];
 }
 //#endregion
-export { interpolate, matrixInput, multilinear, tetrahedral4 };
+export { interpolate, linearGrid, matrixInput, multilinear, tetrahedral4 };

package/dist/color/profile.js

@@ -1,7 +1,7 @@
 import { REVERSE_LUT, checked, refuse } from "./types.js";
 import { destinationBlackPoint, detectSourceBlackPoint } from "./black-point.js";
 import { fixed, need, signature, u32 } from "./binary.js";
-import { matrixTables, parseMab, parseMft } from "./tables.js";
+import { grayTables, matrixTables, parseMab, parseMft } from "./tables.js";
 //#region src/color/profile.ts
 const MAX_PROFILE_BYTES = 33554432;
 function header(bytes, view, bounds) {
@@ -12,7 +12,7 @@ function header(bytes, view, bounds) {
 	const profileClass = signature(bytes, 12, bounds);
 	if (profileClass !== "prtr" && profileClass !== "mntr") refuse(`profile class ${JSON.stringify(profileClass)}`, "prtr or mntr");
 	const colorSpace = signature(bytes, 16, bounds);
-	if (colorSpace !== "CMYK" && colorSpace !== "RGB ") refuse(`color space ${JSON.stringify(colorSpace)}`, "CMYK or RGB");
+	if (colorSpace !== "CMYK" && colorSpace !== "GRAY" && colorSpace !== "RGB ") refuse(`color space ${JSON.stringify(colorSpace)}`, "CMYK, GRAY, or RGB");
 	const pcs = signature(bytes, 20, bounds);
 	if (pcs !== "Lab " && pcs !== "XYZ ") refuse(`PCS ${JSON.stringify(pcs)}`, "Lab or XYZ");
 	u32(view, 0, bounds);
@@ -55,6 +55,13 @@ function table(bytes, view, all, names, inputs, outputs) {
 	if (!record) throw new Error(`ICC profile is missing ${name} after its tag set was validated`);
 	return recordTable(bytes, view, record, inputs, outputs);
 }
+function optionalTable(bytes, view, all, names, inputs, outputs) {
+	const name = names.find((candidate) => all[candidate]);
+	if (!name) return void 0;
+	const record = all[name];
+	if (!record) throw new Error(`ICC profile is missing ${name} after its tag set was validated`);
+	return recordTable(bytes, view, record, inputs, outputs);
+}
 function readProfile(bytes) {
 	if (bytes.length > 33554432) refuse(`profile length ${bytes.length}`, `at most ${MAX_PROFILE_BYTES} bytes`);
 	const bounds = {
@@ -63,12 +70,15 @@ function readProfile(bytes) {
 	}, view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
 	const parsed = header(bytes, view, bounds), all = records(bytes, view, bounds);
 	if (all.wtpt?.type !== "XYZ ") refuse(`white point tag type ${JSON.stringify(all.wtpt?.type ?? "missing")}`, "XYZ ");
-	const channels = parsed.colorSpace === "CMYK" ? 4 : 3;
+	const channels = parsed.colorSpace === "CMYK" ? 4 : parsed.colorSpace === "GRAY" ? 1 : 3;
 	const matrix = parsed.colorSpace === "RGB " ? matrixTables(bytes, view, all) : void 0;
-	const a2b = matrix?.a2b ?? table(bytes, view, all, ["A2B1", "A2B0"], channels, 3);
-	const b2a = matrix?.b2a ?? table(bytes, view, all, ["B2A1", "B2A0"], 3, channels);
-	const perceptualA2b = matrix?.a2b ?? table(bytes, view, all, ["A2B0", "A2B1"], channels, 3);
-	const perceptualB2a = matrix?.b2a ?? table(bytes, view, all, ["B2A0", "B2A1"], 3, channels);
+	const trcRecord = all.kTRC;
+	const gray = parsed.colorSpace === "GRAY" && trcRecord ? grayTables(bytes, view, trcRecord, parsed.pcs) : void 0;
+	const select = (names, inputs, outputs, fallback) => optionalTable(bytes, view, all, names, inputs, outputs) ?? fallback ?? table(bytes, view, all, names, inputs, outputs);
+	const a2b = matrix?.a2b ?? select(["A2B1", "A2B0"], channels, 3, gray?.a2b);
+	const b2a = matrix?.b2a ?? select(["B2A1", "B2A0"], 3, channels, gray?.b2a);
+	const perceptualA2b = matrix?.a2b ?? select(["A2B0", "A2B1"], channels, 3, gray?.a2b);
+	const perceptualB2a = matrix?.b2a ?? select(["B2A0", "B2A1"], 3, channels, gray?.b2a);
 	const gamutRecord = all.gamt, gamut = gamutRecord ? recordTable(bytes, view, gamutRecord, 3, 1) : void 0;
 	const white = all.wtpt;
 	if (!white) throw new Error("ICC profile is missing wtpt after its tag set was validated");

package/dist/color/tables.js

@@ -1,7 +1,7 @@
 import { REVERSE_LUT, checked, clamp, refuse } from "./types.js";
 import { invert3, matrix3 } from "./spaces.js";
 import { align4, fixed, need, signature, u16, u32 } from "./binary.js";
-import { interpolate, matrixInput, multilinear, tetrahedral4 } from "./interpolation.js";
+import { interpolate, linearGrid, matrixInput, multilinear, tetrahedral4 } from "./interpolation.js";
 //#region src/color/tables.ts
 function packed(bytes, view, offset, length, width, bounds) {
 	need(offset, length * width, bounds);
@@ -73,6 +73,16 @@ function parseCurve(bytes, view, offset, bounds) {
 		size: 12 + count * 4
 	};
 }
+function invertCurve(curve, target) {
+	let low = 0, high = 1;
+	const descending = curve(0) > curve(1);
+	for (let index = 0; index < 24; index++) {
+		const middle = (low + high) / 2;
+		if (descending ? curve(middle) > target : curve(middle) < target) low = middle;
+		else high = middle;
+	}
+	return (low + high) / 2;
+}
 function curvesAt(bytes, view, offset, count, bounds) {
 	const curves = [];
 	let cursor = offset;
@@ -132,7 +142,7 @@ function parseMft(bytes, view, record, type, inputs, outputs) {
 				];
 				current = matrix3(fixedMatrix, matrixInput(current));
 			}
-			current = inputs === 3 ? multilinear(grid, points, outputs, current) : tetrahedral4(grid, points, outputs, current);
+			current = inputs === 1 ? linearGrid(grid, points, outputs, current) : inputs === 3 ? multilinear(grid, points, outputs, current) : tetrahedral4(grid, points, outputs, current);
 			return current.map((value, channel) => interpolate(checked(outputTables, channel, `${type} output tables`), value));
 		}
 	};
@@ -179,7 +189,7 @@ function parseMab(bytes, view, record, type, inputs, outputs) {
 			2
 		].map((row) => checked(matrix, row * 3, `${type} matrix`) * x + checked(matrix, row * 3 + 1, `${type} matrix`) * y + checked(matrix, row * 3 + 2, `${type} matrix`) * z + checked(matrix, 9 + row, `${type} matrix`));
 	};
-	const clut = (values) => !grid ? [...values] : inputs === 3 ? multilinear(grid, points, outputs, values) : tetrahedral4(grid, points, outputs, values);
+	const clut = (values) => !grid ? [...values] : inputs === 1 ? linearGrid(grid, points, outputs, values) : inputs === 3 ? multilinear(grid, points, outputs, values) : tetrahedral4(grid, points, outputs, values);
 	return {
 		inputChannels: inputs,
 		outputChannels: outputs,
@@ -227,15 +237,6 @@ function matrixTables(bytes, view, records) {
 		checked(checked(columns, 2, "colorants"), 2, "blue")
 	];
 	const inverse = invert3(matrix);
-	const invertCurve = (curve, target) => {
-		let low = 0, high = 1;
-		for (let index = 0; index < 24; index++) {
-			const middle = (low + high) / 2;
-			if (curve(middle) < target) low = middle;
-			else high = middle;
-		}
-		return (low + high) / 2;
-	};
 	return {
 		a2b: {
 			inputChannels: 3,
@@ -251,5 +252,38 @@ function matrixTables(bytes, view, records) {
 		}
 	};
 }
+function grayTables(bytes, view, record, pcs) {
+	const curve = parseCurve(bytes, view, record.offset, record).curve;
+	const scale = 32768 / 65535;
+	return {
+		a2b: {
+			inputChannels: 1,
+			outputChannels: 3,
+			encoding: "mAB ",
+			run(input) {
+				const luminance = curve(checked(input, 0, "gray input"));
+				if (pcs === "XYZ ") return [
+					luminance * .9642 * scale,
+					luminance * scale,
+					luminance * .8249 * scale
+				];
+				return [
+					luminance,
+					128 / 255,
+					128 / 255
+				];
+			}
+		},
+		b2a: {
+			inputChannels: 3,
+			outputChannels: 1,
+			encoding: REVERSE_LUT,
+			run(input) {
+				const luminance = pcs === "XYZ " ? checked(input, 1, "gray PCS input") / scale : checked(input, 0, "gray PCS input");
+				return [invertCurve(curve, luminance)];
+			}
+		}
+	};
+}
 //#endregion
-export { matrixTables, parseCurve, parseMab, parseMft };
+export { grayTables, invertCurve, matrixTables, parseCurve, parseMab, parseMft };

package/dist/color/types.js

@@ -8,6 +8,9 @@ function checked(values, index, structure) {
 	if (value === void 0) throw new Error(`${structure} index ${index} is outside length ${values.length}`);
 	return value;
 }
+function color1(values, structure) {
+	return [checked(values, 0, structure)];
+}
 function color4(values, structure) {
 	return [
 		checked(values, 0, structure),
@@ -18,4 +21,4 @@ function color4(values, structure) {
 }
 const clamp = (value) => Math.max(0, Math.min(1, value));
 //#endregion
-export { REVERSE_LUT, checked, clamp, color4, refuse };
+export { REVERSE_LUT, checked, clamp, color1, color4, refuse };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { EffectsReport } from "./effects/types.js";
-import { PressImage, PressReport } from "./press/types.js";
-import { Font, ImageOptions, RenderLimits, RenderOptions } from "./options.js";
+import { PressDestination, PressImage, PressReport } from "./press/types.js";
+import { Font, ImageOptions, OverflowContribution, OverflowEntry, OverflowPart, OverflowReport, RenderLimits, RenderOptions } from "./options.js";
 import { RenderRefusedError, RendererUnavailableError } from "./errors.js";
 import { BookInput, Deck, ImpositionInput, PageInput } from "@segnavia/format";
 import { PrintOptions } from "@segnavia/frame/print-document";
@@ -33,4 +33,4 @@ export declare function fontFaces(fonts?: Font[]): string;
 export declare function captureImage(tab: Page$1, options: Pick<ImageOptions, 'format' | 'quality' | 'limits'>, fullPage: boolean): Promise<Uint8Array>;
 export declare function openRenderer(options: RendererOptions): Promise<Renderer>;
 //#endregion
-export { type EffectsReport, type Font, type ImageOptions, type PressImage, type PressReport, type RenderLimits, type RenderOptions, RenderRefusedError, RendererUnavailableError };
+export { type EffectsReport, type Font, type ImageOptions, type OverflowContribution, type OverflowEntry, type OverflowPart, type OverflowReport, type PressDestination, type PressImage, type PressReport, type RenderLimits, type RenderOptions, RenderRefusedError, RendererUnavailableError };

package/dist/index.js

@@ -1,9 +1,11 @@
 import { RenderRefusedError, RendererUnavailableError } from "./errors.js";
 import { renderBrowserBookPdf } from "./book-render.js";
+import { browserJpegDecoder } from "./browser-jpeg.js";
 import { containFixedPageOverflow } from "./overflow-containment.js";
 import { renderDeckPdf } from "./deck-pdf.js";
 import { assertNeutralTolerance } from "./press/color-policy.js";
 import { rewriteEffectsPdf } from "./effects/adapter.js";
+import { measureOverflow, printWithOverflow } from "./overflow.js";
 import { assertPrintOptions, printCss, printPage, printViewport } from "./page-paper.js";
 import { renderPagesPdf } from "./pages-pdf.js";
 import { rewritePressPdf } from "./press/adapter.js";
@@ -55,7 +57,7 @@ async function enforce(pdf, limits) {
 	}
 	return pdf;
 }
-async function finishPdf(pdf, options) {
+async function finishPdf(pdf, options, decodeJpeg) {
 	if (options.limits?.maxBytes !== void 0 && pdf.byteLength > options.limits.maxBytes) throw new RenderRefusedError(`The PDF is ${pdf.byteLength} bytes; the limit is ${options.limits.maxBytes}.`);
 	let output = pdf;
 	if (options.effects !== false) {
@@ -66,7 +68,7 @@ async function finishPdf(pdf, options) {
 	if (options.press) {
 		const neutralTolerance = options.press.neutralTolerance ?? 3;
 		assertNeutralTolerance(neutralTolerance);
-		const converted = await rewritePressPdf(output, options.press.profile, neutralTolerance);
+		const converted = await rewritePressPdf(output, options.press.profile, neutralTolerance, decodeJpeg);
 		output = converted.bytes;
 		options.press.report?.(converted.report);
 	}
@@ -205,6 +207,18 @@ async function openRenderer(options) {
 			reportHeight: false
 		});
 	}
+	async function finishWithBrowser(pdf, options) {
+		if (!options.press || new TextDecoder().decode(options.press.profile.subarray(16, 20)) !== "GRAY") return finishPdf(pdf, options);
+		return withTab({
+			viewport: {
+				width: 1,
+				height: 1
+			},
+			scripts: true,
+			html: "<!doctype html>",
+			waitForReady: false
+		}, (tab) => finishPdf(pdf, options, browserJpegDecoder(tab)));
+	}
 	function pageViewport(page, width, printing = false) {
 		if (page.print) return printViewport(page.print, printing);
 		if (page.size === "fluid") return {
@@ -217,10 +231,10 @@ async function openRenderer(options) {
 		};
 	}
 	const image = captureImage;
-	async function renderPagePdf(page, opts) {
+	async function renderPagePdf(page, opts, inputIndex) {
 		if (page.print) assertPrintOptions(page.print, opts.preferCssPageSize);
 		const viewport = pageViewport(page, void 0, true);
-		return await withTab({
+		return withTab({
 			viewport,
 			scripts: page.scripts === "sandboxed",
 			html: pageDocument(page, opts, true),
@@ -228,15 +242,26 @@ async function openRenderer(options) {
 			boundMs: opts.boundMs,
 			beforeOutput: opts.beforeOutput
 		}, async (tab) => {
-			if (page.print) return printPage(tab, page.print, opts.preferCssPageSize);
+			if (page.print) return printPage(tab, page.print, opts.preferCssPageSize, inputIndex);
 			const fixedHeight = typeof page.size === "object" && page.size.height !== "auto" ? page.size.height : null;
 			const height = fixedHeight ?? await contentHeight(tab);
-			return tab.pdf({
+			if (fixedHeight !== null) {
+				const overflow = await measureOverflow(tab, viewport.width, "page", inputIndex);
+				return {
+					bytes: await tab.pdf({
+						width: `${viewport.width}px`,
+						height: `${height}px`,
+						printBackground: true
+					}),
+					overflow
+				};
+			}
+			return printWithOverflow(tab, viewport.width, "page", {
 				width: `${viewport.width}px`,
 				height: `${height}px`,
 				printBackground: true,
-				pageRanges: fixedHeight ? void 0 : "1"
-			});
+				pageRanges: "1"
+			}, inputIndex);
 		});
 	}
 	async function renderPiecePdf(page, geometry, css, opts) {
@@ -273,13 +298,16 @@ async function openRenderer(options) {
 	return {
 		bookPdf(input, opts = {}) {
 			return renderBrowserBookPdf(input, opts, {
-				render: (setup, pdf) => withTab(setup, (tab) => tab.pdf(pdf)),
+				render: (setup, pdf, pageWidth, part) => withTab(setup, (tab) => printWithOverflow(tab, pageWidth, part, pdf)),
 				fontFaces: (options) => fontFaces(options.fonts),
-				finish: finishPdf
+				finish: finishWithBrowser
 			});
 		},
 		async pagePdf(input, opts = {}) {
-			return finishPdf(await renderPagePdf(Page.parse(input), opts), opts);
+			const printed = await renderPagePdf(Page.parse(input), opts);
+			const output = await finishWithBrowser(printed.bytes, opts);
+			if (printed.overflow) opts.overflow?.report?.({ entries: [printed.overflow] });
+			return output;
 		},
 		async pageImage(input, opts = {}) {
 			const page = Page.parse(input);
@@ -300,10 +328,10 @@ async function openRenderer(options) {
 		},
 		pagesPdf(inputs, opts = {}) {
 			return renderPagesPdf(inputs, opts, {
-				pagePdf: renderPagePdf,
+				pagePdf: (page, options, inputIndex) => renderPagePdf(page, options, inputIndex),
 				piecePdf: renderPiecePdf,
 				fontFaces: (options) => fontFaces(options.fonts),
-				finish: finishPdf
+				finish: finishWithBrowser
 			});
 		},
 		deckPdf(deck, opts = {}) {
@@ -313,7 +341,7 @@ async function openRenderer(options) {
 					waitForReady: false
 				}, (tab) => tab.pdf(pdf)),
 				fontFaces: (options) => fontFaces(options.fonts),
-				finish: finishPdf
+				finish: finishWithBrowser
 			});
 		},
 		async slideImage(deck, index, opts = {}) {

package/dist/options.d.ts

@@ -2,6 +2,37 @@ import { EffectsReport } from "./effects/types.js";
 import { PressReport } from "./press/types.js";
 import { Page } from "playwright-core";
 //#region src/options.d.ts
+export type OverflowPart = 'page' | 'front' | 'body' | 'margin';
+export interface OverflowContribution {
+  /** A short id or tag-and-class path locating the element. */
+  locator: string;
+  /** Border-box pixels clipped beyond the inline start of the page. */
+  clippedStart: number;
+  /** Border-box pixels clipped beyond the inline end of the page. */
+  clippedEnd: number;
+}
+export interface OverflowEntry {
+  /** Output part printed by this entry. */
+  part: OverflowPart;
+  /** Input position when the public render is pagesPdf. */
+  inputIndex?: number;
+  /** Printable inline width in CSS pixels. */
+  pageWidth: number;
+  /** Greatest document scroll width in CSS pixels. */
+  extent: number;
+  /** Pixels clipped beyond the inline start of the page. */
+  clippedStart: number;
+  /** Pixels clipped beyond the inline end of the page. */
+  clippedEnd: number;
+  /** PDF scale used to preserve the print's true size. */
+  scale: number;
+  /** Up to twenty border boxes that extend beyond the page. */
+  elements: OverflowContribution[];
+}
+export interface OverflowReport {
+  /** Kept prints in output order. */
+  entries: OverflowEntry[];
+}
 export interface Font {
   family: string;
   data: Uint8Array;
@@ -24,6 +55,9 @@ export interface RenderOptions {
   effects?: false | {
     report?: (report: EffectsReport) => void;
   };
+  overflow?: {
+    report?: (report: OverflowReport) => void;
+  };
   press?: {
     profile: Uint8Array;
     neutralTolerance?: number;