ziex 0.1.0-dev.1360 → 0.1.0-dev.1377

package/cloudflare/index.js

@@ -1,221 +1,311 @@
 var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
 var __export = (target, all) => {
   for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../vendor/jsz/js/src/zigjs.ts
-var NAN_PREFIX = 2146959360;
-var predefined = {
-  nan: 0,
-  null: 1,
-  true: 2,
-  false: 3,
-  undefined: 4,
-  globalThis: 5,
-  runtime: 6
-};
-var PREDEFINED_ID_MAX = 6;
-var encoder = new TextEncoder;
-var decoder = new TextDecoder("utf-8");
+// src/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  attachWebSocket: () => attachWebSocket,
+  buildWsImports: () => buildWsImports,
+  run: () => run
+});
 
-class ZigJS {
-  memory;
-  values = [NaN, null, true, false, undefined, globalThis, this];
-  idPool = [];
-  importObject() {
-    return {
-      "zig-js": {
-        valueGet: this.valueGet.bind(this),
-        valueSet: this.valueSet.bind(this),
-        valueDeinit: this.valueDeinit.bind(this),
-        valueObjectCreate: this.valueObjectCreate.bind(this),
-        valueStringCreate: this.valueStringCreate.bind(this),
-        valueStringLen: this.valueStringLen.bind(this),
-        valueStringCopy: this.valueStringCopy.bind(this),
-        valueNew: this.valueNew.bind(this),
-        funcApply: this.funcApply.bind(this)
-      }
-    };
-  }
-  valueGet(out, id, ptr, len) {
-    const val = this.loadValue(id);
-    const str = this.loadString(ptr, len);
-    const result = Reflect.get(val, str);
-    this.storeValue(out, result);
-  }
-  valueSet(id, ptr, len, refAddr) {
-    const obj = this.loadValue(id);
-    const str = this.loadString(ptr, len);
-    const val = this.loadRef(refAddr);
-    Reflect.set(obj, str, val);
+// src/wasm/wasi.ts
+var decoder = new TextDecoder();
+var encoder = new TextEncoder();
+var ZxWasiBridge = class {
+  #alloc;
+  #fetchCompleteHandler;
+  #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.#fetchCompleteHandler = exports.__zx_fetch_complete;
+    this.#cb = exports.__zx_cb;
   }
-  valueDeinit(id) {
-    if (id > PREDEFINED_ID_MAX) {
-      this.values[id] = null;
-      this.idPool.push(id);
+  #view() {
+    const buf = this.#memory.buffer;
+    if (buf !== this.#memBuf) {
+      this.#memBuf = buf;
+      this.#memView = new Uint8Array(buf);
     }
+    return this.#memView;
   }
-  valueObjectCreate(out) {
-    this.storeValue(out, new Object);
-  }
-  valueStringCreate(out, ptr, len) {
-    const str = this.loadString(ptr, len);
-    this.storeValue(out, str);
-  }
-  valueStringLen(id) {
-    const val = this.loadValue(id);
-    const buf = encoder.encode(val);
-    return buf.byteLength;
+  #readString(ptr, len) {
+    return decoder.decode(this.#view().subarray(ptr, ptr + len));
   }
-  valueStringCopy(id, ptr, max) {
-    if (this.memory == null)
-      return;
-    const val = this.loadValue(id);
-    const bytes = encoder.encode(val);
-    if (bytes.byteLength > max)
-      return;
-    if (bytes.length === 0)
-      return;
-    new Uint8Array(this.memory.buffer, ptr, bytes.length).set(bytes);
+  #writeBytes(ptr, data) {
+    this.#view().set(data, ptr);
   }
-  valueNew(out, id, argsAddr, argsLen) {
-    const fn = this.loadValue(id);
-    const args = [];
-    for (let i = 0;i < argsLen; i++) {
-      args.push(this.loadRef(argsAddr + i * 8));
+  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;
     }
-    const result = Reflect.construct(fn, args);
-    this.storeValue(out, result);
   }
-  funcApply(out, id, thisRefAddr, argsAddr, argsLen) {
-    const fn = this.loadValue(id);
-    const thisVal = this.loadRef(thisRefAddr);
-    const args = [];
-    for (let i = 0;i < argsLen; i++) {
-      args.push(this.loadRef(argsAddr + i * 8));
+  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 result = Reflect.apply(fn, thisVal, args);
-    this.storeValue(out, result);
+    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);
+    });
   }
-  loadValue(id) {
-    return this.values[id];
+  #notifyFetchComplete(fetchId, status, body, isError) {
+    const encoded = typeof body === "string" ? encoder.encode(body) : body;
+    const ptr = this.#alloc(encoded.length);
+    this.#writeBytes(ptr, encoded);
+    this.#fetchCompleteHandler(fetchId, status, ptr, encoded.length, isError ? 1 : 0);
   }
-  deleteValue(id) {
-    const val = this.values[id];
-    this.valueDeinit(id);
-    return val;
+  setTimeout(callbackId, delayMs) {
+    setTimeout(() => this.#cb?.(3, callbackId, 0n), delayMs);
   }
-  loadRef(refAddr) {
-    if (this.memory == null)
-      return;
-    const view = new DataView(this.memory.buffer);
-    const floatVal = view.getFloat64(refAddr, true);
-    if (!isNaN(floatVal))
-      return floatVal;
-    const id = this.loadRefId(refAddr);
-    return this.values[id];
+  setInterval(callbackId, intervalMs) {
+    const handle = setInterval(() => this.#cb?.(4, callbackId, 0n), intervalMs);
+    this.#intervals.set(callbackId, handle);
   }
-  loadRefId(refAddr) {
-    if (this.memory == null)
-      return 0;
-    return new DataView(this.memory.buffer).getUint32(refAddr, true);
+  clearInterval(callbackId) {
+    const handle = this.#intervals.get(callbackId);
+    if (handle !== void 0) {
+      clearInterval(handle);
+      this.#intervals.delete(callbackId);
+    }
   }
-  storeValue(out, val) {
-    if (this.memory == null)
-      return;
-    const view = new DataView(this.memory.buffer);
-    if (typeof val === "number") {
-      if (isNaN(val)) {
-        view.setUint32(out, predefined.nan, true);
-        view.setUint32(out + 4, NAN_PREFIX, true);
-      } else {
-        view.setFloat64(out, val, true);
+  /**
+   * 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.current?.log(level, ptr, len);
+        },
+        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
+          bridgeRef.current?.fetchAsync(
+            urlPtr,
+            urlLen,
+            methodPtr,
+            methodLen,
+            headersPtr,
+            headersLen,
+            bodyPtr,
+            bodyLen,
+            timeoutMs,
+            fetchId
+          );
+        },
+        _setTimeout: (callbackId, delayMs) => {
+          bridgeRef.current?.setTimeout(callbackId, delayMs);
+        },
+        _setInterval: (callbackId, intervalMs) => {
+          bridgeRef.current?.setInterval(callbackId, intervalMs);
+        },
+        _clearInterval: (callbackId) => {
+          bridgeRef.current?.clearInterval(callbackId);
+        }
       }
-      return;
-    }
-    if (val === null) {
-      view.setUint32(out, predefined.null, true);
-      view.setUint32(out + 4, NAN_PREFIX, true);
-      return;
-    }
-    if (val === undefined) {
-      view.setUint32(out, predefined.undefined, true);
-      view.setUint32(out + 4, NAN_PREFIX, true);
-      return;
-    }
-    if (typeof val === "boolean") {
-      view.setUint32(out, val ? predefined.true : predefined.false, true);
-      view.setUint32(out + 4, NAN_PREFIX, true);
-      return;
-    }
-    if (typeof val === "bigint") {
-      view.setFloat64(out, Number(val), true);
-      return;
-    }
-    let id = this.idPool.pop();
-    if (id === undefined) {
-      id = this.values.length;
+    };
+  }
+};
+
+// src/kv.ts
+var kv_exports = {};
+__export(kv_exports, {
+  createKVImports: () => createKVImports,
+  createMemoryKV: () => createMemoryKV
+});
+function putOptions(ttlSeconds) {
+  if (ttlSeconds < 60) return void 0;
+  return { expirationTtl: ttlSeconds };
+}
+function createMemoryKV() {
+  const store = /* @__PURE__ */ new Map();
+  function read(key) {
+    const entry = store.get(key);
+    if (!entry) return null;
+    if (entry.expiresAt !== void 0 && Date.now() >= entry.expiresAt) {
+      store.delete(key);
+      return null;
     }
-    this.values[id] = val;
-    let typeId = 0;
-    switch (typeof val) {
-      case "object":
-        typeId = 1;
-        break;
-      case "string":
-        typeId = 2;
-        break;
-      case "symbol":
-        typeId = 3;
-        break;
-      case "function":
-        typeId = 4;
-        break;
+    return entry.value;
+  }
+  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;
     }
-    view.setUint32(out, Number(id), true);
-    view.setUint32(out + 4, NAN_PREFIX | typeId, true);
-  }
-  loadString(ptr, len) {
-    if (this.memory == null)
-      return "";
-    const arr = new Uint8ClampedArray(this.memory.buffer, ptr, Number(len));
-    const data = arr.slice();
-    return decoder.decode(data);
+    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/fetch.ts
-function createFetchImports(getMemory) {
-  const encoder2 = new TextEncoder;
-  const decoder2 = new TextDecoder;
+function isSyncKVNamespace(binding) {
+  const candidate = binding;
+  return typeof candidate.getSync === "function" && typeof candidate.putSync === "function" && typeof candidate.deleteSync === "function" && typeof candidate.listSync === "function";
+}
+function createKVImports(bindings, getMemory) {
+  const encoder3 = new TextEncoder();
+  const decoder3 = new TextDecoder();
   function readStr(ptr, len) {
-    return decoder2.decode(new Uint8Array(getMemory().buffer, ptr, len));
+    return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
   }
-  function writeBytes(buf_ptr, buf_max, data) {
-    if (data.length > buf_max)
-      return -2;
+  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 binding(ns) {
+    return bindings[ns] ?? bindings["default"] ?? null;
+  }
+  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, buf_ptr, buf_max) => {
+        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 writeBytes2(buf_ptr, buf_max, 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, buf_ptr, buf_max) => {
+        const b = syncBinding2(readStr(ns_ptr, ns_len));
+        if (!b) return writeBytes2(buf_ptr, buf_max, encoder3.encode("[]"));
+        const prefix = readStr(pfx_ptr, pfx_len);
+        const result = b.listSync(prefix.length > 0 ? { prefix } : void 0);
+        return writeBytes2(buf_ptr, buf_max, encoder3.encode(JSON.stringify(result.keys.map((k) => k.name))));
+      }
+    };
+  }
+  return {
+    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, buf_ptr, buf_max) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b) return -1;
+      const value = await b.get(readStr(key_ptr, key_len));
+      if (value === null) return -1;
+      return writeBytes2(buf_ptr, buf_max, encoder3.encode(value));
+    }),
+    kv_put: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, 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_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_list: new Suspending(async (ns_ptr, ns_len, prefix_ptr, prefix_len, buf_ptr, buf_max) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b) return writeBytes2(buf_ptr, buf_max, encoder3.encode("[]"));
+      const prefix = readStr(prefix_ptr, prefix_len);
+      const result = await b.list(prefix.length > 0 ? { prefix } : void 0);
+      return writeBytes2(buf_ptr, buf_max, encoder3.encode(JSON.stringify(result.keys.map((k) => k.name))));
+    })
+  };
+}
+
+// src/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(`
-`)) {
+      for (const line of headersJson.split("\n")) {
         const colonIdx = line.indexOf(":");
         if (colonIdx > 0) {
           headers[line.slice(0, colonIdx)] = line.slice(colonIdx + 1);
@@ -228,25 +318,23 @@ function createFetchImports(getMemory) {
     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) : undefined;
+    const body = body_len > 0 ? readBytes(body_ptr, body_len) : void 0;
     const headers = parseHeaders(headersJson);
-    const controller = new AbortController;
+    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 : undefined,
-        body: method !== "GET" && method !== "HEAD" ? body : undefined,
+        headers: Object.keys(headers).length > 0 ? headers : void 0,
+        body: method !== "GET" && method !== "HEAD" ? body : void 0,
         signal: controller.signal
       });
-      if (timeout)
-        clearTimeout(timeout);
+      if (timeout) clearTimeout(timeout);
       new DataView(getMemory().buffer).setUint16(status_out, response.status, true);
       const bytes = new Uint8Array(await response.arrayBuffer());
-      return writeBytes(buf_ptr, buf_max, bytes);
+      return writeBytes2(buf_ptr, buf_max, bytes);
     } catch (err) {
-      if (timeout)
-        clearTimeout(timeout);
+      if (timeout) clearTimeout(timeout);
       const msg = err instanceof Error ? err.message : String(err);
       console.error(`wasm fetch failed: ${url} (${msg})`);
       return -1;
@@ -263,1508 +351,272 @@ function createFetchImports(getMemory) {
   };
 }
 
-// src/wasm/core.ts
-var CallbackType = {
-  Event: 0,
-  FetchSuccess: 1,
-  FetchError: 2,
-  Timeout: 3,
-  Interval: 4,
-  WebSocketOpen: 5,
-  WebSocketMessage: 6,
-  WebSocketError: 7,
-  WebSocketClose: 8
-};
-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);
+// src/db.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;
 }
-var textDecoder = new TextDecoder;
-var textEncoder = new TextEncoder;
-var memoryView = null;
-var memoryBuffer = null;
-function getMemoryView() {
-  const buf = jsz.memory.buffer;
-  if (buf !== memoryBuffer) {
-    memoryBuffer = buf;
-    memoryView = new Uint8Array(buf);
+function toD1Value(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;
   }
-  return memoryView;
-}
-var stringCache = new Map;
-function stringCacheKey(ptr, len) {
-  return ptr * 65536 + len;
-}
-function readString(ptr, len) {
-  const key = stringCacheKey(ptr, len);
-  const cached = stringCache.get(key);
-  if (cached !== undefined)
-    return cached;
-  const str = textDecoder.decode(getMemoryView().subarray(ptr, ptr + len));
-  stringCache.set(key, str);
-  return str;
-}
-function writeBytes(ptr, data) {
-  getMemoryView().set(data, ptr);
 }
-function wrapPromisingExport(fn) {
-  if (!fn)
-    return;
-  const promising = WebAssembly.promising;
-  if (typeof promising !== "function")
-    return fn;
-  return promising(fn);
-}
-function invokeWasmExport(fn, ...args) {
-  if (!fn)
-    return;
-  const result = fn(...args);
-  if (result && typeof result.then === "function") {
-    result.then(undefined, (error) => {
-      console.error(error);
-    });
+function toPositionalBindings(json) {
+  switch (json.kind) {
+    case "none":
+      return [];
+    case "positional":
+      return json.values.map(toD1Value);
+    case "named":
+      throw new Error("Cloudflare D1 adapter does not support named bindings yet");
   }
 }
-
-class ZxBridgeCore {
-  #intervals = new Map;
-  _alloc;
-  #handler;
-  #fetchCompleteHandler;
-  constructor(exports) {
-    this._alloc = exports.__zx_alloc;
-    this.#handler = wrapPromisingExport(exports.__zx_cb);
-    const fetchCompleteHandler = wrapPromisingExport(exports.__zx_fetch_complete);
-    if (!fetchCompleteHandler) {
-      throw new Error("__zx_fetch_complete not exported from WASM");
-    }
-    this.#fetchCompleteHandler = fetchCompleteHandler;
-    if (exports.memory)
-      jsz.memory = exports.memory;
-  }
-  #invoke(type, id, data) {
-    const handler = this.#handler;
-    if (!handler) {
-      console.warn("__zx_cb not exported from WASM");
-      return;
-    }
-    const dataRef = storeValueGetRef(data);
-    invokeWasmExport(handler, type, id, dataRef);
-  }
-  fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) {
-    const url = readString(urlPtr, urlLen);
-    const method = methodLen > 0 ? readString(methodPtr, methodLen) : "GET";
-    const headersJson = headersLen > 0 ? readString(headersPtr, headersLen) : "{}";
-    const body = bodyLen > 0 ? getMemoryView().subarray(bodyPtr, bodyPtr + bodyLen) : undefined;
-    let headers = {};
-    try {
-      headers = JSON.parse(headersJson);
-    } catch {
-      for (const line of headersJson.split(`
-`)) {
-        const colonIdx = line.indexOf(":");
-        if (colonIdx > 0) {
-          headers[line.slice(0, colonIdx)] = line.slice(colonIdx + 1);
-        }
-      }
-    }
-    const controller = new AbortController;
-    const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
-    const fetchOptions = {
-      method,
-      headers: Object.keys(headers).length > 0 ? headers : undefined,
-      body: method !== "GET" && method !== "HEAD" ? body : undefined,
-      signal: controller.signal
-    };
-    fetch(url, fetchOptions).then(async (response) => {
-      if (timeout)
-        clearTimeout(timeout);
-      const bytes = new Uint8Array(await response.arrayBuffer());
-      this._notifyFetchComplete(fetchId, response.status, bytes, false);
-    }).catch((error) => {
-      if (timeout)
-        clearTimeout(timeout);
-      const isAbort = error.name === "AbortError";
-      const errorMsg = isAbort ? "Request timeout" : error.message ?? "Fetch failed";
-      this._notifyFetchComplete(fetchId, 0, errorMsg, true);
-    });
+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 };
   }
-  _notifyFetchComplete(fetchId, statusCode, body, isError) {
-    const handler = this.#fetchCompleteHandler;
-    const encoded = typeof body === "string" ? textEncoder.encode(body) : body;
-    const ptr = this._alloc(encoded.length);
-    writeBytes(ptr, encoded);
-    invokeWasmExport(handler, fetchId, statusCode, ptr, encoded.length, isError ? 1 : 0);
+  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) };
   }
-  setTimeout(callbackId, delayMs) {
-    setTimeout(() => {
-      this.#invoke(CallbackType.Timeout, callbackId, null);
-    }, delayMs);
+  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) };
   }
-  setInterval(callbackId, intervalMs) {
-    const handle = setInterval(() => {
-      this.#invoke(CallbackType.Interval, callbackId, null);
-    }, intervalMs);
-    this.#intervals.set(callbackId, handle);
+  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 createD1Imports(bindings, getMemory) {
+  const encoder3 = new TextEncoder();
+  const decoder3 = new TextDecoder();
+  function readStr(ptr, len) {
+    return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
   }
-  clearInterval(callbackId) {
-    const handle = this.#intervals.get(callbackId);
-    if (handle !== undefined) {
-      clearInterval(handle);
-      this.#intervals.delete(callbackId);
-    }
+  function writeJson(buf_ptr, buf_max, value) {
+    const data = encoder3.encode(JSON.stringify(value));
+    if (data.length > buf_max) return -2;
+    new Uint8Array(getMemory().buffer, buf_ptr, data.length).set(data);
+    return data.length;
   }
-  dispose() {
-    for (const handle of this.#intervals.values()) {
-      clearInterval(handle);
-    }
-    this.#intervals.clear();
+  function binding(ns) {
+    return bindings[ns] ?? bindings["default"] ?? null;
   }
-  _writeStringToWasm(str) {
-    return this._writeBytesToWasm(textEncoder.encode(str));
+  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));
   }
-  _writeBytesToWasm(data) {
-    const ptr = this._alloc(data.length);
-    writeBytes(ptr, data);
-    return { ptr, len: data.length };
-  }
-  static log(level, ptr, len) {
-    const msg = textDecoder.decode(getMemoryView().subarray(ptr, ptr + len));
-    switch (level) {
-      case 0:
-        console.error(msg);
-        break;
-      case 1:
-        console.warn(msg);
-        break;
-      case 3:
-        console.debug(msg);
-        break;
-      default:
-        console.log(msg);
-        break;
-    }
-  }
-  static createImportObject(bridgeRef) {
-    return {
-      ...jsz.importObject(),
-      __zx_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),
-        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
-          bridgeRef.current?.fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId);
-        },
-        _setTimeout: (callbackId, delayMs) => {
-          bridgeRef.current?.setTimeout(callbackId, delayMs);
-        },
-        _setInterval: (callbackId, intervalMs) => {
-          bridgeRef.current?.setInterval(callbackId, intervalMs);
-        },
-        _clearInterval: (callbackId) => {
-          bridgeRef.current?.clearInterval(callbackId);
-        }
-      }
-    };
-  }
-}
-// src/kv.ts
-var exports_kv = {};
-__export(exports_kv, {
-  createMemoryKV: () => createMemoryKV,
-  createKVImports: () => createKVImports
-});
-function createMemoryKV() {
-  const store = new Map;
-  return {
-    async get(key) {
-      return store.get(key) ?? null;
-    },
-    async put(key, value) {
-      store.set(key, value);
-    },
-    async delete(key) {
-      store.delete(key);
-    },
-    async list(options) {
-      const keys = [...store.keys()].filter((k) => !options?.prefix || k.startsWith(options.prefix)).map((name) => ({ name }));
-      return { keys };
-    }
-  };
-}
-function isSyncKVNamespace(binding) {
-  const candidate = binding;
-  return typeof candidate.getSync === "function" && typeof candidate.putSync === "function" && typeof candidate.deleteSync === "function" && typeof candidate.listSync === "function";
-}
-function createKVImports(bindings, getMemory) {
-  const encoder2 = new TextEncoder;
-  const decoder2 = new TextDecoder;
-  function readStr(ptr, len) {
-    return decoder2.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 binding(ns) {
-    return bindings[ns] ?? bindings["default"] ?? null;
-  }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "function") {
-    let syncBinding = function(ns) {
-      const candidate = binding(ns);
-      return candidate && isSyncKVNamespace(candidate) ? candidate : null;
-    };
-    return {
-      kv_get: (ns_ptr, ns_len, key_ptr, key_len, buf_ptr, buf_max) => {
-        const b = syncBinding(readStr(ns_ptr, ns_len));
-        if (!b)
-          return -1;
-        const value = b.getSync(readStr(key_ptr, key_len));
-        if (value === null)
-          return -1;
-        return writeBytes2(buf_ptr, buf_max, encoder2.encode(value));
-      },
-      kv_put: (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len) => {
-        const b = syncBinding(readStr(ns_ptr, ns_len));
-        if (!b)
-          return 0;
-        b.putSync(readStr(key_ptr, key_len), readStr(val_ptr, val_len));
-        return 0;
-      },
-      kv_delete: (ns_ptr, ns_len, key_ptr, key_len) => {
-        const b = syncBinding(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, buf_ptr, buf_max) => {
-        const b = syncBinding(readStr(ns_ptr, ns_len));
-        if (!b)
-          return writeBytes2(buf_ptr, buf_max, encoder2.encode("[]"));
-        const prefix = readStr(pfx_ptr, pfx_len);
-        const result = b.listSync(prefix.length > 0 ? { prefix } : undefined);
-        return writeBytes2(buf_ptr, buf_max, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
-      }
-    };
+  const Suspending = WebAssembly.Suspending;
+  if (typeof Suspending !== "function") {
+    return {
+      db_open: (_ns, _ns_len) => -1,
+      db_run: (_a, _b, _c, _d, _e, _f, _g, _h) => -1,
+      db_get: (_a, _b, _c, _d, _e, _f, _g, _h) => -1,
+      db_all: (_a, _b, _c, _d, _e, _f, _g, _h) => -1,
+      db_values: (_a, _b, _c, _d, _e, _f, _g, _h) => -1
+    };
   }
   return {
-    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, buf_ptr, buf_max) => {
-      const b = binding(readStr(ns_ptr, ns_len));
-      if (!b)
-        return -1;
-      const value = await b.get(readStr(key_ptr, key_len));
-      if (value === null)
-        return -1;
-      return writeBytes2(buf_ptr, buf_max, encoder2.encode(value));
+    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, buf_ptr, buf_max) => {
+      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 writeJson(buf_ptr, buf_max, {
+        last_insert_rowid: result.meta?.last_row_id ?? 0,
+        changes: result.meta?.changes ?? 0
+      });
     }),
-    kv_put: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len) => {
-      const b = binding(readStr(ns_ptr, ns_len));
-      if (!b)
-        return -1;
-      await b.put(readStr(key_ptr, key_len), readStr(val_ptr, val_len));
-      return 0;
+    db_get: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, buf_ptr, buf_max) => {
+      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) return 0;
+      return writeJson(buf_ptr, buf_max, [objectToWireRow(row)]);
     }),
-    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;
+    db_all: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, buf_ptr, buf_max) => {
+      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();
+      return writeJson(buf_ptr, buf_max, (result.results ?? []).map(objectToWireRow));
     }),
-    kv_list: new Suspending(async (ns_ptr, ns_len, prefix_ptr, prefix_len, buf_ptr, buf_max) => {
-      const b = binding(readStr(ns_ptr, ns_len));
-      if (!b)
-        return writeBytes2(buf_ptr, buf_max, encoder2.encode("[]"));
-      const prefix = readStr(prefix_ptr, prefix_len);
-      const result = await b.list(prefix.length > 0 ? { prefix } : undefined);
-      return writeBytes2(buf_ptr, buf_max, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
+    db_values: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, buf_ptr, buf_max) => {
+      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();
+      return writeJson(buf_ptr, buf_max, valuesToWireRows(rows));
     })
   };
 }
 
-// src/browser/kv.ts
-function getIndexedDb() {
-  if (typeof indexedDB === "undefined") {
-    throw new Error("IndexedDB is not available in this environment");
+// src/wasi.ts
+var ProcExit = class extends Error {
+  constructor(code) {
+    super(`proc_exit(${code})`);
+    this.code = code;
   }
-  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 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}`);
   });
-}
-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);
+  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);
       }
