/** * The recovery policy is tested against a fake environment in * preload-error.test.ts; this covers the environment the browser actually gets, * because a policy fed the wrong inputs recovers from nothing. The failure this * guards against is silent: a probe that answers backwards, or a reload guard * that never latches, turns "reload once" into a reload loop with every * behavioural test still green. */ import { afterEach, describe, expect, it } from "@effect/vitest";import { browserEnvironment } from "./server-disconnected"; const BROWSER_GLOBALS = ["window", "document", "fetch", "reportError"] as const;const originalGlobals = new Map<string, unknown>(  BROWSER_GLOBALS.map((key) => [key, (globalThis as Record<string, unknown>)[key]]),); afterEach(() => {  // The fakes below are installed on the real global object; leaving them there  // would silently hand the next test a browser that does not exist.  for (const [key, value] of originalGlobals) {    if (value === undefined) delete (globalThis as Record<string, unknown>)[key];    else (globalThis as Record<string, unknown>)[key] = value;  }}); class FakeElement {  id = "";  textContent = "";  readonly style = { cssText: "" };  readonly children: FakeElement[] = [];   append(...nodes: FakeElement[]): void {    this.children.push(...nodes);  }   byId(id: string): FakeElement | null {    if (this.id === id) return this;    for (const child of this.children) {      const found = child.byId(id);      if (found) return found;    }    return null;  }   get text(): string {    return [this.textContent, ...this.children.map((child) => child.text)].join(" ").trim();  }} interface FetchCall {  readonly input: unknown;  readonly init: RequestInit | undefined;} const environment = (options: {  readonly respond?: () => Promise<{ ok: boolean; body: string }>;  readonly storage?: "working" | "blocked";}) => {  const body = new FakeElement();  const fetches: FetchCall[] = [];  const reloads = { count: 0 };  const reported: unknown[] = [];  const store = new Map<string, string>();   const sessionStorage = {    getItem: (key: string) => store.get(key) ?? null,    setItem: (key: string, value: string) => store.set(key, value),  };   const fakeWindow = {    addEventListener: () => {},    removeEventListener: () => {},    location: {      reload: () => {        reloads.count += 1;      },    },  };  if (options.storage === "blocked") {    Object.defineProperty(fakeWindow, "sessionStorage", {      get: () => {        // oxlint-disable-next-line executor/no-error-constructor, executor/no-try-catch-or-throw -- boundary: reproduces the SecurityError a browser raises when storage is blocked        throw new Error("SecurityError: storage is disabled");      },    });  } else {    Object.defineProperty(fakeWindow, "sessionStorage", { get: () => sessionStorage });  }   const globals = globalThis as Record<string, unknown>;  globals.window = fakeWindow;  globals.document = {    body,    createElement: () => new FakeElement(),    getElementById: (id: string) => body.byId(id),  };  globals.fetch = async (input: unknown, init?: RequestInit) => {    fetches.push({ input, init });    const answer = await (options.respond?.() ?? Promise.resolve({ ok: true, body: "ok" }));    return { ok: answer.ok, text: async () => answer.body };  };  globals.reportError = (error: unknown) => reported.push(error);   return { env: browserEnvironment(), body, fetches, reloads, reported, store };}; describe("browserEnvironment", () => {  it("probes the unauthenticated health endpoint and believes only a healthy answer", async () => {    const healthy = environment({ respond: async () => ({ ok: true, body: "ok\n" }) });    expect(await healthy.env.probeServer()).toBe(true);    expect(healthy.fetches).toHaveLength(1);    expect(healthy.fetches[0]?.input).toBe("/api/health");    // A cached 200 from before the server died would report it as alive.    expect(healthy.fetches[0]?.init?.cache).toBe("no-store");     const wrongBody = environment({ respond: async () => ({ ok: true, body: "<!doctype html>" }) });    expect(await wrongBody.env.probeServer()).toBe(false);     const failing = environment({ respond: async () => ({ ok: false, body: "" }) });    expect(await failing.env.probeServer()).toBe(false);  });   it("reads a refused connection as a down server rather than propagating", async () => {    const down = environment({      respond: async () => {        // oxlint-disable-next-line executor/no-error-constructor, executor/no-try-catch-or-throw -- boundary: fetch rejects when the origin is gone, which is the signal under test        throw new TypeError("Failed to fetch");      },    });     expect(await down.env.probeServer()).toBe(false);  });   it("shows one reconnect overlay however many times it is asked", () => {    const { env, body } = environment({});     env.showDisconnected();    env.showDisconnected();     const overlays = body.children.filter((child) => child.id === "executor-server-disconnected");    expect(overlays).toHaveLength(1);    expect(overlays[0]?.text).toContain("Lost connection to the Executor server");    expect(overlays[0]?.text).toContain("RECONNECTING");  });   it("latches the one-reload-per-session guard in storage", () => {    const { env, store } = environment({});     expect(env.readReloadFlag()).toBe(false);    env.writeReloadFlag();     expect(env.readReloadFlag()).toBe(true);    expect([...store.keys()]).toEqual(["executor:preload-reloaded"]);  });   it("reports rather than reloads when storage is unavailable", () => {    // Without a place to record the reload, an auto-reload could repeat    // forever; reading the flag as already spent degrades to reporting once.    const { env } = environment({ storage: "blocked" });     expect(env.readReloadFlag()).toBe(true);  });   it("reloads the page and reports through the shared handled-error reporter", () => {    const { env, reloads, reported } = environment({});    // oxlint-disable-next-line executor/no-error-constructor -- test boundary: stands in for the chunk TypeError    const failure = new TypeError("Failed to fetch dynamically imported module");     env.reload();    env.report(failure);     expect(reloads.count).toBe(1);    // Reporting the raw TypeError would file this as an unhandled crash with no    // surface attached; it must arrive as the normalized handled-error envelope.    expect(reported).toHaveLength(1);    const report = reported[0] as { readonly context?: unknown; readonly cause?: unknown };    expect(report.context).toMatchObject({      surface: "renderer",      action: "load-route-chunk",    });    expect(report.cause).toBe(failure);  });});