@fluidframework/merge-tree 2.12.0 → 2.13.0

package/dist/segmentInfos.d.ts

@@ -0,0 +1,257 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+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 declare function propExists<P extends string>(thing: unknown, prop: P): thing is Record<P, unknown>;
+export declare function hasProp<P extends string, T extends keyof StringToType>(thing: unknown, prop: P, type: T): thing is Record<P, StringToType[typeof type]>;
+export declare function propInstanceOf<P extends string, T>(thing: unknown, prop: P, type: new (...args: any[]) => T): thing is Record<P, T>;
+/**
+ * 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 declare const toInsertionInfo: (segmentLike: unknown) => IInsertionInfo | 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 declare const isInserted: (segmentLike: unknown) => segmentLike is IInsertionInfo;
+/**
+ * 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 declare const assertInserted: <T extends Partial<IInsertionInfo> | undefined>(segmentLike: ISegmentInternal | Partial<IInsertionInfo> | T) => asserts segmentLike is IInsertionInfo | Exclude<T, Partial<IInsertionInfo>>;
+/**
+ * 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 declare const toMergeNodeInfo: (nodeLike: unknown) => IMergeNodeInfo | 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 declare const isMergeNodeInfo: (nodeLike: unknown) => nodeLike is IMergeNodeInfo;
+/**
+ * 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 declare const assertMergeNode: <T extends Partial<IMergeNodeInfo> | undefined>(nodeLike: ISegmentInternal | ISegmentPrivate | Partial<IMergeNodeInfo> | T) => asserts nodeLike is IMergeNodeInfo | Exclude<T, Partial<IMergeNodeInfo>>;
+/**
+ * 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 declare const removeMergeNodeInfo: (nodeLike: IMergeNodeInfo) => asserts nodeLike is never;
+/**
+ * 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 declare const toRemovalInfo: (segmentLike: unknown) => IRemovalInfo | 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 declare const isRemoved: (segmentLike: unknown) => segmentLike is IRemovalInfo;
+/**
+ * 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 declare const assertRemoved: <T extends Partial<IRemovalInfo> | undefined>(segmentLike: ISegmentInternal | Partial<IRemovalInfo> | T) => asserts segmentLike is IRemovalInfo | Exclude<T, Partial<IRemovalInfo>>;
+/**
+ * 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 declare const removeRemovalInfo: (nodeLike: IRemovalInfo) => asserts nodeLike is never;
+/**
+ * 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 declare const toMoveInfo: (segmentLike: unknown) => IMoveInfo | 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 declare const isMoved: (segmentLike: unknown) => segmentLike is IMoveInfo;
+/**
+ * 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 declare const assertMoved: <T extends Partial<IMoveInfo> | undefined>(segmentLike: ISegmentInternal | Partial<IMoveInfo> | T) => asserts segmentLike is IMoveInfo | Exclude<T, Partial<IMoveInfo>>;
+/**
+ * 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 declare const overwriteInfo: <T extends SegmentInfo, S extends ISegmentPrivate = ISegmentPrivate>(segmentLike: S, info: T) => SegmentWithInfo<T, S>;
+//# sourceMappingURL=segmentInfos.d.ts.map

package/dist/segmentInfos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmentInfos.d.ts","sourceRoot":"","sources":["../src/segmentInfos.ts"],"names":[],"mappings":"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"}

package/dist/segmentInfos.js

@@ -0,0 +1,166 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overwriteInfo = exports.assertMoved = exports.isMoved = exports.toMoveInfo = exports.removeRemovalInfo = exports.assertRemoved = exports.isRemoved = exports.toRemovalInfo = exports.removeMergeNodeInfo = exports.assertMergeNode = exports.isMergeNodeInfo = exports.toMergeNodeInfo = exports.assertInserted = exports.isInserted = exports.toInsertionInfo = exports.propInstanceOf = exports.hasProp = exports.propExists = void 0;
+const internal_1 = require("@fluidframework/core-utils/internal");
+const mergeTreeNodes_js_1 = require("./mergeTreeNodes.js");
+function propExists(thing, prop) {
+    return (0, internal_1.isObject)(thing) && prop in thing;
+}
+exports.propExists = propExists;
+function hasProp(thing, prop, type) {
+    return (propExists(thing, prop) &&
+        (type === "array" ? Array.isArray(thing[prop]) : typeof thing[prop] === type));
+}
+exports.hasProp = hasProp;
+function propInstanceOf(thing, prop, type) {
+    return propExists(thing, prop) && thing[prop] instanceof type;
+}
+exports.propInstanceOf = propInstanceOf;
+/**
+ * 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.
+ */
+const toInsertionInfo = (segmentLike) => hasProp(segmentLike, "clientId", "number") && hasProp(segmentLike, "seq", "number")
+    ? segmentLike
+    : undefined;
+exports.toInsertionInfo = toInsertionInfo;
+/**
+ * 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.
+ */
+const isInserted = (segmentLike) => (0, exports.toInsertionInfo)(segmentLike) !== undefined;
+exports.isInserted = isInserted;
+/**
+ * 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.
+ */
+const assertInserted = (segmentLike) => (0, internal_1.assert)(segmentLike === undefined || (0, exports.isInserted)(segmentLike), 0xaa0 /* must be insertionInfo */);
+exports.assertInserted = assertInserted;
+/**
+ * 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.
+ */
+const toMergeNodeInfo = (nodeLike) => propInstanceOf(nodeLike, "parent", mergeTreeNodes_js_1.MergeBlock) &&
+    hasProp(nodeLike, "ordinal", "string") &&
+    hasProp(nodeLike, "index", "number")
+    ? nodeLike
+    : undefined;
+exports.toMergeNodeInfo = toMergeNodeInfo;
+/**
+ * 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.
+ */
+const isMergeNodeInfo = (nodeLike) => (0, exports.toMergeNodeInfo)(nodeLike) !== undefined;
+exports.isMergeNodeInfo = isMergeNodeInfo;
+/**
+ * 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.
+ */
+const assertMergeNode = (segmentLike) => (0, internal_1.assert)(segmentLike === undefined || (0, exports.isMergeNodeInfo)(segmentLike), 0xaa1 /* must be MergeNodeInfo */);
+exports.assertMergeNode = assertMergeNode;
+/**
+ * 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.
+ */
+const removeMergeNodeInfo = (nodeLike) => Object.assign(nodeLike, {
+    parent: undefined,
+    index: undefined,
+    ordinal: undefined,
+});
+exports.removeMergeNodeInfo = removeMergeNodeInfo;
+/**
+ * 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.
+ */
+const toRemovalInfo = (segmentLike) => hasProp(segmentLike, "removedClientIds", "array") &&
+    hasProp(segmentLike, "removedSeq", "number")
+    ? segmentLike
+    : undefined;
+exports.toRemovalInfo = toRemovalInfo;
+/**
+ * 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.
+ */
+const isRemoved = (segmentLike) => (0, exports.toRemovalInfo)(segmentLike) !== undefined;
+exports.isRemoved = isRemoved;
+/**
+ * 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.
+ */
+const assertRemoved = (segmentLike) => (0, internal_1.assert)(segmentLike === undefined || (0, exports.isRemoved)(segmentLike), 0xaa2 /* must be removalInfo */);
+exports.assertRemoved = assertRemoved;
+/**
+ * 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.
+ */
+const removeRemovalInfo = (nodeLike) => Object.assign(nodeLike, {
+    localRemovedSeq: undefined,
+    removedClientIds: undefined,
+    removedSeq: undefined,
+});
+exports.removeRemovalInfo = removeRemovalInfo;
+const toMoveInfo = (segmentLike) => hasProp(segmentLike, "movedClientIds", "array") &&
+    hasProp(segmentLike, "movedSeq", "number") &&
+    hasProp(segmentLike, "movedSeqs", "array") &&
+    hasProp(segmentLike, "wasMovedOnInsert", "boolean")
+    ? segmentLike
+    : undefined;
+exports.toMoveInfo = toMoveInfo;
+/**
+ * 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.
+ */
+const isMoved = (segmentLike) => (0, exports.toMoveInfo)(segmentLike) !== undefined;
+exports.isMoved = isMoved;
+/**
+ * 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.
+ */
+const assertMoved = (segmentLike) => (0, internal_1.assert)(segmentLike === undefined || (0, exports.isMoved)(segmentLike), 0xaa3 /* must be moveInfo */);
+exports.assertMoved = assertMoved;
+/**
+ * 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.
+ */
+const overwriteInfo = (segmentLike, info) => Object.assign(segmentLike, info);
+exports.overwriteInfo = overwriteInfo;
+//# sourceMappingURL=segmentInfos.js.map

