@omercnet/paseo-shared-browser 1.2.1 → 1.2.2-next.237.1

package/server/browser-video-socket.test.ts

@@ -0,0 +1,368 @@
+/** Actual plugin bridge socket: a held media reply must not delay a later input command. */
+
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { performance } from "node:perf_hooks";
+import { expect, it } from "vitest";
+import type { BrowserFrame, BrowserState } from "../shared/browser";
+import type { BrowserVideoReadReply } from "../shared/browser-video";
+import { RuntimeProtocolError } from "./runtime-protocol";
+import { resolveSupervisorPaths, startSupervisorServer } from "./supervisor";
+import { SupervisorClient } from "./supervisor-client";
+
+it("keeps video past unrelated teardown and input past video on the authenticated socket", async () => {
+  const home = await mkdtemp(join(tmpdir(), "owned-video-socket-"));
+  let release = () => {};
+  let started = () => {};
+  let block = false;
+  const gate = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  const arrived = new Promise<void>((resolve) => {
+    started = resolve;
+  });
+  const retirementGate = Promise.withResolvers<void>();
+  const retirementStarted = Promise.withResolvers<void>();
+  let blockRetirement = false;
+  let retirement: Promise<unknown> | null = null;
+  const stateGate = Promise.withResolvers<void>();
+  const inputPublished = Promise.withResolvers<void>();
+  let blockState = false;
+  let jpegQuality: unknown;
+  let videoSequence = 0;
+  const calls: string[] = [];
+  const running = await startSupervisorServer(
+    {
+      create: async () => ({ runtimeId: "r".repeat(32) }),
+      stop: async () => {},
+      request: async (_runtime, operation, parameters) => {
+        calls.push(operation);
+        if (operation === "screencast.stop" && blockRetirement) {
+          retirementStarted.resolve();
+          await retirementGate.promise;
+        }
+        if (operation === "identity") return { userAgent: "Owned fixture" };
+        if (operation === "frame") {
+          jpegQuality = (parameters as { quality?: unknown }).quality;
+          return {
+            dataBase64: "AA==",
+            byteLength: 1,
+            width: 1280,
+            height: 800,
+            capturedAt: new Date().toISOString(),
+          };
+        }
+        if (operation === "mouse.move") inputPublished.resolve();
+        if (operation === "state") {
+          if (blockState) await stateGate.promise;
+          return {
+            url: "https://fixture.invalid/",
+            title: "Owned",
+            inputGeneration: "1:1",
+            canGoBack: false,
+            canGoForward: false,
+          };
+        }
+        if (operation === "video.read") {
+          if (block) {
+            started();
+            await gate;
+          }
+          return {
+            status: "ready",
+            streamId: "s".repeat(32),
+            inputGeneration: "1:1",
+            packets: [
+              {
+                streamId: "s".repeat(32),
+                captureGeneration: 1,
+                sequence: ++videoSequence,
+                timestampUs: 1000,
+                type: "key",
+                codec: "vp8",
+                width: 1280,
+                height: 800,
+                dataBase64: "AA==",
+                capturedAt: new Date().toISOString(),
+                capturedAtMonotonicMs: performance.now(),
+              },
+            ],
+          };
+        }
+        return null;
+      },
+    },
+    resolveSupervisorPaths(home),
+  );
+  const client = new SupervisorClient({
+    bridgeId: "owned-video-socket",
+    paths: resolveSupervisorPaths(home),
+  });
+  type MediaReply = {
+    state: BrowserState;
+    frame?: BrowserFrame | null;
+    packets?: BrowserVideoReadReply["packets"];
+  };
+  let pending: Promise<MediaReply> | null = null;
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+  try {
+    await client.connect();
+    const attached = await client.requestBrowser<{ viewerToken: string }>("attach", {
+      workspaceId: "owned",
+      viewerLabel: "Owned fixture",
+    });
+    const control = await client.requestBrowser<{ controlToken: string; state: BrowserState }>(
+      "acquire-control",
+      { viewerToken: attached.viewerToken },
+    );
+    const input = {
+      viewerToken: attached.viewerToken,
+      quality: "high",
+      streamId: null,
+      afterSequence: 0,
+      waitMs: 250,
+      requestKeyFrame: false,
+    };
+    const maximum = await client.requestBrowser<MediaReply>("capture", {
+      viewerToken: attached.viewerToken,
+      quality: "maximum",
+    });
+    expect(maximum.frame?.mimeType).toBe("image/jpeg");
+    expect(jpegQuality).toBe(100);
+    const initial = await client.requestBrowser<MediaReply>("video.read", input);
+    // Switching panels can retire one workspace while another keeps playing.
+    // Its native teardown must not occupy the shared socket's video lane.
+    const retiring = await client.requestBrowser<{ viewerToken: string }>("attach", {
+      workspaceId: "retiring",
+      viewerLabel: "Retiring fixture",
+    });
+    blockRetirement = true;
+    retirement = client.requestBrowser("detach", { viewerToken: retiring.viewerToken });
+    await retirementStarted.promise;
+    const independentRead = client.requestBrowser<MediaReply>("video.read", input);
+    const progressed = await Promise.race([
+      independentRead.then(() => true),
+      new Promise<boolean>((resolve) => {
+        timeout = setTimeout(() => resolve(false), 250);
+      }),
+    ]);
+    retirementGate.resolve();
+    await retirement;
+    await independentRead;
+    expect(progressed).toBe(true);
+    blockRetirement = false;
+    const frame = initial.packets![0]!.frame;
+    const stateReads = calls.filter((call) => call === "state").length;
+    block = true;
+    blockState = true;
+    pending = client.requestBrowser<MediaReply>("video.read", input);
+    await arrived;
+    expect(calls.filter((call) => call === "state")).toHaveLength(stateReads);
+    const mutation = client.requestBrowser("input", {
+      viewerToken: attached.viewerToken,
+      controlToken: control.controlToken,
+      expected: {
+        sessionId: initial.state.sessionId,
+        navigationGeneration: initial.state.navigationGeneration,
+        viewportGeneration: initial.state.viewportGeneration,
+      },
+      target: {
+        frameId: frame.frameId,
+        navigationGeneration: frame.navigationGeneration,
+        viewportGeneration: frame.viewportGeneration,
+      },
+      event: { kind: "move", point: { x: 10, y: 20, width: 1280, height: 800 } },
+    });
+    // Discrete input first reconciles the captured document, so a stalled metadata
+    // read must hold back every native primitive rather than let one reach an
+    // unobserved page. The pending video read must not be what delays it.
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    expect(calls).not.toContain("mouse.move");
+    expect(calls).not.toContain("input.begin");
+    stateGate.resolve();
+    const accepted = await Promise.race([
+      inputPublished.promise.then(() => true),
+      new Promise<boolean>((resolve) => {
+        timeout = setTimeout(() => resolve(false), 1000);
+      }),
+    ]);
+    // Published through a pinned channel while the video read is still pending.
+    expect(accepted).toBe(true);
+    expect(calls.indexOf("input.begin")).toBeGreaterThan(-1);
+    expect(calls.indexOf("input.begin")).toBeLessThan(calls.indexOf("mouse.move"));
+    await mutation;
+    expect(calls).toContain("input.end");
+    const finalStateReads = calls.filter((call) => call === "state").length;
+    release();
+    expect((await pending).packets).toEqual([]);
+    expect(calls.filter((call) => call === "state")).toHaveLength(finalStateReads);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    retirementGate.resolve();
+    await retirement?.catch(() => undefined);
+    stateGate.resolve();
+    release();
+    await pending?.catch(() => undefined);
+    client.disconnect();
+    await running.close();
+    await rm(home, { recursive: true, force: true });
+  }
+});
+
+it("bounds sixteen viewers' media while retaining input, cancel and heartbeat capacity", async () => {
+  const home = await mkdtemp(join(tmpdir(), "owned-heartbeat-cap-review-"));
+  let release!: () => void;
+  let allStarted!: () => void;
+  let reads = 0;
+  const calls: string[] = [];
+  const barrier = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  const started = new Promise<void>((resolve) => {
+    allStarted = resolve;
+  });
+  const paths = resolveSupervisorPaths(home);
+  const running = await startSupervisorServer(
+    {
+      create: async () => ({ runtimeId: "r".repeat(32) }),
+      stop: async () => {},
+      async request(_runtime, operation) {
+        calls.push(operation);
+        if (operation === "identity") return { userAgent: "Fixture" };
+        if (operation === "state")
+          return {
+            url: "https://fixture.invalid/",
+            title: "Fixture",
+            inputGeneration: "1:1",
+            canGoBack: false,
+            canGoForward: false,
+          };
+        if (operation === "frame")
+          return {
+            dataBase64: "AA==",
+            byteLength: 1,
+            width: 1280,
+            height: 800,
+            capturedAt: new Date().toISOString(),
+          };
+        if (operation === "video.read") {
+          if (++reads === 12) allStarted();
+          await barrier;
+          return {
+            status: "waiting",
+            streamId: "s".repeat(32),
+            inputGeneration: "1:1",
+            packets: [],
+          };
+        }
+        return null;
+      },
+    },
+    paths,
+  );
+  const client = new SupervisorClient({ bridgeId: "owned-cap-review", paths });
+  const pending: Promise<unknown>[] = [];
+  try {
+    const lease = await client.connect();
+    const viewers: string[] = [];
+    for (let i = 0; i < 16; i++) {
+      const attached = await client.requestBrowser<{ viewerToken: string }>("attach", {
+        workspaceId: "owned",
+        viewerLabel: `Fixture ${i}`,
+      });
+      viewers.push(attached.viewerToken);
+    }
+    const viewerToken = viewers[0]!;
+    const { controlToken } = await client.requestBrowser<{ controlToken: string }>(
+      "acquire-control",
+      { viewerToken },
+    );
+    const captured = await client.requestBrowser<{ state: BrowserState; frame: BrowserFrame }>(
+      "capture",
+      { viewerToken },
+    );
+    const expected = {
+      sessionId: captured.state.sessionId,
+      runtimeId: captured.state.runtimeId!,
+      bridgeEpoch: captured.state.bridgeEpoch!,
+      navigationGeneration: captured.state.navigationGeneration,
+      viewportGeneration: captured.state.viewportGeneration,
+    };
+    const target = {
+      frameId: captured.frame.frameId,
+      navigationGeneration: captured.frame.navigationGeneration,
+      viewportGeneration: captured.frame.viewportGeneration,
+    };
+    const context = { viewerToken, controlToken, expected };
+    const gesture = await client.requestBrowser<{ gestureId: string; nextSequence: number }>(
+      "gesture.begin",
+      {
+        ...context,
+        target,
+        pointerKind: "mouse",
+      },
+    );
+    for (const viewerToken of viewers)
+      pending.push(
+        client
+          .requestBrowser("video.read", {
+            viewerToken,
+            quality: "high",
+            streamId: null,
+            afterSequence: 0,
+            waitMs: 250,
+            requestKeyFrame: false,
+          })
+          .catch((error) => error),
+      );
+    await started;
+    const internal = client as unknown as { send(request: unknown): Promise<unknown> };
+    await expect(
+      internal.send({
+        method: "bridge.heartbeat",
+        bridgeId: "owned-cap-review",
+        epoch: lease.epoch,
+      }),
+    ).resolves.toMatchObject({ epoch: lease.epoch });
+    // JPEG fallback uses the same media cap, so excess readers cannot consume
+    // the normal headroom reserved for an ordered press and its cleanup.
+    await expect(client.requestBrowser("capture", { viewerToken })).rejects.toMatchObject({
+      code: "RUNTIME_BUSY",
+    });
+    const pressed = await client.requestBrowser<{ nextSequence: number }>("gesture.update", {
+      ...context,
+      gestureId: gesture.gestureId,
+      sequence: gesture.nextSequence,
+      target,
+      event: {
+        kind: "down",
+        point: { x: 10, y: 20, width: 1280, height: 800 },
+        button: "left",
+        clickCount: 1,
+      },
+    });
+    await client.requestBrowser("gesture.end", {
+      ...context,
+      gestureId: gesture.gestureId,
+      sequence: pressed.nextSequence,
+      cancel: true,
+    });
+    expect(calls).toContain("mouse.down");
+    expect(calls).toContain("input.end");
+    expect(reads).toBe(12);
+    release();
+    const results = await Promise.all(pending);
+    expect(
+      results.filter(
+        (value) => value instanceof RuntimeProtocolError && value.code === "RUNTIME_BUSY",
+      ),
+    ).toHaveLength(4);
+  } finally {
+    release();
+    await Promise.allSettled(pending);
+    client.disconnect();
+    await running.close();
+    await rm(home, { recursive: true, force: true });
+  }
+});

