@fluidframework/tree 2.111.0 → 2.112.0

package/dist/componentApi.js

@@ -0,0 +1,138 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Component = void 0;
+const internal_1 = require("@fluidframework/telemetry-utils/internal");
+const index_js_1 = require("./util/index.js");
+/**
+ * Utilities for composing application "components" which contribute to a shared configuration.
+ *
+ * @remarks
+ * Nothing in this namespace is specific to tree schema,
+ * however it is designed to be able to handle the needs of components which work with {@link TreeSchema}.
+ *
+ * This is mainly used to implement "open polymorphism", where the set of allowed types
+ * for a field or collection can be extended by independently authored libraries (components) instead of being
+ * fixed up front.
+ *
+ * This basically amounts to dependency injection, where the "injection" is done at "composition" time to build the schema.
+ *
+ * Tree's schema do not natively support open polymorphism: all possible implementations must be explicitly listed.
+ * These tools work around these limitations by carefully controlling evaluation order:
+ * the source code can be structured in an open polymorphism style which at runtime evaluates into closed polymorphism
+ * by having each component register its implementations into a central collection (typically an
+ * {@link AllowedTypes} array).
+ *
+ * Each component is expressed as a {@link Component.Factory}: a function which receives a lazy reference to the
+ * composed configuration and returns the content that component contributes.
+ * Because the configuration is provided lazily, components may reference (including recursively) types contributed by
+ * other components, as long as nothing evaluates the lazy references until composition has completed.
+ * Use {@link Component.(compose:1)} to combine a set of components into a {@link Component.Composed}.
+ *
+ * See {@link https://github.com/microsoft/FluidFramework/blob/main/packages/dds/tree/src/test/openPolymorphism.integration.ts|openPolymorphism.integration.ts} for worked examples of this pattern.
+ *
+ * @privateRemarks
+ * The examples and integration tests for this pattern live in `openPolymorphism.integration.ts`.
+ * Those tests and the docs here should be kept in sync.
+ *
+ * @alpha
+ */
+var Component;
+(function (Component) {
+    /**
+     * Wrap a 0 argument function to cache the result.
+     * @remarks
+     * Do not use for impure functions.
+     *
+     * Generally {@link Component} utilities have built in caching in most cases,
+     * but this is occasionally helpful when manually implementing laziness.
+     *
+     * Note that this takes a different approach than use in {@link evaluateLazySchema} where the function evaluation is done using a utility that adds caching.
+     *
+     * @param factory - The factory function to memoize.
+     * @returns A function that returns the cached result of the factory.
+     * @alpha
+     */
+    Component.memoize = (factory) => {
+        let run = false;
+        let cached;
+        return () => {
+            if (!run) {
+                cached = factory();
+                run = true;
+            }
+            return cached;
+        };
+    };
+    /**
+     * Implementation of {@link Component.Composed}.
+     */
+    class Config {
+        constructor(allComponents, lazyConfiguration) {
+            /**
+             * Cache of results produced by {@link Component.Composed.getConfigured}.
+             *
+             * @remarks
+             * Maps each {@link Component.Configurable} to the result of evaluating it against this composition.
+             * This ensures a given `Configurable` is only configured once: subsequent lookups return the cached result.
+             */
+            this.evaluatedMap = new Map();
+            /**
+             * Cache of results produced by {@link Component.Composed.getComposed}.
+             *
+             * @remarks
+             * Maps each composed property to the array produced for it.
+             * This ensures a given property is only composed once: subsequent lookups return the same array
+             * (including the same lazy values), so repeated calls with the same property are reference-stable.
+             */
+            this.composedMap = new Map();
+            // eslint-disable-next-line no-undef-init -- Explicitly undefined: `config` is populated below, after all components have been constructed, and is read lazily via `lazyConfigInner`.
+            let config = undefined;
+            const lazyConfigInner = () => {
+                if (config === undefined) {
+                    throw new internal_1.UsageError("Configuration not yet available: components must not evaluate the lazy configuration during composition.");
+                }
+                return config;
+            };
+            this.componentsMap = new Map(allComponents.map((c) => [c, c(lazyConfigInner)]));
+            this.components = [...this.componentsMap.values()];
+            config = lazyConfiguration(this);
+            this.config = config;
+        }
+        getComponent(factory) {
+            const found = this.componentsMap.get(factory);
+            if (found === undefined) {
+                throw new internal_1.UsageError("Requested component not included in this configuration");
+            }
+            return found;
+        }
+        getConfigured(configurable) {
+            const configured = (0, index_js_1.getOrCreate)(this.evaluatedMap, configurable, (c) => {
+                const result = c.configure(this.config, this);
+                if (result === undefined) {
+                    throw new internal_1.UsageError("Configurable must not return undefined");
+                }
+                return result;
+            });
+            return configured;
+        }
+        getComposed(property) {
+            const result = (0, index_js_1.getOrCreate)(this.composedMap, property, () => this.components.flatMap((c) => {
+                const prop = c[property];
+                if (prop === undefined) {
+                    return [];
+                }
+                return prop();
+            }));
+            return result;
+        }
+    }
+    function compose(allComponents, lazyConfiguration = (composed) => composed) {
+        return new Config(allComponents, lazyConfiguration);
+    }
+    Component.compose = compose;
+})(Component || (exports.Component = Component = {}));
+//# sourceMappingURL=componentApi.js.map

package/dist/componentApi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentApi.js","sourceRoot":"","sources":["../src/componentApi.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 { UsageError } from \"@fluidframework/telemetry-utils/internal\";\n\nimport { getOrCreate } from \"./util/index.js\";\n\n/**\n * Utilities for composing application \"components\" which contribute to a shared configuration.\n *\n * @remarks\n * Nothing in this namespace is specific to tree schema,\n * however it is designed to be able to handle the needs of components which work with {@link TreeSchema}.\n *\n * This is mainly used to implement \"open polymorphism\", where the set of allowed types\n * for a field or collection can be extended by independently authored libraries (components) instead of being\n * fixed up front.\n *\n * This basically amounts to dependency injection, where the \"injection\" is done at \"composition\" time to build the schema.\n *\n * Tree's schema do not natively support open polymorphism: all possible implementations must be explicitly listed.\n * These tools work around these limitations by carefully controlling evaluation order:\n * the source code can be structured in an open polymorphism style which at runtime evaluates into closed polymorphism\n * by having each component register its implementations into a central collection (typically an\n * {@link AllowedTypes} array).\n *\n * Each component is expressed as a {@link Component.Factory}: a function which receives a lazy reference to the\n * composed configuration and returns the content that component contributes.\n * Because the configuration is provided lazily, components may reference (including recursively) types contributed by\n * other components, as long as nothing evaluates the lazy references until composition has completed.\n * Use {@link Component.(compose:1)} to combine a set of components into a {@link Component.Composed}.\n *\n * See {@link https://github.com/microsoft/FluidFramework/blob/main/packages/dds/tree/src/test/openPolymorphism.integration.ts|openPolymorphism.integration.ts} for worked examples of this pattern.\n *\n * @privateRemarks\n * The examples and integration tests for this pattern live in `openPolymorphism.integration.ts`.\n * Those tests and the docs here should be kept in sync.\n *\n * @alpha\n */\nexport namespace Component {\n\t/**\n\t * A function which takes in a lazy configuration and returns the content a component contributes.\n\t *\n\t * @remarks\n\t * The lazy configuration allows the component to reference items from the composed configuration, which can\n\t * include items the component itself contributes (allowing recursive references between components).\n\t *\n\t * The execution of the factory must not evaluate `lazyConfiguration` (doing so will error):\n\t * instead the returned `TComponent` can capture `lazyConfiguration` and evaluate it at a later time\n\t * (after all components have been composed).\n\t *\n\t * @typeParam TComponent - The content a component contributes.\n\t * @typeParam TConfig - The composed configuration type made available to components.\n\t * Defaults to the {@link Component.Composed} produced by composition: the common case where\n\t * components read composed content directly from the composition and no custom configuration type is needed.\n\t *\n\t * @input\n\t * @alpha\n\t */\n\texport type Factory<TComponent, TConfig = ComposedDefault<TComponent>> = (\n\t\tlazyConfiguration: () => TConfig,\n\t) => TComponent;\n\n\t/**\n\t * A function which returns an array of lazy values which each evaluate to `T`.\n\t *\n\t * @remarks\n\t * This mirrors the shape of {@link AllowedTypes} where all of the values are lazy:\n\t * the outer function and inner functions defer evaluation until after composition is complete.\n\t *\n\t * @typeParam T - The type each lazy value evaluates to.\n\t *\n\t * @alpha\n\t */\n\texport type LazyArray<T> = () => readonly (() => T)[];\n\n\t/**\n\t * Wrap a 0 argument function to cache the result.\n\t * @remarks\n\t * Do not use for impure functions.\n\t *\n\t * Generally {@link Component} utilities have built in caching in most cases,\n\t * but this is occasionally helpful when manually implementing laziness.\n\t *\n\t * Note that this takes a different approach than use in {@link evaluateLazySchema} where the function evaluation is done using a utility that adds caching.\n\t *\n\t * @param factory - The factory function to memoize.\n\t * @returns A function that returns the cached result of the factory.\n\t * @alpha\n\t */\n\texport const memoize = <T>(factory: () => T): (() => T) => {\n\t\tlet run = false;\n\t\tlet cached: T;\n\t\treturn () => {\n\t\t\tif (!run) {\n\t\t\t\tcached = factory();\n\t\t\t\trun = true;\n\t\t\t}\n\t\t\treturn cached;\n\t\t};\n\t};\n\n\t/**\n\t * An item which can be configured (evaluated) against a composed configuration to produce a result.\n\t *\n\t * @remarks\n\t * Use {@link Component.Composed.getConfigured} to evaluate a `Configurable`.\n\t * The result is cached, so a given `Configurable` is only evaluated once per composition.\n\t *\n\t * @typeParam TConfigPartial - The configuration type made available when configuring.\n\t * @typeParam TResult - The result produced by configuring.\n\t * @typeParam TComponent - The content components contribute.\n\t *\n\t * @alpha\n\t */\n\texport interface Configurable<TConfigPartial, out TResult, TComponent> {\n\t\t/**\n\t\t * Produce the configured result.\n\t\t * @param config - The composed configuration.\n\t\t * @param components - The composed components.\n\t\t */\n\t\tconfigure(\n\t\t\tconfig: TConfigPartial,\n\t\t\tcomponents: Composed<TComponent, TConfigPartial>,\n\t\t): TResult;\n\t}\n\n\t/**\n\t * Implementation of {@link Component.Composed}.\n\t */\n\tclass Config<TConfig, TComponent> implements Composed<TComponent, TConfig> {\n\t\tpublic readonly componentsMap: ReadonlyMap<Factory<TComponent, TConfig>, TComponent>;\n\n\t\t/**\n\t\t * Cache of results produced by {@link Component.Composed.getConfigured}.\n\t\t *\n\t\t * @remarks\n\t\t * Maps each {@link Component.Configurable} to the result of evaluating it against this composition.\n\t\t * This ensures a given `Configurable` is only configured once: subsequent lookups return the cached result.\n\t\t */\n\t\tprivate readonly evaluatedMap: Map<Configurable<TConfig, unknown, TComponent>, unknown> =\n\t\t\tnew Map();\n\n\t\t/**\n\t\t * Cache of results produced by {@link Component.Composed.getComposed}.\n\t\t *\n\t\t * @remarks\n\t\t * Maps each composed property to the array produced for it.\n\t\t * This ensures a given property is only composed once: subsequent lookups return the same array\n\t\t * (including the same lazy values), so repeated calls with the same property are reference-stable.\n\t\t */\n\t\tprivate readonly composedMap: Map<keyof TComponent, readonly unknown[]> = new Map();\n\n\t\tpublic readonly components: readonly TComponent[];\n\n\t\tpublic readonly config: TConfig;\n\n\t\tpublic constructor(\n\t\t\tallComponents: readonly Factory<TComponent, TConfig>[],\n\t\t\tlazyConfiguration: (composed: Composed<TComponent, TConfig>) => TConfig,\n\t\t) {\n\t\t\t// eslint-disable-next-line no-undef-init -- Explicitly undefined: `config` is populated below, after all components have been constructed, and is read lazily via `lazyConfigInner`.\n\t\t\tlet config: TConfig | undefined = undefined;\n\t\t\tconst lazyConfigInner = (): TConfig => {\n\t\t\t\tif (config === undefined) {\n\t\t\t\t\tthrow new UsageError(\n\t\t\t\t\t\t\"Configuration not yet available: components must not evaluate the lazy configuration during composition.\",\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\treturn config;\n\t\t\t};\n\t\t\tthis.componentsMap = new Map(allComponents.map((c) => [c, c(lazyConfigInner)]));\n\t\t\tthis.components = [...this.componentsMap.values()];\n\t\t\tconfig = lazyConfiguration(this);\n\t\t\tthis.config = config;\n\t\t}\n\n\t\tpublic getComponent<TFactory extends Factory<TComponent, TConfig>>(\n\t\t\tfactory: TFactory,\n\t\t): ReturnType<TFactory> {\n\t\t\tconst found = this.componentsMap.get(factory);\n\t\t\tif (found === undefined) {\n\t\t\t\tthrow new UsageError(\"Requested component not included in this configuration\");\n\t\t\t}\n\t\t\treturn found as ReturnType<TFactory>;\n\t\t}\n\n\t\tpublic getConfigured<TConfigurable extends Configurable<TConfig, unknown, TComponent>>(\n\t\t\tconfigurable: TConfigurable,\n\t\t): ReturnType<TConfigurable[\"configure\"]> {\n\t\t\tconst configured: unknown = getOrCreate(this.evaluatedMap, configurable, (c) => {\n\t\t\t\tconst result = c.configure(this.config, this);\n\t\t\t\tif (result === undefined) {\n\t\t\t\t\tthrow new UsageError(\"Configurable must not return undefined\");\n\t\t\t\t}\n\t\t\t\treturn result;\n\t\t\t});\n\t\t\treturn configured as ReturnType<TConfigurable[\"configure\"]>;\n\t\t}\n\n\t\tpublic getComposed<\n\t\t\tTKey extends keyof {\n\t\t\t\t[Property in keyof TComponent as TComponent[Property] extends\n\t\t\t\t\t| LazyArray<unknown>\n\t\t\t\t\t| undefined\n\t\t\t\t\t? Property\n\t\t\t\t\t: never]: boolean;\n\t\t\t},\n\t\t>(\n\t\t\tproperty: TKey,\n\t\t): readonly (Exclude<TComponent[TKey], undefined> extends LazyArray<infer U>\n\t\t\t? () => U\n\t\t\t: never)[] {\n\t\t\tconst result = getOrCreate(this.composedMap, property, () =>\n\t\t\t\tthis.components.flatMap((c) => {\n\t\t\t\t\tconst prop = c[property] as LazyArray<unknown> | undefined;\n\t\t\t\t\tif (prop === undefined) {\n\t\t\t\t\t\treturn [];\n\t\t\t\t\t}\n\t\t\t\t\treturn prop();\n\t\t\t\t}),\n\t\t\t);\n\t\t\treturn result as (Exclude<TComponent[TKey], undefined> extends LazyArray<infer U>\n\t\t\t\t? () => U\n\t\t\t\t: never)[];\n\t\t}\n\t}\n\n\t/**\n\t * Combine multiple {@link Component.Factory|components} into a single {@link Component.Composed}.\n\t *\n\t * @remarks\n\t * The {@link Component.Composed} itself is used as the configuration made available to components:\n\t * the simple case where components read composed content directly from the composition.\n\t * To produce a custom aggregated configuration, use the overload which takes a `lazyConfiguration` builder.\n\t *\n\t * @param allComponents - The components to compose.\n\t * @returns The composed components, from which configuration and per-component content can be read.\n\t *\n\t * @typeParam TComponent - The content each component contributes.\n\t *\n\t * @alpha\n\t */\n\texport function compose<TComponent>(\n\t\tallComponents: readonly Factory<TComponent>[],\n\t): Composed<TComponent>;\n\t/**\n\t * Combine multiple {@link Component.Factory|components} into a single {@link Component.Composed}.\n\t *\n\t * @param allComponents - The components to compose.\n\t * @param lazyConfiguration - Builds the composed configuration from the composed components.\n\t * This is invoked once, after all components have been created, and can aggregate content contributed by the\n\t * components (for example via {@link Component.Composed.getComposed}).\n\t * @returns The composed components, from which configuration and per-component content can be read.\n\t *\n\t * @typeParam TComponent - The content each component contributes.\n\t * @typeParam TConfig - The composed configuration type made available to components.\n\t *\n\t * @alpha\n\t */\n\texport function compose<TComponent, TConfig>(\n\t\tallComponents: readonly Factory<TComponent, TConfig>[],\n\t\tlazyConfiguration: (composed: Composed<TComponent, TConfig>) => TConfig,\n\t): Composed<TComponent, TConfig>;\n\texport function compose<TComponent, TConfig>(\n\t\tallComponents: readonly Factory<TComponent, TConfig>[],\n\t\tlazyConfiguration: (composed: Composed<TComponent, TConfig>) => TConfig = (composed) =>\n\t\t\tcomposed as unknown as TConfig,\n\t): Composed<TComponent, TConfig> {\n\t\treturn new Config<TConfig, TComponent>(allComponents, lazyConfiguration);\n\t}\n\n\t/**\n\t * The default configuration type for a composition.\n\t * Also the type of Composed when using the default composition.\n\t * @privateRemarks\n\t * Declaring this as its own type makes the recursion possible instead of having to list the config parameter as unknown.\n\t * This makes it easier to understand what is going on when seeing this type in the intellisense.\n\t * @sealed @alpha\n\t */\n\texport type ComposedDefault<TComponent> = Composed<TComponent, ComposedDefault<TComponent>>;\n\n\t/**\n\t * The result of composing multiple components.\n\t *\n\t * @remarks\n\t * Create using {@link Component.(compose:1)}.\n\t *\n\t * @typeParam TComponent - The content each component contributes.\n\t * @typeParam TConfig - The composed configuration type made available to components.\n\t * Defaults to the composition itself: the common case where no custom configuration type is needed.\n\t *\n\t * @sealed @alpha\n\t */\n\texport interface Composed<TComponent, TConfig = ComposedDefault<TComponent>> {\n\t\t/**\n\t\t * The components which were composed.\n\t\t */\n\t\treadonly components: readonly TComponent[];\n\n\t\t/**\n\t\t * The configuration which was produced when composing.\n\t\t */\n\t\treadonly config: TConfig;\n\n\t\t/**\n\t\t * Get a component by its factory.\n\t\t *\n\t\t * @param factory - The factory used to look up the component. Must have been provided when composing.\n\t\t * @returns The content created by the provided factory.\n\t\t * This result is cached during composition and not reevaluated.\n\t\t */\n\t\tgetComponent<TFactory extends Factory<TComponent, TConfig>>(\n\t\t\tfactory: TFactory,\n\t\t): ReturnType<TFactory>;\n\n\t\t/**\n\t\t * Configure a {@link Component.Configurable}.\n\t\t * @remarks\n\t\t * The result is cached when first evaluated, so subsequent calls with the same `configurable` return the\n\t\t * same result.\n\t\t * @param configurable - The item to configure against this composition.\n\t\t */\n\t\tgetConfigured<TConfigurable extends Configurable<TConfig, unknown, TComponent>>(\n\t\t\tconfigurable: TConfigurable,\n\t\t): ReturnType<TConfigurable[\"configure\"]>;\n\n\t\t/**\n\t\t * Compose the contents of a {@link Component.LazyArray} property from all components.\n\t\t * @remarks\n\t\t * The result is cached when first evaluated, so subsequent calls with the same `property` return the\n\t\t * same result.\n\t\t * @param property - The property of the components to compose.\n\t\t * @returns The concatenation of the lazy values contributed by each component for `property`.\n\t\t * Components which omit the property contribute nothing.\n\t\t */\n\t\tgetComposed<\n\t\t\tTKey extends keyof {\n\t\t\t\t[Property in keyof TComponent as TComponent[Property] extends\n\t\t\t\t\t| LazyArray<unknown>\n\t\t\t\t\t| undefined\n\t\t\t\t\t? Property\n\t\t\t\t\t: never]: boolean;\n\t\t\t},\n\t\t>(\n\t\t\tproperty: TKey,\n\t\t): readonly (Exclude<TComponent[TKey], undefined> extends LazyArray<infer U>\n\t\t\t? () => U\n\t\t\t: never)[];\n\t}\n}\n"]}

