@stll/folio-core 0.46.0 → 0.47.1

package/dist/compare/content-alignment.js

@@ -1,3 +1,4 @@
+import { alignParagraphOrdinals } from "../docx/paraIdAttribute.js";
 import { alignTableColumns } from "./column-alignment.js";
 import { panic } from "better-result";
 //#region src/compare/content-alignment.ts
@@ -273,6 +274,44 @@ const pairsInAnchorGaps = ({ baseLength, revisedLength, anchors, pairGap }) => {
 	}
 	return pairs;
 };
+/**
+* Blocks the anchor passes left unpaired whose exact text stands, also
+* unpaired, on the other side.
+*
+* Anchoring is monotone, so content that moved past other content leaves one
+* of its two correspondences unanchored by construction: two paragraphs that
+* swap places produce two exact candidates that cross, and only one survives
+* the increasing subsequence. What is left over is both ends of that crossing.
+* It is not a paragraph rewritten into another, so the positional fallback
+* must not fuse them: a relocation would come back as a replacement neither
+* document contains, and the move pass would never see the removal and the
+* arrival it is there to pair.
+*/
+const crossedExactTextBlocks = ({ base, revised, anchors, canPair }) => {
+	const uniqueUnanchoredByText = (blocks, anchored) => {
+		const blocksByText = /* @__PURE__ */ new Map();
+		for (const block of blocks) {
+			if (anchored.has(block.index) || !NON_WHITESPACE.test(block.block.text)) continue;
+			const { text } = block.block;
+			blocksByText.set(text, blocksByText.has(text) ? null : block);
+		}
+		return blocksByText;
+	};
+	const baseByText = uniqueUnanchoredByText(base, new Set(anchors.map(({ baseIndex }) => baseIndex)));
+	const revisedByText = uniqueUnanchoredByText(revised, new Set(anchors.map(({ revisedIndex }) => revisedIndex)));
+	const crossedBase = /* @__PURE__ */ new Set();
+	const crossedRevised = /* @__PURE__ */ new Set();
+	for (const [text, baseBlock] of baseByText) {
+		const revisedBlock = revisedByText.get(text);
+		if (!baseBlock || !revisedBlock || !canPair(baseBlock, revisedBlock)) continue;
+		crossedBase.add(baseBlock.index);
+		crossedRevised.add(revisedBlock.index);
+	}
+	return {
+		base: crossedBase,
+		revised: crossedRevised
+	};
+};
 const alignFolioContentBlocksInScope = (baseBlocks, revisedBlocks, options) => {
 	const stableIdMismatch = options.stableIdMismatch ?? "separate";
 	const idStability = options.idStability ?? folioContentIdStability;
@@ -322,13 +361,19 @@ const alignFolioContentBlocksInScope = (baseBlocks, revisedBlocks, options) => {
 		})
 	});
 	const anchors = [...exactAndStableAnchors, ...continuityAnchors].toSorted((left, right) => left.baseIndex - right.baseIndex || left.revisedIndex - right.revisedIndex);
