@stll/folio-core 0.55.0 → 0.57.0

package/dist/docx/rezip.js

@@ -1,5 +1,7 @@
 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";
@@ -9,6 +11,7 @@ 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";
@@ -16,13 +19,13 @@ 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 { cloneParagraphWithPropertySource } from "./paragraphPropertySource.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 { planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
+import { buildPatchedNotePartXml, collectChangedNoteParaIds, collectParaIds, patchNumberingDefinitions, spliceXml } from "./selectiveXmlPatch.js";
+import { hasOwnedCommentsPart, planCommentParts, serializeComments, serializeCommentsExtended } from "./serializer/commentSerializer.js";
 import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeFontTableXml } from "./serializer/fontTableSerializer.js";
 import { serializeHeaderFooter } from "./serializer/headerFooterSerializer.js";
@@ -34,11 +37,14 @@ import { serializeStyle, serializeStylesXml } from "./serializer/stylesSerialize
 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,13 +202,19 @@ async function serializeCommentsToZip(doc, zip, compressionLevel) {
 	const sourceCommentsFile = findZipEntryCaseInsensitive(zip, "word/comments.xml");
 	const sourceCommentsXml = sourceCommentsFile ? await sourceCommentsFile.async("text") : void 0;
 	if (comments.length === 0) {
-		if (sourceCommentsXml === void 0 || !hasCommentEntries(sourceCommentsXml)) return;
+		const ownsCommentsPart = hasOwnedCommentsPart(doc);
+		if (sourceCommentsXml === void 0 ? !ownsCommentsPart : !hasCommentEntries(sourceCommentsXml)) return;
 	}
 	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);
@@ -231,9 +243,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);
@@ -244,9 +261,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) {
@@ -255,7 +277,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}`;
 }
@@ -352,9 +376,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) {
@@ -425,9 +454,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);
@@ -438,13 +472,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);
 }
@@ -456,67 +492,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 }
-		});
 	}
 }
 /**
@@ -541,9 +769,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 }
+			}
 		});
 	}
 };
@@ -558,9 +791,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 }
+		}
 	});
 };
 /**
@@ -639,20 +877,37 @@ const normalizeExportDrawingIds = ({ package: docxPackage }) => {
 		...docxPackage.endnotes !== void 0 ? { endnotes: docxPackage.endnotes } : {}
 	});
 };
-const finishRepack = async ({ document, originalZip, outputZip, originalDocument, originalCorePropertiesXml, compressionLevel, updateModifiedDate, modifiedBy, changedNoteParaIds, onDiagnostic, sectionEndpointRemoval, sectionReferenceRemovals }) => {
-	document = 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,
@@ -666,11 +921,21 @@ 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 rebindWatermarkRelIds(document, outputZip, compressionLevel);
 	await serializeHeadersFootersToZip({
 		doc: document,
 		zip: outputZip,
@@ -689,16 +954,18 @@ const finishRepack = async ({ document, originalZip, outputZip, originalDocument
 	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 }) {
@@ -718,6 +985,7 @@ async function repackDocxWithSectionEndpointRemoval({ document: doc, options, se
 		compressionLevel,
 		updateModifiedDate,
 		onDiagnostic: options.onDiagnostic,
+		bodyAuthority: options.bodyAuthority,
 		...modifiedBy !== void 0 ? { modifiedBy } : {},
 		...changedNoteParaIds !== void 0 ? { changedNoteParaIds } : {},
 		...sectionEndpointRemoval !== void 0 ? { sectionEndpointRemoval } : {},
@@ -744,18 +1012,30 @@ function repackDocx(doc, options = {}) {
 */
 async function repackDocxFromRaw(doc, rawContent, options = {}) {
 	const { compressionLevel = 6, updateModifiedDate = true, modifiedBy, changedNoteParaIds } = options;
-	let 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 }
+			}
 		});
 	}
 	exportDocument = await materializeNewHeaderFooterParts(exportDocument, newZip, compressionLevel);
@@ -764,23 +1044,42 @@ async function repackDocxFromRaw(doc, rawContent, options = {}) {
 		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({
 		doc: exportDocument,
 		zip: newZip,
@@ -799,16 +1098,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";
@@ -897,13 +1198,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 }
+		}
 	});
 }
 /**
@@ -914,11 +1225,17 @@ async function ensureCommentsContentType(zip, compressionLevel) {
 	const ctFile = zip.file("[Content_Types].xml");
 	if (!ctFile) return;
 	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 }
+	if (ctXml.toLowerCase().includes("/word/comments.xml")) return;
+	const commentsPartPath = findZipEntryCaseInsensitive(zip, "word/comments.xml")?.name ?? "word/comments.xml";
+	ctXml = ctXml.replace("</Types>", `<Override PartName="/${commentsPartPath}" ContentType="${COMMENTS_CONTENT_TYPE}"/></Types>`);
+	writeZipPart({
+		zip,
+		path: "[Content_Types].xml",
+		data: ctXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 }
 /**
@@ -930,12 +1247,18 @@ async function ensureCommentsRelationship(zip, compressionLevel) {
 	const relsFile = zip.file(relsPath);
 	if (!relsFile) return;
 	let relsXml = await relsFile.async("text");
-	if (relsXml.includes("comments.xml")) return;
+	if (relsXml.toLowerCase().includes("comments.xml")) return;
+	const commentsPartPath = findZipEntryCaseInsensitive(zip, "word/comments.xml")?.name ?? "word/comments.xml";
 	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 }
+	relsXml = relsXml.replace("</Relationships>", `<Relationship Id="${newRId}" Type="${RELATIONSHIP_TYPES.comments}" Target="${commentsPartPath.slice(5)}"/></Relationships>`);
+	writeZipPart({
+		zip,
+		path: relsPath,
+		data: relsXml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 }
 /**
@@ -949,9 +1272,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",
@@ -971,9 +1299,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",
@@ -1004,9 +1337,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({
@@ -1031,8 +1369,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",
@@ -1054,7 +1395,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}`
@@ -1067,7 +1412,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",
@@ -1213,17 +1562,27 @@ async function materializeNewHeaderFooterParts(doc, zip, compressionLevel) {
 	materialize(doc.package.headers, RELATIONSHIP_TYPES.header, "header", HEADER_CONTENT_TYPE, true);
 	materialize(doc.package.footers, RELATIONSHIP_TYPES.footer, "footer", FOOTER_CONTENT_TYPE, false);
 	const compressionOptions = { level: compressionLevel };
-	if (relEntries.length > 0) 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) {
 		const original = await ctFile.async("text");
 		const updated = registerContentTypeParts(original, contentTypeParts);
-		if (updated !== original) zip.file("[Content_Types].xml", updated, {
-			compression: "DEFLATE",
-			compressionOptions
+		if (updated !== original) writeZipPart({
+			zip,
+			path: "[Content_Types].xml",
+			data: updated,
+			options: {
+				compression: "DEFLATE",
+				compressionOptions
+			}
 		});
 	}
 	return doc;
@@ -1242,25 +1601,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,
@@ -1293,20 +1673,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);
@@ -1331,9 +1728,14 @@ 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
+			}
 		});
 	}
 }
