ziex 0.1.0-dev.1458 → 0.1.0-dev.1567

package/index.js

@@ -1,9 +1,14 @@
+// src/wasm/constants.ts
+var CallbackType_FetchSuccess = 1;
+var CallbackType_FetchError = 2;
+var CallbackType_Timeout = 3;
+var CallbackType_Interval = 4;
+
 // src/wasm/wasi.ts
 var decoder = new TextDecoder();
 var encoder = new TextEncoder();
 var ZxWasiBridge = class {
   #alloc;
-  #fetchCompleteHandler;
   #memory;
   #cb;
   #intervals = /* @__PURE__ */ new Map();
@@ -13,7 +18,6 @@ var ZxWasiBridge = class {
   constructor(exports) {
     this.#memory = exports.memory;
     this.#alloc = exports.__zx_alloc;
-    this.#fetchCompleteHandler = exports.__zx_fetch_complete;
     this.#cb = exports.__zx_cb;
   }
   #view() {
@@ -38,6 +42,9 @@ var ZxWasiBridge = class {
     if (start + data.length > view.byteLength) return;
     view.set(data, start);
   }
+  #invoke(type, id, a = 0n, b = 0n, c = 0n) {
+    this.#cb?.(type, id, a, b, c);
+  }
   log(level, ptr, len) {
     const msg = decoder.decode(this.#view().subarray(ptr, ptr + len));
     switch (level) {
@@ -90,13 +97,14 @@ var ZxWasiBridge = class {
     const encoded = typeof body === "string" ? encoder.encode(body) : body;
     const ptr = this.#alloc(encoded.length);
     this.#writeBytes(ptr, encoded);
-    this.#fetchCompleteHandler(fetchId, status, ptr, encoded.length, isError ? 1 : 0);
+    const type = isError ? CallbackType_FetchError : CallbackType_FetchSuccess;
+    this.#invoke(type, fetchId, BigInt(status), BigInt(ptr), BigInt(encoded.length));
   }
   setTimeout(callbackId, delayMs) {
-    setTimeout(() => this.#cb?.(3, callbackId, 0n), delayMs);
+    setTimeout(() => this.#invoke(CallbackType_Timeout, callbackId), delayMs);
   }
   setInterval(callbackId, intervalMs) {
-    const handle = setInterval(() => this.#cb?.(4, callbackId, 0n), intervalMs);
+    const handle = setInterval(() => this.#invoke(CallbackType_Interval, callbackId), intervalMs);
     this.#intervals.set(callbackId, handle);
   }
   clearInterval(callbackId) {
@@ -150,7 +158,7 @@ var ZxWasiBridge = class {
 function createFetchImports(getMemory) {
   const encoder3 = new TextEncoder();
   const decoder3 = new TextDecoder();
-  function readStr(ptr, len) {
+  function readStr2(ptr, len) {
     return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
   }
   function writeBytes(buf_ptr, buf_max, data) {
@@ -176,9 +184,9 @@ function createFetchImports(getMemory) {
     return headers;
   }
   async function doFetch(url_ptr, url_len, method_ptr, method_len, headers_ptr, headers_len, body_ptr, body_len, timeout_ms, status_out, buf_ptr, buf_max) {
-    const url = readStr(url_ptr, url_len);
-    const method = method_len > 0 ? readStr(method_ptr, method_len) : "GET";
-    const headersJson = headers_len > 0 ? readStr(headers_ptr, headers_len) : "{}";
+    const url = readStr2(url_ptr, url_len);
+    const method = method_len > 0 ? readStr2(method_ptr, method_len) : "GET";
+    const headersJson = headers_len > 0 ? readStr2(headers_ptr, headers_len) : "{}";
     const body = body_len > 0 ? readBytes(body_ptr, body_len) : void 0;
     const headers = parseHeaders(headersJson);
     const controller = new AbortController();
@@ -201,14 +209,14 @@ function createFetchImports(getMemory) {
       return -1;
     }
   }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "function") {
+  const Suspending2 = WebAssembly.Suspending;
+  if (typeof Suspending2 !== "function") {
     return {
       fetch: (_url_ptr, _url_len, _method_ptr, _method_len, _headers_ptr, _headers_len, _body_ptr, _body_len, _timeout_ms, _status_out, _buf_ptr, _buf_max) => -1
     };
   }
   return {
-    fetch: new Suspending(doFetch)
+    fetch: new Suspending2(doFetch)
   };
 }
 
@@ -490,90 +498,96 @@ function bindWasmAlloc(allocRef, exports) {
 }
 
 // src/runtime/kv/extern.ts
+var Suspending = WebAssembly.Suspending;
+var jspi = typeof Suspending === "function";
+var miss = jspi ? -1 : 0;
 function putOptions(ttlSeconds) {
   if (ttlSeconds < 60) return void 0;
   return { expirationTtl: ttlSeconds };
 }
+function kvDel(binding, key) {
+  const b = binding;
+  return (b.del ?? b.delete).call(b, key);
+}
 function isSyncKVNamespace(binding) {
-  const candidate = binding;
-  return typeof candidate.getSync === "function" && typeof candidate.putSync === "function" && typeof candidate.deleteSync === "function" && typeof candidate.listSync === "function";
+  return typeof binding.get === "function" && binding.get.constructor.name !== "AsyncFunction";
 }
-function createKVImports(bindings, getMemory, allocRef) {
-  const encoder3 = new TextEncoder();
-  const decoder3 = new TextDecoder();
-  function readStr(ptr, len) {
-    return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
-  }
-  function binding(ns) {
-    return bindings[ns] ?? bindings["default"] ?? null;
+function listOpts(prefix) {
+  return prefix.length > 0 ? { prefix } : void 0;
+}
+function maybeThen(r, f) {
+  return r instanceof Promise ? r.then(f) : f(r);
+}
+function readStr(getMemory, ptr, len) {
+  return textDecoder.decode(new Uint8Array(getMemory().buffer, ptr, len));
+}
+function resolve(bindings, ns) {
+  const b = bindings[ns] ?? bindings["default"] ?? null;
+  if (!b || jspi) return b;
+  return isSyncKVNamespace(b) ? b : null;
+}
+function encodeGet(getMemory, allocRef, value, out_ptr) {
+  if (value === null) return -1;
+  return writeBytesOut(getMemory, allocRef, out_ptr, textEncoder.encode(value));
+}
+function encodeList(getMemory, allocRef, names, out_ptr) {
+  if (names.length === 0) {
+    new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+    return 0;
   }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "function") {
-    let syncBinding2 = function(ns) {
-      const candidate = binding(ns);
-      return candidate && isSyncKVNamespace(candidate) ? candidate : null;
-    };
-    var syncBinding = syncBinding2;
-    return {
-      kv_get: (ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
-        const b = syncBinding2(readStr(ns_ptr, ns_len));
-        if (!b) return -1;
-        const value = b.getSync(readStr(key_ptr, key_len));
-        if (value === null) return -1;
-        return writeBytesOut(getMemory, allocRef, out_ptr, encoder3.encode(value));
-      },
-      kv_put: (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
-        const b = syncBinding2(readStr(ns_ptr, ns_len));
-        if (!b) return 0;
-        b.putSync(readStr(key_ptr, key_len), readStr(val_ptr, val_len), putOptions(ttl_seconds));
-        return 0;
-      },
-      kv_delete: (ns_ptr, ns_len, key_ptr, key_len) => {
-        const b = syncBinding2(readStr(ns_ptr, ns_len));
-        if (!b) return 0;
-        b.deleteSync(readStr(key_ptr, key_len));
-        return 0;
-      },
-      kv_list: (ns_ptr, ns_len, pfx_ptr, pfx_len, out_ptr) => {
-        const b = syncBinding2(readStr(ns_ptr, ns_len));
-        if (!b) return writeJsonOut(getMemory, allocRef, out_ptr, []);
-        const prefix = readStr(pfx_ptr, pfx_len);
-        const result = b.listSync(prefix.length > 0 ? { prefix } : void 0);
-        return writeJsonOut(getMemory, allocRef, out_ptr, result.keys.map((k) => k.name));
-      }
-    };
+  return writeJsonOut(getMemory, allocRef, out_ptr, names);
+}
+function get(b, key, out_ptr, getMemory, allocRef) {
+  return maybeThen(b.get(key), (v) => encodeGet(getMemory, allocRef, v, out_ptr));
+}
+function put(b, key, val, ttl) {
+  return maybeThen(b.put(key, val, putOptions(ttl)), () => 0);
+}
+function del(b, key) {
+  return maybeThen(kvDel(b, key), () => 0);
+}
+function list(b, prefix, out_ptr, getMemory, allocRef) {
+  return maybeThen(
+    b.list(listOpts(prefix)),
+    (result) => encodeList(getMemory, allocRef, result.keys.map((k) => k.name), out_ptr)
+  );
+}
+function wrapImport(impl) {
+  if (!jspi) {
+    return ((...args) => {
+      const r = impl(...args);
+      if (r instanceof Promise) throw new Error("async kv binding requires JSPI");
+      return r;
+    });
   }
+  return new Suspending(impl);
+}
+function createKVImports(bindings, getMemory, allocRef) {
   return {
-    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
-      const b = binding(readStr(ns_ptr, ns_len));
+    kv_get: wrapImport((ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
       if (!b) return -1;
-      const value = await b.get(readStr(key_ptr, key_len));
-      if (value === null) return -1;
-      return writeBytesOut(getMemory, allocRef, out_ptr, encoder3.encode(value));
+      return get(b, readStr(getMemory, key_ptr, key_len), out_ptr, getMemory, allocRef);
     }),
-    kv_put: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
-      const b = binding(readStr(ns_ptr, ns_len));
-      if (!b) return -1;
-      await b.put(readStr(key_ptr, key_len), readStr(val_ptr, val_len), putOptions(ttl_seconds));
-      return 0;
+    kv_put: wrapImport((ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
+      if (!b) return miss;
+      return put(
+        b,
+        readStr(getMemory, key_ptr, key_len),
+        readStr(getMemory, val_ptr, val_len),
+        ttl_seconds
+      );
     }),
-    kv_delete: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len) => {
-      const b = binding(readStr(ns_ptr, ns_len));
-      if (!b) return -1;
-      await b.delete(readStr(key_ptr, key_len));
-      return 0;
+    kv_delete: wrapImport((ns_ptr, ns_len, key_ptr, key_len) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
+      if (!b) return miss;
+      return del(b, readStr(getMemory, key_ptr, key_len));
     }),
-    kv_list: new Suspending(async (ns_ptr, ns_len, prefix_ptr, prefix_len, out_ptr) => {
-      const b = binding(readStr(ns_ptr, ns_len));
+    kv_list: wrapImport((ns_ptr, ns_len, pfx_ptr, pfx_len, out_ptr) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
       if (!b) return writeJsonOut(getMemory, allocRef, out_ptr, []);
-      const prefix = readStr(prefix_ptr, prefix_len);
-      const result = await b.list(prefix.length > 0 ? { prefix } : void 0);
-      const names = result.keys.map((k) => k.name);
-      if (names.length === 0) {
-        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
-        return 0;
-      }
-      return writeJsonOut(getMemory, allocRef, out_ptr, names);
+      return list(b, readStr(getMemory, pfx_ptr, pfx_len), out_ptr, getMemory, allocRef);
     })
   };
 }
@@ -645,21 +659,21 @@ function valuesToWireRows(rows) {
 }
 function createDbImports(bindings, getMemory, allocRef) {
   const decoder3 = new TextDecoder();
-  function readStr(ptr, len) {
+  function readStr2(ptr, len) {
     return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
   }
   function binding(ns) {
     return bindings[ns] ?? bindings["default"] ?? null;
   }
   async function statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len) {
-    const database = binding(readStr(ns_ptr, ns_len));
+    const database = binding(readStr2(ns_ptr, ns_len));
     if (!database) return null;
-    const sql = readStr(sql_ptr, sql_len);
-    const bindingsJson = JSON.parse(readStr(bindings_ptr, bindings_len));
+    const sql = readStr2(sql_ptr, sql_len);
+    const bindingsJson = JSON.parse(readStr2(bindings_ptr, bindings_len));
     return database.prepare(sql).bind(...toPositionalBindings(bindingsJson));
   }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "function") {
+  const Suspending2 = WebAssembly.Suspending;
+  if (typeof Suspending2 !== "function") {
     return {
       db_open: (_ns, _ns_len) => -1,
       db_run: (_a, _b, _c, _d, _e, _f, _g) => -1,
@@ -669,8 +683,8 @@ function createDbImports(bindings, getMemory, allocRef) {
     };
   }
   return {
-    db_open: (ns_ptr, ns_len) => binding(readStr(ns_ptr, ns_len)) ? 0 : -1,
-    db_run: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
+    db_open: (ns_ptr, ns_len) => binding(readStr2(ns_ptr, ns_len)) ? 0 : -1,
+    db_run: new Suspending2(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
       const stmt = await statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len);
       if (!stmt) return -1;
       const result = await stmt.run();
@@ -679,7 +693,7 @@ function createDbImports(bindings, getMemory, allocRef) {
         changes: result.meta?.changes ?? 0
       });
     }),
-    db_get: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
+    db_get: new Suspending2(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
       const stmt = await statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len);
       if (!stmt) return -1;
       const row = await stmt.first();
@@ -689,7 +703,7 @@ function createDbImports(bindings, getMemory, allocRef) {
       }
       return writeJsonOut(getMemory, allocRef, out_ptr, [objectToWireRow(row)]);
     }),
-    db_all: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
+    db_all: new Suspending2(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
       const stmt = await statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len);
       if (!stmt) return -1;
       const result = await stmt.all();
@@ -700,7 +714,7 @@ function createDbImports(bindings, getMemory, allocRef) {
       }
       return writeJsonOut(getMemory, allocRef, out_ptr, rows);
     }),
-    db_values: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
+    db_values: new Suspending2(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, out_ptr) => {
       const stmt = await statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len);
       if (!stmt) return -1;
       const rows = await stmt.raw();
@@ -722,8 +736,7 @@ var ProcExit = class extends Error {
 };
 function createWasiImports({
   request,
-  stdinData,
-  onStdout
+  stdinData
 }) {
   const encoder3 = new TextEncoder();
   const url = new URL(request.url);
@@ -747,8 +760,6 @@ function createWasiImports({
   const setMemory = (m2) => {
     wasmMemory = m2;
   };
-  const stdoutChunks = [];
-  let stderrMeta = "";
   let stderrPartial = "";
   const stderrDecoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
   function processStderrChunk(chunk) {
@@ -756,9 +767,7 @@ function createWasiImports({
     const lines = (stderrPartial + text).split("\n");
     stderrPartial = lines.pop() ?? "";
     for (const line of lines) {
-      if (line.startsWith("__ZIEX_META__:")) {
-        stderrMeta += line + "\n";
-      } else if (line.length > 0) {
+      if (line.length > 0) {
         console.error("[ziex]", line);
       }
     }
@@ -804,10 +813,7 @@ function createWasiImports({
         const buf_ptr = dv.getUint32(iovs_ptr + i * 8, true);
         const buf_len = dv.getUint32(iovs_ptr + i * 8 + 4, true);
         const chunk = mem.slice(buf_ptr, buf_ptr + buf_len);
-        if (fd === 1) {
-          if (onStdout) onStdout(chunk);
-          else stdoutChunks.push(chunk);
-        } else if (fd === 2) processStderrChunk(chunk);
+        if (fd === 2) processStderrChunk(chunk);
         written += buf_len;
       }
       dv.setUint32(nwritten_ptr, written, true);
@@ -975,26 +981,12 @@ function createWasiImports({
       v().setUint32(bufused_ptr, 0, true);
       return 76;
     },
-    // Stub for poll_oneoff - no blocking I/O in edge runtimes.
     poll_oneoff(_in, _out, _nsubscriptions, nevents_ptr) {
       v().setUint32(nevents_ptr, 0, true);
       return 0;
     }
   };
-  function collectOutput() {
-    const remaining = stderrDecoder.decode(void 0, { stream: false });
-    const tail = stderrPartial + remaining;
-    if (tail.length > 0) {
-      if (tail.startsWith("__ZIEX_META__:")) stderrMeta += tail;
-      else console.error("[ziex]", tail);
-      stderrPartial = "";
-    }
-    return {
-      stdout: mergeUint8Arrays(stdoutChunks),
-      stderrText: stderrMeta
-    };
-  }
-  return { wasiImport, setMemory, collectOutput };
+  return { wasiImport, setMemory };
 }
 function mergeUint8Arrays(arrays) {
   const totalLen = arrays.reduce((sum, arr) => sum + arr.length, 0);
@@ -1008,50 +1000,78 @@ function mergeUint8Arrays(arrays) {
 }
 
 // src/runtime/kv/memory.ts
-function createMemoryKV() {
-  const store = /* @__PURE__ */ new Map();
-  function read(key) {
-    const entry = store.get(key);
-    if (!entry) return null;
-    const expiresAt = entry[1];
-    if (expiresAt !== void 0 && Date.now() >= expiresAt) {
-      store.delete(key);
-      return null;
-    }
-    return entry[0];
-  }
-  function write(key, value, options) {
-    let expiresAt;
-    if (options?.expiration !== void 0) {
-      expiresAt = options.expiration * 1e3;
-    } else if (options?.expirationTtl !== void 0) {
-      expiresAt = Date.now() + options.expirationTtl * 1e3;
-    }
-    store.set(key, [value, expiresAt]);
+var store = /* @__PURE__ */ new Map();
+async function get2(key) {
+  const entry = store.get(key);
+  if (!entry) return null;
+  const expiresAt = entry[1];
+  if (expiresAt !== void 0 && Date.now() >= expiresAt) {
+    store.delete(key);
+    return null;
+  }
+  return entry[0];
+}
+async function put2(key, value, options) {
+  let expiresAt;
+  if (options?.expiration !== void 0) {
+    expiresAt = options.expiration * 1e3;
+  } else if (options?.expirationTtl !== void 0) {
+    expiresAt = Date.now() + options.expirationTtl * 1e3;
+  }
+  store.set(key, [value, expiresAt]);
+}
+async function del2(key) {
+  store.delete(key);
+}
+async function list2(options) {
+  const keys = [];
+  for (const name of [...store.keys()]) {
+    if (options?.prefix && !name.startsWith(options.prefix)) continue;
+    if (await get2(name) !== null) keys.push({ name });
   }
+  return { keys };
+}
+
+// src/runtime/index.ts
+function buildHttpImports(mem, http) {
+  const decoder3 = new TextDecoder();
   return {
-    async get(key) {
-      return read(key);
-    },
-    async put(key, value, options) {
-      write(key, value, options);
+    commit: (status, meta_ptr, meta_len) => {
+      http.status = status >>> 0;
+      http.committed = true;
+      http.headers = new Headers();
+      http.streaming = false;
+      if (meta_len > 0) {
+        try {
+          const raw = decoder3.decode(new Uint8Array(mem().buffer, meta_ptr >>> 0, meta_len >>> 0));
+          const parsed = JSON.parse(raw);
+          if (parsed.streaming === true) http.streaming = true;
+          if (Array.isArray(parsed.headers)) {
+            for (const [name, value] of parsed.headers) {
+              http.headers.append(name, value);
+            }
+          }
+        } catch {
+        }
+      }
     },
-    async delete(key) {
-      store.delete(key);
+    write: (ptr, len) => {
+      if (len <= 0) return;
+      const chunk = new Uint8Array(mem().buffer, ptr >>> 0, len >>> 0).slice();
+      if (http.streamWriter) void http.streamWriter.write(chunk);
+      else http.bodyChunks.push(chunk);
     },
-    async list(options) {
-      const keys = [...store.keys()].filter((k) => {
-        if (options?.prefix && !k.startsWith(options.prefix)) return false;
-        return read(k) !== null;
-      }).map((name) => ({ name }));
-      return { keys };
+    end: () => {
+      http.ended = true;
+      if (http.streamWriter) {
+        void http.streamWriter.close();
+        http.streamWriter = null;
+      }
     }
   };
 }
-
-// src/runtime/index.ts
-function buildWsImports(Suspending, mem, decoder3, ws) {
-  const readStr = (ptr, len) => decoder3.decode(new Uint8Array(mem().buffer, ptr, len));
+function buildWsImports(Suspending2, mem, decoder3, ws) {
+  const readStr2 = (ptr, len) => decoder3.decode(new Uint8Array(mem().buffer, ptr, len));
   return {
     ws_upgrade: () => {
       ws.upgraded = true;
@@ -1067,7 +1087,7 @@ function buildWsImports(Suspending, mem, decoder3, ws) {
     ws_close: (code, 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) => {
+    ws_recv: Suspending2 ? new Suspending2(async (buf_ptr, buf_max) => {
       if (ws._resolveFirstSuspend) {
         const fn = ws._resolveFirstSuspend;
         ws._resolveFirstSuspend = void 0;
@@ -1080,23 +1100,23 @@ function buildWsImports(Suspending, mem, decoder3, ws) {
         return n;
       };
       if (ws.messageQueue.length > 0) return deliver(ws.messageQueue.shift());
-      return new Promise((resolve) => {
-        ws.recvResolve = (bytes) => resolve(deliver(bytes));
+      return new Promise((resolve2) => {
+        ws.recvResolve = (bytes) => resolve2(deliver(bytes));
       });
     }) : (_buf_ptr, _buf_max) => -1,
     // Pub/sub - delegates to optional callbacks (real in DO, no-ops otherwise)
     ws_subscribe: (ptr, len) => {
-      ws.subscribe?.(readStr(ptr, len));
+      ws.subscribe?.(readStr2(ptr, len));
     },
     ws_unsubscribe: (ptr, len) => {
-      ws.unsubscribe?.(readStr(ptr, len));
+      ws.unsubscribe?.(readStr2(ptr, len));
     },
     ws_publish: (topic_ptr, topic_len, data_ptr, data_len) => {
-      const topic = readStr(topic_ptr, topic_len);
+      const topic = readStr2(topic_ptr, topic_len);
       const data = new Uint8Array(mem().buffer, data_ptr, data_len).slice();
       return ws.publish?.(topic, data) ?? 0;
     },
-    ws_is_subscribed: (ptr, len) => ws.isSubscribed?.(readStr(ptr, len)) ? 1 : 0
+    ws_is_subscribed: (ptr, len) => ws.isSubscribed?.(readStr2(ptr, len)) ? 1 : 0
   };
 }
 function attachWebSocket(ws) {
@@ -1127,14 +1147,14 @@ function attachWebSocket(ws) {
   });
   return { client };
 }
-function buildSysImports(jspi, Suspending) {
+function buildSysImports(jspi2, Suspending2) {
   return {
-    sleep_ms: jspi ? new Suspending(async (ms) => new Promise((r) => setTimeout(r, ms))) : (_ms) => {
+    sleep_ms: jspi2 ? new Suspending2(async (ms) => new Promise((r) => setTimeout(r, ms))) : (_ms) => {
     }
   };
 }
-function executeWasm(instance, jspi, Suspending, wsState) {
-  if (!jspi) {
+function executeWasm(instance, jspi2, Suspending2, wsState) {
+  if (!jspi2) {
     try {
       instance.exports._start();
     } catch (e) {
@@ -1154,25 +1174,6 @@ function executeWasm(instance, jspi, Suspending, wsState) {
     }
   });
 }
-function parseZiexMeta(stderrText) {
-  const meta = { status: 200, headers: new Headers(), streaming: false };
-  const metaPrefix = "__ZIEX_META__:";
-  const metaLine = stderrText.split("\n").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,
@@ -1182,29 +1183,32 @@ async function run({
   db: dbBindings,
   imports,
   wasi,
-  websocket: doNamespace
+  sticky
 }) {
-  if (doNamespace && request.headers.get("upgrade")?.toLowerCase() === "websocket") {
-    const id = doNamespace.idFromName(new URL(request.url).pathname);
-    return doNamespace.get(id).fetch(request);
+  if (sticky && request.headers.get("upgrade")?.toLowerCase() === "websocket") {
+    const id = sticky.idFromName(new URL(request.url).pathname);
+    return sticky.get(id).fetch(request);
   }
   const stdinData = request.body ? new Uint8Array(await request.arrayBuffer()) : void 0;
-  const stdoutChunks = [];
-  let streamWriter = null;
-  const { wasiImport, setMemory, collectOutput } = createWasiImports({
+  const httpState = {
+    committed: false,
+    ended: false,
+    status: 200,
+    streaming: false,
+    headers: new Headers(),
+    bodyChunks: [],
+    streamWriter: null
+  };
+  const { wasiImport, setMemory } = createWasiImports({
     request,
-    stdinData,
-    onStdout: (chunk) => {
-      if (streamWriter) void streamWriter.write(chunk);
-      else stdoutChunks.push(chunk);
-    }
+    stdinData
   });
   let wasmMemory = null;
   const mem = () => wasmMemory;
   const bridgeRef = [null];
   const allocRef = [null];
-  const Suspending = WebAssembly.Suspending;
-  const jspi = typeof Suspending === "function";
+  const Suspending2 = WebAssembly.Suspending;
+  const jspi2 = typeof Suspending2 === "function";
   const wsState = {
     upgraded: false,
     server: null,
@@ -1214,15 +1218,16 @@ async function run({
   };
   const importObject = {
     wasi_snapshot_preview1: { ...wasi?.wasiImport, ...wasiImport },
-    __zx_sys: buildSysImports(jspi, Suspending),
-    __zx_ws: buildWsImports(jspi ? Suspending : null, mem, new TextDecoder(), wsState),
+    __zx_sys: buildSysImports(jspi2, Suspending2),
+    __zx_ws: buildWsImports(jspi2 ? Suspending2 : null, mem, new TextDecoder(), wsState),
+    __zx_http: buildHttpImports(mem, httpState),
     __zx_net: createFetchImports(mem),
     ...imports ? imports(mem) : {},
     ...ZxWasiBridge.createImportObject(bridgeRef)
   };
   if (true) {
     importObject.__zx_kv = createKVImports(
-      kvBindings ?? { default: createMemoryKV() },
+      kvBindings ?? { default: { get: get2, put: put2, del: del2, list: list2 } },
       mem,
       allocRef
     );
@@ -1239,34 +1244,37 @@ async function run({
   setMemory(wasmMemory);
   bridgeRef[0] = new ZxWasiBridge(instance.exports);
   bindWasmAlloc(allocRef, instance.exports);
-  const wasmPromise = executeWasm(instance, jspi, Suspending, wsState);
+  const wasmPromise = executeWasm(instance, jspi2, Suspending2, wsState);
   if (wsState.upgraded) {
     const server = attachWebSocket(wsState);
     ctx?.waitUntil(wasmPromise);
     return new Response(null, { status: 101, webSocket: server.client });
   }
-  const { stderrText: earlyStderrText } = collectOutput();
-  const earlyMeta = parseZiexMeta(earlyStderrText);
-  if (earlyMeta.streaming) {
+  if (httpState.committed && httpState.streaming) {
     const { readable, writable } = new TransformStream();
-    streamWriter = writable.getWriter();
-    for (const chunk of stdoutChunks) void streamWriter.write(chunk);
-    stdoutChunks.length = 0;
-    void wasmPromise.finally(() => streamWriter?.close());
-    return new Response(readable, { status: earlyMeta.status, headers: earlyMeta.headers });
+    httpState.streamWriter = writable.getWriter();
+    for (const chunk of httpState.bodyChunks) void httpState.streamWriter.write(chunk);
+    httpState.bodyChunks.length = 0;
+    void wasmPromise.finally(() => {
+      if (httpState.streamWriter) {
+        void httpState.streamWriter.close();
+        httpState.streamWriter = null;
+      }
+    });
+    return new Response(readable, { status: httpState.status, headers: httpState.headers });
   }
   await wasmPromise;
-  const { stderrText } = collectOutput();
-  const meta = parseZiexMeta(stderrText);
-  const body = mergeUint8Arrays(stdoutChunks);
-  meta.headers.delete("transfer-encoding");
-  const nullBody = meta.status === 101 || meta.status === 204 || meta.status === 205 || meta.status === 304;
+  const status = httpState.status;
+  const headers = httpState.headers;
+  headers.delete("transfer-encoding");
+  const nullBody = status === 101 || status === 204 || status === 205 || status === 304;
   if (nullBody) {
-    meta.headers.delete("content-length");
-    return new Response(null, { status: meta.status, headers: meta.headers });
+    headers.delete("content-length");
+    return new Response(null, { status, headers });
   }
-  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 });
+  const body = mergeUint8Arrays(httpState.bodyChunks);
+  if (!headers.has("content-length")) headers.set("content-length", String(body.byteLength));
+  return new Response(body.buffer, { status, headers });
 }
 
 // src/app.ts
@@ -1303,7 +1311,7 @@ var Ziex = class {
      */
     this.fetch = async (request, env, ctx) => {
       const module = await this.getModule();
-      const { wasi, imports, websocket } = this.options;
+      const { wasi, imports, sticky } = this.options;
       return run({
         request,
         env,
@@ -1313,7 +1321,7 @@ var Ziex = class {
         imports,
         kv: this.resolveKV(env),
         db: this.resolveDB(env),
-        websocket: websocket !== void 0 ? env[websocket] : void 0
+        sticky: sticky !== void 0 ? env[sticky] : void 0
       });
     };
     this.options = options;
@@ -1322,6 +1330,27 @@ var Ziex = class {
     if (!this.resolved) this.resolved = await resolveModule(this.options.module);
     return this.resolved;
   }
+  /**
+   * Enable sticky upgrade forwarding and return host config for platform adapters
+   * (e.g. Cloudflare {@linkcode stateful}).
+   *
+   * Requires `options.module` to already be a compiled `WebAssembly.Module`.
+   */
+  stickyHost(binding) {
+    this.options.sticky = binding;
+    const mod = this.options.module;
+    if (mod instanceof ArrayBuffer || ArrayBuffer.isView(mod) || mod instanceof Response || mod instanceof URL || typeof mod === "string") {
+      throw new Error(
+        'sticky handlers require a compiled WebAssembly.Module (e.g. `import module from "./app.wasm"` under wrangler)'
+      );
+    }
+    return {
+      module: mod,
+      imports: this.options.imports,
+      kv: (env) => this.resolveKV(env),
+      db: (env) => this.resolveDB(env)
+    };
+  }
   resolveKV(env) {
     const { kv } = this.options;
     if (kv === void 0) return void 0;