ziex 0.1.0-dev.1367 → 0.1.0-dev.1377

package/wasm/index.js

@@ -1,37 +1,36 @@
-var __defProp = Object.defineProperty;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
 // ../../vendor/jsz/js/src/zigjs.ts
 var NAN_PREFIX = 2146959360;
 var predefined = {
-  nan: 0,
-  null: 1,
-  true: 2,
-  false: 3,
-  undefined: 4,
-  globalThis: 5,
-  runtime: 6
+  "nan": 0,
+  "null": 1,
+  "true": 2,
+  "false": 3,
+  "undefined": 4,
+  "globalThis": 5,
+  "runtime": 6
 };
 var PREDEFINED_ID_MAX = 6;
-var encoder = new TextEncoder;
+var encoder = new TextEncoder();
 var decoder = new TextDecoder("utf-8");
-
-class ZigJS {
-  memory;
-  values = [NaN, null, true, false, undefined, globalThis, this];
-  idPool = [];
+var ZigJS = class {
+  constructor() {
+    /**
+     * The values, indexed by ID (number). Duplicate values can be in this
+     * if they are loaded multiple times. That just acts as duplicate references.
+     * */
+    this.values = [NaN, null, true, false, void 0, globalThis, this];
+    /**
+     * When a value is removed from the values array, its ID is put
+     * in the pool so that we can use it next. This avoids fragmentation in
+     * our array keys.
+     * */
+    this.idPool = [];
+  }
+  /**
+   * Returns the import object that should be merged with your import
+   * object when instantiating your wasm instance. This injects the required
+   * functions into the wasm environment.
+   * */
   importObject() {
     return {
       "zig-js": {
@@ -47,92 +46,121 @@ class ZigJS {
       }
     };
   }
+  /**
+   * Get a value from the JS environment.
+   * */
   valueGet(out, id, ptr, len) {
     const val = this.loadValue(id);
     const str = this.loadString(ptr, len);
     const result = Reflect.get(val, str);
     this.storeValue(out, result);
   }
+  /**
+   * Set a value on an object.
+   * */
   valueSet(id, ptr, len, refAddr) {
     const obj = this.loadValue(id);
     const str = this.loadString(ptr, len);
     const val = this.loadRef(refAddr);
     Reflect.set(obj, str, val);
   }
+  /**
+   * Dereference a value, allowing the JS environment to potentially GC it.
+   * */
   valueDeinit(id) {
     if (id > PREDEFINED_ID_MAX) {
       this.values[id] = null;
       this.idPool.push(id);
     }
   }
+  /**
+   * Create an empty object.
+   * */
   valueObjectCreate(out) {
-    this.storeValue(out, new Object);
+    this.storeValue(out, new Object());
   }
+  /**
+   * Creates a string on the JS side from a UTF-8 encoded string in wasm memory.
+   * */
   valueStringCreate(out, ptr, len) {
     const str = this.loadString(ptr, len);
     this.storeValue(out, str);
   }
+  /**
+   * Returns the length of the string given by id.
+   * */
   valueStringLen(id) {
     const val = this.loadValue(id);
     const buf = encoder.encode(val);
     return buf.byteLength;
   }
+  /**
+   * Copy the string at id "id" into the shared memory at ptr.
+   * */
   valueStringCopy(id, ptr, max) {
-    if (this.memory == null)
-      return;
+    if (this.memory == null) return;
     const val = this.loadValue(id);
     const bytes = encoder.encode(val);
-    if (bytes.byteLength > max)
-      return;
-    if (bytes.length === 0)
-      return;
+    if (bytes.byteLength > max) return;
+    if (bytes.length === 0) return;
     new Uint8Array(this.memory.buffer, ptr, bytes.length).set(bytes);
   }
+  /**
+   * Call a constructor given by id.
+   * */
   valueNew(out, id, argsAddr, argsLen) {
     const fn = this.loadValue(id);
     const args = [];
-    for (let i = 0;i < argsLen; i++) {
+    for (let i = 0; i < argsLen; i++) {
       args.push(this.loadRef(argsAddr + i * 8));
     }
     const result = Reflect.construct(fn, args);
     this.storeValue(out, result);
   }
+  /**
+   * Call a function given by id.
+   * */
   funcApply(out, id, thisRefAddr, argsAddr, argsLen) {
     const fn = this.loadValue(id);
     const thisVal = this.loadRef(thisRefAddr);
     const args = [];
-    for (let i = 0;i < argsLen; i++) {
+    for (let i = 0; i < argsLen; i++) {
       args.push(this.loadRef(argsAddr + i * 8));
     }
     const result = Reflect.apply(fn, thisVal, args);
     this.storeValue(out, result);
   }
+  /**
+   * This can be used to load a value given by an ID. A WASM function
+   * might return a value as an ID. This can be used to retrieve it.
+   * */
   loadValue(id) {
     return this.values[id];
   }
+  /**
+   * This removes the value from the values list and returns it. This
+   * will not remove predefined values but can still be used to retrieve
+   * them.
+   * */
   deleteValue(id) {
     const val = this.values[id];
     this.valueDeinit(id);
     return val;
   }
   loadRef(refAddr) {
-    if (this.memory == null)
-      return;
+    if (this.memory == null) return;
     const view = new DataView(this.memory.buffer);
     const floatVal = view.getFloat64(refAddr, true);
-    if (!isNaN(floatVal))
-      return floatVal;
+    if (!isNaN(floatVal)) return floatVal;
     const id = this.loadRefId(refAddr);
     return this.values[id];
   }
   loadRefId(refAddr) {
-    if (this.memory == null)
-      return 0;
+    if (this.memory == null) return 0;
     return new DataView(this.memory.buffer).getUint32(refAddr, true);
   }
   storeValue(out, val) {
-    if (this.memory == null)
-      return;
+    if (this.memory == null) return;
     const view = new DataView(this.memory.buffer);
     if (typeof val === "number") {
       if (isNaN(val)) {
@@ -148,7 +176,7 @@ class ZigJS {
       view.setUint32(out + 4, NAN_PREFIX, true);
       return;
     }
-    if (val === undefined) {
+    if (val === void 0) {
       view.setUint32(out, predefined.undefined, true);
       view.setUint32(out + 4, NAN_PREFIX, true);
       return;
@@ -163,7 +191,7 @@ class ZigJS {
       return;
     }
     let id = this.idPool.pop();
-    if (id === undefined) {
+    if (id === void 0) {
       id = this.values.length;
     }
     this.values[id] = val;
@@ -186,23 +214,22 @@ class ZigJS {
     view.setUint32(out + 4, NAN_PREFIX | typeId, true);
   }
   loadString(ptr, len) {
-    if (this.memory == null)
-      return "";
+    if (this.memory == null) return "";
     const arr = new Uint8ClampedArray(this.memory.buffer, ptr, Number(len));
     const data = arr.slice();
     return decoder.decode(data);
   }
-}
+};
+
 // src/fetch.ts
 function createFetchImports(getMemory) {
-  const encoder2 = new TextEncoder;
-  const decoder2 = new TextDecoder;
+  const encoder2 = new TextEncoder();
+  const decoder2 = new TextDecoder();
   function readStr(ptr, len) {
     return decoder2.decode(new Uint8Array(getMemory().buffer, ptr, len));
   }
-  function writeBytes(buf_ptr, buf_max, data) {
-    if (data.length > buf_max)
-      return -2;
+  function writeBytes2(buf_ptr, buf_max, data) {
+    if (data.length > buf_max) return -2;
     new Uint8Array(getMemory().buffer, buf_ptr, data.length).set(data);
     return data.length;
   }
@@ -214,8 +241,7 @@ function createFetchImports(getMemory) {
     try {
       headers = JSON.parse(headersJson);
     } catch {
-      for (const line of headersJson.split(`
-`)) {
+      for (const line of headersJson.split("\n")) {
         const colonIdx = line.indexOf(":");
         if (colonIdx > 0) {
           headers[line.slice(0, colonIdx)] = line.slice(colonIdx + 1);
@@ -228,25 +254,23 @@ function createFetchImports(getMemory) {
     const url = readStr(url_ptr, url_len);
     const method = method_len > 0 ? readStr(method_ptr, method_len) : "GET";
     const headersJson = headers_len > 0 ? readStr(headers_ptr, headers_len) : "{}";
-    const body = body_len > 0 ? readBytes(body_ptr, body_len) : undefined;
+    const body = body_len > 0 ? readBytes(body_ptr, body_len) : void 0;
     const headers = parseHeaders(headersJson);
-    const controller = new AbortController;
+    const controller = new AbortController();
     const timeout = timeout_ms > 0 ? setTimeout(() => controller.abort(), timeout_ms) : null;
     try {
       const response = await fetch(url, {
         method,
-        headers: Object.keys(headers).length > 0 ? headers : undefined,
-        body: method !== "GET" && method !== "HEAD" ? body : undefined,
+        headers: Object.keys(headers).length > 0 ? headers : void 0,
+        body: method !== "GET" && method !== "HEAD" ? body : void 0,
         signal: controller.signal
       });
-      if (timeout)
-        clearTimeout(timeout);
+      if (timeout) clearTimeout(timeout);
       new DataView(getMemory().buffer).setUint16(status_out, response.status, true);
       const bytes = new Uint8Array(await response.arrayBuffer());
-      return writeBytes(buf_ptr, buf_max, bytes);
+      return writeBytes2(buf_ptr, buf_max, bytes);
     } catch (err) {
-      if (timeout)
-        clearTimeout(timeout);
+      if (timeout) clearTimeout(timeout);
       const msg = err instanceof Error ? err.message : String(err);
       console.error(`wasm fetch failed: ${url} (${msg})`);
       return -1;
@@ -275,7 +299,7 @@ var CallbackType = {
   WebSocketError: 7,
   WebSocketClose: 8
 };
-var jsz = new ZigJS;
+var jsz = new ZigJS();
 var tempRefBuffer = new ArrayBuffer(8);
 var tempRefView = new DataView(tempRefBuffer);
 function storeValueGetRef(val) {
@@ -285,8 +309,8 @@ function storeValueGetRef(val) {
   jsz.memory = originalMemory;
   return tempRefView.getBigUint64(0, true);
 }
-var textDecoder = new TextDecoder;
-var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder();
+var textEncoder = new TextEncoder();
 var memoryView = null;
 var memoryBuffer = null;
 function getMemoryView() {
@@ -297,15 +321,14 @@ function getMemoryView() {
   }
   return memoryView;
 }
-var stringCache = new Map;
+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 !== undefined)
-    return cached;
+  if (cached !== void 0) return cached;
   const str = textDecoder.decode(getMemoryView().subarray(ptr, ptr + len));
   stringCache.set(key, str);
   return str;
@@ -314,27 +337,22 @@ function writeBytes(ptr, data) {
   getMemoryView().set(data, ptr);
 }
 function wrapPromisingExport(fn) {
-  if (!fn)
-    return;
+  if (!fn) return void 0;
   const promising = WebAssembly.promising;
-  if (typeof promising !== "function")
-    return fn;
+  if (typeof promising !== "function") return fn;
   return promising(fn);
 }
 function invokeWasmExport(fn, ...args) {
-  if (!fn)
-    return;
+  if (!fn) return;
   const result = fn(...args);
   if (result && typeof result.then === "function") {
-    result.then(undefined, (error) => {
+    void result.then(void 0, (error) => {
       console.error(error);
     });
   }
 }
-
-class ZxBridgeCore {
-  #intervals = new Map;
-  _alloc;
+var ZxBridgeCore = class _ZxBridgeCore {
+  #intervals = /* @__PURE__ */ new Map();
   #handler;
   #fetchCompleteHandler;
   constructor(exports) {
@@ -345,9 +363,9 @@ class ZxBridgeCore {
       throw new Error("__zx_fetch_complete not exported from WASM");
     }
     this.#fetchCompleteHandler = fetchCompleteHandler;
-    if (exports.memory)
-      jsz.memory = exports.memory;
+    if (exports.memory) jsz.memory = exports.memory;
   }
+  /** Invoke the unified callback handler */
   #invoke(type, id, data) {
     const handler = this.#handler;
     if (!handler) {
@@ -357,44 +375,46 @@ class ZxBridgeCore {
     const dataRef = storeValueGetRef(data);
     invokeWasmExport(handler, type, id, dataRef);
   }
+  /**
+   * Async fetch with full options support.
+   * Calls __zx_fetch_complete when done.
+   */
   fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) {
     const url = readString(urlPtr, urlLen);
     const method = methodLen > 0 ? readString(methodPtr, methodLen) : "GET";
     const headersJson = headersLen > 0 ? readString(headersPtr, headersLen) : "{}";
-    const body = bodyLen > 0 ? getMemoryView().subarray(bodyPtr, bodyPtr + bodyLen) : undefined;
+    const body = bodyLen > 0 ? getMemoryView().subarray(bodyPtr, bodyPtr + bodyLen) : void 0;
     let headers = {};
     try {
       headers = JSON.parse(headersJson);
     } catch {
-      for (const line of headersJson.split(`
-`)) {
+      for (const line of headersJson.split("\n")) {
         const colonIdx = line.indexOf(":");
         if (colonIdx > 0) {
           headers[line.slice(0, colonIdx)] = line.slice(colonIdx + 1);
         }
       }
     }
-    const controller = new AbortController;
+    const controller = new AbortController();
     const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
     const fetchOptions = {
       method,
-      headers: Object.keys(headers).length > 0 ? headers : undefined,
-      body: method !== "GET" && method !== "HEAD" ? body : undefined,
+      headers: Object.keys(headers).length > 0 ? headers : void 0,
+      body: method !== "GET" && method !== "HEAD" ? body : void 0,
       signal: controller.signal
     };
     fetch(url, fetchOptions).then(async (response) => {
-      if (timeout)
-        clearTimeout(timeout);
+      if (timeout) clearTimeout(timeout);
       const bytes = new Uint8Array(await response.arrayBuffer());
       this._notifyFetchComplete(fetchId, response.status, bytes, false);
     }).catch((error) => {
-      if (timeout)
-        clearTimeout(timeout);
+      if (timeout) clearTimeout(timeout);
       const isAbort = error.name === "AbortError";
       const errorMsg = isAbort ? "Request timeout" : error.message ?? "Fetch failed";
       this._notifyFetchComplete(fetchId, 0, errorMsg, true);
     });
   }
+  /** 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;
@@ -402,20 +422,23 @@ class ZxBridgeCore {
     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);
     }, delayMs);
   }
+  /** Set an interval and callback each time it fires */
   setInterval(callbackId, intervalMs) {
     const handle = setInterval(() => {
       this.#invoke(CallbackType.Interval, callbackId, null);
     }, intervalMs);
     this.#intervals.set(callbackId, handle);
   }
+  /** Clear an interval */
   clearInterval(callbackId) {
     const handle = this.#intervals.get(callbackId);
-    if (handle !== undefined) {
+    if (handle !== void 0) {
       clearInterval(handle);
       this.#intervals.delete(callbackId);
     }
@@ -426,6 +449,7 @@ class ZxBridgeCore {
     }
     this.#intervals.clear();
   }
+  /** Write a string to WASM memory, returning pointer and length */
   _writeStringToWasm(str) {
     return this._writeBytesToWasm(textEncoder.encode(str));
   }
@@ -434,6 +458,7 @@ class ZxBridgeCore {
     writeBytes(ptr, data);
     return { ptr, len: data.length };
   }
+  /** Log a message from WASM at the given level (0=error, 1=warn, 2=info, 3=debug) */
   static log(level, ptr, len) {
     const msg = textDecoder.decode(getMemoryView().subarray(ptr, ptr + len));
     switch (level) {
@@ -451,18 +476,34 @@ class ZxBridgeCore {
         break;
     }
   }
+  /**
+   * Create the core import object for WASM instantiation.
+   * Includes only environment-agnostic bindings: log, fetch, and timers.
+   * Use ZxBridge.createImportObject (from wasm/index.ts) in browser contexts
+   * to additionally include DOM and WebSocket bindings.
+   */
   static createImportObject(bridgeRef) {
     return {
       ...jsz.importObject(),
       __zx_net: createFetchImports(() => {
-        if (!jsz.memory)
-          throw new Error("WASM memory is not ready");
+        if (!jsz.memory) throw new Error("WASM memory is not ready");
         return jsz.memory;
       }),
       __zx: {
-        _log: (level, ptr, len) => ZxBridgeCore.log(level, ptr, len),
+        _log: (level, ptr, len) => _ZxBridgeCore.log(level, ptr, len),
         _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
-          bridgeRef.current?.fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId);
+          bridgeRef.current?.fetchAsync(
+            urlPtr,
+            urlLen,
+            methodPtr,
+            methodLen,
+            headersPtr,
+            headersLen,
+            bodyPtr,
+            bodyLen,
+            timeoutMs,
+            fetchId
+          );
         },
         _setTimeout: (callbackId, delayMs) => {
           bridgeRef.current?.setTimeout(callbackId, delayMs);
@@ -476,72 +517,25 @@ class ZxBridgeCore {
       }
     };
   }
-}
+};
+
 // src/kv.ts
-var exports_kv = {};
-__export(exports_kv, {
-  createMemoryKV: () => createMemoryKV,
-  createKVImports: () => createKVImports
-});
 function putOptions(ttlSeconds) {
-  if (ttlSeconds < 60)
-    return;
+  if (ttlSeconds < 60) return void 0;
   return { expirationTtl: ttlSeconds };
 }
-function createMemoryKV() {
-  const store = new Map;
-  function read(key) {
-    const entry = store.get(key);
-    if (!entry)
-      return null;
-    if (entry.expiresAt !== undefined && Date.now() >= entry.expiresAt) {
-      store.delete(key);
-      return null;
-    }
-    return entry.value;
-  }
-  function write(key, value, options) {
-    let expiresAt;
-    if (options?.expiration !== undefined) {
-      expiresAt = options.expiration * 1000;
-    } else if (options?.expirationTtl !== undefined) {
-      expiresAt = Date.now() + options.expirationTtl * 1000;
-    }
-    store.set(key, { value, expiresAt });
-  }
-  return {
-    async get(key) {
-      return read(key);
-    },
-    async put(key, value, options) {
-      write(key, value, options);
-    },
-    async delete(key) {
-      store.delete(key);
-    },
-    async list(options) {
-      const keys = [...store.keys()].filter((k) => {
-        if (options?.prefix && !k.startsWith(options.prefix))
-          return false;
-        return read(k) !== null;
-      }).map((name) => ({ name }));
-      return { keys };
-    }
-  };
-}
 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;
+  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;
+    if (data.length > buf_max) return -2;
     new Uint8Array(getMemory().buffer, buf_ptr, data.length).set(data);
     return data.length;
   }
@@ -550,40 +544,36 @@ function createKVImports(bindings, getMemory) {
   }
   const Suspending = WebAssembly.Suspending;
   if (typeof Suspending !== "function") {
-    let syncBinding = function(ns) {
+    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 = syncBinding(readStr(ns_ptr, ns_len));
-        if (!b)
-          return -1;
+        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;
+        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 = syncBinding(readStr(ns_ptr, ns_len));
-        if (!b)
-          return 0;
+        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 = syncBinding(readStr(ns_ptr, ns_len));
-        if (!b)
-          return 0;
+        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 = syncBinding(readStr(ns_ptr, ns_len));
-        if (!b)
-          return writeBytes2(buf_ptr, buf_max, encoder2.encode("[]"));
+        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 } : undefined);
+        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))));
       }
     };
@@ -591,33 +581,28 @@ function createKVImports(bindings, getMemory) {
   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;
+      if (!b) return -1;
       const value = await b.get(readStr(key_ptr, key_len));
-      if (value === null)
-        return -1;
+      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;
+      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;
+      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("[]"));
+      if (!b) return writeBytes2(buf_ptr, buf_max, encoder2.encode("[]"));
       const prefix = readStr(prefix_ptr, prefix_len);
-      const result = await b.list(prefix.length > 0 ? { prefix } : undefined);
+      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))));
     })
   };
@@ -729,10 +714,9 @@ function createLocalStorageKV(options = {}) {
     listSync(options2) {
       const prefix = namespacePrefix + (options2?.prefix ?? "");
       const keys = [];
-      for (let i = 0;i < storage.length; i += 1) {
+      for (let i = 0; i < storage.length; i += 1) {
         const key = storage.key(i);
-        if (!key || !key.startsWith(prefix))
-          continue;
+        if (!key || !key.startsWith(prefix)) continue;
         keys.push({ name: key.slice(namespacePrefix.length) });
       }
       return { keys };
@@ -753,8 +737,8 @@ function createBrowserKVBindings(options = {}) {
 }
 
 // src/wasm/index.ts
-class ZxBridge extends ZxBridgeCore {
-  #websockets = new Map;
+var ZxBridge = class extends ZxBridgeCore {
+  #websockets = /* @__PURE__ */ new Map();
   #wsOnOpenHandler;
   #wsOnMessageHandler;
   #wsOnErrorHandler;
@@ -768,7 +752,9 @@ class ZxBridge extends ZxBridgeCore {
     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);
+    this.#eventbridgeAsync = wrapPromisingExport(
+      exports.__zx_eventbridge_async ?? exports.__zx_eventbridge
+    );
   }
   eventMaySuspend(velementId, eventTypeId) {
     return !!((eventHandlerModes.get(velementId) ?? 0) & 1 << eventTypeId);
@@ -777,19 +763,19 @@ class ZxBridge extends ZxBridgeCore {
     const bit = 1 << eventTypeId;
     const current = eventHandlerModes.get(velementId) ?? 0;
     const next = maySuspend ? current | bit : current & ~bit;
-    if (next === 0)
-      eventHandlerModes.delete(velementId);
-    else
-      eventHandlerModes.set(velementId, next);
+    if (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) => {
@@ -800,25 +786,27 @@ class ZxBridge extends ZxBridgeCore {
       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) : undefined;
+    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;
+        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;
+        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);
@@ -826,15 +814,13 @@ class ZxBridge extends ZxBridgeCore {
       };
       ws.onerror = (_event) => {
         const handler = this.#wsOnErrorHandler;
-        if (!handler)
-          return;
+        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;
+        if (!handler) return;
         const reason = event.reason || "";
         const { ptr, len } = this._writeStringToWasm(reason);
         invokeWasmExport(handler, wsId, event.code, ptr, len, event.wasClean ? 1 : 0);
@@ -850,10 +836,10 @@ class ZxBridge extends ZxBridgeCore {
       }
     }
   }
+  /** Send data over WebSocket */
   wsSend(wsId, dataPtr, dataLen, isBinary) {
     const ws = this.#websockets.get(wsId);
-    if (!ws || ws.readyState !== WebSocket.OPEN)
-      return;
+    if (!ws || ws.readyState !== WebSocket.OPEN) return;
     const memory = getMemoryView();
     if (isBinary) {
       ws.send(memory.slice(dataPtr, dataPtr + dataLen));
@@ -861,16 +847,14 @@ class ZxBridge extends ZxBridgeCore {
       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) : undefined;
+    if (!ws) return;
+    const reason = reasonLen > 0 ? readString(reasonPtr, reasonLen) : void 0;
     try {
-      if (reason)
-        ws.close(code, reason);
-      else
-        ws.close(code);
+      if (reason) ws.close(code, reason);
+      else ws.close(code);
     } catch {
       ws.close();
     }
@@ -881,10 +865,12 @@ class ZxBridge extends ZxBridgeCore {
     for (const ws of this.#websockets.values()) {
       try {
         ws.close();
-      } catch {}
+      } 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)) {
@@ -893,12 +879,12 @@ class ZxBridge extends ZxBridgeCore {
     }
     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");
+        if (!jsz.memory) throw new Error("WASM memory is not ready");
         return jsz.memory;
       }),
       __zx: {
@@ -910,7 +896,18 @@ class ZxBridge extends ZxBridgeCore {
           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);
+          bridgeRef.current?.fetchAsync(
+            urlPtr,
+            urlLen,
+            methodPtr,
+            methodLen,
+            headersPtr,
+            headersLen,
+            bodyPtr,
+            bodyLen,
+            timeoutMs,
+            fetchId
+          );
         },
         _setTimeout: (callbackId, delayMs) => {
           bridgeRef.current?.setTimeout(callbackId, delayMs);
@@ -921,6 +918,7 @@ class ZxBridge extends ZxBridgeCore {
         _clearInterval: (callbackId) => {
           bridgeRef.current?.clearInterval(callbackId);
         },
+        // WebSocket API
         _wsConnect: (wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) => {
           bridgeRef.current?.wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen);
         },
@@ -964,26 +962,22 @@ class ZxBridge extends ZxBridgeCore {
         },
         _snv: (vnodeId, ptr, len) => {
           const node = domNodes.get(vnodeId);
-          if (node)
-            node.nodeValue = readString(ptr, len);
+          if (node) node.nodeValue = readString(ptr, len);
         },
         _srh: (vnodeId, ptr, len) => {
           const el = domNodes.get(vnodeId);
-          if (el)
-            el.innerHTML = readString(ptr, len);
+          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);
+          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);
+          if (parent && child) parent.insertBefore(child, ref);
         },
         _rc: (parentId, childId) => {
           const parent = domNodes.get(parentId);
@@ -1010,8 +1004,7 @@ class ZxBridge extends ZxBridgeCore {
         },
         _getFormData: (vnodeId, bufPtr, bufLen) => {
           const form = domNodes.get(vnodeId);
-          if (!form || !(form instanceof HTMLFormElement))
-            return 0;
+          if (!form || !(form instanceof HTMLFormElement)) return 0;
           const formData = new FormData(form);
           const urlEncoded = new URLSearchParams(formData).toString();
           const bytes = textEncoder.encode(urlEncoded);
@@ -1021,34 +1014,32 @@ class ZxBridge extends ZxBridgeCore {
         },
         _submitFormAction: (vnodeId, actionId) => {
           const form = domNodes.get(vnodeId);
-          if (!form || !(form instanceof HTMLFormElement))
-            return;
+          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(() => {});
+          }).catch(() => {
+          });
         },
         _submitFormActionAsync: (vnodeId, actionId, statesPtr, statesLen, fetchId) => {
           const form = domNodes.get(vnodeId);
-          if (!form || !(form instanceof HTMLFormElement))
-            return;
+          if (!form || !(form instanceof HTMLFormElement)) return;
           const statesJson = statesLen > 0 ? readString(statesPtr, statesLen) : "[]";
           bridgeRef.current?.submitFormActionAsync(form, actionId, statesJson, fetchId);
         }
       }
     };
   }
-}
-var domNodes = new Map;
+};
+var domNodes = /* @__PURE__ */ new Map();
 function cleanupDomNodes(node) {
   const ref = node.__zx_ref;
-  if (ref !== undefined)
-    domNodes.delete(BigInt(ref));
+  if (ref !== void 0) domNodes.delete(BigInt(ref));
   const children = node.childNodes;
-  for (let i = 0;i < children.length; i++)
-    cleanupDomNodes(children[i]);
+  for (let i = 0; i < children.length; i++) cleanupDomNodes(children[i]);
 }
 var SVG_TAG_START_INDEX = 140;
 var TAG_NAMES = [
@@ -1192,6 +1183,7 @@ var TAG_NAMES = [
   "strike",
   "tt",
   "xmp",
+  // SVG Tags
   "animate",
   "animateMotion",
   "animateTransform",
@@ -1258,6 +1250,7 @@ var DELEGATED_EVENTS = [
   { 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 },
@@ -1273,21 +1266,20 @@ var DELEGATED_EVENTS = [
   { domType: "touchmove", eventTypeId: 17 },
   { domType: "scroll", eventTypeId: 18 }
 ];
-var eventHandlerModes = new Map;
+var eventHandlerModes = /* @__PURE__ */ new Map();
 function initEventDelegation(bridge, rootSelector = "body") {
   const root = document.querySelector(rootSelector);
-  if (!root)
-    return () => {};
+  if (!root) return () => {
+  };
   const removers = [];
   for (const delegatedEvent of DELEGATED_EVENTS) {
     const listener = (event) => {
       let target = event.target;
       while (target && target !== document.body) {
         const zxRef = target.__zx_ref;
-        if (zxRef !== undefined) {
+        if (zxRef !== void 0) {
           bridge.eventbridge(BigInt(zxRef), delegatedEvent.eventTypeId, event);
-          if (event.cancelBubble)
-            break;
+          if (event.cancelBubble) break;
         }
         target = target.parentElement;
       }
@@ -1297,8 +1289,7 @@ function initEventDelegation(bridge, rootSelector = "body") {
     removers.push(() => root.removeEventListener(delegatedEvent.domType, listener, options));
   }
   return () => {
-    for (const remove of removers)
-      remove();
+    for (const remove of removers) remove();
   };
 }
 var DEFAULT_URL = "/assets/_/main.wasm";
@@ -1320,8 +1311,7 @@ function normalizeOptions(options = {}) {
   };
 }
 function registerDevReinit(options) {
-  if (typeof window === "undefined")
-    return;
+  if (typeof window === "undefined") return;
   const reinit = () => init(options);
   window.__zx_dev_reinit = reinit;
   window.__ZIEX_DEVTOOLS_GLOBAL_HOOK__ = {
@@ -1341,14 +1331,17 @@ async function init(options = {}) {
   const kvBindings = options.kv ?? createBrowserKVBindings();
   const kvImportObject = {
     __zx_kv: createKVImports(kvBindings, () => {
-      if (wasmMemory)
-        return wasmMemory;
-      if (jsz.memory)
-        return jsz.memory;
+      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 importObject = Object.assign(
+    {},
+    ZxBridge.createImportObject(bridgeRef),
+    kvImportObject,
+    options.importObject
+  );
   const source = await WebAssembly.instantiateStreaming(fetch(url), importObject);
   const { instance } = source;
   wasmMemory = instance.exports.memory;
@@ -1367,21 +1360,20 @@ async function init(options = {}) {
       domNodes.clear();
     }
   };
-  if (true)
-    registerDevReinit(normalizedOptions);
+  if (true) registerDevReinit(normalizedOptions);
   return { source, bridge };
 }
 export {
-  writeBytes,
-  textEncoder,
-  textDecoder,
-  storeValueGetRef,
-  readString,
-  jsz,
-  initEventDelegation,
-  init,
-  getMemoryView,
-  ZxBridgeCore,
+  CallbackType,
   ZxBridge,
-  CallbackType
+  ZxBridgeCore,
+  getMemoryView,
+  init,
+  initEventDelegation,
+  jsz,
+  readString,
+  storeValueGetRef,
+  textDecoder,
+  textEncoder,
+  writeBytes
 };