@fluidframework/tree 2.74.0-365691 → 2.74.0-368706

package/src/feature-libraries/index.ts

@@ -12,7 +12,7 @@ export { allowsValue, assertAllowedValue, isTreeValue } from "./valueUtilities.j
 export {
 	ForestSummarizer,
 	getCodecTreeForForestFormat,
-	type ForestFormatVersion,
+	ForestFormatVersion,
 } from "./forest-summary/index.js";
 export {
 	cursorForMapTreeField,
@@ -72,7 +72,9 @@ export {
 	type NodeChangeInverter,
 	type NodeChangeRebaser,
 	type NodeChangePruner,
-	type CrossFieldManager,
+	type ComposeNodeManager,
+	type InvertNodeManager,
+	type RebaseNodeManager,
 	CrossFieldTarget,
 	FlexFieldKind,
 	type FullSchemaPolicy,
@@ -82,7 +84,6 @@ export {
 	type HasFieldChanges,
 	type NodeExistsConstraint,
 	ModularChangeFamily,
-	type RelevantRemovedRootsFromChild,
 	EncodedModularChangeset,
 	updateRefreshers,
 	type NodeId,
@@ -92,7 +93,11 @@ export {
 	isNeverTree,
 } from "./modular-schema/index.js";
 
-export { mapRootChanges } from "./deltaUtils.js";
+export {
+	mapRootChanges,
+	nodeIdFromChangeAtom,
+	changeAtomFromDetachedNodeId,
+} from "./deltaUtils.js";
 
 export {
 	type TreeChunk,
@@ -133,17 +138,25 @@ export {
 	type Identifier,
 	type Forbidden,
 	type DefaultChangeset,
+	type DetachedRootIds,
 	DefaultChangeFamily,
-	DefaultEditBuilder,
-	type IDefaultEditBuilder,
-	type ValueFieldEditBuilder,
-	type OptionalFieldEditBuilder,
-	type SequenceFieldEditBuilder,
+	type IdBasedChangeFamilyDataEditor,
+	DefaultIdBasedDataEditor,
+	type DataEditor,
+	type RequiredFieldEditor,
+	type OptionalFieldEditor,
+	type SequenceFieldEditor,
 	defaultSchemaPolicy,
 	fieldKinds,
 	fieldKindConfigurations,
 	intoDelta,
 	relevantRemovedRoots,
+	type DetachedRootLocation,
+	type DetachedRootsLocation,
+	type DetachedRootIdRange,
+	type Locator,
+	LocationBasedDataEditor,
+	type ILocationBasedDataEditor,
 	getCodecTreeForModularChangeFormat,
 	type ModularChangeFormatVersion,
 } from "./default-schema/index.js";

package/src/feature-libraries/mapTreeCursor.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, debugAssert } from "@fluidframework/core-utils/internal";
 
 import {
 	CursorLocationType,
@@ -161,6 +161,7 @@ export function mapTreeFromCursor(cursor: ITreeCursor): ExclusiveMapTree {
 	const fields: Map<FieldKey, ExclusiveMapTree[]> = new Map();
 	for (let inField = cursor.firstField(); inField; inField = cursor.nextField()) {
 		const field: ExclusiveMapTree[] = mapCursorField(cursor, mapTreeFromCursor);
+		debugAssert(() => field.length > 0 || "field must have at least one child");
 		fields.set(cursor.getFieldKey(), field);
 	}
 

package/src/feature-libraries/mitigatedChangeFamily.ts

@@ -7,6 +7,7 @@ import type {
 	ChangeFamily,
 	ChangeFamilyEditor,
 	ChangeRebaser,
+	EditorOptions,
 	RevisionMetadataSource,
 	RevisionTag,
 	TaggedChange,
@@ -35,8 +36,9 @@ export function makeMitigatedChangeFamily<TEditor extends ChangeFamilyEditor, TC
 		buildEditor: (
 			mintRevisionTag: () => RevisionTag,
 			changeReceiver: (change: TaggedChange<TChange>) => void,
+			options?: EditorOptions,
 		): TEditor => {
-			return unmitigatedChangeFamily.buildEditor(mintRevisionTag, changeReceiver);
+			return unmitigatedChangeFamily.buildEditor(mintRevisionTag, changeReceiver, options);
 		},
 		rebaser: makeMitigatedRebaser(unmitigatedChangeFamily.rebaser, fallbackChange, onError),
 		codecs: unmitigatedChangeFamily.codecs,

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

@@ -3,11 +3,12 @@
  * Licensed under the MIT License.
  */
 
-import { assert, fail } from "@fluidframework/core-utils/internal";
+import { assert, fail, unreachableCase } from "@fluidframework/core-utils/internal";
 
 import {
 	LeafNodeStoredSchema,
 	MapNodeStoredSchema,
+	Multiplicity,
 	ObjectNodeStoredSchema,
 	type TreeFieldStoredSchema,
 	type TreeNodeStoredSchema,
@@ -19,7 +20,7 @@ import {
 import { compareSets } from "../../util/index.js";
 
 import type { FullSchemaPolicy } from "./fieldKind.js";
-import { isNeverTree } from "./isNeverTree.js";
+import { isNeverField, isNeverTree } from "./isNeverTree.js";
 
 /**
  * Returns true iff `superset` is a superset of `original`.
@@ -125,16 +126,46 @@ export function allowsValueSuperset(
  * Returns true iff `superset` is a superset of `original`.
  *
  * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ *
+ * @param monotonicOnly - If true, only allow changes of field kinds which are explicitly listed in {@link FieldKindOptions.allowMonotonicUpgradeFrom}.
+ * This prevents this function from considering two different schema as equivalent, preventing upgrades which would allow their inverse.
+ * This prevents infinite upgrade loops where two clients could keep upgrading between two schema.
+ *
+ * @remarks
+ * True if a client should be able to {@link TreeView.upgradeSchema} from a field schema using this field kind and `originalTypes` to `superset`.
+ *
+ * @privateRemarks
+ * See also {@link FieldKindOptions.allowMonotonicUpgradeFrom} for constraints on the implementation.
  */
 export function allowsFieldSuperset(
 	policy: FullSchemaPolicy,
 	originalData: TreeStoredSchema,
 	original: TreeFieldStoredSchema,
 	superset: TreeFieldStoredSchema,
+	monotonicOnly: boolean = true,
 ): boolean {
-	return (
-		policy.fieldKinds.get(original.kind) ?? fail(0xb1b /* missing kind */)
-	).allowsFieldSuperset(policy, originalData, original.types, superset);
+	if (!monotonicOnly) {
+		if (isNeverField(policy, originalData, original)) {
+			return true;
+		}
+	}
+
+	if (!allowsTreeSchemaIdentifierSuperset(original.types, superset.types)) {
+		return false;
+	}
+
+	if (original.kind === superset.kind) {
+		return true;
+	}
+
+	const supersetKind = policy.fieldKinds.get(superset.kind) ?? fail(0xb1b /* missing kind */);
+
+	if (monotonicOnly) {
+		return supersetKind.options.allowMonotonicUpgradeFrom.has(original.kind);
+	} else {
+		const originalKind = policy.fieldKinds.get(original.kind) ?? fail("missing kind");
+		return allowsMultiplicitySuperset(originalKind.multiplicity, supersetKind.multiplicity);
+	}
 }
 
 /**
@@ -192,3 +223,30 @@ export function allowsRepoSuperset(
 	// Therefore, we do not need to check them.
 	return true;
 }
+
+/**
+ * Returns true iff `superset` is a superset of `original`.
+ *
+ * This does not require a strict (aka proper) superset: equivalent schema will return true.
+ */
+export function allowsMultiplicitySuperset(
+	original: Multiplicity,
+	superset: Multiplicity,
+): boolean {
+	if (original === superset) {
+		return true;
+	}
+
+	switch (superset) {
+		case Multiplicity.Forbidden:
+			return false;
+		case Multiplicity.Optional:
+			return original === Multiplicity.Single || original === Multiplicity.Forbidden;
+		case Multiplicity.Single:
+			return false;
+		case Multiplicity.Sequence:
+			return true;
+		default:
+			return unreachableCase(superset);
+	}
+}

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

@@ -16,23 +16,13 @@ import type { NodeId } from "./modularChangeTypes.js";
 export type CrossFieldMap<T> = ChangeAtomIdRangeMap<T>;
 export type CrossFieldQuerySet = CrossFieldMap<boolean>;
 
-export function addCrossFieldQuery(
-	set: CrossFieldQuerySet,
-	revision: RevisionTag | undefined,
-	id: ChangesetLocalId,
-	count: number,
-): void {
-	setInCrossFieldMap(set, revision, id, count, true);
-}
-
 export function setInCrossFieldMap<T>(
 	map: CrossFieldMap<T>,
-	revision: RevisionTag | undefined,
-	id: ChangesetLocalId,
+	id: ChangeAtomId,
 	count: number,
 	value: T,
 ): void {
-	map.set({ revision, localId: id }, count, value);
+	map.set(id, count, value);
 }
 
 export function getFirstFromCrossFieldMap<T>(
@@ -40,60 +30,168 @@ export function getFirstFromCrossFieldMap<T>(
 	revision: RevisionTag | undefined,
 	id: ChangesetLocalId,
 	count: number,
-): RangeQueryResult<ChangeAtomId, T> {
+): RangeQueryResult<T | undefined> {
 	return map.getFirst({ revision, localId: id }, count);
 }
 
+// TODO: Rename to NodeMoveType(Attach | Detach)
 export enum CrossFieldTarget {
 	Source,
 	Destination,
 }
 
-/**
- * Used by {@link FieldChangeHandler} implementations for exchanging information across other fields
- * while rebasing, composing, or inverting a change.
- */
-export interface CrossFieldManager<T = unknown> {
+export interface InvertNodeManager {
+	/**
+	 * Transfers the given node changes from the input context of the field changeset being inverted to the input context of the detached space (from which it may be further moved).
+	 *
+	 * This must be called for each detach in the field kind when rolling-back or undoing an detach.
+	 * This implies that all detaches in the field must be inverted.
+	 * @param detachId - The ID of the detach to invert.
+	 * @param count - The number of nodes being detached.
+	 * @param nodeChanges - The node changes to transfer.
+	 * @param newAttachId - The ID that the nodes will be attached with in the inverted changeset of this field.
+	 */
+	invertDetach(
+		detachId: ChangeAtomId,
+		count: number,
+		nodeChanges: NodeId | undefined,
+		newAttachId: ChangeAtomId,
+	): void;
+
+	/**
+	 * Gets the node changes associated with the node being attached in input changeset.
+	 *
+	 * This must be called for each attach in the field kind when rolling-back or undoing an attach.
+	 * This implies that all attaches in the field must be inverted.
+	 * @param attachId - The ID of the attach to invert.
+	 * @param count - The number of nodes being attached.
+	 */
+	invertAttach(
+		attachId: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<DetachedNodeEntry | undefined>;
+}
+
+export interface ComposeNodeManager {
+	/**
+	 * Allows a field kind to query nested changes associated with a node in the input context of the new changeset.
+	 * This should be called for every detach in the base changeset.
+	 * @param baseDetachId - The ID of the detach in the base changeset.
+	 * @param count - The number of nodes being detached.
+	 */
+	getNewChangesForBaseDetach(
+		baseDetachId: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<DetachedNodeEntry | undefined>;
+
 	/**
-	 * Returns the first data range associated with the key of `target`, `revision`, between `id` and `id + count`.
-	 * Calling this records a dependency for the current field on this key if `addDependency` is true.
+	 * Must be called by a field kind when composing an attach in the base changeset with a detach in the new changeset.
+	 * This allows Modular Change Family to keep track of how a given node is being renamed.
+	 * @param baseAttachId - The ID of the attach in the base changeset.
+	 * @param newDetachId - The ID of the detach in the new changeset.
+	 * @param count - The number of nodes being attached then detached.
 	 */
-	get(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	composeAttachDetach(
+		baseAttachId: ChangeAtomId,
+		newDetachId: ChangeAtomId,
 		count: number,
-		addDependency: boolean,
-	): RangeQueryResult<ChangeAtomId, T>;
+	): void;
+
+	/**
+	 * Must be called by a field kind when composing an attach in the base changeset with nested changes the new changeset.
+	 *
+	 * This is needed because child changes are represented at the location of the node they impact in the input context of a changeset.
+	 * So if the later of the two changes being composed carries nested changes for a node,
+	 * then in the composed changeset, these nested changes must to be represented at the location of that node in the input context of the composed changeset.
+	 *
+	 * @param baseAttachId - The ID of the attach in the base changeset.
+	 * @param newChanges - The ID of the nested changes associated with this node in the new changeset.
+	 */
+	sendNewChangesToBaseSourceLocation(baseAttachId: ChangeAtomId, newChanges: NodeId): void;
 
+	// XXX: It doesn't seem like it should be mandatory to call this if you don't want the rename to be removed (e.g., optional field pin).
 	/**
-	 * Sets the range of keys to `newValue`.
-	 * If `invalidateDependents` is true, all fields which took a dependency on this key will be considered invalidated
-	 * and will be given a chance to address the new data in `amendCompose`, or a second pass of `rebase` or `invert` as appropriate.
+	 * Must be called by a field kind when composing a detach in the base changeset with an attach of the same nodes in the new changeset.
+	 * @param baseDetachId - The ID of the detach in the base changeset.
+	 * @param newAttachId - The ID of the attach in the new changeset.
+	 * @param count - The number of nodes being detached then attached.
+	 * @param convertToPin - Should be set to true if the composed change will include a detach and attach with `newAttachId`.
+	 * Otherwise the composed change should not include either `baseDetachId` or `newAttachId`.
 	 */
-	set(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	composeDetachAttach(
+		baseDetachId: ChangeAtomId,
+		newAttachId: ChangeAtomId,
 		count: number,
-		newValue: T,
-		invalidateDependents: boolean,
+		convertToPin: boolean,
 	): void;
+}
 
+export interface RebaseNodeManager {
+	// XXX: It's not clear whether the returned changes are already rebased or not.
 	/**
-	 * This must be called whenever a new node is moved into this field as part of the current rebase, compose, or invert.
-	 * Calling this for a node which was already in the field is tolerated.
+	 * Must be called by a field kind when rebasing over an attach.
+	 * The returned child changes and detach intentions must be represented in the output changeset.
+	 * @param baseAttachId - The ID of the attach that is being rebased over.
+	 * @param count - The number of nodes attached by the base attach.
+	 * @returns The new nested changes and detach intentions associated with the node in the changeset being rebased.
 	 */
-	onMoveIn(id: NodeId): void;
+	getNewChangesForBaseAttach(
+		baseAttachId: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<RebaseDetachedNodeEntry | undefined>;
 
+	// XXX: It's not clear if this must be called even when newDetachId and nodeChange are undefined.
+	// XXX: It's not clear if it's okay to call this once with a newDetachId then once with a nodeChange.
+	// XXX: It's not clear if nodeChange should be rebased already, or should not be rebased, or if it doesn't matter.
 	/**
-	 * This must be called whenever a new cross field key is moved into this field as part of the current rebase or compose.
-	 * Calling this for a key which was already in the field is tolerated.
+	 * Must be called by a field kind when rebasing over a detach.
+	 * The field kind must provide the nested changes and detach intentions associated with the node in the changeset being rebased.
+	 * @param baseDetachId - The ID of the detach that is being rebased over.
+	 * @param count - The number of nodes detached by the base detach.
+	 * @param newDetachId - The ID associated the detach intention (if any) for these nodes in the rebased changeset.
+	 * @param nodeChange - The nested changes (if any) associated with this node in the rebased changeset.
+	 * @param newDetachCellId - An additional ID to associate with this node.
+	 * This ID will be included in the result of {@link getNewChangesForBaseAttach}.
+	 * This is only used by sequence field for compatibility with earlier client versions.
 	 */
-	moveKey(
-		target: CrossFieldTarget,
-		revision: RevisionTag | undefined,
-		id: ChangesetLocalId,
+	rebaseOverDetach(
+		baseDetachId: ChangeAtomId,
 		count: number,
+		newDetachId: ChangeAtomId | undefined,
+		nodeChange: NodeId | undefined,
+		newDetachCellId?: ChangeAtomId,
 	): void;
+
+	addDetach(id: ChangeAtomId, count: number): void;
+	removeDetach(id: ChangeAtomId, count: number): void;
+
+	/**
+	 * Returns whether nodes which were either previously detached by `id` or the base changeset is now detaching with `id`
+	 * are also reattached by the base changeset.
+	 */
+	doesBaseAttachNodes(id: ChangeAtomId, count: number): RangeQueryResult<boolean>;
+
+	/**
+	 * Returns the root ID the base change renames `id` to, if any.
+	 */
+	getBaseRename(id: ChangeAtomId, count: number): RangeQueryResult<ChangeAtomId | undefined>;
+
+	/**
+	 * Given a detached node ID in the base changeset's output context,
+	 * returns the ID the rebased changeset renames that ID to, if any.
+	 */
+	getNewRenameForBaseRename(
+		baseRenameTo: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<ChangeAtomId | undefined>;
+}
+
+export interface DetachedNodeEntry {
+	nodeChange?: NodeId;
+	detachId?: ChangeAtomId;
+}
+
+export interface RebaseDetachedNodeEntry extends DetachedNodeEntry {
+	// This is only needed for sequence field to implement detach cell IDs.
+	cellRename?: ChangeAtomId;
 }

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

@@ -5,45 +5,31 @@
 
 import type { ICodecFamily, IJsonCodec } from "../../codec/index.js";
 import type {
+	ChangeAtomId,
+	ChangeAtomIdRangeMap,
 	ChangeEncodingContext,
-	DeltaDetachedNodeChanges,
-	DeltaDetachedNodeId,
-	DeltaDetachedNodeRename,
 	DeltaFieldChanges,
 	DeltaFieldMap,
 	EncodedRevisionTag,
 	RevisionMetadataSource,
 	RevisionTag,
 } from "../../core/index.js";
-import type { IdAllocator, Invariant } from "../../util/index.js";
-
-import type { CrossFieldManager } from "./crossFieldQueries.js";
-import type { EncodedNodeChangeset } from "./modularChangeFormat.js";
-import type { CrossFieldKeyRange, NodeId } from "./modularChangeTypes.js";
+import type { IdAllocator, Invariant, RangeQueryResult } from "../../util/index.js";
+import type {
+	ComposeNodeManager,
+	InvertNodeManager,
+	RebaseNodeManager,
+} from "./crossFieldQueries.js";
 
-export type NestedChangesIndices = [
+import type { EncodedNodeChangeset } from "./modularChangeFormatV1.js";
+import type {
+	ChangeAtomIdBTree,
+	CrossFieldKeyRange,
 	NodeId,
-	number | undefined /* inputIndex */,
-	number | undefined /* outputIndex */,
-][];
+	RebaseVersion,
+} from "./modularChangeTypes.js";
 
-/**
- * The return value of calling {@link FieldChangeHandler.intoDelta}.
- */
-export interface FieldChangeDelta {
-	/**
-	 * {@inheritdoc DeltaFieldChanges}
-	 */
-	readonly local?: DeltaFieldChanges;
-	/**
-	 * {@inheritdoc DeltaRoot.global}
-	 */
-	readonly global?: readonly DeltaDetachedNodeChanges[];
-	/**
-	 * {@inheritdoc DeltaRoot.rename}
-	 */
-	readonly rename?: readonly DeltaDetachedNodeRename[];
-}
+export type NestedChangesIndices = [NodeId, number /* inputIndex */][];
 
 /**
  * Functionality provided by a field kind which will be composed with other `FieldChangeHandler`s to
@@ -64,27 +50,7 @@ export interface FieldChangeHandler<
 		>,
 	) => ICodecFamily<TChangeset, FieldChangeEncodingContext>;
 	readonly editor: TEditor;
-	intoDelta(change: TChangeset, deltaFromChild: ToDelta): FieldChangeDelta;
-	/**
-	 * Returns the set of removed roots that should be in memory for the given change to be applied.
-	 * A removed root is relevant if any of the following is true:
-	 * - It is being inserted
-	 * - It is being restored
-	 * - It is being edited
-	 * - The ID it is associated with is being changed
-	 *
-	 * Implementations are allowed to be conservative by returning more removed roots than strictly necessary
-	 * (though they should, for the sake of performance, try to avoid doing so).
-	 *
-	 * Implementations are not allowed to return IDs for non-root trees, even if they are removed.
-	 *
-	 * @param change - The change to be applied.
-	 * @param relevantRemovedRootsFromChild - Delegate for collecting relevant removed roots from child changes.
-	 */
-	readonly relevantRemovedRoots: (
-		change: TChangeset,
-		relevantRemovedRootsFromChild: RelevantRemovedRootsFromChild,
-	) => Iterable<DeltaDetachedNodeId>;
+	intoDelta(change: TChangeset, deltaFromChild: ToDelta): DeltaFieldChanges;
 
 	/**
 	 * Returns whether this change is empty, meaning that it represents no modifications to the field
@@ -129,7 +95,7 @@ export interface FieldChangeRebaser<TChangeset> {
 		change2: TChangeset,
 		composeChild: NodeChangeComposer,
 		genId: IdAllocator,
-		crossFieldManager: CrossFieldManager,
+		nodeManager: ComposeNodeManager,
 		revisionMetadata: RevisionMetadataSource,
 	): TChangeset;
 
@@ -142,10 +108,11 @@ export interface FieldChangeRebaser<TChangeset> {
 		isRollback: boolean,
 		genId: IdAllocator,
 		revision: RevisionTag | undefined,
-		crossFieldManager: CrossFieldManager,
+		nodeManager: InvertNodeManager,
 		revisionMetadata: RevisionMetadataSource,
 	): TChangeset;
 
+	// XXX: It's not clear whether `rebaseChild` must be called in all cases.
 	/**
 	 * Rebase `change` over `over`.
 	 * See `ChangeRebaser` for details.
@@ -155,8 +122,9 @@ export interface FieldChangeRebaser<TChangeset> {
 		over: TChangeset,
 		rebaseChild: NodeChangeRebaser,
 		genId: IdAllocator,
-		crossFieldManager: CrossFieldManager,
+		nodeManager: RebaseNodeManager,
 		revisionMetadata: RebaseRevisionMetadata,
+		rebaseVersion: RebaseVersion,
 	): TChangeset;
 
 	/**
@@ -249,10 +217,7 @@ export type NodeChangeComposer = (
 
 export type NodeChangePruner = (change: NodeId) => NodeId | undefined;
 
-/**
- * A function that returns the set of removed roots that should be in memory for a given node changeset to be applied.
- */
-export type RelevantRemovedRootsFromChild = (child: NodeId) => Iterable<DeltaDetachedNodeId>;
+export type HasDetachedChanges = (detachId: ChangeAtomId, count: number) => boolean;
 
 export interface RebaseRevisionMetadata extends RevisionMetadataSource {
 	readonly getRevisionToRebase: () => RevisionTag | undefined;
@@ -261,6 +226,20 @@ export interface RebaseRevisionMetadata extends RevisionMetadataSource {
 
 export interface FieldChangeEncodingContext {
 	readonly baseContext: ChangeEncodingContext;
+	readonly rootNodeChanges: ChangeAtomIdBTree<NodeId>;
+	readonly rootRenames: ChangeAtomIdRangeMap<ChangeAtomId>;
 	encodeNode(nodeId: NodeId): EncodedNodeChangeset;
+	getInputRootId(
+		outputRootId: ChangeAtomId,
+		count: number,
+	): RangeQueryResult<ChangeAtomId | undefined>;
+
+	isAttachId(id: ChangeAtomId, count: number): RangeQueryResult<boolean>;
+	isDetachId(id: ChangeAtomId, count: number): RangeQueryResult<boolean>;
+
 	decodeNode(encodedNode: EncodedNodeChangeset): NodeId;
+	decodeRootNodeChange(detachId: ChangeAtomId, encodedNode: EncodedNodeChangeset): void;
+	decodeRootRename(oldId: ChangeAtomId, newId: ChangeAtomId, count: number): void;
+	decodeMoveAndDetach(detachId: ChangeAtomId, count: number): void;
+	generateId(): ChangeAtomId;
 }