package/dist/entrypoints/alpha.d.ts

@@ -2,5 +2,5 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-export { AllowedTypes, CommitKind, CommitMetadata, FieldKind, FieldProps, FieldSchema, FieldSchemaMetadata, ITree, ITreeConfigurationOptions, ITreeViewConfiguration, ImplicitAllowedTypes, ImplicitFieldSchema, Input, InsertableTreeFieldFromImplicitField, InsertableTreeNodeFromAllowedTypes, InsertableTreeNodeFromImplicitAllowedTypes, InsertableTypedNode, InternalTreeNode, InternalTypes, IsListener, IsUnion, IterableTreeArrayContent, LazyItem, LeafSchema, Listenable, Listeners, MakeNominal, MapNodeInsertableData, NodeFromSchema, NodeInDocumentConstraint, NodeKind, NodeSchemaMetadata, NodeSchemaOptions, NumberKeys, ObjectFromSchemaRecord, Off, ReadonlyArrayNode, RestrictiveReadonlyRecord, RestrictiveStringRecord, Revertible, RevertibleFactory, RevertibleStatus, RunTransaction, SchemaCompatibilityStatus, SchemaFactory, SchemaFactory_base, SchemaStatics, SimpleNodeSchemaBase, System_Unsafe, TransactionConstraint, Tree, TreeArrayNode, TreeChangeEvents, TreeFieldFromImplicitField, TreeLeafValue, TreeMapNode, TreeNode, TreeNodeApi, TreeNodeFromImplicitAllowedTypes, TreeNodeSchema, TreeNodeSchemaClass, TreeNodeSchemaCore, TreeNodeSchemaNonClass, TreeObjectNode, TreeStatus, TreeView, TreeViewConfiguration, TreeViewEvents, Unenforced, Unhydrated, UnionToIntersection, ValidateRecursiveSchema, ValidateRecursiveSchemaTemplate, ViewableTree, WithType, rollback, typeSchemaSymbol, AllowedTypeMetadata, AllowedTypesFull, AllowedTypesFullEvaluated, AllowedTypesFullFromMixed, AllowedTypesFullFromMixedUnsafe, AllowedTypesMetadata, AnnotateAllowedTypesList, AnnotateAllowedTypesListUnsafe, AnnotatedAllowedType, AnnotatedAllowedTypeUnsafe, AnnotatedAllowedTypes, AnnotatedAllowedTypesUnsafe, CodecWriteOptionsBeta, ConciseTree, ExtensibleUnionNode, FixRecursiveArraySchema, FluidSerializableAsTree, ForestOptions, ForestType, ForestTypeExpensiveDebug, ForestTypeOptimized, ForestTypeReference, IdentifierIndex, JsonCompatible, JsonCompatibleObject, KeyEncodingOptions, NodeChangedData, ObjectSchemaOptions, PopUnion, RecordNodeInsertableData, RunTransactionParamsBeta, SchemaFactoryBeta, SchemaStaticsBeta, SchemaUpgrade, SharedTreeOptionsBeta, SnapshotFileSystem, SnapshotSchemaCompatibilityOptions, System_TableSchema, TableSchema, TransactionCallbackStatusBeta, TransactionResultFailed, TransactionResultSuccess, TransactionValueResult, TransactionVoidResult, TreeBeta, TreeBranch, TreeChangeEventsBeta, TreeEncodingOptions, TreeIndex, TreeIndexKey, TreeIndexNodes, TreeRecordNode, TreeRecordNodeUnsafe, TreeViewBeta, UnannotateAllowedTypeUnsafe, UnannotateAllowedTypesList, UnannotateAllowedTypesListUnsafe, UnionToTuple, VoidTransactionCallbackStatusBeta, WithValue, adaptEnum, asBeta, configuredSharedTreeBeta, createIdentifierIndex, createIndependentTreeBeta, createTreeIndex, enumFromStrings, singletonSchema, snapshotSchemaCompatibility, AllowedTypesFullUnsafe, ArrayNodeCustomizableSchema, ArrayNodeCustomizableSchemaAlpha, ArrayNodeCustomizableSchemaUnsafe, ArrayNodeDeltaOp, ArrayNodeInsertOp, ArrayNodePojoEmulationSchema, ArrayNodeRemoveOp, ArrayNodeRetainOp, ArrayNodeSchema, ArrayNodeTreeChangedDeltaOp, ArrayNodeTreeChangedRetainOp, ArrayPlaceAnchor, ChangeMetadata, CodecName, CodecWriteOptions, CreateIndependentTreeAlphaOptions, DirtyTreeMap, DirtyTreeStatus, ErasedNode, ErasedSchema, ErasedSchemaSubclassable, FactoryContent, FactoryContentObject, FieldHasDefaultAlpha, FieldHasDefaultAlphaUnsafe, FieldPropsAlpha, FieldSchemaAlpha, FieldSchemaAlphaUnsafe, FluidClientVersion, FormatValidator, FormatValidatorBasic, FormatValidatorNoOp, FormatVersion, HandleConverter, ICodecOptions, ITreeAlpha, IncrementalEncodingPolicy, IndependentViewOptions, Insertable, InsertableContent, InsertableField, InsertableObjectFromSchemaRecordAlpha, InsertableObjectFromSchemaRecordAlphaUnsafe, JsonArrayNodeSchema, JsonAsTree, JsonCompatibleReadOnly, JsonCompatibleReadOnlyObject, JsonFieldSchema, JsonLeafNodeSchema, JsonLeafSchemaType, JsonMapNodeSchema, JsonNodeSchema, JsonNodeSchemaBase, JsonObjectNodeSchema, JsonRecordNodeSchema, JsonRefPath, JsonSchemaId, JsonSchemaRef, JsonSchemaType, JsonStringKeyPatternProperties, JsonTreeSchema, LabelTree, LocalChangeMetadata, MapNodeCustomizableSchema, MapNodeCustomizableSchemaUnsafe, MapNodePojoEmulationSchema, MapNodeSchema, NoChangeConstraint, NodeChangedDataAlpha, NodeChangedDataDelta, NodeChangedDataProperties, NodeChangedDataTreeDelta, NodeProvider, NodeSchemaOptionsAlpha, ObjectNodeSchema, ObjectNodeSchemaWorkaround, ObjectSchemaOptionsAlpha, ObservationResults, ReadSchema, ReadableField, RecordNodeCustomizableSchema, RecordNodePojoEmulationSchema, RecordNodeSchema, RemoteChangeMetadata, RevertibleAlpha, RevertibleAlphaFactory, RunTransactionParamsAlpha, SchemaFactoryAlpha, SchemaStaticsAlpha, SchemaType, SharedTreeFormatOptions, SharedTreeOptions, SimpleAllowedTypeAttributes, SimpleArrayNodeSchema, SimpleFieldSchema, SimpleLeafNodeSchema, SimpleMapNodeSchema, SimpleNodeSchema, SimpleNodeSchemaBaseAlpha, SimpleObjectFieldSchema, SimpleObjectNodeSchema, SimpleRecordNodeSchema, SimpleTreeSchema, TextAsTree, TransactionCallbackStatusAlpha, TransactionConstraintAlpha, TransactionLabels, TransactionPostProcessor, TreeAlpha, TreeArrayNodeAlpha, TreeBranchAlpha, TreeBranchEvents, TreeChangeEventsAlpha, TreeCompressionStrategy, TreeContextAlpha, TreeIdentifierUtils, TreeMapNodeAlpha, TreeParsingOptions, TreeSchema, TreeSchemaEncodingOptions, TreeViewAlpha, TreeViewConfigurationAlpha, UnsafeUnknownSchema, ValueSchema, VerboseTree, VerboseTreeNode, ViewContent, VoidTransactionCallbackStatusAlpha, allowUnused, asAlpha, asTreeViewAlpha, checkCompatibility, cloneWithReplacements, comparePersistedSchema, configuredSharedTreeAlpha, contentSchemaSymbol, createArrayInsertionAnchor, createIndependentTreeAlpha, decodeSchemaCompatibilitySnapshot, encodeSchemaCompatibilitySnapshot, eraseSchemaDetails, eraseSchemaDetailsSubclassable, evaluateLazySchema, exportCompatibilitySchemaSnapshot, extractPersistedSchema, generateSchemaFromSimpleSchema, getJsonSchema, getSimpleSchema, importCompatibilitySchemaSnapshot, incrementalEncodingPolicyForAllowedTypes, incrementalSummaryHint, independentInitializedView, independentView, normalizeAllowedTypes, persistedToSimpleSchema, replaceConciseTreeHandles, replaceHandles, replaceVerboseTreeHandles, trackDirtyNodes } from "../index.js";
+export { AllowedTypes, CommitKind, CommitMetadata, FieldKind, FieldProps, FieldSchema, FieldSchemaMetadata, ITree, ITreeConfigurationOptions, ITreeViewConfiguration, ImplicitAllowedTypes, ImplicitFieldSchema, Input, InsertableTreeFieldFromImplicitField, InsertableTreeNodeFromAllowedTypes, InsertableTreeNodeFromImplicitAllowedTypes, InsertableTypedNode, InternalTreeNode, InternalTypes, IsListener, IsUnion, IterableTreeArrayContent, LazyItem, LeafSchema, Listenable, Listeners, MakeNominal, MapNodeInsertableData, NodeFromSchema, NodeInDocumentConstraint, NodeKind, NodeSchemaMetadata, NodeSchemaOptions, NumberKeys, ObjectFromSchemaRecord, Off, ReadonlyArrayNode, RestrictiveReadonlyRecord, RestrictiveStringRecord, Revertible, RevertibleFactory, RevertibleStatus, RunTransaction, SchemaCompatibilityStatus, SchemaFactory, SchemaFactory_base, SchemaStatics, SimpleNodeSchemaBase, System_Unsafe, TransactionConstraint, Tree, TreeArrayNode, TreeChangeEvents, TreeFieldFromImplicitField, TreeLeafValue, TreeMapNode, TreeNode, TreeNodeApi, TreeNodeFromImplicitAllowedTypes, TreeNodeSchema, TreeNodeSchemaClass, TreeNodeSchemaCore, TreeNodeSchemaNonClass, TreeObjectNode, TreeStatus, TreeView, TreeViewConfiguration, TreeViewEvents, Unenforced, Unhydrated, UnionToIntersection, ValidateRecursiveSchema, ValidateRecursiveSchemaTemplate, ViewableTree, WithType, rollback, typeSchemaSymbol, AllowedTypeMetadata, AllowedTypesFull, AllowedTypesFullEvaluated, AllowedTypesFullFromMixed, AllowedTypesFullFromMixedUnsafe, AllowedTypesMetadata, AnnotateAllowedTypesList, AnnotateAllowedTypesListUnsafe, AnnotatedAllowedType, AnnotatedAllowedTypeUnsafe, AnnotatedAllowedTypes, AnnotatedAllowedTypesUnsafe, CodecWriteOptionsBeta, ConciseTree, ExtensibleUnionNode, FixRecursiveArraySchema, FluidSerializableAsTree, ForestOptions, ForestType, ForestTypeExpensiveDebug, ForestTypeOptimized, ForestTypeReference, IdentifierIndex, JsonCompatible, JsonCompatibleObject, KeyEncodingOptions, NodeChangedData, ObjectSchemaOptions, PopUnion, RecordNodeInsertableData, RunTransactionParamsBeta, SchemaFactoryBeta, SchemaStaticsBeta, SchemaUpgrade, SharedTreeOptionsBeta, SnapshotFileSystem, SnapshotSchemaCompatibilityOptions, System_TableSchema, TableSchema, TransactionCallbackStatusBeta, TransactionResultFailed, TransactionResultSuccess, TransactionValueResult, TransactionVoidResult, TreeBeta, TreeBranch, TreeChangeEventsBeta, TreeEncodingOptions, TreeIndex, TreeIndexKey, TreeIndexNodes, TreeRecordNode, TreeRecordNodeUnsafe, TreeViewBeta, UnannotateAllowedTypeUnsafe, UnannotateAllowedTypesList, UnannotateAllowedTypesListUnsafe, UnionToTuple, VoidTransactionCallbackStatusBeta, WithValue, adaptEnum, asBeta, configuredSharedTreeBeta, createIdentifierIndex, createIndependentTreeBeta, createTreeIndex, enumFromStrings, singletonSchema, snapshotSchemaCompatibility, AllowedTypesFullUnsafe, ArrayNodeCustomizableSchema, ArrayNodeCustomizableSchemaAlpha, ArrayNodeCustomizableSchemaUnsafe, ArrayNodeDeltaOp, ArrayNodeInsertOp, ArrayNodePojoEmulationSchema, ArrayNodeRemoveOp, ArrayNodeRetainOp, ArrayNodeSchema, ArrayNodeTreeChangedDeltaOp, ArrayNodeTreeChangedRetainOp, ArrayPlaceAnchor, ChangeMetadata, CodecName, CodecWriteOptions, Component, CreateIndependentTreeAlphaOptions, DirtyTreeMap, DirtyTreeStatus, ErasedNode, ErasedSchema, ErasedSchemaSubclassable, FactoryContent, FactoryContentObject, FieldHasDefaultAlpha, FieldHasDefaultAlphaUnsafe, FieldPropsAlpha, FieldSchemaAlpha, FieldSchemaAlphaUnsafe, FluidClientVersion, FormatValidator, FormatValidatorBasic, FormatValidatorNoOp, FormatVersion, HandleConverter, ICodecOptions, ITreeAlpha, IncrementalEncodingPolicy, IndependentViewOptions, IndependentViewTelemetryOptions, Insertable, InsertableContent, InsertableField, InsertableObjectFromSchemaRecordAlpha, InsertableObjectFromSchemaRecordAlphaUnsafe, JsonArrayNodeSchema, JsonAsTree, JsonCompatibleReadOnly, JsonCompatibleReadOnlyObject, JsonFieldSchema, JsonLeafNodeSchema, JsonLeafSchemaType, JsonMapNodeSchema, JsonNodeSchema, JsonNodeSchemaBase, JsonObjectNodeSchema, JsonRecordNodeSchema, JsonRefPath, JsonSchemaId, JsonSchemaRef, JsonSchemaType, JsonStringKeyPatternProperties, JsonTreeSchema, LabelTree, LocalChangeMetadata, MapNodeCustomizableSchema, MapNodeCustomizableSchemaUnsafe, MapNodePojoEmulationSchema, MapNodeSchema, NoChangeConstraint, NodeChangedDataAlpha, NodeChangedDataDelta, NodeChangedDataProperties, NodeChangedDataTreeDelta, NodeProvider, NodeSchemaOptionsAlpha, ObjectNodeSchema, ObjectNodeSchemaWorkaround, ObjectSchemaOptionsAlpha, ObservationResults, ReadSchema, ReadableField, RecordNodeCustomizableSchema, RecordNodePojoEmulationSchema, RecordNodeSchema, RemoteChangeMetadata, RevertibleAlpha, RevertibleAlphaFactory, RunTransactionParamsAlpha, SchemaFactoryAlpha, SchemaStaticsAlpha, SchemaType, SharedTreeFormatOptions, SharedTreeOptions, SimpleAllowedTypeAttributes, SimpleArrayNodeSchema, SimpleFieldSchema, SimpleLeafNodeSchema, SimpleMapNodeSchema, SimpleNodeSchema, SimpleNodeSchemaBaseAlpha, SimpleObjectFieldSchema, SimpleObjectNodeSchema, SimpleRecordNodeSchema, SimpleTreeSchema, TextAsTree, TransactionCallbackStatusAlpha, TransactionConstraintAlpha, TransactionLabels, TransactionPostProcessor, TreeAlpha, TreeArrayNodeAlpha, TreeBranchAlpha, TreeBranchEvents, TreeChangeEventsAlpha, TreeCompressionStrategy, TreeContextAlpha, TreeIdentifierUtils, TreeMapNodeAlpha, TreeParsingOptions, TreeSchema, TreeSchemaEncodingOptions, TreeViewAlpha, TreeViewConfigurationAlpha, UnsafeUnknownSchema, ValueSchema, VerboseTree, VerboseTreeNode, ViewContent, VoidTransactionCallbackStatusAlpha, allowUnused, asAlpha, asTreeViewAlpha, checkCompatibility, cloneWithReplacements, comparePersistedSchema, configuredSharedTreeAlpha, contentSchemaSymbol, createArrayInsertionAnchor, createIndependentTreeAlpha, decodeSchemaCompatibilitySnapshot, encodeSchemaCompatibilitySnapshot, eraseSchemaDetails, eraseSchemaDetailsSubclassable, evaluateLazySchema, exportCompatibilitySchemaSnapshot, extractPersistedSchema, generateSchemaFromSimpleSchema, getJsonSchema, getSimpleSchema, importCompatibilitySchemaSnapshot, incrementalEncodingPolicyForAllowedTypes, incrementalSummaryHint, independentInitializedView, independentView, minimize, normalizeAllowedTypes, persistedToSimpleSchema, replaceConciseTreeHandles, replaceHandles, replaceVerboseTreeHandles, trackDirtyNodes } from "../index.js";
 //# sourceMappingURL=alpha.d.ts.map

