@fluidframework/tree 2.111.0 → 2.113.0-411909

package/src/feature-libraries/chunked-forest/codec/chunkDecoding.ts

@@ -5,7 +5,6 @@
 
 import { assert, unreachableCase, oob } from "@fluidframework/core-utils/internal";
 import type {
-	IIdCompressor,
 	OpSpaceCompressedId,
 	SessionSpaceCompressedId,
 } from "@fluidframework/id-compressor";
@@ -17,7 +16,12 @@ import type {
 	Value,
 	TreeChunk,
 } from "../../../core/index.js";
-import { assertValidIndex, brand, decompressIdentifierIfNeeded } from "../../../util/index.js";
+import {
+	assertValidIndex,
+	brand,
+	decompressIdentifierIfNeeded,
+	type IdDecodingContext,
+} from "../../../util/index.js";
 import { BasicChunk } from "../basicChunk.js";
 import { emptyChunk } from "../emptyChunk.js";
 import { SequenceChunk } from "../sequenceChunk.js";
@@ -55,31 +59,6 @@ import {
 	supportsIncrementalEncoding,
 } from "./format/index.js";
 
-/**
- * Context for decoding identifiers.
- * @remarks
- * See {@link FieldBatchDecodingContext} for the production implementation of this.
- *
- * This intentionally avoids exposing anything which depends on the underlying id-compressor's session ID to avoid confusion with the session ID of the compressor which encoded the data.
- * If the session ID of the encoder which encoded the data is known, that information is baked into `resolveEncodedId`.
- */
-export interface IdDecodingContext {
-	/**
-	 * Compressor which can decompress session-space identifiers from {@link resolveEncodedId} as needed.
-	 */
-	readonly idCompressor: Pick<IIdCompressor, "decompress">;
-	/**
-	 * Resolves an encoded op-space identifier to either a session-space ID
-	 * (which {@link idCompressor} can decompress if needed)
-	 * or a string (which passes through unchanged).
-	 * @remarks
-	 * In contexts where non-final identifiers can't be supported (where no originator session is available),
-	 * if a non-final identifier is encountered, this may throw or perform a data healing workaround.
-	 * See {@link FieldBatchDecodingContext.forOp} and {@link FieldBatchDecodingContext.forSummary} for details.
-	 */
-	readonly resolveEncodedId: (id: OpSpaceCompressedId) => SessionSpaceCompressedId | string;
-}
-
 /**
  * Decode `chunk` into a TreeChunk.
  */

package/src/feature-libraries/chunked-forest/codec/chunkDecodingGeneric.ts

@@ -7,7 +7,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import type { DiscriminatedUnionDispatcher } from "../../../codec/index.js";
 import type { TreeChunk } from "../../../core/index.js";
