export-runtime 0.0.1 → 0.0.3

package/client.js

@@ -162,14 +162,43 @@ __DEVALUE_PARSE__
 const ws = new WebSocket(__WS_URL__);
 const pending = new Map();
 let nextId = 1;
+let keepaliveInterval = null;
 
 const ready = new Promise((resolve, reject) => {
-  ws.onopen = () => resolve(undefined);
+  ws.onopen = () => {
+    // Start keepalive ping every 30 seconds
+    keepaliveInterval = setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(stringify({ type: "ping", id: 0 }));
+      }
+    }, 30000);
+    resolve(undefined);
+  };
   ws.onerror = (e) => reject(e);
 });
 
+ws.onclose = () => {
+  if (keepaliveInterval) {
+    clearInterval(keepaliveInterval);
+    keepaliveInterval = null;
+  }
+};
+
+const sendRequest = async (msg) => {
+  await ready;
+  const id = nextId++;
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+    ws.send(stringify({ ...msg, id }));
+  });
+};
+
 ws.onmessage = (event) => {
   const msg = parse(event.data);
+
+  // Ignore pong responses (keepalive)
+  if (msg.type === "pong") return;
+
   const resolver = pending.get(msg.id);
   if (!resolver) return;
 
@@ -179,27 +208,56 @@ ws.onmessage = (event) => {
   } else if (msg.type === "result") {
     if (msg.valueType === "function") {
       resolver.resolve(createProxy(msg.path));
+    } else if (msg.valueType === "instance") {
+      resolver.resolve(createInstanceProxy(msg.instanceId));
     } else if (msg.valueType === "asynciterator") {
       const iteratorProxy = {
         [Symbol.asyncIterator]() { return this; },
         async next() {
-          await ready;
-          const id = nextId++;
-          return new Promise((resolve, reject) => {
-            pending.set(id, { resolve, reject });
-            ws.send(stringify({ type: "iterate-next", id, iteratorId: msg.iteratorId }));
-          });
+          return sendRequest({ type: "iterate-next", iteratorId: msg.iteratorId });
         },
         async return(value) {
-          await ready;
-          const id = nextId++;
-          return new Promise((resolve, reject) => {
-            pending.set(id, { resolve, reject });
-            ws.send(stringify({ type: "iterate-return", id, iteratorId: msg.iteratorId, value }));
-          });
+          return sendRequest({ type: "iterate-return", iteratorId: msg.iteratorId, value });
         }
       };
       resolver.resolve(iteratorProxy);
+    } else if (msg.valueType === "readablestream") {
+      // Create a ReadableStream proxy that pulls from server
+      const streamId = msg.streamId;
+      const stream = new ReadableStream({
+        async pull(controller) {
+          try {
+            const result = await sendRequest({ type: "stream-read", streamId });
+            if (result.done) {
+              controller.close();
+            } else {
+              controller.enqueue(result.value);
+            }
+          } catch (err) {
+            controller.error(err);
+          }
+        },
+        async cancel() {
+          await sendRequest({ type: "stream-cancel", streamId });
+        }
+      });
+      resolver.resolve(stream);
+    } else if (msg.valueType === "writablestream") {
+      // Create a WritableStream proxy that pushes to server
+      const writableId = msg.writableId;
+      const stream = new WritableStream({
+        async write(chunk) {
+          const data = chunk instanceof Uint8Array ? Array.from(chunk) : chunk;
+          await sendRequest({ type: "writable-write", writableId, chunk: data });
+        },
+        async close() {
+          await sendRequest({ type: "writable-close", writableId });
+        },
+        async abort(reason) {
+          await sendRequest({ type: "writable-abort", writableId });
+        }
+      });
+      resolver.resolve(stream);
     } else {
       resolver.resolve(msg.value);
     }
@@ -207,23 +265,72 @@ ws.onmessage = (event) => {
   } else if (msg.type === "iterate-result") {
     resolver.resolve({ value: msg.value, done: msg.done });
     pending.delete(msg.id);
+  } else if (msg.type === "stream-result") {
+    // Convert array back to Uint8Array if it was serialized
+    const value = Array.isArray(msg.value) ? new Uint8Array(msg.value) : msg.value;
+    resolver.resolve({ value, done: msg.done });
+    pending.delete(msg.id);
   }
 };
 
+// Proxy for remote class instances
+const createInstanceProxy = (instanceId, path = []) => {
+  const proxy = new Proxy(function(){}, {
+    get(_, prop) {
+      if (prop === "then" || prop === Symbol.toStringTag) return undefined;
+      if (prop === Symbol.dispose || prop === Symbol.asyncDispose) {
+        return () => sendRequest({ type: "release", instanceId });
+      }
+      if (prop === "[release]") {
+        return () => sendRequest({ type: "release", instanceId });
+      }
+      return createInstanceProxy(instanceId, [...path, prop]);
+    },
+    set(_, prop, value) {
+      sendRequest({ type: "set", instanceId, path: [...path, prop], args: [value] });
+      return true;
+    },
+    async apply(_, __, args) {
+      return sendRequest({ type: "call", instanceId, path, args });
+    }
+  });
+  return proxy;
+};
+
+// Proxy for exports (functions, classes, objects)
 const createProxy = (path = []) => new Proxy(function(){}, {
   get(_, prop) {
     if (prop === "then" || prop === Symbol.toStringTag) return undefined;
     return createProxy([...path, prop]);
   },
   async apply(_, __, args) {
-    await ready;
-    const id = nextId++;
-    return new Promise((resolve, reject) => {
-      pending.set(id, { resolve, reject });
-      ws.send(stringify({ type: "call", id, path, args }));
-    });
+    return sendRequest({ type: "call", path, args });
+  },
+  construct(_, args) {
+    return sendRequest({ type: "construct", path, args });
   }
 });
 
+// Helper to create a client-side WritableStream that can be passed to server functions
+export const createUploadStream = async () => {
+  const result = await sendRequest({ type: "writable-create" });
+  const writableId = result.writableId;
+
+  const stream = new WritableStream({
+    async write(chunk) {
+      const data = chunk instanceof Uint8Array ? Array.from(chunk) : chunk;
+      await sendRequest({ type: "writable-write", writableId, chunk: data });
+    },
+    async close() {
+      return sendRequest({ type: "writable-close", writableId });
+    },
+    async abort(reason) {
+      await sendRequest({ type: "writable-abort", writableId });
+    }
+  });
+
+  return { stream, writableId };
+};
+
 __NAMED_EXPORTS__
 `;

package/handler.js

@@ -13,10 +13,21 @@ const getByPath = (obj, path) => {
 const isAsyncIterable = (value) =>
   value != null && typeof value[Symbol.asyncIterator] === "function";
 
+const isReadableStream = (value) =>
+  value != null && typeof value.getReader === "function" && typeof value.pipeTo === "function";
+
+const isClass = (fn) =>
+  typeof fn === "function" && /^class\s/.test(Function.prototype.toString.call(fn));
+
 export const createHandler = (exports) => {
   const exportKeys = Object.keys(exports);
   const iteratorStore = new Map();
+  const instanceStore = new Map();
+  const streamStore = new Map();
+  const writableStreamStore = new Map();
   let nextIteratorId = 1;
+  let nextInstanceId = 1;
+  let nextStreamId = 1;
 
   const send = (ws, data) => {
     ws.send(stringify(data));
@@ -36,18 +47,62 @@ export const createHandler = (exports) => {
         server.addEventListener("message", async (event) => {
           try {
             const msg = parse(event.data);
-            const { type, id, path = [], args = [], iteratorId } = msg;
+            const { type, id, path = [], args = [], iteratorId, instanceId } = msg;
+
+            // Keepalive ping/pong
+            if (type === "ping") {
+              send(server, { type: "pong", id });
+              return;
+            }
 
-            if (type === "call") {
+            if (type === "construct") {
+              // Class instantiation
               try {
-                const fn = getByPath(exports, path);
-                if (typeof fn !== "function") {
+                const Ctor = getByPath(exports, path);
+                if (!isClass(Ctor)) {
+                  send(server, { type: "error", id, error: `${path.join(".")} is not a class` });
+                  return;
+                }
+                const instance = new Ctor(...args);
+                const instId = nextInstanceId++;
+                instanceStore.set(instId, instance);
+                send(server, { type: "result", id, instanceId: instId, valueType: "instance" });
+              } catch (err) {
+                send(server, { type: "error", id, error: String(err) });
+              }
+            } else if (type === "call") {
+              try {
+                let target;
+                let thisArg;
+
+                if (instanceId !== undefined) {
+                  // Method call on instance
+                  const instance = instanceStore.get(instanceId);
+                  if (!instance) {
+                    send(server, { type: "error", id, error: "Instance not found" });
+                    return;
+                  }
+                  target = getByPath(instance, path);
+                  thisArg = path.length > 1 ? getByPath(instance, path.slice(0, -1)) : instance;
+                } else {
+                  // Regular function call
+                  target = getByPath(exports, path);
+                  thisArg = path.length > 1 ? getByPath(exports, path.slice(0, -1)) : undefined;
+                }
+
+                if (typeof target !== "function") {
                   send(server, { type: "error", id, error: `${path.join(".")} is not a function` });
                   return;
                 }
-                const result = await fn.apply(undefined, args);
 
-                if (isAsyncIterable(result)) {
+                // Await result to support both sync and async functions
+                const result = await target.apply(thisArg, args);
+
+                if (isReadableStream(result)) {
+                  const streamId = nextStreamId++;
+                  streamStore.set(streamId, { stream: result, reader: null });
+                  send(server, { type: "result", id, streamId, valueType: "readablestream" });
+                } else if (isAsyncIterable(result)) {
                   const iterId = nextIteratorId++;
                   iteratorStore.set(iterId, result[Symbol.asyncIterator]());
                   send(server, { type: "result", id, iteratorId: iterId, valueType: "asynciterator" });
@@ -59,6 +114,42 @@ export const createHandler = (exports) => {
               } catch (err) {
                 send(server, { type: "error", id, error: String(err) });
               }
+            } else if (type === "get") {
+              // Property access on instance
+              try {
+                const instance = instanceStore.get(instanceId);
+                if (!instance) {
+                  send(server, { type: "error", id, error: "Instance not found" });
+                  return;
+                }
+                const value = getByPath(instance, path);
+                if (typeof value === "function") {
+                  send(server, { type: "result", id, valueType: "function" });
+                } else {
+                  send(server, { type: "result", id, value });
+                }
+              } catch (err) {
+                send(server, { type: "error", id, error: String(err) });
+              }
+            } else if (type === "set") {
+              // Property assignment on instance
+              try {
+                const instance = instanceStore.get(instanceId);
+                if (!instance) {
+                  send(server, { type: "error", id, error: "Instance not found" });
+                  return;
+                }
+                const parent = path.length > 1 ? getByPath(instance, path.slice(0, -1)) : instance;
+                const prop = path[path.length - 1];
+                parent[prop] = args[0];
+                send(server, { type: "result", id, value: true });
+              } catch (err) {
+                send(server, { type: "error", id, error: String(err) });
+              }
+            } else if (type === "release") {
+              // Release instance
+              instanceStore.delete(instanceId);
+              send(server, { type: "result", id, value: true });
             } else if (type === "iterate-next") {
               const iter = iteratorStore.get(iteratorId);
               if (!iter) {
@@ -77,6 +168,99 @@ export const createHandler = (exports) => {
               if (iter?.return) await iter.return(undefined);
               iteratorStore.delete(iteratorId);
               send(server, { type: "iterate-result", id, value: undefined, done: true });
+            } else if (type === "stream-read") {
+              // ReadableStream chunk read
+              const { streamId } = msg;
+              const entry = streamStore.get(streamId);
+              if (!entry) {
+                send(server, { type: "error", id, error: "Stream not found" });
+                return;
+              }
+              try {
+                // Get or create reader for this stream
+                let reader = entry.reader;
+                if (!reader) {
+                  reader = entry.stream.getReader();
+                  entry.reader = reader;
+                }
+                const { value, done } = await reader.read();
+                if (done) {
+                  streamStore.delete(streamId);
+                }
+                // Convert Uint8Array to array for devalue serialization
+                const serializedValue = value instanceof Uint8Array ? Array.from(value) : value;
+                send(server, { type: "stream-result", id, value: serializedValue, done: !!done });
+              } catch (err) {
+                streamStore.delete(streamId);
+                send(server, { type: "error", id, error: String(err) });
+              }
+            } else if (type === "stream-cancel") {
+              // Cancel ReadableStream
+              const { streamId } = msg;
+              const entry = streamStore.get(streamId);
+              if (entry) {
+                try {
+                  if (entry.reader) {
+                    await entry.reader.cancel();
+                  } else {
+                    await entry.stream.cancel();
+                  }
+                } catch (e) { /* ignore */ }
+                streamStore.delete(streamId);
+              }
+              send(server, { type: "result", id, value: true });
+            } else if (type === "writable-create") {
+              // Create a WritableStream on server side
+              const { targetPath, targetInstanceId } = msg;
+              let chunks = [];
+              const writableId = nextStreamId++;
+
+              const writable = new WritableStream({
+                write(chunk) {
+                  chunks.push(chunk);
+                },
+                close() {
+                  // Resolve with all chunks when stream closes
+                },
+                abort(reason) {
+                  chunks = [];
+                }
+              });
+
+              writableStreamStore.set(writableId, { writable, chunks, targetPath, targetInstanceId });
+              send(server, { type: "result", id, writableId, valueType: "writablestream" });
+            } else if (type === "writable-write") {
+              // Write chunk to WritableStream
+              const { writableId, chunk } = msg;
+              const entry = writableStreamStore.get(writableId);
+              if (!entry) {
+                send(server, { type: "error", id, error: "WritableStream not found" });
+                return;
+              }
+              try {
+                // Convert array back to Uint8Array if needed
+                const data = Array.isArray(chunk) ? new Uint8Array(chunk) : chunk;
+                entry.chunks.push(data);
+                send(server, { type: "result", id, value: true });
+              } catch (err) {
+                send(server, { type: "error", id, error: String(err) });
+              }
+            } else if (type === "writable-close") {
+              // Close WritableStream and return collected chunks
+              const { writableId } = msg;
+              const entry = writableStreamStore.get(writableId);
+              if (!entry) {
+                send(server, { type: "error", id, error: "WritableStream not found" });
+                return;
+              }
+              writableStreamStore.delete(writableId);
+              // Return the collected data
+              send(server, { type: "result", id, value: entry.chunks });
+            } else if (type === "writable-abort") {
+              // Abort WritableStream
+              const { writableId } = msg;
+              writableStreamStore.delete(writableId);
+              send(server, { type: "result", id, value: true });
             }
           } catch (err) {
             console.error("WebSocket message error:", err);
@@ -85,6 +269,9 @@ export const createHandler = (exports) => {
 
         server.addEventListener("close", () => {
           iteratorStore.clear();
+          instanceStore.clear();
+          streamStore.clear();
+          writableStreamStore.clear();
         });
 
         return new Response(null, { status: 101, webSocket: client });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "export-runtime",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Cloudflare Workers ESM Export Framework Runtime",
   "keywords": [
     "cloudflare",