export-runtime 0.0.7 → 0.0.9

package/bin/generate-types.mjs

@@ -9,7 +9,7 @@ import { fileURLToPath } from "url";
 
 const cwd = process.cwd();
 
-// Read wrangler.toml to find user module path
+// Read wrangler.toml to find source root
 const wranglerPath = path.join(cwd, "wrangler.toml");
 if (!fs.existsSync(wranglerPath)) {
   console.error("wrangler.toml not found in", cwd);
@@ -22,17 +22,41 @@ if (!aliasMatch) {
   process.exit(1);
 }
 
-const userModulePath = path.resolve(cwd, aliasMatch[1]);
-if (!fs.existsSync(userModulePath)) {
-  console.error("User module not found:", userModulePath);
-  process.exit(1);
+// Derive source root directory from the alias (e.g., "./src/index.ts" → "./src")
+const aliasTarget = aliasMatch[1];
+// If alias points to the module map, resolve src dir from it; otherwise derive from file
+const srcDir = aliasTarget.includes(".export-module-map")
+  ? path.resolve(cwd, "src")
+  : path.resolve(cwd, path.dirname(aliasTarget.replace(/^\.\//, "")));
+
+// --- Discover all source files under srcDir ---
+
+const EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
+
+function discoverModules(dir, base = "") {
+  const modules = [];
+  if (!fs.existsSync(dir)) return modules;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      modules.push(...discoverModules(fullPath, base ? `${base}/${entry.name}` : entry.name));
+    } else if (EXTENSIONS.includes(path.extname(entry.name))) {
+      const nameWithoutExt = entry.name.replace(/\.(ts|tsx|js|jsx)$/, "");
+      const routePath = nameWithoutExt === "index"
+        ? base  // index.ts → directory path ("" for root)
+        : (base ? `${base}/${nameWithoutExt}` : nameWithoutExt);
+      modules.push({ routePath, filePath: fullPath });
+    }
+  }
+  return modules;
 }
 
-const source = fs.readFileSync(userModulePath, "utf8");
-const isTS = userModulePath.endsWith(".ts") || userModulePath.endsWith(".tsx");
-const fileName = path.basename(userModulePath);
-const result = parseSync(fileName, source, { sourceType: "module" });
-const program = result.program;
+const modules = discoverModules(srcDir);
+if (modules.length === 0) {
+  console.error("No source files found in", srcDir);
+  process.exit(1);
+}
 
 // --- Type extraction helpers ---
 
@@ -52,14 +76,10 @@ function extractType(node) {
     case "TSBigIntKeyword": return "bigint";
     case "TSSymbolKeyword": return "symbol";
     case "TSObjectKeyword": return "object";
-    case "TSArrayType":
-      return `${extractType(ta.elementType)}[]`;
-    case "TSTupleType":
-      return `[${(ta.elementTypes || []).map(e => extractType(e)).join(", ")}]`;
-    case "TSUnionType":
-      return ta.types.map(t => extractType(t)).join(" | ");
-    case "TSIntersectionType":
-      return ta.types.map(t => extractType(t)).join(" & ");
+    case "TSArrayType": return `${extractType(ta.elementType)}[]`;
+    case "TSTupleType": return `[${(ta.elementTypes || []).map(e => extractType(e)).join(", ")}]`;
+    case "TSUnionType": return ta.types.map(t => extractType(t)).join(" | ");
+    case "TSIntersectionType": return ta.types.map(t => extractType(t)).join(" & ");
     case "TSLiteralType": {
       const lit = ta.literal;
       if (lit.type === "StringLiteral") return JSON.stringify(lit.value);
@@ -94,10 +114,8 @@ function extractType(node) {
       }).filter(Boolean);
       return `{ ${members.join("; ")} }`;
     }
-    case "TSTypeAnnotation":
-      return extractType(ta.typeAnnotation);
-    default:
-      return "any";
+    case "TSTypeAnnotation": return extractType(ta.typeAnnotation);
+    default: return "any";
   }
 }
 
@@ -116,109 +134,110 @@ function extractParams(params) {
   });
 }
 
