@fluidframework/tree 2.43.0-343119 → 2.50.0-345060

package/src/simple-tree/schemaTypes.ts

@@ -32,8 +32,10 @@ import type {
 	TreeNodeSchemaCore,
 	TreeNodeSchemaNonClass,
 	UnhydratedFlexTreeNode,
+	AnnotatedAllowedType,
+	NormalizedAnnotatedAllowedTypes,
 } from "./core/index.js";
-import { inPrototypeChain } from "./core/index.js";
+import { inPrototypeChain, isAnnotatedAllowedTypes } from "./core/index.js";
 import { isLazy, type FlexListToUnion, type LazyItem } from "./flexList.js";
 import { LeafNodeSchema } from "./leafNodeSchema.js";
 import type { SimpleFieldSchema, SimpleObjectFieldSchema } from "./simpleSchema.js";
@@ -106,17 +108,6 @@ export interface AnnotatedAllowedTypes {
 	readonly types: readonly (AnnotatedAllowedType | LazyItem<TreeNodeSchema>)[];
 }
 
-/**
- * Checks if the input is an {@link AnnotatedAllowedTypes}.
- */
-export function isAnnotatedAllowedTypes(
-	allowedTypes: ImplicitAnnotatedAllowedTypes,
-): allowedTypes is AnnotatedAllowedTypes {
-	return (
-		typeof allowedTypes === "object" && "metadata" in allowedTypes && "types" in allowedTypes
-	);
-}
-
 /**
  * Annotations that apply to a set of allowed types.
  * @remarks
@@ -130,21 +121,6 @@ export interface AllowedTypesMetadata {
 	readonly custom?: unknown;
 }
 
-/**
- * Stores annotations for an individual allowed type.
- * @alpha
- */
-export interface AnnotatedAllowedType<T extends TreeNodeSchema = TreeNodeSchema> {
-	/**
-	 * Annotations for the allowed type.
-	 */
-	readonly metadata: AllowedTypeMetadata;
-	/**
-	 * The allowed type the annotations apply to in a particular schema.
-	 */
-	readonly type: LazyItem<T>;
-}
-
 /**
  * Checks if the given allowed type is annotated with {@link AllowedTypeMetadata}.
  */
