@segnavia/format 0.37.0 → 0.39.0

package/dist/page.d.ts

@@ -0,0 +1,174 @@
+import { z } from "zod";
+//#region src/page.d.ts
+export declare const FLUID_WIDTH = 1024;
+export declare const PageSize: z.ZodUnion<readonly [z.ZodLiteral<"fluid">, z.ZodObject<{
+  width: z.ZodNumber;
+  height: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  width: z.ZodNumber;
+  height: z.ZodLiteral<"auto">;
+}, z.core.$strip>]>;
+export type PageSize = z.infer<typeof PageSize>;
+export declare const Page: z.ZodObject<{
+  id: z.ZodOptional<z.ZodString>;
+  html: z.ZodString;
+  size: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"fluid">, z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+  }, z.core.$strip>, z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodLiteral<"auto">;
+  }, z.core.$strip>]>>;
+  scripts: z.ZodDefault<z.ZodEnum<{
+    refuse: "refuse";
+    sandboxed: "sandboxed";
+  }>>;
+  dir: z.ZodOptional<z.ZodEnum<{
+    auto: "auto";
+    ltr: "ltr";
+    rtl: "rtl";
+  }>>;
+  lang: z.ZodOptional<z.ZodString>;
+  print: z.ZodOptional<z.ZodObject<{
+    paper: z.ZodUnion<readonly [z.ZodEnum<{
+      letter: "letter";
+      legal: "legal";
+      tabloid: "tabloid";
+      a3: "a3";
+      a4: "a4";
+      a5: "a5";
+      "business-card-us": "business-card-us";
+      "business-card-eu": "business-card-eu";
+      "business-card-square-us": "business-card-square-us";
+      "business-card-slim-us": "business-card-slim-us";
+      "postcard-4x6": "postcard-4x6";
+      "postcard-5x7": "postcard-5x7";
+      "postcard-6x9": "postcard-6x9";
+      "postcard-6x11": "postcard-6x11";
+      "card-square-4in": "card-square-4in";
+      "half-letter": "half-letter";
+      a6: "a6";
+      dl: "dl";
+      "rack-card-4x9": "rack-card-4x9";
+      "rack-card-3.5x8.5": "rack-card-3.5x8.5";
+      "poster-12x18": "poster-12x18";
+      "poster-16x20": "poster-16x20";
+      "poster-18x24": "poster-18x24";
+      "poster-24x36": "poster-24x36";
+      a2: "a2";
+      a1: "a1";
+      a0: "a0";
+    }>, z.ZodObject<{
+      width: z.ZodNumber;
+      height: z.ZodNumber;
+      unit: z.ZodEnum<{
+        mm: "mm";
+        in: "in";
+        pt: "pt";
+      }>;
+    }, z.core.$strip>]>;
+    orientation: z.ZodDefault<z.ZodEnum<{
+      portrait: "portrait";
+      landscape: "landscape";
+    }>>;
+    margin: z.ZodOptional<z.ZodObject<{
+      top: z.ZodDefault<z.ZodNumber>;
+      right: z.ZodDefault<z.ZodNumber>;
+      bottom: z.ZodDefault<z.ZodNumber>;
+      left: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    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>>;
+  printedPages: z.ZodOptional<z.ZodObject<{
+    parents: z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      basedOn: z.ZodOptional<z.ZodString>;
+      margin: z.ZodOptional<z.ZodObject<{
+        top: z.ZodNumber;
+        bottom: z.ZodNumber;
+        inner: z.ZodNumber;
+        outer: z.ZodNumber;
+      }, z.core.$strip>>;
+      head: z.ZodOptional<z.ZodString>;
+      foot: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    rules: z.ZodPipe<z.ZodObject<{
+      every: z.ZodString;
+      first: z.ZodOptional<z.ZodString>;
+      recto: z.ZodOptional<z.ZodString>;
+      verso: z.ZodOptional<z.ZodString>;
+      last: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodTransform<{
+      last?: string | undefined;
+      verso?: string | undefined;
+      recto?: string | undefined;
+      first?: string | undefined;
+      every: string;
+    }, {
+      [x: string]: unknown;
+      every: string;
+      first?: string | undefined;
+      recto?: string | undefined;
+      verso?: string | undefined;
+      last?: string | undefined;
+    }>>;
+    numbering: z.ZodOptional<z.ZodEnum<{
+      arabic: "arabic";
+      "roman-lower": "roman-lower";
+      "roman-upper": "roman-upper";
+      hebrew: "hebrew";
+    }>>;
+  }, z.core.$strip>>;
+  slots: z.ZodOptional<z.ZodArray<z.ZodPipe<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    type: z.ZodEnum<{
+      text: "text";
+      image: "image";
+      phone: "phone";
+      email: "email";
+      link: "link";
+      qr: "qr";
+    }>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    placeholder: z.ZodOptional<z.ZodString>;
+    overflow: z.ZodDefault<z.ZodEnum<{
+      refuse: "refuse";
+      shrink: "shrink";
+      truncate: "truncate";
+      wrap: "wrap";
+    }>>;
+    minSize: z.ZodOptional<z.ZodNumber>;
+  }, z.core.$strip>, z.ZodTransform<{
+    key: string;
+    label: string;
+    type: "text" | "image" | "phone" | "email" | "link" | "qr";
+    required: boolean;
+    overflow: "refuse" | "shrink" | "truncate" | "wrap";
+    placeholder?: string | undefined;
+    minSize?: number | undefined;
+  }, {
+    key: string;
+    label: string;
+    type: "text" | "image" | "phone" | "email" | "link" | "qr";
+    required: boolean;
+    overflow: "refuse" | "shrink" | "truncate" | "wrap";
+    placeholder?: string | undefined;
+    minSize?: number | undefined;
+  }>>>>;
+  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>]>>>;
+}, z.core.$strip>;
+export type Page = z.infer<typeof Page>;
+export type PageInput = z.input<typeof Page>;
+//#endregion

