@stll/folio-core 0.48.0 → 0.50.0

package/dist/ai-edits/headless.d.ts

@@ -35,6 +35,34 @@ type FolioApplyOperationsOptions = {
 };
 /** Options for {@link FolioDocxReviewer.applyDocumentOperations}. */
 type FolioApplyDocumentOperationsOptions = Omit<FolioApplyOperationsOptions, "mode">;
+/**
+ * Why a save rewrote the whole package instead of patching the edited
+ * paragraphs into the original: `structuralChange` (paragraphs added or
+ * removed, or styles, headers, footers or final section properties staged),
+ * `untrackedChange` (an edit the change tracker cannot key to a paragraph), or
+ * `selectiveDeclined` (the patch could not express the edit safely).
+ */
+type FolioReviewerRepackReason = "structuralChange" | "untrackedChange" | "selectiveDeclined";
+/** Options for {@link FolioDocxReviewer.save}. */
+type FolioReviewerSaveOptions = {
+  /**
+   * `"allow"` (default) falls back to a full repack when the selective patch
+   * does not apply; `"refuse"` reports the reason and writes nothing.
+   */
+  repack?: "allow" | "refuse";
+};
+/** Result of {@link FolioDocxReviewer.save}. */
+type FolioReviewerSaveResult = {
+  type: "selective";
+  buffer: ArrayBuffer;
+} | {
+  type: "full-repack";
+  reason: FolioReviewerRepackReason;
+  buffer: ArrayBuffer;
+} | {
+  type: "repackRefused";
+  reason: FolioReviewerRepackReason;
+};
 /** Options for {@link FolioDocxReviewer.getContentAsText}. */
 type FolioGetContentAsTextOptions = {
   /**
@@ -248,6 +276,8 @@ type FolioReviewReplyInput = {
   /** Reply author; defaults to the reviewer's author. */
   author?: string;
   initials?: string;
+  /** ISO-8601 reply date; defaults to the wall clock. */
+  date?: string;
 };
 /** A comment thread discovered in the document. */
 type FolioReviewComment = {
@@ -506,6 +536,12 @@ declare class FolioDocxReviewer {
    * structural edits — the same two-tier path the editor's save uses.
    */
   toBuffer(): Promise<ArrayBuffer>;
+  /**
+   * Serialise like {@link toBuffer} and report which path wrote the package.
+   * With `repack: "refuse"`, a save the selective patch cannot express
+   * returns the reason instead of rewriting every part.
+   */
+  save({ repack: repackPolicy }?: FolioReviewerSaveOptions): Promise<FolioReviewerSaveResult>;
   private assertResolvedStoriesSerialized;
   /**
    * Attempt the selective patch, treating a throw the same as a decline. Odd
@@ -580,4 +616,4 @@ type ApplyFolioAIEditsToBufferResult = FolioAIEditApplyResult & {
  */
 declare const applyFolioAIEditsToBuffer: (buffer: ArrayBuffer, operations: FolioAIEditOperation[], options?: ApplyFolioAIEditsToBufferOptions) => Promise<ApplyFolioAIEditsToBufferResult>;
 //#endregion
-export { ApplyFolioAIEditsToBufferOptions, ApplyFolioAIEditsToBufferResult, FOLIO_RESOLVED_REVIEWED_VIEWS, FOLIO_REVIEWED_VIEWS, FolioApplyDocumentOperationsOptions, FolioApplyDocumentOperationsToStoryOptions, FolioApplyOperationsOptions, FolioDocumentStory, FolioDocumentStoryHandle, FolioDocumentStoryNotFoundError, FolioDocxReviewer, FolioDocxReviewerOptions, FolioEditableDocumentStoryHandle, FolioGetContentAsTextOptions, FolioMatchStoryTableGeometryOptions, FolioNumberingLevel, FolioReadReviewedStoryOptions, FolioResolveReviewedStoryOptions, FolioResolvedReviewedView, type FolioReviewChange, FolioReviewChangeFilter, type FolioReviewChangeKind, FolioReviewComment, FolioReviewCommentFilter, FolioReviewCommentReply, FolioReviewReplyInput, FolioReviewedStory, FolioReviewedView, type FolioRevisionStamp, UnsupportedFolioReviewedViewError, applyFolioAIEditsToBuffer, getFolioDocxComparisonAccess, isFolioResolvedReviewedView, isFolioReviewedView };
+export { ApplyFolioAIEditsToBufferOptions, ApplyFolioAIEditsToBufferResult, FOLIO_RESOLVED_REVIEWED_VIEWS, FOLIO_REVIEWED_VIEWS, FolioApplyDocumentOperationsOptions, FolioApplyDocumentOperationsToStoryOptions, FolioApplyOperationsOptions, FolioDocumentStory, FolioDocumentStoryHandle, FolioDocumentStoryNotFoundError, FolioDocxReviewer, FolioDocxReviewerOptions, FolioEditableDocumentStoryHandle, FolioGetContentAsTextOptions, FolioMatchStoryTableGeometryOptions, FolioNumberingLevel, FolioReadReviewedStoryOptions, FolioResolveReviewedStoryOptions, FolioResolvedReviewedView, type FolioReviewChange, FolioReviewChangeFilter, type FolioReviewChangeKind, FolioReviewComment, FolioReviewCommentFilter, FolioReviewCommentReply, FolioReviewReplyInput, FolioReviewedStory, FolioReviewedView, FolioReviewerRepackReason, FolioReviewerSaveOptions, FolioReviewerSaveResult, type FolioRevisionStamp, UnsupportedFolioReviewedViewError, applyFolioAIEditsToBuffer, getFolioDocxComparisonAccess, isFolioResolvedReviewedView, isFolioReviewedView };

package/dist/ai-edits/headless.js

@@ -68,16 +68,10 @@ import JSZip from "jszip";
 */
 let commentIdCursor = Date.now();
 let undoHandleCursor = Date.now();
-/**
-* Build the note-free comment thread the apply layer references by id.
-* Mirrors `commentsHelpers.createComment` (a pure object literal there) so a
-* headless `commentOnBlock` / `comment` op serialises the same `comments.xml`
-* shape the editor produces.
-*/
-const createReviewerComment = (id, text, author) => ({
+const createReviewerComment = ({ id, text, author, date }) => ({
 	id,
 	author,
-	date: (/* @__PURE__ */ new Date()).toISOString(),
+	date: date ?? (/* @__PURE__ */ new Date()).toISOString(),
 	content: [{
 		type: "paragraph",
 		formatting: {},
@@ -848,7 +842,12 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			...tableTemplates !== void 0 && { tableTemplates },
 			...replacementBackground !== void 0 && { replacementBackground },
 			createCommentId: (text) => {
-				const comment = createReviewerComment(this.nextCommentId(), text, this.author);
+				const comment = createReviewerComment({
+					id: this.nextCommentId(),
+					text,
+					author: this.author,
+					date: revisionStamp?.date
+				});
 				this.createdComments.push(comment);
 				return comment.id;
 			},
@@ -1080,7 +1079,8 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 		const reply = createReply([...this.baseDocument.package.document.comments ?? [], ...this.createdComments], parentId, {
 			author: input.author ?? this.author,
 			text: input.text,
-			...input.initials !== void 0 ? { initials: input.initials } : {}
+			...input.initials !== void 0 ? { initials: input.initials } : {},
+			...input.date !== void 0 && { date: input.date }
 		});
 		if (!reply) return null;
 		this.createdComments.push(reply);
@@ -1344,12 +1344,21 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			structuralChange ||= hasStructuralChanges(entry.state);
 			untrackedChanges ||= hasUntrackedChanges(entry.state);
 		}
+		let path = {
+			type: "selective-first",
+			changedParaIds
+		};
+		if (structuralChange) path = {
+			type: "full-repack",
+			reason: "structuralChange"
+		};
+		else if (untrackedChanges) path = {
+			type: "full-repack",
+			reason: "untrackedChange"
+		};
 		return {
 			document: this.documentFromStateSnapshot(snapshot),
-			path: structuralChange || untrackedChanges ? { type: "full-repack" } : {
-				type: "selective-first",
-				changedParaIds
-			},
+			path,
 			changedNoteParaIds,
 			sectionReferenceRemovals: snapshot.sectionReferenceRemovals,
 			sectionEndpointRemoval: getTrackedSectionEndpointRemoval(snapshot.mainState),
@@ -1363,12 +1372,30 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 	* structural edits — the same two-tier path the editor's save uses.
 	*/
 	async toBuffer() {
+		const result = await this.save();
+		if (result.type === "repackRefused") return panic("A save that allows a full repack refused to repack", { result });
+		return result.buffer;
+	}
+	/**
+	* Serialise like {@link toBuffer} and report which path wrote the package.
+	* With `repack: "refuse"`, a save the selective patch cannot express
+	* returns the reason instead of rewriting every part.
+	*/
+	async save({ repack: repackPolicy = "allow" } = {}) {
 		const save = this.captureSaveSnapshot();
 		const selective = save.path.type === "selective-first" ? await this.trySelectiveSave(save.document, save.path.changedParaIds) : null;
 		if (selective) {
 			await this.assertResolvedStoriesSerialized(selective, save.resolvedStoryExpectations);
-			return selective;
+			return {
+				type: "selective",
+				buffer: selective
+			};
 		}
+		const reason = save.path.type === "full-repack" ? save.path.reason : "selectiveDeclined";
+		if (repackPolicy === "refuse") return {
+			type: "repackRefused",
+			reason
+		};
 		const repackDocument = {
 			...save.document,
 			originalBuffer: this.originalBuffer
@@ -1385,7 +1412,11 @@ var FolioDocxReviewer = class FolioDocxReviewer {
 			repack: repackReferences
 		}) : await repackReferences();
 		await this.assertResolvedStoriesSerialized(buffer, save.resolvedStoryExpectations);
-		return buffer;
+		return {
+			type: "full-repack",
+			reason,
+			buffer
+		};
 	}
 	async assertResolvedStoriesSerialized(buffer, expectations) {
 		if (expectations.length === 0) return;

package/dist/ai-edits/minimal-replacement.d.ts

@@ -0,0 +1,64 @@
+import { WordDiffSegment } from "./word-diff.js";
+//#region src/ai-edits/minimal-replacement.d.ts
+/** Replace `source.slice(start, end)` with `text`; offsets index the source span. */
+type TextChange = {
+  start: number;
+  end: number;
+  text: string;
+};
+/** A clean-text span that can only be replaced whole (a field result). */
+type AtomicTextSpan = {
+  offset: number;
+  length: number;
+};
+/** Common prefix length that never ends between the halves of a surrogate pair. */
+declare const commonPrefixLength: (a: string, b: string) => number;
+/** Common suffix length that never starts between the halves of a surrogate pair. */
+declare const commonSuffixLength: (a: string, b: string) => number;
+/**
+ * Edits beyond which a replacement is treated as one rewrite. Bounds the diff
+ * at O((N + M) * D) time and O(D^2) memory; a rewrite that large keeps
+ * nothing of its source worth aligning to anyway.
+ */
+declare const MAX_TOKEN_EDITS = 1024;
+/**
+ * The shortest edit script between two token sequences (Myers, 1986), as
+ * segments of joined token text, or `null` past `maxEdits` edits.
+ *
+ * Deliberately the shortest one. The redline diff in `word-diff.ts` gives up
+ * short matches between changes so a reader sees whole phrases replaced; an
+ * edit applied directly has no reader to serve, and every token it gives up is
+ * text rewritten with someone else's formatting.
+ */
+declare const shortestTokenDiff: (before: readonly string[], after: readonly string[], maxEdits?: number) => WordDiffSegment[] | null;
+/**
+ * The changes from `source` to `replacement`, in source order and disjoint.
+ *
+ * Words (with their leading whitespace, and edge punctuation on its own; see
+ * `tokenizeWords`) are aligned by the shortest edit script, and each changed
+ * stretch is then trimmed to the characters that actually differ, so
+ * appending a letter to a word that spans two runs leaves both runs alone. A
+ * rewrite past {@link MAX_TOKEN_EDITS}, or a diff that does not reconstruct
+ * both strings exactly (it never should), is one change over the whole span,
+ * trimmed the same way.
+ */
+declare const planTextChanges: (source: string, replacement: string) => TextChange[];
+/**
+ * The changes a diff's segments describe, in source order and disjoint: each
+ * run of `del` and `ins` segments between two `equal` ones is one change,
+ * exactly as wide as the segments say. A redline's segments come cut to the
+ * granularity its reader asked for, so they are not trimmed further.
+ */
+declare const changesFromSegments: (segments: readonly WordDiffSegment[]) => TextChange[];
+/**
+ * `changes` widened so none cuts into an atomic span, then merged where the
+ * widening made two overlap. A widened change re-emits the source text it
+ * absorbed, so applying the result still yields exactly the replacement.
+ *
+ * `spans` are in the same coordinates as the changes (the source span's).
+ */
+declare const widenChangesToAtomicSpans: (source: string, changes: readonly TextChange[], spans: readonly AtomicTextSpan[]) => TextChange[];
+/** `source` with `changes` applied; the invariant the planner owes. */
+declare const applyTextChanges: (source: string, changes: readonly TextChange[]) => string;
+//#endregion
+export { AtomicTextSpan, MAX_TOKEN_EDITS, TextChange, applyTextChanges, changesFromSegments, commonPrefixLength, commonSuffixLength, planTextChanges, shortestTokenDiff, widenChangesToAtomicSpans };

package/dist/ai-edits/minimal-replacement.js

@@ -0,0 +1,282 @@
+import { tokenizeWords } from "./word-diff.js";
+//#region src/ai-edits/minimal-replacement.ts
+/**
+* The smallest set of text changes that turns one clean-text span into another.
+*
+* A direct-mode replacement (`replaceInBlock`, `replaceRange`, `replaceBlock`)
+* names the text it matched and the text it wants. Swapping the whole match
+* gives every character of the result the formatting of the first one, drops
+* the inline content controls, note references and fields the match crossed,
+* and makes a one-character edit rewrite the paragraph. The edit is the
+* difference between the two strings, so that is all the applier writes:
+*
+* - Text outside a change is not touched: its runs, marks and every inline node
+*   between its characters stay exactly as they were.
+* - A change deletes only the characters it removes (text, tabs, breaks and
+*   whole field results). Non-text inline content between those characters —
+*   bookmarks, comment anchors, drawings, content-control boundaries, rendered
+*   page breaks — stays where it was; the new text is written where the first
+*   removed character stood and takes its formatting.
+* - A pure insertion follows the character before it, with the formatting that
+*   character has, the way typed text does. At the start of the matched span
+*   there is no such character inside the match, so it takes the formatting of
+*   the first matched character. A note reference's number lends no
+*   formatting: prose beside it is not superscript.
+* - An insertion at the edge of an inline content control (`w:sdt`), a link or
+*   a comment range stays inside it only when the whole match lies inside it.
+*   Matching a control's or a link's text edits it; appending to a paragraph
+*   that ends in a checkbox or a link writes after it.
+* - A field result is one unit: a change that would cut into it is widened to
+*   the whole result, which the new text then replaces as plain text (a result
+*   cannot be partly edited; it is regenerated from the field code). A field
+*   whose displayed text the replacement keeps is never touched. A match that
+*   itself starts or ends inside a field result is refused as before
+*   (`unsupportedBlock`).
+*
+* A replacement carrying inline emphasis markup (`**bold**`) states its own
+* formatting and still replaces the match whole in direct mode.
+*
+* Tracked-changes and suggested modes cut their changes from the redline diff
+* instead ({@link changesFromSegments}: word or character granularity, as the
+* caller asked), and map them onto the document by the same rules. A change
+* marks exactly the characters it removes as a deletion, which keeps their
+* runs, and writes its text as an insertion after them, formatted as the
+* first removed character that is not a note reference; a pure insertion is
+* placed and formatted as above. Nothing outside a change is wrapped in a
+* revision.
+*
+* This module is the pure half: clean-text offsets in, changes out. The
+* applier maps each change onto the document.
+*/
+const isHighSurrogate = (code) => code >= 55296 && code <= 56319;
+const isLowSurrogate = (code) => code >= 56320 && code <= 57343;
+/** Common prefix length that never ends between the halves of a surrogate pair. */
+const commonPrefixLength = (a, b) => {
+	const limit = Math.min(a.length, b.length);
+	let index = 0;
+	while (index < limit && a.charCodeAt(index) === b.charCodeAt(index)) index++;
+	return index > 0 && isHighSurrogate(a.charCodeAt(index - 1)) ? index - 1 : index;
+};
+/** Common suffix length that never starts between the halves of a surrogate pair. */
+const commonSuffixLength = (a, b) => {
+	const limit = Math.min(a.length, b.length);
+	let length = 0;
+	while (length < limit && a.charCodeAt(a.length - 1 - length) === b.charCodeAt(b.length - 1 - length)) length++;
+	return length > 0 && isLowSurrogate(a.charCodeAt(a.length - length)) ? length - 1 : length;
+};
+/** `change` without the characters its deleted and inserted text share at either end. */
+const trimChange = (source, change) => {
+	const removed = source.slice(change.start, change.end);
+	const prefix = commonPrefixLength(removed, change.text);
+	const suffix = commonSuffixLength(removed.slice(prefix), change.text.slice(prefix));
+	const trimmed = {
+		start: change.start + prefix,
+		end: change.end - suffix,
+		text: change.text.slice(prefix, change.text.length - suffix)
+	};
+	return trimmed.start === trimmed.end && trimmed.text.length === 0 ? null : trimmed;
+};
+const reconstructs = (segments, source, replacement) => {
+	let before = "";
+	let after = "";
+	for (const segment of segments) {
+		if (segment.type !== "ins") before += segment.text;
+		if (segment.type !== "del") after += segment.text;
+	}
+	return before === source && after === replacement;
+};
+/**
+* Edits beyond which a replacement is treated as one rewrite. Bounds the diff
+* at O((N + M) * D) time and O(D^2) memory; a rewrite that large keeps
+* nothing of its source worth aligning to anyway.
+*/
+const MAX_TOKEN_EDITS = 1024;
+/**
+* The shortest edit script between two token sequences (Myers, 1986), as
+* segments of joined token text, or `null` past `maxEdits` edits.
+*
+* Deliberately the shortest one. The redline diff in `word-diff.ts` gives up
+* short matches between changes so a reader sees whole phrases replaced; an
+* edit applied directly has no reader to serve, and every token it gives up is
+* text rewritten with someone else's formatting.
+*/
+const shortestTokenDiff = (before, after, maxEdits = MAX_TOKEN_EDITS) => {
+	const n = before.length;
+	const m = after.length;
+	const limit = Math.min(n + m, maxEdits);
+	const offset = limit + 1;
+	const frontier = new Int32Array(2 * limit + 3);
+	const trace = [];
+	let edits = -1;
+	search: for (let d = 0; d <= limit; d++) {
+		trace.push(frontier.slice(offset - d, offset + d + 1));
+		for (let k = -d; k <= d; k += 2) {
+			let x = k === -d || k !== d && frontier[offset + k - 1] < frontier[offset + k + 1] ? frontier[offset + k + 1] : frontier[offset + k - 1] + 1;
+			let y = x - k;
+			while (x < n && y < m && before[x] === after[y]) {
+				x++;
+				y++;
+			}
+			frontier[offset + k] = x;
+			if (x >= n && y >= m) {
+				edits = d;
+				break search;
+			}
+		}
+	}
+	if (edits < 0) return null;
+	const reversed = [];
+	const push = (type, text) => {
+		const last = reversed.at(-1);
+		if (last?.type === type) last.text = text + last.text;
+		else reversed.push({
+			type,
+			text
+		});
+	};
+	let x = n;
+	let y = m;
+	for (let d = edits; d > 0; d--) {
+		const previous = trace[d];
+		const at = (diagonal) => previous[diagonal + d];
+		const k = x - y;
+		const down = k === -d || k !== d && at(k - 1) < at(k + 1);
+		const previousK = down ? k + 1 : k - 1;
+		const previousX = at(previousK);
+		const previousY = previousX - previousK;
+		while (x > previousX && y > previousY) {
+			x--;
+			y--;
+			push("equal", before[x]);
+		}
+		if (down) {
+			y--;
+			push("ins", after[y]);
+		} else {
+			x--;
+			push("del", before[x]);
+		}
+	}
+	while (x > 0 && y > 0) {
+		x--;
+		y--;
+		push("equal", before[x]);
+	}
+	return reversed.toReversed();
+};
+/**
+* The changes from `source` to `replacement`, in source order and disjoint.
+*
+* Words (with their leading whitespace, and edge punctuation on its own; see
+* `tokenizeWords`) are aligned by the shortest edit script, and each changed
+* stretch is then trimmed to the characters that actually differ, so
+* appending a letter to a word that spans two runs leaves both runs alone. A
+* rewrite past {@link MAX_TOKEN_EDITS}, or a diff that does not reconstruct
+* both strings exactly (it never should), is one change over the whole span,
+* trimmed the same way.
+*/
+const planTextChanges = (source, replacement) => {
+	if (source === replacement) return [];
+	const diffed = shortestTokenDiff(tokenizeWords(source), tokenizeWords(replacement));
+	const segments = diffed !== null && reconstructs(diffed, source, replacement) ? diffed : [{
+		type: "del",
+		text: source
+	}, {
+		type: "ins",
+		text: replacement
+	}];
+	return changesFromSegments(segments).flatMap((change) => trimChange(source, change) ?? []);
+};
+/**
+* The changes a diff's segments describe, in source order and disjoint: each
+* run of `del` and `ins` segments between two `equal` ones is one change,
+* exactly as wide as the segments say. A redline's segments come cut to the
+* granularity its reader asked for, so they are not trimmed further.
+*/
+const changesFromSegments = (segments) => {
+	const changes = [];
+	let cursor = 0;
+	let pending = null;
+	for (const segment of segments) {
+		if (segment.type === "equal") {
+			if (pending !== null) {
+				changes.push(pending);
+				pending = null;
+			}
+			cursor += segment.text.length;
+			continue;
+		}
+		pending ??= {
+			start: cursor,
+			end: cursor,
+			text: ""
+		};
+		if (segment.type === "del") {
+			cursor += segment.text.length;
+			pending.end = cursor;
+		} else pending.text += segment.text;
+	}
+	if (pending !== null) changes.push(pending);
+	return changes;
+};
+const cutsInto = ({ offset, length }, position) => position > offset && position < offset + length;
+/**
+* `changes` widened so none cuts into an atomic span, then merged where the
+* widening made two overlap. A widened change re-emits the source text it
+* absorbed, so applying the result still yields exactly the replacement.
+*
+* `spans` are in the same coordinates as the changes (the source span's).
+*/
+const widenChangesToAtomicSpans = (source, changes, spans) => {
+	if (spans.length === 0 || changes.length === 0) return [...changes];
+	const windows = changes.map(({ start, end }) => {
+		let from = start;
+		let to = end;
+		for (const span of spans) {
+			if (cutsInto(span, from)) from = span.offset;
+			if (cutsInto(span, to)) to = span.offset + span.length;
+		}
+		return {
+			from,
+			to
+		};
+	});
+	const merged = [];
+	let index = 0;
+	while (index < changes.length) {
+		const { from } = windows[index];
+		let { to } = windows[index];
+		const group = [changes[index]];
+		index++;
+		while (index < changes.length && windows[index].from < to) {
+			to = Math.max(to, windows[index].to);
+			group.push(changes[index]);
+			index++;
+		}
+		let text = "";
+		let cursor = from;
+		for (const change of group) {
+			text += source.slice(cursor, change.start) + change.text;
+			cursor = change.end;
+		}
+		text += source.slice(cursor, to);
+		merged.push({
+			start: from,
+			end: to,
+			text
+		});
+	}
+	return merged;
+};
+/** `source` with `changes` applied; the invariant the planner owes. */
+const applyTextChanges = (source, changes) => {
+	let result = "";
+	let cursor = 0;
+	for (const change of changes) {
+		result += source.slice(cursor, change.start) + change.text;
+		cursor = change.end;
+	}
+	return result + source.slice(cursor);
+};
+//#endregion
+export { MAX_TOKEN_EDITS, applyTextChanges, changesFromSegments, commonPrefixLength, commonSuffixLength, planTextChanges, shortestTokenDiff, widenChangesToAtomicSpans };

package/dist/controller/layoutPipeline.js

@@ -230,6 +230,15 @@ function runLayoutPipelineMeasured(deps, state, options) {
 				preparedFooter: refs.footerEven ? footerContentByRId?.get(refs.footerEven) : void 0
 			});
 		});
+		const sectionFirstPageMargins = sectionHeaderFooterRefs?.map((refs, index) => {
+			if (refs.titlePg !== true) return;
+			const properties = sectionPropertiesForMargins[index];
+			return bodyMarginsClearHeaderFooter({
+				authoredMargins: properties ? getMargins(properties) : margins,
+				preparedHeader: refs.headerFirst ? headerContentByRId?.get(refs.headerFirst) : void 0,
+				preparedFooter: refs.footerFirst ? footerContentByRId?.get(refs.footerFirst) : void 0
+			});
+		});
 		newBlocks = bodyBlocksClearSectionHeaderFooter(newBlocks, {
 			authoredMargins: margins,
 			sectionHeaderFooterRefs,
@@ -358,7 +367,8 @@ function runLayoutPipelineMeasured(deps, state, options) {
 			};
 			if (document?.package.document.sections !== void 0) nextLayoutOpts.sectionVerticalAlignments = document.package.document.sections.map(({ properties }) => properties.verticalAlign);
 			else if (sectionProperties !== null && sectionProperties !== void 0) nextLayoutOpts.sectionVerticalAlignments = [sectionProperties.verticalAlign];
-			if (hasTitlePg) nextLayoutOpts.firstPageMargins = bodyMarginsClearHeaderFooter({
+			if (sectionFirstPageMargins !== void 0) nextLayoutOpts.sectionFirstPageMargins = sectionFirstPageMargins;
+			else if (hasTitlePg) nextLayoutOpts.firstPageMargins = bodyMarginsClearHeaderFooter({
 				authoredMargins: margins,
 				preparedHeader: firstPageHeaderForRender,
 				preparedFooter: firstPageFooterForRender

package/dist/display-list/build/paragraphPrimitives.js

@@ -1,6 +1,7 @@
 import { getListMarkerInlineWidth, getListMarkerVisualOffset, resolveListMarkerFont } from "../../layout-engine/measure/listMarkerWidth.js";
 import { DEFAULT_FONT_FAMILY, buildRunFontStyle, ptToPx } from "../../layout-engine/measure/measureHelpers.js";
 import { getFontMetrics, measureTextWidth } from "../../layout-engine/measure/measureProvider.js";
+import { SMALL_CAPS_SCALE, smallCapsSegments } from "../../layout-engine/measure/smallCapsCasing.js";
 import { calculateTabWidth, pixelsToTwips } from "../../layout-engine/measure/tabCalculator.js";
 import { countCompressibleSpaces, toPaintedText } from "../../layout-engine/measure/textMeasurementPolicy.js";
 import { isFloatingImageRun } from "../../layout-engine/types.js";
@@ -315,6 +316,39 @@ const runGlyphDirection = (run, paragraphIsRtl) => run.bidiWrapper?.direction ??
 */
 const runUnicodeBidi = (run) => run.bidiWrapper === void 0 ? void 0 : UNICODE_BIDI_BY_WRAPPER_CONTROL[run.bidiWrapper.control];
 /**
+* `glyphs` split into same-size stretches for a `w:smallCaps` run, or
+* `undefined` when it has no lowercase letter (a heading typed in caps, a run
+* of digits and punctuation): that run paints as the single glyph run it
+* always did, no backend work spent on a split it does not need.
+*
+* Every backend draws one glyph size per `glyphRun` (a PDF's `Tf` sets the
+* whole text-showing operation's size; a DOM span sets one `font-size`), so a
+* mixed-size run becomes a short run of primitives instead of one primitive
+* with glyphs a backend cannot all draw at the size it is told. `advancesPx`
+* is sliced from the already-measured run — the widths line breaking decided
+* on — never re-measured, so the split cannot disagree with the width the
+* line was fitted at.
+*/
+const smallCapsGlyphRunSegments = (glyphs, fontSizePx) => {
+	const segments = smallCapsSegments(glyphs.text);
+	if (!segments.some((segment) => segment.small)) return;
+	const smallFontSizePx = fontSizePx * SMALL_CAPS_SCALE;
+	const result = [];
+	let advanceIndex = 0;
+	for (const segment of segments) {
+		const codePointCount = [...segment.text].length;
+		const advancesPx = glyphs.advancesPx.slice(advanceIndex, advanceIndex + codePointCount);
+		advanceIndex += codePointCount;
+		result.push({
+			text: segment.text,
+			fontSizePx: segment.small ? smallFontSizePx : fontSizePx,
+			advancesPx,
+			widthPx: advancesPx.reduce((sum, advance) => sum + advance, 0)
+		});
+	}
+	return result;
+};
+/**
 * One `glyphRun` plus everything painted around it: the run's background rect
 * first, then the glyphs, then the decorations whose geometry CSS would have
 * derived from the font.
@@ -380,20 +414,43 @@ const emitGlyphRun = ({ sink, context, run, glyphs, style, paintXPx, baselineYPx
 		pattern: "solid"
 	} : void 0;
 	const unicodeBidi = runUnicodeBidi(run);
-	sink.glyphs.push({
-		kind: "glyphRun",
+	const direction = runGlyphDirection(run, isRtl);
+	const commonFields = {
 		font,
-		fontSizePx,
 		color,
-		xPx: paintXPx,
 		baselineYPx: runBaselineYPx,
-		...glyphRunText(glyphs),
-		direction: runGlyphDirection(run, isRtl),
+		direction,
 		...unicodeBidi === void 0 ? {} : { unicodeBidi },
 		...stroke === void 0 ? {} : { stroke },
 		...pmRange === void 0 ? {} : { pmRange },
 		...collapsedEdge === void 0 ? {} : { collapsedEdge }
+	};
+	const smallCapsRuns = style.fontVariant === "small-caps" && direction === "ltr" ? smallCapsGlyphRunSegments(glyphs, fontSizePx) : void 0;
+	if (smallCapsRuns === void 0) sink.glyphs.push({
+		kind: "glyphRun",
+		fontSizePx,
+		xPx: paintXPx,
+		...glyphRunText(glyphs),
+		...commonFields
 	});
+	else {
+		const adjustments = glyphs.adjustments === void 0 ? {} : { adjustments: glyphs.adjustments };
+		let segmentXPx = paintXPx;
+		for (const segment of smallCapsRuns) {
+			sink.glyphs.push({
+				kind: "glyphRun",
+				fontSizePx: segment.fontSizePx,
+				xPx: segmentXPx,
+				text: segment.text,
+				advancesPx: segment.advancesPx,
+				kerning: glyphs.kerning,
+				smallCaps: true,
+				...adjustments,
+				...commonFields
+			});
+			segmentXPx += segment.widthPx;
+		}
+	}
 	emitDecorations({
 		sink,
 		run,
@@ -506,7 +563,6 @@ const emitDecorations = ({ sink, run, color, context, xPx, glyphs, baselineYPx,
 */
 const reportRunEffects = (run, context) => {
 	const { unsupported, pageIndex } = context;
-	if (run.smallCaps) unsupported.report(UNSUPPORTED_CONSTRUCT.smallCaps, pageIndex, "w:smallCaps is carried on the run and painted by the DOM backend; the PDF backend paints full-size glyphs for it");
 	if (getHorizontalScaleFactor(run.horizontalScale) !== 1) unsupported.report(UNSUPPORTED_CONSTRUCT.horizontalScale, pageIndex, `w:w ${String(run.horizontalScale)}% is carried on the run and painted by the DOM backend; the PDF backend paints unnarrowed glyphs at the measured advances`);
 	if (run.textEffect) unsupported.report(UNSUPPORTED_CONSTRUCT.textEffect, pageIndex, `w:effect ${run.textEffect}`);
 	if (run.emphasisMark) unsupported.report(UNSUPPORTED_CONSTRUCT.emphasisMark, pageIndex, `w:em ${run.emphasisMark}`);

package/dist/display-list/build/textBoxPrimitives.js

@@ -64,7 +64,7 @@ const paintUnrotatedTextBoxFragment = ({ composer, fragment, block, measure, con
 			fill
 		});
 		else context.unsupported.report(UNSUPPORTED_CONSTRUCT.unresolvedColor, context.pageIndex, `text box fill ${block.fillColor}`);
-	}
+	} else if (block.fillGradient) context.unsupported.report(UNSUPPORTED_CONSTRUCT.textBoxGradientFill, context.pageIndex, "text box gradient fill");
 	let outlineWidthPx = 0;
 	const outlineDash = presetDashForOutlineAttr(block.outlineStyle) ?? "solid";
 	if (block.outlineWidth !== void 0 && block.outlineWidth > 0 && outlineDash !== "none") {