@fluidframework/tree 2.0.0-dev-rc.1.0.0.224419

package/dist/core/schema-stored/format.js

@@ -0,0 +1,65 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeNodeSchemaDataFormat = exports.PersistedValueSchema = exports.FieldSchemaFormat = exports.TreeNodeSchemaIdentifierSchema = exports.FieldKindIdentifierSchema = exports.FieldKeySchema = exports.version = void 0;
+const typebox_1 = require("@sinclair/typebox");
+const codec_1 = require("../../codec");
+const util_1 = require("../../util");
+exports.version = 1;
+/**
+ * TypeBox Schema for encoding {@link FieldKey} in persisted data.
+ */
+exports.FieldKeySchema = (0, util_1.brandedStringType)();
+exports.FieldKindIdentifierSchema = (0, util_1.brandedStringType)();
+/**
+ * TypeBox Schema for encoding {@link TreeNodeSchemaIdentifiers} in persisted data.
+ */
+exports.TreeNodeSchemaIdentifierSchema = (0, util_1.brandedStringType)();
+const FieldSchemaFormatBase = typebox_1.Type.Object({
+    kind: exports.FieldKindIdentifierSchema,
+    types: typebox_1.Type.Optional(typebox_1.Type.Array(exports.TreeNodeSchemaIdentifierSchema)),
+});
+const noAdditionalProps = { additionalProperties: false };
+exports.FieldSchemaFormat = typebox_1.Type.Composite([FieldSchemaFormatBase], noAdditionalProps);
+const NamedFieldSchemaFormat = typebox_1.Type.Composite([
+    FieldSchemaFormatBase,
+    typebox_1.Type.Object({
+        name: exports.FieldKeySchema,
+    }),
+], noAdditionalProps);
+/**
+ * Persisted version of {@link ValueSchema}.
+ * @internal
+ */
+var PersistedValueSchema;
+(function (PersistedValueSchema) {
+    PersistedValueSchema[PersistedValueSchema["Number"] = 0] = "Number";
+    PersistedValueSchema[PersistedValueSchema["String"] = 1] = "String";
+    PersistedValueSchema[PersistedValueSchema["Boolean"] = 2] = "Boolean";
+    PersistedValueSchema[PersistedValueSchema["FluidHandle"] = 3] = "FluidHandle";
+    PersistedValueSchema[PersistedValueSchema["Null"] = 4] = "Null";
+})(PersistedValueSchema || (exports.PersistedValueSchema = PersistedValueSchema = {}));
+/**
+ * Discriminated union content of tree node schema.
+ *
+ * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.
+ * @internal
+ */
+exports.TreeNodeSchemaDataFormat = typebox_1.Type.Object({
+    /**
+     * Object node union member.
+     */
+    object: typebox_1.Type.Optional(typebox_1.Type.Array(NamedFieldSchemaFormat)),
+    /**
+     * Map node union member.
+     */
+    map: typebox_1.Type.Optional(exports.FieldSchemaFormat),
+    /**
+     * Leaf node union member.
+     */
+    leaf: typebox_1.Type.Optional(typebox_1.Type.Enum(PersistedValueSchema)),
+}, codec_1.unionOptions);
+//# sourceMappingURL=format.js.map

package/dist/core/schema-stored/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../../src/core/schema-stored/format.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+CAAgE;AAChE,uCAA2C;AAC3C,qCAAsD;AAEzC,QAAA,OAAO,GAAG,CAAU,CAAC;AAUlC;;GAEG;AACU,QAAA,cAAc,GAAG,IAAA,wBAAiB,GAAY,CAAC;AAsB/C,QAAA,yBAAyB,GAAG,IAAA,wBAAiB,GAAuB,CAAC;AAElF;;GAEG;AACU,QAAA,8BAA8B,GAAG,IAAA,wBAAiB,GAA4B,CAAC;AAE5F,MAAM,qBAAqB,GAAG,cAAI,CAAC,MAAM,CAAC;IACzC,IAAI,EAAE,iCAAyB;IAC/B,KAAK,EAAE,cAAI,CAAC,QAAQ,CAAC,cAAI,CAAC,KAAK,CAAC,sCAA8B,CAAC,CAAC;CAChE,CAAC,CAAC;AAEH,MAAM,iBAAiB,GAAkB,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAAC;AAE5D,QAAA,iBAAiB,GAAG,cAAI,CAAC,SAAS,CAAC,CAAC,qBAAqB,CAAC,EAAE,iBAAiB,CAAC,CAAC;AAE5F,MAAM,sBAAsB,GAAG,cAAI,CAAC,SAAS,CAC5C;IACC,qBAAqB;IACrB,cAAI,CAAC,MAAM,CAAC;QACX,IAAI,EAAE,sBAAc;KACpB,CAAC;CACF,EACD,iBAAiB,CACjB,CAAC;AAEF;;;GAGG;AACH,IAAY,oBAMX;AAND,WAAY,oBAAoB;IAC/B,mEAAM,CAAA;IACN,mEAAM,CAAA;IACN,qEAAO,CAAA;IACP,6EAAW,CAAA;IACX,+DAAI,CAAA;AACL,CAAC,EANW,oBAAoB,oCAApB,oBAAoB,QAM/B;AAED;;;;;GAKG;AACU,QAAA,wBAAwB,GAAG,cAAI,CAAC,MAAM,CAClD;IACC;;OAEG;IACH,MAAM,EAAE,cAAI,CAAC,QAAQ,CAAC,cAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC;IACzD;;OAEG;IACH,GAAG,EAAE,cAAI,CAAC,QAAQ,CAAC,yBAAiB,CAAC;IACrC;;OAEG;IACH,IAAI,EAAE,cAAI,CAAC,QAAQ,CAAC,cAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC;CACpD,EACD,oBAAY,CACZ,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ObjectOptions, Static, Type } from \"@sinclair/typebox\";\nimport { unionOptions } from \"../../codec\";\nimport { Brand, brandedStringType } from \"../../util\";\n\nexport const version = 1 as const;\n\n/**\n * Key (aka Name or Label) for a field which is scoped to a specific TreeNodeStoredSchema.\n *\n * Stable identifier, used when persisting data.\n * @internal\n */\nexport type FieldKey = Brand<string, \"tree.FieldKey\">;\n\n/**\n * TypeBox Schema for encoding {@link FieldKey} in persisted data.\n */\nexport const FieldKeySchema = brandedStringType<FieldKey>();\n\n/**\n * Identifier for a TreeNode schema.\n * Also known as \"Definition\"\n *\n * Stable identifier, used when persisting data.\n * @internal\n */\nexport type TreeNodeSchemaIdentifier<TName extends string = string> = Brand<\n\tTName,\n\t\"tree.TreeNodeSchemaIdentifier\"\n>;\n\n/**\n * Identifier for a FieldKind.\n * Refers to an exact stable policy (ex: specific version of a policy),\n * for how to handle (ex: edit and merge edits to) fields marked with this kind.\n * Persisted in documents as part of stored schema.\n * @internal\n */\nexport type FieldKindIdentifier = Brand<string, \"tree.FieldKindIdentifier\">;\nexport const FieldKindIdentifierSchema = brandedStringType<FieldKindIdentifier>();\n\n/**\n * TypeBox Schema for encoding {@link TreeNodeSchemaIdentifiers} in persisted data.\n */\nexport const TreeNodeSchemaIdentifierSchema = brandedStringType<TreeNodeSchemaIdentifier>();\n\nconst FieldSchemaFormatBase = Type.Object({\n\tkind: FieldKindIdentifierSchema,\n\ttypes: Type.Optional(Type.Array(TreeNodeSchemaIdentifierSchema)),\n});\n\nconst noAdditionalProps: ObjectOptions = { additionalProperties: false };\n\nexport const FieldSchemaFormat = Type.Composite([FieldSchemaFormatBase], noAdditionalProps);\n\nconst NamedFieldSchemaFormat = Type.Composite(\n\t[\n\t\tFieldSchemaFormatBase,\n\t\tType.Object({\n\t\t\tname: FieldKeySchema,\n\t\t}),\n\t],\n\tnoAdditionalProps,\n);\n\n/**\n * Persisted version of {@link ValueSchema}.\n * @internal\n */\nexport enum PersistedValueSchema {\n\tNumber,\n\tString,\n\tBoolean,\n\tFluidHandle,\n\tNull,\n}\n\n/**\n * Discriminated union content of tree node schema.\n *\n * See {@link DiscriminatedUnionDispatcher} for more information on this pattern.\n * @internal\n */\nexport const TreeNodeSchemaDataFormat = Type.Object(\n\t{\n\t\t/**\n\t\t * Object node union member.\n\t\t */\n\t\tobject: Type.Optional(Type.Array(NamedFieldSchemaFormat)),\n\t\t/**\n\t\t * Map node union member.\n\t\t */\n\t\tmap: Type.Optional(FieldSchemaFormat),\n\t\t/**\n\t\t * Leaf node union member.\n\t\t */\n\t\tleaf: Type.Optional(Type.Enum(PersistedValueSchema)),\n\t},\n\tunionOptions,\n);\n\nexport type TreeNodeSchemaDataFormat = Static<typeof TreeNodeSchemaDataFormat>;\n/**\n * @internal\n */\nexport type FieldSchemaFormat = Static<typeof FieldSchemaFormat>;\n/**\n * @internal\n */\nexport type NamedFieldSchemaFormat = Static<typeof NamedFieldSchemaFormat>;\n"]}

