@fluidframework/tree 2.72.0 → 2.74.0-365691

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

@@ -18,22 +18,26 @@ import {
 	type FieldEditor,
 	type FieldKindConfiguration,
 	type FieldKindConfigurationEntry,
-	FieldKindWithEditor,
-	type FlexFieldKind,
+	FlexFieldKind,
+	type FullSchemaPolicy,
 	type ToDelta,
 	allowsTreeSchemaIdentifierSuperset,
 	referenceFreeFieldChangeRebaser,
 } from "../modular-schema/index.js";
 import {
 	type OptionalChangeset,
+	type OptionalFieldEditor,
 	optionalChangeHandler,
 	optionalFieldEditor,
 } from "../optional-field/index.js";
-import { sequenceFieldChangeHandler } from "../sequence-field/index.js";
+import {
+	sequenceFieldChangeHandler,
+	type SequenceFieldEditor,
+} from "../sequence-field/index.js";
 
 import { noChangeCodecFamily } from "./noChangeCodecs.js";
 import type { CodecTree } from "../../codec/index.js";
-import { brand, type Brand } from "../../util/index.js";
+import { brand, brandConst, type Brand } from "../../util/index.js";
 
 /**
  * ChangeHandler that only handles no-op / identity changes.
@@ -55,7 +59,15 @@ export const noChangeHandler: FieldChangeHandler<0> = {
 	getCrossFieldKeys: () => [],
 };
 
-export interface ValueFieldEditor extends FieldEditor<OptionalChangeset> {
+/**
+ * {@link FieldEditor} for required fields (always contain exactly 1 child).
+ * @remarks
+ * This shares code with optional fields, since they are the same edit wise except setting to empty is not allowed,
+ * and the content is always assumed to not be empty.
+ * This means the actual edits implemented for optional fields are sufficient to support required fields
+ * which is why this is defined and implemented in terms of optional fields.
+ */
+export interface RequiredFieldEditor extends FieldEditor<OptionalChangeset> {
 	/**
 	 * Creates a change which replaces the current value of the field with `newValue`.
 	 * @param ids - The ids for the fill and detach fields.
@@ -63,21 +75,19 @@ export interface ValueFieldEditor extends FieldEditor<OptionalChangeset> {
 	set(ids: { fill: ChangeAtomId; detach: ChangeAtomId }): OptionalChangeset;
 }
 
-const optionalIdentifier = "Optional";
+const optionalIdentifier = brandConst("Optional")<FieldKindIdentifier>();
+
 /**
  * 0 or 1 items.
  */
-export const optional = new FieldKindWithEditor(
-	optionalIdentifier,
-	Multiplicity.Optional,
-	optionalChangeHandler,
-	(types, other) =>
+export const optional = new FlexFieldKind(optionalIdentifier, Multiplicity.Optional, {
+	changeHandler: optionalChangeHandler,
+	allowsTreeSupersetOf: (types, other) =>
 		(other.kind === sequence.identifier || other.kind === optionalIdentifier) &&
 		allowsTreeSchemaIdentifierSuperset(types, other.types),
-	new Set([]),
-);
+});
 
-export const valueFieldEditor: ValueFieldEditor = {
+export const requiredFieldEditor: RequiredFieldEditor = {
 	...optionalFieldEditor,
 	set: (ids: {
 		fill: ChangeAtomId;
@@ -85,21 +95,22 @@ export const valueFieldEditor: ValueFieldEditor = {
 	}): OptionalChangeset => optionalFieldEditor.set(false, ids),
 };
 
-export const valueChangeHandler: FieldChangeHandler<OptionalChangeset, ValueFieldEditor> = {
-	...optional.changeHandler,
-	editor: valueFieldEditor,
+export const requiredFieldChangeHandler: FieldChangeHandler<
+	OptionalChangeset,
+	RequiredFieldEditor
+> = {
+	...optionalChangeHandler,
+	editor: requiredFieldEditor,
 };
 
-const requiredIdentifier = "Value";
+const requiredIdentifier = brandConst("Value")<FieldKindIdentifier>();
 
 /**
  * Exactly one item.
  */
-export const required = new FieldKindWithEditor(
-	requiredIdentifier,
-	Multiplicity.Single,
-	valueChangeHandler,
-	(types, other) =>
+export const required = new FlexFieldKind(requiredIdentifier, Multiplicity.Single, {
+	changeHandler: requiredFieldChangeHandler,
+	allowsTreeSupersetOf: (types, other) =>
 		// By omitting Identifier here,
 		// this is making a policy choice that a schema upgrade cannot be done from required to identifier.
 		// Since an identifier can be upgraded into a required field,
@@ -109,43 +120,35 @@ export const required = new FieldKindWithEditor(
 			other.kind === requiredIdentifier ||
 			other.kind === optional.identifier) &&
 		allowsTreeSchemaIdentifierSuperset(types, other.types),
-	new Set(),
-);
+});
 
-const sequenceIdentifier = "Sequence";
+const sequenceIdentifier = brandConst("Sequence")<FieldKindIdentifier>();
 
 /**
  * 0 or more items.
  */
-export const sequence = new FieldKindWithEditor(
-	sequenceIdentifier,
-	Multiplicity.Sequence,
-	sequenceFieldChangeHandler,
-	(types, other) =>
+export const sequence = new FlexFieldKind(sequenceIdentifier, Multiplicity.Sequence, {
+	changeHandler: sequenceFieldChangeHandler,
+	allowsTreeSupersetOf: (types, other) =>
 		other.kind === sequenceIdentifier &&
 		allowsTreeSchemaIdentifierSuperset(types, other.types),
-	// TODO: add normalizer/importers for handling ops from other kinds.
-	new Set([]),
-);
+});
 
-const identifierFieldIdentifier = "Identifier";
+const identifierFieldIdentifier = brandConst("Identifier")<FieldKindIdentifier>();
 
 /**
  * Exactly one identifier.
  */
-export const identifier = new FieldKindWithEditor(
-	identifierFieldIdentifier,
-	Multiplicity.Single,
-	noChangeHandler,
-	(types, other) =>
+export const identifier = new FlexFieldKind(identifierFieldIdentifier, Multiplicity.Single, {
+	changeHandler: noChangeHandler,
+	allowsTreeSupersetOf: (types, other) =>
 		// Allows upgrading from identifier to required: which way this upgrade is allowed to go is a subjective policy choice.
 		(other.kind === sequence.identifier ||
 			other.kind === requiredIdentifier ||
 			other.kind === optional.identifier ||
 			other.kind === identifierFieldIdentifier) &&
 		allowsTreeSchemaIdentifierSuperset(types, other.types),
-	new Set(),
-);
+});
 
 /**
  * Exactly 0 items.
@@ -175,39 +178,21 @@ export const identifier = new FieldKindWithEditor(
  *
  * See {@link emptyField} for a constant, reusable field using Forbidden.
  */
-export const forbidden = new FieldKindWithEditor(
+export const forbidden = new FlexFieldKind(
 	forbiddenFieldKindIdentifier,
 	Multiplicity.Forbidden,
-	noChangeHandler,
-	// All multiplicities other than Value support empty.
-	(types, other) => fieldKinds.get(other.kind)?.multiplicity !== Multiplicity.Single,
-	new Set(),
+	{
+		changeHandler: noChangeHandler,
+		// All multiplicities other than Value support empty.
+		allowsTreeSupersetOf: (types, other) =>
+			fieldKinds.get(other.kind)?.multiplicity !== Multiplicity.Single,
+	},
 );
 
 export const fieldKindConfigurations: ReadonlyMap<
 	ModularChangeFormatVersion,
 	FieldKindConfiguration
 > = new Map([
-	[
-		brand(1),
-		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
-			[required.identifier, { kind: required, formatVersion: 1 }],
-			[optional.identifier, { kind: optional, formatVersion: 1 }],
-			[sequence.identifier, { kind: sequence, formatVersion: 1 }],
-			[forbidden.identifier, { kind: forbidden, formatVersion: 1 }],
-			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
-		]),
-	],
-	[
-		brand(2),
-		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
-			[required.identifier, { kind: required, formatVersion: 2 }],
-			[optional.identifier, { kind: optional, formatVersion: 2 }],
-			[sequence.identifier, { kind: sequence, formatVersion: 1 }],
-			[forbidden.identifier, { kind: forbidden, formatVersion: 1 }],
-			[identifier.identifier, { kind: identifier, formatVersion: 1 }],
-		]),
-	],
 	[
 		brand(3),
 		new Map<FieldKindIdentifier, FieldKindConfigurationEntry>([
@@ -230,7 +215,7 @@ export const fieldKindConfigurations: ReadonlyMap<
 	],
 ]);
 
-export type ModularChangeFormatVersion = Brand<1 | 2 | 3 | 4, "ModularChangeFormatVersion">;
+export type ModularChangeFormatVersion = Brand<3 | 4, "ModularChangeFormatVersion">;
 export function getCodecTreeForModularChangeFormat(
 	version: ModularChangeFormatVersion,
 ): CodecTree {
@@ -256,7 +241,7 @@ export function getCodecTreeForModularChangeFormat(
  * Before making a SharedTree format change which impacts which set of field kinds are allowed,
  * code which uses this should be audited for compatibility considerations.
  */
-export const fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor> = new Map(
+export const fieldKinds: ReadonlyMap<FieldKindIdentifier, FlexFieldKind> = new Map(
 	[required, optional, sequence, identifier, forbidden].map((s) => [s.identifier, s]),
 );
 
@@ -265,12 +250,32 @@ export const fieldKinds: ReadonlyMap<FieldKindIdentifier, FieldKindWithEditor> =
 // TODO: Find a way to make docs like {@inheritDoc required} work in vscode.
 // TODO: ensure thy work in generated docs.
 // TODO: add these comments to the rest of the cases below.
-export interface Required extends FlexFieldKind<"Value", Multiplicity.Single> {}
-export interface Optional extends FlexFieldKind<"Optional", Multiplicity.Optional> {}
-export interface Sequence extends FlexFieldKind<"Sequence", Multiplicity.Sequence> {}
-export interface Identifier extends FlexFieldKind<"Identifier", Multiplicity.Single> {}
+export interface Required
+	extends FlexFieldKind<RequiredFieldEditor, typeof requiredIdentifier, Multiplicity.Single> {}
+export interface Optional
+	extends FlexFieldKind<
+		OptionalFieldEditor,
+		typeof optionalIdentifier,
+		Multiplicity.Optional
+	> {}
+export interface Sequence
+	extends FlexFieldKind<
+		SequenceFieldEditor,
+		typeof sequenceIdentifier,
+		Multiplicity.Sequence
+	> {}
+export interface Identifier
+	extends FlexFieldKind<
+		FieldEditor<0>,
+		typeof identifierFieldIdentifier,
+		Multiplicity.Single
+	> {}
 export interface Forbidden
-	extends FlexFieldKind<typeof forbiddenFieldKindIdentifier, Multiplicity.Forbidden> {}
+	extends FlexFieldKind<
+		FieldEditor<0>,
+		typeof forbiddenFieldKindIdentifier,
+		Multiplicity.Forbidden
+	> {}
 
 /**
  * Default FieldKinds with their editor types erased.
@@ -283,3 +288,10 @@ export const FieldKinds: {
 	readonly identifier: Identifier;
 	readonly forbidden: Forbidden;
 } = { required, optional, sequence, identifier, forbidden };
+
+/**
+ * FullSchemaPolicy with the default field kinds.
+ */
+export const defaultSchemaPolicy: FullSchemaPolicy = {
+	fieldKinds,
+};

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

@@ -14,6 +14,7 @@ export {
 	fieldKindConfigurations,
 	getCodecTreeForModularChangeFormat,
 	type ModularChangeFormatVersion,
+	defaultSchemaPolicy,
 } from "./defaultFieldKinds.js";
 
 export {
@@ -28,13 +29,4 @@ export {
 	relevantRemovedRoots,
 } from "./defaultEditBuilder.js";
 
-export {
-	SchemaValidationError,
-	isNodeInSchema,
-	isFieldInSchema,
-	throwOutOfSchema,
-} from "./schemaChecker.js";
-
-export { defaultSchemaPolicy } from "./defaultSchema.js";
-
 export { MappedEditBuilder } from "./mappedEditBuilder.js";

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

@@ -48,7 +48,7 @@ import {
 	ForestIncrementalSummaryBuilder,
 	forestSummaryContentKey,
 } from "./incrementalSummaryBuilder.js";
-import { TreeCompressionStrategyExtended } from "../treeCompressionUtils.js";
+import { TreeCompressionStrategy } from "../treeCompressionUtils.js";
 import type { IFluidHandle } from "@fluidframework/core-interfaces";
 
 /**
@@ -85,7 +85,7 @@ export class ForestSummarizer implements Summarizable {
 		this.codec = makeForestSummarizerCodec(options, fieldBatchCodec);
 		this.incrementalSummaryBuilder = new ForestIncrementalSummaryBuilder(
 			encoderContext.encodeType ===
-				TreeCompressionStrategyExtended.CompressedIncremental /* enableIncrementalSummary */,
+				TreeCompressionStrategy.CompressedIncremental /* enableIncrementalSummary */,
 			(cursor: ITreeCursorSynchronous) => this.forest.chunkField(cursor),
 			shouldEncodeIncrementally,
 			initialSequenceNumber,

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

@@ -7,7 +7,7 @@ import { type Static, Type } from "@sinclair/typebox";
 
 import { Versioned } from "../../codec/index.js";
 import { schemaFormatV1 } from "../../core/index.js";
-import type { Brand } from "../../util/index.js";
+import { brand, type Brand } from "../../util/index.js";
 
 /**
  * The format version for the forest.
@@ -20,13 +20,19 @@ export type ForestFormatVersion = Brand<
 	"ForestFormatVersion"
 >;
 
-export const Format = Type.Object(
-	{
-		version: Type.Literal(ForestFormatVersion.v1),
-		keys: Type.Array(schemaFormatV1.FieldKeySchema),
-		fields: Versioned,
-	},
-	{ additionalProperties: false },
-);
+const FormatGeneric = (
+	version: ForestFormatVersion,
+	// Return type is intentionally derived.
+	// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+) =>
+	Type.Object(
+		{
+			version: Type.Literal(version),
+			keys: Type.Array(schemaFormatV1.FieldKeySchema),
+			fields: Versioned,
+		},
+		{ additionalProperties: false },
+	);
 
+export const Format = FormatGeneric(brand<ForestFormatVersion>(ForestFormatVersion.v1));
 export type Format = Static<typeof Format>;

package/src/feature-libraries/index.ts

@@ -81,7 +81,6 @@ export {
 	genericFieldKind,
 	type HasFieldChanges,
 	type NodeExistsConstraint,
-	FieldKindWithEditor,
 	ModularChangeFamily,
 	type RelevantRemovedRootsFromChild,
 	EncodedModularChangeset,
@@ -104,7 +103,7 @@ export {
 	defaultChunkPolicy,
 	type FieldBatch,
 	type FieldBatchCodec,
-	type FieldBatchFormatVersion,
+	FieldBatchFormatVersion,
 	getCodecTreeForFieldBatchFormat,
 	makeTreeChunker,
 	makeFieldBatchCodec,
@@ -145,13 +144,16 @@ export {
 	fieldKindConfigurations,
 	intoDelta,
 	relevantRemovedRoots,
+	getCodecTreeForModularChangeFormat,
+	type ModularChangeFormatVersion,
+} from "./default-schema/index.js";
+
+export {
 	SchemaValidationError,
 	isNodeInSchema,
 	isFieldInSchema,
 	throwOutOfSchema,
-	getCodecTreeForModularChangeFormat,
-	type ModularChangeFormatVersion,
-} from "./default-schema/index.js";
+} from "./schemaChecker.js";
 
 export {
 	type FlexTreeOptionalField,
@@ -188,11 +190,7 @@ export {
 	type Observer,
 } from "./flex-tree/index.js";
 
-export {
-	TreeCompressionStrategy,
-	TreeCompressionStrategyExtended,
-	type TreeCompressionStrategyPrivate,
-} from "./treeCompressionUtils.js";
+export { TreeCompressionStrategy } from "./treeCompressionUtils.js";
 
 export { valueSchemaAllows } from "./valueUtilities.js";
 

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

@@ -19,7 +19,6 @@ import {
 import { compareSets } from "../../util/index.js";
 
 import type { FullSchemaPolicy } from "./fieldKind.js";
-import { withEditor } from "./fieldKindWithEditor.js";
 import { isNeverTree } from "./isNeverTree.js";
 
 /**
@@ -133,8 +132,8 @@ export function allowsFieldSuperset(
 	original: TreeFieldStoredSchema,
 	superset: TreeFieldStoredSchema,
 ): boolean {
-	return withEditor(
-		policy.fieldKinds.get(original.kind) ?? fail(0xb1b /* missing kind */),
+	return (
+		policy.fieldKinds.get(original.kind) ?? fail(0xb1b /* missing kind */)
 	).allowsFieldSuperset(policy, originalData, original.types, superset);
 }
 

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

@@ -8,7 +8,14 @@ import type {
 	FieldKindData,
 	Multiplicity,
 	SchemaPolicy,
+	TreeFieldStoredSchema,
+	TreeStoredSchema,
+	TreeTypeSet,
 } from "../../core/index.js";
+import type { MakeNominal } from "../../util/index.js";
+
+import type { FieldChangeHandler, FieldEditor } from "./fieldChangeHandler.js";
+import { isNeverField } from "./isNeverTree.js";
 
 /**
  * Functionality for FieldKinds that is stable,
@@ -22,26 +29,96 @@ import type {
  *
  * These policies include the data encoding, change encoding, change rebase and change application.
  *
- * @sealed * @privateRemarks
- * This being @sealed is for users of this package.
- * This package itself may provide implementations.
- * This pattern was picked instead of an interface since we do not have a convention for how to mark interfaces as only allowed to be implemented by the package declaring them,
- * and using a class also gets stronger (nominal) typing for objects which will be down cast.
+ * @privateRemarks
+ * Using a class gets stronger (nominal) typing for objects which will be down cast.
  */
-export abstract class FlexFieldKind<
-	TName extends string = string,
+export class FlexFieldKind<
+	// TODO: stronger typing
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	TEditor extends FieldEditor<any> = FieldEditor<any>,
+	TName extends FieldKindIdentifier = FieldKindIdentifier,
 	TMultiplicity extends Multiplicity = Multiplicity,
 > implements FieldKindData
 {
+	protected _typeCheck!: MakeNominal;
+
 	/**
-	 * @param identifier - Globally scoped identifier.
-	 * @param multiplicity - bound on the number of children that fields of this kind may have.
-	 * TODO: consider replacing with numeric upper and lower bounds.
+	 * Change handling policy.
 	 */
-	protected constructor(
-		public readonly identifier: TName & FieldKindIdentifier,
+	// TODO: stronger typing
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	public readonly changeHandler: FieldChangeHandler<any, TEditor>;
+
+	public constructor(
+		public readonly identifier: TName,
 		public readonly multiplicity: TMultiplicity,
-	) {}
+		// TODO: stronger typing
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		private readonly options: FieldKindOptions<FieldChangeHandler<any, TEditor>>,
+	) {
+		this.changeHandler = options.changeHandler;
+	}
+
+	/**
+	 * Returns true if and only if `superset` permits a (non-strict) superset of the subtrees
+	 * allowed by field made from `this` and `originalTypes`.
+	 *
+	 * TODO: clarify the relationship between this and FieldKindData, and issues with cyclic schema upgrades.
+	 */
+	public allowsFieldSuperset(
+		policy: SchemaPolicy,
+		originalData: TreeStoredSchema,
+		originalTypes: TreeTypeSet,
+		superset: TreeFieldStoredSchema,
+	): boolean {
+		if (
+			isNeverField(policy, originalData, {
+				kind: this.identifier,
+				types: originalTypes,
+				// Metadata is not used for this check.
+				persistedMetadata: undefined,
+			})
+		) {
+			return true;
+		}
+		if (isNeverField(policy, originalData, superset)) {
+			return false;
+		}
+		return this.options.allowsTreeSupersetOf(originalTypes, superset);
+	}
+}
+
+/**
+ * Additional options for {@link FlexFieldKind}.
+ *
+ * @remarks
+ * Puts the more confusing parameters into this object so they get explicit names to help with clarity.
+ */
+export interface FieldKindOptions<TFieldChangeHandler> {
+	/**
+	 * Change handling policy.
+	 */
+	readonly changeHandler: TFieldChangeHandler;
+
+	/**
+	 * Returns true if and only if `superset` permits a (non-strict) superset of the subtrees
+	 * allowed by field made from `this` and `originalTypes`.
+	 * @remarks
+	 * Used by {@link FlexFieldKind.allowsFieldSuperset}, which handles the `never` cases before calling this.
+	 */
+	readonly allowsTreeSupersetOf: (
+		originalTypes: TreeTypeSet,
+		superset: TreeFieldStoredSchema,
+	) => boolean;
+
+	/**
+	 * Kinds (in addition to this) whose edits can be processed by changeHandler.
+	 * If the kind of a field changes, and edits are rebased across that kind change,
+	 * listing the other old kind here can prevent those edits from being conflicted and
+	 * provide a chance to handle them.
+	 */
+	// TODO: provide this and use it for improved support for rebasing changes across schema upgrades.
+	// readonly handlesEditsFrom: ReadonlySet<FieldKindIdentifier>;
 }
 
 /**

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

@@ -4,14 +4,13 @@
  */
 
 import type { FieldKindIdentifier } from "../../core/index.js";
-
-import type { FieldKindWithEditor } from "./fieldKindWithEditor.js";
+import type { FlexFieldKind } from "./fieldKind.js";
 
 /**
  * Configuration for a single field kind.
  */
 export interface FieldKindConfigurationEntry {
-	readonly kind: FieldKindWithEditor;
+	readonly kind: FlexFieldKind;
 	/**
 	 * The format to be used for encoding changesets for this field kind.
 	 */

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

@@ -9,6 +9,7 @@ import { BTree } from "@tylerbu/sorted-btree-es6";
 import {
 	type DeltaDetachedNodeId,
 	type DeltaMark,
+	type FieldKindIdentifier,
 	Multiplicity,
 	type RevisionTag,
 	replaceAtomRevisions,
@@ -24,10 +25,11 @@ import type {
 	RelevantRemovedRootsFromChild,
 	ToDelta,
 } from "./fieldChangeHandler.js";
-import { FieldKindWithEditor } from "./fieldKindWithEditor.js";
 import { makeGenericChangeCodec } from "./genericFieldKindCodecs.js";
 import { newGenericChangeset, type GenericChangeset } from "./genericFieldKindTypes.js";
 import type { NodeId } from "./modularChangeTypes.js";
+import { FlexFieldKind } from "./fieldKind.js";
+import { brandConst } from "../../util/index.js";
 
 /**
  * {@link FieldChangeHandler} implementation for {@link GenericChangeset}.
@@ -164,12 +166,10 @@ function replaceRevisions(
 /**
  * {@link FieldKind} used to represent changes to elements of a field in a field-kind-agnostic format.
  */
-export const genericFieldKind: FieldKindWithEditor = new FieldKindWithEditor(
-	"ModularEditBuilder.Generic",
+export const genericFieldKind: FlexFieldKind = new FlexFieldKind(
+	brandConst("ModularEditBuilder.Generic")<FieldKindIdentifier>(),
 	Multiplicity.Sequence,
-	genericChangeHandler,
-	(types, other) => false,
-	new Set(),
+	{ changeHandler: genericChangeHandler, allowsTreeSupersetOf: (types, other) => false },
 );
 
 /**

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

@@ -26,7 +26,6 @@ export {
 	EncodedNodeChangeset,
 } from "./modularChangeFormat.js";
 export { FlexFieldKind, type FullSchemaPolicy } from "./fieldKind.js";
-export { FieldKindWithEditor } from "./fieldKindWithEditor.js";
 export {
 	type FieldChangeHandler,
 	type FieldChangeDelta,

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

@@ -13,12 +13,11 @@ import {
 	type TreeNodeStoredSchema,
 	type TreeStoredSchema,
 	Multiplicity,
+	type SchemaPolicy,
 } from "../../core/index.js";
 
-import type { FullSchemaPolicy } from "./fieldKind.js";
-
 export function isNeverField(
-	policy: FullSchemaPolicy,
+	policy: SchemaPolicy,
 	originalData: TreeStoredSchema,
 	field: TreeFieldStoredSchema,
 ): boolean {
@@ -26,7 +25,7 @@ export function isNeverField(
 }
 
 export function isNeverFieldRecursive(
-	policy: FullSchemaPolicy,
+	policy: SchemaPolicy,
 	originalData: TreeStoredSchema,
 	field: TreeFieldStoredSchema,
 	parentTypeStack: Set<TreeNodeStoredSchema>,
@@ -54,29 +53,29 @@ export function isNeverFieldRecursive(
 	}
 	return false;
 }
+
 /**
  * Returns true iff there are no possible trees that could meet this schema.
  * Trees which are infinite (like endless linked lists) are considered impossible.
  *
  * `undefined` means the schema is not present and thus a NeverTree.
  */
-
 export function isNeverTree(
-	policy: FullSchemaPolicy,
+	policy: SchemaPolicy,
 	originalData: TreeStoredSchema,
 	treeNode: TreeNodeStoredSchema | undefined,
 ): boolean {
 	return isNeverTreeRecursive(policy, originalData, treeNode, new Set());
 }
+
 /**
  * Returns true iff there are no possible trees that could meet this schema.
  * Trees which are infinite (like endless linked lists) are considered impossible.
  *
  * `undefined` means the schema is not present and thus a NeverTree.
  */
-
 export function isNeverTreeRecursive(
-	policy: FullSchemaPolicy,
+	policy: SchemaPolicy,
 	originalData: TreeStoredSchema,
 	treeNode: TreeNodeStoredSchema | undefined,
 	parentTypeStack: Set<TreeNodeStoredSchema>,