-import type { BrandedType } from "../../../util/index.js";
+import type { BrandedType, IdDecodingContext } from "../../../util/index.js";
 
 import {
 	type ChunkDecoder,
@@ -15,7 +15,6 @@ import {
 	getChecked,
 	readStream,
 } from "./chunkCodecUtilities.js";
-import type { IdDecodingContext } from "./chunkDecoding.js";
 import type { IncrementalDecoder } from "./codecs.js";
 import type { EncodedFieldBatchGeneric, IdentifierOrIndex } from "./format/index.js";
 

package/src/feature-libraries/chunked-forest/codec/codecs.ts

@@ -4,12 +4,7 @@
  */
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import type {
-	IIdCompressor,
-	OpSpaceCompressedId,
-	SessionId,
-	SessionSpaceCompressedId,
-} from "@fluidframework/id-compressor";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 import { lowestMinVersionForCollab } from "@fluidframework/runtime-utils/internal";
 import type { TSchema } from "@sinclair/typebox";
 
@@ -29,13 +24,14 @@ import {
 } from "../../../core/index.js";
 import {
 	brandedNumberType,
-	forceDecodeEncodedIdWithoutSession,
+	IdDecodingContext,
 	type Brand,
-	type IdentifierHealingConfig,
+	type IdDecoderOptionsOriginatorless,
+	type IdDecoderOptionsWithOriginator,
 } from "../../../util/index.js";
 import { TreeCompressionStrategy } from "../../treeCompressionUtils.js";
 
-import { decode, type IdDecodingContext } from "./chunkDecoding.js";
+import { decode } from "./chunkDecoding.js";
 import type { FieldBatch } from "./fieldBatch.js";
 import {
 	EncodedFieldBatchV1,
@@ -148,26 +144,18 @@ export interface FieldBatchEncodingContext {
  * op-style and summary-style decoding is load-bearing (different invariants
  * apply, and bugs in this area are typically the result of conflating them).
  */
-export class FieldBatchDecodingContext implements IdDecodingContext {
+export class FieldBatchDecodingContext extends IdDecodingContext {
 	private constructor(
-		/**
-		 * Used internally to prevent the use of this decoder in incremental chunks if it has a session id (which would be wrong in those chunks).
-		 */
-		private readonly hasOriginatorSessionId: boolean,
-
-		public readonly idCompressor: Pick<IIdCompressor, "decompress">,
-
-		public readonly resolveEncodedId: (
-			id: OpSpaceCompressedId,
-		) => SessionSpaceCompressedId | string,
-
+		private readonly options: IdDecoderOptionsOriginatorless | IdDecoderOptionsWithOriginator,
 		/**
 		 * Decoder for incremental fields. Defined when the encoded batch contains
 		 * incremental chunks. Only populated on summary-style contexts; op-style
 		 * contexts always have this undefined.
 		 */
 		public readonly incrementalDecoder?: IncrementalDecoder,
-	) {}
+	) {
+		super(options);
+	}
 
 	/**
 	 * Construct a decode context for an op.
@@ -178,14 +166,8 @@ export class FieldBatchDecodingContext implements IdDecodingContext {
 	 * not a recoverable state, so the resolver throws rather than synthesizing
 	 * a UUID. Incremental decoding is not used for ops.
 	 */
-	public static forOp(opts: {
-		readonly idCompressor: IIdCompressor;
-		readonly originatorId: SessionId;
-	}): FieldBatchDecodingContext {
-		const { idCompressor, originatorId } = opts;
-		return new FieldBatchDecodingContext(true, idCompressor, (id) =>
-			idCompressor.normalizeToSessionSpace(id, originatorId),
-		);
+	public static forOp(options: IdDecoderOptionsWithOriginator): FieldBatchDecodingContext {
+		return new FieldBatchDecodingContext(options);
 	}
 
 	/**
@@ -204,14 +186,10 @@ export class FieldBatchDecodingContext implements IdDecodingContext {
 	 * `withIncrementalDecoder` has logic to guard against cases which expect session-relative identifiers in incremental chunks,
 	 * as does the encoding-side assert in the {@link EncoderContext}.
 	 */
-	public static forSummary(opts: {
-		readonly idCompressor: IIdCompressor;
-		readonly healing?: IdentifierHealingConfig;
-	}): FieldBatchDecodingContext {
-		const { idCompressor, healing } = opts;
-		return new FieldBatchDecodingContext(false, idCompressor, (id) =>
-			forceDecodeEncodedIdWithoutSession(id, idCompressor, healing),
-		);
+	public static forSummary(
+		options: IdDecoderOptionsOriginatorless | IdDecoderOptionsWithOriginator,
+	): FieldBatchDecodingContext {
+		return new FieldBatchDecodingContext(options);
 	}
 
 	/**
@@ -231,12 +209,7 @@ export class FieldBatchDecodingContext implements IdDecodingContext {
 			!this.hasOriginatorSessionId,
 			0xd0c /* withIncrementalDecoder can only be called on contexts without an originator session ID */,
 		);
-		return new FieldBatchDecodingContext(
-			false,
-			this.idCompressor,
-			this.resolveEncodedId,
-			incrementalDecoder,
-		);
+		return new FieldBatchDecodingContext(this.options, incrementalDecoder);
 	}
 }
 

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

@@ -38,7 +38,7 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 		compose: (change1: 0, change2: 0) => 0,
 		invert: (changes: 0) => 0,
 		rebase: (change: 0, over: 0) => 0,
-		mute: (changes: 0) => 0,
+		filterEdits: (changes: 0) => 0,
 	}),
 	codecsFactory: () => noChangeCodecFamily,
 	editor: { buildChildChanges: () => fail(0xb0d /* Child changes not supported */) },

package/src/feature-libraries/index.ts

@@ -93,6 +93,7 @@ export {
 	isNeverTree,
 	DefaultRevisionReplacer,
 	ModularChangeFormatVersion,
+	minimizeModularChangeset,
 } from "./modular-schema/index.js";
 
 export { mapRootChanges } from "./deltaUtils.js";
@@ -149,6 +150,7 @@ export {
 
 export {
 	SchemaValidationError,
+	type SchemaValidationErrorContext,
 	isNodeInSchema,
 	isFieldInSchema,
 	throwOutOfSchema,

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

@@ -5,6 +5,7 @@
 
 import type { ICodecFamily, JsonCodecPart } from "../../codec/index.js";
 import type {
+	ChangeAtomId,
 	ChangeEncodingContext,
 	DeltaDetachedNodeChanges,
 	DeltaDetachedNodeId,
@@ -16,7 +17,7 @@ import type {
 	RevisionTag,
 	RevisionTagSchema,
 } from "../../core/index.js";
-import type { IdAllocator, Invariant } from "../../util/index.js";
+import type { IdAllocator, Invariant, RangeQueryResult } from "../../util/index.js";
 
 import type { CrossFieldManager } from "./crossFieldQueries.js";
 import type { EncodedNodeChangeset } from "./modularChangeFormatV1.js";
@@ -167,10 +168,53 @@ export interface FieldChangeRebaser<TChangeset> {
 	replaceRevisions(change: TChangeset, replacer: RevisionReplacer): TChangeset;
 
 	/**
-	 * Returns a copy of the given changeset with the same declarations (e.g., new cells) but no actual changes.
-	 * This is a kludge. TODO: remove once AB#46104 is completed.
+	 * Returns a copy of the given changeset with edits removed as specified.
+	 * @param change - The change to filter edits from
+	 * @param filterDetach - This should be called for each range of detaches in the changeset,
+	 * and the detach should be preserved, removed, or converted to a non-move detach as specified.
+	 * If the returned result does not cover the entire detach range, the remainder should be queried again.
+	 * @param filterDetach - This should be called for each range of attaches in the changeset,
+	 * and the attach should be preserved, removed, or converted to a non-move attach as specified.
+	 * If the returned result does not cover the entire detach range, the remainder should be queried again.
+	 * @param preserveOtherEdits - Whether edits other than attaches and detaches (e.g. root renames),
+	 * should be preserved or removed.
 	 */
-	mute(change: TChangeset): TChangeset;
+	filterEdits(
+		change: TChangeset,
+		options: {
+			filterDetach: EditFilterFunc;
+			filterAttach: EditFilterFunc;
+			preserveOtherEdits: boolean;
+		},
+	): TChangeset;
+}
+
+export type EditFilterFunc = (
+	id: ChangeAtomId,
+	count: number,
+	endpoint?: ChangeAtomId,
+) => RangeQueryResult<EditFilterStatus>;
+
+/**
+ * Used to describe what should be done with a particular attach or detach during `filterEdits`.
+ */
+export enum EditFilterStatus {
+	/**
+	 * The edit should be removed from the filtered changeset.
+	 */
+	Remove,
+
+	/**
+	 * The edit should be preserved in the filtered changeset.
+	 */
+	Preserve,
+
+	/**
+	 * This should only be used for an attach or detach which is part of a move.
+	 * The edit should be preserved, but should be adjusted, if necessary,
+	 * to reflect that the other endpoint of the move has been filtered out.
+	 */
+	PreserveWithoutMove,
 }
 
 /**
@@ -181,13 +225,13 @@ export function referenceFreeFieldChangeRebaser<TChangeset>(data: {
 	compose: (change1: TChangeset, change2: TChangeset) => TChangeset;
 	invert: (change: TChangeset) => TChangeset;
 	rebase: (change: TChangeset, over: TChangeset) => TChangeset;
-	mute: (change: TChangeset) => TChangeset;
+	filterEdits: FieldChangeRebaser<TChangeset>["filterEdits"];
 }): FieldChangeRebaser<TChangeset> {
 	return isolatedFieldChangeRebaser({
 		compose: (change1, change2, _composeChild, _genId) => data.compose(change1, change2),
 		invert: (change, _invertChild, _genId) => data.invert(change),
 		rebase: (change, over, _rebaseChild, _genId) => data.rebase(change, over),
-		mute: (change) => data.mute(change),
+		filterEdits: (change, options) => data.filterEdits(change, options),
 	});
 }
 
@@ -195,7 +239,7 @@ export function isolatedFieldChangeRebaser<TChangeset>(data: {
 	compose: FieldChangeRebaser<TChangeset>["compose"];
 	invert: FieldChangeRebaser<TChangeset>["invert"];
 	rebase: FieldChangeRebaser<TChangeset>["rebase"];
-	mute: FieldChangeRebaser<TChangeset>["mute"];
+	filterEdits: FieldChangeRebaser<TChangeset>["filterEdits"];
 }): FieldChangeRebaser<TChangeset> {
 	return {
 		...data,

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

@@ -40,7 +40,7 @@ export const genericChangeHandler: FieldChangeHandler<GenericChangeset> = {
 		rebase: rebaseGenericChange,
 		prune: pruneGenericChange,
 		replaceRevisions,
-		mute: (change: GenericChangeset): GenericChangeset => change,
+		filterEdits: (change: GenericChangeset): GenericChangeset => change,
 	},
 	codecsFactory: makeGenericChangeCodec,
 	editor: {

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

@@ -29,10 +29,14 @@ export {
 export { EncodedModularChangesetV2 } from "./modularChangeFormatV2.js";
 export { FlexFieldKind, type FullSchemaPolicy } from "./fieldKind.js";
 export {
+	type EditFilterFunc,
+	EditFilterStatus,
 	type FieldChangeHandler,
 	type FieldChangeDelta,
+	type FieldChangeEncodingContext,
 	type FieldChangeRebaser,
 	type FieldEditor,
+	type NestedChangesIndices,
 	type NodeChangeComposer,
 	type NodeChangeInverter,
 	type NodeChangeRebaser,
@@ -42,8 +46,6 @@ export {
 	type RelevantRemovedRootsFromChild,
 	type ToDelta,
 	NodeAttachState,
-	type FieldChangeEncodingContext,
-	type NestedChangesIndices,
 } from "./fieldChangeHandler.js";
 export type {
 	CrossFieldKey,
@@ -83,3 +85,4 @@ export type {
 	FieldKindConfigurationEntry,
 } from "./fieldKindConfiguration.js";
 export { DefaultRevisionReplacer } from "./defaultRevisionReplacer.js";
+export { minimizeModularChangeset } from "./minimizeModularChange.js";

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

@@ -0,0 +1,33 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { FieldKindIdentifier } from "../../core/index.js";
+
+import type { FlexFieldKind } from "./fieldKind.js";
+import type { ModularChangeset } from "./modularChangeTypes.js";
+
+/**
+ * "Minimizes" a {@link ModularChangeset} so that it contains no extraneous
+ * information, i.e. no new content that isn't observable from document tree
+ * and no edits without net observed effect on the document tree.
+ * @remarks
+ * "Extraneous information" includes, for example, data for nodes that were both created and removed within the same
+ * transaction, or changes whose effects cancel out to nothing. Minimizing reduces the size of an edit without altering
+ * its observable effect.
+ *
+ * This is the eventual home of the minimization algorithm, colocated with {@link ModularChangeFamily} so it can use its
+ * internals. It is currently a no-op that returns the change unchanged; a real implementation will be provided in a
+ * future change.
+ *
+ * @param change - The change to minimize.
+ * @param fieldKinds - The field kinds to delegate to when computing the change's delta.
+ */
+export function minimizeModularChangeset(
+	change: ModularChangeset,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): ModularChangeset {
+	// TODO: Actually minimize the change. For now this is a no-op that returns the change unchanged.
+	return change;
+}

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

@@ -82,6 +82,7 @@ import {
 	setInCrossFieldMap,
 } from "./crossFieldQueries.js";
 import {
+	EditFilterStatus,
 	type FieldChangeHandler,
 	NodeAttachState,
 	type RebaseRevisionMetadata,
@@ -1739,11 +1740,25 @@ export class ModularChangeFamily
 		const handler = getChangeHandler(this.fieldKinds, change.fieldKind);
 		return {
 			fieldKind: change.fieldKind,
-			change: brand(handler.rebaser.mute(change.change)),
+			change: brand(
+				handler.rebaser.filterEdits(change.change, {
+					filterDetach: removeAllEditsFilter,
+					filterAttach: removeAllEditsFilter,
+					preserveOtherEdits: false,
+				}),
+			),
 		};
 	}
 }
 
+function removeAllEditsFilter(
+	_id: ChangeAtomId,
+	count: number,
+	_endpointId?: ChangeAtomId,
+): RangeQueryResult<EditFilterStatus> {
+	return { value: EditFilterStatus.Remove, length: count };
+}
+
 function replaceCrossFieldKeyTableRevisions(
 	table: CrossFieldKeyTable,
 	replacer: RevisionReplacer,

package/src/feature-libraries/optional-field/optionalField.ts

@@ -35,6 +35,7 @@ import {
 	requiredIdentifier,
 } from "../fieldKindIdentifiers.js";
 import {
+	EditFilterStatus,
 	type FieldChangeHandler,
 	type FieldChangeRebaser,
 	type FieldEditor,
@@ -48,6 +49,7 @@ import {
 	type NestedChangesIndices,
 	type FieldChangeDelta,
 	FlexFieldKind,
+	type EditFilterFunc,
 } from "../modular-schema/index.js";
 
 import type {
@@ -466,9 +468,7 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 		return updated;
 	},
 
-	mute: (change: OptionalChangeset): OptionalChangeset => {
-		return { childChanges: change.childChanges, moves: [] };
-	},
+	filterEdits,
 };
 
 function replaceReplaceRevisions(
@@ -814,3 +814,43 @@ export const optional: Optional = new FlexFieldKind(
 		]),
 	},
 );
+
+function filterEdits(
+	change: OptionalChangeset,
+	options: {
+		filterDetach: EditFilterFunc;
+		filterAttach: EditFilterFunc;
+		preserveOtherEdits: boolean;
+	},
+): OptionalChangeset {
+	const filtered: Mutable<OptionalChangeset> = { ...change };
+	if (filtered.valueReplace !== undefined) {
+		if (isReplaceEffectful(filtered.valueReplace)) {
+			const detachId = getEffectfulDst(filtered.valueReplace);
+			const detachResult =
+				detachId === undefined ? undefined : options.filterDetach(detachId, 1).value;
+
+			const attachId = filtered.valueReplace.src;
+			const attachResult =
+				attachId === undefined ? undefined : options.filterAttach(attachId, 1).value;
+
+			if (detachResult === EditFilterStatus.Remove) {
+				assert(
+					attachId === undefined || attachResult === EditFilterStatus.Remove,
+					"Cannot remove detach without also removing attach",
+				);
+
+				delete filtered.valueReplace;
+			} else if (attachResult === EditFilterStatus.Remove) {
+				delete filtered.valueReplace.src;
+			}
+		} else if (!options.preserveOtherEdits) {
+			delete filtered.valueReplace;
+		}
+	}
+
+	if (!options.preserveOtherEdits) {
+		filtered.moves = [];
+	}
+	return filtered;
+}

package/src/feature-libraries/schemaChecker.ts

@@ -32,13 +32,82 @@ export enum SchemaValidationError {
 	Node_MissingSchema,
 }
 
+/**
+ * Additional context about a schema validation error.
+ * @remarks
+ * Not all fields are populated for every error type — only those relevant to the specific error.
+ */
+export interface SchemaValidationErrorContext {
+	/**
+	 * The type identifier of the node that failed validation.
+	 */
+	readonly nodeType?: string;
+	/**
+	 * The set of type identifiers allowed in the field, if applicable.
+	 */
+	readonly allowedTypes?: ReadonlySet<string>;
+	/**
+	 * Field keys on the node that were not recognized by its schema.
+	 */
+	readonly unexpectedFields?: ReadonlySet<string>;
+}
+
 /**
  * Throws a UsageError indicating a tree is out of schema.
  */
-export function throwOutOfSchema(maybeError: SchemaValidationError): never {
-	throw new UsageError(
-		`Tree does not conform to schema: ${SchemaValidationError[maybeError]}`,
-	);
+export function throwOutOfSchema(
+	maybeError: SchemaValidationError,
+	context?: SchemaValidationErrorContext,
+): never {
+	throw new UsageError(formatSchemaValidationError(maybeError, context));
+}
+
+// Not exported: internal helper used by throwOutOfSchema.
+function formatSchemaValidationError(
+	error: SchemaValidationError,
+	context: SchemaValidationErrorContext | undefined,
+): string {
+	switch (error) {
+		case SchemaValidationError.Field_NodeTypeNotAllowed: {
+			const nodeDesc = context?.nodeType === undefined ? "unknown" : `"${context.nodeType}"`;
+			const allowedDesc =
+				context?.allowedTypes === undefined
+					? "unknown"
+					: `[${[...context.allowedTypes].map((t) => `"${t}"`).join(", ")}]`;
+			return (
+				`Tree does not conform to schema. ` +
+				`A node of type ${nodeDesc} is not allowed in this field. Allowed types: ${allowedDesc}. ` +
+				`If using a staged allowed type, the stored schema has not been upgraded to include this type yet. ` +
+				`Either upgrade the schema to enable the staged type or avoid inserting content of this type until the schema is upgraded.`
+			);
+		}
+		case SchemaValidationError.Node_MissingSchema: {
+			const nodeDesc = context?.nodeType === undefined ? "unknown" : `"${context.nodeType}"`;
+			return (
+				`Tree does not conform to schema. ` +
+				`No schema definition was found for node type ${nodeDesc}. ` +
+				`Ensure the node's type is included in the schema and that the stored schema has been upgraded if needed.`
+			);
+		}
+		case SchemaValidationError.ObjectNode_FieldNotInSchema: {
+			const nodeDesc = context?.nodeType === undefined ? "unknown" : `"${context.nodeType}"`;
+			const fieldsDesc =
+				context?.unexpectedFields === undefined || context.unexpectedFields.size === 0
+					? undefined
+					: `[${[...context.unexpectedFields].map((f) => `"${f}"`).join(", ")}]`;
+			const fieldsPart =
+				fieldsDesc === undefined
+					? "The node has fields that are not defined in its schema."
+					: `Unexpected fields: ${fieldsDesc}.`;
+			return (
+				`Tree does not conform to schema. ` +
+				`A node of type ${nodeDesc} has fields not defined in its schema. ${fieldsPart}`
+			);
+		}
+		default: {
+			return `Tree does not conform to schema: ${SchemaValidationError[error]}.`;
+		}
+	}
 }
 
 type NotUndefined = number | string | boolean | bigint | symbol | object;
@@ -53,12 +122,14 @@ type NotUndefined = number | string | boolean | bigint | symbol | object;
 export function isNodeInSchema<T extends NotUndefined>(
 	node: MinimalMapTreeNodeView,
 	schemaAndPolicy: SchemaAndPolicy,
-	onError: (error: SchemaValidationError) => T,
+	onError: (error: SchemaValidationError, context?: SchemaValidationErrorContext) => T,
 ): T | undefined {
 	// Validate the schema declared by the node exists
 	const schema = schemaAndPolicy.schema.nodeSchema.get(node.type);
 	if (schema === undefined) {
-		return onError(SchemaValidationError.Node_MissingSchema);
+		return onError(SchemaValidationError.Node_MissingSchema, {
+			nodeType: node.type,
+		});
 	}
 
 	// Validate the node is well formed according to its schema
@@ -95,7 +166,10 @@ export function isNodeInSchema<T extends NotUndefined>(
 			// Code using this with a stored schema derived from a view schema rather than the document can be problematic because it may be missing unknown fields that the actual document has.
 			// Other schema evolution features like "staged" allowed types will likely cause similar issues elsewhere in this checker.
 			if (uncheckedFieldsFromNode.size > 0) {
-				return onError(SchemaValidationError.ObjectNode_FieldNotInSchema);
+				return onError(SchemaValidationError.ObjectNode_FieldNotInSchema, {
+					nodeType: node.type,
+					unexpectedFields: uncheckedFieldsFromNode,
+				});
 			}
 		} else if (schema instanceof MapNodeStoredSchema) {
 			for (const [_key, field] of node.fields) {
@@ -128,7 +202,7 @@ export function isFieldInSchema<T extends NotUndefined>(
 	childNodes: MapTreeFieldViewGeneric<MinimalMapTreeNodeView>,
 	schema: TreeFieldStoredSchema,
 	schemaAndPolicy: SchemaAndPolicy,
-	onError: (error: SchemaValidationError) => T,
+	onError: (error: SchemaValidationError, context?: SchemaValidationErrorContext) => T,
 ): T | undefined {
 	// Validate that the field kind is handled by the schema policy
 	const kind = schemaAndPolicy.policy.fieldKinds.get(schema.kind);
@@ -147,7 +221,10 @@ export function isFieldInSchema<T extends NotUndefined>(
 	for (const node of childNodes) {
 		// Validate the type declared by the node is allowed in this field
 		if (schema.types !== undefined && !schema.types.has(node.type)) {
-			return onError(SchemaValidationError.Field_NodeTypeNotAllowed);
+			return onError(SchemaValidationError.Field_NodeTypeNotAllowed, {
+				nodeType: node.type,
+				allowedTypes: schema.types,
+			});
 		}
 
 		// Validate the node complies with the type it declares to be.