@fluidframework/tree 2.117.0 → 3.0.0

package/src/simple-tree/node-kinds/array/arrayNode.ts

@@ -3,6 +3,10 @@
  * Licensed under the MIT License.
  */
 
+import type {
+	FluidIterableIterator,
+	FluidReadonlyArray,
+} from "@fluidframework/core-interfaces";
 import { Lazy, oob, fail, assert, clamp } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
@@ -23,8 +27,7 @@ import type { NodeSchemaOptionsAlpha, System_Unsafe } from "../../api/index.js";
 import {
 	CompatibilityLevel,
 	type WithType,
-	// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-	typeNameSymbol,
+	schemaIdentifierBrand,
 	NodeKind,
 	type TreeNode,
 	type InternalTreeNode,
@@ -84,7 +87,7 @@ import type {
  * @system @sealed @public
  */
 export interface ReadonlyArrayNode<out T = TreeNode | TreeLeafValue>
-	extends ReadonlyArray<T>,
+	extends FluidReadonlyArray<T>,
 		Awaited<TreeNode & WithType<string, NodeKind.Array>> {}
 
 /**
@@ -463,7 +466,7 @@ export interface TreeArrayNode<
 	/**
 	 * Returns a custom IterableIterator which throws usage errors if concurrent editing and iteration occurs.
 	 */
-	values(): IterableIterator<T>;
+	values(): FluidIterableIterator<T>;
 }
 
 /**
@@ -737,15 +740,15 @@ const TreeNodeWithArrayFeatures = (() => {
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 declare abstract class NodeWithArrayFeatures<Input, T>
 	extends TreeNodeValid<Input>
-	implements Pick<readonly T[], (typeof arrayPrototypeKeys)[number]>
+	implements Pick<FluidReadonlyArray<T>, (typeof arrayPrototypeKeys)[number]>
 {
 	concat(...items: ConcatArray<T>[]): T[];
 	concat(...items: (T | ConcatArray<T>)[]): T[];
-	entries(): IterableIterator<[number, T]>;
+	entries(): FluidIterableIterator<[number, T]>;
 	every<S extends T>(
 		predicate: (value: T, index: number, array: readonly T[]) => value is S,
 		thisArg?: any,
-	): this is readonly S[];
+	): this is FluidReadonlyArray<S>;
 	every(
 		predicate: (value: T, index: number, array: readonly T[]) => unknown,
 		thisArg?: any,
@@ -782,7 +785,7 @@ declare abstract class NodeWithArrayFeatures<Input, T>
 	includes(searchElement: T, fromIndex?: number | undefined): boolean;
 	indexOf(searchElement: T, fromIndex?: number | undefined): number;
 	join(separator?: string | undefined): string;
-	keys(): IterableIterator<number>;
+	keys(): FluidIterableIterator<number>;
 	lastIndexOf(searchElement: T, fromIndex?: number | undefined): number;
 	map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
 	reduce(
@@ -1100,7 +1103,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		return fail(0xadb /* Proxy should intercept length */);
 	}
 
-	public [Symbol.iterator](): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
+	public [Symbol.iterator](): FluidIterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
 		return this.values();
 	}
 
@@ -1398,7 +1401,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		}
 	}
 