package/dist/core/schema-stored/index.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+export { TreeFieldStoredSchema, ValueSchema, TreeNodeStoredSchema, TreeTypeSet, FieldKindSpecifier, TreeStoredSchema, forbiddenFieldKindIdentifier, storedEmptyFieldSchema, StoredSchemaCollection, LeafNodeStoredSchema, ObjectNodeStoredSchema, MapNodeStoredSchema, BrandedTreeNodeSchemaDataFormat, decodeFieldSchema, encodeFieldSchema, storedSchemaDecodeDispatcher, ErasedTreeNodeSchemaDataFormat, } from "./schema";
+export { TreeStoredSchemaSubscription, MutableTreeStoredSchema, TreeStoredSchemaRepository, schemaDataIsEmpty, SchemaEvents, } from "./storedSchemaRepository";
+export { TreeNodeSchemaIdentifier, FieldKey, FieldKindIdentifier } from "./format";
+import * as schemaFormat from "./format";
+export { schemaFormat };
+//# sourceMappingURL=index.d.ts.map

package/dist/core/schema-stored/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/schema-stored/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,qBAAqB,EACrB,WAAW,EACX,oBAAoB,EACpB,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,4BAA4B,EAC5B,sBAAsB,EACtB,sBAAsB,EACtB,oBAAoB,EACpB,sBAAsB,EACtB,mBAAmB,EACnB,+BAA+B,EAC/B,iBAAiB,EACjB,iBAAiB,EACjB,4BAA4B,EAC5B,8BAA8B,GAC9B,MAAM,UAAU,CAAC;AAClB,OAAO,EACN,4BAA4B,EAC5B,uBAAuB,EACvB,0BAA0B,EAC1B,iBAAiB,EACjB,YAAY,GACZ,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,wBAAwB,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEnF,OAAO,KAAK,YAAY,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/core/schema-stored/index.js

@@ -0,0 +1,47 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaFormat = exports.schemaDataIsEmpty = exports.TreeStoredSchemaRepository = exports.storedSchemaDecodeDispatcher = exports.encodeFieldSchema = exports.decodeFieldSchema = exports.MapNodeStoredSchema = exports.ObjectNodeStoredSchema = exports.LeafNodeStoredSchema = exports.storedEmptyFieldSchema = exports.forbiddenFieldKindIdentifier = exports.TreeNodeStoredSchema = exports.ValueSchema = void 0;
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "ValueSchema", { enumerable: true, get: function () { return schema_1.ValueSchema; } });
+Object.defineProperty(exports, "TreeNodeStoredSchema", { enumerable: true, get: function () { return schema_1.TreeNodeStoredSchema; } });
+Object.defineProperty(exports, "forbiddenFieldKindIdentifier", { enumerable: true, get: function () { return schema_1.forbiddenFieldKindIdentifier; } });
+Object.defineProperty(exports, "storedEmptyFieldSchema", { enumerable: true, get: function () { return schema_1.storedEmptyFieldSchema; } });
+Object.defineProperty(exports, "LeafNodeStoredSchema", { enumerable: true, get: function () { return schema_1.LeafNodeStoredSchema; } });
+Object.defineProperty(exports, "ObjectNodeStoredSchema", { enumerable: true, get: function () { return schema_1.ObjectNodeStoredSchema; } });
+Object.defineProperty(exports, "MapNodeStoredSchema", { enumerable: true, get: function () { return schema_1.MapNodeStoredSchema; } });
+Object.defineProperty(exports, "decodeFieldSchema", { enumerable: true, get: function () { return schema_1.decodeFieldSchema; } });
+Object.defineProperty(exports, "encodeFieldSchema", { enumerable: true, get: function () { return schema_1.encodeFieldSchema; } });
+Object.defineProperty(exports, "storedSchemaDecodeDispatcher", { enumerable: true, get: function () { return schema_1.storedSchemaDecodeDispatcher; } });
+var storedSchemaRepository_1 = require("./storedSchemaRepository");
+Object.defineProperty(exports, "TreeStoredSchemaRepository", { enumerable: true, get: function () { return storedSchemaRepository_1.TreeStoredSchemaRepository; } });
+Object.defineProperty(exports, "schemaDataIsEmpty", { enumerable: true, get: function () { return storedSchemaRepository_1.schemaDataIsEmpty; } });
+const schemaFormat = __importStar(require("./format"));
+exports.schemaFormat = schemaFormat;
+//# sourceMappingURL=index.js.map

