export-runtime 0.0.5 → 0.0.7

package/bin/generate-types.mjs

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 
 import { parseSync } from "oxc-parser";
+import { minifySync } from "oxc-minify";
+import crypto from "crypto";
 import fs from "fs";
 import path from "path";
+import { fileURLToPath } from "url";
 
 const cwd = process.cwd();
 
@@ -217,7 +220,88 @@ lines.push("}>;");
 
 const typeDefinitions = lines.join("\n");
 
-// Write as a JS module that exports the string
+// --- Minify core modules ---
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const { CORE_CODE, SHARED_CORE_CODE } = await import(path.join(__dirname, "..", "client.js"));
+
+const minified = minifySync("_core.js", CORE_CODE);
+if (minified.errors?.length) {
+  console.error("Minification errors (core):", minified.errors);
+}
+
+const minifiedShared = minifySync("_core-shared.js", SHARED_CORE_CODE);
+if (minifiedShared.errors?.length) {
+  console.error("Minification errors (shared core):", minifiedShared.errors);
+}
+
+// Generate a unique ID per build for cache-busting the core module path
+const coreId = crypto.randomUUID();
+
+// Write as a JS module
 const outPath = path.join(cwd, ".export-types.js");
-fs.writeFileSync(outPath, `export default ${JSON.stringify(typeDefinitions)};\n`);
-console.log("Generated type definitions →", outPath);
+fs.writeFileSync(outPath, [
+  `export default ${JSON.stringify(typeDefinitions)};`,
+  `export const minifiedCore = ${JSON.stringify(minified.code)};`,
+  `export const minifiedSharedCore = ${JSON.stringify(minifiedShared.code)};`,
+  `export const coreId = ${JSON.stringify(coreId)};`,
+].join("\n") + "\n");
+
+// Generate Worker-side shared import module (.export-shared.js)
+const exportNames = [];
+for (const node of program.body) {
+  if (node.type !== "ExportNamedDeclaration" || !node.declaration) continue;
+  const decl = node.declaration;
+  if (decl.id?.name) exportNames.push(decl.id.name);
+  else if (decl.declarations) {
+    for (const d of decl.declarations) {
+      if (d.id?.name) exportNames.push(d.id.name);
+    }
+  }
+}
+
+const sharedModulePath = path.join(cwd, ".export-shared.js");
+const sharedModuleLines = [
+  `import { env } from "cloudflare:workers";`,
+  ``,
+  `const getStub = (room = "default") =>`,
+  `  env.SHARED_EXPORT.get(env.SHARED_EXPORT.idFromName(room));`,
+  ``,
+  `const createSharedInstanceProxy = (stub, instanceId, path = []) =>`,
+  `  new Proxy(function(){}, {`,
+  `    get(_, prop) {`,
+  `      if (prop === "then" || prop === Symbol.toStringTag) return undefined;`,
+  `      if (prop === Symbol.dispose || prop === Symbol.asyncDispose || prop === "[release]")`,
+  `        return () => stub.rpcRelease(instanceId);`,
+  `      return createSharedInstanceProxy(stub, instanceId, [...path, prop]);`,
+  `    },`,
+  `    async apply(_, __, args) {`,
+  `      const r = await stub.rpcInstanceCall(instanceId, path, args);`,
+  `      return r.value;`,
+  `    },`,
+  `  });`,
+  ``,
+  `const createSharedProxy = (stub, path = []) =>`,
+  `  new Proxy(function(){}, {`,
+  `    get(_, prop) {`,
+  `      if (prop === "then" || prop === Symbol.toStringTag) return undefined;`,
+  `      return createSharedProxy(stub, [...path, prop]);`,
+  `    },`,
+  `    async apply(_, __, args) {`,
+  `      const r = await stub.rpcCall(path, args);`,
+  `      return r.value;`,
+  `    },`,
+  `    async construct(_, args) {`,
+  `      const r = await stub.rpcConstruct(path, args);`,
+  `      return createSharedInstanceProxy(stub, r.instanceId);`,
+  `    },`,
+  `  });`,
+  ``,
+  `const _stub = getStub();`,
+  ...exportNames.map(n => `export const ${n} = createSharedProxy(_stub, [${JSON.stringify(n)}]);`),
+  `export { getStub };`,
+];
+fs.writeFileSync(sharedModulePath, sharedModuleLines.join("\n") + "\n");
+
+console.log("Generated type definitions + minified core →", outPath);
+console.log("Generated shared import module →", sharedModulePath);

package/client.js

