@volter/tabnode 0.5.25 → 0.5.27

package/dist/port-bridge-CixAESwA.js

@@ -0,0 +1,655 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const CHUNK = 8192;
+function uint8ToBase64(bytes) {
+  const parts = [];
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    parts.push(String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK))));
+  }
+  return btoa(parts.join(""));
+}
+function base64ToUint8(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function uint8ToHex(bytes) {
+  const hex = new Array(bytes.length);
+  for (let i = 0; i < bytes.length; i++) {
+    hex[i] = bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex.join("");
+}
+function uint8ToBinaryString(bytes) {
+  const parts = [];
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    parts.push(String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK))));
+  }
+  return parts.join("");
+}
+const _encoder = new TextEncoder();
+const FLOW_MAX_REQUEST_BYTES = 64 * 1024 * 1024;
+const FLOW_MAX_CHUNK_BYTES = 65536;
+const FLOW_QUEUED_CHUNKS = 4;
+function ownedBytes(view) {
+  const copy = new Uint8Array(view.byteLength);
+  copy.set(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
+  return copy;
+}
+class BridgeEvents {
+  constructor() {
+    __publicField(this, "listenersByEvent", /* @__PURE__ */ new Map());
+  }
+  on(event, listener) {
+    const list = this.listenersByEvent.get(event) ?? [];
+    list.push(listener);
+    this.listenersByEvent.set(event, list);
+    return this;
+  }
+  addListener(event, listener) {
+    return this.on(event, listener);
+  }
+  once(event, listener) {
+    const wrapped = (...args) => {
+      this.off(event, wrapped);
+      listener(...args);
+    };
+    wrapped.listener = listener;
+    return this.on(event, wrapped);
+  }
+  off(event, listener) {
+    const list = this.listenersByEvent.get(event);
+    if (!list) return this;
+    const at = list.findIndex((candidate) => candidate === listener || candidate.listener === listener);
+    if (at >= 0) list.splice(at, 1);
+    if (list.length === 0) this.listenersByEvent.delete(event);
+    return this;
+  }
+  removeListener(event, listener) {
+    return this.off(event, listener);
+  }
+  removeAllListeners(event) {
+    if (event === void 0) this.listenersByEvent.clear();
+    else this.listenersByEvent.delete(event);
+    return this;
+  }
+  listenerCount(event) {
+    var _a;
+    return ((_a = this.listenersByEvent.get(event)) == null ? void 0 : _a.length) ?? 0;
+  }
+  emit(event, ...args) {
+    const list = this.listenersByEvent.get(event);
+    if (!list || list.length === 0) return false;
+    for (const listener of [...list]) listener(...args);
+    return true;
+  }
+}
+const _PortBridge = class _PortBridge extends BridgeEvents {
+  constructor(options = {}) {
+    super();
+    __publicField(this, "servers", /* @__PURE__ */ new Map());
+    __publicField(this, "baseUrl");
+    __publicField(this, "options");
+    __publicField(this, "messageChannel", null);
+    __publicField(this, "serviceWorkerReady", false);
+    __publicField(this, "keepaliveInterval", null);
+    /** The server the service worker answers at the origin's root, the preview's; null for none. */
+    __publicField(this, "primaryPort", null);
+    __publicField(this, "ownDocuments");
+    /** Flow-controlled requests in flight: a pull is one chunk's credit, a cancel ends the upstream. */
+    __publicField(this, "controlledStreams", /* @__PURE__ */ new Map());
+    this.options = options;
+    if (typeof location !== "undefined") {
+      this.baseUrl = options.baseUrl || `${location.protocol}//${location.host}`;
+    } else {
+      this.baseUrl = options.baseUrl || "http://localhost";
+    }
+  }
+  /**
+   * Give back everything this bridge opened: the service worker keepalive,
+   * and in an engine's bridge its upgrade channel. A host that is done with a
+   * container calls it and has its process back; calling it twice is nothing.
+   */
+  close() {
+    if (this.keepaliveInterval !== null) {
+      clearInterval(this.keepaliveInterval);
+      this.keepaliveInterval = null;
+    }
+  }
+  /**
+   * Register a server on a port
+   */
+  registerServer(server, port, hostname = "0.0.0.0") {
+    this.servers.set(port, { server, port, hostname });
+    const url = this.getServerUrl(port);
+    this.emit("server-ready", port, url);
+    if (this.options.onServerReady) {
+      this.options.onServerReady(port, url);
+    }
+    this.notifyServiceWorker("server-registered", { port, hostname, primary: port === this.primaryPort });
+  }
+  /**
+   * Unregister a server
+   */
+  unregisterServer(port) {
+    this.servers.delete(port);
+    if (this.primaryPort === port) this.primaryPort = null;
+    this.notifyServiceWorker("server-unregistered", { port });
+  }
+  /**
+   * Names the server the service worker serves at the origin's root, as an
+   * app is served at its own origin's root: its documents read their routes
+   * from `location.pathname`, which under /__virtual__/<port>/ is not the
+   * path they expect. Told to the worker now and again whenever the worker
+   * is (re)initialized, since a worker that restarted remembers nothing.
+   */
+  setPrimaryPort(port) {
+    const previous = this.primaryPort;
+    this.primaryPort = port;
+    if (previous !== null && previous !== port) {
+      const entry = this.servers.get(previous);
+      if (entry) this.notifyServiceWorker("server-registered", { port: previous, hostname: entry.hostname, primary: false });
+    }
+    if (port !== null) {
+      const entry = this.servers.get(port);
+      this.notifyServiceWorker("server-registered", { port, hostname: (entry == null ? void 0 : entry.hostname) ?? "0.0.0.0", primary: true });
+    }
+  }
+  /** Every registration the worker should hold, sent again to a worker that was (re)initialized. */
+  announceServers() {
+    if (this.ownDocuments) this.notifyServiceWorker("own-documents", { paths: this.ownDocuments });
+    for (const [port, entry] of this.servers) {
+      this.notifyServiceWorker("server-registered", { port, hostname: entry.hostname, primary: port === this.primaryPort });
+    }
+  }
+  /**
+   * Get server URL for a port
+   */
+  getServerUrl(port) {
+    return `${this.baseUrl}/__virtual__/${port}`;
+  }
+  /**
+   * Get all registered server ports
+   */
+  getServerPorts() {
+    return [...this.servers.keys()];
+  }
+  /**
+   * Handle an incoming request from Service Worker
+   */
+  async handleRequest(port, method, url, headers, body) {
+    const virtualServer = this.servers.get(port);
+    if (!virtualServer) {
+      return {
+        statusCode: 503,
+        statusMessage: "Service Unavailable",
+        headers: { "Content-Type": "text/plain" },
+        body: _encoder.encode(`No server listening on port ${port}`)
+      };
+    }
+    try {
+      const bodyBuffer = body ? this.bodyOf(new Uint8Array(body)) : void 0;
+      const named = Object.keys(headers).some((name) => name.toLowerCase() === "host");
+      const authority = `${virtualServer.hostname && virtualServer.hostname !== "0.0.0.0" && virtualServer.hostname !== "::" ? virtualServer.hostname : "127.0.0.1"}:${port}`;
+      const withHost = named ? headers : { ...headers, host: authority };
+      if (virtualServer.server) return await virtualServer.server.handleRequest(method, url, withHost, bodyBuffer);
+      return await this.requestGuest(port, method, url, withHost, bodyBuffer);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal Server Error";
+      return {
+        statusCode: 500,
+        statusMessage: "Internal Server Error",
+        headers: { "Content-Type": "text/plain" },
+        body: _encoder.encode(message)
+      };
+    }
+  }
+  /**
+   * Initialize Service Worker communication
+   * @param options - Configuration options for the service worker
+   * @param options.swUrl - Custom URL path to the service worker file (default: '/__sw__.js')
+   */
+  async initServiceWorker(options) {
+    if (!("serviceWorker" in navigator)) {
+      throw new Error("Service Workers not supported");
+    }
+    const swUrl = (options == null ? void 0 : options.swUrl) ?? "/__sw__.js";
+    const controllerReady = navigator.serviceWorker.controller ? Promise.resolve() : new Promise((resolve) => {
+      navigator.serviceWorker.addEventListener("controllerchange", () => resolve(), { once: true });
+    });
+    const registration = await navigator.serviceWorker.register(swUrl, {
+      scope: "/"
+    });
+    const sw = registration.active || registration.waiting || registration.installing;
+    if (!sw) {
+      throw new Error("Service Worker registration failed");
+    }
+    await new Promise((resolve) => {
+      if (sw.state === "activated") {
+        resolve();
+      } else {
+        const handler = () => {
+          if (sw.state === "activated") {
+            sw.removeEventListener("statechange", handler);
+            resolve();
+          }
+        };
+        sw.addEventListener("statechange", handler);
+      }
+    });
+    this.messageChannel = new MessageChannel();
+    this.messageChannel.port1.onmessage = this.handleServiceWorkerMessage.bind(this);
+    this.ownDocuments = options == null ? void 0 : options.ownDocuments;
+    sw.postMessage({ type: "init", port: this.messageChannel.port2, data: { ownDocuments: this.ownDocuments ?? [] } }, [
+      this.messageChannel.port2
+    ]);
+    await controllerReady;
+    const reinit = () => {
+      if (navigator.serviceWorker.controller) {
+        for (const stream of [...this.controlledStreams.values()]) stream.cancel();
+        this.messageChannel = new MessageChannel();
+        this.messageChannel.port1.onmessage = this.handleServiceWorkerMessage.bind(this);
+        navigator.serviceWorker.controller.postMessage(
+          { type: "init", port: this.messageChannel.port2, data: { ownDocuments: this.ownDocuments ?? [] } },
+          [this.messageChannel.port2]
+        );
+        this.announceServers();
+      }
+    };
+    navigator.serviceWorker.addEventListener("controllerchange", reinit);
+    navigator.serviceWorker.addEventListener("message", (event) => {
+      var _a;
+      if (((_a = event.data) == null ? void 0 : _a.type) === "sw-needs-init") {
+        reinit();
+      }
+    });
+    this.keepaliveInterval = setInterval(() => {
+      var _a;
+      (_a = this.messageChannel) == null ? void 0 : _a.port1.postMessage({ type: "keepalive" });
+    }, 2e4);
+    this.serviceWorkerReady = true;
+    this.announceServers();
+    this.emit("sw-ready");
+  }
+  /**
+   * Handle messages from Service Worker
+   */
+  async handleServiceWorkerMessage(event) {
+    var _a, _b, _c;
+    const { type, id, data } = event.data;
+    _PortBridge.DEBUG && console.log("[ServerBridge] SW message:", type, id, data == null ? void 0 : data.url);
+    if (type === "stream-pull" || type === "stream-cancel") {
+      const stream = this.controlledStreams.get(id);
+      if (type === "stream-pull") stream == null ? void 0 : stream.pull();
+      else stream == null ? void 0 : stream.cancel();
+      return;
+    }
+    if (type === "request" && (data == null ? void 0 : data.flowControl) === 1) {
+      const { port, method, url, headers, body } = data;
+      await this.controlledStream(id, port, method, url, headers, body);
+      return;
+    }
+    if (type === "request") {
+      const { port, method, url, headers, body, streaming } = data;
+      _PortBridge.DEBUG && console.log("[ServerBridge] Handling request:", port, method, url, "streaming:", streaming);
+      if (streaming) {
+        _PortBridge.DEBUG && console.log("[ServerBridge] 🔴 Will use streaming handler");
+      }
+      try {
+        if (streaming) {
+          await this.streamToServiceWorker(id, port, method, url, headers, body);
+        } else {
+          const response = await this.handleRequest(port, method, url, headers, body);
+          _PortBridge.DEBUG && console.log("[ServerBridge] Response:", response.statusCode, "body length:", (_a = response.body) == null ? void 0 : _a.length);
+          let bodyBase64 = "";
+          if (response.body && response.body.length > 0) {
+            const bytes = response.body instanceof Uint8Array ? response.body : new Uint8Array(0);
+            bodyBase64 = uint8ToBase64(bytes);
+          }
+          _PortBridge.DEBUG && console.log("[ServerBridge] Sending response to SW, body base64 length:", bodyBase64.length);
+          (_b = this.messageChannel) == null ? void 0 : _b.port1.postMessage({
+            type: "response",
+            id,
+            data: {
+              statusCode: response.statusCode,
+              statusMessage: response.statusMessage,
+              headers: response.headers,
+              bodyBase64
+            }
+          });
+        }
+      } catch (error) {
+        (_c = this.messageChannel) == null ? void 0 : _c.port1.postMessage({
+          type: "response",
+          id,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+  }
+  /**
+   * Handle a streaming request - sends chunks as they arrive
+   */
+  /**
+   * A page-side request streamed to the caller as it arrives, the door a host
+   * reads a guest's server through when it wants chunks rather than a body:
+   * a guest's own server is reached over the loopback as any client reaches
+   * it; a server the host registered answers through its own streaming
+   * method where it has one, else its buffered answer is delivered whole.
+   */
+  async handleStreamingRequest(port, method, url, headers, body, callbacks, flow) {
+    const virtualServer = this.servers.get(port);
+    if (!virtualServer) return false;
+    const bodyBuffer = body ? this.bodyOf(new Uint8Array(body)) : void 0;
+    if (this.isGuest(virtualServer)) {
+      const named = Object.keys(headers).some((name) => name.toLowerCase() === "host");
+      const authority = `${virtualServer.hostname && virtualServer.hostname !== "0.0.0.0" && virtualServer.hostname !== "::" ? virtualServer.hostname : "127.0.0.1"}:${port}`;
+      await this.streamGuest(
+        port,
+        method,
+        url,
+        named ? headers : { ...headers, host: authority },
+        bodyBuffer,
+        (statusCode, statusMessage, respHeaders) => callbacks.start(statusCode, statusMessage, respHeaders),
+        (chunk) => callbacks.chunk(ownedBytes(chunk)),
+        () => callbacks.end(),
+        flow
+      );
+      return true;
+    }
+    const server = virtualServer.server;
+    if (typeof server.handleStreamingRequest === "function") {
+      await server.handleStreamingRequest(
+        method,
+        url,
+        headers,
+        bodyBuffer,
+        (statusCode, statusMessage, respHeaders) => callbacks.start(statusCode, statusMessage, respHeaders),
+        (chunk) => callbacks.chunk(typeof chunk === "string" ? _encoder.encode(chunk) : ownedBytes(chunk)),
+        () => callbacks.end(),
+        flow
+      );
+      return true;
+    }
+    const response = await this.handleRequest(port, method, url, headers, body);
+    callbacks.start(response.statusCode, response.statusMessage ?? "", response.headers);
+    if (response.body) {
+      const body2 = typeof response.body === "string" ? _encoder.encode(response.body) : response.body;
+      callbacks.chunk(ownedBytes(body2));
+    }
+    callbacks.end();
+    return true;
+  }
+  async streamToServiceWorker(id, port, method, url, headers, body) {
+    var _a, _b, _c, _d, _e;
+    const virtualServer = this.servers.get(port);
+    if (!virtualServer) {
+      (_a = this.messageChannel) == null ? void 0 : _a.port1.postMessage({
+        type: "stream-start",
+        id,
+        data: { statusCode: 503, statusMessage: "Service Unavailable", headers: {} }
+      });
+      (_b = this.messageChannel) == null ? void 0 : _b.port1.postMessage({ type: "stream-end", id });
+      return;
+    }
+    if (this.isGuest(virtualServer)) {
+      const bodyBuffer = body ? this.bodyOf(new Uint8Array(body)) : void 0;
+      const named = Object.keys(headers).some((name) => name.toLowerCase() === "host");
+      const authority = `${virtualServer.hostname && virtualServer.hostname !== "0.0.0.0" && virtualServer.hostname !== "::" ? virtualServer.hostname : "127.0.0.1"}:${port}`;
+      await this.streamGuest(
+        port,
+        method,
+        url,
+        named ? headers : { ...headers, host: authority },
+        bodyBuffer,
+        (statusCode, statusMessage, respHeaders) => {
+          var _a2;
+          (_a2 = this.messageChannel) == null ? void 0 : _a2.port1.postMessage({ type: "stream-start", id, data: { statusCode, statusMessage, headers: respHeaders } });
+        },
+        (chunk) => {
+          var _a2;
+          const copy = ownedBytes(chunk);
+          (_a2 = this.messageChannel) == null ? void 0 : _a2.port1.postMessage({ type: "stream-chunk", id, data: copy.buffer }, [copy.buffer]);
+        },
+        () => {
+          var _a2;
+          (_a2 = this.messageChannel) == null ? void 0 : _a2.port1.postMessage({ type: "stream-end", id });
+        }
+      );
+      return;
+    }
+    const server = virtualServer.server;
+    if (!server) return;
+    if (typeof server.handleStreamingRequest === "function") {
+      _PortBridge.DEBUG && console.log("[ServerBridge] 🟢 Server has streaming support, calling handleStreamingRequest");
+      const bodyBuffer = body ? this.bodyOf(new Uint8Array(body)) : void 0;
+      await server.handleStreamingRequest(
+        method,
+        url,
+        headers,
+        bodyBuffer,
+        // onStart - called with headers
+        (statusCode, statusMessage, respHeaders) => {
+          var _a2;
+          _PortBridge.DEBUG && console.log("[ServerBridge] 🟢 onStart called, sending stream-start");
+          (_a2 = this.messageChannel) == null ? void 0 : _a2.port1.postMessage({
+            type: "stream-start",
+            id,
+            data: { statusCode, statusMessage, headers: respHeaders }
+          });
+        },
+        // onChunk - called for each chunk
+        (chunk) => {
+          var _a2;
+          const bytes = typeof chunk === "string" ? _encoder.encode(chunk) : chunk;
+          const chunkBase64 = uint8ToBase64(bytes);
+          _PortBridge.DEBUG && console.log("[ServerBridge] 🟡 onChunk called, sending stream-chunk, size:", chunkBase64.length);
+          (_a2 = this.messageChannel) == null ? void 0 : _a2.port1.postMessage({
+            type: "stream-chunk",
+            id,
+            data: { chunkBase64 }
+          });
+        },
+        // onEnd - called when response is complete
+        () => {
+          var _a2;
+          _PortBridge.DEBUG && console.log("[ServerBridge] 🟢 onEnd called, sending stream-end");
+          (_a2 = this.messageChannel) == null ? void 0 : _a2.port1.postMessage({ type: "stream-end", id });
+        }
+      );
+    } else {
+      const bodyBuffer = body ? this.bodyOf(new Uint8Array(body)) : void 0;
+      const response = await server.handleRequest(method, url, headers, bodyBuffer);
+      (_c = this.messageChannel) == null ? void 0 : _c.port1.postMessage({
+        type: "stream-start",
+        id,
+        data: {
+          statusCode: response.statusCode,
+          statusMessage: response.statusMessage,
+          headers: response.headers
+        }
+      });
+      if (response.body && response.body.length > 0) {
+        const bytes = response.body instanceof Uint8Array ? response.body : new Uint8Array(0);
+        (_d = this.messageChannel) == null ? void 0 : _d.port1.postMessage({
+          type: "stream-chunk",
+          id,
+          data: { chunkBase64: uint8ToBase64(bytes) }
+        });
+      }
+      (_e = this.messageChannel) == null ? void 0 : _e.port1.postMessage({ type: "stream-end", id });
+    }
+  }
+  /**
+   * Send message to Service Worker
+   */
+  notifyServiceWorker(type, data) {
+    if (this.serviceWorkerReady && this.messageChannel) {
+      const flow = type === "server-registered" ? { flowControl: 1, maxRequestBytes: FLOW_MAX_REQUEST_BYTES, maxChunkBytes: FLOW_MAX_CHUNK_BYTES } : {};
+      this.messageChannel.port1.postMessage({ type, data: { ...data, ...flow } });
+    }
+  }
+  /**
+   * A request the worker sent under flow control: the response starts with
+   * its head, then goes one chunk (at most FLOW_MAX_CHUNK_BYTES) for each
+   * `stream-pull`, and ends with `stream-end` once the server finished and
+   * every chunk went out. The upstream connection is paused while chunks wait
+   * for credit, so a slow reader holds the server back; `stream-cancel` ends it.
+   */
+  async controlledStream(id, port, method, url, headers, body) {
+    const channel = this.messageChannel;
+    const post = (type, data) => {
+      channel == null ? void 0 : channel.port1.postMessage({ type, id, ...data === void 0 ? {} : { data } });
+    };
+    const queue = [];
+    const abort = new AbortController();
+    let credits = 0;
+    let upstreamEnded = false;
+    let finished = false;
+    let paused = false;
+    let pause = () => void 0;
+    let resume = () => void 0;
+    const finish = () => {
+      finished = true;
+      this.controlledStreams.delete(id);
+    };
+    const flush = () => {
+      if (finished) return;
+      while (credits > 0 && queue.length > 0) {
+        credits -= 1;
+        post("stream-chunk", { chunkBase64: uint8ToBase64(queue.shift()) });
+      }
+      if (upstreamEnded && queue.length === 0) {
+        post("stream-end");
+        finish();
+        return;
+      }
+      if (queue.length >= FLOW_QUEUED_CHUNKS && !paused) {
+        paused = true;
+        pause();
+      } else if (queue.length < FLOW_QUEUED_CHUNKS && paused) {
+        paused = false;
+        resume();
+      }
+    };
+    this.controlledStreams.set(id, {
+      pull: () => {
+        credits += 1;
+        flush();
+      },
+      cancel: () => {
+        if (finished) return;
+        finish();
+        queue.length = 0;
+        abort.abort();
+      }
+    });
+    try {
+      const answered = await this.handleStreamingRequest(port, method, url, headers, body, {
+        start: (statusCode, statusMessage, respHeaders) => post("stream-start", { statusCode, statusMessage, headers: respHeaders }),
+        chunk: (chunk) => {
+          if (finished) return;
+          for (let at = 0; at < chunk.byteLength; at += FLOW_MAX_CHUNK_BYTES) queue.push(chunk.slice(at, at + FLOW_MAX_CHUNK_BYTES));
+          flush();
+        },
+        end: () => {
+          upstreamEnded = true;
+          flush();
+        }
+      }, { signal: abort.signal, control: (p, r) => {
+        pause = p;
+        resume = r;
+      } });
+      if (!answered) {
+        post("stream-start", { statusCode: 503, statusMessage: "Service Unavailable", headers: {} });
+        post("stream-end");
+        finish();
+      }
+    } catch (error) {
+      if (!finished) {
+        post("stream-error", { message: error instanceof Error ? error.message : String(error) });
+        finish();
+      }
+    }
+  }
+  /**
+   * Create a mock request handler for testing without Service Worker
+   */
+  createFetchHandler() {
+    return async (request) => {
+      const url = new URL(request.url);
+      const match = url.pathname.match(/^\/__virtual__\/(\d+)(\/.*)?$/);
+      if (!match) {
+        throw new Error("Not a virtual server request");
+      }
+      const port = parseInt(match[1], 10);
+      const path = match[2] || "/";
+      const headers = {};
+      request.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      let body;
+      if (request.method !== "GET" && request.method !== "HEAD") {
+        body = await request.arrayBuffer();
+      }
+      const response = await this.handleRequest(
+        port,
+        request.method,
+        path + url.search,
+        headers,
+        body
+      );
+      const answerHeaders = new Headers();
+      for (const [name, value] of Object.entries(response.headers)) {
+        for (const each of Array.isArray(value) ? value : [value]) answerHeaders.append(name, each);
+      }
+      return new Response(response.body, {
+        status: response.statusCode,
+        statusText: response.statusMessage ?? "",
+        headers: answerHeaders
+      });
+    };
+  }
+  // ---------------------------------------------------------------- an engine's own servers
+  /**
+   * Whether a registration is a guest's own listener, answered over the
+   * engine's loopback rather than by a server object the host registered. A
+   * bridge with no engine in its realm has none: every server it holds was
+   * registered by the host, a worker's proxies among them.
+   */
+  isGuest(entry) {
+    return entry.server === null;
+  }
+  /** A request to a guest's listener, over the engine's loopback. */
+  requestGuest(port, _method, _url, _headers, _body) {
+    return Promise.reject(new Error(`Port ${port} has no server in this realm.`));
+  }
+  /** A guest's answer streamed off its connection as it arrives. */
+  streamGuest(port, _method, _url, _headers, _body, _onStart, _onChunk, _onEnd, _flow) {
+    return Promise.reject(new Error(`Port ${port} has no server in this realm.`));
+  }
+  /** A request's body as the servers of this realm read it. */
+  bodyOf(bytes) {
+    return bytes;
+  }
+};
+__publicField(_PortBridge, "DEBUG", false);
+let PortBridge = _PortBridge;
+let globalPortBridge = null;
+function getPortBridge(options) {
+  if (!globalPortBridge) globalPortBridge = new PortBridge(options);
+  return globalPortBridge;
+}
+export {
+  PortBridge as P,
+  uint8ToBinaryString as a,
+  base64ToUint8 as b,
+  uint8ToHex as c,
+  getPortBridge as g,
+  ownedBytes as o,
+  uint8ToBase64 as u
+};