@fluidframework/tree 2.103.0 → 2.111.0

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

@@ -4,7 +4,12 @@
  */
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
+import type {
+	IIdCompressor,
+	OpSpaceCompressedId,
+	SessionId,
+	SessionSpaceCompressedId,
+} from "@fluidframework/id-compressor";
 import { lowestMinVersionForCollab } from "@fluidframework/runtime-utils/internal";
 import type { TSchema } from "@sinclair/typebox";
 
@@ -22,10 +27,15 @@ import {
 	type StoredSchemaCollection,
 	type TreeChunk,
 } from "../../../core/index.js";
-import { brandedNumberType, type Brand } from "../../../util/index.js";
+import {
+	brandedNumberType,
+	forceDecodeEncodedIdWithoutSession,
+	type Brand,
+	type IdentifierHealingConfig,
+} from "../../../util/index.js";
 import { TreeCompressionStrategy } from "../../treeCompressionUtils.js";
 
-import { decode } from "./chunkDecoding.js";
+import { decode, type IdDecodingContext } from "./chunkDecoding.js";
 import type { FieldBatch } from "./fieldBatch.js";
 import {
 	EncodedFieldBatchV1,
@@ -97,44 +107,139 @@ export interface IncrementalDecoder {
  */
 export interface IncrementalEncoderDecoder extends IncrementalEncoder, IncrementalDecoder {}
 
+/**
+ * Encode-side context for {@link FieldBatchCodec}.
+ *
+ * Carries only the data the encoder actually consumes. Originator-session
+ * lookup, heal flags, and the incremental *decoder* live on
+ * {@link FieldBatchDecodingContext}.
+ */
 export interface FieldBatchEncodingContext {
 	readonly encodeType: TreeCompressionStrategy;
 	readonly idCompressor: IIdCompressor;
-	readonly originatorId: SessionId;
 	readonly schema?: SchemaAndPolicy;
 	/**
-	 * An encoder / decoder for encoding and decoding of incremental fields.
-	 * This will be defined if incremental encoding is supported and enabled.
+	 * Encoder for incremental fields. Defined when incremental encoding is
+	 * supported and enabled.
 	 */
-	readonly incrementalEncoderDecoder?: IncrementalEncoderDecoder;
+	readonly incrementalEncoder?: IncrementalEncoder;
 	/**
-	 * `true` when encoding to or decoding from a summary blob. `false` for
-	 * op-stream encode/decode paths and for utility encoders that are not
-	 * tied to a persisted document. Healing behavior is gated on this flag.
+	 * `true` when encoding to a summary blob. `false` for op-stream encode
+	 * paths and for utility encoders that aren't tied to a persisted document.
+	 *
+	 * @remarks
+	 * Used by the node encoder to decide whether non-finalized op-space ids
+	 * can be written into the batch (they can't, for summaries).
 	 */
 	readonly isSummary: boolean;
+}
+
+/**
+ * Decode-side context for {@link FieldBatchCodec}.
+ *
+ * Carries the per-call `resolveEncodedId` function that encapsulates the
+ * originator-session lookup and (for the forest-summarizer's legacy heal path)
+ * the deterministic UUIDv5 synthesis. Heal and originator-session flags live
+ * inside that function, not on this context.
+ *
+ * Constructed via one of the two named static factories — {@link forOp} or
+ * {@link forSummary} — depending on the call site's semantics. The constructor
+ * is private; there is no general-purpose builder, because the choice between
+ * 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 {
+	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,
+
+		/**
+		 * 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,
+	) {}
+
 	/**
-	 * If `true`, when an op-space compressed ID encountered while decoding
-	 * cannot be resolved by the local id-compressor (e.g. the attach-summary
-	 * blob's originator session state was stripped), a deterministic stable
-	 * UUID derived from `sharedObjectId` is returned instead of throwing.
-	 * @remarks
-	 * Off by default. Used only to recover documents whose attach summary was
-	 * written with non-finalized op-space IDs before the encode-side fix
-	 * shipped. Only takes effect when `isSummary` is also `true`.
-	 * See {@link SharedTreeOptionsBeta.healUnresolvableIdentifiersOnDecode}.
+	 * Construct a decode context for an op.
+	 *
+	 * The originator is the session that produced the encoded form (carried
+	 * alongside the op envelope by the caller). Heal-on-decode is *not*
+	 * available — an unresolvable id during op decode indicates a real bug,
+	 * not a recoverable state, so the resolver throws rather than synthesizing
+	 * a UUID. Incremental decoding is not used for ops.
 	 */
-	readonly healUnresolvableIdentifiersOnDecode?: boolean;
+	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),
+		);
+	}
+
 	/**
-	 * The SharedTree's shared-object id, used as input to the deterministic
-	 * UUID derivation when `healUnresolvableIdentifiersOnDecode` triggers. Required
-	 * for that path; ignored otherwise.
-	 * @remarks
-	 * This allows us to ensure that multiple attaches,
-	 * in the same or different documents, with the same session offsets, get different UUIDs.
+	 * Construct a decode context for a summary blob.
+	 *
+	 * Summaries must contain only ids resolvable without an originator — either
+	 * finalized op-space ids, or (when {@link IdentifierHealingConfig} is supplied
+	 * via `healing`) non-final ids that get healed into deterministic UUIDv5
+	 * strings. Incremental decoding is attached via {@link withIncrementalDecoder}.
+	 *
+	 * @privateRemarks
+	 * In the future (if adding a summary format which includes the session id),
+	 * this could allow providing an originator ID to allow for op-space compressed identifiers in attach summaries.
+	 * Non-attach summaries should only have finalized compressed identifiers (due to only being made by summary clients which never allocate identifiers since they never edit).
+	 * Since only non-attach summaries can be incremental, incremental summaries should never have non finalized identifiers.
+	 * `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}.
 	 */
