codehost 0.20.4 → 0.20.5

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.20.5](https://github.com/snomiao/codehost/compare/v0.20.4...v0.20.5) (2026-06-12)
+
+
+### Performance Improvements
+
+* **tunnel:** dedicated bulk lane — HTTP bodies ride a second data channel so they can't HOL-block typing ([b14797b](https://github.com/snomiao/codehost/commit/b14797b5e4efb4e3f299ba9c3b78bdf360a9a064))
+
 ## [0.20.4](https://github.com/snomiao/codehost/compare/v0.20.3...v0.20.4) (2026-06-12)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codehost",
-  "version": "0.20.4",
+  "version": "0.20.5",
   "type": "module",
   "repository": {
     "type": "git",

package/src/shared/rtc.ts

@@ -24,3 +24,11 @@ export type RtcSignal = SdpSignal | CandidateSignal;
 
 /** Label used for the control/tunnel data channel. */
 export const CHANNEL_LABEL = "codehost";
+/**
+ * Second data channel for bulk HTTP bodies. Separate channel = separate SCTP
+ * stream, so multi-MB asset downloads no longer head-of-line block the
+ * interactive WS traffic (VS Code remote protocol, terminal) on
+ * CHANNEL_LABEL. The daemon spins up one Tunnel per incoming channel, so old
+ * daemons handle this unmodified; old browsers simply never open it.
+ */
+export const BULK_CHANNEL_LABEL = "codehost-bulk";

package/src/web/conn-broker.ts

@@ -15,9 +15,10 @@ import { TunnelClient, type TunnelLike, type TunnelWsHandlers, type TunnelWsHand
 
 type AnyMsg = Record<string, any>;
 
-/** Creates the RTCPeerConnection for a peer and resolves with its open channel.
+/** Creates the RTCPeerConnection for a peer and resolves with its open
+ *  interactive channel plus the (possibly still-connecting) bulk lane.
  *  Provided by the UI (discovery.tsx) and invoked only when this tab is owner. */
-export type Establish = () => Promise<RTCDataChannel>;
+export type Establish = () => Promise<{ channel: RTCDataChannel; bulk: RTCDataChannel | null }>;
 
 class ConnBroker {
   private port: MessagePort | null = null;
@@ -110,8 +111,8 @@ class ConnBroker {
     if (!establish) return;
     this.establishing.add(peerId);
     try {
-      const channel = await establish();
-      this.locals.set(peerId, new TunnelClient(channel));
+      const { channel, bulk } = await establish();
+      this.locals.set(peerId, new TunnelClient(channel, bulk));
       this.post({ t: "ready", peerId });
       this.resolveReady(peerId);
     } catch (err) {

package/src/web/discovery.tsx

@@ -431,7 +431,7 @@ export function Discovery() {
       // only invoked when we're the owner (or get promoted on failover); other
       // tabs reuse the owner's channel via a proxy, so they never open WebRTC.
       const establish = () =>
-        new Promise<RTCDataChannel>((resolve, reject) => {
+        new Promise<{ channel: RTCDataChannel; bulk: RTCDataChannel | null }>((resolve, reject) => {
           const rtc = new RtcClient({
             sendSignal: (data: RtcSignal) => send(server.peerId, data),
             onState: (state) => {
@@ -439,7 +439,7 @@ export function Discovery() {
             },
             onOpen: (channel) => {
               clearTimeout(timer);
-              resolve(channel);
+              resolve({ channel, bulk: rtc.bulkChannel });
             },
             onClose: () => setConnState((s) => (s === "connected" ? "idle" : s)),
           });

package/src/web/room-client.ts

@@ -91,7 +91,7 @@ export class CodehostRoom {
         onOpen: (channel) => {
           clearTimeout(timer);
           this.dialFailedAt.delete(peerId);
-          resolve(new TunnelClient(channel));
+          resolve(new TunnelClient(channel, rtc.bulkChannel));
         },
         onClose: drop,
         onState: (state) => {

package/src/web/rtc-client.ts

@@ -1,4 +1,4 @@
-import { CHANNEL_LABEL, ICE_SERVERS, type RtcSignal } from "../shared/rtc";
+import { BULK_CHANNEL_LABEL, CHANNEL_LABEL, ICE_SERVERS, type RtcSignal } from "../shared/rtc";
 
 export interface RtcClientOptions {
   /** Relay a signal to the server peer via the signaling channel. */
@@ -15,6 +15,7 @@ export interface RtcClientOptions {
 export class RtcClient {
   private pc: RTCPeerConnection;
   private channel: RTCDataChannel | null = null;
+  private bulk: RTCDataChannel | null = null;
 
   constructor(private opts: RtcClientOptions) {
     this.pc = new RTCPeerConnection({
@@ -36,7 +37,7 @@ export class RtcClient {
     };
   }
 
-  /** Create the data channel + offer and kick off the handshake. */
+  /** Create the data channels + offer and kick off the handshake. */
   async start(): Promise<void> {
     const channel = this.pc.createDataChannel(CHANNEL_LABEL, { ordered: true });
     channel.binaryType = "arraybuffer";
@@ -44,6 +45,13 @@ export class RtcClient {
     channel.onopen = () => this.opts.onOpen?.(channel);
     channel.onclose = () => this.opts.onClose?.();
 
+    // Bulk lane for HTTP bodies (its own SCTP stream — no HOL with the
+    // interactive channel above). Senders fall back to the interactive channel
+    // until it opens, so nothing waits on it.
+    const bulk = this.pc.createDataChannel(BULK_CHANNEL_LABEL, { ordered: true });
+    bulk.binaryType = "arraybuffer";
+    this.bulk = bulk;
+
     const offer = await this.pc.createOffer();
     await this.pc.setLocalDescription(offer);
     this.opts.sendSignal({ kind: "offer", type: "offer", sdp: offer.sdp ?? "" });
@@ -69,6 +77,11 @@ export class RtcClient {
     return this.channel;
   }
 
+  /** The bulk lane (may still be CONNECTING when the interactive one opens). */
+  get bulkChannel(): RTCDataChannel | null {
+    return this.bulk;
+  }
+
   /**
    * Which ICE path the nominated candidate pair uses: "lan" when both ends
    * are host candidates (same network — traffic never leaves it), "p2p" for a
@@ -111,6 +124,11 @@ export class RtcClient {
     } catch {
       // ignore
     }
+    try {
+      this.bulk?.close();
+    } catch {
+      // ignore
+    }
     try {
       this.pc.close();
     } catch {

package/src/web/tunnel-client.ts

@@ -49,9 +49,24 @@ export class TunnelClient {
   private wsRx = new WsReassembler(); // reassembles daemon -> browser WS messages
   private textEncoder = new TextEncoder();
 
-  constructor(private channel: RTCDataChannel) {
+  /**
+   * `channel` carries the interactive traffic (WebSocket frames — VS Code's
+   * remote protocol, terminals); `bulk`, when provided and open, carries HTTP
+   * request/response streams on its own SCTP stream so multi-MB asset bodies
+   * never head-of-line block a keystroke. The daemon runs one Tunnel per
+   * channel, so each lane answers on itself and no demuxing is needed beyond
+   * listening on both.
+   */
+  constructor(
+    private channel: RTCDataChannel,
+    private bulk: RTCDataChannel | null = null,
+  ) {
     channel.binaryType = "arraybuffer";
     channel.addEventListener("message", (ev) => this.onFrame(ev.data));
+    if (bulk) {
+      bulk.binaryType = "arraybuffer";
+      bulk.addEventListener("message", (ev) => this.onFrame(ev.data));
+    }
   }
 
   private allocId(): number {
@@ -171,11 +186,16 @@ export class TunnelClient {
         },
       });
 
-      this.send(encodeJson(Op.HttpReq, streamId, { method, path, headers: reqHeaders }));
+      // HTTP rides the bulk lane. Pinned per request: every frame of this
+      // stream must hit the SAME channel — the daemon runs one Tunnel per
+      // channel, so a mid-request switch (e.g. bulk finishing its handshake)
+      // would strand the stream across two Tunnels.
+      const lane = this.bulk?.readyState === "open" ? this.bulk : this.channel;
+      this.sendOn(lane, encodeJson(Op.HttpReq, streamId, { method, path, headers: reqHeaders }));
       if (body && body.byteLength) {
-        for (const part of chunk(body)) this.send(encodeFrame(Op.HttpReqBody, streamId, part));
+        for (const part of chunk(body)) this.sendOn(lane, encodeFrame(Op.HttpReqBody, streamId, part));
       }
-      this.send(encodeFrame(Op.HttpReqEnd, streamId));
+      this.sendOn(lane, encodeFrame(Op.HttpReqEnd, streamId));
     });
   }
 
@@ -198,12 +218,17 @@ export class TunnelClient {
     };
   }
 
+  /** Interactive-channel send (WS frames, control). */
   private send(frame: Uint8Array): void {
-    if (this.channel.readyState === "open") {
+    this.sendOn(this.channel, frame);
+  }
+
+  private sendOn(ch: RTCDataChannel, frame: Uint8Array): void {
+    if (ch.readyState === "open") {
       // Copy into a fresh ArrayBuffer-backed view to satisfy send()'s typing.
       const copy = new Uint8Array(frame.byteLength);
       copy.set(frame);
-      this.channel.send(copy.buffer);
+      ch.send(copy.buffer);
     }
   }