import {
  PREVIEW_AUTOMATION_V1_OPERATIONS,
  PreviewAutomationClientDisconnectedError,
  PreviewAutomationControlInterruptedError,
  PreviewAutomationControlReason,
  PreviewAutomationExecutionError,
  SERVER_BROWSER_AUTOMATION_CLIENT_ID,
  PreviewAutomationInvalidSelectorError,
  PreviewAutomationMalformedResponseError,
  PreviewAutomationNoAvailableHostError,
  PreviewAutomationRemoteUnavailableError,
  PreviewAutomationRecordingTransferError,
  PreviewAutomationRecordingDesktopUpdateRequiredError,
  PreviewAutomationRecordingTooLargeError,
  PreviewAutomationRecordingDeadlineExpiredError,
  PreviewAutomationRequestQueueClosedError,
  PreviewAutomationResultTooLargeError,
  PreviewAutomationTabNotFoundError,
  PreviewAutomationTargetNotEditableError,
  PreviewAutomationTimeoutError,
  PreviewAutomationUnsupportedClientError,
  PreviewTabId,
  type PreviewAutomationError,
  type PreviewAutomationOperation,
  type PreviewAutomationHost,
  type PreviewAutomationHostFocus,
  type PreviewAutomationResponse,
  type PreviewAutomationStreamEvent,
} from "@t3tools/contracts";
import * as Context from "effect/Context";
import type * as Cause from "effect/Cause";
import * as SecureRandom from "effect/crypto/SecureRandom";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Queue from "effect/Queue";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as SynchronizedRef from "effect/SynchronizedRef";

import * as McpInvocationContext from "./McpInvocationContext.ts";

const HOST_RESPONSE_GRACE_MS = 1_000;

export interface PreviewAutomationInvokeInput {
  readonly scope: McpInvocationContext.McpThreadInvocationScope;
  readonly operation: PreviewAutomationOperation;
  readonly input: unknown;
  readonly tabId?: PreviewTabId;
  readonly timeoutMs?: number;
  /** Background metadata reads must not change the agent's current tab. */
  readonly updateCurrentTab?: boolean;
  readonly onTargetTab?: (tabId: PreviewTabId | undefined) => void;
}

export interface PreviewAutomationConnectOptions {
  readonly preferred?: boolean;
}

export class PreviewAutomationBroker extends Context.Service<
  PreviewAutomationBroker,
  {
    readonly connect: (
      host: PreviewAutomationHost,
      options?: PreviewAutomationConnectOptions,
    ) => Effect.Effect<Stream.Stream<PreviewAutomationStreamEvent>>;
    readonly focusHost: (host: PreviewAutomationHostFocus) => Effect.Effect<void>;
    readonly respond: (
      response: PreviewAutomationResponse,
    ) => Effect.Effect<void, PreviewAutomationError>;
    readonly invoke: <A = unknown>(
      request: PreviewAutomationInvokeInput,
    ) => Effect.Effect<A, PreviewAutomationError>;
  }
>()("t3/mcp/PreviewAutomationBroker") {}

interface ClientConnection {
  readonly clientId: string;
  readonly connectionId: string;
  readonly environmentId: PreviewAutomationHost["environmentId"];
  readonly supportedOperations: ReadonlySet<PreviewAutomationOperation>;
  readonly focused: boolean;
  readonly preferred: boolean;
  readonly liveTabs: NonNullable<PreviewAutomationHostFocus["liveTabs"]>;
  readonly focusOrder: number;
  readonly queue: Queue.Queue<PreviewAutomationStreamEvent, Cause.Done>;
}

interface PendingRequest {
  readonly queue: ClientConnection["queue"];
  readonly deferred: Deferred.Deferred<unknown, PreviewAutomationError>;
  readonly context: PreviewAutomationRequestErrorContext;
}

