@fluidframework/tree 2.91.0 → 2.92.0

package/src/codec/codec.ts

@@ -202,6 +202,27 @@ export interface IJsonCodec<
 	encodedSchema?: TAnySchema;
 }
 
+/**
+ * Part of a codec.
+ * @remarks
+ * Encode and decode logic and schema for some chunk of data.
+ * Can be composed into larger codecs, and eventually versioned at the top level using
+ * {@link VersionDispatchingCodecBuilder}.
+ *
+ * This portion of a codec is not responsible for managing versioning or validation of the data against the schema.
+ */
+export interface JsonCodecPart<TDecoded, TEncodedSchema extends TAnySchema, TContext = void>
+	extends IEncoder<TDecoded, Static<TEncodedSchema>, TContext>,
+		IDecoder<TDecoded, Static<TEncodedSchema>, TContext> {
+	/**
+	 * TypeBox schema which describes the encoded format for this chunk of data.
+	 * @remarks
+	 * The user of this codec can use this to build its own larger schema,
+	 * until eventually it is provided to the {@link VersionDispatchingCodecBuilder}.
+	 */
+	encodedSchema: TEncodedSchema;
+}
+
 /**
  * Type erase the more detailed encoded type from a codec.
  */
@@ -398,6 +419,7 @@ export function withSchemaValidation<
 			}
 			return codec.decode(encoded, context);
 		},
+		encodedSchema: schema,
 	};
 }
 
