@stll/folio-core 0.54.2 → 0.56.0

package/dist/docx/rezip.js

@@ -1,13 +1,17 @@
 import { consumeTrackedSectionEndpointRemoval } from "../internal/sectionEndpointResolution.js";
 import { consumeSectionReferenceResolution } from "../internal/sectionReferenceResolution.js";
+import { CANONICAL_GAP } from "../types/canonicalCapabilities.js";
+import { canonicalJson } from "../utils/canonicalJson.js";
 import { isAllowedExternalWatermarkImageUrl } from "../watermark/index.js";
 import { appVersionInSchemaForm, normalizeAppVersionInExtendedProperties } from "./appVersionNormalization.js";
 import { withoutOrphanCommentRanges } from "./commentRangeIntegrity.js";
 import { applyReplyThreadMarkers } from "./commentReplyMarkers.js";
+import { registerContentTypeParts } from "./contentTypeRegistry.js";
 import { readDocumentSectionFacts } from "./documentSectionFacts.js";
 import { normalizeDrawingIds } from "./drawingIdNormalization.js";
 import { rebindDrawingImageRelationship } from "./drawingRelationships.js";
 import { parseEndnotes, parseFootnotes } from "./footnoteParser.js";
+import { getDocumentSourceBaseline } from "./headerFooterVerbatim.js";
 import { assertValidFolioDocumentModel } from "./modelValidation.js";
 import { isNewDataUrlDrawing } from "./newImage.js";
 import { missingNoteReferenceStyles, noteReferenceNeeds } from "./noteReferenceStyles.js";
@@ -15,11 +19,12 @@ import { parseNumbering } from "./numberingParser.js";
 import { paragraphNumberingReferenceId as paragraphNumberingReferenceId$1 } from "./numberingReference.js";
 import { isUnsafePackagePath, reconcilePackageReferences, removeUnsafeEntries } from "./packageParts.js";
 import { normalizeParaIdRangeInXmlParts } from "./paraIdRangeNormalization.js";
-import { BLOCK_TREE_DESCENT, visitBlockTreeRecords } from "./paragraphTraversal.js";
+import { cloneDocumentWithParagraphPropertySources, cloneParagraphWithPropertySource, copyDocumentParagraphPropertySourceContract } from "./paragraphPropertySource.js";
+import { BLOCK_TREE_DESCENT, visitBlockTreeRecords, visitInlineContentSlots, visitParagraphRuns } from "./paragraphTraversal.js";
 import { RELATIONSHIP_TYPES, parseRelationships, resolveRelativePath } from "./relsParser.js";
 import { removeResolvedHeaderFooterParts } from "./removeHeaderFooterParts.js";
 import { normalizeRevisionIdsInXmlParts } from "./revisionIdNormalization.js";
-import { buildPatchedNotePartXml, collectChangedNoteParaIds, collectParaIds, patchNumberingDefinitions } from "./selectiveXmlPatch.js";
+import { buildPatchedNotePartXml, collectChangedNoteParaIds, collectParaIds, patchNumberingDefinitions, spliceXml } from "./selectiveXmlPatch.js";
 import { planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
 import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeFontTableXml } from "./serializer/fontTableSerializer.js";
@@ -30,11 +35,16 @@ import { readRootNamespaceBindings, serializePartElement } from "./serializer/pa
 import { serializeSettingsXml } from "./serializer/settingsSerializer.js";
 import { serializeStyle, serializeStylesXml } from "./serializer/stylesSerializer.js";
 import { serializeThemeXml } from "./serializer/themeSerializer.js";
+import { updateEvenAndOddHeaders } from "./settingsHeaderFooterUpdate.js";
+import { parseSettings } from "./settingsParser.js";
+import { getXmlSourceRange, parseStreamingXmlWithSourceRanges } from "./streamingXmlParser.js";
+import { captureVerbatimXml } from "./verbatimCapture.js";
 import { hasCanonicalWordprocessingPrefixes } from "./wordprocessingPrefixes.js";
-import { WORDPROCESSINGML_NAMESPACE_URIS, findChild, findChildByNamespaceUri, findChildrenByNamespaceUri, getAttribute, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespaceUri, matchesName, parseXml, parseXmlDocument } from "./xmlParser.js";
-import { TaggedError, panic } from "better-result";
+import { OFFICE_RELATIONSHIP_NAMESPACE_URIS, OOXML_NAMESPACE_SCOPE, WORDPROCESSINGML_NAMESPACE_URIS, findAttributeByNamespaceUri, findChild, findChildByNamespaceUri, findChildrenByNamespaceUri, getAttribute, getAttributeByNamespaceUri, getChildElements, getLocalName, getNamespaceUri, matchesName, parseXml, parseXmlDocument } from "./xmlParser.js";
+import { Result, TaggedError, panic } from "better-result";
 import { assertValidOoxmlNumericIds, escapeXmlAttribute, escapeXmlText, validateDocxPackage } from "@stll/docx-core";
 import { mintRelationshipId } from "@stll/docx-core/model";