-    };
-    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);
-      console.debug(`KV GET - Key: ${key}, Value: ${value}`);
-      return typeof value === "string" ? value : null;
+    }
+  }
+  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;
     },
-    async put(key, value) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readwrite");
-      tx.objectStore(storeName).put(value, scopedKey(key));
-      await transactionToPromise(tx);
-      console.debug(`KV PUT - Key: ${key}, Value: ${value}`);
+    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;
     },
-    async delete(key) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readwrite");
-      tx.objectStore(storeName).delete(scopedKey(key));
-      await transactionToPromise(tx);
+    environ_sizes_get(count_ptr, buf_size_ptr) {
+      v().setUint32(count_ptr, 0, true);
+      v().setUint32(buf_size_ptr, 0, true);
+      return 0;
     },
-    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) }))
-      };
-    }
-  };
-}
-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));
+    environ_get(_environ_ptr, _environ_buf_ptr) {
+      return 0;
     },
-    async get(key) {
-      return this.getSync(key);
+    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;
     },
-    putSync(key, value) {
-      storage.setItem(scopedKey(key), value);
+    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;
     },
-    async put(key, value) {
-      this.putSync(key, value);
+    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;
     },
-    deleteSync(key) {
-      storage.removeItem(scopedKey(key));
+    fd_prestat_get(_fd, _bufptr) {
+      return 8;
     },
-    async delete(key) {
-      this.deleteSync(key);
+    fd_prestat_dir_name(_fd, _path, _path_len) {
+      return 8;
     },
-    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);
-    }
-  };
-}
-function hasJSPI() {
-  return typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
-}
-function createBrowserKVBindings(options = {}) {
-  const namespace = options.namespace ?? "default";
-  return {
-    [namespace]: hasJSPI() ? createIndexedDbKV(options) : createLocalStorageKV(options)
-  };
-}
-
-// src/wasm/index.ts
-class ZxBridge extends ZxBridgeCore {
-  #websockets = new Map;
-  #wsOnOpenHandler;
-  #wsOnMessageHandler;
-  #wsOnErrorHandler;
-  #wsOnCloseHandler;
-  #eventbridge;
-  #eventbridgeAsync;
-  constructor(exports) {
-    super(exports);
-    this.#wsOnOpenHandler = wrapPromisingExport(exports.__zx_ws_onopen);
-    this.#wsOnMessageHandler = wrapPromisingExport(exports.__zx_ws_onmessage);
-    this.#wsOnErrorHandler = wrapPromisingExport(exports.__zx_ws_onerror);
-    this.#wsOnCloseHandler = wrapPromisingExport(exports.__zx_ws_onclose);
-    this.#eventbridge = exports.__zx_eventbridge;
-    this.#eventbridgeAsync = wrapPromisingExport(exports.__zx_eventbridge_async ?? exports.__zx_eventbridge);
-  }
-  eventMaySuspend(velementId, eventTypeId) {
-    return !!((eventHandlerModes.get(velementId) ?? 0) & 1 << eventTypeId);
-  }
-  setEventHandlerMode(velementId, eventTypeId, maySuspend) {
-    const bit = 1 << eventTypeId;
-    const current = eventHandlerModes.get(velementId) ?? 0;
-    const next = maySuspend ? current | bit : current & ~bit;
-    if (next === 0)
-      eventHandlerModes.delete(velementId);
-    else
-      eventHandlerModes.set(velementId, next);
-  }
-  clearEventHandlerModes(velementId) {
-    eventHandlerModes.delete(velementId);
-  }
-  submitFormActionAsync(form, actionId, statesJson, fetchId) {
-    const formData = new FormData(form);
-    formData.append("__$states", statesJson);
-    fetch(window.location.href, {
-      method: "POST",
-      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);
-    });
-  }
-  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) : undefined;
-    try {
-      const ws = protocols && protocols.length > 0 ? new WebSocket(url, protocols) : new WebSocket(url);
-      ws.binaryType = "arraybuffer";
-      ws.onopen = () => {
-        const handler = this.#wsOnOpenHandler;
-        if (!handler)
-          return;
-        const protocol = ws.protocol || "";
-        const { ptr, len } = this._writeStringToWasm(protocol);
-        invokeWasmExport(handler, wsId, ptr, len);
-      };
-      ws.onmessage = (event) => {
-        const handler = this.#wsOnMessageHandler;
-        if (!handler)
-          return;
-        const isBinary = event.data instanceof ArrayBuffer;
-        const data = isBinary ? new Uint8Array(event.data) : textEncoder.encode(event.data);
-        const { ptr, len } = this._writeBytesToWasm(data);
-        invokeWasmExport(handler, wsId, ptr, len, isBinary ? 1 : 0);
-      };
-      ws.onerror = (_event) => {
-        const handler = this.#wsOnErrorHandler;
-        if (!handler)
-          return;
-        const { ptr, len } = this._writeStringToWasm("WebSocket error");
-        invokeWasmExport(handler, wsId, ptr, len);
-      };
-      ws.onclose = (event) => {
-        const handler = this.#wsOnCloseHandler;
-        if (!handler)
-          return;
-        const reason = event.reason || "";
-        const { ptr, len } = this._writeStringToWasm(reason);
-        invokeWasmExport(handler, wsId, event.code, ptr, len, event.wasClean ? 1 : 0);
-        this.#websockets.delete(wsId);
-      };
-      this.#websockets.set(wsId, ws);
-    } catch (error) {
-      const handler = this.#wsOnErrorHandler;
-      if (handler) {
-        const msg = error instanceof Error ? error.message : "WebSocket connection failed";
-        const { ptr, len } = this._writeStringToWasm(msg);
-        invokeWasmExport(handler, wsId, ptr, len);
-      }
-    }
-  }
-  wsSend(wsId, dataPtr, dataLen, isBinary) {
-    const ws = this.#websockets.get(wsId);
-    if (!ws || ws.readyState !== WebSocket.OPEN)
-      return;
-    const memory = getMemoryView();
-    if (isBinary) {
-      ws.send(memory.slice(dataPtr, dataPtr + dataLen));
-    } else {
-      ws.send(textDecoder.decode(memory.subarray(dataPtr, dataPtr + dataLen)));
-    }
-  }
-  wsClose(wsId, code, reasonPtr, reasonLen) {
-    const ws = this.#websockets.get(wsId);
-    if (!ws)
-      return;
-    const reason = reasonLen > 0 ? readString(reasonPtr, reasonLen) : undefined;
-    try {
-      if (reason)
-        ws.close(code, reason);
-      else
-        ws.close(code);
-    } catch {
-      ws.close();
-    }
-  }
-  dispose() {
-    super.dispose();
-    eventHandlerModes.clear();
-    for (const ws of this.#websockets.values()) {
-      try {
-        ws.close();
-      } catch {}
-    }
-    this.#websockets.clear();
-  }
-  eventbridge(velementId, eventTypeId, event) {
-    const eventRef = storeValueGetRef(event);
-    if (this.eventMaySuspend(velementId, eventTypeId)) {
-      invokeWasmExport(this.#eventbridgeAsync, velementId, eventTypeId, eventRef);
-      return;
-    }
-    invokeWasmExport(this.#eventbridge, velementId, eventTypeId, eventRef);
-  }
-  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.current?.setEventHandlerMode(vnodeId, eventTypeId, maySuspend !== 0);
-        },
-        _clearEventHandlerModes: (vnodeId) => {
-          bridgeRef.current?.clearEventHandlerModes(vnodeId);
-        },
-        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
-          bridgeRef.current?.fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId);
-        },
-        _setTimeout: (callbackId, delayMs) => {
-          bridgeRef.current?.setTimeout(callbackId, delayMs);
-        },
-        _setInterval: (callbackId, intervalMs) => {
-          bridgeRef.current?.setInterval(callbackId, intervalMs);
-        },
-        _clearInterval: (callbackId) => {
-          bridgeRef.current?.clearInterval(callbackId);
-        },
-        _wsConnect: (wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) => {
-          bridgeRef.current?.wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen);
-        },
-        _wsSend: (wsId, dataPtr, dataLen, isBinary) => {
-          bridgeRef.current?.wsSend(wsId, dataPtr, dataLen, isBinary);
-        },
-        _wsClose: (wsId, code, reasonPtr, reasonLen) => {
-          bridgeRef.current?.wsClose(wsId, code, reasonPtr, reasonLen);
-        },
-        _ce: (id, vnodeId) => {
-          const tagName = TAG_NAMES[id];
-          const el = id >= SVG_TAG_START_INDEX ? document.createElementNS("http://www.w3.org/2000/svg", tagName) : document.createElement(tagName);
-          el.__zx_ref = Number(vnodeId);
-          domNodes.set(vnodeId, el);
-          return storeValueGetRef(el);
-        },
-        _ct: (ptr, len, vnodeId) => {
-          const text = readString(ptr, len);
-          const node = document.createTextNode(text);
-          node.__zx_ref = Number(vnodeId);
-          domNodes.set(vnodeId, node);
-          return storeValueGetRef(node);
-        },
-        _sa: (vnodeId, namePtr, nameLen, valPtr, valLen) => {
-          domNodes.get(vnodeId)?.setAttribute(readString(namePtr, nameLen), readString(valPtr, valLen));
-        },
-        _sp: (vnodeId, namePtr, nameLen, valPtr, valLen) => {
-          const el = domNodes.get(vnodeId);
-          if (el) {
-            const name = readString(namePtr, nameLen);
-            const val = readString(valPtr, valLen);
-            if (name === "checked" || name === "selected" || name === "muted") {
-              el[name] = val !== "false";
-            } else {
-              el[name] = val;
-            }
-          }
-        },
-        _ra: (vnodeId, namePtr, nameLen) => {
-          domNodes.get(vnodeId)?.removeAttribute(readString(namePtr, nameLen));
-        },
-        _snv: (vnodeId, ptr, len) => {
-          const node = domNodes.get(vnodeId);
-          if (node)
-            node.nodeValue = readString(ptr, len);
-        },
-        _srh: (vnodeId, ptr, len) => {
-          const el = domNodes.get(vnodeId);
-          if (el)
-            el.innerHTML = readString(ptr, len);
-        },
-        _ac: (parentId, childId) => {
-          const parent = domNodes.get(parentId);
-          const child = domNodes.get(childId);
-          if (parent && child)
-            parent.appendChild(child);
-        },
-        _ib: (parentId, childId, refId) => {
-          const parent = domNodes.get(parentId);
-          const child = domNodes.get(childId);
-          const ref = domNodes.get(refId) ?? null;
-          if (parent && child)
-            parent.insertBefore(child, ref);
-        },
-        _rc: (parentId, childId) => {
-          const parent = domNodes.get(parentId);
-          const child = domNodes.get(childId);
-          if (parent && child) {
-            parent.removeChild(child);
-            cleanupDomNodes(child);
-          }
-        },
-        _rpc: (parentId, newId, oldId) => {
-          const parent = domNodes.get(parentId);
-          const newChild = domNodes.get(newId);
-          const oldChild = domNodes.get(oldId);
-          if (parent && newChild && oldChild) {
-            parent.replaceChild(newChild, oldChild);
-            cleanupDomNodes(oldChild);
-          }
-        },
-        _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: (vnodeId, bufPtr, bufLen) => {
-          const form = domNodes.get(vnodeId);
-          if (!form || !(form instanceof HTMLFormElement))
-            return 0;
-          const formData = new FormData(form);
-          const urlEncoded = new URLSearchParams(formData).toString();
-          const bytes = textEncoder.encode(urlEncoded);
-          const len = Math.min(bytes.length, bufLen);
-          writeBytes(bufPtr, bytes.subarray(0, len));
-          return len;
-        },
-        _submitFormAction: (vnodeId, actionId) => {
-          const form = domNodes.get(vnodeId);
-          if (!form || !(form instanceof HTMLFormElement))
-            return;
-          const formData = new FormData(form);
-          fetch(window.location.href, {
-            method: "POST",
-            headers: { "x-action": String(actionId >>> 0) },
-            body: formData
-          }).catch(() => {});
-        },
-        _submitFormActionAsync: (vnodeId, actionId, statesPtr, statesLen, fetchId) => {
-          const form = domNodes.get(vnodeId);
-          if (!form || !(form instanceof HTMLFormElement))
-            return;
-          const statesJson = statesLen > 0 ? readString(statesPtr, statesLen) : "[]";
-          bridgeRef.current?.submitFormActionAsync(form, actionId, statesJson, fetchId);
-        }
-      }
-    };
-  }
-}
-var domNodes = new Map;
-function cleanupDomNodes(node) {
-  const ref = node.__zx_ref;
-  if (ref !== undefined)
-    domNodes.delete(BigInt(ref));
-  const children = node.childNodes;
-  for (let i = 0;i < children.length; i++)
-    cleanupDomNodes(children[i]);
-}
-var SVG_TAG_START_INDEX = 140;
-var TAG_NAMES = [
-  "aside",
-  "fragment",
-  "iframe",
-  "slot",
-  "img",
-  "html",
-  "base",
-  "head",
-  "link",
-  "meta",
-  "script",
-  "style",
-  "title",
-  "address",
-  "article",
-  "body",
-  "h1",
-  "h6",
-  "footer",
-  "header",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "hgroup",
-  "nav",
-  "section",
-  "dd",
-  "dl",
-  "dt",
-  "div",
-  "figcaption",
-  "figure",
-  "hr",
-  "li",
-  "ol",
-  "ul",
-  "menu",
-  "main",
-  "p",
-  "picture",
-  "pre",
-  "a",
-  "abbr",
-  "b",
-  "bdi",
-  "bdo",
-  "br",
-  "cite",
-  "code",
-  "data",
-  "time",
-  "dfn",
-  "em",
-  "i",
-  "kbd",
-  "mark",
-  "q",
-  "blockquote",
-  "rp",
-  "ruby",
-  "rt",
-  "rtc",
-  "rb",
-  "s",
-  "del",
-  "ins",
-  "samp",
-  "small",
-  "span",
-  "strong",
-  "sub",
-  "sup",
-  "u",
-  "var",
-  "wbr",
-  "area",
-  "map",
-  "audio",
-  "source",
-  "track",
-  "video",
-  "embed",
-  "object",
-  "param",
-  "canvas",
-  "noscript",
-  "caption",
-  "table",
-  "col",
-  "colgroup",
-  "tbody",
-  "tr",
-  "thead",
-  "tfoot",
-  "td",
-  "th",
-  "button",
-  "datalist",
-  "option",
-  "fieldset",
-  "label",
-  "form",
-  "input",
-  "keygen",
-  "legend",
-  "meter",
-  "optgroup",
-  "select",
-  "output",
-  "progress",
-  "textarea",
-  "details",
-  "dialog",
-  "menuitem",
-  "summary",
-  "content",
-  "element",
-  "shadow",
-  "template",
-  "acronym",
-  "applet",
-  "basefont",
-  "font",
-  "big",
-  "blink",
-  "center",
-  "command",
-  "dir",
-  "frame",
-  "frameset",
-  "isindex",
-  "listing",
-  "marquee",
-  "noembed",
-  "plaintext",
-  "spacer",
-  "strike",
-  "tt",
-  "xmp",
-  "animate",
-  "animateMotion",
-  "animateTransform",
-  "circle",
-  "clipPath",
-  "defs",
-  "desc",
-  "ellipse",
-  "feBlend",
-  "feColorMatrix",
-  "feComponentTransfer",
-  "feComposite",
-  "feConvolveMatrix",
-  "feDiffuseLighting",
-  "feDisplacementMap",
-  "feDistantLight",
-  "feDropShadow",
-  "feFlood",
-  "feFuncA",
-  "feFuncB",
-  "feFuncG",
-  "feFuncR",
-  "feGaussianBlur",
-  "feImage",
-  "feMerge",
-  "feMergeNode",
-  "feMorphology",
-  "feOffset",
-  "fePointLight",
-  "feSpecularLighting",
-  "feSpotLight",
-  "feTile",
-  "feTurbulence",
-  "filter",
-  "foreignObject",
-  "g",
-  "image",
-  "line",
-  "linearGradient",
-  "marker",
-  "mask",
-  "metadata",
-  "mpath",
-  "path",
-  "pattern",
-  "polygon",
-  "polyline",
-  "radialGradient",
-  "rect",
-  "set",
-  "stop",
-  "svg",
-  "switch",
-  "symbol",
-  "text",
-  "textPath",
-  "tspan",
-  "use",
-  "view"
-];
-var DELEGATED_EVENTS = [
-  { domType: "click", eventTypeId: 0 },
-  { domType: "dblclick", eventTypeId: 1 },
-  { domType: "input", eventTypeId: 2 },
-  { domType: "change", eventTypeId: 3 },
-  { domType: "submit", eventTypeId: 4 },
-  { domType: "focusin", eventTypeId: 5 },
-  { domType: "focusout", eventTypeId: 6 },
-  { domType: "keydown", eventTypeId: 7 },
-  { domType: "keyup", eventTypeId: 8 },
-  { domType: "keypress", eventTypeId: 9 },
-  { domType: "mouseenter", eventTypeId: 10 },
-  { domType: "mouseleave", eventTypeId: 11 },
-  { domType: "mousedown", eventTypeId: 12 },
-  { domType: "mouseup", eventTypeId: 13 },
-  { domType: "mousemove", eventTypeId: 14 },
-  { domType: "touchstart", eventTypeId: 15 },
-  { domType: "touchend", eventTypeId: 16 },
-  { domType: "touchmove", eventTypeId: 17 },
-  { domType: "scroll", eventTypeId: 18 }
-];
-var eventHandlerModes = new Map;
-function initEventDelegation(bridge, rootSelector = "body") {
-  const root = document.querySelector(rootSelector);
-  if (!root)
-    return () => {};
-  const removers = [];
-  for (const delegatedEvent of DELEGATED_EVENTS) {
-    const listener = (event) => {
-      let target = event.target;
-      while (target && target !== document.body) {
-        const zxRef = target.__zx_ref;
-        if (zxRef !== undefined) {
-          bridge.eventbridge(BigInt(zxRef), delegatedEvent.eventTypeId, event);
-          if (event.cancelBubble)
-            break;
-        }
-        target = target.parentElement;
-      }
-    };
-    const options = { passive: delegatedEvent.domType.startsWith("touch") || delegatedEvent.domType === "scroll" };
-    root.addEventListener(delegatedEvent.domType, listener, options);
-    removers.push(() => root.removeEventListener(delegatedEvent.domType, listener, options));
-  }
-  return () => {
-    for (const remove of removers)
-      remove();
-  };
-}
-var DEFAULT_URL = "/assets/_/main.wasm";
-var activeRuntime = null;
-function buildDevtoolsLocation() {
-  return {
-    href: window.location.href,
-    origin: window.location.origin,
-    host: window.location.host,
-    pathname: window.location.pathname
-  };
-}
-function normalizeOptions(options = {}) {
-  return {
-    url: options.url,
-    eventDelegationRoot: options.eventDelegationRoot,
-    importObject: options.importObject,
-    kv: options.kv
-  };
-}
-function registerDevReinit(options) {
-  if (typeof window === "undefined")
-    return;
-  const reinit = () => init(options);
-  window.__zx_dev_reinit = reinit;
-  window.__ZIEX_DEVTOOLS_GLOBAL_HOOK__ = {
-    location: buildDevtoolsLocation(),
-    reinit
-  };
-}
-async function init(options = {}) {
-  const normalizedOptions = normalizeOptions(options);
-  if (activeRuntime) {
-    activeRuntime.dispose();
-    activeRuntime = null;
-  }
-  const url = options.url ?? document.getElementById("__$wasmlink")?.href ?? DEFAULT_URL;
-  const bridgeRef = { current: null };
-  let wasmMemory = null;
-  const kvBindings = options.kv ?? createBrowserKVBindings();
-  const kvImportObject = {
-    __zx_kv: createKVImports(kvBindings, () => {
-      if (wasmMemory)
-        return wasmMemory;
-      if (jsz.memory)
-        return jsz.memory;
-      throw new Error("WASM memory is not ready");
-    })
-  };
-  const importObject = Object.assign({}, ZxBridge.createImportObject(bridgeRef), kvImportObject, options.importObject);
-  const source = await WebAssembly.instantiateStreaming(fetch(url), importObject);
-  const { instance } = source;
-  wasmMemory = instance.exports.memory;
-  jsz.memory = wasmMemory;
-  const bridge = new ZxBridge(instance.exports);
-  bridgeRef.current = bridge;
-  domNodes.clear();
-  const disposeDelegation = initEventDelegation(bridge, options.eventDelegationRoot ?? "body");
-  const main = wrapPromisingExport(instance.exports.mainClient);
-  invokeWasmExport(main);
-  activeRuntime = {
-    options: normalizedOptions,
-    dispose: () => {
-      disposeDelegation();
-      bridge.dispose();
-      domNodes.clear();
-    }
-  };
-  if (true)
-    registerDevReinit(normalizedOptions);
-  return { source, bridge };
-}
-
-// src/runtime.ts
-var exports_runtime = {};
-__export(exports_runtime, {
-  run: () => run,
-  buildWsImports: () => buildWsImports,
-  attachWebSocket: () => attachWebSocket
-});
-
-// src/wasm/wasi.ts
-var decoder2 = new TextDecoder;
-var encoder2 = new TextEncoder;
-
-class ZxWasiBridge {
-  #alloc;
-  #fetchCompleteHandler;
-  #memory;
-  #cb;
-  #intervals = new Map;
-  #memView = null;
-  #memBuf = null;
-  constructor(exports) {
-    this.#memory = exports.memory;
-    this.#alloc = exports.__zx_alloc;
-    this.#fetchCompleteHandler = exports.__zx_fetch_complete;
-    this.#cb = exports.__zx_cb;
-  }
-  #view() {
-    const buf = this.#memory.buffer;
-    if (buf !== this.#memBuf) {
-      this.#memBuf = buf;
-      this.#memView = new Uint8Array(buf);
-    }
-    return this.#memView;
-  }
-  #readString(ptr, len) {
-    return decoder2.decode(this.#view().subarray(ptr, ptr + len));
-  }
-  #writeBytes(ptr, data) {
-    this.#view().set(data, ptr);
-  }
-  log(level, ptr, len) {
-    const msg = decoder2.decode(this.#view().subarray(ptr, ptr + len));
-    switch (level) {
-      case 0:
-        console.error(msg);
-        break;
-      case 1:
-        console.warn(msg);
-        break;
-      case 3:
-        console.debug(msg);
-        break;
-      default:
-        console.log(msg);
-        break;
-    }
-  }
-  fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) {
-    const url = this.#readString(urlPtr, urlLen);
-    const method = methodLen > 0 ? this.#readString(methodPtr, methodLen) : "GET";
-    const headersJson = headersLen > 0 ? this.#readString(headersPtr, headersLen) : "{}";
-    const body = bodyLen > 0 ? this.#view().subarray(bodyPtr, bodyPtr + bodyLen) : undefined;
-    let headers = {};
-    try {
-      headers = JSON.parse(headersJson);
-    } catch {
-      for (const line of headersJson.split(`
-`)) {
-        const i = line.indexOf(":");
-        if (i > 0)
-          headers[line.slice(0, i)] = line.slice(i + 1);
-      }
-    }
-    const controller = new AbortController;
-    const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
-    fetch(url, {
-      method,
-      headers: Object.keys(headers).length > 0 ? headers : undefined,
-      body: method !== "GET" && method !== "HEAD" ? body : undefined,
-      signal: controller.signal
-    }).then(async (res) => {
-      if (timeout)
-        clearTimeout(timeout);
-      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" ? encoder2.encode(body) : body;
-    const ptr = this.#alloc(encoded.length);
-    this.#writeBytes(ptr, encoded);
-    this.#fetchCompleteHandler(fetchId, status, ptr, encoded.length, isError ? 1 : 0);
-  }
-  setTimeout(callbackId, delayMs) {
-    setTimeout(() => this.#cb?.(3, callbackId, 0n), delayMs);
-  }
-  setInterval(callbackId, intervalMs) {
-    const handle = setInterval(() => this.#cb?.(4, callbackId, 0n), intervalMs);
-    this.#intervals.set(callbackId, handle);
-  }
-  clearInterval(callbackId) {
-    const handle = this.#intervals.get(callbackId);
-    if (handle !== undefined) {
-      clearInterval(handle);
-      this.#intervals.delete(callbackId);
-    }
-  }
-  static createImportObject(bridgeRef) {
-    return {
-      __zx: {
-        _log: (level, ptr, len) => {
-          bridgeRef.current?.log(level, ptr, len);
-        },
-        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
-          bridgeRef.current?.fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId);
-        },
-        _setTimeout: (callbackId, delayMs) => {
-          bridgeRef.current?.setTimeout(callbackId, delayMs);
-        },
-        _setInterval: (callbackId, intervalMs) => {
-          bridgeRef.current?.setInterval(callbackId, intervalMs);
-        },
-        _clearInterval: (callbackId) => {
-          bridgeRef.current?.clearInterval(callbackId);
-        }
-      }
-    };
-  }
-}
-
-// src/db.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 toD1Value(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(toD1Value);
-    case "named":
-      throw new Error("Cloudflare D1 adapter does not support named bindings yet");
-  }
-}
-function toWireValue(value) {
-  if (value === null || value === undefined)
-    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 createD1Imports(bindings, getMemory) {
-  const encoder3 = new TextEncoder;
-  const decoder3 = new TextDecoder;
-  function readStr(ptr, len) {
-    return decoder3.decode(new Uint8Array(getMemory().buffer, ptr, len));
-  }
-  function writeJson(buf_ptr, buf_max, value) {
-    const data = encoder3.encode(JSON.stringify(value));
-    if (data.length > buf_max)
-      return -2;
-    new Uint8Array(getMemory().buffer, buf_ptr, data.length).set(data);
-    return data.length;
-  }
-  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, _h) => -1,
-      db_get: (_a, _b, _c, _d, _e, _f, _g, _h) => -1,
-      db_all: (_a, _b, _c, _d, _e, _f, _g, _h) => -1,
-      db_values: (_a, _b, _c, _d, _e, _f, _g, _h) => -1
-    };
-  }
-  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, buf_ptr, buf_max) => {
-      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 writeJson(buf_ptr, buf_max, {
-        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, buf_ptr, buf_max) => {
-      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)
-        return 0;
-      return writeJson(buf_ptr, buf_max, [objectToWireRow(row)]);
-    }),
-    db_all: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, buf_ptr, buf_max) => {
-      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();
-      return writeJson(buf_ptr, buf_max, (result.results ?? []).map(objectToWireRow));
-    }),
-    db_values: new Suspending(async (ns_ptr, ns_len, sql_ptr, sql_len, bindings_ptr, bindings_len, buf_ptr, buf_max) => {
-      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();
-      return writeJson(buf_ptr, buf_max, valuesToWireRows(rows));
-    })
-  };
-}
-
-// src/wasi.ts
-class ProcExit extends Error {
-  code;
-  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 + "\x00"));
-  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(`
-`);
-    stderrPartial = lines.pop() ?? "";
-    for (const line of lines) {
-      if (line.startsWith("__EDGE_META__:")) {
-        stderrMeta += line + `
-`;
-      } else if (line.length > 0) {
-        console.error("[ziex]", line);
-      }
-    }
-  }
-  let stdinOffset = 0;
-  function v() {
-    return new DataView(wasmMemory.buffer);
-  }
-  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_close(_fd) {
+      return 0;
     },
     fd_pread(_fd, _iovs, _iovs_len, _offset, nread_ptr) {
       v().setUint32(nread_ptr, 0, true);
@@ -1891,336 +743,1298 @@ function createWasiImports({
       v().setUint32(bufused_ptr, 0, true);
       return 76;
     },
+    // Stub for poll_oneoff - no blocking I/O in edge runtimes.
     poll_oneoff(_in, _out, _nsubscriptions, nevents_ptr) {
       v().setUint32(nevents_ptr, 0, true);
       return 0;
     }
-  };
-  function collectOutput() {
-    const remaining = stderrDecoder.decode(undefined, { stream: false });
-    const tail = stderrPartial + remaining;
-    if (tail.length > 0) {
-      if (tail.startsWith("__EDGE_META__:"))
-        stderrMeta += tail;
-      else
-        console.error("[ziex]", tail);
-      stderrPartial = "";
+  };
+  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.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 = { current: null };
+  const Suspending = WebAssembly.Suspending;
+  const jspi = typeof Suspending === "function";
+  const wsState = {
+    upgraded: false,
+    server: null,
+    pendingWrites: [],
+    messageQueue: [],
+    recvResolve: null
+  };
+  const instance = new WebAssembly.Instance(module, {
+    wasi_snapshot_preview1: { ...wasi?.wasiImport, ...wasiImport },
+    __zx_sys: buildSysImports(jspi, Suspending),
+    __zx_ws: buildWsImports(jspi ? Suspending : null, mem, new TextDecoder(), wsState),
+    __zx_kv: createKVImports(kvBindings ?? { default: createMemoryKV() }, mem),
+    __zx_db: createD1Imports(dbBindings ?? {}, mem),
+    __zx_net: createFetchImports(mem),
+    ...imports ? imports(mem) : {},
+    ...ZxWasiBridge.createImportObject(bridgeRef)
+  });
+  wasmMemory = instance.exports.memory;
+  setMemory(wasmMemory);
+  bridgeRef.current = new ZxWasiBridge(instance.exports);
+  const wasmPromise = executeWasm(instance, jspi, Suspending, wsState);
+  if (wsState.upgraded) {
+    const server = attachWebSocket(wsState);
+    ctx?.waitUntil(wasmPromise);
+    return new Response(null, { status: 101, webSocket: server.client });
+  }
+  const { stderrText: 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] };
+  }
+};
+
+// ../../vendor/jsz/js/src/zigjs.ts
+var NAN_PREFIX = 2146959360;
+var predefined = {
+  "nan": 0,
+  "null": 1,
+  "true": 2,
+  "false": 3,
+  "undefined": 4,
+  "globalThis": 5,
+  "runtime": 6
+};
+var PREDEFINED_ID_MAX = 6;
+var encoder2 = new TextEncoder();
+var decoder2 = new TextDecoder("utf-8");
+var ZigJS = class {
+  constructor() {
+    /**
+     * The values, indexed by ID (number). Duplicate values can be in this
+     * if they are loaded multiple times. That just acts as duplicate references.
+     * */
+    this.values = [NaN, null, true, false, void 0, globalThis, this];
+    /**
+     * When a value is removed from the values array, its ID is put
+     * in the pool so that we can use it next. This avoids fragmentation in
+     * our array keys.
+     * */
+    this.idPool = [];
+  }
+  /**
+   * Returns the import object that should be merged with your import
+   * object when instantiating your wasm instance. This injects the required
+   * functions into the wasm environment.
+   * */
+  importObject() {
     return {
-      stdout: mergeUint8Arrays(stdoutChunks),
-      stderrText: stderrMeta
+      "zig-js": {
+        valueGet: this.valueGet.bind(this),
+        valueSet: this.valueSet.bind(this),
+        valueDeinit: this.valueDeinit.bind(this),
+        valueObjectCreate: this.valueObjectCreate.bind(this),
+        valueStringCreate: this.valueStringCreate.bind(this),
+        valueStringLen: this.valueStringLen.bind(this),
+        valueStringCopy: this.valueStringCopy.bind(this),
+        valueNew: this.valueNew.bind(this),
+        funcApply: this.funcApply.bind(this)
+      }
     };
   }
-  return { wasiImport, setMemory, collectOutput };
+  /**
+   * Get a value from the JS environment.
+   * */
+  valueGet(out, id, ptr, len) {
+    const val = this.loadValue(id);
+    const str = this.loadString(ptr, len);
+    const result = Reflect.get(val, str);
+    this.storeValue(out, result);
+  }
+  /**
+   * Set a value on an object.
+   * */
+  valueSet(id, ptr, len, refAddr) {
+    const obj = this.loadValue(id);
+    const str = this.loadString(ptr, len);
+    const val = this.loadRef(refAddr);
+    Reflect.set(obj, str, val);
+  }
+  /**
+   * Dereference a value, allowing the JS environment to potentially GC it.
+   * */
+  valueDeinit(id) {
+    if (id > PREDEFINED_ID_MAX) {
+      this.values[id] = null;
+      this.idPool.push(id);
+    }
+  }
+  /**
+   * Create an empty object.
+   * */
+  valueObjectCreate(out) {
+    this.storeValue(out, new Object());
+  }
+  /**
+   * Creates a string on the JS side from a UTF-8 encoded string in wasm memory.
+   * */
+  valueStringCreate(out, ptr, len) {
+    const str = this.loadString(ptr, len);
+    this.storeValue(out, str);
+  }
+  /**
+   * Returns the length of the string given by id.
+   * */
+  valueStringLen(id) {
+    const val = this.loadValue(id);
+    const buf = encoder2.encode(val);
+    return buf.byteLength;
+  }
+  /**
+   * Copy the string at id "id" into the shared memory at ptr.
+   * */
+  valueStringCopy(id, ptr, max) {
+    if (this.memory == null) return;
+    const val = this.loadValue(id);
+    const bytes = encoder2.encode(val);
+    if (bytes.byteLength > max) return;
+    if (bytes.length === 0) return;
+    new Uint8Array(this.memory.buffer, ptr, bytes.length).set(bytes);
+  }
+  /**
+   * Call a constructor given by id.
+   * */
+  valueNew(out, id, argsAddr, argsLen) {
+    const fn = this.loadValue(id);
+    const args = [];
+    for (let i = 0; i < argsLen; i++) {
+      args.push(this.loadRef(argsAddr + i * 8));
+    }
+    const result = Reflect.construct(fn, args);
+    this.storeValue(out, result);
+  }
+  /**
+   * Call a function given by id.
+   * */
+  funcApply(out, id, thisRefAddr, argsAddr, argsLen) {
+    const fn = this.loadValue(id);
+    const thisVal = this.loadRef(thisRefAddr);
+    const args = [];
+    for (let i = 0; i < argsLen; i++) {
+      args.push(this.loadRef(argsAddr + i * 8));
+    }
+    const result = Reflect.apply(fn, thisVal, args);
+    this.storeValue(out, result);
+  }
+  /**
+   * This can be used to load a value given by an ID. A WASM function
+   * might return a value as an ID. This can be used to retrieve it.
+   * */
+  loadValue(id) {
+    return this.values[id];
+  }
+  /**
+   * This removes the value from the values list and returns it. This
+   * will not remove predefined values but can still be used to retrieve
+   * them.
+   * */
+  deleteValue(id) {
+    const val = this.values[id];
+    this.valueDeinit(id);
+    return val;
+  }
+  loadRef(refAddr) {
+    if (this.memory == null) return;
+    const view = new DataView(this.memory.buffer);
+    const floatVal = view.getFloat64(refAddr, true);
+    if (!isNaN(floatVal)) return floatVal;
+    const id = this.loadRefId(refAddr);
+    return this.values[id];
+  }
+  loadRefId(refAddr) {
+    if (this.memory == null) return 0;
+    return new DataView(this.memory.buffer).getUint32(refAddr, true);
+  }
+  storeValue(out, val) {
+    if (this.memory == null) return;
+    const view = new DataView(this.memory.buffer);
+    if (typeof val === "number") {
+      if (isNaN(val)) {
+        view.setUint32(out, predefined.nan, true);
+        view.setUint32(out + 4, NAN_PREFIX, true);
+      } else {
+        view.setFloat64(out, val, true);
+      }
+      return;
+    }
+    if (val === null) {
+      view.setUint32(out, predefined.null, true);
+      view.setUint32(out + 4, NAN_PREFIX, true);
+      return;
+    }
+    if (val === void 0) {
+      view.setUint32(out, predefined.undefined, true);
+      view.setUint32(out + 4, NAN_PREFIX, true);
+      return;
+    }
+    if (typeof val === "boolean") {
+      view.setUint32(out, val ? predefined.true : predefined.false, true);
+      view.setUint32(out + 4, NAN_PREFIX, true);
+      return;
+    }
+    if (typeof val === "bigint") {
+      view.setFloat64(out, Number(val), true);
+      return;
+    }
+    let id = this.idPool.pop();
+    if (id === void 0) {
+      id = this.values.length;
+    }
+    this.values[id] = val;
+    let typeId = 0;
+    switch (typeof val) {
+      case "object":
+        typeId = 1;
+        break;
+      case "string":
+        typeId = 2;
+        break;
+      case "symbol":
+        typeId = 3;
+        break;
+      case "function":
+        typeId = 4;
+        break;
+    }
+    view.setUint32(out, Number(id), true);
+    view.setUint32(out + 4, NAN_PREFIX | typeId, true);
+  }
+  loadString(ptr, len) {
+    if (this.memory == null) return "";
+    const arr = new Uint8ClampedArray(this.memory.buffer, ptr, Number(len));
+    const data = arr.slice();
+    return decoder2.decode(data);
+  }
+};
+
+// src/wasm/core.ts
+var CallbackType = {
+  Event: 0,
+  FetchSuccess: 1,
+  FetchError: 2,
+  Timeout: 3,
+  Interval: 4,
+  WebSocketOpen: 5,
+  WebSocketMessage: 6,
+  WebSocketError: 7,
+  WebSocketClose: 8
+};
+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 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;
+var textDecoder = new TextDecoder();
+var textEncoder = new TextEncoder();
+var memoryView = null;
+var memoryBuffer = null;
+function getMemoryView() {
+  const buf = jsz.memory.buffer;
+  if (buf !== memoryBuffer) {
+    memoryBuffer = buf;
+    memoryView = new Uint8Array(buf);
   }
-  return result;
+  return memoryView;
+}
+var stringCache = /* @__PURE__ */ new Map();
+function stringCacheKey(ptr, len) {
+  return ptr * 65536 + len;
+}
+function readString(ptr, len) {
+  const key = stringCacheKey(ptr, len);
+  const cached = stringCache.get(key);
+  if (cached !== void 0) return cached;
+  const str = textDecoder.decode(getMemoryView().subarray(ptr, ptr + len));
+  stringCache.set(key, str);
+  return str;
 }
