export-runtime 0.0.1 → 0.0.2

package/client.js

@@ -168,6 +168,15 @@ const ready = new Promise((resolve, reject) => {
   ws.onerror = (e) => reject(e);
 });
 
+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);
   const resolver = pending.get(msg.id);
@@ -179,24 +188,16 @@ 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);
@@ -210,18 +211,41 @@ ws.onmessage = (event) => {
   }
 };
 
+// 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 });
   }
 });
 

package/handler.js

@@ -13,10 +13,15 @@ const getByPath = (obj, path) => {
 const isAsyncIterable = (value) =>
   value != null && typeof value[Symbol.asyncIterator] === "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();
   let nextIteratorId = 1;
+  let nextInstanceId = 1;
 
   const send = (ws, data) => {
     ws.send(stringify(data));
@@ -36,16 +41,50 @@ 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;
 
-            if (type === "call") {
+            if (type === "construct") {
+              // Class instantiation
+              try {
+                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 {
-                const fn = getByPath(exports, path);
-                if (typeof fn !== "function") {
+                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);
+
+                // Await result to support both sync and async functions
+                const result = await target.apply(thisArg, args);
 
                 if (isAsyncIterable(result)) {
                   const iterId = nextIteratorId++;
@@ -59,6 +98,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) {
@@ -85,6 +160,7 @@ export const createHandler = (exports) => {
 
         server.addEventListener("close", () => {
           iteratorStore.clear();
+          instanceStore.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.2",
   "description": "Cloudflare Workers ESM Export Framework Runtime",
   "keywords": [
     "cloudflare",