@fluid-experimental/tree 0.58.2002 → 0.59.1000

package/lib/test/utilities/SharedTreeTests.js

@@ -3,34 +3,50 @@
  * Licensed under the MIT License.
  */
 import { assert, expect } from 'chai';
-import { v4 as uuidv4 } from 'uuid';
-import { delay } from '@fluidframework/common-utils';
-import { MockFluidDataStoreRuntime } from '@fluidframework/test-runtime-utils';
-import { assertArrayOfOne, assertNotUndefined, isSharedTreeEvent } from '../../Common';
-import { SharedTreeOpType, SharedTreeEvent, serialize, newEdit, EditStatus, } from '../../generic';
-import { Change, ChangeType, Delete, Insert, StablePlace, StableRange } from '../../default-edits';
-import { Snapshot } from '../../Snapshot';
+import { IsoBuffer } from '@fluidframework/common-utils';
+import { LoaderHeader } from '@fluidframework/container-definitions';
+import { MockFluidDataStoreRuntime, } from '@fluidframework/test-runtime-utils';
+import { assertArrayOfOne, assertNotUndefined, fail, isSharedTreeEvent } from '../../Common';
+import { EditLog } from '../../EditLog';
 import { initialTree } from '../../InitialTree';
 import { TreeNodeHandle } from '../../TreeNodeHandle';
 import { deserialize } from '../../SummaryBackCompatibility';
-import { makeEmptyNode, testTrait, left, right, leftTraitLabel, leftTraitLocation, rightTraitLocation, simpleTestTree, areNodesEquivalent, rightTraitLabel, assertNoDelta, deepCompareNodes, initialSnapshot, } from './TestUtilities';
-import { runSharedTreeUndoRedoTestSuite } from './UndoRedoTests';
+import { useFailedSequencedEditTelemetry } from '../../MergeHealth';
+import { MutableStringInterner } from '../../StringInterner';
+import { getChangeNodeFromView } from '../../SerializationUtilities';
+import { ChangeInternal, ChangeTypeInternal, editsPerChunk, EditStatus, WriteFormat, } from '../../persisted-types';
+import { SharedTreeDiagnosticEvent, SharedTreeEvent } from '../../EventTypes';
+import { Change, ChangeType, StablePlace, StableRange } from '../../ChangeTypes';
+import { convertTreeNodes, deepCompareNodes } from '../../EditUtilities';
+import { serialize } from '../../Summary';
+import { InterningTreeCompressor } from '../../TreeCompressor';
+import { SharedTreeEncoder_0_0_2, SharedTreeEncoder_0_1_1 } from '../../SharedTreeEncoder';
+import { sequencedIdNormalizer } from '../../NodeIdUtilities';
+import { convertNodeDataIds } from '../../IdConversion';
+import { buildLeaf, SimpleTestTree } from './TestNode';
 import { TestFluidHandle, TestFluidSerializer } from './TestSerializer';
-const revert = (tree, editId) => {
-    const editIndex = tree.edits.getIndexOfId(editId);
-    return tree.editor.revert(tree.edits.getEditInSessionAtIndex(editIndex), tree.logViewer.getSnapshotInSession(editIndex));
-};
+import { runSharedTreeUndoRedoTestSuite } from './UndoRedoTests';
+import { areNodesEquivalent, assertNoDelta, setUpTestTree, testTrait, testTraitLabel, translateId, spyOnSubmittedOps, normalizeIds, normalizeId, normalizeEdit, setUpLocalServerTestSharedTree, applyNoop, getIdNormalizerFromSharedTree, waitForSummary, } from './TestUtilities';
+function revertEditInTree(tree, edit) {
+    return tree.revert(edit);
+}
 // Options for the undo/redo test suite. The undo and redo functions are the same.
 const undoRedoOptions = {
     title: 'Revert',
-    undo: revert,
-    redo: revert,
+    undo: revertEditInTree,
+    redo: revertEditInTree,
 };
 /**
- * Runs a test suite for operations on `SharedTree`.
+ * Runs a test suite for operations on `SharedTree` writing ops at `writeFormat`.
  * This suite can be used to test other implementations that aim to fulfill `SharedTree`'s contract.
  */
-export function runSharedTreeOperationsTests(title, setUpTestSharedTree) {
+export function runSharedTreeOperationsTests(title, writeFormat, setUpTestSharedTreeWithDefaultVersion) {
+    const setUpTestSharedTree = (options) => setUpTestSharedTreeWithDefaultVersion(Object.assign({ writeFormat }, options));
+    function createSimpleTestTree(options) {
+        const { tree: sharedTree, componentRuntime, containerRuntimeFactory } = setUpTestSharedTree(options);
+        const testTree = setUpTestTree(sharedTree);
+        return { sharedTree, testTree, componentRuntime, containerRuntimeFactory };
+    }
     describe(title, () => {
         const testSerializer = new TestFluidSerializer();
         describe('SharedTree before initialization', () => {
@@ -40,664 +56,905 @@ export function runSharedTreeOperationsTests(title, setUpTestSharedTree) {
             });
             it('valid without initial tree', () => {
                 const { tree } = setUpTestSharedTree();
-                expect(tree.currentView.getTrait(testTrait)).deep.equals([], 'Root should exist, and child traits should be valid but empty.');
+                expect(tree.currentView.getTrait(testTrait(tree.currentView))).deep.equals([], 'Root should exist, and child traits should be valid but empty.');
             });
         });
         describe('SharedTree in local state', () => {
             it('does not emit change events for each change in a batch of changes', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
+                const { sharedTree, testTree } = createSimpleTestTree();
                 let changeCount = 0;
-                tree.on(SharedTreeEvent.EditCommitted, () => {
-                    const leftTrait = tree.currentView.getTrait(leftTraitLocation);
-                    const rightTrait = tree.currentView.getTrait(rightTraitLocation);
+                sharedTree.on(SharedTreeEvent.EditCommitted, () => {
+                    const leftTrait = sharedTree.currentView.getTrait(testTree.left.traitLocation);
+                    const rightTrait = sharedTree.currentView.getTrait(testTree.right.traitLocation);
                     expect(leftTrait.length).to.equal(0); // "left" child is deleted...
                     expect(rightTrait.length).to.equal(2); // ...and added to "right" trait
                     changeCount += 1;
                 });
-                tree.editor.move(left, StablePlace.after(right));
+                sharedTree.applyEdit(...Change.move(StableRange.only(testTree.left), StablePlace.after(testTree.right)));
                 expect(changeCount).equals(1);
             });
             it('can insert a wrapped tree', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const childNode = makeEmptyNode();
+                const { sharedTree, testTree } = createSimpleTestTree();
+                const childNode = testTree.buildLeaf(testTree.generateNodeId());
                 const childId = 0;
                 const childrenTraitLabel = 'children';
                 const parentNode = {
-                    identifier: uuidv4(),
+                    identifier: testTree.generateNodeId(),
                     definition: 'node',
                     traits: {
-                        [childrenTraitLabel]: [childId],
+                        [childrenTraitLabel]: childId,
                     },
                 };
                 const parentId = 1;
-                const buildChild = Change.build([childNode], childId);
-                const buildParent = Change.build([parentNode], parentId);
-                const insertParent = Change.insert(parentId, StablePlace.before(left));
-                tree.applyEdit(buildChild, buildParent, insertParent);
-                const leftTrait = tree.currentView.getTrait(leftTraitLocation);
+                const buildChild = Change.build(childNode, childId);
+                const buildParent = Change.build(parentNode, parentId);
+                const insertParent = Change.insert(parentId, StablePlace.before(testTree.left));
+                sharedTree.applyEdit(buildChild, buildParent, insertParent);
+                const leftTrait = sharedTree.currentView.getTrait(testTree.left.traitLocation);
                 expect(leftTrait.length).to.equal(2);
                 expect(leftTrait[0]).to.equal(parentNode.identifier);
-                const childrenTrait = tree.currentView.getTrait({
+                const childrenTrait = sharedTree.currentView.getTrait({
                     parent: parentNode.identifier,
                     label: childrenTraitLabel,
                 });
                 expect(childrenTrait.length).to.equal(1);
                 expect(childrenTrait[0]).to.equal(childNode.identifier);
             });
-            it('prevents multiparenting detached trees', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree, allowMalformed: true });
-                const childNode = makeEmptyNode();
+            it('prevents multi-parenting detached trees', () => {
+                const { sharedTree, testTree } = createSimpleTestTree({ allowMalformed: true });
+                const childNode = testTree.buildLeaf();
                 const childId = 0;
                 const childrenTraitLabel = 'children';
                 const parentNode = {
-                    identifier: uuidv4(),
+                    identifier: testTree.generateNodeId(),
                     definition: 'node',
                     traits: {
-                        [childrenTraitLabel]: [childId],
+                        [childrenTraitLabel]: childId,
                     },
                 };
-                const parentId = 1;
                 const parentNode2 = {
-                    identifier: uuidv4(),
+                    identifier: testTree.generateNodeId(),
                     definition: 'node',
                     traits: {
-                        [childrenTraitLabel]: [childId],
+                        [childrenTraitLabel]: childId,
                     },
                 };
-                const parentId2 = 2;
-                const buildChild = Change.build([childNode], childId);
-                const buildParent = Change.build([parentNode], parentId);
-                const buildParent2 = Change.build([parentNode2], parentId2);
-                assertNoDelta(tree, () => {
+                const buildChild = Change.build(childNode, childId);
+                const buildParent = Change.build(parentNode, 1);
+                const buildParent2 = Change.build(parentNode2, 2);
+                assertNoDelta(sharedTree, () => {
                     // we don't expect this edit application to change anything
-                    tree.applyEdit(buildChild, buildParent, buildParent2);
+                    sharedTree.applyEdit(buildChild, buildParent, buildParent2);
                 });
             });
             // TODO:#58052: Make this test pass.
             it.skip('prevents setting the value of a node in a detached subtree', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree, allowInvalid: true });
-                const detachedNode = makeEmptyNode();
+                const { sharedTree, testTree } = createSimpleTestTree({ allowInvalid: true });
+                const detachedNode = testTree.buildLeaf(testTree.generateNodeId());
                 const detachedSequenceId = 0;
-                const editId = tree.applyEdit(Change.build([detachedNode], detachedSequenceId), Change.setPayload(detachedNode.identifier, 42), Change.insert(detachedSequenceId, StablePlace.before(left)));
-                const logViewer = tree.logViewer;
-                expect(logViewer.getEditResultInSession(logViewer.log.getIndexOfId(editId)).status).equals(EditStatus.Invalid);
-                tree.currentView.assertConsistent();
+                const { id } = sharedTree.applyEdit(Change.build(detachedNode, detachedSequenceId), Change.setPayload(detachedNode.identifier, 42), Change.insert(detachedSequenceId, StablePlace.before(testTree.left)));
+                const logViewer = sharedTree.logViewer;
+                expect(logViewer.getEditResultInSession(logViewer.log.getIndexOfId(id)).status).equals(EditStatus.Invalid);
+                sharedTree.currentView.assertConsistent();
             });
             // TODO:#58052: Make this test pass.
             it.skip('prevents inserting a node in a detached subtree through a local edit', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree, allowInvalid: true });
-                const detachedNewNode = makeEmptyNode();
+                const { sharedTree, testTree } = createSimpleTestTree({ allowInvalid: true });
+                const detachedNewNode = testTree.buildLeaf();
                 const detachedNewNodeSequenceId = 0;
                 const detachedRightNodeSequenceId = 1;
-                const editId = tree.applyEdit(Change.build([detachedNewNode], detachedNewNodeSequenceId), Change.detach(StableRange.only(right), detachedRightNodeSequenceId), 
+                const { id } = sharedTree.applyEdit(Change.build(detachedNewNode, detachedNewNodeSequenceId), Change.detach(StableRange.only(testTree.right), detachedRightNodeSequenceId), 
                 // This change attempts to insert a node under a detached node
-                Change.insert(detachedNewNodeSequenceId, StablePlace.atStartOf({ parent: right.identifier, label: 'foo' })), Change.insert(detachedRightNodeSequenceId, StablePlace.before(left)));
-                const logViewer = tree.logViewer;
-                expect(logViewer.getEditResultInSession(logViewer.log.getIndexOfId(editId)).status).equals(EditStatus.Invalid);
-                tree.currentView.assertConsistent();
+                Change.insert(detachedNewNodeSequenceId, StablePlace.atStartOf({ parent: testTree.right.identifier, label: 'foo' })), Change.insert(detachedRightNodeSequenceId, StablePlace.before(testTree.left)));
+                const logViewer = sharedTree.logViewer;
+                expect(logViewer.getEditResultInSession(logViewer.log.getIndexOfId(id)).status).equals(EditStatus.Invalid);
+                sharedTree.currentView.assertConsistent();
             });
             it('prevents deletion of the root', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree, allowInvalid: true });
-                expect(tree.currentView.hasNode(initialSnapshot.root));
-                assertNoDelta(tree, () => {
+                const { sharedTree } = createSimpleTestTree({ allowInvalid: true });
+                const rootId = sharedTree.convertToNodeId(initialTree.identifier);
+                expect(sharedTree.currentView.hasNode(rootId));
+                assertNoDelta(sharedTree, () => {
                     // Try to delete the root
-                    tree.processLocalEdit(newEdit([Delete.create(StableRange.only(initialSnapshot.root))]));
+                    sharedTree.applyEdit(Change.delete(StableRange.only(rootId)));
                 });
             });
             it('can apply multiple local edits without ack from server', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const newNode = makeEmptyNode();
-                tree.editor.insert(newNode, StablePlace.after(left));
-                tree.editor.move(newNode, StablePlace.before(left));
-                const leftTrait = tree.currentView.getTrait(leftTraitLocation);
+                const { sharedTree, testTree } = createSimpleTestTree();
+                const newNode = testTree.buildLeaf(testTree.generateNodeId());
+                sharedTree.applyEdit(...Change.insertTree(newNode, StablePlace.after(testTree.left)));
+                sharedTree.applyEdit(...Change.move(StableRange.only(newNode), StablePlace.before(testTree.left)));
+                const leftTrait = sharedTree.currentView.getTrait(testTree.left.traitLocation);
                 expect(leftTrait.length).equals(2);
                 expect(leftTrait[0]).equals(newNode.identifier);
             });