@@ -207,7 +183,10 @@ export enum FieldKind {
  * If an explicit stored key was specified in the schema, it will be used.
  * Otherwise, the stored key is the same as the property key.
  */
-export function getStoredKey(propertyKey: string, fieldSchema: ImplicitFieldSchema): FieldKey {
+export function getStoredKey(
+	propertyKey: string,
+	fieldSchema: ImplicitAnnotatedFieldSchema,
+): FieldKey {
 	return brand(getExplicitStoredKey(fieldSchema) ?? propertyKey);
 }
 
@@ -215,7 +194,9 @@ export function getStoredKey(propertyKey: string, fieldSchema: ImplicitFieldSche
  * Gets the {@link FieldProps.key | stored key} specified by the schema, if one was explicitly specified.
  * Otherwise, returns undefined.
  */
-export function getExplicitStoredKey(fieldSchema: ImplicitFieldSchema): string | undefined {
+export function getExplicitStoredKey(
+	fieldSchema: ImplicitAnnotatedFieldSchema,
+): string | undefined {
 	return fieldSchema instanceof FieldSchema ? fieldSchema.props?.key : undefined;
 }
 
@@ -541,7 +522,7 @@ export class FieldSchemaAlpha<
 	implements SimpleFieldSchema
 {
 	private readonly lazyIdentifiers: Lazy<ReadonlySet<string>>;
-	private readonly lazyAnnotatedTypes: Lazy<ReadonlyMap<TreeNodeSchema, AllowedTypeMetadata>>;
+	private readonly lazyAnnotatedTypes: Lazy<NormalizedAnnotatedAllowedTypes>;
 	private readonly propsAlpha: FieldPropsAlpha<TCustomMetadata> | undefined;
 
 	/**
@@ -586,7 +567,7 @@ export class FieldSchemaAlpha<
 			? annotatedAllowedTypes.metadata
 			: {};
 		this.lazyAnnotatedTypes = new Lazy(() =>
-			extractAnnotationsFromAllowedTypes(this.annotatedAllowedTypes),
+			normalizeAnnotatedAllowedTypes(annotatedAllowedTypes),
 		);
 		this.lazyIdentifiers = new Lazy(
 			() => new Set([...this.allowedTypeSet].map((t) => t.identifier)),
@@ -602,7 +583,7 @@ export class FieldSchemaAlpha<
 	 * What types of tree nodes are allowed in this field and their annotations.
 	 * @remarks Counterpart to {@link FieldSchemaAlpha.annotatedAllowedTypes}, with any lazy definitions evaluated.
 	 */
-	public get annotatedAllowedTypeSet(): ReadonlyMap<TreeNodeSchema, AllowedTypeMetadata> {
+	public get annotatedAllowedTypesNormalized(): NormalizedAnnotatedAllowedTypes {
 		return this.lazyAnnotatedTypes.value;
 	}
 }
@@ -671,8 +652,8 @@ export function normalizeAllowedTypes(
  * Normalizes an allowed type to an {@link AnnotatedAllowedType}, by adding empty annotations if they don't already exist.
  */
 export function normalizeToAnnotatedAllowedType<T extends TreeNodeSchema>(
-	type: T | AnnotatedAllowedType<T>,
-): AnnotatedAllowedType<T> {
+	type: T | AnnotatedAllowedType<T> | AnnotatedAllowedType<LazyItem<T>>,
+): AnnotatedAllowedType<T> | AnnotatedAllowedType<LazyItem<T>> {
 	return isAnnotatedAllowedType(type)
 		? type
 		: {
@@ -681,6 +662,46 @@ export function normalizeToAnnotatedAllowedType<T extends TreeNodeSchema>(
 			};
 }
 
+/**
+ * Normalizes a {@link ImplicitAnnotatedAllowedTypes} to a set of {@link AnnotatedAllowedSchema}s, by eagerly evaluating any
+ * lazy schema declarations and adding empty metadata if it doesn't already exist.
+ *
+ * @remarks Note: this must only be called after all required schemas have been declared, otherwise evaluation of
+ * recursive schemas may fail.
+ */
+export function normalizeAnnotatedAllowedTypes(
+	types: ImplicitAnnotatedAllowedTypes,
+): NormalizedAnnotatedAllowedTypes {
+	const typesWithoutAnnotation = isAnnotatedAllowedTypes(types) ? types.types : types;
+	const annotatedTypes: AnnotatedAllowedType<TreeNodeSchema>[] = [];
+	if (isReadonlyArray(typesWithoutAnnotation)) {
+		for (const annotatedType of typesWithoutAnnotation) {
+			if (isAnnotatedAllowedType(annotatedType)) {
+				annotatedTypes.push({
+					type: evaluateLazySchema(annotatedType.type),
+					metadata: annotatedType.metadata,
+				});
+			} else {
+				annotatedTypes.push({ type: evaluateLazySchema(annotatedType), metadata: {} });
+			}
+		}
+	} else {
+		if (isAnnotatedAllowedType(typesWithoutAnnotation)) {
+			annotatedTypes.push({
+				type: evaluateLazySchema(typesWithoutAnnotation.type),
+				metadata: typesWithoutAnnotation.metadata,
+			});
+		} else {
+			annotatedTypes.push({ type: evaluateLazySchema(typesWithoutAnnotation), metadata: {} });
+		}
+	}
+
+	return {
+		metadata: isAnnotatedAllowedTypes(types) ? types.metadata : {},
+		types: annotatedTypes,
+	};
+}
+
 /**
  * Converts an {@link ImplicitAnnotatedAllowedTypes} to an {@link ImplicitAllowedTypes}s, by removing
  * any annotations.
@@ -719,36 +740,6 @@ export function unannotateSchemaRecord<
 	) as UnannotateSchemaRecord<Schema>;
 }
 
-/**
- * Converts annotated allowed types into a mapping between the type schema and their associated annotations.
- */
-export function extractAnnotationsFromAllowedTypes(
-	types: ImplicitAnnotatedAllowedTypes,
-): ReadonlyMap<TreeNodeSchema, AllowedTypeMetadata> {
-	const typesWithoutAnnotation = isAnnotatedAllowedTypes(types) ? types.types : types;
-	const annotations = new Map<TreeNodeSchema, AllowedTypeMetadata>();
-	if (isReadonlyArray(typesWithoutAnnotation)) {
-		for (const annotatedType of typesWithoutAnnotation) {
-			if (isAnnotatedAllowedType(annotatedType)) {
-				annotations.set(evaluateLazySchema(annotatedType.type), annotatedType.metadata);
-			} else {
-				annotations.set(evaluateLazySchema(annotatedType), {});
-			}
-		}
-	} else {
-		if (isAnnotatedAllowedType(typesWithoutAnnotation)) {
-			annotations.set(
-				evaluateLazySchema(typesWithoutAnnotation.type),
-				typesWithoutAnnotation.metadata,
-			);
-		} else {
-			annotations.set(evaluateLazySchema(typesWithoutAnnotation), {});
-		}
-	}
-
-	return annotations;
-}
-
 /**
  * Returns true if the given {@link ImplicitFieldSchema} are equivalent, otherwise false.
  * @remarks Two ImplicitFieldSchema are considered equivalent if all of the following are true:

package/src/simple-tree/simpleSchema.ts

@@ -126,6 +126,23 @@ export interface SimpleMapNodeSchema<out TCustomMetadata = unknown>
 	readonly allowedTypesIdentifiers: ReadonlySet<string>;
 }
 
+/**
+ * A {@link SimpleNodeSchema} for a map node.
+ *
+ * @alpha
+ * @sealed
+ */
+export interface SimpleRecordNodeSchema<out TCustomMetadata = unknown>
+	extends SimpleNodeSchemaBaseAlpha<NodeKind.Record, TCustomMetadata> {
+	/**
+	 * The types allowed as values in the record.
+	 *
+	 * @remarks Refers to the types by identifier.
+	 * A {@link SimpleTreeSchema} is needed to resolve these identifiers to their schema {@link SimpleTreeSchema.definitions}.
+	 */
+	readonly allowedTypesIdentifiers: ReadonlySet<string>;
+}
+
 /**
  * A {@link SimpleNodeSchema} for a leaf node.
  *
@@ -157,7 +174,8 @@ export type SimpleNodeSchema =
 	| SimpleLeafNodeSchema
 	| SimpleMapNodeSchema
 	| SimpleArrayNodeSchema
-	| SimpleObjectNodeSchema;
+	| SimpleObjectNodeSchema
+	| SimpleRecordNodeSchema;
 
 /**
  * A simple, shallow representation of a schema for a field.

package/src/simple-tree/toStoredSchema.ts

@@ -37,6 +37,8 @@ const viewToStoredCache = new WeakMap<ImplicitFieldSchema, TreeStoredSchema>();
 
 /**
  * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema}.
+ * @throws
+ * Throws a `UsageError` if multiple schemas are encountered with the same identifier.
  */
 export function toStoredSchema(root: ImplicitFieldSchema): TreeStoredSchema {
 	return getOrCreate(viewToStoredCache, root, () => {
@@ -117,7 +119,8 @@ export function getStoredSchema(schema: SimpleNodeSchema): TreeNodeStoredSchema
 			assert(schema instanceof LeafNodeSchema, 0xa4a /* invalid kind */);
 			return new LeafNodeStoredSchema(schema.leafKind);
 		}
-		case NodeKind.Map: {
+		case NodeKind.Map:
+		case NodeKind.Record: {
 			const types = schema.allowedTypesIdentifiers as TreeTypeSet;
 			return new MapNodeStoredSchema(
 				{
@@ -146,7 +149,8 @@ export function getStoredSchema(schema: SimpleNodeSchema): TreeNodeStoredSchema
 			}
 			return new ObjectNodeStoredSchema(fields, schema.persistedMetadata);
 		}
-		default:
+		default: {
 			unreachableCase(kind);
+		}
 	}
 }

package/src/simple-tree/treeNodeValid.ts

@@ -20,8 +20,8 @@ import {
 	type InnerNode,
 	type Context,
 	type UnhydratedFlexTreeNode,
+	getSimpleNodeSchemaFromInnerNode,
 } from "./core/index.js";
-import { getSimpleNodeSchemaFromInnerNode } from "./core/index.js";
 import { markEager } from "./flexList.js";
 
 /**

package/src/simple-tree/unhydratedFlexTreeFromInsertable.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import type { IFluidHandle } from "@fluidframework/core-interfaces";
 import { assert, fail, unreachableCase } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { isFluidHandle } from "@fluidframework/runtime-utils/internal";
@@ -28,28 +29,39 @@ import {
 	type TreeLeafValue,
 	extractFieldProvider,
 	type ContextualFieldProvider,
+	unannotateImplicitAllowedTypes,
 } from "./schemaTypes.js";
 import {
+	createField,
 	getKernel,
 	isTreeNode,
 	NodeKind,
 	type TreeNode,
 	type TreeNodeSchema,
 	type Unhydrated,
+	type UnhydratedFlexTreeField,
 	UnhydratedFlexTreeNode,
 	UnhydratedSequenceField,
 } from "./core/index.js";
+import { getUnhydratedContext } from "./createContext.js";
+import { convertFieldKind } from "./toStoredSchema.js";
+
 // Required to prevent the introduction of new circular dependencies
 // TODO: Having the schema provide their own policy functions for compatibility which
-// unhydratedFlexTreeFromInsertable invokes instead of manually handling each kind would remove this bad
+// `unhydratedFlexTreeFromInsertable` invokes instead of manually handling each kind would remove this bad
 // dependency, and reduce coupling.
-// eslint-disable-next-line import/no-internal-modules
-import { isObjectNodeSchema } from "./node-kinds/object/objectNodeTypes.js";
-import type { IFluidHandle } from "@fluidframework/core-interfaces";
-// eslint-disable-next-line import/no-internal-modules
-import { createField, type UnhydratedFlexTreeField } from "./core/unhydratedFlexTree.js";
-import { convertFieldKind } from "./toStoredSchema.js";
-import { getUnhydratedContext } from "./createContext.js";
+/* eslint-disable import/no-internal-modules */
+import { isArrayNodeSchema, type ArrayNodeSchema } from "./node-kinds/array/arrayNodeTypes.js";
+import { isMapNodeSchema, type MapNodeSchema } from "./node-kinds/map/mapNodeTypes.js";
+import {
+	isObjectNodeSchema,
+	type ObjectNodeSchemaPrivate,
+} from "./node-kinds/object/objectNodeTypes.js";
+import {
+	isRecordNodeSchema,
+	type RecordNodeSchema,
+} from "./node-kinds/record/recordNodeTypes.js";
+/* eslint-enable import/no-internal-modules */
 
 /**
  * Module notes:
@@ -139,14 +151,21 @@ function unhydratedFlexTreeFromInsertableNode(
 			result = leafToFlexContent(data, schema, allowedTypes);
 			break;
 		case NodeKind.Array:
+			assert(isArrayNodeSchema(schema), 0x922 /* Expected an array schema. */);
 			result = arrayToFlexContent(data, schema);
 			break;
 		case NodeKind.Map:
+			assert(isMapNodeSchema(schema), 0x923 /* Expected a Map schema. */);
 			result = mapToFlexContent(data, schema);
 			break;
 		case NodeKind.Object:
+			assert(isObjectNodeSchema(schema), 0x924 /* Expected an Object schema. */);
 			result = objectToFlexContent(data, schema);
 			break;
+		case NodeKind.Record:
+			assert(isRecordNodeSchema(schema), "Expected a Record schema.");
+			result = recordToFlexContent(data, schema);
+			break;
 		default:
 			unreachableCase(schema.kind);
 	}
@@ -265,8 +284,7 @@ function arrayChildToFlexTree(
  * @param data - The tree data to be transformed. Must be an iterable.
  * @param schema - The schema associated with the value.
  */
-function arrayToFlexContent(data: FactoryContent, schema: TreeNodeSchema): FlexContent {
-	assert(schema.kind === NodeKind.Array, 0x922 /* Expected an array schema. */);
+function arrayToFlexContent(data: FactoryContent, schema: ArrayNodeSchema): FlexContent {
 	if (!(typeof data === "object" && data !== null && Symbol.iterator in data)) {
 		throw new UsageError(`Input data is incompatible with Array schema: ${data}`);
 	}
@@ -308,14 +326,11 @@ function arrayToFlexContent(data: FactoryContent, schema: TreeNodeSchema): FlexC
  * @param data - The tree data to be transformed. Must be an iterable.
  * @param schema - The schema associated with the value.
  */
-function mapToFlexContent(data: FactoryContent, schema: TreeNodeSchema): FlexContent {
-	assert(schema.kind === NodeKind.Map, 0x923 /* Expected a Map schema. */);
+function mapToFlexContent(data: FactoryContent, schema: MapNodeSchema): FlexContent {
 	if (!(typeof data === "object" && data !== null)) {
 		throw new UsageError(`Input data is incompatible with Map schema: ${data}`);
 	}
 
-	const allowedChildTypes = normalizeAllowedTypes(schema.info as ImplicitAllowedTypes);
-
 	const fieldsIterator = (
 		Symbol.iterator in data
 			? // Support iterables of key value pairs (including Map objects)
@@ -324,30 +339,7 @@ function mapToFlexContent(data: FactoryContent, schema: TreeNodeSchema): FlexCon
 				Object.entries(data)
 	) as Iterable<readonly [string, InsertableContent]>;
 
-	const context = getUnhydratedContext(schema).flexContext;
-
-	const transformedFields = new Map<FieldKey, UnhydratedFlexTreeField>();
-	for (const item of fieldsIterator) {
-		if (!isReadonlyArray(item) || item.length !== 2 || typeof item[0] !== "string") {
-			throw new UsageError(`Input data is incompatible with map entry: ${item}`);
-		}
-		const [key, value] = item;
-		assert(!transformedFields.has(brand(key)), 0x84c /* Keys should not be duplicated */);
-
-		// Omit undefined values - an entry with an undefined value is equivalent to one that has been removed or omitted
-		if (value !== undefined) {
-			const child = unhydratedFlexTreeFromInsertableNode(value, allowedChildTypes);
-			const field = createField(context, FieldKinds.optional.identifier, brand(key), [child]);
-			transformedFields.set(brand(key), field);
-		}
-	}
-
-	return [
-		{
-			type: brand(schema.identifier),
-		},
-		transformedFields,
-	];
+	return recordLikeDataToFlexContent(fieldsIterator, schema);
 }
 
 /**
@@ -355,8 +347,10 @@ function mapToFlexContent(data: FactoryContent, schema: TreeNodeSchema): FlexCon
  * @param data - The tree data to be transformed. Must be a Record-like object.
  * @param schema - The schema associated with the value.
  */
-function objectToFlexContent(data: FactoryContent, schema: TreeNodeSchema): FlexContent {
-	assert(isObjectNodeSchema(schema), 0x924 /* Expected an Object schema. */);
+function objectToFlexContent(
+	data: FactoryContent,
+	schema: ObjectNodeSchemaPrivate,
+): FlexContent {
 	if (
 		typeof data !== "object" ||
 		data === null ||
@@ -396,6 +390,51 @@ function objectToFlexContent(data: FactoryContent, schema: TreeNodeSchema): Flex
 	return [{ type: brand(schema.identifier) }, fields];
 }
 
+/**
+ * Transforms data under an Object schema.
+ * @param data - The tree data to be transformed. Must be a Record-like object.
+ * @param schema - The schema associated with the value.
+ */
+function recordToFlexContent(data: FactoryContent, schema: RecordNodeSchema): FlexContent {
+	if (!(typeof data === "object" && data !== null)) {
+		throw new UsageError(`Input data is incompatible with Record schema: ${data}`);
+	}
+
+	const fieldsIterator: Iterable<readonly [string, InsertableContent]> = Object.entries(data);
+	return recordLikeDataToFlexContent(fieldsIterator, schema);
+}
+
+/**
+ * Converts record-like data to a FlexContent representation for map/record schema.
+ */
+function recordLikeDataToFlexContent(
+	fieldsIterator: Iterable<readonly [string, InsertableContent]>,
+	schema: MapNodeSchema | RecordNodeSchema,
+): FlexContent {
+	const allowedChildTypes = normalizeAllowedTypes(unannotateImplicitAllowedTypes(schema.info));
+	const context = getUnhydratedContext(schema).flexContext;
+
+	const transformedFields = new Map<FieldKey, UnhydratedFlexTreeField>();
+	for (const item of fieldsIterator) {
+		const [key, value] = item;
+		assert(!transformedFields.has(brand(key)), 0x84c /* Keys should not be duplicated */);
+
+		// Omit undefined values - an entry with an undefined value is equivalent to one that has been removed or omitted
+		if (value !== undefined) {
+			const child = unhydratedFlexTreeFromInsertableNode(value, allowedChildTypes);
+			const field = createField(context, FieldKinds.optional.identifier, brand(key), [child]);
+			transformedFields.set(brand(key), field);
+		}
+	}
+
+	return [
+		{
+			type: brand(schema.identifier),
+		},
+		transformedFields,
+	];
+}
+
 /**
  * Check {@link FactoryContentObject} for a property which could be store a field.
  *
@@ -550,6 +589,10 @@ function shallowCompatibilityTest(
 
 	// At this point, it is assumed data is a record-like object since all the other cases have been eliminated.
 
+	if (schema.kind === NodeKind.Record) {
+		return CompatibilityLevel.Normal;
+	}
+
 	if (schema.kind === NodeKind.Array) {
 		return CompatibilityLevel.None;
 	}

package/src/simple-tree/walkFieldSchema.ts

@@ -14,5 +14,9 @@ export function walkFieldSchema(
 	visitor: SchemaVisitor,
 	visitedSet: Set<TreeNodeSchema> = new Set(),
 ): void {
-	walkAllowedTypes(normalizeFieldSchema(schema).allowedTypeSet, visitor, visitedSet);
+	walkAllowedTypes(
+		normalizeFieldSchema(schema).annotatedAllowedTypesNormalized,
+		visitor,
+		visitedSet,
+	);
 }

package/src/tableSchema.ts

@@ -6,7 +6,7 @@
 import { oob } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { Tree } from "./shared-tree/index.js";
+import { Tree, TreeAlpha } from "./shared-tree/index.js";
 import {
 	type FieldHasDefault,
 	type ImplicitAllowedTypes,
@@ -28,6 +28,7 @@ import {
 	type ImplicitAnnotatedFieldSchema,
 	type UnannotateImplicitFieldSchema,
 	isArrayNodeSchema,
+	type InsertableField,
 } from "./simple-tree/index.js";
 
 // Future improvement TODOs:
@@ -352,7 +353,12 @@ export namespace System_TableSchema {
 		// See definition of `RowInsertableType` below.
 		const rowFieldsBuiltInParts = {
 			id: schemaFactory.identifier,
-			cells: schemaFactory.required(schemaFactory.map("Row.cells", cellSchema), {
+			/**
+			 * The cells of the table row, keyed by column ID.
+			 * @remarks
+			 * The table row models its cells as a record, where each key is the ID of the column it belongs to. The choice of record (as opposed to a map) is intended to make interop with common table rendering libraries in TypeScript/JavaScript easier.
+			 */
+			cells: schemaFactory.required(schemaFactory.record("Row.cells", cellSchema), {
 				metadata: {
 					description: "The cells of the table row, keyed by column ID.",
 				},
@@ -389,7 +395,8 @@ export namespace System_TableSchema {
 				columnOrId: TableSchema.Column<TCellSchema> | string,
 			): CellValueType | undefined {
 				const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
-				return this.cells.get(columnId) as CellValueType | undefined;
+				// Unlike most objects, RecordNodes don't have the default inherited object properties, so this is safe
+				return this.cells[columnId];
 			}
 
 			public setCell(
@@ -398,8 +405,18 @@ export namespace System_TableSchema {
 			): void {
 				// TODO: throw if column does not exist in the owning table.
 
-				const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
-				this.cells.set(columnId, value);
+				if (value === undefined) {
+					this.removeCell(columnOrId);
+				} else {
+					const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
+
+					// TypeScript is unable to narrow the types correctly here, hence the casts.
+					// See: https://github.com/microsoft/TypeScript/issues/52144
+					this.cells[columnId] = TreeAlpha.create(
+						cellSchema,
+						value as InsertableField<TCellSchema>,
+					) as CellValueType;
+				}
 			}
 
 			public removeCell(
@@ -409,12 +426,14 @@ export namespace System_TableSchema {
 
 				const columnId = typeof columnOrId === "string" ? columnOrId : columnOrId.id;
 
-				const cell: CellValueType | undefined = this.cells.get(columnId);
+				const cell: CellValueType | undefined = this.getCell(columnId);
 				if (cell === undefined) {
 					return undefined;
 				}
 
-				this.cells.delete(columnId);
+				// eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- The record's values are non-optional, so setting `undefined` as a means to remove the cell is not supported.
+				delete this.cells[columnId];
+
 				return cell;
 			}
 
@@ -423,7 +442,7 @@ export namespace System_TableSchema {
 				cell: CellValueType;
 			}[] {
 				const result = [];
-				for (const [columnId, cell] of this.cells.entries()) {
+				for (const [columnId, cell] of Object.entries(this.cells)) {
 					if (cell !== undefined) {
 						result.push({
 							columnId,

package/src/util/brandedMap.ts

@@ -16,8 +16,6 @@ import { getOrCreate } from "./utils.js";
  */
 export type BrandedKey<TKey, TContent> = TKey & Invariant<TContent>;
 
-/**
- */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type BrandedKeyContent<TKey extends BrandedKey<unknown, any>> = TKey extends BrandedKey<
 	unknown,