@fluidframework/container-runtime 2.0.0-dev-rc.2.0.0.245554 → 2.0.0-dev-rc.3.0.0.250606

package/dist/summary/documentSchema.d.ts

@@ -0,0 +1,178 @@
+/**
+ * Descripe allowed type for properties in document schema.
+ * Please note that for all property types we should use undefined to indicate that particular capability is off.
+ * Using false, or some string value (like "off") will result in clients who do not understand that property failing, whereas
+ * we want them to continue to collaborate alongside clients who support that capability, but such capability is shipping dark for now.
+ * @alpha
+ */
+export type DocumentSchemaValueType = string | true | number | undefined;
+/**
+ * ID Compressor mode.
+ * "on" - compressor is On. It's loaded as part of container load. This mode is sticky - once on, compressor is On for all
+ * sessions for a given document. This results in IContainerRuntime.idCompressor to be always available.
+ * "delayed" - ID compressor bundle is loaded only on establishing of first delta connection, i.e. it does not impact boot of cotnainer.
+ * In such mode IContainerRuntime.idCompressor is not made available (unless previous sessions of same document had it "On").
+ * The only thing that is available is IContainerRuntime.generateDocumentUniqueId() that provides opportunistically short IDs.
+ * undefined - ID compressor is not loaded.
+ * While IContainerRuntime.generateDocumentUniqueId() is available, it will produce long IDs that are do not compress well.
+ *
+ * @alpha
+ */
+export type IdCompressorMode = "on" | "delayed" | undefined;
+/**
+ * Document schema information.
+ * Describes overall shape of document schema, including unknown (to this version) properties.
+ *
+ * Used by runtime to make a call if it can understand document schema.
+ * If it can't, it should not continue with document and immediately fail, preventing random (cryptic) failures
+ * down the road and potentially corrupting documents.
+ * For now this structure and appropriate interpretation / behavior is focused only on runtime features.
+ * In the future that could be interpolated to more areas, including DDSs used, and even possibly - application
+ * schema.
+ *
+ * Runtime will ignore any properties at the root that it does not understand (i.e. IDocumentSchema.app), but will
+ * stop (and fail session) on any unknown properties within "runtime" sub-tree.
+ *
+ * In most cases values preserved in the document will not dictate if such features should be enabled in a given session.
+ * I.e. if compression is mentioned in document schema, this means that runtime version that opens such document must know
+ * how to interpret such ops, but does not need to actually use compression itself. That said, some options could be
+ * sticky, i.e. influence feature selection for all runtimes opening a document. ID compression is one such example.
+ * Currently there is no mechanism to remove feature from this property bag, i.e. once compression was used, even if it's
+ * disabled (through feature gate or code deployment), all existing documents that used compression will continue to fail
+ * if opened by clients who do not support compression.
+ *
+ * For now we are limiting it to just plain properties, and only really simple types, but that can be changed in the future.
+ *
+ * @alpha
+ */
+export interface IDocumentSchema {
+    version: number;
+    refSeq: number;
+    runtime: Record<string, DocumentSchemaValueType>;
+}
+/**
+ * Content of the type=ContainerMessageType.DocumentSchemaChange ops.
+ * The meaning of refSeq field is different in such messages (compared to other usages of IDocumentSchemaCurrent)
+ * ContainerMessageType.DocumentSchemaChange messages use CAS (Compare-and-swap) semantics, and convey
+ * regSeq of last known schema change (known to a client proposing schema change).
+ * @see ContainerRuntimeDocumentSchemaMessage
+ * @alpha
+ */
+export type IDocumentSchemaChangeMessage = IDocumentSchema;
+/**
+ * Settings that this session would like to have, based on options and feature gates.
+ *
+ * WARNING: This type is used to infer IDocumentSchemaCurrent type!
+ * Any changes here (including renaming of properties) are potentially changing document format and should be considered carefully!
+ *
+ * @alpha
+ */
+export interface IDocumentSchemaFeatures {
+    explicitSchemaControl: boolean;
+    compressionLz4: boolean;
+    idCompressorMode: IdCompressorMode;
+    opGroupingEnabled: boolean;
+}
+/**
+ * Current version known properties that define document schema
+ * This must be bumped whenever the format of document schema or protocol for changing the current document schema changes.
+ * Ex: adding a new configuration property (under IDocumentSchema.runtime) does not require changing this version.
+ * Ex: Changing the 'document schema acceptance' mechanism from convert-and-swap to one requiring consensus does require changing this version.
+ * @alpha
+ */
+export declare const currentDocumentVersionSchema = 1;
+/**
+ * Current document schema.
+ * @alpha
+ */
+export type IDocumentSchemaCurrent = {
+    version: 1;
+    refSeq: number;
+    runtime: {
+        [P in keyof IDocumentSchemaFeatures]?: IDocumentSchemaFeatures[P] extends boolean ? true : IDocumentSchemaFeatures[P];
+    };
+};
+/**
+ * Controller of document schema.
+ *
+ * Recommended pre-reading: https://github.com/microsoft/FluidFramework/blob/main/packages/dds/SchemaVersioning.md
+ *
+ * This class manages current document schema and transitions between document schemas.
+ * At the moment, it only focuses on subset of document schema, specifically - how FluidFramework runtime serializes data
+ * (summary and op format), features & capabilities that a version of runtime has to support and understand in
+ * order to collaborate on a document.
+ * New features that modify document format have to be included in document schema definition.
+ * Usage of such features could only happen after document schema has been updated to reflect such feature.
+ *
+ * This formality allows clients that do not understand such features to fail right away when they observe
+ * document schema listing capabilities that such client does not understand.
+ * Old clients will fail in predictable way. This allows us to
+ * 1) Immediately see such issues and adjust if features are enabled too early, before changes have been saturated.
+ * 2) There is no way to get to 100% saturation with new code. Even if we have 99.99% saturation, there are
+ *    still 0.01% of clients who will fail. Failing early and predictably ensures they have no chance to limp along
+ *    and potentially corrupt the document. This is especially true for summarizer client, who could simply "undo"
+ *    changes it does not understands.
+ *
+ * It's important to note how it overlaps with feature gates and safe velocity.
+ * If new feature was in use, that resulted in a number of documents referencing such feature in document schema.
+ * But, developers (through code deployment or feature gates) could disable usage of such features.
+ * That will stop a process of further document schema changes (for documents that were not using such feature).
+ * And documents that already list such capability in their schema will continue to do so. Later ensures that old
+ * clients who do not understand such feature will continue to fail to open such documents, as such documents very
+ * likely contain data in a new format.
+ *
+ * Users of this class need to use DocumentsSchemaController.sessionSchema to determine what features can be used.
+ *
+ * There are two modes this class can operate:
+ * 1) Legacy mode. In such mode it does not issue any ops to change document schema. Any changes happen implicitly,
+ *    right away, and new features are available right away
+ * 2) Non-legacy mode. In such mode any changes to schema require an op roundtrip. This class will manage such transitions.
+ *    However code should assume that any new features that were not enabled in a given document will not be available
+ *    for a given session. That's because this session may never send any ops (including read-only documents). Or it may
+ *    fail to convert schema.
+ *    This class promises eventual movement forward. I.e. if new feature is allowed (let's say - through feature gates),
+ *    then eventually all documents that are modified will have that feature reflected in their schema. It could require
+ *    multiple reloads / new sessions to get there (depends on if code reacts to schema changes right away, or only consults
+ *    schema on document load).
+ *
+ * How schemas are changed (in non-legacy mode):
+ * If a client needs to change a schema, it will attempt to do so as part of normal ops sending process.
+ * Changes happen in CAS (Compare-and-swap) fashion, i.e. client tells current schema and schema it wants to change to.
+ * When a number of clients race to change a schema, then only one of them will win, all others will fail because they will
+ * reference old schema that is no longer in effect.
+ * Clients can retry, but current implementation is simply - they will not (and will rely on next session / reload to do
+ * recalc and decide if schema needs to be changed or not).
+ *
+ * @alpha
+ */
+export declare class DocumentsSchemaController {
+    private readonly onSchemaChange;
+    private explicitSchemaControl;
+    private sendOp;
+    private documentSchema;
+    private readonly desiredSchema;
+    private futureSchema;
+    sessionSchema: IDocumentSchemaCurrent;
+    /**
+     * Constructs DocumentsSchemaController that controls current schema and processes around it, including changes in schema.
+     * @param explicitSchemaControl - Tells if schema changes are done implicitly (without ops - legacy behavior), or go through formal schema change ops process.
+     * @param existing - Is the document existing document, or a new doc.
+     * @param documentMetadataSchema - current document's schema, if present.
+     * @param compressionAlgorithm - desired compression algorith to use
+     * @param idCompressorModeArg - desired ID compressor mode to use
+     * @param opGroupingEnabled - true if it's desired to use op grouping.
+     */
+    constructor(existing: boolean, documentMetadataSchema: IDocumentSchema | undefined, features: IDocumentSchemaFeatures, onSchemaChange: (schema: IDocumentSchemaCurrent) => void);
+    summarizeDocumentSchema(refSeq: number): IDocumentSchemaCurrent | undefined;
+    onMessageSent(send: (content: IDocumentSchemaChangeMessage) => void): void;
+    /**
+     * Process document schema change message
+     * @param content - content of the message
+     * @param local - whether op is local
+     * @param sequenceNumber - sequence number of the op
+     * @returns - true if schema was accepted, otherwise false (rejected due to failed CAS)
+     */
+    processDocumentSchemaOp(content: IDocumentSchemaChangeMessage, local: boolean, sequenceNumber: number): boolean;
+    onDisconnect(): void;
+}
+//# sourceMappingURL=documentSchema.d.ts.map

