ziex 0.1.0-dev.1466 → 0.1.0-dev.1568

package/platforms/cloudflare/index.js

@@ -1,257 +1,3 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/runtime/index.ts
-var runtime_exports = {};
-__export(runtime_exports, {
-  attachWebSocket: () => attachWebSocket,
-  buildWsImports: () => buildWsImports,
-  run: () => run
-});
-
-// src/wasm/constants.ts
-var DOM_CMD_HEADER_SIZE = 8;
-var DOM_CMD_RECORD_SIZE = 24;
-var DomOp_CreateElement = 1;
-var DomOp_CreateText = 2;
-var DomOp_HydrateInsert = 3;
-var DomOp_SetAttr = 4;
-var DomOp_SetProp = 5;
-var DomOp_RemoveAttr = 6;
-var DomOp_SetNodeValue = 7;
-var DomOp_SetInnerHtml = 8;
-var DomOp_AppendChild = 9;
-var DomOp_InsertBefore = 10;
-var DomOp_RemoveChild = 11;
-var DomOp_ReplaceChild = 12;
-var CallbackType_FetchSuccess = 1;
-var CallbackType_FetchError = 2;
-var CallbackType_Timeout = 3;
-var CallbackType_Interval = 4;
-var CallbackType_WebSocketOpen = 5;
-var CallbackType_WebSocketMessage = 6;
-var CallbackType_WebSocketError = 7;
-var CallbackType_WebSocketClose = 8;
-
-// src/wasm/wasi.ts
-var decoder = new TextDecoder();
-var encoder = new TextEncoder();
-var ZxWasiBridge = class {
-  #alloc;
-  #memory;
-  #cb;
-  #intervals = /* @__PURE__ */ new Map();
-  // Cached memory view - invalidated when the WASM buffer grows.
-  #memView = null;
-  #memBuf = null;
-  constructor(exports) {
-    this.#memory = exports.memory;
-    this.#alloc = exports.__zx_alloc;
-    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) {
-    const start = ptr >>> 0;
-    const length = len >>> 0;
-    if (length === 0) return "";
-    const view = this.#view();
-    if (start + length > view.byteLength) return "";
-    return decoder.decode(view.subarray(start, start + length));
-  }
-  #writeBytes(ptr, data) {
-    const start = ptr >>> 0;
-    const view = this.#view();
-    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) {
-      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.#view().subarray(bodyPtr, bodyPtr + bodyLen) : void 0;
-    let headers = {};
-    try {
-      headers = JSON.parse(headersJson);
-    } catch {
-      for (const line of headersJson.split("\n")) {
-        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 : void 0,
-      body: method !== "GET" && method !== "HEAD" ? body : void 0,
-      signal: controller.signal
-    }).then(async (res) => {
-      if (timeout) clearTimeout(timeout);
-      const bytes = new Uint8Array(await res.arrayBuffer());
-      this.#notifyFetchComplete(fetchId, res.status, bytes, 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 = typeof body === "string" ? encoder.encode(body) : body;
-    const ptr = this.#alloc(encoded.length);
-    this.#writeBytes(ptr, encoded);
-    const type = isError ? CallbackType_FetchError : CallbackType_FetchSuccess;
-    this.#invoke(type, fetchId, BigInt(status), BigInt(ptr), BigInt(encoded.length));
-  }
-  setTimeout(callbackId, delayMs) {
-    setTimeout(() => this.#invoke(CallbackType_Timeout, callbackId), delayMs);
-  }
-  setInterval(callbackId, intervalMs) {
-    const handle = setInterval(() => this.#invoke(CallbackType_Interval, callbackId), intervalMs);
-    this.#intervals.set(callbackId, handle);
-  }
-  clearInterval(callbackId) {
-    const handle = this.#intervals.get(callbackId);
-    if (handle !== void 0) {
-      clearInterval(handle);
-      this.#intervals.delete(callbackId);
-    }
-  }
-  /**
-   * Create the WASI import object for WASM instantiation.
-   *
-   * Returns only the `__zx` namespace (log, fetch, timers).
-   * Does NOT include jsz.importObject() - the server binary does not use jsz.
-   */
-  static createImportObject(bridgeRef) {
-    return {
-      __zx: {
-        _log: (level, ptr, len) => {
-          bridgeRef[0]?.log(level, ptr, len);
-        },
-        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
-          bridgeRef[0]?.fetchAsync(
-            urlPtr,
-            urlLen,
-            methodPtr,
-            methodLen,
-            headersPtr,
-            headersLen,
-            bodyPtr,
-            bodyLen,
-            timeoutMs,
-            fetchId
-          );
-        },
-        _setTimeout: (callbackId, delayMs) => {
-          bridgeRef[0]?.setTimeout(callbackId, delayMs);
-        },
-        _setInterval: (callbackId, intervalMs) => {
-          bridgeRef[0]?.setInterval(callbackId, intervalMs);
-        },
-        _clearInterval: (callbackId) => {
-          bridgeRef[0]?.clearInterval(callbackId);
-        }
-      }
-    };
-  }
-};
-
-// src/runtime/fetch.ts
-function createFetchImports(getMemory) {
-  const encoder3 = new TextEncoder();
-  const decoder3 = new TextDecoder();
-  function readStr(ptr, len) {
-    return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
-  }
-  function writeBytes2(buf_ptr, buf_max, data) {
-    if (data.length > buf_max) return -2;
-    new Uint8Array(getMemory().buffer, buf_ptr, data.length).set(data);
-    return data.length;
-  }
-  function readBytes(ptr, len) {
-    return new Uint8Array(getMemory().buffer, ptr, len);
-  }
-  function parseHeaders(headersJson) {
-    let headers = {};
-    try {
-      headers = JSON.parse(headersJson);
-    } catch {
-      for (const line of headersJson.split("\n")) {
-        const colonIdx = line.indexOf(":");
-        if (colonIdx > 0) {
-          headers[line.slice(0, colonIdx)] = line.slice(colonIdx + 1);
-        }
-      }
-    }
-    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 body = body_len > 0 ? readBytes(body_ptr, body_len) : void 0;
-    const headers = parseHeaders(headersJson);
-    const controller = new AbortController();
-    const timeout = timeout_ms > 0 ? setTimeout(() => controller.abort(), timeout_ms) : null;
-    try {
-      const response = await fetch(url, {
-        method,
-        headers: Object.keys(headers).length > 0 ? headers : void 0,
-        body: method !== "GET" && method !== "HEAD" ? body : void 0,
-        signal: controller.signal
-      });
-      if (timeout) clearTimeout(timeout);
-      new DataView(getMemory().buffer).setUint16(status_out, response.status, true);
-      const bytes = new Uint8Array(await response.arrayBuffer());
-      return writeBytes2(buf_ptr, buf_max, bytes);
-    } catch (err) {
-      if (timeout) clearTimeout(timeout);
-      const msg = err instanceof Error ? err.message : String(err);
-      console.error(`wasm fetch failed: ${url} (${msg})`);
-      return -1;
-    }
-  }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "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)
-  };
-}
-
 // ../../vendor/jsz/js/src/zigjs.ts
 var NAN_PREFIX = 2146959360;
 var predefined = {
@@ -264,8 +10,8 @@ var predefined = {
   "runtime": 6
 };
 var PREDEFINED_ID_MAX = 6;
-var encoder2 = new TextEncoder();
-var decoder2 = new TextDecoder("utf-8");
+var encoder = new TextEncoder();
+var decoder = new TextDecoder("utf-8");
 var ZigJS = class {
   constructor() {
     /**
@@ -349,7 +95,7 @@ var ZigJS = class {
    * */
   valueStringLen(id) {
     const val = this.loadValue(id);
-    const buf = encoder2.encode(val);
+    const buf = encoder.encode(val);
     return buf.byteLength;
   }
   /**
@@ -361,7 +107,7 @@ var ZigJS = class {
     const cap = max >>> 0;
     const val = this.loadValue(id);
     if (typeof val !== "string") return;
-    const bytes = encoder2.encode(val);
+    const bytes = encoder.encode(val);
     if (bytes.byteLength > cap || bytes.length === 0) return;
     const buf = this.memory.buffer;
     if (dest + bytes.length > buf.byteLength) return;
@@ -497,31 +243,121 @@ var ZigJS = class {
     if (length === 0 || start + length > buf.byteLength) return "";
     const arr = new Uint8ClampedArray(buf, start, length);
     const data = arr.slice();
-    return decoder2.decode(data);
+    return decoder.decode(data);
   }
 };
 
-// src/wasm/core.ts
-var jsz = new ZigJS();
-var tempRefBuffer = new ArrayBuffer(8);
-var tempRefView = new DataView(tempRefBuffer);
-function storeValueGetRef(val) {
-  const originalMemory = jsz.memory;
-  jsz.memory = { buffer: tempRefBuffer };
-  jsz.storeValue(0, val);
-  jsz.memory = originalMemory;
-  return tempRefView.getBigUint64(0, true);
-}
-function loadValueFromRef(ref) {
-  tempRefView.setBigUint64(0, ref, true);
-  const originalMemory = jsz.memory;
-  jsz.memory = { buffer: tempRefBuffer };
-  const val = jsz.loadRef(0);
-  jsz.memory = originalMemory;
-  return val;
-}
-function releaseValueRef(ref) {
-  tempRefView.setBigUint64(0, ref, true);
+// src/runtime/fetch.ts
+function createFetchImports(getMemory) {
+  const encoder3 = new TextEncoder();
+  const decoder3 = new TextDecoder();
+  function readStr2(ptr, len) {
+    return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
+  }
+  function writeBytes2(buf_ptr, buf_max, data) {
+    if (data.length > buf_max) return -2;
+    new Uint8Array(getMemory().buffer, buf_ptr, data.length).set(data);
+    return data.length;
+  }
+  function readBytes(ptr, len) {
+    return new Uint8Array(getMemory().buffer, ptr, len);
+  }
+  function parseHeaders(headersJson) {
+    let headers = {};
+    try {
+      headers = JSON.parse(headersJson);
+    } catch {
+      for (const line of headersJson.split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx > 0) {
+          headers[line.slice(0, colonIdx)] = line.slice(colonIdx + 1);
+        }
+      }
+    }
+    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 = 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();
+    const timeout = timeout_ms > 0 ? setTimeout(() => controller.abort(), timeout_ms) : null;
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: Object.keys(headers).length > 0 ? headers : void 0,
+        body: method !== "GET" && method !== "HEAD" ? body : void 0,
+        signal: controller.signal
+      });
+      if (timeout) clearTimeout(timeout);
+      new DataView(getMemory().buffer).setUint16(status_out, response.status, true);
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      return writeBytes2(buf_ptr, buf_max, bytes);
+    } catch (err) {
+      if (timeout) clearTimeout(timeout);
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`wasm fetch failed: ${url} (${msg})`);
+      return -1;
+    }
+  }
+  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 Suspending2(doFetch)
+  };
+}
+
+// src/wasm/constants.ts
+var DOM_CMD_HEADER_SIZE = 8;
+var DOM_CMD_RECORD_SIZE = 24;
+var DomOp_CreateElement = 1;
+var DomOp_CreateText = 2;
+var DomOp_HydrateInsert = 3;
+var DomOp_SetAttr = 4;
+var DomOp_SetProp = 5;
+var DomOp_RemoveAttr = 6;
+var DomOp_SetNodeValue = 7;
+var DomOp_SetInnerHtml = 8;
+var DomOp_AppendChild = 9;
+var DomOp_InsertBefore = 10;
+var DomOp_RemoveChild = 11;
+var DomOp_ReplaceChild = 12;
+var CallbackType_FetchSuccess = 1;
+var CallbackType_FetchError = 2;
+var CallbackType_Timeout = 3;
+var CallbackType_Interval = 4;
+var CallbackType_WebSocketOpen = 5;
+var CallbackType_WebSocketMessage = 6;
+var CallbackType_WebSocketError = 7;
+var CallbackType_WebSocketClose = 8;
+
+// src/wasm/core.ts
+var jsz = new ZigJS();
+var tempRefBuffer = new ArrayBuffer(8);
+var tempRefView = new DataView(tempRefBuffer);
+function storeValueGetRef(val) {
+  const originalMemory = jsz.memory;
+  jsz.memory = { buffer: tempRefBuffer };
+  jsz.storeValue(0, val);
+  jsz.memory = originalMemory;
+  return tempRefView.getBigUint64(0, true);
+}
+function loadValueFromRef(ref) {
+  tempRefView.setBigUint64(0, ref, true);
+  const originalMemory = jsz.memory;
+  jsz.memory = { buffer: tempRefBuffer };
+  const val = jsz.loadRef(0);
+  jsz.memory = originalMemory;
+  return val;
+}
+function releaseValueRef(ref) {
+  tempRefView.setBigUint64(0, ref, true);
   if (!Number.isNaN(tempRefView.getFloat64(0, true))) return;
   const id = tempRefView.getUint32(0, true);
   if (id > 6) jsz.deleteValue(id);
@@ -760,1005 +596,239 @@ 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);
     })
   };
 }
 
-// src/runtime/db/extern.ts
-function decodeBlob(base64) {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-  return bytes;
-}
-function toDbValue(value) {
-  switch (value.kind) {
-    case "null":
-      return null;
-    case "integer":
-      return value.integer;
-    case "float":
-      return value.float;
-    case "text":
-      return value.text;
-    case "blob":
-      return decodeBlob(value.blob);
-    case "boolean":
-      return value.boolean;
+// src/runtime/kv/localstorage.ts
+var namespace = "default";
+var storagePrefix = "ziex-kv";
+var namespacePrefix = `${storagePrefix}:${namespace}:`;
+function storage() {
+  if (typeof localStorage === "undefined") {
+    throw new Error("localStorage is not available in this environment");
   }
+  return localStorage;
 }
-function toPositionalBindings(json) {
-  switch (json.kind) {
-    case "none":
-      return [];
-    case "positional":
-      return json.values.map(toDbValue);
-    case "named":
-      throw new Error("named SQL bindings are not supported yet");
-  }
+function get2(key) {
+  return storage().getItem(`${storagePrefix}:${namespace}:${key}`);
 }
-function toWireValue(value) {
-  if (value === null || value === void 0) return { kind: "null" };
-  if (typeof value === "string") return { kind: "text", text: value };
-  if (typeof value === "boolean") return { kind: "boolean", boolean: value };
-  if (typeof value === "number") {
-    return Number.isInteger(value) ? { kind: "integer", integer: value } : { kind: "float", float: value };
-  }
-  if (value instanceof ArrayBuffer) {
-    const bytes = new Uint8Array(value);
-    let binary = "";
-    for (const byte of bytes) binary += String.fromCharCode(byte);
-    return { kind: "blob", blob: btoa(binary) };
-  }
-  if (ArrayBuffer.isView(value)) {
-    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-    let binary = "";
-    for (const byte of bytes) binary += String.fromCharCode(byte);
-    return { kind: "blob", blob: btoa(binary) };
+function put2(key, value) {
+  storage().setItem(`${storagePrefix}:${namespace}:${key}`, value);
+}
+function del2(key) {
+  storage().removeItem(`${storagePrefix}:${namespace}:${key}`);
+}
+function list2(options) {
+  const ls = storage();
+  const prefix = namespacePrefix + (options?.prefix ?? "");
+  const keys = [];
+  for (let i = 0; i < ls.length; i += 1) {
+    const key = ls.key(i);
+    if (!key || !key.startsWith(prefix)) continue;
+    keys.push({ name: key.slice(namespacePrefix.length) });
+  }
+  return { keys };
+}
+
+// src/runtime/kv/indexdb.ts
+var databaseName = "ziex-kv";
+var storeName = "kv";
+var namespace2 = "default";
+var dbPromise;
+function openDb() {
+  if (!dbPromise) {
+    if (typeof indexedDB === "undefined") {
+      return Promise.reject(new Error("IndexedDB is not available in this environment"));
+    }
+    dbPromise = new Promise((resolve2, reject) => {
+      const request = indexedDB.open(databaseName, 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(storeName)) {
+          db.createObjectStore(storeName);
+        }
+      };
+      request.onsuccess = () => resolve2(request.result);
+      request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
+    });
   }
-  return { kind: "text", text: String(value) };
+  return dbPromise;
 }
-function objectToWireRow(record) {
+function requestToPromise(request) {
+  return new Promise((resolve2, reject) => {
+    request.onsuccess = () => resolve2(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+function transactionToPromise(transaction) {
+  return new Promise((resolve2, reject) => {
+    transaction.oncomplete = () => resolve2();
+    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
+    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed"));
+  });
+}
+async function get3(key) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readonly");
+  const value = await requestToPromise(tx.objectStore(storeName).get(`${namespace2}:${key}`));
+  await transactionToPromise(tx);
+  return typeof value === "string" ? value : null;
+}
+async function put3(key, value) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).put(value, `${namespace2}:${key}`);
+  await transactionToPromise(tx);
+}
+async function del3(key) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).delete(`${namespace2}:${key}`);
+  await transactionToPromise(tx);
+}
+async function list3(options) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readonly");
+  const keys = await requestToPromise(tx.objectStore(storeName).getAllKeys());
+  await transactionToPromise(tx);
+  const prefix = `${namespace2}:${options?.prefix ?? ""}`;
   return {
-    fields: Object.entries(record).map(([name, value]) => ({
-      name,
-      value: toWireValue(value)
-    }))
+    keys: keys.filter((key) => typeof key === "string" && key.startsWith(prefix)).map((key) => ({ name: key.slice(namespace2.length + 1) }))
   };
 }
-function valuesToWireRows(rows) {
-  return rows.map((row) => row.map((value) => toWireValue(value)));
+
+// src/runtime/kv.ts
+var hasJspi = typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
+function createBrowserKVBindings(options = {}) {
+  const namespace3 = options.namespace ?? "default";
+  return {
+    [namespace3]: hasJspi && !options.forceLocalStorage ? { get: get3, put: put3, del: del3, list: list3 } : { get: get2, put: put2, del: del2, list: list2 }
+  };
 }
-function createDbImports(bindings, getMemory, allocRef) {
-  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;
-  }
-  async function statement(ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len) {
-    const database = binding(readStr(ns_ptr, ns_len));
-    if (!database) return null;
-    const sql = readStr(sql_ptr, sql_len);
-    const bindingsJson = JSON.parse(readStr(bindings_ptr, bindings_len));
-    return database.prepare(sql).bind(...toPositionalBindings(bindingsJson));
-  }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "function") {
-    return {
-      db_open: (_ns, _ns_len) => -1,
-      db_run: (_a, _b, _c, _d, _e, _f, _g) => -1,
-      db_get: (_a, _b, _c, _d, _e, _f, _g) => -1,
-      db_all: (_a, _b, _c, _d, _e, _f, _g) => -1,
-      db_values: (_a, _b, _c, _d, _e, _f, _g) => -1
-    };
+
+// src/runtime/kv/memory.ts
+var store = /* @__PURE__ */ new Map();
+async function get4(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 put4(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 del4(key) {
+  store.delete(key);
+}
+async function list4(options) {
+  const keys = [];
+  for (const name of [...store.keys()]) {
+    if (options?.prefix && !name.startsWith(options.prefix)) continue;
+    if (await get4(name) !== null) keys.push({ name });
   }
-  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) => {
-      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();
-      return writeJsonOut(getMemory, allocRef, out_ptr, {
-        last_insert_rowid: result.meta?.last_row_id ?? 0,
-        changes: result.meta?.changes ?? 0
-      });
-    }),
-    db_get: new Suspending(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();
-      if (!row) {
-        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
-        return 0;
-      }
-      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) => {
-      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();
-      const rows = (result.results ?? []).map(objectToWireRow);
-      if (rows.length === 0) {
-        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
-        return 0;
-      }
-      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) => {
-      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();
-      if (rows.length === 0) {
-        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
-        return 0;
-      }
-      return writeJsonOut(getMemory, allocRef, out_ptr, valuesToWireRows(rows));
-    })
-  };
-}
-
-// src/runtime/wasi.ts
-var ProcExit = class extends Error {
-  constructor(code) {
-    super(`proc_exit(${code})`);
-    this.code = code;
-  }
-};
-function createWasiImports({
-  request,
-  stdinData,
-  onStdout
-}) {
-  const encoder3 = new TextEncoder();
-  const url = new URL(request.url);
-  const argStrings = [
-    "wasm",
-    "--pathname",
-    url.pathname,
-    "--method",
-    request.method,
-    "--search",
-    url.search,
-    "--url",
-    url.href
-  ];
-  request.headers.forEach((value, name) => {
-    if (value) argStrings.push("--header", `${name}:${value}`);
-  });
-  const encodedArgs = argStrings.map((a) => encoder3.encode(a + "\0"));
-  const argBufSize = encodedArgs.reduce((s, a) => s + a.length, 0);
-  let wasmMemory = null;
-  const setMemory = (m2) => {
-    wasmMemory = m2;
-  };
-  const stdoutChunks = [];
-  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("\n");
-    stderrPartial = lines.pop() ?? "";
-    for (const line of lines) {
-      if (line.startsWith("__ZIEX_META__:")) {
-        stderrMeta += line + "\n";
-      } else if (line.length > 0) {
-        console.error("[ziex]", line);
-      }
-    }
-  }
-  let stdinOffset = 0;
-  function v() {
-    return new DataView(wasmMemory.buffer);
-  }
-  function m() {
-    return new Uint8Array(wasmMemory.buffer);
-  }
-  const wasiImport = {
-    args_sizes_get(argc_ptr, argv_buf_size_ptr) {
-      v().setUint32(argc_ptr, encodedArgs.length, true);
-      v().setUint32(argv_buf_size_ptr, argBufSize, true);
-      return 0;
-    },
-    args_get(argv_ptr, argv_buf_ptr) {
-      const dv = v();
-      const mem = m();
-      let offset = argv_buf_ptr;
-      for (const arg of encodedArgs) {
-        dv.setUint32(argv_ptr, offset, true);
-        mem.set(arg, offset);
-        argv_ptr += 4;
-        offset += arg.length;
-      }
-      return 0;
-    },
-    environ_sizes_get(count_ptr, buf_size_ptr) {
-      v().setUint32(count_ptr, 0, true);
-      v().setUint32(buf_size_ptr, 0, true);
-      return 0;
-    },
-    environ_get(_environ_ptr, _environ_buf_ptr) {
-      return 0;
-    },
-    fd_write(fd, iovs_ptr, iovs_len, nwritten_ptr) {
-      const dv = v();
-      const mem = m();
-      let written = 0;
-      for (let i = 0; i < iovs_len; i++) {
-        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);
-        written += buf_len;
-      }
-      dv.setUint32(nwritten_ptr, written, true);
-      return 0;
-    },
-    fd_read(fd, iovs_ptr, iovs_len, nread_ptr) {
-      const dv = v();
-      const mem = m();
-      const stdin = stdinData ?? new Uint8Array(0);
-      let totalRead = 0;
-      for (let i = 0; i < iovs_len; i++) {
-        const buf_ptr = dv.getUint32(iovs_ptr + i * 8, true);
-        const buf_len = dv.getUint32(iovs_ptr + i * 8 + 4, true);
-        if (fd === 0 && stdinOffset < stdin.length) {
-          const toRead = Math.min(buf_len, stdin.length - stdinOffset);
-          mem.set(stdin.subarray(stdinOffset, stdinOffset + toRead), buf_ptr);
-          stdinOffset += toRead;
-          totalRead += toRead;
-        }
-      }
-      dv.setUint32(nread_ptr, totalRead, true);
-      return 0;
-    },
-    fd_fdstat_get(_fd, fdstat_ptr) {
-      const dv = v();
-      dv.setUint8(fdstat_ptr, 2);
-      dv.setUint8(fdstat_ptr + 1, 0);
-      dv.setUint16(fdstat_ptr + 2, 0, true);
-      dv.setUint32(fdstat_ptr + 4, 0, true);
-      dv.setBigUint64(fdstat_ptr + 8, 0n, true);
-      dv.setBigUint64(fdstat_ptr + 16, 0n, true);
-      return 0;
-    },
-    fd_prestat_get(_fd, _bufptr) {
-      return 8;
-    },
-    fd_prestat_dir_name(_fd, _path, _path_len) {
-      return 8;
-    },
-    fd_close(_fd) {
-      return 0;
-    },
-    fd_pread(_fd, _iovs, _iovs_len, _offset, nread_ptr) {
-      v().setUint32(nread_ptr, 0, true);
-      return 0;
-    },
-    fd_pwrite(_fd, _iovs, _iovs_len, _offset, nwritten_ptr) {
-      v().setUint32(nwritten_ptr, 0, true);
-      return 0;
-    },
-    fd_filestat_get(_fd, filestat_ptr) {
-      const dv = v();
-      dv.setBigUint64(filestat_ptr, 0n, true);
-      dv.setBigUint64(filestat_ptr + 8, 0n, true);
-      dv.setUint8(filestat_ptr + 16, 2);
-      dv.setBigUint64(filestat_ptr + 24, 1n, true);
-      dv.setBigUint64(filestat_ptr + 32, 0n, true);
-      dv.setBigUint64(filestat_ptr + 40, 0n, true);
-      dv.setBigUint64(filestat_ptr + 48, 0n, true);
-      dv.setBigUint64(filestat_ptr + 56, 0n, true);
-      return 0;
-    },
-    fd_filestat_set_size(_fd, _size) {
-      return 76;
-    },
-    fd_filestat_set_times(_fd, _atim, _mtim, _fst_flags) {
-      return 76;
-    },
-    fd_fdstat_set_flags(_fd, _flags) {
-      return 0;
-    },
-    fd_fdstat_set_rights(_fd, _rights_base, _rights_inheriting) {
-      return 0;
-    },
-    fd_sync(_fd) {
-      return 0;
-    },
-    fd_datasync(_fd) {
-      return 0;
-    },
-    fd_advise(_fd, _offset, _len, _advice) {
-      return 0;
-    },
-    fd_allocate(_fd, _offset, _len) {
-      return 76;
-    },
-    fd_tell(_fd, offset_ptr) {
-      v().setBigUint64(offset_ptr, 0n, true);
-      return 0;
-    },
-    fd_renumber(_from, _to) {
-      return 0;
-    },
-    path_filestat_set_times(_fd, _flags, _path, _path_len, _atim, _mtim, _fst_flags) {
-      return 76;
-    },
-    path_link(_old_fd, _old_flags, _old_path, _old_path_len, _new_fd, _new_path, _new_path_len) {
-      return 76;
-    },
-    path_symlink(_old_path, _old_path_len, _fd, _new_path, _new_path_len) {
-      return 76;
-    },
-    proc_raise(_sig) {
-      return 0;
-    },
-    sock_recv(_fd, _ri_data, _ri_data_len, _ri_flags, ro_datalen_ptr, ro_flags_ptr) {
-      v().setUint32(ro_datalen_ptr, 0, true);
-      v().setUint32(ro_flags_ptr, 0, true);
-      return 76;
-    },
-    sock_send(_fd, _si_data, _si_data_len, _si_flags, so_datalen_ptr) {
-      v().setUint32(so_datalen_ptr, 0, true);
-      return 76;
-    },
-    sock_shutdown(_fd, _how) {
-      return 76;
-    },
-    fd_seek(_fd, _offset, _whence, newoffset_ptr) {
-      v().setBigInt64(newoffset_ptr, 0n, true);
-      return 0;
-    },
-    proc_exit(code) {
-      throw new ProcExit(code);
-    },
-    sched_yield() {
-      return 0;
-    },
-    clock_time_get(_id, _precision, time_ptr) {
-      v().setBigUint64(time_ptr, BigInt(Date.now()) * 1000000n, true);
-      return 0;
-    },
-    clock_res_get(_id, res_ptr) {
-      v().setBigUint64(res_ptr, 1000000n, true);
-      return 0;
-    },
-    random_get(buf_ptr, buf_len) {
-      crypto.getRandomValues(new Uint8Array(wasmMemory.buffer, buf_ptr, buf_len));
-      return 0;
-    },
-    path_open(_fd, _dirflags, _path, _path_len, _oflags, _rights_base, _rights_inheriting, _fdflags, opened_fd_ptr) {
-      v().setInt32(opened_fd_ptr, -1, true);
-      return 76;
-    },
-    path_create_directory(_fd, _path, _path_len) {
-      return 76;
-    },
-    path_unlink_file(_fd, _path, _path_len) {
-      return 76;
-    },
-    path_remove_directory(_fd, _path, _path_len) {
-      return 76;
-    },
-    path_rename(_fd, _old_path, _old_path_len, _new_fd, _new_path, _new_path_len) {
-      return 76;
-    },
-    path_filestat_get(_fd, _flags, _path, _path_len, filestat_ptr) {
-      new Uint8Array(wasmMemory.buffer, filestat_ptr, 64).fill(0);
-      return 76;
-    },
-    path_readlink(_fd, _path, _path_len, _buf, _buf_len, nread_ptr) {
-      v().setUint32(nread_ptr, 0, true);
-      return 76;
-    },
-    fd_readdir(_fd, _buf, _buf_len, _cookie, bufused_ptr) {
-      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 };
-}
-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;
-}
-
-// src/runtime/kv.ts
-var kv_exports = {};
-__export(kv_exports, {
-  createBrowserKVBindings: () => createBrowserKVBindings,
-  createIndexedDbKV: () => createIndexedDbKV,
-  createKVImports: () => createKVImports,
-  createLocalStorageKV: () => createLocalStorageKV,
-  createMemoryKV: () => createMemoryKV,
-  hasJSPI: () => hasJSPI
-});
-
-// 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]);
-  }
-  return {
-    async get(key) {
-      return read(key);
-    },
-    async put(key, value, options) {
-      write(key, value, options);
-    },
-    async delete(key) {
-      store.delete(key);
-    },
-    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 };
-    }
-  };
-}
-
-// src/runtime/kv/localstorage.ts
-function getLocalStorage() {
-  if (typeof localStorage === "undefined") {
-    throw new Error("localStorage is not available in this environment");
-  }
-  return localStorage;
-}
-function createLocalStorageKV(options = {}) {
-  const storage = getLocalStorage();
-  const namespace = options.namespace ?? "default";
-  const storagePrefix = options.storagePrefix ?? "ziex-kv";
-  const scopedKey = (key) => `${storagePrefix}:${namespace}:${key}`;
-  const namespacePrefix = scopedKey("");
-  return {
-    getSync(key) {
-      return storage.getItem(scopedKey(key));
-    },
-    async get(key) {
-      return this.getSync(key);
-    },
-    putSync(key, value) {
-      storage.setItem(scopedKey(key), value);
-    },
-    async put(key, value) {
-      this.putSync(key, value);
-    },
-    deleteSync(key) {
-      storage.removeItem(scopedKey(key));
-    },
-    async delete(key) {
-      this.deleteSync(key);
-    },
-    listSync(options2) {
-      const prefix = namespacePrefix + (options2?.prefix ?? "");
-      const keys = [];
-      for (let i = 0; i < storage.length; i += 1) {
-        const key = storage.key(i);
-        if (!key || !key.startsWith(prefix)) continue;
-        keys.push({ name: key.slice(namespacePrefix.length) });
-      }
-      return { keys };
-    },
-    async list(options2) {
-      return this.listSync(options2);
-    }
-  };
-}
-
-// src/runtime/kv/indexdb.ts
-function getIndexedDb() {
-  if (typeof indexedDB === "undefined") {
-    throw new Error("IndexedDB is not available in this environment");
-  }
-  return indexedDB;
-}
-function requestToPromise(request) {
-  return new Promise((resolve, reject) => {
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
-  });
-}
-function transactionToPromise(transaction) {
-  return new Promise((resolve, reject) => {
-    transaction.oncomplete = () => resolve();
-    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
-    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed"));
-  });
-}
-function createIndexedDbKV(options = {}) {
-  const databaseName = options.databaseName ?? "ziex-kv";
-  const storeName = options.storeName ?? "kv";
-  const namespace = options.namespace ?? "default";
-  const dbPromise = new Promise((resolve, reject) => {
-    const request = getIndexedDb().open(databaseName, 1);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(storeName)) {
-        db.createObjectStore(storeName);
-      }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
-  });
-  const scopedKey = (key) => `${namespace}:${key}`;
-  return {
-    async get(key) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readonly");
-      const store = tx.objectStore(storeName);
-      const value = await requestToPromise(store.get(scopedKey(key)));
-      await transactionToPromise(tx);
-      return typeof value === "string" ? value : null;
-    },
-    async put(key, value) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readwrite");
-      tx.objectStore(storeName).put(value, scopedKey(key));
-      await transactionToPromise(tx);
-    },
-    async delete(key) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readwrite");
-      tx.objectStore(storeName).delete(scopedKey(key));
-      await transactionToPromise(tx);
-    },
-    async list(options2) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readonly");
-      const store = tx.objectStore(storeName);
-      const keys = await requestToPromise(store.getAllKeys());
-      await transactionToPromise(tx);
-      const prefix = scopedKey(options2?.prefix ?? "");
-      return {
-        keys: keys.filter((key) => typeof key === "string" && key.startsWith(prefix)).map((key) => ({ name: key.slice(namespace.length + 1) }))
-      };
-    }
-  };
-}
-
-// src/runtime/kv.ts
-function hasJSPI() {
-  return typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
-}
-function createBrowserKVBindings(options = {}) {
-  const namespace = options.namespace ?? "default";
-  const isIndexedDb = hasJSPI() && !options.forceLocalStorage;
-  return {
-    [namespace]: isIndexedDb ? createIndexedDbKV(options) : createLocalStorageKV(options)
-  };
-}
-
-// src/runtime/index.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;
-    },
-    ws_write: (ptr, len) => {
-      const data = new Uint8Array(mem().buffer, ptr, len).slice();
-      if (!ws.server) {
-        ws.pendingWrites.push(data);
-      } else {
-        ws.server.send(data);
-      }
-    },
-    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) => {
-      if (ws._resolveFirstSuspend) {
-        const fn = ws._resolveFirstSuspend;
-        ws._resolveFirstSuspend = void 0;
-        fn();
-      }
-      const deliver = (bytes) => {
-        if (bytes === null) return -1;
-        const n = Math.min(bytes.length, buf_max);
-        new Uint8Array(mem().buffer, buf_ptr, n).set(bytes.subarray(0, n));
-        return n;
-      };
-      if (ws.messageQueue.length > 0) return deliver(ws.messageQueue.shift());
-      return new Promise((resolve) => {
-        ws.recvResolve = (bytes) => resolve(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_unsubscribe: (ptr, len) => {
-      ws.unsubscribe?.(readStr(ptr, len));
-    },
-    ws_publish: (topic_ptr, topic_len, data_ptr, data_len) => {
-      const topic = readStr(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
-  };
-}
-function attachWebSocket(ws) {
-  const WebSocketPairCtor = globalThis.WebSocketPair;
-  const pair = new WebSocketPairCtor();
-  const client = pair[0];
-  const server = pair[1];
-  ws.server = server;
-  server.accept();
-  for (const data of ws.pendingWrites) server.send(data);
-  ws.pendingWrites = [];
-  server.addEventListener("message", (event) => {
-    const data = typeof event.data === "string" ? new TextEncoder().encode(event.data) : new Uint8Array(event.data);
-    if (ws.recvResolve) {
-      const res = ws.recvResolve;
-      ws.recvResolve = null;
-      res(data);
-    } else {
-      ws.messageQueue.push(data);
-    }
-  });
-  server.addEventListener("close", () => {
-    if (ws.recvResolve) {
-      const res = ws.recvResolve;
-      ws.recvResolve = null;
-      res(null);
-    }
-  });
-  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 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,
-  ctx,
-  module,
-  kv: kvBindings,
-  db: dbBindings,
-  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()) : void 0;
-  const stdoutChunks = [];
-  let streamWriter = null;
-  const { wasiImport, setMemory, collectOutput } = createWasiImports({
-    request,
-    stdinData,
-    onStdout: (chunk) => {
-      if (streamWriter) void streamWriter.write(chunk);
-      else stdoutChunks.push(chunk);
-    }
-  });
-  let wasmMemory = null;
-  const mem = () => wasmMemory;
-  const bridgeRef = [null];
-  const allocRef = [null];
-  const Suspending = WebAssembly.Suspending;
-  const jspi = typeof Suspending === "function";
-  const wsState = {
-    upgraded: false,
-    server: null,
-    pendingWrites: [],
-    messageQueue: [],
-    recvResolve: null
-  };
-  const importObject = {
-    wasi_snapshot_preview1: { ...wasi?.wasiImport, ...wasiImport },
-    __zx_sys: buildSysImports(jspi, Suspending),
-    __zx_ws: buildWsImports(jspi ? Suspending : null, mem, new TextDecoder(), wsState),
-    __zx_net: createFetchImports(mem),
-    ...imports ? imports(mem) : {},
-    ...ZxWasiBridge.createImportObject(bridgeRef)
-  };
-  if (true) {
-    importObject.__zx_kv = createKVImports(
-      kvBindings ?? { default: createMemoryKV() },
-      mem,
-      allocRef
-    );
-  }
-  if (true) {
-    importObject.__zx_db = createDbImports(
-      dbBindings ?? {},
-      mem,
-      allocRef
-    );
-  }
-  const instance = new WebAssembly.Instance(module, importObject);
-  wasmMemory = instance.exports.memory;
-  setMemory(wasmMemory);
-  bridgeRef[0] = new ZxWasiBridge(instance.exports);
-  bindWasmAlloc(allocRef, 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: earlyStderrText } = collectOutput();
-  const earlyMeta = parseZiexMeta(earlyStderrText);
-  if (earlyMeta.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 });
-  }
-  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;
-  if (nullBody) {
-    meta.headers.delete("content-length");
-    return new Response(null, { status: meta.status, headers: meta.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 });
-}
-
-// 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;
-}
-var Ziex = class {
-  constructor(options) {
-    this.resolved = null;
-    /**
-     * Fetch handler called by the runtime on every request.
-     *
-     * Arrow function so `this` is always the class instance, even when the
-     * runtime extracts `fetch` from the exported object (e.g. Bun).
-     */
-    this.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),
-        db: this.resolveDB(env),
-        websocket: websocket !== void 0 ? env[websocket] : void 0
-      });
-    };
-    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 === void 0) return void 0;
-    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] };
-  }
-  resolveDB(env) {
-    const { db } = this.options;
-    if (db === void 0) return void 0;
-    if (typeof db === "object" && db !== null) {
-      const result = {};
-      for (const [name, key] of Object.entries(db)) {
-        result[name] = env[key];
-      }
-      return result;
-    }
-    return { default: env[db] };
-  }
-};
+  return { keys };
+}
 
 // src/wasm/generated/tags.ts
 var TAG_NAMES = [
@@ -1969,6 +1039,55 @@ var SVG_TAG_START_INDEX = 140;
 var CUSTOM_TAG_INDEX = 199;
 
 // src/wasm/dom_cmd.ts
+var BOOL_PROPS = /* @__PURE__ */ new Set([
+  "checked",
+  "selected",
+  "muted",
+  "defaultChecked",
+  "indeterminate"
+]);
+function enqueueAfterConnect(queue, el, kind) {
+  for (let i = 0; i < queue.length; i++) {
+    const job = queue[i];
+    if (job.el === el && job.kind === kind) return;
+  }
+  queue.push({ el, kind });
+}
+function runAfterConnect(queue) {
+  for (let i = 0; i < queue.length; i++) {
+    const job = queue[i];
+    if (!job.el.isConnected) continue;
+    switch (job.kind) {
+      case "focus": {
+        if (typeof job.el.focus !== "function") break;
+        try {
+          job.el.focus({ preventScroll: true });
+        } catch {
+          job.el.focus();
+        }
+        break;
+      }
+    }
+  }
+}
+function assignProp(el, name, val) {
+  if (BOOL_PROPS.has(name)) {
+    const on = val !== "false";
+    el[name] = on;
+    if (name === "defaultChecked" && "checked" in el) {
+      el.checked = on;
+    }
+    return;
+  }
+  if (name === "defaultValue") {
+    el.defaultValue = val;
+    if (typeof el.value === "string" && (el.value === "" || el.value === el.defaultValue)) {
+      el.value = val;
+    }
+    return;
+  }
+  el[name] = val;
+}
 function flushDomCmds(ptr, len, ctx) {
   const start = ptr >>> 0;
   const length = len >>> 0;
@@ -1980,6 +1099,7 @@ function flushDomCmds(ptr, len, ctx) {
   const recordsBytes = count * DOM_CMD_RECORD_SIZE;
   if (DOM_CMD_HEADER_SIZE + recordsBytes > length) return;
   const { domNodes: domNodes2, cleanupDomNodes: cleanupDomNodes2 } = ctx;
+  const afterConnect = [];
   for (let i = 0; i < count; i++) {
     const off = DOM_CMD_HEADER_SIZE + i * DOM_CMD_RECORD_SIZE;
     const op = view.getUint8(off);
@@ -2011,266 +1131,963 @@ function flushDomCmds(ptr, len, ctx) {
         end.parentNode.insertBefore(child, end);
         break;
       }
-      case DomOp_SetAttr: {
-        domNodes2.get(p0)?.setAttribute(readString(p1, p2), readString(p3, p4));
-        break;
+      case DomOp_SetAttr: {
+        const el = domNodes2.get(p0);
+        if (!el) break;
+        const name = readString(p1, p2);
+        const val = readString(p3, p4);
+        el.setAttribute(name, val);
+        if (name === "autofocus") {
+          enqueueAfterConnect(afterConnect, el, "focus");
+        }
+        break;
+      }
+      case DomOp_SetProp: {
+        const el = domNodes2.get(p0);
+        if (el) assignProp(el, readString(p1, p2), readString(p3, p4));
+        break;
+      }
+      case DomOp_RemoveAttr: {
+        domNodes2.get(p0)?.removeAttribute(readString(p1, p2));
+        break;
+      }
+      case DomOp_SetNodeValue: {
+        const node = domNodes2.get(p0);
+        if (node) node.nodeValue = readString(p1, p2);
+        break;
+      }
+      case DomOp_SetInnerHtml: {
+        const el = domNodes2.get(p0);
+        if (el) el.innerHTML = readString(p1, p2);
+        break;
+      }
+      case DomOp_AppendChild: {
+        const parent = domNodes2.get(p0);
+        const child = domNodes2.get(p1);
+        if (parent && child) parent.appendChild(child);
+        break;
+      }
+      case DomOp_InsertBefore: {
+        const parent = domNodes2.get(p0);
+        const child = domNodes2.get(p1);
+        const refNode = domNodes2.get(p2) ?? null;
+        if (parent && child) parent.insertBefore(child, refNode);
+        break;
+      }
+      case DomOp_RemoveChild: {
+        const parent = domNodes2.get(p0);
+        const child = domNodes2.get(p1);
+        if (parent && child) {
+          parent.removeChild(child);
+          cleanupDomNodes2(child);
+        }
+        break;
+      }
+      case DomOp_ReplaceChild: {
+        const parent = domNodes2.get(p0);
+        const newChild = domNodes2.get(p1);
+        const oldChild = domNodes2.get(p2);
+        if (parent && newChild && oldChild) {
+          parent.replaceChild(newChild, oldChild);
+          cleanupDomNodes2(oldChild);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  runAfterConnect(afterConnect);
+}
+
+// src/wasm/generated/events.ts
+var DELEGATED_EVENTS = [
+  "click",
+  "dblclick",
+  "input",
+  "change",
+  "submit",
+  "focusin",
+  "focusout",
+  "keydown",
+  "keyup",
+  "keypress",
+  "mouseenter",
+  "mouseleave",
+  "mousedown",
+  "mouseup",
+  "mousemove",
+  "touchstart",
+  "touchend",
+  "touchmove",
+  "scroll",
+  "wheel",
+  "pointerdown",
+  "pointermove",
+  "pointerup",
+  "pointercancel",
+  "pointerenter",
+  "pointerleave",
+  "lostpointercapture"
+];
+
+// src/wasm/generated/event_bits.ts
+var HIGH_FREQ_EVENT_BITS = 3031040;
+
+// src/wasm/index.ts
+var ZxBridge = class extends ZxBridgeCore {
+  #websockets = /* @__PURE__ */ new Map();
+  #eventbridge;
+  #eventbridgeAsync;
+  constructor(exports) {
+    super(exports);
+    this.#eventbridge = exports.__zx_eventbridge;
+    this.#eventbridgeAsync = wrapPromisingExport(
+      exports.__zx_eventbridge_async ?? exports.__zx_eventbridge
+    );
+  }
+  hasEventHandler(velementId, eventTypeId) {
+    return !!((eventHandlersPresent.get(velementId) ?? 0) & 1 << eventTypeId);
+  }
+  eventMaySuspend(velementId, eventTypeId) {
+    return !!((eventHandlersSuspend.get(velementId) ?? 0) & 1 << eventTypeId);
+  }
+  setEventHandlerMode(velementId, eventTypeId, maySuspend) {
+    const bit = 1 << eventTypeId;
+    const present = (eventHandlersPresent.get(velementId) ?? 0) | bit;
+    eventHandlersPresent.set(velementId, present);
+    const suspendBits = eventHandlersSuspend.get(velementId) ?? 0;
+    const nextSuspend = maySuspend ? suspendBits | bit : suspendBits & ~bit;
+    if (nextSuspend === 0) eventHandlersSuspend.delete(velementId);
+    else eventHandlersSuspend.set(velementId, nextSuspend);
+    ensureDelegatedListener(eventTypeId);
+  }
+  clearEventHandlerModes(velementId) {
+    const present = eventHandlersPresent.get(velementId) ?? 0;
+    eventHandlersPresent.delete(velementId);
+    eventHandlersSuspend.delete(velementId);
+    for (let bits = present & HIGH_FREQ_EVENT_BITS; bits !== 0; bits &= bits - 1) {
+      maybeRemoveHighFreqListener(31 - Math.clz32(bits));
+    }
+  }
+  /** Submit a form action with bound-state round-trip. */
+  submitFormActionAsync(form, actionId, statesJson, fetchId) {
+    const formData = new FormData(form);
+    formData.append("__$states", statesJson);
+    fetch(window.location.href, {
+      method: "POST",
+      // `>>> 0` reinterprets the i32 from wasm as u32 (ids can exceed 2^31).
+      headers: { "x-action": String(actionId >>> 0) },
+      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);
+    });
+  }
+  /**
+   * Create and connect a WebSocket.
+   * Completes via `__zx_cb(ws_open|ws_message|ws_error|ws_close, ...)`.
+   */
+  wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) {
+    const url = readString(urlPtr, urlLen);
+    const protocolsStr = protocolsLen > 0 ? readString(protocolsPtr, protocolsLen) : "";
+    const protocols = protocolsStr ? protocolsStr.split(",").map((p) => p.trim()).filter(Boolean) : void 0;
+    try {
+      const ws = protocols && protocols.length > 0 ? new WebSocket(url, protocols) : new WebSocket(url);
+      ws.binaryType = "arraybuffer";
+      ws.onopen = () => {
+        const protocol = ws.protocol || "";
+        const [ptr, len] = this._writeStringToWasm(protocol);
+        this._invoke(CallbackType_WebSocketOpen, wsId, BigInt(ptr), BigInt(len));
+      };
+      ws.onmessage = (event) => {
+        const isBinary = event.data instanceof ArrayBuffer;
+        const data = isBinary ? new Uint8Array(event.data) : textEncoder.encode(event.data);
+        const [ptr, len] = this.writeBytesToWasm(data);
+        this._invoke(CallbackType_WebSocketMessage, wsId, BigInt(ptr), BigInt(len), BigInt(isBinary ? 1 : 0));
+      };
+      ws.onerror = (_event) => {
+        const [ptr, len] = this._writeStringToWasm("WebSocket error");
+        this._invoke(CallbackType_WebSocketError, wsId, BigInt(ptr), BigInt(len));
+      };
+      ws.onclose = (event) => {
+        const reason = event.reason || "";
+        const [ptr, len] = this._writeStringToWasm(reason);
+        const c = BigInt(len) | BigInt(event.wasClean ? 1 : 0) << 32n;
+        this._invoke(CallbackType_WebSocketClose, wsId, BigInt(event.code), BigInt(ptr), c);
+        this.#websockets.delete(wsId);
+      };
+      this.#websockets.set(wsId, ws);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "WebSocket connection failed";
+      const [ptr, len] = this._writeStringToWasm(msg);
+      this._invoke(CallbackType_WebSocketError, wsId, BigInt(ptr), BigInt(len));
+    }
+  }
+  /** Send data over WebSocket */
+  wsSend(wsId, dataPtr, dataLen, isBinary) {
+    const ws = this.#websockets.get(wsId);
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    const memory = getMemoryView();
+    const start = dataPtr >>> 0;
+    const length = dataLen >>> 0;
+    if (start + length > memory.byteLength) return;
+    if (isBinary) {
+      ws.send(memory.slice(start, start + length));
+    } else {
+      ws.send(textDecoder.decode(memory.subarray(start, start + length)));
+    }
+  }
+  /** Close WebSocket connection */
+  wsClose(wsId, code, reasonPtr, reasonLen) {
+    const ws = this.#websockets.get(wsId);
+    if (!ws) return;
+    const reason = reasonLen > 0 ? readString(reasonPtr, reasonLen) : void 0;
+    try {
+      if (reason) ws.close(code, reason);
+      else ws.close(code);
+    } catch {
+      ws.close();
+    }
+  }
+  dispose() {
+    super.dispose();
+    eventHandlersPresent.clear();
+    eventHandlersSuspend.clear();
+    for (const ws of this.#websockets.values()) {
+      try {
+        ws.close();
+      } catch {
+      }
+    }
+    this.#websockets.clear();
+  }
+  /**
+   * Dispatch to WASM for one vnode. Caller owns `eventRef` lifetime
+   * (store once per bubble, release after sync/async work completes).
+   */
+  eventbridge(velementId, eventTypeId, eventRef) {
+    const id = BigInt(velementId >>> 0);
+    if (this.eventMaySuspend(velementId, eventTypeId)) {
+      return invokeWasmExport(this.#eventbridgeAsync, id, eventTypeId, eventRef);
+    }
+    invokeWasmExport(this.#eventbridge, id, eventTypeId, eventRef);
+  }
+  /** Create the full browser import object for WASM instantiation (includes DOM + WebSocket). */
+  static createImportObject(bridgeRef) {
+    return {
+      ...jsz.importObject(),
+      __zx_net: createFetchImports(() => {
+        if (!jsz.memory) throw new Error("WASM memory is not ready");
+        return jsz.memory;
+      }),
+      __zx: {
+        _log: (level, ptr, len) => ZxBridgeCore.log(level, ptr, len),
+        _setEventHandlerMode: (vnodeId, eventTypeId, maySuspend) => {
+          bridgeRef[0]?.setEventHandlerMode(Number(vnodeId), eventTypeId, maySuspend !== 0);
+        },
+        _clearEventHandlerModes: (vnodeId) => {
+          bridgeRef[0]?.clearEventHandlerModes(Number(vnodeId));
+        },
+        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
+          bridgeRef[0]?.fetchAsync(
+            urlPtr,
+            urlLen,
+            methodPtr,
+            methodLen,
+            headersPtr,
+            headersLen,
+            bodyPtr,
+            bodyLen,
+            timeoutMs,
+            fetchId
+          );
+        },
+        _setTimeout: (callbackId, delayMs) => {
+          bridgeRef[0]?.setTimeout(callbackId, delayMs);
+        },
+        _setInterval: (callbackId, intervalMs) => {
+          bridgeRef[0]?.setInterval(callbackId, intervalMs);
+        },
+        _clearInterval: (callbackId) => {
+          bridgeRef[0]?.clearInterval(callbackId);
+        },
+        // WebSocket API
+        _wsConnect: (wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) => {
+          bridgeRef[0]?.wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen);
+        },
+        _wsSend: (wsId, dataPtr, dataLen, isBinary) => {
+          bridgeRef[0]?.wsSend(wsId, dataPtr, dataLen, isBinary);
+        },
+        _wsClose: (wsId, code, reasonPtr, reasonLen) => {
+          bridgeRef[0]?.wsClose(wsId, code, reasonPtr, reasonLen);
+        },
+        _flush: (ptr, len) => {
+          flushDomCmds(ptr, len, {
+            domNodes,
+            cleanupDomNodes
+          });
+        },
+        _getLocationHref: (bufPtr, bufLen) => {
+          const bytes = textEncoder.encode(window.location.href);
+          const len = Math.min(bytes.length, bufLen);
+          writeBytes(bufPtr, bytes.subarray(0, len));
+          return len;
+        },
+        _getFormData: (eventRef, outPtrAddr) => {
+          const event = loadValueFromRef(eventRef);
+          const el = event?.target;
+          const form = el instanceof HTMLFormElement ? el : el?.closest?.("form") ?? null;
+          if (!form) return 0;
+          const entries = [];
+          for (const [k, v] of new FormData(form).entries()) {
+            entries.push(k, String(v));
+          }
+          const bytes = textEncoder.encode(JSON.stringify(entries));
+          const [ptr, len] = bridgeRef[0].writeBytesToWasm(bytes);
+          new DataView(jsz.memory.buffer).setUint32(outPtrAddr, ptr, true);
+          return len;
+        },
+        _submitFormAction: (vnodeId, actionId) => {
+          const form = domNodes.get(Number(vnodeId));
+          if (!form || !(form instanceof HTMLFormElement)) return;
+          const formData = new FormData(form);
+          fetch(window.location.href, {
+            method: "POST",
+            // `>>> 0` reinterprets the i32 from wasm as u32 (ids can exceed 2^31).
+            headers: { "x-action": String(actionId >>> 0) },
+            body: formData
+          }).catch(() => {
+          });
+        },
+        _submitFormActionAsync: (vnodeId, actionId, statesPtr, statesLen, fetchId) => {
+          const form = domNodes.get(Number(vnodeId));
+          if (!form || !(form instanceof HTMLFormElement)) return;
+          const statesJson = statesLen > 0 ? readString(statesPtr, statesLen) : "[]";
+          bridgeRef[0]?.submitFormActionAsync(form, actionId, statesJson, fetchId);
+        },
+        _formReset: (vnodeId) => {
+          const form = domNodes.get(Number(vnodeId));
+          if (form instanceof HTMLFormElement) form.reset();
+        }
+      }
+    };
+  }
+};
+var domNodes = /* @__PURE__ */ new Map();
+var eventHandlersPresent = /* @__PURE__ */ new Map();
+var eventHandlersSuspend = /* @__PURE__ */ new Map();
+function cleanupDomNodes(node) {
+  const stack = [node];
+  let highFreqBits = 0;
+  while (stack.length > 0) {
+    const n = stack.pop();
+    const ref = n.__zx_ref;
+    if (typeof ref === "number") {
+      const present = eventHandlersPresent.get(ref);
+      if (present !== void 0) {
+        highFreqBits |= present;
+        eventHandlersPresent.delete(ref);
+        eventHandlersSuspend.delete(ref);
       }
-      case DomOp_SetProp: {
-        const el = domNodes2.get(p0);
-        if (el) {
-          const name = readString(p1, p2);
-          const val = readString(p3, p4);
-          if (name === "checked" || name === "selected" || name === "muted") {
-            el[name] = val !== "false";
-          } else {
-            el[name] = val;
-          }
+      domNodes.delete(ref);
+    }
+    const children = n.childNodes;
+    for (let i = 0; i < children.length; i++) stack.push(children[i]);
+  }
+  for (let bits = highFreqBits & HIGH_FREQ_EVENT_BITS; bits !== 0; bits &= bits - 1) {
+    maybeRemoveHighFreqListener(31 - Math.clz32(bits));
+  }
+}
+var delegationState = null;
+function makeDelegatedListener(bridge, eventTypeId) {
+  return (event) => {
+    let eventRef;
+    const pending = [];
+    let target = event.target;
+    while (target && target !== document.body) {
+      const zxRef = target.__zx_ref;
+      if (typeof zxRef === "number" && bridge.hasEventHandler(zxRef, eventTypeId)) {
+        if (eventRef === void 0) eventRef = storeValueGetRef(event);
+        const result = bridge.eventbridge(zxRef, eventTypeId, eventRef);
+        if (result && typeof result.then === "function") {
+          pending.push(result);
         }
-        break;
+        if (event.cancelBubble) break;
       }
-      case DomOp_RemoveAttr: {
-        domNodes2.get(p0)?.removeAttribute(readString(p1, p2));
-        break;
+      target = target.parentElement;
+    }
+    if (eventRef !== void 0) {
+      const ref = eventRef;
+      if (pending.length > 0) {
+        Promise.all(pending).finally(() => releaseValueRef(ref));
+      } else {
+        releaseValueRef(ref);
+      }
+    }
+  };
+}
+function ensureDelegatedListener(eventTypeId) {
+  const state = delegationState;
+  if (!state || state.attached.has(eventTypeId)) return;
+  const domType = DELEGATED_EVENTS[eventTypeId];
+  if (!domType) return;
+  const passive = domType.startsWith("touch") || domType === "scroll";
+  const options = { passive };
+  const listener = makeDelegatedListener(state.bridge, eventTypeId);
+  state.root.addEventListener(domType, listener, options);
+  state.attached.set(eventTypeId, { listener, options });
+}
+function anyHandlerForType(eventTypeId) {
+  const bit = 1 << eventTypeId;
+  for (const mask of eventHandlersPresent.values()) {
+    if (mask & bit) return true;
+  }
+  return false;
+}
+function maybeRemoveHighFreqListener(eventTypeId) {
+  if ((HIGH_FREQ_EVENT_BITS & 1 << eventTypeId) === 0) return;
+  if (anyHandlerForType(eventTypeId)) return;
+  const state = delegationState;
+  if (!state) return;
+  const entry = state.attached.get(eventTypeId);
+  if (!entry) return;
+  const domType = DELEGATED_EVENTS[eventTypeId];
+  state.root.removeEventListener(domType, entry.listener, entry.options);
+  state.attached.delete(eventTypeId);
+}
+
+// src/runtime/db/extern.ts
+function decodeBlob(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function toDbValue(value) {
+  switch (value.kind) {
+    case "null":
+      return null;
+    case "integer":
+      return value.integer;
+    case "float":
+      return value.float;
+    case "text":
+      return value.text;
+    case "blob":
+      return decodeBlob(value.blob);
+    case "boolean":
+      return value.boolean;
+  }
+}
+function toPositionalBindings(json) {
+  switch (json.kind) {
+    case "none":
+      return [];
+    case "positional":
+      return json.values.map(toDbValue);
+    case "named":
+      throw new Error("named SQL bindings are not supported yet");
+  }
+}
+function toWireValue(value) {
+  if (value === null || value === void 0) return { kind: "null" };
+  if (typeof value === "string") return { kind: "text", text: value };
+  if (typeof value === "boolean") return { kind: "boolean", boolean: value };
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? { kind: "integer", integer: value } : { kind: "float", float: value };
+  }
+  if (value instanceof ArrayBuffer) {
+    const bytes = new Uint8Array(value);
+    let binary = "";
+    for (const byte of bytes) binary += String.fromCharCode(byte);
+    return { kind: "blob", blob: btoa(binary) };
+  }
+  if (ArrayBuffer.isView(value)) {
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    let binary = "";
+    for (const byte of bytes) binary += String.fromCharCode(byte);
+    return { kind: "blob", blob: btoa(binary) };
+  }
+  return { kind: "text", text: String(value) };
+}
+function objectToWireRow(record) {
+  return {
+    fields: Object.entries(record).map(([name, value]) => ({
+      name,
+      value: toWireValue(value)
+    }))
+  };
+}
+function valuesToWireRows(rows) {
+  return rows.map((row) => row.map((value) => toWireValue(value)));
+}
+function createDbImports(bindings, getMemory, allocRef) {
+  const decoder3 = new TextDecoder();
+  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(readStr2(ns_ptr, ns_len));
+    if (!database) return null;
+    const sql = readStr2(sql_ptr, sql_len);
+    const bindingsJson = JSON.parse(readStr2(bindings_ptr, bindings_len));
+    return database.prepare(sql).bind(...toPositionalBindings(bindingsJson));
+  }
+  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,
+      db_get: (_a, _b, _c, _d, _e, _f, _g) => -1,
+      db_all: (_a, _b, _c, _d, _e, _f, _g) => -1,
+      db_values: (_a, _b, _c, _d, _e, _f, _g) => -1
+    };
+  }
+  return {
+    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();
+      return writeJsonOut(getMemory, allocRef, out_ptr, {
+        last_insert_rowid: result.meta?.last_row_id ?? 0,
+        changes: result.meta?.changes ?? 0
+      });
+    }),
+    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();
+      if (!row) {
+        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+        return 0;
       }
-      case DomOp_SetNodeValue: {
-        const node = domNodes2.get(p0);
-        if (node) node.nodeValue = readString(p1, p2);
-        break;
+      return writeJsonOut(getMemory, allocRef, out_ptr, [objectToWireRow(row)]);
+    }),
+    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();
+      const rows = (result.results ?? []).map(objectToWireRow);
+      if (rows.length === 0) {
+        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+        return 0;
       }
-      case DomOp_SetInnerHtml: {
-        const el = domNodes2.get(p0);
-        if (el) el.innerHTML = readString(p1, p2);
-        break;
+      return writeJsonOut(getMemory, allocRef, out_ptr, rows);
+    }),
+    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();
+      if (rows.length === 0) {
+        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+        return 0;
       }
-      case DomOp_AppendChild: {
-        const parent = domNodes2.get(p0);
-        const child = domNodes2.get(p1);
-        if (parent && child) parent.appendChild(child);
-        break;
+      return writeJsonOut(getMemory, allocRef, out_ptr, valuesToWireRows(rows));
+    })
+  };
+}
+
+// src/runtime/wasi.ts
+var ProcExit = class extends Error {
+  constructor(code) {
+    super(`proc_exit(${code})`);
+    this.code = code;
+  }
+};
+function createWasiImports({
+  request,
+  stdinData
+}) {
+  const encoder3 = new TextEncoder();
+  const url = new URL(request.url);
+  const argStrings = [
+    "wasm",
+    "--pathname",
+    url.pathname,
+    "--method",
+    request.method,
+    "--search",
+    url.search,
+    "--url",
+    url.href
+  ];
+  request.headers.forEach((value, name) => {
+    if (value) argStrings.push("--header", `${name}:${value}`);
+  });
+  const encodedArgs = argStrings.map((a) => encoder3.encode(a + "\0"));
+  const argBufSize = encodedArgs.reduce((s, a) => s + a.length, 0);
+  let wasmMemory = null;
+  const setMemory = (m2) => {
+    wasmMemory = m2;
+  };
+  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("\n");
+    stderrPartial = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.length > 0) {
+        console.error("[ziex]", line);
       }
