agl 23.0.0 → 24.0.0

package/ts_web/classes.browserviewtransport.ts

@@ -0,0 +1,532 @@
+import * as plugins from './plugins.js';
+import * as interfaces from '../ts_interfaces/index.js';
+
+const browserOperationTimeoutMs = 35_000;
+const browserTransportStopTimeoutMs = 1_000;
+const textEncoder = new TextEncoder();
+
+interface IPendingBrowserOperation {
+  resolve(resultArg: interfaces.TControllerBrowserOperationResult): void;
+  reject(reasonArg: unknown): void;
+  abortSignal?: AbortSignal;
+  abortListener?: () => void;
+  timeout: ReturnType<typeof setTimeout>;
+}
+
+export interface IControllerBrowserViewTransportClientOptions {
+  streamGeneration: number;
+  events: plugins.typedrequestInterfaces.TVirtualStream<'receive'>;
+  operations: plugins.typedrequestInterfaces.TVirtualStream<'send'>;
+  onEvent(eventArg: interfaces.TControllerBrowserViewEvent): void;
+  onFailure(errorArg: unknown, recoverableArg: boolean): void;
+}
+
+export class ControllerBrowserOperationError extends Error {
+  constructor(
+    public readonly code: string,
+    messageArg: string,
+  ) {
+    super(messageArg);
+    this.name = 'ControllerBrowserOperationError';
+  }
+}
+
+type TObject = Record<string, unknown>;
+
+const assertObject = (valueArg: unknown, nameArg: string): TObject => {
+  if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg)) {
+    throw new interfaces.ControllerBrowserTransportProtocolError(`${nameArg} must be an object.`);
+  }
+  const prototype = Object.getPrototypeOf(valueArg);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new interfaces.ControllerBrowserTransportProtocolError(`${nameArg} must be a plain object.`);
+  }
+  return valueArg as TObject;
+};
+
+const assertKeys = (
+  valueArg: TObject,
+  requiredArg: readonly string[],
+  optionalArg: readonly string[] = [],
+): void => {
+  const allowed = new Set([...requiredArg, ...optionalArg]);
+  if (
+    !requiredArg.every((keyArg) => Object.prototype.hasOwnProperty.call(valueArg, keyArg))
+    || Object.keys(valueArg).some((keyArg) => !allowed.has(keyArg))
+  ) throw new interfaces.ControllerBrowserTransportProtocolError('Browser packet keys are invalid.');
+};
+
+const assertBoundedString = (valueArg: unknown, nameArg: string, maximumBytesArg = 512): string => {
+  if (
+    typeof valueArg !== 'string'
+    || valueArg.length === 0
+    || textEncoder.encode(valueArg).byteLength > maximumBytesArg
+  ) throw new interfaces.ControllerBrowserTransportProtocolError(`${nameArg} is invalid.`);
+  return valueArg;
+};
+
+const assertSafeInteger = (valueArg: unknown, nameArg: string, minimumArg = 0): number => {
+  if (!Number.isSafeInteger(valueArg) || (valueArg as number) < minimumArg) {
+    throw new interfaces.ControllerBrowserTransportProtocolError(`${nameArg} is invalid.`);
+  }
+  return valueArg as number;
+};
+
+const assertFiniteNumber = (valueArg: unknown, nameArg: string): number => {
+  if (typeof valueArg !== 'number' || !Number.isFinite(valueArg)) {
+    throw new interfaces.ControllerBrowserTransportProtocolError(`${nameArg} is invalid.`);
+  }
+  return valueArg;
+};
+
+const assertBrowserViewport = (valueArg: unknown): interfaces.IControllerBrowserViewport => {
+  const value = assertObject(valueArg, 'frame.viewport');
+  assertKeys(value, ['width', 'height', 'deviceScaleFactor']);
+  const width = assertSafeInteger(value.width, 'viewport.width', 1);
+  const height = assertSafeInteger(value.height, 'viewport.height', 1);
+  const deviceScaleFactor = assertFiniteNumber(value.deviceScaleFactor, 'viewport.deviceScaleFactor');
+  if (
+    width > 4096
+    || height > 4096
+    || deviceScaleFactor < 0.25
+    || deviceScaleFactor > 3
+    || Math.ceil(width * deviceScaleFactor) * Math.ceil(height * deviceScaleFactor) > 8_294_400
+  ) throw new interfaces.ControllerBrowserTransportProtocolError('frame.viewport is out of bounds.');
+  return { width, height, deviceScaleFactor };
+};
+
+const assertBrowserError = (
+  valueArg: unknown,
+  fatalRequiredArg = true,
+): { code: string; message: string; fatal: boolean; tabId?: string } => {
+  const value = assertObject(valueArg, 'browser error');
+  assertKeys(value, fatalRequiredArg ? ['code', 'message', 'fatal'] : ['code', 'message'], ['tabId']);
+  if (fatalRequiredArg && typeof value.fatal !== 'boolean') {
+    throw new interfaces.ControllerBrowserTransportProtocolError('browser error fatal flag is invalid.');
+  }
+  const tabId = value.tabId === undefined
+    ? undefined
+    : assertBoundedString(value.tabId, 'browser error tabId');
+  return {
+    code: assertBoundedString(value.code, 'browser error code', 128),
+    message: assertBoundedString(value.message, 'browser error message', 512),
+    fatal: fatalRequiredArg ? value.fatal as boolean : false,
+    ...(tabId === undefined ? {} : { tabId }),
+  };
+};
+
+const assertBrowserState = (valueArg: unknown): interfaces.IControllerBrowserViewState => {
+  const value = assertObject(valueArg, 'browser state');
+  assertKeys(
+    value,
+    ['revision', 'status', 'activeTabId', 'viewportRevision', 'viewport', 'tabs'],
+    ['lastError'],
+  );
+  if (!['stopped', 'starting', 'running', 'stopping'].includes(String(value.status))) {
+    throw new interfaces.ControllerBrowserTransportProtocolError('browser state status is invalid.');
+  }
+  if (value.activeTabId !== null && typeof value.activeTabId !== 'string') {
+    throw new interfaces.ControllerBrowserTransportProtocolError('browser state activeTabId is invalid.');
+  }
+  if (!Array.isArray(value.tabs) || value.tabs.length > 64) {
+    throw new interfaces.ControllerBrowserTransportProtocolError('browser state tabs are invalid.');
+  }
+  const tabs = value.tabs.map((tabArg): interfaces.IControllerBrowserTabState => {
+    const tab = assertObject(tabArg, 'browser tab');
+    assertKeys(tab, [
+      'id', 'url', 'title', 'active', 'status', 'generation', 'appliedViewportRevision', 'streaming',
+    ]);
+    if (
+      typeof tab.active !== 'boolean'
+      || typeof tab.streaming !== 'boolean'
+      || !['open', 'crashed'].includes(String(tab.status))
+    ) throw new interfaces.ControllerBrowserTransportProtocolError('browser tab state is invalid.');
+    return {
+      id: assertBoundedString(tab.id, 'browser tab id'),
+      url: typeof tab.url === 'string' && textEncoder.encode(tab.url).byteLength <= 16 * 1024
+        ? tab.url
+        : (() => { throw new interfaces.ControllerBrowserTransportProtocolError('browser tab URL is invalid.'); })(),
+      title: typeof tab.title === 'string' && textEncoder.encode(tab.title).byteLength <= 4 * 1024
+        ? tab.title
+        : (() => { throw new interfaces.ControllerBrowserTransportProtocolError('browser tab title is invalid.'); })(),
+      active: tab.active,
+      status: tab.status as 'open' | 'crashed',
+      generation: assertSafeInteger(tab.generation, 'browser tab generation'),
+      appliedViewportRevision: assertSafeInteger(
+        tab.appliedViewportRevision,
+        'browser tab viewport revision',
+      ),
+      streaming: tab.streaming,
+    };
+  });
+  const lastError = value.lastError === undefined
+    ? undefined
+    : assertBrowserError(value.lastError);
+  return {
+    revision: assertSafeInteger(value.revision, 'browser state revision', 1),
+    status: value.status as interfaces.IControllerBrowserViewState['status'],
+    activeTabId: value.activeTabId as string | null,
+    viewportRevision: assertSafeInteger(value.viewportRevision, 'browser state viewport revision'),
+    viewport: assertBrowserViewport(value.viewport),
+    tabs,
+    ...(lastError === undefined ? {} : { lastError }),
+  };
+};
+
+const assertBrowserFrameMetadata = (
+  valueArg: unknown,
+): interfaces.IControllerBrowserFrameMetadata => {
+  const value = assertObject(valueArg, 'browser frame');
+  assertKeys(value, [
+    'tabId', 'sequence', 'generation', 'viewportRevision', 'viewport', 'format', 'mimeType',
+    'width', 'height', 'metadata', 'dataByteLength',
+  ]);
+  if (
+    (value.format !== 'jpeg' && value.format !== 'png')
+    || (value.mimeType !== 'image/jpeg' && value.mimeType !== 'image/png')
+    || (value.format === 'jpeg' && value.mimeType !== 'image/jpeg')
+    || (value.format === 'png' && value.mimeType !== 'image/png')
+  ) throw new interfaces.ControllerBrowserTransportProtocolError('browser frame format is invalid.');
+  const metadata = assertObject(value.metadata, 'browser frame metadata');
+  assertKeys(metadata, [
+    'offsetTop', 'pageScaleFactor', 'deviceWidth', 'deviceHeight', 'scrollOffsetX', 'scrollOffsetY',
+  ], ['timestamp']);
+  const dataByteLength = assertSafeInteger(value.dataByteLength, 'frame.dataByteLength', 1);
+  if (dataByteLength > interfaces.controllerBrowserTransportMaximumFrameBytes) {
+    throw new interfaces.ControllerBrowserTransportProtocolError('browser frame exceeds the byte limit.');
+  }
+  return {
+    tabId: assertBoundedString(value.tabId, 'frame.tabId'),
+    sequence: assertSafeInteger(value.sequence, 'frame.sequence', 1),
+    generation: assertSafeInteger(value.generation, 'frame.generation'),
+    viewportRevision: assertSafeInteger(value.viewportRevision, 'frame.viewportRevision'),
+    viewport: assertBrowserViewport(value.viewport),
+    format: value.format,
+    mimeType: value.mimeType,
+    width: assertSafeInteger(value.width, 'frame.width', 1),
+    height: assertSafeInteger(value.height, 'frame.height', 1),
+    metadata: {
+      offsetTop: assertFiniteNumber(metadata.offsetTop, 'frame.metadata.offsetTop'),
+      pageScaleFactor: assertFiniteNumber(metadata.pageScaleFactor, 'frame.metadata.pageScaleFactor'),
+      deviceWidth: assertFiniteNumber(metadata.deviceWidth, 'frame.metadata.deviceWidth'),
+      deviceHeight: assertFiniteNumber(metadata.deviceHeight, 'frame.metadata.deviceHeight'),
+      scrollOffsetX: assertFiniteNumber(metadata.scrollOffsetX, 'frame.metadata.scrollOffsetX'),
+      scrollOffsetY: assertFiniteNumber(metadata.scrollOffsetY, 'frame.metadata.scrollOffsetY'),
+      ...(metadata.timestamp === undefined
+        ? {}
+        : { timestamp: assertFiniteNumber(metadata.timestamp, 'frame.metadata.timestamp') }),
+    },
+    dataByteLength,
+  };
+};
+
+const assertServerPacket = (valueArg: unknown): interfaces.TControllerBrowserServerPacket => {
+  const value = assertObject(valueArg, 'browser server packet');
+  if (value.protocol !== interfaces.controllerBrowserTransportProtocol) {
+    throw new interfaces.ControllerBrowserTransportProtocolError('browser packet protocol is invalid.');
+  }
+  const streamGeneration = assertSafeInteger(value.streamGeneration, 'streamGeneration', 1);
+  if (value.type === 'state') {
+    assertKeys(value, ['protocol', 'streamGeneration', 'type', 'state']);
+    return {
+      protocol: interfaces.controllerBrowserTransportProtocol,
+      streamGeneration,
+      type: 'state',
+      state: assertBrowserState(value.state),
+    };
+  }
+  if (value.type === 'error') {
+    assertKeys(value, ['protocol', 'streamGeneration', 'type', 'error']);
+    return {
+      protocol: interfaces.controllerBrowserTransportProtocol,
+      streamGeneration,
+      type: 'error',
+      error: assertBrowserError(value.error),
+    };
+  }
+  if (value.type === 'frame') {
+    assertKeys(value, ['protocol', 'streamGeneration', 'type', 'frame']);
+    return {
+      protocol: interfaces.controllerBrowserTransportProtocol,
+      streamGeneration,
+      type: 'frame',
+      frame: assertBrowserFrameMetadata(value.frame),
+    };
+  }
+  if (value.type === 'operationResult') {
+    assertKeys(value, ['protocol', 'streamGeneration', 'type', 'operationId', 'result']);
+    const result = assertObject(value.result, 'browser operation result');
+    if (result.status === 'succeeded') {
+      assertKeys(result, ['status'], ['accepted', 'state']);
+      if (result.accepted !== undefined && typeof result.accepted !== 'boolean') {
+        throw new interfaces.ControllerBrowserTransportProtocolError('operation acceptance is invalid.');
+      }
+      return {
+        protocol: interfaces.controllerBrowserTransportProtocol,
+        streamGeneration,
+        type: 'operationResult',
+        operationId: assertSafeInteger(value.operationId, 'operationId', 1),
+        result: {
+          status: 'succeeded',
+          ...(result.accepted === undefined ? {} : { accepted: result.accepted }),
+          ...(result.state === undefined ? {} : { state: assertBrowserState(result.state) }),
+        },
+      };
+    }
+    if (result.status === 'failed') {
+      assertKeys(result, ['status', 'error']);
+      const error = assertBrowserError(result.error, false);
+      return {
+        protocol: interfaces.controllerBrowserTransportProtocol,
+        streamGeneration,
+        type: 'operationResult',
+        operationId: assertSafeInteger(value.operationId, 'operationId', 1),
+        result: { status: 'failed', error: { code: error.code, message: error.message } },
+      };
+    }
+    if (result.status === 'cancelled' || result.status === 'superseded') {
+      assertKeys(result, ['status']);
+      return {
+        protocol: interfaces.controllerBrowserTransportProtocol,
+        streamGeneration,
+        type: 'operationResult',
+        operationId: assertSafeInteger(value.operationId, 'operationId', 1),
+        result: { status: result.status },
+      };
+    }
+  }
+  throw new interfaces.ControllerBrowserTransportProtocolError('browser server packet type is invalid.');
+};
+
+export class ControllerBrowserViewTransportClient {
+  private lifecycle: 'new' | 'opening' | 'active' | 'failed' | 'stopped' = 'new';
+  private nextOperationId = 0;
+  private readonly pendingOperations = new Map<number, IPendingBrowserOperation>();
+  private startTask?: Promise<void>;
+  private receiveTask?: Promise<void>;
+  private stopTask?: Promise<void>;
+  private failureReported = false;
+
+  constructor(private readonly options: IControllerBrowserViewTransportClientOptions) {}
+
+  public get streamGeneration(): number {
+    return this.options.streamGeneration;
+  }
+
+  public start(): Promise<void> {
+    if (this.lifecycle === 'active') return Promise.resolve();
+    if (this.startTask) return this.startTask;
+    if (this.lifecycle !== 'new') {
+      return Promise.reject(new Error('The browser transport cannot be started.'));
+    }
+    this.lifecycle = 'opening';
+    const receiveTask = this.receiveEvents();
+    this.receiveTask = receiveTask;
+    void receiveTask.catch((errorArg) => this.fail(
+      errorArg,
+      !(errorArg instanceof interfaces.ControllerBrowserTransportProtocolError),
+    ));
+    const startTask = Promise.all([
+      this.options.events.opened,
+      this.options.operations.opened,
+    ]).then(() => {
+      if (this.lifecycle !== 'opening') throw new Error('The browser transport stopped while opening.');
+      this.lifecycle = 'active';
+    }).catch((errorArg) => {
+      this.fail(errorArg, true);
+      throw errorArg;
+    });
+    this.startTask = startTask;
+    return startTask;
+  }
+
+  public async operate(
+    operationArg: interfaces.TControllerBrowserViewOperation,
+    signalArg?: AbortSignal,
+  ): Promise<interfaces.TControllerBrowserOperationResult> {
+    if (this.lifecycle !== 'active') throw new Error('The browser transport is unavailable.');
+    signalArg?.throwIfAborted();
+    if (
+      this.pendingOperations.size
+      >= interfaces.controllerBrowserTransportMaximumPendingOperations
+    ) throw new Error('The browser operation capacity was reached.');
+    const operationId = ++this.nextOperationId;
+    const packet = interfaces.encodeControllerBrowserTransportPacket({
+      protocol: interfaces.controllerBrowserTransportProtocol,
+      streamGeneration: this.options.streamGeneration,
+      type: 'operation',
+      operationId,
+      operation: operationArg,
+    });
+    const result = new Promise<interfaces.TControllerBrowserOperationResult>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.cancelPendingOperation(
+          operationId,
+          new DOMException('The browser operation timed out.', 'TimeoutError'),
+        );
+      }, browserOperationTimeoutMs);
+      const pending: IPendingBrowserOperation = { resolve, reject, timeout };
+      if (signalArg) {
+        pending.abortSignal = signalArg;
+        pending.abortListener = () => this.cancelPendingOperation(
+          operationId,
+          signalArg.reason ?? new DOMException('The operation was aborted.', 'AbortError'),
+        );
+        signalArg.addEventListener('abort', pending.abortListener, { once: true });
+      }
+      this.pendingOperations.set(operationId, pending);
+    });
+    let sendTask: Promise<void>;
+    try {
+      sendTask = this.options.operations.send(packet);
+    } catch (errorArg) {
+      this.rejectPendingOperation(operationId, errorArg);
+      this.fail(errorArg, true);
+      return result;
+    }
+    void sendTask.catch((errorArg) => {
+      this.rejectPendingOperation(operationId, errorArg);
+      this.fail(errorArg, true);
+    });
+    return result;
+  }
+
+  public stop(reasonArg: unknown = new Error('The browser transport stopped.')): Promise<void> {
+    if (this.stopTask) return this.stopTask;
+    this.lifecycle = 'stopped';
+    this.rejectAllPending(reasonArg);
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    const settlement = Promise.allSettled([
+      Promise.resolve().then(() => this.options.events.abort(reasonArg)),
+      Promise.resolve().then(() => this.options.operations.abort(reasonArg)),
+      this.startTask,
+      this.receiveTask,
+      this.options.events.closed,
+      this.options.operations.closed,
+    ].filter((candidateArg): candidateArg is Promise<void> => candidateArg !== undefined))
+      .then(() => undefined);
+    const boundedStop = Promise.race([
+      settlement,
+      new Promise<void>((resolve) => {
+        timeout = setTimeout(resolve, browserTransportStopTimeoutMs);
+      }),
+    ]).finally(() => {
+      if (timeout) clearTimeout(timeout);
+    });
+    this.stopTask = boundedStop;
+    return boundedStop;
+  }
+
+  private async receiveEvents(): Promise<void> {
+    while (this.lifecycle !== 'failed' && this.lifecycle !== 'stopped') {
+      const chunk = await this.options.events.receive();
+      if (chunk === undefined) {
+        if (this.isStopped()) return;
+        await this.options.events.accept();
+        throw new Error('The browser event stream closed unexpectedly.');
+      }
+      const packet = assertServerPacket(
+        interfaces.decodeControllerBrowserTransportPacket(chunk),
+      );
+      if (packet.streamGeneration !== this.options.streamGeneration) {
+        throw new interfaces.ControllerBrowserTransportProtocolError(
+          'The browser packet belongs to a stale stream generation.',
+        );
+      }
+      if (packet.type === 'operationResult') {
+        this.settlePendingOperation(packet.operationId, packet.result);
+        continue;
+      }
+      if (packet.type === 'state') {
+        this.options.onEvent({ type: 'state', state: packet.state });
+        continue;
+      }
+      if (packet.type === 'error') {
+        this.options.onEvent({ type: 'error', error: packet.error });
+        if (packet.error.fatal) {
+          this.fail(new Error(packet.error.message), false);
+          return;
+        }
+        continue;
+      }
+      const data = await this.options.events.receive();
+      if (data === undefined || data.byteLength !== packet.frame.dataByteLength) {
+        throw new interfaces.ControllerBrowserTransportProtocolError(
+          'The browser frame payload length does not match its metadata.',
+        );
+      }
+      const { dataByteLength: _dataByteLength, ...frame } = packet.frame;
+      const browserFrame: interfaces.IControllerBrowserFrame = {
+        ...frame,
+        data: Uint8Array.from(data),
+      };
+      this.options.onEvent({ type: 'frame', frame: browserFrame });
+    }
+  }
+
+  private cancelPendingOperation(operationIdArg: number, reasonArg: unknown): void {
+    if (!this.rejectPendingOperation(operationIdArg, reasonArg)) return;
+    const packet = interfaces.encodeControllerBrowserTransportPacket({
+      protocol: interfaces.controllerBrowserTransportProtocol,
+      streamGeneration: this.options.streamGeneration,
+      type: 'cancel',
+      operationId: operationIdArg,
+    });
+    void Promise.resolve().then(() => this.options.operations.send(packet))
+      .catch((errorArg) => this.fail(errorArg, true));
+  }
+
+  private settlePendingOperation(
+    operationIdArg: number,
+    resultArg: interfaces.TControllerBrowserOperationResult,
+  ): void {
+    const pending = this.takePendingOperation(operationIdArg);
+    if (!pending) return;
+    if (resultArg.status === 'failed') {
+      pending.reject(new ControllerBrowserOperationError(resultArg.error.code, resultArg.error.message));
+    } else if (resultArg.status === 'cancelled') {
+      pending.reject(new DOMException('The browser operation was cancelled.', 'AbortError'));
+    } else {
+      pending.resolve(resultArg);
+    }
+  }
+
+  private rejectPendingOperation(operationIdArg: number, reasonArg: unknown): boolean {
+    const pending = this.takePendingOperation(operationIdArg);
+    if (!pending) return false;
+    pending.reject(reasonArg);
+    return true;
+  }
+
+  private takePendingOperation(operationIdArg: number): IPendingBrowserOperation | undefined {
+    const pending = this.pendingOperations.get(operationIdArg);
+    if (!pending) return undefined;
+    this.pendingOperations.delete(operationIdArg);
+    clearTimeout(pending.timeout);
+    if (pending.abortSignal && pending.abortListener) {
+      pending.abortSignal.removeEventListener('abort', pending.abortListener);
+    }
+    return pending;
+  }
+
+  private rejectAllPending(reasonArg: unknown): void {
+    for (const operationId of [...this.pendingOperations.keys()]) {
+      this.rejectPendingOperation(operationId, reasonArg);
+    }
+  }
+
+  private fail(errorArg: unknown, recoverableArg: boolean): void {
+    if (this.lifecycle === 'failed' || this.lifecycle === 'stopped') return;
+    this.lifecycle = 'failed';
+    this.rejectAllPending(errorArg);
+    void this.options.events.abort(errorArg).catch(() => undefined);
+    void this.options.operations.abort(errorArg).catch(() => undefined);
+    if (this.failureReported) return;
+    this.failureReported = true;
+    this.options.onFailure(errorArg, recoverableArg);
+  }
+
+  private isStopped(): boolean {
+    return this.lifecycle === 'stopped';
+  }
+}

