herdr-remote-relay 0.3.11 → 0.3.13

package/dist/scroll-input.js

@@ -0,0 +1,124 @@
+/**
+ * Wheel-report recognition for read-only clients.
+ *
+ * A viewer holds no control lease and may not type into the terminal. It may
+ * still scroll, for the same reason `resize` does not require the lease: every
+ * client drives its *own* PTY stream (`session_start` is emitted per client
+ * with `streamId: client.id`), so a wheel report moves only that viewer's own
+ * screen and cannot disturb the controller.
+ *
+ * This module is the trust boundary for that allowance, so the match is exact
+ * rather than heuristic. A frame is forwarded only when it consists entirely
+ * of wheel reports in the encodings a terminal emits; a single stray byte —
+ * a keystroke, a click, a drag — rejects the whole frame.
+ */
+const ESC = 0x1b;
+const LEFT_BRACKET = 0x5b; // [
+const LESS_THAN = 0x3c; // <
+const SEMICOLON = 0x3b; // ;
+const UPPER_M = 0x4d; // M
+const ZERO = 0x30;
+const NINE = 0x39;
+/**
+ * The wheel sets bit 64 of the event code; bit 1 is up/down and bits 4/8/16
+ * are shift/alt/ctrl. Every other bit belongs to something that is not a
+ * wheel: bit 32 marks motion, bits 2 and 128 select other buttons.
+ */
+const WHEEL_BASE = 64;
+const WHEEL_CODE_MASK = ~(1 | 4 | 8 | 16);
+/** Single-byte (X10) parameters are biased by 32 and cannot exceed one byte. */
+const X10_PARAM_BIAS = 32;
+const X10_PARAM_MAX = 255;
+function isWheelCode(code) {
+    return Number.isInteger(code) && (code & WHEEL_CODE_MASK) === WHEEL_BASE;
+}
+function isDigit(byte) {
+    return byte >= ZERO && byte <= NINE;
+}
+/** Reads one decimal parameter. */
+function readNumber(bytes, start) {
+    let index = start;
+    let value = 0;
+    while (index < bytes.length && isDigit(bytes[index])) {
+        value = value * 10 + (bytes[index] - ZERO);
+        // A parameter long enough to overflow is not something a terminal emits.
+        if (value > 0xffff)
+            return null;
+        index += 1;
+    }
+    if (index === start)
+        return null;
+    return { value, next: index };
+}
+/**
+ * Matches `ESC [ < Pb ; Px ; Py M`, the SGR and SGR-pixels encodings.
+ * @returns offset after the report, or -1
+ */
+function matchSgrWheel(bytes, start) {
+    if (bytes[start] !== ESC || bytes[start + 1] !== LEFT_BRACKET || bytes[start + 2] !== LESS_THAN) {
+        return -1;
+    }
+    const code = readNumber(bytes, start + 3);
+    if (!code || !isWheelCode(code.value) || bytes[code.next] !== SEMICOLON)
+        return -1;
+    const first = readNumber(bytes, code.next + 1);
+    if (!first || bytes[first.next] !== SEMICOLON)
+        return -1;
+    const second = readNumber(bytes, first.next + 1);
+    if (!second)
+        return -1;
+    // A wheel is never released, so the terminator is always `M`. Accepting `m`
+    // here would admit button releases, which are not scrolling.
+    if (bytes[second.next] !== UPPER_M)
+        return -1;
+    return second.next + 1;
+}
+/**
+ * Matches `ESC [ M Pb Px Py`, the default single-byte encoding.
+ * @returns offset after the report, or -1
+ */
+function matchX10Wheel(bytes, start) {
+    if (bytes[start] !== ESC || bytes[start + 1] !== LEFT_BRACKET || bytes[start + 2] !== UPPER_M) {
+        return -1;
+    }
+    if (start + 6 > bytes.length)
+        return -1;
+    const code = bytes[start + 3] - X10_PARAM_BIAS;
+    const column = bytes[start + 4];
+    const row = bytes[start + 5];
+    if (!isWheelCode(code))
+        return -1;
+    if (column < X10_PARAM_BIAS || column > X10_PARAM_MAX)
+        return -1;
+    if (row < X10_PARAM_BIAS || row > X10_PARAM_MAX)
+        return -1;
+    return start + 6;
+}
+/** Whether every byte of `payload`, a raw client input frame, belongs to a wheel report. */
+function isWheelOnlyInput(payload) {
+    if (!payload)
+        return false;
+    const bytes = payload instanceof Uint8Array
+        ? payload
+        : payload instanceof ArrayBuffer
+            ? new Uint8Array(payload)
+            : null;
+    if (!bytes || bytes.length === 0)
+        return false;
+    let offset = 0;
+    while (offset < bytes.length) {
+        const sgr = matchSgrWheel(bytes, offset);
+        if (sgr > offset) {
+            offset = sgr;
+            continue;
+        }
+        const x10 = matchX10Wheel(bytes, offset);
+        if (x10 > offset) {
+            offset = x10;
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+export { isWheelOnlyInput };

package/dist/server/client-channel.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage } from 'node:http';
+import type { RelayContext, RelaySocket } from './types.js';
+export declare function handleClientConnection(relay: RelayContext, ws: RelaySocket, req: IncomingMessage): void;

package/dist/server/client-channel.js

@@ -0,0 +1,365 @@
+// The browser side of the relay: a window's WebSocket, from its hello and
+// pairing to every message and keystroke it sends after.
+import { CAPABILITY, FRAME_TYPE_INPUT, PASTE_MAX_BYTES, PROTOCOL_VERSION, hasImageSignature, isPasteImageMime, packStreamFrame, packStreamFrameV2, } from '../protocol/index.js';
+import { requestFontChunk, requestFontSubset } from './font-proxy.js';
+import { allowClientHandshake, allowPairAttempt, clientAddress } from './requests.js';
+import { MIN_SESSION_COLS, MIN_SESSION_ROWS, beginHostReconnect, broadcastControlState, detachClient, startSession, } from './sessions.js';
+import { clampDimension, closeSocket, isOpen, jsonSend, parseJson, randomId, rejectHandshake, } from './sockets.js';
+import { enqueueDelayedSend, notifyHostClientCount } from './transport.js';
+/** A window asks to start its workstation's Herdr at most this often. */
+const HERDR_START_REPEAT_MS = 3_000;
+/** A window asks its workstation to re-read the terminal font at most this often. */
+const FONT_REFRESH_REPEAT_MS = 2_000;
+function verifyImageMagicBytes(mime, dataBase64) {
+    if (typeof dataBase64 !== 'string' || dataBase64.length === 0)
+        return false;
+    let headerBuf;
+    try {
+        headerBuf = Buffer.from(dataBase64.slice(0, 32), 'base64');
+    }
+    catch {
+        return false;
+    }
+    if (headerBuf.length === 0)
+        return false;
+    return hasImageSignature(mime, headerBuf);
+}
+export function handleClientConnection(relay, ws, req) {
+    const pending = { ws, req, authenticated: false };
+    const deadline = setTimeout(() => {
+        if (!pending.authenticated)
+            closeSocket(ws, 1008, 'client hello timeout');
+    }, 10000);
+    ws.isAlive = true;
+    ws.on('pong', () => {
+        ws.isAlive = true;
+        if (pending.client) {
+            pending.client.lastSeenAt = Date.now();
+            pending.client.lastPingAt = new Date().toISOString();
+        }
+    });
+    ws.on('ping', () => {
+        ws.isAlive = true;
+        if (pending.client) {
+            pending.client.lastSeenAt = Date.now();
+            pending.client.lastPingAt = new Date().toISOString();
+        }
+    });
+    ws.on('message', (raw, isBinary) => {
+        if (!pending.authenticated) {
+            if (isBinary)
+                return rejectHandshake(ws, 'client hello must be JSON');
+            const message = parseJson(raw.toString());
+            if (message?.type !== 'hello' || message.protocol !== PROTOCOL_VERSION)
+                return rejectHandshake(ws, 'invalid client hello');
+            if (!allowClientHandshake(relay, req))
+                return rejectHandshake(ws, 'too many connection attempts', 'rate_limited');
+            let device = null;
+            let paired = null;
+            if (message.pairCode) {
+                if (!allowPairAttempt(relay, req))
+                    return rejectHandshake(ws, 'too many pairing attempts', 'rate_limited');
+                paired = relay.auth.completePairing(message.pairCode);
+            }
+            if (paired)
+                device = paired;
+            else if (message.token)
+                device = relay.auth.authenticateDevice(message.token);
+            if (!device)
+                return rejectHandshake(ws, 'valid device token or pairing code required', 'auth_required');
+            const host = relay.hosts.get(device.hostId);
+            if (!host || host.reconnecting || !isOpen(host.ws))
+                return rejectHandshake(ws, 'paired Herdr host is offline', host?.reconnecting ? 'host_reconnecting' : 'host_offline');
+            // Two tabs of one browser are separate windows with their own PTY sessions,
+            // not rivals. Nothing is retired here: each connection gets its own stream
+            // without evicting existing clients.
+            if (host.clients.size >= relay.config.relay.maxClientsPerHost)
+                return rejectHandshake(ws, 'host client limit reached', 'too_many_clients');
+            clearTimeout(deadline);
+            relay.finishHandshake(ws);
+            const clientId = randomId('client');
+            const client = {
+                id: clientId,
+                ws,
+                hostId: host.id,
+                deviceId: device.deviceId,
+                // Stable per browser profile; used to recognise a reconnect from the
+                // same browser rather than a genuinely separate viewer.
+                browserClientId: typeof message.clientId === 'string' ? message.clientId.slice(0, 128) : null,
+                handoffCapable: Array.isArray(message.capabilities) &&
+                    message.capabilities.includes(CAPABILITY.hostHandoff),
+                session: null,
+                // Every paired window gets its own interactive PTY session. Pairing
+                // is the permission boundary; once a device is through it, every
+                // window can type into its own terminal.
+                role: 'controller',
+                controllerId: null,
+                connectedAt: new Date().toISOString(),
+                connectedAtMs: Date.now(),
+                lastSeenAt: Date.now(),
+                lastPingAt: null,
+                bytesReceived: 0,
+                bytesSent: 0,
+                ip: clientAddress(relay, req),
+                userAgent: String(req.headers['user-agent'] || '').slice(0, 256),
+                cols: clampDimension(message.cols, 80),
+                rows: clampDimension(message.rows, 24),
+            };
+            client.controllerId = null;
+            // Persist how this device identifies itself so the operator dashboard
+            // can name it in the revoke list instead of showing a bare device id.
+            relay.auth.noteDeviceSeen(device.deviceId, { userAgent: client.userAgent, ip: client.ip });
+            pending.authenticated = true;
+            pending.client = client;
+            relay.clients.set(client.id, client);
+            host.clients.add(client.id);
+            notifyHostClientCount(host);
+            ws.isAlive = true;
+            if (paired)
+                jsonSend(ws, {
+                    type: 'paired',
+                    token: paired.token,
+                    deviceId: paired.deviceId,
+                    hostId: paired.hostId,
+                    expiresAt: paired.expiresAtIso,
+                });
+            // Expose the relay-assigned connection id so clients can distinguish
+            // their own controller lease from another device's lease. The browser
+            // supplied clientId identifies a device, not this live WebSocket.
+            jsonSend(ws, {
+                type: 'ready',
+                role: client.role,
+                // There is no controller to name: every window has full input. The
+                // field stays in the message for clients built against protocol 1,
+                // which read it to decide whether somebody else held the lease — and
+                // `null` is exactly the answer that means "nobody does".
+                controllerId: null,
+                hostId: host.id,
+                hostname: host.hostname,
+                clientId: client.id,
+                // Delivered with `ready`, before the first PTY byte, so the terminal
+                // is painted in the host's colors from its very first frame.
+                terminalPalette: host.terminalPalette || null,
+                terminalFont: host.terminalFont || null,
+                clientCount: host.clients.size,
+            });
+            if (host.agentStatus)
+                jsonSend(ws, host.agentStatus);
+            if (host.updateStatus)
+                jsonSend(ws, host.updateStatus);
+            startSession(relay, host, client);
+            broadcastControlState(relay, host);
+            return;
+        }
+        if (pending.client)
+            handleClientMessage(relay, pending.client, raw, isBinary);
+    });
+    ws.on('close', () => {
+        clearTimeout(deadline);
+        if (pending.client)
+            detachClient(relay, pending.client, { notify: true });
+    });
+    ws.on('error', () => { });
+}
+function handleClientMessage(relay, client, raw, isBinary) {
+    client.lastSeenAt = Date.now();
+    const host = relay.hosts.get(client.hostId);
+    if (!host) {
+        detachClient(relay, client, { notify: true, reason: 'host_offline' });
+        return;
+    }
+    if (isBinary) {
+        // The server keeps ws's default binaryType, so a binary frame is one Buffer.
+        const bytes = raw;
+        if (bytes.length > relay.config.relay.maxPayloadBytes)
+            return;
+        if (!client.session)
+            return;
+        // Each window owns its own PTY session, so input is stamped with the
+        // client's dedicated stream id or streamIndex.
+        const frame = host.binaryFrameV2 && typeof client.session.streamIndex === 'number'
+            ? packStreamFrameV2(FRAME_TYPE_INPUT, client.session.streamIndex, bytes)
+            : packStreamFrame('input', client.session.streamId, bytes);
+        if (isOpen(host.ws)) {
+            const doSend = () => {
+                if (!isOpen(host.ws))
+                    return;
+                try {
+                    host.ws.send(frame);
+                    client.bytesReceived += bytes.length;
+                    relay.metrics.recordIn(bytes.length, host.id);
+                }
+                catch {
+                    beginHostReconnect(relay, host, 'host_send_failed');
+                }
+            };
+            if (relay.devLatencyMs > 0)
+                enqueueDelayedSend(relay, host.ws, doSend);
+            else
+                doSend();
+        }
+        return;
+    }
+    // Untrusted: each branch reads only the fields its message type defines.
+    const message = parseJson(raw.toString());
+    if (!message) {
+        jsonSend(client.ws, { type: 'error', code: 'invalid_json', message: 'message must be JSON' });
+        return;
+    }
+    if (message.type === 'ping') {
+        client.lastPingAt = new Date().toISOString();
+        jsonSend(client.ws, { type: 'pong' });
+    }
+    else if (message.type === 'resize') {
+        // Each client owns its own PTY session, so resizing directly forwards
+        // the new geometry for this client's stream to the host.
+        client.cols = clampDimension(message.cols, client.cols);
+        client.rows = clampDimension(message.rows, client.rows);
+        if (client.session) {
+            client.session.cols = client.cols;
+            client.session.rows = client.rows;
+            if (isOpen(host.ws)) {
+                jsonSend(host.ws, {
+                    type: 'resize',
+                    clientId: client.session.streamId,
+                    streamId: client.session.streamId,
+                    cols: Math.max(MIN_SESSION_COLS, client.cols),
+                    rows: Math.max(MIN_SESSION_ROWS, client.rows),
+                });
+            }
+        }
+    }
+    else if (message.type === 'herdr_start') {
+        // The window's own workstation, and nobody else's: `host` was fixed by
+        // the device token at handshake, and nothing in this message can name
+        // another one. The host starts Herdr as its own user, at its own socket.
+        // Repeats are dropped — one click is enough, and the host shares a
+        // start between windows anyway.
+        if (!client.session) {
+            jsonSend(client.ws, {
+                type: 'error',
+                code: 'no_session',
+                message: 'terminal session is not ready',
+            });
+            return;
+        }
+        const now = Date.now();
+        if (client.herdrStartAt && now - client.herdrStartAt < HERDR_START_REPEAT_MS)
+            return;
+        client.herdrStartAt = now;
+        if (isOpen(host.ws)) {
+            jsonSend(host.ws, {
+                type: 'herdr_start',
+                clientId: client.session.streamId,
+                streamId: client.session.streamId,
+            });
+        }
+    }
+    else if (message.type === 'host_font_chunk_request') {
+        requestFontChunk(host, client, message);
+    }
+    else if (message.type === 'host_font_subset_request') {
+        requestFontSubset(host, client, message);
+    }
+    else if (message.type === 'host_font_refresh') {
+        // Same routing as herdr_start: only the workstation this window is
+        // bound to, and only what it offered. Repeats inside the window are
+        // dropped; the answer is broadcast to every window anyway.
+        if (!client.session || !isOpen(host.ws))
+            return;
+        const now = Date.now();
+        if (client.fontRefreshAt && now - client.fontRefreshAt < FONT_REFRESH_REPEAT_MS)
+            return;
+        client.fontRefreshAt = now;
+        jsonSend(host.ws, {
+            type: 'host_font_refresh',
+            clientId: client.session.streamId,
+            streamId: client.session.streamId,
+        });
+    }
+    else if (message.type === 'claim_control') {
+        // Control is no longer a lease. Answering the old request keeps clients
+        // built against the previous protocol working.
+        client.role = 'controller';
+        jsonSend(client.ws, { type: 'control_granted' });
+    }
+    else if (message.type === 'release_control') {
+        // Nothing to release: the window keeps its input either way, and saying
+        // so beats a silence an older client would wait on.
+        jsonSend(client.ws, { type: 'control_state', role: 'controller', controllerId: null });
+    }
+    else if (message.type === 'paste_file') {
+        if (client.role === 'viewer') {
+            jsonSend(client.ws, {
+                type: 'error',
+                code: 'viewer_mode',
+                message: 'Viewer mode cannot paste to terminal',
+            });
+            return;
+        }
+        if (!isPasteImageMime(message.mime)) {
+            jsonSend(client.ws, {
+                type: 'error',
+                code: 'paste_file_unsupported',
+                message: 'Unsupported paste image format',
+            });
+            return;
+        }
+        if (typeof message.dataBase64 !== 'string') {
+            jsonSend(client.ws, {
+                type: 'error',
+                code: 'paste_file_unsupported',
+                message: 'Invalid paste image payload',
+            });
+            return;
+        }
+        const rawLength = Buffer.byteLength(message.dataBase64, 'base64');
+        if (rawLength === 0) {
+            jsonSend(client.ws, {
+                type: 'error',
+                code: 'paste_file_empty',
+                message: 'Pasted image payload is empty',
+            });
+            return;
+        }
+        if (rawLength > PASTE_MAX_BYTES) {
+            jsonSend(client.ws, {
+                type: 'error',
+                code: 'paste_file_too_large',
+                message: 'Pasted image exceeds 3 MB limit',
+            });
+            return;
+        }
+        if (!verifyImageMagicBytes(message.mime, message.dataBase64)) {
+            jsonSend(client.ws, {
+                type: 'error',
+                code: 'paste_file_unsupported',
+                message: 'Pasted image content does not match declared MIME type',
+            });
+            return;
+        }
+        if (!isOpen(host?.ws)) {
+            jsonSend(client.ws, {
+                type: 'error',
+                code: 'host_offline',
+                message: 'Host is offline or disconnected',
+            });
+            return;
+        }
+        if (!client.session) {
+            jsonSend(client.ws, {
+                type: 'error',
+                code: 'no_session',
+                message: 'Terminal session is not ready',
+            });
+            return;
+        }
+        jsonSend(host.ws, {
+            type: 'paste_file',
+            clientId: client.session.streamId,
+            streamId: client.session.streamId,
+            mime: message.mime,
+            dataBase64: message.dataBase64,
+        });
+    }
+}

package/dist/server/font-proxy.d.ts

@@ -0,0 +1,19 @@
+import { type ClientHostFontChunkRequestMessage, type ClientHostFontSubsetRequestMessage, type HostFontChunkMessage, type HostFontSubsetMessage } from '../protocol/index.js';
+import type { RelayClient, RelayHost } from './types.js';
+/** One outstanding font chunk request of this window was answered. */
+export declare function settleFontChunk(client: RelayClient): void;
+/** One outstanding font subset request of this window was answered. */
+export declare function settleFontSubset(client: RelayClient): void;
+/**
+ * Pass a browser's request for one slice of a font file to its workstation.
+ * Only a file the workstation announced can be asked for, by its hash, and
+ * only a few slices at a time.
+ */
+export declare function requestFontChunk(host: RelayHost, client: RelayClient, message: ClientHostFontChunkRequestMessage): void;
+/**
+ * Ask the workstation to cut characters out of a large font it announced.
+ * The text is only characters to look up; a few requests at a time.
+ */
+export declare function requestFontSubset(host: RelayHost, client: RelayClient, message: ClientHostFontSubsetRequestMessage): void;
+export declare function forwardFontSubset(client: RelayClient, message: HostFontSubsetMessage): void;
+export declare function forwardFontChunk(client: RelayClient, message: HostFontChunkMessage): void;

package/dist/server/font-proxy.js

@@ -0,0 +1,155 @@
+// Terminal font files and cuts, passed between a window and its workstation a
+// slice at a time, and only for what the workstation announced.
+import { TERMINAL_FONT_CHUNK_BYTES, } from '../protocol/index.js';
+import { isOpen, jsonSend } from './sockets.js';
+/**
+ * Font chunks a window may have outstanding. Fonts are pulled a slice at a
+ * time so megabytes of font never queue ahead of terminal output; an answer
+ * that never comes stops counting after the timeout.
+ */
+const MAX_FONT_CHUNKS_IN_FLIGHT = 4;
+const FONT_CHUNK_TIMEOUT_MS = 30_000;
+/** Base64 of one full chunk, the most a `host_font_chunk` may carry. */
+const MAX_FONT_CHUNK_BASE64 = Math.ceil(TERMINAL_FONT_CHUNK_BYTES / 3) * 4;
+const SHA256_HEX = /^[0-9a-f]{64}$/;
+/** Characters one subset request may ask for (UTF-16 units of `text`). */
+const MAX_FONT_SUBSET_TEXT = 32 * 1024;
+/** Cut fonts a window may pull by hash; older ones stop being fetchable. */
+const MAX_FONT_SUBSETS_PER_CLIENT = 64;
+const MAX_FONT_SUBSET_BYTES = 16 * 1024 * 1024;
+const REQUEST_ID = /^[A-Za-z0-9_-]{1,32}$/;
+/** One outstanding font chunk request of this window was answered. */
+export function settleFontChunk(client) {
+    if (Array.isArray(client.fontChunkRequests) && client.fontChunkRequests.length)
+        client.fontChunkRequests.shift();
+}
+/** One outstanding font subset request of this window was answered. */
+export function settleFontSubset(client) {
+    if (Array.isArray(client.fontSubsetRequests) && client.fontSubsetRequests.length)
+        client.fontSubsetRequests.shift();
+}
+/**
+ * Pass a browser's request for one slice of a font file to its workstation.
+ * Only a file the workstation announced can be asked for, by its hash, and
+ * only a few slices at a time.
+ */
+export function requestFontChunk(host, client, message) {
+    if (!client.session || !isOpen(host.ws))
+        return;
+    const face = host.terminalFont?.faces?.find((candidate) => candidate.sha256 === message.sha256);
+    // A whole font file the workstation announced, or a cut it made for this window.
+    const bytes = face ? face.bytes : client.fontSubsets?.get(message.sha256) || 0;
+    const total = Math.ceil(bytes / TERMINAL_FONT_CHUNK_BYTES);
+    if (!bytes || !Number.isInteger(message.index) || message.index < 0 || message.index >= total) {
+        jsonSend(client.ws, {
+            type: 'error',
+            code: 'host_font_unavailable',
+            message: 'The workstation did not offer this font file',
+        });
+        return;
+    }
+    const now = Date.now();
+    client.fontChunkRequests = (client.fontChunkRequests || []).filter((at) => now - at < FONT_CHUNK_TIMEOUT_MS);
+    if (client.fontChunkRequests.length >= MAX_FONT_CHUNKS_IN_FLIGHT)
+        return;
+    client.fontChunkRequests.push(now);
+    jsonSend(host.ws, {
+        type: 'host_font_chunk_request',
+        clientId: client.session.streamId,
+        streamId: client.session.streamId,
+        sha256: message.sha256,
+        index: message.index,
+    });
+}
+/**
+ * Ask the workstation to cut characters out of a large font it announced.
+ * The text is only characters to look up; a few requests at a time.
+ */
+export function requestFontSubset(host, client, message) {
+    if (!client.session || !isOpen(host.ws))
+        return;
+    const known = host.terminalFont?.subsets?.some((source) => source.sha256 === message.sha256);
+    const valid = known &&
+        typeof message.text === 'string' &&
+        message.text.length > 0 &&
+        message.text.length <= MAX_FONT_SUBSET_TEXT &&
+        typeof message.requestId === 'string' &&
+        REQUEST_ID.test(message.requestId);
+    if (!valid) {
+        jsonSend(client.ws, {
+            type: 'error',
+            code: 'host_font_unavailable',
+            message: 'The workstation did not offer this font',
+        });
+        return;
+    }
+    const now = Date.now();
+    client.fontSubsetRequests = (client.fontSubsetRequests || []).filter((at) => now - at < FONT_CHUNK_TIMEOUT_MS);
+    if (client.fontSubsetRequests.length >= MAX_FONT_CHUNKS_IN_FLIGHT)
+        return;
+    client.fontSubsetRequests.push(now);
+    jsonSend(host.ws, {
+        type: 'host_font_subset_request',
+        clientId: client.session.streamId,
+        streamId: client.session.streamId,
+        requestId: message.requestId,
+        sha256: message.sha256,
+        text: message.text,
+    });
+}
+export function forwardFontSubset(client, message) {
+    settleFontSubset(client);
+    const valid = typeof message.sha256 === 'string' &&
+        SHA256_HEX.test(message.sha256) &&
+        typeof message.subsetSha === 'string' &&
+        SHA256_HEX.test(message.subsetSha) &&
+        typeof message.requestId === 'string' &&
+        REQUEST_ID.test(message.requestId) &&
+        Number.isInteger(message.bytes) &&
+        message.bytes > 0 &&
+        message.bytes <= MAX_FONT_SUBSET_BYTES &&
+        (message.dataBase64 === undefined ||
+            (typeof message.dataBase64 === 'string' &&
+                message.dataBase64.length <= MAX_FONT_CHUNK_BASE64));
+    if (!valid)
+        return;
+    if (message.dataBase64 === undefined) {
+        // Pulled in slices next: make this hash fetchable for this window only.
+        client.fontSubsets ||= new Map();
+        client.fontSubsets.delete(message.subsetSha);
+        client.fontSubsets.set(message.subsetSha, message.bytes);
+        while (client.fontSubsets.size > MAX_FONT_SUBSETS_PER_CLIENT) {
+            const oldest = client.fontSubsets.keys().next().value;
+            if (oldest !== undefined)
+                client.fontSubsets.delete(oldest);
+        }
+    }
+    jsonSend(client.ws, {
+        type: 'host_font_subset_ready',
+        requestId: message.requestId,
+        sha256: message.sha256,
+        subsetSha: message.subsetSha,
+        bytes: message.bytes,
+        ...(message.dataBase64 !== undefined ? { dataBase64: message.dataBase64 } : {}),
+    });
+}
+export function forwardFontChunk(client, message) {
+    settleFontChunk(client);
+    const valid = typeof message.sha256 === 'string' &&
+        SHA256_HEX.test(message.sha256) &&
+        Number.isInteger(message.index) &&
+        message.index >= 0 &&
+        Number.isInteger(message.total) &&
+        message.total > message.index &&
+        typeof message.dataBase64 === 'string' &&
+        message.dataBase64.length <= MAX_FONT_CHUNK_BASE64;
+    if (!valid)
+        return;
+    jsonSend(client.ws, {
+        type: 'host_font_chunk',
+        sha256: message.sha256,
+        index: message.index,
+        total: message.total,
+        dataBase64: message.dataBase64,
+    });
+}