Improve network usage for small text changes (#166)

frontend/sync-client/package.json

@@ -16,7 +16,7 @@
         "byte-base64": "^1.1.0",
         "minimatch": "^10.0.1",
         "p-queue": "^8.1.0",
-        "reconcile-text": "^0.5.0",
+        "reconcile-text": "^0.7.1",
         "uuid": "^13.0.0"
     },
     "devDependencies": {

frontend/sync-client/src/file-operations/file-operations.ts

@@ -3,8 +3,9 @@ import type { FileSystemOperations } from "./filesystem-operations";
 import type { Database, RelativePath } from "../persistence/database";
 import { SafeFileSystemOperations } from "./safe-filesystem-operations";
 import type { TextWithCursors } from "reconcile-text";
-import { isBinary, reconcile } from "reconcile-text";
+import { reconcile } from "reconcile-text";
 import { isFileTypeMergable } from "../utils/is-file-type-mergable";
+import { isBinary } from "../utils/is-binary";
 
 export class FileOperations {
 	private static readonly PARENTHESES_REGEX = / \((\d+)\)$/;

frontend/sync-client/src/services/sync-service.ts

@@ -16,6 +16,7 @@ import type { DocumentVersion } from "./types/DocumentVersion";
 import type { FetchLatestDocumentsResponse } from "./types/FetchLatestDocumentsResponse";
 import type { PingResponse } from "./types/PingResponse";
 import type { DeleteDocumentVersion } from "./types/DeleteDocumentVersion";
+import type { UpdateTextDocumentVersion } from "./types/UpdateTextDocumentVersion";
 
 export interface CheckConnectionResult {
 	isSuccessful: boolean;
@@ -102,7 +103,59 @@ export class SyncService {
 		});
 	}
 
-	public async put({
+	public async putText({
+		parentVersionId,
+		documentId,
+		relativePath,
+		content
+	}: {
+		parentVersionId: VaultUpdateId;
+		documentId: DocumentId;
+		relativePath: RelativePath;
+		content: (number | string)[];
+	}): Promise<DocumentUpdateResponse> {
+		return this.withRetries(async () => {
+			this.logger.debug(
+				`Updating text document ${documentId} with parent version ${parentVersionId} and relative path ${relativePath}`
+			);
+
+			const request: UpdateTextDocumentVersion = {
+				parentVersionId,
+				relativePath,
+				content
+			};
+
+			const response = await this.client(
+				this.getUrl(`/documents/${documentId}/text`),
+				{
+					method: "PUT",
+					body: JSON.stringify(request),
+					headers: this.getDefaultHeaders({ type: "json" })
+				}
+			);
+
+			const result: SerializedError | DocumentUpdateResponse =
+				(await response.json()) as  // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+					| SerializedError
+					| DocumentUpdateResponse;
+
+			if ("errorType" in result) {
+				throw new Error(
+					`Failed to update document: ${SyncService.formatError(result)}`
+				);
+			}
+
+			this.logger.debug(
+				`Updated document ${JSON.stringify(result)} with id ${
+					result.documentId
+				}}`
+			);
+
+			return result;
+		});
+	}
+
+	public async putBinary({
 		parentVersionId,
 		documentId,
 		relativePath,
@@ -115,7 +168,7 @@ export class SyncService {
 	}): Promise<DocumentUpdateResponse> {
 		return this.withRetries(async () => {
 			this.logger.debug(
-				`Updating document ${documentId} with parent version ${parentVersionId} and relative path ${relativePath}`
+				`Updating binary document ${documentId} with parent version ${parentVersionId} and relative path ${relativePath}`
 			);
 			const formData = new FormData();
 			formData.append("parent_version_id", parentVersionId.toString());
@@ -126,7 +179,7 @@ export class SyncService {
 			);
 
 			const response = await this.client(
-				this.getUrl(`/documents/${documentId}`),
+				this.getUrl(`/documents/${documentId}/binary`),
 				{
 					method: "PUT",
 					body: formData,
@@ -171,10 +224,7 @@ export class SyncService {
 				{
 					method: "DELETE",
 					body: JSON.stringify(request),
-					headers: {
-						"Content-Type": "application/json",
-						...this.getDefaultHeaders()
-					}
+					headers: this.getDefaultHeaders({ type: "json" })
 				}
 			);
 
@@ -297,11 +347,19 @@ export class SyncService {
 		return `${safeRemoteUri}/vaults/${vaultName}${path}`;
 	}
 
-	private getDefaultHeaders(): Record<string, string> {
-		return {
+	private getDefaultHeaders(
+		{ type }: { type?: "json" } = { type: undefined }
+	): Record<string, string> {
+		const headers: Record<string, string> = {
 			"device-id": this.deviceId,
 			authorization: `Bearer ${this.settings.getSettings().token}`
 		};
+
+		if (type === "json") {
+			headers["Content-Type"] = "application/json";
+		}
+
+		return headers;
 	}
 
 	private async withRetries<T>(fn: () => Promise<T>): Promise<T> {

frontend/sync-client/src/services/types/UpdateTextDocumentVersion.ts

@@ -0,0 +1,7 @@
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export interface UpdateTextDocumentVersion {
+	parentVersionId: number;
+	relativePath: string;
+	content: (number | string)[];
+}

frontend/sync-client/src/sync-client.ts

@@ -21,13 +21,13 @@ import { CursorTracker } from "./sync-operations/cursor-tracker";
 import type { CursorSpan } from "./services/types/CursorSpan";
 import type { MaybeOutdatedClientCursors } from "./types/maybe-outdated-client-cursors";
 import { FileChangeNotifier } from "./sync-operations/file-change-notifier";
+import { FixedSizeDocumentCache } from "./utils/fix-sized-cache";
 
 export class SyncClient {
 	private static readonly MINIMUM_SAVE_INTERVAL_MS = 1000;
 	private hasStartedOfflineSync = false;
 	private hasFinishedOfflineSync = false;
 
-	// eslint-disable-next-line @typescript-eslint/max-params
 	private constructor(
 		private readonly history: SyncHistory,
 		private readonly settings: Settings,
@@ -135,13 +135,15 @@ export class SyncClient {
 			nativeLineEndings
 		);
 
+		const contentCache = new FixedSizeDocumentCache(1024 * 1024 * 2); // 2 MB cache
 		const unrestrictedSyncer = new UnrestrictedSyncer(
 			logger,
 			database,
 			settings,
 			syncService,
 			fileOperations,
-			history
+			history,
+			contentCache
 		);
 
 		const syncer = new Syncer(
@@ -150,7 +152,8 @@ export class SyncClient {
 			settings,
 			syncService,
 			fileOperations,
-			unrestrictedSyncer
+			unrestrictedSyncer,
+			contentCache
 		);
 
 		const webSocketManager = new WebSocketManager(

frontend/sync-client/src/sync-operations/syncer.ts

@@ -17,6 +17,7 @@ import { createPromise } from "../utils/create-promise";
 import { SyncResetError } from "../services/sync-reset-error";
 import { Locks } from "../utils/locks";
 import type { DocumentVersionWithoutContent } from "../services/types/DocumentVersionWithoutContent";
+import type { FixedSizeDocumentCache } from "../utils/fix-sized-cache";
 
 export class Syncer {
 	private readonly remoteDocumentsLock: Locks<DocumentId>;
@@ -33,7 +34,8 @@ export class Syncer {
 		settings: Settings,
 		private readonly syncService: SyncService,
 		private readonly operations: FileOperations,
-		private readonly internalSyncer: UnrestrictedSyncer
+		private readonly internalSyncer: UnrestrictedSyncer,
+		private readonly contentCache: FixedSizeDocumentCache
 	) {
 		this.syncQueue = new PQueue({
 			concurrency: settings.getSettings().syncConcurrency
@@ -250,6 +252,7 @@ export class Syncer {
 
 	public async reset(): Promise<void> {
 		await this.waitUntilFinished();
+		this.contentCache.clear();
 	}
 
 	public async syncRemotelyUpdatedFile(

frontend/sync-client/src/sync-operations/unrestricted-syncer.ts

@@ -4,6 +4,7 @@ import type {
 	RelativePath
 } from "../persistence/database";
 
+import { diff } from "reconcile-text";
 import type { SyncService } from "../services/sync-service";
 import type { Logger } from "../tracing/logger";
 import type {
@@ -27,6 +28,9 @@ import { globsToRegexes } from "../utils/globs-to-regexes";
 import type { DocumentVersion } from "../services/types/DocumentVersion";
 import type { DocumentUpdateResponse } from "../services/types/DocumentUpdateResponse";
 import type { DocumentVersionWithoutContent } from "../services/types/DocumentVersionWithoutContent";
+import type { FixedSizeDocumentCache } from "../utils/fix-sized-cache";
+import { isFileTypeMergable } from "../utils/is-file-type-mergable";
+import { isBinary } from "../utils/is-binary";
 
 export class UnrestrictedSyncer {
 	private ignorePatterns: RegExp[];
@@ -37,7 +41,8 @@ export class UnrestrictedSyncer {
 		private readonly settings: Settings,
 		private readonly syncService: SyncService,
 		private readonly operations: FileOperations,
-		private readonly history: SyncHistory
+		private readonly history: SyncHistory,
+		private readonly contentCache: FixedSizeDocumentCache
 	) {
 		this.ignorePatterns = globsToRegexes(
 			this.settings.getSettings().ignorePatterns,
@@ -87,8 +92,12 @@ export class UnrestrictedSyncer {
 				},
 				document
 			);
-
 			this.database.addSeenUpdateId(response.vaultUpdateId);
+			this.updateCache(
+				response.vaultUpdateId,
+				contentBytes,
+				response.relativePath
+			);
 
 			this.history.addHistoryEntry({
 				status: SyncStatus.SUCCESS,
@@ -178,12 +187,32 @@ export class UnrestrictedSyncer {
 				undefined;
 
 			if (areThereLocalChanges) {
-				response = await this.syncService.put({
-					documentId: document.documentId,
-					parentVersionId: document.metadata.parentVersionId,
-					relativePath: document.relativePath,
-					contentBytes
-				});
+				const isText =
+					!isBinary(contentBytes) &&
+					isFileTypeMergable(document.relativePath);
+				const cachedVersion = this.contentCache.get(
+					document.metadata.parentVersionId
+				);
+
+				response =
+					isText && cachedVersion !== undefined
+						? await this.syncService.putText({
+								documentId: document.documentId,
+								parentVersionId:
+									document.metadata.parentVersionId,
+								relativePath: document.relativePath,
+								content: diff(
+									new TextDecoder().decode(cachedVersion),
+									new TextDecoder().decode(contentBytes)
+								)
+							})
+						: await this.syncService.putBinary({
+								documentId: document.documentId,
+								parentVersionId:
+									document.metadata.parentVersionId,
+								relativePath: document.relativePath,
+								contentBytes
+							});
 			} else {
 				if (!force) {
 					this.logger.debug(
@@ -274,12 +303,16 @@ export class UnrestrictedSyncer {
 					},
 					document
 				);
-
 				await this.operations.write(
 					actualPath,
 					contentBytes,
 					responseBytes
 				);
+				this.updateCache(
+					response.vaultUpdateId,
+					responseBytes,
+					actualPath
+				);
 
 				if (!force) {
 					this.history.addHistoryEntry({
@@ -297,6 +330,11 @@ export class UnrestrictedSyncer {
 					},
 					document
 				);
+				this.updateCache(
+					response.vaultUpdateId,
+					contentBytes,
+					actualPath
+				);
 			}
 
 			this.database.addSeenUpdateId(response.vaultUpdateId);
@@ -423,6 +461,11 @@ export class UnrestrictedSyncer {
 				remoteVersion.relativePath,
 				contentBytes
 			);
+			this.updateCache(
+				remoteVersion.vaultUpdateId,
+				contentBytes,
+				remoteVersion.relativePath
+			);
 
 			resolve();
 			this.database.removeDocumentPromise(promise);
@@ -513,4 +556,14 @@ export class UnrestrictedSyncer {
 			};
 		}
 	}
+
+	private updateCache(
+		updateId: number,
+		contentBytes: Uint8Array,
+		filePath: RelativePath
+	): void {
+		if (isFileTypeMergable(filePath) && !isBinary(contentBytes)) {
+			this.contentCache.put(updateId, contentBytes);
+		}
+	}
 }

frontend/sync-client/src/utils/fix-sized-cache.test.ts

@@ -0,0 +1,239 @@
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { FixedSizeDocumentCache } from "./fix-sized-cache";
+
+describe("fixedSizeDocumentCache", () => {
+	it("happyPath", async () => {
+		const cache = new FixedSizeDocumentCache(4);
+		const doc1 = new Uint8Array([1, 2]);
+		const doc2 = new Uint8Array([3, 4]);
+		const doc3 = new Uint8Array([5, 6]);
+
+		cache.put(1, doc1);
+		assert.equal(cache.get(1), doc1);
+		cache.put(2, doc2);
+		assert.equal(cache.get(1), doc1);
+		assert.equal(cache.get(2), doc2);
+		cache.put(3, doc3);
+		assert.equal(cache.get(1), undefined);
+		assert.equal(cache.get(2), doc2);
+		assert.equal(cache.get(3), doc3);
+	});
+
+	it("updateExistingEntry", async () => {
+		const cache = new FixedSizeDocumentCache(4);
+		const doc1_v1 = new Uint8Array([1, 2]);
+		const doc1_v2 = new Uint8Array([3, 4]);
+		const doc2 = new Uint8Array([5, 6]);
+
+		cache.put(1, doc1_v1);
+		assert.equal(cache.get(1), doc1_v1);
+		cache.put(2, doc2);
+		assert.equal(cache.get(1), doc1_v1);
+		assert.equal(cache.get(2), doc2);
+		cache.put(1, doc1_v2); // Update doc1
+		assert.equal(cache.get(1), doc1_v2);
+		assert.equal(cache.get(2), doc2);
+	});
+
+	it("evictOldestEntry", async () => {
+		const cache = new FixedSizeDocumentCache(4);
+		const doc1 = new Uint8Array([1, 2]);
+		const doc2 = new Uint8Array([3, 4]);
+		const doc3 = new Uint8Array([5, 6]);
+
+		cache.put(1, doc1);
+		cache.put(2, doc2);
+		assert.equal(cache.get(2), doc2);
+		assert.equal(cache.get(1), doc1);
+		cache.put(3, doc3);
+		assert.equal(cache.get(1), doc1);
+		assert.equal(cache.get(2), undefined);
+		assert.equal(cache.get(3), doc3);
+	});
+
+	it("tooLargeEntry", async () => {
+		const cache = new FixedSizeDocumentCache(2);
+		const doc1 = new Uint8Array([1, 2, 3]);
+
+		cache.put(1, doc1);
+		assert.equal(cache.get(1), undefined);
+	});
+
+	it("multipleEvictionsInSinglePut", async () => {
+		const cache = new FixedSizeDocumentCache(10);
+		const doc1 = new Uint8Array([1, 2]);
+		const doc2 = new Uint8Array([3, 4]);
+		const doc3 = new Uint8Array([5, 6]);
+		const doc4 = new Uint8Array([7, 8, 9, 10, 11, 12, 13, 14]); // 8 bytes
+
+		cache.put(1, doc1);
+		cache.put(2, doc2);
+		cache.put(3, doc3);
+		// Cache now has 6 bytes total
+
+		cache.put(4, doc4); // Should evict doc1 and doc2 to make room (total: 2+8=10)
+		assert.equal(cache.get(1), undefined); // Evicted
+		assert.equal(cache.get(2), undefined); // Evicted
+		assert.equal(cache.get(3), doc3); // Still present
+		assert.equal(cache.get(4), doc4);
+	});
+
+	it("clearCache", async () => {
+		const cache = new FixedSizeDocumentCache(10);
+		const doc1 = new Uint8Array([1, 2]);
+		const doc2 = new Uint8Array([3, 4]);
+
+		cache.put(1, doc1);
+		cache.put(2, doc2);
+		assert.equal(cache.get(1), doc1);
+		assert.equal(cache.get(2), doc2);
+
+		cache.clear();
+		assert.equal(cache.get(1), undefined);
+		assert.equal(cache.get(2), undefined);
+
+		// Should be able to add entries after clear
+		cache.put(3, doc1);
+		assert.equal(cache.get(3), doc1);
+	});
+
+	it("getNonExistentKey", async () => {
+		const cache = new FixedSizeDocumentCache(10);
+		const doc1 = new Uint8Array([1, 2]);
+		cache.put(1, doc1);
+		assert.equal(cache.get(999), undefined);
+	});
+
+	it("updateEntryWithDifferentSizeTriggeringEviction", async () => {
+		const cache = new FixedSizeDocumentCache(6);
+		const doc1_v1 = new Uint8Array([1, 2]);
+		const doc1_v2 = new Uint8Array([1, 2, 3, 4]); // Larger version
+		const doc2 = new Uint8Array([5, 6]);
+		const doc3 = new Uint8Array([7, 8]);
+
+		cache.put(1, doc1_v1);
+		cache.put(2, doc2);
+		cache.put(3, doc3);
+
+		// Update doc1 with larger version, should evict doc2
+		cache.put(1, doc1_v2);
+
+		assert.equal(cache.get(1), doc1_v2);
+		assert.equal(cache.get(2), undefined); // Evicted
+		assert.equal(cache.get(3), doc3);
+	});
+
+	it("singleItemCache", async () => {
+		const cache = new FixedSizeDocumentCache(2);
+		const doc1 = new Uint8Array([1, 2]);
+		const doc2 = new Uint8Array([3, 4]);
+
+		cache.put(1, doc1);
+		assert.equal(cache.get(1), doc1);
+
+		cache.put(2, doc2);
+		assert.equal(cache.get(1), undefined); // Evicted
+		assert.equal(cache.get(2), doc2);
+	});
+
+	it("multipleGetsOnSameEntry", async () => {
+		const cache = new FixedSizeDocumentCache(4);
+		const doc1 = new Uint8Array([1, 2]);
+		const doc2 = new Uint8Array([3, 4]);
+		const doc3 = new Uint8Array([5, 6]);
+
+		cache.put(1, doc1);
+		cache.put(2, doc2);
+
+		// Multiple gets on doc1
+		cache.get(1);
+		cache.get(1);
+		cache.get(1);
+
+		// Order should be: 2 (LRU), 1 (MRU)
+		cache.put(3, doc3);
+
+		assert.equal(cache.get(1), doc1);
+		assert.equal(cache.get(2), undefined); // Evicted
+		assert.equal(cache.get(3), doc3);
+	});
+
+	it("exactlySizedEntry", async () => {
+		const cache = new FixedSizeDocumentCache(4);
+		const doc1 = new Uint8Array([1, 2, 3, 4]); // Exactly cache size
+
+		cache.put(1, doc1);
+		assert.equal(cache.get(1), doc1);
+
+		const doc2 = new Uint8Array([5, 6]);
+		cache.put(2, doc2);
+
+		// doc1 should be evicted to make room for doc2
+		assert.equal(cache.get(1), undefined);
+		assert.equal(cache.get(2), doc2);
+	});
+
+	it("updateEntryMakesItMostRecent", async () => {
+		const cache = new FixedSizeDocumentCache(6);
+		const doc1_v1 = new Uint8Array([1, 2]);
+		const doc1_v2 = new Uint8Array([3, 4]);
+		const doc2 = new Uint8Array([5, 6]);
+		const doc3 = new Uint8Array([7, 8]);
+		const doc4 = new Uint8Array([9, 10]);
+
+		cache.put(1, doc1_v1);
+		cache.put(2, doc2);
+		cache.put(3, doc3);
+
+		// Update doc1 (should move it to most recent)
+		cache.put(1, doc1_v2);
+
+		// Order should be: 2 (LRU), 3, 1 (MRU)
+		// Adding doc4 should evict doc2
+		cache.put(4, doc4);
+
+		assert.equal(cache.get(1), doc1_v2);
+		assert.equal(cache.get(2), undefined); // Evicted
+		assert.equal(cache.get(3), doc3);
+		assert.equal(cache.get(4), doc4);
+	});
+
+	it("alternatingAccessPattern", async () => {
+		const cache = new FixedSizeDocumentCache(4);
+		const doc1 = new Uint8Array([1, 2]);
+		const doc2 = new Uint8Array([3, 4]);
+		const doc3 = new Uint8Array([5, 6]);
+
+		cache.put(1, doc1);
+		cache.put(2, doc2);
+
+		// Alternate access between doc1 and doc2
+		cache.get(1);
+		cache.get(2);
+		cache.get(1);
+		cache.get(2);
+
+		// Order should be: 1, 2 (MRU)
+		cache.put(3, doc3);
+
+		assert.equal(cache.get(1), undefined); // Evicted
+		assert.equal(cache.get(2), doc2);
+		assert.equal(cache.get(3), doc3);
+	});
+
+	it("zeroByteDocs", async () => {
+		const cache = new FixedSizeDocumentCache(2);
+		const doc1 = new Uint8Array([]);
+		const doc2 = new Uint8Array([]);
+		const doc3 = new Uint8Array([1, 2]);
+
+		cache.put(1, doc1);
+		cache.put(2, doc2);
+		cache.put(3, doc3);
+
+		assert.equal(cache.get(1), doc1);
+		assert.equal(cache.get(2), doc2);
+		assert.equal(cache.get(3), doc3);
+	});
+});

frontend/sync-client/src/utils/fix-sized-cache.ts

@@ -0,0 +1,113 @@
+// Implements an in-memory fixed-size cache for document contents,
+
+import type { VaultUpdateId } from "../persistence/database";
+
+// Doubly-linked list node for O(1) LRU operations
+class LRUNode {
+	public constructor(
+		public key: VaultUpdateId,
+		public value: Uint8Array,
+		public prev: LRUNode | null = null,
+		public next: LRUNode | null = null
+	) {}
+}
+
+// evicting the least recently used documents when the size limit is exceeded.
+export class FixedSizeDocumentCache {
+	private readonly maxSizeInBytes: number;
+	private currentSizeInBytes: number;
+	private readonly cache: Map<VaultUpdateId, LRUNode>;
+	private head: LRUNode | null; // Least recently used
+	private tail: LRUNode | null; // Most recently used
+
+	public constructor(maxSizeInBytes: number) {
+		this.maxSizeInBytes = maxSizeInBytes;
+		this.currentSizeInBytes = 0;
+		this.cache = new Map();
+		this.head = null;
+		this.tail = null;
+	}
+
+	public get(updateId: VaultUpdateId): Uint8Array | undefined {
+		const node = this.cache.get(updateId);
+		if (node) {
+			this.moveToTail(node);
+			return node.value;
+		}
+
+		return undefined;
+	}
+
+	public put(updateId: VaultUpdateId, content: Uint8Array): void {
+		if (content.byteLength > this.maxSizeInBytes) {
+			// Document is too large to fit in the cache
+			return;
+		}
+
+		// If the document is already in the cache, update it
+		const existingNode = this.cache.get(updateId);
+		if (existingNode != null) {
+			this.currentSizeInBytes -= existingNode.value.byteLength;
+			this.removeNode(existingNode);
+			this.cache.delete(updateId);
+		}
+
+		const newNode = new LRUNode(updateId, content);
+		this.cache.set(updateId, newNode);
+		this.addToTail(newNode);
+		this.currentSizeInBytes += content.byteLength;
+
+		// Evict least recently used documents if over size limit
+		while (this.currentSizeInBytes > this.maxSizeInBytes && this.head) {
+			const lruNode = this.head;
+			this.removeNode(lruNode);
+			this.cache.delete(lruNode.key);
+			this.currentSizeInBytes -= lruNode.value.byteLength;
+		}
+	}
+
+	public clear(): void {
+		this.cache.clear();
+		this.head = null;
+		this.tail = null;
+		this.currentSizeInBytes = 0;
+	}
+
+	private removeNode(node: LRUNode): void {
+		if (node.prev) {
+			node.prev.next = node.next;
+		} else {
+			this.head = node.next;
+		}
+
+		if (node.next) {
+			node.next.prev = node.prev;
+		} else {
+			this.tail = node.prev;
+		}
+
+		node.prev = null;
+		node.next = null;
+	}
+
+	private addToTail(node: LRUNode): void {
+		node.prev = this.tail;
+		node.next = null;
+
+		if (this.tail) {
+			this.tail.next = node;
+		}
+
+		this.tail = node;
+
+		this.head ??= node;
+	}
+
+	private moveToTail(node: LRUNode): void {
+		if (node === this.tail) {
+			return;
+		}
+		this.removeNode(node);
+		this.addToTail(node);
+	}
+}

frontend/sync-client/src/utils/is-binary.ts

@@ -0,0 +1,16 @@
+// Text is unlikely to contain null bytes, so we can use that to distinguish binary files.
+export function isBinary(content: Uint8Array): boolean {
+	for (const byte of content) {
+		if (byte === 0) {
+			return true;
+		}
+	}
+
+	try {
+		new TextDecoder("utf-8", { fatal: true }).decode(content);
+	} catch {
+		return true;
+	}
+
+	return false;
+}