@fluidframework/driver-utils 2.81.1 → 2.82.0

package/src/adapters/compression/summaryblob/documentStorageServiceSummaryBlobCompressionAdapter.ts

@@ -6,13 +6,13 @@
 import { type Buffer, IsoBuffer } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils/internal";
 import {
-	ISummaryBlob,
-	ISummaryHandle,
-	ISummaryTree,
-	SummaryObject,
+	type ISummaryBlob,
+	type ISummaryHandle,
+	type ISummaryTree,
+	type SummaryObject,
 	SummaryType,
 } from "@fluidframework/driver-definitions";
-import {
+import type {
 	IDocumentStorageService,
 	ISummaryContext,
 	ISnapshotTree,
@@ -74,10 +74,10 @@ export class DocumentStorageServiceCompressionAdapter extends DocumentStorageSer
 	 * @param blob - The maybe compressed blob.
 	 */
 	private static readAlgorithmFromBlob(blob: ArrayBufferLike): number {
-		return !this.hasPrefix(blob)
-			? SummaryCompressionAlgorithm.None
-			: // eslint-disable-next-line no-bitwise
-				IsoBuffer.from(blob)[0] & 0x0f;
+		return this.hasPrefix(blob)
+			? // eslint-disable-next-line no-bitwise
+				IsoBuffer.from(blob)[0] & 0x0f
+			: SummaryCompressionAlgorithm.None;
 	}
 
 	/**
@@ -202,7 +202,7 @@ export class DocumentStorageServiceCompressionAdapter extends DocumentStorageSer
 		} else if (algorithm === SummaryCompressionAlgorithm.None) {
 			maybeCompressed = file;
 		} else if (algorithm === SummaryCompressionAlgorithm.LZ4) {
-			const compressed = compress(file) as ArrayBufferLike;
+			const compressed = compress(file as Uint8Array) as ArrayBufferLike;
 			maybeCompressed = compressed;
 		} else {
 			throw new Error(`Unknown Algorithm ${config.algorithm}`);
@@ -221,8 +221,9 @@ export class DocumentStorageServiceCompressionAdapter extends DocumentStorageSer
 	 */
 	private static decodeBlob(file: ArrayBufferLike): ArrayBufferLike {
 		let decompressed: ArrayBufferLike;
-		let originalBlob;
-		let algorithm;
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any -- TODO: use a real type
+		let originalBlob: any;
+		let algorithm: SummaryCompressionAlgorithm;
 		if (this.hasPrefix(file)) {
 			algorithm = DocumentStorageServiceCompressionAdapter.readAlgorithmFromBlob(file);
 			originalBlob = this.removePrefixFromBlobIfPresent(file);
@@ -231,8 +232,10 @@ export class DocumentStorageServiceCompressionAdapter extends DocumentStorageSer
 			originalBlob = file;
 		}
 		if (algorithm === SummaryCompressionAlgorithm.None) {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 			decompressed = originalBlob;
 		} else if (algorithm === SummaryCompressionAlgorithm.LZ4) {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment
 			decompressed = decompress(originalBlob) as ArrayBufferLike;
 		} else {
 			throw new Error(`Unknown Algorithm ${algorithm}`);
@@ -267,12 +270,13 @@ export class DocumentStorageServiceCompressionAdapter extends DocumentStorageSer
 		}
 		let clone: object | undefined;
 		for (const key of Object.keys(input)) {
-			const value = input[key];
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+			const value: SummaryObject = input[key];
 
 			if (Boolean(value) && typeof value === "object") {
 				const replaced = this.recursivelyReplace(
 					isEncode,
-					value as SummaryObject,
+					value,
 					encoder,
 					decoder,
 					config,
@@ -396,13 +400,13 @@ export class DocumentStorageServiceCompressionAdapter extends DocumentStorageSer
 	 */
 	public override async readBlob(id: string): Promise<ArrayBufferLike> {
 		const originalBlob = await super.readBlob(id);
-		if (!this._isCompressionEnabled) {
-			return originalBlob;
-		} else {
+		if (this._isCompressionEnabled) {
 			const decompressedBlob =
 				DocumentStorageServiceCompressionAdapter.decodeBlob(originalBlob);
 			//			console.log(`Miso summary-blob Blob read END : ${id} ${decompressedBlob.byteLength}`);
 			return decompressedBlob;
+		} else {
+			return originalBlob;
 		}
 	}
 
@@ -451,14 +455,14 @@ export class DocumentStorageServiceCompressionAdapter extends DocumentStorageSer
 	 */
 	public override async downloadSummary(id: ISummaryHandle): Promise<ISummaryTree> {
 		const summary = await super.downloadSummary(id);
-		return !this._isCompressionEnabled
-			? summary
-			: (DocumentStorageServiceCompressionAdapter.recursivelyReplace(
+		return this._isCompressionEnabled
+			? (DocumentStorageServiceCompressionAdapter.recursivelyReplace(
 					false,
 					summary,
 					DocumentStorageServiceCompressionAdapter.blobEncoder,
 					DocumentStorageServiceCompressionAdapter.blobDecoder,
 					this._config,
-				) as ISummaryTree);
+				) as ISummaryTree)
+			: summary;
 	}
 }

package/src/adapters/index.ts

@@ -5,7 +5,7 @@
 
 export {
 	SummaryCompressionAlgorithm,
-	ICompressionStorageConfig,
+	type ICompressionStorageConfig,
 	DefaultCompressionStorageConfig,
 	blobHeadersBlobName,
 } from "./compression/index.js";

package/src/adapters/predefinedAdapters.ts

@@ -4,12 +4,12 @@
  */
 
 import { assert } from "@fluidframework/core-utils/internal";
-import { IDocumentServiceFactory } from "@fluidframework/driver-definitions/internal";
+import type { IDocumentServiceFactory } from "@fluidframework/driver-definitions/internal";
 
 import {
 	DefaultCompressionStorageConfig,
 	DocumentServiceFactoryCompressionAdapter,
-	ICompressionStorageConfig,
+	type ICompressionStorageConfig,
 } from "./compression/index.js";
 
 /**
@@ -67,9 +67,12 @@ function applyStorageCompressionInternal(
  * This method checks whether given objects contains
  * a properties expected for the interface ICompressionStorageConfig.
  */
-export function isCompressionConfig(config: any): config is ICompressionStorageConfig {
+export function isCompressionConfig(config: unknown): config is ICompressionStorageConfig {
 	return (
 		config !== undefined &&
-		(config.algorithm !== undefined || config.minSizeToCompress !== undefined)
+		typeof config === "object" &&
+		config !== null &&
+		((config as Partial<ICompressionStorageConfig>).algorithm !== undefined ||
+			(config as Partial<ICompressionStorageConfig>).minSizeToCompress !== undefined)
 	);
 }

package/src/blob.ts

@@ -3,13 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import {
-	FileMode,
-	IAttachment,
-	IBlob,
-	ITree,
-	TreeEntry,
-} from "@fluidframework/driver-definitions/internal";
+import type { IAttachment, IBlob, ITree } from "@fluidframework/driver-definitions/internal";
+import { FileMode, TreeEntry } from "@fluidframework/driver-definitions/internal";
 
 /**
  * Basic implementation of a blob ITreeEntry
@@ -29,6 +24,7 @@ export class BlobTreeEntry {
 	constructor(
 		public readonly path: string,
 		contents: string,
+		// eslint-disable-next-line unicorn/text-encoding-identifier-case
 		encoding: "utf-8" | "base64" = "utf-8",
 	) {
 		this.value = { contents, encoding };

package/src/buildSnapshotTree.ts

@@ -7,10 +7,10 @@ import { stringToBuffer } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils/internal";
 import {
 	FileMode,
-	IGitTree,
-	IGitTreeEntry,
-	ISnapshotTree,
-	ITreeEntry,
+	type IGitTree,
+	type IGitTreeEntry,
+	type ISnapshotTree,
+	type ITreeEntry,
 	TreeEntry,
 } from "@fluidframework/driver-definitions/internal";
 import { v4 as uuid } from "uuid";
@@ -33,7 +33,7 @@ function flattenCore(
 			blobMap.set(id, buffer);
 
 			const entry: IGitTreeEntry = {
-				mode: FileMode[treeEntry.mode],
+				mode: FileMode[treeEntry.mode] as string,
 				path: subPath,
 				sha: id,
 				size: 0,
@@ -48,7 +48,7 @@ function flattenCore(
 			);
 			const t = treeEntry.value;
 			const entry: IGitTreeEntry = {
-				mode: FileMode[treeEntry.mode],
+				mode: FileMode[treeEntry.mode] as string,
 				path: subPath,
 				sha: "",
 				size: -1,

package/src/cacheUtils.ts

@@ -22,6 +22,6 @@ export const maximumCacheDurationMs: FiveDaysMs = 432_000_000; // 5 days in ms
  * @internal
  */
 export function getKeyForCacheEntry(entry: ICacheEntry): string {
-	const version = entry.file.fileVersion !== undefined ? `_${entry.file.fileVersion}` : "";
+	const version = entry.file.fileVersion === undefined ? "" : `_${entry.file.fileVersion}`;
 	return `${entry.file.docId}${version}_${entry.type}_${entry.key}`;
 }

package/src/documentServiceFactoryProxy.ts

@@ -4,9 +4,9 @@
  */
 
 import type { ILayerCompatDetails } from "@fluid-internal/client-utils";
-import { ITelemetryBaseLogger, type FluidObject } from "@fluidframework/core-interfaces";
-import { ISummaryTree } from "@fluidframework/driver-definitions";
-import {
+import type { ITelemetryBaseLogger, FluidObject } from "@fluidframework/core-interfaces";
+import type { ISummaryTree } from "@fluidframework/driver-definitions";
+import type {
 	IDocumentService,
 	IDocumentServiceFactory,
 	IResolvedUrl,

package/src/documentServiceProxy.ts

@@ -4,8 +4,8 @@
  */
 
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { IClient } from "@fluidframework/driver-definitions";
-import {
+import type { IClient } from "@fluidframework/driver-definitions";
+import type {
 	IDocumentDeltaConnection,
 	IDocumentDeltaStorageService,
 	IDocumentService,
@@ -43,7 +43,7 @@ export abstract class DocumentServiceProxy
 		return this._service.connectToDeltaStream(client);
 	}
 
-	public dispose(error?: any): void {
+	public dispose(error?: unknown): void {
 		this._service.dispose(error);
 	}
 

package/src/documentStorageServiceProxy.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 
-import { ISummaryHandle, ISummaryTree } from "@fluidframework/driver-definitions";
-import {
+import type { ISummaryHandle, ISummaryTree } from "@fluidframework/driver-definitions";
+import type {
 	FetchSource,
 	IDocumentStorageService,
 	IDocumentStorageServicePolicies,
@@ -36,6 +36,7 @@ export class DocumentStorageServiceProxy implements IDocumentStorageService {
 	public async getSnapshotTree(
 		version?: IVersion,
 		scenarioName?: string,
+		// eslint-disable-next-line @rushstack/no-new-null
 	): Promise<ISnapshotTree | null> {
 		return this.internalStorageService.getSnapshotTree(version, scenarioName);
 	}
@@ -50,6 +51,7 @@ export class DocumentStorageServiceProxy implements IDocumentStorageService {
 	}
 
 	public async getVersions(
+		// eslint-disable-next-line @rushstack/no-new-null
 		versionId: string | null,
 		count: number,
 		scenarioName?: string,

package/src/error.ts

@@ -5,9 +5,9 @@
 
 import {
 	DriverErrorTypes,
-	IDriverErrorBase,
+	type IDriverErrorBase,
 } from "@fluidframework/driver-definitions/internal";
-import { IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils/internal";
+import { type IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils/internal";
 
 /**
  * Error indicating an API is being used improperly resulting in an invalid operation.

package/src/index.ts

@@ -18,7 +18,7 @@ export {
 	createGenericNetworkError,
 	createWriteError,
 	DeltaStreamConnectionForbiddenError,
-	DriverErrorTelemetryProps,
+	type DriverErrorTelemetryProps,
 	FluidInvalidSchemaError,
 	GenericNetworkError,
 	getRetryDelayFromError,
@@ -43,9 +43,9 @@ export {
 export { PrefetchDocumentStorageService } from "./prefetchDocumentStorageService.js";
 export { RateLimiter } from "./rateLimiter.js";
 export { readAndParse } from "./readAndParse.js";
-export { calculateMaxWaitTime, IProgress, runWithRetry } from "./runWithRetry.js";
+export { calculateMaxWaitTime, type IProgress, runWithRetry } from "./runWithRetry.js";
 export {
-	CombinedAppAndProtocolSummary,
+	type CombinedAppAndProtocolSummary,
 	getDocAttributesFromProtocolSummary,
 	getQuorumValuesFromProtocolSummary,
 	isCombinedAppAndProtocolSummary,
@@ -53,7 +53,7 @@ export {
 export { convertSummaryTreeToSnapshotITree } from "./treeConversions.js";
 export {
 	applyStorageCompression,
-	ICompressionStorageConfig,
+	type ICompressionStorageConfig,
 	SummaryCompressionAlgorithm,
 	blobHeadersBlobName,
 } from "./adapters/index.js";

package/src/insecureUrlResolver.ts

@@ -3,12 +3,12 @@
  * Licensed under the MIT License.
  */
 
-import { IRequest } from "@fluidframework/core-interfaces";
+import type { IRequest } from "@fluidframework/core-interfaces";
 import { assert } from "@fluidframework/core-utils/internal";
 import {
 	DriverHeader,
-	IResolvedUrl,
-	IUrlResolver,
+	type IResolvedUrl,
+	type IUrlResolver,
 } from "@fluidframework/driver-definitions/internal";
 
 /**
@@ -51,11 +51,11 @@ export class InsecureUrlResolver implements IUrlResolver {
 		// If hosts match then we use the local tenant information. Otherwise we make a REST call out to the hosting
 		// service using our bearer token.
 		if (this.isForNodeTest) {
-			const [, documentId, tmpRelativePath] = parsedUrl.pathname.substr(1).split("/");
+			const [, documentId, tmpRelativePath] = parsedUrl.pathname.slice(1).split("/");
 			const relativePath = tmpRelativePath ?? "";
 			return this.resolveHelper(documentId, relativePath, parsedUrl.search);
 		} else if (parsedUrl.host === window.location.host) {
-			const fullPath = parsedUrl.pathname.substr(1);
+			const fullPath = parsedUrl.pathname.slice(1);
 			const documentId = fullPath.split("/")[0];
 			const documentRelativePath = fullPath.slice(documentId.length);
 			return this.resolveHelper(documentId, documentRelativePath);
@@ -142,13 +142,13 @@ export class InsecureUrlResolver implements IUrlResolver {
 		relativeUrl: string,
 	): Promise<string> {
 		const parsedUrl = new URL(resolvedUrl.url);
-		const [, , documentId] = parsedUrl.pathname?.split("/") ?? [];
+		const documentId = (parsedUrl.pathname?.split("/") ?? [])[2];
 
 		assert(!!documentId, 0x273 /* "Invalid document id from parsed URL" */);
 
 		let url = relativeUrl;
 		if (url.startsWith("/")) {
-			url = url.substr(1);
+			url = url.slice(1);
 		}
 
 		return `${this.hostUrl}/${encodeURIComponent(this.tenantId)}/${encodeURIComponent(

package/src/messageRecognition.ts

@@ -4,8 +4,8 @@
  */
 
 import {
-	ISequencedDocumentMessage,
-	IDocumentMessage,
+	type ISequencedDocumentMessage,
+	type IDocumentMessage,
 	MessageType,
 } from "@fluidframework/driver-definitions/internal";
 
@@ -20,6 +20,8 @@ export function isRuntimeMessage(message: { type: string }): boolean {
 }
 
 /**
+ * Whether the message can be coalesced by the relay service.
+ *
  * @privateRemarks ADO #1385: To be moved to packages/protocol-base/src/protocol.ts
  * @internal
  */

package/src/network.ts

@@ -3,16 +3,16 @@
  * Licensed under the MIT License.
  */
 
-import { ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
+import type { ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
 import {
-	IAuthorizationError,
-	ILocationRedirectionError,
-	IResolvedUrl,
-	IThrottlingWarning,
 	DriverErrorTypes,
-	IDriverErrorBase,
+	type IAuthorizationError,
+	type ILocationRedirectionError,
+	type IResolvedUrl,
+	type IThrottlingWarning,
+	type IDriverErrorBase,
 } from "@fluidframework/driver-definitions/internal";
-import { IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils/internal";
+import { type IFluidErrorBase, LoggingError } from "@fluidframework/telemetry-utils/internal";
 
 /**
  * @internal
@@ -226,6 +226,8 @@ export class ThrottlingError
 }
 
 /**
+ * Creates a non-retryable write error.
+ *
  * @internal
  */
 export const createWriteError = (
@@ -235,6 +237,8 @@ export const createWriteError = (
 	new NonRetryableError(message, DriverErrorTypes.writeError, props);
 
 /**
+ * Creates a generic network error, either throttling or non-throttling based on the provided retry information.
+ *
  * @internal
  */
 export function createGenericNetworkError(
@@ -254,18 +258,28 @@ export function createGenericNetworkError(
  * @param error - The error to inspect for ability to retry
  * @internal
  */
-export const canRetryOnError = (error: any): boolean => error?.canRetry === true;
+export const canRetryOnError = (error: unknown): boolean =>
+	typeof error === "object" &&
+	error !== null &&
+	(error as { canRetry?: boolean }).canRetry === true;
 
 /**
  * Check retryAfterSeconds property on error
  * @internal
  */
-export const getRetryDelaySecondsFromError = (error: any): number | undefined =>
-	error?.retryAfterSeconds as number | undefined;
+export const getRetryDelaySecondsFromError = (error: unknown): number | undefined => {
+	if (typeof error === "object" && error !== null) {
+		const retryAfterSeconds = (error as { retryAfterSeconds?: unknown }).retryAfterSeconds;
+		return typeof retryAfterSeconds === "number" ? retryAfterSeconds : undefined;
+	}
+	return undefined;
+};
 
 /**
  * Check retryAfterSeconds property on error and convert to ms
  * @internal
  */
-export const getRetryDelayFromError = (error: any): number | undefined =>
-	error?.retryAfterSeconds !== undefined ? error.retryAfterSeconds * 1000 : undefined;
+export const getRetryDelayFromError = (error: unknown): number | undefined => {
+	const retryAfterSeconds = getRetryDelaySecondsFromError(error);
+	return retryAfterSeconds === undefined ? undefined : retryAfterSeconds * 1000;
+};

package/src/networkUtils.ts

@@ -3,29 +3,37 @@
  * Licensed under the MIT License.
  */
 
-import type { ITelemetryErrorEventExt } from "@fluidframework/telemetry-utils/internal";
-import { ITelemetryLoggerExt } from "@fluidframework/telemetry-utils/internal";
+import type {
+	ITelemetryErrorEventExt,
+	ITelemetryLoggerExt,
+} from "@fluidframework/telemetry-utils/internal";
 
 import { OnlineStatus, canRetryOnError, isOnline } from "./network.js";
 
 /**
+ * Logs a network failure with additional context about online status and retry capability for the provided event.
+ *
  * @internal
  */
 export function logNetworkFailure(
 	logger: ITelemetryLoggerExt,
 	event: ITelemetryErrorEventExt,
-	error?: any,
+	error?: unknown,
 ): void {
 	const newEvent = { ...event };
 
-	const errorOnlineProp = error?.online;
+	// TODO: better typing
+	const errorOnlineProp = (error as { online?: unknown })?.online;
 	newEvent.online =
 		typeof errorOnlineProp === "string" ? errorOnlineProp : OnlineStatus[isOnline()];
 
 	if (typeof navigator === "object" && navigator !== null) {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any -- TODO: use a real type
 		const nav = navigator as any;
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
 		const connection = nav.connection ?? nav.mozConnection ?? nav.webkitConnection;
 		if (connection !== null && typeof connection === "object") {
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
 			newEvent.connectionType = connection.type;
 		}
 	}

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/driver-utils";
-export const pkgVersion = "2.81.1";
+export const pkgVersion = "2.82.0";

package/src/parallelRequests.ts

@@ -4,16 +4,16 @@
  */
 
 import { performanceNow } from "@fluid-internal/client-utils";
-import { ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
+import type { ITelemetryBaseProperties } from "@fluidframework/core-interfaces";
 import { assert, Deferred } from "@fluidframework/core-utils/internal";
-import {
+import type {
 	IDeltasFetchResult,
 	IStream,
 	IStreamResult,
 	ISequencedDocumentMessage,
 } from "@fluidframework/driver-definitions/internal";
 import {
-	ITelemetryLoggerExt,
+	type ITelemetryLoggerExt,
 	PerformanceEvent,
 } from "@fluidframework/telemetry-utils/internal";
 
@@ -164,10 +164,8 @@ export class ParallelRequests<T> {
 		}
 
 		const from = this.latestRequested;
-		if (this.to !== undefined) {
-			if (this.to <= from) {
-				return undefined;
-			}
+		if (this.to !== undefined && this.to <= from) {
+			return undefined;
 		}
 
 		// this.latestRequested
@@ -237,7 +235,7 @@ export class ParallelRequests<T> {
 				// If it pops into our view a lot, we would need to reconsider how we approach it.
 				// Note that this is not visible to user other than potentially not hitting 100% of
 				// what we can in perf domain.
-				if (payload.length !== 0) {
+				if (payload.length > 0) {
 					this.logger.sendErrorEvent({
 						eventName: "ParallelRequests_GotExtra",
 						from,
@@ -255,7 +253,25 @@ export class ParallelRequests<T> {
 				const length = payload.length;
 				let fullChunk = requestedLength <= length; // we can possible get more than we asked.
 
-				if (length !== 0) {
+				if (length === 0) {
+					// 1. empty (partial) chunks should not be returned by various caching / adapter layers -
+					//    they should fall back to next layer. This might be important invariant to hold to ensure
+					//    that we are less likely have bugs where such layer would keep returning empty partial
+					//    result on each call.
+					// 2. Current invariant is that callback does retries until it gets something,
+					//    with the goal of failing if zero data is retrieved in given amount of time.
+					//    This is very specific property of storage / ops, so this logic is not here, but given only
+					//    one user of this class, we assert that to catch issues earlier.
+					// These invariant can be relaxed if needed.
+					assert(
+						!partial,
+						0x10f /* "empty/partial chunks should not be returned by caching" */,
+					);
+					assert(
+						!this.knewTo,
+						0x110 /* "callback should retry until valid fetch before it learns new boundary" */,
+					);
+				} else {
 					// We can get more than we asked for!
 					// This can screw up logic in dispatch!
 					// So push only batch size, and keep the rest for later - if conditions are favorable, we
@@ -274,24 +290,6 @@ export class ParallelRequests<T> {
 					const data = payload.splice(0, requestedLength);
 					this.results.set(from, data);
 					from += data.length;
-				} else {
-					// 1. empty (partial) chunks should not be returned by various caching / adapter layers -
-					//    they should fall back to next layer. This might be important invariant to hold to ensure
-					//    that we are less likely have bugs where such layer would keep returning empty partial
-					//    result on each call.
-					// 2. Current invariant is that callback does retries until it gets something,
-					//    with the goal of failing if zero data is retrieved in given amount of time.
-					//    This is very specific property of storage / ops, so this logic is not here, but given only
-					//    one user of this class, we assert that to catch issues earlier.
-					// These invariant can be relaxed if needed.
-					assert(
-						!partial,
-						0x10f /* "empty/partial chunks should not be returned by caching" */,
-					);
-					assert(
-						!this.knewTo,
-						0x110 /* "callback should retry until valid fetch before it learns new boundary" */,
-					);
 				}
 
 				if (!partial && !fullChunk) {
@@ -319,7 +317,7 @@ export class ParallelRequests<T> {
 				if (to === this.latestRequested) {
 					// we can go after full chunk at the end if we received partial chunk, or more than asked
 					// Also if we got more than we asked to, we can actually use those ops!
-					while (payload.length !== 0) {
+					while (payload.length > 0) {
 						const data = payload.splice(0, requestedLength);
 						this.results.set(from, data);
 						from += data.length;
@@ -358,7 +356,7 @@ export class Queue<T> implements IStream<T> {
 		this.pushCore(Promise.resolve({ done: false, value }));
 	}
 
-	public pushError(error: any): void {
+	public pushError(error: unknown): void {
 		// eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
 		this.pushCore(Promise.reject(error));
 		this.done = true;
@@ -445,7 +443,7 @@ async function getSingleOpBatch(
 
 			// If we got messages back, return them.  Return regardless of whether we got messages back if we didn't
 			// specify a "to", since we don't have an expectation of how many to receive.
-			if (messages.length !== 0 || !strongTo) {
+			if (messages.length > 0 || !strongTo) {
 				// Report this event if we waited to fetch ops due to being offline or throttling.
 				telemetryEvent?.end({
 					duration: totalRetryAfterTime,
@@ -670,6 +668,8 @@ export const emptyMessageStream: IStream<ISequencedDocumentMessage[]> = {
 };
 
 /**
+ * Creates a stream from the provided promise of messages.
+ *
  * @internal
  */
 export function streamFromMessages(
@@ -682,6 +682,7 @@ export function streamFromMessages(
 				return { done: true };
 			}
 			const value = await messages;
+			// eslint-disable-next-line require-atomic-updates
 			messages = undefined;
 			return value.length === 0 ? { done: true } : { done: false, value };
 		},
@@ -689,6 +690,8 @@ export function streamFromMessages(
 }
 
 /**
+ * Wraps the provided stream to observe values as they are read.
+ *
  * @internal
  */
 export function streamObserver<T>(