@fluidframework/tree 2.11.0 → 2.13.0

package/src/feature-libraries/chunked-forest/index.ts

@@ -4,7 +4,7 @@
  */
 
 export { uniformChunk, ChunkShape } from "./uniformChunk.js";
-export { type TreeChunk, dummyRoot } from "./chunk.js";
+export { type TreeChunk, dummyRoot } from "../../core/index.js";
 export {
 	chunkTree,
 	defaultChunkPolicy,

package/src/feature-libraries/chunked-forest/sequenceChunk.ts

@@ -6,7 +6,7 @@
 import { ReferenceCountedBase } from "../../util/index.js";
 
 import { BasicChunkCursor } from "./basicChunk.js";
-import { type ChunkedCursor, type TreeChunk, dummyRoot } from "./chunk.js";
+import { type ChunkedCursor, type TreeChunk, dummyRoot } from "../../core/index.js";
 
 /**
  * General purpose multi-node sequence chunk.

package/src/feature-libraries/chunked-forest/uniformChunk.ts

@@ -14,11 +14,14 @@ import {
 	type TreeValue,
 	type UpPath,
 	type Value,
+	type ChunkedCursor,
+	type TreeChunk,
+	cursorChunk,
+	dummyRoot,
 } from "../../core/index.js";
 import { ReferenceCountedBase, fail, hasSome } from "../../util/index.js";
 import { SynchronousCursor, prefixFieldPath, prefixPath } from "../treeCursorUtils.js";
 
-import { type ChunkedCursor, type TreeChunk, cursorChunk, dummyRoot } from "./chunk.js";
 import type { SessionSpaceCompressedId, IIdCompressor } from "@fluidframework/id-compressor";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 

package/src/feature-libraries/default-schema/defaultEditBuilder.ts

@@ -160,8 +160,17 @@ export interface IDefaultEditBuilder {
 		destinationIndex: number,
 	): void;
 
-	// TODO: document
+	/**
+	 * Add a constraint that the node at the given path must exist.
+	 * @param path - The path to the node that must exist.
+	 */
 	addNodeExistsConstraint(path: UpPath): void;
+
+	/**
+	 * Add a constraint that the node at the given path must exist when reverting a change.
+	 * @param path - The path to the node that must exist when reverting a change.
+	 */
+	addNodeExistsConstraintOnRevert(path: UpPath): void;
 }
 
 /**
@@ -191,6 +200,10 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 		this.modularBuilder.addNodeExistsConstraint(path, this.mintRevisionTag());
 	}
 
+	public addNodeExistsConstraintOnRevert(path: UpPath): void {
+		this.modularBuilder.addNodeExistsConstraintOnRevert(path, this.mintRevisionTag());
+	}
+
 	public valueField(field: FieldUpPath): ValueFieldEditBuilder<ITreeCursorSynchronous> {
 		return {
 			set: (newContent: ITreeCursorSynchronous): void => {

package/src/feature-libraries/default-schema/defaultSchema.ts

@@ -13,4 +13,5 @@ import { fieldKinds } from "./defaultFieldKinds.js";
 export const defaultSchemaPolicy: FullSchemaPolicy = {
 	fieldKinds,
 	validateSchema: false,
+	allowUnknownOptionalFields: () => false,
 };

package/src/feature-libraries/default-schema/schemaChecker.ts

@@ -73,7 +73,10 @@ export function isNodeInSchema(
 			uncheckedFieldsFromNode.delete(fieldKey);
 		}
 		// The node has fields that we did not check as part of looking at every field defined in the node's schema
-		if (uncheckedFieldsFromNode.size !== 0) {
+		if (
+			uncheckedFieldsFromNode.size !== 0 &&
+			!schemaAndPolicy.policy.allowUnknownOptionalFields(node.type)
+		) {
 			return SchemaValidationErrors.ObjectNode_FieldNotInSchema;
 		}
 	} else if (schema instanceof MapNodeStoredSchema) {

package/src/feature-libraries/index.ts

@@ -16,7 +16,6 @@ export {
 	mapTreeFromCursor,
 	mapTreeFieldFromCursor,
 } from "./mapTreeCursor.js";
-export { MemoizedIdRangeAllocator, type IdRange } from "./memoizedIdRangeAllocator.js";
 export { buildForest } from "./object-forest/index.js";
 export { SchemaSummarizer, encodeTreeSchema, makeSchemaCodec } from "./schema-index/index.js";
 export {
@@ -76,7 +75,20 @@ export {
 	type FieldKindConfigurationEntry,
 	getAllowedContentDiscrepancies,
 	isRepoSuperset,
+	type AllowedTypeDiscrepancy,
+	type FieldKindDiscrepancy,
+	type ValueSchemaDiscrepancy,
+	type FieldDiscrepancy,
+	type NodeDiscrepancy,
+	type NodeKindDiscrepancy,
+	type NodeFieldsDiscrepancy,
 	isNeverTree,
+	type LinearExtension,
+	type Realizer,
+	fieldRealizer,
+	PosetComparisonResult,
+	comparePosetElements,
+	posetLte,
 } from "./modular-schema/index.js";
 
 export { mapRootChanges } from "./deltaUtils.js";

package/src/feature-libraries/indexing/anchorTreeIndex.ts

@@ -82,6 +82,8 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 	 * @param getValue - a pure and functional function that returns the associated value of one or more anchor nodes, can be used to map and filter the indexed anchor nodes
 	 * so that the values returned from the index are more usable
 	 * @param checkTreeStatus - a function that gets the tree status from an anchor node, used for filtering out detached nodes
+	 * @param isShallowIndex - indicates if this index is shallow, meaning that it only allows nodes to be keyed off of fields directly under them rather than anywhere in their subtree.
+	 * As a performance optimization, re-indexing up the spine can be turned off for shallow indexes.
 	 */
 	public constructor(
 		private readonly forest: IForestSubscription,
@@ -90,6 +92,7 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 		) => KeyFinder<TKey> | undefined,
 		private readonly getValue: (anchorNodes: TreeIndexNodes<AnchorNode>) => TValue | undefined,
 		private readonly checkTreeStatus: (node: AnchorNode) => TreeStatus | undefined,
