jsilnet 0.1.0 → 0.2.0

package/src/browser/index.js

@@ -0,0 +1,373 @@
+import { FormatError, UnsupportedFormatError } from "../binary/errors.js";
+
+let nextRequestId = 0;
+
+function createWorker(workerFactory) {
+  if (workerFactory) return workerFactory();
+  if (typeof Worker === "undefined") {
+    throw new Error("jsILNET browser APIs require Web Worker support");
+  }
+  return new Worker(new URL("./worker.js", import.meta.url), { type: "module" });
+}
+
+function normalizeInput(input, transferInput) {
+  if (typeof Blob !== "undefined" && input instanceof Blob) {
+    return { input, transfer: [] };
+  }
+  if (input instanceof ArrayBuffer) {
+    const buffer = transferInput ? input : input.slice(0);
+    return { input: buffer, transfer: [buffer] };
+  }
+  if (input instanceof Uint8Array) {
+    if (transferInput && input.buffer instanceof ArrayBuffer &&
+        input.byteOffset === 0 && input.byteLength === input.buffer.byteLength) {
+      return { input: input.buffer, transfer: [input.buffer] };
+    }
+    const bytes = Uint8Array.from(input);
+    return { input: bytes.buffer, transfer: [bytes.buffer] };
+  }
+  throw new TypeError("Assembly input must be a Uint8Array, ArrayBuffer, or Blob");
+}
+
+function encodeCallbacks(value, callbacks, seen = new WeakMap()) {
+  if (typeof value === "function") {
+    const id = callbacks.size + 1;
+    callbacks.set(id, value);
+    return { __jsilnetCallback: id };
+  }
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return seen.get(value);
+  if (typeof Blob !== "undefined" && value instanceof Blob) return value;
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;
+  const output = value instanceof Map
+    ? new Map()
+    : value instanceof Set
+      ? new Set()
+      : Array.isArray(value)
+        ? []
+        : {};
+  seen.set(value, output);
+  if (value instanceof Map) {
+    for (const [key, item] of value) {
+      output.set(encodeCallbacks(key, callbacks, seen), encodeCallbacks(item, callbacks, seen));
+    }
+  } else if (value instanceof Set) {
+    for (const item of value) output.add(encodeCallbacks(item, callbacks, seen));
+  } else if (Array.isArray(value)) {
+    for (const item of value) output.push(encodeCallbacks(item, callbacks, seen));
+  } else {
+    for (const key of Object.keys(value)) {
+      output[key] = encodeCallbacks(value[key], callbacks, seen);
+    }
+  }
+  return output;
+}
+
+function decodeAssemblyReferences(value, assembly, seen = new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  if (value.__jsilnetAssembly === true) return assembly;
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;
+  const output = value instanceof Map
+    ? new Map()
+    : value instanceof Set
+      ? new Set()
+      : Array.isArray(value)
+        ? []
+        : {};
+  seen.set(value, output);
+  if (value instanceof Map) {
+    for (const [key, item] of value) {
+      output.set(
+        decodeAssemblyReferences(key, assembly, seen),
+        decodeAssemblyReferences(item, assembly, seen)
+      );
+    }
+  } else if (value instanceof Set) {
+    for (const item of value) output.add(decodeAssemblyReferences(item, assembly, seen));
+  } else if (Array.isArray(value)) {
+    for (const item of value) output.push(decodeAssemblyReferences(item, assembly, seen));
+  } else {
+    for (const key of Object.keys(value)) {
+      output[key] = decodeAssemblyReferences(value[key], assembly, seen);
+    }
+  }
+  return output;
+}
+
+async function encodeResolverResult(value, currentAssembly, seen = new WeakMap()) {
+  if (value instanceof BrowserAssembly) {
+    return value === currentAssembly
+      ? { __jsilnetAssemblyReference: true }
+      : { __jsilnetSerializedAssembly: await value.serialize() };
+  }
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "function" || typeof value === "symbol") {
+      throw new TypeError("Resolver results must be structured-cloneable values");
+    }
+    return value;
+  }
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;
+  const output = value instanceof Map
+    ? new Map()
+    : value instanceof Set
+      ? new Set()
+      : Array.isArray(value)
+        ? []
+        : {};
+  seen.set(value, output);
+  if (value instanceof Map) {
+    for (const [key, item] of value) {
+      output.set(
+        await encodeResolverResult(key, currentAssembly, seen),
+        await encodeResolverResult(item, currentAssembly, seen)
+      );
+    }
+  } else if (value instanceof Set) {
+    for (const item of value) {
+      output.add(await encodeResolverResult(item, currentAssembly, seen));
+    }
+  } else if (Array.isArray(value)) {
+    for (const item of value) output.push(await encodeResolverResult(item, currentAssembly, seen));
+  } else {
+    for (const key of Object.keys(value)) {
+      output[key] = await encodeResolverResult(value[key], currentAssembly, seen);
+    }
+  }
+  return output;
+}
+
+function makeError(data) {
+  const error = data?.name === "FormatError"
+    ? new FormatError(data.message)
+    : data?.name === "UnsupportedFormatError"
+      ? new UnsupportedFormatError(data.message)
+      : new Error(data?.message ?? "Browser worker request failed");
+  if (data?.name && data.name !== "FormatError" && data.name !== "UnsupportedFormatError") {
+    error.name = data.name;
+  }
+  if (data && "offset" in data) error.offset = data.offset;
+  if (data && "context" in data) error.context = data.context;
+  return error;
+}
+
+function addRvaMapper(pe) {
+  if (!pe || !Array.isArray(pe.sections) || !Number.isInteger(pe.sectionOffset)) return pe;
+  pe.rvaToOffset = (rva, size = 1) => {
+    if (!Number.isInteger(rva) || !Number.isInteger(size) || rva < 0 || size < 0) {
+      throw new FormatError("Invalid RVA range (RVA mapping)");
+    }
+    if (rva === 0 && size === 0) return 0;
+    for (const section of pe.sections) {
+      const span = Math.max(section.virtualSize, section.rawSize);
+      if (rva < section.virtualAddress || rva - section.virtualAddress >= span) continue;
+      const delta = rva - section.virtualAddress;
+      if (delta + size > section.rawSize || section.rawPointer + delta + size > pe.bytes.length) {
+        throw new FormatError(
+          "RVA range is not backed by file data",
+          { offset: section.rawPointer + delta, context: `section ${section.name}` }
+        );
+      }
+      return section.rawPointer + delta;
+    }
+    if (rva < pe.sectionOffset && rva + size <= pe.bytes.length) return rva;
+    throw new FormatError(`RVA 0x${rva.toString(16)} is not mapped by a PE section (RVA mapping)`);
+  };
+  return pe;
+}
+
+class WorkerClient {
+  #worker;
+  #pending = new Map();
+  #onMessage;
+  #onError;
+  #onMessageError;
+  #closed = false;
+
+  constructor(worker) {
+    this.#worker = worker;
+    this.#onMessage = (event) => {
+      const response = event.data;
+      const pending = this.#pending.get(response?.id);
+      if (!pending) return;
+      if (response.type === "resolver") {
+        void this.#resolveCallback(response, pending);
+        return;
+      }
+      this.#pending.delete(response.id);
+      if (response.ok) pending.resolve(response.value);
+      else pending.reject(makeError(response.error));
+    };
+    this.#onError = (event) => {
+      const error = event.error ?? new Error(event.message || "Browser worker failed");
+      for (const pending of this.#pending.values()) pending.reject(error);
+      this.#pending.clear();
+      this.#close();
+    };
+    this.#onMessageError = () => {
+      const error = new Error("Browser worker sent an uncloneable response");
+      for (const pending of this.#pending.values()) pending.reject(error);
+      this.#pending.clear();
+      this.#close();
+    };
+    worker.addEventListener("message", this.#onMessage);
+    worker.addEventListener("error", this.#onError);
+    worker.addEventListener("messageerror", this.#onMessageError);
+  }
+
+  request(type, payload = {}, transfer = [], resolverOptions = {}) {
+    if (this.#closed) {
+      return Promise.reject(new Error("Browser worker is closed"));
+    }
+    const id = ++nextRequestId;
+    return new Promise((resolve, reject) => {
+      const callbacks = new Map();
+      const encodedPayload = encodeCallbacks(payload, callbacks);
+      this.#pending.set(id, { resolve, reject, callbacks, resolverOptions });
+      try {
+        this.#worker.postMessage({ id, type, ...encodedPayload }, transfer);
+      } catch (error) {
+        this.#pending.delete(id);
+        if (error?.name === "DataCloneError") {
+          reject(new TypeError("Browser Worker request contains a non-cloneable value"));
+        } else {
+          reject(error);
+        }
+      }
+    });
+  }
+
+  async #resolveCallback(response, pending) {
+    const callback = pending.callbacks.get(response.callbackId);
+    try {
+      if (!callback) throw new TypeError("Worker requested an unknown resolver callback");
+      const args = pending.resolverOptions.decodeArguments
+        ? pending.resolverOptions.decodeArguments(response.args)
+        : response.args;
+      const result = await callback(...args);
+      if (this.#closed || !this.#pending.has(response.id)) return;
+      const value = pending.resolverOptions.encodeResult
+        ? await pending.resolverOptions.encodeResult(result)
+        : result;
+      if (this.#closed || !this.#pending.has(response.id)) return;
+      this.#worker.postMessage({
+        type: "resolverResult",
+        id: response.id,
+        resolverRequestId: response.resolverRequestId,
+        ok: true,
+        value
+      });
+    } catch (error) {
+      if (this.#closed || !this.#pending.has(response.id)) return;
+      this.#worker.postMessage({
+        type: "resolverResult",
+        id: response.id,
+        resolverRequestId: response.resolverRequestId,
+        ok: false,
+        error: {
+          name: error?.name ?? "Error",
+          message: error?.message ?? String(error)
+        }
+      });
+    }
+  }
+
+  dispose() {
+    if (this.#closed) return;
+    for (const pending of this.#pending.values()) {
+      pending.reject(new Error("Browser worker was disposed"));
+    }
+    this.#pending.clear();
+    this.#close();
+  }
+
+  #close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#worker.removeEventListener("message", this.#onMessage);
+    this.#worker.removeEventListener("error", this.#onError);
+    this.#worker.removeEventListener("messageerror", this.#onMessageError);
+    this.#worker.terminate();
+  }
+}
+
+export class BrowserAssembly {
+  #client;
+  #proxy;
+
+  constructor(client) {
+    this.#client = client;
+  }
+
+  static async from(input, { workerFactory, transferInput = false } = {}) {
+    const normalizedInput = normalizeInput(input, transferInput);
+    const worker = createWorker(workerFactory);
+    const client = new WorkerClient(worker);
+    const { input: inputValue, transfer } = normalizedInput;
+    try {
+      await client.request("parse", { input: inputValue }, transfer);
+      const instance = new BrowserAssembly(client);
+      instance.#proxy = new Proxy(instance, {
+        get(target, property, receiver) {
+          if (property === "then") return undefined;
+          if (Reflect.has(target, property)) {
+            const value = Reflect.get(target, property, target);
+            return typeof value === "function" ? value.bind(target) : value;
+          }
+          if (typeof property === "string") {
+            return (...args) => target.#call(property, args);
+          }
+          return undefined;
+        }
+      });
+      return instance.#proxy;
+    } catch (error) {
+      client.dispose();
+      throw error;
+    }
+  }
+
+  async getState() {
+    return this.#client.request("state");
+  }
+
+  async callUtility(name, ...args) {
+    const result = await this.#client.request("utility", { name, args });
+    return name === "parsePE" ? addRvaMapper(result) : result;
+  }
+
+  async #call(name, args) {
+    const result = await this.#client.request(
+      "call",
+      { name, args },
+      [],
+      {
+        decodeArguments: (value) => decodeAssemblyReferences(value, this.#proxy),
+        encodeResult: (value) => encodeResolverResult(value, this.#proxy)
+      }
+    );
+    return result?.__jsilnetAssembly === true ? this.#proxy : result;
+  }
+
+  dispose() {
+    this.#client.dispose();
+  }
+}
+
+export async function parseAssembly(input, options) {
+  return BrowserAssembly.from(input, options);
+}
+
+export async function callUtility(name, ...args) {
+  const worker = createWorker();
+  const client = new WorkerClient(worker);
+  try {
+    const result = await client.request("utility", { name, args });
+    return name === "parsePE" ? addRvaMapper(result) : result;
+  } finally {
+    client.dispose();
+  }
+}
+
+export { BrowserAssembly as Assembly, FormatError, UnsupportedFormatError };