-      case DomOp_InsertBefore: {
-        const parent = domNodes2.get(p0);
-        const child = domNodes2.get(p1);
-        const refNode = domNodes2.get(p2) ?? null;
-        if (parent && child) parent.insertBefore(child, refNode);
-        break;
+    }
+  }
+  let stdinOffset = 0;
+  function v() {
+    return new DataView(wasmMemory.buffer);
+  }
+  function m() {
+    return new Uint8Array(wasmMemory.buffer);
+  }
+  const wasiImport = {
+    args_sizes_get(argc_ptr, argv_buf_size_ptr) {
+      v().setUint32(argc_ptr, encodedArgs.length, true);
+      v().setUint32(argv_buf_size_ptr, argBufSize, true);
+      return 0;
+    },
+    args_get(argv_ptr, argv_buf_ptr) {
+      const dv = v();
+      const mem = m();
+      let offset = argv_buf_ptr;
+      for (const arg of encodedArgs) {
+        dv.setUint32(argv_ptr, offset, true);
+        mem.set(arg, offset);
+        argv_ptr += 4;
+        offset += arg.length;
       }
-      case DomOp_RemoveChild: {
-        const parent = domNodes2.get(p0);
-        const child = domNodes2.get(p1);
-        if (parent && child) {
-          parent.removeChild(child);
-          cleanupDomNodes2(child);
-        }
-        break;
+      return 0;
+    },
+    environ_sizes_get(count_ptr, buf_size_ptr) {
+      v().setUint32(count_ptr, 0, true);
+      v().setUint32(buf_size_ptr, 0, true);
+      return 0;
+    },
+    environ_get(_environ_ptr, _environ_buf_ptr) {
+      return 0;
+    },
+    fd_write(fd, iovs_ptr, iovs_len, nwritten_ptr) {
+      const dv = v();
+      const mem = m();
+      let written = 0;
+      for (let i = 0; i < iovs_len; i++) {
+        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 === 2) processStderrChunk(chunk);
+        written += buf_len;
       }
-      case DomOp_ReplaceChild: {
-        const parent = domNodes2.get(p0);
-        const newChild = domNodes2.get(p1);
-        const oldChild = domNodes2.get(p2);
-        if (parent && newChild && oldChild) {
-          parent.replaceChild(newChild, oldChild);
-          cleanupDomNodes2(oldChild);
+      dv.setUint32(nwritten_ptr, written, true);
+      return 0;
+    },
+    fd_read(fd, iovs_ptr, iovs_len, nread_ptr) {
+      const dv = v();
+      const mem = m();
+      const stdin = stdinData ?? new Uint8Array(0);
+      let totalRead = 0;
+      for (let i = 0; i < iovs_len; i++) {
+        const buf_ptr = dv.getUint32(iovs_ptr + i * 8, true);
+        const buf_len = dv.getUint32(iovs_ptr + i * 8 + 4, true);
+        if (fd === 0 && stdinOffset < stdin.length) {
+          const toRead = Math.min(buf_len, stdin.length - stdinOffset);
+          mem.set(stdin.subarray(stdinOffset, stdinOffset + toRead), buf_ptr);
+          stdinOffset += toRead;
+          totalRead += toRead;
         }
-        break;
       }
-      default:
-        break;
+      dv.setUint32(nread_ptr, totalRead, true);
+      return 0;
+    },
+    fd_fdstat_get(_fd, fdstat_ptr) {
+      const dv = v();
+      dv.setUint8(fdstat_ptr, 2);
+      dv.setUint8(fdstat_ptr + 1, 0);
+      dv.setUint16(fdstat_ptr + 2, 0, true);
+      dv.setUint32(fdstat_ptr + 4, 0, true);
+      dv.setBigUint64(fdstat_ptr + 8, 0n, true);
+      dv.setBigUint64(fdstat_ptr + 16, 0n, true);
+      return 0;
+    },
+    fd_prestat_get(_fd, _bufptr) {
+      return 8;
+    },
+    fd_prestat_dir_name(_fd, _path, _path_len) {
+      return 8;
+    },
+    fd_close(_fd) {
+      return 0;
+    },
+    fd_pread(_fd, _iovs, _iovs_len, _offset, nread_ptr) {
+      v().setUint32(nread_ptr, 0, true);
+      return 0;
+    },
+    fd_pwrite(_fd, _iovs, _iovs_len, _offset, nwritten_ptr) {
+      v().setUint32(nwritten_ptr, 0, true);
+      return 0;
+    },
+    fd_filestat_get(_fd, filestat_ptr) {
+      const dv = v();
+      dv.setBigUint64(filestat_ptr, 0n, true);
+      dv.setBigUint64(filestat_ptr + 8, 0n, true);
+      dv.setUint8(filestat_ptr + 16, 2);
+      dv.setBigUint64(filestat_ptr + 24, 1n, true);
+      dv.setBigUint64(filestat_ptr + 32, 0n, true);
+      dv.setBigUint64(filestat_ptr + 40, 0n, true);
+      dv.setBigUint64(filestat_ptr + 48, 0n, true);
+      dv.setBigUint64(filestat_ptr + 56, 0n, true);
+      return 0;
+    },
+    fd_filestat_set_size(_fd, _size) {
+      return 76;
+    },
+    fd_filestat_set_times(_fd, _atim, _mtim, _fst_flags) {
+      return 76;
+    },
+    fd_fdstat_set_flags(_fd, _flags) {
+      return 0;
+    },
+    fd_fdstat_set_rights(_fd, _rights_base, _rights_inheriting) {
+      return 0;
+    },
+    fd_sync(_fd) {
+      return 0;
+    },
+    fd_datasync(_fd) {
+      return 0;
+    },
+    fd_advise(_fd, _offset, _len, _advice) {
+      return 0;
+    },
+    fd_allocate(_fd, _offset, _len) {
+      return 76;
+    },
+    fd_tell(_fd, offset_ptr) {
+      v().setBigUint64(offset_ptr, 0n, true);
+      return 0;
+    },
+    fd_renumber(_from, _to) {
+      return 0;
+    },
+    path_filestat_set_times(_fd, _flags, _path, _path_len, _atim, _mtim, _fst_flags) {
+      return 76;
+    },
+    path_link(_old_fd, _old_flags, _old_path, _old_path_len, _new_fd, _new_path, _new_path_len) {
+      return 76;
+    },
+    path_symlink(_old_path, _old_path_len, _fd, _new_path, _new_path_len) {
+      return 76;
+    },
+    proc_raise(_sig) {
+      return 0;
+    },
+    sock_recv(_fd, _ri_data, _ri_data_len, _ri_flags, ro_datalen_ptr, ro_flags_ptr) {
+      v().setUint32(ro_datalen_ptr, 0, true);
+      v().setUint32(ro_flags_ptr, 0, true);
+      return 76;
+    },
+    sock_send(_fd, _si_data, _si_data_len, _si_flags, so_datalen_ptr) {
+      v().setUint32(so_datalen_ptr, 0, true);
+      return 76;
+    },
+    sock_shutdown(_fd, _how) {
+      return 76;
+    },
+    fd_seek(_fd, _offset, _whence, newoffset_ptr) {
+      v().setBigInt64(newoffset_ptr, 0n, true);
+      return 0;
+    },
+    proc_exit(code) {
+      throw new ProcExit(code);
+    },
+    sched_yield() {
+      return 0;
+    },
+    clock_time_get(_id, _precision, time_ptr) {
+      v().setBigUint64(time_ptr, BigInt(Date.now()) * 1000000n, true);
+      return 0;
+    },
+    clock_res_get(_id, res_ptr) {
+      v().setBigUint64(res_ptr, 1000000n, true);
+      return 0;
+    },
+    random_get(buf_ptr, buf_len) {
+      crypto.getRandomValues(new Uint8Array(wasmMemory.buffer, buf_ptr, buf_len));
+      return 0;
+    },
+    path_open(_fd, _dirflags, _path, _path_len, _oflags, _rights_base, _rights_inheriting, _fdflags, opened_fd_ptr) {
+      v().setInt32(opened_fd_ptr, -1, true);
+      return 76;
+    },
+    path_create_directory(_fd, _path, _path_len) {
+      return 76;
+    },
+    path_unlink_file(_fd, _path, _path_len) {
+      return 76;
+    },
+    path_remove_directory(_fd, _path, _path_len) {
+      return 76;
+    },
+    path_rename(_fd, _old_path, _old_path_len, _new_fd, _new_path, _new_path_len) {
+      return 76;
+    },
+    path_filestat_get(_fd, _flags, _path, _path_len, filestat_ptr) {
+      new Uint8Array(wasmMemory.buffer, filestat_ptr, 64).fill(0);
+      return 76;
+    },
+    path_readlink(_fd, _path, _path_len, _buf, _buf_len, nread_ptr) {
+      v().setUint32(nread_ptr, 0, true);
+      return 76;
+    },
+    fd_readdir(_fd, _buf, _buf_len, _cookie, bufused_ptr) {
+      v().setUint32(bufused_ptr, 0, true);
+      return 76;
+    },
+    poll_oneoff(_in, _out, _nsubscriptions, nevents_ptr) {
+      v().setUint32(nevents_ptr, 0, true);
+      return 0;
     }
+  };
+  return { wasiImport, setMemory };
+}
+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;
 }
 
