@fluidframework/tree 2.118.1 → 3.0.1

package/lib/tableSchema.js

@@ -2,7 +2,6 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { __classPrivateFieldGet, __classPrivateFieldSet } from "tslib";
 import { assert, fail, oob } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { EmptyKey } from "./core/index.js";
@@ -137,7 +136,7 @@ export var System_TableSchema;
      */
     // eslint-disable-next-line @typescript-eslint/explicit-function-return-type -- Return type is too complex to be reasonable to specify
     function createTableSchema(inputSchemaFactory, _cellSchema, columnSchema, rowSchema) {
-        var _Table_instances, _a, _Table_rowCache, _Table_rowCacheUnsubscribe, _Table_columnCache, _Table_columnCacheUnsubscribe, _Table_applyEditsInBatch, _Table_buildColumnInDocumentConstraintsForRows, _Table_getColumnCache, _Table_tryGetColumnId, _Table_tryGetColumn, _Table_getColumn, _Table_getRowCache, _Table_tryGetRow, _Table_getRow, _Table_validateNewColumns, _Table_validateNewRows;
+        var _a;
         const schemaFactory = createTableScopedFactory(inputSchemaFactory);
         /**
          * {@link Table} inner fields.
@@ -178,51 +177,6 @@ export var System_TableSchema;
         }) {
             constructor(node) {
                 super(node ?? { table: { columns: [], rows: [] } });
-                _Table_instances.add(this);
-                // #region ID lookup caches
-                // Looking up rows/columns by string ID is a hot path (every getCell / setCell / etc. call goes
-                // through #tryGetRow or #tryGetColumn). Rather than scanning the arrays linearly on every call,
-                // we maintain lazily-built Maps from ID → node.
-                //
-                // Cache invalidation:
-                //   Each cache is marked stale (reset to `undefined`) by a `nodeChanged` listener registered on
-                //   the corresponding array node (this.table.rows / this.table.columns). `nodeChanged` fires on
-                //   an array node whenever an element is inserted, removed, or moved — exactly the set of
-                //   operations that could change which ID maps to which node. The event fires after the full
-                //   batch of edits has been applied (including remote edits received from collaborators), so the
-                //   cache is always rebuilt from a consistent, in-schema state.
-                //   TODO: Consider if we should do more fine-grained invalidation here. E.g. look at the specific deltas
-                //   returned by the `nodeChanged` event and only invalidate entries as needed.
-                //
-                // Listener lifetime:
-                //   The listener is registered exactly once per cache (guarded by the non-undefined check on the
-                //   stored unsubscribe callback).  Subsequent cache rebuilds after invalidation reuse the same
-                //   listener — no additional subscriptions accumulate.  The unsubscribe callback is stored so
-                //   that explicit cleanup is possible in the future if needed.
-                /**
-                 * Cache from row ID → row node for O(1) lookups in {@link Table.#tryGetRow}.
-                 * `undefined` means the cache is stale and must be rebuilt before use.
-                 */
-                _Table_rowCache.set(this, undefined);
-                /**
-                 * Unsubscribe function for the `nodeChanged` listener on `this.table.rows`.
-                 * `undefined` means the listener has not yet been registered (first cache build is pending).
-                 * After the first build, this is always defined and the listener remains active for the
-                 * lifetime of the Table node.
-                 */
-                _Table_rowCacheUnsubscribe.set(this, undefined);
-                /**
-                 * Cache from column ID → column node for O(1) lookups in {@link Table.#tryGetColumn}.
-                 * `undefined` means the cache is stale and must be rebuilt before use.
-                 */
-                _Table_columnCache.set(this, undefined);
-                /**
-                 * Unsubscribe function for the `nodeChanged` listener on `this.table.columns`.
-                 * `undefined` means the listener has not yet been registered (first cache build is pending).
-                 * After the first build, this is always defined and the listener remains active for the
-                 * lifetime of the Table node.
-                 */
-                _Table_columnCacheUnsubscribe.set(this, undefined);
             }
             static create(initialContents) {
                 // #region Input validation
@@ -256,47 +210,33 @@ export var System_TableSchema;
                 return this.table.rows;
             }
             getColumn(indexOrId) {
-                return __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetColumn).call(this, indexOrId);
+                return this.#tryGetColumn(indexOrId);
             }
             getRow(indexOrId) {
-                return __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetRow).call(this, indexOrId);
+                return this.#tryGetRow(indexOrId);
             }
             getCell(key) {
                 const { column: columnOrIdOrIndex, row: rowOrIdOrIndex } = key;
-                const row = __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetRow).call(this, rowOrIdOrIndex);
+                const row = this.#tryGetRow(rowOrIdOrIndex);
                 if (row === undefined) {
                     return undefined;
                 }