package/server/browser.ts

@@ -9,14 +9,25 @@ import type {
   acquireControlRpc,
   applyDevicePresetRpc,
   attachBrowserRpc,
+  beginBrowserGestureRpc,
   captureBrowserRpc,
+  closeBrowserRpc,
+  closeBrowserTabRpc,
+  createBrowserTabRpc,
   detachBrowserRpc,
+  endBrowserGestureRpc,
+  listBrowserTabsRpc,
   listOpenBrowserWorkspacesRpc,
   navigateBrowserRpc,
   releaseControlRpc,
+  reopenBrowserRpc,
   resizeBrowserRpc,
   sendBrowserInputRpc,
+  setCaptureDensityRpc,
+  updateBrowserGestureRpc,
 } from "../shared/browser";
+import type { BrowserVideoReadInput, BrowserVideoReadReply } from "../shared/browser-video";
+import { createBrowserOperationDiagnostics } from "./browser-operation-diagnostics";
 import { resolveBrowserRuntimeRoot } from "./runtime-path";
 import type { JsonValue } from "./runtime-protocol";
 import { resolveSupervisorPaths } from "./supervisor";
@@ -33,8 +44,18 @@ type AttachInput = RpcInput<typeof attachBrowserRpc>;
 type AttachOutput = RpcOutput<typeof attachBrowserRpc>;
 type DetachInput = RpcInput<typeof detachBrowserRpc>;
 type DetachOutput = RpcOutput<typeof detachBrowserRpc>;