+		private readonly isShallowIndex = false,
 	) {
 		this.forest.registerAnnouncedVisitor(this.keyFinder);
 
@@ -132,6 +135,14 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 				this.indexField(detachedCursor);
 				detachedCursor.free();
 			},
+			afterAttach: () => {
+				assert(parent !== undefined, 0xa99 /* must have a parent */);
+				this.reIndexSpine(parent);
+			},
+			afterDetach: () => {
+				assert(parent !== undefined, 0xa9a /* must have a parent */);
+				this.reIndexSpine(parent);
+			},
 			// when a replace happens, the keys of previously indexed nodes could be changed so we must re-index them
 			afterReplace: () => {
 				assert(parent !== undefined, 0xa8b /* must have a parent */);
@@ -142,9 +153,12 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 					0xa8c /* replace should happen in a node */,
 				);
 				cursor.exitNode();
-				// we must re-index the spine because the key finders allow for any value under a subtree to be the key
-				// this means that a replace can cause the key for any node up its spine to be changed
-				this.indexSpine(cursor);
+				this.indexField(cursor);
+				if (!this.isShallowIndex) {
+					// we must also re-index the spine if the key finders allow for any value under a subtree to be the key
+					// this means that a replace can cause the key for any node up its spine to be changed
+					this.indexSpine(cursor);
+				}
 				cursor.clear();
 			},
 			// the methods below are used to keep track of the path that has been traversed by the visitor
@@ -297,6 +311,23 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 		this.disposed = true;
 	}
 
