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

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 = {
@@ -251,7 +275,7 @@ var ZigJS = class {
 function createFetchImports(getMemory) {
   const encoder2 = new TextEncoder();
   const decoder2 = new TextDecoder();
-  function readStr(ptr, len) {
+  function readStr2(ptr, len) {
     return decoder2.decode(new Uint8Array(getMemory().buffer, ptr, len));
   }
   function writeBytes2(buf_ptr, buf_max, data) {
@@ -277,9 +301,9 @@ function createFetchImports(getMemory) {
     return headers;
   }
   async function doFetch(url_ptr, url_len, method_ptr, method_len, headers_ptr, headers_len, body_ptr, body_len, timeout_ms, status_out, buf_ptr, buf_max) {
-    const url = readStr(url_ptr, url_len);
-    const method = method_len > 0 ? readStr(method_ptr, method_len) : "GET";
-    const headersJson = headers_len > 0 ? readStr(headers_ptr, headers_len) : "{}";
+    const url = readStr2(url_ptr, url_len);
+    const method = method_len > 0 ? readStr2(method_ptr, method_len) : "GET";
+    const headersJson = headers_len > 0 ? readStr2(headers_ptr, headers_len) : "{}";
     const body = body_len > 0 ? readBytes(body_ptr, body_len) : void 0;
     const headers = parseHeaders(headersJson);
     const controller = new AbortController();
@@ -302,14 +326,14 @@ function createFetchImports(getMemory) {
       return -1;
     }
   }
-  const Suspending = WebAssembly.Suspending;
-  if (typeof Suspending !== "function") {
+  const Suspending2 = WebAssembly.Suspending;
+  if (typeof Suspending2 !== "function") {
     return {
       fetch: (_url_ptr, _url_len, _method_ptr, _method_len, _headers_ptr, _headers_len, _body_ptr, _body_len, _timeout_ms, _status_out, _buf_ptr, _buf_max) => -1
     };
   }
   return {
-    fetch: new Suspending(doFetch)
+    fetch: new Suspending2(doFetch)
   };
 }
 
@@ -382,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);
@@ -444,23 +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) >>> 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(3, 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(4, callbackId, null);
+      this._invoke(CallbackType_Interval, callbackId);
     }, intervalMs);
     this.#intervals.set(callbackId, handle);
   }
@@ -575,240 +595,619 @@ function bindWasmAlloc(allocRef, exports) {
   allocRef[0] = exports.__zx_alloc;
 }
 
-// src/runtime/kv/extern.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, 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/wasm/generated/tags.ts
+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",
+  "custom"
+];
 
