@devries-cameron20 / t3code-1 / commits / d38055656e
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

perf(web): skip oversized TAR preview payload copies (#34301)

Co-authored-by: Julius Marminge <julius0216@outlook.com>

Lakshmi Tanmay committed Nov 15, 2026 at 01:56 UTC d38055656e0018694afb6ac9a902582db34f4d51
2 files changed +110 -5
apps/web/src/components/files/binaryPreview.worker.test.ts new
+104
@@ -0,0 +1,104 @@
1 +import { expect, it, vi } from "vite-plus/test";
2 +
3 +import {
4 + ARCHIVE_ENTRY_MAX_BYTES,
5 + type BinaryWorkerRequest,
6 + type BinaryWorkerResult,
7 +} from "./binaryPreviewProtocol";
8 +
9 +it.each([ARCHIVE_ENTRY_MAX_BYTES, ARCHIVE_ENTRY_MAX_BYTES + 1])(
10 + "only copies previewable TAR payloads with a %i-byte entry",
11 + async (size) => {
12 + const encode = (value: string) => new TextEncoder().encode(value);
13 + const large = new Uint8Array(size).fill(97);
14 + const entries = [
15 + { path: "before.txt", bytes: encode("before") },
16 + { path: "large.txt", bytes: large },
17 + { path: "empty.txt", bytes: new Uint8Array() },
18 + { path: "large-link.txt", bytes: new Uint8Array(), link: "large.txt" },
19 + { path: "after.txt", bytes: encode("after") },
20 + ];
21 + const contents = (entry: (typeof entries)[number]) => (entry.link ? large : entry.bytes);
22 + const bytes = new Uint8Array(
23 + entries.reduce(
24 + (length, entry) => length + 512 + Math.ceil(entry.bytes.length / 512) * 512,
25 + 1024,
26 + ),
27 + );
28 + let offset = 0;
29 + for (const entry of entries) {
30 + const write = (position: number, value: string) =>
31 + bytes.set(encode(value), offset + position);
32 + write(0, entry.path);
33 + write(124, entry.bytes.length.toString(8).padStart(11, "0") + "\0");
34 + write(136, "00000000000\0");
35 + bytes.fill(32, offset + 148, offset + 156);
36 + write(156, entry.link ? "1" : "0");
37 + if (entry.link) write(157, entry.link);
38 + write(
39 + 148,
40 + bytes
41 + .subarray(offset, offset + 512)
42 + .reduce((sum, byte) => sum + byte, 0)
43 + .toString(8)
44 + .padStart(6, "0") + "\0 ",
45 + );
46 + bytes.set(entry.bytes, offset + 512);
47 + offset += 512 + Math.ceil(entry.bytes.length / 512) * 512;
48 + }
49 +
50 + const worker = new EventTarget();
51 + let receive = (_result: BinaryWorkerResult) => {};
52 + vi.stubGlobal(
53 + "self",
54 + Object.assign(worker, { postMessage: (result: BinaryWorkerResult) => receive(result) }),
55 + );
56 + try {
57 + vi.resetModules();
58 + await import("./binaryPreview.worker");
59 + const request = (input: BinaryWorkerRequest) =>
60 + new Promise<BinaryWorkerResult>((resolve) => {
61 + receive = resolve;
62 + worker.dispatchEvent(new MessageEvent("message", { data: input }));
63 + });
64 + using copies = vi.spyOn(Uint8Array.prototype, "slice");
65 + expect(
66 + await request({ type: "open", kind: "archive", name: "mixed.tar", bytes: bytes.buffer }),
67 + ).toEqual({
68 + type: "archive",
69 + entries: entries.map((entry) => ({
70 + path: entry.path,
71 + size: contents(entry).length,
72 + directory: false,
73 + modified: "1970-01-01T00:00:00.000Z",
74 + })),
75 + });
76 + const copiedBytes = copies.mock.results.reduce(
77 + (total, result) => total + (result.type === "return" ? result.value.byteLength : 0),
78 + 0,
79 + );
80 + expect(copiedBytes).toBe(11 + (size <= ARCHIVE_ENTRY_MAX_BYTES ? size : 0));
81 + for (const entry of entries) {
82 + const result = await request({ type: "entry", path: entry.path });
83 + const expected = contents(entry);
84 + if (expected.length > ARCHIVE_ENTRY_MAX_BYTES) {
85 + expect(result).toEqual({
86 + type: "error",
87 + message: "Entry previews are limited to 10 MB.",
88 + });
89 + } else {
90 + if (result.type !== "entry") throw new Error("Expected entry");
91 + expect(result.path).toBe(entry.path);
92 + expect(result.bytes.length).toBe(expected.length);
93 + expect(result.bytes.every((byte, index) => byte === expected[index])).toBe(true);
94 + }
95 + }
96 + expect(await request({ type: "entry", path: "missing.txt" })).toEqual({
97 + type: "error",
98 + message: "This archive entry is unavailable.",
99 + });
100 + } finally {
101 + vi.unstubAllGlobals();
102 + }
103 + },
104 +);
apps/web/src/components/files/binaryPreview.worker.ts
+6 -5
@@ -14,7 +14,8 @@ import {
14
15 let database: Database | null = null;
16 let tables: string[] = [];
17 -let files = new Map<string, Uint8Array<ArrayBuffer>>();
17 +// Entries over the preview limit keep only their size, so their payload is never copied.
18 +let files = new Map<string, Uint8Array<ArrayBuffer> | number>();
19 const reply = (result: BinaryWorkerResult) => self.postMessage(result, { transfer: [] });
20 const quote = (name: string) => `"${name.replaceAll('"', '""')}"`;
21
@@ -137,14 +138,14 @@ function tarEntries(bytes: Uint8Array<ArrayBuffer>) {
138 const linked = type === "1" ? files.get(linkpath) : undefined;
139 entries.push({
140 path,
140 - size: linked?.length ?? size,
141 + size: typeof linked === "number" ? linked : (linked?.length ?? size),
142 directory: type === "5",
143 modified: Number.isNaN(date.getTime()) ? null : date.toISOString(),
144 });
145 if (type === "5") {
146 files.delete(path);
147 files.delete(path.replace(/\/+$/, ""));
147 - } else files.set(path, linked ?? content.slice());
148 + } else files.set(path, linked ?? (size > ARCHIVE_ENTRY_MAX_BYTES ? size : content.slice()));
149 } else {
150 files.delete(path);
151 }
@@ -157,8 +158,8 @@ function tarEntries(bytes: Uint8Array<ArrayBuffer>) {
158 async function handle(input: BinaryWorkerRequest) {
159 if (input.type === "entry") {
160 const bytes = files.get(input.path);
160 - if (!bytes) throw new Error("This archive entry is unavailable.");
161 - if (bytes.length > ARCHIVE_ENTRY_MAX_BYTES)
161 + if (bytes === undefined) throw new Error("This archive entry is unavailable.");
162 + if (typeof bytes === "number" || bytes.length > ARCHIVE_ENTRY_MAX_BYTES)
163 throw new Error("Entry previews are limited to 10 MB.");
164 reply({ type: "entry", path: input.path, bytes });
165 return;