@segnavia/format 0.25.0 → 0.27.0

package/dist/index.js

@@ -5,10 +5,15 @@ 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 { Book, BookContents, BookFrontMatterEntry, BookMode, BookPage, BookSection, BookShape, BookView, Chapter, isBookContents, isHebrew, noteMarkerIssues } from "./book.js";
+import { APP_FONT_NAME, APP_FONT_NAME_MESSAGE, FONT_FORMATS, FONT_GENERICS, FontReference, FontReferenceInput, LocalFaceTransport, LocalFacesTransport, localFontReferences } from "./fonts.js";
+import { NoteMarker, NumberSystem, defaultPageNumbering, formatNumber, isHebrew, noteMarker } from "./numbering.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, 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 { BOOK_FURNITURE, LIBRARY_MOTIF_PREFIX, MOTIF_ATTRIBUTE, Motif, MotifField, MotifFieldInput, MotifInput, MotifVersion, MotifVersionInput, PRINTED_PAGE_CONTEXT, PRINTED_PAGE_FOLIO_PATH, PRINTED_PAGE_NUMBER_PATH, PRINTED_PAGE_RUNNING_HEAD_PATH, PRINTED_PAGE_TOTAL_PATH, chooseMotifVersion, motifFieldAttribute } from "./motif.js";
+import { BOOK_PARENT_NAMES, PRINTED_PAGE_LIMIT, PRINTED_PAGE_ROLES, ParentPage, ParentPageMargin, PrintedPageRules, PrintedPages, bookParentPages, pagePrintedPagesIssues, printedPagesIssues, resolveParentPages } from "./printed-pages.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";
 import { boardListing, boardListingIsEmpty, foldForSearch, nameMatches } from "./board-listing.js";