-// src/wasm/generated/events.ts
-var DELEGATED_EVENTS = [
-  "click",
-  "dblclick",
-  "input",
-  "change",
-  "submit",
-  "focusin",
-  "focusout",
-  "keydown",
-  "keyup",
-  "keypress",
-  "mouseenter",
-  "mouseleave",
-  "mousedown",
-  "mouseup",
-  "mousemove",
-  "touchstart",
-  "touchend",
-  "touchmove",
-  "scroll",
-  "wheel",
-  "pointerdown",
-  "pointermove",
-  "pointerup",
-  "pointercancel",
-  "pointerenter",
-  "pointerleave",
-  "lostpointercapture"
-];
-
-// src/wasm/generated/event_bits.ts
-var HIGH_FREQ_EVENT_BITS = 3031040;
-
-// src/wasm/index.ts
-var ZxBridge = class extends ZxBridgeCore {
-  #websockets = /* @__PURE__ */ new Map();
-  #eventbridge;
-  #eventbridgeAsync;
+// src/wasm/wasi.ts
+var decoder2 = new TextDecoder();
+var encoder2 = new TextEncoder();
+var ZxWasiBridge = class {
+  #alloc;
+  #memory;
+  #cb;
+  #intervals = /* @__PURE__ */ new Map();
+  // Cached memory view - invalidated when the WASM buffer grows.
+  #memView = null;
+  #memBuf = null;
   constructor(exports) {
-    super(exports);
-    this.#eventbridge = exports.__zx_eventbridge;
-    this.#eventbridgeAsync = wrapPromisingExport(
-      exports.__zx_eventbridge_async ?? exports.__zx_eventbridge
-    );
-  }
-  hasEventHandler(velementId, eventTypeId) {
-    return !!((eventHandlersPresent.get(velementId) ?? 0) & 1 << eventTypeId);
-  }
-  eventMaySuspend(velementId, eventTypeId) {
-    return !!((eventHandlersSuspend.get(velementId) ?? 0) & 1 << eventTypeId);
-  }
-  setEventHandlerMode(velementId, eventTypeId, maySuspend) {
-    const bit = 1 << eventTypeId;
-    const present = (eventHandlersPresent.get(velementId) ?? 0) | bit;
-    eventHandlersPresent.set(velementId, present);
-    const suspendBits = eventHandlersSuspend.get(velementId) ?? 0;
-    const nextSuspend = maySuspend ? suspendBits | bit : suspendBits & ~bit;
-    if (nextSuspend === 0) eventHandlersSuspend.delete(velementId);
-    else eventHandlersSuspend.set(velementId, nextSuspend);
-    ensureDelegatedListener(eventTypeId);
-  }
-  clearEventHandlerModes(velementId) {
-    const present = eventHandlersPresent.get(velementId) ?? 0;
-    eventHandlersPresent.delete(velementId);
-    eventHandlersSuspend.delete(velementId);
-    for (let bits = present & HIGH_FREQ_EVENT_BITS; bits !== 0; bits &= bits - 1) {
-      maybeRemoveHighFreqListener(31 - Math.clz32(bits));
-    }
-  }
-  /** Submit a form action with bound-state round-trip. */
-  submitFormActionAsync(form, actionId, statesJson, fetchId) {
-    const formData = new FormData(form);
-    formData.append("__$states", statesJson);
-    fetch(window.location.href, {
-      method: "POST",
-      // `>>> 0` reinterprets the i32 from wasm as u32 (ids can exceed 2^31).
-      headers: { "x-action": String(actionId >>> 0) },
-      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);
-    });
+    this.#memory = exports.memory;
+    this.#alloc = exports.__zx_alloc;
+    this.#cb = exports.__zx_cb;
   }
