@stll/folio-core 0.66.1 → 0.66.2

package/dist/ai-edits/apply.js

@@ -1,3 +1,4 @@
+import { NO_NUMBERING_IDS_IN_USE } from "../docx/numberingIds.js";
 import { isNumberingReference } from "../docx/numberingReference.js";
 import { formattingEquals } from "../docx/runConsolidator.js";
 import { isStyleSourcedParagraphNumbering } from "../internal/paragraphFormattingSerialization.js";
@@ -20,7 +21,7 @@ import { directParagraphAlignment } from "../prosemirror/paragraphAlignment.js";
 import { styleResolvedParagraphFormatting } from "../prosemirror/paragraphFormattingProvenance.js";
 import { directParagraphIndentation, paragraphIndentationAttrPatch, paragraphIndentationEqual, paragraphIndentationFromFormatting, withDirectParagraphIndentation } from "../prosemirror/paragraphIndentation.js";
 import { joinAtParagraphMark } from "../prosemirror/paragraphMarkJoin.js";
-import { carriedParagraphProperties, carryParagraphProperties, paragraphLeftAfter, propertiesSetInBatch, recordReplacedParagraphProperties } from "../prosemirror/paragraphPropertyCarry.js";
+import { carryParagraphProperties, paragraphLeftAfter, recordReplacedParagraphProperties } from "../prosemirror/paragraphPropertyCarry.js";
 import { directParagraphSpacing, paragraphSpacingAttrPatch, paragraphSpacingEqual, paragraphSpacingFromFormatting, withDirectParagraphSpacing } from "../prosemirror/paragraphSpacing.js";
 import { getDocumentNumbering, getDocumentNumberingInstanceIds } from "../prosemirror/plugins/documentNumbering.js";
 import { getDocumentStyleDefinitions, getDocumentStyleResolver } from "../prosemirror/plugins/documentStyleState.js";
