@fluidframework/merge-tree 2.12.0 → 2.13.0

package/src/segmentInfos.ts

@@ -0,0 +1,377 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { assert, isObject } from "@fluidframework/core-utils/internal";
+
+import { ISegmentInternal, ISegmentPrivate, MergeBlock } from "./mergeTreeNodes.js";
+import type { ReferencePosition } from "./referencePositions.js";
+
+export interface StringToType {
+	"string": string;
+	"number": number;
+	"object": object;
+	"array": [];
+	"boolean": boolean;
+}
+
+export function propExists<P extends string>(
+	thing: unknown,
+	prop: P,
+): thing is Record<P, unknown> {
+	return isObject(thing) && prop in thing;
+}
+
+export function hasProp<P extends string, T extends keyof StringToType>(
+	thing: unknown,
+	prop: P,
+	type: T,
+): thing is Record<P, StringToType[typeof type]> {
+	return (
+		propExists(thing, prop) &&
+		(type === "array" ? Array.isArray(thing[prop]) : typeof thing[prop] === type)
+	);
+}
+
+export function propInstanceOf<P extends string, T>(
+	thing: unknown,
+	prop: P,
+	type: new (...args: any[]) => T,
+): thing is Record<P, T> {
+	return propExists(thing, prop) && thing[prop] instanceof type;
+}
+
+/**
+ * Contains insertion information associated to an {@link ISegment}.
+ */
+export interface IInsertionInfo {
+	/**
+	 * Short clientId for the client that inserted this segment.
+	 */
+	clientId: number;
+	/**
+	 * Local seq at which this segment was inserted.
+	 * This is defined if and only if the insertion of the segment is pending ack, i.e. `seq` is UnassignedSequenceNumber.
+	 * Once the segment is acked, this field is cleared.
+	 *
+	 * @privateRemarks
+	 * See {@link CollaborationWindow.localSeq} for more information on the semantics of localSeq.
+	 */
+	localSeq?: number;
+	/**
+	 * Seq at which this segment was inserted.
+	 * If undefined, it is assumed the segment was inserted prior to the collab window's minimum sequence number.
+	 */
+	seq: number;
+}
+
+/**
+ * Converts a segment-like object to an insertion info object if possible.
+ *
+ * @param segmentLike - The segment-like object to convert.
+ * @returns The insertion info object if the conversion is possible, otherwise undefined.
+ */
+export const toInsertionInfo = (segmentLike: unknown): IInsertionInfo | undefined =>
+	hasProp(segmentLike, "clientId", "number") && hasProp(segmentLike, "seq", "number")
+		? segmentLike
+		: undefined;
+
+/**
+ * A type-guard which determines if the segment has insertion info, and
+ * returns true if it does, along with applying strong typing.
+ *
+ * @param segmentLike - The segment-like object to check.
+ * @returns True if the segment has insertion info, otherwise false.
+ */
+export const isInserted = (segmentLike: unknown): segmentLike is IInsertionInfo =>
+	toInsertionInfo(segmentLike) !== undefined;
+
+/**
+ * Asserts that the segment has insertion info. Usage of this function should not produce a user facing error.
+ *
+ * @param segmentLike - The segment-like object to check.
+ * @throws Will throw an error if the segment does not have insertion info.
+ */
+export const assertInserted: <T extends Partial<IInsertionInfo> | undefined>(
+	segmentLike: ISegmentInternal | Partial<IInsertionInfo> | T,
+) => asserts segmentLike is IInsertionInfo | Exclude<T, Partial<IInsertionInfo>> = (
+	segmentLike,
+) =>
+	assert(
+		segmentLike === undefined || isInserted(segmentLike),
+		0xaa0 /* must be insertionInfo */,
+	);
+
+/**
+ * Common properties for a node in a merge tree.
+ */
+export interface IMergeNodeInfo {
+	/**
+	 * The parent merge block if the node is parented
+	 */
+	parent: MergeBlock;
+
+	/**
+	 * The index of this node in its parent's list of children.
+	 */
+	index: number;
+
+	/**
+	 * A string that can be used for comparing the location of this node to other `MergeNode`s in the same tree.
+	 * `a.ordinal < b.ordinal` if and only if `a` comes before `b` in a pre-order traversal of the tree.
+	 */
+	ordinal: string;
+}
+
+/**
+ * Converts a segment-like object to a merge node info object if possible.
+ *
+ * @param segmentLike - The segment-like object to convert.
+ * @returns The merge node info object if the conversion is possible, otherwise undefined.
+ */
+export const toMergeNodeInfo = (nodeLike: unknown): IMergeNodeInfo | undefined =>
+	propInstanceOf(nodeLike, "parent", MergeBlock) &&
+	hasProp(nodeLike, "ordinal", "string") &&
+	hasProp(nodeLike, "index", "number")
+		? nodeLike
+		: undefined;
+
+/**
+ * A type-guard which determines if the segment has merge node info, and
+ * returns true if it does, along with applying strong typing.
+ *
+ * @param nodeLike - The segment-like object to check.
+ * @returns True if the segment has merge node info, otherwise false.
+ */
+export const isMergeNodeInfo = (nodeLike: unknown): nodeLike is IMergeNodeInfo =>
+	toMergeNodeInfo(nodeLike) !== undefined;
+
+/**
+ * Asserts that the segment has merge node info. Usage of this function should not produce a user facing error.
+ *
+ * @param segmentLike - The segment-like object to check.
+ * @throws Will throw an error if the segment does not have merge node info.
+ */
+export const assertMergeNode: <T extends Partial<IMergeNodeInfo> | undefined>(
+	nodeLike: ISegmentInternal | ISegmentPrivate | Partial<IMergeNodeInfo> | T,
+) => asserts nodeLike is IMergeNodeInfo | Exclude<T, Partial<IMergeNodeInfo>> = (
+	segmentLike,
+) =>
+	assert(
+		segmentLike === undefined || isMergeNodeInfo(segmentLike),
+		0xaa1 /* must be MergeNodeInfo */,
+	);
+
+/**
+ * Removes the merge node info. This is used to remove nodes from the merge-tree.
+ * @param segmentLike - The segment-like object to check.
+ * @returns This function will change the type of the provided node like to never via an assertion. This
+ * ensures no further usage of the removed merge node info is allowed. if continued use is required other
+ * type coercion methods should be used to correctly re-type the variable.
+ */
+export const removeMergeNodeInfo: (nodeLike: IMergeNodeInfo) => asserts nodeLike is never = (
+	nodeLike,
+) =>
+	Object.assign<IMergeNodeInfo, Record<keyof IMergeNodeInfo, undefined>>(nodeLike, {
+		parent: undefined,
+		index: undefined,
+		ordinal: undefined,
+	});
+
+/**
+ * Contains removal information associated to an {@link ISegment}.
+ * @legacy
+ * @alpha
+ * @deprecated - This interface will be removed in 2.20 with no replacement.
+ */
+export interface IRemovalInfo {
+	/**
+	 * Local seq at which this segment was removed, if the removal is yet-to-be acked.
+	 */
+	localRemovedSeq?: number;
+	/**
+	 * Seq at which this segment was removed.
+	 */
+	removedSeq: number;
+	/**
+	 * List of client IDs that have removed this segment.
+	 * The client that actually removed the segment (i.e. whose removal op was sequenced first) is stored as the first
+	 * client in this list. Other clients in the list have all issued concurrent ops to remove the segment.
+	 * @remarks When this list has length \> 1, this is referred to as the "overlapping remove" case.
+	 */
+	removedClientIds: number[];
+}
+
+/**
+ * Converts a segment-like object to a removal info object if possible.
+ *
+ * @param segmentLike - The segment-like object to convert.
+ * @returns The removal info object if the conversion is possible, otherwise undefined.
+ */
+export const toRemovalInfo = (segmentLike: unknown): IRemovalInfo | undefined =>
+	hasProp(segmentLike, "removedClientIds", "array") &&
+	hasProp(segmentLike, "removedSeq", "number")
+		? segmentLike
+		: undefined;
+
+/**
+ * A type-guard which determines if the segment has removal info, and
+ * returns true if it does, along with applying strong typing.
+ *
+ * @param segmentLike - The segment-like object to check.
+ * @returns True if the segment has removal info, otherwise false.
+ */
+export const isRemoved = (segmentLike: unknown): segmentLike is IRemovalInfo =>
+	toRemovalInfo(segmentLike) !== undefined;
+
+/**
+ * Asserts that the segment has removal info. Usage of this function should not produce a user facing error.
+ *
+ * @param segmentLike - The segment-like object to check.
+ * @throws Will throw an error if the segment does not have removal info.
+ */
+export const assertRemoved: <T extends Partial<IRemovalInfo> | undefined>(
+	segmentLike: ISegmentInternal | Partial<IRemovalInfo> | T,
+) => asserts segmentLike is IRemovalInfo | Exclude<T, Partial<IRemovalInfo>> = (segmentLike) =>
+	assert(segmentLike === undefined || isRemoved(segmentLike), 0xaa2 /* must be removalInfo */);
+
+/**
+ * Removes the removal info. This is used in rollback.
+ * @param segmentLike - The segment-like object to check.
+ * @returns This function will change the type of the provided node like to never via an assertion. This
+ * ensures no further usage of the removed removal info is allowed. if continued use is required other
+ * type coercion methods should be use to correctly re-type the variable.
+ */
+export const removeRemovalInfo: (nodeLike: IRemovalInfo) => asserts nodeLike is never = (
+	nodeLike,
+) =>
+	Object.assign<IRemovalInfo, Record<keyof IRemovalInfo, undefined>>(nodeLike, {
+		localRemovedSeq: undefined,
+		removedClientIds: undefined,
+		removedSeq: undefined,
+	});
+
+/**
+ * Tracks information about when and where this segment was moved to.
+ *
+ * Note that merge-tree does not currently support moving and only supports
+ * obliterate. The fields below include "move" in their names to avoid renaming
+ * in the future, when moves _are_ supported.
+ * @legacy
+ * @alpha
+ * @deprecated - This interface will be removed in 2.20 with no replacement.
+ */
+export interface IMoveInfo {
+	/**
+	 * Local seq at which this segment was moved if the move is yet-to-be
+	 * acked.
+	 */
+	localMovedSeq?: number;
+
+	/**
+	 * The first seq at which this segment was moved.
+	 */
+	movedSeq: number;
+
+	/**
+	 * All seqs at which this segment was moved. In the case of overlapping,
+	 * concurrent moves this array will contain multiple seqs.
+	 *
+	 * The seq at  `movedSeqs[i]` corresponds to the client id at `movedClientIds[i]`.
+	 *
+	 * The first element corresponds to the seq of the first move
+	 */
+	movedSeqs: number[];
+
+	/**
+	 * A reference to the inserted destination segment corresponding to this
+	 * segment's move.
+	 *
+	 * If undefined, the move was an obliterate.
+	 *
+	 * Currently this field is unused, as we only support obliterate operations
+	 */
+	moveDst?: ReferencePosition;
+
+	/**
+	 * List of client IDs that have moved this segment.
+	 *
+	 * The client that actually moved the segment (i.e. whose move op was sequenced
+	 * first) is stored as the first client in this list. Other clients in the
+	 * list have all issued concurrent ops to move the segment.
+	 */
+	movedClientIds: number[];
+
+	/**
+	 * If this segment was inserted into a concurrently moved range and
+	 * the move op was sequenced before the insertion op. In this case,
+	 * the segment is visible only to the inserting client
+	 *
+	 * `wasMovedOnInsert` only applies for acked obliterates. That is, if
+	 * a segment inserted by a remote client is moved on insertion by a local
+	 * and unacked obliterate, we do not consider it as having been moved
+	 * on insert
+	 *
+	 * If a segment is moved on insertion, its length is only ever visible to
+	 * the client that inserted the segment. This is relevant in partial length
+	 * calculations
+	 */
+	wasMovedOnInsert: boolean;
+}
+export const toMoveInfo = (segmentLike: unknown): IMoveInfo | undefined =>
+	hasProp(segmentLike, "movedClientIds", "array") &&
+	hasProp(segmentLike, "movedSeq", "number") &&
+	hasProp(segmentLike, "movedSeqs", "array") &&
+	hasProp(segmentLike, "wasMovedOnInsert", "boolean")
+		? segmentLike
+		: undefined;
+
+/**
+ * A type-guard which determines if the segment has move info, and
+ * returns true if it does, along with applying strong typing.
+ *
+ * @param segmentLike - The segment-like object to check.
+ * @returns True if the segment has move info, otherwise false.
+ */
+export const isMoved = (segmentLike: unknown): segmentLike is IMoveInfo =>
+	toMoveInfo(segmentLike) !== undefined;
+
+/**
+ * Asserts that the segment has move info. Usage of this function should not produce a user facing error.
+ *
+ * @param segmentLike - The segment-like object to check.
+ * @throws Will throw an error if the segment does not have move info.
+ */
+export const assertMoved: <T extends Partial<IMoveInfo> | undefined>(
+	segmentLike: ISegmentInternal | Partial<IMoveInfo> | T,
+) => asserts segmentLike is IMoveInfo | Exclude<T, Partial<IMoveInfo>> = (segmentLike) =>
+	assert(segmentLike === undefined || isMoved(segmentLike), 0xaa3 /* must be moveInfo */);
+
+/**
+ * A union type representing any segment info.
+ */
+export type SegmentInfo = IMergeNodeInfo | IInsertionInfo | IMoveInfo | IRemovalInfo;
+
+/**
+ * A type representing a segment with additional info.
+ */
+export type SegmentWithInfo<
+	T extends SegmentInfo,
+	S extends ISegmentPrivate = ISegmentPrivate,
+> = S & T;
+
+/**
+ * Overwrites the segment info on a segment-like object.
+ *
+ * @param segmentLike - The segment-like object to set the info on.
+ * @param info - The segment info to overwrite.
+ * @returns The segment-like object with the info set.
+ */
+export const overwriteInfo = <
+	T extends SegmentInfo,
+	S extends ISegmentPrivate = ISegmentPrivate,
+>(
+	segmentLike: S,
+	info: T,
+): SegmentWithInfo<T, S> => Object.assign(segmentLike, info);