-            it('is not equal to a tree with different initial views', () => {
-                const secondSimpleTestTree = Object.assign(Object.assign({}, simpleTestTree), { identifier: uuidv4() });
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const { tree: secondTree } = setUpTestSharedTree({ initialTree: secondSimpleTestTree });
-                expect(tree.equals(secondTree)).to.be.false;
+            it('is not equal to a tree with different current views', () => {
+                const { sharedTree: sharedTree1 } = createSimpleTestTree();
+                const { tree: sharedTree2 } = setUpTestSharedTree();
+                expect(sharedTree1.equals(sharedTree2)).to.be.false;
             });
-            it('is not equal to a tree with the same view but different edit lists', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const { tree: secondTree } = setUpTestSharedTree({ initialTree: simpleTestTree });
+            it('is not equal to a tree with the same current view but different edit logs', () => {
+                const { sharedTree: sharedTree1 } = createSimpleTestTree();
+                const { sharedTree: sharedTree2 } = createSimpleTestTree();
                 // The edits that create the initial tree have different identities.
-                expect(tree.equals(secondTree)).to.be.false;
+                expect(sharedTree1.equals(sharedTree2)).to.be.false;
             });
             it('tolerates invalid inserts', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree, allowInvalid: true });
-                const firstNode = makeEmptyNode();
-                const secondNode = makeEmptyNode();
-                tree.editor.insert(firstNode, StablePlace.after(left));
-                tree.editor.delete(firstNode);
+                const { sharedTree, testTree } = createSimpleTestTree({ allowInvalid: true });
+                const firstNode = testTree.buildLeaf(testTree.generateNodeId());
+                const secondNode = testTree.buildLeaf(testTree.generateNodeId());
+                sharedTree.applyEdit(...Change.insertTree(firstNode, StablePlace.after(testTree.left)));
+                sharedTree.applyEdit(Change.delete(StableRange.only(firstNode)));
                 // Trying to insert next to the deleted node should drop, confirm that it doesn't
-                // change the snapshot
-                assertNoDelta(tree, () => {
-                    tree.processLocalEdit(newEdit(Insert.create([secondNode], StablePlace.after(firstNode))));
+                // change the view
+                assertNoDelta(sharedTree, () => {
+                    sharedTree.applyEdit(...Change.insertTree(secondNode, StablePlace.after(firstNode)));
                 });
-                const leftTrait = tree.currentView.getTrait(leftTraitLocation);
+                const leftTrait = sharedTree.currentView.getTrait(testTree.left.traitLocation);
                 expect(leftTrait.length).to.equal(1);
             });
             it('tolerates invalid detaches', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree, allowInvalid: true });
-                const firstNode = makeEmptyNode();
-                const secondNode = makeEmptyNode();
-                const thirdNode = makeEmptyNode();
-                tree.editor.insert([firstNode, secondNode, thirdNode], StablePlace.after(left));
-                tree.editor.delete(secondNode);
-                assertNoDelta(tree, () => {
+                const { sharedTree, testTree } = createSimpleTestTree({ allowInvalid: true });
+                const firstNode = testTree.buildLeaf(testTree.generateNodeId());
+                const secondNode = testTree.buildLeaf(testTree.generateNodeId());
+                const thirdNode = testTree.buildLeaf(testTree.generateNodeId());
+                sharedTree.applyEdit(...Change.insertTree([firstNode, secondNode, thirdNode], StablePlace.after(testTree.left)));
+                sharedTree.applyEdit(Change.delete(StableRange.only(secondNode)));
+                assertNoDelta(sharedTree, () => {
                     // Trying to delete from before firstNode to after secondNode should drop
-                    tree.processLocalEdit(newEdit([
-                        Delete.create(StableRange.from(StablePlace.before(firstNode)).to(StablePlace.after(secondNode))),
-                    ]));
+                    sharedTree.applyEdit(Change.delete(StableRange.from(StablePlace.before(firstNode)).to(StablePlace.after(secondNode))));
                     // Trying to delete from after thirdNode to before firstNode should drop
-                    tree.processLocalEdit(newEdit([
-                        Delete.create(StableRange.from(StablePlace.after(thirdNode)).to(StablePlace.before(firstNode))),
-                    ]));
+                    sharedTree.applyEdit(Change.delete(StableRange.from(StablePlace.after(thirdNode)).to(StablePlace.before(firstNode))));
                 });
                 // Expect that firstNode did not get deleted
-                const leftTrait = tree.currentView.getTrait(leftTraitLocation);
+                const leftTrait = sharedTree.currentView.getTrait(testTree.left.traitLocation);
                 expect(leftTrait.length).to.equal(3);
             });
             it('tolerates malformed inserts', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree, allowMalformed: true });
