@fluidframework/tree 2.90.0 → 2.92.0

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[];
 }