package/dist/summary/documentSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentSchema.d.ts","sourceRoot":"","sources":["../../src/summary/documentSchema.ts"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,GAAG,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,SAAS,CAAC;AAEzE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,SAAS,GAAG,SAAS,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,eAAe;IAI/B,OAAO,EAAE,MAAM,CAAC;IAGhB,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;CACjD;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,4BAA4B,GAAG,eAAe,CAAC;AAE3D;;;;;;;GAOG;AACH,MAAM,WAAW,uBAAuB;IAIvC,qBAAqB,EAAE,OAAO,CAAC;IAC/B,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,iBAAiB,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,IAAI,CAAC;AAE9C;;;GAGG;AAEH,MAAM,MAAM,sBAAsB,GAAG;IACpC,OAAO,EAAE,CAAC,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,EAAE;SACP,CAAC,IAAI,MAAM,uBAAuB,CAAC,CAAC,EAAE,uBAAuB,CAAC,CAAC,CAAC,SAAS,OAAO,GAC9E,IAAI,GACJ,uBAAuB,CAAC,CAAC,CAAC;KAC7B,CAAC;CACF,CAAC;AAuMF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,qBAAa,yBAAyB;IAkCpC,OAAO,CAAC,QAAQ,CAAC,cAAc;IAjChC,OAAO,CAAC,qBAAqB,CAAU;IACvC,OAAO,CAAC,MAAM,CAAQ;IAGtB,OAAO,CAAC,cAAc,CAAyB;IAI/C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAyB;IAGvD,OAAO,CAAC,YAAY,CAAqC;IAOlD,aAAa,EAAE,sBAAsB,CAAC;IAE7C;;;;;;;;OAQG;gBAEF,QAAQ,EAAE,OAAO,EACjB,sBAAsB,EAAE,eAAe,GAAG,SAAS,EACnD,QAAQ,EAAE,uBAAuB,EAChB,cAAc,EAAE,CAAC,MAAM,EAAE,sBAAsB,KAAK,IAAI;IAyDnE,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS;IAmB3E,aAAa,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,4BAA4B,KAAK,IAAI;IAe1E;;;;;;OAMG;IACI,uBAAuB,CAC7B,OAAO,EAAE,4BAA4B,EACrC,KAAK,EAAE,OAAO,EACd,cAAc,EAAE,MAAM;IAyChB,YAAY;CAGnB"}

