@fluidframework/container-runtime 2.41.0 → 2.42.0

package/lib/containerRuntime.js

@@ -5,7 +5,7 @@
 import { createEmitter, Trace, TypedEventEmitter } from "@fluid-internal/client-utils";
 import { AttachState } from "@fluidframework/container-definitions";
 import { isIDeltaManagerFull } from "@fluidframework/container-definitions/internal";
-import { assert, Deferred, Lazy, LazyPromise, PromiseCache, delay, fail, } from "@fluidframework/core-utils/internal";
+import { assert, Deferred, Lazy, LazyPromise, PromiseCache, delay, fail, unreachableCase, } from "@fluidframework/core-utils/internal";
 import { SummaryType } from "@fluidframework/driver-definitions";
 import { FetchSource, MessageType } from "@fluidframework/driver-definitions/internal";
 import { readAndParse } from "@fluidframework/driver-utils/internal";
@@ -19,7 +19,7 @@ import { v4 as uuid } from "uuid";
 import { BindBatchTracker } from "./batchTracker.js";
 import { BlobManager, blobManagerBasePath, blobsTreeName, isBlobPath, loadBlobManagerLoadInfo, } from "./blobManager/index.js";
 import { ChannelCollection, getSummaryForDatastores, wrapContext, } from "./channelCollection.js";
-import { defaultMinVersionForCollab, getMinVersionForCollabDefaults, isValidMinVersionForCollab, } from "./compatUtils.js";
+import { defaultMinVersionForCollab, getMinVersionForCollabDefaults, isValidMinVersionForCollab, validateRuntimeOptions, } from "./compatUtils.js";
 import { CompressionAlgorithms, disabledCompressionConfig } from "./compressionDefinitions.js";
 import { ReportOpPerfTelemetry } from "./connectionTelemetry.js";
 import { ContainerFluidHandleContext } from "./containerHandleContext.js";
@@ -191,6 +191,20 @@ export async function loadContainerRuntime(params) {
     return ContainerRuntime.loadRuntime(params);
 }
 const defaultMaxConsecutiveReconnects = 7;
+/**
+ * These are the ONLY message types that are allowed to be submitted while in staging mode
+ * (Does not apply to pre-StagingMode batches that are resubmitted, those are not considered to be staged)
+ */
+function canStageMessageOfType(type) {
+    return (
+    // These are user changes coming up from the runtime's DataStores
+    type === ContainerMessageType.FluidDataStoreOp ||
+        // GC ops are used to detect issues in the reference graph so all clients can repair their GC state.
+        // These can be submitted at any time, including while in Staging Mode.
+        type === ContainerMessageType.GC ||
+        // These are typically sent shortly after boot and will not be common in Staging Mode, but it's possible.
+        type === ContainerMessageType.DocumentSchemaChange);
+}
 /**
  * Represents the runtime of the container. Contains helper functions/state of the container.
  * It will define the store level mappings.
@@ -239,6 +253,9 @@ export class ContainerRuntime extends TypedEventEmitter {
         if (!isValidMinVersionForCollab(minVersionForCollab)) {
             throw new UsageError(`Invalid minVersionForCollab: ${minVersionForCollab}. It must be an existing FF version (i.e. 2.22.1).`);
         }
+        // We also validate that there is not a mismatch between `minVersionForCollab` and runtime options that
+        // were manually set.
+        validateRuntimeOptions(minVersionForCollab, runtimeOptions);
         const defaultsAffectingDocSchema = getMinVersionForCollabDefaults(minVersionForCollab);
         // The following are the default values for the options that do not affect the DocumentSchema.
         const defaultsNotAffectingDocSchema = {
@@ -504,8 +521,12 @@ export class ContainerRuntime extends TypedEventEmitter {
     ensureNoDataModelChanges(callback) {
         return this.dataModelChangeRunner.run(callback);
     }
+    /**
+     * Indicates whether the container is in a state where it is able to send
+     * ops (connected to op stream and not in readonly mode).
+     */
     get connected() {
-        return this._connected;
+        return this.canSendOps;
     }
     /**
      * clientId of parent (non-summarizing) container that owns summarizer container
@@ -593,7 +614,10 @@ export class ContainerRuntime extends TypedEventEmitter {
         // eslint-disable-next-line import/no-deprecated
         this.enterStagingMode = () => {
             if (this.stageControls !== undefined) {
-                throw new Error("already in staging mode");
+                throw new UsageError("already in staging mode");
+            }
+            if (this.attachState === AttachState.Detached) {
+                throw new UsageError("cannot enter staging mode while detached");
             }
             // Make sure all BatchManagers are empty before entering staging mode,
             // since we mark whole batches as "staged" or not to indicate whether to submit them.
@@ -614,7 +638,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                     // Pop all staged batches from the PSM and roll them back in LIFO order
                     this.pendingStateManager.popStagedBatches(({ runtimeOp, localOpMetadata }) => {
                         assert(runtimeOp !== undefined, 0xb82 /* Staged batches expected to have runtimeOp defined */);