/** A lease belongs to this exact connectionId/queue; replacing the host invalidates it. */
interface HostAssignment {
  readonly clientId: ClientConnection["clientId"];
  readonly connectionId: ClientConnection["connectionId"];
  readonly queue: ClientConnection["queue"];
  readonly tabId?: PreviewTabId;
  readonly tabSequence?: number;
}

interface PreviewAutomationRequestErrorContext {
  readonly operation: PreviewAutomationOperation;
  readonly environmentId: McpInvocationContext.McpInvocationScope["environmentId"];
  readonly threadId: McpInvocationContext.McpThreadCaller["threadId"];
  readonly providerSessionId: string;
  readonly providerInstanceId: McpInvocationContext.McpThreadCaller["providerInstanceId"];
  readonly clientId: string;
  readonly connectionId: ClientConnection["connectionId"];
  readonly requestId: string;
  readonly tabId?: PreviewTabId;
  readonly timeoutMs: number;
  readonly selectorKind?: "locator" | "selector";
  readonly selectorLength?: number;
}

interface BrokerState {
  readonly clients: ReadonlyMap<string, ClientConnection>;
  readonly assignments: ReadonlyMap<string, HostAssignment>;
  readonly pending: ReadonlyMap<string, PendingRequest>;
  readonly requestSequence: number;
  readonly focusSequence: number;
}

const removeConnectionFromState = (
  current: BrokerState,
  clientId: string,
  queue: ClientConnection["queue"],
): { readonly state: BrokerState; readonly disconnected: ReadonlyArray<PendingRequest> } => {
  const clients = new Map(current.clients);
  const assignments = new Map(current.assignments);
  const pending = new Map(current.pending);
  const disconnected: PendingRequest[] = [];
  if (current.clients.get(clientId)?.queue === queue) clients.delete(clientId);
  for (const [assignmentKey, assignment] of assignments) {
    if (assignment.queue === queue) assignments.delete(assignmentKey);
  }
  for (const [requestId, entry] of pending) {
    if (entry.queue !== queue) continue;
    pending.delete(requestId);
    disconnected.push(entry);
  }
  return {
    state: { ...current, clients, assignments, pending },
    disconnected,
  };
};

const selectorDiagnosticsFromInput = (
  input: unknown,
): Pick<PreviewAutomationRequestErrorContext, "selectorKind" | "selectorLength"> => {
  if (typeof input !== "object" || input === null) return {};
  if ("locator" in input && typeof input.locator === "string") {
    return { selectorKind: "locator", selectorLength: input.locator.length };
  }
  if ("selector" in input && typeof input.selector === "string") {
    return { selectorKind: "selector", selectorLength: input.selector.length };
  }
  return {};
};

/** Codex/OpenCode share sessions across threads; include thread id to isolate tabs and ownership. */
const hostAssignmentKey = (scope: McpInvocationContext.McpThreadInvocationScope): string =>
  `${scope.environmentId}\u0000${scope.thread.providerSessionId}\u0000${scope.thread.threadId}`;

const isPreviewTabId = Schema.is(PreviewTabId);
const decodeControlReason = Schema.decodeUnknownOption(PreviewAutomationControlReason);

const readResultTabId = (result: unknown): PreviewTabId | null | undefined => {
  if (typeof result !== "object" || result === null || !("tabId" in result)) return undefined;
  const tabId = result.tabId;
  return tabId === null || isPreviewTabId(tabId) ? tabId : undefined;
};

const supportsOperation = (
  connection: ClientConnection,
  operation: PreviewAutomationOperation,
): boolean => connection.supportedOperations.has(operation);

type RemoteDetailKind = "null" | "array" | "object" | "string" | "number" | "boolean";

function remoteDetailKind(detail: unknown): RemoteDetailKind {
  if (detail === null) return "null";
  if (Array.isArray(detail)) return "array";
  switch (typeof detail) {
    case "string":
      return "string";
    case "number":
      return "number";
    case "boolean":
      return "boolean";
    default:
      return "object";
  }
}