-
-// src/runtime.ts
-function buildWsImports(Suspending, mem, decoder3, ws) {
-  const readStr = (ptr, len) => decoder3.decode(new Uint8Array(mem().buffer, ptr, len));
-  return {
-    ws_upgrade: () => {
-      ws.upgraded = true;
-    },
-    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 = undefined;
-        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,
-    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 writeBytes(ptr, data) {
+  getMemoryView().set(data, ptr);
 }
-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 wrapPromisingExport(fn) {
+  if (!fn) return void 0;
+  const promising = WebAssembly.promising;
+  if (typeof promising !== "function") return fn;
+  return promising(fn);
 }
-function buildSysImports(jspi, Suspending) {
-  return {
-    sleep_ms: jspi ? new Suspending(async (ms) => new Promise((r) => setTimeout(r, ms))) : (_ms) => {}
-  };
+function invokeWasmExport(fn, ...args) {
+  if (!fn) return;
+  const result = fn(...args);
+  if (result && typeof result.then === "function") {
+    void result.then(void 0, (error) => {
+      console.error(error);
+    });
+  }
 }
-function executeWasm(instance, jspi, Suspending, wsState) {
-  if (!jspi) {
-    try {
-      instance.exports._start();
-    } catch (e) {
-      if (!(e instanceof ProcExit))
-        throw e;
+var ZxBridgeCore = class _ZxBridgeCore {
+  #intervals = /* @__PURE__ */ new Map();
+  #handler;
+  #fetchCompleteHandler;
+  constructor(exports) {
+    this._alloc = exports.__zx_alloc;
+    this.#handler = wrapPromisingExport(exports.__zx_cb);
+    const fetchCompleteHandler = wrapPromisingExport(exports.__zx_fetch_complete);
+    if (!fetchCompleteHandler) {
+      throw new Error("__zx_fetch_complete not exported from WASM");
     }
-    return Promise.resolve();
+    this.#fetchCompleteHandler = fetchCompleteHandler;
+    if (exports.memory) jsz.memory = exports.memory;
   }
-  const start = WebAssembly.promising(instance.exports._start);
-  return start().catch((e) => {
-    if (e instanceof Error && e.message.startsWith("proc_exit"))
+  /** Invoke the unified callback handler */
+  #invoke(type, id, data) {
+    const handler = this.#handler;
+    if (!handler) {
+      console.warn("__zx_cb not exported from WASM");
       return;
-    throw e;
-  }).finally(() => {
-    if (wsState.recvResolve) {
-      const res = wsState.recvResolve;
-      wsState.recvResolve = null;
-      res(null);
     }
-  });
-}
-function parseEdgeMeta(stderrText) {
-  const meta = { status: 200, headers: new Headers, streaming: false };
-  const metaPrefix = "__EDGE_META__:";
-  const metaLine = stderrText.split(`
-`).find((line) => line.startsWith(metaPrefix));
-  if (metaLine) {
+    const dataRef = storeValueGetRef(data);
+    invokeWasmExport(handler, type, id, dataRef);
+  }
+  /**
+   * Async fetch with full options support.
+   * Calls __zx_fetch_complete when done.
+   */
+  fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) {
+    const url = readString(urlPtr, urlLen);
+    const method = methodLen > 0 ? readString(methodPtr, methodLen) : "GET";
+    const headersJson = headersLen > 0 ? readString(headersPtr, headersLen) : "{}";
+    const body = bodyLen > 0 ? getMemoryView().subarray(bodyPtr, bodyPtr + bodyLen) : void 0;
+    let headers = {};
     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);
+      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);
         }
       }
-    } catch {}
+    }
+    const controller = new AbortController();
+    const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
+    const fetchOptions = {
+      method,
+      headers: Object.keys(headers).length > 0 ? headers : void 0,
+      body: method !== "GET" && method !== "HEAD" ? body : void 0,
+      signal: controller.signal
+    };
+    fetch(url, fetchOptions).then(async (response) => {
+      if (timeout) clearTimeout(timeout);
+      const bytes = new Uint8Array(await response.arrayBuffer());
+      this._notifyFetchComplete(fetchId, response.status, bytes, false);
+    }).catch((error) => {
+      if (timeout) clearTimeout(timeout);
+      const isAbort = error.name === "AbortError";
+      const errorMsg = isAbort ? "Request timeout" : error.message ?? "Fetch failed";
+      this._notifyFetchComplete(fetchId, 0, errorMsg, true);
+    });
   }
-  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);
+  /** Notify WASM that a fetch completed. `body` is raw bytes on success, text on error. */
+  _notifyFetchComplete(fetchId, statusCode, body, isError) {
+    const handler = this.#fetchCompleteHandler;
+    const encoded = typeof body === "string" ? textEncoder.encode(body) : body;
+    const ptr = this._alloc(encoded.length);
+    writeBytes(ptr, encoded);
+    invokeWasmExport(handler, fetchId, statusCode, ptr, encoded.length, isError ? 1 : 0);
   }
