@fluidframework/container-runtime 2.101.1 → 2.103.0

package/src/opLifecycle/duplicateBatchDetector.ts

@@ -9,6 +9,41 @@ import type { ITelemetryContext } from "@fluidframework/runtime-definitions/inte
 import { getEffectiveBatchId } from "./batchManager.js";
 import type { BatchStartInfo } from "./remoteMessageProcessor.js";
 
+/**
+ * Identifying info for a previously-recorded batch that we can include in DuplicateBatch telemetry
+ * to help diagnose where the duplicate came from.
+ *
+ * @remarks `batchIdExplicit` distinguishes the two main duplicate-source scenarios:
+ * - `true`: the batchId was stamped on the wire as explicit metadata, indicating a resubmit (PendingStateManager.replayPendingStates).
+ * - `false`: the batchId was derived from the wire `clientId` and `batchStartCsn`, indicating a fresh, non-resubmit batch.
+ */
+export interface RecordedBatchInfo {
+	/**
+	 * Wire clientId on the message that started the batch (NOT necessarily the `originalClientId`
+	 * encoded in the batchId for resubmits).
+	 */
+	readonly clientId: string;
+	/**
+	 * Wire client sequence number at the start of the batch.
+	 */
+	readonly batchStartCsn: number;
+	/**
+	 * True if the batchId came from explicit metadata on the wire (i.e. a resubmit),
+	 * false if it was derived from clientId + batchStartCsn (i.e. a fresh submit).
+	 */
+	readonly batchIdExplicit: boolean;
+}
+
+interface RecordedBatch {
+	readonly batchId: string;
+	/**
+	 * Identifying info for the batch as observed at runtime.
+	 * `undefined` if the batch was loaded from a summary snapshot (where only the
+	 * `[seqNum, batchId]` pair is persisted).
+	 */
+	readonly info: RecordedBatchInfo | undefined;
+}
+
 /**
  * Detects duplicate batches that can arise from the "parallel fork" scenario:
  * Container 1 is serialized, and Containers 2 and 3 are rehydrated from that state.
@@ -24,9 +59,21 @@ export class DuplicateBatchDetector {
 	private readonly seqNumByBatchId = new Map<string, number>();
 
 	/**
-	 * We map from sequenceNumber to batchId to find which ones we can stop tracking as MSN advances
+	 * Map from sequenceNumber to the recorded batch info. Used to clear out old entries as MSN
+	 * advances, and to report identifying info about the original occurrence when a duplicate
+	 * is detected.
+	 */
+	private readonly batchesBySeqNum = new Map<number, RecordedBatch>();
+
+	/**
+	 * Number of inbound batches processed since the last summary. Reset by getRecentBatchInfoForSummary.
+	 */
+	private processedBatchCount = 0;
+
+	/**
+	 * Largest tracked-batch count observed since the last summary. Reset by getRecentBatchInfoForSummary.
 	 */
-	private readonly batchIdsBySeqNum = new Map<number, string>();
+	private peakTrackedBatchCount = 0;
 
 	/**
 	 * Initialize from snapshot data if provided - otherwise initialize empty
@@ -34,22 +81,31 @@ export class DuplicateBatchDetector {
 	constructor(batchIdsFromSnapshot: [number, string][] | undefined) {
 		if (batchIdsFromSnapshot) {
 			for (const [seqNum, batchId] of batchIdsFromSnapshot) {
-				this.batchIdsBySeqNum.set(seqNum, batchId);
+				// Entries loaded from a snapshot don't carry the original clientId/csn/explicit-bit;
+				// we record them with `info: undefined` so duplicate telemetry can indicate that.
+				this.batchesBySeqNum.set(seqNum, { batchId, info: undefined });
 				this.seqNumByBatchId.set(batchId, seqNum);
 			}
+			this.peakTrackedBatchCount = this.batchesBySeqNum.size;
 		}
 	}
 
 	/**
 	 * Records this batch's batchId, and checks if it's a duplicate of a batch we've already seen.
-	 * If it's a duplicate, also return the sequence number of the other batch for logging.
+	 * If it's a duplicate, also return the sequence number of the other batch (and identifying info,
+	 * if the other batch was seen during this container session rather than loaded from snapshot) for logging.
 	 *
 	 * @remarks We also use the minimumSequenceNumber to clear out old batchIds that are no longer at risk for duplicates.
 	 */
