"use client"; import { useAtomValue } from "@effect/atom-react";import { squashAtomCommandFailure } from "@t3tools/client-runtime/state/runtime";import type {  PreviewAutomationNavigateInput,  PreviewAutomationOpenInput,  PreviewAutomationRequest,  PreviewAutomationOwner as PreviewAutomationOwnerState,  PreviewAutomationStatus,  ScopedThreadRef,} from "@t3tools/contracts";import { useCallback, useEffect, useEffectEvent, useId, useMemo, useRef, useState } from "react"; import {  applyPreviewServerSnapshot,  readThreadPreviewState,  subscribeThreadPreviewState,} from "~/previewStateStore";import { useRightPanelStore } from "~/rightPanelStore";import { resolveBrowserNavigationTarget } from "~/browser/browserTargetResolver";import { startBrowserRecording, stopBrowserRecording } from "~/browser/browserRecording";import { previewEnvironment } from "~/state/preview";import { useEnvironmentConnectionState } from "~/state/environments";import { useAtomCommand } from "~/state/use-atom-command"; import { previewBridge } from "./previewBridge";import {  createLatestPreviewAutomationRequestHandler,  createPreviewAutomationRequestConsumerAtom,} from "./previewAutomationRequestConsumer"; export function observeAutomationOwnerConnectedGeneration(  previousGeneration: number | null,  connectedGeneration: number | null,): {  readonly nextGeneration: number | null;  readonly shouldReport: boolean;} {  if (connectedGeneration === null) {    return {      nextGeneration: previousGeneration,      shouldReport: false,    };  }  return {    nextGeneration: connectedGeneration,    shouldReport: previousGeneration !== connectedGeneration,  };} const waitForDesktopOverlay = async (  threadRef: ScopedThreadRef,  timeoutMs: number,): Promise<void> => {  const deadline = Date.now() + timeoutMs;  while (Date.now() <= deadline) {    const state = readThreadPreviewState(threadRef);    const tabId = state.snapshot?.tabId;    if (tabId && state.desktopOverlay && previewBridge) {      const status = await previewBridge.automation.status(tabId);      if (status.available) return;    }    await new Promise<void>((resolve) => window.setTimeout(resolve, 50));  }  const error = new Error(`Preview webview did not register within ${timeoutMs}ms.`);  error.name = "PreviewAutomationTimeoutError";  throw error;}; const waitForNavigationReadiness = async (  tabId: string,  readiness: PreviewAutomationNavigateInput["readiness"],  timeoutMs: number,): Promise<void> => {  if (!previewBridge || readiness === "none") return;  const deadline = Date.now() + timeoutMs;  while (Date.now() <= deadline) {    if (readiness === "domContentLoaded") {      const readyState = await previewBridge.automation.evaluate(tabId, {        expression: "document.readyState",      });      if (readyState === "interactive" || readyState === "complete") return;    } else {      const status = await previewBridge.automation.status(tabId);      if (!status.loading) return;    }    await new Promise<void>((resolve) => window.setTimeout(resolve, 50));  }  const error = new Error(`Preview navigation did not become ready within ${timeoutMs}ms.`);  error.name = "PreviewAutomationTimeoutError";  throw error;}; const currentStatus = async (  threadRef: ScopedThreadRef,  visible: boolean,): Promise<PreviewAutomationStatus> => {  const state = readThreadPreviewState(threadRef);  const tabId = state.snapshot?.tabId ?? null;  if (tabId && previewBridge && state.desktopOverlay) {    const status = await previewBridge.automation.status(tabId);    return { ...status, visible };  }  const navStatus = state.snapshot?.navStatus;  return {    available: Boolean(previewBridge?.automation),    visible,    tabId,    url: navStatus && navStatus._tag !== "Idle" ? navStatus.url : null,    title: navStatus && navStatus._tag !== "Idle" ? navStatus.title : null,    loading: navStatus?._tag === "Loading",  };}; const previewTabNotFoundError = (): Error => {  const error = new Error("Preview tab is not initialized.");  error.name = "PreviewAutomationTabNotFoundError";  return error;}; export function PreviewAutomationOwner(props: {  readonly threadRef: ScopedThreadRef;  readonly visible: boolean;}) {  const { threadRef, visible } = props;  const automationClientId = useId();  const initialAutomationOwner = useMemo<PreviewAutomationOwnerState>(    () => ({      clientId: automationClientId,      environmentId: threadRef.environmentId,      threadId: threadRef.threadId,      tabId: null,      visible: false,      supportsAutomation: Boolean(previewBridge?.automation),      focusedAt: new Date().toISOString(),    }),    [automationClientId, threadRef.environmentId, threadRef.threadId],  );  const automationRequestsAtom = previewEnvironment.automationRequests({    environmentId: threadRef.environmentId,    input: initialAutomationOwner,  });  const connectionState = useEnvironmentConnectionState(threadRef.environmentId).data;  const connectedGeneration =    connectionState?.phase === "connected" ? connectionState.generation : null;  const open = useAtomCommand(previewEnvironment.open, {    reportFailure: false,  });  const respondToAutomation = useAtomCommand(    previewEnvironment.respondToAutomation,    "preview automation response",  );  const reportAutomationOwner = useAtomCommand(    previewEnvironment.reportAutomationOwner,    "preview automation owner report",  );  const clearAutomationOwner = useAtomCommand(    previewEnvironment.clearAutomationOwner,    "preview automation owner clear",  );  const connectedGenerationRef = useRef<number | null>(null);  const reportCurrentAutomationOwner = useEffectEvent(() => {    const state = readThreadPreviewState(threadRef);    return reportAutomationOwner({      environmentId: threadRef.environmentId,      input: {        clientId: automationClientId,        environmentId: threadRef.environmentId,        threadId: threadRef.threadId,        tabId: state.snapshot?.tabId ?? null,        visible,        supportsAutomation: Boolean(previewBridge?.automation),        focusedAt: new Date().toISOString(),      },    });  });  useEffect(() => {    void reportCurrentAutomationOwner();  }, [threadRef, visible]);   const handleRequest = useCallback(    async (request: PreviewAutomationRequest): Promise<unknown> => {      if (request.threadId !== threadRef.threadId) {        const error = new Error("Preview automation request targeted a stale thread owner.");        error.name = "PreviewAutomationUnavailableError";        throw error;      }      const state = readThreadPreviewState(threadRef);      const tabId = request.tabId ?? state.snapshot?.tabId ?? null;      switch (request.operation) {        case "status":          return currentStatus(threadRef, visible);        case "open": {          const input = request.input as PreviewAutomationOpenInput;          let activeTabId =            (input.reuseExistingTab ?? true) ? (state.snapshot?.tabId ?? null) : null;          if (!activeTabId) {            const result = await open({              environmentId: threadRef.environmentId,              input: {                threadId: threadRef.threadId,                ...(input.url ? { url: input.url } : {}),              },            });            if (result._tag === "Failure") {              throw squashAtomCommandFailure(result);            }            const snapshot = result.value;            applyPreviewServerSnapshot(threadRef, snapshot);            activeTabId = snapshot.tabId;          } else if (input.url && previewBridge) {            await previewBridge.navigate(activeTabId, input.url);          }          if (input.show ?? true) {            useRightPanelStore.getState().openBrowser(threadRef, activeTabId);          }          await waitForDesktopOverlay(threadRef, request.timeoutMs);          return currentStatus(threadRef, input.show ?? true);        }        case "navigate": {          if (!previewBridge || !tabId) throw previewTabNotFoundError();          const input = request.input as PreviewAutomationNavigateInput;          const resolution = resolveBrowserNavigationTarget(            threadRef.environmentId,            input.target ?? { kind: "url", url: input.url! },          );          await previewBridge.navigate(tabId, resolution.resolvedUrl);          await waitForNavigationReadiness(            tabId,            input.readiness ?? "load",            input.timeoutMs ?? request.timeoutMs,          );          return currentStatus(threadRef, visible);        }        case "snapshot":          if (!previewBridge || !tabId) throw previewTabNotFoundError();          return previewBridge.automation.snapshot(tabId);        case "click":          if (!previewBridge || !tabId) throw previewTabNotFoundError();          return previewBridge.automation.click(            tabId,            request.input as Parameters<typeof previewBridge.automation.click>[1],          );        case "type":          if (!previewBridge || !tabId) throw previewTabNotFoundError();          return previewBridge.automation.type(            tabId,            request.input as Parameters<typeof previewBridge.automation.type>[1],          );        case "press":          if (!previewBridge || !tabId) throw previewTabNotFoundError();          return previewBridge.automation.press(            tabId,            request.input as Parameters<typeof previewBridge.automation.press>[1],          );        case "scroll":          if (!previewBridge || !tabId) throw previewTabNotFoundError();          return previewBridge.automation.scroll(            tabId,            request.input as Parameters<typeof previewBridge.automation.scroll>[1],          );        case "evaluate":          if (!previewBridge || !tabId) throw previewTabNotFoundError();          return previewBridge.automation.evaluate(            tabId,            request.input as Parameters<typeof previewBridge.automation.evaluate>[1],          );        case "waitFor":          if (!previewBridge || !tabId) throw previewTabNotFoundError();          return previewBridge.automation.waitFor(            tabId,            request.input as Parameters<typeof previewBridge.automation.waitFor>[1],          );        case "recordingStart": {          if (!tabId) throw previewTabNotFoundError();          const startedAt = await startBrowserRecording(tabId);          return {            tabId,            recording: true,            startedAt,          };        }        case "recordingStop": {          if (!tabId) throw previewTabNotFoundError();          const artifact = await stopBrowserRecording(tabId);          if (!artifact) throw new Error("No active recording exists for this preview tab.");          return artifact;        }      }    },    [open, threadRef, visible],  );  const [requestHandler] = useState(() =>    createLatestPreviewAutomationRequestHandler(handleRequest),  );  useEffect(() => {    requestHandler.set(handleRequest);  }, [handleRequest, requestHandler]);   const automationRequestConsumerAtom = useMemo(    () =>      createPreviewAutomationRequestConsumerAtom({        requestsAtom: automationRequestsAtom,        handleRequest: requestHandler.handle,        respond: (response) =>          respondToAutomation({            environmentId: threadRef.environmentId,            input: response,          }),        label: `preview:automation-request-consumer:${automationClientId}`,      }),    [      automationClientId,      automationRequestsAtom,      requestHandler,      respondToAutomation,      threadRef.environmentId,    ],  );  useAtomValue(automationRequestConsumerAtom);   useEffect(() => {    const observation = observeAutomationOwnerConnectedGeneration(      connectedGenerationRef.current,      connectedGeneration,    );    connectedGenerationRef.current = observation.nextGeneration;    if (!observation.shouldReport) return;     void reportCurrentAutomationOwner();  }, [connectedGeneration]);   useEffect(() => {    const report = () => void reportCurrentAutomationOwner();    window.addEventListener("focus", report);    const unsubscribe = subscribeThreadPreviewState(threadRef, (state, previous) => {      if (state.snapshot?.tabId !== previous.snapshot?.tabId) {        report();      }    });    return () => {      window.removeEventListener("focus", report);      unsubscribe();      void clearAutomationOwner({        environmentId: threadRef.environmentId,        input: {          clientId: automationClientId,          environmentId: threadRef.environmentId,          threadId: threadRef.threadId,        },      });    };  }, [automationClientId, clearAutomationOwner, threadRef]);   return null;}