exoagent 0.0.1 → 0.0.2

package/dist/{code-mode-runtime.mjs → capnweb/index.js}

@@ -1,5 +1,7 @@
-// packages/capnweb/dist/index.js
+// src/symbols.ts
 var WORKERS_MODULE_SYMBOL = /* @__PURE__ */ Symbol("workers-module");
+
+// src/core.ts
 if (!Symbol.dispose) {
   Symbol.dispose = /* @__PURE__ */ Symbol.for("dispose");
 }
@@ -23,6 +25,9 @@ var RpcTarget = workersModule ? workersModule.RpcTarget : class {
 var AsyncFunction = (async function() {
 }).constructor;
 var getGlobalRpcSessionOptions = () => ({});
+var setGlobalRpcSessionOptions = (options) => {
+  getGlobalRpcSessionOptions = options;
+};
 var CALLBACK_CLEANUP = /* @__PURE__ */ Symbol("callback-cleanup");
 function typeForRpc(value) {
   switch (typeof value) {
@@ -292,6 +297,17 @@ function unwrapStubNoProperties(stub) {
   }
   return hook;
 }
+function takeOwnership(fn) {
+  const cleanup = fn[CALLBACK_CLEANUP];
+  if (cleanup) {
+    fn[Symbol.dispose] = cleanup;
+    delete fn[CALLBACK_CLEANUP];
+  } else if (!fn[Symbol.dispose]) {
+    fn[Symbol.dispose] = () => {
+    };
+  }
+  return fn;
+}
 function unwrapStubOrParent(stub) {
   return stub[RAW_STUB].hook;
 }
@@ -1097,6 +1113,8 @@ var PromiseStubHook = class _PromiseStubHook extends StubHook {
     }
   }
 };
+
+// src/map.ts
 var currentMapBuilder;
 var MapBuilder = class {
   context;
@@ -1361,9 +1379,15 @@ mapImpl.applyMap = (input, parent, owner, captures, instructions) => {
     }
   }
 };
+
+// src/serialize.ts
 var isExplicitCallback = (arg) => {
   return typeof arg === "function" && "serializationMode" in arg;
 };
