ziex 0.0.1-dev.7 → 0.1.0-dev.1000

package/wasm/index.js

@@ -1,4 +1,19 @@
-// node_modules/jsz/js/src/zigjs.ts
+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,
@@ -167,53 +182,1090 @@ class ZigJS {
     return decoder.decode(data);
   }
 }
-// src/wasm/index.ts
-var DEFAULT_URL = "/assets/main.wasm";
-var MAX_EVENTS = 100;
-var jsz = new ZigJS;
-var importObject = {
-  module: {},
-  env: {},
-  ...jsz.importObject()
+// src/wasm/core.ts
+var CallbackType = {
+  Event: 0,
+  FetchSuccess: 1,
+  FetchError: 2,
+  Timeout: 3,
+  Interval: 4,
+  WebSocketOpen: 5,
+  WebSocketMessage: 6,
+  WebSocketError: 7,
+  WebSocketClose: 8
 };
+var jsz = new ZigJS;
+var tempRefBuffer = new ArrayBuffer(8);
+var tempRefView = new DataView(tempRefBuffer);
+function storeValueGetRef(val) {
+  const originalMemory = jsz.memory;
+  jsz.memory = { buffer: tempRefBuffer };
+  jsz.storeValue(0, val);
+  jsz.memory = originalMemory;
+  return tempRefView.getBigUint64(0, true);
+}
+var textDecoder = new TextDecoder;
+var textEncoder = new TextEncoder;
+var memoryView = null;
+var memoryBuffer = null;
+function getMemoryView() {
+  const buf = jsz.memory.buffer;
+  if (buf !== memoryBuffer) {
+    memoryBuffer = buf;
+    memoryView = new Uint8Array(buf);
+  }
+  return memoryView;
+}
+var stringCache = new Map;
+function stringCacheKey(ptr, len) {
+  return ptr * 65536 + len;
+}
+function readString(ptr, len) {
+  const key = stringCacheKey(ptr, len);
+  const cached = stringCache.get(key);
+  if (cached !== undefined)
+    return cached;
+  const str = textDecoder.decode(getMemoryView().subarray(ptr, ptr + len));
+  stringCache.set(key, str);
+  return str;
+}
+function writeBytes(ptr, data) {
+  getMemoryView().set(data, ptr);
+}
+function wrapPromisingExport(fn) {
+  if (!fn)
+    return;
+  const promising = WebAssembly.promising;
+  if (typeof promising !== "function")
+    return fn;
+  return promising(fn);
+}
+function invokeWasmExport(fn, ...args) {
+  if (!fn)
+    return;
+  const result = fn(...args);
+  if (result && typeof result.then === "function") {
+    result.then(undefined, (error) => {
+      console.error(error);
+    });
+  }
+}
+
+class ZxBridgeCore {
+  #intervals = new Map;
+  _alloc;
+  #handler;
+  #fetchCompleteHandler;
+  constructor(exports) {
+    this._alloc = exports.__zx_alloc;
+    this.#handler = wrapPromisingExport(exports.__zx_cb);
+    const fetchCompleteHandler = wrapPromisingExport(exports.__zx_fetch_complete);
+    if (!fetchCompleteHandler) {
+      throw new Error("__zx_fetch_complete not exported from WASM");
+    }
+    this.#fetchCompleteHandler = fetchCompleteHandler;
+    if (exports.memory)
+      jsz.memory = exports.memory;
+  }
+  #invoke(type, id, data) {
+    const handler = this.#handler;
+    if (!handler) {
+      console.warn("__zx_cb not exported from WASM");
+      return;
+    }
+    const dataRef = storeValueGetRef(data);
+    invokeWasmExport(handler, type, id, dataRef);
+  }
+  fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) {
+    const url = readString(urlPtr, urlLen);
+    const method = methodLen > 0 ? readString(methodPtr, methodLen) : "GET";
+    const headersJson = headersLen > 0 ? readString(headersPtr, headersLen) : "{}";
+    const body = bodyLen > 0 ? readString(bodyPtr, bodyLen) : undefined;
+    let headers = {};
+    try {
+      headers = JSON.parse(headersJson);
+    } catch {
+      for (const line of headersJson.split(`
+`)) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx > 0) {
+          headers[line.slice(0, colonIdx)] = line.slice(colonIdx + 1);
+        }
+      }
+    }
+    const controller = new AbortController;
+    const timeout = timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
+    const fetchOptions = {
+      method,
+      headers: Object.keys(headers).length > 0 ? headers : undefined,
+      body: method !== "GET" && method !== "HEAD" ? body : undefined,
+      signal: controller.signal
+    };
+    fetch(url, fetchOptions).then(async (response) => {
+      if (timeout)
+        clearTimeout(timeout);
+      const text = await response.text();
+      this._notifyFetchComplete(fetchId, response.status, text, false);
+    }).catch((error) => {
+      if (timeout)
+        clearTimeout(timeout);
+      const isAbort = error.name === "AbortError";
+      const errorMsg = isAbort ? "Request timeout" : error.message ?? "Fetch failed";
+      this._notifyFetchComplete(fetchId, 0, errorMsg, true);
+    });
+  }
+  _notifyFetchComplete(fetchId, statusCode, body, isError) {
+    const handler = this.#fetchCompleteHandler;
+    const encoded = textEncoder.encode(body);
+    const ptr = this._alloc(encoded.length);
+    writeBytes(ptr, encoded);
+    invokeWasmExport(handler, fetchId, statusCode, ptr, encoded.length, isError ? 1 : 0);
+  }
+  setTimeout(callbackId, delayMs) {
+    setTimeout(() => {
+      this.#invoke(CallbackType.Timeout, callbackId, null);
+    }, delayMs);
+  }
+  setInterval(callbackId, intervalMs) {
+    const handle = setInterval(() => {
+      this.#invoke(CallbackType.Interval, callbackId, null);
+    }, intervalMs);
+    this.#intervals.set(callbackId, handle);
+  }
+  clearInterval(callbackId) {
+    const handle = this.#intervals.get(callbackId);
+    if (handle !== undefined) {
+      clearInterval(handle);
+      this.#intervals.delete(callbackId);
+    }
+  }
+  dispose() {
+    for (const handle of this.#intervals.values()) {
+      clearInterval(handle);
+    }
+    this.#intervals.clear();
+  }
+  _writeStringToWasm(str) {
+    return this._writeBytesToWasm(textEncoder.encode(str));
+  }
+  _writeBytesToWasm(data) {
+    const ptr = this._alloc(data.length);
+    writeBytes(ptr, data);
+    return { ptr, len: data.length };
+  }
+  static log(level, ptr, len) {
+    const msg = textDecoder.decode(getMemoryView().subarray(ptr, ptr + len));
+    switch (level) {
+      case 0:
+        console.error(msg);
+        break;
+      case 1:
+        console.warn(msg);
+        break;
+      case 3:
+        console.debug(msg);
+        break;
+      default:
+        console.log(msg);
+        break;
+    }
+  }
+  static createImportObject(bridgeRef) {
+    return {
+      ...jsz.importObject(),
+      __zx: {
+        _log: (level, ptr, len) => ZxBridgeCore.log(level, ptr, len),
+        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
+          bridgeRef.current?.fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId);
+        },
+        _setTimeout: (callbackId, delayMs) => {
+          bridgeRef.current?.setTimeout(callbackId, delayMs);
+        },
+        _setInterval: (callbackId, intervalMs) => {
+          bridgeRef.current?.setInterval(callbackId, intervalMs);
+        },
+        _clearInterval: (callbackId) => {
+          bridgeRef.current?.clearInterval(callbackId);
+        }
+      }
+    };
+  }
+}
+// src/kv.ts
+var exports_kv = {};
+__export(exports_kv, {
+  createMemoryKV: () => createMemoryKV,
+  createKVImports: () => createKVImports
+});
+function createMemoryKV() {
+  const store = new Map;
+  return {
+    async get(key) {
+      return store.get(key) ?? null;
+    },
+    async put(key, value) {
+      store.set(key, value);
+    },
+    async delete(key) {
+      store.delete(key);
+    },
+    async list(options) {
+      const keys = [...store.keys()].filter((k) => !options?.prefix || k.startsWith(options.prefix)).map((name) => ({ name }));
+      return { keys };
+    }
+  };
+}
+function isSyncKVNamespace(binding) {
+  const candidate = binding;
+  return typeof candidate.getSync === "function" && typeof candidate.putSync === "function" && typeof candidate.deleteSync === "function" && typeof candidate.listSync === "function";
+}
+function createKVImports(bindings, getMemory) {
+  const encoder2 = new TextEncoder;
+  const decoder2 = new TextDecoder;
+  function readStr(ptr, len) {
+    return decoder2.decode(new Uint8Array(getMemory().buffer, ptr, len));
+  }
+  function writeBytes2(buf_ptr, buf_max, data) {
+    if (data.length > buf_max)
+      return -2;
+    new Uint8Array(getMemory().buffer, buf_ptr, data.length).set(data);
+    return data.length;
+  }
+  function binding(ns) {
+    return bindings[ns] ?? bindings["default"] ?? null;
+  }
+  const Suspending = WebAssembly.Suspending;
+  if (typeof Suspending !== "function") {
+    let syncBinding = function(ns) {
+      const candidate = binding(ns);
+      return candidate && isSyncKVNamespace(candidate) ? candidate : null;
+    };
+    return {
+      kv_get: (ns_ptr, ns_len, key_ptr, key_len, buf_ptr, buf_max) => {
+        const b = syncBinding(readStr(ns_ptr, ns_len));
+        if (!b)
+          return -1;
+        const value = b.getSync(readStr(key_ptr, key_len));
+        if (value === null)
+          return -1;
+        return writeBytes2(buf_ptr, buf_max, encoder2.encode(value));
+      },
+      kv_put: (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len) => {
+        const b = syncBinding(readStr(ns_ptr, ns_len));
+        if (!b)
+          return 0;
+        b.putSync(readStr(key_ptr, key_len), readStr(val_ptr, val_len));
+        return 0;
+      },
+      kv_delete: (ns_ptr, ns_len, key_ptr, key_len) => {
+        const b = syncBinding(readStr(ns_ptr, ns_len));
+        if (!b)
+          return 0;
+        b.deleteSync(readStr(key_ptr, key_len));
+        return 0;
+      },
+      kv_list: (ns_ptr, ns_len, pfx_ptr, pfx_len, buf_ptr, buf_max) => {
+        const b = syncBinding(readStr(ns_ptr, ns_len));
+        if (!b)
+          return writeBytes2(buf_ptr, buf_max, encoder2.encode("[]"));
+        const prefix = readStr(pfx_ptr, pfx_len);
+        const result = b.listSync(prefix.length > 0 ? { prefix } : undefined);
+        return writeBytes2(buf_ptr, buf_max, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
+      }
+    };
+  }
+  return {
+    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, buf_ptr, buf_max) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b)
+        return -1;
+      const value = await b.get(readStr(key_ptr, key_len));
+      if (value === null)
+        return -1;
+      return writeBytes2(buf_ptr, buf_max, encoder2.encode(value));
+    }),
+    kv_put: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b)
+        return -1;
+      await b.put(readStr(key_ptr, key_len), readStr(val_ptr, val_len));
+      return 0;
+    }),
+    kv_delete: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b)
+        return -1;
+      await b.delete(readStr(key_ptr, key_len));
+      return 0;
+    }),
+    kv_list: new Suspending(async (ns_ptr, ns_len, prefix_ptr, prefix_len, buf_ptr, buf_max) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b)
+        return writeBytes2(buf_ptr, buf_max, encoder2.encode("[]"));
+      const prefix = readStr(prefix_ptr, prefix_len);
+      const result = await b.list(prefix.length > 0 ? { prefix } : undefined);
+      return writeBytes2(buf_ptr, buf_max, encoder2.encode(JSON.stringify(result.keys.map((k) => k.name))));
+    })
+  };
+}
+
+// src/browser/kv.ts
+function getIndexedDb() {
+  if (typeof indexedDB === "undefined") {
+    throw new Error("IndexedDB is not available in this environment");
+  }
+  return indexedDB;
+}
+function requestToPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+function transactionToPromise(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
+    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed"));
+  });
+}
+function createIndexedDbKV(options = {}) {
+  const databaseName = options.databaseName ?? "ziex-kv";
+  const storeName = options.storeName ?? "kv";
+  const namespace = options.namespace ?? "default";
+  const dbPromise = new Promise((resolve, reject) => {
+    const request = getIndexedDb().open(databaseName, 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName);
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
+  });
+  const scopedKey = (key) => `${namespace}:${key}`;
+  return {
+    async get(key) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readonly");
+      const store = tx.objectStore(storeName);
+      const value = await requestToPromise(store.get(scopedKey(key)));
+      await transactionToPromise(tx);
+      console.debug(`KV GET - Key: ${key}, Value: ${value}`);
+      return typeof value === "string" ? value : null;
+    },
+    async put(key, value) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readwrite");
+      tx.objectStore(storeName).put(value, scopedKey(key));
+      await transactionToPromise(tx);
+      console.debug(`KV PUT - Key: ${key}, Value: ${value}`);
+    },
+    async delete(key) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readwrite");
+      tx.objectStore(storeName).delete(scopedKey(key));
+      await transactionToPromise(tx);
+    },
+    async list(options2) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readonly");
+      const store = tx.objectStore(storeName);
+      const keys = await requestToPromise(store.getAllKeys());
+      await transactionToPromise(tx);
+      const prefix = scopedKey(options2?.prefix ?? "");
+      return {
+        keys: keys.filter((key) => typeof key === "string" && key.startsWith(prefix)).map((key) => ({ name: key.slice(namespace.length + 1) }))
+      };
+    }
+  };
+}
+function getLocalStorage() {
+  if (typeof localStorage === "undefined") {
+    throw new Error("localStorage is not available in this environment");
+  }
+  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);
+    }
+  };
+}
+function hasJSPI() {
+  return typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
+}
+function createBrowserKVBindings(options = {}) {
+  const namespace = options.namespace ?? "default";
+  return {
+    [namespace]: hasJSPI() ? createIndexedDbKV(options) : createLocalStorageKV(options)
+  };
+}
 
