@fluidframework/tree 2.22.1 → 2.23.0

package/src/shared-tree/treeApiAlpha.ts

@@ -310,7 +310,11 @@ export const TreeAlpha: {
 		};
 
 		const cursor = borrowCursorFromTreeNodeOrValue(node);
-		return conciseFromCursor(cursor, tryGetSchema(node) ?? fail("invalid input"), config);
+		return conciseFromCursor(
+			cursor,
+			tryGetSchema(node) ?? fail(0xacd /* invalid input */),
+			config,
+		);
 	},
 
 	exportVerbose<T>(
@@ -325,7 +329,11 @@ export const TreeAlpha: {
 		};
 
 		const cursor = borrowCursorFromTreeNodeOrValue(node);
-		return verboseFromCursor(cursor, tryGetSchema(node) ?? fail("invalid input"), config);
+		return verboseFromCursor(
+			cursor,
+			tryGetSchema(node) ?? fail(0xace /* invalid input */),
+			config,
+		);
 	},
 
 	exportCompressed(
@@ -335,7 +343,7 @@ export const TreeAlpha: {
 			idCompressor?: IIdCompressor;
 		},
 	): JsonCompatible<IFluidHandle> {
-		const schema = tryGetSchema(node) ?? fail("invalid input");
+		const schema = tryGetSchema(node) ?? fail(0xacf /* invalid input */);
 		const format = versionToFormat[options.oldestCompatibleClient];
 		const codec = makeFieldBatchCodec({ jsonValidator: noopValidator }, format);
 		const cursor = borrowFieldCursorFromTreeNodeOrValue(node);
@@ -375,7 +383,7 @@ function borrowCursorFromTreeNodeOrValue(
 ): ITreeCursorSynchronous {
 	if (isTreeValue(node)) {
 		return cursorFromInsertable<UnsafeUnknownSchema>(
-			tryGetSchema(node) ?? fail("missing schema"),
+			tryGetSchema(node) ?? fail(0xad0 /* missing schema */),
 			node,
 		);
 	}

package/src/shared-tree/treeCheckout.ts

@@ -524,7 +524,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 					// original (reinstated) schema.
 					this.storedSchema.apply(change.innerChange.schema.new);
 				} else {
-					fail("Unknown Shared Tree change type.");
+					fail(0xad1 /* Unknown Shared Tree change type. */);
 				}
 			}
 		}

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

