ziex 0.1.0-dev.1389 → 0.1.0-dev.1466

package/wasm/init.dev.js

@@ -1,3 +1,27 @@
+// src/wasm/constants.ts
+var DOM_CMD_HEADER_SIZE = 8;
+var DOM_CMD_RECORD_SIZE = 24;
+var DomOp_CreateElement = 1;
+var DomOp_CreateText = 2;
+var DomOp_HydrateInsert = 3;
+var DomOp_SetAttr = 4;
+var DomOp_SetProp = 5;
+var DomOp_RemoveAttr = 6;
+var DomOp_SetNodeValue = 7;
+var DomOp_SetInnerHtml = 8;
+var DomOp_AppendChild = 9;
+var DomOp_InsertBefore = 10;
+var DomOp_RemoveChild = 11;
+var DomOp_ReplaceChild = 12;
+var CallbackType_FetchSuccess = 1;
+var CallbackType_FetchError = 2;
+var CallbackType_Timeout = 3;
+var CallbackType_Interval = 4;
+var CallbackType_WebSocketOpen = 5;
+var CallbackType_WebSocketMessage = 6;
+var CallbackType_WebSocketError = 7;
+var CallbackType_WebSocketClose = 8;
+
 // ../../vendor/jsz/js/src/zigjs.ts
 var NAN_PREFIX = 2146959360;
 var predefined = {
@@ -51,6 +75,10 @@ var ZigJS = class {
    * */
   valueGet(out, id, ptr, len) {
     const val = this.loadValue(id);
+    if (val === null || val === void 0 || typeof val !== "object" && typeof val !== "function") {
+      this.storeValue(out, void 0);
+      return;
+    }
     const str = this.loadString(ptr, len);
     const result = Reflect.get(val, str);
     this.storeValue(out, result);
@@ -99,11 +127,15 @@ var ZigJS = class {
    * */
   valueStringCopy(id, ptr, max) {
     if (this.memory == null) return;
+    const dest = ptr >>> 0;
+    const cap = max >>> 0;
     const val = this.loadValue(id);
+    if (typeof val !== "string") return;
     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);
+    if (bytes.byteLength > cap || bytes.length === 0) return;
+    const buf = this.memory.buffer;
+    if (dest + bytes.length > buf.byteLength) return;
+    new Uint8Array(buf, dest, bytes.length).set(bytes);
   }
   /**
    * Call a constructor given by id.
@@ -111,8 +143,10 @@ var ZigJS = class {
   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 base = argsAddr >>> 0;
+    const count = argsLen >>> 0;
+    for (let i = 0; i < count; i++) {
+      args.push(this.loadRef(base + i * 8));
     }
     const result = Reflect.construct(fn, args);
     this.storeValue(out, result);
@@ -122,13 +156,23 @@ var ZigJS = class {
    * */
   funcApply(out, id, thisRefAddr, argsAddr, argsLen) {
     const fn = this.loadValue(id);
-    const thisVal = this.loadRef(thisRefAddr);
+    const thisVal = this.loadRef(thisRefAddr >>> 0);
     const args = [];
-    for (let i = 0; i < argsLen; i++) {
-      args.push(this.loadRef(argsAddr + i * 8));
+    const base = argsAddr >>> 0;
+    const count = argsLen >>> 0;
+    for (let i = 0; i < count; i++) {
+      args.push(this.loadRef(base + i * 8));
+    }
+    if (typeof fn !== "function") {
+      this.storeValue(out, void 0);
+      return;
+    }
+    try {
+      const result = Reflect.apply(fn, thisVal, args);
+      this.storeValue(out, result);
+    } catch {
+      this.storeValue(out, void 0);
     }
-    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
@@ -149,19 +193,21 @@ var ZigJS = class {
   }
   loadRef(refAddr) {
     if (this.memory == null) return;
+    const addr = refAddr >>> 0;
     const view = new DataView(this.memory.buffer);
-    const floatVal = view.getFloat64(refAddr, true);
+    const floatVal = view.getFloat64(addr, true);
     if (!isNaN(floatVal)) return floatVal;
-    const id = this.loadRefId(refAddr);
+    const id = this.loadRefId(addr);
     return this.values[id];
   }
   loadRefId(refAddr) {
     if (this.memory == null) return 0;
-    return new DataView(this.memory.buffer).getUint32(refAddr, true);
+    return new DataView(this.memory.buffer).getUint32(refAddr >>> 0, true);
   }
   storeValue(out, val) {
     if (this.memory == null) return;
     const view = new DataView(this.memory.buffer);
+    out = out >>> 0;
     if (typeof val === "number") {
       if (isNaN(val)) {
         view.setUint32(out, predefined.nan, true);
@@ -215,13 +261,17 @@ var ZigJS = class {
   }
   loadString(ptr, len) {
     if (this.memory == null) return "";
-    const arr = new Uint8ClampedArray(this.memory.buffer, ptr, Number(len));
+    const start = ptr >>> 0;
+    const length = Number(len) >>> 0;
+    const buf = this.memory.buffer;
+    if (length === 0 || start + length > buf.byteLength) return "";
+    const arr = new Uint8ClampedArray(buf, start, length);
     const data = arr.slice();
     return decoder.decode(data);
   }
 };
 
-// src/fetch.ts
+// src/runtime/fetch.ts
 function createFetchImports(getMemory) {
   const encoder2 = new TextEncoder();
   const decoder2 = new TextDecoder();
@@ -288,17 +338,6 @@ 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);
@@ -309,6 +348,20 @@ function storeValueGetRef(val) {
   jsz.memory = originalMemory;
   return tempRefView.getBigUint64(0, true);
 }
+function loadValueFromRef(ref) {
+  tempRefView.setBigUint64(0, ref, true);
+  const originalMemory = jsz.memory;
+  jsz.memory = { buffer: tempRefBuffer };
+  const val = jsz.loadRef(0);
+  jsz.memory = originalMemory;
+  return val;
+}
+function releaseValueRef(ref) {
+  tempRefView.setBigUint64(0, ref, true);
+  if (!Number.isNaN(tempRefView.getFloat64(0, true))) return;
+  const id = tempRefView.getUint32(0, true);
+  if (id > 6) jsz.deleteValue(id);
+}
 var textDecoder = new TextDecoder();
 var textEncoder = new TextEncoder();
 var memoryView = null;
@@ -321,20 +374,19 @@ function getMemoryView() {
   }
   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;
+  const start = ptr >>> 0;
+  const length = len >>> 0;
+  if (length === 0) return "";
+  const view = getMemoryView();
+  if (start + length > view.byteLength) return "";
+  return textDecoder.decode(view.subarray(start, start + length));
 }
 function writeBytes(ptr, data) {
-  getMemoryView().set(data, ptr);
+  const start = ptr >>> 0;
+  const view = getMemoryView();
+  if (start + data.length > view.byteLength) return;
+  view.set(data, start);
 }
 function wrapPromisingExport(fn) {
   if (!fn) return void 0;
@@ -354,30 +406,26 @@ function invokeWasmExport(fn, ...args) {
 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");
+    if (!this.#handler) {
+      console.warn("__zx_cb not exported from WASM");
     }
-    this.#fetchCompleteHandler = fetchCompleteHandler;
     if (exports.memory) jsz.memory = exports.memory;
   }
   /** Invoke the unified callback handler */
-  #invoke(type, id, data) {
+  _invoke(type, id, a = 0n, b = 0n, c = 0n) {
     const handler = this.#handler;
     if (!handler) {
       console.warn("__zx_cb not exported from WASM");
       return;
     }
-    const dataRef = storeValueGetRef(data);
-    invokeWasmExport(handler, type, id, dataRef);
+    invokeWasmExport(handler, type, id, a, b, c);
   }
   /**
    * Async fetch with full options support.
-   * Calls __zx_fetch_complete when done.
+   * Completes via `__zx_cb(fetch_success|fetch_error, ...)`.
    */
   fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) {
     const url = readString(urlPtr, urlLen);
@@ -416,22 +464,23 @@ var ZxBridgeCore = class _ZxBridgeCore {
   }
   /** 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);
+    const ptr = this._alloc(encoded.length) >>> 0;
+    if (!ptr && encoded.length > 0) return;
     writeBytes(ptr, encoded);
-    invokeWasmExport(handler, fetchId, statusCode, ptr, encoded.length, isError ? 1 : 0);
+    const type = isError ? CallbackType_FetchError : CallbackType_FetchSuccess;
+    this._invoke(type, fetchId, BigInt(statusCode), BigInt(ptr), BigInt(encoded.length));
   }
   /** Set a timeout and callback when it fires */
   setTimeout(callbackId, delayMs) {
     setTimeout(() => {
-      this.#invoke(CallbackType.Timeout, callbackId, null);
+      this._invoke(CallbackType_Timeout, callbackId);
     }, delayMs);
   }
   /** Set an interval and callback each time it fires */
   setInterval(callbackId, intervalMs) {
     const handle = setInterval(() => {
-      this.#invoke(CallbackType.Interval, callbackId, null);
+      this._invoke(CallbackType_Interval, callbackId);
     }, intervalMs);
     this.#intervals.set(callbackId, handle);
   }
@@ -449,18 +498,24 @@ var ZxBridgeCore = class _ZxBridgeCore {
     }
     this.#intervals.clear();
   }
-  /** Write a string to WASM memory, returning pointer and length */
+  /** Write a string to WASM memory, returning `[ptr, len]`. */
   _writeStringToWasm(str) {
-    return this._writeBytesToWasm(textEncoder.encode(str));
+    return this.writeBytesToWasm(textEncoder.encode(str));
   }
-  _writeBytesToWasm(data) {
-    const ptr = this._alloc(data.length);
+  writeBytesToWasm(data) {
+    if (data.length === 0) return [0, 0];
+    const ptr = this._alloc(data.length) >>> 0;
+    if (!ptr) return [0, 0];
     writeBytes(ptr, data);
-    return { ptr, len: data.length };
+    return [ptr, 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));
+    const start = ptr >>> 0;
+    const length = len >>> 0;
+    const view = getMemoryView();
+    if (start + length > view.byteLength) return;
+    const msg = textDecoder.decode(view.subarray(start, start + length));
     switch (level) {
       case 0:
         console.error(msg);
@@ -492,7 +547,7 @@ var ZxBridgeCore = class _ZxBridgeCore {
       __zx: {
         _log: (level, ptr, len) => _ZxBridgeCore.log(level, ptr, len),
         _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
-          bridgeRef.current?.fetchAsync(
+          bridgeRef[0]?.fetchAsync(
             urlPtr,
             urlLen,
             methodPtr,
@@ -506,542 +561,41 @@ var ZxBridgeCore = class _ZxBridgeCore {
           );
         },
         _setTimeout: (callbackId, delayMs) => {
-          bridgeRef.current?.setTimeout(callbackId, delayMs);
+          bridgeRef[0]?.setTimeout(callbackId, delayMs);
         },
         _setInterval: (callbackId, intervalMs) => {
-          bridgeRef.current?.setInterval(callbackId, intervalMs);
+          bridgeRef[0]?.setInterval(callbackId, intervalMs);
         },
         _clearInterval: (callbackId) => {
-          bridgeRef.current?.clearInterval(callbackId);
+          bridgeRef[0]?.clearInterval(callbackId);
         }
       }
     };
   }
 };
-
-// src/kv.ts
-function putOptions(ttlSeconds) {
-  if (ttlSeconds < 60) return void 0;
-  return { expirationTtl: ttlSeconds };
-}
-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 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, encoder2.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, encoder2.encode("[]"));
-        const prefix = readStr(pfx_ptr, pfx_len);
-        const result = b.listSync(prefix.length > 0 ? { prefix } : void 0);
-        return writeBytes2(buf_ptr, buf_max, encoder2.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, encoder2.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, encoder2.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, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
-    })
-  };
-}
-
-// src/browser/kv.ts
-function getIndexedDb() {
-  if (typeof indexedDB === "undefined") {
-    throw new Error("IndexedDB is not available in this environment");
-  }
-  return indexedDB;
-}
-function requestToPromise(request) {
-  return new Promise((resolve, reject) => {
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
-  });
-}
-function transactionToPromise(transaction) {
-  return new Promise((resolve, reject) => {
-    transaction.oncomplete = () => resolve();
-    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
-    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed"));
-  });
-}
-function createIndexedDbKV(options = {}) {
-  const databaseName = options.databaseName ?? "ziex-kv";
-  const storeName = options.storeName ?? "kv";
-  const namespace = options.namespace ?? "default";
-  const dbPromise = new Promise((resolve, reject) => {
-    const request = getIndexedDb().open(databaseName, 1);
-    request.onupgradeneeded = () => {
-      const db = request.result;
-      if (!db.objectStoreNames.contains(storeName)) {
-        db.createObjectStore(storeName);
-      }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
-  });
-  const scopedKey = (key) => `${namespace}:${key}`;
-  return {
-    async get(key) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readonly");
-      const store = tx.objectStore(storeName);
-      const value = await requestToPromise(store.get(scopedKey(key)));
-      await transactionToPromise(tx);
-      console.debug(`KV GET - Key: ${key}, Value: ${value}`);
-      return typeof value === "string" ? value : null;
-    },
-    async put(key, value) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readwrite");
-      tx.objectStore(storeName).put(value, scopedKey(key));
-      await transactionToPromise(tx);
-      console.debug(`KV PUT - Key: ${key}, Value: ${value}`);
-    },
-    async delete(key) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readwrite");
-      tx.objectStore(storeName).delete(scopedKey(key));
-      await transactionToPromise(tx);
-    },
-    async list(options2) {
-      const db = await dbPromise;
-      const tx = db.transaction(storeName, "readonly");
-      const store = tx.objectStore(storeName);
-      const keys = await requestToPromise(store.getAllKeys());
-      await transactionToPromise(tx);
-      const prefix = scopedKey(options2?.prefix ?? "");
-      return {
-        keys: keys.filter((key) => typeof key === "string" && key.startsWith(prefix)).map((key) => ({ name: key.slice(namespace.length + 1) }))
-      };
-    }
-  };
-}
-function getLocalStorage() {
-  if (typeof localStorage === "undefined") {
-    throw new Error("localStorage is not available in this environment");
+function writeBytesOut(getMemory, allocRef, outPtrAddr, data) {
+  if (data.length === 0) {
+    new DataView(getMemory().buffer).setUint32(outPtrAddr, 0, true);
+    return 0;
   }
-  return localStorage;
-}
-function createLocalStorageKV(options = {}) {
-  const storage = getLocalStorage();
-  const namespace = options.namespace ?? "default";
-  const storagePrefix = options.storagePrefix ?? "ziex-kv";
-  const scopedKey = (key) => `${storagePrefix}:${namespace}:${key}`;
-  const namespacePrefix = scopedKey("");
-  return {
-    getSync(key) {
-      return storage.getItem(scopedKey(key));
-    },
-    async get(key) {
-      return this.getSync(key);
-    },
-    putSync(key, value) {
-      storage.setItem(scopedKey(key), value);
-    },
-    async put(key, value) {
-      this.putSync(key, value);
-    },
-    deleteSync(key) {
-      storage.removeItem(scopedKey(key));
-    },
-    async delete(key) {
-      this.deleteSync(key);
-    },
-    listSync(options2) {
-      const prefix = namespacePrefix + (options2?.prefix ?? "");
-      const keys = [];
-      for (let i = 0; i < storage.length; i += 1) {
-        const key = storage.key(i);
-        if (!key || !key.startsWith(prefix)) continue;
-        keys.push({ name: key.slice(namespacePrefix.length) });
-      }
-      return { keys };
-    },
-    async list(options2) {
-      return this.listSync(options2);
-    }
-  };
+  const alloc = allocRef[0];
+  if (!alloc) return -1;
+  const ptr = alloc(data.length) >>> 0;
+  if (!ptr) return -1;
+  const buffer = getMemory().buffer;
+  if (ptr + data.length > buffer.byteLength) return -1;
+  new Uint8Array(buffer, ptr, data.length).set(data);
+  new DataView(buffer).setUint32(outPtrAddr >>> 0, ptr, true);
+  return data.length;
 }
-function hasJSPI() {
-  return typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
+function writeJsonOut(getMemory, allocRef, outPtrAddr, value) {
+  return writeBytesOut(getMemory, allocRef, outPtrAddr, textEncoder.encode(JSON.stringify(value)));
 }
-function createBrowserKVBindings(options = {}) {
-  const namespace = options.namespace ?? "default";
-  return {
-    [namespace]: hasJSPI() ? createIndexedDbKV(options) : createLocalStorageKV(options)
-  };
+function bindWasmAlloc(allocRef, exports) {
+  allocRef[0] = exports.__zx_alloc;
 }
 
-// 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
-    );
-  }
-  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);
-  }
-  /** Submit a form action with bound-state round-trip. */
-  submitFormActionAsync(form, actionId, statesJson, fetchId) {
-    const formData = new FormData(form);
-    formData.append("__$states", statesJson);
-    fetch(window.location.href, {
-      method: "POST",
-      // `>>> 0` reinterprets the i32 from wasm as u32 (ids can exceed 2^31).
-      headers: { "x-action": String(actionId >>> 0) },
-      body: formData
-    }).then(async (response) => {
-      const text = await response.text();
-      this._notifyFetchComplete(fetchId, response.status, text, false);
-    }).catch((error) => {
-      const msg = error instanceof Error ? error.message : "Fetch failed";
-      this._notifyFetchComplete(fetchId, 0, msg, true);
-    });
-  }
-  /**
-   * Create and connect a WebSocket.
-   * 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);
-      }
-    }
-  }
-  /** 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)));
-    }
-  }
-  /** Close WebSocket connection */
-  wsClose(wsId, code, reasonPtr, reasonLen) {
-    const ws = this.#websockets.get(wsId);
-    if (!ws) return;
-    const reason = reasonLen > 0 ? readString(reasonPtr, reasonLen) : void 0;
-    try {
-      if (reason) ws.close(code, reason);
-      else ws.close(code);
-    } catch {
-      ws.close();
-    }
-  }
-  dispose() {
-    super.dispose();
-    eventHandlerModes.clear();
-    for (const ws of this.#websockets.values()) {
-      try {
-        ws.close();
-      } catch {
-      }
-    }
-    this.#websockets.clear();
-  }
-  /** 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;
-    }
-    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);
-        }
-      }
-    };
-  }
-};
-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;
+// src/wasm/generated/tags.ts
 var TAG_NAMES = [
   "aside",
   "fragment",
@@ -1183,7 +737,6 @@ var TAG_NAMES = [
   "strike",
   "tt",
   "xmp",
-  // SVG Tags
   "animate",
   "animateMotion",
   "animateTransform",
@@ -1242,112 +795,780 @@ var TAG_NAMES = [
   "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 },
-  // focus/blur do not bubble, so delegated handlers must listen to focusin/focusout.
-  { 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 }
+  "view",
+  "custom"
 ];
-var eventHandlerModes = /* @__PURE__ */ 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 !== void 0) {
-          bridge.eventbridge(BigInt(zxRef), delegatedEvent.eventTypeId, event);
-          if (event.cancelBubble) break;
+
+// src/wasm/generated/tag_indices.ts
+var SVG_TAG_START_INDEX = 140;
+var CUSTOM_TAG_INDEX = 199;
+
+// src/wasm/dom_cmd.ts
+function flushDomCmds(ptr, len, ctx) {
+  const start = ptr >>> 0;
+  const length = len >>> 0;
+  if (length < DOM_CMD_HEADER_SIZE) return;
+  const mem = getMemoryView();
+  if (start + length > mem.byteLength) return;
+  const view = new DataView(mem.buffer, mem.byteOffset + start, length);
+  const count = view.getUint32(0, true);
+  const recordsBytes = count * DOM_CMD_RECORD_SIZE;
+  if (DOM_CMD_HEADER_SIZE + recordsBytes > length) return;
+  const { domNodes: domNodes2, cleanupDomNodes: cleanupDomNodes2 } = ctx;
+  for (let i = 0; i < count; i++) {
+    const off = DOM_CMD_HEADER_SIZE + i * DOM_CMD_RECORD_SIZE;
+    const op = view.getUint8(off);
+    const p0 = view.getUint32(off + 4, true);
+    const p1 = view.getUint32(off + 8, true);
+    const p2 = view.getUint32(off + 12, true);
+    const p3 = view.getUint32(off + 16, true);
+    const p4 = view.getUint32(off + 20, true);
+    switch (op) {
+      case DomOp_CreateElement: {
+        const isCustom = p0 === CUSTOM_TAG_INDEX;
+        const tagName = isCustom ? readString(p2, p3) : TAG_NAMES[p0];
+        const el = !isCustom && p0 >= SVG_TAG_START_INDEX ? document.createElementNS("http://www.w3.org/2000/svg", tagName) : document.createElement(tagName);
+        el.__zx_ref = p1;
+        domNodes2.set(p1, el);
+        break;
+      }
+      case DomOp_CreateText: {
+        const node = document.createTextNode(readString(p0, p1));
+        node.__zx_ref = p2;
+        domNodes2.set(p2, node);
+        break;
+      }
+      case DomOp_HydrateInsert: {
+        const child = domNodes2.get(p0);
+        const ref = BigInt(p1) | BigInt(p2) << 32n;
+        const end = loadValueFromRef(ref);
+        if (!child || !end?.parentNode) break;
+        end.parentNode.insertBefore(child, end);
+        break;
+      }
+      case DomOp_SetAttr: {
+        domNodes2.get(p0)?.setAttribute(readString(p1, p2), readString(p3, p4));
+        break;
+      }
+      case DomOp_SetProp: {
+        const el = domNodes2.get(p0);
+        if (el) {
+          const name = readString(p1, p2);
+          const val = readString(p3, p4);
+          if (name === "checked" || name === "selected" || name === "muted") {
+            el[name] = val !== "false";
+          } else {
+            el[name] = val;
+          }
         }
-        target = target.parentElement;
+        break;
       }
-    };
-    const options = { passive: delegatedEvent.domType.startsWith("touch") || delegatedEvent.domType === "scroll" };
-    root.addEventListener(delegatedEvent.domType, listener, options);
-    removers.push(() => root.removeEventListener(delegatedEvent.domType, listener, options));
+      case DomOp_RemoveAttr: {
+        domNodes2.get(p0)?.removeAttribute(readString(p1, p2));
+        break;
+      }
+      case DomOp_SetNodeValue: {
+        const node = domNodes2.get(p0);
+        if (node) node.nodeValue = readString(p1, p2);
+        break;
+      }
+      case DomOp_SetInnerHtml: {
+        const el = domNodes2.get(p0);
+        if (el) el.innerHTML = readString(p1, p2);
+        break;
+      }
+      case DomOp_AppendChild: {
+        const parent = domNodes2.get(p0);
+        const child = domNodes2.get(p1);
+        if (parent && child) parent.appendChild(child);
+        break;
+      }
+      case DomOp_InsertBefore: {
+        const parent = domNodes2.get(p0);
+        const child = domNodes2.get(p1);
+        const refNode = domNodes2.get(p2) ?? null;
+        if (parent && child) parent.insertBefore(child, refNode);
+        break;
+      }
+      case DomOp_RemoveChild: {
+        const parent = domNodes2.get(p0);
+        const child = domNodes2.get(p1);
+        if (parent && child) {
+          parent.removeChild(child);
+          cleanupDomNodes2(child);
+        }
+        break;
+      }
+      case DomOp_ReplaceChild: {
+        const parent = domNodes2.get(p0);
+        const newChild = domNodes2.get(p1);
+        const oldChild = domNodes2.get(p2);
+        if (parent && newChild && oldChild) {
+          parent.replaceChild(newChild, oldChild);
+          cleanupDomNodes2(oldChild);
+        }
+        break;
+      }
+      default:
+        break;
+    }
   }
-  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
-  };
+
+// src/runtime/kv/extern.ts
+function putOptions(ttlSeconds) {
+  if (ttlSeconds < 60) return void 0;
+  return { expirationTtl: ttlSeconds };
 }
