replicas-computer 0.2.3 → 0.2.5

package/assets/desktop/replicas-chrome

@@ -39,6 +39,8 @@ JSON
   touch "$MARKER"
 fi
 
+# password-store skips a keyring D-Bus probe that stalls first launch for seconds
+# on a headless image; the network flags keep first-run downloads off the critical path.
 exec /usr/bin/google-chrome-stable \
   --user-data-dir="$PROFILE_DIR" \
   --profile-directory=Default \
@@ -46,6 +48,10 @@ exec /usr/bin/google-chrome-stable \
   --no-default-browser-check \
   --disable-search-engine-choice-screen \
   --disable-sync \
+  --password-store=basic \
+  --disable-component-update \
+  --disable-background-networking \
+  --no-pings \
   --remote-debugging-address=127.0.0.1 \
   --remote-debugging-port="$DEBUG_PORT" \
   --start-maximized \

package/assets/desktop/start-services.sh

@@ -384,8 +384,17 @@ fi
 
 kill_pids "$(legacy_stream_websockify_pids)"
 clear_bridge_pid_if_unhealthy stream has_stream stream_listener_pids stream_pids
+# Forwarded only when set, so the stream server keeps its own default.
 start_bg stream \
   "has_stream" \
-  "exec env REPLICAS_DESKTOP_DISPLAY=:$DISPLAY_NUM REPLICAS_DESKTOP_WIDTH=$WIDTH REPLICAS_DESKTOP_HEIGHT=$HEIGHT REPLICAS_DESKTOP_STREAM_FPS=${REPLICAS_DESKTOP_STREAM_FPS:-60} REPLICAS_DESKTOP_STREAM_PORT=$STREAM_PORT REPLICAS_DESKTOP_STREAM_WEBROOT=${REPLICAS_DESKTOP_STREAM_WEBROOT:-$REPLICAS_DESKTOP_TEMPLATES/stream} replicas-computer stream"
+  "exec env REPLICAS_DESKTOP_DISPLAY=:$DISPLAY_NUM REPLICAS_DESKTOP_WIDTH=$WIDTH REPLICAS_DESKTOP_HEIGHT=$HEIGHT ${REPLICAS_DESKTOP_STREAM_FPS:+REPLICAS_DESKTOP_STREAM_FPS=$REPLICAS_DESKTOP_STREAM_FPS }REPLICAS_DESKTOP_STREAM_PORT=$STREAM_PORT REPLICAS_DESKTOP_STREAM_WEBROOT=${REPLICAS_DESKTOP_STREAM_WEBROOT:-$REPLICAS_DESKTOP_TEMPLATES/stream} replicas-computer stream"
+
+# Takes Chrome's cold-start cost at boot instead of on the user's first click;
+# later launches join this instance through the profile singleton.
+if [ "${REPLICAS_DESKTOP_CHROME_PREWARM:-1}" = "1" ] && command -v replicas-chrome >/dev/null 2>&1; then
+  start_bg chrome-prewarm \
+    "curl -fsS --max-time 1 http://127.0.0.1:${REPLICAS_DESKTOP_CHROME_DEBUG_PORT:-9222}/json/version" \
+    "DISPLAY=:$DISPLAY_NUM REPLICAS_DESKTOP_CHROME_PROFILE_DIR=\"$CHROME_PROFILE_DIR\" exec replicas-chrome --no-startup-window"
+fi
 
 exit 0

package/dist/index.js

@@ -18,7 +18,7 @@ import { dirname, isAbsolute, resolve } from "path";
 var DESKTOP_STREAM_PORT = 6080;
 function getDesktopViewerUrl(publicUrl) {
   const url = new URL(`${publicUrl.replace(/\/$/, "")}/`);
-  url.searchParams.set("v", "14");
+  url.searchParams.set("v", "15");
   return url.toString();
 }
 var DESKTOP_VIEWER_WIDTH = 1920;
