@fluidframework/tree 2.23.0-323641 → 2.23.0

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 = {

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

@@ -52,7 +52,7 @@ import {
 	idAllocatorFromMaxId,
 	idAllocatorFromState,
 	type RangeQueryResult,
-	getOrAddInMapLazy,
+	getOrCreate,
 	newTupleBTree,
 	mergeTupleBTrees,
 	type TupleBTree,
@@ -321,7 +321,7 @@ export class ModularChangeFamily
 				crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
 			}
 
-			return child1 ?? child2 ?? fail("Should not compose two undefined nodes");
+			return child1 ?? child2 ?? fail(0xb22 /* Should not compose two undefined nodes */);
 		};
 
 		const amendedChange = rebaser.compose(
@@ -566,7 +566,7 @@ export class ModularChangeFamily
 					setInChangeAtomIdMap(crossFieldTable.newToBaseNodeId, child2, child1);
 					crossFieldTable.pendingCompositions.nodeIdsToCompose.push([child1, child2]);
 				}
-				return child1 ?? child2 ?? fail("Should not compose two undefined nodes");
+				return child1 ?? child2 ?? fail(0xb23 /* Should not compose two undefined nodes */);
 			},
 			idAllocator,
 			manager,
@@ -1426,7 +1426,8 @@ export class ModularChangeFamily
 		constraintState: ConstraintState,
 		revertConstraintState: ConstraintState,
 	): void {
-		const node = nodes.get([nodeId.revision, nodeId.localId]) ?? fail("Unknown node ID");
+		const node =
+			nodes.get([nodeId.revision, nodeId.localId]) ?? fail(0xb24 /* Unknown node ID */);
 		if (node.nodeExistsConstraint !== undefined) {
 			const isNowViolated = inputAttachState === NodeAttachState.Detached;
 			if (node.nodeExistsConstraint.violated !== isNowViolated) {
@@ -1924,7 +1925,7 @@ export function updateRefreshers(
 
 	if (change.builds !== undefined) {
 		for (const [[revision, id], chunk] of change.builds.entries()) {
-			const lengthTree = getOrAddInMapLazy(chunkLengths, revision, () => new BTree());
+			const lengthTree = getOrCreate(chunkLengths, revision, () => new BTree());
 			lengthTree.set(id, chunk.topLevelLength);
 		}
 	}
@@ -3002,7 +3003,7 @@ function fieldChangeFromId(
 	id: FieldId,
 ): FieldChange {
 	const fieldMap = fieldMapFromNodeId(fields, nodes, id.nodeId);
-	return fieldMap.get(id.field) ?? fail("No field exists for the given ID");
+	return fieldMap.get(id.field) ?? fail(0xb25 /* No field exists for the given ID */);
 }
 
 function fieldMapFromNodeId(

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

@@ -27,7 +27,7 @@ export class MockNodeKeyManager implements NodeKeyManager {
 	}
 
 	public localizeNodeKey(key: StableNodeKey): LocalNodeKey {
-		return this.tryLocalizeNodeKey(key) ?? fail("Key is not compressible");
+		return this.tryLocalizeNodeKey(key) ?? fail(0xb26 /* Key is not compressible */);
 	}
 
 	public stabilizeNodeKey(key: LocalNodeKey): StableNodeKey {

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

@@ -439,7 +439,7 @@ class Cursor extends SynchronousCursor implements ITreeSubscriptionCursor {
 	}
 	public getPath(prefix?: PathRootPrefix): UpPath {
 		assert(this.innerCursor !== undefined, 0x436 /* Cursor must be current to be used */);
-		return this.innerCursor.getPath(prefix) ?? fail("no path when at root");
+		return this.innerCursor.getPath(prefix) ?? fail(0xb27 /* no path when at root */);
 	}
 	public get fieldIndex(): number {
 		assert(this.innerCursor !== undefined, 0x437 /* Cursor must be current to be used */);

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

@@ -27,7 +27,7 @@ export function encodeRepo(repo: TreeStoredSchema): Format {
 		Object.create(null);
 	const rootFieldSchema = encodeFieldSchema(repo.rootFieldSchema);
 	for (const name of [...repo.nodeSchema.keys()].sort()) {
-		const schema = repo.nodeSchema.get(name) ?? fail("missing schema");
+		const schema = repo.nodeSchema.get(name) ?? fail(0xb28 /* missing schema */);
 		Object.defineProperty(nodeSchema, name, {
 			enumerable: true,
 			configurable: true,

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

@@ -540,7 +540,7 @@ export class ComposeQueue {
 			return this.dequeueBase();
 		} else if (areOutputCellsEmpty(baseMark) && areInputCellsEmpty(newMark)) {
 			const baseCellId: ChangeAtomId =
-				getOutputCellId(baseMark) ?? fail("Expected defined output ID");
+				getOutputCellId(baseMark) ?? fail(0xb29 /* Expected defined output ID */);
 
 			if (markEmptiesCells(baseMark) && baseCellId.revision === undefined) {
 				// The base revision should always be defined except when squashing changes into a transaction.

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

@@ -176,7 +176,7 @@ function invertMark(
 			}
 
 			const cellId = getDetachOutputCellId(mark) ?? {
-				revision: mark.revision ?? fail("Revision must be defined"),
+				revision: mark.revision ?? fail(0xb2a /* Revision must be defined */),
 				localId: mark.id,
 			};
 

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

@@ -145,7 +145,7 @@ export function makeV1Codec(
 						context,
 					);
 				case NoopMarkType:
-					fail("Mark type: NoopMarkType should not be encoded.");
+					fail(0xb2b /* Mark type: NoopMarkType should not be encoded. */);
 				default:
 					unreachableCase(type);
 			}

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

@@ -132,7 +132,7 @@ export function makeV2CodecHelpers(
 						context,
 					);
 				case NoopMarkType:
-					fail("Mark type: NoopMarkType should not be encoded.");
+					fail(0xb2c /* Mark type: NoopMarkType should not be encoded. */);
 				default:
 					unreachableCase(type);
 			}

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

@@ -747,7 +747,7 @@ export function splitMark<TMark extends Mark>(mark: TMark, length: number): [TMa
 	const markLength = mark.count;
 	const remainder = markLength - length;
 	if (length < 1 || remainder < 1) {
-		fail("Unable to split mark due to lengths");
+		fail(0xb2d /* Unable to split mark due to lengths */);
 	}
 
 	const [effect1, effect2] = splitMarkEffect(mark, length);

package/src/feature-libraries/treeCursorUtils.ts

@@ -345,14 +345,16 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 
 	public exitField(): void {
 		// assert(this.mode === CursorLocationType.Fields, "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(0xac3 /* Unexpected siblingStack.length */);
+		this.index = this.indexStack.pop() ?? fail(0xac4 /* Unexpected indexStack.length */);
 	}
 
 	public exitNode(): void {
 		// assert(this.mode === CursorLocationType.Nodes, "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(0xac5 /* Unexpected siblingStack.length */);
+		this.index = this.indexStack.pop() ?? fail(0xac6 /* Unexpected indexStack.length */);
 	}
 
 	public getNode(): TNode {

package/src/index.ts

@@ -73,7 +73,6 @@ export {
 	ForestTypeOptimized,
 	ForestTypeExpensiveDebug,
 	ForestTypeReference,
-	type IChannelView,
 } from "./shared-tree/index.js";
 
 export {
@@ -259,3 +258,6 @@ export {
 export type { MapNodeInsertableData } from "./simple-tree/index.js";
 
 export type { JsonCompatible, JsonCompatibleObject } from "./util/index.js";
+
+export { JsonAsTree } from "./jsonDomainSchema.js";
+export { FluidSerializableAsTree } from "./serializableDomainSchema.js";