package/dist/page.js

@@ -0,0 +1,37 @@
+import { Direction } from "./direction.js";
+import { Size } from "./geometry.js";
+import { Scripts } from "./scripts.js";
+import { Slots } from "./slots.js";
+import { FontReference } from "./fonts.js";
+import { PrintedPages, pagePrintedPagesIssues } from "./printed-pages.js";
+import { Print } from "./print.js";
+import { z } from "zod";
+//#region src/page.ts
+const FLUID_WIDTH = 1024;
+const PageSize = z.union([
+	z.literal("fluid"),
+	Size,
+	z.object({
+		width: z.number().int().positive(),
+		height: z.literal("auto")
+	})
+]);
+const Page = z.object({
+	id: z.string().optional(),
+	html: z.string(),
+	size: PageSize.default("fluid"),
+	scripts: Scripts.default("refuse"),
+	dir: Direction.optional(),
+	lang: z.string().optional(),
+	print: Print.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
+	});
+});
+//#endregion
+export { FLUID_WIDTH, Page, PageSize };

package/dist/paper.d.ts

@@ -1,4 +1,4 @@
-import { Print } from "./index.js";
+import { Print } from "./print.js";
 import { z } from "zod";
 //#region src/paper.d.ts
 export declare const NAMED_PAPERS: readonly ["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"];
@@ -305,6 +305,7 @@ export declare function sheetMm(print: Pick<Print, 'paper' | 'orientation'>): {
   height: number;
 };
 export declare const PX_PER_MM: number;
+export declare const PX_PER_PT: number;
 export declare const paperPixels: (millimeters: number) => number;
 export declare function printProperties(print: Pick<Print, 'bleed' | 'safe'>, unit?: 'mm' | 'in' | 'pt'): string;
 export declare function printPadding(edges: {

package/dist/paper.js

@@ -375,6 +375,7 @@ function sheetMm(print) {
 	};
 }
 const PX_PER_MM = 96 / 25.4;
+const PX_PER_PT = PX_PER_MM * MM_PER_PT;
 const paperPixels = (millimeters) => Math.ceil(millimeters * PX_PER_MM - 1e-9);
 function printProperties(print, unit = "mm") {
 	return `:root{--segnavia-bleed:${roundMillimeters(toMillimeters(print.bleed, unit))}mm;--segnavia-safe:${roundMillimeters(toMillimeters(print.safe, unit))}mm}`;
@@ -485,4 +486,4 @@ function printBoxes(print) {
 	};
 }
 //#endregion
-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 };
+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, PX_PER_PT, Paper, PaperUnit, PrintSetting, PrintSettingInput, fromMillimeters, paperPixels, printBoxes, printPadding, printProperties, roundMillimeters, sheetMm, toMillimeters };

