linkshell-cli 0.8.1 → 0.8.2

package/dist/host/src/screen-pacer.d.ts

@@ -0,0 +1,62 @@
+/** How the picture is sent, best first. A gateway carries messages rather than video: relayed, it starts lower. */
+export declare const LADDER: readonly [{
+    readonly fps: 20;
+    readonly width: 1600;
+    readonly bitrate: "3M";
+    readonly ceiling: "4M";
+}, {
+    readonly fps: 15;
+    readonly width: 1440;
+    readonly bitrate: "1500k";
+    readonly ceiling: "2M";
+}, {
+    readonly fps: 12;
+    readonly width: 1280;
+    readonly bitrate: "900k";
+    readonly ceiling: "1300k";
+}, {
+    readonly fps: 10;
+    readonly width: 1024;
+    readonly bitrate: "500k";
+    readonly ceiling: "700k";
+}, {
+    readonly fps: 8;
+    readonly width: 854;
+    readonly bitrate: "260k";
+    readonly ceiling: "380k";
+}];
+/** The level a relayed stream starts at, and never goes above. */
+export declare const RELAY_LEVEL = 2;
+export declare class Pacer {
+    private seq;
+    private shown;
+    private readonly sentAt;
+    /** The path's own delay: the least a frame has taken to come back as shown. */
+    private floor;
+    private behindSince?;
+    private troubles;
+    private calmSince;
+    private calmFor;
+    private raisedAt?;
+    private firstSent?;
+    private heard;
+    private settledAt;
+    private lastSent;
+    constructor(now: number);
+    /** Whether frames are being dropped for the viewer to catch up. */
+    get dropping(): boolean;
+    /** How long ago the oldest frame not yet shown was sent. */
+    private lag;
+    /** The number to send this frame under, or undefined to drop it. */
+    next(key: boolean, now: number): number | undefined;
+    /** The viewer has shown everything up to `seq`. */
+    ack(seq: number, now: number): void;
+    /** Whether to move to a lighter picture ("down") or try a better one ("up"); asked after each frame. */
+    advice(now: number, canGoUp: boolean, canGoDown: boolean): "up" | "down" | undefined;
+    /**
+     * The capture was started again (another level). The viewer drops what it had of the old stream
+     * without showing it, so none of that will ever be answered for: the new stream starts clean, with
+     * its keyframe, and is judged on its own frames once what was on the way has had time to arrive.
+     */
+    restarted(now: number): void;
+}

package/dist/host/src/screen-pacer.js

