@fluidframework/tree 2.10.0-305357 → 2.10.0-307060

package/src/feature-libraries/modular-schema/discrepancies.ts

@@ -11,12 +11,14 @@ import {
 	LeafNodeStoredSchema,
 	MapNodeStoredSchema,
 	ObjectNodeStoredSchema,
+	storedEmptyFieldSchema,
 	type TreeFieldStoredSchema,
 	type TreeNodeSchemaIdentifier,
 	type TreeStoredSchema,
 	type TreeTypeSet,
 	type ValueSchema,
 } from "../../core/index.js";
+import { brand } from "../../util/index.js";
 
 // TODO:
 // The comparisons in this file seem redundant with those in comparison.ts.
@@ -25,45 +27,45 @@ import {
 /**
  * @remarks
  *
- * 1. FieldIncompatibility
+ * 1. FieldDiscrepancy
  *
- * `FieldIncompatibility` represents the differences between two `TreeFieldStoredSchema` objects. It consists of
+ * `FieldDiscrepancy` represents the differences between two `TreeFieldStoredSchema` objects. It consists of
  * three types of incompatibilities:
  *
- * - FieldKindIncompatibility: Indicates the differences in `FieldKindIdentifier` between two `TreeFieldStoredSchema`
+ * - FieldKindDiscrepancy: Indicates the differences in `FieldKindIdentifier` between two `TreeFieldStoredSchema`
  * objects (e.g., optional, required, sequence, etc.).
- * - AllowedTypesIncompatibility: Indicates the differences in the allowed child types between the two schemas.
- * - ValueSchemaIncompatibility: Specifically indicates the differences in the `ValueSchema` of two
+ * - AllowedTypesDiscrepancy: Indicates the differences in the allowed child types between the two schemas.
+ * - ValueSchemaDiscrepancy: Specifically indicates the differences in the `ValueSchema` of two
  * `LeafNodeStoredSchema` objects.
  *
- * 2. NodeIncompatibility
+ * 2. NodeDiscrepancy
  *
- * `NodeIncompatibility` represents the differences between two `TreeNodeStoredSchema` objects and includes:
+ * `NodeDiscrepancy` represents the differences between two `TreeNodeStoredSchema` objects and includes:
  *
- * - NodeKindIncompatibility: Indicates the differences in the types of `TreeNodeStoredSchema` (currently supports
+ * - NodeKindDiscrepancy: Indicates the differences in the types of `TreeNodeStoredSchema` (currently supports
  * `ObjectNodeStoredSchema`, `MapNodeStoredSchema`, and `LeafNodeStoredSchema`).
- * - NodeFieldsIncompatibility: Indicates the `FieldIncompatibility` of `TreeFieldStoredSchema` within two
- * `TreeNodeStoredSchema`. It includes an array of `FieldIncompatibility` instances in the `differences` field.
+ * - NodeFieldsDiscrepancy: Indicates the `FieldDiscrepancy` of `TreeFieldStoredSchema` within two
+ * `TreeNodeStoredSchema`. It includes an array of `FieldDiscrepancy` instances in the `differences` field.
  *
  * When comparing two nodes for compatibility, it only makes sense to compare their fields if the nodes are of
  * the same kind (map, object, leaf).
  *
- * 3. Incompatibility
+ * 3. Discrepancy
  *
- * Incompatibility consists of both `NodeIncompatibility` and `FieldIncompatibility`, representing any kind of
- * schema differences. See {@link getAllowedContentIncompatibilities} for more details about how we process it
+ * Discrepancy consists of both `NodeDiscrepancy` and `FieldDiscrepancy`, representing any kind of
+ * schema differences. See {@link getAllowedContentDiscrepancies} for more details about how we process it
  * and the ordering.
  */
-export type Incompatibility = FieldIncompatibility | NodeIncompatibility;
+export type Discrepancy = FieldDiscrepancy | NodeDiscrepancy;
 
-export type NodeIncompatibility = NodeKindIncompatibility | NodeFieldsIncompatibility;
+export type NodeDiscrepancy = NodeKindDiscrepancy | NodeFieldsDiscrepancy;
 
-export type FieldIncompatibility =
-	| AllowedTypeIncompatibility
-	| FieldKindIncompatibility
-	| ValueSchemaIncompatibility;
+export type FieldDiscrepancy =
+	| AllowedTypeDiscrepancy
+	| FieldKindDiscrepancy
+	| ValueSchemaDiscrepancy;
 
-export interface AllowedTypeIncompatibility {
+export interface AllowedTypeDiscrepancy {
 	identifier: string | undefined; // undefined indicates root field schema
 	mismatch: "allowedTypes";
 	/**
@@ -76,62 +78,60 @@ export interface AllowedTypeIncompatibility {
 	stored: string[];
 }
 
-export interface FieldKindIncompatibility {
+export interface FieldKindDiscrepancy {
 	identifier: string | undefined; // undefined indicates root field schema
 	mismatch: "fieldKind";
-	view: FieldKindIdentifier | undefined;
-	stored: FieldKindIdentifier | undefined;
+	view: FieldKindIdentifier;
+	stored: FieldKindIdentifier;
 }
 
-export interface ValueSchemaIncompatibility {
+export interface ValueSchemaDiscrepancy {
 	identifier: string;
 	mismatch: "valueSchema";
 	view: ValueSchema | undefined;
 	stored: ValueSchema | undefined;
 }
 
-export interface NodeKindIncompatibility {
+export interface NodeKindDiscrepancy {
 	identifier: string;
 	mismatch: "nodeKind";
 	view: SchemaFactoryNodeKind | undefined;
 	stored: SchemaFactoryNodeKind | undefined;
 }
 
-export interface NodeFieldsIncompatibility {
+export interface NodeFieldsDiscrepancy {
 	identifier: string;
 	mismatch: "fields";
-	differences: FieldIncompatibility[];
+	differences: FieldDiscrepancy[];
 }
 
 type SchemaFactoryNodeKind = "object" | "leaf" | "map";
 
 /**
- * @remarks
+ * Finds and reports discrepancies between a view schema and a stored schema.
  *
  * The workflow for finding schema incompatibilities:
- * 1. Compare the two root schemas to identify any `FieldIncompatibility`.
+ * 1. Compare the two root schemas to identify any `FieldDiscrepancy`.
  *
  * 2. For each node schema in the `view`:
  * - Verify if the node schema exists in the stored. If it does, ensure that the `SchemaFactoryNodeKind` are
- * consistent. Otherwise this difference is treated as `NodeKindIncompatibility`
+ * consistent. Otherwise this difference is treated as `NodeKindDiscrepancy`
  * - If a node schema with the same identifier exists in both view and stored, and their `SchemaFactoryNodeKind`
- * are consistent, perform a exhaustive validation to identify all `FieldIncompatibility`.
+ * are consistent, perform a exhaustive validation to identify all `FieldDiscrepancy`.
  *
  * 3. For each node schema in the stored, verify if it exists in the view. The overlapping parts were already
  * addressed in the previous step.
  *
  * @returns the discrepancies between two TreeStoredSchema objects
  */
-export function getAllowedContentIncompatibilities(
+export function getAllowedContentDiscrepancies(
 	view: TreeStoredSchema,
 	stored: TreeStoredSchema,
-): Incompatibility[] {
-	const incompatibilities: Incompatibility[] = [];
+): Discrepancy[] {
+	const discrepancies: Discrepancy[] = [];
 
 	// check root schema discrepancies
-	incompatibilities.push(
-		...trackFieldDiscrepancies(view.rootFieldSchema, stored.rootFieldSchema),
-	);
+	discrepancies.push(...trackFieldDiscrepancies(view.rootFieldSchema, stored.rootFieldSchema));
 
 	// Verify the existence and type of a node schema given its identifier (key), then determine if
 	// an exhaustive search is necessary.
@@ -141,7 +141,7 @@ export function getAllowedContentIncompatibilities(
 
 		if (viewNodeSchema instanceof ObjectNodeStoredSchema) {
 			if (!stored.nodeSchema.has(key)) {
-				incompatibilities.push({
+				discrepancies.push({
 					identifier: key,
 					mismatch: "nodeKind",
 					view: "object",
@@ -154,27 +154,27 @@ export function getAllowedContentIncompatibilities(
 					0x9be /* The storedNodeSchema in stored.nodeSchema should not be undefined */,
 				);
 				if (storedNodeSchema instanceof MapNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "object",
 						stored: "map",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof LeafNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "object",
 						stored: "leaf",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof ObjectNodeStoredSchema) {
 					const differences = trackObjectNodeDiscrepancies(viewNodeSchema, storedNodeSchema);
 					if (differences.length > 0) {
-						incompatibilities.push({
+						discrepancies.push({
 							identifier: key,
 							mismatch: "fields",
 							differences,
-						} satisfies NodeFieldsIncompatibility);
+						} satisfies NodeFieldsDiscrepancy);
 					}
 				} else {
 					throwUnsupportedNodeType(storedNodeSchema.constructor.name);
@@ -182,12 +182,12 @@ export function getAllowedContentIncompatibilities(
 			}
 		} else if (viewNodeSchema instanceof MapNodeStoredSchema) {
 			if (!stored.nodeSchema.has(key)) {
-				incompatibilities.push({
+				discrepancies.push({
 					identifier: key,
 					mismatch: "nodeKind",
 					view: "map",
 					stored: undefined,
-				} satisfies NodeKindIncompatibility);
+				} satisfies NodeKindDiscrepancy);
 			} else {
 				const storedNodeSchema = stored.nodeSchema.get(key);
 				assert(
@@ -195,21 +195,21 @@ export function getAllowedContentIncompatibilities(
 					0x9bf /* The storedNodeSchema in stored.nodeSchema should not be undefined */,
 				);
 				if (storedNodeSchema instanceof ObjectNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "map",
 						stored: "object",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof LeafNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "map",
 						stored: "leaf",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof MapNodeStoredSchema) {
-					incompatibilities.push(
+					discrepancies.push(
 						...trackFieldDiscrepancies(
 							viewNodeSchema.mapFields,
 							storedNodeSchema.mapFields,
@@ -222,7 +222,7 @@ export function getAllowedContentIncompatibilities(
 			}
 		} else if (viewNodeSchema instanceof LeafNodeStoredSchema) {
 			if (!stored.nodeSchema.has(key)) {
-				incompatibilities.push({
+				discrepancies.push({
 					identifier: key,
 					mismatch: "nodeKind",
 					view: "leaf",
@@ -235,27 +235,27 @@ export function getAllowedContentIncompatibilities(
 					0x9c0 /* The storedNodeSchema in stored.nodeSchema should not be undefined */,
 				);
 				if (storedNodeSchema instanceof MapNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "leaf",
 						stored: "map",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof ObjectNodeStoredSchema) {
-					incompatibilities.push({
+					discrepancies.push({
 						identifier: key,
 						mismatch: "nodeKind",
 						view: "leaf",
 						stored: "object",
-					} satisfies NodeKindIncompatibility);
+					} satisfies NodeKindDiscrepancy);
 				} else if (storedNodeSchema instanceof LeafNodeStoredSchema) {
 					if (viewNodeSchema.leafValue !== storedNodeSchema.leafValue) {
-						incompatibilities.push({
+						discrepancies.push({
 							identifier: key,
 							mismatch: "valueSchema",
 							view: viewNodeSchema.leafValue,
 							stored: storedNodeSchema.leafValue,
-						} satisfies ValueSchemaIncompatibility);
+						} satisfies ValueSchemaDiscrepancy);
 					}
 				} else {
 					throwUnsupportedNodeType(storedNodeSchema.constructor.name);
@@ -268,7 +268,7 @@ export function getAllowedContentIncompatibilities(
 
 	for (const [key, storedNodeSchema] of stored.nodeSchema) {
 		if (!viewNodeKeys.has(key)) {
-			incompatibilities.push({
+			discrepancies.push({
 				identifier: key,
 				mismatch: "nodeKind",
 				view: undefined,
@@ -278,11 +278,11 @@ export function getAllowedContentIncompatibilities(
 						: storedNodeSchema instanceof ObjectNodeStoredSchema
 							? "object"
 							: "leaf",
-			} satisfies NodeKindIncompatibility);
+			} satisfies NodeKindDiscrepancy);
 		}
 	}
 
-	return incompatibilities;
+	return discrepancies;
 }
 
 /**
@@ -294,8 +294,8 @@ function trackFieldDiscrepancies(
 	view: TreeFieldStoredSchema,
 	stored: TreeFieldStoredSchema,
 	keyOrRoot?: string,
-): FieldIncompatibility[] {
-	const differences: FieldIncompatibility[] = [];
+): FieldDiscrepancy[] {
+	const differences: FieldDiscrepancy[] = [];
 
 	// Only track the symmetric differences of two sets.
 	const findSetDiscrepancies = (
@@ -314,7 +314,7 @@ function trackFieldDiscrepancies(
 			mismatch: "allowedTypes",
 			view: allowedTypesDiscrepancies[0],
 			stored: allowedTypesDiscrepancies[1],
-		} satisfies AllowedTypeIncompatibility);
+		} satisfies AllowedTypeDiscrepancy);
 	}
 
 	if (view.kind !== stored.kind) {
@@ -323,7 +323,7 @@ function trackFieldDiscrepancies(
 			mismatch: "fieldKind",
 			view: view.kind,
 			stored: stored.kind,
-		} satisfies FieldKindIncompatibility);
+		} satisfies FieldKindDiscrepancy);
 	}
 
 	return differences;
@@ -332,8 +332,8 @@ function trackFieldDiscrepancies(
 function trackObjectNodeDiscrepancies(
 	view: ObjectNodeStoredSchema,
 	stored: ObjectNodeStoredSchema,
-): FieldIncompatibility[] {
-	const differences: FieldIncompatibility[] = [];
+): FieldDiscrepancy[] {
+	const differences: FieldDiscrepancy[] = [];
 	const viewFieldKeys = new Set<FieldKey>();
 	/**
 	 * Similar to the logic used for tracking discrepancies between two node schemas, we will identify
@@ -348,13 +348,16 @@ function trackObjectNodeDiscrepancies(
 
 	for (const [fieldKey, fieldStoredSchema] of view.objectNodeFields) {
 		viewFieldKeys.add(fieldKey);
-		if (!stored.objectNodeFields.has(fieldKey)) {
+		if (
+			!stored.objectNodeFields.has(fieldKey) &&
+			fieldStoredSchema.kind !== storedEmptyFieldSchema.kind
+		) {
 			differences.push({
 				identifier: fieldKey,
 				mismatch: "fieldKind",
 				view: fieldStoredSchema.kind,
-				stored: undefined,
-			} satisfies FieldKindIncompatibility);
+				stored: storedEmptyFieldSchema.kind,
+			} satisfies FieldKindDiscrepancy);
 		} else {
 			differences.push(
 				...trackFieldDiscrepancies(
@@ -370,12 +373,15 @@ function trackObjectNodeDiscrepancies(
 		if (viewFieldKeys.has(fieldKey)) {
 			continue;
 		}
-		differences.push({
-			identifier: fieldKey,
-			mismatch: "fieldKind",
-			view: undefined,
-			stored: fieldStoredSchema.kind,
-		} satisfies FieldKindIncompatibility);
+
+		if (fieldStoredSchema.kind !== storedEmptyFieldSchema.kind) {
+			differences.push({
+				identifier: fieldKey,
+				mismatch: "fieldKind",
+				view: storedEmptyFieldSchema.kind,
+				stored: fieldStoredSchema.kind,
+			} satisfies FieldKindDiscrepancy);
+		}
 	}
 
 	return differences;
@@ -399,24 +405,28 @@ function trackObjectNodeDiscrepancies(
  * validating internal fields.
  */
 export function isRepoSuperset(view: TreeStoredSchema, stored: TreeStoredSchema): boolean {
-	const incompatibilities = getAllowedContentIncompatibilities(view, stored);
+	const discrepancies = getAllowedContentDiscrepancies(view, stored);
 
-	for (const incompatibility of incompatibilities) {
-		switch (incompatibility.mismatch) {
+	for (const discrepancy of discrepancies) {
+		switch (discrepancy.mismatch) {
 			case "nodeKind": {
-				return false;
+				if (discrepancy.stored !== undefined) {
+					// It's fine for the view schema to know of a node type that the stored schema doesn't know about.
+					return false;
+				}
+				break;
 			}
 			case "valueSchema":
 			case "allowedTypes":
 			case "fieldKind": {
-				if (!validateFieldIncompatibility(incompatibility)) {
+				if (!validateFieldIncompatibility(discrepancy)) {
 					return false;
 				}
 				break;
 			}
 			case "fields": {
 				if (
-					incompatibility.differences.some(
+					discrepancy.differences.some(
 						(difference) => !validateFieldIncompatibility(difference),
 					)
 				) {
@@ -430,26 +440,16 @@ export function isRepoSuperset(view: TreeStoredSchema, stored: TreeStoredSchema)
 	return true;
 }
 
-function validateFieldIncompatibility(incompatibility: FieldIncompatibility): boolean {
-	switch (incompatibility.mismatch) {
+function validateFieldIncompatibility(discrepancy: FieldDiscrepancy): boolean {
+	switch (discrepancy.mismatch) {
 		case "allowedTypes": {
 			// Since we only track the symmetric difference between the allowed types in the view and
 			// stored schemas, it's sufficient to check if any extra allowed types still exist in the
 			// stored schema.
-			return incompatibility.stored.length === 0;
+			return discrepancy.stored.length === 0;
 		}
 		case "fieldKind": {
-			if (incompatibility.stored === undefined) {
-				// Add an optional field
-				if (incompatibility.view === "Optional") {
-					return true;
-				}
-			} else {
-				// Relax the field to make it more general
-				return compareFieldKind(incompatibility.stored, incompatibility.view);
-			}
-
-			break;
+			return posetLte(discrepancy.stored, discrepancy.view, fieldRealizer);
 		}
 		case "valueSchema": {
 			return false;
@@ -460,41 +460,105 @@ function validateFieldIncompatibility(incompatibility: FieldIncompatibility): bo
 }
 
 /**
- * A mapping that defines the order of field kinds for comparison purposes.
- * The numeric values indicate the hierarchy or "strength" of each field kind, where lower numbers are more restrictive.
- * This is used to determine if one field kind can be considered a superset of another.
+ * A linear extension of a partially-ordered set of `T`s. See:
+ * https://en.wikipedia.org/wiki/Linear_extension
  *
- * - "Forbidden": The most restrictive, represented by 1. Indicates a forbidden field.
- * - "Value": Represented by 2. Indicates a required field with a specific value.
- * - "Optional": Represented by 3. Indicates an optional field.
- *
- * Note:
- * - "Sequence": (Currently commented out) was intended to represent a sequence field kind with a value of 4.
- * Relaxing non-sequence fields to sequences is not currently supported but may be considered in the future.
- *
- * TODO: We may need more coverage in realm to prove the correctness of the Forbidden -\> Value transaction
+ * The linear extension is represented as a lookup from each poset element to its index in the linear extension.
+ */
+type LinearExtension<T> = Map<T, number>;
+
+/**
+ * A realizer for a partially-ordered set. See:
+ * https://en.wikipedia.org/wiki/Order_dimension
+ */
+type Realizer<T> = LinearExtension<T>[];
+
+/**
+ * @privateRemarks
+ * TODO: Knowledge of specific field kinds is not appropriate for modular schema.
+ * This bit of field comparison should be dependency injected by default-schema if this comparison logic remains in modular-schema
+ * (this is analogous to what is done in comparison.ts).
  */
-const fieldKindOrder: { [key: string]: number } = {
-	"Forbidden": 1,
-	"Value": 2,
-	"Optional": 3,
-	// "Sequence": 4,  // Relaxing non-sequence fields to sequences is not currently supported, though we could consider doing so in the future.
+const FieldKindIdentifiers = {
+	forbidden: brand<FieldKindIdentifier>("Forbidden"),
+	required: brand<FieldKindIdentifier>("Value"),
+	identifier: brand<FieldKindIdentifier>("Identifier"),
+	optional: brand<FieldKindIdentifier>("Optional"),
+	sequence: brand<FieldKindIdentifier>("Sequence"),
 };
 
-function compareFieldKind(
-	aKind: FieldKindIdentifier | undefined,
-	bKind: FieldKindIdentifier | undefined,
-): boolean {
-	if (aKind === undefined || bKind === undefined) {
-		return false;
+/**
+ * A realizer for the partial order of field kind relaxability.
+ *
+ * It seems extremely likely that this partial order will remain dimension 2 over time (i.e. the set of allowed relaxations can be visualized
+ * with a [dominance drawing](https://en.wikipedia.org/wiki/Dominance_drawing)), so this strategy allows efficient comarison between field kinds
+ * without excessive casework.
+ *
+ * Hasse diagram for the partial order is shown below (lower fields can be relaxed to higher fields):
+ * ```
+ * sequence
+ *    |
+ * optional
+ *    |    \
+ * required forbidden
+ *    |
+ * identifier
+ * ```
+ */
+const fieldRealizer: Realizer<FieldKindIdentifier> = [
+	[
+		FieldKindIdentifiers.forbidden,
+		FieldKindIdentifiers.identifier,
+		FieldKindIdentifiers.required,
+		FieldKindIdentifiers.optional,
+		FieldKindIdentifiers.sequence,
+	],
+	[
+		FieldKindIdentifiers.identifier,
+		FieldKindIdentifiers.required,
+		FieldKindIdentifiers.forbidden,
+		FieldKindIdentifiers.optional,
+		FieldKindIdentifiers.sequence,
+	],
+].map((extension) => new Map(extension.map((identifier, index) => [identifier, index])));
+
+const PosetComparisonResult = {
+	Less: "<",
+	Greater: ">",
+	Equal: "=",
+	Incomparable: "||",
+} as const;
+type PosetComparisonResult =
+	(typeof PosetComparisonResult)[keyof typeof PosetComparisonResult];
+
+function comparePosetElements<T>(a: T, b: T, realizer: Realizer<T>): PosetComparisonResult {
+	let hasLessThanResult = false;
+	let hasGreaterThanResult = false;
+	for (const extension of realizer) {
+		const aIndex = extension.get(a);
+		const bIndex = extension.get(b);
+		assert(aIndex !== undefined && bIndex !== undefined, "Invalid realizer");
+		if (aIndex < bIndex) {
+			hasLessThanResult = true;
+		} else if (aIndex > bIndex) {
+			hasGreaterThanResult = true;
+		}
 	}
 
-	if (!(aKind in fieldKindOrder) || !(bKind in fieldKindOrder)) {
-		return false;
-	}
+	return hasLessThanResult
+		? hasGreaterThanResult
+			? PosetComparisonResult.Incomparable
+			: PosetComparisonResult.Less
+		: hasGreaterThanResult
+			? PosetComparisonResult.Greater
+			: PosetComparisonResult.Equal;
+}
 
-	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-	return fieldKindOrder[aKind]! <= fieldKindOrder[bKind]!;
+function posetLte<T>(a: T, b: T, realizer: Realizer<T>): boolean {
+	const comparison = comparePosetElements(a, b, realizer);
+	return (
+		comparison === PosetComparisonResult.Less || comparison === PosetComparisonResult.Equal
+	);
 }
 
 function throwUnsupportedNodeType(type: string): never {

package/src/feature-libraries/modular-schema/genericFieldKind.ts

@@ -103,8 +103,8 @@ function rebaseGenericChange(
 			break;
 		}
 
-		const newIndex = newEntry?.[0] ?? Infinity;
-		const baseIndex = baseEntry?.[0] ?? Infinity;
+		const newIndex = newEntry?.[0] ?? Number.POSITIVE_INFINITY;
+		const baseIndex = baseEntry?.[0] ?? Number.POSITIVE_INFINITY;
 		let newNodeChange: NodeId | undefined;
 		let baseNodeChange: NodeId | undefined;
 		let index: number;

package/src/feature-libraries/modular-schema/index.ts

@@ -74,4 +74,7 @@ export type {
 	FieldKindConfiguration,
 	FieldKindConfigurationEntry,
 } from "./fieldKindConfiguration.js";
-export { getAllowedContentIncompatibilities, isRepoSuperset } from "./discrepancies.js";
+export {
+	getAllowedContentDiscrepancies,
+	isRepoSuperset,
+} from "./discrepancies.js";

package/src/feature-libraries/modular-schema/modularChangeFamily.ts

@@ -3016,7 +3016,7 @@ function getFirstIntersectingCrossFieldEntry(
 	table: CrossFieldKeyTable,
 	[target, revision, id, count]: CrossFieldKeyRange,
 ): [CrossFieldKeyRange, FieldId] | undefined {
-	const entry = table.nextLowerPair([target, revision, id, Infinity]);
+	const entry = table.nextLowerPair([target, revision, id, Number.POSITIVE_INFINITY]);
 	if (entry === undefined) {
 		return undefined;
 	}

package/src/feature-libraries/object-forest/objectForest.ts

@@ -33,7 +33,7 @@ import {
 	aboveRootPlaceholder,
 	deepCopyMapTree,
 } from "../../core/index.js";
-import { createEmitter } from "../../events/index.js";
+import { createEmitter, type Listenable } from "../../events/index.js";
 import {
 	assertNonNegativeSafeInteger,
 	assertValidIndex,
@@ -73,7 +73,8 @@ export class ObjectForest implements IEditableForest {
 	// All cursors that are in the "Current" state. Must be empty when editing.
 	public readonly currentCursors: Set<Cursor> = new Set();
 
-	private readonly events = createEmitter<ForestEvents>();
+	readonly #events = createEmitter<ForestEvents>();
+	public readonly events: Listenable<ForestEvents> = this.#events;
 
 	readonly #roots: MutableMapTree;
 	public get roots(): MapTree {
@@ -98,13 +99,6 @@ export class ObjectForest implements IEditableForest {
 		return this.roots.fields.size === 0;
 	}
 
-	public on<K extends keyof ForestEvents>(
-		eventName: K,
-		listener: ForestEvents[K],
-	): () => void {
-		return this.events.on(eventName, listener);
-	}
-
 	public clone(_: TreeStoredSchemaSubscription, anchors: AnchorSet): ObjectForest {
 		return new ObjectForest(anchors, this.additionalAsserts, this.roots);
 	}
@@ -133,7 +127,7 @@ export class ObjectForest implements IEditableForest {
 		 * This is required for each change since there may be app facing change event handlers which create cursors.
 		 */
 		const preEdit = (): void => {
-			this.events.emit("beforeChange");
+			this.#events.emit("beforeChange");
 			assert(
 				this.currentCursors.has(cursor),
 				0x995 /* missing visitor cursor while editing */,
@@ -168,7 +162,7 @@ export class ObjectForest implements IEditableForest {
 			public create(content: ProtoNodes, destination: FieldKey): void {
 				preEdit();
 				this.forest.add(content, destination);
-				this.forest.events.emit("afterRootFieldCreated", destination);
+				this.forest.#events.emit("afterRootFieldCreated", destination);
 			}
 			public attach(source: FieldKey, count: number, destination: PlaceIndex): void {
 				preEdit();