@segnavia/render 0.5.0 → 0.7.0

package/dist/overflow.js

@@ -0,0 +1,123 @@
+//#region src/overflow.ts
+/**
+* Chromium's measured maximum print shrink; the 3x overflow demo check fails
+* if it changes. Chromium lays a scaled print out at the narrower width P / s,
+* then shrinks it by at most this factor. The solved scale searches layout
+* widths for the point where rightward content reaches P, and uses this exact
+* cap when it is already reached at the narrowest layout. Rightward generated
+* content in an RTL root is a known limit: neither scroll extent nor element
+* boxes expose it.
+*/
+const CHROMIUM_MAX_SHRINK = 1.5;
+/** Decides the next layout to measure, or the print scale, from measured widths. */
+function solveScale(pageWidth, measurements) {
+	const measured = new Map(measurements.map((measurement) => [measurement.layoutWidth, measurement.contentWidth]));
+	const atPage = measured.get(pageWidth);
+	if (atPage === void 0) return { measure: pageWidth };
+	if (atPage <= pageWidth) return { scale: 1 };
+	const narrowest = Math.ceil(pageWidth / CHROMIUM_MAX_SHRINK);
+	const atNarrowest = measured.get(narrowest);
+	if (atNarrowest === void 0) return { measure: narrowest };
+	if (atNarrowest >= pageWidth) return { scale: CHROMIUM_MAX_SHRINK };
+	let low = narrowest;
+	let high = pageWidth;
+	let lastSatisfied = pageWidth;
+	while (high - low > 1) {
+		const middle = Math.floor((low + high) / 2);
+		const width = measured.get(middle);
+		if (width === void 0) return { measure: middle };
+		if (width >= pageWidth) {
+			high = middle;
+			lastSatisfied = middle;
+		} else low = middle;
+	}
+	return { scale: pageWidth / (measured.get(high) !== void 0 && measured.get(high) >= pageWidth ? high : lastSatisfied) };
+}
+async function measuredOverflow(tab, pageWidth) {
+	return tab.evaluate((width) => {
+		const root = document.documentElement;
+		const extent = Math.max(root.scrollWidth, document.body?.scrollWidth ?? 0);
+		const endOverflow = Math.max(0, extent - root.clientWidth);
+		const rtl = getComputedStyle(root).direction === "rtl";
+		const contributions = [];
+		let clippedStart = 0;
+		let rightOverflow = rtl ? 0 : endOverflow;
+		const locator = (element) => {
+			if (element.id) return `#${CSS.escape(element.id)}`;
+			const parts = [];
+			let current = element;
+			while (current && current !== root && parts.length < 3) {
+				const classes = [...current.classList].slice(0, 2).map((name) => `.${CSS.escape(name)}`).join("");
+				parts.unshift(`${current.localName}${classes}`);
+				current = current.parentElement;
+			}
+			return parts.join(" > ");
+		};
+		for (const element of document.querySelectorAll("*")) {
+			const box = element.getBoundingClientRect();
+			const elementStart = Math.max(0, rtl ? box.right - width : -box.left);
+			const elementEnd = Math.max(0, rtl ? -box.left : box.right - width);
+			clippedStart = Math.max(clippedStart, elementStart);
+			rightOverflow = Math.max(rightOverflow, box.right - width);
+			if ((elementStart > 0 || elementEnd > 0) && contributions.length < 20) contributions.push({
+				locator: locator(element),
+				clippedStart: elementStart,
+				clippedEnd: elementEnd
+			});
+		}
+		return {
+			overflow: {
+				pageWidth: width,
+				extent,
+				clippedStart,
+				clippedEnd: endOverflow,
+				elements: contributions
+			},
+			rightOverflow
+		};
+	}, pageWidth);
+}
+function overflowEntry(measured, scale, part, inputIndex) {
+	return {
+		part,
+		...inputIndex === void 0 ? {} : { inputIndex },
+		...measured.overflow,
+		scale
+	};
+}
+async function measureOverflow(tab, pageWidth, part, inputIndex) {
+	await tab.emulateMedia({ media: "print" });
+	return overflowEntry(await measuredOverflow(tab, pageWidth), 1, part, inputIndex);
+}
+async function printWithOverflow(tab, pageWidth, part, pdf, inputIndex) {
+	await tab.emulateMedia({ media: "print" });
+	const viewport = tab.viewportSize();
+	if (!viewport) throw new Error("The print tab has no viewport.");
+	const measurements = [];
+	let original;
+	let decision = solveScale(pageWidth, measurements);
+	while ("measure" in decision) {
+		await tab.setViewportSize({
+			width: decision.measure,
+			height: viewport.height
+		});
+		const measured = await measuredOverflow(tab, decision.measure);
+		if (decision.measure === pageWidth) original = measured;
+		measurements.push({
+			layoutWidth: decision.measure,
+			contentWidth: decision.measure + measured.rightOverflow
+		});
+		decision = solveScale(pageWidth, measurements);
+	}
+	await tab.setViewportSize(viewport);
+	if (!original) throw new Error("The page-width overflow measurement was not made.");
+	return {
+		bytes: await tab.pdf({
+			...pdf,
+			scale: decision.scale
+		}),
+		overflow: overflowEntry(original, decision.scale, part, inputIndex)
+	};
+}
+//#endregion
+export { CHROMIUM_MAX_SHRINK, measureOverflow, printWithOverflow, solveScale };

