@fluidframework/tree 2.22.1 → 2.23.0

package/src/core/tree/anchorSet.ts

@@ -18,6 +18,8 @@ import {
 	brand,
 	brandedSlot,
 	fail,
+	getOrAddEmptyToMap,
+	getOrCreate,
 } from "../../util/index.js";
 import type { FieldKey } from "../schema-stored/index.js";
 
@@ -474,7 +476,7 @@ export class AnchorSet implements AnchorLocator {
 			}
 		}
 
-		return path ?? fail("internalize path must be a path");
+		return path ?? fail(0xaea /* internalize path must be a path */);
 	}
 
 	/**
@@ -711,15 +713,7 @@ export class AnchorSet implements AnchorLocator {
 			/**
 			 * Events collected during the visit which get sent as a batch during "free".
 			 */
-			bufferedEvents: [] as {
-				node: PathNode;
-				event: keyof AnchorEvents;
-				/**
-				 * The key for the impacted field, if the event is associated with a key.
-				 * Some events, such as afterDestroy, do not involve a key, and thus leave this undefined.
-				 */
-				changedField?: FieldKey;
-			}[],
+			bufferedEvents: [] as BufferedEvent[],
 
 			// 'currentDepth' and 'depthThresholdForSubtreeChanged' serve to keep track of when do we need to emit
 			// subtreeChangedAfterBatch events.
@@ -751,25 +745,31 @@ export class AnchorSet implements AnchorLocator {
 					node.removeRef();
 				}
 				this.anchorSet.activeVisitor = undefined;
