@omercnet/paseo-shared-browser 1.2.2 → 2.0.0-next.249.1

package/server/emulation-restoration.test.ts

@@ -0,0 +1,262 @@
+import { EventEmitter } from "node:events";
+import { describe, expect, it } from "vitest";
+import { AgentBrowserRuntime, type DeviceEmulation } from "./agent-browser-runtime";
+import { type CdpConnection, CdpSession } from "./cdp";
+
+/** Protocol fixture exercises real attachment/configuration methods without a browser process. */
+class ConnectionFixture extends EventEmitter {
+  isOpen = true;
+  nextSession = 0;
+  calls: { method: string; params: Record<string, unknown>; sessionId: string | undefined }[] = [];
+  intercept?: (method: string, sessionId?: string) => Promise<void>;
+
+  async send<T>(
+    method: string,
+    params: Record<string, unknown> = {},
+    options: { sessionId?: string } = {},
+  ): Promise<T> {
+    this.calls.push({ method, params, sessionId: options.sessionId });
+    await this.intercept?.(method, options.sessionId);
+    if (method === "Target.getTargets") {
+      return {
+        targetInfos: ["a", "b"].map((targetId) => ({
+          targetId,
+          type: "page",
+          url: "about:blank",
+          title: targetId,
+        })),
+      } as T;
+    }
+    if (method === "Target.attachToTarget") return { sessionId: `new-${++this.nextSession}` } as T;
+    if (method === "Page.getNavigationHistory") return { currentIndex: 0, entries: [] } as T;
+    return {} as T;
+  }
+
+  close(): void {
+    this.isOpen = false;
+  }
+}
+
+interface RuntimeControl {
+  connection: CdpConnection;
+  page: CdpSession | null;
+  targetId: string | null;
+  viewport: DeviceEmulation;
+  emulationAppliedPage: CdpSession | null;
+  screencastActive: boolean;
+  screencastFrame: unknown;
+  attachmentGeneration: number;
+  assertVersion(): Promise<void>;
+  connectCdp(targetId?: string): Promise<void>;
+  requirePage(): Promise<CdpSession>;
+  reattachPageForScreencast(previous: CdpSession): Promise<CdpSession>;
+  onScreencastFrame(page: CdpSession, event: unknown): void;
+}
+
+const pixel: DeviceEmulation = {
+  width: 412,
+  height: 839,
+  deviceScaleFactor: 2.625,
+  captureScale: 2,
+  mobile: true,
+  touch: true,
+  screenWidth: 430,
+  screenHeight: 900,
+  userAgent: "fixture-mobile-agent",
+  platform: "Android",
+};
+
+function fixture() {
+  const runtime = new AgentBrowserRuntime({
+    binaryPath: "/tmp/unlaunched-browser",
+    executablePath: "/tmp/unlaunched-chromium",
+    profilePath: "/tmp/uncreated-profile",
+    ipcDirectory: "/tmp/uncreated-ipc",
+    session: "emulation-test",
+  });
+  const connection = new ConnectionFixture();
+  const typedConnection = connection as unknown as CdpConnection;
+  const previous = new CdpSession(typedConnection, "previous", "a");
+  const control = runtime as unknown as RuntimeControl;
+  Object.assign(control, {
+    connection: typedConnection,
+    page: previous,
+    targetId: "a",
+    viewport: { ...pixel },
+    emulationAppliedPage: previous,
+  });
+  return { runtime, connection, previous, control };
+}
+
+function assertDeviceRestored(connection: ConnectionFixture, sessionId: string) {
+  const calls = connection.calls.filter((call) => call.sessionId === sessionId);
+  expect(
+    calls.find((call) => call.method === "Emulation.setDeviceMetricsOverride")?.params,
+  ).toEqual({
+    width: 412,
+    height: 839,
+    deviceScaleFactor: 2.625,
+    mobile: true,
+    screenWidth: 430,
+    screenHeight: 900,
+    screenOrientation: { type: "portraitPrimary", angle: 0 },
+  });
+  expect(
+    calls.find((call) => call.method === "Emulation.setTouchEmulationEnabled")?.params,
+  ).toEqual({ enabled: true, maxTouchPoints: 5 });
+  // Target-scoped: lets a page behind another tab acknowledge input without being raised.
+  expect(
+    calls.find((call) => call.method === "Emulation.setFocusEmulationEnabled")?.params,
+  ).toEqual({ enabled: true });
+  expect(calls.find((call) => call.method === "Emulation.setUserAgentOverride")?.params).toEqual({
+    userAgent: "fixture-mobile-agent",
+    platform: "Android",
+  });
+}
+
+describe("session-owned device emulation restoration", () => {
+  it("restores full retained settings before publishing a newly selected target", async () => {
+    const { runtime, connection, control } = fixture();
+    const publications: (CdpSession | null)[] = [];
+    connection.intercept = async (method) => {
+      if (method.startsWith("Emulation.")) publications.push(control.page);
+    };
+    await runtime.selectTarget("b");
+    expect(publications).toEqual([null, null, null, null]);
+    expect(control.page?.targetId).toBe("b");
+    expect(control.emulationAppliedPage).toBe(control.page);
+    expect(control.viewport.captureScale).toBe(2);
+    assertDeviceRestored(connection, control.page!.sessionId);
+  });
+
+  it("reconnect restores the device on the replacement transport rather than the old connection", async () => {
+    const { runtime, connection, control } = fixture();
+    const replacement = new ConnectionFixture();
+    control.assertVersion = async () => {};
+    control.connectCdp = async () => {
+      control.connection = replacement as unknown as CdpConnection;
+      await runtime.selectTarget("a");
+    };
+    await runtime.reconnect();
+    expect(connection.isOpen).toBe(false);
+    expect(control.page?.connection).toBe(control.connection);
+    assertDeviceRestored(replacement, control.page!.sessionId);
+  });
+
+  it("screencast retry detaches the old controller before applying replacement metrics", async () => {
+    const { connection, control, previous } = fixture();
+    const restored = await control.reattachPageForScreencast(previous);
+    const detach = connection.calls.findIndex((call) => call.method === "Target.detachFromTarget");
+    const metrics = connection.calls.findIndex(
+      (call) => call.method === "Emulation.setDeviceMetricsOverride",
+    );
+    expect(detach).toBeGreaterThanOrEqual(0);
+    expect(metrics).toBeGreaterThan(detach);
+    expect(control.page).toBe(restored);
+    assertDeviceRestored(connection, restored.sessionId);
+  });
+
+  it("refuses frame admission after partial restoration fails", async () => {
+    const { runtime, connection, control } = fixture();
+    connection.intercept = async (method) => {
+      if (method === "Emulation.setTouchEmulationEnabled")
+        throw new Error("touch restore rejected");
+    };
+    await expect(runtime.selectTarget("b")).rejects.toThrow("touch restore rejected");
+    expect(control.page).toBeNull();
+    expect(control.emulationAppliedPage).toBeNull();
+    expect(
+      connection.calls.some(
+        (call) => call.method === "Target.detachFromTarget" && call.params.sessionId === "new-1",
+      ),
+    ).toBe(true);
+    control.assertVersion = async () => {
+      throw new Error("transport unavailable");
+    };
+    await expect(runtime.frame(1024, 95, 0)).rejects.toThrow("transport unavailable");
+    expect(
+      connection.calls.some(
+        (call) =>
+          call.method === "Page.captureScreenshot" || call.method === "Page.startScreencast",
+      ),
+    ).toBe(false);
+  });
+
+  it("rejects a disconnect while restoring rather than publishing the detached session", async () => {
+    const { runtime, connection, control } = fixture();
+    connection.intercept = async (method) => {
+      if (method === "Emulation.setUserAgentOverride") connection.close();
+    };
+    await expect(runtime.selectTarget("b")).rejects.toThrow("attachment changed");
+    expect(control.page).toBeNull();
+    expect(control.emulationAppliedPage).toBeNull();
+  });
+
+  it("repairs the winning attachment after a stale restoring controller is detached", async () => {
+    const { runtime, connection, control } = fixture();
+    const gate = Promise.withResolvers<void>();
+    const reached = Promise.withResolvers<void>();
+    connection.intercept = async (method, sessionId) => {
+      if (method === "Emulation.setUserAgentOverride" && sessionId === "new-1") {
+        reached.resolve();
+        await gate.promise;
+      }
+    };
+    const older = runtime.selectTarget("a");
+    await reached.promise;
+    await runtime.selectTarget("b");
+    const winner = control.page;
+    expect(control.emulationAppliedPage).toBe(winner);
+    gate.resolve();
+    await expect(older).rejects.toThrow("attachment changed");
+    expect(control.page).toBe(winner);
+    expect(control.emulationAppliedPage).toBeNull();
+    control.screencastActive = true;
+    control.onScreencastFrame(winner!, { data: "ignored", metadata: {}, sessionId: 4 });
+    expect(control.screencastFrame).toBeNull();
+    expect(await control.requirePage()).toBe(winner);
+    expect(control.emulationAppliedPage).toBe(winner);
+    assertDeviceRestored(connection, winner!.sessionId);
+  });
+
+  it("refuses retry publication if detaching the prior emulation controller fails", async () => {
+    const { connection, control, previous } = fixture();
+    connection.intercept = async (method) => {
+      if (method === "Target.detachFromTarget") throw new Error("detach outcome unknown");
+    };
+    await expect(control.reattachPageForScreencast(previous)).rejects.toThrow(
+      "detach outcome unknown",
+    );
+    expect(control.page).toBeNull();
+    expect(control.emulationAppliedPage).toBeNull();
+    expect(
+      connection.calls.some(
+        (call) => call.method.startsWith("Emulation.") || call.method === "Page.startScreencast",
+      ),
+    ).toBe(false);
+  });
+
+  it("invalidates winner readiness after detaching a superseded retry controller", async () => {
+    const { runtime, connection, control, previous } = fixture();
+    const reached = Promise.withResolvers<void>();
+    const gate = Promise.withResolvers<void>();
+    let first = true;
+    connection.intercept = async (method) => {
+      if (method === "Target.attachToTarget" && first) {
+        first = false;
+        reached.resolve();
+        await gate.promise;
+      }
+    };
+    const retry = control.reattachPageForScreencast(previous);
+    await reached.promise;
+    await runtime.selectTarget("b");
+    const winner = control.page;
+    gate.resolve();
+    expect(await retry).toBe(winner);
+    expect(control.page).toBe(winner);
+    expect(control.emulationAppliedPage).toBeNull();
+    expect(await control.requirePage()).toBe(winner);
+    expect(control.emulationAppliedPage).toBe(winner);
+  });
+});

