ziex 0.1.0-dev.1387 → 0.1.0-dev.1458

package/wasm/index.js

@@ -51,6 +51,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 +103,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 +119,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 +132,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 +169,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 +237,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 +314,15 @@ 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 CallbackType_Event = 0;
+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;
 var jsz = new ZigJS();
 var tempRefBuffer = new ArrayBuffer(8);
 var tempRefView = new DataView(tempRefBuffer);
@@ -309,6 +333,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 +359,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;
@@ -418,20 +455,21 @@ var ZxBridgeCore = class _ZxBridgeCore {
   _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);
   }
   /** Set a timeout and callback when it fires */
   setTimeout(callbackId, delayMs) {
     setTimeout(() => {
-      this.#invoke(CallbackType.Timeout, callbackId, null);
+      this.#invoke(3, callbackId, null);
     }, delayMs);
   }
   /** Set an interval and callback each time it fires */
   setInterval(callbackId, intervalMs) {
     const handle = setInterval(() => {
-      this.#invoke(CallbackType.Interval, callbackId, null);
+      this.#invoke(4, callbackId, null);
     }, intervalMs);
     this.#intervals.set(callbackId, handle);
   }
@@ -449,18 +487,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 +536,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,20 +550,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);
         }
       }
     };
   }
 };
+function writeBytesOut(getMemory, allocRef, outPtrAddr, data) {
+  if (data.length === 0) {
+    new DataView(getMemory().buffer).setUint32(outPtrAddr, 0, true);
+    return 0;
+  }
+  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 writeJsonOut(getMemory, allocRef, outPtrAddr, value) {
+  return writeBytesOut(getMemory, allocRef, outPtrAddr, textEncoder.encode(JSON.stringify(value)));
+}
+function bindWasmAlloc(allocRef, exports) {
+  allocRef[0] = exports.__zx_alloc;
+}
 
-// src/kv.ts
+// src/runtime/kv/extern.ts
 function putOptions(ttlSeconds) {
   if (ttlSeconds < 60) return void 0;
   return { expirationTtl: ttlSeconds };
@@ -528,17 +593,12 @@ 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) {
+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 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;
   }
@@ -550,12 +610,12 @@ function createKVImports(bindings, getMemory) {
     };
     var syncBinding = syncBinding2;
     return {
-      kv_get: (ns_ptr, ns_len, key_ptr, key_len, buf_ptr, buf_max) => {
+      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 writeBytes2(buf_ptr, buf_max, encoder2.encode(value));
+        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));
@@ -569,22 +629,22 @@ function createKVImports(bindings, getMemory) {
         b.deleteSync(readStr(key_ptr, key_len));
         return 0;
       },
-      kv_list: (ns_ptr, ns_len, pfx_ptr, pfx_len, buf_ptr, buf_max) => {
+      kv_list: (ns_ptr, ns_len, pfx_ptr, pfx_len, out_ptr) => {
         const b = syncBinding2(readStr(ns_ptr, ns_len));
-        if (!b) return writeBytes2(buf_ptr, buf_max, encoder2.encode("[]"));
+        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 writeBytes2(buf_ptr, buf_max, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
+        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, buf_ptr, buf_max) => {
+    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 writeBytes2(buf_ptr, buf_max, encoder2.encode(value));
+      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));
@@ -598,17 +658,70 @@ function createKVImports(bindings, getMemory) {
       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) => {
+    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 writeBytes2(buf_ptr, buf_max, encoder2.encode("[]"));
+      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);
-      return writeBytes2(buf_ptr, buf_max, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
+      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/browser/kv.ts
+// 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");
@@ -651,7 +764,6 @@ function createIndexedDbKV(options = {}) {
       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) {
@@ -659,7 +771,6 @@ function createIndexedDbKV(options = {}) {
       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;
@@ -680,52 +791,8 @@ function createIndexedDbKV(options = {}) {
     }
   };
 }
-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.ts
 function hasJSPI() {
   return typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
 }
@@ -756,18 +823,29 @@ var ZxBridge = class extends ZxBridgeCore {
       exports.__zx_eventbridge_async ?? exports.__zx_eventbridge
     );
   }
+  hasEventHandler(velementId, eventTypeId) {
+    return !!((eventHandlersPresent.get(velementId) ?? 0) & 1 << eventTypeId);
+  }
   eventMaySuspend(velementId, eventTypeId) {
-    return !!((eventHandlerModes.get(velementId) ?? 0) & 1 << eventTypeId);
+    return !!((eventHandlersSuspend.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);
+    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) {
-    eventHandlerModes.delete(velementId);
+    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);
+    }
   }
   /** Submit a form action with bound-state round-trip. */
   submitFormActionAsync(form, actionId, statesJson, fetchId) {
@@ -801,7 +879,7 @@ var ZxBridge = class extends ZxBridgeCore {
         const handler = this.#wsOnOpenHandler;
         if (!handler) return;
         const protocol = ws.protocol || "";
-        const { ptr, len } = this._writeStringToWasm(protocol);
+        const [ptr, len] = this._writeStringToWasm(protocol);
         invokeWasmExport(handler, wsId, ptr, len);
       };
       ws.onmessage = (event) => {
@@ -809,20 +887,20 @@ var ZxBridge = class extends ZxBridgeCore {
         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);
+        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");
+        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);
+        const [ptr, len] = this._writeStringToWasm(reason);
         invokeWasmExport(handler, wsId, event.code, ptr, len, event.wasClean ? 1 : 0);
         this.#websockets.delete(wsId);
       };
@@ -831,7 +909,7 @@ var ZxBridge = class extends ZxBridgeCore {
       const handler = this.#wsOnErrorHandler;
       if (handler) {
         const msg = error instanceof Error ? error.message : "WebSocket connection failed";
-        const { ptr, len } = this._writeStringToWasm(msg);
+        const [ptr, len] = this._writeStringToWasm(msg);
         invokeWasmExport(handler, wsId, ptr, len);
       }
     }
@@ -841,10 +919,13 @@ var ZxBridge = class extends ZxBridgeCore {
     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(dataPtr, dataPtr + dataLen));
+      ws.send(memory.slice(start, start + length));
     } else {
-      ws.send(textDecoder.decode(memory.subarray(dataPtr, dataPtr + dataLen)));
+      ws.send(textDecoder.decode(memory.subarray(start, start + length)));
     }
   }
   /** Close WebSocket connection */
