@fluidframework/tree 2.51.0 → 2.53.0-350190

package/src/simple-tree/prepareForInsertion.ts

@@ -11,6 +11,7 @@ import type {
 	FieldKey,
 	DetachedField,
 	TreeFieldStoredSchema,
+	TreeTypeSet,
 } from "../core/index.js";
 import {
 	type FlexTreeContext,
@@ -19,8 +20,9 @@ import {
 	FieldKinds,
 	type FlexibleFieldContent,
 	type FlexibleNodeContent,
+	throwOutOfSchema,
 } from "../feature-libraries/index.js";
-import { normalizeFieldSchema, type ImplicitFieldSchema } from "./fieldSchema.js";
+import type { ImplicitAnnotatedFieldSchema } from "./fieldSchema.js";
 import {
 	type InsertableContent,
 	unhydratedFlexTreeFromInsertable,
@@ -29,13 +31,20 @@ import { UsageError } from "@fluidframework/telemetry-utils/internal";
 import { brand } from "../util/index.js";
 import {
 	getKernel,
-	type ImplicitAllowedTypes,
+	type ImplicitAnnotatedAllowedTypes,
 	type TreeNode,
 	type UnhydratedFlexTreeNode,
 } from "./core/index.js";
 import { debugAssert, oob } from "@fluidframework/core-utils/internal";
-import { inSchemaOrThrow, isFieldInSchema } from "../feature-libraries/index.js";
-import { convertField } from "./toStoredSchema.js";
+import { isFieldInSchema } from "../feature-libraries/index.js";
+
+/**
+ * For now, schema validation for inserted content is always enabled.
+ * @remarks
+ * If this ends up being too much of a performance overhead, AND nothing depends on it (like staged allowed types likely will),
+ * this could be changed.
+ */
+const validateSchema = true;
 
 /**
  * Prepare content from a user for insertion into a tree.
@@ -47,14 +56,16 @@ import { convertField } from "./toStoredSchema.js";
  */
 export function prepareForInsertion<TIn extends InsertableContent | undefined>(
 	data: TIn,
-	schema: ImplicitFieldSchema,
+	schema: ImplicitAnnotatedFieldSchema,
 	destinationContext: FlexTreeContext,
+	destinationSchema: TreeFieldStoredSchema,
 ): TIn extends undefined ? undefined : FlexibleNodeContent {
 	return prepareForInsertionContextless(
 		data,
 		schema,
 		getSchemaAndPolicy(destinationContext),
 		destinationContext.isHydrated() ? destinationContext : undefined,
+		destinationSchema,
 	);
 }
 
@@ -73,21 +84,20 @@ export function prepareForInsertion<TIn extends InsertableContent | undefined>(
  */
 export function prepareArrayContentForInsertion(
 	data: readonly InsertableContent[],
-	schema: ImplicitAllowedTypes,
+	schema: ImplicitAnnotatedAllowedTypes,
 	destinationContext: FlexTreeContext,
+	destinationSchema: TreeTypeSet,
 ): FlexibleFieldContent {
 	const mapTrees: UnhydratedFlexTreeNode[] = data.map((item) =>
 		unhydratedFlexTreeFromInsertable(item, schema),
 	);
 
-	const fieldSchema = convertField(normalizeFieldSchema(schema));
-
 	validateAndPrepare(
 		getSchemaAndPolicy(destinationContext),
 		destinationContext.isHydrated() ? destinationContext : undefined,
 		{
 			kind: FieldKinds.sequence.identifier,
-			types: fieldSchema.types,
+			types: destinationSchema,
 			persistedMetadata: undefined,
 		},
 		mapTrees,
@@ -107,15 +117,15 @@ export function prepareArrayContentForInsertion(
  */
 export function prepareForInsertionContextless<TIn extends InsertableContent | undefined>(
 	data: TIn,
-	schema: ImplicitFieldSchema,
+	schema: ImplicitAnnotatedFieldSchema,
 	schemaAndPolicy: SchemaAndPolicy,
 	hydratedData: FlexTreeHydratedContextMinimal | undefined,
+	destinationSchema: TreeFieldStoredSchema,
 ): TIn extends undefined ? undefined : FlexibleNodeContent {
 	const mapTree = unhydratedFlexTreeFromInsertable(data, schema);
 
 	const contentArray = mapTree === undefined ? [] : [mapTree];
-	const fieldSchema = convertField(normalizeFieldSchema(schema));
-	validateAndPrepare(schemaAndPolicy, hydratedData, fieldSchema, contentArray);
+	validateAndPrepare(schemaAndPolicy, hydratedData, destinationSchema, contentArray);
 
 	return mapTree;
 }
@@ -137,9 +147,12 @@ function validateAndPrepare(
 		// This ensures that when `isFieldInSchema` requests identifiers (or any other contextual defaults),
 		// they were already creating used the more specific context we have access to from `hydratedData`.
 		prepareContentForHydration(mapTrees, hydratedData.checkout.forest, hydratedData);
-		if (schemaAndPolicy.policy.validateSchema === true) {
-			const maybeError = isFieldInSchema(mapTrees, fieldSchema, schemaAndPolicy);
-			inSchemaOrThrow(maybeError);
+		// TODO: AB#45723
+		// Now that staged schema rely on this validation, its a bit odd we don't do it for insertion into unhydrated contexts.
+		// We can't simply enable it for them however due to contextual default fields which would not have been created yet (see comment above).
+		// Specifically at least clone can result in unhydrated trees which can end up violating their stored schema (but not view schema) just using the type safe APIs.
+		if (validateSchema === true) {
+			isFieldInSchema(mapTrees, fieldSchema, schemaAndPolicy, throwOutOfSchema);
 		}
 	}
 }

package/src/simple-tree/simpleSchema.ts

@@ -5,7 +5,7 @@
 
 import type { ValueSchema } from "../core/index.js";
 import type { JsonCompatibleReadOnlyObject } from "../util/index.js";
-import type { NodeKind, NodeSchemaMetadata } from "./core/index.js";
+import type { NodeKind, SimpleNodeSchemaBase } from "./core/index.js";
 import type { FieldKind, FieldSchemaMetadata } from "./fieldSchema.js";
 
 /*
@@ -13,30 +13,6 @@ import type { FieldKind, FieldSchemaMetadata } from "./fieldSchema.js";
  * - Customize their JSON serialization to use these formats or provide some other serialization scheme.
  */
 
-/**
- * Base interface for {@link TreeNodeSchema} and {@link SimpleNodeSchema} types.
- * Once simple schema is stable this doesn't have a reason to be kept `@system`, but it could be.
- * @system
- * @public
- * @sealed
- */
-export interface SimpleNodeSchemaBase<
-	out TNodeKind extends NodeKind,
-	out TCustomMetadata = unknown,
-> {
-	/**
-	 * The {@link NodeKind}.
-	 *
-	 * @remarks can be used to type-switch between implementations.
-	 */
-	readonly kind: TNodeKind;
-
-	/**
-	 * User-provided {@link NodeSchemaMetadata} for this schema.
-	 */
-	readonly metadata: NodeSchemaMetadata<TCustomMetadata>;
-}
-
 /**
  * A {@link SimpleNodeSchema} containing fields for alpha features.
  *
@@ -230,7 +206,11 @@ export interface SimpleTreeSchema {
 	/**
 	 * The complete set of node schema definitions recursively referenced by the tree's {@link SimpleTreeSchema.root}.
 	 *
-	 * @remarks the keys are the schemas' {@link TreeNodeSchemaCore.identifier | identifiers}.
+	 * @remarks
+	 * The keys are the schemas' {@link TreeNodeSchemaCore.identifier | identifiers}.
+	 *
+	 * Information about if a schema is {@link SchemaStaticsAlpha.staged | staged} or not is not available as the "Simple Schema" layer of abstraction: they are included unconditionally.
+	 * Options for filtering out staged schemas from view schema are available in {@link extractPersistedSchema}.
 	 */
 	readonly definitions: ReadonlyMap<string, SimpleNodeSchema>;
 }

package/src/simple-tree/toStoredSchema.ts

@@ -3,7 +3,7 @@
  * Licensed under the MIT License.
  */
 
-import { assert, unreachableCase, fail } from "@fluidframework/core-utils/internal";
+import { unreachableCase, fail } from "@fluidframework/core-utils/internal";
 import { UsageError } from "@fluidframework/telemetry-utils/internal";
 
 import {
@@ -20,27 +20,81 @@ import {
 	type TreeTypeSet,
 } from "../core/index.js";
 import { FieldKinds, type FlexFieldKind } from "../feature-libraries/index.js";
-import { brand, getOrCreate } from "../util/index.js";
+import { brand, getOrCreate, type JsonCompatibleReadOnlyObject } from "../util/index.js";
 
-import { NodeKind } from "./core/index.js";
-import { FieldKind, normalizeFieldSchema, type ImplicitFieldSchema } from "./fieldSchema.js";
-import type {
-	SimpleFieldSchema,
-	SimpleNodeSchema,
-	SimpleNodeSchemaBase,
-	SimpleTreeSchema,
-} from "./simpleSchema.js";
+import {
+	allowedTypeFilter,
+	convertAllowedTypes,
+	getTreeNodeSchemaPrivateData,
+	isClassBasedSchema,
+	NodeKind,
+	type SimpleNodeSchemaBase,
+	type StoredSchemaGenerationOptions,
+} from "./core/index.js";
+import {
+	FieldKind,
+	FieldSchemaAlpha,
+	normalizeFieldSchema,
+	type ImplicitAnnotatedFieldSchema,
+	type ImplicitFieldSchema,
+} from "./fieldSchema.js";
+import type { SimpleFieldSchema, SimpleNodeSchema } from "./simpleSchema.js";
 import { walkFieldSchema } from "./walkFieldSchema.js";
 
-const viewToStoredCache = new WeakMap<ImplicitFieldSchema, TreeStoredSchema>();
+const viewToStoredCache = new WeakMap<
+	StoredSchemaGenerationOptions,
+	WeakMap<ImplicitFieldSchema, TreeStoredSchema>
+>();
+
+export const restrictiveStoredSchemaGenerationOptions: StoredSchemaGenerationOptions = {
+	includeStaged: () => false,
+};
+
+export const permissiveStoredSchemaGenerationOptions: StoredSchemaGenerationOptions = {
+	includeStaged: () => true,
+};
+
+/**
+ * Converts a {@link ImplicitAnnotatedFieldSchema} into a {@link TreeStoredSchema} for use in schema upgrades.
+ *
+ * TODO: once upgrades are more flexible, this should take in more options, including the old schema and specific upgrades to enable.
+ */
+export function toUpgradeSchema(root: ImplicitAnnotatedFieldSchema): TreeStoredSchema {
+	return toStoredSchema(root, restrictiveStoredSchemaGenerationOptions);
+}
+
+/**
+ * Converts a {@link ImplicitAnnotatedFieldSchema} into a {@link TreeStoredSchema} for use as initial document schema.
+ */
+export function toInitialSchema(root: ImplicitAnnotatedFieldSchema): TreeStoredSchema {
+	return toStoredSchema(root, restrictiveStoredSchemaGenerationOptions);
+}
+
+/**
+ * Converts a {@link ImplicitAnnotatedFieldSchema} into a {@link TreeStoredSchema} to used for unhydrated nodes.
+ * @remarks
+ * This allows as much as possible, relying on further validation when inserting the content.
+ *
+ * TODO: this should get additional options to enable support for unknown optional fields.
+ */
+export const toUnhydratedSchema = permissiveStoredSchemaGenerationOptions;
 
 /**
- * Converts a {@link ImplicitFieldSchema} into a {@link TreeStoredSchema}.
+ * Converts a {@link ImplicitAnnotatedFieldSchema} into a {@link TreeStoredSchema}.
+ *
+ * @privateRemarks
+ * TODO:#38722 When runtime schema upgrades are implemented, this will need to be updated to check if
+ * a staged allowed type has been upgraded and if so, include it in the conversion.
+ *
  * @throws
  * Throws a `UsageError` if multiple schemas are encountered with the same identifier.
  */
-export function toStoredSchema(root: ImplicitFieldSchema): TreeStoredSchema {
-	return getOrCreate(viewToStoredCache, root, () => {
+export function toStoredSchema(
+	root: ImplicitAnnotatedFieldSchema,
+	options: StoredSchemaGenerationOptions,
+): TreeStoredSchema {
+	const cache = getOrCreate(viewToStoredCache, options, () => new WeakMap());
+	return getOrCreate(cache, root, () => {
 		const normalized = normalizeFieldSchema(root);
 		const nodeSchema: Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> = new Map();
 		walkFieldSchema(normalized, {
@@ -55,42 +109,39 @@ export function toStoredSchema(root: ImplicitFieldSchema): TreeStoredSchema {
 				}
 				nodeSchema.set(
 					brand(schema.identifier),
-					getStoredSchema(schema as SimpleNodeSchemaBase<NodeKind> as SimpleNodeSchema),
+					getStoredSchema(
+						schema as SimpleNodeSchemaBase<NodeKind> as SimpleNodeSchema,
+						options,
+					),
 				);
 			},
+			allowedTypeFilter: (allowedType) => allowedTypeFilter(allowedType, options),
 		});
 
 		const result: TreeStoredSchema = {
 			nodeSchema,
-			rootFieldSchema: convertField(normalized),
+			rootFieldSchema: convertField(normalized, options),
 		};
 		return result;
 	});
 }
 
-/**
- * Converts a {@link SimpleTreeSchema} into a {@link TreeStoredSchema}.
- */
-export function simpleToStoredSchema(root: SimpleTreeSchema): TreeStoredSchema {
-	const nodeSchema: Map<TreeNodeSchemaIdentifier, TreeNodeStoredSchema> = new Map();
-	for (const [identifier, schema] of root.definitions) {
-		nodeSchema.set(brand(identifier), getStoredSchema(schema));
-	}
-
-	const result: TreeStoredSchema = {
-		nodeSchema,
-		rootFieldSchema: convertField(root.root),
-	};
-	return result;
-}
-
 /**
  * Normalizes an {@link ImplicitFieldSchema} into a {@link TreeFieldSchema}.
  */
-export function convertField(schema: SimpleFieldSchema): TreeFieldStoredSchema {
+export function convertField(
+	schema: SimpleFieldSchema | FieldSchemaAlpha,
+	options: StoredSchemaGenerationOptions,
+): TreeFieldStoredSchema {
 	const kind: FieldKindIdentifier =
 		convertFieldKind.get(schema.kind)?.identifier ?? fail(0xae3 /* Invalid field kind */);
-	const types: TreeTypeSet = schema.allowedTypesIdentifiers as TreeTypeSet;
+	let types: TreeTypeSet;
+	// eslint-disable-next-line unicorn/prefer-ternary
+	if (schema instanceof FieldSchemaAlpha) {
+		types = convertAllowedTypes(schema.annotatedAllowedTypesNormalized, options);
+	} else {
+		types = schema.allowedTypesIdentifiers as TreeTypeSet;
+	}
 	return { kind, types, persistedMetadata: schema.persistedMetadata };
 }
 
@@ -110,12 +161,20 @@ export const convertFieldKind: ReadonlyMap<FieldKind, FlexFieldKind> = new Map<
  * Converts a {@link TreeNodeSchema} into a {@link TreeNodeStoredSchema}.
  * @privateRemarks
  * TODO: Persist node metadata once schema FormatV2 is supported.
+ *
+ * TODO: AB#43548: Using a stored schema for unhydrated flex trees does not handle schema evolution features like "allowUnknownOptionalFields".
+ * Usage of this and the conversion which wrap it should be audited and reduced.
  */
-export function getStoredSchema(schema: SimpleNodeSchema): TreeNodeStoredSchema {
+export function getStoredSchema(
+	schema: SimpleNodeSchema,
+	options: StoredSchemaGenerationOptions,
+): TreeNodeStoredSchema {
+	if (isClassBasedSchema(schema)) {
+		return getTreeNodeSchemaPrivateData(schema).toStored(options);
+	}
 	const kind = schema.kind;
 	switch (kind) {
 		case NodeKind.Leaf: {
-			assert(schema.kind === NodeKind.Leaf, 0xa4a /* invalid kind */);
 			return new LeafNodeStoredSchema(schema.leafKind);
 		}
 		case NodeKind.Map:
@@ -133,18 +192,12 @@ export function getStoredSchema(schema: SimpleNodeSchema): TreeNodeStoredSchema
 		}
 		case NodeKind.Array: {
 			const types = schema.allowedTypesIdentifiers as TreeTypeSet;
-			const field = {
-				kind: FieldKinds.sequence.identifier,
-				types,
-				persistedMetadata: schema.persistedMetadata,
-			};
-			const fields = new Map([[EmptyKey, field]]);
-			return new ObjectNodeStoredSchema(fields, schema.persistedMetadata);
+			return arrayNodeStoredSchema(types, schema.persistedMetadata);
 		}
 		case NodeKind.Object: {
 			const fields: Map<FieldKey, TreeFieldStoredSchema> = new Map();
 			for (const fieldSchema of schema.fields.values()) {
-				fields.set(brand(fieldSchema.storedKey), convertField(fieldSchema));
+				fields.set(brand(fieldSchema.storedKey), convertField(fieldSchema, options));
 			}
 			return new ObjectNodeStoredSchema(fields, schema.persistedMetadata);
 		}
@@ -153,3 +206,16 @@ export function getStoredSchema(schema: SimpleNodeSchema): TreeNodeStoredSchema
 		}
 	}
 }
+
+export function arrayNodeStoredSchema(
+	types: TreeTypeSet,
+	persistedMetadata: JsonCompatibleReadOnlyObject | undefined,
+): ObjectNodeStoredSchema {
+	const field = {
+		kind: FieldKinds.sequence.identifier,
+		types,
+		persistedMetadata,
+	};
+	const fields = new Map([[EmptyKey, field]]);
+	return new ObjectNodeStoredSchema(fields, persistedMetadata);
+}

package/src/simple-tree/unhydratedFlexTreeFromInsertable.ts

@@ -9,7 +9,11 @@ import { assert } from "@fluidframework/core-utils/internal";
 
 import { hasSingle } from "../util/index.js";
 
-import { type ImplicitFieldSchema, normalizeFieldSchema, FieldKind } from "./fieldSchema.js";
+import {
+	normalizeFieldSchema,
+	FieldKind,
+	type ImplicitAnnotatedFieldSchema,
+} from "./fieldSchema.js";
 import {
 	CompatibilityLevel,
 	getKernel,
@@ -50,7 +54,7 @@ import { getUnhydratedContext } from "./createContext.js";
  */
 export function unhydratedFlexTreeFromInsertable<TIn extends InsertableContent | undefined>(
 	data: TIn,
-	allowedTypes: ImplicitFieldSchema,
+	allowedTypes: ImplicitAnnotatedFieldSchema,
 ): TIn extends undefined ? undefined : UnhydratedFlexTreeNode {
 	const normalizedFieldSchema = normalizeFieldSchema(allowedTypes);
 

package/src/simple-tree/walkFieldSchema.ts

@@ -8,6 +8,7 @@ import { type ImplicitFieldSchema, normalizeFieldSchema } from "./fieldSchema.js
 
 /**
  * Traverses all {@link TreeNodeSchema} schema reachable from `schema`, applying the visitor pattern.
+ * @internal
  */
 export function walkFieldSchema(
 	schema: ImplicitFieldSchema,

package/dist/core/tree/detachedFieldIndexCodec.d.ts

@@ -1,11 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import type { IIdCompressor } from "@fluidframework/id-compressor";
-import { type ICodecOptions, type IJsonCodec } from "../../codec/index.js";
-import type { RevisionTagCodec } from "../rebase/index.js";
-import { Format } from "./detachedFieldIndexFormat.js";
-import type { DetachedFieldSummaryData } from "./detachedFieldIndexTypes.js";
-export declare function makeDetachedNodeToFieldCodec(revisionTagCodec: RevisionTagCodec, options: ICodecOptions, idCompressor: IIdCompressor): IJsonCodec<DetachedFieldSummaryData, Format>;
-//# sourceMappingURL=detachedFieldIndexCodec.d.ts.map

package/dist/core/tree/detachedFieldIndexCodec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"detachedFieldIndexCodec.d.ts","sourceRoot":"","sources":["../../../src/core/tree/detachedFieldIndexCodec.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,OAAO,EACN,KAAK,aAAa,EAClB,KAAK,UAAU,EAEf,MAAM,sBAAsB,CAAC;AAE9B,OAAO,KAAK,EAAsB,gBAAgB,EAAe,MAAM,oBAAoB,CAAC;AAE5F,OAAO,EAEN,MAAM,EAGN,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAEX,wBAAwB,EAExB,MAAM,8BAA8B,CAAC;AA6CtC,wBAAgB,4BAA4B,CAC3C,gBAAgB,EAAE,gBAAgB,EAClC,OAAO,EAAE,aAAa,EACtB,YAAY,EAAE,aAAa,GACzB,UAAU,CAAC,wBAAwB,EAAE,MAAM,CAAC,CAkD9C"}

package/dist/core/tree/detachedFieldIndexCodec.js

@@ -1,100 +0,0 @@
-"use strict";
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeDetachedNodeToFieldCodec = void 0;
-const internal_1 = require("@fluidframework/core-utils/internal");
-const index_js_1 = require("../../codec/index.js");
-const index_js_2 = require("../../util/index.js");
-const detachedFieldIndexFormat_js_1 = require("./detachedFieldIndexFormat.js");
-class MajorCodec {
-    constructor(revisionTagCodec, options, idCompressor) {
-        this.revisionTagCodec = revisionTagCodec;
-        this.options = options;
-        this.idCompressor = idCompressor;
-    }
-    encode(major) {
-        (0, internal_1.assert)(major !== undefined, 0x88e /* Unexpected undefined revision */);
-        const id = this.revisionTagCodec.encode(major);
-        /**
-         * Preface: this codec is only used at summarization time (not for ops).
-         * Note that the decode path must provide a session id in which to interpret the revision tag.
-         * The revision associated with a detached root generally comes from the session which detaches that subtree,
-         * which isn't generally the local session (nor is it available at decode time with the layering of the tree
-         * package), despite decode using the local session id.
-         *
-         * This is made OK by enforcing that all ids on encode/decode are non-local, since local ids won't be interpretable
-         * at decode time.
-         * This assert is valid because the revision for an acked edit will have already been finalized, and a revision
-         * for a local-only edit will be finalizable at summarization time (local edits can only occur on a summarizing client
-         * if they're created while detached, and local ids made while detached are finalized before generating the attach summary).
-         */
-        (0, internal_1.assert)(id === "root" || id >= 0, 0x88f /* Expected final id on encode of detached field index revision */);
-        return id;
-    }
-    decode(major) {
-        (0, internal_1.assert)(major === "root" || major >= 0, 0x890 /* Expected final id on decode of detached field index revision */);
-        return this.revisionTagCodec.decode(major, {
-            originatorId: this.revisionTagCodec.localSessionId,
-            idCompressor: this.idCompressor,
-            revision: undefined,
-        });
-    }
-}
-function makeDetachedNodeToFieldCodec(revisionTagCodec, options, idCompressor) {
-    const majorCodec = new MajorCodec(revisionTagCodec, options, idCompressor);
-    return (0, index_js_1.makeVersionedValidatedCodec)(options, new Set([detachedFieldIndexFormat_js_1.version]), detachedFieldIndexFormat_js_1.Format, {
-        encode: (data) => {
-            const rootsForRevisions = [];
-            for (const [major, innerMap] of data.data) {
-                const encodedRevision = majorCodec.encode(major);
-                const rootRanges = [];
-                for (const [minor, detachedField] of innerMap) {
-                    rootRanges.push([minor, detachedField.root]);
-                }
-                if ((0, index_js_2.hasSingle)(rootRanges)) {
-                    const firstRootRange = rootRanges[0];
-                    const rootsForRevision = [
-                        encodedRevision,
-                        firstRootRange[0],
-                        firstRootRange[1],
-                    ];
-                    rootsForRevisions.push(rootsForRevision);
-                }
-                else {
-                    const rootsForRevision = [encodedRevision, rootRanges];
-                    rootsForRevisions.push(rootsForRevision);
-                }
-            }
-            const encoded = {
-                version: detachedFieldIndexFormat_js_1.version,
-                data: rootsForRevisions,
-                maxId: data.maxId,
-            };
-            return encoded;
-        },
-        decode: (parsed) => {
-            const map = new Map();
-            for (const rootsForRevision of parsed.data) {
-                const innerMap = new Map();
-                if (rootsForRevision.length === 2) {
-                    for (const [minor, root] of rootsForRevision[1]) {
-                        innerMap.set(minor, { root });
-                    }
-                }
-                else {
-                    innerMap.set(rootsForRevision[1], { root: rootsForRevision[2] });
-                }
-                map.set(majorCodec.decode(rootsForRevision[0]), innerMap);
-            }
-            return {
-                data: map,
-                maxId: parsed.maxId,
-            };
-        },
-    });
-}
-exports.makeDetachedNodeToFieldCodec = makeDetachedNodeToFieldCodec;
-//# sourceMappingURL=detachedFieldIndexCodec.js.map

package/dist/core/tree/detachedFieldIndexCodec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"detachedFieldIndexCodec.js","sourceRoot":"","sources":["../../../src/core/tree/detachedFieldIndexCodec.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert } from \"@fluidframework/core-utils/internal\";\nimport type { IIdCompressor } from \"@fluidframework/id-compressor\";\n\nimport {\n\ttype ICodecOptions,\n\ttype IJsonCodec,\n\tmakeVersionedValidatedCodec,\n} from \"../../codec/index.js\";\nimport { hasSingle } from \"../../util/index.js\";\nimport type { EncodedRevisionTag, RevisionTagCodec, RevisionTag } from \"../rebase/index.js\";\n\nimport {\n\ttype EncodedRootsForRevision,\n\tFormat,\n\ttype RootRanges,\n\tversion,\n} from \"./detachedFieldIndexFormat.js\";\nimport type {\n\tDetachedField,\n\tDetachedFieldSummaryData,\n\tMajor,\n} from \"./detachedFieldIndexTypes.js\";\n\nclass MajorCodec implements IJsonCodec<Major> {\n\tpublic constructor(\n\t\tprivate readonly revisionTagCodec: RevisionTagCodec,\n\t\tprivate readonly options: ICodecOptions,\n\t\tprivate readonly idCompressor: IIdCompressor,\n\t) {}\n\n\tpublic encode(major: Major): EncodedRevisionTag {\n\t\tassert(major !== undefined, 0x88e /* Unexpected undefined revision */);\n\t\tconst id = this.revisionTagCodec.encode(major);\n\t\t/**\n\t\t * Preface: this codec is only used at summarization time (not for ops).\n\t\t * Note that the decode path must provide a session id in which to interpret the revision tag.\n\t\t * The revision associated with a detached root generally comes from the session which detaches that subtree,\n\t\t * which isn't generally the local session (nor is it available at decode time with the layering of the tree\n\t\t * package), despite decode using the local session id.\n\t\t *\n\t\t * This is made OK by enforcing that all ids on encode/decode are non-local, since local ids won't be interpretable\n\t\t * at decode time.\n\t\t * This assert is valid because the revision for an acked edit will have already been finalized, and a revision\n\t\t * for a local-only edit will be finalizable at summarization time (local edits can only occur on a summarizing client\n\t\t * if they're created while detached, and local ids made while detached are finalized before generating the attach summary).\n\t\t */\n\t\tassert(\n\t\t\tid === \"root\" || id >= 0,\n\t\t\t0x88f /* Expected final id on encode of detached field index revision */,\n\t\t);\n\t\treturn id;\n\t}\n\n\tpublic decode(major: EncodedRevisionTag): RevisionTag {\n\t\tassert(\n\t\t\tmajor === \"root\" || major >= 0,\n\t\t\t0x890 /* Expected final id on decode of detached field index revision */,\n\t\t);\n\t\treturn this.revisionTagCodec.decode(major, {\n\t\t\toriginatorId: this.revisionTagCodec.localSessionId,\n\t\t\tidCompressor: this.idCompressor,\n\t\t\trevision: undefined,\n\t\t});\n\t}\n}\n\nexport function makeDetachedNodeToFieldCodec(\n\trevisionTagCodec: RevisionTagCodec,\n\toptions: ICodecOptions,\n\tidCompressor: IIdCompressor,\n): IJsonCodec<DetachedFieldSummaryData, Format> {\n\tconst majorCodec = new MajorCodec(revisionTagCodec, options, idCompressor);\n\treturn makeVersionedValidatedCodec(options, new Set([version]), Format, {\n\t\tencode: (data: DetachedFieldSummaryData): Format => {\n\t\t\tconst rootsForRevisions: EncodedRootsForRevision[] = [];\n\t\t\tfor (const [major, innerMap] of data.data) {\n\t\t\t\tconst encodedRevision = majorCodec.encode(major);\n\t\t\t\tconst rootRanges: RootRanges = [];\n\t\t\t\tfor (const [minor, detachedField] of innerMap) {\n\t\t\t\t\trootRanges.push([minor, detachedField.root]);\n\t\t\t\t}\n\t\t\t\tif (hasSingle(rootRanges)) {\n\t\t\t\t\tconst firstRootRange = rootRanges[0];\n\t\t\t\t\tconst rootsForRevision: EncodedRootsForRevision = [\n\t\t\t\t\t\tencodedRevision,\n\t\t\t\t\t\tfirstRootRange[0],\n\t\t\t\t\t\tfirstRootRange[1],\n\t\t\t\t\t];\n\t\t\t\t\trootsForRevisions.push(rootsForRevision);\n\t\t\t\t} else {\n\t\t\t\t\tconst rootsForRevision: EncodedRootsForRevision = [encodedRevision, rootRanges];\n\t\t\t\t\trootsForRevisions.push(rootsForRevision);\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst encoded: Format = {\n\t\t\t\tversion,\n\t\t\t\tdata: rootsForRevisions,\n\t\t\t\tmaxId: data.maxId,\n\t\t\t};\n\t\t\treturn encoded;\n\t\t},\n\t\tdecode: (parsed: Format): DetachedFieldSummaryData => {\n\t\t\tconst map = new Map();\n\t\t\tfor (const rootsForRevision of parsed.data) {\n\t\t\t\tconst innerMap = new Map<number, DetachedField>();\n\t\t\t\tif (rootsForRevision.length === 2) {\n\t\t\t\t\tfor (const [minor, root] of rootsForRevision[1]) {\n\t\t\t\t\t\tinnerMap.set(minor, { root });\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tinnerMap.set(rootsForRevision[1], { root: rootsForRevision[2] });\n\t\t\t\t}\n\t\t\t\tmap.set(majorCodec.decode(rootsForRevision[0]), innerMap);\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tdata: map,\n\t\t\t\tmaxId: parsed.maxId,\n\t\t\t};\n\t\t},\n\t});\n}\n"]}

package/dist/core/tree/detachedFieldIndexFormat.d.ts

@@ -1,33 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { type Static } from "@sinclair/typebox";
-import type { ForestRootId } from "./detachedFieldIndexTypes.js";
-export declare const version = 1;
-/**
- * The ID of a detached node. Is not globally unique on.
- * A `RevisionTag` + `DetachId` pair is globally unique and eventually consistent across clients.
- */
-export declare const DetachId: import("@sinclair/typebox").TNumber;
-/**
- * A mapping from a range of the detached node IDs the corresponding range root IDs.
- * The detached node IDs need to be qualified with a revision (stored in the containing `EncodedRootsForRevision`).
- * Note: the length of the range (currently always 1) can be looked up in the forest.
- */
-export declare const RootRange: import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TUnsafe<ForestRootId>]>;
-export type RootRange = Static<typeof RootRange>;
-export declare const RootRanges: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TUnsafe<ForestRootId>]>>;
-export type RootRanges = Static<typeof RootRanges>;
-/**
- * For all the roots detached in a revision, represents a mapping from the detached node ID to corresponding root ID.
- */
-export declare const EncodedRootsForRevision: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"root">, import("@sinclair/typebox").TUnsafe<import("../../util/brand.js").Brand<import("@fluidframework/id-compressor").OpSpaceCompressedId, "EncodedRevisionTag">>]>, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TUnsafe<ForestRootId>]>>]>, import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"root">, import("@sinclair/typebox").TUnsafe<import("../../util/brand.js").Brand<import("@fluidframework/id-compressor").OpSpaceCompressedId, "EncodedRevisionTag">>]>, import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TUnsafe<ForestRootId>]>]>;
-export type EncodedRootsForRevision = Static<typeof EncodedRootsForRevision>;
-export declare const Format: import("@sinclair/typebox").TObject<{
-    version: import("@sinclair/typebox").TLiteral<1>;
-    data: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"root">, import("@sinclair/typebox").TUnsafe<import("../../util/brand.js").Brand<import("@fluidframework/id-compressor").OpSpaceCompressedId, "EncodedRevisionTag">>]>, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TUnsafe<ForestRootId>]>>]>, import("@sinclair/typebox").TTuple<[import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"root">, import("@sinclair/typebox").TUnsafe<import("../../util/brand.js").Brand<import("@fluidframework/id-compressor").OpSpaceCompressedId, "EncodedRevisionTag">>]>, import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TUnsafe<ForestRootId>]>]>>;
-    maxId: import("@sinclair/typebox").TUnsafe<ForestRootId>;
-}>;
-export type Format = Static<typeof Format>;
-//# sourceMappingURL=detachedFieldIndexFormat.d.ts.map