-	public values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
+	public values(): FluidIterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
 		return this.generateValues(getKernel(this).generationNumber);
 	}
 	private *generateValues(
@@ -1549,8 +1552,7 @@ export function arraySchema<
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
 			persistedMetadata;
 
-		// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-		public get [typeNameSymbol](): TName {
+		public get [schemaIdentifierBrand](): TName {
 			return identifier;
 		}
 		public get [typeSchemaSymbol](): Output {

package/src/simple-tree/node-kinds/map/mapNode.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import type { FluidReadonlyMap } from "@fluidframework/core-interfaces/internal";
+import type { FluidIterableIterator, FluidReadonlyMap } from "@fluidframework/core-interfaces";
 import { assert, Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
@@ -33,8 +33,7 @@ import {
 	type InnerNode,
 	NodeKind,
 	type TreeNodeSchema,
-	// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-	typeNameSymbol,
+	schemaIdentifierBrand,
 	type TreeNode,
 	typeSchemaSymbol,
 	getInnerNode,
@@ -82,7 +81,7 @@ import type {
  * @sealed @public
  */
 export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTypes>
-	extends ReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>,
+	extends FluidReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>,
 		TreeNode {
 	/**
 	 * Adds or updates an entry in the map with a specified `key` and a `value`.
@@ -118,8 +117,7 @@ export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTyp
 	 * Note: no guarantees are made regarding the order of the keys returned.
 	 * If your usage scenario depends on consistent ordering, you will need to sort these yourself.
 	 */
-	keys(): IterableIterator<string>;
-
+	keys(): FluidIterableIterator<string>;
 	/**
 	 * Returns an iterable of values in the map.
 	 *
@@ -127,7 +125,7 @@ export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTyp
 	 * Note: no guarantees are made regarding the order of the values returned.
 	 * If your usage scenario depends on consistent ordering, you will need to sort these yourself.
 	 */
-	values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>>;
+	values(): FluidIterableIterator<TreeNodeFromImplicitAllowedTypes<T>>;
 
 	/**
 	 * Returns an iterable of key, value pairs for every entry in the map.
@@ -136,7 +134,7 @@ export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTyp
 	 * Note: no guarantees are made regarding the order of the entries returned.
 	 * If your usage scenario depends on consistent ordering, you will need to sort these yourself.
 	 */
-	entries(): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]>;
+	entries(): FluidIterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]>;
 
 	/**
 	 * Executes the provided function once per each key/value pair in this map.
@@ -149,7 +147,7 @@ export interface TreeMapNode<T extends ImplicitAllowedTypes = ImplicitAllowedTyp
 		callbackfn: (
 			value: TreeNodeFromImplicitAllowedTypes<T>,
 			key: string,
-			map: ReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>,
+			map: FluidReadonlyMap<string, TreeNodeFromImplicitAllowedTypes<T>>,
 		) => void,
 		// Typing inherited from `ReadonlyMap`.
 		// eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -309,7 +307,9 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		super(input ?? []);
 	}
 
-	public [Symbol.iterator](): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]> {
+	public [Symbol.iterator](): FluidIterableIterator<
+		[string, TreeNodeFromImplicitAllowedTypes<T>]
+	> {
 		return this.entries();
 	}
 
@@ -326,7 +326,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 		const field = this.innerNode.getBoxed(brand(key));
 		this.editor(key).set(undefined, field.length === 0);
 	}
-	public *entries(): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]> {
+	public *entries(): FluidIterableIterator<[string, TreeNodeFromImplicitAllowedTypes<T>]> {
 		const node = this.innerNode;
 		for (const key of node.keys()) {
 			yield [
@@ -343,7 +343,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 	public has(key: string): boolean {
 		return this.innerNode.tryGetField(brand(key)) !== undefined;
 	}
-	public *keys(): IterableIterator<string> {
+	public *keys(): Generator<string, void, undefined> {
 		const node = this.innerNode;
 		yield* node.keys();
 	}
@@ -395,7 +395,7 @@ abstract class CustomMapNodeBase<const T extends ImplicitAllowedTypes> extends T
 	public get size(): number {
 		return count(this.innerNode.keys());
 	}
-	public *values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
+	public *values(): FluidIterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
 		for (const [, value] of this.entries()) {
 			yield value;
 		}
@@ -506,8 +506,7 @@ export function mapSchema<
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
 			persistedMetadata;
 
-		// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-		public get [typeNameSymbol](): TName {
+		public get [schemaIdentifierBrand](): TName {
 			return identifier;
 		}
 		public get [typeSchemaSymbol](): typeof schemaErased {

package/src/simple-tree/node-kinds/object/objectNode.ts

@@ -32,8 +32,7 @@ import {
 	type TreeNodeSchema,
 	NodeKind,
 	type WithType,
-	// eslint-disable-next-line import-x/no-deprecated -- Required to handle the deprecated typeNameSymbol API.
-	typeNameSymbol,
+	schemaIdentifierBrand,
 	typeSchemaSymbol,
 	type InternalTreeNode,
 	type TreeNode,
@@ -335,8 +334,7 @@ function createProxyHandler(
 			if (propertyKey === typeSchemaSymbol) {
 				return schema;
 			}
-			// eslint-disable-next-line import-x/no-deprecated -- Required to handle the deprecated typeNameSymbol API.
-			if (propertyKey === typeNameSymbol) {
+			if (propertyKey === schemaIdentifierBrand) {
 				return schema.identifier;
 			}
 
@@ -633,8 +631,7 @@ export function objectSchema<
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
 			nodeOptions.persistedMetadata;
 
-		// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-		public get [typeNameSymbol](): TName {
+		public get [schemaIdentifierBrand](): TName {
 			return identifier;
 		}
 		public get [typeSchemaSymbol](): Output {

package/src/simple-tree/node-kinds/record/recordNode.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import type { FluidIterableIterator } from "@fluidframework/core-interfaces";
 import { assert, Lazy } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
@@ -17,8 +18,7 @@ import type { NodeSchemaOptionsAlpha } from "../../api/index.js";
 import {
 	type TreeNodeSchema,
 	NodeKind,
-	// eslint-disable-next-line import-x/no-deprecated -- Required to handle the deprecated typeNameSymbol API.
-	typeNameSymbol,
+	schemaIdentifierBrand,
 	typeSchemaSymbol,
 	type UnhydratedFlexTreeNode,
 	getInnerNode,
@@ -78,8 +78,7 @@ function createRecordNodeProxy(
 					case typeSchemaSymbol: {
 						return schema;
 					}
-					// eslint-disable-next-line import-x/no-deprecated -- Required to handle the deprecated typeNameSymbol API.
-					case typeNameSymbol: {
+					case schemaIdentifierBrand: {
 						return schema.identifier;
 					}
 					case Symbol.iterator: {
@@ -370,15 +369,14 @@ export function recordSchema<
 		public static readonly persistedMetadata: JsonCompatibleReadOnlyObject | undefined =
 			persistedMetadata;
 
-		// eslint-disable-next-line import-x/no-deprecated -- Required to implement the deprecated typeNameSymbol API.
-		public get [typeNameSymbol](): TName {
+		public get [schemaIdentifierBrand](): TName {
 			return identifier;
 		}
 		public get [typeSchemaSymbol](): Output {
 			return Schema.constructorCached?.constructor as unknown as Output;
 		}
 
-		public [Symbol.iterator](): IterableIterator<
+		public [Symbol.iterator](): FluidIterableIterator<
 			[string, TreeNodeFromImplicitAllowedTypes<TAllowedTypes>]
 		> {
 			return recordIterator(this);
@@ -412,7 +410,7 @@ export function recordSchema<
 
 function* recordIterator<TAllowedTypes extends ImplicitAllowedTypes>(
 	record: TreeRecordNode<TAllowedTypes>,
-): IterableIterator<[string, TreeNodeFromImplicitAllowedTypes<TAllowedTypes>]> {
+): FluidIterableIterator<[string, TreeNodeFromImplicitAllowedTypes<TAllowedTypes>]> {
 	for (const [key, value] of Object.entries(record)) {
 		yield [key, value];
 	}

package/src/simple-tree/node-kinds/record/recordNodeTypes.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import type { FluidIterableIterator } from "@fluidframework/core-interfaces";
 import type { RestrictiveStringRecord } from "../../../util/index.js";
 import { NodeKind } from "../../core/index.js";
 import type {
@@ -50,7 +51,7 @@ export interface TreeRecordNode<
 	/**
 	 * Allows the record's entries to be iterated over, including in contexts like `for...of` loops.
 	 */
-	[Symbol.iterator](): IterableIterator<
+	[Symbol.iterator](): FluidIterableIterator<
 		[string, TreeNodeFromImplicitAllowedTypes<TAllowedTypes>]
 	>;
 }

package/src/tableSchema.ts

@@ -629,25 +629,9 @@ export namespace System_TableSchema {
 			}
 
 			public insertColumns(
-				columnsOrParams:
-					| readonly ColumnInsertableType[]
-					| TableSchema.InsertColumnsParameters<TColumnSchema>,
-				maybeIndex?: number,
+				columns: readonly ColumnInsertableType[],
+				index?: number,
 			): ColumnValueType[] {
-				// 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: number | undefined;
-				let columns: readonly ColumnInsertableType[];
-				if (Array.isArray(columnsOrParams)) {
-					index = maybeIndex;
-					columns = columnsOrParams;
-				} else {
-					const params = columnsOrParams as TableSchema.InsertColumnsParameters<TColumnSchema>;
-					index = params.index;
-					columns = params.columns;
-				}
-
 				// #region Input validation
 
 				// Ensure specified index is valid
@@ -692,26 +676,7 @@ export namespace System_TableSchema {
 				return columns as unknown as ColumnValueType[];
 			}
 
-			public insertRows(
-				rowsOrParams:
-					| readonly RowInsertableType[]
-					| TableSchema.InsertRowsParameters<TRowSchema>,
-				maybeIndex?: number,
-			): RowValueType[] {
-				// 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: number | undefined;
-				let rows: readonly RowInsertableType[];
-				if (Array.isArray(rowsOrParams)) {
-					index = maybeIndex;
-					rows = rowsOrParams;
-				} else {
-					const params = rowsOrParams as TableSchema.InsertRowsParameters<TRowSchema>;
-					index = params.index;
-					rows = params.rows;
-				}
-
+			public insertRows(rows: readonly RowInsertableType[], index?: number): RowValueType[] {
 				// #region Input validation
 
 				// Ensure specified index is valid
@@ -755,35 +720,10 @@ export namespace System_TableSchema {
 			}
 
 			public setCell(
-				rowOrParams:
-					| string
-					| number
-					| RowValueType
-					| TableSchema.SetCellParameters<TCellSchema, TColumnSchema, TRowSchema>,
-				maybeColumn?: string | number | ColumnValueType,
-				maybeCell?: CellInsertableType,
+				rowOrId: string | number | RowValueType,
+				columnOrId: string | number | ColumnValueType,
+				cell: CellInsertableType,
 			): void {
-				// 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: string | number | RowValueType;
-				let columnOrId: string | number | ColumnValueType;
-				let cell: CellInsertableType;
-				if (maybeColumn === undefined) {
-					const params = rowOrParams as TableSchema.SetCellParameters<
-						TCellSchema,
-						TColumnSchema,
-						TRowSchema
-					>;
-					rowOrId = params.key.row as string | number | RowValueType;
-					columnOrId = params.key.column as string | number | ColumnValueType;
-					cell = params.cell as CellInsertableType;
-				} else {
-					rowOrId = rowOrParams as string | number | RowValueType;
-					columnOrId = maybeColumn;
-					cell = maybeCell as CellInsertableType;
-				}
-
 				const row = this.#getRow(rowOrId);
 				const column = this.#getColumn(columnOrId);
 
@@ -1009,26 +949,9 @@ export namespace System_TableSchema {
 			}
 
 			public removeCell(
-				rowOrKey:
-					| string
-					| number
-					| RowValueType
-					| TableSchema.CellKey<TColumnSchema, TRowSchema>,
-				maybeColumn?: string | number | ColumnValueType,
+				rowOrIdOrIndex: string | number | RowValueType,
+				columnOrIdOrIndex: string | number | ColumnValueType,
 			): CellValueType | undefined {
-				// 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: string | number | RowValueType;
-				let columnOrIdOrIndex: string | number | ColumnValueType;
-				if (maybeColumn === undefined) {
-					const key = rowOrKey as TableSchema.CellKey<TColumnSchema, TRowSchema>;
-					rowOrIdOrIndex = key.row as string | number | RowValueType;
-					columnOrIdOrIndex = key.column as string | number | ColumnValueType;
-				} else {
-					rowOrIdOrIndex = rowOrKey as string | number | RowValueType;
-					columnOrIdOrIndex = maybeColumn;
-				}
 				const row = this.#getRow(rowOrIdOrIndex) as RowValueInternalType;
 				const column = this.#getColumn(columnOrIdOrIndex);
 
@@ -1893,63 +1816,6 @@ export namespace TableSchema {
 		readonly row: string | number | TreeNodeFromImplicitAllowedTypes<TRow>;
 	}
 
-	/**
-	 * {@link TableSchema.Table.(insertColumns:2)} parameters.
-	 * @input @beta
-	 * @deprecated Use the positional argument overload of {@link TableSchema.Table.(insertColumns:1)} instead.
-	 */
-	export interface InsertColumnsParameters<TColumn extends ImplicitAllowedTypes> {
-		/**
-		 * The index at which to insert the new columns.
-		 * @remarks If not provided, the columns will be appended to the end of the table.
-		 */
-		readonly index?: number | undefined;
-
-		/**
-		 * The columns to insert.
-		 */
-		readonly columns: InsertableTreeNodeFromImplicitAllowedTypes<TColumn>[];
-	}
-
-	/**
-	 * {@link TableSchema.Table.(insertRows:2)} parameters.
-	 * @input @beta
-	 * @deprecated Use the positional argument overload of {@link TableSchema.Table.(insertRows:1)} instead.
-	 */
-	export interface InsertRowsParameters<TRow extends ImplicitAllowedTypes> {
-		/**
-		 * The index at which to insert the new rows.
-		 * @remarks If not provided, the rows will be appended to the end of the table.
-		 */
-		readonly index?: number | undefined;
-
-		/**
-		 * The rows to insert.
-		 */
-		readonly rows: InsertableTreeNodeFromImplicitAllowedTypes<TRow>[];
-	}
-
-	/**
-	 * {@link TableSchema.Table.(setCell:2)} parameters.
-	 * @input @beta
-	 * @deprecated Use the positional argument overload of {@link TableSchema.Table.(setCell:1)} instead.
-	 */
-	export interface SetCellParameters<
-		TCell extends ImplicitAllowedTypes,
-		TColumn extends ImplicitAllowedTypes,
-		TRow extends ImplicitAllowedTypes,
-	> {
-		/**
-		 * The key to uniquely identify a cell in a table.
-		 */
-		readonly key: CellKey<TColumn, TRow>;
-
-		/**
-		 * The cell to set.
-		 */
-		readonly cell: InsertableTreeNodeFromImplicitAllowedTypes<TCell>;
-	}
-
 	/**
 	 * A table.
 	 *
@@ -2029,19 +1895,6 @@ export namespace TableSchema {
 			columns: readonly InsertableTreeNodeFromImplicitAllowedTypes<TColumn>[],
 			index?: number,
 		): TreeNodeFromImplicitAllowedTypes<TColumn>[];
-		/**
-		 * Inserts 0 or more columns into the table.
-		 *
-		 * @throws Throws an error if the specified index is out of range.
-		 *
-		 * No columns are inserted in this case.
-		 *
-		 * @deprecated Use {@link TableSchema.Table.(insertColumns:1)} instead.
-		 */
-		insertColumns(
-			params: InsertColumnsParameters<TColumn>,
-		): TreeNodeFromImplicitAllowedTypes<TColumn>[];
-
 		/**
 		 * Inserts 0 or more rows into the table.
 		 * @param rows - The rows to insert.
@@ -2059,22 +1912,6 @@ export namespace TableSchema {
 			rows: readonly InsertableTreeNodeFromImplicitAllowedTypes<TRow>[],
 			index?: number,
 		): TreeNodeFromImplicitAllowedTypes<TRow>[];
-		/**
-		 * Inserts 0 or more rows into the table.
-		 *
-		 * @throws
-		 * Throws an error in the following cases:
-		 *
-		 * - The row contains cells, but the table does not contain matching columns for one or more of those cells.
-		 *
-		 * - The specified index is out of range.
-		 *
-		 * No rows are inserted in these cases.
-		 *
-		 * @deprecated Use {@link TableSchema.Table.(insertRows:1)} instead.
-		 */
-		insertRows(params: InsertRowsParameters<TRow>): TreeNodeFromImplicitAllowedTypes<TRow>[];
-
 		/**
 		 * Sets the cell at the specified location in the table.
 		 * @param row - The {@link TableSchema.Row}, {@link TableSchema.Row.id}, or row index at which the cell is located.
@@ -2087,13 +1924,6 @@ export namespace TableSchema {
 			column: string | number | TreeNodeFromImplicitAllowedTypes<TColumn>,
 			cell: InsertableTreeNodeFromImplicitAllowedTypes<TCell>,
 		): void;
-		/**
-		 * Sets the cell at the specified location in the table.
-		 * @remarks To remove a cell, call {@link TableSchema.Table.(removeCell:1)} instead.
-		 * @deprecated Use {@link TableSchema.Table.(setCell:1)} instead.
-		 */
-		setCell(params: SetCellParameters<TCell, TColumn, TRow>): void;
-
 		/**
 		 * Removes a range of columns from the table.
 		 *
@@ -2181,15 +2011,6 @@ export namespace TableSchema {
 			row: string | number | TreeNodeFromImplicitAllowedTypes<TRow>,
 			column: string | number | TreeNodeFromImplicitAllowedTypes<TColumn>,
 		): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
-		/**
-		 * Removes the cell at the specified location in the table.
-		 * @returns The cell if it exists, otherwise undefined.
-		 * @throws Throws an error if the location does not exist in the table.
-		 * @deprecated Use {@link TableSchema.Table.(removeCell:1)} instead.
-		 */
-		removeCell(
-			key: CellKey<TColumn, TRow>,
-		): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
 	}
 
 	/**

package/src/text/codePointUtils.ts

@@ -5,6 +5,8 @@
 
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
+import { validateIndex } from "../util/index.js";
+
 /**
  * Returns the number of Unicode code points in `value`.
  * @remarks
@@ -17,8 +19,16 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
  * codePointCount("abc");  // 3
  * codePointCount("a😀b"); // 3 — emoji is one code point, but "a😀b".length === 4 (UTF-16 surrogate pair)
  * ```
+ * @privateRemarks
+ * Users of this are assuming the segmentation of their string exactly matches what our text utils do.
+ * If they are using this to evaluate what they will do, it might be better to just use the text APIs directly, and measure the resulting length.
+ * If measuring what they did, then measuring the length of the resulting character array would likely be better.
+ * In short: using this typically means making an assumption about how data in one of our string arrays is or will be segmented,
+ * which can't always be robust since it's possible to violate our default segmentation policy via round tripping the data and injecting irregular segments.
+ * Additionally, using this likely means you will have problems if/when handling embedded objects.
+ * Therefore we might want to reevaluate the code using this, instead of promoting it to a more stable API surface and encouraging use of it.
  *
- * @internal
+ * @alpha
  */
 export function codePointCount(value: string): number {
 	// Iterate instead of spreading to avoid allocating an intermediate array.
@@ -33,7 +43,7 @@ export function codePointCount(value: string): number {
  * Returns the number of UTF-16 code units occupied by the first `count` Unicode code points in `value`,
  * starting at UTF-16 index `start`.
  * @remarks
- * Use this to translate {@link PlainText}-space counts (code points) into JavaScript string indices (UTF-16).
+ * Use this to translate {@link PlainText} substring lengths (code points) into JavaScript string lengths (UTF-16).
  * One code point outside the Basic Multilingual Plane (e.g. most emoji) occupies two UTF-16 code units.
  *
  * Validates that the requested `count` code points are fully consumable from `start`; silent truncation
@@ -51,31 +61,32 @@ export function codePointCount(value: string): number {
  * @param start - The UTF-16 index in `value` to start measuring from. Must be in `[0, value.length]`.
  * @param count - The number of Unicode code points to measure. Must be non-negative, and there must
  * be at least `count` code points available in `value` starting at `start`.
+ * @returns The number of UTF-16 code units occupied by the requested code points.
  * @throws A {@link @fluidframework/telemetry-utils#UsageError} if `start` is out of range,
  * `count` is negative, or fewer than `count` code points are available from `start`.
- * @internal
+ *
+ * @privateRemarks
+ * See remarks on {@link codePointCount} regarding the stability of this API and its assumptions about string segmentation.
+ *
+ * @alpha
  */
 export function utf16LengthForCodePoints(value: string, start: number, count: number): number {
-	if (start < 0 || start > value.length) {
-		throw new UsageError(
-			`start (${start}) must be within [0, ${value.length}] (value.length).`,
-		);
-	}
+	validateIndex(start, value, "utf16LengthForCodePoints", true);
 	if (count < 0) {
 		throw new UsageError(`count (${count}) must be non-negative.`);
 	}
 	let utf16 = 0;
 	let counted = 0;
-	while (counted < count && start + utf16 < value.length) {
+	while (counted < count) {
+		if (start + utf16 >= value.length) {
+			throw new UsageError(
+				`count (${count}) exceeds the ${counted} code point(s) available from start (${start}) in a value of length ${value.length}.`,
+			);
+		}
 		// Code points above 0xFFFF are encoded in UTF-16 as a surrogate pair (2 units);
 		// everything else takes a single UTF-16 unit.
 		utf16 += (value.codePointAt(start + utf16) ?? 0) > 0xffff ? 2 : 1;
 		counted++;
 	}
-	if (counted !== count) {
-		throw new UsageError(
-			`count (${count}) exceeds the ${counted} code point(s) available from start (${start}) in a value of length ${value.length}.`,
-		);
-	}
 	return utf16;
 }