Skip to content

Commit bc8da5c

Browse files
Bil0000t3dotgg
authored andcommitted
perf(mobile): deflate large socket frames for clients without permessage-deflate
iOS WebSockets never negotiate permessage-deflate, so the connect config (about 78 KB) and every snapshot crossed the wire uncompressed. Clients now ask with frameDeflate=1; when the upgrade offers no permessage-deflate, the server sends string frames of 1 KB or more as raw DEFLATE binary parts (node zlib, level 1) and client-runtime inflates them with fflate. Old servers ignore the flag and old clients never send it.
1 parent 1a43f48 commit bc8da5c

7 files changed

Lines changed: 128 additions & 37 deletions

File tree

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
// @effect-diagnostics nodeBuiltinImport:off -- zlib deflates 6-8x faster than a JS deflate on the event loop.
2+
import * as NodeZlib from "node:zlib";
3+
4+
export const deflateSocketFrame = (frame: string): Uint8Array =>
5+
NodeZlib.deflateRawSync(frame, { level: 1 });

‎apps/server/src/ws.ts‎

Lines changed: 13 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -266,6 +266,7 @@ import { failEnvironmentAuthInvalid, failEnvironmentInternal } from "./auth/http
266266
import { isNetworkPath } from "@t3tools/shared/path";
267267
import * as RelayClient from "@t3tools/shared/relayClient";
268268
import {
269+
SOCKET_FRAME_DEFLATE_QUERY_PARAM,
269270
SOCKET_FRAME_PARTS_QUERY_PARAM,
270271
splitLargeSocketFrames,
271272
} from "@t3tools/shared/socketFrameParts";
@@ -275,6 +276,7 @@ import {
275276
withUsageLimitsCommands,
276277
} from "@t3tools/shared/usageLimits";
277278
import * as AgentSessionScanner from "./project/AgentSessionScanner.ts";
279+
import { deflateSocketFrame } from "./socketFrameDeflate.ts";
278280
import * as AgentSessionImporter from "./project/AgentSessionImporter.ts";
279281
import * as UsageLimitSources from "./usage/UsageLimitSources.ts";
280282
import { requestUrl } from "./requestUrl.ts";
@@ -3635,6 +3637,12 @@ export const layer = Layer.unwrap(
36353637
),
36363638
),
36373639
);
3640+
// A socket with permessage-deflate is already compressed on the wire.
3641+
const deflateFrames =
3642+
url.value.searchParams.has(SOCKET_FRAME_DEFLATE_QUERY_PARAM) &&
3643+
!request.headers["sec-websocket-extensions"]?.includes("permessage-deflate")
3644+
? deflateSocketFrame
3645+
: undefined;
36383646
const framedRpcWebSocketHttpEffect = url.value.searchParams.has(
36393647
SOCKET_FRAME_PARTS_QUERY_PARAM,
36403648
)
@@ -3644,7 +3652,11 @@ export const layer = Layer.unwrap(
36443652
// The RPC server upgrades the request itself, so its socket is
36453653
// wrapped through the request it reads.
36463654
Object.create(request, {
3647-
upgrade: { value: Effect.map(request.upgrade, splitLargeSocketFrames) },
3655+
upgrade: {
3656+
value: Effect.map(request.upgrade, (socket) =>
3657+
splitLargeSocketFrames(socket, deflateFrames),
3658+
),
3659+
},
36483660
}),
36493661
),
36503662
)

‎packages/client-runtime/src/rpc/session.test.ts‎

Lines changed: 48 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ import {
88
WS_METHODS,
99
UsageLimitSourceId,
1010
} from "@t3tools/contracts";
11-
import { splitSocketFrame } from "@t3tools/shared/socketFrameParts";
11+
import { splitDeflatedSocketFrame, splitSocketFrame } from "@t3tools/shared/socketFrameParts";
1212
import { describe, expect, it } from "@effect/vitest";
1313
import * as Cause from "effect/Cause";
1414
import * as Deferred from "effect/Deferred";
@@ -91,7 +91,7 @@ class TestWebSocket {
9191
this.emit("open", { type: "open" });
9292
}
9393

94-
serverMessage(data: string) {
94+
serverMessage(data: string | ArrayBuffer) {
9595
this.emit("message", { data, type: "message" });
9696
}
9797

@@ -277,34 +277,52 @@ const publishConfigEvents = Effect.fn("TestRpcSessionFactory.publishConfigEvents
277277
});
278278