package/dist/core/schema-stored/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/schema-stored/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,mCAkBkB;AAhBjB,qGAAA,WAAW,OAAA;AACX,8GAAA,oBAAoB,OAAA;AAIpB,sHAAA,4BAA4B,OAAA;AAC5B,gHAAA,sBAAsB,OAAA;AAEtB,8GAAA,oBAAoB,OAAA;AACpB,gHAAA,sBAAsB,OAAA;AACtB,6GAAA,mBAAmB,OAAA;AAEnB,2GAAA,iBAAiB,OAAA;AACjB,2GAAA,iBAAiB,OAAA;AACjB,sHAAA,4BAA4B,OAAA;AAG7B,mEAMkC;AAHjC,oIAAA,0BAA0B,OAAA;AAC1B,2HAAA,iBAAiB,OAAA;AAMlB,uDAAyC;AAChC,oCAAY","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nexport {\n\tTreeFieldStoredSchema,\n\tValueSchema,\n\tTreeNodeStoredSchema,\n\tTreeTypeSet,\n\tFieldKindSpecifier,\n\tTreeStoredSchema,\n\tforbiddenFieldKindIdentifier,\n\tstoredEmptyFieldSchema,\n\tStoredSchemaCollection,\n\tLeafNodeStoredSchema,\n\tObjectNodeStoredSchema,\n\tMapNodeStoredSchema,\n\tBrandedTreeNodeSchemaDataFormat,\n\tdecodeFieldSchema,\n\tencodeFieldSchema,\n\tstoredSchemaDecodeDispatcher,\n\tErasedTreeNodeSchemaDataFormat,\n} from \"./schema\";\nexport {\n\tTreeStoredSchemaSubscription,\n\tMutableTreeStoredSchema,\n\tTreeStoredSchemaRepository,\n\tschemaDataIsEmpty,\n\tSchemaEvents,\n} from \"./storedSchemaRepository\";\n\nexport { TreeNodeSchemaIdentifier, FieldKey, FieldKindIdentifier } from \"./format\";\n\nimport * as schemaFormat from \"./format\";\nexport { schemaFormat };\n"]}

package/dist/core/schema-stored/schema.d.ts