-				const alreadyEmitted = new Map<PathNode, string[]>();
-				for (const { node, event } of this.bufferedEvents) {
-					if (!alreadyEmitted.has(node)) {
-						alreadyEmitted.set(node, []);
+
+				// Aggregate changedFields by node.
+				const eventsByNode: Map<PathNode, Set<FieldKey>> = new Map();
+				for (const { node, event, changedField } of this.bufferedEvents) {
+					if (event === "childrenChangedAfterBatch") {
+						const keys = getOrCreate(eventsByNode, node, () => new Set());
+						keys.add(
+							changedField ??
+								fail(0xb57 /* childrenChangedAfterBatch events should have a changedField */),
+						);
 					}
-					const emittedEvents = alreadyEmitted.get(node);
-					if (emittedEvents?.includes(event) ?? false) {
+				}
+
+				const alreadyEmitted = new Map<PathNode, (keyof AnchorEvents)[]>();
+				for (const { node, event } of this.bufferedEvents) {
+					const emittedEvents = getOrAddEmptyToMap(alreadyEmitted, node);
+					if (emittedEvents.includes(event)) {
 						continue;
 					}
-					emittedEvents?.push(event);
+					emittedEvents.push(event);
 					if (event === "childrenChangedAfterBatch") {
-						const fieldKeys: FieldKey[] = this.bufferedEvents
-							.filter((e) => e.node === node && e.event === event)
-							.map(
-								(e) =>
-									e.changedField ??
-									fail("childrenChangedAfterBatch events should have a changedField"),
-							);
-						node.events.emit(event, { changedFields: new Set(fieldKeys) });
+						const changedFields =
+							eventsByNode.get(node) ??
+							fail(0xaeb /* childrenChangedAfterBatch events should have changedFields */);
+						node.events.emit(event, { changedFields });
 					} else {
 						node.events.emit(event);
 					}
@@ -1031,7 +1031,8 @@ class PathNode extends ReferenceCountedBase implements UpPath<PathNode>, AnchorN
 	public getOrCreateChildRef(key: FieldKey, index: number): [Anchor, AnchorNode] {
 		const anchor = this.anchorSet.track(this.child(key, index));
 		const node =
-			this.anchorSet.locate(anchor) ?? fail("cannot reference child that does not exist");
+			this.anchorSet.locate(anchor) ??
+			fail(0xaec /* cannot reference child that does not exist */);
 		return [anchor, node];
 	}
 
@@ -1194,3 +1195,13 @@ function binaryFind(sorted: readonly PathNode[], index: number): PathNode | unde
 	}
 	return undefined; // If we reach here, target is not in array (or array was not sorted)
 }
+
+interface BufferedEvent {
+	node: PathNode;
+	event: keyof AnchorEvents;
+	/**
+	 * The key for the impacted field, if the event is associated with a key.
+	 * Some events, such as afterDestroy, do not involve a key, and thus leave this undefined.
+	 */
+	changedField?: FieldKey;
+}

package/src/core/tree/treeTextFormat.ts

@@ -90,7 +90,7 @@ export function getGenericTreeField<T>(
 
 	// Do not just read field and check for undefined: see warning on FieldMapObject.
 	if (Object.prototype.hasOwnProperty.call(children, key)) {
-		return children[key] ?? fail("This wont be undefined due to the check above");
+		return children[key] ?? fail(0xaed /* This wont be undefined due to the check above */);
 	}
 	// Handle missing field:
 	if (createIfMissing === false) {

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

@@ -234,7 +234,7 @@ export class BasicChunkCursor extends SynchronousCursor implements ChunkedCursor
 		if (this.nestedCursor !== undefined) {
 			return (
 				this.nestedCursor.getPath(this.nestedPathPrefix(prefix)) ??
-				fail("nested cursors should not be root")
+				fail(0xaee /* nested cursors should not be root */)
 			);
 		}
 		assert(this.mode === CursorLocationType.Nodes, 0x524 /* must be in nodes mode */);
@@ -247,7 +247,7 @@ export class BasicChunkCursor extends SynchronousCursor implements ChunkedCursor
 		// This uses index offset for actual node, when it should use offset for start of chunk.
 		// To compensate, subtract this.indexWithinChunk below.
 		const rootPath: UpPath =
-			this.getOffsetPath(0, prefix) ?? fail("nested cursors should not be root");
+			this.getOffsetPath(0, prefix) ?? fail(0xaef /* nested cursors should not be root */);
 		return {
 			indexOffset: rootPath.parentIndex - this.indexWithinChunk,
 			rootFieldOverride: rootPath.parentField,
@@ -483,8 +483,9 @@ export class BasicChunkCursor extends SynchronousCursor implements ChunkedCursor
 			this.mode === CursorLocationType.Fields,
 			0x52d /* can only navigate up from field when in field */,
 		);
-		this.siblings = this.siblingStack.pop() ?? fail("Unexpected siblingStack.length");
-		this.index = this.indexStack.pop() ?? fail("Unexpected indexStack.length");
+		this.siblings =
+			this.siblingStack.pop() ?? fail(0xaf0 /* Unexpected siblingStack.length */);
+		this.index = this.indexStack.pop() ?? fail(0xaf1 /* Unexpected indexStack.length */);
 	}
 
 	public exitNode(): void {
@@ -498,12 +499,14 @@ export class BasicChunkCursor extends SynchronousCursor implements ChunkedCursor
 			this.mode === CursorLocationType.Nodes,
 			0x52e /* can only navigate up from node when in node */,
 		);
-		this.siblings = this.siblingStack.pop() ?? fail("Unexpected siblingStack.length");
-		this.index = this.indexStack.pop() ?? fail("Unexpected indexStack.length");
+		this.siblings =
+			this.siblingStack.pop() ?? fail(0xaf2 /* Unexpected siblingStack.length */);
+		this.index = this.indexStack.pop() ?? fail(0xaf3 /* Unexpected indexStack.length */);
 		this.indexOfChunk =
-			this.indexOfChunkStack.pop() ?? fail("Unexpected indexOfChunkStack.length");
+			this.indexOfChunkStack.pop() ?? fail(0xaf4 /* Unexpected indexOfChunkStack.length */);
 		this.indexWithinChunk =
-			this.indexWithinChunkStack.pop() ?? fail("Unexpected indexWithinChunkStack.length");
+			this.indexWithinChunkStack.pop() ??
+			fail(0xaf5 /* Unexpected indexWithinChunkStack.length */);
 	}
 
 	private getNode(): BasicChunk {

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

@@ -247,7 +247,7 @@ export function tryShapeFromSchema(
 	shapes: Map<TreeNodeSchemaIdentifier, ShapeInfo>,
 ): ShapeInfo {
 	return getOrCreate(shapes, type, () => {
-		const treeSchema = schema.nodeSchema.get(type) ?? fail("missing schema");
+		const treeSchema = schema.nodeSchema.get(type) ?? fail(0xaf9 /* missing schema */);
 		if (treeSchema instanceof LeafNodeStoredSchema) {
 			// Allow all string values (but only string values) to be compressed by the id compressor.
 			// This allows compressing all compressible identifiers without requiring additional context to know which values could be identifiers.
@@ -284,7 +284,7 @@ export function tryShapeFromFieldSchema(
 	key: FieldKey,
 	shapes: Map<TreeNodeSchemaIdentifier, ShapeInfo>,
 ): FieldShape | undefined {
-	const kind = policy.fieldKinds.get(type.kind) ?? fail("missing FieldKind");
+	const kind = policy.fieldKinds.get(type.kind) ?? fail(0xafa /* missing FieldKind */);
 	if (kind.multiplicity !== Multiplicity.Single) {
 		return undefined;
 	}

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

@@ -227,7 +227,7 @@ export class ChunkedForest implements IEditableForest {
 				assert(this.mutableChunk === undefined, 0x535 /* should be in field */);
 				const parent = this.getParent();
 				const chunks =
-					parent.mutableChunk.fields.get(parent.key) ?? fail("missing edited field");
+					parent.mutableChunk.fields.get(parent.key) ?? fail(0xaf6 /* missing edited field */);
 				let indexWithinChunk = index;
 				let indexOfChunk = 0;
 				let chunk = chunks[indexOfChunk] ?? oob();
@@ -236,7 +236,7 @@ export class ChunkedForest implements IEditableForest {
 					indexWithinChunk -= chunk.topLevelLength;
 					indexOfChunk++;
 					if (indexOfChunk === chunks.length) {
-						fail("missing edited node");
+						fail(0xaf7 /* missing edited node */);
 					}
 				}
 				let found = chunks[indexOfChunk] ?? oob();
@@ -277,7 +277,7 @@ export class ChunkedForest implements IEditableForest {
 				this.mutableChunk = undefined;
 			},
 			exitField(key: FieldKey): void {
-				const top = this.mutableChunkStack.pop() ?? fail("should not be at root");
+				const top = this.mutableChunkStack.pop() ?? fail(0xaf8 /* should not be at root */);
 				assert(this.mutableChunk === undefined, 0x539 /* should be in field */);
 				this.mutableChunk = top.mutableChunk;
 			},

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

@@ -85,7 +85,7 @@ export function handleShapesAndIdentifiers<TEncodedShape>(
 			) {
 				// because "serializable" is allowed in buffer and it has type `any`, its very easy to mess up including of shapes in the buffer.
 				// This catches the easiest way to get it wrong.
-				fail("encoder interface instead of shape written to stream");
+				fail(0xb4b /* encoder interface instead of shape written to stream */);
 			}
 		}
 	}
@@ -108,7 +108,7 @@ export function handleShapesAndIdentifiers<TEncodedShape>(
 			if (item instanceof IdentifierToken) {
 				array[index] = identifierTable.valueToIndex.get(item.identifier) ?? item.identifier;
 			} else if (item instanceof Shape) {
-				array[index] = shapeTable.valueToIndex.get(item) ?? fail("missing shape");
+				array[index] = shapeTable.valueToIndex.get(item) ?? fail(0xb4c /* missing shape */);
 			}
 		}
 	}

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

@@ -273,7 +273,7 @@ export class InlineArrayShape
 			shapes: EncoderCache,
 			outputBuffer: BufferFormat,
 		): void {
-			fail("Empty array should not encode any nodes");
+			fail(0xb4d /* Empty array should not encode any nodes */);
 		},
 	});
 
@@ -324,7 +324,7 @@ export class InlineArrayShape
 		return {
 			b: {
 				length: this.length,
-				shape: shapes.valueToIndex.get(this.inner.shape) ?? fail("missing shape"),
+				shape: shapes.valueToIndex.get(this.inner.shape) ?? fail(0xb4e /* missing shape */),
 			},
 		};
 	}
@@ -380,7 +380,8 @@ export class NestedArrayShape extends ShapeGeneric<EncodedChunkShape> implements
 		shapes: DeduplicationTable<Shape>,
 	): EncodedChunkShape {
 		const shape: EncodedNestedArray =
-			shapes.valueToIndex.get(this.inner.shape) ?? fail("index for shape not found in table");
+			shapes.valueToIndex.get(this.inner.shape) ??
+			fail(0xb4f /* index for shape not found in table */);
 		return {
 			a: shape,
 		};

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

@@ -138,7 +138,7 @@ export function encodeFieldShapes(
 		// key
 		encodeIdentifier(field.key, identifiers),
 		// shape
-		shapes.valueToIndex.get(field.shape.shape) ?? fail("missing shape"),
+		shapes.valueToIndex.get(field.shape.shape) ?? fail(0xb50 /* missing shape */),
 	]);
 }
 
