export-runtime 0.0.6 → 0.0.7

package/bin/generate-types.mjs

@@ -220,25 +220,88 @@ lines.push("}>;");
 
 const typeDefinitions = lines.join("\n");
 
-// --- Minify core module ---
+// --- Minify core modules ---
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const { CORE_CODE } = await import(path.join(__dirname, "..", "client.js"));
+const { CORE_CODE, SHARED_CORE_CODE } = await import(path.join(__dirname, "..", "client.js"));
 
-// CORE_CODE uses import.meta.url for WS URL — no placeholders needed.
 const minified = minifySync("_core.js", CORE_CODE);
 if (minified.errors?.length) {
-  console.error("Minification errors:", minified.errors);
+  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 that exports type definitions, minified core, and core ID
+// Write as a JS module
 const outPath = path.join(cwd, ".export-types.js");
 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,27 +1,19 @@
-// Core module code - self-contained ES module that derives WS URL from import.meta.url.
-// Served at /_core.js with long cache. Exports createProxy and createUploadStream.
-export const CORE_CODE = `
+// 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) {
@@ -38,73 +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);
 };
 
-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)) {
@@ -125,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);
@@ -145,38 +102,29 @@ const parse = (serialized) => {
       hydrated[index] = obj;
       for (const key in value) obj[key] = hydrate(value[key]);
     }
-
     return hydrated[index];
   };
-
   return hydrate(0);
 };
 
-const _u = new URL("./", import.meta.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 = () => {
     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;
@@ -187,135 +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);
-
-  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") {
-      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") {
-      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") {
-    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 });
   }
 };
 
-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;
-};
+const createInstanceProxy = (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 () => 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 });
+  }
+});
 
 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 });
-  }
+  async apply(_, __, args) { return sendRequest({ type: "call", path, args }); },
+  construct(_, args) { return sendRequest({ type: "construct", path, args }); }
 });
 
 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 };
+  const { writableId } = await sendRequest({ type: "writable-create" });
+  return { stream: makeWritable(writableId), writableId };
 };
 `;
+
+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, { minifiedCore, coreId } 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, minifiedCore, coreId);
+export default createHandler(userExports, generatedTypes, minifiedCore, coreId, minifiedSharedCore);

package/handler.js

@@ -1,395 +1,133 @@
 import { stringify, parse } from "devalue";
-import { CORE_CODE } from "./client.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 isClass = (fn) =>
-  typeof fn === "function" && /^class\s/.test(Function.prototype.toString.call(fn));
-
-// Runtime fallback: generate TypeScript type definitions from exports
-const generateTypeDefinitions = (exports, keys) => {
-  const lines = [
-    "// Auto-generated type definitions",
-    "// All functions are async over the network",
-    "",
-  ];
-
-  for (const name of keys) {
-    const value = exports[name];
-    if (isClass(value)) {
-      const proto = value.prototype;
-      const methodNames = Object.getOwnPropertyNames(proto).filter(
-        (n) => n !== "constructor" && typeof proto[n] === "function"
-      );
-      lines.push(`export declare class ${name} {`);
-      lines.push(`  constructor(...args: any[]);`);
-      for (const method of methodNames) {
-        lines.push(`  ${method}(...args: any[]): Promise<any>;`);
-      }
-      lines.push(`  [Symbol.dispose](): Promise<void>;`);
-      lines.push(`  "[release]"(): Promise<void>;`);
-      lines.push(`}`);
-    } else if (typeof value === "function") {
-      const fnStr = Function.prototype.toString.call(value);
-      if (fnStr.startsWith("async function*") || fnStr.includes("async *")) {
-        lines.push(`export declare function ${name}(...args: any[]): Promise<AsyncIterable<any>>;`);
-      } else if (fnStr.includes("ReadableStream")) {
-        lines.push(`export declare function ${name}(...args: any[]): Promise<ReadableStream<any>>;`);
-      } else {
-        lines.push(`export declare function ${name}(...args: any[]): Promise<any>;`);
-      }
-    } else if (typeof value === "object" && value !== null) {
-      const keys = Object.keys(value);
-      lines.push(`export declare const ${name}: {`);
-      for (const key of keys) {
-        const v = value[key];
-        if (typeof v === "function") {
-          lines.push(`  ${key}(...args: any[]): Promise<any>;`);
-        } else {
-          lines.push(`  ${key}: any;`);
-        }
-      }
-      lines.push(`};`);
-    } else {
-      lines.push(`export declare const ${name}: any;`);
-    }
-    lines.push("");
-  }
-
-  lines.push("export declare function createUploadStream(): Promise<{");
-  lines.push("  stream: WritableStream<any>;");
-  lines.push("  writableId: number;");
-  lines.push("}>;");
-
-  return lines.join("\n");
-};
+import { CORE_CODE, SHARED_CORE_CODE } from "./client.js";
+import { createRpcDispatcher } from "./rpc.js";
 
