@omercnet/paseo-shared-browser 1.2.2-next.232.1 → 1.2.2-next.239.1

package/server/daemon-shutdown.test.ts

@@ -0,0 +1,289 @@
+/** The session daemon is signalled only while it is still the exact process this runtime launched. */
+import { type ChildProcess, spawn } from "node:child_process";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AgentBrowserRuntime } from "./agent-browser-runtime";
+import { RUNTIME_OWNER_VARIABLE } from "./process-identity";
+
+const probe = vi.hoisted(() => ({
+  unreadable: false,
+  /** Simulated /proc ownership for platforms without it: pid -> start ticks. */
+  simulated: null as Map<number, string> | null,
+}));
+vi.mock("./process-identity", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./process-identity")>();
+  return {
+    ...actual,
+    probeProcess: (pid: number, nonce: string) => {
+      if (probe.unreadable) return Promise.resolve({ status: "unknown" as const });
+      if (!probe.simulated) return actual.probeProcess(pid, nonce);
+      // Simulated ownership (platforms without /proc): a stable start time for owned pids,
+      // real liveness so a killed child is observed absent rather than owned forever.
+      if (!actual.processExists(pid)) return Promise.resolve({ status: "absent" as const });
+      const startTicks = probe.simulated.get(pid);
+      return Promise.resolve(
+        startTicks === undefined
+          ? { status: "foreign" as const }
+          : { status: "owned" as const, identity: { pid, startTicks } },
+      );
+    },
+  };
+});
+
+const cli = vi.hoisted(() => ({ onClose: null as null | (() => void), closes: 0 }));
+vi.mock("node:child_process", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("node:child_process")>()),
+  execFile: (
+    _file: string,
+    args: string[],
+    _options: unknown,
+    callback: (error: null, result: { stdout: string }) => void,
+  ) => {
+    if (args.includes("close")) {
+      cli.closes += 1;
+      cli.onClose?.();
+    }
+    callback(null, { stdout: args.includes("--version") ? "0.37.1\n" : "{}\n" });
+  },
+}));
+
+const children: ChildProcess[] = [];
+const directories: string[] = [];
+afterEach(async () => {
+  for (const child of children.splice(0)) child.kill("SIGKILL");
+  await Promise.all(
+    directories.splice(0).map((path) => rm(path, { recursive: true, force: true })),
+  );
+  cli.onClose = null;
+  cli.closes = 0;
+  probe.unreadable = false;
+  probe.simulated = null;
+  vi.restoreAllMocks();
+});
+
+/** A harmless process this test owns; `nonce` makes it descend from the runtime's own launch. */
+async function ownChild(nonce?: string): Promise<ChildProcess> {
+  const child = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], {
+    stdio: "ignore",
+    env: nonce ? { ...process.env, [RUNTIME_OWNER_VARIABLE]: nonce } : process.env,
+  });
+  children.push(child);
+  await new Promise((resolve) => child.once("spawn", resolve));
+  return child;
+}
+
+const alive = (pid: number) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const exited = (child: ChildProcess) =>
+  child.exitCode !== null || child.signalCode !== null
+    ? Promise.resolve()
+    : new Promise((resolve) => child.once("exit", resolve));
+
+async function fixture(waitMs = 400) {
+  const directory = await mkdtemp(join(tmpdir(), "shared-browser-daemon-"));
+  directories.push(directory);
+  const ipc = join(directory, "ipc");
+  const profile = join(directory, "profile");
+  await mkdir(ipc, { recursive: true });
+  const runtime = new AgentBrowserRuntime({
+    binaryPath: process.execPath,
+    executablePath: join(directory, "unlaunched-chromium"),
+    profilePath: profile,
+    ipcDirectory: ipc,
+    session: "owned",
+    daemonExitWaitMs: waitMs,
+  });
+  const native = runtime as unknown as {
+    ownerNonce: string;
+    daemonLaunched: boolean;
+    captureDaemon(): Promise<void>;
+    daemon: { pid: number; identity: { pid: number; startTicks: string } | null } | null;
+  };
+  const recordPid = async (pid: number) => {
+    await mkdir(profile, { recursive: true });
+    await writeFile(join(ipc, "owned.pid"), String(pid));
+    await writeFile(join(ipc, "owned.sock"), "");
+    native.daemonLaunched = true;
+    await native.captureDaemon();
+  };
+  return { runtime, native, recordPid, ipc, profile };
+}
+
+describe.skipIf(process.platform !== "linux")("owned daemon shutdown", () => {
+  it("waits for the acknowledged close to finish the daemon without signalling it, preserving the profile", async () => {
+    const f = await fixture();
+    const daemon = await ownChild(f.native.ownerNonce);
+    await f.recordPid(daemon.pid as number);
+    expect(f.native.daemon?.identity?.pid).toBe(daemon.pid);
+    const kill = vi.spyOn(process, "kill");
+    cli.onClose = () => void setTimeout(() => daemon.kill("SIGTERM"), 100);
+    await f.runtime.shutdown();
+    await exited(daemon);
+    expect(kill).not.toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+    await expect(readFile(join(f.ipc, "owned.sock"))).rejects.toThrow();
+    await expect(readFile(join(f.profile, "."))).rejects.toMatchObject({ code: "EISDIR" });
+  });
+
+  it("force-terminates a daemon that outlives the bounded wait and confirms exit before returning", async () => {
+    const f = await fixture(200);
+    const daemon = await ownChild(f.native.ownerNonce);
+    await f.recordPid(daemon.pid as number);
+    const kill = vi.spyOn(process, "kill");
+    await f.runtime.shutdown();
+    // exit was confirmed before shutdown returned; the OS only has to deliver the status
+    await exited(daemon);
+    // Portable contract (signalCode is POSIX-only): the runtime asked for SIGKILL of the
+    // owned pid, and that process is observably gone.
+    expect(kill).toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+    expect(daemon.pid && alive(daemon.pid)).toBe(false);
+    expect(cli.closes).toBe(1);
+    await expect(readFile(join(f.ipc, "owned.pid"))).rejects.toThrow();
+  });
+
+  it("fails shutdown instead of reporting success when a signalled daemon does not exit", async () => {
+    const f = await fixture(200);
+    const daemon = await ownChild(f.native.ownerNonce);
+    await f.recordPid(daemon.pid as number);
+    const kill = vi.spyOn(process, "kill").mockImplementation(() => true);
+    await expect(f.runtime.shutdown(true)).rejects.toThrow("not confirmed");
+    expect(kill).toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+    expect(daemon.pid && alive(daemon.pid)).toBe(true);
+  });
+
+  it("never signals a verified PID that was recycled after capture", async () => {
+    const f = await fixture(200);
+    const recorded = await ownChild(f.native.ownerNonce);
+    await f.recordPid(recorded.pid as number);
+    const identity = f.native.daemon?.identity;
+    expect(identity).toBeTruthy();
+    // Same PID, different birth: the recorded start time no longer matches.
+    f.native.daemon = {
+      pid: recorded.pid as number,
+      identity: { ...(identity as { pid: number; startTicks: string }), startTicks: "1" },
+    };
+    const kill = vi.spyOn(process, "kill");
+    await f.runtime.shutdown(true);
+    expect(kill).not.toHaveBeenCalledWith(recorded.pid, "SIGKILL");
+    expect(recorded.pid && alive(recorded.pid)).toBe(true);
+  });
+
+  it("does not own a same-executable process from another session named by the PID file", async () => {
+    const f = await fixture(200);
+    // Same executable as the runtime's own children, but not launched by this runtime.
+    const otherSession = await ownChild();
+    await f.recordPid(otherSession.pid as number);
+    expect(f.native.daemon?.identity).toBeNull();
+    const kill = vi.spyOn(process, "kill");
+    await expect(f.runtime.shutdown(true)).rejects.toThrow("not confirmed");
+    expect(kill).not.toHaveBeenCalledWith(otherSession.pid, "SIGKILL");
+    expect(otherSession.pid && alive(otherSession.pid)).toBe(true);
+  });
+});
+
+describe("unverifiable daemon identity (platforms without /proc, unowned PIDs)", () => {
+  it("accepts a graceful close once the recorded process is observed gone, without signalling", async () => {
+    const f = await fixture();
+    const daemon = await ownChild();
+    await f.recordPid(daemon.pid as number);
+    const kill = vi.spyOn(process, "kill");
+    cli.onClose = () => void setTimeout(() => daemon.kill("SIGTERM"), 100);
+    await f.runtime.shutdown();
+    expect(kill).not.toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+    await expect(readFile(join(f.ipc, "owned.sock"))).rejects.toThrow();
+  });
+
+  it("neither signals nor reports success when the recorded process stays alive", async () => {
+    const f = await fixture(150);
+    const daemon = await ownChild();
+    await f.recordPid(daemon.pid as number);
+    const kill = vi.spyOn(process, "kill");
+    await expect(f.runtime.shutdown()).rejects.toThrow("not confirmed");
+    expect(kill).not.toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+  });
+
+  it("has nothing to observe or signal for a runtime that never launched", async () => {
+    // Never launched: ordinary cleanup has nothing to observe.
+    const f = await fixture(150);
+    await f.native.captureDaemon();
+    expect(f.native.daemon).toBeNull();
+    await expect(f.runtime.shutdown()).resolves.toBeUndefined();
+  });
+});
+
+/** Real /proc ownership on Linux; an explicit simulation of it everywhere (macOS, Windows have no /proc). */
+const ownershipModes =
+  process.platform === "linux" ? (["real", "simulated"] as const) : (["simulated"] as const);
+describe.each(ownershipModes)(
+  "unknown daemon state is never confirmed exit (%s ownership)",
+  (mode) => {
+    /** Marks a child as this runtime's own daemon when ownership is simulated. */
+    const own = (daemon: ChildProcess) => {
+      if (mode === "simulated") probe.simulated = new Map([[daemon.pid as number, "42"]]);
+    };
+    it("fails closed, then recovers once the PID record is observable, when capture found no PID", async () => {
+      const f = await fixture(150);
+      const daemon = await ownChild(f.native.ownerNonce);
+      own(daemon);
+      f.native.daemonLaunched = true; // launched, but the PID file is unreadable at capture
+      await f.native.captureDaemon();
+      expect(f.native.daemon).toBeNull();
+      const kill = vi.spyOn(process, "kill");
+      await expect(f.runtime.shutdown()).rejects.toThrow("not confirmed");
+      await expect(f.runtime.shutdown(true)).rejects.toThrow("not confirmed");
+      expect(kill).not.toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+      expect(daemon.pid && alive(daemon.pid)).toBe(true);
+      // The record becomes readable again: shutdown re-captures, re-verifies and finishes.
+      await writeFile(join(f.ipc, "owned.pid"), String(daemon.pid));
+      await f.runtime.shutdown(true);
+      await exited(daemon);
+      // Portable contract (signalCode is POSIX-only): the runtime asked for SIGKILL of the
+      // owned pid, and that process is observably gone.
+      expect(kill).toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+      expect(daemon.pid && alive(daemon.pid)).toBe(false);
+    });
+
+    it("does not treat a later unreadable identity as exit and never signals on it", async () => {
+      const f = await fixture(150);
+      const daemon = await ownChild(f.native.ownerNonce);
+      own(daemon);
+      await f.recordPid(daemon.pid as number);
+      expect(f.native.daemon?.identity).toBeTruthy();
+      probe.unreadable = true;
+      const kill = vi.spyOn(process, "kill");
+      await expect(f.runtime.shutdown()).rejects.toThrow("not confirmed");
+      await expect(f.runtime.shutdown(true)).rejects.toThrow("not confirmed");
+      expect(kill).not.toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+      expect(daemon.pid && alive(daemon.pid)).toBe(true);
+      await expect(readFile(join(f.ipc, "owned.sock"))).resolves.toBeDefined(); // metadata kept
+      // Identity is readable again: the original verification authorises the forced exit.
+      probe.unreadable = false;
+      await f.runtime.shutdown(true);
+      await exited(daemon);
+      // Portable contract (signalCode is POSIX-only): the runtime asked for SIGKILL of the
+      // owned pid, and that process is observably gone.
+      expect(kill).toHaveBeenCalledWith(daemon.pid, "SIGKILL");
+      expect(daemon.pid && alive(daemon.pid)).toBe(false);
+    });
+
+    it("shares one in-flight shutdown and never reports success after a failed one", async () => {
+      const f = await fixture(150);
+      const daemon = await ownChild();
+      await f.recordPid(daemon.pid as number); // unowned: observable, not signalled
+      const outcomes = await Promise.allSettled([f.runtime.shutdown(), f.runtime.shutdown()]);
+      expect(outcomes.map((outcome) => outcome.status)).toEqual(["rejected", "rejected"]);
+      await expect(f.runtime.shutdown()).rejects.toThrow("not confirmed");
+      daemon.kill("SIGKILL");
+      await exited(daemon);
+      await expect(f.runtime.shutdown()).resolves.toBeUndefined();
+      await expect(f.runtime.shutdown()).resolves.toBeUndefined();
+    });
+  },
+);

