@fluidframework/tree 2.42.0 → 2.43.0

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

@@ -10,7 +10,6 @@ import {
 	type AnchorNode,
 	CursorLocationType,
 	type FieldKey,
-	type ITreeCursorSynchronous,
 	type FieldKindIdentifier,
 	type ITreeSubscriptionCursor,
 	type TreeNavigationResult,
@@ -75,14 +74,14 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements HydratedFlexTree
 
 	public constructor(
 		context: Context,
-		public readonly schema: TreeNodeSchemaIdentifier,
+		public readonly type: TreeNodeSchemaIdentifier,
 		cursor: ITreeSubscriptionCursor,
 		public readonly anchorNode: AnchorNode,
 		anchor: Anchor,
 	) {
 		super(context, cursor, anchor);
 		this.storedSchema =
-			context.schema.nodeSchema.get(this.schema) ?? fail(0xb14 /* missing schema */);
+			context.schema.nodeSchema.get(this.type) ?? 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);
@@ -92,10 +91,6 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements HydratedFlexTree
 		return true;
 	}
 
-	public borrowCursor(): ITreeCursorSynchronous {
-		return this.cursor as ITreeCursorSynchronous;
-	}
-
 	protected override tryMoveCursorToAnchor(
 		cursor: ITreeSubscriptionCursor,
 	): TreeNavigationResult {
@@ -115,6 +110,20 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements HydratedFlexTree
 		return this.cursor.value;
 	}
 
+	public readonly fields: Pick<Map<FieldKey, FlexTreeField>, typeof Symbol.iterator | "get"> =
+		{
+			get: (key: FieldKey): FlexTreeField | undefined => this.tryGetField(key),
+			[Symbol.iterator]: (): IterableIterator<[FieldKey, FlexTreeField]> =>
+				mapCursorFields(this.cursor, (cursor) => {
+					const key: FieldKey = cursor.getFieldKey();
+					const pair: [FieldKey, FlexTreeField] = [
+						key,
+						makeField(this.context, this.storedSchema.getFieldSchema(key).kind, cursor),
+					];
+					return pair;
+				}).values(),
+		};
+
 	public tryGetField(fieldKey: FieldKey): FlexTreeField | undefined {
 		const schema = this.storedSchema.getFieldSchema(fieldKey);
 		return inCursorField(this.cursor, fieldKey, (cursor) => {
@@ -132,7 +141,7 @@ export class LazyTreeNode extends LazyEntity<Anchor> implements HydratedFlexTree
 		});
 	}
 