@@ -34,6 +35,7 @@ import { paragraphRunStyleContext, paragraphRunStyleContextAt, resolveParagraphB
 import { sectionPropertiesOf } from "../prosemirror/sectionCarrier.js";
 import { listAttrsFromNumbering, listLevelAttrPatch, listLevelIndentRemovalPatch } from "../prosemirror/styles/resolvedStyleAttrs.js";
 import { removeRowsWithoutCellsAfterBatch } from "../prosemirror/tableGridMutation.js";
+import { runInCellPending } from "../prosemirror/tableRunIn.js";
 import { isZeroWidthAnchor } from "../prosemirror/zeroWidthAnchors.js";
 import { getFolioParaIdFromBlockId } from "../types/block-id.js";
 import { CANONICAL_GAP } from "../types/canonicalCapabilities.js";
@@ -59,7 +61,7 @@ import { panic } from "better-result";
 import { Fragment, Mark } from "prosemirror-model";
 import { TableMap } from "prosemirror-tables";
 import { canSplit } from "prosemirror-transform";
-import { contentRank, groupInsertionRuns, orderBatchOperations } from "@stll/docx-core/ops";
+import { contentRank, deletionRemovesBlock, groupInsertionRuns, orderAddressingBeforeRemoval, orderBatchOperations } from "@stll/docx-core/ops";
 // src/ai-edits/apply.ts
 const coarseWordDiff = (before, after) => {
 	if (before === after) return before.length === 0 ? [] : [{
@@ -377,8 +379,8 @@ const withoutRevisionsOnZeroWidthAnchors = (tr, batchRevisionIds, deletedTextBox
 * text box's anchor is the exception: it stands for the box's drawing run,
 * which is the paragraph's content, and the box follows it.
 */
-const undeletedContentAtomRanges = (tr, blockFrom) => {
-	const position = tr.mapping.map(blockFrom);
+const undeletedContentAtomRanges = (tr, blockFrom, readAt) => {
+	const position = tr.mapping.slice(readAt).map(blockFrom);
 	const block = tr.doc.nodeAt(position);
 	if (!block?.isTextblock) return [];
 	const ranges = [];
@@ -567,7 +569,7 @@ const applyReplaceBlockStyleId = ({ item, tr, styleResolver, revisionInfo }) =>
 		revisionId: null,
 		revisionIds: []
 	};
-	const blockPosition = tr.mapping.map(item.blockFrom, -1);
+	const blockPosition = sinceRead(tr, item).map(item.blockFrom, -1);
 	const block = tr.doc.nodeAt(blockPosition);
 	if (!block) return {
 		tr,
@@ -1039,6 +1041,28 @@ const foldedBlankCellRanges = (doc, { tablePosition, rectangle }) => {
 		}] : [];
 	});
 };
+/**
+* The paragraphs before `paragraph`, which ends its container, nearest first,
+* up to the container's start or another block, past those that go whole, as
+* `finalParagraphPredecessor` looks past them. See the `deleteBlock` claim's
+* `paragraphsBefore`.
+*/
+const paragraphsBeforeFinal = ($paragraph, paragraph) => {
+	const paragraphs = [];
+	let position = $paragraph.pos;
+	for (let index = $paragraph.index() - 1; index >= 0; index--) {
+		const node = $paragraph.parent.child(index);
+		position -= node.nodeSize;
+		if (node.type !== paragraph.type) break;
+		const mark = node.attrs["pPrMark"];
+		if (isPlainDeletedPPrMark(mark) && holdsOnlyDeletedContent(node)) continue;
+		paragraphs.push({
+			block: position,
+			keepsBreak: mark == null
+		});
+	}
+	return paragraphs;
+};
 /** What `item` claims of the document its batch resolved against; see `batch-claims.ts`. */
 const batchClaimOf = ({ item, doc, producesTrackedChanges }) => {
 	const block = item.blockFrom;
@@ -1090,7 +1114,9 @@ const batchClaimOf = ({ item, doc, producesTrackedChanges }) => {
 				type: "deleteBlock",
 				block,
 				end: item.blockTo,
-				keepsParagraph
+				keepsParagraph,
+				endsContainer: endsItsContainer,
+				paragraphsBefore: producesTrackedChanges && endsItsContainer ? paragraphsBeforeFinal(at, item.blockNode) : []
 			};
 		}
 		case "insertAfterBlock":
@@ -1308,22 +1334,253 @@ const rebuiltBlockContent = ({ doc, blockFrom, blockTo, content }) => annotatedR
 }).fragment;
 const isBatchableParagraphInsertion = (item, mode) => {
 	if (item.operation.type !== "insertAfterBlock" && item.operation.type !== "insertBeforeBlock") return false;
+	if (item.joinSide !== void 0) return false;
 	if (item.commentText !== void 0) return false;
 	const insertTexts = item.insertTexts ?? [""];
 	const isEmptyInsert = insertTexts.length === 1 && insertTexts[0]?.length === 0;
 	return !(mode === "tracked-changes" && item.operation.pageBreakBefore === true && isEmptyInsert);
 };
-const insertionWithLiveAnchor = (item, tr) => {
+const insertionWithLiveAnchor = (item, tr, joinedInto) => {
 	if (item.operation.type !== "insertAfterBlock" && item.operation.type !== "insertBeforeBlock") panic("Only paragraph insertions have insertion anchors", { operationId: item.operation.id });
-	const mapped = tr.mapping.mapResult(item.blockFrom, 1);
+	const mapped = liveBlockResult(tr, item, 1);
 	const anchor = mapped.deletedAcross ? null : tr.doc.nodeAt(mapped.pos);
-	const paraId = item.blockNode.attrs["paraId"];
+	let paraId = item.blockNode.attrs["paraId"];
+	while (typeof paraId === "string" && joinedInto.has(paraId)) paraId = joinedInto.get(paraId);
 	if (!anchor?.isTextblock || anchor.type !== item.blockNode.type || typeof paraId === "string" && anchor.attrs["paraId"] !== paraId) return null;
 	return {
 		...item,
 		blockNode: anchor
 	};
 };
+/** Operations that place a block in a gap between blocks. */
+const BLOCK_INSERTION_TYPES = /* @__PURE__ */ new Set([
+	"insertAfterBlock",
+	"insertBeforeBlock",
+	"insertTable",
+	"insertSignatureTable"
+]);
+/** The steps of `tr` since `item` read its positions. */
+const sinceRead = (tr, item) => tr.mapping.slice(item.readAt ?? 0);
+/**
+* Where the block `item` names stands now, mapped from the document the
+* batch read, so the result also says whether an earlier step deleted it.
+*/
+const liveBlockResult = (tr, item, assoc) => tr.mapping.mapResult(item.batchBlockFrom ?? item.blockFrom, assoc);
+/**
+* `item` with its positions read in the document as it stands now. A batch
+* runs its operations in the shared order (`orderAddressingBeforeRemoval`),
+* which can run an edit before one further left; every operation therefore
+* reads its positions through the steps already taken rather than the
+* document the batch read. A block's start stays with its content and its
+* end with what precedes it.
+*/
+const readNow = (item, tr) => {
+	const steps = tr.mapping.maps.length;
+	if ((item.readAt ?? 0) === steps) return item;
+	const mapping = sinceRead(tr, item);
+	const blockFrom = mapping.map(item.blockFrom, 1);
+	const blockTo = Math.max(blockFrom, mapping.map(item.blockTo, -1));
+	let from;
+	let to;
+	if (item.from === item.to) {
+		const side = item.from === item.blockTo || BLOCK_INSERTION_TYPES.has(item.operation.type) ? -1 : 1;
+		from = mapping.map(item.from, side);
+		to = from;
+	} else {
+		from = mapping.map(item.from, 1);
+		to = Math.max(from, mapping.map(item.to, -1));
+	}
+	return {
+		...item,
+		from,
+		to,
+		blockFrom,
+		blockTo,
+		readAt: steps
+	};
+};
+/**
+* The paragraph a pending join makes of the one at `paragraphPos`: where its
+* break is pending removal while its words stay, accepting runs them into the
+* paragraph the join leaves, which already carries the joined paragraph's
+* properties (see `carryParagraphProperties`). Null when the paragraph stands
+* alone, or goes whole as a pending deletion.
+*/
+const pendingJoinSurvivor = ({ doc, paragraphPos, cleanText, noteReferences }) => {
+	const paragraph = doc.nodeAt(paragraphPos);
+	if (paragraph?.type.name !== "paragraph" || !isDeletedPPrMark(paragraph.attrs["pPrMark"]) || isPendingDeletion(doc, paragraphPos, paragraph, cleanText)) return null;
+	const survivor = paragraphLeftAfter({
+		doc,
+		paragraphPos
+	});
+	const left = survivor === null ? null : doc.nodeAt(survivor);
+	if (survivor === null || left?.type !== paragraph.type) return null;
+	return isDeletedPPrMark(left.attrs["pPrMark"]) && isPendingDeletion(doc, survivor, left, buildCleanBlockText(left, survivor, {
+		fieldResults: "text",
+		noteReferences
+	}).text) ? null : survivor;
+};
+/**
+* The insertion with the paragraph its new paragraphs copy properties from as
+* its anchor: a paragraph a pending join runs into another reads as that one,
+* as the joined paragraph does when the merge is applied directly. A
+* suggestion is read against the document as it stands, where the join has
+* not run anything together yet, so it copies the paragraph it names.
+*/
+const insertionFormattingAnchor = ({ item, tr, mode, noteReferences }) => {
+	if (mode === "suggested") return item;
+	const position = sinceRead(tr, item).map(item.blockFrom, 1);
+	const anchor = tr.doc.nodeAt(position);
+	if (anchor?.type !== item.blockNode.type) return item;
+	const survivor = pendingJoinSurvivor({
+		doc: tr.doc,
+		paragraphPos: position,
+		cleanText: buildCleanBlockText(anchor, position, {
+			fieldResults: "text",
+			noteReferences
+		}).text,
+		noteReferences
+	});
+	const source = survivor === null ? null : tr.doc.nodeAt(survivor);
+	return source ? {
+		...item,
+		blockNode: source
+	} : item;
+};
+const keepsWords = ({ doc, paragraphPos, noteReferences }) => {
+	const paragraph = doc.nodeAt(paragraphPos);
+	if (paragraph?.type.name !== "paragraph") return false;
+	const cleanText = buildCleanBlockText(paragraph, paragraphPos, {
+		fieldResults: "text",
+		noteReferences
+	}).text;
+	return cleanText.length > 0 && !isPendingDeletion(doc, paragraphPos, paragraph, cleanText);
+};
+/**
+* Whether accepting runs the paragraph into the one its pending join leaves:
+* it keeps words, or it is empty. One whose words are all pending deletion
+* goes whole instead.
+*/
+const joinsIn = (options) => options.doc.nodeAt(options.paragraphPos)?.content.size === 0 || keepsWords(options);
+/**
+* Whether a pending join runs earlier words on to `paragraphPos`, the start of
+* a paragraph or a place between blocks: the paragraphs before it, back to one
+* that keeps words, all have their breaks pending removal.
+*/
+const joinRunsWordsInto = ({ doc, paragraphPos, noteReferences }) => {
+	const $place = doc.resolve(paragraphPos);
+	let position = paragraphPos;
+	for (let index = $place.index() - 1; index >= 0; index--) {
+		const previous = $place.parent.child(index);
+		position -= previous.nodeSize;
+		if (previous.type.name !== "paragraph" || !isDeletedPPrMark(previous.attrs["pPrMark"])) return false;
+		if (keepsWords({
+			doc,
+			paragraphPos: position,
+			noteReferences
+		})) return true;
+	}
+	return false;
+};
+/**
+* Whether a pending join runs earlier words on to `paragraphPos`, right before
+* a table. A paragraph put there cannot stand apart once accepted: keeping its
+* own break, it takes the words, and taking the deleted break from them, it
+* runs into the table's first cell. Where that cell is itself pending nothing
+* runs into it, so a paragraph right after the words can take their break and
+* stand; so can one with a paragraph going whole between it and the table.
+*/
+const joinStopsAtTableAfter = (options) => {
+	if (!joinRunsWordsInto(options)) return false;
+	const $place = options.doc.resolve(options.paragraphPos);
+	for (let index = $place.index(); index < $place.parent.childCount; index++) {
+		const next = $place.parent.child(index);
+		if (next.type.name === "paragraph") return false;
+		if (next.type.spec["tableRole"] === "table") {
+			const before = $place.nodeBefore;
+			return !runInCellPending(next) || before !== null && holdsOnlyDeletedContent(before);
+		}
+	}
+	return false;
+};
+/**
+* Where a block goes before and after the paragraph at `paragraphPos`, read
+* as the joined paragraph a pending join makes of it. A join runs the words
+* of each paragraph whose break is pending removal into the paragraph it
+* leaves, so a block put between them would take those words once accepted,
+* as the same edits applied directly never do. Where a paragraph runs into
+* one the join leaves that keeps words of its own, a block after any
+* paragraph of the join goes after the paragraph it leaves, and a block
+* before that one goes before the first paragraph the join takes in, empty
+* ones included. A join into a paragraph with no words left (an emptied
+* final carrier, or one going whole) runs nothing together, nor does a
+* paragraph going whole with no join running through it: blocks keep their
+* places.
+*/
+const pendingJoinBounds = (options) => {
+	const { doc, paragraphPos, noteReferences } = options;
+	const paragraph = doc.nodeAt(paragraphPos);
+	let after = paragraphPos;
+	if (paragraph?.type.name === "paragraph" && isDeletedPPrMark(paragraph.attrs["pPrMark"]) && (joinsIn(options) || joinRunsWordsInto(options))) {
+		const survivor = paragraphLeftAfter({
+			doc,
+			paragraphPos
+		});
+		if (survivor !== null && keepsWords({
+			doc,
+			paragraphPos: survivor,
+			noteReferences
+		})) after = survivor;
+	}
+	let before = paragraphPos;
+	if (paragraph?.type.name === "paragraph" && keepsWords(options)) {
+		let start = paragraphPos;
+		for (;;) {
+			const previous = doc.resolve(start).nodeBefore;
+			if (previous?.type !== paragraph.type || !isDeletedPPrMark(previous.attrs["pPrMark"])) break;
+			start -= previous.nodeSize;
+			if (joinsIn({
+				doc,
+				paragraphPos: start,
+				noteReferences
+			})) before = start;
+		}
+	}
+	return {
+		before,
+		after: endOfParagraphWithItsTextBoxes(doc, after)
+	};
+};
+/** Where a block insertion lands as it runs (see `joinSide`). */
+const insertionAt = ({ item, tr, noteReferences }) => {
+	if (item.joinSide === void 0) return item.from;
+	const position = sinceRead(tr, item).map(item.blockFrom, 1);
+	if (tr.doc.nodeAt(position)?.type.name !== "paragraph") return item.from;
+	return pendingJoinBounds({
+		doc: tr.doc,
+		paragraphPos: position,
+		noteReferences
+	})[item.joinSide];
+};
+/**
+* Where a block insertion lands as it runs, with the comments running across
+* that boundary. They are the ones the batch read there, so an edit that runs
+* first cannot move a comment's end out from around the block; but where an
+* earlier edit moved the join the block follows, the block lands at another
+* boundary, and carries the comments across that one.
+*/
+const insertionPlacement = (options) => {
+	const { item, tr } = options;
+	const at = insertionAt(options);
+	if (item.joinAt === void 0) return {
+		at,
+		comments: item.boundaryComments
+	};
+	return {
+		at,
+		comments: at === tr.mapping.map(item.joinAt, item.joinSide === "after" ? -1 : 1) ? item.boundaryComments : commentsAcrossBlockBoundary(tr.doc, at)
+	};
+};
 /** The comments running across both edges of the table at `tablePosition`: over all of it. */
 const commentsAcrossTable = (doc, tablePosition) => {
 	const table = doc.nodeAt(tablePosition);
@@ -1351,6 +1608,10 @@ const isInsertedPPrMark = (value) => typeof value === "object" && value !== null
 const isSuggestedParagraphInsert = (paragraph) => typeof paragraph.attrs["_suggestedInsert"] === "object" && paragraph.attrs["_suggestedInsert"] !== null;
 /** A paragraph mark that is a pending deletion, or a relocation's source. */
 const isDeletedPPrMark = (value) => typeof value === "object" && value !== null && "kind" in value && (value.kind === "del" || value.kind === "moveFrom");
+const pendingJoinInsertionRefusal = {
+	reason: "pendingParagraphMarkDeletion",
+	message: "Accepting the pending paragraph mark deletion before this place would run the paragraph together with the words before it or the table after it. Resolve that change first, or insert elsewhere."
+};
 const pendingParagraphMarkPropertyRefusal = {
 	reason: "pendingParagraphMarkDeletion",
 	canonicalRefusal: { gap: CANONICAL_GAP.publicPendingParagraphMarkProperties },
@@ -1614,6 +1875,20 @@ const deletedFinalParagraphAfter = (at, paragraphTypeName, insertedBy) => {
 	}
 	return null;
 };
+/** Whether every row of `node` is a table row one insertion revision of this batch added. */
+const isWhollyInsertedTable = (node, batchRevisionIds) => {
+	if (node.type.spec["tableRole"] !== "table" || node.childCount === 0) return false;
+	let revisionId;
+	for (let index = 0; index < node.childCount; index++) {
+		const row = node.child(index);
+		if (row.type.spec["tableRole"] !== "row") return false;
+		const { trIns, trDel } = expectTableRowAttrs(row);
+		if (!trIns || trDel || !batchRevisionIds.has(trIns.revisionId)) return false;
+		revisionId ??= trIns.revisionId;
+		if (trIns.revisionId !== revisionId) return false;
+	}
+	return true;
+};
 /**
 * Where the added break of the final paragraph at `at` rotates to: the free
 * mark `addedBreakCarrierBefore` finds, or else a paragraph the batch deletes
@@ -1628,19 +1903,7 @@ const finalBreakCarrierBefore = (at, paragraphTypeName, batchRevisionIds) => {
 	const free = addedBreakCarrierBefore({
 		at,
 		paragraphTypeName,
-		canCrossTable: (table) => {
-			if (table.childCount === 0) return false;
-			let revisionId;
-			for (let index = 0; index < table.childCount; index++) {
-				const row = table.child(index);
-				if (row.type.spec["tableRole"] !== "row") return false;
-				const { trIns, trDel } = expectTableRowAttrs(row);
-				if (!trIns || trDel || !batchRevisionIds.has(trIns.revisionId)) return false;
-				revisionId ??= trIns.revisionId;
-				if (trIns.revisionId !== revisionId) return false;
-			}
-			return true;
-		}
+		canCrossTable: (table) => isWhollyInsertedTable(table, batchRevisionIds)
 	});
 	if (free) return {
 		...free,
@@ -1746,22 +2009,6 @@ const collapsedFinalRunSource = (doc, at, batchRevisionIds) => {
 	}
 	return source;
 };
-/**
-* Whether a sibling between a final carrier's predecessor and the carrier
-* has its break deleted by this batch.
-*/
-const crossesBatchDeletion = ({ doc, from, to, batchRevisionIds }) => {
-	const $to = doc.resolve(to);
-	let position = to;
-	for (let index = $to.index() - 1; index >= 0 && position > from; index--) {
-		const node = $to.parent.child(index);
-		position -= node.nodeSize;
-		const mark = node.attrs["pPrMark"];
-		const revisionId = isPlainDeletedPPrMark(mark) ? addedOrDeletedBreakRevisionId(mark) : null;
-		if (revisionId !== null && batchRevisionIds.has(revisionId)) return true;
-	}
-	return false;
-};
 const canRetractFinalBreak = ({ predecessor, target }) => {
 	if (target.type !== predecessor.type) return false;
 	return !(JSON.stringify(paragraphPropertiesBeforePendingChanges(target)) !== JSON.stringify(paragraphPropertiesSnapshot(predecessor)) && hasSerializableParagraphPropertyChange(expectParagraphAttrs(predecessor)._propertyChanges));
@@ -1778,8 +2025,8 @@ const pendingRemovedFinalBreakPositions = (tr, deletions) => {
 	return positions;
 };
 /** An unoccupied final carrier takes admissible writes from the finished batch. */
-const finalParagraphCarry = ({ tr, at, target, predecessor, batchRevisionIds, styleResolver, numbering }) => {
-	const { node: previous, position } = predecessor;
+const finalParagraphCarry = ({ target, predecessor, batchRevisionIds, styleResolver, numbering }) => {
+	const { node: previous } = predecessor;
 	const beforeBatch = hasSerializableParagraphPropertyChange(expectParagraphAttrs(target)._propertyChanges) ? resolveParagraphChangeAttrs({
 		node: previous,
 		mode: "reject",
@@ -1788,15 +2035,7 @@ const finalParagraphCarry = ({ tr, at, target, predecessor, batchRevisionIds, st
 		styleResolver,
 		numbering
 	}) : null;
-	return {
-		source: beforeBatch ? previous.type.create(beforeBatch, previous.content, previous.marks) : previous,
-		keep: crossesBatchDeletion({
-			doc: tr.doc,
-			from: position + previous.nodeSize,
-			to: at,
-			batchRevisionIds
-		}) ? /* @__PURE__ */ new Set() : propertiesSetInBatch(target, batchRevisionIds)
-	};
+	return { source: beforeBatch ? previous.type.create(beforeBatch, previous.content, previous.marks) : previous };
 };
 /** Deferred retirement still owns a slot before a later explicit formatting merge. */
 const hasDeferredParagraphPropertyWrite = ({ tr, deletions, targets, mergedPropertyTargets, batchRevisionIds, styleResolver, numbering }) => {
@@ -1819,26 +2058,19 @@ const hasDeferredParagraphPropertyWrite = ({ tr, deletions, targets, mergedPrope
 		}))) continue;
 		const transfer = mark == null ? finalParagraphCarry({
 			tr,
-			at,
 			target,
 			predecessor,
 			batchRevisionIds,
 			styleResolver,
 			numbering
-		}) : {
-			source: predecessor.node,
-			keep: propertiesSetInBatch(writeTarget, batchRevisionIds)
-		};
-		if (JSON.stringify(paragraphPropertiesSnapshot(writeTarget)) !== JSON.stringify(carriedParagraphProperties({
-			...transfer,
-			target: writeTarget
-		}))) return true;
+		}) : { source: predecessor.node };
+		if (JSON.stringify(paragraphPropertiesSnapshot(writeTarget)) !== JSON.stringify(paragraphPropertiesSnapshot(transfer.source))) return true;
 	}
 	return false;
 };
 /** The paragraph a merge leaves owns its properties, even across pending deleted breaks. */
 const paragraphPropertyRevisionTargets = ({ item, tr, deletedFinalParagraphs }) => {
-	const position = tr.mapping.map(item.blockFrom, item.operation.type === "replaceBlock" ? -1 : 1);
+	const position = sinceRead(tr, item).map(item.blockFrom, item.operation.type === "replaceBlock" ? -1 : 1);
 	const source = tr.doc.nodeAt(position) ?? item.blockNode;
 	const targets = source.type.name === "paragraph" ? [source] : [];
 	if (item.operation.type !== "mergeBlockWithNext") return targets;
@@ -1915,8 +2147,7 @@ const withRetiredFinalParagraphs = ({ tr, deletions, mergedPropertyTargets, appl
 					author,
 					date,
 					...revisionExtras
-				},
-				keep: /* @__PURE__ */ new Set()
+				}
 			});
 			if (carried.tracked) {
 				nextRevisionId++;
@@ -1950,7 +2181,6 @@ const withRetiredFinalParagraphs = ({ tr, deletions, mergedPropertyTargets, appl
 				position: at,
 				...finalParagraphCarry({
 					tr,
-					at,
 					target: emptied,
 					predecessor,
 					batchRevisionIds,
@@ -1995,7 +2225,6 @@ const withRetiredFinalParagraphs = ({ tr, deletions, mergedPropertyTargets, appl
 				doc: tr.doc,
 				paragraphPos: position
 			}) ?? position : position;
-			const carryTarget = tr.doc.nodeAt(carryPosition) ?? following;
 			const revisionId = nextRevisionId;
 			if (carryParagraphProperties({
 				tr,
@@ -2008,8 +2237,7 @@ const withRetiredFinalParagraphs = ({ tr, deletions, mergedPropertyTargets, appl
 					author,
 					date,
 					...revisionExtras
-				},
-				keep: propertiesSetInBatch(carryTarget, batchRevisionIds)
+				}
 			}).tracked) {
 				nextRevisionId++;
 				addedRevisions.push({
@@ -2069,6 +2297,7 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 		let carriedDeletedFormatting = null;
 		parent.forEach((node, offset) => {
 			const position = contentStart + offset;
+			if (isWhollyInsertedTable(node, batchRevisionIds)) return;
 			if (node.type.name !== "paragraph") {
 				previous = null;
 				carriedDeletedMark = null;
@@ -2215,25 +2444,38 @@ const withRotatedAddedFinalBreaks = ({ tr, batchRevisionIds, revisionSeed, autho
 				const liveCurrent = next.doc.nodeAt(current.position);
 				if (!liveCurrent || liveCurrent.type.name !== final.type.name) panic("A final-mark rotation lost its paragraph", { position: current.position });
 				const existing = expectParagraphAttrs(liveCurrent)._propertyChanges;
-				if (hasSerializableParagraphPropertyChange(existing)) panic("A final-mark rotation cannot append a second w:pPrChange", { position: current.position });
-				const revisionId = nextRevisionId++;
-				next = next.setNodeMarkup(current.position, void 0, {
-					...liveCurrent.attrs,
-					_propertyChanges: [...Array.isArray(existing) ? existing : [], {
-						type: "paragraphPropertyChange",
-						info: {
-							id: revisionId,
-							author,
-							date,
-							...initials ? { initials } : {}
-						},
+				if (hasSerializableParagraphPropertyChange(existing)) {
+					const serialized = (existing ?? []).filter(({ info }) => info.provenance !== "suggested");
+					if (!serialized.every(({ info }) => batchRevisionIds.has(info.id))) panic("A final-mark rotation met a w:pPrChange from outside", { position: current.position });
+					const restated = [];
+					for (const change of existing ?? []) restated.push(serialized.includes(change) ? {
+						...change,
 						previousFormatting
-					}]
-				});
-				synthesizedRevisions.push({
-					ownerRevisionId,
-					revisionId
-				});
+					} : change);
+					next = next.setNodeMarkup(current.position, void 0, {
+						...liveCurrent.attrs,
+						_propertyChanges: restated
+					});
+				} else {
+					const revisionId = nextRevisionId++;
+					next = next.setNodeMarkup(current.position, void 0, {
+						...liveCurrent.attrs,
+						_propertyChanges: [...Array.isArray(existing) ? existing : [], {
+							type: "paragraphPropertyChange",
+							info: {
+								id: revisionId,
+								author,
+								date,
+								...initials ? { initials } : {}
+							},
+							previousFormatting
+						}]
+					});
+					synthesizedRevisions.push({
+						ownerRevisionId,
+						revisionId
+					});
+				}
 			}
 			if (cancels) {
 				const deleted = next.doc.nodeAt(previous.position);
@@ -2490,7 +2732,7 @@ const buildInsertedParagraphs = ({ item, schema, formattingFromStyle, mode, auth
 		nextRevisionId
 	};
 };
-const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: requestedOperations, mode = "tracked-changes", author = "AI", initials, createCommentId, revisionStamp, revisionIdSeed, wordDiff, wordDiffMode = "bounded", tableTemplates, replacementBackground = "clear", undefinedReferences }) => {
+const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: requestedOperations, mode = "tracked-changes", author = "AI", initials, createCommentId, revisionStamp, revisionIdSeed, wordDiff, wordDiffMode = "bounded", tableTemplates, replacementBackground = "clear", undefinedReferences, numberingIdsElsewhere }) => {
 	seedRevisionIdsFromDoc(view.state.doc);
 	const applied = [];
 	const skipped = [];
@@ -2571,7 +2813,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			liveBlocks,
 			liveBlocksByParaId,
 			noteReferences,
-			doc: view.state.doc
+			doc: view.state.doc,
+			mode
 		});
 		if (resolution.type === "skip") {
 			skipped.push({
@@ -2652,7 +2895,8 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			"splitTableCell"
 		].includes(operation.type) ? removedBlocksBy.get(targetBlockId) : void 0;
 		const continuesMergeChain = operation.type === "mergeBlockWithNext" && removedBy?.type === "mergeBlockWithNext";
-		if (removedBy !== void 0 && !continuesMergeChain) {
+		const formatsBeforeRemoval = operation.type === "setBlockParagraphProperties" && (removedBy?.type === "mergeBlockWithNext" || removedBy?.type === "deleteBlock");
+		if (removedBy !== void 0 && !continuesMergeChain && !formatsBeforeRemoval) {
 			skipped.push({
 				id: operation.id,
 				reason: "overlappingOperation",
@@ -2692,6 +2936,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 		});
 		resolved.push({
 			...resolution.operation,
+			batchBlockFrom: resolution.operation.blockFrom,
 			originalIndex: index,
 			...commentText !== void 0 && { commentText }
 		});
@@ -2813,18 +3058,71 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			inputIndex: item.originalIndex
 		};
 	};
-	const executionOrder = orderBatchOperations(executableResolved, batchAddress);
+	const batchDeletions = new Set(executableResolved.flatMap((item) => item.operation.type === "deleteBlock" ? [item.blockFrom] : []));
+	const blockAccess = (item) => {
+		const doc = view.state.doc;
+		if (item.operation.type === "mergeBlockWithNext") {
+			const next = paragraphJoinAfter(doc, item.blockTo);
+			return {
+				addresses: [item.blockFrom],
+				removes: next ? [next.nextPosition] : []
+			};
+		}
+		if (item.operation.type === "deleteTableRow" || item.operation.type === "deleteTable") return {
+			addresses: [],
+			removes: [item.blockFrom]
+		};
+		if (item.tableColumnInsertion ?? item.tableColumnDeletion ?? item.tableCellMerge ?? item.tableCellSplit) return {
+			addresses: [],
+			removes: []
+		};
+		if (item.operation.type !== "deleteBlock") return {
+			addresses: [item.blockFrom],
+			removes: []
+		};
+		const at = doc.resolve(item.blockFrom);
+		let hasKeptParagraphBefore = false;
+		let position = at.pos;
+		for (let index = at.index() - 1; index >= 0; index -= 1) {
+			const previous = at.parent.child(index);
+			position -= previous.nodeSize;
+			if (previous.type !== item.blockNode.type) break;
+			if (!batchDeletions.has(position)) {
+				hasKeptParagraphBefore = true;
+				break;
+			}
+		}
+		const appended = executableResolved.some((other) => other.blockFrom === item.blockFrom && (other.operation.type === "insertAfterBlock" || other.operation.type === "insertTable" && other.operation.position !== "before"));
+		return {
+			addresses: [],
+			removes: deletionRemovesBlock({
+				endsContainer: !appended && paragraphEndsItsContainer(at, item.blockNode.type.name),
+				hasKeptParagraphBefore
+			}) ? [item.blockFrom] : []
+		};
+	};
+	const groupRuns = (items) => groupInsertionRuns(items, (candidate) => isBatchableParagraphInsertion(candidate, mode) ? candidate.from : null, (candidate) => candidate.operation.type === "setBlockParagraphProperties");
+	const executionOrder = orderAddressingBeforeRemoval(groupRuns(orderBatchOperations(executableResolved, batchAddress)), (run) => {
+		const access = run.map(blockAccess);
+		return {
+			addresses: access.flatMap(({ addresses }) => addresses),
+			removes: access.flatMap(({ removes }) => removes)
+		};
+	}).flat();
 	const allocateNewLists = ({ items }) => {
-		const allocated = resolveNewListOperations(items.map(({ operation }) => operation), numbering);
+		const allocated = resolveNewListOperations(items.map(({ operation }) => operation), numbering, numberingIdsElsewhere);
 		numbering = allocated.numbering;
 		for (const [index, candidate] of items.entries()) candidate.operation = allocated.operations[index] ?? panic("A will-apply operation lost its new-list allocation", { id: candidate.operation.id });
 	};
-	const executionGroups = groupInsertionRuns(executionOrder, (candidate) => isBatchableParagraphInsertion(candidate, mode) ? candidate.from : null, (candidate) => candidate.operation.type === "setBlockParagraphProperties");
+	/** Paragraphs a retracted break of this batch joined, to the one it left. */
+	const joinedInto = /* @__PURE__ */ new Map();
+	const executionGroups = groupRuns(executionOrder);
 	for (const executionGroup of executionGroups) {
 		const insertionState = tr;
-		const insertionRun = executionGroup.flatMap((candidate) => {
+		const insertionRun = executionGroup.flatMap((resolvedCandidate) => {
+			const candidate = readNow(resolvedCandidate, insertionState);
 			if (candidate.operation.type !== "insertAfterBlock" && candidate.operation.type !== "insertBeforeBlock") return [candidate];
-			const liveCandidate = insertionWithLiveAnchor(candidate, insertionState);
+			const liveCandidate = insertionWithLiveAnchor(candidate, insertionState, joinedInto);
 			if (!liveCandidate) {
 				if (!isSuggested) return [candidate];
 				if (candidate.operation.moveId !== void 0) refusedMoveIds.add(candidate.operation.moveId);
@@ -2835,7 +3133,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 				return [];
 			}
 			if (isSuggested) {
-				const blockFrom = insertionState.mapping.map(candidate.blockFrom, 1);
+				const blockFrom = sinceRead(insertionState, candidate).map(candidate.blockFrom, 1);
 				if (isPendingDeletion(insertionState.doc, blockFrom, liveCandidate.blockNode, buildCleanBlockText(liveCandidate.blockNode, blockFrom, {
 					fieldResults: "text",
 					noteReferences
@@ -2887,10 +3185,16 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			const runApplied = [];
 			for (const insertion of insertionRun) {
 				const insertionSuggestionId = isSuggested ? insertion.operation.suggestionId ?? insertion.operation.id : null;
-				const built = buildInsertedParagraphs({
+				const formatted = insertionFormattingAnchor({
 					item: insertion,
+					tr,
+					mode,
+					noteReferences
+				});
+				const built = buildInsertedParagraphs({
+					item: formatted,
 					schema: view.state.schema,
-					formattingFromStyle: formattingFromStyleForInsertion(insertion),
+					formattingFromStyle: formattingFromStyleForInsertion(formatted),
 					mode,
 					author,
 					date,
@@ -2918,7 +3222,11 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			for (const group of nodeGroups.toReversed()) for (const node of group) nodes.push(node);
 			tr = insertBlocksInsideComments({
 				tr,
-				at: item.from,
+				at: insertionAt({
+					item,
+					tr,
+					noteReferences
+				}),
 				blocks: nodes,
 				...item.boundaryComments !== void 0 && { carriedComments: item.boundaryComments }
 			});
@@ -3115,7 +3423,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 			case "replaceBlock": {
 				if (!isResolvedReplaceBlockOperation(item)) panic("Resolved replaceBlock operation lost its impact discriminator");
 				const { changesStyle, changesText } = REPLACE_BLOCK_IMPACT[item.replaceBlockImpact];
-				if (changesStyle && isDeletedPPrMark(tr.doc.nodeAt(tr.mapping.map(item.blockFrom, -1))?.attrs["pPrMark"])) {
+				if (changesStyle && isDeletedPPrMark(tr.doc.nodeAt(sinceRead(tr, item).map(item.blockFrom, -1))?.attrs["pPrMark"])) {
 					skipped.push({
 						id: item.operation.id,
 						...pendingParagraphMarkPropertyRefusal
@@ -3286,10 +3594,16 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					items: [item]
 				});
 				assertNewListsAllocated(item.operation);
-				const built = buildInsertedParagraphs({
+				const formatted = insertionFormattingAnchor({
 					item,
+					tr,
+					mode,
+					noteReferences
+				});
+				const built = buildInsertedParagraphs({
+					item: formatted,
 					schema: view.state.schema,
-					formattingFromStyle: formattingFromStyleForInsertion(item),
+					formattingFromStyle: formattingFromStyleForInsertion(formatted),
 					mode,
 					author,
 					date,
@@ -3303,11 +3617,16 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 				});
 				operationRevisionSeed = built.nextRevisionId;
 				if (built.revisionIds.length > 0) appliedRevisionIds = built.revisionIds;
+				const placement = insertionPlacement({
+					item,
+					tr,
+					noteReferences
+				});
 				tr = insertBlocksInsideComments({
 					tr,
-					at: item.from,
+					at: placement.at,
 					blocks: built.nodes,
-					...item.boundaryComments !== void 0 && { carriedComments: item.boundaryComments }
+					...placement.comments !== void 0 && { carriedComments: placement.comments }
 				});
 				break;
 			}
@@ -3345,7 +3664,11 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					}, signatureTable.content, signatureTable.marks);
 					appliedRevisionIds = [revisionId];
 				}
-				tr = tr.insert(item.from, node);
+				tr = tr.insert(insertionAt({
+					item,
+					tr,
+					noteReferences
+				}), node);
 				break;
 			}
 			case "insertTableRow": {
@@ -3617,7 +3940,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 						to: item.to,
 						mark: deletionMark
 					});
-					const atomRanges = undeletedContentAtomRanges(tr, item.blockFrom);
+					const atomRanges = undeletedContentAtomRanges(tr, item.blockFrom, item.readAt ?? 0);
 					for (const { from, to } of atomRanges) addTrackedDeletionMark({
 						insertionPolicy: "preserve-pending",
 						tr,
@@ -3625,7 +3948,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 						to,
 						mark: deletionMark
 					});
-					for (const anchorId of textBoxAnchorIdsBetween(tr.doc, tr.mapping.map(item.blockFrom), tr.mapping.map(item.blockTo))) deletedTextBoxAnchorIds.add(anchorId);
+					for (const anchorId of textBoxAnchorIdsBetween(tr.doc, sinceRead(tr, item).map(item.blockFrom), sinceRead(tr, item).map(item.blockTo))) deletedTextBoxAnchorIds.add(anchorId);
 					encloseWholeControls({
 						tr,
 						from: item.blockFrom,
@@ -3634,7 +3957,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					});
 					const inlineRevisionApplied = item.from < item.to || atomRanges.length > 0;
 					appliedRevisionIds = inlineRevisionApplied ? [revisionId] : [];
-					let markPosition = tr.mapping.map(item.blockFrom);
+					let markPosition = sinceRead(tr, item).map(item.blockFrom);
 					const markOwner = tr.doc.nodeAt(markPosition);
 					const across = markOwner && !isPairedMove(item.operation.moveId) && addedBreakRevisionId(markOwner.attrs["pPrMark"]) !== null ? paragraphAcrossVanishingTables(tr.doc, markPosition) : null;
 					if (across !== null) markPosition = moveParagraphPastTables(tr, markPosition, across);
@@ -3729,10 +4052,15 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					continue;
 				}
 				if (producesTrackedChanges) appliedRevisionIds = [operationRevisionSeed++];
-				const carriedComments = tableAfterDeletedSplit.get(item.blockFrom);
-				const usesRetractedSplit = carriedComments !== void 0 && item.from === item.blockTo;
-				let at = usesRetractedSplit ? tr.mapping.map(item.blockFrom, -1) : item.from;
-				let insertionComments = carriedComments ?? item.boundaryComments;
+				const carriedComments = tableAfterDeletedSplit.get(item.batchBlockFrom ?? item.blockFrom);
+				const usesRetractedSplit = carriedComments !== void 0 && item.from === item.blockTo && liveBlockResult(tr, item, 1).deletedAcross;
+				const placement = insertionPlacement({
+					item,
+					tr,
+					noteReferences
+				});
+				let at = usesRetractedSplit ? sinceRead(tr, item).map(item.blockFrom, -1) : placement.at;
+				let insertionComments = carriedComments ?? placement.comments;
 				if (!usesRetractedSplit) {
 					const boundary = tr.doc.resolve(at);
 					const before = boundary.nodeBefore;
@@ -3857,7 +4185,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 				break;
 			}
 			case "setBlockParagraphProperties": {
-				const mapped = tr.mapping.mapResult(item.blockFrom);
+				const mapped = liveBlockResult(tr, item);
 				const liveBlock = mapped.deletedAcross ? null : tr.doc.nodeAt(mapped.pos);
 				const paraId = item.blockNode.attrs["paraId"];
 				if (!liveBlock || liveBlock.type !== item.blockNode.type || typeof paraId === "string" && liveBlock.attrs["paraId"] !== paraId) {
@@ -3954,6 +4282,19 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 						kind: "ins",
 						info
 					});
+					const second = tr.doc.nodeAt(item.from + 1);
+					const survivor = mode === "tracked-changes" && isDeletedPPrMark(second?.attrs["pPrMark"]) ? paragraphLeftAfter({
+						doc: tr.doc,
+						paragraphPos: item.from + 1
+					}) : null;
+					const source = survivor === null ? null : tr.doc.nodeAt(survivor);
+					if (source) tr = carryParagraphProperties({
+						tr,
+						position: item.blockFrom,
+						source,
+						styleResolver,
+						numbering
+					}).tr;
 				}
 				const allocateSplitParagraphPropertyRevisionInfo = () => ({
 					id: operationRevisionSeed++,
@@ -3987,7 +4328,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 				break;
 			}
 			case "mergeBlockWithNext": {
-				const mapped = tr.mapping.mapResult(item.blockFrom, 1);
+				const mapped = liveBlockResult(tr, item, 1);
 				const live = mapped.deletedAcross ? null : tr.doc.nodeAt(mapped.pos);
 				const paraId = item.blockNode.attrs["paraId"];
 				if (!live || live.type !== item.blockNode.type || typeof paraId === "string" && live.attrs["paraId"] !== paraId) {
@@ -4102,7 +4443,7 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 					const nextPosition = join.nextPosition + separator.length;
 					const next = tr.doc.nodeAt(nextPosition);
 					if (!paragraph || !next) panic("A resolved merge lost its paragraphs");
-					if (isInsertedPPrMark(paragraph.attrs["pPrMark"])) {
+					if (addedBreakRevisionId(paragraph.attrs["pPrMark"]) !== null) {
 						joinAtParagraphMark({
 							tr,
 							paragraphPos: blockFrom,
@@ -4110,6 +4451,9 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 							next,
 							styleResolver
 						});
+						const firstId = paragraph.attrs["paraId"];
+						const nextId = next.attrs["paraId"];
+						if (typeof firstId === "string" && typeof nextId === "string") joinedInto.set(firstId, nextId);
 						const joinedMark = tr.doc.nodeAt(blockFrom)?.attrs["pPrMark"];
 						const removedBreakPositions = pendingRemovedFinalBreakPositions(tr, deletedFinalParagraphs);
 						const carryPos = isDeletedPPrMark(joinedMark) || removedBreakPositions.has(blockFrom) ? paragraphLeftAfter({
@@ -4348,8 +4692,16 @@ const applyFolioAIEditOperationsInternal = ({ view, snapshot, operations: reques
 		nextRevisionId: revisionSeed
 	};
 };
-const applyFolioAIEditOperations = (options) => applyFolioAIEditOperationsInternal(options);
-const previewFolioAIEditOperations = (options) => previewFolioAIEditOperationsWithResult(options).outcome;
+const applyFolioAIEditOperations = (options) => applyFolioAIEditOperationsInternal({
+	...options,
+	numberingIdsElsewhere: NO_NUMBERING_IDS_IN_USE
+});
+/** {@link applyFolioAIEditOperations} for a caller holding every story. Internal. */
+const applyFolioAIEditOperationsInPackage = (options) => applyFolioAIEditOperationsInternal(options);
+const previewFolioAIEditOperations = (options) => previewFolioAIEditOperationsWithResult({
+	...options,
+	numberingIdsElsewhere: NO_NUMBERING_IDS_IN_USE
+}).outcome;
 /**
 * A preview together with the document it would leave and the provisional
 * comment ids it placed, for a caller that checks the result before reporting
@@ -5228,7 +5580,7 @@ const refuseNoteReferenceEdit = (item, noteReferences) => {
 		reason: "protectedReference"
 	} : null;
 };
-const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByParaId, noteReferences, doc }) => {
+const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByParaId, noteReferences, doc, mode }) => {
 	const blockId = operation.type === "replaceRange" || operation.type === "commentOnRange" || operation.type === "formatRange" ? operation.range.blockId : operation.blockId;
 	const primaryBlock = resolveStableBlock({
 		snapshot,
@@ -5243,6 +5595,28 @@ const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByP
 		type: "skip",
 		reason: "preconditionFailed"
 	};
+	const joinBounds = () => mode === "suggested" ? {
+		before: blockFrom,
+		after: endOfParagraphWithItsTextBoxes(doc, blockFrom)
+	} : pendingJoinBounds({
+		doc,
+		paragraphPos: blockFrom,
+		noteReferences
+	});
+	const beside = (side) => {
+		const plain = side === "after" ? endOfParagraphWithItsTextBoxes(doc, blockFrom) : blockFrom;
+		const at = joinBounds()[side];
+		const from = side === "after" ? plain : at;
+		return at === plain ? {
+			from,
+			at
+		} : {
+			from,
+			at,
+			joinSide: side,
+			joinAt: at
+		};
+	};
 	if (operation.type === "replaceRange" || operation.type === "commentOnRange" || operation.type === "formatRange") {
 		const { startOffset, endOffset, selectedTextHash } = operation.range;
 		if (cleanBlock.offsets[startOffset] === void 0 || cleanBlock.offsets[endOffset] === void 0) return {
@@ -5291,11 +5665,20 @@ const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByP
 	}
 	if (operation.type === "insertAfterBlock" || operation.type === "insertBeforeBlock") {
 		const tableBoundary = findOutermostTableBoundary(doc, blockFrom);
-		const isInsertAfter = operation.type === "insertAfterBlock";
-		let insertFrom;
-		if (tableBoundary) insertFrom = isInsertAfter ? tableBoundary.after : tableBoundary.before;
-		else insertFrom = isInsertAfter ? endOfParagraphWithItsTextBoxes(doc, blockFrom) : blockFrom;
-		const insertTexts = operation.lineBreakMode !== "inline" && LINE_BREAK_PATTERN.test(operation.text) ? splitInsertParagraphTexts(operation.text) : [operation.text];
+		const side = operation.type === "insertAfterBlock" ? "after" : "before";
+		const placed = tableBoundary ? {
+			from: tableBoundary[side],
+			at: tableBoundary[side]
+		} : beside(side);
+		if (joinStopsAtTableAfter({
+			doc,
+			paragraphPos: placed.at,
+			noteReferences
+		})) return {
+			type: "skip",
+			...pendingJoinInsertionRefusal
+		};
+		const insertFrom = placed.from;
 		return {
 			type: "resolved",
 			operation: {
@@ -5305,8 +5688,12 @@ const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByP
 				blockFrom,
 				blockTo,
 				blockNode,
-				insertTexts,
-				boundaryComments: commentsAcrossBlockBoundary(doc, insertFrom)
+				insertTexts: operation.lineBreakMode !== "inline" && LINE_BREAK_PATTERN.test(operation.text) ? splitInsertParagraphTexts(operation.text) : [operation.text],
+				boundaryComments: commentsAcrossBlockBoundary(doc, placed.at),
+				...placed.joinSide !== void 0 && {
+					joinSide: placed.joinSide,
+					joinAt: placed.joinAt
+				}
 			}
 		};
 	}
@@ -5317,18 +5704,23 @@ const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByP
 		};
 		const position = operation.position ?? "after";
 		const tableBoundary = findOutermostTableBoundary(doc, blockFrom);
-		let insertFrom;
-		if (tableBoundary) insertFrom = position === "after" ? tableBoundary.after : tableBoundary.before;
-		else insertFrom = position === "after" ? endOfParagraphWithItsTextBoxes(doc, blockFrom) : blockFrom;
+		const placed = tableBoundary ? {
+			from: tableBoundary[position],
+			at: tableBoundary[position]
+		} : beside(position);
 		return {
 			type: "resolved",
 			operation: {
 				operation,
-				from: insertFrom,
-				to: insertFrom,
+				from: placed.from,
+				to: placed.from,
 				blockFrom,
 				blockTo,
-				blockNode
+				blockNode,
+				...placed.joinSide !== void 0 && {
+					joinSide: placed.joinSide,
+					joinAt: placed.joinAt
+				}
 			}
 		};
 	}
@@ -5549,21 +5941,26 @@ const resolveOperationTarget = ({ snapshot, operation, liveBlocks, liveBlocksByP
 		};
 	}
 	if (operation.type === "insertTable") {
-		const boundary = findOutermostTableBoundary(doc, blockFrom) ?? {
-			before: blockFrom,
-			after: endOfParagraphWithItsTextBoxes(doc, blockFrom)
-		};
-		const insertFrom = (operation.position ?? "after") === "after" ? boundary.after : boundary.before;
+		const side = (operation.position ?? "after") === "after" ? "after" : "before";
+		const tableBoundary = findOutermostTableBoundary(doc, blockFrom);
+		const placed = tableBoundary ? {
+			from: tableBoundary[side],
+			at: tableBoundary[side]
+		} : beside(side);
 		return {
 			type: "resolved",
 			operation: {
 				operation,
-				from: insertFrom,
-				to: insertFrom,
+				from: placed.from,
+				to: placed.from,
 				blockFrom,
 				blockTo,
 				blockNode,
-				boundaryComments: commentsAcrossBlockBoundary(doc, insertFrom)
+				boundaryComments: commentsAcrossBlockBoundary(doc, placed.at),
+				...placed.joinSide !== void 0 && {
+					joinSide: placed.joinSide,
+					joinAt: placed.joinAt
+				}
 			}
 		};
 	}
@@ -5947,4 +6344,4 @@ const getOperationQuote = (operation) => {
 	if (operation.type === "replaceInBlock") return operation.find;
 	if (operation.type === "commentOnBlock") return operation.quote;
 };
-export { applyFolioAIEditOperations, insertCleanText, previewFolioAIEditOperations, previewFolioAIEditOperationsWithResult };
+export { applyFolioAIEditOperations, applyFolioAIEditOperationsInPackage, insertCleanText, previewFolioAIEditOperations, previewFolioAIEditOperationsWithResult };