@@ -0,0 +1,195 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { DiscriminatedUnionDispatcher } from "../../codec";
+import { Brand, Erased, MakeNominal } from "../../util";
+import { FieldKey, FieldKindIdentifier, FieldSchemaFormat, TreeNodeSchemaDataFormat, TreeNodeSchemaIdentifier } from "./format";
+/**
+ * Schema for what {@link TreeValue} is allowed on a Leaf node.
+ * @internal
+ */
+export declare enum ValueSchema {
+    Number = 0,
+    String = 1,
+    Boolean = 2,
+    FluidHandle = 3,
+    Null = 4
+}
+/**
+ * Set of allowed tree types.
+ * Providing multiple values here allows polymorphism, tagged union style.
+ *
+ * If not specified, types are unconstrained
+ * (equivalent to the set containing every TreeNodeSchemaIdentifier defined in the document).
+ *
+ * Note that even when unconstrained, children must still be in-schema for their own type.
+ *
+ * In the future, this could be extended to allow inlining a TreeNodeStoredSchema here
+ * (or some similar structural schema system).
+ * For structural types which could go here, there are a few interesting options:
+ *
+ * - Allow replacing the whole set with a structural type for terminal / non-tree data,
+ * and use this as a replacement for values on the tree nodes.
+ *
+ * - Allow expression structural constraints for child trees, for example requiring specific traits
+ * (ex: via TreeNodeStoredSchema), instead of by type.
+ *
+ * There are two ways this could work:
+ *
+ * - Constrain the child nodes based on their shape:
+ * this makes schema safe editing difficult because nodes would incur extra editing constraints to prevent them
+ * from going out of schema based on their location in such a field.
+ *
+ * - Constrain the types allowed based on which types guarantee their data will always meet the constraints.
+ *
+ * Care would need to be taken to make sure this is sound for the schema updating mechanisms.
+ * @internal
+ */
+export type TreeTypeSet = ReadonlySet<TreeNodeSchemaIdentifier> | undefined;
+/**
+ * Specifies which field kind to use.
+ *
+ * @remarks
+ * This is used instead of just the FieldKindIdentifier so that it can be subtyped into a more expressive type with additional information.
+ *
+ * @internal
+ */
+export interface FieldKindSpecifier<T = FieldKindIdentifier> {
+    identifier: T;
+}
+/**
+ * Schema for a field.
+ * Object implementing this interface should never be modified.
+ * @internal
+ */
+export interface TreeFieldStoredSchema {
+    readonly kind: FieldKindSpecifier;
+    /**
+     * The set of allowed child types.
+     * If not specified, types are unconstrained.
+     */
+    readonly types?: TreeTypeSet;
+}
+/**
+ * Identifier used for the FieldKind for fields which must be empty.
+ *
+ * @remarks
+ * This mainly show up in:
+ * 1. The root default field for documents.
+ * 2. The schema used for out of schema fields (which thus must be empty/not exist) on object and leaf nodes.
+ *
+ * @internal
+ */
+export declare const forbiddenFieldKindIdentifier = "Forbidden";
+/**
+ * A schema for empty fields (fields which must always be empty).
+ * There are multiple ways this could be encoded, but this is the most explicit.
+ */
+export declare const storedEmptyFieldSchema: TreeFieldStoredSchema;
+/**
+ * Opaque type erased handle to the encoded representation of the contents of a stored schema.
+ * @internal
+ */
+export interface ErasedTreeNodeSchemaDataFormat extends Erased<"TreeNodeSchemaDataFormat"> {
+}
+export interface BrandedTreeNodeSchemaDataFormat extends Brand<TreeNodeSchemaDataFormat, ErasedTreeNodeSchemaDataFormat> {
+}
+/**
+ * @internal
+ */
+export declare abstract class TreeNodeStoredSchema {
+    protected _typeCheck: MakeNominal;
+    /**
+     * @privateRemarks
+     * Returns TreeNodeSchemaDataFormat.
+     * This is uses an opaque type to avoid leaking these types out of the package,
+     * and is runtime validated by the codec.
+     */
+    abstract encode(): ErasedTreeNodeSchemaDataFormat;
+}
+/**
+ * @internal
+ */
+export declare class ObjectNodeStoredSchema extends TreeNodeStoredSchema {
+    readonly objectNodeFields: ReadonlyMap<FieldKey, TreeFieldStoredSchema>;
+    /**
+     * @param objectNodeFields -
+     * Schema for fields with keys scoped to this TreeNodeStoredSchema.
+     * This refers to the TreeFieldStoredSchema directly
+     * (as opposed to just supporting FieldSchemaIdentifier and having a central FieldKey -\> TreeFieldStoredSchema map).
+     * This allows os short friendly field keys which can ergonomically used as field names in code.
+     * It also interoperates well with mapFields being used as a map with arbitrary data as keys.
+     */
+    constructor(objectNodeFields: ReadonlyMap<FieldKey, TreeFieldStoredSchema>);
+    encode(): ErasedTreeNodeSchemaDataFormat;
+}
+/**
+ * @internal
+ */
+export declare class MapNodeStoredSchema extends TreeNodeStoredSchema {
+    readonly mapFields: TreeFieldStoredSchema;
+    /**
+     * @param mapFields -
+     * Allows using using the fields as a map, with the keys being
+     * FieldKeys and the values being constrained by this TreeFieldStoredSchema.
+     * Usually `FieldKind.Value` should NOT be used here
+     * since no nodes can ever be in schema are in schema if you use `FieldKind.Value` here
+     * (that would require infinite children).
+     */
+    constructor(mapFields: TreeFieldStoredSchema);
+    encode(): ErasedTreeNodeSchemaDataFormat;
+}
+/**
+ * @internal
+ */
+export declare class LeafNodeStoredSchema extends TreeNodeStoredSchema {
+    readonly leafValue: ValueSchema;
+    /**
+     * @param leafValue -
+     * There are several approaches for how to store actual data in the tree
+     * (special node types, special field contents, data on nodes etc.)
+     * as well as several options about how the data should be modeled at this level
+     * (byte sequence? javascript type? json?),
+     * as well as options for how much of this would be exposed in the schema language
+     * (ex: would all nodes with values be special built-ins, or could any schema add them?)
+     * A simple easy to do in javascript approach is taken here:
+     * this is not intended to be a suggestion of what approach to take, or what to expose in the schema language.
+     * This is simply one approach that can work for modeling them in the internal schema representation.
+     */
+    constructor(leafValue: ValueSchema);
+    encode(): ErasedTreeNodeSchemaDataFormat;
+}
+export declare const storedSchemaDecodeDispatcher: DiscriminatedUnionDispatcher<TreeNodeSchemaDataFormat, [
+], TreeNodeStoredSchema>;
+export declare function encodeFieldSchema(schema: TreeFieldStoredSchema): FieldSchemaFormat;
+export declare function decodeFieldSchema(schema: FieldSchemaFormat): TreeFieldStoredSchema;
+/**
+ * Document schema data that can be stored in a document.
+ *
+ * @remarks
+ * Note: the owner of this may modify it over time:
+ * thus if needing to hand onto a specific version, make a copy.
+ * @internal
+ */
+export interface TreeStoredSchema extends StoredSchemaCollection {
+    /**
+     * Schema for the root field which contains the whole tree.
+     */
+    readonly rootFieldSchema: TreeFieldStoredSchema;
+}
+/**
+ * Collection of TreeNodeSchema data that can be stored in a document.
+ *
+ * @remarks
+ * Note: the owner of this may modify it over time:
+ * thus if needing to hang onto a specific version, make a copy.
+ * @internal
+ */
+export interface StoredSchemaCollection {
+    /**
+     * {@inheritdoc StoredSchemaCollection}
+     */
+    readonly nodeSchema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>;
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/core/schema-stored/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/core/schema-stored/schema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EACN,KAAK,EACL,MAAM,EACN,WAAW,EAOX,MAAM,YAAY,CAAC;AACpB,OAAO,EACN,QAAQ,EACR,mBAAmB,EACnB,iBAAiB,EAGjB,wBAAwB,EACxB,wBAAwB,EACxB,MAAM,UAAU,CAAC;AAElB;;;GAGG;AACH,oBAAY,WAAW;IACtB,MAAM,IAAA;IACN,MAAM,IAAA;IACN,OAAO,IAAA;IACP,WAAW,IAAA;IACX,IAAI,IAAA;CACJ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,wBAAwB,CAAC,GAAG,SAAS,CAAC;AAE5E;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,GAAG,mBAAmB;IAC1D,UAAU,EAAE,CAAC,CAAC;CACd;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACrC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC;CAC7B;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,cAAc,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,qBAKpC,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,8BAA+B,SAAQ,MAAM,CAAC,0BAA0B,CAAC;CAAG;AAC7F,MAAM,WAAW,+BAChB,SAAQ,KAAK,CAAC,wBAAwB,EAAE,8BAA8B,CAAC;CAAG;AAE3E;;GAEG;AACH,8BAAsB,oBAAoB;IACzC,SAAS,CAAC,UAAU,EAAG,WAAW,CAAC;IAEnC;;;;;OAKG;aACa,MAAM,IAAI,8BAA8B;CACxD;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,oBAAoB;aAU9C,gBAAgB,EAAE,WAAW,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAT/E;;;;;;;OAOG;gBAEc,gBAAgB,EAAE,WAAW,CAAC,QAAQ,EAAE,qBAAqB,CAAC;IAK/D,MAAM,IAAI,8BAA8B;CASxD;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,oBAAoB;aASzB,SAAS,EAAE,qBAAqB;IARnE;;;;;;;OAOG;gBACgC,SAAS,EAAE,qBAAqB;IAInD,MAAM,IAAI,8BAA8B;CAKxD;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,oBAAoB;aAa1B,SAAS,EAAE,WAAW;IAZzD;;;;;;;;;;;OAWG;gBACgC,SAAS,EAAE,WAAW;IAIzC,MAAM,IAAI,8BAA8B;CAKxD;AAED,eAAO,MAAM,4BAA4B,EAAE,4BAA4B,CACtE,wBAAwB,EACxB;CAAE,EACF,oBAAoB,CAanB,CAAC;AAoBH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,qBAAqB,GAAG,iBAAiB,CAQlF;AASD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,GAAG,qBAAqB,CAOlF;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAiB,SAAQ,sBAAsB;IAC/D;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,qBAAqB,CAAC;CAChD;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACtC;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,wBAAwB,EAAE,oBAAoB,CAAC,CAAC;CACjF"}

package/dist/core/schema-stored/schema.js

@@ -0,0 +1,174 @@
+"use strict";
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeFieldSchema = exports.encodeFieldSchema = exports.storedSchemaDecodeDispatcher = exports.LeafNodeStoredSchema = exports.MapNodeStoredSchema = exports.ObjectNodeStoredSchema = exports.TreeNodeStoredSchema = exports.storedEmptyFieldSchema = exports.forbiddenFieldKindIdentifier = exports.ValueSchema = void 0;
+const codec_1 = require("../../codec");
+const util_1 = require("../../util");
+const format_1 = require("./format");
+/**
+ * Schema for what {@link TreeValue} is allowed on a Leaf node.
+ * @internal
+ */
+var ValueSchema;
+(function (ValueSchema) {
+    ValueSchema[ValueSchema["Number"] = 0] = "Number";
+    ValueSchema[ValueSchema["String"] = 1] = "String";
+    ValueSchema[ValueSchema["Boolean"] = 2] = "Boolean";
+    ValueSchema[ValueSchema["FluidHandle"] = 3] = "FluidHandle";
+    ValueSchema[ValueSchema["Null"] = 4] = "Null";
+})(ValueSchema || (exports.ValueSchema = ValueSchema = {}));
+/**
+ * Identifier used for the FieldKind for fields which must be empty.
+ *
+ * @remarks
+ * This mainly show up in:
+ * 1. The root default field for documents.
+ * 2. The schema used for out of schema fields (which thus must be empty/not exist) on object and leaf nodes.
+ *
+ * @internal
+ */
+exports.forbiddenFieldKindIdentifier = "Forbidden";
+/**
+ * A schema for empty fields (fields which must always be empty).
+ * There are multiple ways this could be encoded, but this is the most explicit.
+ */
+exports.storedEmptyFieldSchema = {
+    // This kind requires the field to be empty.
+    kind: { identifier: (0, util_1.brand)(exports.forbiddenFieldKindIdentifier) },
+    // This type set also forces the field to be empty not not allowing any types as all.
+    types: new Set(),
+};
+/**
+ * @internal
+ */
+class TreeNodeStoredSchema {
+}
+exports.TreeNodeStoredSchema = TreeNodeStoredSchema;
+/**
+ * @internal
+ */
+class ObjectNodeStoredSchema extends TreeNodeStoredSchema {
+    /**
+     * @param objectNodeFields -
+     * Schema for fields with keys scoped to this TreeNodeStoredSchema.
+     * This refers to the TreeFieldStoredSchema directly
+     * (as opposed to just supporting FieldSchemaIdentifier and having a central FieldKey -\> TreeFieldStoredSchema map).
+     * This allows os short friendly field keys which can ergonomically used as field names in code.
+     * It also interoperates well with mapFields being used as a map with arbitrary data as keys.
+     */
+    constructor(objectNodeFields) {
+        super();
+        this.objectNodeFields = objectNodeFields;
+    }
+    encode() {
+        // Sort fields to ensure output is identical for for equivalent schema (since field order is not considered significant).
+        // This makes comparing schema easier, and ensures chunk reuse for schema summaries isn't needlessly broken.
+        return (0, util_1.brandErased)({
+            object: [...this.objectNodeFields]
+                .map(([k, v]) => encodeNamedField(k, v))
+                .sort(util_1.compareNamed),
+        });
+    }
+}
+exports.ObjectNodeStoredSchema = ObjectNodeStoredSchema;
+/**
+ * @internal
+ */
+class MapNodeStoredSchema extends TreeNodeStoredSchema {
+    /**
+     * @param mapFields -
+     * Allows using using the fields as a map, with the keys being
+     * FieldKeys and the values being constrained by this TreeFieldStoredSchema.
+     * Usually `FieldKind.Value` should NOT be used here
+     * since no nodes can ever be in schema are in schema if you use `FieldKind.Value` here
+     * (that would require infinite children).
+     */
+    constructor(mapFields) {
+        super();
+        this.mapFields = mapFields;
+    }
+    encode() {
+        return (0, util_1.brandErased)({
+            map: encodeFieldSchema(this.mapFields),
+        });
+    }
+}
+exports.MapNodeStoredSchema = MapNodeStoredSchema;
+/**
+ * @internal
+ */
+class LeafNodeStoredSchema extends TreeNodeStoredSchema {
+    /**
+     * @param leafValue -
+     * There are several approaches for how to store actual data in the tree
+     * (special node types, special field contents, data on nodes etc.)
+     * as well as several options about how the data should be modeled at this level
+     * (byte sequence? javascript type? json?),
+     * as well as options for how much of this would be exposed in the schema language
+     * (ex: would all nodes with values be special built-ins, or could any schema add them?)
+     * A simple easy to do in javascript approach is taken here:
+     * this is not intended to be a suggestion of what approach to take, or what to expose in the schema language.
+     * This is simply one approach that can work for modeling them in the internal schema representation.
+     */
+    constructor(leafValue) {
+        super();
+        this.leafValue = leafValue;
+    }
+    encode() {
+        return (0, util_1.brandErased)({
+            leaf: encodeValueSchema(this.leafValue),
+        });
+    }
+}
+exports.LeafNodeStoredSchema = LeafNodeStoredSchema;
+exports.storedSchemaDecodeDispatcher = new codec_1.DiscriminatedUnionDispatcher({
+    leaf: (data) => new LeafNodeStoredSchema(decodeValueSchema(data)),
+    object: (data) => new ObjectNodeStoredSchema(new Map(data.map((field) => [
+        (0, util_1.brand)(field.name),
+        decodeFieldSchema(field),
+    ]))),
+    map: (data) => new MapNodeStoredSchema(decodeFieldSchema(data)),
+});
+const valueSchemaEncode = new Map([
+    [ValueSchema.Number, format_1.PersistedValueSchema.Number],
+    [ValueSchema.String, format_1.PersistedValueSchema.String],
+    [ValueSchema.Boolean, format_1.PersistedValueSchema.Boolean],
+    [ValueSchema.FluidHandle, format_1.PersistedValueSchema.FluidHandle],
+    [ValueSchema.Null, format_1.PersistedValueSchema.Null],
+]);
+const valueSchemaDecode = (0, util_1.invertMap)(valueSchemaEncode);
+function encodeValueSchema(inMemory) {
+    return valueSchemaEncode.get(inMemory) ?? (0, util_1.fail)("missing PersistedValueSchema");
+}
+function decodeValueSchema(inMemory) {
+    return valueSchemaDecode.get(inMemory) ?? (0, util_1.fail)("missing ValueSchema");
+}
+function encodeFieldSchema(schema) {
+    const out = {
+        kind: schema.kind.identifier,
+    };
+    if (schema.types !== undefined) {
+        out.types = [...schema.types];
+    }
+    return out;
+}
+exports.encodeFieldSchema = encodeFieldSchema;
+function encodeNamedField(name, schema) {
+    return {
+        ...encodeFieldSchema(schema),
+        name,
+    };
+}
+function decodeFieldSchema(schema) {
+    const out = {
+        // TODO: maybe provide actual FieldKind objects here, error on unrecognized kinds.
+        kind: { identifier: schema.kind },
+        types: schema.types === undefined ? undefined : new Set(schema.types),
+    };
+    return out;
+}
+exports.decodeFieldSchema = decodeFieldSchema;
+//# sourceMappingURL=schema.js.map

package/dist/core/schema-stored/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/core/schema-stored/schema.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 { DiscriminatedUnionDispatcher } from \"../../codec\";\nimport {\n\tBrand,\n\tErased,\n\tMakeNominal,\n\tNamed,\n\tbrand,\n\tbrandErased,\n\tcompareNamed,\n\tfail,\n\tinvertMap,\n} from \"../../util\";\nimport {\n\tFieldKey,\n\tFieldKindIdentifier,\n\tFieldSchemaFormat,\n\tNamedFieldSchemaFormat,\n\tPersistedValueSchema,\n\tTreeNodeSchemaDataFormat,\n\tTreeNodeSchemaIdentifier,\n} from \"./format\";\n\n/**\n * Schema for what {@link TreeValue} is allowed on a Leaf node.\n * @internal\n */\nexport enum ValueSchema {\n\tNumber,\n\tString,\n\tBoolean,\n\tFluidHandle,\n\tNull,\n}\n\n/**\n * Set of allowed tree types.\n * Providing multiple values here allows polymorphism, tagged union style.\n *\n * If not specified, types are unconstrained\n * (equivalent to the set containing every TreeNodeSchemaIdentifier defined in the document).\n *\n * Note that even when unconstrained, children must still be in-schema for their own type.\n *\n * In the future, this could be extended to allow inlining a TreeNodeStoredSchema here\n * (or some similar structural schema system).\n * For structural types which could go here, there are a few interesting options:\n *\n * - Allow replacing the whole set with a structural type for terminal / non-tree data,\n * and use this as a replacement for values on the tree nodes.\n *\n * - Allow expression structural constraints for child trees, for example requiring specific traits\n * (ex: via TreeNodeStoredSchema), instead of by type.\n *\n * There are two ways this could work:\n *\n * - Constrain the child nodes based on their shape:\n * this makes schema safe editing difficult because nodes would incur extra editing constraints to prevent them\n * from going out of schema based on their location in such a field.\n *\n * - Constrain the types allowed based on which types guarantee their data will always meet the constraints.\n *\n * Care would need to be taken to make sure this is sound for the schema updating mechanisms.\n * @internal\n */\nexport type TreeTypeSet = ReadonlySet<TreeNodeSchemaIdentifier> | undefined;\n\n/**\n * Specifies which field kind to use.\n *\n * @remarks\n * This is used instead of just the FieldKindIdentifier so that it can be subtyped into a more expressive type with additional information.\n *\n * @internal\n */\nexport interface FieldKindSpecifier<T = FieldKindIdentifier> {\n\tidentifier: T;\n}\n\n/**\n * Schema for a field.\n * Object implementing this interface should never be modified.\n * @internal\n */\nexport interface TreeFieldStoredSchema {\n\treadonly kind: FieldKindSpecifier;\n\t/**\n\t * The set of allowed child types.\n\t * If not specified, types are unconstrained.\n\t */\n\treadonly types?: TreeTypeSet;\n}\n\n/**\n * Identifier used for the FieldKind for fields which must be empty.\n *\n * @remarks\n * This mainly show up in:\n * 1. The root default field for documents.\n * 2. The schema used for out of schema fields (which thus must be empty/not exist) on object and leaf nodes.\n *\n * @internal\n */\nexport const forbiddenFieldKindIdentifier = \"Forbidden\";\n\n/**\n * A schema for empty fields (fields which must always be empty).\n * There are multiple ways this could be encoded, but this is the most explicit.\n */\nexport const storedEmptyFieldSchema: TreeFieldStoredSchema = {\n\t// This kind requires the field to be empty.\n\tkind: { identifier: brand(forbiddenFieldKindIdentifier) },\n\t// This type set also forces the field to be empty not not allowing any types as all.\n\ttypes: new Set(),\n};\n\n/**\n * Opaque type erased handle to the encoded representation of the contents of a stored schema.\n * @internal\n */\nexport interface ErasedTreeNodeSchemaDataFormat extends Erased<\"TreeNodeSchemaDataFormat\"> {}\nexport interface BrandedTreeNodeSchemaDataFormat\n\textends Brand<TreeNodeSchemaDataFormat, ErasedTreeNodeSchemaDataFormat> {}\n\n/**\n * @internal\n */\nexport abstract class TreeNodeStoredSchema {\n\tprotected _typeCheck!: MakeNominal;\n\n\t/**\n\t * @privateRemarks\n\t * Returns TreeNodeSchemaDataFormat.\n\t * This is uses an opaque type to avoid leaking these types out of the package,\n\t * and is runtime validated by the codec.\n\t */\n\tpublic abstract encode(): ErasedTreeNodeSchemaDataFormat;\n}\n\n/**\n * @internal\n */\nexport class ObjectNodeStoredSchema extends TreeNodeStoredSchema {\n\t/**\n\t * @param objectNodeFields -\n\t * Schema for fields with keys scoped to this TreeNodeStoredSchema.\n\t * This refers to the TreeFieldStoredSchema directly\n\t * (as opposed to just supporting FieldSchemaIdentifier and having a central FieldKey -\\> TreeFieldStoredSchema map).\n\t * This allows os short friendly field keys which can ergonomically used as field names in code.\n\t * It also interoperates well with mapFields being used as a map with arbitrary data as keys.\n\t */\n\tpublic constructor(\n\t\tpublic readonly objectNodeFields: ReadonlyMap<FieldKey, TreeFieldStoredSchema>,\n\t) {\n\t\tsuper();\n\t}\n\n\tpublic override encode(): ErasedTreeNodeSchemaDataFormat {\n\t\t// Sort fields to ensure output is identical for for equivalent schema (since field order is not considered significant).\n\t\t// This makes comparing schema easier, and ensures chunk reuse for schema summaries isn't needlessly broken.\n\t\treturn brandErased<BrandedTreeNodeSchemaDataFormat>({\n\t\t\tobject: [...this.objectNodeFields]\n\t\t\t\t.map(([k, v]) => encodeNamedField(k, v))\n\t\t\t\t.sort(compareNamed),\n\t\t});\n\t}\n}\n\n/**\n * @internal\n */\nexport class MapNodeStoredSchema extends TreeNodeStoredSchema {\n\t/**\n\t * @param mapFields -\n\t * Allows using using the fields as a map, with the keys being\n\t * FieldKeys and the values being constrained by this TreeFieldStoredSchema.\n\t * Usually `FieldKind.Value` should NOT be used here\n\t * since no nodes can ever be in schema are in schema if you use `FieldKind.Value` here\n\t * (that would require infinite children).\n\t */\n\tpublic constructor(public readonly mapFields: TreeFieldStoredSchema) {\n\t\tsuper();\n\t}\n\n\tpublic override encode(): ErasedTreeNodeSchemaDataFormat {\n\t\treturn brandErased<BrandedTreeNodeSchemaDataFormat>({\n\t\t\tmap: encodeFieldSchema(this.mapFields),\n\t\t});\n\t}\n}\n\n/**\n * @internal\n */\nexport class LeafNodeStoredSchema extends TreeNodeStoredSchema {\n\t/**\n\t * @param leafValue -\n\t * There are several approaches for how to store actual data in the tree\n\t * (special node types, special field contents, data on nodes etc.)\n\t * as well as several options about how the data should be modeled at this level\n\t * (byte sequence? javascript type? json?),\n\t * as well as options for how much of this would be exposed in the schema language\n\t * (ex: would all nodes with values be special built-ins, or could any schema add them?)\n\t * A simple easy to do in javascript approach is taken here:\n\t * this is not intended to be a suggestion of what approach to take, or what to expose in the schema language.\n\t * This is simply one approach that can work for modeling them in the internal schema representation.\n\t */\n\tpublic constructor(public readonly leafValue: ValueSchema) {\n\t\tsuper();\n\t}\n\n\tpublic override encode(): ErasedTreeNodeSchemaDataFormat {\n\t\treturn brandErased<BrandedTreeNodeSchemaDataFormat>({\n\t\t\tleaf: encodeValueSchema(this.leafValue),\n\t\t});\n\t}\n}\n\nexport const storedSchemaDecodeDispatcher: DiscriminatedUnionDispatcher<\n\tTreeNodeSchemaDataFormat,\n\t[],\n\tTreeNodeStoredSchema\n> = new DiscriminatedUnionDispatcher({\n\tleaf: (data: PersistedValueSchema) => new LeafNodeStoredSchema(decodeValueSchema(data)),\n\tobject: (data: NamedFieldSchemaFormat[]) =>\n\t\tnew ObjectNodeStoredSchema(\n\t\t\tnew Map(\n\t\t\t\tdata.map((field): [FieldKey, TreeFieldStoredSchema] => [\n\t\t\t\t\tbrand(field.name),\n\t\t\t\t\tdecodeFieldSchema(field),\n\t\t\t\t]),\n\t\t\t),\n\t\t),\n\tmap: (data: FieldSchemaFormat) => new MapNodeStoredSchema(decodeFieldSchema(data)),\n});\n\nconst valueSchemaEncode = new Map([\n\t[ValueSchema.Number, PersistedValueSchema.Number],\n\t[ValueSchema.String, PersistedValueSchema.String],\n\t[ValueSchema.Boolean, PersistedValueSchema.Boolean],\n\t[ValueSchema.FluidHandle, PersistedValueSchema.FluidHandle],\n\t[ValueSchema.Null, PersistedValueSchema.Null],\n]);\n\nconst valueSchemaDecode = invertMap(valueSchemaEncode);\n\nfunction encodeValueSchema(inMemory: ValueSchema): PersistedValueSchema {\n\treturn valueSchemaEncode.get(inMemory) ?? fail(\"missing PersistedValueSchema\");\n}\n\nfunction decodeValueSchema(inMemory: PersistedValueSchema): ValueSchema {\n\treturn valueSchemaDecode.get(inMemory) ?? fail(\"missing ValueSchema\");\n}\n\nexport function encodeFieldSchema(schema: TreeFieldStoredSchema): FieldSchemaFormat {\n\tconst out: FieldSchemaFormat = {\n\t\tkind: schema.kind.identifier,\n\t};\n\tif (schema.types !== undefined) {\n\t\tout.types = [...schema.types];\n\t}\n\treturn out;\n}\n\nfunction encodeNamedField<T>(name: T, schema: TreeFieldStoredSchema): FieldSchemaFormat & Named<T> {\n\treturn {\n\t\t...encodeFieldSchema(schema),\n\t\tname,\n\t};\n}\n\nexport function decodeFieldSchema(schema: FieldSchemaFormat): TreeFieldStoredSchema {\n\tconst out: TreeFieldStoredSchema = {\n\t\t// TODO: maybe provide actual FieldKind objects here, error on unrecognized kinds.\n\t\tkind: { identifier: schema.kind },\n\t\ttypes: schema.types === undefined ? undefined : new Set(schema.types),\n\t};\n\treturn out;\n}\n\n/**\n * Document schema data that can be stored in a document.\n *\n * @remarks\n * Note: the owner of this may modify it over time:\n * thus if needing to hand onto a specific version, make a copy.\n * @internal\n */\nexport interface TreeStoredSchema extends StoredSchemaCollection {\n\t/**\n\t * Schema for the root field which contains the whole tree.\n\t */\n\treadonly rootFieldSchema: TreeFieldStoredSchema;\n}\n\n/**\n * Collection of TreeNodeSchema data that can be stored in a document.\n *\n * @remarks\n * Note: the owner of this may modify it over time:\n * thus if needing to hang onto a specific version, make a copy.\n * @internal\n */\nexport interface StoredSchemaCollection {\n\t/**\n\t * {@inheritdoc StoredSchemaCollection}\n\t */\n\treadonly nodeSchema: ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>;\n}\n"]}

