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

package/dist/conformance.cjs

@@ -1,12 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_Change = require("./Change-Ct-dB8D5.cjs");
+const require_calibrate = require("./calibrate-DJbi1wuK.cjs");
 const require_resolveAnnotationDraft = require("./resolveAnnotationDraft-7Ke4nV7F.cjs");
 const require_format = require("./format-Bp3QFSH1.cjs");
-const require_calibrate = require("./calibrate-DJBXnhLE.cjs");
 const require_pageRefs = require("./pageRefs-B3ur7Ckm.cjs");
-const require_Change = require("./Change-CjImsrN0.cjs");
 require("./PageInsertBlankInput-CXHAM7l6.cjs");
-const require_schema = require("./schema-C-gU4vj7.cjs");
-const require_schemas = require("./schemas-Berf1swF.cjs");
+const require_schema = require("./schema-miH6tWQC.cjs");
+const require_schemas = require("./schemas-DljJR9ut.cjs");
 const require_LocalDocumentHandle = require("./LocalDocumentHandle-D02FMm-Z.cjs");
 //#region src/conformance/fixtureScope.ts
 /**
@@ -3792,7 +3792,7 @@ const FORGED = {
 	modifiedAt: "2001-01-01T00:00:00.000Z",
 	importedBy: "mallory"
 };
-const SQUARE$1 = {
+const SQUARE$2 = {
 	subtype: "square",
 	box: {
 		x: 40,
@@ -3849,7 +3849,7 @@ function runAnnotationAttributionConformance(runner, opts) {
 			}, async (page) => {
 				const before = Date.now();
 				const { annotation: created } = await page.annotations.create({
-					...SQUARE$1,
+					...SQUARE$2,
 					...FORGED
 				});
 				const after = Date.now();
@@ -3882,7 +3882,7 @@ function runAnnotationAttributionConformance(runner, opts) {
 			try {
 				const page = await firstPage$1(alice);
 				({annotation: original} = await page.annotations.create({
-					...SQUARE$1,
+					...SQUARE$2,
 					nm: "attribution-conformance-update"
 				}));
 			} catch (error) {
@@ -3948,12 +3948,12 @@ function runAnnotationAttributionConformance(runner, opts) {
 				identity: ALICE$2
 			}, async (page) => {
 				const own = await page.annotations.create({
-					...SQUARE$1,
+					...SQUARE$2,
 					groupId: "legal"
 				});
 				expect(own.annotation.groupId).toBe("legal");
 				await expectRefused(() => page.annotations.create({
-					...SQUARE$1,
+					...SQUARE$2,
 					groupId: "finance"
 				}), "set-group");
 			});
@@ -3963,7 +3963,7 @@ function runAnnotationAttributionConformance(runner, opts) {
 			};
 			await asSession(granted, async (page) => {
 				const { annotation: created } = await page.annotations.create({
-					...SQUARE$1,
+					...SQUARE$2,
 					groupId: "finance"
 				});
 				expect(attributionOf(await readBack(page, created.ref))).toMatchObject({
@@ -3977,7 +3977,7 @@ function runAnnotationAttributionConformance(runner, opts) {
 				scope: SCOPE,
 				identity: ALICE$2
 			}, async (page) => {
-				const { annotation: created } = await page.annotations.create(SQUARE$1);
+				const { annotation: created } = await page.annotations.create(SQUARE$2);
 				await expectRefused(() => page.annotations.update(created.ref, { groupId: "finance" }), "set-group");
 				expect((await readBack(page, created.ref)).groupId).toBe("legal");
 			});
@@ -3986,7 +3986,7 @@ function runAnnotationAttributionConformance(runner, opts) {
 				identity: ALICE$2
 			};
 			await asSession(granted, async (page) => {
-				const { annotation: created } = await page.annotations.create(SQUARE$1);
+				const { annotation: created } = await page.annotations.create(SQUARE$2);
 				await page.annotations.update(created.ref, { groupId: "finance" });
 				expect((await readBack(page, created.ref)).groupId).toBe("finance");
 			});
@@ -4003,7 +4003,7 @@ function runAnnotationAttributionConformance(runner, opts) {
 				width: 30,
 				height: 30
 			};
-			const { annotation: square } = await page.annotations.create(SQUARE$1);
+			const { annotation: square } = await page.annotations.create(SQUARE$2);
 			const { annotation: note } = await page.annotations.create({
 				subtype: "text",
 				rect: iconRect(rect.x, rect.y)
@@ -4067,7 +4067,7 @@ function runAnnotationAttributionConformance(runner, opts) {
 				scope: READ,
 				identity: ALICE$2
 			}, async (page, doc) => {
-				const { annotation: created } = await page.annotations.create(SQUARE$1);
+				const { annotation: created } = await page.annotations.create(SQUARE$2);
 				const bundle = await doc.annotations.export({ refs: [created.ref] });
 				await expectRefused(() => doc.annotations.import(bundle), "doc.annotate.import");
 				const stamped = await doc.annotations.import(bundle, { attribution: "stamp" });
@@ -4088,7 +4088,7 @@ function runAnnotationAttributionConformance(runner, opts) {
 				],
 				identity: BOB$2
 			}, async (page, doc) => {
-				const { annotation: created } = await page.annotations.create(SQUARE$1);
+				const { annotation: created } = await page.annotations.create(SQUARE$2);
 				const bundle = await doc.annotations.export({ refs: [created.ref] });
 				const stamped = await doc.annotations.import(bundle, { attribution: "stamp" });
 				expect(attributionOf(stamped.annotations[0])).toMatchObject({ userId: "bob" });
@@ -8709,24 +8709,24 @@ function runPageRenderConformance(runner, opts) {
 					format: "png",
 					...options
 				});
-				const raster = await decode$2(image);
+				const raster = await decode$3(image);
 				expect([image.width, image.height]).toEqual(size);
 				expect([raster.width, raster.height]).toEqual(size);
 			}
 		});
 		test("a page image starts at the crop box", async () => {
-			const raster = await decode$2(await page.render.image({
+			const raster = await decode$3(await page.render.image({
 				format: "png",
 				viewport: {
 					kind: "scale",
 					scale: .5
 				}
 			}));
-			expect(isDark$1(pixel$1(raster, 75, 125))).toBe(true);
-			expect(isDark$1(pixel$1(raster, 25, 25))).toBe(false);
+			expect(isDark$2(pixel$2(raster, 75, 125))).toBe(true);
+			expect(isDark$2(pixel$2(raster, 25, 25))).toBe(false);
 		});
 		test("a target rect is in page space, from the crop box's top-left", async () => {
-			const square = await decode$2(await page.render.image({
+			const square = await decode$3(await page.render.image({
 				format: "png",
 				target: {
 					kind: "rect",
@@ -8738,8 +8738,8 @@ function runPageRenderConformance(runner, opts) {
 				}
 			}));
 			expect([square.width, square.height]).toEqual([10, 10]);
-			expect(everyPixel(square, isDark$1)).toBe(true);
-			const beside = await decode$2(await page.render.image({
+			expect(everyPixel(square, isDark$2)).toBe(true);
+			const beside = await decode$3(await page.render.image({
 				format: "png",
 				target: {
 					kind: "rect",
@@ -8755,7 +8755,7 @@ function runPageRenderConformance(runner, opts) {
 					scale: .1
 				}
 			}));
-			expect(everyPixel(beside, (rgba) => !isDark$1(rgba))).toBe(true);
+			expect(everyPixel(beside, (rgba) => !isDark$2(rgba))).toBe(true);
 		});
 		test("an appearance on a cropped page renders its own area", async () => {
 			const { annotation } = await page.annotations.create({
@@ -8771,8 +8771,8 @@ function runPageRenderConformance(runner, opts) {
 				const { x, y, width, height } = found.rect;
 				expect(Math.abs(x - SQUARE_ON_PAGE.x) <= 2 && Math.abs(y - SQUARE_ON_PAGE.y) <= 2).toBe(true);
 				expect(Math.abs(width - 100) <= 4 && Math.abs(height - 100) <= 4).toBe(true);
-				const raster = await decode$2(found.image);
-				const [r, g, b, a] = pixel$1(raster, raster.width >> 1, raster.height >> 1);
+				const raster = await decode$3(found.image);
+				const [r, g, b, a] = pixel$2(raster, raster.width >> 1, raster.height >> 1);
 				expect(r > 200 && g < 60 && b < 60 && a > 200).toBe(true);
 			} finally {
 				await page.annotations.delete(annotation.ref);
@@ -8831,17 +8831,17 @@ function runPageRenderConformance(runner, opts) {
 				const expected = require_calibrate.pageTransform(layout, options);
 				expect([expected.width, expected.height]).toEqual([image.width, image.height]);
 				expect(transform.matrix.every((n, i) => Math.abs(n - expected.matrix[i]) < 1e-9)).toBe(true);
-				const raster = await decode$2(image);
+				const raster = await decode$3(image);
 				const inside = transform.pageToPixels({
 					x: 150,
 					y: 250
 				});
-				expect(isDark$1(pixel$1(raster, Math.floor(inside.x), Math.floor(inside.y)))).toBe(true);
+				expect(isDark$2(pixel$2(raster, Math.floor(inside.x), Math.floor(inside.y)))).toBe(true);
 				const outside = transform.pageToPixels({
 					x: 70,
 					y: 250
 				});
-				expect(isDark$1(pixel$1(raster, Math.floor(outside.x), Math.floor(outside.y)))).toBe(false);
+				expect(isDark$2(pixel$2(raster, Math.floor(outside.x), Math.floor(outside.y)))).toBe(false);
 				const back = transform.pixelsToPage(inside);
 				expect(Math.abs(back.x - 150) < 1e-9 && Math.abs(back.y - 250) < 1e-9).toBe(true);
 			}
@@ -8899,10 +8899,10 @@ function runPageRenderConformance(runner, opts) {
 	});
 }
 /** The image's pixels, read the way an app would on either engine: through `blob()`. */