@@ -861,7 +942,8 @@ var ZxBridge = class extends ZxBridgeCore {
   }
   dispose() {
     super.dispose();
-    eventHandlerModes.clear();
+    eventHandlersPresent.clear();
+    eventHandlersSuspend.clear();
     for (const ws of this.#websockets.values()) {
       try {
         ws.close();
@@ -870,14 +952,16 @@ var ZxBridge = class extends ZxBridgeCore {
     }
     this.#websockets.clear();
   }
-  /** Handle a DOM event (called by event delegation) */
-  eventbridge(velementId, eventTypeId, event) {
-    const eventRef = storeValueGetRef(event);
+  /**
+   * 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)) {
-      invokeWasmExport(this.#eventbridgeAsync, velementId, eventTypeId, eventRef);
-      return;
+      return invokeWasmExport(this.#eventbridgeAsync, id, eventTypeId, eventRef);
     }
-    invokeWasmExport(this.#eventbridge, velementId, eventTypeId, eventRef);
+    invokeWasmExport(this.#eventbridge, id, eventTypeId, eventRef);
   }
   /** Create the full browser import object for WASM instantiation (includes DOM + WebSocket). */
   static createImportObject(bridgeRef) {
@@ -890,13 +974,13 @@ var ZxBridge = class extends ZxBridgeCore {
       __zx: {
         _log: (level, ptr, len) => ZxBridgeCore.log(level, ptr, len),
         _setEventHandlerMode: (vnodeId, eventTypeId, maySuspend) => {
-          bridgeRef.current?.setEventHandlerMode(vnodeId, eventTypeId, maySuspend !== 0);
+          bridgeRef[0]?.setEventHandlerMode(Number(vnodeId), eventTypeId, maySuspend !== 0);
         },
         _clearEventHandlerModes: (vnodeId) => {
-          bridgeRef.current?.clearEventHandlerModes(vnodeId);
+          bridgeRef[0]?.clearEventHandlerModes(Number(vnodeId));
         },
         _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
-          bridgeRef.current?.fetchAsync(
+          bridgeRef[0]?.fetchAsync(
             urlPtr,
             urlLen,
             methodPtr,
@@ -910,43 +994,49 @@ var ZxBridge = class extends 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);
         },
         // WebSocket API
         _wsConnect: (wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) => {
-          bridgeRef.current?.wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen);
+          bridgeRef[0]?.wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen);
         },
         _wsSend: (wsId, dataPtr, dataLen, isBinary) => {
-          bridgeRef.current?.wsSend(wsId, dataPtr, dataLen, isBinary);
+          bridgeRef[0]?.wsSend(wsId, dataPtr, dataLen, isBinary);
         },
         _wsClose: (wsId, code, reasonPtr, reasonLen) => {
-          bridgeRef.current?.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 = Number(vnodeId);
-          domNodes.set(vnodeId, el);
-          return storeValueGetRef(el);
+          el.__zx_ref = nid;
+          domNodes.set(nid, 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);
+          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(vnodeId)?.setAttribute(readString(namePtr, nameLen), readString(valPtr, valLen));
+          domNodes.get(Number(vnodeId))?.setAttribute(readString(namePtr, nameLen), readString(valPtr, valLen));
         },
         _sp: (vnodeId, namePtr, nameLen, valPtr, valLen) => {
-          const el = domNodes.get(vnodeId);
+          const el = domNodes.get(Number(vnodeId));
           if (el) {
             const name = readString(namePtr, nameLen);
             const val = readString(valPtr, valLen);
@@ -958,39 +1048,39 @@ var ZxBridge = class extends ZxBridgeCore {
           }
         },
         _ra: (vnodeId, namePtr, nameLen) => {
-          domNodes.get(vnodeId)?.removeAttribute(readString(namePtr, nameLen));
+          domNodes.get(Number(vnodeId))?.removeAttribute(readString(namePtr, nameLen));
         },
         _snv: (vnodeId, ptr, len) => {
-          const node = domNodes.get(vnodeId);
+          const node = domNodes.get(Number(vnodeId));
           if (node) node.nodeValue = readString(ptr, len);
         },
         _srh: (vnodeId, ptr, len) => {
-          const el = domNodes.get(vnodeId);
+          const el = domNodes.get(Number(vnodeId));
           if (el) el.innerHTML = readString(ptr, len);
         },
         _ac: (parentId, childId) => {
-          const parent = domNodes.get(parentId);
-          const child = domNodes.get(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(parentId);
-          const child = domNodes.get(childId);
-          const ref = domNodes.get(refId) ?? null;
+          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(parentId);
-          const child = domNodes.get(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(parentId);
-          const newChild = domNodes.get(newId);
-          const oldChild = domNodes.get(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);
@@ -1002,18 +1092,22 @@ var ZxBridge = class extends ZxBridgeCore {
           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));
+        _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(vnodeId);
+          const form = domNodes.get(Number(vnodeId));
           if (!form || !(form instanceof HTMLFormElement)) return;
           const formData = new FormData(form);
           fetch(window.location.href, {
@@ -1025,21 +1119,39 @@ var ZxBridge = class extends ZxBridgeCore {
           });
         },
         _submitFormActionAsync: (vnodeId, actionId, statesPtr, statesLen, fetchId) => {
-          const form = domNodes.get(vnodeId);
+          const form = domNodes.get(Number(vnodeId));
           if (!form || !(form instanceof HTMLFormElement)) return;
           const statesJson = statesLen > 0 ? readString(statesPtr, statesLen) : "[]";
-          bridgeRef.current?.submitFormActionAsync(form, actionId, statesJson, fetchId);
+          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 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]);
+  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 (const eventTypeId of HIGH_FREQ_EVENT_IDS) {
+    if (highFreqBits & 1 << eventTypeId) maybeRemoveHighFreqListener(eventTypeId);
+  }
 }
 var SVG_TAG_START_INDEX = 140;
 var TAG_NAMES = [
@@ -1245,54 +1357,115 @@ var TAG_NAMES = [
   "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 }
+  "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 eventHandlerModes = /* @__PURE__ */ new Map();
+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) => {
+    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_IDS.has(eventTypeId)) 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 () => {
   };
-  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;
-        }
-        target = target.parentElement;
-      }
-    };
-    const options = { passive: delegatedEvent.domType.startsWith("touch") || delegatedEvent.domType === "scroll" };
-    root.addEventListener(delegatedEvent.domType, listener, options);
-    removers.push(() => root.removeEventListener(delegatedEvent.domType, listener, options));
+  delegationState = { root, bridge, attached: /* @__PURE__ */ new Map() };
+  for (let eventTypeId = 0; eventTypeId < DELEGATED_EVENTS.length; eventTypeId++) {
+    if (HIGH_FREQ_EVENT_IDS.has(eventTypeId)) continue;
+    ensureDelegatedListener(eventTypeId);
   }
   return () => {
-    for (const remove of removers) remove();
+    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 DEFAULT_URL = "/assets/_/main.wasm";
 var activeRuntime = null;
 function buildDevtoolsLocation() {
   return {
@@ -1325,29 +1498,34 @@ async function init(options = {}) {
     activeRuntime.dispose();
     activeRuntime = null;
   }
-  const url = options.url ?? document.getElementById("__$wasmlink")?.href ?? DEFAULT_URL;
-  const bridgeRef = { current: 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 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 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
   };
-  const importObject = Object.assign(
-    {},
-    ZxBridge.createImportObject(bridgeRef),
-    kvImportObject,
-    options.importObject
-  );
+  if (true) {
+    importObject.__zx_kv = createKVImports(
+      options.kv ?? createBrowserKVBindings(),
+      getMemory,
+      allocRef
+    );
+  }
   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);
@@ -1364,16 +1542,29 @@ async function init(options = {}) {
   return { source, bridge };
 }
 export {
-  CallbackType,
+  CallbackType_Event,
+  CallbackType_FetchError,
+  CallbackType_FetchSuccess,
+  CallbackType_Interval,
+  CallbackType_Timeout,
+  CallbackType_WebSocketClose,
+  CallbackType_WebSocketError,
+  CallbackType_WebSocketMessage,
+  CallbackType_WebSocketOpen,
   ZxBridge,
   ZxBridgeCore,
+  bindWasmAlloc,
   getMemoryView,
   init,
   initEventDelegation,
   jsz,
+  loadValueFromRef,
   readString,
+  releaseValueRef,
   storeValueGetRef,
   textDecoder,
   textEncoder,
-  writeBytes
+  writeBytes,
+  writeBytesOut,
+  writeJsonOut
 };