@fluidframework/tree 2.41.0-338186 → 2.41.0

package/src/simple-tree/core/treeNodeKernel.ts

@@ -3,11 +3,11 @@
  * Licensed under the MIT License.
  */
 
-import { assert, Lazy, fail, debugAssert } from "@fluidframework/core-utils/internal";
-import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import type { Listenable, Off } from "@fluidframework/core-interfaces";
-import type { InternalTreeNode, Unhydrated } from "./types.js";
+import { assert, Lazy, fail, debugAssert } from "@fluidframework/core-utils/internal";
+import { UsageError } from "@fluidframework/telemetry-utils/internal";
+
 import {
 	anchorSlot,
 	type AnchorEvents,
@@ -16,6 +16,9 @@ import {
 	type TreeValue,
 	type UpPath,
 } from "../../core/index.js";
+// TODO: decide how to deal with dependencies on flex-tree implementation.
+// eslint-disable-next-line import/no-internal-modules
+import { makeTree } from "../../feature-libraries/flex-tree/lazyNode.js";
 import {
 	assertFlexTreeEntityNotFreed,
 	ContextSlot,
@@ -25,13 +28,12 @@ import {
 	treeStatusFromAnchorCache,
 	type FlexTreeNode,
 } from "../../feature-libraries/index.js";
-import type { TreeNodeSchema } from "./treeNodeSchema.js";
-// TODO: decide how to deal with dependencies on flex-tree implementation.
-// eslint-disable-next-line import/no-internal-modules
-import { makeTree } from "../../feature-libraries/flex-tree/lazyNode.js";
+
 import { SimpleContextSlot, type Context, type HydratedContext } from "./context.js";
-import { UnhydratedFlexTreeNode } from "./unhydratedFlexTree.js";
 import type { TreeNode } from "./treeNode.js";
+import type { TreeNodeSchema } from "./treeNodeSchema.js";
+import type { InternalTreeNode, Unhydrated } from "./types.js";
+import { UnhydratedFlexTreeNode } from "./unhydratedFlexTree.js";
 
 const treeNodeToKernel = new WeakMap<TreeNode, TreeNodeKernel>();
 
@@ -175,12 +177,7 @@ export class TreeNodeKernel {
 			};
 		} else {
 			// Hydrated case
-			const { anchorNode } = innerNode;
-			assert(
-				!anchorNode.slots.has(proxySlot),
-				0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */,
-			);
-			this.#hydrationState = this.createHydratedState(anchorNode);
+			this.#hydrationState = this.createHydratedState(innerNode.anchorNode);
 		}
 	}
 
