@fluidframework/tree 2.3.0-288113 → 2.3.1

package/src/feature-libraries/flex-tree/flexTreeTypes.ts

@@ -8,10 +8,11 @@ import {
 	type ExclusiveMapTree,
 	type FieldKey,
 	type FieldUpPath,
+	type TreeFieldStoredSchema,
+	type TreeNodeSchemaIdentifier,
 	type TreeValue,
 	anchorSlot,
 } from "../../core/index.js";
-import type { Assume } from "../../util/index.js";
 import type {
 	FieldKinds,
 	SequenceFieldEditBuilder,
@@ -19,18 +20,7 @@ import type {
 	OptionalFieldEditBuilder,
 } from "../default-schema/index.js";
 import type { FlexFieldKind } from "../modular-schema/index.js";
-import type {
-	Any,
-	FlexAllowedTypes,
-	FlexFieldSchema,
-	FlexList,
-	FlexListToUnion,
-	FlexMapNodeSchema,
-	FlexObjectNodeSchema,
-	FlexTreeNodeSchema,
-	LazyItem,
-	LeafNodeSchema,
-} from "../typed-schema/index.js";
+import type { FlexTreeNodeSchema } from "../typed-schema/index.js";
 
 import type { FlexTreeContext } from "./context.js";
 
@@ -45,7 +35,7 @@ export const flexTreeSlot = anchorSlot<FlexTreeNode>();
  */
 export const flexTreeMarker = Symbol("flexTreeMarker");
 
-export function isFlexTreeEntity(t: unknown): t is FlexTreeEntity {
+function isFlexTreeEntity(t: unknown): t is FlexTreeEntity {
 	return typeof t === "object" && t !== null && flexTreeMarker in t;
 }
 
@@ -74,7 +64,7 @@ export enum FlexTreeEntityKind {
  * Design and document iterator invalidation rules and ordering rules.
  * Providing a custom iterator type with place anchor semantics would be a good approach.
  */
-export interface FlexTreeEntity<out TSchema = unknown> {
+export interface FlexTreeEntity {
 	/**
 	 * Indicates that an object is a specific kind of flex tree FlexTreeEntity.
 	 * This makes it possible to both down cast FlexTreeEntities safely as well as validate if an object is or is not a FlexTreeEntity.
@@ -82,24 +72,9 @@ export interface FlexTreeEntity<out TSchema = unknown> {
 	readonly [flexTreeMarker]: FlexTreeEntityKind;
 
 	/**
-	 * Schema for this entity.
-	 * If well-formed, it must follow this schema.
-	 */
-	readonly schema: TSchema;
-
-	/**
-	 * A common context of a "forest" of FlexTrees.
-	 * @remarks This is `undefined` for unhydrated nodes or fields that have not yet been inserted into the tree.
-	 */
-	readonly context?: FlexTreeContext;
-
-	/**
-	 * Iterate through all nodes/fields in this field/node.
-	 *
-	 * @remarks
-	 * No mutations to the current view of the shared tree are permitted during iteration.
+	 * A common context of FlexTrees.
 	 */
-	boxedIterator(): IterableIterator<FlexTreeEntity>;
+	readonly context: FlexTreeContext;
 }
 
 /**
@@ -124,6 +99,20 @@ export enum TreeStatus {
 
 	/**
 	 * Is created but has not yet been inserted into the tree.
+	 * @remarks
+	 * See also {@link Unhydrated}.
+	 *
+	 * Nodes in the new state have some limitations:
+	 *
+	 * - Events are not currently triggered for changes. Fixes for this are planned.
+	 *
+	 * - Reading identifiers from nodes which were left unspecified (defaulted) when creating the tree will error.
+	 * This is because allocating unique identifiers in a compressible manner requires knowing which tree the nodes will be inserted into.
+	 *
+	 * - Transactions do not work: transactions apply to a single {@link TreeView}, and `New` nodes are not part of one.
+	 *
+	 * - `Tree.shortId` (when the identifier was explicitly specified and thus works at all) will just return the full identifier as a string,
+	 * but might return a compressed form as a number once hydrated.
 	 */
 	New = 3,
 }
@@ -144,7 +133,7 @@ export enum TreeStatus {
  * the schema aware API may be more ergonomic.
  * All editing is actually done via {@link FlexTreeField}s: the nodes are immutable other than that they contain mutable fields.
  */
-export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
+export interface FlexTreeNode extends FlexTreeEntity {
 	readonly [flexTreeMarker]: FlexTreeEntityKind.Node;
 
 	/**
@@ -176,7 +165,7 @@ export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
 	/**
 	 * Type guard for narrowing / down-casting to a specific schema.
 	 */
-	is<TSchema extends FlexTreeNodeSchema>(schema: TSchema): this is FlexTreeTypedNode<TSchema>;
+	is(schema: FlexTreeNodeSchema): boolean;
 
 	boxedIterator(): IterableIterator<FlexTreeField>;
 
@@ -189,6 +178,28 @@ export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
 	 * a separate Anchor (and thus ref count) must be allocated to keep it alive.
 	 */
 	readonly anchorNode: AnchorNode;
+
+	/**
+	 * Returns an iterable of keys for non-empty fields.
+	 *
+	 * @remarks
+	 * All fields under a map implicitly exist, but `keys` will yield only the keys of fields which contain one or more nodes.
+	 *
+	 * No guarantees are made regarding the order of the keys returned.
+	 */
+	keys(): IterableIterator<FieldKey>;
+
+	/**
+	 * Schema for this entity.
+	 * If well-formed, it must follow this schema.
+	 */
+	readonly schema: TreeNodeSchemaIdentifier;
+
+	/**
+	 * Schema for this entity.
+	 * If well-formed, it must follow this schema.
+	 */
+	readonly flexSchema: FlexTreeNodeSchema;
 }
 
 /**
@@ -209,7 +220,7 @@ export interface FlexTreeNode extends FlexTreeEntity<FlexTreeNodeSchema> {
  * All content in the tree is accessible without down-casting, but if the schema is known,
  * the schema aware API may be more ergonomic.
  */
-export interface FlexTreeField extends FlexTreeEntity<FlexFieldSchema> {
+export interface FlexTreeField extends FlexTreeEntity {
 	readonly [flexTreeMarker]: FlexTreeEntityKind.Field;
 
 	/**
@@ -232,7 +243,7 @@ export interface FlexTreeField extends FlexTreeEntity<FlexFieldSchema> {
 	/**
 	 * Type guard for narrowing / down-casting to a specific schema.
 	 */
-	is<TSchema extends FlexFieldSchema>(schema: TSchema): this is FlexTreeTypedField<TSchema>;
+	is<TKind extends FlexFieldKind>(kind: TKind): this is FlexTreeTypedField<TKind>;
 
 	boxedIterator(): IterableIterator<FlexTreeNode>;
 
@@ -247,117 +258,19 @@ export interface FlexTreeField extends FlexTreeEntity<FlexFieldSchema> {
 	 * Semantics match {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at}.
 	 */
 	boxedAt(index: number): FlexTreeNode | undefined;
-}
-
-// #region Node Kinds
-
-/**
- * A {@link FlexTreeNode} that behaves like a `Map<string, Field>` for a specific `Field` type.
- *
- * @remarks
- * Unlike TypeScript Map type, {@link FlexTreeMapNode.get} always provides a reference to any field looked up, even if it has never been set.
- *
- * This means that, for example, a `MapNode` of {@link FlexTreeSequenceField} fields will return an empty sequence when a previously unused key is looked up,
- * and that sequence can be used to insert new items into the field.
- * Additionally empty fields (those containing no nodes) are not distinguished from fields which do not exist.
- * This differs from JavaScript Maps which have a subtle distinction between storing undefined as a value in the map and deleting an entry from the map.
- */
-export interface FlexTreeMapNode<in out TSchema extends FlexMapNodeSchema>
-	extends FlexTreeNode {
-	readonly schema: TSchema;
-
-	/**
-	 * Get the field for `key`.
-	 * @param key - which map entry to look up.
-	 *
-	 * @remarks
-	 * All fields under a map implicitly exist, so `get` can be called with any key and will always return a field.
-	 * Even if the field is empty, it will still be returned, and can be edited to insert content into the map.
-	 */
-	getBoxed(key: string): FlexTreeTypedField<TSchema["info"]>;
 
 	/**
-	 * Returns an iterable of keys in the map.
-	 *
-	 * @remarks
-	 * All fields under a map implicitly exist, but `keys` will yield only the keys of fields which contain one or more nodes.
-	 *
-	 * No guarantees are made regarding the order of the keys returned.
-	 */
-	keys(): IterableIterator<FieldKey>;
-
-	/**
-	 * Returns an iterable of values in the map.
-	 *
-	 * @remarks
-	 * All fields under a map implicitly exist, but `values` will yield only the fields containing one or more nodes.
-	 *
-	 * No guarantees are made regarding the order of the values returned.
-	 */
-	values(): IterableIterator<FlexTreeUnboxField<TSchema["info"], "notEmpty">>;
-
-	/**
-	 * Returns an iterable of key, value pairs for every entry in the map.
-	 *
-	 * @remarks
-	 * All fields under a map implicitly exist, but `entries` will yield only the entries whose fields contain one or more nodes.
-	 *
-	 * This iteration provided by `entries()` is equivalent to that provided by direct iteration of the {@link FlexTreeMapNode} (a.k.a. `[Symbol.Iterator]()`).
-	 *
-	 * No guarantees are made regarding the order of the entries returned.
+	 * Gets the FieldUpPath of a field.
 	 */
-	entries(): IterableIterator<[FieldKey, FlexTreeUnboxField<TSchema["info"], "notEmpty">]>;
-
-	[Symbol.iterator](): IterableIterator<
-		[FieldKey, FlexTreeUnboxField<TSchema["info"], "notEmpty">]
-	>;
-}
-
-/**
- * A {@link FlexTreeNode} that behaves like an "object" or "struct", providing properties to access its fields.
- *
- * ObjectNodes consist of a finite collection of fields, each with their own (distinct) key and {@link FlexFieldSchema}.
- *
- * @remarks
- * ObjectNodes require complex typing, and have been split into two parts for implementation purposes.
- *
- * These "Objects" resemble "Structs" from a wide variety of programming languages
- * (Including Algol 68, C, Go, Rust, C# etc.).
- * ObjectNodes also somewhat resemble JavaScript objects: this analogy is less precise (objects don't have a fixed schema for example),
- * but for consistency with other systems in the JavaScript ecosystem (like JSON) is "ObjectNodes" nodes are named "Objects".
- *
- * Another common name for this abstraction is [record](https://en.wikipedia.org/wiki/Record_(computer_science)).
- * The name "Record" is avoided (in favor of Object) here because it has less precise connotations for most TypeScript developers.
- * For example, TypeScript has a built in `Record` type, but it requires all of the fields to have the same type,
- * putting its semantics half way between this library's "Object" schema and {@link FlexTreeMapNode}.
- */
-export interface FlexTreeObjectNode extends FlexTreeNode {
-	readonly schema: FlexObjectNodeSchema;
-}
-
-/**
- * Leaf holding a value.
- *
- * @remarks
- * Leaves are immutable and have no children.
- * Leaf unboxes its content, so in schema aware APIs which do unboxing, the Leaf itself will be skipped over and its value will be returned directly.
- */
-export interface FlexTreeLeafNode<in out TSchema extends LeafNodeSchema> extends FlexTreeNode {
-	readonly schema: TSchema;
+	getFieldPath(): FieldUpPath;
 
 	/**
-	 * Value stored on this node.
+	 * Schema for this entity.
+	 * If well-formed, it must follow this schema.
 	 */
-	readonly value: TreeValue<TSchema["info"]>;
+	readonly schema: TreeFieldStoredSchema;
 }
 
-/**
- * Field kinds that allow value assignment.
- */
-export type AssignableFieldKinds = typeof FieldKinds.optional | typeof FieldKinds.required;
-
-// #endregion
-
 // #region Field Kinds
 
 /**
@@ -370,22 +283,6 @@ export type FlexibleFieldContent = ExclusiveMapTree[];
  */
 export type FlexibleNodeContent = ExclusiveMapTree;
 
-/**
- * Tree for inserting a subsequence of nodes.
- *
- * Used to insert a batch of 0 or more nodes into some location in a {@link FlexTreeSequenceField}.
- */
-export type FlexibleNodeSubSequence = ExclusiveMapTree[];
-
-/**
- * Type to ensures two types overlap in at least one way.
- * It evaluates to the input type if this is true, and never otherwise.
- * Examples:
- * CheckTypesOverlap\<number | boolean, number | object\> = number | boolean
- * CheckTypesOverlap\<number | boolean, string | object\> = never
- */
-export type CheckTypesOverlap<T, TCheck> = [Extract<T, TCheck> extends never ? never : T][0];
-
 /**
  * {@link FlexTreeField} that stores a sequence of children.
  *
@@ -402,8 +299,7 @@ export type CheckTypesOverlap<T, TCheck> = [Extract<T, TCheck> extends never ? n
  * Add anchor API that can actually hold onto locations in a sequence.
  * Currently only nodes can be held onto with anchors, and this does not replicate the behavior implemented for editing.
  */
-export interface FlexTreeSequenceField<in out TTypes extends FlexAllowedTypes>
-	extends FlexTreeField {
+export interface FlexTreeSequenceField extends FlexTreeField {
 	/**
 	 * Gets a node of this field by its index with unboxing.
 	 * @param index - Zero-based index of the item to retrieve. Negative values are interpreted from the end of the sequence.
@@ -414,34 +310,25 @@ export interface FlexTreeSequenceField<in out TTypes extends FlexAllowedTypes>
 	 * @remarks
 	 * Semantics match {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at | Array.at}.
 	 */
-	at(index: number): FlexTreeUnboxNodeUnion<TTypes> | undefined;
+	at(index: number): FlexTreeUnknownUnboxed | undefined;
 
 	/**
 	 * {@inheritdoc FlexTreeField.boxedAt}
 	 */
-	boxedAt(index: number): FlexTreeTypedNodeUnion<TTypes> | undefined;
+	boxedAt(index: number): FlexTreeNode | undefined;
 
 	/**
 	 * Calls the provided callback function on each child of this sequence, and returns an array that contains the results.
 	 * @param callbackfn - A function that accepts the child and its index.
 	 */
-	map<U>(callbackfn: (value: FlexTreeUnboxNodeUnion<TTypes>, index: number) => U): U[];
-
-	readonly length: number;
+	map<U>(callbackfn: (value: FlexTreeUnknownUnboxed, index: number) => U): U[];
 
 	/**
 	 * Get an editor for this sequence.
 	 */
 	readonly editor: SequenceFieldEditBuilder<FlexibleFieldContent>;
 
-	boxedIterator(): IterableIterator<FlexTreeTypedNodeUnion<TTypes>>;
-
-	/**
-	 * Gets the FieldUpPath of a field.
-	 */
-	getFieldPath(): FieldUpPath;
-
-	[Symbol.iterator](): IterableIterator<FlexTreeUnboxNodeUnion<TTypes>>;
+	boxedIterator(): IterableIterator<FlexTreeNode>;
 }
 
 /**
@@ -450,9 +337,8 @@ export interface FlexTreeSequenceField<in out TTypes extends FlexAllowedTypes>
  * @remarks
  * Unboxes its content, so in schema aware APIs which do unboxing, the RequiredField itself will be skipped over and its content will be returned directly.
  */
-export interface FlexTreeRequiredField<in out TTypes extends FlexAllowedTypes>
-	extends FlexTreeField {
-	get content(): FlexTreeUnboxNodeUnion<TTypes>;
+export interface FlexTreeRequiredField extends FlexTreeField {
+	get content(): FlexTreeUnknownUnboxed;
 
 	readonly editor: ValueFieldEditBuilder<FlexibleNodeContent>;
 }
@@ -470,9 +356,8 @@ export interface FlexTreeRequiredField<in out TTypes extends FlexAllowedTypes>
  * Better centralize the documentation about what kinds of merge semantics are available for field kinds.
  * Maybe link editor?
  */
-export interface FlexTreeOptionalField<in out TTypes extends FlexAllowedTypes>
-	extends FlexTreeField {
-	get content(): FlexTreeUnboxNodeUnion<TTypes> | undefined;
+export interface FlexTreeOptionalField extends FlexTreeField {
+	get content(): FlexTreeUnknownUnboxed | undefined;
 
 	readonly editor: OptionalFieldEditBuilder<FlexibleNodeContent>;
 }
@@ -484,125 +369,18 @@ export interface FlexTreeOptionalField<in out TTypes extends FlexAllowedTypes>
 /**
  * Schema aware specialization of {@link FlexTreeField}.
  */
-export type FlexTreeTypedField<TSchema extends FlexFieldSchema> = FlexTreeTypedFieldInner<
-	TSchema["kind"],
-	TSchema["allowedTypes"]
->;
-
-/**
- * Helper for implementing {@link FlexTreeTypedField}.
- */
-export type FlexTreeTypedFieldInner<
-	Kind extends FlexFieldKind,
-	Types extends FlexAllowedTypes,
-> = Kind extends typeof FieldKinds.sequence
-	? FlexTreeSequenceField<Types>
-	: Kind extends typeof FieldKinds.required
-		? FlexTreeRequiredField<Types>
-		: Kind extends typeof FieldKinds.optional
-			? FlexTreeOptionalField<Types>
-			: FlexTreeField;
-
-/**
- * Schema aware specialization of {@link FlexTreeNode} for a given {@link FlexAllowedTypes}.
- */
-export type FlexTreeTypedNodeUnion<T extends FlexAllowedTypes> =
-	T extends FlexList<FlexTreeNodeSchema>
-		? FlexTreeTypedNode<Assume<FlexListToUnion<T>, FlexTreeNodeSchema>>
-		: FlexTreeNode;
-
-/**
- * Schema aware specialization of {@link FlexTreeNode} for a given {@link FlexTreeNodeSchema}.
- */
-export type FlexTreeTypedNode<TSchema extends FlexTreeNodeSchema> =
-	TSchema extends LeafNodeSchema
-		? FlexTreeLeafNode<TSchema>
-		: TSchema extends FlexMapNodeSchema
-			? FlexTreeMapNode<TSchema>
-			: TSchema extends FlexObjectNodeSchema
-				? FlexTreeObjectNode
-				: FlexTreeNode;
+export type FlexTreeTypedField<Kind extends FlexFieldKind> =
+	Kind extends typeof FieldKinds.sequence
+		? FlexTreeSequenceField
+		: Kind extends typeof FieldKinds.required
+			? FlexTreeRequiredField
+			: Kind extends typeof FieldKinds.optional
+				? FlexTreeOptionalField
+				: FlexTreeField;
 
 // #endregion
 
-// #region Unbox
-
-/**
- * Schema aware unboxed field.
- * @remarks
- * Unboxes fields to their content if appropriate for the kind.
- * Recursively unboxes that content (then its content etc.) as well if the node union does unboxing.
- */
-export type FlexTreeUnboxField<
-	TSchema extends FlexFieldSchema,
-	// If "notEmpty", then optional fields will unbox to their content (not their content | undefined)
-	Emptiness extends "maybeEmpty" | "notEmpty" = "maybeEmpty",
-> = FlexTreeUnboxFieldInner<TSchema["kind"], TSchema["allowedTypes"], Emptiness>;
-
-/**
- * Helper for implementing FlexTreeUnboxField.
- */
-export type FlexTreeUnboxFieldInner<
-	Kind extends FlexFieldKind,
-	TTypes extends FlexAllowedTypes,
-	Emptiness extends "maybeEmpty" | "notEmpty",
-> = Kind extends typeof FieldKinds.sequence
-	? FlexTreeSequenceField<TTypes>
-	: Kind extends typeof FieldKinds.required
-		? FlexTreeUnboxNodeUnion<TTypes>
-		: Kind extends typeof FieldKinds.optional
-			? FlexTreeUnboxNodeUnion<TTypes> | (Emptiness extends "notEmpty" ? never : undefined)
-			: // TODO: forbidden
-				unknown;
-
-/**
- * Schema aware unboxed union of tree types.
- * @remarks
- * Unboxes when not polymorphic.
- * Recursively unboxes that content as well if the node kind does unboxing.
- */
-export type FlexTreeUnboxNodeUnion<TTypes extends FlexAllowedTypes> = TTypes extends readonly [
-	LazyItem<infer InnerType>,
-]
-	? InnerType extends FlexTreeNodeSchema
-		? FlexTreeUnboxNode<InnerType>
-		: InnerType extends Any
-			? FlexTreeNode
-			: // This case should not occur. If the result ever ends up unknown, look at places like this to debug.
-				unknown
-	: boolean extends IsArrayOfOne<TTypes>
-		? FlexTreeUnknownUnboxed // Unknown if this will unbox. This should mainly happen when TTypes is AllowedTypes.
-		: FlexTreeTypedNodeUnion<TTypes>; // Known to not be a single type, so known not to unbox.
-
-/**
- * `true` if T is known to be an array of one item.
- * `false` if T is known not to be an array of one item.
- * `boolean` if it is unknown if T is an array of one item or not.
- */
-export type IsArrayOfOne<T extends readonly unknown[]> = T["length"] extends 1
-	? true
-	: 1 extends T["length"]
-		? boolean
-		: false;
-
-/**
- * Schema aware unboxed tree type.
- * @remarks
- * Unboxes if the node kind does unboxing.
- * Recursively unboxes that content as well if it does unboxing.
- */
-export type FlexTreeUnboxNode<TSchema extends FlexTreeNodeSchema> =
-	TSchema extends LeafNodeSchema
-		? TreeValue<TSchema["info"]>
-		: TSchema extends FlexMapNodeSchema
-			? FlexTreeMapNode<TSchema>
-			: TSchema extends FlexObjectNodeSchema
-				? FlexTreeObjectNode
-				: FlexTreeUnknownUnboxed;
-
 /**
  * Unboxed tree type for unknown schema cases.
  */
 export type FlexTreeUnknownUnboxed = TreeValue | FlexTreeNode;
-
-// #endregion

package/src/feature-libraries/flex-tree/index.ts

@@ -8,21 +8,11 @@ export {
 	type FlexTreeNode,
 	type FlexTreeEntity,
 	type FlexTreeTypedField,
-	type FlexibleFieldContent,
-	type FlexibleNodeContent,
-	type FlexTreeLeafNode,
-	type FlexTreeMapNode,
 	type FlexTreeOptionalField,
 	type FlexTreeRequiredField,
 	type FlexTreeSequenceField,
-	type FlexTreeObjectNode,
-	type AssignableFieldKinds,
-	type FlexTreeTypedNode,
-	type FlexTreeTypedNodeUnion,
-	type CheckTypesOverlap,
 	TreeStatus,
 	type FlexTreeUnknownUnboxed,
-	type FlexTreeUnboxField,
 	flexTreeMarker,
 	FlexTreeEntityKind,
 	isFlexTreeNode,
@@ -37,12 +27,16 @@ export {
 	visitIterableTreeWithState,
 } from "./navigation.js";
 
-export { getTreeContext, type FlexTreeContext, Context, ContextSlot } from "./context.js";
+export {
+	getTreeContext,
+	type FlexTreeContext,
+	type FlexTreeHydratedContext,
+	Context,
+	ContextSlot,
+} from "./context.js";
 
 export { type FlexTreeNodeEvents } from "./treeEvents.js";
 
-export type { FlexTreeUnboxNodeUnion } from "./flexTreeTypes.js";
-
 export {
 	assertFlexTreeEntityNotFreed,
 	isFreedSymbol,

package/src/feature-libraries/flex-tree/lazyEntity.ts

@@ -44,14 +44,14 @@ export function assertFlexTreeEntityNotFreed(entity: FlexTreeEntity): void {
  * This is a base class for lazy (cursor based) UntypedEntity implementations, which uniformly handles cursors and anchors.
  */
 export abstract class LazyEntity<TSchema = unknown, TAnchor = unknown>
-	implements FlexTreeEntity<TSchema>, IDisposable
+	implements FlexTreeEntity, IDisposable
 {
 	readonly #lazyCursor: ITreeSubscriptionCursor;
 	public readonly [anchorSymbol]: TAnchor;
 
 	protected constructor(
 		public readonly context: Context,
-		public readonly schema: TSchema,
+		public readonly flexSchema: TSchema,
 		cursor: ITreeSubscriptionCursor,
 		anchor: TAnchor,
 	) {
@@ -109,12 +109,3 @@ export abstract class LazyEntity<TSchema = unknown, TAnchor = unknown>
 	 */
 	protected abstract [forgetAnchorSymbol](): void;
 }
-
-/**
- * Prevent Entities from inheriting members from Object.prototype including:
- * '__defineGetter__', '__defineSetter__', '__lookupGetter__', '__lookupSetter__', '__proto__',
- * 'hasOwnProperty', 'isPrototypeOf', 'valueOf', 'propertyIsEnumerable', 'toLocaleString' and 'toString'.
- *
- * This opens up more options for field names on struct nodes.
- */
-Object.setPrototypeOf(LazyEntity.prototype, null);