@fluidframework/tree 2.118.0 → 3.0.0

package/lib/shared-tree/treeCheckout.js

@@ -2,12 +2,12 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { __classPrivateFieldGet, __classPrivateFieldSet, __esDecorate, __runInitializers } from "tslib";
+import { __esDecorate, __runInitializers } from "tslib";
 import { createEmitter } from "@fluid-internal/client-utils";
 import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
+import { UsageError, tagCodeArtifacts, } from "@fluidframework/telemetry-utils/internal";
 import { FluidClientVersion, FormatValidatorNoOp, } from "../codec/index.js";
-import { CommitKind, CommitOutcome, RevertibleStatus, TreeStoredSchemaRepository, combineVisitors, makeDetachedFieldIndex, rebaseChange, rootFieldKey, tagChange, visitDelta, isAncestor, moveToDetachedField, LeafNodeStoredSchema, diffHistories, makeAnonChange, deltaFieldMapHasVisibleChanges, findCommonAncestor, rebaseBranch, findAncestor, } from "../core/index.js";
+import { CommitKind, CommitOutcome, RevertibleStatus, TreeStoredSchemaRepository, combineVisitors, makeDetachedFieldIndex, rebaseChange, rootFieldKey, tagChange, visitDelta, isAncestor, moveToDetachedField, LeafNodeStoredSchema, diffHistories, makeAnonChange, findCommonAncestor, rebaseBranch, getDeltaChangeProfile, findAncestor, } from "../core/index.js";
 import { allowsRepoSuperset, buildForest, createNodeIdentifierManager, defaultSchemaPolicy, fieldBatchCodecBuilder, TreeStatus, intoDelta, jsonableTreeFromCursor, } from "../feature-libraries/index.js";
 import { SquashingTransactionStack, SharedTreeBranch, TransactionResult as InternalTransactionResult, } from "../shared-tree-core/index.js";
 import { getInnerNode, getKernel, customFromCursorStored, } from "../simple-tree/index.js";
@@ -116,6 +116,7 @@ export function createTreeCheckout(idCompressor, mintRevisionTag, revisionTagCod
             change: changeFamily.rebaser.compose([]),
             revision: "root",
             customMetadata: undefined,
+            wasTrimmed: true,
         }, changeFamily, () => idCompressor.generateCompressedId());
     return new TreeCheckout(branch, true, changeFamily, schema, forest, mintRevisionTag, revisionTagCodec, idCompressor, args?.removedRoots);
 }