package/dist/summary/documentSchema.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentsSchemaController = exports.currentDocumentVersionSchema = void 0;
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+const core_utils_1 = require("@fluidframework/core-utils");
+const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+/**
+ * Current version known properties that define document schema
+ * This must be bumped whenever the format of document schema or protocol for changing the current document schema changes.
+ * Ex: adding a new configuration property (under IDocumentSchema.runtime) does not require changing this version.
+ * Ex: Changing the 'document schema acceptance' mechanism from convert-and-swap to one requiring consensus does require changing this version.
+ * @alpha
+ */
+exports.currentDocumentVersionSchema = 1;
+class TrueOrUndefined {
+    and(currentDocSchema, desiredDocSchema) {
+        return currentDocSchema === true && desiredDocSchema === true ? true : undefined;
+    }
+    or(currentDocSchema, desiredDocSchema) {
+        return currentDocSchema === true || desiredDocSchema === true ? true : undefined;
+    }
+    validate(t) {
+        return t === undefined || t === true;
+    }
+}
+class TrueOrUndefinedMax extends TrueOrUndefined {
+    and(currentDocSchema, desiredDocSchema) {
+        return this.or(currentDocSchema, desiredDocSchema);
+    }
+}
+class MultiChoice {
+    constructor(choices) {
+        this.choices = choices;
+    }
+    and(currentDocSchema, desiredDocSchema) {
+        if (currentDocSchema === undefined || desiredDocSchema === undefined) {
+            return undefined;
+        }
+        return this.choices[Math.min(this.choices.indexOf(currentDocSchema), this.choices.indexOf(desiredDocSchema))];
+    }
+    or(currentDocSchema, desiredDocSchema) {
+        if (currentDocSchema === undefined) {
+            return desiredDocSchema;
+        }
+        if (desiredDocSchema === undefined) {
+            return currentDocSchema;
+        }
+        return this.choices[Math.max(this.choices.indexOf(currentDocSchema), this.choices.indexOf(desiredDocSchema))];
+    }
+    validate(t) {
+        return t === undefined || (typeof t === "string" && this.choices.includes(t));
+    }
+}
+class IdCompressorProperty extends MultiChoice {
+    // document schema always wins!
+    and(currentDocSchema, desiredDocSchema) {
+        return currentDocSchema;
+    }
+}
+/**
+ * Helper structure to valida if a schema is compatible with existing code.
+ */
+const documentSchemaSupportedConfigs = {
+    explicitSchemaControl: new TrueOrUndefinedMax(),
+    idCompressorMode: new IdCompressorProperty(["delayed", "on"]),
+    opGroupingEnabled: new TrueOrUndefined(),
+    compressionLz4: new TrueOrUndefined(),
+};
+/**
+ * Checks if a given schema is compatible with current code, i.e. if current code can understand all the features of that schema.
+ * If schema is not compatible with current code, it throws an exception.
+ * @param documentSchema - current schema
+ */
+function checkRuntimeCompatibility(documentSchema) {
+    // Back-compat - we can't do anything about legacy documents.
+    // There is no way to validate them, so we are taking a guess that safe deployment processes used by a given app
+    // do not run into compat problems.
+    if (documentSchema === undefined) {
+        return;
+    }
+    const msg = "Document can't be opened with current version of the code";
+    if (documentSchema.version !== exports.currentDocumentVersionSchema) {
+        throw telemetry_utils_1.DataProcessingError.create(msg, "checkRuntimeCompat", undefined, // message
+        {
+            runtimeSchemaVersion: documentSchema.version,
+            currentRuntimeSchemaVersion: exports.currentDocumentVersionSchema,
+        });
+    }
+    let unknownProperty;
+    const regSeq = documentSchema.refSeq;
+    // defence in depth - it should not be possible to get here anything other than integer, but worth validating it.
+    if (typeof regSeq !== "number" || regSeq < 0 || !Number.isInteger(regSeq)) {
+        unknownProperty = "refSeq";
+    }
+    else if (documentSchema.runtime === null || typeof documentSchema.runtime !== "object") {
+        unknownProperty = "runtime";
+    }
+    else {
+        for (const [name, value] of Object.entries(documentSchema.runtime)) {
+            const validator = documentSchemaSupportedConfigs[name];
+            if (validator === undefined || !validator.validate(value)) {
+                unknownProperty = `runtime/${name}`;
+            }
+        }
+    }
+    if (unknownProperty !== undefined) {
+        const value = documentSchema[unknownProperty];
+        throw telemetry_utils_1.DataProcessingError.create(msg, "checkRuntimeCompat", undefined, // message
+        {
+            codeVersion: exports.currentDocumentVersionSchema,
+            property: unknownProperty,
+            value,
+        });
+    }
+}
+function and(currentDocSchema, desiredDocSchema) {
+    const runtime = {};
+    for (const key of new Set([
+        ...Object.keys(currentDocSchema.runtime),
+        ...Object.keys(desiredDocSchema.runtime),
+    ])) {
+        runtime[key] = documentSchemaSupportedConfigs[key].and(currentDocSchema.runtime[key], desiredDocSchema.runtime[key]);
+    }
+    return {
+        version: exports.currentDocumentVersionSchema,
+        refSeq: currentDocSchema.refSeq,
+        runtime,
+    };
+}
+function or(currentDocSchema, desiredDocSchema) {
+    const runtime = {};
+    for (const key of new Set([
+        ...Object.keys(currentDocSchema.runtime),
+        ...Object.keys(desiredDocSchema.runtime),
+    ])) {
+        runtime[key] = documentSchemaSupportedConfigs[key].or(currentDocSchema.runtime[key], desiredDocSchema.runtime[key]);
+    }
+    return {
+        version: exports.currentDocumentVersionSchema,
+        refSeq: currentDocSchema.refSeq,
+        runtime,
+    };
+}
+function same(currentDocSchema, desiredDocSchema) {
+    for (const key of new Set([
+        ...Object.keys(currentDocSchema.runtime),
+        ...Object.keys(desiredDocSchema.runtime),
+    ])) {
+        // If schemas differ only by type of behavior, then we should not send schema change ops!
+        if (key !== "explicitSchemaControl" &&
+            currentDocSchema.runtime[key] !== desiredDocSchema.runtime[key]) {
+            return false;
+        }
+    }
+    return true;
+}
+function boolToProp(b) {
+    return b ? true : undefined;
+}
+/* eslint-disable jsdoc/check-indentation */
+/**
+ * Controller of document schema.
+ *
+ * Recommended pre-reading: https://github.com/microsoft/FluidFramework/blob/main/packages/dds/SchemaVersioning.md
+ *
+ * This class manages current document schema and transitions between document schemas.
+ * At the moment, it only focuses on subset of document schema, specifically - how FluidFramework runtime serializes data
+ * (summary and op format), features & capabilities that a version of runtime has to support and understand in
+ * order to collaborate on a document.
+ * New features that modify document format have to be included in document schema definition.
+ * Usage of such features could only happen after document schema has been updated to reflect such feature.
+ *
+ * This formality allows clients that do not understand such features to fail right away when they observe
+ * document schema listing capabilities that such client does not understand.
+ * Old clients will fail in predictable way. This allows us to
+ * 1) Immediately see such issues and adjust if features are enabled too early, before changes have been saturated.
+ * 2) There is no way to get to 100% saturation with new code. Even if we have 99.99% saturation, there are
+ *    still 0.01% of clients who will fail. Failing early and predictably ensures they have no chance to limp along
+ *    and potentially corrupt the document. This is especially true for summarizer client, who could simply "undo"
+ *    changes it does not understands.
+ *
+ * It's important to note how it overlaps with feature gates and safe velocity.
+ * If new feature was in use, that resulted in a number of documents referencing such feature in document schema.
+ * But, developers (through code deployment or feature gates) could disable usage of such features.
+ * That will stop a process of further document schema changes (for documents that were not using such feature).
+ * And documents that already list such capability in their schema will continue to do so. Later ensures that old
+ * clients who do not understand such feature will continue to fail to open such documents, as such documents very
+ * likely contain data in a new format.
+ *
+ * Users of this class need to use DocumentsSchemaController.sessionSchema to determine what features can be used.
+ *
+ * There are two modes this class can operate:
+ * 1) Legacy mode. In such mode it does not issue any ops to change document schema. Any changes happen implicitly,
+ *    right away, and new features are available right away
+ * 2) Non-legacy mode. In such mode any changes to schema require an op roundtrip. This class will manage such transitions.
+ *    However code should assume that any new features that were not enabled in a given document will not be available
+ *    for a given session. That's because this session may never send any ops (including read-only documents). Or it may
+ *    fail to convert schema.
+ *    This class promises eventual movement forward. I.e. if new feature is allowed (let's say - through feature gates),
+ *    then eventually all documents that are modified will have that feature reflected in their schema. It could require
+ *    multiple reloads / new sessions to get there (depends on if code reacts to schema changes right away, or only consults
+ *    schema on document load).
+ *
+ * How schemas are changed (in non-legacy mode):
+ * If a client needs to change a schema, it will attempt to do so as part of normal ops sending process.
+ * Changes happen in CAS (Compare-and-swap) fashion, i.e. client tells current schema and schema it wants to change to.
+ * When a number of clients race to change a schema, then only one of them will win, all others will fail because they will
+ * reference old schema that is no longer in effect.
+ * Clients can retry, but current implementation is simply - they will not (and will rely on next session / reload to do
+ * recalc and decide if schema needs to be changed or not).
+ *
+ * @alpha
+ */
+class DocumentsSchemaController {
+    /**
+     * Constructs DocumentsSchemaController that controls current schema and processes around it, including changes in schema.
+     * @param explicitSchemaControl - Tells if schema changes are done implicitly (without ops - legacy behavior), or go through formal schema change ops process.
+     * @param existing - Is the document existing document, or a new doc.
+     * @param documentMetadataSchema - current document's schema, if present.
+     * @param compressionAlgorithm - desired compression algorith to use
+     * @param idCompressorModeArg - desired ID compressor mode to use
+     * @param opGroupingEnabled - true if it's desired to use op grouping.
+     */
+    constructor(existing, documentMetadataSchema, features, onSchemaChange) {
+        this.onSchemaChange = onSchemaChange;
+        this.sendOp = true;
+        checkRuntimeCompatibility(documentMetadataSchema);
+        this.documentSchema =
+            documentMetadataSchema ??
+                ({
+                    version: exports.currentDocumentVersionSchema,
+                    // see comment in summarizeDocumentSchema() on why it has to stay zero
+                    refSeq: 0,
+                    // If it's existing document and it has no schema, then it was written by legacy client.
+                    // If it's a new document, then we define it's legacy-related behaviors.
+                    runtime: {
+                        explicitSchemaControl: boolToProp(!existing && features.explicitSchemaControl),
+                    },
+                });
+        // Use legacy behavior only if both document and options tell us to use legacy.
+        // Otherwise it's no longer legacy time!
+        this.explicitSchemaControl =
+            this.documentSchema.runtime.explicitSchemaControl === true ||
+                features.explicitSchemaControl;
+        this.desiredSchema = {
+            version: exports.currentDocumentVersionSchema,
+            refSeq: this.documentSchema.refSeq,
+            runtime: {
+                explicitSchemaControl: boolToProp(features.explicitSchemaControl),
+                compressionLz4: boolToProp(features.compressionLz4),
+                idCompressorMode: features.idCompressorMode,
+                opGroupingEnabled: boolToProp(features.opGroupingEnabled),
+            },
+        };
+        if (!this.explicitSchemaControl || !existing) {
+            this.sessionSchema = this.desiredSchema;
+            (0, core_utils_1.assert)(boolToProp(this.explicitSchemaControl) ===
+                this.sessionSchema.runtime.explicitSchemaControl, "explicitSchemaControl");
+            this.futureSchema = undefined;
+        }
+        else {
+            this.sessionSchema = and(this.documentSchema, this.desiredSchema);
+            this.futureSchema = or(this.documentSchema, this.desiredSchema);
+            (0, core_utils_1.assert)(this.sessionSchema.runtime.explicitSchemaControl === true, "legacy");
+            (0, core_utils_1.assert)(this.futureSchema.runtime.explicitSchemaControl === true, "legacy");
+            if (same(this.documentSchema, this.futureSchema)) {
+                this.futureSchema = undefined;
+            }
+        }
+        // Validate that schema we are operating in is actually a schema we consider compatible with current runtime.
+        checkRuntimeCompatibility(this.sessionSchema);
+        checkRuntimeCompatibility(this.futureSchema);
+    }
+    summarizeDocumentSchema(refSeq) {
+        // For legacy behavior, we could write nothing (return undefined).
+        // It does not buy us anything, as whatever written in summary does not actually impact clients operating in legacy mode.
+        // But writing current used config (and assuming most of the clients settle on same config over time) will help with transition
+        // out of legacy mode, as clients transitioning out of it would be able to use all the
+        // features that are mentioned in schema right away, without a need to go through schema transition (and thus for a session or
+        // two losing ability to use all the features)
+        const schema = this.explicitSchemaControl ? this.documentSchema : this.desiredSchema;
+        // It's important to keep refSeq at zero in legacy mode, such that transition out of it is simple and we do not have
+        // race conditions. If we put any other number (including latest seq number), then we will have two clients
+        // (loading from two different summaries) with different numbers, and eventual consistency will be broken as schema
+        // change ops will be interpretted differently by those two clients.
+        (0, core_utils_1.assert)(this.explicitSchemaControl || schema.refSeq === 0, "refSeq should be zero");
+        return schema;
+    }
+    onMessageSent(send) {
+        if (this.sendOp && this.futureSchema !== undefined) {
+            (0, core_utils_1.assert)(this.explicitSchemaControl &&
+                this.futureSchema.runtime.explicitSchemaControl === true, "not legacy");
+            send({
+                ...this.futureSchema,
+                refSeq: this.documentSchema.refSeq,
+            });
+        }
+        this.sendOp = false;
+    }
+    /**
+     * Process document schema change message
+     * @param content - content of the message
+     * @param local - whether op is local
+     * @param sequenceNumber - sequence number of the op
+     * @returns - true if schema was accepted, otherwise false (rejected due to failed CAS)
+     */
+    processDocumentSchemaOp(content, local, sequenceNumber) {
+        (0, core_utils_1.assert)(content.refSeq <= this.documentSchema.refSeq, "did we lose a message somewhere?");
+        (0, core_utils_1.assert)(this.documentSchema.refSeq < sequenceNumber, "time should move forward only!");
+        if (content.refSeq !== this.documentSchema.refSeq) {
+            // CAS failed
+            return false;
+        }
+        // This assert should be after checking for successful CAS above.
+        // This will ensure we do not trip on our own messages that are no longer wanted as we processed someone else schema change message.
+        (0, core_utils_1.assert)(!local || (this.explicitSchemaControl && this.futureSchema !== undefined), "not sending ops");
+        // Changes are in effect. Immediately check that this client understands these changes
+        checkRuntimeCompatibility(content);
+        const schema = { ...content, refSeq: sequenceNumber };
+        this.documentSchema = schema;
+        this.sessionSchema = and(this.documentSchema, this.desiredSchema);
+        // legacy behavior is automatically off for the document once someone sends a schema op -
+        // from now on it's fully controlled by ops.
+        // This is very important, as summarizeDocumentSchema() should use this new schema!
+        this.explicitSchemaControl = true;
+        // Stop attempting changing schema.
+        // If it was local op, then we succeeded and do not need to try again.
+        // If it was remote op, then some changes happened to schema.
+        // We would need to recalculate this.futureSchema by merging changes that we just received.
+        // Avoid this complexity for now - a new client session (loading from new summary with these changes)
+        // will automatically do this recalculation and will figure out
+        this.futureSchema = undefined;
+        this.onSchemaChange(this.sessionSchema);
+        return true;
+    }
+    onDisconnect() {
+        this.sendOp = true;
+    }
+}
+exports.DocumentsSchemaController = DocumentsSchemaController;
+/* eslint-enable jsdoc/check-indentation */
+//# sourceMappingURL=documentSchema.js.map