@@ -1373,9 +1775,14 @@ async function serializeHeadersFootersToZip({ doc, zip, compressionLevel, onDiag
 	for (const [filename, xml] of await collectHeaderFooterUpdates(doc, {
 		sourceZip: zip,
 		onDiagnostic
-	})) zip.file(filename, xml, {
-		compression: "DEFLATE",
-		compressionOptions
+	})) writeZipPart({
+		zip,
+		path: filename,
+		data: xml,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions
+		}
 	});
 }
 async function serializeNotesToZip({ doc, originalZip, newZip, compressionLevel, changedNoteParaIds }) {
@@ -1429,22 +1836,37 @@ 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>`), {
-			compression: "DEFLATE",
-			compressionOptions
+		writeZipPart({
+			zip: newZip,
+			path: relationshipsFile.name,
+			data: relationshipsXml.replace("</Relationships>", () => `<Relationship Id="${relationshipId}" Type="${relationshipType}" Target="${target}"/></Relationships>`),
+			options: {
+				compression: "DEFLATE",
+				compressionOptions
+			}
 		});
 	}
-	newZip.file(partPath, serializedPart, {
-		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. */
@@ -1468,9 +1890,14 @@ async function serializeHeaderFooterSettingsIntoZip(doc, zip, compressionLevel)
 	if (parseSettings(xml).evenAndOddHeaders === enabled) return;
 	const patched = updateEvenAndOddHeaders(xml, enabled);
 	if (patched === null) throw new DocxPackageFidelityError("Cannot update malformed header/footer settings");
-	zip.file(file.name, patched, {
-		compression: "DEFLATE",
-		compressionOptions: { level: compressionLevel }
+	writeZipPart({
+		zip,
+		path: file.name,
+		data: patched,
+		options: {
+			compression: "DEFLATE",
+			compressionOptions: { level: compressionLevel }
+		}
 	});
 }
 const numberingBaselines = /* @__PURE__ */ new WeakMap();
@@ -1506,9 +1933,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";
@@ -1616,24 +2048,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) {
@@ -1641,13 +2067,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.
@@ -1702,9 +2157,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). */
@@ -1802,7 +2262,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"/>
@@ -1810,18 +2273,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>
@@ -1834,19 +2309,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;
 };
 /**
@@ -1868,7 +2354,8 @@ async function createDocx(doc, properties = {}) {
 			originalCorePropertiesXml: source.corePropertiesXml,
 			compressionLevel: 6,
 			updateModifiedDate: true,
-			onDiagnostic: properties.onDiagnostic
+			onDiagnostic: properties.onDiagnostic,
+			bodyAuthority: properties.bodyAuthority
 		});
 	}
 	const zip = await createDocumentSeedZip(doc, properties);
@@ -1880,7 +2367,8 @@ async function createDocx(doc, properties = {}) {
 		originalCorePropertiesXml: await zip.file("docProps/core.xml")?.async("text"),
 		compressionLevel: 6,
 		updateModifiedDate: true,
-		onDiagnostic: properties.onDiagnostic
+		onDiagnostic: properties.onDiagnostic,
+		bodyAuthority: properties.bodyAuthority
 	});
 }
 const createDocumentSeedZip = async (doc, properties) => {
@@ -1891,38 +2379,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;
 };
@@ -1956,4 +2475,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 };