@stll/folio-core 0.37.4 → 0.38.0

package/dist/ai-edits/headless.js

@@ -1,29 +1,44 @@
+import { matchInlineAtoms } from "../compare/inline-atoms.js";
+import { matchInlineProvenance } from "../compare/inline-provenance.js";
+import { stageSectionBoundaryProperties } from "../compare/section-boundary-properties.js";
+import { importReferencedStyleDefinitions } from "../compare/style-resources.js";
 import { applyFolioDocumentOperations } from "../document-operations.js";
+import { rebindDrawingImageRelationship } from "../docx/drawingRelationships.js";
 import { getEndnoteText, getFootnoteText, isSeparatorEndnote, isSeparatorFootnote } from "../docx/footnoteParser.js";
 import { getHeaderFooterText } from "../docx/headerFooterParser.js";
+import { getCachedNumberingMap } from "../docx/numberingParser.js";
 import { recreateProseNodeWithParagraphPropertySource, transferProseParagraphPropertySource } from "../docx/paragraphPropertySource.js";
 import { parseDocx } from "../docx/parser.js";
 import { createReply } from "../docx/replyToComment.js";
 import { repackDocx } from "../docx/rezip.js";
+import { sectionReferenceHistory } from "../docx/sectionReferenceHistory.js";
 import { attemptSelectiveSave } from "../docx/selectiveSave.js";
 import { pluginsForHeadlessRevisionResolution } from "../internal/headlessRevisionResolutionGuard.js";
 import { withTrackedSectionEndpointRemoval } from "../internal/sectionEndpointResolution.js";
+import { captureSectionReferenceInventory, resolvedSectionReferenceLosses, withSectionReferenceResolution } from "../internal/sectionReferenceResolution.js";
+import { expectCharacterStyleMarkAttrs } from "../prosemirror/attrs/index.js";
 import { acceptAIEditRevision, rejectAIEditRevision, resolveAllChangesInHeadlessState } from "../prosemirror/commands/comments.js";
+import { sectionRejectProperties } from "../prosemirror/commands/propertyChangeScope.js";
 import { proseDocToBlocks, updateDocumentContent } from "../prosemirror/conversion/fromProseDoc.js";
 import { footnoteToProseDoc, headerFooterToProseDoc, toProseDoc } from "../prosemirror/conversion/toProseDoc.js";
 import { ensureBaseDirectionInState } from "../prosemirror/extensions/features/AutoBidiDetectionExtension.js";
 import { getChangedParagraphIds, getTrackedSectionEndpointRemoval, hasStructuralChanges, hasUntrackedChanges } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
-import { createDocumentNumberingPlugin } from "../prosemirror/plugins/documentNumbering.js";
-import { createDocumentStylesPlugin, getDocumentStyleResolver } from "../prosemirror/plugins/documentStyles.js";
+import "../prosemirror/listMarker.js";
+import { createDocumentNumberingPlugin, withDocumentNumbering } from "../prosemirror/plugins/documentNumbering.js";
+import { createDocumentStylesPlugin, getDocumentStyleResolver, withDocumentStyles } from "../prosemirror/plugins/documentStyles.js";
 import { schema, singletonManager } from "../prosemirror/schema/index.js";
+import { canonicalJson } from "../utils/canonicalJson.js";
 import { deterministicHexId } from "../utils/hexId.js";
 import { buildAnnotatedBlockText } from "./clean-text.js";
 import { getCommentAnchorsFromDoc, getTrackedChangeStatsFromDoc, getTrackedChangesFromDoc, getTrackedChangesFromSnapshot } from "./read.js";
-import { createFolioAIEditSnapshotWithStyleResolver, folioStoryTables, isFolioAIContentBlock, normalizeFolioAIBlockText, sourceDocumentOf } from "./snapshot.js";
+import { createFolioAIEditSnapshotWithStyleResolver, detachFolioAIEditSnapshotExternalHyperlinks, folioStoryTables, isFolioAIContentBlock, normalizeFolioAIBlockText, sourceDocumentOf } from "./snapshot.js";
 import { matchTableGeometry } from "./table-geometry.js";
+import { tableTemplateCanCrossPackageLosslessly } from "./table-template.js";
 import { TaggedError, panic } from "better-result";
 import { Fragment } from "prosemirror-model";
 import { EditorState } from "prosemirror-state";