package/dist/summary/documentSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"documentSchema.js","sourceRoot":"","sources":["../../src/summary/documentSchema.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 */\nimport { assert } from \"@fluidframework/core-utils\";\nimport { DataProcessingError } from \"@fluidframework/telemetry-utils\";\n\n/**\n * Descripe allowed type for properties in document schema.\n * Please note that for all property types we should use undefined to indicate that particular capability is off.\n * Using false, or some string value (like \"off\") will result in clients who do not understand that property failing, whereas\n * we want them to continue to collaborate alongside clients who support that capability, but such capability is shipping dark for now.\n * @alpha\n */\nexport type DocumentSchemaValueType = string | true | number | undefined;\n\n/**\n * ID Compressor mode.\n * \"on\" - compressor is On. It's loaded as part of container load. This mode is sticky - once on, compressor is On for all\n * sessions for a given document. This results in IContainerRuntime.idCompressor to be always available.\n * \"delayed\" - ID compressor bundle is loaded only on establishing of first delta connection, i.e. it does not impact boot of cotnainer.\n * In such mode IContainerRuntime.idCompressor is not made available (unless previous sessions of same document had it \"On\").\n * The only thing that is available is IContainerRuntime.generateDocumentUniqueId() that provides opportunistically short IDs.\n * undefined - ID compressor is not loaded.\n * While IContainerRuntime.generateDocumentUniqueId() is available, it will produce long IDs that are do not compress well.\n *\n * @alpha\n */\nexport type IdCompressorMode = \"on\" | \"delayed\" | undefined;\n\n/**\n * Document schema information.\n * Describes overall shape of document schema, including unknown (to this version) properties.\n *\n * Used by runtime to make a call if it can understand document schema.\n * If it can't, it should not continue with document and immediately fail, preventing random (cryptic) failures\n * down the road and potentially corrupting documents.\n * For now this structure and appropriate interpretation / behavior is focused only on runtime features.\n * In the future that could be interpolated to more areas, including DDSs used, and even possibly - application\n * schema.\n *\n * Runtime will ignore any properties at the root that it does not understand (i.e. IDocumentSchema.app), but will\n * stop (and fail session) on any unknown properties within \"runtime\" sub-tree.\n *\n * In most cases values preserved in the document will not dictate if such features should be enabled in a given session.\n * I.e. if compression is mentioned in document schema, this means that runtime version that opens such document must know\n * how to interpret such ops, but does not need to actually use compression itself. That said, some options could be\n * sticky, i.e. influence feature selection for all runtimes opening a document. ID compression is one such example.\n * Currently there is no mechanism to remove feature from this property bag, i.e. once compression was used, even if it's\n * disabled (through feature gate or code deployment), all existing documents that used compression will continue to fail\n * if opened by clients who do not support compression.\n *\n * For now we are limiting it to just plain properties, and only really simple types, but that can be changed in the future.\n *\n * @alpha\n */\nexport interface IDocumentSchema {\n\t// version that describes how data is stored in this structure.\n\t// If runtime sees a version it does not understand, it should immediately fail and not\n\t// attempt to interpret any further data.\n\tversion: number;\n\n\t// Sequence number when this schema became active.\n\trefSeq: number;\n\n\truntime: Record<string, DocumentSchemaValueType>;\n}\n\n/**\n * Content of the type=ContainerMessageType.DocumentSchemaChange ops.\n * The meaning of refSeq field is different in such messages (compared to other usages of IDocumentSchemaCurrent)\n * ContainerMessageType.DocumentSchemaChange messages use CAS (Compare-and-swap) semantics, and convey\n * regSeq of last known schema change (known to a client proposing schema change).\n * @see ContainerRuntimeDocumentSchemaMessage\n * @alpha\n */\nexport type IDocumentSchemaChangeMessage = IDocumentSchema;\n\n/**\n * Settings that this session would like to have, based on options and feature gates.\n *\n * WARNING: This type is used to infer IDocumentSchemaCurrent type!\n * Any changes here (including renaming of properties) are potentially changing document format and should be considered carefully!\n *\n * @alpha\n */\nexport interface IDocumentSchemaFeatures {\n\t// Tells if client uses legacy behavior of changing schema.\n\t// - Legacy behavior - changing schema without leveraging schema change ops.\n\t// - New behavior - changes in schema require ops and take into affect with delay.\n\texplicitSchemaControl: boolean;\n\tcompressionLz4: boolean;\n\tidCompressorMode: IdCompressorMode;\n\topGroupingEnabled: boolean;\n}\n\n/**\n * Current version known properties that define document schema\n * This must be bumped whenever the format of document schema or protocol for changing the current document schema changes.\n * Ex: adding a new configuration property (under IDocumentSchema.runtime) does not require changing this version.\n * Ex: Changing the 'document schema acceptance' mechanism from convert-and-swap to one requiring consensus does require changing this version.\n * @alpha\n */\nexport const currentDocumentVersionSchema = 1;\n\n/**\n * Current document schema.\n * @alpha\n */\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\nexport type IDocumentSchemaCurrent = {\n\tversion: 1;\n\trefSeq: number;\n\n\truntime: {\n\t\t[P in keyof IDocumentSchemaFeatures]?: IDocumentSchemaFeatures[P] extends boolean\n\t\t\t? true\n\t\t\t: IDocumentSchemaFeatures[P];\n\t};\n};\n\ninterface IProperty<T = unknown> {\n\tand: (currentDocSchema: T, desiredDocSchema: T) => T;\n\tor: (currentDocSchema: T, desiredDocSchema: T) => T;\n\tvalidate(t: unknown): boolean;\n}\n\nclass TrueOrUndefined implements IProperty<true | undefined> {\n\tpublic and(currentDocSchema?: true, desiredDocSchema?: true) {\n\t\treturn currentDocSchema === true && desiredDocSchema === true ? true : undefined;\n\t}\n\n\tpublic or(currentDocSchema?: true, desiredDocSchema?: true) {\n\t\treturn currentDocSchema === true || desiredDocSchema === true ? true : undefined;\n\t}\n\n\tpublic validate(t: unknown) {\n\t\treturn t === undefined || t === true;\n\t}\n}\n\nclass TrueOrUndefinedMax extends TrueOrUndefined {\n\tpublic and(currentDocSchema?: true, desiredDocSchema?: true) {\n\t\treturn this.or(currentDocSchema, desiredDocSchema);\n\t}\n}\n\nclass MultiChoice implements IProperty<string | undefined> {\n\tconstructor(private readonly choices: string[]) {}\n\n\tpublic and(currentDocSchema?: string, desiredDocSchema?: string) {\n\t\tif (currentDocSchema === undefined || desiredDocSchema === undefined) {\n\t\t\treturn undefined;\n\t\t}\n\t\treturn this.choices[\n\t\t\tMath.min(this.choices.indexOf(currentDocSchema), this.choices.indexOf(desiredDocSchema))\n\t\t];\n\t}\n\n\tpublic or(currentDocSchema?: string, desiredDocSchema?: string) {\n\t\tif (currentDocSchema === undefined) {\n\t\t\treturn desiredDocSchema;\n\t\t}\n\t\tif (desiredDocSchema === undefined) {\n\t\t\treturn currentDocSchema;\n\t\t}\n\t\treturn this.choices[\n\t\t\tMath.max(this.choices.indexOf(currentDocSchema), this.choices.indexOf(desiredDocSchema))\n\t\t];\n\t}\n\n\tpublic validate(t: unknown) {\n\t\treturn t === undefined || (typeof t === \"string\" && this.choices.includes(t));\n\t}\n}\n\nclass IdCompressorProperty extends MultiChoice {\n\t// document schema always wins!\n\tpublic and(currentDocSchema?: string, desiredDocSchema?: string) {\n\t\treturn currentDocSchema;\n\t}\n}\n\n/**\n * Helper structure to valida if a schema is compatible with existing code.\n */\nconst documentSchemaSupportedConfigs = {\n\texplicitSchemaControl: new TrueOrUndefinedMax(), // once new behavior shows up, it's sticky\n\tidCompressorMode: new IdCompressorProperty([\"delayed\", \"on\"]),\n\topGroupingEnabled: new TrueOrUndefined(),\n\tcompressionLz4: new TrueOrUndefined(),\n};\n\n/**\n * Checks if a given schema is compatible with current code, i.e. if current code can understand all the features of that schema.\n * If schema is not compatible with current code, it throws an exception.\n * @param documentSchema - current schema\n */\nfunction checkRuntimeCompatibility(documentSchema?: IDocumentSchema) {\n\t// Back-compat - we can't do anything about legacy documents.\n\t// There is no way to validate them, so we are taking a guess that safe deployment processes used by a given app\n\t// do not run into compat problems.\n\tif (documentSchema === undefined) {\n\t\treturn;\n\t}\n\n\tconst msg = \"Document can't be opened with current version of the code\";\n\tif (documentSchema.version !== currentDocumentVersionSchema) {\n\t\tthrow DataProcessingError.create(\n\t\t\tmsg,\n\t\t\t\"checkRuntimeCompat\",\n\t\t\tundefined, // message\n\t\t\t{\n\t\t\t\truntimeSchemaVersion: documentSchema.version,\n\t\t\t\tcurrentRuntimeSchemaVersion: currentDocumentVersionSchema,\n\t\t\t},\n\t\t);\n\t}\n\n\tlet unknownProperty: string | undefined;\n\n\tconst regSeq = documentSchema.refSeq;\n\t// defence in depth - it should not be possible to get here anything other than integer, but worth validating it.\n\tif (typeof regSeq !== \"number\" || regSeq < 0 || !Number.isInteger(regSeq)) {\n\t\tunknownProperty = \"refSeq\";\n\t} else if (documentSchema.runtime === null || typeof documentSchema.runtime !== \"object\") {\n\t\tunknownProperty = \"runtime\";\n\t} else {\n\t\tfor (const [name, value] of Object.entries(documentSchema.runtime)) {\n\t\t\tconst validator = documentSchemaSupportedConfigs[name] as IProperty | undefined;\n\t\t\tif (validator === undefined || !validator.validate(value)) {\n\t\t\t\tunknownProperty = `runtime/${name}`;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (unknownProperty !== undefined) {\n\t\tconst value = documentSchema[unknownProperty];\n\t\tthrow DataProcessingError.create(\n\t\t\tmsg,\n\t\t\t\"checkRuntimeCompat\",\n\t\t\tundefined, // message\n\t\t\t{\n\t\t\t\tcodeVersion: currentDocumentVersionSchema,\n\t\t\t\tproperty: unknownProperty,\n\t\t\t\tvalue,\n\t\t\t},\n\t\t);\n\t}\n}\n\nfunction and(\n\tcurrentDocSchema: IDocumentSchemaCurrent,\n\tdesiredDocSchema: IDocumentSchemaCurrent,\n): IDocumentSchemaCurrent {\n\tconst runtime = {};\n\tfor (const key of new Set([\n\t\t...Object.keys(currentDocSchema.runtime),\n\t\t...Object.keys(desiredDocSchema.runtime),\n\t])) {\n\t\truntime[key] = (documentSchemaSupportedConfigs[key] as IProperty).and(\n\t\t\tcurrentDocSchema.runtime[key],\n\t\t\tdesiredDocSchema.runtime[key],\n\t\t);\n\t}\n\treturn {\n\t\tversion: currentDocumentVersionSchema,\n\t\trefSeq: currentDocSchema.refSeq,\n\t\truntime,\n\t} as unknown as IDocumentSchemaCurrent;\n}\n\nfunction or(\n\tcurrentDocSchema: IDocumentSchemaCurrent,\n\tdesiredDocSchema: IDocumentSchemaCurrent,\n): IDocumentSchemaCurrent {\n\tconst runtime = {};\n\tfor (const key of new Set([\n\t\t...Object.keys(currentDocSchema.runtime),\n\t\t...Object.keys(desiredDocSchema.runtime),\n\t])) {\n\t\truntime[key] = (documentSchemaSupportedConfigs[key] as IProperty).or(\n\t\t\tcurrentDocSchema.runtime[key],\n\t\t\tdesiredDocSchema.runtime[key],\n\t\t);\n\t}\n\treturn {\n\t\tversion: currentDocumentVersionSchema,\n\t\trefSeq: currentDocSchema.refSeq,\n\t\truntime,\n\t} as unknown as IDocumentSchemaCurrent;\n}\n\nfunction same(\n\tcurrentDocSchema: IDocumentSchemaCurrent,\n\tdesiredDocSchema: IDocumentSchemaCurrent,\n): boolean {\n\tfor (const key of new Set([\n\t\t...Object.keys(currentDocSchema.runtime),\n\t\t...Object.keys(desiredDocSchema.runtime),\n\t])) {\n\t\t// If schemas differ only by type of behavior, then we should not send schema change ops!\n\t\tif (\n\t\t\tkey !== \"explicitSchemaControl\" &&\n\t\t\tcurrentDocSchema.runtime[key] !== desiredDocSchema.runtime[key]\n\t\t) {\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn true;\n}\n\nfunction boolToProp(b: boolean) {\n\treturn b ? true : undefined;\n}\n\n/* eslint-disable jsdoc/check-indentation */\n\n/**\n * Controller of document schema.\n *\n * Recommended pre-reading: https://github.com/microsoft/FluidFramework/blob/main/packages/dds/SchemaVersioning.md\n *\n * This class manages current document schema and transitions between document schemas.\n * At the moment, it only focuses on subset of document schema, specifically - how FluidFramework runtime serializes data\n * (summary and op format), features & capabilities that a version of runtime has to support and understand in\n * order to collaborate on a document.\n * New features that modify document format have to be included in document schema definition.\n * Usage of such features could only happen after document schema has been updated to reflect such feature.\n *\n * This formality allows clients that do not understand such features to fail right away when they observe\n * document schema listing capabilities that such client does not understand.\n * Old clients will fail in predictable way. This allows us to\n * 1) Immediately see such issues and adjust if features are enabled too early, before changes have been saturated.\n * 2) There is no way to get to 100% saturation with new code. Even if we have 99.99% saturation, there are\n *    still 0.01% of clients who will fail. Failing early and predictably ensures they have no chance to limp along\n *    and potentially corrupt the document. This is especially true for summarizer client, who could simply \"undo\"\n *    changes it does not understands.\n *\n * It's important to note how it overlaps with feature gates and safe velocity.\n * If new feature was in use, that resulted in a number of documents referencing such feature in document schema.\n * But, developers (through code deployment or feature gates) could disable usage of such features.\n * That will stop a process of further document schema changes (for documents that were not using such feature).\n * And documents that already list such capability in their schema will continue to do so. Later ensures that old\n * clients who do not understand such feature will continue to fail to open such documents, as such documents very\n * likely contain data in a new format.\n *\n * Users of this class need to use DocumentsSchemaController.sessionSchema to determine what features can be used.\n *\n * There are two modes this class can operate:\n * 1) Legacy mode. In such mode it does not issue any ops to change document schema. Any changes happen implicitly,\n *    right away, and new features are available right away\n * 2) Non-legacy mode. In such mode any changes to schema require an op roundtrip. This class will manage such transitions.\n *    However code should assume that any new features that were not enabled in a given document will not be available\n *    for a given session. That's because this session may never send any ops (including read-only documents). Or it may\n *    fail to convert schema.\n *    This class promises eventual movement forward. I.e. if new feature is allowed (let's say - through feature gates),\n *    then eventually all documents that are modified will have that feature reflected in their schema. It could require\n *    multiple reloads / new sessions to get there (depends on if code reacts to schema changes right away, or only consults\n *    schema on document load).\n *\n * How schemas are changed (in non-legacy mode):\n * If a client needs to change a schema, it will attempt to do so as part of normal ops sending process.\n * Changes happen in CAS (Compare-and-swap) fashion, i.e. client tells current schema and schema it wants to change to.\n * When a number of clients race to change a schema, then only one of them will win, all others will fail because they will\n * reference old schema that is no longer in effect.\n * Clients can retry, but current implementation is simply - they will not (and will rely on next session / reload to do\n * recalc and decide if schema needs to be changed or not).\n *\n * @alpha\n */\nexport class DocumentsSchemaController {\n\tprivate explicitSchemaControl: boolean;\n\tprivate sendOp = true;\n\n\t// schema coming from document metadata (snapshot we loaded from)\n\tprivate documentSchema: IDocumentSchemaCurrent;\n\n\t// desired schema, based on feature gates / runtime options.\n\t// This includes requests to enable to disable functionality\n\tprivate readonly desiredSchema: IDocumentSchemaCurrent;\n\n\t// OR() of document schema and desired schema. It enables all the features that are enabled in either of schemas.\n\tprivate futureSchema: IDocumentSchemaCurrent | undefined;\n\n\t// Current schema this session operates with.\n\t// 1) Legacy mode: this is same as desired schema - all options that were requested to be on are on, and all options requested to be off are off.\n\t// 2) Non-legacy mode: this is AND() of document schema and desired schema. Only options that are enabled in both are enabled here.\n\t//    If there are any options that are not enabled in document schema, but are enabled in desired schema, then attempt to change schema\n\t//    (and enable such options) will be made through the session.\n\tpublic sessionSchema: IDocumentSchemaCurrent;\n\n\t/**\n\t * Constructs DocumentsSchemaController that controls current schema and processes around it, including changes in schema.\n\t * @param explicitSchemaControl - Tells if schema changes are done implicitly (without ops - legacy behavior), or go through formal schema change ops process.\n\t * @param existing - Is the document existing document, or a new doc.\n\t * @param documentMetadataSchema - current document's schema, if present.\n\t * @param compressionAlgorithm - desired compression algorith to use\n\t * @param idCompressorModeArg - desired ID compressor mode to use\n\t * @param opGroupingEnabled - true if it's desired to use op grouping.\n\t */\n\tconstructor(\n\t\texisting: boolean,\n\t\tdocumentMetadataSchema: IDocumentSchema | undefined,\n\t\tfeatures: IDocumentSchemaFeatures,\n\t\tprivate readonly onSchemaChange: (schema: IDocumentSchemaCurrent) => void,\n\t) {\n\t\tcheckRuntimeCompatibility(documentMetadataSchema);\n\n\t\tthis.documentSchema =\n\t\t\t(documentMetadataSchema as IDocumentSchemaCurrent) ??\n\t\t\t({\n\t\t\t\tversion: currentDocumentVersionSchema,\n\t\t\t\t// see comment in summarizeDocumentSchema() on why it has to stay zero\n\t\t\t\trefSeq: 0,\n\t\t\t\t// If it's existing document and it has no schema, then it was written by legacy client.\n\t\t\t\t// If it's a new document, then we define it's legacy-related behaviors.\n\t\t\t\truntime: {\n\t\t\t\t\texplicitSchemaControl: boolToProp(!existing && features.explicitSchemaControl),\n\t\t\t\t},\n\t\t\t} satisfies IDocumentSchemaCurrent);\n\n\t\t// Use legacy behavior only if both document and options tell us to use legacy.\n\t\t// Otherwise it's no longer legacy time!\n\t\tthis.explicitSchemaControl =\n\t\t\tthis.documentSchema.runtime.explicitSchemaControl === true ||\n\t\t\tfeatures.explicitSchemaControl;\n\n\t\tthis.desiredSchema = {\n\t\t\tversion: currentDocumentVersionSchema,\n\t\t\trefSeq: this.documentSchema.refSeq,\n\t\t\truntime: {\n\t\t\t\texplicitSchemaControl: boolToProp(features.explicitSchemaControl),\n\t\t\t\tcompressionLz4: boolToProp(features.compressionLz4),\n\t\t\t\tidCompressorMode: features.idCompressorMode,\n\t\t\t\topGroupingEnabled: boolToProp(features.opGroupingEnabled),\n\t\t\t},\n\t\t};\n\n\t\tif (!this.explicitSchemaControl || !existing) {\n\t\t\tthis.sessionSchema = this.desiredSchema;\n\t\t\tassert(\n\t\t\t\tboolToProp(this.explicitSchemaControl) ===\n\t\t\t\t\tthis.sessionSchema.runtime.explicitSchemaControl,\n\t\t\t\t\"explicitSchemaControl\",\n\t\t\t);\n\t\t\tthis.futureSchema = undefined;\n\t\t} else {\n\t\t\tthis.sessionSchema = and(this.documentSchema, this.desiredSchema);\n\t\t\tthis.futureSchema = or(this.documentSchema, this.desiredSchema);\n\t\t\tassert(this.sessionSchema.runtime.explicitSchemaControl === true, \"legacy\");\n\t\t\tassert(this.futureSchema.runtime.explicitSchemaControl === true, \"legacy\");\n\t\t\tif (same(this.documentSchema, this.futureSchema)) {\n\t\t\t\tthis.futureSchema = undefined;\n\t\t\t}\n\t\t}\n\n\t\t// Validate that schema we are operating in is actually a schema we consider compatible with current runtime.\n\t\tcheckRuntimeCompatibility(this.sessionSchema);\n\t\tcheckRuntimeCompatibility(this.futureSchema);\n\t}\n\n\tpublic summarizeDocumentSchema(refSeq: number): IDocumentSchemaCurrent | undefined {\n\t\t// For legacy behavior, we could write nothing (return undefined).\n\t\t// It does not buy us anything, as whatever written in summary does not actually impact clients operating in legacy mode.\n\t\t// But writing current used config (and assuming most of the clients settle on same config over time) will help with transition\n\t\t// out of legacy mode, as clients transitioning out of it would be able to use all the\n\t\t// features that are mentioned in schema right away, without a need to go through schema transition (and thus for a session or\n\t\t// two losing ability to use all the features)\n\n\t\tconst schema = this.explicitSchemaControl ? this.documentSchema : this.desiredSchema;\n\n\t\t// It's important to keep refSeq at zero in legacy mode, such that transition out of it is simple and we do not have\n\t\t// race conditions. If we put any other number (including latest seq number), then we will have two clients\n\t\t// (loading from two different summaries) with different numbers, and eventual consistency will be broken as schema\n\t\t// change ops will be interpretted differently by those two clients.\n\t\tassert(this.explicitSchemaControl || schema.refSeq === 0, \"refSeq should be zero\");\n\n\t\treturn schema;\n\t}\n\n\tpublic onMessageSent(send: (content: IDocumentSchemaChangeMessage) => void) {\n\t\tif (this.sendOp && this.futureSchema !== undefined) {\n\t\t\tassert(\n\t\t\t\tthis.explicitSchemaControl &&\n\t\t\t\t\tthis.futureSchema.runtime.explicitSchemaControl === true,\n\t\t\t\t\"not legacy\",\n\t\t\t);\n\t\t\tsend({\n\t\t\t\t...this.futureSchema,\n\t\t\t\trefSeq: this.documentSchema.refSeq,\n\t\t\t});\n\t\t}\n\t\tthis.sendOp = false;\n\t}\n\n\t/**\n\t * Process document schema change message\n\t * @param content - content of the message\n\t * @param local - whether op is local\n\t * @param sequenceNumber - sequence number of the op\n\t * @returns - true if schema was accepted, otherwise false (rejected due to failed CAS)\n\t */\n\tpublic processDocumentSchemaOp(\n\t\tcontent: IDocumentSchemaChangeMessage,\n\t\tlocal: boolean,\n\t\tsequenceNumber: number,\n\t) {\n\t\tassert(content.refSeq <= this.documentSchema.refSeq, \"did we lose a message somewhere?\");\n\t\tassert(this.documentSchema.refSeq < sequenceNumber, \"time should move forward only!\");\n\t\tif (content.refSeq !== this.documentSchema.refSeq) {\n\t\t\t// CAS failed\n\t\t\treturn false;\n\t\t}\n\n\t\t// This assert should be after checking for successful CAS above.\n\t\t// This will ensure we do not trip on our own messages that are no longer wanted as we processed someone else schema change message.\n\t\tassert(\n\t\t\t!local || (this.explicitSchemaControl && this.futureSchema !== undefined),\n\t\t\t\"not sending ops\",\n\t\t);\n\n\t\t// Changes are in effect. Immediately check that this client understands these changes\n\t\tcheckRuntimeCompatibility(content);\n\n\t\tconst schema: IDocumentSchema = { ...content, refSeq: sequenceNumber };\n\t\tthis.documentSchema = schema as IDocumentSchemaCurrent;\n\t\tthis.sessionSchema = and(this.documentSchema, this.desiredSchema);\n\n\t\t// legacy behavior is automatically off for the document once someone sends a schema op -\n\t\t// from now on it's fully controlled by ops.\n\t\t// This is very important, as summarizeDocumentSchema() should use this new schema!\n\t\tthis.explicitSchemaControl = true;\n\n\t\t// Stop attempting changing schema.\n\t\t// If it was local op, then we succeeded and do not need to try again.\n\t\t// If it was remote op, then some changes happened to schema.\n\t\t// We would need to recalculate this.futureSchema by merging changes that we just received.\n\t\t// Avoid this complexity for now - a new client session (loading from new summary with these changes)\n\t\t// will automatically do this recalculation and will figure out\n\t\tthis.futureSchema = undefined;\n\n\t\tthis.onSchemaChange(this.sessionSchema);\n\n\t\treturn true;\n\t}\n\n\tpublic onDisconnect() {\n\t\tthis.sendOp = true;\n\t}\n}\n\n/* eslint-enable jsdoc/check-indentation */\n"]}