-                assertNoDelta(tree, () => {
-                    tree.processLocalEdit(newEdit([Change.build([], 0)]));
+                const { sharedTree } = createSimpleTestTree({ allowMalformed: true });
+                assertNoDelta(sharedTree, () => {
+                    sharedTree.applyEdit(Change.build([], 0));
                 });
             });
             runSharedTreeUndoRedoTestSuite(Object.assign({ localMode: true }, undoRedoOptions));
         });
         describe('SharedTree in connected state with a remote SharedTree', () => {
-            const treeOptions = { initialTree: simpleTestTree, localMode: false };
-            const secondTreeOptions = {
-                id: 'secondTestSharedTree',
-                localMode: false,
-            };
+            /**
+             * Initial tree options for multi-tree tests below.
+             * Intended to be passed to {@link createSimpleTestTree}.
+             */
+            const tree1Options = { localMode: false };
+            /**
+             * Secondary tree options derived from some initial tree.
+             */
+            function createSecondTreeOptions(containerRuntimeFactory) {
+                return {
+                    containerRuntimeFactory,
+                    id: 'secondTestSharedTree',
+                    localMode: false,
+                };
+            }
             it('should apply remote changes and converge', () => {
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree(treeOptions);
-                const { tree: secondTree } = setUpTestSharedTree(Object.assign({ containerRuntimeFactory }, secondTreeOptions));
+                const { tree: sharedTree1, containerRuntimeFactory } = setUpTestSharedTree(tree1Options);
+                const { tree: sharedTree2 } = setUpTestSharedTree(createSecondTreeOptions(containerRuntimeFactory));
+                const newNodeId1 = sharedTree1.generateNodeId();
+                sharedTree1.applyEdit(...Change.insertTree([buildLeaf(newNodeId1)], StablePlace.atStartOf(testTrait(sharedTree1.currentView))));
                 // Sync initial tree
                 containerRuntimeFactory.processAllMessages();
+                const newNodeId2 = translateId(newNodeId1, sharedTree1, sharedTree2);
                 // Both trees should contain 'left'
-                expect(tree.currentView.getSnapshotNode(left.identifier)).to.not.be.undefined;
-                expect(secondTree.currentView.getSnapshotNode(left.identifier)).to.not.be.undefined;
-                secondTree.editor.delete(left);
-                containerRuntimeFactory.processAllMessages();
-                const rootA = tree.currentView.getSnapshotNode(simpleTestTree.identifier);
-                expect(rootA.traits.get(leftTraitLabel)).to.be.undefined;
-                const rootB = secondTree.currentView.getSnapshotNode(simpleTestTree.identifier);
-                expect(rootB.traits.get(leftTraitLabel)).to.be.undefined;
-            });
-            it('should apply local edits after all sequenced edits', () => {
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree(treeOptions);
-                const { tree: secondTree } = setUpTestSharedTree(Object.assign({ containerRuntimeFactory }, secondTreeOptions));
-                // Sync initial tree
-                containerRuntimeFactory.processAllMessages();
-                const newNode = makeEmptyNode();
-                tree.editor.insert(newNode, StablePlace.after(left));
-                containerRuntimeFactory.processAllMessages();
-                // Concurrently perform edit that will be sequenced before the move below.
-                // If local edits are sorted incorrectly (before sequenced edits), this will cause evaluation of a state in which the local
-                // move is evaluated before all other edits. Since it is causally dependant on the initial insert edit, it would fail.
-                secondTree.editor.delete(right);
-                // Attempt to move the new node.
-                tree.editor.move(newNode, StablePlace.before(left));
-                // Deliver the remote edit. The move should be applied after all sequenced edits and succeed.
+                expect(sharedTree1.currentView.getViewNode(newNodeId1)).to.not.be.undefined;
+                expect(sharedTree2.currentView.getViewNode(newNodeId2)).to.not.be.undefined;
+                sharedTree2.applyEdit(Change.delete(StableRange.only(newNodeId2)));
                 containerRuntimeFactory.processAllMessages();
+                const rootA = sharedTree1.currentView.getViewNode(sharedTree1.currentView.root);
+                expect(rootA.traits.get(testTraitLabel)).to.be.undefined;
+                const rootB = sharedTree2.currentView.getViewNode(sharedTree2.currentView.root);
+                expect(rootB.traits.get(testTraitLabel)).to.be.undefined;
             });
             it('converges in the face of concurrent changes', () => {
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree(treeOptions);
-                const { tree: secondTree } = setUpTestSharedTree(Object.assign({ containerRuntimeFactory }, secondTreeOptions));
-                // Sync initial tree
+                const { tree: sharedTree1, containerRuntimeFactory } = setUpTestSharedTree(tree1Options);
+                const { sharedTree: sharedTree2 } = createSimpleTestTree(createSecondTreeOptions(containerRuntimeFactory));
+                const newNodeId1 = sharedTree1.generateNodeId();
+                sharedTree1.applyEdit(...Change.insertTree([buildLeaf(newNodeId1)], StablePlace.atStartOf(testTrait(sharedTree1.currentView))));
                 containerRuntimeFactory.processAllMessages();
                 // First client deletes a trait containing a node in the initial tree
-                tree.editor.delete(left);
+                sharedTree1.applyEdit(Change.delete(StableRange.all(testTrait(sharedTree1.currentView))));
                 // Second client concurrently adds a new node to that trait
-                const newNode = makeEmptyNode();
-                secondTree.editor.insert(newNode, StablePlace.atEndOf(leftTraitLocation));
+                const newNodeId2 = sharedTree2.generateNodeId();
+                sharedTree2.applyEdit(...Change.insertTree([buildLeaf(newNodeId2)], StablePlace.atStartOf(testTrait(sharedTree2.currentView))));
                 containerRuntimeFactory.processAllMessages();
                 // Second client's change gets sequenced after the deletion, so the trait
-                // should exist and contain the new node on both clients after messages are delivered.
-                const leftTrait = tree.currentView.getTrait(leftTraitLocation);
-                const secondLeftTrait = secondTree.currentView.getTrait(leftTraitLocation);
+                // should exist and contain the second new node on both clients after messages are delivered.
+                const leftTrait = normalizeIds(sharedTree1, ...sharedTree1.currentView.getTrait(testTrait(sharedTree1.currentView)));
+                const secondLeftTrait = normalizeIds(sharedTree2, ...sharedTree2.currentView.getTrait(testTrait(sharedTree2.currentView)));
                 expect(leftTrait.length).equals(1);
-                expect(leftTrait[0]).equals(newNode.identifier);
+                expect(leftTrait[0]).equals(normalizeId(sharedTree2, newNodeId2));
                 expect(leftTrait).deep.equals(secondLeftTrait);
             });
             it('is equal to a tree with the same state', () => {
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree(treeOptions);
-                const { tree: secondTree } = setUpTestSharedTree(Object.assign({ containerRuntimeFactory }, secondTreeOptions));
+                const { tree: sharedTree1, containerRuntimeFactory } = setUpTestSharedTree(tree1Options);
+                const { tree: sharedTree2 } = setUpTestSharedTree(createSecondTreeOptions(containerRuntimeFactory));
+                const newNodeId1 = sharedTree1.generateNodeId();
+                sharedTree1.applyEdit(...Change.insertTree([
+                    {
+                        identifier: newNodeId1,
+                        definition: 'foo',
+                        traits: { left: buildLeaf(), right: buildLeaf() },
+                    },
+                ], StablePlace.atStartOf(testTrait(sharedTree1.currentView))));
                 containerRuntimeFactory.processAllMessages();
-                expect(tree.equals(secondTree)).to.be.true;
-                secondTree.editor.delete(left);
+                expect(sharedTree1.equals(sharedTree2)).to.be.true;
+                sharedTree2.applyEdit(Change.delete(StableRange.only(translateId(newNodeId1, sharedTree1, sharedTree2))));
                 containerRuntimeFactory.processAllMessages();
-                expect(tree.equals(secondTree)).to.be.true;
+                expect(sharedTree1.equals(sharedTree2)).to.be.true;
             });
             // TODO:#58052: Make this test pass.
             it.skip('prevents inserting a node in a detached subtree as the result of merged edits', () => {
-                const rootId = 'root';
-                const parent1Id = 'parent1';
-                const parent2Id = 'parent2';
-                const childId = 'child';
-                const childTraitUnderParent2 = { parent: parent2Id, label: 'child' };
-                const badTraitUnderChild = { parent: childId, label: 'whatever' };
-                const initialTree = Object.assign(Object.assign({}, makeEmptyNode(rootId)), { traits: {
+                const { testTree } = createSimpleTestTree();
+                const rootNode = testTree.buildLeaf(testTree.generateNodeId());
+                const parent1Node = testTree.buildLeaf(testTree.generateNodeId());
+                const parent2Node = testTree.buildLeaf(testTree.generateNodeId());
+                const parent2Id = parent2Node.identifier;
+                const childNode = testTree.buildLeaf(testTree.generateNodeId());
+                const childId = childNode.identifier;
+                const initialTree = Object.assign(Object.assign({}, rootNode), { traits: {
                         parents: [
-                            Object.assign(Object.assign({}, makeEmptyNode(parent1Id)), { traits: { child: [makeEmptyNode(childId)] } }),
-                            makeEmptyNode(parent2Id),
+                            Object.assign(Object.assign({}, parent1Node), { traits: { child: childNode } }),
+                            parent2Node,
                         ],
                     } });
-                const { tree: tree1, containerRuntimeFactory } = setUpTestSharedTree(Object.assign(Object.assign({}, treeOptions), { initialTree, allowInvalid: true }));
-                const { tree: tree2 } = setUpTestSharedTree(Object.assign(Object.assign({ containerRuntimeFactory }, secondTreeOptions), { allowInvalid: true }));
+                const childTraitUnderParent2 = { parent: parent2Id, label: 'child' };
+                const badTraitUnderChild = { parent: childId, label: 'whatever' };
+                const { tree: sharedTree1, containerRuntimeFactory } = setUpTestSharedTree(Object.assign(Object.assign({}, tree1Options), { initialTree, allowInvalid: true }));
+                const { tree: sharedTree2 } = setUpTestSharedTree(Object.assign(Object.assign({}, createSecondTreeOptions(containerRuntimeFactory)), { allowInvalid: true }));
                 containerRuntimeFactory.processAllMessages();
                 // Move the child under parent2
                 // This first edit should succeed locally and globally
-                const edit1Id = tree1.editor.move(childId, StablePlace.atStartOf(childTraitUnderParent2));
+                const edit1 = sharedTree1.applyEdit(...Change.move(StableRange.only(childId), StablePlace.atStartOf(childTraitUnderParent2)));
                 // Concurrently move parent2 under child
                 // This first edit should succeed locally but fail globally
-                const edit2Id = tree2.editor.move(parent2Id, StablePlace.atStartOf(badTraitUnderChild));
+                const edit2 = sharedTree2.applyEdit(...Change.move(StableRange.only(parent2Id), StablePlace.atStartOf(badTraitUnderChild)));
                 containerRuntimeFactory.processAllMessages();
-                const logViewer = tree1.logViewer;
-                expect(logViewer.getEditResultInSession(logViewer.log.getIndexOfId(edit1Id)).status).equals(EditStatus.Applied);
-                expect(logViewer.getEditResultInSession(logViewer.log.getIndexOfId(edit2Id)).status).equals(EditStatus.Invalid);
-                tree1.currentView.assertConsistent();
+                const logViewer = sharedTree1.logViewer;
+                expect(logViewer.getEditResultInSession(logViewer.log.getIndexOfId(edit1.id)).status).equals(EditStatus.Applied);
+                expect(logViewer.getEditResultInSession(logViewer.log.getIndexOfId(edit2.id)).status).equals(EditStatus.Invalid);
+                sharedTree1.currentView.assertConsistent();
             });
             it('tolerates invalid inserts', () => {
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree(Object.assign(Object.assign({}, treeOptions), { allowInvalid: true }));
-                const { tree: secondTree } = setUpTestSharedTree(Object.assign(Object.assign({ containerRuntimeFactory }, secondTreeOptions), { allowInvalid: true }));
+                const { tree: sharedTree1, containerRuntimeFactory } = setUpTestSharedTree(Object.assign(Object.assign({}, tree1Options), { allowInvalid: true }));
+                const { tree: sharedTree2 } = setUpTestSharedTree(Object.assign(Object.assign({}, createSecondTreeOptions(containerRuntimeFactory)), { allowInvalid: true }));
                 containerRuntimeFactory.processAllMessages();
-                const firstNode = makeEmptyNode();
-                const firstEditId = secondTree.editor.insert(firstNode, StablePlace.after(left));
+                const firstNode2 = buildLeaf(sharedTree2.generateNodeId());
+                const firstEdit = sharedTree2.applyEdit(...Change.insertTree(firstNode2, StablePlace.atStartOf(testTrait(sharedTree2.currentView))));
                 containerRuntimeFactory.processAllMessages();
                 // Concurrently edit, creating invalid insert.
                 // Create delete. This will apply.
-                const secondEditId = tree.editor.delete(firstNode);
-                let thirdEditId;
-                assertNoDelta(tree, () => {
+                const secondEdit = sharedTree1.applyEdit(Change.delete(StableRange.only(translateId(firstNode2, sharedTree2, sharedTree1))));
+                let thirdEdit;
+                assertNoDelta(sharedTree1, () => {
                     // concurrently insert next to the deleted node: this will become invalid.
-                    const secondNode = makeEmptyNode();
-                    thirdEditId = secondTree.editor.insert(secondNode, StablePlace.after(firstNode));
+                    const secondNode2 = buildLeaf();
+                    thirdEdit = sharedTree2.applyEdit(...Change.insertTree(secondNode2, StablePlace.after(firstNode2)));
                     containerRuntimeFactory.processAllMessages();
                 });
-                const leftTrait = secondTree.currentView.getTrait(leftTraitLocation);
-                expect(leftTrait.length).to.equal(1);
-                const editIds = tree.edits.editIds;
-                // Edit 0 creates initial tree
-                expect(editIds[1]).is.equal(firstEditId);
-                expect(editIds[2]).is.equal(secondEditId);
-                expect(editIds[3]).is.equal(thirdEditId);
+                const leftTrait = sharedTree2.currentView.getTrait(testTrait(sharedTree2.currentView));
+                expect(leftTrait.length).to.equal(0);
+                const editIds = sharedTree1.edits.editIds;
+                expect(editIds[0]).is.equal(firstEdit.id);
+                expect(editIds[1]).is.equal(secondEdit.id);
+                expect(editIds[2]).is.equal(thirdEdit.id);
             });
             it('tolerates invalid detaches', () => {
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree(Object.assign(Object.assign({}, treeOptions), { allowInvalid: true }));
-                const { tree: secondTree } = setUpTestSharedTree(Object.assign({ containerRuntimeFactory }, secondTreeOptions));
+                const { tree: sharedTree1, containerRuntimeFactory } = setUpTestSharedTree(Object.assign(Object.assign({}, tree1Options), { allowInvalid: true }));
+                const { tree: sharedTree2 } = setUpTestSharedTree(createSecondTreeOptions(containerRuntimeFactory));
                 containerRuntimeFactory.processAllMessages();
-                const firstNode = makeEmptyNode();
-                const secondNode = makeEmptyNode();
-                const thirdNode = makeEmptyNode();
-                const firstEditId = secondTree.editor.insert([firstNode, secondNode, thirdNode], StablePlace.after(left));
+                const firstNode2 = buildLeaf(sharedTree2.generateNodeId());
+                const secondNode2 = buildLeaf(sharedTree2.generateNodeId());
+                const thirdNode = buildLeaf();
+                const firstEdit = sharedTree2.applyEdit(...Change.insertTree([firstNode2, secondNode2, thirdNode], StablePlace.atStartOf(testTrait(sharedTree2.currentView))));
                 containerRuntimeFactory.processAllMessages();
-                // Concurrently edit, creating invalid insert.
                 // Create delete. This will apply.
-                const secondEditId = tree.editor.delete(secondNode);
-                let thirdEditId;
-                assertNoDelta(tree, () => {
-                    // concurrently delete from before firstNode to after secondNode: this should become invalid
-                    thirdEditId = secondTree.editor.delete(StableRange.from(StablePlace.before(firstNode)).to(StablePlace.after(secondNode)));
-                });
+                const secondEdit = sharedTree1.applyEdit(Change.delete(StableRange.only(translateId(secondNode2, sharedTree2, sharedTree1))));
+                // concurrently delete from before firstNode to after secondNode: this should become invalid
+                const thirdEdit = sharedTree2.applyEdit(Change.delete(StableRange.from(StablePlace.before(firstNode2)).to(StablePlace.after(secondNode2))));
                 containerRuntimeFactory.processAllMessages();
                 // Expect that firstNode did not get deleted
-                const leftTrait = tree.currentView.getTrait(leftTraitLocation);
-                expect(leftTrait.length).to.equal(3);
-                const editIds = tree.edits.editIds;
-                // Edit 0 creates initial tree
-                expect(editIds[1]).to.equal(firstEditId);
-                expect(editIds[2]).to.equal(secondEditId);
-                expect(editIds[3]).to.equal(thirdEditId);
+                const leftTrait = sharedTree1.currentView.getTrait(testTrait(sharedTree1.currentView));
+                expect(leftTrait.length).to.equal(2);
+                const editIds = sharedTree1.edits.editIds;
+                expect(editIds[0]).to.equal(firstEdit.id);
+                expect(editIds[1]).to.equal(secondEdit.id);
+                expect(editIds[2]).to.equal(thirdEdit.id);
             });
             it('tolerates malformed inserts', () => {
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree(Object.assign(Object.assign({}, treeOptions), { allowMalformed: true }));
-                const { tree: secondTree } = setUpTestSharedTree(Object.assign({ containerRuntimeFactory }, secondTreeOptions));
+                const { sharedTree: sharedTree1, containerRuntimeFactory } = createSimpleTestTree(Object.assign(Object.assign({}, tree1Options), { allowMalformed: true }));
+                const { tree: sharedTree2 } = setUpTestSharedTree(createSecondTreeOptions(containerRuntimeFactory));
                 containerRuntimeFactory.processAllMessages();
-                let edit;
-                assertNoDelta(tree, () => {
+                let editId;
+                assertNoDelta(sharedTree1, () => {
                     const build = Change.build([], 0);
-                    edit = newEdit([build]);
-                    secondTree.processLocalEdit(edit);
+                    editId = sharedTree2.applyEdit(build).id;
                     containerRuntimeFactory.processAllMessages();
                 });
                 // Edit 0 creates initial tree
-                expect(tree.edits.getIdAtIndex(1)).to.equal(edit.id);
+                expect(sharedTree1.edits.getIdAtIndex(1)).to.equal(editId);
             });
             runSharedTreeUndoRedoTestSuite(Object.assign({ localMode: false }, undoRedoOptions));
             // This is a regression test for documents corrupted by the following github issue:
             // https://github.com/microsoft/FluidFramework/issues/4399
             it('tolerates duplicate edits in trailing operations', () => {
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree(Object.assign({}, treeOptions));
+                const { sharedTree: sharedTree1, containerRuntimeFactory } = createSimpleTestTree(tree1Options);
                 const remoteRuntime = containerRuntimeFactory.createContainerRuntime(new MockFluidDataStoreRuntime());
-                const defaultEdits = tree.edits.length;
-                const edit = newEdit([]);
-                for (let submissions = 0; submissions < 2; submissions++) {
-                    remoteRuntime.submit({ type: SharedTreeOpType.Edit, edit }, /* localOpMetadata */ undefined);
-                }
+                const ops = spyOnSubmittedOps(containerRuntimeFactory);
+                const initialEditCount = sharedTree1.edits.length;
+                sharedTree1.applyEdit(Change.setPayload(sharedTree1.currentView.root, 42));
+                remoteRuntime.submit(ops[0], /* localOpMetadata */ undefined);
                 containerRuntimeFactory.processAllMessages();
-                expect(tree.edits.length).to.equal(defaultEdits + 1);
+                expect(sharedTree1.edits.length).to.equal(initialEditCount + 1);
             });
+            it('detects concurrent duplicate IDs', () => {
+                const { tree: sharedTree1, containerRuntimeFactory } = setUpTestSharedTree(Object.assign(Object.assign({}, tree1Options), { allowInvalid: true }));
+                const { tree: sharedTree2 } = setUpTestSharedTree(Object.assign(Object.assign({}, createSecondTreeOptions(containerRuntimeFactory)), { allowInvalid: true }));
+                containerRuntimeFactory.processAllMessages();
+                const duplicateId = 'duplicate';
+                sharedTree1.applyEdit(...Change.insertTree([buildLeaf(sharedTree1.generateNodeId(duplicateId))], StablePlace.atEndOf(testTrait(sharedTree1.currentView))));
+                sharedTree2.applyEdit(...Change.insertTree([buildLeaf(sharedTree2.generateNodeId(duplicateId))], StablePlace.atEndOf(testTrait(sharedTree2.currentView))));
+                containerRuntimeFactory.processAllMessages();
+                expect(sharedTree1.currentView.size).to.equal(2);
+                const trait1 = sharedTree1.currentView.getTrait(testTrait(sharedTree1.currentView));
+                expect(trait1.length).to.equal(1);
+                expect(sharedTree1.convertToStableNodeId(trait1[0])).to.equal(duplicateId);
+                expect(sharedTree1.equals(sharedTree2));
+            });
+            if (writeFormat !== WriteFormat.v0_0_2) {
+                // This is a regression test for an issue where edits containing Fluid handles weren't properly
+                // serialized by chunk uploading code: rather than use an IFluidSerializer, we previously just
+                // JSON.stringify'd.
+                it('can round-trip edits containing handles through chunking', async () => {
+                    const blobbedPayload = 'blobbed-string-payload';
+                    const { tree, testObjectProvider } = await setUpLocalServerTestSharedTree({
+                        writeFormat,
+                    });
+                    const testTree = setUpTestTree(tree);
+                    const buffer = IsoBuffer.from(blobbedPayload, 'utf8');
+                    const blob = await tree.getRuntime().uploadBlob(buffer);
+                    const nodeWithPayload = testTree.buildLeaf(testTree.generateNodeId());
+                    tree.applyEdit(...Change.insertTree(nodeWithPayload, StablePlace.after(testTree.left)), Change.setPayload(nodeWithPayload.identifier, { blob }));
+                    // Apply enough edits for the upload of an edit chunk
+                    for (let i = 0; i < tree.edits.editsPerChunk; i++) {
+                        applyNoop(tree);
+                    }
+                    // `ensureSynchronized` does not guarantee blob upload
+                    await new Promise((resolve) => setImmediate(resolve));
+                    // Wait for the ops to to be submitted and processed across the containers
+                    await testObjectProvider.ensureSynchronized();
+                    const summary = tree.saveSummary();
+                    const { editHistory } = summary;
+                    const { editChunks } = assertNotUndefined(editHistory);
+                    expect(editChunks.length).to.equal(2);
+                    const chunkHandle = editChunks[0].chunk;
+                    expect(typeof chunkHandle.get).to.equal('function');
+                    const { tree: secondTree } = await setUpLocalServerTestSharedTree({
+                        writeFormat,
+                        testObjectProvider,
+                    });
+                    secondTree.loadSummary(summary);
+                    expect(tree.equals(secondTree)).to.be.true;
+                    const { blob: blobHandle } = new TreeNodeHandle(secondTree.currentView, translateId(nodeWithPayload.identifier, tree, secondTree)).payload;
+                    expect(blobHandle).to.not.be.undefined;
+                    const blobContents = await blobHandle.get();
+                    expect(IsoBuffer.from(blobContents, 'utf8').toString()).to.equal(blobbedPayload);
+                });
+            }
         });
         describe('SharedTree summarizing', () => {
-            const treeOptions = { initialTree: simpleTestTree, localMode: false };
-            const newNode = makeEmptyNode();
             const testHandle = new TestFluidHandle();
-            it('returns false when given bad json input', () => {
-                assert.typeOf(deserialize('', testSerializer), 'string');
-                assert.typeOf(deserialize('~ malformed JSON ~', testSerializer), 'string');
-                assert.typeOf(deserialize('{ unrecognizedKey: 42 }', testSerializer), 'string');
+            it('throws error when given bad json input', () => {
+                assert.throws(() => deserialize('', testSerializer));
+                assert.throws(() => deserialize('~ malformed JSON ~', testSerializer));
+                assert.throws(() => deserialize('{ unrecognizedKey: 42 }', testSerializer));
             });
             it('correctly handles snapshots of default trees', () => {
                 const { tree: uninitializedTree } = setUpTestSharedTree();
                 // Serialize the state of one uninitialized tree into a second tree
                 const serialized = serialize(uninitializedTree.saveSummary(), testSerializer, testHandle);
                 const parsedTree = deserialize(serialized, testSerializer);
-                expect(parsedTree.sequencedEdits).deep.equal([]);
-                expect(deepCompareNodes(parsedTree.currentTree, initialTree)).to.be.true;
+                if (writeFormat === WriteFormat.v0_0_2) {
+                    const summary = parsedTree;
+                    expect(summary.sequencedEdits).to.deep.equal([]);
+                    expect(deepCompareNodes(summary.currentTree, initialTree)).to.be.true;
+                }
+                else {
+                    const summary = parsedTree;
+                    expect(summary.editHistory).to.deep.equal({ editChunks: [], editIds: [] });
+                    expect(summary.currentTree).to.be.instanceOf(Array);
+                    expect(summary.internedStrings).to.have.length(1);
+                }
             });
             [true, false].forEach((hasLocalEdits) => {
-                it(`produces correct snapshot for a tree with ${hasLocalEdits ? 'local' : 'acked'} edits`, () => {
+                it(`produces correct snapshot for a tree with ${hasLocalEdits ? 'local' : 'acked'} edits`, async () => {
+                    var _a;
                     // The initial tree results in an edit.
-                    const { tree, containerRuntimeFactory } = setUpTestSharedTree({
-                        initialTree: treeOptions.initialTree,
+                    const { sharedTree, testTree, containerRuntimeFactory } = createSimpleTestTree({
                         localMode: hasLocalEdits,
                     });
-                    tree.editor.insert(newNode, StablePlace.before(left));
+                    const newNode = testTree.buildLeaf();
+                    sharedTree.applyEdit(...Change.insertTree(newNode, StablePlace.before(testTree.left)));
                     if (!hasLocalEdits) {
                         containerRuntimeFactory.processAllMessages();
                     }
-                    const serialized = serialize(tree.saveSummary(), testSerializer, testHandle);
+                    const serialized = serialize(sharedTree.saveSummary(), testSerializer, testHandle);
                     const treeContent = JSON.parse(serialized);
-                    const parsedTree = treeContent;
+                    let parsedTree;
+                    if (writeFormat === WriteFormat.v0_1_1) {
+                        parsedTree = new SharedTreeEncoder_0_1_1(true).decodeSummary(treeContent);
+                    }
+                    else {
+                        parsedTree = new SharedTreeEncoder_0_0_2(true).decodeSummary(treeContent);
+                    }
                     expect(parsedTree.currentTree).to.not.be.undefined;
-                    const testRoot = assertArrayOfOne(parsedTree.currentTree.traits[testTrait.label]);
+                    const testRoot = assertArrayOfOne(assertNotUndefined((_a = parsedTree.currentTree) === null || _a === void 0 ? void 0 : _a.traits[testTree.traitLabel]));
                     expect(testRoot).to.not.be.undefined;
                     expect(testRoot.traits.left).to.not.be.undefined;
                     expect(testRoot.traits.right).to.not.be.undefined;
                     expect(testRoot.traits.left.length).to.equal(2);
-                    expect(parsedTree.sequencedEdits).to.not.be.undefined;
-                    const sequencedEdits = assertNotUndefined(parsedTree.sequencedEdits);
+                    const editLog = new EditLog(parsedTree.editHistory);
                     // Expect there to be a change in the edit history in addition to the one from setUpTestSharedTree
-                    expect(sequencedEdits.length).to.equal(2);
+                    expect(editLog.length).to.equal(2);
                     // The first operation to be sequenced is the tree init
-                    expect(sequencedEdits[1].changes.length).to.equal(2);
-                    expect(sequencedEdits[1].changes[0].type).to.equal(ChangeType.Build);
-                    expect(sequencedEdits[1].changes[1].type).to.equal(ChangeType.Insert);
+                    const treeInitEdit = await editLog.getEditAtIndex(1);
+                    expect(treeInitEdit.changes.length).to.equal(2);
+                    expect(treeInitEdit.changes[0].type).to.equal(ChangeType.Build);
+                    expect(treeInitEdit.changes[1].type).to.equal(ChangeType.Insert);
                 });
             });
             it('can be used to initialize a tree', () => {
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree(treeOptions);
-                const { tree: secondTree } = setUpTestSharedTree();
-                tree.editor.insert(newNode, StablePlace.before(left));
+                const { sharedTree: sharedTree1, testTree: testTree1, containerRuntimeFactory, } = createSimpleTestTree({ localMode: false });
+                const { tree: sharedTree2 } = setUpTestSharedTree();
+                const newNode = testTree1.buildLeaf();
+                sharedTree1.applyEdit(...Change.insertTree(newNode, StablePlace.before(testTree1.left)));
                 containerRuntimeFactory.processAllMessages();
-                secondTree.loadSummary(tree.saveSummary());
+                sharedTree2.loadSummary(sharedTree1.saveSummary());
                 // Trees should have equal state since we deserialized the first tree's state into the second tree
-                expect(tree.equals(secondTree)).to.be.true;
+                expect(sharedTree1.equals(sharedTree2)).to.be.true;
             });
             it('can be used to initialize a tree with an empty edit list', () => {
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree(treeOptions);
-                const { tree: secondTree } = setUpTestSharedTree();
+                const { sharedTree: sharedTree1, containerRuntimeFactory } = createSimpleTestTree({ localMode: false });
+                const { tree: sharedTree2 } = setUpTestSharedTree();
                 containerRuntimeFactory.processAllMessages();
                 // The second tree is not caught up to the first tree yet
-                expect(tree.equals(secondTree)).to.be.false;
-                secondTree.loadSummary(tree.saveSummary());
+                expect(sharedTree1.equals(sharedTree2)).to.be.false;
+                sharedTree2.loadSummary(sharedTree1.saveSummary());
                 // Trees should have equal state since we deserialized the first tree's state into the second tree
-                expect(tree.equals(secondTree)).to.be.true;
+                expect(sharedTree1.equals(sharedTree2)).to.be.true;
             });
             it('asserts when loading a summary with duplicated edits', () => {
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree(Object.assign(Object.assign({}, treeOptions), { summarizeHistory: true }));
-                const { tree: secondTree } = setUpTestSharedTree();
-                tree.editor.insert(newNode, StablePlace.before(left));
+                const { sharedTree: sharedTree1, testTree: testTree1, containerRuntimeFactory, } = createSimpleTestTree({
+                    localMode: false,
+                    summarizeHistory: true,
+                    writeFormat: WriteFormat.v0_0_2,
+                });
+                const { tree: sharedTree2 } = setUpTestSharedTree();
+                const newNode = testTree1.buildLeaf();
+                sharedTree1.applyEdit(...Change.insertTree(newNode, StablePlace.before(testTree1.left)));
                 containerRuntimeFactory.processAllMessages();
-                const summary = tree.saveSummary();
+                const summary = sharedTree1.saveSummary();
                 const sequencedEdits = assertNotUndefined(summary.sequencedEdits).slice();
                 sequencedEdits.push(sequencedEdits[0]);
                 const corruptedSummary = Object.assign(Object.assign({}, summary), { sequencedEdits });
-                expect(() => secondTree.loadSummary(corruptedSummary))
+                expect(() => sharedTree2.loadSummary(corruptedSummary))
                     .to.throw(Error)
                     .that.has.property('message')
                     .which.matches(/Duplicate/);
             });
             it('can be used without history preservation', async () => {
-                const { tree } = setUpTestSharedTree({
-                    initialTree: simpleTestTree,
+                const { sharedTree, testTree } = createSimpleTestTree({
                     localMode: true,
                     summarizeHistory: false,
                 });
-                const editID = tree.editor.insert(newNode, StablePlace.before(left));
-                const view = tree.currentView;
-                const summary = tree.saveSummary();
-                tree.loadSummary(summary);
+                const newNode = testTree.buildLeaf();
+                const { id } = sharedTree.applyEdit(...Change.insertTree(newNode, StablePlace.before(testTree.left)));
+                const treeBefore = convertTreeNodes(getChangeNodeFromView(sharedTree.currentView), (node) => convertNodeDataIds(node, (id) => sharedTree.convertToStableNodeId(id)));
+                const summary = sharedTree.saveSummary();
+                const { tree: sharedTree2 } = setUpTestSharedTree();
+                sharedTree2.loadSummary(summary);
+                const treeAfter = convertTreeNodes(getChangeNodeFromView(sharedTree2.currentView), (node) => convertNodeDataIds(node, (id) => sharedTree2.convertToStableNodeId(id)));
                 // The current state of the tree should be identical to the one contained in the old summary.
-                expect(tree.currentView.equals(view)).to.be.true;
+                expect(deepCompareNodes(treeBefore, treeAfter)).to.be.true;
                 // The history should have been dropped by the default handling behavior.
                 // It will contain a single entry setting the tree to equal the head revision.
-                expect(tree.edits.length).to.equal(1);
-                expect(await tree.edits.tryGetEdit(editID)).to.be.undefined;
+                expect(sharedTree2.edits.length).to.equal(1);
+                expect(await sharedTree2.edits.tryGetEdit(id)).to.be.undefined;
+            });
+            it('correctly handles payloads at the root', () => {
+                var _a;
+                const payload = 'foo';
+                const { tree, containerRuntimeFactory } = setUpTestSharedTree({ summarizeHistory: false });
+                tree.applyEdit(Change.setPayload(tree.currentView.root, payload));
+                containerRuntimeFactory.processAllMessages();
+                const summary = tree.saveSummary();
+                const { tree: tree2 } = setUpTestSharedTree({ summarizeHistory: false });
+                tree2.loadSummary(summary);
+                expect((_a = tree2.currentView.tryGetViewNode(tree2.currentView.root)) === null || _a === void 0 ? void 0 : _a.payload).to.equal(payload);
             });
             // TODO:#49901: Enable these tests once we write edit chunk handles to summaries
             it.skip('does not swallow errors in asynchronous blob uploading', async () => {
                 const errorMessage = 'Simulated exception in uploadBlob';
-                const { tree, componentRuntime, containerRuntimeFactory } = setUpTestSharedTree(treeOptions);
+                const { sharedTree, testTree, componentRuntime, containerRuntimeFactory } = createSimpleTestTree({
+                    localMode: false,
+                });
                 componentRuntime.uploadBlob = async () => {
                     throw new Error(errorMessage);
                 };
                 let treeErrorEventWasInvoked = false;
-                tree.on('error', (error) => {
+                sharedTree.on('error', (error) => {
                     treeErrorEventWasInvoked = true;
                     expect(error).to.have.property('message').which.equals(errorMessage);
                 });
                 // Generate enough edits to cause a chunk upload.
-                for (let i = 0; i < tree.edits.editsPerChunk / 2 + 1; i++) {
-                    const insertee = makeEmptyNode();
-                    tree.editor.insert(insertee, StablePlace.before(left));
-                    tree.editor.delete(StableRange.only(insertee));
+                for (let i = 0; i < sharedTree.edits.editsPerChunk / 2 + 1; i++) {
+                    const insertee = testTree.buildLeaf(testTree.generateNodeId());
+                    sharedTree.applyEdit(...Change.insertTree(insertee, StablePlace.before(testTree.left)));
+                    sharedTree.applyEdit(Change.delete(StableRange.only(insertee)));
                 }
                 containerRuntimeFactory.processAllMessages();
-                tree.saveSummary();
+                sharedTree.saveSummary();
                 // Just waiting for the ChunksEmitted event here isn't sufficient, as the SharedTree error
                 // will propagate in a separate promise chain.
-                await delay(0);
+                await new Promise((resolve) => setTimeout(resolve, 0));
                 expect(treeErrorEventWasInvoked).to.equal(true, 'SharedTree error was never raised');
             });
         });
-        describe('correctly diffs snapshots', () => {
-            it('that are the same object', () => {
-                const id = uuidv4();
-                const snapshot = Snapshot.fromTree(makeEmptyNode(id));
-                expect(snapshot.delta(snapshot)).deep.equals({
-                    changed: [],
-                    added: [],
-                    removed: [],
-                });
-            });
-            it('that have the same tree', () => {
-                const node = makeEmptyNode();
-                const snapshotA = Snapshot.fromTree(node);
-                const snapshotB = Snapshot.fromTree(node);
-                expect(snapshotA.delta(snapshotB)).deep.equals({
-                    changed: [],
-                    added: [],
-                    removed: [],
-                });
-            });
-            it('with different root ids', () => {
-                const snapshotA = Snapshot.fromTree(makeEmptyNode());
-                const snapshotB = Snapshot.fromTree(makeEmptyNode());
-                expect(() => snapshotA.delta(snapshotB)).to.throw('Delta can only be calculated between snapshots that share a root');
-            });
-            it('with different subtrees', () => {
-                const rootId = uuidv4();
-                const subtreeA = uuidv4();
-                const subtreeB = uuidv4();
-                const leafA = makeEmptyNode();
-                const leafB = makeEmptyNode();
-                const rootA = {
-                    identifier: rootId,
-                    definition: 'node',
-                    traits: {
-                        children: [
-                            {
-                                identifier: subtreeA,
-                                definition: 'node',
-                                traits: { children: [leafA] },
-                            },
-                        ],
-                    },
-                };
-                const rootB = {
-                    identifier: rootId,
-                    definition: 'node',
-                    traits: {
-                        children: [
-                            {
-                                identifier: subtreeB,
-                                definition: 'node',
-                                traits: { children: [leafB] },
-                            },
-                        ],
-                    },
-                };
-                const snapshotA = Snapshot.fromTree(rootA);
-                const snapshotB = Snapshot.fromTree(rootB);
-                const delta = snapshotA.delta(snapshotB);
-                expect(delta.changed).deep.equals([rootId]);
-                expect(delta.removed.length).equals(2);
-                expect(delta.added.length).equals(2);
-                expect(delta.removed).contains(subtreeA);
-                expect(delta.removed).contains(leafA.identifier);
-                expect(delta.added).contains(subtreeB);
-                expect(delta.added).contains(leafB.identifier);
-            });
-            it('with different payloads', () => {
-                const rootId = uuidv4();
-                const nodeA = {
-                    identifier: rootId,
-                    definition: 'node',
-                    payload: 'test1',
-                    traits: {},
-                };
-                const nodeB = {
-                    identifier: rootId,
-                    definition: 'node',
-                    payload: 'test2',
-                    traits: {},
-                };
-                const snapshotA = Snapshot.fromTree(nodeA);
-                const snapshotB = Snapshot.fromTree(nodeB);
-                const delta = snapshotA.delta(snapshotB);
-                expect(delta.changed).deep.equals([rootId]);
-                expect(delta.removed).deep.equals([]);
-                expect(delta.added).deep.equals([]);
-            });
-            it('after an insert', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const snapshotA = tree.currentView;
-                const insertedNode = makeEmptyNode();
-                tree.editor.insert(insertedNode, StablePlace.before(left));
-                const snapshotB = tree.currentView;
-                const delta = snapshotA.delta(snapshotB);
-                assert(delta);
-                expect(delta.changed).deep.equals([simpleTestTree.identifier]);
-                expect(delta.removed).deep.equals([]);
-                expect(delta.added).deep.equals([insertedNode.identifier]);
-            });
-            it('after a delete', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const snapshotA = tree.currentView;
-                tree.editor.delete(left);
-                const snapshotB = tree.currentView;
-                const delta = snapshotA.delta(snapshotB);
-                assert(delta);
-                expect(delta.changed).deep.equals([simpleTestTree.identifier]);
-                expect(delta.removed).deep.equals([left.identifier]);
-                expect(delta.added).deep.equals([]);
-            });
-            it('after a move', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const snapshotA = tree.currentView;
-                tree.editor.move(left, StablePlace.after(right));
-                const snapshotB = tree.currentView;
-                const delta = snapshotA.delta(snapshotB);
-                assert(delta);
-                expect(delta.changed).deep.equals([simpleTestTree.identifier]);
-                expect(delta.removed).deep.equals([]);
-                expect(delta.added).deep.equals([]);
-            });
-        });
         describe('handles', () => {
             it('can reference a node', () => {
                 // Test that a handle can wrap a node and retrieve that node's properties
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const leftHandle = new TreeNodeHandle(tree.currentView, left.identifier);
-                expect(areNodesEquivalent(left, leftHandle)).to.be.true;
-                expect(areNodesEquivalent(right, leftHandle)).to.be.false;
+                const { sharedTree, testTree } = createSimpleTestTree();
+                const leftHandle = new TreeNodeHandle(sharedTree.currentView, testTree.left.identifier);
+                expect(areNodesEquivalent(testTree.left, leftHandle)).to.be.true;
+                expect(areNodesEquivalent(testTree.right, leftHandle)).to.be.false;
             });
             it('can create handles from children', () => {
                 // Test that when retrieving children via the "traits" property of a handle, the
                 // children are also wrapped in handles
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const rootHandle = new TreeNodeHandle(tree.currentView, simpleTestTree.identifier);
-                expect(areNodesEquivalent(simpleTestTree, rootHandle)).to.be.true;
+                const { sharedTree, testTree } = createSimpleTestTree();
+                const rootHandle = new TreeNodeHandle(sharedTree.currentView, testTree.identifier);
+                expect(areNodesEquivalent(testTree, rootHandle)).to.be.true;
                 const leftHandle = rootHandle.traits.left[0];
-                expect(areNodesEquivalent(left, leftHandle)).to.be.true;
+                expect(areNodesEquivalent(testTree.left, leftHandle)).to.be.true;
                 expect(leftHandle instanceof TreeNodeHandle).to.be.true;
             });
             it('do not update when the current view of the tree changes', () => {
-                // Unlike CurrentTreeNodeHandles, SnapshotTreeNodeHandles should never change
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const leftHandle = new TreeNodeHandle(tree.currentView, left.identifier);
+                const { sharedTree, testTree } = createSimpleTestTree();
+                const leftHandle = new TreeNodeHandle(sharedTree.currentView, testTree.left.identifier);
                 expect(leftHandle.traits.right).to.be.undefined;
                 // Move "right" under "left"
-                tree.editor.move(right, StablePlace.atStartOf({ parent: left.identifier, label: rightTraitLabel }));
+                sharedTree.applyEdit(...Change.move(StableRange.only(testTree.right), StablePlace.atStartOf({ parent: testTree.left.identifier, label: testTree.right.traitLabel })));
                 expect(leftHandle.traits.right).to.be.undefined;
             });
-            it('can be fully demanded', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const rootHandle = new TreeNodeHandle(tree.currentView, simpleTestTree.identifier);
-                const rootNode = rootHandle.demandTree();
-                expect(areNodesEquivalent(simpleTestTree, rootNode)).to.be.true;
-                const printBeforeDemand = JSON.stringify(rootNode);
-                // Demand the tree by walking into its traits. If they were lazy, this would change the `rootNode` object.
-                expect(areNodesEquivalent(left, rootNode.traits.left[0])).to.be.true;
-                expect(areNodesEquivalent(right, rootNode.traits.right[0])).to.be.true;
-                // Ensure that they were _not_ lazy by comparing with the initial print of the tree
-                expect(JSON.stringify(rootNode)).equals(printBeforeDemand);
-            });
-            it('implement toString', () => {
-                const { tree } = setUpTestSharedTree({ initialTree: simpleTestTree });
-                const rootHandle = new TreeNodeHandle(tree.currentView, simpleTestTree.identifier);
-                const print = `${rootHandle}`;
-                // Shouldn't print the default toString for objects
-                expect(print.startsWith('[object')).to.be.false;
-            });
         });
         describe('telemetry', () => {
-            it('decorates events with the correct properties', async () => {
-                // Test that a handle can wrap a node and retrieve that node's properties
-                const events = [];
-                const { tree, containerRuntimeFactory } = setUpTestSharedTree({
-                    initialTree: simpleTestTree,
-                    logger: { send: (event) => events.push(event) },
+            describe('useFailedSequencedEditTelemetry', () => {
+                it('decorates events with the correct properties', async () => {
+                    // Test that a handle can wrap a node and retrieve that node's properties
+                    const events = [];
+                    const { sharedTree, testTree, containerRuntimeFactory } = createSimpleTestTree({
+                        logger: { send: (event) => events.push(event) },
+                        allowInvalid: true,
+                    });
+                    useFailedSequencedEditTelemetry(sharedTree);
+                    // Invalid edit
+                    sharedTree.applyEdit(...Change.insertTree([testTree.buildLeaf()], StablePlace.after(testTree.buildLeaf(testTree.generateNodeId()))));
+                    containerRuntimeFactory.processAllMessages();
+                    // Force demand, which will cause a telemetry event for the invalid edit to be emitted
+                    await sharedTree.logViewer.getRevisionView(Number.POSITIVE_INFINITY);
+                    expect(events.length).is.greaterThan(0);
+                    events.forEach((event) => {
+                        expect(isSharedTreeEvent(event)).is.true;
+                    });
+                });
+                it('is logged for invalid locally generated edits when those edits are sequenced', async () => {
+                    const events = [];
+                    const { sharedTree, testTree, containerRuntimeFactory } = createSimpleTestTree({
+                        logger: { send: (event) => events.push(event) },
+                        allowInvalid: true,
+                    });
+                    useFailedSequencedEditTelemetry(sharedTree);
+                    // Invalid edit
+                    sharedTree.applyEdit(...Change.insertTree([testTree.buildLeaf()], StablePlace.after(testTree.buildLeaf(testTree.generateNodeId()))));
+                    expect(events.length).equals(0);
+                    containerRuntimeFactory.processAllMessages();
+                    // Force demand, which will cause a telemetry event for the invalid edit to be emitted
+                    await sharedTree.logViewer.getRevisionView(Number.POSITIVE_INFINITY);
+                    expect(events.length).equals(1);
+                    expect(events[0].category).equals('generic');
+                    expect(events[0].eventName).equals('SharedTree:SequencedEditApplied:InvalidSharedTreeEdit');
+                });
+                it('can be disabled and re-enabled', async () => {
+                    const events = [];
+                    const { sharedTree, testTree, containerRuntimeFactory } = createSimpleTestTree({
+                        logger: { send: (event) => events.push(event) },
+                        allowInvalid: true,
+                    });
+                    const { disable } = useFailedSequencedEditTelemetry(sharedTree);
+                    sharedTree.applyEdit(...Change.insertTree([testTree.buildLeaf()], StablePlace.after(testTree.buildLeaf(testTree.generateNodeId()))));
+                    expect(events.length).equals(0);
+                    containerRuntimeFactory.processAllMessages();
+                    await sharedTree.logViewer.getRevisionView(Number.POSITIVE_INFINITY);
+                    expect(events.length).equals(1);
+                    expect(events[0].eventName).equals('SharedTree:SequencedEditApplied:InvalidSharedTreeEdit');
+                    disable();
+                    sharedTree.applyEdit(...Change.insertTree([testTree.buildLeaf()], StablePlace.after(testTree.buildLeaf(testTree.generateNodeId()))));
+                    containerRuntimeFactory.processAllMessages();
+                    await sharedTree.logViewer.getRevisionView(Number.POSITIVE_INFINITY);
+                    expect(events.length).equals(1);
+                    useFailedSequencedEditTelemetry(sharedTree);
+                    sharedTree.applyEdit(...Change.insertTree([testTree.buildLeaf()], StablePlace.after(testTree.buildLeaf(testTree.generateNodeId()))));
+                    containerRuntimeFactory.processAllMessages();
+                    await sharedTree.logViewer.getRevisionView(Number.POSITIVE_INFINITY);
+                    expect(events.length).equals(2);
+                    expect(events[1].eventName).equals('SharedTree:SequencedEditApplied:InvalidSharedTreeEdit');
+                });
+                it('is not logged for valid edits', async () => {
+                    const events = [];
+                    const { sharedTree, testTree, containerRuntimeFactory } = createSimpleTestTree({
+                        logger: { send: (event) => events.push(event) },
+                    });
+                    useFailedSequencedEditTelemetry(sharedTree);
+                    sharedTree.applyEdit(...Change.insertTree(testTree.buildLeaf(), StablePlace.after(testTree.left)));
+                    containerRuntimeFactory.processAllMessages();
+                    await sharedTree.logViewer.getRevisionView(Number.POSITIVE_INFINITY);
+                    expect(events.length).equals(0);
+                });
+                it('is not logged for remote edits', async () => {
+                    const events = [];
+                    const { sharedTree: sharedTree1, containerRuntimeFactory } = createSimpleTestTree({
+                        logger: { send: (event) => events.push(event) },
+                        allowInvalid: true,
+                        localMode: false,
+                    });
+                    const { sharedTree: sharedTree2, testTree: testTree2 } = createSimpleTestTree({
+                        containerRuntimeFactory,
+                        id: 'secondTestSharedTree',
+                        localMode: false,
+                    });
+                    useFailedSequencedEditTelemetry(sharedTree1);
+                    sharedTree2.applyEdit(...Change.insertTree([testTree2.buildLeaf()], StablePlace.after(testTree2.buildLeaf(testTree2.generateNodeId()))));
+                    containerRuntimeFactory.processAllMessages();
+                    await sharedTree1.logViewer.getRevisionView(Number.POSITIVE_INFINITY);
+                    expect(events.length).equals(0);
+                });
+            });
+        });
+        describe('Events', () => {
+            it('fires an event when an edit is committed', () => {
+                const { sharedTree, testTree } = createSimpleTestTree();
+                let eventCount = 0;
+                let editIdFromEvent;
+                sharedTree.on(SharedTreeEvent.EditCommitted, (args) => {
+                    expect(args.local).true;
+                    expect(args.tree).equals(sharedTree);
+                    editIdFromEvent = args.editId;
+                    eventCount += 1;
+                });
+                // Invalid change
+                const invalidEdit = sharedTree.applyEdit(...Change.insertTree([testTree.buildLeaf()], StablePlace.after(testTree.buildLeaf(testTree.generateNodeId()))));
+                expect(editIdFromEvent).equals(invalidEdit.id);
+                expect(eventCount).equals(1);
+                // Valid change
+                const { id } = sharedTree.applyEdit(...Change.insertTree(testTree.buildLeaf(), StablePlace.after(testTree.left)));
+                expect(editIdFromEvent).equals(id);
+                expect(eventCount).equals(2);
+            });
+            it('fires an event when a sequenced edit is applied', async () => {
+                const { sharedTree: sharedTree1, testTree, containerRuntimeFactory, } = createSimpleTestTree({
                     allowInvalid: true,
+                    localMode: false,
                 });
-                // Invalid edit
-                tree.editor.insert(makeEmptyNode(), StablePlace.after(makeEmptyNode()));
-                containerRuntimeFactory.processAllMessages();
-                // Force demand, which will cause a telemetry event for the invalid edit to be emitted
-                await tree.logViewer.getSnapshot(Number.POSITIVE_INFINITY);
-                expect(events.length).is.greaterThan(0);
-                events.forEach((event) => {
-                    expect(isSharedTreeEvent(event)).is.true;
+                const { tree: sharedTree2 } = setUpTestSharedTree({
+                    containerRuntimeFactory,
+                    id: 'secondTestSharedTree',
+                    localMode: false,
                 });
+                containerRuntimeFactory.processAllMessages();
+                await sharedTree1.logViewer.getRevisionView(Number.POSITIVE_INFINITY);
+                const eventArgs = [];
+                sharedTree1.on(SharedTreeEvent.SequencedEditApplied, (args) => eventArgs.push(args));
+                // Invalid change
+                const change = Change.setPayload(testTree.generateNodeId(), 42);
+                const invalidEdit = sharedTree1.applyEdit(change);
+                containerRuntimeFactory.processAllMessages();
+                await sharedTree1.logViewer.getRevisionView(Number.POSITIVE_INFINITY);
+                expect(eventArgs.length).equals(1);
+                expect(eventArgs[0].edit.id).equals(invalidEdit.id);
+                expect(eventArgs[0].wasLocal).equals(true);
+                expect(eventArgs[0].reconciliationPath.length).equals(0);
+                expect(eventArgs[0].outcome.status).equals(EditStatus.Invalid);
+                // Valid change
+                const validEdit1 = sharedTree2.applyEdit(...Change.insertTree([testTree.buildLeaf()], StablePlace.after(testTree.left.translateId(sharedTree2))));
+                // Valid change
+                const validEdit2 = sharedTree1.applyEdit(...Change.insertTree(testTree.buildLeaf(), StablePlace.after(testTree.left)));
+                containerRuntimeFactory.processAllMessages();
+                await sharedTree1.logViewer.getRevisionView(Number.POSITIVE_INFINITY);
+                expect(eventArgs.length).equals(3);
+                expect(eventArgs[1].edit.id).equals(validEdit1.id);
+                expect(eventArgs[1].wasLocal).equals(false);
+                expect(eventArgs[1].reconciliationPath.length).equals(0);
+                expect(eventArgs[1].outcome.status).equals(EditStatus.Applied);
+                expect(eventArgs[2].edit.id).equals(validEdit2.id);
+                expect(eventArgs[2].wasLocal).equals(true);
+                expect(eventArgs[2].reconciliationPath.length).equals(1);
+                expect(eventArgs[2].outcome.status).equals(EditStatus.Applied);
             });
         });
+        /**
+         * This test is a slightly minified regression test for an issue discovered by fuzz testing.
+         * It demonstrates issues with clients using writeFormat v0.1.1 and mixed `summarizeHistory` values.
+         * The problem is illustrated by the following scenario:
+         * 1. Client A and client B join a session. A does not summarize history, but B does.
+         * 2. A is elected to be the summarizer.
+         * 3. Client A and B make 50 edits (half a chunks' worth), then idle.
+         * 4. Client A summarizes. Since it does not summarize history, the summary it produces has a single edit.
+         * 5. Client C joins, configured to write history.
+         * 6. The three clients collaborate further for another 50/51 edits.
+         *
+         * At this point in time, client B thinks the first edit chunk is full, but client C thinks it's only half-full.
+         * The entire edit compression scheme is built upon assuming clients agree where the chunk boundaries are, so this
+         * generally leads to correctness issues. The fuzz test reproed a similar scenario, and what ultimately caused
+         * failure is a newly-loaded client being shocked at a chunk with `startRevision: 400` uploaded (when it thinks
+         * there has only been one edit).
+         *
+         * To fix this, we need to incorporate a scheme where all clients agree on chunk boundaries (e.g., by including the
+         * total number of edits even in no-history summaries).
+         *
+         * In the meantime, we are forbidding collaboration of no-history clients and history clients.
+         */
+        it('can be initialized on multiple clients with different `summarizeHistory` values', async () => {
+            const { tree, testObjectProvider, container } = await setUpLocalServerTestSharedTree({
+                writeFormat,
+                summarizeHistory: false,
+            });
+            testObjectProvider.logger.registerExpectedEvent({ eventName: 'fluid:telemetry:Batching:LengthTooBig' }, { eventName: 'fluid:telemetry:Batching:LengthTooBig' }, { eventName: 'fluid:telemetry:Batching:LengthTooBig' });
+            applyNoop(tree);
+            await testObjectProvider.ensureSynchronized();
+            const firstSummaryVersion = await waitForSummary(container);
+            const { tree: tree2 } = await setUpLocalServerTestSharedTree({
+                writeFormat,
+                testObjectProvider,
+                summarizeHistory: true,
+                headers: { [LoaderHeader.version]: firstSummaryVersion },
+            });
+            // Apply enough edits for the upload of a few edit chunks, and some extra so future chunks are misaligned
+            for (let i = 0; i < (5 * editsPerChunk) / 2; i++) {
+                applyNoop(tree);
+            }
+            const secondSummaryVersion = await waitForSummary(container);
+            const { tree: tree3 } = await setUpLocalServerTestSharedTree({
+                writeFormat,
+                testObjectProvider,
+                summarizeHistory: true,
+                headers: { [LoaderHeader.version]: secondSummaryVersion },
+            });
+            // Verify we loaded a no-history summary.
+            expect(tree3.editsInternal.length).to.equal(1);
+            let unexpectedHistoryChunkCount = 0;
+            tree3.on(SharedTreeDiagnosticEvent.UnexpectedHistoryChunk, () => unexpectedHistoryChunkCount++);
+            await testObjectProvider.ensureSynchronized();
+            // Apply enough edits to guarantee another chunk upload occurs.
+            for (let i = 0; i < editsPerChunk; i++) {
+                applyNoop(tree2);
+            }
+            await testObjectProvider.ensureSynchronized();
+            // If tree 2 didn't change its write format, it would attempt to upload the above chunk with start revision 200, which is past
+            // how many sequenced edits tree 3 thinks there are.
+            expect(unexpectedHistoryChunkCount).to.equal(0);
+        }).timeout(/* double summarization can take some time */ 20000);
+        // This functionality was only implemented in format 0.1.1.
+        if (writeFormat !== WriteFormat.v0_0_2) {
+            describe('String interning and tree compression', () => {
+                function getMutableStringInterner(tree) {
+                    const summary = tree.saveSummary();
+                    switch (summary.version) {
+                        case WriteFormat.v0_0_2:
+                            return new MutableStringInterner();
+                        case WriteFormat.v0_1_1:
+                            return new MutableStringInterner(summary.internedStrings);
+                        default:
+                            fail(`Invalid summary format: ${summary.version}`);
+                    }
+                }
+                it('compress ops via interning and tree compression and decompress when processing edits', () => {
+                    const { sharedTree: tree, testTree, containerRuntimeFactory, } = createSimpleTestTree({ writeFormat });
+                    const { tree: secondTree } = setUpTestSharedTree({ containerRuntimeFactory, writeFormat });
+                    const remoteRuntime = containerRuntimeFactory.createContainerRuntime(new MockFluidDataStoreRuntime());
+                    const newNode = testTree.buildLeaf(testTree.generateNodeId());
+                    tree.applyEdit(...Change.insertTree(newNode, StablePlace.after(testTree.left)));
+                    tree.applyEdit(...Change.move(StableRange.only(newNode), StablePlace.before(testTree.left)));
+                    const factory = remoteRuntime.factory;
+                    const messages = factory.messages;
+                    expect(messages.length).to.equal(3);
+                    for (const message of messages.slice(1)) {
+                        // After the initial setup edit, common definitions should be interned
+                        for (const change of message.contents.edit.changes) {
+                            if (change.type === ChangeTypeInternal.CompressedBuild) {
+                                const stringifiedContents = JSON.stringify(message.contents);
+                                expect(stringifiedContents).to.not.include(SimpleTestTree.leftTraitLabel);
+                            }
+                        }
+                    }
+                    expect(tree.equals(secondTree)).to.be.false;
+                    containerRuntimeFactory.processAllMessages();
+                    const { internedStrings } = tree.saveSummary();
+                    const insertEdit = normalizeEdit(tree, tree.editsInternal.getEditInSessionAtIndex(1));
+                    const moveEdit = normalizeEdit(tree, tree.editsInternal.getEditInSessionAtIndex(2));
+                    const insertEdit2 = normalizeEdit(secondTree, secondTree.editsInternal.getEditInSessionAtIndex(1));
+                    const moveEdit2 = normalizeEdit(secondTree, secondTree.editsInternal.getEditInSessionAtIndex(2));
+                    expect(insertEdit).to.deep.equal(insertEdit2);
+                    expect(moveEdit).to.deep.equal(moveEdit2);
+                    expect(tree.equals(secondTree)).to.be.true;
+                    expect(internedStrings).to.include(SimpleTestTree.leftTraitLabel);
+                    expect(internedStrings).to.include(newNode.definition);
+                });
+                it('compress summaries via interning and tree compression on save and decompress on load', () => {
+                    const { sharedTree: tree, testTree: testTree, containerRuntimeFactory, } = createSimpleTestTree({ writeFormat });
+                    const newNode = testTree.buildLeaf(testTree.generateNodeId());
+                    tree.applyEdit(...Change.insertTree(newNode, StablePlace.after(testTree.left)));
+                    tree.applyEdit(...Change.move(StableRange.only(newNode), StablePlace.before(testTree.left)));
+                    containerRuntimeFactory.processAllMessages();
+                    const summary = tree.saveSummary();
+                    expect(summary.internedStrings).to.not.be.undefined;
+                    expect(summary.internedStrings.length).to.equal(5);
+                    const interner = new MutableStringInterner(summary.internedStrings);
+                    const treeCompressor = new InterningTreeCompressor();
+                    const expectedCompressedTree = treeCompressor.compress(getChangeNodeFromView(tree.currentView), interner, sequencedIdNormalizer(getIdNormalizerFromSharedTree(tree)));
+                    expect(summary.currentTree).deep.equal(expectedCompressedTree);
+                    const { tree: secondTree } = setUpTestSharedTree({ writeFormat });
+                    expect(tree.equals(secondTree)).to.be.false;
+                    secondTree.loadSummary(summary);
+                    expect(tree.equals(secondTree)).to.be.true;
+                });
+                it('compress and decompress edit chunks via interning and tree compression', async () => {
+                    const { tree, testObjectProvider } = await setUpLocalServerTestSharedTree({
+                        writeFormat,
+                    });
+                    const testTree = setUpTestTree(tree);
+                    const uncompressedEdits = [
+                        {
+                            changes: tree.edits.getEditInSessionAtIndex(0).changes,
+                        },
+                    ];
+                    // Apply enough edits for the upload of an edit chunk
+                    for (let i = 0; i < tree.edits.editsPerChunk - 1; i++) {
+                        const newNode = testTree.buildLeaf(testTree.generateNodeId());
+                        const edit = tree.applyEditInternal(ChangeInternal.insertTree([newNode], StablePlace.after(testTree.left)));
+                        uncompressedEdits.push({ changes: edit.changes });
+                    }
+                    await testObjectProvider.ensureSynchronized();
+                    const interner = getMutableStringInterner(tree);
+                    const expectedCompressedEdits = new SharedTreeEncoder_0_1_1(true).encodeEditChunk(uncompressedEdits, sequencedIdNormalizer(testTree), interner).edits;
+                    // Apply one more edit so that an edit chunk gets uploaded
+                    const newNode = testTree.buildLeaf(testTree.generateNodeId());
+                    tree.applyEdit(...Change.insertTree(newNode, StablePlace.after(testTree.left)));
+                    // `ensureSynchronized` does not guarantee blob upload
+                    await new Promise((resolve) => setImmediate(resolve));
+                    // Wait for the ops to to be submitted and processed across the containers
+                    await testObjectProvider.ensureSynchronized();
+                    const summary = tree.saveSummary();
+                    const { editHistory } = summary;
+                    const { editChunks } = assertNotUndefined(editHistory);
+                    expect(editChunks.length).to.equal(2);
+                    const handle = editChunks[0].chunk;
+                    expect(typeof handle.get).to.equal('function');
+                    const chunkContents = JSON.parse(IsoBuffer.from(await handle.get()).toString());
+                    expect(chunkContents.edits).to.deep.equal(expectedCompressedEdits);
+                    const { tree: secondTree } = setUpTestSharedTree({ writeFormat });
+                    expect(tree.equals(secondTree)).to.be.false;
+                    secondTree.loadSummary(summary);
+                    expect(tree.equals(secondTree)).to.be.true;
+                    expect((await tree.edits.getEditAtIndex(2)).id).to.equal((await secondTree.edits.getEditAtIndex(2)).id);
+                });
+            });
+        }
     });
 }
 //# sourceMappingURL=SharedTreeTests.js.map