-	public processInboundBatch(
-		batchStart: BatchStartInfo,
-	): { duplicate: true; otherSequenceNumber: number } | { duplicate: false } {
+	public processInboundBatch(batchStart: BatchStartInfo):
+		| {
+				duplicate: true;
+				otherSequenceNumber: number;
+				otherBatchInfo: RecordedBatchInfo | undefined;
+		  }
+		| { duplicate: false } {
 		const { sequenceNumber, minimumSequenceNumber } = batchStart.keyMessage;
+		this.processedBatchCount++;
 
 		// Glance at this batch's MSN. Any batchIds we're tracking with a lower sequence number are now safe to forget.
 		// Why? Because any other client holding the same batch locally would have seen the earlier batch and closed before submitting its duplicate.
@@ -64,22 +120,37 @@ export class DuplicateBatchDetector {
 		// O(1) duplicate check + get otherSequenceNumber in one lookup
 		const otherSequenceNumber = this.seqNumByBatchId.get(batchId);
 		if (otherSequenceNumber !== undefined) {
+			const other = this.batchesBySeqNum.get(otherSequenceNumber);
 			assert(
-				this.batchIdsBySeqNum.get(otherSequenceNumber) === batchId,
+				other?.batchId === batchId,
 				0xce0 /* batchIdToSeqNum and seqNumToBatchId should be in sync for duplicate */,
 			);
-			return { duplicate: true, otherSequenceNumber };
+			return {
+				duplicate: true,
+				otherSequenceNumber,
+				otherBatchInfo: other.info,
+			};
 		}
 
 		// Now we know it's not a duplicate, so add it to the tracked batchIds and return.
 		assert(
-			!this.batchIdsBySeqNum.has(sequenceNumber),
+			!this.batchesBySeqNum.has(sequenceNumber),
 			0xce1 /* seqNumToBatchId and batchIdToSeqNum should be in sync */,
 		);
 
-		// Add new batch
-		this.batchIdsBySeqNum.set(sequenceNumber, batchId);
+		// Add new batch. Record identifying info so we can report it if a future duplicate matches us.
+		const info: RecordedBatchInfo | undefined = {
+			clientId: batchStart.clientId,
+			batchStartCsn: batchStart.batchStartCsn,
+			// True iff the wire carried explicit batchId metadata (resubmit path).
+			// False indicates the batchId was derived from clientId + batchStartCsn (fresh submit).
+			batchIdExplicit: batchStart.batchId !== undefined,
+		};
+		this.batchesBySeqNum.set(sequenceNumber, { batchId, info });
 		this.seqNumByBatchId.set(batchId, sequenceNumber);
+		if (this.batchesBySeqNum.size > this.peakTrackedBatchCount) {
+			this.peakTrackedBatchCount = this.batchesBySeqNum.size;
+		}
 
 		return { duplicate: false };
 	}
@@ -89,10 +160,10 @@ export class DuplicateBatchDetector {
 	 * since the batch start has been processed by all clients, and local batches are deduped and the forked client would close.
 	 */
 	private clearOldBatchIds(msn: number): void {
-		for (const [sequenceNumber, batchId] of this.batchIdsBySeqNum) {
+		for (const [sequenceNumber, recorded] of this.batchesBySeqNum) {
 			if (sequenceNumber < msn) {
-				this.batchIdsBySeqNum.delete(sequenceNumber);
-				this.seqNumByBatchId.delete(batchId);
+				this.batchesBySeqNum.delete(sequenceNumber);
+				this.seqNumByBatchId.delete(recorded.batchId);
 			} else {
 				break;
 			}
@@ -108,16 +179,25 @@ export class DuplicateBatchDetector {
 	public getRecentBatchInfoForSummary(
 		telemetryContext?: ITelemetryContext,
 	): [number, string][] | undefined {
-		if (this.batchIdsBySeqNum.size === 0) {
-			return undefined;
+		if (telemetryContext !== undefined) {
+			const prefix = "fluid_DuplicateBatchDetector_";
+			telemetryContext.set(prefix, "recentBatchCount", this.batchesBySeqNum.size);
+			telemetryContext.set(prefix, "peakRecentBatchCount", this.peakTrackedBatchCount);
+			telemetryContext.set(prefix, "processedBatchCount", this.processedBatchCount);
 		}
 
-		telemetryContext?.set(
-			"fluid_DuplicateBatchDetector_",
-			"recentBatchCount",
-			this.batchIdsBySeqNum.size,
-		);
+		// Reset per-window perf counters so each summary covers only the activity since the
+		// previous one. Peak resets to the current size (the floor for the next window).
+		this.processedBatchCount = 0;
+		this.peakTrackedBatchCount = this.batchesBySeqNum.size;
+
+		if (this.batchesBySeqNum.size === 0) {
+			return undefined;
+		}
 
-		return [...this.batchIdsBySeqNum.entries()];
+		return [...this.batchesBySeqNum.entries()].map(([seqNum, recorded]) => [
+			seqNum,
+			recorded.batchId,
+		]);
 	}
 }

package/src/opLifecycle/opCompressor.ts

@@ -9,7 +9,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 import {
 	DataProcessingError,
 	createChildLogger,
-	type ITelemetryLoggerExt,
+	type TelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
 import { compress } from "lz4js";
 
@@ -25,7 +25,7 @@ import { estimateSocketSize } from "./outbox.js";
  * Use opGroupingManager to group a batch into a singleton batch suitable for compression.
  */
 export class OpCompressor {
-	private readonly logger: ITelemetryLoggerExt;
+	private readonly logger: TelemetryLoggerExt;
 
 	constructor(logger: ITelemetryBaseLogger) {
 		this.logger = createChildLogger({ logger, namespace: "OpCompressor" });

package/src/opLifecycle/opDecompressor.ts

@@ -9,7 +9,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 import type { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import {
 	createChildLogger,
-	type ITelemetryLoggerExt,
+	type TelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
 import { decompress } from "lz4js";
 
@@ -40,7 +40,7 @@ export class OpDecompressor {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	private rootMessageContents: any | undefined;
 	private processedCount = 0;
-	private readonly logger: ITelemetryLoggerExt;
+	private readonly logger: TelemetryLoggerExt;
 
 	constructor(logger: ITelemetryBaseLogger) {
 		this.logger = createChildLogger({ logger, namespace: "OpDecompressor" });

package/src/opLifecycle/opGroupingManager.ts

@@ -8,7 +8,7 @@ import { assert } from "@fluidframework/core-utils/internal";
 import type { ISequencedDocumentMessage } from "@fluidframework/driver-definitions/internal";
 import {
 	createChildLogger,
-	type ITelemetryLoggerExt,
+	type TelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
 
 import type {
@@ -65,7 +65,7 @@ export interface EmptyGroupedBatch {
 
 export class OpGroupingManager {
 	static readonly groupedBatchOp = "groupedBatch";
-	private readonly logger: ITelemetryLoggerExt;
+	private readonly logger: TelemetryLoggerExt;
 
 	constructor(
 		private readonly config: OpGroupingManagerConfig,

package/src/opLifecycle/opSplitter.ts

@@ -11,7 +11,7 @@ import {
 	DataCorruptionError,
 	createChildLogger,
 	extractSafePropertiesFromMessage,
-	type ITelemetryLoggerExt,
+	type TelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
 
 import {
@@ -45,7 +45,7 @@ function isChunkedContents(contents: unknown): contents is IChunkedContents {
 export class OpSplitter {
 	// Local copy of incomplete received chunks.
 	private readonly chunkMap: Map<string, string[]>;
-	private readonly logger: ITelemetryLoggerExt;
+	private readonly logger: TelemetryLoggerExt;
 
 	constructor(
 		chunks: [string, string[]][],

package/src/opLifecycle/outbox.ts

@@ -14,7 +14,7 @@ import {
 	UsageError,
 	createChildLogger,
 	type IFluidErrorBase,
-	type ITelemetryLoggerExt,
+	type TelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
 
 import type { ICompressionRuntimeOptions } from "../compressionDefinitions.js";
@@ -194,7 +194,7 @@ export const estimateSocketSize = (batch: OutboundBatch): number => {
  * to support slight variation in semantics for each batch (e.g. support for rebasing or grouping).
  */
 export class Outbox {
-	private readonly logger: ITelemetryLoggerExt;
+	private readonly logger: TelemetryLoggerExt;
 	private readonly mainBatch: BatchManager;
 	private readonly blobAttachBatch: BatchManager;
 	private batchRebasesToReport = 5;

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.101.1";
+export const pkgVersion = "2.103.0";

package/src/pendingStateManager.ts

@@ -6,7 +6,7 @@
 import type { IDisposable, ITelemetryBaseLogger } from "@fluidframework/core-interfaces";
 import { assert, Lazy } from "@fluidframework/core-utils/internal";
 import {
-	type ITelemetryLoggerExt,
+	type TelemetryLoggerExt,
 	DataProcessingError,
 	LoggingError,
 	extractSafePropertiesFromMessage,
@@ -142,6 +142,25 @@ export interface IRuntimeStateHandler {
 	isAttached: () => boolean;
 }
 
+/**
+ * Optional hooks invoked at the close of the stashed-op apply lifecycle.
+ *
+ * `onAfterStashedOpsApplied` fires synchronously the first time
+ * `initialMessages` drains during `applyStashedOpsAt`, immediately after
+ * `isApplyingStashedOps` flips to `false`. Fires at most once per PSM
+ * lifetime. If an apply throws, control never reaches the close site and
+ * the hook is not invoked — load is fatal in that case.
+ *
+ * No corresponding open hook is exposed. The apply window is opened eagerly
+ * in the PSM constructor, but at that point `ContainerRuntime` has not yet
+ * wired up the downstream observers (`channelCollection` is undefined), so a
+ * fanout fired from the constructor would be a no-op. Consumers that care
+ * about the open transition can read `isApplyingStashedOps` directly.
+ */
+export interface PendingStateManagerHooks {
+	onAfterStashedOpsApplied?: () => void;
+}
+
 function isEmptyBatchPendingMessage(message: IPendingMessageFromStash): boolean {
 	const content = JSON.parse(message.content) as Partial<EmptyGroupedBatch>;
 	return content.type === "groupedBatch" && content.contents?.length === 0;
@@ -366,17 +385,62 @@ export class PendingStateManager implements IDisposable {
 		};
 	}
 
-	private readonly logger: ITelemetryLoggerExt;
+	private readonly logger: TelemetryLoggerExt;
+
+	/**
+	 * One-way lifecycle of the stashed-op apply window: `ended` → `applying` → `ended`.
+	 *
+	 * Default is `ended` — no stashed state means there's nothing to apply, so the window is
+	 * closed before it ever opens. `ended` → `applying` happens in the constructor when
+	 * stashed state is present (i.e. `initialMessages` is non-empty at construction). The
+	 * open is eager so the runtime is readonly from the moment any DDS could possibly
+	 * observe it. `applying` → `ended` happens the first time {@link applyStashedOpsAt}
+	 * drains `initialMessages`. After that, local edits are safe — they queue FIFO behind
+	 * any remaining `pendingMessages`, preserving server-side ordering.
+	 *
+	 * The window never reopens. After the close, subsequent `applyStashedOpsAt` calls (e.g.
+	 * from late `notifyOpReplay`s) early-return at the empty guard.
+	 *
+	 * `pendingMessages` state is intentionally NOT part of the close condition. Those
+	 * entries are drained transparently by {@link replayPendingStates} on connect via
+	 * resubmit (each pop is matched by a fresh push), so the queue size is conserved across
+	 * resubmit and DDSes can't distinguish a resubmit-ack from a normal ack. Holding the
+	 * window open through resubmit would force resubmits to run while the runtime is
+	 * readonly, which is the inverse of what we want ("never resubmit during apply stashed
+	 * ops").
+	 *
+	 * An apply error leaves the lifecycle at `applying` because the queue isn't drained.
+	 * That's fine: an error here is fatal for the load, the container is unusable, and
+	 * there's no state to restore.
+	 */
+	private _applyLifecycle: "applying" | "ended" = "ended";
+	public get isApplyingStashedOps(): boolean {
+		return this._applyLifecycle === "applying";
+	}
+
+	private readonly hooks: PendingStateManagerHooks;
 
 	constructor(
 		private readonly stateHandler: IRuntimeStateHandler,
 		stashedLocalState: IPendingLocalState | undefined,
 		logger: ITelemetryBaseLogger,
+		hooks: PendingStateManagerHooks = {},
 	) {
 		this.logger = createChildLogger({ logger });
+		this.hooks = hooks;
 		if (stashedLocalState?.pendingStates) {
 			this.initialMessages.push(...stashedLocalState.pendingStates);
 		}
+		// Open the apply window eagerly if there is any stashed work. The
+		// runtime is readonly while `isApplyingStashedOps` is true (see
+		// `ContainerRuntime.isReadOnly`); compliant DDSes consult `readOnly`
+		// at realize time and skip submits. No fanout fires here — downstream
+		// observers (`channelCollection`) are not yet constructed at this
+		// point in the runtime constructor, and the first real readonly read
+		// happens after the constructor returns.
+		if (!this.initialMessages.isEmpty()) {
+			this._applyLifecycle = "applying";
+		}
 	}
 
 	public get disposed(): boolean {
@@ -451,6 +515,10 @@ export class PendingStateManager implements IDisposable {
 	 * @param seqNum - Sequence number at which to apply ops. Will apply all ops if seqNum is undefined.
 	 */
 	public async applyStashedOpsAt(seqNum?: number): Promise<void> {
+		if (this.initialMessages.isEmpty()) {
+			return;
+		}
+
 		// apply stashed ops at sequence number
 		while (!this.initialMessages.isEmpty()) {
 			if (seqNum !== undefined) {
@@ -497,6 +565,16 @@ export class PendingStateManager implements IDisposable {
 				throw DataProcessingError.wrapIfUnrecognized(error, "applyStashedOp", nextMessage);
 			}
 		}
+
+		// The apply window was opened eagerly in the constructor when there
+		// was any stashed work. We close it on full successful drain only.
+		// If an apply throws above, control never reaches here and the
+		// lifecycle stays at "applying" — the load is fatal so there's no
+		// recoverable state.
+		if (this._applyLifecycle === "applying" && this.initialMessages.isEmpty()) {
+			this._applyLifecycle = "ended";
+			this.hooks.onAfterStashedOpsApplied?.();
+		}
 	}
 
 	/**

package/src/signalTelemetryProcessing.ts

@@ -5,7 +5,7 @@
 
 import type { ISignalEnvelope } from "@fluidframework/core-interfaces/internal";
 import type {
-	ITelemetryLoggerExt,
+	TelemetryLoggerExt,
 	TelemetryEventPropertyTypeExt,
 } from "@fluidframework/telemetry-utils/internal";
 
@@ -101,7 +101,7 @@ export class SignalTelemetryManager {
 	 */
 	public trackReceivedSignal(
 		envelope: ISignalEnvelope,
-		logger: ITelemetryLoggerExt,
+		logger: TelemetryLoggerExt,
 		consecutiveReconnects: number,
 	): void {
 		const {

package/src/summary/documentSchema.ts

@@ -5,7 +5,7 @@
 
 import { assert } from "@fluidframework/core-utils/internal";
 import type { SemanticVersion } from "@fluidframework/runtime-utils/internal";
-import type { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
+import type { TelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
 import { DataProcessingError } from "@fluidframework/telemetry-utils/internal";
 import { gt, lt, parse } from "semver-ts";
 
@@ -303,6 +303,58 @@ const documentSchemaSupportedConfigs = {
 	disallowedVersions: new CheckVersions(),
 };
 
+/**
+ * Entry in {@link retiredDocumentSchemaFeatures}.
+ *
+ * - `handler` validates/merges the persisted value (same as a "non-retired" feature).
+ * - `value` is the hardcoded value that this runtime will always use for the desired schema.
+ */
+interface IRetiredFeatureEntry {
+	handler: IProperty;
+	value: DocumentSchemaValueType;
+}
+
+/**
+ * Retired runtime features. A retired feature is one this runtime version no longer toggles
+ * via {@link IDocumentSchemaFeatures}, but that older documents may still carry in their
+ * persisted schema. Each entry bundles the property handler with the hardcoded value for the feature.
+ *
+ * Retired features participate in the normal merge / schema-change-op flow exactly like
+ * non-retired features — the only difference is that their values are hardcoded.
+ */
+const retiredDocumentSchemaFeatures = {
+	// Note: There are currently no retired retired features. To retire a feature, remove it from IDocumentSchemaFeatures
+	// and documentSchemaSupportedConfigs and add an entry here, e.g.:
+	//   featureFoo: { handler: new TrueOrUndefined(), value: true },
+} satisfies Record<string, IRetiredFeatureEntry> & {
+	// This ensures that retiredDocumentSchemaFeatures and IDocumentSchemaFeatures are mutually exclusive.
+	[K in keyof IDocumentSchemaFeatures]?: never;
+};
+
+/**
+ * Looks up the validator/merger for a given runtime property name across both supported and
+ * retired configs. Returns `undefined` if the property is unknown to this runtime.
+ */
+function getRuntimeConfigHandler(name: string): IProperty | undefined {
+	return (
+		(documentSchemaSupportedConfigs as Record<string, IProperty>)[name] ??
+		(retiredDocumentSchemaFeatures as Record<string, IRetiredFeatureEntry>)[name]?.handler
+	);
+}
+
+/**
+ * Builds the `{ key: value }` for retired features (for building the desired schema).
+ */
+function retiredFeatureValues(): Record<string, DocumentSchemaValueType> {
+	const result: Record<string, DocumentSchemaValueType> = {};
+	for (const [key, entry] of Object.entries(
+		retiredDocumentSchemaFeatures as Record<string, IRetiredFeatureEntry>,
+	)) {
+		result[key] = entry.value;
+	}
+	return result;
+}
+
 /**
  * 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.
@@ -343,7 +395,7 @@ function checkRuntimeCompatibility(
 		unknownProperty = "runtime";
 	} else {
 		for (const [name, value] of Object.entries(documentSchema.runtime)) {
-			const validator = documentSchemaSupportedConfigs[name] as IProperty | undefined;
+			const validator = getRuntimeConfigHandler(name);
 			if (!(validator?.validate(value) ?? false)) {
 				unknownProperty = `runtime/${name}`;
 			}
@@ -377,7 +429,7 @@ function and(
 		...Object.keys(persistedSchema.runtime),
 		...Object.keys(providedSchema.runtime),
 	])) {
-		runtime[key] = (documentSchemaSupportedConfigs[key] as IProperty).and(
+		runtime[key] = (getRuntimeConfigHandler(key) as IProperty).and(
 			persistedSchema.runtime[key],
 			providedSchema.runtime[key],
 		);
@@ -405,7 +457,7 @@ function or(
 		...Object.keys(persistedSchema.runtime),
 		...Object.keys(providedSchema.runtime),
 	])) {
-		runtime[key] = (documentSchemaSupportedConfigs[key] as IProperty).or(
+		runtime[key] = (getRuntimeConfigHandler(key) as IProperty).or(
 			persistedSchema.runtime[key],
 			providedSchema.runtime[key],
 		);
@@ -581,7 +633,7 @@ export class DocumentsSchemaController {
 		features: IDocumentSchemaFeatures,
 		private readonly onSchemaChange: (schema: IDocumentSchemaCurrent) => void,
 		info: IDocumentSchemaInfo,
-		logger: ITelemetryLoggerExt,
+		logger: TelemetryLoggerExt,
 		private readonly disableSchemaUpgrade: boolean,
 	) {
 		// For simplicity, let's only support new schema features for explicit schema control mode
@@ -625,6 +677,7 @@ export class DocumentsSchemaController {
 				opGroupingEnabled: boolToProp(features.opGroupingEnabled),
 				createBlobPayloadPending: features.createBlobPayloadPending,
 				disallowedVersions: arrayToProp(features.disallowedVersions),
+				...retiredFeatureValues(),
 			},
 		};
 

package/src/summary/orderedClientElection.ts

@@ -19,7 +19,7 @@ import type {
 	ISequencedClient,
 } from "@fluidframework/driver-definitions";
 import {
-	type ITelemetryLoggerExt,
+	type TelemetryLoggerExt,
 	UsageError,
 	createChildLogger,
 } from "@fluidframework/telemetry-utils/internal";
@@ -135,7 +135,7 @@ export class OrderedClientCollection
 	 * Pointer to end of linked list, for optimized client adds.
 	 */
 	private _youngestClient: LinkNode = this.rootNode;
-	private readonly logger: ITelemetryLoggerExt;
+	private readonly logger: TelemetryLoggerExt;
 
 	public get count(): number {
 		return this.clientMap.size;
@@ -413,7 +413,7 @@ export class OrderedClientElection
 	}
 
 	constructor(
-		private readonly logger: ITelemetryLoggerExt,
+		private readonly logger: TelemetryLoggerExt,
 		private readonly orderedClientCollection: IOrderedClientCollection,
 		/**
 		 * Serialized state from summary or current sequence number at time of load if new.

package/src/summary/summarizerClientElection.ts

@@ -7,7 +7,7 @@ import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import type { IEvent, IEventProvider } from "@fluidframework/core-interfaces";
 import type { IClientDetails } from "@fluidframework/driver-definitions";
 import { MessageType } from "@fluidframework/driver-definitions/internal";
-import type { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
+import type { TelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
 
 import type {
 	IOrderedClientElection,
@@ -58,7 +58,7 @@ export class SummarizerClientElection
 	}
 
 	constructor(
-		private readonly logger: ITelemetryLoggerExt,
+		private readonly logger: TelemetryLoggerExt,
 		private readonly summaryCollection: IEventProvider<ISummaryCollectionOpEvents>,
 		public readonly clientElection: IOrderedClientElection,
 		private readonly maxOpsSinceLastSummary: number,

package/src/summary/summarizerNode/summarizerNode.ts

@@ -31,7 +31,7 @@ import {
 } from "@fluidframework/telemetry-utils/internal";
 import type {
 	ITelemetryErrorEventExt,
-	ITelemetryLoggerExt,
+	TelemetryLoggerExt,
 } from "@fluidframework/telemetry-utils/internal";
 
 import type {
@@ -90,7 +90,7 @@ export class SummarizerNode implements IRootSummarizerNode {
 	private wipSummarizeCalled: boolean = false;
 	private wipSkipRecursion = false;
 
-	protected readonly logger: ITelemetryLoggerExt;
+	protected readonly logger: TelemetryLoggerExt;
 
 	/**
 	 * Do not call constructor directly.
@@ -664,7 +664,7 @@ export class SummarizerNode implements IRootSummarizerNode {
  * @param config - Configure behavior of summarizer node
  */
 export const createRootSummarizerNode = (
-	logger: ITelemetryLoggerExt,
+	logger: TelemetryLoggerExt,
 	summarizeInternalFn: SummarizeInternalFn,
 	changeSequenceNumber: number,
 	referenceSequenceNumber: number | undefined,

package/src/summary/summarizerNode/summarizerNodeUtils.ts

@@ -6,7 +6,7 @@
 import type { SummaryObject } from "@fluidframework/driver-definitions";
 import type { ISnapshotTree } from "@fluidframework/driver-definitions/internal";
 import type {
-	ITelemetryLoggerExt,
+	TelemetryLoggerExt,
 	TelemetryDataTag,
 } from "@fluidframework/telemetry-utils/internal";
 
@@ -67,7 +67,7 @@ export type ValidateSummaryResult =
 export interface ISummarizerNodeRootContract {
 	startSummary(
 		referenceSequenceNumber: number,
-		summaryLogger: ITelemetryLoggerExt,
+		summaryLogger: TelemetryLoggerExt,
 		latestSummaryRefSeqNum: number,
 	): IStartSummaryResult;
 	validateSummary(): ValidateSummaryResult;

package/src/summary/summarizerTypes.ts

@@ -24,7 +24,7 @@ import type {
 import type { ISummaryStats } from "@fluidframework/runtime-definitions/internal";
 import type { TelemetryContext } from "@fluidframework/runtime-utils/internal";
 import type {
-	ITelemetryLoggerExt,
+	TelemetryLoggerExt,
 	ITelemetryLoggerPropertyBag,
 } from "@fluidframework/telemetry-utils/internal";
 
@@ -79,7 +79,7 @@ export interface IRefreshSummaryAckOptions {
 	/**
 	 * Telemetry logger to which telemetry events will be forwarded.
 	 */
-	readonly summaryLogger: ITelemetryLoggerExt;
+	readonly summaryLogger: TelemetryLoggerExt;
 }
 
 /**
@@ -157,7 +157,7 @@ export interface ISubmitSummaryOptions extends ISummarizeOptions {
 	/**
 	 * Logger to use for correlated summary events
 	 */
-	readonly summaryLogger: ITelemetryLoggerExt;
+	readonly summaryLogger: TelemetryLoggerExt;
 	/**
 	 * Tells when summary process should be cancelled
 	 */