@@ -2694,11 +2694,13 @@ async function computerLaunchCommand(app, args) {
   const fullArgs = [...baseArgs.slice(1), ...args];
   const expectsNewChromePage = args.some((arg) => !arg.startsWith("-"));
   const existingChromePageIds = /* @__PURE__ */ new Set();
+  let chromeAlreadyRunning = false;
   if (app === "chrome") {
     try {
       for (const page of await getChromePages()) {
         if (page.id) existingChromePageIds.add(page.id);
       }
+      chromeAlreadyRunning = true;
     } catch {
     }
   }
@@ -2729,10 +2731,12 @@ async function computerLaunchCommand(app, args) {
         }
       }
       if (readyPage) break;
-      try {
-        if (child.pid) process.kill(child.pid, 0);
-      } catch {
-        fail(`Chrome exited before its desktop control channel became ready.`);
+      if (!chromeAlreadyRunning) {
+        try {
+          if (child.pid) process.kill(child.pid, 0);
+        } catch {
+          fail(`Chrome exited before its desktop control channel became ready.`);
+        }
       }
       await sleep(100);
     }
@@ -2921,7 +2925,7 @@ async function computerStatusCommand() {
 }
 
 // src/version.ts
-var COMPUTER_USE_VERSION = "0.2.3";
+var COMPUTER_USE_VERSION = "0.2.5";
 var COMPUTER_USE_PROTOCOL_VERSION = 1;
 
 // src/program.ts
@@ -3165,6 +3169,7 @@ import { spawn as spawn4 } from "child_process";
 import { createSocket } from "dgram";
 import { createReadStream, existsSync as existsSync6, statSync as statSync2 } from "fs";
 import { createServer as createServer2 } from "http";
