@embedpdf/engine-core 3.0.0-next.14 → 3.0.0-next.16

package/dist/schema-6S2VmlAj.js

@@ -0,0 +1,2087 @@
+import { c as STANDARD_FONTS, n as validNumberFormat } from "./format-Dgg428Kb.js";
+import { i as PdfAnnotationSubtypeCode } from "./subtype-CG4WpIRj.js";
+import { z } from "zod";
+//#region src/identity/PageRef.schema.ts
+/** Wire form of `PageRef` — see the type. */
+const PageRefSchema = z.object({
+	kind: z.literal("objectNumber"),
+	objectNumber: z.number().int().positive()
+});
+//#endregion
+//#region src/geometry/schemas.ts
+/**
+* Zod schemas for engine PDF-document geometry. Exported from `wire.ts` only
+* (never from `shared.ts`/`runtime`) so the zod-free runtime stays zod-free.
+*/
+const PdfPointSchema = z.object({
+	x: z.number(),
+	y: z.number()
+});
+const LinePointsSchema = z.object({
+	start: PdfPointSchema,
+	end: PdfPointSchema
+});
+/** `/CL` callout leader line — two points (straight) or three (knee-jointed). */
+const CalloutLineSchema = z.union([z.tuple([PdfPointSchema, PdfPointSchema]), z.tuple([
+	PdfPointSchema,
+	PdfPointSchema,
+	PdfPointSchema
+])]);
+/** `/InkList` — an array of strokes, each an array of points. */
+const InkListSchema = z.array(z.array(PdfPointSchema));
+/** A rect's edges are finite, as `isFinitePdfRect` checks them on the page. */
+const PdfRectSchema = z.object({
+	left: z.number().finite(),
+	bottom: z.number().finite(),
+	right: z.number().finite(),
+	top: z.number().finite()
+});
+const PdfSizeSchema = z.object({
+	width: z.number().nonnegative(),
+	height: z.number().nonnegative()
+});
+const PdfQuadSchema = z.object({
+	upperLeft: PdfPointSchema,
+	upperRight: PdfPointSchema,
+	lowerLeft: PdfPointSchema,
+	lowerRight: PdfPointSchema
+});
+const PdfRotationSchema = z.union([
+	z.literal(0),
+	z.literal(90),
+	z.literal(180),
+	z.literal(270)
+]);
+const PagePointSchema = z.object({
+	x: z.number(),
+	y: z.number()
+});
+/** A box is finite, as a rect is (`PdfRectSchema`). */
+const PageBoxSchema = z.object({
+	x: z.number().finite(),
+	y: z.number().finite(),
+	width: z.number().finite().nonnegative(),
+	height: z.number().finite().nonnegative()
+});
+const PageQuadSchema = z.object({
+	upperLeft: PagePointSchema,
+	upperRight: PagePointSchema,
+	lowerLeft: PagePointSchema,
+	lowerRight: PagePointSchema
+});
+//#endregion
+//#region src/annotation/base.schema.ts
+/** @deprecated Use `PdfPointSchema` from `../geometry/schemas`. */
+const PointSchema = PdfPointSchema;
+/** @deprecated Use `PdfRectSchema` from `../geometry/schemas`. */
+const RectSchema = PdfRectSchema;
+const ColorSchema = z.string().regex(/^#[0-9a-fA-F]{6}$/, "expected a color as '#rrggbb'");
+const AnnotationBorderStyleSchema = z.enum([
+	"solid",
+	"dashed",
+	"beveled",
+	"inset"
+]);
+const WidgetBorderStyleSchema = z.enum([
+	"solid",
+	"dashed",
+	"beveled",
+	"inset",
+	"underline"
+]);
+const WidgetCheckStyleSchema = z.enum([
+	"check",
+	"cross",
+	"star",
+	"circle",
+	"square",
+	"diamond"
+]);
+/** What a write takes for a border that isn't a widget's. */
+const DrawnBorderStyleSchema = z.enum(["solid", "dashed"]);
+const LineEndingSchema = z.enum([
+	"none",
+	"square",
+	"circle",
+	"diamond",
+	"open-arrow",
+	"closed-arrow",
+	"butt",
+	"r-open-arrow",
+	"r-closed-arrow",
+	"slash"
+]);
+const LineEndingsSchema = z.object({
+	start: LineEndingSchema,
+	end: LineEndingSchema
+});
+const StandardFontSchema = z.enum(STANDARD_FONTS);
+const TextAlignmentSchema = z.enum([
+	"left",
+	"center",
+	"right"
+]);
+const FreeTextIntentSchema = z.enum([
+	"free-text",
+	"free-text-callout",
+	"free-text-typewriter"
+]);
+/** The intents a write makes: a typewriter is only sent back as read. */
+const FreeTextIntentWriteSchema = z.enum(["free-text", "free-text-callout"]);
+const VerticalAlignmentSchema = z.enum([
+	"top",
+	"middle",
+	"bottom"
+]);
+const CaretIntentSchema = z.literal("replace");
+const StrikeoutIntentSchema = z.literal("strikeout-text-edit");
+const InkIntentSchema = z.literal("ink-highlight");
+const BlendModeSchema = z.enum([
+	"normal",
+	"multiply",
+	"screen",
+	"overlay",
+	"darken",
+	"lighten",
+	"color-dodge",
+	"color-burn",
+	"hard-light",
+	"soft-light",
+	"difference",
+	"exclusion",
+	"hue",
+	"saturation",
+	"color",
+	"luminosity"
+]);
+const AnnotationRefSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("objectNumber"),
+	page: PageRefSchema,
+	objectNumber: z.number().int().positive()
+}), z.object({
+	kind: z.literal("baseIndex"),
+	page: PageRefSchema,
+	baseIndex: z.number().int().nonnegative()
+})]);
+//#endregion
+//#region src/dto/PdfDestination.schema.ts
+const page = PageRefSchema;
+/** Spec-nullable axis value: absent and `null` both mean "retain current". */
+const axis = z.number().nullable().optional();
+/**
+* Runtime schema for {@link PdfDestination}. Lives beside its DTO in `dto/`
+* so every destination-shaped surface (link targets, action-node payloads,
+* the document `openDestination`) shares one schema without an import cycle
+* through the annotation tree.
+*/
+const PdfDestinationSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("xyz"),
+		page,
+		left: axis,
+		top: axis,
+		zoom: axis
+	}),
+	z.object({
+		kind: z.literal("fit"),
+		page
+	}),
+	z.object({
+		kind: z.literal("fitH"),
+		page,
+		top: axis
+	}),
+	z.object({
+		kind: z.literal("fitV"),
+		page,
+		left: axis
+	}),
+	z.object({
+		kind: z.literal("fitR"),
+		page,
+		left: z.number(),
+		bottom: z.number(),
+		right: z.number(),
+		top: z.number()
+	}),
+	z.object({
+		kind: z.literal("fitB"),
+		page
+	}),
+	z.object({
+		kind: z.literal("fitBH"),
+		page,
+		top: axis
+	}),
+	z.object({
+		kind: z.literal("fitBV"),
+		page,
+		left: axis
+	})
+]);
+/** A destination in page space: measured from the top-left of its page's visible box. */
+const PageDestinationSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("xyz"),
+		page,
+		x: axis,
+		y: axis,
+		zoom: axis
+	}),
+	z.object({
+		kind: z.literal("fit"),
+		page
+	}),
+	z.object({
+		kind: z.literal("fitH"),
+		page,
+		y: axis
+	}),
+	z.object({
+		kind: z.literal("fitV"),
+		page,
+		x: axis
+	}),
+	z.object({
+		kind: z.literal("fitR"),
+		page,
+		x: z.number(),
+		y: z.number(),
+		width: z.number().nonnegative(),
+		height: z.number().nonnegative()
+	}),
+	z.object({
+		kind: z.literal("fitB"),
+		page
+	}),
+	z.object({
+		kind: z.literal("fitBH"),
+		page,
+		y: axis
+	}),
+	z.object({
+		kind: z.literal("fitBV"),
+		page,
+		x: axis
+	})
+]);
+//#endregion
+//#region src/annotation/kinds/link/values.ts
+/** A link target's two schemas, a read and a write, for destinations of one kind. */
+function linkTargetSchemasFor(destination) {
+	const goto = z.object({
+		kind: z.literal("goto"),
+		destination
+	});
+	const uri = z.object({
+		kind: z.literal("uri"),
+		uri: z.string()
+	});
+	const read = z.discriminatedUnion("kind", [
+		goto,
+		uri,
+		z.object({
+			kind: z.literal("goto-remote"),
+			file: z.string()
+		}),
+		z.object({
+			kind: z.literal("launch"),
+			path: z.string()
+		}),
+		z.object({ kind: z.literal("javascript") }),
+		z.object({
+			kind: z.literal("named"),
+			name: z.string()
+		}),
+		z.object({ kind: z.literal("unsupported") })
+	]);
+	/** Drafts and patches author `goto`, `uri` and the standard named verbs; see {@link PdfLinkTargetWritable}. */
+	const named = z.object({
+		kind: z.literal("named"),
+		name: z.enum([
+			"NextPage",
+			"PrevPage",
+			"FirstPage",
+			"LastPage"
+		])
+	});
+	return {
+		read,
+		write: z.discriminatedUnion("kind", [
+			goto,
+			uri,
+			named
+		])
+	};
+}
+const PAGE_SPACE$1 = linkTargetSchemasFor(PageDestinationSchema);
+const FILE_SPACE = linkTargetSchemasFor(PdfDestinationSchema);
+/** A link's target: a destination in page space. */
+const PdfLinkTargetSchema = PAGE_SPACE$1.read;
+/** What a create or an update may set as a link's target. */
+const PdfLinkTargetWritableSchema = PAGE_SPACE$1.write;
+/** A link's target as the engine reads the file: a destination in the file's coordinates. */
+const FileLinkTargetSchema = FILE_SPACE.read;
+const FileLinkTargetWritableSchema = FILE_SPACE.write;
+//#endregion
+//#region src/dto/PdfAction.schema.ts
+const PdfActionTargetRefSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("name"),
+	name: z.string()
+}), z.object({
+	kind: z.literal("objectNumber"),
+	objectNumber: z.number().int().positive()
+})]);
+const SubmitFormFlagsSchema = z.object({
+	raw: z.number().int().nonnegative(),
+	exclude: z.boolean(),
+	includeNoValueFields: z.boolean(),
+	format: z.enum([
+		"fdf",
+		"html",
+		"xfdf",
+		"pdf"
+	]),
+	method: z.enum(["post", "get"]),
+	submitCoordinates: z.boolean(),
+	includeAppendSaves: z.boolean(),
+	includeAnnotations: z.boolean(),
+	canonicalFormat: z.boolean(),
+	exclNonUserAnnots: z.boolean(),
+	exclFKey: z.boolean(),
+	embedForm: z.boolean()
+});
+/**
+* The action schemas for one kind of destination: in the file's coordinates
+* or in page space. Everything but a `goto`'s destination is the same.
+*/
+function actionSchemasFor(destination) {
+	/** Fields every node arm repeats — zod 3's discriminatedUnion needs plain
+	*  object options, so the recursion (`next`) lives inline per arm and the
+	*  whole union sits behind one `z.lazy`. */
+	const nodeCommon = {
+		subtype: z.string(),
+		next: z.array(z.lazy(() => node))
+	};
+	const arm = (type, shape = {}) => z.object({
+		type: z.literal(type),
+		...nodeCommon,
+		...shape
+	});
+	const arms = [
+		arm("javascript", { script: z.string() }),
+		arm("goto", { destination }),
+		arm("uri", {
+			uri: z.string(),
+			isMap: z.boolean()
+		}),
+		arm("named", { name: z.string() }),
+		arm("hide", {
+			targets: z.array(PdfActionTargetRefSchema),
+			hide: z.boolean()
+		}),
+		arm("reset-form", {
+			fields: z.array(PdfActionTargetRefSchema).nullable(),
+			exclude: z.boolean()
+		}),
+		arm("goto-remote", { filePath: z.string() }),
+		arm("goto-embedded", { filePath: z.string() }),
+		arm("launch", { filePath: z.string() }),
+		arm("rendition", { script: z.string().optional() }),
+		arm("submit-form", { payload: z.object({
+			url: z.string(),
+			fields: z.array(PdfActionTargetRefSchema).nullable(),
+			flags: SubmitFormFlagsSchema,
+			charSet: z.string().optional()
+		}).optional() }),
+		arm("thread"),
+		arm("sound"),
+		arm("movie"),
+		arm("import-data"),
+		arm("set-ocg-state"),
+		arm("transition"),
+		arm("goto-3d-view"),
+		arm("unknown")
+	];
+	const node = z.lazy(() => z.discriminatedUnion("type", [...arms]));
+	const tree = z.object({
+		root: node.nullable(),
+		incomplete: z.boolean(),
+		warningFlags: z.number().int().nonnegative(),
+		warnings: z.array(z.enum([
+			"cycle-dropped",
+			"malformed-next",
+			"incomplete",
+			"payload-dropped"
+		]))
+	});
+	return {
+		arms,
+		node,
+		tree,
+		fieldActions: z.object({
+			keystroke: tree.optional(),
+			format: tree.optional(),
+			validate: tree.optional(),
+			calculate: tree.optional()
+		}),
+		pageActions: z.object({
+			open: tree.optional(),
+			close: tree.optional()
+		}),
+		annotationActions: z.object({
+			activate: tree.optional(),
+			cursorEnter: tree.optional(),
+			cursorExit: tree.optional(),
+			mouseDown: tree.optional(),
+			mouseUp: tree.optional(),
+			focus: tree.optional(),
+			blur: tree.optional(),
+			pageOpen: tree.optional(),
+			pageClose: tree.optional(),
+			pageVisible: tree.optional(),
+			pageInvisible: tree.optional()
+		}),
+		documentActions: z.object({
+			nameTreeScripts: z.array(z.object({
+				name: z.string(),
+				action: tree
+			})),
+			openAction: tree.nullable(),
+			openDestination: destination.nullable().default(null),
+			willClose: tree.optional(),
+			willSave: tree.optional(),
+			didSave: tree.optional(),
+			willPrint: tree.optional(),
+			didPrint: tree.optional()
+		}).superRefine((snapshot, context) => {
+			if (snapshot.openAction !== null && (snapshot.openDestination ?? null) !== null) context.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "openAction and openDestination are mutually exclusive",
+				path: ["openDestination"]
+			});
+		})
+	};
+}
+const PAGE_SPACE = actionSchemasFor(PageDestinationSchema);
+const PDF_SPACE = actionSchemasFor(PdfDestinationSchema);
+/**
+* The write schemas for one kind of destination: an action a write makes,
+* and a widget's actions patch.
+*/
+function actionWriteSchemasFor(destination) {
+	const next = () => ({ next: z.array(z.lazy(() => node)).optional() });
+	const arms = [
+		z.object({
+			type: z.literal("javascript"),
+			script: z.string(),
+			...next()
+		}),
+		z.object({
+			type: z.literal("goto"),
+			destination,
+			...next()
+		}),
+		z.object({
+			type: z.literal("uri"),
+			uri: z.string().min(1),
+			...next()
+		}),
+		z.object({
+			type: z.literal("named"),
+			name: z.string().min(1),
+			...next()
+		}),
+		z.object({
+			type: z.literal("hide"),
+			targets: z.array(PdfActionTargetRefSchema).min(1),
+			hide: z.boolean(),
+			...next()
+		}),
+		z.object({
+			type: z.literal("reset-form"),
+			fields: z.array(PdfActionTargetRefSchema).nullable(),
+			exclude: z.boolean(),
+			...next()
+		}),
+		z.object({
+			type: z.literal("submit-form"),
+			url: z.string().min(1),
+			fields: z.array(PdfActionTargetRefSchema).nullable(),
+			flags: z.number().int().nonnegative().optional(),
+			...next()
+		})
+	];
+	const node = z.lazy(() => z.discriminatedUnion("type", [...arms]));
+	const event = () => node.nullable().optional();
+	return {
+		node,
+		widgetActions: z.object({
+			activate: event(),
+			cursorEnter: event(),
+			cursorExit: event(),
+			mouseDown: event(),
+			mouseUp: event(),
+			focus: event(),
+			blur: event(),
+			pageOpen: event(),
+			pageClose: event(),
+			pageVisible: event(),
+			pageInvisible: event()
+		}).strict()
+	};
+}
+const PAGE_SPACE_WRITES = actionWriteSchemasFor(PageDestinationSchema);
+const PDF_SPACE_WRITES = actionWriteSchemasFor(PdfDestinationSchema);
+/** An action a write makes, its destinations in page space. */
+const PdfActionWriteSchema = PAGE_SPACE_WRITES.node;
+/** A widget's actions to write, by event, their destinations in page space. */
+const WidgetActionsPatchSchema = PAGE_SPACE_WRITES.widgetActions;
+/** A widget's actions to write, as the engine writes the file: destinations in its coordinates. */
+const FileWidgetActionsPatchSchema = PDF_SPACE_WRITES.widgetActions;
+const PdfActionNodeSchema = PAGE_SPACE.node;
+/** The `/S` vocabulary, derived from the union arms so it cannot drift. */
+const PdfActionTypeSchema = z.enum(PAGE_SPACE.arms.map((option) => option.shape.type.value));
+const PdfActionTreeSchema = PAGE_SPACE.tree;
+const PdfFieldActionsSchema = PAGE_SPACE.fieldActions;
+const PdfPageActionsSchema = PAGE_SPACE.pageActions;
+const DocumentActionsSnapshotSchema = PAGE_SPACE.documentActions;
+/** An annotation's actions (`/A`, `/AA`), their destinations in page space. */
+const PdfAnnotationActionsSchema = PAGE_SPACE.annotationActions;
+/** An annotation's actions as the engine reads the file: destinations in the file's coordinates. */
+const FileAnnotationActionsSchema = PDF_SPACE.annotationActions;
+/**
+* A field event's script: JavaScript all through. Any other action type is
+* refused here, at the boundary.
+*/
+const FieldScriptWriteSchema = z.lazy(() => z.object({
+	type: z.literal("javascript"),
+	script: z.string(),
+	next: z.array(FieldScriptWriteSchema).optional()
+}));
+/** A field's scripts to write, by event: a script sets one, `null` removes it. */
+const FieldActionsPatchSchema = z.object({
+	keystroke: FieldScriptWriteSchema.nullable().optional(),
+	format: FieldScriptWriteSchema.nullable().optional(),
+	validate: FieldScriptWriteSchema.nullable().optional(),
+	calculate: FieldScriptWriteSchema.nullable().optional()
+});
+/**
+* Stable public component names for generators that project the action wire
+* model into OpenAPI or another schema format. Keep reusable boundaries here;
+* individual action arms remain owned by `PdfActionNodeSchema`.
+*/
+const PdfActionWireComponents = {
+	PdfActionTargetRef: PdfActionTargetRefSchema,
+	PageDestination: PageDestinationSchema,
+	PdfActionNode: PdfActionNodeSchema,
+	PdfActionTree: PdfActionTreeSchema,
+	PdfFieldActions: PdfFieldActionsSchema,
+	PdfPageActions: PdfPageActionsSchema,
+	PdfAnnotationActions: PdfAnnotationActionsSchema,
+	DocumentActionsSnapshot: DocumentActionsSnapshotSchema,
+	FieldScriptWrite: FieldScriptWriteSchema,
+	FieldActionsPatch: FieldActionsPatchSchema,
+	PdfActionWrite: PdfActionWriteSchema,
+	WidgetActionsPatch: WidgetActionsPatchSchema
+};
+//#endregion
+//#region src/annotation/declaration.ts
+function createField(read, write, traits) {
+	const next = (changed) => createField(read, write, {
+		...traits,
+		...changed
+	});
+	return {
+		read,
+		write,
+		traits,
+		nullable: () => next({
+			readNullable: true,
+			writeNullable: true
+		}),
+		nullableOnRead: () => next({ readNullable: true }),
+		optional: () => next({ required: false }),
+		createOnly: () => next({ createOnly: true }),
+		readBack: () => next({ readBack: true }),
+		space: (space) => next({ space }),
+		writes: (schema) => createField(read, schema, traits)
+	};
+}
+const ownedBy = (owner, required) => ({
+	owner,
+	readNullable: false,
+	writeNullable: false,
+	required,
+	createOnly: false,
+	readBack: false,
+	space: "none"
+});
+/** Field builders for {@link defineKind}. */
+const field = {
+	/** Written by the caller. Required on create until marked `optional()`. */
+	data: (schema) => createField(schema, schema, ownedBy("data", true)),
+	/** Stamped by the engine from the session's identity. */
+	attribution: (schema) => createField(schema, schema, ownedBy("attribution", false)),
+	/** Written only by the engine. */
+	engine: (schema) => createField(schema, schema, ownedBy("engine", false)),
+	/** Read from the PDF and kept in place, but not writable. */
+	preserved: (schema) => createField(schema, schema, ownedBy("preserved", false))
+};
+/**
+* The page-space schema of a field that holds a box or destinations, whose
+* shape differs from the file's: a box is `{ x, y, width, height }`, and a
+* destination is measured from its page's top-left. Every other place has
+* the same shape in both spaces.
+*/
+const PAGE_SPACE_SCHEMAS = {
+	box: {
+		read: PageBoxSchema,
+		write: PageBoxSchema
+	},
+	linkTarget: {
+		read: PdfLinkTargetSchema,
+		write: PdfLinkTargetWritableSchema
+	},
+	actions: {
+		read: PdfAnnotationActionsSchema,
+		write: WidgetActionsPatchSchema
+	}
+};
+/** The zod shapes of a kind's fields, each field's schemas given by `schemasOf`. */
+function shapesOf(subtype, fields, schemasOf) {
+	const read = { subtype: z.literal(subtype) };
+	const create = { subtype: z.literal(subtype) };
+	const update = { subtype: z.literal(subtype).optional() };
+	const readBackWrites = {};
+	for (const [name, spec] of Object.entries(fields)) {
+		const { owner, readNullable, writeNullable, required, readBack } = spec.traits;
+		const schemas = schemasOf(spec);
+		read[name] = readNullable ? schemas.read.nullable() : schemas.read;
+		if (owner === "data") {
+			const write = writeNullable ? schemas.write.nullable() : schemas.write;
+			create[name] = required ? write : write.optional();
+			const readBackUpdate = schemas.read === schemas.write ? readNullable || writeNullable ? schemas.write.nullable() : schemas.write : z.union([write, read[name]]);
+			update[name] = (readBack ? readBackUpdate : write).optional();
+			if (readBack) readBackWrites[name] = write;
+		} else {
+			create[name] = readBack ? read[name].optional() : z.unknown().optional();
+			update[name] = readBack ? read[name].optional() : z.unknown().optional();
+			if (readBack) readBackWrites[name] = null;
+		}
+	}
+	return {
+		read,
+		create,
+		update,
+		readBackWrites
+	};
+}
+/**
+* Declares an annotation kind from its fields and the resources it takes
+* beside its data. Fields are declared as the file holds them; the page-space
+* schemas follow from what each field holds (`space`).
+*/
+function defineKind(subtype, fields, resources = {}) {
+	const file = shapesOf(subtype, fields, (spec) => spec);
+	const page = shapesOf(subtype, fields, (spec) => PAGE_SPACE_SCHEMAS[spec.traits.space] ?? spec);
+	return {
+		subtype,
+		fields,
+		resources,
+		readSchema: z.object(page.read),
+		createSchema: z.object(page.create).strict(),
+		updateSchema: z.object(page.update).strict(),
+		fileSchemas: {
+			read: z.object(file.read),
+			create: z.object(file.create).strict(),
+			update: z.object(file.update).strict()
+		},
+		readBackWrites: file.readBackWrites,
+		shapes: {
+			read: page.read,
+			create: page.create,
+			update: page.update
+		}
+	};
+}
+//#endregion
+//#region src/dto/IsoDateTime.schema.ts
+/** ISO 8601 with an offset (`Z` or `±HH:mm`) or without one. */
+const IsoDateTimeSchema = z.string().datetime({
+	offset: true,
+	local: true
+});
+/**
+* A moment in a write. JSON carries the string; a `Date` only ever arrives
+* in-process (the local engine), and becomes that string on the wire.
+*/
+const DateInputSchema = z.union([IsoDateTimeSchema, z.date()]);
+//#endregion
+//#region src/dto/Measure.schema.ts
+const float = z.number().finite().refine((n) => Number.isFinite(Math.fround(n)), "Outside PDF float range");
+const point = z.object({
+	x: float,
+	y: float
+}).strict();
+const positive = float.refine((n) => Math.fround(n) > 0, "Must be positive in PDF float precision");
+const PdfNumberFormatSchema = z.object({
+	unit: z.string(),
+	conversion: float.optional(),
+	fraction: z.enum([
+		"decimal",
+		"fraction",
+		"round",
+		"truncate"
+	]).optional(),
+	precision: z.number().int().optional(),
+	fixed: z.boolean().optional(),
+	thousands: z.string().optional(),
+	decimal: z.string().optional(),
+	prefixSpacing: z.string().optional(),
+	suffixSpacing: z.string().optional(),
+	labelPosition: z.enum(["suffix", "prefix"]).optional()
+});
+const PdfMeasureSchema = z.object({
+	subtype: z.literal("rectilinear"),
+	ratio: z.string().optional(),
+	x: z.array(PdfNumberFormatSchema),
+	y: z.array(PdfNumberFormatSchema).optional(),
+	distance: z.array(PdfNumberFormatSchema),
+	area: z.array(PdfNumberFormatSchema),
+	angle: z.array(PdfNumberFormatSchema).optional(),
+	slope: z.array(PdfNumberFormatSchema).optional(),
+	origin: point.optional(),
+	cyx: float.optional()
+});
+const writableFormat = PdfNumberFormatSchema.extend({
+	conversion: positive,
+	precision: z.number().int().min(1).max(2147483647).optional()
+}).refine(validNumberFormat, "Invalid number format precision");
+const PdfMeasureWriteSchema = PdfMeasureSchema.extend({
+	x: z.array(writableFormat),
+	y: z.array(writableFormat).optional(),
+	distance: z.array(writableFormat),
+	area: z.array(writableFormat),
+	angle: z.array(writableFormat).optional(),
+	slope: z.array(writableFormat).optional(),
+	cyx: positive.optional()
+});
+const geoMeasure = z.object({ subtype: z.literal("geospatial") });
+const unknownMeasure = z.object({ subtype: z.literal("unknown") });
+const PdfForeignMeasureSchema = z.union([geoMeasure, unknownMeasure]);
+const PageScaleInputSchema = z.object({ measure: PdfMeasureWriteSchema.nullable() });
+const PdfMeasurementSchema = z.discriminatedUnion("subtype", [
+	PdfMeasureSchema,
+	geoMeasure,
+	unknownMeasure
+]);
+const PageMeasurementViewportSchema = z.object({
+	bbox: PageBoxSchema,
+	name: z.string().nullable(),
+	measure: PdfMeasurementSchema.nullable(),
+	owned: z.boolean()
+});
+/** See `PageMeasurementViewportList`. */
+const PageMeasurementViewportListSchema = z.object({ viewports: z.array(PageMeasurementViewportSchema) });
+const LineIntentSchema = z.enum(["line-arrow", "line-dimension"]);
+const PolygonIntentSchema = z.enum(["polygon-cloud", "polygon-dimension"]);
+const PolylineIntentSchema = z.literal("polyline-dimension");
+const offset = z.object({
+	along: float,
+	perpendicular: float
+}).strict();
+const LineDimensionCaptionSchema = z.object({
+	enabled: z.boolean(),
+	position: z.enum(["inline", "top"]).optional(),
+	offset: offset.optional()
+}).strict();
+const ShapeDimensionCaptionSchema = z.object({
+	enabled: z.boolean(),
+	center: point.optional()
+}).strict();
+const LineCaptionPatchSchema = z.object({
+	enabled: z.boolean().optional(),
+	position: z.enum(["inline", "top"]).nullable().optional(),
+	offset: offset.nullable().optional()
+}).strict();
+const ShapeCaptionPatchSchema = z.object({
+	enabled: z.boolean().optional(),
+	center: point.nullable().optional()
+}).strict();
+const LineLeaderSchema = z.object({
+	length: float,
+	extension: float.refine((n) => n >= 0).optional(),
+	offset: float.refine((n) => n >= 0).optional()
+}).strict();
+//#endregion
+//#region src/annotation/kinds/shared-fields.ts
+/** `/IRT` and `/RT`: the annotation this one replies to, and how it relates to it. */
+const AnnotationReplySchema = z.object({
+	to: AnnotationRefSchema,
+	type: z.enum(["reply", "group"])
+});
+/** A write may leave out `type`: an absent `/RT` means `'reply'` (ISO 32000-2 §12.5.6.2). */
+const AnnotationReplyWriteSchema = z.object({
+	to: AnnotationRefSchema,
+	type: z.enum(["reply", "group"]).optional()
+});
+/** A standard font name or a registered font key; the writer resolves which. */
+const FontNameSchema = z.string().min(1);
+/** One `/F` bit (ISO 32000-2 §12.5.3); every bit defaults to off. */
+const flag = () => field.data(z.boolean()).optional();
+/** Fields every annotation kind has. */
+const annotationBaseFields = {
+	ref: field.engine(AnnotationRefSchema),
+	page: field.engine(PageRefSchema),
+	/**
+	* Whether the file holds its appearance (`/AP /N`). Without one, every
+	* viewer draws the annotation from its fields: the engine in memory, never
+	* written.
+	*/
+	hasAppearance: field.engine(z.boolean()),
+	/**
+	* `/AS`: which state of its appearance the annotation shows, when the
+	* appearance has states (a check box's `Off` and its on state); `null`
+	* when it names none. The appearance images are labelled with the same
+	* names, so this picks the one to show.
+	*/
+	appearanceState: field.engine(z.string()).nullable(),
+	nm: field.data(z.string()).nullable().optional().createOnly(),
+	rect: field.data(PdfRectSchema).space("box"),
+	contents: field.data(z.string()).nullable().optional(),
+	subject: field.data(z.string()).nullable().optional(),
+	blendMode: field.data(BlendModeSchema).optional(),
+	invisible: flag(),
+	hidden: flag(),
+	print: flag(),
+	noZoom: flag(),
+	noRotate: flag(),
+	noView: flag(),
+	readOnly: flag(),
+	locked: flag(),
+	toggleNoView: flag(),
+	lockedContents: flag(),
+	reply: field.data(AnnotationReplySchema).writes(AnnotationReplyWriteSchema).nullable().optional(),
+	/** `/Popup`, kept in sync by the engine from the popup's `parent`. */
+	popup: field.engine(AnnotationRefSchema).nullable(),
+	/** `/EMBD_Metadata/GroupID`: the group that owns the annotation. */
+	groupId: field.data(z.string().min(1)).nullable().optional(),
+	author: field.attribution(z.string()).nullable(),
+	/** `/CreationDate`. */
+	createdAt: field.attribution(IsoDateTimeSchema).writes(DateInputSchema).nullable(),
+	/** `/M`. */
+	modifiedAt: field.attribution(IsoDateTimeSchema).writes(DateInputSchema).nullable(),
+	userId: field.attribution(z.string()).nullable(),
+	createdBy: field.attribution(z.string()).nullable(),
+	/** `/EMBD_Metadata/UpdatedBy`. */
+	modifiedBy: field.attribution(z.string()).nullable(),
+	/** The session that restored this annotation's attribution in an import. */
+	importedBy: field.engine(z.string()).nullable(),
+	/** `/A` and `/AA`. */
+	actions: field.preserved(FileAnnotationActionsSchema).nullable().space("actions")
+};
+const colorStyleFields = {
+	color: field.data(ColorSchema).optional(),
+	opacity: field.data(z.number().min(0).max(1)).optional()
+};
+const geometryStyleFields = {
+	...colorStyleFields,
+	strokeWidth: field.data(z.number().nonnegative()).optional(),
+	/** `beveled` and `inset` are read from other apps' files and kept; only widgets draw them. */
+	borderStyle: field.data(AnnotationBorderStyleSchema).writes(DrawnBorderStyleSchema).readBack().optional(),
+	dashArray: field.data(z.array(z.number().nonnegative())).nullable().optional()
+};
+const filledStyleFields = {
+	...geometryStyleFields,
+	interiorColor: field.data(ColorSchema).nullable().optional()
+};
+/**
+* `rect` where another field gives the shape (a box, points, quads): where
+* the annotation sits on the page, the upright box around all it draws. The
+* engine works it out from the shape, so a create's `rect` is worked out
+* again. An update's `rect` other than the one read puts the shape there
+* (`shapeForRect`); the rect read, sent back, changes nothing.
+*/
+const drawnRectFields = { rect: field.engine(PdfRectSchema).readBack().space("box") };
+/**
+* The turn of a kind drawn from points (line, polyline, polygon, ink): the
+* points are upright, and the turn takes them about the middle of their box,
+* as a square turns about its box.
+*/
+const pointsTurnFields = { 
+/** Degrees clockwise, about the middle of the points' box. */
+rotation: field.data(z.number()).nullable().optional() };
+/**
+* A kind drawn about a box that can turn: square, circle, free text, stamp
+* and caret. The caller gives the box and the turn; `rect` takes in the
+* turned box and what the drawing adds around it (a cloudy border's bumps, a
+* callout's line and arrow).
+*
+* A create gives `box`, or `rect` with a quarter turn: where the turned box
+* stands on the page, which pins the box down (`pdfQuarterTurnBox`). At any
+* other angle many boxes share one rect, so a create by `rect` is refused.
+*/
+const boxFields = {
+	...drawnRectFields,
+	/** The shape's own box, before any turn: a callout's text box. */
+	box: field.data(PdfRectSchema).space("box").optional(),
+	/** Degrees clockwise, about the middle of `box`. */
+	rotation: field.data(z.number()).nullable().optional()
+};
+/**
+* A widget's frame and its turn: the box its contents are laid out in, and
+* a quarter turn (`/MK /R`, which the file holds counterclockwise), so every
+* viewer can lay an upright editor over it. `rect` is where the widget
+* stands on the page, the box turned. A create gives `box` or `rect`, as a
+* box kind's does.
+*/
+const widgetBoxFields = {
+	...drawnRectFields,
+	/** The box the contents are laid out in, before the turn: `rect` with its sides swapped under 90 and 270. */
+	box: field.data(PdfRectSchema).space("box").optional(),
+	/** Degrees clockwise, a quarter turn, about the middle of `box`; `null` upright. */
+	rotation: field.data(PdfRotationSchema).nullable().optional()
+};
+const textMarkupFields = {
+	...annotationBaseFields,
+	...colorStyleFields,
+	/** The box around the quads. */
+	...drawnRectFields,
+	quadPoints: field.data(z.array(PdfQuadSchema).min(1)).space("quads")
+};
+const shapeFields = {
+	...annotationBaseFields,
+	...filledStyleFields,
+	...boxFields,
+	cloudyIntensity: field.data(z.number().positive()).nullable().optional()
+};
+const vertexFields = {
+	...annotationBaseFields,
+	...filledStyleFields,
+	...drawnRectFields,
+	vertices: field.data(z.array(PdfPointSchema)).space("points"),
+	...pointsTurnFields
+};
+/**
+* `/Measure`. A write takes a rectilinear scale, or sends back the marker a read
+* returned for a scale the engine can't model.
+*/
+const measureField = field.data(PdfMeasurementSchema).writes(z.union([PdfMeasureWriteSchema, PdfForeignMeasureSchema])).nullable().optional().space("measure");
+/** Our caption on a polygon or polyline measurement; `null` when the shape has no caption flag. */
+const shapeCaptionFields = {
+	captionEnabled: field.data(z.boolean()).nullable().optional(),
+	/** `null` places the caption automatically. */
+	captionCenter: field.data(PdfPointSchema).nullable().optional().space("point")
+};
+//#endregion
+//#region src/annotation/kinds/caret/declaration.ts
+const CaretDeclaration = defineKind("caret", {
+	...annotationBaseFields,
+	...colorStyleFields,
+	...boxFields,
+	intent: field.data(CaretIntentSchema).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/caret/index.ts
+const CaretDTOSchema = CaretDeclaration.readSchema;
+const CaretDraftSchema = CaretDeclaration.createSchema;
+const CaretPatchSchema = CaretDeclaration.updateSchema;
+const CaretKind = {
+	subtype: "caret",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.CARET,
+	dtoSchema: CaretDTOSchema,
+	draftSchema: CaretDraftSchema,
+	patchSchema: CaretPatchSchema,
+	readBackWrites: CaretDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/circle/declaration.ts
+const CircleDeclaration = defineKind("circle", shapeFields);
+//#endregion
+//#region src/annotation/kinds/circle/index.ts
+const CircleDTOSchema = CircleDeclaration.readSchema;
+const CircleDraftSchema = CircleDeclaration.createSchema;
+const CirclePatchSchema = CircleDeclaration.updateSchema;
+const CircleKind = {
+	subtype: "circle",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.CIRCLE,
+	dtoSchema: CircleDTOSchema,
+	draftSchema: CircleDraftSchema,
+	patchSchema: CirclePatchSchema,
+	readBackWrites: CircleDeclaration.readBackWrites
+};
+//#endregion
+//#region src/wire/resourceKeys.ts
+/**
+* A multipart message carries each file as a part `resource:<key>`, and its
+* JSON names the file by role: `resources: { <role>: <key> }`, on the
+* object the files belong to. These are those objects, one per set of roles.
+*/
+/** A file's key: the `<key>` of its `resource:<key>` part. */
+const ResourceKeySchema = z.string().min(1);
+/** An annotation write's files: its drawing and its attached file. */
+const AnnotationResourceKeysSchema = z.object({
+	appearance: ResourceKeySchema.optional(),
+	file: ResourceKeySchema.optional()
+}).strict();
+/** A drawn appearance: a signature's mark, as a one-page PDF or an image. */
+const AppearanceResourceKeysSchema = z.object({ appearance: ResourceKeySchema }).strict();
+/** An attachment's file. */
+const FileResourceKeysSchema = z.object({ file: ResourceKeySchema }).strict();
+/** The PDF whose pages an insert copies in. */
+const SourceResourceKeysSchema = z.object({ source: ResourceKeySchema }).strict();
+/** An answer's picture. */
+const ImageResourceKeysSchema = z.object({ image: ResourceKeySchema }).strict();
+//#endregion
+//#region src/dto/Attachment.schema.ts
+/**
+* Wire schemas for the attachment vocabulary (see `Attachment.ts`). The
+* write-side `AttachmentFileSource` carries bytes and never appears on the
+* wire; `WireAttachmentFile` is its form there.
+*/
+const WireAttachmentFileSchema = z.object({
+	resources: FileResourceKeysSchema,
+	name: z.string().min(1),
+	mimeType: z.string().optional(),
+	description: z.string().optional()
+});
+/** What a write takes of a file: its name (its key), type and description. */
+const AttachmentFileBaseSchema = z.object({
+	name: z.string().min(1),
+	mimeType: z.string().optional(),
+	description: z.string().optional()
+});
+const AttachmentFileInfoSchema = z.object({
+	name: z.string(),
+	mimeType: z.string().nullable(),
+	description: z.string().nullable(),
+	size: z.number().int().nonnegative().nullable(),
+	checksum: z.string().nullable(),
+	createdAt: IsoDateTimeSchema.nullable(),
+	modifiedAt: IsoDateTimeSchema.nullable()
+});
+const AttachmentRefSchema = z.object({
+	kind: z.literal("key"),
+	key: z.string().min(1)
+});
+const AttachmentSchema = z.object({
+	ref: z.object({
+		kind: z.literal("key"),
+		key: z.string()
+	}),
+	name: z.string(),
+	mimeType: z.string().nullable(),
+	description: z.string().nullable(),
+	size: z.number().int().nonnegative().nullable(),
+	checksum: z.string().nullable(),
+	createdAt: IsoDateTimeSchema.nullable(),
+	modifiedAt: IsoDateTimeSchema.nullable(),
+	index: z.number().int().nonnegative()
+});
+//#endregion
+//#region src/annotation/kinds/file-attachment/values.ts
+const FileAttachmentIconSchema = z.enum([
+	"push-pin",
+	"paperclip",
+	"graph",
+	"tag"
+]);
+//#endregion
+//#region src/annotation/kinds/file-attachment/declaration.ts
+/**
+* The file's metadata; its bytes travel as the `file` resource. What a read
+* adds (size, checksum, creation date) comes from the bytes and is ignored.
+* A create may leave it out when the resource is a `File`, which brings its
+* name and type.
+*/
+const AttachmentFileWriteSchema = z.object({
+	name: z.string().min(1),
+	mimeType: z.string().nullable().optional(),
+	description: z.string().nullable().optional()
+});
+/** A file on the page: its icon fills `rect`, 20×20 at the usual size. */
+const FileAttachmentDeclaration = defineKind("file-attachment", {
+	...annotationBaseFields,
+	...colorStyleFields,
+	icon: field.data(FileAttachmentIconSchema).optional(),
+	/**
+	* `null` when the file specification has no embedded file. A write takes
+	* what a read returns, so a read can be copied: on a create `null` is the
+	* same as leaving it out, and an update that sends back the `null` a read
+	* returned changes nothing (a file can't be removed).
+	*/
+	file: field.data(AttachmentFileInfoSchema).writes(AttachmentFileWriteSchema).nullable().optional()
+}, { file: "required" });
+//#endregion
+//#region src/annotation/kinds/file-attachment/index.ts
+const FileAttachmentDTOSchema = FileAttachmentDeclaration.readSchema;
+const FileAttachmentDraftSchema = FileAttachmentDeclaration.createSchema;
+const FileAttachmentPatchSchema = FileAttachmentDeclaration.updateSchema;
+const FileAttachmentKind = {
+	subtype: "file-attachment",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.FILEATTACHMENT,
+	dtoSchema: FileAttachmentDTOSchema,
+	draftSchema: FileAttachmentDraftSchema,
+	patchSchema: FileAttachmentPatchSchema,
+	readBackWrites: FileAttachmentDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/free-text/values.ts
+/** How a paragraph's lines line up: a free text's `textAlign` too. */
+const RichTextAlignSchema = z.enum([
+	"left",
+	"center",
+	"right",
+	"justify"
+]);
+const RichTextRunStyleShape = {
+	family: z.string().min(1),
+	weight: z.number().int().min(100).max(900),
+	italic: z.boolean(),
+	size: z.number().nonnegative(),
+	color: ColorSchema,
+	decoration: z.array(z.enum([
+		"underline",
+		"line-through",
+		"word"
+	])),
+	script: z.enum([
+		"normal",
+		"sub",
+		"super"
+	]),
+	letterSpacing: z.number(),
+	horizontalScale: z.number().positive(),
+	unknown: z.string().optional()
+};
+const RichTextParagraphPropsShape = {
+	align: RichTextAlignSchema,
+	dir: z.enum(["ltr", "rtl"]),
+	lineHeight: z.number().positive().optional(),
+	margins: z.object({
+		top: z.number(),
+		bottom: z.number(),
+		left: z.number(),
+		right: z.number()
+	}).optional(),
+	textIndent: z.number().optional(),
+	unknown: z.string().optional()
+};
+const RichTextRunStyleDeltaSchema = z.object(RichTextRunStyleShape).partial();
+const RichTextParagraphSchema = z.object({
+	...RichTextParagraphPropsShape,
+	runs: z.array(z.object({
+		text: z.string(),
+		style: RichTextRunStyleDeltaSchema.optional()
+	}))
+}).partial({
+	align: true,
+	dir: true
+});
+const RichTextDocumentSchema = z.object({
+	body: z.object({
+		...RichTextRunStyleShape,
+		...RichTextParagraphPropsShape
+	}),
+	paragraphs: z.array(RichTextParagraphSchema)
+});
+const RichTextDocumentInputSchema = z.object({
+	body: z.object({
+		...RichTextRunStyleShape,
+		...RichTextParagraphPropsShape
+	}).partial().optional(),
+	paragraphs: z.array(RichTextParagraphSchema)
+});
+//#endregion
+//#region src/annotation/kinds/free-text/declaration.ts
+const FreeTextDeclaration = defineKind("free-text", {
+	...annotationBaseFields,
+	...boxFields,
+	/**
+	* A create without it is a callout when it has a `calloutLine`, else a
+	* plain box. A typewriter another app made is kept as it is.
+	*/
+	intent: field.data(FreeTextIntentSchema).writes(FreeTextIntentWriteSchema).readBack().optional(),
+	/** The text's font: the rich text body's. Helvetica when a create leaves it out. */
+	fontFamily: field.data(FontNameSchema).optional(),
+	/** The body's size in points: 12 when a create leaves it out. */
+	fontSize: field.data(z.number().positive()).optional(),
+	/** The body's alignment: left when a create leaves it out. */
+	textAlign: field.data(RichTextAlignSchema).optional(),
+	/** Where the lines sit in the box: top when a create leaves it out. */
+	verticalAlign: field.data(VerticalAlignmentSchema).optional(),
+	richText: field.data(RichTextDocumentSchema).writes(RichTextDocumentInputSchema).optional().space("length"),
+	/** The border's color, and a callout line's. */
+	color: field.data(ColorSchema).optional(),
+	/** The text's color: the rich text body's. Black when a create leaves it out. */
+	fontColor: field.data(ColorSchema).optional(),
+	interiorColor: field.data(ColorSchema).nullable().optional(),
+	opacity: field.data(z.number().min(0).max(1)).optional(),
+	strokeWidth: field.data(z.number().nonnegative()).optional(),
+	borderStyle: field.data(AnnotationBorderStyleSchema).writes(DrawnBorderStyleSchema).readBack().optional(),
+	dashArray: field.data(z.array(z.number().nonnegative())).nullable().optional(),
+	cloudyIntensity: field.data(z.number().positive()).nullable().optional(),
+	calloutLine: field.data(CalloutLineSchema).nullable().optional().space("calloutLine"),
+	lineEnding: field.data(LineEndingSchema).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/free-text/index.ts
+const FreeTextDTOSchema = FreeTextDeclaration.readSchema;
+const FreeTextDraftSchema = FreeTextDeclaration.createSchema;
+const FreeTextPatchSchema = FreeTextDeclaration.updateSchema;
+const FreeTextKind = {
+	subtype: "free-text",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.FREETEXT,
+	dtoSchema: FreeTextDTOSchema,
+	draftSchema: FreeTextDraftSchema,
+	patchSchema: FreeTextPatchSchema,
+	readBackWrites: FreeTextDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/highlight/declaration.ts
+const HighlightDeclaration = defineKind("highlight", textMarkupFields);
+//#endregion
+//#region src/annotation/kinds/highlight/index.ts
+const HighlightDTOSchema = HighlightDeclaration.readSchema;
+const HighlightDraftSchema = HighlightDeclaration.createSchema;
+const HighlightPatchSchema = HighlightDeclaration.updateSchema;
+const HighlightKind = {
+	subtype: "highlight",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.HIGHLIGHT,
+	dtoSchema: HighlightDTOSchema,
+	draftSchema: HighlightDraftSchema,
+	patchSchema: HighlightPatchSchema,
+	readBackWrites: HighlightDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/ink/declaration.ts
+const InkDeclaration = defineKind("ink", {
+	...annotationBaseFields,
+	...geometryStyleFields,
+	/** More than 0 on a write: ink has no fill, so a line of 0 draws nothing. */
+	strokeWidth: field.data(z.number().nonnegative()).writes(z.number().positive()).readBack().optional(),
+	...drawnRectFields,
+	/** At least one stroke on a write, and no stroke without points. */
+	inkList: field.data(InkListSchema).writes(z.array(z.array(PdfPointSchema).min(1)).min(1)).readBack().space("strokes"),
+	intent: field.data(InkIntentSchema).nullable().optional(),
+	...pointsTurnFields
+});
+//#endregion
+//#region src/annotation/kinds/ink/index.ts
+const InkDTOSchema = InkDeclaration.readSchema;
+const InkDraftSchema = InkDeclaration.createSchema;
+const InkPatchSchema = InkDeclaration.updateSchema;
+const InkKind = {
+	subtype: "ink",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.INK,
+	dtoSchema: InkDTOSchema,
+	draftSchema: InkDraftSchema,
+	patchSchema: InkPatchSchema,
+	readBackWrites: InkDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/line/declaration.ts
+const LineDeclaration = defineKind("line", {
+	...annotationBaseFields,
+	...filledStyleFields,
+	...drawnRectFields,
+	linePoints: field.data(LinePointsSchema).space("linePoints"),
+	lineEndings: field.data(LineEndingsSchema).optional(),
+	...pointsTurnFields,
+	intent: field.data(LineIntentSchema).nullable().optional(),
+	measure: measureField,
+	/** `/Cap`: paint `/Contents` on the line. */
+	captionEnabled: field.data(z.boolean()).nullable().optional(),
+	/** `/CP`. */
+	captionPosition: field.data(z.enum(["inline", "top"])).optional(),
+	/** `/CO`, along the line and its normal; `null` is the normal position. */
+	captionOffset: field.data(z.object({
+		along: z.number(),
+		perpendicular: z.number()
+	})).nullable().optional(),
+	/** `/LL`, `/LLE` and `/LLO`. */
+	leader: field.data(LineLeaderSchema).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/line/index.ts
+const LineDTOSchema = LineDeclaration.readSchema;
+const LineDraftSchema = LineDeclaration.createSchema;
+const LinePatchSchema = LineDeclaration.updateSchema;
+const LineKind = {
+	subtype: "line",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.LINE,
+	dtoSchema: LineDTOSchema,
+	draftSchema: LineDraftSchema,
+	patchSchema: LinePatchSchema,
+	readBackWrites: LineDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/link/declaration.ts
+const LinkDeclaration = defineKind("link", {
+	...annotationBaseFields,
+	target: field.data(FileLinkTargetSchema).writes(FileLinkTargetWritableSchema).nullable().readBack().space("linkTarget")
+});
+//#endregion
+//#region src/annotation/kinds/link/index.ts
+const LinkDTOSchema = LinkDeclaration.readSchema;
+const LinkDraftSchema = LinkDeclaration.createSchema;
+const LinkPatchSchema = LinkDeclaration.updateSchema;
+const LinkKind = {
+	subtype: "link",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.LINK,
+	dtoSchema: LinkDTOSchema,
+	draftSchema: LinkDraftSchema,
+	patchSchema: LinkPatchSchema,
+	readBackWrites: LinkDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/polygon/declaration.ts
+const PolygonDeclaration = defineKind("polygon", {
+	...vertexFields,
+	/** At least three points on a write; fewer enclose nothing. */
+	vertices: field.data(z.array(PdfPointSchema)).writes(z.array(PdfPointSchema).min(3)).readBack().space("points"),
+	...shapeCaptionFields,
+	intent: field.data(PolygonIntentSchema).nullable().optional(),
+	measure: measureField,
+	cloudyIntensity: field.data(z.number().positive()).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/polygon/index.ts
+const PolygonDTOSchema = PolygonDeclaration.readSchema;
+const PolygonDraftSchema = PolygonDeclaration.createSchema;
+const PolygonPatchSchema = PolygonDeclaration.updateSchema;
+const PolygonKind = {
+	subtype: "polygon",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.POLYGON,
+	dtoSchema: PolygonDTOSchema,
+	draftSchema: PolygonDraftSchema,
+	patchSchema: PolygonPatchSchema,
+	readBackWrites: PolygonDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/polyline/declaration.ts
+const PolylineDeclaration = defineKind("polyline", {
+	...vertexFields,
+	/** At least two points on a write; fewer draw nothing. */
+	vertices: field.data(z.array(PdfPointSchema)).writes(z.array(PdfPointSchema).min(2)).readBack().space("points"),
+	...shapeCaptionFields,
+	intent: field.data(PolylineIntentSchema).nullable().optional(),
+	measure: measureField,
+	lineEndings: field.data(LineEndingsSchema).optional()
+});
+//#endregion
+//#region src/annotation/kinds/polyline/index.ts
+const PolylineDTOSchema = PolylineDeclaration.readSchema;
+const PolylineDraftSchema = PolylineDeclaration.createSchema;
+const PolylinePatchSchema = PolylineDeclaration.updateSchema;
+const PolylineKind = {
+	subtype: "polyline",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.POLYLINE,
+	dtoSchema: PolylineDTOSchema,
+	draftSchema: PolylineDraftSchema,
+	patchSchema: PolylinePatchSchema,
+	readBackWrites: PolylineDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/popup/declaration.ts
+/** The window that shows its parent annotation's text. */
+const PopupDeclaration = defineKind("popup", {
+	...annotationBaseFields,
+	/**
+	* `/Parent`: the annotation this popup shows. Required on create; `null`
+	* on a read of a popup whose PDF names none, which an update may send
+	* back unchanged.
+	*/
+	parent: field.data(AnnotationRefSchema).nullableOnRead().readBack(),
+	/** `/Open`: whether the window is shown open. `false` when the PDF doesn't say. */
+	open: field.data(z.boolean()).optional()
+});
+//#endregion
+//#region src/annotation/kinds/popup/index.ts
+const PopupDTOSchema = PopupDeclaration.readSchema;
+const PopupDraftSchema = PopupDeclaration.createSchema;
+const PopupPatchSchema = PopupDeclaration.updateSchema;
+const PopupKind = {
+	subtype: "popup",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.POPUP,
+	dtoSchema: PopupDTOSchema,
+	draftSchema: PopupDraftSchema,
+	patchSchema: PopupPatchSchema,
+	readBackWrites: PopupDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/redact/declaration.ts
+const RedactDeclaration = defineKind("redact", {
+	...annotationBaseFields,
+	...colorStyleFields,
+	/** Worked out from the quads when a create gives quads and no `rect`. */
+	rect: field.data(PdfRectSchema).optional().space("box"),
+	quadPoints: field.data(z.array(PdfQuadSchema)).optional().space("quads"),
+	interiorColor: field.data(ColorSchema).nullable().optional(),
+	overlayText: field.data(z.string()).nullable().optional(),
+	repeat: field.data(z.boolean()).optional(),
+	/** A standard font or a registered key, as on free text. */
+	fontFamily: field.data(FontNameSchema).optional(),
+	/** `0` fits the label to the region. */
+	fontSize: field.data(z.number().nonnegative()).optional(),
+	fontColor: field.data(ColorSchema).optional(),
+	textAlign: field.data(TextAlignmentSchema).optional()
+});
+//#endregion
+//#region src/annotation/kinds/redact/index.ts
+const RedactDTOSchema = RedactDeclaration.readSchema;
+const RedactDraftSchema = RedactDeclaration.createSchema;
+const RedactPatchSchema = RedactDeclaration.updateSchema;
+const RedactKind = {
+	subtype: "redact",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.REDACT,
+	dtoSchema: RedactDTOSchema,
+	draftSchema: RedactDraftSchema,
+	patchSchema: RedactPatchSchema,
+	readBackWrites: RedactDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/square/declaration.ts
+const SquareDeclaration = defineKind("square", shapeFields);
+//#endregion
+//#region src/annotation/kinds/square/index.ts
+const SquareDTOSchema = SquareDeclaration.readSchema;
+const SquareDraftSchema = SquareDeclaration.createSchema;
+const SquarePatchSchema = SquareDeclaration.updateSchema;
+const SquareKind = {
+	subtype: "square",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.SQUARE,
+	dtoSchema: SquareDTOSchema,
+	draftSchema: SquareDraftSchema,
+	patchSchema: SquarePatchSchema,
+	readBackWrites: SquareDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/squiggly/declaration.ts
+const SquigglyDeclaration = defineKind("squiggly", textMarkupFields);
+//#endregion
+//#region src/annotation/kinds/squiggly/index.ts
+const SquigglyDTOSchema = SquigglyDeclaration.readSchema;
+const SquigglyDraftSchema = SquigglyDeclaration.createSchema;
+const SquigglyPatchSchema = SquigglyDeclaration.updateSchema;
+const SquigglyKind = {
+	subtype: "squiggly",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.SQUIGGLY,
+	dtoSchema: SquigglyDTOSchema,
+	draftSchema: SquigglyDraftSchema,
+	patchSchema: SquigglyPatchSchema,
+	readBackWrites: SquigglyDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/stamp/values.ts
+const StampFitSchema = z.enum([
+	"contain",
+	"cover",
+	"fill"
+]);
+//#endregion
+//#region src/annotation/kinds/stamp/declaration.ts
+const StampDeclaration = defineKind("stamp", {
+	...annotationBaseFields,
+	...boxFields,
+	/** `/Name`: the stamp's label, such as `Approved`. */
+	name: field.data(z.string()).nullable().optional(),
+	/**
+	* How the drawing is scaled into the box, and re-fit when the box changes
+	* (`/EMBD_Metadata/AppearanceFit`). `null` when the PDF doesn't record it,
+	* as for a stamp another tool made; the engine then fits with `'fill'`,
+	* the way a PDF places any appearance in its `/Rect`. A create without it
+	* fits with `'contain'` and records that.
+	*/
+	fit: field.data(StampFitSchema).nullable().optional(),
+	/** `/CA`, painted once over the whole drawing. */
+	opacity: field.data(z.number().min(0).max(1)).optional()
+}, { appearance: "required" });
+//#endregion
+//#region src/annotation/kinds/stamp/index.ts
+const StampDTOSchema = StampDeclaration.readSchema;
+const StampDraftSchema = StampDeclaration.createSchema;
+const StampPatchSchema = StampDeclaration.updateSchema;
+const StampKind = {
+	subtype: "stamp",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.STAMP,
+	dtoSchema: StampDTOSchema,
+	draftSchema: StampDraftSchema,
+	patchSchema: StampPatchSchema,
+	readBackWrites: StampDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/strikeout/declaration.ts
+const StrikeoutDeclaration = defineKind("strikeout", {
+	...textMarkupFields,
+	intent: field.data(StrikeoutIntentSchema).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/strikeout/index.ts
+const StrikeoutDTOSchema = StrikeoutDeclaration.readSchema;
+const StrikeoutDraftSchema = StrikeoutDeclaration.createSchema;
+const StrikeoutPatchSchema = StrikeoutDeclaration.updateSchema;
+const StrikeoutKind = {
+	subtype: "strikeout",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.STRIKEOUT,
+	dtoSchema: StrikeoutDTOSchema,
+	draftSchema: StrikeoutDraftSchema,
+	patchSchema: StrikeoutPatchSchema,
+	readBackWrites: StrikeoutDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/text/values.ts
+const NoteIconSchema = z.enum([
+	"comment",
+	"key",
+	"note",
+	"help",
+	"new-paragraph",
+	"paragraph",
+	"insert"
+]);
+//#endregion
+//#region src/annotation/kinds/text/declaration.ts
+/** A note: its icon fills `rect`, 20×20 at the usual size. */
+const TextDeclaration = defineKind("text", {
+	...annotationBaseFields,
+	...colorStyleFields,
+	icon: field.data(NoteIconSchema).optional(),
+	/**
+	* `/Open`: whether the note's window shows open. Kept equal to its
+	* popup's `open`: a write sets both. `false` when the PDF doesn't say.
+	*/
+	open: field.data(z.boolean()).optional(),
+	/** `/State`: standard states in lowercase, custom ones as written. */
+	state: field.data(z.string().min(1)).nullable().optional(),
+	stateModel: field.data(z.string().min(1)).nullable().optional()
+});
+//#endregion
+//#region src/annotation/kinds/text/index.ts
+const TextDTOSchema = TextDeclaration.readSchema;
+const TextDraftSchema = TextDeclaration.createSchema;
+const TextPatchSchema = TextDeclaration.updateSchema;
+const TextKind = {
+	subtype: "text",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.TEXT,
+	dtoSchema: TextDTOSchema,
+	draftSchema: TextDraftSchema,
+	patchSchema: TextPatchSchema,
+	readBackWrites: TextDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/underline/declaration.ts
+const UnderlineDeclaration = defineKind("underline", textMarkupFields);
+//#endregion
+//#region src/annotation/kinds/underline/index.ts
+const UnderlineDTOSchema = UnderlineDeclaration.readSchema;
+const UnderlineDraftSchema = UnderlineDeclaration.createSchema;
+const UnderlinePatchSchema = UnderlineDeclaration.updateSchema;
+const UnderlineKind = {
+	subtype: "underline",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.UNDERLINE,
+	dtoSchema: UnderlineDTOSchema,
+	draftSchema: UnderlineDraftSchema,
+	patchSchema: UnderlinePatchSchema,
+	readBackWrites: UnderlineDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/unsupported/declaration.ts
+/** An annotation of a type the engine doesn't model: only the shared fields are read. */
+const UnsupportedDeclaration = defineKind("unsupported", {
+	...annotationBaseFields,
+	rawSubtypeCode: field.engine(z.number().int()),
+	rawSubtypeName: field.engine(z.string()).nullable()
+});
+//#endregion
+//#region src/annotation/kinds/unsupported/index.ts
+const UnsupportedDTOSchema = UnsupportedDeclaration.readSchema;
+const UnsupportedDraftSchema = z.never();
+const UnsupportedPatchSchema = z.never();
+const UnsupportedKind = {
+	subtype: "unsupported",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.UNKNOWN,
+	dtoSchema: UnsupportedDTOSchema,
+	draftSchema: UnsupportedDraftSchema,
+	patchSchema: UnsupportedPatchSchema,
+	readBackWrites: UnsupportedDeclaration.readBackWrites
+};
+//#endregion
+//#region src/identity/FormFieldRef.schema.ts
+/** Wire form of `FormFieldRef` — see the type. */
+const FormFieldRefSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("objectNumber"),
+	objectNumber: z.number().int().positive()
+}), z.object({
+	kind: z.literal("fqn"),
+	name: z.string().min(1)
+})]);
+//#endregion
+//#region src/annotation/kinds/widget/declaration.ts
+const WidgetDeclaration = defineKind("widget", {
+	...annotationBaseFields,
+	...widgetBoxFields,
+	color: field.data(ColorSchema).nullable().optional(),
+	interiorColor: field.data(ColorSchema).nullable().optional(),
+	strokeWidth: field.data(z.number().nonnegative()).optional(),
+	borderStyle: field.data(WidgetBorderStyleSchema).optional(),
+	/** The border's dash pattern (`/BS /D`), for a dashed border; `null` for the default (3 on, 3 off). */
+	dashArray: field.data(z.array(z.number().nonnegative())).nullable().optional(),
+	/**
+	* The font `/DA` names, as a free text names its font: a standard font's
+	* name, a registered font's key, or the family of a font the document has.
+	* `null` when `/DA` names none. A write takes a standard name or a key.
+	*/
+	fontFamily: field.data(FontNameSchema).nullable().optional(),
+	fontSize: field.data(z.number().nonnegative()).nullable().optional(),
+	fontColor: field.data(ColorSchema).nullable().optional(),
+	textAlign: field.data(TextAlignmentSchema).optional(),
+	/**
+	* A push button's caption (`/MK /CA`), drawn centred on the button.
+	* `null` for every other widget, whose `/MK /CA` is no caption (a
+	* checkbox's is its symbol); a caption written to one is refused.
+	*/
+	caption: field.data(z.string()).nullable().optional(),
+	/**
+	* The symbol a checkbox's or radio button's widget shows while it's on
+	* (`/MK /CA`); `null` shows its family's own, a checkbox's check and a
+	* radio button's circle. Always `null` for other widgets, and one written
+	* to another widget is refused.
+	*/
+	checkStyle: field.data(WidgetCheckStyleSchema).nullable().optional(),
+	/**
+	* `/A` and `/AA`: what the widget does when clicked, entered, focused and
+	* so on. A write sets an event's action, `null` removes it, an event left
+	* out keeps what it has; `null` for the whole removes them all. The
+	* actions a read returns, sent back unchanged, are kept.
+	*/
+	actions: field.data(FileAnnotationActionsSchema).writes(FileWidgetActionsPatchSchema).readBack().nullable().optional().space("actions"),
+	/** The field the widget belongs to, or `null` when it's in none. */
+	field: field.engine(FormFieldRefSchema).nullable(),
+	/** Its field's family, so a widget reads as what it is without the form. */
+	fieldFamily: field.engine(z.enum([
+		"text",
+		"checkbox",
+		"radio",
+		"combobox",
+		"listbox",
+		"pushbutton",
+		"signature",
+		"unknown"
+	]))
+});
+//#endregion
+//#region src/annotation/kinds/widget/index.ts
+const WidgetDTOSchema = WidgetDeclaration.readSchema;
+const WidgetDraftSchema = WidgetDeclaration.createSchema;
+const WidgetPatchSchema = WidgetDeclaration.updateSchema;
+const WidgetKind = {
+	subtype: "widget",
+	pdfSubtypeCode: PdfAnnotationSubtypeCode.WIDGET,
+	dtoSchema: WidgetDTOSchema,
+	draftSchema: WidgetDraftSchema,
+	patchSchema: WidgetPatchSchema,
+	readBackWrites: WidgetDeclaration.readBackWrites
+};
+//#endregion
+//#region src/annotation/kinds/declarations.ts
+/** Every annotation kind's declaration, in the engine's catalog order. */
+const ANNOTATION_DECLARATIONS = [
+	HighlightDeclaration,
+	UnderlineDeclaration,
+	SquigglyDeclaration,
+	StrikeoutDeclaration,
+	CircleDeclaration,
+	SquareDeclaration,
+	PolygonDeclaration,
+	PolylineDeclaration,
+	LineDeclaration,
+	LinkDeclaration,
+	InkDeclaration,
+	FreeTextDeclaration,
+	CaretDeclaration,
+	TextDeclaration,
+	StampDeclaration,
+	FileAttachmentDeclaration,
+	WidgetDeclaration,
+	RedactDeclaration,
+	PopupDeclaration,
+	UnsupportedDeclaration
+];
+/** Looks up a kind's declaration by its `subtype`. */
+function declarationOf(subtype) {
+	return ANNOTATION_DECLARATIONS.find((declaration) => declaration.subtype === subtype) ?? null;
+}
+/** The style fields' schemas, as a widget annotation's update takes them. */
+const WIDGET_STYLE_SHAPE = Object.fromEntries([
+	"color",
+	"interiorColor",
+	"strokeWidth",
+	"borderStyle",
+	"dashArray",
+	"fontFamily",
+	"fontSize",
+	"fontColor",
+	"textAlign",
+	"caption",
+	"checkStyle"
+].map((name) => [name, WidgetDeclaration.shapes.update[name]]));
+const WidgetAppearanceSchema = z.object(WIDGET_STYLE_SHAPE).strict();
+//#endregion
+//#region src/annotation/kinds/index.ts
+/**
+* The closed-world catalog of currently-implemented annotation kinds.
+*
+* Adding a new subtype is one folder under `kinds/<name>/` with its
+* `declaration.ts` and `index.ts`, and one entry in this tuple and in
+* `declarations.ts`. The discriminated unions and zod discriminator below regenerate
+* automatically; no other file in the package needs to change.
+*
+* Every subtype the engine has not yet wired up rides on
+* `UnsupportedKind`. The wire format is stable: when a per-subtype reader
+* lands later, the engine starts emitting the dedicated DTO instead of
+* `unsupported`, and existing clients widen their handling without a
+* version bump.
+*/
+const ANNOTATION_KINDS = [
+	HighlightKind,
+	UnderlineKind,
+	SquigglyKind,
+	StrikeoutKind,
+	CircleKind,
+	SquareKind,
+	PolygonKind,
+	PolylineKind,
+	LineKind,
+	LinkKind,
+	InkKind,
+	FreeTextKind,
+	CaretKind,
+	TextKind,
+	StampKind,
+	FileAttachmentKind,
+	WidgetKind,
+	RedactKind,
+	PopupKind,
+	UnsupportedKind
+];
+/**
+* Lookup helper for the engine's reader catalog and identity resolver.
+* O(1) by `subtype` literal at runtime.
+*/
+const KIND_BY_SUBTYPE = Object.freeze(Object.fromEntries(ANNOTATION_KINDS.map((kind) => [kind.subtype, kind])));
+/**
+* Runtime zod schema for the discriminated union. The cast unwinds the
+* generic schema map into the specific tuple form `discriminatedUnion`
+* needs. Servers and cloud clients use this to validate every annotation
+* payload on the wire.
+*/
+const AnnotationSchema = z.discriminatedUnion("subtype", [
+	HighlightKind.dtoSchema,
+	UnderlineKind.dtoSchema,
+	SquigglyKind.dtoSchema,
+	StrikeoutKind.dtoSchema,
+	CircleKind.dtoSchema,
+	SquareKind.dtoSchema,
+	PolygonKind.dtoSchema,
+	PolylineKind.dtoSchema,
+	LineKind.dtoSchema,
+	LinkKind.dtoSchema,
+	InkKind.dtoSchema,
+	FreeTextKind.dtoSchema,
+	CaretKind.dtoSchema,
+	TextKind.dtoSchema,
+	StampKind.dtoSchema,
+	FileAttachmentKind.dtoSchema,
+	WidgetKind.dtoSchema,
+	RedactKind.dtoSchema,
+	PopupKind.dtoSchema,
+	UnsupportedKind.dtoSchema
+]);
+/** Validates a create's data against its kind. */
+const AnnotationDraftSchema = z.discriminatedUnion("subtype", [
+	HighlightKind.draftSchema,
+	UnderlineKind.draftSchema,
+	SquigglyKind.draftSchema,
+	StrikeoutKind.draftSchema,
+	CircleKind.draftSchema,
+	SquareKind.draftSchema,
+	PolygonKind.draftSchema,
+	PolylineKind.draftSchema,
+	LineKind.draftSchema,
+	LinkKind.draftSchema,
+	InkKind.draftSchema,
+	FreeTextKind.draftSchema,
+	CaretKind.draftSchema,
+	TextKind.draftSchema,
+	StampKind.draftSchema,
+	FileAttachmentKind.draftSchema,
+	WidgetKind.draftSchema,
+	RedactKind.draftSchema,
+	PopupKind.draftSchema
+]);
+/**
+* Validates a patch against every kind. A
+* patch may leave out its `subtype`, so this only checks that the patch fits
+* some kind; {@link annotationPatchSchemaOf} checks it against its target.
+*/
+const AnnotationPatchSchema = z.union(ANNOTATION_KINDS.filter((kind) => kind.subtype !== "unsupported").map((kind) => kind.patchSchema));
+/** The patch schema of one kind: how an update of an annotation of that kind is checked. */
+function annotationPatchSchemaOf(subtype) {
+	return KIND_BY_SUBTYPE[subtype].patchSchema;
+}
+/**
+* A create's data in the file's coordinates, checked against its kind: the
+* engine's own check, after the worker converted the data from page space.
+*/
+const FileAnnotationDraftSchema = z.discriminatedUnion("subtype", ANNOTATION_DECLARATIONS.filter((declaration) => declaration.subtype !== "unsupported").map((declaration) => declaration.fileSchemas.create));
+/** An update's data in the file's coordinates, checked against the kind it changes. */
+function fileAnnotationPatchSchemaOf(subtype) {
+	return declarationOf(subtype).fileSchemas.update;
+}
+//#endregion
+//#region src/forms/schema.ts
+const FormWidgetShape = {
+	ref: AnnotationRefSchema.nullable(),
+	objectNumber: z.number().int().nonnegative(),
+	page: PageRefSchema.nullable()
+};
+const FormWidgetSchema = z.object(FormWidgetShape);
+const FormFieldWidgetSchema = FormWidgetSchema;
+const ToggleFieldWidgetSchema = z.object({
+	...FormWidgetShape,
+	onState: z.string(),
+	exportValue: z.string(),
+	checked: z.boolean()
+});
+const FormFieldOptionSchema = z.object({
+	label: z.string(),
+	value: z.string(),
+	selected: z.boolean()
+});
+const FormValueEntrySchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("none") }),
+	z.object({
+		kind: z.literal("scalar"),
+		value: z.string()
+	}),
+	z.object({
+		kind: z.literal("array"),
+		values: z.array(z.string())
+	}),
+	z.object({ kind: z.literal("unsupported") })
+]);
+const FormFieldBaseShape = {
+	ref: FormFieldRefSchema,
+	name: z.string(),
+	origin: z.enum(["acroform", "recovered"]),
+	readOnly: z.boolean(),
+	required: z.boolean(),
+	noExport: z.boolean(),
+	alternateName: z.string().nullable(),
+	mappingName: z.string().nullable(),
+	valueEntry: FormValueEntrySchema,
+	defaultValueEntry: FormValueEntrySchema,
+	actions: PdfFieldActionsSchema.optional(),
+	groupId: z.string().nullable(),
+	createdBy: z.string().nullable(),
+	createdAt: IsoDateTimeSchema.nullable(),
+	filledBy: z.string().nullable(),
+	filledByName: z.string().nullable(),
+	filledAt: IsoDateTimeSchema.nullable(),
+	importedBy: z.string().nullable(),
+	widgets: z.array(FormFieldWidgetSchema)
+};
+const FormFieldDTOSchema = z.discriminatedUnion("family", [
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("text"),
+		value: z.string(),
+		defaultValue: z.string(),
+		maxLength: z.number().int().positive().nullable(),
+		multiline: z.boolean(),
+		password: z.boolean(),
+		comb: z.boolean()
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("checkbox"),
+		checked: z.boolean(),
+		exportValue: z.string(),
+		widgets: z.array(ToggleFieldWidgetSchema)
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("radio"),
+		value: z.string(),
+		radiosInUnison: z.boolean(),
+		noToggleToOff: z.boolean(),
+		widgets: z.array(ToggleFieldWidgetSchema)
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("combobox"),
+		value: z.string(),
+		defaultValue: z.string(),
+		edit: z.boolean(),
+		options: z.array(FormFieldOptionSchema)
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("listbox"),
+		selectedValues: z.array(z.string()),
+		defaultValue: z.array(z.string()),
+		multiSelect: z.boolean(),
+		options: z.array(FormFieldOptionSchema),
+		topIndex: z.number().int().nonnegative()
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("pushbutton")
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("signature")
+	}),
+	z.object({
+		...FormFieldBaseShape,
+		family: z.literal("unknown"),
+		rawValue: z.string()
+	})
+]);
+const FormKindSchema = z.enum([
+	"none",
+	"acroform",
+	"xfa"
+]);
+const FormSnapshotSchema = z.object({
+	formKind: FormKindSchema,
+	needsAppearances: z.boolean(),
+	fields: z.array(FormFieldDTOSchema),
+	widgets: z.array(WidgetDTOSchema),
+	calculationOrder: z.array(FormFieldRefSchema.nullable())
+});
+/**
+* `{ value }`, `{ checked }` or `{ selectedValues }`: one object with exactly
+* one of the three, so the wire has no untagged union (the API reference
+* labels variants by a discriminating literal, and a value has none to add).
+*/
+const FormFieldValueSchema = z.object({
+	value: z.string().nullable().optional(),
+	checked: z.boolean().optional(),
+	selectedValues: z.array(z.string()).optional()
+}).strict().refine((value) => [
+	value.value,
+	value.checked,
+	value.selectedValues
+].filter((set) => set !== void 0).length === 1, { message: "exactly one of value, checked or selectedValues" });
+const WidgetPlacementSchema = z.object({
+	page: PageRefSchema,
+	rect: PageBoxSchema.optional(),
+	box: PageBoxSchema.optional(),
+	rotation: PdfRotationSchema.optional(),
+	exportValue: z.string().min(1).optional(),
+	actions: WidgetActionsPatchSchema.optional(),
+	...WIDGET_STYLE_SHAPE
+}).strict();
+const FormFieldOptionInputSchema = z.object({
+	label: z.string(),
+	value: z.string()
+});
+const FormFieldDraftBaseShape = {
+	name: z.string().min(1),
+	readOnly: z.boolean().optional(),
+	required: z.boolean().optional(),
+	noExport: z.boolean().optional(),
+	alternateName: z.string().optional(),
+	mappingName: z.string().optional(),
+	groupId: z.string().min(1).max(256).optional(),
+	actions: FieldActionsPatchSchema.optional(),
+	widgets: z.array(WidgetPlacementSchema).optional()
+};
+/** A draft that names a member its family doesn't have is refused, not trimmed. */
+const FormFieldDraftSchema = z.discriminatedUnion("family", [
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("text"),
+		defaultValue: z.string().optional(),
+		maxLength: z.number().int().positive().optional(),
+		multiline: z.boolean().optional(),
+		password: z.boolean().optional(),
+		comb: z.boolean().optional()
+	}).strict(),
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("checkbox")
+	}).strict(),
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("radio"),
+		radiosInUnison: z.boolean().optional(),
+		noToggleToOff: z.boolean().optional()
+	}).strict(),
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("combobox"),
+		edit: z.boolean().optional(),
+		options: z.array(FormFieldOptionInputSchema).optional(),
+		defaultValue: z.string().optional()
+	}).strict(),
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("listbox"),
+		multiSelect: z.boolean().optional(),
+		options: z.array(FormFieldOptionInputSchema).optional(),
+		defaultValue: z.array(z.string()).optional()
+	}).strict(),
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("pushbutton")
+	}).strict(),
+	z.object({
+		...FormFieldDraftBaseShape,
+		family: z.literal("signature")
+	}).strict()
+]);
+const FormFieldPatchBaseShape = {
+	name: z.string().min(1).optional(),
+	readOnly: z.boolean().optional(),
+	required: z.boolean().optional(),
+	noExport: z.boolean().optional(),
+	alternateName: z.string().nullable().optional(),
+	mappingName: z.string().nullable().optional(),
+	groupId: z.string().min(1).max(256).optional(),
+	actions: FieldActionsPatchSchema.optional()
+};
+/**
+* One object on the wire: the family is optional (the engine knows it from
+* the ref), so there is no discriminator, and the engine refuses members
+* the field's family doesn't have.
+*/
+const FormFieldPatchSchema = z.object({
+	...FormFieldPatchBaseShape,
+	family: z.enum([
+		"text",
+		"checkbox",
+		"radio",
+		"combobox",
+		"listbox",
+		"pushbutton",
+		"signature"
+	]).optional(),
+	defaultValue: z.union([z.string(), z.array(z.string())]).nullable().optional(),
+	maxLength: z.number().int().positive().nullable().optional(),
+	multiline: z.boolean().optional(),
+	password: z.boolean().optional(),
+	comb: z.boolean().optional(),
+	radiosInUnison: z.boolean().optional(),
+	noToggleToOff: z.boolean().optional(),
+	edit: z.boolean().optional(),
+	multiSelect: z.boolean().optional(),
+	options: z.array(FormFieldOptionInputSchema).optional()
+}).strict();
+//#endregion
+export { PolylineDTOSchema as $, PolygonIntentSchema as $t, UnderlineDTOSchema as A, InkIntentSchema as An, AppearanceResourceKeysSchema as At, StampDTOSchema as B, WidgetCheckStyleSchema as Bn, CaretPatchSchema as Bt, declarationOf as C, AnnotationRefSchema as Cn, FileAttachmentIconSchema as Ct, UnsupportedDTOSchema as D, DrawnBorderStyleSchema as Dn, AttachmentSchema as Dt, FormFieldRefSchema as E, ColorSchema as En, AttachmentRefSchema as Et, TextPatchSchema as F, StandardFontSchema as Fn, CircleDTOSchema as Ft, SquigglyDraftSchema as G, PagePointSchema as Gn, PageMeasurementViewportListSchema as Gt, StampPatchSchema as H, InkListSchema as Hn, LineDimensionCaptionSchema as Ht, NoteIconSchema as I, StrikeoutIntentSchema as In, CircleDraftSchema as It, SquareDraftSchema as J, PdfQuadSchema as Jn, PdfForeignMeasureSchema as Jt, SquigglyPatchSchema as K, PageQuadSchema as Kn, PageMeasurementViewportSchema as Kt, StrikeoutDTOSchema as L, TextAlignmentSchema as Ln, CirclePatchSchema as Lt, UnderlinePatchSchema as M, LineEndingsSchema as Mn, ImageResourceKeysSchema as Mt, TextDTOSchema as N, PointSchema as Nn, ResourceKeySchema as Nt, UnsupportedDraftSchema as O, FreeTextIntentSchema as On, WireAttachmentFileSchema as Ot, TextDraftSchema as P, RectSchema as Pn, SourceResourceKeysSchema as Pt, PopupPatchSchema as Q, PageRefSchema as Qn, PdfNumberFormatSchema as Qt, StrikeoutDraftSchema as R, VerticalAlignmentSchema as Rn, CaretDTOSchema as Rt, WidgetAppearanceSchema as S, AnnotationBorderStyleSchema as Sn, FileAttachmentPatchSchema as St, WidgetPatchSchema as T, CaretIntentSchema as Tn, AttachmentFileInfoSchema as Tt, StampFitSchema as U, LinePointsSchema as Un, LineIntentSchema as Ut, StampDraftSchema as V, CalloutLineSchema as Vn, LineCaptionPatchSchema as Vt, SquigglyDTOSchema as W, PageBoxSchema as Wn, LineLeaderSchema as Wt, PopupDTOSchema as X, PdfRotationSchema as Xn, PdfMeasureWriteSchema as Xt, SquarePatchSchema as Y, PdfRectSchema as Yn, PdfMeasureSchema as Yt, PopupDraftSchema as Z, PdfSizeSchema as Zn, PdfMeasurementSchema as Zt, AnnotationSchema as _, PdfPageActionsSchema as _n, FreeTextDTOSchema as _t, FormFieldPatchSchema as a, DocumentActionsSnapshotSchema as an, LinkDTOSchema as at, annotationPatchSchemaOf as b, PdfLinkTargetWritableSchema as bn, FileAttachmentDTOSchema as bt, FormKindSchema as c, FileWidgetActionsPatchSchema as cn, LineDTOSchema as ct, FormWidgetSchema as d, PdfActionTreeSchema as dn, InkDTOSchema as dt, PolylineIntentSchema as en, PolylineDraftSchema as et, ToggleFieldWidgetSchema as f, PdfActionTypeSchema as fn, InkDraftSchema as ft, AnnotationPatchSchema as g, PdfFieldActionsSchema as gn, HighlightPatchSchema as gt, AnnotationDraftSchema as h, PdfAnnotationActionsSchema as hn, HighlightDraftSchema as ht, FormFieldOptionSchema as i, IsoDateTimeSchema as in, PolygonPatchSchema as it, UnderlineDraftSchema as j, LineEndingSchema as jn, FileResourceKeysSchema as jt, UnsupportedPatchSchema as k, FreeTextIntentWriteSchema as kn, AnnotationResourceKeysSchema as kt, FormSnapshotSchema as l, PdfActionNodeSchema as ln, LineDraftSchema as lt, ANNOTATION_KINDS as m, PdfActionWriteSchema as mn, HighlightDTOSchema as mt, FormFieldDraftSchema as n, ShapeDimensionCaptionSchema as nn, PolygonDTOSchema as nt, FormFieldValueSchema as o, FieldActionsPatchSchema as on, LinkDraftSchema as ot, WidgetPlacementSchema as p, PdfActionWireComponents as pn, InkPatchSchema as pt, SquareDTOSchema as q, PdfPointSchema as qn, PageScaleInputSchema as qt, FormFieldOptionInputSchema as r, DateInputSchema as rn, PolygonDraftSchema as rt, FormFieldWidgetSchema as s, FieldScriptWriteSchema as sn, LinkPatchSchema as st, FormFieldDTOSchema as t, ShapeCaptionPatchSchema as tn, PolylinePatchSchema as tt, FormValueEntrySchema as u, PdfActionTargetRefSchema as un, LinePatchSchema as ut, FileAnnotationDraftSchema as v, WidgetActionsPatchSchema as vn, FreeTextDraftSchema as vt, WidgetDTOSchema as w, BlendModeSchema as wn, AttachmentFileBaseSchema as wt, fileAnnotationPatchSchemaOf as x, PdfDestinationSchema as xn, FileAttachmentDraftSchema as xt, KIND_BY_SUBTYPE as y, PdfLinkTargetSchema as yn, FreeTextPatchSchema as yt, StrikeoutPatchSchema as z, WidgetBorderStyleSchema as zn, CaretDraftSchema as zt };
+
+//# sourceMappingURL=schema-6S2VmlAj.js.map