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

package/server/reattach-held-input.test.ts

@@ -0,0 +1,143 @@
+import { EventEmitter } from "node:events";
+import { 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,
+  mobile: true,
+  touch: true,
+  screenWidth: 430,
+  screenHeight: 900,
+  userAgent: "fixture-mobile-agent",
+  platform: "Android",
+};
+
+const generation = (runtime: AgentBrowserRuntime) => {
+  const { attachmentGeneration, documentGeneration } = runtime as unknown as {
+    attachmentGeneration: number;
+    documentGeneration: number;
+  };
+  return `${attachmentGeneration}:${documentGeneration}`;
+};
+
+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 };
+}
+
+it("never releases input held on an older attachment onto a later one during screencast retry", async () => {
+  const { runtime, connection, control } = fixture();
+  await runtime.beginLiveInput("old-channel", generation(runtime));
+  await runtime.mouseDown(10, 20, "left", 1, "old-channel");
+  // Real reconnect + target publication; only transport setup is replaced.
+  const reconnected = new ConnectionFixture();
+  control.assertVersion = async () => {};
+  control.connectCdp = async () => {
+    control.connection = reconnected as unknown as CdpConnection;
+    await runtime.selectTarget("b");
+  };
+  await runtime.reconnect();
+  expect(connection.isOpen).toBe(false);
+  await control.reattachPageForScreencast(control.page!);
+  expect(reconnected.calls.filter((call) => call.params.type === "mouseReleased")).toEqual([]);
+  await runtime.endLiveInput("old-channel");
+});
+
+it("still releases held input on its own attachment before reattach detaches it", async () => {
+  const { runtime, connection, control, previous } = fixture();
+  await runtime.beginLiveInput("channel", generation(runtime));
+  await runtime.mouseDown(10, 20, "left", 1, "channel");
+  await control.reattachPageForScreencast(previous);
+  const order = connection.calls.map((call) => call.params.type ?? call.method);
+  expect(order.indexOf("mouseReleased")).toBeGreaterThan(-1);
+  expect(order.indexOf("mouseReleased")).toBeLessThan(order.indexOf("Target.detachFromTarget"));
+  expect(connection.calls.find((call) => call.params.type === "mouseReleased")).toMatchObject({
+    sessionId: "previous",
+    params: { x: 10, y: 20 },
+  });
+});
+
+it("does not retarget ungestured held input from a replaced attachment onto its replacement", async () => {
+  const { runtime, connection, control } = fixture();
+  await runtime.mouseDown(10, 20, "left", 1);
+  const reconnected = new ConnectionFixture();
+  control.assertVersion = async () => {};
+  control.connectCdp = async () => {
+    control.connection = reconnected as unknown as CdpConnection;
+    await runtime.selectTarget("b");
+  };
+  await runtime.reconnect();
+  expect(connection.isOpen).toBe(false);
+  await control.reattachPageForScreencast(control.page!);
+  expect(reconnected.calls.filter((call) => call.params.type === "mouseReleased")).toEqual([]);
+});

package/server/runtime-frame-reuse.test.ts