package/server/input-cleanup.ts

@@ -0,0 +1,23 @@
+/** Input cleanup preserves the first failure, including an uncertain native
+ * publication. Cleanup always runs once; neither phase is ever retried. */
+
+/** Run an input phase and then its release. A cleanup error is exposed only if
+ * the input phase succeeded, so a secondary failure cannot hide UNKNOWN_OUTCOME. */
+export async function runWithInputCleanup<Value>(
+  operation: () => Promise<Value>,
+  cleanup: () => Promise<unknown>,
+): Promise<Value> {
+  let result: { value: Value } | { error: unknown };
+  try {
+    result = { value: await operation() };
+  } catch (error) {
+    result = { error };
+  }
+  try {
+    await cleanup();
+  } catch (error) {
+    if ("value" in result) throw error;
+  }
+  if ("error" in result) throw result.error;
+  return result.value;
+}

package/server/input-generation.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { formatRuntimeInputGeneration, sameRuntimeInputAttachment } from "./input-generation";
+
+describe("private native input generation codec", () => {
+  it("admits document changes only within the same exact native attachment", () => {
+    expect(
+      sameRuntimeInputAttachment(
+        formatRuntimeInputGeneration(3, 4),
+        formatRuntimeInputGeneration(3, 5),
+      ),
+    ).toBe(true);
+    expect(sameRuntimeInputAttachment("3:4", "4:4")).toBe(false);
+  });
+
+  it("refuses missing, opaque, truncated and unbounded generation formats", () => {
+    for (const invalid of [
+      null,
+      "opaque",
+      "3",
+      "3:",
+      "03:4",
+      "3:-1",
+      "3:9007199254740992",
+      "3:4:5",
+    ]) {
+      expect(sameRuntimeInputAttachment("3:4", invalid)).toBe(false);
+      expect(sameRuntimeInputAttachment(invalid, "3:4")).toBe(false);
+    }
+    expect(() => formatRuntimeInputGeneration(-1, 0)).toThrow("Invalid");
+  });
+});