-  /**
-   * Create and connect a WebSocket.
-   * Completes via `__zx_cb(ws_open|ws_message|ws_error|ws_close, ...)`.
-   */
-  wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) {
-    const url = readString(urlPtr, urlLen);
-    const protocolsStr = protocolsLen > 0 ? readString(protocolsPtr, protocolsLen) : "";
-    const protocols = protocolsStr ? protocolsStr.split(",").map((p) => p.trim()).filter(Boolean) : void 0;
-    try {
-      const ws = protocols && protocols.length > 0 ? new WebSocket(url, protocols) : new WebSocket(url);
-      ws.binaryType = "arraybuffer";
-      ws.onopen = () => {
-        const protocol = ws.protocol || "";
-        const [ptr, len] = this._writeStringToWasm(protocol);
-        this._invoke(CallbackType_WebSocketOpen, wsId, BigInt(ptr), BigInt(len));
-      };
-      ws.onmessage = (event) => {
-        const isBinary = event.data instanceof ArrayBuffer;
-        const data = isBinary ? new Uint8Array(event.data) : textEncoder.encode(event.data);
-        const [ptr, len] = this.writeBytesToWasm(data);
-        this._invoke(CallbackType_WebSocketMessage, wsId, BigInt(ptr), BigInt(len), BigInt(isBinary ? 1 : 0));
-      };
-      ws.onerror = (_event) => {
-        const [ptr, len] = this._writeStringToWasm("WebSocket error");
-        this._invoke(CallbackType_WebSocketError, wsId, BigInt(ptr), BigInt(len));
-      };
-      ws.onclose = (event) => {
-        const reason = event.reason || "";
-        const [ptr, len] = this._writeStringToWasm(reason);
-        const c = BigInt(len) | BigInt(event.wasClean ? 1 : 0) << 32n;
-        this._invoke(CallbackType_WebSocketClose, wsId, BigInt(event.code), BigInt(ptr), c);
-        this.#websockets.delete(wsId);
-      };
-      this.#websockets.set(wsId, ws);
-    } catch (error) {
-      const msg = error instanceof Error ? error.message : "WebSocket connection failed";
-      const [ptr, len] = this._writeStringToWasm(msg);
-      this._invoke(CallbackType_WebSocketError, wsId, BigInt(ptr), BigInt(len));
+  #view() {
+    const buf = this.#memory.buffer;
+    if (buf !== this.#memBuf) {
+      this.#memBuf = buf;
+      this.#memView = new Uint8Array(buf);
     }
+    return this.#memView;
   }
-  /** Send data over WebSocket */
-  wsSend(wsId, dataPtr, dataLen, isBinary) {
-    const ws = this.#websockets.get(wsId);
-    if (!ws || ws.readyState !== WebSocket.OPEN) return;
-    const memory = getMemoryView();
-    const start = dataPtr >>> 0;
-    const length = dataLen >>> 0;
-    if (start + length > memory.byteLength) return;
-    if (isBinary) {
-      ws.send(memory.slice(start, start + length));
-    } else {
-      ws.send(textDecoder.decode(memory.subarray(start, start + length)));
+  #readString(ptr, len) {
+    const start = ptr >>> 0;
+    const length = len >>> 0;
+    if (length === 0) return "";
+    const view = this.#view();
+    if (start + length > view.byteLength) return "";
+    return decoder2.decode(view.subarray(start, start + length));
+  }
+  #writeBytes(ptr, data) {
+    const start = ptr >>> 0;
+    const view = this.#view();
+    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 = 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;
     }
   }
