@fluidframework/container-loader 2.0.0-dev-rc.3.0.0.250606 → 2.0.0-dev-rc.3.0.0.254274

package/dist/container.js

@@ -10,11 +10,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Container = exports.ReportIfTooLong = exports.waitContainerToCatchUp = void 0;
 const client_utils_1 = require("@fluid-internal/client-utils");
 const container_definitions_1 = require("@fluidframework/container-definitions");
+const internal_1 = require("@fluidframework/container-definitions/internal");
 const core_interfaces_1 = require("@fluidframework/core-interfaces");
-const core_utils_1 = require("@fluidframework/core-utils");
-const driver_utils_1 = require("@fluidframework/driver-utils");
+const internal_2 = require("@fluidframework/core-utils/internal");
+const internal_3 = require("@fluidframework/driver-utils/internal");
 const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
-const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+const internal_4 = require("@fluidframework/telemetry-utils/internal");
 const structured_clone_1 = __importDefault(require("@ungap/structured-clone"));
 const uuid_1 = require("uuid");
 const attachment_js_1 = require("./attachment.js");
@@ -57,7 +58,7 @@ const packageNotFactoryError = "Code package does not implement IRuntimeFactory"
 async function waitContainerToCatchUp(container) {
     // Make sure we stop waiting if container is closed.
     if (container.closed) {
-        throw new telemetry_utils_1.UsageError("waitContainerToCatchUp: Container closed");
+        throw new internal_4.UsageError("waitContainerToCatchUp: Container closed");
     }
     return new Promise((resolve, reject) => {
         const deltaManager = container.deltaManager;
@@ -65,8 +66,8 @@ async function waitContainerToCatchUp(container) {
             container.off("closed", closedCallback);
             const baseMessage = "Container closed while waiting to catch up";
             reject(err !== undefined
-                ? (0, telemetry_utils_1.wrapError)(err, (innerMessage) => new telemetry_utils_1.GenericError(`${baseMessage}: ${innerMessage}`))
-                : new telemetry_utils_1.GenericError(baseMessage));
+                ? (0, internal_4.wrapError)(err, (innerMessage) => new internal_4.GenericError(`${baseMessage}: ${innerMessage}`))
+                : new internal_4.GenericError(baseMessage));
         };
         container.on("closed", closedCallback);
         // Depending on config, transition to "connected" state may include the guarantee
@@ -74,11 +75,11 @@ async function waitContainerToCatchUp(container) {
         // Waiting for "connected" state in either case gets us at least to our own Join op
         // which is a reasonable approximation of "caught up"
         const waitForOps = () => {
-            (0, core_utils_1.assert)(container.connectionState === connectionState_js_1.ConnectionState.CatchingUp ||
+            (0, internal_2.assert)(container.connectionState === connectionState_js_1.ConnectionState.CatchingUp ||
                 container.connectionState === connectionState_js_1.ConnectionState.Connected, 0x0cd /* "Container disconnected while waiting for ops!" */);
             const hasCheckpointSequenceNumber = deltaManager.hasCheckpointSequenceNumber;
             const connectionOpSeqNumber = deltaManager.lastKnownSeqNumber;
-            (0, core_utils_1.assert)(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
+            (0, internal_2.assert)(deltaManager.lastSequenceNumber <= connectionOpSeqNumber, 0x266 /* "lastKnownSeqNumber should never be below last processed sequence number" */);
             if (deltaManager.lastSequenceNumber === connectionOpSeqNumber) {
                 container.off("closed", closedCallback);
                 resolve(hasCheckpointSequenceNumber);
@@ -102,10 +103,10 @@ async function waitContainerToCatchUp(container) {
             return;
         }
         const callback = () => {
-            container.off(telemetry_utils_1.connectedEventName, callback);
+            container.off(internal_4.connectedEventName, callback);
             waitForOps();
         };
-        container.on(telemetry_utils_1.connectedEventName, callback);
+        container.on(internal_4.connectedEventName, callback);
         if (container.connectionState === connectionState_js_1.ConnectionState.Disconnected) {
             container.connect();
         }
@@ -120,7 +121,7 @@ const getCodeProposal = (quorum) => quorum.get("code") ?? quorum.get("code2");
  * @param action - functor to call and measure
  */
 async function ReportIfTooLong(logger, eventName, action) {
-    const event = telemetry_utils_1.PerformanceEvent.start(logger, { eventName });
+    const event = internal_4.PerformanceEvent.start(logger, { eventName });
     const props = await action();
     if (event.duration > 200) {
         event.end(props);
@@ -128,7 +129,7 @@ async function ReportIfTooLong(logger, eventName, action) {
 }
 exports.ReportIfTooLong = ReportIfTooLong;
 const summarizerClientType = "summarizer";
-class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
+class Container extends internal_4.EventEmitterWithErrorHandling {
     /**
      * Load an existing container.
      */
@@ -136,7 +137,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const { version, pendingLocalState, loadMode, resolvedUrl, loadToSequenceNumber } = loadProps;
         const container = new Container(createProps, loadProps);
         const disableRecordHeapSize = container.mc.config.getBoolean("Fluid.Loader.DisableRecordHeapSize");
-        return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
+        return internal_4.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "Load" }, async (event) => new Promise((resolve, reject) => {
             const defaultMode = { opsBeforeReturn: "cached" };
             // 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
@@ -145,7 +146,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 : loadMode ?? defaultMode;
             const onClosed = (err) => {
                 // pre-0.58 error message: containerClosedWithoutErrorDuringLoad
-                reject(err ?? new telemetry_utils_1.GenericError("Container closed without error during load"));
+                reject(err ?? new internal_4.GenericError("Container closed without error during load"));
             };
             container.on("closed", onClosed);
             container
@@ -157,7 +158,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 event.end({ ...props, ...loadMode });
                 resolve(container);
             }, (error) => {
-                const err = (0, telemetry_utils_1.normalizeError)(error);
+                const err = (0, internal_4.normalizeError)(error);
                 // Depending where error happens, we can be attempting to connect to web socket
                 // and continuously retrying (consider offline mode)
                 // Host has no container to close, so it's prudent to do it here
@@ -175,7 +176,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      */
     static async createDetached(createProps, codeDetails) {
         const container = new Container(createProps);
-        return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
+        return internal_4.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "CreateDetached" }, async (_event) => {
             await container.createDetached(codeDetails);
             return container;
         }, { start: true, end: true, cancel: "generic" });
@@ -186,7 +187,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      */
     static async rehydrateDetachedFromSnapshot(createProps, snapshot) {
         const container = new Container(createProps);
-        return telemetry_utils_1.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
+        return internal_4.PerformanceEvent.timedExecAsync(container.mc.logger, { eventName: "RehydrateDetachedFromSnapshot" }, async (_event) => {
             const detachedContainerState = (0, utils_js_1.getDetachedContainerStateFromSerializedContainer)(snapshot);
             await container.rehydrateDetachedFromSnapshot(detachedContainerState);
             return container;
@@ -315,14 +316,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
      */
     async getEntryPoint() {
         if (this._disposed) {
-            throw new telemetry_utils_1.UsageError("The context is already disposed");
+            throw new internal_4.UsageError("The context is already disposed");
         }
         if (this._runtime !== undefined) {
             return this._runtime.getEntryPoint?.();
         }
         return new Promise((resolve, reject) => {
             const runtimeInstantiatedHandler = () => {
-                (0, core_utils_1.assert)(this._runtime !== undefined, 0x5a3 /* runtimeInstantiated fired but runtime is still undefined */);
+                (0, internal_2.assert)(this._runtime !== undefined, 0x5a3 /* runtimeInstantiated fired but runtime is still undefined */);
                 resolve(this._runtime.getEntryPoint?.());
                 this._lifecycleEvents.off("disposed", disposedHandler);
             };
@@ -369,14 +370,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this._lifecycleEvents = new client_utils_1.TypedEventEmitter();
         this._disposed = false;
         this.attach = (0, utils_js_1.runSingle)(async (request, attachProps) => {
-            await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
+            await internal_4.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "Attach" }, async () => {
                 if (this._lifecycleState !== "loaded" ||
                     this.attachmentData.state === container_definitions_1.AttachState.Attached) {
                     // pre-0.58 error message: containerNotValidForAttach
-                    throw new telemetry_utils_1.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}] and [${this.attachState}]`);
+                    throw new internal_4.UsageError(`The Container is not in a valid state for attach [${this._lifecycleState}] and [${this.attachState}]`);
                 }
                 const normalizeErrorAndClose = (error) => {
-                    const newError = (0, telemetry_utils_1.normalizeError)(error);
+                    const newError = (0, internal_4.normalizeError)(error);
                     this.close(newError);
                     // add resolved URL on error object so that host has the ability to find this document and delete it
                     newError.addTelemetryProperties({
@@ -400,7 +401,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 };
                 const createAttachmentSummary = (redirectTable) => {
                     try {
-                        (0, core_utils_1.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
+                        (0, internal_2.assert)(this.deltaManager.inbound.length === 0, 0x0d6 /* "Inbound queue should be empty when attaching" */);
                         return (0, utils_js_1.combineAppAndProtocolSummary)(this.runtime.createSummary(redirectTable), this.captureProtocolSummary());
                     }
                     catch (error) {
@@ -411,9 +412,9 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                     // Actually go and create the resolved document
                     if (this.service === undefined) {
                         const createNewResolvedUrl = await this.urlResolver.resolve(request);
-                        (0, core_utils_1.assert)(this.client.details.type !== summarizerClientType &&
+                        (0, internal_2.assert)(this.client.details.type !== summarizerClientType &&
                             createNewResolvedUrl !== undefined, 0x2c4 /* "client should not be summarizer before container is created" */);
-                        this.service = await (0, driver_utils_1.runWithRetry)(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
+                        this.service = await (0, internal_3.runWithRetry)(async () => this.serviceFactory.createContainer(summary, createNewResolvedUrl, this.subLogger, false), "containerAttach", this.mc.logger, {
                             cancel: this._deltaManager.closeAbortController.signal,
                         });
                     }
@@ -434,7 +435,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                         throw normalizeErrorAndClose(error);
                     });
                 }
-                this.serializedStateManager.setSnapshot(await attachP);
+                const snapshotWithBlobs = await attachP;
+                this.serializedStateManager.setInitialSnapshot(snapshotWithBlobs);
                 if (!this.closed) {
                     this.handleDeltaConnectionArg({
                         fetchOpsFromStorage: false,
@@ -493,7 +495,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const clientType = `${interactive ? "interactive" : "noninteractive"}${type !== undefined && type !== "" ? `/${type}` : ""}`;
         // Need to use the property getter for docId because for detached flow we don't have the docId initially.
         // We assign the id later so property getter is used.
-        this.subLogger = (0, telemetry_utils_1.createChildLogger)({
+        this.subLogger = (0, internal_4.createChildLogger)({
             logger: subLogger,
             properties: {
                 all: {
@@ -528,7 +530,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             },
         });
         // Prefix all events in this file with container-loader
-        this.mc = (0, telemetry_utils_1.createChildMonitoringContext)({ logger: this.subLogger, namespace: "Container" });
+        this.mc = (0, internal_4.createChildMonitoringContext)({ logger: this.subLogger, namespace: "Container" });
         this._deltaManager = this.createDeltaManager();
         this.connectionStateHandler = (0, connectionStateHandler_js_1.createConnectionStateHandler)({
             logger: this.mc.logger,
@@ -584,7 +586,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // We expose our storage publicly, so it's possible others may call uploadSummaryWithContext() with a
         // non-combined summary tree (in particular, ContainerRuntime.submitSummary).  We'll intercept those calls
         // using this callback and fix them up.
-        const addProtocolSummaryIfMissing = (summaryTree) => (0, driver_utils_1.isCombinedAppAndProtocolSummary)(summaryTree) === true
+        const addProtocolSummaryIfMissing = (summaryTree) => (0, internal_3.isCombinedAppAndProtocolSummary)(summaryTree) === true
             ? summaryTree
             : (0, utils_js_1.combineAppAndProtocolSummary)(summaryTree, this.captureProtocolSummary());
         // Whether the combined summary tree has been forced on by either the loader option or the monitoring context.
@@ -636,11 +638,11 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.verifyClosed();
     }
     verifyClosed() {
-        (0, core_utils_1.assert)(this.connectionState === connectionState_js_1.ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
-        (0, core_utils_1.assert)(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
+        (0, internal_2.assert)(this.connectionState === connectionState_js_1.ConnectionState.Disconnected, 0x0cf /* "disconnect event was not raised!" */);
+        (0, internal_2.assert)(this._lifecycleState === "closed" || this._lifecycleState === "disposed", 0x314 /* Container properly closed */);
     }
     closeCore(error) {
-        (0, core_utils_1.assert)(!this.closed, 0x315 /* re-entrancy */);
+        (0, internal_2.assert)(!this.closed, 0x315 /* re-entrancy */);
         try {
             // Ensure that we raise all key events even if one of these throws
             try {
@@ -679,7 +681,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     disposeCore(error) {
-        (0, core_utils_1.assert)(!this._disposed, 0x54c /* Container already disposed */);
+        (0, internal_2.assert)(!this._disposed, 0x54c /* Container already disposed */);
         this._disposed = true;
         try {
             // Ensure that we raise all key events even if one of these throws
@@ -735,10 +737,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     async getPendingLocalStateCore(props) {
         if (this.closed || this._disposed) {
-            throw new telemetry_utils_1.UsageError("Pending state cannot be retried if the container is closed or disposed");
+            throw new internal_4.UsageError("Pending state cannot be retried if the container is closed or disposed");
         }
-        (0, core_utils_1.assert)(this.attachmentData.state === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
-        (0, core_utils_1.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
+        (0, internal_2.assert)(this.attachmentData.state === container_definitions_1.AttachState.Attached, 0x0d1 /* "Container should be attached before close" */);
+        (0, internal_2.assert)(this.resolvedUrl !== undefined && this.resolvedUrl.type === "fluid", 0x0d2 /* "resolved url should be valid Fluid url" */);
         const pendingState = await this.serializedStateManager.getPendingLocalStateCore(props, this.clientId, this.runtime, this.resolvedUrl);
         return pendingState;
     }
@@ -747,14 +749,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     serialize() {
         if (this.attachmentData.state === container_definitions_1.AttachState.Attached || this.closed) {
-            throw new telemetry_utils_1.UsageError("Container must not be attached or closed.");
+            throw new internal_4.UsageError("Container must not be attached or closed.");
         }
         const attachingData = this.attachmentData.state === container_definitions_1.AttachState.Attaching ? this.attachmentData : undefined;
         const combinedSummary = attachingData?.summary ??
             (0, utils_js_1.combineAppAndProtocolSummary)(this.runtime.createSummary(), this.captureProtocolSummary());
         const { baseSnapshot, snapshotBlobs } = (0, utils_js_1.getSnapshotTreeAndBlobsFromSerializedContainer)(combinedSummary);
         const pendingRuntimeState = attachingData !== undefined ? this.runtime.getPendingLocalState() : undefined;
-        (0, core_utils_1.assert)(!(0, core_utils_1.isPromiseLike)(pendingRuntimeState), 0x8e3 /* should not be a promise */);
+        (0, internal_2.assert)(!(0, internal_2.isPromiseLike)(pendingRuntimeState), 0x8e3 /* should not be a promise */);
         const detachedContainerState = {
             attached: false,
             baseSnapshot,
@@ -782,10 +784,10 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     connect() {
         if (this.closed) {
-            throw new telemetry_utils_1.UsageError(`The Container is closed and cannot be connected`);
+            throw new internal_4.UsageError(`The Container is closed and cannot be connected`);
         }
         else if (this.attachState !== container_definitions_1.AttachState.Attached) {
-            throw new telemetry_utils_1.UsageError(`The Container is not attached and cannot be connected`);
+            throw new internal_4.UsageError(`The Container is not attached and cannot be connected`);
         }
         else if (!this.connected) {
             // Note: no need to fetch ops as we do it preemptively as part of DeltaManager.attachOpHandler().
@@ -798,8 +800,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     connectInternal(args) {
-        (0, core_utils_1.assert)(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
-        (0, core_utils_1.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
+        (0, internal_2.assert)(!this.closed, 0x2c5 /* "Attempting to connect() a closed Container" */);
+        (0, internal_2.assert)(this.attachState === container_definitions_1.AttachState.Attached, 0x2c6 /* "Attempting to connect() a container that is not attached" */);
         // Resume processing ops and connect to delta stream
         this.resumeInternal(args);
         // Set Auto Reconnect Mode
@@ -808,20 +810,20 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     disconnect() {
         if (this.closed) {
-            throw new telemetry_utils_1.UsageError(`The Container is closed and cannot be disconnected`);
+            throw new internal_4.UsageError(`The Container is closed and cannot be disconnected`);
         }
         else {
             this.disconnectInternal({ text: "DocumentDisconnect" });
         }
     }
     disconnectInternal(reason) {
-        (0, core_utils_1.assert)(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
+        (0, internal_2.assert)(!this.closed, 0x2c7 /* "Attempting to disconnect() a closed Container" */);
         // Set Auto Reconnect Mode
         const mode = contracts_js_1.ReconnectMode.Disabled;
         this.setAutoReconnectInternal(mode, reason);
     }
     resumeInternal(args) {
-        (0, core_utils_1.assert)(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
+        (0, internal_2.assert)(!this.closed, 0x0d9 /* "Attempting to connect() a closed DeltaManager" */);
         // Resume processing ops
         if (this.inboundQueuePausedFromInit) {
             this.inboundQueuePausedFromInit = false;
@@ -832,7 +834,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this.connectToDeltaStream(args);
     }
     async proposeCodeDetails(codeDetails) {
-        if (!(0, container_definitions_1.isFluidCodeDetails)(codeDetails)) {
+        if (!(0, internal_1.isFluidCodeDetails)(codeDetails)) {
             throw new Error("Provided codeDetails are not IFluidCodeDetails");
         }
         if (this.codeLoader.IFluidCodeDetailsComparer) {
@@ -858,7 +860,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             return;
         }
         // pre-0.58 error message: existingContextDoesNotSatisfyIncomingProposal
-        const error = new telemetry_utils_1.GenericError("Existing context does not satisfy incoming proposal");
+        const error = new internal_4.GenericError("Existing context does not satisfy incoming proposal");
         this.close(error);
     }
     /**
@@ -942,17 +944,17 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         this._loadedFromVersion = version;
         const attributes = await (0, utils_js_1.getDocumentAttributes)(this.storageAdapter, baseSnapshot);
         // If we saved ops, we will replay them and don't need DeltaManager to fetch them
-        const sequenceNumber = pendingLocalState?.savedOps[pendingLocalState.savedOps.length - 1]?.sequenceNumber;
-        const dmAttributes = sequenceNumber !== undefined ? { ...attributes, sequenceNumber } : attributes;
+        const lastProcessedSequenceNumber = pendingLocalState?.savedOps[pendingLocalState.savedOps.length - 1]?.sequenceNumber ??
+            attributes.sequenceNumber;
         let opsBeforeReturnP;
         if (loadMode.pauseAfterLoad === true) {
             // If we are trying to pause at a specific sequence number, ensure the latest snapshot is not newer than the desired sequence number.
             if (loadMode.opsBeforeReturn === "sequenceNumber") {
-                (0, core_utils_1.assert)(loadToSequenceNumber !== undefined, 0x727 /* sequenceNumber should be defined */);
+                (0, internal_2.assert)(loadToSequenceNumber !== undefined, 0x727 /* sequenceNumber should be defined */);
                 // Note: It is possible that we think the latest snapshot is newer than the specified sequence number
                 // due to saved ops that may be replayed after the snapshot.
                 // https://dev.azure.com/fluidframework/internal/_workitems/edit/5055
-                if (dmAttributes.sequenceNumber > loadToSequenceNumber) {
+                if (lastProcessedSequenceNumber > loadToSequenceNumber) {
                     throw new Error("Cannot satisfy request to pause the container at the specified sequence number. Most recent snapshot is newer than the specified sequence number.");
                 }
             }
@@ -993,15 +995,15 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             case undefined:
                 // Start prefetch, but not set opsBeforeReturnP - boot is not blocked by it!
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                this.attachDeltaManagerOpHandler(dmAttributes, loadMode.deltaConnection !== "none" ? "all" : "none");
+                this.attachDeltaManagerOpHandler(attributes, loadMode.deltaConnection !== "none" ? "all" : "none", lastProcessedSequenceNumber);
                 break;
             case "sequenceNumber":
             case "cached":
             case "all":
-                opsBeforeReturnP = this.attachDeltaManagerOpHandler(dmAttributes, loadMode.opsBeforeReturn);
+                opsBeforeReturnP = this.attachDeltaManagerOpHandler(attributes, loadMode.opsBeforeReturn, lastProcessedSequenceNumber);
                 break;
             default:
-                (0, core_utils_1.unreachableCase)(loadMode.opsBeforeReturn);
+                (0, internal_2.unreachableCase)(loadMode.opsBeforeReturn);
         }
         // ...load in the existing quorum
         // Initialize the protocol handler
@@ -1010,7 +1012,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         const codeDetails = this.getCodeDetailsFromQuorum();
         await this.instantiateRuntime(codeDetails, baseSnapshot, 
         // give runtime a dummy value so it knows we're loading from a stash blob
-        pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined, (0, driver_utils_1.isInstanceOfISnapshot)(baseSnapshot) ? baseSnapshot : undefined);
+        pendingLocalState ? pendingLocalState?.pendingRuntimeState ?? {} : undefined, (0, internal_3.isInstanceOfISnapshot)(baseSnapshot) ? baseSnapshot : undefined);
         // replay saved ops
         if (pendingLocalState) {
             for (const message of pendingLocalState.savedOps) {
@@ -1028,8 +1030,8 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         if (!this.closed) {
             if (opsBeforeReturnP !== undefined) {
                 this._deltaManager.inbound.resume();
-                await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "WaitOps" }, async () => opsBeforeReturnP);
-                await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "WaitOpProcessing" }, async () => this._deltaManager.inbound.waitTillProcessingDone());
+                await internal_4.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "WaitOps" }, async () => opsBeforeReturnP);
+                await internal_4.PerformanceEvent.timedExecAsync(this.mc.logger, { eventName: "WaitOpProcessing" }, async () => this._deltaManager.inbound.waitTillProcessingDone());
                 // eslint-disable-next-line @typescript-eslint/no-floating-promises
                 this._deltaManager.inbound.pause();
             }
@@ -1088,7 +1090,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     async rehydrateDetachedFromSnapshot({ baseSnapshot, snapshotBlobs, hasAttachmentBlobs, pendingRuntimeState, }) {
         if (hasAttachmentBlobs) {
-            (0, core_utils_1.assert)(!!this.detachedBlobStorage && this.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
+            (0, internal_2.assert)(!!this.detachedBlobStorage && this.detachedBlobStorage.size > 0, 0x250 /* "serialized container with attachment blobs must be rehydrated with detached blob storage" */);
         }
         const snapshotTreeWithBlobContents = (0, utils_js_1.combineSnapshotTreeAndSnapshotBlobs)(baseSnapshot, snapshotBlobs);
         this.storageAdapter.loadSnapshotFromSnapshotBlobs(snapshotBlobs);
@@ -1096,7 +1098,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         await this.attachDeltaManagerOpHandler(attributes);
         // Initialize the protocol handler
         const baseTree = (0, utils_js_1.getProtocolSnapshotTree)(snapshotTreeWithBlobContents);
-        const qValues = await (0, driver_utils_1.readAndParse)(this.storageAdapter, baseTree.blobs.quorumValues);
+        const qValues = await (0, internal_3.readAndParse)(this.storageAdapter, baseTree.blobs.quorumValues);
         this.initializeProtocolState(attributes, {
             members: [],
             proposals: [],
@@ -1116,16 +1118,16 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             const baseTree = (0, utils_js_1.getProtocolSnapshotTree)(snapshot);
             [quorumSnapshot.members, quorumSnapshot.proposals, quorumSnapshot.values] =
                 await Promise.all([
-                    (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumMembers),
-                    (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumProposals),
-                    (0, driver_utils_1.readAndParse)(storage, baseTree.blobs.quorumValues),
+                    (0, internal_3.readAndParse)(storage, baseTree.blobs.quorumMembers),
+                    (0, internal_3.readAndParse)(storage, baseTree.blobs.quorumProposals),
+                    (0, internal_3.readAndParse)(storage, baseTree.blobs.quorumValues),
                 ]);
         }
         this.initializeProtocolState(attributes, quorumSnapshot);
     }
     initializeProtocolState(attributes, quorumSnapshot) {
         const protocol = this.protocolHandlerBuilder(attributes, quorumSnapshot, (key, value) => this.submitMessage(protocol_definitions_1.MessageType.Propose, JSON.stringify({ key, value })));
-        const protocolLogger = (0, telemetry_utils_1.createChildLogger)({
+        const protocolLogger = (0, internal_4.createChildLogger)({
             logger: this.subLogger,
             namespace: "ProtocolHandler",
         });
@@ -1141,13 +1143,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         });
         protocol.quorum.on("approveProposal", (sequenceNumber, key, value) => {
             if (key === "code" || key === "code2") {
-                if (!(0, container_definitions_1.isFluidCodeDetails)(value)) {
+                if (!(0, internal_1.isFluidCodeDetails)(value)) {
                     this.mc.logger.sendErrorEvent({
                         eventName: "CodeProposalNotIFluidCodeDetails",
                     });
                 }
                 this.processCodeProposal().catch((error) => {
-                    const normalizedError = (0, telemetry_utils_1.normalizeError)(error);
+                    const normalizedError = (0, internal_4.normalizeError)(error);
                     this.close(normalizedError);
                     throw error;
                 });
@@ -1229,14 +1231,14 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
     }
     createDeltaManager() {
         const serviceProvider = () => this.service;
-        const deltaManager = new deltaManager_js_1.DeltaManager(serviceProvider, (0, telemetry_utils_1.createChildLogger)({ logger: this.subLogger, namespace: "DeltaManager" }), () => this.activeConnection(), (props) => new connectionManager_js_1.ConnectionManager(serviceProvider, () => this.isDirty, this.client, this._canReconnect, (0, telemetry_utils_1.createChildLogger)({ logger: this.subLogger, namespace: "ConnectionManager" }), props));
+        const deltaManager = new deltaManager_js_1.DeltaManager(serviceProvider, (0, internal_4.createChildLogger)({ logger: this.subLogger, namespace: "DeltaManager" }), () => this.activeConnection(), (props) => new connectionManager_js_1.ConnectionManager(serviceProvider, () => this.isDirty, this.client, this._canReconnect, (0, internal_4.createChildLogger)({ logger: this.subLogger, namespace: "ConnectionManager" }), props));
         // Disable inbound queues as Container is not ready to accept any ops until we are fully loaded!
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inbound.pause();
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         deltaManager.inboundSignal.pause();
         deltaManager.on("connect", (details, _opsBehind) => {
-            (0, core_utils_1.assert)(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
+            (0, internal_2.assert)(this.connectionMode === details.mode, 0x4b7 /* mismatch */);
             this.connectionStateHandler.receivedConnectEvent(details);
         });
         deltaManager.on("establishingConnection", (reason) => {
@@ -1272,13 +1274,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         });
         return deltaManager;
     }
-    async attachDeltaManagerOpHandler(attributes, prefetchType) {
+    async attachDeltaManagerOpHandler(attributes, prefetchType, lastProcessedSequenceNumber) {
         return this._deltaManager.attachOpHandler(attributes.minimumSequenceNumber, attributes.sequenceNumber, {
             process: (message) => this.processRemoteMessage(message),
             processSignal: (message) => {
                 this.processSignal(message);
             },
-        }, prefetchType);
+        }, prefetchType, lastProcessedSequenceNumber);
     }
     logConnectionStateChangeTelemetry(value, oldState, reason) {
         // Log actual event
@@ -1297,7 +1299,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             if (value === connectionState_js_1.ConnectionState.Connected) {
                 durationFromDisconnected =
                     time - this.connectionTransitionTimes[connectionState_js_1.ConnectionState.Disconnected];
-                durationFromDisconnected = (0, telemetry_utils_1.formatTick)(durationFromDisconnected);
+                durationFromDisconnected = (0, internal_4.formatTick)(durationFromDisconnected);
             }
             else if (value === connectionState_js_1.ConnectionState.CatchingUp) {
                 // This info is of most interesting while Catching Up.
@@ -1321,7 +1323,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             clientId: this.clientId,
             autoReconnect,
             opsBehind,
-            online: driver_utils_1.OnlineStatus[(0, driver_utils_1.isOnline)()],
+            online: internal_3.OnlineStatus[(0, internal_3.isOnline)()],
             lastVisible: this.lastVisible !== undefined
                 ? client_utils_1.performance.now() - this.lastVisible
                 : undefined,
@@ -1347,7 +1349,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         // Both protocol and context should not be undefined if we got so far.
         this.setContextConnectedState(state, this.readOnlyInfo.readonly ?? false);
         this.protocolHandler.setConnectionState(state, this.clientId);
-        (0, telemetry_utils_1.raiseConnectedEvent)(this.mc.logger, this, state, this.clientId, disconnectedReason?.text);
+        (0, internal_4.raiseConnectedEvent)(this.mc.logger, this, state, this.clientId, disconnectedReason?.text);
     }
     // back-compat: ADO #1385: Remove in the future, summary op should come through submitSummaryMessage()
     submitContainerMessage(type, contents, batch, metadata) {
@@ -1357,7 +1359,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             case protocol_definitions_1.MessageType.Summarize:
                 return this.submitSummaryMessage(contents);
             default: {
-                const newError = new telemetry_utils_1.GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type });
+                const newError = new internal_4.GenericError("invalidContainerSubmitOpType", undefined /* error */, { messageType: type });
                 this.close(newError);
                 return -1;
             }
@@ -1407,13 +1409,13 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 // 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.
-                (0, core_utils_1.assert)(serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
+                (0, internal_2.assert)(serviceConfiguration !== undefined, 0x2e4 /* "there should be service config for active connection" */);
                 this.noopHeuristic = new noopHeuristic_js_1.NoopHeuristic(serviceConfiguration.noopTimeFrequency, serviceConfiguration.noopCountFrequency);
                 this.noopHeuristic.on("wantsNoop", () => {
                     // On disconnect we notify the heuristic which should prevent it from wanting a noop.
                     // Hitting this assert would imply we lost activeConnection between notifying the heuristic of a processed message and
                     // running the microtask that the heuristic queued in response.
-                    (0, core_utils_1.assert)(this.activeConnection(), 0x241 /* "Trying to send noop without active connection" */);
+                    (0, internal_2.assert)(this.activeConnection(), 0x241 /* "Trying to send noop without active connection" */);
                     this.submitMessage(protocol_definitions_1.MessageType.NoOp);
                 });
             }
@@ -1421,7 +1423,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             // The contract with the protocolHandler is that returning "immediateNoOp" is equivalent to "please immediately accept the proposal I just processed".
             if (result.immediateNoOp === true) {
                 // ADO:1385: Remove cast and use MessageType once definition changes propagate
-                this.submitMessage(driver_utils_1.MessageType2.Accept);
+                this.submitMessage(internal_3.MessageType2.Accept);
             }
         }
         this.emit("op", message);
@@ -1441,12 +1443,12 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
     }
     async instantiateRuntime(codeDetails, snapshotTree, pendingLocalState, snapshot) {
-        (0, core_utils_1.assert)(this._runtime?.disposed !== false, 0x0dd /* "Existing runtime not disposed" */);
+        (0, internal_2.assert)(this._runtime?.disposed !== false, 0x0dd /* "Existing runtime not disposed" */);
         // The relative loader will proxy requests to '/' to the loader itself assuming no non-cache flags
         // are set. Global requests will still go directly to the loader
         const maybeLoader = this.scope;
         const loader = new loader_js_1.RelativeLoader(this, maybeLoader.ILoader);
-        const loadCodeResult = await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "CodeLoad" }, async () => this.codeLoader.load(codeDetails));
+        const loadCodeResult = await internal_4.PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "CodeLoad" }, async () => this.codeLoader.load(codeDetails));
         this._loadedModule = {
             module: loadCodeResult.module,
             // An older interface ICodeLoader could return an IFluidModule which didn't have details.
@@ -1461,7 +1463,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
         }
         const existing = snapshotTree !== undefined;
         const context = new containerContext_js_1.ContainerContext(this.options, this.scope, snapshotTree, this._loadedFromVersion, this._deltaManager, this.storageAdapter, this.protocolHandler.quorum, this.protocolHandler.audience, loader, (type, contents, batch, metadata) => this.submitContainerMessage(type, contents, batch, metadata), (summaryOp, referenceSequenceNumber) => this.submitSummaryMessage(summaryOp, referenceSequenceNumber), (batch, referenceSequenceNumber) => this.submitBatch(batch, referenceSequenceNumber), (content, targetClientId) => this.submitSignal(content, targetClientId), (error) => this.dispose(error), (error) => this.close(error), this.updateDirtyContainerState, this.getAbsoluteUrl, () => this.resolvedUrl?.id, () => this.clientId, () => this.attachState, () => this.connected, this._deltaManager.clientDetails, existing, this.subLogger, pendingLocalState, snapshot);
-        this._runtime = await telemetry_utils_1.PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "InstantiateRuntime" }, async () => runtimeFactory.instantiateRuntime(context, existing));
+        this._runtime = await internal_4.PerformanceEvent.timedExecAsync(this.subLogger, { eventName: "InstantiateRuntime" }, async () => runtimeFactory.instantiateRuntime(context, existing));
         this._lifecycleEvents.emit("runtimeInstantiated");
         this._loadedCodeDetails = codeDetails;
     }
@@ -1491,7 +1493,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
                 }
             // intentional fallthrough
             case "delayed":
-                (0, core_utils_1.assert)(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
+                (0, internal_2.assert)(this.inboundQueuePausedFromInit, 0x346 /* inboundQueuePausedFromInit should be true */);
                 this.inboundQueuePausedFromInit = false;
                 this._deltaManager.inbound.resume();
                 this._deltaManager.inboundSignal.resume();
@@ -1499,7 +1501,7 @@ class Container extends telemetry_utils_1.EventEmitterWithErrorHandling {
             case "none":
                 break;
             default:
-                (0, core_utils_1.unreachableCase)(deltaConnectionArg);
+                (0, internal_2.unreachableCase)(deltaConnectionArg);
         }
     }
 }