import {  EnvironmentId,  type PreviewAutomationRequest,  type PreviewAutomationResponse,  type PreviewAutomationStreamEvent,  PreviewTabId,  ThreadId,} from "@t3tools/contracts";import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";import { describe, expect, it, vi } from "vite-plus/test"; import {  PreviewAutomationRecordingNotActiveError,  PreviewAutomationTargetUnavailableError,  PreviewAutomationViewportTimeoutError,} from "./previewAutomationErrors";import {  createPreviewAutomationRequestConsumerAtom,  serializePreviewAutomationError,} from "./previewAutomationRequestConsumer"; const environmentId = EnvironmentId.make("environment-1");const threadId = ThreadId.make("thread-1");const tabId = PreviewTabId.make("tab-1");const clientId = "client-1";const connectionId = "connection-1"; const request = (  requestId: string,  overrides: Partial<PreviewAutomationRequest> = {},): PreviewAutomationRequest => ({  requestId,  threadId,  operation: "status",  input: {},  timeoutMs: 15_000,  ...overrides,}); const requestEvent = (  requestId: string,  overrides: Partial<PreviewAutomationRequest> = {},  eventConnectionId = connectionId,): PreviewAutomationStreamEvent => ({  type: "request",  connectionId: eventConnectionId,  request: request(requestId, overrides),}); const consumerState = (handleRequest: (request: PreviewAutomationRequest) => Promise<unknown>) => ({  connectionAtom: Atom.make<string | null>(null),  requestHandlerAtom: Atom.make({ handle: handleRequest }),}); describe("previewAutomationRequestConsumer", () => {  it("acknowledges a replacement stream before consuming requests from it", async () => {    const requestsAtom = Atom.make(      AsyncResult.success<PreviewAutomationStreamEvent, Error>({        type: "connected",        connectionId,      }),    );    const handleRequest = vi.fn(async () => undefined);    const respond = vi.fn(async () => undefined);    const state = consumerState(handleRequest);    const consumerAtom = createPreviewAutomationRequestConsumerAtom({      requestsAtom,      clientId,      connectionAtom: state.connectionAtom,      environmentId,      requestHandlerAtom: state.requestHandlerAtom,      respond,      label: "test:preview-automation-connected",    });    const registry = AtomRegistry.make();     registry.mount(consumerAtom);    registry.set(requestsAtom, AsyncResult.success(requestEvent("request-after-connect")));     await vi.waitFor(() => expect(registry.get(state.connectionAtom)).toBe(connectionId));    await vi.waitFor(() => expect(respond).toHaveBeenCalledTimes(1));    expect(handleRequest).toHaveBeenCalledTimes(1);    registry.dispose();  });   it("drops late requests from an older stream generation", async () => {    const requestsAtom = Atom.make(      AsyncResult.success<PreviewAutomationStreamEvent, Error>({        type: "connected",        connectionId: "connection-2",      }),    );    const handleRequest = vi.fn(async () => undefined);    const respond = vi.fn(async () => undefined);    const state = consumerState(handleRequest);    const consumerAtom = createPreviewAutomationRequestConsumerAtom({      requestsAtom,      clientId,      connectionAtom: state.connectionAtom,      environmentId,      requestHandlerAtom: state.requestHandlerAtom,      respond,      label: "test:preview-automation-stale-generation",    });    const registry = AtomRegistry.make();     registry.mount(consumerAtom);    registry.set(      requestsAtom,      AsyncResult.success(requestEvent("request-stale", {}, "connection-1")),    );     await vi.waitFor(() => expect(registry.get(state.connectionAtom)).toBe("connection-2"));    expect(handleRequest).not.toHaveBeenCalled();    expect(respond).not.toHaveBeenCalled();    registry.dispose();  });   it("consumes every request emitted before React can render", async () => {    const requestsAtom = Atom.make<AsyncResult.AsyncResult<PreviewAutomationStreamEvent, Error>>(      AsyncResult.initial<PreviewAutomationStreamEvent, Error>(false),    );    const handleRequest = vi.fn(async (value: PreviewAutomationRequest) => ({      requestId: value.requestId,    }));    const responses: PreviewAutomationResponse[] = [];    const respond = vi.fn(async (response: PreviewAutomationResponse) => {      responses.push(response);    });    const state = consumerState(handleRequest);    const consumerAtom = createPreviewAutomationRequestConsumerAtom({      requestsAtom,      clientId,      connectionAtom: state.connectionAtom,      environmentId,      requestHandlerAtom: state.requestHandlerAtom,      respond,      label: "test:preview-automation-consumer",    });    const registry = AtomRegistry.make();    registry.mount(consumerAtom);     registry.set(requestsAtom, AsyncResult.success(requestEvent("request-1")));    registry.set(requestsAtom, AsyncResult.success(requestEvent("request-2")));     await vi.waitFor(() => expect(respond).toHaveBeenCalledTimes(2));    expect(handleRequest.mock.calls.map(([value]) => value.requestId)).toEqual([      "request-1",      "request-2",    ]);    expect(responses.map((response) => response.requestId)).toEqual(["request-1", "request-2"]);    registry.dispose();  });   it("uses the latest request handler without rebuilding the stream consumer", async () => {    const requestsAtom = Atom.make<AsyncResult.AsyncResult<PreviewAutomationStreamEvent, Error>>(      AsyncResult.initial<PreviewAutomationStreamEvent, Error>(false),    );    const firstHandler = vi.fn(async () => "first");    const secondHandler = vi.fn(async () => "second");    const respond = vi.fn(async (_response: PreviewAutomationResponse) => undefined);    const state = consumerState(firstHandler);    const consumerAtom = createPreviewAutomationRequestConsumerAtom({      requestsAtom,      clientId,      connectionAtom: state.connectionAtom,      environmentId,      requestHandlerAtom: state.requestHandlerAtom,      respond,      label: "test:preview-automation-latest-handler",    });    const registry = AtomRegistry.make();    registry.mount(consumerAtom);     registry.set(requestsAtom, AsyncResult.success(requestEvent("request-first")));    await vi.waitFor(() => expect(respond).toHaveBeenCalledTimes(1));    registry.set(state.requestHandlerAtom, { handle: secondHandler });    registry.set(requestsAtom, AsyncResult.success(requestEvent("request-second")));     await vi.waitFor(() => expect(respond).toHaveBeenCalledTimes(2));    expect(firstHandler).toHaveBeenCalledTimes(1);    expect(secondHandler).toHaveBeenCalledTimes(1);    expect(respond.mock.calls.map(([response]) => response.result)).toEqual(["first", "second"]);    registry.dispose();  });   it("consumes a request that arrived immediately before the consumer mounted", async () => {    const requestsAtom = Atom.make(      AsyncResult.success<PreviewAutomationStreamEvent, Error>(requestEvent("request-ready")),    );    const respond = vi.fn(async (_response: PreviewAutomationResponse) => undefined);    const state = consumerState(async () => undefined);    const consumerAtom = createPreviewAutomationRequestConsumerAtom({      requestsAtom,      clientId,      connectionAtom: state.connectionAtom,      environmentId,      requestHandlerAtom: state.requestHandlerAtom,      respond,      label: "test:preview-automation-initial-request",    });    const registry = AtomRegistry.make();     registry.mount(consumerAtom);     await vi.waitFor(() => expect(respond).toHaveBeenCalledTimes(1));    expect(respond).toHaveBeenCalledWith({      clientId,      connectionId,      requestId: "request-ready",      ok: true,    });    registry.dispose();  });   it("preserves tagged automation errors and their structured diagnostics", () => {    const error = new PreviewAutomationTargetUnavailableError({      requestId: "request-1",      operation: "click",      environmentId,      threadId,      tabId,      bridgeAvailable: false,    });     expect(      serializePreviewAutomationError(error, {        requestId: "request-1",        operation: "click",        environmentId,        threadId,        tabId,      }),    ).toEqual({      _tag: "PreviewAutomationTabNotFoundError",      message:        "Preview automation target for click request request-1 is unavailable on environment environment-1 thread thread-1 (tab tab-1, bridge unavailable).",      detail: {        requestId: "request-1",        operation: "click",        environmentId: "environment-1",        threadId: "thread-1",        tabId: "tab-1",        bridgeAvailable: false,      },    });  });   it("reports a missing recording even when no preview tab remains", () => {    const error = new PreviewAutomationRecordingNotActiveError({      requestId: "request-recording-stop",      environmentId,      threadId,      tabId: null,    });     expect(      serializePreviewAutomationError(error, {        requestId: "request-recording-stop",        operation: "recordingStop",        environmentId,        threadId,        tabId: null,      }),    ).toMatchObject({      _tag: "PreviewAutomationExecutionError",      detail: { tabId: null },    });  });   it("preserves viewport render timeouts as timeout responses", () => {    const error = new PreviewAutomationViewportTimeoutError({      requestId: "request-resize",      environmentId,      threadId,      tabId,      timeoutMs: 2_500,    });     expect(      serializePreviewAutomationError(error, {        requestId: "request-resize",        operation: "resize",        environmentId,        threadId,        tabId,      }),    ).toMatchObject({      _tag: "PreviewAutomationTimeoutError",      detail: { tabId: "tab-1", timeoutMs: 2_500 },    });  });   it("maps desktop non-editable targets to the public typed response", () => {    expect(      serializePreviewAutomationError(        {          _tag: "PreviewAutomationTargetNotEditableError",          tabId: "tab-1",          selectorKind: "selector",          selectorLength: 6,        },        {          requestId: "request-type",          operation: "type",          environmentId,          threadId,          tabId,        },      ),    ).toEqual({      _tag: "PreviewAutomationTargetNotEditableError",      message:        "Preview automation type request request-type requires an editable target in tab tab-1.",      detail: {        requestId: "request-type",        operation: "type",        environmentId: "environment-1",        threadId: "thread-1",        tabId: "tab-1",        selectorKind: "selector",        selectorLength: 6,      },    });  });   it("correlates unexpected failures without exposing cause details", () => {    const cause = new Error("private bridge token: preview-secret");    const context = {      requestId: "request-2",      operation: "snapshot" as const,      environmentId,      threadId,      tabId,    };    const response = serializePreviewAutomationError(cause, context);     expect(response).toEqual({      _tag: "PreviewAutomationExecutionError",      message:        "Preview automation snapshot request request-2 failed on environment environment-1 thread thread-1 (tab tab-1).",      detail: {        requestId: "request-2",        operation: "snapshot",        environmentId: "environment-1",        threadId: "thread-1",        tabId: "tab-1",      },    });    expect(JSON.stringify(response)).not.toContain("preview-secret");  });   it("sanitizes unexpected handler failures at the response boundary", async () => {    const requestsAtom = Atom.make<AsyncResult.AsyncResult<PreviewAutomationStreamEvent, Error>>(      AsyncResult.initial<PreviewAutomationStreamEvent, Error>(false),    );    const responses: PreviewAutomationResponse[] = [];    const state = consumerState(async () => {      throw new Error("desktop IPC secret: do-not-return");    });    const consumerAtom = createPreviewAutomationRequestConsumerAtom({      requestsAtom,      clientId,      connectionAtom: state.connectionAtom,      environmentId,      requestHandlerAtom: state.requestHandlerAtom,      respond: async (response) => {        responses.push(response);      },      label: "test:preview-automation-failure-boundary",    });    const registry = AtomRegistry.make();    registry.mount(consumerAtom);     registry.set(      requestsAtom,      AsyncResult.success(        requestEvent("request-failed", {          operation: "click",          tabId,        }),      ),    );     await vi.waitFor(() => expect(responses).toHaveLength(1));    expect(responses[0]).toEqual({      clientId,      connectionId,      requestId: "request-failed",      ok: false,      error: {        _tag: "PreviewAutomationExecutionError",        message:          "Preview automation click request request-failed failed on environment environment-1 thread thread-1 (tab tab-1).",        detail: {          requestId: "request-failed",          operation: "click",          environmentId: "environment-1",          threadId: "thread-1",          tabId: "tab-1",        },      },    });    expect(JSON.stringify(responses[0])).not.toContain("do-not-return");    registry.dispose();  });});