-  const stdinData = request.body ? new Uint8Array(await request.arrayBuffer()) : undefined;
-  const stdoutChunks = [];
-  let streamWriter = null;
-  const { wasiImport, setMemory, collectOutput } = createWasiImports({
-    request,
-    stdinData,
-    onStdout: (chunk) => {
-      if (streamWriter)
-        streamWriter.write(chunk);
-      else
-        stdoutChunks.push(chunk);
+  /** Set a timeout and callback when it fires */
+  setTimeout(callbackId, delayMs) {
+    setTimeout(() => {
+      this.#invoke(CallbackType.Timeout, callbackId, null);
+    }, delayMs);
+  }
+  /** Set an interval and callback each time it fires */
+  setInterval(callbackId, intervalMs) {
+    const handle = setInterval(() => {
+      this.#invoke(CallbackType.Interval, callbackId, null);
+    }, intervalMs);
+    this.#intervals.set(callbackId, handle);
+  }
+  /** Clear an interval */
+  clearInterval(callbackId) {
+    const handle = this.#intervals.get(callbackId);
+    if (handle !== void 0) {
+      clearInterval(handle);
+      this.#intervals.delete(callbackId);
     }
-  });
-  let wasmMemory = null;
-  const mem = () => wasmMemory;
-  const bridgeRef = { current: null };
-  const Suspending = WebAssembly.Suspending;
-  const jspi = typeof Suspending === "function";
-  const wsState = {
-    upgraded: false,
-    server: null,
-    pendingWrites: [],
-    messageQueue: [],
-    recvResolve: null
-  };
-  const instance = new WebAssembly.Instance(module, {
-    wasi_snapshot_preview1: { ...wasi?.wasiImport, ...wasiImport },
-    __zx_sys: buildSysImports(jspi, Suspending),
-    __zx_ws: buildWsImports(jspi ? Suspending : null, mem, new TextDecoder, wsState),
-    __zx_kv: createKVImports(kvBindings ?? { default: createMemoryKV() }, mem),
-    __zx_db: createD1Imports(dbBindings ?? {}, mem),
-    __zx_net: createFetchImports(mem),
-    ...imports ? imports(mem) : {},
-    ...ZxWasiBridge.createImportObject(bridgeRef)
-  });
-  wasmMemory = instance.exports.memory;
-  setMemory(wasmMemory);
-  bridgeRef.current = new ZxWasiBridge(instance.exports);
-  const wasmPromise = executeWasm(instance, jspi, Suspending, wsState);
-  if (wsState.upgraded) {
-    const server = attachWebSocket(wsState);
-    ctx?.waitUntil(wasmPromise);
-    return new Response(null, { status: 101, webSocket: server.client });
   }
-  const { stderrText: earlyStderrText } = collectOutput();
-  const earlyMeta = parseEdgeMeta(earlyStderrText);
-  if (earlyMeta.streaming) {
-    const { readable, writable } = new TransformStream;
-    streamWriter = writable.getWriter();
-    for (const chunk of stdoutChunks)
-      streamWriter.write(chunk);
-    stdoutChunks.length = 0;
-    wasmPromise.finally(() => streamWriter?.close());
-    return new Response(readable, { status: earlyMeta.status, headers: earlyMeta.headers });
+  dispose() {
+    for (const handle of this.#intervals.values()) {
+      clearInterval(handle);
+    }
+    this.#intervals.clear();
+  }
+  /** Write a string to WASM memory, returning pointer and length */
+  _writeStringToWasm(str) {
+    return this._writeBytesToWasm(textEncoder.encode(str));
+  }
+  _writeBytesToWasm(data) {
+    const ptr = this._alloc(data.length);
+    writeBytes(ptr, data);
+    return { ptr, len: data.length };
+  }
+  /** Log a message from WASM at the given level (0=error, 1=warn, 2=info, 3=debug) */
+  static log(level, ptr, len) {
+    const msg = textDecoder.decode(getMemoryView().subarray(ptr, ptr + len));
+    switch (level) {
+      case 0:
+        console.error(msg);
+        break;
+      case 1:
+        console.warn(msg);
+        break;
+      case 3:
+        console.debug(msg);
+        break;
+      default:
+        console.log(msg);
+        break;
+    }
+  }
+  /**
+   * Create the core import object for WASM instantiation.
+   * Includes only environment-agnostic bindings: log, fetch, and timers.
+   * Use ZxBridge.createImportObject (from wasm/index.ts) in browser contexts
+   * to additionally include DOM and WebSocket bindings.
+   */
+  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),
+        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
+          bridgeRef.current?.fetchAsync(
+            urlPtr,
+            urlLen,
+            methodPtr,
+            methodLen,
+            headersPtr,
+            headersLen,
+            bodyPtr,
+            bodyLen,
+            timeoutMs,
+            fetchId
+          );
+        },
+        _setTimeout: (callbackId, delayMs) => {
+          bridgeRef.current?.setTimeout(callbackId, delayMs);
+        },
+        _setInterval: (callbackId, intervalMs) => {
+          bridgeRef.current?.setInterval(callbackId, intervalMs);
+        },
+        _clearInterval: (callbackId) => {
+          bridgeRef.current?.clearInterval(callbackId);
+        }
+      }
+    };
+  }
+};
+
+// src/wasm/index.ts
+var ZxBridge = class extends ZxBridgeCore {
+  #websockets = /* @__PURE__ */ new Map();
+  #wsOnOpenHandler;
+  #wsOnMessageHandler;
+  #wsOnErrorHandler;
+  #wsOnCloseHandler;
+  #eventbridge;
+  #eventbridgeAsync;
+  constructor(exports) {
+    super(exports);
+    this.#wsOnOpenHandler = wrapPromisingExport(exports.__zx_ws_onopen);
+    this.#wsOnMessageHandler = wrapPromisingExport(exports.__zx_ws_onmessage);
+    this.#wsOnErrorHandler = wrapPromisingExport(exports.__zx_ws_onerror);
+    this.#wsOnCloseHandler = wrapPromisingExport(exports.__zx_ws_onclose);
+    this.#eventbridge = exports.__zx_eventbridge;
+    this.#eventbridgeAsync = wrapPromisingExport(
+      exports.__zx_eventbridge_async ?? exports.__zx_eventbridge
+    );
   }
