@omercnet/paseo-shared-browser 4.1.1-next.338.1 → 4.1.1-next.348.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-shared-browser",
-  "version": "4.1.1-next.338.1",
+  "version": "4.1.1-next.348.1",
   "description": "One real Chromium session per Paseo workspace, shared live across every connected client.",
   "keywords": [
     "browser",

package/server/native-video-backpressure.test.ts

@@ -17,7 +17,7 @@ async function fixture(failFirstEncoder = false) {
       }),
     cancel: async () => deliver({ done: true }),
   };
-  const pending: { timestamp: number; type: string }[] = [];
+  const pending: { timestamp: number; type: string; queued: boolean }[] = [];
   const encoded: { timestamp: number; keyFrame: boolean }[] = [];
   let encoder: Encoder;
   const instances: Encoder[] = [];
@@ -37,14 +37,31 @@ async function fixture(failFirstEncoder = false) {
       if (failFirstEncoder && this === instances[0]) throw new Error("Codec stopped");
       this.encodeQueueSize++;
       encoded.push({ timestamp: frame.timestamp, keyFrame: options.keyFrame });
-      pending.push({ timestamp: frame.timestamp, type: options.keyFrame ? "key" : "delta" });
+      pending.push({
+        timestamp: frame.timestamp,
+        type: options.keyFrame ? "key" : "delta",
+        queued: true,
+      });
+    }
+    /** WebCodecs lowers encodeQueueSize once the codec starts a frame, before its output. */
+    dequeue() {
+      const value = pending.find((entry) => entry.queued);
+      if (!value) throw new Error("No queued fixture frame");
+      value.queued = false;
+      this.encodeQueueSize--;
     }
+    /** Emits in submission order, as an in-order realtime codec does. */
     output() {
       const value = pending.shift();
       if (!value) throw new Error("No queued fixture frame");
-      this.encodeQueueSize--;
+      if (value.queued) this.encodeQueueSize--;
       this.callbacks.output(
-        { ...value, byteLength: 10, copyTo: (bytes: Uint8Array) => bytes.fill(1) },
+        {
+          timestamp: value.timestamp,
+          type: value.type,
+          byteLength: 10,
+          copyTo: (bytes: Uint8Array) => bytes.fill(1),
+        },
         {},
       );
     }
@@ -94,6 +111,7 @@ async function fixture(failFirstEncoder = false) {
       await turn();
     },
     output: () => encoder!.output(),
+    dequeue: () => encoder!.dequeue(),
     ack: () =>
       runInContext(
         'for(const p of fixturePackets) acknowledge("stream",p.sequence)',
@@ -189,6 +207,28 @@ it("still suppresses dependencies after an actual encoded output is dropped", as
   }
 });
 
+it("emits outputs from a codec that lags further behind than its dequeued queue size", async () => {
+  const f = await fixture();
+  try {
+    const timestamps = [0, 33334, 66668, 100002, 133336, 166670];
+    for (const timestamp of timestamps) {
+      await f.frame(timestamp);
+      f.dequeue();
+    }
+    expect(f.encoded).toHaveLength(timestamps.length);
+    for (const _ of timestamps) {
+      f.output();
+      f.ack();
+    }
+    expect(f.packets.map((p) => [p.timestampUs, p.type])).toEqual(
+      timestamps.map((timestamp, index) => [timestamp, index ? "delta" : "key"]),
+    );
+    expect(f.encoded.filter((e) => e.keyFrame)).toHaveLength(1);
+  } finally {
+    await f.stop();
+  }
+});
+
 it("shipped packet conversion is exact with native and legacy byte APIs", () => {
   for (const native of [true, false]) {
     const context = createContext({

package/server/native-video-extension-source.ts

@@ -132,7 +132,12 @@ async function startCapture(targetId, width, height, generation) {
                 continue;
               state.lastEncodedTimestampUs = frame.timestamp;
               state.frameGenerations.set(frame.timestamp, current.generation);
-              while (state.frameGenerations.size > 4)
+              // encodeQueueSize drops when the codec dequeues a frame, not when it
+              // outputs, so a slow encode keeps more frames in flight than the gate
+              // above admits. Bound by one second at the 60fps ceiling, the host's
+              // packet age limit, so an in-flight output keeps its generation
+              // for as long as the host would still accept it.
+              while (state.frameGenerations.size > 60)
                 state.frameGenerations.delete(state.frameGenerations.keys().next().value);
               const keyFrame =
                 state.forceKey || frame.timestamp - state.lastKeyTimestamp >= 1000000;