-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
-  };
+function isSyncKVNamespace(binding) {
+  const candidate = binding;
+  return typeof candidate.getSync === "function" && typeof candidate.putSync === "function" && typeof candidate.deleteSync === "function" && typeof candidate.listSync === "function";
 }
-async function init(options = {}) {
-  const normalizedOptions = normalizeOptions(options);
-  if (activeRuntime) {
-    activeRuntime.dispose();
-    activeRuntime = null;
+function createKVImports(bindings, getMemory, allocRef) {
+  const encoder2 = new TextEncoder();
+  const decoder2 = new TextDecoder();
+  function readStr(ptr, len) {
+    return decoder2.decode(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, out_ptr) => {
+        const b = syncBinding2(readStr(ns_ptr, ns_len));
+        if (!b) return -1;
+        const value = b.getSync(readStr(key_ptr, key_len));
+        if (value === null) return -1;
+        return writeBytesOut(getMemory, allocRef, out_ptr, encoder2.encode(value));
+      },
+      kv_put: (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
+        const b = syncBinding2(readStr(ns_ptr, ns_len));
+        if (!b) return 0;
+        b.putSync(readStr(key_ptr, key_len), readStr(val_ptr, val_len), putOptions(ttl_seconds));
+        return 0;
+      },
+      kv_delete: (ns_ptr, ns_len, key_ptr, key_len) => {
+        const b = syncBinding2(readStr(ns_ptr, ns_len));
+        if (!b) return 0;
+        b.deleteSync(readStr(key_ptr, key_len));
+        return 0;
+      },
+      kv_list: (ns_ptr, ns_len, pfx_ptr, pfx_len, out_ptr) => {
+        const b = syncBinding2(readStr(ns_ptr, ns_len));
+        if (!b) return writeJsonOut(getMemory, allocRef, out_ptr, []);
+        const prefix = readStr(pfx_ptr, pfx_len);
+        const result = b.listSync(prefix.length > 0 ? { prefix } : void 0);
+        return writeJsonOut(getMemory, allocRef, out_ptr, result.keys.map((k) => k.name));
+      }
+    };
+  }
+  return {
+    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
+      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 writeBytesOut(getMemory, allocRef, out_ptr, encoder2.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, out_ptr) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b) return writeJsonOut(getMemory, allocRef, out_ptr, []);
+      const prefix = readStr(prefix_ptr, prefix_len);
+      const result = await b.list(prefix.length > 0 ? { prefix } : void 0);
+      const names = result.keys.map((k) => k.name);
+      if (names.length === 0) {
+        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+        return 0;
+      }
+      return writeJsonOut(getMemory, allocRef, out_ptr, names);
+    })
+  };
+}
+
+// src/runtime/kv/localstorage.ts
+function getLocalStorage() {
+  if (typeof localStorage === "undefined") {
+    throw new Error("localStorage is not available in this environment");
+  }
+  return localStorage;
+}
+function createLocalStorageKV(options = {}) {
+  const storage = getLocalStorage();
+  const namespace = options.namespace ?? "default";
+  const storagePrefix = options.storagePrefix ?? "ziex-kv";
+  const scopedKey = (key) => `${storagePrefix}:${namespace}:${key}`;
+  const namespacePrefix = scopedKey("");
+  return {
+    getSync(key) {
+      return storage.getItem(scopedKey(key));
+    },
+    async get(key) {
+      return this.getSync(key);
+    },
+    putSync(key, value) {
+      storage.setItem(scopedKey(key), value);
+    },
+    async put(key, value) {
+      this.putSync(key, value);
+    },
+    deleteSync(key) {
+      storage.removeItem(scopedKey(key));
+    },
+    async delete(key) {
+      this.deleteSync(key);
+    },
+    listSync(options2) {
+      const prefix = namespacePrefix + (options2?.prefix ?? "");
+      const keys = [];
+      for (let i = 0; i < storage.length; i += 1) {
+        const key = storage.key(i);
+        if (!key || !key.startsWith(prefix)) continue;
+        keys.push({ name: key.slice(namespacePrefix.length) });
+      }
+      return { keys };
+    },
+    async list(options2) {
+      return this.listSync(options2);
+    }
+  };
+}
+
+// src/runtime/kv/indexdb.ts
+function getIndexedDb() {
+  if (typeof indexedDB === "undefined") {
+    throw new Error("IndexedDB is not available in this environment");
+  }
+  return indexedDB;
+}
+function requestToPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+function transactionToPromise(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
+    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed"));
+  });
+}
+function createIndexedDbKV(options = {}) {
+  const databaseName = options.databaseName ?? "ziex-kv";
+  const storeName = options.storeName ?? "kv";
+  const namespace = options.namespace ?? "default";
+  const dbPromise = new Promise((resolve, reject) => {
+    const request = getIndexedDb().open(databaseName, 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName);
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
+  });
+  const scopedKey = (key) => `${namespace}:${key}`;
+  return {
+    async get(key) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readonly");
+      const store = tx.objectStore(storeName);
+      const value = await requestToPromise(store.get(scopedKey(key)));
+      await transactionToPromise(tx);
+      return typeof value === "string" ? value : null;
+    },
+    async put(key, value) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readwrite");
+      tx.objectStore(storeName).put(value, scopedKey(key));
+      await transactionToPromise(tx);
+    },
+    async delete(key) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readwrite");
+      tx.objectStore(storeName).delete(scopedKey(key));
+      await transactionToPromise(tx);
+    },
+    async list(options2) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readonly");
+      const store = tx.objectStore(storeName);
+      const keys = await requestToPromise(store.getAllKeys());
+      await transactionToPromise(tx);
+      const prefix = scopedKey(options2?.prefix ?? "");
+      return {
+        keys: keys.filter((key) => typeof key === "string" && key.startsWith(prefix)).map((key) => ({ name: key.slice(namespace.length + 1) }))
+      };
+    }
+  };
+}
+
+// src/runtime/kv.ts
+function hasJSPI() {
+  return typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
+}
+function createBrowserKVBindings(options = {}) {
+  const namespace = options.namespace ?? "default";
+  const isIndexedDb = hasJSPI() && !options.forceLocalStorage;
+  return {
+    [namespace]: isIndexedDb ? createIndexedDbKV(options) : createLocalStorageKV(options)
+  };
+}
+
+// src/wasm/generated/events.ts
+var DELEGATED_EVENTS = [
+  "click",
+  "dblclick",
+  "input",
+  "change",
+  "submit",
+  "focusin",
+  "focusout",
+  "keydown",
+  "keyup",
+  "keypress",
+  "mouseenter",
+  "mouseleave",
+  "mousedown",
+  "mouseup",
+  "mousemove",
+  "touchstart",
+  "touchend",
+  "touchmove",
+  "scroll",
+  "wheel",
+  "pointerdown",
+  "pointermove",
+  "pointerup",
+  "pointercancel",
+  "pointerenter",
+  "pointerleave",
+  "lostpointercapture"
+];
+
+// src/wasm/generated/event_bits.ts
+var HIGH_FREQ_EVENT_BITS = 3031040;
+
+// src/wasm/index.ts
+var ZxBridge = class extends ZxBridgeCore {
+  #websockets = /* @__PURE__ */ new Map();
+  #eventbridge;
+  #eventbridgeAsync;
+  constructor(exports) {
+    super(exports);
+    this.#eventbridge = exports.__zx_eventbridge;
+    this.#eventbridgeAsync = wrapPromisingExport(
+      exports.__zx_eventbridge_async ?? exports.__zx_eventbridge
+    );
+  }
+  hasEventHandler(velementId, eventTypeId) {
+    return !!((eventHandlersPresent.get(velementId) ?? 0) & 1 << eventTypeId);
+  }
+  eventMaySuspend(velementId, eventTypeId) {
+    return !!((eventHandlersSuspend.get(velementId) ?? 0) & 1 << eventTypeId);
+  }
+  setEventHandlerMode(velementId, eventTypeId, maySuspend) {
+    const bit = 1 << eventTypeId;
+    const present = (eventHandlersPresent.get(velementId) ?? 0) | bit;
+    eventHandlersPresent.set(velementId, present);
+    const suspendBits = eventHandlersSuspend.get(velementId) ?? 0;
+    const nextSuspend = maySuspend ? suspendBits | bit : suspendBits & ~bit;
+    if (nextSuspend === 0) eventHandlersSuspend.delete(velementId);
+    else eventHandlersSuspend.set(velementId, nextSuspend);
+    ensureDelegatedListener(eventTypeId);
+  }
+  clearEventHandlerModes(velementId) {
+    const present = eventHandlersPresent.get(velementId) ?? 0;
+    eventHandlersPresent.delete(velementId);
+    eventHandlersSuspend.delete(velementId);
+    for (let bits = present & HIGH_FREQ_EVENT_BITS; bits !== 0; bits &= bits - 1) {
+      maybeRemoveHighFreqListener(31 - Math.clz32(bits));
+    }
+  }
+  /** Submit a form action with bound-state round-trip. */
+  submitFormActionAsync(form, actionId, statesJson, fetchId) {
+    const formData = new FormData(form);
+    formData.append("__$states", statesJson);
+    fetch(window.location.href, {
+      method: "POST",
+      // `>>> 0` reinterprets the i32 from wasm as u32 (ids can exceed 2^31).
+      headers: { "x-action": String(actionId >>> 0) },
+      body: formData
+    }).then(async (response) => {
+      const text = await response.text();
+      this._notifyFetchComplete(fetchId, response.status, text, false);
+    }).catch((error) => {
+      const msg = error instanceof Error ? error.message : "Fetch failed";
+      this._notifyFetchComplete(fetchId, 0, msg, true);
+    });
+  }
+  /**
+   * Create and connect a WebSocket.
+   * Completes via `__zx_cb(ws_open|ws_message|ws_error|ws_close, ...)`.
+   */
+  wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) {
+    const url = readString(urlPtr, urlLen);
+    const protocolsStr = protocolsLen > 0 ? readString(protocolsPtr, protocolsLen) : "";
+    const protocols = protocolsStr ? protocolsStr.split(",").map((p) => p.trim()).filter(Boolean) : void 0;
+    try {
+      const ws = protocols && protocols.length > 0 ? new WebSocket(url, protocols) : new WebSocket(url);
+      ws.binaryType = "arraybuffer";
+      ws.onopen = () => {
+        const protocol = ws.protocol || "";
+        const [ptr, len] = this._writeStringToWasm(protocol);
+        this._invoke(CallbackType_WebSocketOpen, wsId, BigInt(ptr), BigInt(len));
+      };
+      ws.onmessage = (event) => {
+        const isBinary = event.data instanceof ArrayBuffer;
+        const data = isBinary ? new Uint8Array(event.data) : textEncoder.encode(event.data);
+        const [ptr, len] = this.writeBytesToWasm(data);
+        this._invoke(CallbackType_WebSocketMessage, wsId, BigInt(ptr), BigInt(len), BigInt(isBinary ? 1 : 0));
+      };
+      ws.onerror = (_event) => {
+        const [ptr, len] = this._writeStringToWasm("WebSocket error");
+        this._invoke(CallbackType_WebSocketError, wsId, BigInt(ptr), BigInt(len));
+      };
+      ws.onclose = (event) => {
+        const reason = event.reason || "";
+        const [ptr, len] = this._writeStringToWasm(reason);
+        const c = BigInt(len) | BigInt(event.wasClean ? 1 : 0) << 32n;
+        this._invoke(CallbackType_WebSocketClose, wsId, BigInt(event.code), BigInt(ptr), c);
+        this.#websockets.delete(wsId);
+      };
+      this.#websockets.set(wsId, ws);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "WebSocket connection failed";
+      const [ptr, len] = this._writeStringToWasm(msg);
+      this._invoke(CallbackType_WebSocketError, wsId, BigInt(ptr), BigInt(len));
+    }
+  }
+  /** Send data over WebSocket */
+  wsSend(wsId, dataPtr, dataLen, isBinary) {
+    const ws = this.#websockets.get(wsId);
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
+    const memory = getMemoryView();
+    const start = dataPtr >>> 0;
+    const length = dataLen >>> 0;
+    if (start + length > memory.byteLength) return;
+    if (isBinary) {
+      ws.send(memory.slice(start, start + length));
+    } else {
+      ws.send(textDecoder.decode(memory.subarray(start, start + length)));
+    }
+  }
+  /** Close WebSocket connection */
+  wsClose(wsId, code, reasonPtr, reasonLen) {
+    const ws = this.#websockets.get(wsId);
+    if (!ws) return;
+    const reason = reasonLen > 0 ? readString(reasonPtr, reasonLen) : void 0;
+    try {
+      if (reason) ws.close(code, reason);
+      else ws.close(code);
+    } catch {
+      ws.close();
+    }
+  }
+  dispose() {
+    super.dispose();
+    eventHandlersPresent.clear();
+    eventHandlersSuspend.clear();
+    for (const ws of this.#websockets.values()) {
+      try {
+        ws.close();
+      } catch {
+      }
+    }
+    this.#websockets.clear();
+  }
+  /**
+   * Dispatch to WASM for one vnode. Caller owns `eventRef` lifetime
+   * (store once per bubble, release after sync/async work completes).
+   */
+  eventbridge(velementId, eventTypeId, eventRef) {
+    const id = BigInt(velementId >>> 0);
+    if (this.eventMaySuspend(velementId, eventTypeId)) {
+      return invokeWasmExport(this.#eventbridgeAsync, id, eventTypeId, eventRef);
+    }
+    invokeWasmExport(this.#eventbridge, id, eventTypeId, eventRef);
+  }
+  /** Create the full browser import object for WASM instantiation (includes DOM + WebSocket). */
+  static createImportObject(bridgeRef) {
+    return {
+      ...jsz.importObject(),
+      __zx_net: createFetchImports(() => {
+        if (!jsz.memory) throw new Error("WASM memory is not ready");
+        return jsz.memory;
+      }),
+      __zx: {
+        _log: (level, ptr, len) => ZxBridgeCore.log(level, ptr, len),
+        _setEventHandlerMode: (vnodeId, eventTypeId, maySuspend) => {
+          bridgeRef[0]?.setEventHandlerMode(Number(vnodeId), eventTypeId, maySuspend !== 0);
+        },
+        _clearEventHandlerModes: (vnodeId) => {
+          bridgeRef[0]?.clearEventHandlerModes(Number(vnodeId));
+        },
+        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
+          bridgeRef[0]?.fetchAsync(
+            urlPtr,
+            urlLen,
+            methodPtr,
+            methodLen,
+            headersPtr,
+            headersLen,
+            bodyPtr,
+            bodyLen,
+            timeoutMs,
+            fetchId
+          );
+        },
+        _setTimeout: (callbackId, delayMs) => {
+          bridgeRef[0]?.setTimeout(callbackId, delayMs);
+        },
+        _setInterval: (callbackId, intervalMs) => {
+          bridgeRef[0]?.setInterval(callbackId, intervalMs);
+        },
+        _clearInterval: (callbackId) => {
+          bridgeRef[0]?.clearInterval(callbackId);
+        },
+        // WebSocket API
+        _wsConnect: (wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) => {
+          bridgeRef[0]?.wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen);
+        },
+        _wsSend: (wsId, dataPtr, dataLen, isBinary) => {
+          bridgeRef[0]?.wsSend(wsId, dataPtr, dataLen, isBinary);
+        },
+        _wsClose: (wsId, code, reasonPtr, reasonLen) => {
+          bridgeRef[0]?.wsClose(wsId, code, reasonPtr, reasonLen);
+        },
+        _flush: (ptr, len) => {
+          flushDomCmds(ptr, len, {
+            domNodes,
+            cleanupDomNodes
+          });
+        },
+        _getLocationHref: (bufPtr, bufLen) => {
+          const bytes = textEncoder.encode(window.location.href);
+          const len = Math.min(bytes.length, bufLen);
+          writeBytes(bufPtr, bytes.subarray(0, len));
+          return len;
+        },
+        _getFormData: (eventRef, outPtrAddr) => {
+          const event = loadValueFromRef(eventRef);
+          const el = event?.target;
+          const form = el instanceof HTMLFormElement ? el : el?.closest?.("form") ?? null;
+          if (!form) return 0;
+          const entries = [];
+          for (const [k, v] of new FormData(form).entries()) {
+            entries.push(k, String(v));
+          }
+          const bytes = textEncoder.encode(JSON.stringify(entries));
+          const [ptr, len] = bridgeRef[0].writeBytesToWasm(bytes);
+          new DataView(jsz.memory.buffer).setUint32(outPtrAddr, ptr, true);
+          return len;
+        },
+        _submitFormAction: (vnodeId, actionId) => {
+          const form = domNodes.get(Number(vnodeId));
+          if (!form || !(form instanceof HTMLFormElement)) return;
+          const formData = new FormData(form);
+          fetch(window.location.href, {
+            method: "POST",
+            // `>>> 0` reinterprets the i32 from wasm as u32 (ids can exceed 2^31).
+            headers: { "x-action": String(actionId >>> 0) },
+            body: formData
+          }).catch(() => {
+          });
+        },
+        _submitFormActionAsync: (vnodeId, actionId, statesPtr, statesLen, fetchId) => {
+          const form = domNodes.get(Number(vnodeId));
+          if (!form || !(form instanceof HTMLFormElement)) return;
+          const statesJson = statesLen > 0 ? readString(statesPtr, statesLen) : "[]";
+          bridgeRef[0]?.submitFormActionAsync(form, actionId, statesJson, fetchId);
+        }
+      }
+    };
+  }
+};
+var domNodes = /* @__PURE__ */ new Map();
+var eventHandlersPresent = /* @__PURE__ */ new Map();
+var eventHandlersSuspend = /* @__PURE__ */ new Map();
+function cleanupDomNodes(node) {
+  const stack = [node];
+  let highFreqBits = 0;
+  while (stack.length > 0) {
+    const n = stack.pop();
+    const ref = n.__zx_ref;
+    if (typeof ref === "number") {
+      const present = eventHandlersPresent.get(ref);
+      if (present !== void 0) {
+        highFreqBits |= present;
+        eventHandlersPresent.delete(ref);
+        eventHandlersSuspend.delete(ref);
+      }
+      domNodes.delete(ref);
+    }
+    const children = n.childNodes;
+    for (let i = 0; i < children.length; i++) stack.push(children[i]);
+  }
+  for (let bits = highFreqBits & HIGH_FREQ_EVENT_BITS; bits !== 0; bits &= bits - 1) {
+    maybeRemoveHighFreqListener(31 - Math.clz32(bits));
+  }
+}
+var delegationState = null;
+function makeDelegatedListener(bridge, eventTypeId) {
+  return (event) => {
+    let eventRef;
+    const pending = [];
+    let target = event.target;
+    while (target && target !== document.body) {
+      const zxRef = target.__zx_ref;
+      if (typeof zxRef === "number" && bridge.hasEventHandler(zxRef, eventTypeId)) {
+        if (eventRef === void 0) eventRef = storeValueGetRef(event);
+        const result = bridge.eventbridge(zxRef, eventTypeId, eventRef);
+        if (result && typeof result.then === "function") {
+          pending.push(result);
+        }
+        if (event.cancelBubble) break;
+      }
+      target = target.parentElement;
+    }
+    if (eventRef !== void 0) {
+      const ref = eventRef;
+      if (pending.length > 0) {
+        Promise.all(pending).finally(() => releaseValueRef(ref));
+      } else {
+        releaseValueRef(ref);
+      }
+    }
+  };
+}
+function ensureDelegatedListener(eventTypeId) {
+  const state = delegationState;
+  if (!state || state.attached.has(eventTypeId)) return;
+  const domType = DELEGATED_EVENTS[eventTypeId];
+  if (!domType) return;
+  const passive = domType.startsWith("touch") || domType === "scroll";
+  const options = { passive };
+  const listener = makeDelegatedListener(state.bridge, eventTypeId);
+  state.root.addEventListener(domType, listener, options);
+  state.attached.set(eventTypeId, { listener, options });
+}
+function anyHandlerForType(eventTypeId) {
+  const bit = 1 << eventTypeId;
+  for (const mask of eventHandlersPresent.values()) {
+    if (mask & bit) return true;
+  }
+  return false;
+}
+function maybeRemoveHighFreqListener(eventTypeId) {
+  if ((HIGH_FREQ_EVENT_BITS & 1 << eventTypeId) === 0) return;
+  if (anyHandlerForType(eventTypeId)) return;
+  const state = delegationState;
+  if (!state) return;
+  const entry = state.attached.get(eventTypeId);
+  if (!entry) return;
+  const domType = DELEGATED_EVENTS[eventTypeId];
+  state.root.removeEventListener(domType, entry.listener, entry.options);
+  state.attached.delete(eventTypeId);
+}
+function initEventDelegation(bridge, rootSelector = "body") {
+  const root = document.querySelector(rootSelector);
+  if (!root) return () => {
+  };
+  delegationState = { root, bridge, attached: /* @__PURE__ */ new Map() };
+  for (let eventTypeId = 0; eventTypeId < DELEGATED_EVENTS.length; eventTypeId++) {
+    if ((HIGH_FREQ_EVENT_BITS & 1 << eventTypeId) !== 0) continue;
+    ensureDelegatedListener(eventTypeId);
+  }
+  return () => {
+    if (!delegationState) return;
+    for (const [eventTypeId, entry] of delegationState.attached) {
+      const domType = DELEGATED_EVENTS[eventTypeId];
+      delegationState.root.removeEventListener(domType, entry.listener, entry.options);
+    }
+    delegationState.attached.clear();
+    delegationState = null;
+  };
+}
+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;
+  if (!url) throw new Error("WASM URL is not set");
+  const bridgeRef = [null];
+  let wasmMemory = null;
+  const allocRef = [null];
+  const getMemory = () => {
+    if (wasmMemory) return wasmMemory;
+    if (jsz.memory) return jsz.memory;
+    throw new Error("WASM memory is not ready");
+  };
+  const importObject = {
+    ...ZxBridge.createImportObject(bridgeRef),
+    ...options.importObject
+  };
+  if (true) {
+    importObject.__zx_kv = createKVImports(
+      options.kv ?? createBrowserKVBindings(),
+      getMemory,
+      allocRef
+    );
   }
-  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;
+  bindWasmAlloc(allocRef, instance.exports);
   const bridge = new ZxBridge(instance.exports);
-  bridgeRef.current = bridge;
+  bridgeRef[0] = bridge;
   domNodes.clear();
   const disposeDelegation = initEventDelegation(bridge, options.eventDelegationRoot ?? "body");
   const main = wrapPromisingExport(instance.exports.mainClient);