-  await wasmPromise;
-  const { stderrText } = collectOutput();
-  const meta = parseEdgeMeta(stderrText);
-  const body = mergeUint8Arrays(stdoutChunks);
-  meta.headers.delete("transfer-encoding");
-  if (!meta.headers.has("content-length"))
-    meta.headers.set("content-length", String(body.byteLength));
-  return new Response(body.buffer, { status: meta.status, headers: meta.headers });
-}
-// src/app.ts
-async function resolveModule(input) {
-  if (typeof input === "string") {
-    if (input.startsWith("http://") || input.startsWith("https://")) {
-      return WebAssembly.compileStreaming(fetch(input));
-    }
-    const url = input.startsWith("/") ? `file://${input}` : input;
-    return WebAssembly.compile(await fetch(url).then((r) => r.arrayBuffer()));
+  eventMaySuspend(velementId, eventTypeId) {
+    return !!((eventHandlerModes.get(velementId) ?? 0) & 1 << eventTypeId);
   }
-  if (input instanceof URL) {
-    return WebAssembly.compileStreaming(fetch(input));
+  setEventHandlerMode(velementId, eventTypeId, maySuspend) {
+    const bit = 1 << eventTypeId;
+    const current = eventHandlerModes.get(velementId) ?? 0;
+    const next = maySuspend ? current | bit : current & ~bit;
+    if (next === 0) eventHandlerModes.delete(velementId);
+    else eventHandlerModes.set(velementId, next);
   }
-  if (input instanceof Response) {
-    return WebAssembly.compileStreaming(input);
+  clearEventHandlerModes(velementId) {
+    eventHandlerModes.delete(velementId);
   }
-  if (input instanceof ArrayBuffer) {
-    return WebAssembly.compile(input);
+  /** 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);
+    });
   }
-  if (ArrayBuffer.isView(input)) {
-    return WebAssembly.compile(input.buffer);
+  /**
+   * Create and connect a WebSocket.
+   * Calls __zx_ws_onopen, __zx_ws_onmessage, __zx_ws_onerror, __zx_ws_onclose.
+   */
+  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 handler = this.#wsOnOpenHandler;
+        if (!handler) return;
+        const protocol = ws.protocol || "";
+        const { ptr, len } = this._writeStringToWasm(protocol);
+        invokeWasmExport(handler, wsId, ptr, len);
+      };
+      ws.onmessage = (event) => {
+        const handler = this.#wsOnMessageHandler;
+        if (!handler) return;
+        const isBinary = event.data instanceof ArrayBuffer;
+        const data = isBinary ? new Uint8Array(event.data) : textEncoder.encode(event.data);
+        const { ptr, len } = this._writeBytesToWasm(data);
+        invokeWasmExport(handler, wsId, ptr, len, isBinary ? 1 : 0);
+      };
+      ws.onerror = (_event) => {
+        const handler = this.#wsOnErrorHandler;
+        if (!handler) return;
+        const { ptr, len } = this._writeStringToWasm("WebSocket error");
+        invokeWasmExport(handler, wsId, ptr, len);
+      };
+      ws.onclose = (event) => {
+        const handler = this.#wsOnCloseHandler;
+        if (!handler) return;
+        const reason = event.reason || "";
+        const { ptr, len } = this._writeStringToWasm(reason);
+        invokeWasmExport(handler, wsId, event.code, ptr, len, event.wasClean ? 1 : 0);
+        this.#websockets.delete(wsId);
+      };
+      this.#websockets.set(wsId, ws);
+    } catch (error) {
+      const handler = this.#wsOnErrorHandler;
+      if (handler) {
+        const msg = error instanceof Error ? error.message : "WebSocket connection failed";
+        const { ptr, len } = this._writeStringToWasm(msg);
+        invokeWasmExport(handler, wsId, ptr, len);
+      }
+    }
   }
-  return input;
-}
-
-class Ziex {
-  options;
-  resolved = null;
-  constructor(options) {
-    this.options = options;
+  /** 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();
+    if (isBinary) {
+      ws.send(memory.slice(dataPtr, dataPtr + dataLen));
+    } else {
+      ws.send(textDecoder.decode(memory.subarray(dataPtr, dataPtr + dataLen)));
+    }
   }
-  async getModule() {
-    if (!this.resolved)
-      this.resolved = await resolveModule(this.options.module);
-    return this.resolved;
+  /** 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();
+    }
   }
-  resolveKV(env) {
-    const { kv } = this.options;
-    if (kv === undefined)
-      return;
-    if (typeof kv === "object" && kv !== null) {
-      const result = {};
-      for (const [name, key] of Object.entries(kv)) {
-        result[name] = env[key];
+  dispose() {
+    super.dispose();
+    eventHandlerModes.clear();
+    for (const ws of this.#websockets.values()) {
+      try {
+        ws.close();
+      } catch {
       }
-      return result;
     }
-    return { default: env[kv] };
+    this.#websockets.clear();
   }
-  resolveDB(env) {
-    const { db } = this.options;
-    if (db === undefined)
+  /** Handle a DOM event (called by event delegation) */
+  eventbridge(velementId, eventTypeId, event) {
+    const eventRef = storeValueGetRef(event);
+    if (this.eventMaySuspend(velementId, eventTypeId)) {
+      invokeWasmExport(this.#eventbridgeAsync, velementId, eventTypeId, eventRef);
       return;
-    if (typeof db === "object" && db !== null) {
-      const result = {};
-      for (const [name, key] of Object.entries(db)) {
-        result[name] = env[key];
+    }
+    invokeWasmExport(this.#eventbridge, velementId, 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.current?.setEventHandlerMode(vnodeId, eventTypeId, maySuspend !== 0);
+        },
+        _clearEventHandlerModes: (vnodeId) => {
+          bridgeRef.current?.clearEventHandlerModes(vnodeId);
+        },
+        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
+          bridgeRef.current?.fetchAsync(
+            urlPtr,
+            urlLen,
+            methodPtr,
+            methodLen,
+            headersPtr,
+            headersLen,
+            bodyPtr,
+            bodyLen,
+            timeoutMs,
+            fetchId
+          );
+        },
+        _setTimeout: (callbackId, delayMs) => {
+          bridgeRef.current?.setTimeout(callbackId, delayMs);
+        },
+        _setInterval: (callbackId, intervalMs) => {
+          bridgeRef.current?.setInterval(callbackId, intervalMs);
+        },
+        _clearInterval: (callbackId) => {
+          bridgeRef.current?.clearInterval(callbackId);
+        },
+        // WebSocket API
+        _wsConnect: (wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) => {
+          bridgeRef.current?.wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen);
+        },
+        _wsSend: (wsId, dataPtr, dataLen, isBinary) => {
+          bridgeRef.current?.wsSend(wsId, dataPtr, dataLen, isBinary);
+        },
+        _wsClose: (wsId, code, reasonPtr, reasonLen) => {
+          bridgeRef.current?.wsClose(wsId, code, reasonPtr, reasonLen);
+        },
+        _ce: (id, vnodeId) => {
+          const tagName = TAG_NAMES[id];
+          const el = id >= SVG_TAG_START_INDEX ? document.createElementNS("http://www.w3.org/2000/svg", tagName) : document.createElement(tagName);
+          el.__zx_ref = Number(vnodeId);
+          domNodes.set(vnodeId, el);
+          return storeValueGetRef(el);
+        },
+        _ct: (ptr, len, vnodeId) => {
+          const text = readString(ptr, len);
+          const node = document.createTextNode(text);
+          node.__zx_ref = Number(vnodeId);
+          domNodes.set(vnodeId, node);
+          return storeValueGetRef(node);
+        },
+        _sa: (vnodeId, namePtr, nameLen, valPtr, valLen) => {
+          domNodes.get(vnodeId)?.setAttribute(readString(namePtr, nameLen), readString(valPtr, valLen));
+        },
+        _sp: (vnodeId, namePtr, nameLen, valPtr, valLen) => {
+          const el = domNodes.get(vnodeId);
+          if (el) {
+            const name = readString(namePtr, nameLen);
+            const val = readString(valPtr, valLen);
+            if (name === "checked" || name === "selected" || name === "muted") {
+              el[name] = val !== "false";
+            } else {
+              el[name] = val;
+            }
+          }
+        },
+        _ra: (vnodeId, namePtr, nameLen) => {
+          domNodes.get(vnodeId)?.removeAttribute(readString(namePtr, nameLen));
+        },
+        _snv: (vnodeId, ptr, len) => {
+          const node = domNodes.get(vnodeId);
+          if (node) node.nodeValue = readString(ptr, len);
+        },
+        _srh: (vnodeId, ptr, len) => {
+          const el = domNodes.get(vnodeId);
+          if (el) el.innerHTML = readString(ptr, len);
+        },
+        _ac: (parentId, childId) => {
+          const parent = domNodes.get(parentId);
+          const child = domNodes.get(childId);
+          if (parent && child) parent.appendChild(child);
+        },
+        _ib: (parentId, childId, refId) => {
+          const parent = domNodes.get(parentId);
+          const child = domNodes.get(childId);
+          const ref = domNodes.get(refId) ?? null;
+          if (parent && child) parent.insertBefore(child, ref);
+        },
+        _rc: (parentId, childId) => {
+          const parent = domNodes.get(parentId);
+          const child = domNodes.get(childId);
+          if (parent && child) {
+            parent.removeChild(child);
+            cleanupDomNodes(child);
+          }
+        },
+        _rpc: (parentId, newId, oldId) => {
+          const parent = domNodes.get(parentId);
+          const newChild = domNodes.get(newId);
+          const oldChild = domNodes.get(oldId);
+          if (parent && newChild && oldChild) {
+            parent.replaceChild(newChild, oldChild);
+            cleanupDomNodes(oldChild);
+          }
+        },
+        _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: (vnodeId, bufPtr, bufLen) => {
+          const form = domNodes.get(vnodeId);
+          if (!form || !(form instanceof HTMLFormElement)) return 0;
+          const formData = new FormData(form);
+          const urlEncoded = new URLSearchParams(formData).toString();
+          const bytes = textEncoder.encode(urlEncoded);
+          const len = Math.min(bytes.length, bufLen);
+          writeBytes(bufPtr, bytes.subarray(0, len));
+          return len;
+        },
+        _submitFormAction: (vnodeId, actionId) => {
+          const form = domNodes.get(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(vnodeId);
+          if (!form || !(form instanceof HTMLFormElement)) return;
+          const statesJson = statesLen > 0 ? readString(statesPtr, statesLen) : "[]";
+          bridgeRef.current?.submitFormActionAsync(form, actionId, statesJson, fetchId);
+        }
       }
-      return result;
-    }
-    return { default: env[db] };
+    };
   }
-  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 !== undefined ? env[websocket] : undefined
-    });
-  };
+};
+var domNodes = /* @__PURE__ */ new Map();
+function cleanupDomNodes(node) {
+  const ref = node.__zx_ref;
+  if (ref !== void 0) domNodes.delete(BigInt(ref));
+  const children = node.childNodes;
+  for (let i = 0; i < children.length; i++) cleanupDomNodes(children[i]);
 }