package/dist/placement-cycle.d.ts

@@ -0,0 +1,5 @@
+//#region src/placement-cycle.d.ts
+export type PlacementGraph = Readonly<Record<string, readonly string[]>>;
+export declare function findPlacementCycle(graph: PlacementGraph): string[] | undefined;
+export declare function checkPlacementCycles(graph: PlacementGraph): void;
+//#endregion

package/dist/placement-cycle.js

@@ -0,0 +1,30 @@
+import { PlacementRefusedError } from "./placement-refusal.js";
+//#region src/placement-cycle.ts
+function findPlacementCycle(graph) {
+	const visiting = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const path = [];
+	const visit = (address) => {
+		if (visiting.has(address)) return [...path.slice(path.indexOf(address)), address];
+		if (visited.has(address)) return void 0;
+		visiting.add(address);
+		path.push(address);
+		for (const child of graph[address] ?? []) {
+			const cycle = visit(child);
+			if (cycle) return cycle;
+		}
+		path.pop();
+		visiting.delete(address);
+		visited.add(address);
+	};
+	for (const address of Object.keys(graph)) {
+		const cycle = visit(address);
+		if (cycle) return cycle;
+	}
+}
+function checkPlacementCycles(graph) {
+	const cycle = findPlacementCycle(graph);
+	if (cycle) throw new PlacementRefusedError(`address could not be accepted because the placement chain ${cycle.join(" → ")} is a cycle; remove any one placement in the chain to clear this refusal`);
+}
+//#endregion
+export { checkPlacementCycles, findPlacementCycle };

package/dist/placement-refusal.d.ts

@@ -0,0 +1,5 @@
+//#region src/placement-refusal.d.ts
+export declare class PlacementRefusedError extends Error {
+  name: string;
+}
+//#endregion

package/dist/placement-refusal.js

@@ -0,0 +1,6 @@
+//#region src/placement-refusal.ts
+var PlacementRefusedError = class extends Error {
+	name = "PlacementRefusedError";
+};
+//#endregion
+export { PlacementRefusedError };

package/dist/placement.d.ts