package/src/browser/worker-runtime.js

@@ -0,0 +1,287 @@
+import * as core from "../index.js";
+import { Assembly, parseAssembly } from "../index.js";
+
+const assemblyMethods = new Set(
+  Object.getOwnPropertyNames(Assembly.prototype).filter((name) => name !== "constructor")
+);
+
+function cloneValue(value, assembly, seen = new WeakMap(), functionMode = "omit") {
+  if (assembly !== null && value === assembly) return { __jsilnetAssembly: true };
+  if (value === null || typeof value !== "object") {
+    if (typeof value !== "function") return value;
+    if (functionMode === "omit") return undefined;
+    if (value.name === "rvaToOffset") return { __jsilnetFunction: "pe.rvaToOffset" };
+    throw new TypeError("Browser utility returned an unsupported function-valued property");
+  }
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof ArrayBuffer) return value.slice(0);
+  if (ArrayBuffer.isView(value)) {
+    if (value instanceof DataView) {
+      return new DataView(value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength));
+    }
+    if (value instanceof Uint8Array) return Uint8Array.from(value);
+    return new value.constructor(value);
+  }
+  if (value instanceof Map) {
+    const output = new Map();
+    seen.set(value, output);
+    for (const [key, item] of value) {
+      output.set(
+        cloneValue(key, assembly, seen, functionMode),
+        cloneValue(item, assembly, seen, functionMode)
+      );
+    }
+    return output;
+  }
+  if (value instanceof Set) {
+    const output = new Set();
+    seen.set(value, output);
+    for (const item of value) output.add(cloneValue(item, assembly, seen, functionMode));
+    return output;
+  }
+  if (Array.isArray(value)) {
+    const output = [];
+    seen.set(value, output);
+    for (const item of value) output.push(cloneValue(item, assembly, seen, functionMode));
+    return output;
+  }
+  const output = {};
+  seen.set(value, output);
+  for (const key of Object.keys(value)) {
+    const item = cloneValue(value[key], assembly, seen, functionMode);
+    if (item !== undefined) output[key] = item;
+  }
+  return output;
+}
+
+class ResolverRequest extends Error {
+  constructor(callbackId, args) {
+    super("Browser resolver callback required");
+    this.callbackId = callbackId;
+    this.args = args;
+  }
+}
+
+function stableValue(value, assembly, seen = new WeakSet()) {
+  if (assembly !== null && value === assembly) return { assembly: true };
+  if (value === null || typeof value !== "object") {
+    if (typeof value === "bigint") return `${value}n`;
+    if (typeof value === "undefined") return "__undefined";
+    return value;
+  }
+  if (seen.has(value)) return "__cycle";
+  seen.add(value);
+  if (value instanceof ArrayBuffer) return [...new Uint8Array(value)];
+  if (ArrayBuffer.isView(value)) {
+    return {
+      type: value.constructor.name,
+      values: [...new Uint8Array(value.buffer, value.byteOffset, value.byteLength)]
+    };
+  }
+  if (value instanceof Map) {
+    return [...value].map(([key, item]) => [
+      stableValue(key, assembly, seen),
+      stableValue(item, assembly, seen)
+    ]);
+  }
+  if (value instanceof Set) return [...value].map((item) => stableValue(item, assembly, seen));
+  if (Array.isArray(value)) return value.map((item) => stableValue(item, assembly, seen));
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [
+    key,
+    stableValue(value[key], assembly, seen)
+  ]));
+}
+
+function decodeResolverResult(value, assembly, seen = new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  if (value.__jsilnetAssemblyReference === true) return assembly;
+  if (value.__jsilnetSerializedAssembly instanceof Uint8Array) {
+    return parseAssembly(value.__jsilnetSerializedAssembly);
+  }
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;
+  const output = value instanceof Map
+    ? new Map()
+    : value instanceof Set
+      ? new Set()
+      : Array.isArray(value)
+        ? []
+        : {};
+  seen.set(value, output);
+  if (value instanceof Map) {
+    for (const [key, item] of value) {
+      output.set(
+        decodeResolverResult(key, assembly, seen),
+        decodeResolverResult(item, assembly, seen)
+      );
+    }
+  } else if (value instanceof Set) {
+    for (const item of value) output.add(decodeResolverResult(item, assembly, seen));
+  } else if (Array.isArray(value)) {
+    for (const item of value) output.push(decodeResolverResult(item, assembly, seen));
+  } else {
+    for (const key of Object.keys(value)) {
+      output[key] = decodeResolverResult(value[key], assembly, seen);
+    }
+  }
+  return output;
+}
+
+function restoreCallbacks(value, cache, assembly, seen = new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  if (Number.isInteger(value.__jsilnetCallback)) {
+    const callbackId = value.__jsilnetCallback;
+    return (...args) => {
+      const key = `${callbackId}:${JSON.stringify(stableValue(args, assembly))}`;
+      if (cache.has(key)) return cache.get(key);
+      throw new ResolverRequest(callbackId, args);
+    };
+  }
+  if (seen.has(value)) return seen.get(value);
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) return value;
+  const output = value instanceof Map
+    ? new Map()
+    : value instanceof Set
+      ? new Set()
+      : Array.isArray(value)
+        ? []
+        : {};
+  seen.set(value, output);
+  if (value instanceof Map) {
+    for (const [key, item] of value) {
+      output.set(
+        restoreCallbacks(key, cache, assembly, seen),
+        restoreCallbacks(item, cache, assembly, seen)
+      );
+    }
+  } else if (value instanceof Set) {
+    for (const item of value) output.add(restoreCallbacks(item, cache, assembly, seen));
+  } else if (Array.isArray(value)) {
+    for (const item of value) output.push(restoreCallbacks(item, cache, assembly, seen));
+  } else {
+    for (const key of Object.keys(value)) {
+      output[key] = restoreCallbacks(value[key], cache, assembly, seen);
+    }
+  }
+  return output;
+}
+
+function getState(assembly) {
+  const state = {};
+  for (const key of Object.keys(assembly)) {
+    if (!key.startsWith("_")) state[key] = cloneValue(assembly[key], assembly);
+  }
+  state.bytes = cloneValue(assembly.bytes, assembly);
+  state.modified = assembly.modified;
+  return state;
+}
+
+function serializeError(error) {
+  return {
+    name: error?.name ?? "Error",
+    message: error?.message ?? String(error),
+    offset: error?.offset,
+    context: error?.context
+  };
+}
+
+export function createWorkerController({ requestResolver } = {}) {
+  let assembly = null;
+  let nextResolverRequestId = 0;
+  async function invokeWithResolvers(message, operation, input, activeAssembly, resolveCallback) {
+    const resolverCache = new Map();
+    while (true) {
+      try {
+        return operation(...restoreCallbacks(input, resolverCache, activeAssembly));
+      } catch (error) {
+        if (!(error instanceof ResolverRequest)) throw error;
+        if (typeof resolveCallback !== "function") {
+          throw new Error("Browser resolver callback channel is unavailable");
+        }
+        const resolverRequestId = ++nextResolverRequestId;
+        const value = await new Promise((resolve, reject) => {
+          resolveCallback(
+            message.id,
+            resolverRequestId,
+            error.callbackId,
+            cloneValue(error.args, activeAssembly),
+            (response) => {
+              if (response.ok) resolve(response.value);
+              else {
+                const failure = new Error(
+                  response.error?.message ?? "Resolver callback failed"
+                );
+                failure.name = response.error?.name ?? "Error";
+                reject(failure);
+              }
+            }
+          );
+        });
+        const key = `${error.callbackId}:${JSON.stringify(
+          stableValue(error.args, activeAssembly)
+        )}`;
+        resolverCache.set(key, decodeResolverResult(value, activeAssembly));
+      }
+    }
+  }
+  return async function handle(message, resolveCallback = requestResolver) {
+    try {
+      if (message?.type === "parse") {
+        const input = typeof Blob !== "undefined" && message.input instanceof Blob
+          ? await message.input.arrayBuffer()
+          : message.input;
+        assembly = parseAssembly(input);
+        return { id: message.id, ok: true, value: null };
+      }
+      if (message?.type === "dispose") {
+        assembly = null;
+        return { id: message.id, ok: true, value: null };
+      }
+      if (message?.type === "state") {
+        if (!assembly) throw new Error("No assembly has been loaded");
+        return { id: message.id, ok: true, value: getState(assembly) };
+      }
+      if (message?.type === "call") {
+        if (!assembly) throw new Error("No assembly has been loaded");
+        if (!assemblyMethods.has(message.name)) {
+          throw new TypeError(`Assembly method ${String(message.name)} is not available`);
+        }
+        const result = await invokeWithResolvers(
+          message,
+          (...args) => assembly[message.name](...args),
+          message.args,
+          assembly,
+          resolveCallback
+        );
+        return {
+          id: message.id,
+          ok: true,
+          value: result === assembly
+            ? { __jsilnetAssembly: true }
+            : cloneValue(result, assembly)
+        };
+      }
+      if (message?.type === "utility") {
+        const operation = core[message.name];
+        if (typeof operation !== "function" || message.name === "parseAssembly") {
+          throw new TypeError(`Library utility ${String(message.name)} is not available`);
+        }
+        const result = await invokeWithResolvers(
+          message,
+          operation,
+          message.args,
+          assembly,
+          resolveCallback
+        );
+        return {
+          id: message.id,
+          ok: true,
+          value: cloneValue(result, assembly, new WeakMap(), "encode")
+        };
+      }
+      throw new TypeError("Unknown browser worker request");
+    } catch (error) {
+      return { id: message?.id, ok: false, error: serializeError(error) };
+    }
+  };
+}