-                const columnId = __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetColumnId).call(this, columnOrIdOrIndex);
+                const columnId = this.#tryGetColumnId(columnOrIdOrIndex);
                 if (columnId === undefined) {
                     return undefined;
                 }
                 return row.cells[columnId];
             }
-            insertColumns(columnsOrParams, maybeIndex) {
-                // Dispatch on the runtime type of the first argument to disambiguate the two overloads:
-                //  * Array  → positional `(columns, index?)` overload
-                //  * object → deprecated `(params)` property-bag overload
-                let index;
-                let columns;
-                if (Array.isArray(columnsOrParams)) {
-                    index = maybeIndex;
-                    columns = columnsOrParams;
-                }
-                else {
-                    const params = columnsOrParams;
-                    index = params.index;
-                    columns = params.columns;
-                }
+            insertColumns(columns, index) {
                 // #region Input validation
                 // Ensure specified index is valid
                 if (index !== undefined) {
                     validateIndex(index, this.table.columns, "Table.insertColumns", true);
                 }
                 // Ensure the new columns being inserted are valid
-                __classPrivateFieldGet(this, _Table_instances, "m", _Table_validateNewColumns).call(this, columns);
+                this.#validateNewColumns(columns);
                 // #endregion
-                __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
+                this.#applyEditsInBatch({
                     applyEdits: () => {
                         // TypeScript is unable to narrow the column type correctly here, hence the casts below.
                         // See: https://github.com/microsoft/TypeScript/issues/52144
@@ -327,28 +267,14 @@ export var System_TableSchema;
                 // Inserting the input nodes into the tree hydrates them, making them usable as nodes.
                 return columns;
             }
-            insertRows(rowsOrParams, maybeIndex) {
-                // Dispatch on the runtime type of the first argument to disambiguate the two overloads:
-                //  * Array  → positional `(rows, index?)` overload
-                //  * object → deprecated `(params)` property-bag overload
-                let index;
-                let rows;
-                if (Array.isArray(rowsOrParams)) {
-                    index = maybeIndex;
-                    rows = rowsOrParams;
-                }
-                else {
-                    const params = rowsOrParams;
-                    index = params.index;
-                    rows = params.rows;
-                }
+            insertRows(rows, index) {
                 // #region Input validation
                 // Ensure specified index is valid
                 if (index !== undefined) {
                     validateIndex(index, this.table.rows, "Table.insertRows", true);
                 }
                 // Ensure the new rows being inserted are valid
-                __classPrivateFieldGet(this, _Table_instances, "m", _Table_validateNewRows).call(this, rows);
+                this.#validateNewRows(rows);
                 // #endregion
                 // Relevant invariant: each cell corresponds to an existing row and column.
                 // Prevents cell leaks from concurrently removed columns.
@@ -357,8 +283,8 @@ export var System_TableSchema;
                 // We only need to constrain columns that the new rows actually reference — a removed column with no
                 // corresponding cell in the inserted rows cannot orphan anything from this insertion.
                 // TODO: Replace with "no detach" constraint on the column array when available.
-                const columnConstraints = __classPrivateFieldGet(this, _Table_instances, "m", _Table_buildColumnInDocumentConstraintsForRows).call(this, rows);
-                __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
+                const columnConstraints = this.#buildColumnInDocumentConstraintsForRows(rows);
+                this.#applyEditsInBatch({
                     applyEdits: () => {
                         // TypeScript is unable to narrow the row type correctly here, hence the casts below.
                         // See: https://github.com/microsoft/TypeScript/issues/52144
@@ -376,27 +302,10 @@ export var System_TableSchema;
                 // Inserting the input nodes into the tree hydrates them, making them usable as nodes.
                 return rows;
             }
-            setCell(rowOrParams, maybeColumn, maybeCell) {
-                // Dispatch on the presence of the second argument to disambiguate the two overloads:
-                //  * `maybeColumn === undefined` → deprecated `(params)` property-bag overload; unpack from `params.key`/`params.cell`
-                //  * otherwise                   → positional `(row, column, cell)` overload
-                let rowOrId;
-                let columnOrId;
-                let cell;
-                if (maybeColumn === undefined) {
-                    const params = rowOrParams;
-                    rowOrId = params.key.row;
-                    columnOrId = params.key.column;
-                    cell = params.cell;
-                }
-                else {
-                    rowOrId = rowOrParams;
-                    columnOrId = maybeColumn;
-                    cell = maybeCell;
-                }
-                const row = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getRow).call(this, rowOrId);
-                const column = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumn).call(this, columnOrId);
-                __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
+            setCell(rowOrId, columnOrId, cell) {
+                const row = this.#getRow(rowOrId);
+                const column = this.#getColumn(columnOrId);
+                this.#applyEditsInBatch({
                     applyEdits: () => {
                         row.cells[column.id] = cell;
                     },
@@ -441,7 +350,7 @@ export var System_TableSchema;
                         return [];
                     }
                     validateIndexRange(startIndex, endIndex, this.table.columns, "Table.removeColumns");
-                    __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
+                    this.#applyEditsInBatch({
                         applyEdits: () => {
                             const columnsToRemove = this.table.columns.slice(startIndex, endIndex);
                             // First, remove all cells that correspond to each column from each row.
@@ -475,14 +384,14 @@ export var System_TableSchema;
                     // expected by both the cell-deletion loop and the returned array.
                     const columnsToRemove = new Set();
                     for (const columnOrIdToRemove of indexOrColumns) {
-                        columnsToRemove.add(__classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumn).call(this, columnOrIdToRemove));
+                        columnsToRemove.add(this.#getColumn(columnOrIdToRemove));
                     }
                     // Collect contiguous runs of columns-to-remove as [start, end) ranges so they can be
                     // removed via a small number of `removeRange` calls below.
                     const ranges = collectContiguousRanges(this.table.columns, (column) => columnsToRemove.has(column));
                     // Note, throwing an error within a transaction will abort the entire transaction.
                     // So if we throw an error here for any column, no columns will be removed.
-                    __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
+                    this.#applyEditsInBatch({
                         applyEdits: () => {
                             // Remove the corresponding cell from every row.
                             // The per-column `id` values are hoisted out of the row loop so each row's `cells`
@@ -519,7 +428,7 @@ export var System_TableSchema;
                     validateIndexRange(startIndex, endIndex, this.table.rows, "Table.removeRows");
                     // Compute revert constraints from the rows being removed.
                     const rowsBeingRemoved = this.table.rows.slice(startIndex, endIndex);
-                    __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
+                    this.#applyEditsInBatch({
                         applyEdits: () => {
                             removedRows = removeRangeFromArray(startIndex, endIndex, this.table.rows, "Table.removeRows");
                         },
@@ -528,7 +437,7 @@ export var System_TableSchema;
                         // each column referenced by those cells to still exist. Columns the removed rows
                         // don't reference cannot be orphaned by the revert and need not be constrained.
                         // TODO: Replace with "no detach on revert" constraint on the column array when available.
-                        preconditionsOnRevert: __classPrivateFieldGet(this, _Table_instances, "m", _Table_buildColumnInDocumentConstraintsForRows).call(this, rowsBeingRemoved),
+                        preconditionsOnRevert: this.#buildColumnInDocumentConstraintsForRows(rowsBeingRemoved),
                     });
                     return removedRows ?? fail(0xccd /* Transaction did not complete */);
                 }
@@ -543,14 +452,14 @@ export var System_TableSchema;
                 // expected by the returned array.
                 const rowsToRemove = new Set();
                 for (const rowToRemove of indexOrRows) {
-                    rowsToRemove.add(__classPrivateFieldGet(this, _Table_instances, "m", _Table_getRow).call(this, rowToRemove));
+                    rowsToRemove.add(this.#getRow(rowToRemove));
                 }
                 // Collect contiguous runs of rows-to-remove as [start, end) ranges so they can be
                 // removed via a small number of `removeRange` calls below.
                 const ranges = collectContiguousRanges(this.table.rows, (row) => rowsToRemove.has(row));
                 // Note, throwing an error within a transaction will abort the entire transaction.
                 // So if we throw an error here for any row, no rows will be removed.
-                __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
+                this.#applyEditsInBatch({
                     applyEdits: () => {
                         // Ranges are iterated in reverse so each `removeRange` call doesn't shift
                         // the indices of yet-to-remove ranges at lower positions.
@@ -564,32 +473,18 @@ export var System_TableSchema;
                     // each column referenced by those cells to still exist. Columns the removed rows
                     // don't reference cannot be orphaned by the revert and need not be constrained.
                     // TODO: Replace with "no detach on revert" constraint on the column array when available.
-                    preconditionsOnRevert: __classPrivateFieldGet(this, _Table_instances, "m", _Table_buildColumnInDocumentConstraintsForRows).call(this, rowsToRemove),
+                    preconditionsOnRevert: this.#buildColumnInDocumentConstraintsForRows(rowsToRemove),
                 });
                 return [...rowsToRemove];
             }
-            removeCell(rowOrKey, maybeColumn) {
-                // Dispatch on the presence of the second argument to disambiguate the two overloads:
-                //  * `maybeColumn === undefined` → deprecated `(key)` overload; unpack from `key.row`/`key.column`
-                //  * otherwise                   → positional `(row, column)` overload
-                let rowOrIdOrIndex;
-                let columnOrIdOrIndex;
-                if (maybeColumn === undefined) {
-                    const key = rowOrKey;
-                    rowOrIdOrIndex = key.row;
-                    columnOrIdOrIndex = key.column;
-                }
-                else {
-                    rowOrIdOrIndex = rowOrKey;
-                    columnOrIdOrIndex = maybeColumn;
-                }
-                const row = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getRow).call(this, rowOrIdOrIndex);
-                const column = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumn).call(this, columnOrIdOrIndex);
+            removeCell(rowOrIdOrIndex, columnOrIdOrIndex) {
+                const row = this.#getRow(rowOrIdOrIndex);
+                const column = this.#getColumn(columnOrIdOrIndex);
                 const cell = row.cells[column.id];
                 if (cell === undefined) {
                     return undefined;
                 }
-                __classPrivateFieldGet(this, _Table_instances, "m", _Table_applyEditsInBatch).call(this, {
+                this.#applyEditsInBatch({
                     applyEdits: () => {
                         // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- This is currently how Record node entries are deleted.
                         delete row.cells[column.id];
@@ -603,6 +498,203 @@ export var System_TableSchema;
                 });
                 return cell;
             }
+            // #region ID lookup caches
+            // Looking up rows/columns by string ID is a hot path (every getCell / setCell / etc. call goes
+            // through #tryGetRow or #tryGetColumn). Rather than scanning the arrays linearly on every call,
+            // we maintain lazily-built Maps from ID → node.
+            //
+            // Cache invalidation:
+            //   Each cache is marked stale (reset to `undefined`) by a `nodeChanged` listener registered on
+            //   the corresponding array node (this.table.rows / this.table.columns). `nodeChanged` fires on
+            //   an array node whenever an element is inserted, removed, or moved — exactly the set of
+            //   operations that could change which ID maps to which node. The event fires after the full
+            //   batch of edits has been applied (including remote edits received from collaborators), so the
+            //   cache is always rebuilt from a consistent, in-schema state.
+            //   TODO: Consider if we should do more fine-grained invalidation here. E.g. look at the specific deltas
+            //   returned by the `nodeChanged` event and only invalidate entries as needed.
+            //
+            // Listener lifetime:
+            //   The listener is registered exactly once per cache (guarded by the non-undefined check on the
+            //   stored unsubscribe callback).  Subsequent cache rebuilds after invalidation reuse the same
+            //   listener — no additional subscriptions accumulate.  The unsubscribe callback is stored so
+            //   that explicit cleanup is possible in the future if needed.
+            /**
+             * Cache from row ID → row node for O(1) lookups in {@link Table.#tryGetRow}.
+             * `undefined` means the cache is stale and must be rebuilt before use.
+             */
+            #rowCache = undefined;
+            /**
+             * Unsubscribe function for the `nodeChanged` listener on `this.table.rows`.
+             * `undefined` means the listener has not yet been registered (first cache build is pending).
+             * After the first build, this is always defined and the listener remains active for the
+             * lifetime of the Table node.
+             */
+            #rowCacheUnsubscribe = undefined;
+            /**
+             * Cache from column ID → column node for O(1) lookups in {@link Table.#tryGetColumn}.
+             * `undefined` means the cache is stale and must be rebuilt before use.
+             */
+            #columnCache = undefined;
+            /**
+             * Unsubscribe function for the `nodeChanged` listener on `this.table.columns`.
+             * `undefined` means the listener has not yet been registered (first cache build is pending).
+             * After the first build, this is always defined and the listener remains active for the
+             * lifetime of the Table node.
+             */
+            #columnCacheUnsubscribe = undefined;
+            // #endregion
+            /**
+             * Applies the provided edits in a "batch".
+             *
+             * @remarks
+             * For hydrated trees, this will be done in a transaction to ensure atomicity.
+             *
+             * Transactions are not supported for unhydrated trees, so we cannot run a transaction in that case.
+             * But since there are no collaborators, this is not an issue.
+             */
+            #applyEditsInBatch(options) {
+                const { applyEdits, preconditions, preconditionsOnRevert } = options;
+                const context = TreeAlpha.context(this);
+                // Ensure events are paused until all of the edits are applied.
+                // This ensures that the user sees the corresponding table-level edit as atomic,
+                // and ensures they are not spammed with intermediate events.
+                withBufferedTreeEvents(() => {
+                    if (context.isView()) {
+                        context.runTransaction(() => {
+                            applyEdits();
+                            if (preconditionsOnRevert !== undefined) {
+                                return { preconditionsOnRevert };
+                            }
+                        }, preconditions === undefined ? undefined : { preconditions });
+                    }
+                    else {
+                        // If this node does not have a corresponding view, then it is unhydrated.
+                        // I.e., it is not part of a collaborative session yet.
+                        // Therefore, we don't need to run the edits as a transaction.
+                        applyEdits();
+                    }
+                });
+            }
+            /**
+             * Builds an array of `nodeInDocument` constraints over each column referenced by a cell
+             * in any of `rows`.
+             *
+             * @remarks
+             * The orphan-cell invariant only cares about columns that have cells in the affected rows;
+             * columns absent from those rows' cells have no cell to orphan, so they need not be
+             * constrained. This keeps the constraint set proportional to the cells touched rather than
+             * the total column count, which matters for sparse tables.
+             *
+             * Returns `undefined` when:
+             * - The table is unhydrated (no transaction will run), or
+             * - None of `rows` reference any cells.
+             *
+             * In those cases there is nothing to constrain, and returning `undefined` avoids
+             * allocating an array that would only be discarded.
+             */
+            #buildColumnInDocumentConstraintsForRows(rows) {
+                if (!TreeAlpha.context(this).isView()) {
+                    return undefined;
+                }
+                const referencedColumnIds = new Set();
+                for (const row of rows) {
+                    // `cells` is intentionally hidden on the public row type, so cast to read it.
+                    const cells = row.cells;
+                    if (cells === undefined) {
+                        continue;
+                    }
+                    for (const id of Object.keys(cells)) {
+                        referencedColumnIds.add(id);
+                    }
+                }
+                if (referencedColumnIds.size === 0) {
+                    return undefined;
+                }
+                const columnCache = this.#getColumnCache();
+                const constraints = [];
+                for (const id of referencedColumnIds) {
+                    const column = columnCache.get(id) ?? fail(0xd05 /* Column ID not found in cache */);
+                    constraints.push({ type: "nodeInDocument", node: column });
+                }
+                assert(constraints.length > 0, 0xd06 /* No constraints generated for column references. */);
+                return constraints;
+            }
+            /**
+             * Returns the column ID → column node cache, building and caching it first if stale.
+             *
+             * @remarks
+             * The first time this is called, it builds the map from the current contents of
+             * `this.table.columns` and registers a `nodeChanged` listener on that array.
+             * The listener invalidates the cache (sets `#columnCache` to `undefined`) whenever
+             * the column array is structurally modified (insert / remove / move), so every
+             * subsequent call that follows a structural change automatically triggers a rebuild.
+             * The listener is registered only once — it is not re-registered on cache rebuilds.
+             */
+            #getColumnCache() {
+                let cache = this.#columnCache;
+                if (cache === undefined) {
+                    cache = new Map();
+                    for (const column of this.table.columns) {
+                        // TypeScript is unable to narrow array element types correctly here.
+                        // See: https://github.com/microsoft/TypeScript/issues/52144
+                        cache.set(column.id, column);
+                    }
+                    this.#columnCache = cache;
+                    // Register the invalidation listener once. The `nodeChanged` event fires on the
+                    // array node itself after any structural change (insert / remove / move), which is
+                    // exactly the set of changes that can alter the ID → node mapping.
+                    if (this.#columnCacheUnsubscribe === undefined) {
+                        this.#columnCacheUnsubscribe = Tree.on(this.columns, "nodeChanged", () => {
+                            this.#columnCache = undefined;
+                        });
+                    }
+                }
+                return cache;
+            }
+            /**
+             * Attempts to resolve the provided Column node, ID, or index to the corresponding Column ID.
+             * Returns `undefined` if there is no match.
+             */
+            #tryGetColumnId(columnOrIdOrIndex) {
+                if (typeof columnOrIdOrIndex === "string") {
+                    return columnOrIdOrIndex;
+                }
+                return this.#tryGetColumn(columnOrIdOrIndex)?.id;
+            }
+            /**
+             * Attempts to resolve the provided Column node or ID to a Column node in the table.
+             * Returns `undefined` if there is no match.
+             * @remarks Searches for a match based strictly on the ID and returns that result.
+             */
+            #tryGetColumn(columnOrIdOrIndex) {
+                if (typeof columnOrIdOrIndex === "number") {
+                    if (columnOrIdOrIndex < 0 || columnOrIdOrIndex >= this.table.columns.length) {
+                        return undefined;
+                    }
+                    // TypeScript is unable to narrow the types correctly here, hence the cast.
+                    // See: https://github.com/microsoft/TypeScript/issues/52144
+                    return this.table.columns[columnOrIdOrIndex];
+                }
+                const columnCache = this.#getColumnCache();
+                if (typeof columnOrIdOrIndex === "string") {
+                    return columnCache.get(columnOrIdOrIndex);
+                }
+                // If the user provided a node, ensure it actually exists in this table.
+                const cached = columnCache.get(columnOrIdOrIndex.id);
+                return cached === columnOrIdOrIndex ? columnOrIdOrIndex : undefined;
+            }
+            /**
+             * Attempts to resolve the provided Column node or ID to a Column node in the table.
+             * @throws Throws a `UsageError` if there is no match.
+             * @remarks Searches for a match based strictly on the ID and returns that result.
+             */
+            #getColumn(columnOrIdOrIndex) {
+                const column = this.#tryGetColumn(columnOrIdOrIndex);
+                if (column === undefined) {
+                    _a._throwMissingColumnError(columnOrIdOrIndex);
+                }
+                return column;
+            }
             /**
              * Throw a `UsageError` for a missing Column by its ID or index.
              */
