export-runtime 0.0.4 → 0.0.6

package/bin/generate-types.mjs

@@ -0,0 +1,244 @@
+#!/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();
+
+// Read wrangler.toml to find user module path
+const wranglerPath = path.join(cwd, "wrangler.toml");
+if (!fs.existsSync(wranglerPath)) {
+  console.error("wrangler.toml not found in", cwd);
+  process.exit(1);
+}
+const wranglerContent = fs.readFileSync(wranglerPath, "utf8");
+const aliasMatch = wranglerContent.match(/"__USER_MODULE__"\s*=\s*"([^"]+)"/);
+if (!aliasMatch) {
+  console.error('Could not find __USER_MODULE__ alias in wrangler.toml');
+  process.exit(1);
+}
+
+const userModulePath = path.resolve(cwd, aliasMatch[1]);
+if (!fs.existsSync(userModulePath)) {
+  console.error("User module not found:", userModulePath);
+  process.exit(1);
+}
+
+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;
+
+// --- Type extraction helpers ---
+
+function extractType(node) {
+  if (!node) return "any";
+  const ta = node.type === "TSTypeAnnotation" ? node.typeAnnotation : node;
+  switch (ta.type) {
+    case "TSStringKeyword": return "string";
+    case "TSNumberKeyword": return "number";
+    case "TSBooleanKeyword": return "boolean";
+    case "TSVoidKeyword": return "void";
+    case "TSAnyKeyword": return "any";
+    case "TSNullKeyword": return "null";
+    case "TSUndefinedKeyword": return "undefined";
+    case "TSNeverKeyword": return "never";
+    case "TSUnknownKeyword": return "unknown";
+    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 "TSLiteralType": {
+      const lit = ta.literal;
+      if (lit.type === "StringLiteral") return JSON.stringify(lit.value);
+      if (lit.type === "NumericLiteral") return String(lit.value);
+      if (lit.type === "BooleanLiteral") return String(lit.value);
+      if (lit.type === "UnaryExpression") return `-${lit.argument.value}`;
+      return "any";
+    }
+    case "TSTypeReference": {
+      const name = ta.typeName?.name || ta.typeName?.right?.name || "any";
+      const typeArgs = ta.typeArguments || ta.typeParameters;
+      if (typeArgs?.params?.length) {
+        const args = typeArgs.params.map(p => extractType(p)).join(", ");
+        return `${name}<${args}>`;
+      }
+      return name;
+    }
+    case "TSFunctionType": {
+      const params = extractParams(ta.params);
+      const ret = ta.returnType ? extractType(ta.returnType) : "any";
+      return `(${params.join(", ")}) => ${ret}`;
+    }
+    case "TSTypeLiteral": {
+      const members = (ta.members || []).map(m => {
+        if (m.type === "TSPropertySignature") {
+          const key = m.key?.name || m.key?.value;
+          const type = m.typeAnnotation ? extractType(m.typeAnnotation) : "any";
+          const opt = m.optional ? "?" : "";
+          return `${key}${opt}: ${type}`;
+        }
+        return "";
+      }).filter(Boolean);
+      return `{ ${members.join("; ")} }`;
+    }
+    case "TSTypeAnnotation":
+      return extractType(ta.typeAnnotation);
+    default:
+      return "any";
+  }
+}
+
+function extractParams(params) {
+  return params.map(p => {
+    if (p.type === "AssignmentPattern") {
+      const name = p.left?.name || "arg";
+      const type = p.left?.typeAnnotation ? extractType(p.left.typeAnnotation) : "any";
+      return `${name}?: ${type}`;
+    }
+    const name = p.name || p.argument?.name || "arg";
+    const type = p.typeAnnotation ? extractType(p.typeAnnotation) : "any";
+    const opt = p.optional ? "?" : "";
+    const rest = p.type === "RestElement" ? "..." : "";
+    return `${rest}${name}${opt}: ${type}`;
+  });
+}
+
+// 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 ---
+
+const lines = [
+  "// Auto-generated type definitions (oxc-parser)",
+  "// All functions are async over the network",
+  "",
+];
+
+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};`);
+        }
+      } 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(`};`);
+        lines.push("");
+      } else {
+        const type = d.id.typeAnnotation ? extractType(d.id.typeAnnotation) : "any";
+        lines.push(`export declare const ${name}: ${type};`);
+        lines.push("");
+      }
+    }
+  }
+}
+
+// Add createUploadStream helper type
+lines.push("export declare function createUploadStream(): Promise<{");
+lines.push("  stream: WritableStream<any>;");
+lines.push("  writableId: number;");
+lines.push("}>;");
+
+const typeDefinitions = lines.join("\n");
+
+// --- Minify core module ---
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const { 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);
+}
+
+// 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
+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 coreId = ${JSON.stringify(coreId)};`,
+].join("\n") + "\n");
+console.log("Generated type definitions + minified core →", outPath);