279279
describe("RpcSessionFactory", () => {
280-
it.effect("connects while a large config snapshot downloads at 4000 bytes per second", () =>
281-
Effect.gen(function* () {
282-
const { factory, sockets } = yield* makeFactory();
283-
const session = yield* factory.connect(PREPARED);
284-
const readyFiber = yield* Effect.forkChild(session.ready);
285-
const socket = yield* awaitSocket(sockets);
286-
socket.open();
287-
const request = yield* awaitRequest(socket);
288-
// Multi-byte text, so parts must be sized in UTF-8 bytes and never split a surrogate pair.
289-
const config = { ...SERVER_CONFIG, cwd: "/" + "é€😀x".repeat(32 * 1024) };
290-
const frame = encodeJson({
291-
_tag: "Chunk",
292-
requestId: request.id,
293-
values: [{ version: 1, type: "snapshot", config: encodeServerConfig(config) }],
294-
});
295-
const parts = new URL(socket.url).searchParams.has("frameParts")
296-
? splitSocketFrame(frame)
297-
: [frame];
298-
299-
for (const part of parts) {
300-
const bytes = new TextEncoder().encode(part);
301-
yield* TestClock.adjust((bytes.length / 4000) * 1000);
302-
socket.serverMessage(new TextDecoder().decode(bytes));
303-
}
304-
yield* Fiber.join(readyFiber);
280+
it.effect.each([
281+
{ label: "text parts", deflated: false },
282+
{ label: "deflated binary parts", deflated: true },
283+
])(
284+
"connects while a large config snapshot downloads at 4000 bytes per second as $label",
285+
({ deflated }) =>
286+
Effect.gen(function* () {
287+
const { factory, sockets } = yield* makeFactory();
288+
const session = yield* factory.connect(PREPARED);
289+
const readyFiber = yield* Effect.forkChild(session.ready);
290+
const socket = yield* awaitSocket(sockets);
291+
socket.open();
292+
const request = yield* awaitRequest(socket);
293+
// Multi-byte text, so parts must be sized in UTF-8 bytes and never split a surrogate pair.
294+
const config = { ...SERVER_CONFIG, cwd: "/" + "é€😀x".repeat(32 * 1024) };
295+
const frame = encodeJson({
296+
_tag: "Chunk",
297+
requestId: request.id,
298+
values: [{ version: 1, type: "snapshot", config: encodeServerConfig(config) }],
299+
});
300+
const url = new URL(socket.url).searchParams;
301+
expect(url.has("frameParts") && url.has("frameDeflate")).toBe(true);
302+
const parts = deflated
303+
? splitDeflatedSocketFrame(
304+
yield* Effect.promise(() =>
305+
new Response(
306+
new Blob([frame]).stream().pipeThrough(new CompressionStream("deflate-raw")),
307+
)
308+
.arrayBuffer()
309+
.then((buffer) => new Uint8Array(buffer)),
310+
),
311+
// Repeated text deflates small, so a small part size forces several parts.
312+
1024,
313+
)
314+
: splitSocketFrame(frame);
315+
expect(parts.length).toBeGreaterThan(1);
316+
317+
for (const part of parts) {
318+
const bytes = typeof part === "string" ? new TextEncoder().encode(part) : part;
319+
yield* TestClock.adjust((bytes.length / 4000) * 1000);
320+
socket.serverMessage(typeof part === "string" ? part : bytes.slice().buffer);
321+
}
322+
yield* Fiber.join(readyFiber);
305323

306-
expect(yield* session.initialConfig).toEqual(config);
307-
}),
324+
expect(yield* session.initialConfig).toEqual(config);
325+
}),
308326
);
309327

310328
it.effect("owns one scoped websocket attempt and exposes readiness and closure", () =>
@@ -314,7 +332,7 @@ describe("RpcSessionFactory", () => {
314332
const readyFiber = yield* Effect.forkChild(session.ready);
315333
const socket = yield* awaitSocket(sockets);
316334

317-
expect(socket.url).toBe(`${PREPARED.socketUrl}&frameParts=1`);
335+
expect(socket.url).toBe(`${PREPARED.socketUrl}&frameParts=1&frameDeflate=1`);
318336
socket.open();
319337
yield* completeInitialConfig(socket);
320338
yield* Fiber.join(readyFiber);

‎packages/client-runtime/src/rpc/session.ts‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@ import {
66
} from "@t3tools/contracts";
77
import {
88
joinSocketFrameParts,
9+
SOCKET_FRAME_DEFLATE_QUERY_PARAM,
910
SOCKET_FRAME_PARTS_QUERY_PARAM,
1011
} from "@t3tools/shared/socketFrameParts";
1112
import * as Cause from "effect/Cause";
@@ -231,6 +232,7 @@ export const make = Effect.fn("RpcSessionFactory.make")(function* (
231232
};
232233
const socketUrl = new URL(connection.socketUrl);
233234
socketUrl.searchParams.set(SOCKET_FRAME_PARTS_QUERY_PARAM, "1");
235+
socketUrl.searchParams.set(SOCKET_FRAME_DEFLATE_QUERY_PARAM, "1");
234236
const layerSocket = Layer.effect(
235237
Socket.Socket,
236238
Effect.map(Effect.service(Socket.Socket), joinSocketFrameParts),

‎packages/shared/package.json‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -554,6 +554,7 @@
554554
"@t3tools/contracts": "workspace:*",
555555
"effect": "catalog:",
556556
"ffi-rs": "1.3.2",
557+
"fflate": "0.8.3",
557558
"mdast-util-directive": "catalog:",
558559
"mdast-util-to-hast": "^13.2.1",
559560
"micromark-extension-directive": "catalog:",

‎packages/shared/src/socketFrameParts.ts‎

Lines changed: 56 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,17 @@
11
import * as Arr from "effect/Array";
22
import * as Effect from "effect/Effect";
33
import * as Socket from "effect/socket/Socket";
4+
import { inflateSync, strFromU8 } from "fflate";
45

56
// Old clients omit this; old servers ignore it.
67
export const SOCKET_FRAME_PARTS_QUERY_PARAM = "frameParts";
8+
// The client can inflate frames the server deflated. The server only does so
9+
// when the socket negotiated no permessage-deflate, as iOS sockets never do.
10+
export const SOCKET_FRAME_DEFLATE_QUERY_PARAM = "frameDeflate";
11+
// Smaller frames gain little from a deflate without a shared window.
12+
const SOCKET_FRAME_DEFLATE_MIN_CHARS = 1024;
13+
const BINARY_PART_MORE = 1;
14+
const BINARY_PART_LAST = 0;
715

816
// WebSocket messages arrive whole. At 4,000 bytes/s each part takes about
917
// 12 seconds, leaving margin before the client's 15-second liveness timeout.
@@ -41,27 +49,69 @@ export function splitSocketFrame(
4149
return Arr.append(parts, frame.slice(start));
4250
}
4351

44-
/** Server side: sends string frames longer than one part as consecutive parts. */
45-
export function splitLargeSocketFrames(socket: Socket.Socket): Socket.Socket {
52+
/** Raw DEFLATE bytes as binary parts, each led by a byte that says whether more follow. */
53+
export function splitDeflatedSocketFrame(
54+
deflated: Uint8Array,
55+
partBytes = SOCKET_FRAME_PART_BYTES,
56+
): Arr.NonEmptyReadonlyArray<Uint8Array> {
57+
const size = partBytes - 1;
58+
const parts: Array<Uint8Array> = [];
59+
for (let start = 0; start === 0 || start < deflated.length; start += size) {
60+
const body = deflated.subarray(start, start + size);
61+
const part = new Uint8Array(body.length + 1);
62+
part[0] = start + size < deflated.length ? BINARY_PART_MORE : BINARY_PART_LAST;
63+
part.set(body, 1);
64+
parts.push(part);
65+
}
66+
return parts as unknown as Arr.NonEmptyReadonlyArray<Uint8Array>;
67+
}
68+
69+
/**
70+
* Server side: sends string frames longer than one part as consecutive parts.
71+
* With `deflate` (raw DEFLATE), larger string frames go out as binary parts.
72+
*/
73+
export function splitLargeSocketFrames(
74+
socket: Socket.Socket,
75+
deflate?: (frame: string) => Uint8Array,
76+
): Socket.Socket {
4677
const split = (chunk: string | Uint8Array): Arr.NonEmptyReadonlyArray<string | Uint8Array> =>
47-
typeof chunk === "string" ? splitSocketFrame(chunk) : [chunk];
78+
typeof chunk !== "string"
79+
? [chunk]
80+
: deflate !== undefined && chunk.length >= SOCKET_FRAME_DEFLATE_MIN_CHARS
81+
? splitDeflatedSocketFrame(deflate(chunk))
82+
: splitSocketFrame(chunk);
4883
return Socket.make({
4984
reader: socket.reader,
5085
writer: Effect.map(socket.writer, (writer) => ({
5186
write: (chunk) =>
52-
typeof chunk === "string" ? writer.writeAll(splitSocketFrame(chunk)) : writer.write(chunk),
87+
typeof chunk === "string" ? writer.writeAll(split(chunk)) : writer.write(chunk),
5388
writeAll: (chunks) => writer.writeAll(Arr.flatMap(chunks, split)),
5489
})),
5590
});
5691
}
5792

58-
/** Client side: joins parts back into whole frames. */
93+
/** Client side: joins parts back into whole frames, inflating deflated ones. */
5994
export function joinSocketFrameParts(socket: Socket.Socket): Socket.Socket {
6095
return Socket.make({
6196
reader: Effect.map(socket.reader, (reader) => {
6297
let pending = "";
98+
let pendingBinary: Array<Uint8Array> = [];
99+
const joinBinary = (part: Uint8Array) => {
100+
pendingBinary.push(part.subarray(1));
101+
if (part[0] === BINARY_PART_MORE) return PART_RECEIVED_FRAME;
102+
const deflated = new Uint8Array(
103+
pendingBinary.reduce((size, body) => size + body.length, 0),
104+
);
105+
let offset = 0;
106+
for (const body of pendingBinary) {
107+
deflated.set(body, offset);
108+
offset += body.length;
109+
}
110+
pendingBinary = [];
111+
return strFromU8(inflateSync(deflated));
112+
};
63113
const join = (frame: string | Uint8Array) => {
64-
if (typeof frame !== "string") return frame;
114+
if (typeof frame !== "string") return joinBinary(frame);
65115
if (frame.startsWith(PART_PREFIX)) {
66116
pending += frame.slice(PART_PREFIX.length);
67117
return PART_RECEIVED_FRAME;

‎pnpm-lock.yaml‎

Lines changed: 3 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

0 commit comments

Comments
 (0)