export-runtime 0.0.2 → 0.0.3

package/client.js

@@ -162,12 +162,28 @@ __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++;
@@ -179,6 +195,10 @@ const sendRequest = async (msg) => {
 
 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;
 
@@ -201,6 +221,43 @@ ws.onmessage = (event) => {
         }
       };
       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);
     }
@@ -208,6 +265,11 @@ 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);
   }
 };
 
@@ -249,5 +311,26 @@ const createProxy = (path = []) => new Proxy(function(){}, {
   }
 });
 
+// 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,6 +13,9 @@ 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));
 
@@ -20,8 +23,11 @@ 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));
@@ -43,6 +49,12 @@ export const createHandler = (exports) => {
             const msg = parse(event.data);
             const { type, id, path = [], args = [], iteratorId, instanceId } = msg;
 
+            // Keepalive ping/pong
+            if (type === "ping") {
+              send(server, { type: "pong", id });
+              return;
+            }
+
             if (type === "construct") {
               // Class instantiation
               try {
@@ -86,7 +98,11 @@ export const createHandler = (exports) => {
                 // Await result to support both sync and async functions
                 const result = await target.apply(thisArg, args);
 
-                if (isAsyncIterable(result)) {
+                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" });
@@ -152,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);
@@ -161,6 +270,8 @@ 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.2",
+  "version": "0.0.3",
   "description": "Cloudflare Workers ESM Export Framework Runtime",
   "keywords": [
     "cloudflare",