-// Wrap return type: all functions become async over the network
 function wrapReturnType(returnType, isAsync, isGenerator) {
   if (isGenerator) {
-    // async generator → AsyncIterable<YieldType>
-    // extract inner type from AsyncGenerator<T> if present
     if (returnType.startsWith("AsyncGenerator")) {
       const inner = returnType.match(/^AsyncGenerator<(.+?)(?:,.*)?>/);
       return `Promise<AsyncIterable<${inner ? inner[1] : "any"}>>`;
     }
     return `Promise<AsyncIterable<${returnType === "any" ? "any" : returnType}>>`;
   }
-  // Already Promise<T> → keep as-is
   if (returnType.startsWith("Promise<")) return returnType;
-  // ReadableStream<T> → Promise<ReadableStream<T>>
   if (returnType.startsWith("ReadableStream")) return `Promise<${returnType}>`;
-  // Wrap in Promise
   return `Promise<${returnType}>`;
 }
 
-// --- Generate .d.ts ---
+// --- Extract types and export names from a single file ---
 
-const lines = [
-  "// Auto-generated type definitions (oxc-parser)",
-  "// All functions are async over the network",
-  "",
-];
+function extractFileTypes(filePath) {
+  const source = fs.readFileSync(filePath, "utf8");
+  const fileName = path.basename(filePath);
+  const result = parseSync(fileName, source, { sourceType: "module" });
+  const program = result.program;
 
-for (const node of program.body) {
-  if (node.type !== "ExportNamedDeclaration" || !node.declaration) continue;
-  const decl = node.declaration;
-
-  if (decl.type === "FunctionDeclaration") {
-    const name = decl.id.name;
-    const params = extractParams(decl.params);
-    const rawRet = decl.returnType ? extractType(decl.returnType) : "any";
-    const ret = wrapReturnType(rawRet, decl.async, decl.generator);
-    lines.push(`export declare function ${name}(${params.join(", ")}): ${ret};`);
-    lines.push("");
-
-  } else if (decl.type === "ClassDeclaration") {
-    const name = decl.id.name;
-    lines.push(`export declare class ${name} {`);
-    for (const member of decl.body.body) {
-      if (member.type === "MethodDefinition") {
-        const mName = member.key.name || member.key.value;
-        if (member.kind === "constructor") {
-          const params = extractParams(member.value.params);
-          lines.push(`  constructor(${params.join(", ")});`);
-        } else {
-          const params = extractParams(member.value.params);
-          const rawRet = member.value.returnType ? extractType(member.value.returnType) : "any";
-          const ret = wrapReturnType(rawRet, member.value.async, member.value.generator);
-          lines.push(`  ${mName}(${params.join(", ")}): ${ret};`);
+  const lines = [];
+  const exportNames = [];
+
+  for (const node of program.body) {
+    if (node.type !== "ExportNamedDeclaration" || !node.declaration) continue;
+    const decl = node.declaration;
+
+    if (decl.type === "FunctionDeclaration") {
+      const name = decl.id.name;
+      exportNames.push(name);
+      const params = extractParams(decl.params);
+      const rawRet = decl.returnType ? extractType(decl.returnType) : "any";
+      const ret = wrapReturnType(rawRet, decl.async, decl.generator);
+      lines.push(`export declare function ${name}(${params.join(", ")}): ${ret};`);
+      lines.push("");
+    } else if (decl.type === "ClassDeclaration") {
+      const name = decl.id.name;
+      exportNames.push(name);
+      lines.push(`export declare class ${name} {`);
+      for (const member of decl.body.body) {
+        if (member.type === "MethodDefinition") {
+          const mName = member.key.name || member.key.value;
+          if (member.kind === "constructor") {
+            lines.push(`  constructor(${extractParams(member.value.params).join(", ")});`);
+          } else {
+            const params = extractParams(member.value.params);
+            const rawRet = member.value.returnType ? extractType(member.value.returnType) : "any";
+            const ret = wrapReturnType(rawRet, member.value.async, member.value.generator);
+            lines.push(`  ${mName}(${params.join(", ")}): ${ret};`);
+          }
+        } else if (member.type === "PropertyDefinition") {
+          if (member.accessibility === "private") continue;
+          const mName = member.key.name;
+          const type = member.typeAnnotation ? extractType(member.typeAnnotation) : "any";
+          lines.push(`  ${mName}: ${type};`);
         }
-      } else if (member.type === "PropertyDefinition") {
-        // Skip private members
-        if (member.accessibility === "private") continue;
-        const mName = member.key.name;
-        const type = member.typeAnnotation ? extractType(member.typeAnnotation) : "any";
-        lines.push(`  ${mName}: ${type};`);
       }
-    }
-    lines.push(`  [Symbol.dispose](): Promise<void>;`);
-    lines.push(`  "[release]"(): Promise<void>;`);
-    lines.push(`}`);
-    lines.push("");
-
-  } else if (decl.type === "VariableDeclaration") {
-    for (const d of decl.declarations) {
-      const name = d.id.name;
-      if (d.init?.type === "ObjectExpression") {
-        lines.push(`export declare const ${name}: {`);
-        for (const prop of d.init.properties) {
-          if (prop.type === "SpreadElement") continue;
-          const key = prop.key?.name || prop.key?.value;
-          if (prop.value?.type === "FunctionExpression" || prop.value?.type === "ArrowFunctionExpression") {
-            const params = extractParams(prop.value.params);
-            const rawRet = prop.value.returnType ? extractType(prop.value.returnType) : "any";
-            const ret = wrapReturnType(rawRet, prop.value.async, prop.value.generator);
-            lines.push(`  ${key}(${params.join(", ")}): ${ret};`);
-          } else {
-            const type = d.id.typeAnnotation ? "any" : "any";
-            lines.push(`  ${key}: any;`);
+      lines.push(`  [Symbol.dispose](): Promise<void>;`);
+      lines.push(`  "[release]"(): Promise<void>;`);
+      lines.push(`}`);
+      lines.push("");
+    } else if (decl.type === "VariableDeclaration") {
+      for (const d of decl.declarations) {
+        const name = d.id.name;
+        exportNames.push(name);
+        if (d.init?.type === "ObjectExpression") {
+          lines.push(`export declare const ${name}: {`);
+          for (const prop of d.init.properties) {
+            if (prop.type === "SpreadElement") continue;
+            const key = prop.key?.name || prop.key?.value;
+            if (prop.value?.type === "FunctionExpression" || prop.value?.type === "ArrowFunctionExpression") {
+              const params = extractParams(prop.value.params);
+              const rawRet = prop.value.returnType ? extractType(prop.value.returnType) : "any";
+              const ret = wrapReturnType(rawRet, prop.value.async, prop.value.generator);
+              lines.push(`  ${key}(${params.join(", ")}): ${ret};`);
+            } else {
+              lines.push(`  ${key}: any;`);
+            }
           }
+          lines.push(`};`);
+          lines.push("");
+        } else {
+          const type = d.id.typeAnnotation ? extractType(d.id.typeAnnotation) : "any";
+          lines.push(`export declare const ${name}: ${type};`);
+          lines.push("");
         }
-        lines.push(`};`);
-        lines.push("");
-      } else {
-        const type = d.id.typeAnnotation ? extractType(d.id.typeAnnotation) : "any";
-        lines.push(`export declare const ${name}: ${type};`);
-        lines.push("");
       }
     }
   }
+
+  return { types: lines.join("\n"), exportNames };
 }
 
-// Add createUploadStream helper type
-lines.push("export declare function createUploadStream(): Promise<{");
-lines.push("  stream: WritableStream<any>;");
-lines.push("  writableId: number;");
-lines.push("}>;");
+// --- Process all modules ---
+
+const typesMap = {};     // routePath → type definition string
+const exportsMap = {};   // routePath → export names array
 
-const typeDefinitions = lines.join("\n");
+for (const mod of modules) {
+  const { types, exportNames } = extractFileTypes(mod.filePath);
+  typesMap[mod.routePath] = types;
+  exportsMap[mod.routePath] = exportNames;
+}
 
 // --- Minify core modules ---
 
@@ -226,42 +245,39 @@ 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);
-}
+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);
-}
+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
+// --- Write .export-types.js ---
+
 const outPath = path.join(cwd, ".export-types.js");
 fs.writeFileSync(outPath, [
-  `export default ${JSON.stringify(typeDefinitions)};`,
+  `export default ${JSON.stringify(typesMap)};`,
   `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);
-    }
-  }
-}
+// --- Write .export-module-map.js ---
+
+const moduleMapPath = path.join(cwd, ".export-module-map.js");
+const relSrcDir = path.relative(cwd, srcDir);
+const mapLines = [];
+modules.forEach((mod, i) => {
+  const relFile = "./" + path.relative(cwd, mod.filePath).replace(/\\/g, "/");
+  mapLines.push(`import * as _${i} from ${JSON.stringify(relFile)};`);
+});
+mapLines.push(`export default { ${modules.map((mod, i) => `${JSON.stringify(mod.routePath)}: _${i}`).join(", ")} };`);
+fs.writeFileSync(moduleMapPath, mapLines.join("\n") + "\n");
+
+// --- Write .export-shared.js ---
 
 const sharedModulePath = path.join(cwd, ".export-shared.js");
-const sharedModuleLines = [
+const sharedLines = [
   `import { env } from "cloudflare:workers";`,
   ``,
   `const getStub = (room = "default") =>`,
@@ -298,10 +314,20 @@ const sharedModuleLines = [
   `  });`,
   ``,
   `const _stub = getStub();`,
-  ...exportNames.map(n => `export const ${n} = createSharedProxy(_stub, [${JSON.stringify(n)}]);`),
-  `export { getStub };`,
 ];
-fs.writeFileSync(sharedModulePath, sharedModuleLines.join("\n") + "\n");
+// Generate proxies for all modules' exports, prefixed with route
+for (const mod of modules) {
+  const names = exportsMap[mod.routePath] || [];
+  for (const n of names) {
+    const proxyPath = mod.routePath ? `[${JSON.stringify(mod.routePath)}, ${JSON.stringify(n)}]` : `[${JSON.stringify("")}, ${JSON.stringify(n)}]`;
+    const exportAlias = mod.routePath ? `${mod.routePath.replace(/\//g, "_")}_${n}` : n;
+    sharedLines.push(`export const ${exportAlias} = createSharedProxy(_stub, ${proxyPath});`);
+  }
+}
+sharedLines.push(`export { getStub };`);
+fs.writeFileSync(sharedModulePath, sharedLines.join("\n") + "\n");
 
+console.log(`Discovered ${modules.length} module(s): ${modules.map(m => m.routePath || "/").join(", ")}`);
 console.log("Generated type definitions + minified core →", outPath);
+console.log("Generated module map →", moduleMapPath);
 console.log("Generated shared import module →", sharedModulePath);

package/client.js

@@ -135,14 +135,6 @@ 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);
   const resolver = pending.get(msg.id);
@@ -166,7 +158,6 @@ ws.onmessage = (event) => {
       },
       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 });
@@ -199,11 +190,6 @@ export const createProxy = (path = []) => new Proxy(function(){}, {
   async apply(_, __, args) { return sendRequest({ type: "call", path, args }); },
   construct(_, args) { return sendRequest({ type: "construct", path, args }); }
 });
-
-export const createUploadStream = async () => {
-  const { writableId } = await sendRequest({ type: "writable-create" });
-  return { stream: makeWritable(writableId), writableId };
-};
 `;
 
 export const CORE_CODE = CORE_TEMPLATE.replace("__WS_SUFFIX__", "./");

package/entry.js

@@ -1,6 +1,6 @@
-import * as userExports from "__USER_MODULE__";
+import moduleMap from "__USER_MODULE__";
 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, minifiedSharedCore);
+export default createHandler(moduleMap, generatedTypes, minifiedCore, coreId, minifiedSharedCore);

package/handler.js

@@ -13,28 +13,61 @@ const jsResponse = (body, extra = {}) =>
 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, minifiedSharedCore) => {
-  const exportKeys = Object.keys(exports);
+export const createHandler = (moduleMap, generatedTypes, minifiedCore, coreId, minifiedSharedCore) => {
+  // moduleMap: { routePath: moduleNamespace, ... }
+  const moduleRoutes = Object.keys(moduleMap); // e.g. ["", "greet", "utils/math"]
+  const moduleExportKeys = {};
+  for (const [route, mod] of Object.entries(moduleMap)) {
+    moduleExportKeys[route] = Object.keys(mod);
+  }
 
   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");
+  // Resolve a URL pathname to { route, exportName } or null
+  const resolveRoute = (pathname) => {
+    const p = pathname === "/" ? "" : pathname.slice(1);
 
-  const buildIndexModule = (cpath) =>
-    `import { createProxy, createUploadStream } from ".${cpath}";\n${namedExportsCode}\nexport { createUploadStream };`;
+    // Exact module match: /greet → route "greet", /utils/math → route "utils/math"
+    if (moduleRoutes.includes(p)) {
+      return { route: p, exportName: null };
+    }
 
-  const buildExportModule = (cpath, name) =>
-    `import { createProxy } from ".${cpath}";\nconst _export = createProxy([${JSON.stringify(name)}]);\nexport default _export;\nexport { _export as ${name} };`;
+    // Try parent as module, last segment as export: /greet/foo → route "greet", export "foo"
+    const lastSlash = p.lastIndexOf("/");
+    if (lastSlash > 0) {
+      const parentRoute = p.slice(0, lastSlash);
+      const name = p.slice(lastSlash + 1);
+      if (moduleRoutes.includes(parentRoute) && moduleExportKeys[parentRoute]?.includes(name)) {
+        return { route: parentRoute, exportName: name };
+      }
+    }
+
+    // Root module export: /greet → route "", export "greet" (only if no module named "greet")
+    if (moduleExportKeys[""]?.includes(p) && !p.includes("/")) {
+      return { route: "", exportName: p };
+    }
+
+    return null;
+  };
+
+  const buildIndexModule = (cpath, route) => {
+    const keys = moduleExportKeys[route] || [];
+    const namedExports = keys
+      .map((key) => `export const ${key} = createProxy([${JSON.stringify(route)}, ${JSON.stringify(key)}]);`)
+      .join("\n");
+    return `import { createProxy } from ".${cpath}";\n${namedExports}`;
+  };
+
+  const buildExportModule = (cpath, route, name) =>
+    `import { createProxy } from ".${cpath}";\n` +
+    `const _export = createProxy([${JSON.stringify(route)}, ${JSON.stringify(name)}]);\n` +
+    `export 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;
+    const { type, path = [], args = [], instanceId, iteratorId, streamId } = msg;
     switch (type) {
       case "ping": return { type: "pong" };
       case "call":
@@ -49,10 +82,6 @@ export const createHandler = (exports, generatedTypes, minifiedCore, coreId, min
       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);
     }
   };
 
