import type {  AssetCreateUrlResult,  AssetResource,  EnvironmentId,  PreviewOpenInput,  PreviewSessionSnapshot,  ScopedThreadRef,} from "@t3tools/contracts";import { scopedThreadKey } from "@t3tools/client-runtime/environment";import {  type AtomCommandResult,  mapAtomCommandResult,} from "@t3tools/client-runtime/state/runtime";import {  isWorkspaceBrowserPreviewPath,  isWorkspaceImagePreviewPath,  isWorkspacePreviewEntryPath,} from "@t3tools/shared/filePreview";import * as Cause from "effect/Cause";import * as Schema from "effect/Schema";import { AsyncResult } from "effect/unstable/reactivity"; import {  applyPreviewServerSnapshot,  isPreviewSupportedInRuntime,  rememberPreviewUrl,} from "~/previewStateStore";import { useRightPanelStore } from "~/rightPanelStore"; export const isBrowserPreviewFile = isWorkspaceBrowserPreviewPath;export const isImagePreviewFile = isWorkspaceImagePreviewPath;export const isWorkspacePreviewFile = isWorkspacePreviewEntryPath; export class BrowserPreviewUnavailableError extends Schema.TaggedErrorClass<BrowserPreviewUnavailableError>()(  "BrowserPreviewUnavailableError",  {},) {  override get message(): string {    return "The integrated browser is unavailable in this runtime.";  }} export class BrowserPreviewThreadContextUnavailableError extends Schema.TaggedErrorClass<BrowserPreviewThreadContextUnavailableError>()(  "BrowserPreviewThreadContextUnavailableError",  {},) {  override get message(): string {    return "Thread context is unavailable.";  }} export class BrowserPreviewEnvironmentDisconnectedError extends Schema.TaggedErrorClass<BrowserPreviewEnvironmentDisconnectedError>()(  "BrowserPreviewEnvironmentDisconnectedError",  {    environmentId: Schema.String,    threadId: Schema.String,  },) {  override get message(): string {    return "Environment is not connected.";  }} export class BrowserPreviewAssetUrlInvalidError extends Schema.TaggedErrorClass<BrowserPreviewAssetUrlInvalidError>()(  "BrowserPreviewAssetUrlInvalidError",  {    environmentId: Schema.String,    threadId: Schema.String,    filePath: Schema.String,    httpBaseUrlLength: Schema.Int,    relativeUrlLength: Schema.Int,    expiresAt: Schema.Int,    cause: Schema.Defect(),  },) {  override get message(): string {    return "The environment returned an invalid asset URL.";  }} export const isBrowserPreviewAssetUrlInvalidError = Schema.is(BrowserPreviewAssetUrlInvalidError); export type OpenPreviewMutation<E = unknown> = (input: {  readonly environmentId: EnvironmentId;  readonly input: PreviewOpenInput;}) => Promise<AtomCommandResult<PreviewSessionSnapshot, E>>; interface PreviewRequest {  readonly isCurrent: () => boolean;  readonly complete: () => void;} const activePreviewRequestByThread = new Map<string, symbol>(); const beginPreviewRequest = (  threadRef: ScopedThreadRef,  signal: AbortSignal | undefined,): PreviewRequest => {  const threadKey = scopedThreadKey(threadRef);  const requestId = Symbol();  activePreviewRequestByThread.set(threadKey, requestId);  return {    isCurrent: () =>      activePreviewRequestByThread.get(threadKey) === requestId && signal?.aborted !== true,    complete: () => {      if (activePreviewRequestByThread.get(threadKey) === requestId) {        activePreviewRequestByThread.delete(threadKey);      }    },  };}; const openUrlForPreviewRequest = async <E>(  input: {    readonly threadRef: ScopedThreadRef;    readonly url: string;    readonly openPreview: OpenPreviewMutation<E>;  },  request: PreviewRequest,): Promise<AtomCommandResult<void, E>> => {  const result = await input.openPreview({    environmentId: input.threadRef.environmentId,    input: { threadId: input.threadRef.threadId, url: input.url },  });  if (!request.isCurrent()) {    return AsyncResult.success(undefined);  }  return mapAtomCommandResult(result, (snapshot) => {    applyPreviewServerSnapshot(input.threadRef, snapshot);    rememberPreviewUrl(input.threadRef, input.url);    useRightPanelStore.getState().openBrowser(input.threadRef, snapshot.tabId);  });}; export async function openUrlInPreview<E>(input: {  readonly threadRef: ScopedThreadRef;  readonly url: string;  readonly openPreview: OpenPreviewMutation<E>;  readonly signal?: AbortSignal;}): Promise<AtomCommandResult<void, E>> {  const request = beginPreviewRequest(input.threadRef, input.signal);  try {    return await openUrlForPreviewRequest(input, request);  } finally {    request.complete();  }} export async function openFileInPreview<AssetError, PreviewError>(input: {  readonly threadRef: ScopedThreadRef;  readonly filePath: string;  readonly httpBaseUrl: string;  readonly createAssetUrl: (input: {    readonly environmentId: EnvironmentId;    readonly input: { readonly resource: AssetResource };  }) => Promise<AtomCommandResult<AssetCreateUrlResult, AssetError>>;  readonly openPreview: OpenPreviewMutation<PreviewError>;  readonly signal?: AbortSignal;}): Promise<  AtomCommandResult<    void,    AssetError | PreviewError | BrowserPreviewUnavailableError | BrowserPreviewAssetUrlInvalidError  >> {  const request = beginPreviewRequest(input.threadRef, input.signal);  try {    if (!isPreviewSupportedInRuntime()) {      return AsyncResult.failure(Cause.fail(new BrowserPreviewUnavailableError()));    }    const assetResult = await input.createAssetUrl({      environmentId: input.threadRef.environmentId,      input: {        resource: {          _tag: "workspace-file",          threadId: input.threadRef.threadId,          path: input.filePath,        },      },    });    if (!request.isCurrent()) {      return AsyncResult.success(undefined);    }    if (assetResult._tag === "Failure") {      return AsyncResult.failure(assetResult.cause);    }    let assetUrl: string;    try {      assetUrl = new URL(assetResult.value.relativeUrl, input.httpBaseUrl).toString();    } catch (cause) {      return AsyncResult.failure(        Cause.fail(          new BrowserPreviewAssetUrlInvalidError({            environmentId: input.threadRef.environmentId,            threadId: input.threadRef.threadId,            filePath: input.filePath,            httpBaseUrlLength: input.httpBaseUrl.length,            relativeUrlLength: assetResult.value.relativeUrl.length,            expiresAt: assetResult.value.expiresAt,            cause,          }),        ),      );    }    return await openUrlForPreviewRequest(      {        threadRef: input.threadRef,        url: assetUrl,        openPreview: input.openPreview,      },      request,    );  } finally {    request.complete();  }}