@fluidframework/tree 2.0.0-rc.2.0.2 → 2.0.0-rc.3.0.0

package/src/feature-libraries/sequence-field/format.ts

@@ -4,9 +4,10 @@
  */
 
 import { ObjectOptions, Static, TSchema, Type } from "@sinclair/typebox";
+
+import { unionOptions } from "../../codec/index.js";
 import { RevisionTagSchema } from "../../core/index.js";
 import { ChangesetLocalIdSchema, EncodedChangeAtomId } from "../modular-schema/index.js";
-import { unionOptions } from "../../codec/index.js";
 
 export enum DetachIdOverrideType {
 	/**

package/src/feature-libraries/sequence-field/helperTypes.ts

@@ -4,23 +4,23 @@
  */
 
 import {
+	AttachAndDetach,
 	CellId,
-	HasMarkFields,
+	CellMark,
 	Detach,
+	HasMarkFields,
 	Mark,
-	CellMark,
-	AttachAndDetach,
 	MoveIn,
 	MoveOut,
 } from "./types.js";
 
-export type EmptyInputCellMark<TNodeChange> = Mark<TNodeChange> & DetachedCellMark;
+export type EmptyInputCellMark = Mark & DetachedCellMark;
 
 export interface DetachedCellMark extends HasMarkFields {
 	cellId: CellId;
 }
 
-export type EmptyOutputCellMark<TNodeChange> = CellMark<Detach | AttachAndDetach, TNodeChange>;
+export type EmptyOutputCellMark = CellMark<Detach | AttachAndDetach>;
 
 export type MoveMarkEffect = MoveOut | MoveIn;
 export type DetachOfRemovedNodes = Detach & { cellId: CellId };

package/src/feature-libraries/sequence-field/index.ts

@@ -14,7 +14,6 @@ export {
 	MarkList,
 	MoveIn,
 	MoveOut,
-	NodeChangeType,
 	CellCount as NodeCount,
 	MoveId,
 	Attach,
@@ -35,12 +34,12 @@ export {
 } from "./sequenceFieldChangeHandler.js";
 export { SequenceChangeRebaser, sequenceFieldChangeRebaser } from "./sequenceFieldChangeRebaser.js";
 export { sequenceFieldChangeCodecFactory } from "./sequenceFieldCodecs.js";
-export { sequenceFieldToDelta, ToDelta } from "./sequenceFieldToDelta.js";
+export { sequenceFieldToDelta } from "./sequenceFieldToDelta.js";
 export { SequenceFieldEditor, sequenceFieldEditor } from "./sequenceFieldEditor.js";
 export { MarkListFactory } from "./markListFactory.js";
-export { NodeChangeRebaser, rebase } from "./rebase.js";
-export { invert, NodeChangeInverter } from "./invert.js";
-export { compose, NodeChangeComposer } from "./compose.js";
+export { rebase } from "./rebase.js";
+export { invert } from "./invert.js";
+export { compose } from "./compose.js";
 export {
 	getInputLength,
 	isDetach,

package/src/feature-libraries/sequence-field/invert.ts

@@ -3,27 +3,30 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+
 import { RevisionMetadataSource, RevisionTag, TaggedChange } from "../../core/index.js";
 import { IdAllocator, Mutable, fail } from "../../util/index.js";
-import { CrossFieldManager, CrossFieldTarget } from "../modular-schema/index.js";
+import { CrossFieldManager, CrossFieldTarget, NodeId } from "../modular-schema/index.js";
+
+import { DetachIdOverrideType } from "./format.js";
+import { MarkListFactory } from "./markListFactory.js";
 import {
+	CellId,
+	CellMark,
 	Changeset,
 	Mark,
+	MarkEffect,
 	MarkList,
-	NoopMarkType,
+	MoveIn,
 	MoveOut,
 	NoopMark,
+	NoopMarkType,
 	Remove,
-	CellMark,
-	MoveIn,
-	MarkEffect,
-	CellId,
 } from "./types.js";
-import { MarkListFactory } from "./markListFactory.js";
 import {
 	extractMarkEffect,
-	getDetachOutputId,
+	getDetachOutputCellId,
 	getEndpoint,
 	getInputCellId,
 	getOutputCellId,
@@ -35,9 +38,6 @@ import {
 	splitMark,
 	withNodeChange,
 } from "./utils.js";
-import { DetachIdOverrideType } from "./format.js";
-
-export type NodeChangeInverter<TNodeChange> = (change: TNodeChange) => TNodeChange;
 
 /**
  * Inverts a given changeset.
@@ -47,71 +47,57 @@ export type NodeChangeInverter<TNodeChange> = (change: TNodeChange) => TNodeChan
  * WARNING! This implementation is incomplete:
  * - Support for slices is not implemented.
  */
-export function invert<TNodeChange>(
-	change: TaggedChange<Changeset<TNodeChange>>,
-	invertChild: NodeChangeInverter<TNodeChange>,
+export function invert(
+	change: TaggedChange<Changeset>,
 	isRollback: boolean,
 	genId: IdAllocator,
 	crossFieldManager: CrossFieldManager,
 	revisionMetadata: RevisionMetadataSource,
-): Changeset<TNodeChange> {
+): Changeset {
 	return invertMarkList(
 		change.change,
 		change.revision,
-		invertChild,
-		crossFieldManager as CrossFieldManager<TNodeChange>,
+		crossFieldManager as CrossFieldManager<NodeId>,
 		revisionMetadata,
 	);
 }
 
-function invertMarkList<TNodeChange>(
-	markList: MarkList<TNodeChange>,
+function invertMarkList(
+	markList: MarkList,
 	revision: RevisionTag | undefined,
-	invertChild: NodeChangeInverter<TNodeChange>,
-	crossFieldManager: CrossFieldManager<TNodeChange>,
+	crossFieldManager: CrossFieldManager<NodeId>,
 	revisionMetadata: RevisionMetadataSource,
-): MarkList<TNodeChange> {
-	const inverseMarkList = new MarkListFactory<TNodeChange>();
+): MarkList {
+	const inverseMarkList = new MarkListFactory();
 
 	for (const mark of markList) {
-		const inverseMarks = invertMark(
-			mark,
-			revision,
-			invertChild,
-			crossFieldManager,
-			revisionMetadata,
-		);
+		const inverseMarks = invertMark(mark, revision, crossFieldManager, revisionMetadata);
 		inverseMarkList.push(...inverseMarks);
 	}
 
 	return inverseMarkList.list;
 }
 
-function invertMark<TNodeChange>(
-	mark: Mark<TNodeChange>,
+function invertMark(
+	mark: Mark,
 	revision: RevisionTag | undefined,
-	invertChild: NodeChangeInverter<TNodeChange>,
-	crossFieldManager: CrossFieldManager<TNodeChange>,
+	crossFieldManager: CrossFieldManager<NodeId>,
 	revisionMetadata: RevisionMetadataSource,
-): Mark<TNodeChange>[] {
+): Mark[] {
 	if (!isImpactful(mark, revision, revisionMetadata)) {
 		const inputId = getInputCellId(mark, revision, revisionMetadata);
-		return [invertNodeChangeOrSkip(mark.count, mark.changes, invertChild, inputId)];
+		return [invertNodeChangeOrSkip(mark.count, mark.changes, inputId)];
 	}
 	const type = mark.type;
 	switch (type) {
 		case NoopMarkType: {
-			const inverse = { ...mark };
-			if (mark.changes !== undefined) {
-				inverse.changes = invertChild(mark.changes);
-			}
-			return [inverse];
+			return [mark];
 		}
 		case "Remove": {
 			assert(revision !== undefined, 0x5a1 /* Unable to revert to undefined revision */);
 			const outputId = getOutputCellId(mark, revision, revisionMetadata);
 			const inputId = getInputCellId(mark, revision, revisionMetadata);
-			const inverse: Mark<TNodeChange> =
+			const inverse: Mark =
 				inputId === undefined
 					? {
 							type: "Insert",
@@ -129,12 +115,12 @@ function invertMark<TNodeChange>(
 								id: inputId,
 							},
 					  };
-			return [withNodeChange(inverse, invertNodeChange(mark.changes, invertChild))];
+			return [withNodeChange(inverse, mark.changes)];
 		}
 		case "Insert": {
 			const inputId = getInputCellId(mark, revision, revisionMetadata);
 			assert(inputId !== undefined, 0x80c /* Active inserts should target empty cells */);
-			const removeMark: Mutable<CellMark<Remove, TNodeChange>> = {
+			const removeMark: Mutable<CellMark<Remove>> = {
 				type: "Remove",
 				count: mark.count,
 				id: inputId.localId,
@@ -147,7 +133,7 @@ function invertMark<TNodeChange>(
 				id: inputId,
 			};
 
-			const inverse = withNodeChange(removeMark, invertNodeChange(mark.changes, invertChild));
+			const inverse = withNodeChange(removeMark, mark.changes);
 			return [inverse];
 		}
 		case "MoveOut": {
@@ -163,12 +149,12 @@ function invertMark<TNodeChange>(
 					endpoint.revision,
 					endpoint.localId,
 					mark.count,
-					invertChild(mark.changes),
+					mark.changes,
 					true,
 				);
 			}
 
-			const cellId = getDetachOutputId(
+			const cellId = getDetachOutputCellId(
 				mark,
 				mark.revision ?? revision ?? fail("Revision must be defined"),
 				revisionMetadata,
@@ -206,7 +192,7 @@ function invertMark<TNodeChange>(
 		case "MoveIn": {
 			const inputId = getInputCellId(mark, revision, revisionMetadata);
 			assert(inputId !== undefined, 0x89e /* Active move-ins should target empty cells */);
-			const invertedMark: Mutable<CellMark<MoveOut, TNodeChange>> = {
+			const invertedMark: Mutable<CellMark<MoveOut>> = {
 				type: "MoveOut",
 				id: mark.id,
 				count: mark.count,
@@ -227,7 +213,7 @@ function invertMark<TNodeChange>(
 		}
 		case "AttachAndDetach": {
 			// Which should get the child change? Don't want to invert twice
-			const attach: Mark<TNodeChange> = {
+			const attach: Mark = {
 				count: mark.count,
 				cellId: mark.cellId,
 				...mark.attach,
@@ -236,7 +222,7 @@ function invertMark<TNodeChange>(
 
 			// We put `mark.changes` on the detach so that if it is a move source
 			// the changes can be sent to the endpoint.
-			const detach: Mark<TNodeChange> = {
+			const detach: Mark = {
 				count: mark.count,
 				cellId: idAfterAttach,
 				changes: mark.changes,
@@ -245,14 +231,12 @@ function invertMark<TNodeChange>(
 			const attachInverses = invertMark(
 				attach,
 				revision,
-				invertChild,
 				crossFieldManager,
 				revisionMetadata,
 			);
 			const detachInverses = invertMark(
 				detach,
 				revision,
-				invertChild,
 				crossFieldManager,
 				revisionMetadata,
 			);
@@ -269,9 +253,9 @@ function invertMark<TNodeChange>(
 			let detachInverse = detachInverses[0];
 			assert(isAttach(detachInverse), 0x80e /* Inverse of a detach should be an attach */);
 
-			const inverses: Mark<TNodeChange>[] = [];
+			const inverses: Mark[] = [];
 			for (const attachInverse of attachInverses) {
-				let detachInverseCurr: Mark<TNodeChange> = detachInverse;
+				let detachInverseCurr: Mark = detachInverse;
 				if (attachInverse.count !== detachInverse.count) {
 					[detachInverseCurr, detachInverse] = splitMark(
 						detachInverse,
@@ -295,7 +279,7 @@ function invertMark<TNodeChange>(
 					0x810 /* Inverse of an attach should be a detach */,
 				);
 
-				const inverted: Mark<TNodeChange> = {
+				const inverted: Mark = {
 					type: "AttachAndDetach",
 					count: attachInverse.count,
 					attach: extractMarkEffect(detachInverseCurr),
@@ -325,11 +309,11 @@ function invertMark<TNodeChange>(
 	}
 }
 
-function applyMovedChanges<TNodeChange>(
-	mark: CellMark<MoveOut, TNodeChange>,
+function applyMovedChanges(
+	mark: CellMark<MoveOut>,
 	revision: RevisionTag | undefined,
-	manager: CrossFieldManager<TNodeChange>,
-): Mark<TNodeChange>[] {
+	manager: CrossFieldManager<NodeId>,
+): Mark[] {
 	// Although this is a source mark, we query the destination because this was a destination mark during the original invert pass.
 	const entry = manager.get(
 		CrossFieldTarget.Destination,
@@ -343,35 +327,25 @@ function applyMovedChanges<TNodeChange>(
 		const [mark1, mark2] = splitMark(mark, entry.length);
 		const mark1WithChanges =
 			entry.value !== undefined
-				? withNodeChange<CellMark<MoveOut, TNodeChange>, MoveOut, TNodeChange>(
-						mark1,
-						entry.value,
-				  )
+				? withNodeChange<CellMark<MoveOut>, MoveOut>(mark1, entry.value)
 				: mark1;
 
 		return [mark1WithChanges, ...applyMovedChanges(mark2, revision, manager)];
 	}
 
 	if (entry.value !== undefined) {
-		return [
-			withNodeChange<CellMark<MoveOut, TNodeChange>, MoveOut, TNodeChange>(mark, entry.value),
-		];
+		return [withNodeChange<CellMark<MoveOut>, MoveOut>(mark, entry.value)];
 	}
 
 	return [mark];
 }
 
-function invertNodeChangeOrSkip<TNodeChange>(
-	count: number,
-	changes: TNodeChange | undefined,
-	inverter: NodeChangeInverter<TNodeChange>,
-	cellId?: CellId,
-): Mark<TNodeChange> {
+function invertNodeChangeOrSkip(count: number, changes: NodeId | undefined, cellId?: CellId): Mark {
 	if (changes !== undefined) {
 		assert(count === 1, 0x66c /* A modify mark must have length equal to one */);
-		const noop: CellMark<NoopMark, TNodeChange> = {
+		const noop: CellMark<NoopMark> = {
 			count,
-			changes: inverter(changes),
+			changes,
 		};
 		if (cellId !== undefined) {
 			noop.cellId = cellId;
@@ -384,10 +358,3 @@ function invertNodeChangeOrSkip<TNodeChange>(
 	}
 	return { count };
 }
-
-function invertNodeChange<TNodeChange>(
-	change: TNodeChange | undefined,
-	inverter: NodeChangeInverter<TNodeChange>,
-): TNodeChange | undefined {
-	return change === undefined ? undefined : inverter(change);
-}

package/src/feature-libraries/sequence-field/markListFactory.ts

@@ -14,13 +14,13 @@ import { isNoopMark, isTombstone, tryMergeMarks as tryMergeMarks } from "./utils
  * - Merges runs of offsets together
  * - Merges marks together
  */
-export class MarkListFactory<TNodeChange> {
+export class MarkListFactory {
 	private offset = 0;
-	public readonly list: MarkList<TNodeChange> = [];
+	public readonly list: MarkList = [];
 
 	public constructor() {}
 
-	public push(...marks: Mark<TNodeChange>[]): void {
+	public push(...marks: Mark[]): void {
 		for (const item of marks) {
 			this.pushContent(item);
 		}
@@ -30,7 +30,7 @@ export class MarkListFactory<TNodeChange> {
 		this.offset += offset;
 	}
 
-	public pushContent(mark: Mark<TNodeChange>): void {
+	public pushContent(mark: Mark): void {
 		if (isTombstone(mark) && sequenceConfig.cellOrdering !== "Tombstone") {
 			return;
 		}

package/src/feature-libraries/sequence-field/markQueue.ts

@@ -3,20 +3,22 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils";
+import { assert } from "@fluidframework/core-utils/internal";
+
 import { RevisionTag } from "../../core/index.js";
+
+import { MoveEffectTable, splitMarkForMoveEffects } from "./moveEffectTable.js";
 import { Mark } from "./types.js";
-import { splitMarkForMoveEffects, MoveEffectTable } from "./moveEffectTable.js";
 import { splitMark } from "./utils.js";
 
-export class MarkQueue<T> {
-	private readonly stack: Mark<T>[] = [];
+export class MarkQueue {
+	private readonly stack: Mark[] = [];
 	private index = 0;
 
 	public constructor(
-		private readonly list: readonly Mark<T>[],
+		private readonly list: readonly Mark[],
 		public readonly revision: RevisionTag | undefined,
-		private readonly moveEffects: MoveEffectTable<T>,
+		private readonly moveEffects: MoveEffectTable,
 	) {
 		this.list = list;
 	}
@@ -25,13 +27,13 @@ export class MarkQueue<T> {
 		return this.peek() === undefined;
 	}
 
-	public dequeue(): Mark<T> {
+	public dequeue(): Mark {
 		const output = this.tryDequeue();
 		assert(output !== undefined, 0x4e2 /* Unexpected end of mark queue */);
 		return output;
 	}
 
-	public tryDequeue(): Mark<T> | undefined {
+	public tryDequeue(): Mark | undefined {
 		const mark = this.stack.length > 0 ? this.stack.pop() : this.list[this.index++];
 		if (mark === undefined) {
 			return undefined;
@@ -49,7 +51,7 @@ export class MarkQueue<T> {
 	 * or the entire next mark if `length` is longer than the mark's length.
 	 * @param length - The length to dequeue, measured in the input context.
 	 */
-	public dequeueUpTo(length: number): Mark<T> {
+	public dequeueUpTo(length: number): Mark {
 		const mark = this.dequeue();
 		if (mark.count <= length) {
 			return mark;
@@ -60,7 +62,7 @@ export class MarkQueue<T> {
 		return mark1;
 	}
 
-	public peek(): Mark<T> | undefined {
+	public peek(): Mark | undefined {
 		const mark = this.tryDequeue();
 		if (mark !== undefined) {
 			this.stack.push(mark);

package/src/feature-libraries/sequence-field/moveEffectTable.ts

@@ -3,25 +3,27 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase } from "@fluidframework/core-utils";
+import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+
 import { ChangeAtomId, RevisionTag, TaggedChange } from "../../core/index.js";
-import { CrossFieldManager, CrossFieldTarget } from "../modular-schema/index.js";
 import { RangeQueryResult, brand } from "../../util/index.js";
+import { CrossFieldManager, CrossFieldTarget, NodeId } from "../modular-schema/index.js";
+
+import { MoveMarkEffect } from "./helperTypes.js";
 import { CellMark, Mark, MarkEffect, MoveId, MoveIn, MoveOut } from "./types.js";
 import { isAttachAndDetachEffect, splitMark, splitMarkEffect } from "./utils.js";
-import { MoveMarkEffect } from "./helperTypes.js";
 
-export type MoveEffectTable<T> = CrossFieldManager<MoveEffect<T>>;
+export type MoveEffectTable = CrossFieldManager<MoveEffect>;
 
 /**
  * Changes to be applied to a move mark.
  */
-export interface MoveEffect<T> {
+export interface MoveEffect {
 	/**
 	 * Node changes which should be applied to this mark.
 	 * If this mark already has node changes, `modifyAfter` should be composed as later changes.
 	 */
-	modifyAfter?: T;
+	modifyAfter?: NodeId;
 
 	/**
 	 * Only used during rebasing.
@@ -32,15 +34,28 @@ export interface MoveEffect<T> {
 	/**
 	 * Rebased changes for a node which has been moved to the position of this mark.
 	 */
-	rebasedChanges?: T;
+	rebasedChanges?: NodeId;
 
 	/**
-	 * The ID of the new endpoint associated with this mark.
+	 * The ID of the other outer endpoint.
+	 * Used when this is the outer endpoint in a move chain which is being composed with another move chain.
 	 */
 	endpoint?: ChangeAtomId;
+
+	/**
+	 * The ID of the truncated endpoint.
+	 * Used when this mark is the outer endpoint of a chain being composed with a redundant move chain.
+	 */
+	truncatedEndpoint?: ChangeAtomId;
+
+	/**
+	 * The ID of the truncated endpoint.
+	 * Used when this mark is the inner endpoint of a redundant move chain.
+	 */
+	truncatedEndpointForInner?: ChangeAtomId;
 }
 
-interface MoveEffectWithBasis<T> extends MoveEffect<T> {
+interface MoveEffectWithBasis extends MoveEffect {
 	/**
 	 * The ID for the start of the range this MoveEffect was created for.
 	 * This is used, for example, to correctly interpret `MoveEffect.endpoint` field.
@@ -53,43 +68,43 @@ export enum MoveEnd {
 	Dest,
 }
 
-export interface MovePartition<TNodeChange> {
+export interface MovePartition {
 	id: MoveId;
 
 	// Undefined means the partition is the same size as the input.
 	count?: number;
-	replaceWith?: Mark<TNodeChange>[];
-	modifyAfter?: TaggedChange<TNodeChange>;
+	replaceWith?: Mark[];
+	modifyAfter?: TaggedChange<NodeId>;
 }
 
-export function setMoveEffect<T>(
-	moveEffects: MoveEffectTable<T>,
+export function setMoveEffect(
+	moveEffects: MoveEffectTable,
 	target: CrossFieldTarget,
 	revision: RevisionTag | undefined,
 	id: MoveId,
 	count: number,
-	effect: MoveEffect<T>,
+	effect: MoveEffect,
 	invalidate: boolean = true,
 ) {
-	(effect as MoveEffectWithBasis<T>).basis = id;
+	(effect as MoveEffectWithBasis).basis = id;
 	moveEffects.set(target, revision, id, count, effect, invalidate);
 }
 
-export function getMoveEffect<T>(
-	moveEffects: MoveEffectTable<T>,
+export function getMoveEffect(
+	moveEffects: MoveEffectTable,
 	target: CrossFieldTarget,
 	revision: RevisionTag | undefined,
 	id: MoveId,
 	count: number,
 	addDependency: boolean = true,
-): RangeQueryResult<MoveEffect<T>> {
+): RangeQueryResult<MoveEffect> {
 	const result = moveEffects.get(target, revision, id, count, addDependency);
 	return result.value !== undefined
-		? { ...result, value: adjustMoveEffectBasis(result.value as MoveEffectWithBasis<T>, id) }
+		? { ...result, value: adjustMoveEffectBasis(result.value as MoveEffectWithBasis, id) }
 		: result;
 }
 
-export type MoveMark<T> = CellMark<MoveMarkEffect, T>;
+export type MoveMark = CellMark<MoveMarkEffect>;
 
 export function isMoveMark(effect: MarkEffect): effect is MoveMarkEffect {
 	return isMoveOut(effect) || isMoveIn(effect);
@@ -114,7 +129,7 @@ export function getMoveIn(effect: MarkEffect): MoveIn | undefined {
 	}
 }
 
-function adjustMoveEffectBasis<T>(effect: MoveEffectWithBasis<T>, newBasis: MoveId): MoveEffect<T> {
+function adjustMoveEffectBasis(effect: MoveEffectWithBasis, newBasis: MoveId): MoveEffect {
 	if (effect.basis === newBasis) {
 		return effect;
 	}
@@ -124,10 +139,18 @@ function adjustMoveEffectBasis<T>(effect: MoveEffectWithBasis<T>, newBasis: Move
 	assert(basisShift > 0, 0x812 /* Expected basis shift to be positive */);
 
 	if (effect.endpoint !== undefined) {
-		adjusted.endpoint = {
-			...effect.endpoint,
-			localId: brand(effect.endpoint.localId + basisShift),
-		};
+		adjusted.endpoint = adjustChangeAtomId(effect.endpoint, basisShift);
+	}
+
+	if (effect.truncatedEndpoint !== undefined) {
+		adjusted.truncatedEndpoint = adjustChangeAtomId(effect.truncatedEndpoint, basisShift);
+	}
+
+	if (effect.truncatedEndpointForInner !== undefined) {
+		adjusted.truncatedEndpointForInner = adjustChangeAtomId(
+			effect.truncatedEndpointForInner,
+			basisShift,
+		);
 	}
 
 	if (effect.movedEffect !== undefined) {
@@ -138,11 +161,11 @@ function adjustMoveEffectBasis<T>(effect: MoveEffectWithBasis<T>, newBasis: Move
 	return adjusted;
 }
 
-export function splitMarkForMoveEffects<T>(
-	mark: Mark<T>,
+export function splitMarkForMoveEffects(
+	mark: Mark,
 	revision: RevisionTag | undefined,
-	effects: MoveEffectTable<T>,
-): Mark<T>[] {
+	effects: MoveEffectTable,
+): Mark[] {
 	const length = getFirstMoveEffectLength(mark, mark.count, revision, effects);
 	return length < mark.count ? splitMark(mark, length) : [mark];
 }
@@ -151,7 +174,7 @@ function getFirstMoveEffectLength(
 	markEffect: MarkEffect,
 	count: number,
 	revision: RevisionTag | undefined,
-	effects: MoveEffectTable<unknown>,
+	effects: MoveEffectTable,
 ): number {
 	if (isMoveMark(markEffect)) {
 		return getMoveEffect(
@@ -182,3 +205,10 @@ export function getCrossFieldTargetFromMove(mark: MoveMarkEffect): CrossFieldTar
 			unreachableCase(type);
 	}
 }
+
+function adjustChangeAtomId(id: ChangeAtomId, shift: number): ChangeAtomId {
+	return {
+		...id,
+		localId: brand(id.localId + shift),
+	};
+}

package/src/feature-libraries/sequence-field/prune.ts

@@ -3,17 +3,13 @@
  * Licensed under the MIT License.
  */
 
-import { Changeset } from "./types.js";
+import { NodeChangePruner } from "../modular-schema/index.js";
 import { MarkListFactory } from "./markListFactory.js";
+import { Changeset } from "./types.js";
 import { withNodeChange } from "./utils.js";
 
-export type NodeChangePruner<TNodeChange> = (change: TNodeChange) => TNodeChange | undefined;
-
-export function prune<TNodeChange>(
-	changeset: Changeset<TNodeChange>,
-	pruneNode: NodeChangePruner<TNodeChange>,
-): Changeset<TNodeChange> {
-	const pruned = new MarkListFactory<TNodeChange>();
+export function prune(changeset: Changeset, pruneNode: NodeChangePruner): Changeset {
+	const pruned = new MarkListFactory();
 	for (let mark of changeset) {
 		if (mark.changes !== undefined) {
 			mark = withNodeChange(mark, pruneNode(mark.changes));