@@ -87,7 +116,7 @@ export const createHandler = (exports, generatedTypes, minifiedCore, coreId, min
           const stub = env.SHARED_EXPORT.get(env.SHARED_EXPORT.idFromName(room));
           wireWebSocket(server, stub);
         } else {
-          const dispatcher = createRpcDispatcher(exports);
+          const dispatcher = createRpcDispatcher(moduleMap);
           wireWebSocket(server, dispatcher, () => dispatcher.clearAll());
         }
 
@@ -97,41 +126,52 @@ export const createHandler = (exports, generatedTypes, minifiedCore, coreId, min
       // --- HTTP routing ---
       const pathname = url.pathname;
 
-      // Core modules (cached immutably)
+      // Core modules
       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")) {
-        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);
+        const p = pathname === "/" ? "" : pathname.slice(1);
+        // Module types
+        if (generatedTypes?.[p] !== undefined) {
+          return tsResponse(generatedTypes[p]);
+        }
+        // Per-export re-export
+        const resolved = resolveRoute(pathname);
+        if (resolved?.exportName) {
+          const routeTypesPath = resolved.route ? `./${resolved.route}?types` : "./?types";
+          const code = `export { ${resolved.exportName} as default, ${resolved.exportName} } from "${routeTypesPath}";`;
+          return tsResponse(code);
+        }
+        return tsResponse("// Not found", 404);
+      }
+      if (pathname.endsWith(".d.ts")) {
+        return tsResponse(generatedTypes?.[""] || "");
       }