package/dist/entrypoints/alpha.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alpha.d.ts","sourceRoot":"","sources":["../../src/entrypoints/alpha.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"alpha.d.ts","sourceRoot":"","sources":["../../src/entrypoints/alpha.ts"],"names":[],"mappings":"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"}

package/dist/entrypoints/alpha.js

@@ -4,8 +4,8 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkCompatibility = exports.asTreeViewAlpha = exports.asAlpha = exports.allowUnused = exports.ValueSchema = exports.TreeViewConfigurationAlpha = exports.TreeCompressionStrategy = exports.TreeAlpha = exports.TextAsTree = exports.SchemaFactoryAlpha = exports.RecordNodeSchema = exports.ObjectNodeSchema = exports.MapNodeSchema = exports.JsonAsTree = exports.FormatValidatorNoOp = exports.FormatValidatorBasic = exports.FluidClientVersion = exports.ArrayNodeSchema = exports.snapshotSchemaCompatibility = exports.singletonSchema = exports.enumFromStrings = exports.createTreeIndex = exports.createIndependentTreeBeta = exports.createIdentifierIndex = exports.configuredSharedTreeBeta = exports.asBeta = exports.adaptEnum = exports.TreeBeta = exports.TableSchema = exports.SchemaFactoryBeta = exports.KeyEncodingOptions = exports.ForestTypeReference = exports.ForestTypeOptimized = exports.ForestTypeExpensiveDebug = exports.FluidSerializableAsTree = exports.ExtensibleUnionNode = exports.rollback = exports.TreeViewConfiguration = exports.TreeStatus = exports.TreeNode = exports.TreeArrayNode = exports.Tree = exports.SchemaFactory = exports.RevertibleStatus = exports.NodeKind = exports.IterableTreeArrayContent = exports.InternalTypes = exports.FieldSchema = exports.FieldKind = exports.CommitKind = void 0;
-exports.trackDirtyNodes = exports.replaceVerboseTreeHandles = exports.replaceHandles = exports.replaceConciseTreeHandles = exports.persistedToSimpleSchema = exports.normalizeAllowedTypes = exports.independentView = exports.independentInitializedView = exports.incrementalSummaryHint = exports.incrementalEncodingPolicyForAllowedTypes = exports.importCompatibilitySchemaSnapshot = exports.getSimpleSchema = exports.getJsonSchema = exports.generateSchemaFromSimpleSchema = exports.extractPersistedSchema = exports.exportCompatibilitySchemaSnapshot = exports.evaluateLazySchema = exports.eraseSchemaDetailsSubclassable = exports.eraseSchemaDetails = exports.encodeSchemaCompatibilitySnapshot = exports.decodeSchemaCompatibilitySnapshot = exports.createIndependentTreeAlpha = exports.createArrayInsertionAnchor = exports.contentSchemaSymbol = exports.configuredSharedTreeAlpha = exports.comparePersistedSchema = exports.cloneWithReplacements = void 0;
+exports.asTreeViewAlpha = exports.asAlpha = exports.allowUnused = exports.ValueSchema = exports.TreeViewConfigurationAlpha = exports.TreeCompressionStrategy = exports.TreeAlpha = exports.TextAsTree = exports.SchemaFactoryAlpha = exports.RecordNodeSchema = exports.ObjectNodeSchema = exports.MapNodeSchema = exports.JsonAsTree = exports.FormatValidatorNoOp = exports.FormatValidatorBasic = exports.FluidClientVersion = exports.Component = exports.ArrayNodeSchema = exports.snapshotSchemaCompatibility = exports.singletonSchema = exports.enumFromStrings = exports.createTreeIndex = exports.createIndependentTreeBeta = exports.createIdentifierIndex = exports.configuredSharedTreeBeta = exports.asBeta = exports.adaptEnum = exports.TreeBeta = exports.TableSchema = exports.SchemaFactoryBeta = exports.KeyEncodingOptions = exports.ForestTypeReference = exports.ForestTypeOptimized = exports.ForestTypeExpensiveDebug = exports.FluidSerializableAsTree = exports.ExtensibleUnionNode = exports.rollback = exports.TreeViewConfiguration = exports.TreeStatus = exports.TreeNode = exports.TreeArrayNode = exports.Tree = exports.SchemaFactory = exports.RevertibleStatus = exports.NodeKind = exports.IterableTreeArrayContent = exports.InternalTypes = exports.FieldSchema = exports.FieldKind = exports.CommitKind = void 0;
+exports.trackDirtyNodes = exports.replaceVerboseTreeHandles = exports.replaceHandles = exports.replaceConciseTreeHandles = exports.persistedToSimpleSchema = exports.normalizeAllowedTypes = exports.minimize = exports.independentView = exports.independentInitializedView = exports.incrementalSummaryHint = exports.incrementalEncodingPolicyForAllowedTypes = exports.importCompatibilitySchemaSnapshot = exports.getSimpleSchema = exports.getJsonSchema = exports.generateSchemaFromSimpleSchema = exports.extractPersistedSchema = exports.exportCompatibilitySchemaSnapshot = exports.evaluateLazySchema = exports.eraseSchemaDetailsSubclassable = exports.eraseSchemaDetails = exports.encodeSchemaCompatibilitySnapshot = exports.decodeSchemaCompatibilitySnapshot = exports.createIndependentTreeAlpha = exports.createArrayInsertionAnchor = exports.contentSchemaSymbol = exports.configuredSharedTreeAlpha = exports.comparePersistedSchema = exports.cloneWithReplacements = exports.checkCompatibility = void 0;
 /*
  * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
  * Generated by "generate:entrypoint-sources".
@@ -44,6 +44,7 @@ Object.defineProperty(exports, "enumFromStrings", { enumerable: true, get: funct
 Object.defineProperty(exports, "singletonSchema", { enumerable: true, get: function () { return index_js_1.singletonSchema; } });
 Object.defineProperty(exports, "snapshotSchemaCompatibility", { enumerable: true, get: function () { return index_js_1.snapshotSchemaCompatibility; } });
 Object.defineProperty(exports, "ArrayNodeSchema", { enumerable: true, get: function () { return index_js_1.ArrayNodeSchema; } });
+Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return index_js_1.Component; } });
 Object.defineProperty(exports, "FluidClientVersion", { enumerable: true, get: function () { return index_js_1.FluidClientVersion; } });
 Object.defineProperty(exports, "FormatValidatorBasic", { enumerable: true, get: function () { return index_js_1.FormatValidatorBasic; } });
 Object.defineProperty(exports, "FormatValidatorNoOp", { enumerable: true, get: function () { return index_js_1.FormatValidatorNoOp; } });
@@ -82,6 +83,7 @@ Object.defineProperty(exports, "incrementalEncodingPolicyForAllowedTypes", { enu
 Object.defineProperty(exports, "incrementalSummaryHint", { enumerable: true, get: function () { return index_js_1.incrementalSummaryHint; } });
 Object.defineProperty(exports, "independentInitializedView", { enumerable: true, get: function () { return index_js_1.independentInitializedView; } });
 Object.defineProperty(exports, "independentView", { enumerable: true, get: function () { return index_js_1.independentView; } });
+Object.defineProperty(exports, "minimize", { enumerable: true, get: function () { return index_js_1.minimize; } });
 Object.defineProperty(exports, "normalizeAllowedTypes", { enumerable: true, get: function () { return index_js_1.normalizeAllowedTypes; } });
 Object.defineProperty(exports, "persistedToSimpleSchema", { enumerable: true, get: function () { return index_js_1.persistedToSimpleSchema; } });
 Object.defineProperty(exports, "replaceConciseTreeHandles", { enumerable: true, get: function () { return index_js_1.replaceConciseTreeHandles; } });

package/dist/entrypoints/alpha.js.map

@@ -1 +1 @@
-{"version":3,"file":"alpha.js","sourceRoot":"","sources":["../../src/entrypoints/alpha.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;AAEH;;;GAGG;AAEH,wCA2TqB;AAxTpB,sGAAA,UAAU,OAAA;AAEV,qGAAA,SAAS,OAAA;AAET,uGAAA,WAAW,OAAA;AAaX,yGAAA,aAAa,OAAA;AAGb,oHAAA,wBAAwB,OAAA;AASxB,oGAAA,QAAQ,OAAA;AAWR,4GAAA,gBAAgB,OAAA;AAGhB,yGAAA,aAAa,OAAA;AAMb,gGAAA,IAAI,OAAA;AACJ,yGAAA,aAAa,OAAA;AAKb,oGAAA,QAAQ,OAAA;AAQR,sGAAA,UAAU,OAAA;AAEV,iHAAA,qBAAqB,OAAA;AASrB,oGAAA,QAAQ,OAAA;AAmBR,+GAAA,mBAAmB,OAAA;AAEnB,mHAAA,uBAAuB,OAAA;AAGvB,oHAAA,wBAAwB,OAAA;AACxB,+GAAA,mBAAmB,OAAA;AACnB,+GAAA,mBAAmB,OAAA;AAInB,8GAAA,kBAAkB,OAAA;AAMlB,6GAAA,iBAAiB,OAAA;AAOjB,uGAAA,WAAW,OAAA;AAMX,oGAAA,QAAQ,OAAA;AAgBR,qGAAA,SAAS,OAAA;AACT,kGAAA,MAAM,OAAA;AACN,oHAAA,wBAAwB,OAAA;AACxB,iHAAA,qBAAqB,OAAA;AACrB,qHAAA,yBAAyB,OAAA;AACzB,2GAAA,eAAe,OAAA;AACf,2GAAA,eAAe,OAAA;AACf,2GAAA,eAAe,OAAA;AACf,uHAAA,2BAA2B,OAAA;AAa3B,2GAAA,eAAe,OAAA;AAoBf,8GAAA,kBAAkB,OAAA;AAElB,gHAAA,oBAAoB,OAAA;AACpB,+GAAA,mBAAmB,OAAA;AAanB,sGAAA,UAAU,OAAA;AAsBV,yGAAA,aAAa,OAAA;AAQb,4GAAA,gBAAgB,OAAA;AAQhB,4GAAA,gBAAgB,OAAA;AAKhB,8GAAA,kBAAkB,OAAA;AAgBlB,sGAAA,UAAU,OAAA;AAKV,qGAAA,SAAS,OAAA;AAKT,mHAAA,uBAAuB,OAAA;AAQvB,sHAAA,0BAA0B,OAAA;AAE1B,uGAAA,WAAW,OAAA;AAKX,uGAAA,WAAW,OAAA;AACX,mGAAA,OAAO,OAAA;AACP,2GAAA,eAAe,OAAA;AACf,8GAAA,kBAAkB,OAAA;AAClB,iHAAA,qBAAqB,OAAA;AACrB,kHAAA,sBAAsB,OAAA;AACtB,qHAAA,yBAAyB,OAAA;AACzB,+GAAA,mBAAmB,OAAA;AACnB,sHAAA,0BAA0B,OAAA;AAC1B,sHAAA,0BAA0B,OAAA;AAC1B,6HAAA,iCAAiC,OAAA;AACjC,6HAAA,iCAAiC,OAAA;AACjC,8GAAA,kBAAkB,OAAA;AAClB,0HAAA,8BAA8B,OAAA;AAC9B,8GAAA,kBAAkB,OAAA;AAClB,6HAAA,iCAAiC,OAAA;AACjC,kHAAA,sBAAsB,OAAA;AACtB,0HAAA,8BAA8B,OAAA;AAC9B,yGAAA,aAAa,OAAA;AACb,2GAAA,eAAe,OAAA;AACf,6HAAA,iCAAiC,OAAA;AACjC,oIAAA,wCAAwC,OAAA;AACxC,kHAAA,sBAAsB,OAAA;AACtB,sHAAA,0BAA0B,OAAA;AAC1B,2GAAA,eAAe,OAAA;AACf,iHAAA,qBAAqB,OAAA;AACrB,mHAAA,uBAAuB,OAAA;AACvB,qHAAA,yBAAyB,OAAA;AACzB,0GAAA,cAAc,OAAA;AACd,qHAAA,yBAAyB,OAAA;AACzB,2GAAA,eAAe,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/*\n * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.\n * Generated by \"generate:entrypoint-sources\".\n */\n\nexport {\n\t// #region @public APIs\n\tAllowedTypes, \n\tCommitKind, \n\tCommitMetadata, \n\tFieldKind, \n\tFieldProps, \n\tFieldSchema, \n\tFieldSchemaMetadata, \n\tITree, \n\tITreeConfigurationOptions, \n\tITreeViewConfiguration, \n\tImplicitAllowedTypes, \n\tImplicitFieldSchema, \n\tInput, \n\tInsertableTreeFieldFromImplicitField, \n\tInsertableTreeNodeFromAllowedTypes, \n\tInsertableTreeNodeFromImplicitAllowedTypes, \n\tInsertableTypedNode, \n\tInternalTreeNode, \n\tInternalTypes, \n\tIsListener, \n\tIsUnion, \n\tIterableTreeArrayContent, \n\tLazyItem, \n\tLeafSchema, \n\tListenable, \n\tListeners, \n\tMakeNominal, \n\tMapNodeInsertableData, \n\tNodeFromSchema, \n\tNodeInDocumentConstraint, \n\tNodeKind, \n\tNodeSchemaMetadata, \n\tNodeSchemaOptions, \n\tNumberKeys, \n\tObjectFromSchemaRecord, \n\tOff, \n\tReadonlyArrayNode, \n\tRestrictiveReadonlyRecord, \n\tRestrictiveStringRecord, \n\tRevertible, \n\tRevertibleFactory, \n\tRevertibleStatus, \n\tRunTransaction, \n\tSchemaCompatibilityStatus, \n\tSchemaFactory, \n\tSchemaFactory_base, \n\tSchemaStatics, \n\tSimpleNodeSchemaBase, \n\tSystem_Unsafe, \n\tTransactionConstraint, \n\tTree, \n\tTreeArrayNode, \n\tTreeChangeEvents, \n\tTreeFieldFromImplicitField, \n\tTreeLeafValue, \n\tTreeMapNode, \n\tTreeNode, \n\tTreeNodeApi, \n\tTreeNodeFromImplicitAllowedTypes, \n\tTreeNodeSchema, \n\tTreeNodeSchemaClass, \n\tTreeNodeSchemaCore, \n\tTreeNodeSchemaNonClass, \n\tTreeObjectNode, \n\tTreeStatus, \n\tTreeView, \n\tTreeViewConfiguration, \n\tTreeViewEvents, \n\tUnenforced, \n\tUnhydrated, \n\tUnionToIntersection, \n\tValidateRecursiveSchema, \n\tValidateRecursiveSchemaTemplate, \n\tViewableTree, \n\tWithType, \n\trollback, \n\ttypeSchemaSymbol,\n\t// #endregion\n \n\t// #region @beta APIs\n\tAllowedTypeMetadata, \n\tAllowedTypesFull, \n\tAllowedTypesFullEvaluated, \n\tAllowedTypesFullFromMixed, \n\tAllowedTypesFullFromMixedUnsafe, \n\tAllowedTypesMetadata, \n\tAnnotateAllowedTypesList, \n\tAnnotateAllowedTypesListUnsafe, \n\tAnnotatedAllowedType, \n\tAnnotatedAllowedTypeUnsafe, \n\tAnnotatedAllowedTypes, \n\tAnnotatedAllowedTypesUnsafe, \n\tCodecWriteOptionsBeta, \n\tConciseTree, \n\tExtensibleUnionNode, \n\tFixRecursiveArraySchema, \n\tFluidSerializableAsTree, \n\tForestOptions, \n\tForestType, \n\tForestTypeExpensiveDebug, \n\tForestTypeOptimized, \n\tForestTypeReference, \n\tIdentifierIndex, \n\tJsonCompatible, \n\tJsonCompatibleObject, \n\tKeyEncodingOptions, \n\tNodeChangedData, \n\tObjectSchemaOptions, \n\tPopUnion, \n\tRecordNodeInsertableData, \n\tRunTransactionParamsBeta, \n\tSchemaFactoryBeta, \n\tSchemaStaticsBeta, \n\tSchemaUpgrade, \n\tSharedTreeOptionsBeta, \n\tSnapshotFileSystem, \n\tSnapshotSchemaCompatibilityOptions, \n\tSystem_TableSchema, \n\tTableSchema, \n\tTransactionCallbackStatusBeta, \n\tTransactionResultFailed, \n\tTransactionResultSuccess, \n\tTransactionValueResult, \n\tTransactionVoidResult, \n\tTreeBeta, \n\tTreeBranch, \n\tTreeChangeEventsBeta, \n\tTreeEncodingOptions, \n\tTreeIndex, \n\tTreeIndexKey, \n\tTreeIndexNodes, \n\tTreeRecordNode, \n\tTreeRecordNodeUnsafe, \n\tTreeViewBeta, \n\tUnannotateAllowedTypeUnsafe, \n\tUnannotateAllowedTypesList, \n\tUnannotateAllowedTypesListUnsafe, \n\tUnionToTuple, \n\tVoidTransactionCallbackStatusBeta, \n\tWithValue, \n\tadaptEnum, \n\tasBeta, \n\tconfiguredSharedTreeBeta, \n\tcreateIdentifierIndex, \n\tcreateIndependentTreeBeta, \n\tcreateTreeIndex, \n\tenumFromStrings, \n\tsingletonSchema, \n\tsnapshotSchemaCompatibility,\n\t// #endregion\n \n\t// #region @alpha APIs\n\tAllowedTypesFullUnsafe, \n\tArrayNodeCustomizableSchema, \n\tArrayNodeCustomizableSchemaAlpha, \n\tArrayNodeCustomizableSchemaUnsafe, \n\tArrayNodeDeltaOp, \n\tArrayNodeInsertOp, \n\tArrayNodePojoEmulationSchema, \n\tArrayNodeRemoveOp, \n\tArrayNodeRetainOp, \n\tArrayNodeSchema, \n\tArrayNodeTreeChangedDeltaOp, \n\tArrayNodeTreeChangedRetainOp, \n\tArrayPlaceAnchor, \n\tChangeMetadata, \n\tCodecName, \n\tCodecWriteOptions, \n\tCreateIndependentTreeAlphaOptions, \n\tDirtyTreeMap, \n\tDirtyTreeStatus, \n\tErasedNode, \n\tErasedSchema, \n\tErasedSchemaSubclassable, \n\tFactoryContent, \n\tFactoryContentObject, \n\tFieldHasDefaultAlpha, \n\tFieldHasDefaultAlphaUnsafe, \n\tFieldPropsAlpha, \n\tFieldSchemaAlpha, \n\tFieldSchemaAlphaUnsafe, \n\tFluidClientVersion, \n\tFormatValidator, \n\tFormatValidatorBasic, \n\tFormatValidatorNoOp, \n\tFormatVersion, \n\tHandleConverter, \n\tICodecOptions, \n\tITreeAlpha, \n\tIncrementalEncodingPolicy, \n\tIndependentViewOptions, \n\tInsertable, \n\tInsertableContent, \n\tInsertableField, \n\tInsertableObjectFromSchemaRecordAlpha, \n\tInsertableObjectFromSchemaRecordAlphaUnsafe, \n\tJsonArrayNodeSchema, \n\tJsonAsTree, \n\tJsonCompatibleReadOnly, \n\tJsonCompatibleReadOnlyObject, \n\tJsonFieldSchema, \n\tJsonLeafNodeSchema, \n\tJsonLeafSchemaType, \n\tJsonMapNodeSchema, \n\tJsonNodeSchema, \n\tJsonNodeSchemaBase, \n\tJsonObjectNodeSchema, \n\tJsonRecordNodeSchema, \n\tJsonRefPath, \n\tJsonSchemaId, \n\tJsonSchemaRef, \n\tJsonSchemaType, \n\tJsonStringKeyPatternProperties, \n\tJsonTreeSchema, \n\tLabelTree, \n\tLocalChangeMetadata, \n\tMapNodeCustomizableSchema, \n\tMapNodeCustomizableSchemaUnsafe, \n\tMapNodePojoEmulationSchema, \n\tMapNodeSchema, \n\tNoChangeConstraint, \n\tNodeChangedDataAlpha, \n\tNodeChangedDataDelta, \n\tNodeChangedDataProperties, \n\tNodeChangedDataTreeDelta, \n\tNodeProvider, \n\tNodeSchemaOptionsAlpha, \n\tObjectNodeSchema, \n\tObjectNodeSchemaWorkaround, \n\tObjectSchemaOptionsAlpha, \n\tObservationResults, \n\tReadSchema, \n\tReadableField, \n\tRecordNodeCustomizableSchema, \n\tRecordNodePojoEmulationSchema, \n\tRecordNodeSchema, \n\tRemoteChangeMetadata, \n\tRevertibleAlpha, \n\tRevertibleAlphaFactory, \n\tRunTransactionParamsAlpha, \n\tSchemaFactoryAlpha, \n\tSchemaStaticsAlpha, \n\tSchemaType, \n\tSharedTreeFormatOptions, \n\tSharedTreeOptions, \n\tSimpleAllowedTypeAttributes, \n\tSimpleArrayNodeSchema, \n\tSimpleFieldSchema, \n\tSimpleLeafNodeSchema, \n\tSimpleMapNodeSchema, \n\tSimpleNodeSchema, \n\tSimpleNodeSchemaBaseAlpha, \n\tSimpleObjectFieldSchema, \n\tSimpleObjectNodeSchema, \n\tSimpleRecordNodeSchema, \n\tSimpleTreeSchema, \n\tTextAsTree, \n\tTransactionCallbackStatusAlpha, \n\tTransactionConstraintAlpha, \n\tTransactionLabels, \n\tTransactionPostProcessor, \n\tTreeAlpha, \n\tTreeArrayNodeAlpha, \n\tTreeBranchAlpha, \n\tTreeBranchEvents, \n\tTreeChangeEventsAlpha, \n\tTreeCompressionStrategy, \n\tTreeContextAlpha, \n\tTreeIdentifierUtils, \n\tTreeMapNodeAlpha, \n\tTreeParsingOptions, \n\tTreeSchema, \n\tTreeSchemaEncodingOptions, \n\tTreeViewAlpha, \n\tTreeViewConfigurationAlpha, \n\tUnsafeUnknownSchema, \n\tValueSchema, \n\tVerboseTree, \n\tVerboseTreeNode, \n\tViewContent, \n\tVoidTransactionCallbackStatusAlpha, \n\tallowUnused, \n\tasAlpha, \n\tasTreeViewAlpha, \n\tcheckCompatibility, \n\tcloneWithReplacements, \n\tcomparePersistedSchema, \n\tconfiguredSharedTreeAlpha, \n\tcontentSchemaSymbol, \n\tcreateArrayInsertionAnchor, \n\tcreateIndependentTreeAlpha, \n\tdecodeSchemaCompatibilitySnapshot, \n\tencodeSchemaCompatibilitySnapshot, \n\teraseSchemaDetails, \n\teraseSchemaDetailsSubclassable, \n\tevaluateLazySchema, \n\texportCompatibilitySchemaSnapshot, \n\textractPersistedSchema, \n\tgenerateSchemaFromSimpleSchema, \n\tgetJsonSchema, \n\tgetSimpleSchema, \n\timportCompatibilitySchemaSnapshot, \n\tincrementalEncodingPolicyForAllowedTypes, \n\tincrementalSummaryHint, \n\tindependentInitializedView, \n\tindependentView, \n\tnormalizeAllowedTypes, \n\tpersistedToSimpleSchema, \n\treplaceConciseTreeHandles, \n\treplaceHandles, \n\treplaceVerboseTreeHandles, \n\ttrackDirtyNodes\n\t// #endregion\n} from \"../index.js\";\n"]}
+{"version":3,"file":"alpha.js","sourceRoot":"","sources":["../../src/entrypoints/alpha.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;AAEH;;;GAGG;AAEH,wCA8TqB;AA3TpB,sGAAA,UAAU,OAAA;AAEV,qGAAA,SAAS,OAAA;AAET,uGAAA,WAAW,OAAA;AAaX,yGAAA,aAAa,OAAA;AAGb,oHAAA,wBAAwB,OAAA;AASxB,oGAAA,QAAQ,OAAA;AAWR,4GAAA,gBAAgB,OAAA;AAGhB,yGAAA,aAAa,OAAA;AAMb,gGAAA,IAAI,OAAA;AACJ,yGAAA,aAAa,OAAA;AAKb,oGAAA,QAAQ,OAAA;AAQR,sGAAA,UAAU,OAAA;AAEV,iHAAA,qBAAqB,OAAA;AASrB,oGAAA,QAAQ,OAAA;AAmBR,+GAAA,mBAAmB,OAAA;AAEnB,mHAAA,uBAAuB,OAAA;AAGvB,oHAAA,wBAAwB,OAAA;AACxB,+GAAA,mBAAmB,OAAA;AACnB,+GAAA,mBAAmB,OAAA;AAInB,8GAAA,kBAAkB,OAAA;AAMlB,6GAAA,iBAAiB,OAAA;AAOjB,uGAAA,WAAW,OAAA;AAMX,oGAAA,QAAQ,OAAA;AAgBR,qGAAA,SAAS,OAAA;AACT,kGAAA,MAAM,OAAA;AACN,oHAAA,wBAAwB,OAAA;AACxB,iHAAA,qBAAqB,OAAA;AACrB,qHAAA,yBAAyB,OAAA;AACzB,2GAAA,eAAe,OAAA;AACf,2GAAA,eAAe,OAAA;AACf,2GAAA,eAAe,OAAA;AACf,uHAAA,2BAA2B,OAAA;AAa3B,2GAAA,eAAe,OAAA;AAOf,qGAAA,SAAS,OAAA;AAcT,8GAAA,kBAAkB,OAAA;AAElB,gHAAA,oBAAoB,OAAA;AACpB,+GAAA,mBAAmB,OAAA;AAcnB,sGAAA,UAAU,OAAA;AAsBV,yGAAA,aAAa,OAAA;AAQb,4GAAA,gBAAgB,OAAA;AAQhB,4GAAA,gBAAgB,OAAA;AAKhB,8GAAA,kBAAkB,OAAA;AAgBlB,sGAAA,UAAU,OAAA;AAKV,qGAAA,SAAS,OAAA;AAKT,mHAAA,uBAAuB,OAAA;AAQvB,sHAAA,0BAA0B,OAAA;AAE1B,uGAAA,WAAW,OAAA;AAKX,uGAAA,WAAW,OAAA;AACX,mGAAA,OAAO,OAAA;AACP,2GAAA,eAAe,OAAA;AACf,8GAAA,kBAAkB,OAAA;AAClB,iHAAA,qBAAqB,OAAA;AACrB,kHAAA,sBAAsB,OAAA;AACtB,qHAAA,yBAAyB,OAAA;AACzB,+GAAA,mBAAmB,OAAA;AACnB,sHAAA,0BAA0B,OAAA;AAC1B,sHAAA,0BAA0B,OAAA;AAC1B,6HAAA,iCAAiC,OAAA;AACjC,6HAAA,iCAAiC,OAAA;AACjC,8GAAA,kBAAkB,OAAA;AAClB,0HAAA,8BAA8B,OAAA;AAC9B,8GAAA,kBAAkB,OAAA;AAClB,6HAAA,iCAAiC,OAAA;AACjC,kHAAA,sBAAsB,OAAA;AACtB,0HAAA,8BAA8B,OAAA;AAC9B,yGAAA,aAAa,OAAA;AACb,2GAAA,eAAe,OAAA;AACf,6HAAA,iCAAiC,OAAA;AACjC,oIAAA,wCAAwC,OAAA;AACxC,kHAAA,sBAAsB,OAAA;AACtB,sHAAA,0BAA0B,OAAA;AAC1B,2GAAA,eAAe,OAAA;AACf,oGAAA,QAAQ,OAAA;AACR,iHAAA,qBAAqB,OAAA;AACrB,mHAAA,uBAAuB,OAAA;AACvB,qHAAA,yBAAyB,OAAA;AACzB,0GAAA,cAAc,OAAA;AACd,qHAAA,yBAAyB,OAAA;AACzB,2GAAA,eAAe,OAAA","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/*\n * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.\n * Generated by \"generate:entrypoint-sources\".\n */\n\nexport {\n\t// #region @public APIs\n\tAllowedTypes, \n\tCommitKind, \n\tCommitMetadata, \n\tFieldKind, \n\tFieldProps, \n\tFieldSchema, \n\tFieldSchemaMetadata, \n\tITree, \n\tITreeConfigurationOptions, \n\tITreeViewConfiguration, \n\tImplicitAllowedTypes, \n\tImplicitFieldSchema, \n\tInput, \n\tInsertableTreeFieldFromImplicitField, \n\tInsertableTreeNodeFromAllowedTypes, \n\tInsertableTreeNodeFromImplicitAllowedTypes, \n\tInsertableTypedNode, \n\tInternalTreeNode, \n\tInternalTypes, \n\tIsListener, \n\tIsUnion, \n\tIterableTreeArrayContent, \n\tLazyItem, \n\tLeafSchema, \n\tListenable, \n\tListeners, \n\tMakeNominal, \n\tMapNodeInsertableData, \n\tNodeFromSchema, \n\tNodeInDocumentConstraint, \n\tNodeKind, \n\tNodeSchemaMetadata, \n\tNodeSchemaOptions, \n\tNumberKeys, \n\tObjectFromSchemaRecord, \n\tOff, \n\tReadonlyArrayNode, \n\tRestrictiveReadonlyRecord, \n\tRestrictiveStringRecord, \n\tRevertible, \n\tRevertibleFactory, \n\tRevertibleStatus, \n\tRunTransaction, \n\tSchemaCompatibilityStatus, \n\tSchemaFactory, \n\tSchemaFactory_base, \n\tSchemaStatics, \n\tSimpleNodeSchemaBase, \n\tSystem_Unsafe, \n\tTransactionConstraint, \n\tTree, \n\tTreeArrayNode, \n\tTreeChangeEvents, \n\tTreeFieldFromImplicitField, \n\tTreeLeafValue, \n\tTreeMapNode, \n\tTreeNode, \n\tTreeNodeApi, \n\tTreeNodeFromImplicitAllowedTypes, \n\tTreeNodeSchema, \n\tTreeNodeSchemaClass, \n\tTreeNodeSchemaCore, \n\tTreeNodeSchemaNonClass, \n\tTreeObjectNode, \n\tTreeStatus, \n\tTreeView, \n\tTreeViewConfiguration, \n\tTreeViewEvents, \n\tUnenforced, \n\tUnhydrated, \n\tUnionToIntersection, \n\tValidateRecursiveSchema, \n\tValidateRecursiveSchemaTemplate, \n\tViewableTree, \n\tWithType, \n\trollback, \n\ttypeSchemaSymbol,\n\t// #endregion\n \n\t// #region @beta APIs\n\tAllowedTypeMetadata, \n\tAllowedTypesFull, \n\tAllowedTypesFullEvaluated, \n\tAllowedTypesFullFromMixed, \n\tAllowedTypesFullFromMixedUnsafe, \n\tAllowedTypesMetadata, \n\tAnnotateAllowedTypesList, \n\tAnnotateAllowedTypesListUnsafe, \n\tAnnotatedAllowedType, \n\tAnnotatedAllowedTypeUnsafe, \n\tAnnotatedAllowedTypes, \n\tAnnotatedAllowedTypesUnsafe, \n\tCodecWriteOptionsBeta, \n\tConciseTree, \n\tExtensibleUnionNode, \n\tFixRecursiveArraySchema, \n\tFluidSerializableAsTree, \n\tForestOptions, \n\tForestType, \n\tForestTypeExpensiveDebug, \n\tForestTypeOptimized, \n\tForestTypeReference, \n\tIdentifierIndex, \n\tJsonCompatible, \n\tJsonCompatibleObject, \n\tKeyEncodingOptions, \n\tNodeChangedData, \n\tObjectSchemaOptions, \n\tPopUnion, \n\tRecordNodeInsertableData, \n\tRunTransactionParamsBeta, \n\tSchemaFactoryBeta, \n\tSchemaStaticsBeta, \n\tSchemaUpgrade, \n\tSharedTreeOptionsBeta, \n\tSnapshotFileSystem, \n\tSnapshotSchemaCompatibilityOptions, \n\tSystem_TableSchema, \n\tTableSchema, \n\tTransactionCallbackStatusBeta, \n\tTransactionResultFailed, \n\tTransactionResultSuccess, \n\tTransactionValueResult, \n\tTransactionVoidResult, \n\tTreeBeta, \n\tTreeBranch, \n\tTreeChangeEventsBeta, \n\tTreeEncodingOptions, \n\tTreeIndex, \n\tTreeIndexKey, \n\tTreeIndexNodes, \n\tTreeRecordNode, \n\tTreeRecordNodeUnsafe, \n\tTreeViewBeta, \n\tUnannotateAllowedTypeUnsafe, \n\tUnannotateAllowedTypesList, \n\tUnannotateAllowedTypesListUnsafe, \n\tUnionToTuple, \n\tVoidTransactionCallbackStatusBeta, \n\tWithValue, \n\tadaptEnum, \n\tasBeta, \n\tconfiguredSharedTreeBeta, \n\tcreateIdentifierIndex, \n\tcreateIndependentTreeBeta, \n\tcreateTreeIndex, \n\tenumFromStrings, \n\tsingletonSchema, \n\tsnapshotSchemaCompatibility,\n\t// #endregion\n \n\t// #region @alpha APIs\n\tAllowedTypesFullUnsafe, \n\tArrayNodeCustomizableSchema, \n\tArrayNodeCustomizableSchemaAlpha, \n\tArrayNodeCustomizableSchemaUnsafe, \n\tArrayNodeDeltaOp, \n\tArrayNodeInsertOp, \n\tArrayNodePojoEmulationSchema, \n\tArrayNodeRemoveOp, \n\tArrayNodeRetainOp, \n\tArrayNodeSchema, \n\tArrayNodeTreeChangedDeltaOp, \n\tArrayNodeTreeChangedRetainOp, \n\tArrayPlaceAnchor, \n\tChangeMetadata, \n\tCodecName, \n\tCodecWriteOptions, \n\tComponent, \n\tCreateIndependentTreeAlphaOptions, \n\tDirtyTreeMap, \n\tDirtyTreeStatus, \n\tErasedNode, \n\tErasedSchema, \n\tErasedSchemaSubclassable, \n\tFactoryContent, \n\tFactoryContentObject, \n\tFieldHasDefaultAlpha, \n\tFieldHasDefaultAlphaUnsafe, \n\tFieldPropsAlpha, \n\tFieldSchemaAlpha, \n\tFieldSchemaAlphaUnsafe, \n\tFluidClientVersion, \n\tFormatValidator, \n\tFormatValidatorBasic, \n\tFormatValidatorNoOp, \n\tFormatVersion, \n\tHandleConverter, \n\tICodecOptions, \n\tITreeAlpha, \n\tIncrementalEncodingPolicy, \n\tIndependentViewOptions, \n\tIndependentViewTelemetryOptions, \n\tInsertable, \n\tInsertableContent, \n\tInsertableField, \n\tInsertableObjectFromSchemaRecordAlpha, \n\tInsertableObjectFromSchemaRecordAlphaUnsafe, \n\tJsonArrayNodeSchema, \n\tJsonAsTree, \n\tJsonCompatibleReadOnly, \n\tJsonCompatibleReadOnlyObject, \n\tJsonFieldSchema, \n\tJsonLeafNodeSchema, \n\tJsonLeafSchemaType, \n\tJsonMapNodeSchema, \n\tJsonNodeSchema, \n\tJsonNodeSchemaBase, \n\tJsonObjectNodeSchema, \n\tJsonRecordNodeSchema, \n\tJsonRefPath, \n\tJsonSchemaId, \n\tJsonSchemaRef, \n\tJsonSchemaType, \n\tJsonStringKeyPatternProperties, \n\tJsonTreeSchema, \n\tLabelTree, \n\tLocalChangeMetadata, \n\tMapNodeCustomizableSchema, \n\tMapNodeCustomizableSchemaUnsafe, \n\tMapNodePojoEmulationSchema, \n\tMapNodeSchema, \n\tNoChangeConstraint, \n\tNodeChangedDataAlpha, \n\tNodeChangedDataDelta, \n\tNodeChangedDataProperties, \n\tNodeChangedDataTreeDelta, \n\tNodeProvider, \n\tNodeSchemaOptionsAlpha, \n\tObjectNodeSchema, \n\tObjectNodeSchemaWorkaround, \n\tObjectSchemaOptionsAlpha, \n\tObservationResults, \n\tReadSchema, \n\tReadableField, \n\tRecordNodeCustomizableSchema, \n\tRecordNodePojoEmulationSchema, \n\tRecordNodeSchema, \n\tRemoteChangeMetadata, \n\tRevertibleAlpha, \n\tRevertibleAlphaFactory, \n\tRunTransactionParamsAlpha, \n\tSchemaFactoryAlpha, \n\tSchemaStaticsAlpha, \n\tSchemaType, \n\tSharedTreeFormatOptions, \n\tSharedTreeOptions, \n\tSimpleAllowedTypeAttributes, \n\tSimpleArrayNodeSchema, \n\tSimpleFieldSchema, \n\tSimpleLeafNodeSchema, \n\tSimpleMapNodeSchema, \n\tSimpleNodeSchema, \n\tSimpleNodeSchemaBaseAlpha, \n\tSimpleObjectFieldSchema, \n\tSimpleObjectNodeSchema, \n\tSimpleRecordNodeSchema, \n\tSimpleTreeSchema, \n\tTextAsTree, \n\tTransactionCallbackStatusAlpha, \n\tTransactionConstraintAlpha, \n\tTransactionLabels, \n\tTransactionPostProcessor, \n\tTreeAlpha, \n\tTreeArrayNodeAlpha, \n\tTreeBranchAlpha, \n\tTreeBranchEvents, \n\tTreeChangeEventsAlpha, \n\tTreeCompressionStrategy, \n\tTreeContextAlpha, \n\tTreeIdentifierUtils, \n\tTreeMapNodeAlpha, \n\tTreeParsingOptions, \n\tTreeSchema, \n\tTreeSchemaEncodingOptions, \n\tTreeViewAlpha, \n\tTreeViewConfigurationAlpha, \n\tUnsafeUnknownSchema, \n\tValueSchema, \n\tVerboseTree, \n\tVerboseTreeNode, \n\tViewContent, \n\tVoidTransactionCallbackStatusAlpha, \n\tallowUnused, \n\tasAlpha, \n\tasTreeViewAlpha, \n\tcheckCompatibility, \n\tcloneWithReplacements, \n\tcomparePersistedSchema, \n\tconfiguredSharedTreeAlpha, \n\tcontentSchemaSymbol, \n\tcreateArrayInsertionAnchor, \n\tcreateIndependentTreeAlpha, \n\tdecodeSchemaCompatibilitySnapshot, \n\tencodeSchemaCompatibilitySnapshot, \n\teraseSchemaDetails, \n\teraseSchemaDetailsSubclassable, \n\tevaluateLazySchema, \n\texportCompatibilitySchemaSnapshot, \n\textractPersistedSchema, \n\tgenerateSchemaFromSimpleSchema, \n\tgetJsonSchema, \n\tgetSimpleSchema, \n\timportCompatibilitySchemaSnapshot, \n\tincrementalEncodingPolicyForAllowedTypes, \n\tincrementalSummaryHint, \n\tindependentInitializedView, \n\tindependentView, \n\tminimize, \n\tnormalizeAllowedTypes, \n\tpersistedToSimpleSchema, \n\treplaceConciseTreeHandles, \n\treplaceHandles, \n\treplaceVerboseTreeHandles, \n\ttrackDirtyNodes\n\t// #endregion\n} from \"../index.js\";\n"]}

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

@@ -2,36 +2,12 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import type { IIdCompressor, OpSpaceCompressedId, SessionSpaceCompressedId } from "@fluidframework/id-compressor";
 import type { Value, TreeChunk } from "../../../core/index.js";
+import { type IdDecodingContext } from "../../../util/index.js";
 import { type ChunkDecoder, type StreamCursor } from "./chunkCodecUtilities.js";
 import { DecoderContext } from "./chunkDecodingGeneric.js";
 import type { IncrementalDecoder } from "./codecs.js";
 import { type EncodedChunkShape, type EncodedChunkShapeV2, type EncodedFieldBatchV1OrV2, type EncodedInlineArrayShape, type EncodedNestedArrayShape, type EncodedNodeShape, type EncodedSpecializedNodeShape, type EncodedValueShape, type ShapeIndex } from "./format/index.js";
-/**
- * Context for decoding identifiers.
- * @remarks
- * See {@link FieldBatchDecodingContext} for the production implementation of this.
- *
- * This intentionally avoids exposing anything which depends on the underlying id-compressor's session ID to avoid confusion with the session ID of the compressor which encoded the data.
- * If the session ID of the encoder which encoded the data is known, that information is baked into `resolveEncodedId`.
- */
-export interface IdDecodingContext {
-    /**
-     * Compressor which can decompress session-space identifiers from {@link resolveEncodedId} as needed.
-     */
-    readonly idCompressor: Pick<IIdCompressor, "decompress">;
-    /**
-     * Resolves an encoded op-space identifier to either a session-space ID
-     * (which {@link idCompressor} can decompress if needed)
-     * or a string (which passes through unchanged).
-     * @remarks
-     * In contexts where non-final identifiers can't be supported (where no originator session is available),
-     * if a non-final identifier is encountered, this may throw or perform a data healing workaround.
-     * See {@link FieldBatchDecodingContext.forOp} and {@link FieldBatchDecodingContext.forSummary} for details.
-     */
-    readonly resolveEncodedId: (id: OpSpaceCompressedId) => SessionSpaceCompressedId | string;
-}
 /**
  * Decode `chunk` into a TreeChunk.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"chunkDecoding.d.ts","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/chunkDecoding.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"chunkDecoding.d.ts","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/chunkDecoding.ts"],"names":[],"mappings":"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"chunkDecoding.js","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/chunkDecoding.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, unreachableCase, oob } from \"@fluidframework/core-utils/internal\";\nimport type {\n\tIIdCompressor,\n\tOpSpaceCompressedId,\n\tSessionSpaceCompressedId,\n} from \"@fluidframework/id-compressor\";\n\nimport { DiscriminatedUnionDispatcher } from \"../../../codec/index.js\";\nimport type {\n\tFieldKey,\n\tTreeNodeSchemaIdentifier,\n\tValue,\n\tTreeChunk,\n} from \"../../../core/index.js\";\nimport { assertValidIndex, brand, decompressIdentifierIfNeeded } from \"../../../util/index.js\";\nimport { BasicChunk } from \"../basicChunk.js\";\nimport { emptyChunk } from \"../emptyChunk.js\";\nimport { SequenceChunk } from \"../sequenceChunk.js\";\n\nimport {\n\ttype ChunkDecoder,\n\ttype StreamCursor,\n\tgetChecked,\n\treadStream,\n\treadStreamBoolean,\n\treadStreamNumber,\n\treadStreamStream,\n\treadStreamValue,\n} from \"./chunkCodecUtilities.js\";\nimport {\n\tDecoderContext,\n\tdecode as genericDecode,\n\treadStreamIdentifier,\n} from \"./chunkDecodingGeneric.js\";\nimport type { IncrementalDecoder } from \"./codecs.js\";\nimport {\n\ttype EncodedAnyShape,\n\ttype EncodedChunkShape,\n\ttype EncodedChunkShapeV2,\n\ttype EncodedFieldBatchV1OrV2,\n\ttype EncodedFieldBatchV2,\n\ttype EncodedIncrementalChunkShape,\n\ttype EncodedInlineArrayShape,\n\ttype EncodedNestedArrayShape,\n\ttype EncodedNodeShape,\n\ttype EncodedSpecializedNodeShape,\n\ttype EncodedValueShape,\n\ttype ShapeIndex,\n\tSpecialField,\n\tsupportsIncrementalEncoding,\n} from \"./format/index.js\";\n\n/**\n * Context for decoding identifiers.\n * @remarks\n * See {@link FieldBatchDecodingContext} for the production implementation of this.\n *\n * This intentionally avoids exposing anything which depends on the underlying id-compressor's session ID to avoid confusion with the session ID of the compressor which encoded the data.\n * If the session ID of the encoder which encoded the data is known, that information is baked into `resolveEncodedId`.\n */\nexport interface IdDecodingContext {\n\t/**\n\t * Compressor which can decompress session-space identifiers from {@link resolveEncodedId} as needed.\n\t */\n\treadonly idCompressor: Pick<IIdCompressor, \"decompress\">;\n\t/**\n\t * Resolves an encoded op-space identifier to either a session-space ID\n\t * (which {@link idCompressor} can decompress if needed)\n\t * or a string (which passes through unchanged).\n\t * @remarks\n\t * In contexts where non-final identifiers can't be supported (where no originator session is available),\n\t * if a non-final identifier is encountered, this may throw or perform a data healing workaround.\n\t * See {@link FieldBatchDecodingContext.forOp} and {@link FieldBatchDecodingContext.forSummary} for details.\n\t */\n\treadonly resolveEncodedId: (id: OpSpaceCompressedId) => SessionSpaceCompressedId | string;\n}\n\n/**\n * Decode `chunk` into a TreeChunk.\n */\nexport function decode(\n\tchunk: EncodedFieldBatchV1OrV2,\n\tidDecodingContext: IdDecodingContext,\n\tincrementalDecoder?: IncrementalDecoder,\n): TreeChunk[] {\n\treturn genericDecode(\n\t\tdecoderLibrary,\n\t\tnew DecoderContext(chunk.identifiers, chunk.shapes, idDecodingContext, incrementalDecoder),\n\t\tchunk,\n\t\tanyDecoder,\n\t);\n}\n\n/**\n * Resolves `shapeIndex` to a fully-resolved {@link EncodedNodeShape}, normalizing away any\n * specialized node shapes (`f`) along the way by applying their overlays via\n * {@link applySpecialization} until a concrete node shape is reached.\n *\n * @param input - The index of the shape to resolve, which must be a concrete or specialized node shape.\n * @param context - The decoding context containing the shape definitions.\n * @param pendingResolution - (Internal) A set of shape indices visited so far in the current resolution chain, used to detect cycles in the specialization chain. Most callers should not provide this argument.\n *\n * @remarks\n * Exported for testing.\n */\nexport function normalizeToNodeShape(\n\tinput: EncodedNodeShape | EncodedSpecializedNodeShape,\n\tcontext: DecoderContext<EncodedChunkShape>,\n\tpendingResolution: Set<ShapeIndex> = new Set(),\n): EncodedNodeShape {\n\tif (!(\"base\" in input)) {\n\t\treturn input;\n\t}\n\n\tconst baseIndex = input.base;\n\tassert(!pendingResolution.has(baseIndex), 0xcfb /* cyclic specialized node shape chain */);\n\tpendingResolution.add(baseIndex);\n\tconst encoded = context.shapes[baseIndex];\n\tassert(encoded !== undefined, 0xcfc /* shape index out of bounds */);\n\n\tconst baseShape = encoded.c ?? (\"f\" in encoded ? encoded.f : undefined);\n\tassert(\n\t\tbaseShape !== undefined,\n\t\t0xcfd /* shape at index must be a concrete (c) or specialized (f) node shape */,\n\t);\n\n\treturn applySpecialization(\n\t\tnormalizeToNodeShape(baseShape, context, pendingResolution),\n\t\tinput,\n\t\tcontext,\n\t);\n}\n\n/**\n * Produces a specialized {@link EncodedNodeShape} by overlaying `overrides` onto `base`.\n *\n * See {@link EncodedSpecializedNodeShape} for the override/inherit/clear semantics.\n *\n * @remarks\n * Exported for testing.\n */\nexport function applySpecialization(\n\tbase: EncodedNodeShape,\n\toverrides: EncodedSpecializedNodeShape,\n\tcontext: DecoderContext<EncodedChunkShape>,\n): EncodedNodeShape {\n\tconst fields = [...(base.fields ?? [])];\n\tconst indexFromKey = new Map<FieldKey, number>();\n\tfor (const [i, [keyEncoded]] of fields.entries()) {\n\t\tconst key = context.identifier<FieldKey>(keyEncoded);\n\t\tassert(!indexFromKey.has(key), 0xcfe /* duplicate field key in base node shape */);\n\t\tindexFromKey.set(key, i);\n\t}\n\n\t// Replace fields in base with overrides, append new keys in overrides in the order they are specified.\n\tconst seenOverrideKeys = new Set<FieldKey>();\n\tfor (const [keyEncoded, shapeIndex] of overrides.fields ?? []) {\n\t\tconst key = context.identifier<FieldKey>(keyEncoded);\n\t\tassert(\n\t\t\t!seenOverrideKeys.has(key),\n\t\t\t0xcff /* duplicate field key in specialized node shape */,\n\t\t);\n\t\tseenOverrideKeys.add(key);\n\t\tconst existingIndex = indexFromKey.get(key);\n\t\tif (existingIndex === undefined) {\n\t\t\tfields.push([keyEncoded, shapeIndex]);\n\t\t} else {\n\t\t\tconst index = fields[existingIndex];\n\t\t\tassert(index !== undefined, 0xd00 /* expected existing field index */);\n\t\t\tfields[existingIndex] = [index[0], shapeIndex];\n\t\t}\n\t}\n\n\treturn {\n\t\ttype: base.type,\n\t\tvalue: resolveOverride(overrides.value, base.value),\n\t\tfields: fields.length > 0 ? fields : undefined,\n\t\textraFields: resolveOverride(overrides.extraFields, base.extraFields),\n\t};\n}\n\n/**\n * Resolves an override against a base value.\n *\n * @param override - `undefined` means the override is absent (inherit from base); `null` is the\n * explicit-clear sentinel needed because JSON.stringify drops `undefined`-valued properties, making\n * property-presence indistinguishable from absent on the wire.\n * @param baseValue - The value to inherit when the override is absent.\n */\nfunction resolveOverride<T>(\n\t// eslint-disable-next-line @rushstack/no-new-null\n\toverride: T | null | undefined,\n\tbaseValue: T | undefined,\n): T | undefined {\n\tif (override === undefined) {\n\t\treturn baseValue;\n\t}\n\tif (override === null) {\n\t\treturn undefined;\n\t}\n\treturn override;\n}\n\n/**\n * Decoder for {@link EncodedSpecializedNodeShape}s.\n * Applies the specialization's field overrides to the resolved base node shape, then delegates\n * to a {@link NodeDecoder} built from the resulting shape.\n */\nexport class SpecializedNodeDecoder implements ChunkDecoder {\n\tprivate readonly inner: NodeDecoder;\n\tpublic constructor(\n\t\tshape: EncodedSpecializedNodeShape,\n\t\tcontext: DecoderContext<EncodedChunkShape>,\n\t) {\n\t\tthis.inner = new NodeDecoder(normalizeToNodeShape(shape, context), context);\n\t}\n\tpublic decode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\treturn this.inner.decode(decoders, stream);\n\t}\n}\n\nconst decoderLibrary = new DiscriminatedUnionDispatcher<\n\tEncodedChunkShape,\n\t[context: DecoderContext<EncodedChunkShape>],\n\tChunkDecoder\n>({\n\ta(shape: EncodedNestedArrayShape, context): ChunkDecoder {\n\t\treturn new NestedArrayDecoder(shape);\n\t},\n\tb(shape: EncodedInlineArrayShape, context): ChunkDecoder {\n\t\treturn new InlineArrayDecoder(shape);\n\t},\n\tc(shape: EncodedNodeShape, context): ChunkDecoder {\n\t\treturn new NodeDecoder(shape, context);\n\t},\n\td(shape: EncodedAnyShape): ChunkDecoder {\n\t\treturn anyDecoder;\n\t},\n\te(\n\t\tshape: EncodedIncrementalChunkShape,\n\t\tcontext: DecoderContext<EncodedChunkShapeV2>,\n\t): ChunkDecoder {\n\t\treturn new IncrementalChunkDecoder(context);\n\t},\n\tf(shape: EncodedSpecializedNodeShape, context): ChunkDecoder {\n\t\treturn new SpecializedNodeDecoder(shape, context);\n\t},\n});\n\n/**\n * Decode a node's value from `stream` using its shape.\n */\nexport function readValue(\n\tstream: StreamCursor,\n\tshape: EncodedValueShape,\n\tidDecodingContext: IdDecodingContext,\n): Value {\n\tif (shape === undefined) {\n\t\treturn readStreamBoolean(stream) ? readStreamValue(stream) : undefined;\n\t} else {\n\t\tif (shape === true) {\n\t\t\treturn readStreamValue(stream);\n\t\t} else if (shape === false) {\n\t\t\treturn undefined;\n\t\t} else if (Array.isArray(shape)) {\n\t\t\tassert(shape.length === 1, 0x734 /* expected a single constant for value */);\n\t\t\treturn shape[0] as Value;\n\t\t} else if (shape === SpecialField.Identifier) {\n\t\t\t// This case is a special case handling the decoding of identifier fields.\n\t\t\tconst streamValue = readStream(stream);\n\t\t\tassert(\n\t\t\t\ttypeof streamValue === \"number\" || typeof streamValue === \"string\",\n\t\t\t\t0x997 /* identifier must be string or number. */,\n\t\t\t);\n\t\t\t// Strings (StableId UUIDs, heal-synthesized v5 UUIDs, or arbitrary user\n\t\t\t// identifier strings) are already in the stored form and pass through.\n\t\t\t// Op-space compressed ids are resolved by the caller-supplied\n\t\t\t// `resolveEncodedId`, which encapsulates the originator lookup, finalized-id\n\t\t\t// normalization, and (for the forest summarizer's heal path) UUIDv5 synthesis.\n\t\t\tconst sessionIdOrString: SessionSpaceCompressedId | string =\n\t\t\t\ttypeof streamValue === \"string\"\n\t\t\t\t\t? streamValue\n\t\t\t\t\t: idDecodingContext.resolveEncodedId(streamValue as OpSpaceCompressedId);\n\t\t\t// Performance:\n\t\t\t// Currently, we just fully expand the identifier here rather than keeping it in the SessionSpaceCompressedId format.\n\t\t\t// Avoiding this expansion, and keeping the in memory format using SessionSpaceCompressedId would be a good optimization for the future.\n\t\t\t// Keeping this optimization possible is why `resolveEncodedId` doesn't simply return a string.\n\t\t\treturn decompressIdentifierIfNeeded(sessionIdOrString, idDecodingContext.idCompressor);\n\t\t} else {\n\t\t\t// EncodedCounter case:\n\t\t\tunreachableCase(shape, \"decoding values as deltas is not yet supported\");\n\t\t}\n\t}\n}\n\n/**\n * Normalize a {@link TreeChunk} into an array.\n *\n * Unwraps {@link SequenceChunk}s, and wraps other chunks.\n */\nexport function deaggregateChunks(chunk: TreeChunk): TreeChunk[] {\n\tif (chunk === emptyChunk) {\n\t\treturn [];\n\t}\n\t// TODO: when handling of SequenceChunks has better performance (for example in cursors),\n\t// consider keeping SequenceChunks here if they are longer than some threshold.\n\tif (chunk instanceof SequenceChunk) {\n\t\t// Could return [] here, however the logic in this file is designed to never produce an empty SequenceChunk, so its better to throw an error here to detect bugs.\n\t\tassert(chunk.subChunks.length > 0, 0x735 /* Unexpected empty sequence */);\n\t\t// Logic in this file is designed to never produce an unneeded (single item) SequenceChunks, so its better to throw an error here to detect bugs.\n\t\tassert(chunk.subChunks.length > 1, 0x736 /* Unexpected single item sequence */);\n\n\t\tfor (const sub of chunk.subChunks) {\n\t\t\t// The logic in this file is designed to never produce an nested SequenceChunks or emptyChunk, so its better to throw an error here to detect bugs.\n\t\t\tassert(!(sub instanceof SequenceChunk), 0x737 /* unexpected nested sequence */);\n\t\t\tassert(sub !== emptyChunk, 0x738 /* unexpected empty chunk */);\n\n\t\t\tsub.referenceAdded();\n\t\t}\n\n\t\tchunk.referenceRemoved();\n\t\treturn chunk.subChunks;\n\t} else {\n\t\treturn [chunk];\n\t}\n}\n\n/**\n * Normalize a {@link TreeChunk}[] into a single TreeChunk.\n *\n * Avoids creating nested or less than 2 child {@link SequenceChunk}s.\n */\nexport function aggregateChunks(input: TreeChunk[]): TreeChunk {\n\tconst chunks = input.flatMap(deaggregateChunks);\n\tswitch (chunks.length) {\n\t\tcase 0: {\n\t\t\treturn emptyChunk;\n\t\t}\n\t\tcase 1: {\n\t\t\treturn chunks[0] ?? oob();\n\t\t}\n\t\tdefault: {\n\t\t\treturn new SequenceChunk(chunks);\n\t\t}\n\t}\n}\n\n/**\n * Decoder for {@link EncodedNestedArrayShape}s.\n */\nexport class NestedArrayDecoder implements ChunkDecoder {\n\tpublic constructor(private readonly shape: EncodedNestedArrayShape) {}\n\tpublic decode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\tconst decoder = decoders[this.shape] ?? oob();\n\n\t\t// TODO: uniform chunk fast path\n\t\tconst chunks: TreeChunk[] = [];\n\n\t\tconst data = readStream(stream);\n\t\tif (typeof data === \"number\") {\n\t\t\t// This case means that the array contained only 0-sized items, and was thus encoded as the length of the array.\n\t\t\tconst inner = { data: [], offset: 0 };\n\t\t\tfor (let index = 0; index < data; index++) {\n\t\t\t\tchunks.push(decoder.decode(decoders, inner));\n\t\t\t}\n\t\t} else {\n\t\t\tassert(\n\t\t\t\tArray.isArray(data),\n\t\t\t\t0x739 /* expected number of array for encoding of nested array */,\n\t\t\t);\n\t\t\tconst inner = { data, offset: 0 };\n\t\t\twhile (inner.offset !== inner.data.length) {\n\t\t\t\tchunks.push(decoder.decode(decoders, inner));\n\t\t\t}\n\t\t}\n\n\t\treturn aggregateChunks(chunks);\n\t}\n}\n\n/**\n * Decoder for {@link EncodedInlineArrayShape}s.\n */\nexport class InlineArrayDecoder implements ChunkDecoder {\n\tpublic constructor(private readonly shape: EncodedInlineArrayShape) {}\n\tpublic decode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\tconst length = this.shape.length;\n\t\tconst decoder = decoders[this.shape.shape] ?? oob();\n\t\tconst chunks: TreeChunk[] = [];\n\t\tfor (let index = 0; index < length; index++) {\n\t\t\tchunks.push(decoder.decode(decoders, stream));\n\t\t}\n\t\treturn aggregateChunks(chunks);\n\t}\n}\n\n/**\n * Decoder for {@link EncodedIncrementalChunkShape}s.\n */\nexport class IncrementalChunkDecoder implements ChunkDecoder {\n\tpublic constructor(private readonly context: DecoderContext<EncodedChunkShapeV2>) {}\n\tpublic decode(_: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\tassert(\n\t\t\tthis.context.incrementalDecoder !== undefined,\n\t\t\t0xc27 /* incremental decoder not available for incremental field decoding */,\n\t\t);\n\n\t\tconst chunkDecoder = (batch: EncodedFieldBatchV2): TreeChunk => {\n\t\t\tassert(\n\t\t\t\tsupportsIncrementalEncoding(batch.version),\n\t\t\t\t0xc9f /* Unsupported FieldBatchFormatVersion for incremental chunks; must be v2 or higher */,\n\t\t\t);\n\t\t\tconst context = new DecoderContext(\n\t\t\t\tbatch.identifiers,\n\t\t\t\tbatch.shapes,\n\t\t\t\tthis.context.idDecodingContext,\n\t\t\t\tthis.context.incrementalDecoder,\n\t\t\t);\n\t\t\tconst chunks = genericDecode(decoderLibrary, context, batch, anyDecoder);\n\t\t\treturn aggregateChunks(chunks);\n\t\t};\n\n\t\tconst chunkReferenceId = readStreamNumber(stream);\n\t\treturn this.context.incrementalDecoder.decodeIncrementalChunk(\n\t\t\tbrand(chunkReferenceId),\n\t\t\tchunkDecoder,\n\t\t);\n\t}\n}\n\n/**\n * Decoder for {@link EncodedAnyShape}s.\n */\nexport const anyDecoder: ChunkDecoder = {\n\tdecode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\tconst shapeIndex = readStreamNumber(stream);\n\t\tconst decoder = getChecked(decoders, shapeIndex);\n\t\treturn decoder.decode(decoders, stream);\n\t},\n};\n\n/**\n * Decoder for field.\n */\ntype BasicFieldDecoder = (\n\tdecoders: readonly ChunkDecoder[],\n\tstream: StreamCursor,\n) => [FieldKey, TreeChunk];\n\n/**\n * Get a decoder for fields of a provided (via `shape` and `context`).\n */\nfunction fieldDecoder(\n\tcontext: DecoderContext<EncodedChunkShape>,\n\tkey: FieldKey,\n\tshape: number,\n): BasicFieldDecoder {\n\tassertValidIndex(shape, context.shapes);\n\treturn (decoders, stream) => {\n\t\tconst decoder = decoders[shape] ?? oob();\n\t\treturn [key, decoder.decode(decoders, stream)];\n\t};\n}\n\n/**\n * Decoder for {@link EncodedNodeShape}s.\n */\nexport class NodeDecoder implements ChunkDecoder {\n\tprivate readonly type?: TreeNodeSchemaIdentifier;\n\tprivate readonly fieldDecoders: readonly BasicFieldDecoder[];\n\tpublic constructor(\n\t\tprivate readonly shape: EncodedNodeShape,\n\t\tprivate readonly context: DecoderContext<EncodedChunkShape>,\n\t) {\n\t\tthis.type = shape.type === undefined ? undefined : context.identifier(shape.type);\n\n\t\tconst fieldDecoders: BasicFieldDecoder[] = [];\n\t\tfor (const [fieldKey, fieldShape] of shape.fields ?? []) {\n\t\t\tconst key: FieldKey = context.identifier(fieldKey);\n\t\t\tfieldDecoders.push(fieldDecoder(context, key, fieldShape));\n\t\t}\n\t\tthis.fieldDecoders = fieldDecoders;\n\t}\n\tpublic decode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\tconst type: TreeNodeSchemaIdentifier =\n\t\t\tthis.type ?? readStreamIdentifier(stream, this.context);\n\t\t// TODO: Consider typechecking against stored schema in here somewhere.\n\n\t\tconst value = readValue(stream, this.shape.value, this.context.idDecodingContext);\n\t\tconst fields: Map<FieldKey, TreeChunk[]> = new Map();\n\n\t\t// Helper to add fields, but with unneeded array chunks removed.\n\t\tfunction addField(key: FieldKey, data: TreeChunk): void {\n\t\t\t// TODO: when handling of ArrayChunks has better performance (for example in cursors),\n\t\t\t// consider keeping array chunks here if they are longer than some threshold.\n\t\t\tconst chunks = deaggregateChunks(data);\n\n\t\t\tif (chunks.length > 0) {\n\t\t\t\tfields.set(key, chunks);\n\t\t\t}\n\t\t}\n\n\t\tfor (const decoder of this.fieldDecoders) {\n\t\t\tconst [key, content] = decoder(decoders, stream);\n\t\t\taddField(key, content);\n\t\t}\n\n\t\tif (this.shape.extraFields !== undefined) {\n\t\t\tconst decoder = decoders[this.shape.extraFields] ?? oob();\n\t\t\tconst inner = readStreamStream(stream);\n\t\t\twhile (inner.offset !== inner.data.length) {\n\t\t\t\tconst key: FieldKey = readStreamIdentifier(inner, this.context);\n\t\t\t\taddField(key, decoder.decode(decoders, inner));\n\t\t\t}\n\t\t}\n\n\t\treturn new BasicChunk(type, fields, value);\n\t}\n}\n"]}
