@fluidframework/tree 2.90.0-378676 → 2.91.0

package/src/core/rebase/types.ts

@@ -234,8 +234,83 @@ export interface LocalChangeMetadata extends CommitMetadata {
 	 * This can be used by undo/redo to group or classify edits.
 	 */
 	readonly label?: unknown;
+
+	/**
+	 * A set of {@link RunTransactionParams.label | labels} for all transactions (nested or otherwise)
+	 * that made up this change.
+	 * This can be used to identify, group, or filter changes — for example, to decide whether a change
+	 * should be included in an undo/redo stack.
+	 *
+	 * @remarks
+	 * The optional {@link TransactionLabels.tree | tree} property provides the structural nesting
+	 * of the transactions as a {@link LabelTree}.
+	 *
+	 * The `tree` property is present whenever the change was produced by a transaction that
+	 * includes at least one label. If the change was unlabeled,
+	 * `tree` is `undefined` and the set is empty.
+	 *
+	 * @example
+	 * Checking whether a change was produced by a specific kind of transaction:
+	 * ```typescript
+	 * branch.events.on("changed", (metadata) => {
+	 *   if (metadata.labels.has("testLabel")) {
+	 *     // This change came from a transaction labeled "testLabel"
+	 *   }
+	 * });
+	 * ```
+	 *
+	 * @example
+	 * A nested transaction produces a tree that reflects the nesting:
+	 * ```typescript
+	 * tree.runTransaction(() => {
+	 *   tree.runTransaction(() => { ... }, { label: "inner" });
+	 * }, { label: "outer" });
+	 * // metadata.labels.has("inner") === true
+	 * // metadata.labels.tree will be:
+	 * //   { label: "outer", sublabels: [{ label: "inner", sublabels: [] }] }
+	 * ```
+	 */
+	readonly labels: TransactionLabels;
 }
 
+/**
+ * A tree representing the nesting structure of transaction labels.
+ *
+ * @remarks
+ * Each transaction contributes a node whose {@link LabelTree.label} is its
+ * {@link RunTransactionParams.label | label} (or `undefined` if no label was provided).
+ * When transactions are nested, inner transaction nodes become {@link LabelTree.sublabels | sublabels}
+ * of outer ones.
+ *
+ * @sealed @alpha
+ */
+export interface LabelTree {
+	/**
+	 * The label for this transaction, or `undefined` if no label was provided.
+	 */
+	label: unknown;
+
+	/**
+	 * The label trees of any nested transactions within this one.
+	 */
+	sublabels: LabelTree[];
+}
+
+/**
+ * A set of transaction labels with an optional structural tree.
+ *
+ * @remarks
+ * The set contains all label values from the transactions that produced the change.
+ * Use standard {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set | Set}
+ * methods to check for specific labels.
+ *
+ * The optional {@link TransactionLabels.tree | tree} property provides the structural nesting
+ * of the transactions as a {@link LabelTree}.
+ *
+ * @sealed @alpha
+ */
+export type TransactionLabels = Set<unknown> & { tree?: LabelTree };
+
 /**
  * Information about a change that has been applied by a remote client.
  * @sealed @alpha
@@ -260,6 +335,11 @@ export interface RemoteChangeMetadata extends CommitMetadata {
 	 * @remarks This is only available for {@link LocalChangeMetadata | local changes}.
 	 */
 	readonly label?: undefined;