-      if (pathname.endsWith(".d.ts")) return tsResponse(generatedTypes || "");
 
       const baseUrl = `${url.protocol}//${url.host}`;
       const cpath = isShared ? sharedCorePath : corePath;
 
-      // Root module
-      if (pathname === "/") {
-        return jsResponse(buildIndexModule(cpath), {
-          "Cache-Control": "no-cache",
-          "X-TypeScript-Types": `${baseUrl}/?types`,
-        });
-      }
+      const resolved = resolveRoute(pathname);
+      if (!resolved) return new Response("Not found", { status: 404 });
+
+      const { route, exportName } = resolved;
 
-      // Per-export module
-      const exportName = pathname.slice(1);
-      if (exportKeys.includes(exportName)) {
-        return jsResponse(buildExportModule(cpath, exportName), {
+      if (exportName) {
+        // Per-export module
+        return jsResponse(buildExportModule(cpath, route, exportName), {
           "Cache-Control": "no-cache",
-          "X-TypeScript-Types": `${baseUrl}/${exportName}?types`,
+          "X-TypeScript-Types": `${baseUrl}${pathname}?types`,
         });
       }
 
-      return new Response("Not found", { status: 404 });
+      // Module index
+      const typesPath = route ? `${baseUrl}/${route}?types` : `${baseUrl}/?types`;
+      return jsResponse(buildIndexModule(cpath, route), {
+        "Cache-Control": "no-cache",
+        "X-TypeScript-Types": typesPath,
+      });
     },
   };
 };