package/src/snapshotLoader.ts

@@ -20,12 +20,20 @@ import {
 	createChildLogger,
 } from "@fluidframework/telemetry-utils/internal";
 
-// eslint-disable-next-line import/no-deprecated
 import { Client } from "./client.js";
 import { NonCollabClient, UniversalSequenceNumber } from "./constants.js";
 import { MergeTree } from "./mergeTree.js";
-import { ISegmentLeaf } from "./mergeTreeNodes.js";
+import { ISegmentPrivate } from "./mergeTreeNodes.js";
 import { IJSONSegment } from "./ops.js";
+import {
+	// eslint-disable-next-line import/no-deprecated
+	IRemovalInfo,
+	overwriteInfo,
+	type IInsertionInfo,
+	// eslint-disable-next-line import/no-deprecated
+	type IMoveInfo,
+	type SegmentWithInfo,
+} from "./segmentInfos.js";
 import {
 	IJSONSegmentWithMergeInfo,
 	MergeTreeChunkV1,
@@ -39,7 +47,7 @@ export class SnapshotLoader {
 
 	constructor(
 		private readonly runtime: IFluidDataStoreRuntime,
-		// eslint-disable-next-line import/no-deprecated
+
 		private readonly client: Client,
 		private readonly mergeTree: MergeTree,
 		logger: ITelemetryLoggerExt,
@@ -96,60 +104,57 @@ export class SnapshotLoader {
 
 	private readonly specToSegment = (
 		spec: IJSONSegment | IJSONSegmentWithMergeInfo,
-	): ISegmentLeaf => {
-		let seg: ISegmentLeaf;
-
+	): SegmentWithInfo<IInsertionInfo> => {
 		if (hasMergeInfo(spec)) {
-			seg = this.client.specToSegment(spec.json);
-
-			// `specToSegment()` initializes `seg` with the LocalClientId.  Overwrite this with
-			// the `spec` client (if specified).  Otherwise overwrite with `NonCollabClient`.
-			seg.clientId =
-				spec.client === undefined
-					? NonCollabClient
-					: this.client.getOrAddShortClientId(spec.client);
-
-			seg.seq = spec.seq ?? UniversalSequenceNumber;
+			const seg = overwriteInfo<IInsertionInfo>(this.client.specToSegment(spec.json), {
+				clientId:
+					spec.client === undefined
+						? NonCollabClient
+						: this.client.getOrAddShortClientId(spec.client),
+				seq: spec.seq ?? UniversalSequenceNumber,
+			});
 
 			if (spec.removedSeq !== undefined) {
-				seg.removedSeq = spec.removedSeq;
+				// this format had a bug where it didn't store all the overlap clients
+				// this is for back compat, so we change the singular id to an array
+				// this will only cause problems if there is an overlapping delete
+				// spanning the snapshot, which should be rare
+				const specAsBuggyFormat: IJSONSegmentWithMergeInfo & { removedClient?: string } = spec;
+				if (specAsBuggyFormat.removedClient !== undefined) {
+					spec.removedClientIds ??= [specAsBuggyFormat.removedClient];
+				}
+				assert(spec.removedClientIds !== undefined, 0xaa4 /* must have removedClient ids */);
+				// eslint-disable-next-line import/no-deprecated
+				overwriteInfo<IRemovalInfo>(seg, {
+					removedSeq: spec.removedSeq,
+					removedClientIds: spec.removedClientIds.map((id) =>
+						this.client.getOrAddShortClientId(id),
+					),
+				});
 			}
 			if (spec.movedSeq !== undefined) {
-				seg.movedSeq = spec.movedSeq;
-			}
-			if (spec.movedSeqs !== undefined) {
-				seg.movedSeqs = spec.movedSeqs;
-			}
-			// this format had a bug where it didn't store all the overlap clients
-			// this is for back compat, so we change the singular id to an array
-			// this will only cause problems if there is an overlapping delete
-			// spanning the snapshot, which should be rare
-			const specAsBuggyFormat: IJSONSegmentWithMergeInfo & { removedClient?: string } = spec;
-			if (specAsBuggyFormat.removedClient !== undefined) {
-				seg.removedClientIds = [
-					this.client.getOrAddShortClientId(specAsBuggyFormat.removedClient),
-				];
-			}
-			if (spec.removedClientIds !== undefined) {
-				seg.removedClientIds = spec.removedClientIds?.map((sid) =>
-					this.client.getOrAddShortClientId(sid),
-				);
-			}
-			if (spec.movedClientIds !== undefined) {
-				seg.movedClientIds = spec.movedClientIds?.map((sid) =>
-					this.client.getOrAddShortClientId(sid),
+				assert(
+					spec.movedClientIds !== undefined && spec.movedSeqs !== undefined,
+					0xaa5 /* must have movedIds ids */,
 				);
+				// eslint-disable-next-line import/no-deprecated
+				overwriteInfo<IMoveInfo>(seg, {
+					movedSeq: spec.movedSeq,
+					movedSeqs: spec.movedSeqs,
+					movedClientIds: spec.movedClientIds.map((id) =>
+						this.client.getOrAddShortClientId(id),
+					),
+					// BUG? This isn't persisted
+					wasMovedOnInsert: false,
+				});
 			}
-		} else {
-			seg = this.client.specToSegment(spec);
-			seg.seq = UniversalSequenceNumber;
 
-			// `specToSegment()` initializes `seg` with the LocalClientId.  We must overwrite this with
-			// `NonCollabClient`.
-			seg.clientId = NonCollabClient;
+			return seg;
 		}
-
-		return seg;
+		return overwriteInfo(this.client.specToSegment(spec), {
+			seq: UniversalSequenceNumber,
+			clientId: NonCollabClient,
+		});
 	};
 
 	private loadHeader(header: string): MergeTreeChunkV1 {
@@ -207,7 +212,7 @@ export class SnapshotLoader {
 		}
 
 		let chunksWithAttribution = chunk1.attribution === undefined ? 0 : 1;
-		const segs: ISegmentLeaf[] = [];
+		const segs: SegmentWithInfo<IInsertionInfo>[] = [];
 		let lengthSofar = chunk1.length;
 		for (
 			let chunkIndex = 1;
@@ -244,7 +249,7 @@ export class SnapshotLoader {
 
 		// Helper to insert segments at the end of the MergeTree.
 		const mergeTree = this.mergeTree;
-		const append = (segments: ISegmentLeaf[], cli: number, seq: number): void => {
+		const append = (segments: ISegmentPrivate[], cli: number, seq: number): void => {
 			mergeTree.insertSegments(
 				mergeTree.root.cachedLength ?? 0,
 				segments,
@@ -256,7 +261,7 @@ export class SnapshotLoader {
 		};
 
 		// Helpers to batch-insert segments that are below the min seq
-		const batch: ISegmentLeaf[] = [];
+		const batch: SegmentWithInfo<IInsertionInfo>[] = [];
 		const flushBatch = (): void => {
 			if (batch.length > 0) {
 				append(batch, NonCollabClient, UniversalSequenceNumber);
@@ -264,23 +269,21 @@ export class SnapshotLoader {
 		};
 
 		for (const seg of segs) {
-			const cli = seg.clientId;
-			const seq = seg.seq;
-
+			const { clientId, seq } = seg;
 			// If the segment can be batch inserted, add it to the 'batch' array.  Otherwise, flush
 			// any batched segments and then insert the current segment individually.
-			if (cli === NonCollabClient && seq === UniversalSequenceNumber) {
+			if (clientId === NonCollabClient && seq === UniversalSequenceNumber) {
 				batch.push(seg);
 			} else {
 				flushBatch();
-				append([seg], cli, seq!);
+				append([seg], clientId, seq);
 			}
 		}
 
 		flushBatch();
 	}
 
-	private extractAttribution(segments: ISegmentLeaf[], chunk: MergeTreeChunkV1): void {
+	private extractAttribution(segments: ISegmentPrivate[], chunk: MergeTreeChunkV1): void {
 		if (chunk.attribution) {
 			const { attributionPolicy } = this.mergeTree;
 			if (attributionPolicy === undefined) {

package/src/snapshotV1.ts

@@ -22,9 +22,10 @@ import { IAttributionCollection } from "./attributionCollection.js";
 import { UnassignedSequenceNumber } from "./constants.js";
 import { MergeTree } from "./mergeTree.js";
 import { walkAllChildSegments } from "./mergeTreeNodeWalk.js";
-import { ISegmentLeaf } from "./mergeTreeNodes.js";
+import { ISegmentPrivate } from "./mergeTreeNodes.js";
 import type { IJSONSegment } from "./ops.js";
 import { PropertySet, matchProperties } from "./properties.js";
+import { assertInserted, isMoved, isRemoved } from "./segmentInfos.js";
 import {
 	IJSONSegmentWithMergeInfo,
 	JsonSegmentSpecs,
@@ -208,7 +209,7 @@ export class SnapshotV1 {
 		};
 
 		// Helper to serialize the given `segment` and add it to the snapshot (if a segment is provided).
-		const pushSeg = (segment?: ISegmentLeaf): void => {
+		const pushSeg = (segment?: ISegmentPrivate): void => {
 			if (segment) {
 				if (segment.properties !== undefined && Object.keys(segment.properties).length === 0) {
 					segment.properties = undefined;
@@ -221,8 +222,9 @@ export class SnapshotV1 {
 			}
 		};
 
-		let prev: ISegmentLeaf | undefined;
-		const extractSegment = (segment: ISegmentLeaf): boolean => {
+		let prev: ISegmentPrivate | undefined;
+		const extractSegment = (segment: ISegmentPrivate): boolean => {
+			assertInserted(segment);
 			// Elide segments that do not need to be included in the snapshot.  A segment may be elided if
 			// either condition is true:
 			//   a) The segment has not yet been ACKed.  We do not need to snapshot unACKed segments because
@@ -231,10 +233,8 @@ export class SnapshotV1 {
 			//      segment, and therefore we can discard it.
 			if (
 				segment.seq === UnassignedSequenceNumber ||
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				segment.removedSeq! <= minSeq ||
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				segment.movedSeq! <= minSeq
+				(isRemoved(segment) && segment.removedSeq <= minSeq) ||
+				(isMoved(segment) && segment.movedSeq <= minSeq)
 			) {
 				if (segment.seq !== UnassignedSequenceNumber) {
 					originalSegments += 1;
@@ -248,11 +248,10 @@ export class SnapshotV1 {
 			// (seq, client, etc.)  This information is only needed if the segment is above the MSN (and doesn't
 			// have a pending remove.)
 			if (
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				segment.seq! <= minSeq && // Segment is below the MSN, and...
-				(segment.removedSeq === undefined || // .. Segment has not been removed, or...
+				segment.seq <= minSeq && // Segment is below the MSN, and...
+				(!isRemoved(segment) || // .. Segment has not been removed, or...
 					segment.removedSeq === UnassignedSequenceNumber) && // .. Removal op to be delivered on reconnect
-				(segment.movedSeq === undefined || segment.movedSeq === UnassignedSequenceNumber)
+				(!isMoved(segment) || segment.movedSeq === UnassignedSequenceNumber)
 			) {
 				// This segment is below the MSN, which means that future ops will not reference it.  Attempt to
 				// coalesce the new segment with the previous (if any).
@@ -286,14 +285,13 @@ export class SnapshotV1 {
 					json: segment.toJSONObject() as IJSONSegment,
 				};
 				// If the segment insertion is above the MSN, record the insertion merge info.
-				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-				if (segment.seq! > minSeq) {
+				if (segment.seq > minSeq) {
 					raw.seq = segment.seq;
 					raw.client = this.getLongClientId(segment.clientId);
 				}
 				// We have already dispensed with removed segments below the MSN and removed segments with unassigned
 				// sequence numbers.  Any remaining removal info should be preserved.
-				if (segment.removedSeq !== undefined) {
+				if (isRemoved(segment)) {
 					assert(
 						segment.removedSeq !== UnassignedSequenceNumber && segment.removedSeq > minSeq,
 						0x065 /* "On removal info preservation, segment has invalid removed sequence number!" */,
@@ -311,7 +309,7 @@ export class SnapshotV1 {
 					);
 				}
 
-				if (segment.movedSeq !== undefined) {
+				if (isMoved(segment)) {
 					assert(
 						segment.movedSeq !== UnassignedSequenceNumber && segment.movedSeq > minSeq,
 						0x873 /* On move info preservation, segment has invalid moved sequence number! */,