package/dist/summary/index.d.ts

@@ -11,7 +11,8 @@ export { SummarizeHeuristicData, SummarizeHeuristicRunner } from "./summarizerHe
 export { createRootSummarizerNode, createRootSummarizerNodeWithGC, IRefreshSummaryResult, IRootSummarizerNode, IRootSummarizerNodeWithGC, } from "./summarizerNode/index.js";
 export { IConnectableRuntime, IGeneratedSummaryStats, IRefreshSummaryAckOptions, ISubmitSummaryOptions, ISummarizeAttempt, ISummarizeHeuristicData, ISummarizer, ISummarizeResults, ISummarizerEvents, ISummarizerInternalsProvider, ISummarizerRuntime, ISummaryCancellationToken, SubmitSummaryResult, SummarizerStopReason, EnqueueSummarizeResult, IAckSummaryResult, IBaseSummarizeResult, IBroadcastSummaryResult, ICancellationToken, IEnqueueSummarizeOptions, IGenerateSummaryTreeResult, INackSummaryResult, IOnDemandSummarizeOptions, ISubmitSummaryOpResult, ISummarizeOptions, ISummarizingWarning, IUploadSummaryResult, SummarizeResultPart, SubmitSummaryFailureData, SummaryStage, IRetriableFailureResult, ISummarizeEventProps, } from "./summarizerTypes.js";
 export { IAckedSummary, ISummaryCollectionOpEvents, ISummaryOpMessage, SummaryCollection, IClientSummaryWatcher, ISummary, ISummaryAckMessage, ISummaryNackMessage, OpActionEventListener, OpActionEventName, } from "./summaryCollection.js";