package/dist/core/tree/detachedFieldIndexFormat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"detachedFieldIndexFormat.d.ts","sourceRoot":"","sources":["../../../src/core/tree/detachedFieldIndexFormat.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAQ,MAAM,mBAAmB,CAAC;AAKtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,eAAO,MAAM,OAAO,IAAM,CAAC;AAE3B;;;GAGG;AACH,eAAO,MAAM,QAAQ,qCAAiC,CAAC;AAQvD;;;;GAIG;AACH,eAAO,MAAM,SAAS,8HAKpB,CAAC;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,SAAS,CAAC,CAAC;AAEjD,eAAO,MAAM,UAAU,kKAAwB,CAAC;AAChD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,CAAC;AAEnD;;GAEG;AACH,eAAO,MAAM,uBAAuB,80BAKlC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE7E,eAAO,MAAM,MAAM;;;;EAOlB,CAAC;AAEF,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,MAAM,CAAC,CAAC"}

package/dist/core/tree/detachedFieldIndexFormat.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"detachedFieldIndexFormat.js","sourceRoot":"","sources":["../../../src/core/tree/detachedFieldIndexFormat.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+CAAsD;AAEtD,kDAAwD;AACxD,iDAAuD;AAI1C,QAAA,OAAO,GAAG,GAAG,CAAC;AAE3B;;;GAGG;AACU,QAAA,QAAQ,GAAG,cAAI,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,CAAC;AAEvD;;;GAGG;AACH,MAAM,kBAAkB,GAAG,IAAA,4BAAiB,EAAe,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,CAAC;AAE3F;;;;GAIG;AACU,QAAA,SAAS,GAAG,cAAI,CAAC,KAAK,CAAC;IACnC,iCAAiC;IACjC,gBAAQ;IACR,6BAA6B;IAC7B,kBAAkB;CAClB,CAAC,CAAC;AAGU,QAAA,UAAU,GAAG,cAAI,CAAC,KAAK,CAAC,iBAAS,CAAC,CAAC;AAGhD;;GAEG;AACU,QAAA,uBAAuB,GAAG,cAAI,CAAC,KAAK,CAAC;IACjD,yEAAyE;IACzE,cAAI,CAAC,KAAK,CAAC,CAAC,4BAAiB,EAAE,kBAAU,CAAC,CAAC;IAC3C,mEAAmE;IACnE,cAAI,CAAC,KAAK,CAAC,CAAC,4BAAiB,EAAE,gBAAQ,EAAE,kBAAkB,CAAC,CAAC;CAC7D,CAAC,CAAC;AAGU,QAAA,MAAM,GAAG,cAAI,CAAC,MAAM,CAChC;IACC,OAAO,EAAE,cAAI,CAAC,OAAO,CAAC,eAAO,CAAC;IAC9B,IAAI,EAAE,cAAI,CAAC,KAAK,CAAC,+BAAuB,CAAC;IACzC,KAAK,EAAE,kBAAkB;CACzB,EACD,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAC/B,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { type Static, Type } from \"@sinclair/typebox\";\n\nimport { brandedNumberType } from \"../../util/index.js\";\nimport { RevisionTagSchema } from \"../rebase/index.js\";\n\nimport type { ForestRootId } from \"./detachedFieldIndexTypes.js\";\n\nexport const version = 1.0;\n\n/**\n * The ID of a detached node. Is not globally unique on.\n * A `RevisionTag` + `DetachId` pair is globally unique and eventually consistent across clients.\n */\nexport const DetachId = Type.Number({ multipleOf: 1 });\n\n/**\n * The ID of a root node in the forest associated with the owning checkout. Is unique for that forest.\n * Is not consistent across clients.\n */\nconst ForestRootIdSchema = brandedNumberType<ForestRootId>({ minimum: -1, multipleOf: 1 });\n\n/**\n * A mapping from a range of the detached node IDs the corresponding range root IDs.\n * The detached node IDs need to be qualified with a revision (stored in the containing `EncodedRootsForRevision`).\n * Note: the length of the range (currently always 1) can be looked up in the forest.\n */\nexport const RootRange = Type.Tuple([\n\t// ID for the first detached node\n\tDetachId,\n\t// ID for the first root node\n\tForestRootIdSchema,\n]);\nexport type RootRange = Static<typeof RootRange>;\n\nexport const RootRanges = Type.Array(RootRange);\nexport type RootRanges = Static<typeof RootRanges>;\n\n/**\n * For all the roots detached in a revision, represents a mapping from the detached node ID to corresponding root ID.\n */\nexport const EncodedRootsForRevision = Type.Union([\n\t// Used to represent a revision in which more than one node were detached\n\tType.Tuple([RevisionTagSchema, RootRanges]),\n\t// Used to represent a revision in which a single node was detached\n\tType.Tuple([RevisionTagSchema, DetachId, ForestRootIdSchema]),\n]);\nexport type EncodedRootsForRevision = Static<typeof EncodedRootsForRevision>;\n\nexport const Format = Type.Object(\n\t{\n\t\tversion: Type.Literal(version),\n\t\tdata: Type.Array(EncodedRootsForRevision),\n\t\tmaxId: ForestRootIdSchema,\n\t},\n\t{ additionalProperties: false },\n);\n\nexport type Format = Static<typeof Format>;\n"]}