-	public boxedIterator(): IterableIterator<FlexTreeField> {
+	public [Symbol.iterator](): IterableIterator<FlexTreeField> {
 		return mapCursorFields(this.cursor, (cursor) =>
 			makeField(
 				this.context,

package/src/feature-libraries/forest-summary/forestSummarizer.ts

@@ -8,6 +8,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 import type { IChannelStorageService } from "@fluidframework/datastore-definitions/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 import type {
+	IExperimentalIncrementalSummaryContext,
 	ISummaryTreeWithStats,
 	ITelemetryContext,
 } from "@fluidframework/runtime-definitions/internal";
@@ -95,22 +96,14 @@ export class ForestSummarizer implements Summarizable {
 		return stringify(encoded);
 	}
 
-	public getAttachSummary(
-		stringify: SummaryElementStringifier,
-		fullTree?: boolean,
-		trackState?: boolean,
-		telemetryContext?: ITelemetryContext,
-	): ISummaryTreeWithStats {
-		return createSingleBlobSummary(treeBlobKey, this.getTreeString(stringify));
-	}
-
-	public async summarize(
-		stringify: SummaryElementStringifier,
-		fullTree?: boolean,
-		trackState?: boolean,
-		telemetryContext?: ITelemetryContext,
-	): Promise<ISummaryTreeWithStats> {
-		return createSingleBlobSummary(treeBlobKey, this.getTreeString(stringify));
+	public summarize(props: {
+		stringify: SummaryElementStringifier;
+		fullTree?: boolean;
+		trackState?: boolean;
+		telemetryContext?: ITelemetryContext;
+		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext;
+	}): ISummaryTreeWithStats {
+		return createSingleBlobSummary(treeBlobKey, this.getTreeString(props.stringify));
 	}
 
 	public async load(

package/src/feature-libraries/index.ts

@@ -20,6 +20,7 @@ export {
 	mapTreeWithField,
 	type MapTreeFieldViewGeneric,
 	type MapTreeNodeViewGeneric,
+	type MinimalFieldMap,
 } from "./mapTreeCursor.js";
 export { buildForest } from "./object-forest/index.js";
 export {
@@ -157,7 +158,6 @@ export {
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
-	Skip,
 	type FlexTreeContext,
 	type FlexTreeHydratedContext,
 	type FlexTreeTypedField,

package/src/feature-libraries/mapTreeCursor.ts

@@ -42,19 +42,28 @@ export interface MapTreeNodeViewGeneric<TNode> extends NodeData {
 	 * This is the subset of map needed to view the tree.
 	 * Theoretically `Symbol.iterator` and "keys" are redundant.
 	 */
-	readonly fields: Pick<
-		Map<FieldKey, MapTreeFieldViewGeneric<TNode>>,
-		typeof Symbol.iterator | "get"
-	>;
+	readonly fields: MinimalFieldMap<MapTreeFieldViewGeneric<TNode>>;
+}
+
+/**
+ * A minimal map for the fields of a {@link MapTreeNodeViewGeneric}.
+ * @remarks
+ * Subset of map, so can be implemented by `Map<FieldKey, TField>`.
+ */
+export interface MinimalFieldMap<TField> {
+	[Symbol.iterator]: () => Iterator<[FieldKey, TField]>;
+	get: (key: FieldKey) => TField | undefined;
 }
 
 /**
  * A field in {@link MapTreeNodeViewGeneric}.
+ * @remarks
+ * Subset of array, so can be implemented by `TNode[]`.
  */
-export type MapTreeFieldViewGeneric<TNode> = Pick<
-	readonly TNode[],
-	typeof Symbol.iterator | "length"
->;
+export interface MapTreeFieldViewGeneric<TNode> {
+	readonly [Symbol.iterator]: () => Iterator<TNode>;
+	readonly length: number;
+}
 
 /**
  * Like {@link MapTree} but with the minimal properties needed for reading.

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

@@ -79,6 +79,8 @@ export class FieldKindWithEditor<
 			isNeverField(policy, originalData, {
 				kind: this.identifier,
 				types: originalTypes,
+				// Metadata is not used for this check.
+				persistedMetadata: undefined,
 			})
 		) {
 			return true;

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

@@ -154,6 +154,9 @@ export class ObjectForest implements IEditableForest, WithBreakable {
 								// Some detached fields may have multiple nodes, so we must treat them as sequences:
 								kind: FieldKinds.sequence.identifier,
 								types: new Set(documentRoot.map((node) => node.type)),
+
+								// Metadata is not used for schema checks
+								persistedMetadata: undefined,
 							};
 				const maybeError = isFieldInSchema(documentRoot, fieldSchema, {
 					schema,

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

@@ -13,7 +13,7 @@ import {
 	makeVersionDispatchingCodec,
 	withSchemaValidation,
 } from "../../codec/index.js";
-import { makeSchemaCodec, type Format as FormatV1 } from "../schema-index/index.js";
+import { makeSchemaCodec } from "../schema-index/index.js";
 
 import { EncodedSchemaChange } from "./schemaChangeFormat.js";
 import type { SchemaChange } from "./schemaChangeTypes.js";
@@ -25,7 +25,10 @@ import { SchemaVersion } from "../../core/index.js";
  * @returns The composed codec family.
  */
 export function makeSchemaChangeCodecs(options: ICodecOptions): ICodecFamily<SchemaChange> {
-	return makeCodecFamily([[SchemaVersion.v1, makeSchemaChangeCodecV1(options)]]);
+	return makeCodecFamily([
+		[SchemaVersion.v1, makeSchemaChangeCodecV1(options, SchemaVersion.v1)],
+		[SchemaVersion.v2, makeSchemaChangeCodecV1(options, SchemaVersion.v2)],
+	]);
 }
 
 /**
@@ -43,14 +46,16 @@ export function makeSchemaChangeCodec(
 }
 
 /**
- * Compose the v1 schema change codec.
+ * Compose the change codec using mostly v1 logic.
  * @param options - The codec options.
+ * @param schemaWriteVersion - The schema write version.
  * @returns The composed schema change codec.
  */
 function makeSchemaChangeCodecV1(
 	options: ICodecOptions,
+	schemaWriteVersion: SchemaVersion,
 ): IJsonCodec<SchemaChange, EncodedSchemaChange> {
-	const schemaCodec = makeSchemaCodec(options, SchemaVersion.v1);
+	const schemaCodec = makeSchemaCodec(options, schemaWriteVersion);
 	const schemaChangeCodec: IJsonCodec<SchemaChange, EncodedSchemaChange> = {
 		encode: (schemaChange) => {
 			assert(
@@ -58,8 +63,8 @@ function makeSchemaChangeCodecV1(
 				0x933 /* Inverse schema changes should never be transmitted */,
 			);
 			return {
-				new: schemaCodec.encode(schemaChange.schema.new) as FormatV1,
-				old: schemaCodec.encode(schemaChange.schema.old) as FormatV1,
+				new: schemaCodec.encode(schemaChange.schema.new),
+				old: schemaCodec.encode(schemaChange.schema.old),
 			};
 		},
 		decode: (encoded) => {

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

@@ -4,11 +4,11 @@
  */
 
 import { type Static, Type } from "@sinclair/typebox";
-import { Format as FormatV1 } from "../schema-index/index.js";
+import { JsonCompatibleReadOnlySchema } from "../../util/index.js";
 
 export const EncodedSchemaChange = Type.Object({
-	new: FormatV1,
-	old: FormatV1,
+	new: JsonCompatibleReadOnlySchema,
+	old: JsonCompatibleReadOnlySchema,
 });
 
 export type EncodedSchemaChange = Static<typeof EncodedSchemaChange>;

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

@@ -20,13 +20,14 @@ import {
 	type TreeNodeStoredSchema,
 	type TreeStoredSchema,
 	decodeFieldSchema,
-	encodeFieldSchema,
-	type schemaFormatV1,
+	encodeFieldSchemaV1,
+	encodeFieldSchemaV2,
 	storedSchemaDecodeDispatcher,
 } from "../../core/index.js";
 import { brand, type JsonCompatible } from "../../util/index.js";
 
 import { Format as FormatV1 } from "./formatV1.js";
+import { Format as FormatV2 } from "./formatV2.js";
 
 /**
  * Convert a FluidClientVersion to a SchemaVersion.
@@ -62,7 +63,10 @@ export function makeSchemaCodec(
  * @returns The composed codec family.
  */
 export function makeSchemaCodecs(options: ICodecOptions): ICodecFamily<TreeStoredSchema> {
-	return makeCodecFamily([[SchemaVersion.v1, makeSchemaCodecV1(options)]]);
+	return makeCodecFamily([
+		[SchemaVersion.v1, makeSchemaCodecV1(options)],
+		[SchemaVersion.v2, makeSchemaCodecV2(options)],
+	]);
 }
 
 /**
@@ -74,36 +78,79 @@ export function makeSchemaCodecs(options: ICodecOptions): ICodecFamily<TreeStore
 export function encodeRepo(repo: TreeStoredSchema, version: SchemaVersion): JsonCompatible {
 	switch (version) {
 		case SchemaVersion.v1:
-			return encodeRepoV1(repo);
+			return encodeRepoV1(repo) as JsonCompatible;
+		case SchemaVersion.v2:
+			return encodeRepoV2(repo) as JsonCompatible;
 		default:
 			unreachableCase(version);
 	}
 }
 
 function encodeRepoV1(repo: TreeStoredSchema): FormatV1 {
-	const nodeSchema: Record<string, schemaFormatV1.TreeNodeSchemaDataFormat> =
-		Object.create(null);
-	const rootFieldSchema = encodeFieldSchema(repo.rootFieldSchema);
+	const nodeSchema = encodeNodeSchema(repo, (schema) => schema.encodeV1());
+	const rootFieldSchema = encodeFieldSchemaV1(repo.rootFieldSchema);
+	return {
+		version: SchemaVersion.v1,
+		nodes: nodeSchema,
+		root: rootFieldSchema,
+	};
+}
+
+function encodeRepoV2(repo: TreeStoredSchema): FormatV2 {
+	const nodeSchema = encodeNodeSchema(repo, (schema) => schema.encodeV2());
+	const rootFieldSchema = encodeFieldSchemaV2(repo.rootFieldSchema);
+	return {
+		version: SchemaVersion.v2,
+		nodes: nodeSchema,
+		root: rootFieldSchema,
+	};
+}
+
+/**
+ * Shared logic for encoding node schemas.
+ * @param repo - The stored schema to encode.
+ * @param encodeValue - A function which encodes a single node schema.
+ * @returns The encoded node schema.
+ */
+function encodeNodeSchema<TFormat>(
+	repo: TreeStoredSchema,
+	encodeValue: (schema: TreeNodeStoredSchema) => TFormat,
+): Record<string, TFormat> {
+	const nodeSchema: Record<string, TFormat> = Object.create(null);
 	for (const name of [...repo.nodeSchema.keys()].sort()) {
 		const schema = repo.nodeSchema.get(name) ?? fail(0xb28 /* missing schema */);
 		Object.defineProperty(nodeSchema, name, {
 			enumerable: true,
 			configurable: true,
 			writable: true,
-			value: schema.encode(),
+			value: encodeValue(schema),
 		});
 	}
+
+	return nodeSchema;
+}
+
+function decodeV1(f: FormatV1): TreeStoredSchema {
+	const nodeSchema: Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> = new Map();
+	for (const [key, schema] of Object.entries(f.nodes)) {
+		const storedSchemaDecoder = storedSchemaDecodeDispatcher.dispatch(schema);
+
+		// No metadata in v1, so pass undefined
+		nodeSchema.set(brand(key), storedSchemaDecoder(undefined));
+	}
 	return {
-		version: SchemaVersion.v1,
-		nodes: nodeSchema,
-		root: rootFieldSchema,
+		rootFieldSchema: decodeFieldSchema(f.root),
+		nodeSchema,
 	};
 }
 
-function decode(f: FormatV1): TreeStoredSchema {
+function decodeV2(f: FormatV2): TreeStoredSchema {
 	const nodeSchema: Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> = new Map();
 	for (const [key, schema] of Object.entries(f.nodes)) {
-		nodeSchema.set(brand(key), storedSchemaDecodeDispatcher.dispatch(schema));
+		const storedSchemaDecoder = storedSchemaDecodeDispatcher.dispatch(schema.kind);
+
+		// Pass in the node metadata
+		nodeSchema.set(brand(key), storedSchemaDecoder(schema.metadata));
 	}
 	return {
 		rootFieldSchema: decodeFieldSchema(f.root),
@@ -119,6 +166,18 @@ function decode(f: FormatV1): TreeStoredSchema {
 function makeSchemaCodecV1(options: ICodecOptions): IJsonCodec<TreeStoredSchema, FormatV1> {
 	return makeVersionedValidatedCodec(options, new Set([SchemaVersion.v1]), FormatV1, {
 		encode: (data: TreeStoredSchema) => encodeRepoV1(data),
-		decode: (data: FormatV1) => decode(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([SchemaVersion.v2]), FormatV2, {
+		encode: (data: TreeStoredSchema) => encodeRepoV2(data),
+		decode: (data: FormatV2) => decodeV2(data),
 	});
 }

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

@@ -0,0 +1,30 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { type ObjectOptions, type Static, Type } from "@sinclair/typebox";
+
+import { SchemaVersion, schemaFormatV2 } from "../../core/index.js";
+
+const noAdditionalProps: ObjectOptions = { additionalProperties: false };
+
+/**
+ * Format for encoding as json.
+ *
+ * For consistency all lists are sorted and undefined values are omitted.
+ *
+ * This chooses to use lists of named objects instead of maps:
+ * this choice is somewhat arbitrary, but avoids user data being used as object keys,
+ * which can sometimes be an issue (for example handling that for "__proto__" can require care).
+ * It also makes it simpler to determinately sort by keys.
+ */
+export const Format = Type.Object(
+	{
+		version: Type.Literal(SchemaVersion.v2),
+		nodes: Type.Record(Type.String(), schemaFormatV2.TreeNodeSchemaDataFormat),
+		root: schemaFormatV2.FieldSchemaFormat,
+	},
+	noAdditionalProps,
+);
+export type Format = Static<typeof Format>;

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

@@ -9,4 +9,5 @@ export {
 	makeSchemaCodecs,
 	clientVersionToSchemaVersion,
 } from "./codec.js";
-export { Format } from "./formatV1.js";
+export { Format as FormatV1 } from "./formatV1.js";
+export { Format as FormatV2 } from "./formatV2.js";

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

@@ -51,15 +51,18 @@ export class SchemaSummarizer implements Summarizable {
 		});
 	}
 
-	public getAttachSummary(
-		stringify: SummaryElementStringifier,
-		fullTree?: boolean,
-		trackState?: boolean,
-		telemetryContext?: ITelemetryContext,
-		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext | undefined,
-	): ISummaryTreeWithStats {
+	public summarize(props: {
+		stringify: SummaryElementStringifier;
+		fullTree?: boolean;
+		trackState?: boolean;
+		telemetryContext?: ITelemetryContext;
+		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext;
+	}): ISummaryTreeWithStats {
+		const incrementalSummaryContext = props.incrementalSummaryContext;
 		const builder = new SummaryTreeBuilder();
+		const fullTree = props.fullTree ?? false;
 		if (
+			!fullTree &&
 			incrementalSummaryContext !== undefined &&
 			this.schemaIndexLastChangedSeq !== undefined &&
 			incrementalSummaryContext.latestSummarySequenceNumber >= this.schemaIndexLastChangedSeq
@@ -67,7 +70,7 @@ export class SchemaSummarizer implements Summarizable {
 			builder.addHandle(
 				schemaStringKey,
 				SummaryType.Blob,
-				`${incrementalSummaryContext.summaryPath}/indexes/${this.key}/${schemaStringKey}`,
+				`${incrementalSummaryContext.summaryPath}/${schemaStringKey}`,
 			);
 		} else {
 			const dataString = JSON.stringify(this.codec.encode(this.schema));
@@ -76,16 +79,6 @@ export class SchemaSummarizer implements Summarizable {
 		return builder.getSummaryTree();
 	}
 
-	public async summarize(
-		stringify: SummaryElementStringifier,
-		fullTree?: boolean,
-		trackState?: boolean,
-		telemetryContext?: ITelemetryContext,
-		incrementalSummaryContext?: IExperimentalIncrementalSummaryContext | undefined,
-	): Promise<ISummaryTreeWithStats> {
-		throw new Error("Method not implemented.");
-	}
-
 	public async load(
 		services: IChannelStorageService,
 		parse: SummaryElementParser,

package/src/index.ts

@@ -113,6 +113,7 @@ export {
 	type TreeNodeSchemaClass,
 	type SchemaCompatibilityStatus,
 	type FieldProps,
+	type FieldPropsAlpha,
 	type InternalTreeNode,
 	type WithType,
 	type NodeChangedData,
@@ -157,6 +158,7 @@ export {
 	type ImplicitAnnotatedFieldSchema,
 	type AnnotatedAllowedType,
 	type AnnotatedAllowedTypes,
+	type NormalizedAnnotatedAllowedTypes,
 	type AllowedTypeMetadata,
 	type AllowedTypesMetadata,
 	type InsertableObjectFromAnnotatedSchemaRecord,
@@ -198,6 +200,7 @@ export {
 	type LazyItem,
 	type Unenforced,
 	type SimpleNodeSchemaBase,
+	type SimpleNodeSchemaBaseAlpha,
 	type SimpleTreeSchema,
 	type SimpleNodeSchema,
 	type SimpleFieldSchema,
@@ -215,6 +218,7 @@ export {
 	type TreeBranchEvents,
 	asTreeViewAlpha,
 	type NodeSchemaOptions,
+	type NodeSchemaOptionsAlpha,
 	type NodeSchemaMetadata,
 	type SchemaStatics,
 	type ITreeAlpha,
@@ -282,6 +286,8 @@ export type {
 	PopUnion,
 	JsonCompatible,
 	JsonCompatibleObject,
+	JsonCompatibleReadOnly,
+	JsonCompatibleReadOnlyObject,
 } from "./util/index.js";
 export { cloneWithReplacements } from "./util/index.js";
 

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.42.0";
+export const pkgVersion = "2.43.0";

package/src/shared-tree/schematizeTree.ts

@@ -68,6 +68,7 @@ export function initializeContent(
 			rootFieldSchema: {
 				kind: FieldKinds.optional.identifier,
 				types: rootSchema.types,
+				persistedMetadata: rootSchema.persistedMetadata,
 			},
 		};
 	}

package/src/shared-tree/schematizingTreeView.ts

@@ -22,12 +22,11 @@ import {
 	TreeStatus,
 } from "../feature-libraries/index.js";
 import {
-	type FieldSchema,
 	type ImplicitFieldSchema,
 	type SchemaCompatibilityStatus,
 	type TreeView,
 	type TreeViewEvents,
-	getTreeNodeForField,
+	tryGetTreeNodeForField,
 	setField,
 	normalizeFieldSchema,
 	SchemaCompatibilityTester,
@@ -53,6 +52,7 @@ import {
 	areImplicitFieldSchemaEqual,
 	createUnknownOptionalFieldPolicy,
 	prepareForInsertionContextless,
+	type FieldSchema,
 } from "../simple-tree/index.js";
 import {
 	type Breakable,
@@ -353,7 +353,10 @@ export class SchematizingSimpleTreeView<
 			);
 			this.checkout.forest.anchors.slots.set(
 				SimpleContextSlot,
-				new HydratedContext(this.rootFieldSchema.allowedTypeSet, view.context),
+				new HydratedContext(
+					normalizeFieldSchema(this.rootFieldSchema).annotatedAllowedTypesNormalized,
+					view.context,
+				),
 			);
 
 			const unregister = this.checkout.storedSchema.events.on("afterSchemaChange", () => {
@@ -428,7 +431,7 @@ export class SchematizingSimpleTreeView<
 			);
 		}
 		const view = this.getView();
-		return getTreeNodeForField(view.flexTree) as ReadableField<TRootSchema>;
+		return tryGetTreeNodeForField(view.flexTree) as ReadableField<TRootSchema>;
 	}
 
 	public set root(newRoot: InsertableField<TRootSchema>) {
@@ -525,7 +528,7 @@ export function addConstraintsToTransaction(
 						`Attempted to add a "nodeInDocument" constraint${revertText}, but the node is not currently in the document. Node status: ${nodeStatus}`,
 					);
 				}
-				assert(node.isHydrated(), "In document node must be hydrated.");
+				assert(node.isHydrated(), 0xbc2 /* In document node must be hydrated. */);
 				if (constraintsOnRevert) {
 					checkout.editor.addNodeExistsConstraintOnRevert(node.anchorNode);
 				} else {