+var explicitCallback = (fn, serializationMode) => {
+  fn.serializationMode = serializationMode;
+  return fn;
+};
 var NullExporter = class {
   exportStub(stub) {
     throw new Error("Cannot serialize RPC stubs without an RPC session.");
@@ -1575,6 +1599,9 @@ var Devaluator = class _Devaluator {
     return [type, exportId];
   }
 };
+function serialize(value) {
+  return JSON.stringify(Devaluator.devaluate(value));
+}
 var NullImporter = class {
   importStub(idx) {
     throw new Error("Cannot deserialize RPC stubs without an RPC session.");
@@ -1832,6 +1859,11 @@ var Evaluator = class _Evaluator {
     }
   }
 };
+function deserialize(value) {
+  let payload = new Evaluator(NULL_IMPORTER).evaluate(JSON.parse(value));
+  payload.dispose();
+  return payload.value;
+}
 var maybeUnwrapStubHook = (hook) => {
   if (!(hook instanceof PayloadStubHook)) {
     return void 0;
@@ -1847,6 +1879,8 @@ var maybeUnwrapStubHook = (hook) => {
   }
   return void 0;
 };
+
+// src/rpc.ts
 var ImportTableEntry = class {
   constructor(session, importId, pulling) {
     this.session = session;
@@ -2411,109 +2445,327 @@ var RpcSession = class {
     return this.#session.drain();
   }
 };
-var RpcSession2 = RpcSession;
 
-// src/stream-transport.ts
-function concatBuffers(a, b) {
-  const result = new Uint8Array(a.length + b.length);
-  result.set(a, 0);
-  result.set(b, a.length);
-  return result;
+// src/websocket.ts
+function newWebSocketRpcSession(webSocket, localMain, options) {
+  if (typeof webSocket === "string") {
+    webSocket = new WebSocket(webSocket);
+  }
+  let transport = new WebSocketTransport(webSocket);
+  let rpc = new RpcSession(transport, localMain, options);
+  return rpc.getRemoteMain();
 }
-var BufferedReader = class {
-  buffer;
-  reader;
-  constructor(input) {
-    this.buffer = new Uint8Array(0);
-    this.reader = input.getReader();
-  }
-  async read(numberOfBytes) {
-    if (numberOfBytes <= 0) {
-      throw new Error("numberOfBytes must be positive");
-    }
-    while (this.buffer.length < numberOfBytes) {
-      const result2 = await this.reader.read();
-      if (result2.done || result2.value == null) {
-        throw new Error("Stream closed");
-      }
-      this.buffer = concatBuffers(this.buffer, result2.value);
-    }
-    const result = this.buffer.slice(0, numberOfBytes);
-    this.buffer = this.buffer.slice(numberOfBytes);
-    return result;
+function newWorkersWebSocketRpcResponse(request, localMain, options) {
+  if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") {
+    return new Response("This endpoint only accepts WebSocket requests.", { status: 400 });
+  }
+  let pair = new WebSocketPair();
+  let server = pair[0];
+  server.accept();
+  newWebSocketRpcSession(server, localMain, options);
+  return new Response(null, {
+    status: 101,
+    webSocket: pair[1]
+  });
+}
+var WebSocketTransport = class {
+  constructor(webSocket) {
+    this.#webSocket = webSocket;
+    if (webSocket.readyState === WebSocket.CONNECTING) {
+      this.#sendQueue = [];
+      webSocket.addEventListener("open", (event) => {
+        try {
+          for (let message of this.#sendQueue) {
+            webSocket.send(message);
+          }
+        } catch (err) {
+          this.#receivedError(err);
+        }
+        this.#sendQueue = void 0;
+      });
+    }
+    webSocket.addEventListener("message", (event) => {
+      if (this.#error) ; else if (typeof event.data === "string") {
+        if (this.#receiveResolver) {
+          this.#receiveResolver(event.data);
+          this.#receiveResolver = void 0;
+          this.#receiveRejecter = void 0;
+        } else {
+          this.#receiveQueue.push(event.data);
+        }
+      } else {
+        this.#receivedError(new TypeError("Received non-string message from WebSocket."));
+      }
+    });
+    webSocket.addEventListener("close", (event) => {
+      this.#receivedError(new Error(`Peer closed WebSocket: ${event.code} ${event.reason}`));
+    });
+    webSocket.addEventListener("error", (event) => {
+      this.#receivedError(new Error(`WebSocket connection failed.`));
+    });
+  }
+  #webSocket;
+  #sendQueue;
+  // only if not opened yet
+  #receiveResolver;
+  #receiveRejecter;
+  #receiveQueue = [];
+  #error;
+  async send(message) {
+    if (this.#sendQueue === void 0) {
+      this.#webSocket.send(message);
+    } else {
+      this.#sendQueue.push(message);
+    }
+  }
+  async receive() {
+    if (this.#receiveQueue.length > 0) {
+      return this.#receiveQueue.shift();
+    } else if (this.#error) {
+      throw this.#error;
+    } else {
+      return new Promise((resolve, reject) => {
+        this.#receiveResolver = resolve;
+        this.#receiveRejecter = reject;
+      });
+    }
+  }
+  abort(reason) {
+    let message;
+    if (reason instanceof Error) {
+      message = reason.message;
+    } else {
+      message = `${reason}`;
+    }
+    this.#webSocket.close(3e3, message);
+    if (!this.#error) {
+      this.#error = reason;
+    }
+  }
+  #receivedError(reason) {
+    if (!this.#error) {
+      this.#error = reason;
+      if (this.#receiveRejecter) {
+        this.#receiveRejecter(reason);
+        this.#receiveResolver = void 0;
+        this.#receiveRejecter = void 0;
+      }
+    }
   }
 };
-var StreamTransport = class {
-  constructor(input, output) {
-    this.input = input;
-    this.output = output;
-    this.bufferReader = new BufferedReader(input);
-    this.writer = output.getWriter();
-  }
-  bufferReader;
-  writer;
+
+// src/batch.ts
+var BatchClientTransport = class {
+  constructor(sendBatch) {
+    this.#promise = this.#scheduleBatch(sendBatch);
+  }
+  #promise;
+  #aborted;
+  #batchToSend = [];
+  #batchToReceive = null;
   async send(message) {
-    const encoder = new TextEncoder();
-    const messageBytes = encoder.encode(message);
-    const length = messageBytes.length;
-    if (length > 4294967295) {
-      throw new Error("Message length exceeds maximum allowed size (4GB)");
-    }
-    const lengthBytes = new Uint8Array(4);
-    const view = new DataView(lengthBytes.buffer);
-    view.setUint32(0, length, true);
-    const combined = new Uint8Array(4 + length);
-    combined.set(lengthBytes, 0);
-    combined.set(messageBytes, 4);
-    await this.writer.write(combined);
+    if (this.#batchToSend !== null) {
+      this.#batchToSend.push(message);
+    }
   }
   async receive() {
-    const lengthBytes = await this.bufferReader.read(4);
-    const lengthBuffer = new Uint8Array(lengthBytes).buffer;
-    const length = new DataView(lengthBuffer).getUint32(0, true);
-    if (length > 100 * 1024 * 1024) {
-      throw new Error("Message length exceeds maximum allowed size");
+    if (!this.#batchToReceive) {
+      await this.#promise;
     }
-    if (length === 0) {
-      return "";
+    let msg = this.#batchToReceive.shift();
+    if (msg !== void 0) {
+      return msg;
+    } else {
+      throw new Error("Batch RPC request ended.");
     }
-    const messageBytes = await this.bufferReader.read(length);
-    const decoder = new TextDecoder();
-    return decoder.decode(messageBytes);
   }
   abort(reason) {
-    this.input.cancel(reason).catch(() => {
-    });
-    this.writer.close().catch(() => {
-    });
+    this.#aborted = reason;
+  }
+  async #scheduleBatch(sendBatch) {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    if (this.#aborted !== void 0) {
+      throw this.#aborted;
+    }
+    let batch = this.#batchToSend;
+    this.#batchToSend = null;
+    this.#batchToReceive = await sendBatch(batch);
   }
 };
-
-// src/code-mode-runtime.ts
-async function run(context) {
-  const transport = new StreamTransport(context.input, context.output);
-  try {
-    const session = new RpcSession2(transport);
-    const api = session.getRemoteMain();
-    const code = await api.__code__();
-    const fn = new Function("api", `return (${code})(api)`);
-    const result = await fn(api);
-    await api.__return__(result);
-  } finally {
-    transport.abort("done");
+function newHttpBatchRpcSession(urlOrRequest, options) {
+  let sendBatch = async (batch) => {
+    let response = await fetch(urlOrRequest, {
+      method: "POST",
+      body: batch.join("\n")
+    });
+    if (!response.ok) {
+      response.body?.cancel();
+      throw new Error(`RPC request failed: ${response.status} ${response.statusText}`);
+    }
+    let body = await response.text();
+    return body == "" ? [] : body.split("\n");
+  };
+  let transport = new BatchClientTransport(sendBatch);
+  let rpc = new RpcSession(transport, void 0, options);
+  return rpc.getRemoteMain();
+}
+var BatchServerTransport = class {
+  constructor(batch) {
+    this.#batchToReceive = batch;
+  }
+  #batchToSend = [];
+  #batchToReceive;
+  #allReceived = Promise.withResolvers();
+  async send(message) {
+    this.#batchToSend.push(message);
+  }
+  async receive() {
+    let msg = this.#batchToReceive.shift();
+    if (msg !== void 0) {
+      return msg;
+    } else {
+      this.#allReceived.resolve();
+      return new Promise((r) => {
+      });
+    }
   }
+  abort(reason) {
+    this.#allReceived.reject(reason);
+  }
+  whenAllReceived() {
+    return this.#allReceived.promise;
+  }
+  getResponseBody() {
+    return this.#batchToSend.join("\n");
+  }
+};
+async function newHttpBatchRpcResponse(request, localMain, options) {
+  if (request.method !== "POST") {
+    return new Response("This endpoint only accepts POST requests.", { status: 405 });
+  }
+  let body = await request.text();
+  let batch = body === "" ? [] : body.split("\n");
+  let transport = new BatchServerTransport(batch);
+  let rpc = new RpcSession(transport, localMain, options);
+  await transport.whenAllReceived();
+  await rpc.drain();
+  return new Response(transport.getResponseBody());
 }
-async function main() {
-  if (!__SANDBOX_CONTEXT_PROMISE__) {
-    throw new TypeError("__SANDBOX_CONTEXT_PROMISE__ was not replaced prior to execution.");
-  }
-  const ctx = await __SANDBOX_CONTEXT_PROMISE__;
-  const { input, output, onSuccess, onFailure } = ctx;
-  return run({ input, output }).then(() => {
-    onSuccess();
-  }).catch((err) => {
-    console.error("runtime error", err);
-    onFailure();
+async function nodeHttpBatchRpcResponse(request, response, localMain, options) {
+  if (request.method !== "POST") {
+    response.writeHead(405, "This endpoint only accepts POST requests.");
+  }
+  let body = await new Promise((resolve, reject) => {
+    let chunks = [];
+    request.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    request.on("end", () => {
+      resolve(Buffer.concat(chunks).toString());
+    });
+    request.on("error", reject);
   });
+  let batch = body === "" ? [] : body.split("\n");
+  let transport = new BatchServerTransport(batch);
+  let rpc = new RpcSession(transport, localMain, options);
+  await transport.whenAllReceived();
+  await rpc.drain();
+  response.writeHead(200, options?.headers);
+  response.end(transport.getResponseBody());
+}
+
+// src/messageport.ts
+function newMessagePortRpcSession(port, localMain, options) {
+  let transport = new MessagePortTransport(port);
+  let rpc = new RpcSession(transport, localMain, options);
+  return rpc.getRemoteMain();
+}
+var MessagePortTransport = class {
+  constructor(port) {
+    this.#port = port;
+    port.start();
+    port.addEventListener("message", (event) => {
+      if (this.#error) ; else if (event.data === null) {
+        this.#receivedError(new Error("Peer closed MessagePort connection."));
+      } else if (typeof event.data === "string") {
+        if (this.#receiveResolver) {
+          this.#receiveResolver(event.data);
+          this.#receiveResolver = void 0;
+          this.#receiveRejecter = void 0;
+        } else {
+          this.#receiveQueue.push(event.data);
+        }
+      } else {
+        this.#receivedError(new TypeError("Received non-string message from MessagePort."));
+      }
+    });
+    port.addEventListener("messageerror", (event) => {
+      this.#receivedError(new Error("MessagePort message error."));
+    });
+  }
+  #port;
+  #receiveResolver;
+  #receiveRejecter;
+  #receiveQueue = [];
+  #error;
+  async send(message) {
+    if (this.#error) {
+      throw this.#error;
+    }
+    this.#port.postMessage(message);
+  }
+  async receive() {
+    if (this.#receiveQueue.length > 0) {
+      return this.#receiveQueue.shift();
+    } else if (this.#error) {
+      throw this.#error;
+    } else {
+      return new Promise((resolve, reject) => {
+        this.#receiveResolver = resolve;
+        this.#receiveRejecter = reject;
+      });
+    }
+  }
+  abort(reason) {
+    try {
+      this.#port.postMessage(null);
+    } catch (err) {
+    }
+    this.#port.close();
+    if (!this.#error) {
+      this.#error = reason;
+    }
+  }
+  #receivedError(reason) {
+    if (!this.#error) {
+      this.#error = reason;
+      if (this.#receiveRejecter) {
+        this.#receiveRejecter(reason);
+        this.#receiveResolver = void 0;
+        this.#receiveRejecter = void 0;
+      }
+    }
+  }
+};
+var RpcStub2 = RpcStub;
+var RpcPromise2 = RpcPromise;
+var RpcSession2 = RpcSession;
+var RpcTarget4 = RpcTarget;
+var newWebSocketRpcSession2 = newWebSocketRpcSession;
+var newHttpBatchRpcSession2 = newHttpBatchRpcSession;
+var newMessagePortRpcSession2 = newMessagePortRpcSession;
+async function newWorkersRpcResponse(request, localMain) {
+  if (request.method === "POST") {
+    let response = await newHttpBatchRpcResponse(request, localMain);
+    response.headers.set("Access-Control-Allow-Origin", "*");
+    return response;
+  } else if (request.headers.get("Upgrade")?.toLowerCase() === "websocket") {
+    return newWorkersWebSocketRpcResponse(request, localMain);
+  } else {
+    return new Response("This endpoint only accepts POST or WebSocket requests.", { status: 400 });
+  }
 }
-main();
+
+export { RpcPromise2 as RpcPromise, RpcSession2 as RpcSession, RpcStub2 as RpcStub, RpcTarget4 as RpcTarget, deserialize, explicitCallback, newHttpBatchRpcResponse, newHttpBatchRpcSession2 as newHttpBatchRpcSession, newMessagePortRpcSession2 as newMessagePortRpcSession, newWebSocketRpcSession2 as newWebSocketRpcSession, newWorkersRpcResponse, newWorkersWebSocketRpcResponse, nodeHttpBatchRpcResponse, serialize, setGlobalRpcSessionOptions, takeOwnership };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map