@fluidframework/tree 2.74.0-370705 → 2.80.0

package/src/feature-libraries/optional-field/optionalFieldChangeTypes.ts

@@ -6,19 +6,48 @@
 import type { ChangeAtomId } from "../../core/index.js";
 import type { NodeId } from "../modular-schema/index.js";
 
+/**
+ * Uniquely identifies a register within the scope of this changeset.
+ * The sentinel value "self" is used for the active register, which is a universally shared register
+ * (as in, any changeset referring to "self" refers to the register containing the active value of the field).
+ *
+ * See the model description in {@link OptionalChangeset} for more details.
+ */
+export type RegisterId = ChangeAtomId | "self";
+
+export type Move = readonly [src: ChangeAtomId, dst: ChangeAtomId];
+
+export type ChildChange = readonly [register: RegisterId, childChange: NodeId];
+
 /**
  * Changes to an optional field.
  *
- * The model used is that optional field consists of a single register.
- * In a given change input or output context, this register may hold 0 or 1 nodes.
+ * The model used is that optional field consists of a collection of "registers" with one designated as the "active" register.
+ * In a given change input or output context, registers may hold 0 or 1 nodes.
+ * Each register is identified using a {@link RegisterId}.
+ * The active register holds the current value of the field, and other registers hold detached roots.
  */
 export interface OptionalChangeset {
+	/**
+	 * Each entry signifies the intent to move a node from `src` to `dst`.
+	 * Moves to or from the "self" register are represented in {@link valueReplace}.
+	 *
+	 * These entries should not be interpreted as "applied one after the other", but rather as "applied simultaneously".
+	 * As such, changesets should not contain duplicated src or dst entries.
+	 */
+	readonly moves: readonly Move[];
+
+	/**
+	 * Nested changes to nodes that occupy registers.
+	 *
+	 * Nodes are identified by the register they occupy in the *input* context of the changeset.
+	 */
+	readonly childChanges: readonly ChildChange[];
+
 	/**
 	 * An optional description of how to replace the current value of the field.
 	 */
 	readonly valueReplace?: Replace;
-	readonly nodeDetach?: ChangeAtomId;
-	readonly childChange?: NodeId;
 }
 
 export interface Replace {
@@ -28,28 +57,13 @@ export interface Replace {
 	readonly isEmpty: boolean;
 
 	/**
-	 * An ID to associate with the node (if any) which is detached by this edit.
-	 *
-	 * When the field is empty in the input context, this ID is dormant in the sense that it would not be used if the changeset were applied as is.
-	 * However, it can become active if the changeset is rebased over a change that attaches a node in the field.
+	 * The ID for the node to put in this field, or undefined if the field should be emptied.
+	 * Will be "self" when the intention is to keep the current node in this field.
 	 */
-	readonly dst: ChangeAtomId;
+	readonly src?: RegisterId;
 
 	/**
-	 * The ID for the node to attach in this field, or undefined if no node should be attached.
-	 *
-	 * Note that this ID may refer to the node detached by this changeset:
-	 * The node in the field is detached and associated with ID `dst`,
-	 * then that node is renamed from `dst` to `src` (at the ModularChangeset level),
-	 * then that node is attached back into the field.
-	 * When this is the case, we say that the node is being pinned in the field.
-	 * While a pin has no effect on the document state if applied as-is, its merge semantics are different from an empty changeset.
-	 * This is because rebasing a pin over a change that detaches the node from the field will result in a changeset that re-attaches the node to the field.
-	 * In other words, a pin guarantees that the node will be in the field after the changeset is rebased and applied, whereas an empty changeset does not.
-	 *
-	 * `src` must be structurally different from `dst` even when the changeset is a pin.
-	 * An optional field changeset that aims to attach a node must be able to affect two nodes,
-	 * so unless we want to mint new IDs during rebasing, such a changeset must have two different IDs.
+	 * An ID to associate with the node (if any) which is detached by this edit.
 	 */
-	readonly src?: ChangeAtomId;
+	readonly dst: ChangeAtomId;
 }

package/src/feature-libraries/optional-field/optionalFieldCodecV2.ts

@@ -6,12 +6,11 @@
 import type { TAnySchema } from "@sinclair/typebox";
 
 import type { IJsonCodec } from "../../codec/index.js";
-import {
-	areEqualChangeAtomIdOpts,
-	type ChangeAtomId,
-	type ChangeEncodingContext,
-	type EncodedRevisionTag,
-	type RevisionTag,
+import type {
+	ChangeAtomId,
+	ChangeEncodingContext,
+	EncodedRevisionTag,
+	RevisionTag,
 } from "../../core/index.js";
 import type { Mutable } from "../../util/index.js";
 import { makeChangeAtomIdCodec } from "../changeAtomIdCodec.js";
@@ -22,10 +21,7 @@ import {
 } from "../modular-schema/index.js";
 
 import { EncodedOptionalChangeset, EncodedRegisterId } from "./optionalFieldChangeFormatV2.js";
-import type { OptionalChangeset, Replace } from "./optionalFieldChangeTypes.js";
-import { assert } from "@fluidframework/core-utils/internal";
-
-type RegisterId = ChangeAtomId | "self";
+import type { OptionalChangeset, RegisterId, Replace } from "./optionalFieldChangeTypes.js";
 
 function makeRegisterIdCodec(
 	changeAtomIdCodec: IJsonCodec<
@@ -70,62 +66,33 @@ export function makeOptionalFieldCodec(
 
 	return {
 		encode: (change: OptionalChangeset, context: FieldChangeEncodingContext) => {
-			assert(
-				change.nodeDetach === undefined ||
-					areEqualChangeAtomIdOpts(change.valueReplace?.src, change.nodeDetach),
-				"This format only supports node detach when it represents a pin",
-			);
-
 			const encoded: EncodedOptionalChangeset<TAnySchema> = {};
 
+			if (change.moves.length > 0) {
+				encoded.m = change.moves.map(([src, dst]) => [
+					changeAtomIdCodec.encode(src, context.baseContext),
+					changeAtomIdCodec.encode(dst, context.baseContext),
+				]);
+			}
+
 			if (change.valueReplace !== undefined) {
 				encoded.r = {
 					e: change.valueReplace.isEmpty,
 					d: changeAtomIdCodec.encode(change.valueReplace.dst, context.baseContext),
 				};
 				if (change.valueReplace.src !== undefined) {
-					const srcRegister =
-						change.nodeDetach === undefined ? change.valueReplace.src : "self";
-
-					encoded.r.s = registerIdCodec.encode(srcRegister, context.baseContext);
+					encoded.r.s = registerIdCodec.encode(change.valueReplace.src, context.baseContext);
 				}
 			}
 
-			const encodedChildChanges: [EncodedRegisterId, EncodedNodeChangeset][] = [];
-
-			if (change.childChange !== undefined) {
-				encodedChildChanges.push([null, context.encodeNode(change.childChange)]);
-			}
-
-			for (const [detachId, nodeId] of context.rootNodeChanges.entries()) {
-				encodedChildChanges.push([
-					changeAtomIdCodec.encode(
-						{ revision: detachId[0], localId: detachId[1] },
-						context.baseContext,
-					),
-					context.encodeNode(nodeId),
-				]);
-			}
-
-			if (encodedChildChanges.length > 0) {
-				encoded.c = encodedChildChanges;
-			}
-
-			const encodedMoves: [EncodedChangeAtomId, EncodedChangeAtomId][] = [];
-			for (const {
-				start: oldId,
-				value: newId,
-				length: count,
-			} of context.rootRenames.entries()) {
-				assert(count === 1, "Unexpected range rename in optional field");
-				encodedMoves.push([
-					changeAtomIdCodec.encode(oldId, context.baseContext),
-					changeAtomIdCodec.encode(newId, context.baseContext),
-				]);
-			}
-
-			if (encodedMoves.length > 0) {
-				encoded.m = encodedMoves;
+			if (change.childChanges.length > 0) {
+				encoded.c = [];
+				for (const [id, childChange] of change.childChanges) {
+					encoded.c.push([
+						registerIdCodec.encode(id, context.baseContext),
+						context.encodeNode(childChange),
+					]);
+				}
 			}
 
 			return encoded;
@@ -135,7 +102,18 @@ export function makeOptionalFieldCodec(
 			encoded: EncodedOptionalChangeset<TAnySchema>,
 			context: FieldChangeEncodingContext,
 		) => {
-			const decoded: Mutable<OptionalChangeset> = {};
+			const decoded: Mutable<OptionalChangeset> = {
+				moves:
+					encoded.m?.map(([encodedSrc, encodedDst]) => [
+						changeAtomIdCodec.decode(encodedSrc, context.baseContext),
+						changeAtomIdCodec.decode(encodedDst, context.baseContext),
+					]) ?? [],
+				childChanges:
+					encoded.c?.map(([id, encodedChange]) => [
+						registerIdCodec.decode(id, context.baseContext),
+						context.decodeNode(encodedChange),
+					]) ?? [],
+			};
 
 			if (encoded.r !== undefined) {
 				const replace: Mutable<Replace> = {
@@ -143,42 +121,10 @@ export function makeOptionalFieldCodec(
 					dst: changeAtomIdCodec.decode(encoded.r.d, context.baseContext),
 				};
 				if (encoded.r.s !== undefined) {
-					const register = registerIdCodec.decode(encoded.r.s, context.baseContext);
-					if (register === "self") {
-						// Note that this is safe as long as we assume that this change will not be rebased
-						// over a move to a sequence field.
-						// The ID of an attach and accompanying detach/rename is arbitrary, except in sequence field where
-						// the ID of the detach becomes a cell ID which may be referenced by other changes.
-						replace.src = context.generateId();
-						decoded.nodeDetach = replace.src;
-					} else {
-						replace.src = register;
-					}
+					replace.src = registerIdCodec.decode(encoded.r.s, context.baseContext);
 				}
 				decoded.valueReplace = replace;
 			}
-
-			if (encoded.c !== undefined) {
-				for (const [encodedDetachId, nodeChange] of encoded.c) {
-					if (encodedDetachId !== null) {
-						context.decodeRootNodeChange(
-							changeAtomIdCodec.decode(encodedDetachId, context.baseContext),
-							nodeChange,
-						);
-					} else {
-						decoded.childChange = context.decodeNode(nodeChange);
-					}
-				}
-			}
-
-			for (const [encodedOldId, encodedNewId] of encoded.m ?? []) {
-				context.decodeRootRename(
-					changeAtomIdCodec.decode(encodedOldId, context.baseContext),
-					changeAtomIdCodec.decode(encodedNewId, context.baseContext),
-					1,
-				);
-			}
-
 			return decoded;
 		},
 		encodedSchema: EncodedOptionalChangeset(EncodedNodeChangeset),

package/src/feature-libraries/optional-field/optionalFieldCodecs.ts

@@ -13,7 +13,6 @@ import type { FieldChangeEncodingContext } from "../modular-schema/index.js";
 
 import type { OptionalChangeset } from "./optionalFieldChangeTypes.js";
 import { makeOptionalFieldCodec as makeV2Codec } from "./optionalFieldCodecV2.js";
-import { makeOptionalFieldCodec as makeV3Codec } from "./optionalFieldCodecV3.js";
 
 export const makeOptionalFieldCodecFamily = (
 	revisionTagCodec: IJsonCodec<
@@ -23,7 +22,4 @@ export const makeOptionalFieldCodecFamily = (
 		ChangeEncodingContext
 	>,
 ): ICodecFamily<OptionalChangeset, FieldChangeEncodingContext> =>
-	makeCodecFamily([
-		[2, makeV2Codec(revisionTagCodec)],
-		[3, makeV3Codec(revisionTagCodec)],
-	]);
+	makeCodecFamily([[2, makeV2Codec(revisionTagCodec)]]);

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

@@ -15,12 +15,11 @@ import {
 	makeVersionDispatchingCodec,
 	withSchemaValidation,
 } from "../../codec/index.js";
-import { getCodecTreeForSchemaFormat, makeSchemaCodec } from "../schema-index/index.js";
+import { makeSchemaCodec, schemaCodecBuilder } from "../schema-index/index.js";
 
 import { EncodedSchemaChange } from "./schemaChangeFormat.js";
 import type { SchemaChange } from "./schemaChangeTypes.js";
 import { SchemaFormatVersion } from "../../core/index.js";
-import { brand } from "../../util/index.js";
 
 /**
  * Create a family of schema change codecs.
@@ -31,8 +30,23 @@ export function makeSchemaChangeCodecs(
 	options: CodecWriteOptions,
 ): ICodecFamily<SchemaChange> {
 	return makeCodecFamily([
-		[SchemaFormatVersion.v1, makeSchemaChangeCodecV1(options, brand(SchemaFormatVersion.v1))],
-		[SchemaFormatVersion.v2, makeSchemaChangeCodecV1(options, brand(SchemaFormatVersion.v2))],
+		[SchemaFormatVersion.v1, makeSchemaChangeCodecV1(options, SchemaFormatVersion.v1)],
+		// This code  (makeSchemaChangeCodecs) is constructing a SchemaFormatVersion.v2 codec, regardless of the requested write version.
+		// It then trusts the user of the produced makeCodecFamily to only select if when it is valid to do so.
+		// This trust is manifests in having to use `allowPossiblyIncompatibleWriteVersionOverrides`
+		// here as it needs to build the v2 codec regardless of if its valid to use.
+		// TODO: There should not be two separate places selecting the write version for this codec. Such cases should instead adopt one of the following patterns:
+		// 1. The outer coded should let the inner one do its own version selection instead of forcing it.
+		// 2. The outer codec should fully handle version selection and embed the inner content directly (referencing its format not codec) and not involve the codec at all.
+		// TODO: fix this up when migrating SchemaChangeCodec to use ClientVersionDispatchingCodecBuilder.
+		// This should probably use pattern 1 above, which will result in this codec having two identical versions.
+		[
+			SchemaFormatVersion.v2,
+			makeSchemaChangeCodecV1(
+				{ ...options, allowPossiblyIncompatibleWriteVersionOverrides: true },
+				SchemaFormatVersion.v2,
+			),
+		],
 	]);
 }
 
@@ -43,7 +57,7 @@ export function getCodecTreeForSchemaChangeFormat(
 	return {
 		name: "SchemaChange",
 		version,
-		children: [getCodecTreeForSchemaFormat(clientVersion)],
+		children: [schemaCodecBuilder.getCodecTree(clientVersion)],
 	};
 }
 

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

@@ -3,22 +3,14 @@
  * Licensed under the MIT License.
  */
 
-import { fail, unreachableCase } from "@fluidframework/core-utils/internal";
-import {
-	getConfigForMinVersionForCollab,
-	lowestMinVersionForCollab,
-} from "@fluidframework/runtime-utils/internal";
+import { fail } from "@fluidframework/core-utils/internal";
+import { lowestMinVersionForCollab } from "@fluidframework/runtime-utils/internal";
 
 import {
-	type CodecTree,
+	ClientVersionDispatchingCodecBuilder,
 	type CodecWriteOptions,
 	FluidClientVersion,
-	type ICodecFamily,
-	type ICodecOptions,
 	type IJsonCodec,
-	makeCodecFamily,
-	makeVersionDispatchingCodec,
-	makeVersionedValidatedCodec,
 } from "../../codec/index.js";
 import {
 	SchemaFormatVersion,
@@ -30,84 +22,32 @@ import {
 	encodeFieldSchemaV2,
 	storedSchemaDecodeDispatcher,
 } from "../../core/index.js";
-import { brand, type JsonCompatible } from "../../util/index.js";
+import { brand } from "../../util/index.js";
 
 import { Format as FormatV1 } from "./formatV1.js";
 import { Format as FormatV2 } from "./formatV2.js";
-import type { MinimumVersionForCollab } from "@fluidframework/runtime-definitions/internal";
-
-/**
- * Convert a MinimumVersionForCollab to a SchemaFormatVersion.
- * @param clientVersion - The MinimumVersionForCollab to convert.
- * @returns The SchemaFormatVersion that corresponds to the provided MinimumVersionForCollab.
- */
-export function clientVersionToSchemaVersion(
-	clientVersion: MinimumVersionForCollab,
-): SchemaFormatVersion {
-	return brand(
-		getConfigForMinVersionForCollab(clientVersion, {
-			[lowestMinVersionForCollab]: SchemaFormatVersion.v1,
-			[FluidClientVersion.v2_43]: SchemaFormatVersion.v2,
-		}),
-	);
-}
-
-export function getCodecTreeForSchemaFormat(
-	clientVersion: MinimumVersionForCollab,
-): CodecTree {
-	return { name: "Schema", version: clientVersionToSchemaVersion(clientVersion) };
-}
 
 /**
  * Create a schema codec.
  * @param options - Specifies common codec options, including `minVersionForCollab` and which `validator` to use.
  * @param writeVersionOverride - The schema version to write. If not provided, the version will be derived from `minVersionForCollab`.
+ * TODO: Currently this parameter is provided when it probably should not be. Users of it should probably allow the automatic selection to occur and this parameter can be removed.
+ * Any case where an override is actually required can use `options` to do so.
  * @returns The composed codec.
  *
  * @privateRemarks We should consider using the Shared Tree format version instead as it may be more valuable for application authors than the schema version.
+ *
+ * TODO: replace use of this with schemaCodecBuilder.build(...).
  */
 export function makeSchemaCodec(
 	options: CodecWriteOptions,
 	writeVersionOverride?: SchemaFormatVersion,
 ): IJsonCodec<TreeStoredSchema> {
-	const family = makeSchemaCodecs(options);
-	return makeVersionDispatchingCodec(family, {
-		...options,
-		writeVersion:
-			writeVersionOverride ?? clientVersionToSchemaVersion(options.minVersionForCollab),
-	});
-}
-
-/**
- * Create a family of schema codecs.
- * @param options - Specifies common codec options, including which `validator` to use.
- * @returns The composed codec family.
- */
-export function makeSchemaCodecs(options: ICodecOptions): ICodecFamily<TreeStoredSchema> {
-	return makeCodecFamily([
-		[SchemaFormatVersion.v1, makeSchemaCodecV1(options)],
-		[SchemaFormatVersion.v2, makeSchemaCodecV2(options)],
-	]);
-}
-
-/**
- * Encode an in-memory TreeStoredSchema into the specified format version.
- * @param repo - The in-memory schema.
- * @param version - The schema write version.
- * @returns The encoded schema.
- */
-export function encodeRepo(
-	repo: TreeStoredSchema,
-	version: SchemaFormatVersion,
-): JsonCompatible {
-	switch (version) {
-		case SchemaFormatVersion.v1:
-			return encodeRepoV1(repo) as JsonCompatible;
-		case SchemaFormatVersion.v2:
-			return encodeRepoV2(repo) as JsonCompatible;
-		default:
-			unreachableCase(version);
+	const overrides = new Map(options.writeVersionOverrides ?? []);
+	if (writeVersionOverride !== undefined) {
+		overrides.set(schemaCodecBuilder.name, writeVersionOverride);
 	}
+	return schemaCodecBuilder.build({ ...options, writeVersionOverrides: overrides });
 }
 
 function encodeRepoV1(repo: TreeStoredSchema): FormatV1 {
@@ -184,24 +124,22 @@ function decodeV2(f: FormatV2): TreeStoredSchema {
 
 /**
  * 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 makeSchemaCodecV1(options: ICodecOptions): IJsonCodec<TreeStoredSchema, FormatV1> {
-	return makeVersionedValidatedCodec(options, new Set([SchemaFormatVersion.v1]), FormatV1, {
-		encode: (data: TreeStoredSchema) => encodeRepoV1(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([SchemaFormatVersion.v2]), FormatV2, {
-		encode: (data: TreeStoredSchema) => encodeRepoV2(data),
-		decode: (data: FormatV2) => decodeV2(data),
-	});
-}
+export const schemaCodecBuilder = ClientVersionDispatchingCodecBuilder.build("Schema", {
+	[lowestMinVersionForCollab]: {
+		formatVersion: SchemaFormatVersion.v1,
+		codec: {
+			encode: (data: TreeStoredSchema) => encodeRepoV1(data),
+			decode: (data: FormatV1) => decodeV1(data),
+			schema: FormatV1,
+		},
+	},
+	[FluidClientVersion.v2_43]: {
+		formatVersion: SchemaFormatVersion.v2,
+		codec: {
+			encode: (data: TreeStoredSchema) => encodeRepoV2(data),
+			decode: (data: FormatV2) => decodeV2(data),
+			schema: FormatV2,
+		},
+	},
+});

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

@@ -3,12 +3,10 @@
  * Licensed under the MIT License.
  */
 
-export { SchemaSummarizer, encodeTreeSchema } from "./schemaSummarizer.js";
+export { SchemaSummarizer } from "./schemaSummarizer.js";
 export {
 	makeSchemaCodec,
-	makeSchemaCodecs,
-	clientVersionToSchemaVersion,
-	getCodecTreeForSchemaFormat,
+	schemaCodecBuilder,
 } from "./codec.js";
 export { Format as FormatV1 } from "./formatV1.js";
 export { Format as FormatV2 } from "./formatV2.js";

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

@@ -17,7 +17,6 @@ import type { SummaryTreeBuilder } from "@fluidframework/runtime-utils/internal"
 import type { IJsonCodec } from "../../codec/index.js";
 import {
 	type MutableTreeStoredSchema,
-	type SchemaFormatVersion,
 	type TreeStoredSchema,
 	schemaDataIsEmpty,
 } from "../../core/index.js";
@@ -27,11 +26,8 @@ import {
 	type SummaryElementParser,
 	type SummaryElementStringifier,
 } from "../../shared-tree-core/index.js";
-import type { JsonCompatible } from "../../util/index.js";
 import type { CollabWindow } from "../incrementalSummarizationUtils.js";
 
-import { encodeRepo } from "./codec.js";
-
 export const schemaStringKey = "SchemaString";
 
 /**
@@ -141,16 +137,3 @@ export class SchemaSummarizer
 		this.schemaIndexLastChangedSeq = 0;
 	}
 }
-
-/**
- * Dumps schema into a deterministic JSON compatible semi-human readable format.
- *
- * @remarks
- * This can be used to help inspect schema for debugging, and to save a snapshot of schema to help detect and review changes to an applications schema.
- */
-export function encodeTreeSchema(
-	schema: TreeStoredSchema,
-	writeVersion: SchemaFormatVersion,
-): JsonCompatible {
-	return encodeRepo(schema, writeVersion);
-}

package/src/feature-libraries/schemaChecker.ts

@@ -93,7 +93,7 @@ export function isNodeInSchema<T extends NotUndefined>(
 			// Since this is testing compatibility with a stored schema (not view schema), "allowUnknownOptionalFields" does not exist at this layer.
 			// Code using this with a stored schema derived from a view schema rather than the document can be problematic because it may be missing unknown fields that the actual document has.
 			// Other schema evolution features like "staged" allowed types will likely cause similar issues elsewhere in this checker.
-			if (uncheckedFieldsFromNode.size !== 0) {
+			if (uncheckedFieldsFromNode.size > 0) {
 				return onError(SchemaValidationError.ObjectNode_FieldNotInSchema);
 			}
 		} else if (schema instanceof MapNodeStoredSchema) {
@@ -170,7 +170,7 @@ export function compliesWithMultiplicity(
 	multiplicity: Multiplicity,
 ): SchemaValidationError | undefined {
 	switch (multiplicity) {
-		case Multiplicity.Single:
+		case Multiplicity.Single: {
 			if (numberOfItems < 1) {
 				return SchemaValidationError.Field_MissingRequiredChild;
 			} else if (numberOfItems > 1) {
@@ -178,17 +178,22 @@ export function compliesWithMultiplicity(
 			} else {
 				return undefined;
 			}
-		case Multiplicity.Optional:
+		}
+		case Multiplicity.Optional: {
 			return numberOfItems > 1
 				? SchemaValidationError.Field_MultipleChildrenNotAllowed
 				: undefined;
-		case Multiplicity.Sequence:
+		}
+		case Multiplicity.Sequence: {
 			return undefined;
-		case Multiplicity.Forbidden:
+		}
+		case Multiplicity.Forbidden: {
 			return numberOfItems === 0
 				? undefined
 				: SchemaValidationError.Field_ChildInForbiddenField;
-		default:
+		}
+		default: {
 			unreachableCase(multiplicity);
+		}
 	}
 }