@@ -0,0 +1,295 @@
+/** Exact fresh runtime receipts avoid resending cached JPEGs without reviving invalidated input. */
+import { describe, expect, it } from "vitest";
+import type { BrowserFrame, BrowserState } from "../shared/browser";
+import { DEFAULT_CAPTURE_QUALITY } from "../shared/capture-settings";
+import { type BrowserRuntimeClient, SessionManager } from "./browser-policy";
+import type { JsonValue } from "./runtime-protocol";
+
+async function fixture() {
+  let now = 1_000;
+  let token = 0;
+  let frames = 0;
+  let inputGeneration = "0:0";
+  const raw: Record<string, JsonValue> = {
+    dataBase64: Buffer.alloc(200_000, 120).toString("base64"),
+    byteLength: 200_000,
+    width: 1280,
+    height: 800,
+    transport: "screenshot",
+    capturedAt: new Date(now).toISOString(),
+  };
+  const client: BrowserRuntimeClient = {
+    connect: async () => ({ epoch: 1 }),
+    ensureWorkspace: async (workspaceId) => ({
+      workspaceId,
+      runtimeId: "runtime-one",
+      createdAt: 1,
+    }),
+    requestWorkspace: async (_workspace, operation, input) => {
+      if (operation === "identity") return { userAgent: "Fixture" };
+      if (operation === "state")
+        return {
+          url: "https://fixture.invalid/",
+          title: "Fixture",
+          canGoBack: false,
+          canGoForward: false,
+          inputGeneration,
+        };
+      if (operation === "frame") {
+        frames++;
+        return { ...raw };
+      }
+      if (operation === "emulate" && input && typeof input === "object" && !Array.isArray(input)) {
+        raw.width = input.width!;
+        raw.height = input.height!;
+      }
+      if (operation === "cursor") return null;
+      return null;
+    },
+    archiveWorkspace: async () => {},
+    closeWorkspace: async () => {},
+    disconnect: () => {},
+  };
+  const manager = new SessionManager({
+    client,
+    now: () => now,
+    validateWorkspace: async () => true,
+    issueToken: () => String(++token).padStart(32, "0"),
+  });
+  await manager.connect();
+  const viewer = await manager.attach("owned-perf-fixture", "Viewer");
+  const control = await manager.acquireControl(viewer.viewerToken);
+  const expected = (state: BrowserState) => ({
+    sessionId: state.sessionId,
+    runtimeId: state.runtimeId!,
+    bridgeEpoch: state.bridgeEpoch!,
+    navigationGeneration: state.navigationGeneration,
+    viewportGeneration: state.viewportGeneration,
+  });
+  return {
+    manager,
+    raw,
+    viewer,
+    control,
+    expected,
+    get frames() {
+      return frames;
+    },
+    advance(ms = 250) {
+      now += ms;
+    },
+    documentChange() {
+      inputGeneration = "0:1";
+    },
+    session: () =>
+      (
+        manager as unknown as { sessions: Map<string, { runtimeId: string; bridgeEpoch: number }> }
+      ).sessions.get("owned-perf-fixture")!,
+  };
+}
+const target = (frame: BrowserFrame) => ({
+  frameId: frame.frameId,
+  navigationGeneration: frame.navigationGeneration,
+  viewportGeneration: frame.viewportGeneration,
+});
+
+describe("exact runtime receipt reuse across policy cache expiry", () => {
+  it("returns metadata-only repeated polls while preserving current-frame input authority", async () => {
+    const f = await fixture();
+    try {
+      const first = await f.manager.capture(f.viewer.viewerToken);
+      for (let index = 0; index < 3; index++) {
+        f.advance();
+        const repeated = await f.manager.capture(
+          f.viewer.viewerToken,
+          DEFAULT_CAPTURE_QUALITY,
+          first.frame!.frameId,
+        );
+        expect(repeated.frame).toBeNull();
+      }
+      expect(f.frames).toBe(4);
+      const result = await f.manager.beginGesture({
+        viewerToken: f.viewer.viewerToken,
+        controlToken: f.control.controlToken,
+        expected: f.expected(first.state),
+        target: target(first.frame!),
+        pointerKind: "mouse",
+      });
+      expect(result).toHaveProperty("gestureId");
+    } finally {
+      f.manager.disconnect();
+    }
+  });
+
+  it("assigns a new token for any changed runtime receipt field, including equal pixels at a new capture time", async () => {
+    for (const [field, value] of [
+      ["capturedAt", "2026-10-03T12:00:00.000Z"],
+      ["transport", "cdp-screencast"],
+      ["dataBase64", Buffer.alloc(200_000, 121).toString("base64")],
+      ["byteLength", 1],
+    ] as const) {
+      const f = await fixture();
+      try {
+        const first = await f.manager.capture(f.viewer.viewerToken);
+        f.advance();
+        f.raw[field] = value;
+        if (field === "byteLength") f.raw.dataBase64 = "eA==";
+        const next = await f.manager.capture(
+          f.viewer.viewerToken,
+          DEFAULT_CAPTURE_QUALITY,
+          first.frame!.frameId,
+        );
+        expect(next.frame?.frameId).not.toBe(first.frame!.frameId);
+      } finally {
+        f.manager.disconnect();
+      }
+    }
+  });
+
+  it("keeps per-quality tokens separate even for identical runtime receipts", async () => {
+    const f = await fixture();
+    try {
+      const first = await f.manager.capture(f.viewer.viewerToken, "high");
+      f.advance();
+      const next = await f.manager.capture(f.viewer.viewerToken, "medium", first.frame!.frameId);
+      expect(next.frame?.frameId).not.toBe(first.frame!.frameId);
+    } finally {
+      f.manager.disconnect();
+    }
+  });
+
+  it("cannot revive an identical runtime receipt after input invalidation", async () => {
+    const f = await fixture();
+    try {
+      const first = await f.manager.capture(f.viewer.viewerToken);
+      await f.manager.sendInput({
+        viewerToken: f.viewer.viewerToken,
+        controlToken: f.control.controlToken,
+        expected: f.expected(first.state),
+        target: target(first.frame!),
+        event: { kind: "type", text: "x" },
+      });
+      f.advance();
+      const next = await f.manager.capture(
+        f.viewer.viewerToken,
+        DEFAULT_CAPTURE_QUALITY,
+        first.frame!.frameId,
+      );
+      expect(next.frame?.frameId).not.toBe(first.frame!.frameId);
+      await expect(
+        f.manager.beginGesture({
+          viewerToken: f.viewer.viewerToken,
+          controlToken: f.control.controlToken,
+          expected: f.expected(next.state),
+          target: target(first.frame!),
+          pointerKind: "mouse",
+        }),
+      ).resolves.toMatchObject({ admission: "stale-frame" });
+    } finally {
+      f.manager.disconnect();
+    }
+  });
+
+  it("changes token for exact resized geometry and refuses malformed old dimensions", async () => {
+    const f = await fixture();
+    try {
+      const first = await f.manager.capture(f.viewer.viewerToken);
+      await f.manager.resize({
+        viewerToken: f.viewer.viewerToken,
+        controlToken: f.control.controlToken,
+        expected: f.expected(first.state),
+        viewport: { width: 1920, height: 1200 },
+      });
+      const next = await f.manager.capture(
+        f.viewer.viewerToken,
+        DEFAULT_CAPTURE_QUALITY,
+        first.frame!.frameId,
+      );
+      expect(next.frame).toMatchObject({ width: 1920, height: 1200 });
+      expect(next.frame!.frameId).not.toBe(first.frame!.frameId);
+      f.advance();
+      f.raw.width = 1280;
+      await expect(f.manager.capture(f.viewer.viewerToken)).rejects.toThrow("stale viewport");
+    } finally {
+      f.manager.disconnect();
+    }
+  });
+
+  it("does not reuse receipts under changed runtime identity or bridge epoch", async () => {
+    for (const field of ["runtimeId", "bridgeEpoch"] as const) {
+      const f = await fixture();
+      try {
+        const first = await f.manager.capture(f.viewer.viewerToken);
+        f.advance();
+        if (field === "runtimeId") f.session().runtimeId = "runtime-two";
+        else f.session().bridgeEpoch = 2;
+        const next = await f.manager.capture(
+          f.viewer.viewerToken,
+          DEFAULT_CAPTURE_QUALITY,
+          first.frame!.frameId,
+        );
+        expect(next.frame!.frameId).not.toBe(first.frame!.frameId);
+      } finally {
+        f.manager.disconnect();
+      }
+    }
+  });
+
+  it("cannot deduplicate legacy unmarked receipts or metadata after a document change", async () => {
+    for (const field of ["capturedAt", "transport"] as const) {
+      const f = await fixture();
+      try {
+        delete f.raw[field];
+        const first = await f.manager.capture(f.viewer.viewerToken);
+        f.advance();
+        const next = await f.manager.capture(
+          f.viewer.viewerToken,
+          DEFAULT_CAPTURE_QUALITY,
+          first.frame!.frameId,
+        );
+        expect(next.frame!.frameId).not.toBe(first.frame!.frameId);
+      } finally {
+        f.manager.disconnect();
+      }
+    }
+    const f = await fixture();
+    try {
+      const first = await f.manager.capture(f.viewer.viewerToken);
+      f.documentChange();
+      await f.manager.status(f.viewer.viewerToken);
+      f.advance();
+      const next = await f.manager.capture(
+        f.viewer.viewerToken,
+        DEFAULT_CAPTURE_QUALITY,
+        first.frame!.frameId,
+      );
+      expect(next.frame!.frameId).not.toBe(first.frame!.frameId);
+      expect(next.state.navigationGeneration).toBeGreaterThan(first.state.navigationGeneration);
+    } finally {
+      f.manager.disconnect();
+    }
+  });
+
+  it("avoids repeated large payloads while every expired policy read still asks the runtime for fresh pixels", async () => {
+    const f = await fixture();
+    try {
+      const first = await f.manager.capture(f.viewer.viewerToken);
+      let before = JSON.stringify(first).length;
+      let after = before;
+      for (let index = 0; index < 3; index++) {
+        f.advance();
+        const reply = await f.manager.capture(
+          f.viewer.viewerToken,
+          DEFAULT_CAPTURE_QUALITY,
+          first.frame!.frameId,
+        );
+        after += JSON.stringify(reply).length;
+        before += JSON.stringify({ state: reply.state, frame: first.frame }).length;
+      }
+      expect(after).toBeLessThan(before * 0.26);
+      expect(f.frames).toBe(4);
+    } finally {
+      f.manager.disconnect();
+    }
+  });
+});

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

