@fluidframework/tree 2.1.0-276985 → 2.1.0-281041

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

@@ -130,6 +130,8 @@ export const EncodedModularChangeset = Type.Object(
 		maxId: Type.Optional(ChangesetLocalIdSchema),
 		changes: EncodedFieldChangeMap,
 		revisions: Type.ReadonlyOptional(Type.Array(EncodedRevisionInfo)),
+		// TODO#8574: separating `builds` and `refreshers` here means that we encode their `EncodedBuilds.trees` separately.
+		// This can lead to a less efficient wire representation because of duplicated schema/shape information.
 		builds: Type.Optional(EncodedBuilds),
 		refreshers: Type.Optional(EncodedBuilds),
 		/**

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

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import type { BTree } from "@tylerbu/sorted-btree-es6";
 import type {
 	ChangeAtomId,
 	ChangeAtomIdMap,
@@ -10,9 +11,11 @@ import type {
 	FieldKey,
 	FieldKindIdentifier,
 	RevisionInfo,
+	RevisionTag,
 } from "../../core/index.js";
 import type { Brand } from "../../util/index.js";
 import type { TreeChunk } from "../chunked-forest/index.js";
+import type { CrossFieldTarget } from "./crossFieldQueries.js";
 
 /**
  * @internal
@@ -30,13 +33,61 @@ export interface ModularChangeset extends HasFieldChanges {
 	 */
 	readonly revisions?: readonly RevisionInfo[];
 	readonly fieldChanges: FieldChangeMap;
+
+	/**
+	 * Maps from this changeset's canonical ID for a node (see comment on node aliases) to the changes for that node.
+	 */
 	readonly nodeChanges: ChangeAtomIdMap<NodeChangeset>;
+
+	/**
+	 * Maps from this changeset's canonical ID for a node to the ID for the field which contains that node.
+	 */
+	// TODO: Should this be merged with `nodeChanges`?
+	readonly nodeToParent: ChangeAtomIdMap<FieldId>;
+
+	/**
+	 * Maps from a node ID to another ID for the same node.
+	 * If a node ID used in this changeset has no entry in this table, then it is the canonical ID for that node.
+	 * The aliases form a set of trees, where the root of each tree is a canonical ID.
+	 *
+	 * When composing changesets with different canonical IDs for the same node,
+	 * one of those IDs becomes the canonical ID for the composition, while the other is added to this table as an alias.
+	 *
+	 * Node aliases are preserved when composing changesets so we can avoid having to find and update all changed node IDs
+	 * in the field IDs in nodeToParent and crossFieldKeys.
+	 */
+	readonly nodeAliases: ChangeAtomIdMap<NodeId>;
+	readonly crossFieldKeys: CrossFieldKeyTable;
 	readonly constraintViolationCount?: number;
 	readonly builds?: ChangeAtomIdMap<TreeChunk>;
 	readonly destroys?: ChangeAtomIdMap<number>;
 	readonly refreshers?: ChangeAtomIdMap<TreeChunk>;
 }
 
+export type TupleBTree<K, V> = Brand<BTree<K, V>, "TupleBTree">;
+export type CrossFieldKeyTable = TupleBTree<CrossFieldKeyRange, FieldId>;
+export type CrossFieldKeyRange = readonly [
+	CrossFieldTarget,
+	RevisionTag | undefined,
+	ChangesetLocalId,
+	/**
+	 * The length of this range.
+	 * TODO: This does not need to be part of the key and could be part of the value instead.
+	 */
+	number,
+];
+
+export type CrossFieldKey = readonly [
+	CrossFieldTarget,
+	RevisionTag | undefined,
+	ChangesetLocalId,
+];
+
+export interface FieldId {
+	readonly nodeId: NodeId | undefined;
+	readonly field: FieldKey;
+}
+
 /**
  * @internal
  */

package/src/feature-libraries/node-key/index.ts