-class ZXInstance {
-  exports;
-  events;
-  actions;
-  constructor({ exports, events = [] }) {
-    this.exports = exports;
-    this.events = events;
-    this.actions = {};
-    Object.entries(exports).forEach(([name, func]) => {
-      if (typeof func !== "function")
-        return;
-      this.actions[name] = this.#actionWrapper.bind(this, name);
+// src/wasm/index.ts
+class ZxBridge extends ZxBridgeCore {
+  #websockets = new Map;
+  #wsOnOpenHandler;
+  #wsOnMessageHandler;
+  #wsOnErrorHandler;
+  #wsOnCloseHandler;
+  #eventbridge;
+  #eventbridgeAsync;
+  constructor(exports) {
+    super(exports);
+    this.#wsOnOpenHandler = wrapPromisingExport(exports.__zx_ws_onopen);
+    this.#wsOnMessageHandler = wrapPromisingExport(exports.__zx_ws_onmessage);
+    this.#wsOnErrorHandler = wrapPromisingExport(exports.__zx_ws_onerror);
+    this.#wsOnCloseHandler = wrapPromisingExport(exports.__zx_ws_onclose);
+    this.#eventbridge = exports.__zx_eventbridge;
+    this.#eventbridgeAsync = wrapPromisingExport(exports.__zx_eventbridge_async ?? exports.__zx_eventbridge);
+  }
+  eventMaySuspend(velementId, eventTypeId) {
+    return !!((eventHandlerModes.get(velementId) ?? 0) & 1 << eventTypeId);
+  }
+  setEventHandlerMode(velementId, eventTypeId, maySuspend) {
+    const bit = 1 << eventTypeId;
+    const current = eventHandlerModes.get(velementId) ?? 0;
+    const next = maySuspend ? current | bit : current & ~bit;
+    if (next === 0)
+      eventHandlerModes.delete(velementId);
+    else
+      eventHandlerModes.set(velementId, next);
+  }
+  clearEventHandlerModes(velementId) {
+    eventHandlerModes.delete(velementId);
+  }
+  submitFormActionAsync(form, statesJson, fetchId) {
+    const formData = new FormData(form);
+    formData.append("__$states", statesJson);
+    fetch(window.location.href, {
+      method: "POST",
+      headers: { "X-ZX-Action": "1" },
+      body: formData
+    }).then(async (response) => {
+      const text = await response.text();
+      this._notifyFetchComplete(fetchId, response.status, text, false);
+    }).catch((error) => {
+      const msg = error instanceof Error ? error.message : "Fetch failed";
+      this._notifyFetchComplete(fetchId, 0, msg, true);
     });
   }
-  addEvent(event) {
-    if (this.events.length >= MAX_EVENTS)
-      this.events.length = 0;
-    const idx = this.events.push(event);
-    return idx - 1;
+  wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) {
+    const url = readString(urlPtr, urlLen);
+    const protocolsStr = protocolsLen > 0 ? readString(protocolsPtr, protocolsLen) : "";
+    const protocols = protocolsStr ? protocolsStr.split(",").map((p) => p.trim()).filter(Boolean) : undefined;
+    try {
+      const ws = protocols && protocols.length > 0 ? new WebSocket(url, protocols) : new WebSocket(url);
+      ws.binaryType = "arraybuffer";
+      ws.onopen = () => {
+        const handler = this.#wsOnOpenHandler;
+        if (!handler)
+          return;
+        const protocol = ws.protocol || "";
+        const { ptr, len } = this._writeStringToWasm(protocol);
+        invokeWasmExport(handler, wsId, ptr, len);
+      };
+      ws.onmessage = (event) => {
+        const handler = this.#wsOnMessageHandler;
+        if (!handler)
+          return;
+        const isBinary = event.data instanceof ArrayBuffer;
+        const data = isBinary ? new Uint8Array(event.data) : textEncoder.encode(event.data);
+        const { ptr, len } = this._writeBytesToWasm(data);
+        invokeWasmExport(handler, wsId, ptr, len, isBinary ? 1 : 0);
+      };
+      ws.onerror = (_event) => {
+        const handler = this.#wsOnErrorHandler;
+        if (!handler)
+          return;
+        const { ptr, len } = this._writeStringToWasm("WebSocket error");
+        invokeWasmExport(handler, wsId, ptr, len);
+      };
+      ws.onclose = (event) => {
+        const handler = this.#wsOnCloseHandler;
+        if (!handler)
+          return;
+        const reason = event.reason || "";
+        const { ptr, len } = this._writeStringToWasm(reason);
+        invokeWasmExport(handler, wsId, event.code, ptr, len, event.wasClean ? 1 : 0);
+        this.#websockets.delete(wsId);
+      };
+      this.#websockets.set(wsId, ws);
+    } catch (error) {
+      const handler = this.#wsOnErrorHandler;
+      if (handler) {
+        const msg = error instanceof Error ? error.message : "WebSocket connection failed";
+        const { ptr, len } = this._writeStringToWasm(msg);
+        invokeWasmExport(handler, wsId, ptr, len);
+      }
+    }
+  }
+  wsSend(wsId, dataPtr, dataLen, isBinary) {
+    const ws = this.#websockets.get(wsId);
+    if (!ws || ws.readyState !== WebSocket.OPEN)
+      return;
+    const memory = getMemoryView();
+    if (isBinary) {
+      ws.send(memory.slice(dataPtr, dataPtr + dataLen));
+    } else {
+      ws.send(textDecoder.decode(memory.subarray(dataPtr, dataPtr + dataLen)));
+    }
+  }
+  wsClose(wsId, code, reasonPtr, reasonLen) {
+    const ws = this.#websockets.get(wsId);
+    if (!ws)
+      return;
+    const reason = reasonLen > 0 ? readString(reasonPtr, reasonLen) : undefined;
+    try {
+      if (reason)
+        ws.close(code, reason);
+      else
+        ws.close(code);
+    } catch {
+      ws.close();
+    }
   }
-  #actionWrapper(name, ...args) {
-    const func = this.exports[name];
-    if (typeof func !== "function")
-      throw new Error(`Action ${name} is not a function`);
-    const eventId = this.addEvent(args[0]);
-    return func(eventId);
+  dispose() {
+    super.dispose();
+    eventHandlerModes.clear();
+    for (const ws of this.#websockets.values()) {
+      try {
+        ws.close();
+      } catch {}
+    }
+    this.#websockets.clear();
+  }
+  eventbridge(velementId, eventTypeId, event) {
+    const eventRef = storeValueGetRef(event);
+    if (this.eventMaySuspend(velementId, eventTypeId)) {
+      invokeWasmExport(this.#eventbridgeAsync, velementId, eventTypeId, eventRef);
+      return;
+    }
+    invokeWasmExport(this.#eventbridge, velementId, eventTypeId, eventRef);
+  }
+  static createImportObject(bridgeRef) {
+    return {
+      ...jsz.importObject(),
+      __zx: {
+        _log: (level, ptr, len) => ZxBridgeCore.log(level, ptr, len),
+        _setEventHandlerMode: (vnodeId, eventTypeId, maySuspend) => {
+          bridgeRef.current?.setEventHandlerMode(vnodeId, eventTypeId, maySuspend !== 0);
+        },
+        _clearEventHandlerModes: (vnodeId) => {
+          bridgeRef.current?.clearEventHandlerModes(vnodeId);
+        },
+        _fetchAsync: (urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId) => {
+          bridgeRef.current?.fetchAsync(urlPtr, urlLen, methodPtr, methodLen, headersPtr, headersLen, bodyPtr, bodyLen, timeoutMs, fetchId);
+        },
+        _setTimeout: (callbackId, delayMs) => {
+          bridgeRef.current?.setTimeout(callbackId, delayMs);
+        },
+        _setInterval: (callbackId, intervalMs) => {
+          bridgeRef.current?.setInterval(callbackId, intervalMs);
+        },
+        _clearInterval: (callbackId) => {
+          bridgeRef.current?.clearInterval(callbackId);
+        },
+        _wsConnect: (wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) => {
+          bridgeRef.current?.wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen);
+        },
+        _wsSend: (wsId, dataPtr, dataLen, isBinary) => {
+          bridgeRef.current?.wsSend(wsId, dataPtr, dataLen, isBinary);
+        },
+        _wsClose: (wsId, code, reasonPtr, reasonLen) => {
+          bridgeRef.current?.wsClose(wsId, code, reasonPtr, reasonLen);
+        },
+        _ce: (id, vnodeId) => {
+          const tagName = TAG_NAMES[id];
+          const el = id >= SVG_TAG_START_INDEX ? document.createElementNS("http://www.w3.org/2000/svg", tagName) : document.createElement(tagName);
+          el.__zx_ref = Number(vnodeId);
+          domNodes.set(vnodeId, el);
+          return storeValueGetRef(el);
+        },
+        _ct: (ptr, len, vnodeId) => {
+          const text = readString(ptr, len);
+          const node = document.createTextNode(text);
+          node.__zx_ref = Number(vnodeId);
+          domNodes.set(vnodeId, node);
+          return storeValueGetRef(node);
+        },
+        _sa: (vnodeId, namePtr, nameLen, valPtr, valLen) => {
+          domNodes.get(vnodeId)?.setAttribute(readString(namePtr, nameLen), readString(valPtr, valLen));
+        },
+        _ra: (vnodeId, namePtr, nameLen) => {
+          domNodes.get(vnodeId)?.removeAttribute(readString(namePtr, nameLen));
+        },
+        _snv: (vnodeId, ptr, len) => {
+          const node = domNodes.get(vnodeId);
+          if (node)
+            node.nodeValue = readString(ptr, len);
+        },
+        _ac: (parentId, childId) => {
+          const parent = domNodes.get(parentId);
+          const child = domNodes.get(childId);
+          if (parent && child)
+            parent.appendChild(child);
+        },
+        _ib: (parentId, childId, refId) => {
+          const parent = domNodes.get(parentId);
+          const child = domNodes.get(childId);
+          const ref = domNodes.get(refId) ?? null;
+          if (parent && child)
+            parent.insertBefore(child, ref);
+        },
+        _rc: (parentId, childId) => {
+          const parent = domNodes.get(parentId);
+          const child = domNodes.get(childId);
+          if (parent && child) {
+            parent.removeChild(child);
+            cleanupDomNodes(child);
+          }
+        },
+        _rpc: (parentId, newId, oldId) => {
+          const parent = domNodes.get(parentId);
+          const newChild = domNodes.get(newId);
+          const oldChild = domNodes.get(oldId);
+          if (parent && newChild && oldChild) {
+            parent.replaceChild(newChild, oldChild);
+            cleanupDomNodes(oldChild);
+          }
+        },
+        _getLocationHref: (bufPtr, bufLen) => {
+          const bytes = textEncoder.encode(window.location.href);
+          const len = Math.min(bytes.length, bufLen);
+          writeBytes(bufPtr, bytes.subarray(0, len));
+          return len;
+        },
+        _getFormData: (vnodeId, bufPtr, bufLen) => {
+          const form = domNodes.get(vnodeId);
+          if (!form || !(form instanceof HTMLFormElement))
+            return 0;
+          const formData = new FormData(form);
+          const urlEncoded = new URLSearchParams(formData).toString();
+          const bytes = textEncoder.encode(urlEncoded);
+          const len = Math.min(bytes.length, bufLen);
+          writeBytes(bufPtr, bytes.subarray(0, len));
+          return len;
+        },
+        _submitFormAction: (vnodeId) => {
+          const form = domNodes.get(vnodeId);
+          if (!form || !(form instanceof HTMLFormElement))
+            return;
+          const formData = new FormData(form);
+          fetch(window.location.href, {
+            method: "POST",
+            headers: { "X-ZX-Action": "1" },
+            body: formData
+          }).catch(() => {});
+        },
+        _submitFormActionAsync: (vnodeId, statesPtr, statesLen, fetchId) => {
+          const form = domNodes.get(vnodeId);
+          if (!form || !(form instanceof HTMLFormElement))
+            return;
+          const statesJson = statesLen > 0 ? readString(statesPtr, statesLen) : "[]";
+          bridgeRef.current?.submitFormActionAsync(form, statesJson, fetchId);
+        }
+      }
+    };
   }
 }
+var domNodes = new Map;
+function cleanupDomNodes(node) {
+  const ref = node.__zx_ref;
+  if (ref !== undefined)
+    domNodes.delete(BigInt(ref));
+  const children = node.childNodes;
+  for (let i = 0;i < children.length; i++)
+    cleanupDomNodes(children[i]);
+}
+var SVG_TAG_START_INDEX = 140;
+var TAG_NAMES = [
+  "aside",
+  "fragment",
+  "iframe",
+  "slot",
+  "img",
+  "html",
+  "base",
+  "head",
+  "link",
+  "meta",
+  "script",
+  "style",
+  "title",
+  "address",
+  "article",
+  "body",
+  "h1",
+  "h6",
+  "footer",
+  "header",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "hgroup",
+  "nav",
+  "section",
+  "dd",
+  "dl",
+  "dt",
+  "div",
+  "figcaption",
+  "figure",
+  "hr",
+  "li",
+  "ol",
+  "ul",
+  "menu",
+  "main",
+  "p",
+  "picture",
+  "pre",
+  "a",
+  "abbr",
+  "b",
+  "bdi",
+  "bdo",
+  "br",
+  "cite",
+  "code",
+  "data",
+  "time",
+  "dfn",
+  "em",
+  "i",
+  "kbd",
+  "mark",
+  "q",
+  "blockquote",
+  "rp",
+  "ruby",
+  "rt",
+  "rtc",
+  "rb",
+  "s",
+  "del",
+  "ins",
+  "samp",
+  "small",
+  "span",
+  "strong",
+  "sub",
+  "sup",
+  "u",
+  "var",
+  "wbr",
+  "area",
+  "map",
+  "audio",
+  "source",
+  "track",
+  "video",
+  "embed",
+  "object",
+  "param",
+  "canvas",
+  "noscript",
+  "caption",
+  "table",
+  "col",
+  "colgroup",
+  "tbody",
+  "tr",
+  "thead",
+  "tfoot",
+  "td",
+  "th",
+  "button",
+  "datalist",
+  "option",
+  "fieldset",
+  "label",
+  "form",
+  "input",
+  "keygen",
+  "legend",
+  "meter",
+  "optgroup",
+  "select",
+  "output",
+  "progress",
+  "textarea",
+  "details",
+  "dialog",
+  "menuitem",
+  "summary",
+  "content",
+  "element",
+  "shadow",
+  "template",
+  "acronym",
+  "applet",
+  "basefont",
+  "font",
+  "big",
+  "blink",
+  "center",
+  "command",
+  "dir",
+  "frame",
+  "frameset",
+  "isindex",
+  "listing",
+  "marquee",
+  "noembed",
+  "plaintext",
+  "spacer",
+  "strike",
+  "tt",
+  "xmp",
+  "animate",
+  "animateMotion",
+  "animateTransform",
+  "circle",
+  "clipPath",
+  "defs",
+  "desc",
+  "ellipse",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feDistantLight",
+  "feDropShadow",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "fePointLight",
+  "feSpecularLighting",
+  "feSpotLight",
+  "feTile",
+  "feTurbulence",
+  "filter",
+  "foreignObject",
+  "g",
+  "image",
+  "line",
+  "linearGradient",
+  "marker",
+  "mask",
+  "metadata",
+  "mpath",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "radialGradient",
+  "rect",
+  "set",
+  "stop",
+  "svg",
+  "switch",
+  "symbol",
+  "text",
+  "textPath",
+  "tspan",
+  "use",
+  "view"
+];
+var DELEGATED_EVENTS = [
+  "click",
+  "dblclick",
+  "input",
+  "change",
+  "submit",
+  "focus",
+  "blur",
+  "keydown",
+  "keyup",
+  "keypress",
+  "mouseenter",
+  "mouseleave",
+  "mousedown",
+  "mouseup",
+  "mousemove",
+  "touchstart",
+  "touchend",
+  "touchmove",
+  "scroll"
+];
+var EVENT_TYPE_MAP = {
+  click: 0,
+  dblclick: 1,
+  input: 2,
+  change: 3,
+  submit: 4,
+  focus: 5,
+  blur: 6,
+  keydown: 7,
+  keyup: 8,
+  keypress: 9,
+  mouseenter: 10,
+  mouseleave: 11,
+  mousedown: 12,
+  mouseup: 13,
+  mousemove: 14,
+  touchstart: 15,
+  touchend: 16,
+  touchmove: 17,
+  scroll: 18
+};
+var eventHandlerModes = new Map;
+function initEventDelegation(bridge, rootSelector = "body") {
+  const root = document.querySelector(rootSelector);
+  if (!root)
+    return () => {};
+  const removers = [];
+  for (const eventType of DELEGATED_EVENTS) {
+    const listener = (event) => {
+      let target = event.target;
+      while (target && target !== document.body) {
+        const zxRef = target.__zx_ref;
+        if (zxRef !== undefined) {
+          bridge.eventbridge(BigInt(zxRef), EVENT_TYPE_MAP[eventType] ?? 0, event);
+          if (event.cancelBubble)
+            break;
+        }
+        target = target.parentElement;
+      }
+    };
+    const options = { passive: eventType.startsWith("touch") || eventType === "scroll" };
+    root.addEventListener(eventType, listener, options);
+    removers.push(() => root.removeEventListener(eventType, listener, options));
+  }
+  return () => {
+    for (const remove of removers)
+      remove();
+  };
+}
+var DEFAULT_URL = "/assets/_/main.wasm";
+var activeRuntime = null;
+function buildDevtoolsLocation() {
+  return {
+    href: window.location.href,
+    origin: window.location.origin,
+    host: window.location.host,
+    pathname: window.location.pathname
+  };
+}
+function normalizeOptions(options = {}) {
+  return {
+    url: options.url,
+    eventDelegationRoot: options.eventDelegationRoot,
+    importObject: options.importObject,
+    kv: options.kv
+  };
+}
+function registerDevReinit(options) {
+  if (typeof window === "undefined")
+    return;
+  const reinit = () => init(options);
+  window.__zx_dev_reinit = reinit;
+  window.__ZIEX_DEVTOOLS_GLOBAL_HOOK__ = {
+    location: buildDevtoolsLocation(),
+    reinit
+  };
+}
 async function init(options = {}) {
-  const url = options?.url ?? DEFAULT_URL;
-  const { instance } = await WebAssembly.instantiateStreaming(fetch(url), importObject);
-  jsz.memory = instance.exports.memory;
-  window._zx = new ZXInstance({ exports: instance.exports });
-  const main = instance.exports.mainClient;
-  if (typeof main === "function")
-    main();
+  const normalizedOptions = normalizeOptions(options);
+  if (activeRuntime) {
+    activeRuntime.dispose();
+    activeRuntime = null;
+  }
+  const url = options.url ?? document.getElementById("__$wasmlink")?.href ?? DEFAULT_URL;
+  const bridgeRef = { current: null };
+  let wasmMemory = null;
+  const kvBindings = options.kv ?? createBrowserKVBindings();
+  const kvImportObject = {
+    __zx_kv: createKVImports(kvBindings, () => {
+      if (wasmMemory)
+        return wasmMemory;
+      if (jsz.memory)
+        return jsz.memory;
+      throw new Error("WASM memory is not ready");
+    })
+  };
+  const importObject = Object.assign({}, ZxBridge.createImportObject(bridgeRef), kvImportObject, options.importObject);
+  const source = await WebAssembly.instantiateStreaming(fetch(url), importObject);
+  const { instance } = source;
+  wasmMemory = instance.exports.memory;
+  jsz.memory = wasmMemory;
+  const bridge = new ZxBridge(instance.exports);
+  bridgeRef.current = bridge;
+  domNodes.clear();
+  const disposeDelegation = initEventDelegation(bridge, options.eventDelegationRoot ?? "body");
+  const main = wrapPromisingExport(instance.exports.mainClient);
+  invokeWasmExport(main);
+  activeRuntime = {
+    options: normalizedOptions,
+    dispose: () => {
+      disposeDelegation();
+      bridge.dispose();
+      domNodes.clear();
+    }
+  };
+  registerDevReinit(normalizedOptions);
+  return { source, bridge };
 }
 export {
-  init
+  writeBytes,
+  textEncoder,
+  textDecoder,
+  storeValueGetRef,
+  readString,
+  jsz,
+  initEventDelegation,
+  init,
+  getMemoryView,
+  ZxBridgeCore,
+  ZxBridge,
+  CallbackType
 };