package/dist/page-paper.js

@@ -1,5 +1,6 @@
 import { RenderRefusedError } from "./errors.js";
 import { pdfBox, pdfPoint, pt } from "./pdf-geometry.js";
+import { printWithOverflow } from "./overflow.js";
 import { PX_PER_MM, printBoxes, printPadding, printProperties, sheetMm } from "@segnavia/format";
 import { PDFDocument, PDFName, rgb } from "pdf-lib";
 //#region src/page-paper.ts
@@ -56,11 +57,12 @@ async function addPressBoxes(pdf, print) {
 	});
 	return document.save();
 }
-async function printPage(tab, print, preferCssPageSize) {
+async function printPage(tab, print, preferCssPageSize, inputIndex) {
 	if (!usesPressLayout(print)) {
 		const mm = sheetMm(print);
 		const margin = print.margin;
-		return tab.pdf({
+		const pageWidth = Math.round(mm.width * PX_PER_MM);
+		return printWithOverflow(tab, pageWidth, "page", {
 			width: `${mm.width}mm`,
 			height: `${mm.height}mm`,
 			printBackground: true,
@@ -71,10 +73,10 @@ async function printPage(tab, print, preferCssPageSize) {
 				bottom: `${margin.bottom}mm`,
 				left: `${margin.left}mm`
 			} : void 0
-		});
+		}, inputIndex);
 	}
 	const boxes = printBoxes(print);
-	const pdf = await tab.pdf({
+	const printed = await printWithOverflow(tab, Math.round(boxes.bleedBox.width * PX_PER_MM), "page", {
 		width: `${boxes.bleedBox.width}mm`,
 		height: `${boxes.bleedBox.height}mm`,
 		printBackground: true,
@@ -85,10 +87,13 @@ async function printPage(tab, print, preferCssPageSize) {
 			bottom: "0mm",
 			left: "0mm"
 		}
-	});
-	const papers = (await PDFDocument.load(pdf)).getPageCount();
+	}, inputIndex);
+	const papers = (await PDFDocument.load(printed.bytes)).getPageCount();
 	if (papers > 1) throw new RenderRefusedError(`A page with bleed or marks is one printed piece, but the content needs ${papers} papers. Shorten the content, or remove the bleed and marks.`);
-	return addPressBoxes(pdf, print);
+	return {
+		bytes: await addPressBoxes(printed.bytes, print),
+		overflow: printed.overflow
+	};
 }
 //#endregion
 export { assertPrintOptions, printCss, printPage, printViewport };

package/dist/pages-pdf.js

@@ -51,13 +51,16 @@ async function renderPagesPdf(inputs, opts, services) {
 	if (inputs.length === 0) throw new RenderRefusedError("There is nothing to render. Pass at least one page to clear this refusal.");
 	const pages = inputs.map((input) => Page.parse(input));
 	if (!opts.imposition) {
-		const rendered = await Promise.all(pages.map((page) => services.pagePdf(page, {
+		const rendered = await Promise.all(pages.map((page, inputIndex) => services.pagePdf(page, {
 			...opts,
 			effects: false,
 			limits: void 0,
-			press: void 0
-		})));
-		return services.finish(await joinPdfs(rendered), opts);
+			press: void 0,
+			overflow: void 0
+		}, inputIndex)));
+		const output = await services.finish(await joinPdfs(rendered.map((part) => part.bytes)), opts);
+		opts.overflow?.report?.({ entries: rendered.flatMap((part) => part.overflow ? [part.overflow] : []) });
+		return output;
 	}
 	const imposition = Imposition.parse(opts.imposition);
 	if (opts.preferCssPageSize) throw new RenderRefusedError("Pages in an imposition take their size from its paper. Remove preferCssPageSize, or remove the imposition, to clear this refusal.");

package/dist/press/adapter.js

@@ -1,5 +1,5 @@
 import { RenderRefusedError } from "../errors.js";
-import { cachedPressColor, newlySnapsToNeutral, pressColor } from "./color-policy.js";
+import { cachedPressColor, destinationColor, newlySnapsToNeutral, pdfMaskLuminosity, pressDestination } from "./color-policy.js";
 import { groupAction, shadingAction } from "./policy.js";
 import { rewriteContent } from "./content.js";
 import { arrayNumbers, decodeContent, dictionaryOf, nameOf, numberOf, replaceArray, resolvedColorSpace } from "./pdf-objects.js";
@@ -7,6 +7,7 @@ import { walkPressGraph } from "./visitor.js";
 import "../effects/types.js";
 import { replaceType1Function, sampleDomainForUses, shadingDeviceMatrix, shadingDomainOf, shadingSampleGridForUses } from "./sample-shading.js";
 import { readProfile } from "../color/profile.js";
+import { convertSuppliedImage, convertedImageCount, createImageState } from "./image.js";
 import { createPaintedBoundsTracker, recordPatternPaintedBounds } from "./pattern-bounds.js";
 import { inspectPressPdf } from "./report.js";
 import { PDFDict, PDFDocument, PDFHexString, PDFName, PDFRef, PDFString } from "pdf-lib";
@@ -17,12 +18,14 @@ const refuse = (found, supported) => {
 	throw new RenderRefusedError(`The PDF has unsupported ${found}; supported: ${supported}.`);
 };
 const resolved = (state, object) => object instanceof PDFRef ? state.document.context.lookup(object) : object;
-function convertFunction(state, fn, policy) {
+const isGrayMask = (state, mask) => state.destination === "gray" && mask !== "none";
+const converterFor = (state, mask) => isGrayMask(state, mask) ? pdfMaskLuminosity : state.convert;
+function convertFunction(state, fn, policy, mask) {
 	if (policy.action === "refuse") refuse(policy.found, policy.supported);
 	if (!fn) return;
 	if (numberOf(fn, "FunctionType") === 2) {
-		for (const name of ["C0", "C1"]) replaceArray(fn, name, state.convert(arrayNumbers(fn, name, 3)));
-		if (fn.has(key("Range"))) replaceArray(fn, "Range", [
+		for (const name of ["C0", "C1"]) replaceArray(fn, name, converterFor(state, mask)(arrayNumbers(fn, name, 3)));
+		if (fn.has(key("Range"))) replaceArray(fn, "Range", state.destination === "gray" ? [0, 1] : [
 			0,
 			1,
 			0,
@@ -35,7 +38,7 @@ function convertFunction(state, fn, policy) {
 		state.totals.gradientStops += 2;
 		return;
 	}
-	if (fn.has(key("Range"))) replaceArray(fn, "Range", [
+	if (fn.has(key("Range"))) replaceArray(fn, "Range", state.destination === "gray" ? [0, 1] : [
 		0,
 		1,
 		0,
@@ -72,78 +75,81 @@ function shadingUses(state, shading, pattern) {
 	});
 	return uses.filter((use) => use.painted !== void 0);
 }
-function convertType1Shading(state, shading, pattern) {
+function convertType1Shading(state, shading, pattern, mask) {
 	const uses = shadingUses(state, shading, pattern);
 	const domain = sampleDomainForUses(shadingDomainOf(shading), uses);
 	const matrices = uses.length > 0 ? uses.map((use) => use.matrix) : [shadingDeviceMatrix(shading, pattern)];
 	const size = shadingSampleGridForUses(domain, matrices);
-	replaceType1Function(state.document, shading, pattern, state.sampleConvert, state.budget, void 0, domain, size);
+	replaceType1Function(state.document, shading, pattern, isGrayMask(state, mask) ? pdfMaskLuminosity : state.sampleConvert, state.budget, void 0, domain, size, state.destination === "gray" ? 1 : 4);
 }
-function convertShading(state, shading, pattern) {
+function convertShading(state, shading, pattern, mask) {
 	if (state.seenShadings.has(shading)) return false;
 	state.seenShadings.add(shading);
 	const type = numberOf(shading, "ShadingType");
 	const functionType = functionTypeOf(state, shading);
 	const space = resolvedColorSpace(state.document, resolved(state, shading.get(key("ColorSpace"))));
-	const policy = shadingAction(space.kind, type, functionType);
+	const destination = state.destination;
+	const policy = shadingAction(space.kind, type, functionType, destination);
 	if (policy.action === "refuse") {
 		if (type === 1) refuse(`ShadingType 1 FunctionType ${functionType ?? "missing"}`, policy.supported);
 		refuse(`ShadingType ${type ?? "missing"} color space ${space.label}`, policy.supported);
 	}
 	if (policy.action === "keep") return false;
-	if (shading.has(key("Background"))) replaceArray(shading, "Background", state.convert(arrayNumbers(shading, "Background", 3)));
-	shading.set(key("ColorSpace"), key("DeviceCMYK"));
+	if (shading.has(key("Background"))) replaceArray(shading, "Background", converterFor(state, mask)(arrayNumbers(shading, "Background", 3)));
+	shading.set(key("ColorSpace"), key(destination === "gray" ? "DeviceGray" : "DeviceCMYK"));
 	if (type === 1) {
-		convertType1Shading(state, shading, pattern);
+		convertType1Shading(state, shading, pattern, mask);
 		return false;
 	}
 	return true;
 }
-function convertGroup(state, owner, maskSource) {
+function convertGroup(state, owner, mask) {
 	const group = owner.lookupMaybe(key("Group"), PDFDict);
 	if (!group || nameOf(group.get(key("S"))) !== "Transparency" || state.seenGroups.has(group)) return;
 	state.seenGroups.add(group);
 	const space = resolvedColorSpace(state.document, resolved(state, group.get(key("CS"))));
-	const policy = groupAction(space.kind, space.label, maskSource);
+	const destination = state.destination;
+	const policy = groupAction(space.kind, space.label, mask !== "none", destination);
 	if (policy.action === "refuse") refuse(`transparency group color space ${space.label}`, policy.supported);
 	if (policy.action === "convert") {
-		group.set(key("CS"), key("DeviceCMYK"));
+		group.set(key("CS"), key(destination === "gray" ? "DeviceGray" : "DeviceCMYK"));
 		state.totals.groups++;
 	}
 }
-function convertRuleCImage(state, image, width, height, dictionary) {
+function convertRuleCImage(state, image, width, height, dictionary, convert) {
 	const source = decodeContent(image, state.budget);
 	if (source.length !== width * height * 3) refuse("effect image sample length", "three 8-bit RGB samples per pixel");
-	const converted = new Uint8Array(width * height * 4);
+	const channels = state.destination === "gray" ? 1 : 4;
+	const converted = new Uint8Array(width * height * channels);
 	for (let pixel = 0; pixel < width * height; pixel++) {
-		const color = state.convert([
+		const color = convert([
 			(source[pixel * 3] ?? 0) / 255,
 			(source[pixel * 3 + 1] ?? 0) / 255,
 			(source[pixel * 3 + 2] ?? 0) / 255
 		]);
-		for (let channel = 0; channel < 4; channel++) converted[pixel * 4 + channel] = Math.round(Math.max(0, Math.min(1, color[channel] ?? 0)) * 255);
+		for (let channel = 0; channel < channels; channel++) converted[pixel * channels + channel] = Math.round(Math.max(0, Math.min(1, color[channel] ?? 0)) * 255);
 	}
-	dictionary.ColorSpace = key("DeviceCMYK");
+	dictionary.ColorSpace = key(state.destination === "gray" ? "DeviceGray" : "DeviceCMYK");
 	const replacement = state.document.context.stream(deflateSync(converted), dictionary);
 	const reference = state.document.context.getObjectRef(image);
 	if (reference) state.document.context.assign(reference, replacement);
 }
-function convertEffectImage(state, image) {
+function convertEffectImage(state, image, mask) {
 	if (!image.dict.has(key("SegnaviaGeneratedEffect")) || resolvedColorSpace(state.document, resolved(state, image.dict.get(key("ColorSpace")))).kind !== "rgb") return;
 	const width = numberOf(image.dict, "Width") ?? refuse("effect image Width missing", "a positive Width number");
 	const height = numberOf(image.dict, "Height") ?? refuse("effect image Height missing", "a positive Height number");
 	if (width <= 0 || height <= 0) refuse("effect image dimensions", "positive Width and Height numbers");
 	const dictionary = streamDictionary(image);
+	const convert = converterFor(state, mask);
 	if (!image.dict.has(key("SegnaviaEffectColor"))) {
-		convertRuleCImage(state, image, width, height, dictionary);
+		convertRuleCImage(state, image, width, height, dictionary, convert);
 		return;
 	}
-	const source = arrayNumbers(image.dict, "SegnaviaEffectColor", 3);
-	const color = state.convert(source);
+	const color = convert(arrayNumbers(image.dict, "SegnaviaEffectColor", 3));
 	const palette = color.map((value) => Math.round(Math.max(0, Math.min(1, value)) * 255));
 	dictionary.ColorSpace = state.document.context.obj([
 		"Indexed",
-		"DeviceCMYK",
+		state.destination === "gray" ? "DeviceGray" : "DeviceCMYK",
 		0,
 		PDFHexString.of(Buffer.from(palette).toString("hex"))
 	]);
@@ -185,9 +191,10 @@ function recordContentBounds(state, stream, resources, budget) {
 	if (state.sequence) state.sequence.feed(bytes, resolve, resolveGs, resolveShading);
 	else recordPatternPaintedBounds(bytes, resolve, state.painted, resolveGs, resolveShading, state.shadingPainted);
 }
-function convertContent(state, object, stream, setDirect) {
+function convertContent(state, object, stream, setDirect, mask) {
 	const bytes = decodeContent(stream, state.budget);
-	const rewritten = rewriteContent(bytes, state.convert);
+	const destination = state.destination;
+	const rewritten = rewriteContent(bytes, converterFor(state, mask), destination);
 	state.totals.fills += rewritten.counts.fills;
 	state.totals.strokes += rewritten.counts.strokes;
 	const replacement = state.document.context.stream(deflateSync(rewritten.bytes), streamDictionary(stream));
@@ -211,15 +218,16 @@ function newState(document, profile, tolerance) {
 			shadingSamples: 0
 		},
 		convert: (rgb) => {
-			if (newlySnapsToNeutral(rgb, tolerance)) totals.neutralColors++;
+			if (profile.colorSpace === "CMYK" && newlySnapsToNeutral(rgb, tolerance)) totals.neutralColors++;
 			return cached(rgb);
 		},
+		destination: pressDestination(profile),
 		document,
 		painted: /* @__PURE__ */ new WeakMap(),
 		profile,
 		sampleConvert: (rgb) => {
-			if (newlySnapsToNeutral(rgb, tolerance)) totals.neutralColors++;
-			return pressColor(profile, rgb, tolerance);
+			if (profile.colorSpace === "CMYK" && newlySnapsToNeutral(rgb, tolerance)) totals.neutralColors++;
+			return destinationColor(profile, rgb, tolerance);
 		},
 		seenGroups: /* @__PURE__ */ new WeakSet(),
 		seenShadings: /* @__PURE__ */ new WeakSet(),
@@ -235,7 +243,9 @@ function rewritePressDocument(document, profile, tolerance = 3) {
 		beginContentsSequence: () => {
 			state.sequence = createPaintedBoundsTracker(state.painted, state.shadingPainted);
 		},
-		content: (_object, stream, _replace, resources) => recordContentBounds(state, stream, resources, boundsBudget),
+		content: (_object, stream, _replace, resources) => {
+			recordContentBounds(state, stream, resources, boundsBudget);
+		},
 		endContentsSequence: () => {
 			state.sequence = void 0;
 		},
@@ -246,16 +256,16 @@ function rewritePressDocument(document, profile, tolerance = 3) {
 		shading: (shading, pattern) => indexShadingPattern(state, shading, pattern)
 	});
 	walkPressGraph(document, {
-		content: (object, stream, replace) => convertContent(state, object, stream, replace),
-		function: (fn, decision) => convertFunction(state, fn, decision),
-		group: (owner, _stream, maskSource) => convertGroup(state, owner, maskSource),
-		image: (image) => convertEffectImage(state, image),
-		shading: (shading, pattern) => convertShading(state, shading, pattern)
+		content: (object, stream, replace, _resources, mask) => convertContent(state, object, stream, replace, mask),
+		function: (fn, decision, mask) => convertFunction(state, fn, decision, mask),
+		group: (owner, _stream, mask) => convertGroup(state, owner, mask),
+		image: (image, mask) => convertEffectImage(state, image, mask),
+		shading: (shading, pattern, mask) => convertShading(state, shading, pattern, mask)
 	});
 	return state.totals;
 }
-function addOutputIntent(document, profile) {
-	const profileRef = document.context.register(document.context.stream(profile, { N: 4 }));
+function addOutputIntent(document, profile, channels) {
+	const profileRef = document.context.register(document.context.stream(profile, { N: channels }));
 	const intentRef = document.context.register(document.context.obj({
 		Type: "OutputIntent",
 		S: "GTS_PDFX",
@@ -264,16 +274,61 @@ function addOutputIntent(document, profile) {
 	}));
 	document.catalog.set(key("OutputIntents"), document.context.obj([intentRef]));
 }
-async function rewritePressPdf(bytes, profileBytes, tolerance = 3) {
+function replaceSourceImage(document, image, uses, replacement) {
+	const reference = document.context.getObjectRef(image);
+	if (reference) document.context.assign(reference, replacement);
+	else for (const use of uses) use.replace(replacement);
+}
+async function convertImageUses(state, image, uses) {
+	const normal = uses.filter((use) => use.mask === "none");
+	const masks = uses.filter((use) => use.mask !== "none");
+	if (normal.length > 0) {
+		const replacement = await convertSuppliedImage(state, image, "none");
+		if (!replacement) return;
+		replaceSourceImage(state.document, image, normal, replacement);
+	}
+	if (masks.length === 0) return;
+	const replacement = await convertSuppliedImage(state, image, masks[0]?.mask ?? "luminosity");
+	if (!replacement) return;
+	if (normal.length === 0) replaceSourceImage(state.document, image, masks, replacement);
+	else {
+		const reference = state.document.context.getObjectRef(replacement) ?? state.document.context.register(replacement);
+		for (const use of masks) use.replace(reference);
+	}
+}
+async function convertGrayImages(document, profile, decodeJpeg) {
+	const state = createImageState(document, profile, decodeJpeg);
+	const images = [];
+	walkPressGraph(document, {
+		content: () => void 0,
+		function: () => void 0,
+		group: () => void 0,
+		image: (image, mask, replace) => images.push({
+			image,
+			mask,
+			replace
+		}),
+		shading: () => false
+	});
+	const uses = /* @__PURE__ */ new Map();
+	for (const found of images) uses.set(found.image, [...uses.get(found.image) ?? [], found]);
+	for (const [image, found] of uses) await convertImageUses(state, image, found);
+	return convertedImageCount(state);
+}
+async function rewritePressPdf(bytes, profileBytes, tolerance = 3, decodeJpeg) {
 	try {
 		const profile = readProfile(profileBytes);
-		if (profile.colorSpace !== "CMYK") refuse(`press profile color space ${profile.colorSpace}`, "CMYK");
+		if (profile.colorSpace !== "CMYK" && profile.colorSpace !== "GRAY") refuse(`press profile color space ${profile.colorSpace}`, "CMYK or GRAY");
 		const document = await PDFDocument.load(bytes, { updateMetadata: false });
 		const counts = rewritePressDocument(document, profile, tolerance);
-		addOutputIntent(document, profileBytes);
+		let convertedImages = 0;
+		const destination = pressDestination(profile);
+		if (destination === "gray") convertedImages = await convertGrayImages(document, profile, decodeJpeg);
+		addOutputIntent(document, profileBytes, destination === "gray" ? 1 : 4);
 		const output = await document.save({ useObjectStreams: false });
-		const report = await inspectPressPdf(output);
+		const report = await inspectPressPdf(output, destination);
 		report.neutralColors = counts.neutralColors;
+		report.convertedImages = convertedImages;
 		return {
 			bytes: output,
 			report

package/dist/press/color-policy.js

@@ -1,7 +1,13 @@
 import { RenderRefusedError } from "../errors.js";
-import { toPress } from "../color/engine.js";
+import { toGray, toPress } from "../color/engine.js";
 //#region src/press/color-policy.ts
 const NEUTRAL_TOLERANCE = .001;
+function pressDestination(profile) {
+	return profile.colorSpace === "GRAY" ? "gray" : "cmyk";
+}
+function pdfMaskLuminosity([red, green, blue]) {
+	return [.3 * red + .59 * green + .11 * blue];
+}
 function assertNeutralTolerance(value) {
 	if (!Number.isFinite(value) || value < 0 || value > 255) throw new RenderRefusedError(`The press neutral tolerance is ${String(value)}; supported: a finite number from 0 to 255.`);
 }
@@ -21,6 +27,9 @@ function pressColor(profile, rgb, tolerance = 3) {
 	];
 	return toPress(profile, rgb);
 }
+function destinationColor(profile, rgb, tolerance = 3) {
+	return profile.colorSpace === "GRAY" ? toGray(profile, rgb) : pressColor(profile, rgb, tolerance);
+}
 function formatPdfNumber(value) {
 	const rounded = Math.round(value * 1e6) / 1e6;
 	if (Object.is(rounded, -0)) return "0";
@@ -32,10 +41,10 @@ function cachedPressColor(profile, tolerance = 3) {
 		const key = `${tolerance}:${rgb.join(",")}`;
 		const cached = cache.get(key);
 		if (cached) return cached;
-		const converted = pressColor(profile, rgb, tolerance);
+		const converted = destinationColor(profile, rgb, tolerance);
 		cache.set(key, converted);
 		return converted;
 	};
 }
 //#endregion
-export { assertNeutralTolerance, cachedPressColor, formatPdfNumber, newlySnapsToNeutral, pressColor, snapsToNeutral };
+export { assertNeutralTolerance, cachedPressColor, destinationColor, formatPdfNumber, newlySnapsToNeutral, pdfMaskLuminosity, pressColor, pressDestination, snapsToNeutral };

package/dist/press/content.js

@@ -120,7 +120,7 @@ function inlineHeader(source, at) {
 	}
 	return refusal("truncated BI operator", "an ID and EI pair");
 }
-function inlineImageEnd(source, at) {
+function inlineImageEnd(source, at, destination) {
 	const { colorSpace, id, imageMask } = inlineHeader(source, at);
 	const match = /[\0\t\n\f\r ]EI(?=[\0\t\n\f\r ()<>[\]{}/%]|$)/g;
 	match.lastIndex = id;
@@ -129,6 +129,7 @@ function inlineImageEnd(source, at) {
 	const name = colorSpace?.startsWith("/") ? colorSpace.slice(1) : void 0;
 	const policy = inlineImageAction(name, imageMask);
 	if (policy.action === "refuse") refusal(`BI operator with color space ${policy.label}`, policy.supported);
+	if (destination === "gray" && policy.kind === "cmyk") refusal(`BI operator with color space ${policy.label}`, "RGB or gray input for a greyscale press");
 	return end.index + end[0].length;
 }
 function skippedConstruct(source, cursor) {
@@ -144,7 +145,7 @@ function numeric(operands, count, operator) {
 	return operands.map((token) => Number(token.raw));
 }
 function replacement(token, operands, values) {
-	const operator = token.raw === "rg" || token.raw === "g" ? "k" : "K";
+	const operator = values.length === 1 ? token.raw === token.raw.toLowerCase() ? "g" : "G" : token.raw === token.raw.toLowerCase() ? "k" : "K";
 	return {
 		start: operands[0]?.start ?? token.start,
 		end: token.end,
@@ -169,36 +170,43 @@ function replaceGray(token, operands, convert, counts) {
 		gray
 	]));
 }
-function validateSpace(token, operands) {
+function validateSpace(token, operands, destination) {
 	if (operands.length !== 1 || operands[0]?.kind !== "name") refusal(`${token.raw} operator operands`, "one color space name");
 	const name = operands[0].raw.slice(1);
-	const policy = contentOperatorAction(token.raw, false, name);
+	const policy = contentOperatorAction(token.raw, false, name, false, destination);
 	if (policy.action === "refuse") refusal(`${token.raw} operator selecting ${colorSpaceLabel({ name })}`, policy.supported);
 }
-function enforceOperatorPolicy(token, operands, policy) {
+function enforceOperatorPolicy(token, operands, policy, destination) {
 	if (policy.action !== "refuse") return;
 	const operator = token.raw;
 	if (operator === "cs" || operator === "CS") {
-		validateSpace(token, operands);
+		validateSpace(token, operands, destination);
 		return;
 	}
 	if (operator === "sc" || operator === "SC" || operator === "scn" || operator === "SCN") refusal(`${operator} operator with numeric operands`, policy.supported);
-	refusal(`${operator === "g" || operator === "G" ? "gray" : "RGB"} color operator ${operator} after conversion`, policy.supported);
+	refusal(`${operator === "g" || operator === "G" ? "gray" : operator === "k" || operator === "K" ? "CMYK" : "RGB"} color operator ${operator} after conversion`, policy.supported);
 }
-function colorOperator(token, operands, convert, counts, inspect) {
+function colorOperator(token, operands, convert, counts, inspect, destination) {
 	const operator = token.raw;
 	if (!isContentColorOperator(operator)) return void 0;
 	const patternName = operands.length === 1 && operands[0]?.kind === "name";
-	enforceOperatorPolicy(token, operands, contentOperatorAction(operator, inspect, void 0, patternName));
+	enforceOperatorPolicy(token, operands, contentOperatorAction(operator, inspect, void 0, patternName, destination), destination);
 	if (operator === "rg" || operator === "RG") return replaceRgb(token, operands, convert, counts);
-	if (operator === "g" || operator === "G") return replaceGray(token, operands, convert, counts);
-	if (operator === "cs" || operator === "CS") validateSpace(token, operands);
+	if (operator === "g" || operator === "G") {
+		if (inspect && destination === "gray") {
+			numeric(operands, 1, operator);
+			counts[operator === "g" ? "fills" : "strokes"]++;
+			return;
+		}
+		return replaceGray(token, operands, convert, counts);
+	}
+	if (operator === "cs" || operator === "CS") validateSpace(token, operands, destination);
 	else if (operator === "k" || operator === "K") {
 		numeric(operands, 4, operator);
 		counts[operator === "k" ? "fills" : "strokes"]++;
 	}
 }
-function scan(source, convert, inspect, visit, operatorVisit) {
+function scan(source, convert, inspect, destination, visit, operatorVisit) {
 	const counts = {
 		fills: 0,
 		strokes: 0
@@ -218,11 +226,11 @@ function scan(source, convert, inspect, visit, operatorVisit) {
 		}
 		cursor = token.end;
 		if (token.raw === "BI") {
-			cursor = inlineImageEnd(source, cursor);
+			cursor = inlineImageEnd(source, cursor, destination);
 			operands = [];
 		} else if (token.kind === "operator") {
 			operatorVisit?.(token, operands);
-			const found = colorOperator(token, operands, convert, counts, inspect);
+			const found = colorOperator(token, operands, convert, counts, inspect, destination);
 			if (found) visit?.(found);
 			operands = [];
 		} else {
@@ -241,7 +249,7 @@ function visitContentOperations(bytes, visit) {
 		0,
 		0,
 		0
-	], false, void 0, (operator, operands) => {
+	], false, "cmyk", void 0, (operator, operands) => {
 		visit({
 			end: operator.end,
 			operands: operands.flatMap((operand) => operand.kind === "name" || operand.kind === "number" ? [{
@@ -255,14 +263,14 @@ function visitContentOperations(bytes, visit) {
 		});
 	});
 }
-function inspectContent(bytes) {
-	return scan(decoder.decode(bytes), () => refusal("RGB color operator after conversion", "CMYK operators"), true);
+function inspectContent(bytes, destination = "cmyk") {
+	return scan(decoder.decode(bytes), () => refusal("RGB color operator after conversion", `${destination === "gray" ? "gray" : "CMYK"} operators`), true, destination);
 }
-function rewriteContent(bytes, convert) {
+function rewriteContent(bytes, convert, destination = "cmyk") {
 	const source = decoder.decode(bytes);
 	let outputLength = bytes.length;
 	let changed = false;
-	const counts = scan(source, convert, false, (found) => {
+	const counts = scan(source, convert, false, destination, (found) => {
 		changed = true;
 		outputLength += encoder.encode(found.text).length - (found.end - found.start);
 	});
@@ -273,7 +281,7 @@ function rewriteContent(bytes, convert) {
 	const output = new Uint8Array(outputLength);
 	let inputAt = 0;
 	let outputAt = 0;
-	scan(source, convert, false, (found) => {
+	scan(source, convert, false, destination, (found) => {
 		const untouched = bytes.subarray(inputAt, found.start);
 		output.set(untouched, outputAt);
 		outputAt += untouched.length;