@@ -242,7 +242,7 @@ export class EditManager<
 	private trackBranch(b: SharedTreeBranch<TEditor, TChangeset>): void {
 		const trunkCommit =
 			findCommonAncestor(this.trunk.getHead(), b.getHead()) ??
-			fail("Expected branch to be related to trunk");
+			fail(0xad2 /* Expected branch to be related to trunk */);
 		const sequenceId = this.getCommitSequenceId(trunkCommit);
 		const branches = getOrCreate(this.trunkBranches, sequenceId, () => new Set());
 
@@ -253,10 +253,10 @@ export class EditManager<
 	private untrackBranch(b: SharedTreeBranch<TEditor, TChangeset>): void {
 		const trunkCommit =
 			findCommonAncestor(this.trunk.getHead(), b.getHead()) ??
-			fail("Expected branch to be related to trunk");
+			fail(0xad3 /* Expected branch to be related to trunk */);
 		const sequenceId = this.getCommitSequenceId(trunkCommit);
 		const branches =
-			this.trunkBranches.get(sequenceId) ?? fail("Expected branch to be tracked");
+			this.trunkBranches.get(sequenceId) ?? fail(0xad4 /* Expected branch to be tracked */);
 
 		assert(branches.delete(b), 0x671 /* Expected branch to be tracked */);
 		if (branches.size === 0) {
@@ -472,7 +472,7 @@ export class EditManager<
 		// `EditManager` would have to be amended in one of two ways:
 		// A) Changes made by the local session should be represented by a branch in `EditManager.branches`.
 		// B) The contents of such a branch should be computed on demand based on the trunk.
-		// Note that option (A) would be a simple change to `addSequencedChange` whereas (B) would likely require
+		// Note that option (A) would be a simple change to `addSequencedChanges` whereas (B) would likely require
 		// rebasing trunk changes over the inverse of trunk changes.
 		assert(
 			this.localBranch.getHead() === this.trunk.getHead(),
@@ -500,7 +500,8 @@ export class EditManager<
 					0xa61 /* Serialized trunk should not include the trunk base */,
 				);
 				const metadata =
-					this.trunkMetadata.get(c.revision) ?? fail("Expected metadata for trunk commit");
+					this.trunkMetadata.get(c.revision) ??
+					fail(0xad5 /* Expected metadata for trunk commit */);
 				const commit: SequencedCommit<TChangeset> = {
 					change: c.change,
 					revision: c.revision,
@@ -519,7 +520,7 @@ export class EditManager<
 				const branchPath: GraphCommit<TChangeset>[] = [];
 				const ancestor =
 					findCommonAncestor([branch.getHead(), branchPath], this.trunk.getHead()) ??
-					fail("Expected branch to be based on trunk");
+					fail(0xad6 /* Expected branch to be based on trunk */);
 
 				const base = ancestor === this.trunkBase ? rootRevision : ancestor.revision;
 				return [
@@ -582,7 +583,7 @@ export class EditManager<
 		for (const [sessionId, branch] of data.peerLocalBranches) {
 			const commit =
 				trunkRevisionCache.get(branch.base) ??
-				fail("Expected summary branch to be based off of a revision in the trunk");
+				fail(0xad7 /* Expected summary branch to be based off of a revision in the trunk */);
 
 			this.peerLocalBranches.set(
 				sessionId,
@@ -646,24 +647,45 @@ export class EditManager<
 		return Math.max(max, localPath.length);
 	}
 
-	public addSequencedChange(
-		newCommit: Commit<TChangeset>,
+	/* eslint-disable jsdoc/check-indentation */
+	/**
+	 * Add a bunch of sequenced changes. A bunch is a group of sequenced commits that have the following properties:
+	 * - They are not interleaved with messages from other DDSes in the container.
+	 * - They are all part of the same batch, which entails:
+	 *   - They are contiguous in sequencing order.
+	 *   - They are all from the same client.
+	 *   - They are all based on the same reference sequence number.
+	 *   - They are not interleaved with messages from other clients.
+	 */
+	/* eslint-enable jsdoc/check-indentation */
+	public addSequencedChanges(
+		newCommits: readonly GraphCommit<TChangeset>[],
+		sessionId: SessionId,
 		sequenceNumber: SeqNumber,
 		referenceSequenceNumber: SeqNumber,
 	): void {
+		assert(newCommits.length > 0, 0xad8 /* Expected at least one sequenced change */);
 		assert(
 			sequenceNumber > this.minimumSequenceNumber,
 			0x713 /* Expected change sequence number to exceed the last known minimum sequence number */,
 		);
-
 		assert(
 			sequenceNumber >= // This is ">=", not ">" because changes in the same batch will have the same sequence number
 				(this.sequenceMap.maxKey()?.sequenceNumber ?? minimumPossibleSequenceNumber),
 			0xa64 /* Attempted to sequence change with an outdated sequence number */,
 		);
 
+		// Returns the sequence id for the next commit to be processed in the bunch. Since all the commits have the
+		// same sequence number, only the index in the batch needs to be incremented.
+		const getNextSequenceId = (sequenceId: SequenceId): SequenceId => {
+			return {
+				sequenceNumber: sequenceId.sequenceNumber,
+				indexInBatch: (sequenceId.indexInBatch ?? 0) + 1,
+			};
+		};
 		const commitsSequenceNumber = this.getBatch(sequenceNumber);
-		const sequenceId: SequenceId =
+		// The sequence id for the next commit to be processed in the bunch.
+		let nextSequenceId =
 			commitsSequenceNumber.length === 0
 				? {
 						sequenceNumber,
@@ -673,49 +695,65 @@ export class EditManager<
 						indexInBatch: commitsSequenceNumber.length,
 					};
 
-		if (newCommit.sessionId === this.localSessionId) {
-			return this.fastForwardNextLocalCommit(sequenceId);
+		// Local changes, i.e., changes from this client are applied by fast forwarding the local branch commit onto
+		// the trunk.
+		if (sessionId === this.localSessionId) {
+			for (const _ of newCommits) {
+				this.fastForwardNextLocalCommit(nextSequenceId);
+				nextSequenceId = getNextSequenceId(nextSequenceId);
+			}
+			return;
 		}
 
-		// Get the revision that the remote change is based on
-		const [, baseRevisionInTrunk] = this.getClosestTrunkCommit(referenceSequenceNumber);
-		// Rebase that branch over the part of the trunk up to the base revision
-		// This will be a no-op if the sending client has not advanced since the last time we received an edit from it
-		const peerLocalBranch = getOrCreate(
-			this.peerLocalBranches,
-			newCommit.sessionId,
-			() => new SharedTreeBranch(baseRevisionInTrunk, this.changeFamily, this.mintRevisionTag),
-		);
-		peerLocalBranch.rebaseOnto(this.trunk, baseRevisionInTrunk);
-
-		if (peerLocalBranch.getHead() === this.trunk.getHead()) {
-			// If the branch is fully caught up and empty after being rebased, then push to the trunk directly
-			this.pushCommitToTrunk(sequenceId, newCommit);
-			peerLocalBranch.setHead(this.trunk.getHead());
-		} else {
-			// Otherwise, rebase the change over the trunk and append it, and append the original change to the peer branch.
-			const { duration, output: newChangeFullyRebased } = measure(() =>
-				rebaseChange(
-					this.changeFamily.rebaser,
-					newCommit,
-					peerLocalBranch.getHead(),
-					this.trunk.getHead(),
-					this.mintRevisionTag,
-				),
+		// Remote changes, i.e., changes from remote clients are applied in three steps.
+		for (const newCommit of newCommits) {
+			// Step 1 - Recreate the peer remote client's local environment.
+			// Get the revision that the remote change is based on
+			const [, baseRevisionInTrunk] = this.getClosestTrunkCommit(referenceSequenceNumber);
+			// Rebase that peer local branch over the part of the trunk up to the base revision
+			// This will be a no-op if the sending client has not advanced since the last time we received an edit from it
+			const peerLocalBranch = getOrCreate(
+				this.peerLocalBranches,
+				sessionId,
+				() =>
+					new SharedTreeBranch(baseRevisionInTrunk, this.changeFamily, this.mintRevisionTag),
 			);
+			peerLocalBranch.rebaseOnto(this.trunk, baseRevisionInTrunk);
 
-			this.telemetryEventBatcher?.accumulateAndLog({
-				duration,
-				...newChangeFullyRebased.telemetryProperties,
-			});
+			// Step 2 - Append the change to the peer branch. Rebase the change to the tip of the trunk.
+			if (peerLocalBranch.getHead() === this.trunk.getHead()) {
+				// If the branch is fully caught up and empty after being rebased, then push to the trunk directly
+				this.pushCommitToTrunk(nextSequenceId, { ...newCommit, sessionId });
+				peerLocalBranch.setHead(this.trunk.getHead());
+			} else {
+				// Otherwise, rebase the change over the trunk and append it, and append the original change to the peer branch.
+				const { duration, output: newChangeFullyRebased } = measure(() =>
+					rebaseChange(
+						this.changeFamily.rebaser,
+						newCommit,
+						peerLocalBranch.getHead(),
+						this.trunk.getHead(),
+						this.mintRevisionTag,
+					),
+				);
 
-			peerLocalBranch.apply(tagChange(newCommit.change, newCommit.revision));
-			this.pushCommitToTrunk(sequenceId, {
-				...newCommit,
-				change: newChangeFullyRebased.change,
-			});
+				this.telemetryEventBatcher?.accumulateAndLog({
+					duration,
+					...newChangeFullyRebased.telemetryProperties,
+				});
+
+				peerLocalBranch.apply(tagChange(newCommit.change, newCommit.revision));
+				this.pushCommitToTrunk(nextSequenceId, {
+					...newCommit,
+					sessionId,
+					change: newChangeFullyRebased.change,
+				});
+			}
+
+			nextSequenceId = getNextSequenceId(nextSequenceId);
 		}
 
+		// Step 3 - Rebase the local branch over the updated trunk.
 		this.localBranch.rebaseOnto(this.trunk);
 	}
 

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

@@ -39,6 +39,8 @@ export interface ResubmitMachine<TChange> {
 
 	/**
 	 * Must be called after a sequenced commit is applied.
+	 * Note that this may be called multiples times in a row after a number of sequenced commits have been applied
+	 * (as opposed to always being called before the next sequenced commit is applied).
 	 * @param isLocal - whether the sequenced commit was generated by the local session.
 	 */
 	onSequencedCommitApplied(isLocal: boolean): void;

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

@@ -5,15 +5,19 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
-import type { IIdCompressor } from "@fluidframework/id-compressor";
+import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
 import type { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import type {
 	IExperimentalIncrementalSummaryContext,
+	IRuntimeMessageCollection,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
 import { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal";
-import type { IFluidSerializer } from "@fluidframework/shared-object-base/internal";
+import type {
+	IChannelView,
+	IFluidSerializer,
+} from "@fluidframework/shared-object-base/internal";
 
 import type { ICodecOptions, IJsonCodec } from "../codec/index.js";
 import {
@@ -50,7 +54,6 @@ import { DefaultResubmitMachine } from "./defaultResubmitMachine.js";
 import { BranchCommitEnricher } from "./branchCommitEnricher.js";
 import { createChildLogger } from "@fluidframework/telemetry-utils/internal";
 import type { IFluidLoadable, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
-import type { IChannelView } from "../shared-tree/index.js";
 
 // TODO: Organize this to be adjacent to persisted types.
 const summarizablesTreeKey = "indexes";
@@ -301,8 +304,9 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		if (this.detachedRevision !== undefined) {
 			const newRevision: SeqNumber = brand((this.detachedRevision as number) + 1);
 			this.detachedRevision = newRevision;
-			this.editManager.addSequencedChange(
-				{ ...enrichedCommit, sessionId: this.editManager.localSessionId },
+			this.editManager.addSequencedChanges(
+				[enrichedCommit],
+				this.editManager.localSessionId,
 				newRevision,
 				this.detachedRevision,
 			);
@@ -327,24 +331,68 @@ export class SharedTreeCore<TEditor extends ChangeFamilyEditor, TChange>
 		this.resubmitMachine.onCommitSubmitted(enrichedCommit);
 	}
 
+	/**
+	 * Process a message from the runtime.
+	 * @deprecated - Use processMessagesCore to process a bunch of messages together.
+	 */
 	public processCore(
 		message: ISequencedDocumentMessage,
 		local: boolean,
 		localOpMetadata: unknown,
 	): void {
-		// Empty context object is passed in, as our decode function is schema-agnostic.
-		const { commit, sessionId } = this.messageCodec.decode(message.contents, {
-			idCompressor: this.idCompressor,
+		this.processMessagesCore({
+			envelope: message,
+			local,
+			messagesContent: [
+				{
+					clientSequenceNumber: message.clientSequenceNumber,
+					contents: message.contents,
+					localOpMetadata,
+				},
+			],
 		});
+	}
 
-		this.editManager.addSequencedChange(
-			{ ...commit, sessionId },
-			brand(message.sequenceNumber),
-			brand(message.referenceSequenceNumber),
+	/**
+	 * Process a bunch of messages from the runtime. SharedObject will call this method with a bunch of messages.
+	 */
+	public processMessagesCore(messagesCollection: IRuntimeMessageCollection): void {
+		const { envelope, local, messagesContent } = messagesCollection;
+		const commits: GraphCommit<TChange>[] = [];
+		let messagesSessionId: SessionId | undefined;
+
+		// Get a list of all the commits from the messages.
+		for (const messageContent of messagesContent) {
+			// Empty context object is passed in, as our decode function is schema-agnostic.
+			const { commit, sessionId } = this.messageCodec.decode(messageContent.contents, {
+				idCompressor: this.idCompressor,
+			});
+			commits.push(commit);
+
+			if (messagesSessionId !== undefined) {
+				assert(
+					messagesSessionId === sessionId,
+					0xad9 /* All messages in a bunch must have the same session ID */,
+				);
+			}
+			messagesSessionId = sessionId;
+		}
+
+		assert(messagesSessionId !== undefined, 0xada /* Messages must have a session ID */);
+
+		this.editManager.addSequencedChanges(
+			commits,
+			messagesSessionId,
+			brand(envelope.sequenceNumber),
+			brand(envelope.referenceSequenceNumber),
 		);
-		this.resubmitMachine.onSequencedCommitApplied(local);
 
-		this.editManager.advanceMinimumSequenceNumber(brand(message.minimumSequenceNumber));
+		// Update the resubmit machine for each commit applied.
+		for (const _ of messagesContent) {
+			this.resubmitMachine.onSequencedCommitApplied(local);
+		}
+
+		this.editManager.advanceMinimumSequenceNumber(brand(envelope.minimumSequenceNumber));
 	}
 
 	public getLocalBranch(): SharedTreeBranch<TEditor, TChange> {

package/src/simple-tree/api/customTree.ts

@@ -79,7 +79,7 @@ export function customFromCursor<TChild, THandle>(
 	) => TChild,
 ): CustomTree<TChild, THandle> {
 	const type = reader.type;
-	const nodeSchema = schema.get(type) ?? fail("missing schema for type in cursor");
+	const nodeSchema = schema.get(type) ?? fail(0xb2e /* missing schema for type in cursor */);
 
 	switch (type) {
 		case numberSchema.identifier:
@@ -109,7 +109,7 @@ export function customFromCursor<TChild, THandle>(
 						const key =
 							isObjectNodeSchema(nodeSchema) && !options.useStoredKeys
 								? (nodeSchema.storedKeyToPropertyKey.get(storedKey) ??
-									fail("missing property key"))
+									fail(0xb2f /* missing property key */))
 								: storedKey;
 						// Length is checked above.
 						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -138,7 +138,7 @@ export function customFromCursorStored<TChild>(
 	) => TChild,
 ): CustomTree<TChild, IFluidHandle> {
 	const type = reader.type;
-	const nodeSchema = schema.get(type) ?? fail("missing schema for type in cursor");
+	const nodeSchema = schema.get(type) ?? fail(0xb30 /* missing schema for type in cursor */);
 
 	if (nodeSchema instanceof LeafNodeStoredSchema) {
 		assert(valueSchemaAllows(nodeSchema.leafValue, reader.value), 0xa9c /* invalid value */);

package/src/simple-tree/api/schemaCreationUtilities.ts

@@ -138,7 +138,7 @@ export function adaptEnum<
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 	const factoryOut = <TValue extends Values>(value: TValue) => {
 		return new out[
-			inverse.get(value) ?? fail("missing enum value")
+			inverse.get(value) ?? fail(0xb31 /* missing enum value */)
 			// "extends unknown" is required here to handle when TValue is an union: each member of the union should be processed independently.
 		]() as TValue extends unknown
 			? NodeFromSchema<ReturnType<typeof singletonSchema<TScope, TValue>>>

package/src/simple-tree/api/schemaFactoryRecursive.ts

@@ -174,7 +174,7 @@ export type ValidateRecursiveSchema<
  * ```typescript
  *  // Workaround to avoid
  *  // `error TS2310: Type 'RecursiveArray' recursively references itself as a base type.` in the d.ts file.
- * export declare const _RecursiveArrayWorkaround: FixRecursiveArraySchema<typeof RecursiveArray>;
+ * export declare type _RecursiveArrayWorkaround = FixRecursiveArraySchema<typeof RecursiveArray>;
  * export class RecursiveArray extends schema.arrayRecursive("RA", [() => RecursiveArray]) {}
  * {
  * 	type _check = ValidateRecursiveSchema<typeof RecursiveArray>;

package/src/simple-tree/api/simpleTreeIndex.ts

@@ -164,7 +164,7 @@ export function createSimpleTreeIndex<
 							return makeGenericKeyFinder<TKey>(brand(keyLocation), isKeyValid);
 						}
 					} else {
-						fail("node is out of schema");
+						fail(0xb32 /* node is out of schema */);
 					}
 				}
 			: (schemaIdentifier: TreeNodeSchemaIdentifier) => {
@@ -221,11 +221,11 @@ function makeGenericKeyFinder<TKey extends TreeIndexKey>(
 		cursor.exitField();
 
 		if (value === undefined) {
-			fail("a value for the key does not exist");
+			fail(0xb33 /* a value for the key does not exist */);
 		}
 
 		if (!isKeyValid(value)) {
-			fail("the key is an unexpected type");
+			fail(0xb34 /* the key is an unexpected type */);
 		}
 
 		return value;

package/src/simple-tree/api/tree.ts

@@ -376,7 +376,7 @@ export function checkUnion(union: Iterable<TreeNodeSchema>, errors: string[]): v
 		// For each field of schema, remove schema from possiblyAmbiguous that do not have that field
 		for (const [key, field] of schema.fields) {
 			if (field.kind === FieldKind.Required) {
-				const withKey = allObjectKeys.get(key) ?? fail("missing schema");
+				const withKey = allObjectKeys.get(key) ?? fail(0xb35 /* missing schema */);
 				for (const candidate of possiblyAmbiguous) {
 					if (!withKey.has(candidate)) {
 						possiblyAmbiguous.delete(candidate);

package/src/simple-tree/api/treeNodeApi.ts

@@ -40,6 +40,7 @@ import {
 } from "../core/index.js";
 import { isObjectNodeSchema } from "../objectNodeTypes.js";
 import { isLazy, type LazyItem } from "../flexList.js";
+import { markSchemaMostDerived } from "./schemaFactory.js";
 
 /**
  * Provides various functions for analyzing {@link TreeNode}s.
@@ -174,7 +175,7 @@ export const treeNodeApi: TreeNodeApi = {
 								changedFields,
 								(field) =>
 									nodeSchema.storedKeyToPropertyKey.get(field) ??
-									fail("Could not find stored key in schema."),
+									fail(0xb36 /* Could not find stored key in schema. */),
 							),
 						);
 						listener({ changedProperties });
@@ -203,6 +204,10 @@ export const treeNodeApi: TreeNodeApi = {
 		value: unknown,
 		schema: TSchema,
 	): value is TreeNodeFromImplicitAllowedTypes<TSchema> {
+		// This "is" utility would return false if the provided schema is a base type of the actual schema.
+		// This could be confusing, and that case can only be hit when violating the rule that there is a single most derived schema that gets used (See documentation on TreeNodeSchemaClass).
+		// Therefore this uses markSchemaMostDerived to ensure an informative usage error is thrown in the case where a base type is used.
+
 		const actualSchema = tryGetSchema(value);
 		if (actualSchema === undefined) {
 			return false;
@@ -210,19 +215,19 @@ export const treeNodeApi: TreeNodeApi = {
 		if (isReadonlyArray<LazyItem<TreeNodeSchema>>(schema)) {
 			for (const singleSchema of schema) {
 				const testSchema = isLazy(singleSchema) ? singleSchema() : singleSchema;
+				markSchemaMostDerived(testSchema);
 				if (testSchema === actualSchema) {
 					return true;
 				}
 			}
 			return false;
 		} else {
-			// Linter is incorrect about this bering unnecessary: it does not compile without the type assertion.
-			// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-			return (schema as TreeNodeSchema) === actualSchema;
+			markSchemaMostDerived(schema);
+			return schema === actualSchema;
 		}
 	},
 	schema(node: TreeNode | TreeLeafValue): TreeNodeSchema {
-		return tryGetSchema(node) ?? fail("Not a tree node");
+		return tryGetSchema(node) ?? fail(0xb37 /* Not a tree node */);
 	},
 	shortId(node: TreeNode): number | string | undefined {
 		const schema = node[typeSchemaSymbol];
@@ -341,7 +346,7 @@ function getPropertyKeyFromStoredKey(
 	}
 
 	if (fields[storedKey] === undefined) {
-		fail("Existing stored key should always map to a property key");
+		fail(0xb38 /* Existing stored key should always map to a property key */);
 	}
 
 	return storedKey;

package/src/simple-tree/api/verboseTree.ts

@@ -172,7 +172,8 @@ export function applySchemaToParserOptions<TCustom>(
 			: {
 					encode: (type, key: FieldKey): string => {
 						// translate stored key into property key.
-						const simpleNodeSchema = context.schema.get(brand(type)) ?? fail("missing schema");
+						const simpleNodeSchema =
+							context.schema.get(brand(type)) ?? fail(0xb39 /* missing schema */);
 						if (isObjectNodeSchema(simpleNodeSchema)) {
 							const propertyKey = simpleNodeSchema.storedKeyToPropertyKey.get(key);
 							if (propertyKey !== undefined) {
@@ -193,10 +194,12 @@ export function applySchemaToParserOptions<TCustom>(
 						return key;
 					},
 					parse: (type, inputKey): FieldKey => {
-						const simpleNodeSchema = context.schema.get(brand(type)) ?? fail("missing schema");
+						const simpleNodeSchema =
+							context.schema.get(brand(type)) ?? fail(0xb3a /* missing schema */);
 						if (isObjectNodeSchema(simpleNodeSchema)) {
 							const info =
-								simpleNodeSchema.flexKeyMap.get(inputKey) ?? fail("missing field info");
+								simpleNodeSchema.flexKeyMap.get(inputKey) ??
+								fail(0xb3b /* missing field info */);
 							return info.storedKey;
 						}
 						return brand(inputKey);
@@ -345,7 +348,8 @@ function verboseFromCursorInner<TCustom>(
 	schema: ReadonlyMap<string, TreeNodeSchema>,
 ): VerboseTree<TCustom> {
 	const fields = customFromCursor(reader, options, schema, verboseFromCursorInner);
-	const nodeSchema = schema.get(reader.type) ?? fail("missing schema for type in cursor");
+	const nodeSchema =
+		schema.get(reader.type) ?? fail(0xb3c /* missing schema for type in cursor */);
 	if (nodeSchema.kind === NodeKind.Leaf) {
 		return fields as CustomTreeValue<TCustom>;
 	}

package/src/simple-tree/api/view.ts

@@ -250,7 +250,7 @@ export class ViewSchema {
 					this.viewSchemaAsStored.nodeSchema.get(adapter.output),
 				)
 			) {
-				fail("tree adapter for stored adapter.output should not be never");
+				fail(0xb3d /* tree adapter for stored adapter.output should not be never */);
 			}
 		}
 

package/src/simple-tree/arrayNode.ts

@@ -858,7 +858,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 	// Therefore it must include `length`,
 	// even though this "length" is never invoked (due to being shadowed by the proxy provided own property).
 	public get length(): number {
-		return fail("Proxy should intercept length");
+		return fail(0xadb /* Proxy should intercept length */);
 	}
 
 	public [Symbol.iterator](): IterableIterator<TreeNodeFromImplicitAllowedTypes<T>> {
@@ -1045,7 +1045,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 			throw new UsageError(`Concurrent editing and iteration is not allowed.`);
 		}
 		for (let i = 0; i < this.length; i++) {
-			yield this.at(i) ?? fail("Index is out of bounds");
+			yield this.at(i) ?? fail(0xadc /* Index is out of bounds */);
 			if (initialLastUpdatedStamp !== kernel.generationNumber) {
 				throw new UsageError(`Concurrent editing and iteration is not allowed.`);
 			}

package/src/simple-tree/core/getOrCreateNode.ts

@@ -31,7 +31,8 @@ export function getOrCreateNodeFromInnerNode(flexNode: InnerNode): TreeNode | Tr
 		return cached;
 	}
 
-	const classSchema = getSimpleNodeSchemaFromInnerNode(flexNode) ?? fail("Missing schema");
+	const classSchema =
+		getSimpleNodeSchemaFromInnerNode(flexNode) ?? fail(0xb3e /* Missing schema */);
 	const node = flexNode as unknown as InternalTreeNode;
 	// eslint-disable-next-line unicorn/prefer-ternary
 	if (typeof classSchema === "function") {

package/src/simple-tree/core/schemaCaching.ts

@@ -17,7 +17,7 @@ import { SimpleContextSlot, type Context } from "./context.js";
  */
 export function getSimpleNodeSchemaFromInnerNode(innerNode: InnerNode): TreeNodeSchema {
 	const context: Context = getSimpleContextFromInnerNode(innerNode);
-	return context.schema.get(innerNode.schema) ?? fail("missing schema from context");
+	return context.schema.get(innerNode.schema) ?? fail(0xb3f /* missing schema from context */);
 }
 
 /**