@@ -615,6 +707,89 @@ export var System_TableSchema;
                 }
                 throw new UsageError(`The specified column node with ID "${columnOrIdOrIndex.id}" does not exist in the table.`);
             }
+            /**
+             * Returns the row ID → row node cache, building and caching it first if stale.
+             *
+             * @remarks
+             * The first time this is called, it builds the map from the current contents of
+             * `this.table.rows` and registers a `nodeChanged` listener on that array.
+             * The listener invalidates the cache (sets `#rowCache` to `undefined`) whenever
+             * the row array is structurally modified (insert / remove / move), so every
+             * subsequent call that follows a structural change automatically triggers a rebuild.
+             * The listener is registered only once — it is not re-registered on cache rebuilds.
+             */
+            #getRowCache() {
+                let cache = this.#rowCache;
+                if (cache === undefined) {
+                    cache = new Map();
+                    for (const row of this.table.rows) {
+                        // TypeScript is unable to narrow array element types correctly here.
+                        // See: https://github.com/microsoft/TypeScript/issues/52144
+                        cache.set(row.id, row);
+                    }
+                    this.#rowCache = cache;
+                    // Register the invalidation listener once. The `nodeChanged` event fires on the
+                    // array node itself after any structural change (insert / remove / move), which is
+                    // exactly the set of changes that can alter the ID → node mapping.
+                    if (this.#rowCacheUnsubscribe === undefined) {
+                        this.#rowCacheUnsubscribe = Tree.on(this.rows, "nodeChanged", () => {
+                            this.#rowCache = undefined;
+                        });
+                    }
+                }
+                return cache;
+            }
+            /**
+             * Attempts to resolve the provided Row node or ID to a Row node in the table.
+             * Returns `undefined` if there is no match.
+             * @remarks Searches for a match based strictly on the ID and returns that result.
+             */
+            #tryGetRow(rowOrIdOrIndex) {
+                if (typeof rowOrIdOrIndex === "number") {
+                    if (rowOrIdOrIndex < 0 || rowOrIdOrIndex >= this.table.rows.length) {
+                        return undefined;
+                    }
+                    // TypeScript is unable to narrow the types correctly here, hence the cast.
+                    // See: https://github.com/microsoft/TypeScript/issues/52144
+                    return this.table.rows[rowOrIdOrIndex];
+                }
+                const rowCache = this.#getRowCache();
+                if (typeof rowOrIdOrIndex === "string") {
+                    return rowCache.get(rowOrIdOrIndex);
+                }
+                // If the user provided a node, ensure it actually exists in this table.
+                const cached = rowCache.get(rowOrIdOrIndex.id);
+                return cached === rowOrIdOrIndex ? rowOrIdOrIndex : undefined;
+            }
+            /**
+             * Attempts to resolve the provided Row node, ID, or index to a Row node in the table.
+             * @throws Throws a `UsageError` if there is no match.
+             * @remarks Searches for a match based strictly on the ID and returns that result.
+             */
+            #getRow(rowOrIdOrIndex) {
+                const row = this.#tryGetRow(rowOrIdOrIndex);
+                if (row === undefined) {
+                    _a._throwMissingRowError(rowOrIdOrIndex);
+                }
+                return row;
+            }
+            /**
+             * Validates the provided list of new columns being inserted into the table.
+             * @throws Throws a `UsageError` if any of the following conditions are met:
+             * - A column with a duplicate ID is being inserted.
+             */
+            #validateNewColumns(newColumns) {
+                return _a._validateNewColumns(newColumns, this.#getColumnCache());
+            }
+            /**
+             * Validates the provided list of new rows being inserted into the table.
+             * @throws Throws a `UsageError` if any of the following conditions are met:
+             * - A row with a duplicate ID is being inserted.
+             * - A row is being inserted that contains cells for columns that do not exist in the table.
+             */
+            #validateNewRows(newRows) {
+                return _a._validateNewRows(newRows, this.#getRowCache(), this.#getColumnCache());
+            }
             /**
              * Validates the provided list of new columns being inserted into the table.
              * @throws Throws a `UsageError` if any of the following conditions are met:
@@ -680,148 +855,7 @@ export var System_TableSchema;
                 throw new UsageError(`The specified row node with ID "${rowOrIdOrIndex.id}" does not exist in the table.`);
             }
         }
-        _a = Table, _Table_rowCache = new WeakMap(), _Table_rowCacheUnsubscribe = new WeakMap(), _Table_columnCache = new WeakMap(), _Table_columnCacheUnsubscribe = new WeakMap(), _Table_instances = new WeakSet(), _Table_applyEditsInBatch = function _Table_applyEditsInBatch(options) {
-            const { applyEdits, preconditions, preconditionsOnRevert } = options;
-            const context = TreeAlpha.context(this);
-            // Ensure events are paused until all of the edits are applied.
-            // This ensures that the user sees the corresponding table-level edit as atomic,
-            // and ensures they are not spammed with intermediate events.
-            withBufferedTreeEvents(() => {
-                if (context.isView()) {
-                    context.runTransaction(() => {
-                        applyEdits();
-                        if (preconditionsOnRevert !== undefined) {
-                            return { preconditionsOnRevert };
-                        }
-                    }, preconditions === undefined ? undefined : { preconditions });
-                }
-                else {
-                    // If this node does not have a corresponding view, then it is unhydrated.
-                    // I.e., it is not part of a collaborative session yet.
-                    // Therefore, we don't need to run the edits as a transaction.
-                    applyEdits();
-                }
-            });
-        }, _Table_buildColumnInDocumentConstraintsForRows = function _Table_buildColumnInDocumentConstraintsForRows(rows) {
-            if (!TreeAlpha.context(this).isView()) {
-                return undefined;
-            }
-            const referencedColumnIds = new Set();
-            for (const row of rows) {
-                // `cells` is intentionally hidden on the public row type, so cast to read it.
-                const cells = row.cells;
-                if (cells === undefined) {
-                    continue;
-                }
-                for (const id of Object.keys(cells)) {
-                    referencedColumnIds.add(id);
-                }
-            }
-            if (referencedColumnIds.size === 0) {
-                return undefined;
-            }
-            const columnCache = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumnCache).call(this);
-            const constraints = [];
-            for (const id of referencedColumnIds) {
-                const column = columnCache.get(id) ?? fail(0xd05 /* Column ID not found in cache */);
-                constraints.push({ type: "nodeInDocument", node: column });
-            }
-            assert(constraints.length > 0, 0xd06 /* No constraints generated for column references. */);
-            return constraints;
-        }, _Table_getColumnCache = function _Table_getColumnCache() {
-            let cache = __classPrivateFieldGet(this, _Table_columnCache, "f");
-            if (cache === undefined) {
-                cache = new Map();
-                for (const column of this.table.columns) {
-                    // TypeScript is unable to narrow array element types correctly here.
-                    // See: https://github.com/microsoft/TypeScript/issues/52144
-                    cache.set(column.id, column);
-                }
-                __classPrivateFieldSet(this, _Table_columnCache, cache, "f");
-                // Register the invalidation listener once. The `nodeChanged` event fires on the
-                // array node itself after any structural change (insert / remove / move), which is
-                // exactly the set of changes that can alter the ID → node mapping.
-                if (__classPrivateFieldGet(this, _Table_columnCacheUnsubscribe, "f") === undefined) {
-                    __classPrivateFieldSet(this, _Table_columnCacheUnsubscribe, Tree.on(this.columns, "nodeChanged", () => {
-                        __classPrivateFieldSet(this, _Table_columnCache, undefined, "f");
-                    }), "f");
-                }
-            }
-            return cache;
-        }, _Table_tryGetColumnId = function _Table_tryGetColumnId(columnOrIdOrIndex) {
-            if (typeof columnOrIdOrIndex === "string") {
-                return columnOrIdOrIndex;
-            }
-            return __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetColumn).call(this, columnOrIdOrIndex)?.id;
-        }, _Table_tryGetColumn = function _Table_tryGetColumn(columnOrIdOrIndex) {
-            if (typeof columnOrIdOrIndex === "number") {
-                if (columnOrIdOrIndex < 0 || columnOrIdOrIndex >= this.table.columns.length) {
-                    return undefined;
-                }
-                // TypeScript is unable to narrow the types correctly here, hence the cast.
-                // See: https://github.com/microsoft/TypeScript/issues/52144
-                return this.table.columns[columnOrIdOrIndex];
-            }
-            const columnCache = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumnCache).call(this);
-            if (typeof columnOrIdOrIndex === "string") {
-                return columnCache.get(columnOrIdOrIndex);
-            }
-            // If the user provided a node, ensure it actually exists in this table.
-            const cached = columnCache.get(columnOrIdOrIndex.id);
-            return cached === columnOrIdOrIndex ? columnOrIdOrIndex : undefined;
-        }, _Table_getColumn = function _Table_getColumn(columnOrIdOrIndex) {
-            const column = __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetColumn).call(this, columnOrIdOrIndex);
-            if (column === undefined) {
-                _a._throwMissingColumnError(columnOrIdOrIndex);
-            }
-            return column;
-        }, _Table_getRowCache = function _Table_getRowCache() {
-            let cache = __classPrivateFieldGet(this, _Table_rowCache, "f");
-            if (cache === undefined) {
-                cache = new Map();
-                for (const row of this.table.rows) {
-                    // TypeScript is unable to narrow array element types correctly here.
-                    // See: https://github.com/microsoft/TypeScript/issues/52144
-                    cache.set(row.id, row);
-                }
-                __classPrivateFieldSet(this, _Table_rowCache, cache, "f");
-                // Register the invalidation listener once. The `nodeChanged` event fires on the
-                // array node itself after any structural change (insert / remove / move), which is
-                // exactly the set of changes that can alter the ID → node mapping.
-                if (__classPrivateFieldGet(this, _Table_rowCacheUnsubscribe, "f") === undefined) {
-                    __classPrivateFieldSet(this, _Table_rowCacheUnsubscribe, Tree.on(this.rows, "nodeChanged", () => {
-                        __classPrivateFieldSet(this, _Table_rowCache, undefined, "f");
-                    }), "f");
-                }
-            }
-            return cache;
-        }, _Table_tryGetRow = function _Table_tryGetRow(rowOrIdOrIndex) {
-            if (typeof rowOrIdOrIndex === "number") {
-                if (rowOrIdOrIndex < 0 || rowOrIdOrIndex >= this.table.rows.length) {
-                    return undefined;
-                }
-                // TypeScript is unable to narrow the types correctly here, hence the cast.
-                // See: https://github.com/microsoft/TypeScript/issues/52144
-                return this.table.rows[rowOrIdOrIndex];
-            }
-            const rowCache = __classPrivateFieldGet(this, _Table_instances, "m", _Table_getRowCache).call(this);
-            if (typeof rowOrIdOrIndex === "string") {
-                return rowCache.get(rowOrIdOrIndex);
-            }
-            // If the user provided a node, ensure it actually exists in this table.
-            const cached = rowCache.get(rowOrIdOrIndex.id);
-            return cached === rowOrIdOrIndex ? rowOrIdOrIndex : undefined;
-        }, _Table_getRow = function _Table_getRow(rowOrIdOrIndex) {
-            const row = __classPrivateFieldGet(this, _Table_instances, "m", _Table_tryGetRow).call(this, rowOrIdOrIndex);
-            if (row === undefined) {
-                _a._throwMissingRowError(rowOrIdOrIndex);
-            }
-            return row;
-        }, _Table_validateNewColumns = function _Table_validateNewColumns(newColumns) {
-            return _a._validateNewColumns(newColumns, __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumnCache).call(this));
-        }, _Table_validateNewRows = function _Table_validateNewRows(newRows) {
-            return _a._validateNewRows(newRows, __classPrivateFieldGet(this, _Table_instances, "m", _Table_getRowCache).call(this), __classPrivateFieldGet(this, _Table_instances, "m", _Table_getColumnCache).call(this));
-        };
+        _a = Table;
         // Returning SingletonSchema without a type conversion results in TypeScript generating something like `readonly "__#124291@#brand": unknown;`
         // for the private brand field of TreeNode.
         // This numeric id doesn't seem to be stable over incremental builds, and thus causes diffs in the API extractor reports.