@@ -18,6 +23,7 @@ import { assignMembership, fitSection, fitTouchedSections, makeRoom, settleBoard
 import { deckFromSlides } from "./deck-from-slides.js";
 import { fitPage, impose, mirrorPlacement, pagePlacementLayout } from "./imposition.js";
 import { MIN_MARK_LENGTH_MM, impositionMarks } from "./imposition-marks.js";
+import { isPrintedPageIdentityImposition } from "./printed-page-imposition.js";
 import { shotsUsed } from "./shots-used.js";
 import { z } from "zod";
 //#region src/index.ts
@@ -27,14 +33,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 +75,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 +89,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 +159,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`
-	});
-	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`
+	refuseOverflow(ctx, paper, {
+		width: gridWidth,
+		height: gridHeight
 	});
-	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 +173,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,
@@ -150,7 +190,14 @@ const Page = z.object({
 	dir: Direction.optional(),
 	lang: z.string().optional(),
 	print: Print.optional(),
-	slots: Slots.optional()
+	printedPages: PrintedPages.optional(),
+	slots: Slots.optional(),
+	fonts: z.array(FontReference).optional()
+}).superRefine((page, ctx) => {
+	for (const issue of pagePrintedPagesIssues(page)) ctx.addIssue({
+		code: "custom",
+		...issue
+	});
 });
 function jsonSchemas() {
 	return {
@@ -166,8 +213,14 @@ function jsonSchemas() {
 		printSetting: z.toJSONSchema(PrintSetting, { io: "input" }),
 		printSettingInput: z.toJSONSchema(PrintSettingInput, { io: "input" }),
 		slotDeclaration: z.toJSONSchema(SlotDeclaration, { io: "input" }),
-		slotDeclarationInput: z.toJSONSchema(SlotDeclarationInput, { io: "input" })
+		slotDeclarationInput: z.toJSONSchema(SlotDeclarationInput, { io: "input" }),
+		fontReference: z.toJSONSchema(FontReference, { io: "input" }),
+		fontReferenceInput: z.toJSONSchema(FontReferenceInput, { io: "input" }),
+		localFaceTransport: z.toJSONSchema(LocalFaceTransport, { io: "input" }),
+		localFacesTransport: z.toJSONSchema(LocalFacesTransport, { io: "input" }),
+		motif: z.toJSONSchema(Motif, { io: "input" }),
+		motifInput: z.toJSONSchema(MotifInput, { io: "input" })
 	};
 }
 //#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, 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, 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, SlotKey, SlotType, SlotValue, 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 { APP_FONT_NAME, APP_FONT_NAME_MESSAGE, Annotation, BOOK_FURNITURE, BOOK_PARENT_NAMES, 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, FONT_FORMATS, FONT_GENERICS, FillValues, FontReference, FontReferenceInput, GridCell, ImageFit, Imposition, LIBRARY_MOTIF_PREFIX, Lexicon, LocalFaceTransport, LocalFacesTransport, 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, MOTIF_ATTRIBUTE, Manifest, Margin, MarkColor, Motif, MotifField, MotifFieldInput, MotifInput, MotifVersion, MotifVersionInput, NAMED_PAPERS, Narration, NoteMarker, NumberSystem, ORIENTATIONS, Orientation, PAPER_FIT_TOLERANCE_MM, PAPER_GROUPS, PAPER_METADATA, PAPER_MM, PAPER_UNITS, PLAYBACK_MODES, PRINTED_PAGE_CONTEXT, PRINTED_PAGE_FOLIO_PATH, PRINTED_PAGE_LIMIT, PRINTED_PAGE_NUMBER_PATH, PRINTED_PAGE_ROLES, PRINTED_PAGE_RUNNING_HEAD_PATH, PRINTED_PAGE_TOTAL_PATH, PX_PER_MM, Page, PageSize, Paper, PaperUnit, ParentPage, ParentPageMargin, Playback, Point, Print, PrintSetting, PrintSettingInput, PrintedPageRules, PrintedPages, 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, bookParentPages, chooseMotifVersion, deckFromSlides, defaultPageNumbering, deriveSectionCells, exceedsLimits, firstStrongDirection, fitPage, fitSection, fitTouchedSections, foldCellPages, foldColumns, foldForSearch, foldPageCountMessage, foldPanelMap, formatNumber, fromMillimeters, gridDropMarkerBox, gridDropTarget, impose, impositionMarks, insertIntoGrid, isBookContents, isHebrew, isPrintedPageIdentityImposition, itemAt, itemHeight, jsonSchemas, languageDirection, layoutSection, lexiconVersion, localFontReferences, makeRoom, mergeSlotDeclarations, mirrorPlacement, motifFieldAttribute, moveItems, moveSection, nameMatches, noteMarker, noteMarkerIssues, pagePlacementLayout, pagePrintedPagesIssues, paperPixels, parsePlayback, printBoxes, printPadding, printProperties, printedPagesIssues, removeFromGrid, removeItems, resizeItem, resolveDirection, resolveParentPages, revealView, roundMillimeters, screenToBoard, settleBoard, sheetMm, shotsUsed, toMillimeters, visibleItems, zoomAt, zoomToFit };

package/dist/motif.d.ts

@@ -0,0 +1,143 @@
+import { z } from "zod";
+//#region src/motif.d.ts
+export declare const MOTIF_ATTRIBUTE = "data-motif";
+export declare const PRINTED_PAGE_CONTEXT = "printedPage";
+export declare const PRINTED_PAGE_NUMBER_PATH = "printedPage.number";
+export declare const PRINTED_PAGE_TOTAL_PATH = "printedPage.total";
+export declare const PRINTED_PAGE_FOLIO_PATH = "printedPage.folio";
+export declare const PRINTED_PAGE_RUNNING_HEAD_PATH = "printedPage.runningHead";
+export declare const LIBRARY_MOTIF_PREFIX = "segnavia:";
+export declare const BOOK_FURNITURE: readonly [{
+  readonly key: "segnavia:folio";
+  readonly path: "printedPage.folio";
+  readonly value: "folio";
+  readonly className: "segnavia-folio";
+  readonly region: "foot";
+}, {
+  readonly key: "segnavia:running-head";
+  readonly path: "printedPage.runningHead";
+  readonly value: "runningHead";
+  readonly className: "segnavia-running-head";
+  readonly region: "head";
+}];
+export type BookFurniture = (typeof BOOK_FURNITURE)[number];
+export declare const motifFieldAttribute: (key: string) => string;
+export declare const MotifField: z.ZodObject<{
+  key: z.ZodString;
+  label: z.ZodString;
+  choices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  default: z.ZodOptional<z.ZodString>;
+  required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type MotifField = z.infer<typeof MotifField>;
+export declare const MotifFieldInput: z.ZodObject<{
+  key: z.ZodString;
+  label: z.ZodString;
+  choices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  default: z.ZodOptional<z.ZodString>;
+  required: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type MotifFieldInput = z.input<typeof MotifFieldInput>;
+export declare const MotifVersion: z.ZodObject<{
+  lang: z.ZodString;
+  dir: z.ZodOptional<z.ZodEnum<{
+    ltr: "ltr";
+    rtl: "rtl";
+  }>>;
+  when: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  html: z.ZodString;
+}, z.core.$strip>;
+export type MotifVersion = z.infer<typeof MotifVersion>;
+export declare const MotifVersionInput: z.ZodObject<{
+  lang: z.ZodString;
+  dir: z.ZodOptional<z.ZodEnum<{
+    ltr: "ltr";
+    rtl: "rtl";
+  }>>;
+  when: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  html: z.ZodString;
+}, z.core.$strict>;
+export type MotifVersionInput = z.input<typeof MotifVersionInput>;
+export declare const Motif: z.ZodObject<{
+  key: z.ZodString;
+  revision: z.ZodString;
+  label: z.ZodString;
+  fields: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    choices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    default: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  versions: z.ZodArray<z.ZodObject<{
+    lang: z.ZodString;
+    dir: z.ZodOptional<z.ZodEnum<{
+      ltr: "ltr";
+      rtl: "rtl";
+    }>>;
+    when: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    html: z.ZodString;
+  }, z.core.$strip>>;
+  fonts: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    app: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    local: z.ZodString;
+    fallback: z.ZodString;
+  }, z.core.$strip>]>>>;
+}, z.core.$strip>;
+export type Motif = z.infer<typeof Motif>;
+export declare const MotifInput: z.ZodObject<{
+  fields: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    choices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    default: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strict>>;
+  versions: z.ZodArray<z.ZodObject<{
+    lang: z.ZodString;
+    dir: z.ZodOptional<z.ZodEnum<{
+      ltr: "ltr";
+      rtl: "rtl";
+    }>>;
+    when: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    html: z.ZodString;
+  }, z.core.$strict>>;
+  fonts: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    app: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    local: z.ZodString;
+    fallback: z.ZodString;
+  }, z.core.$strict>]>>>;
+  key: z.ZodString;
+  revision: z.ZodString;
+  label: z.ZodString;
+}, z.core.$strict>;
+export type MotifInput = z.input<typeof MotifInput>;
+export interface MotifPlacement {
+  key: string;
+  revision: string;
+  lang: string;
+  fields: Record<string, string>;
+}
+export interface MotifSource {
+  motif(key: string, options: {
+    revision?: string;
+    signal: AbortSignal;
+  }): Promise<Motif | undefined>;
+  data?(placement: MotifPlacement, options: {
+    signal: AbortSignal;
+  }): Promise<Record<string, unknown>>;
+}
+export type MotifVersionChoice = {
+  ok: true;
+  version: MotifVersion;
+  index: number;
+} | {
+  ok: false;
+  reason: string;
+};
+export declare function chooseMotifVersion(motif: Motif, values: {
+  lang?: string;
+} & Record<string, string | undefined>): MotifVersionChoice;
+//#endregion