-  /** Close WebSocket connection */
-  wsClose(wsId, code, reasonPtr, reasonLen) {
-    const ws = this.#websockets.get(wsId);
-    if (!ws) return;
-    const reason = reasonLen > 0 ? readString(reasonPtr, reasonLen) : void 0;
+  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.#view().subarray(bodyPtr, bodyPtr + bodyLen) : void 0;
+    let headers = {};
     try {
-      if (reason) ws.close(code, reason);
-      else ws.close(code);
+      headers = JSON.parse(headersJson);
     } catch {
-      ws.close();
+      for (const line of headersJson.split("\n")) {
+        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 : void 0,
+      body: method !== "GET" && method !== "HEAD" ? body : void 0,
+      signal: controller.signal
+    }).then(async (res) => {
+      if (timeout) clearTimeout(timeout);
+      const bytes = new Uint8Array(await res.arrayBuffer());
+      this.#notifyFetchComplete(fetchId, res.status, bytes, false);
+    }).catch((err) => {
+      if (timeout) clearTimeout(timeout);
+      const msg = err.name === "AbortError" ? "Request timeout" : err.message ?? "Fetch failed";
+      this.#notifyFetchComplete(fetchId, 0, msg, true);
+    });
   }
-  dispose() {
-    super.dispose();
-    eventHandlersPresent.clear();
-    eventHandlersSuspend.clear();
-    for (const ws of this.#websockets.values()) {
-      try {
-        ws.close();
-      } catch {
-      }
+  #notifyFetchComplete(fetchId, status, body, isError) {
+    const encoded = typeof body === "string" ? encoder2.encode(body) : body;
+    const ptr = this.#alloc(encoded.length);
+    this.#writeBytes(ptr, encoded);
+    const type = isError ? CallbackType_FetchError : CallbackType_FetchSuccess;
+    this.#invoke(type, fetchId, BigInt(status), BigInt(ptr), BigInt(encoded.length));
+  }
+  setTimeout(callbackId, delayMs) {
+    setTimeout(() => this.#invoke(CallbackType_Timeout, callbackId), delayMs);
+  }
+  setInterval(callbackId, intervalMs) {
+    const handle = setInterval(() => this.#invoke(CallbackType_Interval, callbackId), intervalMs);
+    this.#intervals.set(callbackId, handle);
+  }
+  clearInterval(callbackId) {
+    const handle = this.#intervals.get(callbackId);
+    if (handle !== void 0) {
+      clearInterval(handle);
+      this.#intervals.delete(callbackId);
     }
-    this.#websockets.clear();
   }
   /**
-   * Dispatch to WASM for one vnode. Caller owns `eventRef` lifetime
-   * (store once per bubble, release after sync/async work completes).
+   * Create the WASI import object for WASM instantiation.
+   *
+   * Returns only the `__zx` namespace (log, fetch, timers).
+   * Does NOT include jsz.importObject() - the server binary does not use jsz.
    */
-  eventbridge(velementId, eventTypeId, eventRef) {
-    const id = BigInt(velementId >>> 0);
-    if (this.eventMaySuspend(velementId, eventTypeId)) {
-      return invokeWasmExport(this.#eventbridgeAsync, id, eventTypeId, eventRef);
-    }
-    invokeWasmExport(this.#eventbridge, id, eventTypeId, eventRef);
-  }
-  /** Create the full browser import object for WASM instantiation (includes DOM + WebSocket). */
   static createImportObject(bridgeRef) {
     return {
-      ...jsz.importObject(),
-      __zx_net: createFetchImports(() => {
-        if (!jsz.memory) throw new Error("WASM memory is not ready");
-        return jsz.memory;
-      }),
       __zx: {
-        _log: (level, ptr, len) => ZxBridgeCore.log(level, ptr, len),
-        _setEventHandlerMode: (vnodeId, eventTypeId, maySuspend) => {
-          bridgeRef[0]?.setEventHandlerMode(Number(vnodeId), eventTypeId, maySuspend !== 0);
-        },
-        _clearEventHandlerModes: (vnodeId) => {
-          bridgeRef[0]?.clearEventHandlerModes(Number(vnodeId));
+        _log: (level, ptr, len) => {
+          bridgeRef[0]?.log(level, ptr, len);
         },
         _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
           bridgeRef[0]?.fetchAsync(
@@ -2294,188 +2111,330 @@ var ZxBridge = class extends ZxBridgeCore {
         },
         _clearInterval: (callbackId) => {
           bridgeRef[0]?.clearInterval(callbackId);
-        },
-        // WebSocket API
-        _wsConnect: (wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) => {
-          bridgeRef[0]?.wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen);
-        },
-        _wsSend: (wsId, dataPtr, dataLen, isBinary) => {
-          bridgeRef[0]?.wsSend(wsId, dataPtr, dataLen, isBinary);
-        },
-        _wsClose: (wsId, code, reasonPtr, reasonLen) => {
-          bridgeRef[0]?.wsClose(wsId, code, reasonPtr, reasonLen);
-        },
-        _flush: (ptr, len) => {
-          flushDomCmds(ptr, len, {
-            domNodes,
-            cleanupDomNodes
-          });
-        },
-        _getLocationHref: (bufPtr, bufLen) => {
-          const bytes = textEncoder.encode(window.location.href);
-          const len = Math.min(bytes.length, bufLen);
-          writeBytes(bufPtr, bytes.subarray(0, len));
-          return len;
-        },
-        _getFormData: (eventRef, outPtrAddr) => {
-          const event = loadValueFromRef(eventRef);
-          const el = event?.target;
-          const form = el instanceof HTMLFormElement ? el : el?.closest?.("form") ?? null;
-          if (!form) return 0;
-          const entries = [];
-          for (const [k, v] of new FormData(form).entries()) {
-            entries.push(k, String(v));
-          }
-          const bytes = textEncoder.encode(JSON.stringify(entries));
-          const [ptr, len] = bridgeRef[0].writeBytesToWasm(bytes);
-          new DataView(jsz.memory.buffer).setUint32(outPtrAddr, ptr, true);
-          return len;
-        },
-        _submitFormAction: (vnodeId, actionId) => {
-          const form = domNodes.get(Number(vnodeId));
-          if (!form || !(form instanceof HTMLFormElement)) return;
-          const formData = new FormData(form);
-          fetch(window.location.href, {
-            method: "POST",
-            // `>>> 0` reinterprets the i32 from wasm as u32 (ids can exceed 2^31).
-            headers: { "x-action": String(actionId >>> 0) },
-            body: formData
-          }).catch(() => {
-          });
-        },
-        _submitFormActionAsync: (vnodeId, actionId, statesPtr, statesLen, fetchId) => {
-          const form = domNodes.get(Number(vnodeId));
-          if (!form || !(form instanceof HTMLFormElement)) return;
-          const statesJson = statesLen > 0 ? readString(statesPtr, statesLen) : "[]";
-          bridgeRef[0]?.submitFormActionAsync(form, actionId, statesJson, fetchId);
         }
       }
     };
   }
 };
-var domNodes = /* @__PURE__ */ new Map();
-var eventHandlersPresent = /* @__PURE__ */ new Map();
-var eventHandlersSuspend = /* @__PURE__ */ new Map();
-function cleanupDomNodes(node) {
-  const stack = [node];
-  let highFreqBits = 0;
-  while (stack.length > 0) {
-    const n = stack.pop();
-    const ref = n.__zx_ref;
-    if (typeof ref === "number") {
-      const present = eventHandlersPresent.get(ref);
-      if (present !== void 0) {
-        highFreqBits |= present;
-        eventHandlersPresent.delete(ref);
-        eventHandlersSuspend.delete(ref);
+
+// src/runtime/index.ts
+function buildHttpImports(mem, http) {
+  const decoder3 = new TextDecoder();
+  return {
+    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 {
+        }
       }
-      domNodes.delete(ref);
+    },
+    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);
+    },
+    end: () => {
+      http.ended = true;
+      if (http.streamWriter) {
+        void http.streamWriter.close();
+        http.streamWriter = null;
+      }
+    }
+  };
+}
+function buildWsImports(Suspending2, mem, decoder3, ws) {
+  const readStr2 = (ptr, len) => decoder3.decode(new Uint8Array(mem().buffer, ptr, len));
+  return {
+    ws_upgrade: () => {
+      ws.upgraded = true;
+    },
+    ws_write: (ptr, len) => {
+      const data = new Uint8Array(mem().buffer, ptr, len).slice();
+      if (!ws.server) {
+        ws.pendingWrites.push(data);
+      } else {
+        ws.server.send(data);
+      }
+    },
+    ws_close: (code, reason_ptr, reason_len) => {
+      ws.server?.close(code, decoder3.decode(new Uint8Array(mem().buffer, reason_ptr, reason_len)));
+    },
+    ws_recv: Suspending2 ? new Suspending2(async (buf_ptr, buf_max) => {
+      if (ws._resolveFirstSuspend) {
+        const fn = ws._resolveFirstSuspend;
+        ws._resolveFirstSuspend = void 0;
+        fn();
+      }
+      const deliver = (bytes) => {
+        if (bytes === null) return -1;
+        const n = Math.min(bytes.length, buf_max);
+        new Uint8Array(mem().buffer, buf_ptr, n).set(bytes.subarray(0, n));
+        return n;
+      };
+      if (ws.messageQueue.length > 0) return deliver(ws.messageQueue.shift());
+      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?.(readStr2(ptr, len));
+    },
+    ws_unsubscribe: (ptr, len) => {
+      ws.unsubscribe?.(readStr2(ptr, len));
+    },
+    ws_publish: (topic_ptr, topic_len, data_ptr, data_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?.(readStr2(ptr, len)) ? 1 : 0
+  };
+}
+function attachWebSocket(ws) {
+  const WebSocketPairCtor = globalThis.WebSocketPair;
+  const pair = new WebSocketPairCtor();
+  const client = pair[0];
+  const server = pair[1];
+  ws.server = server;
+  server.accept();
+  for (const data of ws.pendingWrites) server.send(data);
+  ws.pendingWrites = [];
+  server.addEventListener("message", (event) => {
+    const data = typeof event.data === "string" ? new TextEncoder().encode(event.data) : new Uint8Array(event.data);
+    if (ws.recvResolve) {
+      const res = ws.recvResolve;
+      ws.recvResolve = null;
+      res(data);
+    } else {
+      ws.messageQueue.push(data);
+    }
+  });
+  server.addEventListener("close", () => {
+    if (ws.recvResolve) {
+      const res = ws.recvResolve;
+      ws.recvResolve = null;
+      res(null);
     }
-    const children = n.childNodes;
-    for (let i = 0; i < children.length; i++) stack.push(children[i]);
-  }
-  for (let bits = highFreqBits & HIGH_FREQ_EVENT_BITS; bits !== 0; bits &= bits - 1) {
-    maybeRemoveHighFreqListener(31 - Math.clz32(bits));
-  }
+  });
+  return { client };
 }
-var delegationState = null;
-function makeDelegatedListener(bridge, eventTypeId) {
-  return (event) => {
-    let eventRef;
-    const pending = [];
-    let target = event.target;
-    while (target && target !== document.body) {
-      const zxRef = target.__zx_ref;
-      if (typeof zxRef === "number" && bridge.hasEventHandler(zxRef, eventTypeId)) {
-        if (eventRef === void 0) eventRef = storeValueGetRef(event);
-        const result = bridge.eventbridge(zxRef, eventTypeId, eventRef);
-        if (result && typeof result.then === "function") {
-          pending.push(result);
-        }
-        if (event.cancelBubble) break;
-      }
-      target = target.parentElement;
-    }
-    if (eventRef !== void 0) {
-      const ref = eventRef;
-      if (pending.length > 0) {
-        Promise.all(pending).finally(() => releaseValueRef(ref));
-      } else {
-        releaseValueRef(ref);
-      }
+function buildSysImports(jspi2, Suspending2) {
+  return {
+    sleep_ms: jspi2 ? new Suspending2(async (ms) => new Promise((r) => setTimeout(r, ms))) : (_ms) => {
     }
   };
 }
-function ensureDelegatedListener(eventTypeId) {
-  const state = delegationState;
-  if (!state || state.attached.has(eventTypeId)) return;
-  const domType = DELEGATED_EVENTS[eventTypeId];
-  if (!domType) return;
-  const passive = domType.startsWith("touch") || domType === "scroll";
-  const options = { passive };
-  const listener = makeDelegatedListener(state.bridge, eventTypeId);
-  state.root.addEventListener(domType, listener, options);
-  state.attached.set(eventTypeId, { listener, options });
-}
-function anyHandlerForType(eventTypeId) {
-  const bit = 1 << eventTypeId;
-  for (const mask of eventHandlersPresent.values()) {
-    if (mask & bit) return true;
+function executeWasm(instance, jspi2, Suspending2, wsState) {
+  if (!jspi2) {
+    try {
+      instance.exports._start();
+    } catch (e) {
+      if (!(e instanceof ProcExit)) throw e;
+    }
+    return Promise.resolve();
   }
-  return false;
+  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 maybeRemoveHighFreqListener(eventTypeId) {
-  if ((HIGH_FREQ_EVENT_BITS & 1 << eventTypeId) === 0) return;
-  if (anyHandlerForType(eventTypeId)) return;
-  const state = delegationState;
-  if (!state) return;
-  const entry = state.attached.get(eventTypeId);
-  if (!entry) return;
-  const domType = DELEGATED_EVENTS[eventTypeId];
-  state.root.removeEventListener(domType, entry.listener, entry.options);
-  state.attached.delete(eventTypeId);
+async function run({
+  request,
+  env,
+  ctx,
+  module,
+  kv: kvBindings,
+  db: dbBindings,
+  imports,
+  wasi,
+  sticky
+}) {
+  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 httpState = {
+    committed: false,
+    ended: false,
+    status: 200,
+    streaming: false,
+    headers: new Headers(),
+    bodyChunks: [],
+    streamWriter: null
+  };
+  const { wasiImport, setMemory } = createWasiImports({
+    request,
+    stdinData
+  });
+  let wasmMemory = null;
+  const mem = () => wasmMemory;
+  const bridgeRef = [null];
+  const allocRef = [null];
+  const Suspending2 = WebAssembly.Suspending;
+  const jspi2 = typeof Suspending2 === "function";
+  const wsState = {
+    upgraded: false,
+    server: null,
+    pendingWrites: [],
+    messageQueue: [],
+    recvResolve: null
+  };
+  const importObject = {
+    wasi_snapshot_preview1: { ...wasi?.wasiImport, ...wasiImport },
+    __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: { get: get4, put: put4, del: del4, list: list4 } },
+      mem,
+      allocRef
+    );
+  }
+  if (true) {
+    importObject.__zx_db = createDbImports(
+      dbBindings ?? {},
+      mem,
+      allocRef
+    );
+  }
+  const instance = new WebAssembly.Instance(module, importObject);
+  wasmMemory = instance.exports.memory;
+  setMemory(wasmMemory);
+  bridgeRef[0] = new ZxWasiBridge(instance.exports);
+  bindWasmAlloc(allocRef, instance.exports);
+  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 });
+  }
+  if (httpState.committed && httpState.streaming) {
+    const { readable, writable } = new TransformStream();
+    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 status = httpState.status;
+  const headers = httpState.headers;
+  headers.delete("transfer-encoding");
+  const nullBody = status === 101 || status === 204 || status === 205 || status === 304;
+  if (nullBody) {
+    headers.delete("content-length");
+    return new Response(null, { status, 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/platforms/cloudflare/do.ts
-function createWebSocketDO(module, options) {
-  return class ZxWebSocketDO {
+// src/platforms/cloudflare/stateful.ts
+var textDecoder2 = new TextDecoder();
+function deliverToWasm(conn, data) {
+  if (conn.recvResolve) {
+    const res = conn.recvResolve;
+    conn.recvResolve = null;
+    res(data);
+    return;
+  }
+  if (data) conn.messageQueue.push(data);
+}
+function attachWebSocketPair(ws) {
+  const WebSocketPairCtor = globalThis.WebSocketPair;
+  const pair = new WebSocketPairCtor();
+  const [client, server] = Object.values(pair);
+  ws.server = server;
+  server.accept();
+  const pending = ws.pendingWrites;
+  ws.pendingWrites = [];
+  queueMicrotask(() => {
+    for (const data of pending) {
+      try {
+        server.send(textDecoder2.decode(data));
+      } catch {
+      }
+    }
+  });
+  server.addEventListener("message", (event) => {
+    const data = typeof event.data === "string" ? new TextEncoder().encode(event.data) : new Uint8Array(event.data);
+    deliverToWasm(ws, data);
+  });
+  server.addEventListener("close", () => {
+    deliverToWasm(ws, null);
+  });
+  return client;
+}
+function createStatefulFetch(module, options) {
+  return class StatefulFetch {
     constructor(state, env) {
-      /** All active connections in this room, keyed by their server-side WebSocket. */
       this.connections = /* @__PURE__ */ new Map();
-      this.doState = state;
+      this.state = state;
       this.env = env;
     }
     async fetch(request) {
-      const stdinData = request.body ? new Uint8Array(await request.arrayBuffer()) : void 0;
+      const isUpgrade = request.headers.get("upgrade")?.toLowerCase() === "websocket";
+      const stdinData = !isUpgrade && request.body ? new Uint8Array(await request.arrayBuffer()) : void 0;
       const { wasiImport, setMemory } = createWasiImports({ request, stdinData });
       let wasmMemory = null;
       const mem = () => wasmMemory;
       const bridgeRef = [null];
       const bridgeImports = ZxBridge.createImportObject(bridgeRef);
-      const Suspending = WebAssembly.Suspending;
-      const jspi = typeof Suspending === "function";
+      const Suspending2 = WebAssembly.Suspending;
+      const jspi2 = typeof Suspending2 === "function";
+      if (!jspi2) {
+        return new Response("Sticky WebSocket fetch requires WebAssembly JSPI", { status: 501 });
+      }
       const decoder3 = new TextDecoder();
-      let _resolveFirstSuspend;
-      const firstSuspendPromise = new Promise((resolve) => {
-        _resolveFirstSuspend = resolve;
-      });
-      let wasmExited = false;
       const connState = {
         upgraded: false,
         server: null,
         pendingWrites: [],
         messageQueue: [],
         recvResolve: null,
-        _resolveFirstSuspend,
         topics: /* @__PURE__ */ new Set(),
         subscribe: (topic) => connState.topics.add(topic),
         unsubscribe: (topic) => connState.topics.delete(topic),
         publish: (topic, data) => {
           let count = 0;
-          for (const [ws, conn] of this.connections) {
+          const text = textDecoder2.decode(data);
+          for (const [sock, conn] of this.connections) {
             if (conn.topics.has(topic)) {
               try {
-                ws.send(data);
+                sock.send(text);
                 count++;
               } catch {
               }
@@ -2490,10 +2449,20 @@ function createWebSocketDO(module, options) {
         isSubscribed: (topic) => connState.topics.has(topic)
       };
       const sysImports = {
-        sleep_ms: jspi ? new Suspending(async (ms) => new Promise((r) => setTimeout(r, ms))) : (_ms) => {
-        }
+        sleep_ms: new Suspending2(
+          async (ms) => new Promise((r) => setTimeout(r, ms))
+        )
+      };
+      const wsImports = buildWsImports(Suspending2, mem, decoder3, connState);
+      const httpState = {
+        committed: false,
+        ended: false,
+        status: 200,
+        streaming: false,
+        headers: new Headers(),
+        bodyChunks: [],
+        streamWriter: null
       };
-      const wsImports = buildWsImports(jspi ? Suspending : null, mem, decoder3, connState);
       const kvBindings = options?.kv?.(this.env);
       const dbBindings = options?.db?.(this.env);
       const allocRef = [null];
@@ -2501,23 +2470,20 @@ function createWebSocketDO(module, options) {
         wasi_snapshot_preview1: wasiImport,
         __zx_sys: sysImports,
         __zx_ws: wsImports,
+        __zx_http: buildHttpImports(mem, httpState),
         __zx_net: createFetchImports(mem),
         ...options?.imports ? options.imports(mem) : {},
         ...bridgeImports
       };
       if (true) {
         importObject.__zx_kv = createKVImports(
-          kvBindings ?? { default: createMemoryKV() },
+          kvBindings ?? { default: { get: get4, put: put4, del: del4, list: list4 } },
           mem,
           allocRef
         );
       }
       if (true) {
-        importObject.__zx_db = createDbImports(
-          dbBindings ?? {},
-          mem,
-          allocRef
-        );
+        importObject.__zx_db = createDbImports(dbBindings ?? {}, mem, allocRef);
       }
       const instance = new WebAssembly.Instance(module, importObject);
       wasmMemory = instance.exports.memory;
@@ -2526,31 +2492,142 @@ function createWebSocketDO(module, options) {
       bindWasmAlloc(allocRef, instance.exports);
       const start = WebAssembly.promising(instance.exports._start);
       const wasmPromise = start().catch((e) => {
-        wasmExited = true;
         if (e instanceof Error && e.message.startsWith("proc_exit")) return;
-        console.error("[ZxWebSocketDO] WASM error:", e);
+        console.error("[StatefulFetch] WASM error:", e);
       }).finally(() => {
         if (connState.server) this.connections.delete(connState.server);
-        if (connState.recvResolve) {
-          const res = connState.recvResolve;
-          connState.recvResolve = null;
-          res(null);
-        }
+        deliverToWasm(connState, null);
       });
-      await Promise.race([firstSuspendPromise, wasmPromise]);
-      if (!connState.upgraded || wasmExited) {
+      if (!connState.upgraded) {
+        await wasmPromise;
         return new Response("WebSocket upgrade expected", { status: 426 });
       }
-      const { client } = attachWebSocket(connState);
+      const client = attachWebSocketPair(connState);
       this.connections.set(connState.server, connState);
-      this.doState.waitUntil(wasmPromise);
+      this.state.waitUntil(wasmPromise);
       return new Response(null, { status: 101, webSocket: client });
     }
   };
 }
+
+// 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;
+}
+var Ziex = class {
+  constructor(options) {
+    this.resolved = null;
+    /**
+     * Fetch handler called by the runtime on every request.
+     *
+     * Arrow function so `this` is always the class instance, even when the
+     * runtime extracts `fetch` from the exported object (e.g. Bun).
+     */
+    this.fetch = async (request, env, ctx) => {
+      const module = await this.getModule();
+      const { wasi, imports, sticky } = this.options;
+      return run({
+        request,
+        env,
+        ctx,
+        module,
+        wasi,
+        imports,
+        kv: this.resolveKV(env),
+        db: this.resolveDB(env),
+        sticky: sticky !== void 0 ? env[sticky] : void 0
+      });
+    };
+    this.options = options;
+  }
+  async getModule() {
+    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;
+    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] };
+  }
+  resolveDB(env) {
+    const { db } = this.options;
+    if (db === void 0) return void 0;
+    if (typeof db === "object" && db !== null) {
+      const result = {};
+      for (const [name, key] of Object.entries(db)) {
+        result[name] = env[key];
+      }
+      return result;
+    }
+    return { default: env[db] };
+  }
+};
+
+// src/platforms/cloudflare/app.ts
+function stateful(app, options) {
+  const host = app.stickyHost(options.binding);
+  return createStatefulFetch(host.module, {
+    kv: (env) => host.kv(env) ?? { default: { get: get4, put: put4, del: del4, list: list4 } },
+    db: (env) => host.db(env) ?? {},
+    imports: host.imports
+  });
+}
 export {
   Ziex,
-  createWebSocketDO,
-  kv_exports as kv,
-  runtime_exports as worker
+  createBrowserKVBindings,
+  createKVImports,
+  del4 as del,
+  get4 as get,
+  hasJspi,
+  list4 as list,
+  put4 as put,
+  resolveModule,
+  stateful
 };