package/dist/segmentInfos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmentInfos.js","sourceRoot":"","sources":["../src/segmentInfos.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAAuE;AAEvE,2DAAoF;AAWpF,SAAgB,UAAU,CACzB,KAAc,EACd,IAAO;IAEP,OAAO,IAAA,mBAAQ,EAAC,KAAK,CAAC,IAAI,IAAI,IAAI,KAAK,CAAC;AACzC,CAAC;AALD,gCAKC;AAED,SAAgB,OAAO,CACtB,KAAc,EACd,IAAO,EACP,IAAO;IAEP,OAAO,CACN,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC;QACvB,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,CAC7E,CAAC;AACH,CAAC;AATD,0BASC;AAED,SAAgB,cAAc,CAC7B,KAAc,EACd,IAAO,EACP,IAA+B;IAE/B,OAAO,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC;AAC/D,CAAC;AAND,wCAMC;AA0BD;;;;;GAKG;AACI,MAAM,eAAe,GAAG,CAAC,WAAoB,EAA8B,EAAE,CACnF,OAAO,CAAC,WAAW,EAAE,UAAU,EAAE,QAAQ,CAAC,IAAI,OAAO,CAAC,WAAW,EAAE,KAAK,EAAE,QAAQ,CAAC;IAClF,CAAC,CAAC,WAAW;IACb,CAAC,CAAC,SAAS,CAAC;AAHD,QAAA,eAAe,mBAGd;AAEd;;;;;;GAMG;AACI,MAAM,UAAU,GAAG,CAAC,WAAoB,EAAiC,EAAE,CACjF,IAAA,uBAAe,EAAC,WAAW,CAAC,KAAK,SAAS,CAAC;AAD/B,QAAA,UAAU,cACqB;AAE5C;;;;;GAKG;AACI,MAAM,cAAc,GAEwD,CAClF,WAAW,EACV,EAAE,CACH,IAAA,iBAAM,EACL,WAAW,KAAK,SAAS,IAAI,IAAA,kBAAU,EAAC,WAAW,CAAC,EACpD,KAAK,CAAC,2BAA2B,CACjC,CAAC;AARU,QAAA,cAAc,kBAQxB;AAuBH;;;;;GAKG;AACI,MAAM,eAAe,GAAG,CAAC,QAAiB,EAA8B,EAAE,CAChF,cAAc,CAAC,QAAQ,EAAE,QAAQ,EAAE,8BAAU,CAAC;IAC9C,OAAO,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC;IACtC,OAAO,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,CAAC;IACnC,CAAC,CAAC,QAAQ;IACV,CAAC,CAAC,SAAS,CAAC;AALD,QAAA,eAAe,mBAKd;AAEd;;;;;;GAMG;AACI,MAAM,eAAe,GAAG,CAAC,QAAiB,EAA8B,EAAE,CAChF,IAAA,uBAAe,EAAC,QAAQ,CAAC,KAAK,SAAS,CAAC;AAD5B,QAAA,eAAe,mBACa;AAEzC;;;;;GAKG;AACI,MAAM,eAAe,GAEoD,CAC/E,WAAW,EACV,EAAE,CACH,IAAA,iBAAM,EACL,WAAW,KAAK,SAAS,IAAI,IAAA,uBAAe,EAAC,WAAW,CAAC,EACzD,KAAK,CAAC,2BAA2B,CACjC,CAAC;AARU,QAAA,eAAe,mBAQzB;AAEH;;;;;;GAMG;AACI,MAAM,mBAAmB,GAA4D,CAC3F,QAAQ,EACP,EAAE,CACH,MAAM,CAAC,MAAM,CAA0D,QAAQ,EAAE;IAChF,MAAM,EAAE,SAAS;IACjB,KAAK,EAAE,SAAS;IAChB,OAAO,EAAE,SAAS;CAClB,CAAC,CAAC;AAPS,QAAA,mBAAmB,uBAO5B;AA0BJ;;;;;GAKG;AACI,MAAM,aAAa,GAAG,CAAC,WAAoB,EAA4B,EAAE,CAC/E,OAAO,CAAC,WAAW,EAAE,kBAAkB,EAAE,OAAO,CAAC;IACjD,OAAO,CAAC,WAAW,EAAE,YAAY,EAAE,QAAQ,CAAC;IAC3C,CAAC,CAAC,WAAW;IACb,CAAC,CAAC,SAAS,CAAC;AAJD,QAAA,aAAa,iBAIZ;AAEd;;;;;;GAMG;AACI,MAAM,SAAS,GAAG,CAAC,WAAoB,EAA+B,EAAE,CAC9E,IAAA,qBAAa,EAAC,WAAW,CAAC,KAAK,SAAS,CAAC;AAD7B,QAAA,SAAS,aACoB;AAE1C;;;;;GAKG;AACI,MAAM,aAAa,GAEqD,CAAC,WAAW,EAAE,EAAE,CAC9F,IAAA,iBAAM,EAAC,WAAW,KAAK,SAAS,IAAI,IAAA,iBAAS,EAAC,WAAW,CAAC,EAAE,KAAK,CAAC,yBAAyB,CAAC,CAAC;AAHjF,QAAA,aAAa,iBAGoE;AAE9F;;;;;;GAMG;AACI,MAAM,iBAAiB,GAA0D,CACvF,QAAQ,EACP,EAAE,CACH,MAAM,CAAC,MAAM,CAAsD,QAAQ,EAAE;IAC5E,eAAe,EAAE,SAAS;IAC1B,gBAAgB,EAAE,SAAS;IAC3B,UAAU,EAAE,SAAS;CACrB,CAAC,CAAC;AAPS,QAAA,iBAAiB,qBAO1B;AAqEG,MAAM,UAAU,GAAG,CAAC,WAAoB,EAAyB,EAAE,CACzE,OAAO,CAAC,WAAW,EAAE,gBAAgB,EAAE,OAAO,CAAC;IAC/C,OAAO,CAAC,WAAW,EAAE,UAAU,EAAE,QAAQ,CAAC;IAC1C,OAAO,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC;IAC1C,OAAO,CAAC,WAAW,EAAE,kBAAkB,EAAE,SAAS,CAAC;IAClD,CAAC,CAAC,WAAW;IACb,CAAC,CAAC,SAAS,CAAC;AAND,QAAA,UAAU,cAMT;AAEd;;;;;;GAMG;AACI,MAAM,OAAO,GAAG,CAAC,WAAoB,EAA4B,EAAE,CACzE,IAAA,kBAAU,EAAC,WAAW,CAAC,KAAK,SAAS,CAAC;AAD1B,QAAA,OAAO,WACmB;AAEvC;;;;;GAKG;AACI,MAAM,WAAW,GAEiD,CAAC,WAAW,EAAE,EAAE,CACxF,IAAA,iBAAM,EAAC,WAAW,KAAK,SAAS,IAAI,IAAA,eAAO,EAAC,WAAW,CAAC,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAC;AAH5E,QAAA,WAAW,eAGiE;AAezF;;;;;;GAMG;AACI,MAAM,aAAa,GAAG,CAI5B,WAAc,EACd,IAAO,EACiB,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;AANhD,QAAA,aAAa,iBAMmC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert, isObject } from \"@fluidframework/core-utils/internal\";\n\nimport { ISegmentInternal, ISegmentPrivate, MergeBlock } from \"./mergeTreeNodes.js\";\nimport type { ReferencePosition } from \"./referencePositions.js\";\n\nexport interface StringToType {\n\t\"string\": string;\n\t\"number\": number;\n\t\"object\": object;\n\t\"array\": [];\n\t\"boolean\": boolean;\n}\n\nexport function propExists<P extends string>(\n\tthing: unknown,\n\tprop: P,\n): thing is Record<P, unknown> {\n\treturn isObject(thing) && prop in thing;\n}\n\nexport function hasProp<P extends string, T extends keyof StringToType>(\n\tthing: unknown,\n\tprop: P,\n\ttype: T,\n): thing is Record<P, StringToType[typeof type]> {\n\treturn (\n\t\tpropExists(thing, prop) &&\n\t\t(type === \"array\" ? Array.isArray(thing[prop]) : typeof thing[prop] === type)\n\t);\n}\n\nexport function propInstanceOf<P extends string, T>(\n\tthing: unknown,\n\tprop: P,\n\ttype: new (...args: any[]) => T,\n): thing is Record<P, T> {\n\treturn propExists(thing, prop) && thing[prop] instanceof type;\n}\n\n/**\n * Contains insertion information associated to an {@link ISegment}.\n */\nexport interface IInsertionInfo {\n\t/**\n\t * Short clientId for the client that inserted this segment.\n\t */\n\tclientId: number;\n\t/**\n\t * Local seq at which this segment was inserted.\n\t * This is defined if and only if the insertion of the segment is pending ack, i.e. `seq` is UnassignedSequenceNumber.\n\t * Once the segment is acked, this field is cleared.\n\t *\n\t * @privateRemarks\n\t * See {@link CollaborationWindow.localSeq} for more information on the semantics of localSeq.\n\t */\n\tlocalSeq?: number;\n\t/**\n\t * Seq at which this segment was inserted.\n\t * If undefined, it is assumed the segment was inserted prior to the collab window's minimum sequence number.\n\t */\n\tseq: number;\n}\n\n/**\n * Converts a segment-like object to an insertion info object if possible.\n *\n * @param segmentLike - The segment-like object to convert.\n * @returns The insertion info object if the conversion is possible, otherwise undefined.\n */\nexport const toInsertionInfo = (segmentLike: unknown): IInsertionInfo | undefined =>\n\thasProp(segmentLike, \"clientId\", \"number\") && hasProp(segmentLike, \"seq\", \"number\")\n\t\t? segmentLike\n\t\t: undefined;\n\n/**\n * A type-guard which determines if the segment has insertion info, and\n * returns true if it does, along with applying strong typing.\n *\n * @param segmentLike - The segment-like object to check.\n * @returns True if the segment has insertion info, otherwise false.\n */\nexport const isInserted = (segmentLike: unknown): segmentLike is IInsertionInfo =>\n\ttoInsertionInfo(segmentLike) !== undefined;\n\n/**\n * Asserts that the segment has insertion info. Usage of this function should not produce a user facing error.\n *\n * @param segmentLike - The segment-like object to check.\n * @throws Will throw an error if the segment does not have insertion info.\n */\nexport const assertInserted: <T extends Partial<IInsertionInfo> | undefined>(\n\tsegmentLike: ISegmentInternal | Partial<IInsertionInfo> | T,\n) => asserts segmentLike is IInsertionInfo | Exclude<T, Partial<IInsertionInfo>> = (\n\tsegmentLike,\n) =>\n\tassert(\n\t\tsegmentLike === undefined || isInserted(segmentLike),\n\t\t0xaa0 /* must be insertionInfo */,\n\t);\n\n/**\n * Common properties for a node in a merge tree.\n */\nexport interface IMergeNodeInfo {\n\t/**\n\t * The parent merge block if the node is parented\n\t */\n\tparent: MergeBlock;\n\n\t/**\n\t * The index of this node in its parent's list of children.\n\t */\n\tindex: number;\n\n\t/**\n\t * A string that can be used for comparing the location of this node to other `MergeNode`s in the same tree.\n\t * `a.ordinal < b.ordinal` if and only if `a` comes before `b` in a pre-order traversal of the tree.\n\t */\n\tordinal: string;\n}\n\n/**\n * Converts a segment-like object to a merge node info object if possible.\n *\n * @param segmentLike - The segment-like object to convert.\n * @returns The merge node info object if the conversion is possible, otherwise undefined.\n */\nexport const toMergeNodeInfo = (nodeLike: unknown): IMergeNodeInfo | undefined =>\n\tpropInstanceOf(nodeLike, \"parent\", MergeBlock) &&\n\thasProp(nodeLike, \"ordinal\", \"string\") &&\n\thasProp(nodeLike, \"index\", \"number\")\n\t\t? nodeLike\n\t\t: undefined;\n\n/**\n * A type-guard which determines if the segment has merge node info, and\n * returns true if it does, along with applying strong typing.\n *\n * @param nodeLike - The segment-like object to check.\n * @returns True if the segment has merge node info, otherwise false.\n */\nexport const isMergeNodeInfo = (nodeLike: unknown): nodeLike is IMergeNodeInfo =>\n\ttoMergeNodeInfo(nodeLike) !== undefined;\n\n/**\n * Asserts that the segment has merge node info. Usage of this function should not produce a user facing error.\n *\n * @param segmentLike - The segment-like object to check.\n * @throws Will throw an error if the segment does not have merge node info.\n */\nexport const assertMergeNode: <T extends Partial<IMergeNodeInfo> | undefined>(\n\tnodeLike: ISegmentInternal | ISegmentPrivate | Partial<IMergeNodeInfo> | T,\n) => asserts nodeLike is IMergeNodeInfo | Exclude<T, Partial<IMergeNodeInfo>> = (\n\tsegmentLike,\n) =>\n\tassert(\n\t\tsegmentLike === undefined || isMergeNodeInfo(segmentLike),\n\t\t0xaa1 /* must be MergeNodeInfo */,\n\t);\n\n/**\n * Removes the merge node info. This is used to remove nodes from the merge-tree.\n * @param segmentLike - The segment-like object to check.\n * @returns This function will change the type of the provided node like to never via an assertion. This\n * ensures no further usage of the removed merge node info is allowed. if continued use is required other\n * type coercion methods should be used to correctly re-type the variable.\n */\nexport const removeMergeNodeInfo: (nodeLike: IMergeNodeInfo) => asserts nodeLike is never = (\n\tnodeLike,\n) =>\n\tObject.assign<IMergeNodeInfo, Record<keyof IMergeNodeInfo, undefined>>(nodeLike, {\n\t\tparent: undefined,\n\t\tindex: undefined,\n\t\tordinal: undefined,\n\t});\n\n/**\n * Contains removal information associated to an {@link ISegment}.\n * @legacy\n * @alpha\n * @deprecated - This interface will be removed in 2.20 with no replacement.\n */\nexport interface IRemovalInfo {\n\t/**\n\t * Local seq at which this segment was removed, if the removal is yet-to-be acked.\n\t */\n\tlocalRemovedSeq?: number;\n\t/**\n\t * Seq at which this segment was removed.\n\t */\n\tremovedSeq: number;\n\t/**\n\t * List of client IDs that have removed this segment.\n\t * The client that actually removed the segment (i.e. whose removal op was sequenced first) is stored as the first\n\t * client in this list. Other clients in the list have all issued concurrent ops to remove the segment.\n\t * @remarks When this list has length \\> 1, this is referred to as the \"overlapping remove\" case.\n\t */\n\tremovedClientIds: number[];\n}\n\n/**\n * Converts a segment-like object to a removal info object if possible.\n *\n * @param segmentLike - The segment-like object to convert.\n * @returns The removal info object if the conversion is possible, otherwise undefined.\n */\nexport const toRemovalInfo = (segmentLike: unknown): IRemovalInfo | undefined =>\n\thasProp(segmentLike, \"removedClientIds\", \"array\") &&\n\thasProp(segmentLike, \"removedSeq\", \"number\")\n\t\t? segmentLike\n\t\t: undefined;\n\n/**\n * A type-guard which determines if the segment has removal info, and\n * returns true if it does, along with applying strong typing.\n *\n * @param segmentLike - The segment-like object to check.\n * @returns True if the segment has removal info, otherwise false.\n */\nexport const isRemoved = (segmentLike: unknown): segmentLike is IRemovalInfo =>\n\ttoRemovalInfo(segmentLike) !== undefined;\n\n/**\n * Asserts that the segment has removal info. Usage of this function should not produce a user facing error.\n *\n * @param segmentLike - The segment-like object to check.\n * @throws Will throw an error if the segment does not have removal info.\n */\nexport const assertRemoved: <T extends Partial<IRemovalInfo> | undefined>(\n\tsegmentLike: ISegmentInternal | Partial<IRemovalInfo> | T,\n) => asserts segmentLike is IRemovalInfo | Exclude<T, Partial<IRemovalInfo>> = (segmentLike) =>\n\tassert(segmentLike === undefined || isRemoved(segmentLike), 0xaa2 /* must be removalInfo */);\n\n/**\n * Removes the removal info. This is used in rollback.\n * @param segmentLike - The segment-like object to check.\n * @returns This function will change the type of the provided node like to never via an assertion. This\n * ensures no further usage of the removed removal info is allowed. if continued use is required other\n * type coercion methods should be use to correctly re-type the variable.\n */\nexport const removeRemovalInfo: (nodeLike: IRemovalInfo) => asserts nodeLike is never = (\n\tnodeLike,\n) =>\n\tObject.assign<IRemovalInfo, Record<keyof IRemovalInfo, undefined>>(nodeLike, {\n\t\tlocalRemovedSeq: undefined,\n\t\tremovedClientIds: undefined,\n\t\tremovedSeq: undefined,\n\t});\n\n/**\n * Tracks information about when and where this segment was moved to.\n *\n * Note that merge-tree does not currently support moving and only supports\n * obliterate. The fields below include \"move\" in their names to avoid renaming\n * in the future, when moves _are_ supported.\n * @legacy\n * @alpha\n * @deprecated - This interface will be removed in 2.20 with no replacement.\n */\nexport interface IMoveInfo {\n\t/**\n\t * Local seq at which this segment was moved if the move is yet-to-be\n\t * acked.\n\t */\n\tlocalMovedSeq?: number;\n\n\t/**\n\t * The first seq at which this segment was moved.\n\t */\n\tmovedSeq: number;\n\n\t/**\n\t * All seqs at which this segment was moved. In the case of overlapping,\n\t * concurrent moves this array will contain multiple seqs.\n\t *\n\t * The seq at  `movedSeqs[i]` corresponds to the client id at `movedClientIds[i]`.\n\t *\n\t * The first element corresponds to the seq of the first move\n\t */\n\tmovedSeqs: number[];\n\n\t/**\n\t * A reference to the inserted destination segment corresponding to this\n\t * segment's move.\n\t *\n\t * If undefined, the move was an obliterate.\n\t *\n\t * Currently this field is unused, as we only support obliterate operations\n\t */\n\tmoveDst?: ReferencePosition;\n\n\t/**\n\t * List of client IDs that have moved this segment.\n\t *\n\t * The client that actually moved the segment (i.e. whose move op was sequenced\n\t * first) is stored as the first client in this list. Other clients in the\n\t * list have all issued concurrent ops to move the segment.\n\t */\n\tmovedClientIds: number[];\n\n\t/**\n\t * If this segment was inserted into a concurrently moved range and\n\t * the move op was sequenced before the insertion op. In this case,\n\t * the segment is visible only to the inserting client\n\t *\n\t * `wasMovedOnInsert` only applies for acked obliterates. That is, if\n\t * a segment inserted by a remote client is moved on insertion by a local\n\t * and unacked obliterate, we do not consider it as having been moved\n\t * on insert\n\t *\n\t * If a segment is moved on insertion, its length is only ever visible to\n\t * the client that inserted the segment. This is relevant in partial length\n\t * calculations\n\t */\n\twasMovedOnInsert: boolean;\n}\nexport const toMoveInfo = (segmentLike: unknown): IMoveInfo | undefined =>\n\thasProp(segmentLike, \"movedClientIds\", \"array\") &&\n\thasProp(segmentLike, \"movedSeq\", \"number\") &&\n\thasProp(segmentLike, \"movedSeqs\", \"array\") &&\n\thasProp(segmentLike, \"wasMovedOnInsert\", \"boolean\")\n\t\t? segmentLike\n\t\t: undefined;\n\n/**\n * A type-guard which determines if the segment has move info, and\n * returns true if it does, along with applying strong typing.\n *\n * @param segmentLike - The segment-like object to check.\n * @returns True if the segment has move info, otherwise false.\n */\nexport const isMoved = (segmentLike: unknown): segmentLike is IMoveInfo =>\n\ttoMoveInfo(segmentLike) !== undefined;\n\n/**\n * Asserts that the segment has move info. Usage of this function should not produce a user facing error.\n *\n * @param segmentLike - The segment-like object to check.\n * @throws Will throw an error if the segment does not have move info.\n */\nexport const assertMoved: <T extends Partial<IMoveInfo> | undefined>(\n\tsegmentLike: ISegmentInternal | Partial<IMoveInfo> | T,\n) => asserts segmentLike is IMoveInfo | Exclude<T, Partial<IMoveInfo>> = (segmentLike) =>\n\tassert(segmentLike === undefined || isMoved(segmentLike), 0xaa3 /* must be moveInfo */);\n\n/**\n * A union type representing any segment info.\n */\nexport type SegmentInfo = IMergeNodeInfo | IInsertionInfo | IMoveInfo | IRemovalInfo;\n\n/**\n * A type representing a segment with additional info.\n */\nexport type SegmentWithInfo<\n\tT extends SegmentInfo,\n\tS extends ISegmentPrivate = ISegmentPrivate,\n> = S & T;\n\n/**\n * Overwrites the segment info on a segment-like object.\n *\n * @param segmentLike - The segment-like object to set the info on.\n * @param info - The segment info to overwrite.\n * @returns The segment-like object with the info set.\n */\nexport const overwriteInfo = <\n\tT extends SegmentInfo,\n\tS extends ISegmentPrivate = ISegmentPrivate,\n>(\n\tsegmentLike: S,\n\tinfo: T,\n): SegmentWithInfo<T, S> => Object.assign(segmentLike, info);\n"]}

