sailfork / t3code-github / apps/ web/ src/ components/ preview/ previewSessionSync.browser.test.ts

import {
  EnvironmentId,
  ThreadId,
  type PreviewEvent,
  type PreviewListResult,
  type PreviewSessionSnapshot,
} from "@t3tools/contracts";
import { AsyncResult, Atom } from "effect/reactivity";
import { createElement } from "react";
import { describe, expect, it, vi } from "vite-plus/test";

import { act, fakeTimers, render } from "../../../test/render";

// Only the transport is substituted. The hook, atom registry and preview
// store run unchanged, including idle-TTL node removal.
type ListResult = AsyncResult.AsyncResult<PreviewListResult, never>;
type EventResult = AsyncResult.AsyncResult<PreviewEvent, never>;
const harness = vi.hoisted(() => ({
  lists: new Map<string, { requests: number; atom: Atom.Writable<ListResult> }>(),
  events: new Map<string, Atom.Writable<EventResult>>(),
}));

vi.mock("~/env", () => ({ isElectron: true }));

vi.mock("~/state/preview", async () => {
  const { AsyncResult, Atom } = await import("effect/reactivity");
  return {
    previewEnvironment: {
      list: (target: { input: { threadId: string } }) => {
        const key = target.input.threadId;
        let entry = harness.lists.get(key);
        if (!entry) {
          let current: ListResult = AsyncResult.initial();
          const created = {
            requests: 0,
            atom: Atom.writable(
              () => {
                created.requests += 1;
                return AsyncResult.waiting(current);
              },
              (ctx, value: ListResult) => {
                current = value;
                ctx.setSelf(value);
              },
            ),
          };
          entry = created;
          harness.lists.set(key, entry);
        }
        return entry.atom;
      },
      events: (target: { environmentId: string }) => {
        let atom = harness.events.get(target.environmentId);
        if (!atom) {
          atom = Atom.make<EventResult>(AsyncResult.initial());
          harness.events.set(target.environmentId, atom);
        }
        return atom;
      },
    },
  };
});

import { readThreadPreviewState, resetPreviewStateForTests } from "~/previewStateStore";
import { AppAtomRegistryProvider, appAtomRegistry } from "~/rpc/atomRegistry";
import { previewEnvironment } from "~/state/preview";
import { useDesktopHostedPreviewSessions } from "./usePreviewSession";

describe("desktop-hosted preview session sync", () => {
  it("stops syncing a thread once its last tab closes and resumes when a tab opens again", async () => {
    resetPreviewStateForTests();
    const ref = {
      environmentId: EnvironmentId.make("preview-sync-release"),
      threadId: ThreadId.make("thread-sync-release"),
    };
    previewEnvironment.events({ environmentId: ref.environmentId, input: {} });
    previewEnvironment.list({
      environmentId: ref.environmentId,
      input: { threadId: ref.threadId },
    });
    const events = harness.events.get(ref.environmentId)!;
    const listAtom = harness.lists.get(ref.threadId)!.atom;
    const listRequests = () => harness.lists.get(ref.threadId)!.requests;
    const isListMounted = () => appAtomRegistry.getNodes().has(listAtom);
    const snapshot = (tabId: string): PreviewSessionSnapshot => ({
      threadId: ref.threadId,
      tabId,
      navStatus: { _tag: "Idle" },
      canGoBack: false,
      canGoForward: false,
      updatedAt: "2026-10-02T00:00:00.000Z",
    });
    let revision = 0;
    const emit = (type: "opened" | "closed", tabId: string) =>
      act(async () => {
        revision += 1;
        const base = {
          threadId: ref.threadId,
          tabId,
          serverEpoch: "epoch-1",
          revision,
          createdAt: "2026-10-02T00:00:00.000Z",
        };
        appAtomRegistry.set(
          events,
          AsyncResult.success(
            type === "opened" ? { ...base, type, snapshot: snapshot(tabId) } : { ...base, type },
          ),
        );
      });

    function DesktopSessionSync() {
      useDesktopHostedPreviewSessions(ref.environmentId);
      return null;
    }
    // The hook renders nothing and never reads or changes the route.
    await using _screen = await render(
      createElement(AppAtomRegistryProvider, null, createElement(DesktopSessionSync)),
      { router: false },
    );
    using _timers = fakeTimers();

    await emit("opened", "first");
    await emit("opened", "second");
    appAtomRegistry.set(
      listAtom,
      AsyncResult.success({
        serverEpoch: "epoch-1",
        revision,
        sessions: [snapshot("first"), snapshot("second")],
      }),
    );
    expect(listRequests()).toBe(1);

    // One tab is still open, so the thread keeps syncing.
    await emit("closed", "first");
    await act(async () => vi.advanceTimersByTime(5_000));
    expect(isListMounted()).toBe(true);

    await emit("closed", "second");
    await act(async () => vi.advanceTimersByTime(5_000));
    expect(readThreadPreviewState(ref).sessions).toEqual({});
    expect(isListMounted()).toBe(false);

    await emit("opened", "third");
    expect(listRequests()).toBe(2);
    expect(Object.keys(readThreadPreviewState(ref).sessions)).toEqual(["third"]);
    await emit("closed", "third");
    expect(readThreadPreviewState(ref).sessions).toEqual({});
    resetPreviewStateForTests();
  });
});