+	const crossed = crossedExactTextBlocks({
+		base: prepared.base,
+		revised: prepared.revised,
+		anchors,
+		canPair
+	});
 	const events = [];
 	const emitPositionalGap = (baseFrom, baseTo, revisedFrom, revisedTo) => {
 		const pairedCount = Math.min(baseTo - baseFrom, revisedTo - revisedFrom);
 		for (let offset = 0; offset < pairedCount; offset++) {
 			const baseBlock = prepared.base[baseFrom + offset];
 			const revisedBlock = prepared.revised[revisedFrom + offset];
-			if (baseBlock && revisedBlock) if (!canPair(baseBlock, revisedBlock)) {
+			if (baseBlock && revisedBlock) if (baseBlock.block.text !== revisedBlock.block.text && crossed.base.has(baseBlock.index) && crossed.revised.has(revisedBlock.index) || !canPair(baseBlock, revisedBlock)) {
 				events.push({
 					type: "baseOnly",
 					block: baseBlock.block
@@ -437,6 +482,37 @@ const groupFolioContentTableRows = (blocks) => {
 	}
 	return [...rows.values()];
 };
+/**
+* Which uninterrupted run of its own cell each block belongs to.
+*
+* A cell holds paragraphs and nested tables, and the nested table splits the
+* cell's paragraphs into runs: the ones before it and the ones after it are
+* separate sequences, because nothing moves a block from one side of a table
+* to the other. Aligned as one sequence they pair across it, and the plan that
+* follows can neither move the base paragraph past the nested table nor delete
+* the one it left behind when that paragraph ends the cell. So the runs are
+* aligned separately, the way rows and cells already are.
+*
+* Document order is the whole input: a cell's blocks are contiguous until a
+* block of another cell interrupts them, and inside one table segment the only
+* cell that can interrupt another is one of a table nested in it.
+*/
+const cellRunOrdinals = (blocks) => {
+	const ordinals = /* @__PURE__ */ new Map();
+	const runByCell = /* @__PURE__ */ new Map();
+	let previousKey = null;
+	for (const block of blocks) {
+		const { table } = block;
+		if (!table) continue;
+		const key = `${String(table.tableIndex)}:${String(table.rowIndex)}:${String(table.cellIndex)}`;
+		const seen = runByCell.get(key) ?? -1;
+		const run = key === previousKey ? seen : seen + 1;
+		runByCell.set(key, run);
+		ordinals.set(block, run);
+		previousKey = key;
+	}
+	return ordinals;
+};
 const groupTables = (blocks) => {
 	const tables = /* @__PURE__ */ new Map();
 	for (const block of blocks) {
@@ -644,15 +720,64 @@ const stableContentSequencePairs = (base, revised) => {
 	}
 	return pairs;
 };
-const contentContainerIdentityTransition = (base, revised) => {
-	if (base === null || revised === null || base.status !== "available" || revised.status !== "available" || base.blockIds.length === 0 || base.blockIds.length !== revised.blockIds.length) return false;
-	let hasStabilityTransition = false;
-	for (let index = 0; index < base.blockIds.length; index++) {
-		if (base.blockIds[index] !== revised.blockIds[index]) return false;
-		hasStabilityTransition ||= base.idStabilities[index] !== revised.idStabilities[index];
-	}
-	return hasStabilityTransition;
+/**
+* A container's blocks as the paragraph identities the save reasons about: a
+* stable id is one the package wrote, a positional id one folio minted for a
+* paragraph that arrived without one.
+*/
+const containerParagraphIdentities = (profile) => profile.blockIds.map((paraId, ordinal) => profile.idStabilities[ordinal] === "stable" ? {
+	type: "authored",
+	paraId,
+	ordinal
+} : {
+	type: "minted",
+	paraId,
+	ordinal
+});
+/**
+* Whether two containers are the same container, read from the paragraph ids
+* their blocks carry.
+*
+* This used to ask for a positional-to-stable *transition* with identical ids
+* at every index, which is the shape a save produced when it stamped folio's
+* minted ids into the package it wrote. That made the comparison depend on a
+* side effect of the save rather than on the documents in front of it: once a
+* save stopped persisting a minted id, both sides read positional, the
+* transition never fired, and an edited row was reported deleted and inserted
+* instead of edited.
+*
+* The question is the one {@link alignParagraphOrdinals} answers, and it is
+* asked through the owner the save asks it through, so the two cannot come to
+* disagree about which paragraph is which. A comparison sees two different
+* documents, so absence of contradiction is not enough on its own: most of the
+* container has to actively confirm the ordinals, or every container of equal
+* size would pair with every other on the strength of saying nothing. A
+* positional id is derived from the paragraph's own text and position, so an
+* unedited block keeps it across the edit and supplies that confirmation, while
+* an edited block's id changes with its text. A majority is therefore "the
+* blocks this edit did not touch", and it is what separates a row with an edit
+* in it from a row replaced by a different row, which shares no id at all.
+*
+* This signal only has to carry the containers similarity cannot reach: a pair
+* it declines is still weighed on content, so a two-block container with one
+* block edited pairs on the half it kept rather than on a bare majority.
+*/
+const contentContainersShareIdentity = (base, revised) => {
+	if (base === null || revised === null || base.status !== "available" || revised.status !== "available" || base.blockIds.length === 0) return false;
+	const alignment = alignParagraphOrdinals(containerParagraphIdentities(base), containerParagraphIdentities(revised));
+	return alignment.consistent && alignment.sharedOrdinals * 2 > base.blockIds.length;
 };
+/**
+* Whether two containers carry the same block ids in the same order, over
+* their whole length.
+*
+* Stricter than {@link contentContainersShareIdentity}, which answers which
+* container this is while blocks come and go. This answers whether there is
+* anything left to decide: nothing moved within either container, so paired
+* with equal content they are one container seen twice. An identity a cap
+* withheld is unknown, never equal.
+*/
+const contentContainerIdsAreEqual = (base, revised) => base !== null && revised !== null && base.status === "available" && revised.status === "available" && base.blockIds.length > 0 && base.blockIds.length === revised.blockIds.length && base.blockIds.every((id, index) => id === revised.blockIds[index]);
 const uniqueExactContentSequencePairs = ({ baseKeys, revisedKeys }) => {
 	const uniqueIndexes = (keys) => {
 		const indexes = /* @__PURE__ */ new Map();
@@ -723,7 +848,7 @@ const persistedContentSequencePairs = ({ base, revised, anchors, canPair }) => {
 			baseIndex,
 			revisedIndex
 		};
-		if (revisedItem && canPair(baseItem, revisedItem) && contentContainerIdentityTransition(baseItem.profile.containerIdentity, revisedItem.profile.containerIdentity) && pairIsCompatibleWithAnchors(pair, anchors)) candidates.push(pair);
+		if (revisedItem && canPair(baseItem, revisedItem) && contentContainersShareIdentity(baseItem.profile.containerIdentity, revisedItem.profile.containerIdentity) && pairIsCompatibleWithAnchors(pair, anchors)) candidates.push(pair);
 	}
 	return new Set(monotoneContentSequencePairs(candidates).map(({ baseIndex, revisedIndex }) => baseIndex * revised.length + revisedIndex));
 };
@@ -742,7 +867,7 @@ const alignProfiledContentSequence = ({ base, revised, workSession, canPair = ()
 		const revisedProfile = revised[index]?.profile;
 		if (!baseProfile || !revisedProfile) continue;
 		const hasContainerIdentity = baseProfile.containerIdentity !== null || revisedProfile.containerIdentity !== null;
-		let hasProvenanceTransition = contentContainerIdentityTransition(baseProfile.containerIdentity, revisedProfile.containerIdentity);
+		let hasProvenanceTransition = contentContainersShareIdentity(baseProfile.containerIdentity, revisedProfile.containerIdentity);
 		if (!hasContainerIdentity) {
 			const revisedIds = new Set(revisedProfile.blockIds);
 			const baseStableIds = new Set(baseProfile.stableIds);
@@ -861,6 +986,7 @@ const alignProfiledContentSequence = ({ base, revised, workSession, canPair = ()
 	let revisedIndex = 0;
 	let pairCount = 0;
 	let solePairIsShifted = false;
+	let solePairIsIdentity = false;
 	let hasBaseOnly = false;
 	let hasRevisedOnly = false;
 	while (baseIndex < base.length && revisedIndex < revised.length) {
@@ -875,6 +1001,7 @@ const alignProfiledContentSequence = ({ base, revised, workSession, canPair = ()
 			});
 			pairCount += 1;
 			solePairIsShifted = baseIndex !== revisedIndex;
+			solePairIsIdentity = baseExactSignatureKeys[baseIndex] === revisedExactSignatureKeys[revisedIndex] && contentContainerIdsAreEqual(base[baseIndex]?.profile.containerIdentity ?? null, revised[revisedIndex]?.profile.containerIdentity ?? null);
 			baseIndex += 1;
 			revisedIndex += 1;
 		} else if (direction === ALIGNMENT_DIRECTION.revisedOnly && revisedItem !== void 0) {
@@ -907,7 +1034,7 @@ const alignProfiledContentSequence = ({ base, revised, workSession, canPair = ()
 		});
 		hasRevisedOnly = true;
 	}
-	if ((soleShiftedPairResiduePolicy === "conservative" || base.length === revised.length) && pairCount === 1 && solePairIsShifted && hasBaseOnly && hasRevisedOnly) return aligned.flatMap((entry) => entry.type === "pair" ? [{
+	if (!solePairIsIdentity && (soleShiftedPairResiduePolicy === "conservative" || base.length === revised.length) && pairCount === 1 && solePairIsShifted && hasBaseOnly && hasRevisedOnly) return aligned.flatMap((entry) => entry.type === "pair" ? [{
 		type: "baseOnly",
 		item: entry.base
 	}, {
@@ -917,7 +1044,7 @@ const alignProfiledContentSequence = ({ base, revised, workSession, canPair = ()
 	return aligned;
 };
 const rowLocation = (row) => row.at(0)?.table ?? null;
-const alignRowCells = ({ baseRow, revisedRow, workSession, moveScopeContext, stableIdMismatch, idStability, baseColumnKeys, revisedColumnKeys }) => {
+const alignRowCells = ({ baseRow, revisedRow, workSession, moveScopeContext, stableIdMismatch, idStability, baseColumnKeys, revisedColumnKeys, cellRuns }) => {
 	const byCell = (row, columnKeys) => {
 		const cells = /* @__PURE__ */ new Map();
 		for (const block of row) {
@@ -928,47 +1055,62 @@ const alignRowCells = ({ baseRow, revisedRow, workSession, moveScopeContext, sta
 				if (alignedColumn === void 0) return panic("A paired table cell has no aligned grid column", { gridColumnIndex: table.gridColumnIndex });
 				cellIndex = alignedColumn;
 			}
-			const blocks = cells.get(cellIndex);
+			const runs = cells.get(cellIndex) ?? /* @__PURE__ */ new Map();
+			cells.set(cellIndex, runs);
+			const run = cellRuns.get(block) ?? 0;
+			const blocks = runs.get(run);
 			if (blocks) blocks.push(block);
-			else cells.set(cellIndex, [block]);
+			else runs.set(run, [block]);
 		}
 		return cells;
 	};
+	const ascending = (left, right) => left - right;
 	const baseCells = byCell(baseRow, baseColumnKeys);
 	const revisedCells = byCell(revisedRow, revisedColumnKeys);
-	const cellIndexes = [.../* @__PURE__ */ new Set([...baseCells.keys(), ...revisedCells.keys()])].toSorted((left, right) => left - right);
+	const cellIndexes = [.../* @__PURE__ */ new Set([...baseCells.keys(), ...revisedCells.keys()])].toSorted(ascending);
 	const steps = [];
 	for (const cellIndex of cellIndexes) {
-		const baseBlocks = baseCells.get(cellIndex) ?? [];
-		const revisedBlocks = revisedCells.get(cellIndex) ?? [];
-		const aligned = alignFolioContentBlocksInScope(baseBlocks, revisedBlocks, {
+		const baseRuns = baseCells.get(cellIndex) ?? /* @__PURE__ */ new Map();
+		const revisedRuns = revisedCells.get(cellIndex) ?? /* @__PURE__ */ new Map();
+		const runOrdinals = [.../* @__PURE__ */ new Set([...baseRuns.keys(), ...revisedRuns.keys()])].toSorted(ascending);
+		for (const run of runOrdinals) steps.push(...alignCellRun({
+			baseBlocks: baseRuns.get(run) ?? [],
+			revisedBlocks: revisedRuns.get(run) ?? [],
 			workSession,
-			idStability,
+			moveScopeContext,
 			stableIdMismatch,
-			structuralScope: "pairedTableCell"
-		}).flatMap((event) => {
-			if (event.type === "pair" && !contentBlocksShareContainerPath(event.baseBlock, event.revisedBlock)) return [{
-				type: "baseOnly",
-				block: event.baseBlock
-			}, {
-				type: "revisedOnly",
-				block: event.revisedBlock
-			}];
-			return [event];
-		});
-		const bucketByContainerPath = /* @__PURE__ */ new Map();
-		const bucketForBlock = (block) => {
-			const path = containerPathKeyOf(block);
-			const existing = bucketByContainerPath.get(path);
-			if (existing !== void 0) return existing;
-			const bucket = moveScopeContext.nextTableCellBucket++;
-			bucketByContainerPath.set(path, bucket);
-			return bucket;
-		};
-		steps.push(...scopedAlignmentSteps(aligned, moveScopeContext, bucketForBlock));
+			idStability
+		}));
 	}
 	return steps;
 };
+const alignCellRun = ({ baseBlocks, revisedBlocks, workSession, moveScopeContext, stableIdMismatch, idStability }) => {
+	const aligned = alignFolioContentBlocksInScope(baseBlocks, revisedBlocks, {
+		workSession,
+		idStability,
+		stableIdMismatch,
+		structuralScope: "pairedTableCell"
+	}).flatMap((event) => {
+		if (event.type === "pair" && !contentBlocksShareContainerPath(event.baseBlock, event.revisedBlock)) return [{
+			type: "baseOnly",
+			block: event.baseBlock
+		}, {
+			type: "revisedOnly",
+			block: event.revisedBlock
+		}];
+		return [event];
+	});
+	const bucketByContainerPath = /* @__PURE__ */ new Map();
+	const bucketForBlock = (block) => {
+		const path = containerPathKeyOf(block);
+		const existing = bucketByContainerPath.get(path);
+		if (existing !== void 0) return existing;
+		const bucket = moveScopeContext.nextTableCellBucket++;
+		bucketByContainerPath.set(path, bucket);
+		return bucket;
+	};
+	return scopedAlignmentSteps(aligned, moveScopeContext, bucketForBlock);
+};
 const pairTableRows = ({ baseRows, revisedRows, workSession, idStability }) => {
 	const profile = (row) => ({
 		item: row,
@@ -1001,7 +1143,7 @@ const pairTableRows = ({ baseRows, revisedRows, workSession, idStability }) => {
 		}
 	});
 };
-const alignTableRows = ({ rows, workSession, moveScopeContext, stableIdMismatch, idStability, baseColumnKeys, revisedColumnKeys }) => {
+const alignTableRows = ({ rows, workSession, moveScopeContext, stableIdMismatch, idStability, baseColumnKeys, revisedColumnKeys, cellRuns }) => {
 	const steps = [];
 	const pushRow = (row, side) => {
 		const location = rowLocation(row);
@@ -1027,7 +1169,8 @@ const alignTableRows = ({ rows, workSession, moveScopeContext, stableIdMismatch,
 				stableIdMismatch,
 				idStability,
 				baseColumnKeys,
-				revisedColumnKeys
+				revisedColumnKeys,
+				cellRuns
 			}));
 			break;
 		default: panic("Unhandled table row alignment", { alignment });
@@ -1052,7 +1195,7 @@ const rowCellSpansEqual = (baseRow, revisedRow) => {
 	});
 };
 const rowHasVerticalSpan = (row) => row.some(({ table }) => table !== void 0 && table.rowSpan > 1);
-const buildTablePlan = ({ baseBlocks, revisedBlocks, workSession, moveScopeContext, stableIdMismatch, idStability }) => {
+const buildTablePlan = ({ baseBlocks, revisedBlocks, workSession, moveScopeContext, stableIdMismatch, idStability, cellRuns }) => {
 	const resolveIdStability = idStability ?? folioContentIdStability;
 	const columns = alignTableColumns(baseBlocks, revisedBlocks);
 	const rows = pairTableRows({
@@ -1073,13 +1216,15 @@ const buildTablePlan = ({ baseBlocks, revisedBlocks, workSession, moveScopeConte
 			stableIdMismatch,
 			idStability: resolveIdStability,
 			baseColumnKeys: columns?.baseColumnKeys,
-			revisedColumnKeys: columns?.revisedColumnKeys
+			revisedColumnKeys: columns?.revisedColumnKeys,
+			cellRuns
 		})]
 	};
 };
 const buildTableSegmentPlan = ({ baseBlocks, revisedBlocks, workSession, moveScopeContext, stableIdMismatch, idStability }) => {
 	const baseTables = groupTables(baseBlocks);
 	const revisedTables = groupTables(revisedBlocks);
+	const cellRuns = new Map([...cellRunOrdinals(baseBlocks), ...cellRunOrdinals(revisedBlocks)]);
 	const resolveIdStability = idStability ?? folioContentIdStability;
 	const profile = (blocks) => ({
 		item: blocks,
@@ -1101,7 +1246,8 @@ const buildTableSegmentPlan = ({ baseBlocks, revisedBlocks, workSession, moveSco
 				workSession,
 				moveScopeContext,
 				stableIdMismatch,
-				idStability: resolveIdStability
+				idStability: resolveIdStability,
+				cellRuns
 			});
 			steps.push(...table.steps);
 			representable &&= table.representable;

package/dist/compare/content-types.d.ts

@@ -1,3 +1,4 @@
+import { document_d_exports } from "../types/document.js";
 //#region src/compare/content-types.d.ts
 /** How callers expect a block identifier to behave across document revisions. */
 type FolioContentIdStability = "stable" | "positional";
@@ -74,8 +75,13 @@ type FolioContentTableLocation = {
   rowSpan: number;
   paragraphIndex: number;
 };
-/** Direct paragraph alignment understood by the neutral comparison model. */
-type FolioContentParagraphAlignment = "left" | "center" | "right" | "both" | "distribute" | "mediumKashida" | "highKashida" | "lowKashida" | "thaiDistribute";
+/**
+ * Direct paragraph alignment understood by the neutral comparison model.
+ *
+ * The model's own `ST_Jc` union: a copy spelled here would refuse an alignment
+ * a parsed document carries.
+ */
+type FolioContentParagraphAlignment = document_d_exports.ParagraphAlignment;
 /** Line-height interpretation understood by the neutral comparison model. */
 type FolioContentLineSpacingRule = "auto" | "exact" | "atLeast";
 /** The complete modeled attribute set of direct paragraph indentation. */

package/dist/compare/content.js

@@ -1,5 +1,6 @@
 import { WORD_DIFF_GRANULARITIES, createWordDiffSession } from "../ai-edits/word-diff.js";
 import { paragraphIndentationEqual } from "../prosemirror/paragraphIndentation.js";
+import { PARAGRAPH_ALIGNMENT_VALUES } from "../types/documentEnumValues.js";
 import { alignFolioContentStructure, contentBlocksShareContainer, createFolioContentAlignmentWorkSession } from "./content-alignment.js";
 import { inlineFormattingSegments } from "./formatting.js";
 import { Result, TaggedError, panic } from "better-result";
@@ -67,17 +68,7 @@ const isFiniteInteger = (value) => typeof value === "number" && Number.isSafeInt
 const isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value);
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const hasRecordShape = (value) => isRecord(value);
-const PARAGRAPH_ALIGNMENTS = /* @__PURE__ */ new Set([
-	"left",
-	"center",
-	"right",
-	"both",
-	"distribute",
-	"mediumKashida",
-	"highKashida",
-	"lowKashida",
-	"thaiDistribute"
-]);
+const PARAGRAPH_ALIGNMENTS = new Set(PARAGRAPH_ALIGNMENT_VALUES);
 const validateRunFormatting = (block, side, blockIndex) => {
 	for (const [runIndex, run] of (block.previewRuns ?? []).entries()) {
 		if (run.directFormatting !== void 0 && !isRecord(run.directFormatting)) return invalidInput(side, `blocks[${String(blockIndex)}].previewRuns[${String(runIndex)}].directFormatting`, "Direct inline formatting must be an object.", blockIndex);

package/dist/compare/plan.js

@@ -178,16 +178,19 @@ const terminalCarrierIsStranded = (steps, baseBlocks) => {
 * back over the next paragraph. The applier rotates instead — the paragraph
 * the run was appended after takes the inserted mark, and the last one takes
 * the free mark — and that rotation reaches only across paragraphs. A table
-* among them stops it, and the words the target ends with have to be written
-* into the base's own last paragraph instead.
+* among them stops it, and so does removing the paragraph the rotation turns
+* on: a run appended after a paragraph that is itself deleted has no mark to
+* take. Either way the words the target ends with have to be written into the
+* base's own last paragraph instead.
 */
 const addedTerminalCarrierIsStranded = (steps, baseBlocks, targetBlocks) => {
 	const baseLast = baseBlocks.at(-1);
 	const targetLast = targetBlocks.at(-1);
 	if (baseLast === void 0 || targetLast === void 0) return false;
 	if (!steps.some((step) => step.type === "targetOnly" && step.block.id === targetLast.id)) return false;
-	const baseLastStep = steps.findIndex((step) => step.type === "pair" && step.baseBlock.id === baseLast.id || step.type === "baseOnly" && step.block.id === baseLast.id);
-	return baseLastStep === -1 || steps.slice(baseLastStep + 1).some((step) => step.type !== "targetOnly");
+	const baseLastStepIndex = steps.findIndex((step) => step.type === "pair" && step.baseBlock.id === baseLast.id || step.type === "baseOnly" && step.block.id === baseLast.id);
+	const baseLastStep = steps[baseLastStepIndex];
+	return baseLastStep === void 0 || baseLastStep.type === "baseOnly" || steps.slice(baseLastStepIndex + 1).some((step) => step.type !== "targetOnly");
 };
 const buildSteps = ({ baseSnapshot, targetSnapshot, wholeTableReplacement, workSession }) => {
 	const baseBlocks = baseSnapshot.blocks;

package/dist/compare/section-boundary-properties.js

@@ -220,8 +220,7 @@ const stageSectionBoundaryProperties = ({ state, target, originalRevisionIdSeed,
 			_sectionProperties: {
 				...update.target,
 				...propertyChanges === void 0 ? {} : { propertyChanges }
-			},
-			sectionBreakType: update.target.sectionStart ?? null
+			}
 		});
 	}
 	return {

package/dist/content-controls/checkboxDisplay.d.ts

@@ -5,7 +5,13 @@ type CheckboxDisplayContent = Extract<document_d_exports.RunContent, {
 } | {
   type: "text";
 }>;
-/** Resolve the authored checkbox state into the run payload Word expects. */
-declare const checkboxDisplayContent: (rawPropertiesXml: string | undefined, checked: boolean) => CheckboxDisplayContent;
+/**
+ * Resolve the authored checkbox state into the run payload Word expects.
+ *
+ * @param checkboxXml the preserved `w14:checkbox` element, from
+ *   `SdtProperties.preserved`. A control that carries none — one built in
+ *   code, or one whose author wrote no glyphs — gets Word's own defaults.
+ */
+declare const checkboxDisplayContent: (checkboxXml: string | undefined, checked: boolean) => CheckboxDisplayContent;
 //#endregion
 export { checkboxDisplayContent };

package/dist/content-controls/checkboxDisplay.js

@@ -11,16 +11,22 @@ const defaultDisplay = (checked) => ({
 	char: checked ? DEFAULT_CHECKED_CHARACTER : DEFAULT_UNCHECKED_CHARACTER,
 	font: DEFAULT_CHECKBOX_FONT
 });
-/** Resolve the authored checkbox state into the run payload Word expects. */
-const checkboxDisplayContent = (rawPropertiesXml, checked) => {
-	if (!rawPropertiesXml || rawPropertiesXml.length > MAX_CHECKBOX_PROPERTIES_CHARACTERS) return defaultDisplay(checked);
+/**
+* Resolve the authored checkbox state into the run payload Word expects.
+*
+* @param checkboxXml the preserved `w14:checkbox` element, from
+*   `SdtProperties.preserved`. A control that carries none — one built in
+*   code, or one whose author wrote no glyphs — gets Word's own defaults.
+*/
+const checkboxDisplayContent = (checkboxXml, checked) => {
+	if (!checkboxXml || checkboxXml.length > MAX_CHECKBOX_PROPERTIES_CHARACTERS) return defaultDisplay(checked);
 	let root;
 	try {
-		root = parseXml(rawPropertiesXml, OOXML_NAMESPACE_SCOPE);
+		root = parseXml(checkboxXml, OOXML_NAMESPACE_SCOPE);
 	} catch {
 		return defaultDisplay(checked);
 	}
-	const state = findChildByNamespaceUri(findChildByNamespaceUri(findChildByNamespaceUri(root, WORDPROCESSINGML_NAMESPACE_URIS, "sdtPr"), CHECKBOX_NAMESPACE_URIS, "checkbox"), CHECKBOX_NAMESPACE_URIS, checked ? "checkedState" : "uncheckedState");
+	const state = findChildByNamespaceUri(findChildByNamespaceUri(root, CHECKBOX_NAMESPACE_URIS, "checkbox"), CHECKBOX_NAMESPACE_URIS, checked ? "checkedState" : "uncheckedState");
 	const rawCharacter = getAttributeByNamespaceUri(state, CHECKBOX_NAMESPACE_URIS, "val");
 	if (!rawCharacter || !HEX_CODE_POINT.test(rawCharacter)) return defaultDisplay(checked);
 	const codePoint = Number.parseInt(rawCharacter, 16);