osra 0.2.0 → 0.2.1

package/build/extension-test/background.js

@@ -0,0 +1,753 @@
+const OSRA_KEY = "__OSRA_KEY__";
+const OSRA_DEFAULT_KEY = "__OSRA_DEFAULT_KEY__";
+const OSRA_BOX = "__OSRA_BOX__";
+
+const makeMessageChannelAllocator = () => {
+  const channels = /* @__PURE__ */ new Map();
+  const result = {
+    getUniqueUuid: () => {
+      let uuid = globalThis.crypto.randomUUID();
+      while (channels.has(uuid)) {
+        uuid = globalThis.crypto.randomUUID();
+      }
+      return uuid;
+    },
+    set: (uuid, messagePorts) => {
+      channels.set(uuid, { uuid, ...messagePorts });
+    },
+    alloc: (uuid = result.getUniqueUuid(), messagePorts) => {
+      if (messagePorts) {
+        channels.set(uuid, { uuid, ...messagePorts });
+        return { uuid, ...messagePorts };
+      }
+      const messageChannel = new MessageChannel();
+      const allocatedMessageChannel = {
+        uuid,
+        port1: messageChannel.port1,
+        port2: messageChannel.port2
+      };
+      channels.set(uuid, allocatedMessageChannel);
+      return allocatedMessageChannel;
+    },
+    has: (uuid) => channels.has(uuid),
+    get: (uuid) => channels.get(uuid),
+    free: (uuid) => channels.delete(uuid),
+    getOrAlloc: (uuid = result.getUniqueUuid(), messagePorts) => {
+      const existingChannel = result.get(uuid);
+      if (existingChannel) return existingChannel;
+      return result.alloc(uuid, messagePorts);
+    }
+  };
+  return result;
+};
+
+const checkOsraMessageKey = (message, key) => isOsraMessage(message) && message[OSRA_KEY] === key;
+const registerOsraMessageListener = ({ listener, transport, remoteName, key = OSRA_KEY, unregisterSignal }) => {
+  const registerListenerOnReceiveTransport = (receiveTransport) => {
+    if (typeof receiveTransport === "function") {
+      receiveTransport(listener);
+    } else if (isWebExtensionPort(receiveTransport) || isWebExtensionOnConnect(receiveTransport) || isWebExtensionOnMessage(receiveTransport)) {
+      const listenOnWebExtOnMessage = (onMessage, port) => {
+        const _listener = (message, sender) => {
+          if (!checkOsraMessageKey(message, key)) return;
+          if (remoteName && message.name !== remoteName) return;
+          listener(message, { port, sender });
+        };
+        onMessage.addListener(_listener);
+        if (unregisterSignal) {
+          unregisterSignal.addEventListener(
+            "abort",
+            () => onMessage.removeListener(_listener)
+          );
+        }
+      };
+      if (isWebExtensionOnConnect(receiveTransport)) {
+        const _listener = (port) => {
+          listenOnWebExtOnMessage(port.onMessage, port);
+        };
+        receiveTransport.addListener(_listener);
+        if (unregisterSignal) {
+          unregisterSignal.addEventListener(
+            "abort",
+            () => receiveTransport.removeListener(_listener)
+          );
+        }
+      } else if (isWebExtensionOnMessage(receiveTransport)) {
+        listenOnWebExtOnMessage(receiveTransport);
+      } else {
+        listenOnWebExtOnMessage(receiveTransport.onMessage);
+      }
+    } else {
+      const _listener = (event) => {
+        if (!checkOsraMessageKey(event.data, key)) return;
+        if (remoteName && event.data.name !== remoteName) return;
+        listener(event.data, { receiveTransport, source: event.source });
+      };
+      receiveTransport.addEventListener("message", _listener);
+      if (unregisterSignal) {
+        unregisterSignal.addEventListener(
+          "abort",
+          () => receiveTransport.removeEventListener("message", _listener)
+        );
+      }
+    }
+  };
+  if (isCustomTransport(transport)) {
+    registerListenerOnReceiveTransport(transport.receive);
+  } else {
+    registerListenerOnReceiveTransport(transport);
+  }
+};
+const sendOsraMessage = (transport, message, origin = "*", transferables = []) => {
+  const sendToEmitTransport = (emitTransport) => {
+    if (typeof emitTransport === "function") {
+      emitTransport(message, transferables);
+    } else if (isWebExtensionPort(emitTransport)) {
+      emitTransport.postMessage(message);
+    } else if (isWindow(emitTransport)) {
+      emitTransport.postMessage(message, origin, transferables);
+    } else if (isWebSocket(emitTransport)) {
+      emitTransport.send(JSON.stringify(message));
+    } else if (isSharedWorker(emitTransport)) {
+      emitTransport.port.postMessage(message, transferables);
+    } else {
+      emitTransport.postMessage(message, transferables);
+    }
+  };
+  if (isCustomTransport(transport)) {
+    sendToEmitTransport(transport.emit);
+  } else {
+    sendToEmitTransport(transport);
+  }
+};
+
+const typedArrayConstructors = [
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float16Array,
+  Float32Array,
+  Float64Array,
+  BigInt64Array,
+  BigUint64Array
+];
+[
+  new Int8Array(),
+  new Uint8Array(),
+  new Uint8ClampedArray(),
+  new Int16Array(),
+  new Uint16Array(),
+  new Int32Array(),
+  new Uint32Array(),
+  new Float16Array(),
+  new Float32Array(),
+  new Float64Array(),
+  new BigInt64Array(),
+  new BigUint64Array()
+];
+const typedArrayToType = (value) => {
+  const type = value instanceof Int8Array ? "Int8Array" : value instanceof Uint8Array ? "Uint8Array" : value instanceof Uint8ClampedArray ? "Uint8ClampedArray" : value instanceof Int16Array ? "Int16Array" : value instanceof Uint16Array ? "Uint16Array" : value instanceof Int32Array ? "Int32Array" : value instanceof Uint32Array ? "Uint32Array" : value instanceof Float16Array ? "Float16Array" : value instanceof Float32Array ? "Float32Array" : value instanceof Float64Array ? "Float64Array" : value instanceof BigInt64Array ? "BigInt64Array" : value instanceof BigUint64Array ? "BigUint64Array" : void 0;
+  if (type === void 0) throw new Error("Unknown typed array type");
+  return type;
+};
+const typedArrayTypeToTypedArrayConstructor = (value) => {
+  const typedArray = value === "Int8Array" ? Int8Array : value === "Uint8Array" ? Uint8Array : value === "Uint8ClampedArray" ? Uint8ClampedArray : value === "Int16Array" ? Int16Array : value === "Uint16Array" ? Uint16Array : value === "Int32Array" ? Int32Array : value === "Uint32Array" ? Uint32Array : value === "Float16Array" ? Float16Array : value === "Float32Array" ? Float32Array : value === "Float64Array" ? Float64Array : value === "BigInt64Array" ? BigInt64Array : value === "BigUint64Array" ? BigUint64Array : void 0;
+  if (typedArray === void 0) throw new Error("Unknown typed array type");
+  return typedArray;
+};
+const isTypedArray = (value) => typedArrayConstructors.some((typedArray) => value instanceof typedArray);
+const isWebSocket = (value) => value instanceof WebSocket;
+const isServiceWorkerContainer = (value) => globalThis.ServiceWorkerContainer && value instanceof ServiceWorkerContainer;
+const isWorker = (value) => globalThis.Worker && value instanceof Worker;
+const isDedicatedWorker = (value) => globalThis.DedicatedWorkerGlobalScope && value instanceof DedicatedWorkerGlobalScope;
+const isSharedWorker = (value) => globalThis.SharedWorker && value instanceof SharedWorker;
+const isMessagePort = (value) => value instanceof MessagePort;
+const isPromise = (value) => value instanceof Promise;
+const isFunction = (value) => typeof value === "function";
+const isArrayBuffer = (value) => value instanceof ArrayBuffer;
+const isReadableStream = (value) => value instanceof ReadableStream;
+const isDate = (value) => value instanceof Date;
+const isError = (value) => value instanceof Error;
+const isAlwaysBox = (value) => isFunction(value) || isPromise(value) || isTypedArray(value) || isDate(value) || isError(value);
+const isOsraMessage = (value) => Boolean(
+  value && typeof value === "object" && value[OSRA_KEY]
+);
+const isClonable = (value) => globalThis.SharedArrayBuffer && value instanceof globalThis.SharedArrayBuffer ? true : false;
+const isTransferable = (value) => globalThis.ArrayBuffer && value instanceof globalThis.ArrayBuffer ? true : globalThis.MessagePort && value instanceof globalThis.MessagePort ? true : globalThis.ReadableStream && value instanceof globalThis.ReadableStream ? true : globalThis.WritableStream && value instanceof globalThis.WritableStream ? true : globalThis.TransformStream && value instanceof globalThis.TransformStream ? true : globalThis.ImageBitmap && value instanceof globalThis.ImageBitmap ? true : false;
+const isWebExtensionPort = (value, connectPort = false) => {
+  return Boolean(
+    value && typeof value === "object" && value.name && value.disconnect && value.postMessage && (connectPort ? value.sender && value.onMessage && value.onDisconnect : true)
+  );
+};
+const isWebExtensionOnConnect = (value) => Boolean(
+  value && typeof value === "object" && value.addListener && value.hasListener && value.removeListener
+);
+const isWebExtensionOnMessage = (value) => Boolean(
+  value && typeof value === "object" && value.addListener && value.hasListener && value.removeListener
+);
+const isWindow = (value) => {
+  return Boolean(
+    value && typeof value === "object" && value.document && value.location && value.navigator && value.screen && value.history
+  );
+};
+const isEmitJsonOnlyTransport = (value) => isWebSocket(value) || isWebExtensionPort(value);
+const isReceiveJsonOnlyTransport = (value) => isWebSocket(value) || isWebExtensionPort(value) || isWebExtensionOnConnect(value) || isWebExtensionOnMessage(value);
+const isJsonOnlyTransport = (value) => isEmitJsonOnlyTransport(value) || isReceiveJsonOnlyTransport(value);
+const isEmitTransport = (value) => isEmitJsonOnlyTransport(value) || isWindow(value) || isServiceWorkerContainer(value) || isWorker(value) || isDedicatedWorker(value) || isSharedWorker(value) || isMessagePort(value) || isCustomEmitTransport(value);
+const isReceiveTransport = (value) => isReceiveJsonOnlyTransport(value) || isWindow(value) || isServiceWorkerContainer(value) || isWorker(value) || isDedicatedWorker(value) || isSharedWorker(value) || isMessagePort(value) || isCustomReceiveTransport(value);
+const isCustomEmitTransport = (value) => Boolean(
+  value && typeof value === "object" && ("emit" in value && (isEmitTransport(value.emit) || typeof value.emit === "function"))
+);
+const isCustomReceiveTransport = (value) => Boolean(
+  value && typeof value === "object" && ("receive" in value && (isReceiveTransport(value.receive) || typeof value.receive === "function"))
+);
+const isCustomTransport = (value) => isCustomEmitTransport(value) || isCustomReceiveTransport(value);
+const isRevivable = (value) => isMessagePort(value) || isFunction(value) || isPromise(value) || isTypedArray(value) || isArrayBuffer(value) || isReadableStream(value) || isDate(value) || isError(value);
+const isRevivableBox = (value) => value && typeof value === "object" && OSRA_BOX in value && value[OSRA_BOX] === "revivable";
+const isRevivableMessagePortBox = (value) => isRevivableBox(value) && value.type === "messagePort";
+const isRevivablePromiseBox = (value) => isRevivableBox(value) && value.type === "promise";
+const isRevivableFunctionBox = (value) => isRevivableBox(value) && value.type === "function";
+const isRevivableTypedArrayBox = (value) => isRevivableBox(value) && value.type === "typedArray";
+const isRevivableArrayBufferBox = (value) => isRevivableBox(value) && value.type === "arrayBuffer";
+const isRevivableReadableStreamBox = (value) => isRevivableBox(value) && value.type === "readableStream";
+const isRevivableErrorBox = (value) => isRevivableBox(value) && value.type === "error";
+const isRevivableDateBox = (value) => isRevivableBox(value) && value.type === "date";
+
+const getTransferableObjects = (value) => {
+  const transferables = [];
+  const recurse = (value2) => isClonable(value2) ? void 0 : isTransferable(value2) ? transferables.push(value2) : Array.isArray(value2) ? value2.map(recurse) : value2 && typeof value2 === "object" ? Object.values(value2).map(recurse) : void 0;
+  recurse(value);
+  return transferables;
+};
+
+const probePlatformCapabilityUtil = (value, transfer = false) => {
+  const { port1, port2 } = new MessageChannel();
+  const result = new Promise(
+    (resolve) => port1.addEventListener(
+      "message",
+      (message) => resolve(message.data)
+    )
+  );
+  port1.start();
+  port2.postMessage(value, transfer ? getTransferableObjects(value) : []);
+  return result;
+};
+const probeMessagePortTransfer = async () => {
+  const { port1 } = new MessageChannel();
+  const port = await probePlatformCapabilityUtil(port1, true);
+  return port instanceof MessagePort;
+};
+const probeArrayBufferClone = async () => {
+  const buffer = new ArrayBuffer(1);
+  const arrayBuffer = await probePlatformCapabilityUtil(buffer);
+  return arrayBuffer instanceof ArrayBuffer;
+};
+const probeArrayBufferTransfer = async () => {
+  const buffer = new ArrayBuffer(1);
+  const arrayBuffer = await probePlatformCapabilityUtil(buffer, true);
+  return arrayBuffer instanceof ArrayBuffer;
+};
+const probeTransferableStream = async () => {
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(new Uint8Array(1));
+      controller.close();
+    }
+  });
+  const transferableStream = await probePlatformCapabilityUtil(stream, true);
+  return transferableStream instanceof ReadableStream;
+};
+const probePlatformCapabilities = async () => {
+  const [
+    messagePort,
+    arrayBuffer,
+    transferable,
+    transferableStream
+  ] = await Promise.all([
+    probeMessagePortTransfer().catch(() => false),
+    probeArrayBufferClone().catch(() => false),
+    probeArrayBufferTransfer().catch(() => false),
+    probeTransferableStream().catch(() => false)
+  ]);
+  return {
+    jsonOnly: !messagePort && !arrayBuffer && !transferable && !transferableStream,
+    messagePort,
+    arrayBuffer,
+    transferable,
+    transferableStream
+  };
+};
+
+const boxMessagePort = (value, context) => {
+  const messagePort = value;
+  const { uuid: portId } = context.messageChannels.alloc(void 0, { port1: messagePort });
+  messagePort.addEventListener("message", ({ data }) => {
+    context.sendMessage({
+      type: "message",
+      remoteUuid: context.remoteUuid,
+      data: isRevivableBox(data) ? data : recursiveBox(data, context),
+      portId
+    });
+  });
+  messagePort.start();
+  context.eventTarget.addEventListener("message", function listener({ detail: message }) {
+    if (message.type === "message-port-close") {
+      if (message.portId !== portId) return;
+      context.eventTarget.removeEventListener("message", listener);
+      messagePort.close();
+      context.messageChannels.free(portId);
+      return;
+    }
+    if (message.type !== "message" || message.portId !== portId) return;
+    messagePort.postMessage(message.data, getTransferableObjects(message.data));
+  });
+  return {
+    type: "messagePort",
+    portId
+  };
+};
+const reviveMessagePort = (value, context) => {
+  const { port1: userPort, port2: internalPort } = new MessageChannel();
+  internalPort.addEventListener("message", ({ data }) => {
+    context.sendMessage({
+      type: "message",
+      remoteUuid: context.remoteUuid,
+      data: isRevivableBox(data) ? data : recursiveBox(data, context),
+      portId: value.portId
+    });
+  });
+  internalPort.start();
+  const existingChannel = context.messageChannels.get(value.portId);
+  const { port1 } = existingChannel ? existingChannel : context.messageChannels.alloc(value.portId);
+  port1.addEventListener("message", function listener({ data: message }) {
+    if (message.type === "message-port-close") {
+      if (message.portId !== value.portId) return;
+      port1.removeEventListener("message", listener);
+      internalPort.close();
+      context.messageChannels.free(value.portId);
+      return;
+    }
+    if (message.type !== "message" || message.portId !== value.portId) return;
+    if (context.messagePorts.has(userPort)) {
+      internalPort.postMessage(message.data);
+    } else {
+      const revivedData = recursiveRevive(message.data, context);
+      internalPort.postMessage(revivedData, getTransferableObjects(revivedData));
+    }
+  });
+  port1.start();
+  return userPort;
+};
+const boxPromise = (value, context) => {
+  const { port1: localPort, port2: remotePort } = new MessageChannel();
+  context.messagePorts.add(remotePort);
+  const sendResult = (result) => {
+    const boxedResult = recursiveBox(result, context);
+    localPort.postMessage(boxedResult, getTransferableObjects(boxedResult));
+    localPort.close();
+  };
+  value.then((data) => sendResult({ type: "resolve", data })).catch((error) => sendResult({ type: "reject", error: error.stack }));
+  return {
+    type: "promise",
+    port: remotePort
+  };
+};
+const revivePromise = (value, context) => {
+  context.messagePorts.add(value.port);
+  return new Promise((resolve, reject) => {
+    value.port.addEventListener("message", ({ data }) => {
+      const result = recursiveRevive(data, context);
+      if (result.type === "resolve") {
+        resolve(result.data);
+      } else {
+        reject(result.error);
+      }
+      value.port.close();
+    }, { once: true });
+    value.port.start();
+  });
+};
+const boxFunction = (value, context) => {
+  const { port1: localPort, port2: remotePort } = new MessageChannel();
+  context.messagePorts.add(remotePort);
+  localPort.addEventListener("message", ({ data }) => {
+    const [returnValuePort, args] = recursiveRevive(data, context);
+    const result = (async () => value(...args))();
+    const boxedResult = recursiveBox(result, context);
+    returnValuePort.postMessage(boxedResult, getTransferableObjects(boxedResult));
+  });
+  localPort.start();
+  return {
+    type: "function",
+    port: remotePort
+  };
+};
+const reviveFunction = (value, context) => {
+  const func = (...args) => new Promise((resolve, reject) => {
+    const { port1: returnValueLocalPort, port2: returnValueRemotePort } = new MessageChannel();
+    context.messagePorts.add(returnValueRemotePort);
+    const callContext = recursiveBox([returnValueRemotePort, args], context);
+    value.port.postMessage(callContext, getTransferableObjects(callContext));
+    returnValueLocalPort.addEventListener("message", ({ data }) => {
+      if (!isRevivablePromiseBox(data)) throw new Error(`Proxied function did not return a promise`);
+      const result = recursiveRevive(data, context);
+      result.then(resolve).catch(reject).finally(() => returnValueLocalPort.close());
+    });
+    returnValueLocalPort.start();
+  });
+  return func;
+};
+const boxTypedArray = (value, context) => {
+  return {
+    type: "typedArray",
+    typedArrayType: typedArrayToType(value),
+    arrayBuffer: value.buffer
+  };
+};
+const reviveTypedArray = (value, context) => {
+  const TypedArrayConstructor = typedArrayTypeToTypedArrayConstructor(value.typedArrayType);
+  const result = new TypedArrayConstructor(value.arrayBuffer);
+  return result;
+};
+const boxArrayBuffer = (value, context) => {
+  return {
+    type: "arrayBuffer",
+    base64Buffer: new Uint8Array(value).toBase64()
+  };
+};
+const reviveArrayBuffer = (value, context) => {
+  return Uint8Array.fromBase64(value.base64Buffer).buffer;
+};
+const boxError = (value, context) => {
+  return {
+    type: "error",
+    message: value.message,
+    stack: value.stack || value.toString()
+  };
+};
+const reviveError = (value, context) => {
+  return new Error(value.message, { cause: value.stack });
+};
+const boxReadableStream = (value, context) => {
+  const { port1: localPort, port2: remotePort } = new MessageChannel();
+  context.messagePorts.add(remotePort);
+  const reader = value.getReader();
+  localPort.addEventListener("message", async ({ data }) => {
+    const { type } = recursiveRevive(data, context);
+    if (type === "pull") {
+      const pullResult = reader.read();
+      const boxedResult = recursiveBox(pullResult, context);
+      localPort.postMessage(boxedResult, getTransferableObjects(boxedResult));
+    } else {
+      reader.cancel();
+      localPort.close();
+    }
+  });
+  localPort.start();
+  return {
+    type: "readableStream",
+    port: remotePort
+  };
+};
+const reviveReadableStream = (value, context) => {
+  context.messagePorts.add(value.port);
+  value.port.start();
+  return new ReadableStream({
+    start(controller) {
+    },
+    pull(controller) {
+      return new Promise((resolve, reject) => {
+        value.port.addEventListener("message", async ({ data }) => {
+          if (!isRevivablePromiseBox(data)) throw new Error(`Proxied function did not return a promise`);
+          const result = recursiveRevive(data, context);
+          result.then((result2) => {
+            if (result2.done) controller.close();
+            else controller.enqueue(result2.value);
+            resolve();
+          }).catch(reject);
+        }, { once: true });
+        value.port.postMessage(recursiveBox({ type: "pull" }, context));
+      });
+    },
+    cancel() {
+      value.port.postMessage(recursiveBox({ type: "cancel" }, context));
+      value.port.close();
+    }
+  });
+};
+const boxDate = (value, context) => {
+  return {
+    type: "date",
+    ISOString: value.toISOString()
+  };
+};
+const reviveDate = (value, context) => {
+  return new Date(value.ISOString);
+};
+const box = (value, context) => {
+  if (isAlwaysBox(value) || isReadableStream(value) && !context.platformCapabilities.transferableStream) {
+    return {
+      [OSRA_BOX]: "revivable",
+      ...isFunction(value) ? boxFunction(value, context) : isPromise(value) ? boxPromise(value, context) : isTypedArray(value) ? boxTypedArray(value) : isReadableStream(value) ? boxReadableStream(value, context) : isDate(value) ? boxDate(value) : isError(value) ? boxError(value) : value
+    };
+  }
+  return {
+    [OSRA_BOX]: "revivable",
+    ..."isJson" in context.transport && context.transport.isJson ? isMessagePort(value) ? boxMessagePort(value, context) : isArrayBuffer(value) ? boxArrayBuffer(value) : isReadableStream(value) ? boxReadableStream(value, context) : { type: "unknown", value } : {
+      type: isMessagePort(value) ? "messagePort" : isArrayBuffer(value) ? "arrayBuffer" : isReadableStream(value) ? "readableStream" : "unknown",
+      value
+    }
+  };
+};
+const recursiveBox = (value, context) => {
+  const boxedValue = isRevivable(value) ? box(value, context) : value;
+  return Array.isArray(boxedValue) ? boxedValue.map((value2) => recursiveBox(value2, context)) : boxedValue && typeof boxedValue === "object" && Object.getPrototypeOf(boxedValue) === Object.prototype ? Object.fromEntries(
+    Object.entries(boxedValue).map(([key, value2]) => [
+      key,
+      isRevivableBox(boxedValue) && boxedValue.type === "messagePort" && boxedValue.value instanceof MessagePort || isRevivableBox(boxedValue) && boxedValue.type === "arrayBuffer" && boxedValue.value instanceof ArrayBuffer || isRevivableBox(boxedValue) && boxedValue.type === "readableStream" && boxedValue.value instanceof ReadableStream ? value2 : recursiveBox(value2, context)
+    ])
+  ) : boxedValue;
+};
+const revive = (box2, context) => {
+  if (isRevivable(box2.value)) return box2.value;
+  return isRevivableMessagePortBox(box2) ? reviveMessagePort(box2, context) : isRevivableFunctionBox(box2) ? reviveFunction(box2, context) : isRevivablePromiseBox(box2) ? revivePromise(box2, context) : isRevivableErrorBox(box2) ? reviveError(box2) : isRevivableTypedArrayBox(box2) ? reviveTypedArray(box2) : isRevivableArrayBufferBox(box2) ? reviveArrayBuffer(box2) : isRevivableReadableStreamBox(box2) ? reviveReadableStream(box2, context) : isRevivableDateBox(box2) ? reviveDate(box2) : box2;
+};
+const recursiveRevive = (value, context) => {
+  const recursedValue = isTransferable(value) ? value : Array.isArray(value) ? value.map((value2) => recursiveRevive(value2, context)) : value && typeof value === "object" ? Object.fromEntries(
+    Object.entries(value).map(([key, value2]) => [
+      key,
+      recursiveRevive(value2, context)
+    ])
+  ) : value;
+  return isRevivableBox(recursedValue) ? revive(recursedValue, context) : recursedValue;
+};
+
+const startBidirectionalConnection = ({ transport, value, uuid, remoteUuid, platformCapabilities, eventTarget, send, close }) => {
+  const revivableContext = {
+    platformCapabilities,
+    transport,
+    remoteUuid,
+    messagePorts: /* @__PURE__ */ new Set(),
+    messageChannels: makeMessageChannelAllocator(),
+    sendMessage: send,
+    eventTarget
+  };
+  let initResolve;
+  const initMessage = new Promise((resolve, reject) => {
+    initResolve = resolve;
+  });
+  eventTarget.addEventListener("message", ({ detail }) => {
+    if (detail.type === "init") {
+      initResolve(detail);
+      return;
+    } else if (detail.type === "message") {
+      const messageChannel = revivableContext.messageChannels.getOrAlloc(detail.portId);
+      messageChannel.port2?.postMessage(detail);
+    }
+  });
+  send({
+    type: "init",
+    remoteUuid,
+    data: recursiveBox(value, revivableContext)
+  });
+  return {
+    revivableContext,
+    close: () => {
+    },
+    remoteValue: initMessage.then((initMessage2) => recursiveRevive(initMessage2.data, revivableContext))
+  };
+};
+const startUnidirectionalEmittingConnection = ({ value, uuid, platformCapabilities, send, close }) => {
+  return {
+    close: () => {
+    },
+    remoteValueProxy: new Proxy(
+      new Function(),
+      {
+        apply: (target, thisArg, args) => {
+        },
+        get: (target, prop) => {
+        }
+      }
+    )
+  };
+};
+
+var e=class extends EventTarget{dispatchTypedEvent(s,t){return super.dispatchEvent(t)}};
+
+const expose = async (value, {
+  transport: _transport,
+  name,
+  remoteName,
+  key = OSRA_DEFAULT_KEY,
+  origin = "*",
+  unregisterSignal,
+  platformCapabilities: _platformCapabilities,
+  transferAll,
+  logger
+}) => {
+  const transport = {
+    isJson: "isJson" in _transport && _transport.isJson !== void 0 ? _transport.isJson : isJsonOnlyTransport(_transport),
+    ...isCustomTransport(_transport) ? _transport : {
+      emit: _transport,
+      receive: _transport
+    }
+  };
+  const platformCapabilities = _platformCapabilities ?? await probePlatformCapabilities();
+  const connectionContexts = /* @__PURE__ */ new Map();
+  let resolveRemoteValue;
+  const remoteValuePromise = new Promise((resolve) => {
+    resolveRemoteValue = resolve;
+  });
+  let uuid = globalThis.crypto.randomUUID();
+  const sendMessage = (transport2, message) => {
+    const transferables = getTransferableObjects(message);
+    sendOsraMessage(
+      transport2,
+      {
+        [OSRA_KEY]: key,
+        name,
+        uuid,
+        ...message
+      },
+      origin,
+      transferables
+    );
+  };
+  const listener = async (message, messageContext) => {
+    if (message.uuid === uuid) return;
+    if (!isEmitTransport(transport)) {
+      throw new Error("Unidirectional receiving mode not implemented");
+    }
+    if (message.type === "announce") {
+      if (!message.remoteUuid) {
+        sendMessage(transport, { type: "announce", remoteUuid: message.uuid });
+        return;
+      }
+      if (message.remoteUuid !== uuid) return;
+      if (connectionContexts.has(message.uuid)) {
+        sendMessage(
+          transport,
+          { type: "reject-uuid-taken", remoteUuid: message.uuid }
+        );
+        return;
+      }
+      const eventTarget = new e();
+      const connectionContext = {
+        type: "bidirectional",
+        eventTarget,
+        connection: startBidirectionalConnection({
+          transport,
+          value,
+          uuid,
+          remoteUuid: message.uuid,
+          platformCapabilities,
+          eventTarget,
+          send: (message2) => sendMessage(transport, message2),
+          close: () => void connectionContexts.delete(message.uuid)
+        })
+      };
+      connectionContexts.set(message.uuid, connectionContext);
+      connectionContext.connection.remoteValue.then(
+        (remoteValue) => resolveRemoteValue(remoteValue)
+      );
+    } else if (message.type === "reject-uuid-taken") {
+      if (message.remoteUuid !== uuid) return;
+      uuid = globalThis.crypto.randomUUID();
+      sendMessage(transport, { type: "announce" });
+    } else if (message.type === "close") {
+      if (message.remoteUuid !== uuid) return;
+      const connectionContext = connectionContexts.get(message.uuid);
+      if (!connectionContext) {
+        console.warn(`Connection not found for remoteUuid: ${message.uuid}`);
+        return;
+      }
+      connectionContext.connection.close();
+      connectionContexts.delete(message.uuid);
+    } else {
+      if (message.remoteUuid !== uuid) return;
+      const connection = connectionContexts.get(message.uuid);
+      if (!connection) {
+        console.warn(`Connection not found for remoteUuid: ${message.uuid}`);
+        return;
+      }
+      if (connection.type !== "unidirectional-emitting") {
+        connection.eventTarget.dispatchTypedEvent(
+          "message",
+          new CustomEvent("message", { detail: message })
+        );
+      }
+    }
+  };
+  if (isReceiveTransport(transport)) {
+    registerOsraMessageListener({
+      listener,
+      transport,
+      remoteName,
+      key,
+      unregisterSignal
+    });
+  }
+  if (isEmitTransport(transport)) {
+    sendMessage(transport, { type: "announce" });
+  }
+  if (isEmitTransport(transport) && !isReceiveTransport(transport)) {
+    const { remoteValueProxy } = startUnidirectionalEmittingConnection({
+      value,
+      uuid,
+      platformCapabilities,
+      send: (message) => sendMessage(transport, message),
+      close: () => connectionContexts.delete(uuid)
+    });
+    return remoteValueProxy;
+  }
+  return remoteValuePromise;
+};
+
+const api = {
+  echo: async (data) => data,
+  add: async (a, b) => a + b,
+  math: {
+    multiply: async (a, b) => a * b,
+    divide: async (a, b) => a / b
+  },
+  createCallback: async () => async () => 42,
+  callWithCallback: async (cb) => cb(),
+  getDate: async () => /* @__PURE__ */ new Date(),
+  getError: async () => new Error("Test error"),
+  throwError: async () => {
+    throw new Error("Thrown error");
+  },
+  processBuffer: async (data) => new Uint8Array(data.map((x) => x * 2)),
+  getBuffer: async () => {
+    const buffer = new ArrayBuffer(16);
+    new Uint8Array(buffer).forEach((_, i, arr) => arr[i] = i);
+    return buffer;
+  },
+  getPromise: async () => Promise.resolve(123),
+  getStream: async () => new ReadableStream({
+    start(controller) {
+      controller.enqueue(new Uint8Array([1, 2, 3]));
+      controller.enqueue(new Uint8Array([4, 5, 6]));
+      controller.close();
+    }
+  })
+};
+const jsonOnlyCapabilities = {
+  jsonOnly: true,
+  messagePort: false,
+  arrayBuffer: false,
+  transferable: false,
+  transferableStream: false
+};
+chrome.runtime.onConnect.addListener((port) => {
+  expose(api, {
+    transport: { isJson: true, emit: port, receive: port },
+    platformCapabilities: jsonOnlyCapabilities
+  });
+});
+//# sourceMappingURL=background.js.map