+{"version":3,"file":"chunkDecoding.js","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/chunkDecoding.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, unreachableCase, oob } from \"@fluidframework/core-utils/internal\";\nimport type {\n\tOpSpaceCompressedId,\n\tSessionSpaceCompressedId,\n} from \"@fluidframework/id-compressor\";\n\nimport { DiscriminatedUnionDispatcher } from \"../../../codec/index.js\";\nimport type {\n\tFieldKey,\n\tTreeNodeSchemaIdentifier,\n\tValue,\n\tTreeChunk,\n} from \"../../../core/index.js\";\nimport {\n\tassertValidIndex,\n\tbrand,\n\tdecompressIdentifierIfNeeded,\n\ttype IdDecodingContext,\n} from \"../../../util/index.js\";\nimport { BasicChunk } from \"../basicChunk.js\";\nimport { emptyChunk } from \"../emptyChunk.js\";\nimport { SequenceChunk } from \"../sequenceChunk.js\";\n\nimport {\n\ttype ChunkDecoder,\n\ttype StreamCursor,\n\tgetChecked,\n\treadStream,\n\treadStreamBoolean,\n\treadStreamNumber,\n\treadStreamStream,\n\treadStreamValue,\n} from \"./chunkCodecUtilities.js\";\nimport {\n\tDecoderContext,\n\tdecode as genericDecode,\n\treadStreamIdentifier,\n} from \"./chunkDecodingGeneric.js\";\nimport type { IncrementalDecoder } from \"./codecs.js\";\nimport {\n\ttype EncodedAnyShape,\n\ttype EncodedChunkShape,\n\ttype EncodedChunkShapeV2,\n\ttype EncodedFieldBatchV1OrV2,\n\ttype EncodedFieldBatchV2,\n\ttype EncodedIncrementalChunkShape,\n\ttype EncodedInlineArrayShape,\n\ttype EncodedNestedArrayShape,\n\ttype EncodedNodeShape,\n\ttype EncodedSpecializedNodeShape,\n\ttype EncodedValueShape,\n\ttype ShapeIndex,\n\tSpecialField,\n\tsupportsIncrementalEncoding,\n} from \"./format/index.js\";\n\n/**\n * Decode `chunk` into a TreeChunk.\n */\nexport function decode(\n\tchunk: EncodedFieldBatchV1OrV2,\n\tidDecodingContext: IdDecodingContext,\n\tincrementalDecoder?: IncrementalDecoder,\n): TreeChunk[] {\n\treturn genericDecode(\n\t\tdecoderLibrary,\n\t\tnew DecoderContext(chunk.identifiers, chunk.shapes, idDecodingContext, incrementalDecoder),\n\t\tchunk,\n\t\tanyDecoder,\n\t);\n}\n\n/**\n * Resolves `shapeIndex` to a fully-resolved {@link EncodedNodeShape}, normalizing away any\n * specialized node shapes (`f`) along the way by applying their overlays via\n * {@link applySpecialization} until a concrete node shape is reached.\n *\n * @param input - The index of the shape to resolve, which must be a concrete or specialized node shape.\n * @param context - The decoding context containing the shape definitions.\n * @param pendingResolution - (Internal) A set of shape indices visited so far in the current resolution chain, used to detect cycles in the specialization chain. Most callers should not provide this argument.\n *\n * @remarks\n * Exported for testing.\n */\nexport function normalizeToNodeShape(\n\tinput: EncodedNodeShape | EncodedSpecializedNodeShape,\n\tcontext: DecoderContext<EncodedChunkShape>,\n\tpendingResolution: Set<ShapeIndex> = new Set(),\n): EncodedNodeShape {\n\tif (!(\"base\" in input)) {\n\t\treturn input;\n\t}\n\n\tconst baseIndex = input.base;\n\tassert(!pendingResolution.has(baseIndex), 0xcfb /* cyclic specialized node shape chain */);\n\tpendingResolution.add(baseIndex);\n\tconst encoded = context.shapes[baseIndex];\n\tassert(encoded !== undefined, 0xcfc /* shape index out of bounds */);\n\n\tconst baseShape = encoded.c ?? (\"f\" in encoded ? encoded.f : undefined);\n\tassert(\n\t\tbaseShape !== undefined,\n\t\t0xcfd /* shape at index must be a concrete (c) or specialized (f) node shape */,\n\t);\n\n\treturn applySpecialization(\n\t\tnormalizeToNodeShape(baseShape, context, pendingResolution),\n\t\tinput,\n\t\tcontext,\n\t);\n}\n\n/**\n * Produces a specialized {@link EncodedNodeShape} by overlaying `overrides` onto `base`.\n *\n * See {@link EncodedSpecializedNodeShape} for the override/inherit/clear semantics.\n *\n * @remarks\n * Exported for testing.\n */\nexport function applySpecialization(\n\tbase: EncodedNodeShape,\n\toverrides: EncodedSpecializedNodeShape,\n\tcontext: DecoderContext<EncodedChunkShape>,\n): EncodedNodeShape {\n\tconst fields = [...(base.fields ?? [])];\n\tconst indexFromKey = new Map<FieldKey, number>();\n\tfor (const [i, [keyEncoded]] of fields.entries()) {\n\t\tconst key = context.identifier<FieldKey>(keyEncoded);\n\t\tassert(!indexFromKey.has(key), 0xcfe /* duplicate field key in base node shape */);\n\t\tindexFromKey.set(key, i);\n\t}\n\n\t// Replace fields in base with overrides, append new keys in overrides in the order they are specified.\n\tconst seenOverrideKeys = new Set<FieldKey>();\n\tfor (const [keyEncoded, shapeIndex] of overrides.fields ?? []) {\n\t\tconst key = context.identifier<FieldKey>(keyEncoded);\n\t\tassert(\n\t\t\t!seenOverrideKeys.has(key),\n\t\t\t0xcff /* duplicate field key in specialized node shape */,\n\t\t);\n\t\tseenOverrideKeys.add(key);\n\t\tconst existingIndex = indexFromKey.get(key);\n\t\tif (existingIndex === undefined) {\n\t\t\tfields.push([keyEncoded, shapeIndex]);\n\t\t} else {\n\t\t\tconst index = fields[existingIndex];\n\t\t\tassert(index !== undefined, 0xd00 /* expected existing field index */);\n\t\t\tfields[existingIndex] = [index[0], shapeIndex];\n\t\t}\n\t}\n\n\treturn {\n\t\ttype: base.type,\n\t\tvalue: resolveOverride(overrides.value, base.value),\n\t\tfields: fields.length > 0 ? fields : undefined,\n\t\textraFields: resolveOverride(overrides.extraFields, base.extraFields),\n\t};\n}\n\n/**\n * Resolves an override against a base value.\n *\n * @param override - `undefined` means the override is absent (inherit from base); `null` is the\n * explicit-clear sentinel needed because JSON.stringify drops `undefined`-valued properties, making\n * property-presence indistinguishable from absent on the wire.\n * @param baseValue - The value to inherit when the override is absent.\n */\nfunction resolveOverride<T>(\n\t// eslint-disable-next-line @rushstack/no-new-null\n\toverride: T | null | undefined,\n\tbaseValue: T | undefined,\n): T | undefined {\n\tif (override === undefined) {\n\t\treturn baseValue;\n\t}\n\tif (override === null) {\n\t\treturn undefined;\n\t}\n\treturn override;\n}\n\n/**\n * Decoder for {@link EncodedSpecializedNodeShape}s.\n * Applies the specialization's field overrides to the resolved base node shape, then delegates\n * to a {@link NodeDecoder} built from the resulting shape.\n */\nexport class SpecializedNodeDecoder implements ChunkDecoder {\n\tprivate readonly inner: NodeDecoder;\n\tpublic constructor(\n\t\tshape: EncodedSpecializedNodeShape,\n\t\tcontext: DecoderContext<EncodedChunkShape>,\n\t) {\n\t\tthis.inner = new NodeDecoder(normalizeToNodeShape(shape, context), context);\n\t}\n\tpublic decode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\treturn this.inner.decode(decoders, stream);\n\t}\n}\n\nconst decoderLibrary = new DiscriminatedUnionDispatcher<\n\tEncodedChunkShape,\n\t[context: DecoderContext<EncodedChunkShape>],\n\tChunkDecoder\n>({\n\ta(shape: EncodedNestedArrayShape, context): ChunkDecoder {\n\t\treturn new NestedArrayDecoder(shape);\n\t},\n\tb(shape: EncodedInlineArrayShape, context): ChunkDecoder {\n\t\treturn new InlineArrayDecoder(shape);\n\t},\n\tc(shape: EncodedNodeShape, context): ChunkDecoder {\n\t\treturn new NodeDecoder(shape, context);\n\t},\n\td(shape: EncodedAnyShape): ChunkDecoder {\n\t\treturn anyDecoder;\n\t},\n\te(\n\t\tshape: EncodedIncrementalChunkShape,\n\t\tcontext: DecoderContext<EncodedChunkShapeV2>,\n\t): ChunkDecoder {\n\t\treturn new IncrementalChunkDecoder(context);\n\t},\n\tf(shape: EncodedSpecializedNodeShape, context): ChunkDecoder {\n\t\treturn new SpecializedNodeDecoder(shape, context);\n\t},\n});\n\n/**\n * Decode a node's value from `stream` using its shape.\n */\nexport function readValue(\n\tstream: StreamCursor,\n\tshape: EncodedValueShape,\n\tidDecodingContext: IdDecodingContext,\n): Value {\n\tif (shape === undefined) {\n\t\treturn readStreamBoolean(stream) ? readStreamValue(stream) : undefined;\n\t} else {\n\t\tif (shape === true) {\n\t\t\treturn readStreamValue(stream);\n\t\t} else if (shape === false) {\n\t\t\treturn undefined;\n\t\t} else if (Array.isArray(shape)) {\n\t\t\tassert(shape.length === 1, 0x734 /* expected a single constant for value */);\n\t\t\treturn shape[0] as Value;\n\t\t} else if (shape === SpecialField.Identifier) {\n\t\t\t// This case is a special case handling the decoding of identifier fields.\n\t\t\tconst streamValue = readStream(stream);\n\t\t\tassert(\n\t\t\t\ttypeof streamValue === \"number\" || typeof streamValue === \"string\",\n\t\t\t\t0x997 /* identifier must be string or number. */,\n\t\t\t);\n\t\t\t// Strings (StableId UUIDs, heal-synthesized v5 UUIDs, or arbitrary user\n\t\t\t// identifier strings) are already in the stored form and pass through.\n\t\t\t// Op-space compressed ids are resolved by the caller-supplied\n\t\t\t// `resolveEncodedId`, which encapsulates the originator lookup, finalized-id\n\t\t\t// normalization, and (for the forest summarizer's heal path) UUIDv5 synthesis.\n\t\t\tconst sessionIdOrString: SessionSpaceCompressedId | string =\n\t\t\t\ttypeof streamValue === \"string\"\n\t\t\t\t\t? streamValue\n\t\t\t\t\t: idDecodingContext.resolveEncodedId(streamValue as OpSpaceCompressedId);\n\t\t\t// Performance:\n\t\t\t// Currently, we just fully expand the identifier here rather than keeping it in the SessionSpaceCompressedId format.\n\t\t\t// Avoiding this expansion, and keeping the in memory format using SessionSpaceCompressedId would be a good optimization for the future.\n\t\t\t// Keeping this optimization possible is why `resolveEncodedId` doesn't simply return a string.\n\t\t\treturn decompressIdentifierIfNeeded(sessionIdOrString, idDecodingContext.idCompressor);\n\t\t} else {\n\t\t\t// EncodedCounter case:\n\t\t\tunreachableCase(shape, \"decoding values as deltas is not yet supported\");\n\t\t}\n\t}\n}\n\n/**\n * Normalize a {@link TreeChunk} into an array.\n *\n * Unwraps {@link SequenceChunk}s, and wraps other chunks.\n */\nexport function deaggregateChunks(chunk: TreeChunk): TreeChunk[] {\n\tif (chunk === emptyChunk) {\n\t\treturn [];\n\t}\n\t// TODO: when handling of SequenceChunks has better performance (for example in cursors),\n\t// consider keeping SequenceChunks here if they are longer than some threshold.\n\tif (chunk instanceof SequenceChunk) {\n\t\t// Could return [] here, however the logic in this file is designed to never produce an empty SequenceChunk, so its better to throw an error here to detect bugs.\n\t\tassert(chunk.subChunks.length > 0, 0x735 /* Unexpected empty sequence */);\n\t\t// Logic in this file is designed to never produce an unneeded (single item) SequenceChunks, so its better to throw an error here to detect bugs.\n\t\tassert(chunk.subChunks.length > 1, 0x736 /* Unexpected single item sequence */);\n\n\t\tfor (const sub of chunk.subChunks) {\n\t\t\t// The logic in this file is designed to never produce an nested SequenceChunks or emptyChunk, so its better to throw an error here to detect bugs.\n\t\t\tassert(!(sub instanceof SequenceChunk), 0x737 /* unexpected nested sequence */);\n\t\t\tassert(sub !== emptyChunk, 0x738 /* unexpected empty chunk */);\n\n\t\t\tsub.referenceAdded();\n\t\t}\n\n\t\tchunk.referenceRemoved();\n\t\treturn chunk.subChunks;\n\t} else {\n\t\treturn [chunk];\n\t}\n}\n\n/**\n * Normalize a {@link TreeChunk}[] into a single TreeChunk.\n *\n * Avoids creating nested or less than 2 child {@link SequenceChunk}s.\n */\nexport function aggregateChunks(input: TreeChunk[]): TreeChunk {\n\tconst chunks = input.flatMap(deaggregateChunks);\n\tswitch (chunks.length) {\n\t\tcase 0: {\n\t\t\treturn emptyChunk;\n\t\t}\n\t\tcase 1: {\n\t\t\treturn chunks[0] ?? oob();\n\t\t}\n\t\tdefault: {\n\t\t\treturn new SequenceChunk(chunks);\n\t\t}\n\t}\n}\n\n/**\n * Decoder for {@link EncodedNestedArrayShape}s.\n */\nexport class NestedArrayDecoder implements ChunkDecoder {\n\tpublic constructor(private readonly shape: EncodedNestedArrayShape) {}\n\tpublic decode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\tconst decoder = decoders[this.shape] ?? oob();\n\n\t\t// TODO: uniform chunk fast path\n\t\tconst chunks: TreeChunk[] = [];\n\n\t\tconst data = readStream(stream);\n\t\tif (typeof data === \"number\") {\n\t\t\t// This case means that the array contained only 0-sized items, and was thus encoded as the length of the array.\n\t\t\tconst inner = { data: [], offset: 0 };\n\t\t\tfor (let index = 0; index < data; index++) {\n\t\t\t\tchunks.push(decoder.decode(decoders, inner));\n\t\t\t}\n\t\t} else {\n\t\t\tassert(\n\t\t\t\tArray.isArray(data),\n\t\t\t\t0x739 /* expected number of array for encoding of nested array */,\n\t\t\t);\n\t\t\tconst inner = { data, offset: 0 };\n\t\t\twhile (inner.offset !== inner.data.length) {\n\t\t\t\tchunks.push(decoder.decode(decoders, inner));\n\t\t\t}\n\t\t}\n\n\t\treturn aggregateChunks(chunks);\n\t}\n}\n\n/**\n * Decoder for {@link EncodedInlineArrayShape}s.\n */\nexport class InlineArrayDecoder implements ChunkDecoder {\n\tpublic constructor(private readonly shape: EncodedInlineArrayShape) {}\n\tpublic decode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\tconst length = this.shape.length;\n\t\tconst decoder = decoders[this.shape.shape] ?? oob();\n\t\tconst chunks: TreeChunk[] = [];\n\t\tfor (let index = 0; index < length; index++) {\n\t\t\tchunks.push(decoder.decode(decoders, stream));\n\t\t}\n\t\treturn aggregateChunks(chunks);\n\t}\n}\n\n/**\n * Decoder for {@link EncodedIncrementalChunkShape}s.\n */\nexport class IncrementalChunkDecoder implements ChunkDecoder {\n\tpublic constructor(private readonly context: DecoderContext<EncodedChunkShapeV2>) {}\n\tpublic decode(_: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\tassert(\n\t\t\tthis.context.incrementalDecoder !== undefined,\n\t\t\t0xc27 /* incremental decoder not available for incremental field decoding */,\n\t\t);\n\n\t\tconst chunkDecoder = (batch: EncodedFieldBatchV2): TreeChunk => {\n\t\t\tassert(\n\t\t\t\tsupportsIncrementalEncoding(batch.version),\n\t\t\t\t0xc9f /* Unsupported FieldBatchFormatVersion for incremental chunks; must be v2 or higher */,\n\t\t\t);\n\t\t\tconst context = new DecoderContext(\n\t\t\t\tbatch.identifiers,\n\t\t\t\tbatch.shapes,\n\t\t\t\tthis.context.idDecodingContext,\n\t\t\t\tthis.context.incrementalDecoder,\n\t\t\t);\n\t\t\tconst chunks = genericDecode(decoderLibrary, context, batch, anyDecoder);\n\t\t\treturn aggregateChunks(chunks);\n\t\t};\n\n\t\tconst chunkReferenceId = readStreamNumber(stream);\n\t\treturn this.context.incrementalDecoder.decodeIncrementalChunk(\n\t\t\tbrand(chunkReferenceId),\n\t\t\tchunkDecoder,\n\t\t);\n\t}\n}\n\n/**\n * Decoder for {@link EncodedAnyShape}s.\n */\nexport const anyDecoder: ChunkDecoder = {\n\tdecode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\tconst shapeIndex = readStreamNumber(stream);\n\t\tconst decoder = getChecked(decoders, shapeIndex);\n\t\treturn decoder.decode(decoders, stream);\n\t},\n};\n\n/**\n * Decoder for field.\n */\ntype BasicFieldDecoder = (\n\tdecoders: readonly ChunkDecoder[],\n\tstream: StreamCursor,\n) => [FieldKey, TreeChunk];\n\n/**\n * Get a decoder for fields of a provided (via `shape` and `context`).\n */\nfunction fieldDecoder(\n\tcontext: DecoderContext<EncodedChunkShape>,\n\tkey: FieldKey,\n\tshape: number,\n): BasicFieldDecoder {\n\tassertValidIndex(shape, context.shapes);\n\treturn (decoders, stream) => {\n\t\tconst decoder = decoders[shape] ?? oob();\n\t\treturn [key, decoder.decode(decoders, stream)];\n\t};\n}\n\n/**\n * Decoder for {@link EncodedNodeShape}s.\n */\nexport class NodeDecoder implements ChunkDecoder {\n\tprivate readonly type?: TreeNodeSchemaIdentifier;\n\tprivate readonly fieldDecoders: readonly BasicFieldDecoder[];\n\tpublic constructor(\n\t\tprivate readonly shape: EncodedNodeShape,\n\t\tprivate readonly context: DecoderContext<EncodedChunkShape>,\n\t) {\n\t\tthis.type = shape.type === undefined ? undefined : context.identifier(shape.type);\n\n\t\tconst fieldDecoders: BasicFieldDecoder[] = [];\n\t\tfor (const [fieldKey, fieldShape] of shape.fields ?? []) {\n\t\t\tconst key: FieldKey = context.identifier(fieldKey);\n\t\t\tfieldDecoders.push(fieldDecoder(context, key, fieldShape));\n\t\t}\n\t\tthis.fieldDecoders = fieldDecoders;\n\t}\n\tpublic decode(decoders: readonly ChunkDecoder[], stream: StreamCursor): TreeChunk {\n\t\tconst type: TreeNodeSchemaIdentifier =\n\t\t\tthis.type ?? readStreamIdentifier(stream, this.context);\n\t\t// TODO: Consider typechecking against stored schema in here somewhere.\n\n\t\tconst value = readValue(stream, this.shape.value, this.context.idDecodingContext);\n\t\tconst fields: Map<FieldKey, TreeChunk[]> = new Map();\n\n\t\t// Helper to add fields, but with unneeded array chunks removed.\n\t\tfunction addField(key: FieldKey, data: TreeChunk): void {\n\t\t\t// TODO: when handling of ArrayChunks has better performance (for example in cursors),\n\t\t\t// consider keeping array chunks here if they are longer than some threshold.\n\t\t\tconst chunks = deaggregateChunks(data);\n\n\t\t\tif (chunks.length > 0) {\n\t\t\t\tfields.set(key, chunks);\n\t\t\t}\n\t\t}\n\n\t\tfor (const decoder of this.fieldDecoders) {\n\t\t\tconst [key, content] = decoder(decoders, stream);\n\t\t\taddField(key, content);\n\t\t}\n\n\t\tif (this.shape.extraFields !== undefined) {\n\t\t\tconst decoder = decoders[this.shape.extraFields] ?? oob();\n\t\t\tconst inner = readStreamStream(stream);\n\t\t\twhile (inner.offset !== inner.data.length) {\n\t\t\t\tconst key: FieldKey = readStreamIdentifier(inner, this.context);\n\t\t\t\taddField(key, decoder.decode(decoders, inner));\n\t\t\t}\n\t\t}\n\n\t\treturn new BasicChunk(type, fields, value);\n\t}\n}\n"]}

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

