@fluidframework/odsp-driver 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.225277

package/src/compactSnapshotParser.ts

@@ -3,28 +3,34 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/common-utils";
+import { assert } from "@fluidframework/core-utils";
 import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
+import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 import { ISnapshotContents } from "./odspPublicUtils";
 import { ReadBuffer } from "./ReadBufferUtils";
-import { ISnapshotTreeEx } from "./contracts";
 import {
-    assertBlobCoreInstance,
-    assertBoolInstance,
-    assertNodeCoreInstance,
-    assertNumberInstance,
-    getAndValidateNodeProps,
-    NodeCore,
-    NodeTypes,
-    TreeBuilder,
+	assertBlobCoreInstance,
+	getStringInstance,
+	assertBoolInstance,
+	assertNodeCoreInstance,
+	assertNumberInstance,
+	getNodeProps,
+	NodeCore,
+	NodeTypes,
+	TreeBuilder,
 } from "./zipItDataRepresentationUtils";
+import { measure } from "./odspUtils";
 
 export const snapshotMinReadVersion = "1.0";
 export const currentReadVersion = "1.0";
 
-interface ISnapshotSection {
-    snapshotTree: ISnapshotTree;
-    sequenceNumber: number;
+/**
+ * The parsing is significantly faster if the position of props is well known instead of dynamic. So these variables
+ * represents how many times slower parsing path is executed. This will be then logged into telemetry.
+ * @internal
+ */
+export interface ISnapshotContentsWithProps extends ISnapshotContents {
+	telemetryProps: Record<string, number>;
 }
 
 /**
@@ -32,16 +38,38 @@ interface ISnapshotSection {
  * @param node - tree node to read blob section from
  */
 function readBlobSection(node: NodeTypes) {
-    assertNodeCoreInstance(node, "TreeBlobs should be of type NodeCore");
-    const blobs: Map<string, ArrayBuffer> = new Map();
-    for (let count = 0; count < node.length; ++count) {
-        const blob = node.getNode(count);
-        const records = getAndValidateNodeProps(blob, ["id", "data"]);
-        assertBlobCoreInstance(records.data, "data should be of BlobCore type");
-        assertBlobCoreInstance(records.id, "blob id should be of BlobCore type");
-        blobs.set(records.id.toString(), records.data.arrayBuffer);
-    }
-    return blobs;
+	assertNodeCoreInstance(node, "TreeBlobs should be of type NodeCore");
+	let slowBlobStructureCount = 0;
+	const blobs: Map<string, ArrayBuffer> = new Map();
+	for (const blob of node) {
+		assertNodeCoreInstance(blob, "blob should be node");
+
+		/**
+		 * Perf optimization - the most common cases!
+		 * This is essentially unrolling code below for faster processing
+		 * It speeds up tree parsing by 2-3x times!
+		 */
+		if (
+			blob.length === 4 &&
+			blob.getMaybeString(0) === "id" &&
+			blob.getMaybeString(2) === "data"
+		) {
+			// "id": <node name>
+			// "data": <blob>
+			blobs.set(blob.getString(1), blob.getBlob(3).arrayBuffer);
+			continue;
+		}
+
+		/**
+		 * More generalized workflow
+		 */
+		slowBlobStructureCount += 1;
+		const records = getNodeProps(blob);
+		assertBlobCoreInstance(records.data, "data should be of BlobCore type");
+		const id = getStringInstance(records.id, "blob id should be string");
+		blobs.set(id, records.data.arrayBuffer);
+	}
+	return { blobs, slowBlobStructureCount };
 }
 
 /**
@@ -49,17 +77,22 @@ function readBlobSection(node: NodeTypes) {
  * @param node - tree node to read ops section from
  */
 function readOpsSection(node: NodeTypes) {
-    assertNodeCoreInstance(node, "Deltas should be of type NodeCore");
-    const ops: ISequencedDocumentMessage[] = [];
-    const records = getAndValidateNodeProps(node, ["firstSequenceNumber", "deltas"]);
-    assertNumberInstance(records.firstSequenceNumber, "Seq number should be a number");
-    assertNodeCoreInstance(records.deltas, "Deltas should be a Node");
-    for (let i = 0; i < records.deltas.length; ++i) {
-        ops.push(JSON.parse(records.deltas.getString(i)));
-    }
-    assert(records.firstSequenceNumber.valueOf() === ops[0].sequenceNumber,
-        0x280 /* "Validate first op seq number" */);
-    return ops;
+	assertNodeCoreInstance(node, "Deltas should be of type NodeCore");
+	const ops: ISequencedDocumentMessage[] = [];
+	const records = getNodeProps(node);
+	assertNumberInstance(records.firstSequenceNumber, "Seq number should be a number");
+	assertNodeCoreInstance(records.deltas, "Deltas should be a Node");
+	for (let i = 0; i < records.deltas.length; ++i) {
+		ops.push(JSON.parse(records.deltas.getString(i)));
+	}
+	// Due to a bug at service side, in an edge case service was serializing deltas even
+	// when there are no ops. So just make the code resilient to that bug. Service has also
+	// fixed that bug.
+	assert(
+		ops.length === 0 || records.firstSequenceNumber.valueOf() === ops[0].sequenceNumber,
+		0x280 /* "Validate first op seq number" */,
+	);
+	return ops;
 }
 
 /**
@@ -67,85 +100,168 @@ function readOpsSection(node: NodeTypes) {
  * @param node - tree node to de-serialize from
  */
 function readTreeSection(node: NodeCore) {
-    const snapshotTree: ISnapshotTreeEx = {
-        blobs: {},
-        commits: {},
-        trees: {},
-    };
-    for (let count = 0; count < node.length; count++) {
-        const treeNode = node.getNode(count);
-        const records = getAndValidateNodeProps(treeNode,
-            ["name", "value", "children", "unreferenced"], false);
-        assertBlobCoreInstance(records.name, "Path should be of BlobCore");
-        const path = records.name.toString();
-        if (records.value !== undefined) {
-            assertBlobCoreInstance(records.value, "Blob value should be BlobCore");
-            snapshotTree.blobs[path] = records.value.toString();
-        } else {
-            assertNodeCoreInstance(records.children, "Trees should be of type NodeCore");
-            snapshotTree.trees[path] = readTreeSection(records.children);
-        }
-        if (records.unreferenced !== undefined) {
-            assertBoolInstance(records.unreferenced, "Unreferenced flag should be bool");
-            const unreferenced = records.unreferenced.valueOf();
-            assert(unreferenced, 0x281 /* "Unreferenced if present should be true" */);
-            snapshotTree.unreferenced = unreferenced;
-        }
-    }
-    return snapshotTree;
+	let slowTreeStructureCount = 0;
+	const trees = {};
+	const snapshotTree: ISnapshotTree = {
+		blobs: {},
+		trees,
+	};
+	for (const treeNode of node) {
+		assertNodeCoreInstance(treeNode, "tree nodes should be nodes");
+
+		/**
+		 * Perf optimization - the most common cases!
+		 * This is essentially unrolling code below for faster processing
+		 * It speeds up tree parsing by 2-3x times!
+		 */
+		const length = treeNode.length;
+		if (length > 0 && treeNode.getMaybeString(0) === "name") {
+			if (length === 4) {
+				const content = treeNode.getMaybeString(2);
+				// "name": <node name>
+				// "children": <blob id>
+				if (content === "children") {
+					const result = readTreeSection(treeNode.getNode(3));
+					trees[treeNode.getString(1)] = result.snapshotTree;
+					slowTreeStructureCount += result.slowTreeStructureCount;
+					continue;
+				}
+				// "name": <node name>
+				// "value": <blob id>
+				if (content === "value") {
+					snapshotTree.blobs[treeNode.getString(1)] = treeNode.getString(3);
+					continue;
+				}
+			}
+
+			// "name": <node name>
+			// "nodeType": 3
+			// "value": <blob id>
+			if (
+				length === 6 &&
+				treeNode.getMaybeString(2) === "nodeType" &&
+				treeNode.getMaybeString(4) === "value"
+			) {
+				snapshotTree.blobs[treeNode.getString(1)] = treeNode.getString(5);
+				continue;
+			}
+
+			// "name": <node name>
+			// "unreferenced": true
+			// "children": <blob id>
+			if (
+				length === 6 &&
+				treeNode.getMaybeString(2) === "unreferenced" &&
+				treeNode.getMaybeString(4) === "children"
+			) {
+				const result = readTreeSection(treeNode.getNode(5));
+				trees[treeNode.getString(1)] = result.snapshotTree;
+				slowTreeStructureCount += result.slowTreeStructureCount;
+				assert(treeNode.getBool(3), 0x3db /* Unreferenced if present should be true */);
+				snapshotTree.unreferenced = true;
+				continue;
+			}
+		}
+
+		/**
+		 * More generalized workflow
+		 */
+		slowTreeStructureCount += 1;
+		const records = getNodeProps(treeNode);
+
+		if (records.unreferenced !== undefined) {
+			assertBoolInstance(records.unreferenced, "Unreferenced flag should be bool");
+			assert(records.unreferenced, 0x281 /* "Unreferenced if present should be true" */);
+			snapshotTree.unreferenced = true;
+		}
+
+		const path = getStringInstance(records.name, "Path name should be string");
+		if (records.value !== undefined) {
+			snapshotTree.blobs[path] = getStringInstance(
+				records.value,
+				"Blob value should be string",
+			);
+		} else if (records.children !== undefined) {
+			assertNodeCoreInstance(records.children, "Trees should be of type NodeCore");
+			const result = readTreeSection(records.children);
+			trees[path] = result.snapshotTree;
+			slowTreeStructureCount += result.slowTreeStructureCount;
+		} else {
+			trees[path] = { blobs: {}, trees: {} };
+		}
+	}
+	return { snapshotTree, slowTreeStructureCount };
 }
 
 /**
  * Recreates snapshot tree out of tree representation.
  * @param node - tree node to de-serialize from
  */
-function readSnapshotSection(node: NodeTypes): ISnapshotSection {
-    assertNodeCoreInstance(node, "Snapshot should be of type NodeCore");
-    const records = getAndValidateNodeProps(node,
-        ["id", "sequenceNumber", "treeNodes"]);
-
-    assertNodeCoreInstance(records.treeNodes, "TreeNodes should be of type NodeCore");
-    assertNumberInstance(records.sequenceNumber, "sequenceNumber should be of type number");
-    assertBlobCoreInstance(records.id, "snapshotId should be BlobCore");
-    const snapshotTree: ISnapshotTree = readTreeSection(records.treeNodes);
-    snapshotTree.id = records.id.toString();
-    const sequenceNumber = records.sequenceNumber.valueOf();
-    return {
-        sequenceNumber,
-        snapshotTree,
-    };
+function readSnapshotSection(node: NodeTypes) {
+	assertNodeCoreInstance(node, "Snapshot should be of type NodeCore");
+	const records = getNodeProps(node);
+
+	assertNodeCoreInstance(records.treeNodes, "TreeNodes should be of type NodeCore");
+	assertNumberInstance(records.sequenceNumber, "sequenceNumber should be of type number");
+	const { snapshotTree, slowTreeStructureCount } = readTreeSection(records.treeNodes);
+	snapshotTree.id = getStringInstance(records.id, "snapshotId should be string");
+	const sequenceNumber = records.sequenceNumber.valueOf();
+	return {
+		sequenceNumber,
+		snapshotTree,
+		slowTreeStructureCount,
+	};
 }
 
 /**
  * Converts snapshot from binary compact representation to tree/blobs/ops.
  * @param buffer - Compact snapshot to be parsed into tree/blobs/ops.
- * @returns - tree, blobs and ops from the snapshot.
+ * @returns Tree, blobs and ops from the snapshot.
+ * @internal
  */
-export function parseCompactSnapshotResponse(buffer: ReadBuffer): ISnapshotContents {
-    const builder = TreeBuilder.load(buffer);
-    assert(builder.length === 1, 0x219 /* "1 root should be there" */);
-    const root = builder.getNode(0);
-
-    const records = getAndValidateNodeProps(root,
-        ["mrv", "cv", "lsn", "snapshot", "blobs", "deltas"], false);
-
-    assertBlobCoreInstance(records.mrv, "minReadVersion should be of BlobCore type");
-    assertBlobCoreInstance(records.cv, "createVersion should be of BlobCore type");
-    if (records.lsn !== undefined) {
-        assertNumberInstance(records.lsn, "lsn should be a number");
-    }
-
-    assert(parseFloat(snapshotMinReadVersion) >= parseFloat(records.mrv.toString()),
-        0x20f /* "Driver min read version should >= to server minReadVersion" */);
-    assert(parseFloat(records.cv.toString()) >= parseFloat(snapshotMinReadVersion),
-        0x210 /* "Snapshot should be created with minReadVersion or above" */);
-    assert(currentReadVersion === records.cv.toString(),
-        0x2c2 /* "Create Version should be equal to currentReadVersion" */);
-
-    return {
-        ...readSnapshotSection(records.snapshot),
-        blobs: readBlobSection(records.blobs),
-        ops: records.deltas !== undefined ? readOpsSection(records.deltas) : [],
-        latestSequenceNumber: records.lsn,
-    };
+export function parseCompactSnapshotResponse(
+	buffer: Uint8Array,
+	logger: ITelemetryLoggerExt,
+): ISnapshotContentsWithProps {
+	const { builder, telemetryProps } = TreeBuilder.load(new ReadBuffer(buffer), logger);
+	assert(builder.length === 1, 0x219 /* "1 root should be there" */);
+	const root = builder.getNode(0);
+
+	const records = getNodeProps(root);
+
+	const mrv = getStringInstance(records.mrv, "minReadVersion should be string");
+	const cv = getStringInstance(records.cv, "createVersion should be string");
+	if (records.lsn !== undefined) {
+		assertNumberInstance(records.lsn, "lsn should be a number");
+	}
+
+	assert(
+		parseFloat(snapshotMinReadVersion) >= parseFloat(mrv),
+		0x20f /* "Driver min read version should >= to server minReadVersion" */,
+	);
+	assert(
+		parseFloat(cv) >= parseFloat(snapshotMinReadVersion),
+		0x210 /* "Snapshot should be created with minReadVersion or above" */,
+	);
+	assert(
+		currentReadVersion === cv,
+		0x2c2 /* "Create Version should be equal to currentReadVersion" */,
+	);
+
+	const [snapshot, durationSnapshotTree] = measure(() => readSnapshotSection(records.snapshot));
+	const [blobs, durationBlobs] = measure(() => readBlobSection(records.blobs));
+
+	return {
+		...snapshot,
+		...blobs,
+		ops: records.deltas !== undefined ? readOpsSection(records.deltas) : [],
+		latestSequenceNumber: records.lsn,
+		telemetryProps: {
+			...telemetryProps,
+			durationSnapshotTree,
+			durationBlobs,
+			slowTreeStructureCount: snapshot.slowTreeStructureCount,
+			slowBlobStructureCount: blobs.slowBlobStructureCount,
+		},
+	};
 }

package/src/compactSnapshotWriter.ts

@@ -3,75 +3,93 @@
  * Licensed under the MIT License.
  */
 
-import { assert, stringToBuffer } from "@fluidframework/common-utils";
-import { IBlob, ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
+import { stringToBuffer } from "@fluid-internal/client-utils";
+import { assert } from "@fluidframework/core-utils";
+import {
+	IBlob,
+	ISequencedDocumentMessage,
+	ISnapshotTree,
+} from "@fluidframework/protocol-definitions";
 import { snapshotMinReadVersion } from "./compactSnapshotParser";
 import { ISnapshotContents } from "./odspPublicUtils";
-import { ReadBuffer } from "./ReadBufferUtils";
 import { TreeBuilderSerializer } from "./WriteBufferUtils";
-import { addBoolProperty, addNumberProperty, addStringProperty, NodeCore } from "./zipItDataRepresentationUtils";
+import {
+	addBoolProperty,
+	addNumberProperty,
+	addStringProperty,
+	addDictionaryStringProperty,
+	NodeCore,
+} from "./zipItDataRepresentationUtils";
 
 /**
  * Writes header section of the snapshot.
  * @param node - snapshot node to serialize to
  * @param latestSequenceNumber - latest seq number of the container.
-*/
+ */
 function writeSnapshotProps(node: NodeCore, latestSequenceNumber: number) {
-    addStringProperty(node, "mrv", snapshotMinReadVersion);
-    addStringProperty(node, "cv", snapshotMinReadVersion);
-    addNumberProperty(node, "lsn", latestSequenceNumber);
+	addStringProperty(node, "mrv", snapshotMinReadVersion);
+	addStringProperty(node, "cv", snapshotMinReadVersion);
+	addNumberProperty(node, "lsn", latestSequenceNumber);
 }
 
 /**
  * Represents blobs in the tree.
  * @param snapshotNode - node to serialize to.
  * @param blobs - blobs that is being serialized
-*/
+ */
 function writeBlobsSection(snapshotNode: NodeCore, blobs: Map<string, IBlob | ArrayBuffer>) {
-    snapshotNode.addString("blobs", true);
-    const blobsNode = snapshotNode.addNode("list");
-    for (const [storageBlobId, blob] of blobs) {
-        const blobNode = blobsNode.addNode();
-        addStringProperty(blobNode, "id", storageBlobId, true);
-        blobNode.addString("data", true);
-        if (blob instanceof ArrayBuffer) {
-            blobNode.addBlob(new Uint8Array(blob), false);
-        } else {
-            blobNode.addBlob(new Uint8Array(stringToBuffer(blob.contents, blob.encoding ?? "utf-8")), false);
-        }
-    }
+	snapshotNode.addDictionaryString("blobs");
+	const blobsNode = snapshotNode.addNode("list");
+	for (const [storageBlobId, blob] of blobs) {
+		const blobNode = blobsNode.addNode();
+		addDictionaryStringProperty(blobNode, "id", storageBlobId);
+		blobNode.addString("data");
+		if (blob instanceof ArrayBuffer) {
+			blobNode.addBlob(new Uint8Array(blob));
+		} else {
+			blobNode.addBlob(
+				new Uint8Array(stringToBuffer(blob.contents, blob.encoding ?? "utf-8")),
+			);
+		}
+	}
 }
 
 /**
  * Represents and serializes tree part of the snapshot
  * @param snapshotNode - tree node to serialize to
  * @param snapshotTree - snapshot tree that is being serialized
-*/
+ */
 function writeTreeSection(snapshotNode: NodeCore, snapshotTree: ISnapshotTree) {
-    snapshotNode.addString("treeNodes", true);
-    const treesNode = snapshotNode.addNode("list");
-    writeTreeSectionCore(treesNode, snapshotTree);
+	snapshotNode.addDictionaryString("treeNodes");
+	const treesNode = snapshotNode.addNode("list");
+	writeTreeSectionCore(treesNode, snapshotTree);
 }
 
 function writeTreeSectionCore(treesNode: NodeCore, snapshotTree: ISnapshotTree) {
-    for (const [path, value] of Object.entries(snapshotTree.trees)) {
-        const treeNode = treesNode.addNode();
-        addStringProperty(treeNode, "name", path);
-        if (snapshotTree.unreferenced) {
-            addBoolProperty(treeNode, "unreferenced", snapshotTree.unreferenced);
-        }
-        treeNode.addString("children", true);
-        const childNode = treeNode.addNode("list");
-        writeTreeSectionCore(childNode, value);
-    }
-
-    if (snapshotTree.blobs) {
-        for (const [path, id] of Object.entries(snapshotTree.blobs)) {
-            const blobNode = treesNode.addNode();
-            addStringProperty(blobNode, "name", path);
-            addStringProperty(blobNode, "value", id, true);
-        }
-    }
+	for (const [path, value] of Object.entries(snapshotTree.trees)) {
+		const treeNode = treesNode.addNode();
+		// Many leaf nodes in the tree have same names like "content", "body", "header"
+		// We could be smarter here and not use dictionary where we are sure reuse is unlikely, but
+		// it does not feel like it's worth it.
+		addDictionaryStringProperty(treeNode, "name", path);
+		if (snapshotTree.unreferenced) {
+			addBoolProperty(treeNode, "unreferenced", snapshotTree.unreferenced);
+		}
+		// Only write children prop if either blobs or trees are present.
+		if (Object.keys(value.blobs).length > 0 || Object.keys(value.trees).length > 0) {
+			treeNode.addDictionaryString("children");
+			const childNode = treeNode.addNode("list");
+			writeTreeSectionCore(childNode, value);
+		}
+	}
+
+	if (snapshotTree.blobs) {
+		for (const [path, id] of Object.entries(snapshotTree.blobs)) {
+			const blobNode = treesNode.addNode();
+			addDictionaryStringProperty(blobNode, "name", path);
+			addDictionaryStringProperty(blobNode, "value", id);
+		}
+	}
 }
 
 /**
@@ -80,75 +98,78 @@ function writeTreeSectionCore(treesNode: NodeCore, snapshotTree: ISnapshotTree)
  * @param snapshotTree - snapshot tree that is being serialized
  * @param blobs - blobs mapping of the snapshot
  * @param snapshotSequenceNumber - seq number at which snapshot is taken
-*/
+ */
 function writeSnapshotSection(
-    rootNode: NodeCore,
-    snapshotTree: ISnapshotTree,
-    snapshotSequenceNumber: number,
+	rootNode: NodeCore,
+	snapshotTree: ISnapshotTree,
+	snapshotSequenceNumber: number,
 ) {
-    rootNode.addString("snapshot", true);
-    const snapshotNode = rootNode.addNode();
+	rootNode.addDictionaryString("snapshot");
+	const snapshotNode = rootNode.addNode();
 
-    const snapshotId = snapshotTree.id;
-    assert(snapshotId !== undefined, 0x21b /* "Snapshot id should be provided" */);
-    addStringProperty(snapshotNode, "id", snapshotId);
-    addStringProperty(snapshotNode, "message", `Snapshot@${snapshotSequenceNumber}`);
-    addNumberProperty(snapshotNode, "sequenceNumber", snapshotSequenceNumber);
+	const snapshotId = snapshotTree.id;
+	assert(snapshotId !== undefined, 0x21b /* "Snapshot id should be provided" */);
+	addStringProperty(snapshotNode, "id", snapshotId);
+	addStringProperty(snapshotNode, "message", `Snapshot@${snapshotSequenceNumber}`);
+	addNumberProperty(snapshotNode, "sequenceNumber", snapshotSequenceNumber);
 
-    // Add Trees
-    writeTreeSection(snapshotNode, snapshotTree);
+	// Add Trees
+	writeTreeSection(snapshotNode, snapshotTree);
 }
 
 /**
  * Represents ops in the tree.
  * @param rootNode - node to serialize to.
  * @param ops - ops that is being serialized
-*/
+ */
 function writeOpsSection(rootNode: NodeCore, ops: ISequencedDocumentMessage[]) {
-    let firstSequenceNumber: number | undefined;
-    if (ops.length > 0) {
-        firstSequenceNumber = ops[0].sequenceNumber;
-    }
-    if (firstSequenceNumber !== undefined) {
-        rootNode.addString("deltas", true);
-        const opsNode = rootNode.addNode();
-        addNumberProperty(opsNode, "firstSequenceNumber", firstSequenceNumber);
-        opsNode.addString("deltas", true);
-        const deltaNode = opsNode.addNode("list");
-        ops.forEach((op) => {
-            deltaNode.addString(JSON.stringify(op), false);
-        });
-    }
+	let firstSequenceNumber: number | undefined;
+	if (ops.length > 0) {
+		firstSequenceNumber = ops[0].sequenceNumber;
+	}
+	if (firstSequenceNumber !== undefined) {
+		rootNode.addDictionaryString("deltas");
+		const opsNode = rootNode.addNode();
+		addNumberProperty(opsNode, "firstSequenceNumber", firstSequenceNumber);
+		opsNode.addDictionaryString("deltas");
+		const deltaNode = opsNode.addNode("list");
+		ops.forEach((op) => {
+			deltaNode.addString(JSON.stringify(op));
+		});
+	}
 }
 
 /**
  * Converts trees/blobs/ops to binary compact representation.
  * @param snapshotContents - snapshot tree contents to serialize
- * @returns - ReadBuffer - binary representation of the data.
+ * @returns ReadBuffer - binary representation of the data.
  */
-export function convertToCompactSnapshot(snapshotContents: ISnapshotContents): ReadBuffer {
-    const builder = new TreeBuilderSerializer();
-    // Create the root node.
-    const rootNode = builder.addNode();
-    assert(snapshotContents.sequenceNumber !== undefined, 0x21c /* "Seq number should be provided" */);
-
-    const latestSequenceNumber = snapshotContents.latestSequenceNumber ??
-        snapshotContents.ops.length > 0 ?
-        snapshotContents.ops[snapshotContents.ops.length - 1].sequenceNumber : snapshotContents.sequenceNumber;
-
-    writeSnapshotProps(rootNode, latestSequenceNumber);
-
-    writeSnapshotSection(
-        rootNode,
-        snapshotContents.snapshotTree,
-        snapshotContents.sequenceNumber,
-    );
-
-    // Add Blobs
-    writeBlobsSection(rootNode, snapshotContents.blobs);
-
-    // Then write the ops node.
-    writeOpsSection(rootNode, snapshotContents.ops);
-
-    return builder.serialize();
+export function convertToCompactSnapshot(snapshotContents: ISnapshotContents): Uint8Array {
+	const builder = new TreeBuilderSerializer();
+	// Create the root node.
+	const rootNode = builder.addNode();
+	assert(
+		snapshotContents.sequenceNumber !== undefined,
+		0x21c /* "Seq number should be provided" */,
+	);
+
+	let latestSequenceNumber = snapshotContents.latestSequenceNumber;
+	if (latestSequenceNumber === undefined) {
+		latestSequenceNumber =
+			snapshotContents.ops.length > 0
+				? snapshotContents.ops[snapshotContents.ops.length - 1].sequenceNumber
+				: snapshotContents.sequenceNumber;
+	}
+
+	writeSnapshotProps(rootNode, latestSequenceNumber);
+
+	writeSnapshotSection(rootNode, snapshotContents.snapshotTree, snapshotContents.sequenceNumber);
+
+	// Add Blobs
+	writeBlobsSection(rootNode, snapshotContents.blobs);
+
+	// Then write the ops node.
+	writeOpsSection(rootNode, snapshotContents.ops);
+
+	return builder.serialize();
 }

package/src/constants.ts

@@ -3,5 +3,12 @@
  * Licensed under the MIT License.
  */
 
+/**
+ * @alpha
+ */
 export const OdcApiSiteOrigin = "https://my.microsoftpersonalcontent.com";
+
+/**
+ * @alpha
+ */
 export const OdcFileSiteOrigin = "https://1drv.ms";