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

package/npm-shrinkwrap.json

@@ -12,7 +12,7 @@
         "@modelcontextprotocol/sdk": "1.30.0",
         "agent-browser": "0.39.4",
         "esbuild": "0.28.2",
-        "zod": "4.4.3"
+        "zod": "4.6.6"
       }
     },
     "node_modules/@agentclientprotocol/sdk": {
@@ -1874,9 +1874,9 @@
       "license": "ISC"
     },
     "node_modules/ws": {
-      "version": "8.22.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.22.0.tgz",
-      "integrity": "sha512-Ydggc987+RO0AnWtZ/7Wq9FtNvcrL1b/RO0ud9mWjUPgDrsAAwQSF51sm2hm1XofbU/4jkpGEsLFsZZxU+1DOg==",
+      "version": "8.22.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.22.1.tgz",
+      "integrity": "sha512-oyL6OPYme/CmiFvNuGzeoxCJ4nOrZE2O1FwM9MWM1AsGri6nLXB2pg+lNA8aLeXMSav0J6eIVS1j6vUPzUtK9g==",
       "license": "MIT",
       "peer": true,
       "engines": {
@@ -1896,9 +1896,9 @@
       }
     },
     "node_modules/zod": {
-      "version": "4.4.3",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
-      "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
+      "version": "4.6.6",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.6.6.tgz",
+      "integrity": "sha512-4UmzQUF5fxvfcYHlbjBmejU+w+hbDnWFx4aS8kBx7nPBHcO2SqPbpAG8snbdg+Xse4pRefR98hgjFgIMCI/UhA==",
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-shared-browser",
-  "version": "4.1.1-next.338.1",
+  "version": "4.1.1-next.354.1",
   "description": "One real Chromium session per Paseo workspace, shared live across every connected client.",
   "keywords": [
     "browser",
@@ -59,7 +59,7 @@
     "@modelcontextprotocol/sdk": "1.30.0",
     "agent-browser": "0.39.4",
     "esbuild": "0.28.2",
-    "zod": "4.4.3"
+    "zod": "4.6.6"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.10",

package/scripts/prepare-dependencies.mjs

@@ -1,10 +1,12 @@
-import { execFileSync } from "node:child_process";
+import { execSync } from "node:child_process";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 const projectRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+// Run through the shell so Windows resolves npm.cmd: Node refuses to spawn .cmd files without one.
+const INSTALL_COMMAND = "npm ci --omit=dev --ignore-scripts --workspaces=false";
 
 function loadRootCatalog(root) {
   for (let directory = root; ; directory = dirname(directory)) {
@@ -28,6 +30,8 @@ function stageManifest(root, catalog, install) {
     manifest.dependencies[name] = catalog[name];
   }
   delete manifest.devDependencies;
+  // npm-shrinkwrap.json is generated without overrides, so npm ci rejects a manifest that keeps them.
+  delete manifest.overrides;
 
   writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
   try {
@@ -41,18 +45,11 @@ export function resolveDependencyRoot(packageName, from = import.meta.url) {
   return dirname(createRequire(from).resolve(`${packageName}/package.json`));
 }
 
-export function prepareDependencies(root = projectRoot, execute = execFileSync) {
+export function prepareDependencies(root = projectRoot, execute = execSync) {
   const catalog = loadRootCatalog(root);
   if (!catalog) return false;
   stageManifest(root, catalog, () => {
-    execute(
-      process.platform === "win32" ? "npm.cmd" : "npm",
-      ["ci", "--omit=dev", "--ignore-scripts", "--workspaces=false"],
-      {
-        cwd: root,
-        stdio: "inherit",
-      },
-    );
+    execute(INSTALL_COMMAND, { cwd: root, stdio: "inherit" });
   });
   return true;
 }

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;