@@ -10,7 +10,6 @@ export {
 	type StableNodeKey,
 	nodeKeyTreeIdentifier,
 } from "./nodeKey.js";
-export { NodeKeyIndex } from "./nodeKeyIndex.js";
 export {
 	createNodeKeyManager,
 	isStableNodeKey,

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

@@ -713,6 +713,7 @@ export const optionalChangeHandler: FieldChangeHandler<
 	getNestedChanges,
 
 	createEmpty: () => ({ moves: [], childChanges: [] }),
+	getCrossFieldKeys: (_change) => [],
 };
 
 function getNestedChanges(change: OptionalChangeset): [NodeId, number | undefined][] {

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

@@ -42,8 +42,6 @@ export { compose } from "./compose.js";
 export {
 	getInputLength,
 	isDetach,
-	newCrossFieldTable,
-	type CrossFieldTable,
 	cloneMark,
 	extractMarkEffect,
 } from "./utils.js";

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

@@ -194,7 +194,6 @@ function invertMark(
 			return applyMovedChanges(invertedMark, mark.revision, crossFieldManager);
 		}
 		case "AttachAndDetach": {
-			// Which should get the child change? Don't want to invert twice
 			const attach: Mark = {
 				count: mark.count,
 				cellId: mark.cellId,
@@ -294,6 +293,7 @@ function applyMovedChanges(
 	}
 
 	if (entry.value !== undefined) {
+		manager.onMoveIn(entry.value);
 		return [withNodeChange<CellMark<MoveOut>, MoveOut>(mark, entry.value)];
 	}
 

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

@@ -270,6 +270,7 @@ function rebaseMark(
 			0x8dc /* Unexpected collision of new node changes */,
 		);
 		rebasedMark.changes = movedNodeChanges;
+		moveEffects.onMoveIn(movedNodeChanges);
 	}
 
 	return rebaseMarkIgnoreChild(rebasedMark, baseMark, moveEffects);
@@ -514,7 +515,12 @@ function getMovedEffect(
 ): MarkEffect | undefined {
 	const effect = getMoveEffect(moveEffects, CrossFieldTarget.Destination, revision, id, count);
 	assert(effect.length === count, 0x6f3 /* Expected effect to cover entire mark */);
-	return effect.value?.movedEffect;
+	const movedEffect = effect.value?.movedEffect;
+	if (movedEffect !== undefined && movedEffect.type === "MoveOut") {
+		moveEffects.moveKey(CrossFieldTarget.Source, movedEffect.revision, movedEffect.id, count);
+	}
+
+	return movedEffect;
 }
 
 function getMovedChangesFromBaseMark(

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

@@ -11,7 +11,7 @@ import { sequenceFieldChangeCodecFactory } from "./sequenceFieldCodecs.js";
 import { type SequenceFieldEditor, sequenceFieldEditor } from "./sequenceFieldEditor.js";
 import { sequenceFieldToDelta } from "./sequenceFieldToDelta.js";
 import type { Changeset } from "./types.js";
-import { createEmpty, getNestedChanges, isEmpty } from "./utils.js";
+import { createEmpty, getCrossFieldKeys, getNestedChanges, isEmpty } from "./utils.js";
 
 export type SequenceFieldChangeHandler = FieldChangeHandler<Changeset, SequenceFieldEditor>;
 
@@ -24,4 +24,5 @@ export const sequenceFieldChangeHandler: SequenceFieldChangeHandler = {
 	isEmpty,
 	getNestedChanges,
 	createEmpty,
+	getCrossFieldKeys,
 };

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

@@ -13,20 +13,11 @@ import {
 	areEqualChangeAtomIds,
 	makeChangeAtomId,
 } from "../../core/index.js";
+import { type Mutable, brand, fail } from "../../util/index.js";
 import {
-	type Mutable,
-	type RangeMap,
-	brand,
-	fail,
-	getFromRangeMap,
-} from "../../util/index.js";
-import {
-	type CrossFieldManager,
-	type CrossFieldQuerySet,
 	CrossFieldTarget,
 	type NodeId,
-	addCrossFieldQuery,
-	setInCrossFieldMap,
+	type CrossFieldKeyRange,
 } from "../modular-schema/index.js";
 
 import type {
@@ -47,7 +38,6 @@ import {
 	type Insert,
 	type Mark,
 	type MarkEffect,
-	type MoveId,
 	type MoveIn,
 	type MoveOut,
 	type NoopMark,
@@ -708,79 +698,6 @@ function tryMergeEffects(
 	return undefined;
 }
 
-/**
- * @internal
- */
-export interface CrossFieldTable<T = unknown> extends CrossFieldManager<T> {
-	srcQueries: CrossFieldQuerySet;
-	dstQueries: CrossFieldQuerySet;
-	isInvalidated: boolean;
-	mapSrc: Map<RevisionTag | undefined, RangeMap<T>>;
-	mapDst: Map<RevisionTag | undefined, RangeMap<T>>;
-	reset: () => void;
-}
-
-/**
- * @internal
- */
-export function newCrossFieldTable<T = unknown>(): CrossFieldTable<T> {
-	const srcQueries: CrossFieldQuerySet = new Map();
-	const dstQueries: CrossFieldQuerySet = new Map();
-	const mapSrc: Map<RevisionTag | undefined, RangeMap<T>> = new Map();
-	const mapDst: Map<RevisionTag | undefined, RangeMap<T>> = new Map();
-
-	const getMap = (target: CrossFieldTarget): Map<RevisionTag | undefined, RangeMap<T>> =>
-		target === CrossFieldTarget.Source ? mapSrc : mapDst;
-
-	const getQueries = (target: CrossFieldTarget): CrossFieldQuerySet =>
-		target === CrossFieldTarget.Source ? srcQueries : dstQueries;
-
-	const table = {
-		srcQueries,
-		dstQueries,
-		isInvalidated: false,
-		mapSrc,
-		mapDst,
-
-		get: (
-			target: CrossFieldTarget,
-			revision: RevisionTag | undefined,
-			id: MoveId,
-			count: number,
-			addDependency: boolean,
-		) => {
-			if (addDependency) {
-				addCrossFieldQuery(getQueries(target), revision, id, count);
-			}
-			return getFromRangeMap(getMap(target).get(revision) ?? [], id, count);
-		},
-		set: (
-			target: CrossFieldTarget,
-			revision: RevisionTag | undefined,
-			id: MoveId,
-			count: number,
-			value: T,
-			invalidateDependents: boolean,
-		) => {
-			if (
-				invalidateDependents &&
-				getFromRangeMap(getQueries(target).get(revision) ?? [], id, count) !== undefined
-			) {
-				table.isInvalidated = true;
-			}
-			setInCrossFieldMap(getMap(target), revision, id, count, value);
-		},
-
-		reset: () => {
-			table.isInvalidated = false;
-			table.srcQueries.clear();
-			table.dstQueries.clear();
-		},
-	};
-
-	return table;
-}
-
 /**
  * Splits the `mark` into two marks such that the first returned mark has length `length`.
  * @param mark - The mark to split.
@@ -969,3 +886,38 @@ export function getEndpoint(effect: MoveMarkEffect): ChangeAtomId {
 			}
 		: { revision: effect.revision, localId: effect.id };
 }
+
+export function getCrossFieldKeys(change: Changeset): CrossFieldKeyRange[] {
+	const keys: CrossFieldKeyRange[] = [];
+	for (const mark of change) {
+		keys.push(...getCrossFieldKeysForMarkEffect(mark, mark.count));
+	}
+
+	return keys;
+}
+
+function getCrossFieldKeysForMarkEffect(
+	effect: MarkEffect,
+	count: number,
+): CrossFieldKeyRange[] {
+	switch (effect.type) {
+		case "Insert":
+			// An insert behaves like a move where the source and destination are at the same location.
+			// An insert can become a move when after rebasing.
+			return [
+				[CrossFieldTarget.Source, effect.revision, effect.id, count],
+				[CrossFieldTarget.Destination, effect.revision, effect.id, count],
+			];
+		case "MoveOut":
+			return [[CrossFieldTarget.Source, effect.revision, effect.id, count]];
+		case "MoveIn":
+			return [[CrossFieldTarget.Destination, effect.revision, effect.id, count]];
+		case "AttachAndDetach":
+			return [
+				...getCrossFieldKeysForMarkEffect(effect.attach, count),
+				...getCrossFieldKeysForMarkEffect(effect.detach, count),
+			];
+		default:
+			return [];
+	}
+}

package/src/feature-libraries/typed-schema/typedTreeSchema.ts

@@ -19,6 +19,7 @@ import {
 	type TreeStoredSchema,
 	type TreeTypeSet,
 	type ValueSchema,
+	identifierFieldKindIdentifier,
 } from "../../core/index.js";
 import {
 	type Assume,
@@ -28,6 +29,7 @@ import {
 	mapIterable,
 	oneFromSet,
 	type requireAssignableTo,
+	filterIterable,
 } from "../../util/index.js";
 import { FieldKinds } from "../default-schema/index.js";
 import type { FlexFieldKind, FullSchemaPolicy } from "../modular-schema/index.js";
@@ -154,6 +156,7 @@ export class FlexObjectNodeSchema<
 	const out Specification extends Unenforced<FlexObjectNodeFields> = FlexObjectNodeFields,
 > extends TreeNodeSchemaBase<Name, Specification> {
 	protected _typeCheck2?: MakeNominal;
+	public readonly identifierFieldKeys: readonly FieldKey[] = [];
 
 	public static create<
 		const Name extends string,
@@ -192,6 +195,13 @@ export class FlexObjectNodeSchema<
 	) {
 		const fields = mapIterable(objectNodeFields, ([k, v]) => [k, v.stored] as const);
 		super(builder, name, info, new ObjectNodeStoredSchema(new Map(fields)));
+		this.identifierFieldKeys = Array.from(
+			filterIterable(
+				objectNodeFields.entries(),
+				([k, f]) => f.kind.identifier === identifierFieldKindIdentifier,
+			),
+			([k]) => k,
+		);
 	}
 
 	public override getFieldSchema(field: FieldKey): FlexFieldSchema {

package/src/index.ts

@@ -358,7 +358,6 @@ export {
 	type FlexTreeUnboxField,
 	type FlexTreeUnboxNode,
 	type FlexTreeUnboxNodeUnion,
-	type FlexTreeNodeKeyField,
 	type IsArrayOfOne,
 	type FlexibleNodeSubSequence,
 	flexTreeMarker,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.1.0-276985";
+export const pkgVersion = "2.1.0-281041";

package/src/shared-tree/schematizingTreeView.ts

@@ -39,7 +39,7 @@ import {
 	mapTreeFromNodeData,
 	prepareContentForHydration,
 } from "../simple-tree/index.js";
-import { disposeSymbol } from "../util/index.js";
+import { Breakable, breakingClass, disposeSymbol, type WithBreakable } from "../util/index.js";
 
 import { canInitialize, ensureSchema, initialize } from "./schematizeTree.js";
 import type { TreeCheckout } from "./treeCheckout.js";
@@ -48,8 +48,9 @@ import { CheckoutFlexTreeView } from "./treeView.js";
 /**
  * Implementation of TreeView wrapping a FlexTreeView.
  */
+@breakingClass
 export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitFieldSchema>
-	implements TreeView<TRootSchema>
+	implements TreeView<TRootSchema>, WithBreakable
 {
 	/**
 	 * The view is set to undefined when this object is disposed or the view schema does not support viewing the document's stored schema.
@@ -86,6 +87,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		public readonly checkout: TreeCheckout,
 		public readonly config: TreeViewConfiguration<TRootSchema>,
 		public readonly nodeKeyManager: NodeKeyManager,
+		public readonly breaker: Breakable = new Breakable("SchematizingSimpleTreeView"),
 	) {
 		const policy = {
 			...defaultSchemaPolicy,
@@ -306,6 +308,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	}
 
 	public get root(): TreeFieldFromImplicitField<TRootSchema> {
+		this.breaker.use();
 		if (!this.compatibility.canView) {
 			throw new UsageError(
 				"Document is out of schema. Check TreeView.compatibility before accessing TreeView.root.",
@@ -316,6 +319,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	}
 
 	public set root(newRoot: InsertableTreeFieldFromImplicitField<TRootSchema>) {
+		this.breaker.use();
 		if (!this.compatibility.canView) {
 			throw new UsageError(
 				"Document is out of schema. Check TreeView.compatibility before accessing TreeView.root.",

package/src/shared-tree/sharedTree.ts

@@ -64,6 +64,7 @@ import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
 import type { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 import { type CheckoutEvents, type TreeCheckout, createTreeCheckout } from "./treeCheckout.js";
 import type { CheckoutFlexTreeView, FlexTreeView } from "./treeView.js";
+import { breakingClass, throwIfBroken } from "../util/index.js";
 
 /**
  * Copy of data from an {@link ISharedTree} at some point in time.
@@ -162,6 +163,7 @@ function getCodecVersions(formatVersion: number): ExplicitCodecVersions {
  *
  * TODO: detail compatibility requirements.
  */
+@breakingClass
 export class SharedTree
 	extends SharedTreeCore<SharedTreeEditBuilder, SharedTreeChange>
 	implements ISharedTree
@@ -288,6 +290,7 @@ export class SharedTree
 		);
 	}
 
+	@throwIfBroken
 	public contentSnapshot(): SharedTreeContentSnapshot {
 		const cursor = this.checkout.forest.allocateCursor("contentSnapshot");
 		try {
@@ -326,6 +329,7 @@ export class SharedTree
 			this.checkout,
 			config,
 			createNodeKeyManager(this.runtime.idCompressor),
+			this.breaker,
 		);
 	}
 

package/src/shared-tree/treeCheckout.ts

@@ -572,6 +572,10 @@ export class TreeCheckout implements ITreeCheckoutFork {
 
 	public rebase(view: TreeCheckout): void {
 		this.checkNotDisposed();
+		assert(
+			!view.transaction.inProgress(),
+			"A view cannot be rebased while it has a pending transaction",
+		);
 		view.branch.rebaseOnto(this.branch);
 	}
 
@@ -585,8 +589,8 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	public merge(view: TreeCheckout, disposeView = true): void {
 		this.checkNotDisposed();
 		assert(
-			!this.transaction.inProgress() || disposeView,
-			0x710 /* A view that is merged into an in-progress transaction must be disposed */,
+			!this.transaction.inProgress(),
+			"Views cannot be merged into a view while it has a pending transaction",
 		);
 		while (view.transaction.inProgress()) {
 			view.transaction.commit();

package/src/shared-tree-core/branch.ts

@@ -244,6 +244,7 @@ export class SharedTreeBranch<
 	): [change: TChange, newCommit: GraphCommit<TChange>] {
 		this.assertNotDisposed();
 
+		// TODO: This should not be necessary when receiving changes from other clients.
 		const changeWithRevision = this.changeFamily.rebaser.changeRevision(change, revision);
 
 		const newHead = mintCommit(this.head, {

package/src/shared-tree-core/sharedTreeCore.ts

@@ -34,7 +34,14 @@ import {
 	type SchemaPolicy,
 	type TreeStoredSchemaRepository,
 } from "../core/index.js";
-import { type JsonCompatibleReadOnly, brand } from "../util/index.js";
+import {
+	type JsonCompatibleReadOnly,
+	brand,
+	Breakable,
+	type WithBreakable,
+	throwIfBroken,
+	breakingClass,
+} from "../util/index.js";
 
 import { type SharedTreeBranch, getChangeReplaceType } from "./branch.js";
 import { EditManager, minimumPossibleSequenceNumber } from "./editManager.js";
@@ -62,12 +69,15 @@ export interface ClonableSchemaAndPolicy extends SchemaAndPolicy {
 }
 
 /**
- * Generic shared tree, which needs to be configured with indexes, field kinds and a history policy to be used.
- *
- * TODO: actually implement
- * TODO: is history policy a detail of what indexes are used, or is there something else to it?
+ * Generic shared tree, which needs to be configured with indexes, field kinds and other configuration.
  */
-export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange> extends SharedObject {
+@breakingClass
+export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
+	extends SharedObject
+	implements WithBreakable
+{
+	public readonly breaker: Breakable = new Breakable("Shared Tree");
+
 	private readonly editManager: EditManager<TEditor, TChange, ChangeFamily<TEditor, TChange>>;
 	private readonly summarizables: readonly Summarizable[];
 	/**
@@ -262,6 +272,7 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange> extends
 
 	// TODO: SharedObject's merging of the two summary methods into summarizeCore is not what we want here:
 	// We might want to not subclass it, or override/reimplement most of its functionality.
+	@throwIfBroken
 	protected summarizeCore(
 		serializer: IFluidSerializer,
 		telemetryContext?: ITelemetryContext,
@@ -304,6 +315,7 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange> extends
 	 * @returns the submitted commit. This is undefined if the underlying `SharedObject` is not attached,
 	 * and may differ from `commit` due to enrichments like detached tree refreshers.
 	 */
+
 	private submitCommit(
 		commit: GraphCommit<TChange>,
 		schemaAndPolicy: ClonableSchemaAndPolicy,

package/src/simple-tree/arrayNode.ts

@@ -19,6 +19,7 @@ import {
 	getOrCreateMapTreeNode,
 	getSchemaAndPolicy,
 	isMapTreeNode,
+	isFlexTreeNode,
 } from "../feature-libraries/index.js";
 import {
 	type InsertableContent,
@@ -39,7 +40,12 @@ import {
 	normalizeFieldSchema,
 } from "./schemaTypes.js";
 import { mapTreeFromNodeData } from "./toMapTree.js";
-import { type TreeNode, TreeNodeValid } from "./types.js";
+import {
+	type TreeNode,
+	TreeNodeValid,
+	type InternalTreeNode,
+	type MostDerivedData,
+} from "./types.js";
 import { fail } from "../util/index.js";
 import { getFlexSchema } from "./toFlexSchema.js";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
@@ -215,6 +221,11 @@ export interface TreeArrayNodeBase<out T, in TNew, in TMoveFrom>
 		sourceEnd: number,
 		source: TMoveFrom,
 	): void;
+
+	/**
+	 * Returns a custom IterableIterator which throws usage errors if concurrent editing and iteration occurs.
+	 */
+	values(): IterableIterator<T>;
 }
 
 /**
@@ -315,7 +326,6 @@ const arrayPrototypeKeys = [
 	"some",
 	"toLocaleString",
 	"toString",
-	"values",
 
 	// "copyWithin",
 	// "fill",
@@ -489,7 +499,6 @@ declare abstract class NodeWithArrayFeatures<Input, T>
 	): boolean;
 	toLocaleString(): string;
 	toString(): string;
-	values(): IterableIterator<T>;
 }
 /* eslint-enable @typescript-eslint/explicit-member-accessibility, @typescript-eslint/no-explicit-any */
 
@@ -554,16 +563,8 @@ function createArrayNodeProxy(
 				return Reflect.get(dispatchTarget, key, receiver) as unknown;
 			}
 
-			const value = field.boxedAt(maybeIndex);
-
-			if (value === undefined) {
-				return undefined;
-			}
-
-			// TODO: Ideally, we would return leaves without first boxing them.  However, this is not
-			//       as simple as calling '.content' since this skips the node and returns the FieldNode's
-			//       inner field.
-			return getOrCreateNodeProxy(value);
+			const maybeContent = field.at(maybeIndex);
+			return isFlexTreeNode(maybeContent) ? getOrCreateNodeProxy(maybeContent) : maybeContent;
 		},
 		set: (target, key, newValue, receiver) => {
 			if (key === "length") {
@@ -590,7 +591,7 @@ function createArrayNodeProxy(
 					"Cannot set indexed properties on array nodes. Use array node mutation APIs to alter the array.",
 				);
 			}
-			return allowAdditionalProperties ? Reflect.set(target, key, newValue) : false;
+			return allowAdditionalProperties ? Reflect.set(target, key, newValue, receiver) : false;
 		},
 		has: (target, key) => {
 			const field = getSequenceField(proxy);
@@ -672,6 +673,21 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 
 	protected abstract get simpleSchema(): T;
 
+	/**
+	 * Generation number which is incremented any time we have an edit on the node.
+	 * Used during iteration to make sure there has been no edits that were concurrently made.
+	 */
+	#generationNumber: number = 0;
+
+	public constructor(
+		input: Iterable<InsertableTreeNodeFromImplicitAllowedTypes<T>> | InternalTreeNode,
+	) {
+		super(input);
+		getFlexNode(this).on("nodeChanged", () => {
+			this.#generationNumber += 1;
+		});
+	}
+
 	#cursorFromFieldData(value: Insertable<T>): ITreeCursorSynchronous {
 		if (isMapTreeNode(getFlexNode(this))) {
 			throw new UsageError(`An array cannot be mutated before being inserted into the tree`);
@@ -827,13 +843,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		const destinationField = getSequenceField(this);
 		validateIndex(destinationIndex, destinationField, "moveRangeToIndex", true);
 		validateIndexRange(sourceStart, sourceEnd, source ?? destinationField, "moveRangeToIndex");
-		const sourceField =
-			source !== undefined
-				? destinationField.isSameAs(getSequenceField(source))
-					? destinationField
-					: getSequenceField(source)
-				: destinationField;
-
+		const sourceField = source !== undefined ? getSequenceField(source) : destinationField;
 		// TODO: determine support for move across different sequence types
 		if (destinationField.schema.types !== undefined && sourceField !== destinationField) {
 			for (let i = sourceStart; i < sourceEnd; i++) {
@@ -855,6 +865,23 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 			destinationIndex,
 		);
 	}
+
+	public values(): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
+		return this.generateValues(this.#generationNumber);
+	}
+	private *generateValues(
+		initialLastUpdatedStamp: number,
+	): Generator<TreeNodeFromImplicitAllowedTypes<T>> {
+		if (initialLastUpdatedStamp !== this.#generationNumber) {
+			throw new UsageError(`Concurrent editing and iteration is not allowed.`);
+		}
+		for (let i = 0; i < this.length; i++) {
+			yield this.at(i) ?? fail("Index is out of bounds");
+			if (initialLastUpdatedStamp !== this.#generationNumber) {
+				throw new UsageError(`Concurrent editing and iteration is not allowed.`);
+			}
+		}
+	}
 }
 
 /**
@@ -921,7 +948,7 @@ export function arraySchema<
 			);
 		}
 
-		protected static override constructorCached: typeof TreeNodeValid | undefined = undefined;
+		protected static override constructorCached: MostDerivedData | undefined = undefined;
 
 		protected static override oneTimeSetup<T2>(this: typeof TreeNodeValid<T2>): void {
 			flexSchema = getFlexSchema(this as unknown as TreeNodeSchema) as FlexFieldNodeSchema;