@@ -4,9 +4,8 @@
  */
 import type { DiscriminatedUnionDispatcher } from "../../../codec/index.js";
 import type { TreeChunk } from "../../../core/index.js";
-import type { BrandedType } from "../../../util/index.js";
+import type { BrandedType, IdDecodingContext } from "../../../util/index.js";
 import { type ChunkDecoder, type StreamCursor } from "./chunkCodecUtilities.js";
-import type { IdDecodingContext } from "./chunkDecoding.js";
 import type { IncrementalDecoder } from "./codecs.js";
 import type { EncodedFieldBatchGeneric, IdentifierOrIndex } from "./format/index.js";
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"chunkDecodingGeneric.d.ts","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/chunkDecodingGeneric.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE1D,OAAO,EACN,KAAK,YAAY,EACjB,KAAK,YAAY,EAGjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAErF;;GAEG;AACH,wBAAgB,MAAM,CAAC,aAAa,SAAS,MAAM,EAAE,QAAQ,EAC5D,cAAc,EAAE,4BAA4B,CAC3C,aAAa,EACb;IAAC,OAAO,EAAE,QAAQ;CAAC,EACnB,YAAY,CACZ,EACD,OAAO,EAAE,QAAQ,EACjB,KAAK,EAAE,wBAAwB,CAAC,aAAa,CAAC,EAC9C,WAAW,EAAE,YAAY,GACvB,SAAS,EAAE,CAcb;AAED;;GAEG;AACH,qBAAa,cAAc,CAAC,aAAa,GAAG,OAAO;IAEjD;;OAEG;aACa,WAAW,EAAE,SAAS,MAAM,EAAE;aAC9B,MAAM,EAAE,SAAS,aAAa,EAAE;aAChC,iBAAiB,EAAE,iBAAiB;IACpD;;;;OAIG;aACa,kBAAkB,EAAE,kBAAkB,GAAG,SAAS;;IAXlE;;OAEG;IACa,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,iBAAiB,EAAE,iBAAiB;IACpD;;;;OAIG;IACa,kBAAkB,EAAE,kBAAkB,GAAG,SAAS;IAG5D,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/D,OAAO,EAAE,iBAAiB,GACxB,CAAC;CAMJ;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAClF,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,cAAc,GACrB,CAAC,CAOH"}
+{"version":3,"file":"chunkDecodingGeneric.d.ts","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/chunkDecodingGeneric.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,yBAAyB,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAE7E,OAAO,EACN,KAAK,YAAY,EACjB,KAAK,YAAY,EAGjB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,wBAAwB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAErF;;GAEG;AACH,wBAAgB,MAAM,CAAC,aAAa,SAAS,MAAM,EAAE,QAAQ,EAC5D,cAAc,EAAE,4BAA4B,CAC3C,aAAa,EACb;IAAC,OAAO,EAAE,QAAQ;CAAC,EACnB,YAAY,CACZ,EACD,OAAO,EAAE,QAAQ,EACjB,KAAK,EAAE,wBAAwB,CAAC,aAAa,CAAC,EAC9C,WAAW,EAAE,YAAY,GACvB,SAAS,EAAE,CAcb;AAED;;GAEG;AACH,qBAAa,cAAc,CAAC,aAAa,GAAG,OAAO;IAEjD;;OAEG;aACa,WAAW,EAAE,SAAS,MAAM,EAAE;aAC9B,MAAM,EAAE,SAAS,aAAa,EAAE;aAChC,iBAAiB,EAAE,iBAAiB;IACpD;;;;OAIG;aACa,kBAAkB,EAAE,kBAAkB,GAAG,SAAS;;IAXlE;;OAEG;IACa,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,MAAM,EAAE,SAAS,aAAa,EAAE,EAChC,iBAAiB,EAAE,iBAAiB;IACpD;;;;OAIG;IACa,kBAAkB,EAAE,kBAAkB,GAAG,SAAS;IAG5D,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAC/D,OAAO,EAAE,iBAAiB,GACxB,CAAC;CAMJ;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,EAClF,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,cAAc,GACrB,CAAC,CAOH"}

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

