ziex 0.1.0-dev.787 → 0.1.0-dev.804

package/cloudflare/index.js

@@ -178,7 +178,7 @@ class ZigJS {
     return decoder.decode(data);
   }
 }
-// src/wasm/index.ts
+// src/wasm/core.ts
 var CallbackType = {
   Event: 0,
   FetchSuccess: 1,
@@ -229,25 +229,17 @@ function writeBytes(ptr, data) {
   getMemoryView().set(data, ptr);
 }
 
-class ZxBridge {
+class ZxBridgeCore {
   #intervals = new Map;
-  #websockets = new Map;
-  #alloc;
+  _alloc;
   #handler;
   #fetchCompleteHandler;
-  #wsOnOpenHandler;
-  #wsOnMessageHandler;
-  #wsOnErrorHandler;
-  #wsOnCloseHandler;
   constructor(exports) {
-    this.#alloc = exports.__zx_alloc;
+    this._alloc = exports.__zx_alloc;
     this.#handler = exports.__zx_cb;
     this.#fetchCompleteHandler = exports.__zx_fetch_complete;
-    this.#wsOnOpenHandler = exports.__zx_ws_onopen;
-    this.#wsOnMessageHandler = exports.__zx_ws_onmessage;
-    this.#wsOnErrorHandler = exports.__zx_ws_onerror;
-    this.#wsOnCloseHandler = exports.__zx_ws_onclose;
-    this.#eventbridge = exports.__zx_eventbridge;
+    if (exports.memory)
+      jsz.memory = exports.memory;
   }
   #invoke(type, id, data) {
     const handler = this.#handler;
@@ -287,37 +279,22 @@ class ZxBridge {
       if (timeout)
         clearTimeout(timeout);
       const text = await response.text();
-      this.#notifyFetchComplete(fetchId, response.status, text, false);
+      this._notifyFetchComplete(fetchId, response.status, text, false);
     }).catch((error) => {
       if (timeout)
         clearTimeout(timeout);
       const isAbort = error.name === "AbortError";
       const errorMsg = isAbort ? "Request timeout" : error.message ?? "Fetch failed";
-      this.#notifyFetchComplete(fetchId, 0, errorMsg, true);
+      this._notifyFetchComplete(fetchId, 0, errorMsg, true);
     });
   }
-  #notifyFetchComplete(fetchId, statusCode, body, isError) {
+  _notifyFetchComplete(fetchId, statusCode, body, isError) {
     const handler = this.#fetchCompleteHandler;
     const encoded = textEncoder.encode(body);
-    const ptr = this.#alloc(encoded.length);
+    const ptr = this._alloc(encoded.length);
     writeBytes(ptr, encoded);
     handler(fetchId, statusCode, ptr, encoded.length, isError ? 1 : 0);
   }
-  submitFormActionAsync(form, statesJson, fetchId) {
-    const formData = new FormData(form);
-    formData.append("__zx_states", statesJson);
-    fetch(window.location.href, {
-      method: "POST",
-      headers: { "X-ZX-Action": "1" },
-      body: formData
-    }).then(async (response) => {
-      const text = await response.text();
-      this.#notifyFetchComplete(fetchId, response.status, text, false);
-    }).catch((error) => {
-      const msg = error instanceof Error ? error.message : "Fetch failed";
-      this.#notifyFetchComplete(fetchId, 0, msg, true);
-    });
-  }
   setTimeout(callbackId, delayMs) {
     setTimeout(() => {
       this.#invoke(CallbackType.Timeout, callbackId, null);
@@ -336,6 +313,83 @@ class ZxBridge {
       this.#intervals.delete(callbackId);
     }
   }
+  _writeStringToWasm(str) {
+    return this._writeBytesToWasm(textEncoder.encode(str));
+  }
+  _writeBytesToWasm(data) {
+    const ptr = this._alloc(data.length);
+    writeBytes(ptr, data);
+    return { ptr, len: data.length };
+  }
+  static log(level, ptr, len) {
+    const msg = textDecoder.decode(getMemoryView().subarray(ptr, ptr + len));
+    switch (level) {
+      case 0:
+        console.error(msg);
+        break;
+      case 1:
+        console.warn(msg);
+        break;
+      case 3:
+        console.debug(msg);
+        break;
+      default:
+        console.log(msg);
+        break;
+    }
+  }
+  static createImportObject(bridgeRef) {
+    return {
+      ...jsz.importObject(),
+      __zx: {
+        _log: (level, ptr, len) => ZxBridgeCore.log(level, ptr, len),
+        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
+          bridgeRef.current?.fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId);
+        },
+        _setTimeout: (callbackId, delayMs) => {
+          bridgeRef.current?.setTimeout(callbackId, delayMs);
+        },
+        _setInterval: (callbackId, intervalMs) => {
+          bridgeRef.current?.setInterval(callbackId, intervalMs);
+        },
+        _clearInterval: (callbackId) => {
+          bridgeRef.current?.clearInterval(callbackId);
+        }
+      }
+    };
+  }
+}
+// src/wasm/index.ts
+class ZxBridge extends ZxBridgeCore {
+  #websockets = new Map;
+  #wsOnOpenHandler;
+  #wsOnMessageHandler;
+  #wsOnErrorHandler;
+  #wsOnCloseHandler;
+  #eventbridge;
+  constructor(exports) {
+    super(exports);
+    this.#wsOnOpenHandler = exports.__zx_ws_onopen;
+    this.#wsOnMessageHandler = exports.__zx_ws_onmessage;
+    this.#wsOnErrorHandler = exports.__zx_ws_onerror;
+    this.#wsOnCloseHandler = exports.__zx_ws_onclose;
+    this.#eventbridge = exports.__zx_eventbridge;
+  }
+  submitFormActionAsync(form, statesJson, fetchId) {
+    const formData = new FormData(form);
+    formData.append("__zx_states", statesJson);
+    fetch(window.location.href, {
+      method: "POST",
+      headers: { "X-ZX-Action": "1" },
+      body: formData
+    }).then(async (response) => {
+      const text = await response.text();
+      this._notifyFetchComplete(fetchId, response.status, text, false);
+    }).catch((error) => {
+      const msg = error instanceof Error ? error.message : "Fetch failed";
+      this._notifyFetchComplete(fetchId, 0, msg, true);
+    });
+  }
   wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) {
     const url = readString(urlPtr, urlLen);
     const protocolsStr = protocolsLen > 0 ? readString(protocolsPtr, protocolsLen) : "";
@@ -348,7 +402,7 @@ class ZxBridge {
         if (!handler)
           return;
         const protocol = ws.protocol || "";
-        const { ptr, len } = this.#writeStringToWasm(protocol);
+        const { ptr, len } = this._writeStringToWasm(protocol);
         handler(wsId, ptr, len);
       };
       ws.onmessage = (event) => {
@@ -356,21 +410,15 @@ class ZxBridge {
         if (!handler)
           return;
         const isBinary = event.data instanceof ArrayBuffer;
-        let data;
-        if (isBinary) {
-          data = new Uint8Array(event.data);
-        } else {
-          data = textEncoder.encode(event.data);
-        }
-        const { ptr, len } = this.#writeBytesToWasm(data);
+        const data = isBinary ? new Uint8Array(event.data) : textEncoder.encode(event.data);
+        const { ptr, len } = this._writeBytesToWasm(data);
         handler(wsId, ptr, len, isBinary ? 1 : 0);
       };
-      ws.onerror = (event) => {
+      ws.onerror = (_event) => {
         const handler = this.#wsOnErrorHandler;
         if (!handler)
           return;
-        const msg = "WebSocket error";
-        const { ptr, len } = this.#writeStringToWasm(msg);
+        const { ptr, len } = this._writeStringToWasm("WebSocket error");
         handler(wsId, ptr, len);
       };
       ws.onclose = (event) => {
@@ -378,7 +426,7 @@ class ZxBridge {
         if (!handler)
           return;
         const reason = event.reason || "";
-        const { ptr, len } = this.#writeStringToWasm(reason);
+        const { ptr, len } = this._writeStringToWasm(reason);
         handler(wsId, event.code, ptr, len, event.wasClean ? 1 : 0);
         this.#websockets.delete(wsId);
       };
@@ -387,7 +435,7 @@ class ZxBridge {
       const handler = this.#wsOnErrorHandler;
       if (handler) {
         const msg = error instanceof Error ? error.message : "WebSocket connection failed";
-        const { ptr, len } = this.#writeStringToWasm(msg);
+        const { ptr, len } = this._writeStringToWasm(msg);
         handler(wsId, ptr, len);
       }
     }
@@ -409,25 +457,14 @@ class ZxBridge {
       return;
     const reason = reasonLen > 0 ? readString(reasonPtr, reasonLen) : undefined;
     try {
-      if (reason) {
+      if (reason)
         ws.close(code, reason);
-      } else {
+      else
         ws.close(code);
-      }
     } catch {
       ws.close();
     }
   }
-  #writeStringToWasm(str) {
-    const encoded = textEncoder.encode(str);
-    return this.#writeBytesToWasm(encoded);
-  }
-  #writeBytesToWasm(data) {
-    const ptr = this.#alloc(data.length);
-    writeBytes(ptr, data);
-    return { ptr, len: data.length };
-  }
-  #eventbridge;
   eventbridge(velementId, eventTypeId, event) {
     if (!this.#eventbridge)
       return;
@@ -438,6 +475,7 @@ class ZxBridge {
     return {
       ...jsz.importObject(),
       __zx: {
+        _log: (level, ptr, len) => ZxBridgeCore.log(level, ptr, len),
         _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
           bridgeRef.current?.fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId);
         },
@@ -842,16 +880,141 @@ async function init(options = {}) {
   return { source, bridge };
 }
 
-// src/cloudflare/worker.ts
-var exports_worker = {};
-__export(exports_worker, {
+// src/runtime.ts
+var exports_runtime = {};
+__export(exports_runtime, {
   run: () => run,
-  respond: () => respond,
-  prepare: () => prepare,
-  createWebSocketDO: () => createWebSocketDO
+  buildWsImports: () => buildWsImports,
+  attachWebSocket: () => attachWebSocket
 });
 
-// src/cloudflare/kv.ts
+// src/wasm/wasi.ts
+var decoder2 = new TextDecoder;
+var encoder2 = new TextEncoder;
+
+class ZxWasiBridge {
+  #alloc;
+  #fetchCompleteHandler;
+  #memory;
+  #cb;
+  #intervals = new Map;
+  #memView = null;
+  #memBuf = null;
+  constructor(exports) {
+    this.#memory = exports.memory;
+    this.#alloc = exports.__zx_alloc;
+    this.#fetchCompleteHandler = exports.__zx_fetch_complete;
+    this.#cb = exports.__zx_cb;
+  }
+  #view() {
+    const buf = this.#memory.buffer;
+    if (buf !== this.#memBuf) {
+      this.#memBuf = buf;
+      this.#memView = new Uint8Array(buf);
+    }
+    return this.#memView;
+  }
+  #readString(ptr, len) {
+    return decoder2.decode(this.#view().subarray(ptr, ptr + len));
+  }
+  #writeBytes(ptr, data) {
+    this.#view().set(data, ptr);
+  }
+  log(level, ptr, len) {
+    const msg = decoder2.decode(this.#view().subarray(ptr, ptr + len));
+    switch (level) {
+      case 0:
+        console.error(msg);
+        break;
+      case 1:
+        console.warn(msg);
+        break;
+      case 3:
+        console.debug(msg);
+        break;
+      default:
+        console.log(msg);
+        break;
+    }
+  }
+  fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) {
+    const url = this.#readString(urlPtr, urlLen);
+    const method = methodLen > 0 ? this.#readString(methodPtr, methodLen) : "GET";
+    const headersJson = headersLen > 0 ? this.#readString(headersPtr, headersLen) : "{}";
+    const body = bodyLen > 0 ? this.#readString(bodyPtr, bodyLen) : undefined;
+    let headers = {};
+    try {
+      headers = JSON.parse(headersJson);
+    } catch {
+      for (const line of headersJson.split(`
+`)) {
+        const i = line.indexOf(":");
+        if (i > 0)
+          headers[line.slice(0, i)] = line.slice(i + 1);
+      }
+    }
+    const controller = new AbortController;
+    const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
+    fetch(url, {
+      method,
+      headers: Object.keys(headers).length > 0 ? headers : undefined,
+      body: method !== "GET" && method !== "HEAD" ? body : undefined,
+      signal: controller.signal
+    }).then(async (res) => {
+      if (timeout)
+        clearTimeout(timeout);
+      this.#notifyFetchComplete(fetchId, res.status, await res.text(), false);
+    }).catch((err) => {
+      if (timeout)
+        clearTimeout(timeout);
+      const msg = err.name === "AbortError" ? "Request timeout" : err.message ?? "Fetch failed";
+      this.#notifyFetchComplete(fetchId, 0, msg, true);
+    });
+  }
+  #notifyFetchComplete(fetchId, status, body, isError) {
+    const encoded = encoder2.encode(body);
+    const ptr = this.#alloc(encoded.length);
+    this.#writeBytes(ptr, encoded);
+    this.#fetchCompleteHandler(fetchId, status, ptr, encoded.length, isError ? 1 : 0);
+  }
+  setTimeout(callbackId, delayMs) {
+    setTimeout(() => this.#cb?.(3, callbackId, 0n), delayMs);
+  }
+  setInterval(callbackId, intervalMs) {
+    const handle = setInterval(() => this.#cb?.(4, callbackId, 0n), intervalMs);
+    this.#intervals.set(callbackId, handle);
+  }
+  clearInterval(callbackId) {
+    const handle = this.#intervals.get(callbackId);
+    if (handle !== undefined) {
+      clearInterval(handle);
+      this.#intervals.delete(callbackId);
+    }
+  }
+  static createImportObject(bridgeRef) {
+    return {
+      __zx: {
+        _log: (level, ptr, len) => {
+          bridgeRef.current?.log(level, ptr, len);
+        },
+        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
+          bridgeRef.current?.fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId);
+        },
+        _setTimeout: (callbackId, delayMs) => {
+          bridgeRef.current?.setTimeout(callbackId, delayMs);
+        },
+        _setInterval: (callbackId, intervalMs) => {
+          bridgeRef.current?.setInterval(callbackId, intervalMs);
+        },
+        _clearInterval: (callbackId) => {
+          bridgeRef.current?.clearInterval(callbackId);
+        }
+      }
+    };
+  }
+}
+
+// src/kv.ts
 var exports_kv = {};
 __export(exports_kv, {
   createMemoryKV: () => createMemoryKV,
@@ -876,10 +1039,10 @@ function createMemoryKV() {
   };
 }
 function createKVImports(bindings, getMemory) {
-  const encoder2 = new TextEncoder;
-  const decoder2 = new TextDecoder;
+  const encoder3 = new TextEncoder;
+  const decoder3 = new TextDecoder;
   function readStr(ptr, len) {
-    return decoder2.decode(new Uint8Array(getMemory().buffer, ptr, len));
+    return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
   }
   function writeBytes2(buf_ptr, buf_max, data) {
     if (data.length > buf_max)
@@ -896,7 +1059,7 @@ function createKVImports(bindings, getMemory) {
       kv_get: (_ns, _nsLen, _key, _keyLen, _buf, _max) => -1,
       kv_put: (_ns, _nsLen, _key, _keyLen, _val, _valLen) => 0,
       kv_delete: (_ns, _nsLen, _key, _keyLen) => 0,
-      kv_list: (_ns, _nsLen, _pfx, _pfxLen, buf_ptr, buf_max) => writeBytes2(buf_ptr, buf_max, encoder2.encode("[]"))
+      kv_list: (_ns, _nsLen, _pfx, _pfxLen, buf_ptr, buf_max) => writeBytes2(buf_ptr, buf_max, encoder3.encode("[]"))
     };
   }
   return {
@@ -907,7 +1070,7 @@ function createKVImports(bindings, getMemory) {
       const value = await b.get(readStr(key_ptr, key_len));
       if (value === null)
         return -1;
-      return writeBytes2(buf_ptr, buf_max, encoder2.encode(value));
+      return writeBytes2(buf_ptr, buf_max, encoder3.encode(value));
     }),
     kv_put: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len) => {
       const b = binding(readStr(ns_ptr, ns_len));
@@ -926,15 +1089,15 @@ function createKVImports(bindings, getMemory) {
     kv_list: new Suspending(async (ns_ptr, ns_len, prefix_ptr, prefix_len, buf_ptr, buf_max) => {
       const b = binding(readStr(ns_ptr, ns_len));
       if (!b)
-        return writeBytes2(buf_ptr, buf_max, encoder2.encode("[]"));
+        return writeBytes2(buf_ptr, buf_max, encoder3.encode("[]"));
       const prefix = readStr(prefix_ptr, prefix_len);
       const result = await b.list(prefix.length > 0 ? { prefix } : undefined);
-      return writeBytes2(buf_ptr, buf_max, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
+      return writeBytes2(buf_ptr, buf_max, encoder3.encode(JSON.stringify(result.keys.map((k) => k.name))));
     })
   };
 }
 
-// src/cloudflare/worker.ts
+// src/wasi.ts
 class ProcExit extends Error {
   code;
   constructor(code) {
@@ -947,8 +1110,7 @@ function createWasiImports({
   stdinData,
   onStdout
 }) {
-  const encoder2 = new TextEncoder;
-  const decoder2 = new TextDecoder;
+  const encoder3 = new TextEncoder;
   const url = new URL(request.url);
   const argStrings = [
     "wasm",
@@ -963,14 +1125,30 @@ function createWasiImports({
     if (value)
       argStrings.push("--header", `${name}:${value}`);
   });
-  const encodedArgs = argStrings.map((a) => encoder2.encode(a + "\x00"));
+  const encodedArgs = argStrings.map((a) => encoder3.encode(a + "\x00"));
   const argBufSize = encodedArgs.reduce((s, a) => s + a.length, 0);
   let wasmMemory = null;
   const setMemory = (m2) => {
     wasmMemory = m2;
   };
   const stdoutChunks = [];
-  const stderrChunks = [];
+  let stderrMeta = "";
+  let stderrPartial = "";
+  const stderrDecoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
+  function processStderrChunk(chunk) {
+    const text = stderrDecoder.decode(chunk, { stream: true });
+    const lines = (stderrPartial + text).split(`
+`);
+    stderrPartial = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.startsWith("__EDGE_META__:")) {
+        stderrMeta += line + `
+`;
+      } else if (line.length > 0) {
+        console.error("[ziex]", line);
+      }
+    }
+  }
   let stdinOffset = 0;
   function v() {
     return new DataView(wasmMemory.buffer);
@@ -1018,7 +1196,7 @@ function createWasiImports({
           else
             stdoutChunks.push(chunk);
         } else if (fd === 2)
-          stderrChunks.push(chunk);
+          processStderrChunk(chunk);
         written += buf_len;
       }
       dv.setUint32(nwritten_ptr, written, true);
@@ -1133,106 +1311,36 @@ function createWasiImports({
     }
   };
   function collectOutput() {
+    const remaining = stderrDecoder.decode(undefined, { stream: false });
+    const tail = stderrPartial + remaining;
+    if (tail.length > 0) {
+      if (tail.startsWith("__EDGE_META__:"))
+        stderrMeta += tail;
+      else
+        console.error("[ziex]", tail);
+      stderrPartial = "";
+    }
     return {
       stdout: mergeUint8Arrays(stdoutChunks),
-      stderrText: decoder2.decode(mergeUint8Arrays(stderrChunks))
+      stderrText: stderrMeta
     };
   }
   return { wasiImport, setMemory, collectOutput };
 }
-async function run({
-  request,
-  env,
-  ctx,
-  module,
-  kv: kvBindings,
-  imports,
-  wasi,
-  websocket: doNamespace
-}) {
-  if (doNamespace && request.headers.get("upgrade")?.toLowerCase() === "websocket") {
-    const id = doNamespace.idFromName(new URL(request.url).pathname);
-    return doNamespace.get(id).fetch(request);
-  }
-  const stdinData = request.body ? new Uint8Array(await request.arrayBuffer()) : undefined;
-  const { readable, writable } = new TransformStream;
-  const stdoutWriter = writable.getWriter();
-  const { wasiImport, setMemory, collectOutput } = createWasiImports({
-    request,
-    stdinData,
-    onStdout: (chunk) => {
-      stdoutWriter.write(chunk);
-    }
-  });
-  let wasmMemory = null;
-  const mem = () => wasmMemory;
-  const bridgeRef = { current: null };
-  const bridgeImports = ZxBridge.createImportObject(bridgeRef);
-  const decoder2 = new TextDecoder;
-  const Suspending = WebAssembly.Suspending;
-  const jspi = typeof Suspending === "function";
-  const sysImports = {
-    sleep_ms: jspi ? new Suspending(async (ms) => new Promise((resolve) => setTimeout(resolve, ms))) : (_ms) => {}
-  };
-  const wsState = {
-    upgraded: false,
-    server: null,
-    pendingWrites: [],
-    messageQueue: [],
-    recvResolve: null
-  };
-  const wsImports = buildWsImports(jspi ? Suspending : null, mem, decoder2, wsState);
-  const instance = new WebAssembly.Instance(module, {
-    wasi_snapshot_preview1: { ...wasi?.wasiImport, ...wasiImport },
-    __zx_sys: sysImports,
-    __zx_ws: wsImports,
-    __zx_kv: createKVImports(kvBindings ?? { default: createMemoryKV() }, mem),
-    ...imports ? imports(mem) : {},
-    ...bridgeImports
-  });
-  wasmMemory = instance.exports.memory;
-  setMemory(wasmMemory);
-  const bridge = new ZxBridge(instance.exports);
-  bridgeRef.current = bridge;
-  let wasmPromise;
-  if (jspi) {
-    const start = WebAssembly.promising(instance.exports._start);
-    wasmPromise = start().catch((e) => {
-      if (e instanceof Error && e.message.startsWith("proc_exit"))
-        return;
-      throw e;
-    }).finally(() => {
-      stdoutWriter.close();
-      if (wsState.recvResolve) {
-        const res = wsState.recvResolve;
-        wsState.recvResolve = null;
-        res(null);
-      }
-    });
-  } else {
-    try {
-      instance.exports._start();
-    } catch (e) {
-      if (!(e instanceof ProcExit))
-        throw e;
-    }
-    stdoutWriter.close();
-    wasmPromise = Promise.resolve();
-  }
-  if (wsState.upgraded) {
-    const server = attachWebSocket(wsState);
-    ctx?.waitUntil(wasmPromise);
-    return new Response(null, { status: 101, webSocket: server.client });
+function mergeUint8Arrays(arrays) {
+  const totalLen = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
   }
-  const { stderrText } = collectOutput();
-  const meta = parseEdgeMeta(stderrText);
-  return new Response(readable, {
-    status: meta.status,
-    headers: meta.headers
-  });
+  return result;
 }
-function buildWsImports(Suspending, mem, decoder2, ws) {
-  const readStr = (ptr, len) => decoder2.decode(new Uint8Array(mem().buffer, ptr, len));
+
+// src/runtime.ts
+function buildWsImports(Suspending, mem, decoder3, ws) {
+  const readStr = (ptr, len) => decoder3.decode(new Uint8Array(mem().buffer, ptr, len));
   return {
     ws_upgrade: () => {
       ws.upgraded = true;
@@ -1246,7 +1354,7 @@ function buildWsImports(Suspending, mem, decoder2, ws) {
       }
     },
     ws_close: (code, reason_ptr, reason_len) => {
-      ws.server?.close(code, decoder2.decode(new Uint8Array(mem().buffer, reason_ptr, reason_len)));
+      ws.server?.close(code, decoder3.decode(new Uint8Array(mem().buffer, reason_ptr, reason_len)));
     },
     ws_recv: Suspending ? new Suspending(async (buf_ptr, buf_max) => {
       if (ws._resolveFirstSuspend) {
@@ -1310,6 +1418,193 @@ function attachWebSocket(ws) {
   });
   return { client };
 }
+function buildSysImports(jspi, Suspending) {
+  return {
+    sleep_ms: jspi ? new Suspending(async (ms) => new Promise((r) => setTimeout(r, ms))) : (_ms) => {}
+  };
+}
+function executeWasm(instance, jspi, Suspending, wsState) {
+  if (!jspi) {
+    try {
+      instance.exports._start();
+    } catch (e) {
+      if (!(e instanceof ProcExit))
+        throw e;
+    }
+    return Promise.resolve();
+  }
+  const start = WebAssembly.promising(instance.exports._start);
+  return start().catch((e) => {
+    if (e instanceof Error && e.message.startsWith("proc_exit"))
+      return;
+    throw e;
+  }).finally(() => {
+    if (wsState.recvResolve) {
+      const res = wsState.recvResolve;
+      wsState.recvResolve = null;
+      res(null);
+    }
+  });
+}
+function parseEdgeMeta(stderrText) {
+  const meta = { status: 200, headers: new Headers, streaming: false };
+  const metaPrefix = "__EDGE_META__:";
+  const metaLine = stderrText.split(`
+`).find((line) => line.startsWith(metaPrefix));
+  if (metaLine) {
+    try {
+      const parsed = JSON.parse(metaLine.slice(metaPrefix.length));
+      if (parsed.status)
+        meta.status = parsed.status;
+      if (parsed.streaming === true)
+        meta.streaming = true;
+      if (Array.isArray(parsed.headers)) {
+        for (const [name, value] of parsed.headers) {
+          meta.headers.append(name, value);
+        }
+      }
+    } catch {}
+  }
+  return meta;
+}
+async function run({
+  request,
+  env,
+  ctx,
+  module,
+  kv: kvBindings,
+  imports,
+  wasi,
+  websocket: doNamespace
+}) {
+  if (doNamespace && request.headers.get("upgrade")?.toLowerCase() === "websocket") {
+    const id = doNamespace.idFromName(new URL(request.url).pathname);
+    return doNamespace.get(id).fetch(request);
+  }
+  const stdinData = request.body ? new Uint8Array(await request.arrayBuffer()) : undefined;
+  const stdoutChunks = [];
+  let streamWriter = null;
+  const { wasiImport, setMemory, collectOutput } = createWasiImports({
+    request,
+    stdinData,
+    onStdout: (chunk) => {
+      if (streamWriter)
+        streamWriter.write(chunk);
+      else
+        stdoutChunks.push(chunk);
+    }
+  });
+  let wasmMemory = null;
+  const mem = () => wasmMemory;
+  const bridgeRef = { current: null };
+  const Suspending = WebAssembly.Suspending;
+  const jspi = typeof Suspending === "function";
+  const wsState = {
+    upgraded: false,
+    server: null,
+    pendingWrites: [],
+    messageQueue: [],
+    recvResolve: null
+  };
+  const instance = new WebAssembly.Instance(module, {
+    wasi_snapshot_preview1: { ...wasi?.wasiImport, ...wasiImport },
+    __zx_sys: buildSysImports(jspi, Suspending),
+    __zx_ws: buildWsImports(jspi ? Suspending : null, mem, new TextDecoder, wsState),
+    __zx_kv: createKVImports(kvBindings ?? { default: createMemoryKV() }, mem),
+    ...imports ? imports(mem) : {},
+    ...ZxWasiBridge.createImportObject(bridgeRef)
+  });
+  wasmMemory = instance.exports.memory;
+  setMemory(wasmMemory);
+  bridgeRef.current = new ZxWasiBridge(instance.exports);
+  const wasmPromise = executeWasm(instance, jspi, Suspending, wsState);
+  if (wsState.upgraded) {
+    const server = attachWebSocket(wsState);
+    ctx?.waitUntil(wasmPromise);
+    return new Response(null, { status: 101, webSocket: server.client });
+  }
+  const { stderrText } = collectOutput();
+  const meta = parseEdgeMeta(stderrText);
+  if (meta.streaming) {
+    const { readable, writable } = new TransformStream;
+    streamWriter = writable.getWriter();
+    for (const chunk of stdoutChunks)
+      streamWriter.write(chunk);
+    stdoutChunks.length = 0;
+    wasmPromise.finally(() => streamWriter?.close());
+    return new Response(readable, { status: meta.status, headers: meta.headers });
+  }
+  await wasmPromise;
+  const body = mergeUint8Arrays(stdoutChunks);
+  meta.headers.delete("transfer-encoding");
+  if (!meta.headers.has("content-length"))
+    meta.headers.set("content-length", String(body.byteLength));
+  return new Response(body.buffer, { status: meta.status, headers: meta.headers });
+}
+// src/app.ts
+async function resolveModule(input) {
+  if (typeof input === "string") {
+    if (input.startsWith("http://") || input.startsWith("https://")) {
+      return WebAssembly.compileStreaming(fetch(input));
+    }
+    const url = input.startsWith("/") ? `file://${input}` : input;
+    return WebAssembly.compile(await fetch(url).then((r) => r.arrayBuffer()));
+  }
+  if (input instanceof URL) {
+    return WebAssembly.compileStreaming(fetch(input));
+  }
+  if (input instanceof Response) {
+    return WebAssembly.compileStreaming(input);
+  }
+  if (input instanceof ArrayBuffer) {
+    return WebAssembly.compile(input);
+  }
+  if (ArrayBuffer.isView(input)) {
+    return WebAssembly.compile(input.buffer);
+  }
+  return input;
+}
+
+class Ziex {
+  options;
+  resolved = null;
+  constructor(options) {
+    this.options = options;
+  }
+  async getModule() {
+    if (!this.resolved)
+      this.resolved = await resolveModule(this.options.module);
+    return this.resolved;
+  }
+  resolveKV(env) {
+    const { kv } = this.options;
+    if (kv === undefined)
+      return;
+    if (typeof kv === "object" && kv !== null) {
+      const result = {};
+      for (const [name, key] of Object.entries(kv)) {
+        result[name] = env[key];
+      }
+      return result;
+    }
+    return { default: env[kv] };
+  }
+  fetch = async (request, env, ctx) => {
+    const module = await this.getModule();
+    const { wasi, imports, websocket } = this.options;
+    return run({
+      request,
+      env,
+      ctx,
+      module,
+      wasi,
+      imports,
+      kv: this.resolveKV(env),
+      websocket: websocket !== undefined ? env[websocket] : undefined
+    });
+  };
+}
+// src/cloudflare/do.ts
 function createWebSocketDO(module, options) {
   return class ZxWebSocketDO {
     doState;
@@ -1328,7 +1623,7 @@ function createWebSocketDO(module, options) {
       const bridgeImports = ZxBridge.createImportObject(bridgeRef);
       const Suspending = WebAssembly.Suspending;
       const jspi = typeof Suspending === "function";
-      const decoder2 = new TextDecoder;
+      const decoder3 = new TextDecoder;
       let _resolveFirstSuspend;
       const firstSuspendPromise = new Promise((resolve) => {
         _resolveFirstSuspend = resolve;
@@ -1365,7 +1660,7 @@ function createWebSocketDO(module, options) {
       const sysImports = {
         sleep_ms: jspi ? new Suspending(async (ms) => new Promise((r) => setTimeout(r, ms))) : (_ms) => {}
       };
-      const wsImports = buildWsImports(jspi ? Suspending : null, mem, decoder2, connState);
+      const wsImports = buildWsImports(jspi ? Suspending : null, mem, decoder3, connState);
       const kvBindings = options?.kv?.(this.env);
       const instance = new WebAssembly.Instance(module, {
         wasi_snapshot_preview1: wasiImport,
@@ -1404,109 +1699,8 @@ function createWebSocketDO(module, options) {
     }
   };
 }
-function parseEdgeMeta(stderrText) {
-  const meta = { status: 200, headers: new Headers };
-  const metaPrefix = "__EDGE_META__:";
-  const metaLine = stderrText.split(`
-`).find((line) => line.startsWith(metaPrefix));
-  if (metaLine) {
-    try {
-      const parsed = JSON.parse(metaLine.slice(metaPrefix.length));
-      if (parsed.status)
-        meta.status = parsed.status;
-      if (Array.isArray(parsed.headers)) {
-        for (const [name, value] of parsed.headers) {
-          meta.headers.append(name, value);
-        }
-      }
-    } catch {}
-  }
-  return meta;
-}
-function mergeUint8Arrays(arrays) {
-  const totalLen = arrays.reduce((sum, arr) => sum + arr.length, 0);
-  const result = new Uint8Array(totalLen);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-async function collectStream(readable, chunks) {
-  const reader = readable.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done)
-      break;
-    if (value)
-      chunks.push(value);
-  }
-}
-function prepare({
-  request,
-  env,
-  ctx
-}) {
-  const stdout = new TransformStream;
-  const stderr = new TransformStream;
-  const url = new URL(request.url);
-  const args = [
-    "--pathname",
-    url.pathname,
-    "--method",
-    request.method,
-    "--search",
-    url.search
-  ];
-  request.headers.forEach((value, name) => {
-    args.push("--header", `${name}:${value}`);
-  });
-  const stdin = request.body ?? undefined;
-  return { args, stdout, stderr, stdin };
-}
-async function respond({
-  exec,
-  stdout,
-  stderr
-}) {
-  const stdoutChunks = [];
-  const stderrChunks = [];
-  const stderrReadable = stderr instanceof ReadableStream ? stderr : stderr.readable;
-  await Promise.all([
-    exec,
-    collectStream(stdout.readable, stdoutChunks),
-    collectStream(stderrReadable, stderrChunks)
-  ]);
-  const stderrText = new TextDecoder().decode(mergeUint8Arrays(stderrChunks));
-  const meta = parseEdgeMeta(stderrText);
-  return new Response(mergeUint8Arrays(stdoutChunks).buffer, {
-    status: meta.status,
-    headers: meta.headers
-  });
-}
-// src/cloudflare/app.ts
-class Ziex {
-  options;
-  constructor(options) {
-    this.options = options;
-  }
-  fetch(request, env, ctx) {
-    const { module, wasi, imports, kv, websocket } = this.options;
-    return run({
-      request,
-      env,
-      ctx,
-      module,
-      wasi,
-      imports,
-      kv: kv?.(env),
-      websocket: websocket?.(env)
-    });
-  }
-}
 export {
-  exports_worker as worker,
+  exports_runtime as worker,
   exports_kv as kv,
   createWebSocketDO,
   Ziex