expo-device-hub 0.10.0 → 0.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-device-hub",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Expo DevTools plugin for managing iOS simulators and Android emulators.",
   "keywords": [
     "expo",

package/vendor/serve-emu/dist/cli.js

@@ -257,7 +257,7 @@ Options:
       --unsafe-no-auth   Allow a non-loopback bind with NO authentication.
                          Anyone who can reach the port can control the device.
   -s, --serial <serial>  adb device serial (defaults to the only booted device)
-      --max-fps <n>      Cap source frame rate (default: ${SCRCPY_DEFAULTS.maxFps})
+      --max-fps <n>      Frame-rate target; RGB888 handoff is uncapped (default: ${SCRCPY_DEFAULTS.maxFps})
       --bit-rate <bps>   H.264 bit rate (default: ${SCRCPY_DEFAULTS.bitRate})
       --max-size <px>    Cap longest screen edge in pixels; 0 = native. The
                          gRPC screenshot source uses host-side software H.264

package/vendor/serve-emu/dist/emulator-grpc.js

@@ -7,6 +7,9 @@ import { setTimeout as sleep } from "node:timers/promises";
 import { isEmulatorSerial, parseEmulatorSerial } from "./device-capabilities.js";
 import { execText } from "./exec.js";
 const MAX_GRPC_MESSAGE_BYTES = 64 * 1024 * 1024;
+// Allow several full RGB frames in flight without a 64 KiB flow-control cycle
+// for each chunk. Cooperative reads yield after a bounded amount of work.
+const GRPC_RECEIVE_WINDOW_BYTES = 8 * 1024 * 1024;
 const MAX_PROTO_VARINT_BYTES = 10;
 const CONTROLLER_PREFIX = "/android.emulation.control.EmulatorController/";
 const UNARY_TIMEOUT_MS = 5_000;
@@ -505,6 +508,81 @@ export class GrpcMessageParser {
         this.#onMessage(message);
     }
 }