package/server/input-generation.ts

@@ -0,0 +1,36 @@
+/**
+ * Private runtime metadata codec for attachment and document counters. This is
+ * produced by agent-browser-runtime and consumed only by browser-policy. Unknown
+ * older formats cannot prove same-attachment completion after input publication.
+ */
+
+/** Serialize native counters without treating document navigation as target replacement. */
+export function formatRuntimeInputGeneration(attachment: number, document: number): string {
+  if (
+    !Number.isSafeInteger(attachment) ||
+    attachment < 0 ||
+    !Number.isSafeInteger(document) ||
+    document < 0
+  ) {
+    throw new Error("Invalid native input generation");
+  }
+  return `${attachment}:${document}`;
+}
+
+/** Compare only independently serialized attachment identity; malformed or absent metadata refuses completion. */
+export function sameRuntimeInputAttachment(
+  original: string | null,
+  current: string | null,
+): boolean {
+  const before = readNativeCounters(original);
+  const after = readNativeCounters(current);
+  return before !== null && after !== null && before.attachment === after.attachment;
+}
+
+/** Require the complete native codec, including a bounded valid document counter. */
+function readNativeCounters(value: string | null): { attachment: number; document: number } | null {
+  if (!value || value.length > 33 || !/^(0|[1-9]\d*):(0|[1-9]\d*)$/.test(value)) return null;
+  const [attachment, document] = value.split(":").map(Number);
+  if (!Number.isSafeInteger(attachment) || !Number.isSafeInteger(document)) return null;
+  return { attachment: attachment!, document: document! };
+}