-                        this.rollback(runtimeOp, localOpMetadata);
+                        this.rollbackStagedChanges(runtimeOp, localOpMetadata);
                     });
                     this.updateDocumentDirtyState();
                 }),
@@ -651,6 +675,11 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.mc = createChildMonitoringContext({
             logger: this.baseLogger,
             namespace: "ContainerRuntime",
+            properties: {
+                all: {
+                    inStagingMode: this.inStagingMode,
+                },
+            },
         });
         // If we support multiple algorithms in the future, then we would need to manage it here carefully.
         // We can use runtimeOptions.compressionOptions.compressionAlgorithm, but only if it's in the schema list!
@@ -691,7 +720,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         // Values are generally expected to be set from the runtime side.
         this.options = options ?? {};
         this.clientDetails = clientDetails;
-        const isSummarizerClient = this.clientDetails.type === summarizerClientType;
+        this.isSummarizerClient = this.clientDetails.type === summarizerClientType;
         this.loadedFromVersionId = context.getLoadedFromVersion()?.id;
         // eslint-disable-next-line unicorn/consistent-destructuring
         this._getClientId = () => context.clientId;
@@ -728,7 +757,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             details: { attachState: this.attachState },
         }));
         // In cases of summarizer, we want to dispose instead since consumer doesn't interact with this container
-        this.closeFn = isSummarizerClient ? this.disposeFn : closeFn;
+        this.closeFn = this.isSummarizerClient ? this.disposeFn : closeFn;
         let loadSummaryNumber;
         // Get the container creation metadata. For new container, we initialize these. For existing containers,
         // get the values from the metadata blob.
@@ -752,7 +781,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         this.messageAtLastSummary = lastMessageFromMetadata(metadata);
         // Note that we only need to pull the *initial* connected state from the context.
         // Later updates come through calls to setConnectionState.