+type DensityInput = RpcInput<typeof setCaptureDensityRpc>;
+type DensityOutput = RpcOutput<typeof setCaptureDensityRpc>;
 type CaptureInput = RpcInput<typeof captureBrowserRpc>;
 type CaptureOutput = RpcOutput<typeof captureBrowserRpc>;
+type CloseInput = RpcInput<typeof closeBrowserRpc>;
+type CloseOutput = RpcOutput<typeof closeBrowserRpc>;
+type CloseTabInput = RpcInput<typeof closeBrowserTabRpc>;
+type CloseTabOutput = RpcOutput<typeof closeBrowserTabRpc>;
+type CreateTabOutput = RpcOutput<typeof createBrowserTabRpc>;
+type ListTabsOutput = RpcOutput<typeof listBrowserTabsRpc>;
+type ReopenInput = RpcInput<typeof reopenBrowserRpc>;
+type ReopenOutput = RpcOutput<typeof reopenBrowserRpc>;
 type AcquireControlInput = RpcInput<typeof acquireControlRpc>;
 type AcquireControlOutput = RpcOutput<typeof acquireControlRpc>;
 type ReleaseControlInput = RpcInput<typeof releaseControlRpc>;
@@ -48,24 +69,60 @@ type ApplyDevicePresetInput = RpcInput<typeof applyDevicePresetRpc>;
 type ApplyDevicePresetOutput = RpcOutput<typeof applyDevicePresetRpc>;
 type SendInput = RpcInput<typeof sendBrowserInputRpc>;
 type SendOutput = RpcOutput<typeof sendBrowserInputRpc>;