+import { REVIEW_CARRIERS } from "@stll/docx-core/model";
+import JSZip from "jszip";
 //#region src/ai-edits/headless.ts
 /**
 * Headless `.docx` review path: buffer -> apply AI edits -> buffer, with
@@ -160,6 +175,47 @@ const resolvedStoryBlockProjection = (block) => {
 	delete persisted.idStability;
 	return persisted;
 };
+const numberingLevelsOf = (numbering) => {
+	if (!numbering) return [];
+	const levelsByAbstractId = new Map(numbering.abstractNums.map((abstractNum) => [abstractNum.abstractNumId, abstractNum.levels]));
+	const levels = [];
+	for (const instance of numbering.nums) {
+		const overrides = new Map((instance.levelOverrides ?? []).map((override) => [override.ilvl, override]));
+		for (const level of levelsByAbstractId.get(instance.abstractNumId) ?? []) {
+			const override = overrides.get(level.ilvl);
+			const resolved = override?.lvl ?? level;
+			levels.push({
+				numId: instance.numId,
+				level: resolved.ilvl,
+				format: resolved.numFmt,
+				levelText: resolved.lvlText,
+				...(override?.startOverride ?? resolved.start) !== void 0 ? { start: override?.startOverride ?? resolved.start } : {}
+			});
+		}
+	}
+	return levels;
+};
+const referencedNumberingLevelsByNumId = ({ references }) => {
+	const levelsByNumId = /* @__PURE__ */ new Map();
+	for (const { numId, level } of references) {
+		const levels = levelsByNumId.get(numId) ?? /* @__PURE__ */ new Set();
+		levelsByNumId.set(numId, levels);
+		levels.add(level);
+		for (let ancestor = 0; ancestor <= Math.min(level, 8); ancestor += 1) levels.add(ancestor);
+	}
+	return new Map([...levelsByNumId].map(([numId, levels]) => [numId, [...levels].toSorted((left, right) => left - right)]));
+};
+const sameReferencedNumberingLevels = ({ current, target, numId, levelsByNumId }) => {
+	if (!current) return false;
+	const currentNumbering = getCachedNumberingMap(current);
+	const targetNumbering = getCachedNumberingMap(target);
+	for (const level of levelsByNumId.get(numId) ?? []) {
+		const currentLevel = currentNumbering.getLevel(numId, level);
+		const targetLevel = targetNumbering.getLevel(numId, level);
+		if (!currentLevel || !targetLevel || canonicalJson(currentLevel) !== canonicalJson(targetLevel)) return false;
+	}
+	return true;
+};
 const comparisonAccessByReviewer = /* @__PURE__ */ new WeakMap();
 const MAIN_STORY = Object.freeze({ type: "main" });
 const headerFooterStoryKey = ({ type, relationshipId }) => `${type}:${relationshipId}`;
@@ -242,9 +298,16 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	/** Default author for tracked changes and comments. */
 	author;
 	baseDocument;
+	finalSectionPropertiesOverride;
 	originalBuffer;
 	state;
 	secondaryStoryStates = /* @__PURE__ */ new Map();
+	removedHeaderFooterStories = /* @__PURE__ */ new Map();
+	sectionReferenceRemovals = [];
+	importedStyles;
+	importedMedia = /* @__PURE__ */ new Map();
+	importedHeaders = /* @__PURE__ */ new Map();
+	importedFooters = /* @__PURE__ */ new Map();
 	resolvedStoryExpectations = /* @__PURE__ */ new Map();
 	createdComments = [];
 	usedCommentIds;
@@ -265,10 +328,231 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		this.author = args.author;
 		this.usedCommentIds = new Set((args.baseDocument.package.document.comments ?? []).map(({ id }) => id));
 		comparisonAccessByReviewer.set(this, Object.freeze({
+			stageTerminalTableReviewCarrier: (target) => this.stageTerminalTableReviewCarrier(target),
+			stageTargetStyles: (source, snapshots, importedHeaderFooterSnapshots) => this.stageTargetStyles(source, snapshots, importedHeaderFooterSnapshots),
+			createComparisonHeaderFooter: (source, story) => this.createComparisonHeaderFooter(source, story),
+			finalSectionProperties: () => this.currentFinalSectionProperties(),
+			stageFinalSectionProperties: ({ target, previous, revision }) => this.stageFinalSectionProperties({
+				target,
+				previous,
+				revision
+			}),
+			stageMappedSectionBoundaries: (options) => this.stageMappedSectionBoundaries(options),
+			matchInlineAtoms: ({ story, ...options }) => {
+				const state = this.getEditableStoryState(story);
+				if (!state) return panic("A compared story lost its editable state", { story });
+				const result = matchInlineAtoms({
+					...options,
+					state,
+					author: this.author
+				});
+				switch (result.status) {
+					case "matched":
+						if (result.transaction.docChanged) this.setEditableStoryState(story, state.apply(result.transaction));
+						return {
+							status: "matched",
+							nextRevisionId: result.nextRevisionId,
+							changedTargetBlockIds: result.changedTargetBlockIds,
+							rangeCount: result.rangeCount,
+							documentChanged: result.transaction.docChanged
+						};
+					case "unalignable":
+					case "budget-exceeded": return result;
+					default: return panic("Unhandled inline atom result", { result });
+				}
+			},
+			matchInlineProvenance: ({ story, ...options }) => {
+				const state = this.getEditableStoryState(story);
+				if (!state) return panic("A compared story lost its editable state", { story });
+				const result = matchInlineProvenance({
+					...options,
+					state,
+					author: this.author
+				});
+				switch (result.status) {
+					case "matched":
+						if (result.transaction.docChanged) this.setEditableStoryState(story, state.apply(result.transaction));
+						return {
+							status: "matched",
+							nextRevisionId: result.nextRevisionId,
+							changedTargetBlockIds: result.changedTargetBlockIds,
+							rangeCount: result.rangeCount,
+							documentChanged: result.transaction.docChanged
+						};
+					case "unalignable":
+					case "budget-exceeded": return result;
+					default: return panic("Unhandled inline provenance result", { result });
+				}
+			},
 			projectStories: (mode) => this.projectComparisonStoriesInternal(mode),
-			snapshotReviewedStory: (options) => this.snapshotReviewedStoryInternal(options)
+			snapshotReviewedStory: (options) => this.snapshotReviewedStoryInternal(options),
+			numberingDefinitions: () => this.baseDocument.package.numbering,
+			planTargetNumberingReferences: (target, references) => this.planTargetNumberingReferences(target, references),
+			stageTargetNumbering: (target, references, remappedNumIds) => this.stageTargetNumbering(target, references, remappedNumIds)
 		}));
 	}