@@ -0,0 +1,76 @@
+import { Media } from "./media.js";
+import { z } from "zod";
+//#region src/placement.d.ts
+export declare const PLACEMENT_ACCEPTS: {
+  readonly board: readonly ["deck", "page", "paper", "book", "media", "shot"];
+  readonly book: readonly ["media", "page"];
+  readonly page: readonly ["media"];
+  readonly deck: readonly ["media"];
+  readonly paper: readonly ["media"];
+};
+export declare const AssetKind: z.ZodEnum<{
+  deck: "deck";
+  page: "page";
+  paper: "paper";
+  book: "book";
+  media: "media";
+  shot: "shot";
+}>;
+export type AssetKind = z.infer<typeof AssetKind>;
+export type PlacementContainer = keyof typeof PLACEMENT_ACCEPTS;
+export declare const CropEdge: z.ZodString;
+export type CropEdge = z.infer<typeof CropEdge>;
+export declare const PlacementCrop: z.ZodObject<{
+  top: z.ZodOptional<z.ZodString>;
+  right: z.ZodOptional<z.ZodString>;
+  bottom: z.ZodOptional<z.ZodString>;
+  left: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PlacementCrop = z.infer<typeof PlacementCrop>;
+export declare const PlacementShape: z.ZodObject<{
+  kind: z.ZodEnum<{
+    deck: "deck";
+    page: "page";
+    paper: "paper";
+    book: "book";
+    media: "media";
+    shot: "shot";
+  }>;
+  address: z.ZodString;
+  page: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+  box: z.ZodOptional<z.ZodEnum<{
+    media: "media";
+    bleed: "bleed";
+    crop: "crop";
+    trim: "trim";
+    art: "art";
+  }>>;
+  crop: z.ZodOptional<z.ZodObject<{
+    top: z.ZodOptional<z.ZodString>;
+    right: z.ZodOptional<z.ZodString>;
+    bottom: z.ZodOptional<z.ZodString>;
+    left: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  fit: z.ZodOptional<z.ZodEnum<{
+    width: "width";
+    contain: "contain";
+    cover: "cover";
+    focus: "focus";
+  }>>;
+  alt: z.ZodOptional<z.ZodObject<{
+    text: z.ZodString;
+    lang: z.ZodOptional<z.ZodString>;
+    dir: z.ZodOptional<z.ZodEnum<{
+      auto: "auto";
+      ltr: "ltr";
+      rtl: "rtl";
+    }>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Placement = z.infer<typeof PlacementShape>;
+export type PlacementInput = z.input<typeof PlacementShape>;
+declare function parsePlacement(input: PlacementInput, container: PlacementContainer, placed?: Media): Placement;
+export declare const Placement: {
+  parse: typeof parsePlacement;
+};
+//#endregion

package/dist/placement.js

@@ -0,0 +1,100 @@
+import { ImageFit } from "./image-fit.js";
+import { MEDIA_FORMATS, MediaText, PAGE_BOXES, PageBoxName, PageSelector } from "./media.js";
+import { PlacementRefusedError } from "./placement-refusal.js";
+import { z } from "zod";
+//#region src/placement.ts
+const PLACEMENT_ACCEPTS = {
+	board: [
+		"deck",
+		"page",
+		"paper",
+		"book",
+		"media",
+		"shot"
+	],
+	book: ["media", "page"],
+	page: ["media"],
+	deck: ["media"],
+	paper: ["media"]
+};
+const AssetKind = z.enum(PLACEMENT_ACCEPTS.board);
+const CropEdge = z.string().regex(/^(?:0|(?:\d+(?:\.\d+)?|\.\d+)(?:%|px|pt|mm|cm|in))$/, "crop edge must be 0 or a non-negative CSS length or percentage");
+function percentage(edge) {
+	return edge?.endsWith("%") ? Number(edge.slice(0, -1)) : void 0;
+}
+function addCropAxisIssue(crop, first, second, ctx) {
+	const one = percentage(crop[first]);
+	const two = percentage(crop[second]);
+	const overfull = one !== void 0 && one > 100 ? first : two !== void 0 && two > 100 ? second : void 0;
+	if (overfull !== void 0) {
+		ctx.addIssue({
+			code: "custom",
+			path: [overfull],
+			message: `${overfull} crop percentage must be at most 100%; lower it to clear this refusal`
+		});
+		return;
+	}
+	if ((one ?? 0) + (two ?? 0) < 100) return;
+	const percentageEdges = [one === void 0 ? void 0 : first, two === void 0 ? void 0 : second].filter((edge) => edge !== void 0);
+	const subject = percentageEdges.join(" and ");
+	ctx.addIssue({
+		code: "custom",
+		path: [first],
+		message: percentageEdges.length === 1 ? `${subject} crop percentage leaves no area; lower ${subject} below 100% to clear this refusal` : `${subject} crop percentages leave no area; lower either edge so their sum is below 100% to clear this refusal`
+	});
+}
+const PlacementCrop = z.object({
+	top: CropEdge.optional(),
+	right: CropEdge.optional(),
+	bottom: CropEdge.optional(),
+	left: CropEdge.optional()
+}).superRefine((crop, ctx) => {
+	for (const [first, second] of [["top", "bottom"], ["left", "right"]]) addCropAxisIssue(crop, first, second, ctx);
+});
+const PlacementShape = z.object({
+	kind: AssetKind,
+	address: z.string().min(1),
+	page: PageSelector.optional(),
+	box: PageBoxName.optional(),
+	crop: PlacementCrop.optional(),
+	fit: ImageFit.optional(),
+	alt: MediaText.optional()
+});
+const FIELD_REMEDIES = {
+	kind: `pass one of ${AssetKind.options.join(", ")}`,
+	address: "pass a non-empty address",
+	page: "pass a positive page number or a non-empty page name",
+	box: `pass one of ${PAGE_BOXES.join(", ")}`,
+	crop: "pass non-negative crop edges using supported CSS units",
+	fit: "pass contain, cover, width or focus",
+	alt: "pass non-empty alt text with an optional language and direction"
+};
+function shapeRefusal(error) {
+	const issue = error.issues[0];
+	const field = String(issue?.path[0] ?? "kind");
+	const detail = issue?.message ?? "the value is invalid";
+	if (issue?.code === "custom") return new PlacementRefusedError(`${field} could not be accepted: ${detail}`);
+	return new PlacementRefusedError(`${field} could not be accepted: ${detail}; ${FIELD_REMEDIES[field]} to clear this refusal`);
+}
+const PLACEMENT_SETTING_NEEDS = {
+	page: "pages",
+	box: "pages",
+	crop: "media"
+};
+function parsePlacement(input, container, placed) {
+	const parsed = PlacementShape.safeParse(input);
+	if (!parsed.success) throw shapeRefusal(parsed.error);
+	const placement = parsed.data;
+	const accepted = PLACEMENT_ACCEPTS[container];
+	if (accepted === void 0) throw new PlacementRefusedError(`container could not be accepted: ${container}; place into one of ${Object.keys(PLACEMENT_ACCEPTS).join(", ")} to clear this refusal`);
+	if (!accepted.includes(placement.kind)) throw new PlacementRefusedError(`kind could not be accepted: ${container} does not accept ${placement.kind}; place one of ${accepted.join(", ")} to clear this refusal`);
+	for (const field of Object.keys(PLACEMENT_SETTING_NEEDS)) {
+		const need = PLACEMENT_SETTING_NEEDS[field];
+		if (placement[field] !== void 0 && placement.kind !== "media") throw new PlacementRefusedError(`${field} could not be accepted on ${placement.kind}; remove ${field} or place media to clear this refusal`);
+		if (placement[field] !== void 0 && need === "pages" && placed && !MEDIA_FORMATS[placed.format].pages) throw new PlacementRefusedError(`${field} could not be accepted for ${placed.format} media; remove ${field} or place media with pages to clear this refusal`);
+	}
+	return placement;
+}
+const Placement = { parse: parsePlacement };
+//#endregion
+export { AssetKind, CropEdge, PLACEMENT_ACCEPTS, Placement, PlacementCrop, PlacementShape };

package/dist/print.d.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+//#region src/print.d.ts
+export declare const Margin: z.ZodObject<{
+  top: z.ZodDefault<z.ZodNumber>;
+  right: z.ZodDefault<z.ZodNumber>;
+  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";
+    legal: "legal";
+    tabloid: "tabloid";
+    a3: "a3";
+    a4: "a4";
+    a5: "a5";
+    "business-card-us": "business-card-us";
+    "business-card-eu": "business-card-eu";
+    "business-card-square-us": "business-card-square-us";
+    "business-card-slim-us": "business-card-slim-us";
+    "postcard-4x6": "postcard-4x6";
+    "postcard-5x7": "postcard-5x7";
+    "postcard-6x9": "postcard-6x9";
+    "postcard-6x11": "postcard-6x11";
+    "card-square-4in": "card-square-4in";
+    "half-letter": "half-letter";
+    a6: "a6";
+    dl: "dl";
+    "rack-card-4x9": "rack-card-4x9";
+    "rack-card-3.5x8.5": "rack-card-3.5x8.5";
+    "poster-12x18": "poster-12x18";
+    "poster-16x20": "poster-16x20";
+    "poster-18x24": "poster-18x24";
+    "poster-24x36": "poster-24x36";
+    a2: "a2";
+    a1: "a1";
+    a0: "a0";
+  }>, z.ZodObject<{
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    unit: z.ZodEnum<{
+      mm: "mm";
+      in: "in";
+      pt: "pt";
+    }>;
+  }, z.core.$strip>]>;
+  orientation: z.ZodDefault<z.ZodEnum<{
+    portrait: "portrait";
+    landscape: "landscape";
+  }>>;
+  margin: z.ZodOptional<z.ZodObject<{
+    top: z.ZodDefault<z.ZodNumber>;
+    right: z.ZodDefault<z.ZodNumber>;
+    bottom: z.ZodDefault<z.ZodNumber>;
+    left: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  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>;
+//#endregion

package/dist/print.js

@@ -0,0 +1,38 @@
+import { Orientation, Paper, sheetMm } from "./paper.js";
+import { z } from "zod";
+//#region src/print.ts
+const Margin = z.object({
+	top: z.number().nonnegative().default(0),
+	right: z.number().nonnegative().default(0),
+	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),
+	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",
+		path: ["safe"],
+		message: `safe is ${print.safe}mm on the left and right, but the trim is ${trim.width}mm wide; safe must leave area inside the trim`
+	});
+	if (print.safe * 2 >= trim.height) ctx.addIssue({
+		code: "custom",
+		path: ["safe"],
+		message: `safe is ${print.safe}mm on the top and bottom, but the trim is ${trim.height}mm high; safe must leave area inside the trim`
+	});
+});
+//#endregion
+export { Margin, MarkColor, Print };

package/dist/printed-page-imposition.d.ts

@@ -1,4 +1,5 @@
-import { Imposition, Print } from "./index.js";
+import { Print } from "./print.js";
+import { Imposition } from "./imposition-schema.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;

package/dist/printed-pages.d.ts

@@ -91,6 +91,12 @@ export declare const BOOK_PARENT_NAMES: {
   readonly opener: "segnavia:opener";
   readonly blank: "segnavia:blank";
 };
+export interface FlowingParentNames {
+  opener: string;
+  recto: string;
+  verso: string;
+}
+export declare function flowingParentNames(parents?: Partial<FlowingParentNames>): FlowingParentNames;
 export declare function bookParentPages(margin: ParentPageMargin): ParentPage[];
 export interface ResolvedParentPage {
   name: string;
@@ -98,6 +104,14 @@ export interface ResolvedParentPage {
   head: string;
   foot: string;
 }
+export interface TextArea {
+  width: number;
+  height: number;
+}
+export declare function textArea(parent: Pick<ResolvedParentPage, 'margin'>, paper: {
+  width: number;
+  height: number;
+}): TextArea;
 export declare function resolveParentPages(parents: ParentPage[]): ResolvedParentPage[];
 export declare function parentListIssues(parents: ParentPage[], options?: {
   path?: (string | number)[];

package/dist/printed-pages.js

@@ -54,6 +54,13 @@ const BOOK_PARENT_NAMES = {
 	opener: "segnavia:opener",
 	blank: "segnavia:blank"
 };
+function flowingParentNames(parents) {
+	return {
+		opener: parents?.opener ?? "segnavia:opener",
+		recto: parents?.recto ?? "segnavia:recto",
+		verso: parents?.verso ?? "segnavia:verso"
+	};
+}
 function furniture(region) {
 	return BOOK_FURNITURE.filter((item) => item.region === region).filter((item) => item.fields.every((field) => !("required" in field) || !field.required)).map((item) => `<div class="${item.className}" data-motif="${item.key}"></div>`).join("");
 }
@@ -85,6 +92,12 @@ function bookParentPages(margin) {
 		}
 	];
 }
+function textArea(parent, paper) {
+	return {
+		width: paper.width - parent.margin.inner - parent.margin.outer,
+		height: paper.height - parent.margin.top - parent.margin.bottom
+	};
+}
 const ZERO_PARENT_MARGIN = {
 	top: 0,
 	bottom: 0,
@@ -193,4 +206,4 @@ function pagePrintedPagesIssues(page) {
 	return issues;
 }
 //#endregion
-export { BOOK_PARENT_NAMES, PRINTED_PAGE_LIMIT, PRINTED_PAGE_ROLES, ParentPage, ParentPageMargin, PrintedPageRules, PrintedPages, bookParentPages, pagePrintedPagesIssues, parentListIssues, printedPagesIssues, resolveParentPages };
+export { BOOK_PARENT_NAMES, PRINTED_PAGE_LIMIT, PRINTED_PAGE_ROLES, ParentPage, ParentPageMargin, PrintedPageRules, PrintedPages, bookParentPages, flowingParentNames, pagePrintedPagesIssues, parentListIssues, printedPagesIssues, resolveParentPages, textArea };

package/dist/shots-used.d.ts

@@ -1,5 +1,4 @@
 import { Deck } from "./deck.js";
-import "./index.js";
 //#region src/shots-used.d.ts
 export interface ShotUse {
   slide: string;

package/dist/shots-used.js

@@ -1,11 +1,11 @@
 //#region src/shots-used.ts
 function shotsUsed(deck) {
 	return deck.slides.flatMap((slide) => {
-		if (slide.content.kind === "shot") return [{
+		if ("kind" in slide.content && slide.content.kind === "shot") return [{
 			slide: slide.id,
 			key: slide.content.shot.key
 		}];
-		if (slide.content.kind === "shot-ref") return [{
+		if ("kind" in slide.content && slide.content.kind === "shot-ref") return [{
 			slide: slide.id,
 			href: slide.content.href
 		}];