@fluidframework/tree 2.110.0 → 2.112.0

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

@@ -7,7 +7,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import type { DiscriminatedUnionDispatcher } from "../../../codec/index.js";
 import type { TreeChunk } from "../../../core/index.js";
-import type { BrandedType } from "../../../util/index.js";
+import type { BrandedType, IdDecodingContext } from "../../../util/index.js";
 
 import {
 	type ChunkDecoder,
@@ -15,7 +15,6 @@ import {
 	getChecked,
 	readStream,
 } from "./chunkCodecUtilities.js";
-import type { IdDecodingContext } from "./chunkDecoding.js";
 import type { IncrementalDecoder } from "./codecs.js";
 import type { EncodedFieldBatchGeneric, IdentifierOrIndex } from "./format/index.js";
 

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

@@ -4,7 +4,7 @@
  */
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
-import type { IIdCompressor, SessionId } from "@fluidframework/id-compressor";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 import { lowestMinVersionForCollab } from "@fluidframework/runtime-utils/internal";
 import type { TSchema } from "@sinclair/typebox";
 
@@ -22,7 +22,13 @@ import {
 	type StoredSchemaCollection,
 	type TreeChunk,
 } from "../../../core/index.js";
-import { brandedNumberType, type Brand } from "../../../util/index.js";
+import {
+	brandedNumberType,
+	IdDecodingContext,
+	type Brand,
+	type IdDecoderOptionsOriginatorless,
+	type IdDecoderOptionsWithOriginator,
+} from "../../../util/index.js";
 import { TreeCompressionStrategy } from "../../treeCompressionUtils.js";
 
 import { decode } from "./chunkDecoding.js";
@@ -97,44 +103,116 @@ export interface IncrementalDecoder {
  */
 export interface IncrementalEncoderDecoder extends IncrementalEncoder, IncrementalDecoder {}
 
+/**
+ * Encode-side context for {@link FieldBatchCodec}.
+ *
+ * Carries only the data the encoder actually consumes. Originator-session
+ * lookup, heal flags, and the incremental *decoder* live on
+ * {@link FieldBatchDecodingContext}.
+ */
 export interface FieldBatchEncodingContext {
 	readonly encodeType: TreeCompressionStrategy;
 	readonly idCompressor: IIdCompressor;
-	readonly originatorId: SessionId;
 	readonly schema?: SchemaAndPolicy;
 	/**
-	 * An encoder / decoder for encoding and decoding of incremental fields.
-	 * This will be defined if incremental encoding is supported and enabled.
+	 * Encoder for incremental fields. Defined when incremental encoding is
+	 * supported and enabled.
 	 */
-	readonly incrementalEncoderDecoder?: IncrementalEncoderDecoder;
+	readonly incrementalEncoder?: IncrementalEncoder;
 	/**
-	 * `true` when encoding to or decoding from a summary blob. `false` for
-	 * op-stream encode/decode paths and for utility encoders that are not
-	 * tied to a persisted document. Healing behavior is gated on this flag.
+	 * `true` when encoding to a summary blob. `false` for op-stream encode
+	 * paths and for utility encoders that aren't tied to a persisted document.
+	 *
+	 * @remarks
+	 * Used by the node encoder to decide whether non-finalized op-space ids
+	 * can be written into the batch (they can't, for summaries).
 	 */
 	readonly isSummary: boolean;
+}
+
+/**
+ * Decode-side context for {@link FieldBatchCodec}.
+ *
+ * Carries the per-call `resolveEncodedId` function that encapsulates the
+ * originator-session lookup and (for the forest-summarizer's legacy heal path)
+ * the deterministic UUIDv5 synthesis. Heal and originator-session flags live
+ * inside that function, not on this context.
+ *
+ * Constructed via one of the two named static factories — {@link forOp} or
+ * {@link forSummary} — depending on the call site's semantics. The constructor
+ * is private; there is no general-purpose builder, because the choice between
+ * op-style and summary-style decoding is load-bearing (different invariants
+ * apply, and bugs in this area are typically the result of conflating them).
+ */
+export class FieldBatchDecodingContext extends IdDecodingContext {
+	private constructor(
+		private readonly options: IdDecoderOptionsOriginatorless | IdDecoderOptionsWithOriginator,
+		/**
+		 * Decoder for incremental fields. Defined when the encoded batch contains
+		 * incremental chunks. Only populated on summary-style contexts; op-style
+		 * contexts always have this undefined.
+		 */
+		public readonly incrementalDecoder?: IncrementalDecoder,
+	) {
+		super(options);
+	}
+
 	/**
-	 * If `true`, when an op-space compressed ID encountered while decoding
-	 * cannot be resolved by the local id-compressor (e.g. the attach-summary
-	 * blob's originator session state was stripped), a deterministic stable
-	 * UUID derived from `sharedObjectId` is returned instead of throwing.
-	 * @remarks
-	 * Off by default. Used only to recover documents whose attach summary was
-	 * written with non-finalized op-space IDs before the encode-side fix
-	 * shipped. Only takes effect when `isSummary` is also `true`.
-	 * See {@link SharedTreeOptionsBeta.healUnresolvableIdentifiersOnDecode}.
+	 * Construct a decode context for an op.
+	 *
+	 * The originator is the session that produced the encoded form (carried
+	 * alongside the op envelope by the caller). Heal-on-decode is *not*
+	 * available — an unresolvable id during op decode indicates a real bug,
+	 * not a recoverable state, so the resolver throws rather than synthesizing
+	 * a UUID. Incremental decoding is not used for ops.
 	 */
-	readonly healUnresolvableIdentifiersOnDecode?: boolean;
+	public static forOp(options: IdDecoderOptionsWithOriginator): FieldBatchDecodingContext {
+		return new FieldBatchDecodingContext(options);
+	}
+
 	/**
-	 * The SharedTree's shared-object id, used as input to the deterministic
-	 * UUID derivation when `healUnresolvableIdentifiersOnDecode` triggers. Required
-	 * for that path; ignored otherwise.
-	 * @remarks
-	 * This allows us to ensure that multiple attaches,
-	 * in the same or different documents, with the same session offsets, get different UUIDs.
+	 * Construct a decode context for a summary blob.
+	 *
+	 * Summaries must contain only ids resolvable without an originator — either
+	 * finalized op-space ids, or (when {@link IdentifierHealingConfig} is supplied
+	 * via `healing`) non-final ids that get healed into deterministic UUIDv5
+	 * strings. Incremental decoding is attached via {@link withIncrementalDecoder}.
+	 *
+	 * @privateRemarks
+	 * In the future (if adding a summary format which includes the session id),
+	 * this could allow providing an originator ID to allow for op-space compressed identifiers in attach summaries.
+	 * Non-attach summaries should only have finalized compressed identifiers (due to only being made by summary clients which never allocate identifiers since they never edit).
+	 * Since only non-attach summaries can be incremental, incremental summaries should never have non finalized identifiers.
+	 * `withIncrementalDecoder` has logic to guard against cases which expect session-relative identifiers in incremental chunks,
+	 * as does the encoding-side assert in the {@link EncoderContext}.
+	 */
+	public static forSummary(
+		options: IdDecoderOptionsOriginatorless | IdDecoderOptionsWithOriginator,
+	): FieldBatchDecodingContext {
+		return new FieldBatchDecodingContext(options);
+	}
+
+	/**
+	 * Returns a copy of this context with `incrementalDecoder` swapped in. Used by
+	 * the forest summarizer to attach the per-call incremental builder to a base
+	 * decode context.
 	 */
-	readonly sharedObjectId?: string;
+	public withIncrementalDecoder(
+		incrementalDecoder: IncrementalDecoder,
+	): FieldBatchDecodingContext {
+		// As different incremental chunks may come from different sessions,
+		// for now we simply enforce that we do not provide an originator session ID
+		// when we might be dealing with incremental chunks.
+		// This mitigates the risk of using incorrect originator session ID identifiers in incremental chunks.
+		// See also private remarks on forSummary.
+		assert(
+			!this.hasOriginatorSessionId,
+			0xd0c /* withIncrementalDecoder can only be called on contexts without an originator session ID */,
+		);
+		return new FieldBatchDecodingContext(this.options, incrementalDecoder);
+	}
 }
+
 /**
  * @remarks
  * Fields in this batch currently don't have field schema for the root, which limits optimizations.
@@ -142,7 +220,8 @@ export interface FieldBatchEncodingContext {
 export type FieldBatchCodec = VersionDispatchingCodec<
 	FieldBatch,
 	FieldBatchEncodingContext,
-	FieldBatchFormatVersion
+	FieldBatchFormatVersion,
+	FieldBatchDecodingContext
 >;
 
 /**
@@ -160,7 +239,7 @@ function makeFieldBatchCodecForVersion(
 		isSummary: boolean,
 	) => EncodedFieldBatchV1OrV2,
 	encodedFieldBatchType: TSchema,
-): CodecAndSchema<FieldBatch, FieldBatchEncodingContext> {
+): CodecAndSchema<FieldBatch, FieldBatchEncodingContext, FieldBatchDecodingContext> {
 	return {
 		encode: (
 			data: FieldBatch,
@@ -185,7 +264,7 @@ function makeFieldBatchCodecForVersion(
 						0xca0 /* Unsupported FieldBatchFormatVersion for incremental encoding; must be v2 or higher */,
 					);
 					// Incremental encoding is only supported for CompressedIncremental.
-					incrementalEncoder = context.incrementalEncoderDecoder;
+					incrementalEncoder = context.incrementalEncoder;
 				}
 				// fallthrough
 				case TreeCompressionStrategy.Compressed: {
@@ -216,20 +295,10 @@ function makeFieldBatchCodecForVersion(
 		},
 		decode: (
 			data: EncodedFieldBatchV1OrV2,
-			context: FieldBatchEncodingContext,
+			context: FieldBatchDecodingContext,
 		): FieldBatch => {
 			// TODO: consider checking data is in schema.
-			return decode(
-				data,
-				{
-					idCompressor: context.idCompressor,
-					originatorId: context.originatorId,
-					isSummary: context.isSummary,
-					healUnresolvableIdentifiersOnDecode: context.healUnresolvableIdentifiersOnDecode,
-					sharedObjectId: context.sharedObjectId,
-				},
-				context.incrementalEncoderDecoder,
-			).map((chunk) => chunk.cursor());
+			return decode(data, context, context.incrementalDecoder).map((chunk) => chunk.cursor());
 		},
 		schema: encodedFieldBatchType,
 	};

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

