@fluid-experimental/tree 0.58.2002 → 0.58.3000-61081

package/lib/SharedTree.js

@@ -0,0 +1,1059 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { bufferToString, IsoBuffer } from '@fluidframework/common-utils';
+import { AttachState } from '@fluidframework/container-definitions';
+import { createSingleBlobSummary, serializeHandles, SharedObject, } from '@fluidframework/shared-object-base';
+import { ChildLogger, PerformanceEvent } from '@fluidframework/telemetry-utils';
+import { assert, assertNotUndefined, fail, copyPropertyIfDefined } from './Common';
+import { EditLog, getNumberOfHandlesFromEditLogSummary } from './EditLog';
+import { isDetachedSequenceId } from './Identifiers';
+import { initialTree } from './InitialTree';
+import { CachingLogViewer, } from './LogViewer';
+import { deserialize, getSummaryStatistics } from './SummaryBackCompatibility';
+import { ChangeTypeInternal, EditStatus, reservedIdCount, SharedTreeOpType, ghostSessionId, WriteFormat, } from './persisted-types';
+import { serialize } from './Summary';
+import { areRevisionViewsSemanticallyEqual, convertTreeNodes, deepCloneStablePlace, deepCloneStableRange, internalizeBuildNode, newEditId, walkTree, } from './EditUtilities';
+import { getNodeIdContext, sequencedIdNormalizer } from './NodeIdUtilities';
+import { SharedTreeDiagnosticEvent, SharedTreeEvent } from './EventTypes';
+import { RevisionView } from './RevisionView';
+import { SharedTreeEncoder_0_0_2, SharedTreeEncoder_0_1_1 } from './SharedTreeEncoder';
+import { revert } from './HistoryEditFactory';
+import { ChangeType } from './ChangeTypes';
+import { TransactionInternal } from './TransactionInternal';
+import { IdCompressor, createSessionId } from './id-compressor';
+import { convertEditIds } from './IdConversion';
+import { MutableStringInterner } from './StringInterner';
+/**
+ * Factory for SharedTree.
+ * Includes history in the summary.
+ * @public
+ */
+export class SharedTreeFactory {
+    /**
+     * Get a factory for SharedTree to register with the data store.
+     * @param writeFormat - Determines the format version the SharedTree will write summaries in.
+     * This format may be updated to a newer (supported) version at runtime if a collaborating shared-tree
+     * that was initialized with a newer write version connects to the session. Care must be taken when changing this value,
+     * as a staged rollout must have occurred such that all collaborating clients must have the code to read at least the version
+     * written.
+     * @param summarizeHistory - Determines if the history is included in summaries and if edit chunks are uploaded when they are full.
+     * See docs/Breaking-Change-Migration for more details on this scheme.
+     * @param expensiveValidation - Enables expensive asserts on SharedTree.
+     * @returns A factory that creates `SharedTree`s and loads them from storage.
+     */
+    constructor(writeFormat, summarizeHistory = false, expensiveValidation = false) {
+        this.writeFormat = writeFormat;
+        this.summarizeHistory = summarizeHistory;
+        this.expensiveValidation = expensiveValidation;
+    }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory."type"}
+     */
+    get type() {
+        return SharedTreeFactory.Type;
+    }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory.attributes}
+     */
+    get attributes() {
+        return SharedTreeFactory.Attributes;
+    }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory.load}
+     */
+    async load(runtime, id, services, _channelAttributes) {
+        const sharedTree = this.createSharedTree(runtime, id);
+        await sharedTree.load(services);
+        return sharedTree;
+    }
+    /**
+     * Create a new SharedTree.
+     * @param runtime - data store runtime that owns the new SharedTree
+     * @param id - optional name for the SharedTree
+     */
+    create(runtime, id, expensiveValidation = false) {
+        this.expensiveValidation = expensiveValidation;
+        const sharedTree = this.createSharedTree(runtime, id);
+        sharedTree.initializeLocal();
+        return sharedTree;
+    }
+    createSharedTree(runtime, id) {
+        const sharedTree = new SharedTree(runtime, id, this.writeFormat, this.summarizeHistory, this.expensiveValidation);
+        return sharedTree;
+    }
+}
+/**
+ * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory."type"}
+ */
+SharedTreeFactory.Type = 'SharedTree';
+/**
+ * {@inheritDoc @fluidframework/shared-object-base#ISharedObjectFactory.attributes}
+ */
+SharedTreeFactory.Attributes = {
+    type: SharedTreeFactory.Type,
+    snapshotFormatVersion: '0.1',
+    packageVersion: '0.1',
+};
+/**
+ * Filename where the snapshot is stored.
+ */
+const snapshotFileName = 'header';
+/**
+ * Used for version comparison.
+ */
+const sortedWriteVersions = [WriteFormat.v0_0_2, WriteFormat.v0_1_1];
+const sharedTreeTelemetryProperties = { all: { isSharedTreeEvent: true } };
+/**
+ * A distributed tree.
+ * @public
+ */
+export class SharedTree extends SharedObject {
+    /**
+     * Create a new SharedTreeFactory.
+     * @param runtime - The runtime the SharedTree will be associated with
+     * @param id - Unique ID for the SharedTree
+     * @param writeFormat - Determines the format version the SharedTree will write summaries in.
+     * @param summarizeHistory - Determines if the history is included in summaries and if edit chunks are uploaded when they are full.
+     * @param expensiveValidation - Enable expensive asserts.
+     */
+    constructor(runtime, id, writeFormat, summarizeHistory = false, expensiveValidation = false) {
+        super(id, runtime, SharedTreeFactory.Attributes);
+        this.writeFormat = writeFormat;
+        this.expensiveValidation = expensiveValidation;
+        this.idCompressor = new IdCompressor(createSessionId(), reservedIdCount);
+        this.idNormalizer = {
+            tree: this,
+            get localSessionId() {
+                return this.tree.idCompressor.localSessionId;
+            },
+            normalizeToOpSpace: (id) => this.idCompressor.normalizeToOpSpace(id),
+            normalizeToSessionSpace: (id, sessionId) => this.idCompressor.normalizeToSessionSpace(id, sessionId),
+        };
+        // The initial tree's definition isn't included in any op by default but it should still be interned. Including it here ensures that.
+        this.interner = new MutableStringInterner([initialTree.definition]);
+        this.processEditResult = (editResult, editId) => {
+            // TODO:#44859: Invalid results should be handled by the app
+            this.emit(SharedTree.eventFromEditResult(editResult), editId);
+        };
+        this.processSequencedEditResult = ({ edit, wasLocal, result, reconciliationPath, }) => {
+            const eventArguments = {
+                edit,
+                wasLocal,
+                tree: this,
+                logger: this.sequencedEditAppliedLogger,
+                reconciliationPath,
+                outcome: result,
+            };
+            this.emit(SharedTreeEvent.SequencedEditApplied, eventArguments);
+        };
+        this.transactionFactory = TransactionInternal.factory;
+        /**
+         * Re-computes currentIsOldest and emits an event if it has changed.
+         * TODO:#55900: Get rid of copy-pasted OldestClientObserver code
+         */
+        this.updateOldest = () => {
+            const oldest = this.computeIsOldest();
+            if (this.currentIsOldest !== oldest) {
+                this.currentIsOldest = oldest;
+                if (oldest) {
+                    this.emit('becameOldest');
+                    this.logger.sendTelemetryEvent({ eventName: 'BecameOldestClient' });
+                }
+                else {
+                    this.emit('lostOldest');
+                }
+            }
+        };
+        this.summarizeHistory = summarizeHistory === false ? false : true;
+        this.uploadEditChunks = summarizeHistory === false ? false : summarizeHistory.uploadEditChunks;
+        // This code is somewhat duplicated from OldestClientObserver because it currently depends on the container runtime
+        // which SharedTree does not have access to.
+        // TODO:#55900: Get rid of copy-pasted OldestClientObserver code
+        const quorum = this.runtime.getQuorum();
+        this.currentIsOldest = this.computeIsOldest();
+        quorum.on('addMember', this.updateOldest);
+        quorum.on('removeMember', this.updateOldest);
+        runtime.on('connected', this.updateOldest);
+        runtime.on('disconnected', this.updateOldest);
+        this.logger = ChildLogger.create(runtime.logger, 'SharedTree', sharedTreeTelemetryProperties);
+        this.sequencedEditAppliedLogger = ChildLogger.create(this.logger, 'SequencedEditApplied', sharedTreeTelemetryProperties);
+        const { editLog, cachingLogViewer } = this.initializeNewEditLogFromSummary({
+            editChunks: [],
+            editIds: [],
+        }, undefined, this.idCompressor, // TODO: Attribution info
+        this.processEditResult, this.processSequencedEditResult, WriteFormat.v0_1_1);
+        this.editLog = editLog;
+        this.cachingLogViewer = cachingLogViewer;
+        this.encoder_0_0_2 = new SharedTreeEncoder_0_0_2(this.summarizeHistory);
+        this.encoder_0_1_1 = new SharedTreeEncoder_0_1_1(this.summarizeHistory);
+    }
+    /**
+     * Create a new SharedTree. It will contain the default value (see initialTree).
+     */
+    static create(runtime, id) {
+        return runtime.createChannel(id, SharedTreeFactory.Type);
+    }
+    /**
+     * Get a factory for SharedTree to register with the data store.
+     * @param summarizeHistory - Determines if the history is included in summaries and if edit chunks are uploaded when they are full.
+     * On 0.1.1 documents, due to current code limitations, this parameter is only impactful for newly created documents.
+     * `SharedTree`s which load existing documents will summarize history if and only if the loaded summary included history.
+     *
+     * The technical limitations here relate to clients with mixed versions collaborating.
+     * In the future we may allow modification of whether or not a particular document saves history, but only via a consensus mechanism.
+     * See the skipped test in SharedTreeFuzzTests.ts for more details on this issue.
+     * See docs/Breaking-Change-Migration for more details on the consensus scheme.
+     * @param writeFormat - Determines the format version the SharedTree will write summaries in.
+     * This format may be updated to a newer (supported) version at runtime if a collaborating shared-tree
+     * that was initialized with a newer write version connects to the session. Care must be taken when changing this value,
+     * as a staged rollout must of occurred such that all collaborating clients must have the code to read at least the version
+     * written.
+     * @returns A factory that creates `SharedTree`s and loads them from storage.
+     */
+    static getFactory(writeFormat, summarizeHistory = false) {
+        return new SharedTreeFactory(writeFormat, summarizeHistory);
+    }
+    /**
+     * Viewer for trees defined by editLog. This allows access to views of the tree at different revisions (various points in time).
+     */
+    get logViewer() {
+        return this.cachingLogViewer;
+    }
+    getWriteFormat() {
+        return this.writeFormat;
+    }
+    /**
+     * Computes the oldest client in the quorum, true by default if the container is detached and false by default if the client isn't connected.
+     * TODO:#55900: Get rid of copy-pasted OldestClientObserver code
+     */
+    computeIsOldest() {
+        // If the container is detached, we are the only ones that know about it and are the oldest by default.
+        if (this.runtime.attachState === AttachState.Detached) {
+            return true;
+        }
+        // If we're not connected we can't be the oldest connected client.
+        if (!this.runtime.connected) {
+            return false;
+        }
+        assert(this.runtime.clientId !== undefined, 'Client id should be set if connected.');
+        const quorum = this.runtime.getQuorum();
+        const selfSequencedClient = quorum.getMember(this.runtime.clientId);
+        // When in readonly mode our clientId will not be present in the quorum.
+        if (selfSequencedClient === undefined) {
+            return false;
+        }
+        const members = quorum.getMembers();
+        for (const sequencedClient of members.values()) {
+            if (sequencedClient.sequenceNumber < selfSequencedClient.sequenceNumber) {
+                return false;
+            }
+        }
+        // No member of the quorum was older
+        return true;
+    }
+    /**
+     * @returns the current view of the tree.
+     */
+    get currentView() {
+        return this.logViewer.getRevisionViewInSession(Number.POSITIVE_INFINITY);
+    }
+    /**
+     * {@inheritdoc NodeIdGenerator.generateNodeId}
+     * @public
+     */
+    generateNodeId(override) {
+        return this.idCompressor.generateCompressedId(override);
+    }
+    /** {@inheritdoc NodeIdConverter.convertToStableNodeId} */
+    convertToStableNodeId(id) {
+        var _a;
+        return (_a = this.idCompressor.tryDecompress(id)) !== null && _a !== void 0 ? _a : fail('Node id is not known to this SharedTree');
+    }
+    /** {@inheritdoc NodeIdConverter.tryConvertToStableNodeId} */
+    tryConvertToStableNodeId(id) {
+        return this.idCompressor.tryDecompress(id);
+    }
+    /** {@inheritdoc NodeIdConverter.convertToNodeId} */
+    convertToNodeId(id) {
+        var _a;
+        return ((_a = this.idCompressor.tryRecompress(id)) !== null && _a !== void 0 ? _a : fail('Stable node id is not known to this SharedTree'));
+    }
+    /** {@inheritdoc NodeIdConverter.tryConvertToNodeId} */
+    tryConvertToNodeId(id) {
+        return this.idCompressor.tryRecompress(id);
+    }
+    /**
+     * @returns the edit history of the tree.
+     * @public
+     */
+    get edits() {
+        return this.editLog;
+    }
+    /**
+     * @returns the edit history of the tree. The format of the contents of edits are subject to change and should not be relied upon.
+     * @internal
+     */
+    get editsInternal() {
+        return this.editLog;
+    }
+    deserializeHandle(serializedHandle) {
+        const deserializeHandle = this.serializer.parse(serializedHandle);
+        assert(typeof deserializeHandle === 'object');
+        return deserializeHandle;
+    }
+    /**
+     * Uploads the edit chunk and sends the chunk starting revision along with the resulting handle as an op.
+     */
+    async uploadEditChunk(edits, startRevision) {
+        var _a;
+        assert(this.writeFormat !== WriteFormat.v0_0_2, 'Edit chunking is not supported in v0_0_2');
+        // SPO attachment blob upload limit is set here:
+        // https://onedrive.visualstudio.com/SharePoint%20Online/_git/SPO?path=%2Fsts%2Fstsom%2FPrague%2FSPPragueProtocolConfig.cs&version=GBmaster&line=82&lineEnd=82&lineStartColumn=29&lineEndColumn=116&lineStyle=plain&_a=contents
+        // TODO:#59754: Create chunks based on data buffer size instead of number of edits
+        const blobUploadSizeLimit = 4194304;
+        try {
+            const chunkContents = this.encoder_0_1_1.encodeEditChunk(edits, sequencedIdNormalizer(this.idNormalizer), this.interner);
+            const serializedContents = serializeHandles(chunkContents, this.serializer, this.handle);
+            const buffer = IsoBuffer.from(serializedContents);
+            const bufferSize = buffer.byteLength;
+            assert(bufferSize <= blobUploadSizeLimit, `Edit chunk size ${bufferSize} is larger than blob upload size limit of ${blobUploadSizeLimit} bytes.`);
+            const editHandle = await this.runtime.uploadBlob(buffer);
+            const handleOp = {
+                editHandle: (_a = serializeHandles(editHandle, this.serializer, this.handle)) !== null && _a !== void 0 ? _a : fail('Edit chunk handle could not be serialized.'),
+                startRevision,
+                type: SharedTreeOpType.Handle,
+                version: this.writeFormat,
+            };
+            this.submitOp(handleOp);
+            this.emit(SharedTreeDiagnosticEvent.EditChunkUploaded);
+        }
+        catch (error) {
+            // If chunk load fails, we will try again later in loadCore on the oldest client so we log the error instead of throwing.
+            this.logger.sendErrorEvent({
+                eventName: 'EditChunkUploadFailure',
+            }, error);
+        }
+    }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.summarizeCore}
+     */
+    summarizeCore(serializer) {
+        return createSingleBlobSummary(snapshotFileName, this.saveSerializedSummary({ serializer }));
+    }
+    /**
+     * Saves this SharedTree into a serialized summary. This is used for testing.
+     *
+     * @param summarizer - Optional summarizer to use. If not passed in, SharedTree's summarizer is used.
+     * @internal
+     */
+    saveSerializedSummary(options) {
+        const { serializer } = options || {};
+        return serialize(this.saveSummary(), serializer !== null && serializer !== void 0 ? serializer : this.serializer, this.handle);
+    }
+    /**
+     * Initialize shared tree with a serialized summary. This is used for testing.
+     * @returns - statistics about the loaded summary.
+     * @internal
+     */
+    loadSerializedSummary(blobData) {
+        const summary = deserialize(blobData, this.serializer);
+        this.loadSummary(summary);
+        return getSummaryStatistics(summary);
+    }
+    /**
+     * Saves this SharedTree into a deserialized summary.
+     * @internal
+     */
+    saveSummary() {
+        // If local changes exist, emulate the sequencing of those changes.
+        // Doing so is necessary so edits created during DataObject.initializingFirstTime are included.
+        // Doing so is safe because it is guaranteed that the DDS has not yet been attached. This is because summary creation is only
+        // ever invoked on a DataObject containing local changes when it is attached for the first time. In post-attach flows, an extra
+        // instance of the DataObject is created for generating summaries and will never have local edits.
+        if (this.editLog.numberOfLocalEdits > 0) {
+            assert(this.runtime.attachState !== AttachState.Attached, 'Summarizing should not occur with local edits except on first attach.');
+            if (this.writeFormat === WriteFormat.v0_1_1) {
+                // Since we're the first client to attach, we can safely finalize ourselves since we're the only ones who have made IDs.
+                this.idCompressor.finalizeCreationRange(this.idCompressor.takeNextCreationRange());
+                for (const edit of this.editLog.getLocalEdits()) {
+                    this.internStringsFromEdit(edit);
+                }
+            }
+            this.editLog.sequenceLocalEdits();
+        }
+        assert(this.editLog.numberOfLocalEdits === 0, 'generateSummary must not be called with local edits');
+        return this.generateSummary();
+    }
+    /**
+     * Generates a SharedTree summary for the current state of the tree.
+     * Will never be called when local edits are present.
+     */
+    generateSummary() {
+        var _a;
+        try {
+            switch (this.writeFormat) {
+                case WriteFormat.v0_0_2:
+                    return this.encoder_0_0_2.encodeSummary(this.editLog, this.currentView, this);
+                case WriteFormat.v0_1_1:
+                    return this.encoder_0_1_1.encodeSummary(this.editLog, this.currentView, this, this.idNormalizer, this.interner, this.idCompressor.serialize(false));
+                default:
+                    fail('Unknown version');
+            }
+        }
+        catch (error) {
+            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.sendErrorEvent({
+                eventName: 'UnsupportedSummaryWriteFormat',
+                formatVersion: this.writeFormat,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Initialize shared tree with a deserialized summary.
+     * @internal
+     */
+    loadSummary(summary) {
+        const { version: loadedSummaryVersion } = summary;
+        if (isUpdateRequired(loadedSummaryVersion, this.writeFormat)) {
+            this.submitOp({ type: SharedTreeOpType.Update, version: this.writeFormat });
+            this.logger.sendTelemetryEvent({
+                eventName: 'RequestVersionUpdate',
+                versionFrom: loadedSummaryVersion,
+                versionTo: this.writeFormat,
+            });
+        }
+        if (compareSummaryFormatVersions(loadedSummaryVersion, this.writeFormat) !== 0) {
+            // Write whatever format the loaded summary uses (this is the current agreed-upon format: it may be updated by an update op)
+            this.changeWriteFormat(loadedSummaryVersion);
+        }
+        assert(this.idCompressor.getAllIdsFromLocalSession().next().done === true, 'Summary load should not be executed after local state is created.');
+        let convertedSummary;
+        switch (loadedSummaryVersion) {
+            case WriteFormat.v0_0_2:
+                convertedSummary = this.encoder_0_0_2.decodeSummary(summary);
+                break;
+            case WriteFormat.v0_1_1: {
+                const typedSummary = summary;
+                // See comment in factory constructor--ensure we write a consistent type of summary as how the document began.
+                const loadedSummaryIncludesHistory = typedSummary.currentTree !== undefined;
+                if (loadedSummaryIncludesHistory !== this.summarizeHistory) {
+                    this.summarizeHistory = loadedSummaryIncludesHistory;
+                    this.uploadEditChunks = loadedSummaryIncludesHistory;
+                    this.encoder_0_1_1 = new SharedTreeEncoder_0_1_1(this.summarizeHistory);
+                }
+                convertedSummary = this.encoder_0_1_1.decodeSummary(summary);
+                break;
+            }
+            default:
+                fail('Unknown version');
+        }
+        const { editHistory, currentTree, idCompressor, interner } = convertedSummary;
+        this.interner = interner;
+        this.interner.getOrCreateInternedId(initialTree.definition);
+        if (compareSummaryFormatVersions(loadedSummaryVersion, WriteFormat.v0_1_1) < 0) {
+            const { editIds, editChunks } = editHistory;
+            this.logger.sendTelemetryEvent({
+                eventName: 'SummaryConversion',
+                formatVersion: WriteFormat.v0_1_1,
+                historySize: editIds.length,
+                totalNumberOfChunks: editChunks.length,
+                uploadedChunks: getNumberOfHandlesFromEditLogSummary(editHistory),
+            });
+        }
+        this.initializeNewEditLogFromSummary(editHistory, currentTree, idCompressor, this.processEditResult, this.processSequencedEditResult, summary.version);
+        if (this.runtime.connected) {
+            const noChunksReadyForUpload = this.editLog.getEditChunksReadyForUpload()[Symbol.iterator]().next().done;
+            if (noChunksReadyForUpload === undefined || !noChunksReadyForUpload) {
+                // A client does not become a member of the quorum until it is within the collaboration window.
+                //
+                // The collaboration window is the range from the minimum sequence number enforced by the server and head.
+                // When a client sends an op, they include the last sequence number the client has processed. We call this the reference
+                // sequence number.
+                //
+                // If there are no members in the quorum, we send a no op op in order to have this client added as a member to the quorum.
+                // This is required so we can ensure only the oldest client will upload blobs during summary load.
+                if (this.runtime.getQuorum().getMembers().size === 0) {
+                    const noop = {
+                        type: SharedTreeOpType.NoOp,
+                        version: this.writeFormat,
+                    };
+                    this.submitOp(noop);
+                    this.logger.sendTelemetryEvent({ eventName: 'NoOpSent' });
+                }
+                else if (this.currentIsOldest) {
+                    this.uploadCatchUpBlobs();
+                }
+            }
+            // If this client becomes the oldest, it should take care of uploading catch up blobs.
+            this.on('becameOldest', () => this.uploadCatchUpBlobs());
+        }
+    }
+    static eventFromEditResult(editStatus) {
+        switch (editStatus) {
+            case EditStatus.Applied:
+                return SharedTreeDiagnosticEvent.AppliedEdit;
+            case EditStatus.Invalid:
+                return SharedTreeDiagnosticEvent.DroppedInvalidEdit;
+            default:
+                return SharedTreeDiagnosticEvent.DroppedMalformedEdit;
+        }
+    }
+    /**
+     * Initializes a new `EditLog` and `CachingLogViewer` on this `SharedTree`, replacing and disposing of any previously existing ones.
+     * @returns the initialized values (this is mostly to keep the constructor happy)
+     */
+    initializeNewEditLogFromSummary(editHistory, currentTree, idCompressor, editStatusCallback, sequencedEditResultCallback, version) {
+        var _a, _b;
+        this.idCompressor = idCompressor;
+        // Dispose the current log viewer if it exists. This ensures that re-used EditAddedHandlers below don't retain references to old
+        // log viewers.
+        (_a = this.cachingLogViewer) === null || _a === void 0 ? void 0 : _a.detachFromEditLog();
+        const indexOfFirstEditInSession = version === WriteFormat.v0_0_2 || ((editHistory === null || editHistory === void 0 ? void 0 : editHistory.editIds.length) === 1 && version === WriteFormat.v0_1_1)
+            ? 0
+            : editHistory === null || editHistory === void 0 ? void 0 : editHistory.editIds.length;
+        // Use previously registered EditAddedHandlers if there is an existing EditLog.
+        const editLog = new EditLog(editHistory, this.logger, (_b = this.editLog) === null || _b === void 0 ? void 0 : _b.editAddedHandlers, indexOfFirstEditInSession);
+        editLog.on(SharedTreeDiagnosticEvent.UnexpectedHistoryChunk, () => {
+            this.emit(SharedTreeDiagnosticEvent.UnexpectedHistoryChunk);
+        });
+        let knownRevisions;
+        if (currentTree !== undefined) {
+            const currentView = RevisionView.fromTree(currentTree);
+            // TODO:#47830: Store multiple checkpoints in summary.
+            knownRevisions = [[editLog.length, { view: currentView }]];
+        }
+        const logViewer = new CachingLogViewer(editLog, RevisionView.fromTree(initialTree, this), knownRevisions, this.expensiveValidation, editStatusCallback, sequencedEditResultCallback, this.transactionFactory, 0);
+        this.editLog = editLog;
+        this.cachingLogViewer = logViewer;
+        return { editLog, cachingLogViewer: logViewer };
+    }
+    /**
+     * Upload any full chunks that have yet to be uploaded.
+     */
+    uploadCatchUpBlobs() {
+        if (this.writeFormat !== WriteFormat.v0_0_2 && this.uploadEditChunks) {
+            for (const [startRevision, chunk] of this.editLog.getEditChunksReadyForUpload()) {
+                this.uploadEditChunk(chunk, startRevision)
+                    .then(() => {
+                    this.emit(SharedTreeDiagnosticEvent.CatchUpBlobUploaded);
+                    this.logger.sendTelemetryEvent({ eventName: 'CatchUpBlobUpload', chunkSize: chunk.length });
+                })
+                    // It is safe to swallow errors from edit chunk upload because the next summary load will
+                    // do another attempt to upload the edit chunks that couldn't previously be uploaded
+                    .catch((error) => { });
+            }
+        }
+    }
+    /**
+     * Compares this shared tree to another for equality. Should only be used for correctness testing.
+     *
+     * Equality means that the histories as captured by the EditLogs are equivalent.
+     *
+     * Equality does not include:
+     *   - if an edit is open
+     *   - the shared tree's id
+     *   - local vs sequenced status of edits
+     *   - registered event listeners
+     *   - state of caches
+     *
+     * @internal
+     * */
+    equals(sharedTree) {
+        if (!areRevisionViewsSemanticallyEqual(this.currentView, this, sharedTree.currentView, sharedTree)) {
+            return false;
+        }
+        return this.editLog.equals(sharedTree.editLog);
+    }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    async loadCore(storage) {
+        const summaryLoadPerformanceEvent = PerformanceEvent.start(this.logger, { eventName: 'SummaryLoad' });
+        try {
+            const newBlob = await storage.readBlob(snapshotFileName);
+            const blobData = bufferToString(newBlob, 'utf8');
+            const stats = this.loadSerializedSummary(blobData);
+            summaryLoadPerformanceEvent.end(stats);
+        }
+        catch (error) {
+            summaryLoadPerformanceEvent.cancel({ eventName: 'SummaryLoadFailure' }, error);
+            throw error;
+        }
+    }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.processCore}
+     */
+    processCore(message, local) {
+        const typedMessage = message;
+        this.cachingLogViewer.setMinimumSequenceNumber(typedMessage.minimumSequenceNumber);
+        const op = typedMessage.contents;
+        const { type, version } = op;
+        const resolvedVersion = version !== null && version !== void 0 ? version : WriteFormat.v0_0_2;
+        const sameVersion = resolvedVersion === this.writeFormat;
+        // Edit and handle ops should only be processed if they're the same version as the tree write version.
+        // Update ops should only be processed if they're not the same version.
+        if (sameVersion) {
+            if (type === SharedTreeOpType.Handle) {
+                const { editHandle, startRevision } = op;
+                const baseHandle = this.deserializeHandle(editHandle);
+                const decodedHandle = {
+                    get: async () => {
+                        const contents = await baseHandle.get();
+                        const parsedContents = JSON.parse(IsoBuffer.from(contents).toString());
+                        return this.encoder_0_1_1.decodeEditChunk(parsedContents, sequencedIdNormalizer(this.idNormalizer), this.interner);
+                    },
+                    baseHandle,
+                };
+                this.editLog.processEditChunkHandle(decodedHandle, startRevision);
+            }
+            else if (type === SharedTreeOpType.Edit) {
+                if (op.version === WriteFormat.v0_1_1) {
+                    // TODO: This cast can be removed on typescript 4.6
+                    this.idCompressor.finalizeCreationRange(op.idRange);
+                }
+                // TODO: This cast can be removed on typescript 4.6
+                const edit = this.parseSequencedEdit(op);
+                this.internStringsFromEdit(edit);
+                this.processSequencedEdit(edit, typedMessage);
+            }
+        }
+        else if (type === SharedTreeOpType.Update) {
+            this.processVersionUpdate(op.version);
+        }
+        else if (compareSummaryFormatVersions(resolvedVersion, this.writeFormat) === 1) {
+            // An op version newer than our current version should not be received. If this happens, either an
+            // incorrect op version has been written or an update op was skipped.
+            const error = 'Newer op version received by a client that has yet to be updated.';
+            this.logger.sendErrorEvent({
+                eventName: 'UnexpectedNewerOpVersion',
+            }, error);
+            fail(error);
+        }
+    }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.registerCore}
+     */
+    registerCore() {
+        // Do nothing
+    }
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onDisconnect}
+     */
+    onDisconnect() {
+        // Do nothing
+    }
+    /**
+     * Parses a sequenced edit. This is only invoked for ops with version matching the current `writeFormat`.
+     */
+    parseSequencedEdit(op) {
+        // TODO:Type Safety: Improve type safety around op sending/parsing (e.g. discriminated union over version field somehow)
+        switch (op.version) {
+            case WriteFormat.v0_0_2:
+                return this.encoder_0_0_2.decodeEditOp(op, this.encodeSemiSerializedEdit.bind(this), this);
+            case WriteFormat.v0_1_1:
+                return this.encoder_0_1_1.decodeEditOp(op, this.encodeSemiSerializedEdit.bind(this), this.idNormalizer, this.interner);
+            default:
+                fail('Unknown op version');
+        }
+    }
+    encodeSemiSerializedEdit(semiSerializedEdit) {
+        // semiSerializedEdit may have handles which have been replaced by `serializer.encode`.
+        // Since there is no API to un-replace them except via parse, re-stringify the edit, then parse it.
+        // Stringify using JSON, not IFluidSerializer since OPs use JSON directly.
+        // TODO:Performance:#48025: Avoid this serialization round trip.
+        const encodedEdit = this.serializer.parse(JSON.stringify(semiSerializedEdit));
+        return encodedEdit;
+    }
+    processSequencedEdit(edit, message) {
+        const { id: editId } = edit;
+        const wasLocalEdit = this.editLog.isLocalEdit(editId);
+        // If the id of the supplied edit matches a non-local edit already present in the log, this would normally be indicative of an error.
+        // However, the @fluidframework packages prior to 0.37.x have a bug which can cause data corruption by sequencing duplicate edits--
+        // see discussion on the following github issue: https://github.com/microsoft/FluidFramework/issues/4399
+        // To work around this issue, we currently tolerate duplicate ops in loaded documents.
+        // This could be strengthened in the future to only apply to documents which may have been impacted.
+        const shouldIgnoreEdit = this.editLog.tryGetIndexOfId(editId) !== undefined && !wasLocalEdit;
+        if (shouldIgnoreEdit) {
+            return;
+        }
+        if (wasLocalEdit) {
+            this.editLog.addSequencedEdit(edit, message);
+            // If this client created the edit that filled up a chunk, it is responsible for uploading that chunk.
+            if (compareSummaryFormatVersions(this.writeFormat, WriteFormat.v0_0_2) > 0 && this.uploadEditChunks) {
+                const lastPair = this.editLog.getLastEditChunk();
+                if (lastPair !== undefined) {
+                    const [startRevision, chunk] = lastPair;
+                    const edits = assertNotUndefined(chunk.edits);
+                    if (edits.length === this.editLog.editsPerChunk) {
+                        this.uploadEditChunk(edits, startRevision)
+                            .then(() => {
+                            this.logger.sendTelemetryEvent({
+                                eventName: 'EditChunkUpload',
+                                chunkSize: edits.length,
+                            });
+                        })
+                            // It is safe to swallow errors from edit chunk upload because the next summary load will
+                            // do another attempt to upload the edit chunks that couldn't previously be uploaded
+                            .catch((error) => { });
+                    }
+                }
+            }
+        }
+        else {
+            this.applyEditLocally(edit, message);
+        }
+    }
+    /**
+     * Updates SharedTree to the provided version if the version is a valid write version newer than the current version.
+     * @param version - The version to update to.
+     */
+    processVersionUpdate(version) {
+        if (isUpdateRequired(this.writeFormat, version)) {
+            PerformanceEvent.timedExec(this.logger, { eventName: 'VersionUpdate', version }, () => {
+                if (compareSummaryFormatVersions(version, WriteFormat.v0_1_1) >= 0) {
+                    this.upgradeFrom_0_0_2_to_0_1_1();
+                }
+                else {
+                    throw new Error(`Updating to version ${version} is not supported.`);
+                }
+                this.changeWriteFormat(version);
+                // The edit log may contain some local edits submitted after the version update op was submitted but
+                // before we receive the message it has been sequenced. Since these edits must be sequenced after the version
+                // update op, they will be discarded. These edits are then re-submitted using the new format.
+                for (const edit of this.editLog.getLocalEdits()) {
+                    this.submitEditOp(edit);
+                }
+                if (this.currentIsOldest) {
+                    this.uploadCatchUpBlobs();
+                }
+            }, {
+                end: true,
+                cancel: 'error',
+            });
+        }
+    }
+    upgradeFrom_0_0_2_to_0_1_1() {
+        for (let i = 0; i < this.editLog.numberOfSequencedEdits; i++) {
+            this.internStringsFromEdit(this.editsInternal.getEditInSessionAtIndex(i));
+        }
+        const oldIdCompressor = this.idCompressor;
+        // Create the IdCompressor that will be used after the upgrade
+        const newIdCompressor = new IdCompressor(createSessionId(), reservedIdCount); // TODO: attribution info
+        const newContext = getNodeIdContext(newIdCompressor);
+        // Generate all local IDs in the new compressor that were in the old compressor and preserve their UUIDs.
+        // This will allow the client to continue to use local IDs that were allocated pre-upgrade
+        for (const localId of oldIdCompressor.getAllIdsFromLocalSession()) {
+            newIdCompressor.generateCompressedId(oldIdCompressor.decompress(localId));
+        }
+        const unifyHistoricalIds = (context) => {
+            for (let i = 0; i < this.editLog.numberOfSequencedEdits; i++) {
+                const edit = this.editsInternal.getEditInSessionAtIndex(i);
+                convertEditIds(edit, (id) => context.generateNodeId(this.convertToStableNodeId(id)));
+            }
+        };
+        // Construct a temporary "ghost" compressor which is used to generate final IDs that will be consistent across all upgrading clients
+        const ghostIdCompressor = new IdCompressor(ghostSessionId, reservedIdCount); // TODO: attribution info
+        const ghostContext = getNodeIdContext(ghostIdCompressor);
+        if (this.summarizeHistory) {
+            // All clients have the full history, and can therefore all "generate" the same final IDs for every ID in the history
+            // via the ghost compressor.
+            unifyHistoricalIds(ghostContext);
+        }
+        else {
+            // Clients do not have the full history, but all share the same current view (sequenced). They can all finalize the same final
+            // IDs for every ID in the view via the ghost compressor.
+            for (const node of this.logViewer.getRevisionViewInSession(this.editLog.numberOfSequencedEdits)) {
+                ghostContext.generateNodeId(this.convertToStableNodeId(node.identifier));
+            }
+            // Every node in this client's history can simply be generated in the new compressor as well, preserving the UUID
+            unifyHistoricalIds(newContext);
+        }
+        // Finalize any IDs in the ghost compressor into the actual compressor. This simulates all clients reaching a consensus on those IDs
+        newIdCompressor.finalizeCreationRange(ghostIdCompressor.takeNextCreationRange());
+        this.idCompressor = newIdCompressor;
+    }
+    /**
+     * Add an `Edit` directly.
+     * External users should use one of the more specialized functions, like applyEdit which handles constructing the actual `Edit` object.
+     * This is exposed as it is useful for testing, particularly with invalid and malformed Edits.
+     * @internal
+     */
+    applyEdit(...changes) {
+        const id = newEditId();
+        const internalEdit = {
+            id,
+            changes: changes.map((c) => this.internalizeChange(c)),
+        };
+        this.submitEditOp(internalEdit);
+        this.applyEditLocally(internalEdit, undefined);
+        return internalEdit;
+    }
+    /**
+     * @internal
+     */
+    applyEditInternal(editOrChanges) {
+        let edit;
+        if (Array.isArray(editOrChanges)) {
+            const id = newEditId();
+            edit = { id, changes: editOrChanges };
+        }
+        else {
+            edit = editOrChanges;
+        }
+        this.submitEditOp(edit);
+        this.applyEditLocally(edit, undefined);
+        return edit;
+    }
+    /**
+     * Given a newly constructed edit, add any necessary metadata
+     * @internal
+     */
+    internalizeChange(change) {
+        switch (change.type) {
+            case ChangeType.Insert:
+                return {
+                    source: change.source,
+                    destination: deepCloneStablePlace(change.destination),
+                    type: ChangeTypeInternal.Insert,
+                };
+            case ChangeType.Detach: {
+                const detach = {
+                    source: deepCloneStableRange(change.source),
+                    type: ChangeTypeInternal.Detach,
+                };
+                copyPropertyIfDefined(change, detach, 'destination');
+                return detach;
+            }
+            case ChangeType.Build: {
+                if (isTreeNodeSequence(change.source)) {
+                    const source = change.source.map((buildNode) => convertTreeNodes(buildNode, (nodeData) => internalizeBuildNode(nodeData, this), (x) => typeof x === 'number'));
+                    return {
+                        source,
+                        destination: change.destination,
+                        type: ChangeTypeInternal.Build,
+                    };
+                }
+                else {
+                    const source = convertTreeNodes(change.source, (nodeData) => internalizeBuildNode(nodeData, this), (x) => typeof x === 'number');
+                    return {
+                        source: [source],
+                        destination: change.destination,
+                        type: ChangeTypeInternal.Build,
+                    };
+                }
+            }
+            case ChangeType.SetValue:
+                return {
+                    nodeToModify: change.nodeToModify,
+                    payload: change.payload,
+                    type: ChangeTypeInternal.SetValue,
+                };
+            case ChangeType.Constraint: {
+                const constraint = {
+                    effect: change.effect,
+                    toConstrain: change.toConstrain,
+                    type: ChangeTypeInternal.Constraint,
+                };
+                copyPropertyIfDefined(change, constraint, 'contentHash');
+                copyPropertyIfDefined(change, constraint, 'identityHash');
+                copyPropertyIfDefined(change, constraint, 'label');
+                copyPropertyIfDefined(change, constraint, 'length');
+                copyPropertyIfDefined(change, constraint, 'parentNode');
+                return constraint;
+            }
+            default:
+                fail('unexpected change type');
+        }
+    }
+    applyEditLocally(edit, message) {
+        const isSequenced = message !== undefined;
+        if (isSequenced) {
+            // TODO: This cast can be removed on typescript 4.6
+            this.editLog.addSequencedEdit(edit, message);
+        }
+        else {
+            this.editLog.addLocalEdit(edit);
+        }
+        const eventArguments = {
+            editId: edit.id,
+            local: !isSequenced,
+            tree: this,
+        };
+        this.emit(SharedTreeEvent.EditCommitted, eventArguments);
+    }
+    /**
+     * Reverts a previous edit by applying a new edit containing the inverse of the original edit's changes.
+     * @param editId - the edit to revert
+     * @returns the id of the new edit, or undefined if the original edit could not be inverted given the current tree state.
+     * @public
+     */
+    revert(editId) {
+        const index = this.edits.getIndexOfId(editId);
+        const edit = this.editLog.getEditInSessionAtIndex(index);
+        const before = this.logViewer.getRevisionViewInSession(index);
+        const changes = this.revertChanges(edit.changes, before);
+        if (changes === undefined) {
+            return undefined;
+        }
+        return this.applyEditInternal(changes).id;
+    }
+    /**
+     * Revert the given changes
+     * @param changes - the changes to revert
+     * @param before - the revision view before the changes were originally applied
+     * @returns the inverse of `changes` or undefined if the changes could not be inverted for the given tree state.
+     * @internal
+     */
+    revertChanges(changes, before) {
+        return revert(changes, before);
+    }
+    /**
+     * Submits an edit by the local client to the runtime.
+     */
+    submitEditOp(edit) {
+        // Only submit ops if attached, since op submission can have stateful side effects (e.g. changing the IdCompressor)
+        // Ops will be submitted again when attached (see loadSummary())
+        if (this.isAttached()) {
+            switch (this.writeFormat) {
+                case WriteFormat.v0_0_2:
+                    this.submitOp(this.encoder_0_0_2.encodeEditOp(edit, this.serializeEdit.bind(this), this));
+                    break;
+                case WriteFormat.v0_1_1:
+                    this.submitOp(this.encoder_0_1_1.encodeEditOp(edit, this.serializeEdit.bind(this), this.idCompressor.takeNextCreationRange(), this.idNormalizer, this.interner));
+                    break;
+                default:
+                    fail('Unknown version');
+            }
+        }
+    }
+    serializeEdit(preparedEdit) {
+        return this.serializer.encode(preparedEdit, this.handle);
+    }
+    /** A type-safe `submitLocalMessage` wrapper to enforce op format */
+    submitOp(content, localOpMetadata = undefined) {
+        assert(compareSummaryFormatVersions(content.version, this.writeFormat) === 0, 'Attempted to submit op of wrong version');
+        this.submitLocalMessage(content, localOpMetadata);
+    }
+    getRuntime() {
+        return this.runtime;
+    }
+    /**
+     * "Pending local state" refers to ops submitted to the runtime that have not yet been acked.
+     * When closing a container, hosts have the option to stash this pending local state somewhere to be reapplied
+     * later (to avoid data loss).
+     * If a host then loads a container using that stashed state, this function is called for each stashed op, and is expected to:
+     * 1. Update this DDS to reflect that state locally.
+     * 2. Return any `localOpMetadata` that would have been associated with this op.
+     *
+     * @param content - op to apply locally.
+     */
+    applyStashedOp(op) {
+        const sharedTreeOp = op;
+        switch (sharedTreeOp.type) {
+            case SharedTreeOpType.Edit: {
+                switch (this.writeFormat) {
+                    case WriteFormat.v0_0_2:
+                        switch (sharedTreeOp.version) {
+                            case WriteFormat.v0_0_2: {
+                                const edit = this.parseSequencedEdit(sharedTreeOp);
+                                this.applyEditLocally(edit, undefined);
+                                break;
+                            }
+                            case WriteFormat.v0_1_1:
+                                // TODO:#74390: Implement
+                                fail('Received stashed op 0.1.1 before upgrade');
+                            default:
+                                fail('Unknown version');
+                        }
+                        break;
+                    case WriteFormat.v0_1_1:
+                        switch (sharedTreeOp.version) {
+                            case WriteFormat.v0_0_2:
+                                // TODO:#74390: Implement
+                                fail('v0.1.1 does not support stashed ops.');
+                            case WriteFormat.v0_1_1:
+                                // TODO:#74390: Implement
+                                fail('v0.1.1 does not support stashed ops.');
+                            default:
+                                fail('Unknown version');
+                        }
+                    default:
+                        fail('Unknown version');
+                }
+                break;
+            }
+            // Handle and update ops are only acknowledged by the client that generated them upon sequencing--no local changes necessary.
+            case SharedTreeOpType.Handle:
+            case SharedTreeOpType.Update:
+            case SharedTreeOpType.NoOp:
+                break;
+            default:
+                fail('Unrecognized op');
+        }
+    }
+    changeWriteFormat(newFormat) {
+        this.writeFormat = newFormat;
+        this.emit(SharedTreeDiagnosticEvent.WriteVersionChanged, newFormat);
+    }
+    /**
+     * Interns all Definitions and TraitLabel_s referenced by the provided edit.
+     *
+     * Clients must have consensus on the interned values to guarantee the interned ID is valid.
+     */
+    internStringsFromEdit(edit) {
+        for (const change of edit.changes) {
+            if (change.type === ChangeTypeInternal.Build) {
+                for (const root of change.source) {
+                    walkTree(root, (node) => {
+                        this.interner.getOrCreateInternedId(node.definition);
+                        for (const trait of Object.keys(node.traits)) {
+                            this.interner.getOrCreateInternedId(trait);
+                        }
+                    }, isDetachedSequenceId);
+                }
+            }
+            else if (change.type === ChangeTypeInternal.Insert) {
+                const { referenceTrait } = change.destination;
+                if (referenceTrait !== undefined) {
+                    this.interner.getOrCreateInternedId(referenceTrait.label);
+                }
+            }
+        }
+    }
+}
+/**
+ * @returns 1 if versionA is newer, -1 if versionB is newer, and 0 if the versions are the same.
+ * @throws if either version isn't a valid WriteFormat version.
+ */
+function compareSummaryFormatVersions(versionA, versionB) {
+    const versionAIndex = sortedWriteVersions.indexOf(versionA);
+    const versionBIndex = sortedWriteVersions.indexOf(versionB);
+    if (versionAIndex === -1 || versionBIndex === -1) {
+        fail('Summary version being compared cannot be read.');
+    }
+    if (versionAIndex < versionBIndex) {
+        return -1;
+    }
+    else if (versionAIndex > versionBIndex) {
+        return 1;
+    }
+    return 0;
+}
+/**
+ * Checks if the summary version needs to be updated.
+ * @returns true if the old version is older than the new version.
+ * @throws if the new version isn't a supported WriteFormat version.
+ */
+function isUpdateRequired(oldVersion, newVersion) {
+    const newVersionIndex = sortedWriteVersions.indexOf(newVersion);
+    if (newVersionIndex === -1) {
+        fail('New write version is invalid.');
+    }
+    return compareSummaryFormatVersions(oldVersion, newVersion) === -1 ? true : false;
+}
+function isTreeNodeSequence(source) {
+    return Array.isArray(source);
+}
+//# sourceMappingURL=SharedTree.js.map