+	stageTargetStyles(source, snapshots, importedHeaderFooterSnapshots) {
+		const destination = this.baseDocument.package;
+		const sourcePackage = source.baseDocument.package;
+		const destinationStyles = this.importedStyles ?? destination.styles;
+		const existing = new Set(destinationStyles?.styles.map(({ styleId }) => styleId));
+		const sourceStyleIds = new Set(sourcePackage.styles?.styles.map(({ styleId }) => styleId));
+		const collect = (document) => {
+			const references = /* @__PURE__ */ new Set();
+			document.descendants((node) => {
+				const styleId = node.attrs["styleId"];
+				if (typeof styleId === "string" && styleId.length > 0) references.add(styleId);
+				for (const mark of node.marks) if (mark.type.name === "characterStyle") references.add(expectCharacterStyleMarkAttrs(mark).styleId);
+			});
+			return references;
+		};
+		const hasUnstyledParagraph = (document) => {
+			let found = false;
+			document.descendants((node) => {
+				if (node.isTextblock && typeof node.attrs["styleId"] !== "string") {
+					found = true;
+					return false;
+				}
+				return true;
+			});
+			return found;
+		};
+		const resourceSnapshots = canonicalJson(sourcePackage.styles?.docDefaults) === canonicalJson(destinationStyles?.docDefaults) && canonicalJson(sourcePackage.theme) === canonicalJson(destination.theme) ? snapshots : importedHeaderFooterSnapshots;
+		const referencedStyleIds = /* @__PURE__ */ new Set();
+		let materializeDefaultParagraphStyle = false;
+		for (const snapshot of resourceSnapshots) {
+			if (hasUnstyledParagraph(sourceDocumentOf(snapshot))) materializeDefaultParagraphStyle = true;
+			for (const styleId of collect(sourceDocumentOf(snapshot))) if (sourceStyleIds.has(styleId) && !existing.has(styleId)) referencedStyleIds.add(styleId);
+		}
+		const reservedStyleIds = /* @__PURE__ */ new Set();
+		if (referencedStyleIds.size > 0) for (const handle of this.listStoryHandlesInternal()) {
+			const state = this.getEditableStoryState(handle);
+			if (!state) continue;
+			for (const styleId of collect(state.doc)) if (referencedStyleIds.has(styleId)) reservedStyleIds.add(styleId);
+		}
+		const result = importReferencedStyleDefinitions({
+			sourceStyles: sourcePackage.styles,
+			destinationStyles,
+			sourceTheme: sourcePackage.theme,
+			destinationTheme: destination.theme,
+			referencedStyleIds: [...referencedStyleIds],
+			reservedStyleIds: [...reservedStyleIds],
+			materializeDefaultParagraphStyle
+		});
+		if (result.status === "imported") {
+			this.importedStyles = result.styles;
+			this.state = withDocumentStyles(this.state, result.styles);
+			for (const entry of this.secondaryStoryStates.values()) {
+				const wasUntouched = entry.state === entry.initialState;
+				const refreshed = withDocumentStyles(entry.state, result.styles);
+				entry.state = refreshed;
+				if (wasUntouched) entry.initialState = refreshed;
+			}
+		}
+		return result;
+	}
+	/**
+	* A raw final table has no paragraph mark after it for Word to merge into
+	* when the target ends in a paragraph. Folio-exact comparison adds this
+	* untracked receiver before planning; its private marker makes resolving in
+	* Folio restore the raw source view.
+	*/
+	stageTerminalTableReviewCarrier(target) {
+		if (this.state.doc.lastChild?.type.name !== "table" || target.lastChild?.type.name !== "paragraph") return false;
+		const paragraphType = this.state.schema.nodes["paragraph"];
+		if (!paragraphType) return panic("The schema has no paragraph node for a terminal-table review carrier");
+		const carrier = paragraphType.create({ reviewCarrier: REVIEW_CARRIERS.TERMINAL_TABLE });
+		this.state = this.state.apply(this.state.tr.insert(this.state.doc.content.size, carrier));
+		return true;
+	}
+	stageTargetNumbering(target, references, remappedNumIds) {
+		if (references.length === 0) return "unchanged";
+		if (!target) return "conflict";
+		const current = this.baseDocument.package.numbering ?? {
+			abstractNums: [],
+			nums: []
+		};
+		const nums = new Map(current.nums.map((entry) => [entry.numId, entry]));
+		const abstracts = new Map(current.abstractNums.map((entry) => [entry.abstractNumId, entry]));
+		const targetNums = new Map(target.nums.map((entry) => [entry.numId, entry]));
+		const targetAbstracts = new Map(target.abstractNums.map((entry) => [entry.abstractNumId, entry]));
+		const levelsByNumId = referencedNumberingLevelsByNumId({ references });
+		const importedAbstractIds = /* @__PURE__ */ new Map();
+		let nextAbstractId = 0;
+		for (const id of abstracts.keys()) nextAbstractId = Math.max(nextAbstractId, id + 1);
+		for (const numId of levelsByNumId.keys()) {
+			const targetNum = targetNums.get(numId);
+			if (!targetNum) return "conflict";
+			const targetAbstract = targetAbstracts.get(targetNum.abstractNumId);
+			if (!targetAbstract) return "conflict";
+			const stagedNumId = remappedNumIds.get(numId) ?? numId;
+			if (nums.get(stagedNumId)) {
+				if (stagedNumId === numId && sameReferencedNumberingLevels({
+					current,
+					target,
+					numId,
+					levelsByNumId
+				})) continue;
+				return "conflict";
+			}
+			let abstractNumId = importedAbstractIds.get(targetAbstract.abstractNumId);
+			if (abstractNumId === void 0) {
+				abstractNumId = targetAbstract.abstractNumId;
+				const collision = abstracts.get(abstractNumId);
+				if (collision && canonicalJson(collision) !== canonicalJson(targetAbstract)) abstractNumId = nextAbstractId++;
+				nextAbstractId = Math.max(nextAbstractId, abstractNumId + 1);
+				importedAbstractIds.set(targetAbstract.abstractNumId, abstractNumId);
+				abstracts.set(abstractNumId, {
+					...targetAbstract,
+					abstractNumId
+				});
+			}
+			nums.set(stagedNumId, {
+				...targetNum,
+				numId: stagedNumId,
+				abstractNumId
+			});
+		}
+		if (nums.size === current.nums.length) return "unchanged";
+		const numbering = {
+			...current,
+			abstractNums: [...abstracts.values()],
+			nums: [...nums.values()]
+		};
+		this.baseDocument.package.numbering = numbering;
+		this.state = withDocumentNumbering(this.state, numbering);
+		for (const entry of this.secondaryStoryStates.values()) entry.state = withDocumentNumbering(entry.state, numbering);
+		return "staged";
+	}
+	planTargetNumberingReferences(target, references) {
+		if (references.length === 0) return /* @__PURE__ */ new Map();
+		if (!target) return null;
+		const current = this.baseDocument.package.numbering ?? {
+			abstractNums: [],
+			nums: []
+		};
+		const nums = new Map(current.nums.map((entry) => [entry.numId, entry]));
+		const targetNums = new Map(target.nums.map((entry) => [entry.numId, entry]));
+		const targetAbstracts = new Map(target.abstractNums.map((entry) => [entry.abstractNumId, entry]));
+		const levelsByNumId = referencedNumberingLevelsByNumId({ references });
+		let nextNumId = 0;
+		for (const id of nums.keys()) nextNumId = Math.max(nextNumId, id + 1);
+		for (const id of targetNums.keys()) nextNumId = Math.max(nextNumId, id + 1);
+		const remapped = /* @__PURE__ */ new Map();
+		for (const numId of levelsByNumId.keys()) {
+			const targetNum = targetNums.get(numId);
+			const targetAbstract = targetNum ? targetAbstracts.get(targetNum.abstractNumId) : void 0;
+			if (!targetNum || !targetAbstract) return null;
+			if (!nums.get(numId)) continue;
+			if (!sameReferencedNumberingLevels({
+				current,
+				target,
+				numId,
+				levelsByNumId
+			})) remapped.set(numId, nextNumId++);
+		}
+		return remapped;
+	}
 	/** Parse a `.docx` buffer into a reviewer. */
 	static async fromBuffer(buffer, options = {}) {
 		const baseDocument = await parseDocx(buffer, {
@@ -308,25 +592,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	* packages can be compared entry by entry.
 	*/
 	readNumberingDefinitions() {
-		const numbering = this.baseDocument.package.numbering;
-		if (!numbering) return [];
-		const levelsByAbstractId = new Map(numbering.abstractNums.map((abstractNum) => [abstractNum.abstractNumId, abstractNum.levels]));
-		const levels = [];
-		for (const instance of numbering.nums) {
-			const overrides = new Map((instance.levelOverrides ?? []).map((override) => [override.ilvl, override]));
-			for (const level of levelsByAbstractId.get(instance.abstractNumId) ?? []) {
-				const override = overrides.get(level.ilvl);
-				const resolved = override?.lvl ?? level;
-				levels.push({
-					numId: instance.numId,
-					level: resolved.ilvl,
-					format: resolved.numFmt,
-					levelText: resolved.lvlText,
-					...(override?.startOverride ?? resolved.start) !== void 0 ? { start: override?.startOverride ?? resolved.start } : {}
-				});
-			}
-		}
-		return levels.toSorted((left, right) => left.numId - right.numId || left.level - right.level);
+		return numberingLevelsOf(this.baseDocument.package.numbering).toSorted((left, right) => left.numId - right.numId || left.level - right.level);
 	}
 	/** Return parsed package metadata without exposing the mutable document model. */
 	getDocumentProperties() {
@@ -357,12 +623,18 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		const handles = this.listStoryHandlesInternal();
 		let highestId = 0;
 		let present = false;
-		if (mode === "with-revision-census") for (const handle of handles) {
-			const state = this.getEditableStoryState(handle);
-			if (!state) continue;
-			const stats = getTrackedChangeStatsFromDoc(state.doc);
-			highestId = Math.max(highestId, stats.highestId);
-			present ||= stats.present;
+		if (mode === "with-revision-census") {
+			for (const change of this.currentFinalSectionProperties()?.propertyChanges ?? []) {
+				highestId = Math.max(highestId, change.info.id);
+				present = true;
+			}
+			for (const handle of handles) {
+				const state = this.getEditableStoryState(handle);
+				if (!state) continue;
+				const stats = getTrackedChangeStatsFromDoc(state.doc);
+				highestId = Math.max(highestId, stats.highestId);
+				present ||= stats.present;
+			}
 		}
 		const stories = [];
 		for (const handle of handles) stories.push({
@@ -661,10 +933,18 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			type: "header",
 			relationshipId
 		});
+		for (const relationshipId of this.importedHeaders.keys()) handles.push({
+			type: "header",
+			relationshipId
+		});
 		for (const relationshipId of pkg.footers?.keys() ?? []) handles.push({
 			type: "footer",
 			relationshipId
 		});
+		for (const relationshipId of this.importedFooters.keys()) handles.push({
+			type: "footer",
+			relationshipId
+		});
 		for (const footnote of pkg.footnotes ?? []) if (!isSeparatorFootnote(footnote)) handles.push({
 			type: "footnote",
 			noteId: footnote.id
@@ -673,7 +953,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			type: "endnote",
 			noteId: endnote.id
 		});
-		return handles;
+		return handles.filter((handle) => handle.type !== "header" && handle.type !== "footer" || !this.removedHeaderFooterStories.has(headerFooterStoryKey(handle)));
 	}
 	/** Discover every readable document story through a typed, serializable handle. */
 	listStories() {
@@ -696,7 +976,14 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	* entry where the document model identifies them as one authored change.
 	*/
 	getChanges(filter) {
-		const changes = getTrackedChangesFromDoc(this.state.doc);
+		const changes = [...getTrackedChangesFromDoc(this.state.doc), ...(this.currentFinalSectionProperties()?.propertyChanges ?? []).map(({ info }) => ({
+			id: info.id,
+			type: "sectionPropertiesChanged",
+			author: info.author,
+			date: info.date ?? null,
+			text: "",
+			blockId: null
+		}))];
 		if (!filter) return changes;
 		return changes.filter((change) => (filter.author === void 0 || change.author === filter.author) && (filter.type === void 0 || change.type === filter.type));
 	}
@@ -786,6 +1073,86 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		this.resolvedOverrides.set(target.id, resolved);
 		return true;
 	}
+	currentFinalSectionProperties() {
+		return this.finalSectionPropertiesOverride ?? this.baseDocument.package.document.finalSectionProperties;
+	}
+	stageFinalSectionProperties({ target, previous, revision }) {
+		if (canonicalJson(target) === canonicalJson(previous)) return false;
+		const previousReferences = sectionReferenceHistory({
+			previous,
+			target
+		});
+		this.finalSectionPropertiesOverride = {
+			...target,
+			propertyChanges: [{
+				type: "sectionPropertyChange",
+				info: {
+					id: revision.idSeed,
+					author: this.author,
+					date: revision.date
+				},
+				previousProperties: previous,
+				...previousReferences !== void 0 && { previousReferences },
+				currentProperties: target
+			}]
+		};
+		return true;
+	}
+	stageMappedSectionBoundaries({ target, originalRevisionIdSeed, maxRanges, revision, mapTargetProperties }) {
+		const result = stageSectionBoundaryProperties({
+			state: this.state,
+			target,
+			originalRevisionIdSeed,
+			revisionStamp: revision,
+			author: this.author,
+			maxRanges,
+			mapTargetProperties
+		});
+		if (result.status !== "matched") return result;
+		const documentChanged = result.transaction.docChanged;
+		if (documentChanged) this.state = this.state.apply(result.transaction);
+		return {
+			status: "matched",
+			rangeCount: result.rangeCount,
+			nextRevisionId: result.nextRevisionId,
+			documentChanged
+		};
+	}
+	resolveFinalSectionProperties(mode, id) {
+		const current = this.currentFinalSectionProperties();
+		const changes = current?.propertyChanges;
+		const targetIndex = changes?.findIndex(({ info }) => info.id === id);
+		if (!current || !changes || changes.length === 0 || targetIndex === void 0 || targetIndex < 0) return 0;
+		const { propertyChanges: _propertyChanges, ...liveProperties } = current;
+		const previousStates = changes.map((change) => sectionRejectProperties({
+			live: current,
+			previousProperties: change.previousProperties,
+			previousReferences: change.previousReferences
+		}));
+		let resolvedProperties = previousStates[0] ?? liveProperties;
+		const remaining = [];
+		for (const [index, change] of changes.entries()) {
+			const nextProperties = previousStates[index + 1] ?? liveProperties;
+			if (index === targetIndex) {
+				if (mode === "accept") resolvedProperties = nextProperties;
+				continue;
+			}
+			remaining.push({
+				...change,
+				previousProperties: resolvedProperties,
+				...change.previousReferences !== void 0 && { previousReferences: {
+					...resolvedProperties.headerReferences !== void 0 && { headerReferences: resolvedProperties.headerReferences },
+					...resolvedProperties.footerReferences !== void 0 && { footerReferences: resolvedProperties.footerReferences }
+				} }
+			});
+			resolvedProperties = nextProperties;
+		}
+		this.finalSectionPropertiesOverride = {
+			...resolvedProperties,
+			...remaining.length > 0 && { propertyChanges: remaining }
+		};
+		return 1;
+	}
 	/**
 	* Accept an existing tracked change, keeping its text and dropping the
 	* redline. Pass a {@link FolioReviewChange} from {@link getChanges} or its
@@ -794,14 +1161,26 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	* revision is no longer present (already resolved, or never existed).
 	*/
 	acceptChange(target) {
-		return this.runCommand(acceptAIEditRevision(revisionIdOf(target)));
+		return this.resolveWithSectionReferenceHistory(() => this.acceptChangeInternal(target));
+	}
+	acceptChangeInternal(target) {
+		const id = revisionIdOf(target);
+		const bodyChanged = this.runCommand(acceptAIEditRevision(id));
+		const sectionChanged = this.resolveFinalSectionProperties("accept", id) > 0;
+		return bodyChanged || sectionChanged;
 	}
 	/**
 	* Reject an existing tracked change: an insertion's text is removed, a
 	* deletion's text is restored. See {@link acceptChange} for targeting.
 	*/
 	rejectChange(target) {
-		return this.runCommand(rejectAIEditRevision(revisionIdOf(target)));
+		return this.resolveWithSectionReferenceHistory(() => this.rejectChangeInternal(target));
+	}
+	rejectChangeInternal(target) {
+		const id = revisionIdOf(target);
+		const bodyChanged = this.runCommand(rejectAIEditRevision(id));
+		const sectionChanged = this.resolveFinalSectionProperties("reject", id) > 0;
+		return bodyChanged || sectionChanged;
 	}
 	/**
 	* Accept every tracked change in the package. Returns the number of changes
@@ -812,11 +1191,45 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	* document still carries a redline nobody can see from the body.
 	*/
 	acceptAll() {
-		return this.resolveEveryStory("accept");
+		return this.resolveWithSectionReferenceHistory(() => this.resolveEveryStory("accept") + this.resolveEveryFinalSectionChange("accept"));
 	}
 	/** Reject every tracked change in the package. See {@link acceptAll}. */
 	rejectAll() {
-		return this.resolveEveryStory("reject");
+		return this.resolveWithSectionReferenceHistory(() => this.resolveEveryStory("reject") + this.resolveEveryFinalSectionChange("reject"));
+	}
+	resolveWithSectionReferenceHistory(resolve) {
+		const before = captureSectionReferenceInventory(this.state.doc, this.currentFinalSectionProperties());
+		const result = resolve();
+		const removedEndpointReferences = getTrackedSectionEndpointRemoval(this.state)?.removedReferences ?? [];
+		if (before.revisionRelationships.size > 0 || removedEndpointReferences.length > 0) {
+			const after = captureSectionReferenceInventory(this.state.doc, this.currentFinalSectionProperties());
+			const removed = resolvedSectionReferenceLosses({
+				before,
+				after
+			});
+			this.sectionReferenceRemovals.push(...removed);
+			for (const reference of [...removed, ...removedEndpointReferences]) {
+				if (after.references.some(({ part, relationshipId }) => part === reference.part && relationshipId === reference.relationshipId)) continue;
+				const handle = {
+					type: reference.part,
+					relationshipId: reference.relationshipId
+				};
+				this.removedHeaderFooterStories.set(headerFooterStoryKey(handle), handle);
+			}
+		}
+		return result;
+	}
+	resolveEveryFinalSectionChange(mode) {
+		const current = this.currentFinalSectionProperties();
+		const firstChange = current?.propertyChanges?.at(0);
+		if (!current || !firstChange) return 0;
+		const { propertyChanges, ...liveProperties } = current;
+		this.finalSectionPropertiesOverride = mode === "accept" ? liveProperties : sectionRejectProperties({
+			live: current,
+			previousProperties: firstChange.previousProperties,
+			previousReferences: firstChange.previousReferences
+		});
+		return propertyChanges?.length ?? 0;
 	}
 	resolveEveryStory(mode) {
 		let count = 0;
@@ -841,14 +1254,39 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		});
 		return {
 			mainState: this.state,
+			finalSectionPropertiesOverride: this.finalSectionPropertiesOverride,
 			secondaryStoryStates,
+			sectionReferenceRemovals: [...this.sectionReferenceRemovals],
+			removedHeaderFooterStories: [...this.removedHeaderFooterStories.values()],
+			importedStyles: this.importedStyles,
+			importedMedia: new Map(this.importedMedia),
+			importedHeaders: new Map(this.importedHeaders),
+			importedFooters: new Map(this.importedFooters),
 			createdComments: [...this.createdComments],
 			resolvedOverrides: new Map(this.resolvedOverrides),
 			resolvedStoryExpectations: [...this.resolvedStoryExpectations.values()]
 		};
 	}
 	documentFromStateSnapshot(snapshot) {
-		const document = updateDocumentContent(this.baseDocument, snapshot.mainState.doc);
+		const document = updateDocumentContent(snapshot.importedStyles === void 0 ? this.baseDocument : {
+			...this.baseDocument,
+			package: {
+				...this.baseDocument.package,
+				styles: snapshot.importedStyles
+			}
+		}, snapshot.mainState.doc);
+		if (snapshot.finalSectionPropertiesOverride !== void 0) document.package.document.finalSectionProperties = snapshot.finalSectionPropertiesOverride;
+		if (snapshot.importedStyles !== void 0) document.package.styles = snapshot.importedStyles;
+		if (snapshot.importedMedia.size > 0) document.package.media = new Map([...document.package.media ?? [], ...snapshot.importedMedia]);
+		if (snapshot.importedHeaders.size > 0) document.package.headers = new Map([...document.package.headers ?? [], ...snapshot.importedHeaders]);
+		if (snapshot.importedFooters.size > 0) document.package.footers = new Map([...document.package.footers ?? [], ...snapshot.importedFooters]);
+		for (const handle of snapshot.removedHeaderFooterStories) if (handle.type === "header") {
+			document.package.headers = new Map(document.package.headers);
+			document.package.headers.delete(handle.relationshipId);
+		} else {
+			document.package.footers = new Map(document.package.footers);
+			document.package.footers.delete(handle.relationshipId);
+		}
 		this.mergeEditedSecondaryStories(document, snapshot.secondaryStoryStates);
 		if (snapshot.createdComments.length > 0 || snapshot.resolvedOverrides.size > 0) document.package.document.comments = this.withResolvedOverrides([...document.package.document.comments ?? [], ...snapshot.createdComments], snapshot.resolvedOverrides);
 		return document;
@@ -856,7 +1294,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	captureSaveSnapshot() {
 		const snapshot = this.captureReviewerState();
 		const changedParaIds = new Set(getChangedParagraphIds(snapshot.mainState));
-		let structuralChange = hasStructuralChanges(snapshot.mainState);
+		let structuralChange = hasStructuralChanges(snapshot.mainState) || snapshot.finalSectionPropertiesOverride !== void 0 || snapshot.importedStyles !== void 0 || snapshot.importedHeaders.size > 0 || snapshot.importedFooters.size > 0;
 		let untrackedChanges = hasUntrackedChanges(snapshot.mainState);
 		const changedNoteParaIds = /* @__PURE__ */ new Set();
 		for (const entry of snapshot.secondaryStoryStates) {
@@ -875,6 +1313,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 				changedParaIds
 			},
 			changedNoteParaIds,
+			sectionReferenceRemovals: snapshot.sectionReferenceRemovals,
 			sectionEndpointRemoval: getTrackedSectionEndpointRemoval(snapshot.mainState),
 			resolvedStoryExpectations: snapshot.resolvedStoryExpectations
 		};
@@ -896,11 +1335,17 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			...save.document,
 			originalBuffer: this.originalBuffer
 		};
+		const repack = () => repackDocx(repackDocument, { changedNoteParaIds: save.changedNoteParaIds });
+		const repackReferences = () => save.sectionReferenceRemovals.length > 0 ? withSectionReferenceResolution({
+			document: repackDocument,
+			removedReferences: save.sectionReferenceRemovals,
+			repack
+		}) : repack();
 		const buffer = save.sectionEndpointRemoval ? await withTrackedSectionEndpointRemoval({
 			document: repackDocument,
 			resolution: save.sectionEndpointRemoval,
-			repack: () => repackDocx(repackDocument, { changedNoteParaIds: save.changedNoteParaIds })
-		}) : await repackDocx(repackDocument, { changedNoteParaIds: save.changedNoteParaIds });
+			repack: repackReferences
+		}) : await repackReferences();
 		await this.assertResolvedStoriesSerialized(buffer, save.resolvedStoryExpectations);
 		return buffer;
 	}