@@ -197,16 +194,22 @@ export class TreeNodeKernel {
 
 	/**
 	 * Transition from {@link Unhydrated} to hydrated.
-	 * Bi-directionally associates the given hydrated TreeNode to the given anchor node.
+	 * Bi-directionally associates the given hydrated TreeNode to the anchor node at the provided path.
 	 * @remarks
 	 * Happens at most once for any given node.
-	 * Cleans up mappings to {@link UnhydratedFlexTreeNode} - it is assumed that they are no longer needed once the proxy has an anchor node.
+	 * Cleans up mappings to {@link UnhydratedFlexTreeNode} - it is assumed that they are no longer needed once this node has an anchor node.
 	 */
-	private hydrate(anchorNode: AnchorNode): void {
+	public hydrate(anchors: AnchorSet, path: UpPath): void {
 		assert(!this.disposed, 0xa2a /* cannot hydrate a disposed node */);
 		assert(!isHydrated(this.#hydrationState), 0xa2b /* hydration should only happen once */);
 		unhydratedFlexTreeNodeToTreeNodeInternal.delete(this.#hydrationState.innerNode);
+
+		const anchor = anchors.track(path);
+		const anchorNode =
+			anchors.locate(anchor) ?? fail(0xb42 /* Expected anchor node to be present */);
+
 		this.#hydrationState = this.createHydratedState(anchorNode);
+		this.#hydrationState.offAnchorNode.add(() => anchors.forget(anchor));
 
 		// If needed, register forwarding emitters for events from before hydration
 		if (this.#unhydratedEvents.evaluated) {
@@ -224,7 +227,11 @@ export class TreeNodeKernel {
 	}
 
 	private createHydratedState(anchorNode: AnchorNode): HydratedState {
-		anchorNode.slots.set(proxySlot, this.node);
+		assert(
+			!anchorNode.slots.has(simpleTreeNodeSlot),
+			0x7f5 /* Cannot associate an flex node with multiple simple-tree nodes */,
+		);
+		anchorNode.slots.set(simpleTreeNodeSlot, this.node);
 		return {
 			anchorNode,
 			offAnchorNode: new Set([
@@ -265,6 +272,7 @@ export class TreeNodeKernel {
 	}
 
 	public dispose(): void {
+		debugAssert(() => !this.disposed || "Cannot dispose a disposed node");
 		this.disposed = true;
 		if (isHydrated(this.#hydrationState)) {
 			for (const off of this.#hydrationState.offAnchorNode) {
@@ -305,7 +313,7 @@ export class TreeNodeKernel {
 		if (this.#hydrationState.innerNode === undefined) {
 			// Marinated case -> cooked
 			const anchorNode = this.#hydrationState.anchorNode;
-			// The proxy is bound to an anchor node, but it may or may not have an actual flex node yet
+			// This TreeNode is bound to an anchor node, but it may or may not have an actual flex node yet
 			const flexNode = anchorNode.slots.get(flexTreeSlot);
 			if (flexNode !== undefined) {
 				// If the flex node already exists, use it...
@@ -318,8 +326,6 @@ export class TreeNodeKernel {
 				context.checkout.forest.moveCursorToPath(anchorNode, cursor);
 				this.#hydrationState.innerNode = makeTree(context, cursor);
 				cursor.free();
-				// Calling this is a performance improvement, however, do this only after demand to avoid momentarily having no anchors to anchorNode
-				anchorForgetters?.get(this.node)?.();
 				if (!allowDeleted) {
 					assertFlexTreeEntityNotFreed(this.#hydrationState.innerNode);
 				}
@@ -335,35 +341,6 @@ export class TreeNodeKernel {
 		return this.#hydrationState.innerNode;
 	}
 
-	/**
-	 * Creates an anchor node and associates it with the given proxy.
-	 * @privateRemarks
-	 * Use `forgetters` to cleanup the anchor allocated by this function once the anchor is no longer needed.
-	 * In practice, this happens when either the anchor node is destroyed, or another anchor to the same node is created by a new flex node.
-	 *
-	 * The FlexTreeNode holds a reference to the same anchor, and has a lifetime at least as long as the simple-tree,
-	 * so this would be unnecessary except for the case of "marinated" nodes, which have an anchor,
-	 * but might not have a FlexTreeNode.
-	 * Handling this case is an optimization assuming that this extra anchor reference is cheaper than eagerly creating FlexTreeNodes.
-	 */
-	public anchorProxy(anchors: AnchorSet, path: UpPath): AnchorNode {
-		assert(!anchorForgetters.has(this.node), 0x91c /* Proxy anchor should not be set twice */);
-		const anchor = anchors.track(path);
-		const anchorNode =
-			anchors.locate(anchor) ?? fail(0xb42 /* Expected anchor node to be present */);
-		this.hydrate(anchorNode);
-		const forget = (): void => {
-			if (anchors.locate(anchor)) {
-				anchors.forget(anchor);
-			}
-			anchorForgetters.delete(this.node);
-			off();
-		};
-		anchorForgetters.set(this.node, forget);
-		const off = anchorNode.events.on("afterDestroy", forget);
-		return anchorNode;
-	}
-
 	/**
 	 * Retrieves the InnerNode associated with the given target via {@link setInnerNode}, if any.
 	 * @remarks
@@ -383,11 +360,6 @@ export class TreeNodeKernel {
 	}
 }
 
-/**
- * Used by {@link anchorProxy} as an optimization to ensure that only one anchor is remembered at a time for a given anchor node
- */
-const anchorForgetters = new WeakMap<TreeNode, () => void>();
-
 const kernelEvents = ["childrenChangedAfterBatch", "subtreeChangedAfterBatch"] as const;
 
 type KernelEvents = Pick<AnchorEvents, (typeof kernelEvents)[number]>;
@@ -423,22 +395,22 @@ export const unhydratedFlexTreeNodeToTreeNode =
 	>;
 
 /**
- * An anchor slot which associates an anchor with its corresponding TreeNode, if there is one.
+ * An anchor slot which associates an anchor with its corresponding {@link TreeNode}, if there is one.
  * @remarks
  * For this to work, we have to require that there is at most a single view using a given AnchorSet.
  * FlexTree already has this assumption, and we also assume there is a single simple-tree per FlexTree, so this is valid.
  */
-export const proxySlot = anchorSlot<TreeNode>();
+export const simpleTreeNodeSlot = anchorSlot<TreeNode>();
 
 /**
  * Dispose a TreeNode (if any) for an existing anchor without disposing the anchor.
  */
 export function tryDisposeTreeNode(anchorNode: AnchorNode): void {
-	const treeNode = anchorNode.slots.get(proxySlot);
+	const treeNode = anchorNode.slots.get(simpleTreeNodeSlot);
 	if (treeNode !== undefined) {
 		const kernel = getKernel(treeNode);
 		kernel.dispose();
-		anchorNode.slots.delete(proxySlot);
+		anchorNode.slots.delete(simpleTreeNodeSlot);
 	}
 }
 
@@ -483,7 +455,6 @@ export function getOrCreateInnerNode(treeNode: TreeNode, allowDeleted = false):
  * Gets a flex node from an anchor node
  */
 function flexNodeFromAnchor(anchorNode: AnchorNode): FlexTreeNode {
-	// the proxy is bound to an anchor node, but it may or may not have an actual flex node yet
 	const flexNode = anchorNode.slots.get(flexTreeSlot);
 	if (flexNode !== undefined) {
 		return flexNode; // If it does have a flex node, return it...
@@ -501,7 +472,7 @@ function flexNodeFromAnchor(anchorNode: AnchorNode): FlexTreeNode {
  * Gets a tree node from an anchor node
  */
 export function treeNodeFromAnchor(anchorNode: AnchorNode): TreeNode | TreeValue {
-	const cached = anchorNode.slots.get(proxySlot);
+	const cached = anchorNode.slots.get(simpleTreeNodeSlot);
 	if (cached !== undefined) {
 		return cached;
 	}

package/src/simple-tree/core/treeNodeSchema.ts

@@ -5,6 +5,7 @@
 
 import type { TreeLeafValue } from "../schemaTypes.js";
 import type { SimpleNodeSchemaBase } from "../simpleSchema.js";
+
 import type { TreeNode } from "./treeNode.js";
 import type { InternalTreeNode, Unhydrated } from "./types.js";
 

package/src/simple-tree/core/types.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { assert } from "@fluidframework/core-utils/internal";
 import type { ErasedType } from "@fluidframework/core-interfaces";
+import { assert } from "@fluidframework/core-utils/internal";
 
 import { isFlexTreeNode, type FlexTreeNode } from "../../feature-libraries/index.js";
 

package/src/simple-tree/core/unhydratedFlexTree.ts

@@ -3,9 +3,9 @@
  * Licensed under the MIT License.
  */
 
-import { assert, oob, fail } from "@fluidframework/core-utils/internal";
 import { createEmitter } from "@fluid-internal/client-utils";
 import type { Listenable } from "@fluidframework/core-interfaces";
+import { assert, oob, fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
@@ -25,7 +25,6 @@ import {
 	type TreeStoredSchema,
 	type Value,
 } from "../../core/index.js";
-import { brand, getOrCreate, mapIterable } from "../../util/index.js";
 import {
 	type FlexTreeContext,
 	FlexTreeEntityKind,
@@ -44,6 +43,8 @@ import {
 	type SequenceFieldEditBuilder,
 	cursorForMapTreeNode,
 } from "../../feature-libraries/index.js";
+import { brand, getOrCreate, mapIterable } from "../../util/index.js";
+
 import type { Context } from "./context.js";
 
 interface UnhydratedTreeSequenceFieldEditBuilder
@@ -602,7 +603,7 @@ function getOrCreateField(
 		return new UnhydratedFlexTreeField(parent.simpleContext, schema, key, parent, onEdit);
 	}
 
-	return fail("unsupported field kind");
+	return fail(0xb9d /* unsupported field kind */);
 }
 
 // #endregion Caching and unboxing utilities

package/src/simple-tree/core/withType.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import type { NodeKind, TreeNodeSchemaClass } from "./treeNodeSchema.js";
 import type { TreeNode } from "./treeNode.js";
+import type { NodeKind, TreeNodeSchemaClass } from "./treeNodeSchema.js";
 
 /**
  * The type of a {@link TreeNode}.

package/src/simple-tree/createContext.ts

@@ -5,6 +5,7 @@
 
 import { defaultSchemaPolicy } from "../feature-libraries/index.js";
 import { getOrCreate } from "../util/index.js";
+
 import { Context, UnhydratedContext } from "./core/index.js";
 import { normalizeFieldSchema, type ImplicitFieldSchema } from "./schemaTypes.js";
 import { toStoredSchema } from "./toStoredSchema.js";

package/src/simple-tree/{proxies.ts → getTreeNodeForField.ts}

@@ -4,6 +4,7 @@
  */
 
 import { fail } from "@fluidframework/core-utils/internal";
+
 import type { TreeValue } from "../core/index.js";
 import {
 	FieldKinds,
@@ -12,6 +13,7 @@ import {
 	type FlexTreeRequiredField,
 	type FlexTreeOptionalField,
 } from "../feature-libraries/index.js";
+
 import { type TreeNode, getOrCreateNodeFromInnerNode } from "./core/index.js";
 
 /**

package/src/simple-tree/index.ts

@@ -43,13 +43,8 @@ export {
 	adaptEnum,
 	enumFromStrings,
 	singletonSchema,
-	test_RecursiveObject,
-	test_RecursiveObject_base,
-	test_RecursiveObjectPojoMode,
 	treeNodeApi,
 	type TreeNodeApi,
-	cursorFromInsertable,
-	createFromInsertable,
 	type NodeChangedData,
 	TreeBeta,
 	type TreeChangeEventsBeta,
@@ -88,6 +83,8 @@ export {
 	type TreeBranch,
 	type TreeBranchEvents,
 	tryGetSchema,
+	getStoredKey,
+	getPropertyKeyFromStoredKey,
 	applySchemaToParserOptions,
 	cursorFromVerbose,
 	verboseFromCursor,
@@ -117,6 +114,7 @@ export {
 	type HandleConverter,
 	allowUnused,
 	type FieldSchemaAlphaUnsafe,
+	getIdentifierFromNode,
 	type TreeSchema,
 	type ValidateRecursiveSchemaTemplate,
 	type FixRecursiveRecursionLimit,
@@ -184,33 +182,30 @@ export {
 	type NodeSchemaMetadata,
 	evaluateLazySchema,
 } from "./schemaTypes.js";
-export { getTreeNodeForField } from "./proxies.js";
+export { getTreeNodeForField } from "./getTreeNodeForField.js";
 export {
-	TreeArrayNode,
+	type ArrayNodeCustomizableSchema,
+	type ArrayNodePojoEmulationSchema,
+	ArrayNodeSchema,
+	isArrayNodeSchema,
 	IterableTreeArrayContent,
 	type ReadonlyArrayNode,
-} from "./arrayNode.js";
-export type {
-	ArrayNodeCustomizableSchema,
-	ArrayNodePojoEmulationSchema,
-} from "./arrayNodeTypes.js";
-export { ArrayNodeSchema, isArrayNodeSchema } from "./arrayNodeTypes.js";
-export type {
-	MapNodeCustomizableSchema,
-	MapNodePojoEmulationSchema,
-} from "./mapNodeTypes.js";
-export { MapNodeSchema, isMapNodeSchema } from "./mapNodeTypes.js";
-export {
+	TreeArrayNode,
+	type MapNodeCustomizableSchema,
+	type MapNodePojoEmulationSchema,
+	MapNodeSchema,
+	isMapNodeSchema,
+	type TreeMapNode,
+	type MapNodeInsertableData,
 	type FieldHasDefault,
 	type InsertableObjectFromSchemaRecord,
 	type ObjectFromSchemaRecord,
+	ObjectNodeSchema,
 	type InsertableObjectFromAnnotatedSchemaRecord,
 	type TreeObjectNode,
 	setField,
 	createUnknownOptionalFieldPolicy,
-} from "./objectNode.js";
-export { ObjectNodeSchema } from "./objectNodeTypes.js";
-export type { TreeMapNode, MapNodeInsertableData } from "./mapNode.js";
+} from "./node-kinds/index.js";
 export {
 	mapTreeFromNodeData,
 	type InsertableContent,

package/src/simple-tree/leafNodeSchema.ts

@@ -11,6 +11,7 @@ import {
 	isFlexTreeNode,
 	valueSchemaAllows,
 } from "../feature-libraries/index.js";
+
 import { NodeKind, type TreeNodeSchema, type TreeNodeSchemaNonClass } from "./core/index.js";
 import type { NodeSchemaMetadata, TreeLeafValue } from "./schemaTypes.js";
 import type { SimpleLeafNodeSchema } from "./simpleSchema.js";

package/src/simple-tree/{arrayNode.ts → node-kinds/array/arrayNode.ts}

@@ -6,12 +6,12 @@
 import { Lazy, oob, fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
-import { EmptyKey, type ExclusiveMapTree } from "../core/index.js";
+import { EmptyKey, type ExclusiveMapTree } from "../../../core/index.js";
 import {
 	type FlexTreeNode,
 	type FlexTreeSequenceField,
 	isFlexTreeNode,
-} from "../feature-libraries/index.js";
+} from "../../../feature-libraries/index.js";
 import {
 	normalizeAllowedTypes,
 	unannotateImplicitAllowedTypes,
@@ -22,7 +22,7 @@ import {
 	type TreeLeafValue,
 	type TreeNodeFromImplicitAllowedTypes,
 	type UnannotateImplicitAllowedTypes,
-} from "./schemaTypes.js";
+} from "../../schemaTypes.js";
 import {
 	type WithType,
 	// eslint-disable-next-line import/no-deprecated
@@ -37,17 +37,17 @@ import {
 	getSimpleNodeSchemaFromInnerNode,
 	getOrCreateInnerNode,
 	type TreeNodeSchemaClass,
-} from "./core/index.js";
-import { type InsertableContent, mapTreeFromNodeData } from "./toMapTree.js";
-import { prepareArrayForInsertion } from "./prepareForInsertion.js";
+} from "../../core/index.js";
+import { type InsertableContent, mapTreeFromNodeData } from "../../toMapTree.js";
+import { prepareArrayContentForInsertion } from "../../prepareForInsertion.js";
 import {
 	getKernel,
 	UnhydratedFlexTreeNode,
 	UnhydratedTreeSequenceField,
-} from "./core/index.js";
-import { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
-import { getUnhydratedContext } from "./createContext.js";
-import type { System_Unsafe } from "./api/index.js";
+} from "../../core/index.js";
+import { TreeNodeValid, type MostDerivedData } from "../../treeNodeValid.js";
+import { getUnhydratedContext } from "../../createContext.js";
+import type { System_Unsafe } from "../../api/index.js";
 import type {
 	ArrayNodeCustomizableSchema,
 	ArrayNodePojoEmulationSchema,
@@ -862,7 +862,7 @@ abstract class CustomArrayNodeBase<const T extends ImplicitAllowedTypes>
 		const contentArray = content.flatMap((c): InsertableContent[] =>
 			c instanceof IterableTreeArrayContent ? Array.from(c) : [c],
 		);
-		const mapTrees = prepareArrayForInsertion(
+		const mapTrees = prepareArrayContentForInsertion(
 			contentArray,
 			this.simpleSchema,
 			sequenceField.context,

package/src/simple-tree/{arrayNodeTypes.ts → node-kinds/array/arrayNodeTypes.ts}

@@ -8,16 +8,16 @@ import type {
 	ImplicitAnnotatedAllowedTypes,
 	InsertableTreeNodeFromImplicitAllowedTypes,
 	UnannotateImplicitAllowedTypes,
-} from "./schemaTypes.js";
+} from "../../schemaTypes.js";
 import {
 	NodeKind,
 	type TreeNodeSchemaClass,
 	type TreeNodeSchema,
 	type TreeNodeSchemaNonClass,
 	type WithType,
-} from "./core/index.js";
+} from "../../core/index.js";
 
-import type { SimpleArrayNodeSchema } from "./simpleSchema.js";
+import type { SimpleArrayNodeSchema } from "../../simpleSchema.js";
 
 /**
  * A schema for customizable {@link (TreeArrayNode:interface)}s.

package/src/simple-tree/node-kinds/array/index.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	arraySchema,
+	asIndex,
+	IterableTreeArrayContent,
+	TreeArrayNode,
+	type ReadonlyArrayNode,
+} from "./arrayNode.js";
+export {
+	type ArrayNodeCustomizableSchema,
+	type ArrayNodePojoEmulationSchema,
+	ArrayNodeSchema,
+	isArrayNodeSchema,
+} from "./arrayNodeTypes.js";

package/src/simple-tree/node-kinds/index.ts

@@ -0,0 +1,40 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	type ArrayNodeCustomizableSchema,
+	type ArrayNodePojoEmulationSchema,
+	ArrayNodeSchema,
+	arraySchema,
+	asIndex,
+	isArrayNodeSchema,
+	IterableTreeArrayContent,
+	TreeArrayNode,
+	type ReadonlyArrayNode,
+} from "./array/index.js";
+
+export {
+	isMapNodeSchema,
+	type MapNodeCustomizableSchema,
+	type MapNodeInsertableData,
+	type MapNodePojoEmulationSchema,
+	MapNodeSchema,
+	mapSchema,
+	type TreeMapNode,
+} from "./map/index.js";
+
+export {
+	createUnknownOptionalFieldPolicy,
+	type FieldHasDefault,
+	type InsertableObjectFromAnnotatedSchemaRecord,
+	type InsertableObjectFromSchemaRecord,
+	isObjectNodeSchema,
+	lazilyAllocateIdentifier,
+	type ObjectFromSchemaRecord,
+	ObjectNodeSchema,
+	objectSchema,
+	setField,
+	type TreeObjectNode,
+} from "./object/index.js";

package/src/simple-tree/node-kinds/map/index.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	type MapNodeInsertableData,
+	mapSchema,
+	type TreeMapNode,
+} from "./mapNode.js";
+export {
+	isMapNodeSchema,
+	type MapNodeCustomizableSchema,
+	type MapNodePojoEmulationSchema,
+	MapNodeSchema,
+} from "./mapNodeTypes.js";

package/src/simple-tree/{mapNode.ts → node-kinds/map/mapNode.ts}

@@ -8,8 +8,8 @@ import type {
 	FlexTreeNode,
 	FlexTreeOptionalField,
 	OptionalFieldEditBuilder,
-} from "../feature-libraries/index.js";
-import { getTreeNodeForField } from "./proxies.js";
+} from "../../../feature-libraries/index.js";
+import { getTreeNodeForField } from "../../getTreeNodeForField.js";
 import {
 	createFieldSchema,
 	FieldKind,
@@ -21,7 +21,7 @@ import {
 	type NodeSchemaMetadata,
 	type TreeNodeFromImplicitAllowedTypes,
 	type UnannotateImplicitAllowedTypes,
-} from "./schemaTypes.js";
+} from "../../schemaTypes.js";
 import {
 	getKernel,
 	type InnerNode,
@@ -35,17 +35,17 @@ import {
 	UnhydratedFlexTreeNode,
 	getOrCreateInnerNode,
 	type InternalTreeNode,
-} from "./core/index.js";
+} from "../../core/index.js";
 import {
 	mapTreeFromNodeData,
 	type FactoryContent,
 	type InsertableContent,
-} from "./toMapTree.js";
-import { prepareForInsertion } from "./prepareForInsertion.js";
-import { brand, count, type RestrictiveStringRecord } from "../util/index.js";
-import { TreeNodeValid, type MostDerivedData } from "./treeNodeValid.js";
-import type { ExclusiveMapTree } from "../core/index.js";
-import { getUnhydratedContext } from "./createContext.js";
+} from "../../toMapTree.js";
+import { prepareForInsertion } from "../../prepareForInsertion.js";
+import { brand, count, type RestrictiveStringRecord } from "../../../util/index.js";
+import { TreeNodeValid, type MostDerivedData } from "../../treeNodeValid.js";
+import type { ExclusiveMapTree } from "../../../core/index.js";
+import { getUnhydratedContext } from "../../createContext.js";
 import type { MapNodeCustomizableSchema, MapNodePojoEmulationSchema } from "./mapNodeTypes.js";
 
 /**

package/src/simple-tree/{mapNodeTypes.ts → node-kinds/map/mapNodeTypes.ts}

@@ -7,16 +7,16 @@ import type { MapNodeInsertableData, TreeMapNode } from "./mapNode.js";
 import type {
 	ImplicitAnnotatedAllowedTypes,
 	UnannotateImplicitAllowedTypes,
-} from "./schemaTypes.js";
+} from "../../schemaTypes.js";
 import {
 	NodeKind,
 	type TreeNodeSchemaClass,
 	type TreeNodeSchema,
 	type TreeNodeSchemaNonClass,
 	type WithType,
-} from "./core/index.js";
+} from "../../core/index.js";
 
-import type { SimpleMapNodeSchema } from "./simpleSchema.js";
+import type { SimpleMapNodeSchema } from "../../simpleSchema.js";
 
 /**
  * A schema for customizable {@link (TreeMapNode:interface)}s.

package/src/simple-tree/node-kinds/object/index.ts

@@ -0,0 +1,17 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export {
+	createUnknownOptionalFieldPolicy,
+	type FieldHasDefault,
+	type InsertableObjectFromAnnotatedSchemaRecord,
+	type InsertableObjectFromSchemaRecord,
+	lazilyAllocateIdentifier,
+	type ObjectFromSchemaRecord,
+	objectSchema,
+	setField,
+	type TreeObjectNode,
+} from "./objectNode.js";
+export { isObjectNodeSchema, ObjectNodeSchema } from "./objectNodeTypes.js";