package/package.json

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

package/rpc.js

@@ -19,14 +19,24 @@ export const isClass = (fn) =>
 export const RPC_METHODS = [
   "rpcCall", "rpcConstruct", "rpcInstanceCall", "rpcGet", "rpcSet", "rpcRelease",
   "rpcIterateNext", "rpcIterateReturn", "rpcStreamRead", "rpcStreamCancel",
-  "rpcWritableCreate", "rpcWritableWrite", "rpcWritableClose", "rpcWritableAbort",
 ];
 
-export function createRpcDispatcher(exports) {
+// moduleMap: { routePath: moduleNamespace, ... } or a single namespace (backward compat)
+export function createRpcDispatcher(moduleMap) {
+  // Normalize: if moduleMap has no "" key and looks like a namespace, wrap it
+  const isMap = typeof moduleMap === "object" && !moduleMap.__esModule && "" in moduleMap;
+  const resolveModule = (route) => {
+    if (isMap) {
+      const mod = moduleMap[route];
+      if (!mod) throw new Error(`Module not found: ${route}`);
+      return mod;
+    }
+    return moduleMap; // single namespace fallback
+  };
+
   const instances = new Map();
   const iterators = new Map();
   const streams = new Map();
-  const writables = new Map();
   let nextId = 1;
 
   const requireInstance = (id) => {
@@ -52,19 +62,29 @@ export function createRpcDispatcher(exports) {
     return { type: "result", value: result };
   };
 
-  const callTarget = async (obj, path, args) => {
+  // path = [route, ...exportPath] — route selects the module, exportPath walks its exports
+  const splitPath = (path) => {
+    const [route, ...rest] = path;
+    return { exports: resolveModule(route), exportPath: rest };
+  };
+
+  const callTarget = async (obj, path, args, isRoot = false) => {
     const target = getByPath(obj, path);
-    const thisArg = path.length > 1 ? getByPath(obj, path.slice(0, -1)) : (obj === exports ? undefined : obj);
+    const thisArg = path.length > 1 ? getByPath(obj, path.slice(0, -1)) : (isRoot ? 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),
+    rpcCall(path, args = []) {
+      const { exports, exportPath } = splitPath(path);
+      return callTarget(exports, exportPath, args, true);
+    },
 
     async rpcConstruct(path, args = []) {
-      const Ctor = getByPath(exports, path);
-      if (!isClass(Ctor)) throw new Error(`${path.join(".")} is not a class`);
+      const { exports, exportPath } = splitPath(path);
+      const Ctor = getByPath(exports, exportPath);
+      if (!isClass(Ctor)) throw new Error(`${exportPath.join(".")} is not a class`);
       const id = nextId++;
       instances.set(id, new Ctor(...args));
       return { type: "result", instanceId: id, valueType: "instance" };
@@ -126,36 +146,10 @@ export function createRpcDispatcher(exports) {
       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

@@ -1,12 +1,12 @@
 import { DurableObject } from "cloudflare:workers";
-import * as userExports from "__USER_MODULE__";
+import moduleMap from "__USER_MODULE__";
 import { createRpcDispatcher } from "./rpc.js";
 
 export class SharedExportDO extends DurableObject {
   #d;
   constructor(ctx, env) {
     super(ctx, env);
-    this.#d = createRpcDispatcher(userExports);
+    this.#d = createRpcDispatcher(moduleMap);
   }
   rpcCall(p, a) { return this.#d.rpcCall(p, a); }
   rpcConstruct(p, a) { return this.#d.rpcConstruct(p, a); }
@@ -18,8 +18,4 @@ export class SharedExportDO extends DurableObject {
   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); }
 }