package/dist/motif.js

@@ -0,0 +1,175 @@
+import { SlotKey } from "./slots.js";
+import { FontReference, FontReferenceInput } from "./fonts.js";
+import { z } from "zod";
+//#region src/motif.ts
+const MOTIF_ATTRIBUTE = "data-motif";
+const PRINTED_PAGE_CONTEXT = "printedPage";
+const PRINTED_PAGE_NUMBER_PATH = `${PRINTED_PAGE_CONTEXT}.number`;
+const PRINTED_PAGE_TOTAL_PATH = `${PRINTED_PAGE_CONTEXT}.total`;
+const PRINTED_PAGE_FOLIO_PATH = `${PRINTED_PAGE_CONTEXT}.folio`;
+const PRINTED_PAGE_RUNNING_HEAD_PATH = `${PRINTED_PAGE_CONTEXT}.runningHead`;
+const LIBRARY_MOTIF_PREFIX = "segnavia:";
+const BOOK_FURNITURE = [{
+	key: "segnavia:folio",
+	path: PRINTED_PAGE_FOLIO_PATH,
+	value: "folio",
+	className: "segnavia-folio",
+	region: "foot"
+}, {
+	key: "segnavia:running-head",
+	path: PRINTED_PAGE_RUNNING_HEAD_PATH,
+	value: "runningHead",
+	className: "segnavia-running-head",
+	region: "head"
+}];
+const motifFieldAttribute = (key) => `${MOTIF_ATTRIBUTE}-${key}`;
+const uniqueChoices = (field, ctx) => {
+	if (field.choices && new Set(field.choices).size !== field.choices.length) ctx.addIssue({
+		code: "custom",
+		path: ["choices"],
+		message: "choices must be unique"
+	});
+	if (field.choices && field.default !== void 0 && !field.choices.includes(field.default)) ctx.addIssue({
+		code: "custom",
+		path: ["default"],
+		message: "default must be one of the field choices"
+	});
+};
+const MotifFieldShape = {
+	key: SlotKey,
+	label: z.string().min(1),
+	choices: z.array(z.string()).min(1).optional(),
+	default: z.string().optional(),
+	required: z.boolean().default(false)
+};
+const MotifField = z.object(MotifFieldShape).superRefine(uniqueChoices);
+const MotifFieldInput = z.strictObject(MotifFieldShape).superRefine(uniqueChoices);
+const MotifVersionShape = {
+	lang: z.string().min(1),
+	dir: z.enum(["ltr", "rtl"]).optional(),
+	when: z.record(SlotKey, z.string()).optional(),
+	html: z.string()
+};
+const MotifVersion = z.object(MotifVersionShape);
+const MotifVersionInput = z.strictObject(MotifVersionShape);
+const validateMotif = (motif, ctx) => {
+	const fields = new Map(motif.fields.map((field) => [field.key, field]));
+	const fieldCases = /* @__PURE__ */ new Map();
+	motif.fields.forEach((field, index) => {
+		const normalized = field.key.toLowerCase();
+		if (field.key.toLowerCase() === "lang") ctx.addIssue({
+			code: "custom",
+			path: [
+				"fields",
+				index,
+				"key"
+			],
+			message: "lang is always present and must not be declared"
+		});
+		const previous = fieldCases.get(normalized);
+		if (previous !== void 0) ctx.addIssue({
+			code: "custom",
+			path: [
+				"fields",
+				index,
+				"key"
+			],
+			message: `field key differs only by case from field ${previous + 1}`
+		});
+		else fieldCases.set(normalized, index);
+	});
+	const seen = /* @__PURE__ */ new Map();
+	motif.versions.forEach((version, index) => {
+		for (const [key, value] of Object.entries(version.when ?? {})) {
+			const field = fields.get(key);
+			if (!field?.choices) ctx.addIssue({
+				code: "custom",
+				path: [
+					"versions",
+					index,
+					"when",
+					key
+				],
+				message: `when key "${key}" must name a choice field`
+			});
+			else if (!field.choices.includes(value)) ctx.addIssue({
+				code: "custom",
+				path: [
+					"versions",
+					index,
+					"when",
+					key
+				],
+				message: `when value "${value}" must be one of the choices for "${key}"`
+			});
+		}
+		const conditions = Object.entries(version.when ?? {}).sort(([left], [right]) => left.localeCompare(right));
+		const signature = JSON.stringify([version.lang.toLowerCase(), conditions]);
+		const previous = seen.get(signature);
+		if (previous !== void 0) ctx.addIssue({
+			code: "custom",
+			path: ["versions", index],
+			message: `version duplicates version ${previous + 1} for the same lang and when values`
+		});
+		else seen.set(signature, index);
+	});
+};
+const MotifShape = {
+	key: SlotKey,
+	revision: z.string().min(1),
+	label: z.string().min(1),
+	fields: z.array(MotifField),
+	versions: z.array(MotifVersion).min(1),
+	fonts: z.array(FontReference).default([])
+};
+const MotifInputShape = {
+	...MotifShape,
+	fields: z.array(MotifFieldInput),
+	versions: z.array(MotifVersionInput).min(1),
+	fonts: z.array(FontReferenceInput).default([])
+};
+const Motif = z.object(MotifShape).superRefine(validateMotif);
+const MotifInput = z.strictObject(MotifInputShape).superRefine(validateMotif);
+function chooseMotifVersion(motif, values) {
+	const suppliedLang = values.lang;
+	const langs = new Map(motif.versions.map((version) => [version.lang.toLowerCase(), version.lang]));
+	const lang = suppliedLang ?? (langs.size === 1 ? langs.values().next().value : void 0);
+	if (!lang) return {
+		ok: false,
+		reason: "no language was supplied and the motif has more than one language"
+	};
+	const resolved = Object.fromEntries(motif.fields.map((field) => [field.key, values[field.key] ?? field.default]));
+	const normalized = lang.toLowerCase();
+	const primary = normalized.split("-")[0];
+	const matches = motif.versions.map((version, index) => ({
+		version,
+		index
+	})).filter(({ version }) => {
+		const versionLang = version.lang.toLowerCase();
+		const versionPrimary = versionLang.split("-")[0];
+		if (versionLang !== normalized && versionPrimary !== primary) return false;
+		return Object.entries(version.when ?? {}).every(([key, value]) => resolved[key] === value);
+	}).map((match) => ({
+		...match,
+		exact: match.version.lang.toLowerCase() === normalized,
+		specificity: Object.keys(match.version.when ?? {}).length
+	}));
+	if (matches.length === 0) return {
+		ok: false,
+		reason: `no version matches language "${lang}" and the supplied field values`
+	};
+	matches.sort((left, right) => Number(right.exact) - Number(left.exact) || right.specificity - left.specificity);
+	const best = matches[0];
+	const tied = matches.filter((match) => match.exact === best.exact && match.specificity === best.specificity);
+	if (tied.length > 1) return {
+		ok: false,
+		reason: `versions ${tied.map((match) => match.index + 1).join(", ")} match equally specifically`
+	};
+	return {
+		ok: true,
+		version: best.version,
+		index: best.index
+	};
+}
+//#endregion
+export { BOOK_FURNITURE, LIBRARY_MOTIF_PREFIX, MOTIF_ATTRIBUTE, Motif, MotifField, MotifFieldInput, MotifInput, MotifVersion, MotifVersionInput, PRINTED_PAGE_CONTEXT, PRINTED_PAGE_FOLIO_PATH, PRINTED_PAGE_NUMBER_PATH, PRINTED_PAGE_RUNNING_HEAD_PATH, PRINTED_PAGE_TOTAL_PATH, chooseMotifVersion, motifFieldAttribute };

