@fluidframework/tree 2.51.0 → 2.52.0

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

@@ -9,11 +9,11 @@ export declare const validVersions: Set<number>;
  * Top level length is implied from length of data array.
  * All content are of this shape.
  */
-export declare const EncodedNestedArray: import("@sinclair/typebox").TNumber;
+export declare const EncodedNestedArrayShape: import("@sinclair/typebox").TNumber;
 /**
  * Inline array.
  */
-export declare const EncodedInlineArray: import("@sinclair/typebox").TObject<{
+export declare const EncodedInlineArrayShape: import("@sinclair/typebox").TObject<{
     length: import("@sinclair/typebox").TNumber;
     /**
      * All entries are this shape.
@@ -80,11 +80,11 @@ export declare enum SpecialField {
  * In the future other value shape formats may be added, likely as objects.
  *
  * @remarks
- * See {@link EncodedTreeShape} for usage.
+ * See {@link EncodedNodeShape} for usage.
  */
 export declare const EncodedValueShape: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TBoolean, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TAny>, import("@sinclair/typebox").TEnum<typeof SpecialField>]>;
 export type EncodedValueShape = undefined | Static<typeof EncodedValueShape>;
-export declare const EncodedTreeShape: import("@sinclair/typebox").TObject<{
+export declare const EncodedNodeShape: import("@sinclair/typebox").TObject<{
     /**
      * If not provided, inlined in data.
      */
@@ -103,17 +103,23 @@ export declare const EncodedTreeShape: import("@sinclair/typebox").TObject<{
     extraFields: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
 }>;
 /**
- * Discriminated union of chunk shapes.
+ * Discriminated union that represents the shapes of chunks in the encoded data.
+ * "Chunk" here refers to a chunk of tree data, rooted at a range of nodes, that is encoded as a
+ * single unit in a specific format represented by one of the shapes in this union.
+ *
+ * The concept of "chunk" is same for the tree data in memory and in the encoded wire format.
+ * The physical representation of the chunk may differ, but the logical structure remains the same.
+ * This is similar to other such concepts in the system.
  *
  * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.
  */
 export declare const EncodedChunkShape: import("@sinclair/typebox").TObject<{
     /**
-     * {@link EncodedNestedArray} union member.
+     * {@link EncodedNestedArrayShape} union member.
      */
     a: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     /**
-     * {@link EncodedInlineArray} union member.
+     * {@link EncodedInlineArrayShape} union member.
      */
     b: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
         length: import("@sinclair/typebox").TNumber;
@@ -123,7 +129,7 @@ export declare const EncodedChunkShape: import("@sinclair/typebox").TObject<{
         shape: import("@sinclair/typebox").TNumber;
     }>>;
     /**
-     * {@link EncodedTreeShape} union member.
+     * {@link EncodedNodeShape} union member.
      */
     c: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
         /**
@@ -149,9 +155,9 @@ export declare const EncodedChunkShape: import("@sinclair/typebox").TObject<{
     d: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TLiteral<0>>;
 }>;
 export type EncodedChunkShape = Static<typeof EncodedChunkShape>;
-export type EncodedNestedArray = Static<typeof EncodedNestedArray>;
-export type EncodedInlineArray = Static<typeof EncodedInlineArray>;
-export type EncodedTreeShape = Static<typeof EncodedTreeShape>;
+export type EncodedNestedArrayShape = Static<typeof EncodedNestedArrayShape>;
+export type EncodedInlineArrayShape = Static<typeof EncodedInlineArrayShape>;
+export type EncodedNodeShape = Static<typeof EncodedNodeShape>;
 export type EncodedAnyShape = Static<typeof EncodedAnyShape>;
 export declare const EncodedFieldBatch: import("@sinclair/typebox").TObject<{
     data: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TAny>>;
@@ -159,11 +165,11 @@ export declare const EncodedFieldBatch: import("@sinclair/typebox").TObject<{
     identifiers: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
     shapes: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
         /**
-         * {@link EncodedNestedArray} union member.
+         * {@link EncodedNestedArrayShape} union member.
          */
         a: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
         /**
-         * {@link EncodedInlineArray} union member.
+         * {@link EncodedInlineArrayShape} union member.
          */
         b: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
             length: import("@sinclair/typebox").TNumber;
@@ -173,7 +179,7 @@ export declare const EncodedFieldBatch: import("@sinclair/typebox").TObject<{
             shape: import("@sinclair/typebox").TNumber;
         }>>;
         /**
-         * {@link EncodedTreeShape} union member.
+         * {@link EncodedNodeShape} union member.
          */
         c: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
             /**

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

@@ -1 +1 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/format.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAQ,MAAM,mBAAmB,CAAC;AAWtD,eAAO,MAAM,OAAO,IAAI,CAAC;AAIzB,eAAO,MAAM,aAAa,aAAqB,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,qCAAa,CAAC;AAE7C;;GAEG;AACH,eAAO,MAAM,kBAAkB;;IAG7B;;OAEG;;EAIJ,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,yCAAkB,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,2LAS5B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEjE,aAAK,iBAAiB;IAErB,qCAAqC,IAAA;CAErC;AAED,aAAK,WAAW;IACf,MAAM,IAAA;IAEN,IAAI,IAAA;CACJ;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;EAQ1B,CAAC;AAEF;;GAEG;AACH,oBAAY,YAAY;IACvB;;OAEG;IACH,UAAU,IAAI;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,iBAAiB,0MAM5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE7E,eAAO,MAAM,gBAAgB;IAE3B;;OAEG;;;IAGH;;;;OAIG;;IAEH;;;OAGG;;EAIJ,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;IAE5B;;OAEG;;IAEH;;OAEG;;;QAzIH;;WAEG;;;IAyIH;;OAEG;;QArCH;;WAEG;;;QAGH;;;;WAIG;;QAEH;;;WAGG;;;IAyBH;;OAEG;;EAIJ,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEjE,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACnE,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACnE,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAE7D,eAAO,MAAM,iBAAiB;;;;;QA3B5B;;WAEG;;QAEH;;WAEG;;;YAzIH;;eAEG;;;QAyIH;;WAEG;;YArCH;;eAEG;;;YAGH;;;;eAIG;;YAEH;;;eAGG;;;QAyBH;;WAEG;;;EAagF,CAAC;AACtF,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/format.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAQ,MAAM,mBAAmB,CAAC;AAWtD,eAAO,MAAM,OAAO,IAAI,CAAC;AAIzB,eAAO,MAAM,aAAa,aAAqB,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,qCAAa,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,uBAAuB;;IAGlC;;OAEG;;EAIJ,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,yCAAkB,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,iBAAiB,2LAS5B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEjE,aAAK,iBAAiB;IAErB,qCAAqC,IAAA;CAErC;AAED,aAAK,WAAW;IACf,MAAM,IAAA;IAEN,IAAI,IAAA;CACJ;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;EAQ1B,CAAC;AAEF;;GAEG;AACH,oBAAY,YAAY;IACvB;;OAEG;IACH,UAAU,IAAI;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,iBAAiB,0MAM5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE7E,eAAO,MAAM,gBAAgB;IAE3B;;OAEG;;;IAGH;;;;OAIG;;IAEH;;;OAGG;;EAIJ,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB;IAE5B;;OAEG;;IAEH;;OAEG;;;QA/IH;;WAEG;;;IA+IH;;OAEG;;QA3CH;;WAEG;;;QAGH;;;;WAIG;;QAEH;;;WAGG;;;IA+BH;;OAEG;;EAIJ,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEjE,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC7E,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC7E,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,OAAO,eAAe,CAAC,CAAC;AAE7D,eAAO,MAAM,iBAAiB;;;;;QA3B5B;;WAEG;;QAEH;;WAEG;;;YA/IH;;eAEG;;;QA+IH;;WAEG;;YA3CH;;eAEG;;;YAGH;;;;eAIG;;YAEH;;;eAGG;;;QA+BH;;WAEG;;;EAagF,CAAC;AACtF,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/feature-libraries/chunked-forest/codec/format.js

@@ -4,7 +4,7 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EncodedFieldBatch = exports.EncodedChunkShape = exports.EncodedTreeShape = exports.EncodedValueShape = exports.SpecialField = exports.EncodedCounter = exports.EncodedFieldShape = exports.EncodedAnyShape = exports.EncodedInlineArray = exports.EncodedNestedArray = exports.validVersions = exports.version = void 0;
+exports.EncodedFieldBatch = exports.EncodedChunkShape = exports.EncodedNodeShape = exports.EncodedValueShape = exports.SpecialField = exports.EncodedCounter = exports.EncodedFieldShape = exports.EncodedAnyShape = exports.EncodedInlineArrayShape = exports.EncodedNestedArrayShape = exports.validVersions = exports.version = void 0;
 const typebox_1 = require("@sinclair/typebox");
 const index_js_1 = require("../../../codec/index.js");
 const formatGeneric_js_1 = require("./formatGeneric.js");
@@ -16,11 +16,11 @@ exports.validVersions = new Set([exports.version]);
  * Top level length is implied from length of data array.
  * All content are of this shape.
  */
-exports.EncodedNestedArray = formatGeneric_js_1.ShapeIndex;
+exports.EncodedNestedArrayShape = formatGeneric_js_1.ShapeIndex;
 /**
  * Inline array.
  */
-exports.EncodedInlineArray = typebox_1.Type.Object({
+exports.EncodedInlineArrayShape = typebox_1.Type.Object({
     length: formatGeneric_js_1.Count,
     /**
      * All entries are this shape.
@@ -102,7 +102,7 @@ var SpecialField;
  * In the future other value shape formats may be added, likely as objects.
  *
  * @remarks
- * See {@link EncodedTreeShape} for usage.
+ * See {@link EncodedNodeShape} for usage.
  */
 exports.EncodedValueShape = typebox_1.Type.Union([
     typebox_1.Type.Boolean(),
@@ -111,7 +111,7 @@ exports.EncodedValueShape = typebox_1.Type.Union([
     // TODO: support delta encoding and/or special node identifier handling
     // EncodedCounter,
 ]);
-exports.EncodedTreeShape = typebox_1.Type.Object({
+exports.EncodedNodeShape = typebox_1.Type.Object({
     /**
      * If not provided, inlined in data.
      */
@@ -130,23 +130,29 @@ exports.EncodedTreeShape = typebox_1.Type.Object({
     extraFields: typebox_1.Type.Optional(formatGeneric_js_1.ShapeIndex),
 }, { additionalProperties: false });
 /**
- * Discriminated union of chunk shapes.
+ * Discriminated union that represents the shapes of chunks in the encoded data.
+ * "Chunk" here refers to a chunk of tree data, rooted at a range of nodes, that is encoded as a
+ * single unit in a specific format represented by one of the shapes in this union.
+ *
+ * The concept of "chunk" is same for the tree data in memory and in the encoded wire format.
+ * The physical representation of the chunk may differ, but the logical structure remains the same.
+ * This is similar to other such concepts in the system.
  *
  * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.
  */
 exports.EncodedChunkShape = typebox_1.Type.Object({
     /**
-     * {@link EncodedNestedArray} union member.
+     * {@link EncodedNestedArrayShape} union member.
      */
-    a: typebox_1.Type.Optional(exports.EncodedNestedArray),
+    a: typebox_1.Type.Optional(exports.EncodedNestedArrayShape),
     /**
-     * {@link EncodedInlineArray} union member.
+     * {@link EncodedInlineArrayShape} union member.
      */
-    b: typebox_1.Type.Optional(exports.EncodedInlineArray),
+    b: typebox_1.Type.Optional(exports.EncodedInlineArrayShape),
     /**
-     * {@link EncodedTreeShape} union member.
+     * {@link EncodedNodeShape} union member.
      */
-    c: typebox_1.Type.Optional(exports.EncodedTreeShape),
+    c: typebox_1.Type.Optional(exports.EncodedNodeShape),
     /**
      * {@link EncodedAnyShape} union member.
      */

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

@@ -1 +1 @@
-{"version":3,"file":"format.js","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/format.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 { type Static, Type } from \"@sinclair/typebox\";\n\nimport { unionOptions } from \"../../../codec/index.js\";\n\nimport {\n\tCount,\n\tEncodedFieldBatchGeneric,\n\tIdentifierOrIndex,\n\tShapeIndex,\n} from \"./formatGeneric.js\";\n\nexport const version = 1;\n\n// Compatible versions used for format/version validation.\n// TODO: A proper version update policy will need to be documented.\nexport const validVersions = new Set([version]);\n\n/**\n * Top level length is implied from length of data array.\n * All content are of this shape.\n */\nexport const EncodedNestedArray = ShapeIndex;\n\n/**\n * Inline array.\n */\nexport const EncodedInlineArray = Type.Object(\n\t{\n\t\tlength: Count,\n\t\t/**\n\t\t * All entries are this shape.\n\t\t */\n\t\tshape: ShapeIndex,\n\t},\n\t{ additionalProperties: false },\n);\n\n/**\n * Encoded as `shape, ...[data for shape]`.\n *\n * Used for polymorphism.\n */\nexport const EncodedAnyShape = Type.Literal(0);\n\n/**\n * Content of the encoded field is specified by the Shape referenced by the ShapeIndex.\n * This is a tuple for conciseness.\n */\nexport const EncodedFieldShape = Type.Tuple([\n\t/**\n\t * Field key for this field.\n\t */\n\tIdentifierOrIndex,\n\t/**\n\t * Shape of data in this field.\n\t */\n\tShapeIndex,\n]);\n\nexport type EncodedFieldShape = Static<typeof EncodedFieldShape>;\n\nenum CounterRelativeTo {\n\t// Relative to previous node of same type in depth first pre-order traversal.\n\tPreviousNodeOfType_DepthFirstPreOrder,\n\t// TODO: add alternative relative mode relative to previous note at a path to allow delta encoded sequences (like points where x and y are delta encoded relative to previous points).\n}\n\nenum CounterMode {\n\tNumber,\n\t// TODO: document wrap modes and bit skipping. Note UUID subVersion here (ex: UUIDv4)\n\tUUID,\n}\n\n/**\n * Delta encoded value relative to a previous node's value.\n */\nexport const EncodedCounter = Type.Object(\n\t{\n\t\trelativeTo: Type.Enum(CounterRelativeTo),\n\t\t// If not provided, delta inline in data.\n\t\tdelta: Type.Optional(Type.Number()),\n\t\tmode: Type.Enum(CounterMode),\n\t},\n\t{ additionalProperties: false },\n);\n\n/**\n * Used in {@link EncodedValueShape} for special field kind handling.\n */\nexport enum SpecialField {\n\t/**\n\t * Special case for Identifier field kind.\n\t */\n\tIdentifier = 0,\n}\n\n/**\n * Shape of a value on a node.\n *\n * Due to limitations of TypeBox and differences between JavaScript objects, TypeScript types and JSON,\n * the case where no information about the value is captured in the shape is a bit confusing.\n * In TypeBox this is allowed by the user of this type putting it in an optional property.\n * In TypeScript it is modeled using `undefined`.\n * In JavaScript the property may be missing or explicitly `undefined`.\n * In JSON this will serialize as the property being omitted.\n * In this case, the value will be encoded as either:\n * - `false` (when there is no value) OR\n * - `true, value` when there is a value.\n *\n * For a more compact encoding, there are 4 options for the shape:\n * - `true`: there is a value, and it will simply be encoded by putting it in the output buffer (so `value`).\n * - `false`: there is never a value, and it takes up no space in the output buffer.\n * - `[value]`: there is a value, and its always the same.\n * - `SpecialField.Identifier`: special case for node identifier handling.\n * Takes up no space in the output buffer: the value comes from the shape arrays's content.\n * It is wrapped in an array to differentiate value shape types.\n *\n * In the future other value shape formats may be added, likely as objects.\n *\n * @remarks\n * See {@link EncodedTreeShape} for usage.\n */\nexport const EncodedValueShape = Type.Union([\n\tType.Boolean(),\n\tType.Array(Type.Any(), { minItems: 1, maxItems: 1 }),\n\tType.Enum(SpecialField),\n\t// TODO: support delta encoding and/or special node identifier handling\n\t// EncodedCounter,\n]);\nexport type EncodedValueShape = undefined | Static<typeof EncodedValueShape>;\n\nexport const EncodedTreeShape = Type.Object(\n\t{\n\t\t/**\n\t\t * If not provided, inlined in data.\n\t\t */\n\t\ttype: Type.Optional(IdentifierOrIndex),\n\t\tvalue: Type.Optional(EncodedValueShape),\n\t\t/**\n\t\t * Fields with fixed (per key) shapes.\n\t\t * They are encoded in the order they are specified here.\n\t\t * To ensure the order is preserved, this is an array instead of an object with keys.\n\t\t */\n\t\tfields: Type.Optional(Type.Array(EncodedFieldShape)),\n\t\t/**\n\t\t * If undefined, no data. Otherwise, nested array of `[key, ...data]*`\n\t\t * Covers any fields beyond those in `fields`.\n\t\t */\n\t\textraFields: Type.Optional(ShapeIndex),\n\t},\n\t{ additionalProperties: false },\n);\n\n/**\n * Discriminated union of chunk shapes.\n *\n * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.\n */\nexport const EncodedChunkShape = Type.Object(\n\t{\n\t\t/**\n\t\t * {@link EncodedNestedArray} union member.\n\t\t */\n\t\ta: Type.Optional(EncodedNestedArray),\n\t\t/**\n\t\t * {@link EncodedInlineArray} union member.\n\t\t */\n\t\tb: Type.Optional(EncodedInlineArray),\n\t\t/**\n\t\t * {@link EncodedTreeShape} union member.\n\t\t */\n\t\tc: Type.Optional(EncodedTreeShape),\n\t\t/**\n\t\t * {@link EncodedAnyShape} union member.\n\t\t */\n\t\td: Type.Optional(EncodedAnyShape),\n\t},\n\tunionOptions,\n);\n\nexport type EncodedChunkShape = Static<typeof EncodedChunkShape>;\n\nexport type EncodedNestedArray = Static<typeof EncodedNestedArray>;\nexport type EncodedInlineArray = Static<typeof EncodedInlineArray>;\nexport type EncodedTreeShape = Static<typeof EncodedTreeShape>;\nexport type EncodedAnyShape = Static<typeof EncodedAnyShape>;\n\nexport const EncodedFieldBatch = EncodedFieldBatchGeneric(version, EncodedChunkShape);\nexport type EncodedFieldBatch = Static<typeof EncodedFieldBatch>;\n"]}
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/format.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 { type Static, Type } from \"@sinclair/typebox\";\n\nimport { unionOptions } from \"../../../codec/index.js\";\n\nimport {\n\tCount,\n\tEncodedFieldBatchGeneric,\n\tIdentifierOrIndex,\n\tShapeIndex,\n} from \"./formatGeneric.js\";\n\nexport const version = 1;\n\n// Compatible versions used for format/version validation.\n// TODO: A proper version update policy will need to be documented.\nexport const validVersions = new Set([version]);\n\n/**\n * Top level length is implied from length of data array.\n * All content are of this shape.\n */\nexport const EncodedNestedArrayShape = ShapeIndex;\n\n/**\n * Inline array.\n */\nexport const EncodedInlineArrayShape = Type.Object(\n\t{\n\t\tlength: Count,\n\t\t/**\n\t\t * All entries are this shape.\n\t\t */\n\t\tshape: ShapeIndex,\n\t},\n\t{ additionalProperties: false },\n);\n\n/**\n * Encoded as `shape, ...[data for shape]`.\n *\n * Used for polymorphism.\n */\nexport const EncodedAnyShape = Type.Literal(0);\n\n/**\n * Content of the encoded field is specified by the Shape referenced by the ShapeIndex.\n * This is a tuple for conciseness.\n */\nexport const EncodedFieldShape = Type.Tuple([\n\t/**\n\t * Field key for this field.\n\t */\n\tIdentifierOrIndex,\n\t/**\n\t * Shape of data in this field.\n\t */\n\tShapeIndex,\n]);\n\nexport type EncodedFieldShape = Static<typeof EncodedFieldShape>;\n\nenum CounterRelativeTo {\n\t// Relative to previous node of same type in depth first pre-order traversal.\n\tPreviousNodeOfType_DepthFirstPreOrder,\n\t// TODO: add alternative relative mode relative to previous note at a path to allow delta encoded sequences (like points where x and y are delta encoded relative to previous points).\n}\n\nenum CounterMode {\n\tNumber,\n\t// TODO: document wrap modes and bit skipping. Note UUID subVersion here (ex: UUIDv4)\n\tUUID,\n}\n\n/**\n * Delta encoded value relative to a previous node's value.\n */\nexport const EncodedCounter = Type.Object(\n\t{\n\t\trelativeTo: Type.Enum(CounterRelativeTo),\n\t\t// If not provided, delta inline in data.\n\t\tdelta: Type.Optional(Type.Number()),\n\t\tmode: Type.Enum(CounterMode),\n\t},\n\t{ additionalProperties: false },\n);\n\n/**\n * Used in {@link EncodedValueShape} for special field kind handling.\n */\nexport enum SpecialField {\n\t/**\n\t * Special case for Identifier field kind.\n\t */\n\tIdentifier = 0,\n}\n\n/**\n * Shape of a value on a node.\n *\n * Due to limitations of TypeBox and differences between JavaScript objects, TypeScript types and JSON,\n * the case where no information about the value is captured in the shape is a bit confusing.\n * In TypeBox this is allowed by the user of this type putting it in an optional property.\n * In TypeScript it is modeled using `undefined`.\n * In JavaScript the property may be missing or explicitly `undefined`.\n * In JSON this will serialize as the property being omitted.\n * In this case, the value will be encoded as either:\n * - `false` (when there is no value) OR\n * - `true, value` when there is a value.\n *\n * For a more compact encoding, there are 4 options for the shape:\n * - `true`: there is a value, and it will simply be encoded by putting it in the output buffer (so `value`).\n * - `false`: there is never a value, and it takes up no space in the output buffer.\n * - `[value]`: there is a value, and its always the same.\n * - `SpecialField.Identifier`: special case for node identifier handling.\n * Takes up no space in the output buffer: the value comes from the shape arrays's content.\n * It is wrapped in an array to differentiate value shape types.\n *\n * In the future other value shape formats may be added, likely as objects.\n *\n * @remarks\n * See {@link EncodedNodeShape} for usage.\n */\nexport const EncodedValueShape = Type.Union([\n\tType.Boolean(),\n\tType.Array(Type.Any(), { minItems: 1, maxItems: 1 }),\n\tType.Enum(SpecialField),\n\t// TODO: support delta encoding and/or special node identifier handling\n\t// EncodedCounter,\n]);\nexport type EncodedValueShape = undefined | Static<typeof EncodedValueShape>;\n\nexport const EncodedNodeShape = Type.Object(\n\t{\n\t\t/**\n\t\t * If not provided, inlined in data.\n\t\t */\n\t\ttype: Type.Optional(IdentifierOrIndex),\n\t\tvalue: Type.Optional(EncodedValueShape),\n\t\t/**\n\t\t * Fields with fixed (per key) shapes.\n\t\t * They are encoded in the order they are specified here.\n\t\t * To ensure the order is preserved, this is an array instead of an object with keys.\n\t\t */\n\t\tfields: Type.Optional(Type.Array(EncodedFieldShape)),\n\t\t/**\n\t\t * If undefined, no data. Otherwise, nested array of `[key, ...data]*`\n\t\t * Covers any fields beyond those in `fields`.\n\t\t */\n\t\textraFields: Type.Optional(ShapeIndex),\n\t},\n\t{ additionalProperties: false },\n);\n\n/**\n * Discriminated union that represents the shapes of chunks in the encoded data.\n * \"Chunk\" here refers to a chunk of tree data, rooted at a range of nodes, that is encoded as a\n * single unit in a specific format represented by one of the shapes in this union.\n *\n * The concept of \"chunk\" is same for the tree data in memory and in the encoded wire format.\n * The physical representation of the chunk may differ, but the logical structure remains the same.\n * This is similar to other such concepts in the system.\n *\n * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.\n */\nexport const EncodedChunkShape = Type.Object(\n\t{\n\t\t/**\n\t\t * {@link EncodedNestedArrayShape} union member.\n\t\t */\n\t\ta: Type.Optional(EncodedNestedArrayShape),\n\t\t/**\n\t\t * {@link EncodedInlineArrayShape} union member.\n\t\t */\n\t\tb: Type.Optional(EncodedInlineArrayShape),\n\t\t/**\n\t\t * {@link EncodedNodeShape} union member.\n\t\t */\n\t\tc: Type.Optional(EncodedNodeShape),\n\t\t/**\n\t\t * {@link EncodedAnyShape} union member.\n\t\t */\n\t\td: Type.Optional(EncodedAnyShape),\n\t},\n\tunionOptions,\n);\n\nexport type EncodedChunkShape = Static<typeof EncodedChunkShape>;\n\nexport type EncodedNestedArrayShape = Static<typeof EncodedNestedArrayShape>;\nexport type EncodedInlineArrayShape = Static<typeof EncodedInlineArrayShape>;\nexport type EncodedNodeShape = Static<typeof EncodedNodeShape>;\nexport type EncodedAnyShape = Static<typeof EncodedAnyShape>;\n\nexport const EncodedFieldBatch = EncodedFieldBatchGeneric(version, EncodedChunkShape);\nexport type EncodedFieldBatch = Static<typeof EncodedFieldBatch>;\n"]}

package/{lib/feature-libraries/chunked-forest/codec/nodeShape.d.ts → dist/feature-libraries/chunked-forest/codec/nodeEncoder.d.ts}

@@ -5,30 +5,36 @@
 import { type ITreeCursorSynchronous, type TreeNodeSchemaIdentifier } from "../../../core/index.js";
 import type { Counter, DeduplicationTable } from "./chunkCodecUtilities.js";
 import { type BufferFormat, Shape } from "./chunkEncodingGeneric.js";
-import { type EncoderCache, type FieldEncoder, type KeyedFieldEncoder, type NodeEncoder } from "./compressedEncode.js";
+import { type EncoderContext, type FieldEncoder, type KeyedFieldEncoder, type NodeEncoder } from "./compressedEncode.js";
 import type { EncodedChunkShape, EncodedFieldShape, EncodedValueShape } from "./format.js";
-export declare class NodeShape extends Shape<EncodedChunkShape> implements NodeEncoder {
+/**
+ * Encodes a node with the {@link EncodedNodeShape} shape.
+ * @remarks
+ * The fact this is also a Shape is an implementation detail of the encoder: that allows the shape it uses to be itself,
+ * which is an easy way to keep all the related code together without extra objects.
+ */
+export declare class NodeShapeBasedEncoder extends Shape<EncodedChunkShape> implements NodeEncoder {
     readonly type: undefined | TreeNodeSchemaIdentifier;
     readonly value: EncodedValueShape;
     /**
      * Encoders for a specific set of fields, by key, in the order they will be encoded.
      * These are fields for which specialized encoding is provided as an optimization.
-     * Using these for a given field instead of falling back to {@link NodeShape.specializedFieldEncoders} is often more efficient:
+     * Using these for a given field instead of falling back to {@link NodeShapeBasedEncoder.specializedFieldEncoders} is often more efficient:
      * this avoids the need to explicitly include the key and shape in the encoded data for each node instance.
      * Instead, this information is here, and thus is encoded only once as part of the node shape.
      * These encoders will be used, even if the field they apply to is empty (which can add overhead for fields which are usually empty).
      *
-     * Any fields not included here will be encoded using {@link NodeShape.otherFieldsEncoder}.
-     * If {@link NodeShape.otherFieldsEncoder} is undefined, then this must handle all non-empty fields.
+     * Any fields not included here will be encoded using {@link NodeShapeBasedEncoder.otherFieldsEncoder}.
+     * If {@link NodeShapeBasedEncoder.otherFieldsEncoder} is undefined, then this must handle all non-empty fields.
      */
     readonly specializedFieldEncoders: readonly KeyedFieldEncoder[];
     /**
-     * Encoder for all other fields that are not in {@link NodeShape.specializedFieldEncoders}. These fields must
+     * Encoder for all other fields that are not in {@link NodeShapeBasedEncoder.specializedFieldEncoders}. These fields must
      * be encoded after the specialized fields.
      */
     readonly otherFieldsEncoder: undefined | FieldEncoder;
     /**
-     * Set of keys for fields that are encoded using {@link NodeShape.specializedFieldEncoders}.
+     * Set of keys for fields that are encoded using {@link NodeShapeBasedEncoder.specializedFieldEncoders}.
      * TODO: Ensure uniform chunks, encoding and identifier generation sort fields the same.
      */
     private readonly specializedFieldKeys;
@@ -36,25 +42,25 @@ export declare class NodeShape extends Shape<EncodedChunkShape> implements NodeE
     /**
      * Encoders for a specific set of fields, by key, in the order they will be encoded.
      * These are fields for which specialized encoding is provided as an optimization.
-     * Using these for a given field instead of falling back to {@link NodeShape.specializedFieldEncoders} is often more efficient:
+     * Using these for a given field instead of falling back to {@link NodeShapeBasedEncoder.specializedFieldEncoders} is often more efficient:
      * this avoids the need to explicitly include the key and shape in the encoded data for each node instance.
      * Instead, this information is here, and thus is encoded only once as part of the node shape.
      * These encoders will be used, even if the field they apply to is empty (which can add overhead for fields which are usually empty).
      *
-     * Any fields not included here will be encoded using {@link NodeShape.otherFieldsEncoder}.
-     * If {@link NodeShape.otherFieldsEncoder} is undefined, then this must handle all non-empty fields.
+     * Any fields not included here will be encoded using {@link NodeShapeBasedEncoder.otherFieldsEncoder}.
+     * If {@link NodeShapeBasedEncoder.otherFieldsEncoder} is undefined, then this must handle all non-empty fields.
      */
     specializedFieldEncoders: readonly KeyedFieldEncoder[], 
     /**
-     * Encoder for all other fields that are not in {@link NodeShape.specializedFieldEncoders}. These fields must
+     * Encoder for all other fields that are not in {@link NodeShapeBasedEncoder.specializedFieldEncoders}. These fields must
      * be encoded after the specialized fields.
      */
     otherFieldsEncoder: undefined | FieldEncoder);
     private getValueToEncode;
-    encodeNode(cursor: ITreeCursorSynchronous, cache: EncoderCache, outputBuffer: BufferFormat<EncodedChunkShape>): void;
+    encodeNode(cursor: ITreeCursorSynchronous, context: EncoderContext, outputBuffer: BufferFormat<EncodedChunkShape>): void;
     encodeShape(identifiers: DeduplicationTable<string>, shapes: DeduplicationTable<Shape<EncodedChunkShape>>): EncodedChunkShape;
     countReferencedShapesAndIdentifiers(identifiers: Counter<string>, shapeDiscovered: (shape: Shape<EncodedChunkShape>) => void): void;
-    get shape(): NodeShape;
+    get shape(): Shape<EncodedChunkShape>;
 }
 export declare function encodeFieldShapes(fieldEncoders: readonly KeyedFieldEncoder[], identifiers: DeduplicationTable<string>, shapes: DeduplicationTable<Shape<EncodedChunkShape>>): EncodedFieldShape[] | undefined;
-//# sourceMappingURL=nodeShape.d.ts.map
+//# sourceMappingURL=nodeEncoder.d.ts.map

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

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

package/dist/feature-libraries/chunked-forest/codec/{nodeShape.js → nodeEncoder.js}

@@ -4,29 +4,35 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeFieldShapes = exports.NodeShape = void 0;
+exports.encodeFieldShapes = exports.NodeShapeBasedEncoder = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const internal_2 = require("@fluidframework/id-compressor/internal");
 const index_js_1 = require("../../../core/index.js");
 const index_js_2 = require("../../../util/index.js");
 const chunkEncodingGeneric_js_1 = require("./chunkEncodingGeneric.js");
 const compressedEncode_js_1 = require("./compressedEncode.js");
-class NodeShape extends chunkEncodingGeneric_js_1.Shape {
+/**
+ * Encodes a node with the {@link EncodedNodeShape} shape.
+ * @remarks
+ * The fact this is also a Shape is an implementation detail of the encoder: that allows the shape it uses to be itself,
+ * which is an easy way to keep all the related code together without extra objects.
+ */
+class NodeShapeBasedEncoder extends chunkEncodingGeneric_js_1.Shape {
     constructor(type, value, 
     /**
      * Encoders for a specific set of fields, by key, in the order they will be encoded.
      * These are fields for which specialized encoding is provided as an optimization.
-     * Using these for a given field instead of falling back to {@link NodeShape.specializedFieldEncoders} is often more efficient:
+     * Using these for a given field instead of falling back to {@link NodeShapeBasedEncoder.specializedFieldEncoders} is often more efficient:
      * this avoids the need to explicitly include the key and shape in the encoded data for each node instance.
      * Instead, this information is here, and thus is encoded only once as part of the node shape.
      * These encoders will be used, even if the field they apply to is empty (which can add overhead for fields which are usually empty).
      *
-     * Any fields not included here will be encoded using {@link NodeShape.otherFieldsEncoder}.
-     * If {@link NodeShape.otherFieldsEncoder} is undefined, then this must handle all non-empty fields.
+     * Any fields not included here will be encoded using {@link NodeShapeBasedEncoder.otherFieldsEncoder}.
+     * If {@link NodeShapeBasedEncoder.otherFieldsEncoder} is undefined, then this must handle all non-empty fields.
      */
     specializedFieldEncoders, 
     /**
-     * Encoder for all other fields that are not in {@link NodeShape.specializedFieldEncoders}. These fields must
+     * Encoder for all other fields that are not in {@link NodeShapeBasedEncoder.specializedFieldEncoders}. These fields must
      * be encoded after the specialized fields.
      */
     otherFieldsEncoder) {
@@ -37,29 +43,29 @@ class NodeShape extends chunkEncodingGeneric_js_1.Shape {
         this.otherFieldsEncoder = otherFieldsEncoder;
         this.specializedFieldKeys = new Set(this.specializedFieldEncoders.map((f) => f.key));
     }
-    getValueToEncode(cursor, cache) {
+    getValueToEncode(cursor, context) {
         if (this.value === 0) {
             (0, internal_1.assert)(typeof cursor.value === "string", 0x9aa /* identifier must be type string */);
             if ((0, internal_2.isStableId)(cursor.value)) {
-                const sessionSpaceCompressedId = cache.idCompressor.tryRecompress(cursor.value);
+                const sessionSpaceCompressedId = context.idCompressor.tryRecompress(cursor.value);
                 if (sessionSpaceCompressedId !== undefined) {
-                    return cache.idCompressor.normalizeToOpSpace(sessionSpaceCompressedId);
+                    return context.idCompressor.normalizeToOpSpace(sessionSpaceCompressedId);
                 }
             }
         }
         return cursor.value;
     }
-    encodeNode(cursor, cache, outputBuffer) {
+    encodeNode(cursor, context, outputBuffer) {
         if (this.type === undefined) {
             outputBuffer.push(new chunkEncodingGeneric_js_1.IdentifierToken(cursor.type));
         }
         else {
             (0, internal_1.assert)(cursor.type === this.type, 0x741 /* type must match shape */);
         }
-        (0, compressedEncode_js_1.encodeValue)(this.getValueToEncode(cursor, cache), this.value, outputBuffer);
+        (0, compressedEncode_js_1.encodeValue)(this.getValueToEncode(cursor, context), this.value, outputBuffer);
         for (const fieldEncoder of this.specializedFieldEncoders) {
             cursor.enterField((0, index_js_2.brand)(fieldEncoder.key));
-            fieldEncoder.encoder.encodeField(cursor, cache, outputBuffer);
+            fieldEncoder.encoder.encodeField(cursor, context, outputBuffer);
             cursor.exitField();
         }
         const otherFieldsBuffer = [];
@@ -68,7 +74,7 @@ class NodeShape extends chunkEncodingGeneric_js_1.Shape {
             if (!this.specializedFieldKeys.has(key)) {
                 (0, internal_1.assert)(this.otherFieldsEncoder !== undefined, 0x742 /* had extra local fields when shape does not support them */);
                 otherFieldsBuffer.push(new chunkEncodingGeneric_js_1.IdentifierToken(key));
-                this.otherFieldsEncoder.encodeField(cursor, cache, otherFieldsBuffer);
+                this.otherFieldsEncoder.encodeField(cursor, context, otherFieldsBuffer);
             }
         });
         if (this.otherFieldsEncoder !== undefined) {
@@ -101,7 +107,7 @@ class NodeShape extends chunkEncodingGeneric_js_1.Shape {
         return this;
     }
 }
-exports.NodeShape = NodeShape;
+exports.NodeShapeBasedEncoder = NodeShapeBasedEncoder;
 function encodeFieldShapes(fieldEncoders, identifiers, shapes) {
     if (fieldEncoders.length === 0) {
         return undefined;
@@ -120,10 +126,10 @@ function encodeIdentifier(identifier, identifiers) {
 function encodeOptionalIdentifier(identifier, identifiers) {
     return identifier === undefined ? undefined : encodeIdentifier(identifier, identifiers);
 }
-function encodeOptionalFieldShape(shape, shapes) {
-    return shape === undefined ? undefined : dedupShape(shape.shape, shapes);
+function encodeOptionalFieldShape(encoder, shapes) {
+    return encoder === undefined ? undefined : dedupShape(encoder.shape, shapes);
 }
 function dedupShape(shape, shapes) {
     return shapes.valueToIndex.get(shape) ?? (0, internal_1.fail)(0xb51 /* missing shape */);
 }
-//# sourceMappingURL=nodeShape.js.map
+//# sourceMappingURL=nodeEncoder.js.map

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

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

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

@@ -5,10 +5,10 @@
 import type { IIdCompressor } from "@fluidframework/id-compressor";
 import { type StoredSchemaCollection, type TreeFieldStoredSchema, type TreeNodeSchemaIdentifier } from "../../../core/index.js";
 import type { FullSchemaPolicy } from "../../modular-schema/index.js";
-import { EncoderCache, type FieldEncoder, type FieldShaper, type TreeShaper } from "./compressedEncode.js";
+import { EncoderContext, type FieldEncoder, type FieldEncodeBuilder, type NodeEncodeBuilder } from "./compressedEncode.js";
 import type { FieldBatch } from "./fieldBatch.js";
 import { type EncodedFieldBatch } from "./format.js";
-import { NodeShape } from "./nodeShape.js";
+import { NodeShapeBasedEncoder } from "./nodeEncoder.js";
 /**
  * Encode data from `fieldBatch` in into an `EncodedChunk`.
  *
@@ -16,14 +16,14 @@ import { NodeShape } from "./nodeShape.js";
  * TODO: This function should eventually also take in the root FieldSchema to more efficiently compress the nodes.
  */
 export declare function schemaCompressedEncode(schema: StoredSchemaCollection, policy: FullSchemaPolicy, fieldBatch: FieldBatch, idCompressor: IIdCompressor): EncodedFieldBatch;
-export declare function buildCache(schema: StoredSchemaCollection, policy: FullSchemaPolicy, idCompressor: IIdCompressor): EncoderCache;
+export declare function buildContext(storedSchema: StoredSchemaCollection, policy: FullSchemaPolicy, idCompressor: IIdCompressor): EncoderContext;
 /**
- * Selects shapes to use to encode fields.
+ * Selects an encoder to use to encode fields.
  */
-export declare function fieldShaper(treeHandler: TreeShaper, field: TreeFieldStoredSchema, cache: EncoderCache, storedSchema: StoredSchemaCollection): FieldEncoder;
+export declare function getFieldEncoder(nodeBuilder: NodeEncodeBuilder, field: TreeFieldStoredSchema, context: EncoderContext, storedSchema: StoredSchemaCollection): FieldEncoder;
 /**
- * Selects shapes to use to encode trees.
+ * Selects an encoder to use to encode nodes.
  */
-export declare function treeShaper(fullSchema: StoredSchemaCollection, policy: FullSchemaPolicy, fieldHandler: FieldShaper, schemaName: TreeNodeSchemaIdentifier): NodeShape;
+export declare function getNodeEncoder(fieldBuilder: FieldEncodeBuilder, storedSchema: StoredSchemaCollection, schemaName: TreeNodeSchemaIdentifier): NodeShapeBasedEncoder;
 export declare function oneFromSet<T>(set: ReadonlySet<T> | undefined): T | undefined;
 //# sourceMappingURL=schemaBasedEncode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"schemaBasedEncode.d.ts","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/schemaBasedEncode.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,OAAO,EAIN,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAI7B,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,OAAO,EACN,YAAY,EACZ,KAAK,YAAY,EACjB,KAAK,WAAW,EAEhB,KAAK,UAAU,EAIf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,KAAK,iBAAiB,EAAwC,MAAM,aAAa,CAAC;AAC3F,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACrC,MAAM,EAAE,sBAAsB,EAC9B,MAAM,EAAE,gBAAgB,EACxB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,aAAa,GACzB,iBAAiB,CAEnB;AAED,wBAAgB,UAAU,CACzB,MAAM,EAAE,sBAAsB,EAC9B,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,aAAa,GACzB,YAAY,CAUd;AAED;;GAEG;AACH,wBAAgB,WAAW,CAC1B,WAAW,EAAE,UAAU,EACvB,KAAK,EAAE,qBAAqB,EAC5B,KAAK,EAAE,YAAY,EACnB,YAAY,EAAE,sBAAsB,GAClC,YAAY,CA6Bd;AAED;;GAEG;AACH,wBAAgB,UAAU,CACzB,UAAU,EAAE,sBAAsB,EAClC,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,WAAW,EACzB,UAAU,EAAE,wBAAwB,GAClC,SAAS,CAoCX;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,GAAG,SAAS,CAU5E"}
+{"version":3,"file":"schemaBasedEncode.d.ts","sourceRoot":"","sources":["../../../../src/feature-libraries/chunked-forest/codec/schemaBasedEncode.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEnE,OAAO,EAIN,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,wBAAwB,EAI7B,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,OAAO,EACN,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,kBAAkB,EAEvB,KAAK,iBAAiB,EAItB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,KAAK,iBAAiB,EAAwC,MAAM,aAAa,CAAC;AAC3F,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACrC,MAAM,EAAE,sBAAsB,EAC9B,MAAM,EAAE,gBAAgB,EACxB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,aAAa,GACzB,iBAAiB,CAEnB;AAED,wBAAgB,YAAY,CAC3B,YAAY,EAAE,sBAAsB,EACpC,MAAM,EAAE,gBAAgB,EACxB,YAAY,EAAE,aAAa,GACzB,cAAc,CAUhB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC9B,WAAW,EAAE,iBAAiB,EAC9B,KAAK,EAAE,qBAAqB,EAC5B,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,sBAAsB,GAClC,YAAY,CA8Bd;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC7B,YAAY,EAAE,kBAAkB,EAChC,YAAY,EAAE,sBAAsB,EACpC,UAAU,EAAE,wBAAwB,GAClC,qBAAqB,CAoCvB;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,GAAG,SAAS,CAU5E"}

package/dist/feature-libraries/chunked-forest/codec/schemaBasedEncode.js

@@ -4,12 +4,12 @@
  * Licensed under the MIT License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.oneFromSet = exports.treeShaper = exports.fieldShaper = exports.buildCache = exports.schemaCompressedEncode = void 0;
+exports.oneFromSet = exports.getNodeEncoder = exports.getFieldEncoder = exports.buildContext = exports.schemaCompressedEncode = void 0;
 const internal_1 = require("@fluidframework/core-utils/internal");
 const index_js_1 = require("../../../core/index.js");
 const compressedEncode_js_1 = require("./compressedEncode.js");
 const format_js_1 = require("./format.js");
-const nodeShape_js_1 = require("./nodeShape.js");
+const nodeEncoder_js_1 = require("./nodeEncoder.js");
 /**
  * Encode data from `fieldBatch` in into an `EncodedChunk`.
  *
@@ -17,21 +17,21 @@ const nodeShape_js_1 = require("./nodeShape.js");
  * TODO: This function should eventually also take in the root FieldSchema to more efficiently compress the nodes.
  */
 function schemaCompressedEncode(schema, policy, fieldBatch, idCompressor) {
-    return (0, compressedEncode_js_1.compressedEncode)(fieldBatch, buildCache(schema, policy, idCompressor));
+    return (0, compressedEncode_js_1.compressedEncode)(fieldBatch, buildContext(schema, policy, idCompressor));
 }
 exports.schemaCompressedEncode = schemaCompressedEncode;
-function buildCache(schema, policy, idCompressor) {
-    const cache = new compressedEncode_js_1.EncoderCache((fieldHandler, schemaName) => treeShaper(schema, policy, fieldHandler, schemaName), (treeHandler, field) => fieldShaper(treeHandler, field, cache, schema), policy.fieldKinds, idCompressor);
-    return cache;
+function buildContext(storedSchema, policy, idCompressor) {
+    const context = new compressedEncode_js_1.EncoderContext((fieldBuilder, schemaName) => getNodeEncoder(fieldBuilder, storedSchema, schemaName), (nodeBuilder, fieldSchema) => getFieldEncoder(nodeBuilder, fieldSchema, context, storedSchema), policy.fieldKinds, idCompressor);
+    return context;
 }
-exports.buildCache = buildCache;
+exports.buildContext = buildContext;
 /**
- * Selects shapes to use to encode fields.
+ * Selects an encoder to use to encode fields.
  */
-function fieldShaper(treeHandler, field, cache, storedSchema) {
-    const kind = cache.fieldShapes.get(field.kind) ?? (0, internal_1.fail)(0xb52 /* missing FieldKind */);
+function getFieldEncoder(nodeBuilder, field, context, storedSchema) {
+    const kind = context.fieldShapes.get(field.kind) ?? (0, internal_1.fail)(0xb52 /* missing FieldKind */);
     const type = oneFromSet(field.types);
-    const nodeEncoder = type !== undefined ? treeHandler.shapeFromTree(type) : compressedEncode_js_1.anyNodeEncoder;
+    const nodeEncoder = type !== undefined ? nodeBuilder.nodeEncoderFromSchema(type) : compressedEncode_js_1.anyNodeEncoder;
     if (kind.multiplicity === index_js_1.Multiplicity.Single) {
         if (field.kind === index_js_1.identifierFieldKindIdentifier) {
             (0, internal_1.assert)(type !== undefined, 0x999 /* field type must be defined in identifier field */);
@@ -39,43 +39,43 @@ function fieldShaper(treeHandler, field, cache, storedSchema) {
             (0, internal_1.assert)(nodeSchema !== undefined, 0x99a /* nodeSchema must be defined */);
             (0, internal_1.assert)(nodeSchema instanceof index_js_1.LeafNodeStoredSchema, 0x99b /* nodeSchema must be LeafNodeStoredSchema */);
             (0, internal_1.assert)(nodeSchema.leafValue === index_js_1.ValueSchema.String, 0x99c /* identifier field can only be type string */);
-            const identifierNodeEncoder = new nodeShape_js_1.NodeShape(type, format_js_1.SpecialField.Identifier, [], undefined);
+            const identifierNodeEncoder = new nodeEncoder_js_1.NodeShapeBasedEncoder(type, format_js_1.SpecialField.Identifier, [], undefined);
             return (0, compressedEncode_js_1.asFieldEncoder)(identifierNodeEncoder);
         }
         return (0, compressedEncode_js_1.asFieldEncoder)(nodeEncoder);
     }
     else {
-        return cache.nestedArray(nodeEncoder);
+        return context.nestedArrayEncoder(nodeEncoder);
     }
 }
-exports.fieldShaper = fieldShaper;
+exports.getFieldEncoder = getFieldEncoder;
 /**
- * Selects shapes to use to encode trees.
+ * Selects an encoder to use to encode nodes.
  */
-function treeShaper(fullSchema, policy, fieldHandler, schemaName) {
-    const schema = fullSchema.nodeSchema.get(schemaName) ?? (0, internal_1.fail)(0xb53 /* missing node schema */);
+function getNodeEncoder(fieldBuilder, storedSchema, schemaName) {
+    const schema = storedSchema.nodeSchema.get(schemaName) ?? (0, internal_1.fail)(0xb53 /* missing node schema */);
     if (schema instanceof index_js_1.ObjectNodeStoredSchema) {
         // TODO:Performance:
         // consider moving some optional and sequence fields to extra fields if they are commonly empty
         // to reduce encoded size.
         const objectNodeFields = [];
         for (const [key, field] of schema.objectNodeFields ?? []) {
-            objectNodeFields.push({ key, encoder: fieldHandler.shapeFromField(field) });
+            objectNodeFields.push({ key, encoder: fieldBuilder.fieldEncoderFromSchema(field) });
         }
-        const shape = new nodeShape_js_1.NodeShape(schemaName, false, objectNodeFields, undefined);
+        const shape = new nodeEncoder_js_1.NodeShapeBasedEncoder(schemaName, false, objectNodeFields, undefined);
         return shape;
     }
     if (schema instanceof index_js_1.LeafNodeStoredSchema) {
-        const shape = new nodeShape_js_1.NodeShape(schemaName, valueShapeFromSchema(schema.leafValue), [], undefined);
+        const shape = new nodeEncoder_js_1.NodeShapeBasedEncoder(schemaName, valueShapeFromSchema(schema.leafValue), [], undefined);
         return shape;
     }
     if (schema instanceof index_js_1.MapNodeStoredSchema) {
-        const shape = new nodeShape_js_1.NodeShape(schemaName, false, [], fieldHandler.shapeFromField(schema.mapFields));
+        const shape = new nodeEncoder_js_1.NodeShapeBasedEncoder(schemaName, false, [], fieldBuilder.fieldEncoderFromSchema(schema.mapFields));
         return shape;
     }
     (0, internal_1.fail)(0xb54 /* unsupported node kind */);
 }
-exports.treeShaper = treeShaper;
+exports.getNodeEncoder = getNodeEncoder;
 function oneFromSet(set) {
     if (set === undefined) {
         return undefined;