@@ -167,5 +167,5 @@ function dedupShape(
 	shape: Shape<EncodedChunkShape>,
 	shapes: DeduplicationTable<Shape<EncodedChunkShape>>,
 ): number {
-	return shapes.valueToIndex.get(shape) ?? fail("missing shape");
+	return shapes.valueToIndex.get(shape) ?? fail(0xb51 /* missing shape */);
 }

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

@@ -74,7 +74,7 @@ export function fieldShaper(
 	cache: EncoderCache,
 	storedSchema: StoredSchemaCollection,
 ): FieldEncoder {
-	const kind = cache.fieldShapes.get(field.kind) ?? fail("missing FieldKind");
+	const kind = cache.fieldShapes.get(field.kind) ?? fail(0xb52 /* missing FieldKind */);
 	const type = oneFromSet(field.types);
 	const nodeEncoder = type !== undefined ? treeHandler.shapeFromTree(type) : anyNodeEncoder;
 	if (kind.multiplicity === Multiplicity.Single) {
@@ -113,7 +113,8 @@ export function treeShaper(
 	fieldHandler: FieldShaper,
 	schemaName: TreeNodeSchemaIdentifier,
 ): NodeShape {
-	const schema = fullSchema.nodeSchema.get(schemaName) ?? fail("missing node schema");
+	const schema =
+		fullSchema.nodeSchema.get(schemaName) ?? fail(0xb53 /* missing node schema */);
 
 	if (schema instanceof ObjectNodeStoredSchema) {
 		// TODO:Performance:
@@ -146,7 +147,7 @@ export function treeShaper(
 		);
 		return shape;
 	}
-	fail("unsupported node kind");
+	fail(0xb54 /* unsupported node kind */);
 }
 
 export function oneFromSet<T>(set: ReadonlySet<T> | undefined): T | undefined {

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

@@ -52,10 +52,10 @@ export const emptyCursor: ChunkedCursor = {
 	mode: CursorLocationType.Fields,
 	[cursorChunk]: emptyChunk,
 	nextField(): boolean {
-		fail("cannot navigate above root");
+		fail(0xafb /* cannot navigate above root */);
 	},
 	exitField(): void {
-		fail("cannot navigate above root");
+		fail(0xafc /* cannot navigate above root */);
 	},
 	skipPendingFields(): boolean {
 		return true;
@@ -70,43 +70,43 @@ export const emptyCursor: ChunkedCursor = {
 		return false;
 	},
 	enterNode(childIndex: number): void {
-		fail("empty cursor has no nodes");
+		fail(0xafd /* empty cursor has no nodes */);
 	},
 	getFieldPath(prefix?: PathRootPrefix): FieldUpPath {
 		return prefixFieldPath(prefix, emptyPath);
 	},
 	getPath(): UpPath | undefined {
-		fail("empty cursor has no nodes");
+		fail(0xafe /* empty cursor has no nodes */);
 	},
 	get fieldIndex(): never {
-		return fail("empty cursor has no nodes");
+		return fail(0xaff /* empty cursor has no nodes */);
 	},
 	get chunkStart(): never {
-		return fail("empty cursor has no nodes");
+		return fail(0xb00 /* empty cursor has no nodes */);
 	},
 	get chunkLength(): never {
-		return fail("empty cursor has no nodes");
+		return fail(0xb01 /* empty cursor has no nodes */);
 	},
 	seekNodes(offset: number): boolean {
-		fail("empty cursor has no nodes");
+		fail(0xb02 /* empty cursor has no nodes */);
 	},
 	nextNode(): boolean {
-		fail("empty cursor has no nodes");
+		fail(0xb03 /* empty cursor has no nodes */);
 	},
 	exitNode(): void {
-		fail("empty cursor has no nodes");
+		fail(0xb04 /* empty cursor has no nodes */);
 	},
 	firstField(): boolean {
-		fail("empty cursor has no nodes");
+		fail(0xb05 /* empty cursor has no nodes */);
 	},
 	enterField(key: FieldKey): void {
-		fail("empty cursor has no nodes");
+		fail(0xb06 /* empty cursor has no nodes */);
 	},
 	get type(): never {
-		return fail("empty cursor has no nodes");
+		return fail(0xb07 /* empty cursor has no nodes */);
 	},
 	get value(): never {
-		return fail("empty cursor has no nodes");
+		return fail(0xb08 /* empty cursor has no nodes */);
 	},
 	atChunkRoot(): boolean {
 		return true;

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

@@ -382,7 +382,7 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 	}
 
 	public getFieldKey(): FieldKey {
-		return this.fieldKey ?? fail("not in a field");
+		return this.fieldKey ?? fail(0xb09 /* not in a field */);
 	}
 
 	public getFieldLength(): number {
@@ -510,11 +510,13 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 	public exitNode(): void {
 		const info = this.nodeInfo(CursorLocationType.Nodes);
 		this.indexOfField =
-			info.indexOfParentField ?? fail("navigation up to root field not yet supported"); // TODO;
+			info.indexOfParentField ??
+			fail(0xb0a /* navigation up to root field not yet supported */); // TODO;
 		this.fieldKey = info.parentField;
 		this.mode = CursorLocationType.Fields;
 		this.moveToPosition(
-			info.indexOfParentPosition ?? fail("navigation up to root field not yet supported"),
+			info.indexOfParentPosition ??
+				fail(0xb0b /* navigation up to root field not yet supported */),
 		); // TODO
 	}
 
@@ -536,7 +538,7 @@ class Cursor extends SynchronousCursor implements ChunkedCursor {
 		this.indexOfField =
 			fieldInfo === undefined
 				? fieldMap.size
-				: (fieldInfo.indexOfParentField ?? fail("children should have parents"));
+				: (fieldInfo.indexOfParentField ?? fail(0xb0c /* children should have parents */));
 		this.fieldKey = key;
 		this.mode = CursorLocationType.Fields;
 	}

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

@@ -42,7 +42,7 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 		rebase: (change: 0, over: 0) => 0,
 	}),
 	codecsFactory: () => noChangeCodecFamily,
-	editor: { buildChildChanges: () => fail("Child changes not supported") },
+	editor: { buildChildChanges: () => fail(0xb0d /* Child changes not supported */) },
 	intoDelta: (change, deltaFromChild: ToDelta): FieldChangeDelta => ({}),
 	relevantRemovedRoots: (change): Iterable<DeltaDetachedNodeId> => [],
 	isEmpty: (change: 0) => true,

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

@@ -90,7 +90,7 @@ export function isNodeInSchema(
 			}
 		}
 	} else {
-		fail("Unknown TreeNodeStoredSchema type");
+		fail(0xb0e /* Unknown TreeNodeStoredSchema type */);
 	}
 
 	return SchemaValidationErrors.NoError;

package/src/feature-libraries/flex-tree/lazyField.ts

@@ -82,12 +82,9 @@ export function makeField(
 
 	const makeFlexTreeField = (): FlexTreeField => {
 		usedAnchor = true;
-		const field = new (kindToClass.get(schema) ?? fail("missing field implementation"))(
-			context,
-			schema,
-			cursor,
-			fieldAnchor,
-		);
+		const field = new (
+			kindToClass.get(schema) ?? fail(0xb0f /* missing field implementation */)
+		)(context, schema, cursor, fieldAnchor);
 		return field;
 	};
 
@@ -97,7 +94,8 @@ export function makeField(
 
 	// For the common case (all but roots), cache field associated with its node's anchor and field key.
 	const anchorNode =
-		context.checkout.forest.anchors.locate(fieldAnchor.parent) ?? fail("missing anchor");
+		context.checkout.forest.anchors.locate(fieldAnchor.parent) ??
+		fail(0xb10 /* missing anchor */);
 
 	// Since anchor-set could be reused across a flex tree context getting disposed, key off the flex tree node not the anchor.
 	const cacheKey = anchorNode.slots.get(flexTreeSlot);
@@ -150,7 +148,7 @@ export abstract class LazyField extends LazyEntity<FieldAnchor> implements FlexT
 		if (fieldAnchor.parent !== undefined) {
 			const anchorNode =
 				context.checkout.forest.anchors.locate(fieldAnchor.parent) ??
-				fail("parent anchor node should always exist since field is under a node");
+				fail(0xb11 /* parent anchor node should always exist since field is under a node */);
 			this.offAfterDestroy = anchorNode.events.on("afterDestroy", () => {
 				this[disposeSymbol]();
 			});

package/src/feature-libraries/flex-tree/lazyNode.ts

@@ -48,7 +48,7 @@ export function makeTree(context: Context, cursor: ITreeSubscriptionCursor): Laz
 	const anchor = cursor.buildAnchor();
 	const anchorNode =
 		context.checkout.forest.anchors.locate(anchor) ??
-		fail("cursor should point to a node that is not the root of the AnchorSet");
+		fail(0xb12 /* cursor should point to a node that is not the root of the AnchorSet */);
 	const cached = anchorNode.slots.get(flexTreeSlot);
 	if (cached !== undefined) {
 		context.checkout.forest.anchors.forget(anchor);
@@ -60,7 +60,8 @@ export function makeTree(context: Context, cursor: ITreeSubscriptionCursor): Laz
 }
 
 function cleanupTree(anchor: AnchorNode): void {
-	const cached = anchor.slots.get(flexTreeSlot) ?? fail("tree should only be cleaned up once");
+	const cached =
+		anchor.slots.get(flexTreeSlot) ?? fail(0xb13 /* tree should only be cleaned up once */);
 	assert(cached instanceof LazyTreeNode, 0x92d /* Expected LazyTreeNode */);
 	cached[disposeSymbol]();
 }
@@ -86,7 +87,8 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements FlexTreeNode {
 		anchor: Anchor,
 	) {
 		super(context, cursor, anchor);
-		this.storedSchema = context.schema.nodeSchema.get(this.schema) ?? fail("missing schema");
+		this.storedSchema =
+			context.schema.nodeSchema.get(this.schema) ?? fail(0xb14 /* missing schema */);
 		assert(cursor.mode === CursorLocationType.Nodes, 0x783 /* must be in nodes mode */);
 		anchorNode.slots.set(flexTreeSlot, this);
 		this.#removeDeleteCallback = anchorNode.events.on("afterDestroy", cleanupTree);
@@ -180,7 +182,7 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements FlexTreeNode {
 			cursor.enterField(key);
 			const nodeSchema =
 				this.context.schema.nodeSchema.get(parentType) ??
-				fail("requested schema that does not exist");
+				fail(0xb15 /* requested schema that does not exist */);
 			fieldSchema = nodeSchema.getFieldSchema(key).kind;
 		}
 

package/src/feature-libraries/indexing/anchorTreeIndex.ts

@@ -359,7 +359,8 @@ export class AnchorTreeIndex<TKey extends TreeIndexKey, TValue>
 				throw new Error("key finder should be pure and functional");
 			}
 			const anchor = nodeCursor.buildAnchor();
-			const anchorNode = this.forest.anchors.locate(anchor) ?? fail("expected anchor node");
+			const anchorNode =
+				this.forest.anchors.locate(anchor) ?? fail(0xb16 /* expected anchor node */);
 
 			// check if this anchor node already exists in the index
 			const existingKey = this.nodeToKey.get(anchorNode);

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

@@ -104,7 +104,8 @@ export function allowsTreeSuperset(
 			allowsFieldSuperset(
 				policy,
 				originalData,
-				original.objectNodeFields.get(originalField) ?? fail("missing expected field"),
+				original.objectNodeFields.get(originalField) ??
+					fail(0xb17 /* missing expected field */),
 				normalizeField(undefined),
 			),
 		bExtra: (supersetField) =>
@@ -112,14 +113,15 @@ export function allowsTreeSuperset(
 				policy,
 				originalData,
 				normalizeField(undefined),
-				superset.objectNodeFields.get(supersetField) ?? fail("missing expected field"),
+				superset.objectNodeFields.get(supersetField) ??
+					fail(0xb18 /* missing expected field */),
 			),
 		same: (sameField) =>
 			allowsFieldSuperset(
 				policy,
 				originalData,
-				original.objectNodeFields.get(sameField) ?? fail("missing expected field"),
-				superset.objectNodeFields.get(sameField) ?? fail("missing expected field"),
+				original.objectNodeFields.get(sameField) ?? fail(0xb19 /* missing expected field */),
+				superset.objectNodeFields.get(sameField) ?? fail(0xb1a /* missing expected field */),
 			),
 	});
 }
@@ -148,7 +150,7 @@ export function allowsFieldSuperset(
 	superset: TreeFieldStoredSchema,
 ): boolean {
 	return withEditor(
-		policy.fieldKinds.get(original.kind) ?? fail("missing kind"),
+		policy.fieldKinds.get(original.kind) ?? fail(0xb1b /* missing kind */),
 	).allowsFieldSuperset(policy, originalData, original.types, superset);
 }
 

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

@@ -35,8 +35,8 @@ export function isNeverFieldRecursive(
 	parentTypeStack: Set<TreeNodeStoredSchema>,
 ): boolean {
 	if (
-		(policy.fieldKinds.get(field.kind) ?? fail("missing field kind")).multiplicity ===
-			Multiplicity.Single &&
+		(policy.fieldKinds.get(field.kind) ?? fail(0xb1c /* missing field kind */))
+			.multiplicity === Multiplicity.Single &&
 		field.types !== undefined
 	) {
 		for (const type of field.types) {
@@ -94,8 +94,10 @@ export function isNeverTreeRecursive(
 		parentTypeStack.add(treeNode);
 		if (treeNode instanceof MapNodeStoredSchema) {
 			return (
-				(policy.fieldKinds.get(treeNode.mapFields.kind) ?? fail("missing field kind"))
-					.multiplicity === Multiplicity.Single
+				(
+					policy.fieldKinds.get(treeNode.mapFields.kind) ??
+					fail(0xb1d /* missing field kind */)
+				).multiplicity === Multiplicity.Single
 			);
 		} else if (treeNode instanceof ObjectNodeStoredSchema) {
 			for (const field of treeNode.objectNodeFields.values()) {

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

@@ -177,7 +177,7 @@ function makeModularChangeCodec(
 				return encodeNodeChangesForJson(node, fieldContext);
 			},
 
-			decodeNode: () => fail("Should not decode nodes during field encoding"),
+			decodeNode: () => fail(0xb1e /* Should not decode nodes during field encoding */),
 		};
 
 		return encodeFieldChangesForJsonI(change, fieldContext);
@@ -193,7 +193,7 @@ function makeModularChangeCodec(
 			const { codec, compiledSchema } = getFieldChangesetCodec(fieldChange.fieldKind);
 			const encodedChange = codec.json.encode(fieldChange.change, context);
 			if (compiledSchema !== undefined && !compiledSchema.check(encodedChange)) {
-				fail("Encoded change didn't pass schema validation.");
+				fail(0xb1f /* Encoded change didn't pass schema validation. */);
 			}
 
 			const fieldKey: FieldKey = field;
@@ -238,7 +238,7 @@ function makeModularChangeCodec(
 		for (const field of encodedChange) {
 			const { codec, compiledSchema } = getFieldChangesetCodec(field.fieldKind);
 			if (compiledSchema !== undefined && !compiledSchema.check(field.change)) {
-				fail("Encoded change didn't pass schema validation.");
+				fail(0xb20 /* Encoded change didn't pass schema validation. */);
 			}
 
 			const fieldId: FieldId = {
@@ -249,7 +249,7 @@ function makeModularChangeCodec(
 			const fieldContext: FieldChangeEncodingContext = {
 				baseContext: context,
 
-				encodeNode: () => fail("Should not encode nodes during field decoding"),
+				encodeNode: () => fail(0xb21 /* Should not encode nodes during field decoding */),
 
 				decodeNode: (encodedNode: EncodedNodeChangeset): NodeId => {
 					const nodeId: NodeId = {