package/server/jpeg-capture-demand.test.ts

@@ -0,0 +1,76 @@
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { createJpegCaptureDemand, JPEG_CAPTURE_IDLE_MS } from "./jpeg-capture-demand";
+
+beforeEach(() => vi.useFakeTimers());
+afterEach(() => vi.useRealTimers());
+function setup() {
+  const retire = vi.fn(async () => {});
+  const onError = vi.fn();
+  const demand = createJpegCaptureDemand({ now: () => Date.now(), retire, onError });
+  return { demand, retire, onError };
+}
+it("no viewer/video-only activity allocates a timer; completed reads renew beyond startup polling", async () => {
+  const { demand, retire } = setup();
+  const transition = demand.pin(false);
+  transition();
+  expect(vi.getTimerCount()).toBe(0);
+  const release = demand.pin();
+  release();
+  for (let i = 0; i < 3; i++) {
+    await vi.advanceTimersByTimeAsync(1500);
+    const releaseNext = demand.pin();
+    releaseNext();
+  }
+  expect(retire).not.toHaveBeenCalled();
+  await vi.advanceTimersByTimeAsync(JPEG_CAPTURE_IDLE_MS);
+  expect(retire).toHaveBeenCalledTimes(1);
+  expect(vi.getTimerCount()).toBe(0);
+});
+it("slow read/start remains pinned across the entire await, and renewal queues after retirement", async () => {
+  const { demand, retire } = setup();
+  const release = demand.pin();
+  await vi.advanceTimersByTimeAsync(10000);
+  expect(retire).not.toHaveBeenCalled();
+  release();
+  const stop = Promise.withResolvers<void>();
+  retire.mockImplementationOnce(() => stop.promise);
+  await vi.advanceTimersByTimeAsync(JPEG_CAPTURE_IDLE_MS);
+  const nextRelease = demand.pin();
+  const started = vi.fn(async () => {});
+  const start = demand.serialize(started);
+  await Promise.resolve();
+  expect(started).not.toHaveBeenCalled();
+  stop.resolve();
+  await start;
+  expect(started).toHaveBeenCalledTimes(1);
+  nextRelease();
+});
+it("non-image transitions protect but never renew old demand", async () => {
+  const { demand, retire } = setup();
+  demand.pin()();
+  await vi.advanceTimersByTimeAsync(2000);
+  const transition = demand.pin(false);
+  await vi.advanceTimersByTimeAsync(10000);
+  expect(retire).not.toHaveBeenCalled();
+  transition();
+  await vi.advanceTimersByTimeAsync(1);
+  expect(retire).toHaveBeenCalledTimes(1);
+});
+it("explicit cancellation, failed retire and shutdown do not rearm or replay", async () => {
+  const { demand, retire, onError } = setup();
+  const release = demand.pin();
+  demand.cancel();
+  release();
+  await vi.advanceTimersByTimeAsync(10000);
+  expect(retire).not.toHaveBeenCalled();
+  retire.mockRejectedValueOnce(new Error("uncertain stop"));
+  demand.pin()();
+  await vi.advanceTimersByTimeAsync(10000);
+  expect(retire).toHaveBeenCalledTimes(1);
+  expect(onError).toHaveBeenCalledTimes(1);
+  demand.pin()();
+  demand.close();
+  await vi.advanceTimersByTimeAsync(10000);
+  expect(retire).toHaveBeenCalledTimes(1);
+  expect(() => demand.pin()).toThrow("closed");
+});