const readRemoteTimeoutMs = (detail: unknown): number | undefined => {
  if (typeof detail !== "object" || detail === null || !("timeoutMs" in detail)) return undefined;
  const timeoutMs = detail.timeoutMs;
  return typeof timeoutMs === "number" && Number.isInteger(timeoutMs) && timeoutMs > 0
    ? timeoutMs
    : undefined;
};

const readRemoteReason = (detail: unknown): string | undefined =>
  typeof detail === "object" &&
  detail !== null &&
  "reason" in detail &&
  typeof detail.reason === "string"
    ? detail.reason
    : undefined;

const MAX_REASON_CHARS = 500;

const classifyResponseError = (
  context: PreviewAutomationRequestErrorContext,
  error: NonNullable<PreviewAutomationResponse["error"]>,
): PreviewAutomationError => {
  const remoteDiagnostics = {
    remoteTag: error._tag,
    remoteMessageLength: error.message.length,
    ...(error.detail === undefined ? {} : { remoteDetailKind: remoteDetailKind(error.detail) }),
    cause: error,
  };
  switch (error._tag) {
    case "PreviewAutomationRecordingDesktopUpdateRequiredError":
      return new PreviewAutomationRecordingDesktopUpdateRequiredError({
        threadId: context.threadId,
        cause: error,
      });
    case "PreviewAutomationRecordingTooLargeError":
      return new PreviewAutomationRecordingTooLargeError({
        threadId: context.threadId,
        cause: error,
      });
    case "PreviewAutomationRecordingDeadlineExpiredError":
      return new PreviewAutomationRecordingDeadlineExpiredError({
        threadId: context.threadId,
        cause: error,
      });
    case "PreviewAutomationRecordingTransferError":
      return new PreviewAutomationRecordingTransferError({
        threadId: context.threadId,
        cause: error,
      });
    case "PreviewAutomationNoAvailableHostError":
      return new PreviewAutomationNoAvailableHostError({
        ...context,
        ...remoteDiagnostics,
      });
    case "PreviewAutomationUnsupportedClientError":
      return new PreviewAutomationUnsupportedClientError({
        ...context,
        ...remoteDiagnostics,
      });
    case "PreviewAutomationTabNotFoundError":
      return new PreviewAutomationTabNotFoundError({
        ...context,
        ...remoteDiagnostics,
      });
    case "PreviewAutomationTimeoutError": {
      const remoteTimeoutMs = readRemoteTimeoutMs(error.detail);
      const remoteReason = readRemoteReason(error.detail);
      return new PreviewAutomationTimeoutError({
        ...context,
        ...remoteDiagnostics,
        ...(context.clientId === SERVER_BROWSER_AUTOMATION_CLIENT_ID && remoteReason !== undefined
          ? { reason: remoteReason.slice(0, MAX_REASON_CHARS) }
          : {}),
        ...(remoteTimeoutMs === undefined
          ? {}
          : { timeoutMs: Math.min(context.timeoutMs, remoteTimeoutMs) }),
      });
    }
    case "PreviewAutomationControlInterruptedError": {
      const reason = decodeControlReason(error.detail);
      return new PreviewAutomationControlInterruptedError({
        ...context,
        ...remoteDiagnostics,
        ...(Option.isSome(reason) ? { reason: reason.value } : {}),
      });
    }
    case "PreviewAutomationInvalidSelectorError": {
      const staleRef =
        typeof error.detail === "object" &&
        error.detail !== null &&
        "staleRef" in error.detail &&
        error.detail.staleRef === true;
      return new PreviewAutomationInvalidSelectorError({
        ...context,
        ...remoteDiagnostics,
        ...(staleRef ? { staleRef } : {}),
      });
    }
    case "PreviewAutomationTargetNotEditableError": {
      const detail =
        typeof error.detail === "object" && error.detail !== null ? error.detail : undefined;
      const remoteSelectorKind =
        detail &&
        "selectorKind" in detail &&
        (detail.selectorKind === "focused-element" ||
          detail.selectorKind === "locator" ||
          detail.selectorKind === "selector")
          ? detail.selectorKind
          : undefined;
      const remoteSelectorLength =
        detail &&
        "selectorLength" in detail &&
        typeof detail.selectorLength === "number" &&
        Number.isInteger(detail.selectorLength) &&
        detail.selectorLength >= 0
          ? detail.selectorLength
          : undefined;
      return new PreviewAutomationTargetNotEditableError({
        ...context,
        ...remoteDiagnostics,
        ...(remoteSelectorKind === undefined && context.selectorKind === undefined
          ? {}
          : { selectorKind: remoteSelectorKind ?? context.selectorKind }),
        ...(remoteSelectorLength === undefined && context.selectorLength === undefined
          ? {}
          : { selectorLength: remoteSelectorLength ?? context.selectorLength }),
      });
    }
    case "PreviewAutomationResultTooLargeError": {
      const detail =
        typeof error.detail === "object" && error.detail !== null ? error.detail : undefined;
      const maximumBytes =
        detail &&
        "maximumBytes" in detail &&
        typeof detail.maximumBytes === "number" &&
        Number.isInteger(detail.maximumBytes) &&
        detail.maximumBytes > 0
          ? detail.maximumBytes
          : undefined;
      return new PreviewAutomationResultTooLargeError({
        ...context,
        ...remoteDiagnostics,
        ...(maximumBytes === undefined ? {} : { maximumBytes }),
      });
    }
    case "PreviewAutomationUnavailableError":
      return new PreviewAutomationRemoteUnavailableError({
        ...context,
        ...remoteDiagnostics,
      });
    default:
      return new PreviewAutomationExecutionError({
        ...context,
        ...remoteDiagnostics,
        ...(context.clientId === SERVER_BROWSER_AUTOMATION_CLIENT_ID
          ? { reason: error.message.slice(0, MAX_REASON_CHARS) }
          : {}),
      });
  }
};

