@fluidframework/container-definitions 2.0.0-dev.6.4.0.192049 → 2.0.0-dev.7.2.0.204906

package/CHANGELOG.md

@@ -1,5 +1,97 @@
 # @fluidframework/container-definitions
 
+## 2.0.0-internal.7.1.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.0.0
+
+### Major Changes
+
+-   odsp-driver: Load container in readonly mode when driver throws DriverErrorType.outOfStorage [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    Handle DriverErrorType.outOfStorage error from driver and load the container in readonly mode. Currently there is no
+    handling and when the join session throws this error, the container will get closed. With this we use NoDeltaStream
+    object as connection and load the container in read mode, so that it loads properly. We also notify the that the
+    container is "readonly" through the event on delta manager so that apps can listen to this and show any UX etc. The app
+    can listen to the event like this:
+
+    ```ts
+    container.deltaManager.on(
+    	"readonly",
+    	(readonly?: boolean, readonlyConnectionReason?: { text: string; error?: IErrorBase }) => {
+    		// error?.errorType will be equal to DriverErrorType.outOfStorage in this case
+    		// App logic
+    	},
+    );
+    ```
+
+-   Dependencies on @fluidframework/protocol-definitions package updated to 3.0.0 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    This included the following changes from the protocol-definitions release:
+
+    -   Updating signal interfaces for some planned improvements. The intention is split the interface between signals
+        submitted by clients to the server and the resulting signals sent from the server to clients.
+        -   A new optional type member is available on the ISignalMessage interface and a new ISentSignalMessage interface has
+            been added, which will be the typing for signals sent from the client to the server. Both extend a new
+            ISignalMessageBase interface that contains common members.
+    -   The @fluidframework/common-definitions package dependency has been updated to version 1.0.0.
+
+-   container-definitions: IContainer's and IDataStore's IFluidRouter capabilities are deprecated [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    `IFluidRouter` and `request({ url: "/" })` on `IContainer` and `IDataStore` are deprecated and will be removed in a future major release. Please migrate all usage to the appropriate `getEntryPoint()` or `entryPoint` APIs.
+
+    See [Removing-IFluidRouter.md](https://github.com/microsoft/FluidFramework/blob/main/packages/common/core-interfaces/Removing-IFluidRouter.md) for more details.
+
+-   Server upgrade: dependencies on Fluid server packages updated to 2.0.1 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    Dependencies on the following Fluid server package have been updated to version 2.0.1:
+
+    -   @fluidframework/gitresources: 2.0.1
+    -   @fluidframework/server-kafka-orderer: 2.0.1
+    -   @fluidframework/server-lambdas: 2.0.1
+    -   @fluidframework/server-lambdas-driver: 2.0.1
+    -   @fluidframework/server-local-server: 2.0.1
+    -   @fluidframework/server-memory-orderer: 2.0.1
+    -   @fluidframework/protocol-base: 2.0.1
+    -   @fluidframework/server-routerlicious: 2.0.1
+    -   @fluidframework/server-routerlicious-base: 2.0.1
+    -   @fluidframework/server-services: 2.0.1
+    -   @fluidframework/server-services-client: 2.0.1
+    -   @fluidframework/server-services-core: 2.0.1
+    -   @fluidframework/server-services-ordering-kafkanode: 2.0.1
+    -   @fluidframework/server-services-ordering-rdkafka: 2.0.1
+    -   @fluidframework/server-services-ordering-zookeeper: 2.0.1
+    -   @fluidframework/server-services-shared: 2.0.1
+    -   @fluidframework/server-services-telemetry: 2.0.1
+    -   @fluidframework/server-services-utils: 2.0.1
+    -   @fluidframework/server-test-utils: 2.0.1
+    -   tinylicious: 2.0.1
+
+-   test-utils: provideEntryPoint is required [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    The optional `provideEntryPoint` method has become required on a number of constructors. A value will need to be provided to the following classes:
+
+    -   `BaseContainerRuntimeFactory`
+    -   `RuntimeFactory`
+    -   `ContainerRuntime` (constructor and `loadRuntime`)
+    -   `FluidDataStoreRuntime`
+
+    See [testContainerRuntimeFactoryWithDefaultDataStore.ts](https://github.com/microsoft/FluidFramework/tree/main/packages/test/test-utils/src/testContainerRuntimeFactoryWithDefaultDataStore.ts) for an example implemtation of `provideEntryPoint` for ContainerRuntime.
+    See [pureDataObjectFactory.ts](https://github.com/microsoft/FluidFramework/tree/main/packages/framework/aqueduct/src/data-object-factories/pureDataObjectFactory.ts#L83) for an example implementation of `provideEntryPoint` for DataStoreRuntime.
+
+    Subsequently, various `entryPoint` and `getEntryPoint()` endpoints have become required. Please see [containerRuntime.ts](https://github.com/microsoft/FluidFramework/tree/main/packages/runtime/container-runtime/src/containerRuntime.ts) for example implementations of these APIs.
+
+    For more details, see [Removing-IFluidRouter.md](https://github.com/microsoft/FluidFramework/blob/main/packages/common/core-interfaces/Removing-IFluidRouter.md)
+
+-   Minimum TypeScript version now 5.1.6 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    The minimum supported TypeScript version for Fluid 2.0 clients is now 5.1.6.
+
+## 2.0.0-internal.6.4.0
+
+Dependency updates only.
+
 ## 2.0.0-internal.6.3.0
 
 Dependency updates only.

package/api-extractor.json

@@ -1,4 +1,4 @@
 {
 	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "@fluidframework/build-common/api-extractor-common-strict.json"
+	"extends": "@fluidframework/build-common/api-extractor-base.json"
 }

package/api-report/container-definitions.api.md

@@ -0,0 +1,538 @@
+## API Report File for "@fluidframework/container-definitions"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { EventEmitter } from 'events';
+import { FluidObject } from '@fluidframework/core-interfaces';
+import { IAnyDriverError } from '@fluidframework/driver-definitions';
+import { IClient } from '@fluidframework/protocol-definitions';
+import { IClientConfiguration } from '@fluidframework/protocol-definitions';
+import { IClientDetails } from '@fluidframework/protocol-definitions';
+import { IDisposable } from '@fluidframework/core-interfaces';
+import { IDocumentMessage } from '@fluidframework/protocol-definitions';
+import { IDocumentStorageService } from '@fluidframework/driver-definitions';
+import { IErrorBase } from '@fluidframework/core-interfaces';
+import { IErrorEvent } from '@fluidframework/core-interfaces';
+import { IEvent } from '@fluidframework/core-interfaces';
+import { IEventProvider } from '@fluidframework/core-interfaces';
+import { IFluidRouter } from '@fluidframework/core-interfaces';
+import { IGenericError } from '@fluidframework/core-interfaces';
+import { IQuorumClients } from '@fluidframework/protocol-definitions';
+import { IRequest } from '@fluidframework/core-interfaces';
+import { IResolvedUrl } from '@fluidframework/driver-definitions';
+import { IResponse } from '@fluidframework/core-interfaces';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISequencedProposal } from '@fluidframework/protocol-definitions';
+import { ISignalMessage } from '@fluidframework/protocol-definitions';
+import { ISnapshotTree } from '@fluidframework/protocol-definitions';
+import { ISummaryContent } from '@fluidframework/protocol-definitions';
+import { ISummaryTree } from '@fluidframework/protocol-definitions';
+import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import { IThrottlingWarning } from '@fluidframework/core-interfaces';
+import { ITokenClaims } from '@fluidframework/protocol-definitions';
+import { IUsageError } from '@fluidframework/core-interfaces';
+import { IVersion } from '@fluidframework/protocol-definitions';
+import { MessageType } from '@fluidframework/protocol-definitions';
+
+// @public
+export enum AttachState {
+    Attached = "Attached",
+    Attaching = "Attaching",
+    Detached = "Detached"
+}
+
+// @public
+export namespace ConnectionState {
+    export type CatchingUp = 1;
+    export type Connected = 2;
+    export type Disconnected = 0;
+    export type EstablishingConnection = 3;
+}
+
+// @public
+export type ConnectionState = ConnectionState.Disconnected | ConnectionState.EstablishingConnection | ConnectionState.CatchingUp | ConnectionState.Connected;
+
+// @public @deprecated
+export enum ContainerErrorType {
+    clientSessionExpiredError = "clientSessionExpiredError",
+    dataCorruptionError = "dataCorruptionError",
+    dataProcessingError = "dataProcessingError",
+    genericError = "genericError",
+    throttlingError = "throttlingError",
+    usageError = "usageError"
+}
+
+// @public
+export const ContainerErrorTypes: {
+    readonly clientSessionExpiredError: "clientSessionExpiredError";
+    readonly genericError: "genericError";
+    readonly throttlingError: "throttlingError";
+    readonly dataCorruptionError: "dataCorruptionError";
+    readonly dataProcessingError: "dataProcessingError";
+    readonly usageError: "usageError";
+};
+
+// @public (undocumented)
+export type ContainerErrorTypes = (typeof ContainerErrorTypes)[keyof typeof ContainerErrorTypes];
+
+// @public
+export interface ContainerWarning extends IErrorBase {
+    logged?: boolean;
+}
+
+// @public
+export interface IAudience extends EventEmitter {
+    getMember(clientId: string): IClient | undefined;
+    getMembers(): Map<string, IClient>;
+    on(event: "addMember" | "removeMember", listener: (clientId: string, client: IClient) => void): this;
+}
+
+// @public
+export interface IAudienceOwner extends IAudience {
+    addMember(clientId: string, details: IClient): void;
+    removeMember(clientId: string): boolean;
+}
+
+// @public
+export interface IBatchMessage {
+    // (undocumented)
+    compression?: string;
+    // (undocumented)
+    contents?: string;
+    // (undocumented)
+    metadata: Record<string, unknown> | undefined;
+    // (undocumented)
+    referenceSequenceNumber?: number;
+}
+
+// @public
+export interface ICodeDetailsLoader extends Partial<IProvideFluidCodeDetailsComparer> {
+    load(source: IFluidCodeDetails): Promise<IFluidModuleWithDetails>;
+}
+
+// @public
+export interface IConnectionDetails {
+    checkpointSequenceNumber: number | undefined;
+    // (undocumented)
+    claims: ITokenClaims;
+    // (undocumented)
+    clientId: string;
+    // (undocumented)
+    serviceConfiguration: IClientConfiguration;
+}
+
+// @public
+export interface IContainer extends IEventProvider<IContainerEvents>, IFluidRouter {
+    attach(request: IRequest, attachProps?: {
+        deltaConnection?: "none" | "delayed";
+    }): Promise<void>;
+    readonly attachState: AttachState;
+    readonly audience: IAudience;
+    readonly clientId?: string | undefined;
+    close(error?: ICriticalContainerError): void;
+    readonly closed: boolean;
+    connect(): void;
+    readonly connectionState: ConnectionState;
+    deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    disconnect(): void;
+    dispose(error?: ICriticalContainerError): void;
+    readonly disposed?: boolean;
+    // @alpha
+    forceReadonly?(readonly: boolean): any;
+    getAbsoluteUrl(relativeUrl: string): Promise<string | undefined>;
+    getEntryPoint(): Promise<FluidObject | undefined>;
+    getLoadedCodeDetails(): IFluidCodeDetails | undefined;
+    getQuorum(): IQuorumClients;
+    getSpecifiedCodeDetails(): IFluidCodeDetails | undefined;
+    // @deprecated (undocumented)
+    readonly IFluidRouter: IFluidRouter;
+    readonly isDirty: boolean;
+    proposeCodeDetails(codeDetails: IFluidCodeDetails): Promise<boolean>;
+    readonly readOnlyInfo: ReadOnlyInfo;
+    // @deprecated (undocumented)
+    request(request: {
+        url: "/";
+        headers?: undefined;
+    }): Promise<IResponse>;
+    // @deprecated
+    request(request: IRequest): Promise<IResponse>;
+    resolvedUrl: IResolvedUrl | undefined;
+    serialize(): string;
+}
+
+// @public
+export interface IContainerContext {
+    readonly attachState: AttachState;
+    // (undocumented)
+    readonly audience: IAudience | undefined;
+    // (undocumented)
+    readonly baseSnapshot: ISnapshotTree | undefined;
+    // (undocumented)
+    readonly clientDetails: IClientDetails;
+    // (undocumented)
+    readonly clientId: string | undefined;
+    // (undocumented)
+    readonly closeFn: (error?: ICriticalContainerError) => void;
+    // (undocumented)
+    readonly connected: boolean;
+    // (undocumented)
+    readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    // (undocumented)
+    readonly disposeFn?: (error?: ICriticalContainerError) => void;
+    getAbsoluteUrl?(relativeUrl: string): Promise<string | undefined>;
+    // (undocumented)
+    getLoadedFromVersion(): IVersion | undefined;
+    // @deprecated (undocumented)
+    getSpecifiedCodeDetails?(): IFluidCodeDetails | undefined;
+    // @deprecated
+    readonly id: string;
+    // (undocumented)
+    readonly loader: ILoader;
+    // (undocumented)
+    readonly options: ILoaderOptions;
+    // (undocumented)
+    pendingLocalState?: unknown;
+    // (undocumented)
+    readonly quorum: IQuorumClients;
+    readonly scope: FluidObject;
+    // (undocumented)
+    readonly storage: IDocumentStorageService;
+    // (undocumented)
+    readonly submitBatchFn: (batch: IBatchMessage[], referenceSequenceNumber?: number) => number;
+    // @deprecated (undocumented)
+    readonly submitFn: (type: MessageType, contents: any, batch: boolean, appData?: any) => number;
+    // (undocumented)
+    readonly submitSignalFn: (contents: any) => void;
+    // (undocumented)
+    readonly submitSummaryFn: (summaryOp: ISummaryContent, referenceSequenceNumber?: number) => number;
+    // (undocumented)
+    readonly supportedFeatures?: ReadonlyMap<string, unknown>;
+    // (undocumented)
+    readonly taggedLogger: ITelemetryBaseLogger;
+    // (undocumented)
+    updateDirtyContainerState(dirty: boolean): void;
+}
+
+// @public
+export interface IContainerEvents extends IEvent {
+    (event: "readonly", listener: (readonly: boolean) => void): void;
+    (event: "connected", listener: (clientId: string) => void): any;
+    (event: "codeDetailsProposed", listener: (codeDetails: IFluidCodeDetails, proposal: ISequencedProposal) => void): any;
+    (event: "disconnected", listener: () => void): any;
+    (event: "attaching", listener: () => void): any;
+    (event: "attached", listener: () => void): any;
+    (event: "closed", listener: (error?: ICriticalContainerError) => void): any;
+    (event: "disposed", listener: (error?: ICriticalContainerError) => void): any;
+    (event: "warning", listener: (error: ContainerWarning) => void): any;
+    (event: "op", listener: (message: ISequencedDocumentMessage) => void): any;
+    (event: "dirty", listener: (dirty: boolean) => void): any;
+    (event: "saved", listener: (dirty: boolean) => void): any;
+}
+
+// @public (undocumented)
+export interface IContainerLoadMode {
+    // (undocumented)
+    deltaConnection?: "none" | "delayed" | undefined;
+    // (undocumented)
+    opsBeforeReturn?: undefined | "sequenceNumber" | "cached" | "all";
+    pauseAfterLoad?: boolean;
+}
+
+// @public
+export type ICriticalContainerError = IErrorBase;
+
+// @public
+export interface IDeltaManager<T, U> extends IEventProvider<IDeltaManagerEvents>, IDeltaSender {
+    readonly active: boolean;
+    readonly clientDetails: IClientDetails;
+    readonly hasCheckpointSequenceNumber: boolean;
+    readonly inbound: IDeltaQueue<T>;
+    readonly inboundSignal: IDeltaQueue<ISignalMessage>;
+    readonly initialSequenceNumber: number;
+    readonly lastKnownSeqNumber: number;
+    readonly lastMessage: ISequencedDocumentMessage | undefined;
+    readonly lastSequenceNumber: number;
+    readonly maxMessageSize: number;
+    readonly minimumSequenceNumber: number;
+    readonly outbound: IDeltaQueue<U[]>;
+    // (undocumented)
+    readonly readOnlyInfo: ReadOnlyInfo;
+    readonly serviceConfiguration: IClientConfiguration | undefined;
+    submitSignal(content: any): void;
+    readonly version: string;
+}
+
+// @public
+export interface IDeltaManagerEvents extends IEvent {
+    // @deprecated (undocumented)
+    (event: "prepareSend", listener: (messageBuffer: any[]) => void): any;
+    // @deprecated (undocumented)
+    (event: "submitOp", listener: (message: IDocumentMessage) => void): any;
+    (event: "op", listener: (message: ISequencedDocumentMessage, processingTime: number) => void): any;
+    (event: "pong", listener: (latency: number) => void): any;
+    (event: "connect", listener: (details: IConnectionDetails, opsBehind?: number) => void): any;
+    (event: "disconnect", listener: (reason: string, error?: IAnyDriverError) => void): any;
+    (event: "readonly", listener: (readonly: boolean, readonlyConnectionReason?: {
+        reason: string;
+        error?: IErrorBase;
+    }) => void): any;
+}
+
+// @public
+export interface IDeltaQueue<T> extends IEventProvider<IDeltaQueueEvents<T>>, IDisposable {
+    idle: boolean;
+    length: number;
+    pause(): Promise<void>;
+    paused: boolean;
+    peek(): T | undefined;
+    resume(): void;
+    toArray(): T[];
+    waitTillProcessingDone(): Promise<{
+        count: number;
+        duration: number;
+    }>;
+}
+
+// @public
+export interface IDeltaQueueEvents<T> extends IErrorEvent {
+    (event: "push", listener: (task: T) => void): any;
+    (event: "op", listener: (task: T) => void): any;
+    (event: "idle", listener: (count: number, duration: number) => void): any;
+}
+
+// @public
+export interface IDeltaSender {
+    flush(): void;
+}
+
+export { IErrorBase }
+
+// @public
+export interface IFluidBrowserPackage extends IFluidPackage {
+    // (undocumented)
+    fluid: {
+        browser: IFluidBrowserPackageEnvironment;
+        [environment: string]: IFluidPackageEnvironment;
+    };
+}
+
+// @public
+export interface IFluidBrowserPackageEnvironment extends IFluidPackageEnvironment {
+    umd: {
+        files: string[];
+        library: string;
+    };
+}
+
+// @public
+export interface IFluidCodeDetails {
+    readonly config?: IFluidCodeDetailsConfig;
+    readonly package: string | Readonly<IFluidPackage>;
+}
+
+// @public (undocumented)
+export const IFluidCodeDetailsComparer: keyof IProvideFluidCodeDetailsComparer;
+
+// @public
+export interface IFluidCodeDetailsComparer extends IProvideFluidCodeDetailsComparer {
+    compare(a: IFluidCodeDetails, b: IFluidCodeDetails): Promise<number | undefined>;
+    satisfies(candidate: IFluidCodeDetails, constraint: IFluidCodeDetails): Promise<boolean>;
+}
+
+// @public
+export interface IFluidCodeDetailsConfig {
+    // (undocumented)
+    readonly [key: string]: string;
+}
+
+// @public
+export interface IFluidCodeResolver {
+    resolveCodeDetails(details: IFluidCodeDetails): Promise<IResolvedFluidCodeDetails>;
+}
+
+// @public (undocumented)
+export interface IFluidModule {
+    // (undocumented)
+    fluidExport: FluidObject<IRuntimeFactory & IProvideFluidCodeDetailsComparer>;
+}
+
+// @public
+export interface IFluidModuleWithDetails {
+    details: IFluidCodeDetails;
+    module: IFluidModule;
+}
+
+// @public
+export interface IFluidPackage {
+    [key: string]: unknown;
+    fluid: {
+        [environment: string]: undefined | IFluidPackageEnvironment;
+    };
+    name: string;
+}
+
+// @public
+export interface IFluidPackageEnvironment {
+    [target: string]: undefined | {
+        files: string[];
+        [key: string]: unknown;
+    };
+}
+
+export { IGenericError }
+
+// @public
+export interface IHostLoader extends ILoader {
+    createDetachedContainer(codeDetails: IFluidCodeDetails, createDetachedProps?: {
+        canReconnect?: boolean;
+        clientDetailsOverride?: IClientDetails;
+    }): Promise<IContainer>;
+    rehydrateDetachedContainerFromSnapshot(snapshot: string, createDetachedProps?: {
+        canReconnect?: boolean;
+        clientDetailsOverride?: IClientDetails;
+    }): Promise<IContainer>;
+}
+
+// @public
+export interface ILoader extends Partial<IProvideLoader> {
+    // @deprecated (undocumented)
+    readonly IFluidRouter: IFluidRouter;
+    // @deprecated (undocumented)
+    request(request: IRequest): Promise<IResponse>;
+    resolve(request: IRequest, pendingLocalState?: string): Promise<IContainer>;
+}
+
+// @public
+export interface ILoaderHeader {
+    // @deprecated (undocumented)
+    [LoaderHeader.cache]: boolean;
+    // (undocumented)
+    [LoaderHeader.clientDetails]: IClientDetails;
+    // (undocumented)
+    [LoaderHeader.reconnect]: boolean;
+    [LoaderHeader.sequenceNumber]: number;
+    // (undocumented)
+    [LoaderHeader.loadMode]: IContainerLoadMode;
+    // (undocumented)
+    [LoaderHeader.version]: string | undefined;
+}
+
+// @public (undocumented)
+export type ILoaderOptions = {
+    [key in string | number]: any;
+} & {
+    cache?: boolean;
+    provideScopeLoader?: boolean;
+    maxClientLeaveWaitTime?: number;
+};
+
+// @public @deprecated (undocumented)
+export interface IPendingLocalState {
+    // (undocumented)
+    pendingRuntimeState: unknown;
+    // (undocumented)
+    url: string;
+}
+
+// @public (undocumented)
+export interface IProvideFluidCodeDetailsComparer {
+    // (undocumented)
+    readonly IFluidCodeDetailsComparer: IFluidCodeDetailsComparer;
+}
+
+// @public (undocumented)
+export interface IProvideLoader {
+    // (undocumented)
+    readonly ILoader: ILoader;
+}
+
+// @public (undocumented)
+export interface IProvideRuntimeFactory {
+    // (undocumented)
+    readonly IRuntimeFactory: IRuntimeFactory;
+}
+
+// @public
+export interface IResolvedFluidCodeDetails extends IFluidCodeDetails {
+    readonly resolvedPackage: Readonly<IFluidPackage>;
+    readonly resolvedPackageCacheId: string | undefined;
+}
+
+// @public
+export interface IRuntime extends IDisposable {
+    createSummary(blobRedirectTable?: Map<string, string>): ISummaryTree;
+    getEntryPoint(): Promise<FluidObject | undefined>;
+    getPendingLocalState(props?: {
+        notifyImminentClosure?: boolean;
+    }): unknown;
+    // @deprecated
+    notifyAttaching(snapshot: ISnapshotTreeWithBlobContents): void;
+    notifyOpReplay?(message: ISequencedDocumentMessage): Promise<void>;
+    process(message: ISequencedDocumentMessage, local: boolean): any;
+    processSignal(message: any, local: boolean): any;
+    // @deprecated
+    request(request: IRequest): Promise<IResponse>;
+    setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
+    setConnectionState(connected: boolean, clientId?: string): any;
+}
+
+// @public (undocumented)
+export const IRuntimeFactory: keyof IProvideRuntimeFactory;
+
+// @public
+export interface IRuntimeFactory extends IProvideRuntimeFactory {
+    instantiateRuntime(context: IContainerContext, existing: boolean): Promise<IRuntime>;
+}
+
+// @public
+export const isFluidBrowserPackage: (maybePkg: unknown) => maybePkg is Readonly<IFluidBrowserPackage>;
+
+// @public
+export const isFluidCodeDetails: (details: unknown) => details is Readonly<IFluidCodeDetails>;
+
+// @public
+export const isFluidPackage: (pkg: unknown) => pkg is Readonly<IFluidPackage>;
+
+// @public
+export interface ISnapshotTreeWithBlobContents extends ISnapshotTree {
+    // (undocumented)
+    blobsContents: {
+        [path: string]: ArrayBufferLike;
+    };
+    // (undocumented)
+    trees: {
+        [path: string]: ISnapshotTreeWithBlobContents;
+    };
+}
+
+export { IThrottlingWarning }
+
+export { IUsageError }
+
+// @public
+export enum LoaderHeader {
+    // @deprecated (undocumented)
+    cache = "fluid-cache",
+    // (undocumented)
+    clientDetails = "fluid-client-details",
+    loadMode = "loadMode",
+    // (undocumented)
+    reconnect = "fluid-reconnect",
+    sequenceNumber = "fluid-sequence-number",
+    version = "version"
+}
+
+// @public (undocumented)
+export type ReadOnlyInfo = {
+    readonly readonly: false | undefined;
+} | {
+    readonly readonly: true;
+    readonly forced: boolean;
+    readonly permissions: boolean | undefined;
+    readonly storageOnly: boolean;
+    readonly storageOnlyReason?: string;
+};
+
+```

package/dist/audience.d.ts

@@ -6,6 +6,7 @@ import { EventEmitter } from "events";
 import { IClient } from "@fluidframework/protocol-definitions";
 /**
  * Manages the state and the members for {@link IAudience}
+ * @public
  */
 export interface IAudienceOwner extends IAudience {
     /**
@@ -23,6 +24,7 @@ export interface IAudienceOwner extends IAudience {
  *
  * See {@link https://nodejs.org/api/events.html#class-eventemitter | here} for an overview of the `EventEmitter`
  * class.
+ * @public
  */
 export interface IAudience extends EventEmitter {
     /**

package/dist/audience.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"audience.d.ts","sourceRoot":"","sources":["../src/audience.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAC;AAE/D;;GAEG;AACH,MAAM,WAAW,cAAe,SAAQ,SAAS;IAChD;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAEpD;;;OAGG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;CACxC;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAU,SAAQ,YAAY;IAC9C;;OAEG;IACH,EAAE,CACD,KAAK,EAAE,WAAW,GAAG,cAAc,EACnC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,GACnD,IAAI,CAAC;IAER;;OAEG;IACH,UAAU,IAAI,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEnC;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;CACjD"}
+{"version":3,"file":"audience.d.ts","sourceRoot":"","sources":["../src/audience.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAC;AAE/D;;;GAGG;AACH,MAAM,WAAW,cAAe,SAAQ,SAAS;IAChD;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAEpD;;;OAGG;IACH,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;CACxC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAU,SAAQ,YAAY;IAC9C;;OAEG;IACH,EAAE,CACD,KAAK,EAAE,WAAW,GAAG,cAAc,EACnC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,GACnD,IAAI,CAAC;IAER;;OAEG;IACH,UAAU,IAAI,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEnC;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;CACjD"}

package/dist/audience.js.map

@@ -1 +1 @@
-{"version":3,"file":"audience.js","sourceRoot":"","sources":["../src/audience.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { EventEmitter } from \"events\";\nimport { IClient } from \"@fluidframework/protocol-definitions\";\n\n/**\n * Manages the state and the members for {@link IAudience}\n */\nexport interface IAudienceOwner extends IAudience {\n\t/**\n\t * Adds a new client to the audience\n\t */\n\taddMember(clientId: string, details: IClient): void;\n\n\t/**\n\t * Removes a client from the audience. Only emits an event if a client is actually removed\n\t * @returns if a client was removed from the audience\n\t */\n\tremoveMember(clientId: string): boolean;\n}\n\n/**\n * Audience represents all clients connected to the op stream, both read-only and read/write.\n *\n * See {@link https://nodejs.org/api/events.html#class-eventemitter | here} for an overview of the `EventEmitter`\n * class.\n */\nexport interface IAudience extends EventEmitter {\n\t/**\n\t * See {@link https://nodejs.dev/learn/the-nodejs-event-emitter | here} for an overview of `EventEmitter.on`.\n\t */\n\ton(\n\t\tevent: \"addMember\" | \"removeMember\",\n\t\tlistener: (clientId: string, client: IClient) => void,\n\t): this;\n\n\t/**\n\t * List all clients connected to the op stream, keyed off their clientId\n\t */\n\tgetMembers(): Map<string, IClient>;\n\n\t/**\n\t * Get details about the connected client with the specified clientId,\n\t * or undefined if the specified client isn't connected\n\t */\n\tgetMember(clientId: string): IClient | undefined;\n}\n"]}
+{"version":3,"file":"audience.js","sourceRoot":"","sources":["../src/audience.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// False positive: this is an import from the `events` package, not from Node.\n// eslint-disable-next-line unicorn/prefer-node-protocol\nimport { EventEmitter } from \"events\";\nimport { IClient } from \"@fluidframework/protocol-definitions\";\n\n/**\n * Manages the state and the members for {@link IAudience}\n * @public\n */\nexport interface IAudienceOwner extends IAudience {\n\t/**\n\t * Adds a new client to the audience\n\t */\n\taddMember(clientId: string, details: IClient): void;\n\n\t/**\n\t * Removes a client from the audience. Only emits an event if a client is actually removed\n\t * @returns if a client was removed from the audience\n\t */\n\tremoveMember(clientId: string): boolean;\n}\n\n/**\n * Audience represents all clients connected to the op stream, both read-only and read/write.\n *\n * See {@link https://nodejs.org/api/events.html#class-eventemitter | here} for an overview of the `EventEmitter`\n * class.\n * @public\n */\nexport interface IAudience extends EventEmitter {\n\t/**\n\t * See {@link https://nodejs.dev/learn/the-nodejs-event-emitter | here} for an overview of `EventEmitter.on`.\n\t */\n\ton(\n\t\tevent: \"addMember\" | \"removeMember\",\n\t\tlistener: (clientId: string, client: IClient) => void,\n\t): this;\n\n\t/**\n\t * List all clients connected to the op stream, keyed off their clientId\n\t */\n\tgetMembers(): Map<string, IClient>;\n\n\t/**\n\t * Get details about the connected client with the specified clientId,\n\t * or undefined if the specified client isn't connected\n\t */\n\tgetMember(clientId: string): IClient | undefined;\n}\n"]}