package/server/jpeg-capture-demand.ts

@@ -0,0 +1,98 @@
+/** Runtime-owned JPEG activity lifetime. Viewer/control/video heartbeats do not
+ * renew it. Start/stop transitions share one FIFO, while active reads and native
+ * target transitions pin retirement before their asynchronous work begins.
+ */
+export const JPEG_CAPTURE_IDLE_MS = 3_000;
+
+/** Own one unreferenced timer, not a periodic loop. The timeout is twice the
+ * existing 1.5s startup image poll (ready polls are 250ms, active input 100ms).
+ * Stop failure is reported once; no page mutation or start is silently replayed.
+ */
+export function createJpegCaptureDemand(options: {
+  now(): number;
+  retire(): Promise<void>;
+  onError(error: unknown): void;
+}) {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let lastDemand: number | null = null;
+  let pins = 0;
+  let revision = 0;
+  let closed = false;
+  let tail = Promise.resolve();
+
+  function clearTimer() {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  }
+
+  /** Serialize native stream start/stop without retaining a failed queue tail. */
+  function serialize<T>(operation: () => Promise<T>): Promise<T> {
+    const result = tail.then(async () => {
+      if (closed) throw new Error("JPEG capture lifetime is closed");
+      return await operation();
+    });
+    tail = result.then(
+      () => undefined,
+      () => undefined,
+    );
+    return result;
+  }
+
+  function arm() {
+    clearTimer();
+    if (closed || pins > 0 || lastDemand === null) return;
+    const scheduledRevision = revision;
+    timer = setTimeout(
+      () => {
+        timer = null;
+        void serialize(async () => {
+          if (pins > 0 || revision !== scheduledRevision || lastDemand === null) return;
+          if (options.now() - lastDemand < JPEG_CAPTURE_IDLE_MS) {
+            arm();
+            return;
+          }
+          lastDemand = null;
+          await options.retire();
+        }).catch((error) => {
+          if (!closed) options.onError(error);
+        });
+      },
+      Math.max(1, lastDemand + JPEG_CAPTURE_IDLE_MS - options.now()),
+    );
+    timer.unref?.();
+  }
+
+  /** Pin before the first await. Native transitions may pass false to protect
+   * existing reads without creating/renewing image demand on a video-only page.
+   * Completion renews a real read, allowing slow startup/capture to finish safely.
+   */
+  function pin(renew = true): () => void {
+    if (closed) throw new Error("JPEG capture lifetime is closed");
+    clearTimer();
+    pins += 1;
+    if (renew) lastDemand = options.now();
+    const pinnedRevision = revision;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      pins -= 1;
+      if (renew && !closed && pinnedRevision === revision) lastDemand = options.now();
+      arm();
+    };
+  }
+
+  /** Explicit stop discards demand; an older pending read cannot rearm its timer. */
+  function cancel() {
+    revision += 1;
+    lastDemand = null;
+    clearTimer();
+  }
+
+  /** Shutdown prevents queued native work and future acquisition. */
+  function close() {
+    closed = true;
+    cancel();
+  }
+  return { pin, serialize, cancel, close };
+}

package/server/jpeg-frame.ts

