@peripheries/renderer 0.17.0 → 0.20.0

package/dist/print.js

@@ -0,0 +1,1391 @@
+//#region packages/renderer/src/print/document-profile.ts
+var bundleName = (bundle) => bundle.label ?? bundle.key ?? "(unkeyed)";
+var DEFAULTS = {
+	profile: null,
+	source: "defaults",
+	maxDepth: void 0,
+	numbering: "ladder"
+};
+var warned$1 = new Set();
+function onceKey(key, emit) {
+	if (warned$1.has(key)) return;
+	warned$1.add(key);
+	emit();
+}
+function warnOnce$1(key, message) {
+	onceKey(key, () => console.warn(message));
+}
+function __clearDocumentProfileWarnings() {
+	warned$1.clear();
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readProfileMap(bundle) {
+	const raw = bundle.documentProfiles;
+	if (raw === void 0) return null;
+	if (!isPlainObject(raw)) {
+		warnOnce$1(`map:${bundleName(bundle)}`, `[document-profile] bundle "${bundleName(bundle)}" exports documentProfiles as a ${Array.isArray(raw) ? "array" : typeof raw}, not an object of profiles — every document resolved against it will fall back to host defaults.`);
+		return null;
+	}
+	return raw;
+}
+function resolveDocumentProfile(registries, profileId) {
+	if (!profileId) return DEFAULTS;
+	const available = [];
+	let shipsProfiles = false;
+	for (const bundle of registries) {
+		const map = readProfileMap(bundle);
+		if (!map) continue;
+		shipsProfiles = true;
+		for (const id of Object.keys(map)) if (!available.includes(id)) available.push(id);
+		const candidate = map[profileId];
+		if (candidate === void 0) continue;
+		if (!isPlainObject(candidate)) {
+			warnOnce$1(`entry:${bundleName(bundle)}:${profileId}`, `[document-profile] bundle "${bundleName(bundle)}" has documentProfiles["${profileId}"] as a ${typeof candidate}, not a profile object — skipping it.`);
+			continue;
+		}
+		return {
+			profile: candidate,
+			source: "bundle",
+			maxDepth: readMaxDepth(candidate, bundleName(bundle)),
+			numbering: candidate.depth?.numbering === "none" ? "none" : "ladder"
+		};
+	}
+	if (registries.length === 0) return DEFAULTS;
+	if (shipsProfiles && available.length === 0) {
+		warnOnce$1(`emptymap:${profileId}`, `[document-profile] the bundle cascade exports documentProfiles but it is EMPTY. This is not a bad profile name — no profile registered at all, so EVERY document will render on host defaults (depth unbounded, numbering 'ladder'), not just the one asking for "${profileId}". Profiles register by import side effect; a module graph that drops that import, or a bundler that shakes it out, produces exactly this. Check the bundle, not the page.`);
+		return DEFAULTS;
+	}
+	if (!shipsProfiles) {
+		if (globalThis.process?.env?.NODE_ENV !== "production") onceKey(`noprofiles:${profileId}`, () => console.debug(`[document-profile] page asks for "${profileId}" but no bundle in the cascade exports documentProfiles — using host defaults (depth unbounded, numbering 'ladder').`));
+		return DEFAULTS;
+	}
+	warnOnce$1(`missing:${profileId}:${available.join(",")}`, `[document-profile] profile "${profileId}" not found; the cascade ships [${available.map((id) => `"${id}"`).join(", ")}]. The document will render with host defaults (depth unbounded, numbering 'ladder'), i.e. in the WRONG document system rather than not at all. Fix the bundle, not the page — the page named a profile.`);
+	return DEFAULTS;
+}
+function readMaxDepth(profile, bundleKey) {
+	const max = profile.depth?.max;
+	if (max === void 0) return void 0;
+	if (typeof max !== "number" || !Number.isInteger(max) || max < 1) {
+		warnOnce$1(`depth:${bundleKey}:${profile.id}`, `[document-profile] profile "${profile.id}" declares depth.max as ${JSON.stringify(max)}, which is not a positive integer — depth will be treated as unbounded.`);
+		return;
+	}
+	return max;
+}
+//#endregion
+//#region packages/renderer/src/print/document-bindings.ts
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function resolveRegionBindings(page) {
+	const declared = asRecord(asRecord(asRecord(page?.metadata)?.document)?.bindings);
+	if (!declared) return {
+		values: {},
+		malformed: []
+	};
+	const values = {};
+	const malformed = [];
+	for (const [key, value] of Object.entries(declared)) if (typeof value === "string" && value.length > 0) values[key] = value;
+	else malformed.push(key);
+	return {
+		values,
+		malformed
+	};
+}
+function resolveProfileId(page) {
+	const layout = asRecord(page?.layout);
+	const metadata = asRecord(page?.metadata);
+	const fromLayout = typeof layout?.profile === "string" ? layout.profile : void 0;
+	const fromMetadata = typeof metadata?.profile === "string" ? metadata.profile : void 0;
+	if (fromMetadata !== void 0 && fromMetadata !== fromLayout) console.warn(`[document-bindings] page declares layout.profile=${JSON.stringify(fromLayout)} and metadata.profile=${JSON.stringify(fromMetadata)}. **layout wins.** These are two copies of one fact and only one is read — delete metadata.profile rather than keeping them in step by hand.`);
+	return fromLayout;
+}
+//#endregion
+//#region packages/renderer/src/print/print-policy.ts
+var BREAK_INSIDE = new Set(["avoid", "auto"]);
+function toCount(value) {
+	if (!/^[1-9][0-9]*$/.test(value)) return void 0;
+	return Number(value);
+}
+function parsePrintPolicy(raw) {
+	const constraints = {};
+	const placements = {};
+	const unrecognised = [];
+	if (!raw || typeof raw !== "object") return {
+		constraints,
+		placements,
+		unrecognised
+	};
+	for (const [key, rawValue] of Object.entries(raw)) {
+		const value = typeof rawValue === "string" ? rawValue : String(rawValue);
+		switch (key) {
+			case "breakInside":
+				if (BREAK_INSIDE.has(value)) constraints.breakInside = value;
+				else unrecognised.push(`${key}=${value}`);
+				break;
+			case "breakAfter":
+			case "breakBefore":
+				if (value === "avoid" || value === "page") constraints[key] = value;
+				else unrecognised.push(`${key}=${value}`);
+				break;
+			case "orphans":
+			case "widows": {
+				const n = toCount(value);
+				if (n === void 0) unrecognised.push(`${key}=${value}`);
+				else constraints[key] = n;
+				break;
+			}
+			case "atomic":
+				if (value === "true") constraints.atomic = true;
+				else if (value === "false") constraints.atomic = false;
+				else unrecognised.push(`${key}=${value}`);
+				break;
+			case "region":
+				if (value === "page-footer") placements.region = "page-footer";
+				else unrecognised.push(`${key}=${value}`);
+				break;
+			case "display":
+				if (value === "none") placements.display = "none";
+				else unrecognised.push(`${key}=${value}`);
+				break;
+			default: unrecognised.push(`${key}=${value}`);
+		}
+	}
+	return {
+		constraints,
+		placements,
+		unrecognised
+	};
+}
+function composeConstraints(chain) {
+	const out = {};
+	for (const link of chain) {
+		if (!link) continue;
+		if (link.breakInside === "avoid") out.breakInside = "avoid";
+		else if (link.breakInside === "auto" && out.breakInside === void 0) out.breakInside = "auto";
+		if (link.breakAfter) out.breakAfter = out.breakAfter === "page" ? "page" : link.breakAfter;
+		if (link.breakBefore) out.breakBefore = out.breakBefore === "page" ? "page" : link.breakBefore;
+		if (typeof link.orphans === "number") out.orphans = Math.max(out.orphans ?? 0, link.orphans);
+		if (typeof link.widows === "number") out.widows = Math.max(out.widows ?? 0, link.widows);
+		if (link.atomic) out.atomic = true;
+	}
+	if (out.atomic) out.breakInside = "avoid";
+	return out;
+}
+function resolvePlacement(chain) {
+	const out = {};
+	for (const link of chain) {
+		if (!link) continue;
+		if (link.display === "none") out.display = "none";
+		if (link.region) out.region = link.region;
+	}
+	return out;
+}
+function printPolicyToStyle(constraints, placements) {
+	const style = {};
+	if (placements?.display === "none") {
+		style.display = "none";
+		return style;
+	}
+	if (constraints.atomic) style.breakInside = "avoid";
+	if (constraints.breakInside === "avoid") style.breakInside = "avoid";
+	if (constraints.breakAfter) style.breakAfter = constraints.breakAfter;
+	if (constraints.breakBefore) style.breakBefore = constraints.breakBefore;
+	if (typeof constraints.orphans === "number") style.orphans = constraints.orphans;
+	if (typeof constraints.widows === "number") style.widows = constraints.widows;
+	return style;
+}
+var PRINT_POLICY_ATTR = "data-oa-print-policy";
+function serializeConstraints(c) {
+	if (!c) return "";
+	const parts = [];
+	if (c.atomic) parts.push("atomic=true");
+	if (c.breakInside) parts.push(`breakInside=${c.breakInside}`);
+	if (c.breakBefore) parts.push(`breakBefore=${c.breakBefore}`);
+	if (c.breakAfter) parts.push(`breakAfter=${c.breakAfter}`);
+	if (typeof c.orphans === "number") parts.push(`orphans=${c.orphans}`);
+	if (typeof c.widows === "number") parts.push(`widows=${c.widows}`);
+	return parts.join(";");
+}
+function deserializeConstraints(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	if (trimmed === "") return void 0;
+	const raw = {};
+	for (const pair of trimmed.split(";")) {
+		const eq = pair.indexOf("=");
+		if (eq <= 0) continue;
+		raw[pair.slice(0, eq).trim()] = pair.slice(eq + 1).trim();
+	}
+	const { constraints } = parsePrintPolicy(raw);
+	return Object.keys(constraints).length > 0 ? constraints : void 0;
+}
+//#endregion
+//#region packages/renderer/src/print/page-map.ts
+function collectBlocks(root, printWidthPx, { measureRect, readConstraints, boxFor = defaultBoxFor, selector = "[data-cell-id]", sectionStart, blankBefore }) {
+	if (!root) return {
+		blocks: [],
+		bands: [],
+		sections: [],
+		measuredWidthPx: 0,
+		approximate: true,
+		zeroHeightIds: [],
+		reconciles: false,
+		reconciliation: {
+			modelPx: 0,
+			containerPx: 0,
+			leadingPx: 0
+		}
+	};
+	const rootRect = measureRect(root);
+	const measuredWidthPx = Math.round(rootRect.width);
+	const boxes = [];
+	const zeroHeightIds = [];
+	const openers = new Map();
+	for (const cell of Array.from(root.querySelectorAll(selector))) {
+		const id = cell.getAttribute("data-cell-id");
+		if (!id) continue;
+		const box = boxFor(cell);
+		const rect = measureRect(box);
+		if (Math.round(rect.height) === 0) zeroHeightIds.push(id);
+		const constraints = readConstraints?.(box);
+		const title = sectionStart?.(cell, constraints);
+		if (title !== void 0) openers.set(id, title);
+		boxes.push({
+			id,
+			rect,
+			constraints
+		});
+	}
+	const sorted = [...boxes].sort((a, b) => a.rect.top - b.rect.top || a.rect.bottom - b.rect.bottom);
+	const bands = [];
+	let openBottom = -Infinity;
+	for (const box of sorted) {
+		const top = box.rect.top;
+		const bottom = box.rect.bottom;
+		const open = bands[bands.length - 1];
+		if (open && top < openBottom) {
+			open.members.push(box.id);
+			open.id = open.members.join("+");
+			openBottom = Math.max(openBottom, bottom);
+			open.heightPx = Math.round(openBottom - rootRect.top - open.topPx);
+			open.constraints = mergeBandConstraints(open.constraints, box.constraints);
+		} else {
+			bands.push({
+				id: box.id,
+				members: [box.id],
+				topPx: Math.round(top - rootRect.top),
+				heightPx: Math.round(bottom - top),
+				constraints: box.constraints
+			});
+			openBottom = bottom;
+		}
+	}
+	const gapBelow = (i) => {
+		const next = bands[i + 1];
+		if (!next) return 0;
+		const band = bands[i];
+		return next.topPx - (band.topPx + band.heightPx);
+	};
+	const sections = [];
+	const sectionOfBand = new Map();
+	let currentSection;
+	for (const band of bands) {
+		for (const member of band.members) {
+			const title = openers.get(member);
+			if (title !== void 0) {
+				currentSection = member;
+				sections.push({
+					cellId: member,
+					title
+				});
+				break;
+			}
+		}
+		if (currentSection !== void 0) sectionOfBand.set(band.id, currentSection);
+	}
+	const blocks = bands.map((band, i) => ({
+		id: band.id,
+		heightPx: band.heightPx + gapBelow(i),
+		constraints: band.constraints,
+		...sectionOfBand.has(band.id) ? { sectionId: sectionOfBand.get(band.id) } : {},
+		...band.members.some((m) => blankBefore?.(m)) ? { blankPageBefore: true } : {}
+	}));
+	const leadingPx = bands.length > 0 ? bands[0].topPx : 0;
+	const modelPx = Math.round(leadingPx + blocks.reduce((s, b) => s + b.heightPx, 0));
+	const containerPx = Math.round(rootRect.height);
+	return {
+		blocks,
+		bands,
+		sections,
+		measuredWidthPx,
+		...Math.abs(measuredWidthPx - printWidthPx) <= 1 ? {} : { approximate: true },
+		zeroHeightIds,
+		reconciles: Math.abs(modelPx - containerPx) <= Math.max(1, bands.length),
+		reconciliation: {
+			modelPx,
+			containerPx,
+			leadingPx
+		}
+	};
+}
+function defaultBoxFor(cell) {
+	return cell.parentElement ?? cell;
+}
+function mergeBandConstraints(a, b) {
+	if (!a) return b;
+	if (!b) return a;
+	const out = { ...a };
+	if (a.breakInside === "avoid" || b.breakInside === "avoid") out.breakInside = "avoid";
+	else if (a.breakInside === "auto" || b.breakInside === "auto") out.breakInside = "auto";
+	out.breakAfter = strictestEdge(a.breakAfter, b.breakAfter);
+	out.breakBefore = strictestEdge(a.breakBefore, b.breakBefore);
+	if (out.breakAfter === void 0) delete out.breakAfter;
+	if (out.breakBefore === void 0) delete out.breakBefore;
+	if (a.atomic || b.atomic) out.atomic = true;
+	return out;
+}
+function strictestEdge(a, b) {
+	if (a === "page" || b === "page") return "page";
+	if (a === "avoid" || b === "avoid") return "avoid";
+}
+function constraintsFromComputedStyle(cs) {
+	const out = {};
+	if (cs.breakInside === "avoid") out.breakInside = "avoid";
+	const after = asEdge(cs.breakAfter);
+	const before = asEdge(cs.breakBefore);
+	if (after) out.breakAfter = after;
+	if (before) out.breakBefore = before;
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function constraintsFromBox(el, computed) {
+	const declared = deserializeConstraints(el.getAttribute(PRINT_POLICY_ATTR));
+	if (declared) return declared;
+	return constraintsFromComputedStyle(computed());
+}
+function forcedBreaksWithin(box, styleOf) {
+	const out = {};
+	for (let el = box.children[0]; el; el = el.children[0]) if (asEdge(styleOf(el).breakBefore) === "page") out.breakBefore = "page";
+	for (let el = box.children[box.children.length - 1]; el; el = el.children[el.children.length - 1]) if (asEdge(styleOf(el).breakAfter) === "page") out.breakAfter = "page";
+	return out;
+}
+function withForcedBreaks(constraints, forced) {
+	if (!forced.breakBefore && !forced.breakAfter) return constraints;
+	return {
+		...constraints,
+		...forced
+	};
+}
+function asEdge(v) {
+	if (v === "page" || v === "always" || v === "left" || v === "right") return "page";
+	if (v === "avoid") return "avoid";
+}
+function constraintsResolver(policyFor) {
+	return (componentName) => {
+		if (!componentName) return void 0;
+		const own = policyFor(componentName);
+		if (!own) return void 0;
+		return composeConstraints([own]);
+	};
+}
+var UNIT_PX = {
+	px: 1,
+	in: 96,
+	cm: 96 / 2.54,
+	mm: 96 / 25.4,
+	q: 96 / 101.6,
+	pt: 96 / 72,
+	pc: 16
+};
+function cssLengthToPx(value) {
+	if (typeof value !== "string") return null;
+	const v = value.trim().toLowerCase();
+	if (v === "0") return 0;
+	const m = /^(-?(?:\d+\.?\d*|\.\d+))([a-z]+)$/.exec(v);
+	if (!m) return null;
+	const factor = UNIT_PX[m[2]];
+	if (factor === void 0) return null;
+	const n = Number(m[1]) * factor;
+	return Number.isFinite(n) ? n : null;
+}
+function paperGeometryPx(sheet, margins, columns) {
+	const w = cssLengthToPx(sheet?.width);
+	const h = cssLengthToPx(sheet?.height);
+	const t = cssLengthToPx(margins?.top);
+	const r = cssLengthToPx(margins?.right);
+	const b = cssLengthToPx(margins?.bottom);
+	const l = cssLengthToPx(margins?.left);
+	if ([
+		w,
+		h,
+		t,
+		r,
+		b,
+		l
+	].some((x) => x === null)) return null;
+	const textBlockPx = Math.floor(h - t - b);
+	const pageBoxWidthPx = Math.floor(w - l - r);
+	if (textBlockPx <= 0 || pageBoxWidthPx <= 0) return null;
+	const isColumn = columns?.rail?.placement === "column";
+	const railRaw = isColumn ? cssLengthToPx(columns?.rail?.width) : null;
+	const gutterRaw = isColumn ? cssLengthToPx(columns?.rail?.gutter) : null;
+	const railPx = railRaw !== null && railRaw > 0 ? Math.floor(railRaw) : 0;
+	const gutterPx = railPx > 0 && gutterRaw !== null && gutterRaw > 0 ? Math.floor(gutterRaw) : 0;
+	const measureRaw = cssLengthToPx(columns?.measure);
+	const measurePx = measureRaw !== null && measureRaw > 0 ? Math.floor(measureRaw) : null;
+	const printWidthPx = measurePx !== null && measurePx <= pageBoxWidthPx ? measurePx : pageBoxWidthPx;
+	return {
+		textBlockPx,
+		printWidthPx,
+		pageBoxWidthPx,
+		railPx,
+		gutterPx,
+		columnsReconcile: railPx === 0 || printWidthPx + gutterPx + railPx === pageBoxWidthPx
+	};
+}
+//#endregion
+//#region packages/renderer/src/print/paginate.ts
+function mayNotSplit(c) {
+	if (!c) return true;
+	if (c.atomic) return true;
+	if (c.breakInside === "avoid") return true;
+	if (c.breakInside === "auto") return false;
+	if (typeof c.orphans === "number" || typeof c.widows === "number") return false;
+	return true;
+}
+function paginate(blocks, { textBlockPx, keepWithNextScaleFloor = .6, sectionFillRatio = .5 }) {
+	const pages = [];
+	const overflows = [];
+	if (!Number.isFinite(textBlockPx) || textBlockPx <= 0) {
+		const total = blocks.reduce((s, b) => s + b.heightPx, 0);
+		return {
+			pages: [{
+				index: 1,
+				blocks: blocks.map((b) => ({
+					id: b.id,
+					heightPx: b.heightPx
+				})),
+				usedPx: total,
+				wastePx: 0
+			}],
+			overflows: [],
+			idealPages: 0,
+			degenerateGeometry: true
+		};
+	}
+	let current = {
+		index: 1,
+		blocks: [],
+		usedPx: 0,
+		wastePx: textBlockPx
+	};
+	const commit = () => {
+		pages.push({
+			...current,
+			wastePx: Math.max(0, textBlockPx - current.usedPx)
+		});
+		current = {
+			index: current.index + 1,
+			blocks: [],
+			usedPx: 0,
+			wastePx: textBlockPx
+		};
+	};
+	const breakPage = () => {
+		if (current.blocks.length > 0) commit();
+	};
+	const peekTrailingKeeps = (mayEmptyPage = false) => {
+		const out = [];
+		let i = current.blocks.length - 1;
+		const floor = mayEmptyPage ? 0 : 1;
+		while (i >= floor) {
+			const blk = current.blocks[i];
+			if (blk.continues || blk.spansPages) break;
+			if (!keepWithNext.has(blk.id)) break;
+			out.unshift(blk);
+			i -= 1;
+		}
+		return out;
+	};
+	const takeTrailing = (count) => {
+		const carried = [];
+		for (let i = 0; i < count; i += 1) {
+			const last = current.blocks.pop();
+			if (!last) break;
+			current.usedPx -= last.heightPx;
+			carried.unshift(last);
+		}
+		return carried;
+	};
+	const keepWithNext = new Set(blocks.filter((b) => b.constraints?.breakAfter === "avoid").map((b) => b.id));
+	const sectionOpeners = new Set();
+	if (sectionFillRatio > 0) {
+		const threshold = textBlockPx * sectionFillRatio;
+		let openerId;
+		let runId;
+		let runHeight = 0;
+		const closeRun = () => {
+			if (openerId !== void 0 && runHeight >= threshold) sectionOpeners.add(openerId);
+		};
+		for (const b of blocks) {
+			if (b.sectionId !== runId) {
+				closeRun();
+				runId = b.sectionId;
+				openerId = b.sectionId === void 0 ? void 0 : b.id;
+				runHeight = 0;
+			}
+			runHeight += b.heightPx;
+		}
+		closeRun();
+	}
+	for (const b of blocks) {
+		const c = b.constraints;
+		if (b.blankPageBefore) {
+			breakPage();
+			pages.push({
+				index: current.index,
+				blocks: [],
+				usedPx: 0,
+				wastePx: textBlockPx,
+				blank: true
+			});
+			current = {
+				index: current.index + 1,
+				blocks: [],
+				usedPx: 0,
+				wastePx: textBlockPx
+			};
+		}
+		if (c?.breakBefore === "page") breakPage();
+		if (sectionOpeners.has(b.id) && c?.breakBefore !== "avoid") breakPage();
+		const isHeadingThatFits = c?.breakAfter === "avoid" && b.heightPx <= textBlockPx;
+		const unsplittable = mayNotSplit(c) || isHeadingThatFits;
+		if (b.heightPx > textBlockPx && unsplittable) {
+			const candidates = peekTrailingKeeps(true);
+			const availableIfKept = textBlockPx - candidates.reduce((sum, k) => sum + k.heightPx, 0);
+			const bring = candidates.length > 0 && availableIfKept / b.heightPx >= keepWithNextScaleFloor;
+			const carried = bring ? takeTrailing(candidates.length) : [];
+			breakPage();
+			for (const k of carried) {
+				current.blocks.push(k);
+				current.usedPx += k.heightPx;
+			}
+			current.blocks.push({
+				id: b.id,
+				heightPx: b.heightPx
+			});
+			current.usedPx += b.heightPx;
+			overflows.push({
+				id: b.id,
+				heightPx: b.heightPx,
+				textBlockPx,
+				excessPx: b.heightPx - textBlockPx,
+				availablePx: bring ? availableIfKept : textBlockPx
+			});
+			commit();
+			continue;
+		}
+		const keepsWithPrevious = c?.breakBefore === "avoid" && current.blocks.length > 0;
+		let remaining = textBlockPx - current.usedPx;
+		if (b.heightPx > remaining && !keepsWithPrevious) {
+			if (unsplittable) {
+				const carried = takeTrailing(peekTrailingKeeps(current.blocks.length > 0 && current.blocks.every((x) => keepWithNext.has(x.id) && !x.continues && !x.spansPages)).length);
+				breakPage();
+				for (const k of carried) {
+					current.blocks.push(k);
+					current.usedPx += k.heightPx;
+				}
+				current.blocks.push({
+					id: b.id,
+					heightPx: b.heightPx
+				});
+				current.usedPx += b.heightPx;
+			} else {
+				if (remaining <= 0) {
+					commit();
+					remaining = textBlockPx;
+				}
+				if (b.heightPx <= remaining) {
+					current.blocks.push({
+						id: b.id,
+						heightPx: b.heightPx
+					});
+					current.usedPx += b.heightPx;
+					if (c?.breakAfter === "page") breakPage();
+					continue;
+				}
+				const overhang = b.heightPx - remaining;
+				const extra = Math.ceil(overhang / textBlockPx);
+				current.blocks.push({
+					id: b.id,
+					heightPx: remaining,
+					totalHeightPx: b.heightPx,
+					spansPages: extra + 1
+				});
+				current.usedPx = textBlockPx;
+				commit();
+				for (let i = 1; i < extra; i++) {
+					current.blocks.push({
+						id: b.id,
+						heightPx: textBlockPx,
+						totalHeightPx: b.heightPx,
+						continues: true
+					});
+					current.usedPx = textBlockPx;
+					commit();
+				}
+				const remainder = overhang - (extra - 1) * textBlockPx;
+				if (remainder > 0) {
+					current.blocks.push({
+						id: b.id,
+						heightPx: remainder,
+						totalHeightPx: b.heightPx,
+						continues: true
+					});
+					current.usedPx = remainder;
+				}
+			}
+		} else {
+			current.blocks.push({
+				id: b.id,
+				heightPx: b.heightPx
+			});
+			current.usedPx += b.heightPx;
+		}
+		if (c?.breakAfter === "page") breakPage();
+	}
+	if (current.blocks.length > 0 || pages.length === 0) commit();
+	const total = blocks.reduce((s, b) => s + b.heightPx, 0);
+	return {
+		pages,
+		overflows,
+		idealPages: textBlockPx > 0 ? Number((total / textBlockPx).toFixed(2)) : 0
+	};
+}
+//#endregion
+//#region packages/renderer/src/print/running-header.ts
+function resolveRunningValues(map, bands, markers) {
+	const markerByCell = new Map(markers.map((m) => [m.cellId, m]));
+	const cellsOfBand = new Map(bands.map((b) => [b.id, b.members]));
+	const out = [];
+	let current;
+	let startedOnPage = 0;
+	for (const page of map.pages) {
+		const atPageTop = current;
+		const topStartedEarlier = !!atPageTop && startedOnPage < page.index;
+		for (const block of page.blocks) {
+			if (block.continues) continue;
+			for (const cellId of cellsOfBand.get(block.id) ?? []) {
+				const marker = markerByCell.get(cellId);
+				if (marker) {
+					current = marker;
+					startedOnPage = page.index;
+				}
+			}
+		}
+		const opensWithHeading = startedOnPage === page.index && firstRowIsMarker(page, cellsOfBand, markerByCell);
+		const heading = opensWithHeading ? current : atPageTop;
+		const continued = opensWithHeading ? false : topStartedEarlier;
+		out.push({
+			page: page.index,
+			sectionTitle: heading?.title,
+			continued: !!heading && continued
+		});
+	}
+	return out;
+}
+function firstRowIsMarker(page, cellsOfBand, markerByCell) {
+	const first = page.blocks.find((b) => !b.continues);
+	if (!first) return false;
+	return (cellsOfBand.get(first.id) ?? []).some((c) => markerByCell.has(c));
+}
+var RUNNING_SLOTS = ["section-title", "section-title-continued"];
+function isRunningSlot(name) {
+	return RUNNING_SLOTS.includes(name);
+}
+function runningSlotValues(values, { continuedSuffix = " (continued)" } = {}) {
+	if (!values.sectionTitle) return {};
+	return {
+		"section-title": values.sectionTitle,
+		"section-title-continued": values.continued ? `${values.sectionTitle}${continuedSuffix}` : values.sectionTitle
+	};
+}
+//#endregion
+//#region packages/renderer/src/print/print-stylesheet.ts
+var warned = new Set();
+function warnOnce(key, message) {
+	if (warned.has(key)) return;
+	warned.add(key);
+	console.warn(message);
+}
+function __clearPrintStylesheetWarnings() {
+	warned.clear();
+}
+var BUILT_IN_SLOTS = {
+	"page-x-of-y": "counter(page) \" of \" counter(pages)",
+	"page-number": "counter(page)",
+	"page-count": "counter(pages)"
+};
+function checkPaginatorBindings(bindings, debugLabel) {
+	if (bindings === void 0) return [];
+	if (!Array.isArray(bindings)) {
+		warnOnce(`paginator-shape:${debugLabel}`, `[print-stylesheet] "${debugLabel}" exports PAGINATOR_BINDINGS as a ${typeof bindings}, not an array — the host cannot cross-check its paginator vocabulary against this bundle.`);
+		return [];
+	}
+	const unknown = bindings.filter((b) => typeof b === "string" && !Object.prototype.hasOwnProperty.call(BUILT_IN_SLOTS, b));
+	if (unknown.length > 0) warnOnce(`paginator-unknown:${debugLabel}:${unknown.join(",")}`, `[print-stylesheet] "${debugLabel}" declares paginator binding(s) ${unknown.map((b) => `"${b}"`).join(", ")} that the host has no CSS expression for. A profile placing one in a margin box will render NOTHING there, silently — the host must not supply a paginator binding, so it cannot fall back to a value. Add an expression to BUILT_IN_SLOTS in packages/renderer/src/print/print-stylesheet.ts. Host knows: ${Object.keys(BUILT_IN_SLOTS).join(", ")}.`);
+	return unknown;
+}
+var DEFAULT_SHEET = {
+	width: "8.5in",
+	height: "11in"
+};
+var DEFAULT_MARGINS = {
+	top: "0.75in",
+	right: "0.75in",
+	bottom: "0.75in",
+	left: "0.75in"
+};
+var REGION_EDGE = {
+	"page-header": "top",
+	"page-footer": "bottom"
+};
+var SLOT_SIDE = {
+	left: "left",
+	centre: "center",
+	right: "right"
+};
+function cssString(value) {
+	return `"${value.replace(/[\\"<>\u0000-\u001f\u007f]/g, (c) => `\\${c.charCodeAt(0).toString(16).toUpperCase()} `)}"`;
+}
+function cssValue(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return String(value);
+	if (typeof value !== "string") return void 0;
+	const v = value.trim();
+	return v.length > 0 && v.length <= 120 && /^[#a-zA-Z0-9.,%()\-_/ ]+$/.test(v) ? v : void 0;
+}
+var cssName = (name) => /^[a-z][a-z0-9-]{0,40}$/i.test(name) ? name : null;
+var MissingRequiredBindingError = class extends Error {
+	profileId;
+	missing;
+	constructor(profileId, missing) {
+		super(`[print-stylesheet] refusing to build a page stylesheet for profile "${profileId ?? "(none)"}": required binding(s) ${missing.map((m) => `"${m}"`).join(", ")} could not be filled. The profile declares these as required because a document missing them is not merely incomplete — it states something false about itself. Supply them via \`values\`, or pass \`strict: false\` if this render is not paper.`);
+		this.name = "MissingRequiredBindingError";
+		this.profileId = profileId;
+		this.missing = missing;
+	}
+};
+function buildPageStylesheet(profile, options = {}) {
+	const { values = {}, debugLabel, strict = true } = options;
+	const label = debugLabel ?? profile?.id ?? "(no profile)";
+	const sheetIn = profile?.sheet ?? DEFAULT_SHEET;
+	const marginsIn = profile?.margins ?? DEFAULT_MARGINS;
+	const sheet = {
+		width: cssValue(sheetIn.width) ?? DEFAULT_SHEET.width,
+		height: cssValue(sheetIn.height) ?? DEFAULT_SHEET.height
+	};
+	const margins = {
+		top: cssValue(marginsIn.top) ?? DEFAULT_MARGINS.top,
+		right: cssValue(marginsIn.right) ?? DEFAULT_MARGINS.right,
+		bottom: cssValue(marginsIn.bottom) ?? DEFAULT_MARGINS.bottom,
+		left: cssValue(marginsIn.left) ?? DEFAULT_MARGINS.left
+	};
+	const unresolvedSlots = [];
+	const lines = [
+		"@media print {",
+		"  html, body {",
+		"    -webkit-print-color-adjust: exact;",
+		"    print-color-adjust: exact;",
+		"  }",
+		"}",
+		"",
+		"@page {",
+		`  size: ${sheet.width} ${sheet.height};`,
+		`  margin: ${margins.top} ${margins.right} ${margins.bottom} ${margins.left};`
+	];
+	for (const [regionName, slots] of Object.entries(profile?.regions ?? {})) {
+		const edge = REGION_EDGE[regionName];
+		if (!edge) {
+			warnOnce(`region:${label}:${regionName}`, `[print-stylesheet] "${label}" declares region "${regionName}", which maps to no @page margin box. Known: ${Object.keys(REGION_EDGE).join(", ")}.`);
+			continue;
+		}
+		if (!slots) continue;
+		for (const [slotKey, slotName] of Object.entries(slots)) {
+			if (!slotName) continue;
+			const side = SLOT_SIDE[slotKey];
+			if (!side) {
+				warnOnce(`slotkey:${label}:${regionName}:${String(slotKey)}`, `[print-stylesheet] "${label}" region "${regionName}" declares slot "${String(slotKey)}", which is not a margin-box position and was DROPPED. Known: ${Object.keys(SLOT_SIDE).join(", ")} — note the British "centre", which the host maps to CSS "center".`);
+				continue;
+			}
+			if (isRunningSlot(slotName)) continue;
+			const builtIn = BUILT_IN_SLOTS[slotName];
+			const supplied = values[slotName];
+			let content;
+			if (builtIn) content = builtIn;
+			else if (typeof supplied === "string" && supplied.length > 0) content = cssString(supplied);
+			else {
+				unresolvedSlots.push(slotName);
+				continue;
+			}
+			lines.push(`  @${edge}-${side} {`);
+			lines.push(`    content: ${content};`);
+			lines.push("    font: var(--oa-doc-margin-font, 8pt/1.2 Inter, system-ui, sans-serif);");
+			lines.push("    color: var(--oa-doc-margin-ink, rgba(0,0,0,0.45));");
+			lines.push("  }");
+		}
+	}
+	lines.push("}");
+	const missingRequired = (profile?.requiredBindings ?? []).filter((b) => unresolvedSlots.includes(b));
+	if (missingRequired.length > 0 && strict) throw new MissingRequiredBindingError(profile?.id, missingRequired);
+	if (unresolvedSlots.length > 0) warnOnce(`slots:${label}:${unresolvedSlots.join(",")}`, `[print-stylesheet] "${label}" names ${unresolvedSlots.length} region slot(s) the host could not fill: ${unresolvedSlots.map((s) => `"${s}"`).join(", ")}. Those margin boxes are OMITTED rather than rendered blank. Supply them via \`values\`, or add them to BUILT_IN_SLOTS if CSS can compute them.`);
+	return {
+		css: lines.join("\n"),
+		unresolvedSlots,
+		missingRequired
+	};
+}
+function buildPageVariables(profile) {
+	if (!profile) return "";
+	const decls = [];
+	const measure = cssValue(profile.measure);
+	if (measure) decls.push(`  --oa-doc-measure: ${measure};`);
+	if (typeof profile.bodyMeasureCh === "number" && Number.isFinite(profile.bodyMeasureCh)) decls.push(`  --oa-doc-body-measure: ${profile.bodyMeasureCh}ch;`);
+	if (typeof profile.floorPx === "number" && Number.isFinite(profile.floorPx)) decls.push(`  --oa-doc-type-floor: ${profile.floorPx}px;`);
+	for (const [role, raw] of Object.entries(profile.ink ?? {})) {
+		const value = cssValue(raw);
+		if (value && cssName(role)) decls.push(`  --oa-doc-ink-${role}: ${value};`);
+	}
+	for (const [weight, value] of Object.entries(profile.rules ?? {})) {
+		const safe = cssValue(value);
+		if (safe && cssName(weight)) decls.push(`  --oa-doc-rule-${weight}: ${safe};`);
+	}
+	return decls.length > 0 ? `:root {\n${decls.join("\n")}\n}` : "";
+}
+//#endregion
+//#region packages/renderer/src/print/print-layout.ts
+var SEPARATOR_MARGIN_PX = 48;
+var SEPARATOR_PADDING_PX = 16;
+var SEPARATOR_BORDER_PX = 2;
+var PAGE_FILL_INSET_PX = 2;
+var BLANK_PAGE_SEPARATOR_PX = 50;
+var SEPARATOR_TOTAL_PX = 66;
+function esc(cellId) {
+	return cssString(cellId).slice(1, -1);
+}
+function selectorsFor(cellIsBox) {
+	return {
+		boxSelector: (cellId) => cellIsBox ? `[data-cell-id="${esc(cellId)}"]` : `:has(> [data-cell-id="${esc(cellId)}"])`,
+		contentSelector: (cellId) => cellIsBox ? `[data-cell-id="${esc(cellId)}"] > *` : `[data-cell-id="${esc(cellId)}"]`
+	};
+}
+function buildPrintLayout(map, bands, { textBlockPx, scaleFloor = .6, screenSeparators = true, running, blankPageNotice = "This page was left intentionally blank", cellIsBox = false }) {
+	const { boxSelector, contentSelector } = selectorsFor(cellIsBox);
+	const byId = new Map(bands.map((b) => [b.id, b]));
+	const rules = [];
+	const pageStartCellIds = [];
+	const scaled = [];
+	const refused = [];
+	const blankPageBeforeCellIds = [];
+	for (const [i, page] of map.pages.entries()) {
+		if (!page.blank) continue;
+		const first = map.pages.slice(i + 1).find((p) => !p.blank && p.blocks.length > 0)?.blocks[0];
+		const cellId = (first ? byId.get(first.id) : void 0)?.members[0];
+		if (!cellId) continue;
+		blankPageBeforeCellIds.push(cellId);
+		rules.push(`${boxSelector(cellId)}::before { content: ${cssString(blankPageNotice)}; display: block; break-before: page !important; break-after: page !important; box-sizing: border-box; height: ${textBlockPx - PAGE_FILL_INSET_PX}px; padding-top: ${Math.round((textBlockPx - PAGE_FILL_INSET_PX) / 2)}px; text-align: center; font-size: 11px; letter-spacing: .08em; text-transform: uppercase; color: #78716c; }`);
+	}
+	for (const page of map.pages) {
+		if (page.index === 1) continue;
+		if (page.blank) continue;
+		const first = page.blocks[0];
+		if (!first || first.continues) continue;
+		const band = byId.get(first.id);
+		if (!band || band.members.length === 0) continue;
+		const cellId = band.members[0];
+		pageStartCellIds.push(cellId);
+		rules.push(`${boxSelector(cellId)} { break-before: page !important; }`);
+	}
+	const splitByDesign = new Set();
+	const mayFragment = map.pages.length > 1;
+	for (const page of map.pages) for (const block of page.blocks) if (block.continues || block.spansPages) splitByDesign.add(block.id);
+	for (const band of mayFragment ? bands : []) {
+		if (band.members.length === 0) continue;
+		if (splitByDesign.has(band.id)) continue;
+		if (band.constraints?.breakInside === "avoid") continue;
+		if (band.heightPx > textBlockPx) continue;
+		rules.push(`${boxSelector(band.members[0])} { break-inside: avoid !important; }`);
+	}
+	const fullPageIds = [];
+	let screenExtraPx = 0;
+	for (const page of map.pages) {
+		const sole = page.blocks.length === 1 ? page.blocks[0] : null;
+		if (!sole || sole.continues) continue;
+		const band = byId.get(sole.id);
+		if (!band || band.members.length === 0) continue;
+		if (band.constraints?.breakAfter !== "page") continue;
+		if (band.heightPx >= textBlockPx) continue;
+		fullPageIds.push(band.members[0]);
+		const fillPx = textBlockPx - PAGE_FILL_INSET_PX;
+		rules.push(`${boxSelector(band.members[0])} { height: ${fillPx}px !important; }`, `${contentSelector(band.members[0])} { height: ${fillPx}px !important; }`);
+		screenExtraPx += textBlockPx - PAGE_FILL_INSET_PX - band.heightPx;
+	}
+	for (const over of map.overflows) {
+		const band = byId.get(over.id);
+		if (!band || band.members.length === 0) continue;
+		const height = band.heightPx;
+		if (height <= 0) continue;
+		const k = ((over.availablePx ?? textBlockPx) - Math.max(0, over.heightPx - height) - PAGE_FILL_INSET_PX) / height;
+		if (k >= 1) continue;
+		if (k < scaleFloor) {
+			refused.push({
+				id: over.id,
+				heightPx: height,
+				requiredScale: round2(k)
+			});
+			continue;
+		}
+		const scaledHeightPx = Math.floor(height * k);
+		scaled.push({
+			id: over.id,
+			heightPx: height,
+			scale: round2(k),
+			scaledHeightPx
+		});
+		const box = boxSelector(band.members[0]);
+		rules.push(`${box} { height: ${scaledHeightPx}px !important; overflow: hidden !important; }`);
+		for (const member of band.members) rules.push(`${contentSelector(member)} { transform: scale(${round4(k)}) !important; transform-origin: top left !important; width: ${round2(100 / k)}% !important; }`);
+	}
+	const individuallyHandled = new Set([...scaled.map((r) => r.id), ...refused.map((r) => r.id)]);
+	for (const page of map.pages) {
+		if (page.usedPx <= textBlockPx) continue;
+		if (page.blocks.some((blk) => blk.continues || blk.spansPages)) continue;
+		if (page.blocks.some((blk) => individuallyHandled.has(blk.id))) continue;
+		const members = page.blocks.map((blk) => byId.get(blk.id)).filter((band) => !!band && band.members.length > 0);
+		if (members.length !== page.blocks.length) continue;
+		const bandsSum = members.reduce((sum, band) => sum + band.heightPx, 0);
+		const gapsSum = page.usedPx - bandsSum;
+		if (bandsSum <= 0) continue;
+		const k = (textBlockPx - PAGE_FILL_INSET_PX - gapsSum) / bandsSum;
+		if (k >= 1) continue;
+		if (k < scaleFloor) {
+			refused.push({
+				id: members.map((band) => band.id).join(" + "),
+				heightPx: page.usedPx,
+				requiredScale: round2(k)
+			});
+			continue;
+		}
+		for (const band of members) {
+			const scaledHeightPx = Math.floor(band.heightPx * k);
+			scaled.push({
+				id: band.id,
+				heightPx: band.heightPx,
+				scale: round2(k),
+				scaledHeightPx
+			});
+			rules.push(`${boxSelector(band.members[0])} { height: ${scaledHeightPx}px !important; overflow: hidden !important; }`);
+			for (const member of band.members) rules.push(`${contentSelector(member)} { transform: scale(${round4(k)}) !important; transform-origin: top left !important; width: ${round2(100 / k)}% !important; }`);
+		}
+	}
+	const screenRules = [];
+	if (screenSeparators && pageStartCellIds.length > 0) {
+		const selector = pageStartCellIds.map((id) => boxSelector(id)).join(",\n  ");
+		screenRules.push("@media screen {", `  ${selector} {`, `    margin-top: ${SEPARATOR_MARGIN_PX}px !important;`, `    border-top: ${SEPARATOR_BORDER_PX}px dashed rgb(194 65 12) !important;`, `    padding-top: ${SEPARATOR_PADDING_PX}px !important;`, "  }", "}");
+		if (blankPageBeforeCellIds.length > 0) {
+			const blankSel = blankPageBeforeCellIds.map((id) => `${boxSelector(id)}::before`).join(",\n  ");
+			screenRules.push("@media screen {", `  ${blankSel} {`, `    margin-bottom: ${SEPARATOR_MARGIN_PX}px;`, `    border-bottom: ${SEPARATOR_BORDER_PX}px dashed rgb(194 65 12);`, "  }", "}");
+		}
+		screenExtraPx += pageStartCellIds.length * 66;
+		screenExtraPx += blankPageBeforeCellIds.length * (textBlockPx - PAGE_FILL_INSET_PX + 50);
+	}
+	const runningRules = [];
+	const runningByPage = [];
+	if (running && running.slots.length > 0) {
+		const values = resolveRunningValues(map, bands, running.markers);
+		const font = cssValue(running.marginFont) ?? "var(--oa-doc-margin-font, 8pt/1.2 Inter, system-ui, sans-serif)";
+		const color = cssValue(running.marginColor) ?? "var(--oa-doc-margin-ink, rgba(0,0,0,0.45))";
+		for (const pageValues of values) {
+			runningByPage.push(pageValues);
+			const resolved = runningSlotValues(pageValues, { continuedSuffix: running.continuedSuffix });
+			const boxes = [];
+			for (const placement of running.slots) {
+				if (!isRunningSlot(placement.slot)) continue;
+				const text = resolved[placement.slot];
+				if (!text) continue;
+				boxes.push(`  @${placement.edge}-${placement.side} {`, `    content: ${cssString$1(text)};`, `    font: ${font};`, `    color: ${color};`, "  }");
+			}
+			if (boxes.length === 0) continue;
+			const name = `oa-page-${pageValues.page}`;
+			runningRules.push(`@page ${name} {`, ...boxes, "}");
+			const first = (map.pages.find((p) => p.index === pageValues.page)?.blocks ?? []).find((b) => !b.continues);
+			const anchor = first ? byId.get(first.id)?.members[0] : void 0;
+			if (anchor) runningRules.push(`${boxSelector(anchor)} { page: ${name} !important; }`);
+		}
+	}
+	return {
+		css: [
+			...rules,
+			...runningRules,
+			...screenRules
+		].join("\n"),
+		pageStartCellIds,
+		scaled,
+		refused,
+		fullPageCellIds: fullPageIds,
+		blankPageBeforeCellIds,
+		blankPageScreenOffsetPx: textBlockPx - PAGE_FILL_INSET_PX + (screenSeparators ? 50 : 0),
+		screenExtraPx,
+		runningByPage
+	};
+}
+function cssString$1(value) {
+	return cssString(value.replace(/\s*\n\s*/g, " "));
+}
+function round2(n) {
+	return Math.round(n * 100) / 100;
+}
+function round4(n) {
+	return Math.round(n * 1e4) / 1e4;
+}
+//#endregion
+//#region packages/renderer/src/print/map-staleness.ts
+function expectedHeightAfterTypesetting(measuredContainerPx, layout) {
+	return measuredContainerPx - layout.scaled.reduce((sum, r) => sum + (r.heightPx - r.scaledHeightPx), 0) + layout.screenExtraPx;
+}
+function stalenessTolerancePx(textBlockPx) {
+	return Math.max(120, Math.round(textBlockPx / 2));
+}
+function mapStaleness(liveHeightPx, expectedPx, textBlockPx) {
+	const tolerancePx = stalenessTolerancePx(textBlockPx);
+	const deltaPx = liveHeightPx - expectedPx;
+	return {
+		stale: Math.abs(deltaPx) > tolerancePx,
+		deltaPx,
+		tolerancePx
+	};
+}
+//#endregion
+//#region packages/renderer/src/print/print-lint.ts
+var VIEWPORT_UNIT = /(?<![\w-])(\d*\.?\d+)(v[hw]|vmin|vmax|[sld]v[hwbi]|vb|vi)(?![\w-])/gi;
+var IGNORED_PROPERTIES = new Set(["container-type"]);
+function viewportUnitsIn(cssText, where) {
+	const out = [];
+	for (const decl of cssText.split(";")) {
+		const colon = decl.indexOf(":");
+		if (colon <= 0) continue;
+		const lhs = decl.slice(0, colon);
+		const property = lhs.slice(Math.max(lhs.lastIndexOf("{"), lhs.lastIndexOf("}")) + 1).trim().toLowerCase();
+		const value = decl.slice(colon + 1).trim();
+		if (!property || IGNORED_PROPERTIES.has(property)) continue;
+		VIEWPORT_UNIT.lastIndex = 0;
+		if (VIEWPORT_UNIT.test(value)) out.push({
+			rule: "viewport-unit",
+			where,
+			property,
+			value
+		});
+	}
+	return out;
+}
+function mediaReachesPrint(condition) {
+	if (!condition) return true;
+	const c = condition.toLowerCase();
+	const mentionsPrint = /\bprint\b/.test(c);
+	if (/\bscreen\b/.test(c) && !mentionsPrint) return false;
+	return true;
+}
+function auditPrintLint(root, { computedStyle, rules }) {
+	const out = [];
+	if (!root) return out;
+	for (const el of Array.from(root.querySelectorAll("*"))) {
+		if (computedStyle(el).position === "fixed") out.push({
+			rule: "position-fixed",
+			where: describe(el),
+			property: "position",
+			value: "fixed"
+		});
+		const inline = el.getAttribute("style");
+		if (inline) out.push(...viewportUnitsIn(inline, describe(el)));
+	}
+	for (const [label, cssText] of rules) out.push(...viewportUnitsIn(cssText, label));
+	return out;
+}
+function describe(el) {
+	const cellId = el.getAttribute("data-cell-id");
+	if (cellId) return `[data-cell-id="${cellId}"]`;
+	const component = el.getAttribute("data-component");
+	if (component) return `<${el.tagName.toLowerCase()} data-component="${component}">`;
+	if (el.id) return `#${el.id}`;
+	const cls = el.getAttribute("class");
+	if (cls) return `${el.tagName.toLowerCase()}.${cls.trim().split(/\s+/).slice(0, 2).join(".")}`;
+	return el.tagName.toLowerCase();
+}
+//#endregion
+//#region packages/renderer/src/print/structure-print.ts
+function setRowPageIntent(structure, cellId, intent) {
+	if (!structure || !cellId) return {
+		structure: structure ?? [],
+		changed: false
+	};
+	let changed = false;
+	const visit = (entries) => entries.map((entry) => {
+		if (typeof entry === "string") {
+			if (entry !== cellId || changed) return entry;
+			const next = applyIntent({ cellId: entry }, intent);
+			changed = true;
+			return next;
+		}
+		const node = entry;
+		const children = node.children ? visit(node.children) : void 0;
+		const childrenChanged = children !== void 0 && children !== node.children;
+		if (node.cellId === cellId && !changed) {
+			changed = true;
+			return applyIntent({
+				...node,
+				...children ? { children } : {}
+			}, intent);
+		}
+		if (childrenChanged) return {
+			...node,
+			children
+		};
+		return node;
+	});
+	const next = visit(structure);
+	return {
+		structure: changed ? next : structure,
+		changed
+	};
+}
+function applyIntent(node, intent) {
+	const print = printBlockForIntent(node.print, intent);
+	const next = { ...node };
+	if (print) next.print = print;
+	else delete next.print;
+	return next;
+}
+function printBlockForIntent(existing, intent) {
+	const print = { ...existing ?? {} };
+	delete print.breakBefore;
+	delete print.keepWithPrevious;
+	if (intent === "break-before") print.breakBefore = true;
+	if (intent === "keep-with-previous") print.keepWithPrevious = true;
+	return Object.keys(print).length > 0 ? print : void 0;
+}
+function intentOfPrintBlock(print) {
+	if (print?.breakBefore) return "break-before";
+	if (print?.keepWithPrevious) return "keep-with-previous";
+	return "auto";
+}
+function rowPageIntent(structure, cellId) {
+	const node = findNode(structure, cellId);
+	if (!node || typeof node === "string") return "auto";
+	return intentOfPrintBlock(node.print);
+}
+function findNode(entries, cellId) {
+	for (const entry of entries ?? []) {
+		if (typeof entry === "string") {
+			if (entry === cellId) return entry;
+			continue;
+		}
+		if (entry.cellId === cellId) return entry;
+		const found = findNode(entry.children, cellId);
+		if (found) return found;
+	}
+}
+function printByCellId(structure) {
+	const out = new Map();
+	const visit = (entries) => {
+		for (const entry of entries ?? []) {
+			if (typeof entry === "string") continue;
+			if (entry.cellId && entry.print && Object.keys(entry.print).length > 0) {
+				if (!out.has(entry.cellId)) out.set(entry.cellId, entry.print);
+			}
+			if (entry.children) visit(entry.children);
+		}
+	};
+	visit(structure);
+	return out;
+}
+function nodePrintConstraints(node) {
+	const p = node.print;
+	if (!p) return void 0;
+	const out = {};
+	if (p.breakBefore) out.breakBefore = "page";
+	else if (p.keepWithPrevious) out.breakBefore = "avoid";
+	if (p.breakInside === "avoid") out.breakInside = "avoid";
+	return Object.keys(out).length > 0 ? out : void 0;
+}
+function setRowBlankPage(structure, cellId, present) {
+	let changed = false;
+	const visit = (entries) => entries.map((entry) => {
+		const node = typeof entry === "string" ? { cellId: entry } : entry;
+		const children = node.children ? visit(node.children) : void 0;
+		const childrenChanged = children !== void 0 && children !== node.children;
+		if (node.cellId === cellId && !changed) {
+			if (node.print?.blankPageBefore === true === present) return childrenChanged ? {
+				...node,
+				children
+			} : entry;
+			changed = true;
+			const print = { ...node.print ?? {} };
+			if (present) print.blankPageBefore = true;
+			else delete print.blankPageBefore;
+			const next = {
+				...node,
+				...children ? { children } : {}
+			};
+			if (Object.keys(print).length > 0) next.print = print;
+			else delete next.print;
+			return next;
+		}
+		if (childrenChanged) return {
+			...node,
+			children
+		};
+		return entry;
+	});
+	const next = visit(structure ?? []);
+	return {
+		structure: changed ? next : structure ?? [],
+		changed
+	};
+}
+function rowHasBlankPage(structure, cellId) {
+	const node = findNode(structure, cellId);
+	if (!node || typeof node === "string") return false;
+	return node.print?.blankPageBefore === true;
+}
+function diffRowPrint(base, next) {
+	const a = printByCellId(base);
+	const b = printByCellId(next);
+	const out = [];
+	const same = (x, y) => JSON.stringify(x ?? null) === JSON.stringify(y ?? null);
+	for (const [cellId, print] of b) if (!same(a.get(cellId), print)) out.push({
+		cellId,
+		print
+	});
+	for (const [cellId] of a) if (!b.has(cellId)) out.push({ cellId });
+	return out;
+}
+function applyRowPrint(structure, changes) {
+	const byId = new Map(changes.map((c) => [c.cellId, c]));
+	const applied = new Set();
+	let changed = false;
+	const visit = (entries) => entries.map((entry) => {
+		const node = typeof entry === "string" ? { cellId: entry } : entry;
+		const children = node.children ? visit(node.children) : void 0;
+		const childrenChanged = children !== void 0 && children !== node.children;
+		const change = node.cellId ? byId.get(node.cellId) : void 0;
+		if (change && !applied.has(change.cellId)) {
+			applied.add(change.cellId);
+			const before = JSON.stringify(node.print ?? null);
+			const after = JSON.stringify(change.print ?? null);
+			const out = {
+				...node,
+				...children ? { children } : {}
+			};
+			if (change.print && Object.keys(change.print).length > 0) out.print = change.print;
+			else delete out.print;
+			if (before !== after) changed = true;
+			return out;
+		}
+		if (childrenChanged) return {
+			...node,
+			children
+		};
+		return entry;
+	});
+	const nextStructure = visit(structure ?? []);
+	const missing = changes.filter((c) => !applied.has(c.cellId)).map((c) => c.cellId);
+	return {
+		structure: changed ? nextStructure : structure ?? [],
+		changed,
+		missing
+	};
+}
+function findSlottedCellIds(structure, slot) {
+	const found = [];
+	const seen = new Set();
+	const visit = (entries) => {
+		for (const entry of entries) {
+			if (typeof entry === "string") continue;
+			if (entry.slot === slot && typeof entry.cellId === "string" && entry.cellId) {
+				if (!seen.has(entry.cellId)) {
+					seen.add(entry.cellId);
+					found.push(entry.cellId);
+				}
+			}
+			if (Array.isArray(entry.children)) visit(entry.children);
+		}
+	};
+	visit(structure ?? []);
+	return found;
+}
+function pruneStructure(entries, keep) {
+	const out = [];
+	for (const entry of entries) {
+		if (typeof entry === "string") {
+			if (keep(entry)) out.push(entry);
+			continue;
+		}
+		const children = entry.children ? pruneStructure(entry.children, keep) : void 0;
+		if (typeof entry.cellId === "string" && entry.cellId) {
+			if (keep(entry.cellId)) out.push(children ? {
+				...entry,
+				children
+			} : entry);
+			continue;
+		}
+		if (children && children.length > 0) out.push({
+			...entry,
+			children
+		});
+	}
+	return out;
+}
+function splitMarginalia(page, marginaliaCellId, hasReservedTrack) {
+	const untouched = (reason) => ({
+		bodyPage: page,
+		marginaliaPage: null,
+		reason
+	});
+	if (!page || !marginaliaCellId) return untouched("no-slot");
+	if (!hasReservedTrack) return untouched("no-track");
+	const cells = page.content?.cells ?? [];
+	const railCell = cells.find((c) => c?.id === marginaliaCellId);
+	if (!railCell) return untouched("dangling");
+	const structure = page.layout?.structure ?? [];
+	const bodyStructure = pruneStructure(structure, (id) => id !== marginaliaCellId);
+	const railStructure = pruneStructure(structure, (id) => id === marginaliaCellId);
+	return {
+		bodyPage: {
+			...page,
+			content: {
+				...page.content,
+				cells: cells.filter((c) => c?.id !== marginaliaCellId)
+			},
+			layout: {
+				...page.layout,
+				structure: bodyStructure
+			}
+		},
+		marginaliaPage: {
+			...page,
+			content: {
+				...page.content,
+				cells: [railCell]
+			},
+			layout: {
+				...page.layout,
+				structure: railStructure
+			}
+		},
+		reason: null
+	};
+}
+//#endregion
+export { BLANK_PAGE_SEPARATOR_PX, DEFAULT_MARGINS, DEFAULT_SHEET, MissingRequiredBindingError, PRINT_POLICY_ATTR, RUNNING_SLOTS, SEPARATOR_TOTAL_PX, __clearDocumentProfileWarnings, __clearPrintStylesheetWarnings, applyRowPrint, auditPrintLint, buildPageStylesheet, buildPageVariables, buildPrintLayout, checkPaginatorBindings, collectBlocks, composeConstraints, constraintsFromBox, constraintsFromComputedStyle, constraintsResolver, cssLengthToPx, cssString, cssValue, deserializeConstraints, diffRowPrint, expectedHeightAfterTypesetting, findSlottedCellIds, forcedBreaksWithin, intentOfPrintBlock, isRunningSlot, mapStaleness, mediaReachesPrint, nodePrintConstraints, paginate, paperGeometryPx, parsePrintPolicy, printBlockForIntent, printByCellId, printPolicyToStyle, resolveDocumentProfile, resolvePlacement, resolveProfileId, resolveRegionBindings, resolveRunningValues, rowHasBlankPage, rowPageIntent, runningSlotValues, serializeConstraints, setRowBlankPage, setRowPageIntent, splitMarginalia, stalenessTolerancePx, viewportUnitsIn, withForcedBreaks };
+
+//# sourceMappingURL=print.js.map