+var SVG_TAG_START_INDEX = 140;
+var TAG_NAMES = [
+  "aside",
+  "fragment",
+  "iframe",
+  "slot",
+  "img",
+  "html",
+  "base",
+  "head",
+  "link",
+  "meta",
+  "script",
+  "style",
+  "title",
+  "address",
+  "article",
+  "body",
+  "h1",
+  "h6",
+  "footer",
+  "header",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "hgroup",
+  "nav",
+  "section",
+  "dd",
+  "dl",
+  "dt",
+  "div",
+  "figcaption",
+  "figure",
+  "hr",
+  "li",
+  "ol",
+  "ul",
+  "menu",
+  "main",
+  "p",
+  "picture",
+  "pre",
+  "a",
+  "abbr",
+  "b",
+  "bdi",
+  "bdo",
+  "br",
+  "cite",
+  "code",
+  "data",
+  "time",
+  "dfn",
+  "em",
+  "i",
+  "kbd",
+  "mark",
+  "q",
+  "blockquote",
+  "rp",
+  "ruby",
+  "rt",
+  "rtc",
+  "rb",
+  "s",
+  "del",
+  "ins",
+  "samp",
+  "small",
+  "span",
+  "strong",
+  "sub",
+  "sup",
+  "u",
+  "var",
+  "wbr",
+  "area",
+  "map",
+  "audio",
+  "source",
+  "track",
+  "video",
+  "embed",
+  "object",
+  "param",
+  "canvas",
+  "noscript",
+  "caption",
+  "table",
+  "col",
+  "colgroup",
+  "tbody",
+  "tr",
+  "thead",
+  "tfoot",
+  "td",
+  "th",
+  "button",
+  "datalist",
+  "option",
+  "fieldset",
+  "label",
+  "form",
+  "input",
+  "keygen",
+  "legend",
+  "meter",
+  "optgroup",
+  "select",
+  "output",
+  "progress",
+  "textarea",
+  "details",
+  "dialog",
+  "menuitem",
+  "summary",
+  "content",
+  "element",
+  "shadow",
+  "template",
+  "acronym",
+  "applet",
+  "basefont",
+  "font",
+  "big",
+  "blink",
+  "center",
+  "command",
+  "dir",
+  "frame",
+  "frameset",
+  "isindex",
+  "listing",
+  "marquee",
+  "noembed",
+  "plaintext",
+  "spacer",
+  "strike",
+  "tt",
+  "xmp",
+  // SVG Tags
+  "animate",
+  "animateMotion",
+  "animateTransform",
+  "circle",
+  "clipPath",
+  "defs",
+  "desc",
+  "ellipse",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feDistantLight",
+  "feDropShadow",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "fePointLight",
+  "feSpecularLighting",
+  "feSpotLight",
+  "feTile",
+  "feTurbulence",
+  "filter",
+  "foreignObject",
+  "g",
+  "image",
+  "line",
+  "linearGradient",
+  "marker",
+  "mask",
+  "metadata",
+  "mpath",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "radialGradient",
+  "rect",
+  "set",
+  "stop",
+  "svg",
+  "switch",
+  "symbol",
+  "text",
+  "textPath",
+  "tspan",
+  "use",
+  "view"
+];
+var eventHandlerModes = /* @__PURE__ */ new Map();
+
 // src/cloudflare/do.ts
 function createWebSocketDO(module, options) {
   return class ZxWebSocketDO {
-    doState;
-    env;
-    connections = new Map;
     constructor(state, env) {
+      /** All active connections in this room, keyed by their server-side WebSocket. */
+      this.connections = /* @__PURE__ */ new Map();
       this.doState = state;
       this.env = env;
     }
     async fetch(request) {
-      const stdinData = request.body ? new Uint8Array(await request.arrayBuffer()) : undefined;
+      const stdinData = request.body ? new Uint8Array(await request.arrayBuffer()) : void 0;
       const { wasiImport, setMemory } = createWasiImports({ request, stdinData });
       let wasmMemory = null;
       const mem = () => wasmMemory;
@@ -2228,7 +2042,7 @@ function createWebSocketDO(module, options) {
       const bridgeImports = ZxBridge.createImportObject(bridgeRef);
       const Suspending = WebAssembly.Suspending;
       const jspi = typeof Suspending === "function";
-      const decoder3 = new TextDecoder;
+      const decoder3 = new TextDecoder();
       let _resolveFirstSuspend;
       const firstSuspendPromise = new Promise((resolve) => {
         _resolveFirstSuspend = resolve;
@@ -2241,7 +2055,7 @@ function createWebSocketDO(module, options) {
         messageQueue: [],
         recvResolve: null,
         _resolveFirstSuspend,
-        topics: new Set,
+        topics: /* @__PURE__ */ new Set(),
         subscribe: (topic) => connState.topics.add(topic),
         unsubscribe: (topic) => connState.topics.delete(topic),
         publish: (topic, data) => {
@@ -2251,7 +2065,8 @@ function createWebSocketDO(module, options) {
               try {
                 ws.send(data);
                 count++;
-              } catch {}
+              } catch {
+              }
             }
           }
           if (!connState.server && connState.topics.has(topic)) {
@@ -2263,7 +2078,8 @@ 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: jspi ? new Suspending(async (ms) => new Promise((r) => setTimeout(r, ms))) : (_ms) => {
+        }
       };
       const wsImports = buildWsImports(jspi ? Suspending : null, mem, decoder3, connState);
       const kvBindings = options?.kv?.(this.env);
@@ -2284,12 +2100,10 @@ function createWebSocketDO(module, options) {
       const start = WebAssembly.promising(instance.exports._start);
       const wasmPromise = start().catch((e) => {
         wasmExited = true;
-        if (e instanceof Error && e.message.startsWith("proc_exit"))
-          return;
+        if (e instanceof Error && e.message.startsWith("proc_exit")) return;
         console.error("[ZxWebSocketDO] WASM error:", e);
       }).finally(() => {
-        if (connState.server)
-          this.connections.delete(connState.server);
+        if (connState.server) this.connections.delete(connState.server);
         if (connState.recvResolve) {
           const res = connState.recvResolve;
           connState.recvResolve = null;
@@ -2308,8 +2122,8 @@ function createWebSocketDO(module, options) {
   };
 }
 export {
-  exports_runtime as worker,
-  exports_kv as kv,
+  Ziex,
   createWebSocketDO,
-  Ziex
+  kv_exports as kv,
+  runtime_exports as worker
 };