@fluidframework/tree 2.3.0-288113 → 2.4.0-294316

package/src/shared-tree/schematizingTreeView.ts

@@ -6,7 +6,7 @@
 import { assert } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { AllowedUpdateType, Compatibility } from "../core/index.js";
+import { AllowedUpdateType, anchorSlot, Compatibility } from "../core/index.js";
 import {
 	type HasListeners,
 	type IEmitter,
@@ -14,13 +14,13 @@ import {
 	createEmitter,
 } from "../events/index.js";
 import {
-	type FlexFieldSchema,
 	type NodeKeyManager,
 	ViewSchema,
 	defaultSchemaPolicy,
 	ContextSlot,
 	cursorForMapTreeNode,
 	type FlexTreeSchema,
+	intoStoredSchema,
 } from "../feature-libraries/index.js";
 import {
 	type FieldSchema,
@@ -43,7 +43,12 @@ import { Breakable, breakingClass, disposeSymbol, type WithBreakable } from "../
 
 import { canInitialize, ensureSchema, initialize } from "./schematizeTree.js";
 import type { ITreeCheckout } from "./treeCheckout.js";
-import { CheckoutFlexTreeView } from "./treeView.js";
+import { CheckoutFlexTreeView } from "./checkoutFlexTreeView.js";
+/**
+ * Creating multiple tree views from the same checkout is not supported. This slot is used to detect if one already
+ * exists and error if creating a second.
+ */
+export const ViewSlot = anchorSlot<TreeView<ImplicitFieldSchema>>();
 
 /**
  * Implementation of TreeView wrapping a FlexTreeView.
@@ -57,7 +62,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	 *
 	 * The view schema may be incompatible with the stored schema. Use `compatibility` to check.
 	 */
-	private view: CheckoutFlexTreeView<FlexFieldSchema> | undefined;
+	private view: CheckoutFlexTreeView | undefined;
 
 	/**
 	 * Undefined iff uninitialized or disposed.
@@ -89,6 +94,11 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		public readonly nodeKeyManager: NodeKeyManager,
 		public readonly breaker: Breakable = new Breakable("SchematizingSimpleTreeView"),
 	) {
+		if (checkout.forest.anchors.slots.has(ViewSlot)) {
+			throw new UsageError("Cannot create a second tree view from the same checkout");
+		}
+		checkout.forest.anchors.slots.set(ViewSlot, this);
+
 		const policy = {
 			...defaultSchemaPolicy,
 			validateSchema: config.enableSchemaValidation,
@@ -96,7 +106,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		this.rootFieldSchema = normalizeFieldSchema(config.schema);
 		this.flexSchema = toFlexSchema(config.schema);
 
-		this.viewSchema = new ViewSchema(policy, {}, this.flexSchema);
+		this.viewSchema = new ViewSchema(policy, {}, intoStoredSchema(this.flexSchema));
 		// This must be initialized before `update` can be called.
 		this.currentCompatibility = {
 			canView: false,
@@ -113,6 +123,10 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 		);
 	}
 
+	public get schema(): TRootSchema {
+		return this.config.schema;
+	}
+
 	public initialize(content: InsertableTreeFieldFromImplicitField<TRootSchema>): void {
 		this.ensureUndisposed();
 
@@ -137,7 +151,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 
 			prepareContentForHydration(mapTree, this.checkout.forest);
 			initialize(this.checkout, {
-				schema: this.flexSchema,
+				schema: this.viewSchema.storedSchema,
 				initialTree: mapTree === undefined ? undefined : cursorForMapTreeNode(mapTree),
 			});
 		});
@@ -164,7 +178,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 				AllowedUpdateType.SchemaCompatible,
 				this.checkout,
 				{
-					schema: this.flexSchema,
+					schema: this.viewSchema.storedSchema,
 					initialTree: undefined,
 				},
 			);
@@ -175,7 +189,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	/**
 	 * Gets the view. Throws when disposed.
 	 */
-	public getView(): CheckoutFlexTreeView<FlexFieldSchema> {
+	public getView(): CheckoutFlexTreeView {
 		this.ensureUndisposed();
 		assert(this.view !== undefined, 0x8c0 /* unexpected getViewOrError */);
 		return this.view;
@@ -252,12 +266,21 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 				}
 			};
 
-			this.view = requireSchema(
+			const view = requireSchema(
 				this.checkout,
 				this.viewSchema,
 				onViewDispose,
 				this.nodeKeyManager,
+				this.flexSchema,
 			);
+			this.view = view;
+
+			const unregister = this.checkout.storedSchema.on("afterSchemaChange", () => {
+				unregister();
+				this.unregisterCallbacks.delete(unregister);
+				view[disposeSymbol]();
+			});
+			this.unregisterCallbacks.add(unregister);
 		} else {
 			this.view = undefined;
 
@@ -304,6 +327,7 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
 	public dispose(): void {
 		this.disposed = true;
 		this.disposeView();
+		this.checkout.forest.anchors.slots.delete(ViewSlot);
 		this.currentCompatibility = undefined;
 	}
 
@@ -334,12 +358,13 @@ export class SchematizingSimpleTreeView<in out TRootSchema extends ImplicitField
  * Creates a view that self-disposes whenenever the stored schema changes.
  * This may only be called when the schema is already known to be compatible (typically via ensureSchema).
  */
-export function requireSchema<TRoot extends FlexFieldSchema>(
+export function requireSchema(
 	checkout: ITreeCheckout,
-	viewSchema: ViewSchema<TRoot>,
+	viewSchema: ViewSchema,
 	onDispose: () => void,
 	nodeKeyManager: NodeKeyManager,
-): CheckoutFlexTreeView<TRoot> {
+	flexTreeSchema: FlexTreeSchema,
+): CheckoutFlexTreeView {
 	const slots = checkout.forest.anchors.slots;
 	assert(!slots.has(ContextSlot), 0x8c2 /* Cannot create second view from checkout */);
 
@@ -352,18 +377,7 @@ export function requireSchema<TRoot extends FlexFieldSchema>(
 		);
 	}
 
-	const view = new CheckoutFlexTreeView(
-		checkout,
-		viewSchema.schema,
-		nodeKeyManager,
-		onDispose,
-	);
+	const view = new CheckoutFlexTreeView(checkout, flexTreeSchema, nodeKeyManager, onDispose);
 	assert(slots.has(ContextSlot), 0x90d /* Context should be tracked in slot */);
-
-	const unregister = checkout.storedSchema.on("afterSchemaChange", () => {
-		unregister();
-		view[disposeSymbol]();
-	});
-
 	return view;
 }

package/src/shared-tree/sharedTree.ts

@@ -178,7 +178,11 @@ export class SharedTree
 		const schema = new TreeStoredSchemaRepository();
 		const forest =
 			options.forest === ForestType.Optimized
-				? buildChunkedForest(makeTreeChunker(schema, defaultSchemaPolicy))
+				? buildChunkedForest(
+						makeTreeChunker(schema, defaultSchemaPolicy),
+						undefined,
+						runtime.idCompressor,
+					)
 				: options.forest === ForestType.Reference
 					? buildForest()
 					: buildForest(undefined, true);
@@ -217,6 +221,7 @@ export class SharedTree
 			fieldBatchCodec,
 			options,
 			options.treeEncodeType,
+			runtime.idCompressor,
 		);
 		const changeFamily = makeMitigatedChangeFamily(
 			innerChangeFamily,

package/src/shared-tree/sharedTreeChangeEnricher.ts

@@ -29,6 +29,7 @@ import type {
 	ChangeEnricherMutableCheckout,
 	ChangeEnricherReadonlyCheckout,
 } from "../shared-tree-core/index.js";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 export class SharedTreeReadonlyChangeEnricher
 	implements ChangeEnricherReadonlyCheckout<SharedTreeChange>
@@ -44,6 +45,7 @@ export class SharedTreeReadonlyChangeEnricher
 		protected readonly forest: IEditableForest,
 		private readonly schema: TreeStoredSchemaRepository,
 		protected readonly removedRoots: DetachedFieldIndex,
+		private readonly idCompressor?: IIdCompressor,
 	) {}
 
 	public fork(): ChangeEnricherMutableCheckout<SharedTreeChange> {
@@ -70,7 +72,10 @@ export class SharedTreeReadonlyChangeEnricher
 			const parentField = this.removedRoots.toFieldKey(root);
 			cursor.enterField(parentField);
 			cursor.enterNode(0);
-			return chunkTree(cursor, defaultChunkPolicy);
+			return chunkTree(cursor, {
+				policy: defaultChunkPolicy,
+				idCompressor: this.idCompressor,
+			});
 		}
 		return undefined;
 	};

package/src/shared-tree/sharedTreeChangeFamily.ts

@@ -38,6 +38,7 @@ import {
 import { makeSharedTreeChangeCodecFamily } from "./sharedTreeChangeCodecs.js";
 import type { SharedTreeChange } from "./sharedTreeChangeTypes.js";
 import { SharedTreeEditBuilder } from "./sharedTreeEditBuilder.js";
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 
 /**
  * Implementation of {@link ChangeFamily} that combines edits to fields and schema changes.
@@ -61,6 +62,7 @@ export class SharedTreeChangeFamily
 		fieldBatchCodec: FieldBatchCodec,
 		codecOptions: ICodecOptions,
 		chunkCompressionStrategy?: TreeCompressionStrategy,
+		private readonly idCompressor?: IIdCompressor,
 	) {
 		const modularChangeCodec = makeModularChangeCodecFamily(
 			fieldKindConfigurations,
@@ -79,7 +81,11 @@ export class SharedTreeChangeFamily
 	public buildEditor(
 		changeReceiver: (change: SharedTreeChange) => void,
 	): SharedTreeEditBuilder {
-		return new SharedTreeEditBuilder(this.modularChangeFamily, changeReceiver);
+		return new SharedTreeEditBuilder(
+			this.modularChangeFamily,
+			changeReceiver,
+			this.idCompressor,
+		);
 	}
 
 	public compose(changes: TaggedChange<SharedTreeChange>[]): SharedTreeChange {

package/src/shared-tree/sharedTreeEditBuilder.ts

@@ -3,6 +3,7 @@
  * Licensed under the MIT License.
  */
 
+import type { IIdCompressor } from "@fluidframework/id-compressor";
 import type { ChangeFamilyEditor, TreeStoredSchema } from "../core/index.js";
 import {
 	DefaultEditBuilder,
@@ -48,11 +49,15 @@ export class SharedTreeEditBuilder
 	public constructor(
 		modularChangeFamily: ModularChangeFamily,
 		private readonly changeReceiver: (change: SharedTreeChange) => void,
+		idCompressor?: IIdCompressor,
 	) {
-		super(modularChangeFamily, (change) =>
-			changeReceiver({
-				changes: [{ type: "data", innerChange: change }],
-			}),
+		super(
+			modularChangeFamily,
+			(change) =>
+				changeReceiver({
+					changes: [{ type: "data", innerChange: change }],
+				}),
+			idCompressor,
 		);
 
 		this.schema = {

package/src/shared-tree/treeApi.ts

@@ -4,8 +4,9 @@
  */
 
 import { assert, unreachableCase } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { Context, TreeStatus } from "../feature-libraries/index.js";
+import { TreeStatus } from "../feature-libraries/index.js";
 import {
 	type ImplicitFieldSchema,
 	type TreeNode,
@@ -14,11 +15,10 @@ import {
 	getOrCreateInnerNode,
 	treeNodeApi,
 } from "../simple-tree/index.js";
-import { fail } from "../util/index.js";
 
 import { SchematizingSimpleTreeView } from "./schematizingTreeView.js";
 import type { ITreeCheckout } from "./treeCheckout.js";
-import { contextToTreeView } from "./treeView.js";
+import { getCheckoutFlexTreeView } from "./checkoutFlexTreeView.js";
 
 /**
  * A special object that signifies when a SharedTree {@link RunTransaction | transaction} should "roll back".
@@ -324,9 +324,7 @@ export interface RunTransaction {
  * Provides various functions for interacting with {@link TreeNode}s.
  * @remarks
  * This type should only be used via the public `Tree` export.
- * @privateRemarks
- * Due to limitations of API-Extractor link resolution, this type can't be moved into internalTypes but should be considered just an implementation detail of the `Tree` export.
- * @sealed @public
+ * @system @sealed @public
  */
 export interface TreeApi extends TreeNodeApi {
 	/**
@@ -436,10 +434,12 @@ export function runTransaction<
 		const node = treeOrNode as TNode;
 		const t = transaction as (node: TNode) => TResult | typeof rollback;
 		const context = getOrCreateInnerNode(node).context;
-		assert(context instanceof Context, 0x901 /* Unsupported context */);
-		const treeView =
-			contextToTreeView.get(context) ?? fail("Expected view to be registered for context");
-
+		if (context.isHydrated() === false) {
+			throw new UsageError(
+				"Transactions cannot be run on Unhydrated nodes. Transactions apply to a TreeView and Unhydrated nodes are not part of a TreeView.",
+			);
+		}
+		const treeView = getCheckoutFlexTreeView(context);
 		return runTransactionInCheckout(treeView.checkout, () => t(node), preconditions);
 	}
 }

package/src/shared-tree/treeCheckout.ts

@@ -35,8 +35,10 @@ import {
 	makeAnonChange,
 	makeDetachedFieldIndex,
 	rebaseChange,
+	rootFieldKey,
 	tagChange,
 	visitDelta,
+	type RevertibleFactory,
 } from "../core/index.js";
 import {
 	type HasListeners,
@@ -87,21 +89,6 @@ export interface CheckoutEvents {
 	commitApplied(data: CommitMetadata, getRevertible?: RevertibleFactory): void;
 }
 
-/**
- * Factory for creating a {@link Revertible}.
- * Will error if invoked outside the scope of the `commitApplied` event that provides it, or if invoked multiple times.
- *
- * @param onRevertibleDisposed - A callback that will be invoked when the `Revertible` generated by this factory is disposed.
- * This happens when the `Revertible` is disposed manually, or when the `TreeView` that the `Revertible` belongs to is disposed,
- * whichever happens first.
- * This is typically used to clean up any resources associated with the `Revertible` in the host application.
- *
- * @sealed @public
- */
-export type RevertibleFactory = (
-	onRevertibleDisposed?: (revertible: Revertible) => void,
-) => Revertible;
-
 /**
  * Provides a means for interacting with a SharedTree.
  * This includes reading data from the tree and running transactions to mutate the tree.
@@ -237,6 +224,7 @@ export function createTreeCheckout(
 				makeFieldBatchCodec(defaultCodecOptions, defaultFieldBatchVersion),
 			{ jsonValidator: noopValidator },
 			args?.chunkCompressionStrategy,
+			idCompressor,
 		);
 	const branch =
 		args?.branch ??
@@ -656,6 +644,7 @@ export class TreeCheckout implements ITreeCheckoutFork {
 	}
 
 	public getRemovedRoots(): [string | number | undefined, number, JsonableTree][] {
+		this.assertNoUntrackedRoots();
 		const trees: [string | number | undefined, number, JsonableTree][] = [];
 		const cursor = this.forest.allocateCursor("getRemovedRoots");
 		for (const { id, root } of this.removedRoots.entries()) {
@@ -739,6 +728,28 @@ export class TreeCheckout implements ITreeCheckoutFork {
 
 		return { age: revertAge };
 	}
+
+	private assertNoUntrackedRoots(): void {
+		const cursor = this.forest.getCursorAboveDetachedFields();
+		const rootFields = new Set([rootFieldKey]);
+		for (const { root } of this.removedRoots.entries()) {
+			rootFields.add(this.removedRoots.toFieldKey(root));
+		}
+
+		if (!cursor.firstField()) {
+			return;
+		}
+
+		do {
+			const field = cursor.getFieldKey();
+			assert(
+				rootFields.has(field),
+				0xa22 /* Forest has a root field which is unknown to the detached field index */,
+			);
+
+			rootFields.delete(field);
+		} while (cursor.nextField());
+	}
 }
 
 /**

package/src/shared-tree-core/branch.ts

@@ -387,7 +387,7 @@ export class SharedTreeBranch<
 			const commit =
 				commits[i] ?? fail("This wont run because we are iterating through commits");
 			const inverse = this.changeFamily.rebaser.changeRevision(
-				this.changeFamily.rebaser.invert(commit, false),
+				this.changeFamily.rebaser.invert(commit, true),
 				revision,
 				commit.revision,
 			);

package/src/simple-tree/ProxyBinding.md

@@ -1,6 +1,6 @@
-# simple-tree Proxy Binding
+# simple-tree node Binding
 
-Proxy binding is a technique used in the simple-tree API implementation which enables a useful API feature, namely the ability to use a node proxy after it is inserted into the tree.
+Hydration is a three step process which provides the ability to use a simple-tree node both before and after it is inserted into the tree.
 This allows developers to "read back" values that they insert into the tree much more succinctly.
 Here is an example:
 
@@ -10,7 +10,7 @@ function addPoint(curve: Curve, x: number, y: number): Point {
 	curve.points.insertAtEnd(point);
 	// After insertion, `point` can be queried:
 	assert(point.x === 3);
-	// In fact, `point` is the same proxy object that you would get from reading it off of its new parent in the tree:
+	// In fact, `point` is the same simple-tree node object that you would get from reading it off of its new parent in the tree:
 	assert(point === curve.points[curve.points.length - 1]);
 	// So, to read the content that was just inserted, the original object can be used and there is no need to read via the parent:
 	return point;
@@ -20,22 +20,22 @@ function addPoint(curve: Curve, x: number, y: number): Point {
 
 ## Implementation
 
-This feature is supported by doing some bookkeeping to ensure that the proxy objects,
+This feature is supported by doing some bookkeeping to ensure that the simple-tree objects,
 flex tree nodes and anchor nodes in the tree get associated and disassociated at the right times.
-There are three states that a node proxy can be in: "raw", "marinated" and "cooked".
+There are three states that a node simple-tree node can be in: "raw", "marinated" and "cooked".
 
 Note from the public API perspective, `Unhydrated` nodes are "raw", and hydrated nodes are either "marinated" or "cooked".
 
 ### Raw Proxies
 
-A newly created proxy, a.k.a. a **raw** proxy. A raw proxy is produced by invoking the schema-provided constructor for a node:
+A newly created simple-tree node, a.k.a. a **raw** simple-tree node. A raw simple-tree node is produced by invoking the schema-provided constructor for a node:
 
 ```ts
 const rawPoint = new Point({ x: 3, y: 3 });
 ```
 
-Such a proxy will be raw until it is inserted into the tree and becomes "marinated" (see below).
-As of 2024-03-21 raw proxies cannot be read or mutated, but in the future they will be capable of both.
+Such a simple-tree node will be raw until it is inserted into the tree and becomes "marinated" (see below).
+As raw nodes can be read or mutated.
 
 ### Marinated Proxies
 
@@ -60,15 +60,15 @@ app.graph = {
 };
 ```
 
-A marinated proxy, by definition, is bound bi-directionally to an `AnchorNode`.
-When insertion occurs, an `AnchorNode` will be created for the location of the new content.
-The proxy for that content will then be mapped to the `AnchorNode` and the `AnchorNode` will be mapped to the proxy.
-Note that the `AnchorNode` does not yet have a `FlexTreeNode` associated with it - that happens when the node becomes "cooked" (see below).
+A marinated simple-tree node, by definition, is bound bi-directionally to an `AnchorNode`.
+When insertion occurs, an `AnchorNode` will be created (if not already present) for the location of the new content.
+The simple-tree node for that content will then be mapped to the `AnchorNode` (via its kernel) and the `AnchorNode` will be mapped to the simple-tree node.
+Note that the `AnchorNode` may not yet have a `FlexTreeNode` associated with it - that happens when the node becomes "cooked" (see below).
 
 ### Cooked Proxies
 
-A proxy is fully cooked when it finally associates itself with a `FlexTreeNode`.
-This happens lazily on demand, if/when a marinated proxy is read or mutated.
+A simple-tree node is fully cooked when it finally associates itself with a `FlexTreeNode`.
+This happens lazily on demand, if/when a marinated simple-tree node is read or mutated (by the local client).
 
 ```ts
 const point = new Point({ x: 3, y: 3 }); // `point` is raw
@@ -76,29 +76,29 @@ curves.points.insertAtEnd(point); // `point` becomes marinated
 const x = point.x; // `point` becomes cooked in order to support the read of `x`
 ```
 
-This laziness prevents the proxy tree from generating unnecessary `FlexTreeNodes`.
+This laziness prevents the simple-tree node tree from generating unnecessary `FlexTreeNodes`.
 
-Cooking a marinated proxy works as follows:
+Cooking a marinated simple-tree node works as follows:
 
-1. Get the `AnchorNode` associated with the marinated proxy.
+1. Get the `AnchorNode` associated with the marinated simple-tree node.
 2. Get or create a `FlexTreeNode` for the anchor.
-3. This will cause the `FlexTreeNode` to be generated which corresponds to the proxy.
+3. This will cause the `FlexTreeNode` to be generated which corresponds to the simple-tree node.
 
 ### Mappings
 
 ```mermaid
 graph LR;
-    AnchorNode(AnchorNode)<-->|Cooked|FlexTreeNode(FlexTreeNode)
-    AnchorNode<--->|Marinated|Proxy(Proxy)-.->|Raw|RawTreeNode(RawTreeNode)
+    AnchorNode(AnchorNode)<-->|Cooked and sometimes when Marinated|FlexTreeNode(FlexTreeNode)
+    AnchorNode<--->|Marinated or Cooked|TreeNode(TreeNode)-.->|Raw|RawTreeNode(RawTreeNode)
     linkStyle 0 stroke:#0f0
     linkStyle 1 stroke:#00f
     linkStyle 2 stroke:#f00
 ```
 
-Note that it is possible for the `Cooked` mappings between an `AnchorNode` and a `FlexTreeNode` to exist regardless of whether there is also a proxy yet created for that node.
-In that case, when that proxy is created it will immediately be given its `Marinated` mappings and therefore already be cooked.
+Note that it is possible for the `Cooked` mappings between an `AnchorNode` and a `FlexTreeNode` to exist regardless of whether there is also a simple-tree node yet created for that node.
+In that case, when that simple-tree node is created it will immediately be given its `Marinated` mappings and therefore already be cooked.
 
 `RawTreeNode`s, which implement the `FlexTreeNode` interface (or at least, as of 2024-03-21, pretend to), are substitutes for the true `FlexTreeNode`s that don't yet exist for a raw node.
-The `Raw` mapping is removed when a proxy is marinated, and the `RawTreeNode` is forgotten.
+The `Raw` mapping is removed when a simple-tree node is marinated, and the `RawTreeNode` is forgotten.
 
 See [proxyBinding.ts](./proxyBinding.ts) for more details.

package/src/simple-tree/api/create.ts

@@ -23,12 +23,13 @@ import {
 	FieldKinds,
 	intoStoredSchema,
 	mapTreeFromCursor,
+	UnhydratedContext,
 	type NodeKeyManager,
 } from "../../feature-libraries/index.js";
-import { getOrCreateNodeFromFlexTreeNode, type InsertableContent } from "../proxies.js";
+import { getOrCreateNodeFromFlexTreeNode } from "../proxies.js";
 import { getOrCreateMapTreeNode, isFieldInSchema } from "../../feature-libraries/index.js";
 import { toFlexSchema } from "../toFlexSchema.js";
-import { inSchemaOrThrow, mapTreeFromNodeData } from "../toMapTree.js";
+import { inSchemaOrThrow, mapTreeFromNodeData, type InsertableContent } from "../toMapTree.js";
 import {
 	applySchemaToParserOptions,
 	cursorFromVerbose,
@@ -171,7 +172,11 @@ export function createFromCursor<TSchema extends ImplicitFieldSchema>(
 	// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 	const mapTree = mapTrees[0]!;
 	const rootSchema = flexSchema.nodeSchema.get(mapTree.type) ?? fail("missing schema");
-	const mapTreeNode = getOrCreateMapTreeNode(rootSchema, mapTree);
+	const mapTreeNode = getOrCreateMapTreeNode(
+		new UnhydratedContext(flexSchema),
+		rootSchema,
+		mapTree,
+	);
 
 	// TODO: ensure this works for InnerNodes to create unhydrated nodes
 	const result = getOrCreateNodeFromFlexTreeNode(mapTreeNode);

package/src/simple-tree/{getJsonSchema.ts → api/getJsonSchema.ts}

@@ -4,11 +4,11 @@
  */
 
 import type { JsonTreeSchema } from "./jsonSchema.js";
-import type { ImplicitAllowedTypes } from "./schemaTypes.js";
+import type { ImplicitAllowedTypes } from "../schemaTypes.js";
 import { toJsonSchema } from "./simpleSchemaToJsonSchema.js";
 import { getSimpleSchema } from "./getSimpleSchema.js";
-import { getOrCreate } from "../util/index.js";
-import type { TreeNodeSchema } from "./core/index.js";
+import { getOrCreate } from "../../util/index.js";
+import type { TreeNodeSchema } from "../core/index.js";
 
 /**
  * Cache in which the results of {@link getJsonSchema} are saved.

package/src/simple-tree/{getSimpleSchema.ts → api/getSimpleSchema.ts}

@@ -3,9 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import { getOrCreate } from "../util/index.js";
-import type { TreeNodeSchema } from "./core/index.js";
-import type { ImplicitAllowedTypes } from "./schemaTypes.js";
+import { getOrCreate } from "../../util/index.js";
+import type { TreeNodeSchema } from "../core/index.js";
+import type { ImplicitAllowedTypes } from "../schemaTypes.js";
 import type { SimpleTreeSchema } from "./simpleSchema.js";
 import { toSimpleTreeSchema } from "./viewSchemaToSimpleSchema.js";
 

package/src/simple-tree/api/index.ts

@@ -26,6 +26,26 @@ export {
 } from "./schemaCreationUtilities.js";
 export { treeNodeApi, type TreeNodeApi } from "./treeNodeApi.js";
 export { createFromInsertable, cursorFromInsertable } from "./create.js";
+export type { SimpleTreeSchema } from "./simpleSchema.js";
+export {
+	type JsonSchemaId,
+	type JsonSchemaType,
+	type JsonObjectNodeSchema,
+	type JsonArrayNodeSchema,
+	type JsonMapNodeSchema,
+	type JsonLeafNodeSchema,
+	type JsonSchemaRef,
+	type JsonRefPath,
+	type JsonNodeSchema,
+	type JsonNodeSchemaBase,
+	type JsonTreeSchema,
+	type JsonFieldSchema,
+	type JsonLeafSchemaType,
+} from "./jsonSchema.js";
+export { getJsonSchema } from "./getJsonSchema.js";
+export { getSimpleSchema } from "./getSimpleSchema.js";
+
+export { TreeBeta, type NodeChangedData, type TreeChangeEventsBeta } from "./treeApiBeta.js";
 
 // Exporting the schema (RecursiveObject) to test that recursive types are working correctly.
 // These are `@internal` so they can't be included in the `InternalClassTreeTypes` due to https://github.com/microsoft/rushstack/issues/3639