package/src/browser/worker.js

@@ -0,0 +1,47 @@
+import { createWorkerController } from "./worker-runtime.js";
+
+const handle = createWorkerController();
+const pendingResolvers = new Map();
+
+function collectTransferables(value, transferables = new Set(), seen = new WeakSet()) {
+  if (value === null || typeof value !== "object" || seen.has(value)) return transferables;
+  seen.add(value);
+  if (value instanceof ArrayBuffer) {
+    transferables.add(value);
+  } else if (ArrayBuffer.isView(value)) {
+    if (value.buffer instanceof ArrayBuffer) transferables.add(value.buffer);
+  } else if (value instanceof Map) {
+    for (const [key, item] of value) {
+      collectTransferables(key, transferables, seen);
+      collectTransferables(item, transferables, seen);
+    }
+  } else if (value instanceof Set || Array.isArray(value)) {
+    for (const item of value) collectTransferables(item, transferables, seen);
+  } else {
+    for (const item of Object.values(value)) collectTransferables(item, transferables, seen);
+  }
+  return transferables;
+}
+
+function requestResolver(id, resolverRequestId, callbackId, args, resolve) {
+  const key = `${id}:${resolverRequestId}`;
+  pendingResolvers.set(key, resolve);
+  const request = { type: "resolver", id, resolverRequestId, callbackId, args };
+  self.postMessage(request, [...collectTransferables(request)]);
+}
+
+self.addEventListener("message", async (event) => {
+  const message = event.data;
+  if (message?.type === "resolverResult") {
+    const key = `${message.id}:${message.resolverRequestId}`;
+    const resolve = pendingResolvers.get(key);
+    if (!resolve) return;
+    pendingResolvers.delete(key);
+    resolve(message);
+    return;
+  }
+  const response = await handle(message, (id, resolverRequestId, callbackId, args, resolve) => {
+    requestResolver(id, resolverRequestId, callbackId, args, resolve);
+  });
+  self.postMessage(response, [...collectTransferables(response)]);
+});