+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 jsHeaders = (extra = {}) => ({
-  "Content-Type": "application/javascript; charset=utf-8",
-  "Access-Control-Allow-Origin": "*",
-  ...extra,
-});
+const jsResponse = (body, extra = {}) =>
+  new Response(body, { headers: { "Content-Type": JS, ...CORS, ...extra } });
 
-const tsHeaders = () => ({
-  "Content-Type": "application/typescript; charset=utf-8",
-  "Access-Control-Allow-Origin": "*",
-  "Cache-Control": "no-cache",
-});
+const tsResponse = (body, status = 200) =>
+  new Response(body, { status, headers: { "Content-Type": TS, ...CORS, "Cache-Control": "no-cache" } });
 
-export const createHandler = (exports, generatedTypes, minifiedCore, coreId) => {
+export const createHandler = (exports, generatedTypes, minifiedCore, coreId, minifiedSharedCore) => {
   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 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);
+    }
+  };
+
+  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");
 
-      // --- WebSocket upgrade (path-agnostic) ---
-      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;
-
-            if (type === "ping") {
-              send(server, { type: "pong", id });
-              return;
-            }
-
-            if (type === "construct") {
-              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) {
-                  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 {
-                  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 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" });
-                } 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") {
-              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") {
-              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") {
-              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") {
-              const { streamId } = msg;
-              const entry = streamStore.get(streamId);
-              if (!entry) {
-                send(server, { type: "error", id, error: "Stream not found" });
-                return;
-              }
-              try {
-                let reader = entry.reader;
-                if (!reader) {
-                  reader = entry.stream.getReader();
-                  entry.reader = reader;
-                }
-                const { value, done } = await reader.read();
-                if (done) {
-                  streamStore.delete(streamId);
-                }
-                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") {
-              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") {
-              const { targetPath, targetInstanceId } = msg;
-              let chunks = [];
-              const writableId = nextStreamId++;
-
-              const writable = new WritableStream({
-                write(chunk) { chunks.push(chunk); },
-                close() {},
-                abort(reason) { chunks = []; }
-              });
-
-              writableStreamStore.set(writableId, { writable, chunks, targetPath, targetInstanceId });
-              send(server, { type: "result", id, writableId, valueType: "writablestream" });
-            } else if (type === "writable-write") {
-              const { writableId, chunk } = msg;
-              const entry = writableStreamStore.get(writableId);
-              if (!entry) {
-                send(server, { type: "error", id, error: "WritableStream not found" });
-                return;
-              }
-              try {
-                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") {
-              const { writableId } = msg;
-              const entry = writableStreamStore.get(writableId);
-              if (!entry) {
-                send(server, { type: "error", id, error: "WritableStream not found" });
-                return;
-              }
-              writableStreamStore.delete(writableId);
-              send(server, { type: "result", id, value: entry.chunks });
-            } else if (type === "writable-abort") {
-              const { writableId } = msg;
-              writableStreamStore.delete(writableId);
-              send(server, { type: "result", id, value: true });
-            }
-          } catch (err) {
-            console.error("WebSocket message error:", err);
-          }
-        });
-
-        server.addEventListener("close", () => {
-          iteratorStore.clear();
-          instanceStore.clear();
-          streamStore.clear();
-          writableStreamStore.clear();
-        });
+        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());
+        }
 
         return new Response(null, { status: 101, webSocket: client });
       }
 
       // --- HTTP routing ---
