@fluidframework/tree 2.102.0 → 2.110.0

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

@@ -113,7 +113,15 @@ export class TreeShape {
 	public readonly fieldsOffsetArray: readonly OffsetShape[];
 	public readonly valuesPerTopLevelNode: number;
 
-	// TODO: this is only needed at chunk roots. Optimize it base on that.
+	/**
+	 * Information about every node in this shape.
+	 * The root is first, and all indexes it uses to refer to other nodes are indexes into this array.
+	 * Beyond that the ordering is an implementation detail of this shape.
+	 * @remarks
+	 * Use of this in contexts where there might be multiple top-level nodes requires some additional care.
+	 * For example {@link Cursor} derives each node's actual position info from this shared
+	 * array plus the node's top-level index within the chunk.
+	 */
 	public readonly positions: readonly NodePositionInfo[];
 
 	/**
@@ -246,25 +254,19 @@ function clonePositions(
 /**
  * The shape (see `TreeShape`) of a sequence of trees, all with the same shape (like `FieldShape`, but without a field key).
  *
- * This shape is optimized (by caching derived data like the positions array),
- * so that when paired with a value array it can be efficiently traversed like a tree by an {@link ITreeCursorSynchronous}.
- * See {@link uniformChunk} for how to do this.
+ * @remarks
+ * Paired with a value array, this lets a {@link UniformChunk} be traversed like a tree by an
+ * {@link ITreeCursorSynchronous}. The {@link Cursor} derives each node's position info from the
+ * shared {@link TreeShape.positions} plus the node's top-level index.
  *
  * TODO: consider storing shape information in WASM
  */
 export class ChunkShape {
-	public readonly positions: readonly (NodePositionInfo | undefined)[];
-
 	public constructor(
 		public readonly treeShape: TreeShape,
 		public readonly topLevelLength: number,
 	) {
 		assert(topLevelLength > 0, 0x4c6 /* topLevelLength must be greater than 0 */);
-
-		// TODO: avoid duplication from inner loop
-		const positions: (NodePositionInfo | undefined)[] = [undefined];
-		clonePositions(0, [dummyRoot, treeShape, topLevelLength], 0, 0, positions);
-		this.positions = positions;
 	}
 
 	public equals(other: ChunkShape): boolean {
@@ -295,17 +297,19 @@ class OffsetShape {
 }
 
 /**
- * Information about a node at a specific position within a uniform chunk.
+ * Information about a node at a specific position within one top-level tree of a {@link TreeShape}.
  */
 class NodePositionInfo implements UpPath {
 	/**
-	 * @param parent - TODO
-	 * @param parentField - TODO
+	 * @param parent - The parent node's {@link NodePositionInfo} or `undefined` for a root.
+	 * @param parentField - The {@link FieldKey} of the field this node occupies within its parent.
 	 * @param parentIndex - indexWithinParentField
-	 * @param indexOfParentField - which field of the parent `parentIndex` is indexing into to locate this.
-	 * @param indexOfParentPosition - Index of parent NodePositionInfo in positions array. TODO: use offsets to avoid copying at top level?
+	 * @param indexOfParentField - Which field of the parent `parentIndex` is indexing into to locate this.
+	 * @param indexOfParentPosition - Index of this node's parent in {@link TreeShape.positions}
 	 * @param shape - Shape of the top level sequence this node is part of
-	 * @param valueOffset - TODO
+	 * @param topLevelLength - Number of siblings in this node's field. For a root this is unused
+	 * @param valueOffset - Offset of this node's value within one top-level tree's slice of the chunk's flat `values` array;
+	 * only valid when `shape.hasValue` (otherwise it's where the value would have gone, and should not be used to read a value).
 	 */
 	public constructor(
 		public readonly parent: NodePositionInfo | undefined, // TODO; general UpPath to allow prefixing here?
@@ -322,16 +326,28 @@ class NodePositionInfo implements UpPath {
 /**
  * The cursor implementation for `UniformChunk`.
  *
- * Works by tracking its location in the chunk's `positions` array.
+ * @remarks
+ * Tracks a flat `positionIndex` and derives each node's position info from the shape's shared
+ * {@link TreeShape.positions} plus the node's top-level index.
  */
 class Cursor extends SynchronousCursor implements ChunkedCursor {
 	private positionIndex!: number; // When in fields mode, this points to the parent node.
-	// Undefined when in root field
+
+	/** Position info for the current node, or `undefined` when in root field. */
 	private nodePositionInfo: NodePositionInfo | undefined;
 
-	// Cached constants for faster access
+	/** Which top-level node of the chunk the current position is within. Valid when nodePositionInfo !== undefined. */
+	private topLevelIndex: number = 0;
+
+	// Cached constants for faster access.
+	/** The chunk's shape. */
 	private readonly shape: ChunkShape;
-	private readonly positions: readonly (NodePositionInfo | undefined)[];
+	/** The chunk's per-tree shape (shape of each top-level tree). */
+	private readonly treeShape: TreeShape;
+	/** Number of positions in one top-level tree (treeShape.positions.length). */
+	private readonly nodeLength: number;
+	/** Number of values per top-level node (treeShape.valuesPerTopLevelNode). */
+	private readonly stride: number;
 
 	public mode: CursorLocationType = CursorLocationType.Fields;
 
@@ -346,7 +362,9 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 	public constructor(private readonly chunk: UniformChunk) {
 		super();
 		this.shape = this.chunk.shape;
-		this.positions = this.shape.positions;
+		this.treeShape = this.shape.treeShape;
+		this.nodeLength = this.treeShape.positions.length;
+		this.stride = this.treeShape.valuesPerTopLevelNode;
 		this.fieldKey = dummyRoot;
 		this.moveToPosition(0);
 	}
@@ -377,18 +395,70 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 
 	/**
 	 * Change the current node within the chunk.
+	 *
+	 * @param positionIndex - flat position index of the newly selected node. This is NOT an index
+	 * within a field, and is not bounds checked.
+	 *
+	 * @remarks
+	 * Decomposes the index into {@link Cursor.topLevelIndex} and {@link Cursor.nodePositionInfo}.
 	 * See `nodeInfo` for getting data about the current node.
 	 *
-	 * @param positionIndex - index of the position of the newly selected node in `positions`.
-	 * This is NOT an index within a field, and is not bounds checked.
 	 */
 	private moveToPosition(positionIndex: number): void {
-		this.nodePositionInfo = this.positions[positionIndex];
 		this.positionIndex = positionIndex;
-		if (this.nodePositionInfo === undefined) {
-			assert(positionIndex === 0, 0x561 /* expected root at start */);
+		if (positionIndex === 0) {
+			this.nodePositionInfo = undefined;
 			assert(this.mode === CursorLocationType.Fields, 0x562 /* expected root to be a field */);
+			return;
 		}
+		const decoded = this.decodePosition(positionIndex);
+		this.topLevelIndex = decoded.topLevelIndex;
+		this.nodePositionInfo = decoded.info;
+	}
+
+	/**
+	 * Decode a flat `positionIndex` into its components.
+	 *
+	 * @param positionIndex - flat position index of the node to decode. Must be greater than 0;
+	 * @returns the node's index within {@link TreeShape.positions} (`withinTree`), which top-level
+	 * tree holds it (`topLevelIndex`), and the corresponding shared {@link NodePositionInfo} (`info`).
+	 */
+	private decodePosition(positionIndex: number): {
+		withinTree: number;
+		topLevelIndex: number;
+		info: NodePositionInfo;
+	} {
+		const offset = positionIndex - 1;
+		// Find the node's index within treeShape.positions, then which top-level tree holds it.
+		const withinTree = offset % this.nodeLength; // remainder
+		const topLevelIndex = (offset - withinTree) / this.nodeLength; // quotient
+		const info = this.treeShape.positions[withinTree] ?? oob();
+		return { withinTree, topLevelIndex, info };
+	}
+
+	/**
+	 * Build a standalone {@link UpPath} for the node at `positionIndex`. O(depth) allocation.
+	 *
+	 * @remarks
+	 * walks the shared per-tree {@link TreeShape.positions} and applies the top-level index
+	 * at each level. Mirrors how the `BasicChunk` cursor allocates paths.
+	 */
+	private materializePath(positionIndex: number): UpPath | undefined {
+		if (positionIndex === 0) {
+			return undefined;
+		}
+		const { withinTree, topLevelIndex, info } = this.decodePosition(positionIndex);
+		if (info.parent === undefined) {
+			// Top-level node: its parent is the (prefixed) chunk root.
+			return { parent: undefined, parentField: info.parentField, parentIndex: topLevelIndex };
+		}
+		return {
+			parent: this.materializePath(
+				positionIndex - withinTree + (info.indexOfParentPosition ?? oob()),
+			),
+			parentField: info.parentField,
+			parentIndex: info.parentIndex,
+		};
 	}
 
 	/**
@@ -505,36 +575,51 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 	private enterRootNodeInner(childIndex: number): void {
 		this.mode = CursorLocationType.Nodes;
 		this.fieldKey = undefined;
-		// 1 for the "undefined" at the beginning of the positions array, then stride by top level tree shape.
-		this.moveToPosition(1 + childIndex * this.shape.treeShape.positions.length);
+		// 1 for the "undefined" root-field marker at position 0, then stride by one top-level tree (nodeLength).
+		this.moveToPosition(1 + childIndex * this.nodeLength);
 		assert(this.fieldIndex === childIndex, 0x543 /* should be at selected child */);
 	}
 
 	public getFieldPath(prefix?: PathRootPrefix): FieldUpPath {
 		return prefixFieldPath(prefix, {
 			field: this.getFieldKey(),
-			parent: this.nodePositionInfo,
+			parent: this.materializePath(this.positionIndex),
 		});
 	}
 
 	public getPath(prefix?: PathRootPrefix): UpPath | undefined {
-		return prefixPath(prefix, this.nodeInfo(CursorLocationType.Nodes));
+		this.nodeInfo(CursorLocationType.Nodes); // assert: in nodes mode at a node
+		return prefixPath(prefix, this.materializePath(this.positionIndex));
 	}
 
 	public get fieldIndex(): number {
-		return this.nodeInfo(CursorLocationType.Nodes).parentIndex;
+		const info = this.nodeInfo(CursorLocationType.Nodes);
+		return info.parent === undefined ? this.topLevelIndex : info.parentIndex;
 	}
 
 	public readonly chunkStart: number = 0;
 
+	/**
+	 * Number of nodes in `info`'s field including `info` itself.
+	 *
+	 * @remarks
+	 * For top-level nodes this is the chunk's `topLevelLength`, read from the chunk
+	 * rather than the node, so the shared per-tree {@link TreeShape.positions} stays independent of
+	 * chunk length; the root entry's own `topLevelLength` field is unused. Nested nodes use the
+	 * field length stored on the node.
+	 */
+	private siblingCount(info: NodePositionInfo): number {
+		return info.parent === undefined ? this.shape.topLevelLength : info.topLevelLength;
+	}
+
 	public get chunkLength(): number {
-		return this.nodeInfo(CursorLocationType.Nodes).topLevelLength;
+		return this.siblingCount(this.nodeInfo(CursorLocationType.Nodes));
 	}
 
 	public seekNodes(offset: number): boolean {
 		const info = this.nodeInfo(CursorLocationType.Nodes);
-		const index = offset + info.parentIndex;
-		if (index >= 0 && index < info.topLevelLength) {
+		const index = offset + this.fieldIndex;
+		if (index >= 0 && index < this.siblingCount(info)) {
 			this.moveToPosition(this.positionIndex + offset * info.shape.positions.length);
 			return true;
 		}
@@ -546,8 +631,8 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 		// This is the same as `return this.seekNodes(1);` but slightly faster.
 
 		const info = this.nodeInfo(CursorLocationType.Nodes);
-		const index = info.parentIndex + 1;
-		if (index === info.topLevelLength) {
+		const index = this.fieldIndex + 1;
+		if (index === this.siblingCount(info)) {
 			this.exitNode();
 			return false;
 		}
@@ -557,15 +642,17 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 
 	public exitNode(): void {
 		const info = this.nodeInfo(CursorLocationType.Nodes);
-		this.indexOfField =
-			info.indexOfParentField ??
-			fail(0xb0a /* navigation up to root field not yet supported */); // TODO;
+		const withinTree = this.positionIndex - 1 - this.topLevelIndex * this.nodeLength;
+		// Top-level nodes (no parent) exit to the root field at position 0;
+		// nested nodes' parent is `indexOfParentPosition` within the same top-level instance.
+		this.indexOfField = info.indexOfParentField ?? 0;
 		this.fieldKey = info.parentField;
 		this.mode = CursorLocationType.Fields;
 		this.moveToPosition(
-			info.indexOfParentPosition ??
-				fail(0xb0b /* navigation up to root field not yet supported */),
-		); // TODO
+			info.indexOfParentPosition === undefined
+				? 0
+				: this.positionIndex - withinTree + info.indexOfParentPosition,
+		);
 	}
 
 	public firstField(): boolean {
@@ -598,7 +685,7 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 	public get value(): Value {
 		const info = this.nodeInfo(CursorLocationType.Nodes);
 		if (info.shape.hasValue) {
-			const value = this.chunk.values[info.valueOffset];
+			const value = this.chunk.values[info.valueOffset + this.topLevelIndex * this.stride];
 			// If mayContainCompressedIds is set, check if the value is a number (i.e. a compressed ID that needs decompression).
 			if (info.shape.mayContainCompressedIds && typeof value === "number") {
 				const idCompressor = this.chunk.idCompressor;

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

@@ -316,6 +316,7 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 		const detachCellId = this.modularBuilder.generateId(count);
 		const attachCellId: CellId = { localId: this.modularBuilder.generateId(count), revision };
 		if (compareFieldUpPaths(sourceField, destinationField)) {
+			// The source and destination fields are the same.
 			const change = sequence.changeHandler.editor.move(
 				sourceIndex,
 				count,
@@ -331,32 +332,53 @@ export class DefaultEditBuilder implements ChangeFamilyEditor, IDefaultEditBuild
 				revision,
 			);
 		} else {
+			// The source and destination fields are different.
 			const detachPath = topDownPath(sourceField.parent);
 			const attachPath = topDownPath(destinationField.parent);
+			/**
+			 * The number of elements, starting from the root, that both paths have in common.
+			 * This defines the lowest common ancestor node (LCA) of the source and destination fields.
+			 */
 			const sharedDepth = getSharedPrefixLength(detachPath, attachPath);
 			let adjustedAttachField = destinationField;
-			// After the above loop, `sharedDepth` is the number of elements, starting from the root,
-			// that both paths have in common.
+			// Check if the detach parent
+			// (the node directly above the location of detach)
+			// is along the attach path,
+			// in which case the attach path might need to be adjusted.
+			// This is synonymous with checking if the attach parent
+			// (the node directly above the location of attach)
+			// is either below or the same as the detach parent.
+			// If not, then the move does not need to be adjusted
+			// as the attach path will not be affected by the detach.
 			if (sharedDepth === detachPath.length) {
-				const attachField = attachPath[sharedDepth]?.parentField ?? destinationField.field;
-				if (attachField === sourceField.field) {
-					// The detach occurs in an ancestor field of the field where the attach occurs.
-					let attachAncestorIndex = attachPath[sharedDepth]?.parentIndex ?? sourceIndex;
-					if (attachAncestorIndex < sourceIndex) {
+				const fieldOnDetachPathUnderLCA = sourceField.field;
+				const firstDifferentAttachAncestor = attachPath[sharedDepth];
+				// Check if the detach location uses the same field as in
+				// the attach path.
+				// Note that when `firstDifferentAttachAncestor` is undefined,
+				// that means the parents are the same. Since earlier call
+				// to `compareFieldUpPaths` returned false, we know that the
+				// fields must be different AND thus no adjustment is needed.
+				if (fieldOnDetachPathUnderLCA === firstDifferentAttachAncestor?.parentField) {
+					// Now working at the level where detach happens along the
+					// attach path.
+					if (firstDifferentAttachAncestor.parentIndex < sourceIndex) {
 						// The attach path runs through a node located before the detached nodes.
 						// No need to adjust the attach path.
-					} else if (sourceIndex + count <= attachAncestorIndex) {
+					} else if (sourceIndex + count <= firstDifferentAttachAncestor.parentIndex) {
 						// The attach path runs through a node located after the detached nodes.
-						// adjust the index for the node at that depth of the path, so that it is interpreted correctly
+						// Adjust the index for the node at that depth of the path, so that it is interpreted correctly
 						// in the composition performed by `submitChanges`.
-						attachAncestorIndex -= count;
-						let parent: UpPath | undefined = attachPath[sharedDepth - 1];
-						const parentField = attachPath[sharedDepth] ?? oob();
+						// Start with path to root that remains intact.
+						let parent = firstDifferentAttachAncestor.parent;
+						// Extend with index-adjusted parent.
 						parent = {
 							parent,
-							parentIndex: attachAncestorIndex,
-							parentField: parentField.parentField,
+							parentIndex: firstDifferentAttachAncestor.parentIndex - count,
+							parentField: firstDifferentAttachAncestor.parentField,
 						};
+						// Extend with the rest of the attach path, which is unaffected
+						// apart from parentage replacements.
 						for (let i = sharedDepth + 1; i < attachPath.length; i += 1) {
 							parent = {
 								...(attachPath[i] ?? oob()),

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

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { type Static, Type } from "@sinclair/typebox";
+import * as Type from "@sinclair/typebox";
+import type { Static } from "@sinclair/typebox";
 
 import { versionField } from "../../codec/index.js";
 import { schemaFormatV1 } from "../../core/index.js";

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

@@ -6,7 +6,8 @@
 // Many of the return types in this module are intentionally derived, rather than explicitly specified.
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 
-import { type Static, type TAnySchema, type TSchema, Type } from "@sinclair/typebox";
+import * as Type from "@sinclair/typebox";
+import type { Static, TAnySchema, TSchema } from "@sinclair/typebox";
 
 export const EncodedGenericChange = <NodeChangesetSchema extends TSchema>(
 	tNodeChangeset: NodeChangesetSchema,

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

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

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
+import * as Type from "@sinclair/typebox";
+import type { ObjectOptions, Static } from "@sinclair/typebox";
 
 import { type ChangesetLocalId, RevisionTagSchema, schemaFormatV1 } from "../../core/index.js";
 import {

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

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
+import * as Type from "@sinclair/typebox";
+import type { ObjectOptions, Static } from "@sinclair/typebox";
 
 import { EncodedModularChangesetV1 } from "./modularChangeFormatV1.js";
 

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

@@ -64,11 +64,6 @@ export interface ModularChangeset extends Readonly<HasFieldChanges> {
 	readonly noChangeConstraint?: NoChangeConstraint;
 	/** Constraint that the document must be in the same state before the revert of this change is applied as it was after this change was applied */
 	readonly noChangeConstraintOnRevert?: NoChangeConstraint;
-	/**
-	 * The number of constraint violations that apply to the revert of the changeset. If this count is greater than 0, it will
-	 * prevent the changeset from being reverted or undone.
-	 */
-	readonly constraintViolationCountOnRevert?: number;
 	readonly builds?: ChangeAtomIdBTree<TreeChunk>;
 	readonly destroys?: ChangeAtomIdBTree<number>;
 	readonly refreshers?: ChangeAtomIdBTree<TreeChunk>;

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

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { type ObjectOptions, type Static, type TSchema, Type } from "@sinclair/typebox";
+import * as Type from "@sinclair/typebox";
+import type { ObjectOptions, Static, TSchema } from "@sinclair/typebox";
 
 import { EncodedChangeAtomId } from "../modular-schema/index.js";
 

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

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { type ObjectOptions, type Static, type TSchema, Type } from "@sinclair/typebox";
+import * as Type from "@sinclair/typebox";
+import type { ObjectOptions, Static, TSchema } from "@sinclair/typebox";
 
 import { EncodedChangeAtomId } from "../modular-schema/index.js";
 

package/src/feature-libraries/schema-edits/schemaChangeFormat.ts

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { type Static, Type } from "@sinclair/typebox";
+import * as Type from "@sinclair/typebox";
+import type { Static } from "@sinclair/typebox";
 
 import { JsonCompatibleReadOnlySchema } from "../../util/index.js";
 

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

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
+import * as Type from "@sinclair/typebox";
+import type { ObjectOptions, Static } from "@sinclair/typebox";
 
 import { SchemaFormatVersion, schemaFormatV1 } from "../../core/index.js";
 

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

@@ -3,7 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
+import * as Type from "@sinclair/typebox";
+import type { ObjectOptions, Static } from "@sinclair/typebox";
 
 import { SchemaFormatVersion, schemaFormatV2 } from "../../core/index.js";
 

package/src/feature-libraries/sequence-field/compose.ts

@@ -473,6 +473,7 @@ function handleNodeChanges(
 	moveEffects: MoveEffectTable,
 ): NodeId | undefined {
 	if (newMark.changes !== undefined) {
+		moveEffects.onMoveIn(newMark.changes);
 		const baseSource = getMoveIn(baseMark);
 
 		// TODO: Make sure composeChild is not called twice on the node changes.
@@ -589,10 +590,6 @@ export class ComposeQueue {
 	private dequeueBase(length: number = Number.POSITIVE_INFINITY): ComposeMarks {
 		const baseMark = this.baseMarks.dequeueUpTo(length);
 		const movedChanges = getMovedChangesFromMark(this.moveEffects, baseMark);
-		if (movedChanges !== undefined) {
-			this.moveEffects.onMoveIn(movedChanges);
-		}
-
 		const newMark = createNoopMark(baseMark.count, movedChanges, getOutputCellId(baseMark));
 		return { baseMark, newMark };
 	}