-async function decode$2(image) {
+async function decode$3(image) {
 	return decodePng(new Uint8Array(await (await image.blob()).arrayBuffer()));
 }
-function pixel$1(raster, x, y) {
+function pixel$2(raster, x, y) {
 	const at = (y * raster.width + x) * 4;
 	const { rgba } = raster;
 	return [
@@ -8912,14 +8912,507 @@ function pixel$1(raster, x, y) {
 		rgba[at + 3]
 	];
 }
-function isDark$1([r, g, b]) {
+function isDark$2([r, g, b]) {
 	return r < 60 && g < 60 && b < 60;
 }
 function everyPixel(raster, check) {
-	for (let y = 0; y < raster.height; y++) for (let x = 0; x < raster.width; x++) if (!check(pixel$1(raster, x, y))) return false;
+	for (let y = 0; y < raster.height; y++) for (let x = 0; x < raster.width; x++) if (!check(pixel$2(raster, x, y))) return false;
 	return true;
 }
 //#endregion
+//#region src/conformance/runPrintRenderConformance.ts
+const SQUARE$1 = "0 g 0 0 40 40 re f";
+const LAYERS = "/OC /OCp BDC 0 g 10 150 40 40 re f EMC\n/OC /OCv BDC 0 g 60 150 40 40 re f EMC";
+/** An annotation drawn as a black 40 × 40 square at `rect`, with the flags `f`. */
+const square$2 = (rect, f) => `<< /Type /Annot /Subtype /Square /Rect [${rect}] /F ${f} /C [0 0 0] /P 3 0 R /AP << /N 8 0 R >> >>`;
+/**
+* A 200 × 200 page with one black 40 × 40 square for each print rule, and an
+* A0 page (2384 × 3370) with nothing on it:
+*
+* - a layer that only prints, and one only shown on screen (`/Usage`
+*   `/PrintState` and `/ViewState`, as Acrobat's watermarks write them);
+* - four squares: one that only prints (`noView` + `print`), one only on
+*   screen (no `print`), one on both (`print`), one on neither (`hidden`);
+* - two form fields: a push button only on screen (Acrobat's "Visible but
+*   doesn't print") and a text field that only prints ("Hidden but
+*   printable").
+*/
+const PRINT_RULES_PDF = pdfOf([
+	"<< /Type /Catalog /Pages 2 0 R /AcroForm << /Fields [13 0 R 14 0 R] >> /OCProperties << /OCGs [6 0 R 7 0 R] /D << /ON [7 0 R] /OFF [6 0 R] /AS [<< /Event /Print /Category [/Print] /OCGs [6 0 R 7 0 R] >> << /Event /View /Category [/View] /OCGs [6 0 R 7 0 R] >>] >> >> >>",
+	"<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>",
+	"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 200 200] /Contents 5 0 R /Resources << /Properties << /OCp 6 0 R /OCv 7 0 R >> >> /Annots [9 0 R 10 0 R 11 0 R 12 0 R 13 0 R 14 0 R] >>",
+	"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 2384 3370] /Resources << >> >>",
+	`<< /Length 77 >>\nstream\n${LAYERS}\nendstream`,
+	"<< /Type /OCG /Name (Prints only) /Usage << /Print << /PrintState /ON >> /View << /ViewState /OFF >> >> >>",
+	"<< /Type /OCG /Name (Screen only) /Usage << /Print << /PrintState /OFF >> /View << /ViewState /ON >> >> >>",
+	`<< /Type /XObject /Subtype /Form /BBox [0 0 40 40] /Length 18 >>\nstream\n${SQUARE$1}\nendstream`,
+	square$2("10 90 50 130", 36),
+	square$2("60 90 100 130", 0),
+	square$2("110 90 150 130", 4),
+	square$2("150 90 190 130", 6),
+	"<< /Type /Annot /Subtype /Widget /FT /Btn /Ff 65536 /T (print) /Rect [10 30 50 70] /F 0 /P 3 0 R /AP << /N 8 0 R >> >>",
+	"<< /Type /Annot /Subtype /Widget /FT /Tx /T (stamp) /V (x) /Rect [60 30 100 70] /F 36 /P 3 0 R /AP << /N 8 0 R >> >>"
+]);
+/** The middle of each square in page space, and where it shows. */
+const SPOTS = {
+	layerPrintOnly: {
+		at: {
+			x: 30,
+			y: 30
+		},
+		display: false,
+		print: true
+	},
+	layerScreenOnly: {
+		at: {
+			x: 80,
+			y: 30
+		},
+		display: true,
+		print: false
+	},
+	annotationPrintOnly: {
+		at: {
+			x: 30,
+			y: 90
+		},
+		display: false,
+		print: true
+	},
+	annotationScreenOnly: {
+		at: {
+			x: 80,
+			y: 90
+		},
+		display: true,
+		print: false
+	},
+	annotationBoth: {
+		at: {
+			x: 130,
+			y: 90
+		},
+		display: true,
+		print: true
+	},
+	annotationHidden: {
+		at: {
+			x: 170,
+			y: 90
+		},
+		display: false,
+		print: false
+	},
+	fieldScreenOnly: {
+		at: {
+			x: 30,
+			y: 150
+		},
+		display: true,
+		print: false
+	},
+	fieldPrintOnly: {
+		at: {
+			x: 80,
+			y: 150
+		},
+		display: false,
+		print: true
+	}
+};
+const ANNOTATION_SPOTS = [
+	"annotationPrintOnly",
+	"annotationScreenOnly",
+	"annotationBoth",
+	"annotationHidden"
+];
+const FIELD_SPOTS = ["fieldScreenOnly", "fieldPrintOnly"];
+/** The rights each case opens with: everything, no print, print but not high. */
+const PRINT_SCOPES = {
+	everything: ["*"],
+	screen: [
+		"doc.open",
+		"doc.render",
+		"doc.annotate.read",
+		"doc.forms.read"
+	],
+	print: [
+		"doc.open",
+		"doc.render",
+		"doc.annotate.read",
+		"doc.forms.read",
+		"doc.print"
+	]
+};
+/**
+* Print pictures on both engines (`usage: 'print'` with a `dpi` viewport).
+* A print picture follows
+* the print rules where a screen picture follows the screen's: layers by
+* their print state, annotations and form fields by their `print` flag,
+* `noView` ones included, `hidden` ones never. It is the whole page at its
+* DPI, never more pixels than the page fitted to A4 or Letter needs, and its
+* transform is `pageTransform`'s. It needs `doc.print`, and 300 DPI
+* `doc.print.high`; options that don't fit a print picture are refused.
+*/
+function runPrintRenderConformance(runner, opts) {
+	const { describe, test, beforeAll, afterAll, expect } = runner;
+	describe(`print render conformance: ${opts.label}`, () => {
+		let engine;
+		let doc;
+		let small;
+		let large;
+		beforeAll(async () => {
+			engine = await opts.makeEngine();
+			doc = await opts.open(engine, PRINT_SCOPES.everything);
+			const { pages } = await doc.pages.list();
+			small = pages[0];
+			large = pages[1];
+		});
+		afterAll(async () => {
+			if (doc) await doc.close();
+			if (engine) await engine.destroy();
+		});
+		const as = async (scope, body) => {
+			const restricted = await opts.open(engine, scope);
+			try {
+				await body(restricted);
+			} finally {
+				await restricted.close();
+			}
+		};
+		/** Which spots are dark in a picture of the small page made with `options`. */
+		const darkSpots = (options) => darkSpotsOf(doc, small.ref, options);
+		test("a print picture is the whole page at its DPI, with pageTransform as its transform", async () => {
+			for (const dpi of [150, 300]) {
+				const options = print(dpi);
+				const image = await doc.page(small.ref).render.image({
+					format: "png",
+					...options
+				});
+				const size = Math.round(200 * dpi / 72);
+				expect([image.width, image.height]).toEqual([size, size]);
+				const raster = await decode$2(image);
+				expect([raster.width, raster.height]).toEqual([size, size]);
+				const expected = require_calibrate.pageTransform(small, options);
+				expect([expected.width, expected.height]).toEqual([size, size]);
+				expect(image.transform.matrix.every((n, i) => Math.abs(n - expected.matrix[i]) < 1e-9)).toBe(true);
+			}
+		});
+		test("a page bigger than the paper is printed at the size it has fitted to A4 or Letter", async () => {
+			const options = {
+				...print(150),
+				includeAnnotations: false,
+				includeFormFields: false
+			};
+			const image = await doc.page(large.ref).render.image({
+				format: "png",
+				...options
+			});
+			expect([image.width, image.height]).toEqual([1241, 1754]);
+			const expected = require_calibrate.pageTransform(large, options);
+			expect([expected.width, expected.height]).toEqual([1241, 1754]);
+		});
+		test("a screen picture follows the screen rules, a print picture the print rules", async () => {
+			const layers = {
+				includeAnnotations: true,
+				includeFormFields: true
+			};
+			const all = [...ANNOTATION_SPOTS, ...FIELD_SPOTS];
+			expect(await darkSpots(layers)).toEqual(shown("display", all));
+			expect(await darkSpots({
+				...layers,
+				...print(150)
+			})).toEqual(shown("print", all));
+		});
+		test("each print picture draws what its family draws", async () => {
+			const cases = [
+				{
+					layers: {
+						includeAnnotations: false,
+						includeFormFields: false
+					},
+					spots: []
+				},
+				{
+					layers: {
+						includeAnnotations: true,
+						includeFormFields: false
+					},
+					spots: ANNOTATION_SPOTS
+				},
+				{
+					layers: {
+						includeAnnotations: false,
+						includeFormFields: true
+					},
+					spots: FIELD_SPOTS
+				}
+			];
+			for (const { layers, spots } of cases) expect(await darkSpots({
+				...layers,
+				...print(300)
+			})).toEqual(shown("print", spots));
+		});
+		test("options that do not fit a print picture are refused", async () => {
+			const page = doc.page(small.ref);
+			const refused = [
+				{ usage: "print" },
+				{
+					usage: "print",
+					viewport: {
+						kind: "scale",
+						scale: 2
+					}
+				},
+				{
+					usage: "print",
+					viewport: {
+						kind: "width",
+						width: 400
+					}
+				},
+				{
+					usage: "print",
+					viewport: {
+						kind: "dpi",
+						dpi: 200
+					}
+				},
+				{ viewport: {
+					kind: "dpi",
+					dpi: 150
+				} },
+				{
+					usage: "display",
+					viewport: {
+						kind: "dpi",
+						dpi: 300
+					}
+				},
+				{
+					...print(150),
+					target: {
+						kind: "rect",
+						rect: {
+							x: 0,
+							y: 0,
+							width: 50,
+							height: 50
+						}
+					}
+				},
+				{
+					...print(150),
+					rotation: 90
+				},
+				{
+					...print(150),
+					background: "transparent"
+				}
+			];
+			for (const options of refused) await expect(page.render.image({
+				format: "png",
+				...options
+			})).rejects.toMatchObject({ code: require_format.EngineErrorCode.InvalidArg });
+		});
+		test("printing needs doc.print, and 300 DPI doc.print.high", async () => {
+			await as(PRINT_SCOPES.screen, async (screenOnly) => {
+				const page = screenOnly.page(small.ref);
+				const image = await page.render.image({ format: "png" });
+				expect([image.width, image.height]).toEqual([200, 200]);
+				await expect(page.render.image({
+					format: "png",
+					...print(150)
+				})).rejects.toMatchObject({ code: require_format.EngineErrorCode.Forbidden });
+			});
+			await as(PRINT_SCOPES.print, async (printOnly) => {
+				const page = printOnly.page(small.ref);
+				const image = await page.render.image({
+					format: "png",
+					...print(150)
+				});
+				expect((await decode$2(image)).width).toBe(417);
+				await expect(page.render.image({
+					format: "png",
+					...print(300)
+				})).rejects.toMatchObject({ code: require_format.EngineErrorCode.Forbidden });
+			});
+		});
+	});
+}
+function runPrintCopyConformance(runner, opts) {
+	const { describe, test, beforeAll, afterAll, expect } = runner;
+	describe(`print copy conformance: ${opts.label}`, () => {
+		let engine;
+		let doc;
+		let small;
+		beforeAll(async () => {
+			engine = await opts.makeEngine();
+			doc = await opts.open(engine, PRINT_SCOPES.everything);
+			small = (await doc.pages.list()).pages[0];
+		});
+		afterAll(async () => {
+			if (doc) await doc.close();
+			if (engine) await engine.destroy();
+		});
+		const as = async (scope, body) => {
+			const restricted = await opts.open(engine, scope);
+			try {
+				await body(restricted);
+			} finally {
+				await restricted.close();
+			}
+		};
+		/** The spots dark in a picture (made with `picture`) of the copy `options` makes. */
+		const copySpots = async (source, options, picture) => {
+			const bytes = await source.pages.extract([small.ref], options);
+			const copy = await opts.openCopy(engine, bytes);
+			try {
+				const { pages } = await copy.pages.list();
+				expect(pages).toHaveLength(1);
+				const page = pages[0];
+				const { annotations } = await copy.page(page.ref).annotations.list();
+				return {
+					dark: await darkSpotsOf(copy, page.ref, picture),
+					annotations: annotations.length
+				};
+			} finally {
+				await copy.close();
+			}
+		};
+		test("a print copy, printed, shows what a print picture shows, with nothing interactive left", async () => {
+			const before = (await doc.page(small.ref).annotations.list()).annotations.length;
+			const all = [...ANNOTATION_SPOTS, ...FIELD_SPOTS];
+			const printed = await copySpots(doc, { flatten: { usage: "print" } }, print(150));
+			expect(printed.dark).toEqual(shown("print", all));
+			expect(printed.annotations).toBe(0);
+			expect((await doc.page(small.ref).annotations.list()).annotations.length).toBe(before);
+		});
+		test("a display copy shows what a screen picture shows", async () => {
+			const all = [...ANNOTATION_SPOTS, ...FIELD_SPOTS];
+			const shownCopy = await copySpots(doc, { flatten: {} }, {});
+			expect(shownCopy.dark).toEqual(shown("display", all));
+			expect(shownCopy.annotations).toBe(0);
+		});
+		test("includeAnnotations and includeFormFields choose what a copy paints", async () => {
+			const cases = [
+				{
+					options: {
+						includeAnnotations: false,
+						includeFormFields: false
+					},
+					spots: []
+				},
+				{
+					options: {
+						includeAnnotations: true,
+						includeFormFields: false
+					},
+					spots: ANNOTATION_SPOTS
+				},
+				{
+					options: {
+						includeAnnotations: false,
+						includeFormFields: true
+					},
+					spots: FIELD_SPOTS
+				}
+			];
+			for (const { options, spots } of cases) {
+				const { dark } = await copySpots(doc, {
+					...options,
+					flatten: { usage: "print" }
+				}, print(150));
+				expect(dark).toEqual(shown("print", spots));
+			}
+		});
+		test("the include options take flatten", async () => {
+			for (const options of [{ includeAnnotations: false }, { includeFormFields: true }]) await expect(doc.pages.extract([small.ref], options)).rejects.toMatchObject({ code: require_format.EngineErrorCode.InvalidArg });
+		});
+		test("a flattened copy needs doc.download or doc.download.flattened, and paints what the caller may read", async () => {
+			const reads = [
+				"doc.open",
+				"doc.render",
+				"doc.annotate.read",
+				"doc.forms.read"
+			];
+			await as([...reads, "doc.download.flattened"], async (flattenedOnly) => {
+				await expect(flattenedOnly.pages.extract([small.ref])).rejects.toMatchObject({ code: require_format.EngineErrorCode.Forbidden });
+				const bytes = await flattenedOnly.pages.extract([small.ref], { flatten: { usage: "print" } });
+				expect(Array.from(bytes.slice(0, 4))).toEqual([
+					37,
+					80,
+					68,
+					70
+				]);
+			});
+			await as(reads, async (noDownload) => {
+				await expect(noDownload.pages.extract([small.ref], { flatten: { usage: "print" } })).rejects.toMatchObject({ code: require_format.EngineErrorCode.Forbidden });
+			});
+			await as([
+				"doc.open",
+				"doc.render",
+				"doc.forms.read",
+				"doc.download"
+			], async (noAnnotations) => {
+				await expect(noAnnotations.pages.extract([small.ref], {
+					flatten: { usage: "print" },
+					includeAnnotations: true
+				})).rejects.toMatchObject({ code: require_format.EngineErrorCode.Forbidden });
+				const { dark } = await copySpots(noAnnotations, { flatten: { usage: "print" } }, print(150));
+				expect(dark).toEqual(shown("print", FIELD_SPOTS));
+			});
+		});
+	});
+}
+/** Which spots are dark in a picture of `ref` made with `options`. */
+async function darkSpotsOf(doc, ref, options) {
+	const image = await doc.page(ref).render.image({
+		format: "png",
+		...options
+	});
+	const raster = await decode$2(image);
+	const dark = {};
+	for (const spot of Object.keys(SPOTS)) {
+		const { x, y } = image.transform.pageToPixels(SPOTS[spot].at);
+		dark[spot] = isDark$1(pixel$1(raster, Math.floor(x), Math.floor(y)));
+	}
+	return dark;
+}
+/** The spots `usage` shows when a picture draws the layers and `spots`. */
+function shown(usage, spots = []) {
+	const expected = {};
+	for (const spot of Object.keys(SPOTS)) expected[spot] = (spot === "layerPrintOnly" || spot === "layerScreenOnly" || spots.includes(spot)) && SPOTS[spot][usage];
+	return expected;
+}
+/** The options of a print picture at `dpi`. */
+function print(dpi) {
+	return {
+		usage: "print",
+		viewport: {
+			kind: "dpi",
+			dpi
+		}
+	};
+}
+/** The image's pixels, read the way an app would on either engine: through `blob()`. */
+async function decode$2(image) {
+	return decodePng(new Uint8Array(await (await image.blob()).arrayBuffer()));
+}
+function pixel$1(raster, x, y) {
+	const at = (y * raster.width + x) * 4;
+	const { rgba } = raster;
+	return [
+		rgba[at],
+		rgba[at + 1],
+		rgba[at + 2],
+		rgba[at + 3]
+	];
+}
+function isDark$1([r, g, b]) {
+	return r < 60 && g < 60 && b < 60;
+}
+//#endregion
 //#region src/conformance/pageSpaceFixtures.ts
 const rect = (left, bottom, right, top) => ({
 	left,
@@ -11502,17 +11995,17 @@ async function openFixture$8(engine, opts) {
 * Attachment conformance suite. Fixture requirement: a document whose
 * `/EmbeddedFiles` name tree contains at least one embedded file.
 *
-* Both attachment surfaces are optional on the contract (the
-* `downloadLayer?` pattern), probed independently and skipped cleanly:
-*   - `doc.attachments?` — document-level EmbeddedFiles (list/download)
-*   - `page.annotations.downloadResource(ref, 'file')` — annotation-level file bytes
+* Both homes of a file: `doc.attachments` (the `/EmbeddedFiles` name tree)
+* and a file-attachment annotation's `file` resource
+* (`page.annotations.downloadResource(ref, 'file')`). Both downloads answer
+* the bytes; the name and type are what the listing says.
 *
 * Invariants:
 *   1. `list()` reflects the name tree: positional indices, non-empty
 *      names, and repeated calls agree (a read).
-*   2. `download(index)` round-trips the listed metadata and returns
-*      exactly `size` decoded bytes when the fixture declares one.
-*   3. Unknown indices reject with an `EngineError`.
+*   2. `download(ref)` returns exactly `size` decoded bytes when the
+*      fixture declares one.
+*   3. Unknown keys reject with an `EngineError`.
 *   4. A created file-attachment annotation round-trips its file:
 *      metadata inline on the DTO (never bytes), bytes byte-identical
 *      as its `file` resource.
@@ -11522,22 +12015,17 @@ function runAttachmentConformance(runner, opts) {
 	const { describe, test, beforeAll, afterAll, expect } = runner;
 	describe(`attachment conformance: ${opts.label}`, () => {
 		let engine;
-		let docSupported = false;
-		let annotSupported = false;
 		let firstPageObjectNumber;
 		beforeAll(async () => {
 			engine = await opts.makeEngine();
 			const probe = await openFixture(engine, opts);
-			docSupported = probe.attachments !== void 0;
 			firstPageObjectNumber = (await probe.pages.list()).pages[0].ref.objectNumber;
-			annotSupported = probe.page(require_format.toPageRef(firstPageObjectNumber)).annotations.downloadResource !== void 0;
 			await probe.close();
 		});
 		afterAll(async () => {
 			if (engine) await engine.destroy();
 		});
 		test("attachments.list() reflects the /EmbeddedFiles name tree and is a stable read", async () => {
-			if (!docSupported) return;
 			const doc = await openFixture(engine, opts);
 			try {
 				const list = await doc.attachments.list();
@@ -11555,23 +12043,20 @@ function runAttachmentConformance(runner, opts) {
 				await doc.close();
 			}
 		});
-		test("attachments.download() round-trips the listed metadata and decoded size", async () => {
-			if (!docSupported) return;
+		test("attachments.download() returns the listed decoded size", async () => {
 			const doc = await openFixture(engine, opts);
 			try {
 				const { attachments } = await doc.attachments.list();
 				for (const item of attachments) {
-					const content = await doc.attachments.download(item.ref);
-					expect(content.name).toBe(item.name);
-					if (item.mimeType !== null) expect(content.mimeType).toBe(item.mimeType);
-					if (item.size !== null) expect(content.bytes.length).toBe(item.size);
+					const bytes = await doc.attachments.download(item.ref);
+					expect(bytes).toBeInstanceOf(Uint8Array);
+					if (item.size !== null) expect(bytes.length).toBe(item.size);
 				}
 			} finally {
 				await doc.close();
 			}
 		});
 		test("attachments.download() rejects an unknown key", async () => {
-			if (!docSupported) return;
 			const doc = await openFixture(engine, opts);
 			try {
 				await expect(doc.attachments.download(require_calibrate.toAttachmentRef("conformance-no-such-key.bin"))).rejects.toBeInstanceOf(require_format.EngineError);
@@ -11580,7 +12065,6 @@ function runAttachmentConformance(runner, opts) {
 			}
 		});
 		test("a File brings its name and type, and a file without a type has none", async () => {
-			if (!docSupported) return;
 			const doc = await openFixture(engine, opts);
 			try {
 				const picked = new File([new Uint8Array([
@@ -11600,15 +12084,15 @@ function runAttachmentConformance(runner, opts) {
 					name: "0-untyped.bin"
 				});
 				expect(untyped.mimeType).toBe(null);
-				expect((await doc.attachments.download(untyped.ref)).mimeType).toBe(null);
-				expect((await doc.attachments.download(fromFile.ref)).mimeType).toBe("text/csv");
+				const listed = (await doc.attachments.list()).attachments;
+				expect(listed.find((item) => item.ref.key === "0-untyped.bin")?.mimeType).toBe(null);
+				expect(listed.find((item) => item.ref.key === "0-picked.csv")?.mimeType).toBe("text/csv");
 				await expect(doc.attachments.create({ data: new Uint8Array([7]) })).rejects.toMatchObject({ code: require_format.EngineErrorCode.InvalidArg });
 			} finally {
 				await doc.close();
 			}
 		});
 		test("create() and delete() round-trip the name tree; keys survive index shifts", async () => {
-			if (!docSupported) return;
 			const doc = await openFixture(engine, opts);
 			try {
 				const { attachments: before } = await doc.attachments.list();
@@ -11638,9 +12122,9 @@ function runAttachmentConformance(runner, opts) {
 					data,
 					name: "0-conformance.bin"
 				})).rejects.toBeInstanceOf(require_format.EngineError);
-				const content = await doc.attachments.download(created.ref);
-				expect(content.bytes.length).toBe(data.length);
-				expect(content.bytes.every((byte, i) => byte === data[i])).toBe(true);
+				const bytes = await doc.attachments.download(created.ref);
+				expect(bytes.length).toBe(data.length);
+				expect(bytes.every((byte, i) => byte === data[i])).toBe(true);
 				const removed = await doc.attachments.delete(created.ref);
 				expect(Object.keys(removed)).toEqual(["meta"]);
 				expect(require_Change.deletedAttachmentOf(removed)).toEqual(created.ref);
@@ -11652,7 +12136,6 @@ function runAttachmentConformance(runner, opts) {
 			}
 		});
 		test("a file-attachment annotation takes a File as it is, and never guesses a type", async () => {
-			if (!annotSupported) return;
 			const doc = await openFixture(engine, opts);
 			try {
 				const annotations = doc.page(require_format.toPageRef(firstPageObjectNumber)).annotations;
@@ -11692,7 +12175,6 @@ function runAttachmentConformance(runner, opts) {
 			}
 		});
 		test("a created file-attachment annotation round-trips its file as its file resource", async () => {
-			if (!annotSupported) return;
 			const doc = await openFixture(engine, opts);
 			try {
 				const annotations = doc.page(require_format.toPageRef(firstPageObjectNumber)).annotations;
@@ -11744,7 +12226,6 @@ function runAttachmentConformance(runner, opts) {
 			}
 		});
 		test("a created text annotation round-trips icon, color, and contents", async () => {
-			if (!annotSupported) return;
 			const doc = await openFixture(engine, opts);
 			try {
 				const annotations = doc.page(require_format.toPageRef(firstPageObjectNumber)).annotations;
@@ -12420,6 +12901,46 @@ const box$2 = (x, y = 120) => ({
 	width: 40,
 	height: 30
 });
+/** A new outline item at `objectNumber`, last under `parent` (a number; the top level without one). */
+const outlineItem = (objectNumber, title, parent) => ({
+	type: "outline.create",
+	parent: parent === void 0 ? null : require_calibrate.toOutlineItemRef(parent),
+	data: {
+		title,
+		target: {
+			kind: "goto",
+			destination: {
+				kind: "fit",
+				page: PAGE$4
+			}
+		}
+	},
+	...objectNumber === void 0 ? {} : { objectNumber }
+});
+/** The bytes of a file to embed. */
+const NOTES = new TextEncoder().encode("Notes for the change conformance.");
+const NOTES_REF = require_calibrate.toAttachmentRef("notes.txt");
+/** `notes.txt` embedded in the document, with `bytes`. */
+const embedNotes = (bytes = NOTES) => ({
+	type: "attachments.create",
+	file: {
+		name: "notes.txt",
+		mimeType: "text/plain",
+		description: "Meeting notes"
+	},
+	resources: { file: bytes }
+});
+/** A saved PDF as text, one character per byte. */
+const latin1 = (bytes) => new TextDecoder("latin1").decode(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes));
+/** The `/Count` of object `objectNumber` in a saved PDF, as its last version writes it. */
+const countIn = (pdf, objectNumber) => {
+	const versions = [...pdf.matchAll(new RegExp(`(?:^|[\\r\\n])${objectNumber} 0 obj`, "g"))];
+	const last = versions[versions.length - 1];
+	if (!last) return null;
+	const body = pdf.slice(last.index, pdf.indexOf("endobj", last.index));
+	const count = /\/Count (-?\d+)/.exec(body);
+	return count ? Number(count[1]) : null;
+};
 /**
 * A round trip for every op type. Keyed by the type, so a new op without one
 * doesn't compile: every op must have an exact reverse.
@@ -12674,7 +13195,88 @@ const ROUND_TRIPS = {
 	"metadata.updateCustom": { ops: () => [{
 		type: "metadata.updateCustom",
 		patch: { project: "apply" }
-	}] }
+	}] },
+	"outline.create": { ops: ([item]) => [outlineItem(item, "Chapter")] },
+	"outline.update": {
+		setup: ([item]) => [outlineItem(item, "Chapter")],
+		ops: ([item]) => [{
+			type: "outline.update",
+			ref: require_calibrate.toOutlineItemRef(item),
+			patch: {
+				title: "Renamed",
+				color: "#e11d48",
+				bold: true,
+				target: {
+					kind: "uri",
+					uri: "https://example.com/"
+				}
+			}
+		}]
+	},
+	"outline.move": {
+		setup: ([first, second, child]) => [
+			outlineItem(first, "First"),
+			outlineItem(second, "Second"),
+			outlineItem(child, "Child", first)
+		],
+		ops: ([, second, child]) => [{
+			type: "outline.move",
+			refs: [require_calibrate.toOutlineItemRef(child)],
+			parent: require_calibrate.toOutlineItemRef(second),
+			position: "end"
+		}]
+	},
+	"outline.delete": {
+		setup: ([parent, child]) => [
+			outlineItem(parent, "Parent"),
+			outlineItem(child, "Child", parent),
+			{
+				type: "outline.update",
+				ref: require_calibrate.toOutlineItemRef(parent),
+				patch: { open: true }
+			}
+		],
+		ops: ([parent]) => [{
+			type: "outline.delete",
+			ref: require_calibrate.toOutlineItemRef(parent)
+		}]
+	},
+	"pages.rotate": { ops: () => [{
+		type: "pages.rotate",
+		pages: [PAGE$4, EMPTY_PAGE],
+		rotation: 90
+	}] },
+	"pages.reorder": { ops: () => [{
+		type: "pages.reorder",
+		pages: [EMPTY_PAGE],
+		position: "start"
+	}] },
+	"pages.delete": { ops: () => [{
+		type: "pages.delete",
+		pages: [PAGE$4]
+	}] },
+	"pages.insertBlank": { ops: ([page]) => [{
+		type: "pages.insertBlank",
+		spec: { size: {
+			width: 300,
+			height: 300
+		} },
+		position: { after: PAGE$4 },
+		objectNumbers: [page]
+	}] },
+	"pages.insert": { ops: () => [{
+		type: "pages.insert",
+		source: SIGNATURE_ARTWORK_PDF,
+		position: "start"
+	}] },
+	"attachments.create": { ops: () => [embedNotes()] },
+	"attachments.delete": {
+		setup: () => [embedNotes()],
+		ops: () => [{
+			type: "attachments.delete",
+			ref: NOTES_REF
+		}]
+	}
 };
 /**
 * `doc.apply`, one user action as one change:
@@ -12717,15 +13319,18 @@ function runChangeConformance(runner, opts) {
 		};
 		/** Everything a change can write, as the document reads it. */
 		const factsOf = async (doc) => {
-			const [onPage, onEmptyPage, form, metadata, custom] = await Promise.all([
-				doc.page(PAGE$4).annotations.list(),
-				doc.page(EMPTY_PAGE).annotations.list(),
+			const pages = await doc.pages.list();
+			const [annotations, form, metadata, custom, outline, attachments] = await Promise.all([
+				Promise.all(pages.pages.map((page) => doc.page(page.ref).annotations.list())),
 				doc.forms.list(),
 				doc.metadata.get(),
-				doc.metadata.custom.get()
+				doc.metadata.custom.get(),
+				doc.outline.get(),
+				doc.attachments.list()
 			]);
 			return {
-				annotations: [onPage.annotations, onEmptyPage.annotations],
+				pages,
+				annotations: annotations.map((list) => list.annotations),
 				fields: form.fields,
 				widgets: form.widgets,
 				calculationOrder: form.calculationOrder,
@@ -12733,7 +13338,9 @@ function runChangeConformance(runner, opts) {
 					title: metadata.title,
 					subject: metadata.subject
 				},
-				custom
+				custom,
+				outline,
+				attachments: attachments.attachments
 			};
 		};
 		const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
@@ -13115,14 +13722,406 @@ function runChangeConformance(runner, opts) {
 				expect(await colorOf(doc, FILE_SQUARE)).toBe("#e11d48");
 			});
 		});
-		test("undoing a change twice is harmless", async () => {
+		const pageOrderOf = async (doc) => (await doc.pages.list()).pages.map((page) => page.ref);
+		const blankPage = (objectNumber) => ({
+			type: "pages.insertBlank",
+			spec: { size: {
+				width: 300,
+				height: 300
+			} },
+			objectNumbers: [objectNumber]
+		});
+		test("the undo of a page insert is skipped when someone annotated the page since", async () => {
 			await withDocument(async (doc) => {
-				const before = await factsOf(doc);
-				const mine = await doc.apply({ ops: [{
-					type: "forms.setValue",
-					field: NAME$3,
-					value: { value: "Bea" }
-				}] });
+				const [page, square] = await take(doc, 2);
+				const inserted = await doc.apply({ ops: [blankPage(page)] });
+				const added = require_format.toPageRef(page);
+				await doc.apply({ ops: [{
+					type: "annotations.create",
+					page: added,
+					data: {
+						subtype: "square",
+						box: box$2(20)
+					},
+					objectNumber: square
+				}] });
+				const undo = await doc.apply({ undoOf: inserted.meta.opId });
+				expect(require_Change.isSkippedItem(itemOfType(undo, "pages.delete"))).toBe(true);
+				expect(await pageOrderOf(doc)).toEqual([
+					PAGE$4,
+					EMPTY_PAGE,
+					added
+				]);
+			});
+		});
+		test("the undo of a page insert still applies after pages moved around it", async () => {
+			await withDocument(async (doc) => {
+				const [page] = await take(doc, 1);
+				const inserted = await doc.apply({ ops: [blankPage(page)] });
+				await doc.apply({ ops: [{
+					type: "pages.reorder",
+					pages: [EMPTY_PAGE],
+					position: "end"
+				}] });
+				const undo = await doc.apply({ undoOf: inserted.meta.opId });
+				expect(appliedOfType(undo, "pages.delete").pages).toEqual([require_format.toPageRef(page)]);
+				expect(await pageOrderOf(doc)).toEqual([PAGE$4, EMPTY_PAGE]);
+			});
+		});
+		test("the undo of a page move leaves a page someone moved since", async () => {
+			await withDocument(async (doc) => {
+				const moved = await doc.apply({ ops: [{
+					type: "pages.reorder",
+					pages: [EMPTY_PAGE],
+					position: "start"
+				}] });
+				await doc.apply({ ops: [{
+					type: "pages.reorder",
+					pages: [EMPTY_PAGE],
+					position: "end"
+				}] });
+				const undo = await doc.apply({ undoOf: moved.meta.opId });
+				expect(require_Change.isSkippedItem(itemOfType(undo, "pages.reorder"))).toBe(true);
+				expect(await pageOrderOf(doc)).toEqual([PAGE$4, EMPTY_PAGE]);
+			});
+		});
+		test("the undo of a page rotate leaves a page someone turned since", async () => {
+			await withDocument(async (doc) => {
+				const turned = await doc.apply({ ops: [{
+					type: "pages.rotate",
+					pages: [PAGE$4, EMPTY_PAGE],
+					rotation: 90
+				}] });
+				await doc.apply({ ops: [{
+					type: "pages.rotate",
+					pages: [EMPTY_PAGE],
+					rotation: 180
+				}] });
+				const undo = await doc.apply({ undoOf: turned.meta.opId });
+				expect(appliedOfType(undo, "pages.rotate").pages).toEqual([PAGE$4]);
+				const { pages } = await doc.pages.list();
+				expect(pages.map((page) => page.rotation)).toEqual([0, 180]);
+			});
+		});
+		test("a deleted page comes back at its place, with its name", async () => {
+			await withDocument(async (doc) => {
+				await doc.pages.setName({
+					name: "Appendix",
+					page: EMPTY_PAGE
+				});
+				await doc.apply({ ops: [{
+					type: "pages.reorder",
+					pages: [EMPTY_PAGE],
+					position: "start"
+				}] });
+				const deleted = await doc.apply({ ops: [{
+					type: "pages.delete",
+					pages: [EMPTY_PAGE]
+				}] });
+				expect((await doc.pages.list()).namedPages).toEqual([]);
+				const recorded = recordEvents(doc);
+				const undo = await doc.apply({ undoOf: deleted.meta.opId });
+				recorded.stop();
+				expect(appliedOfType(undo, "pages.restore").pages).toEqual([EMPTY_PAGE]);
+				expect(await pageOrderOf(doc)).toEqual([EMPTY_PAGE, PAGE$4]);
+				expect((await doc.pages.list()).namedPages).toEqual([{
+					name: "Appendix",
+					target: {
+						kind: "page",
+						page: EMPTY_PAGE
+					}
+				}]);
+				expect(recorded.events.map((event) => event.type)).toEqual(["pages.restored"]);
+			});
+		});
+		test("an op meets the pages as the ops before it in the change left them", async () => {
+			await withDocument(async (doc) => {
+				const deleted = await doc.apply({ ops: [{
+					type: "annotations.update",
+					ref: FILE_SQUARE,
+					patch: { color: "#e11d48" }
+				}, {
+					type: "pages.delete",
+					pages: [PAGE$4]
+				}] });
+				expect(deleted.items.map((item) => item.type)).toEqual(["annotations.update", "pages.delete"]);
+				expect(await pageOrderOf(doc)).toEqual([EMPTY_PAGE]);
+				const [page, square] = await take(doc, 2);
+				const added = require_format.toPageRef(page);
+				await doc.apply({ ops: [blankPage(page), {
+					type: "annotations.create",
+					page: added,
+					data: {
+						subtype: "square",
+						box: box$2(20)
+					},
+					objectNumber: square
+				}] });
+				const { annotations } = await doc.page(added).annotations.list();
+				expect(annotations.map((annotation) => annotation.ref)).toEqual([at(square, added)]);
+			});
+		});
+		test("the undo of a page insert applies after the page was turned and turned back", async () => {
+			await withDocument(async (doc) => {
+				const inserted = await doc.apply({ ops: [{
+					type: "pages.insert",
+					source: SIGNATURE_ARTWORK_PDF,
+					position: "end"
+				}] });
+				const [added] = appliedOfType(inserted, "pages.insert").insertedPages;
+				const turned = await doc.apply({ ops: [{
+					type: "pages.rotate",
+					pages: [added],
+					rotation: 90
+				}] });
+				await doc.apply({ undoOf: turned.meta.opId });
+				const undo = await doc.apply({ undoOf: inserted.meta.opId });
+				expect(appliedOfType(undo, "pages.delete").pages).toEqual([added]);
+				expect(await pageOrderOf(doc)).toEqual([PAGE$4, EMPTY_PAGE]);
+			});
+		});
+		test("the undo of a page insert is skipped when someone turned the page since", async () => {
+			await withDocument(async (doc) => {
+				const inserted = await doc.apply({ ops: [{
+					type: "pages.insert",
+					source: SIGNATURE_ARTWORK_PDF,
+					position: "end"
+				}] });
+				const [added] = appliedOfType(inserted, "pages.insert").insertedPages;
+				await doc.apply({ ops: [{
+					type: "pages.rotate",
+					pages: [added],
+					rotation: 90
+				}] });
+				const undo = await doc.apply({ undoOf: inserted.meta.opId });
+				expect(require_Change.isSkippedItem(itemOfType(undo, "pages.delete"))).toBe(true);
+				expect(await pageOrderOf(doc)).toEqual([
+					PAGE$4,
+					EMPTY_PAGE,
+					added
+				]);
+			});
+		});
+		test("a page op naming no pages is refused", async () => {
+			await withDocument(async (doc) => {
+				for (const op of [
+					{
+						type: "pages.rotate",
+						pages: [],
+						rotation: 90
+					},
+					{
+						type: "pages.delete",
+						pages: []
+					},
+					{
+						type: "pages.reorder",
+						pages: [],
+						position: "start"
+					}
+				]) await expect(doc.apply({ ops: [op] })).rejects.toMatchObject({ code: require_format.EngineErrorCode.InvalidArg });
+				expect(await pageOrderOf(doc)).toEqual([PAGE$4, EMPTY_PAGE]);
+			});
+		});
+		test("the undo of opening an item counts the items above it again", async () => {
+			await withDocument(async (doc) => {
+				const [parent, child, grandchild] = await take(doc, 3);
+				await doc.apply({ ops: [
+					outlineItem(parent, "Parent"),
+					outlineItem(child, "Child", parent),
+					outlineItem(grandchild, "Grandchild", child),
+					{
+						type: "outline.update",
+						ref: require_calibrate.toOutlineItemRef(parent),
+						patch: { open: true }
+					}
+				] });
+				const opened = await doc.apply({ ops: [{
+					type: "outline.update",
+					ref: require_calibrate.toOutlineItemRef(child),
+					patch: { open: true }
+				}] });
+				expect(countIn(latin1(await doc.download()), parent)).toBe(2);
+				await doc.apply({ undoOf: opened.meta.opId });
+				expect(countIn(latin1(await doc.download()), parent)).toBe(1);
+			});
+		});
+		test("the undo of a delete or a move that emptied an open item opens it again", async () => {
+			await withDocument(async (doc) => {
+				const [parent, child] = await take(doc, 2);
+				await doc.apply({ ops: [
+					outlineItem(parent, "Parent"),
+					outlineItem(child, "Child", parent),
+					{
+						type: "outline.update",
+						ref: require_calibrate.toOutlineItemRef(parent),
+						patch: { open: true }
+					}
+				] });
+				const openOf = async (item) => (await doc.outline.get()).items.find((read) => read.ref.objectNumber === item)?.open;
+				const deleted = await doc.apply({ ops: [{
+					type: "outline.delete",
+					ref: require_calibrate.toOutlineItemRef(child)
+				}] });
+				expect(await openOf(parent)).toBe(false);
+				const undoDelete = await doc.apply({ undoOf: deleted.meta.opId });
+				expect(undoDelete.items.map((item) => item.type)).toEqual(["outline.restore", "outline.update"]);
+				expect(await openOf(parent)).toBe(true);
+				const moved = await doc.apply({ ops: [{
+					type: "outline.move",
+					refs: [require_calibrate.toOutlineItemRef(child)],
+					parent: null,
+					position: "end"
+				}] });
+				expect(await openOf(parent)).toBe(false);
+				await doc.apply({ undoOf: moved.meta.opId });
+				expect(await openOf(parent)).toBe(true);
+			});
+		});
+		test("the undo of an item made applies after the page it goes to was deleted", async () => {
+			await withDocument(async (doc) => {
+				const [item] = await take(doc, 1);
+				const created = await doc.apply({ ops: [{
+					type: "outline.create",
+					parent: null,
+					data: {
+						title: "Appendix",
+						target: {
+							kind: "goto",
+							destination: {
+								kind: "fit",
+								page: EMPTY_PAGE
+							}
+						}
+					},
+					objectNumber: item
+				}] });
+				await doc.apply({ ops: [{
+					type: "pages.delete",
+					pages: [EMPTY_PAGE]
+				}] });
+				const undo = await doc.apply({ undoOf: created.meta.opId });
+				expect(appliedOfType(undo, "outline.delete")).toBeTruthy();
+				expect((await doc.outline.get()).items).toEqual([]);
+			});
+		});
+		test("the undo of a new target leaves it when the old one goes to a page that is gone", async () => {
+			await withDocument(async (doc) => {
+				const [item] = await take(doc, 1);
+				const ref = require_calibrate.toOutlineItemRef(item);
+				await doc.apply({ ops: [outlineItem(item, "Chapter")] });
+				const retargeted = await doc.apply({ ops: [{
+					type: "outline.update",
+					ref,
+					patch: { target: {
+						kind: "goto",
+						destination: {
+							kind: "fit",
+							page: EMPTY_PAGE
+						}
+					} }
+				}] });
+				await doc.apply({ ops: [{
+					type: "outline.update",
+					ref,
+					patch: { title: "Renamed" }
+				}] });
+				await doc.apply({ ops: [{
+					type: "pages.delete",
+					pages: [PAGE$4]
+				}] });
+				const undo = await doc.apply({ undoOf: retargeted.meta.opId });
+				expect(require_Change.isSkippedItem(itemOfType(undo, "outline.update"))).toBe(true);
+				const [read] = (await doc.outline.get()).items;
+				expect(read?.target).toEqual({
+					kind: "goto",
+					destination: {
+						kind: "fit",
+						page: EMPTY_PAGE
+					}
+				});
+			});
+		});
+		test("no item is made under the deepest item a read shows", async () => {
+			await withDocument(async (doc) => {
+				const numbers = await take(doc, require_Change.OUTLINE_READ_LIMITS.depth);
+				await doc.apply({ ops: numbers.map((item, level) => outlineItem(item, `Level ${level}`, level ? numbers[level - 1] : void 0)) });
+				const deepest = require_calibrate.toOutlineItemRef(numbers[numbers.length - 1]);
+				await expect(doc.apply({ ops: [{
+					type: "outline.create",
+					parent: deepest,
+					data: { title: "Deeper" }
+				}] })).rejects.toMatchObject({ code: require_format.EngineErrorCode.InvalidArg });
+				const { items } = await doc.outline.get();
+				expect(items).toHaveLength(require_Change.OUTLINE_READ_LIMITS.depth);
+			});
+		});
+		test("a deleted file comes back with its bytes, its description and its dates", async () => {
+			await withDocument(async (doc) => {
+				await doc.apply({ ops: [embedNotes()] });
+				const [embedded] = (await doc.attachments.list()).attachments;
+				const deleted = await doc.apply({ ops: [{
+					type: "attachments.delete",
+					ref: NOTES_REF
+				}] });
+				expect((await doc.attachments.list()).attachments).toEqual([]);
+				const recorded = recordEvents(doc);
+				const undo = await doc.apply({ undoOf: deleted.meta.opId });
+				recorded.stop();
+				expect(appliedOfType(undo, "attachments.restore").attachment).toEqual(embedded);
+				expect((await doc.attachments.list()).attachments).toEqual([embedded]);
+				expect(await doc.attachments.download(NOTES_REF)).toEqual(NOTES);
+				expect(recorded.events.map((event) => event.type)).toEqual(["attachments.restored"]);
+			});
+		});
+		test("the undo of a file added is skipped when someone added another under its name", async () => {
+			await withDocument(async (doc) => {
+				const added = await doc.apply({ ops: [embedNotes()] });
+				const other = new TextEncoder().encode("Other notes.");
+				await doc.apply({ ops: [{
+					type: "attachments.delete",
+					ref: NOTES_REF
+				}] });
+				await doc.apply({ ops: [embedNotes(other)] });
+				const undo = await doc.apply({ undoOf: added.meta.opId });
+				expect(require_Change.isSkippedItem(itemOfType(undo, "attachments.delete"))).toBe(true);
+				expect(await doc.attachments.download(NOTES_REF)).toEqual(other);
+			});
+		});
+		test("the undo of a file removed is skipped when another file has its name", async () => {
+			await withDocument(async (doc) => {
+				await doc.apply({ ops: [embedNotes()] });
+				const deleted = await doc.apply({ ops: [{
+					type: "attachments.delete",
+					ref: NOTES_REF
+				}] });
+				const other = new TextEncoder().encode("Other notes.");
+				await doc.apply({ ops: [embedNotes(other)] });
+				const undo = await doc.apply({ undoOf: deleted.meta.opId });
+				expect(require_Change.isSkippedItem(itemOfType(undo, "attachments.restore"))).toBe(true);
+				expect((await doc.attachments.list()).attachments).toHaveLength(1);
+				expect(await doc.attachments.download(NOTES_REF)).toEqual(other);
+			});
+		});
+		test("a file whose name another file has is refused, and the change writes nothing", async () => {
+			await withDocument(async (doc) => {
+				await doc.apply({ ops: [embedNotes()] });
+				const before = await factsOf(doc);
+				await expect(doc.apply({ ops: [{
+					type: "metadata.update",
+					patch: { title: "Changed" }
+				}, embedNotes()] })).rejects.toMatchObject({ code: require_format.EngineErrorCode.InvalidArg });
+				expect(await factsOf(doc)).toEqual(before);
+			});
+		});
+		test("undoing a change twice is harmless", async () => {
+			await withDocument(async (doc) => {
+				const before = await factsOf(doc);
+				const mine = await doc.apply({ ops: [{
+					type: "forms.setValue",
+					field: NAME$3,
+					value: { value: "Bea" }
+				}] });
 				await doc.apply({ undoOf: mine.meta.opId });
 				const again = await doc.apply({ undoOf: mine.meta.opId });
 				expect(again.items.every(require_Change.isSkippedItem)).toBe(true);
@@ -13230,6 +14229,669 @@ function runChangeConformance(runner, opts) {
 				expect(await factsOf(doc)).toEqual(before);
 			});
 		});
+		test("adding and removing a file are one-op changes: their opIds undo them", async () => {
+			await withDocument(async (doc) => {
+				const before = await factsOf(doc);
+				const picked = new File([NOTES], "notes.txt", { type: "text/plain" });
+				const created = await doc.attachments.create({ data: picked });
+				expect(created.attachment.ref).toEqual(NOTES_REF);
+				expect(created.meta.undoable).toBe(true);
+				const withFile = await factsOf(doc);
+				const deleted = await doc.attachments.delete(NOTES_REF);
+				expect(deleted.meta.undoable).toBe(true);
+				await doc.apply({ undoOf: deleted.meta.opId });
+				expect(await factsOf(doc)).toEqual(withFile);
+				await doc.apply({ undoOf: created.meta.opId });
+				expect(await factsOf(doc)).toEqual(before);
+			});
+		});
+	});
+}
+//#endregion
+//#region src/conformance/runOutlineConformance.ts
+/**
+* Two pages of 300 × 300 and an outline, five items showing when it opens:
+*
+* - A (6), open: to page 3 at (20, 280) in the file; its child A1 (10) fits page 4.
+* - B (7): red and bold, a URI action.
+* - C (8), closed: the named destination `chapter-two` (page 4, `/FitH` 250);
+*   its child C1 (11) goes nowhere.
+* - D (9): a JavaScript action.
+*/
+const OUTLINE_FIXTURE_PDF = pdfOf([
+	"<< /Type /Catalog /Pages 2 0 R /Outlines 5 0 R /Names << /Dests 12 0 R >> >>",
+	"<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>",
+	"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 300] >>",
+	"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 300] >>",
+	"<< /Type /Outlines /First 6 0 R /Last 9 0 R /Count 5 >>",
+	"<< /Title (A) /Parent 5 0 R /Next 7 0 R /First 10 0 R /Last 10 0 R /Count 1 /Dest [3 0 R /XYZ 20 280 null] >>",
+	"<< /Title (B) /Parent 5 0 R /Prev 6 0 R /Next 8 0 R /C [1 0 0] /F 2 /A << /S /URI /URI (https://example.com/) >> >>",
+	"<< /Title (C) /Parent 5 0 R /Prev 7 0 R /Next 9 0 R /First 11 0 R /Last 11 0 R /Count -1 /Dest (chapter-two) >>",
+	"<< /Title (D) /Parent 5 0 R /Prev 8 0 R /A << /S /JavaScript /JS (app.alert\\(1\\)) >> >>",
+	"<< /Title (A1) /Parent 6 0 R /Dest [4 0 R /Fit] >>",
+	"<< /Title (C1) /Parent 8 0 R >>",
+	"<< /Names [(chapter-two) [4 0 R /FitH 250]] >>"
+]);
+/**
+* An outline a write never made: One (4) and Two (5), whose `/Next` comes
+* back to One, and after One a direct item no one can name.
+*/
+const BROKEN_OUTLINE_FIXTURE_PDF = pdfOf([
+	"<< /Type /Catalog /Pages 2 0 R /Outlines 3 0 R >>",
+	"<< /Type /Pages /Kids [6 0 R] /Count 1 >>",
+	"<< /Type /Outlines /First 4 0 R /Last 5 0 R /Count 2 >>",
+	"<< /Title (One) /Parent 3 0 R /Next 5 0 R /First << /Title (Direct) >> >>",
+	"<< /Title (Two) /Parent 3 0 R /Prev 4 0 R /Next 4 0 R >>",
+	"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 300] >>"
+]);
+/**
+* Targets stored every way files store them, on the same two pages:
+*
+* - Shared one (6) and Shared two (7): one action object (11), page 3 at
+*   (10, 290) in the file, which the link on page 3 (14) also uses.
+* - Hyperref (8): an action written into the item, going to the named
+*   destination `section.1` of the `/Names` tree (page 4 at (0, 200)).
+* - Old dests (9): the name `/chapter`, from the catalog's `/Dests`
+*   dictionary, written as `<< /D [...] >>` (page 4, `/FitH` 250).
+* - By number (10): a destination naming its page by index, 1 (page 4).
+*/
+const OUTLINE_TARGETS_FIXTURE_PDF = pdfOf([
+	"<< /Type /Catalog /Pages 2 0 R /Outlines 5 0 R /Names << /Dests 12 0 R >> /Dests 13 0 R >>",
+	"<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 >>",
+	"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 300] /Annots [14 0 R] >>",
+	"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 300] >>",
+	"<< /Type /Outlines /First 6 0 R /Last 10 0 R /Count 5 >>",
+	"<< /Title (Shared one) /Parent 5 0 R /Next 7 0 R /A 11 0 R >>",
+	"<< /Title (Shared two) /Parent 5 0 R /Prev 6 0 R /Next 8 0 R /A 11 0 R >>",
+	"<< /Title (Hyperref) /Parent 5 0 R /Prev 7 0 R /Next 9 0 R /A << /S /GoTo /D (section.1) >> >>",
+	"<< /Title (Old dests) /Parent 5 0 R /Prev 8 0 R /Next 10 0 R /Dest /chapter >>",
+	"<< /Title (By number) /Parent 5 0 R /Prev 9 0 R /Dest [1 /Fit] >>",
+	"<< /S /GoTo /D [3 0 R /XYZ 10 290 null] >>",
+	"<< /Names [(section.1) [4 0 R /XYZ 0 200 null]] >>",
+	"<< /chapter << /D [4 0 R /FitH 250] >> >>",
+	"<< /Type /Annot /Subtype /Link /Rect [0 0 50 50] /P 3 0 R /A 11 0 R >>"
+]);
+const A = require_calibrate.toOutlineItemRef(6);
+const B = require_calibrate.toOutlineItemRef(7);
+const C = require_calibrate.toOutlineItemRef(8);
+const D = require_calibrate.toOutlineItemRef(9);
+const A1 = require_calibrate.toOutlineItemRef(10);
+const C1 = require_calibrate.toOutlineItemRef(11);
+const FIRST_PAGE = require_format.toPageRef(3);
+const SECOND_PAGE = require_format.toPageRef(4);
+const SHARED_ONE = require_calibrate.toOutlineItemRef(6);
+const SHARED_TWO = require_calibrate.toOutlineItemRef(7);
+const HYPERREF = require_calibrate.toOutlineItemRef(8);
+const OLD_DESTS = require_calibrate.toOutlineItemRef(9);
+const BY_NUMBER = require_calibrate.toOutlineItemRef(10);
+const titles = (outline) => outline.items.map((item) => item.title);
+const numberOf = (ref) => ref?.objectNumber ?? null;
+const childrenOf = (outline, parent) => outline.items.filter((item) => numberOf(item.parent) === numberOf(parent)).map((item) => item.title);
+const itemOf = (outline, ref) => outline.items.find((item) => item.ref.objectNumber === ref.objectNumber);
+/** The children a write's orders give `parent`, by object number. */
+const orderOf = (orders, parent) => orders.find((order) => numberOf(order.parent) === numberOf(parent))?.children.map((ref) => ref.objectNumber);
+/** Where the document's one link goes. */
+const linkTargetOf = async (doc) => {
+	const link = (await doc.annotations.list()).annotations.find((annotation) => annotation.subtype === "link");
+	return link?.subtype === "link" ? link.target : void 0;
+};
+/**
+* The document's outline (`doc.outline`), the same on every engine:
+*
+* - A read lists every item depth first, with its parent, its target read the
+*   way a link's is (in page space, a named destination resolved), its `/A`
+*   tree, its colour and style, and whether it opens.
+* - Writes name items by object number and places by neighbour; moves keep
+*   subtrees and numbers; deletes take the items under an item with it, and
+*   an undo brings the same items back.
+* - Each write publishes its `outline.*` event; without `doc.outline.modify`
+*   every write is refused and reading still works.
+* - A target reads the same however the file stores it: written into the
+*   item or shared, named in the `/Names` tree or the old `/Dests`, a page
+*   by index. A new target or an undo never changes an action an item shares.
+* - A broken outline reads what it can and says `incomplete`.
+*/
+function runOutlineConformance(runner, opts) {
+	const { describe, test, beforeAll, afterAll, expect } = runner;
+	describe(`outline conformance: ${opts.label}`, () => {
+		let engine;
+		beforeAll(async () => {
+			engine = await opts.makeEngine();
+		});
+		afterAll(async () => {
+			if (engine) await engine.destroy();
+		});
+		const withOutline = async (body, bytes = OUTLINE_FIXTURE_PDF) => {
+			const doc = await opts.open(engine, bytes.slice());
+			try {
+				await body(doc);
+			} finally {
+				await doc.close();
+			}
+		};
+		test("reads every item depth first, with its target, its look and whether it opens", async () => {
+			await withOutline(async (doc) => {
+				const outline = await doc.outline.get();
+				expect(outline.incomplete).toBe(false);
+				expect(titles(outline)).toEqual([
+					"A",
+					"A1",
+					"B",
+					"C",
+					"C1",
+					"D"
+				]);
+				expect(itemOf(outline, A)).toMatchObject({
+					parent: null,
+					open: true,
+					color: null,
+					bold: false,
+					italic: false,
+					action: null,
+					target: {
+						kind: "goto",
+						destination: {
+							kind: "xyz",
+							page: FIRST_PAGE,
+							x: 20,
+							y: 20
+						}
+					}
+				});
+				expect(itemOf(outline, A1)).toMatchObject({
+					parent: A,
+					open: false,
+					target: {
+						kind: "goto",
+						destination: {
+							kind: "fit",
+							page: SECOND_PAGE
+						}
+					}
+				});
+				expect(itemOf(outline, B)).toMatchObject({
+					color: "#ff0000",
+					bold: true,
+					target: {
+						kind: "uri",
+						uri: "https://example.com/"
+					},
+					action: {
+						incomplete: false,
+						root: {
+							type: "uri",
+							uri: "https://example.com/"
+						}
+					}
+				});
+				expect(itemOf(outline, C)).toMatchObject({
+					open: false,
+					target: {
+						kind: "goto",
+						destination: {
+							kind: "fitH",
+							page: SECOND_PAGE,
+							y: 50
+						}
+					}
+				});
+				expect(itemOf(outline, C1)).toMatchObject({
+					parent: C,
+					target: null,
+					action: null
+				});
+				expect(itemOf(outline, D)).toMatchObject({
+					target: { kind: "javascript" },
+					action: { root: {
+						type: "javascript",
+						script: "app.alert(1)"
+					} }
+				});
+			});
+		});
+		test("a target reads the same however the file stores it", async () => {
+			await withOutline(async (doc) => {
+				const outline = await doc.outline.get();
+				expect(outline.incomplete).toBe(false);
+				const shared = {
+					kind: "goto",
+					destination: {
+						kind: "xyz",
+						page: FIRST_PAGE,
+						x: 10,
+						y: 10
+					}
+				};
+				expect(itemOf(outline, SHARED_ONE)).toMatchObject({
+					target: shared,
+					action: { root: { type: "goto" } }
+				});
+				expect(itemOf(outline, SHARED_TWO)).toMatchObject({ target: shared });
+				expect(await linkTargetOf(doc)).toMatchObject(shared);
+				expect(itemOf(outline, HYPERREF)).toMatchObject({
+					target: {
+						kind: "goto",
+						destination: {
+							kind: "xyz",
+							page: SECOND_PAGE,
+							x: 0,
+							y: 100
+						}
+					},
+					action: { root: { type: "goto" } }
+				});
+				expect(itemOf(outline, OLD_DESTS)).toMatchObject({
+					target: {
+						kind: "goto",
+						destination: {
+							kind: "fitH",
+							page: SECOND_PAGE,
+							y: 50
+						}
+					},
+					action: null
+				});
+				expect(itemOf(outline, BY_NUMBER)).toMatchObject({ target: {
+					kind: "goto",
+					destination: {
+						kind: "fit",
+						page: SECOND_PAGE
+					}
+				} });
+			}, OUTLINE_TARGETS_FIXTURE_PDF);
+		});
+		test("a new target leaves an action the item shared alone, and an undo brings it back", async () => {
+			await withOutline(async (doc) => {
+				const before = await doc.outline.get();
+				const link = await linkTargetOf(doc);
+				const changed = await doc.outline.update(SHARED_ONE, { target: {
+					kind: "uri",
+					uri: "https://example.com/"
+				} });
+				expect(changed.item.target).toEqual({
+					kind: "uri",
+					uri: "https://example.com/"
+				});
+				const after = await doc.outline.get();
+				expect(itemOf(after, SHARED_TWO)).toEqual(itemOf(before, SHARED_TWO));
+				expect(await linkTargetOf(doc)).toEqual(link);
+				await doc.apply({ undoOf: changed.meta.opId });
+				expect(await doc.outline.get()).toEqual(before);
+			}, OUTLINE_TARGETS_FIXTURE_PDF);
+		});
+		test("a delete and its undo keep a target however the file stored it", async () => {
+			await withOutline(async (doc) => {
+				const before = await doc.outline.get();
+				const link = await linkTargetOf(doc);
+				for (const ref of [
+					SHARED_TWO,
+					HYPERREF,
+					OLD_DESTS,
+					BY_NUMBER
+				]) {
+					const deleted = await doc.outline.delete(ref);
+					expect(itemOf(await doc.outline.get(), ref)).toBe(void 0);
+					await doc.apply({ undoOf: deleted.meta.opId });
+					expect(await doc.outline.get()).toEqual(before);
+				}
+				expect(await linkTargetOf(doc)).toEqual(link);
+			}, OUTLINE_TARGETS_FIXTURE_PDF);
+		});
+		test("a document without an outline reads an empty one", async () => {
+			const bytes = pdfOf([
+				"<< /Type /Catalog /Pages 2 0 R >>",
+				"<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+				"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 300] >>"
+			]);
+			await withOutline(async (doc) => {
+				expect(await doc.outline.get()).toEqual({
+					items: [],
+					incomplete: false
+				});
+				await doc.outline.create({ title: "First" });
+				expect(titles(await doc.outline.get())).toEqual(["First"]);
+			}, bytes);
+		});
+		test("a create goes to its place, under its parent, at the number it names", async () => {
+			await withOutline(async (doc) => {
+				await doc.objectNumbers.reserve(1);
+				const number = doc.objectNumbers.take();
+				const first = await doc.outline.create({
+					title: "A0",
+					target: {
+						kind: "goto",
+						destination: {
+							kind: "fit",
+							page: FIRST_PAGE
+						}
+					}
+				}, {
+					parent: A,
+					position: "start",
+					objectNumber: number
+				});
+				expect(first.item).toMatchObject({
+					ref: require_calibrate.toOutlineItemRef(number),
+					parent: A,
+					title: "A0"
+				});
+				expect(first.order).toEqual({
+					parent: A,
+					children: [require_calibrate.toOutlineItemRef(number), A1]
+				});
+				const after = await doc.outline.create({
+					title: "B2",
+					color: "#00ff00"
+				}, { position: { after: B } });
+				expect(after.order.parent).toBeNull();
+				expect(after.order.children.map((ref) => ref.objectNumber)).toEqual([
+					6,
+					7,
+					after.item.ref.objectNumber,
+					8,
+					9
+				]);
+				const outline = await doc.outline.get();
+				expect(titles(outline)).toEqual([
+					"A",
+					"A0",
+					"A1",
+					"B",
+					"B2",
+					"C",
+					"C1",
+					"D"
+				]);
+				expect(itemOf(outline, after.item.ref)).toMatchObject({
+					color: "#00ff00",
+					target: null
+				});
+			});
+		});
+		test("an update writes the fields it names and leaves the others", async () => {
+			await withOutline(async (doc) => {
+				const renamed = await doc.outline.update(B, {
+					title: "Bee",
+					italic: true
+				});
+				expect(renamed.item).toMatchObject({
+					title: "Bee",
+					italic: true,
+					bold: true,
+					color: "#ff0000",
+					target: { kind: "uri" }
+				});
+				const cleared = await doc.outline.update(B, {
+					color: null,
+					target: null,
+					bold: false
+				});
+				expect(cleared.item).toMatchObject({
+					color: null,
+					target: null,
+					bold: false,
+					italic: true
+				});
+				const retargeted = await doc.outline.update(C1, { target: {
+					kind: "goto",
+					destination: {
+						kind: "xyz",
+						page: SECOND_PAGE,
+						x: 10,
+						y: 40
+					}
+				} });
+				expect(retargeted.item.target).toMatchObject({
+					kind: "goto",
+					destination: {
+						kind: "xyz",
+						page: SECOND_PAGE,
+						x: 10,
+						y: 40
+					}
+				});
+				expect(retargeted.item.action).toMatchObject({ root: { type: "goto" } });
+			});
+		});
+		test("open takes effect on an item with children; a leaf has no open state", async () => {
+			await withOutline(async (doc) => {
+				expect((await doc.outline.update(C, { open: true })).item.open).toBe(true);
+				expect((await doc.outline.update(A, { open: false })).item.open).toBe(false);
+				expect((await doc.outline.update(D, { open: true })).item.open).toBe(false);
+			});
+		});
+		test("a write answers what the prediction rules say it leaves", async () => {
+			await withOutline(async (doc) => {
+				const drafts = [
+					{ title: "Plain" },
+					{
+						title: "To a spot",
+						target: {
+							kind: "goto",
+							destination: {
+								kind: "xyz",
+								page: SECOND_PAGE,
+								x: 10,
+								y: 40,
+								zoom: null
+							}
+						},
+						color: "#00AAFF",
+						bold: true
+					},
+					{
+						title: "To a site",
+						target: {
+							kind: "uri",
+							uri: "https://example.com/"
+						},
+						italic: true
+					},
+					{
+						title: "Next",
+						target: {
+							kind: "named",
+							name: "NextPage"
+						}
+					},
+					{
+						title: "Fit",
+						target: {
+							kind: "goto",
+							destination: {
+								kind: "fit",
+								page: FIRST_PAGE
+							}
+						}
+					}
+				];
+				for (const draft of drafts) {
+					const { item } = await doc.outline.create(draft, { parent: C });
+					expect(item).toEqual(require_Change.outlineItemOfDraft(item.ref, C, draft));
+				}
+				const before = itemOf(await doc.outline.get(), B);
+				const patches = [
+					{
+						title: "Bee",
+						italic: true
+					},
+					{ color: "#ABCDEF" },
+					{
+						color: null,
+						target: null,
+						bold: false
+					},
+					{ target: {
+						kind: "named",
+						name: "LastPage"
+					} },
+					{ open: true }
+				];
+				let current = before;
+				for (const patch of patches) {
+					const { item } = await doc.outline.update(B, patch);
+					expect(item).toEqual(require_Change.outlineItemAfter(current, patch, false));
+					current = item;
+				}
+				const parent = itemOf(await doc.outline.get(), C);
+				const { item: opened } = await doc.outline.update(C, { open: true });
+				expect(opened).toEqual(require_Change.outlineItemAfter(parent, { open: true }, true));
+			});
+		});
+		test("a move takes items together with the items under them, and names both parents", async () => {
+			await withOutline(async (doc) => {
+				const moved = await doc.outline.move([C, D], A, { after: A1 });
+				expect(moved.meta.changed).toEqual([C, D]);
+				expect(orderOf(moved.orders, null)).toEqual([6, 7]);
+				expect(orderOf(moved.orders, A)).toEqual([
+					10,
+					8,
+					9
+				]);
+				const outline = await doc.outline.get();
+				expect(titles(outline)).toEqual([
+					"A",
+					"A1",
+					"C",
+					"C1",
+					"D",
+					"B"
+				]);
+				expect(itemOf(outline, C)).toMatchObject({
+					parent: A,
+					open: false
+				});
+				expect(itemOf(outline, C1)).toMatchObject({ parent: C });
+				await doc.outline.move([C], null, "start");
+				expect(childrenOf(await doc.outline.get(), null)).toEqual([
+					"C",
+					"A",
+					"B"
+				]);
+			});
+		});
+		test("a move or a create that can not be made is refused", async () => {
+			await withOutline(async (doc) => {
+				const invalid = { code: require_format.EngineErrorCode.InvalidArg };
+				const notFound = { code: require_format.EngineErrorCode.NotFound };
+				await expect(doc.outline.move([A], A1, "end")).rejects.toMatchObject(invalid);
+				await expect(doc.outline.move([A], A, "end")).rejects.toMatchObject(invalid);
+				await expect(doc.outline.move([A, B], null, { after: B })).rejects.toMatchObject(invalid);
+				await expect(doc.outline.move([A, A], null, "end")).rejects.toMatchObject(invalid);
+				await expect(doc.outline.move([A, A1], null, "end")).rejects.toMatchObject(invalid);
+				await expect(doc.outline.move([A], null, { after: C1 })).rejects.toMatchObject(notFound);
+				await expect(doc.outline.move([require_calibrate.toOutlineItemRef(99)], null, "end")).rejects.toMatchObject(notFound);
+				await expect(doc.outline.create({ title: "x" }, { parent: require_calibrate.toOutlineItemRef(3) })).rejects.toMatchObject(notFound);
+				expect(titles(await doc.outline.get())).toEqual([
+					"A",
+					"A1",
+					"B",
+					"C",
+					"C1",
+					"D"
+				]);
+			});
+		});
+		test("a delete takes the items under the item, and an undo brings the same ones back", async () => {
+			await withOutline(async (doc) => {
+				const before = await doc.outline.get();
+				const deleted = await doc.outline.delete(C);
+				expect(deleted.meta.changed).toEqual([C, C1]);
+				expect(titles(await doc.outline.get())).toEqual([
+					"A",
+					"A1",
+					"B",
+					"D"
+				]);
+				const undo = await doc.apply({ undoOf: deleted.meta.opId });
+				expect(undo.items.map((item) => item.type)).toEqual(["outline.restore"]);
+				expect(await doc.outline.get()).toEqual(before);
+			});
+		});
+		test("expect refuses a change whose assumption does not hold", async () => {
+			await withOutline(async (doc) => {
+				await expect(doc.apply({ ops: [{
+					type: "outline.update",
+					ref: B,
+					patch: { title: "Bee" },
+					expect: { title: "Not B" }
+				}] })).rejects.toMatchObject({ code: require_format.EngineErrorCode.ChangeConflict });
+				expect(itemOf(await doc.outline.get(), B)?.title).toBe("B");
+			});
+		});
+		test("each write publishes its outline event, with its result", async () => {
+			await withOutline(async (doc) => {
+				const events = [];
+				const stop = doc.events.subscribe((event) => events.push(event));
+				let created;
+				try {
+					created = (await doc.outline.create({ title: "New" }, { parent: C })).item.ref;
+					await doc.outline.update(created, { title: "Newer" });
+					await doc.outline.move([created], null, "end");
+					await doc.outline.delete(created);
+				} finally {
+					stop();
+				}
+				const outline = events.filter((event) => event.type.startsWith("outline."));
+				expect(outline.map((event) => event.type)).toEqual([
+					"outline.created",
+					"outline.updated",
+					"outline.moved",
+					"outline.deleted"
+				]);
+				expect(outline[0]).toMatchObject({ item: {
+					title: "New",
+					parent: C
+				} });
+				expect(outline[1]).toMatchObject({ item: { title: "Newer" } });
+				expect(outline[2]).toMatchObject({ meta: { changed: [created] } });
+				expect(outline[3]).toMatchObject({ deleted: [created] });
+			});
+		});
+		test("without doc.outline.modify every write is refused; reading still works", async () => {
+			const doc = await opts.openReadOnly(engine, OUTLINE_FIXTURE_PDF.slice());
+			try {
+				expect(titles(await doc.outline.get())).toEqual([
+					"A",
+					"A1",
+					"B",
+					"C",
+					"C1",
+					"D"
+				]);
+				const denied = { code: require_format.EngineErrorCode.Forbidden };
+				await expect(doc.outline.create({ title: "x" })).rejects.toMatchObject(denied);
+				await expect(doc.outline.update(A, { title: "x" })).rejects.toMatchObject(denied);
+				await expect(doc.outline.move([A], null, "end")).rejects.toMatchObject(denied);
+				await expect(doc.outline.delete(A)).rejects.toMatchObject(denied);
+			} finally {
+				await doc.close();
+			}
+		});
+		test("an item whose page is gone keeps its place and goes nowhere it can be followed", async () => {
+			await withOutline(async (doc) => {
+				await doc.pages.delete([FIRST_PAGE]);
+				const outline = await doc.outline.get();
+				expect(titles(outline)).toEqual([
+					"A",
+					"A1",
+					"B",
+					"C",
+					"C1",
+					"D"
+				]);
+				expect(itemOf(outline, A)?.target).toEqual({ kind: "unsupported" });
+			});
+		});
+		test("a broken outline reads what it can and says incomplete", async () => {
+			await withOutline(async (doc) => {
+				const outline = await doc.outline.get();
+				expect(outline.incomplete).toBe(true);
+				expect(titles(outline)).toEqual(["One", "Two"]);
+				await doc.outline.update(require_calibrate.toOutlineItemRef(5), { title: "Second" });
+				expect(titles(await doc.outline.get())).toEqual(["One", "Second"]);
+			}, BROKEN_OUTLINE_FIXTURE_PDF);
+		});
 	});
 }
 //#endregion
@@ -19205,6 +20867,7 @@ function runFieldGroupsConformance(runner, opts) {
 //#endregion
 exports.APPEARANCE_STATES_FIXTURE_PDF = APPEARANCE_STATES_FIXTURE_PDF;
 exports.BARE_PAGE_FIXTURE_PDF = BARE_PAGE_FIXTURE_PDF;
+exports.BROKEN_OUTLINE_FIXTURE_PDF = BROKEN_OUTLINE_FIXTURE_PDF;
 exports.CHANGE_FIXTURE_PDF = CHANGE_FIXTURE_PDF;
 exports.COLOR_FIXTURE_PDF = COLOR_FIXTURE_PDF;
 exports.CROP_OFFSET_PDF = CROP_OFFSET_PDF;
@@ -19212,9 +20875,12 @@ exports.DRAWING_FIXTURE_PDF = DRAWING_FIXTURE_PDF;
 exports.FIELD_GROUPS_PDF = FIELD_GROUPS_PDF;
 exports.FIELD_GROUP_TOKENS = FIELD_GROUP_TOKENS;
 exports.OBJECT_NUMBER_FIXTURE_PDF = OBJECT_NUMBER_FIXTURE_PDF;
+exports.OUTLINE_FIXTURE_PDF = OUTLINE_FIXTURE_PDF;
 exports.PAGE_SPACE_FIXTURES = PAGE_SPACE_FIXTURES;
 exports.PERMISSION_TOKENS = PERMISSION_TOKENS;
 exports.PREDICTION_FIXTURE_PDF = PREDICTION_FIXTURE_PDF;
+exports.PRINT_RULES_PDF = PRINT_RULES_PDF;
+exports.PRINT_SCOPES = PRINT_SCOPES;
 exports.TEXT_DIVERGENCE_CASES = TEXT_DIVERGENCE_CASES;
 exports.TURNED_FIELDS_PDF = TURNED_FIELDS_PDF;
 exports.TWO_PAGES_PDF = TWO_PAGES_PDF;
@@ -19255,6 +20921,7 @@ exports.runMeasurementConformance = runMeasurementConformance;
 exports.runMetadataConformance = runMetadataConformance;
 exports.runNamedPagesConformance = runNamedPagesConformance;
 exports.runObjectNumberConformance = runObjectNumberConformance;
+exports.runOutlineConformance = runOutlineConformance;
 exports.runPageDeleteConformance = runPageDeleteConformance;
 exports.runPageExtractConformance = runPageExtractConformance;
 exports.runPageFlattenConformance = runPageFlattenConformance;
@@ -19268,6 +20935,8 @@ exports.runPageSpaceConformance = runPageSpaceConformance;
 exports.runPageTextConformance = runPageTextConformance;
 exports.runPermissionConformance = runPermissionConformance;
 exports.runPieceInfoConformance = runPieceInfoConformance;
+exports.runPrintCopyConformance = runPrintCopyConformance;
+exports.runPrintRenderConformance = runPrintRenderConformance;
 exports.runRedactionApplyConformance = runRedactionApplyConformance;
 exports.runSearchConformance = runSearchConformance;
 exports.runSignatureConformance = runSignatureConformance;