@@ -1,26 +1,19 @@
-// Minimal devalue stringify implementation (compatible with sveltejs/devalue)
-export const DEVALUE_STRINGIFY = `
+// Core module template. __WS_SUFFIX__ is replaced: "./" for normal, "./?shared" for shared.
+const CORE_TEMPLATE = `
 const stringify = (value) => {
   const stringified = [];
   const indexes = new Map();
   let p = 0;
-
   const flatten = (thing) => {
-    if (typeof thing === 'function') {
-      throw new Error('Cannot stringify a function');
-    }
-
+    if (typeof thing === 'function') throw new Error('Cannot stringify a function');
     if (indexes.has(thing)) return indexes.get(thing);
-
     if (thing === undefined) return -1;
     if (Number.isNaN(thing)) return -3;
     if (thing === Infinity) return -4;
     if (thing === -Infinity) return -5;
     if (thing === 0 && 1 / thing < 0) return -6;
-
     const index = p++;
     indexes.set(thing, index);
-
     if (typeof thing === 'boolean' || typeof thing === 'number' || typeof thing === 'string' || thing === null) {
       stringified[index] = thing;
     } else if (thing instanceof Date) {
@@ -37,76 +30,37 @@ const stringify = (value) => {
       stringified[index] = ['Set', ...[...thing].map(flatten)];
     } else if (thing instanceof Map) {
       stringified[index] = ['Map', ...[...thing].map(([k, v]) => [flatten(k), flatten(v)])];
-    } else if (thing instanceof Int8Array) {
-      stringified[index] = ['Int8Array', ...[...thing].map(flatten)];
-    } else if (thing instanceof Uint8Array) {
-      stringified[index] = ['Uint8Array', ...[...thing].map(flatten)];
-    } else if (thing instanceof Uint8ClampedArray) {
-      stringified[index] = ['Uint8ClampedArray', ...[...thing].map(flatten)];
-    } else if (thing instanceof Int16Array) {
-      stringified[index] = ['Int16Array', ...[...thing].map(flatten)];
-    } else if (thing instanceof Uint16Array) {
-      stringified[index] = ['Uint16Array', ...[...thing].map(flatten)];
-    } else if (thing instanceof Int32Array) {
-      stringified[index] = ['Int32Array', ...[...thing].map(flatten)];
-    } else if (thing instanceof Uint32Array) {
-      stringified[index] = ['Uint32Array', ...[...thing].map(flatten)];
-    } else if (thing instanceof Float32Array) {
-      stringified[index] = ['Float32Array', ...[...thing].map(flatten)];
-    } else if (thing instanceof Float64Array) {
-      stringified[index] = ['Float64Array', ...[...thing].map(flatten)];
-    } else if (thing instanceof BigInt64Array) {
-      stringified[index] = ['BigInt64Array', ...[...thing].map(flatten)];
-    } else if (thing instanceof BigUint64Array) {
-      stringified[index] = ['BigUint64Array', ...[...thing].map(flatten)];
+    } else if (ArrayBuffer.isView(thing)) {
+      stringified[index] = [thing[Symbol.toStringTag], ...[...thing].map(flatten)];
     } else if (thing instanceof ArrayBuffer) {
       stringified[index] = ['ArrayBuffer', ...[...new Uint8Array(thing)].map(flatten)];
     } else if (Array.isArray(thing)) {
       stringified[index] = thing.map(flatten);
     } else if (typeof thing === 'object') {
       const obj = {};
-      for (const key of Object.keys(thing)) {
-        obj[key] = flatten(thing[key]);
-      }
+      for (const key of Object.keys(thing)) obj[key] = flatten(thing[key]);
       stringified[index] = obj;
     } else {
       throw new Error('Cannot stringify ' + typeof thing);
     }
-
     return index;
   };
-
   flatten(value);
   return JSON.stringify(stringified);
 };
-`;
-
-// Minimal devalue parse implementation (compatible with sveltejs/devalue)
-export const DEVALUE_PARSE = `
-const UNDEFINED = -1;
-const HOLE = -2;
-const NAN = -3;
-const POSITIVE_INFINITY = -4;
-const NEGATIVE_INFINITY = -5;
-const NEGATIVE_ZERO = -6;
 
 const parse = (serialized) => {
   if (serialized === '') return undefined;
   const values = JSON.parse(serialized);
   const hydrated = new Array(values.length);
-
   const hydrate = (index) => {
-    if (index === UNDEFINED) return undefined;
-    if (index === HOLE) return undefined;
-    if (index === NAN) return NaN;
-    if (index === POSITIVE_INFINITY) return Infinity;
-    if (index === NEGATIVE_INFINITY) return -Infinity;
-    if (index === NEGATIVE_ZERO) return -0;
-
+    if (index === -1 || index === -2) return undefined;
+    if (index === -3) return NaN;
+    if (index === -4) return Infinity;
+    if (index === -5) return -Infinity;
+    if (index === -6) return -0;
     if (hydrated[index] !== undefined) return hydrated[index];
-
     const value = values[index];
-
     if (typeof value === 'number' || typeof value === 'string' || typeof value === 'boolean' || value === null) {
       hydrated[index] = value;
     } else if (Array.isArray(value)) {
@@ -127,15 +81,16 @@ const parse = (serialized) => {
             break;
           case 'ArrayBuffer': {
             const bytes = value.slice(1).map(hydrate);
-            const buffer = new ArrayBuffer(bytes.length);
-            new Uint8Array(buffer).set(bytes);
-            hydrated[index] = buffer;
+            const buf = new ArrayBuffer(bytes.length);
+            new Uint8Array(buf).set(bytes);
+            hydrated[index] = buf;
             break;
           }
-          default:
+          default: {
             const arr = new Array(value.length);
             hydrated[index] = arr;
             for (let i = 0; i < value.length; i++) arr[i] = hydrate(value[i]);
+          }
         }
       } else {
         const arr = new Array(value.length);
@@ -147,42 +102,29 @@ const parse = (serialized) => {
       hydrated[index] = obj;
       for (const key in value) obj[key] = hydrate(value[key]);
     }
-
     return hydrated[index];
   };
-
   return hydrate(0);
 };
-`;
-
-export const CLIENT_CODE = `
-__DEVALUE_STRINGIFY__
-__DEVALUE_PARSE__
 
-const ws = new WebSocket(__WS_URL__);
+const _u = new URL("__WS_SUFFIX__", import.meta.url);
+_u.protocol = _u.protocol === "https:" ? "wss:" : "ws:";
+const ws = new WebSocket(_u.href);
 const pending = new Map();
 let nextId = 1;
-let keepaliveInterval = null;
+let keepaliveInterval;
 
 const ready = new Promise((resolve, reject) => {
   ws.onopen = () => {
-    // Start keepalive ping every 30 seconds
     keepaliveInterval = setInterval(() => {
-      if (ws.readyState === WebSocket.OPEN) {
-        ws.send(stringify({ type: "ping", id: 0 }));
-      }
+      if (ws.readyState === WebSocket.OPEN) ws.send(stringify({ type: "ping", id: 0 }));
     }, 30000);
-    resolve(undefined);
+    resolve();
   };
-  ws.onerror = (e) => reject(e);
+  ws.onerror = reject;
 });
 
-ws.onclose = () => {
-  if (keepaliveInterval) {
-    clearInterval(keepaliveInterval);
-    keepaliveInterval = null;
-  }
-};
+ws.onclose = () => { clearInterval(keepaliveInterval); };
 
 const sendRequest = async (msg) => {
   await ready;
@@ -193,144 +135,76 @@ const sendRequest = async (msg) => {
   });
 };
 
+const makeWritable = (writableId) => new WritableStream({
+  async write(chunk) {
+    await sendRequest({ type: "writable-write", writableId, chunk: chunk instanceof Uint8Array ? Array.from(chunk) : chunk });
+  },
+  async close() { await sendRequest({ type: "writable-close", writableId }); },
+  async abort() { await sendRequest({ type: "writable-abort", writableId }); }
+});
+
 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;
+  pending.delete(msg.id);
 
   if (msg.type === "error") {
     resolver.reject(new Error(msg.error));
-    pending.delete(msg.id);
   } 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() {
-          return sendRequest({ type: "iterate-next", iteratorId: msg.iteratorId });
-        },
-        async return(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);
-    }
-    pending.delete(msg.id);
+    if (msg.valueType === "function") resolver.resolve(createProxy(msg.path));
+    else if (msg.valueType === "instance") resolver.resolve(createInstanceProxy(msg.instanceId));
+    else if (msg.valueType === "asynciterator") resolver.resolve({
+      [Symbol.asyncIterator]() { return this; },
+      next: () => sendRequest({ type: "iterate-next", iteratorId: msg.iteratorId }),
+      return: () => sendRequest({ type: "iterate-return", iteratorId: msg.iteratorId })
+    });
+    else if (msg.valueType === "readablestream") resolver.resolve(new ReadableStream({
+      async pull(c) {
+        try { const r = await sendRequest({ type: "stream-read", streamId: msg.streamId }); r.done ? c.close() : c.enqueue(r.value); }
+        catch (e) { c.error(e); }
+      },
+      cancel: () => sendRequest({ type: "stream-cancel", streamId: msg.streamId })
+    }));
+    else if (msg.valueType === "writablestream") resolver.resolve(makeWritable(msg.writableId));
+    else resolver.resolve(msg.value);
   } 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);
