@segnavia/format 0.24.0 → 0.26.0

package/dist/fold.d.ts

@@ -0,0 +1,16 @@
+import "./paper.js";
+//#region src/fold.d.ts
+export declare const FOLD_KINDS: readonly ["half", "letter", "z", "gate", "custom"];
+export type FoldKind = (typeof FOLD_KINDS)[number];
+export declare const FOLD_TUCK_IN_MM = 1.5;
+export declare function foldColumns(fold: FoldKind, panelCount?: number): number;
+export declare function foldPanelMap(fold: FoldKind, columns: number): {
+  front: number[];
+  back: number[];
+};
+export declare function foldCellPages(fold: FoldKind, columns: number): Array<{
+  front: number;
+  back: number;
+}>;
+export declare function foldPageCountMessage(fold: FoldKind, pageCount: number, columns: number): string;
+//#endregion

package/dist/fold.js

@@ -0,0 +1,175 @@
+import { fromMillimeters, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
+import { refuseOverflow, refuseSafe } from "./imposition-fit.js";
+//#region src/fold.ts
+const FOLD_KINDS = [
+	"half",
+	"letter",
+	"z",
+	"gate",
+	"custom"
+];
+const FOLD_TUCK_IN_MM = 1.5;
+const FOLD_HEIGHT_REMEDY = "reduce the vertical margins or cell height";
+function foldColumns(fold, panelCount = 0) {
+	if (fold === "custom") return panelCount;
+	return fold === "half" ? 2 : 3;
+}
+function foldPanelMap(fold, columns) {
+	if (fold === "gate") return {
+		front: [
+			2,
+			6,
+			1
+		],
+		back: [
+			3,
+			4,
+			5
+		]
+	};
+	return {
+		front: [...Array.from({ length: columns - 1 }, (_, index) => columns + 2 + index), 1],
+		back: Array.from({ length: columns }, (_, index) => index + 2)
+	};
+}
+function foldCellPages(fold, columns) {
+	const map = foldPanelMap(fold, columns);
+	return Array.from({ length: columns }, (_, cell) => ({
+		front: (map.front[cell] ?? 1) - 1,
+		back: (map.back[columns - 1 - cell] ?? 1) - 1
+	}));
+}
+function foldPageCountMessage(fold, pageCount, columns) {
+	const need = columns * 2;
+	return `this ${fold} fold has ${pageCount} pages and needs ${need} (2 × ${columns} panels); pass ${need} pages to clear this refusal`;
+}
+function splitSum(available, count) {
+	const share = available / count;
+	const widths = Array.from({ length: count - 1 }, () => roundMillimeters(share));
+	const used = widths.reduce((sum, width) => sum + width, 0);
+	widths.push(roundMillimeters(available - used));
+	return widths;
+}
+function presetPanelWidthsMm(fold, availableMm) {
+	if (fold === "letter") {
+		const tuck = roundMillimeters(availableMm / 3 - FOLD_TUCK_IN_MM);
+		const rest = availableMm - tuck;
+		const second = roundMillimeters(rest / 2);
+		return [
+			tuck,
+			second,
+			roundMillimeters(rest - second)
+		];
+	}
+	if (fold === "gate") {
+		const flap = roundMillimeters(availableMm / 4 - FOLD_TUCK_IN_MM);
+		return [
+			flap,
+			roundMillimeters(availableMm - flap * 2),
+			flap
+		];
+	}
+	return splitSum(availableMm, foldColumns(fold));
+}
+function availableWidthMm(draft) {
+	const paper = sheetMm({
+		paper: draft.paper,
+		orientation: draft.orientation
+	});
+	return roundMillimeters(paper.width - toMillimeters(draft.margin.left, draft.unit) - toMillimeters(draft.margin.right, draft.unit));
+}
+function panelWidthsMm(draft) {
+	if (draft.panels) return draft.panels.map((width) => toMillimeters(width, draft.unit));
+	if (!draft.fold || draft.fold === "custom") return [];
+	return presetPanelWidthsMm(draft.fold, availableWidthMm(draft));
+}
+function panelsInUnit(draft) {
+	if (draft.panels) return draft.panels;
+	return panelWidthsMm(draft).map((width) => draft.unit === "mm" ? width : fromMillimeters(width, draft.unit));
+}
+function issue(ctx, path, message) {
+	ctx.addIssue({
+		code: "custom",
+		path,
+		message
+	});
+}
+function refuseShape(draft, ctx, columns) {
+	if (draft.rows !== void 0 && draft.rows !== 1) issue(ctx, ["rows"], `rows is ${draft.rows}, but a fold is one row; set rows to 1 or omit it to clear this refusal`);
+	if (draft.sides === "one") issue(ctx, ["sides"], "sides is one, but a fold is two-sided; set sides to two or omit it to clear this refusal");
+	if (draft.fill === "repeat") issue(ctx, ["fill"], "fill is repeat, but a fold fills in sequence; set fill to sequence or omit it to clear this refusal");
+	if (draft.skip !== 0) issue(ctx, ["skip"], `skip is ${draft.skip}, but a fold has no skipped cells; set skip to 0 or omit it to clear this refusal`);
+	if (draft.gap.column !== 0) issue(ctx, ["gap", "column"], `column gap is ${draft.gap.column}, but a fold's panels touch; set gap.column to 0 or omit it to clear this refusal`);
+	if (draft.columns !== void 0 && draft.columns !== columns) issue(ctx, ["columns"], `columns is ${draft.columns}, but a ${draft.fold} fold has ${columns} panels; set columns to ${columns} or omit it to clear this refusal`);
+}
+function refineFold(draft, ctx) {
+	const fold = draft.fold;
+	if (!fold) return;
+	if (fold === "custom" && (draft.panels === void 0 || draft.panels.length < 2)) {
+		issue(ctx, ["panels"], "a custom fold needs panels with at least two widths; give panel widths that sum to the paper width to clear this refusal");
+		return;
+	}
+	const columns = foldColumns(fold, draft.panels?.length);
+	if (fold !== "custom" && draft.panels !== void 0 && draft.panels.length !== columns) {
+		issue(ctx, ["panels"], `panels has ${draft.panels.length} widths and a ${fold} fold has ${columns} columns; give ${columns} widths or omit panels to use the preset`);
+		return;
+	}
+	refuseShape(draft, ctx, columns);
+	const paper = sheetMm({
+		paper: draft.paper,
+		orientation: draft.orientation
+	});
+	const available = availableWidthMm(draft);
+	if (available <= 0) {
+		issue(ctx, ["margin"], `the horizontal margins leave ${available}mm of the ${paper.width}mm paper; reduce them`);
+		return;
+	}
+	const widths = panelWidthsMm(draft);
+	if (widths.some((width) => width <= 0)) {
+		issue(ctx, ["panels"], `a ${fold} fold has a non-positive panel after the ${FOLD_TUCK_IN_MM}mm tuck-in allowance; use a wider paper or override panels to clear this refusal`);
+		return;
+	}
+	const marginLeft = toMillimeters(draft.margin.left, draft.unit);
+	const marginRight = toMillimeters(draft.margin.right, draft.unit);
+	const sum = roundMillimeters(marginLeft + widths.reduce((total, width) => total + width, 0) + marginRight);
+	if (Math.abs(sum - paper.width) > .01) issue(ctx, ["panels"], `the panels and horizontal margins sum to ${sum}mm and the paper is ${paper.width}mm wide; change panels or margins so they sum to ${paper.width}mm to clear this refusal`);
+	const height = toMillimeters(draft.margin.top, draft.unit) + toMillimeters(draft.cell.height, draft.unit) + toMillimeters(draft.margin.bottom, draft.unit);
+	refuseOverflow(ctx, paper, { height }, { height: {
+		path: ["cell", "height"],
+		subject: "the folded piece",
+		remedy: FOLD_HEIGHT_REMEDY
+	} });
+	refuseSafe(ctx, toMillimeters(draft.safe, draft.unit), {
+		width: Math.min(...widths),
+		height: toMillimeters(draft.cell.height, draft.unit)
+	});
+}
+function resolveImposition(value) {
+	if (!value.fold) return {
+		...value,
+		columns: value.columns ?? 1,
+		rows: value.rows ?? 1,
+		sides: value.sides ?? "one",
+		cell: {
+			width: value.cell.width ?? 1,
+			height: value.cell.height
+		}
+	};
+	const columns = foldColumns(value.fold, value.panels?.length);
+	const panels = panelsInUnit(value);
+	return {
+		...value,
+		columns,
+		rows: 1,
+		sides: "two",
+		fill: "sequence",
+		skip: 0,
+		gap: {
+			column: 0,
+			row: value.gap.row
+		},
+		panels
+	};
+}
+//#endregion
+export { FOLD_KINDS, FOLD_TUCK_IN_MM, foldCellPages, foldColumns, foldPageCountMessage, foldPanelMap, panelWidthsMm, presetPanelWidthsMm, refineFold, resolveImposition };

package/dist/imposition-fit.d.ts

@@ -0,0 +1,3 @@
+//#region src/imposition-fit.d.ts
+export declare const PAPER_FIT_TOLERANCE_MM = 0.01;
+//#endregion

package/dist/imposition-fit.js

@@ -0,0 +1,33 @@
+import { roundMillimeters } from "./paper.js";
+//#region src/imposition-fit.ts
+const PAPER_FIT_TOLERANCE_MM = .01;
+const GRID_WIDTH_REMEDY = "reduce the horizontal margins, columns, cell width or column gap";
+const GRID_HEIGHT_REMEDY = "reduce the vertical margins, rows, cell height or row gap";
+function refuseOverflow(ctx, paper, used, axis = {}) {
+	const width = used.width;
+	if (width !== void 0 && width - paper.width > .01) ctx.addIssue({
+		code: "custom",
+		path: axis.width?.path ?? ["columns"],
+		message: `${axis.width?.subject ?? "the grid"} is ${roundMillimeters(width)}mm wide and the paper is ${paper.width}mm wide, an overflow of ${roundMillimeters(width - paper.width)}mm; ${axis.width?.remedy ?? GRID_WIDTH_REMEDY}`
+	});
+	const height = used.height;
+	if (height !== void 0 && height - paper.height > .01) ctx.addIssue({
+		code: "custom",
+		path: axis.height?.path ?? ["rows"],
+		message: `${axis.height?.subject ?? "the grid"} is ${roundMillimeters(height)}mm high and the paper is ${paper.height}mm high, an overflow of ${roundMillimeters(height - paper.height)}mm; ${axis.height?.remedy ?? GRID_HEIGHT_REMEDY}`
+	});
+}
+function refuseSafe(ctx, safe, cell) {
+	if (safe * 2 >= cell.width) ctx.addIssue({
+		code: "custom",
+		path: ["safe"],
+		message: `safe is ${roundMillimeters(safe)}mm on the left and right, but the cell is ${roundMillimeters(cell.width)}mm wide; safe must leave area inside the cell`
+	});
+	if (safe * 2 >= cell.height) ctx.addIssue({
+		code: "custom",
+		path: ["safe"],
+		message: `safe is ${roundMillimeters(safe)}mm on the top and bottom, but the cell is ${roundMillimeters(cell.height)}mm high; safe must leave area inside the cell`
+	});
+}
+//#endregion
+export { PAPER_FIT_TOLERANCE_MM, refuseOverflow, refuseSafe };

package/dist/imposition-marks.js

@@ -1,9 +1,9 @@
 import { roundMillimeters } from "./paper.js";
-import { impose } from "./imposition.js";
+import { gridPlacements } from "./imposition.js";
 //#region src/imposition-marks.ts
 const MIN_MARK_LENGTH_MM = 2;
 const unique = (values) => [...new Set(values.map(roundMillimeters))].sort((a, b) => a - b);
-function addMark(result, edge, cutPosition, start, available, horizontal, direction) {
+function addMark(result, edge, cutPosition, start, available, horizontal, direction, dashed = false) {
 	const length = Math.min(5, roundMillimeters(available));
 	if (length < 2) {
 		result.omittedMarks.push({
@@ -14,19 +14,22 @@ function addMark(result, edge, cutPosition, start, available, horizontal, direct
 		return;
 	}
 	const end = roundMillimeters(start + direction * length);
+	const dash = dashed ? { dashed: true } : {};
 	result.marks.push(horizontal ? {
 		x1: Math.min(start, end),
 		y1: cutPosition,
 		x2: Math.max(start, end),
-		y2: cutPosition
+		y2: cutPosition,
+		...dash
 	} : {
 		x1: cutPosition,
 		y1: Math.min(start, end),
 		x2: cutPosition,
-		y2: Math.max(start, end)
+		y2: Math.max(start, end),
+		...dash
 	});
 }
-function outerMarks(side, placements, paper) {
+function outerMarks(side, placements, paper, foldCuts) {
 	const verticalCuts = unique(placements.flatMap(({ trim }) => [trim.x, trim.x + trim.width]));
 	const horizontalCuts = unique(placements.flatMap(({ trim }) => [trim.y, trim.y + trim.height]));
 	const top = Math.min(...placements.map(({ bleedBox }) => bleedBox.y));
@@ -34,6 +37,7 @@ function outerMarks(side, placements, paper) {
 	const bottom = Math.max(...placements.map(({ bleedBox }) => bleedBox.y + bleedBox.height));
 	const left = Math.min(...placements.map(({ bleedBox }) => bleedBox.x));
 	for (const cut of verticalCuts) {
+		if (foldCuts.has(cut)) continue;
 		addMark(side, "top", cut, roundMillimeters(top - 1), top - 1, false, -1);
 		addMark(side, "bottom", cut, roundMillimeters(bottom + 1), paper.height - bottom - 1, false, 1);
 	}
@@ -41,6 +45,10 @@ function outerMarks(side, placements, paper) {
 		addMark(side, "left", cut, roundMillimeters(left - 1), left - 1, true, -1);
 		addMark(side, "right", cut, roundMillimeters(right + 1), paper.width - right - 1, true, 1);
 	}
+	for (const cut of foldCuts) {
+		addMark(side, "top", cut, roundMillimeters(top - 1), top - 1, false, -1, true);
+		addMark(side, "bottom", cut, roundMillimeters(bottom + 1), paper.height - bottom - 1, false, 1, true);
+	}
 }
 function intersectsBleed(mark, boxes) {
 	return boxes.some((box) => Math.max(mark.x1, box.x) <= Math.min(mark.x2, box.x + box.width) && Math.max(mark.y1, box.y) <= Math.min(mark.y2, box.y + box.height));
@@ -146,39 +154,38 @@ function cornerMarks(side, placements, rows) {
 		}
 	}
 }
+function foldCutPositions(placements) {
+	const left = Math.min(...placements.map(({ trim }) => trim.x));
+	const right = Math.max(...placements.map(({ trim }) => trim.x + trim.width));
+	return new Set(unique(placements.flatMap(({ trim }) => [trim.x, trim.x + trim.width])).filter((cut) => cut !== left && cut !== right));
+}
 /** Computes physical crop-mark geometry without changing the fixed paper size. */
 function impositionMarks(imposition) {
 	if (!imposition.marks) return [];
-	const cellCount = imposition.columns * imposition.rows;
-	const frontImposed = impose({
-		...imposition,
-		sides: "one",
-		fill: "sequence",
-		skip: 0
-	}, cellCount);
-	const frontPlacements = frontImposed.placements;
+	const { paper, placements: frontPlacements } = gridPlacements(imposition);
+	const foldCuts = imposition.fold ? foldCutPositions(frontPlacements) : /* @__PURE__ */ new Set();
 	const build = (sideName, placements) => {
 		const side = {
 			side: sideName,
 			marks: [],
 			omittedMarks: []
 		};
-		outerMarks(side, placements, frontImposed.paper);
+		outerMarks(side, placements, paper, foldCuts);
 		if (imposition.cornerMarks) cornerMarks(side, placements, imposition.rows);
 		return side;
 	};
 	const front = build("front", frontPlacements);
 	if (imposition.sides === "one") return [front];
-	const portrait = frontImposed.paper.width <= frontImposed.paper.height;
+	const portrait = paper.width <= paper.height;
 	const axis = imposition.flip === "long" === portrait ? "x" : "y";
 	const mirrorMark = (mark) => axis === "x" ? {
 		...mark,
-		x1: roundMillimeters(frontImposed.paper.width - mark.x1),
-		x2: roundMillimeters(frontImposed.paper.width - mark.x2)
+		x1: roundMillimeters(paper.width - mark.x1),
+		x2: roundMillimeters(paper.width - mark.x2)
 	} : {
 		...mark,
-		y1: roundMillimeters(frontImposed.paper.height - mark.y1),
-		y2: roundMillimeters(frontImposed.paper.height - mark.y2)
+		y1: roundMillimeters(paper.height - mark.y1),
+		y2: roundMillimeters(paper.height - mark.y2)
 	};
 	const mirrorEdge = (edge) => {
 		if (axis === "x") return edge === "left" ? "right" : edge === "right" ? "left" : edge;
@@ -190,7 +197,7 @@ function impositionMarks(imposition) {
 		omittedMarks: front.omittedMarks.map(({ edge, cutPosition }) => ({
 			side: "back",
 			edge: mirrorEdge(edge),
-			cutPosition: roundMillimeters(axis === "x" && (edge === "top" || edge === "bottom") ? frontImposed.paper.width - cutPosition : axis === "y" && (edge === "left" || edge === "right") ? frontImposed.paper.height - cutPosition : cutPosition)
+			cutPosition: roundMillimeters(axis === "x" && (edge === "top" || edge === "bottom") ? paper.width - cutPosition : axis === "y" && (edge === "left" || edge === "right") ? paper.height - cutPosition : cutPosition)
 		}))
 	}];
 }

package/dist/imposition.js

@@ -1,4 +1,5 @@
 import { PX_PER_MM, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
+import { foldCellPages, foldPageCountMessage } from "./fold.js";
 //#region src/imposition.ts
 const zeroCrop = () => ({
 	top: 0,
@@ -6,16 +7,34 @@ const zeroCrop = () => ({
 	bottom: 0,
 	left: 0
 });
+function columnWidthsMm(imposition) {
+	if (imposition.fold) return (imposition.panels ?? []).map((width) => toMillimeters(width, imposition.unit));
+	return Array.from({ length: imposition.columns }, () => toMillimeters(imposition.cell.width ?? 0, imposition.unit));
+}
+function columnXMm(imposition, column, widths, paperWidth) {
+	const mm = (value) => toMillimeters(value, imposition.unit);
+	const gap = mm(imposition.gap.column);
+	if (imposition.dir === "rtl") {
+		let x = paperWidth - mm(imposition.margin.right);
+		for (let index = 0; index <= column; index += 1) x -= widths[index] ?? 0;
+		for (let index = 0; index < column; index += 1) x -= gap;
+		return x;
+	}
+	let x = mm(imposition.margin.left);
+	for (let index = 0; index < column; index += 1) x += (widths[index] ?? 0) + gap;
+	return x;
+}
 function placementAt(imposition, paper, cell, page, paperSize) {
 	const mm = (value) => toMillimeters(value, imposition.unit);
 	const column = cell % imposition.columns;
 	const row = Math.floor(cell / imposition.columns);
 	const physicalColumn = imposition.dir === "rtl" ? imposition.columns - column - 1 : column;
-	const cellWidth = mm(imposition.cell.width);
+	const widths = columnWidthsMm(imposition);
+	const cellWidth = widths[column] ?? mm(imposition.cell.width ?? 0);
 	const cellHeight = mm(imposition.cell.height);
 	const columnGap = mm(imposition.gap.column);
 	const rowGap = mm(imposition.gap.row);
-	const x = imposition.dir === "rtl" ? paperSize.width - mm(imposition.margin.right) - cellWidth - column * (cellWidth + columnGap) : mm(imposition.margin.left) + column * (cellWidth + columnGap);
+	const x = columnXMm(imposition, column, widths, paperSize.width);
 	const y = mm(imposition.margin.top) + row * (cellHeight + rowGap);
 	const requested = mm(imposition.bleed);
 	const bleed = {
@@ -145,6 +164,38 @@ function expandAssignments(imposition, assignments, pageCount, paper) {
 	flush();
 	return placements;
 }
+function imposeFold(imposition, pageCount, paper) {
+	const fold = imposition.fold;
+	if (!fold) throw new Error("imposeFold requires a fold");
+	const columns = imposition.columns;
+	if (pageCount !== columns * 2) throw new Error(foldPageCountMessage(fold, pageCount, columns));
+	const cells = foldCellPages(fold, columns);
+	const fronts = [];
+	const backs = [];
+	for (const [cell, pages] of cells.entries()) {
+		if (!pages) continue;
+		const front = placementAt(imposition, 0, cell, pages.front, paper);
+		fronts.push(front);
+		backs.push(mirrorPlacement(front, paper, imposition.flip, pages.back));
+	}
+	return {
+		paper,
+		papers: 1,
+		sides: 2,
+		placements: [...fronts, ...backs]
+	};
+}
+function gridPlacements(imposition) {
+	const paper = sheetMm({
+		paper: imposition.paper,
+		orientation: imposition.orientation
+	});
+	const cells = imposition.columns * imposition.rows;
+	return {
+		paper,
+		placements: Array.from({ length: cells }, (_, cell) => placementAt(imposition, 0, cell, 0, paper))
+	};
+}
 function impose(imposition, pageCount) {
 	if (!Number.isInteger(pageCount) || pageCount < 0) throw new RangeError(`pageCount must be a nonnegative integer; received ${String(pageCount)}`);
 	const paper = sheetMm({
@@ -152,6 +203,7 @@ function impose(imposition, pageCount) {
 		orientation: imposition.orientation
 	});
 	const sides = imposition.sides === "two" ? 2 : 1;
+	if (imposition.fold) return imposeFold(imposition, pageCount, paper);
 	if (pageCount === 0) return {
 		paper,
 		papers: 0,
@@ -291,4 +343,4 @@ function pagePlacementLayout(size, placement, fit) {
 	};
 }
 //#endregion
-export { fitPage, impose, mirrorPlacement, pagePlacementLayout };
+export { fitPage, gridPlacements, impose, mirrorPlacement, pagePlacementLayout };

package/dist/index.d.ts

@@ -9,7 +9,9 @@ import { assignMembership, fitSection, fitTouchedSections, makeRoom, settleBoard
 import { Book, BookContents, BookFrontMatterEntry, BookInput, BookMode, BookPage, BookSection, BookView, BookViewInput, Chapter, isBookContents, isHebrew, noteMarkerIssues } from "./book.js";
 import { DeckFromSlidesOptions, SlideRow, deckFromSlides } from "./deck-from-slides.js";
 import { Direction, TextDirection, firstStrongDirection, languageDirection, resolveDirection } from "./direction.js";
-import { CUSTOM_PAPER_MAX_MM, CUSTOM_PAPER_MIN_MM, MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, MarkSegment, NAMED_PAPERS, NamedPaper, NamedPaperMetadata, ORIENTATIONS, Orientation, PAPER_GROUPS, PAPER_METADATA, PAPER_MM, PAPER_UNITS, PX_PER_MM, Paper, PaperBox, PaperGroup, PaperUnit, PrintSetting, PrintSettingInput, fromMillimeters, paperPixels, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
+import { PAPER_FIT_TOLERANCE_MM } from "./imposition-fit.js";
+import { CUSTOM_PAPER_MAX_MM, CUSTOM_PAPER_MIN_MM, FOLD_DASH_OFF_MM, FOLD_DASH_ON_MM, MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, MarkSegment, NAMED_PAPERS, NamedPaper, NamedPaperMetadata, ORIENTATIONS, Orientation, PAPER_GROUPS, PAPER_METADATA, PAPER_MM, PAPER_UNITS, PX_PER_MM, Paper, PaperBox, PaperGroup, PaperUnit, PrintSetting, PrintSettingInput, fromMillimeters, paperPixels, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
+import { FOLD_KINDS, FOLD_TUCK_IN_MM, FoldKind, foldCellPages, foldColumns, foldPageCountMessage, foldPanelMap } from "./fold.js";
 import { Imposed, MillimeterEdges, PageFit, PagePlacementKind, PagePlacementLayout, Placement, fitPage, impose, mirrorPlacement, pagePlacementLayout } from "./imposition.js";
 import { ImpositionMarkEdge, ImpositionSideMarks, MIN_MARK_LENGTH_MM, OmittedImpositionMark, impositionMarks } from "./imposition-marks.js";
 import { Lexicon, PronunciationEntry, lexiconVersion } from "./lexicon.js";
@@ -18,7 +20,7 @@ import { Scripts } from "./scripts.js";
 import { ShotUse, shotsUsed } from "./shots-used.js";
 import { MAX_SLIDE_TIMING_MS } from "./timing.js";
 import { DEFAULT_TRANSITION_DURATION_MS, MAX_TRANSITION_DURATION_MS, MIN_TRANSITION_DURATION_MS, Transition, TransitionInput } from "./transition.js";
-import { Fill, SLOT_TYPES, SlotDeclaration, SlotDeclarationInput, SlotReport, SlotSource, SlotState, SlotType, SlotValue, Slots, SlotsInput, SlotsOptions, mergeSlotDeclarations } from "./slots.js";
+import { Fill, FillValues, SLOT_TYPES, SlotDeclaration, SlotDeclarationInput, SlotKey, SlotReport, SlotSource, SlotState, SlotType, SlotValue, Slots, SlotsInput, SlotsOptions, mergeSlotDeclarations } from "./slots.js";
 import { z } from "zod";
 //#region src/index.d.ts
 export declare const Margin: z.ZodObject<{
@@ -27,6 +29,11 @@ export declare const Margin: z.ZodObject<{
   bottom: z.ZodDefault<z.ZodNumber>;
   left: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
+export declare const MarkColor: z.ZodEnum<{
+  black: "black";
+  registration: "registration";
+}>;
+export type MarkColor = z.infer<typeof MarkColor>;
 export declare const Print: z.ZodObject<{
   paper: z.ZodUnion<readonly [z.ZodEnum<{
     letter: "letter";
@@ -78,11 +85,15 @@ export declare const Print: z.ZodObject<{
   bleed: z.ZodDefault<z.ZodNumber>;
   safe: z.ZodDefault<z.ZodNumber>;
   marks: z.ZodDefault<z.ZodBoolean>;
+  markColor: z.ZodDefault<z.ZodEnum<{
+    black: "black";
+    registration: "registration";
+  }>>;
 }, z.core.$strip>;
 export type Print = z.infer<typeof Print>;
 export type PrintInput = z.input<typeof Print>;
 export declare const MAX_IMPOSITION_CELLS = 10000;
-export declare const Imposition: z.ZodObject<{
+export declare const Imposition: z.ZodPipe<z.ZodObject<{
   paper: z.ZodUnion<readonly [z.ZodEnum<{
     letter: "letter";
     legal: "legal";
@@ -135,10 +146,10 @@ export declare const Imposition: z.ZodObject<{
     bottom: z.ZodDefault<z.ZodNumber>;
     left: z.ZodDefault<z.ZodNumber>;
   }, z.core.$strip>>;
-  columns: z.ZodNumber;
-  rows: z.ZodNumber;
+  columns: z.ZodOptional<z.ZodNumber>;
+  rows: z.ZodOptional<z.ZodNumber>;
   cell: z.ZodObject<{
-    width: z.ZodNumber;
+    width: z.ZodOptional<z.ZodNumber>;
     height: z.ZodNumber;
   }, z.core.$strip>;
   gap: z.ZodDefault<z.ZodObject<{
@@ -155,7 +166,7 @@ export declare const Imposition: z.ZodObject<{
     sequence: "sequence";
     repeat: "repeat";
   }>>;
-  sides: z.ZodDefault<z.ZodEnum<{
+  sides: z.ZodOptional<z.ZodEnum<{
     one: "one";
     two: "two";
   }>>;
@@ -169,8 +180,98 @@ export declare const Imposition: z.ZodObject<{
     rtl: "rtl";
   }>>;
   marks: z.ZodDefault<z.ZodBoolean>;
+  markColor: z.ZodDefault<z.ZodEnum<{
+    black: "black";
+    registration: "registration";
+  }>>;
   cornerMarks: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
+  fold: z.ZodOptional<z.ZodEnum<{
+    custom: "custom";
+    letter: "letter";
+    half: "half";
+    z: "z";
+    gate: "gate";
+  }>>;
+  panels: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>, z.ZodTransform<{
+  paper: "letter" | "legal" | "tabloid" | "a3" | "a4" | "a5" | "business-card-us" | "business-card-eu" | "business-card-square-us" | "business-card-slim-us" | "postcard-4x6" | "postcard-5x7" | "postcard-6x9" | "postcard-6x11" | "card-square-4in" | "half-letter" | "a6" | "dl" | "rack-card-4x9" | "rack-card-3.5x8.5" | "poster-12x18" | "poster-16x20" | "poster-18x24" | "poster-24x36" | "a2" | "a1" | "a0" | {
+    width: number;
+    height: number;
+    unit: "mm" | "in" | "pt";
+  };
+  orientation: "portrait" | "landscape";
+  unit: "mm" | "in" | "pt";
+  margin: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+  };
+  cell: {
+    height: number;
+    width?: number | undefined;
+  };
+  gap: {
+    column: number;
+    row: number;
+  };
+  bleed: number;
+  safe: number;
+  fit: "contain" | "cover";
+  fill: "sequence" | "repeat";
+  flip: "long" | "short";
+  skip: number;
+  dir: "ltr" | "rtl";
+  marks: boolean;
+  markColor: "black" | "registration";
+  cornerMarks: boolean;
+  columns?: number | undefined;
+  rows?: number | undefined;
+  sides?: "one" | "two" | undefined;
+  fold?: "custom" | "letter" | "half" | "z" | "gate" | undefined;
+  panels?: number[] | undefined;
+} & {
+  columns: number;
+  rows: number;
+  sides: "one" | "two";
+}, {
+  paper: "letter" | "legal" | "tabloid" | "a3" | "a4" | "a5" | "business-card-us" | "business-card-eu" | "business-card-square-us" | "business-card-slim-us" | "postcard-4x6" | "postcard-5x7" | "postcard-6x9" | "postcard-6x11" | "card-square-4in" | "half-letter" | "a6" | "dl" | "rack-card-4x9" | "rack-card-3.5x8.5" | "poster-12x18" | "poster-16x20" | "poster-18x24" | "poster-24x36" | "a2" | "a1" | "a0" | {
+    width: number;
+    height: number;
+    unit: "mm" | "in" | "pt";
+  };
+  orientation: "portrait" | "landscape";
+  unit: "mm" | "in" | "pt";
+  margin: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+  };
+  cell: {
+    height: number;
+    width?: number | undefined;
+  };
+  gap: {
+    column: number;
+    row: number;
+  };
+  bleed: number;
+  safe: number;
+  fit: "contain" | "cover";
+  fill: "sequence" | "repeat";
+  flip: "long" | "short";
+  skip: number;
+  dir: "ltr" | "rtl";
+  marks: boolean;
+  markColor: "black" | "registration";
+  cornerMarks: boolean;
+  columns?: number | undefined;
+  rows?: number | undefined;
+  sides?: "one" | "two" | undefined;
+  fold?: "custom" | "letter" | "half" | "z" | "gate" | undefined;
+  panels?: number[] | undefined;
+}>>;
 export type Imposition = z.infer<typeof Imposition>;
 export type ImpositionInput = z.input<typeof Imposition>;
 export declare const PageSize: z.ZodUnion<readonly [z.ZodLiteral<"fluid">, z.ZodObject<{
@@ -252,6 +353,10 @@ export declare const Page: z.ZodObject<{
     bleed: z.ZodDefault<z.ZodNumber>;
     safe: z.ZodDefault<z.ZodNumber>;
     marks: z.ZodDefault<z.ZodBoolean>;
+    markColor: z.ZodDefault<z.ZodEnum<{
+      black: "black";
+      registration: "registration";
+    }>>;
   }, z.core.$strip>>;
   slots: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
     key: z.ZodString;
@@ -502,6 +607,10 @@ export declare function jsonSchemas(): {
       bleed: z.ZodDefault<z.ZodNumber>;
       safe: z.ZodDefault<z.ZodNumber>;
       marks: z.ZodDefault<z.ZodBoolean>;
+      markColor: z.ZodDefault<z.ZodEnum<{
+        black: "black";
+        registration: "registration";
+      }>>;
     }, z.core.$strip>>;
     slots: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
       key: z.ZodString;
@@ -548,7 +657,7 @@ export declare function jsonSchemas(): {
       ipa: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
   }, z.core.$strip>>;
-  imposition: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+  imposition: z.core.ZodStandardJSONSchemaPayload<z.ZodPipe<z.ZodObject<{
     paper: z.ZodUnion<readonly [z.ZodEnum<{
       letter: "letter";
       legal: "legal";
@@ -601,10 +710,10 @@ export declare function jsonSchemas(): {
       bottom: z.ZodDefault<z.ZodNumber>;
       left: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
-    columns: z.ZodNumber;
-    rows: z.ZodNumber;
+    columns: z.ZodOptional<z.ZodNumber>;
+    rows: z.ZodOptional<z.ZodNumber>;
     cell: z.ZodObject<{
-      width: z.ZodNumber;
+      width: z.ZodOptional<z.ZodNumber>;
       height: z.ZodNumber;
     }, z.core.$strip>;
     gap: z.ZodDefault<z.ZodObject<{
@@ -621,7 +730,7 @@ export declare function jsonSchemas(): {
       sequence: "sequence";
       repeat: "repeat";
     }>>;
-    sides: z.ZodDefault<z.ZodEnum<{
+    sides: z.ZodOptional<z.ZodEnum<{
       one: "one";
       two: "two";
     }>>;
@@ -635,8 +744,98 @@ export declare function jsonSchemas(): {
       rtl: "rtl";
     }>>;
     marks: z.ZodDefault<z.ZodBoolean>;
+    markColor: z.ZodDefault<z.ZodEnum<{
+      black: "black";
+      registration: "registration";
+    }>>;
     cornerMarks: z.ZodDefault<z.ZodBoolean>;
-  }, z.core.$strip>>;
+    fold: z.ZodOptional<z.ZodEnum<{
+      custom: "custom";
+      letter: "letter";
+      half: "half";
+      z: "z";
+      gate: "gate";
+    }>>;
+    panels: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+  }, z.core.$strip>, z.ZodTransform<{
+    paper: "letter" | "legal" | "tabloid" | "a3" | "a4" | "a5" | "business-card-us" | "business-card-eu" | "business-card-square-us" | "business-card-slim-us" | "postcard-4x6" | "postcard-5x7" | "postcard-6x9" | "postcard-6x11" | "card-square-4in" | "half-letter" | "a6" | "dl" | "rack-card-4x9" | "rack-card-3.5x8.5" | "poster-12x18" | "poster-16x20" | "poster-18x24" | "poster-24x36" | "a2" | "a1" | "a0" | {
+      width: number;
+      height: number;
+      unit: "mm" | "in" | "pt";
+    };
+    orientation: "portrait" | "landscape";
+    unit: "mm" | "in" | "pt";
+    margin: {
+      top: number;
+      right: number;
+      bottom: number;
+      left: number;
+    };
+    cell: {
+      height: number;
+      width?: number | undefined;
+    };
+    gap: {
+      column: number;
+      row: number;
+    };
+    bleed: number;
+    safe: number;
+    fit: "contain" | "cover";
+    fill: "sequence" | "repeat";
+    flip: "long" | "short";
+    skip: number;
+    dir: "ltr" | "rtl";
+    marks: boolean;
+    markColor: "black" | "registration";
+    cornerMarks: boolean;
+    columns?: number | undefined;
+    rows?: number | undefined;
+    sides?: "one" | "two" | undefined;
+    fold?: "custom" | "letter" | "half" | "z" | "gate" | undefined;
+    panels?: number[] | undefined;
+  } & {
+    columns: number;
+    rows: number;
+    sides: "one" | "two";
+  }, {
+    paper: "letter" | "legal" | "tabloid" | "a3" | "a4" | "a5" | "business-card-us" | "business-card-eu" | "business-card-square-us" | "business-card-slim-us" | "postcard-4x6" | "postcard-5x7" | "postcard-6x9" | "postcard-6x11" | "card-square-4in" | "half-letter" | "a6" | "dl" | "rack-card-4x9" | "rack-card-3.5x8.5" | "poster-12x18" | "poster-16x20" | "poster-18x24" | "poster-24x36" | "a2" | "a1" | "a0" | {
+      width: number;
+      height: number;
+      unit: "mm" | "in" | "pt";
+    };
+    orientation: "portrait" | "landscape";
+    unit: "mm" | "in" | "pt";
+    margin: {
+      top: number;
+      right: number;
+      bottom: number;
+      left: number;
+    };
+    cell: {
+      height: number;
+      width?: number | undefined;
+    };
+    gap: {
+      column: number;
+      row: number;
+    };
+    bleed: number;
+    safe: number;
+    fit: "contain" | "cover";
+    fill: "sequence" | "repeat";
+    flip: "long" | "short";
+    skip: number;
+    dir: "ltr" | "rtl";
+    marks: boolean;
+    markColor: "black" | "registration";
+    cornerMarks: boolean;
+    columns?: number | undefined;
+    rows?: number | undefined;
+    sides?: "one" | "two" | undefined;
+    fold?: "custom" | "letter" | "half" | "z" | "gate" | undefined;
+    panels?: number[] | undefined;
+  }>>>;
   deck: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
     title: z.ZodString;
     size: z.ZodDefault<z.ZodObject<{
@@ -1139,4 +1338,4 @@ export declare function jsonSchemas(): {
   }>>>;
 };
 //#endregion
-export { Annotation, type ArrangeOptions, Board, type BoardInput, BoardItem, type BoardItemAnchor, BoardLabel, type BoardListingGroup, BoardSection, type BoardShapes, type BoardView, Book, BookContents, BookFrontMatterEntry, type BookInput, BookMode, BookPage, BookSection, BookView, type BookViewInput, Box, CUSTOM_PAPER_MAX_MM, CUSTOM_PAPER_MIN_MM, Chapter, Cue, DECK_SIZE, DEFAULT_TRANSITION_DURATION_MS, Deck, type DeckFromSlidesOptions, type DeckInput, type DeckLimits, Direction, Fill, GridCell, type GridDropTarget, ImageFit, type Imposed, type ImpositionMarkEdge, type ImpositionSideMarks, Lexicon, MAKE_ROOM_LIMIT, MARK_GAP_MM, MARK_LENGTH_MM, MAX_BOARD_ZOOM, MAX_SLIDE_TIMING_MS, MAX_TRANSITION_DURATION_MS, MIN_BOARD_ITEM_WIDTH, MIN_BOARD_ZOOM, MIN_MARK_LENGTH_MM, MIN_TRANSITION_DURATION_MS, MM_PER_PT, Manifest, type MarkSegment, type MillimeterEdges, NAMED_PAPERS, type NamedPaper, type NamedPaperMetadata, Narration, NoteMarker, NumberSystem, ORIENTATIONS, type OmittedImpositionMark, Orientation, PAPER_GROUPS, PAPER_METADATA, PAPER_MM, PAPER_UNITS, PLAYBACK_MODES, PX_PER_MM, type PageFit, type PagePlacementKind, type PagePlacementLayout, Paper, type PaperBox, type PaperGroup, PaperUnit, type Placement, Playback, type PlaybackMode, Point, PrintSetting, PrintSettingInput, PronunciationEntry, PublishedShot, SECTION_GAP, SECTION_MIN_SIZE, SECTION_PADDING, SECTION_TITLE_ROOM, SHOT_KEY, SLOT_TYPES, Scripts, Shot, type ShotUse, Size, Slide, SlideContent, type SlideRow, SlotDeclaration, SlotDeclarationInput, SlotReport, SlotSource, SlotState, SlotType, SlotValue, Slots, SlotsInput, SlotsOptions, TextDirection, Transition, TransitionInput, Word, type ZoomBounds, addItem, annotationCueIssues, arrange, assignMembership, boardBounds, boardListing, boardListingIsEmpty, boardToScreen, deckFromSlides, deriveSectionCells, exceedsLimits, firstStrongDirection, fitPage, fitSection, fitTouchedSections, foldForSearch, formatNumber, fromMillimeters, gridDropMarkerBox, gridDropTarget, impose, impositionMarks, insertIntoGrid, isBookContents, isHebrew, itemAt, itemHeight, languageDirection, layoutSection, lexiconVersion, makeRoom, mergeSlotDeclarations, mirrorPlacement, moveItems, moveSection, nameMatches, noteMarker, noteMarkerIssues, pagePlacementLayout, paperPixels, parsePlayback, printBoxes, printPadding, printProperties, removeFromGrid, removeItems, resizeItem, resolveDirection, revealView, roundMillimeters, screenToBoard, settleBoard, sheetMm, shotsUsed, toMillimeters, visibleItems, zoomAt, zoomToFit };
+export { Annotation, type ArrangeOptions, Board, type BoardInput, BoardItem, type BoardItemAnchor, BoardLabel, type BoardListingGroup, BoardSection, type BoardShapes, type BoardView, Book, BookContents, BookFrontMatterEntry, type BookInput, BookMode, BookPage, BookSection, BookView, type BookViewInput, Box, CUSTOM_PAPER_MAX_MM, CUSTOM_PAPER_MIN_MM, Chapter, Cue, DECK_SIZE, DEFAULT_TRANSITION_DURATION_MS, Deck, type DeckFromSlidesOptions, type DeckInput, type DeckLimits, Direction, FOLD_DASH_OFF_MM, FOLD_DASH_ON_MM, FOLD_KINDS, FOLD_TUCK_IN_MM, Fill, FillValues, type FoldKind, GridCell, type GridDropTarget, ImageFit, type Imposed, type ImpositionMarkEdge, type ImpositionSideMarks, Lexicon, MAKE_ROOM_LIMIT, MARK_GAP_MM, MARK_LENGTH_MM, MAX_BOARD_ZOOM, MAX_SLIDE_TIMING_MS, MAX_TRANSITION_DURATION_MS, MIN_BOARD_ITEM_WIDTH, MIN_BOARD_ZOOM, MIN_MARK_LENGTH_MM, MIN_TRANSITION_DURATION_MS, MM_PER_PT, Manifest, type MarkSegment, type MillimeterEdges, NAMED_PAPERS, type NamedPaper, type NamedPaperMetadata, Narration, NoteMarker, NumberSystem, ORIENTATIONS, type OmittedImpositionMark, Orientation, PAPER_FIT_TOLERANCE_MM, PAPER_GROUPS, PAPER_METADATA, PAPER_MM, PAPER_UNITS, PLAYBACK_MODES, PX_PER_MM, type PageFit, type PagePlacementKind, type PagePlacementLayout, Paper, type PaperBox, type PaperGroup, PaperUnit, type Placement, Playback, type PlaybackMode, Point, PrintSetting, PrintSettingInput, PronunciationEntry, PublishedShot, SECTION_GAP, SECTION_MIN_SIZE, SECTION_PADDING, SECTION_TITLE_ROOM, SHOT_KEY, SLOT_TYPES, Scripts, Shot, type ShotUse, Size, Slide, SlideContent, type SlideRow, SlotDeclaration, SlotDeclarationInput, SlotKey, SlotReport, SlotSource, SlotState, SlotType, SlotValue, Slots, SlotsInput, SlotsOptions, TextDirection, Transition, TransitionInput, Word, type ZoomBounds, addItem, annotationCueIssues, arrange, assignMembership, boardBounds, boardListing, boardListingIsEmpty, boardToScreen, deckFromSlides, deriveSectionCells, exceedsLimits, firstStrongDirection, fitPage, fitSection, fitTouchedSections, foldCellPages, foldColumns, foldForSearch, foldPageCountMessage, foldPanelMap, formatNumber, fromMillimeters, gridDropMarkerBox, gridDropTarget, impose, impositionMarks, insertIntoGrid, isBookContents, isHebrew, itemAt, itemHeight, languageDirection, layoutSection, lexiconVersion, makeRoom, mergeSlotDeclarations, mirrorPlacement, moveItems, moveSection, nameMatches, noteMarker, noteMarkerIssues, pagePlacementLayout, paperPixels, parsePlayback, printBoxes, printPadding, printProperties, removeFromGrid, removeItems, resizeItem, resolveDirection, revealView, roundMillimeters, screenToBoard, settleBoard, sheetMm, shotsUsed, toMillimeters, visibleItems, zoomAt, zoomToFit };

package/dist/index.js

@@ -1,13 +1,15 @@
 import { Direction, TextDirection, firstStrongDirection, languageDirection, resolveDirection } from "./direction.js";
 import { Scripts } from "./scripts.js";
-import { SLOT_TYPES, SlotDeclaration, SlotDeclarationInput, SlotType, Slots, SlotsInput, mergeSlotDeclarations } from "./slots.js";
+import { FillValues, SLOT_TYPES, SlotDeclaration, SlotDeclarationInput, SlotKey, SlotType, SlotValue, Slots, SlotsInput, mergeSlotDeclarations } from "./slots.js";
 import { MAX_SLIDE_TIMING_MS } from "./timing.js";
 import { DEFAULT_TRANSITION_DURATION_MS, MAX_TRANSITION_DURATION_MS, MIN_TRANSITION_DURATION_MS, Transition } from "./transition.js";
 import { Annotation, Box, Cue, DECK_SIZE, Deck, DeckShape, ImageFit, Manifest, Narration, PLAYBACK_MODES, Playback, Point, PublishedShot, SHOT_KEY, Shot, Size, Slide, SlideContent, Word, annotationCueIssues, exceedsLimits, parsePlayback } from "./deck.js";
 import { Board, BoardItem, BoardLabel, BoardSection, GridCell } from "./board.js";
 import { NoteMarker, NumberSystem, formatNumber, noteMarker } from "./numbering.js";
-import { CUSTOM_PAPER_MAX_MM, CUSTOM_PAPER_MIN_MM, MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, NAMED_PAPERS, ORIENTATIONS, Orientation, PAPER_GROUPS, PAPER_METADATA, PAPER_MM, PAPER_UNITS, PX_PER_MM, Paper, PaperUnit, PrintSetting, PrintSettingInput, fromMillimeters, paperPixels, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
+import { CUSTOM_PAPER_MAX_MM, CUSTOM_PAPER_MIN_MM, FOLD_DASH_OFF_MM, FOLD_DASH_ON_MM, MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, NAMED_PAPERS, ORIENTATIONS, Orientation, PAPER_GROUPS, PAPER_METADATA, PAPER_MM, PAPER_UNITS, PX_PER_MM, Paper, PaperUnit, PrintSetting, PrintSettingInput, fromMillimeters, paperPixels, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters } from "./paper.js";
 import { Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookShape, BookView, Chapter, isBookContents, isHebrew, noteMarkerIssues } from "./book.js";
+import { PAPER_FIT_TOLERANCE_MM, refuseOverflow, refuseSafe } from "./imposition-fit.js";
+import { FOLD_KINDS, FOLD_TUCK_IN_MM, foldCellPages, foldColumns, foldPageCountMessage, foldPanelMap, refineFold, resolveImposition } from "./fold.js";
 import { Lexicon, PronunciationEntry, lexiconVersion } from "./lexicon.js";
 import { MIN_BOARD_ITEM_WIDTH, addItem, moveItems, moveSection, removeItems, resizeItem } from "./board-edit.js";
 import { MAX_BOARD_ZOOM, MIN_BOARD_ZOOM, arrange, boardBounds, boardToScreen, itemAt, itemHeight, revealView, screenToBoard, visibleItems, zoomAt, zoomToFit } from "./board-geometry.js";
@@ -27,14 +29,21 @@ const Margin = z.object({
 	bottom: z.number().nonnegative().default(0),
 	left: z.number().nonnegative().default(0)
 });
+const MarkColor = z.enum(["black", "registration"]);
 const Print = z.object({
 	paper: Paper,
 	orientation: Orientation.default("portrait"),
 	margin: Margin.optional(),
 	bleed: z.number().nonnegative().default(0),
 	safe: z.number().nonnegative().default(0),
-	marks: z.boolean().default(false)
+	marks: z.boolean().default(false),
+	markColor: MarkColor.default("black")
 }).superRefine((print, ctx) => {
+	if (print.markColor === "registration" && !print.marks) ctx.addIssue({
+		code: "custom",
+		path: ["markColor"],
+		message: "markColor requires marks to be true"
+	});
 	const trim = sheetMm(print);
 	if (print.safe * 2 >= trim.width) ctx.addIssue({
 		code: "custom",
@@ -62,10 +71,10 @@ const Imposition = z.object({
 		bottom: 0,
 		left: 0
 	}),
-	columns: z.number().int().positive(),
-	rows: z.number().int().positive(),
+	columns: z.number().int().positive().optional(),
+	rows: z.number().int().positive().optional(),
 	cell: z.object({
-		width: z.number().positive(),
+		width: z.number().positive().optional(),
 		height: z.number().positive()
 	}),
 	gap: ImpositionGap.default({
@@ -76,19 +85,61 @@ const Imposition = z.object({
 	safe: z.number().nonnegative().default(0),
 	fit: z.enum(["contain", "cover"]).default("contain"),
 	fill: z.enum(["sequence", "repeat"]).default("sequence"),
-	sides: z.enum(["one", "two"]).default("one"),
+	sides: z.enum(["one", "two"]).optional(),
 	flip: z.enum(["long", "short"]).default("long"),
 	skip: z.number().int().nonnegative().default(0),
 	dir: z.enum(["ltr", "rtl"]).default("ltr"),
 	marks: z.boolean().default(false),
-	cornerMarks: z.boolean().default(false)
+	markColor: MarkColor.default("black"),
+	cornerMarks: z.boolean().default(false),
+	fold: z.enum(FOLD_KINDS).optional(),
+	panels: z.array(z.number().positive()).optional()
 }).superRefine((imposition, ctx) => {
-	const cellCount = BigInt(imposition.columns) * BigInt(imposition.rows);
+	if (imposition.markColor === "registration" && !imposition.marks) ctx.addIssue({
+		code: "custom",
+		path: ["markColor"],
+		message: "markColor requires marks to be true"
+	});
 	if (imposition.cornerMarks && !imposition.marks) ctx.addIssue({
 		code: "custom",
 		path: ["cornerMarks"],
 		message: "cornerMarks requires marks to be true"
 	});
+	if (imposition.panels !== void 0 && !imposition.fold) ctx.addIssue({
+		code: "custom",
+		path: ["panels"],
+		message: "panels needs fold; set fold or remove panels"
+	});
+	if (imposition.fold) {
+		const panelCount = imposition.panels?.length ?? 0;
+		if (panelCount > 1e4) {
+			ctx.addIssue({
+				code: "custom",
+				path: ["panels"],
+				message: `the fold has ${panelCount} panels and the ceiling is ${MAX_IMPOSITION_CELLS}; fewer panels clears this refusal`
+			});
+			return;
+		}
+		refineFold(imposition, ctx);
+		return;
+	}
+	if (imposition.columns === void 0) ctx.addIssue({
+		code: "custom",
+		path: ["columns"],
+		message: "columns is required; give a column count to clear this refusal"
+	});
+	if (imposition.rows === void 0) ctx.addIssue({
+		code: "custom",
+		path: ["rows"],
+		message: "rows is required; give a row count to clear this refusal"
+	});
+	if (imposition.cell.width === void 0) ctx.addIssue({
+		code: "custom",
+		path: ["cell", "width"],
+		message: "cell.width is required; give a cell width to clear this refusal"
+	});
+	if (imposition.columns === void 0 || imposition.rows === void 0 || imposition.cell.width === void 0) return;
+	const cellCount = BigInt(imposition.columns) * BigInt(imposition.rows);
 	if (imposition.columns > 1e4 || imposition.rows > 1e4 || cellCount > BigInt(1e4)) {
 		ctx.addIssue({
 			code: "custom",
@@ -104,28 +155,13 @@ const Imposition = z.object({
 	});
 	const gridWidth = mm(imposition.margin.left + imposition.columns * imposition.cell.width + (imposition.columns - 1) * imposition.gap.column + imposition.margin.right);
 	const gridHeight = mm(imposition.margin.top + imposition.rows * imposition.cell.height + (imposition.rows - 1) * imposition.gap.row + imposition.margin.bottom);
-	if (gridWidth - paper.width > .01) ctx.addIssue({
-		code: "custom",
-		path: ["columns"],
-		message: `the grid is ${roundMillimeters(gridWidth)}mm wide and the paper is ${paper.width}mm wide, an overflow of ${roundMillimeters(gridWidth - paper.width)}mm; reduce the horizontal margins, columns, cell width or column gap`
+	refuseOverflow(ctx, paper, {
+		width: gridWidth,
+		height: gridHeight
 	});
-	if (gridHeight - paper.height > .01) ctx.addIssue({
-		code: "custom",
-		path: ["rows"],
-		message: `the grid is ${roundMillimeters(gridHeight)}mm high and the paper is ${paper.height}mm high, an overflow of ${roundMillimeters(gridHeight - paper.height)}mm; reduce the vertical margins, rows, cell height or row gap`
-	});
-	const safe = mm(imposition.safe);
-	const cellWidth = mm(imposition.cell.width);
-	const cellHeight = mm(imposition.cell.height);
-	if (safe * 2 >= cellWidth) ctx.addIssue({
-		code: "custom",
-		path: ["safe"],
-		message: `safe is ${roundMillimeters(safe)}mm on the left and right, but the cell is ${roundMillimeters(cellWidth)}mm wide; safe must leave area inside the cell`
-	});
-	if (safe * 2 >= cellHeight) ctx.addIssue({
-		code: "custom",
-		path: ["safe"],
-		message: `safe is ${roundMillimeters(safe)}mm on the top and bottom, but the cell is ${roundMillimeters(cellHeight)}mm high; safe must leave area inside the cell`
+	refuseSafe(ctx, mm(imposition.safe), {
+		width: mm(imposition.cell.width),
+		height: mm(imposition.cell.height)
 	});
 	const cells = imposition.columns * imposition.rows;
 	if (imposition.skip >= cells) ctx.addIssue({
@@ -133,7 +169,7 @@ const Imposition = z.object({
 		path: ["skip"],
 		message: `skip is ${imposition.skip}, but the grid has ${cells} cells; skip must be less than ${cells}`
 	});
-});
+}).transform(resolveImposition);
 const PageSize = z.union([
 	z.literal("fluid"),
 	Size,
@@ -170,4 +206,4 @@ function jsonSchemas() {
 	};
 }
 //#endregion
-export { Annotation, Board, BoardItem, BoardLabel, BoardSection, Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookView, Box, CUSTOM_PAPER_MAX_MM, CUSTOM_PAPER_MIN_MM, Chapter, Cue, DECK_SIZE, DEFAULT_TRANSITION_DURATION_MS, Deck, Direction, GridCell, ImageFit, Imposition, Lexicon, MAKE_ROOM_LIMIT, MARK_GAP_MM, MARK_LENGTH_MM, MAX_BOARD_ZOOM, MAX_IMPOSITION_CELLS, MAX_SLIDE_TIMING_MS, MAX_TRANSITION_DURATION_MS, MIN_BOARD_ITEM_WIDTH, MIN_BOARD_ZOOM, MIN_MARK_LENGTH_MM, MIN_TRANSITION_DURATION_MS, MM_PER_PT, Manifest, Margin, NAMED_PAPERS, Narration, NoteMarker, NumberSystem, ORIENTATIONS, Orientation, PAPER_GROUPS, PAPER_METADATA, PAPER_MM, PAPER_UNITS, PLAYBACK_MODES, PX_PER_MM, Page, PageSize, Paper, PaperUnit, Playback, Point, Print, PrintSetting, PrintSettingInput, PronunciationEntry, PublishedShot, SECTION_GAP, SECTION_MIN_SIZE, SECTION_PADDING, SECTION_TITLE_ROOM, SHOT_KEY, SLOT_TYPES, Scripts, Shot, Size, Slide, SlideContent, SlotDeclaration, SlotDeclarationInput, SlotType, Slots, SlotsInput, TextDirection, Transition, Word, addItem, annotationCueIssues, arrange, assignMembership, boardBounds, boardListing, boardListingIsEmpty, boardToScreen, deckFromSlides, deriveSectionCells, exceedsLimits, firstStrongDirection, fitPage, fitSection, fitTouchedSections, foldForSearch, formatNumber, fromMillimeters, gridDropMarkerBox, gridDropTarget, impose, impositionMarks, insertIntoGrid, isBookContents, isHebrew, itemAt, itemHeight, jsonSchemas, languageDirection, layoutSection, lexiconVersion, makeRoom, mergeSlotDeclarations, mirrorPlacement, moveItems, moveSection, nameMatches, noteMarker, noteMarkerIssues, pagePlacementLayout, paperPixels, parsePlayback, printBoxes, printPadding, printProperties, removeFromGrid, removeItems, resizeItem, resolveDirection, revealView, roundMillimeters, screenToBoard, settleBoard, sheetMm, shotsUsed, toMillimeters, visibleItems, zoomAt, zoomToFit };
+export { Annotation, Board, BoardItem, BoardLabel, BoardSection, Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookView, Box, CUSTOM_PAPER_MAX_MM, CUSTOM_PAPER_MIN_MM, Chapter, Cue, DECK_SIZE, DEFAULT_TRANSITION_DURATION_MS, Deck, Direction, FOLD_DASH_OFF_MM, FOLD_DASH_ON_MM, FOLD_KINDS, FOLD_TUCK_IN_MM, FillValues, GridCell, ImageFit, Imposition, Lexicon, MAKE_ROOM_LIMIT, MARK_GAP_MM, MARK_LENGTH_MM, MAX_BOARD_ZOOM, MAX_IMPOSITION_CELLS, MAX_SLIDE_TIMING_MS, MAX_TRANSITION_DURATION_MS, MIN_BOARD_ITEM_WIDTH, MIN_BOARD_ZOOM, MIN_MARK_LENGTH_MM, MIN_TRANSITION_DURATION_MS, MM_PER_PT, Manifest, Margin, MarkColor, NAMED_PAPERS, Narration, NoteMarker, NumberSystem, ORIENTATIONS, Orientation, PAPER_FIT_TOLERANCE_MM, PAPER_GROUPS, PAPER_METADATA, PAPER_MM, PAPER_UNITS, PLAYBACK_MODES, PX_PER_MM, Page, PageSize, Paper, PaperUnit, Playback, Point, Print, PrintSetting, PrintSettingInput, PronunciationEntry, PublishedShot, SECTION_GAP, SECTION_MIN_SIZE, SECTION_PADDING, SECTION_TITLE_ROOM, SHOT_KEY, SLOT_TYPES, Scripts, Shot, Size, Slide, SlideContent, SlotDeclaration, SlotDeclarationInput, SlotKey, SlotType, SlotValue, Slots, SlotsInput, TextDirection, Transition, Word, addItem, annotationCueIssues, arrange, assignMembership, boardBounds, boardListing, boardListingIsEmpty, boardToScreen, deckFromSlides, deriveSectionCells, exceedsLimits, firstStrongDirection, fitPage, fitSection, fitTouchedSections, foldCellPages, foldColumns, foldForSearch, foldPageCountMessage, foldPanelMap, formatNumber, fromMillimeters, gridDropMarkerBox, gridDropTarget, impose, impositionMarks, insertIntoGrid, isBookContents, isHebrew, itemAt, itemHeight, jsonSchemas, languageDirection, layoutSection, lexiconVersion, makeRoom, mergeSlotDeclarations, mirrorPlacement, moveItems, moveSection, nameMatches, noteMarker, noteMarkerIssues, pagePlacementLayout, paperPixels, parsePlayback, printBoxes, printPadding, printProperties, removeFromGrid, removeItems, resizeItem, resolveDirection, revealView, roundMillimeters, screenToBoard, settleBoard, sheetMm, shotsUsed, toMillimeters, visibleItems, zoomAt, zoomToFit };

package/dist/paper.d.ts

@@ -291,6 +291,8 @@ export type PrintSettingInput = z.input<typeof PrintSettingInput>;
 export declare const MM_PER_PT: number;
 export declare const MARK_LENGTH_MM = 5;
 export declare const MARK_GAP_MM = 1;
+export declare const FOLD_DASH_ON_MM = 2;
+export declare const FOLD_DASH_OFF_MM = 1;
 export declare const roundMillimeters: (mm: number) => number;
 export declare function toMillimeters(value: number, unit: PaperUnit): number;
 export declare function fromMillimeters(millimeters: number, unit: PaperUnit): number;
@@ -322,6 +324,7 @@ export interface MarkSegment {
   y1: number;
   x2: number;
   y2: number;
+  dashed?: boolean;
 }
 export interface PrintBoxes {
   media: {

package/dist/paper.js

@@ -206,6 +206,8 @@ const PrintSettingInput = z.strictObject(PrintSettingShape);
 const MM_PER_PT = 25.4 / 72;
 const MARK_LENGTH_MM = 5;
 const MARK_GAP_MM = 1;
+const FOLD_DASH_ON_MM = 2;
+const FOLD_DASH_OFF_MM = 1;
 const roundMillimeters = (mm) => Math.round(mm * 100) / 100;
 function toMillimeters(value, unit) {
 	return value * (unit === "in" ? 25.4 : unit === "pt" ? MM_PER_PT : 1);
@@ -483,4 +485,4 @@ function printBoxes(print) {
 	};
 }
 //#endregion
-export { CUSTOM_PAPER_MAX_MM, CUSTOM_PAPER_MIN_MM, MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, NAMED_PAPERS, ORIENTATIONS, Orientation, PAPER_GROUPS, PAPER_METADATA, PAPER_MM, PAPER_UNITS, PX_PER_MM, Paper, PaperUnit, PrintSetting, PrintSettingInput, fromMillimeters, paperPixels, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters };
+export { CUSTOM_PAPER_MAX_MM, CUSTOM_PAPER_MIN_MM, FOLD_DASH_OFF_MM, FOLD_DASH_ON_MM, MARK_GAP_MM, MARK_LENGTH_MM, MM_PER_PT, NAMED_PAPERS, ORIENTATIONS, Orientation, PAPER_GROUPS, PAPER_METADATA, PAPER_MM, PAPER_UNITS, PX_PER_MM, Paper, PaperUnit, PrintSetting, PrintSettingInput, fromMillimeters, paperPixels, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters };

package/dist/slots.d.ts

@@ -10,6 +10,8 @@ export declare const SlotType: z.ZodEnum<{
   image: "image";
 }>;
 export type SlotType = z.infer<typeof SlotType>;
+export declare const SlotKey: z.ZodString;
+export type SlotKey = z.infer<typeof SlotKey>;
 export declare const SlotDeclaration: z.ZodPipe<z.ZodObject<{
   key: z.ZodString;
   label: z.ZodString;
@@ -164,13 +166,18 @@ export declare const SlotsInput: z.ZodArray<z.ZodPipe<z.ZodObject<{
   minSize?: number | undefined;
 }>>>;
 export type SlotsInput = z.input<typeof SlotsInput>;
-export type SlotValue = string | {
-  asset: string;
-};
+export declare const SlotValue: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+  asset: z.ZodString;
+}, z.core.$strip>]>;
+export type SlotValue = z.infer<typeof SlotValue>;
+export declare const FillValues: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+  asset: z.ZodString;
+}, z.core.$strip>]>>;
+export type FillValues = z.infer<typeof FillValues>;
 export interface Fill {
   id: string;
   label?: string;
-  values: Record<string, SlotValue>;
+  values: FillValues;
 }
 export interface SlotSource {
   id: string;

package/dist/slots.js

@@ -9,8 +9,9 @@ const SLOT_TYPES = [
 	"image"
 ];
 const SlotType = z.enum(SLOT_TYPES);
+const SlotKey = z.string().regex(/^[^.\s]+(?:\.[^.\s]+)*$/, "a slot key must be a dotted path");
 const SlotDeclarationShape = {
-	key: z.string().regex(/^[^.\s]+(?:\.[^.\s]+)*$/, "a slot key must be a dotted path"),
+	key: SlotKey,
 	label: z.string().min(1),
 	type: SlotType,
 	required: z.boolean().default(false),
@@ -69,6 +70,8 @@ const SlotsInput = z.array(SlotDeclarationInput).superRefine((slots, ctx) => {
 		seen.add(slot.key);
 	});
 });
+const SlotValue = z.union([z.string(), z.object({ asset: z.string() })]);
+const FillValues = z.record(SlotKey, SlotValue);
 function mergeSlotDeclarations(...groups) {
 	const merged = /* @__PURE__ */ new Map();
 	for (const slot of groups.flat()) {
@@ -82,4 +85,4 @@ function mergeSlotDeclarations(...groups) {
 	return [...merged.values()];
 }
 //#endregion
-export { SLOT_TYPES, SlotDeclaration, SlotDeclarationInput, SlotType, Slots, SlotsInput, mergeSlotDeclarations };
+export { FillValues, SLOT_TYPES, SlotDeclaration, SlotDeclarationInput, SlotKey, SlotType, SlotValue, Slots, SlotsInput, mergeSlotDeclarations };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segnavia/format",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "type": "module",
   "license": "MIT",
   "repository": {