+	/**
+	 * A set of labels from nested transaction labels.
+	 * @remarks This is always empty for remote changes. Labels are only available for {@link LocalChangeMetadata | local changes}.
+	 */
+	readonly labels: TransactionLabels;
 }
 
 /**
@@ -296,10 +376,6 @@ export function newChangeAtomIdRangeMap<V>(
 	return new RangeMap(offsetChangeAtomId, subtractChangeAtomIds, offsetValue);
 }
 
-export function newChangeAtomIdTransform(): ChangeAtomIdRangeMap<ChangeAtomId> {
-	return new RangeMap(offsetChangeAtomId, subtractChangeAtomIds, offsetChangeAtomId);
-}
-
 export function subtractChangeAtomIds(a: ChangeAtomId, b: ChangeAtomId): number {
 	const cmp = comparePartialRevisions(a.revision, b.revision);
 	if (cmp !== 0) {

package/src/core/rebase/utils.ts

@@ -327,9 +327,7 @@ export function rebaseBranch<TChange>(
 			},
 		},
 		"sourceChange",
-		() => {
-			return changeRebaser.compose(editsToCompose);
-		},
+		() => changeRebaser.compose(editsToCompose),
 	);
 }
 
@@ -377,45 +375,23 @@ export function rebaseChange<TChange>(
 export function revisionMetadataSourceFromInfo(
 	revInfos: readonly RevisionInfo[],
 ): RevisionMetadataSource {
-	const compareRevisions = (revision1: RevisionTag, revision2: RevisionTag): number => {
-		const index1 = getIndex(revision1);
-		const index2 = getIndex(revision2);
-
-		if (index1 !== undefined) {
-			return index2 === undefined ? -1 : index2 - index1;
-		}
-
-		return index2 === undefined ? 0 : 1;
+	const getIndex = (revision: RevisionTag): number | undefined => {
+		const index = revInfos.findIndex((revInfo) => revInfo.revision === revision);
+		return index >= 0 ? index : undefined;
 	};
-
 	const tryGetInfo = (revision: RevisionTag | undefined): RevisionInfo | undefined => {
 		if (revision === undefined) {
 			return undefined;
 		}
-		return revInfos.find((info) => info.revision === revision);
+		const index = getIndex(revision);
+		return index === undefined ? undefined : revInfos[index];
 	};
 
 	const hasRollback = (revision: RevisionTag): boolean => {
 		return revInfos.some((info) => info.rollbackOf === revision);
 	};
 
-	const getIndex = (revision: RevisionTag): number | undefined => {
-		const index = revInfos.findIndex((revInfo) => revInfo.revision === revision);
-		if (index >= 0) {
-			return index;
-		}
-
-		const rollbackIndex = revInfos.findIndex((revInfo) => revInfo.rollbackOf === revision);
-		if (rollbackIndex >= 0) {
-			// This change is the forward revision of a rollback included in revInfos, so it comes after
-			// all revisions in revInfos. Earlier rollbacks have later forward revisions.
-			return 2 * revInfos.length - rollbackIndex;
-		}
-
-		return undefined;
-	};
-
-	return { compareRevisions, tryGetInfo, hasRollback };
+	return { getIndex, tryGetInfo, hasRollback };
 }
 
 export function rebaseChangeOverChanges<TChange>(

package/src/core/tree/delta.ts

@@ -204,10 +204,4 @@ export interface FieldChanges {
 	 * It corresponds to the sum of `mark.count` values for all previous marks for which `isAttachMark(mark)` is false.
 	 */
 	readonly marks: readonly Mark[];
-
-	/**
-	 * Indicates whether nodes detached by this field can be safely re-attached.
-	 * Defaults to false.
-	 */
-	readonly allowReattach?: boolean;
 }

