@fluidframework/tree 2.1.0 → 2.3.0-288113

package/src/feature-libraries/sequence-field/types.ts

@@ -104,6 +104,10 @@ export interface MoveIn extends HasMoveFields {
 export interface DetachFields {
 	/**
 	 * When set, the detach should use the `CellId` specified in this object to characterize the cell being emptied.
+	 *
+	 * This is used in two situations:
+	 * - to restore the prior ID of a cell in a rollback changeset
+	 * - to represent the impact of a detach composed with a rename
 	 */
 	readonly idOverride?: CellId;
 }
@@ -142,9 +146,12 @@ export type Detach = Remove | MoveOut;
  *
  * Only ever targets empty cells.
  *
- * As a matter of normalization, only use an AttachAndDetach mark when the attach is a new insert or a move
- * destination. In all other cases (the attach would be a revive), we rely on the implicit reviving semantics of the
- * detach and represent that detach on its own (i.e., not wrapped in an AttachAndDetach).
+ * As a matter of normalization, we only use an AttachAndDetach to represent MoveIn ○ Remove.
+ *
+ * We do NOT use AttachAndDetach to represent the following compositions:
+ * - Insert/Revive ○ Remove (represented by a Remove)
+ * - Insert/Revive ○ MoveOut (represented by a MoveOut)
+ * - MoveIn ○ MoveOut (represented by a Rename)
  */
 export interface AttachAndDetach {
 	type: "AttachAndDetach";
@@ -152,7 +159,20 @@ export interface AttachAndDetach {
 	detach: Detach;
 }
 
-export type MarkEffect = NoopMark | Attach | Detach | AttachAndDetach;
+/**
+ * Represents the renaming of an empty cell.
+ *
+ * Only ever targets empty cells.
+ *
+ * Occurs when a MoveIn is composed with a MoveOut.
+ * TODO: Use Rename when an Insert/Revive is composed with a Remove.
+ */
+export interface Rename {
+	type: "Rename";
+	readonly idOverride: CellId;
+}
+
+export type MarkEffect = NoopMark | Attach | Detach | AttachAndDetach | Rename;
 
 export type CellMark<TMark> = TMark & HasMarkFields;
 

package/src/feature-libraries/sequence-field/utils.ts

@@ -43,6 +43,8 @@ import {
 	type NoopMark,
 	NoopMarkType,
 	type Remove,
+	type CellCount,
+	type Rename,
 } from "./types.js";
 
 export function isEmpty(change: Changeset): boolean {
@@ -89,6 +91,10 @@ export function isNewAttachEffect(
 	);
 }
 
+export function isRename(mark: MarkEffect): mark is Rename {
+	return mark.type === "Rename";
+}
+
 export function isInsert(mark: MarkEffect): mark is Insert {
 	return mark.type === "Insert";
 }
@@ -119,30 +125,11 @@ export function areEqualCellIds(a: CellId | undefined, b: CellId | undefined): b
 }
 
 export function getInputCellId(mark: Mark): CellId | undefined {
-	const cellId = mark.cellId;
-	if (cellId === undefined) {
-		return undefined;
-	}
-
-	if (cellId.revision !== undefined) {
-		return cellId;
-	}
-
-	let markRevision: RevisionTag | undefined;
-	if (isAttachAndDetachEffect(mark)) {
-		markRevision = mark.attach.revision;
-	} else if (!isNoopMark(mark)) {
-		markRevision = mark.revision;
-	}
-
-	return {
-		...cellId,
-		revision: markRevision,
-	};
+	return mark.cellId;
 }
 
 export function getOutputCellId(mark: Mark): CellId | undefined {
-	if (isDetach(mark)) {
+	if (isDetach(mark) || isRename(mark)) {
 		return getDetachOutputCellId(mark);
 	} else if (markFillsCells(mark)) {
 		return undefined;
@@ -295,15 +282,24 @@ export function compareCellPositionsUsingTombstones(
 /**
  * @returns the ID of the cell in the output context of the given detach `mark`.
  */
-export function getDetachOutputCellId(mark: Detach): ChangeAtomId {
-	return mark.idOverride ?? { revision: mark.revision, localId: mark.id };
+export function getDetachOutputCellId(mark: Detach | Rename): ChangeAtomId {
+	if (isRename(mark)) {
+		return mark.idOverride;
+	}
+	if (mark.idOverride !== undefined) {
+		return mark.idOverride;
+	}
+	return mark.revision === undefined
+		? { localId: mark.id }
+		: { revision: mark.revision, localId: mark.id };
 }
 
 /**
  * @returns the ID of the detached node in the output context of the given detach `mark`.
  */
-export function getDetachedNodeId(mark: Detach): ChangeAtomId {
+export function getDetachedNodeId(mark: Detach | Rename): ChangeAtomId {
 	switch (mark.type) {
+		case "Rename":
 		case "Remove": {
 			return getDetachOutputCellId(mark);
 		}
@@ -319,25 +315,41 @@ export function getDetachedNodeId(mark: Detach): ChangeAtomId {
  * Preserves the semantics of the given `mark` but repackages it into a `DetachOfRemovedNodes` when possible.
  */
 export function normalizeCellRename(
-	mark: CellMark<AttachAndDetach>,
-): CellMark<AttachAndDetach | DetachOfRemovedNodes> {
-	assert(mark.cellId !== undefined, 0x823 /* AttachAndDetach marks should have a cell ID */);
-	// We must keep the attach information when the attach is a move-in because the input-context cell ID may not be
-	// enough to identify the move ID.
-	// TODO: revisit if we still need the attach information for new inserts.
-	if (mark.attach.type !== "Insert" || isNewAttachEffect(mark.attach, mark.cellId)) {
-		return mark;
+	cellId: CellId,
+	count: CellCount,
+	attach: Attach,
+	detach: Detach,
+): CellMark<AttachAndDetach | DetachOfRemovedNodes | Rename | NoopMark> {
+	if (attach.type === "MoveIn") {
+		if (detach.type === "MoveOut") {
+			const outputId = getDetachOutputCellId(detach);
+			// Note that the output ID may be the same as the cellId. In such a scenario,
+			// we output an (impact-less) Rename mark anyway (as opposed to a Skip)
+			// because the resulting Rename may be rebased over other changes that rename the input cell,
+			// eventually leading to an impactful rename.
+			return {
+				type: "Rename",
+				count,
+				cellId,
+				idOverride: outputId,
+			};
+		}
+	} else {
+		// Normalization: when the attach is an insert/revive, we rely on the implicit reviving semantics of the
+		// detach instead of using an explicit revive effect in an AttachAndDetach
+		return {
+			...detach,
+			count,
+			cellId,
+		};
 	}
-	// Normalization: when the attach is a revive, we rely on the implicit reviving semantics of the
-	// detach instead of using an explicit revive effect in an AttachAndDetach mark.
-	return withNodeChange(
-		{
-			...mark.detach,
-			count: mark.count,
-			cellId: mark.cellId,
-		},
-		mark.changes,
-	);
+	return {
+		type: "AttachAndDetach",
+		attach,
+		detach,
+		count,
+		cellId,
+	};
 }
 
 /**
@@ -443,6 +455,7 @@ export function areOutputCellsEmpty(mark: Mark): boolean {
 		case NoopMarkType:
 			return mark.cellId !== undefined;
 		case "Remove":
+		case "Rename":
 		case "MoveOut":
 		case "AttachAndDetach":
 			return true;
@@ -478,6 +491,8 @@ export function isImpactful(mark: Mark): boolean {
 	switch (type) {
 		case NoopMarkType:
 			return false;
+		case "Rename":
+			return true;
 		case "Remove": {
 			const inputId = getInputCellId(mark);
 			if (inputId === undefined) {
@@ -643,7 +658,9 @@ function tryMergeEffects(
 		return { ...lhsAttachAndDetach, attach, detach };
 	}
 
-	if ((lhs as HasRevisionTag).revision !== rhs.revision) {
+	if (
+		(lhs as Partial<HasRevisionTag>).revision !== (rhs as Partial<HasRevisionTag>).revision
+	) {
 		return undefined;
 	}
 
@@ -673,6 +690,13 @@ function tryMergeEffects(
 			}
 			break;
 		}
+		case "Rename": {
+			const lhsDetach = lhs as Rename;
+			if (haveMergeableIdOverrides(lhsDetach, lhsCount, rhs)) {
+				return lhsDetach;
+			}
+			break;
+		}
 		case "MoveOut": {
 			const lhsMoveOut = lhs as MoveOut;
 			if (
@@ -763,6 +787,15 @@ export function splitMarkEffect<TEffect extends MarkEffect>(
 			}
 			return [effect1, effect2];
 		}
+		case "Rename": {
+			const effect1 = { ...effect };
+			const effect2 = { ...effect };
+			const effect2Rename = effect2 as Mutable<Rename>;
+			if (effect2Rename.idOverride !== undefined) {
+				effect2Rename.idOverride = splitDetachEvent(effect2Rename.idOverride, length);
+			}
+			return [effect1, effect2];
+		}
 		case "MoveOut": {
 			const effect2 = {
 				...effect,
@@ -861,7 +894,7 @@ export function withRevision<TMark extends Mark>(
 }
 
 function addRevision(effect: MarkEffect, revision: RevisionTag): void {
-	if (effect.type === NoopMarkType) {
+	if (effect.type === NoopMarkType || isRename(effect)) {
 		return;
 	}
 
@@ -879,12 +912,7 @@ function addRevision(effect: MarkEffect, revision: RevisionTag): void {
 }
 
 export function getEndpoint(effect: MoveMarkEffect): ChangeAtomId {
-	return effect.finalEndpoint !== undefined
-		? {
-				...effect.finalEndpoint,
-				revision: effect.finalEndpoint.revision ?? effect.revision,
-			}
-		: { revision: effect.revision, localId: effect.id };
+	return effect.finalEndpoint ?? { revision: effect.revision, localId: effect.id };
 }
 
 export function getCrossFieldKeys(change: Changeset): CrossFieldKeyRange[] {

package/src/feature-libraries/storedToViewSchema.ts

@@ -35,7 +35,6 @@ import {
  * If the input schema came from a view schema, it will not return the same view schema, and will not be compatible:
  * the returned TreeSchema is simply one which schematize will not object to.
  * Assumes the schema uses the default field kinds.
- * @internal
  */
 export function treeSchemaFromStoredSchema(schema: TreeStoredSchema): FlexTreeSchema {
 	const map: Map<TreeNodeSchemaIdentifier, FlexTreeNodeSchema> = new Map();

package/src/feature-libraries/treeCursorUtils.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
+import { assert, oob } from "@fluidframework/core-utils/internal";
 
 import {
 	CursorLocationType,
@@ -23,7 +23,6 @@ import { fail } from "../util/index.js";
 
 /**
  * {@link ITreeCursorSynchronous} that can return the underlying node objects.
- * @internal
  */
 export interface CursorWithNode<TNode> extends ITreeCursorSynchronous {
 	/**
@@ -48,7 +47,6 @@ export interface CursorWithNode<TNode> extends ITreeCursorSynchronous {
  * Create a cursor, in `nodes` mode at the root of the provided tree.
  *
  * @returns an {@link ITreeCursorSynchronous} for a single root in `nodes` mode.
- * @internal
  */
 export function stackTreeNodeCursor<TNode>(
 	adapter: CursorAdapter<TNode>,
@@ -61,7 +59,6 @@ export function stackTreeNodeCursor<TNode>(
  * Create a cursor, in `fields` mode at the `detachedField` under the provided `root`.
  *
  * @returns an {@link ITreeCursorSynchronous} for `detachedField` of `root` in `fields` mode.
- * @internal
  */
 export function stackTreeFieldCursor<TNode>(
 	adapter: CursorAdapter<TNode>,
@@ -77,7 +74,6 @@ export function stackTreeFieldCursor<TNode>(
 
 /**
  * Provides functionality to allow a {@link stackTreeNodeCursor} and {@link stackTreeFieldCursor} to implement cursors.
- * @internal
  */
 export interface CursorAdapter<TNode> {
 	/**
@@ -156,17 +152,21 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 
 	private getStackedFieldKey(height: number): FieldKey {
 		assert(height % 2 === 1, 0x3b8 /* must field height */);
-		return this.siblingStack[height][this.indexStack[height]] as FieldKey;
+		const siblingStack = this.siblingStack[height] ?? oob();
+		const indexStack = this.indexStack[height] ?? oob();
+		return siblingStack[indexStack] as FieldKey;
 	}
 
 	private getStackedNodeIndex(height: number): number {
 		// assert(height % 2 === 0, "must be node height");
-		return this.indexStack[height];
+		return this.indexStack[height] ?? oob();
 	}
 
 	private getStackedNode(height: number): TNode {
 		const index = this.getStackedNodeIndex(height);
-		return (this.siblingStack[height] as readonly TNode[])[index];
+		// Test is failing when using `?? oob()` here.
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return (this.siblingStack[height] as readonly TNode[])[index]!;
 	}
 
 	public getFieldLength(): number {
@@ -350,7 +350,9 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 
 	public getNode(): TNode {
 		// assert(this.mode === CursorLocationType.Nodes, "can only get node when in node");
-		return (this.siblings as TNode[])[this.index];
+		// Test is failing when using `?? oob()` here.
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return (this.siblings as TNode[])[this.index]!;
 	}
 
 	private getField(): readonly TNode[] {
@@ -389,7 +391,6 @@ class StackCursor<TNode> extends SynchronousCursor implements CursorWithNode<TNo
 
 /**
  * Apply `prefix` to `path`.
- * @internal
  */
 export function prefixPath(
 	prefix: PathRootPrefix | undefined,
@@ -410,7 +411,6 @@ export function prefixPath(
 
 /**
  * Apply `prefix` to `path`.
- * @internal
  */
 export function prefixFieldPath(
 	prefix: PathRootPrefix | undefined,

package/src/feature-libraries/treeTextCursor.ts

@@ -60,7 +60,6 @@ import {
  * Do not confuse this with {@link JsonableTree} with the JSON domain:
  * this takes in data in a specific format that is json compatible (except for FluidHandle values).
  * That is distinct from treating arbitrary JSON data as a tree in the JSON domain.
- * @internal
  */
 export function cursorForJsonableTreeNode(root: JsonableTree): ITreeCursorSynchronous {
 	return stackTreeNodeCursor(adapter, root);
@@ -91,7 +90,6 @@ export const adapter: CursorAdapter<JsonableTree> = {
 
 /**
  * Extract a JsonableTree from the contents of the given ITreeCursor's current node.
- * @internal
  */
 export function jsonableTreeFromCursor(cursor: ITreeCursor): JsonableTree {
 	assert(cursor.mode === CursorLocationType.Nodes, 0x3ba /* must start at node */);

package/src/feature-libraries/typed-schema/flexList.ts

@@ -87,7 +87,6 @@ export function normalizeFlexListEager<List extends FlexList>(
 export type LazyItem<Item = unknown> = Item | (() => Item);
 
 /**
- * @internal
  */
 export type NormalizedFlexList<Item> = readonly Item[];
 
@@ -102,7 +101,6 @@ export type ExtractItemType<Item extends LazyItem> = Item extends () => infer Re
 	: Item;
 
 /**
- * @internal
  */
 export type ExtractListItemType<List extends FlexList> = List extends FlexList<infer Item>
 	? Item
@@ -128,7 +126,6 @@ export type FlexListToUnion<TList extends FlexList> = ExtractItemType<TList[numb
 
 /**
  * Normalize FlexList type to a non-lazy array.
- * @internal
  */
 export type ConstantFlexListToNonLazyArray<List extends FlexList> = List extends readonly [
 	infer Head,

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

@@ -13,7 +13,6 @@ export {
 	LeafNodeSchema,
 	FlexMapNodeSchema,
 	FlexObjectNodeSchema,
-	FlexFieldNodeSchema,
 	type FlexTreeSchema,
 	type Unenforced,
 	type AllowedTypeSet,
@@ -21,7 +20,6 @@ export {
 	type SchemaCollection,
 	TreeNodeSchemaBase,
 	type FlexObjectNodeFields,
-	schemaIsFieldNode,
 	schemaIsLeaf,
 	schemaIsMap,
 	schemaIsObjectNode,

package/src/feature-libraries/typed-schema/schemaCollection.ts

@@ -16,7 +16,6 @@ import { FieldKinds, defaultSchemaPolicy } from "../default-schema/index.js";
 
 import { normalizeFlexListEager } from "./flexList.js";
 import {
-	FlexFieldNodeSchema,
 	type FlexFieldSchema,
 	FlexMapNodeSchema,
 	FlexObjectNodeSchema,
@@ -180,10 +179,6 @@ export function validateSchemaCollection(
 			}
 		} else if (tree instanceof LeafNodeSchema) {
 			// No validation for now.
-		} else if (tree instanceof FlexFieldNodeSchema) {
-			const description = (): string =>
-				`Field node field of "${identifier}" schema from library "${tree.builder.name}"`;
-			validateField(lintConfiguration, collection, tree.info, description, errors);
 		} else if (tree instanceof FlexObjectNodeSchema) {
 			for (const [key, field] of tree.objectNodeFields) {
 				const description = (): string =>

package/src/feature-libraries/typed-schema/typedTreeSchema.ts

@@ -7,7 +7,6 @@ import { assert, Lazy } from "@fluidframework/core-utils/internal";
 
 import {
 	type Adapters,
-	EmptyKey,
 	type FieldKey,
 	LeafNodeStoredSchema,
 	MapNodeStoredSchema,
@@ -38,14 +37,12 @@ import type { LazyItem } from "./flexList.js";
 import { type ObjectToMap, objectToMapTyped } from "./typeUtils.js";
 
 /**
- * @internal
  */
 export interface FlexObjectNodeFields {
 	readonly [key: string]: FlexFieldSchema;
 }
 
 /**
- * @internal
  */
 export type NormalizeObjectNodeFields<T extends FlexObjectNodeFields> = {
 	readonly [Property in keyof T]: NormalizeField<T[Property]>;
@@ -69,13 +66,12 @@ export type Unenforced<_DesiredExtendsConstraint> = unknown;
  * T must extend TreeSchemaSpecification.
  * This can not be enforced using TypeScript since doing so breaks recursive type support.
  * See note on SchemaBuilder.fieldRecursive.
- * @internal
  */
 export abstract class TreeNodeSchemaBase<
 	const out Name extends string = string,
 	const out Specification = unknown,
 > {
-	protected _typeCheck?: MakeNominal;
+	protected _typeCheck!: MakeNominal;
 	protected constructor(
 		public readonly builder: Named<string>,
 		public readonly name: TreeNodeSchemaIdentifier<Name>,
@@ -86,7 +82,6 @@ export abstract class TreeNodeSchemaBase<
 }
 
 /**
- * @internal
  */
 export class FlexMapNodeSchema<
 	const out Name extends string = string,
@@ -119,7 +114,6 @@ export class FlexMapNodeSchema<
 }
 
 /**
- * @internal
  */
 export class LeafNodeSchema<
 	const out Name extends string = string,
@@ -149,7 +143,6 @@ export class LeafNodeSchema<
 }
 
 /**
- * @internal
  */
 export class FlexObjectNodeSchema<
 	const out Name extends string = string,
@@ -210,40 +203,6 @@ export class FlexObjectNodeSchema<
 }
 
 /**
- * TODO: remove or replace (or subclass) this with more specific types, like "List".
- * @internal
- */
-export class FlexFieldNodeSchema<
-	Name extends string = string,
-	Specification extends Unenforced<FlexFieldSchema> = FlexFieldSchema,
-> extends TreeNodeSchemaBase<Name, Specification> {
-	protected _typeCheck2?: MakeNominal;
-	public static create<const Name extends string, const Specification extends FlexFieldSchema>(
-		builder: Named<string>,
-		name: TreeNodeSchemaIdentifier<Name>,
-		specification: Specification,
-	): FlexFieldNodeSchema<Name, Specification> {
-		return new FlexFieldNodeSchema(builder, name, specification);
-	}
-
-	private constructor(
-		builder: Named<string>,
-		name: TreeNodeSchemaIdentifier<Name>,
-		info: Specification,
-	) {
-		const objectNodeFields = new Map([[EmptyKey, (info as FlexFieldSchema).stored]]);
-		super(builder, name, info, new ObjectNodeStoredSchema(objectNodeFields));
-	}
-
-	public override getFieldSchema(field?: FieldKey): FlexFieldSchema {
-		return (field ?? EmptyKey) === EmptyKey
-			? (this.info as FlexFieldSchema)
-			: FlexFieldSchema.empty;
-	}
-}
-
-/**
- * @internal
  * @privateRemarks
  * This could be an exhaustive union, or just the common base type.
  * Using just the base type prevents exhaustive matching, which has both pros and cons.
@@ -254,7 +213,6 @@ export type FlexTreeNodeSchema = TreeNodeSchemaBase;
 
 /**
  * Convert FieldSchemaSpecification | undefined into TreeFieldSchema.
- * @internal
  */
 export type NormalizeField<T extends FlexFieldSchema | undefined> = T extends FlexFieldSchema
 	? T
@@ -285,19 +243,16 @@ function normalizeField<T extends FlexFieldSchema | undefined>(t: T): NormalizeF
 
 /**
  * Allow any node (as long as it meets the schema for its own type).
- * @internal
  */
 export const Any = "Any" as const;
 /**
  * Allow any node (as long as it meets the schema for its own type).
- * @internal
  */
 export type Any = typeof Any;
 
 /**
  * Tree type, but can be wrapped in a function to allow referring to types before they are declared.
  * This makes recursive and co-recursive types possible.
- * @internal
  */
 export type LazyTreeNodeSchema = FlexTreeNodeSchema | (() => FlexTreeNodeSchema);
 
@@ -305,13 +260,11 @@ export type LazyTreeNodeSchema = FlexTreeNodeSchema | (() => FlexTreeNodeSchema)
  * Types for use in fields.
  *
  * "Any" is boxed in an array to allow use as variadic parameter.
- * @internal
  */
 export type FlexAllowedTypes = readonly [Any] | readonly LazyItem<FlexTreeNodeSchema>[];
 
 /**
  * Checks if an {@link FlexAllowedTypes} is {@link (Any:type)}.
- * @internal
  */
 export function allowedTypesIsAny(t: FlexAllowedTypes): t is readonly [Any] {
 	return t.length === 1 && t[0] === Any;
@@ -320,7 +273,6 @@ export function allowedTypesIsAny(t: FlexAllowedTypes): t is readonly [Any] {
 /**
  * Subset of TreeFieldSchema thats legal in maps.
  * This requires empty to be a valid value for the map.
- * @internal
  */
 export type FlexMapFieldSchema = FlexFieldSchema<
 	typeof FieldKinds.optional | typeof FieldKinds.sequence
@@ -339,7 +291,6 @@ export type FlexMapFieldSchema = FlexFieldSchema<
  * @typeParam TTypes - The types allowed by the field.
  *
  * @sealed
- * @internal
  */
 export class FlexFieldSchema<
 	out TKind extends FlexFieldKind = FlexFieldKind,
@@ -375,7 +326,7 @@ export class FlexFieldSchema<
 		return new FlexFieldSchema(kind, allowedTypes);
 	}
 
-	protected _typeCheck?: MakeNominal;
+	protected _typeCheck!: MakeNominal;
 
 	/**
 	 * This is computed lazily since types can be recursive, which makes evaluating this have to happen after all the schema are defined.
@@ -492,13 +443,11 @@ export class FlexFieldSchema<
  * @remarks
  * See {@link TreeTypeSet} for a stored-schema compatible version using the {@link TreeNodeSchemaIdentifier}.
  * See {@link FlexAllowedTypes} for a compile time optimized version.
- * @internal
  */
 export type AllowedTypeSet = Any | ReadonlySet<FlexTreeNodeSchema>;
 
 /**
  * Convert {@link FlexAllowedTypes} to {@link TreeTypeSet}.
- * @internal
  */
 export function allowedTypesSchemaSet(t: FlexAllowedTypes): AllowedTypeSet {
 	if (allowedTypesIsAny(t)) {
@@ -515,7 +464,6 @@ export function allowedTypesSchemaSet(t: FlexAllowedTypes): AllowedTypeSet {
 
 /**
  * Convert {@link FlexAllowedTypes} to {@link TreeTypeSet}.
- * @internal
  */
 export function allowedTypesToTypeSet(t: FlexAllowedTypes): TreeTypeSet {
 	const list = allowedTypesSchemaSet(t);
@@ -536,8 +484,6 @@ export function allowedTypesToTypeSet(t: FlexAllowedTypes): TreeTypeSet {
  * @remarks
  * The type of the rootFieldSchema is used to implement SchemaAware APIs.
  * Cases that do not require being compile time schema aware can omit the explicit type for it.
- *
- * @internal
  */
 export interface FlexTreeSchema<out T extends FlexFieldSchema = FlexFieldSchema>
 	extends SchemaCollection {
@@ -580,7 +526,6 @@ export function intoStoredSchemaCollection(
 
 /**
  * Schema data that can be be used to view a document.
- * @internal
  *
  * @privateRemarks
  * It is convenient that this can be used as a StoredSchemaCollection with no conversion.
@@ -597,7 +542,6 @@ export interface SchemaCollection {
 
 /**
  * Checks if a {@link FlexTreeNodeSchema} is a {@link FlexMapNodeSchema}.
- * @internal
  */
 export function schemaIsMap(schema: FlexTreeNodeSchema): schema is FlexMapNodeSchema {
 	return schema instanceof FlexMapNodeSchema;
@@ -605,23 +549,13 @@ export function schemaIsMap(schema: FlexTreeNodeSchema): schema is FlexMapNodeSc
 
 /**
  * Checks if a {@link FlexTreeNodeSchema} is a {@link LeafNodeSchema}.
- * @internal
  */
 export function schemaIsLeaf(schema: FlexTreeNodeSchema): schema is LeafNodeSchema {
 	return schema instanceof LeafNodeSchema;
 }
 
-/**
- * Checks if a {@link FlexTreeNodeSchema} is a {@link FlexFieldNodeSchema}.
- * @internal
- */
-export function schemaIsFieldNode(schema: FlexTreeNodeSchema): schema is FlexFieldNodeSchema {
-	return schema instanceof FlexFieldNodeSchema;
-}
-
 /**
  * Checks if a {@link FlexTreeNodeSchema} is a {@link FlexObjectNodeSchema}.
- * @internal
  */
 export function schemaIsObjectNode(
 	schema: FlexTreeNodeSchema,

package/src/feature-libraries/typed-schema/view.ts

@@ -163,7 +163,6 @@ export class ViewSchema<out TSchema extends FlexFieldSchema = FlexFieldSchema> {
 
 /**
  * Record where a schema came from for error reporting purposes.
- * @internal
  */
 export interface Sourced {
 	readonly builder: Named<string>;