@fluidframework/container-loader 0.59.4000-71130 → 1.0.0

package/src/container.ts

@@ -25,7 +25,6 @@ import {
     ContainerWarning,
     AttachState,
     IThrottlingWarning,
-    IPendingLocalState,
     ReadOnlyInfo,
     IContainerLoadMode,
     IFluidCodeDetails,
@@ -64,6 +63,7 @@ import {
     IDocumentAttributes,
     IDocumentMessage,
     IProcessMessageResult,
+    IProtocolState,
     IQuorumClients,
     IQuorumProposals,
     ISequencedClient,
@@ -140,6 +140,10 @@ export interface IContainerConfig {
      * Client details provided in the override will be merged over the default client.
      */
     clientDetailsOverride?: IClientDetails;
+    /**
+     * Serialized state from a previous instance of this container
+     */
+    serializedContainerState?: IPendingContainerState;
 }
 
 /**
@@ -147,7 +151,7 @@ export interface IContainerConfig {
  * Useful when resolving URIs and hitting 404, due to container being loaded from (stale) snapshot and not being
  * up to date. Host may chose to wait in such case and retry resolving URI.
  * Warning: Will wait infinitely for connection to establish if there is no connection.
- * May result in deadlock if Container.setAutoReconnect(false) is called and never switched back to auto-reconnect.
+ * May result in deadlock if Container.disconnect() is called and never followed by a call to Container.connect().
  * @returns true: container is up to date, it processed all the ops that were know at the time of first connection
  *          false: storage does not provide indication of how far the client is. Container processed
  *          all the ops known to it, but it maybe still behind.
@@ -174,7 +178,8 @@ export async function waitContainerToCatchUp(container: IContainer) {
         container.on("closed", closedCallback);
 
         const waitForOps = () => {
-            assert(container.connectionState !== ConnectionState.Disconnected,
+            assert(container.connectionState === ConnectionState.CatchingUp
+                || container.connectionState === ConnectionState.Connected,
                 0x0cd /* "Container disconnected while waiting for ops!" */);
             const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
 
@@ -211,9 +216,7 @@ export async function waitContainerToCatchUp(container: IContainer) {
         };
         container.on(connectedEventName, callback);
 
-        // TODO: Remove null check after next release #8523
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        container.resume!();
+        container.connect();
     });
 }
 
@@ -221,6 +224,18 @@ const getCodeProposal =
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     (quorum: IQuorumProposals) => quorum.get("code") ?? quorum.get("code2");
 