+type BeginGestureInput = RpcInput<typeof beginBrowserGestureRpc>;
+type BeginGestureOutput = RpcOutput<typeof beginBrowserGestureRpc>;
+type UpdateGestureInput = RpcInput<typeof updateBrowserGestureRpc>;
+type UpdateGestureOutput = RpcOutput<typeof updateBrowserGestureRpc>;
+type EndGestureInput = RpcInput<typeof endBrowserGestureRpc>;
+type EndGestureOutput = RpcOutput<typeof endBrowserGestureRpc>;
 
 function paseoHome(): string {
   return process.env.PASEO_HOME ?? join(homedir(), ".paseo");
 }
 
 class RemoteBrowserManager {
+  private readonly diagnose = createBrowserOperationDiagnostics();
+
+  private requestBrowser<Result = JsonValue>(operation: string, input: JsonValue): Promise<Result> {
+    return this.diagnose(operation, () => this.client.requestBrowser<Result>(operation, input));
+  }
+
   constructor(private readonly client: SupervisorClient) {}
 
   async connect(): Promise<void> {
     await this.client.connect();
   }
 
-  attach(workspaceId: string, viewerLabel: string): Promise<AttachOutput> {
-    return this.client.requestBrowser<AttachOutput>("attach", { workspaceId, viewerLabel });
+  attach(workspaceId: string, viewerLabel: string, tabId?: string): Promise<AttachOutput> {
+    return this.requestBrowser<AttachOutput>("attach", {
+      workspaceId,
+      viewerLabel,
+      ...(tabId ? { tabId } : {}),
+    });
+  }
+
+  listTabs(viewerToken: string): Promise<ListTabsOutput> {
+    return this.requestBrowser<ListTabsOutput>("tabs.list", { viewerToken });
+  }
+
+  createTab(viewerToken: string): Promise<CreateTabOutput> {
+    return this.requestBrowser<CreateTabOutput>("tabs.create", { viewerToken });
+  }
+
+  closeTab(input: CloseTabInput): Promise<CloseTabOutput> {
+    return this.requestBrowser<CloseTabOutput>("tabs.close", input);
   }
 
   detach(viewerToken: string): Promise<DetachOutput> {
-    return this.client.requestBrowser<DetachOutput>("detach", { viewerToken });
+    return this.requestBrowser<DetachOutput>("detach", { viewerToken });
+  }
+
+  close(input: CloseInput): Promise<CloseOutput> {
+    return this.requestBrowser<CloseOutput>("close", input);
+  }
+
+  reopen(workspaceId: string): Promise<ReopenOutput> {
+    return this.requestBrowser<ReopenOutput>("reopen", { workspaceId });
   }
 
   capture(
@@ -73,48 +130,65 @@ class RemoteBrowserManager {
     quality: CaptureInput["quality"],
     knownFrameId: string | null,
   ): Promise<CaptureOutput> {
-    return this.client.requestBrowser<CaptureOutput>("capture", {
+    return this.requestBrowser<CaptureOutput>("capture", {
       viewerToken,
       quality,
       knownFrameId,
     });
   }
 
+  readVideo(input: BrowserVideoReadInput): Promise<BrowserVideoReadReply> {
+    return this.requestBrowser<BrowserVideoReadReply>("video.read", input as unknown as JsonValue);
+  }
+
   acquireControl(viewerToken: string, takeover: boolean): Promise<AcquireControlOutput> {
-    return this.client.requestBrowser<AcquireControlOutput>("acquire-control", {
+    return this.requestBrowser<AcquireControlOutput>("acquire-control", {
       viewerToken,
       takeover,
     });
   }
 
   releaseControl(viewerToken: string, controlToken: string): Promise<ReleaseControlOutput> {
-    return this.client.requestBrowser<ReleaseControlOutput>("release-control", {
+    return this.requestBrowser<ReleaseControlOutput>("release-control", {
       viewerToken,
       controlToken,
     });
   }
 
   navigate(input: NavigateInput): Promise<NavigateOutput> {
-    return this.client.requestBrowser<NavigateOutput>("navigate", input as unknown as JsonValue);
+    return this.requestBrowser<NavigateOutput>("navigate", input as unknown as JsonValue);
   }
 
   resize(input: ResizeInput): Promise<ResizeOutput> {
-    return this.client.requestBrowser<ResizeOutput>("viewport", input as unknown as JsonValue);
+    return this.requestBrowser<ResizeOutput>("viewport", input as unknown as JsonValue);
+  }
+
+  setCaptureDensity(input: DensityInput): Promise<DensityOutput> {
+    return this.requestBrowser<DensityOutput>("capture.density", input as unknown as JsonValue);
   }
 
   applyDevicePreset(input: ApplyDevicePresetInput): Promise<ApplyDevicePresetOutput> {
-    return this.client.requestBrowser<ApplyDevicePresetOutput>(
-      "device",
-      input as unknown as JsonValue,
-    );
+    return this.requestBrowser<ApplyDevicePresetOutput>("device", input as unknown as JsonValue);
   }
 
   sendInput(input: SendInput): Promise<SendOutput> {
-    return this.client.requestBrowser<SendOutput>("input", input as unknown as JsonValue);
+    return this.requestBrowser<SendOutput>("input", input as unknown as JsonValue);
+  }
+
+  beginGesture(input: BeginGestureInput): Promise<BeginGestureOutput> {
+    return this.requestBrowser("gesture.begin", input as unknown as JsonValue);
+  }
+
+  updateGesture(input: UpdateGestureInput): Promise<UpdateGestureOutput> {
+    return this.requestBrowser("gesture.update", input as unknown as JsonValue);
+  }
+
+  endGesture(input: EndGestureInput): Promise<EndGestureOutput> {
+    return this.requestBrowser("gesture.end", input as unknown as JsonValue);
   }
 
   async listOpenWorkspaceIds(): Promise<string[]> {
-    const result = await this.client.requestBrowser("list", {});
+    const result = await this.requestBrowser("list", {});
     if (
       !result ||
       typeof result !== "object" ||
@@ -132,7 +206,7 @@ class RemoteBrowserManager {
   }
 
   async archiveWorkspace(workspaceId: string): Promise<void> {
-    await this.client.requestBrowser("archive", { workspaceId });
+    await this.requestBrowser("archive", { workspaceId });
   }
 
   issueAgentTicket(ticket: string): Promise<void> {
@@ -237,13 +311,46 @@ export async function handleAttachBrowser(
 ): Promise<AttachOutput> {
   const workspace = await context.paseo.workspaces.ref(input.workspaceId).refresh();
   if (!workspace) throw new Error("Workspace not found");
-  return (await getProductionManager()).attach(input.workspaceId, input.viewerLabel);
+  return (await getProductionManager()).attach(input.workspaceId, input.viewerLabel, input.tabId);
+}
+
+export async function handleListBrowserTabs({
+  viewerToken,
+}: {
+  viewerToken: string;
+}): Promise<ListTabsOutput> {
+  return (await getProductionManager()).listTabs(viewerToken);
+}
+
+export async function handleCreateBrowserTab({
+  viewerToken,
+}: {
+  viewerToken: string;
+}): Promise<CreateTabOutput> {
+  return (await getProductionManager()).createTab(viewerToken);
+}
+
+export async function handleCloseBrowserTab(input: CloseTabInput): Promise<CloseTabOutput> {
+  return (await getProductionManager()).closeTab(input);
 }
 
 export async function handleDetachBrowser({ viewerToken }: DetachInput): Promise<DetachOutput> {
   return (await getProductionManager()).detach(viewerToken);
 }
 
+export async function handleCloseBrowser(input: CloseInput): Promise<CloseOutput> {
+  return (await getProductionManager()).close(input);
+}
+
+export async function handleReopenBrowser(
+  input: ReopenInput,
+  context: PluginHandlerContext,
+): Promise<ReopenOutput> {
+  const workspace = await context.paseo.workspaces.ref(input.workspaceId).refresh();
+  if (!workspace) throw new Error("Workspace not found");
+  return (await getProductionManager()).reopen(input.workspaceId);
+}
+
 export async function handleWorkspaceArchived(workspaceId: string): Promise<void> {
   if (productionStopped) return;
   await (await getProductionManager()).archiveWorkspace(workspaceId);
@@ -283,6 +390,10 @@ export async function handleResizeBrowser(input: ResizeInput): Promise<ResizeOut
   return (await getProductionManager()).resize(input);
 }
 
+export async function handleSetCaptureDensity(input: DensityInput): Promise<DensityOutput> {
+  return (await getProductionManager()).setCaptureDensity(input);
+}
+
 export async function handleApplyDevicePreset(
   input: ApplyDevicePresetInput,
 ): Promise<ApplyDevicePresetOutput> {
@@ -293,9 +404,33 @@ export async function handleSendBrowserInput(input: SendInput): Promise<SendOutp
   return (await getProductionManager()).sendInput(input);
 }
 
+/** Human-viewer live gestures use the existing authenticated supervisor, never an agent ticket. */
+export async function handleBeginBrowserGesture(
+  input: BeginGestureInput,
+): Promise<BeginGestureOutput> {
+  return (await getProductionManager()).beginGesture(input);
+}
+
+export async function handleUpdateBrowserGesture(
+  input: UpdateGestureInput,
+): Promise<UpdateGestureOutput> {
+  return (await getProductionManager()).updateGesture(input);
+}
+
+export async function handleEndBrowserGesture(input: EndGestureInput): Promise<EndGestureOutput> {
+  return (await getProductionManager()).endGesture(input);
+}
+
 export async function cleanupBrowserServer(): Promise<void> {
   productionStopped = true;
   if (productionStart) await productionStart.catch(() => undefined);
   productionManager?.disconnect();
   productionManager = null;
 }
+
+/** Read bounded native video without acquiring control or exposing another transport. */
+export async function handleReadBrowserVideo(
+  input: BrowserVideoReadInput,
+): Promise<BrowserVideoReadReply> {
+  return (await getProductionManager()).readVideo(input);
+}