export const make = Effect.gen(function* PreviewAutomationBrokerMake() {
  const random = yield* SecureRandom.SecureRandom;
  const state = yield* SynchronizedRef.make<BrokerState>({
    clients: new Map(),
    assignments: new Map(),
    pending: new Map(),
    requestSequence: 0,
    focusSequence: 0,
  });

  const closeConnection = Effect.fn("PreviewAutomationBroker.closeConnection")(function* (
    queue: ClientConnection["queue"],
    disconnected: ReadonlyArray<PendingRequest>,
    completeStream = false,
  ) {
    if (completeStream) {
      // Close the evicted generation's RPC stream so a responsive desktop can re-register.
      yield* Queue.clear(queue);
      yield* Queue.end(queue);
    } else {
      // Replaced registrations must not reconnect and displace their successor.
      yield* Queue.shutdown(queue);
    }
    yield* Effect.forEach(
      disconnected,
      ({ deferred, context }) =>
        Deferred.fail(deferred, new PreviewAutomationClientDisconnectedError(context)),
      { discard: true },
    );
  });

  const disconnect = Effect.fn("PreviewAutomationBroker.disconnect")(function* (
    clientId: string,
    queue: ClientConnection["queue"],
    completeStream = false,
  ) {
    yield* SynchronizedRef.modifyEffect(state, (current) => {
      if (current.clients.get(clientId)?.queue !== queue) {
        return Effect.succeed([undefined, current] as const);
      }
      const removed = removeConnectionFromState(current, clientId, queue);
      return closeConnection(queue, removed.disconnected, completeStream).pipe(
        Effect.as([undefined, removed.state] as const),
      );
    });
  });

  const acquireConnection = Effect.fn("PreviewAutomationBroker.acquireConnection")(function* (
    host: PreviewAutomationHost,
    options: PreviewAutomationConnectOptions | undefined,
  ) {
    const clientId = host.clientId;
    const queue = yield* Queue.unbounded<PreviewAutomationStreamEvent, Cause.Done>();
    const connectionId = yield* random.uuidV4();
    yield* Queue.offer(queue, { type: "connected", connectionId });
    const connection: ClientConnection = {
      clientId,
      connectionId,
      environmentId: host.environmentId,
      supportedOperations: new Set(host.supportedOperations ?? PREVIEW_AUTOMATION_V1_OPERATIONS),
      focused: false,
      preferred: options?.preferred ?? false,
      liveTabs: [],
      focusOrder: 0,
      queue,
    };
    const registration = yield* SynchronizedRef.modify(state, (current) => {
      const previousConnection = current.clients.get(clientId);
      const removed = previousConnection
        ? removeConnectionFromState(current, clientId, previousConnection.queue)
        : { state: current, disconnected: [] };
      const clients = new Map(removed.state.clients);
      const focusSequence = removed.state.focusSequence + 1;
      const registeredConnection = { ...connection, focusOrder: focusSequence };
      clients.set(clientId, registeredConnection);
      return [
        {
          previousConnection,
          disconnected: removed.disconnected,
          registeredConnection,
        },
        { ...removed.state, clients, focusSequence },
      ] as const;
    });
    if (registration.previousConnection) {
      yield* closeConnection(registration.previousConnection.queue, registration.disconnected);
    }
    return registration.registeredConnection;
  });

  const connect: PreviewAutomationBroker["Service"]["connect"] = Effect.fn(
    "PreviewAutomationBroker.connect",
  )((host, options) =>
    Effect.succeed(
      Stream.unwrap(
        Effect.acquireRelease(acquireConnection(host, options), (connection) =>
          disconnect(connection.clientId, connection.queue),
        ).pipe(Effect.map((connection) => Stream.fromQueue(connection.queue))),
      ),
    ),
  );

  const focusHost: PreviewAutomationBroker["Service"]["focusHost"] = Effect.fn(
    "PreviewAutomationBroker.focusHost",
  )(function* (host) {
    yield* SynchronizedRef.update(state, (current) => {
      const currentHost = current.clients.get(host.clientId);
      if (
        !currentHost ||
        currentHost.environmentId !== host.environmentId ||
        currentHost.connectionId !== host.connectionId
      ) {
        return current;
      }
      const clients = new Map(current.clients);
      const focusSequence = host.focused ? current.focusSequence + 1 : current.focusSequence;
      clients.set(host.clientId, {
        ...currentHost,
        focused: host.focused,
        liveTabs: host.liveTabs ?? currentHost.liveTabs,
        focusOrder: host.focused ? focusSequence : currentHost.focusOrder,
      });
      return { ...current, clients, focusSequence };
    });
  });

  const respond: PreviewAutomationBroker["Service"]["respond"] = Effect.fn(
    "PreviewAutomationBroker.respond",
  )(function* (response) {
    const pending = yield* SynchronizedRef.modify(state, (current) => {
      const entry = current.pending.get(response.requestId);
      if (
        !entry ||
        entry.context.clientId !== response.clientId ||
        entry.context.connectionId !== response.connectionId
      ) {
        return [undefined, current] as const;
      }
      const next = new Map(current.pending);
      next.delete(response.requestId);
      return [entry, { ...current, pending: next }] as const;
    });
    if (!pending) return;
    if (response.ok) {
      yield* Deferred.succeed(pending.deferred, response.result);
    } else {
      yield* Deferred.fail(
        pending.deferred,
        response.error
          ? classifyResponseError(pending.context, response.error)
          : new PreviewAutomationMalformedResponseError(pending.context),
      );
    }
  });

  const invoke = Effect.fn("PreviewAutomationBroker.invoke")(function* <A = unknown>(
    input: Parameters<PreviewAutomationBroker["Service"]["invoke"]>[0],
  ): Effect.fn.Return<A, PreviewAutomationError> {
    const deferred = yield* Deferred.make<unknown, PreviewAutomationError>();
    const route = yield* SynchronizedRef.modify(state, (current) => {
      const assignments = new Map(
        Array.from(current.assignments).filter(([, assignment]) => {
          const connection = current.clients.get(assignment.clientId);
          return (
            connection?.connectionId === assignment.connectionId &&
            connection.queue === assignment.queue
          );
        }),
      );
      const assignmentKey = hostAssignmentKey(input.scope);
      const assigned = assignments.get(assignmentKey);
      const assignedConnection = assigned ? current.clients.get(assigned.clientId) : undefined;
      const hasLiveAssignment = assignedConnection?.environmentId === input.scope.environmentId;
      // Pin interactions to one desktop runtime so cookie/DOM state cannot jump between hosts.
      const ownsTargetTab = (host: ClientConnection, visibleOnly = false) =>
        host.liveTabs.some(
          (tab) =>
            tab.threadId === input.scope.thread.threadId &&
            (!visibleOnly || tab.visible === true) &&
            (input.tabId === undefined || tab.tabId === input.tabId),
        );
      const connection =
        hasLiveAssignment && supportsOperation(assignedConnection, input.operation)
          ? assignedConnection
          : hasLiveAssignment
            ? undefined
            : Array.from(current.clients.values())
                .filter(
                  (host) =>
                    host.environmentId === input.scope.environmentId &&
                    supportsOperation(host, input.operation),
                )
                .sort(
                  (left, right) =>
                    Number(input.tabId !== undefined && ownsTargetTab(right)) -
                      Number(input.tabId !== undefined && ownsTargetTab(left)) ||
                    Number(right.preferred) - Number(left.preferred) ||
                    Number(ownsTargetTab(right, true)) - Number(ownsTargetTab(left, true)) ||
                    Number(ownsTargetTab(right)) - Number(ownsTargetTab(left)) ||
                    Number(right.focused) - Number(left.focused) ||
                    right.focusOrder - left.focusOrder,
                )[0];
      if (!connection) {
        if (!hasLiveAssignment) assignments.delete(assignmentKey);
        return [undefined, { ...current, assignments }] as const;
      }
      // First open may install Chromium for ten minutes; keep it alive without replaying effects.
      const timeoutMs =
        input.timeoutMs ?? (input.operation === "open" && connection.preferred ? 660_000 : 15_000);
      const canReuseAssignedTab =
        assigned !== undefined &&
        assigned.connectionId === connection.connectionId &&
        assigned.queue === connection.queue;
      assignments.set(assignmentKey, {
        clientId: connection.clientId,
        connectionId: connection.connectionId,
        queue: connection.queue,
        ...(canReuseAssignedTab && assigned.tabId !== undefined ? { tabId: assigned.tabId } : {}),
        ...(canReuseAssignedTab && assigned.tabSequence !== undefined
          ? { tabSequence: assigned.tabSequence }
          : {}),
      });

      const requestSequence = current.requestSequence;
      const requestId = `preview-${requestSequence}`;
      const tabId = input.tabId ?? (canReuseAssignedTab ? assigned.tabId : undefined);
      const selectorDiagnostics = selectorDiagnosticsFromInput(input.input);
      const context: PreviewAutomationRequestErrorContext = {
        operation: input.operation,
        environmentId: input.scope.environmentId,
        threadId: input.scope.thread.threadId,
        providerSessionId: input.scope.thread.providerSessionId,
        providerInstanceId: input.scope.thread.providerInstanceId,
        clientId: connection.clientId,
        connectionId: connection.connectionId,
        requestId,
        ...(tabId === undefined ? {} : { tabId }),
        timeoutMs,
        ...selectorDiagnostics,
      };
      const pending = new Map(current.pending);
      pending.set(requestId, { queue: connection.queue, deferred, context });
      return [
        { connection, requestId, requestContext: context, requestSequence },
        { ...current, assignments, pending, requestSequence: current.requestSequence + 1 },
      ] as const;
    });
    if (!route) {
      return yield* new PreviewAutomationNoAvailableHostError({
        operation: input.operation,
        environmentId: input.scope.environmentId,
        threadId: input.scope.thread.threadId,
        providerSessionId: input.scope.thread.providerSessionId,
        providerInstanceId: input.scope.thread.providerInstanceId,
      });
    }
    const { connection, requestId, requestContext, requestSequence } = route;
    const { timeoutMs } = requestContext;
    input.onTargetTab?.(requestContext.tabId);
    const removePending = SynchronizedRef.update(state, (next) => {
      if (!next.pending.has(requestId)) return next;
      const pending = new Map(next.pending);
      pending.delete(requestId);
      return { ...next, pending };
    });
    const awaitResponse = Effect.fn("PreviewAutomationBroker.awaitResponse")(function* () {
      const offered = yield* SynchronizedRef.modifyEffect(state, (current) => {
        // Serialize generation checks and offers with queue closure; routes can outlive eviction.
        if (
          current.clients.get(connection.clientId)?.queue !== connection.queue ||
          !current.pending.has(requestId)
        ) {
          return Effect.succeed([false, current] as const);
        }
        return Queue.offer(connection.queue, {
          type: "request",
          connectionId: connection.connectionId,
          request: {
            requestId,
            threadId: input.scope.thread.threadId,
            tabId: requestContext.tabId,
            tabIdExplicit: input.tabId !== undefined,
            agentSessionId: hostAssignmentKey(input.scope),
            operation: input.operation,
            input: input.input,
            timeoutMs,
          },
        }).pipe(Effect.map((offered) => [offered, current] as const));
      });
      if (!offered) {
        const completion = yield* Deferred.poll(deferred);
        if (Option.isSome(completion)) {
          return (yield* completion.value) as A;
        }
        return yield* new PreviewAutomationRequestQueueClosedError(requestContext);
      }
      // The browser timer starts on delivery; allow its timeout response before evicting the host.
      const responseTimeoutMs =
        input.updateCurrentTab === false ? timeoutMs : timeoutMs + HOST_RESPONSE_GRACE_MS;
      const result = yield* Deferred.await(deferred).pipe(Effect.timeoutOption(responseTimeoutMs));
      return yield* Option.match(result, {
        // The enclosing operation owns the span for this inline handler.
        onNone: Effect.fnUntraced(function* () {
          // Never replay possibly applied actions; slow metadata reads must not evict the host.
          if (input.updateCurrentTab !== false) {
            yield* disconnect(connection.clientId, connection.queue, true);
          }
          return yield* new PreviewAutomationTimeoutError(requestContext);
        }),
        onSome: (value) => Effect.succeed(value as A),
      });
    });
    const result = yield* awaitResponse().pipe(Effect.ensuring(removePending));
    if (input.updateCurrentTab === false) return result;
    const responseTabId = readResultTabId(result);
    const resultTabId = responseTabId === undefined ? input.tabId : responseTabId;
    if (resultTabId === undefined) return result;
    const assignmentKey = hostAssignmentKey(input.scope);
    yield* SynchronizedRef.update(state, (current) => {
      const assignment = current.assignments.get(assignmentKey);
      if (
        !assignment ||
        assignment.connectionId !== connection.connectionId ||
        assignment.queue !== connection.queue ||
        (assignment.tabSequence ?? -1) > requestSequence
      ) {
        return current;
      }
      const assignments = new Map(current.assignments);
      if (resultTabId === null) {
        const { tabId: _tabId, ...withoutTabId } = assignment;
        assignments.set(assignmentKey, { ...withoutTabId, tabSequence: requestSequence });
      } else {
        assignments.set(assignmentKey, {
          ...assignment,
          ...(resultTabId === undefined ? {} : { tabId: resultTabId }),
          tabSequence: requestSequence,
        });
      }
      return { ...current, assignments };
    });
    return result;
  });

  return PreviewAutomationBroker.of({ connect, focusHost, respond, invoke });
}).pipe(Effect.withSpan("PreviewAutomationBroker.make"));

export const layer = Layer.effect(PreviewAutomationBroker, make);