-export { aliasBlobName, blobsTreeName, chunksBlobName, dataStoreAttributesBlobName, electedSummarizerBlobName, extractSummaryMetadataMessage, getAttributesFormatVersion, getFluidDataStoreAttributes, hasIsolatedChannels, IContainerRuntimeMetadata, ICreateContainerMetadata, ISummaryMetadataMessage, metadataBlobName, nonDataStorePaths, ReadFluidDataStoreAttributes, rootHasIsolatedChannels, WriteFluidDataStoreAttributes, wrapSummaryInChannelsTree, idCompressorBlobName, IdCompressorMode, } from "./summaryFormat.js";
+export { aliasBlobName, blobsTreeName, chunksBlobName, dataStoreAttributesBlobName, electedSummarizerBlobName, extractSummaryMetadataMessage, getAttributesFormatVersion, getFluidDataStoreAttributes, hasIsolatedChannels, IContainerRuntimeMetadata, ICreateContainerMetadata, ISummaryMetadataMessage, metadataBlobName, nonDataStorePaths, ReadFluidDataStoreAttributes, rootHasIsolatedChannels, WriteFluidDataStoreAttributes, wrapSummaryInChannelsTree, idCompressorBlobName, } from "./summaryFormat.js";
+export { IdCompressorMode, IDocumentSchemaCurrent, IDocumentSchema, currentDocumentVersionSchema, DocumentSchemaValueType, DocumentsSchemaController, IDocumentSchemaChangeMessage, IDocumentSchemaFeatures, } from "./documentSchema.js";
 export { getFailMessage, RetriableSummaryError, SummarizeReason } from "./summaryGenerator.js";
 export { IConnectedEvents, IConnectedState, ISummaryManagerConfig, SummaryManager, SummaryManagerState, } from "./summaryManager.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/summary/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/summary/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,EACnB,cAAc,EACd,uBAAuB,EACvB,qBAAqB,GACrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,mCAAmC,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChG,OAAO,EACN,gCAAgC,EAChC,0BAA0B,EAC1B,4BAA4B,GAC5B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACN,yBAAyB,EACzB,+BAA+B,EAC/B,wBAAwB,EACxB,oBAAoB,GACpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC7F,OAAO,EACN,wBAAwB,EACxB,8BAA8B,EAC9B,qBAAqB,EACrB,mBAAmB,EACnB,yBAAyB,GACzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACN,mBAAmB,EACnB,sBAAsB,EACtB,yBAAyB,EACzB,qBAAqB,EACrB,iBAAiB,EACjB,uBAAuB,EACvB,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EACjB,4BAA4B,EAC5B,kBAAkB,EAClB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,EACvB,kBAAkB,EAClB,wBAAwB,EACxB,0BAA0B,EAC1B,kBAAkB,EAClB,yBAAyB,EACzB,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,YAAY,EACZ,uBAAuB,EACvB,oBAAoB,GACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACN,aAAa,EACb,0BAA0B,EAC1B,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,QAAQ,EACR,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,iBAAiB,GACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACN,aAAa,EACb,aAAa,EACb,cAAc,EACd,2BAA2B,EAC3B,yBAAyB,EACzB,6BAA6B,EAC7B,0BAA0B,EAC1B,2BAA2B,EAC3B,mBAAmB,EACnB,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,4BAA4B,EAC5B,uBAAuB,EACvB,6BAA6B,EAC7B,yBAAyB,EACzB,oBAAoB,EACpB,gBAAgB,GAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC/F,OAAO,EACN,gBAAgB,EAChB,eAAe,EACf,qBAAqB,EACrB,cAAc,EACd,mBAAmB,GACnB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/summary/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,wBAAwB,EACxB,sBAAsB,EACtB,mBAAmB,EACnB,cAAc,EACd,uBAAuB,EACvB,qBAAqB,GACrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,mCAAmC,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChG,OAAO,EACN,gCAAgC,EAChC,0BAA0B,EAC1B,4BAA4B,GAC5B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACN,yBAAyB,EACzB,+BAA+B,EAC/B,wBAAwB,EACxB,oBAAoB,GACpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC7F,OAAO,EACN,wBAAwB,EACxB,8BAA8B,EAC9B,qBAAqB,EACrB,mBAAmB,EACnB,yBAAyB,GACzB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACN,mBAAmB,EACnB,sBAAsB,EACtB,yBAAyB,EACzB,qBAAqB,EACrB,iBAAiB,EACjB,uBAAuB,EACvB,WAAW,EACX,iBAAiB,EACjB,iBAAiB,EACjB,4BAA4B,EAC5B,kBAAkB,EAClB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,EACvB,kBAAkB,EAClB,wBAAwB,EACxB,0BAA0B,EAC1B,kBAAkB,EAClB,yBAAyB,EACzB,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACnB,wBAAwB,EACxB,YAAY,EACZ,uBAAuB,EACvB,oBAAoB,GACpB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EACN,aAAa,EACb,0BAA0B,EAC1B,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,QAAQ,EACR,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,iBAAiB,GACjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EACN,aAAa,EACb,aAAa,EACb,cAAc,EACd,2BAA2B,EAC3B,yBAAyB,EACzB,6BAA6B,EAC7B,0BAA0B,EAC1B,2BAA2B,EAC3B,mBAAmB,EACnB,yBAAyB,EACzB,wBAAwB,EACxB,uBAAuB,EACvB,gBAAgB,EAChB,iBAAiB,EACjB,4BAA4B,EAC5B,uBAAuB,EACvB,6BAA6B,EAC7B,yBAAyB,EACzB,oBAAoB,GACpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACN,gBAAgB,EAChB,sBAAsB,EACtB,eAAe,EACf,4BAA4B,EAC5B,uBAAuB,EACvB,yBAAyB,EACzB,4BAA4B,EAC5B,uBAAuB,GACvB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC/F,OAAO,EACN,gBAAgB,EAChB,eAAe,EACf,qBAAqB,EACrB,cAAc,EACd,mBAAmB,GACnB,MAAM,qBAAqB,CAAC"}