package/dist/feature-libraries/chunked-forest/codec/nodeShape.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodeShape.d.ts","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/nodeShape.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,EAEN,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAG7B,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC5E,OAAO,EAAE,KAAK,YAAY,EAAmB,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACtF,OAAO,EACN,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAEhB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAE3F,qBAAa,SAAU,SAAQ,KAAK,CAAC,iBAAiB,CAAE,YAAW,WAAW;aAQ5D,IAAI,EAAE,SAAS,GAAG,wBAAwB;aAC1C,KAAK,EAAE,iBAAiB;IACxC;;;;;;;;;;OAUG;aACa,wBAAwB,EAAE,SAAS,iBAAiB,EAAE;IACtE;;;OAGG;aACa,kBAAkB,EAAE,SAAS,GAAG,YAAY;IAzB7D;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAgB;gBAGpC,IAAI,EAAE,SAAS,GAAG,wBAAwB,EAC1C,KAAK,EAAE,iBAAiB;IACxC;;;;;;;;;;OAUG;IACa,wBAAwB,EAAE,SAAS,iBAAiB,EAAE;IACtE;;;OAGG;IACa,kBAAkB,EAAE,SAAS,GAAG,YAAY;IAM7D,OAAO,CAAC,gBAAgB;IAajB,UAAU,CAChB,MAAM,EAAE,sBAAsB,EAC9B,KAAK,EAAE,YAAY,EACnB,YAAY,EAAE,YAAY,CAAC,iBAAiB,CAAC,GAC3C,IAAI;IAgCA,WAAW,CACjB,WAAW,EAAE,kBAAkB,CAAC,MAAM,CAAC,EACvC,MAAM,EAAE,kBAAkB,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,GAClD,iBAAiB;IAWb,mCAAmC,CACzC,WAAW,EAAE,OAAO,CAAC,MAAM,CAAC,EAC5B,eAAe,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,iBAAiB,CAAC,KAAK,IAAI,GACxD,IAAI;IAeP,IAAW,KAAK,IAAI,SAAS,CAE5B;CACD;AAED,wBAAgB,iBAAiB,CAChC,aAAa,EAAE,SAAS,iBAAiB,EAAE,EAC3C,WAAW,EAAE,kBAAkB,CAAC,MAAM,CAAC,EACvC,MAAM,EAAE,kBAAkB,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,GAClD,iBAAiB,EAAE,GAAG,SAAS,CAUjC"}