package/dist/core/schema-stored/storedSchemaRepository.d.ts

@@ -0,0 +1,71 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import BTree from "sorted-btree";
+import { ISubscribable } from "../../events";
+import { TreeFieldStoredSchema, TreeNodeStoredSchema, TreeStoredSchema } from "./schema";
+import { TreeNodeSchemaIdentifier } from "./format";
+/**
+ * Events for {@link TreeStoredSchemaSubscription}.
+ *
+ * TODO: consider having before and after events per subtree instead while applying anchor (and this just shows what happens at the root).
+ * @internal
+ */
+export interface SchemaEvents {
+    /**
+     * Schema change is about to be applied.
+     */
+    beforeSchemaChange(newSchema: TreeStoredSchema): void;
+    /**
+     * Schema change was just applied.
+     */
+    afterSchemaChange(newSchema: TreeStoredSchema): void;
+}
+/**
+ * A collection of stored schema that fires events in response to changes.
+ * @internal
+ */
+export interface TreeStoredSchemaSubscription extends ISubscribable<SchemaEvents>, TreeStoredSchema {
+}
+/**
+ * Mutable collection of stored schema.
+ * @internal
+ */
+export interface MutableTreeStoredSchema extends TreeStoredSchemaSubscription {
+    /**
+     * Mutates the stored schema.
+     * Replaces all schema with the provided schema.
+     * Can over-write preexisting schema, and removes unmentioned schema.
+     */
+    apply(newSchema: TreeStoredSchema): void;
+}
+/**
+ * Mutable TreeStoredSchema repository.
+ */
+export declare class TreeStoredSchemaRepository implements MutableTreeStoredSchema {
+    protected nodeSchemaData: BTree<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>;
+    protected rootFieldSchemaData: TreeFieldStoredSchema;
+    protected readonly events: ISubscribable<SchemaEvents> & import("../../events").IEmitter<SchemaEvents> & import("../../events").HasListeners<SchemaEvents>;
+    /**
+     * Copies in the provided schema. If `data` is an TreeStoredSchemaRepository, it will be cheap-cloned.
+     * Otherwise, it will be deep-cloned.
+     *
+     * We might not want to store schema in maps long term, as we might want a way to reserve a
+     * large space of schema IDs within a schema.
+     * The way mapFields has been structured mitigates the need for this, but it still might be useful.
+     *
+     * (ex: someone using data as field identifiers might want to
+     * reserve all fields identifiers starting with "foo." to have a specific schema).
+     * Combined with support for such namespaces in the allowed sets in the schema objects,
+     * that might provide a decent alternative to mapFields (which is a bit odd).
+     */
+    constructor(data?: TreeStoredSchema);
+    on<K extends keyof SchemaEvents>(eventName: K, listener: SchemaEvents[K]): () => void;
+    get nodeSchema(): ReadonlyMap<TreeNodeSchemaIdentifier, TreeNodeStoredSchema>;
+    get rootFieldSchema(): TreeFieldStoredSchema;
+    apply(newSchema: TreeStoredSchema): void;
+    clone(): TreeStoredSchemaRepository;
+}
+export declare function schemaDataIsEmpty(data: TreeStoredSchema): boolean;
+//# sourceMappingURL=storedSchemaRepository.d.ts.map