-// src/runtime/kv/localstorage.ts
-function getLocalStorage() {
-  if (typeof localStorage === "undefined") {
-    throw new Error("localStorage is not available in this environment");
+// src/wasm/generated/tag_indices.ts
+var SVG_TAG_START_INDEX = 140;
+var CUSTOM_TAG_INDEX = 199;
+
+// src/wasm/dom_cmd.ts
+var BOOL_PROPS = /* @__PURE__ */ new Set([
+  "checked",
+  "selected",
+  "muted",
+  "defaultChecked",
+  "indeterminate"
+]);
+function enqueueAfterConnect(queue, el, kind) {
+  for (let i = 0; i < queue.length; i++) {
+    const job = queue[i];
+    if (job.el === el && job.kind === kind) return;
   }
-  return localStorage;
+  queue.push({ el, kind });
 }
-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) });
+function runAfterConnect(queue) {
+  for (let i = 0; i < queue.length; i++) {
+    const job = queue[i];
+    if (!job.el.isConnected) continue;
+    switch (job.kind) {
+      case "focus": {
+        if (typeof job.el.focus !== "function") break;
+        try {
+          job.el.focus({ preventScroll: true });
+        } catch {
+          job.el.focus();
+        }
+        break;
       }
-      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 assignProp(el, name, val) {
+  if (BOOL_PROPS.has(name)) {
+    const on = val !== "false";
+    el[name] = on;
+    if (name === "defaultChecked" && "checked" in el) {
+      el.checked = on;
+    }
+    return;
+  }
+  if (name === "defaultValue") {
+    el.defaultValue = val;
+    if (typeof el.value === "string" && (el.value === "" || el.value === el.defaultValue)) {
+      el.value = val;
+    }
+    return;
+  }
+  el[name] = val;
 }
-function 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);
+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;
+  const afterConnect = [];
+  for (let i = 0; i < count; i++) {
+    const off = DOM_CMD_HEADER_SIZE + i * DOM_CMD_RECORD_SIZE;
+    const op = view.getUint8(off);
+    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;
       }
-    };
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
-  });
-  const scopedKey = (key) => `${namespace}:${key}`;
+      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: {
+        const el = domNodes2.get(p0);
+        if (!el) break;
+        const name = readString(p1, p2);
+        const val = readString(p3, p4);
+        el.setAttribute(name, val);
+        if (name === "autofocus") {
+          enqueueAfterConnect(afterConnect, el, "focus");
+        }
+        break;
+      }
+      case DomOp_SetProp: {
+        const el = domNodes2.get(p0);
+        if (el) assignProp(el, readString(p1, p2), readString(p3, p4));
+        break;
+      }
+      case DomOp_RemoveAttr: {
+        domNodes2.get(p0)?.removeAttribute(readString(p1, p2));
+        break;
+      }
+      case DomOp_SetNodeValue: {
+        const node = domNodes2.get(p0);
+        if (node) node.nodeValue = readString(p1, p2);
+        break;
+      }
+      case DomOp_SetInnerHtml: {
+        const el = domNodes2.get(p0);
+        if (el) el.innerHTML = readString(p1, p2);
+        break;
+      }
+      case DomOp_AppendChild: {
+        const parent = domNodes2.get(p0);
+        const child = domNodes2.get(p1);
+        if (parent && child) parent.appendChild(child);
+        break;
+      }
+      case DomOp_InsertBefore: {
+        const parent = domNodes2.get(p0);
+        const child = domNodes2.get(p1);
+        const refNode = domNodes2.get(p2) ?? null;
+        if (parent && child) parent.insertBefore(child, refNode);
+        break;
+      }
+      case DomOp_RemoveChild: {
+        const parent = domNodes2.get(p0);
+        const child = domNodes2.get(p1);
+        if (parent && child) {
+          parent.removeChild(child);
+          cleanupDomNodes2(child);
+        }
+        break;
+      }
+      case DomOp_ReplaceChild: {
+        const parent = domNodes2.get(p0);
+        const newChild = domNodes2.get(p1);
+        const oldChild = domNodes2.get(p2);
+        if (parent && newChild && oldChild) {
+          parent.replaceChild(newChild, oldChild);
+          cleanupDomNodes2(oldChild);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  runAfterConnect(afterConnect);
+}
+
+// src/runtime/kv/extern.ts
+var Suspending = WebAssembly.Suspending;
+var jspi = typeof Suspending === "function";
+var miss = jspi ? -1 : 0;
+function putOptions(ttlSeconds) {
+  if (ttlSeconds < 60) return void 0;
+  return { expirationTtl: ttlSeconds };
+}
+function kvDel(binding, key) {
+  const b = binding;
+  return (b.del ?? b.delete).call(b, key);
+}
+function isSyncKVNamespace(binding) {
+  return typeof binding.get === "function" && binding.get.constructor.name !== "AsyncFunction";
+}
+function listOpts(prefix) {
+  return prefix.length > 0 ? { prefix } : void 0;
+}
+function maybeThen(r, f) {
+  return r instanceof Promise ? r.then(f) : f(r);
+}
+function readStr(getMemory, ptr, len) {
+  return textDecoder.decode(new Uint8Array(getMemory().buffer, ptr, len));
+}
+function resolve(bindings, ns) {
+  const b = bindings[ns] ?? bindings["default"] ?? null;
+  if (!b || jspi) return b;
+  return isSyncKVNamespace(b) ? b : null;
+}
+function encodeGet(getMemory, allocRef, value, out_ptr) {
+  if (value === null) return -1;
+  return writeBytesOut(getMemory, allocRef, out_ptr, textEncoder.encode(value));
+}
+function encodeList(getMemory, allocRef, names, out_ptr) {
+  if (names.length === 0) {
+    new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+    return 0;
+  }
+  return writeJsonOut(getMemory, allocRef, out_ptr, names);
+}
+function get(b, key, out_ptr, getMemory, allocRef) {
+  return maybeThen(b.get(key), (v) => encodeGet(getMemory, allocRef, v, out_ptr));
+}
+function put(b, key, val, ttl) {
+  return maybeThen(b.put(key, val, putOptions(ttl)), () => 0);
+}
+function del(b, key) {
+  return maybeThen(kvDel(b, key), () => 0);
+}
+function list(b, prefix, out_ptr, getMemory, allocRef) {
+  return maybeThen(
+    b.list(listOpts(prefix)),
+    (result) => encodeList(getMemory, allocRef, result.keys.map((k) => k.name), out_ptr)
+  );
+}
+function wrapImport(impl) {
+  if (!jspi) {
+    return ((...args) => {
+      const r = impl(...args);
+      if (r instanceof Promise) throw new Error("async kv binding requires JSPI");
+      return r;
+    });
+  }
+  return new Suspending(impl);
+}
+function createKVImports(bindings, getMemory, allocRef) {
   return {
-    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) }))
-      };
+    kv_get: wrapImport((ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
+      if (!b) return -1;
+      return get(b, readStr(getMemory, key_ptr, key_len), out_ptr, getMemory, allocRef);
+    }),
+    kv_put: wrapImport((ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
+      if (!b) return miss;
+      return put(
+        b,
+        readStr(getMemory, key_ptr, key_len),
+        readStr(getMemory, val_ptr, val_len),
+        ttl_seconds
+      );
+    }),
+    kv_delete: wrapImport((ns_ptr, ns_len, key_ptr, key_len) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
+      if (!b) return miss;
+      return del(b, readStr(getMemory, key_ptr, key_len));
+    }),
+    kv_list: wrapImport((ns_ptr, ns_len, pfx_ptr, pfx_len, out_ptr) => {
+      const b = resolve(bindings, readStr(getMemory, ns_ptr, ns_len));
+      if (!b) return writeJsonOut(getMemory, allocRef, out_ptr, []);
+      return list(b, readStr(getMemory, pfx_ptr, pfx_len), out_ptr, getMemory, allocRef);
+    })
+  };
+}
+
+// src/runtime/kv/localstorage.ts
+var namespace = "default";
+var storagePrefix = "ziex-kv";
+var namespacePrefix = `${storagePrefix}:${namespace}:`;
+function storage() {
+  if (typeof localStorage === "undefined") {
+    throw new Error("localStorage is not available in this environment");
+  }
+  return localStorage;
+}
+function get2(key) {
+  return storage().getItem(`${storagePrefix}:${namespace}:${key}`);
+}
+function put2(key, value) {
+  storage().setItem(`${storagePrefix}:${namespace}:${key}`, value);
+}
+function del2(key) {
+  storage().removeItem(`${storagePrefix}:${namespace}:${key}`);
+}
+function list2(options) {
+  const ls = storage();
+  const prefix = namespacePrefix + (options?.prefix ?? "");
+  const keys = [];
+  for (let i = 0; i < ls.length; i += 1) {
+    const key = ls.key(i);
+    if (!key || !key.startsWith(prefix)) continue;
+    keys.push({ name: key.slice(namespacePrefix.length) });
+  }
+  return { keys };
+}
+
+// src/runtime/kv/indexdb.ts
+var databaseName = "ziex-kv";
+var storeName = "kv";
+var namespace2 = "default";
+var dbPromise;
+function openDb() {
+  if (!dbPromise) {
+    if (typeof indexedDB === "undefined") {
+      return Promise.reject(new Error("IndexedDB is not available in this environment"));
     }
+    dbPromise = new Promise((resolve2, reject) => {
+      const request = indexedDB.open(databaseName, 1);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(storeName)) {
+          db.createObjectStore(storeName);
+        }
+      };
+      request.onsuccess = () => resolve2(request.result);
+      request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
+    });
+  }
+  return dbPromise;
+}
+function requestToPromise(request) {
+  return new Promise((resolve2, reject) => {
+    request.onsuccess = () => resolve2(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+function transactionToPromise(transaction) {
+  return new Promise((resolve2, reject) => {
+    transaction.oncomplete = () => resolve2();
+    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
+    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed"));
+  });
+}
+async function get3(key) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readonly");
+  const value = await requestToPromise(tx.objectStore(storeName).get(`${namespace2}:${key}`));
+  await transactionToPromise(tx);
+  return typeof value === "string" ? value : null;
+}
+async function put3(key, value) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).put(value, `${namespace2}:${key}`);
+  await transactionToPromise(tx);
+}
+async function del3(key) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readwrite");
+  tx.objectStore(storeName).delete(`${namespace2}:${key}`);
+  await transactionToPromise(tx);
+}
+async function list3(options) {
+  const db = await openDb();
+  const tx = db.transaction(storeName, "readonly");
+  const keys = await requestToPromise(tx.objectStore(storeName).getAllKeys());
+  await transactionToPromise(tx);
+  const prefix = `${namespace2}:${options?.prefix ?? ""}`;
+  return {
+    keys: keys.filter((key) => typeof key === "string" && key.startsWith(prefix)).map((key) => ({ name: key.slice(namespace2.length + 1) }))
   };
 }
 
 // src/runtime/kv.ts