package/client.js

@@ -1,5 +1,6 @@
-// Minimal devalue stringify implementation (compatible with sveltejs/devalue)
-export const DEVALUE_STRINGIFY = `
+// 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 = `
 const stringify = (value) => {
   const stringified = [];
   const indexes = new Map();
@@ -79,10 +80,7 @@ const stringify = (value) => {
   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;
@@ -153,20 +151,16 @@ const parse = (serialized) => {
 
   return hydrate(0);
 };
-`;
 
-export const CLIENT_CODE = `
-__DEVALUE_STRINGIFY__
-__DEVALUE_PARSE__
-
-const ws = new WebSocket(__WS_URL__);
+const _u = new URL("./", 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;
 
 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 }));
@@ -196,7 +190,6 @@ const sendRequest = async (msg) => {
 ws.onmessage = (event) => {
   const msg = parse(event.data);
 
-  // Ignore pong responses (keepalive)
   if (msg.type === "pong") return;
 
   const resolver = pending.get(msg.id);
@@ -222,7 +215,6 @@ ws.onmessage = (event) => {
       };
       resolver.resolve(iteratorProxy);
     } else if (msg.valueType === "readablestream") {
-      // Create a ReadableStream proxy that pulls from server
       const streamId = msg.streamId;
       const stream = new ReadableStream({
         async pull(controller) {
@@ -243,7 +235,6 @@ ws.onmessage = (event) => {
       });
       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) {
@@ -266,14 +257,12 @@ ws.onmessage = (event) => {
     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);
   }
 };
 
-// Proxy for remote class instances
 const createInstanceProxy = (instanceId, path = []) => {
   const proxy = new Proxy(function(){}, {
     get(_, prop) {
@@ -297,8 +286,7 @@ const createInstanceProxy = (instanceId, path = []) => {
   return proxy;
 };
 
-// Proxy for exports (functions, classes, objects)
-const createProxy = (path = []) => new Proxy(function(){}, {
+export const createProxy = (path = []) => new Proxy(function(){}, {
   get(_, prop) {
     if (prop === "then" || prop === Symbol.toStringTag) return undefined;
     return createProxy([...path, prop]);
@@ -311,7 +299,6 @@ const createProxy = (path = []) => new Proxy(function(){}, {
   }
 });
 
-// Helper to create a client-side WritableStream that can be passed to server functions
 export const createUploadStream = async () => {
   const result = await sendRequest({ type: "writable-create" });
   const writableId = result.writableId;
@@ -331,6 +318,4 @@ export const createUploadStream = async () => {
 
   return { stream, writableId };
 };
-
-__NAMED_EXPORTS__
 `;

package/entry.js

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

package/handler.js

@@ -1,5 +1,5 @@
 import { stringify, parse } from "devalue";
-import { CLIENT_CODE, DEVALUE_PARSE, DEVALUE_STRINGIFY } from "./client.js";
+import { CORE_CODE } from "./client.js";
 
 const getByPath = (obj, path) => {
   let current = obj;
@@ -19,70 +19,56 @@ const isReadableStream = (value) =>
 const isClass = (fn) =>
   typeof fn === "function" && /^class\s/.test(Function.prototype.toString.call(fn));
 
-// Generate TypeScript type definitions from exports
-const generateTypeDefinitions = (exports, exportKeys) => {
+// 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",
     "",
   ];
 
-  const generateType = (value, name, indent = "") => {
+  for (const name of keys) {
+    const value = exports[name];
     if (isClass(value)) {
-      // Extract class method names
       const proto = value.prototype;
       const methodNames = Object.getOwnPropertyNames(proto).filter(
         (n) => n !== "constructor" && typeof proto[n] === "function"
       );
-
-      lines.push(`${indent}export declare class ${name} {`);
-      lines.push(`${indent}  constructor(...args: any[]);`);
+      lines.push(`export declare class ${name} {`);
+      lines.push(`  constructor(...args: any[]);`);
       for (const method of methodNames) {
-        lines.push(`${indent}  ${method}(...args: any[]): Promise<any>;`);
+        lines.push(`  ${method}(...args: any[]): Promise<any>;`);
       }
-      lines.push(`${indent}  [Symbol.dispose](): Promise<void>;`);
-      lines.push(`${indent}  "[release]"(): Promise<void>;`);
-      lines.push(`${indent}}`);
+      lines.push(`  [Symbol.dispose](): Promise<void>;`);
+      lines.push(`  "[release]"(): Promise<void>;`);
+      lines.push(`}`);
     } 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>>;`
-        );
+        lines.push(`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>>;`
-        );
+        lines.push(`export declare function ${name}(...args: any[]): Promise<ReadableStream<any>>;`);
       } else {
-        lines.push(
-          `${indent}export declare function ${name}(...args: any[]): Promise<any>;`
-        );
+        lines.push(`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}: {`);
+      lines.push(`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>;`);
+          lines.push(`  ${key}(...args: any[]): Promise<any>;`);
         } else {
-          lines.push(`${indent}  ${key}: any;`);
+          lines.push(`  ${key}: any;`);
         }
       }
-      lines.push(`${indent}};`);
+      lines.push(`};`);
     } else {
-      lines.push(`${indent}export declare const ${name}: any;`);
+      lines.push(`export declare const ${name}: any;`);
     }
-  };
-
-  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;");
@@ -91,7 +77,20 @@ const generateTypeDefinitions = (exports, exportKeys) => {
   return lines.join("\n");
 };
 
-export const createHandler = (exports) => {
+
+const jsHeaders = (extra = {}) => ({
+  "Content-Type": "application/javascript; charset=utf-8",
+  "Access-Control-Allow-Origin": "*",
+  ...extra,
+});
+
+const tsHeaders = () => ({
+  "Content-Type": "application/typescript; charset=utf-8",
+  "Access-Control-Allow-Origin": "*",
+  "Cache-Control": "no-cache",
+});
+
+export const createHandler = (exports, generatedTypes, minifiedCore, coreId) => {
   const exportKeys = Object.keys(exports);
   const iteratorStore = new Map();
   const instanceStore = new Map();
@@ -105,11 +104,15 @@ export const createHandler = (exports) => {
     ws.send(stringify(data));
   };
 
+  const coreModuleCode = minifiedCore || CORE_CODE;
+  const corePath = `/${coreId || crypto.randomUUID()}.js`;
+
   return {
     async fetch(request) {
       const url = new URL(request.url);
       const upgradeHeader = request.headers.get("Upgrade");
 
+      // --- WebSocket upgrade (path-agnostic) ---
       if (upgradeHeader === "websocket") {
         const pair = new WebSocketPair();
         const [client, server] = Object.values(pair);
@@ -121,14 +124,12 @@ export const createHandler = (exports) => {
             const msg = parse(event.data);
             const { type, id, path = [], args = [], iteratorId, instanceId } = msg;
 
-            // Keepalive ping/pong
             if (type === "ping") {
               send(server, { type: "pong", id });
               return;
             }
 
             if (type === "construct") {
-              // Class instantiation
               try {
                 const Ctor = getByPath(exports, path);
                 if (!isClass(Ctor)) {
@@ -148,7 +149,6 @@ export const createHandler = (exports) => {
                 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" });
@@ -157,7 +157,6 @@ export const createHandler = (exports) => {
                   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;
                 }
@@ -167,7 +166,6 @@ export const createHandler = (exports) => {
                   return;
                 }
 
-                // Await result to support both sync and async functions
                 const result = await target.apply(thisArg, args);
 
                 if (isReadableStream(result)) {
@@ -187,7 +185,6 @@ export const createHandler = (exports) => {
                 send(server, { type: "error", id, error: String(err) });
               }
             } else if (type === "get") {
-              // Property access on instance
               try {
                 const instance = instanceStore.get(instanceId);
                 if (!instance) {
@@ -204,7 +201,6 @@ export const createHandler = (exports) => {
                 send(server, { type: "error", id, error: String(err) });
               }
             } else if (type === "set") {
-              // Property assignment on instance
               try {
                 const instance = instanceStore.get(instanceId);
                 if (!instance) {
@@ -219,7 +215,6 @@ export const createHandler = (exports) => {
                 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") {
@@ -241,7 +236,6 @@ export const createHandler = (exports) => {
               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) {
@@ -249,7 +243,6 @@ export const createHandler = (exports) => {
                 return;
               }
               try {
-                // Get or create reader for this stream
                 let reader = entry.reader;
                 if (!reader) {
                   reader = entry.stream.getReader();
@@ -259,7 +252,6 @@ export const createHandler = (exports) => {
                 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) {
@@ -267,7 +259,6 @@ export const createHandler = (exports) => {
                 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) {
@@ -282,27 +273,19 @@ export const createHandler = (exports) => {
               }
               send(server, { type: "result", id, value: true });
             } else if (type === "writable-create") {
-              // Create a WritableStream on server side
               const { targetPath, targetInstanceId } = msg;
               let chunks = [];
               const writableId = nextStreamId++;
 
               const writable = new WritableStream({
-                write(chunk) {
-                  chunks.push(chunk);
-                },
-                close() {
-                  // Resolve with all chunks when stream closes
-                },
-                abort(reason) {
-                  chunks = [];
-                }
+                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") {
-              // Write chunk to WritableStream
               const { writableId, chunk } = msg;
               const entry = writableStreamStore.get(writableId);
               if (!entry) {
@@ -310,7 +293,6 @@ export const createHandler = (exports) => {
                 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 });
@@ -318,7 +300,6 @@ export const createHandler = (exports) => {
                 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) {
@@ -326,10 +307,8 @@ export const createHandler = (exports) => {
                 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 });
@@ -349,43 +328,72 @@ export const createHandler = (exports) => {
         return new Response(null, { status: 101, webSocket: client });
       }
 
-      const wsProtocol = url.protocol === "https:" ? "wss:" : "ws:";
-      const wsUrl = `${wsProtocol}//${url.host}${url.pathname}`;
+      // --- 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" }),
+        });
+      }
+
+      // 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
+        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() });
+      }
+
+      const baseUrl = `${url.protocol}//${url.host}`;
+
+      // Root — re-exports all from ${corePath}
+      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`,
+          }),
+        });
+      }
 
-      // Serve TypeScript type definitions
-      if (url.searchParams.has("types") || url.pathname.endsWith(".d.ts")) {
-        const typeDefinitions = generateTypeDefinitions(exports, exportKeys);
-        return new Response(typeDefinitions, {
-          headers: {
-            "Content-Type": "application/typescript; charset=utf-8",
-            "Access-Control-Allow-Origin": "*",
+      // Per-export path — e.g. /greet, /Counter
+      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`,
+          }),
         });
       }
 
-      // 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.4",
+  "version": "0.0.6",
   "description": "Cloudflare Workers ESM Export Framework Runtime",
   "keywords": [
     "cloudflare",
@@ -22,12 +22,18 @@
   "exports": {
     ".": "./entry.js"
   },
+  "bin": {
+    "generate-export-types": "./bin/generate-types.mjs"
+  },
   "files": [
     "entry.js",
     "handler.js",
-    "client.js"
+    "client.js",
+    "bin/generate-types.mjs"
   ],
   "dependencies": {
-    "devalue": "^5.1.1"
+    "devalue": "^5.1.1",
+    "oxc-minify": "^0.121.0",
+    "oxc-parser": "^0.121.0"
   }
 }