+	/**
+	 * Checks if the spine needs to be re-indexed and if so, re-indexes it starting from the given path.
+	 */
+	private reIndexSpine(path: UpPath): void {
+		if (!this.isShallowIndex) {
+			const cursor = this.forest.allocateCursor();
+			this.forest.moveCursorToPath(path, cursor);
+			assert(
+				cursor.mode === CursorLocationType.Nodes,
+				0xa9b /* attach should happen in a node */,
+			);
+			cursor.exitNode();
+			this.indexSpine(cursor);
+			cursor.clear();
+		}
+	}
+
 	private checkNotDisposed(errorMessage?: string): void {
 		if (this.disposed) {
 			if (errorMessage !== undefined) {
@@ -371,8 +402,6 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 	 * Given a cursor in field mode, indexes all nodes under the field and then indexes all nodes up the spine.
 	 */
 	private indexSpine(cursor: ITreeSubscriptionCursor): void {
-		this.indexField(cursor);
-
 		if (keyAsDetachedField(cursor.getFieldKey()) !== rootField) {
 			cursor.exitField();
 			cursor.exitNode();

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

@@ -4,13 +4,7 @@
  */
 
 import type { ChangesetLocalId, RevisionTag } from "../../core/index.js";
-import {
-	type RangeMap,
-	type RangeQueryResult,
-	getFromRangeMap,
-	getOrAddInMap,
-	setInRangeMap,
-} from "../../util/index.js";
+import { RangeMap, type RangeQueryResult } from "../../util/index.js";
 import type { NodeId } from "./modularChangeTypes.js";
 
 export type CrossFieldMap<T> = Map<RevisionTag | undefined, RangeMap<T>>;
@@ -32,7 +26,12 @@ export function setInCrossFieldMap<T>(
 	count: number,
 	value: T,
 ): void {
-	setInRangeMap(getOrAddInMap(map, revision, []), id, count, value);
+	let rangeMap = map.get(revision);
+	if (rangeMap === undefined) {
+		rangeMap = new RangeMap();
+		map.set(revision, rangeMap);
+	}
+	rangeMap.set(id, count, value);
 }
 
 export function getFirstFromCrossFieldMap<T>(
@@ -41,7 +40,8 @@ export function getFirstFromCrossFieldMap<T>(
 	id: ChangesetLocalId,
 	count: number,
 ): RangeQueryResult<T> {
-	return getFromRangeMap(map.get(revision) ?? [], id, count);
+	const rangeMap = map.has(revision) ? (map.get(revision) as RangeMap<T>) : new RangeMap<T>();
+	return rangeMap.get(id, count);
 }
 
 /**

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

@@ -6,6 +6,7 @@
 import { assert } from "@fluidframework/core-utils/internal";
 
 import {
+	type FieldKey,
 	type FieldKindIdentifier,
 	LeafNodeStoredSchema,
 	MapNodeStoredSchema,
@@ -25,6 +26,7 @@ import { brand } from "../../util/index.js";
 // Rather than both existing, one of which just returns boolean and the other which returns additional details, a simple comparison which returns everything needed should be used.
 
 /**
+ * Discriminated union (keyed on `mismatch`) of discrepancies between a view and stored schema.
  * @remarks
  *
  * 1. FieldDiscrepancy
@@ -60,47 +62,73 @@ export type Discrepancy = FieldDiscrepancy | NodeDiscrepancy;
 
 export type NodeDiscrepancy = NodeKindDiscrepancy | NodeFieldsDiscrepancy;
 
+/**
+ * A discrepancy in the declaration of a field.
+ */
 export type FieldDiscrepancy =
 	| AllowedTypeDiscrepancy
 	| FieldKindDiscrepancy
 	| ValueSchemaDiscrepancy;
 
-export interface AllowedTypeDiscrepancy {
-	identifier: string | undefined; // undefined indicates root field schema
+/**
+ * Information about where a field discrepancy is located within a collection of schema.
+ */
+export interface FieldDiscrepancyLocation {
+	/**
+	 * The {@link TreeNodeSchemaIdentifier} that contains the discrepancy.
+	 *
+	 * Undefined iff the discrepancy is part of the root field schema.
+	 */
+	identifier: TreeNodeSchemaIdentifier | undefined;
+	/**
+	 * The {@link FieldKey} for the field that contains the discrepancy.
+	 * Undefined when:
+	 * - the discrepancy is part of the root field schema
+	 * - the discrepancy is for 'all fields' of a map node
+	 */
+	fieldKey: FieldKey | undefined;
+}
+
+/**
+ * A discrepancy in the allowed types of a field.
+ *
+ * @remarks
+ * This reports the symmetric difference of allowed types in view/stored to enable more efficient checks for compatibility
+ */
+export interface AllowedTypeDiscrepancy extends FieldDiscrepancyLocation {
 	mismatch: "allowedTypes";
 	/**
-	 * List of allowed type identifiers in viewed schema
+	 * List of allowed type identifiers in viewed schema which are not allowed in stored schema
 	 */
-	view: string[];
+	view: TreeNodeSchemaIdentifier[];
 	/**
-	 * List of allowed type identifiers in stored schema
+	 * List of allowed type identifiers in stored schema which are not allowed in view schema
 	 */
-	stored: string[];
+	stored: TreeNodeSchemaIdentifier[];
 }
 
-export interface FieldKindDiscrepancy {
-	identifier: string | undefined; // undefined indicates root field schema
+export interface FieldKindDiscrepancy extends FieldDiscrepancyLocation {
 	mismatch: "fieldKind";
 	view: FieldKindIdentifier;
 	stored: FieldKindIdentifier;
 }
 
 export interface ValueSchemaDiscrepancy {
-	identifier: string;
+	identifier: TreeNodeSchemaIdentifier;
 	mismatch: "valueSchema";
 	view: ValueSchema | undefined;
 	stored: ValueSchema | undefined;
 }
 
 export interface NodeKindDiscrepancy {
-	identifier: string;
+	identifier: TreeNodeSchemaIdentifier;
 	mismatch: "nodeKind";
 	view: SchemaFactoryNodeKind | undefined;
 	stored: SchemaFactoryNodeKind | undefined;
 }
 
 export interface NodeFieldsDiscrepancy {
-	identifier: string;
+	identifier: TreeNodeSchemaIdentifier;
 	mismatch: "fields";
 	differences: FieldDiscrepancy[];
 }
@@ -121,26 +149,25 @@ function getNodeSchemaType(nodeSchema: TreeNodeStoredSchema): SchemaFactoryNodeK
 /**
  * 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 `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 `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 `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.
+ * See documentation on {@link Discrepancy} for details of possible discrepancies.
+ * @remarks
+ * This function does not attempt to distinguish between equivalent representations of a node/field involving extraneous never trees.
+ * For example, a Forbidden field with allowed type set `[]` is equivalent to an optional field with allowed type set `[]`,
+ * as well as an optional field with an allowed type set containing only unconstructable types.
  *
- * @returns the discrepancies between two TreeStoredSchema objects
+ * It is up to the caller to determine whether such discrepancies matter.
  */
 export function* getAllowedContentDiscrepancies(
 	view: TreeStoredSchema,
 	stored: TreeStoredSchema,
 ): Iterable<Discrepancy> {
 	// check root schema discrepancies
-	yield* getFieldDiscrepancies(view.rootFieldSchema, stored.rootFieldSchema);
+	yield* getFieldDiscrepancies(
+		view.rootFieldSchema,
+		stored.rootFieldSchema,
+		undefined,
+		undefined,
+	);
 
 	for (const result of compareMaps(view.nodeSchema, stored.nodeSchema)) {
 		switch (result.type) {
@@ -195,6 +222,7 @@ function* getNodeDiscrepancies(
 		case "object": {
 			const differences = Array.from(
 				trackObjectNodeDiscrepancies(
+					identifier,
 					view as ObjectNodeStoredSchema,
 					stored as ObjectNodeStoredSchema,
 				),
@@ -213,6 +241,7 @@ function* getNodeDiscrepancies(
 				(view as MapNodeStoredSchema).mapFields,
 				(stored as MapNodeStoredSchema).mapFields,
 				identifier,
+				undefined,
 			);
 			break;
 		case "leaf": {
@@ -241,7 +270,8 @@ function* getNodeDiscrepancies(
 function* getFieldDiscrepancies(
 	view: TreeFieldStoredSchema,
 	stored: TreeFieldStoredSchema,
-	keyOrRoot?: string,
+	identifier: TreeNodeSchemaIdentifier | undefined,
+	fieldKey: FieldKey | undefined,
 ): Iterable<FieldDiscrepancy> {
 	// Only track the symmetric differences of two sets.
 	const findSetDiscrepancies = (
@@ -256,7 +286,8 @@ function* getFieldDiscrepancies(
 	const [viewExtra, storedExtra] = findSetDiscrepancies(view.types, stored.types);
 	if (viewExtra.length > 0 || storedExtra.length > 0) {
 		yield {
-			identifier: keyOrRoot,
+			identifier,
+			fieldKey,
 			mismatch: "allowedTypes",
 			view: viewExtra,
 			stored: storedExtra,
@@ -265,7 +296,8 @@ function* getFieldDiscrepancies(
 
 	if (view.kind !== stored.kind) {
 		yield {
-			identifier: keyOrRoot,
+			identifier,
+			fieldKey,
 			mismatch: "fieldKind",
 			view: view.kind,
 			stored: stored.kind,
@@ -274,6 +306,7 @@ function* getFieldDiscrepancies(
 }
 
 function* trackObjectNodeDiscrepancies(
+	identifier: TreeNodeSchemaIdentifier,
 	view: ObjectNodeStoredSchema,
 	stored: ObjectNodeStoredSchema,
 ): Iterable<FieldDiscrepancy> {
@@ -298,7 +331,8 @@ function* trackObjectNodeDiscrepancies(
 					break;
 				}
 				yield {
-					identifier: fieldKey,
+					identifier,
+					fieldKey,
 					mismatch: "fieldKind",
 					view: result.value.kind,
 					stored: storedEmptyFieldSchema.kind,
@@ -312,7 +346,8 @@ function* trackObjectNodeDiscrepancies(
 					break;
 				}
 				yield {
-					identifier: fieldKey,
+					identifier,
+					fieldKey,
 					mismatch: "fieldKind",
 					view: storedEmptyFieldSchema.kind,
 					stored: result.value.kind,
@@ -320,12 +355,11 @@ function* trackObjectNodeDiscrepancies(
 				break;
 			}
 			case "both": {
-				yield* getFieldDiscrepancies(result.valueA, result.valueB, fieldKey);
+				yield* getFieldDiscrepancies(result.valueA, result.valueB, identifier, fieldKey);
 				break;
 			}
-			default: {
+			default:
 				break;
-			}
 		}
 	}
 }
@@ -428,13 +462,13 @@ function isFieldDiscrepancyCompatible(discrepancy: FieldDiscrepancy): boolean {
  *
  * 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>;
+export 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>[];
+export type Realizer<T> = LinearExtension<T>[];
 
 /**
  * @privateRemarks
@@ -468,7 +502,7 @@ const FieldKindIdentifiers = {
  * identifier
  * ```
  */
-const fieldRealizer: Realizer<FieldKindIdentifier> = [
+export const fieldRealizer: Realizer<FieldKindIdentifier> = [
 	[
 		FieldKindIdentifiers.forbidden,
 		FieldKindIdentifiers.identifier,
@@ -485,7 +519,7 @@ const fieldRealizer: Realizer<FieldKindIdentifier> = [
 	],
 ].map((extension) => new Map(extension.map((identifier, index) => [identifier, index])));
 
-const PosetComparisonResult = {
+export const PosetComparisonResult = {
 	Less: "<",
 	Greater: ">",
 	Equal: "=",
@@ -494,7 +528,11 @@ const PosetComparisonResult = {
 type PosetComparisonResult =
 	(typeof PosetComparisonResult)[keyof typeof PosetComparisonResult];
 
-function comparePosetElements<T>(a: T, b: T, realizer: Realizer<T>): PosetComparisonResult {
+export function comparePosetElements<T>(
+	a: T,
+	b: T,
+	realizer: Realizer<T>,
+): PosetComparisonResult {
 	let hasLessThanResult = false;
 	let hasGreaterThanResult = false;
 	for (const extension of realizer) {
@@ -517,7 +555,7 @@ function comparePosetElements<T>(a: T, b: T, realizer: Realizer<T>): PosetCompar
 			: PosetComparisonResult.Equal;
 }
 
-function posetLte<T>(a: T, b: T, realizer: Realizer<T>): boolean {
+export function posetLte<T>(a: T, b: T, realizer: Realizer<T>): boolean {
 	const comparison = comparePosetElements(a, b, realizer);
 	return (
 		comparison === PosetComparisonResult.Less || comparison === PosetComparisonResult.Equal

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

@@ -14,12 +14,17 @@ import type {
 	RevisionTag,
 } from "../../core/index.js";
 import type { IdAllocator, Invariant } from "../../util/index.js";
-import type { MemoizedIdRangeAllocator } from "../memoizedIdRangeAllocator.js";
 
 import type { CrossFieldManager } from "./crossFieldQueries.js";
 import type { CrossFieldKeyRange, NodeId } from "./modularChangeTypes.js";
 import type { EncodedNodeChangeset } from "./modularChangeFormat.js";
 
+export type NestedChangesIndices = [
+	NodeId,
+	number | undefined /* inputIndex */,
+	number | undefined /* outputIndex */,
+][];
+
 /**
  * Functionality provided by a field kind which will be composed with other `FieldChangeHandler`s to
  * implement a unified ChangeFamily supporting documents with multiple field kinds.
@@ -39,11 +44,7 @@ export interface FieldChangeHandler<
 		>,
 	) => ICodecFamily<TChangeset, FieldChangeEncodingContext>;
 	readonly editor: TEditor;
-	intoDelta(
-		change: TChangeset,
-		deltaFromChild: ToDelta,
-		idAllocator: MemoizedIdRangeAllocator,
-	): DeltaFieldChanges;
+	intoDelta(change: TChangeset, deltaFromChild: ToDelta): DeltaFieldChanges;
 	/**
 	 * Returns the set of removed roots that should be in memory for the given change to be applied.
 	 * A removed root is relevant if any of the following is true:
@@ -75,13 +76,16 @@ export interface FieldChangeHandler<
 	 * @param change - The field change to get the child changes from.
 	 *
 	 * @returns The set of `NodeId`s that correspond to nested changes in the given `change`.
-	 * Each `NodeId` is associated with the index of the node in the field in the input context of the changeset
-	 * (or `undefined` if the node is not attached in the input context).
+	 * Each `NodeId` is associated with the following:
+	 * - index of the node in the field in the input context of the changeset (or `undefined` if the node is not
+	 * attached in the input context).
+	 * - index of the node in the field in the output context of the changeset (or `undefined` if the node is not
+	 * attached in the output context).
 	 * For all returned entries where the index is defined,
 	 * the indices are are ordered from smallest to largest (with no duplicates).
 	 * The returned array is owned by the caller.
 	 */
-	getNestedChanges(change: TChangeset): [NodeId, number | undefined][];
+	getNestedChanges(change: TChangeset): NestedChangesIndices;
 
 	/**
 	 * @returns A list of all cross-field keys contained in the change.

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

@@ -17,6 +17,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 import type { CrossFieldManager } from "./crossFieldQueries.js";
 import type {
 	FieldChangeHandler,
+	NestedChangesIndices,
 	NodeChangeComposer,
 	NodeChangePruner,
 	NodeChangeRebaser,
@@ -82,8 +83,9 @@ function compose(
 	return composed;
 }
 
-function getNestedChanges(change: GenericChangeset): [NodeId, number | undefined][] {
-	return change.toArray().map(([index, nodeChange]) => [nodeChange, index]);
+function getNestedChanges(change: GenericChangeset): NestedChangesIndices {
+	// For generic changeset, the indices in the input and output contexts are the same.
+	return change.toArray().map(([index, nodeChange]) => [nodeChange, index, index]);
 }
 
 function rebaseGenericChange(

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

@@ -41,6 +41,7 @@ export {
 	type ToDelta,
 	NodeAttachState,
 	type FieldChangeEncodingContext,
+	type NestedChangesIndices,
 } from "./fieldChangeHandler.js";
 export type {
 	CrossFieldKeyRange,
@@ -77,4 +78,17 @@ export type {
 export {
 	getAllowedContentDiscrepancies,
 	isRepoSuperset,
+	type AllowedTypeDiscrepancy,
+	type FieldKindDiscrepancy,
+	type ValueSchemaDiscrepancy,
+	type FieldDiscrepancy,
+	type NodeDiscrepancy,
+	type NodeKindDiscrepancy,
+	type NodeFieldsDiscrepancy,
+	type LinearExtension,
+	type Realizer,
+	fieldRealizer,
+	PosetComparisonResult,
+	comparePosetElements,
+	posetLte,
 } from "./discrepancies.js";

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

@@ -19,9 +19,7 @@ import { fail } from "../../util/index.js";
 import type { FullSchemaPolicy } from "./fieldKind.js";
 
 /**
- * @internal
  */
-
 export function isNeverField(
 	policy: FullSchemaPolicy,
 	originalData: TreeStoredSchema,