@@ -18,7 +18,13 @@ import {
 	type Value,
 	forEachNode,
 } from "../../../core/index.js";
-import { getOrCreate } from "../../../util/index.js";
+import {
+	EncodedIdType,
+	encodePossiblyCompressedId,
+	getOrCreate,
+	type EncodedId,
+	type IdEncodingContext,
+} from "../../../util/index.js";
 
 import type { Counter, DeduplicationTable } from "./chunkCodecUtilities.js";
 import {
@@ -520,7 +526,9 @@ export function encodeValue(
  * - Singletons defined in a static scope.
  * - Cached in this object for future reuse such that all equivalent Shapes are deduplicated.
  */
-export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
+export class EncoderContext
+	implements NodeEncodeBuilder, FieldEncodeBuilder, IdEncodingContext
+{
 	private readonly nodeEncodersFromSchema: Map<TreeNodeSchemaIdentifier, NodeEncoder> =
 		new Map();
 	private readonly nestedArrayEncoders: Map<NodeEncoder, NestedArrayEncoder> = new Map();
@@ -528,7 +536,7 @@ export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
 		private readonly nodeEncoderFromPolicy: NodeEncoderPolicy,
 		private readonly fieldEncoderFromPolicy: FieldEncoderPolicy,
 		public readonly fieldShapes: ReadonlyMap<FieldKindIdentifier, FieldKindData>,
-		public readonly idCompressor: IIdCompressor,
+		private readonly idCompressor: IIdCompressor,
 		/**
 		 * To be used to encode incremental chunks, if any.
 		 * @remarks
@@ -540,7 +548,27 @@ export class EncoderContext implements NodeEncodeBuilder, FieldEncodeBuilder {
 		 * See {@link FieldBatchEncodingContext.isSummary}.
 		 */
 		public readonly isSummary: boolean,
-	) {}
+	) {
+		// Currently we never include originator-dependent identifiers in summaries
+		// (there was a bug which violated this for attach-summaries: it has been fixed, see `IdentifierHealingConfig`).
+		// If that ever changes (to allow better compressed attach summaries), we need to take special care with incremental summaries.
+		// This assert guards against data corruption leaking in via missing session information in incremental summaries,
+		// protecting from bugs of potential future optimizations to attach summaries applied to non-attach summaries.
+		// Incremental summaries should have no need for originator-dependent identifiers,
+		// as they can't be attach summaries which are the only ones which should ever have non-final ids.
+		assert(
+			isSummary || incrementalEncoder === undefined,
+			0xd0d /* incrementalEncoder cannot be used when encoding originator-dependent identifiers */,
+		);
+	}
+
+	public encodePossiblyCompressedId(id: string): string | EncodedId<EncodedIdType> {
+		return encodePossiblyCompressedId(
+			id,
+			this.idCompressor,
+			this.isSummary ? EncodedIdType.Originatorless : EncodedIdType.OriginatorDependent,
+		);
+	}
 
 	public nodeEncoderFromSchema(schemaName: TreeNodeSchemaIdentifier): NodeEncoder {
 		return getOrCreate(this.nodeEncodersFromSchema, schemaName, () =>

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

@@ -13,6 +13,7 @@ export type { FieldBatch } from "./fieldBatch.js";
 export {
 	type FieldBatchCodec,
 	fieldBatchCodecBuilder,
+	FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 	type IncrementalEncoderDecoder,
 	type IncrementalEncoder,

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

@@ -4,7 +4,6 @@
  */
 
 import { assert, fail } from "@fluidframework/core-utils/internal";
-import { isFinalId, isStableId } from "@fluidframework/id-compressor/internal";
 
 import {
 	type FieldKey,
@@ -24,10 +23,11 @@ import {
 	type NodeEncoder,
 	encodeValue,
 } from "./compressedEncode.js";
-import type {
-	EncodedChunkShape,
-	EncodedFieldShape,
-	EncodedValueShape,
+import {
+	SpecialField,
+	type EncodedChunkShape,
+	type EncodedFieldShape,
+	type EncodedValueShape,
 } from "./format/index.js";
 
 /**
@@ -69,21 +69,9 @@ export class NodeShapeBasedEncoder extends Shape<EncodedChunkShape> implements N
 	}
 
 	private getValueToEncode(cursor: ITreeCursorSynchronous, context: EncoderContext): Value {
-		if (this.value === 0) {
+		if (this.value === SpecialField.Identifier) {
 			assert(typeof cursor.value === "string", 0x9aa /* identifier must be type string */);
-			if (isStableId(cursor.value)) {
-				const sessionSpaceCompressedId = context.idCompressor.tryRecompress(cursor.value);
-				if (sessionSpaceCompressedId !== undefined) {
-					const opSpaceId = context.idCompressor.normalizeToOpSpace(sessionSpaceCompressedId);
-					// Summaries can only contain finalized op-space ids unless they also include the originator's session id somewhere.
-					// This is not the case for forest summaries at the time of writing, so non-finalized ids are instead written using
-					// their long form (by falling through to the original cursor value).
-					// A scenario where such ids can appear in the summary is in the attach summary of a tree being attached to an already-attached container.
-					if (!context.isSummary || isFinalId(opSpaceId)) {
-						return opSpaceId;
-					}
-				}
-			}
+			return context.encodePossiblyCompressedId(cursor.value);
 		}
 		return cursor.value;
 	}

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

@@ -20,7 +20,10 @@ export {
 	type FieldBatch,
 	type FieldBatchCodec,
 	fieldBatchCodecBuilder,
+	FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
+	type IncrementalDecoder,
+	type IncrementalEncoder,
 	type IncrementalEncoderDecoder,
 	type ChunkReferenceId,
 	type IncrementalEncodingPolicy,

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

@@ -16,6 +16,7 @@ import {
 import type { FieldKey, ITreeCursorSynchronous } from "../../core/index.js";
 import {
 	fieldBatchCodecBuilder,
+	type FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 } from "../chunked-forest/index.js";
 
@@ -28,13 +29,14 @@ export type FieldSet = ReadonlyMap<FieldKey, ITreeCursorSynchronous>;
 export type ForestCodec = VersionDispatchingCodec<
 	FieldSet,
 	FieldBatchEncodingContext,
-	ForestFormatVersion
+	ForestFormatVersion,
+	FieldBatchDecodingContext
 >;
 
 function makeForestSummarizerCodec(
 	options: CodecWriteOptions,
 	version: ForestFormatVersion,
-): CodecAndSchema<FieldSet, FieldBatchEncodingContext> {
+): CodecAndSchema<FieldSet, FieldBatchEncodingContext, FieldBatchDecodingContext> {
 	// Performance: Since multiple places (including multiple versions of this codec) use the field batch codec,
 	// we may end up with multiple copies of it, including compiling its format validation multiple times.
 	// This is not ideal, but is not too bad as it is a small fixed number of copies and thus should not be too expensive.
@@ -55,7 +57,7 @@ function makeForestSummarizerCodec(
 				version,
 			};
 		},
-		decode: (data: FormatCommon, context: FieldBatchEncodingContext): FieldSet => {
+		decode: (data: FormatCommon, context: FieldBatchDecodingContext): FieldSet => {
 			const out: Map<FieldKey, ITreeCursorSynchronous> = new Map();
 			const fields = fieldBatchCodec.decode(data.fields, context);
 			assert(data.keys.length === fields.length, 0x891 /* mismatched lengths */);

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

@@ -41,6 +41,7 @@ import {
 import { chunkFieldSingle, defaultChunkPolicy } from "../chunked-forest/chunkTree.js";
 import {
 	defaultIncrementalEncodingPolicy,
+	type FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 	type IncrementalEncodingPolicy,
 } from "../chunked-forest/index.js";
@@ -80,6 +81,7 @@ export class ForestSummarizer
 		private readonly forest: IEditableForest,
 		private readonly revisionTagCodec: RevisionTagCodec,
 		private readonly encoderContext: FieldBatchEncodingContext,
+		private readonly decoderContext: FieldBatchDecodingContext,
 		options: CodecWriteOptions,
 		private readonly idCompressor: IIdCompressor,
 		initialSequenceNumber: number,
@@ -160,7 +162,7 @@ export class ForestSummarizer
 		});
 		const encoderContext: FieldBatchEncodingContext = {
 			...this.encoderContext,
-			incrementalEncoderDecoder:
+			incrementalEncoder:
 				incrementalSummaryBehavior === ForestIncrementalSummaryBehavior.Incremental
 					? this.incrementalSummaryBuilder
 					: undefined,
@@ -212,10 +214,7 @@ export class ForestSummarizer
 				parse,
 				// TODO: this type cast assumes there are no handles, which should probably be enforced at runtime or the need for this cast should be removed altogether.
 			)) as JsonCompatibleReadOnly,
-			{
-				...this.encoderContext,
-				incrementalEncoderDecoder: this.incrementalSummaryBuilder,
-			},
+			this.decoderContext.withIncrementalDecoder(this.incrementalSummaryBuilder),
 		);
 		const allocator = idAllocatorFromMaxId();
 		const fieldChanges: [FieldKey, DeltaFieldChanges][] = [];

package/src/feature-libraries/index.ts

@@ -93,6 +93,7 @@ export {
 	isNeverTree,
 	DefaultRevisionReplacer,
 	ModularChangeFormatVersion,
+	minimizeModularChangeset,
 } from "./modular-schema/index.js";
 
 export { mapRootChanges } from "./deltaUtils.js";
@@ -109,11 +110,14 @@ export {
 	FieldBatchFormatVersion,
 	makeTreeChunker,
 	fieldBatchCodecBuilder,
+	FieldBatchDecodingContext,
 	type FieldBatchEncodingContext,
 	emptyChunk,
 	combineChunks,
 	type IncrementalEncodingPolicy,
 	defaultIncrementalEncodingPolicy,
+	type IncrementalDecoder,
+	type IncrementalEncoder,
 } from "./chunked-forest/index.js";
 
 export {
@@ -146,6 +150,7 @@ export {
 
 export {
 	SchemaValidationError,
+	type SchemaValidationErrorContext,
 	isNodeInSchema,
 	isFieldInSchema,
 	throwOutOfSchema,

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

@@ -83,3 +83,4 @@ export type {
 	FieldKindConfigurationEntry,
 } from "./fieldKindConfiguration.js";
 export { DefaultRevisionReplacer } from "./defaultRevisionReplacer.js";
+export { minimizeModularChangeset } from "./minimizeModularChange.js";

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

@@ -0,0 +1,33 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import type { FieldKindIdentifier } from "../../core/index.js";
+
+import type { FlexFieldKind } from "./fieldKind.js";
+import type { ModularChangeset } from "./modularChangeTypes.js";
+
+/**
+ * "Minimizes" a {@link ModularChangeset} so that it contains no extraneous
+ * information, i.e. no new content that isn't observable from document tree
+ * and no edits without net observed effect on the document tree.
+ * @remarks
+ * "Extraneous information" includes, for example, data for nodes that were both created and removed within the same
+ * transaction, or changes whose effects cancel out to nothing. Minimizing reduces the size of an edit without altering
+ * its observable effect.
+ *
+ * This is the eventual home of the minimization algorithm, colocated with {@link ModularChangeFamily} so it can use its
+ * internals. It is currently a no-op that returns the change unchanged; a real implementation will be provided in a
+ * future change.
+ *
+ * @param change - The change to minimize.
+ * @param fieldKinds - The field kinds to delegate to when computing the change's delta.
+ */
+export function minimizeModularChangeset(
+	change: ModularChangeset,
+	fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind>,
+): ModularChangeset {
+	// TODO: Actually minimize the change. For now this is a no-op that returns the change unchanged.
+	return change;
+}

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

@@ -35,6 +35,7 @@ import {
 import { newChangeAtomIdBTree, type ChangeAtomIdBTree } from "../changeAtomIdBTree.js";
 import {
 	type FieldBatchCodec,
+	FieldBatchDecodingContext,
 	type TreeChunk,
 	chunkFieldSingle,
 	defaultChunkPolicy,
@@ -328,7 +329,6 @@ export function encodeDetachedNodes(
 				trees: fieldsCodec.encode(treesToEncode, {
 					encodeType: chunkCompressionStrategy,
 					schema: context.schema,
-					originatorId: context.originatorId,
 					idCompressor: context.idCompressor,
 					isSummary: context.isSummary,
 				}),
@@ -350,14 +350,18 @@ export function decodeDetachedNodes(
 		return undefined;
 	}
 
-	const chunks = fieldsCodec.decode(encoded.trees, {
-		encodeType: chunkCompressionStrategy,
-		originatorId: context.originatorId,
-		idCompressor: context.idCompressor,
-		isSummary: context.isSummary,
-		healUnresolvableIdentifiersOnDecode: context.healUnresolvableIdentifiersOnDecode,
-		sharedObjectId: context.sharedObjectId,
-	});
+	const chunks = fieldsCodec.decode(
+		encoded.trees,
+		context.isSummary
+			? FieldBatchDecodingContext.forSummary({
+					idCompressor: context.idCompressor,
+					healing: context.healing,
+				})
+			: FieldBatchDecodingContext.forOp({
+					idCompressor: context.idCompressor,
+					originatorId: context.originatorId,
+				}),
+	);
 	const getChunk = (index: number): TreeChunk => {
 		assert(index < chunks.length, 0x898 /* out of bounds index for build chunk */);
 		return chunkFieldSingle(chunks[index] ?? oob(), {