package/dist/core/schema-stored/storedSchemaRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storedSchemaRepository.d.ts","sourceRoot":"","sources":["../../../src/core/schema-stored/storedSchemaRepository.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,MAAM,cAAc,CAAC;AACjC,OAAO,EAAiB,aAAa,EAAE,MAAM,cAAc,CAAC;AAE5D,OAAO,EAEN,qBAAqB,EACrB,oBAAoB,EACpB,gBAAgB,EAEhB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC5B;;OAEG;IACH,kBAAkB,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAEtD;;OAEG;IACH,iBAAiB,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACrD;AAED;;;GAGG;AACH,MAAM,WAAW,4BAChB,SAAQ,aAAa,CAAC,YAAY,CAAC,EAClC,gBAAgB;CAAG;AAErB;;;GAGG;AACH,MAAM,WAAW,uBAAwB,SAAQ,4BAA4B;IAC5E;;;;OAIG;IACH,KAAK,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI,CAAC;CACzC;AAED;;GAEG;AACH,qBAAa,0BAA2B,YAAW,uBAAuB;IACzE,SAAS,CAAC,cAAc,EAAE,KAAK,CAAC,wBAAwB,EAAE,oBAAoB,CAAC,CAAC;IAChF,SAAS,CAAC,mBAAmB,EAAE,qBAAqB,CAAC;IACrD,SAAS,CAAC,QAAQ,CAAC,MAAM,kIAAiC;IAE1D;;;;;;;;;;;;OAYG;gBACgB,IAAI,CAAC,EAAE,gBAAgB;IAkBnC,EAAE,CAAC,CAAC,SAAS,MAAM,YAAY,EAAE,SAAS,EAAE,CAAC,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IAI5F,IAAW,UAAU,IAAI,WAAW,CAAC,wBAAwB,EAAE,oBAAoB,CAAC,CAMnF;IAED,IAAW,eAAe,IAAI,qBAAqB,CAElD;IAEM,KAAK,CAAC,SAAS,EAAE,gBAAgB,GAAG,IAAI;IASxC,KAAK,IAAI,0BAA0B;CAG1C;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAEjE"}