@segnavia/format 0.25.0 → 0.27.0

package/dist/book.d.ts

@@ -93,12 +93,17 @@ export declare const BookView: z.ZodObject<{
     sandboxed: "sandboxed";
   }>>;
   lang: z.ZodOptional<z.ZodString>;
+  fonts: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    app: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    local: z.ZodString;
+    fallback: z.ZodString;
+  }, z.core.$strip>]>>>;
   title: z.ZodOptional<z.ZodString>;
   html: z.ZodString;
 }, z.core.$strip>;
 export type BookView = z.infer<typeof BookView>;
 export type BookViewInput = z.input<typeof BookView>;
-export declare function isHebrew(lang: string | undefined): boolean;
 export declare const Book: z.ZodPipe<z.ZodObject<{
   title: z.ZodString;
   mode: z.ZodEnum<{
@@ -177,6 +182,12 @@ export declare const Book: z.ZodPipe<z.ZodObject<{
     html: z.ZodString;
     runningHead: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>;
+  fonts: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    app: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    local: z.ZodString;
+    fallback: z.ZodString;
+  }, z.core.$strip>]>>>;
   numbering: z.ZodDefault<z.ZodObject<{
     frontMatter: z.ZodOptional<z.ZodEnum<{
       arabic: "arabic";
@@ -272,6 +283,12 @@ export declare const Book: z.ZodPipe<z.ZodObject<{
   } | undefined;
   dir?: "ltr" | "rtl" | "auto" | undefined;
   lang?: string | undefined;
+  fonts?: ({
+    app: string;
+  } | {
+    local: string;
+    fallback: string;
+  })[] | undefined;
 }, {
   title: string;
   mode: "continuous" | "paginated";
@@ -323,6 +340,12 @@ export declare const Book: z.ZodPipe<z.ZodObject<{
   } | undefined;
   dir?: "ltr" | "rtl" | "auto" | undefined;
   lang?: string | undefined;
+  fonts?: ({
+    app: string;
+  } | {
+    local: string;
+    fallback: string;
+  })[] | undefined;
 }>>;
 export type Book = z.infer<typeof Book>;
 export type BookInput = z.input<typeof Book>;

package/dist/book.js

@@ -1,6 +1,7 @@
 import { Direction } from "./direction.js";
 import { Scripts } from "./scripts.js";
-import { NoteMarker, NumberSystem } from "./numbering.js";
+import { FontReference } from "./fonts.js";
+import { NoteMarker, NumberSystem, isHebrew } from "./numbering.js";
 import { Orientation, Paper, sheetMm } from "./paper.js";
 import { z } from "zod";
 //#region src/book.ts
@@ -42,6 +43,7 @@ const BookShape = z.object({
 	lang: z.string().optional(),
 	frontMatter: z.array(BookFrontMatterEntry).default([]),
 	chapters: z.array(Chapter).min(1),
+	fonts: z.array(FontReference).optional(),
 	numbering: z.object({
 		frontMatter: NumberSystem.optional(),
 		body: NumberSystem.optional()
@@ -68,15 +70,12 @@ const BookView = BookShape.pick({
 	title: true,
 	dir: true,
 	lang: true,
-	scripts: true
+	scripts: true,
+	fonts: true
 }).extend({
 	title: BookShape.shape.title.optional(),
 	html: z.string()
 });
-function isHebrew(lang) {
-	const primary = lang?.split("-")[0]?.toLowerCase();
-	return primary === "he" || primary === "iw";
-}
 const Book = BookShape.transform((book) => {
 	const hebrew = isHebrew(book.lang);
 	return {
@@ -137,4 +136,4 @@ function noteMarkerIssues(book, used) {
 	return [`footnote and endnote markers are both ${book.footnotes.marker}; the two must differ when both kinds are used`];
 }
 //#endregion
-export { Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookShape, BookView, Chapter, isBookContents, isHebrew, noteMarkerIssues };
+export { Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookShape, BookView, Chapter, isBookContents, noteMarkerIssues };

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/fonts.d.ts

@@ -0,0 +1,77 @@
+import { z } from "zod";
+//#region src/fonts.d.ts
+export declare const APP_FONT_NAME: RegExp;
+export declare const APP_FONT_NAME_MESSAGE = "app font names are lowercase letters, digits and hyphens";
+export declare const FontReference: z.ZodUnion<readonly [z.ZodObject<{
+  app: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  local: z.ZodString;
+  fallback: z.ZodString;
+}, z.core.$strip>]>;
+export type FontReference = z.infer<typeof FontReference>;
+export declare const FontReferenceInput: z.ZodUnion<readonly [z.ZodObject<{
+  app: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  local: z.ZodString;
+  fallback: z.ZodString;
+}, z.core.$strict>]>;
+export type FontReferenceInput = z.input<typeof FontReferenceInput>;
+export declare function localFontReferences(references: readonly FontReference[]): Array<{
+  local: string;
+  fallback: string;
+}>;
+export declare const FONT_FORMATS: readonly ["woff2", "woff", "truetype", "opentype"];
+export type FontFormat = (typeof FONT_FORMATS)[number];
+export declare const LocalFaceTransport: z.ZodObject<{
+  family: z.ZodString;
+  format: z.ZodEnum<{
+    woff2: "woff2";
+    woff: "woff";
+    truetype: "truetype";
+    opentype: "opentype";
+  }>;
+  weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+  style: z.ZodOptional<z.ZodEnum<{
+    normal: "normal";
+    italic: "italic";
+  }>>;
+  data: z.ZodString;
+}, z.core.$strict>;
+export type LocalFaceTransport = z.infer<typeof LocalFaceTransport>;
+export declare const LocalFacesTransport: z.ZodArray<z.ZodObject<{
+  family: z.ZodString;
+  format: z.ZodEnum<{
+    woff2: "woff2";
+    woff: "woff";
+    truetype: "truetype";
+    opentype: "opentype";
+  }>;
+  weight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+  style: z.ZodOptional<z.ZodEnum<{
+    normal: "normal";
+    italic: "italic";
+  }>>;
+  data: z.ZodString;
+}, z.core.$strict>>;
+export type LocalFacesInput = LocalFaceTransport[];
+export declare const FONT_GENERICS: readonly ["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui"];
+export type FontGeneric = (typeof FONT_GENERICS)[number];
+export interface FontFace {
+  family: string;
+  data: Uint8Array;
+  format: FontFormat;
+  weight?: number | string;
+  style?: 'normal' | 'italic';
+  unicodeRange?: string;
+}
+export interface AppFont {
+  family: string;
+  faces: FontFace[];
+  generic?: FontGeneric;
+}
+export interface FontSource {
+  font(name: string, options: {
+    signal: AbortSignal;
+  }): Promise<AppFont | undefined>;
+}
+//#endregion

package/dist/fonts.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+//#region src/fonts.ts
+const APP_FONT_NAME = /^[a-z0-9-]+$/;
+const APP_FONT_NAME_MESSAGE = "app font names are lowercase letters, digits and hyphens";
+const AppFontName = z.string().min(1).regex(APP_FONT_NAME, APP_FONT_NAME_MESSAGE);
+const AppFontShape = { app: AppFontName };
+const LocalFontShape = {
+	local: z.string().min(1),
+	fallback: AppFontName
+};
+const FontReference = z.union([z.object(AppFontShape), z.object(LocalFontShape)]);
+const FontReferenceInput = z.union([z.strictObject(AppFontShape), z.strictObject(LocalFontShape)]);
+function localFontReferences(references) {
+	const seen = /* @__PURE__ */ new Set();
+	const locals = [];
+	for (const reference of references) {
+		if (!("local" in reference)) continue;
+		const key = JSON.stringify(reference);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		locals.push(reference);
+	}
+	return locals;
+}
+const FONT_FORMATS = [
+	"woff2",
+	"woff",
+	"truetype",
+	"opentype"
+];
+const LocalFaceTransportShape = {
+	family: z.string().min(1),
+	format: z.enum(FONT_FORMATS),
+	weight: z.union([z.number(), z.string()]).optional(),
+	style: z.enum(["normal", "italic"]).optional(),
+	data: z.string()
+};
+const LocalFaceTransport = z.strictObject(LocalFaceTransportShape);
+const LocalFacesTransport = z.array(LocalFaceTransport);
+const FONT_GENERICS = [
+	"serif",
+	"sans-serif",
+	"monospace",
+	"cursive",
+	"fantasy",
+	"system-ui"
+];
+//#endregion
+export { APP_FONT_NAME, APP_FONT_NAME_MESSAGE, FONT_FORMATS, FONT_GENERICS, FontReference, FontReferenceInput, LocalFaceTransport, LocalFacesTransport, localFontReferences };

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 };