@fluidframework/tree 2.74.0-370705 → 2.80.0

package/src/feature-libraries/treeCursorUtils.ts

@@ -473,18 +473,18 @@ export function prefixFieldPath(
  * TODO: tests for this.
  */
 export function prefixPathPrefix(root: PathRootPrefix, inner: PathRootPrefix): PathRootPrefix {
-	if (inner.parent !== undefined) {
+	if (inner.parent === undefined) {
 		const composedPrefix: PathRootPrefix = {
-			parent: new PrefixedPath(root, inner.parent),
-			rootFieldOverride: inner.rootFieldOverride,
-			indexOffset: inner.indexOffset,
+			parent: root.parent,
+			rootFieldOverride: root.rootFieldOverride ?? inner.rootFieldOverride,
+			indexOffset: (inner.indexOffset ?? 0) + (root.indexOffset ?? 0),
 		};
 		return composedPrefix;
 	} else {
 		const composedPrefix: PathRootPrefix = {
-			parent: root.parent,
-			rootFieldOverride: root.rootFieldOverride ?? inner.rootFieldOverride,
-			indexOffset: (inner.indexOffset ?? 0) + (root.indexOffset ?? 0),
+			parent: new PrefixedPath(root, inner.parent),
+			rootFieldOverride: inner.rootFieldOverride,
+			indexOffset: inner.indexOffset,
 		};
 		return composedPrefix;
 	}

package/src/feature-libraries/treeTextCursor.ts

@@ -94,13 +94,13 @@ export const adapter: CursorAdapter<JsonableTree> = {
 export function jsonableTreeFromCursor(cursor: ITreeCursor): JsonableTree {
 	assert(cursor.mode === CursorLocationType.Nodes, 0x3ba /* must start at node */);
 	const node: JsonableTree =
-		cursor.value !== undefined
+		cursor.value === undefined
 			? {
 					type: cursor.type,
-					value: cursor.value,
 				}
 			: {
 					type: cursor.type,
+					value: cursor.value,
 				};
 
 	// Normalize object by only including fields that are required.

package/src/feature-libraries/valueUtilities.ts

@@ -21,18 +21,24 @@ export function valueSchemaAllows<TSchema extends ValueSchema>(
 	nodeValue: Value,
 ): nodeValue is TreeValue<TSchema> {
 	switch (schema) {
-		case ValueSchema.String:
+		case ValueSchema.String: {
 			return typeof nodeValue === "string";
-		case ValueSchema.Number:
+		}
+		case ValueSchema.Number: {
 			return typeof nodeValue === "number";
-		case ValueSchema.Boolean:
+		}
+		case ValueSchema.Boolean: {
 			return typeof nodeValue === "boolean";
-		case ValueSchema.FluidHandle:
+		}
+		case ValueSchema.FluidHandle: {
 			return isFluidHandle(nodeValue);
-		case ValueSchema.Null:
+		}
+		case ValueSchema.Null: {
 			return nodeValue === null;
-		default:
+		}
+		default: {
 			unreachableCase(schema);
+		}
 	}
 }
 
@@ -67,9 +73,11 @@ export function isTreeValue(nodeValue: unknown): nodeValue is TreeValue {
 	switch (typeof nodeValue) {
 		case "string":
 		case "number":
-		case "boolean":
+		case "boolean": {
 			return true;
-		default:
+		}
+		default: {
 			return nodeValue === null || isFluidHandle(nodeValue);
+		}
 	}
 }

package/src/index.ts

@@ -9,6 +9,7 @@ export {
 	CommitKind,
 	RevertibleStatus,
 	type CommitMetadata,
+	type ChangeMetadata,
 	type RevertibleFactory,
 	type RevertibleAlphaFactory,
 	type RevertibleAlpha,
@@ -248,7 +249,9 @@ export {
 	type SchemaStatics,
 	type ITreeAlpha,
 	type TransactionConstraint,
+	type TransactionConstraintAlpha,
 	type NodeInDocumentConstraint,
+	type NoChangeConstraint,
 	type RunTransactionParams,
 	type VoidTransactionCallbackStatus,
 	type TransactionCallbackStatus,
@@ -291,6 +294,8 @@ export {
 	checkCompatibility,
 	incrementalSummaryHint,
 	incrementalEncodingPolicyForAllowedTypes,
+	eraseSchemaDetails,
+	eraseSchemaDetailsSubclassable,
 } from "./simple-tree/index.js";
 export {
 	SharedTree,
@@ -308,6 +313,8 @@ export {
 	FluidClientVersion,
 	type FormatValidator,
 	FormatValidatorNoOp,
+	type CodecName,
+	type FormatVersion,
 } from "./codec/index.js";
 export { FormatValidatorBasic } from "./external-utilities/index.js";
 

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/tree";
-export const pkgVersion = "2.74.0-370705";
+export const pkgVersion = "2.80.0";

package/src/shared-tree/independentView.ts

@@ -48,7 +48,6 @@ import {
 	type JsonCompatible,
 	Breakable,
 	oneFromIterable,
-	brand,
 } from "../util/index.js";
 import {
 	buildConfiguredForest,
@@ -206,7 +205,7 @@ export function createIndependentTreeAlpha<const TSchema extends ImplicitFieldSc
 			...options,
 			minVersionForCollab: FluidClientVersion.v2_0,
 		};
-		const schemaCodec = makeSchemaCodec(writeOptions, brand(SchemaFormatVersion.v1));
+		const schemaCodec = makeSchemaCodec(writeOptions, SchemaFormatVersion.v1);
 		const fieldBatchCodec = makeFieldBatchCodec(writeOptions);
 		const newSchema = schemaCodec.decode(options.content.schema as Format);
 

package/src/shared-tree/index.ts

@@ -41,10 +41,9 @@ export { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 export { initialize, initializerFromChunk } from "./schematizeTree.js";
 
 export type {
-	IIdBasedSharedTreeEditor,
-	ILocationBasedSharedTreeEditor,
+	ISharedTreeEditor,
 	ISchemaEditor,
-	IdBasedSharedTreeEditBuilder,
+	SharedTreeEditBuilder,
 } from "./sharedTreeEditBuilder.js";
 
 export { Tree } from "./tree.js";

package/src/shared-tree/schematizeTree.ts

@@ -5,19 +5,12 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 
-import {
-	type ChangeAtomId,
-	type TreeStoredSchema,
-	rootFieldKey,
-	schemaDataIsEmpty,
-} from "../core/index.js";
+import { type TreeStoredSchema, rootFieldKey, schemaDataIsEmpty } from "../core/index.js";
 import {
 	FieldKinds,
 	allowsRepoSuperset,
 	defaultSchemaPolicy,
-	type DetachedRootIds,
-	type ILocationBasedDataEditor,
-	type DataEditor,
+	type IDefaultEditBuilder,
 	type TreeChunk,
 } from "../feature-libraries/index.js";
 
@@ -44,11 +37,11 @@ export function canInitialize(checkout: ITreeCheckout): boolean {
  * @privateRemarks
  * This takes in a checkout using a subset of the checkout interface to enable easier unit testing.
  */
-export function initialize<T>(
+export function initialize(
 	checkout: Pick<ITreeCheckout, "storedSchema" | "updateSchema">,
 	newSchema: TreeStoredSchema,
-	setInitialTree: () => T,
-): T {
+	setInitialTree: () => void,
+): void {
 	assert(
 		schemaDataIsEmpty(checkout.storedSchema),
 		0x743 /* cannot initialize after a schema is set */,
@@ -85,15 +78,13 @@ export function initialize<T>(
 	);
 
 	checkout.updateSchema(intermediateSchema);
-	const result = setInitialTree();
+	setInitialTree();
 
 	// If intermediate schema is not final desired schema, update to the final schema:
 	if (intermediateSchema !== newSchema) {
 		// This makes the root more strict, so set allowNonSupersetSchema to true.
 		checkout.updateSchema(newSchema, true);
 	}
-
-	return result;
 }
 
 /**
@@ -108,9 +99,7 @@ export function initialize<T>(
  */
 export function initializerFromChunk(
 	checkout: Pick<ITreeCheckout, "storedSchema"> & {
-		readonly editor:
-			| ILocationBasedDataEditor
-			| DataEditor<TreeChunk, ChangeAtomId, DetachedRootIds>;
+		readonly editor: IDefaultEditBuilder;
 	},
 	contentFactory: () => TreeChunk,
 ): () => void {
@@ -119,9 +108,7 @@ export function initializerFromChunk(
 
 function initializeFromChunk(
 	checkout: Pick<ITreeCheckout, "storedSchema"> & {
-		readonly editor:
-			| ILocationBasedDataEditor
-			| DataEditor<TreeChunk, ChangeAtomId, DetachedRootIds>;
+		readonly editor: IDefaultEditBuilder;
 	},
 	contentChunk: TreeChunk,
 ): void {

package/src/shared-tree/schematizingTreeView.ts

@@ -16,8 +16,10 @@ import { anchorSlot, rootFieldKey } from "../core/index.js";
 import {
 	type NodeIdentifierManager,
 	defaultSchemaPolicy,
+	cursorForMapTreeField,
 	TreeStatus,
 	Context,
+	combineChunks,
 	type FlexTreeOptionalField,
 	type FlexTreeUnknownUnboxed,
 	FieldKinds,
@@ -48,7 +50,7 @@ import {
 	type TransactionResult,
 	type TransactionResultExt,
 	type RunTransactionParams,
-	type TransactionConstraint,
+	type TransactionConstraintAlpha,
 	HydratedContext,
 	SimpleContextSlot,
 	areImplicitFieldSchemaEqual,
@@ -59,18 +61,18 @@ import {
 	TreeViewConfigurationAlpha,
 	toInitialSchema,
 	toUpgradeSchema,
+	type TreeBranchAlpha,
 } from "../simple-tree/index.js";
 import {
 	type Breakable,
 	breakingClass,
 	disposeSymbol,
-	hasSingle,
+	type JsonCompatibleReadOnly,
 	type WithBreakable,
 } from "../util/index.js";
 
-import { canInitialize, initialize } from "./schematizeTree.js";
+import { canInitialize, initialize, initializerFromChunk } from "./schematizeTree.js";
 import type { ITreeCheckout, TreeCheckout } from "./treeCheckout.js";
-import type { TreeBranchAlpha } from "../simple-tree/index.js";
 
 /**
  * Creating multiple tree views from the same checkout is not supported. This slot is used to detect if one already
@@ -122,6 +124,11 @@ export class SchematizingSimpleTreeView<
 	 */
 	private midUpgrade = false;
 
+	/**
+	 * Hydration work deferred until Context has been created.
+	 */
+	private pendingHydration?: () => void;
+
 	private readonly rootFieldSchema: FieldSchema;
 	public readonly breaker: Breakable;
 
@@ -159,6 +166,10 @@ export class SchematizingSimpleTreeView<
 		);
 	}
 
+	public applyChange(change: JsonCompatibleReadOnly): void {
+		this.checkout.applySerializedChange(change);
+	}
+
 	public hasRootSchema<TSchema extends ImplicitFieldSchema>(
 		schema: TSchema,
 	): this is TreeViewAlpha<TSchema> {
@@ -179,54 +190,57 @@ export class SchematizingSimpleTreeView<
 
 		this.runSchemaEdit(() => {
 			const schema = toInitialSchema(this.config.schema);
-			this.checkout.transaction.start();
-			initialize(this.checkout, schema, () => {
-				const preparedContent = prepareForInsertionContextless(
-					content as InsertableContent | undefined,
-					this.rootFieldSchema,
-					{
-						schema,
-						policy: defaultSchemaPolicy,
-					},
-					this,
-					schema.rootFieldSchema,
-				);
-
-				if (preparedContent.rootsLocations.length === 0) {
-					// If there's no content to attach, no work is needed
-					return undefined;
-				}
+			// This has to be the contextless version, since when "initialize" is called (right after this),
+			// it will do a schema change which would dispose of the current context (see inside `update`).
+			// Thus using the current context (if any) would hydrate nodes then
+			// immediately dispose them instead of having them actually be useable after initialize.
+			// For this to work,
+			// the hydration must be deferred until after the content is inserted into the tree and the final schema change is done (for required roots),
+			// but before any user event could could run.
+			const mapTree = prepareForInsertionContextless(
+				content as InsertableContent | undefined,
+				this.rootFieldSchema,
+				{
+					schema,
+					policy: defaultSchemaPolicy,
+				},
+				this,
+				schema.rootFieldSchema,
+				(batches, doHydration) => {
+					assert(
+						this.pendingHydration === undefined,
+						0xc74 /* pendingHydration already set */,
+					);
+					this.pendingHydration = () => {
+						assert(
+							batches.length <= 1,
+							0xc75 /* initialize should at most one hydration batch */,
+						);
+						for (const batch of batches) {
+							doHydration(batch, {
+								parent: undefined,
+								parentField: rootFieldKey,
+								parentIndex: 0,
+							});
+						}
+					};
+				},
+			);
 
-				const field = { field: rootFieldKey, parent: undefined };
-				assert(
-					this.checkout.storedSchema.rootFieldSchema.kind === FieldKinds.optional.identifier,
-					"initializerFromChunk only supports optional roots",
-				);
+			this.checkout.transaction.start();
 
-				assert(
-					hasSingle(preparedContent.rootsLocations) &&
-						preparedContent.rootsLocations[0].count === 1,
-					"Expected one root",
-				);
-				const fieldEditor = this.checkout.editor.optionalField(field);
-				fieldEditor.attach(preparedContent.rootsLocations[0].field, true);
-
-				return preparedContent;
-			})?.finalize([...this.getFlexTreeContext().root]);
-
-			// TODO:CM
-			// initialize(
-			// 	this.checkout,
-			// 	schema,
-			// 	initializerFromChunk(this.checkout, () => {
-			// 		// This must be done after initial schema is set!
-			// 		return combineChunks(
-			// 			this.checkout.forest.chunkField(
-			// 				cursorForMapTreeField(mapTree === undefined ? [] : [mapTree]),
-			// 			),
-			// 		);
-			// 	}),
-			// );
+			initialize(
+				this.checkout,
+				schema,
+				initializerFromChunk(this.checkout, () => {
+					// This must be done after initial schema is set!
+					return combineChunks(
+						this.checkout.forest.chunkField(
+							cursorForMapTreeField(mapTree === undefined ? [] : [mapTree]),
+						),
+					);
+				}),
+			);
 			this.checkout.transaction.commit();
 		});
 	}
@@ -282,7 +296,7 @@ export class SchematizingSimpleTreeView<
 	): TransactionResultExt<TSuccessValue, TFailureValue> | TransactionResult {
 		const addConstraints = (
 			constraintsOnRevert: boolean,
-			constraints: readonly TransactionConstraint[] = [],
+			constraints: readonly TransactionConstraintAlpha[] = [],
 		): void => {
 			addConstraintsToTransaction(this.checkout, constraintsOnRevert, constraints);
 		};
@@ -299,9 +313,9 @@ export class SchematizingSimpleTreeView<
 
 		if (rollback === true) {
 			this.checkout.transaction.abort();
-			return value !== undefined
-				? { success: false, value: value as TFailureValue }
-				: { success: false };
+			return value === undefined
+				? { success: false }
+				: { success: false, value: value as TFailureValue };
 		}
 
 		// Validate preconditions on revert after running the transaction callback and was successful.
@@ -311,9 +325,9 @@ export class SchematizingSimpleTreeView<
 		);
 
 		this.checkout.transaction.commit();
-		return value !== undefined
-			? { success: true, value: value as TSuccessValue }
-			: { success: true };
+		return value === undefined
+			? { success: true }
+			: { success: true, value: value as TSuccessValue };
 	}
 
 	private ensureUndisposed(): void {
@@ -381,7 +395,9 @@ export class SchematizingSimpleTreeView<
 
 				// Track what the root was before to be able to detect changes.
 				// This uses the flex tree root to avoid demanding the simple-tree TreeNode when it might not be hydrated yet.
-				let lastRoot: FlexTreeUnknownUnboxed | undefined = this.flexRoot.content;
+				let lastRoot: FlexTreeUnknownUnboxed | undefined = (
+					this.flexTreeContext.root as FlexTreeOptionalField
+				).content;
 
 				this.flexTreeViewUnregisterCallbacks.add(
 					this.checkout.events.on("afterBatch", () => {
@@ -405,6 +421,10 @@ export class SchematizingSimpleTreeView<
 		);
 
 		if (!this.midUpgrade) {
+			assert(
+				this.pendingHydration === undefined,
+				0xc76 /* no nodes should be pending hydration when triggering events that could access nodes */,
+			);
 			this.events.emit("schemaChanged");
 			this.events.emit("rootChanged");
 		}
@@ -417,6 +437,9 @@ export class SchematizingSimpleTreeView<
 		} finally {
 			this.midUpgrade = false;
 		}
+		// Ensure hydration is flushed before events run which could access nodes.
+		this.pendingHydration?.();
+		this.pendingHydration = undefined;
 		this.events.emit("schemaChanged");
 		this.events.emit("rootChanged");
 	}
@@ -528,7 +551,7 @@ export function getCheckout(context: TreeBranch): TreeCheckout {
  * Adds constraints to a `checkout`'s pending transaction.
  *
  * @param checkout - The checkout's who's transaction will have the constraints added to it.
- * @param constraintsOnRevert - If true, use {@link IIdBasedSharedTreeEditor.addNodeExistsConstraintOnRevert}.
+ * @param constraintsOnRevert - If true, use {@link ISharedTreeEditor.addNodeExistsConstraintOnRevert}.
  * @param constraints - The constraints to add to the transaction.
  *
  * @see {@link RunTransactionParams.preconditions}.
@@ -536,10 +559,11 @@ export function getCheckout(context: TreeBranch): TreeCheckout {
 export function addConstraintsToTransaction(
 	checkout: ITreeCheckout,
 	constraintsOnRevert: boolean,
-	constraints: readonly TransactionConstraint[] = [],
+	constraints: readonly TransactionConstraintAlpha[] = [],
 ): void {
 	for (const constraint of constraints) {
-		switch (constraint.type) {
+		const constraintType = constraint.type;
+		switch (constraintType) {
 			case "nodeInDocument": {
 				const node = getInnerNode(constraint.node);
 				const nodeStatus = getKernel(constraint.node).getStatus();
@@ -557,8 +581,17 @@ export function addConstraintsToTransaction(
 				}
 				break;
 			}
-			default:
-				unreachableCase(constraint.type);
+			case "noChange": {
+				if (constraintsOnRevert) {
+					checkout.editor.addNoChangeConstraintOnRevert();
+				} else {
+					checkout.editor.addNoChangeConstraint();
+				}
+				break;
+			}
+			default: {
+				unreachableCase(constraintType);
+			}
 		}
 	}
 }

package/src/shared-tree/sharedTree.ts

@@ -41,7 +41,7 @@ import {
 	TreeStoredSchemaRepository,
 	type TreeStoredSchemaSubscription,
 	type TreeTypeSet,
-	getCodecTreeForDetachedFieldIndexFormat,
+	detachedFieldIndexCodecBuilder,
 	makeDetachedFieldIndex,
 	moveToDetachedField,
 } from "../core/index.js";
@@ -57,7 +57,6 @@ import {
 	defaultSchemaPolicy,
 	getCodecTreeForFieldBatchFormat,
 	getCodecTreeForForestFormat,
-	getCodecTreeForSchemaFormat,
 	jsonableTreeFromFieldCursor,
 	makeFieldBatchCodec,
 	makeMitigatedChangeFamily,
@@ -66,7 +65,7 @@ import {
 	type IncrementalEncodingPolicy,
 } from "../feature-libraries/index.js";
 // eslint-disable-next-line import-x/no-internal-modules
-import type { FormatV1 } from "../feature-libraries/schema-index/index.js";
+import { schemaCodecBuilder, type FormatV1 } from "../feature-libraries/schema-index/index.js";
 import {
 	type BranchId,
 	clientVersionToEditManagerFormatVersion,
@@ -104,7 +103,7 @@ import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 import { SharedTreeReadonlyChangeEnricher } from "./sharedTreeChangeEnricher.js";
 import { SharedTreeChangeFamily } from "./sharedTreeChangeFamily.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
-import type { IdBasedSharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
+import type { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
 import { type TreeCheckout, type BranchableTree, createTreeCheckout } from "./treeCheckout.js";
 import {
 	brand,
@@ -182,7 +181,7 @@ export type SharedTreeKernelView = Omit<ITreePrivate, keyof (IChannelView & IFlu
  */
 @breakingClass
 export class SharedTreeKernel
-	extends SharedTreeCore<IdBasedSharedTreeEditBuilder, SharedTreeChange>
+	extends SharedTreeCore<SharedTreeEditBuilder, SharedTreeChange>
 	implements SharedKernel
 {
 	public readonly checkout: TreeCheckout;
@@ -366,10 +365,12 @@ export class SharedTreeKernel
 			}
 		});
 		checkout.events.on("beforeBatch", (event) => {
-			if (event.type === "append" && this.sharedObject.isAttached()) {
-				if (checkout.transaction.isInProgress()) {
-					enricher.addTransactionCommits(event.newCommits);
-				}
+			if (
+				event.type === "append" &&
+				this.sharedObject.isAttached() &&
+				checkout.transaction.isInProgress()
+			) {
+				enricher.addTransactionCommits(event.newCommits);
 			}
 		});
 	}
@@ -470,7 +471,7 @@ export class SharedTreeKernel
 
 	public override applyStashedOp(
 		...args: Parameters<
-			SharedTreeCore<IdBasedSharedTreeEditBuilder, SharedTreeChange>["applyStashedOp"]
+			SharedTreeCore<SharedTreeEditBuilder, SharedTreeChange>["applyStashedOp"]
 		>
 	): void {
 		for (const checkout of this.checkouts.values()) {
@@ -600,8 +601,8 @@ export const changeFormatVersionForEditManager = DependentFormatVersion.fromPair
 		brand<SharedTreeChangeFormatVersion>(4),
 	],
 	[
-		brand<EditManagerFormatVersion>(EditManagerFormatVersion.vDetachedRoots),
-		brand<SharedTreeChangeFormatVersion>(101),
+		brand<EditManagerFormatVersion>(EditManagerFormatVersion.v6),
+		brand<SharedTreeChangeFormatVersion>(5),
 	],
 ]);
 
@@ -625,8 +626,8 @@ export const changeFormatVersionForMessage = DependentFormatVersion.fromPairs([
 		brand<SharedTreeChangeFormatVersion>(4),
 	],
 	[
-		brand<MessageFormatVersion>(MessageFormatVersion.vDetachedRoots),
-		brand<SharedTreeChangeFormatVersion>(101),
+		brand<MessageFormatVersion>(MessageFormatVersion.v6),
+		brand<SharedTreeChangeFormatVersion>(5),
 	],
 ]);
 
@@ -651,8 +652,8 @@ export function getCodecTreeForSharedTreeFormat(
 ): CodecTree {
 	const children: CodecTree[] = [];
 	children.push(getCodecTreeForForestFormat(clientVersion));
-	children.push(getCodecTreeForSchemaFormat(clientVersion));
-	children.push(getCodecTreeForDetachedFieldIndexFormat(clientVersion));
+	children.push(schemaCodecBuilder.getCodecTree(clientVersion));
+	children.push(detachedFieldIndexCodecBuilder.getCodecTree(clientVersion));
 	children.push(getCodecTreeForEditManagerFormat(clientVersion));
 	children.push(getCodecTreeForMessageFormat(clientVersion));
 	children.push(getCodecTreeForFieldBatchFormat(clientVersion));
@@ -683,12 +684,6 @@ export interface SharedTreeOptions
 	 * Defaults to false.
 	 */
 	readonly enableSharedBranches?: boolean;
-	/**
-	 * Experimental feature flag to enable the ability to edit detached roots.
-	 * This feature is not yet complete and should not be used in production.
-	 * Defaults to false.
-	 */
-	readonly enableDetachedRootEditing?: boolean;
 	/**
 	 * Returns whether a node / field should be incrementally encoded.
 	 * @remarks
@@ -829,8 +824,8 @@ export const defaultSharedTreeOptions: Required<SharedTreeOptionsInternal> = {
 	editManagerFormatSelector: clientVersionToEditManagerFormatVersion,
 	messageFormatSelector: clientVersionToMessageFormatVersion,
 	enableSharedBranches: false,
-	enableDetachedRootEditing: false,
-	canMakeDetachedRootEdits: false,
+	writeVersionOverrides: new Map(),
+	allowPossiblyIncompatibleWriteVersionOverrides: false,
 };
 
 /**
@@ -856,21 +851,26 @@ function exportSimpleFieldSchemaStored(
 ): SimpleFieldSchema<SchemaType.Stored> {
 	let kind: FieldKind;
 	switch (schema.kind) {
-		case FieldKinds.identifier.identifier:
+		case FieldKinds.identifier.identifier: {
 			kind = FieldKind.Identifier;
 			break;
-		case FieldKinds.optional.identifier:
+		}
+		case FieldKinds.optional.identifier: {
 			kind = FieldKind.Optional;
 			break;
-		case FieldKinds.required.identifier:
+		}
+		case FieldKinds.required.identifier: {
 			kind = FieldKind.Required;
 			break;
-		case FieldKinds.forbidden.identifier:
+		}
+		case FieldKinds.forbidden.identifier: {
 			kind = FieldKind.Optional;
 			assert(schema.types.size === 0, 0xa94 /* invalid forbidden field */);
 			break;
-		default:
+		}
+		default: {
 			fail(0xaca /* invalid field kind */);
+		}
 	}
 	return {
 		kind,