@@ -0,0 +1,200 @@
+/** Actual runtime entry points with owned fake CDP, no Chromium/process fixture. */
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { DEFAULT_JPEG_QUALITY } from "../shared/capture-settings";
+import { AgentBrowserRuntime, type RuntimeFrame } from "./agent-browser-runtime";
+import { JPEG_CAPTURE_IDLE_MS } from "./jpeg-capture-demand";
+
+function jpeg(tag: number) {
+  return Buffer.from([
+    255,
+    216,
+    255,
+    224,
+    0,
+    3,
+    tag,
+    255,
+    192,
+    0,
+    11,
+    8,
+    3,
+    32,
+    5,
+    0,
+    1,
+    1,
+    17,
+    0,
+    255,
+    217,
+  ]).toString("base64");
+}
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.spyOn(performance, "now").mockImplementation(() => Date.now());
+});
+afterEach(() => {
+  vi.clearAllTimers();
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+});
+function setup() {
+  const runtime = new AgentBrowserRuntime({
+    nativeVideo: true,
+    binaryPath: "/tmp/unlaunched",
+    executablePath: "/tmp/unlaunched-chrome",
+    profilePath: "/tmp/uncreated-p",
+    ipcDirectory: "/tmp/uncreated-i",
+    session: "fixture",
+  });
+  const page = { send: vi.fn(async (_method: string, _params?: unknown) => ({})) };
+  let tag = 0;
+  const internal = runtime as unknown as {
+    page: typeof page;
+    requirePage(): Promise<typeof page>;
+    startScreencastSession(source: typeof page): Promise<void>;
+    onScreencastFrame(source: typeof page, event: unknown): void;
+    captureScreenshot(budget: number, quality: number, preserve?: boolean): Promise<RuntimeFrame>;
+    screencastActive: boolean;
+    invoke(args: string[]): Promise<unknown>;
+  };
+  Object.assign(runtime, {
+    page,
+    emulationAppliedPage: page,
+    viewport: { width: 1280, height: 800, deviceScaleFactor: 1, mobile: false, touch: false },
+  });
+  internal.requirePage = vi.fn(async () => page);
+  const emit = () =>
+    internal.onScreencastFrame(page, {
+      sessionId: 7,
+      data: jpeg(++tag),
+      metadata: { timestamp: (Date.now() + tag / 1000) / 1000 },
+    });
+  internal.startScreencastSession = vi.fn(async () => {
+    emit();
+  });
+  internal.captureScreenshot = vi.fn(
+    async (): Promise<RuntimeFrame> => ({
+      width: 1280,
+      height: 800,
+      transport: "screenshot",
+      dataBase64: jpeg(++tag),
+      byteLength: 24,
+      capturedAt: new Date().toISOString(),
+    }),
+  );
+  return { runtime, internal, page, emit };
+}
+/** A restored stream's first swap can fall inside the conservative source
+ * margin. Settle zero-wait polling so the honest screenshot fallback can finish. */
+async function readFrame(runtime: AgentBrowserRuntime, quality: number = DEFAULT_JPEG_QUALITY) {
+  const pending = runtime.frame(100, quality, 0);
+  await vi.advanceTimersByTimeAsync(0);
+  return pending;
+}
+
+it("lazy image/agent read starts shared JPEG once, idle video-only interval stops it, fresh read restarts", async () => {
+  const { runtime, internal, page, emit } = setup();
+  expect(internal.startScreencastSession).not.toHaveBeenCalled();
+  const first = await readFrame(runtime);
+  await vi.advanceTimersByTimeAsync(1500);
+  emit();
+  await readFrame(runtime);
+  expect(internal.startScreencastSession).toHaveBeenCalledTimes(1);
+  await vi.advanceTimersByTimeAsync(JPEG_CAPTURE_IDLE_MS);
+  expect(page.send).toHaveBeenCalledWith("Page.stopScreencast", {}, { mutation: true });
+  expect(internal.screencastActive).toBe(false);
+  const renewed = await readFrame(runtime);
+  expect(internal.startScreencastSession).toHaveBeenCalledTimes(2);
+  expect(renewed.dataBase64).not.toBe(first.dataBase64);
+  await runtime.stopScreencast();
+});
+it("nonmatching viewer quality stays screenshot-only and cannot keep JPEG95 running", async () => {
+  const { runtime, internal } = setup();
+  for (const quality of [70, 90, 100]) await readFrame(runtime, quality);
+  expect(internal.startScreencastSession).not.toHaveBeenCalled();
+  expect(internal.captureScreenshot).toHaveBeenCalledTimes(3);
+  await vi.advanceTimersByTimeAsync(JPEG_CAPTURE_IDLE_MS);
+  expect(internal.screencastActive).toBe(false);
+});
+it("switching to screenshot-only quality does not renew the former shared stream", async () => {
+  const { runtime, internal } = setup();
+  await readFrame(runtime);
+  for (let i = 0; i < 7; i++) {
+    await vi.advanceTimersByTimeAsync(500);
+    await readFrame(runtime, 100);
+  }
+  expect(internal.screencastActive).toBe(false);
+  expect(internal.startScreencastSession).toHaveBeenCalledTimes(1);
+});
+
+it("stream startup and screenshot completion both pin retirement beyond the idle deadline", async () => {
+  const { runtime, internal, page, emit } = setup();
+  const startup = Promise.withResolvers<void>();
+  internal.startScreencastSession = vi.fn(async () => {
+    await startup.promise;
+    emit();
+  });
+  const read = runtime.frame(100, DEFAULT_JPEG_QUALITY, 0);
+  await vi.advanceTimersByTimeAsync(10000);
+  expect(page.send).not.toHaveBeenCalledWith("Page.stopScreencast", {}, { mutation: true });
+  startup.resolve();
+  await read;
+  const screenshot = Promise.withResolvers<RuntimeFrame>();
+  internal.captureScreenshot = vi.fn(() => screenshot.promise);
+  const fallback = runtime.frame(100, 100, 0);
+  await vi.advanceTimersByTimeAsync(10000);
+  expect(internal.screencastActive).toBe(true);
+  screenshot.resolve({
+    width: 1280,
+    height: 800,
+    transport: "screenshot",
+    dataBase64: jpeg(9),
+    byteLength: 24,
+    capturedAt: new Date().toISOString(),
+  });
+  await fallback;
+  await vi.advanceTimersByTimeAsync(JPEG_CAPTURE_IDLE_MS);
+  expect(internal.screencastActive).toBe(false);
+});
+it("renewed read waits for exact old stop acknowledgment before restarting", async () => {
+  const { runtime, internal, page } = setup();
+  await readFrame(runtime);
+  const stop = Promise.withResolvers<object>();
+  page.send.mockImplementation(async (method) =>
+    method === "Page.stopScreencast" ? await stop.promise : {},
+  );
+  await vi.advanceTimersByTimeAsync(JPEG_CAPTURE_IDLE_MS);
+  const renewed = runtime.frame(100, DEFAULT_JPEG_QUALITY, 0);
+  await vi.advanceTimersByTimeAsync(100);
+  expect(internal.startScreencastSession).toHaveBeenCalledTimes(1);
+  stop.resolve({});
+  await vi.advanceTimersByTimeAsync(0);
+  await renewed;
+  expect(internal.startScreencastSession).toHaveBeenCalledTimes(2);
+  await runtime.stopScreencast();
+});
+it("failed optional stream falls back without setup retry every image poll; idle renew permits new setup", async () => {
+  const { runtime, internal } = setup();
+  internal.startScreencastSession = vi.fn(async () => {
+    throw new Error("unsupported stream");
+  });
+  await readFrame(runtime);
+  await readFrame(runtime);
+  expect(internal.startScreencastSession).toHaveBeenCalledTimes(1);
+  expect(internal.captureScreenshot).toHaveBeenCalledTimes(2);
+  await vi.advanceTimersByTimeAsync(JPEG_CAPTURE_IDLE_MS);
+  await readFrame(runtime);
+  expect(internal.startScreencastSession).toHaveBeenCalledTimes(2);
+  await runtime.stopScreencast();
+});
+it("shutdown cancels runtime-owned JPEG timer even without explicit viewer detach", async () => {
+  const { runtime, internal, page } = setup();
+  await readFrame(runtime);
+  internal.invoke = vi.fn(async () => ({}));
+  await runtime.shutdown();
+  await vi.advanceTimersByTimeAsync(10000);
+  expect(page.send).not.toHaveBeenCalledWith("Page.stopScreencast", {}, { mutation: true });
+  expect(vi.getTimerCount()).toBe(0);
+});