-	readonly sharedObjectId?: string;
+	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),
+		);
+	}
+
+	/**
+	 * Returns a copy of this context with `incrementalDecoder` swapped in. Used by
+	 * the forest summarizer to attach the per-call incremental builder to a base
+	 * decode context.
+	 */
+	public withIncrementalDecoder(
+		incrementalDecoder: IncrementalDecoder,
+	): FieldBatchDecodingContext {
+		// As different incremental chunks may come from different sessions,
+		// for now we simply enforce that we do not provide an originator session ID
+		// when we might be dealing with incremental chunks.
+		// This mitigates the risk of using incorrect originator session ID identifiers in incremental chunks.
+		// See also private remarks on forSummary.
+		assert(
+			!this.hasOriginatorSessionId,
+			0xd0c /* withIncrementalDecoder can only be called on contexts without an originator session ID */,
+		);
+		return new FieldBatchDecodingContext(
+			false,
+			this.idCompressor,
+			this.resolveEncodedId,
+			incrementalDecoder,
+		);
+	}
 }
+
 /**
  * @remarks
  * Fields in this batch currently don't have field schema for the root, which limits optimizations.
@@ -142,7 +247,8 @@ export interface FieldBatchEncodingContext {
 export type FieldBatchCodec = VersionDispatchingCodec<
 	FieldBatch,
 	FieldBatchEncodingContext,
-	FieldBatchFormatVersion
+	FieldBatchFormatVersion,
+	FieldBatchDecodingContext
 >;
 
 /**
@@ -160,7 +266,7 @@ function makeFieldBatchCodecForVersion(
 		isSummary: boolean,
 	) => EncodedFieldBatchV1OrV2,
 	encodedFieldBatchType: TSchema,
-): CodecAndSchema<FieldBatch, FieldBatchEncodingContext> {
+): CodecAndSchema<FieldBatch, FieldBatchEncodingContext, FieldBatchDecodingContext> {
 	return {
 		encode: (
 			data: FieldBatch,
@@ -185,7 +291,7 @@ function makeFieldBatchCodecForVersion(
 						0xca0 /* Unsupported FieldBatchFormatVersion for incremental encoding; must be v2 or higher */,
 					);
 					// Incremental encoding is only supported for CompressedIncremental.