+import { availableParallelism } from "os";
 import { dirname as dirname6, extname, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 
@@ -3357,7 +3362,16 @@ var RtpClock = class {
   base;
   last;
   wraps = 0;
+  origin = 0;
+  emitted = 0;
+  /**
+   * A fresh encoder starts RTP timestamps from a new random base, so the
+   * timeline continues from the last value emitted rather than jumping
+   * backwards — decoders and the viewer's media element both require
+   * monotonic presentation timestamps.
+   */
   reset() {
+    this.origin = this.emitted;
     this.base = void 0;
     this.last = void 0;
     this.wraps = 0;
@@ -3367,7 +3381,8 @@ var RtpClock = class {
     this.last = timestamp;
     const extended = timestamp + this.wraps * 4294967296;
     this.base ??= extended;
-    return Math.round((extended - this.base) * 1e6 / this.rate);
+    this.emitted = this.origin + Math.round((extended - this.base) * 1e6 / this.rate);
+    return this.emitted;
   }
 };
 var startCode = new Uint8Array([0, 0, 0, 1]);
@@ -3461,9 +3476,30 @@ var H264RtpAssembler = class {
 import WebSocket2, { WebSocketServer } from "ws";
 var width = Number.parseInt(process.env.REPLICAS_DESKTOP_WIDTH || String(DESKTOP_VIEWER_WIDTH), 10);
 var height = Number.parseInt(process.env.REPLICAS_DESKTOP_HEIGHT || String(DESKTOP_VIEWER_HEIGHT), 10);
-var fps = Number.parseInt(process.env.REPLICAS_DESKTOP_STREAM_FPS || "60", 10);
-var keyframeInterval = fps;
+var cores = availableParallelism();
+var fps = Number.parseInt(process.env.REPLICAS_DESKTOP_STREAM_FPS || "", 10) || 60;
+var x264Preset = cores >= 4 ? "superfast" : "ultrafast";
 var port = Number.parseInt(process.env.REPLICAS_DESKTOP_STREAM_PORT || String(DESKTOP_STREAM_PORT), 10);
+var configuredTopKbps = (() => {
+  const raw = process.env.REPLICAS_DESKTOP_STREAM_VIDEO_BITRATE?.trim();
+  const match = raw?.match(/^(\d+(?:\.\d+)?)([MmKk]?)$/);
+  if (!match) return 2e4;
+  const value = Number.parseFloat(match[1]);
+  return Math.max(1, Math.round(match[2].toLowerCase() === "m" ? value * 1e3 : value));
+})();
+var qualityLadder = [
+  { fps, kbps: configuredTopKbps, crf: 18 },
+  { fps: Math.max(1, Math.round(fps / 2)), kbps: 6e3, crf: 20 },
+  { fps: Math.max(1, Math.round(fps / 2)), kbps: 3e3, crf: 23 },
+  { fps: Math.max(1, Math.round(fps / 4)), kbps: 1200, crf: 26 }
+];
+var keyframeMs = 250;
+var probeIntervalMs = 250;
+var targetBacklogMs = 120;
+var congestedBacklogMs = 250;
+var congestedDecodeQueue = 3;
+var fallbackBufferedBytes = 512 * 1024;
+var maximumBufferedBytes = 4 * 1024 * 1024;
 var display = process.env.REPLICAS_DESKTOP_DISPLAY?.replace(/^([^:])/, ":$1") || ":99";
 var videoCodec = "avc1.42E02A";
 var config = {
@@ -3508,7 +3544,7 @@ function validInput(value) {
   if (!value || typeof value !== "object" || !("type" in value) || typeof value.type !== "string") return false;
   if (value.type === "release") return true;
   if (value.type === "stats") return "videoFps" in value && typeof value.videoFps === "number" && Number.isFinite(value.videoFps) && "audioPacketsPerSecond" in value && typeof value.audioPacketsPerSecond === "number" && Number.isFinite(value.audioPacketsPerSecond) && "decodeQueue" in value && typeof value.decodeQueue === "number" && Number.isFinite(value.decodeQueue) && "rttMs" in value && typeof value.rttMs === "number" && Number.isFinite(value.rttMs);
-  if (value.type === "ping") return "sentAt" in value && typeof value.sentAt === "number";
+  if (value.type === "ping" || value.type === "pong") return "sentAt" in value && typeof value.sentAt === "number";
   if (value.type === "key") return "code" in value && typeof value.code === "string" && value.code.length < 40 && "down" in value && typeof value.down === "boolean";
   if (!("x" in value) || !("y" in value) || typeof value.x !== "number" || typeof value.y !== "number") return false;
   if (value.type === "pointer") return true;
@@ -3524,23 +3560,30 @@ async function runMediaServer() {
   const videoAssembler = new H264RtpAssembler();
   const audioClock = new RtpClock(48e3);
   const clients = /* @__PURE__ */ new Map();
-  let encoder;
-  let encoderRestart;
   let encoderStop;
+  let rung = 0;
+  let descents = 0;
+  let congestedSeconds = 0;
+  let comfortableSeconds = 0;
   let lastVideoAt = 0;
   let lastAudioAt = 0;
   let videoFrames = 0;
   let audioPackets = 0;
   let videoBytes = 0;
   let audioBytes = 0;
+  const queueMs = (state) => {
+    if (!state.probeAnswered) return 0;
+    const outstanding = state.probeSentAt ? Date.now() - state.probeSentAt : 0;
+    return Math.max(0, Math.max(state.probeAckedMs, outstanding) - state.baselineMs);
+  };
   const broadcast = (packet, keyframe = false) => {
     for (const [client, state] of clients) {
       if (client.readyState !== WebSocket2.OPEN) continue;
-      if (client.bufferedAmount > 4 * 1024 * 1024) {
+      if (client.bufferedAmount > maximumBufferedBytes) {
         client.close(1013, "stream client is too slow");
         continue;
       }
-      if (!keyframe && (state.waitingForKeyframe || client.bufferedAmount > 512 * 1024)) {
+      if (!keyframe && (state.waitingForKeyframe || queueMs(state) > targetBacklogMs || client.bufferedAmount > fallbackBufferedBytes)) {
         state.waitingForKeyframe = true;
         continue;
       }
@@ -3567,14 +3610,78 @@ async function runMediaServer() {
     audioBytes += rtp.payload.byteLength;
     broadcast(mediaPacket(3 /* Audio */, audioClock.microseconds(rtp.timestamp), rtp.payload));
   });
-  const startEncoder = () => {
-    clearTimeout(encoderStop);
-    if (encoder && encoder.exitCode === null) return;
-    clearTimeout(encoderRestart);
+  const superviseEncoder = (label, prepare, buildArgs, niceness = 0) => {
+    let child;
+    let retiring;
+    let restart;
+    let intent = 0;
+    const alive = (process2) => Boolean(process2 && process2.exitCode === null && process2.signalCode === null);
+    const start = () => {
+      clearTimeout(encoderStop);
+      if (alive(child)) return;
+      if (retiring) return;
+      clearTimeout(restart);
+      prepare();
+      const argv = niceness > 0 ? ["nice", "-n", String(niceness), "ffmpeg", ...buildArgs()] : ["ffmpeg", ...buildArgs()];
+      const spawned = spawn4(argv[0], argv.slice(1), { env: { ...process.env, DISPLAY: display }, stdio: ["ignore", "ignore", "pipe"] });
+      spawned.stderr?.on("data", (chunk) => process.stderr.write(`[desktop-stream] ${chunk}`));
+      child = spawned;
+      spawned.once("exit", (code, signal) => {
+        if (child !== spawned) return;
+        child = void 0;
+        if (clients.size === 0) return;
+        process.stderr.write(`[desktop-stream] ${label} encoder exited (${signal || code}); restarting
+`);
+        restart = setTimeout(start, 500);
+      });
+    };
+    return {
+      start,
+      running: () => alive(child),
+      stop: () => {
+        intent += 1;
+        clearTimeout(restart);
+        child?.kill("SIGTERM");
+        retiring?.kill("SIGKILL");
+        child = void 0;
+        retiring = void 0;
+      },
+      replace: () => {
+        const issued = intent += 1;
+        clearTimeout(restart);
+        const previous = child ?? retiring;
+        child = void 0;
+        retiring = void 0;
+        if (!alive(previous)) {
+          start();
+          return;
+        }
+        retiring = previous;
+        let settled = false;
+        const resume = () => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(forceExit);
+          clearTimeout(abandonWait);
+          if (intent !== issued) return;
+          retiring = void 0;
+          if (clients.size === 0) return;
+          start();
+        };
+        const forceExit = setTimeout(() => previous.kill("SIGKILL"), 2e3);
+        const abandonWait = setTimeout(resume, 4e3);
+        previous.once("exit", resume);
+        previous.kill("SIGTERM");
+      }
+    };
+  };
+  const videoEncoder = superviseEncoder("video", () => {
     videoAssembler.reset();
-    audioClock.reset();
-    const videoBitrate = process.env.REPLICAS_DESKTOP_STREAM_VIDEO_BITRATE || "12M";
-    encoder = spawn4("ffmpeg", [
+    for (const state of clients.values()) state.waitingForKeyframe = true;
+  }, () => {
+    const quality = qualityLadder[rung];
+    const keyframeInterval = Math.max(1, Math.round(quality.fps * keyframeMs / 1e3));
+    return [
       "-hide_banner",
       "-loglevel",
       "warning",
@@ -3582,16 +3689,10 @@ async function runMediaServer() {
       "nobuffer",
       "-flags",
       "low_delay",
-      "-thread_queue_size",
-      "1024",
-      "-f",
-      "pulse",
-      "-fragment_size",
-      "2048",
-      "-use_wallclock_as_timestamps",
-      "1",
-      "-i",
-      process.env.REPLICAS_DESKTOP_STREAM_AUDIO_SOURCE || "default",
+      "-probesize",
+      "32",
+      "-analyzeduration",
+      "0",
       "-thread_queue_size",
       "1024",
       "-f",
@@ -3599,20 +3700,18 @@ async function runMediaServer() {
       "-draw_mouse",
       "0",
       "-framerate",
-      String(fps),
+      String(quality.fps),
       "-video_size",
       `${width}x${height}`,
       "-use_wallclock_as_timestamps",
       "1",
       "-i",
       `${display}.0`,
-      "-map",
-      "1:v:0",
       "-an",
       "-c:v",
       "libx264",
       "-preset",
-      "ultrafast",
+      x264Preset,
       "-tune",
       "zerolatency",
       "-profile:v",
@@ -3630,11 +3729,11 @@ async function runMediaServer() {
       "-sc_threshold",
       "0",
       "-crf",
-      "18",
+      String(quality.crf),
       "-maxrate",
-      videoBitrate,
+      `${quality.kbps}k`,
       "-bufsize",
-      "1M",
+      `${Math.round(quality.kbps * keyframeMs / 1e3)}k`,
       "-x264-params",
       `repeat-headers=1:sliced-threads=1:slices=4:keyint=${keyframeInterval}:min-keyint=${keyframeInterval}:scenecut=0`,
       "-fps_mode",
@@ -3645,57 +3744,111 @@ async function runMediaServer() {
       "rtp",
       "-payload_type",
       "96",
-      `rtp://127.0.0.1:${videoPort}?pkt_size=1200&connect=1&rtcpport=${videoPort}`,
-      "-map",
-      "0:a:0",
-      "-vn",
-      "-af",
-      "aresample=async=1:first_pts=0",
-      "-c:a",
-      "libopus",
-      "-application",
-      "lowdelay",
-      "-frame_duration",
-      "20",
-      "-b:a",
-      "128k",
-      "-ar",
-      "48000",
-      "-ac",
-      "2",
-      "-flush_packets",
-      "1",
-      "-f",
-      "rtp",
-      "-payload_type",
-      "111",
-      `rtp://127.0.0.1:${audioPort}?pkt_size=1200&connect=1&rtcpport=${audioPort}`
-    ], { env: { ...process.env, DISPLAY: display }, stdio: ["ignore", "ignore", "pipe"] });
-    encoder.stderr?.on("data", (chunk) => process.stderr.write(`[desktop-stream] ${chunk}`));
-    encoder.once("exit", (code, signal) => {
-      encoder = void 0;
-      if (clients.size > 0) {
-        process.stderr.write(`[desktop-stream] encoder exited (${signal || code}); restarting
+      `rtp://127.0.0.1:${videoPort}?pkt_size=1200&connect=1&rtcpport=${videoPort}`
+    ];
+  }, 10);
+  const audioEncoder = superviseEncoder("audio", () => audioClock.reset(), () => [
+    "-hide_banner",
+    "-loglevel",
+    "warning",
+    "-fflags",
+    "nobuffer",
+    "-flags",
+    "low_delay",
+    "-probesize",
+    "32",
+    "-analyzeduration",
+    "0",
+    "-thread_queue_size",
+    "1024",
+    "-f",
+    "pulse",
+    "-fragment_size",
+    "2048",
+    "-use_wallclock_as_timestamps",
+    "1",
+    "-i",
+    process.env.REPLICAS_DESKTOP_STREAM_AUDIO_SOURCE || "default",
+    "-vn",
+    "-af",
+    "aresample=async=1:first_pts=0",
+    "-c:a",
+    "libopus",
+    "-application",
+    "lowdelay",
+    "-frame_duration",
+    "20",
+    "-b:a",
+    "128k",
+    "-ar",
+    "48000",
+    "-ac",
+    "2",
+    "-flush_packets",
+    "1",
+    "-f",
+    "rtp",
+    "-payload_type",
+    "111",
+    `rtp://127.0.0.1:${audioPort}?pkt_size=1200&connect=1&rtcpport=${audioPort}`
+  ]);
+  const startEncoders = () => {
+    videoEncoder.start();
+    audioEncoder.start();
+  };
+  const setRung = (next) => {
+    if (next === rung) return;
+    if (next > rung) descents += 1;
+    rung = next;
+    congestedSeconds = 0;
+    comfortableSeconds = 0;
+    process.stderr.write(`[desktop-stream] quality rung ${rung} (${qualityLadder[rung].fps} fps, ${qualityLadder[rung].kbps}k)
 `);
-        encoderRestart = setTimeout(startEncoder, 500);
-      }
-    });
+    videoEncoder.replace();
   };
-  const stopEncoderSoon = () => {
+  const stopEncodersSoon = () => {
     clearTimeout(encoderStop);
     encoderStop = setTimeout(() => {
       if (clients.size > 0) return;
-      encoder?.kill("SIGTERM");
-      encoder = void 0;
+      videoEncoder.stop();
+      audioEncoder.stop();
     }, 5e3);
   };
+  const probe = setInterval(() => {
+    for (const [client, state] of clients) {
+      if (client.readyState !== WebSocket2.OPEN || state.probeSentAt) continue;
+      state.probeSentAt = Date.now();
+      client.send(JSON.stringify({ type: "ping", sentAt: state.probeSentAt }));
+    }
+  }, probeIntervalMs);
+  probe.unref();
+  const control = setInterval(() => {
+    const states = [...clients.values()];
+    if (states.length === 0) return;
+    const struggling = states.filter((state) => queueMs(state) > congestedBacklogMs || (state.stats?.decodeQueue ?? 0) > congestedDecodeQueue).length;
+    if (struggling === states.length) {
+      comfortableSeconds = 0;
+      congestedSeconds += 1;
+      if (congestedSeconds >= 2) setRung(Math.min(qualityLadder.length - 1, rung + 1));
+      return;
+    }
+    congestedSeconds = 0;
+    if (struggling > 0) {
+      comfortableSeconds = 0;
+      return;
+    }
+    comfortableSeconds += 1;
+    if (comfortableSeconds >= Math.min(300, 15 * 2 ** descents)) setRung(Math.max(0, rung - 1));
+  }, 1e3);
+  control.unref();
   const httpServer = createServer2((request, response) => {
     const url = new URL(request.url || "/", "http://localhost");
     if (url.pathname === "/health") {
       response.setHeader("content-type", "application/json");
       response.end(JSON.stringify({
         clients: clients.size,
-        encoder: Boolean(encoder && encoder.exitCode === null),
+        encoder: videoEncoder.running(),
+        audioEncoder: audioEncoder.running(),
         lastVideoFrameMsAgo: lastVideoAt ? Date.now() - lastVideoAt : null,
         lastAudioPacketMsAgo: lastAudioAt ? Date.now() - lastAudioAt : null,
         videoFrames,
@@ -3703,9 +3856,12 @@ async function runMediaServer() {
         videoBytes,
         audioBytes,
         clientStats: [...clients.values()].flatMap((client) => client.stats ? [client.stats] : []),
+        clientQueueMs: [...clients.values()].map((client) => Math.round(queueMs(client))),
+        clientBaselineMs: [...clients.values()].map((client) => Number.isFinite(client.baselineMs) ? Math.round(client.baselineMs) : null),
+        qualityRung: rung,
         width,
         height,
-        fps
+        fps: qualityLadder[rung].fps
       }));
       return;
     }
@@ -3716,7 +3872,11 @@ async function runMediaServer() {
       response.end("Not found");
       return;
     }
-    response.setHeader("cache-control", "no-store");
+    if (extname(path) === ".html") {
+      startEncoders();
+      if (clients.size === 0) stopEncodersSoon();
+    }
+    response.setHeader("cache-control", extname(path) === ".html" ? "no-store" : "private, max-age=3600");
     response.setHeader("content-type", contentTypes[extname(path)] || "application/octet-stream");
     createReadStream(path).pipe(response);
   });
@@ -3729,9 +3889,16 @@ async function runMediaServer() {
     webSocketServer.handleUpgrade(request, socket, head, (client) => webSocketServer.emit("connection", client, request));
   });
   webSocketServer.on("connection", (client) => {
-    clients.set(client, { waitingForKeyframe: true, input: new InputBridge(display, width, height) });
+    clients.set(client, {
+      waitingForKeyframe: true,
+      input: new InputBridge(display, width, height),
+      probeSentAt: 0,
+      probeAckedMs: 0,
+      probeAnswered: false,
+      baselineMs: Number.POSITIVE_INFINITY
+    });
     client.send(JSON.stringify(config));
-    startEncoder();
+    startEncoders();
     client.on("message", (raw, binary) => {
       if (binary) return;
       let message;
@@ -3742,21 +3909,33 @@ async function runMediaServer() {
       }
       if (!validInput(message)) return;
       if (message.type === "ping") client.send(JSON.stringify({ type: "pong", sentAt: message.sentAt }));
-      else if (message.type === "stats") {
+      else if (message.type === "pong") {
+        const state = clients.get(client);
+        if (!state || message.sentAt !== state.probeSentAt) return;
+        state.probeAckedMs = Date.now() - state.probeSentAt;
+        state.probeSentAt = 0;
+        state.probeAnswered = true;
+        state.baselineMs = Math.min(state.baselineMs, state.probeAckedMs);
+      } else if (message.type === "stats") {
         const state = clients.get(client);
         if (!state) return;
         state.stats = {
-          videoFps: message.videoFps,
-          audioPacketsPerSecond: message.audioPacketsPerSecond,
-          decodeQueue: message.decodeQueue,
-          rttMs: message.rttMs
+          videoFps: clamp(message.videoFps, 0, 1e3),
+          audioPacketsPerSecond: clamp(message.audioPacketsPerSecond, 0, 1e3),
+          decodeQueue: clamp(message.decodeQueue, 0, 1e3),
+          rttMs: clamp(message.rttMs, 0, 6e5)
         };
       } else clients.get(client)?.input.handle(message);
     });
     client.once("close", () => {
       clients.get(client)?.input.close();
       clients.delete(client);
-      if (clients.size === 0) stopEncoderSoon();
+      if (clients.size > 0) return;
+      rung = 0;
+      descents = 0;
+      congestedSeconds = 0;
+      comfortableSeconds = 0;
+      stopEncodersSoon();
     });
   });
   await new Promise((resolveServer, reject) => {
@@ -3772,13 +3951,15 @@ async function runMediaServer() {
     const close = () => {
       if (closing) return;
       closing = true;
-      clearTimeout(encoderRestart);
+      clearInterval(probe);
+      clearInterval(control);
       clearTimeout(encoderStop);
       for (const [client, state] of clients) {
         state.input.close();
         client.close(1001, "server shutting down");
       }
-      encoder?.kill("SIGTERM");
+      videoEncoder.stop();
+      audioEncoder.stop();
       videoSocket.close();
       audioSocket.close();
       webSocketServer.close();

package/dist/stream-viewer.js

@@ -166,7 +166,7 @@ var handleBinary = (data) => {
   }
   if (!videoDecoder || !activeVideoConfig || videoDecoder.state !== "configured") return;
   const key = kind === 1 /* VideoKey */;
-  if (videoDecoder.decodeQueueSize > 12) {
+  if (videoDecoder.decodeQueueSize > 3) {
     videoDecoder.reset();
     videoDecoder.configure(activeVideoConfig);
     waitingForKeyframe = true;
@@ -205,6 +205,10 @@ var connect = () => {
       rtt = performance.now() - message.sentAt;
       return;
     }
+    if (message.type === "ping") {
+      send({ type: "pong", sentAt: message.sentAt });
+      return;
+    }
     if (message.type !== "config" || message.protocolVersion !== STREAM_PROTOCOL_VERSION) return;
     config = message;
     fitScreen();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-computer",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Replicas workspace computer-use runtime",
   "type": "module",
   "main": "dist/index.js",