@@ -529,9 +551,17 @@ export const FluidClientVersion = {
  */
 export const currentVersion: MinimumVersionForCollab = runtimeUtilsCleanedPackageVersion;
 
-export interface CodecTree {
+/**
+ * TODO:
+ * This needs to be documented.
+ * Its documentation should cover at least the following:
+ * - Is this used for anything other than testing.
+ * - What should be included as children. For example should it include versioned codecs which dispatch base on the min version for collaboration? If so, what version of them should be used?
+ * - What risks does having this mitigate?
+ */
+export interface CodecTree<TFormatVersion extends FormatVersion = FormatVersion> {
 	readonly name: string;
-	readonly version: FormatVersion;
+	readonly version: TFormatVersion;
 	readonly children?: readonly CodecTree[];
 }
 

package/src/codec/index.ts

@@ -28,6 +28,7 @@ export {
 	extractJsonValidator,
 	type CodecName,
 	eraseEncodedType,
+	type JsonCodecPart,
 } from "./codec.js";
 export {
 	DiscriminatedUnionDispatcher,
@@ -36,9 +37,7 @@ export {
 } from "./discriminatedUnions.js";
 export {
 	Versioned,
-	makeVersionedValidatedCodec,
-	makeVersionDispatchingCodec,
-	makeDiscontinuedCodecVersion,
+	makeDiscontinuedCodecAndSchema,
 	ClientVersionDispatchingCodecBuilder,
 	type CodecVersion,
 	type CodecAndSchema,

package/src/codec/versioned/codec.ts

@@ -12,16 +12,16 @@ import {
 	type SemanticVersion,
 } from "@fluidframework/runtime-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
-import { Type, type TSchema } from "@sinclair/typebox";
+import type { TSchema } from "@sinclair/typebox";
 import { gt } from "semver-ts";
 
 import { pkgVersion } from "../../packageVersion.js";
-import type {
-	JsonCompatibleReadOnly,
-	JsonCompatibleReadOnlyObject,
+import {
+	JsonCompatibleReadOnlySchema,
+	type JsonCompatibleReadOnly,
+	type JsonCompatibleReadOnlyObject,
 } from "../../util/index.js";
 import {
-	type ICodecFamily,
 	type ICodecOptions,
 	type IJsonCodec,
 	withSchemaValidation,
@@ -90,10 +90,8 @@ The client which encoded this data likely specified an "minVersionForCollab" val
  * @remarks
  * The passed in codec should not perform its own schema validation.
  * The schema validation gets added here.
- *
- * TODO: users of this should migrate to {@link ClientVersionDispatchingCodecBuilder}.
  */
-export function makeVersionedValidatedCodec<
+function makeVersionedValidatedCodec<
 	EncodedSchema extends TSchema,
 	TDecoded,
 	TEncoded extends Versioned = VersionedJson,
@@ -104,77 +102,46 @@ export function makeVersionedValidatedCodec<
 	supportedVersions: Set<FormatVersion>,
 	schema: EncodedSchema,
 	codec: IJsonCodec<TDecoded, TEncoded, TValidate, TContext>,
-): IJsonCodec<TDecoded, TEncoded, TValidate, TContext> {
-	return makeVersionedCodec(
-		supportedVersions,
-		options,
-		withSchemaValidation(schema, codec, options.jsonValidator),
-	);
+): IJsonCodec<TDecoded, TEncoded, TValidate, TContext> &
+	Pick<CodecAndSchema<TDecoded, TContext>, "schema"> {
+	return {
+		...makeVersionedCodec(
+			supportedVersions,
+			options,
+			withSchemaValidation(schema, codec, options.jsonValidator),
+		),
+		schema,
+	};
 }
 
 /**
- * Creates a codec which always throws a UsageError when encoding or decoding, indicating that the format version is discontinued.
- *
- * TODO: {@link ClientVersionDispatchingCodecBuilder} should get support for extra decode only entries and/or unstable formats (codecs without a minVersionForCollab that will never be selected for write unless overridden).
- * Once done, users of this should migrate to ClientVersionDispatchingCodecBuilder and this function can be simplified.
+ * Creates a codec version which always throws a UsageError when encoding or decoding, indicating that the format version is discontinued.
  */
-export function makeDiscontinuedCodecVersion<
+export function makeDiscontinuedCodecAndSchema<
 	TDecoded,
-	TEncoded extends Versioned = VersionedJson,
-	TContext = unknown,
+	TContext,
+	TFormatVersion extends FormatVersion = FormatVersion,
 >(
-	options: ICodecOptions,
-	discontinuedVersion: FormatVersion,
+	discontinuedVersion: TFormatVersion,
 	discontinuedSince: SemanticVersion,
-): IJsonCodec<TDecoded, TEncoded, TEncoded, TContext> {
-	const schema = Type.Object(
-		{
-			version:
-				discontinuedVersion === undefined
-					? Type.Undefined()
-					: Type.Literal(discontinuedVersion),
-		},
-		// Using `additionalProperties: true` allows this schema to be used when loading data encoded by older versions even though they contain additional properties.
-		{ additionalProperties: true },
-	);
-	const codec: IJsonCodec<TDecoded, TEncoded, TEncoded, TContext> = {
-		encode: (_: TDecoded): TEncoded => {
-			throw new UsageError(
-				`Cannot encode data to format ${discontinuedVersion}. The codec was discontinued in Fluid Framework client version ${discontinuedSince}.`,
-			);
-		},
-		decode: (data: TEncoded): TDecoded => {
-			throw new UsageError(
-				`Cannot decode data to format ${data.version}. The codec was discontinued in Fluid Framework client version ${discontinuedSince}.`,
-			);
+): CodecVersion<TDecoded, TContext, TFormatVersion> {
+	return {
+		minVersionForCollab: undefined,
+		formatVersion: discontinuedVersion,
+		codec: {
+			schema: JsonCompatibleReadOnlySchema,
+			encode: (_data: TDecoded) => {
+				throw new UsageError(
+					`Cannot encode data to format ${discontinuedVersion}. The codec was discontinued in Fluid Framework client version ${discontinuedSince}.`,
+				);
+			},
+			decode: (data: unknown) => {
+				throw new UsageError(
+					`Cannot decode data in format ${discontinuedVersion}. The codec was discontinued in Fluid Framework client version ${discontinuedSince}.`,
+				);
+			},
 		},
 	};
-	return makeVersionedValidatedCodec(options, new Set([discontinuedVersion]), schema, codec);
-}
-
-/**
- * Creates a codec which dispatches to the appropriate member of a codec family based on the version of
- * data it encounters.
- * @remarks
- * Each member of the codec family must write an explicit version number into the data it encodes (implementing {@link Versioned}).
- *
- * TODO: Users of this should migrate to {@link ClientVersionDispatchingCodecBuilder} so that the actual format version used can be encapsulated.
- */
-export function makeVersionDispatchingCodec<TDecoded, TContext>(
-	family: ICodecFamily<TDecoded, TContext>,
-	options: ICodecOptions & { writeVersion: FormatVersion },
-): IJsonCodec<TDecoded, JsonCompatibleReadOnly, JsonCompatibleReadOnly, TContext> {
-	const writeCodec = family.resolve(options.writeVersion);
-	const supportedVersions = new Set(family.getSupportedFormats());
-	return makeVersionedCodec(supportedVersions, options, {
-		encode(data, context): Versioned {
-			return writeCodec.encode(data, context) as Versioned;
-		},
-		decode(data: Versioned, context) {
-			const codec = family.resolve(data.version);
-			return codec.decode(data, context);
-		},
-	});
 }
 
 /**
@@ -218,7 +185,7 @@ export interface CodecVersion<
 	TDecoded,
 	TContext,
 	TFormatVersion extends FormatVersion,
-	TBuildOptions extends CodecWriteOptions,
+	TBuildOptions extends ICodecOptions = ICodecOptions,
 > extends CodecVersionBase<
 		| CodecAndSchema<TDecoded, TContext>
 		| ((options: TBuildOptions) => CodecAndSchema<TDecoded, TContext>),
@@ -235,11 +202,9 @@ export interface NormalizedCodecVersion<
 	TDecoded,
 	TContext,
 	TFormatVersion extends FormatVersion,
-	TBuildOptions extends CodecWriteOptions,
+	TBuildOptions extends ICodecOptions,
 > extends CodecVersionBase<
-		(
-			options: TBuildOptions,
-		) => IJsonCodec<TDecoded, VersionedJson, JsonCompatibleReadOnly, TContext>,
+		(options: TBuildOptions) => CodecAndSchema<TDecoded, TContext>,
 		TFormatVersion
 	> {}
 
@@ -249,10 +214,7 @@ export interface NormalizedCodecVersion<
  * Produced by {@link ClientVersionDispatchingCodecBuilder.applyOptions}.
  */
 interface EvaluatedCodecVersion<TDecoded, TContext, TFormatVersion extends FormatVersion>
-	extends CodecVersionBase<
-		IJsonCodec<TDecoded, VersionedJson, JsonCompatibleReadOnly, TContext>,
-		TFormatVersion
-	> {}
+	extends CodecVersionBase<CodecAndSchema<TDecoded, TContext>, TFormatVersion> {}
 
 /**
  * Normalize the codec to a single format.
@@ -263,7 +225,7 @@ function normalizeCodecVersion<
 	TDecoded,
 	TContext,
 	TFormatVersion extends FormatVersion,
-	TBuildOptions extends CodecWriteOptions,
+	TBuildOptions extends ICodecOptions,
 >(
 	codecVersion: CodecVersion<TDecoded, TContext, TFormatVersion, TBuildOptions>,
 ): NormalizedCodecVersion<TDecoded, TContext, TFormatVersion, TBuildOptions> {
@@ -271,9 +233,7 @@ function normalizeCodecVersion<
 		typeof codecVersion.codec === "function"
 			? codecVersion.codec
 			: () => codecVersion.codec as CodecAndSchema<TDecoded, TContext>;
-	const codec = (
-		options: TBuildOptions,
-	): IJsonCodec<TDecoded, VersionedJson, JsonCompatibleReadOnly, TContext> => {
+	const codec = (options: TBuildOptions): CodecAndSchema<TDecoded, TContext> => {
 		const built = codecBuilder(options);
 		return makeVersionedValidatedCodec(
 			options,
@@ -297,11 +257,11 @@ function normalizeCodecVersion<
  * This is a two stage builder so the first stage can encapsulate all codec specific details and the second can bring in configuration.
  */
 export class ClientVersionDispatchingCodecBuilder<
-	Name extends CodecName,
-	TDecoded,
-	TContext,
-	TFormatVersion extends FormatVersion,
-	TBuildOptions extends CodecWriteOptions,
+	TBuildOptions extends ICodecOptions = ICodecOptions,
+	TDecoded = unknown,
+	TContext = unknown,
+	TFormatVersion extends FormatVersion = FormatVersion,
+	TName extends CodecName = string,
 > {
 	public readonly registry: readonly NormalizedCodecVersion<
 		TDecoded,
@@ -322,7 +282,7 @@ export class ClientVersionDispatchingCodecBuilder<
 		/**
 		 * See {@link CodecName}.
 		 */
-		public readonly name: Name,
+		public readonly name: TName,
 		/**
 		 * The registry of codecs which this builder can use to encode and decode data.
 		 */
@@ -391,7 +351,7 @@ export class ClientVersionDispatchingCodecBuilder<
 	/**
 	 * Produce a single codec which can read any supported format, and writes a version selected based on the provided options.
 	 */
-	public build(options: TBuildOptions): IJsonCodec<
+	public build(options: TBuildOptions & CodecWriteOptions): IJsonCodec<
 		TDecoded,
 		JsonCompatibleReadOnly,
 		JsonCompatibleReadOnly,
@@ -404,32 +364,62 @@ export class ClientVersionDispatchingCodecBuilder<
 		 */
 		readonly writeVersion: TFormatVersion;
 	} {
-		const applied = this.applyOptions(options);
+		const [applied, decoder] = this.buildDecoderInternal(options);
 		const writeVersion = getWriteVersion(this.name, options, applied);
-		const fromFormatVersion = new Map<
-			FormatVersion,
-			EvaluatedCodecVersion<TDecoded, TContext, TFormatVersion>
-		>(applied.map((codec) => [codec.formatVersion, codec]));
 		return {
+			...decoder,
 			encode: (data: TDecoded, context: TContext): JsonCompatibleReadOnly => {
 				return writeVersion.codec.encode(data, context);
 			},
-			decode: (data: JsonCompatibleReadOnly, context: TContext): TDecoded => {
-				const versioned = data as Partial<Versioned>;
-				const codec = fromFormatVersion.get(versioned.version);
-				if (codec === undefined) {
-					throw new UsageError(
-						`Unsupported version ${versioned.version} encountered while decoding ${this.name} data. Supported versions for this data are: ${versionList(applied)}.
-The client which encoded this data likely specified an "minVersionForCollab" value which corresponds to a version newer than the version of this client ("${pkgVersion}").`,
-					);
-				}
-				return codec.codec.decode(data, context);
-			},
 			writeVersion: writeVersion.formatVersion,
 		};
 	}
 
-	public getCodecTree(clientVersion: MinimumVersionForCollab): CodecTree {
+	private buildDecoderInternal(
+		options: TBuildOptions,
+	): [
+		EvaluatedCodecVersion<TDecoded, TContext, TFormatVersion>[],
+		Pick<
+			IJsonCodec<TDecoded, JsonCompatibleReadOnly, JsonCompatibleReadOnly, TContext>,
+			"decode"
+		>,
+	] {
+		const applied = this.applyOptions(options);
+		const fromFormatVersion = new Map<
+			FormatVersion,
+			EvaluatedCodecVersion<TDecoded, TContext, TFormatVersion>
+		>(applied.map((codec) => [codec.formatVersion, codec]));
+		return [
+			applied,
+			{
+				decode: (data: JsonCompatibleReadOnly, context: TContext): TDecoded => {
+					const versioned = data as Partial<Versioned>;
+					const codec = fromFormatVersion.get(versioned.version);
+					if (codec === undefined) {
+						throw new UsageError(
+							`Unsupported version ${versioned.version} encountered while decoding ${this.name} data. Supported versions for this data are: ${versionList(applied)}.
+The client which encoded this data likely specified an "minVersionForCollab" value which corresponds to a version newer than the version of this client ("${pkgVersion}").`,
+						);
+					}
+					return codec.codec.decode(data, context);
+				},
+			},
+		];
+	}
+
+	/**
+	 * Produce a single codec which can read any supported format.
+	 */
+	public buildDecoder(
+		options: TBuildOptions,
+	): Pick<
+		IJsonCodec<TDecoded, JsonCompatibleReadOnly, JsonCompatibleReadOnly, TContext>,
+		"decode"
+	> {
+		return this.buildDecoderInternal(options)[1];
+	}
+
+	public getCodecTree(clientVersion: MinimumVersionForCollab): CodecTree<TFormatVersion> {
 		// TODO: add support for children codecs.
 		const selected = getWriteVersionNoOverrides(this.registry, clientVersion);
 		return {
@@ -470,11 +460,11 @@ The client which encoded this data likely specified an "minVersionForCollab" val
 		const input = inputRegistry as readonly unknown[] as readonly CodecFinal[];
 
 		const builder = new ClientVersionDispatchingCodecBuilder<
-			Name,
+			TBuildOptions2,
 			TDecoded2,
 			unknown extends TContext2 ? void : TContext2,
 			TFormatVersion2,
-			TBuildOptions2
+			Name
 		>(name, input);
 		return builder;
 	}

package/src/codec/versioned/index.ts

@@ -5,9 +5,7 @@
 
 export { Versioned, versionField } from "./format.js";
 export {
-	makeVersionedValidatedCodec,
-	makeVersionDispatchingCodec,
-	makeDiscontinuedCodecVersion,
+	makeDiscontinuedCodecAndSchema,
 	ClientVersionDispatchingCodecBuilder,
 	type CodecVersion,
 	type CodecAndSchema,

package/src/core/forest/forest.ts

@@ -6,6 +6,7 @@
 import type { Listenable } from "@fluidframework/core-interfaces/internal";
 import { assert } from "@fluidframework/core-utils/internal";
 
+import type { Breakable } from "../../util/index.js";
 import type { FieldKey, TreeStoredSchemaSubscription } from "../schema-stored/index.js";
 import {
 	type Anchor,
@@ -77,11 +78,13 @@ export interface IForestSubscription {
 	readonly anchors: AnchorSet;
 
 	/**
-	 * Create an independent copy of this forest, that uses the provided schema and anchors.
+	 * Create an independent copy of this forest, that uses the provided schema.
 	 *
 	 * The new copy will not invalidate observers (dependents) of the old one.
+	 * @param breaker - If provided, the cloned forest will use this breaker instead of inheriting the original's.
+	 * This is useful when creating a fork that should have fault isolation from the original.
 	 */
-	clone(schema: TreeStoredSchemaSubscription, anchors: AnchorSet): IEditableForest;
+	clone(schema: TreeStoredSchemaSubscription, breaker?: Breakable): IEditableForest;
 
 	/**
 	 * Generate a TreeChunk[] for the current field (and its children) of cursor.

package/src/core/index.ts

@@ -106,6 +106,10 @@ export {
 	type ChunkedCursor,
 	DetachedFieldIndexFormatVersion,
 	detachedFieldIndexCodecBuilder,
+	areDetachedNodeIdsEqual,
+	deltaFieldMapHasVisibleChanges,
+	deltaFieldChangesHaveVisibleChanges,
+	forEachNodeSubsequence,
 } from "./tree/index.js";
 
 export {

package/src/core/rebase/changeRebaser.ts

@@ -82,11 +82,19 @@ export interface ChangeRebaser<TChangeset> {
 	 * `compose([rebase(a, c), rebase(b, compose([inverse(a), c, rebase(a, c)])])`.
 	 * - `rebase(a, compose([]))` is equal to `a`.
 	 * - `rebase(compose([]), a)` is equal to `compose([])`.
+	 *
+	 * @param ignoreNoChangeViolation - When true, no-change constraint violations are suppressed during rebase.
+	 * This is a kludge to support undo/redo flows where an undo is rebased over newer commits that have no net
+	 * effect on the document state (e.g. an edit plus its undo). We want the rebaser to treat no-change constraints
+	 * as violated only if the sequence of changes rebased over leave the document in some meaningfully different state.
+	 * Because implementing that rebasing logic in full is more complex, this flag is a hack to manually get
+	 * that behavior in a special case.
 	 */
 	rebase(
 		change: TaggedChange<TChangeset>,
 		over: TaggedChange<TChangeset>,
 		revisionMetadata: RevisionMetadataSource,
+		ignoreNoChangeViolation?: boolean,
 	): TChangeset;
 
 	/**

package/src/core/rebase/revisionTagCodec.ts

@@ -6,16 +6,16 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
 
-import type { IJsonCodec } from "../../codec/index.js";
+import type { JsonCodecPart } from "../../codec/index.js";
 import type { ChangeEncodingContext } from "../change-family/index.js";
 
-import type { EncodedRevisionTag, RevisionTag } from "./types.js";
+import { RevisionTagSchema, type EncodedRevisionTag, type RevisionTag } from "./types.js";
 
 export class RevisionTagCodec
-	implements
-		IJsonCodec<RevisionTag, EncodedRevisionTag, EncodedRevisionTag, ChangeEncodingContext>
+	implements JsonCodecPart<RevisionTag, typeof RevisionTagSchema, ChangeEncodingContext>
 {
 	public localSessionId: SessionId;
+	public readonly encodedSchema = RevisionTagSchema;
 
 	public constructor(private readonly idCompressor: IIdCompressor) {
 		this.localSessionId = idCompressor.localSessionId;

package/src/core/rebase/utils.ts

@@ -347,6 +347,7 @@ export function rebaseChange<TChange>(
 	sourceHead: GraphCommit<TChange>,
 	targetHead: GraphCommit<TChange>,
 	mintRevisionTag: () => RevisionTag,
+	ignoreNoChangeViolation?: boolean,
 ): RebaseChangeResult<TChange> {
 	const sourcePath: GraphCommit<TChange>[] = [];
 	const targetPath: GraphCommit<TChange>[] = [];
@@ -367,7 +368,12 @@ export function rebaseChange<TChange>(
 	};
 
 	return {
-		change: rebaseChangeOverChanges(changeRebaser, change, [...inverses, ...targetPath]),
+		change: rebaseChangeOverChanges(
+			changeRebaser,
+			change,
+			[...inverses, ...targetPath],
+			ignoreNoChangeViolation,
+		),
 		telemetryProperties,
 	};
 }
@@ -398,6 +404,7 @@ export function rebaseChangeOverChanges<TChange>(
 	changeRebaser: ChangeRebaser<TChange>,
 	changeToRebase: TaggedChange<TChange>,
 	changesToRebaseOver: TaggedChange<TChange>[],
+	ignoreNoChangeViolation?: boolean,
 ): TChange {
 	const revisionMetadata = revisionMetadataSourceFromInfo(
 		getRevInfoFromTaggedChanges([...changesToRebaseOver, changeToRebase]),
@@ -407,7 +414,7 @@ export function rebaseChangeOverChanges<TChange>(
 	for (const b of changesToRebaseOver) {
 		result = mapTaggedChange(
 			changeToRebase,
-			changeRebaser.rebase(result, b, revisionMetadata),
+			changeRebaser.rebase(result, b, revisionMetadata, ignoreNoChangeViolation),
 		);
 	}
 	return result.change;

package/src/core/schema-stored/formatV2.ts

@@ -73,7 +73,7 @@ export const TreeNodeSchemaDataFormat = Type.Object(
 
 		// Data in common for all TreeNode schemas:
 		/**
-		 * Leaf node union member.
+		 * Persisted subset of metadata for this node schema.
 		 */
 		metadata: PersistedMetadataFormat,
 	},

package/src/core/tree/anchorSet.ts

@@ -128,7 +128,17 @@ export interface AnchorEvents {
 	 *
 	 * Compare to {@link AnchorEvents.childrenChanged} which is emitted in the middle of the batch/delta-visit.
 	 */
-	childrenChangedAfterBatch(arg: { changedFields: ReadonlySet<FieldKey> }): void;
+	childrenChangedAfterBatch(arg: {
+		changedFields: ReadonlySet<FieldKey>;
+		/**
+		 * The sequential delta marks for each changed field, keyed by field key.
+		 * @remarks
+		 * A field is absent from this map when no mark data was captured for it
+		 * (e.g. for unhydrated nodes, or when marks were invalidated by multiple
+		 * sequential batches touching the same field before the buffer was flushed).
+		 */
+		fieldMarks: ReadonlyMap<FieldKey, readonly Delta.Mark[]>;
+	}): void;
 
 	/**
 	 * Emitted in the middle of applying a batch of changes (i.e. during a delta a visit), if something in the subtree
@@ -726,6 +736,12 @@ export class AnchorSet implements AnchorLocator {
 			 */
 			bufferedEvents: [] as BufferedEvent[],
 
+			/**
+			 * Field marks delivered via {@link DeltaVisitor.fieldMarks}, keyed by (PathNode, FieldKey).
+			 * @remarks Populated during the first (detach) pass and consumed during "free" when emitting events.
+			 */
+			storedFieldMarks: new Map<PathNode, Map<FieldKey, readonly Delta.Mark[]>>(),
+
 			/**
 			 * 'currentDepth' and 'depthThresholdForSubtreeChanged' serve to keep track of when do we need to emit
 			 * subtreeChangedAfterBatch events.
@@ -764,15 +780,31 @@ export class AnchorSet implements AnchorLocator {
 				}
 				this.anchorSet.activeVisitor = undefined;
 
-				// Aggregate changedFields by node.
+				// Aggregate changedFields and fieldMarks by node.
 				const eventsByNode: Map<PathNode, Set<FieldKey>> = new Map();
-				for (const { node, event, changedField } of this.bufferedEvents) {
+				const marksByNode: Map<PathNode, Map<FieldKey, readonly Delta.Mark[]>> = new Map();
+				for (const { node, event, changedField, fieldMarks } of this.bufferedEvents) {
 					if (event === "childrenChangedAfterBatch") {
-						const keys = getOrCreate(eventsByNode, node, () => new Set());
-						keys.add(
+						const resolvedField: FieldKey =
 							changedField ??
-								fail(0xb57 /* childrenChangedAfterBatch events should have a changedField */),
-						);
+							fail(0xb57 /* childrenChangedAfterBatch events should have a changedField */);
+						const keys = getOrCreate(eventsByNode, node, () => new Set());
+						keys.add(resolvedField);
+						if (fieldMarks !== undefined) {
+							const nodeMarks = getOrCreate(marksByNode, node, () => new Map());
+							// First-wins is safe here because `fieldMarks` is called at most once per
+							// field per delta visit (the hook fires during the detach pass only).
+							// Within a single delta a field therefore produces at most one marks entry,
+							// so there is never a legitimate second entry to prefer over the first.
+							// If the same field is touched by two separate deltas before the buffer is
+							// flushed (e.g. because a schema change forced a second delta in the same
+							// batch), `KernelEventBuffer` detects the collision and removes the entry
+							// for that field entirely, so the consumer receives `undefined` rather than
+							// stale marks.
+							if (!nodeMarks.has(resolvedField)) {
+								nodeMarks.set(resolvedField, fieldMarks);
+							}
+						}
 					}
 				}
 
@@ -787,7 +819,9 @@ export class AnchorSet implements AnchorLocator {
 						const changedFields =
 							eventsByNode.get(node) ??
 							fail(0xaeb /* childrenChangedAfterBatch events should have changedFields */);
-						node.events.emit(event, { changedFields });
+						const fieldMarks: ReadonlyMap<FieldKey, readonly Delta.Mark[]> =
+							marksByNode.get(node) ?? new Map();
+						node.events.emit(event, { changedFields, fieldMarks });
 					} else {
 						node.events.emit(event);
 					}
@@ -800,17 +834,20 @@ export class AnchorSet implements AnchorLocator {
 				);
 			},
 			notifyChildrenChanged(): void {
+				const parentField = this.parentField;
 				this.maybeWithNode(
 					(p) => {
 						assert(
-							this.parentField !== undefined,
+							parentField !== undefined,
 							0xa24 /* Must be in a field to modify its contents */,
 						);
 						p.events.emit("childrenChanged", p);
+						const fieldMarks = this.storedFieldMarks.get(p)?.get(parentField);
 						this.bufferedEvents.push({
 							node: p,
 							event: "childrenChangedAfterBatch",
-							changedField: this.parentField,
+							changedField: parentField,
+							fieldMarks,
 						});
 					},
 					() => {},
@@ -934,6 +971,21 @@ export class AnchorSet implements AnchorLocator {
 			exitField(key: FieldKey): void {
 				this.parentField = undefined;
 			},
+			fieldMarks(marks: readonly Delta.Mark[]): void {
+				assert(
+					this.parentField !== undefined,
+					0xce4 /* fieldMarks called outside of a field */,
+				);
+				if (this.parent !== undefined) {
+					const interned = this.anchorSet.internalizePath(this.parent);
+					if (interned instanceof PathNode) {
+						getOrCreate(this.storedFieldMarks, interned, () => new Map()).set(
+							this.parentField,
+							marks,
+						);
+					}
+				}
+			},
 		};
 		this.#events.emit("treeChanging", this);
 		this.activeVisitor = visitor;
@@ -1241,4 +1293,9 @@ interface BufferedEvent {
 	 * Some events, such as afterDestroy, do not involve a key, and thus leave this undefined.
 	 */
 	changedField?: FieldKey;
+	/**
+	 * The sequential delta marks for the impacted field, if available.
+	 * Populated from {@link DeltaVisitor.fieldMarks} during the first (detach) pass.
+	 */
+	fieldMarks?: readonly Delta.Mark[];
 }