@@ -0,0 +1,143 @@
+// Keeping a viewer close to live. The picture goes down pipes that deliver
+// everything, in order (the gateway's relay, a data channel, a socket): when
+// the network can't carry the stream, nothing is lost, it queues, and the
+// phone ends up watching the past. So the viewer says which frame it has shown,
+// and the host, knowing how far behind that is, stops adding to the queue
+// (frames are dropped here, before anything relays them), resumes at a
+// keyframe once the path has caught up, and moves to a lighter picture when
+// that keeps happening.
+/** How the picture is sent, best first. A gateway carries messages rather than video: relayed, it starts lower. */
+export const LADDER = [
+    { fps: 20, width: 1600, bitrate: "3M", ceiling: "4M" },
+    { fps: 15, width: 1440, bitrate: "1500k", ceiling: "2M" },
+    { fps: 12, width: 1280, bitrate: "900k", ceiling: "1300k" },
+    { fps: 10, width: 1024, bitrate: "500k", ceiling: "700k" },
+    { fps: 8, width: 854, bitrate: "260k", ceiling: "380k" },
+];
+/** The level a relayed stream starts at, and never goes above. */
+export const RELAY_LEVEL = 2;
+/** Behind by this much more than the path's own delay: stop sending. */
+const BEHIND_MS = 450;
+/** Caught up to within this of the path's own delay: resume (at a keyframe). */
+const CAUGHT_UP_MS = 150;
+/** Stuck behind for this long, or behind twice within TROUBLE_WINDOW_MS: a lighter picture. */
+const STUCK_MS = 2500;
+const TROUBLE_WINDOW_MS = 10_000;
+/** Smooth for this long: try a better picture. Doubles each time the better one didn't hold. */
+const CALM_MS = 30_000;
+const CALM_MAX_MS = 240_000;
+/** A viewer that never says what it has shown is not paced at all. */
+const SILENT_MS = 5000;
+/** After a change of picture, what was already on its way gets this long to arrive before more is concluded. */
+const SETTLE_MS = 4000;
+/** No path's own delay is taken to be longer than this: a stream that began on a choked path would look normal. */
+const FLOOR_MAX_MS = 800;
+/** Behind, and nothing heard for this long: a keyframe goes anyway. Whatever went wrong, the next answer ends it. */
+const PROBE_MS = 8000;
+export class Pacer {
+    seq = 0;
+    shown = 0;
+    sentAt = new Map();
+    /** The path's own delay: the least a frame has taken to come back as shown. */
+    floor = Infinity;
+    behindSince;
+    troubles = [];
+    calmSince;
+    calmFor = CALM_MS;
+    raisedAt;
+    firstSent;
+    heard = false;
+    settledAt = 0;
+    lastSent = 0;
+    constructor(now) {
+        this.calmSince = now;
+    }
+    /** Whether frames are being dropped for the viewer to catch up. */
+    get dropping() {
+        return this.behindSince !== undefined;
+    }
+    /** How long ago the oldest frame not yet shown was sent. */
+    lag(now) {
+        const oldest = this.sentAt.get(this.shown + 1);
+        return oldest === undefined ? 0 : now - oldest;
+    }
+    /** The number to send this frame under, or undefined to drop it. */
+    next(key, now) {
+        this.firstSent ??= now;
+        const paced = this.heard || now - this.firstSent < SILENT_MS;
+        if (paced) {
+            const own = Number.isFinite(this.floor) ? Math.min(this.floor, FLOOR_MAX_MS) : 0;
+            const lag = this.lag(now);
+            if (this.behindSince === undefined && lag > own + BEHIND_MS) {
+                this.behindSince = now;
+                this.troubles.push(now);
+                this.calmSince = now;
+            }
+            if (this.behindSince !== undefined) {
+                // Back in at a keyframe, once what was sent has been shown (or nearly).
+                const caughtUp = this.sentAt.size === 0 || lag <= own + CAUGHT_UP_MS;
+                if (!key || (!caughtUp && now - this.lastSent < PROBE_MS))
+                    return undefined;
+                if (caughtUp) {
+                    this.behindSince = undefined;
+                    this.calmSince = now;
+                }
+            }
+        }
+        const seq = ++this.seq;
+        this.sentAt.set(seq, now);
+        this.lastSent = now;
+        // A viewer that says nothing must not make this grow for ever.
+        if (this.sentAt.size > 600)
+            this.sentAt.delete(this.sentAt.keys().next().value);
+        return seq;
+    }
+    /** The viewer has shown everything up to `seq`. */
+    ack(seq, now) {
+        if (!Number.isInteger(seq) || seq <= this.shown || seq > this.seq)
+            return;
+        this.heard = true;
+        const sent = this.sentAt.get(seq);
+        if (sent !== undefined)
+            this.floor = Math.min(this.floor, now - sent);
+        for (const key of this.sentAt.keys()) {
+            if (key > seq)
+                break;
+            this.sentAt.delete(key);
+        }
+        this.shown = seq;
+    }
+    /** Whether to move to a lighter picture ("down") or try a better one ("up"); asked after each frame. */
+    advice(now, canGoUp, canGoDown) {
+        if (now < this.settledAt)
+            return undefined;
+        this.troubles = this.troubles.filter((at) => at >= this.settledAt && now - at < TROUBLE_WINDOW_MS);
+        const stuck = this.behindSince !== undefined && now - Math.max(this.behindSince, this.settledAt) > STUCK_MS;
+        if (canGoDown && (stuck || this.troubles.length >= 2)) {
+            // The better picture just tried didn't hold: wait longer before trying it again.
+            if (this.raisedAt !== undefined && now - this.raisedAt < TROUBLE_WINDOW_MS * 2)
+                this.calmFor = Math.min(this.calmFor * 2, CALM_MAX_MS);
+            this.raisedAt = undefined;
+            return "down";
+        }
+        if (canGoUp && this.behindSince === undefined && now - this.calmSince > this.calmFor) {
+            this.raisedAt = now;
+            return "up";
+        }
+        return undefined;
+    }
+    /**
+     * The capture was started again (another level). The viewer drops what it had of the old stream
+     * without showing it, so none of that will ever be answered for: the new stream starts clean, with
+     * its keyframe, and is judged on its own frames once what was on the way has had time to arrive.
+     */
+    restarted(now) {
+        this.sentAt.clear();
+        this.shown = this.seq;
+        this.behindSince = undefined;
+        this.troubles = [];
+        this.calmSince = now;
+        this.settledAt = now + SETTLE_MS;
+    }
+}
+//# sourceMappingURL=screen-pacer.js.map