+/**
+ * State saved by a container at close time, to be used to load a new instance
+ * of the container to the same state
+ */
+export interface IPendingContainerState {
+    pendingRuntimeState: unknown;
+    url: string;
+    protocol: IProtocolState;
+    term: number;
+    clientId?: string;
+}
+
 const summarizerClientType = "summarizer";
 
 export class Container extends EventEmitterWithErrorHandling<IContainerEvents> implements IContainer {
@@ -232,7 +247,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     public static async load(
         loader: Loader,
         loadOptions: IContainerLoadOptions,
-        pendingLocalState?: unknown,
+        pendingLocalState?: IPendingContainerState,
     ): Promise<Container> {
         const container = new Container(
             loader,
@@ -240,6 +255,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 clientDetailsOverride: loadOptions.clientDetailsOverride,
                 resolvedUrl: loadOptions.resolvedUrl,
                 canReconnect: loadOptions.canReconnect,
+                serializedContainerState: pendingLocalState,
             });
 
         return PerformanceEvent.timedExecAsync(
@@ -249,12 +265,12 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 container._lifecycleState = "loading";
                 const version = loadOptions.version;
 
-                // always load unpaused with pending ops!
-                // It is also default mode in general.
                 const defaultMode: IContainerLoadMode = { opsBeforeReturn: "cached" };
-                assert(pendingLocalState === undefined || loadOptions.loadMode === undefined,
-                    0x1e1 /* "pending state requires immediate connection!" */);
-                const mode: IContainerLoadMode = loadOptions.loadMode ?? defaultMode;
+                // if we have pendingLocalState, anything we cached is not useful and we shouldn't wait for connection
+                // to return container, so ignore this value and use undefined for opsBeforeReturn
+                const mode: IContainerLoadMode = pendingLocalState
+                    ? { ...(loadOptions.loadMode ?? defaultMode), opsBeforeReturn: undefined }
+                    : loadOptions.loadMode ?? defaultMode;
 
                 const onClosed = (err?: ICriticalContainerError) => {
                     // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
@@ -597,7 +613,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                     // its own join op. Attempt recovery option.
                     this._deltaManager.logConnectionIssue({
                         eventName,
-                        duration: performance.now() - this.connectionTransitionTimes[ConnectionState.Connecting],
+                        duration: performance.now() - this.connectionTransitionTimes[ConnectionState.CatchingUp],
                     });
                 },
                 connectionStateChanged: () => {
@@ -607,6 +623,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 },
             },
             this.mc.logger,
+            config.serializedContainerState?.clientId,
         );
 
         this.on(savedContainerEvent, () => {
@@ -748,9 +765,13 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         assert(this.attachState === AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
         assert(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid",
             0x0d2 /* "resolved url should be valid Fluid url" */);
-        const pendingState: IPendingLocalState = {
+        assert(!!this._protocolHandler, 0x2e3 /* "Must have a valid protocol handler instance" */);
+        const pendingState: IPendingContainerState = {
             pendingRuntimeState: this.context.getPendingLocalState(),
             url: this.resolvedUrl.url,
+            protocol: this._protocolHandler.getProtocolState(),
+            term: this._protocolHandler.term,
+            clientId: this.clientId,
         };
 
         this.close();
@@ -808,7 +829,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                     // starting to attach the container to storage.
                     // Also, this should only be fired in detached container.
                     this._attachState = AttachState.Attaching;
-                    this.context.notifyAttaching();
+                    this.context.notifyAttaching(getSnapshotTreeFromSerializedContainer(summary));
                 }
 
                 // Actually go and create the resolved document
@@ -860,7 +881,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                     summary = combineAppAndProtocolSummary(appSummary, protocolSummary);
 
                     this._attachState = AttachState.Attaching;
-                    this.context.notifyAttaching();
+                    this.context.notifyAttaching(getSnapshotTreeFromSerializedContainer(summary));
 
                     await this.storageService.uploadSummaryWithContext(summary, {
                         referenceSequenceNumber: 0,
@@ -900,30 +921,6 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         );
     }
 
-    /**
-     * Dictates whether or not the current container will automatically attempt to reconnect to the delta stream
-     * after receiving a disconnect event
-     * @param reconnect - Boolean indicating if reconnect should automatically occur
-     * @deprecated - 0.58, This API will be removed in 1.0
-     * Use `connect()` and `disconnect()` instead of `setAutoReconnect(true)` and `setAutoReconnect(false)` respectively
-     * See https://github.com/microsoft/FluidFramework/issues/9167 for context
-     */
-    public setAutoReconnect(reconnect: boolean) {
-        if (this.closed) {
-            throw new Error("Attempting to setAutoReconnect() a closed Container");
-        }
-
-        const mode = reconnect ? ReconnectMode.Enabled : ReconnectMode.Disabled;
-        this.setAutoReconnectInternal(mode);
-
-        // If container state is not attached and resumed, then don't connect to delta stream. Also don't set the
-        // manual reconnection flag to true as we haven't made the initial connection yet.
-        if (reconnect && this._attachState === AttachState.Attached && this.resumedOpProcessingAfterLoad) {
-            // Ensure connection to web socket
-            this.connectToDeltaStream({ reason: "autoReconnect" });
-        }
-    }
-
     private setAutoReconnectInternal(mode: ReconnectMode) {
         const currentMode = this._deltaManager.connectionManager.reconnectMode;
 
@@ -987,23 +984,8 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         this.setAutoReconnectInternal(mode);
     }
 
-    /**
-     * Have the container attempt to resume processing ops
-     * @deprecated - 0.58, This API will be removed in 1.0
-     * Use `connect()` instead
-     * See https://github.com/microsoft/FluidFramework/issues/9167 for context
-     */
-    public resume() {
-        if (!this.closed) {
-            // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
-            // If there is gap, we will learn about it once connected, but the gap should be small (if any),
-            // assuming that resume() is called quickly after initial container boot.
-            this.resumeInternal({ reason: "DocumentOpenResume", fetchOpsFromStorage: false });
-        }
-    }
-
     private resumeInternal(args: IConnectionArgs) {
-        assert(!this.closed, 0x0d9 /* "Attempting to setAutoReconnect() a closed DeltaManager" */);
+        assert(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
 
         // Resume processing ops
         if (!this.resumedOpProcessingAfterLoad) {
@@ -1095,7 +1077,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     private async load(
         specifiedVersion: string | undefined,
         loadMode: IContainerLoadMode,
-        pendingLocalState?: unknown,
+        pendingLocalState?: IPendingContainerState,
     ) {
         if (this._resolvedUrl === undefined) {
             throw new Error("Attempting to load without a resolved url");
@@ -1123,14 +1105,28 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             this.connectToDeltaStream(connectionArgs);
         }
 
-        await this.connectStorageService();
+        if (!pendingLocalState) {
+            await this.connectStorageService();
+        } else {
+            // if we have pendingLocalState we can load without storage; don't wait for connection
+            this.connectStorageService().catch((error) => this.close(error));
+        }
+
         this._attachState = AttachState.Attached;
 
         // Fetch specified snapshot.
-        const { snapshot, versionId } = await this.fetchSnapshotTree(specifiedVersion);
-        assert(snapshot !== undefined, 0x237 /* "Snapshot should exist" */);
+        const { snapshot, versionId } = pendingLocalState === undefined
+            ? await this.fetchSnapshotTree(specifiedVersion)
+            : { snapshot: undefined, versionId: undefined };
+        assert(snapshot !== undefined || pendingLocalState !== undefined, 0x237 /* "Snapshot should exist" */);
 
-        const attributes = await this.getDocumentAttributes(this.storageService, snapshot);
+        const attributes: IDocumentAttributes = pendingLocalState === undefined
+            ? await this.getDocumentAttributes(this.storageService, snapshot)
+            : {
+                sequenceNumber: pendingLocalState.protocol.sequenceNumber,
+                minimumSequenceNumber: pendingLocalState.protocol.minimumSequenceNumber,
+                term: pendingLocalState.term,
+            };
 
         let opsBeforeReturnP: Promise<void> | undefined;
 
@@ -1154,15 +1150,21 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
 
         // ...load in the existing quorum
         // Initialize the protocol handler
-        this._protocolHandler =
-            await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot);
+        this._protocolHandler = pendingLocalState === undefined
+            ? await this.initializeProtocolStateFromSnapshot(attributes, this.storageService, snapshot)
+            : await this.initializeProtocolState(
+                attributes,
+                pendingLocalState.protocol.members,
+                pendingLocalState.protocol.proposals,
+                pendingLocalState.protocol.values,
+            );
 
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateContext(
             true, // existing
             codeDetails,
             snapshot,
-            pendingLocalState,
+            pendingLocalState?.pendingRuntimeState,
         );
 
         // Propagate current connection state through the system.
@@ -1186,7 +1188,10 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
 
             switch (loadMode.deltaConnection) {
                 case undefined:
-                    this.resume();
+                    // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
+                    // If there is gap, we will learn about it once connected, but the gap should be small (if any),
+                    // assuming that resumeInternal() is called quickly after initial container boot.
+                    this.resumeInternal({ reason: "DocumentLoad", fetchOpsFromStorage: false });
                     break;
                 case "delayed":
                     this.resumedOpProcessingAfterLoad = true;
@@ -1379,13 +1384,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         });
 
         // Track membership changes and update connection state accordingly
-        protocol.quorum.on("addMember", (clientId, details) => {
-            this.connectionStateHandler.receivedAddMemberEvent(clientId);
-        });
-
-        protocol.quorum.on("removeMember", (clientId) => {
-            this.connectionStateHandler.receivedRemoveMemberEvent(clientId);
-        });
+        this.connectionStateHandler.initProtocol(protocol);
 
         protocol.quorum.on("addProposal", (proposal: ISequencedProposal) => {
             if (proposal.key === "code" || proposal.key === "code2") {
@@ -1611,6 +1610,7 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             online: OnlineStatus[isOnline()],
             lastVisible: this.lastVisible !== undefined ? performance.now() - this.lastVisible : undefined,
             checkpointSequenceNumber,
+            quorumSize: this._protocolHandler?.quorum.getMembers().size,
             ...this._deltaManager.connectionProps,
         });
 
@@ -1719,15 +1719,17 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
                 // That means that if relay service changes settings, such changes will impact only newly booted
                 // clients.
                 // All existing will continue to use settings they got earlier.
-                const [noopTimeFrequency, noopCountFrequency] = this.getNoopConfig();
+                assert(
+                    this.serviceConfiguration !== undefined,
+                    0x2e4 /* "there should be service config for active connection" */);
                 this.collabWindowTracker = new CollabWindowTracker(
                     (type, contents) => {
                         assert(this.activeConnection(),
                             0x241 /* "disconnect should result in stopSequenceNumberUpdate() call" */);
                         this.submitMessage(type, contents);
                     },
-                    noopTimeFrequency,
-                    noopCountFrequency,
+                    this.serviceConfiguration?.noopTimeFrequency,
+                    this.serviceConfiguration?.noopCountFrequency,
                 );
             }
             this.collabWindowTracker.scheduleSequenceNumberUpdate(message, result.immediateNoOp === true);
@@ -1738,29 +1740,6 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
         return result;
     }
 
-    /**
-     *  #260 (ADO)
-     * back-compat: noopTimeFrequency & noopCountFrequency properties were added to
-     * IClientConfiguration in 0.59.3000. During the integration, we must read the
-     * available configuration from the loader options.
-     */
-    private getNoopConfig(): [number | undefined, number | undefined] {
-        assert(
-            this.serviceConfiguration !== undefined,
-            0x2e2, /* "there should be service config for active connection" */
-        );
-
-        if (this.serviceConfiguration.noopTimeFrequency !== undefined ||
-            this.serviceConfiguration.noopCountFrequency !== undefined) {
-            return [
-                this.serviceConfiguration.noopTimeFrequency as number,
-                this.serviceConfiguration.noopCountFrequency as number,
-            ];
-        }
-
-        return [this.loader.services.options?.noopTimeFrequency, this.loader.services.options?.noopCountFrequency];
-    }
-
     private submitSignal(message: any) {
         this._deltaManager.submitSignal(JSON.stringify(message));
     }
@@ -1807,7 +1786,6 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
     private async instantiateContextDetached(
         existing: boolean,
         snapshot?: ISnapshotTree,
-        pendingLocalState?: unknown,
     ) {
         const codeDetails = this.getCodeDetailsFromQuorum();
         if (codeDetails === undefined) {
@@ -1818,7 +1796,6 @@ export class Container extends EventEmitterWithErrorHandling<IContainerEvents> i
             existing,
             codeDetails,
             snapshot,
-            pendingLocalState,
         );
     }
 

package/src/containerContext.ts

@@ -21,7 +21,7 @@ import {
     IProvideFluidCodeDetailsComparer,
     ICodeDetailsLoader,
     IFluidModuleWithDetails,
-    IFluidModule,
+    ISnapshotTreeWithBlobContents,
 } from "@fluidframework/container-definitions";
 import {
     IRequest,
@@ -92,7 +92,9 @@ export class ContainerContext implements IContainerContext {
         return this.container.clientId;
     }
 
-    /** @deprecated Added back to unblock 0.56 integration */
+    /**
+     * DISCLAIMER: this id is only for telemetry purposes. Not suitable for any other usages.
+     */
     public get id(): string {
         const resolvedUrl = this.container.resolvedUrl;
         if (isFluidResolvedUrl(resolvedUrl)) {
@@ -159,7 +161,7 @@ export class ContainerContext implements IContainerContext {
         public readonly scope: FluidObject,
         private readonly codeLoader: ICodeDetailsLoader,
         private readonly _codeDetails: IFluidCodeDetails,
-        private readonly _baseSnapshot: ISnapshotTree | undefined,
+        private _baseSnapshot: ISnapshotTree | undefined,
         public readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>,
         quorum: IQuorum,
         public readonly loader: ILoader,
@@ -287,7 +289,9 @@ export class ContainerContext implements IContainerContext {
         return true;
     }
 
-    public notifyAttaching() {
+    public notifyAttaching(snapshot: ISnapshotTreeWithBlobContents) {
+        this._baseSnapshot = snapshot;
+        this.runtime.notifyAttaching?.(snapshot);
         this.runtime.setAttachState(AttachState.Attaching);
     }
 
@@ -316,11 +320,7 @@ export class ContainerContext implements IContainerContext {
     }
 
     private async loadCodeModule(codeDetails: IFluidCodeDetails): Promise<IFluidModuleWithDetails> {
-        // load may actually produce a IFluidModule if using a legacy ICodeLoader.
-        // Because the type system currently does not capture this in load,
-        // explicitly declare the type here to support both cases.
-        // See also comment about this below.
-        const loadCodeResult: IFluidModuleWithDetails | IFluidModule = await PerformanceEvent.timedExecAsync(
+        const loadCodeResult = await PerformanceEvent.timedExecAsync(
             this.taggedLogger,
             { eventName: "CodeLoad" },
             async () => this.codeLoader.load(codeDetails),
@@ -336,7 +336,7 @@ export class ContainerContext implements IContainerContext {
             // If "module" is not in the result, we are using a legacy ICodeLoader.  Fix the result up with details.
             // Once usage drops to 0 we can remove this compat path.
             this.taggedLogger.sendTelemetryEvent({ eventName: "LegacyCodeLoader" });
-            return { module: loadCodeResult, details: codeDetails };
+            return loadCodeResult;
         }
     }
     // #endregion

package/src/containerStorageAdapter.ts

@@ -4,6 +4,7 @@
  */
 
 import { ITelemetryLogger } from "@fluidframework/common-definitions";
+import { ISnapshotTreeWithBlobContents } from "@fluidframework/container-definitions";
 import {
     IDocumentStorageService,
     IDocumentStorageServicePolicies,
@@ -14,11 +15,9 @@ import {
     ISnapshotTree,
     ISummaryHandle,
     ISummaryTree,
-    ITree,
     IVersion,
 } from "@fluidframework/protocol-definitions";
 import { IDetachedBlobStorage } from "./loader";
-import { ISnapshotTreeWithBlobContents } from "./utils";
 
 /**
  * This class wraps the actual storage and make sure no wrong apis are called according to
@@ -70,10 +69,6 @@ export class ContainerStorageAdapter implements IDocumentStorageService {
         return this.storageGetter().getVersions(versionId, count);
     }
 
-    public async write(tree: ITree, parents: string[], message: string, ref: string): Promise<IVersion> {
-        return this.storageGetter().write(tree, parents, message, ref);
-    }
-
     public async uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string> {
         return this.storageGetter().uploadSummaryWithContext(summary, context);
     }

package/src/deltaManagerProxy.ts

@@ -148,10 +148,6 @@ export class DeltaManagerProxy
         super.dispose();
     }
 
-    public close(): void {
-        return this.deltaManager.close();
-    }
-
     public submitSignal(content: any): void {
         return this.deltaManager.submitSignal(content);
     }

package/src/index.ts

@@ -8,6 +8,7 @@ export {
     Container,
     IContainerLoadOptions,
     IContainerConfig,
+    IPendingContainerState,
     waitContainerToCatchUp,
 } from "./container";
 export {

package/src/loader.ts

@@ -17,9 +17,7 @@ import {
     IFluidModule,
     IHostLoader,
     ILoader,
-    IPendingLocalState,
     ILoaderOptions as ILoaderOptions1,
-    IProxyLoaderFactory,
     LoaderHeader,
     IProvideFluidCodeDetailsComparer,
     IFluidCodeDetails,
@@ -47,7 +45,7 @@ import {
     MultiUrlResolver,
     MultiDocumentServiceFactory,
 } from "@fluidframework/driver-utils";
-import { Container } from "./container";
+import { Container, IPendingContainerState } from "./container";
 import { IParsedUrl, parseUrl } from "./utils";
 import { pkgVersion } from "./packageVersion";
 
@@ -200,13 +198,6 @@ export interface ILoaderProps {
      */
     readonly scope?: FluidObject;
 
-    /**
-     * Proxy loader factories for loading containers via proxy in other contexts,
-     * like web workers, or worker threads.
-     * @deprecated Not recommended for general use and will be removed in an upcoming release.
-     */
-    readonly proxyLoaderFactories?: Map<string, IProxyLoaderFactory>;
-
     /**
      * The logger that all telemetry should be pushed to.
      */
@@ -257,13 +248,6 @@ export interface ILoaderServices {
      */
     readonly scope: FluidObject;
 
-    /**
-     * Proxy loader factories for loading containers via proxy in other contexts,
-     * like web workers, or worker threads.
-     * @deprecated Not recommended for general use and will be removed in an upcoming release.
-     */
-    readonly proxyLoaderFactories: Map<string, IProxyLoaderFactory>;
-
     /**
      * The logger downstream consumers should construct their loggers from
      */
@@ -318,7 +302,6 @@ export class Loader implements IHostLoader {
             options: loaderProps.options ?? {},
             scope,
             subLogger: subMc.logger,
-            proxyLoaderFactories: loaderProps.proxyLoaderFactories ?? new Map<string, IProxyLoaderFactory>(),
             detachedBlobStorage: loaderProps.detachedBlobStorage,
         };
         this.mc = loggerToMonitoringContext(
@@ -394,7 +377,7 @@ export class Loader implements IHostLoader {
 
     private async resolveCore(
         request: IRequest,
-        pendingLocalState?: IPendingLocalState,
+        pendingLocalState?: IPendingContainerState,
     ): Promise<{ container: Container; parsed: IParsedUrl; }> {
         const resolvedAsFluid = await this.services.urlResolver.resolve(request);
         ensureFluidResolvedUrl(resolvedAsFluid);
@@ -436,7 +419,7 @@ export class Loader implements IHostLoader {
                 await this.loadContainer(
                     request,
                     resolvedAsFluid,
-                    pendingLocalState?.pendingRuntimeState);
+                    pendingLocalState);
         }
 
         if (container.deltaManager.lastSequenceNumber <= fromSequenceNumber) {
@@ -487,7 +470,7 @@ export class Loader implements IHostLoader {
     private async loadContainer(
         request: IRequest,
         resolved: IFluidResolvedUrl,
-        pendingLocalState?: unknown,
+        pendingLocalState?: IPendingContainerState,
     ): Promise<Container> {
         return Container.load(
             this,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "0.59.4000-71130";
+export const pkgVersion = "1.0.0";

package/src/protocolTreeDocumentStorageService.ts

@@ -31,7 +31,6 @@ export class ProtocolTreeStorageService implements IDocumentStorageService, IDis
 
     getSnapshotTree = this.internalStorageService.getSnapshotTree.bind(this.internalStorageService);
     getVersions = this.internalStorageService.getVersions.bind(this.internalStorageService);
-    write = this.internalStorageService.write.bind(this.internalStorageService);
     createBlob = this.internalStorageService.createBlob.bind(this.internalStorageService);
     readBlob = this.internalStorageService.readBlob.bind(this.internalStorageService);
     downloadSummary = this.internalStorageService.downloadSummary.bind(this.internalStorageService);

package/src/retriableDocumentStorageService.ts

@@ -15,7 +15,6 @@ import {
     ISnapshotTree,
     ISummaryHandle,
     ISummaryTree,
-    ITree,
     IVersion,
 } from "@fluidframework/protocol-definitions";
 import { IDisposable, ITelemetryLogger } from "@fluidframework/common-definitions";
@@ -62,13 +61,6 @@ export class RetriableDocumentStorageService implements IDocumentStorageService,
         );
     }
 
-    public async write(tree: ITree, parents: string[], message: string, ref: string): Promise<IVersion> {
-        return this.runWithRetry(
-            async () => this.internalStorageService.write(tree, parents, message, ref),
-            "storage_write",
-        );
-    }
-
     public async uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string> {
         // Not using retry loop here. Couple reasons:
         // 1. If client lost connectivity, then retry loop will result in uploading stale summary