-function hasJSPI() {
-  return typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
-}
+var hasJspi = typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
 function createBrowserKVBindings(options = {}) {
-  const namespace = options.namespace ?? "default";
+  const namespace3 = options.namespace ?? "default";
   return {
-    [namespace]: hasJSPI() ? createIndexedDbKV(options) : createLocalStorageKV(options)
+    [namespace3]: hasJspi && !options.forceLocalStorage ? { get: get3, put: put3, del: del3, list: list3 } : { get: get2, put: put2, del: del2, list: list2 }
   };
 }
 
+// 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();
-  #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
@@ -834,8 +1233,8 @@ var ZxBridge = class extends ZxBridgeCore {
     const present = eventHandlersPresent.get(velementId) ?? 0;
     eventHandlersPresent.delete(velementId);
     eventHandlersSuspend.delete(velementId);
-    for (const eventTypeId of HIGH_FREQ_EVENT_IDS) {
-      if (present & 1 << eventTypeId) maybeRemoveHighFreqListener(eventTypeId);
+    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. */
@@ -857,7 +1256,7 @@ var ZxBridge = class extends ZxBridgeCore {
   }
   /**
    * Create and connect a WebSocket.
-   * Calls __zx_ws_onopen, __zx_ws_onmessage, __zx_ws_onerror, __zx_ws_onclose.
+   * Completes via `__zx_cb(ws_open|ws_message|ws_error|ws_close, ...)`.
    */
   wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) {
     const url = readString(urlPtr, urlLen);
@@ -867,42 +1266,32 @@ var ZxBridge = class extends ZxBridgeCore {
       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);
+        this._invoke(CallbackType_WebSocketOpen, wsId, BigInt(ptr), BigInt(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);
+        this._invoke(CallbackType_WebSocketMessage, wsId, BigInt(ptr), BigInt(len), BigInt(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);
+        this._invoke(CallbackType_WebSocketError, wsId, BigInt(ptr), BigInt(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);
+        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 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);
-      }
+      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 */
@@ -1003,79 +1392,11 @@ var ZxBridge = class extends ZxBridgeCore {
         _wsClose: (wsId, code, reasonPtr, reasonLen) => {
           bridgeRef[0]?.wsClose(wsId, code, reasonPtr, reasonLen);
         },
-        _ce: (id, vnodeId) => {
-          const nid = Number(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 = nid;
-          domNodes.set(nid, el);
-        },
-        _ct: (ptr, len, vnodeId) => {
-          const nid = Number(vnodeId);
-          const node = document.createTextNode(readString(ptr, len));
-          node.__zx_ref = nid;
-          domNodes.set(nid, node);
-        },
-        /** Insert vnode before a jsz-held end comment (hydration). */
-        _ih: (vnodeId, endCommentRef) => {
-          const child = domNodes.get(Number(vnodeId));
-          const end = loadValueFromRef(endCommentRef);
-          if (!child || !end?.parentNode) return;
-          end.parentNode.insertBefore(child, end);
-        },
-        _sa: (vnodeId, namePtr, nameLen, valPtr, valLen) => {
-          domNodes.get(Number(vnodeId))?.setAttribute(readString(namePtr, nameLen), readString(valPtr, valLen));
-        },
-        _sp: (vnodeId, namePtr, nameLen, valPtr, valLen) => {
-          const el = domNodes.get(Number(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(Number(vnodeId))?.removeAttribute(readString(namePtr, nameLen));
-        },
-        _snv: (vnodeId, ptr, len) => {
-          const node = domNodes.get(Number(vnodeId));
-          if (node) node.nodeValue = readString(ptr, len);
-        },
-        _srh: (vnodeId, ptr, len) => {
-          const el = domNodes.get(Number(vnodeId));
-          if (el) el.innerHTML = readString(ptr, len);
-        },
-        _ac: (parentId, childId) => {
-          const parent = domNodes.get(Number(parentId));
-          const child = domNodes.get(Number(childId));
-          if (parent && child) parent.appendChild(child);
-        },
-        _ib: (parentId, childId, refId) => {
-          const parent = domNodes.get(Number(parentId));
-          const child = domNodes.get(Number(childId));
-          const ref = domNodes.get(Number(refId)) ?? null;
-          if (parent && child) parent.insertBefore(child, ref);
-        },
-        _rc: (parentId, childId) => {
-          const parent = domNodes.get(Number(parentId));
-          const child = domNodes.get(Number(childId));
-          if (parent && child) {
-            parent.removeChild(child);
-            cleanupDomNodes(child);
-          }
-        },
-        _rpc: (parentId, newId, oldId) => {
-          const parent = domNodes.get(Number(parentId));
-          const newChild = domNodes.get(Number(newId));
-          const oldChild = domNodes.get(Number(oldId));
-          if (parent && newChild && oldChild) {
-            parent.replaceChild(newChild, oldChild);
-            cleanupDomNodes(oldChild);
-          }
+        _flush: (ptr, len) => {
+          flushDomCmds(ptr, len, {
+            domNodes,
+            cleanupDomNodes
+          });
         },
         _getLocationHref: (bufPtr, bufLen) => {
           const bytes = textEncoder.encode(window.location.href);
@@ -1114,6 +1435,10 @@ var ZxBridge = class extends ZxBridgeCore {
           if (!form || !(form instanceof HTMLFormElement)) return;
           const statesJson = statesLen > 0 ? readString(statesPtr, statesLen) : "[]";
           bridgeRef[0]?.submitFormActionAsync(form, actionId, statesJson, fetchId);
+        },
+        _formReset: (vnodeId) => {
+          const form = domNodes.get(Number(vnodeId));
+          if (form instanceof HTMLFormElement) form.reset();
         }
       }
     };
@@ -1140,247 +1465,10 @@ function cleanupDomNodes(node) {
     const children = n.childNodes;
     for (let i = 0; i < children.length; i++) stack.push(children[i]);
   }
-  for (const eventTypeId of HIGH_FREQ_EVENT_IDS) {
-    if (highFreqBits & 1 << eventTypeId) maybeRemoveHighFreqListener(eventTypeId);
+  for (let bits = highFreqBits & HIGH_FREQ_EVENT_BITS; bits !== 0; bits &= bits - 1) {
+    maybeRemoveHighFreqListener(31 - Math.clz32(bits));
   }
 }
-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 DELEGATED_EVENTS = [
-  "click",
-  "dblclick",
-  "input",
-  "change",
-  "submit",
-  // focus/blur do not bubble - listen to focusin/focusout instead.
-  "focusin",
-  "focusout",
-  "keydown",
-  "keyup",
-  "keypress",
-  "mouseenter",
-  "mouseleave",
-  "mousedown",
-  "mouseup",
-  "mousemove",
-  "touchstart",
-  "touchend",
-  "touchmove",
-  "scroll",
-  "wheel",
-  "pointerdown",
-  "pointermove",
-  "pointerup",
-  "pointercancel"
-];
-var HIGH_FREQ_EVENT_IDS = new Set([
-  DELEGATED_EVENTS.indexOf("mousemove"),
-  DELEGATED_EVENTS.indexOf("pointermove"),
-  DELEGATED_EVENTS.indexOf("wheel"),
-  DELEGATED_EVENTS.indexOf("scroll"),
-  DELEGATED_EVENTS.indexOf("touchmove")
-].filter((id) => id >= 0));
 var delegationState = null;
 function makeDelegatedListener(bridge, eventTypeId) {
   return (event) => {
@@ -1428,7 +1516,7 @@ function anyHandlerForType(eventTypeId) {
   return false;
 }
 function maybeRemoveHighFreqListener(eventTypeId) {
-  if (!HIGH_FREQ_EVENT_IDS.has(eventTypeId)) return;
+  if ((HIGH_FREQ_EVENT_BITS & 1 << eventTypeId) === 0) return;
   if (anyHandlerForType(eventTypeId)) return;
   const state = delegationState;
   if (!state) return;
@@ -1444,7 +1532,7 @@ function initEventDelegation(bridge, rootSelector = "body") {
   };
   delegationState = { root, bridge, attached: /* @__PURE__ */ new Map() };
   for (let eventTypeId = 0; eventTypeId < DELEGATED_EVENTS.length; eventTypeId++) {
-    if (HIGH_FREQ_EVENT_IDS.has(eventTypeId)) continue;
+    if ((HIGH_FREQ_EVENT_BITS & 1 << eventTypeId) !== 0) continue;
     ensureDelegatedListener(eventTypeId);
   }
   return () => {