+/** Yield receive work between bounded batches, independently of FFmpeg. */ export class GrpcReadScheduler {
+    #stream;
+    #consume;
+    #onError;
+    #batchBytes;
+    #remainingBytes;
+    #pending = null;
+    #immediate = null;
+    #paused = false;
+    #closed = false;
+    #onFinish = null;
+    constructor(options){
+        // Match an I/O-sized quantum: a full RGB frame per turn can still starve
+        // pipe progress when an unrestricted source stays continuously readable.
+        this.#batchBytes = options.batchBytes ?? 64 * 1024;
+        if (!Number.isSafeInteger(this.#batchBytes) || this.#batchBytes <= 0) {
+            throw new RangeError("batchBytes must be a positive safe integer");
+        }
+        this.#remainingBytes = this.#batchBytes;
+        this.#stream = options.stream;
+        this.#consume = options.consume;
+        this.#onError = options.onError;
+    }
+    push(chunk) {
+        if (this.#closed || chunk.length === 0) return;
+        try {
+            // pause() prevents another data event until the retained suffix is read.
+            if (this.#pending) throw new Error("gRPC source emitted data while paused");
+            const bytes = Math.min(chunk.length, this.#remainingBytes);
+            this.#remainingBytes -= bytes;
+            this.#consume(chunk.subarray(0, bytes));
+            if (this.#closed) return;
+            if (bytes < chunk.length) this.#pending = chunk.subarray(bytes);
+            if (this.#remainingBytes === 0) {
+                this.#paused = true;
+                this.#stream.pause();
+            }
+            if (!this.#immediate) {
+                this.#immediate = setImmediate(()=>this.#continue());
+            }
+        } catch (error) {
+            this.close();
+            this.#onError(error);
+        }
+    }
+    finish(callback) {
+        if (this.#closed) return;
+        if (this.#pending) this.#onFinish = callback;
+        else callback();
+    }
+    close() {
+        this.#closed = true;
+        if (this.#immediate) clearImmediate(this.#immediate);
+        this.#immediate = null;
+        this.#pending = null;
+        this.#onFinish = null;
+    }
+    #continue() {
+        this.#immediate = null;
+        if (this.#closed) return;
+        this.#remainingBytes = this.#batchBytes;
+        const pending = this.#pending;
+        this.#pending = null;
+        if (pending) this.push(pending);
+        if (this.#closed) return;
+        if (this.#onFinish && !this.#pending) {
+            const finish = this.#onFinish;
+            this.#onFinish = null;
+            finish();
+        } else if (this.#paused && this.#remainingBytes > 0) {
+            this.#paused = false;
+            this.#stream.resume();
+        }
+    }
+}
 const SYSTEM_PACING_CLOCK = {
     now: ()=>performance.now(),
     setTimeout: (callback, delayMs)=>setTimeout(callback, delayMs),
@@ -647,7 +725,16 @@ export class EmulatorGrpcClient {
         this.#endpoint = endpoint;
         this.#unaryTimeoutMs = positiveTimeout(options.unaryTimeoutMs ?? UNARY_TIMEOUT_MS, "unaryTimeoutMs");
         this.#streamInactivityTimeoutMs = positiveTimeout(options.streamInactivityTimeoutMs ?? STREAM_INACTIVITY_TIMEOUT_MS, "streamInactivityTimeoutMs");
-        this.#session = http2.connect(`http://127.0.0.1:${endpoint.port}`);
+        this.#session = http2.connect(`http://127.0.0.1:${endpoint.port}`, {
+            settings: {
+                initialWindowSize: GRPC_RECEIVE_WINDOW_BYTES
+            }
+        });
+        this.#session.once("connect", ()=>{
+            if (!this.#closed) {
+                this.#session.setLocalWindowSize(GRPC_RECEIVE_WINDOW_BYTES);
+            }
+        });
         this.#session.on("error", (error)=>{
             if (!this.#closed) {
                 for (const listener of this.#errorListeners)listener(error);
@@ -687,12 +774,14 @@ export class EmulatorGrpcClient {
             let inactivityTimer = null;
             let activityGeneration = 0;
             let pacer = null;
+            let readScheduler = null;
             const settle = (error)=>{
                 if (settled) return;
                 settled = true;
                 if (timer) clearTimeout(timer);
                 if (inactivityTimer) clearTimeout(inactivityTimer);
                 pacer?.close();
+                readScheduler?.close();
                 options.signal?.removeEventListener("abort", onAbort);
                 if (error) reject(error);
                 else resolve(messages);
@@ -723,6 +812,7 @@ export class EmulatorGrpcClient {
                 inactivityTimer.unref?.();
             };
             const onMessage = (body, receivedAtMs = Date.now())=>{
+                if (settled) return;
                 if (options.onMessage) options.onMessage(body, receivedAtMs);
                 else messages.push(body);
                 resetInactivityTimer();
@@ -767,6 +857,12 @@ export class EmulatorGrpcClient {
                     onError: cancelForFrameError,
                     signal: options.signal
                 });
+            } else if (options.onMessage) {
+                readScheduler = new GrpcReadScheduler({
+                    stream,
+                    consume: (chunk)=>parser.push(chunk),
+                    onError: cancelForFrameError
+                });
             }
             stream.on("response", (values)=>takeStatus(values));
             stream.on("trailers", (values)=>takeStatus(values));
@@ -774,6 +870,7 @@ export class EmulatorGrpcClient {
                 if (settled) return;
                 try {
                     if (pacer) pacer.push(chunk);
+                    else if (readScheduler) readScheduler.push(chunk);
                     else parser.push(chunk);
                 } catch (error) {
                     cancelForFrameError(error);
@@ -784,8 +881,10 @@ export class EmulatorGrpcClient {
             });
             stream.on("close", ()=>{
                 if (settled) return;
-                if (grpcStatus === "0") settle();
-                else if (grpcStatus !== null) {
+                if (grpcStatus === "0") {
+                    if (readScheduler) readScheduler.finish(()=>settle());
+                    else settle();
+                } else if (grpcStatus !== null) {
                     settle(new Error(`${method}: grpc-status ${grpcStatus}${grpcMessage ? ` (${grpcMessage})` : ""}`));
                 } else {
                     settle(new Error(`${method}: stream closed without grpc status`));

package/vendor/serve-emu/dist/grpc-session.js

@@ -22,8 +22,8 @@ const ACCESS_UNIT_CADENCE_WINDOW = 8;
 const ACCESS_UNIT_CADENCE_OUTLIER_FLOOR_MS = 250;
 const ACCESS_UNIT_CADENCE_OUTLIER_MULTIPLIER = 4;
 const ACCESS_UNIT_SLOW_CADENCE_SIMILARITY = 1.5;
-const ENCODER_WRITE_RETRY_DELAY_MS = 8;
 const DEFAULT_IDLE_REPEAT_MS = 500;
+const ENCODER_DRAIN_TIMEOUT_MS = 5_000;
 const FIRST_FRAME_TIMEOUT_MS = 10_000;
 const MAX_QUEUED_PACKET_BYTES = 64 * 1024 * 1024;
 const DISPLAY_SIZE_POLL_MS = 2_000;
@@ -499,12 +499,12 @@ export function isUsablePngFrame(image) {
     }
     return {
         encoderInputFormat: "rgb24",
-        // Drain raw RGB responses independently of encoder FPS. Pausing HTTP/2
-        // queues old pixels upstream; onImage keeps only the newest frame and the
-        // encoder write pacer decides when to submit it. MMAP also drains metadata
-        // immediately, then selects which notifications trigger memory reads.
+        // Keep receiving RGB independently of encoder readiness so the latest
+        // image stays fresh. MMAP selects metadata before shared-memory reads.
         predecodeMaxFps: undefined,
-        needsEncoderFollowUp: (repeat)=>!repeat
+        // A static source may send only one image. Keep warming the encoder until
+        // it emits output; the regular idle timer starts after that startup gate.
+        needsEncoderFollowUp: (repeat, encoderHasOutput)=>!repeat || !encoderHasOutput
     };
 }
 const DEFAULT_MMAP_NOTIFICATION_CLOCK = {
@@ -719,26 +719,6 @@ export function resolveGrpcDisplayGeometry(options) {
         }
     };
 }
-export class GrpcFrameWritePacer {
-    #frameIntervalMs;
-    #nextFreshWriteAt = 0;
-    constructor(frameIntervalMs){
-        if (!Number.isFinite(frameIntervalMs) || frameIntervalMs <= 0) {
-            throw new RangeError("frameIntervalMs must be a positive number");
-        }
-        this.#frameIntervalMs = frameIntervalMs;
-    }
-    reset(now) {
-        this.#nextFreshWriteAt = now;
-    }
-    recordWrite(now, repeat, accepted = true) {
-        if (repeat || !accepted) return;
-        this.#nextFreshWriteAt = Math.max(this.#nextFreshWriteAt + this.#frameIntervalMs, now + this.#frameIntervalMs);
-    }
-    waitMs(now) {
-        return Math.max(0, this.#nextFreshWriteAt - now);
-    }
-}
 export class GrpcAccessUnitBoundaryCadence {
     #minimumIntervalMs;
     #lastFreshImageAt = null;
@@ -1230,8 +1210,8 @@ function nonNegativeInteger(value, name, maximum) {
     const keyFrameInterval = nonNegativeNumber(options.keyFrameInterval ?? SCRCPY_DEFAULTS.keyFrameInterval, "keyFrameInterval");
     const configuredRepeatFrameMs = nonNegativeNumber(options.repeatFrameMs ?? SCRCPY_DEFAULTS.repeatFrameMs, "repeatFrameMs", 60_000);
     const repeatFrameMs = configuredRepeatFrameMs > 0 ? configuredRepeatFrameMs : DEFAULT_IDLE_REPEAT_MS;
+    const encoderDrainTimeoutMs = positiveNumber(dependencies.encoderDrainTimeoutMs ?? ENCODER_DRAIN_TIMEOUT_MS, "encoderDrainTimeoutMs", 60_000);
     const frameIntervalMs = 1_000 / maxFps;
-    const frameWritePacer = new GrpcFrameWritePacer(frameIntervalMs);
     const accessUnitBoundaryCadence = new GrpcAccessUnitBoundaryCadence(frameIntervalMs);
     if (!isEmulatorSerial(serial)) {
         throw new Error(`grpc-screenshot requires an Android Emulator serial; received ${serial}`);
@@ -1267,8 +1247,11 @@ function nonNegativeInteger(value, name, maximum) {
     let encoderHasOutput = false;
     let captureTransport = null;
     let latest = null;
+    let lastSubmittedImage = null;
+    let waitingForEncoder = false;
+    let pendingRepeat = false;
+    let encoderDrainTimer = null;
     let lastWriteAt = 0;
-    let writeTimer = null;
     let flushTimer = null;
     let idleTimer = null;
     let displaySizePollTimer = null;
@@ -1320,62 +1303,75 @@ function nonNegativeInteger(value, name, maximum) {
         if (closed || fatalFailure) return Promise.resolve(null);
         return new Promise((resolve)=>waiters.push(resolve));
     };
-    const clearWriteTimers = ()=>{
-        if (writeTimer) clearTimeout(writeTimer);
+    const clearBoundaryTimer = ()=>{
         if (flushTimer) clearTimeout(flushTimer);
-        writeTimer = null;
         flushTimer = null;
     };
+    const clearEncoderDrainTimer = ()=>{
+        if (encoderDrainTimer) clearTimeout(encoderDrainTimer);
+        encoderDrainTimer = null;
+    };
+    const encoderWritable = (encoder)=>{
+        if (closed || lifetime.signal.aborted || fatalFailure || encoderLifecycle?.current !== encoder) return;
+        clearEncoderDrainTimer();
+        waitingForEncoder = false;
+        if (latest !== lastSubmittedImage) {
+            pendingRepeat = false;
+            writeFrame(false);
+        } else if (pendingRepeat) {
+            pendingRepeat = false;
+            writeFrame(true);
+        }
+    };
+    const watchEncoderDrain = (encoder)=>{
+        if (encoderDrainTimer || closed || lifetime.signal.aborted || fatalFailure) return;
+        encoderDrainTimer = setTimeout(()=>{
+            encoderDrainTimer = null;
+            if (closed || lifetime.signal.aborted || fatalFailure || encoderLifecycle?.current !== encoder || !waitingForEncoder) return;
+            if (encoder.writable) {
+                // Recover a missed notification only when the encoder confirms it can
+                // accept input. A timer must never force more bytes into a blocked pipe.
+                encoderWritable(encoder);
+            } else {
+                emitFatal({
+                    message: `ffmpeg input remained backpressured for ${encoderDrainTimeoutMs}ms`,
+                    code: "encoder-exit"
+                });
+            }
+        }, encoderDrainTimeoutMs);
+        encoderDrainTimer.unref?.();
+    };
     const nowUs = ()=>BigInt(Math.round(performance.now() * 1_000));
     const writeFrame = (repeat)=>{
         const encoder = encoderLifecycle?.current;
         if (closed || lifetime.signal.aborted || fatalFailure || !encoder || !captureTransport || !latest) {
             return;
         }
+        if (waitingForEncoder) {
+            if (repeat) pendingRepeat = true;
+            return;
+        }
+        if (!repeat && latest === lastSubmittedImage) return;
         const now = performance.now();
         const accepted = encoder.write(latest.image, nowUs());
-        frameWritePacer.recordWrite(now, repeat, accepted);
+        waitingForEncoder = !accepted || !encoder.writable;
+        pendingRepeat = !accepted && repeat;
+        if (accepted) lastSubmittedImage = latest;
+        if (waitingForEncoder) watchEncoderDrain(encoder);
+        else clearEncoderDrainTimer();
         captureDiagnostics.recordEncoderWrite(repeat, accepted, latest.image.length, now);
         if (accepted) lastWriteAt = Date.now();
-        const needsFollowUp = captureTransport.needsEncoderFollowUp(repeat, encoderHasOutput);
-        if (repeat) {
-            if (flushTimer) clearTimeout(flushTimer);
-            flushTimer = null;
-            if (!accepted || needsFollowUp) {
-                flushTimer = setTimeout(()=>{
-                    flushTimer = null;
-                    writeFrame(true);
-                }, accepted ? accessUnitBoundaryCadence.boundaryDelayMs() : Math.min(ENCODER_WRITE_RETRY_DELAY_MS, frameIntervalMs));
-                flushTimer.unref?.();
-            }
-            return;
-        }
-        if (accepted && needsFollowUp) {
-            if (flushTimer) clearTimeout(flushTimer);
+        // Keep receiving while ffmpeg is blocked so drain submits the newest
+        // complete image, without building a FIFO of stale frames upstream.
+        if (!accepted) return;
+        clearBoundaryTimer();
+        if (captureTransport.needsEncoderFollowUp(repeat, encoderHasOutput)) {
             flushTimer = setTimeout(()=>{
                 flushTimer = null;
                 writeFrame(true);
             }, accessUnitBoundaryCadence.boundaryDelayMs());
             flushTimer.unref?.();
-        } else if (needsFollowUp && !writeTimer) {
-            writeTimer = setTimeout(()=>{
-                writeTimer = null;
-                scheduleWrite();
-            }, Math.min(ENCODER_WRITE_RETRY_DELAY_MS, frameIntervalMs));
-            writeTimer.unref?.();
-        }
-    };
-    const scheduleWrite = ()=>{
-        if (writeTimer || closed || !encoderLifecycle?.current || !latest) return;
-        const waitMs = frameWritePacer.waitMs(performance.now());
-        if (waitMs <= 0) {
-            writeFrame(false);
-            return;
         }
-        writeTimer = setTimeout(()=>{
-            writeTimer = null;
-            writeFrame(false);
-        }, waitMs);
     };
     const currentGeometry = (image = latest)=>{
         if (!image) return null;
@@ -1399,13 +1395,16 @@ function nonNegativeInteger(value, name, maximum) {
             });
             return null;
         }
-        frameWritePacer.reset(performance.now());
+        waitingForEncoder = false;
+        pendingRepeat = false;
+        lastSubmittedImage = null;
         encoderHasOutput = false;
         if (sessionMeta) {
             sessionMeta.width = size.width;
             sessionMeta.height = size.height;
         }
         let stopping = false;
+        let managed = null;
         const next = runtime.createEncoder({
             encoderName,
             width: latest.width,
@@ -1428,6 +1427,10 @@ function nonNegativeInteger(value, name, maximum) {
                     message,
                     code: "encoder-exit"
                 });
+            },
+            onWritable: ()=>{
+                // A runtime adapter may notify synchronously during construction.
+                if (!stopping && managed) encoderWritable(managed);
             }
         });
         if (restart.announceSize) {
@@ -1438,7 +1441,10 @@ function nonNegativeInteger(value, name, maximum) {
                 clientResized: false
             });
         }
-        return {
+        managed = {
+            get writable () {
+                return next.writable;
+            },
             width: next.width,
             height: next.height,
             quarterTurn: next.quarterTurn,
@@ -1449,10 +1455,12 @@ function nonNegativeInteger(value, name, maximum) {
                 return next.close();
             }
         };
+        return managed;
     });
     const restartEncoder = (announceSize, clearPending)=>{
         if (closed || lifetime.signal.aborted || !latest) return Promise.resolve();
-        clearWriteTimers();
+        clearBoundaryTimer();
+        clearEncoderDrainTimer();
         return encoderLifecycle.restart({
             announceSize,
             clearPending
@@ -1517,7 +1525,7 @@ function nonNegativeInteger(value, name, maximum) {
                 }));
             return;
         }
-        scheduleWrite();
+        writeFrame(false);
     };
     const inputState = new GrpcInputState(client);
     const touch = async (unitX, unitY, pressure, identifier, signal)=>{
@@ -1658,7 +1666,8 @@ function nonNegativeInteger(value, name, maximum) {
         transportToClose?.stop();
         options.signal?.removeEventListener("abort", abortFromParent);
         lifetime.abort(new Error("gRPC screenshot session closed"));
-        clearWriteTimers();
+        clearBoundaryTimer();
+        clearEncoderDrainTimer();
         if (idleTimer) clearInterval(idleTimer);
         idleTimer = null;
         if (displaySizePollTimer) clearTimeout(displaySizePollTimer);

package/vendor/serve-emu/dist/h264-encoder.js

@@ -624,6 +624,7 @@ export class H264Encoder {
     #stderr = new FfmpegStderrTail();
     #resolveProcessDone;
     #closed = false;
+    #waitingForDrain = false;
     #failureReported = false;
     #closeTask = null;
     constructor(opts){
@@ -664,6 +665,10 @@ export class H264Encoder {
         this.#proc.stdin.once("error", (error)=>{
             this.#reportFailure(`ffmpeg stdin failed: ${error.message}`);
         });
+        this.#proc.stdin.on("drain", ()=>{
+            this.#waitingForDrain = false;
+            if (!this.#closed) this.#opts.onWritable?.();
+        });
         this.#proc.once("error", (error)=>{
             this.#reportFailure(`ffmpeg failed to start: ${error.message}`);
             this.#resolveProcessDone();
@@ -676,6 +681,9 @@ export class H264Encoder {
             this.#resolveProcessDone();
         });
     }
+    /** Whether one more complete source image can be accepted now. */ get writable() {
+        return !this.#closed && !this.#waitingForDrain && this.#proc.stdin.writable && !this.#proc.stdin.writableNeedDrain;
+    }
     /** Feed one complete source image; false means backpressure rejected it. */ write(image, ptsUs) {
         if (!Buffer.isBuffer(image)) {
             throw new TypeError("encoder input must be a Buffer");
@@ -698,13 +706,13 @@ export class H264Encoder {
         if (typeof ptsUs !== "bigint" || ptsUs < 0n) {
             throw new RangeError("ptsUs must be a non-negative bigint");
         }
-        if (this.#closed || !this.#proc.stdin.writable || this.#proc.stdin.writableNeedDrain) {
-            return false;
-        }
+        if (!this.writable) return false;
         try {
             // A false return from Writable.write means "accepted, wait for drain",
             // not "rejected", so every successful call receives a PTS entry.
-            this.#proc.stdin.write(image);
+            // Bun's child-process stdin can leave writableNeedDrain false after a
+            // backpressured write, so retain the write result until drain fires.
+            this.#waitingForDrain = !this.#proc.stdin.write(image);
             this.#parser.enqueuePts(ptsUs);
             return true;
         } catch (error) {