+import { writeZipPart } from "@stll/docx-core/zip";
 import JSZip from "jszip";
 //#region src/docx/rezip.ts
 /**
@@ -196,9 +206,14 @@ async function serializeCommentsToZip(doc, zip, compressionLevel) {
 	}
 	const plan = planCommentParts(comments);
 	const commentsXml = serializeComments(plan, sourceCommentsXml === void 0 ? void 0 : readRootNamespaceBindings(sourceCommentsXml));
-	zip.file(sourceCommentsFile?.name ?? "word/comments.xml", commentsXml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip,
+		path: sourceCommentsFile?.name ?? "word/comments.xml",
+		data: commentsXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 	await ensureCommentsContentType(zip, compressionLevel);
 	await ensureCommentsRelationship(zip, compressionLevel);
@@ -227,9 +242,14 @@ async function syncCommentsExtendedPart(plan, zip, compressionLevel) {
 		await transformPackagingFile(zip, "word/_rels/document.xml.rels", removeCommentsExtendedRelationship, compressionLevel);
 		return;
 	}
-	zip.file(existing?.name ?? "word/commentsExtended.xml", xml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip,
+		path: existing?.name ?? "word/commentsExtended.xml",
+		data: xml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 	await transformPackagingFile(zip, "[Content_Types].xml", addCommentsExtendedOverride, compressionLevel);
 	await transformPackagingFile(zip, "word/_rels/document.xml.rels", addCommentsExtendedRelationship, compressionLevel);
@@ -240,9 +260,14 @@ async function transformPackagingFile(zip, path, transform, compressionLevel) {
 	if (!file) return;
 	const xml = await file.async("text");
 	const next = transform(xml);
-	if (next !== xml) zip.file(path, next, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	if (next !== xml) writeZipPart({
+		zip,
+		path,
+		data: next,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 }
 function findZipEntryCaseInsensitive(zip, lowerPath) {
@@ -251,7 +276,9 @@ function findZipEntryCaseInsensitive(zip, lowerPath) {
 	for (const [path, file] of Object.entries(zip.files)) if (!file.dir && path.toLowerCase() === lowerPath) return file;
 	return null;
 }
-const EMPTY_RELS_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\"></Relationships>";
+const PACKAGE_RELATIONSHIPS_NAMESPACE_URI = "http://schemas.openxmlformats.org/package/2006/relationships";
+const EMPTY_RELS_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="${PACKAGE_RELATIONSHIPS_NAMESPACE_URI}"></Relationships>`;
 function headerFooterFilename(target) {
 	return target.startsWith("/") ? target.slice(1) : `word/${target}`;
 }
@@ -348,9 +375,14 @@ async function registerImageExtensions(zip, extensions, compressionLevel) {
 		changed = true;
 	}
 	if (!changed) return;
-	zip.file("[Content_Types].xml", ctXml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip,
+		path: "[Content_Types].xml",
+		data: ctXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 }
 function collectNewImages(blocks) {
@@ -421,9 +453,14 @@ async function processNewImages(parts, zip, compressionLevel) {
 			maxId++;
 			const mediaPath = `word/media/${`image${maxImageNum}.${extension}`}`;
 			const newRId = mintRelationshipId(maxId);
-			zip.file(mediaPath, data, {
-				compression: "DEFLATE",
-				compressionOptions: { level: compressionLevel }
+			writeZipPart({
+				zip,
+				path: mediaPath,
+				data,
+				options: {
+					compression: "DEFLATE",
+					compressionOptions: { level: compressionLevel }
+				}
 			});
 			relEntries.push(`<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.image}" Target="${escapeXmlAttribute(relativeTargetForPart(partPath, mediaPath))}"/>`);
 			extensionsAdded.add(extension);
@@ -434,13 +471,15 @@ async function processNewImages(parts, zip, compressionLevel) {
 			}) ?? panic("A detached drawing lost its embedded image relationship");
 			image.rId = newRId;
 		}
-		if (relEntries.length > 0) {
-			const updatedRelsXml = relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`);
-			zip.file(relsPath, updatedRelsXml, {
+		if (relEntries.length > 0) writeZipPart({
+			zip,
+			path: relsPath,
+			data: relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`),
+			options: {
 				compression: "DEFLATE",
 				compressionOptions: { level: compressionLevel }
-			});
-		}
+			}
+		});
 	}
 	await registerImageExtensions(zip, extensionsAdded, compressionLevel);
 }
@@ -452,67 +491,259 @@ const materializeEmbeddedMedia = async ({ document, zip, compressionLevel }) =>
 		if (isUnsafePackagePath(media.path) || !media.path.startsWith("word/media/")) panic("Detached media has an invalid package path");
 		const extension = media.path.split(".").at(-1)?.toLowerCase();
 		if (!extension || !/^[a-z0-9]+$/u.test(extension)) panic("Embedded media has an invalid extension");
-		zip.file(media.path, media.data, {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
+		writeZipPart({
+			zip,
+			path: media.path,
+			data: media.data,
+			options: {
+				compression: "DEFLATE",
+				compressionOptions: { level: compressionLevel }
+			}
 		});
 		extensions.add(extension);
 	}
 	await registerImageExtensions(zip, extensions, compressionLevel);
 };
-/**
-* Collect all hyperlinks that have an href but no rId from block content.
-* These are newly created hyperlinks that need relationship entries.
-*/
-function collectHyperlinksWithoutRId(blocks) {
-	const hyperlinks = [];
-	const collectInlineHyperlinks = (content) => {
-		for (const item of content) switch (item.type) {
-			case "hyperlink":
-				if (item.href && !item.rId && !item.anchor) hyperlinks.push(item);
-				break;
-			case "simpleField":
-			case "inlineSdt":
-			case "inlineWrapper":
-			case "insertion":
-			case "deletion":
-			case "moveFrom":
-			case "moveTo":
-				collectInlineHyperlinks(item.content);
-				break;
-			default: break;
+var CanonicalImageRelationshipRefusalError = class extends TaggedError("CanonicalImageRelationshipRefusalError") {};
+/** Publish allocated pictures into each owning story without rebinding canonical ids. */
+const publishCanonicalImageResources = async ({ document, zip, compressionLevel }) => {
+	const baseline = getDocumentSourceBaseline(document);
+	for (const { relsPath, blocks } of collectDocxParts(document, zip)) {
+		const images = [];
+		visitBlockTreeRecords(blocks, (record) => {
+			if (record.type !== "paragraph") return BLOCK_TREE_DESCENT.descend;
+			visitParagraphRuns(record, (run) => {
+				for (const content of run.content) if (content.type === "drawing" && content.image.rId !== void 0) images.push(content.image);
+			});
+			return BLOCK_TREE_DESCENT.descend;
+		});
+		if (images.length === 0) continue;
+		let xml = await readRelsOrStub(zip, relsPath);
+		const local = parseRelationships(xml);
+		const partPath = relsPath.replace("/_rels/", "/").replace(/\.rels$/u, "");
+		let changed = false;
+		for (const image of images) {
+			const id = image.rId;
+			if (id === void 0) continue;
+			const refuse = (reason, message) => {
+				throw new CanonicalImageRelationshipRefusalError({
+					message,
+					gap: CANONICAL_GAP.save,
+					part: relsPath,
+					relationshipId: id,
+					reason
+				});
+			};
+			const source = local.get(id);
+			const allocated = document.package.relationships?.get(id);
+			const allocatedMediaPath = allocated?.targetMode === "External" || allocated?.type !== RELATIONSHIP_TYPES.image ? void 0 : resolveRelativePath("word/_rels/document.xml.rels", allocated.target);
+			const allocatedMedia = allocatedMediaPath === void 0 ? void 0 : document.package.media?.get(allocatedMediaPath);
+			const newlyAllocated = allocated?.type === RELATIONSHIP_TYPES.image && (baseline.type !== "captured" || canonicalJson(allocated) !== canonicalJson(baseline.resourceRelationships?.get(id)));
+			const desired = relsPath === "word/_rels/document.xml.rels" || newlyAllocated || source === void 0 && image.src !== void 0 && (allocated?.targetMode === "External" ? image.src === allocated.target : image.src === allocatedMedia?.dataUrl) ? allocated : source;
+			if (desired?.type !== RELATIONSHIP_TYPES.image) return refuse("unresolved", "A canonical inline picture has no owning image relationship.");
+			const desiredRelsPath = desired === allocated ? "word/_rels/document.xml.rels" : relsPath;
+			const absolute = desired.targetMode === "External" ? void 0 : resolveRelativePath(desiredRelsPath, desired.target);
+			if (desired.targetMode === "External" && !isAllowedExternalWatermarkImageUrl(desired.target)) return refuse("unsafeTarget", "A canonical inline picture has an unsafe external target.");
+			if (absolute !== void 0 && isUnsafePackagePath(absolute)) return refuse("unsafeTarget", "A canonical inline picture has an unsafe media target.");
+			if (source) {
+				const sourceAbsolute = source.targetMode === "External" ? void 0 : resolveRelativePath(relsPath, source.target);
+				if (source.type !== RELATIONSHIP_TYPES.image || source.targetMode === "External" !== (desired.targetMode === "External") || (absolute === void 0 ? source.target !== desired.target : sourceAbsolute !== absolute)) return refuse("conflict", "A canonical inline picture relationship conflicts with its owning source binding.");
+			}
+			if (absolute !== void 0 && !findZipEntryCaseInsensitive(zip, absolute.toLowerCase())) {
+				const media = document.package.media?.get(absolute);
+				if (!media) return refuse("missingMedia", "A canonical inline picture is missing its media bytes.");
+				if (isUnsafePackagePath(media.path) || media.path !== absolute) return refuse("unsafeTarget", "A canonical inline picture media path does not match its relationship.");
+				writeZipPart({
+					zip,
+					path: absolute,
+					data: media.data,
+					options: {
+						compression: "DEFLATE",
+						compressionOptions: { level: compressionLevel }
+					}
+				});
+				const extension = absolute.split(".").at(-1)?.toLowerCase();
+				if (!extension || !/^[a-z0-9]+$/u.test(extension)) return refuse("unsafeTarget", "A canonical inline picture media extension is invalid.");
+				await registerImageExtensions(zip, /* @__PURE__ */ new Set([extension]), compressionLevel);
+			}
+			if (source) continue;
+			const root = parseXmlDocument(xml);
+			const type = root !== null && getChildElements(root).some((element) => getAttribute(element, null, "Type")?.startsWith("http://purl.oclc.org/ooxml/officeDocument/relationships/")) ? "http://purl.oclc.org/ooxml/officeDocument/relationships/image" : RELATIONSHIP_TYPES.image;
+			const target = absolute === void 0 ? desired.target : relativeTargetForPart(partPath, absolute);
+			xml = appendCanonicalRelationship({
+				xml,
+				partPath: relsPath,
+				relationshipXml: `<Relationship Id="${escapeXmlAttribute(id)}" Type="${type}" Target="${escapeXmlAttribute(target)}"${desired.targetMode === "External" ? " TargetMode=\"External\"" : ""}/>`
+			});
+			local.set(id, {
+				id,
+				type: RELATIONSHIP_TYPES.image,
+				target,
+				...desired.targetMode === "External" ? { targetMode: "External" } : {}
+			});
+			changed = true;
 		}
-	};
-	for (const block of blocks) if (block.type === "paragraph") collectInlineHyperlinks(block.content);
-	else if (block.type === "table") for (const row of block.rows) for (const cell of row.cells) hyperlinks.push(...collectHyperlinksWithoutRId(cell.content));
-	else if (block.type === "blockSdt" || block.type === "blockCustomXml") hyperlinks.push(...collectHyperlinksWithoutRId(block.content));
-	return hyperlinks;
+		if (changed) writeZipPart({
+			zip,
+			path: relsPath,
+			data: xml,
+			options: {
+				compression: "DEFLATE",
+				compressionOptions: { level: compressionLevel }
+			}
+		});
+	}
+};
+const collectExternalHyperlinkResources = (blocks) => {
+	const resources = [];
+	visitBlockTreeRecords(blocks, (record) => {
+		if (record.type !== "paragraph") return BLOCK_TREE_DESCENT.descend;
+		visitInlineContentSlots(record, ({ item }) => {
+			if (item.type === "hyperlink" && item.href && !item.anchor) resources.push({
+				type: "text",
+				hyperlink: item
+			});
+		});
+		visitParagraphRuns(record, (run) => {
+			for (const drawing of run.content) if (drawing.type === "drawing" && drawing.rawXmlMode === void 0 && drawing.image.hlinkHref) resources.push({
+				type: "drawing",
+				image: drawing.image,
+				drawing
+			});
+		});
+		return BLOCK_TREE_DESCENT.descend;
+	});
+	return resources;
+};
+const externalHyperlinkTarget = (resource) => {
+	switch (resource.type) {
+		case "text": return {
+			id: resource.hyperlink.rId,
+			href: resource.hyperlink.href
+		};
+		case "drawing": return {
+			id: resource.image.hlinkRId,
+			href: resource.image.hlinkHref
+		};
+		default: return resource;
+	}
+};
+/** Newly authored text links; the census shares the complete owning-part traversal. */
+function collectHyperlinksWithoutRId(blocks) {
+	return collectExternalHyperlinkResources(blocks).flatMap((resource) => resource.type === "text" && !resource.hyperlink.rId ? [resource.hyperlink] : []);
 }
 /** The selective save boundary must use the same resource census as full repack. */
-const hasUnmaterializedInlineResources = (blocks) => collectNewImages(blocks).length > 0 || collectHyperlinksWithoutRId(blocks).length > 0;
-/**
-* Process newly created hyperlinks in every part: assign rIds and add
-* relationship entries to the owning part's rels. Mutates the hyperlinks' rId
-* fields in-place.
-*/
+const hasUnmaterializedInlineResources = (blocks) => collectNewImages(blocks).length > 0 || collectExternalHyperlinkResources(blocks).some((resource) => externalHyperlinkTarget(resource).id === void 0);
+const matchesExternalHyperlink = (relation, href) => relation?.type === RELATIONSHIP_TYPES.hyperlink && relation.targetMode === "External" && relation.target === href;
+/** Compare against the already loaded source ZIP, without mutating model or package. */
+const hasUnmaterializedHyperlinkBindings = async (document, zip) => {
+	for (const { blocks, relsPath } of collectDocxParts(document, zip)) {
+		const resources = collectExternalHyperlinkResources(blocks);
+		if (resources.length === 0) continue;
+		const relationships = parseRelationships(await readRelsOrStub(zip, relsPath));
+		for (const resource of resources) {
+			const { id, href } = externalHyperlinkTarget(resource);
+			if (href && (id === void 0 || !matchesExternalHyperlink(relationships.get(id), href))) return true;
+		}
+	}
+	return false;
+};
+const rebindCapturedDrawingLink = ({ xml, previousId, nextId }) => {
+	const parsed = Result.try({
+		try: () => parseXml(xml, OOXML_NAMESPACE_SCOPE),
+		catch: () => new DocxPackageFidelityError("Cannot rebind invalid captured drawing hyperlink XML.")
+	});
+	if (parsed.isErr()) throw parsed.error;
+	let rebound = 0;
+	const visit = (element) => {
+		const attribute = findAttributeByNamespaceUri(element, OFFICE_RELATIONSHIP_NAMESPACE_URIS, "id");
+		if (attribute?.value === previousId && element.attributes !== void 0) {
+			element.attributes[attribute.name] = nextId;
+			rebound += 1;
+		}
+		for (const child of element.elements ?? []) visit(child);
+	};
+	visit(parsed.value);
+	if (rebound !== 1) throw new DocxPackageFidelityError("Captured drawing hyperlink must own exactly one click relationship.");
+	return (parsed.value.elements ?? []).map(captureVerbatimXml).join("");
+};
+/** Materialize each modeled hyperlink against the actual owning ZIP relationship table. */
 async function processNewHyperlinks(parts, zip, compressionLevel) {
 	for (const { relsPath, blocks } of parts) {
-		const newHyperlinks = collectHyperlinksWithoutRId(blocks);
-		if (newHyperlinks.length === 0) continue;
+		const resources = collectExternalHyperlinkResources(blocks);
+		if (resources.length === 0) continue;
 		const relsXml = await readRelsOrStub(zip, relsPath);
+		const relationships = parseRelationships(relsXml);
+		const root = parseXmlDocument(relsXml);
+		if (root?.name === void 0 || getLocalName(root.name) !== "Relationships" || getNamespaceUri(root) !== PACKAGE_RELATIONSHIPS_NAMESPACE_URI) throw new DocxPackageFidelityError("Cannot materialize hyperlinks into an invalid relationship part.");
+		const strictRelationshipNamespace = "http://purl.oclc.org/ooxml/officeDocument/relationships";
+		const relationshipType = getChildElements(root).some((child) => getAttribute(child, null, "Type")?.startsWith(`${strictRelationshipNamespace}/`)) ? `${strictRelationshipNamespace}/hyperlink` : RELATIONSHIP_TYPES.hyperlink;
+		const byTarget = /* @__PURE__ */ new Map();
+		for (const relation of relationships.values()) if (relation.type === RELATIONSHIP_TYPES.hyperlink && relation.targetMode === "External" && !byTarget.has(relation.target)) byTarget.set(relation.target, relation.id);
 		let maxId = findMaxRId(relsXml);
 		const relEntries = [];
-		for (const hyperlink of newHyperlinks) {
-			if (!hyperlink.href) continue;
-			maxId++;
-			const newRId = `rId${maxId}`;
-			relEntries.push(`<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.hyperlink}" Target="${escapeXmlAttribute(hyperlink.href)}" TargetMode="External"/>`);
-			hyperlink.rId = newRId;
+		for (const resource of resources) {
+			const { id, href } = externalHyperlinkTarget(resource);
+			if (!href || id !== void 0 && matchesExternalHyperlink(relationships.get(id), href)) continue;
+			let nextId = byTarget.get(href);
+			if (nextId === void 0) {
+				if (id !== void 0 && !relationships.has(id)) nextId = id;
+				else do {
+					maxId += 1;
+					nextId = `rId${maxId}`;
+				} while (relationships.has(nextId));
+				relationships.set(nextId, {
+					id: nextId,
+					type: RELATIONSHIP_TYPES.hyperlink,
+					target: href,
+					targetMode: "External"
+				});
+				byTarget.set(href, nextId);
+				relEntries.push({
+					type: "element",
+					name: `${root.name.slice(0, -13)}Relationship`,
+					attributes: {
+						Id: nextId,
+						Type: relationshipType,
+						Target: href,
+						TargetMode: "External"
+					}
+				});
+			}
+			switch (resource.type) {
+				case "text":
+					resource.hyperlink.rId = nextId;
+					break;
+				case "drawing": {
+					const source = resource.image.hlinkClickSource;
+					if (source !== void 0 && source.rId === id && id !== void 0) resource.image.hlinkClickSource = {
+						xml: rebindCapturedDrawingLink({
+							xml: source.xml,
+							previousId: id,
+							nextId
+						}),
+						rId: nextId
+					};
+					resource.image.hlinkRId = nextId;
+					delete resource.drawing.rawXml;
+					delete resource.drawing.rawImageFingerprint;
+					break;
+				}
+				default: panic(`Unsupported hyperlink resource ${JSON.stringify(resource)}`);
+			}
+		}
+		if (relEntries.length > 0) {
+			(root.elements ??= []).push(...relEntries);
+			writeZipPart({
+				zip,
+				path: relsPath,
+				data: captureVerbatimXml(root),
+				options: {
+					compression: "DEFLATE",
+					compressionOptions: { level: compressionLevel }
+				}
+			});
 		}
-		zip.file(relsPath, relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`), {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
-		});
 	}
 }
 /**
@@ -537,9 +768,14 @@ const normalizePackageIdsInZip = async (zip, compressionLevel) => {
 	const normalizedParts = normalizeParaIdRangeInXmlParts(normalizeRevisionIdsInXmlParts(xmlParts));
 	for (const [path, xml] of normalizedParts) if (xml !== xmlParts.get(path)) {
 		assertValidOoxmlNumericIds(xml, path);
-		zip.file(path, xml, {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
+		writeZipPart({
+			zip,
+			path,
+			data: xml,
+			options: {
+				compression: "DEFLATE",
+				compressionOptions: { level: compressionLevel }
+			}
 		});
 	}
 };
@@ -554,9 +790,14 @@ const normalizeAppVersionInZip = async (zip, compressionLevel) => {
 	if (!extendedProperties) return;
 	const xml = await extendedProperties.async("text");
 	const normalized = normalizeAppVersionInExtendedProperties(xml);
-	if (normalized !== xml) zip.file(EXTENDED_PROPERTIES_PATH, normalized, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	if (normalized !== xml) writeZipPart({
+		zip,
+		path: EXTENDED_PROPERTIES_PATH,
+		data: normalized,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 };
 /**
@@ -635,20 +876,37 @@ const normalizeExportDrawingIds = ({ package: docxPackage }) => {
 		...docxPackage.endnotes !== void 0 ? { endnotes: docxPackage.endnotes } : {}
 	});
 };
-const finishRepack = async ({ document, originalZip, outputZip, originalDocument, originalCorePropertiesXml, compressionLevel, updateModifiedDate, modifiedBy, changedNoteParaIds, sectionEndpointRemoval, sectionReferenceRemovals }) => {
-	await materializeNewHeaderFooterParts(document, outputZip, compressionLevel);
+/** Keep export mutations off authority while retaining the source-buffer cache key. */
+const cloneExportDocument = (sourceDocument) => {
+	const { originalBuffer, ...graph } = sourceDocument;
+	const document = cloneDocumentWithParagraphPropertySources(graph);
+	if (originalBuffer !== void 0) document.originalBuffer = originalBuffer;
+	copyDocumentParagraphPropertySourceContract(document, sourceDocument);
+	return document;
+};
+const finishRepack = async ({ document: sourceDocument, originalZip, outputZip, originalDocument, originalCorePropertiesXml, compressionLevel, updateModifiedDate, modifiedBy, changedNoteParaIds, onDiagnostic, bodyAuthority, sectionEndpointRemoval, sectionReferenceRemovals }) => {
+	const document = await materializeNewHeaderFooterParts(cloneExportDocument(sourceDocument), outputZip, compressionLevel);
 	await materializeEmbeddedMedia({
 		document,
 		zip: outputZip,
 		compressionLevel
 	});
+	if (bodyAuthority === "canonical") await publishCanonicalImageResources({
+		document,
+		zip: outputZip,
+		compressionLevel
+	});
 	const parts = collectDocxParts(document, outputZip);
 	normalizeExportDrawingIds(document);
 	await processNewImages(parts, outputZip, compressionLevel);
 	await processNewHyperlinks(parts, outputZip, compressionLevel);
 	assertValidFolioDocumentModel(document, "Cannot repack invalid DOCX document model");
 	applyReplyThreadMarkers(document);
-	const documentXml = serializeDocument(document, originalDocument === void 0 ? void 0 : readRootNamespaceBindings(originalDocument.xml));
+	const documentXml = serializeDocument(document, originalDocument === void 0 ? void 0 : readRootNamespaceBindings(originalDocument.xml), {
+		xml: originalDocument?.xml,
+		onDiagnostic,
+		bodyAuthority
+	});
 	if (originalDocument?.xml) assertDocumentPackageFidelity({
 		originalDocumentFacts: originalDocument.sectionFacts(),
 		serializedDocumentXml: documentXml,
@@ -662,12 +920,27 @@ const finishRepack = async ({ document, originalZip, outputZip, originalDocument
 		removedReferences: [...sectionReferenceRemovals ?? [], ...sectionEndpointRemoval?.removedReferences ?? []],
 		compressionLevel
 	});
-	outputZip.file("word/document.xml", documentXml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip: outputZip,
+		path: "word/document.xml",
+		data: documentXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
+	});
+	await rebindWatermarkRelIds({
+		document,
+		zip: outputZip,
+		compressionLevel,
+		bodyAuthority
+	});
+	await serializeHeadersFootersToZip({
+		doc: document,
+		zip: outputZip,
+		compressionLevel,
+		onDiagnostic
 	});
-	await rebindWatermarkRelIds(document, outputZip, compressionLevel);
-	await serializeHeadersFootersToZip(document, outputZip, compressionLevel);
 	await serializeNotesToZip({
 		doc: document,
 		originalZip,
@@ -677,18 +950,21 @@ const finishRepack = async ({ document, originalZip, outputZip, originalDocument
 	});
 	await serializeNumberingIntoZip(document, originalZip, outputZip, compressionLevel);
 	await serializeAddedStylesIntoZip(document, originalZip, outputZip, compressionLevel);
+	await serializeHeaderFooterSettingsIntoZip(document, outputZip, compressionLevel);
 	await serializeCommentsToZip(document, outputZip, compressionLevel);
 	await dropAttachedTemplateReference(outputZip, compressionLevel);
-	if (updateModifiedDate && originalCorePropertiesXml) {
-		const updatedCoreProperties = updateCoreProperties(originalCorePropertiesXml, {
+	if (updateModifiedDate && originalCorePropertiesXml) writeZipPart({
+		zip: outputZip,
+		path: "docProps/core.xml",
+		data: updateCoreProperties(originalCorePropertiesXml, {
 			updateModifiedDate,
 			...modifiedBy !== void 0 ? { modifiedBy } : {}
-		});
-		outputZip.file("docProps/core.xml", updatedCoreProperties, {
+		}),
+		options: {
 			compression: "DEFLATE",
 			compressionOptions: { level: compressionLevel }
-		});
-	}
+		}
+	});
 	return generateDocxZip(outputZip, compressionLevel);
 };
 async function repackDocxWithSectionEndpointRemoval({ document: doc, options, sectionEndpointRemoval, sectionReferenceRemovals }) {
@@ -707,6 +983,8 @@ async function repackDocxWithSectionEndpointRemoval({ document: doc, options, se
 		originalCorePropertiesXml,
 		compressionLevel,
 		updateModifiedDate,
+		onDiagnostic: options.onDiagnostic,
+		bodyAuthority: options.bodyAuthority,
 		...modifiedBy !== void 0 ? { modifiedBy } : {},
 		...changedNoteParaIds !== void 0 ? { changedNoteParaIds } : {},
 		...sectionEndpointRemoval !== void 0 ? { sectionEndpointRemoval } : {},
@@ -733,44 +1011,81 @@ function repackDocx(doc, options = {}) {
 */
 async function repackDocxFromRaw(doc, rawContent, options = {}) {
 	const { compressionLevel = 6, updateModifiedDate = true, modifiedBy, changedNoteParaIds } = options;
-	const exportDocument = withoutOrphanCommentRanges(doc);
+	let exportDocument = withoutOrphanCommentRanges(cloneExportDocument(doc));
 	const newZip = new JSZip();
 	for (const [path, file] of Object.entries(rawContent.originalZip.files)) {
 		if (file.dir) {
-			newZip.folder(path.replace(/\/$/u, ""));
+			writeZipPart({
+				zip: newZip,
+				path,
+				data: "",
+				options: {
+					dir: true,
+					date: file.date
+				}
+			});
 			continue;
 		}
 		if (isUnsafePackagePath(path)) continue;
-		const content = await file.async("arraybuffer");
-		newZip.file(path, content, {
-			compression: "DEFLATE",
-			compressionOptions: { level: compressionLevel }
+		writeZipPart({
+			zip: newZip,
+			path,
+			data: await file.async("arraybuffer"),
+			options: {
+				compression: "DEFLATE",
+				compressionOptions: { level: compressionLevel }
+			}
 		});
 	}
-	await materializeNewHeaderFooterParts(exportDocument, newZip, compressionLevel);
+	exportDocument = await materializeNewHeaderFooterParts(exportDocument, newZip, compressionLevel);
 	await materializeEmbeddedMedia({
 		document: exportDocument,
 		zip: newZip,
 		compressionLevel
 	});
+	if (options.bodyAuthority === "canonical") await publishCanonicalImageResources({
+		document: exportDocument,
+		zip: newZip,
+		compressionLevel
+	});
 	const parts = collectDocxParts(exportDocument, newZip);
 	normalizeExportDrawingIds(exportDocument);
 	await processNewImages(parts, newZip, compressionLevel);
 	await processNewHyperlinks(parts, newZip, compressionLevel);
 	assertValidFolioDocumentModel(exportDocument, "Cannot repack invalid DOCX document model");
 	applyReplyThreadMarkers(exportDocument);
-	const documentXml = serializeDocument(exportDocument, rawContent.documentXml ? readRootNamespaceBindings(rawContent.documentXml) : void 0);
+	const documentXml = serializeDocument(exportDocument, rawContent.documentXml ? readRootNamespaceBindings(rawContent.documentXml) : void 0, {
+		xml: rawContent.documentXml ?? void 0,
+		onDiagnostic: options.onDiagnostic,
+		bodyAuthority: options.bodyAuthority
+	});
 	if (rawContent.documentXml) assertDocumentPackageFidelity({
 		originalDocumentFacts: readDocumentSectionFacts(rawContent.documentXml),
 		serializedDocumentXml: documentXml,
 		doc: exportDocument
 	});
-	newZip.file("word/document.xml", documentXml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip: newZip,
+		path: "word/document.xml",
+		data: documentXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
+	});
+	await rebindWatermarkRelIds({
+		document: exportDocument,
+		zip: newZip,
+		compressionLevel,
+		bodyAuthority: options.bodyAuthority
 	});
-	await rebindWatermarkRelIds(exportDocument, newZip, compressionLevel);
-	await serializeHeadersFootersToZip(exportDocument, newZip, compressionLevel);
+	await serializeHeadersFootersToZip({
+		doc: exportDocument,
+		zip: newZip,
+		compressionLevel,
+		onDiagnostic: options.onDiagnostic
+	});
+	await serializeHeaderFooterSettingsIntoZip(exportDocument, newZip, compressionLevel);
 	await serializeNotesToZip({
 		doc: exportDocument,
 		originalZip: rawContent.originalZip,
@@ -782,16 +1097,18 @@ async function repackDocxFromRaw(doc, rawContent, options = {}) {
 	await serializeAddedStylesIntoZip(exportDocument, rawContent.originalZip, newZip, compressionLevel);
 	await serializeCommentsToZip(exportDocument, newZip, compressionLevel);
 	await dropAttachedTemplateReference(newZip, compressionLevel);
-	if (updateModifiedDate && rawContent.corePropsXml) {
-		const updatedCoreProps = updateCoreProperties(rawContent.corePropsXml, {
+	if (updateModifiedDate && rawContent.corePropsXml) writeZipPart({
+		zip: newZip,
+		path: "docProps/core.xml",
+		data: updateCoreProperties(rawContent.corePropsXml, {
 			updateModifiedDate,
 			...modifiedBy !== void 0 ? { modifiedBy } : {}
-		});
-		newZip.file("docProps/core.xml", updatedCoreProps, {
+		}),
+		options: {
 			compression: "DEFLATE",
 			compressionOptions: { level: compressionLevel }
-		});
-	}
+		}
+	});
 	return generateDocxZip(newZip, compressionLevel);
 }
 const COMMENTS_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml";
@@ -880,13 +1197,23 @@ async function dropAttachedTemplateReference(zip, compressionLevel) {
 	if (!settingsFile) return;
 	const relsFile = zip.file(SETTINGS_RELS_PART);
 	const filtered = withoutAttachedTemplate(await settingsFile.async("text"), await relsFile?.async("text"));
-	if (filtered.settingsXml !== void 0) zip.file(SETTINGS_PART, filtered.settingsXml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	if (filtered.settingsXml !== void 0) writeZipPart({
+		zip,
+		path: SETTINGS_PART,
+		data: filtered.settingsXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
-	if (filtered.relsXml !== void 0) zip.file(SETTINGS_RELS_PART, filtered.relsXml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	if (filtered.relsXml !== void 0) writeZipPart({
+		zip,
+		path: SETTINGS_RELS_PART,
+		data: filtered.relsXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 }
 /**
@@ -899,9 +1226,14 @@ async function ensureCommentsContentType(zip, compressionLevel) {
 	let ctXml = await ctFile.async("text");
 	if (ctXml.includes("/word/comments.xml")) return;
 	ctXml = ctXml.replace("</Types>", `<Override PartName="/word/comments.xml" ContentType="${COMMENTS_CONTENT_TYPE}"/></Types>`);
-	zip.file("[Content_Types].xml", ctXml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip,
+		path: "[Content_Types].xml",
+		data: ctXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 }
 /**
@@ -916,9 +1248,14 @@ async function ensureCommentsRelationship(zip, compressionLevel) {
 	if (relsXml.includes("comments.xml")) return;
 	const newRId = `rId${findMaxRId(relsXml) + 1}`;
 	relsXml = relsXml.replace("</Relationships>", `<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.comments}" Target="comments.xml"/></Relationships>`);
-	zip.file(relsPath, relsXml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip,
+		path: relsPath,
+		data: relsXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 }
 /**
@@ -932,9 +1269,14 @@ async function ensureCommentsRelationship(zip, compressionLevel) {
 async function updateDocumentXml(originalBuffer, newDocumentXml, options = {}) {
 	const { compressionLevel = 6 } = options;
 	const zip = await JSZip.loadAsync(originalBuffer);
-	zip.file("word/document.xml", newDocumentXml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip,
+		path: "word/document.xml",
+		data: newDocumentXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 	return zip.generateAsync({
 		type: "arraybuffer",
@@ -954,9 +1296,14 @@ async function updateDocumentXml(originalBuffer, newDocumentXml, options = {}) {
 async function updateXmlFile(originalBuffer, path, content, options = {}) {
 	const { compressionLevel = 6 } = options;
 	const zip = await JSZip.loadAsync(originalBuffer);
-	zip.file(path, content, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip,
+		path,
+		data: content,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 	return zip.generateAsync({
 		type: "arraybuffer",
@@ -987,9 +1334,14 @@ async function updateMultipleFiles(originalBuffer, updates, options = {}) {
 */
 async function applyUpdatesToZip(zip, updates, options = {}) {
 	const { compressionLevel = 6 } = options;
-	for (const [path, content] of updates) zip.file(path, content, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	for (const [path, content] of updates) writeZipPart({
+		zip,
+		path,
+		data: content,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 	await normalizePackageOnSave(zip, compressionLevel);
 	return await zip.generateAsync({
@@ -1014,8 +1366,11 @@ async function addRelationship(originalBuffer, relationship) {
 	const newRId = `rId${findMaxRId(relsXml) + 1}`;
 	const targetModeAttr = relationship.targetMode === "External" ? " TargetMode=\"External\"" : "";
 	const newRelElement = `<Relationship Id="${newRId}" Type="${relationship.type}" Target="${escapeXmlAttribute(relationship.target)}"${targetModeAttr}/>`;
-	const updatedRelsXml = relsXml.replace("</Relationships>", `${newRelElement}</Relationships>`);
-	zip.file(relsPath, updatedRelsXml);
+	writeZipPart({
+		zip,
+		path: relsPath,
+		data: relsXml.replace("</Relationships>", `${newRelElement}</Relationships>`)
+	});
 	return {
 		buffer: await zip.generateAsync({
 			type: "arraybuffer",
@@ -1037,7 +1392,11 @@ async function addRelationship(originalBuffer, relationship) {
 async function addMedia(originalBuffer, filename, data, mimeType) {
 	const zip = await JSZip.loadAsync(originalBuffer);
 	const mediaPath = `word/media/${filename}`;
-	zip.file(mediaPath, data);
+	writeZipPart({
+		zip,
+		path: mediaPath,
+		data
+	});
 	const relResult = await addRelationship(await zip.generateAsync({ type: "arraybuffer" }), {
 		type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
 		target: `media/${filename}`
@@ -1050,7 +1409,11 @@ async function addMedia(originalBuffer, filename, data, mimeType) {
 			const extensionElement = `<Default Extension="${extension}" ContentType="${getContentTypeForExtension(extension, mimeType)}"/>`;
 			const updatedContentTypes = contentTypesXml.replace("</Types>", `${extensionElement}</Types>`);
 			const finalZip = await JSZip.loadAsync(relResult.buffer);
-			finalZip.file("[Content_Types].xml", updatedContentTypes);
+			writeZipPart({
+				zip: finalZip,
+				path: "[Content_Types].xml",
+				data: updatedContentTypes
+			});
 			return {
 				buffer: await finalZip.generateAsync({
 					type: "arraybuffer",
@@ -1115,11 +1478,19 @@ function findMaxHeaderFooterNum(zip, prefix) {
 * relationship.
 */
 async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
-	if (!hasUnmaterializedHeaderFooter(doc)) return;
-	doc.package.relationships ??= /* @__PURE__ */ new Map();
-	const rels = doc.package.relationships;
+	if (!doc.package.headers?.size && !doc.package.footers?.size) return doc;
+	doc = {
+		...doc,
+		package: {
+			...doc.package,
+			relationships: new Map(doc.package.relationships),
+			...doc.package.headers === void 0 ? {} : { headers: new Map(doc.package.headers) },
+			...doc.package.footers === void 0 ? {} : { footers: new Map(doc.package.footers) }
+		}
+	};
+	const rels = doc.package.relationships ?? panic("The export owns its relationship map.");
 	const relEntries = [];
-	const overrides = [];
+	const contentTypeParts = [];
 	let maxHeaderNum = findMaxHeaderFooterNum(zip, "header");
 	let maxFooterNum = findMaxHeaderFooterNum(zip, "footer");
 	const relsPath = "word/_rels/document.xml.rels";
@@ -1142,8 +1513,18 @@ async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
 	const materialize = (map, relType, prefix, contentType, isHeader) => {
 		if (!map) return;
 		for (const rId of [...map.keys()]) {
-			const existing = rels.get(rId) ?? zipRels.get(rId);
-			if (existing && existing.type === relType && existing.target) continue;
+			const registered = zipRels.get(rId);
+			const existing = registered ?? rels.get(rId);
+			if (existing && existing.type === relType && existing.target) {
+				rels.set(rId, existing);
+				const path = resolveRelativePath(relsPath, existing.target);
+				contentTypeParts.push({
+					partName: `/${path}`,
+					contentType
+				});
+				if (!registered) relEntries.push(`<Relationship Id="${escapeXmlAttribute(rId)}" Type="${relType}" Target="${escapeXmlAttribute(existing.target)}"/>`);
+				continue;
+			}
 			let effectiveRId = rId;
 			if (existing) {
 				effectiveRId = `rId${++maxRId}`;
@@ -1152,6 +1533,12 @@ async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
 					map.delete(rId);
 					map.set(effectiveRId, headerFooter);
 				}
+				const body = doc.package.document;
+				doc.package.document = {
+					...body,
+					content: body.content.map((block) => block.type === "paragraph" && block.sectionProperties !== void 0 ? cloneParagraphWithPropertySource(block, { sectionProperties: structuredClone(block.sectionProperties) }) : block),
+					...body.finalSectionProperties === void 0 ? {} : { finalSectionProperties: structuredClone(body.finalSectionProperties) }
+				};
 				for (const block of doc.package.document.content) if (block.type === "paragraph") remapRefs(isHeader ? block.sectionProperties?.headerReferences : block.sectionProperties?.footerReferences, rId, effectiveRId);
 				const finalProps = doc.package.document.finalSectionProperties;
 				remapRefs(isHeader ? finalProps?.headerReferences : finalProps?.footerReferences, rId, effectiveRId);
@@ -1163,32 +1550,39 @@ async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
 				target: filename
 			});
 			relEntries.push(`<Relationship Id="${escapeXmlAttribute(effectiveRId)}" Type="${relType}" Target="${filename}"/>`);
-			overrides.push(`<Override PartName="/word/${filename}" ContentType="${contentType}"/>`);
+			contentTypeParts.push({
+				partName: `/word/${filename}`,
+				contentType
+			});
 		}
 	};
 	materialize(doc.package.headers, RELATIONSHIP_TYPES.header, "header", HEADER_CONTENT_TYPE, true);
 	materialize(doc.package.footers, RELATIONSHIP_TYPES.footer, "footer", FOOTER_CONTENT_TYPE, false);
-	if (relEntries.length === 0) return;
 	const compressionOptions = { level: compressionLevel };
-	zip.file(relsPath, relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`), {
-		compression: "DEFLATE",
-		compressionOptions
+	if (relEntries.length > 0) writeZipPart({
+		zip,
+		path: relsPath,
+		data: relsXml.replace("</Relationships>", `${relEntries.join("")}</Relationships>`),
+		options: {
+			compression: "DEFLATE",
+			compressionOptions
+		}
 	});
 	const ctFile = zip.file("[Content_Types].xml");
 	if (ctFile) {
-		let ctXml = await ctFile.async("text");
-		const missing = overrides.filter((override) => {
-			const partName = /PartName="(?<partName>[^"]+)"/u.exec(override)?.groups?.["partName"];
-			return partName ? !ctXml.includes(`PartName="${partName}"`) : true;
-		});
-		if (missing.length > 0) {
-			ctXml = ctXml.replace("</Types>", `${missing.join("")}</Types>`);
-			zip.file("[Content_Types].xml", ctXml, {
+		const original = await ctFile.async("text");
+		const updated = registerContentTypeParts(original, contentTypeParts);
+		if (updated !== original) writeZipPart({
+			zip,
+			path: "[Content_Types].xml",
+			data: updated,
+			options: {
 				compression: "DEFLATE",
 				compressionOptions
-			});
-		}
+			}
+		});
 	}
+	return doc;
 }
 /**
 * A picture watermark is "model-driven" when its raw VML was cleared (so the
@@ -1204,25 +1598,46 @@ function hasModelDrivenPictureWatermark(doc) {
 	for (const hf of headers.values()) if (hf.watermark?.kind === "picture" && !hf.rawWatermarkXml) return true;
 	return false;
 }
-/**
-* Rebind each picture watermark's `imageRId` so it resolves in its own header
-* part's rels. A watermark propagated across headers (or onto a header created
-* by coverage) carries the source header's rId, which is meaningless in a
-* sibling header's `word/_rels/header*.xml.rels`. Per header: keep the rId if
-* it already resolves; otherwise reuse an existing relationship to the same
-* media target, or mint a new one. Media bytes are materialized before this step. Raw watermark XML
-* changes only when its image relationship must be rebound.
-*/
-async function rebindWatermarkRelIds(doc, zip, compressionLevel) {
+const appendCanonicalRelationship = ({ xml, relationshipXml, partPath }) => {
+	const parsed = parseStreamingXmlWithSourceRanges(xml);
+	if (parsed.status !== "parsed") throw new DocxPackageFidelityError(`Cannot read canonical relationships in ${partPath}`);
+	const root = getChildElements(parsed.value).find((element) => getLocalName(element.name ?? "") === "Relationships" && getNamespaceUri(element) === PACKAGE_RELATIONSHIPS_NAMESPACE_URI);
+	const range = root ? getXmlSourceRange(root) : void 0;
+	if (!root?.name || !range) throw new DocxPackageFidelityError(`Cannot find canonical relationship root in ${partPath}`);
+	const sourceRoot = xml.slice(range.start, range.end);
+	const bound = relationshipXml.replace("<Relationship ", `<Relationship xmlns="${PACKAGE_RELATIONSHIPS_NAMESPACE_URI}" `);
+	const selfClosing = sourceRoot.endsWith("/>");
+	const close = xml.lastIndexOf("</", range.end);
+	if (!selfClosing && close < range.start) throw new DocxPackageFidelityError(`Cannot extend canonical relationships in ${partPath}`);
+	const result = spliceXml(xml, [selfClosing ? {
+		start: range.end - 2,
+		end: range.end,
+		newXml: ">" + bound + `</${root.name}>`
+	} : {
+		start: close,
+		end: close,
+		newXml: bound
+	}]);
+	if (result === null) throw new DocxPackageFidelityError(`Cannot splice canonical relationships in ${partPath}`);
+	return result;
+};
+async function rebindWatermarkRelIds({ document: doc, zip, compressionLevel, bodyAuthority }) {
 	const rels = doc.package.relationships;
 	const headers = doc.package.headers;
-	if (!rels || !headers) return;
+	if (!headers) return;
+	if (!rels) {
+		if (bodyAuthority === "canonical" && [...headers.values()].some(({ watermark }) => watermark?.kind === "picture")) throw new DocxPackageFidelityError("A canonical picture watermark has no header relationship map");
+		return;
+	}
 	const pending = [];
 	for (const [rId, hf] of headers) {
 		const watermark = hf.watermark;
 		if (!watermark || watermark.kind !== "picture") continue;
 		const rel = rels.get(rId);
-		if (!rel?.target) continue;
+		if (!rel?.target) {
+			if (bodyAuthority === "canonical") throw new DocxPackageFidelityError(`A canonical picture watermark has no header target for ${rId}`);
+			continue;
+		}
 		pending.push({
 			watermark,
 			header: hf,
@@ -1255,20 +1670,37 @@ async function rebindWatermarkRelIds(doc, zip, compressionLevel) {
 	const changedPaths = /* @__PURE__ */ new Set();
 	for (const { watermark, header, relsPath, partPath } of pending) {
 		let canonical;
-		if (watermark.imageTarget !== void 0) if (watermark.imageTargetExternal) canonical = isAllowedExternalWatermarkImageUrl(watermark.imageTarget) ? {
-			mode: "external",
-			url: watermark.imageTarget
-		} : resolveCanonical(watermark.imageRId);
-		else canonical = {
+		if (watermark.imageTarget !== void 0) if (watermark.imageTargetExternal) {
+			if (bodyAuthority === "canonical" && !isAllowedExternalWatermarkImageUrl(watermark.imageTarget)) throw new DocxPackageFidelityError("A canonical picture watermark has an unsafe external target");
+			canonical = isAllowedExternalWatermarkImageUrl(watermark.imageTarget) ? {
+				mode: "external",
+				url: watermark.imageTarget
+			} : resolveCanonical(watermark.imageRId);
+		} else canonical = {
 			mode: "internal",
 			absolute: watermark.imageTarget
 		};
 		else canonical = resolveCanonical(watermark.imageRId);
-		if (!canonical) continue;
+		if (!canonical) {
+			if (bodyAuthority === "canonical") throw new DocxPackageFidelityError("A canonical picture watermark image cannot be resolved");
+			continue;
+		}
+		if (bodyAuthority === "canonical" && canonical.mode === "internal" && !zip.file(canonical.absolute)) throw new DocxPackageFidelityError("A canonical picture watermark image part is missing");
 		const relsXml = relsXmlByPath.get(relsPath) ?? EMPTY_RELS_XML;
 		const localRels = parseRelationships(relsXml);
 		const local = relImage(localRels.get(watermark.imageRId), relsPath);
 		if (local && sameImage(local, canonical)) continue;
+		if (bodyAuthority === "canonical") {
+			if (localRels.has(watermark.imageRId)) throw new DocxPackageFidelityError(`A canonical picture watermark relationship ${watermark.imageRId} has a conflicting target`);
+			const relXml = canonical.mode === "external" ? `<Relationship Id="${escapeXmlAttribute(watermark.imageRId)}" Type="${RELATIONSHIP_TYPES.image}" Target="${escapeXmlAttribute(canonical.url)}" TargetMode="External"/>` : `<Relationship Id="${escapeXmlAttribute(watermark.imageRId)}" Type="${RELATIONSHIP_TYPES.image}" Target="${escapeXmlAttribute(relativeTargetForPart(partPath, canonical.absolute))}"/>`;
+			relsXmlByPath.set(relsPath, appendCanonicalRelationship({
+				xml: relsXml,
+				relationshipXml: relXml,
+				partPath: relsPath
+			}));
+			changedPaths.add(relsPath);
+			continue;
+		}
 		let resolvedRId;
 		for (const [id, rel] of localRels) {
 			const image = relImage(rel, relsPath);
@@ -1293,19 +1725,18 @@ async function rebindWatermarkRelIds(doc, zip, compressionLevel) {
 	const compressionOptions = { level: compressionLevel };
 	for (const path of changedPaths) {
 		const xml = relsXmlByPath.get(path);
-		if (xml) zip.file(path, xml, {
-			compression: "DEFLATE",
-			compressionOptions
+		if (xml) writeZipPart({
+			zip,
+			path,
+			data: xml,
+			options: {
+				compression: "DEFLATE",
+				compressionOptions
+			}
 		});
 	}
 }
-/**
-* Re-serialize every header/footer the model still owns, keyed by part path.
-*
-* `sourceZip` supplies each part as it stands before the save so the rebuilt
-* root can keep any prefix binding only the source document declared.
-*/
-async function collectHeaderFooterUpdates(doc, sourceZip) {
+async function collectHeaderFooterUpdates(doc, { sourceZip, onDiagnostic }) {
 	const updates = /* @__PURE__ */ new Map();
 	const rels = doc.package.relationships;
 	if (!rels) return updates;
@@ -1327,21 +1758,28 @@ async function collectHeaderFooterUpdates(doc, sourceZip) {
 				const bindings = sourceFile ? readRootNamespaceBindings(await sourceFile.async("text")) : /* @__PURE__ */ new Map();
 				updates.set(path, serializeHeaderFooter(headerFooter, {
 					path,
-					bindings
+					bindings,
+					onDiagnostic,
+					originalBuffer: doc.originalBuffer
 				}));
 			}
 		}
 	}
 	return updates;
 }
-/**
-* Serialize modified headers and footers into the ZIP
-*/
-async function serializeHeadersFootersToZip(doc, zip, compressionLevel) {
+async function serializeHeadersFootersToZip({ doc, zip, compressionLevel, onDiagnostic }) {
 	const compressionOptions = { level: compressionLevel };
-	for (const [filename, xml] of await collectHeaderFooterUpdates(doc, zip)) zip.file(filename, xml, {
-		compression: "DEFLATE",
-		compressionOptions
+	for (const [filename, xml] of await collectHeaderFooterUpdates(doc, {
+		sourceZip: zip,
+		onDiagnostic
+	})) writeZipPart({
+		zip,
+		path: filename,
+		data: xml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions
+		}
 	});
 }
 async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel, changedNoteParaIds }) {
@@ -1350,7 +1788,7 @@ async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel,
 	if (footnotes.length > 0 || originalFootnotes) if (originalFootnotes) await patchNotePartIntoZip({
 		conventionalLowerPath: "word/footnotes.xml",
 		currentXml: serializeFootnotes(footnotes),
-		replacementXml: serializeNewFootnotesPart(footnotes),
+		replacementXml: serializeNewFootnotesPart(footnotes, doc),
 		baselineFrom: (xml) => serializeFootnotes(parseFootnotes(xml).getNormalFootnotes()),
 		elementName: "footnote",
 		changedNoteParaIds,
@@ -1363,7 +1801,7 @@ async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel,
 		newZip,
 		partPath: "word/footnotes.xml",
 		relationshipType: RELATIONSHIP_TYPES.footnotes,
-		serializedPart: serializeNewFootnotesPart(footnotes),
+		serializedPart: serializeNewFootnotesPart(footnotes, doc),
 		compressionLevel
 	});
 	const endnotes = doc.package.endnotes ?? [];
@@ -1371,7 +1809,7 @@ async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel,
 	if (endnotes.length > 0 || originalEndnotes) if (originalEndnotes) await patchNotePartIntoZip({
 		conventionalLowerPath: "word/endnotes.xml",
 		currentXml: serializeEndnotes(endnotes),
-		replacementXml: serializeNewEndnotesPart(endnotes),
+		replacementXml: serializeNewEndnotesPart(endnotes, doc),
 		baselineFrom: (xml) => serializeEndnotes(parseEndnotes(xml).getNormalEndnotes()),
 		elementName: "endnote",
 		changedNoteParaIds,
@@ -1384,7 +1822,7 @@ async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel,
 		newZip,
 		partPath: "word/endnotes.xml",
 		relationshipType: RELATIONSHIP_TYPES.endnotes,
-		serializedPart: serializeNewEndnotesPart(endnotes),
+		serializedPart: serializeNewEndnotesPart(endnotes, doc),
 		compressionLevel
 	});
 }
@@ -1395,22 +1833,68 @@ async function materializeNewNotePart({ contentType, newZip, partPath, relations
 	const compressionOptions = { level: compressionLevel };
 	const contentTypesXml = await contentTypesFile.async("text");
 	const partName = `/${partPath}`;
-	if (!contentTypesXml.toLowerCase().includes(partName.toLowerCase())) newZip.file(contentTypesFile.name, contentTypesXml.replace("</Types>", () => `<Override PartName="${partName}" ContentType="${contentType}"/></Types>`), {
-		compression: "DEFLATE",
-		compressionOptions
+	if (!contentTypesXml.toLowerCase().includes(partName.toLowerCase())) writeZipPart({
+		zip: newZip,
+		path: contentTypesFile.name,
+		data: contentTypesXml.replace("</Types>", () => `<Override PartName="${partName}" ContentType="${contentType}"/></Types>`),
+		options: {
+			compression: "DEFLATE",
+			compressionOptions
+		}
 	});
 	const relationshipsXml = await relationshipsFile.async("text");
 	if (!relationshipsXml.includes(relationshipType)) {
 		const relationshipId = `rId${findMaxRId(relationshipsXml) + 1}`;
 		const target = partPath.slice(5);
-		newZip.file(relationshipsFile.name, relationshipsXml.replace("</Relationships>", () => `<Relationship Id="${relationshipId}" Type="${relationshipType}" Target="${target}"/></Relationships>`), {
+		writeZipPart({
+			zip: newZip,
+			path: relationshipsFile.name,
+			data: relationshipsXml.replace("</Relationships>", () => `<Relationship Id="${relationshipId}" Type="${relationshipType}" Target="${target}"/></Relationships>`),
+			options: {
+				compression: "DEFLATE",
+				compressionOptions
+			}
+		});
+	}
+	writeZipPart({
+		zip: newZip,
+		path: partPath,
+		data: serializedPart,
+		options: {
 			compression: "DEFLATE",
 			compressionOptions
+		}
+	});
+}
+/** Only this modeled switch changes on story lifecycle edits; preserve all other settings. */
+async function serializeHeaderFooterSettingsIntoZip(doc, zip, compressionLevel) {
+	if (!doc.package.settings) return;
+	const enabled = doc.package.settings.evenAndOddHeaders;
+	const file = zip.file(SETTINGS_PART);
+	if (!file) {
+		if (enabled === void 0) return;
+		await materializeNewNotePart({
+			contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml",
+			newZip: zip,
+			partPath: "word/settings.xml",
+			relationshipType: RELATIONSHIP_TYPES.settings,
+			serializedPart: serializeSettingsXml(doc.package.settings),
+			compressionLevel
 		});
+		return;
 	}
-	newZip.file(partPath, serializedPart, {
-		compression: "DEFLATE",
-		compressionOptions
+	const xml = await file.async("text");
+	if (parseSettings(xml).evenAndOddHeaders === enabled) return;
+	const patched = updateEvenAndOddHeaders(xml, enabled);
+	if (patched === null) throw new DocxPackageFidelityError("Cannot update malformed header/footer settings");
+	writeZipPart({
+		zip,
+		path: file.name,
+		data: patched,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 }
 const numberingBaselines = /* @__PURE__ */ new WeakMap();
@@ -1446,9 +1930,14 @@ async function serializeNumberingIntoZip(doc, originalZip, newZip, compressionLe
 		currentXml
 	});
 	if (patched === null || patched === baseline.originalXml) return;
-	newZip.file(file.name, patched, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip: newZip,
+		path: file.name,
+		data: patched,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 }
 const STYLES_PART_PATH = "word/styles.xml";
@@ -1556,24 +2045,18 @@ const styleDefinitionsToSerialize = (doc) => {
 		styles: [...styles.styles, ...missing]
 	};
 };
-async function serializeAddedStylesIntoZip(doc, originalZip, newZip, compressionLevel) {
+/** One append-only style owner for full repack and selective overlays. */
+async function planAddedStyles(doc, originalZip) {
 	const styles = doc.package.styles;
-	if (!styles || styles.styles.length === 0) return;
+	if (!styles || styles.styles.length === 0) return { type: "unchanged" };
 	const file = findNotePartEntry(originalZip, STYLES_PART_PATH);
 	const originalXml = file ? await file.async("text") : null;
 	const rootName = originalXml === null ? void 0 : /<(?![?!])(?<name>[^\s/>]+)/u.exec(originalXml)?.groups?.["name"];
 	const rootClose = originalXml !== null && rootName !== void 0 && getLocalName(rootName) === "styles" ? originalXml.lastIndexOf(`</${rootName}>`) : -1;
-	if (file === null || originalXml === null || rootClose < 0) {
-		await materializeNewNotePart({
-			contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml",
-			newZip,
-			partPath: STYLES_PART_PATH,
-			relationshipType: RELATIONSHIP_TYPES.styles,
-			serializedPart: serializeStylesXml(styles),
-			compressionLevel
-		});
-		return;
-	}
+	if (file === null || originalXml === null || rootClose < 0) return {
+		type: "materialize",
+		styles
+	};
 	const existing = new Set(definedStyleIds(originalXml));
 	const added = [];
 	for (const style of styles.styles) {
@@ -1581,13 +2064,42 @@ async function serializeAddedStylesIntoZip(doc, originalZip, newZip, compression
 		existing.add(style.styleId);
 		added.push(style);
 	}
-	if (added.length === 0) return;
+	if (added.length === 0) return { type: "unchanged" };
 	const canonical = hasCanonicalWordprocessingPrefixes(originalXml);
 	const patched = originalXml.slice(0, rootClose) + added.map((style) => canonical ? serializeStyle(style) : selfBoundFragment(serializeStyle(style), file.name)).join("") + originalXml.slice(rootClose);
-	newZip.file(file.name, patched, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
-	});
+	return {
+		type: "patch",
+		path: file.name,
+		xml: patched
+	};
+}
+async function serializeAddedStylesIntoZip(doc, originalZip, newZip, compressionLevel) {
+	const plan = await planAddedStyles(doc, originalZip);
+	switch (plan.type) {
+		case "unchanged": return;
+		case "materialize":
+			await materializeNewNotePart({
+				contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml",
+				newZip,
+				partPath: STYLES_PART_PATH,
+				relationshipType: RELATIONSHIP_TYPES.styles,
+				serializedPart: serializeStylesXml(plan.styles),
+				compressionLevel
+			});
+			return;
+		case "patch":
+			writeZipPart({
+				zip: newZip,
+				path: plan.path,
+				data: plan.xml,
+				options: {
+					compression: "DEFLATE",
+					compressionOptions: { level: compressionLevel }
+				}
+			});
+			return;
+		default: return plan;
+	}
 }
 /**
 * The XML to write for a patched note part, or null to keep the original.
@@ -1642,9 +2154,14 @@ async function patchNotePartIntoZip({ conventionalLowerPath, currentXml, replace
 		partName: file.name
 	});
 	if (patchedXml === null || patchedXml === originalXml) return;
-	newZip.file(file.name, patchedXml, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip: newZip,
+		path: file.name,
+		data: patchedXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 }
 /** `word/Footnotes.xml` -> `word/_rels/Footnotes.xml.rels` (casing preserved). */
@@ -1742,7 +2259,10 @@ function createEmptyDocx(properties = {}) {
 }
 const createEmptyDocxZip = ({ creator, application }) => {
 	const zip = new JSZip();
-	zip.file("[Content_Types].xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+	writeZipPart({
+		zip,
+		path: "[Content_Types].xml",
+		data: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
   <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
   <Default Extension="xml" ContentType="application/xml"/>
@@ -1750,18 +2270,30 @@ const createEmptyDocxZip = ({ creator, application }) => {
   <Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
   <Override PartName="/docProps/core.xml" ContentType="application/vnd.openxmlformats-package.core-properties+xml"/>
   <Override PartName="/docProps/app.xml" ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml"/>
-</Types>`);
-	zip.file("_rels/.rels", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+</Types>`
+	});
+	writeZipPart({
+		zip,
+		path: "_rels/.rels",
+		data: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
   <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>
   <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>
   <Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>
-</Relationships>`);
-	zip.file("word/_rels/document.xml.rels", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+</Relationships>`
+	});
+	writeZipPart({
+		zip,
+		path: "word/_rels/document.xml.rels",
+		data: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
   <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>
-</Relationships>`);
-	zip.file("word/document.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+</Relationships>`
+	});
+	writeZipPart({
+		zip,
+		path: "word/document.xml",
+		data: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
   <w:body>
     <w:p>
@@ -1774,19 +2306,30 @@ const createEmptyDocxZip = ({ creator, application }) => {
       <w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440" w:header="720" w:footer="720" w:gutter="0"/>
     </w:sectPr>
   </w:body>
-</w:document>`);
-	zip.file(STYLES_PART_PATH, SEED_STYLES_XML);
+</w:document>`
+	});
+	writeZipPart({
+		zip,
+		path: STYLES_PART_PATH,
+		data: SEED_STYLES_XML
+	});
 	const now = (/* @__PURE__ */ new Date()).toISOString();
-	const creatorElement = creator === void 0 ? "" : `\n  <dc:creator>${escapeXmlText(creator)}</dc:creator>`;
-	zip.file("docProps/core.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">${creatorElement}
+	writeZipPart({
+		zip,
+		path: "docProps/core.xml",
+		data: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">${creator === void 0 ? "" : `\n  <dc:creator>${escapeXmlText(creator)}</dc:creator>`}
   <dcterms:created xsi:type="dcterms:W3CDTF">${now}</dcterms:created>
   <dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>
-</cp:coreProperties>`);
-	const applicationElements = application === void 0 ? "" : `\n  <Application>${escapeXmlText(application)}</Application>\n  <AppVersion>${CREATED_APP_VERSION}</AppVersion>`;
-	zip.file("docProps/app.xml", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">${applicationElements}
-</Properties>`);
+</cp:coreProperties>`
+	});
+	writeZipPart({
+		zip,
+		path: "docProps/app.xml",
+		data: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">${application === void 0 ? "" : `\n  <Application>${escapeXmlText(application)}</Application>\n  <AppVersion>${CREATED_APP_VERSION}</AppVersion>`}
+</Properties>`
+	});
 	return zip;
 };
 /**
@@ -1807,7 +2350,9 @@ async function createDocx(doc, properties = {}) {
 			originalDocument: source.document,
 			originalCorePropertiesXml: source.corePropertiesXml,
 			compressionLevel: 6,
-			updateModifiedDate: true
+			updateModifiedDate: true,
+			onDiagnostic: properties.onDiagnostic,
+			bodyAuthority: properties.bodyAuthority
 		});
 	}
 	const zip = await createDocumentSeedZip(doc, properties);
@@ -1818,7 +2363,9 @@ async function createDocx(doc, properties = {}) {
 		originalDocument: void 0,
 		originalCorePropertiesXml: await zip.file("docProps/core.xml")?.async("text"),
 		compressionLevel: 6,
-		updateModifiedDate: true
+		updateModifiedDate: true,
+		onDiagnostic: properties.onDiagnostic,
+		bodyAuthority: properties.bodyAuthority
 	});
 }
 const createDocumentSeedZip = async (doc, properties) => {
@@ -1829,38 +2376,69 @@ const createDocumentSeedZip = async (doc, properties) => {
 	const styleDefinitions = styleDefinitionsToSerialize(doc);
 	if (styleDefinitions) {
 		assertStyleNumberingReferences(doc);
-		zip.file(STYLES_PART_PATH, serializeStylesXml(styleDefinitions));
-	} else zip.file(STYLES_PART_PATH, seedStylesXmlWith(missingNoteReferenceStyles(void 0, noteReferenceNeeds(doc.package))));
+		writeZipPart({
+			zip,
+			path: STYLES_PART_PATH,
+			data: serializeStylesXml(styleDefinitions)
+		});
+	} else writeZipPart({
+		zip,
+		path: STYLES_PART_PATH,
+		data: seedStylesXmlWith(missingNoteReferenceStyles(void 0, noteReferenceNeeds(doc.package)))
+	});
 	const numbering = doc.package.numbering;
 	if (numbering && (numbering.abstractNums.length > 0 || numbering.nums.length > 0)) {
-		zip.file("word/numbering.xml", serializeNumberingXml(numbering));
+		writeZipPart({
+			zip,
+			path: "word/numbering.xml",
+			data: serializeNumberingXml(numbering)
+		});
 		relationships.push(relationshipXml(nextRelationshipId, "numbering", "numbering.xml"));
 		overrides.push(overrideXml("/word/numbering.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"));
 		nextRelationshipId += 1;
 	}
 	if (doc.package.theme) {
-		zip.file("word/theme/theme1.xml", serializeThemeXml(doc.package.theme));
+		writeZipPart({
+			zip,
+			path: "word/theme/theme1.xml",
+			data: serializeThemeXml(doc.package.theme)
+		});
 		relationships.push(relationshipXml(nextRelationshipId, "theme", "theme/theme1.xml"));
 		overrides.push(overrideXml("/word/theme/theme1.xml", "application/vnd.openxmlformats-officedocument.theme+xml"));
 		nextRelationshipId += 1;
 	}
 	if (doc.package.fontTable && doc.package.fontTable.fonts.length > 0) {
-		zip.file("word/fontTable.xml", serializeFontTableXml(doc.package.fontTable));
+		writeZipPart({
+			zip,
+			path: "word/fontTable.xml",
+			data: serializeFontTableXml(doc.package.fontTable)
+		});
 		relationships.push(relationshipXml(nextRelationshipId, "fontTable", "fontTable.xml"));
 		overrides.push(overrideXml("/word/fontTable.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"));
 		nextRelationshipId += 1;
 	}
 	if (doc.package.settings) {
-		zip.file("word/settings.xml", serializeSettingsXml(doc.package.settings));
+		writeZipPart({
+			zip,
+			path: "word/settings.xml",
+			data: serializeSettingsXml(doc.package.settings)
+		});
 		relationships.push(relationshipXml(nextRelationshipId, "settings", "settings.xml"));
 		overrides.push(overrideXml("/word/settings.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"));
 	}
-	zip.file("word/_rels/document.xml.rels", `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${relationships.join("")}</Relationships>`);
+	writeZipPart({
+		zip,
+		path: "word/_rels/document.xml.rels",
+		data: `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${relationships.join("")}</Relationships>`
+	});
 	if (overrides.length > 0) {
 		const contentTypesFile = zip.file("[Content_Types].xml");
 		if (!contentTypesFile) panic("Fresh DOCX seed is missing [Content_Types].xml");
-		const contentTypes = await contentTypesFile.async("string");
-		zip.file("[Content_Types].xml", contentTypes.replace("</Types>", `${overrides.join("")}\n</Types>`));
+		writeZipPart({
+			zip,
+			path: "[Content_Types].xml",
+			data: (await contentTypesFile.async("string")).replace("</Types>", `${overrides.join("")}\n</Types>`)
+		});
 	}
 	return zip;
 };
@@ -1894,4 +2472,4 @@ const assertStyleNumberingReferences = (doc) => {
 	}
 };
 //#endregion
-export { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_CONTENT_TYPE, COMMENTS_EXTENDED_PART, COMMENTS_EXTENDED_PART_LOWER, DocxDuplicateSectionCarrierError, DocxPackageFidelityError, addCommentsExtendedOverride, addCommentsExtendedRelationship, addMedia, addRelationship, applyUpdatesToZip, collectHeaderFooterUpdates, collectHyperlinksWithoutRId, createDocx, createEmptyDocx, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, hasUnmaterializedInlineResources, isDocxBuffer, notePartRelsPath, removeCommentsExtendedOverride, removeCommentsExtendedRelationship, repackDocx, repackDocxFromRaw, updateCoreProperties, updateDocumentXml, updateMultipleFiles, updateXmlFile, validateDocx, withoutAttachedTemplate };
+export { COMMENTS_CONTENT_TYPE, COMMENTS_EXTENDED_CONTENT_TYPE, COMMENTS_EXTENDED_PART, COMMENTS_EXTENDED_PART_LOWER, CanonicalImageRelationshipRefusalError, DocxDuplicateSectionCarrierError, DocxPackageFidelityError, addCommentsExtendedOverride, addCommentsExtendedRelationship, addMedia, addRelationship, applyUpdatesToZip, assertSectionCarriersMatchModel, collectHeaderFooterUpdates, collectHyperlinksWithoutRId, createDocx, createEmptyDocx, findMaxRId, hasModelDrivenPictureWatermark, hasUnmaterializedHeaderFooter, hasUnmaterializedHyperlinkBindings, hasUnmaterializedInlineResources, isDocxBuffer, notePartRelsPath, planAddedStyles, publishCanonicalImageResources, removeCommentsExtendedOverride, removeCommentsExtendedRelationship, repackDocx, repackDocxFromRaw, updateCoreProperties, updateDocumentXml, updateMultipleFiles, updateXmlFile, validateDocx, withoutAttachedTemplate };