package/dist/numbering.d.ts

@@ -7,6 +7,8 @@ export declare const NumberSystem: z.ZodEnum<{
   hebrew: "hebrew";
 }>;
 export type NumberSystem = z.infer<typeof NumberSystem>;
+export declare function isHebrew(lang: string | undefined): boolean;
+export declare function defaultPageNumbering(lang: string | undefined): NumberSystem;
 export declare const NoteMarker: z.ZodUnion<readonly [z.ZodEnum<{
   arabic: "arabic";
   "roman-lower": "roman-lower";

package/dist/numbering.js

@@ -6,6 +6,13 @@ const NumberSystem = z.enum([
 	"roman-upper",
 	"hebrew"
 ]);
+function isHebrew(lang) {
+	const primary = lang?.split("-")[0]?.toLowerCase();
+	return primary === "he" || primary === "iw";
+}
+function defaultPageNumbering(lang) {
+	return isHebrew(lang) ? "hebrew" : "arabic";
+}
 const NoteMarker = z.union([NumberSystem, z.literal("symbols")]);
 const ROMAN_DIGITS = [
 	[1e3, "M"],
@@ -103,4 +110,4 @@ function noteMarker(index, marker) {
 	return NOTE_SYMBOLS[(index - 1) % NOTE_SYMBOLS.length].repeat(Math.ceil(index / NOTE_SYMBOLS.length));
 }
 //#endregion
-export { NoteMarker, NumberSystem, formatNumber, noteMarker };
+export { NoteMarker, NumberSystem, defaultPageNumbering, formatNumber, isHebrew, noteMarker };

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/printed-page-imposition.d.ts

@@ -0,0 +1,5 @@
+import { Imposition, Print } from "./index.js";
+//#region src/printed-page-imposition.d.ts
+/** True when an imposition leaves one printed page unchanged on one paper. */
+export declare function isPrintedPageIdentityImposition(print: Print, imposition: Imposition): boolean;
+//#endregion

package/dist/printed-page-imposition.js

@@ -0,0 +1,12 @@
+import { sheetMm, toMillimeters } from "./paper.js";
+//#region src/printed-page-imposition.ts
+const close = (left, right) => Math.abs(left - right) <= .01;
+/** True when an imposition leaves one printed page unchanged on one paper. */
+function isPrintedPageIdentityImposition(print, imposition) {
+	const pagePaper = sheetMm(print);
+	const imposedPaper = sheetMm(imposition);
+	const mm = (value) => toMillimeters(value, imposition.unit);
+	return print.orientation === imposition.orientation && close(pagePaper.width, imposedPaper.width) && close(pagePaper.height, imposedPaper.height) && imposition.columns === 1 && imposition.rows === 1 && close(mm(imposition.cell.width ?? 0), pagePaper.width) && close(mm(imposition.cell.height), pagePaper.height) && Object.values(imposition.margin).every((value) => value === 0) && imposition.gap.column === 0 && imposition.gap.row === 0 && imposition.bleed === 0 && imposition.marks === false && imposition.cornerMarks === false && imposition.fill === "sequence" && imposition.sides !== "two" && imposition.skip === 0 && imposition.fold === void 0;
+}
+//#endregion
+export { isPrintedPageIdentityImposition };