package/src/core/tree/detachedFieldIndex.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, fail } from "@fluidframework/core-utils/internal";
+import { assert } from "@fluidframework/core-utils/internal";
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 import {
@@ -52,12 +52,6 @@ export interface ReadOnlyDetachedFieldIndex {
 	 */
 	toFieldKey(id: ForestRootId): FieldKey;
 
-	/**
-	 * Returns a node ID for the node in the given field.
-	 * @param field - The field key where the detached node resides.
-	 */
-	fromFieldKey(field: FieldKey): Delta.DetachedNodeId;
-
 	/**
 	 * Returns the `ForestRootId` associated with the given id.
 	 * Returns undefined if no such id is known to the index.
@@ -69,12 +63,6 @@ export interface ReadOnlyDetachedFieldIndex {
 	 * Fails if no such id is known to the index.
 	 */
 	getEntry(id: Delta.DetachedNodeId): ForestRootId;
-
-	/**
-	 * Returns the source associated with the given id if any.
-	 * @param id - The detached node ID.
-	 */
-	isAttachable(id: Delta.DetachedNodeId): boolean | undefined;
 }
 
 /**
@@ -209,16 +197,6 @@ export class DetachedFieldIndex implements ReadOnlyDetachedFieldIndex {
 		return brand(`${this.name}-${id}`);
 	}
 
-	public fromFieldKey(field: FieldKey): Delta.DetachedNodeId {
-		// TODO: maintain a lookup table or use field keys that encode the detached node ID
-		for (const { id, root } of this.entries()) {
-			if (this.toFieldKey(root) === field) {
-				return id;
-			}
-		}
-		fail("No known detached roots in the given field");
-	}
-
 	public tryGetEntry(id: Delta.DetachedNodeId): ForestRootId | undefined {
 		return tryGetFromNestedMap(this.detachedNodeToField, id.major, id.minor)?.root;
 	}
@@ -229,10 +207,6 @@ export class DetachedFieldIndex implements ReadOnlyDetachedFieldIndex {
 		return key;
 	}
 
-	public isAttachable(id: Delta.DetachedNodeId): boolean | undefined {
-		return tryGetFromNestedMap(this.detachedNodeToField, id.major, id.minor)?.isAttachable;
-	}
-
 	/**
 	 * Returns the detached root IDs for all the trees that were detached or last modified by the given revision.
 	 */
@@ -285,7 +259,6 @@ export class DetachedFieldIndex implements ReadOnlyDetachedFieldIndex {
 	public createEntry(
 		nodeId?: Delta.DetachedNodeId,
 		revision?: RevisionTag,
-		isAttachable?: boolean,
 		count: number = 1,
 	): ForestRootId {
 		const root = this.rootIdAllocator.allocate(count);
@@ -299,7 +272,6 @@ export class DetachedFieldIndex implements ReadOnlyDetachedFieldIndex {
 				setInNestedMap(this.detachedNodeToField, nodeId.major, nodeId.minor + i, {
 					root: brand<ForestRootId>(root + i),
 					latestRelevantRevision: revision,
-					isAttachable,
 				});
 				setInNestedMap(this.latestRelevantRevisionToFields, revision, root + i, {
 					major: nodeId.major,

package/src/core/tree/detachedFieldIndexTypes.ts

@@ -49,9 +49,4 @@ export interface DetachedField {
 	 * `DetachedField` and `Forest` are GC-ed.
 	 */
 	readonly latestRelevantRevision?: RevisionTag;
-
-	/**
-	 * Indicates whether the corresponding root can safely be re-attached.
-	 */
-	readonly isAttachable?: boolean;
 }

package/src/core/tree/index.ts

@@ -30,17 +30,17 @@ export {
 	CursorMarker,
 	isCursor,
 } from "./cursor.js";
-export {
-	type ProtoNodes,
-	type Root as DeltaRoot,
-	type Mark as DeltaMark,
-	type DetachedNodeId as DeltaDetachedNodeId,
-	type FieldMap as DeltaFieldMap,
-	type DetachedNodeChanges as DeltaDetachedNodeChanges,
-	type DetachedNodeBuild as DeltaDetachedNodeBuild,
-	type DetachedNodeDestruction as DeltaDetachedNodeDestruction,
-	type DetachedNodeRename as DeltaDetachedNodeRename,
-	type FieldChanges as DeltaFieldChanges,
+export type {
+	ProtoNodes,
+	Root as DeltaRoot,
+	Mark as DeltaMark,
+	DetachedNodeId as DeltaDetachedNodeId,
+	FieldMap as DeltaFieldMap,
+	DetachedNodeChanges as DeltaDetachedNodeChanges,
+	DetachedNodeBuild as DeltaDetachedNodeBuild,
+	DetachedNodeDestruction as DeltaDetachedNodeDestruction,
+	DetachedNodeRename as DeltaDetachedNodeRename,
+	FieldChanges as DeltaFieldChanges,
 } from "./delta.js";
 export { type MapTree, type ExclusiveMapTree, deepCopyMapTree } from "./mapTree.js";
 export {
@@ -59,9 +59,8 @@ export {
 	type NodeIndex,
 	compareUpPaths,
 	compareFieldUpPaths,
-	isDetachedUpPathRoot,
+	isDetachedUpPathRoot as isDetachedUpPath,
 	getDetachedFieldContainingPath,
-	getDetachedFieldContainingFieldPath,
 	type UpPathDefault,
 } from "./pathTree.js";
 export {

package/src/core/tree/pathTree.ts

@@ -126,7 +126,7 @@ export interface FieldUpPath<TUpPath = UpPath> {
  */
 export function isDetachedUpPathRoot<T>(
 	path: UpPath<T> | NormalizedUpPath,
-): path is NormalizedUpPathRoot & { readonly detachedNodeId: DetachedNodeId } {
+): path is NormalizedUpPathRoot {
 	return (path as NormalizedUpPathRoot).detachedNodeId !== undefined;
 }
 
@@ -219,8 +219,8 @@ export function clonePath(path: UpPath | undefined): UpPath | undefined {
  * Gets the elements of the given `path`, ordered from root-most to child-most.
  * @remarks These elements are unchanged and therefore still point "up".
  */
-export function topDownPath<T extends UpPath<T>>(path: T | undefined): T[] {
-	const out: T[] = [];
+export function topDownPath(path: UpPath | undefined): UpPath[] {
+	const out: UpPath[] = [];
 	let curr = path;
 	while (curr !== undefined) {
 		out.push(curr);
@@ -262,7 +262,7 @@ export function compareFieldUpPaths(a: FieldUpPath, b: FieldUpPath): boolean {
 }
 
 /**
- * Returns the field key for the root field.
+ * Checks whether or not a given path is parented under the root field.
  * @param path - the path you want to check.
  * @returns the {@link DetachedField} which contains the path.
  */
@@ -277,15 +277,3 @@ export function getDetachedFieldContainingPath(path: UpPath): DetachedField {
 	}
 	return keyAsDetachedField(path.parentField);
 }
-
-/**
- * Returns the field key for the root field.
- * @param path - the path you want to check.
- * @returns the {@link DetachedField} which contains the path.
- */
-export function getDetachedFieldContainingFieldPath(path: FieldUpPath): DetachedField {
-	if (path.parent === undefined) {
-		return keyAsDetachedField(path.field);
-	}
-	return getDetachedFieldContainingPath(path.parent);
-}

package/src/core/tree/visitDelta.ts

@@ -166,9 +166,7 @@ function transferRoots(
 	refreshers: NestedMap<Major, Minor, ITreeCursorSynchronous>,
 	revision?: RevisionTag,
 ): void {
-	type AtomizedNodeRename = Omit<Delta.DetachedNodeRename, "count"> & {
-		isAttachable?: boolean;
-	};
+	type AtomizedNodeRename = Omit<Delta.DetachedNodeRename, "count">;
 	let nextBatch = rootTransfers.flatMap(({ oldId, newId, count }) => {
 		const atomized: AtomizedNodeRename[] = [];
 		// It's possible for a detached node to be revived transiently such that it ends up back in the same detached field.
@@ -178,12 +176,7 @@ function transferRoots(
 		// This if statement prevents that from happening.
 		if (!areDetachedNodeIdsEqual(oldId, newId)) {
 			for (let i = 0; i < count; i += 1) {
-				const source = detachedFieldIndex.isAttachable(offsetDetachId(oldId, i));
-				atomized.push({
-					oldId: offsetDetachId(oldId, i),
-					newId: offsetDetachId(newId, i),
-					isAttachable: source,
-				});
+				atomized.push({ oldId: offsetDetachId(oldId, i), newId: offsetDetachId(newId, i) });
 			}
 		}
 		return atomized;
@@ -191,29 +184,30 @@ function transferRoots(
 	while (nextBatch.length > 0) {
 		const delayed: AtomizedNodeRename[] = [];
 		const priorSize = nextBatch.length;
-		for (const { oldId, newId, isAttachable } of nextBatch) {
+		for (const { oldId, newId } of nextBatch) {
 			let oldRootId = detachedFieldIndex.tryGetEntry(oldId);
 			if (oldRootId === undefined) {
 				const tree = tryGetFromNestedMap(refreshers, oldId.major, oldId.minor);
 				if (tree !== undefined) {
-					buildTrees(oldId, [tree], detachedFieldIndex, revision, false, visitor);
+					buildTrees(oldId, [tree], detachedFieldIndex, revision, visitor);
 					oldRootId = detachedFieldIndex.getEntry(oldId);
 				}
 			}
 			if (oldRootId === undefined) {
 				// The source field is not populated.
 				// This can happen when another rename needs to be performed first.
-				delayed.push({ oldId, newId, isAttachable });
+				delayed.push({ oldId, newId });
 				continue;
 			}
 			let newRootId = detachedFieldIndex.tryGetEntry(newId);
 			if (newRootId !== undefined) {
 				// The destination field is already occupied.
 				// This can happen when another rename needs to be performed first.
-				delayed.push({ oldId, newId, isAttachable });
+				delayed.push({ oldId, newId });
 				continue;
 			}
-			newRootId = detachedFieldIndex.createEntry(newId, revision, isAttachable);
+			// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- intentional behavior
+			newRootId = detachedFieldIndex.createEntry(newId, revision);
 			const fields = mapToUpdate.get(oldRootId);
 			if (fields !== undefined) {
 				mapToUpdate.delete(oldRootId);
@@ -419,11 +413,7 @@ function detachPass(
 		if (mark.detach !== undefined) {
 			for (let i = 0; i < mark.count; i += 1) {
 				const id = offsetDetachId(mark.detach, i);
-				const root = config.detachedFieldIndex.createEntry(
-					id,
-					config.latestRevision,
-					fieldChanges.allowReattach,
-				);
+				const root = config.detachedFieldIndex.createEntry(id, config.latestRevision);
 				if (mark.fields !== undefined) {
 					config.attachPassRoots.set(root, mark.fields);
 				}
@@ -442,14 +432,13 @@ function buildTrees(
 	trees: readonly ITreeCursorSynchronous[],
 	detachedFieldIndex: DetachedFieldIndex,
 	latestRevision: RevisionTag | undefined,
-	isAttachable: boolean,
 	visitor: DeltaVisitor,
 ): void {
 	for (const [i, tree] of trees.entries()) {
 		const offsettedId = offsetDetachId(id, i);
 		let root = detachedFieldIndex.tryGetEntry(offsettedId);
 		assert(root === undefined, 0x929 /* Unable to build tree that already exists */);
-		root = detachedFieldIndex.createEntry(offsettedId, latestRevision, isAttachable);
+		root = detachedFieldIndex.createEntry(offsettedId, latestRevision);
 		const field = detachedFieldIndex.toFieldKey(root);
 		visitor.create([tree], field);
 	}
@@ -467,7 +456,6 @@ function processBuilds(
 				nodeCursorsFromChunk(trees),
 				config.detachedFieldIndex,
 				config.latestRevision,
-				true,
 				visitor,
 			);
 		}
@@ -485,14 +473,7 @@ function processGlobal(
 			if (root === undefined) {
 				const tree = tryGetFromNestedMap(config.refreshers, id.major, id.minor);
 				assert(tree !== undefined, 0x928 /* refresher data not found */);
-				buildTrees(
-					id,
-					[tree],
-					config.detachedFieldIndex,
-					config.latestRevision,
-					false,
-					visitor,
-				);
+				buildTrees(id, [tree], config.detachedFieldIndex, config.latestRevision, visitor);
 				root = config.detachedFieldIndex.getEntry(id);
 			}
 			// the revision is updated for any refresher data included in the delta that is used
@@ -548,7 +529,6 @@ function attachPass(
 						[tree],
 						config.detachedFieldIndex,
 						config.latestRevision,
-						false,
 						visitor,
 					);
 					sourceRoot = config.detachedFieldIndex.getEntry(offsetAttachId);

package/{dist/alpha.d.ts → src/entrypoints/alpha.ts}

@@ -9,10 +9,6 @@
  */
 
 export {
-	// #region Unrestricted APIs
-	InternalTypes,
-	// #endregion
-	 
 	// #region @public APIs
 	AllowedTypes, 
 	CommitKind, 
@@ -32,6 +28,7 @@ export {
 	InsertableTreeNodeFromImplicitAllowedTypes, 
 	InsertableTypedNode, 
 	InternalTreeNode, 
+	InternalTypes, 
 	IsListener, 
 	IsUnion, 
 	IterableTreeArrayContent, 
@@ -126,6 +123,8 @@ export {
 	SchemaStaticsBeta, 
 	SchemaUpgrade, 
 	SharedTreeOptionsBeta, 
+	SnapshotFileSystem, 
+	SnapshotSchemaCompatibilityOptions, 
 	System_TableSchema, 
 	TableSchema, 
 	TreeBeta, 
@@ -144,7 +143,8 @@ export {
 	configuredSharedTreeBeta, 
 	createIndependentTreeBeta, 
 	enumFromStrings, 
-	singletonSchema,
+	singletonSchema, 
+	snapshotSchemaCompatibility,
 	// #endregion
  
 	// #region @alpha APIs
@@ -161,8 +161,13 @@ export {
 	CreateIndependentTreeAlphaOptions, 
 	DirtyTreeMap, 
 	DirtyTreeStatus, 
+	ErasedNode, 
+	ErasedSchema, 
+	ErasedSchemaSubclassable, 
 	FactoryContent, 
 	FactoryContentObject, 
+	FieldHasDefaultAlpha, 
+	FieldHasDefaultAlphaUnsafe, 
 	FieldPropsAlpha, 
 	FieldSchemaAlpha, 
 	FieldSchemaAlphaUnsafe, 
@@ -180,6 +185,8 @@ export {
 	Insertable, 
 	InsertableContent, 
 	InsertableField, 
+	InsertableObjectFromSchemaRecordAlpha, 
+	InsertableObjectFromSchemaRecordAlphaUnsafe, 
 	JsonArrayNodeSchema, 
 	JsonAsTree, 
 	JsonCompatibleReadOnly, 
@@ -198,14 +205,17 @@ export {
 	JsonSchemaType, 
 	JsonStringKeyPatternProperties, 
 	JsonTreeSchema, 
+	LabelTree, 
 	LocalChangeMetadata, 
 	MapNodeCustomizableSchema, 
 	MapNodeCustomizableSchemaUnsafe, 
 	MapNodePojoEmulationSchema, 
 	MapNodeSchema, 
 	NoChangeConstraint, 
+	NodeProvider, 
 	NodeSchemaOptionsAlpha, 
 	ObjectNodeSchema, 
+	ObjectNodeSchemaWorkaround, 
 	ObjectSchemaOptionsAlpha, 
 	ObservationResults, 
 	ReadSchema, 
@@ -218,6 +228,7 @@ export {
 	RevertibleAlphaFactory, 
 	RunTransactionParams, 
 	SchemaFactoryAlpha, 
+	SchemaStaticsAlpha, 
 	SchemaType, 
 	SharedTreeFormatOptions, 
 	SharedTreeOptions, 
@@ -231,12 +242,11 @@ export {
 	SimpleObjectFieldSchema, 
 	SimpleObjectNodeSchema, 
 	SimpleRecordNodeSchema, 
-	SimpleTreeIndex, 
 	SimpleTreeSchema, 
-	SnapshotFileSystem, 
-	SnapshotSchemaCompatibilityOptions, 
+	TextAsTree, 
 	TransactionCallbackStatus, 
 	TransactionConstraintAlpha, 
+	TransactionLabels, 
 	TransactionResult, 
 	TransactionResultExt, 
 	TransactionResultFailed, 
@@ -246,6 +256,7 @@ export {
 	TreeBranchEvents, 
 	TreeBranchFork, 
 	TreeCompressionStrategy, 
+	TreeContextAlpha, 
 	TreeIdentifierUtils, 
 	TreeIndex, 
 	TreeIndexKey, 
@@ -261,6 +272,7 @@ export {
 	VerboseTreeNode, 
 	ViewContent, 
 	VoidTransactionCallbackStatus, 
+	WithValue, 
 	allowUnused, 
 	asAlpha, 
 	asTreeViewAlpha, 
@@ -272,7 +284,7 @@ export {
 	createArrayInsertionAnchor, 
 	createIdentifierIndex, 
 	createIndependentTreeAlpha, 
-	createSimpleTreeIndex, 
+	createTreeIndex, 
 	decodeSchemaCompatibilitySnapshot, 
 	encodeSchemaCompatibilitySnapshot, 
 	eraseSchemaDetails, 
@@ -294,7 +306,6 @@ export {
 	replaceConciseTreeHandles, 
 	replaceHandles, 
 	replaceVerboseTreeHandles, 
-	snapshotSchemaCompatibility, 
 	trackDirtyNodes
 	// #endregion
-} from "./index.js";
+} from "../index.js";

package/{lib/beta.d.ts → src/entrypoints/beta.ts}

@@ -9,10 +9,6 @@
  */
 
 export {
-	// #region Unrestricted APIs
-	InternalTypes,
-	// #endregion
-	 
 	// #region @public APIs
 	AllowedTypes, 
 	CommitKind, 
@@ -32,6 +28,7 @@ export {
 	InsertableTreeNodeFromImplicitAllowedTypes, 
 	InsertableTypedNode, 
 	InternalTreeNode, 
+	InternalTypes, 
 	IsListener, 
 	IsUnion, 
 	IterableTreeArrayContent, 
@@ -126,6 +123,8 @@ export {
 	SchemaStaticsBeta, 
 	SchemaUpgrade, 
 	SharedTreeOptionsBeta, 
+	SnapshotFileSystem, 
+	SnapshotSchemaCompatibilityOptions, 
 	System_TableSchema, 
 	TableSchema, 
 	TreeBeta, 
@@ -144,6 +143,7 @@ export {
 	configuredSharedTreeBeta, 
 	createIndependentTreeBeta, 
 	enumFromStrings, 
-	singletonSchema
+	singletonSchema, 
+	snapshotSchemaCompatibility
 	// #endregion
-} from "./index.js";
+} from "../index.js";

package/src/entrypoints/internal.ts

@@ -0,0 +1,13 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+// This file provides one module of indirection from index.ts to control
+// TypeScript import spec generation in consumer packages' .d.ts output. Importantly,
+// if alpha / beta / public entrypoints need to search to import spec and those
+// reference index.js, then package exports should not also reference index.js,
+// or that path will be chosen. (import("@fluidframework/tree/internal") in this
+// case).
+
+export * from "../index.js";