@fluidframework/tree 2.74.0 → 2.80.0

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

@@ -10,9 +10,9 @@ import {
 	type FieldKey,
 	type FieldKindIdentifier,
 	type RevisionInfo,
-	type RevisionTag,
 } from "../../core/index.js";
-import { brand, RangeMap, type Brand, type TupleBTree } from "../../util/index.js";
+import { brand, RangeMap, type Brand } from "../../util/index.js";
+import type { ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
 import type { TreeChunk } from "../chunked-forest/index.js";
 
 import type { CrossFieldTarget } from "./crossFieldQueries.js";
@@ -60,6 +60,10 @@ export interface ModularChangeset extends HasFieldChanges {
 	 * If this count is greater than 0, it will prevent the changeset from being applied.
 	 */
 	readonly constraintViolationCount?: number;
+	/** Constraint that the document must be in the same state before this change is applied as it was before this change was authored */
+	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.
@@ -70,8 +74,6 @@ export interface ModularChangeset extends HasFieldChanges {
 	readonly refreshers?: ChangeAtomIdBTree<TreeChunk>;
 }
 
-export type ChangeAtomIdBTree<V> = TupleBTree<[RevisionTag | undefined, ChangesetLocalId], V>;
-
 export type CrossFieldKeyTable = RangeMap<CrossFieldKey, FieldId>;
 
 export function newCrossFieldKeyTable(): CrossFieldKeyTable {
@@ -112,6 +114,13 @@ export interface NodeExistsConstraint {
 	violated: boolean;
 }
 
+/**
+ * A constraint that is violated whenever the state of the document is different from when the change was authored.
+ */
+export interface NoChangeConstraint {
+	violated: boolean;
+}
+
 /**
  * Changeset for a subtree rooted at a specific node.
  */

package/src/feature-libraries/node-identifier/mockNodeIdentifierManager.ts

@@ -46,7 +46,7 @@ export class MockNodeIdentifierManager implements NodeIdentifierManager {
 		if (!isStableNodeIdentifier(key) || !key.startsWith("a110ca7e-add1-4000-8000-")) {
 			return undefined;
 		}
-		const localNodeIdentifier = Number.parseInt(key.substring(24), 16);
+		const localNodeIdentifier = Number.parseInt(key.slice(24), 16);
 		return localNodeIdentifier < this.count
 			? brand(localNodeIdentifier as SessionSpaceCompressedId)
 			: undefined;

package/src/feature-libraries/object-forest/objectForest.ts

@@ -104,12 +104,12 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 		roots?: MapTree,
 	) {
 		this.#roots =
-			roots !== undefined
-				? deepCopyMapTree(roots)
-				: {
+			roots === undefined
+				? {
 						type: aboveRootPlaceholder,
 						fields: new Map(),
-					};
+					}
+				: deepCopyMapTree(roots);
 
 		if (additionalAsserts) {
 			this.checkSchema();

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

@@ -12,10 +12,10 @@ import {
 	type DeltaDetachedNodeChanges,
 	type DeltaDetachedNodeId,
 	type DeltaMark,
+	type RevisionReplacer,
 	type RevisionTag,
 	areEqualChangeAtomIds,
 	makeChangeAtomId,
-	replaceAtomRevisions,
 	taggedAtomId,
 } from "../../core/index.js";
 import {
@@ -178,10 +178,10 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 		const childChanges2ByOriginalId = new RegisterMap<NodeId>();
 		for (const [id, change] of change2.childChanges) {
 			if (id === "self") {
-				if (change1FieldSrc !== undefined) {
-					childChanges2ByOriginalId.set(change1FieldSrc, change);
-				} else {
+				if (change1FieldSrc === undefined) {
 					childChanges2ByOriginalId.set("self", change);
+				} else {
+					childChanges2ByOriginalId.set(change1FieldSrc, change);
 				}
 			} else {
 				if (change1FieldDst !== undefined && areEqualChangeAtomIds(change1FieldDst, id)) {
@@ -269,7 +269,7 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 		genId: IdAllocator<ChangesetLocalId>,
 		revision: RevisionTag | undefined,
 	): OptionalChangeset => {
-		const { moves, childChanges } = change;
+		const { moves, childChanges, valueReplace } = change;
 
 		const invertIdMap = new RegisterMap<RegisterId>();
 		const invertedMoves: Move[] = [];
@@ -277,13 +277,13 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 			invertIdMap.set(src, dst);
 			invertedMoves.push([dst, src]);
 		}
-		if (change.valueReplace !== undefined) {
-			const effectfulDst = getEffectfulDst(change.valueReplace);
+		if (valueReplace !== undefined) {
+			const effectfulDst = getEffectfulDst(valueReplace);
 			if (effectfulDst !== undefined) {
-				invertIdMap.set("self", change.valueReplace.dst);
+				invertIdMap.set("self", valueReplace.dst);
 			}
-			if (change.valueReplace.src !== undefined) {
-				invertIdMap.set(change.valueReplace.src, "self");
+			if (valueReplace.src !== undefined) {
+				invertIdMap.set(valueReplace.src, "self");
 			}
 		}
 
@@ -294,10 +294,10 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 			}),
 		};
 
-		if (change.valueReplace !== undefined) {
-			if (isReplaceEffectful(change.valueReplace)) {
+		if (valueReplace !== undefined) {
+			if (isReplaceEffectful(valueReplace)) {
 				const replace: Mutable<Replace> =
-					change.valueReplace.src === undefined
+					valueReplace.src === undefined
 						? {
 								isEmpty: true,
 								dst: makeChangeAtomId(genId.allocate(), revision),
@@ -305,14 +305,14 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 						: {
 								isEmpty: false,
 								dst: isRollback
-									? change.valueReplace.src
+									? valueReplace.src
 									: makeChangeAtomId(genId.allocate(), revision),
 							};
-				if (change.valueReplace.isEmpty === false) {
-					replace.src = change.valueReplace.dst;
+				if (valueReplace.isEmpty === false) {
+					replace.src = valueReplace.dst;
 				}
 				inverted.valueReplace = replace;
-			} else if (!isRollback && change.valueReplace.src === "self") {
+			} else if (!isRollback && valueReplace.src === "self") {
 				inverted.valueReplace = {
 					isEmpty: false,
 					src: "self",
@@ -433,29 +433,21 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 
 	replaceRevisions: (
 		change: OptionalChangeset,
-		oldRevisions: Set<RevisionTag | undefined>,
-		newRevision: RevisionTag | undefined,
+		replacer: RevisionReplacer,
 	): OptionalChangeset => {
-		const valueReplace = replaceReplaceRevisions(
-			change.valueReplace,
-			oldRevisions,
-			newRevision,
-		);
+		const valueReplace = replaceReplaceRevisions(change.valueReplace, replacer);
 
 		const childChanges: ChildChange[] = [];
 		for (const [id, childChange] of change.childChanges) {
 			childChanges.push([
-				replaceRegisterRevisions(id, oldRevisions, newRevision),
-				replaceAtomRevisions(childChange, oldRevisions, newRevision),
+				replaceRegisterRevisions(id, replacer),
+				replacer.getUpdatedAtomId(childChange),
 			]);
 		}
 
 		const moves: Move[] = [];
 		for (const [src, dst] of change.moves) {
-			moves.push([
-				replaceAtomRevisions(src, oldRevisions, newRevision),
-				replaceAtomRevisions(dst, oldRevisions, newRevision),
-			]);
+			moves.push([replacer.getUpdatedAtomId(src), replacer.getUpdatedAtomId(dst)]);
 		}
 
 		const updated: Mutable<OptionalChangeset> = { childChanges, moves };
@@ -473,8 +465,7 @@ export const optionalChangeRebaser: FieldChangeRebaser<OptionalChangeset> = {
 
 function replaceReplaceRevisions(
 	replace: Replace | undefined,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
 ): Replace | undefined {
 	if (replace === undefined) {
 		return undefined;
@@ -482,11 +473,11 @@ function replaceReplaceRevisions(
 
 	const updated: Mutable<Replace> = {
 		...replace,
-		dst: replaceAtomRevisions(replace.dst, oldRevisions, newRevision),
+		dst: replacer.getUpdatedAtomId(replace.dst),
 	};
 
 	if (replace.src !== undefined) {
-		updated.src = replaceRegisterRevisions(replace.src, oldRevisions, newRevision);
+		updated.src = replaceRegisterRevisions(replace.src, replacer);
 	}
 
 	return updated;
@@ -494,12 +485,9 @@ function replaceReplaceRevisions(
 
 function replaceRegisterRevisions(
 	register: RegisterId,
-	oldRevisions: Set<RevisionTag | undefined>,
-	newRevision: RevisionTag | undefined,
+	replacer: RevisionReplacer,
 ): RegisterId {
-	return register === "self"
-		? register
-		: replaceAtomRevisions(register, oldRevisions, newRevision);
+	return register === "self" ? register : replacer.getUpdatedAtomId(register);
 }
 
 function getComposedReplaceDst(
@@ -696,15 +684,15 @@ export function optionalFieldIntoDelta(
 		const globals: DeltaDetachedNodeChanges[] = [];
 		for (const [id, childChange] of change.childChanges) {
 			const childDelta = deltaFromChild(childChange);
-			if (id !== "self") {
+			if (id === "self") {
+				mark.fields = childDelta;
+				markIsANoop = false;
+			} else {
 				const fields = childDelta;
 				globals.push({
 					id: { major: id.revision, minor: id.localId },
 					fields,
 				});
-			} else {
-				mark.fields = childDelta;
-				markIsANoop = false;
 			}
 		}
 
@@ -760,9 +748,9 @@ function getNestedChanges(change: OptionalChangeset): NestedChangesIndices {
 					? undefined
 					: 0
 				: // If the node starts out as removed, then it remains removed in the output context iff it is not the node that is moved into the field
-					!areEqualRegisterIdsOpt(register, nodeMovedIntoField)
-					? undefined
-					: 0;
+					areEqualRegisterIdsOpt(register, nodeMovedIntoField)
+					? 0
+					: undefined;
 		return [nodeId, inputIndex, outputIndex];
 	});
 }

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

@@ -15,7 +15,7 @@ import {
 	makeVersionDispatchingCodec,
 	withSchemaValidation,
 } from "../../codec/index.js";
-import { getCodecTreeForSchemaFormat, makeSchemaCodec } from "../schema-index/index.js";
+import { makeSchemaCodec, schemaCodecBuilder } from "../schema-index/index.js";
 
 import { EncodedSchemaChange } from "./schemaChangeFormat.js";
 import type { SchemaChange } from "./schemaChangeTypes.js";
@@ -31,7 +31,22 @@ export function makeSchemaChangeCodecs(
 ): ICodecFamily<SchemaChange> {
 	return makeCodecFamily([
 		[SchemaFormatVersion.v1, makeSchemaChangeCodecV1(options, SchemaFormatVersion.v1)],
-		[SchemaFormatVersion.v2, makeSchemaChangeCodecV1(options, SchemaFormatVersion.v2)],
+		// This code  (makeSchemaChangeCodecs) is constructing a SchemaFormatVersion.v2 codec, regardless of the requested write version.
+		// It then trusts the user of the produced makeCodecFamily to only select if when it is valid to do so.
+		// This trust is manifests in having to use `allowPossiblyIncompatibleWriteVersionOverrides`
+		// here as it needs to build the v2 codec regardless of if its valid to use.
+		// TODO: There should not be two separate places selecting the write version for this codec. Such cases should instead adopt one of the following patterns:
+		// 1. The outer coded should let the inner one do its own version selection instead of forcing it.
+		// 2. The outer codec should fully handle version selection and embed the inner content directly (referencing its format not codec) and not involve the codec at all.
+		// TODO: fix this up when migrating SchemaChangeCodec to use ClientVersionDispatchingCodecBuilder.
+		// This should probably use pattern 1 above, which will result in this codec having two identical versions.
+		[
+			SchemaFormatVersion.v2,
+			makeSchemaChangeCodecV1(
+				{ ...options, allowPossiblyIncompatibleWriteVersionOverrides: true },
+				SchemaFormatVersion.v2,
+			),
+		],
 	]);
 }
 
@@ -42,7 +57,7 @@ export function getCodecTreeForSchemaChangeFormat(
 	return {
 		name: "SchemaChange",
 		version,
-		children: [getCodecTreeForSchemaFormat(clientVersion)],
+		children: [schemaCodecBuilder.getCodecTree(clientVersion)],
 	};
 }
 

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

@@ -3,22 +3,14 @@
  * Licensed under the MIT License.
  */
 
-import { fail, unreachableCase } from "@fluidframework/core-utils/internal";
-import {
-	getConfigForMinVersionForCollab,
-	lowestMinVersionForCollab,
-} from "@fluidframework/runtime-utils/internal";
+import { fail } from "@fluidframework/core-utils/internal";
+import { lowestMinVersionForCollab } from "@fluidframework/runtime-utils/internal";
 
 import {
-	type CodecTree,
+	ClientVersionDispatchingCodecBuilder,
 	type CodecWriteOptions,
 	FluidClientVersion,
-	type ICodecFamily,
-	type ICodecOptions,
 	type IJsonCodec,
-	makeCodecFamily,
-	makeVersionDispatchingCodec,
-	makeVersionedValidatedCodec,
 } from "../../codec/index.js";
 import {
 	SchemaFormatVersion,
@@ -30,82 +22,32 @@ import {
 	encodeFieldSchemaV2,
 	storedSchemaDecodeDispatcher,
 } from "../../core/index.js";
-import { brand, unbrand, type JsonCompatible } from "../../util/index.js";
+import { brand } from "../../util/index.js";
 
 import { Format as FormatV1 } from "./formatV1.js";
 import { Format as FormatV2 } from "./formatV2.js";
-import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
-
-/**
- * Convert a MinimumVersionForCollab to a SchemaFormatVersion.
- * @param clientVersion - The MinimumVersionForCollab to convert.
- * @returns The SchemaFormatVersion that corresponds to the provided MinimumVersionForCollab.
- */
-export function clientVersionToSchemaVersion(
-	clientVersion: MinimumVersionForCollab,
-): SchemaFormatVersion {
-	return getConfigForMinVersionForCollab(clientVersion, {
-		[lowestMinVersionForCollab]: SchemaFormatVersion.v1,
-		[FluidClientVersion.v2_43]: SchemaFormatVersion.v2,
-	});
-}
-
-export function getCodecTreeForSchemaFormat(
-	clientVersion: MinimumVersionForCollab,
-): CodecTree {
-	return { name: "Schema", version: clientVersionToSchemaVersion(clientVersion) };
-}
 
 /**
  * Create a schema codec.
  * @param options - Specifies common codec options, including `minVersionForCollab` and which `validator` to use.
  * @param writeVersionOverride - The schema version to write. If not provided, the version will be derived from `minVersionForCollab`.
+ * TODO: Currently this parameter is provided when it probably should not be. Users of it should probably allow the automatic selection to occur and this parameter can be removed.
+ * Any case where an override is actually required can use `options` to do so.
  * @returns The composed codec.
  *
  * @privateRemarks We should consider using the Shared Tree format version instead as it may be more valuable for application authors than the schema version.
+ *
+ * TODO: replace use of this with schemaCodecBuilder.build(...).
  */
 export function makeSchemaCodec(
 	options: CodecWriteOptions,
 	writeVersionOverride?: SchemaFormatVersion,
 ): IJsonCodec<TreeStoredSchema> {
-	const family = makeSchemaCodecs(options);
-	return makeVersionDispatchingCodec(family, {
-		...options,
-		writeVersion:
-			writeVersionOverride ?? clientVersionToSchemaVersion(options.minVersionForCollab),
-	});
-}
-
-/**
- * Create a family of schema codecs.
- * @param options - Specifies common codec options, including which `validator` to use.
- * @returns The composed codec family.
- */
-export function makeSchemaCodecs(options: ICodecOptions): ICodecFamily<TreeStoredSchema> {
-	return makeCodecFamily([
-		[SchemaFormatVersion.v1, makeSchemaCodecV1(options)],
-		[SchemaFormatVersion.v2, makeSchemaCodecV2(options)],
-	]);
-}
-
-/**
- * Encode an in-memory TreeStoredSchema into the specified format version.
- * @param repo - The in-memory schema.
- * @param version - The schema write version.
- * @returns The encoded schema.
- */
-export function encodeRepo(
-	repo: TreeStoredSchema,
-	version: SchemaFormatVersion,
-): JsonCompatible {
-	switch (version) {
-		case unbrand(SchemaFormatVersion.v1):
-			return encodeRepoV1(repo) as JsonCompatible;
-		case unbrand(SchemaFormatVersion.v2):
-			return encodeRepoV2(repo) as JsonCompatible;
-		default:
-			unreachableCase(version);
+	const overrides = new Map(options.writeVersionOverrides ?? []);
+	if (writeVersionOverride !== undefined) {
+		overrides.set(schemaCodecBuilder.name, writeVersionOverride);
 	}
+	return schemaCodecBuilder.build({ ...options, writeVersionOverrides: overrides });
 }
 
 function encodeRepoV1(repo: TreeStoredSchema): FormatV1 {
@@ -182,24 +124,22 @@ function decodeV2(f: FormatV2): TreeStoredSchema {
 
 /**
  * Creates a codec which performs synchronous monolithic encoding of schema content.
- * @param options - Specifies common codec options, including which `validator` to use.
- * @returns The codec.
  */
-function makeSchemaCodecV1(options: ICodecOptions): IJsonCodec<TreeStoredSchema, FormatV1> {
-	return makeVersionedValidatedCodec(options, new Set([SchemaFormatVersion.v1]), FormatV1, {
-		encode: (data: TreeStoredSchema) => encodeRepoV1(data),
-		decode: (data: FormatV1) => decodeV1(data),
-	});
-}
-
-/**
- * Creates a codec which performs synchronous monolithic encoding of schema content.
- * @param options - Specifies common codec options, including which `validator` to use.
- * @returns The codec.
- */
-function makeSchemaCodecV2(options: ICodecOptions): IJsonCodec<TreeStoredSchema, FormatV2> {
-	return makeVersionedValidatedCodec(options, new Set([SchemaFormatVersion.v2]), FormatV2, {
-		encode: (data: TreeStoredSchema) => encodeRepoV2(data),
-		decode: (data: FormatV2) => decodeV2(data),
-	});
-}
+export const schemaCodecBuilder = ClientVersionDispatchingCodecBuilder.build("Schema", {
+	[lowestMinVersionForCollab]: {
+		formatVersion: SchemaFormatVersion.v1,
+		codec: {
+			encode: (data: TreeStoredSchema) => encodeRepoV1(data),
+			decode: (data: FormatV1) => decodeV1(data),
+			schema: FormatV1,
+		},
+	},
+	[FluidClientVersion.v2_43]: {
+		formatVersion: SchemaFormatVersion.v2,
+		codec: {
+			encode: (data: TreeStoredSchema) => encodeRepoV2(data),
+			decode: (data: FormatV2) => decodeV2(data),
+			schema: FormatV2,
+		},
+	},
+});

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

@@ -3,12 +3,10 @@
  * Licensed under the MIT License.
  */
 
-export { SchemaSummarizer, encodeTreeSchema } from "./schemaSummarizer.js";
+export { SchemaSummarizer } from "./schemaSummarizer.js";
 export {
 	makeSchemaCodec,
-	makeSchemaCodecs,
-	clientVersionToSchemaVersion,
-	getCodecTreeForSchemaFormat,
+	schemaCodecBuilder,
 } from "./codec.js";
 export { Format as FormatV1 } from "./formatV1.js";
 export { Format as FormatV2 } from "./formatV2.js";

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

@@ -17,7 +17,6 @@ import type { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal"
 import type { IJsonCodec } from "../../codec/index.js";
 import {
 	type MutableTreeStoredSchema,
-	type SchemaFormatVersion,
 	type TreeStoredSchema,
 	schemaDataIsEmpty,
 } from "../../core/index.js";
@@ -27,11 +26,8 @@ import {
 	type SummaryElementParser,
 	type SummaryElementStringifier,
 } from "../../shared-tree-core/index.js";
-import type { JsonCompatible } from "../../util/index.js";
 import type { CollabWindow } from "../incrementalSummarizationUtils.js";
 
-import { encodeRepo } from "./codec.js";
-
 export const schemaStringKey = "SchemaString";
 
 /**
@@ -141,16 +137,3 @@ export class SchemaSummarizer
 		this.schemaIndexLastChangedSeq = 0;
 	}
 }
-
-/**
- * Dumps schema into a deterministic JSON compatible semi-human readable format.
- *
- * @remarks
- * This can be used to help inspect schema for debugging, and to save a snapshot of schema to help detect and review changes to an applications schema.
- */
-export function encodeTreeSchema(
-	schema: TreeStoredSchema,
-	writeVersion: SchemaFormatVersion,
-): JsonCompatible {
-	return encodeRepo(schema, writeVersion);
-}

package/src/feature-libraries/schemaChecker.ts

@@ -93,7 +93,7 @@ export function isNodeInSchema<T extends NotUndefined>(
 			// Since this is testing compatibility with a stored schema (not view schema), "allowUnknownOptionalFields" does not exist at this layer.
 			// Code using this with a stored schema derived from a view schema rather than the document can be problematic because it may be missing unknown fields that the actual document has.
 			// Other schema evolution features like "staged" allowed types will likely cause similar issues elsewhere in this checker.
-			if (uncheckedFieldsFromNode.size !== 0) {
+			if (uncheckedFieldsFromNode.size > 0) {
 				return onError(SchemaValidationError.ObjectNode_FieldNotInSchema);
 			}
 		} else if (schema instanceof MapNodeStoredSchema) {
@@ -170,7 +170,7 @@ export function compliesWithMultiplicity(
 	multiplicity: Multiplicity,
 ): SchemaValidationError | undefined {
 	switch (multiplicity) {
-		case Multiplicity.Single:
+		case Multiplicity.Single: {
 			if (numberOfItems < 1) {
 				return SchemaValidationError.Field_MissingRequiredChild;
 			} else if (numberOfItems > 1) {
@@ -178,17 +178,22 @@ export function compliesWithMultiplicity(
 			} else {
 				return undefined;
 			}
-		case Multiplicity.Optional:
+		}
+		case Multiplicity.Optional: {
 			return numberOfItems > 1
 				? SchemaValidationError.Field_MultipleChildrenNotAllowed
 				: undefined;
-		case Multiplicity.Sequence:
+		}
+		case Multiplicity.Sequence: {
 			return undefined;
-		case Multiplicity.Forbidden:
+		}
+		case Multiplicity.Forbidden: {
 			return numberOfItems === 0
 				? undefined
 				: SchemaValidationError.Field_ChildInForbiddenField;
-		default:
+		}
+		default: {
 			unreachableCase(multiplicity);
+		}
 	}
 }

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

@@ -502,7 +502,7 @@ function composeMark<TMark extends Mark>(
 	moveEffects: MoveEffectTable,
 	composeChild: (node: NodeId) => NodeId | undefined,
 ): TMark {
-	const nodeChanges = mark.changes !== undefined ? composeChild(mark.changes) : undefined;
+	const nodeChanges = mark.changes === undefined ? undefined : composeChild(mark.changes);
 	const updatedMark = withUpdatedEndpoint(mark, mark.count, moveEffects);
 	return withNodeChange(updatedMark, nodeChanges);
 }
@@ -564,14 +564,18 @@ export class ComposeQueue {
 				this.revisionMetadata,
 			);
 			switch (comparison) {
-				case CellOrder.SameCell:
+				case CellOrder.SameCell: {
 					return this.dequeueBoth();
-				case CellOrder.OldThenNew:
+				}
+				case CellOrder.OldThenNew: {
 					return this.dequeueBase();
-				case CellOrder.NewThenOld:
+				}
+				case CellOrder.NewThenOld: {
 					return this.dequeueNew();
-				default:
+				}
+				default: {
 					unreachableCase(comparison);
+				}
 			}
 		} else if (areOutputCellsEmpty(baseMark)) {
 			return this.dequeueBase();
@@ -680,7 +684,7 @@ function setModifyAfter(
 	const count = 1;
 	const effect = getMoveEffect(moveEffects, target, revision, id, count, false);
 	const newEffect: MoveEffect =
-		effect.value !== undefined ? { ...effect.value, modifyAfter } : { modifyAfter };
+		effect.value === undefined ? { modifyAfter } : { ...effect.value, modifyAfter };
 	setMoveEffect(moveEffects, target, revision, id, count, newEffect);
 }
 
@@ -692,7 +696,7 @@ function setEndpoint(
 	endpoint: ChangeAtomId,
 ): void {
 	const effect = getMoveEffect(moveEffects, target, id.revision, id.localId, count, false);
-	const newEffect = effect.value !== undefined ? { ...effect.value, endpoint } : { endpoint };
+	const newEffect = effect.value === undefined ? { endpoint } : { ...effect.value, endpoint };
 	setMoveEffect(moveEffects, target, id.revision, id.localId, effect.length, newEffect);
 
 	const remainingCount = count - effect.length;
@@ -716,9 +720,9 @@ function setTruncatedEndpoint(
 ): void {
 	const effect = getMoveEffect(moveEffects, target, id.revision, id.localId, count);
 	const newEffect =
-		effect.value !== undefined
-			? { ...effect.value, truncatedEndpoint }
-			: { truncatedEndpoint };
+		effect.value === undefined
+			? { truncatedEndpoint }
+			: { ...effect.value, truncatedEndpoint };
 
 	setMoveEffect(moveEffects, target, id.revision, id.localId, effect.length, newEffect);
 
@@ -743,9 +747,9 @@ function setTruncatedEndpointForInner(
 ): void {
 	const effect = getMoveEffect(moveEffects, target, id.revision, id.localId, count);
 	const newEffect =
-		effect.value !== undefined
-			? { ...effect.value, truncatedEndpointForInner }
-			: { truncatedEndpointForInner };
+		effect.value === undefined
+			? { truncatedEndpointForInner }
+			: { ...effect.value, truncatedEndpointForInner };
 	setMoveEffect(moveEffects, target, id.revision, id.localId, effect.length, newEffect);
 
 	const remainingCount = count - effect.length;

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

@@ -303,8 +303,9 @@ function invertMark(
 
 			return inverses;
 		}
-		default:
+		default: {
 			unreachableCase(type);
+		}
 	}
 }
 
@@ -319,9 +320,9 @@ function applyMovedChanges(
 	if (entry.length < mark.count) {
 		const [mark1, mark2] = splitMark(mark, entry.length);
 		const mark1WithChanges =
-			entry.value !== undefined
-				? withNodeChange<CellMark<MoveOut>, MoveOut>(mark1, entry.value)
-				: mark1;
+			entry.value === undefined
+				? mark1
+				: withNodeChange<CellMark<MoveOut>, MoveOut>(mark1, entry.value);
 
 		return [mark1WithChanges, ...applyMovedChanges(mark2, revision, manager)];
 	}