package/dist/feature-libraries/chunked-forest/codec/nodeShape.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nodeShape.js","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/nodeShape.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { assert, fail } from \"@fluidframework/core-utils/internal\";\nimport { isStableId } from \"@fluidframework/id-compressor/internal\";\n\nimport {\n\ttype FieldKey,\n\ttype ITreeCursorSynchronous,\n\ttype TreeNodeSchemaIdentifier,\n\tforEachField,\n\ttype Value,\n} from \"../../../core/index.js\";\nimport { brand } from \"../../../util/index.js\";\n\nimport type { Counter, DeduplicationTable } from \"./chunkCodecUtilities.js\";\nimport { type BufferFormat, IdentifierToken, Shape } from \"./chunkEncodingGeneric.js\";\nimport {\n\ttype EncoderCache,\n\ttype FieldEncoder,\n\ttype KeyedFieldEncoder,\n\ttype NodeEncoder,\n\tencodeValue,\n} from \"./compressedEncode.js\";\nimport type { EncodedChunkShape, EncodedFieldShape, EncodedValueShape } from \"./format.js\";\n\nexport class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {\n\t/**\n\t * Set of keys for fields that are encoded using {@link NodeShape.specializedFieldEncoders}.\n\t * TODO: Ensure uniform chunks, encoding and identifier generation sort fields the same.\n\t */\n\tprivate readonly specializedFieldKeys: Set<FieldKey>;\n\n\tpublic constructor(\n\t\tpublic readonly type: undefined | TreeNodeSchemaIdentifier,\n\t\tpublic readonly value: EncodedValueShape,\n\t\t/**\n\t\t * Encoders for a specific set of fields, by key, in the order they will be encoded.\n\t\t * These are fields for which specialized encoding is provided as an optimization.\n\t\t * Using these for a given field instead of falling back to {@link NodeShape.specializedFieldEncoders} is often more efficient:\n\t\t * this avoids the need to explicitly include the key and shape in the encoded data for each node instance.\n\t\t * Instead, this information is here, and thus is encoded only once as part of the node shape.\n\t\t * These encoders will be used, even if the field they apply to is empty (which can add overhead for fields which are usually empty).\n\t\t *\n\t\t * Any fields not included here will be encoded using {@link NodeShape.otherFieldsEncoder}.\n\t\t * If {@link NodeShape.otherFieldsEncoder} is undefined, then this must handle all non-empty fields.\n\t\t */\n\t\tpublic readonly specializedFieldEncoders: readonly KeyedFieldEncoder[],\n\t\t/**\n\t\t * Encoder for all other fields that are not in {@link NodeShape.specializedFieldEncoders}. These fields must\n\t\t * be encoded after the specialized fields.\n\t\t */\n\t\tpublic readonly otherFieldsEncoder: undefined | FieldEncoder,\n\t) {\n\t\tsuper();\n\t\tthis.specializedFieldKeys = new Set(this.specializedFieldEncoders.map((f) => f.key));\n\t}\n\n\tprivate getValueToEncode(cursor: ITreeCursorSynchronous, cache: EncoderCache): Value {\n\t\tif (this.value === 0) {\n\t\t\tassert(typeof cursor.value === \"string\", 0x9aa /* identifier must be type string */);\n\t\t\tif (isStableId(cursor.value)) {\n\t\t\t\tconst sessionSpaceCompressedId = cache.idCompressor.tryRecompress(cursor.value);\n\t\t\t\tif (sessionSpaceCompressedId !== undefined) {\n\t\t\t\t\treturn cache.idCompressor.normalizeToOpSpace(sessionSpaceCompressedId);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn cursor.value;\n\t}\n\n\tpublic encodeNode(\n\t\tcursor: ITreeCursorSynchronous,\n\t\tcache: EncoderCache,\n\t\toutputBuffer: BufferFormat<EncodedChunkShape>,\n\t): void {\n\t\tif (this.type === undefined) {\n\t\t\toutputBuffer.push(new IdentifierToken(cursor.type));\n\t\t} else {\n\t\t\tassert(cursor.type === this.type, 0x741 /* type must match shape */);\n\t\t}\n\t\tencodeValue(this.getValueToEncode(cursor, cache), this.value, outputBuffer);\n\t\tfor (const fieldEncoder of this.specializedFieldEncoders) {\n\t\t\tcursor.enterField(brand(fieldEncoder.key));\n\t\t\tfieldEncoder.encoder.encodeField(cursor, cache, outputBuffer);\n\t\t\tcursor.exitField();\n\t\t}\n\n\t\tconst otherFieldsBuffer: BufferFormat<EncodedChunkShape> = [];\n\n\t\tforEachField(cursor, () => {\n\t\t\tconst key = cursor.getFieldKey();\n\t\t\tif (!this.specializedFieldKeys.has(key)) {\n\t\t\t\tassert(\n\t\t\t\t\tthis.otherFieldsEncoder !== undefined,\n\t\t\t\t\t0x742 /* had extra local fields when shape does not support them */,\n\t\t\t\t);\n\t\t\t\totherFieldsBuffer.push(new IdentifierToken(key));\n\t\t\t\tthis.otherFieldsEncoder.encodeField(cursor, cache, otherFieldsBuffer);\n\t\t\t}\n\t\t});\n\n\t\tif (this.otherFieldsEncoder !== undefined) {\n\t\t\toutputBuffer.push(otherFieldsBuffer);\n\t\t}\n\t}\n\n\tpublic encodeShape(\n\t\tidentifiers: DeduplicationTable<string>,\n\t\tshapes: DeduplicationTable<Shape<EncodedChunkShape>>,\n\t): EncodedChunkShape {\n\t\treturn {\n\t\t\tc: {\n\t\t\t\ttype: encodeOptionalIdentifier(this.type, identifiers),\n\t\t\t\tvalue: this.value,\n\t\t\t\tfields: encodeFieldShapes(this.specializedFieldEncoders, identifiers, shapes),\n\t\t\t\textraFields: encodeOptionalFieldShape(this.otherFieldsEncoder, shapes),\n\t\t\t},\n\t\t};\n\t}\n\n\tpublic countReferencedShapesAndIdentifiers(\n\t\tidentifiers: Counter<string>,\n\t\tshapeDiscovered: (shape: Shape<EncodedChunkShape>) => void,\n\t): void {\n\t\tif (this.type !== undefined) {\n\t\t\tidentifiers.add(this.type);\n\t\t}\n\n\t\tfor (const fieldEncoder of this.specializedFieldEncoders) {\n\t\t\tidentifiers.add(fieldEncoder.key);\n\t\t\tshapeDiscovered(fieldEncoder.encoder.shape);\n\t\t}\n\n\t\tif (this.otherFieldsEncoder !== undefined) {\n\t\t\tshapeDiscovered(this.otherFieldsEncoder.shape);\n\t\t}\n\t}\n\n\tpublic get shape(): NodeShape {\n\t\treturn this;\n\t}\n}\n\nexport function encodeFieldShapes(\n\tfieldEncoders: readonly KeyedFieldEncoder[],\n\tidentifiers: DeduplicationTable<string>,\n\tshapes: DeduplicationTable<Shape<EncodedChunkShape>>,\n): EncodedFieldShape[] | undefined {\n\tif (fieldEncoders.length === 0) {\n\t\treturn undefined;\n\t}\n\treturn fieldEncoders.map((fieldEncoder) => [\n\t\t// key\n\t\tencodeIdentifier(fieldEncoder.key, identifiers),\n\t\t// shape\n\t\tshapes.valueToIndex.get(fieldEncoder.encoder.shape) ?? fail(0xb50 /* missing shape */),\n\t]);\n}\n\nfunction encodeIdentifier(\n\tidentifier: string,\n\tidentifiers: DeduplicationTable<string>,\n): string | number {\n\treturn identifiers.valueToIndex.get(identifier) ?? identifier;\n}\n\nfunction encodeOptionalIdentifier(\n\tidentifier: string | undefined,\n\tidentifiers: DeduplicationTable<string>,\n): string | number | undefined {\n\treturn identifier === undefined ? undefined : encodeIdentifier(identifier, identifiers);\n}\n\nfunction encodeOptionalFieldShape(\n\tshape: FieldEncoder | undefined,\n\tshapes: DeduplicationTable<Shape<EncodedChunkShape>>,\n): number | undefined {\n\treturn shape === undefined ? undefined : dedupShape(shape.shape, shapes);\n}\n\nfunction dedupShape(\n\tshape: Shape<EncodedChunkShape>,\n\tshapes: DeduplicationTable<Shape<EncodedChunkShape>>,\n): number {\n\treturn shapes.valueToIndex.get(shape) ?? fail(0xb51 /* missing shape */);\n}\n"]}