package/server/discrete-input-freshness.test.ts

@@ -0,0 +1,364 @@
+/** Exercises real capture/input policy with delayed native replies, without starting a daemon. */
+import { expect, it } from "vitest";
+import type { BrowserInputEvent, BrowserState } from "../shared/browser";
+import type { BrowserFrameAuthority } from "../shared/browser-video";
+import { SessionManager } from "./browser-policy";
+
+/** One owned document and injected elapsed clock make publication boundaries observable. */
+async function fixture() {
+  let clock = 1_000;
+  let monotonicClock = 1_000;
+  let ids = 0;
+  let document = "1:1";
+  let intercept: (operation: string) => void = () => {};
+  const calls: string[] = [];
+  const manager = new SessionManager({
+    now: () => clock,
+    monotonicNow: () => monotonicClock,
+    validateWorkspace: async () => true,
+    issueToken: () => String(++ids).padStart(32, "0"),
+    client: {
+      connect: async () => ({ epoch: 1 }),
+      ensureWorkspace: async (workspaceId) => ({
+        workspaceId,
+        runtimeId: "r".repeat(32),
+        createdAt: 1,
+      }),
+      archiveWorkspace: async () => {},
+      ...{ closeWorkspace: async () => {} },
+      disconnect: () => {},
+      requestWorkspace: async (_workspace, operation) => {
+        calls.push(operation);
+        intercept(operation);
+        if (operation === "identity") return { userAgent: "Fixture" };
+        if (operation === "state") {
+          return {
+            url: "https://fixture.invalid/",
+            title: "Fixture",
+            inputGeneration: document,
+            canGoBack: false,
+            canGoForward: false,
+          };
+        }
+        if (operation === "frame") {
+          return {
+            dataBase64: "eA==",
+            byteLength: 1,
+            width: 1280,
+            height: 800,
+            capturedAt: new Date(clock).toISOString(),
+          };
+        }
+        if (operation === "video.read") {
+          return {
+            status: "ready",
+            streamId: "v".repeat(32),
+            inputGeneration: document,
+            packets: [
+              {
+                streamId: "v".repeat(32),
+                captureGeneration: 1,
+                sequence: 1,
+                timestampUs: 1000,
+                type: "key",
+                codec: "vp8",
+                width: 1280,
+                height: 800,
+                capturedAt: new Date(clock).toISOString(),
+                capturedAtMonotonicMs: monotonicClock,
+                dataBase64: "AA==",
+              },
+            ],
+          };
+        }
+        return null;
+      },
+    },
+  });
+  await manager.connect();
+  const { viewerToken } = await manager.attach("owned", "Fixture");
+  const { controlToken } = await manager.acquireControl(viewerToken);
+  return {
+    manager,
+    viewerToken,
+    calls,
+    advance: (milliseconds: number) => {
+      clock += milliseconds;
+      monotonicClock += milliseconds;
+    },
+    advanceWall: (milliseconds: number) => {
+      clock += milliseconds;
+    },
+    advanceMonotonic: (milliseconds: number) => {
+      monotonicClock += milliseconds;
+    },
+    replaceDocument: () => {
+      document = "1:2";
+    },
+    intercept: (callback: (operation: string) => void) => {
+      intercept = callback;
+    },
+    capture: () => manager.capture(viewerToken),
+    videoCapture: async () => {
+      const reply = await manager.readVideo({
+        viewerToken,
+        quality: "high",
+        streamId: null,
+        afterSequence: 0,
+        waitMs: 0,
+        requestKeyFrame: true,
+      });
+      return { state: reply.state, frame: reply.packets[0]!.frame };
+    },
+    send: (
+      capture: { state: BrowserState; frame: BrowserFrameAuthority | null },
+      event: BrowserInputEvent,
+    ) => {
+      const state = capture.state;
+      return manager.sendInput({
+        viewerToken,
+        controlToken,
+        expected: {
+          sessionId: state.sessionId,
+          runtimeId: state.runtimeId!,
+          bridgeEpoch: state.bridgeEpoch!,
+          navigationGeneration: state.navigationGeneration,
+          viewportGeneration: state.viewportGeneration,
+        },
+        target: capture.frame!,
+        event,
+      });
+    },
+  };
+}
+
+const click: BrowserInputEvent = {
+  kind: "click",
+  point: { x: 100, y: 100, width: 1280, height: 800 },
+  button: "left",
+  clickCount: 1,
+};
+
+it("refuses a capture whose final metadata replaced the same-URL document", async () => {
+  const f = await fixture();
+  try {
+    let pixelsCaptured = false;
+    f.intercept((operation) => {
+      if (operation === "frame") pixelsCaptured = true;
+      if (operation === "state" && pixelsCaptured) f.replaceDocument();
+    });
+    await expect(f.capture()).rejects.toThrow("changed during capture");
+    expect(f.calls).not.toContain("mouse.down");
+  } finally {
+    f.manager.disconnect();
+  }
+});
+
+it("refuses capture authority already expired while final metadata was pending", async () => {
+  const f = await fixture();
+  try {
+    let pixelsCaptured = false;
+    f.intercept((operation) => {
+      if (operation === "frame") pixelsCaptured = true;
+      if (operation === "state" && pixelsCaptured) f.advance(6_000);
+    });
+    await expect(f.capture()).rejects.toThrow("expired during validation");
+  } finally {
+    f.manager.disconnect();
+  }
+});
+
+it("does not extend capture age by the time spent validating metadata", async () => {
+  const f = await fixture();
+  try {
+    let pixelsCaptured = false;
+    f.intercept((operation) => {
+      if (operation === "frame") pixelsCaptured = true;
+      if (operation === "state" && pixelsCaptured) f.advance(4_000);
+    });
+    const capture = await f.capture();
+    f.intercept(() => {});
+    f.advance(1_001);
+    await expect(f.send(capture, click)).rejects.toThrow(
+      "Browser frame is stale (stage=admission; reason=expired; ageMs=5001)",
+    );
+    expect(f.calls).not.toContain("mouse.down");
+  } finally {
+    f.manager.disconnect();
+  }
+});
+
+for (const delayedOperation of ["mouse.move", "mouse.down"]) {
+  it(`finishes one admitted click after an eight-second ${delayedOperation} reply`, async () => {
+    const f = await fixture();
+    try {
+      const capture = await f.capture();
+      f.intercept((operation) => {
+        if (operation === delayedOperation) f.advance(8_000);
+      });
+      await expect(f.send(capture, click)).resolves.toHaveProperty("state");
+      expect(f.calls.filter((operation) => operation === "mouse.down")).toHaveLength(1);
+      expect(f.calls.filter((operation) => operation === "mouse.up")).toHaveLength(1);
+    } finally {
+      f.manager.disconnect();
+    }
+  });
+}
+
+it("still refuses an expired frame before publishing input", async () => {
+  const f = await fixture();
+  try {
+    const capture = await f.capture();
+    f.advance(5_000);
+    await expect(f.send(capture, click)).rejects.toThrow(
+      "Browser frame is stale (stage=admission; reason=expired; ageMs=5000)",
+    );
+    expect(
+      f.calls.filter((operation) => /^(?:mouse\.|key\.|text\.|input\.)/.test(operation)),
+    ).toEqual([]);
+  } finally {
+    f.manager.disconnect();
+  }
+});
+
+it("refuses a document replacement after down while releasing the original press once", async () => {
+  const f = await fixture();
+  try {
+    const capture = await f.capture();
+    f.intercept((operation) => {
+      if (operation === "mouse.down") {
+        f.advance(8_000);
+        f.replaceDocument();
+      }
+    });
+    await expect(f.send(capture, click)).rejects.toThrow(
+      "Browser frame is stale (stage=admitted-input; reason=context-changed)",
+    );
+    expect(f.calls.filter((operation) => operation === "mouse.down")).toHaveLength(1);
+    expect(f.calls.filter((operation) => operation === "mouse.up")).toHaveLength(1);
+    expect(f.calls.filter((operation) => operation === "input.end")).toHaveLength(1);
+  } finally {
+    f.manager.disconnect();
+  }
+});
+
+it("refuses bridge replacement during movement before any button press", async () => {
+  const f = await fixture();
+  try {
+    const capture = await f.capture();
+    f.intercept((operation) => {
+      if (operation === "mouse.move") f.manager.setBridgeEpoch(2);
+    });
+    await expect(f.send(capture, click)).rejects.toThrow("stale");
+    expect(f.calls).not.toContain("mouse.down");
+  } finally {
+    f.manager.disconnect();
+  }
+});
+
+it("does not extend a control lease while a discrete action is awaiting native work", async () => {
+  const f = await fixture();
+  try {
+    const capture = await f.capture();
+    f.intercept((operation) => {
+      if (operation === "mouse.move") f.advance(30_000);
+    });
+    await expect(f.send(capture, click)).rejects.toThrow("control lease");
+    expect(f.calls).not.toContain("mouse.down");
+  } finally {
+    f.manager.disconnect();
+  }
+});
+
+it("revokes the admitted observation when a published press loses its acknowledgement", async () => {
+  const f = await fixture();
+  try {
+    const capture = await f.capture();
+    f.intercept((operation) => {
+      if (operation === "mouse.down") throw new Error("Mutation outcome is unknown");
+    });
+    await expect(f.send(capture, click)).rejects.toThrow("outcome is unknown");
+    f.intercept(() => {});
+    const operationsBeforeReplay = f.calls.length;
+    await expect(f.send(capture, click)).rejects.toThrow(
+      "Browser frame is stale (stage=admission; reason=missing-or-revoked)",
+    );
+    expect(f.calls.slice(operationsBeforeReplay)).toEqual([]);
+    expect(f.calls.filter((operation) => operation === "mouse.down")).toHaveLength(1);
+  } finally {
+    f.manager.disconnect();
+  }
+});
+
+/** Admission diagnostics must describe the same clock and receipt the policy refuses. */
+for (const skew of [-8_000, 8_000]) {
+  it(`expires video authority at five monotonic seconds despite wall skew ${skew}`, async () => {
+    const f = await fixture();
+    try {
+      const capture = await f.videoCapture();
+      f.advanceWall(skew);
+      f.advanceMonotonic(5_000);
+      await expect(f.send(capture, click)).rejects.toThrow(
+        "Browser frame is stale (stage=admission; reason=expired; ageMs=5000)",
+      );
+      expect(
+        f.calls.filter((operation) => /^(?:mouse\.|key\.|text\.|input\.)/.test(operation)),
+      ).toEqual([]);
+    } finally {
+      f.manager.disconnect();
+    }
+  });
+}
+
+it("admits video authority before monotonic expiry despite a forward wall-clock jump", async () => {
+  const f = await fixture();
+  try {
+    const capture = await f.videoCapture();
+    f.advanceWall(8_000);
+    f.advanceMonotonic(4_999);
+    await expect(f.send(capture, click)).resolves.toHaveProperty("state");
+    expect(f.calls.filter((operation) => operation === "mouse.down")).toHaveLength(1);
+    expect(f.calls.filter((operation) => operation === "mouse.up")).toHaveLength(1);
+  } finally {
+    f.manager.disconnect();
+  }
+});
+
+it("reports a known generation mismatch with age without publishing native input", async () => {
+  const f = await fixture();
+  try {
+    const capture = await f.capture();
+    f.advance(25);
+    const changed = {
+      ...capture,
+      frame: { ...capture.frame!, navigationGeneration: capture.frame!.navigationGeneration + 1 },
+    };
+    await expect(f.send(changed, click)).rejects.toThrow(
+      "Browser frame is stale (stage=admission; reason=context-changed; ageMs=25)",
+    );
+    expect(
+      f.calls.filter((operation) => /^(?:mouse\.|key\.|text\.|input\.)/.test(operation)),
+    ).toEqual([]);
+  } finally {
+    f.manager.disconnect();
+  }
+});
+
+it("preserves expiry evidence before pruning and reports the retired receipt without age", async () => {
+  const f = await fixture();
+  try {
+    const capture = await f.capture();
+    f.advance(5_000);
+    await expect(f.send(capture, click)).rejects.toThrow(
+      "Browser frame is stale (stage=admission; reason=expired; ageMs=5000)",
+    );
+    await expect(f.send(capture, click)).rejects.toThrow(
+      "Browser frame is stale (stage=admission; reason=missing-or-revoked)",
+    );
+    expect(
+      f.calls.filter((operation) => /^(?:mouse\.|key\.|text\.|input\.)/.test(operation)),
+    ).toEqual([]);
+  } finally {
+    f.manager.disconnect();
+  }
+});