@@ -0,0 +1,29 @@
+/** Read actual JPEG dimensions so CDP viewport metadata cannot authorize input on cropped pixels. */
+export function readJpegFrameDimensions(
+  dataBase64: string,
+): { width: number; height: number } | null {
+  const bytes = Buffer.from(dataBase64, "base64");
+  if (bytes.length < 4 || bytes.readUInt16BE(0) !== 0xffd8) return null;
+
+  let offset = 2;
+  while (offset < bytes.length) {
+    if (bytes[offset++] !== 0xff) return null;
+    while (bytes[offset] === 0xff) offset += 1;
+    const marker = bytes[offset++];
+    if (marker === undefined || marker === 0xda || marker === 0xd9) return null;
+    if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd8)) continue;
+    if (offset + 2 > bytes.length) return null;
+
+    const length = bytes.readUInt16BE(offset);
+    if (length < 2 || offset + length > bytes.length) return null;
+    // All JPEG start-of-frame markers except the Huffman/arithmetic table markers.
+    if (marker >= 0xc0 && marker <= 0xcf && ![0xc4, 0xc8, 0xcc].includes(marker)) {
+      if (length < 8) return null;
+      const height = bytes.readUInt16BE(offset + 3);
+      const width = bytes.readUInt16BE(offset + 5);
+      return width > 0 && height > 0 ? { width, height } : null;
+    }
+    offset += length;
+  }
+  return null;
+}

package/server/keyboard-input.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { browserGestureEventSchema, browserGestureKeySchema } from "../shared/browser";
+import { heldKeyModifiers, nativeKeyEvent } from "./keyboard-input";
+
+const key = (key: string, code: string, modifiers = 0) =>
+  browserGestureKeySchema.parse({ kind: "key", type: "down", key, code, modifiers });
+
+describe("native keyboard envelopes", () => {
+  it("preserves Unicode and space while Enter and Tab retain native meanings", () => {
+    expect(nativeKeyEvent(key("😀", "KeyA"))).toMatchObject({ type: "keyDown", text: "😀" });
+    expect(nativeKeyEvent(key(" ", "Space"))).toMatchObject({
+      text: " ",
+      windowsVirtualKeyCode: 32,
+    });
+    expect(nativeKeyEvent(key("Enter", "Enter"))).toMatchObject({
+      text: "\r",
+      windowsVirtualKeyCode: 13,
+    });
+    expect(nativeKeyEvent(key("Tab", "Tab"))).toMatchObject({
+      type: "rawKeyDown",
+      windowsVirtualKeyCode: 9,
+    });
+    expect(nativeKeyEvent(key("Tab", "Tab"))).not.toHaveProperty("text");
+    expect(nativeKeyEvent(key("ArrowLeft", "ArrowLeft"))).toMatchObject({
+      windowsVirtualKeyCode: 37,
+    });
+    expect(nativeKeyEvent(key("A", "KeyA", 8))).toMatchObject({ text: "A", modifiers: 8 });
+  });
+
+  it("forwards shortcuts and repeat without synthesizing printable characters", () => {
+    expect(nativeKeyEvent(key("a", "KeyA", 2))).toMatchObject({
+      type: "rawKeyDown",
+      windowsVirtualKeyCode: 65,
+      modifiers: 2,
+    });
+    expect(nativeKeyEvent(key("a", "KeyA", 2))).not.toHaveProperty("text");
+    expect(nativeKeyEvent({ ...key("a", "KeyA"), repeat: true })).toHaveProperty(
+      "autoRepeat",
+      true,
+    );
+    expect(heldKeyModifiers([{ key: "Control" }, { key: "Shift" }])).toBe(10);
+  });
+
+  it("rejects shortcut text, keyup text/repeat and oversized committed text", () => {
+    expect(browserGestureKeySchema.safeParse({ ...key("a", "KeyA", 2), text: "a" }).success).toBe(
+      false,
+    );
+    expect(
+      browserGestureKeySchema.safeParse({ ...key("a", "KeyA"), type: "up", text: "a" }).success,
+    ).toBe(false);
+    expect(
+      browserGestureKeySchema.safeParse({ ...key("a", "KeyA"), type: "up", repeat: true }).success,
+    ).toBe(false);
+    expect(browserGestureEventSchema.safeParse({ kind: "text", text: "漢字\n😀" }).success).toBe(
+      true,
+    );
+    expect(
+      browserGestureEventSchema.safeParse({ kind: "text", text: "x".repeat(16001) }).success,
+    ).toBe(false);
+  });
+});