package/dist/host/src/screen-pacer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-pacer.js","sourceRoot":"","sources":["../../../../host/src/screen-pacer.ts"],"names":[],"mappings":"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"}

package/dist/host/src/screen-viewer.js

@@ -107,7 +107,18 @@ function sps(unit) {
     if (unit[i] === 0 && unit[i + 1] === 0 && unit[i + 2] === 1 && (unit[i + 3] & 0x1f) === 7) return unit.subarray(i + 3);
 }
 if (!("VideoDecoder" in window)) say("这个系统版本的浏览器内核不支持视频解码，请升级系统后再试。");
-let decoder;
+let decoder, skipping = false, arrived = 0;
+// The host is told which frame is on screen: that is how it knows when this end has fallen behind,
+// and stops sending rather than let the picture drift into the past.
+let lastShown = 0, telling = 0;
+// For trying a slow path out without one: ?lag=2500&lagFor=12 answers 2.5 s late for the first 12 s.
+const lag = Number(query.get("lag")) || 0, lagUntil = performance.now() + (Number(query.get("lagFor")) || 0) * 1000;
+function shownUpTo(seq) {
+  if (seq > lastShown) lastShown = seq;
+  if (lag && performance.now() < lagUntil) { const late = lastShown; setTimeout(() => send({ t: "ack", n: late }), lag); return; }
+  if (!telling) telling = setTimeout(() => { telling = 0; send({ t: "ack", n: lastShown }); }, 40);
+}
+let lighterAt = -Infinity;
 const ws = new WebSocket((location.protocol === "https:" ? "wss://" : "ws://") + location.host + "/stream" + location.search);
 ws.binaryType = "arraybuffer";
 const send = (message) => { if (ws.readyState === 1) ws.send(JSON.stringify(message)); };
@@ -115,9 +126,15 @@ ws.onopen = () => { if (mode !== "view") askControl(); };
 ws.onmessage = (event) => {
   if (typeof event.data === "string") return heard(JSON.parse(event.data));
   if (!("VideoDecoder" in window)) return;
-  const bytes = new Uint8Array(event.data);
-  const key = bytes[0] === 1;
-  const unit = bytes.subarray(1);
+  // A frame: whether it is a keyframe, its number, the picture.
+  const head = new DataView(event.data);
+  const key = head.getUint8(0) === 1;
+  const seq = head.getUint32(1);
+  const unit = new Uint8Array(event.data, 5);
+  arrived = seq;
+  // A decoder that can't keep up skips to the next keyframe; what it skips has still arrived.
+  if (decoder && !key && (skipping || decoder.decodeQueueSize > 8)) { skipping = true; return shownUpTo(seq); }
+  skipping = false;
   if (!decoder) {
     const params = key && sps(unit);
     if (!params) return;
@@ -129,6 +146,7 @@ ws.onmessage = (event) => {
           layout();
         }
         ctx.drawImage(frame, 0, 0);
+        shownUpTo(frame.timestamp);
         frame.close();
         say("");
       },
@@ -136,12 +154,24 @@ ws.onmessage = (event) => {
     });
     decoder.configure({ codec: "avc1." + hex(params[1]) + hex(params[2]) + hex(params[3]), optimizeForLatency: true });
   }