-
-      const fullTypes = generatedTypes || generateTypeDefinitions(exports, exportKeys);
       const pathname = url.pathname;
 
-      // Serve core module — long-cached, content-independent of deployment URL
-      if (pathname === corePath) {
-        return new Response(coreModuleCode, {
-          headers: jsHeaders({ "Cache-Control": "public, max-age=31536000, immutable" }),
-        });
-      }
+      // Core modules (cached immutably)
+      if (pathname === corePath) return jsResponse(coreModuleCode, { "Cache-Control": IMMUTABLE });
+      if (pathname === sharedCorePath) return jsResponse(sharedCoreModuleCode, { "Cache-Control": IMMUTABLE });
 
       // Type definitions
-      if (url.searchParams.has("types") || pathname.endsWith(".d.ts")) {
-        if (pathname === "/" || pathname.endsWith(".d.ts")) {
-          return new Response(fullTypes, { headers: tsHeaders() });
-        }
-        // Per-export types — re-export from root to avoid duplication
+      if (url.searchParams.has("types")) {
+        if (pathname === "/") return tsResponse(generatedTypes || "");
         const name = pathname.slice(1);
-        if (exportKeys.includes(name)) {
-          const code = `export { ${name} as default, ${name} } from "./?types";`;
-          return new Response(code, { headers: tsHeaders() });
-        }
-        return new Response("// Export not found", { status: 404, headers: tsHeaders() });
+        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 || "");
 
       const baseUrl = `${url.protocol}//${url.host}`;
+      const cpath = isShared ? sharedCorePath : corePath;
 
-      // Root — re-exports all from ${corePath}
+      // Root module
       if (pathname === "/") {
-        const namedExports = exportKeys
-          .map((key) => `export const ${key} = createProxy([${JSON.stringify(key)}]);`)
-          .join("\n");
-        const code = [
-          `import { createProxy, createUploadStream } from ".${corePath}";`,
-          namedExports,
-          `export { createUploadStream };`,
-        ].join("\n");
-
-        return new Response(code, {
-          headers: jsHeaders({
-            "Cache-Control": "no-cache",
-            "X-TypeScript-Types": `${baseUrl}/?types`,
-          }),
+        return jsResponse(buildIndexModule(cpath), {
+          "Cache-Control": "no-cache",
+          "X-TypeScript-Types": `${baseUrl}/?types`,
         });
       }
 
-      // Per-export path — e.g. /greet, /Counter
+      // Per-export module
       const exportName = pathname.slice(1);
       if (exportKeys.includes(exportName)) {
-        const code = [
-          `import { createProxy } from ".${corePath}";`,
-          `const _export = createProxy([${JSON.stringify(exportName)}]);`,
-          `export default _export;`,
-          `export { _export as ${exportName} };`,
-        ].join("\n");
-
-        return new Response(code, {
-          headers: jsHeaders({
-            "Cache-Control": "no-cache",
-            "X-TypeScript-Types": `${baseUrl}/${exportName}?types`,
-          }),
+        return jsResponse(buildExportModule(cpath, exportName), {
+          "Cache-Control": "no-cache",
+          "X-TypeScript-Types": `${baseUrl}/${exportName}?types`,
         });
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "export-runtime",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Cloudflare Workers ESM Export Framework Runtime",
   "keywords": [
     "cloudflare",
@@ -29,6 +29,8 @@
     "entry.js",
     "handler.js",
     "client.js",
+    "rpc.js",
+    "shared-do.js",
     "bin/generate-types.mjs"
   ],
   "dependencies": {

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); }
+}