@@ -1 +1 @@
-{"version":3,"file":"chunkDecodingGeneric.js","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/chunkDecodingGeneric.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAM7D,qEAKkC;AAKlC;;GAEG;AACH,SAAgB,MAAM,CACrB,cAIC,EACD,OAAiB,EACjB,KAA8C,EAC9C,WAAyB;IAEzB,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;IACtF,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;QAChC,MAAM,MAAM,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;QAC1C,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACpD,IAAA,iBAAM,EACL,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,CAAC,MAAM,EACpC,KAAK,CAAC,4CAA4C,CAClD,CAAC;QACF,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACrB,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC;AAvBD,wBAuBC;AAED;;GAEG;AACH,MAAa,cAAc;IAC1B;IACC;;OAEG;IACa,WAA8B,EAC9B,MAAgC,EAChC,iBAAoC;IACpD;;;;OAIG;IACa,kBAAkD;QARlD,gBAAW,GAAX,WAAW,CAAmB;QAC9B,WAAM,GAAN,MAAM,CAA0B;QAChC,sBAAiB,GAAjB,iBAAiB,CAAmB;QAMpC,uBAAkB,GAAlB,kBAAkB,CAAgC;IAChE,CAAC;IAEG,UAAU,CAChB,OAA0B;QAE1B,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YACjC,OAAO,OAAY,CAAC;QACrB,CAAC;QACD,OAAO,IAAA,mCAAU,EAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAM,CAAC;IACnD,CAAC;CACD;AAxBD,wCAwBC;AAED;;GAEG;AACH,SAAgB,oBAAoB,CACnC,MAAoB,EACpB,OAAuB;IAEvB,MAAM,OAAO,GAAG,IAAA,mCAAU,EAAC,MAAM,CAAC,CAAC;IACnC,IAAA,iBAAM,EACL,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,OAAO,KAAK,QAAQ,EAC1D,KAAK,CAAC,sCAAsC,CAC5C,CAAC;IACF,OAAO,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;AACpC,CAAC;AAVD,oDAUC","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\";\n\nimport type { DiscriminatedUnionDispatcher } from \"../../../codec/index.js\";\nimport type { TreeChunk } from \"../../../core/index.js\";\nimport type { BrandedType } from \"../../../util/index.js\";\n\nimport {\n\ttype ChunkDecoder,\n\ttype StreamCursor,\n\tgetChecked,\n\treadStream,\n} from \"./chunkCodecUtilities.js\";\nimport type { IdDecodingContext } from \"./chunkDecoding.js\";\nimport type { IncrementalDecoder } from \"./codecs.js\";\nimport type { EncodedFieldBatchGeneric, IdentifierOrIndex } from \"./format/index.js\";\n\n/**\n * General purpose shape based tree decoder which gets its support for specific shapes from the caller.\n */\nexport function decode<TEncodedShape extends object, TContext>(\n\tdecoderLibrary: DiscriminatedUnionDispatcher<\n\t\tTEncodedShape,\n\t\t[context: TContext],\n\t\tChunkDecoder\n\t>,\n\tcontext: TContext,\n\tbatch: EncodedFieldBatchGeneric<TEncodedShape>,\n\trootDecoder: ChunkDecoder,\n): TreeChunk[] {\n\tconst decoders = batch.shapes.map((shape) => decoderLibrary.dispatch(shape, context));\n\tconst chunks: TreeChunk[] = [];\n\tfor (const field of batch.data) {\n\t\tconst stream = { data: field, offset: 0 };\n\t\tconst result = rootDecoder.decode(decoders, stream);\n\t\tassert(\n\t\t\tstream.offset === stream.data.length,\n\t\t\t0x73a /* expected decode to consume full stream */,\n\t\t);\n\t\tchunks.push(result);\n\t}\n\n\treturn chunks;\n}\n\n/**\n * Shared data for use in constructing decoders.\n */\nexport class DecoderContext<TEncodedShape = unknown> {\n\tpublic constructor(\n\t\t/**\n\t\t * Identifier substitution table (use to replace numeric identifier indexes with the actual identifiers from this table).\n\t\t */\n\t\tpublic readonly identifiers: readonly string[],\n\t\tpublic readonly shapes: readonly TEncodedShape[],\n\t\tpublic readonly idDecodingContext: IdDecodingContext,\n\t\t/**\n\t\t * To be used to decode incremental chunks, if any.\n\t\t * @remarks\n\t\t * See {@link IncrementalDecoder} for more information.\n\t\t */\n\t\tpublic readonly incrementalDecoder: IncrementalDecoder | undefined,\n\t) {}\n\n\tpublic identifier<T extends string & BrandedType<string, string>>(\n\t\tencoded: IdentifierOrIndex,\n\t): T {\n\t\tif (typeof encoded === \"string\") {\n\t\t\treturn encoded as T;\n\t\t}\n\t\treturn getChecked(this.identifiers, encoded) as T;\n\t}\n}\n\n/**\n * Read one identifier from the stream, advancing the stream offset.\n */\nexport function readStreamIdentifier<T extends string & BrandedType<string, string>>(\n\tstream: StreamCursor,\n\tcontext: DecoderContext,\n): T {\n\tconst content = readStream(stream);\n\tassert(\n\t\ttypeof content === \"number\" || typeof content === \"string\",\n\t\t0x73b /* content to be a number or string */,\n\t);\n\treturn context.identifier(content);\n}\n"]}
+{"version":3,"file":"chunkDecodingGeneric.js","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/chunkDecodingGeneric.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,kEAA6D;AAM7D,qEAKkC;AAIlC;;GAEG;AACH,SAAgB,MAAM,CACrB,cAIC,EACD,OAAiB,EACjB,KAA8C,EAC9C,WAAyB;IAEzB,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;IACtF,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;QAChC,MAAM,MAAM,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;QAC1C,MAAM,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QACpD,IAAA,iBAAM,EACL,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,CAAC,MAAM,EACpC,KAAK,CAAC,4CAA4C,CAClD,CAAC;QACF,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACrB,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC;AAvBD,wBAuBC;AAED;;GAEG;AACH,MAAa,cAAc;IAC1B;IACC;;OAEG;IACa,WAA8B,EAC9B,MAAgC,EAChC,iBAAoC;IACpD;;;;OAIG;IACa,kBAAkD;QARlD,gBAAW,GAAX,WAAW,CAAmB;QAC9B,WAAM,GAAN,MAAM,CAA0B;QAChC,sBAAiB,GAAjB,iBAAiB,CAAmB;QAMpC,uBAAkB,GAAlB,kBAAkB,CAAgC;IAChE,CAAC;IAEG,UAAU,CAChB,OAA0B;QAE1B,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;YACjC,OAAO,OAAY,CAAC;QACrB,CAAC;QACD,OAAO,IAAA,mCAAU,EAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAM,CAAC;IACnD,CAAC;CACD;AAxBD,wCAwBC;AAED;;GAEG;AACH,SAAgB,oBAAoB,CACnC,MAAoB,EACpB,OAAuB;IAEvB,MAAM,OAAO,GAAG,IAAA,mCAAU,EAAC,MAAM,CAAC,CAAC;IACnC,IAAA,iBAAM,EACL,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,OAAO,KAAK,QAAQ,EAC1D,KAAK,CAAC,sCAAsC,CAC5C,CAAC;IACF,OAAO,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;AACpC,CAAC;AAVD,oDAUC","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\";\n\nimport type { DiscriminatedUnionDispatcher } from \"../../../codec/index.js\";\nimport type { TreeChunk } from \"../../../core/index.js\";\nimport type { BrandedType, IdDecodingContext } from \"../../../util/index.js\";\n\nimport {\n\ttype ChunkDecoder,\n\ttype StreamCursor,\n\tgetChecked,\n\treadStream,\n} from \"./chunkCodecUtilities.js\";\nimport type { IncrementalDecoder } from \"./codecs.js\";\nimport type { EncodedFieldBatchGeneric, IdentifierOrIndex } from \"./format/index.js\";\n\n/**\n * General purpose shape based tree decoder which gets its support for specific shapes from the caller.\n */\nexport function decode<TEncodedShape extends object, TContext>(\n\tdecoderLibrary: DiscriminatedUnionDispatcher<\n\t\tTEncodedShape,\n\t\t[context: TContext],\n\t\tChunkDecoder\n\t>,\n\tcontext: TContext,\n\tbatch: EncodedFieldBatchGeneric<TEncodedShape>,\n\trootDecoder: ChunkDecoder,\n): TreeChunk[] {\n\tconst decoders = batch.shapes.map((shape) => decoderLibrary.dispatch(shape, context));\n\tconst chunks: TreeChunk[] = [];\n\tfor (const field of batch.data) {\n\t\tconst stream = { data: field, offset: 0 };\n\t\tconst result = rootDecoder.decode(decoders, stream);\n\t\tassert(\n\t\t\tstream.offset === stream.data.length,\n\t\t\t0x73a /* expected decode to consume full stream */,\n\t\t);\n\t\tchunks.push(result);\n\t}\n\n\treturn chunks;\n}\n\n/**\n * Shared data for use in constructing decoders.\n */\nexport class DecoderContext<TEncodedShape = unknown> {\n\tpublic constructor(\n\t\t/**\n\t\t * Identifier substitution table (use to replace numeric identifier indexes with the actual identifiers from this table).\n\t\t */\n\t\tpublic readonly identifiers: readonly string[],\n\t\tpublic readonly shapes: readonly TEncodedShape[],\n\t\tpublic readonly idDecodingContext: IdDecodingContext,\n\t\t/**\n\t\t * To be used to decode incremental chunks, if any.\n\t\t * @remarks\n\t\t * See {@link IncrementalDecoder} for more information.\n\t\t */\n\t\tpublic readonly incrementalDecoder: IncrementalDecoder | undefined,\n\t) {}\n\n\tpublic identifier<T extends string & BrandedType<string, string>>(\n\t\tencoded: IdentifierOrIndex,\n\t): T {\n\t\tif (typeof encoded === \"string\") {\n\t\t\treturn encoded as T;\n\t\t}\n\t\treturn getChecked(this.identifiers, encoded) as T;\n\t}\n}\n\n/**\n * Read one identifier from the stream, advancing the stream offset.\n */\nexport function readStreamIdentifier<T extends string & BrandedType<string, string>>(\n\tstream: StreamCursor,\n\tcontext: DecoderContext,\n): T {\n\tconst content = readStream(stream);\n\tassert(\n\t\ttypeof content === \"number\" || typeof content === \"string\",\n\t\t0x73b /* content to be a number or string */,\n\t);\n\treturn context.identifier(content);\n}\n"]}