@fluidframework/tree 2.81.1 → 2.83.0

package/src/core/tree/detachedFieldIndexCodecs.ts

@@ -24,16 +24,18 @@ type BuildData = CodecWriteOptions & {
 
 export const detachedFieldIndexCodecBuilder = ClientVersionDispatchingCodecBuilder.build(
 	"DetachedFieldIndex",
-	{
-		[lowestMinVersionForCollab]: {
+	[
+		{
+			minVersionForCollab: lowestMinVersionForCollab,
 			formatVersion: DetachedFieldIndexFormatVersion.v1,
 			codec: (buildData: BuildData) =>
 				makeDetachedNodeToFieldCodecV1(buildData.revisionTagCodec, buildData.idCompressor),
 		},
-		[FluidClientVersion.v2_52]: {
+		{
+			minVersionForCollab: FluidClientVersion.v2_52,
 			formatVersion: DetachedFieldIndexFormatVersion.v2,
 			codec: (buildData: BuildData) =>
 				makeDetachedNodeToFieldCodecV2(buildData.revisionTagCodec, buildData.idCompressor),
 		},
-	},
+	],
 );

package/src/core/tree/visitDelta.ts

@@ -402,7 +402,7 @@ function detachPass(
 	config: PassConfig,
 ): void {
 	let index = 0;
-	for (const mark of fieldChanges) {
+	for (const mark of fieldChanges.marks) {
 		if (mark.fields !== undefined) {
 			assert(
 				mark.attach === undefined || mark.detach !== undefined,
@@ -512,7 +512,7 @@ function attachPass(
 	config: PassConfig,
 ): void {
 	let index = 0;
-	for (const mark of fieldChanges) {
+	for (const mark of fieldChanges.marks) {
 		if (mark.attach !== undefined) {
 			for (let i = 0; i < mark.count; i += 1) {
 				const offsetAttachId = offsetDetachId(mark.attach, i);

package/src/extensibleUnionNode.ts

@@ -0,0 +1,177 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
+import { TreeAlpha, Tree } from "./shared-tree/index.js";
+import type {
+	TreeNodeSchema,
+	TreeNodeFromImplicitAllowedTypes,
+	TreeFieldFromImplicitField,
+	ImplicitFieldSchema,
+	InsertableTreeFieldFromImplicitField,
+	SchemaFactoryBeta,
+} from "./simple-tree/index.js";
+import {
+	createCustomizedFluidFrameworkScopedFactory,
+	eraseSchemaDetailsSubclassable,
+	getInnerNode,
+	SchemaFactory,
+	TreeBeta,
+} from "./simple-tree/index.js";
+import type { UnionToIntersection } from "./util/index.js";
+
+/**
+ * Utilities for creating extensible unions using a node.
+ * @remarks
+ * Use {@link ExtensibleUnionNode.createSchema} to create the union schema.
+ *
+ * Unlike a schema union created using {@link SchemaStaticsBeta.staged | staged} allowed types, this union allows for unknown future types to exist in addition to the known types.
+ * This allows for faster roll-outs of new types without waiting for old clients to be updated to be aware of them.
+ * This does mean however that old clients may see types they do not know about, which are simply exposed as `undefined` children.
+ *
+ * `staged` types are lower overhead, and might gain support for `unknown` types in the future, so prefer them when possible.
+ * This is simply an alternative for when future compatibility with unknown types is required.
+ * It is built on top of the existing {@link ObjectSchemaOptions.allowUnknownOptionalFields | allowUnknownOptionalFields} feature.
+ *
+ * @example
+ * ```typescript
+ * const sf = new SchemaFactoryBeta("extensibleUnionNodeExample.items");
+ * class ItemA extends sf.object("A", { x: sf.string }) {}
+ * class ItemB extends sf.object("B", { x: sf.number }) {}
+ *
+ * class AnyItem extends ExtensibleUnionNode.createSchema(
+ * 	[ItemA, ItemB], // Future versions may add more members here
+ * 	sf,
+ * 	"ExtensibleUnion",
+ * ) {}
+ * // Instances of the union are created using `create`.
+ * const anyItem = AnyItem.create(new ItemA({ x: "hello" }));
+ * // Reading the content from the union is done via the `union` property,
+ * // which can be `undefined` to handle the case where a future version of this schema allows a type unknown to the current version.
+ * const childNode: ItemA | ItemB | undefined = anyItem.union;
+ * // To determine which member of the union was present, its schema can be inspected:
+ * const aSchema = Tree.schema(childNode ?? assert.fail("No child"));
+ * assert.equal(aSchema, ItemA);
+ * ```
+ * @beta
+ */
+export namespace ExtensibleUnionNode {
+	/**
+	 * Members for classes created by {@link ExtensibleUnionNode.createSchema}.
+	 * @beta
+	 */
+	export interface Members<T> {
+		/**
+		 * The child wrapped by this node has one of the types allowed by the union,
+		 * or `undefined` if the type is one which was added to the union by a future version of this schema.
+		 *
+		 * @throws if {@link ExtensibleUnionNode.Members.isValid} is false.
+		 */
+		readonly union: T | undefined;
+
+		/**
+		 * Returns true, unless this node is in an invalid state.
+		 * @remarks
+		 * A well behaved application should not need this API.
+		 * If an application is hitting errors when accessing {@link ExtensibleUnionNode.Members.union},
+		 * this API can be used to help detect and recover from the invalid state which causes those errors (for example by replacing the invalid nodes with new ones).
+		 *
+		 * In this context "invalid" means that the internal implementation details of this node have had their invariants violated.
+		 * This can happen when:
+		 * - Using weakly typed construction APIs like {@link (TreeBeta:interface).importConcise} or {@link (TreeAlpha:interface).importVerbose} to construct an invalid state directly.
+		 * Using such APIs, even when not creating invalid nodes, is not supported for this schema,
+		 * since doing so requires knowing the implementation details of this node which are subject to change.
+		 * - By editing a document using a different client using a different schema for this node.
+		 * - Violating the TypeScript types to directly manipulate the node internals.
+		 * - A bug in this node's implementation (possibly in a different client) corrupted the node.
+		 * - Corruption of the document this node is contained in.
+		 *
+		 * @privateRemarks
+		 * We could support {@link (TreeBeta:interface).exportVerbose} using {@link KeyEncodingOptions.allStoredKeys}
+		 * then {@link (TreeAlpha:interface).importVerbose} with {@link KeyEncodingOptions.knownStoredKeys}.
+		 * However, even this will error (but will not produce an invalid node) if there is a node of an unknown type in the union.
+		 */
+		isValid(): boolean;
+	}
+
+	/**
+	 * Statics for classes created by {@link ExtensibleUnionNode.createSchema}.
+	 * @beta
+	 */
+	export interface Statics<T extends readonly TreeNodeSchema[]> {
+		/**
+		 * Create a {@link TreeNode} with `this` schema which wraps the provided child to create the union.
+		 */
+		create<TThis extends TreeNodeSchema>(
+			this: TThis,
+			child: TreeNodeFromImplicitAllowedTypes<T>,
+		): TreeFieldFromImplicitField<TThis>;
+	}
+
+	/**
+	 * Create an extensible schema union which currently supports the types in `types`,
+	 * but tolerates collaboration with future versions that may include additional types.
+	 * @remarks
+	 * See {@link ExtensibleUnionNode} for an example use.
+	 * @beta
+	 */
+	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+	export function createSchema<
+		const T extends readonly TreeNodeSchema[],
+		const TScope extends string,
+		const TName extends string,
+	>(types: T, inputSchemaFactory: SchemaFactoryBeta<TScope>, name: TName) {
+		const record: Record<string, ImplicitFieldSchema> = {};
+		for (const type of types) {
+			record[`_${type.identifier}`] = SchemaFactory.optional(type, { key: type.identifier });
+		}
+		const schemaFactory = createCustomizedFluidFrameworkScopedFactory(
+			inputSchemaFactory,
+			"extensibleUnionNode",
+		);
+
+		class Union
+			extends schemaFactory.object(name, record, { allowUnknownOptionalFields: true })
+			implements Members<TreeNodeFromImplicitAllowedTypes<T>>
+		{
+			public get union(): TreeNodeFromImplicitAllowedTypes<T> | undefined {
+				if (!this.isValid()) {
+					throw new UsageError(
+						`This ExtensibleUnionNode (${Union.identifier}) is in an invalid state. It must have been edited by another client using a different schema or been directly imported or constructed in an invalid state.`,
+					);
+				}
+				for (const [_key, child] of TreeAlpha.children(this)) {
+					return child as TreeNodeFromImplicitAllowedTypes<T>;
+				}
+				return undefined;
+			}
+
+			public isValid(): boolean {
+				// Use inner node, since it includes populated fields even when they are unknown.
+				const inner = getInnerNode(this);
+				// Fields only includes non-empty fields, so this is what we need to check the one child invariant.
+				return [...inner.fields].length === 1;
+			}
+
+			public static create<TThis extends TreeNodeSchema>(
+				this: TThis,
+				child: TreeNodeFromImplicitAllowedTypes<T>,
+			): TreeFieldFromImplicitField<TThis> {
+				const schema = Tree.schema(child);
+				return TreeBeta.create(this, {
+					[`_${schema.identifier}`]: child,
+				} as unknown as InsertableTreeFieldFromImplicitField<
+					TThis,
+					UnionToIntersection<TThis>
+				>);
+			}
+		}
+		return eraseSchemaDetailsSubclassable<
+			Members<TreeNodeFromImplicitAllowedTypes<T>>,
+			Statics<T>
+		>()(Union);
+	}
+}

package/src/feature-libraries/changeAtomIdBTree.ts

@@ -3,8 +3,14 @@
  * Licensed under the MIT License.
  */
 
-import type { ChangeAtomId, ChangesetLocalId, RevisionTag } from "../core/index.js";
-import type { TupleBTree } from "../util/index.js";
+import {
+	compareChangesetLocalIds,
+	comparePartialRevisions,
+	type ChangeAtomId,
+	type ChangesetLocalId,
+	type RevisionTag,
+} from "../core/index.js";
+import { createTupleComparator, newTupleBTree, type TupleBTree } from "../util/index.js";
 
 /**
  * A BTree which uses ChangeAtomId flattened into a tuple as the key.
@@ -16,6 +22,15 @@ export type ChangeAtomIdBTree<V> = TupleBTree<
 	V
 >;
 
+/** Creates a new {@link ChangeAtomIdBTree} */
+export function newChangeAtomIdBTree<V>(
+	entries?: [readonly [RevisionTag | undefined, ChangesetLocalId], V][],
+): ChangeAtomIdBTree<V> {
+	return newTupleBTree(compareKeys, entries);
+}
+
+const compareKeys = createTupleComparator([comparePartialRevisions, compareChangesetLocalIds]);
+
 export function getFromChangeAtomIdMap<T>(
 	map: ChangeAtomIdBTree<T>,
 	id: ChangeAtomId,

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

@@ -35,13 +35,7 @@ import { TreeCompressionStrategy } from "../../treeCompressionUtils.js";
 
 import { decode } from "./chunkDecoding.js";
 import type { FieldBatch } from "./fieldBatch.js";
-import {
-	type EncodedFieldBatch,
-	validVersions,
-	FieldBatchFormatVersion,
-	EncodedFieldBatchV1,
-	EncodedFieldBatchV2,
-} from "./format.js";
+import { EncodedFieldBatch, validVersions, FieldBatchFormatVersion } from "./format.js";
 import type { IncrementalEncodingPolicy } from "./incrementalEncodingPolicy.js";
 import { schemaCompressedEncodeV1, schemaCompressedEncodeV2 } from "./schemaBasedEncode.js";
 import { uncompressedEncodeV1, uncompressedEncodeV2 } from "./uncompressedEncode.js";
@@ -157,18 +151,15 @@ export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec
 	let schemaCompressedEncodeFn:
 		| typeof schemaCompressedEncodeV1
 		| typeof schemaCompressedEncodeV2;
-	let encodedFieldBatchType: typeof EncodedFieldBatchV1 | typeof EncodedFieldBatchV2;
 	switch (writeVersion) {
 		case unbrand(FieldBatchFormatVersion.v1): {
 			uncompressedEncodeFn = uncompressedEncodeV1;
 			schemaCompressedEncodeFn = schemaCompressedEncodeV1;
-			encodedFieldBatchType = EncodedFieldBatchV1;
 			break;
 		}
 		case unbrand(FieldBatchFormatVersion.v2): {
 			uncompressedEncodeFn = uncompressedEncodeV2;
 			schemaCompressedEncodeFn = schemaCompressedEncodeV2;
-			encodedFieldBatchType = EncodedFieldBatchV2;
 			break;
 		}
 		default: {
@@ -176,7 +167,10 @@ export function makeFieldBatchCodec(options: CodecWriteOptions): FieldBatchCodec
 		}
 	}
 
-	return makeVersionedValidatedCodec(options, validVersions, encodedFieldBatchType, {
+	// Both the encode and decode logic here support both v1 and v2, as does `validVersions` and `EncodedFieldBatch`.
+	// This makes this use of makeVersionedValidatedCodec atypical as it is a single call being used to make a codec that supports all versions,
+	// instead of one call per version, then using another utility to select between them based on version.
+	return makeVersionedValidatedCodec(options, validVersions, EncodedFieldBatch, {
 		encode: (data: FieldBatch, context: FieldBatchEncodingContext): EncodedFieldBatch => {
 			for (const cursor of data) {
 				assert(

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

@@ -12,7 +12,6 @@ import {
 	forbiddenFieldKindIdentifier,
 	Multiplicity,
 } from "../../core/index.js";
-import { brand, type Brand } from "../../util/index.js";
 import { identifierFieldIdentifier } from "../fieldKindIdentifiers.js";
 import {
 	type FieldChangeDelta,
@@ -22,6 +21,7 @@ import {
 	type FieldKindConfigurationEntry,
 	FlexFieldKind,
 	type FullSchemaPolicy,
+	ModularChangeFormatVersion,
 	type ToDelta,
 	referenceFreeFieldChangeRebaser,
 } from "../modular-schema/index.js";
@@ -107,9 +107,9 @@ export const forbidden: Forbidden = new FlexFieldKind(
 export const fieldKindConfigurations: ReadonlyMap<
 	ModularChangeFormatVersion,
 	FieldKindConfiguration
-> = new Map([
+> = new Map<ModularChangeFormatVersion, FieldKindConfiguration>([
 	[
-		brand(3),
+		ModularChangeFormatVersion.v3,
 		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
 			[required.identifier, { kind: required, formatVersion: 2 }],
 			[optional.identifier, { kind: optional, formatVersion: 2 }],
@@ -119,7 +119,7 @@ export const fieldKindConfigurations: ReadonlyMap<
 		]),
 	],
 	[
-		brand(4),
+		ModularChangeFormatVersion.v4,
 		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
 			[required.identifier, { kind: required, formatVersion: 2 }],
 			[optional.identifier, { kind: optional, formatVersion: 2 }],
@@ -129,7 +129,7 @@ export const fieldKindConfigurations: ReadonlyMap<
 		]),
 	],
 	[
-		brand(5),
+		ModularChangeFormatVersion.v5,
 		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
 			[required.identifier, { kind: required, formatVersion: 2 }],
 			[optional.identifier, { kind: optional, formatVersion: 2 }],
@@ -140,7 +140,6 @@ export const fieldKindConfigurations: ReadonlyMap<
 	],
 ]);
 
-export type ModularChangeFormatVersion = Brand<3 | 4 | 5, "ModularChangeFormatVersion">;
 export function getCodecTreeForModularChangeFormat(
 	version: ModularChangeFormatVersion,
 ): CodecTree {

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

@@ -8,7 +8,6 @@ export {
 	fieldKinds,
 	fieldKindConfigurations,
 	getCodecTreeForModularChangeFormat,
-	type ModularChangeFormatVersion,
 	defaultSchemaPolicy,
 } from "./defaultFieldKinds.js";
 

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

@@ -9,6 +9,7 @@ import {
 	getConfigForMinVersionForCollab,
 	lowestMinVersionForCollab,
 } from "@fluidframework/runtime-utils/internal";
+import { Type } from "@sinclair/typebox";
 
 import {
 	type CodecTree,
@@ -18,21 +19,23 @@ import {
 	makeVersionedValidatedCodec,
 } from "../../codec/index.js";
 import type { FieldKey, ITreeCursorSynchronous } from "../../core/index.js";
-import { brand } from "../../util/index.js";
+import { brand, type JsonCompatibleReadOnly } from "../../util/index.js";
 import type { FieldBatchCodec, FieldBatchEncodingContext } from "../chunked-forest/index.js";
 
-import {
-	ForestFormatVersion,
-	validVersions,
-	type Format,
-	FormatCommon,
-} from "./formatCommon.js";
+import { ForestFormatVersion, validVersions, type Format } from "./formatCommon.js";
+import { FormatV1 } from "./formatV1.js";
+import { FormatV2 } from "./formatV2.js";
 
 /**
  * Uses field cursors
  */
 export type FieldSet = ReadonlyMap<FieldKey, ITreeCursorSynchronous>;
-export type ForestCodec = IJsonCodec<FieldSet, Format, Format, FieldBatchEncodingContext>;
+export type ForestCodec = IJsonCodec<
+	FieldSet,
+	Format,
+	JsonCompatibleReadOnly,
+	FieldBatchEncodingContext
+>;
 
 /**
  * Convert a MinimumVersionForCollab to a ForestFormatVersion.
@@ -56,7 +59,10 @@ export function makeForestSummarizerCodec(
 ): ForestCodec {
 	const inner = fieldBatchCodec;
 	const writeVersion = clientVersionToForestFormatVersion(options.minVersionForCollab);
-	const formatSchema = FormatCommon(writeVersion);
+	const formatSchema = Type.Union([FormatV1, FormatV2]);
+	// Both the encode and decode logic here support both v1 and v2, as does `validVersions` and `formatSchema`.
+	// This makes this use of makeVersionedValidatedCodec atypical as it is a single call being used to make a codec that supports all versions,
+	// instead of one call per version, then using another utility to select between them based on version.
 	return makeVersionedValidatedCodec(options, validVersions, formatSchema, {
 		encode: (data: FieldSet, context: FieldBatchEncodingContext): Format => {
 			const keys: FieldKey[] = [];

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

@@ -32,7 +32,11 @@ import {
 	type SummaryElementParser,
 	type SummaryElementStringifier,
 } from "../../shared-tree-core/index.js";
-import { idAllocatorFromMaxId, readAndParseSnapshotBlob } from "../../util/index.js";
+import {
+	idAllocatorFromMaxId,
+	readAndParseSnapshotBlob,
+	type JsonCompatibleReadOnly,
+} from "../../util/index.js";
 // eslint-disable-next-line import-x/no-internal-modules
 import { chunkFieldSingle, defaultChunkPolicy } from "../chunked-forest/chunkTree.js";
 import {
@@ -211,7 +215,12 @@ export class ForestSummarizer
 		// TODO: this code is parsing data without an optional validator, this should be defined in a typebox schema as part of the
 		// forest summary format.
 		const fields = this.codec.decode(
-			await readAndParseSnapshotBlob(forestSummaryRootContentKey, services, parse),
+			(await readAndParseSnapshotBlob(
+				forestSummaryRootContentKey,
+				services,
+				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,
@@ -230,7 +239,10 @@ export class ForestSummarizer
 				id: buildId,
 				trees: chunked,
 			});
-			fieldChanges.push([fieldKey, [{ count: chunked.topLevelLength, attach: buildId }]]);
+			fieldChanges.push([
+				fieldKey,
+				{ marks: [{ count: chunked.topLevelLength, attach: buildId }] },
+			]);
 		}
 
 		assert(this.forest.isEmpty, 0x797 /* forest must be empty */);

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

@@ -6,8 +6,7 @@
 import { type Static, Type } from "@sinclair/typebox";
 
 import { schemaFormatV1 } from "../../core/index.js";
-import { strictEnum, type Values } from "../../util/index.js";
-import { EncodedFieldBatch } from "../chunked-forest/index.js";
+import { strictEnum, type Values, JsonCompatibleReadOnlySchema } from "../../util/index.js";
 
 /**
  * The format version for the forest.
@@ -21,8 +20,8 @@ export type ForestFormatVersion = Values<typeof ForestFormatVersion>;
 
 export const validVersions = new Set([...Object.values(ForestFormatVersion)]);
 
-export const FormatCommon = (
-	version: ForestFormatVersion,
+export const FormatCommon = <const TVersion extends ForestFormatVersion>(
+	version: TVersion,
 	// Return type is intentionally derived.
 	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
 ) =>
@@ -30,8 +29,10 @@ export const FormatCommon = (
 		{
 			version: Type.Literal(version),
 			keys: Type.Array(schemaFormatV1.FieldKeySchema),
-			fields: EncodedFieldBatch,
+			fields: JsonCompatibleReadOnlySchema, // Uses field batch codec
 		},
 		{ additionalProperties: false },
 	);
-export type Format = Static<ReturnType<typeof FormatCommon>>;
+export type Format<TVersion extends ForestFormatVersion = ForestFormatVersion> = Static<
+	ReturnType<typeof FormatCommon<TVersion>>
+>;

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

@@ -5,9 +5,7 @@
 
 import type { Static } from "@sinclair/typebox";
 
-import { brand } from "../../util/index.js";
-
 import { FormatCommon, ForestFormatVersion } from "./formatCommon.js";
 
-export const FormatV1 = FormatCommon(brand<ForestFormatVersion>(ForestFormatVersion.v1));
+export const FormatV1 = FormatCommon(ForestFormatVersion.v1);
 export type FormatV1 = Static<typeof FormatV1>;

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

@@ -5,9 +5,7 @@
 
 import type { Static } from "@sinclair/typebox";
 
-import { brand } from "../../util/index.js";
-
 import { FormatCommon, ForestFormatVersion } from "./formatCommon.js";
 
-export const FormatV2 = FormatCommon(brand<ForestFormatVersion>(ForestFormatVersion.v2));
+export const FormatV2 = FormatCommon(ForestFormatVersion.v2);
 export type FormatV2 = Static<typeof FormatV2>;

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

@@ -276,9 +276,7 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 	 */
 	public async load(args: {
 		services: IChannelStorageService;
-		readAndParseChunk: <T extends JsonCompatible<IFluidHandle>>(
-			chunkBlobPath: string,
-		) => Promise<T>;
+		readAndParseChunk: (chunkBlobPath: string) => Promise<JsonCompatible<IFluidHandle>>;
 	}): Promise<void> {
 		const forestTree = args.services.getSnapshotTree?.();
 		// Snapshot tree should be available when loading forest's contents. However, it is an optional function
@@ -303,8 +301,9 @@ export class ForestIncrementalSummaryBuilder implements IncrementalEncoderDecode
 						`SharedTree: Cannot find contents for incremental chunk ${chunkContentsPath}`,
 					);
 				}
-				const chunkContents =
-					await args.readAndParseChunk<EncodedFieldBatch>(chunkContentsPath);
+				const chunkContents = (await args.readAndParseChunk(
+					chunkContentsPath,
+				)) as EncodedFieldBatch; // TODO: this should use a codec to validate the data instead of just type casting.
 				this.loadedChunksMap.set(chunkReferenceId, {
 					encodedContents: chunkContents,
 					summaryPath: chunkSubTreePath,

package/src/feature-libraries/index.ts

@@ -48,8 +48,8 @@ export {
 	jsonableTreeFromForest,
 } from "./treeTextCursor.js";
 
-// Split this up into separate import and export for compatibility with API-Extractor.
 import * as SequenceField from "./sequence-field/index.js";
+// eslint-disable-next-line unicorn/prefer-export-from -- fixing requires `export * as` (breaks API-Extractor) or named exports (changes public API)
 export { SequenceField };
 
 export {
@@ -89,6 +89,7 @@ export {
 	type FieldKindConfigurationEntry,
 	isNeverTree,
 	DefaultRevisionReplacer,
+	ModularChangeFormatVersion,
 } from "./modular-schema/index.js";
 
 export { mapRootChanges } from "./deltaUtils.js";
@@ -139,7 +140,6 @@ export {
 	intoDelta,
 	relevantRemovedRoots,
 	getCodecTreeForModularChangeFormat,
-	type ModularChangeFormatVersion,
 } from "./default-schema/index.js";
 
 export {
@@ -210,6 +210,7 @@ export {
 
 export {
 	type ChangeAtomIdBTree,
+	newChangeAtomIdBTree,
 	getFromChangeAtomIdMap,
 	setInChangeAtomIdMap,
 } from "./changeAtomIdBTree.js";