@ricsam/r5d-browser 0.0.136 → 0.0.138

package/dist/cjs/port-forward-manager.cjs

@@ -1,233 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var port_forward_manager_exports = {};
-__export(port_forward_manager_exports, {
-  BrowserPortForwardManager: () => BrowserPortForwardManager
-});
-module.exports = __toCommonJS(port_forward_manager_exports);
-var import_node_net = __toESM(require("node:net"), 1);
-var import_ws = __toESM(require("ws"), 1);
-const RELAY_FRAME_BYTES = 64 * 1024;
-const RELAY_PAUSE_BYTES = 1024 * 1024;
-const RELAY_RESUME_BYTES = 256 * 1024;
-function relayUrl(baseUrl, instanceId, forwardId, relayConnectionId) {
-  const url = new URL("/browser/port-forward/ws", baseUrl);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  url.searchParams.set("instance", instanceId);
-  url.searchParams.set("forward", forwardId);
-  url.searchParams.set("connection", relayConnectionId);
-  return url.toString();
-}
-async function listen(server, port, host, ipv6Only = false) {
-  await new Promise((resolve, reject) => {
-    const onError = (error) => {
-      server.off("listening", onListening);
-      reject(error);
-    };
-    const onListening = () => {
-      server.off("error", onError);
-      resolve();
-    };
-    server.once("error", onError);
-    server.once("listening", onListening);
-    server.listen({ port, host, ipv6Only, exclusive: true });
-  });
-}
-async function closeServer(server) {
-  if (!server.listening) return;
-  await new Promise((resolve) => server.close(() => resolve()));
-}
-function rawDataBuffer(data) {
-  if (Buffer.isBuffer(data)) return data;
-  if (Array.isArray(data)) return Buffer.concat(data);
-  return Buffer.from(data);
-}
-class BrowserPortForwardManager {
-  constructor(baseUrl, token, instanceId) {
-    this.baseUrl = baseUrl;
-    this.token = token;
-    this.instanceId = instanceId;
-  }
-  baseUrl;
-  token;
-  instanceId;
-  forwards = /* @__PURE__ */ new Map();
-  forwardByBrowserPort = /* @__PURE__ */ new Map();
-  operationQueue = Promise.resolve();
-  list() {
-    return [...this.forwards.values()].map(({ definition }) => ({ ...definition }));
-  }
-  start(definition) {
-    return this.enqueue(() => this.startNow(definition));
-  }
-  stop(forwardId) {
-    return this.enqueue(() => this.stopNow(forwardId));
-  }
-  close() {
-    return this.enqueue(async () => {
-      for (const forwardId of [...this.forwards.keys()]) await this.stopNow(forwardId);
-    });
-  }
-  enqueue(operation) {
-    const result = this.operationQueue.then(operation, operation);
-    this.operationQueue = result.then(
-      () => void 0,
-      () => void 0
-    );
-    return result;
-  }
-  async startNow(definition) {
-    const existing = this.forwards.get(definition.forwardId);
-    if (existing) {
-      if (JSON.stringify(existing.definition) === JSON.stringify(definition)) return;
-      throw new Error(`Port forward ${definition.forwardId} already exists with different settings.`);
-    }
-    const occupyingId = this.forwardByBrowserPort.get(definition.browserPort);
-    if (occupyingId) throw new Error(`Browser port ${definition.browserPort} is already used by forward ${occupyingId}.`);
-    const active = { definition: { ...definition }, servers: [], relays: /* @__PURE__ */ new Set() };
-    const accept = (socket) => this.acceptConnection(active, socket);
-    const ipv4 = import_node_net.default.createServer({ allowHalfOpen: true }, accept);
-    const ipv6 = import_node_net.default.createServer({ allowHalfOpen: true }, accept);
-    const servers = [ipv4, ipv6];
-    active.servers = servers;
-    try {
-      await listen(ipv4, definition.browserPort, "127.0.0.1");
-      await listen(ipv6, definition.browserPort, "::1", true);
-    } catch (error) {
-      await Promise.all(servers.map(closeServer));
-      throw new Error(
-        `Could not bind localhost:${definition.browserPort}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    this.forwards.set(definition.forwardId, active);
-    this.forwardByBrowserPort.set(definition.browserPort, definition.forwardId);
-  }
-  async stopNow(forwardId) {
-    const active = this.forwards.get(forwardId);
-    if (!active) return;
-    this.forwards.delete(forwardId);
-    this.forwardByBrowserPort.delete(active.definition.browserPort);
-    for (const connection of active.relays) {
-      connection.socket.destroy();
-      connection.relay.close(1e3, "Port forward stopped");
-    }
-    active.relays.clear();
-    await Promise.all(active.servers.map(closeServer));
-  }
-  acceptConnection(active, socket) {
-    socket.pause();
-    socket.setNoDelay(true);
-    const relayConnectionId = crypto.randomUUID();
-    const relay = new import_ws.default(relayUrl(this.baseUrl, this.instanceId, active.definition.forwardId, relayConnectionId), {
-      headers: { Authorization: `Bearer ${this.token}` },
-      perMessageDeflate: false
-    });
-    const connection = { socket, relay };
-    active.relays.add(connection);
-    let ready = false;
-    const pendingChunks = [];
-    let pendingBytes = 0;
-    let resumeTimer;
-    let closing = false;
-    const cleanup = () => {
-      if (closing) return;
-      closing = true;
-      if (resumeTimer) clearInterval(resumeTimer);
-      active.relays.delete(connection);
-      socket.destroy();
-      if (relay.readyState === import_ws.default.OPEN || relay.readyState === import_ws.default.CONNECTING) relay.close();
-    };
-    const waitForRelayDrain = () => {
-      if (resumeTimer || relay.bufferedAmount <= RELAY_PAUSE_BYTES) return;
-      socket.pause();
-      resumeTimer = setInterval(() => {
-        if (relay.readyState !== import_ws.default.OPEN) return cleanup();
-        if (relay.bufferedAmount > RELAY_RESUME_BYTES) return;
-        clearInterval(resumeTimer);
-        resumeTimer = void 0;
-        if (ready) socket.resume();
-      }, 10);
-    };
-    const sendChunk = (chunk) => {
-      for (let offset = 0; offset < chunk.byteLength; offset += RELAY_FRAME_BYTES) {
-        relay.send(chunk.subarray(offset, Math.min(chunk.byteLength, offset + RELAY_FRAME_BYTES)), { binary: true });
-      }
-      waitForRelayDrain();
-    };
-    relay.on("message", (data, isBinary) => {
-      if (!isBinary) {
-        let control;
-        try {
-          control = JSON.parse(rawDataBuffer(data).toString("utf8"));
-        } catch {
-          return cleanup();
-        }
-        if (control.type === "ready") {
-          ready = true;
-          for (const chunk of pendingChunks.splice(0)) sendChunk(chunk);
-          pendingBytes = 0;
-          socket.resume();
-        } else if (control.type === "end") {
-          socket.end();
-        } else if (control.type === "error") {
-          socket.destroy(new Error(control.error || "Port-forward relay failed."));
-        }
-        return;
-      }
-      if (!socket.write(rawDataBuffer(data))) {
-        relay.pause();
-        socket.once("drain", () => relay.resume());
-      }
-    });
-    relay.on("error", cleanup);
-    relay.once("close", cleanup);
-    socket.on("data", (chunk) => {
-      if (!ready || relay.readyState !== import_ws.default.OPEN) {
-        pendingBytes += chunk.byteLength;
-        if (pendingBytes > RELAY_PAUSE_BYTES) return cleanup();
-        pendingChunks.push(Buffer.from(chunk));
-        socket.pause();
-        return;
-      }
-      sendChunk(chunk);
-    });
-    socket.on("end", () => {
-      if (relay.readyState === import_ws.default.OPEN) relay.send(JSON.stringify({ type: "end" }));
-    });
-    socket.on("error", (error) => {
-      if (relay.readyState === import_ws.default.OPEN) relay.send(JSON.stringify({ type: "error", error: error.message }));
-    });
-    socket.on("close", cleanup);
-    socket.pause();
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BrowserPortForwardManager
-});

package/dist/cjs/upload-store.cjs

@@ -1,136 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var upload_store_exports = {};
-__export(upload_store_exports, {
-  BrowserUploadStore: () => BrowserUploadStore
-});
-module.exports = __toCommonJS(upload_store_exports);
-var import_node_fs = __toESM(require("node:fs"), 1);
-var import_node_path = __toESM(require("node:path"), 1);
-var import_node_crypto = require("node:crypto");
-var import_browser_upload = require("@ricsam/r5d-api/browser-upload");
-class BrowserUploadStore {
-  constructor(root, releaseTarget = () => void 0) {
-    this.releaseTarget = releaseTarget;
-    import_node_fs.default.mkdirSync(root, { recursive: true, mode: 448 });
-    this.directory = import_node_fs.default.mkdtempSync(import_node_path.default.join(root, "run-"));
-  }
-  releaseTarget;
-  directory;
-  uploads = /* @__PURE__ */ new Map();
-  begin(id, tabId, files, target) {
-    if (typeof id !== "string" || !/^[a-f0-9-]{36}$/.test(id) || this.uploads.has(id)) throw new Error("Invalid or duplicate upload id.");
-    if (!Array.isArray(files) || files.length === 0 || files.length > 100) throw new Error("Upload requires between 1 and 100 files.");
-    const metadata = files.map(import_browser_upload.validateUploadFile);
-    const directory = import_node_fs.default.mkdtempSync(import_node_path.default.join(this.directory, "upload-"));
-    try {
-      const staged = metadata.map((file, index) => {
-        const parent = import_node_path.default.join(directory, String(index));
-        import_node_fs.default.mkdirSync(parent, { mode: 448 });
-        const filePath = import_node_path.default.join(parent, file.filename);
-        import_node_fs.default.closeSync(import_node_fs.default.openSync(filePath, "wx", 384));
-        return { ...file, path: filePath, offset: 0, hash: (0, import_node_crypto.createHash)("sha256") };
-      });
-      const timer = setTimeout(() => this.abort(id, tabId), 5 * 60 * 1e3);
-      timer.unref();
-      this.uploads.set(id, { tabId, directory, files: staged, target, attached: false, timer });
-    } catch (error) {
-      import_node_fs.default.rmSync(directory, { recursive: true, force: true });
-      throw error;
-    }
-  }
-  get(id, tabId) {
-    const upload = typeof id === "string" ? this.uploads.get(id) : void 0;
-    if (!upload || upload.tabId !== tabId) throw new Error("Upload is missing, expired, or belongs to another tab.");
-    if (upload.attached) throw new Error("Upload has already been attached.");
-    upload.timer.refresh();
-    return upload;
-  }
-  append(id, tabId, index, offset, base64) {
-    const upload = this.get(id, tabId);
-    const file = typeof index === "number" && Number.isInteger(index) ? upload.files[index] : void 0;
-    if (!file || offset !== file.offset) throw new Error("Invalid upload file index or chunk offset.");
-    const bytes = (0, import_browser_upload.decodeUploadChunk)(base64);
-    if (bytes.length === 0 || file.offset + bytes.length > file.size)
-      throw new Error("Upload chunk does not match the declared file size.");
-    const fd = import_node_fs.default.openSync(file.path, import_node_fs.default.constants.O_WRONLY | import_node_fs.default.constants.O_NOFOLLOW);
-    try {
-      let written = 0;
-      while (written < bytes.length) {
-        const count = import_node_fs.default.writeSync(fd, bytes, written, bytes.length - written, file.offset + written);
-        if (!count) throw new Error("Could not write upload chunk.");
-        written += count;
-      }
-    } finally {
-      import_node_fs.default.closeSync(fd);
-    }
-    file.hash.update(bytes);
-    file.offset += bytes.length;
-  }
-  ready(id, tabId, hashes) {
-    const upload = this.get(id, tabId);
-    if (!Array.isArray(hashes) || hashes.length !== upload.files.length) throw new Error("Upload requires a checksum for every file.");
-    for (const [index, file] of upload.files.entries()) {
-      if (file.offset !== file.size || file.hash.copy().digest("hex") !== hashes[index])
-        throw new Error("Upload is incomplete or its checksum does not match.");
-    }
-    return {
-      target: upload.target,
-      paths: upload.files.map((file) => file.path),
-      files: upload.files.map(({ filename, size }) => ({ filename, size }))
-    };
-  }
-  attached(id, tabId) {
-    const upload = this.get(id, tabId);
-    upload.attached = true;
-    clearTimeout(upload.timer);
-  }
-  abort(id, tabId) {
-    const upload = this.uploads.get(id);
-    if (!upload || upload.tabId !== tabId || upload.attached) return;
-    this.remove(id, upload);
-  }
-  remove(id, upload) {
-    clearTimeout(upload.timer);
-    this.uploads.delete(id);
-    this.releaseTarget(upload.target);
-    import_node_fs.default.rmSync(upload.directory, { recursive: true, force: true });
-  }
-  closeTab(tabId) {
-    for (const [id, upload] of this.uploads) if (upload.tabId === tabId) this.remove(id, upload);
-  }
-  close() {
-    for (const [id, upload] of this.uploads) this.remove(id, upload);
-    import_node_fs.default.rmSync(this.directory, { recursive: true, force: true });
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BrowserUploadStore
-});

package/dist/mjs/port-forward-manager.mjs

@@ -1,199 +0,0 @@
-import net, {} from "node:net";
-import WebSocket, {} from "ws";
-const RELAY_FRAME_BYTES = 64 * 1024;
-const RELAY_PAUSE_BYTES = 1024 * 1024;
-const RELAY_RESUME_BYTES = 256 * 1024;
-function relayUrl(baseUrl, instanceId, forwardId, relayConnectionId) {
-  const url = new URL("/browser/port-forward/ws", baseUrl);
-  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-  url.searchParams.set("instance", instanceId);
-  url.searchParams.set("forward", forwardId);
-  url.searchParams.set("connection", relayConnectionId);
-  return url.toString();
-}
-async function listen(server, port, host, ipv6Only = false) {
-  await new Promise((resolve, reject) => {
-    const onError = (error) => {
-      server.off("listening", onListening);
-      reject(error);
-    };
-    const onListening = () => {
-      server.off("error", onError);
-      resolve();
-    };
-    server.once("error", onError);
-    server.once("listening", onListening);
-    server.listen({ port, host, ipv6Only, exclusive: true });
-  });
-}
-async function closeServer(server) {
-  if (!server.listening) return;
-  await new Promise((resolve) => server.close(() => resolve()));
-}
-function rawDataBuffer(data) {
-  if (Buffer.isBuffer(data)) return data;
-  if (Array.isArray(data)) return Buffer.concat(data);
-  return Buffer.from(data);
-}
-class BrowserPortForwardManager {
-  constructor(baseUrl, token, instanceId) {
-    this.baseUrl = baseUrl;
-    this.token = token;
-    this.instanceId = instanceId;
-  }
-  baseUrl;
-  token;
-  instanceId;
-  forwards = /* @__PURE__ */ new Map();
-  forwardByBrowserPort = /* @__PURE__ */ new Map();
-  operationQueue = Promise.resolve();
-  list() {
-    return [...this.forwards.values()].map(({ definition }) => ({ ...definition }));
-  }
-  start(definition) {
-    return this.enqueue(() => this.startNow(definition));
-  }
-  stop(forwardId) {
-    return this.enqueue(() => this.stopNow(forwardId));
-  }
-  close() {
-    return this.enqueue(async () => {
-      for (const forwardId of [...this.forwards.keys()]) await this.stopNow(forwardId);
-    });
-  }
-  enqueue(operation) {
-    const result = this.operationQueue.then(operation, operation);
-    this.operationQueue = result.then(
-      () => void 0,
-      () => void 0
-    );
-    return result;
-  }
-  async startNow(definition) {
-    const existing = this.forwards.get(definition.forwardId);
-    if (existing) {
-      if (JSON.stringify(existing.definition) === JSON.stringify(definition)) return;
-      throw new Error(`Port forward ${definition.forwardId} already exists with different settings.`);
-    }
-    const occupyingId = this.forwardByBrowserPort.get(definition.browserPort);
-    if (occupyingId) throw new Error(`Browser port ${definition.browserPort} is already used by forward ${occupyingId}.`);
-    const active = { definition: { ...definition }, servers: [], relays: /* @__PURE__ */ new Set() };
-    const accept = (socket) => this.acceptConnection(active, socket);
-    const ipv4 = net.createServer({ allowHalfOpen: true }, accept);
-    const ipv6 = net.createServer({ allowHalfOpen: true }, accept);
-    const servers = [ipv4, ipv6];
-    active.servers = servers;
-    try {
-      await listen(ipv4, definition.browserPort, "127.0.0.1");
-      await listen(ipv6, definition.browserPort, "::1", true);
-    } catch (error) {
-      await Promise.all(servers.map(closeServer));
-      throw new Error(
-        `Could not bind localhost:${definition.browserPort}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-    this.forwards.set(definition.forwardId, active);
-    this.forwardByBrowserPort.set(definition.browserPort, definition.forwardId);
-  }
-  async stopNow(forwardId) {
-    const active = this.forwards.get(forwardId);
-    if (!active) return;
-    this.forwards.delete(forwardId);
-    this.forwardByBrowserPort.delete(active.definition.browserPort);
-    for (const connection of active.relays) {
-      connection.socket.destroy();
-      connection.relay.close(1e3, "Port forward stopped");
-    }
-    active.relays.clear();
-    await Promise.all(active.servers.map(closeServer));
-  }
-  acceptConnection(active, socket) {
-    socket.pause();
-    socket.setNoDelay(true);
-    const relayConnectionId = crypto.randomUUID();
-    const relay = new WebSocket(relayUrl(this.baseUrl, this.instanceId, active.definition.forwardId, relayConnectionId), {
-      headers: { Authorization: `Bearer ${this.token}` },
-      perMessageDeflate: false
-    });
-    const connection = { socket, relay };
-    active.relays.add(connection);
-    let ready = false;
-    const pendingChunks = [];
-    let pendingBytes = 0;
-    let resumeTimer;
-    let closing = false;
-    const cleanup = () => {
-      if (closing) return;
-      closing = true;
-      if (resumeTimer) clearInterval(resumeTimer);
-      active.relays.delete(connection);
-      socket.destroy();
-      if (relay.readyState === WebSocket.OPEN || relay.readyState === WebSocket.CONNECTING) relay.close();
-    };
-    const waitForRelayDrain = () => {
-      if (resumeTimer || relay.bufferedAmount <= RELAY_PAUSE_BYTES) return;
-      socket.pause();
-      resumeTimer = setInterval(() => {
-        if (relay.readyState !== WebSocket.OPEN) return cleanup();
-        if (relay.bufferedAmount > RELAY_RESUME_BYTES) return;
-        clearInterval(resumeTimer);
-        resumeTimer = void 0;
-        if (ready) socket.resume();
-      }, 10);
-    };
-    const sendChunk = (chunk) => {
-      for (let offset = 0; offset < chunk.byteLength; offset += RELAY_FRAME_BYTES) {
-        relay.send(chunk.subarray(offset, Math.min(chunk.byteLength, offset + RELAY_FRAME_BYTES)), { binary: true });
-      }
-      waitForRelayDrain();
-    };
-    relay.on("message", (data, isBinary) => {
-      if (!isBinary) {
-        let control;
-        try {
-          control = JSON.parse(rawDataBuffer(data).toString("utf8"));
-        } catch {
-          return cleanup();
-        }
-        if (control.type === "ready") {
-          ready = true;
-          for (const chunk of pendingChunks.splice(0)) sendChunk(chunk);
-          pendingBytes = 0;
-          socket.resume();
-        } else if (control.type === "end") {
-          socket.end();
-        } else if (control.type === "error") {
-          socket.destroy(new Error(control.error || "Port-forward relay failed."));
-        }
-        return;
-      }
-      if (!socket.write(rawDataBuffer(data))) {
-        relay.pause();
-        socket.once("drain", () => relay.resume());
-      }
-    });
-    relay.on("error", cleanup);
-    relay.once("close", cleanup);
-    socket.on("data", (chunk) => {
-      if (!ready || relay.readyState !== WebSocket.OPEN) {
-        pendingBytes += chunk.byteLength;
-        if (pendingBytes > RELAY_PAUSE_BYTES) return cleanup();
-        pendingChunks.push(Buffer.from(chunk));
-        socket.pause();
-        return;
-      }
-      sendChunk(chunk);
-    });
-    socket.on("end", () => {
-      if (relay.readyState === WebSocket.OPEN) relay.send(JSON.stringify({ type: "end" }));
-    });
-    socket.on("error", (error) => {
-      if (relay.readyState === WebSocket.OPEN) relay.send(JSON.stringify({ type: "error", error: error.message }));
-    });
-    socket.on("close", cleanup);
-    socket.pause();
-  }
-}
-export {
-  BrowserPortForwardManager
-};

package/dist/types/port-forward-manager.d.ts

@@ -1,23 +0,0 @@
-export type BrowserPortForwardDefinition = {
-    forwardId: string;
-    workerLabel: string;
-    workerPort: number;
-    browserPort: number;
-};
-export declare class BrowserPortForwardManager {
-    private readonly baseUrl;
-    private readonly token;
-    private readonly instanceId;
-    private readonly forwards;
-    private readonly forwardByBrowserPort;
-    private operationQueue;
-    constructor(baseUrl: string, token: string, instanceId: string);
-    list(): BrowserPortForwardDefinition[];
-    start(definition: BrowserPortForwardDefinition): Promise<void>;
-    stop(forwardId: string): Promise<void>;
-    close(): Promise<void>;
-    private enqueue;
-    private startNow;
-    private stopNow;
-    private acceptConnection;
-}