-        this._connected = connected;
+        this.canSendOps = connected;
         this.mc.logger.sendTelemetryEvent({
             eventName: "GCFeatureMatrix",
             metadataValue: JSON.stringify(metadata?.gcFeatureMatrix),
@@ -845,7 +874,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             existing,
             metadata,
             createContainerMetadata: this.createContainerMetadata,
-            isSummarizerClient,
+            isSummarizerClient: this.isSummarizerClient,
             getNodePackagePath: async (nodePath) => this.getGCNodePackagePath(nodePath),
             getLastSummaryTimestampMs: () => this.messageAtLastSummary?.timestamp,
             readAndParseBlob: async (id) => readAndParse(this.storage, id),
@@ -929,7 +958,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             // Keep the old flag name even though we renamed the class member (it shipped in 2.31.0)
             this.mc.config.getBoolean("Fluid.ContainerRuntime.DisableFlushBeforeProcess") === true;
         this.outbox = new Outbox({
-            shouldSend: () => this.canSendOps(),
+            shouldSend: () => this.shouldSendOps(),
             pendingStateManager: this.pendingStateManager,
             submitBatchFn,
             legacySendBatchFn,
@@ -1068,7 +1097,14 @@ export class ContainerRuntime extends TypedEventEmitter {
         await this.initializeSummarizer(loader);
         if (this.sessionSchema.idCompressorMode === "on" ||
             (this.sessionSchema.idCompressorMode === "delayed" && this.connected)) {
-            this._idCompressor = this.createIdCompressorFn();
+            PerformanceEvent.timedExec(this.mc.logger, { eventName: "CreateIdCompressorOnBoot" }, (event) => {
+                this._idCompressor = this.createIdCompressorFn();
+                event.end({
+                    details: {
+                        idCompressorMode: this.sessionSchema.idCompressorMode,
+                    },
+                });
+            });
             // This is called from loadRuntime(), long before we process any ops, so there should be no ops accumulated yet.
             assert(this.pendingIdCompressorOps.length === 0, 0x8ec /* no pending ops */);
         }
@@ -1097,8 +1133,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         const orderedClientCollection = new OrderedClientCollection(orderedClientLogger, this.innerDeltaManager, this._quorum);
         const orderedClientElectionForSummarizer = new OrderedClientElection(orderedClientLogger, orderedClientCollection, this.electedSummarizerData ?? this.innerDeltaManager.lastSequenceNumber, SummarizerClientElection.isClientEligible, this.mc.config.getBoolean("Fluid.ContainerRuntime.OrderedClientElection.EnablePerformanceEvents"));
         this.summarizerClientElection = new SummarizerClientElection(orderedClientLogger, summaryCollection, orderedClientElectionForSummarizer, maxOpsSinceLastSummary);
-        const isSummarizerClient = this.clientDetails.type === summarizerClientType;
-        if (isSummarizerClient) {
+        if (this.isSummarizerClient) {
             // We want to dynamically import any thing inside summaryDelayLoadedModule module only when we are the summarizer client,
             // so that all non summarizer clients don't have to load the code inside this module.
             const module = await import(
@@ -1446,7 +1481,7 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     replayPendingStates() {
         // We need to be able to send ops to replay states
-        if (!this.canSendOps()) {
+        if (!this.shouldSendOps()) {
             return;
         }
         // Replaying is an internal operation and we don't want to generate noise while doing it.
@@ -1528,25 +1563,35 @@ export class ContainerRuntime extends TypedEventEmitter {
     loadIdCompressor() {
         if (this._idCompressor === undefined &&
             this.sessionSchema.idCompressorMode !== undefined) {
-            this._idCompressor = this.createIdCompressorFn();
-            // Finalize any ranges we received while the compressor was turned off.
-            const ops = this.pendingIdCompressorOps;
-            this.pendingIdCompressorOps = [];
-            for (const range of ops) {
-                this._idCompressor.finalizeCreationRange(range);
-            }
+            PerformanceEvent.timedExec(this.mc.logger, { eventName: "CreateIdCompressorOnDelayedLoad" }, (event) => {
+                this._idCompressor = this.createIdCompressorFn();
+                // Finalize any ranges we received while the compressor was turned off.
+                const ops = this.pendingIdCompressorOps;
+                this.pendingIdCompressorOps = [];
+                const trace = Trace.start();
+                for (const range of ops) {
+                    this._idCompressor.finalizeCreationRange(range);
+                }
+                event.end({
+                    details: {
+                        finalizeCreationRangeDuration: trace.trace().duration,
+                        idCompressorMode: this.sessionSchema.idCompressorMode,
+                        pendingIdCompressorOps: ops.length,
+                    },
+                });
+            });
             assert(this.pendingIdCompressorOps.length === 0, 0x976 /* No new ops added */);
         }
     }
-    setConnectionState(connected, clientId) {
+    setConnectionState(canSendOps, clientId) {
         // Validate we have consistent state
         const currentClientId = this._audience.getSelf()?.clientId;
         assert(clientId === currentClientId, 0x977 /* input clientId does not match Audience */);
         assert(this.clientId === currentClientId, 0x978 /* this.clientId does not match Audience */);
-        if (connected && this.sessionSchema.idCompressorMode === "delayed") {
+        if (canSendOps && this.sessionSchema.idCompressorMode === "delayed") {
             this.loadIdCompressor();
         }
-        if (connected === false && this.delayConnectClientId !== undefined) {
+        if (canSendOps === false && this.delayConnectClientId !== undefined) {
             this.delayConnectClientId = undefined;
             this.mc.logger.sendTelemetryEvent({
                 eventName: "UnsuccessfulConnectedTransition",
@@ -1554,37 +1599,39 @@ export class ContainerRuntime extends TypedEventEmitter {
             // Don't propagate "disconnected" event because we didn't propagate the previous "connected" event
             return;
         }
-        if (!connected) {
-            this.documentsSchemaController.onDisconnect();
-        }
         // If there are stashed blobs in the pending state, we need to delay
         // propagation of the "connected" event until we have uploaded them to
         // ensure we don't submit ops referencing a blob that has not been uploaded
-        const connecting = connected && !this._connected;
+        const connecting = canSendOps && !this.canSendOps;
         if (connecting && this.blobManager.hasPendingStashedUploads()) {
             assert(!this.delayConnectClientId, 0x791 /* Connect event delay must be canceled before subsequent connect event */);
             assert(!!clientId, 0x792 /* Must have clientId when connecting */);
             this.delayConnectClientId = clientId;
             return;
         }
-        this.setConnectionStateCore(connected, clientId);
+        this.setConnectionStateCore(canSendOps, clientId);
     }
-    setConnectionStateCore(connected, clientId) {
+    /**
+     * Raises and propagates connected events.
+     * @param canSendOps - Indicates whether the container can send ops or not (connected and not readonly).
+     * @remarks The connection state from container context used here when raising connected events.
+     */
+    setConnectionStateCore(canSendOps, clientId) {
         assert(!this.delayConnectClientId, 0x394 /* connect event delay must be cleared before propagating connect event */);
         this.verifyNotClosed();
         // There might be no change of state due to Container calling this API after loading runtime.
-        const changeOfState = this._connected !== connected;
-        const reconnection = changeOfState && !connected;
+        const canSendOpsChanged = this.canSendOps !== canSendOps;
+        const reconnection = canSendOpsChanged && !canSendOps;
         // We need to flush the ops currently collected by Outbox to preserve original order.
         // This flush NEEDS to happen before we set the ContainerRuntime to "connected".
         // We want these ops to get to the PendingStateManager without sending to service and have them return to the Outbox upon calling "replayPendingStates".
-        if (changeOfState && connected) {
+        if (canSendOpsChanged && canSendOps) {
             this.flush();
         }
-        this._connected = connected;
-        if (connected) {
+        this.canSendOps = canSendOps;
+        if (canSendOps) {
             assert(this.attachState === AttachState.Attached, 0x3cd /* Connection is possible only if container exists in storage */);
-            if (changeOfState) {
+            if (canSendOpsChanged) {
                 this.signalTelemetryManager.resetTracking();
             }
         }
@@ -1600,12 +1647,12 @@ export class ContainerRuntime extends TypedEventEmitter {
                 return;
             }
         }
-        if (changeOfState) {
+        if (canSendOpsChanged) {
             this.replayPendingStates();
         }
-        this.channelCollection.setConnectionState(connected, clientId);
-        this.garbageCollector.setConnectionState(connected, clientId);
-        raiseConnectedEvent(this.mc.logger, this, connected, clientId);
+        this.channelCollection.setConnectionState(canSendOps, clientId);
+        this.garbageCollector.setConnectionState(canSendOps, clientId);
+        raiseConnectedEvent(this.mc.logger, this, this.connected /* canSendOps */, clientId);
     }
     async notifyOpReplay(message) {
         await this.pendingStateManager.applyStashedOpsAt(message.sequenceNumber);
@@ -2012,7 +2059,9 @@ export class ContainerRuntime extends TypedEventEmitter {
                 if (checkpoint) {
                     // This will throw and close the container if rollback fails
                     try {
-                        checkpoint.rollback((message) => this.rollback(message.runtimeOp, message.localOpMetadata));
+                        checkpoint.rollback((message) => 
+                        // These changes are staged since we entered staging mode above
+                        this.rollbackStagedChanges(message.runtimeOp, message.localOpMetadata));
                         this.updateDocumentDirtyState();
                         stageControls?.discardChanges();
                         stageControls = undefined;
@@ -2089,7 +2138,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         const context = this.channelCollection.createDataStoreContext(Array.isArray(pkg) ? pkg : [pkg], loadingGroupId);
         return channelToDataStore(await context.realize(), context.id, this.channelCollection, this.mc.logger);
     }
-    canSendOps() {
+    shouldSendOps() {
         // Note that the real (non-proxy) delta manager is needed here to get the readonly info. This is because
         // container runtime's ability to send ops depend on the actual readonly state of the delta manager.
         return (this.connected && !this.innerDeltaManager.readOnlyInfo.readonly && !this.imminentClosure);
@@ -2778,6 +2827,7 @@ export class ContainerRuntime extends TypedEventEmitter {
         try {
             // If we're resubmitting a batch, keep the same "staged" value as before.  Otherwise, use the current "global" state.
             const staged = this.batchRunner.resubmitInfo?.staged ?? this.inStagingMode;
+            assert(!staged || canStageMessageOfType(type), 0xbba /* Unexpected message type submitted in Staging Mode */);
             // Before submitting any non-staged change, submit the ID Allocation op to cover any compressed IDs included in the op.
             if (!staged) {
                 this.submitIdAllocationOpIfNeeded({ staged: false });
@@ -2785,7 +2835,7 @@ export class ContainerRuntime extends TypedEventEmitter {
             // Allow document schema controller to send a message if it needs to propose change in document schema.
             // If it needs to send a message, it will call provided callback with payload of such message and rely
             // on this callback to do actual sending.
-            const schemaChangeMessage = this.documentsSchemaController.maybeSendSchemaMessage();
+            const schemaChangeMessage = this.documentsSchemaController.maybeGenerateSchemaMessage();
             if (schemaChangeMessage) {
                 this.mc.logger.sendTelemetryEvent({
                     eventName: "SchemaChangeProposal",
@@ -2883,43 +2933,72 @@ export class ContainerRuntime extends TypedEventEmitter {
     }
     /**
      * Resubmits each message in the batch, and then flushes the outbox.
+     * This typically happens when we reconnect and there are pending messages.
      *
-     * @remarks - If the "Offline Load" feature is enabled, the batchId is included in the resubmitted messages,
+     * @remarks
+     * Attempting to resubmit a batch that has been successfully sequenced will not happen due to
+     * checks in the ConnectionStateHandler (Loader layer)
+     *
+     * The only exception to this would be if the Container "forks" due to misuse of the "Offline Load" feature.
+     * If the "Offline Load" feature is enabled, the batchId is included in the resubmitted messages,
      * for correlation to detect container forking.
      */
     reSubmitBatch(batch, { batchId, staged, squash }) {
+        assert(this._summarizer === undefined, 0x8f2 /* Summarizer never reconnects so should never resubmit */);
         const resubmitInfo = {
             // Only include Batch ID if "Offline Load" feature is enabled
             // It's only needed to identify batches across container forks arising from misuse of offline load.
             batchId: this.offlineEnabled ? batchId : undefined,
             staged,
         };
+        const resubmitFn = squash
+            ? this.reSubmitWithSquashing.bind(this)
+            : this.reSubmit.bind(this);
         this.batchRunner.run(() => {
             for (const message of batch) {
-                this.reSubmit(message, squash);
+                resubmitFn(message);
             }
         }, resubmitInfo);
         this.flush(resubmitInfo);
     }
-    reSubmit(message, squash) {
-        this.reSubmitCore(message.runtimeOp, message.localOpMetadata, message.opMetadata, squash);
+    /**
+     * Resubmit the given message as part of a squash rebase upon exiting Staging Mode.
+     * How exactly to resubmit the message is up to the subsystem that submitted the op to begin with.
+     */
+    reSubmitWithSquashing(resubmitData) {
+        const message = resubmitData.runtimeOp;
+        assert(canStageMessageOfType(message.type), 0xbbb /* Expected message type to be compatible with staging */);
+        switch (message.type) {
+            case ContainerMessageType.FluidDataStoreOp: {
+                this.channelCollection.reSubmit(message.type, message.contents, resubmitData.localOpMetadata, 
+                /* squash: */ true);
+                break;
+            }
+            // NOTE: Squash doesn't apply to GC or DocumentSchemaChange ops, fallback to typical resubmit logic.
+            case ContainerMessageType.GC:
+            case ContainerMessageType.DocumentSchemaChange: {
+                this.reSubmit(resubmitData);
+                break;
+            }
+            default: {
+                unreachableCase(message.type);
+            }
+        }
     }
     /**
-     * Finds the right store and asks it to resubmit the message. This typically happens when we
-     * reconnect and there are pending messages.
-     * ! Note: successfully resubmitting an op that has been successfully sequenced is not possible due to checks in the ConnectionStateHandler (Loader layer)
-     * @param message - The original LocalContainerRuntimeMessage.
-     * @param localOpMetadata - The local metadata associated with the original message.
+     * Resubmit the given message which was previously submitted to the ContainerRuntime but not successfully
+     * transmitted to the ordering service (e.g. due to a disconnect, or being in Staging Mode)
+     * How to resubmit is up to the subsystem that submitted the op to begin with
      */
-    reSubmitCore(message, localOpMetadata, opMetadata, squash) {
-        assert(this._summarizer === undefined, 0x8f2 /* Summarizer never reconnects so should never resubmit */);
+    reSubmit({ runtimeOp: message, localOpMetadata, opMetadata, }) {
         switch (message.type) {
             case ContainerMessageType.FluidDataStoreOp:
             case ContainerMessageType.Attach:
             case ContainerMessageType.Alias: {
                 // For Operations, call resubmitDataStoreOp which will find the right store
                 // and trigger resubmission on it.
-                this.channelCollection.reSubmit(message.type, message.contents, localOpMetadata, squash);
+                this.channelCollection.reSubmit(message.type, message.contents, localOpMetadata, 
+                /* squash: */ false);
                 break;
             }
             case ContainerMessageType.IdAllocation: {
@@ -2945,9 +3024,9 @@ export class ContainerRuntime extends TypedEventEmitter {
                 break;
             }
             case ContainerMessageType.DocumentSchemaChange: {
-                // There is no need to resend this message. Document schema controller will properly resend it again (if needed)
-                // on a first occasion (any ops sent after reconnect). There is a good chance, though, that it will not want to
-                // send any ops, as some other client already changed schema.
+                // We shouldn't directly resubmit due to Compare-And-Swap semantics.
+                // If needed it will be generated from scratch before other ops are submitted.
+                this.documentsSchemaController.pendingOpNotAcked();
                 break;
             }
             default: {
@@ -2957,8 +3036,11 @@ export class ContainerRuntime extends TypedEventEmitter {
             }
         }
     }
-    rollback(runtimeOp, localOpMetadata) {
-        const { type, contents } = runtimeOp;
+    /**
+     * Rollback the given op which was only staged but not yet submitted.
+     */
+    rollbackStagedChanges({ type, contents }, localOpMetadata) {
+        assert(canStageMessageOfType(type), 0xbbc /* Unexpected message type to be rolled back */);
         switch (type) {
             case ContainerMessageType.FluidDataStoreOp: {
                 // For operations, call rollbackDataStoreOp which will find the right store
@@ -2966,8 +3048,24 @@ export class ContainerRuntime extends TypedEventEmitter {
                 this.channelCollection.rollback(type, contents, localOpMetadata);
                 break;
             }
+            case ContainerMessageType.GC: {
+                // Just drop it, but log an error, this is not expected and not ideal, but not critical failure either.
+                // Currently the only expected type here is TombstoneLoaded, which will have been preceded by one of these events as well:
+                // GC_Tombstone_DataStore_Requested, GC_Tombstone_SubDataStore_Requested, GC_Tombstone_Blob_Requested
+                this.mc.logger.sendErrorEvent({
+                    eventName: "GC_OpDiscarded",
+                    details: { subType: contents.type },
+                });
+                break;
+            }
+            case ContainerMessageType.DocumentSchemaChange: {
+                // Notify the document schema controller that the pending op was not acked.
+                // This will allow it to propose the schema change again if needed.
+                this.documentsSchemaController.pendingOpNotAcked();
+                break;
+            }
             default: {
-                throw new Error(`Can't rollback ${type}`);
+                unreachableCase(type);
             }
         }
     }
@@ -3145,6 +3243,7 @@ export class ContainerRuntime extends TypedEventEmitter {
                 },
                 getQuorum: this.getQuorum.bind(this),
                 getAudience: this.getAudience.bind(this),
+                supportedFeatures: this.ILayerCompatDetails.supportedFeatures,
             };
             entry = new factory(runtime, ...useContext);
             this.extensions.set(id, entry);