-					incrementalEncoder = context.incrementalEncoderDecoder;
+					incrementalEncoder = context.incrementalEncoder;
 				}
 				// fallthrough
 				case TreeCompressionStrategy.Compressed: {
@@ -216,20 +322,10 @@ function makeFieldBatchCodecForVersion(
 		},
 		decode: (
 			data: EncodedFieldBatchV1OrV2,
-			context: FieldBatchEncodingContext,
+			context: FieldBatchDecodingContext,
 		): FieldBatch => {
 			// TODO: consider checking data is in schema.
-			return decode(
-				data,
-				{
-					idCompressor: context.idCompressor,
-					originatorId: context.originatorId,
-					isSummary: context.isSummary,
-					healUnresolvableIdentifiersOnDecode: context.healUnresolvableIdentifiersOnDecode,
-					sharedObjectId: context.sharedObjectId,
-				},
-				context.incrementalEncoderDecoder,
-			).map((chunk) => chunk.cursor());
+			return decode(data, context, context.incrementalDecoder).map((chunk) => chunk.cursor());
 		},
 		schema: encodedFieldBatchType,
 	};

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

@@ -18,7 +18,13 @@ import {
 	type Value,
 	forEachNode,
 } from "../../../core/index.js";
-import { getOrCreate } from "../../../util/index.js";
+import {
+	EncodedIdType,
+	encodePossiblyCompressedId,
+	getOrCreate,
+	type EncodedId,
+	type IdEncodingContext,
+} from "../../../util/index.js";
 
 import type { Counter, DeduplicationTable } from "./chunkCodecUtilities.js";
 import {
@@ -520,7 +526,9 @@ export function encodeValue(
  * - Singletons defined in a static scope.
  * - Cached in this object for future reuse such that all equivalent Shapes are deduplicated.
  */
-export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
+export class EncoderContext
+	implements NodeEncodeBuilder, FieldEncodeBuilder, IdEncodingContext
+{
 	private readonly nodeEncodersFromSchema: Map<TreeNodeSchemaIdentifier, NodeEncoder> =
 		new Map();
 	private readonly nestedArrayEncoders: Map<NodeEncoder, NestedArrayEncoder> = new Map();
@@ -528,7 +536,7 @@ export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
 		private readonly nodeEncoderFromPolicy: NodeEncoderPolicy,
 		private readonly fieldEncoderFromPolicy: FieldEncoderPolicy,
 		public readonly fieldShapes: ReadonlyMap<FieldKindIdentifier, FieldKindData>,
-		public readonly idCompressor: IIdCompressor,
+		private readonly idCompressor: IIdCompressor,
 		/**
 		 * To be used to encode incremental chunks, if any.
 		 * @remarks
@@ -540,7 +548,27 @@ export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
 		 * See {@link FieldBatchEncodingContext.isSummary}.
 		 */
 		public readonly isSummary: boolean,
-	) {}
+	) {
+		// Currently we never include originator-dependent identifiers in summaries
+		// (there was a bug which violated this for attach-summaries: it has been fixed, see `IdentifierHealingConfig`).
+		// If that ever changes (to allow better compressed attach summaries), we need to take special care with incremental summaries.
+		// This assert guards against data corruption leaking in via missing session information in incremental summaries,
+		// protecting from bugs of potential future optimizations to attach summaries applied to non-attach summaries.
+		// Incremental summaries should have no need for originator-dependent identifiers,
+		// as they can't be attach summaries which are the only ones which should ever have non-final ids.
+		assert(
+			isSummary || incrementalEncoder === undefined,
+			0xd0d /* incrementalEncoder cannot be used when encoding originator-dependent identifiers */,
+		);
+	}
+
+	public encodePossiblyCompressedId(id: string): string | EncodedId<EncodedIdType> {
+		return encodePossiblyCompressedId(
+			id,
+			this.idCompressor,
+			this.isSummary ? EncodedIdType.Originatorless : EncodedIdType.OriginatorDependent,
+		);
+	}
 
 	public nodeEncoderFromSchema(schemaName: TreeNodeSchemaIdentifier): NodeEncoder {
 		return getOrCreate(this.nodeEncodersFromSchema, schemaName, () =>

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

@@ -13,6 +13,7 @@ export type { FieldBatch } from "./fieldBatch.js";
 export {
 	type FieldBatchCodec,
 	fieldBatchCodecBuilder,
+	FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 	type IncrementalEncoderDecoder,
 	type IncrementalEncoder,

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

@@ -4,7 +4,6 @@
  */
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
-import { isFinalId, isStableId } from "@fluidframework/id-compressor/internal";
 
 import {
 	type FieldKey,
@@ -24,10 +23,11 @@ import {
 	type NodeEncoder,
 	encodeValue,
 } from "./compressedEncode.js";
-import type {
-	EncodedChunkShape,
-	EncodedFieldShape,
-	EncodedValueShape,
+import {
+	SpecialField,
+	type EncodedChunkShape,
+	type EncodedFieldShape,
+	type EncodedValueShape,
 } from "./format/index.js";
 
 /**
@@ -69,21 +69,9 @@ export class NodeShapeBasedEncoder extends Shape<EncodedChunkShape> implements N
 	}
 
 	private getValueToEncode(cursor: ITreeCursorSynchronous, context: EncoderContext): Value {
-		if (this.value === 0) {
+		if (this.value === SpecialField.Identifier) {
 			assert(typeof cursor.value === "string", 0x9aa /* identifier must be type string */);
-			if (isStableId(cursor.value)) {
-				const sessionSpaceCompressedId = context.idCompressor.tryRecompress(cursor.value);
-				if (sessionSpaceCompressedId !== undefined) {
-					const opSpaceId = context.idCompressor.normalizeToOpSpace(sessionSpaceCompressedId);
-					// Summaries can only contain finalized op-space ids unless they also include the originator's session id somewhere.
-					// This is not the case for forest summaries at the time of writing, so non-finalized ids are instead written using
-					// their long form (by falling through to the original cursor value).
-					// A scenario where such ids can appear in the summary is in the attach summary of a tree being attached to an already-attached container.
-					if (!context.isSummary || isFinalId(opSpaceId)) {
-						return opSpaceId;
-					}
-				}
-			}
+			return context.encodePossiblyCompressedId(cursor.value);
 		}
 		return cursor.value;
 	}

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

@@ -20,7 +20,10 @@ export {
 	type FieldBatch,
 	type FieldBatchCodec,
 	fieldBatchCodecBuilder,
+	FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
+	type IncrementalDecoder,
+	type IncrementalEncoder,
 	type IncrementalEncoderDecoder,
 	type ChunkReferenceId,
 	type IncrementalEncodingPolicy,

package/src/feature-libraries/forest-summary/codec.ts

@@ -16,6 +16,7 @@ import {
 import type { FieldKey, ITreeCursorSynchronous } from "../../core/index.js";
 import {
 	fieldBatchCodecBuilder,
+	type FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 } from "../chunked-forest/index.js";
 
@@ -28,13 +29,14 @@ export type FieldSet = ReadonlyMap<FieldKey, ITreeCursorSynchronous>;
 export type ForestCodec = VersionDispatchingCodec<
 	FieldSet,
 	FieldBatchEncodingContext,
-	ForestFormatVersion
+	ForestFormatVersion,
+	FieldBatchDecodingContext
 >;
 
 function makeForestSummarizerCodec(
 	options: CodecWriteOptions,
 	version: ForestFormatVersion,
-): CodecAndSchema<FieldSet, FieldBatchEncodingContext> {
+): CodecAndSchema<FieldSet, FieldBatchEncodingContext, FieldBatchDecodingContext> {
 	// Performance: Since multiple places (including multiple versions of this codec) use the field batch codec,
 	// we may end up with multiple copies of it, including compiling its format validation multiple times.
 	// This is not ideal, but is not too bad as it is a small fixed number of copies and thus should not be too expensive.
@@ -55,7 +57,7 @@ function makeForestSummarizerCodec(
 				version,
 			};
 		},
-		decode: (data: FormatCommon, context: FieldBatchEncodingContext): FieldSet => {
+		decode: (data: FormatCommon, context: FieldBatchDecodingContext): FieldSet => {
 			const out: Map<FieldKey, ITreeCursorSynchronous> = new Map();
 			const fields = fieldBatchCodec.decode(data.fields, context);
 			assert(data.keys.length === fields.length, 0x891 /* mismatched lengths */);

package/src/feature-libraries/forest-summary/forestSummarizer.ts

@@ -41,6 +41,7 @@ import {
 import { chunkFieldSingle, defaultChunkPolicy } from "../chunked-forest/chunkTree.js";
 import {
 	defaultIncrementalEncodingPolicy,
+	type FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 	type IncrementalEncodingPolicy,
 } from "../chunked-forest/index.js";
@@ -80,6 +81,7 @@ export class ForestSummarizer
 		private readonly forest: IEditableForest,
 		private readonly revisionTagCodec: RevisionTagCodec,
 		private readonly encoderContext: FieldBatchEncodingContext,
+		private readonly decoderContext: FieldBatchDecodingContext,
 		options: CodecWriteOptions,
 		private readonly idCompressor: IIdCompressor,
 		initialSequenceNumber: number,
@@ -160,7 +162,7 @@ export class ForestSummarizer
 		});
 		const encoderContext: FieldBatchEncodingContext = {
 			...this.encoderContext,
-			incrementalEncoderDecoder:
+			incrementalEncoder:
 				incrementalSummaryBehavior === ForestIncrementalSummaryBehavior.Incremental
 					? this.incrementalSummaryBuilder
 					: undefined,
@@ -212,10 +214,7 @@ export class ForestSummarizer
 				parse,
 				// TODO: this type cast assumes there are no handles, which should probably be enforced at runtime or the need for this cast should be removed altogether.
 			)) as JsonCompatibleReadOnly,
-			{
-				...this.encoderContext,
-				incrementalEncoderDecoder: this.incrementalSummaryBuilder,
-			},
+			this.decoderContext.withIncrementalDecoder(this.incrementalSummaryBuilder),
 		);
 		const allocator = idAllocatorFromMaxId();
 		const fieldChanges: [FieldKey, DeltaFieldChanges][] = [];

package/src/feature-libraries/index.ts

@@ -109,11 +109,14 @@ export {
 	FieldBatchFormatVersion,
 	makeTreeChunker,
 	fieldBatchCodecBuilder,
+	FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 	emptyChunk,
 	combineChunks,
 	type IncrementalEncodingPolicy,
 	defaultIncrementalEncodingPolicy,
+	type IncrementalDecoder,
+	type IncrementalEncoder,
 } from "./chunked-forest/index.js";
 
 export {

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

@@ -35,6 +35,7 @@ import {
 import { newChangeAtomIdBTree, type ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
 import {
 	type FieldBatchCodec,
+	FieldBatchDecodingContext,
 	type TreeChunk,
 	chunkFieldSingle,
 	defaultChunkPolicy,
@@ -328,7 +329,6 @@ export function encodeDetachedNodes(
 				trees: fieldsCodec.encode(treesToEncode, {
 					encodeType: chunkCompressionStrategy,
 					schema: context.schema,
-					originatorId: context.originatorId,
 					idCompressor: context.idCompressor,
 					isSummary: context.isSummary,
 				}),
@@ -350,14 +350,18 @@ export function decodeDetachedNodes(
 		return undefined;
 	}
 
-	const chunks = fieldsCodec.decode(encoded.trees, {
-		encodeType: chunkCompressionStrategy,
-		originatorId: context.originatorId,
-		idCompressor: context.idCompressor,
-		isSummary: context.isSummary,
-		healUnresolvableIdentifiersOnDecode: context.healUnresolvableIdentifiersOnDecode,
-		sharedObjectId: context.sharedObjectId,
-	});
+	const chunks = fieldsCodec.decode(
+		encoded.trees,
+		context.isSummary
+			? FieldBatchDecodingContext.forSummary({
+					idCompressor: context.idCompressor,
+					healing: context.healing,
+				})
+			: FieldBatchDecodingContext.forOp({
+					idCompressor: context.idCompressor,
+					originatorId: context.originatorId,
+				}),
+	);
 	const getChunk = (index: number): TreeChunk => {
 		assert(index < chunks.length, 0x898 /* out of bounds index for build chunk */);
 		return chunkFieldSingle(chunks[index] ?? oob(), {

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

@@ -782,6 +782,14 @@ export class ModularChangeFamily
 
 		const crossFieldKeys = this.makeCrossFieldKeyTable(invertedFields, invertedNodes);
 
+		const constraintState = newConstraintState(0);
+		this.updateConstraintsForFields(
+			invertedFields,
+			NodeAttachState.Attached,
+			constraintState,
+			invertedNodes,
+		);
+
 		return makeModularChangeset({
 			fieldChanges: invertedFields,
 			nodeChanges: invertedNodes,
@@ -790,8 +798,7 @@ export class ModularChangeFamily
 			crossFieldKeys,
 			maxId: genId.getMaxId(),
 			revisions: revInfos,
-			constraintViolationCount: change.change.constraintViolationCountOnRevert,
-			constraintViolationCountOnRevert: change.change.constraintViolationCount,
+			constraintViolationCount: constraintState.violationCount,
 			noChangeConstraint,
 			noChangeConstraintOnRevert,
 			destroys,
@@ -939,9 +946,6 @@ export class ModularChangeFamily
 		);
 
 		const constraintState = newConstraintState(change.constraintViolationCount ?? 0);
-		const revertConstraintState = newConstraintState(
-			change.constraintViolationCountOnRevert ?? 0,
-		);
 
 		let noChangeConstraint = change.noChangeConstraint;
 		if (
@@ -956,9 +960,7 @@ export class ModularChangeFamily
 		this.updateConstraintsForFields(
 			rebasedFields,
 			NodeAttachState.Attached,
-			NodeAttachState.Attached,
 			constraintState,
-			revertConstraintState,
 			rebasedNodes,
 		);
 
@@ -971,7 +973,6 @@ export class ModularChangeFamily
 			maxId: idState.maxId,
 			revisions: change.revisions,
 			constraintViolationCount: constraintState.violationCount,
-			constraintViolationCountOnRevert: revertConstraintState.violationCount,
 			noChangeConstraint,
 			noChangeConstraintOnRevert: change.noChangeConstraintOnRevert,
 			builds: change.builds,
@@ -1410,32 +1411,21 @@ export class ModularChangeFamily
 	private updateConstraintsForFields(
 		fields: FieldChangeMap,
 		parentInputAttachState: NodeAttachState,
-		parentOutputAttachState: NodeAttachState,
 		constraintState: ConstraintState,
-		revertConstraintState: ConstraintState,
 		nodes: ChangeAtomIdBTree<NodeChangeset>,
 	): void {
 		for (const field of fields.values()) {
 			const handler = getChangeHandler(this.fieldKinds, field.fieldKind);
-			for (const [nodeId, inputIndex, outputIndex] of handler.getNestedChanges(field.change)) {
+			for (const [nodeId, inputIndex, _outputIndex] of handler.getNestedChanges(
+				field.change,
+			)) {
 				const isInputDetached = inputIndex === undefined;
 				const inputAttachState =
 					parentInputAttachState === NodeAttachState.Detached || isInputDetached
 						? NodeAttachState.Detached
 						: NodeAttachState.Attached;
-				const isOutputDetached = outputIndex === undefined;
-				const outputAttachState =
-					parentOutputAttachState === NodeAttachState.Detached || isOutputDetached
-						? NodeAttachState.Detached
-						: NodeAttachState.Attached;
-				this.updateConstraintsForNode(
-					nodeId,
-					inputAttachState,
-					outputAttachState,
-					nodes,
-					constraintState,
-					revertConstraintState,
-				);
+
+				this.updateConstraintsForNode(nodeId, inputAttachState, nodes, constraintState);
 			}
 		}
 	}
@@ -1443,10 +1433,8 @@ export class ModularChangeFamily
 	private updateConstraintsForNode(
 		nodeId: NodeId,
 		inputAttachState: NodeAttachState,
-		outputAttachState: NodeAttachState,
 		nodes: ChangeAtomIdBTree<NodeChangeset>,
 		constraintState: ConstraintState,
-		revertConstraintState: ConstraintState,
 	): void {
 		const node =
 			nodes.get([nodeId.revision, nodeId.localId]) ?? fail(0xb24 /* Unknown node ID */);
@@ -1460,24 +1448,12 @@ export class ModularChangeFamily
 				constraintState.violationCount += isNowViolated ? 1 : -1;
 			}
 		}
-		if (node.nodeExistsConstraintOnRevert !== undefined) {
-			const isNowViolated = outputAttachState === NodeAttachState.Detached;
-			if (node.nodeExistsConstraintOnRevert.violated !== isNowViolated) {
-				node.nodeExistsConstraintOnRevert = {
-					...node.nodeExistsConstraintOnRevert,
-					violated: isNowViolated,
-				};
-				revertConstraintState.violationCount += isNowViolated ? 1 : -1;
-			}
-		}
 
 		if (node.fieldChanges !== undefined) {
 			this.updateConstraintsForFields(
 				node.fieldChanges,
 				inputAttachState,
-				outputAttachState,
 				constraintState,
-				revertConstraintState,
 				nodes,
 			);
 		}
@@ -2003,7 +1979,6 @@ export function updateRefreshers(
 		maxId,
 		revisions,
 		constraintViolationCount,
-		constraintViolationCountOnRevert,
 		builds,
 		destroys,
 	} = change;
@@ -2017,7 +1992,6 @@ export function updateRefreshers(
 		maxId: maxId as number,
 		revisions,
 		constraintViolationCount,
-		constraintViolationCountOnRevert,
 		builds,
 		destroys,
 		refreshers,
@@ -2632,7 +2606,6 @@ function makeModularChangeset(props?: {
 	maxId: number;
 	revisions?: readonly RevisionInfo[];
 	constraintViolationCount?: number;
-	constraintViolationCountOnRevert?: number;
 	noChangeConstraint?: NoChangeConstraint;
 	noChangeConstraintOnRevert?: NoChangeConstraint;
 	builds?: ChangeAtomIdBTree<TreeChunk>;
@@ -2657,12 +2630,6 @@ function makeModularChangeset(props?: {
 	if (p.constraintViolationCount !== undefined && p.constraintViolationCount > 0) {
 		changeset.constraintViolationCount = p.constraintViolationCount;
 	}
-	if (
-		p.constraintViolationCountOnRevert !== undefined &&
-		p.constraintViolationCountOnRevert > 0
-	) {
-		changeset.constraintViolationCountOnRevert = p.constraintViolationCountOnRevert;
-	}
 	if (p.noChangeConstraint !== undefined) {
 		changeset.noChangeConstraint = p.noChangeConstraint;
 	}