-  decoder.decode(new EncodedVideoChunk({ type: key ? "key" : "delta", timestamp: performance.now() * 1000, data: unit }));
+  decoder.decode(new EncodedVideoChunk({ type: key ? "key" : "delta", timestamp: seq, data: unit }));
 };
 ws.onclose = () => { if (note.classList.contains("gone") || note.textContent.startsWith("正在")) say("屏幕连接已断开"); };
 
 function heard(message) {
   if (message.error) return say(message.error);
+  if (message.restart) {
+    // The host starts the stream again at another quality: a new decoder for it.
+    try { if (decoder) decoder.close(); } catch {}
+    decoder = undefined;
+    skipping = false;
+    // What the old decoder still held will never be shown: it has arrived, and that is said.
+    shownUpTo(arrived);
+    if (message.lighter && performance.now() - lighterAt > 30000) {
+      lighterAt = performance.now();
+      hint("网络较慢：已降低画质，优先保证跟得上", 3000);
+    }
+  }
   if (message.control) {
     const was = controlling();
     Object.assign(control, { known: true, reason: "" }, message.control);

package/dist/host/src/screen-viewer.js.map

@@ -1 +1 @@
-{"version":3,"file":"screen-viewer.js","sourceRoot":"","sources":["../../../../host/src/screen-viewer.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,2EAA2E;AAC3E,6EAA6E;AAC7E,mEAAmE;AACnE,EAAE;AACF,4DAA4D;AAC5D,yEAAyE;AACzE,2CAA2C;AAC3C,6EAA6E;AAC7E,+EAA+E;AAC/E,2CAA2C;AAC3C,6FAA6F;AAE7F,MAAM,IAAI,GAAG,CAAC,IAAY,EAAE,EAAE,CAC5B,uJAAuJ,IAAI,QAAQ,CAAC;AAEtK,MAAM,KAAK,GAAG;IACZ,IAAI,EAAE,IAAI,CAAC,qHAAqH,CAAC;IACjI,QAAQ,EAAE,IAAI,CAAC,6DAA6D,CAAC;IAC7E,KAAK,EAAE,IAAI,CAAC,oGAAoG,CAAC;IACjH,QAAQ,EAAE,IAAI,CAAC,iJAAiJ,CAAC;IACjK,GAAG,EAAE,IAAI,CAAC,0EAA0E,CAAC;IACrF,MAAM,EAAE,IAAI,CAAC,qHAAqH,CAAC;IACnI,MAAM,EAAE,IAAI,CAAC,oDAAoD,CAAC;IAClE,MAAM,EAAE,IAAI,CAAC,oDAAoD,CAAC;IAClE,IAAI,EAAE,IAAI,CAAC,4BAA4B,CAAC;CACzC,CAAC;AAEF,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCvB,CAAC;AAEF,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmqBxB,CAAC;AAEF,MAAM,UAAU,UAAU;IACxB,OAAO;;;;SAIA,KAAK;;;;;;;;;;;;kEAYoD,KAAK,CAAC,QAAQ;+DACjB,KAAK,CAAC,GAAG;gEACR,KAAK,CAAC,MAAM;;;;;;;;;;;;;;;;;;6CAkB/B,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;UACxD,MAAM;eACD,CAAC;AAChB,CAAC"}
+{"version":3,"file":"screen-viewer.js","sourceRoot":"","sources":["../../../../host/src/screen-viewer.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,2EAA2E;AAC3E,6EAA6E;AAC7E,mEAAmE;AACnE,EAAE;AACF,4DAA4D;AAC5D,yEAAyE;AACzE,2CAA2C;AAC3C,6EAA6E;AAC7E,+EAA+E;AAC/E,2CAA2C;AAC3C,6FAA6F;AAE7F,MAAM,IAAI,GAAG,CAAC,IAAY,EAAE,EAAE,CAC5B,uJAAuJ,IAAI,QAAQ,CAAC;AAEtK,MAAM,KAAK,GAAG;IACZ,IAAI,EAAE,IAAI,CAAC,qHAAqH,CAAC;IACjI,QAAQ,EAAE,IAAI,CAAC,6DAA6D,CAAC;IAC7E,KAAK,EAAE,IAAI,CAAC,oGAAoG,CAAC;IACjH,QAAQ,EAAE,IAAI,CAAC,iJAAiJ,CAAC;IACjK,GAAG,EAAE,IAAI,CAAC,0EAA0E,CAAC;IACrF,MAAM,EAAE,IAAI,CAAC,qHAAqH,CAAC;IACnI,MAAM,EAAE,IAAI,CAAC,oDAAoD,CAAC;IAClE,MAAM,EAAE,IAAI,CAAC,oDAAoD,CAAC;IAClE,IAAI,EAAE,IAAI,CAAC,4BAA4B,CAAC;CACzC,CAAC;AAEF,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCvB,CAAC;AAEF,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAisBxB,CAAC;AAEF,MAAM,UAAU,UAAU;IACxB,OAAO;;;;SAIA,KAAK;;;;;;;;;;;;kEAYoD,KAAK,CAAC,QAAQ;+DACjB,KAAK,CAAC,GAAG;gEACR,KAAK,CAAC,MAAM;;;;;;;;;;;;;;;;;;6CAkB/B,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;UACxD,MAAM;eACD,CAAC;AAChB,CAAC"}

package/dist/host/src/screen.d.ts

@@ -3,25 +3,6 @@ export interface Display {
     index: number;
     name: string;
 }
-/**
- * How the picture is sent. `full` when it goes straight to the device; `low`
- * when it is relayed by a gateway, which should carry messages rather than video.
- */
-declare const PROFILES: {
-    readonly full: {
-        readonly fps: 20;
-        readonly width: 1600;
-        readonly bitrate: "3M";
-        readonly ceiling: "4M";
-    };
-    readonly low: {
-        readonly fps: 12;
-        readonly width: 1280;
-        readonly bitrate: "900k";
-        readonly ceiling: "1300k";
-    };
-};
-export type ScreenProfile = keyof typeof PROFILES;
 export interface ScreenAccess {
     supported: boolean;
     ffmpeg: boolean;
@@ -30,7 +11,8 @@ export interface ScreenAccess {
     app?: string;
     problem?: string;
 }
-export declare function captureArgs(display: number, quality?: ScreenProfile): string[];
+/** The capture for one rung of the ladder (see `screen-pacer.ts`): 0 is the best picture. */
+export declare function captureArgs(display: number, level?: number): string[];
 /** Splits an Annex-B stream at access-unit delimiters (NAL type 9) into whole frames. */
 export declare class AccessUnitSplitter {
     private buffer;
@@ -57,8 +39,13 @@ export declare class ScreenShare {
     private token;
     private displays;
     private readonly captures;
-    /** Captures the app runs for this host: each one's way to end it. */
-    private readonly stops;
+    /**
+     * The capture that has the screen. The system gives it to one at a time, and
+     * one started while another still holds it never gets a frame, even after
+     * the other has gone: the next starts once this one has.
+     */
+    private holder?;
+    private turn;
     private readonly controls;
     constructor(log: (message: string) => void);
     start(): Promise<{
@@ -74,9 +61,10 @@ export declare class ScreenShare {
      * `ask`, the system asks for the first permission missing.
      */
     access(ask: boolean): Promise<ScreenAccess>;
-    /** Starts a capture where it may record; resolves to the way to end it. */
+    /** Starts a capture where it may record. Undefined when it may not: the viewer has been told why. */
     private capture;
+    /** Takes the screen for a new capture: whatever holds it is ended, and has left, before the new one starts. */
+    private take;
     private stream;
     stop(): void;
 }
-export {};

package/dist/host/src/screen.js

@@ -5,6 +5,7 @@ import { promisify } from "node:util";
 import { WebSocketServer } from "ws";
 import { RpcError } from "@linkshell/wire";
 import { closeInputApp, hostAccess, inputApp, InputControl } from "./input.js";
+import { LADDER, Pacer, RELAY_LEVEL } from "./screen-pacer.js";
 import { viewerPage } from "./screen-viewer.js";
 // Viewing the computer's screen from the phone. The host serves a small
 // viewer page and an H.264 stream on a loopback port; the phone opens it
@@ -18,14 +19,6 @@ import { viewerPage } from "./screen-viewer.js";
 // carries one, LinkShell.app, and the capture runs as its child: the
 // permission is LinkShell's, whichever terminal started the host.
 const run = promisify(execFile);
-/**
- * How the picture is sent. `full` when it goes straight to the device; `low`
- * when it is relayed by a gateway, which should carry messages rather than video.
- */
-const PROFILES = {
-    full: { fps: 20, width: 1600, bitrate: "3M", ceiling: "4M" },
-    low: { fps: 12, width: 1280, bitrate: "900k", ceiling: "1300k" },
-};
 async function hasFfmpeg() {
     return run("ffmpeg", ["-hide_banner", "-version"], { timeout: 5000 }).then(() => true, () => false);
 }
@@ -46,8 +39,9 @@ async function listDisplays() {
     }
     return displays;
 }
-export function captureArgs(display, quality = "full") {
-    const profile = PROFILES[quality];
+/** The capture for one rung of the ladder (see `screen-pacer.ts`): 0 is the best picture. */
+export function captureArgs(display, level = 0) {
+    const profile = LADDER[Math.min(Math.max(level, 0), LADDER.length - 1)];
     const input = process.platform === "darwin"
         ? ["-f", "avfoundation", "-capture_cursor", "1", "-framerate", String(profile.fps), "-i", `${display}:none`]
         : ["-f", "x11grab", "-framerate", String(profile.fps), "-i", process.env.DISPLAY ?? ":0"];
@@ -67,8 +61,9 @@ export function captureArgs(display, quality = "full") {
         // ProMotion display): the frames are dropped here, before the encoder and the network pay for them.
         `fps=${profile.fps},scale='min(${profile.width},iw)':-2,format=yuv420p`,
         ...encode,
+        // A keyframe a second: a viewer that fell behind is back on the live picture within one.
         "-g",
-        String(profile.fps * 2),
+        String(profile.fps),
         "-bf",
         "0",
         // An access-unit delimiter before every frame, so the stream splits into frames cleanly.
@@ -172,8 +167,13 @@ export class ScreenShare {
     token = "";
     displays = [];
     captures = new Set();
-    /** Captures the app runs for this host: each one's way to end it. */
-    stops = new Set();
+    /**
+     * The capture that has the screen. The system gives it to one at a time, and
+     * one started while another still holds it never gets a frame, even after
+     * the other has gone: the next starts once this one has.
+     */
+    holder;
+    turn = Promise.resolve();
     controls = new Set();
     constructor(log) {
         this.log = log;
@@ -210,8 +210,9 @@ export class ScreenShare {
                 socket.destroy();
                 return;
             }
-            const quality = url.searchParams.get("q") === "low" ? "low" : "full";
-            sockets.handleUpgrade(request, socket, head, (ws) => this.stream(ws, Number(url.searchParams.get("display") ?? NaN), quality));
+            // "low": the viewer is reached through a gateway, which should carry messages rather than video.
+            const relayed = url.searchParams.get("q") === "low";
+            sockets.handleUpgrade(request, socket, head, (ws) => this.stream(ws, Number(url.searchParams.get("display") ?? NaN), relayed));
         });
         this.server = server;
         return new Promise((resolve, reject) => {
@@ -247,10 +248,20 @@ export class ScreenShare {
             return { supported, ffmpeg, recording: null, control: null, problem: error.message };
         }
     }
-    /** Starts a capture where it may record; resolves to the way to end it. */
-    async capture(index, quality, on) {
-        const args = captureArgs(index, quality);
+    /** Starts a capture where it may record. Undefined when it may not: the viewer has been told why. */
+    async capture(index, level, on) {
+        const args = captureArgs(index, level);
+        let ended = false;
+        let leave = () => { };
+        const gone = new Promise((resolve) => (leave = resolve));
+        const data = (chunk) => {
+            if (!ended)
+                on.data(chunk);
+        };
         const finished = (code, errors) => {
+            leave();
+            if (ended)
+                return;
             if (code)
                 this.log(`[screen] capture exited ${code}: ${errors.trim()}`);
             on.exit(!code ? undefined : /permission|not authorized|denied/i.test(errors) ? notAllowed("") : "屏幕捕获失败");
@@ -262,13 +273,16 @@ export class ScreenShare {
                 // Someone may be at the computer: the system's question, and its settings, come up there.
                 void app.ask("recording").catch(() => { });
                 on.exit(notAllowed(status.app));
-                return () => { };
+                return undefined;
             }
-            const stop = await app.capture(await ffmpegPath(), args, { data: on.data, exit: finished });
-            this.stops.add(stop);
-            return () => {
-                this.stops.delete(stop);
-                stop();
+            const stop = await app.capture(await ffmpegPath(), args, { data, exit: finished });
+            return {
+                on,
+                gone,
+                end: () => {
+                    ended = true;
+                    stop();
+                },
             };
         }
         if (process.platform === "darwin") {
@@ -277,22 +291,50 @@ export class ScreenShare {
             if (status && !status.recording) {
                 void hostAccess(this.log, "recording").catch(() => { });
                 on.exit(notAllowed(status.app));
-                return () => { };
+                return undefined;
             }
         }
         const capture = spawn("ffmpeg", args, { stdio: ["ignore", "pipe", "pipe"] });
         this.captures.add(capture);
         let errors = "";
-        capture.stdout.on("data", on.data);
+        capture.stdout.on("data", data);
         capture.stderr.on("data", (chunk) => (errors = (errors + chunk.toString()).slice(-2000)));
         capture.on("error", (error) => finished(-1, error.message));
         capture.on("exit", (code) => {
             this.captures.delete(capture);
             finished(code ?? 0, errors);
         });
-        return () => endCapture(capture);
+        return {
+            on,
+            gone,
+            end: () => {
+                ended = true;
+                endCapture(capture);
+            },
+        };
+    }
+    /** Takes the screen for a new capture: whatever holds it is ended, and has left, before the new one starts. */
+    take(index, level, on, wanted) {
+        const mine = this.turn.then(async () => {
+            const previous = this.holder;
+            if (previous) {
+                this.holder = undefined;
+                previous.end();
+                // Another device's picture ends here; a viewer changing its own just carries on.
+                if (previous.on !== on)
+                    previous.on.exit("屏幕画面被另一台设备接手了");
+                await Promise.race([previous.gone, new Promise((resolve) => setTimeout(resolve, 3000))]);
+            }
+            if (!wanted())
+                return undefined;
+            const running = await this.capture(index, level, on);
+            this.holder = running;
+            return running;
+        });
+        this.turn = mine.catch(() => { });
+        return mine;
     }
-    stream(ws, display, quality) {
+    stream(ws, display, relayed) {
         const shown = this.displays.find((entry) => entry.index === display) ?? this.displays[0];
         const tell = (message) => ws.readyState === ws.OPEN && ws.send(JSON.stringify(message));
         // The viewer's hands: started when it first asks to control, for the display it is watching.
@@ -302,63 +344,95 @@ export class ScreenShare {
             posted: (event) => this.log(`[screen] dry run: ${JSON.stringify(event)}`),
         }, this.log);
         this.controls.add(control);
-        ws.on("message", (data, binary) => {
-            if (binary)
-                return;
-            let message;
-            try {
-                message = JSON.parse(String(data));
-            }
-            catch {
-                return;
-            }
-            if (message?.t === "control")
-                void control.start(shown?.screen ?? 0);
-            else
-                control.send(message);
-        });
-        const splitter = new AccessUnitSplitter();
+        // The picture: as good as the path carries without falling behind (see `screen-pacer.ts`).
+        const best = relayed ? RELAY_LEVEL : 0;
+        const pacer = new Pacer(Date.now());
+        let level = best;
+        let splitter = new AccessUnitSplitter();
         let closed = false;
-        let stop;
-        void this.capture(shown?.index ?? 0, quality, {
+        let changing = false;
+        let running;
+        const events = {
             data: (chunk) => splitter.push(chunk, (unit, key) => {
                 if (ws.readyState !== ws.OPEN)
                     return;
-                // Behind (a slow link): skip frames until the next keyframe rather than queue up delay.
-                if (!key && ws.bufferedAmount > 2_000_000)
-                    return;
-                ws.send(Buffer.concat([Buffer.from([key ? 1 : 0]), unit]));
+                const now = Date.now();
+                const seq = pacer.next(key, now);
+                if (seq !== undefined) {
+                    const head = Buffer.allocUnsafe(5);
+                    head[0] = key ? 1 : 0;
+                    head.writeUInt32BE(seq >>> 0, 1);
+                    ws.send(Buffer.concat([head, unit]));
+                }
+                const advice = changing ? undefined : pacer.advice(now, level > best, level < LADDER.length - 1);
+                if (advice)
+                    void change(level + (advice === "down" ? 1 : -1));
             }),
             exit: (message) => {
                 if (message)
                     tell({ error: message });
                 ws.close();
             },
-        }).then((end) => {
+        };
+        const begin = async () => {
+            const started = await this.take(shown?.index ?? 0, level, events, () => !closed);
             if (closed)
-                end();
+                started?.end();
             else
-                stop = end;
-        }, (error) => {
+                running = started;
+        };
+        const failed = (error) => {
             this.log(`[screen] the capture did not start: ${error.message}`);
             tell({ error: "屏幕捕获失败" });
             ws.close();
+        };
+        const change = async (next) => {
+            changing = true;
+            this.log(`[screen] picture ${next > level ? "lighter" : "better"}: ${LADDER[next].width} wide, ${LADDER[next].fps} a second, ${LADDER[next].bitrate}`);
+            // Nothing more of the old stream goes out; the page starts its decoder afresh for the new one.
+            running?.end();
+            tell({ restart: true, level: next, lighter: next > level });
+            level = next;
+            splitter = new AccessUnitSplitter();
+            await begin().catch(failed);
+            pacer.restarted(Date.now());
+            changing = false;
+        };
+        void begin().catch(failed);
+        ws.on("message", (data, binary) => {
+            if (binary)
+                return;
+            let message;
+            try {
+                message = JSON.parse(String(data));
+            }
+            catch {
+                return;
+            }
+            const kind = message?.t;
+            if (kind === "ack")
+                pacer.ack(Number(message.n), Date.now());
+            else if (kind === "control")
+                void control.start(shown?.screen ?? 0);
+            else
+                control.send(message);
         });
         ws.on("close", () => {
             closed = true;
-            stop?.();
+            if (running && this.holder === running)
+                this.holder = undefined;
+            running?.end();
             control.stop();
             this.controls.delete(control);
         });
     }
     stop() {
         // The host is going: there is no later to insist in.
+        this.holder?.end();
+        this.holder = undefined;
         for (const capture of this.captures)
             endCapture(capture, true);
         this.captures.clear();
-        for (const stop of this.stops)
-            stop();
-        this.stops.clear();
         for (const control of this.controls)
             control.stop();
         this.controls.clear();