package/ts_web/classes.controllersocketclient.ts

@@ -279,18 +279,11 @@ export interface IControllerSocketClientOptions {
   onTerminalOutput?: (
     output: interfaces.IReq_ControllerTerminalOutput['request'],
   ) => void | Promise<void>;
-  onBrowserViewEvent?: (
-    event: TControllerBrowserViewEventMessage,
-  ) => void | Promise<void>;
   /** Fires when the transport fail-closes the connection (e.g. frame limits). */
   onTransportClose?: (closeCode: number, reason: string) => void;
+  onReconnectExhausted?: (attempts: number, endpoint: string) => void;
 }
 
-export type TControllerBrowserViewEventMessage =
-  plugins.typedrequest.TReverseVirtualStreamDirections<
-    interfaces.IReq_ControllerBrowserViewEvent['request']
-  >;
-
 export interface IControllerSocketRequestOptions
   extends plugins.typedrequest.ITypedRequestFireOptions {
   abortSignal?: AbortSignal;
@@ -502,15 +495,6 @@ export class ControllerSocketClient {
         },
       ),
     );
-    this.typedRouter.addTypedHandler(
-      new plugins.typedrequest.TypedHandler<interfaces.IReq_ControllerBrowserViewEvent>(
-        'controller.browser.view.event',
-        async (eventArg) => {
-          await this.options.onBrowserViewEvent?.(eventArg);
-          return {};
-        },
-      ),
-    );
   }
 
   public get status(): plugins.typedsocket.TConnectionStatus {
@@ -608,6 +592,11 @@ export class ControllerSocketClient {
           diagnosticArg.closeCode,
           typeof diagnosticArg.reason === 'string' ? diagnosticArg.reason : '',
         );
+      } else if (diagnosticArg.kind === 'reconnectExhausted') {
+        this.options.onReconnectExhausted?.(
+          diagnosticArg.attempts,
+          diagnosticArg.endpoint,
+        );
       }
     });