@@ -197,7 +198,6 @@ export function assertValidConstraint(constraint, onRevert) {
  * An implementation of {@link ITreeCheckout}.
  */
 let TreeCheckout = (() => {
-    var _a, _TreeCheckout_events, _TreeCheckout_transaction, _TreeCheckout_validatedCommits;
     let _instanceExtraInitializers = [];
     let _exportVerbose_decorators;
     let _applySerializedChange_decorators;
@@ -207,990 +207,1069 @@ let TreeCheckout = (() => {
     let _withCombinedVisitor_decorators;
     let _viewWith_decorators;
     let _fork_decorators;
-    return _a = class TreeCheckout {
-            /**
-             * Logger for telemetry events related to this checkout.
-             * @remarks
-             * This logger is provided by the {@link Breakable} passed to the constructor, and may be `undefined` if no logger was provided.
-             * See the explanation on {@link Breakable.logger} for why this pattern makes sense.
-             */
-            get logger() {
-                return this.breaker.logger;
+    return class TreeCheckout {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(this, null, _exportVerbose_decorators, { kind: "method", name: "exportVerbose", static: false, private: false, access: { has: obj => "exportVerbose" in obj, get: obj => obj.exportVerbose }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _applySerializedChange_decorators, { kind: "method", name: "applySerializedChange", static: false, private: false, access: { has: obj => "applySerializedChange" in obj, get: obj => obj.applySerializedChange }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _applyChange_decorators, { kind: "method", name: "applyChange", static: false, private: false, access: { has: obj => "applyChange" in obj, get: obj => obj.applyChange }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _runTransaction_decorators, { kind: "method", name: "runTransaction", static: false, private: false, access: { has: obj => "runTransaction" in obj, get: obj => obj.runTransaction }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _runTransactionAsync_decorators, { kind: "method", name: "runTransactionAsync", static: false, private: false, access: { has: obj => "runTransactionAsync" in obj, get: obj => obj.runTransactionAsync }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _withCombinedVisitor_decorators, { kind: "method", name: "withCombinedVisitor", static: false, private: false, access: { has: obj => "withCombinedVisitor" in obj, get: obj => obj.withCombinedVisitor }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _viewWith_decorators, { kind: "method", name: "viewWith", static: false, private: false, access: { has: obj => "viewWith" in obj, get: obj => obj.viewWith }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _fork_decorators, { kind: "method", name: "fork", static: false, private: false, access: { has: obj => "fork" in obj, get: obj => obj.fork }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        branch = __runInitializers(this, _instanceExtraInitializers);
+        isSharedBranch;
+        changeFamily;
+        storedSchema;
+        forest;
+        mintRevisionTag;
+        revisionTagCodec;
+        idCompressor;
+        _removedRoots;
+        disposeForksAfterTransaction;
+        disposed = false;
+        /**
+         * Logger for telemetry events related to this checkout.
+         * @remarks
+         * This logger is provided by the {@link Breakable} passed to the constructor, and may be `undefined` if no logger was provided.
+         * See the explanation on {@link Breakable.logger} for why this pattern makes sense.
+         */
+        get logger() {
+            return this.breaker.logger;
+        }
+        /**
+         * The breaker for this checkout.
+         * @remarks
+         * As the forest is part of the mutable state of the checkout,
+         * we want to be broken if it is broken, so we use the forest's breaker as our own.
+         *
+         * This does mean that if something goes wrong in the checkout, we break the forest,
+         * which is not strictly necessary, but may be desirable as if something is wrong with the checkout,
+         * while the forest might be internally consistent, it likely doesn't contain the correct content
+         * (since the checkout is keeping it up to date properly anymore).
+         */
+        get breaker() {
+            return this.forest.breaker;
+        }
+        editLock;
+        /**
+         * Root of the mutable label tree tracking transaction nesting.
+         *
+         * @remarks
+         * The label tree is always isomorphic to the actual transaction tree — every transaction
+         * (whether labeled or not) gets its own node. To find the "current" (deepest open) node,
+         * walk down the right side of the tree, stopping at {@link TreeCheckout.mostRecentlyClosedLabelNode}.
+         *
+         * Cleared by {@link TreeCheckout.runWithTransactionLabel} after the commit event is emitted.
+         */
+        labelTreeNode;
+        /**
+         * Points to the most recently closed (committed) label node.
+         * Used by {@link TreeCheckout.currentLabelNode} to stop descending past committed nodes.
+         */
+        mostRecentlyClosedLabelNode;
+        views = new Set();
+        /**
+         * Event emitters for local commits.
+         */
+        localCommitEventEmitters = new Map();
+        /**
+         * Revertibles maintained for automatic disposal
+         */
+        revertibles = new Map();
+        /**
+         * Each branch's head commit corresponds to a revertible commit.
+         * Maintaining a whole branch ensures the commit graph is not pruned in a way that would prevent the commit from
+         * being reverted.
+         */
+        revertibleCommitBranches = new Map();
+        /**
+         * The name of the telemetry event logged for calls to {@link TreeCheckout.revertRevertible}.
+         * @privateRemarks Exposed for testing purposes.
+         */
+        static revertTelemetryEventName = "RevertRevertible";
+        /**
+         * The name of the telemetry event logged when a schema change is applied.
+         * @privateRemarks Exposed for testing purposes.
+         */
+        static schemaChangeTelemetryEventName = "SchemaChangeApplied";
+        #events = createEmitter();
+        events = this.#events;
+        _branchHistory;
+        constructor(branch, 
+        /** True if and only if this checkout is for a branch which is persisted and shared with other clients. */
+        isSharedBranch, changeFamily, storedSchema, forest, mintRevisionTag, revisionTagCodec, idCompressor, _removedRoots = makeDetachedFieldIndex("repair"), disposeForksAfterTransaction = true) {
+            this.branch = branch;
+            this.isSharedBranch = isSharedBranch;
+            this.changeFamily = changeFamily;
+            this.storedSchema = storedSchema;
+            this.forest = forest;
+            this.mintRevisionTag = mintRevisionTag;
+            this.revisionTagCodec = revisionTagCodec;
+            this.idCompressor = idCompressor;
+            this._removedRoots = _removedRoots;
+            this.disposeForksAfterTransaction = disposeForksAfterTransaction;
+            this.#transaction = this.createTransactionStack(branch);
+            this.editLock = new EditLock(this.#transaction.activeBranchEditor);
+            this.registerForBranchEvents();
+        }
+        get branchHistory() {
+            this._branchHistory ??= new DefaultTreeBranchHistory(this.branch, this.idCompressor);
+            return this._branchHistory;
+        }
+        /**
+         * Pushes a new label node for a transaction nesting level.
+         *
+         * @param label - The label for this transaction level.
+         *
+         * @remarks
+         * Called at the start of each transaction (including nested ones).
+         * Creates a new {@link LabelTree} node as a child of the current deepest node (if any),
+         * or as the root if this is the outermost transaction.
+         */
+        pushLabelFrame(label) {
+            const node = { label, sublabels: [] };
+            if (this.labelTreeNode === undefined) {
+                this.labelTreeNode = node;
             }
-            /**
-             * The breaker for this checkout.
-             * @remarks
-             * As the forest is part of the mutable state of the checkout,
-             * we want to be broken if it is broken, so we use the forest's breaker as our own.
-             *
-             * This does mean that if something goes wrong in the checkout, we break the forest,
-             * which is not strictly necessary, but may be desirable as if something is wrong with the checkout,
-             * while the forest might be internally consistent, it likely doesn't contain the correct content
-             * (since the checkout is keeping it up to date properly anymore).
-             */
-            get breaker() {
-                return this.forest.breaker;
+            else {
+                const current = this.currentLabelNode();
+                assert(current !== undefined, 0xcdb /* Expected current label node to exist */);
+                current.sublabels.push(node);
             }
-            constructor(branch, 
-            /** True if and only if this checkout is for a branch which is persisted and shared with other clients. */
-            isSharedBranch, changeFamily, storedSchema, forest, mintRevisionTag, revisionTagCodec, idCompressor, _removedRoots = makeDetachedFieldIndex("repair"), disposeForksAfterTransaction = true) {
-                this.branch = (__runInitializers(this, _instanceExtraInitializers), branch);
-                this.isSharedBranch = isSharedBranch;
-                this.changeFamily = changeFamily;
-                this.storedSchema = storedSchema;
-                this.forest = forest;
-                this.mintRevisionTag = mintRevisionTag;
-                this.revisionTagCodec = revisionTagCodec;
-                this.idCompressor = idCompressor;
-                this._removedRoots = _removedRoots;
-                this.disposeForksAfterTransaction = disposeForksAfterTransaction;
-                this.disposed = false;
-                this.views = new Set();
-                /**
-                 * Event emitters for local commits.
-                 */
-                this.localCommitEventEmitters = new Map();
-                /**
-                 * Revertibles maintained for automatic disposal
-                 */
-                this.revertibles = new Map();
-                /**
-                 * Each branch's head commit corresponds to a revertible commit.
-                 * Maintaining a whole branch ensures the commit graph is not pruned in a way that would prevent the commit from
-                 * being reverted.
-                 */
-                this.revertibleCommitBranches = new Map();
-                _TreeCheckout_events.set(this, createEmitter());
-                this.events = __classPrivateFieldGet(this, _TreeCheckout_events, "f");
-                this.onCommitSequenced = (commit) => {
-                    const emitter = this.localCommitEventEmitters.get(commit.revision);
-                    if (emitter === undefined) {
-                        // If the commit predates the creation of this checkout, there will be no emitter associated with the commit.
-                        // In that case, we don't need to emit any events.
-                        return;
-                    }
-                    const constraintStatus = getConstraintStatus(commit.change);
-                    let outcome;
-                    switch (constraintStatus) {
-                        case ConstraintStatus.Satisfied: {
-                            outcome = CommitOutcome.FullyApplied;
-                            break;
-                        }
-                        case ConstraintStatus.ImplicitViolation: {
-                            outcome = CommitOutcome.FullyDropped;
+        }
+        /**
+         * Returns the deepest open node on the right side of the label tree, which corresponds
+         * to the current (most recently pushed, not yet committed or aborted) transaction.
+         * Returns `undefined` when {@link TreeCheckout.labelTreeNode} is not set.
+         */
+        currentLabelNode() {
+            if (this.labelTreeNode === undefined) {
+                return undefined;
+            }
+            // Walk down the right spine of the tree. Only one closed node is ever reachable
+            // during this traversal, so a single pointer (mostRecentlyClosedLabelNode) suffices
+            // to stop descending past committed nodes.
+            let node = this.labelTreeNode;
+            while (node.sublabels.length > 0) {
+                const lastChild = node.sublabels[node.sublabels.length - 1];
+                assert(lastChild !== undefined, 0xcdc /* Expected label tree node to have children */);
+                if (lastChild === this.mostRecentlyClosedLabelNode) {
+                    break;
+                }
+                node = lastChild;
+            }
+            return node;
+        }
+        /**
+         * Pops the current label frame from the label tree.
+         * @param aborted - If true, the node is removed from the tree (transaction was aborted).
+         * If false, the node is kept in the tree but marked as closed (transaction was committed).
+         */
+        popLabelFrame(aborted) {
+            const node = this.currentLabelNode();
+            if (node === undefined) {
+                return;
+            }
+            if (aborted) {
+                if (node === this.labelTreeNode) {
+                    this.labelTreeNode = undefined;
+                    this.mostRecentlyClosedLabelNode = undefined;
+                }
+                else {
+                    // Temporarily mark node as closed so currentLabelNode() returns its parent.
+                    this.mostRecentlyClosedLabelNode = node;
+                    const parent = this.currentLabelNode();
+                    assert(parent !== undefined, 0xcdd /* Expected parent label node to exist */);
+                    parent.sublabels.pop();
+                    // Point to the parent's new last child (guaranteed closed if it exists),
+                    // or undefined if the parent has no more children.
+                    const newLastChild = parent.sublabels[parent.sublabels.length - 1];
+                    this.mostRecentlyClosedLabelNode = newLastChild;
+                }
+            }
+            else {
+                this.mostRecentlyClosedLabelNode = node;
+            }
+        }
+        /**
+         * Helper method for {@link SchematizingSimpleTreeView.runTransaction} to properly clear transaction labels once the function completes.
+         *
+         * @remarks
+         * The label is stored during the execution of the function and will be included in the {@link ChangeMetadata} of the transaction.
+         *
+         * Labels supplied to nested transactions are ignored - only the outermost transaction label is ever used.
+         *
+         * @param fn - The function to execute. It receives the user provided transaction label as an optional parameter.
+         * @param label - The label to associate with the outermost transaction.
+         * @returns The result of executing `fn`.
+         */
+        runWithTransactionLabel(fn, label) {
+            try {
+                return fn(label);
+            }
+            finally {
+                // Only clear the label tree when the outermost transaction has completed.
+                // Inner transactions' commits don't fire the "changed" event, so the label tree
+                // must remain intact until the outermost commit reads it.
+                if (this.transaction.size === 0) {
+                    this.labelTreeNode = undefined;
+                    this.mostRecentlyClosedLabelNode = undefined;
+                }
+            }
+        }
+        get removedRoots() {
+            return this._removedRoots;
+        }
+        registerForBranchEvents() {
+            this.#transaction.branch.events.on("afterChange", this.onAfterBranchChange);
+            this.#transaction.branch.events.on("commitSequenced", this.onCommitSequenced);
+            this.#transaction.activeBranchEvents.on("afterChange", this.onAfterChange);
+            this.#transaction.activeBranchEvents.on("ancestryTrimmed", this.onAncestryTrimmed);
+        }
+        unregisterFromBranchEvents() {
+            this.#transaction.branch.events.off("afterChange", this.onAfterBranchChange);
+            this.#transaction.branch.events.off("commitSequenced", this.onCommitSequenced);
+            this.#transaction.activeBranchEvents.off("afterChange", this.onAfterChange);
+            this.#transaction.activeBranchEvents.off("ancestryTrimmed", this.onAncestryTrimmed);
+        }
+        createTransactionStack(branch) {
+            return new SquashingTransactionStack(branch, this.mintRevisionTag, () => {
+                // When each transaction is started, make a restorable checkpoint of the current state of removed roots
+                const restoreRemovedRoots = this._removedRoots.createCheckpoint();
+                return (result, viewUpdate) => {
+                    const newHead = this.#transaction.branch.getHead();
+                    switch (result) {
+                        case InternalTransactionResult.Abort: {
+                            restoreRemovedRoots();
+                            if (viewUpdate !== undefined) {
+                                this.applyInternalChange(viewUpdate, newHead.revision);
+                            }
                             break;
                         }
-                        case ConstraintStatus.ExplicitViolation: {
-                            outcome = CommitOutcome.NewContentOnly;
+                        case InternalTransactionResult.Commit: {
+                            if (viewUpdate !== undefined) {
+                                this.applyInternalChange(viewUpdate, newHead.revision);
+                            }
+                            if (this.transaction.size === 0) {
+                                // The changes in a transaction squash commit have already applied to the checkout and are known to be valid, so we can validate the squash commit automatically.
+                                this.validateCommit(newHead);
+                            }
                             break;
                         }
                         default: {
-                            unreachableCase(constraintStatus);
+                            unreachableCase(result);
                         }
                     }
-                    this.emitChangedLocked(() => {
-                        emitter.emit("settled", outcome);
-                    }, "a commit settled event callback");
-                    // No more events will be emitted for this commit, so we can remove the emitter from the map.
-                    this.localCommitEventEmitters.delete(commit.revision);
                 };
-                this.onAfterBranchChange = (event) => {
-                    // The following logic allows revertibles to be generated for the change.
-                    // Currently only appends (including merges and transaction commits) are supported.
-                    if (event.type === "append") {
-                        // TODO:#20949: When the SharedTree is detached, these commits will already have been garbage collected.
-                        //       Figure out a way to generate revertibles before the commits are garbage collected.
-                        for (const commit of event.newCommits) {
-                            const kind = event.type === "append" ? event.kind : CommitKind.Default;
-                            const { change, revision } = commit;
-                            // Snapshot the label tree for this commit before any listener runs, so the captured
-                            // value is stable against mutations to `metadata.labels.tree` (which aliases the
-                            // live `labelTreeNode`).
-                            const commitLabelTree = this.labelTreeNode === undefined ? undefined : cloneLabelTree(this.labelTreeNode);
-                            const getRevertible = hasSchemaChange(change)
-                                ? undefined
-                                : (onRevertibleDisposed) => {
-                                    if (!withinEventContext) {
-                                        throw new UsageError("Cannot get a revertible outside of the context of a changed event.");
-                                    }
-                                    if (this.revertibleCommitBranches.get(revision) !== undefined) {
-                                        throw new UsageError("Cannot generate the same revertible more than once. Note that this can happen when multiple changed event listeners are registered.");
-                                    }
-                                    const revertible = this.createRevertible(revision, kind, this, onRevertibleDisposed, commitLabelTree);
-                                    this.revertibleCommitBranches.set(revision, __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.fork(commit));
-                                    this.revertibles.set(revision, revertible);
-                                    return revertible;
-                                };
-                            let withinEventContext = true;
-                            const events = createEmitter();
-                            this.localCommitEventEmitters.set(commit.revision, events);
-                            const metadata = {
-                                kind,
-                                isLocal: true,
-                                getChange: () => {
-                                    assert(commit.parent !== undefined, 0xca4 /* Expected applied commit to be parented */);
-                                    return SerializedChange.V1.encode(this.idCompressor, this.changeFamily, change, revision);
-                                },
-                                getRevertible: (onDisposed) => getRevertible?.(onDisposed),
-                                label: this.labelTreeNode?.label,
-                                labels: buildLabelsSet(this.labelTreeNode),
-                                events,
-                            };
-                            this.emitChangedLocked(() => {
-                                __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", metadata, getRevertible);
-                            });
-                            withinEventContext = false;
-                        }
-                    }
-                    else if (event.type === "remove") {
-                        // Commits that are rolled back should no longer be revertible
-                        for (const commit of event.removedCommits) {
-                            this.revertibles.get(commit.revision)?.dispose();
-                        }
-                    }
-                    else if (this.isRemoteChangeEvent(event)) {
-                        // TODO: figure out how to plumb through commit kind info for remote changes
-                        this.emitChangedLocked(() => {
-                            __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("changed", {
-                                isLocal: false,
-                                kind: CommitKind.Default,
-                                labels: new Set(),
-                            });
-                        });
-                    }
-                };
-                this.onAfterChange = (event) => {
-                    this.editLock.lock("a change event callback");
-                    __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("beforeBatch", event);
-                    if (event.change !== undefined) {
-                        const revision = event.type === "rebase"
-                            ? __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.getHead().revision
-                            : event.change.revision;
-                        this.applyInternalChange(event.change.change, revision);
-                    }
-                    __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("afterBatch");
-                    this.editLock.unlock();
-                    if (event.type === "append") {
-                        for (const commit of event.newCommits) {
-                            this.validateCommit(commit);
-                        }
-                    }
-                };
-                this.onAncestryTrimmed = (revisions) => {
-                    // When the branch is trimmed, we can garbage collect any repair data whose latest relevant revision is one of the
-                    // trimmed revisions.
-                    this.withCombinedVisitor((visitor) => {
-                        for (const revision of revisions) {
-                            // get all the roots last created or used by the revision
-                            const roots = this._removedRoots.getRootsLastTouchedByRevision(revision);
-                            // get the detached field for the root and delete it from the removed roots
-                            for (const root of roots) {
-                                visitor.destroy(this._removedRoots.toFieldKey(root), 1);
-                            }
-                            this._removedRoots.deleteRootsLastTouchedByRevision(revision);
-                        }
-                    });
-                };
-                /**
-                 * The {@link Transactor} for this checkout.
-                 * @remarks In the context of a checkout, transactions allow edits to be batched into atomic units.
-                 * Edits made during a transaction will update the local state of the tree immediately, but will be squashed into a single edit when the transaction is committed.
-                 * If the transaction is aborted, the local state will be reset to what it was before the transaction began.
-                 * Transactions may nest, meaning that a transaction may be started while a transaction is already ongoing.
-                 *
-                 * To avoid updating observers of the view state with intermediate results during a transaction,
-                 * use {@link ITreeCheckout#fork} and {@link ISharedTreeFork#merge}.
-                 */
-                _TreeCheckout_transaction.set(this, void 0);
-                // #region Commit Validation
-                /** Used to maintain the contract of {@link onCommitValid}(). */
-                _TreeCheckout_validatedCommits.set(this, new WeakMap());
-                // #endregion Commit Validation
-                // #region Enrichment
-                /**
-                 * Statistics about enrichment operations performed by this checkout.
-                 * Used for testing. May be used for telemetry in the future.
-                 * The performance cost of maintaining this information is negligible.
-                 */
-                this.enrichmentStats = { batches: 0, diffs: 0, commitsEnriched: 0, refreshers: 0, forks: 0, applied: 0 };
-                __classPrivateFieldSet(this, _TreeCheckout_transaction, this.createTransactionStack(branch), "f");
-                this.editLock = new EditLock(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEditor);
-                this.registerForBranchEvents();
-            }
-            get branchHistory() {
-                this._branchHistory ??= new DefaultTreeBranchHistory(this.branch, this.idCompressor);
-                return this._branchHistory;
-            }
-            /**
-             * Pushes a new label node for a transaction nesting level.
-             *
-             * @param label - The label for this transaction level.
-             *
-             * @remarks
-             * Called at the start of each transaction (including nested ones).
-             * Creates a new {@link LabelTree} node as a child of the current deepest node (if any),
-             * or as the root if this is the outermost transaction.
-             */
-            pushLabelFrame(label) {
-                const node = { label, sublabels: [] };
-                if (this.labelTreeNode === undefined) {
-                    this.labelTreeNode = node;
+            });
+        }
+        exportVerbose() {
+            const cursor = this.forest.allocateCursor("contentSnapshot");
+            try {
+                moveToDetachedField(this.forest, cursor);
+                const length = cursor.getFieldLength();
+                if (length === 0) {
+                    return undefined;
+                }
+                else if (length === 1) {
+                    cursor.enterNode(0);
+                    return verboseFromCursor(cursor, this.storedSchema.nodeSchema);
                 }
                 else {
-                    const current = this.currentLabelNode();
-                    assert(current !== undefined, 0xcdb /* Expected current label node to exist */);
-                    current.sublabels.push(node);
+                    fail(0xac8 /* Invalid document root length */);
                 }
             }
-            /**
-             * Returns the deepest open node on the right side of the label tree, which corresponds
-             * to the current (most recently pushed, not yet committed or aborted) transaction.
-             * Returns `undefined` when {@link TreeCheckout.labelTreeNode} is not set.
-             */
-            currentLabelNode() {
-                if (this.labelTreeNode === undefined) {
-                    return undefined;
-                }
-                // Walk down the right spine of the tree. Only one closed node is ever reachable
-                // during this traversal, so a single pointer (mostRecentlyClosedLabelNode) suffices
-                // to stop descending past committed nodes.
-                let node = this.labelTreeNode;
-                while (node.sublabels.length > 0) {
-                    const lastChild = node.sublabels[node.sublabels.length - 1];
-                    assert(lastChild !== undefined, 0xcdc /* Expected label tree node to have children */);
-                    if (lastChild === this.mostRecentlyClosedLabelNode) {
-                        break;
-                    }
-                    node = lastChild;
-                }
-                return node;
+            finally {
+                cursor.free();
             }
-            /**
-             * Pops the current label frame from the label tree.
-             * @param aborted - If true, the node is removed from the tree (transaction was aborted).
-             * If false, the node is kept in the tree but marked as closed (transaction was committed).
-             */
-            popLabelFrame(aborted) {
-                const node = this.currentLabelNode();
-                if (node === undefined) {
-                    return;
-                }
-                if (aborted) {
-                    if (node === this.labelTreeNode) {
-                        this.labelTreeNode = undefined;
-                        this.mostRecentlyClosedLabelNode = undefined;
-                    }
-                    else {
-                        // Temporarily mark node as closed so currentLabelNode() returns its parent.
-                        this.mostRecentlyClosedLabelNode = node;
-                        const parent = this.currentLabelNode();
-                        assert(parent !== undefined, 0xcdd /* Expected parent label node to exist */);
-                        parent.sublabels.pop();
-                        // Point to the parent's new last child (guaranteed closed if it exists),
-                        // or undefined if the parent has no more children.
-                        const newLastChild = parent.sublabels[parent.sublabels.length - 1];
-                        this.mostRecentlyClosedLabelNode = newLastChild;
-                    }
+        }
+        onCommitSequenced = (commit) => {
+            const emitter = this.localCommitEventEmitters.get(commit.revision);
+            if (emitter === undefined) {
+                // If the commit predates the creation of this checkout, there will be no emitter associated with the commit.
+                // In that case, we don't need to emit any events.
+                return;
+            }
+            const constraintStatus = getConstraintStatus(commit.change);
+            let outcome;
+            switch (constraintStatus) {
+                case ConstraintStatus.Satisfied: {
+                    outcome = CommitOutcome.FullyApplied;
+                    break;
                 }
-                else {
-                    this.mostRecentlyClosedLabelNode = node;
+                case ConstraintStatus.ImplicitViolation: {
+                    outcome = CommitOutcome.FullyDropped;
+                    break;
                 }
-            }
-            /**
-             * Helper method for {@link SchematizingSimpleTreeView.runTransaction} to properly clear transaction labels once the function completes.
-             *
-             * @remarks
-             * The label is stored during the execution of the function and will be included in the {@link ChangeMetadata} of the transaction.
-             *
-             * Labels supplied to nested transactions are ignored - only the outermost transaction label is ever used.
-             *
-             * @param fn - The function to execute. It receives the user provided transaction label as an optional parameter.
-             * @param label - The label to associate with the outermost transaction.
-             * @returns The result of executing `fn`.
-             */
-            runWithTransactionLabel(fn, label) {
-                try {
-                    return fn(label);
+                case ConstraintStatus.ExplicitViolation: {
+                    outcome = CommitOutcome.NewContentOnly;
+                    break;
                 }
-                finally {
-                    // Only clear the label tree when the outermost transaction has completed.
-                    // Inner transactions' commits don't fire the "changed" event, so the label tree
-                    // must remain intact until the outermost commit reads it.
-                    if (this.transaction.size === 0) {
-                        this.labelTreeNode = undefined;
-                        this.mostRecentlyClosedLabelNode = undefined;
-                    }
+                default: {
+                    unreachableCase(constraintStatus);
                 }
             }
-            get removedRoots() {
-                return this._removedRoots;
-            }
-            registerForBranchEvents() {
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.events.on("afterChange", this.onAfterBranchChange);
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.events.on("commitSequenced", this.onCommitSequenced);
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.on("afterChange", this.onAfterChange);
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.on("ancestryTrimmed", this.onAncestryTrimmed);
-            }
-            unregisterFromBranchEvents() {
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.events.off("afterChange", this.onAfterBranchChange);
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.events.off("commitSequenced", this.onCommitSequenced);
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.off("afterChange", this.onAfterChange);
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEvents.off("ancestryTrimmed", this.onAncestryTrimmed);
-            }
-            createTransactionStack(branch) {
-                return new SquashingTransactionStack(branch, this.mintRevisionTag, () => {
-                    // When each transaction is started, make a restorable checkpoint of the current state of removed roots
-                    const restoreRemovedRoots = this._removedRoots.createCheckpoint();
-                    return (result, viewUpdate) => {
-                        const newHead = __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.getHead();
-                        switch (result) {
-                            case InternalTransactionResult.Abort: {
-                                restoreRemovedRoots();
-                                if (viewUpdate !== undefined) {
-                                    this.applyInternalChange(viewUpdate, newHead.revision);
-                                }
-                                break;
-                            }
-                            case InternalTransactionResult.Commit: {
-                                if (viewUpdate !== undefined) {
-                                    this.applyInternalChange(viewUpdate, newHead.revision);
-                                }
-                                if (this.transaction.size === 0) {
-                                    // The changes in a transaction squash commit have already applied to the checkout and are known to be valid, so we can validate the squash commit automatically.
-                                    this.validateCommit(newHead);
-                                }
-                                break;
+            this.emitChangedLocked(() => {
+                emitter.emit("settled", outcome);
+            }, "a commit settled event callback");
+            // No more events will be emitted for this commit, so we can remove the emitter from the map.
+            this.localCommitEventEmitters.delete(commit.revision);
+        };
+        onAfterBranchChange = (event) => {
+            // The following logic allows revertibles to be generated for the change.
+            // Currently only appends (including merges and transaction commits) are supported.
+            if (event.type === "append") {
+                // TODO:#20949: When the SharedTree is detached, these commits will already have been garbage collected.
+                //       Figure out a way to generate revertibles before the commits are garbage collected.
+                for (const commit of event.newCommits) {
+                    const kind = event.type === "append" ? event.kind : CommitKind.Default;
+                    const { change, revision } = commit;
+                    // Snapshot the label tree for this commit before any listener runs, so the captured
+                    // value is stable against mutations to `metadata.labels.tree` (which aliases the
+                    // live `labelTreeNode`).
+                    const commitLabelTree = this.labelTreeNode === undefined ? undefined : cloneLabelTree(this.labelTreeNode);
+                    const getRevertible = hasSchemaChange(change)
+                        ? undefined
+                        : (onRevertibleDisposed) => {
+                            if (!withinEventContext) {
+                                throw new UsageError("Cannot get a revertible outside of the context of a changed event.");
                             }
-                            default: {
-                                unreachableCase(result);
+                            if (this.revertibleCommitBranches.get(revision) !== undefined) {
+                                throw new UsageError("Cannot generate the same revertible more than once. Note that this can happen when multiple changed event listeners are registered.");
                             }
-                        }
+                            const revertible = this.createRevertible(revision, kind, this, onRevertibleDisposed, commitLabelTree);
+                            this.revertibleCommitBranches.set(revision, this.#transaction.branch.fork(commit));
+                            this.revertibles.set(revision, revertible);
+                            return revertible;
+                        };
+                    let withinEventContext = true;
+                    const events = createEmitter();
+                    this.localCommitEventEmitters.set(commit.revision, events);
+                    const metadata = {
+                        kind,
+                        isLocal: true,
+                        getChange: () => {
+                            assert(commit.parent !== undefined, 0xca4 /* Expected applied commit to be parented */);
+                            return SerializedChange.V1.encode(this.idCompressor, this.changeFamily, change, revision);
+                        },
+                        getRevertible: (onDisposed) => getRevertible?.(onDisposed),
+                        label: this.labelTreeNode?.label,
+                        labels: buildLabelsSet(this.labelTreeNode),
+                        events,
                     };
-                });
-            }
-            exportVerbose() {
-                const cursor = this.forest.allocateCursor("contentSnapshot");
-                try {
-                    moveToDetachedField(this.forest, cursor);
-                    const length = cursor.getFieldLength();
-                    if (length === 0) {
-                        return undefined;
-                    }
-                    else if (length === 1) {
-                        cursor.enterNode(0);
-                        return verboseFromCursor(cursor, this.storedSchema.nodeSchema);
-                    }
-                    else {
-                        fail(0xac8 /* Invalid document root length */);
-                    }
-                }
-                finally {
-                    cursor.free();
+                    this.emitChangedLocked(() => {
+                        this.#events.emit("changed", metadata, getRevertible);
+                    });
+                    withinEventContext = false;
                 }
             }
-            /**
-             * Hold the `editLock` for the duration of `emit`, so that re-entrant edits, transactions,
-             * branch operations, etc. attempted from inside a `changed` listener throw the canonical
-             * "forbidden during a change event" {@link UsageError} via {@link EditLock.checkUnlocked}.
-             *
-             * @remarks
-             * Shared by both the local and remote `changed` emission paths in {@link TreeCheckout.onAfterBranchChange}.
-             * The `try`/`finally` ensures the lock is released even if a listener throws.
-             */
-            emitChangedLocked(emit, reason = "a change event callback") {
-                this.editLock.lock(reason);
-                try {
-                    emit();
-                }
-                finally {
-                    // TODO: any event that throws potentially leaves the code which triggered that event,
-                    // and thus this checkout (and likely more) in a broken state.
-                    // Unlocking this editLock prevents future use of this broken state from giving a confusing error in this case,
-                    // however, a better approach would probably be to put something (this checkout and/or the editLock)
-                    // into a broken state (using a properly scoped `Breakable`),
-                    // likely by moving emitChangedLocked into EditLock, and having EditLock get a Breakable,
-                    // and having the new emitChangedLocked use `Breakable.use`.
-                    this.editLock.unlock();
+            else if (event.type === "remove") {
+                // Commits that are rolled back should no longer be revertible
+                for (const commit of event.removedCommits) {
+                    this.revertibles.get(commit.revision)?.dispose();
                 }
             }
-            /**
-             * Applies the given serialized change (as was produced via a `"changed"` event of another checkout) to this checkout.
-             */
-            applySerializedChange(serializedChange) {
-                const change = SerializedChange.V1.decode(this.idCompressor, this.changeFamily, serializedChange);
-                // Apply the change to the branch, but _not_ the `activeBranch` - we do not support squashing serialized commits in a transaction.
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.apply(change, CommitKind.Default, undefined);
+            else if (this.isRemoteChangeEvent(event)) {
+                // TODO: figure out how to plumb through commit kind info for remote changes
+                this.emitChangedLocked(() => {
+                    this.#events.emit("changed", {
+                        isLocal: false,
+                        kind: CommitKind.Default,
+                        labels: new Set(),
+                    });
+                });
             }
-            // #region UntypedTreeViewAlpha
-            applyChange(change) {
-                this.applySerializedChange(change);
+        };
+        /**
+         * Hold the `editLock` for the duration of `emit`, so that re-entrant edits, transactions,
+         * branch operations, etc. attempted from inside a `changed` listener throw the canonical
+         * "forbidden during a change event" {@link UsageError} via {@link EditLock.checkUnlocked}.
+         *
+         * @remarks
+         * Shared by both the local and remote `changed` emission paths in {@link TreeCheckout.onAfterBranchChange}.
+         * The `try`/`finally` ensures the lock is released even if a listener throws.
+         */
+        emitChangedLocked(emit, reason = "a change event callback") {
+            this.editLock.lock(reason);
+            try {
+                emit();
             }
-            isBranch() {
-                return this.isView();
+            finally {
+                // TODO: any event that throws potentially leaves the code which triggered that event,
+                // and thus this checkout (and likely more) in a broken state.
+                // Unlocking this editLock prevents future use of this broken state from giving a confusing error in this case,
+                // however, a better approach would probably be to put something (this checkout and/or the editLock)
+                // into a broken state (using a properly scoped `Breakable`),
+                // likely by moving emitChangedLocked into EditLock, and having EditLock get a Breakable,
+                // and having the new emitChangedLocked use `Breakable.use`.
+                this.editLock.unlock();
             }
-            isView() {
-                return true;
+        }
+        onAfterChange = (event) => {
+            this.editLock.lock("a change event callback");
+            this.#events.emit("beforeBatch", event);
+            if (event.change !== undefined) {
+                const revision = event.type === "rebase"
+                    ? this.#transaction.activeBranch.getHead().revision
+                    : event.change.revision;
+                this.applyInternalChange(event.change.change, revision);
             }
-            hasRootSchema(_schema) {
-                return false;
+            this.#events.emit("afterBatch");
+            this.editLock.unlock();
+            if (event.type === "append") {
+                for (const commit of event.newCommits) {
+                    this.validateCommit(commit);
+                }
             }
-            runTransaction(transaction, params) {
-                this.mountTransaction(params, false);
-                const transactionCallbackStatus = transaction();
-                return this.unmountTransaction(transactionCallbackStatus, params);
+        };
+        /**
+         * Applies the given serialized change (as was produced via a `"changed"` event of another checkout) to this checkout.
+         */
+        applySerializedChange(serializedChange) {
+            const change = SerializedChange.V1.decode(this.idCompressor, this.changeFamily, serializedChange);
+            // Apply the change to the branch, but _not_ the `activeBranch` - we do not support squashing serialized commits in a transaction.
+            this.#transaction.branch.apply(change, CommitKind.Default, undefined);
+        }
+        // #region UntypedTreeViewAlpha
+        applyChange(change) {
+            this.applySerializedChange(change);
+        }
+        isBranch() {
+            return this.isView();
+        }
+        isView() {
+            return true;
+        }
+        hasRootSchema(_schema) {
+            return false;
+        }
+        runTransaction(transaction, params) {
+            this.mountTransaction(params, false);
+            const transactionCallbackStatus = transaction();
+            return this.unmountTransaction(transactionCallbackStatus, params);
+        }
+        async runTransactionAsync(transaction, params) {
+            this.mountTransaction(params, true);
+            const transactionCallbackStatus = await transaction();
+            return this.unmountTransaction(transactionCallbackStatus, params);
+        }
+        mountTransaction(params, isAsync) {
+            this.checkNotDisposed();
+            // Starting a transaction is an edit, so it is forbidden from within a change-event
+            // callback (where the edit lock is held), the same as direct edits. For the async
+            // entry point this throw is captured as a rejected promise by the `async` wrapper.
+            //
+            // Note: because runTransaction/runTransactionAsync are `@breakingMethod`, this throw also
+            // puts the checkout into a broken state (unlike a direct edit, which throws recoverably).
+            // That is the same pre-existing broken-state limitation tracked by the TODO in
+            // `emitChangedLocked`, not something specific to transactions.
+            this.editLock.checkUnlocked("Running a transaction");
+            if (isAsync && this.transaction.size > 0) {
+                throw new UsageError("An asynchronous transaction cannot be started while another transaction is already in progress.");
             }
-            async runTransactionAsync(transaction, params) {
-                this.mountTransaction(params, true);
-                const transactionCallbackStatus = await transaction();
-                return this.unmountTransaction(transactionCallbackStatus, params);
+            this.pushLabelFrame(params?.label);
+            this.transaction.start({
+                postProcessor: extractTransactionChangeProcessor(params?.postProcessor),
+                // Like the validation described above, rejecting malformed metadata breaks the checkout rather
+                // than being recoverable. Tracked by https://github.com/microsoft/FluidFramework/issues/28085.
+                customMetadata: snapshotCustomMetadata(params?.customMetadata),
+            });
+            addConstraintsToTransaction(this, false, params?.preconditions);
+        }
+        unmountTransaction(transactionCallbackStatus, params) {
+            this.checkNotDisposed();
+            const rollback = transactionCallbackStatus?.rollback;
+            const value = transactionCallbackStatus?.value;
+            if (rollback === true) {
+                this.popLabelFrame(true);
+                this.transaction.abort();
+                return value === undefined
+                    ? { success: false }
+                    : { success: false, value: value };
             }
-            mountTransaction(params, isAsync) {
-                this.checkNotDisposed();
-                // Starting a transaction is an edit, so it is forbidden from within a change-event
-                // callback (where the edit lock is held), the same as direct edits. For the async
-                // entry point this throw is captured as a rejected promise by the `async` wrapper.
-                //
-                // Note: because runTransaction/runTransactionAsync are `@breakingMethod`, this throw also
-                // puts the checkout into a broken state (unlike a direct edit, which throws recoverably).
-                // That is the same pre-existing broken-state limitation tracked by the TODO in
-                // `emitChangedLocked`, not something specific to transactions.
-                this.editLock.checkUnlocked("Running a transaction");
-                if (isAsync && this.transaction.size > 0) {
-                    throw new UsageError("An asynchronous transaction cannot be started while another transaction is already in progress.");
+            addConstraintsToTransaction(this, true, transactionCallbackStatus?.preconditionsOnRevert);
+            this.popLabelFrame(false);
+            this.runWithTransactionLabel(() => {
+                this.transaction.commit();
+            }, params?.label);
+            return value === undefined
+                ? { success: true }
+                : { success: true, value: value };
+        }
+        // #endregion UntypedTreeViewAlpha
+        // Revision is the revision of the commit, if any, which caused this change.
+        applyInternalChange(change, revision) {
+            // Conflicts due to schema will be empty and thus are not applied.
+            for (const innerChange of change.changes) {
+                if (innerChange.type === "data") {
+                    const delta = intoDelta(tagChange(innerChange.innerChange, revision));
+                    this.withCombinedVisitor((visitor) => {
+                        visitDelta(delta, visitor, this._removedRoots, revision);
+                    });
+                }
+                else if (innerChange.type === "schema") {
+                    // Schema changes from a current to a new schema are expected to be backwards compatible.
+                    // This guarantees that all data in the forest (which is valid before the schema change)
+                    // is also valid under the new schema.
+                    // Note however, that such schema changes may in some cases be rolled back:
+                    // Case 1: A transaction with a schema change may be aborted.
+                    // The transaction may have made some data changes that would render some trees invalid
+                    // under the old schema, but these changes will also be rolled back, thereby putting the forest
+                    // back in the state before the transaction, which is valid under the original (reinstated) schema.
+                    // Case 2: A branch with a schema change may be rebased such that the schema change (because
+                    // of a constraint) is no longer applied.
+                    // Such a branch may contain data changes that would render some trees invalid under the
+                    // original schema. These data changes may not necessarily be rolled back.
+                    // They will however be rebased over the rollback of the schema change. This rebasing will
+                    // ensure that these data changes are muted if they would render some trees invalid under the
+                    // original (reinstated) schema.
+                    const newSchema = innerChange.innerChange.schema.new;
+                    const telemetryMetrics = getSchemaChangeTelemetryMetrics(this.storedSchema, newSchema, innerChange.innerChange.isInverse);
+                    this.storedSchema.apply(newSchema);
+                    this.logger?.sendTelemetryEvent({
+                        eventName: TreeCheckout.schemaChangeTelemetryEventName,
+                        ...tagCodeArtifacts({
+                            details: JSON.stringify({
+                                ...telemetryMetrics,
+                                isSharedBranch: this.isSharedBranch,
+                            }),
+                        }),
+                    });
+                }
+                else {
+                    fail(0xad1 /* Unknown Shared Tree change type. */);
                 }
-                this.pushLabelFrame(params?.label);
-                this.transaction.start({
-                    postProcessor: extractTransactionChangeProcessor(params?.postProcessor),
-                    // Like the validation described above, rejecting malformed metadata breaks the checkout rather
-                    // than being recoverable. Tracked by https://github.com/microsoft/FluidFramework/issues/28085.
-                    customMetadata: snapshotCustomMetadata(params?.customMetadata),
-                });
-                addConstraintsToTransaction(this, false, params?.preconditions);
             }
-            unmountTransaction(transactionCallbackStatus, params) {
-                this.checkNotDisposed();
-                const rollback = transactionCallbackStatus?.rollback;
-                const value = transactionCallbackStatus?.value;
-                if (rollback === true) {
-                    this.popLabelFrame(true);
-                    this.transaction.abort();
-                    return value === undefined
-                        ? { success: false }
-                        : { success: false, value: value };
+        }
+        onAncestryTrimmed = (revisions) => {
+            // When the branch is trimmed, we can garbage collect any repair data whose latest relevant revision is one of the
+            // trimmed revisions.
+            this.withCombinedVisitor((visitor) => {
+                for (const revision of revisions) {
+                    // get all the roots last created or used by the revision
+                    const roots = this._removedRoots.getRootsLastTouchedByRevision(revision);
+                    // get the detached field for the root and delete it from the removed roots
+                    for (const root of roots) {
+                        visitor.destroy(this._removedRoots.toFieldKey(root), 1);
+                    }
+                    this._removedRoots.deleteRootsLastTouchedByRevision(revision);
                 }
-                addConstraintsToTransaction(this, true, transactionCallbackStatus?.preconditionsOnRevert);
-                this.popLabelFrame(false);
-                this.runWithTransactionLabel(() => {
-                    this.transaction.commit();
-                }, params?.label);
-                return value === undefined
-                    ? { success: true }
-                    : { success: true, value: value };
+            });
+        };
+        withCombinedVisitor(fn) {
+            const anchorVisitor = this.forest.anchors.acquireVisitor();
+            const combinedVisitor = combineVisitors([this.forest.acquireVisitor(), anchorVisitor]);
+            fn(combinedVisitor);
+            combinedVisitor.free();
+        }
+        checkNotDisposed(usageError) {
+            this.breaker.use();
+            if (this.disposed) {
+                if (usageError !== undefined) {
+                    throw new UsageError(usageError);
+                }
+                fail(0x911 /* Invalid operation on a disposed TreeCheckout */);
             }
-            // #endregion UntypedTreeViewAlpha
-            // Revision is the revision of the commit, if any, which caused this change.
-            applyInternalChange(change, revision) {
-                // Conflicts due to schema will be empty and thus are not applied.
-                for (const innerChange of change.changes) {
-                    if (innerChange.type === "data") {
-                        const delta = intoDelta(tagChange(innerChange.innerChange, revision));
-                        this.withCombinedVisitor((visitor) => {
-                            visitDelta(delta, visitor, this._removedRoots, revision);
-                        });
+        }
+        /**
+         * Creates a {@link RevertibleAlpha} object that can undo a specific change in the tree's history.
+         * Revision must exist in the given {@link TreeCheckout}'s branch.
+         *
+         * @param revision - The revision tag identifying the change to be made revertible.
+         * @param kind - The {@link CommitKind} that produced this revertible (e.g., Default, Undo, Redo).
+         * @param checkout - The {@link TreeCheckout} instance this revertible belongs to.
+         * @param onRevertibleDisposed - Callback function that will be called when the revertible is disposed.
+         * @param labelTree - The {@link LabelTree} (if any) active when the original commit was produced.
+         * The revert commit inherits these labels so that commits and their reverts can be associated.
+         * @returns A {@link RevertibleAlpha} object.
+         */
+        createRevertible(revision, kind, checkout, onRevertibleDisposed, labelTree) {
+            const commitBranches = checkout.revertibleCommitBranches;
+            const revertible = {
+                get status() {
+                    const revertibleCommit = commitBranches.get(revision);
+                    return revertibleCommit === undefined
+                        ? RevertibleStatus.Disposed
+                        : RevertibleStatus.Valid;
+                },
+                revert: (releaseOrOptions = true) => {
+                    if (revertible.status === RevertibleStatus.Disposed) {
+                        throw new UsageError("Unable to revert a revertible that has been disposed.");
+                    }
+                    const options = typeof releaseOrOptions === "boolean"
+                        ? { dispose: releaseOrOptions }
+                        : releaseOrOptions;
+                    const revertMetrics = checkout.revertRevertible(revision, kind, labelTree, snapshotCustomMetadata(options.customMetadata));
+                    checkout.logger?.sendTelemetryEvent({
+                        eventName: TreeCheckout.revertTelemetryEventName,
+                        ...revertMetrics,
+                    });
+                    if (options.dispose ?? true) {
+                        revertible.dispose();
                     }
-                    else if (innerChange.type === "schema") {
-                        // Schema changes from a current to a new schema are expected to be backwards compatible.
-                        // This guarantees that all data in the forest (which is valid before the schema change)
-                        // is also valid under the new schema.
-                        // Note however, that such schema changes may in some cases be rolled back:
-                        // Case 1: A transaction with a schema change may be aborted.
-                        // The transaction may have made some data changes that would render some trees invalid
-                        // under the old schema, but these changes will also be rolled back, thereby putting the forest
-                        // back in the state before the transaction, which is valid under the original (reinstated) schema.
-                        // Case 2: A branch with a schema change may be rebased such that the schema change (because
-                        // of a constraint) is no longer applied.
-                        // Such a branch may contain data changes that would render some trees invalid under the
-                        // original schema. These data changes may not necessarily be rolled back.
-                        // They will however be rebased over the rollback of the schema change. This rebasing will
-                        // ensure that these data changes are muted if they would render some trees invalid under the
-                        // original (reinstated) schema.
-                        this.storedSchema.apply(innerChange.innerChange.schema.new);
+                },
+                clone: (targetView) => {
+                    // TODO:#23442: When a revertible is cloned for a forked branch, optimize to create a fork of a revertible branch once per revision NOT once per revision per checkout.
+                    const targetCheckout = getCheckout(targetView);
+                    const revertibleBranch = this.revertibleCommitBranches.get(revision);
+                    if (revertibleBranch === undefined) {
+                        throw new UsageError("Unable to clone a revertible that has been disposed.");
                     }
-                    else {
-                        fail(0xad1 /* Unknown Shared Tree change type. */);
+                    const commitToRevert = revertibleBranch.getHead();
+                    const branchHead = targetCheckout.#transaction.branch.getHead();
+                    if (isAncestor(commitToRevert, branchHead, true) === false) {
+                        throw new UsageError("Cannot clone revertible for a commit that is not present on the given branch.");
                     }
-                }
+                    targetCheckout.revertibleCommitBranches.set(revision, revertibleBranch.fork());
+                    return this.createRevertible(revision, kind, targetCheckout, onRevertibleDisposed, labelTree);
+                },
+                dispose: () => {
+                    if (revertible.status === RevertibleStatus.Disposed) {
+                        throw new UsageError("Unable to dispose a revertible that has already been disposed.");
+                    }
+                    checkout.disposeRevertible(revision);
+                    onRevertibleDisposed?.(revertible);
+                },
+            };
+            return revertible;
+        }
+        viewWith(config) {
+            const view = new SchematizingSimpleTreeView(this, config, createNodeIdentifierManager(this.idCompressor), () => {
+                this.views.delete(view);
+            });
+            this.views.add(view);
+            return view;
+        }
+        get rootEvents() {
+            return this.forest.anchors.events;
+        }
+        get editor() {
+            this.checkNotDisposed();
+            return this.editLock.editor;
+        }
+        locate(anchor) {
+            this.checkNotDisposed();
+            return this.forest.anchors.locate(anchor);
+        }
+        get transaction() {
+            return this.#transaction;
+        }
+        /**
+         * The {@link Transactor} for this checkout.
+         * @remarks In the context of a checkout, transactions allow edits to be batched into atomic units.
+         * Edits made during a transaction will update the local state of the tree immediately, but will be squashed into a single edit when the transaction is committed.
+         * If the transaction is aborted, the local state will be reset to what it was before the transaction began.
+         * Transactions may nest, meaning that a transaction may be started while a transaction is already ongoing.
+         *
+         * To avoid updating observers of the view state with intermediate results during a transaction,
+         * use {@link ITreeCheckout#fork} and {@link ISharedTreeFork#merge}.
+         */
+        #transaction;
+        fork() {
+            this.checkNotDisposed("The parent branch has already been disposed and can no longer create new branches.");
+            // Branching after an unfinished transaction would expose the application to a state where its invariants may be violated.
+            if (this.transaction.size > 0) {
+                throw new UsageError("A view cannot be forked while it has a pending transaction.");
             }
-            withCombinedVisitor(fn) {
-                const anchorVisitor = this.forest.anchors.acquireVisitor();
-                const combinedVisitor = combineVisitors([this.forest.acquireVisitor(), anchorVisitor]);
-                fn(combinedVisitor);
-                combinedVisitor.free();
+            const branch = this.#transaction.branch.fork();
+            const storedSchema = this.storedSchema.clone();
+            const forkBreaker = new Breakable("TreeCheckout", this.logger);
+            const forest = this.forest.clone(storedSchema, forkBreaker);
+            const checkout = new TreeCheckout(branch, false, this.changeFamily, storedSchema, forest, this.mintRevisionTag, this.revisionTagCodec, this.idCompressor, this._removedRoots.clone());
+            this.#events.emit("fork", checkout);
+            return checkout;
+        }
+        switchBranch(branch) {
+            assert(this.#transaction.size === 0, 0xc55 /* Cannot switch branches during a transaction */);
+            if (this.isSharedBranch) {
+                throw new UsageError("Cannot switch a view away from a shared branch. Consider forking first.");
             }
-            checkNotDisposed(usageError) {
-                this.breaker.use();
-                if (this.disposed) {
-                    if (usageError !== undefined) {
-                        throw new UsageError(usageError);
-                    }
-                    fail(0x911 /* Invalid operation on a disposed TreeCheckout */);
-                }
+            const diff = diffHistories(this.changeFamily.rebaser, this.#transaction.branch.getHead(), branch.getHead(), this.mintRevisionTag);
+            this.unregisterFromBranchEvents();
+            this.#transaction = this.createTransactionStack(branch);
+            this.branch = branch;
+            this._branchHistory?.dispose();
+            this._branchHistory = undefined;
+            this.editLock = new EditLock(this.#transaction.activeBranchEditor);
+            this.registerForBranchEvents();
+            // TODO: Rework eventing
+            this.applyInternalChange(diff);
+            this.#events.emit("afterBatch");
+        }
+        rewindTo(revisionString) {
+            this.checkNotDisposed("The branch has already been disposed and cannot be rewound.");
+            if (this.#transaction.size > 0) {
+                throw new UsageError("Rewinding is not supported during transactions.");
             }
-            /**
-             * Creates a {@link RevertibleAlpha} object that can undo a specific change in the tree's history.
-             * Revision must exist in the given {@link TreeCheckout}'s branch.
-             *
-             * @param revision - The revision tag identifying the change to be made revertible.
-             * @param kind - The {@link CommitKind} that produced this revertible (e.g., Default, Undo, Redo).
-             * @param checkout - The {@link TreeCheckout} instance this revertible belongs to.
-             * @param onRevertibleDisposed - Callback function that will be called when the revertible is disposed.
-             * @param labelTree - The {@link LabelTree} (if any) active when the original commit was produced.
-             * The revert commit inherits these labels so that commits and their reverts can be associated.
-             * @returns A {@link RevertibleAlpha} object.
-             */
-            createRevertible(revision, kind, checkout, onRevertibleDisposed, labelTree) {
-                const commitBranches = checkout.revertibleCommitBranches;
-                const revertible = {
-                    get status() {
-                        const revertibleCommit = commitBranches.get(revision);
-                        return revertibleCommit === undefined
-                            ? RevertibleStatus.Disposed
-                            : RevertibleStatus.Valid;
-                    },
-                    revert: (releaseOrOptions = true) => {
-                        if (revertible.status === RevertibleStatus.Disposed) {
-                            throw new UsageError("Unable to revert a revertible that has been disposed.");
-                        }
-                        const options = typeof releaseOrOptions === "boolean"
-                            ? { dispose: releaseOrOptions }
-                            : releaseOrOptions;
-                        const revertMetrics = checkout.revertRevertible(revision, kind, labelTree, snapshotCustomMetadata(options.customMetadata));
-                        checkout.logger?.sendTelemetryEvent({
-                            eventName: _a.revertTelemetryEventName,
-                            ...revertMetrics,
-                        });
-                        if (options.dispose ?? true) {
-                            revertible.dispose();
-                        }
-                    },
-                    clone: (targetView) => {
-                        // TODO:#23442: When a revertible is cloned for a forked branch, optimize to create a fork of a revertible branch once per revision NOT once per revision per checkout.
-                        const targetCheckout = getCheckout(targetView);
-                        const revertibleBranch = this.revertibleCommitBranches.get(revision);
-                        if (revertibleBranch === undefined) {
-                            throw new UsageError("Unable to clone a revertible that has been disposed.");
-                        }
-                        const commitToRevert = revertibleBranch.getHead();
-                        const branchHead = __classPrivateFieldGet(targetCheckout, _TreeCheckout_transaction, "f").branch.getHead();
-                        if (isAncestor(commitToRevert, branchHead, true) === false) {
-                            throw new UsageError("Cannot clone revertible for a commit that is not present on the given branch.");
-                        }
-                        targetCheckout.revertibleCommitBranches.set(revision, revertibleBranch.fork());
-                        return this.createRevertible(revision, kind, targetCheckout, onRevertibleDisposed, labelTree);
-                    },
-                    dispose: () => {
-                        if (revertible.status === RevertibleStatus.Disposed) {
-                            throw new UsageError("Unable to dispose a revertible that has already been disposed.");
-                        }
-                        checkout.disposeRevertible(revision);
-                        onRevertibleDisposed?.(revertible);
-                    },
-                };
-                return revertible;
+            const revision = this.idCompressor.tryRecompress(revisionString);
+            if (revision === undefined) {
+                throw new UsageError(`Unrecognized revision id: ${revisionString}`);
             }
-            viewWith(config) {
-                const view = new SchematizingSimpleTreeView(this, config, createNodeIdentifierManager(this.idCompressor), () => {
-                    this.views.delete(view);
-                });
-                this.views.add(view);
-                return view;
+            const targetCommit = findAncestor(this.#transaction.branch.getHead(), (commit) => commit.revision === revision);
+            if (targetCommit === undefined) {
+                throw new UsageError(`No commit found with revision: ${revisionString}`);
             }
-            get rootEvents() {
-                return this.forest.anchors.events;
+            this.switchBranch(this.#transaction.branch.fork(targetCommit));
+        }
+        revertTo(revisionString, options) {
+            this.checkNotDisposed("The branch has already been disposed and prior revisions cannot be reverted to.");
+            this.editLock.checkUnlocked("Reverting to a revision");
+            if (this.#transaction.size > 0) {
+                throw new UsageError("Reverting to a revision is not supported during transactions.");
             }
-            get editor() {
-                this.checkNotDisposed();
-                return this.editLock.editor;
+            const customMetadata = snapshotCustomMetadata(options?.customMetadata);
+            const revision = this.idCompressor.tryRecompress(revisionString);
+            if (revision === undefined) {
+                throw new UsageError(`Unrecognized revision id: ${revisionString}`);
             }
-            locate(anchor) {
-                this.checkNotDisposed();
-                return this.forest.anchors.locate(anchor);
+            // Populated with the commits that came after the target commit, from oldest to newest.
+            const commitsToUndo = [];
+            const targetCommit = findAncestor([this.#transaction.activeBranch.getHead(), commitsToUndo], (commit) => commit.revision === revision);
+            if (targetCommit === undefined) {
+                throw new UsageError(`No commit found with revision: ${revisionString}`);
             }
-            get transaction() {
-                return __classPrivateFieldGet(this, _TreeCheckout_transaction, "f");
+            if (!hasSome(commitsToUndo)) {
+                // The target commit is already the head of the branch, so there is nothing to revert.
+                return;
             }
-            fork() {
-                this.checkNotDisposed("The parent branch has already been disposed and can no longer create new branches.");
-                // Branching after an unfinished transaction would expose the application to a state where its invariants may be violated.
-                if (this.transaction.size > 0) {
-                    throw new UsageError("A view cannot be forked while it has a pending transaction.");
-                }
-                const branch = __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.fork();
-                const storedSchema = this.storedSchema.clone();
-                const forkBreaker = new Breakable("TreeCheckout", this.logger);
-                const forest = this.forest.clone(storedSchema, forkBreaker);
-                const checkout = new _a(branch, false, this.changeFamily, storedSchema, forest, this.mintRevisionTag, this.revisionTagCodec, this.idCompressor, this._removedRoots.clone());
-                __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("fork", checkout);
-                return checkout;
+            const revisionForInvert = this.mintRevisionTag();
+            const toUndo = this.changeFamily.rebaser.compose(commitsToUndo);
+            const inverse = this.changeFamily.rebaser.invert(makeAnonChange(toUndo), false, revisionForInvert);
+            this.#transaction.branch.apply(tagChange(inverse, revisionForInvert), CommitKind.Default, toMetadataTree(customMetadata));
+        }
+        rebase(view) {
+            const checkout = getCheckout(view);
+            this.checkNotDisposed("The target branch of the rebase has been disposed and cannot be rebased.");
+            checkout.checkNotDisposed("The source branch of the rebase has been disposed and cannot be rebased.");
+            this.editLock.checkUnlocked("Rebasing");
+            if (this.transaction.size > 0) {
+                throw new UsageError("Views cannot be rebased onto a view that has a pending transaction.");
             }
-            switchBranch(branch) {
-                assert(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").size === 0, 0xc55 /* Cannot switch branches during a transaction */);
-                if (this.isSharedBranch) {
-                    throw new UsageError("Cannot switch a view away from a shared branch. Consider forking first.");
-                }
-                const diff = diffHistories(this.changeFamily.rebaser, __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.getHead(), branch.getHead(), this.mintRevisionTag);
-                this.unregisterFromBranchEvents();
-                __classPrivateFieldSet(this, _TreeCheckout_transaction, this.createTransactionStack(branch), "f");
-                this.branch = branch;
-                this._branchHistory?.dispose();
-                this._branchHistory = undefined;
-                this.editLock = new EditLock(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranchEditor);
-                this.registerForBranchEvents();
-                // TODO: Rework eventing
-                this.applyInternalChange(diff);
-                __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("afterBatch");
+            if (checkout.transaction.size > 0) {
+                throw new UsageError("A view cannot be rebased while it has a pending transaction.");
             }
-            rewindTo(revisionString) {
-                this.checkNotDisposed("The branch has already been disposed and cannot be rewound.");
-                if (__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").size > 0) {
-                    throw new UsageError("Rewinding is not supported during transactions.");
-                }
-                const revision = this.idCompressor.tryRecompress(revisionString);
-                if (revision === undefined) {
-                    throw new UsageError(`Unrecognized revision id: ${revisionString}`);
-                }
-                const targetCommit = findAncestor(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.getHead(), (commit) => commit.revision === revision);
-                if (targetCommit === undefined) {
-                    throw new UsageError(`No commit found with revision: ${revisionString}`);
-                }
-                this.switchBranch(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.fork(targetCommit));
+            assert(!checkout.isSharedBranch, 0xa5d /* Shared branches cannot be rebased onto another branch. */);
+            checkout.#transaction.branch.rebaseOnto(this.#transaction.branch);
+        }
+        rebaseOnto(view) {
+            getCheckout(view).rebase(this);
+        }
+        isMissingEditsFrom(view) {
+            const viewCheckout = getCheckout(view);
+            const targetPath = [];
+            const ancestor = findCommonAncestor(this.mainBranch.getHead(), [
+                viewCheckout.mainBranch.getHead(),
+                targetPath,
+            ]);
+            if (ancestor === undefined) {
+                throw new UsageError("Branches do not share a common ancestor.");
             }
-            revertTo(revisionString, options) {
-                this.checkNotDisposed("The branch has already been disposed and prior revisions cannot be reverted to.");
-                this.editLock.checkUnlocked("Reverting to a revision");
-                if (__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").size > 0) {
-                    throw new UsageError("Reverting to a revision is not supported during transactions.");
-                }
-                const customMetadata = snapshotCustomMetadata(options?.customMetadata);
-                const revision = this.idCompressor.tryRecompress(revisionString);
-                if (revision === undefined) {
-                    throw new UsageError(`Unrecognized revision id: ${revisionString}`);
-                }
-                // Populated with the commits that came after the target commit, from oldest to newest.
-                const commitsToUndo = [];
-                const targetCommit = findAncestor([__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.getHead(), commitsToUndo], (commit) => commit.revision === revision);
-                if (targetCommit === undefined) {
-                    throw new UsageError(`No commit found with revision: ${revisionString}`);
-                }
-                if (!hasSome(commitsToUndo)) {
-                    // The target commit is already the head of the branch, so there is nothing to revert.
-                    return;
-                }
-                const revisionForInvert = this.mintRevisionTag();
-                const toUndo = this.changeFamily.rebaser.compose(commitsToUndo);
-                const inverse = this.changeFamily.rebaser.invert(makeAnonChange(toUndo), false, revisionForInvert);
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.apply(tagChange(inverse, revisionForInvert), CommitKind.Default, toMetadataTree(customMetadata));
+            return targetPath.length > 0;
+        }
+        computeNetChangeIfRebasedOnto(view) {
+            const viewCheckout = getCheckout(view);
+            const rebased = rebaseBranch(this.mintRevisionTag, this.changeFamily.rebaser, this.#transaction.branch.getHead(), viewCheckout.#transaction.branch.getHead());
+            if (rebased.sourceChange === undefined) {
+                return undefined;
             }
-            rebase(view) {
-                const checkout = getCheckout(view);
-                this.checkNotDisposed("The target branch of the rebase has been disposed and cannot be rebased.");
-                checkout.checkNotDisposed("The source branch of the rebase has been disposed and cannot be rebased.");
-                this.editLock.checkUnlocked("Rebasing");
-                if (this.transaction.size > 0) {
-                    throw new UsageError("Views cannot be rebased onto a view that has a pending transaction.");
-                }
-                if (checkout.transaction.size > 0) {
-                    throw new UsageError("A view cannot be rebased while it has a pending transaction.");
-                }
-                assert(!checkout.isSharedBranch, 0xa5d /* Shared branches cannot be rebased onto another branch. */);
-                __classPrivateFieldGet(checkout, _TreeCheckout_transaction, "f").branch.rebaseOnto(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch);
+            const revision = this.mintRevisionTag();
+            return SerializedChange.V1.encode(this.idCompressor, this.changeFamily, rebased.sourceChange, revision, undefined);
+        }
+        merge(view, disposeMerged = true) {
+            const checkout = getCheckout(view);
+            this.checkNotDisposed("The target branch of the merge has been disposed and cannot be merged.");
+            checkout.checkNotDisposed("The source branch of the merge has been disposed and cannot be merged.");
+            this.editLock.checkUnlocked("Merging");
+            if (this.transaction.size > 0) {
+                throw new UsageError("Views cannot be merged into a view while it has a pending transaction.");
             }
-            rebaseOnto(view) {
-                getCheckout(view).rebase(this);
+            if (checkout.transaction.size > 0) {
+                throw new UsageError("Views with an open transaction cannot be merged into another view.");
             }
-            isMissingEditsFrom(view) {
-                const viewCheckout = getCheckout(view);
-                const targetPath = [];
-                const ancestor = findCommonAncestor(this.mainBranch.getHead(), [
-                    viewCheckout.mainBranch.getHead(),
-                    targetPath,
-                ]);
-                if (ancestor === undefined) {
-                    throw new UsageError("Branches do not share a common ancestor.");
-                }
-                return targetPath.length > 0;
+            this.#transaction.branch.merge(checkout.#transaction.branch);
+            if (disposeMerged && !checkout.isSharedBranch) {
+                // Dispose the merged checkout unless it is a shared branch.
+                checkout[disposeSymbol]();
             }
-            computeNetChangeIfRebasedOnto(view) {
-                const viewCheckout = getCheckout(view);
-                const rebased = rebaseBranch(this.mintRevisionTag, this.changeFamily.rebaser, __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.getHead(), __classPrivateFieldGet(viewCheckout, _TreeCheckout_transaction, "f").branch.getHead());
-                if (rebased.sourceChange === undefined) {
-                    return undefined;
-                }
-                const revision = this.mintRevisionTag();
-                return SerializedChange.V1.encode(this.idCompressor, this.changeFamily, rebased.sourceChange, revision, undefined);
+        }
+        updateSchema(newSchema, allowNonSupersetSchema) {
+            this.checkNotDisposed();
+            if (allowNonSupersetSchema !== true) {
+                assert(allowsRepoSuperset(defaultSchemaPolicy, this.storedSchema.clone(), newSchema), 0xbe6 /* New schema must allow all documents allowed by old schema */);
             }
-            merge(view, disposeMerged = true) {
-                const checkout = getCheckout(view);
-                this.checkNotDisposed("The target branch of the merge has been disposed and cannot be merged.");
-                checkout.checkNotDisposed("The source branch of the merge has been disposed and cannot be merged.");
-                this.editLock.checkUnlocked("Merging");
-                if (this.transaction.size > 0) {
-                    throw new UsageError("Views cannot be merged into a view while it has a pending transaction.");
-                }
-                if (checkout.transaction.size > 0) {
-                    throw new UsageError("Views with an open transaction cannot be merged into another view.");
-                }
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.merge(__classPrivateFieldGet(checkout, _TreeCheckout_transaction, "f").branch);
-                if (disposeMerged && !checkout.isSharedBranch) {
-                    // Dispose the merged checkout unless it is a shared branch.
-                    checkout[disposeSymbol]();
-                }
+            this.editor.schema.setStoredSchema(this.storedSchema.clone(), newSchema);
+        }
+        dispose() {
+            this.editLock.checkUnlocked("Disposing a view");
+            this[disposeSymbol]();
+        }
+        [(_exportVerbose_decorators = [throwIfBroken], _applySerializedChange_decorators = [throwIfBroken], _applyChange_decorators = [throwIfBroken], _runTransaction_decorators = [breakingMethod], _runTransactionAsync_decorators = [breakingMethod], _withCombinedVisitor_decorators = [breakingMethod], _viewWith_decorators = [throwIfBroken], _fork_decorators = [throwIfBroken], disposeSymbol)]() {
+            this.checkNotDisposed("The branch has already been disposed and cannot be disposed again.");
+            this.disposed = true;
+            this.#transaction.branch.dispose();
+            this.#transaction.dispose();
+            this.purgeRevertibles();
+            for (const view of this.views) {
+                view.dispose();
             }
-            updateSchema(newSchema, allowNonSupersetSchema) {
-                this.checkNotDisposed();
-                if (allowNonSupersetSchema !== true) {
-                    assert(allowsRepoSuperset(defaultSchemaPolicy, this.storedSchema.clone(), newSchema), 0xbe6 /* New schema must allow all documents allowed by old schema */);
-                }
-                this.editor.schema.setStoredSchema(this.storedSchema.clone(), newSchema);
+            this.#events.emit("dispose");
+            this._branchHistory?.dispose();
+            this._branchHistory = undefined;
+        }
+        getRemovedRoots() {
+            this.assertNoUntrackedRoots();
+            const trees = [];
+            const cursor = this.forest.allocateCursor("getRemovedRoots");
+            for (const { id, root } of this._removedRoots.entries()) {
+                const parentField = this._removedRoots.toFieldKey(root);
+                this.forest.moveCursorToPath({ parent: undefined, parentField, parentIndex: 0 }, cursor);
+                const tree = jsonableTreeFromCursor(cursor);
+                // This method is used for tree consistency comparison.
+                const { major, minor } = id;
+                const finalizedMajor = major === undefined ? major : this.revisionTagCodec.encode(major);
+                trees.push([finalizedMajor, minor, tree]);
             }
-            dispose() {
-                this.editLock.checkUnlocked("Disposing a view");
-                this[disposeSymbol]();
+            cursor.free();
+            return trees;
+        }
+        /**
+         * This must be called on the root/main checkout after loading from a summary.
+         * @remarks This pattern is necessary because the EditManager skips the normal process of applying commits to branches when loading a summary.
+         * Instead, it simply {@link SharedTreeBranch#setHead | mutates} the branches directly which does not propagate the typical events throughout the rest of the system.
+         */
+        load() {
+            // Set the tip revision as the latest relevant revision for any removed roots that are loaded from a summary - this allows them to be garbage collected later.
+            // When a load happens, the head of the trunk and the head of the local/main branch must be the same (this is enforced by SharedTree).
+            this._removedRoots.setRevisionsForLoadedData(this.#transaction.branch.getHead().revision);
+            // The content of the checkout (e.g. the forest) has (maybe) changed, so fire an afterBatch event.
+            this.#events.emit("afterBatch");
+        }
+        purgeRevertibles() {
+            for (const revertible of this.revertibles.values()) {
+                revertible.dispose();
             }
-            [(_TreeCheckout_events = new WeakMap(), _TreeCheckout_transaction = new WeakMap(), _TreeCheckout_validatedCommits = new WeakMap(), _exportVerbose_decorators = [throwIfBroken], _applySerializedChange_decorators = [throwIfBroken], _applyChange_decorators = [throwIfBroken], _runTransaction_decorators = [breakingMethod], _runTransactionAsync_decorators = [breakingMethod], _withCombinedVisitor_decorators = [breakingMethod], _viewWith_decorators = [throwIfBroken], _fork_decorators = [throwIfBroken], disposeSymbol)]() {
-                this.checkNotDisposed("The branch has already been disposed and cannot be disposed again.");
-                this.disposed = true;
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.dispose();
-                __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").dispose();
-                this.purgeRevertibles();
-                for (const view of this.views) {
-                    view.dispose();
-                }
-                __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("dispose");
-                this._branchHistory?.dispose();
-                this._branchHistory = undefined;
+        }
+        disposeRevertible(revision) {
+            this.revertibleCommitBranches.get(revision)?.dispose();
+            this.revertibleCommitBranches.delete(revision);
+            this.revertibles.delete(revision);
+        }
+        revertRevertible(revision, kind, labelTree, customMetadata) {
+            this.editLock.checkUnlocked("Reverting a commit");
+            if (this.transaction.size > 0) {
+                throw new UsageError("Undo is not yet supported during transactions.");
             }
-            getRemovedRoots() {
-                this.assertNoUntrackedRoots();
-                const trees = [];
-                const cursor = this.forest.allocateCursor("getRemovedRoots");
-                for (const { id, root } of this._removedRoots.entries()) {
-                    const parentField = this._removedRoots.toFieldKey(root);
-                    this.forest.moveCursorToPath({ parent: undefined, parentField, parentIndex: 0 }, cursor);
-                    const tree = jsonableTreeFromCursor(cursor);
-                    // This method is used for tree consistency comparison.
-                    const { major, minor } = id;
-                    const finalizedMajor = major === undefined ? major : this.revisionTagCodec.encode(major);
-                    trees.push([finalizedMajor, minor, tree]);
-                }
-                cursor.free();
-                return trees;
+            const revertibleBranch = this.revertibleCommitBranches.get(revision);
+            assert(revertibleBranch !== undefined, 0x7cc /* expected to find a revertible commit */);
+            const commitToRevert = revertibleBranch.getHead();
+            const revisionForInvert = this.mintRevisionTag();
+            let change = tagChange(this.changeFamily.rebaser.invert(commitToRevert, false, revisionForInvert), revisionForInvert);
+            const headCommit = this.#transaction.branch.getHead();
+            // Rebase the inverted change onto any commits that occurred after the undoable commits.
+            if (commitToRevert !== headCommit) {
+                // The inverse may be rebased over newer commits which (despite being present in the history)
+                // have no net effect on the document state (e.g. an edit plus its undo).
+                // In that case, a no-change constraint should not be violated during rebase.
+                const diff = diffHistories(this.changeFamily.rebaser, commitToRevert, headCommit, this.mintRevisionTag);
+                const ignoreNoChangeViolation = !sharedTreeChangeHasApplicationFacingChanges(diff);
+                change = tagChange(rebaseChange(this.changeFamily.rebaser, change, commitToRevert, headCommit, this.mintRevisionTag, ignoreNoChangeViolation).change, revisionForInvert);
             }
-            /**
-             * This must be called on the root/main checkout after loading from a summary.
-             * @remarks This pattern is necessary because the EditManager skips the normal process of applying commits to branches when loading a summary.
-             * Instead, it simply {@link SharedTreeBranch#setHead | mutates} the branches directly which does not propagate the typical events throughout the rest of the system.
-             */
-            load() {
-                // Set the tip revision as the latest relevant revision for any removed roots that are loaded from a summary - this allows them to be garbage collected later.
-                // When a load happens, the head of the trunk and the head of the local/main branch must be the same (this is enforced by SharedTree).
-                this._removedRoots.setRevisionsForLoadedData(__classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.getHead().revision);
-                // The content of the checkout (e.g. the forest) has (maybe) changed, so fire an afterBatch event.
-                __classPrivateFieldGet(this, _TreeCheckout_events, "f").emit("afterBatch");
+            // Install the original commit's label tree so the revert commit's metadata inherits
+            // the same labels. Reusing the captured tree (rather than wrapping it) ensures
+            // revert-of-revert does not introduce new nesting.
+            const previousLabelTreeNode = this.labelTreeNode;
+            this.labelTreeNode = labelTree;
+            try {
+                this.#transaction.branch.apply(change, kind === CommitKind.Default || kind === CommitKind.Redo
+                    ? CommitKind.Undo
+                    : CommitKind.Redo, toMetadataTree(customMetadata));
             }
-            purgeRevertibles() {
-                for (const revertible of this.revertibles.values()) {
-                    revertible.dispose();
-                }
+            finally {
+                this.labelTreeNode = previousLabelTreeNode;
             }
-            disposeRevertible(revision) {
-                this.revertibleCommitBranches.get(revision)?.dispose();
-                this.revertibleCommitBranches.delete(revision);
-                this.revertibles.delete(revision);
+            // Derive some stats about the reversion to return to the caller.
+            let revertAge = 0;
+            let currentCommit = headCommit;
+            while (commitToRevert.revision !== currentCommit.revision) {
+                revertAge++;
+                const parentCommit = currentCommit.parent;
+                assert(parentCommit !== undefined, 0x9a9 /* expected to find a parent commit */);
+                currentCommit = parentCommit;
             }
-            revertRevertible(revision, kind, labelTree, customMetadata) {
-                this.editLock.checkUnlocked("Reverting a commit");
-                if (this.transaction.size > 0) {
-                    throw new UsageError("Undo is not yet supported during transactions.");
-                }
-                const revertibleBranch = this.revertibleCommitBranches.get(revision);
-                assert(revertibleBranch !== undefined, 0x7cc /* expected to find a revertible commit */);
-                const commitToRevert = revertibleBranch.getHead();
-                const revisionForInvert = this.mintRevisionTag();
-                let change = tagChange(this.changeFamily.rebaser.invert(commitToRevert, false, revisionForInvert), revisionForInvert);
-                const headCommit = __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.getHead();
-                // Rebase the inverted change onto any commits that occurred after the undoable commits.
-                if (commitToRevert !== headCommit) {
-                    // The inverse may be rebased over newer commits which (despite being present in the history)
-                    // have no net effect on the document state (e.g. an edit plus its undo).
-                    // In that case, a no-change constraint should not be violated during rebase.
-                    const diff = diffHistories(this.changeFamily.rebaser, commitToRevert, headCommit, this.mintRevisionTag);
-                    const ignoreNoChangeViolation = !sharedTreeChangeHasVisibleChanges(diff);
-                    change = tagChange(rebaseChange(this.changeFamily.rebaser, change, commitToRevert, headCommit, this.mintRevisionTag, ignoreNoChangeViolation).change, revisionForInvert);
-                }
-                // Install the original commit's label tree so the revert commit's metadata inherits
-                // the same labels. Reusing the captured tree (rather than wrapping it) ensures
-                // revert-of-revert does not introduce new nesting.
-                const previousLabelTreeNode = this.labelTreeNode;
-                this.labelTreeNode = labelTree;
-                try {
-                    __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch.apply(change, kind === CommitKind.Default || kind === CommitKind.Redo
-                        ? CommitKind.Undo
-                        : CommitKind.Redo, toMetadataTree(customMetadata));
-                }
-                finally {
-                    this.labelTreeNode = previousLabelTreeNode;
-                }
-                // Derive some stats about the reversion to return to the caller.
-                let revertAge = 0;
-                let currentCommit = headCommit;
-                while (commitToRevert.revision !== currentCommit.revision) {
-                    revertAge++;
-                    const parentCommit = currentCommit.parent;
-                    assert(parentCommit !== undefined, 0x9a9 /* expected to find a parent commit */);
-                    currentCommit = parentCommit;
-                }
-                return { age: revertAge };
+            return { age: revertAge };
+        }
+        assertNoUntrackedRoots() {
+            const cursor = this.forest.getCursorAboveDetachedFields();
+            const rootFields = new Set([rootFieldKey]);
+            for (const { root } of this._removedRoots.entries()) {
+                rootFields.add(this._removedRoots.toFieldKey(root));
             }
-            assertNoUntrackedRoots() {
-                const cursor = this.forest.getCursorAboveDetachedFields();
-                const rootFields = new Set([rootFieldKey]);
-                for (const { root } of this._removedRoots.entries()) {
-                    rootFields.add(this._removedRoots.toFieldKey(root));
-                }
-                if (!cursor.firstField()) {
-                    return;
-                }
-                do {
-                    const field = cursor.getFieldKey();
-                    assert(rootFields.has(field), 0xa22 /* Forest has a root field which is unknown to the detached field index */);
-                    rootFields.delete(field);
-                } while (cursor.nextField());
+            if (!cursor.firstField()) {
+                return;
             }
-            /**
-             * `true` iff the given branch change event is due to a remote change
-             */
-            isRemoteChangeEvent(event) {
-                return (
-                // Remote changes are only ever applied to shared branches
-                this.isSharedBranch &&
-                    // Remote changes are applied to the branch by rebasing it onto the trunk.
-                    // No other rebases are allowed on shared branches, so we can use this to detect remote changes.
-                    event.type === "rebase");
+            do {
+                const field = cursor.getFieldKey();
+                assert(rootFields.has(field), 0xa22 /* Forest has a root field which is unknown to the detached field index */);
+                rootFields.delete(field);
+            } while (cursor.nextField());
+        }
+        /**
+         * `true` iff the given branch change event is due to a remote change
+         */
+        isRemoteChangeEvent(event) {
+            return (
+            // Remote changes are only ever applied to shared branches
+            this.isSharedBranch &&
+                // Remote changes are applied to the branch by rebasing it onto the trunk.
+                // No other rebases are allowed on shared branches, so we can use this to detect remote changes.
+                event.type === "rebase");
+        }
+        // #region Commit Validation
+        /** Used to maintain the contract of {@link onCommitValid}(). */
+        #validatedCommits = new WeakMap();
+        /**
+         * Registers a function to be called when the given commit is validated.
+         * @remarks A commit is validated by the checkout after it has been applied to the checkout's state (e.g. it has an effect on the forest).
+         * If the commit applies successfully (i.e. it does not raise any unexpected errors), the commit is considered valid and the registered function is called.
+         * If the commit does not apply successfully (because it causes an unexpected error), the function is not called (and the checkout will left in an error state).
+         *
+         * If the commit has already been validated when this function is called, the function is called immediately and this function returns `true`.
+         * Otherwise, the function is registered to be called later and this function returns `false`.
+         */
+        onCommitValid(commit, fn) {
+            const validated = getOrCreate(this.#validatedCommits, commit, () => []);
+            if (validated === true) {
+                fn(commit);
+                return true;
             }
-            /**
-             * Registers a function to be called when the given commit is validated.
-             * @remarks A commit is validated by the checkout after it has been applied to the checkout's state (e.g. it has an effect on the forest).
-             * If the commit applies successfully (i.e. it does not raise any unexpected errors), the commit is considered valid and the registered function is called.
-             * If the commit does not apply successfully (because it causes an unexpected error), the function is not called (and the checkout will left in an error state).
-             *
-             * If the commit has already been validated when this function is called, the function is called immediately and this function returns `true`.
-             * Otherwise, the function is registered to be called later and this function returns `false`.
-             */
-            onCommitValid(commit, fn) {
-                const validated = getOrCreate(__classPrivateFieldGet(this, _TreeCheckout_validatedCommits, "f"), commit, () => []);
-                if (validated === true) {
+            validated.push(fn);
+            return false;
+        }
+        /** Mark the given commit as "validated" according to the contract of {@link onCommitValid}(). */
+        validateCommit(commit) {
+            const validated = getOrCreate(this.#validatedCommits, commit, () => []);
+            if (validated !== true) {
+                for (const fn of validated) {
                     fn(commit);
-                    return true;
-                }
-                validated.push(fn);
-                return false;
-            }
-            /** Mark the given commit as "validated" according to the contract of {@link onCommitValid}(). */
-            validateCommit(commit) {
-                const validated = getOrCreate(__classPrivateFieldGet(this, _TreeCheckout_validatedCommits, "f"), commit, () => []);
-                if (validated !== true) {
-                    for (const fn of validated) {
-                        fn(commit);
-                    }
-                    __classPrivateFieldGet(this, _TreeCheckout_validatedCommits, "f").set(commit, true);
                 }
+                this.#validatedCommits.set(commit, true);
             }
-            resetEnrichmentStats() {
-                this.enrichmentStats.batches = 0;
-                this.enrichmentStats.diffs = 0;
-                this.enrichmentStats.commitsEnriched = 0;
-                this.enrichmentStats.refreshers = 0;
-                this.enrichmentStats.forks = 0;
-                this.enrichmentStats.applied = 0;
+        }
+        // #endregion Commit Validation
+        // #region Enrichment
+        /**
+         * Statistics about enrichment operations performed by this checkout.
+         * Used for testing. May be used for telemetry in the future.
+         * The performance cost of maintaining this information is negligible.
+         */
+        enrichmentStats = { batches: 0, diffs: 0, commitsEnriched: 0, refreshers: 0, forks: 0, applied: 0 };
+        resetEnrichmentStats() {
+            this.enrichmentStats.batches = 0;
+            this.enrichmentStats.diffs = 0;
+            this.enrichmentStats.commitsEnriched = 0;
+            this.enrichmentStats.refreshers = 0;
+            this.enrichmentStats.forks = 0;
+            this.enrichmentStats.applied = 0;
+        }
+        getEnrichmentStats() {
+            return { ...this.enrichmentStats };
+        }
+        enrich(context, changes, forceValidation) {
+            if (!hasSome(changes)) {
+                return [];
             }
-            getEnrichmentStats() {
-                return { ...this.enrichmentStats };
+            this.enrichmentStats.batches += 1;
+            const enricher = new SharedTreeChangeEnricher(this.forest, this._removedRoots, this.storedSchema, this.idCompressor, () => (this.enrichmentStats.commitsEnriched += 1), () => (this.enrichmentStats.refreshers += 1), () => (this.enrichmentStats.forks += 1), () => (this.enrichmentStats.applied += 1));
+            // This `lastCommitApplied` may be on the main branch or on a transaction branch.
+            // In either case, it is crucial that the state of the forest & detached field index reflects all changes up to and including this commit.
+            const lastCommitApplied = this.#transaction.activeBranch.getHead();
+            if (context !== lastCommitApplied) {
+                enricher.enqueueChange(() => {
+                    this.enrichmentStats.diffs += 1;
+                    const diff = diffHistories(this.changeFamily.rebaser, lastCommitApplied, context, this.mintRevisionTag);
+                    return makeAnonChange(diff);
+                });
             }
-            enrich(context, changes, forceValidation) {
-                if (!hasSome(changes)) {
-                    return [];
-                }
-                this.enrichmentStats.batches += 1;
-                const enricher = new SharedTreeChangeEnricher(this.forest, this._removedRoots, this.storedSchema, this.idCompressor, () => (this.enrichmentStats.commitsEnriched += 1), () => (this.enrichmentStats.refreshers += 1), () => (this.enrichmentStats.forks += 1), () => (this.enrichmentStats.applied += 1));
-                // This `lastCommitApplied` may be on the main branch or on a transaction branch.
-                // In either case, it is crucial that the state of the forest & detached field index reflects all changes up to and including this commit.
-                const lastCommitApplied = __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").activeBranch.getHead();
-                if (context !== lastCommitApplied) {
-                    enricher.enqueueChange(() => {
-                        this.enrichmentStats.diffs += 1;
-                        const diff = diffHistories(this.changeFamily.rebaser, lastCommitApplied, context, this.mintRevisionTag);
-                        return makeAnonChange(diff);
-                    });
-                }
-                const enrichedChanges = [];
-                for (const change of changes) {
-                    const enrichedChange = enricher.enrich(change.change);
-                    enrichedChanges.push(enrichedChange);
-                    // We could either apply the original or the enriched change: either should allow subsequent changes to be enriched correctly.
-                    // We choose to apply the enriched change in order to more closely replicate what a peer will experience (assuming no concurrent changes).
-                    // This makes it more likely that we'll detect a bug in the enrichment logic.
-                    // Note that enqueueing the change does not guarantee that it will be applied unless `forceValidation` is enabled.
-                    enricher.enqueueChange(tagChange(enrichedChange, change.revision));
-                }
-                if (forceValidation) {
-                    // Ensure that all changes can be applied successfully.
-                    // This is useful for catching bugs in the enrichment logic and in the rebasing logic that may have been involved in producing the changes.
-                    // Note that we cannot guarantee that the enriched change will be applied successfully even in the absence of concurrent changes,
-                    // because the checkout state we are applying this enriched change to was derived from the state of the checkout, which may be different from that of a peer.
-                    enricher.purgeChangeQueue();
-                }
-                enricher[disposeSymbol]();
-                return enrichedChanges;
+            const enrichedChanges = [];
+            for (const change of changes) {
+                const enrichedChange = enricher.enrich(change.change);
+                enrichedChanges.push(enrichedChange);
+                // We could either apply the original or the enriched change: either should allow subsequent changes to be enriched correctly.
+                // We choose to apply the enriched change in order to more closely replicate what a peer will experience (assuming no concurrent changes).
+                // This makes it more likely that we'll detect a bug in the enrichment logic.
+                // Note that enqueueing the change does not guarantee that it will be applied unless `forceValidation` is enabled.
+                enricher.enqueueChange(tagChange(enrichedChange, change.revision));
             }
-            get mainBranch() {
-                return __classPrivateFieldGet(this, _TreeCheckout_transaction, "f").branch;
+            if (forceValidation) {
+                // Ensure that all changes can be applied successfully.
+                // This is useful for catching bugs in the enrichment logic and in the rebasing logic that may have been involved in producing the changes.
+                // Note that we cannot guarantee that the enriched change will be applied successfully even in the absence of concurrent changes,
+                // because the checkout state we are applying this enriched change to was derived from the state of the checkout, which may be different from that of a peer.
+                enricher.purgeChangeQueue();
             }
-        },
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            __esDecorate(_a, null, _exportVerbose_decorators, { kind: "method", name: "exportVerbose", static: false, private: false, access: { has: obj => "exportVerbose" in obj, get: obj => obj.exportVerbose }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _applySerializedChange_decorators, { kind: "method", name: "applySerializedChange", static: false, private: false, access: { has: obj => "applySerializedChange" in obj, get: obj => obj.applySerializedChange }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _applyChange_decorators, { kind: "method", name: "applyChange", static: false, private: false, access: { has: obj => "applyChange" in obj, get: obj => obj.applyChange }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _runTransaction_decorators, { kind: "method", name: "runTransaction", static: false, private: false, access: { has: obj => "runTransaction" in obj, get: obj => obj.runTransaction }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _runTransactionAsync_decorators, { kind: "method", name: "runTransactionAsync", static: false, private: false, access: { has: obj => "runTransactionAsync" in obj, get: obj => obj.runTransactionAsync }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _withCombinedVisitor_decorators, { kind: "method", name: "withCombinedVisitor", static: false, private: false, access: { has: obj => "withCombinedVisitor" in obj, get: obj => obj.withCombinedVisitor }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _viewWith_decorators, { kind: "method", name: "viewWith", static: false, private: false, access: { has: obj => "viewWith" in obj, get: obj => obj.viewWith }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _fork_decorators, { kind: "method", name: "fork", static: false, private: false, access: { has: obj => "fork" in obj, get: obj => obj.fork }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        /**
-         * The name of the telemetry event logged for calls to {@link TreeCheckout.revertRevertible}.
-         * @privateRemarks Exposed for testing purposes.
-         */
-        _a.revertTelemetryEventName = "RevertRevertible",
-        _a;
+            enricher[disposeSymbol]();
+            return enrichedChanges;
+        }
+        get mainBranch() {
+            return this.#transaction.branch;
+        }
+    };
 })();
 export { TreeCheckout };
+function getSchemaChangeTelemetryMetrics(oldSchema, newSchema, isInverse) {
+    let addedNodeSchemaCount = 0;
+    for (const identifier of newSchema.nodeSchema.keys()) {
+        if (!oldSchema.nodeSchema.has(identifier)) {
+            addedNodeSchemaCount++;
+        }
+    }
+    let removedNodeSchemaCount = 0;
+    for (const identifier of oldSchema.nodeSchema.keys()) {
+        if (!newSchema.nodeSchema.has(identifier)) {
+            removedNodeSchemaCount++;
+        }
+    }
+    return {
+        changeKind: isInverse
+            ? "rollback"
+            : oldSchema.nodeSchema.size === 0
+                ? "initialize"
+                : allowsRepoSuperset(defaultSchemaPolicy, oldSchema, newSchema)
+                    ? "upgrade"
+                    : "restriction",
+        isInverse,
+        oldNodeSchemaCount: oldSchema.nodeSchema.size,
+        newNodeSchemaCount: newSchema.nodeSchema.size,
+        addedNodeSchemaCount,
+        removedNodeSchemaCount,
+        rootFieldKindChanged: oldSchema.rootFieldSchema.kind !== newSchema.rootFieldSchema.kind,
+        oldRootAllowedTypeCount: oldSchema.rootFieldSchema.types.size,
+        newRootAllowedTypeCount: newSchema.rootFieldSchema.types.size,
+    };
+}
 /**
  * A helper class that assists {@link TreeCheckout} in preventing functionality from being used while the tree is in the middle of being edited.
  */
 class EditLock {
+    /**
+     * Edits the tree by calling the methods of the editor passed into the {@link EditLock} constructor.
+     * @remarks Edits will throw an error if the lock is currently locked.
+     */
+    editor;
+    /**
+     * The current status of the lock.
+     * The `reason` string will be included in the error message if an attempt is made to edit the tree while the lock is held.
+     */
+    status = { isLocked: false };
     /**
      * @param editor - an editor which will be used to create a new editor that is monitored to determine if any changes are happening to the tree.
      * Use {@link EditLock.editor} in place of the original editor to ensure that changes are monitored.
      */
     constructor(editor) {
-        /**
-         * The current status of the lock.
-         * The `reason` string will be included in the error message if an attempt is made to edit the tree while the lock is held.
-         */
-        this.status = { isLocked: false };
         const checkLock = () => this.checkUnlocked("Editing the tree");
         this.editor = {
             get schema() {
@@ -1288,19 +1367,19 @@ function verboseFromCursor(reader, schema) {
     };
 }
 /**
- * Enumerates through a shared tree change, looking for schema change and field changes that result in visible changes to the tree (e.g. an insert, move, delete).
- * This function also considers changes to detached roots to be visible changes, but not renames of roots or builds of new roots.
+ * Whether the change contains any application-facing changes.
  *
  * @param change - The change to analyze.
- * @returns True if the change contains any schema changes or any field changes that result in visible changes to the tree, false otherwise.
+ * @returns True if the change contains any schema changes or any field changes (either in the document tree or in detached trees), false otherwise.
  */
-function sharedTreeChangeHasVisibleChanges(change) {
+function sharedTreeChangeHasApplicationFacingChanges(change) {
     for (const inner of change.changes) {
         if (inner.type === "schema") {
             return true;
         }
         const delta = intoDelta(tagChange(inner.innerChange, undefined));
-        if (deltaFieldMapHasVisibleChanges(delta.fields)) {
+        const profile = getDeltaChangeProfile(delta);
+        if (profile.hasChangesInDocumentTree || profile.hasChangesInDetachedTrees) {
             return true;
         }
     }