@fluidframework/container-runtime 2.0.0-internal.7.2.2 → 2.0.0-internal.7.4.0

package/src/gc/gcTelemetry.ts

@@ -14,7 +14,6 @@ import {
 import { RuntimeHeaderData } from "../containerRuntime";
 import { ICreateContainerMetadata } from "../summary";
 import {
-	disableSweepLogKey,
 	GCNodeType,
 	UnreferencedState,
 	IGarbageCollectorConfigs,
@@ -143,6 +142,21 @@ export class GCTelemetryTracker {
 
 		const nodeStateTracker = this.getNodeStateTracker(nodeUsageProps.id);
 		const nodeType = this.getNodeType(nodeUsageProps.id);
+		const timeout = (() => {
+			switch (nodeStateTracker?.state) {
+				case UnreferencedState.Inactive:
+					return this.configs.inactiveTimeoutMs;
+				case UnreferencedState.TombstoneReady:
+					return this.configs.sweepTimeoutMs;
+				case UnreferencedState.SweepReady:
+					return (
+						this.configs.sweepTimeoutMs &&
+						this.configs.sweepTimeoutMs + this.configs.sweepGracePeriodMs
+					);
+				default:
+					return undefined;
+			}
+		})();
 		const {
 			usageType,
 			currentReferenceTimestampMs,
@@ -160,10 +174,7 @@ export class GCTelemetryTracker {
 					? nodeUsageProps.currentReferenceTimestampMs -
 					  nodeStateTracker.unreferencedTimestampMs
 					: -1,
-			timeout:
-				nodeStateTracker?.state === UnreferencedState.Inactive
-					? this.configs.inactiveTimeoutMs
-					: this.configs.sweepTimeoutMs,
+			timeout,
 			...tagCodeArtifacts({ id: untaggedId, fromId: untaggedFromId }),
 			...propsToLog,
 			...this.createContainerMetadata,
@@ -392,58 +403,6 @@ export class GCTelemetryTracker {
 		}
 		this.pendingEventsQueue = [];
 	}
-
-	/**
-	 * For nodes that are ready to sweep, log an event for now. Until we start running sweep which deletes objects,
-	 * this will give us a view into how much deleted content a container has.
-	 */
-	public logSweepEvents(
-		logger: ITelemetryLoggerExt,
-		currentReferenceTimestampMs: number,
-		unreferencedNodesState: Map<string, UnreferencedStateTracker>,
-		completedGCRuns: number,
-		lastSummaryTime?: number,
-	) {
-		if (
-			this.mc.config.getBoolean(disableSweepLogKey) === true ||
-			this.configs.sweepTimeoutMs === undefined
-		) {
-			return;
-		}
-
-		const deletedNodeIds: string[] = [];
-		for (const [nodeId, nodeStateTracker] of unreferencedNodesState) {
-			if (nodeStateTracker.state !== UnreferencedState.SweepReady) {
-				return;
-			}
-
-			const nodeType = this.getNodeType(nodeId);
-			if (nodeType !== GCNodeType.DataStore && nodeType !== GCNodeType.Blob) {
-				return;
-			}
-
-			// Log deleted event for each node only once to reduce noise in telemetry.
-			const uniqueEventId = `Deleted-${nodeId}`;
-			if (this.loggedUnreferencedEvents.has(uniqueEventId)) {
-				return;
-			}
-			this.loggedUnreferencedEvents.add(uniqueEventId);
-			deletedNodeIds.push(nodeId);
-		}
-
-		if (deletedNodeIds.length > 0) {
-			logger.sendTelemetryEvent({
-				eventName: "GC_SweepReadyObjects_Delete",
-				details: JSON.stringify({
-					timeout: this.configs.sweepTimeoutMs,
-					completedGCRuns,
-					lastSummaryTime,
-					...this.createContainerMetadata,
-				}),
-				...tagCodeArtifacts({ id: JSON.stringify(deletedNodeIds) }),
-			});
-		}
-	}
 }
 
 /**

package/src/gc/gcUnreferencedStateTracker.ts

@@ -4,6 +4,7 @@
  */
 
 import { assert, Timer } from "@fluidframework/core-utils";
+import { validatePrecondition } from "@fluidframework/telemetry-utils";
 import { UnreferencedState } from "./gcDefinitions";
 
 /** A wrapper around common-utils Timer that requires the timeout when calling start/restart */
@@ -26,7 +27,7 @@ class TimerWithNoDefaultTimeout extends Timer {
 
 /**
  * Helper class that tracks the state of an unreferenced node such as the time it was unreferenced and if it can
- * be deleted by the sweep phase.
+ * be tombstoned or deleted by the sweep phase.
  */
 export class UnreferencedStateTracker {
 	private _state: UnreferencedState = UnreferencedState.Active;
@@ -36,6 +37,8 @@ export class UnreferencedStateTracker {
 
 	/** Timer to indicate when an unreferenced object is considered Inactive */
 	private readonly inactiveTimer: TimerWithNoDefaultTimeout;
+	/** Timer to indicate when an unreferenced object is Tombstone-Ready */
+	private readonly tombstoneTimer: TimerWithNoDefaultTimeout;
 	/** Timer to indicate when an unreferenced object is Sweep-Ready */
 	private readonly sweepTimer: TimerWithNoDefaultTimeout;
 
@@ -45,32 +48,49 @@ export class UnreferencedStateTracker {
 		private readonly inactiveTimeoutMs: number,
 		/** The current reference timestamp used to track how long this node has been unreferenced for. */
 		currentReferenceTimestampMs: number,
-		/** The time after which node transitions to SweepReady state; undefined if session expiry is disabled. */
-		private readonly sweepTimeoutMs: number | undefined,
+		/** The time after which node transitions to TombstoneReady state; undefined if session expiry is disabled. */
+		private readonly tombstoneTimeoutMs: number | undefined,
+		/** The delay from TombstoneReady to SweepReady (only applies if tombstoneTimeoutMs is defined) */
+		private readonly sweepGracePeriodMs: number,
 	) {
-		if (this.sweepTimeoutMs !== undefined) {
-			assert(
-				this.inactiveTimeoutMs <= this.sweepTimeoutMs,
-				0x3b0 /* inactive timeout must not be greater than the sweep timeout */,
-			);
-		}
+		validatePrecondition(
+			this.tombstoneTimeoutMs === undefined ||
+				this.tombstoneTimeoutMs >= this.inactiveTimeoutMs,
+			"inactiveTimeoutMs must not be greater than the tombstoneTimeoutMs",
+		);
 
 		this.sweepTimer = new TimerWithNoDefaultTimeout(() => {
 			this._state = UnreferencedState.SweepReady;
 			assert(
-				!this.inactiveTimer.hasTimer,
-				0x3b1 /* inactiveTimer still running after sweepTimer fired! */,
+				!this.inactiveTimer.hasTimer && !this.tombstoneTimer.hasTimer,
+				0x863 /* inactiveTimer or tombstoneTimer still running after sweepTimer fired! */,
 			);
 		});
 
+		this.tombstoneTimer = new TimerWithNoDefaultTimeout(() => {
+			this._state = UnreferencedState.TombstoneReady;
+			assert(
+				!this.inactiveTimer.hasTimer,
+				0x864 /* inactiveTimer still running after tombstoneTimer fired! */,
+			); // aka 0x3b1
+
+			if (this.sweepGracePeriodMs > 0) {
+				// After the node becomes tombstone ready, start the sweep timer after which the node will be ready for sweep.
+				this.sweepTimer.restart(this.sweepGracePeriodMs);
+			} else {
+				this._state = UnreferencedState.SweepReady;
+			}
+		});
+
 		this.inactiveTimer = new TimerWithNoDefaultTimeout(() => {
 			this._state = UnreferencedState.Inactive;
 
-			// After the node becomes inactive, start the sweep timer after which the node will be ready for sweep.
-			if (this.sweepTimeoutMs !== undefined) {
-				this.sweepTimer.restart(this.sweepTimeoutMs - this.inactiveTimeoutMs);
+			// After the node becomes inactive, start the tombstone timer after which the node will be ready for tombstone.
+			if (this.tombstoneTimeoutMs !== undefined) {
+				this.tombstoneTimer.restart(this.tombstoneTimeoutMs - this.inactiveTimeoutMs);
 			}
 		});
+
 		this.updateTracking(currentReferenceTimestampMs);
 	}
 
@@ -78,21 +98,39 @@ export class UnreferencedStateTracker {
 	public updateTracking(currentReferenceTimestampMs: number) {
 		const unreferencedDurationMs = currentReferenceTimestampMs - this.unreferencedTimestampMs;
 
-		// If the node has been unreferenced for sweep timeout amount of time, update the state to SweepReady.
-		if (this.sweepTimeoutMs !== undefined && unreferencedDurationMs >= this.sweepTimeoutMs) {
+		// Below we will set the appropriate timer (or none). Any running timers are superceded by the new currentReferenceTimestampMs
+		this.clearTimers();
+
+		// If the node has been unreferenced long enough, update the state to SweepReady.
+		if (
+			this.tombstoneTimeoutMs !== undefined &&
+			unreferencedDurationMs >= this.tombstoneTimeoutMs + this.sweepGracePeriodMs
+		) {
 			this._state = UnreferencedState.SweepReady;
-			this.clearTimers();
 			return;
 		}
 
-		// If the node has been unreferenced for inactive timeoutMs amount of time, update the state to inactive.
-		// Also, start a timer for the sweep timeout.
+		// If the node has been unreferenced long enough, update the state to TombstoneReady.
+		// Also, start a timer for the remainder of the sweep delay.
+		if (
+			this.tombstoneTimeoutMs !== undefined &&
+			unreferencedDurationMs >= this.tombstoneTimeoutMs
+		) {
+			this._state = UnreferencedState.TombstoneReady;
+
+			this.sweepTimer.restart(
+				this.tombstoneTimeoutMs + this.sweepGracePeriodMs - unreferencedDurationMs,
+			);
+			return;
+		}
+
+		// If the node has been unreferenced for long enough, update the state to inactive.
+		// Also, start a timer for the remainder of the tombstone timeout.
 		if (unreferencedDurationMs >= this.inactiveTimeoutMs) {
 			this._state = UnreferencedState.Inactive;
-			this.inactiveTimer.clear();
 
-			if (this.sweepTimeoutMs !== undefined) {
-				this.sweepTimer.restart(this.sweepTimeoutMs - unreferencedDurationMs);
+			if (this.tombstoneTimeoutMs !== undefined) {
+				this.tombstoneTimer.restart(this.tombstoneTimeoutMs - unreferencedDurationMs);
 			}
 			return;
 		}
@@ -103,6 +141,7 @@ export class UnreferencedStateTracker {
 
 	private clearTimers() {
 		this.inactiveTimer.clear();
+		this.tombstoneTimer.clear();
 		this.sweepTimer.clear();
 	}
 

package/src/gc/index.ts

@@ -7,13 +7,12 @@ export { GarbageCollector } from "./garbageCollection";
 export {
 	nextGCVersion,
 	defaultInactiveTimeoutMs,
+	defaultSweepGracePeriodMs,
 	defaultSessionExpiryDurationMs,
-	disableSweepLogKey,
 	GCNodeType,
 	gcTestModeKey,
-	gcTombstoneGenerationOptionName,
-	gcThrowOnTombstoneLoadOptionName,
-	gcSweepGenerationOptionName,
+	gcDisableThrowOnTombstoneLoadOptionName,
+	gcGenerationOptionName,
 	GCFeatureMatrix,
 	GCVersion,
 	gcVersionUpgradeToV4Key,
@@ -24,6 +23,8 @@ export {
 	IGCMetadata,
 	IGCResult,
 	IGCRuntimeOptions,
+	IMarkPhaseStats,
+	ISweepPhaseStats,
 	IGCStats,
 	oneDayMs,
 	runGCKey,
@@ -34,6 +35,7 @@ export {
 	disableDatastoreSweepKey,
 	UnreferencedState,
 	throwOnTombstoneLoadOverrideKey,
+	GarbageCollectionMessage,
 } from "./gcDefinitions";
 export {
 	cloneGCData,

package/src/index.ts

@@ -40,6 +40,8 @@ export {
 	GCFeatureMatrix,
 	GCVersion,
 	IGCRuntimeOptions,
+	IMarkPhaseStats,
+	ISweepPhaseStats,
 	IGCStats,
 } from "./gc";
 export {
@@ -91,5 +93,21 @@ export {
 	IRetriableFailureResult,
 	ISummarizeEventProps,
 } from "./summary";
-export { isStableId, generateStableId, assertIsStableId } from "./id-compressor";
 export { IChunkedOp, unpackRuntimeMessage } from "./opLifecycle";
+
+// Re-exports for backwards compatibility.
+// Will be removed in the future.
+export {
+	/**
+	 * @deprecated Import from `@fluidframework/id-compressor` instead.
+	 */
+	assertIsStableId,
+	/**
+	 * @deprecated Import from `@fluidframework/id-compressor` instead.
+	 */
+	generateStableId,
+	/**
+	 * @deprecated Import from `@fluidframework/id-compressor` instead.
+	 */
+	isStableId,
+} from "@fluidframework/id-compressor";

package/src/messageTypes.ts

@@ -8,14 +8,14 @@ import {
 	IEnvelope,
 	InboundAttachMessage,
 	IAttachMessage,
-	IdCreationRangeWithStashedState,
-	IdCreationRange,
 } from "@fluidframework/runtime-definitions";
+import type { IdCreationRange } from "@fluidframework/id-compressor";
 import { IDataStoreAliasMessage } from "./dataStore";
+import { GarbageCollectionMessage } from "./gc";
 import { IChunkedOp } from "./opLifecycle";
 
 /**
- * @public
+ * @internal
  */
 export enum ContainerMessageType {
 	// An op to be delivered to store
@@ -42,6 +42,12 @@ export enum ContainerMessageType {
 	 * See the [IdCompressor README](./id-compressor/README.md) for more details.
 	 */
 	IdAllocation = "idAllocation",
+
+	/**
+	 * Garbage collection specific op. This is sent by the summarizer client when GC runs. It's used to synchronize GC
+	 * state across all clients.
+	 */
+	GC = "GC",
 }
 
 /**
@@ -72,7 +78,8 @@ export interface IContainerRuntimeMessageCompatDetails {
  * IMPORTANT: when creating one to be serialized, set the properties in the order they appear here.
  * This way stringified values can be compared.
  */
-interface TypedContainerRuntimeMessage<TType extends ContainerMessageType, TContents> {
+interface TypedContainerRuntimeMessage<TType extends ContainerMessageType, TContents>
+	extends Partial<RecentlyAddedContainerRuntimeMessageDetails> {
 	/** Type of the op, within the ContainerRuntime's domain */
 	type: TType;
 	/** Domain-specific contents, interpreted according to the type */
@@ -116,13 +123,13 @@ export type ContainerRuntimeAliasMessage = TypedContainerRuntimeMessage<
 	ContainerMessageType.Alias,
 	IDataStoreAliasMessage
 >;
-export type LocalContainerRuntimeIdAllocationMessage = TypedContainerRuntimeMessage<
-	ContainerMessageType.IdAllocation,
-	IdCreationRangeWithStashedState
->;
 export type ContainerRuntimeIdAllocationMessage = TypedContainerRuntimeMessage<
 	ContainerMessageType.IdAllocation,
-	IdCreationRange & { stashedState?: never }
+	IdCreationRange
+>;
+export type ContainerRuntimeGCMessage = TypedContainerRuntimeMessage<
+	ContainerMessageType.GC,
+	GarbageCollectionMessage
 >;
 
 /**
@@ -152,6 +159,7 @@ export type InboundContainerRuntimeMessage =
 	| ContainerRuntimeRejoinMessage
 	| ContainerRuntimeAliasMessage
 	| ContainerRuntimeIdAllocationMessage
+	| ContainerRuntimeGCMessage
 	// Inbound messages may include unknown types from other clients, so we include that as a special case here
 	| UnknownContainerRuntimeMessage;
 
@@ -163,7 +171,8 @@ export type LocalContainerRuntimeMessage =
 	| ContainerRuntimeBlobAttachMessage
 	| ContainerRuntimeRejoinMessage
 	| ContainerRuntimeAliasMessage
-	| LocalContainerRuntimeIdAllocationMessage
+	| ContainerRuntimeIdAllocationMessage
+	| ContainerRuntimeGCMessage
 	// In rare cases (e.g. related to stashed ops) we could have a local message of an unknown type
 	| UnknownContainerRuntimeMessage;
 
@@ -175,7 +184,8 @@ export type OutboundContainerRuntimeMessage =
 	| ContainerRuntimeBlobAttachMessage
 	| ContainerRuntimeRejoinMessage
 	| ContainerRuntimeAliasMessage
-	| ContainerRuntimeIdAllocationMessage;
+	| ContainerRuntimeIdAllocationMessage
+	| ContainerRuntimeGCMessage;
 
 /**
  * An unpacked ISequencedDocumentMessage with the inner TypedContainerRuntimeMessage type/contents/etc

package/src/metadata.ts

@@ -17,3 +17,10 @@ export interface IBlobMetadata {
 	blobId?: string;
 	localId?: string;
 }
+
+/**
+ * The IdCompressor needs to know if this is a replayed savedOp as those need to be skipped in stashed ops scenarios.
+ */
+export interface IIdAllocationMetadata {
+	savedOp?: boolean;
+}

package/src/opLifecycle/definitions.ts

@@ -53,7 +53,7 @@ export interface IBatchCheckpoint {
 }
 
 /**
- * @public
+ * @internal
  */
 export interface IChunkedOp {
 	chunkId: number;

package/src/opLifecycle/opGroupingManager.ts

@@ -96,12 +96,21 @@ export class OpGroupingManager {
 	}
 
 	public ungroupOp(op: ISequencedDocumentMessage): ISequencedDocumentMessage[] {
+		let fakeCsn = 1;
 		if (!isGroupContents(op.contents)) {
+			// Align the worlds of what clientSequenceNumber represents when grouped batching is enabled
+			if (this.config.groupedBatchingEnabled) {
+				return [
+					{
+						...op,
+						clientSequenceNumber: fakeCsn,
+					},
+				];
+			}
 			return [op];
 		}
 
 		const messages = op.contents.contents;
-		let fakeCsn = 1;
 		return messages.map((subMessage) => ({
 			...op,
 			clientSequenceNumber: fakeCsn++,

package/src/opLifecycle/outbox.ts

@@ -89,6 +89,7 @@ export class Outbox {
 	private readonly attachFlowBatch: BatchManager;
 	private readonly mainBatch: BatchManager;
 	private readonly blobAttachBatch: BatchManager;
+	private readonly idAllocationBatch: BatchManager;
 	private readonly defaultAttachFlowSoftLimitInBytes = 320 * 1024;
 	private batchRebasesToReport = 5;
 	private rebasing = false;
@@ -114,6 +115,7 @@ export class Outbox {
 		this.attachFlowBatch = new BatchManager({ hardLimit, softLimit });
 		this.mainBatch = new BatchManager({ hardLimit });
 		this.blobAttachBatch = new BatchManager({ hardLimit });
+		this.idAllocationBatch = new BatchManager({ hardLimit });
 	}
 
 	public get messageCount(): number {
@@ -230,6 +232,37 @@ export class Outbox {
 		}
 	}
 
+	public submitIdAllocation(message: BatchMessage) {
+		this.maybeFlushPartialBatch();
+
+		if (
+			!this.idAllocationBatch.push(
+				message,
+				this.isContextReentrant(),
+				this.params.getCurrentSequenceNumbers().clientSequenceNumber,
+			)
+		) {
+			// BatchManager has two limits - soft limit & hard limit. Soft limit is only engaged
+			// when queue is not empty.
+			// Flush queue & retry. Failure on retry would mean - single message is bigger than hard limit
+			this.flushInternal(this.idAllocationBatch);
+
+			this.addMessageToBatchManager(this.idAllocationBatch, message);
+		}
+
+		// If compression is enabled, we will always successfully receive
+		// attach ops and compress then send them at the next JS turn, regardless
+		// of the overall size of the accumulated ops in the batch.
+		// However, it is more efficient to flush these ops faster, preferably
+		// after they reach a size which would benefit from compression.
+		if (
+			this.idAllocationBatch.contentSizeInBytes >=
+			this.params.config.compressionOptions.minimumBatchSizeInBytes
+		) {
+			this.flushInternal(this.idAllocationBatch);
+		}
+	}
+
 	private addMessageToBatchManager(batchManager: BatchManager, message: BatchMessage) {
 		if (
 			!batchManager.push(
@@ -258,6 +291,7 @@ export class Outbox {
 	}
 
 	private flushAll() {
+		this.flushInternal(this.idAllocationBatch);
 		this.flushInternal(this.attachFlowBatch);
 		this.flushInternal(this.blobAttachBatch, true /* disableGroupedBatching */);
 		this.flushInternal(this.mainBatch);

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-runtime";
-export const pkgVersion = "2.0.0-internal.7.2.2";
+export const pkgVersion = "2.0.0-internal.7.4.0";

package/src/pendingStateManager.ts

@@ -11,7 +11,7 @@ import { ICriticalContainerError } from "@fluidframework/container-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { DataProcessingError, ITelemetryLoggerExt } from "@fluidframework/telemetry-utils";
 
-import { ContainerMessageType, InboundSequencedContainerRuntimeMessage } from "./messageTypes";
+import { InboundSequencedContainerRuntimeMessage } from "./messageTypes";
 import { pkgVersion } from "./packageVersion";
 import { IBatchMetadata } from "./metadata";
 
@@ -21,7 +21,6 @@ import { IBatchMetadata } from "./metadata";
  */
 export interface IPendingMessage {
 	type: "message";
-	clientSequenceNumber: number;
 	referenceSequenceNumber: number;
 	content: string;
 	localOpMetadata: unknown;
@@ -128,18 +127,9 @@ export class PendingStateManager implements IDisposable {
 			return {
 				pendingStates: [...this.savedOps, ...this.pendingMessages.toArray()].map(
 					(message) => {
-						let content = message.content;
-						const parsedContent = JSON.parse(content);
-						// IdAllocations need their localOpMetadata stashed in the contents
-						// of the op to correctly resume the session when processing stashed ops
-						if (parsedContent.type === ContainerMessageType.IdAllocation) {
-							parsedContent.contents.stashedState = message.localOpMetadata;
-							content = JSON.stringify(parsedContent);
-						}
-
 						// delete localOpMetadata since it may not be serializable
 						// and will be regenerated by applyStashedOp()
-						return { ...message, content, localOpMetadata: undefined };
+						return { ...message, localOpMetadata: undefined };
 					},
 				),
 			};
@@ -176,7 +166,6 @@ export class PendingStateManager implements IDisposable {
 	) {
 		const pendingMessage: IPendingMessage = {
 			type: "message",
-			clientSequenceNumber: -1, // dummy value (not to be used anywhere)
 			referenceSequenceNumber,
 			content,
 			localOpMetadata,
@@ -342,6 +331,7 @@ export class PendingStateManager implements IDisposable {
 	/**
 	 * Called when the Container's connection state changes. If the Container gets connected, it replays all the pending
 	 * states in its queue. This includes triggering resubmission of unacked ops.
+	 * ! Note: successfully resubmitting an op that has been successfully sequenced is not possible due to checks in the ConnectionStateHandler (Loader layer)
 	 */
 	public replayPendingStates() {
 		assert(

package/src/summary/orderedClientElection.ts

@@ -227,7 +227,7 @@ export interface IOrderedClientElectionEvents extends IEvent {
 
 /**
  * Serialized state of IOrderedClientElection.
- * @public
+ * @alpha
  */
 export interface ISerializedElection {
 	/** Sequence number at the time of the latest election. */

package/src/summary/runWhileConnectedCoordinator.ts

@@ -12,7 +12,7 @@ import {
 
 /**
  * Similar to AbortController, but using promise instead of events
- * @public
+ * @internal
  */
 export interface ICancellableSummarizerController extends ISummaryCancellationToken {
 	stop(reason: SummarizerStopReason): void;
@@ -21,7 +21,7 @@ export interface ICancellableSummarizerController extends ISummaryCancellationTo
 /**
  * Can be useful in testing as well as in places where caller does not use cancellation.
  * This object implements ISummaryCancellationToken interface but cancellation is never leveraged.
- * @public
+ * @internal
  */
 export const neverCancelledSummaryToken: ISummaryCancellationToken = {
 	cancelled: false,

package/src/summary/summarizer.ts

@@ -69,7 +69,7 @@ export const createSummarizingWarning = (errorMessage: string, logged: boolean)
  * Summarizer is responsible for coordinating when to generate and send summaries.
  * It is the main entry point for summary work.
  * It is created only by summarizing container (i.e. one with clientType === "summarizer")
- * @public
+ * @internal
  */
 export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements ISummarizer {
 	public get ISummarizer() {