package/dist/snapshotLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"snapshotLoader.d.ts","sourceRoot":"","sources":["../src/snapshotLoader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EACN,sBAAsB,EACtB,sBAAsB,EACtB,MAAM,gDAAgD,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AACxF,OAAO,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAC;AAC/E,OAAO,EACN,mBAAmB,EAGnB,MAAM,0CAA0C,CAAC;AAGlD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAW3C,qBAAa,cAAc;IAIzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAE1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAR5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;gBAG3B,OAAO,EAAE,sBAAsB,EAE/B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACrC,MAAM,EAAE,mBAAmB,EACV,UAAU,EAAE,gBAAgB;IAKjC,UAAU,CACtB,QAAQ,EAAE,sBAAsB,GAC9B,OAAO,CAAC;QAAE,WAAW,EAAE,OAAO,CAAC,yBAAyB,EAAE,CAAC,CAAA;KAAE,CAAC;YAiBnD,qBAAqB;IA2BnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAwD5B;IAEF,OAAO,CAAC,UAAU;YAsCJ,QAAQ;IA0FtB,OAAO,CAAC,kBAAkB;IAsB1B;;;;;OAKG;YACW,cAAc;CAQ5B"}
+{"version":3,"file":"snapshotLoader.d.ts","sourceRoot":"","sources":["../src/snapshotLoader.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EACN,sBAAsB,EACtB,sBAAsB,EACtB,MAAM,gDAAgD,CAAC;AACxD,OAAO,EAAE,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AACxF,OAAO,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAC;AAC/E,OAAO,EACN,mBAAmB,EAGnB,MAAM,0CAA0C,CAAC;AAElD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAoB3C,qBAAa,cAAc;IAIzB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAExB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAE1B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAR5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;gBAG3B,OAAO,EAAE,sBAAsB,EAE/B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,EACrC,MAAM,EAAE,mBAAmB,EACV,UAAU,EAAE,gBAAgB;IAKjC,UAAU,CACtB,QAAQ,EAAE,sBAAsB,GAC9B,OAAO,CAAC;QAAE,WAAW,EAAE,OAAO,CAAC,yBAAyB,EAAE,CAAC,CAAA;KAAE,CAAC;YAiBnD,qBAAqB;IA2BnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAqD5B;IAEF,OAAO,CAAC,UAAU;YAsCJ,QAAQ;IAwFtB,OAAO,CAAC,kBAAkB;IAsB1B;;;;;OAKG;YACW,cAAc;CAQ5B"}

package/dist/snapshotLoader.js

@@ -11,62 +11,57 @@ const container_definitions_1 = require("@fluidframework/container-definitions")
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/telemetry-utils/internal");
 const constants_js_1 = require("./constants.js");
+const segmentInfos_js_1 = require("./segmentInfos.js");
 const snapshotChunks_js_1 = require("./snapshotChunks.js");
 const snapshotV1_js_1 = require("./snapshotV1.js");
 const snapshotlegacy_js_1 = require("./snapshotlegacy.js");
 class SnapshotLoader {
-    constructor(runtime, 
-    // eslint-disable-next-line import/no-deprecated
-    client, mergeTree, logger, serializer) {
+    constructor(runtime, client, mergeTree, logger, serializer) {
         this.runtime = runtime;
         this.client = client;
         this.mergeTree = mergeTree;
         this.serializer = serializer;
         this.specToSegment = (spec) => {
-            let seg;
             if ((0, snapshotChunks_js_1.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
+                const seg = (0, segmentInfos_js_1.overwriteInfo)(this.client.specToSegment(spec.json), {
+                    clientId: spec.client === undefined
                         ? constants_js_1.NonCollabClient
-                        : this.client.getOrAddShortClientId(spec.client);
-                seg.seq = spec.seq ?? constants_js_1.UniversalSequenceNumber;
+                        : this.client.getOrAddShortClientId(spec.client),
+                    seq: spec.seq ?? constants_js_1.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 = spec;
+                    if (specAsBuggyFormat.removedClient !== undefined) {
+                        spec.removedClientIds ?? (spec.removedClientIds = [specAsBuggyFormat.removedClient]);
+                    }
+                    (0, internal_1.assert)(spec.removedClientIds !== undefined, 0xaa4 /* must have removedClient ids */);
+                    // eslint-disable-next-line import/no-deprecated
+                    (0, segmentInfos_js_1.overwriteInfo)(seg, {
+                        removedSeq: spec.removedSeq,
+                        removedClientIds: spec.removedClientIds.map((id) => this.client.getOrAddShortClientId(id)),
+                    });
                 }
                 if (spec.movedSeq !== undefined) {
-                    seg.movedSeq = spec.movedSeq;
+                    (0, internal_1.assert)(spec.movedClientIds !== undefined && spec.movedSeqs !== undefined, 0xaa5 /* must have movedIds ids */);
+                    // eslint-disable-next-line import/no-deprecated
+                    (0, segmentInfos_js_1.overwriteInfo)(seg, {
+                        movedSeq: spec.movedSeq,
+                        movedSeqs: spec.movedSeqs,
+                        movedClientIds: spec.movedClientIds.map((id) => this.client.getOrAddShortClientId(id)),
+                        // BUG? This isn't persisted
+                        wasMovedOnInsert: false,
+                    });
                 }
-                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 = 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));
-                }
-            }
-            else {
-                seg = this.client.specToSegment(spec);
-                seg.seq = constants_js_1.UniversalSequenceNumber;
-                // `specToSegment()` initializes `seg` with the LocalClientId.  We must overwrite this with
-                // `NonCollabClient`.
-                seg.clientId = constants_js_1.NonCollabClient;
+                return seg;
             }
-            return seg;
+            return (0, segmentInfos_js_1.overwriteInfo)(this.client.specToSegment(spec), {
+                seq: constants_js_1.UniversalSequenceNumber,
+                clientId: constants_js_1.NonCollabClient,
+            });
         };
         this.logger = (0, internal_2.createChildLogger)({ logger, namespace: "SnapshotLoader" });
     }
@@ -162,16 +157,15 @@ 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 === constants_js_1.NonCollabClient && seq === constants_js_1.UniversalSequenceNumber) {
+            if (clientId === constants_js_1.NonCollabClient && seq === constants_js_1.UniversalSequenceNumber) {
                 batch.push(seg);
             }
             else {
                 flushBatch();
-                append([seg], cli, seq);
+                append([seg], clientId, seq);
             }
         }
         flushBatch();