+    resolver.resolve({ value: Array.isArray(msg.value) ? new Uint8Array(msg.value) : msg.value, done: msg.done });
   }
 };
 
-// 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(){}, {
+const createInstanceProxy = (instanceId, path = []) => new Proxy(function(){}, {
   get(_, prop) {
     if (prop === "then" || prop === Symbol.toStringTag) return undefined;
-    return createProxy([...path, prop]);
+    if (prop === Symbol.dispose || prop === Symbol.asyncDispose || prop === "[release]")
+      return () => sendRequest({ type: "release", instanceId });
+    return createInstanceProxy(instanceId, [...path, prop]);
   },
-  async apply(_, __, args) {
-    return sendRequest({ type: "call", path, args });
+  set(_, prop, value) {
+    sendRequest({ type: "set", instanceId, path: [...path, prop], args: [value] });
+    return true;
   },
-  construct(_, args) {
-    return sendRequest({ type: "construct", path, args });
+  async apply(_, __, args) {
+    return sendRequest({ type: "call", instanceId, 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 });
-    }
-  });
+export const createProxy = (path = []) => new Proxy(function(){}, {
+  get(_, prop) {
+    if (prop === "then" || prop === Symbol.toStringTag) return undefined;
+    return createProxy([...path, prop]);
+  },
+  async apply(_, __, args) { return sendRequest({ type: "call", path, args }); },
+  construct(_, args) { return sendRequest({ type: "construct", path, args }); }
+});
 
-  return { stream, writableId };
+export const createUploadStream = async () => {
+  const { writableId } = await sendRequest({ type: "writable-create" });
+  return { stream: makeWritable(writableId), writableId };
 };
-
-__NAMED_EXPORTS__
 `;
+
+export const CORE_CODE = CORE_TEMPLATE.replace("__WS_SUFFIX__", "./");
+export const SHARED_CORE_CODE = CORE_TEMPLATE.replace("__WS_SUFFIX__", "./?shared");

package/entry.js

@@ -1,5 +1,6 @@
 import * as userExports from "__USER_MODULE__";
-import generatedTypes from "__GENERATED_TYPES__";
+import generatedTypes, { minifiedCore, minifiedSharedCore, coreId } from "__GENERATED_TYPES__";
 import { createHandler } from "./handler.js";
+export { SharedExportDO } from "./shared-do.js";
 
-export default createHandler(userExports, generatedTypes);
+export default createHandler(userExports, generatedTypes, minifiedCore, coreId, minifiedSharedCore);

package/handler.js

@@ -1,391 +1,137 @@
 import { stringify, parse } from "devalue";
-import { CLIENT_CODE, DEVALUE_PARSE, DEVALUE_STRINGIFY } from "./client.js";
+import { CORE_CODE, SHARED_CORE_CODE } from "./client.js";
+import { createRpcDispatcher } from "./rpc.js";
 
-const getByPath = (obj, path) => {
-  let current = obj;
-  for (const key of path) {
-    if (current == null) return undefined;
-    current = current[key];
-  }
-  return current;
-};
-
-const isAsyncIterable = (value) =>
-  value != null && typeof value[Symbol.asyncIterator] === "function";
-
-const isReadableStream = (value) =>
-  value != null && typeof value.getReader === "function" && typeof value.pipeTo === "function";
+const JS = "application/javascript; charset=utf-8";
+const TS = "application/typescript; charset=utf-8";
+const CORS = { "Access-Control-Allow-Origin": "*" };
+const IMMUTABLE = "public, max-age=31536000, immutable";
 
-const isClass = (fn) =>
-  typeof fn === "function" && /^class\s/.test(Function.prototype.toString.call(fn));
+const jsResponse = (body, extra = {}) =>
+  new Response(body, { headers: { "Content-Type": JS, ...CORS, ...extra } });
 
-// Generate TypeScript type definitions from exports
-const generateTypeDefinitions = (exports, exportKeys) => {
-  const lines = [
-    "// Auto-generated type definitions",
-    "// All functions are async over the network",
-    "",
-  ];
+const tsResponse = (body, status = 200) =>
+  new Response(body, { status, headers: { "Content-Type": TS, ...CORS, "Cache-Control": "no-cache" } });
 
-  const generateType = (value, name, indent = "") => {
-    if (isClass(value)) {
-      // Extract class method names
-      const proto = value.prototype;
-      const methodNames = Object.getOwnPropertyNames(proto).filter(
-        (n) => n !== "constructor" && typeof proto[n] === "function"
-      );
+export const createHandler = (exports, generatedTypes, minifiedCore, coreId, minifiedSharedCore) => {
+  const exportKeys = Object.keys(exports);
 
-      lines.push(`${indent}export declare class ${name} {`);
-      lines.push(`${indent}  constructor(...args: any[]);`);
-      for (const method of methodNames) {
-        lines.push(`${indent}  ${method}(...args: any[]): Promise<any>;`);
-      }
-      lines.push(`${indent}  [Symbol.dispose](): Promise<void>;`);
-      lines.push(`${indent}  "[release]"(): Promise<void>;`);
-      lines.push(`${indent}}`);
-    } else if (typeof value === "function") {
-      // Check if it's an async generator
-      const fnStr = Function.prototype.toString.call(value);
-      if (fnStr.startsWith("async function*") || fnStr.includes("async *")) {
-        lines.push(
-          `${indent}export declare function ${name}(...args: any[]): Promise<AsyncIterable<any>>;`
-        );
-      } else if (fnStr.includes("ReadableStream")) {
-        lines.push(
-          `${indent}export declare function ${name}(...args: any[]): Promise<ReadableStream<any>>;`
-        );
-      } else {
-        lines.push(
-          `${indent}export declare function ${name}(...args: any[]): Promise<any>;`
-        );
-      }
-    } else if (typeof value === "object" && value !== null) {
-      // Nested object with methods
-      const keys = Object.keys(value);
-      lines.push(`${indent}export declare const ${name}: {`);
-      for (const key of keys) {
-        const v = value[key];
-        if (typeof v === "function") {
-          lines.push(`${indent}  ${key}(...args: any[]): Promise<any>;`);
-        } else {
-          lines.push(`${indent}  ${key}: any;`);
-        }
-      }
-      lines.push(`${indent}};`);
-    } else {
-      lines.push(`${indent}export declare const ${name}: any;`);
+  const coreModuleCode = minifiedCore || CORE_CODE;
+  const sharedCoreModuleCode = minifiedSharedCore || SHARED_CORE_CODE;
+  const corePath = `/${coreId || crypto.randomUUID()}.js`;
+  const sharedCorePath = corePath.replace(".js", "-shared.js");
+
+  // Pre-generate the named exports string (same for shared and normal, only import source differs)
+  const namedExportsCode = exportKeys
+    .map((key) => `export const ${key} = createProxy([${JSON.stringify(key)}]);`)
+    .join("\n");
+
+  const buildIndexModule = (cpath) =>
+    `import { createProxy, createUploadStream } from ".${cpath}";\n${namedExportsCode}\nexport { createUploadStream };`;
+
+  const buildExportModule = (cpath, name) =>
+    `import { createProxy } from ".${cpath}";\nconst _export = createProxy([${JSON.stringify(name)}]);\nexport default _export;\nexport { _export as ${name} };`;
+
+  // Dispatch a parsed devalue message to an RPC dispatcher
+  const dispatchMessage = async (dispatcher, msg) => {
+    const { type, path = [], args = [], instanceId, iteratorId, streamId, writableId, chunk } = msg;
+    switch (type) {
+      case "ping": return { type: "pong" };
+      case "call":
+        return instanceId !== undefined
+          ? dispatcher.rpcInstanceCall(instanceId, path, args)
+          : dispatcher.rpcCall(path, args);
+      case "construct": return dispatcher.rpcConstruct(path, args);
+      case "get": return dispatcher.rpcGet(instanceId, path);
+      case "set": return dispatcher.rpcSet(instanceId, path, args[0]);
+      case "release": return dispatcher.rpcRelease(instanceId);
+      case "iterate-next": return dispatcher.rpcIterateNext(iteratorId);
+      case "iterate-return": return dispatcher.rpcIterateReturn(iteratorId);
+      case "stream-read": return dispatcher.rpcStreamRead(streamId);
+      case "stream-cancel": return dispatcher.rpcStreamCancel(streamId);
+      case "writable-create": return dispatcher.rpcWritableCreate();
+      case "writable-write": return dispatcher.rpcWritableWrite(writableId, chunk);
+      case "writable-close": return dispatcher.rpcWritableClose(writableId);
+      case "writable-abort": return dispatcher.rpcWritableAbort(writableId);
     }
   };
 
-  for (const key of exportKeys) {
-    generateType(exports[key], key);
-    lines.push("");
-  }
-
-  // Add createUploadStream helper type
-  lines.push("export declare function createUploadStream(): Promise<{");
-  lines.push("  stream: WritableStream<any>;");
-  lines.push("  writableId: number;");
-  lines.push("}>;");
-
-  return lines.join("\n");
-};
-
-export const createHandler = (exports, generatedTypes) => {
-  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));
+  const wireWebSocket = (server, dispatcher, onClose) => {
+    server.addEventListener("message", async (event) => {
+      let id;
+      try {
+        const msg = parse(event.data);
+        id = msg.id;
+        const result = await dispatchMessage(dispatcher, msg);
+        if (result) server.send(stringify({ ...result, id }));
+      } catch (err) {
+        if (id !== undefined) server.send(stringify({ type: "error", id, error: String(err) }));
+      }
+    });
+    if (onClose) server.addEventListener("close", onClose);
   };
 
   return {
-    async fetch(request) {
+    async fetch(request, env) {
       const url = new URL(request.url);
-      const upgradeHeader = request.headers.get("Upgrade");
+      const isShared = url.searchParams.has("shared");
 
-      if (upgradeHeader === "websocket") {
+      // --- WebSocket upgrade ---
+      if (request.headers.get("Upgrade") === "websocket") {
         const pair = new WebSocketPair();
         const [client, server] = Object.values(pair);
-
         server.accept();
 
-        server.addEventListener("message", async (event) => {
-          try {
-            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 {
-                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 (isShared && env?.SHARED_EXPORT) {
+          const room = url.searchParams.get("room") || "default";
+          const stub = env.SHARED_EXPORT.get(env.SHARED_EXPORT.idFromName(room));
+          wireWebSocket(server, stub);
+        } else {
+          const dispatcher = createRpcDispatcher(exports);
+          wireWebSocket(server, dispatcher, () => dispatcher.clearAll());
+        }
 
-                if (typeof target !== "function") {
-                  send(server, { type: "error", id, error: `${path.join(".")} is not a function` });
-                  return;
-                }
+        return new Response(null, { status: 101, webSocket: client });
+      }
 
-                // Await result to support both sync and async functions
-                const result = await target.apply(thisArg, args);
+      // --- HTTP routing ---
+      const pathname = url.pathname;
 
-                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" });
-                } else if (typeof result === "function") {
-                  send(server, { type: "result", id, path: [...path], valueType: "function" });
-                } else {
-                  send(server, { type: "result", id, value: result });
-                }
-              } 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) {
-                send(server, { type: "error", id, error: "Iterator not found" });
-                return;
-              }
-              try {
-                const { value, done } = await iter.next();
-                if (done) iteratorStore.delete(iteratorId);
-                send(server, { type: "iterate-result", id, value, done: !!done });
-              } catch (err) {
-                send(server, { type: "error", id, error: String(err) });
-              }
-            } else if (type === "iterate-return") {
-              const iter = iteratorStore.get(iteratorId);
-              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++;
+      // Core modules (cached immutably)
+      if (pathname === corePath) return jsResponse(coreModuleCode, { "Cache-Control": IMMUTABLE });
+      if (pathname === sharedCorePath) return jsResponse(sharedCoreModuleCode, { "Cache-Control": IMMUTABLE });
 
-              const writable = new WritableStream({
-                write(chunk) {
-                  chunks.push(chunk);
-                },
-                close() {
-                  // Resolve with all chunks when stream closes
-                },
-                abort(reason) {
-                  chunks = [];
-                }
-              });
+      // Type definitions
+      if (url.searchParams.has("types")) {
+        if (pathname === "/") return tsResponse(generatedTypes || "");
+        const name = pathname.slice(1);
+        return exportKeys.includes(name)
+          ? tsResponse(`export { ${name} as default, ${name} } from "./?types";`)
+          : tsResponse("// Export not found", 404);
+      }
+      if (pathname.endsWith(".d.ts")) return tsResponse(generatedTypes || "");
 
-              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);
-          }
-        });
+      const baseUrl = `${url.protocol}//${url.host}`;
+      const cpath = isShared ? sharedCorePath : corePath;
 
-        server.addEventListener("close", () => {
-          iteratorStore.clear();
-          instanceStore.clear();
-          streamStore.clear();
-          writableStreamStore.clear();
+      // Root module
+      if (pathname === "/") {
+        return jsResponse(buildIndexModule(cpath), {
+          "Cache-Control": "no-cache",
+          "X-TypeScript-Types": `${baseUrl}/?types`,
         });
-
-        return new Response(null, { status: 101, webSocket: client });
       }
 
-      const wsProtocol = url.protocol === "https:" ? "wss:" : "ws:";
-      const wsUrl = `${wsProtocol}//${url.host}${url.pathname}`;
-
-      // Serve TypeScript type definitions
-      if (url.searchParams.has("types") || url.pathname.endsWith(".d.ts")) {
-        const typeDefinitions = generatedTypes || generateTypeDefinitions(exports, exportKeys);
-        return new Response(typeDefinitions, {
-          headers: {
-            "Content-Type": "application/typescript; charset=utf-8",
-            "Access-Control-Allow-Origin": "*",
-            "Cache-Control": "no-cache",
-          },
+      // Per-export module
+      const exportName = pathname.slice(1);
+      if (exportKeys.includes(exportName)) {
+        return jsResponse(buildExportModule(cpath, exportName), {
+          "Cache-Control": "no-cache",
+          "X-TypeScript-Types": `${baseUrl}/${exportName}?types`,
         });
       }
 
-      // Generate named exports
-      const namedExports = exportKeys
-        .map((key) => `export const ${key} = createProxy([${JSON.stringify(key)}]);`)
-        .join("\n");
-
-      const clientCode = CLIENT_CODE
-        .replace("__WS_URL__", JSON.stringify(wsUrl))
-        .replace("__DEVALUE_STRINGIFY__", DEVALUE_STRINGIFY)
-        .replace("__DEVALUE_PARSE__", DEVALUE_PARSE)
-        .replace("__NAMED_EXPORTS__", namedExports);
-
-      // Build types URL for X-TypeScript-Types header
-      const typesUrl = `${url.protocol}//${url.host}${url.pathname}?types`;
-
-      return new Response(clientCode, {
-        headers: {
-          "Content-Type": "application/javascript; charset=utf-8",
-          "Access-Control-Allow-Origin": "*",
-          "Cache-Control": "no-cache",
-          "X-TypeScript-Types": typesUrl,
-        },
-      });
+      return new Response("Not found", { status: 404 });
     },
   };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "export-runtime",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Cloudflare Workers ESM Export Framework Runtime",
   "keywords": [
     "cloudflare",
@@ -29,10 +29,13 @@
     "entry.js",
     "handler.js",
     "client.js",
+    "rpc.js",
+    "shared-do.js",
     "bin/generate-types.mjs"
   ],
   "dependencies": {
     "devalue": "^5.1.1",
+    "oxc-minify": "^0.121.0",
     "oxc-parser": "^0.121.0"
   }
 }

package/rpc.js

@@ -0,0 +1,161 @@
+export const getByPath = (obj, path) => {
+  let current = obj;
+  for (const key of path) {
+    if (current == null) return undefined;
+    current = current[key];
+  }
+  return current;
+};
+
+export const isAsyncIterable = (value) =>
+  value != null && typeof value[Symbol.asyncIterator] === "function";
+
+export const isReadableStream = (value) =>
+  value != null && typeof value.getReader === "function" && typeof value.pipeTo === "function";
+
+export const isClass = (fn) =>
+  typeof fn === "function" && /^class\s/.test(Function.prototype.toString.call(fn));
+
+export const RPC_METHODS = [
+  "rpcCall", "rpcConstruct", "rpcInstanceCall", "rpcGet", "rpcSet", "rpcRelease",
+  "rpcIterateNext", "rpcIterateReturn", "rpcStreamRead", "rpcStreamCancel",
+  "rpcWritableCreate", "rpcWritableWrite", "rpcWritableClose", "rpcWritableAbort",
+];
+
+export function createRpcDispatcher(exports) {
+  const instances = new Map();
+  const iterators = new Map();
+  const streams = new Map();
+  const writables = new Map();
+  let nextId = 1;
+
+  const requireInstance = (id) => {
+    const inst = instances.get(id);
+    if (!inst) throw new Error("Instance not found");
+    return inst;
+  };
+
+  const wrapResult = (result, path) => {
+    if (isReadableStream(result)) {
+      const id = nextId++;
+      streams.set(id, { stream: result, reader: null });
+      return { type: "result", streamId: id, valueType: "readablestream" };
+    }
+    if (isAsyncIterable(result)) {
+      const id = nextId++;
+      iterators.set(id, result[Symbol.asyncIterator]());
+      return { type: "result", iteratorId: id, valueType: "asynciterator" };
+    }
+    if (typeof result === "function") {
+      return { type: "result", path: [...path], valueType: "function" };
+    }
+    return { type: "result", value: result };
+  };
+
+  const callTarget = async (obj, path, args) => {
+    const target = getByPath(obj, path);
+    const thisArg = path.length > 1 ? getByPath(obj, path.slice(0, -1)) : (obj === exports ? undefined : obj);
+    if (typeof target !== "function") throw new Error(`${path.join(".")} is not a function`);
+    return wrapResult(await target.apply(thisArg, args), path);
+  };
+
+  return {
+    rpcCall: (path, args = []) => callTarget(exports, path, args),
+
+    async rpcConstruct(path, args = []) {
+      const Ctor = getByPath(exports, path);
+      if (!isClass(Ctor)) throw new Error(`${path.join(".")} is not a class`);
+      const id = nextId++;
+      instances.set(id, new Ctor(...args));
+      return { type: "result", instanceId: id, valueType: "instance" };
+    },
+
+    rpcInstanceCall: (instanceId, path, args = []) =>
+      callTarget(requireInstance(instanceId), path, args),
+
+    async rpcGet(instanceId, path) {
+      const value = getByPath(requireInstance(instanceId), path);
+      return typeof value === "function"
+        ? { type: "result", valueType: "function" }
+        : { type: "result", value };
+    },
+
+    async rpcSet(instanceId, path, value) {
+      const inst = requireInstance(instanceId);
+      const parent = path.length > 1 ? getByPath(inst, path.slice(0, -1)) : inst;
+      parent[path.at(-1)] = value;
+      return { type: "result", value: true };
+    },
+
+    async rpcRelease(instanceId) {
+      instances.delete(instanceId);
+      return { type: "result", value: true };
+    },
+
+    async rpcIterateNext(iteratorId) {
+      const iter = iterators.get(iteratorId);
+      if (!iter) throw new Error("Iterator not found");
+      const { value, done } = await iter.next();
+      if (done) iterators.delete(iteratorId);
+      return { type: "iterate-result", value, done: !!done };
+    },
+
+    async rpcIterateReturn(iteratorId) {
+      const iter = iterators.get(iteratorId);
+      if (iter?.return) await iter.return(undefined);
+      iterators.delete(iteratorId);
+      return { type: "iterate-result", value: undefined, done: true };
+    },
+
+    async rpcStreamRead(streamId) {
+      const entry = streams.get(streamId);
+      if (!entry) throw new Error("Stream not found");
+      if (!entry.reader) entry.reader = entry.stream.getReader();
+      const { value, done } = await entry.reader.read();
+      if (done) streams.delete(streamId);
+      const v = value instanceof Uint8Array ? Array.from(value) : value;
+      return { type: "stream-result", value: v, done: !!done };
+    },
+
+    async rpcStreamCancel(streamId) {
+      const entry = streams.get(streamId);
+      if (entry) {
+        try { await (entry.reader || entry.stream).cancel(); } catch {}
+        streams.delete(streamId);
+      }
+      return { type: "result", value: true };
+    },
+
+    async rpcWritableCreate() {
+      const id = nextId++;
+      writables.set(id, { chunks: [] });
+      return { type: "result", writableId: id, valueType: "writablestream" };
+    },
+
+    async rpcWritableWrite(writableId, chunk) {
+      const entry = writables.get(writableId);
+      if (!entry) throw new Error("WritableStream not found");
+      entry.chunks.push(Array.isArray(chunk) ? new Uint8Array(chunk) : chunk);
+      return { type: "result", value: true };
+    },
+
+    async rpcWritableClose(writableId) {
+      const entry = writables.get(writableId);
+      if (!entry) throw new Error("WritableStream not found");
+      writables.delete(writableId);
+      return { type: "result", value: entry.chunks };
+    },
+
+    async rpcWritableAbort(writableId) {
+      writables.delete(writableId);
+      return { type: "result", value: true };
+    },
+
+    clearAll() {
+      instances.clear();
+      iterators.clear();
+      streams.clear();
+      writables.clear();
+    },
+  };
+}

package/shared-do.js

@@ -0,0 +1,25 @@
+import { DurableObject } from "cloudflare:workers";
+import * as userExports from "__USER_MODULE__";
+import { createRpcDispatcher } from "./rpc.js";
+
+export class SharedExportDO extends DurableObject {
+  #d;
+  constructor(ctx, env) {
+    super(ctx, env);
+    this.#d = createRpcDispatcher(userExports);
+  }
+  rpcCall(p, a) { return this.#d.rpcCall(p, a); }
+  rpcConstruct(p, a) { return this.#d.rpcConstruct(p, a); }
+  rpcInstanceCall(i, p, a) { return this.#d.rpcInstanceCall(i, p, a); }
+  rpcGet(i, p) { return this.#d.rpcGet(i, p); }
+  rpcSet(i, p, v) { return this.#d.rpcSet(i, p, v); }
+  rpcRelease(i) { return this.#d.rpcRelease(i); }
+  rpcIterateNext(i) { return this.#d.rpcIterateNext(i); }
+  rpcIterateReturn(i) { return this.#d.rpcIterateReturn(i); }
+  rpcStreamRead(s) { return this.#d.rpcStreamRead(s); }
+  rpcStreamCancel(s) { return this.#d.rpcStreamCancel(s); }
+  rpcWritableCreate() { return this.#d.rpcWritableCreate(); }
+  rpcWritableWrite(w, c) { return this.#d.rpcWritableWrite(w, c); }
+  rpcWritableClose(w) { return this.#d.rpcWritableClose(w); }
+  rpcWritableAbort(w) { return this.#d.rpcWritableAbort(w); }
+}