@opengeni/sdk 0.48.0 → 0.57.0

package/dist/chunk-ST5DDKJP.js

@@ -0,0 +1,987 @@
+// src/interaction.ts
+var INTERACTION_PROTOCOL_VERSION = 1;
+var BROWSER_CONTROL_WEBSOCKET_PROTOCOL = "opengeni.browser.v1";
+var COMPUTER_CONTROL_WEBSOCKET_PROTOCOL = "opengeni.computer.v1";
+var BROWSER_CONTROL_WEBSOCKET_BEARER_PREFIX = "opengeni.auth.";
+var BROWSER_CONTROL_MAX_FRAME_HEADER_BYTES = 64 * 1024;
+var BROWSER_FRAME_MAX_BYTES = 24 * 1024 * 1024;
+var BROWSER_FRAME_MAX_DIMENSION = 32768;
+var BROWSER_FRAME_MAX_PIXELS = 1e8;
+var OpenGeniInteractionClient = class {
+  attachedBrowsers;
+  authRuns;
+  browsers;
+  computers;
+  identities;
+  interventions;
+  networkRoutes;
+  siteAuthConnections;
+  constructor(transport) {
+    this.attachedBrowsers = new AttachedBrowserDeviceCollection(transport);
+    this.authRuns = new AuthRunCollection(transport);
+    this.browsers = new BrowserSessionCollection(transport);
+    this.computers = new ComputerSessionCollection(transport);
+    this.identities = new BrowserIdentityCollection(transport);
+    this.interventions = new InteractionInterventionCollection(transport);
+    this.networkRoutes = new NetworkRouteCollection(transport);
+    this.siteAuthConnections = new SiteAuthConnectionCollection(transport);
+  }
+};
+var NetworkRouteCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listNetworkRoutes(workspaceId, options);
+  }
+  route(workspaceId, networkRouteId) {
+    return new NetworkRouteResource(this.transport, workspaceId, networkRouteId);
+  }
+  async create(workspaceId, request, options = {}) {
+    const response = await this.transport.createNetworkRoute(workspaceId, request, options);
+    return this.route(workspaceId, response.route.id);
+  }
+};
+var NetworkRouteResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    return await this.transport.getNetworkRoute(this.workspaceId, this.id, options);
+  }
+  async update(request, options = {}) {
+    return await this.transport.updateNetworkRoute(this.workspaceId, this.id, request, options);
+  }
+};
+var SiteAuthConnectionCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listSiteAuthConnections(workspaceId, options);
+  }
+  connection(workspaceId, connectionId) {
+    return new SiteAuthConnectionResource(this.transport, workspaceId, connectionId);
+  }
+  async create(workspaceId, request, options = {}) {
+    const response = await this.transport.createSiteAuthConnection(workspaceId, request, options);
+    return this.connection(workspaceId, response.connection.id);
+  }
+};
+var SiteAuthConnectionResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    return await this.transport.getSiteAuthConnection(this.workspaceId, this.id, options);
+  }
+  async update(request, options = {}) {
+    return await this.transport.updateSiteAuthConnection(
+      this.workspaceId,
+      this.id,
+      request,
+      options
+    );
+  }
+};
+var AuthRunCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listAuthRuns(workspaceId, options);
+  }
+  async get(workspaceId, authRunId, options = {}) {
+    return await this.transport.getAuthRun(workspaceId, authRunId, options);
+  }
+  run(workspaceId, browserSessionId, authRunId) {
+    return new AuthRunResource(this.transport, workspaceId, browserSessionId, authRunId);
+  }
+};
+var BrowserAuthRunCollection = class {
+  constructor(transport, workspaceId, browserSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+  }
+  async list(options = {}) {
+    return await this.transport.listAuthRuns(this.workspaceId, {
+      ...options,
+      browserSessionId: this.browserSessionId
+    });
+  }
+  run(authRunId) {
+    return new AuthRunResource(this.transport, this.workspaceId, this.browserSessionId, authRunId);
+  }
+  async start(request, options = {}) {
+    const response = await this.transport.startBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      request,
+      options
+    );
+    return this.run(response.run.id);
+  }
+};
+var AuthRunResource = class {
+  constructor(transport, workspaceId, browserSessionId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    const run = await this.transport.getAuthRun(this.workspaceId, this.id, options);
+    if (run.browserSessionId !== this.browserSessionId) {
+      throw new Error("AuthRun belongs to another BrowserSession");
+    }
+    return run;
+  }
+  async report(request, options = {}) {
+    return await this.transport.reportBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  async protectedFill(request, options = {}) {
+    return await this.transport.protectedBrowserAuthFill(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  async advanceExternal(request, options = {}) {
+    return await this.transport.advanceExternalBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  /** Human-session helper. Hosted provider URLs never appear in model tools. */
+  async openExternalFlow(request, options = {}) {
+    return await this.transport.openExternalBrowserAuthFlow(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+  async verify(request, options = {}) {
+    return await this.transport.verifyBrowserAuthRun(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      request,
+      options
+    );
+  }
+};
+var InteractionInterventionCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listInteractionInterventions(workspaceId, options);
+  }
+  intervention(workspaceId, interventionId) {
+    return new InteractionInterventionResource(this.transport, workspaceId, interventionId);
+  }
+  async create(workspaceId, request, options = {}) {
+    const response = await this.transport.createInteractionIntervention(
+      workspaceId,
+      request,
+      options
+    );
+    return this.intervention(workspaceId, response.intervention.id);
+  }
+};
+var InteractionInterventionResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    return await this.transport.getInteractionIntervention(this.workspaceId, this.id, options);
+  }
+  async resolve(request, options = {}) {
+    return await this.transport.resolveInteractionIntervention(
+      this.workspaceId,
+      this.id,
+      request,
+      options
+    );
+  }
+};
+var AttachedBrowserDeviceCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listAttachedBrowsers(workspaceId, options);
+  }
+  device(workspaceId, deviceId) {
+    return new AttachedBrowserDeviceResource(this.transport, workspaceId, deviceId);
+  }
+};
+var AttachedBrowserDeviceResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    return await this.transport.getAttachedBrowser(this.workspaceId, this.id, options);
+  }
+};
+var BrowserIdentityCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listBrowserIdentities(workspaceId, options);
+  }
+  identity(workspaceId, identityId) {
+    return new BrowserIdentityResource(this.transport, workspaceId, identityId);
+  }
+  async create(workspaceId, request, options = {}) {
+    const response = await this.transport.createBrowserIdentity(workspaceId, request, options);
+    return this.identity(workspaceId, response.identity.id);
+  }
+};
+var BrowserIdentityResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    return await this.transport.getBrowserIdentity(this.workspaceId, this.id, options);
+  }
+  async revisions(options = {}) {
+    return await this.transport.listBrowserRevisions(this.workspaceId, this.id, options);
+  }
+  async update(request, options = {}) {
+    return await this.transport.updateBrowserIdentity(this.workspaceId, this.id, request, options);
+  }
+};
+var BrowserSessionCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listBrowserSessions(workspaceId, options);
+  }
+  session(workspaceId, browserSessionId) {
+    return new BrowserSessionResource(this.transport, workspaceId, browserSessionId);
+  }
+  async open(workspaceId, request, options = {}) {
+    const response = await this.transport.createBrowserSession(workspaceId, request, options);
+    return this.session(workspaceId, response.session.id);
+  }
+  async currentOrOpen(options) {
+    const requestOptions = options.signal ? { signal: options.signal } : {};
+    const listed = await this.list(options.workspaceId, requestOptions);
+    const current = newestRelevantBrowser(listed.sessions, options.associationSessionId);
+    if (current) {
+      const resource = this.session(options.workspaceId, current.id);
+      if (current.lifecycle === "suspended") {
+        await resource.resume(
+          { operationId: options.operationId ?? crypto.randomUUID() },
+          requestOptions
+        );
+      }
+      return resource;
+    }
+    return await this.open(
+      options.workspaceId,
+      {
+        operationId: options.operationId ?? crypto.randomUUID(),
+        sessionId: options.associationSessionId,
+        ...options.name !== void 0 ? { name: options.name } : {},
+        ...options.initialUrl !== void 0 ? { initialUrl: options.initialUrl } : {},
+        ...options.headless !== void 0 ? { headless: options.headless } : {},
+        ...options.placement !== void 0 ? { placement: options.placement } : {},
+        ...options.identityId !== void 0 ? { identityId: options.identityId } : {},
+        ...options.baseRevisionId !== void 0 ? { baseRevisionId: options.baseRevisionId } : {},
+        ...options.networkRouteId !== void 0 ? { networkRouteId: options.networkRouteId } : {},
+        ...options.linkedComputerSessionId !== void 0 ? { linkedComputerSessionId: options.linkedComputerSessionId } : {}
+      },
+      requestOptions
+    );
+  }
+};
+var BrowserSessionResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+    this.auth = new BrowserAuthRunCollection(transport, workspaceId, id);
+    this.clipboard = new BrowserClipboardResource(transport, workspaceId, id);
+    this.downloads = new BrowserDownloadCollection(transport, workspaceId, id);
+    this.tabs = new BrowserTargetCollection(transport, workspaceId, id);
+    this.targets = this.tabs;
+  }
+  auth;
+  clipboard;
+  downloads;
+  tabs;
+  /** Alias for hosts that prefer the protocol term. */
+  targets;
+  async get(options = {}) {
+    return await this.transport.getBrowserSession(this.workspaceId, this.id, options);
+  }
+  async observe(targetId, options = {}) {
+    return await this.transport.observeBrowserTarget(this.workspaceId, this.id, targetId, options);
+  }
+  async act(request, options = {}) {
+    return await this.transport.actInBrowser(this.workspaceId, this.id, request, options);
+  }
+  async receipt(operationId, options = {}) {
+    return await this.transport.getBrowserActionReceipt(
+      this.workspaceId,
+      this.id,
+      operationId,
+      options
+    );
+  }
+  async diagnostics(targetId, options = {}) {
+    return await this.transport.listBrowserDiagnostics(
+      this.workspaceId,
+      this.id,
+      targetId,
+      options
+    );
+  }
+  async attach(request, options = {}) {
+    return await this.transport.attachBrowserSession(this.workspaceId, this.id, request, options);
+  }
+  async heartbeat(options = {}) {
+    return await this.transport.heartbeatBrowserSession(this.workspaceId, this.id, options);
+  }
+  async publishRevision(request, options = {}) {
+    return await this.transport.publishBrowserRevision(this.workspaceId, this.id, request, options);
+  }
+  async suspend(request = {
+    operationId: crypto.randomUUID()
+  }, options = {}) {
+    return await this.transport.suspendBrowserSession(this.workspaceId, this.id, request, options);
+  }
+  async resume(request = {
+    operationId: crypto.randomUUID()
+  }, options = {}) {
+    return await this.transport.resumeBrowserSession(this.workspaceId, this.id, request, options);
+  }
+  async end(request = {
+    operationId: crypto.randomUUID()
+  }, options = {}) {
+    return await this.transport.endBrowserSession(this.workspaceId, this.id, request, options);
+  }
+};
+var BrowserClipboardResource = class {
+  constructor(transport, workspaceId, browserSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+  }
+  async read(options = {}) {
+    const clipboard = await this.transport.readBrowserClipboard(
+      this.workspaceId,
+      this.browserSessionId,
+      options
+    );
+    if (clipboard.browserSessionId !== this.browserSessionId) {
+      throw new Error("Browser clipboard belongs to another BrowserSession");
+    }
+    return clipboard;
+  }
+};
+var BrowserDownloadCollection = class {
+  constructor(transport, workspaceId, browserSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+  }
+  async list(options = {}) {
+    return await this.transport.listBrowserDownloads(
+      this.workspaceId,
+      this.browserSessionId,
+      options
+    );
+  }
+  download(downloadId) {
+    return new BrowserDownloadResource(
+      this.transport,
+      this.workspaceId,
+      this.browserSessionId,
+      downloadId
+    );
+  }
+};
+var BrowserDownloadResource = class {
+  constructor(transport, workspaceId, browserSessionId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+    this.id = id;
+  }
+  async get(options = {}) {
+    const download = await this.transport.getBrowserDownload(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      options
+    );
+    if (download.browserSessionId !== this.browserSessionId) {
+      throw new Error("BrowserDownload belongs to another BrowserSession");
+    }
+    return download;
+  }
+  /** Publish this exact private browser download into the source session's
+   * workspace. Pass an operationId when the caller needs retry identity across
+   * process boundaries; otherwise one is generated for this call. */
+  async saveToWorkspace(destinationPath, options = {}) {
+    const { operationId = crypto.randomUUID(), overwrite = false, ...requestOptions } = options;
+    const response = await this.transport.saveBrowserDownload(
+      this.workspaceId,
+      this.browserSessionId,
+      this.id,
+      { operationId, destinationPath, overwrite },
+      requestOptions
+    );
+    if (response.download.id !== this.id || response.download.browserSessionId !== this.browserSessionId) {
+      throw new Error("BrowserDownload save returned another resource");
+    }
+    return response;
+  }
+};
+var BrowserTargetCollection = class {
+  constructor(transport, workspaceId, browserSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.browserSessionId = browserSessionId;
+  }
+  async list(options = {}) {
+    return await this.transport.listBrowserTargets(
+      this.workspaceId,
+      this.browserSessionId,
+      options
+    );
+  }
+  async open(url, options = {}) {
+    return await this.transport.openBrowserTarget(
+      this.workspaceId,
+      this.browserSessionId,
+      url === void 0 ? {} : { url },
+      options
+    );
+  }
+  async select(targetId, options = {}) {
+    return await this.transport.selectBrowserTarget(
+      this.workspaceId,
+      this.browserSessionId,
+      targetId,
+      options
+    );
+  }
+  async close(targetId, options = {}) {
+    return await this.transport.closeBrowserTarget(
+      this.workspaceId,
+      this.browserSessionId,
+      targetId,
+      options
+    );
+  }
+};
+var ComputerSessionCollection = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(workspaceId, options = {}) {
+    return await this.transport.listComputerSessions(workspaceId, options);
+  }
+  session(workspaceId, computerSessionId) {
+    return new ComputerSessionResource(this.transport, workspaceId, computerSessionId);
+  }
+  async open(workspaceId, request, options = {}) {
+    const response = await this.transport.createComputerSession(workspaceId, request, options);
+    return this.session(workspaceId, response.session.id);
+  }
+  async currentOrOpen(options) {
+    const requestOptions = options.signal ? { signal: options.signal } : {};
+    const listed = await this.list(options.workspaceId, requestOptions);
+    const current = newestRelevantComputer(listed.sessions, options.associationSessionId);
+    if (current) {
+      return this.session(options.workspaceId, current.id);
+    }
+    return await this.open(
+      options.workspaceId,
+      {
+        operationId: options.operationId ?? crypto.randomUUID(),
+        sessionId: options.associationSessionId,
+        ...options.name !== void 0 ? { name: options.name } : {},
+        ...options.placement !== void 0 ? { placement: options.placement } : {}
+      },
+      requestOptions
+    );
+  }
+};
+var ComputerSessionResource = class {
+  constructor(transport, workspaceId, id) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.id = id;
+    this.targets = new ComputerTargetCollection(transport, workspaceId, id);
+    this.apps = this.targets;
+    this.clipboard = new ComputerClipboardResource(transport, workspaceId, id);
+  }
+  targets;
+  /** Native application/window targets are also the public app collection. */
+  apps;
+  clipboard;
+  async get(options = {}) {
+    return await this.transport.getComputerSession(this.workspaceId, this.id, options);
+  }
+  async observe(targetId, options = {}) {
+    return await this.transport.observeComputerTarget(this.workspaceId, this.id, targetId, options);
+  }
+  async act(request, options = {}) {
+    return await this.transport.actInComputer(this.workspaceId, this.id, request, options);
+  }
+  async receipt(operationId, options = {}) {
+    return await this.transport.getComputerActionReceipt(
+      this.workspaceId,
+      this.id,
+      operationId,
+      options
+    );
+  }
+  async attach(request, options = {}) {
+    return await this.transport.attachComputerSession(this.workspaceId, this.id, request, options);
+  }
+  async heartbeat(options = {}) {
+    return await this.transport.heartbeatComputerSession(this.workspaceId, this.id, options);
+  }
+  async end(request = { operationId: crypto.randomUUID() }, options = {}) {
+    return await this.transport.endComputerSession(this.workspaceId, this.id, request, options);
+  }
+};
+var ComputerClipboardResource = class {
+  constructor(transport, workspaceId, computerSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.computerSessionId = computerSessionId;
+  }
+  async read(options = {}) {
+    const clipboard = await this.transport.readComputerClipboard(
+      this.workspaceId,
+      this.computerSessionId,
+      options
+    );
+    if (clipboard.computerSessionId !== this.computerSessionId) {
+      throw new Error("Computer clipboard belongs to another ComputerSession");
+    }
+    return clipboard;
+  }
+};
+var ComputerTargetCollection = class {
+  constructor(transport, workspaceId, computerSessionId) {
+    this.transport = transport;
+    this.workspaceId = workspaceId;
+    this.computerSessionId = computerSessionId;
+  }
+  async list(options = {}) {
+    return await this.transport.listComputerTargets(
+      this.workspaceId,
+      this.computerSessionId,
+      options
+    );
+  }
+};
+function browserFrameSocketUrl(attachment, options = {}) {
+  if (attachment.stream.kind !== "direct_websocket") {
+    throw new Error("relay browser attachments are opened through the relay protocol");
+  }
+  const url = new URL(attachment.stream.url);
+  if (url.protocol === "http:") url.protocol = "ws:";
+  else if (url.protocol === "https:") url.protocol = "wss:";
+  else if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    throw new Error("browser frame attachment did not contain an HTTP or WebSocket URL");
+  }
+  if (options.format !== void 0) url.searchParams.set("format", options.format);
+  setBoundedIntegerQuery(url, "quality", options.quality, 1, 100);
+  setBoundedIntegerQuery(url, "maxWidth", options.maxWidth, 1, 4096);
+  setBoundedIntegerQuery(url, "maxHeight", options.maxHeight, 1, 4096);
+  setBoundedIntegerQuery(url, "everyNthFrame", options.everyNthFrame, 1, 60);
+  return url.toString();
+}
+function computerFrameSocketUrl(attachment, options = {}) {
+  if (attachment.stream.kind !== "direct_websocket") {
+    throw new Error("relay computer attachments are opened through the relay protocol");
+  }
+  const url = new URL(attachment.stream.url);
+  if (url.protocol === "http:") url.protocol = "ws:";
+  else if (url.protocol === "https:") url.protocol = "wss:";
+  else if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    throw new Error("computer frame attachment did not contain an HTTP or WebSocket URL");
+  }
+  if (options.format !== void 0) url.searchParams.set("format", options.format);
+  setBoundedIntegerQuery(url, "quality", options.quality, 1, 100);
+  setBoundedIntegerQuery(url, "maxWidth", options.maxWidth, 1, 4096);
+  setBoundedIntegerQuery(url, "maxHeight", options.maxHeight, 1, 4096);
+  setBoundedIntegerQuery(url, "everyNthFrame", options.everyNthFrame, 1, 60);
+  return url.toString();
+}
+function decodeBrowserFrameMessage(message) {
+  const bytes = message instanceof Uint8Array ? message : new Uint8Array(message);
+  if (bytes.byteLength < 5 || bytes.byteLength > 4 + BROWSER_CONTROL_MAX_FRAME_HEADER_BYTES + BROWSER_FRAME_MAX_BYTES) {
+    throw new Error("browser frame message is truncated or too large");
+  }
+  const metadataLength = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(
+    0,
+    false
+  );
+  if (metadataLength < 1 || metadataLength > BROWSER_CONTROL_MAX_FRAME_HEADER_BYTES || metadataLength + 4 >= bytes.byteLength) {
+    throw new Error("browser frame metadata length is invalid");
+  }
+  let value;
+  try {
+    value = JSON.parse(
+      new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(4, 4 + metadataLength))
+    );
+  } catch {
+    throw new Error("browser frame metadata is invalid JSON");
+  }
+  const metadata = parseBrowserFrameMetadata(value);
+  const data = bytes.slice(4 + metadataLength);
+  if (data.byteLength < 1 || data.byteLength > BROWSER_FRAME_MAX_BYTES) {
+    throw new Error("browser frame image is empty or too large");
+  }
+  const dimensions = imageDimensions(data, metadata.mediaType);
+  if (dimensions.width !== metadata.width || dimensions.height !== metadata.height) {
+    throw new Error("browser frame image dimensions do not match metadata");
+  }
+  return { ...metadata, data };
+}
+async function decodeComputerFrameMessage(message) {
+  const bytes = message instanceof Uint8Array ? message : new Uint8Array(message);
+  if (bytes.byteLength < 5 || bytes.byteLength > 4 + BROWSER_CONTROL_MAX_FRAME_HEADER_BYTES + BROWSER_FRAME_MAX_BYTES) {
+    throw new Error("computer frame message is truncated or too large");
+  }
+  const metadataLength = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(
+    0,
+    false
+  );
+  if (metadataLength < 1 || metadataLength > BROWSER_CONTROL_MAX_FRAME_HEADER_BYTES || metadataLength + 4 >= bytes.byteLength) {
+    throw new Error("computer frame metadata length is invalid");
+  }
+  let value;
+  try {
+    value = JSON.parse(
+      new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(4, 4 + metadataLength))
+    );
+  } catch {
+    throw new Error("computer frame metadata is invalid JSON");
+  }
+  const metadata = parseComputerFrameMetadata(value);
+  const data = bytes.slice(4 + metadataLength);
+  if (data.byteLength < 1 || data.byteLength > BROWSER_FRAME_MAX_BYTES) {
+    throw new Error("computer frame image is empty or too large");
+  }
+  const dimensions = imageDimensions(data, metadata.mediaType);
+  if (dimensions.width !== metadata.width || dimensions.height !== metadata.height) {
+    throw new Error("computer frame image dimensions do not match metadata");
+  }
+  if (await sha256Hex(data) !== metadata.sha256) {
+    throw new Error("computer frame digest does not match image");
+  }
+  return { ...metadata, data };
+}
+function parseBrowserFrameMetadata(value) {
+  if (!isRecord(value)) throw new Error("browser frame metadata is invalid");
+  const allowed = /* @__PURE__ */ new Set([
+    "frameId",
+    "browserSessionId",
+    "controllerGeneration",
+    "targetId",
+    "targetGeneration",
+    "documentGeneration",
+    "sequence",
+    "mediaType",
+    "width",
+    "height",
+    "deviceScaleFactor",
+    "scrollX",
+    "scrollY",
+    "capturedAt"
+  ]);
+  if (Object.keys(value).some((key) => !allowed.has(key))) {
+    throw new Error("browser frame metadata contains unknown fields");
+  }
+  const strings = [
+    "frameId",
+    "browserSessionId",
+    "controllerGeneration",
+    "targetId",
+    "targetGeneration",
+    "documentGeneration",
+    "mediaType",
+    "capturedAt"
+  ];
+  for (const key of strings) {
+    const item = value[key];
+    const max = key === "targetId" ? 512 : key === "capturedAt" ? 128 : 256;
+    if (typeof item !== "string" || item.length < 1 || utf8Bytes(item) > max) {
+      throw new Error("browser frame metadata is invalid");
+    }
+  }
+  const numbers = [
+    "sequence",
+    "width",
+    "height",
+    "deviceScaleFactor",
+    "scrollX",
+    "scrollY"
+  ];
+  for (const key of numbers) {
+    if (typeof value[key] !== "number" || !Number.isFinite(value[key])) {
+      throw new Error("browser frame metadata is invalid");
+    }
+  }
+  const metadata = value;
+  if (!Number.isSafeInteger(metadata.sequence) || metadata.sequence < 0 || !Number.isSafeInteger(metadata.width) || !Number.isSafeInteger(metadata.height)) {
+    throw new Error("browser frame metadata integers are invalid");
+  }
+  assertImageDimensions(metadata.width, metadata.height);
+  if (metadata.deviceScaleFactor <= 0 || metadata.deviceScaleFactor > 16 || Math.abs(metadata.scrollX) > 1e9 || Math.abs(metadata.scrollY) > 1e9) {
+    throw new Error("browser frame geometry metadata is invalid");
+  }
+  if (metadata.mediaType !== "image/jpeg" && metadata.mediaType !== "image/png") {
+    throw new Error("browser frame media type is invalid");
+  }
+  if (!isUuid(metadata.browserSessionId)) throw new Error("browser frame session id is invalid");
+  if (!/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u.test(metadata.controllerGeneration)) {
+    throw new Error("browser frame controller generation is invalid");
+  }
+  if (!Number.isFinite(new Date(metadata.capturedAt).valueOf())) {
+    throw new Error("browser frame timestamp is invalid");
+  }
+  return metadata;
+}
+function parseComputerFrameMetadata(value) {
+  if (!isRecord(value)) throw new Error("computer frame metadata is invalid");
+  const allowed = /* @__PURE__ */ new Set([
+    "frameId",
+    "computerSessionId",
+    "controllerGeneration",
+    "targetId",
+    "targetGeneration",
+    "sequence",
+    "mediaType",
+    "width",
+    "height",
+    "capturedAt",
+    "sha256"
+  ]);
+  if (Object.keys(value).some((key) => !allowed.has(key))) {
+    throw new Error("computer frame metadata contains unknown fields");
+  }
+  const strings = [
+    "frameId",
+    "computerSessionId",
+    "controllerGeneration",
+    "targetId",
+    "targetGeneration",
+    "mediaType",
+    "capturedAt",
+    "sha256"
+  ];
+  for (const key of strings) {
+    const item = value[key];
+    const max = key === "targetId" ? 512 : key === "capturedAt" ? 128 : 256;
+    if (typeof item !== "string" || item.length < 1 || utf8Bytes(item) > max) {
+      throw new Error("computer frame metadata is invalid");
+    }
+  }
+  const metadata = value;
+  if (!Number.isSafeInteger(metadata.sequence) || metadata.sequence < 0 || !Number.isSafeInteger(metadata.width) || !Number.isSafeInteger(metadata.height)) {
+    throw new Error("computer frame metadata integers are invalid");
+  }
+  assertImageDimensions(metadata.width, metadata.height);
+  if (metadata.mediaType !== "image/jpeg" && metadata.mediaType !== "image/png") {
+    throw new Error("computer frame media type is invalid");
+  }
+  if (!isUuid(metadata.computerSessionId)) {
+    throw new Error("computer frame session id is invalid");
+  }
+  if (!/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u.test(metadata.controllerGeneration)) {
+    throw new Error("computer frame controller generation is invalid");
+  }
+  if (!Number.isFinite(new Date(metadata.capturedAt).valueOf())) {
+    throw new Error("computer frame timestamp is invalid");
+  }
+  if (!/^[0-9a-f]{64}$/u.test(metadata.sha256)) {
+    throw new Error("computer frame digest is invalid");
+  }
+  return metadata;
+}
+function newestRelevantBrowser(sessions, associationSessionId) {
+  const live = sessions.filter(
+    (session) => !["ending", "ended", "failed", "lost"].includes(session.lifecycle) && session.associations.some((association) => association.sessionId === associationSessionId)
+  );
+  live.sort(
+    (left, right) => browserRelevance(right, associationSessionId) - browserRelevance(left, associationSessionId)
+  );
+  return live[0] ?? null;
+}
+function newestRelevantComputer(sessions, associationSessionId) {
+  const live = sessions.filter(
+    (session) => ["starting", "active", "restoring"].includes(session.lifecycle) && session.associations.some((association) => association.sessionId === associationSessionId)
+  );
+  live.sort(
+    (left, right) => computerRelevance(right, associationSessionId) - computerRelevance(left, associationSessionId)
+  );
+  return live[0] ?? null;
+}
+function browserRelevance(session, associationSessionId) {
+  const association = session.associations.filter((item) => item.sessionId === associationSessionId).map((item) => Date.parse(item.lastUsedAt)).filter(Number.isFinite).reduce((best, timestamp) => Math.max(best, timestamp), 0);
+  const used = Date.parse(session.lastUsedAt);
+  return Math.max(association, Number.isFinite(used) ? used : 0);
+}
+function computerRelevance(session, associationSessionId) {
+  const association = session.associations.filter((item) => item.sessionId === associationSessionId).map((item) => Date.parse(item.lastUsedAt)).filter(Number.isFinite).reduce((best, timestamp) => Math.max(best, timestamp), 0);
+  const used = Date.parse(session.lastUsedAt);
+  return Math.max(association, Number.isFinite(used) ? used : 0);
+}
+function setBoundedIntegerQuery(url, name, value, min, max) {
+  if (value === void 0) return;
+  if (!Number.isSafeInteger(value) || value < min || value > max) {
+    throw new Error(`browser frame ${name} must be an integer between ${min} and ${max}`);
+  }
+  url.searchParams.set(name, String(value));
+}
+function imageDimensions(data, mediaType) {
+  const dimensions = mediaType === "image/png" ? pngDimensions(data) : jpegDimensions(data);
+  assertImageDimensions(dimensions.width, dimensions.height);
+  return dimensions;
+}
+function assertImageDimensions(width, height) {
+  if (!Number.isSafeInteger(width) || !Number.isSafeInteger(height) || width < 1 || height < 1 || width > BROWSER_FRAME_MAX_DIMENSION || height > BROWSER_FRAME_MAX_DIMENSION || width * height > BROWSER_FRAME_MAX_PIXELS) {
+    throw new Error("browser image dimensions exceed their bounded envelope");
+  }
+}
+function pngDimensions(data) {
+  const signature = [137, 80, 78, 71, 13, 10, 26, 10];
+  if (data.byteLength < 24 || !signature.every((byte, index) => data[index] === byte) || String.fromCharCode(...data.slice(12, 16)) !== "IHDR") {
+    throw new Error("browser returned an invalid PNG image");
+  }
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  return { width: view.getUint32(16), height: view.getUint32(20) };
+}
+function jpegDimensions(data) {
+  if (data.byteLength < 4 || data[0] !== 255 || data[1] !== 216) {
+    throw new Error("browser returned an invalid JPEG image");
+  }
+  let offset = 2;
+  while (offset + 3 < data.byteLength) {
+    if (data[offset] !== 255) {
+      offset += 1;
+      continue;
+    }
+    let marker = data[offset + 1];
+    while (marker === 255) {
+      offset += 1;
+      marker = data[offset + 1];
+    }
+    if (marker === 216 || marker === 217 || marker === 1 || marker >= 208 && marker <= 215) {
+      offset += 2;
+      continue;
+    }
+    if (offset + 3 >= data.byteLength) break;
+    const length = data[offset + 2] << 8 | data[offset + 3];
+    if (length < 2 || offset + 2 + length > data.byteLength) break;
+    if (isJpegStartOfFrame(marker)) {
+      if (length < 7 || offset + 8 >= data.byteLength) break;
+      return {
+        height: data[offset + 5] << 8 | data[offset + 6],
+        width: data[offset + 7] << 8 | data[offset + 8]
+      };
+    }
+    offset += 2 + length;
+  }
+  throw new Error("browser returned a JPEG without dimensions");
+}
+function isJpegStartOfFrame(marker) {
+  return marker >= 192 && marker <= 195 || marker >= 197 && marker <= 199 || marker >= 201 && marker <= 203 || marker >= 205 && marker <= 207;
+}
+function utf8Bytes(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+async function sha256Hex(value) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw new Error("computer frame digest verification is unavailable");
+  const copy = new Uint8Array(value.byteLength);
+  copy.set(value);
+  const digest = new Uint8Array(await subtle.digest("SHA-256", copy));
+  return [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function isUuid(value) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  INTERACTION_PROTOCOL_VERSION,
+  BROWSER_CONTROL_WEBSOCKET_PROTOCOL,
+  COMPUTER_CONTROL_WEBSOCKET_PROTOCOL,
+  BROWSER_CONTROL_WEBSOCKET_BEARER_PREFIX,
+  BROWSER_CONTROL_MAX_FRAME_HEADER_BYTES,
+  BROWSER_FRAME_MAX_BYTES,
+  BROWSER_FRAME_MAX_DIMENSION,
+  BROWSER_FRAME_MAX_PIXELS,
+  OpenGeniInteractionClient,
+  NetworkRouteCollection,
+  NetworkRouteResource,
+  SiteAuthConnectionCollection,
+  SiteAuthConnectionResource,
+  AuthRunCollection,
+  BrowserAuthRunCollection,
+  AuthRunResource,
+  InteractionInterventionCollection,
+  InteractionInterventionResource,
+  AttachedBrowserDeviceCollection,
+  AttachedBrowserDeviceResource,
+  BrowserIdentityCollection,
+  BrowserIdentityResource,
+  BrowserSessionCollection,
+  BrowserSessionResource,
+  BrowserClipboardResource,
+  BrowserDownloadCollection,
+  BrowserDownloadResource,
+  BrowserTargetCollection,
+  ComputerSessionCollection,
+  ComputerSessionResource,
+  ComputerClipboardResource,
+  ComputerTargetCollection,
+  browserFrameSocketUrl,
+  computerFrameSocketUrl,
+  decodeBrowserFrameMessage,
+  decodeComputerFrameMessage,
+  parseBrowserFrameMetadata,
+  parseComputerFrameMetadata
+};
+//# sourceMappingURL=chunk-ST5DDKJP.js.map