@@ -995,8 +1440,92 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		entry.state = state;
 	}
 	getHeaderFooterStory(story) {
+		if (this.removedHeaderFooterStories.has(headerFooterStoryKey(story))) return void 0;
+		const importedStory = (story.type === "header" ? this.importedHeaders : this.importedFooters).get(story.relationshipId);
+		if (importedStory) return importedStory;
 		return (story.type === "header" ? this.baseDocument.package.headers : this.baseDocument.package.footers)?.get(story.relationshipId);
 	}
+	async createComparisonHeaderFooter(source, story) {
+		const target = source.getHeaderFooterStory(story);
+		if (!target || !this.canImportHeaderFooterContent(source, story)) return null;
+		let importedWatermark = {};
+		let importedMedia;
+		if (target.watermark !== void 0 || target.rawWatermarkXml !== void 0) {
+			const watermark = target.watermark;
+			if (story.type !== "header" || watermark?.kind !== "picture" || watermark.imageTargetExternal || !watermark.imageTarget || !target.rawWatermarkXml) return null;
+			const media = source.baseDocument.package.media?.get(watermark.imageTarget);
+			if (!media || !/^image\/(?:png|jpeg|gif|tiff|bmp)$/u.test(media.mimeType)) return null;
+			const xml = rebindDrawingImageRelationship({
+				xml: target.rawWatermarkXml,
+				previousId: watermark.imageRId,
+				nextId: watermark.imageRId
+			});
+			if (xml === null) return null;
+			const extension = media.path.split(".").at(-1)?.toLowerCase();
+			if (!extension || !/^[a-z0-9]+$/u.test(extension)) return null;
+			const originalZip = await JSZip.loadAsync(this.originalBuffer);
+			const existingPaths = new Set(Object.keys(originalZip.files).map((path) => path.toLowerCase()));
+			let suffix = 1;
+			let path = `word/media/folio-import-${suffix}.${extension}`;
+			while (existingPaths.has(path.toLowerCase()) || this.baseDocument.package.media?.has(path) || this.importedMedia.has(path)) path = `word/media/folio-import-${++suffix}.${extension}`;
+			importedMedia = {
+				...media,
+				path,
+				data: media.data.slice(0)
+			};
+			importedWatermark = {
+				watermark: {
+					...watermark,
+					imageTarget: path
+				},
+				rawWatermarkXml: xml,
+				...target.watermarkBlockIndex !== void 0 && { watermarkBlockIndex: target.watermarkBlockIndex }
+			};
+		}
+		const taken = /* @__PURE__ */ new Set([
+			...this.baseDocument.package.relationships?.keys() ?? [],
+			...this.baseDocument.package.headers?.keys() ?? [],
+			...this.baseDocument.package.footers?.keys() ?? [],
+			...this.importedHeaders.keys(),
+			...this.importedFooters.keys()
+		]);
+		let suffix = 1;
+		let relationshipId = `rId${suffix}`;
+		while (taken.has(relationshipId)) relationshipId = `rId${++suffix}`;
+		const handle = {
+			type: story.type,
+			relationshipId
+		};
+		const empty = {
+			type: story.type,
+			hdrFtrType: target.hdrFtrType,
+			...importedWatermark,
+			content: [{
+				type: "paragraph",
+				content: []
+			}]
+		};
+		if (importedMedia) this.importedMedia.set(importedMedia.path, importedMedia);
+		(story.type === "header" ? this.importedHeaders : this.importedFooters).set(relationshipId, empty);
+		const state = ensureBaseDirectionInState(EditorState.create({
+			schema,
+			doc: ensureDeterministicParaIdsInDoc(headerFooterToProseDoc(empty.content)),
+			plugins: createHeadlessPlugins(this.baseDocument.package.styles, this.baseDocument.package.numbering)
+		}));
+		this.secondaryStoryStates.set(headerFooterStoryKey(handle), {
+			handle,
+			initialState: state,
+			state
+		});
+		return handle;
+	}
+	canImportHeaderFooterContent(source, story) {
+		const state = source.getEditableStoryState(story);
+		if (!state) return false;
+		if (!tableTemplateCanCrossPackageLosslessly(state.doc, "rebind-external")) return false;
+		const snapshot = source.snapshotStory(story);
+		return snapshot !== null && detachFolioAIEditSnapshotExternalHyperlinks(snapshot) !== null;
+	}
 	getNoteStory(story) {
 		if (story.type === "footnote") return this.baseDocument.package.footnotes?.find((note) => note.id === story.noteId && !isSeparatorFootnote(note));
 		return this.baseDocument.package.endnotes?.find((note) => note.id === story.noteId && !isSeparatorEndnote(note));
@@ -1029,7 +1558,7 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		for (const entry of secondaryStoryStates) {
 			if (entry.state === entry.initialState) continue;
 			if (entry.handle.type === "header" || entry.handle.type === "footer") {
-				const source = this.getHeaderFooterStory(entry.handle);
+				const source = entry.handle.type === "header" ? document.package.headers?.get(entry.handle.relationshipId) : document.package.footers?.get(entry.handle.relationshipId);
 				if (!source) continue;
 				const edited = {
 					...source,