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

package/runtime/kv.js

@@ -0,0 +1,543 @@
+// src/runtime/kv/memory.ts
+function createMemoryKV() {
+  const store = /* @__PURE__ */ new Map();
+  function read(key) {
+    const entry = store.get(key);
+    if (!entry) return null;
+    const expiresAt = entry[1];
+    if (expiresAt !== void 0 && Date.now() >= expiresAt) {
+      store.delete(key);
+      return null;
+    }
+    return entry[0];
+  }
+  function write(key, value, options) {
+    let expiresAt;
+    if (options?.expiration !== void 0) {
+      expiresAt = options.expiration * 1e3;
+    } else if (options?.expirationTtl !== void 0) {
+      expiresAt = Date.now() + options.expirationTtl * 1e3;
+    }
+    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 };
+    }
+  };
+}
+
+// src/runtime/kv/localstorage.ts
+function getLocalStorage() {
+  if (typeof localStorage === "undefined") {
+    throw new Error("localStorage is not available in this environment");
+  }
+  return localStorage;
+}
+function createLocalStorageKV(options = {}) {
+  const storage = getLocalStorage();
+  const namespace = options.namespace ?? "default";
+  const storagePrefix = options.storagePrefix ?? "ziex-kv";
+  const scopedKey = (key) => `${storagePrefix}:${namespace}:${key}`;
+  const namespacePrefix = scopedKey("");
+  return {
+    getSync(key) {
+      return storage.getItem(scopedKey(key));
+    },
+    async get(key) {
+      return this.getSync(key);
+    },
+    putSync(key, value) {
+      storage.setItem(scopedKey(key), value);
+    },
+    async put(key, value) {
+      this.putSync(key, value);
+    },
+    deleteSync(key) {
+      storage.removeItem(scopedKey(key));
+    },
+    async delete(key) {
+      this.deleteSync(key);
+    },
+    listSync(options2) {
+      const prefix = namespacePrefix + (options2?.prefix ?? "");
+      const keys = [];
+      for (let i = 0; i < storage.length; i += 1) {
+        const key = storage.key(i);
+        if (!key || !key.startsWith(prefix)) continue;
+        keys.push({ name: key.slice(namespacePrefix.length) });
+      }
+      return { keys };
+    },
+    async list(options2) {
+      return this.listSync(options2);
+    }
+  };
+}
+
+// src/runtime/kv/indexdb.ts
+function getIndexedDb() {
+  if (typeof indexedDB === "undefined") {
+    throw new Error("IndexedDB is not available in this environment");
+  }
+  return indexedDB;
+}
+function requestToPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+function transactionToPromise(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
+    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed"));
+  });
+}
+function createIndexedDbKV(options = {}) {
+  const databaseName = options.databaseName ?? "ziex-kv";
+  const storeName = options.storeName ?? "kv";
+  const namespace = options.namespace ?? "default";
+  const dbPromise = new Promise((resolve, reject) => {
+    const request = getIndexedDb().open(databaseName, 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName);
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB"));
+  });
+  const scopedKey = (key) => `${namespace}:${key}`;
+  return {
+    async get(key) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readonly");
+      const store = tx.objectStore(storeName);
+      const value = await requestToPromise(store.get(scopedKey(key)));
+      await transactionToPromise(tx);
+      return typeof value === "string" ? value : null;
+    },
+    async put(key, value) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readwrite");
+      tx.objectStore(storeName).put(value, scopedKey(key));
+      await transactionToPromise(tx);
+    },
+    async delete(key) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readwrite");
+      tx.objectStore(storeName).delete(scopedKey(key));
+      await transactionToPromise(tx);
+    },
+    async list(options2) {
+      const db = await dbPromise;
+      const tx = db.transaction(storeName, "readonly");
+      const store = tx.objectStore(storeName);
+      const keys = await requestToPromise(store.getAllKeys());
+      await transactionToPromise(tx);
+      const prefix = scopedKey(options2?.prefix ?? "");
+      return {
+        keys: keys.filter((key) => typeof key === "string" && key.startsWith(prefix)).map((key) => ({ name: key.slice(namespace.length + 1) }))
+      };
+    }
+  };
+}
+
+// ../../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
+};
+var PREDEFINED_ID_MAX = 6;
+var encoder = new TextEncoder();
+var decoder = new TextDecoder("utf-8");
+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": {
+        valueGet: this.valueGet.bind(this),
+        valueSet: this.valueSet.bind(this),
+        valueDeinit: this.valueDeinit.bind(this),
+        valueObjectCreate: this.valueObjectCreate.bind(this),
+        valueStringCreate: this.valueStringCreate.bind(this),
+        valueStringLen: this.valueStringLen.bind(this),
+        valueStringCopy: this.valueStringCopy.bind(this),
+        valueNew: this.valueNew.bind(this),
+        funcApply: this.funcApply.bind(this)
+      }
+    };
+  }
+  /**
+   * Get a value from the JS environment.
+   * */
+  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);
+  }
+  /**
+   * 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());
+  }
+  /**
+   * 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;
+    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 > 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.
+   * */
+  valueNew(out, id, argsAddr, argsLen) {
+    const fn = this.loadValue(id);
+    const args = [];
+    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);
+  }
+  /**
+   * Call a function given by id.
+   * */
+  funcApply(out, id, thisRefAddr, argsAddr, argsLen) {
+    const fn = this.loadValue(id);
+    const thisVal = this.loadRef(thisRefAddr >>> 0);
+    const args = [];
+    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);
+    }
+  }
+  /**
+   * 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;
+    const addr = refAddr >>> 0;
+    const view = new DataView(this.memory.buffer);
+    const floatVal = view.getFloat64(addr, true);
+    if (!isNaN(floatVal)) return floatVal;
+    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 >>> 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);
+        view.setUint32(out + 4, NAN_PREFIX, true);
+      } else {
+        view.setFloat64(out, val, true);
+      }
+      return;
+    }
+    if (val === null) {
+      view.setUint32(out, predefined.null, true);
+      view.setUint32(out + 4, NAN_PREFIX, true);
+      return;
+    }
+    if (val === void 0) {
+      view.setUint32(out, predefined.undefined, true);
+      view.setUint32(out + 4, NAN_PREFIX, true);
+      return;
+    }
+    if (typeof val === "boolean") {
+      view.setUint32(out, val ? predefined.true : predefined.false, true);
+      view.setUint32(out + 4, NAN_PREFIX, true);
+      return;
+    }
+    if (typeof val === "bigint") {
+      view.setFloat64(out, Number(val), true);
+      return;
+    }
+    let id = this.idPool.pop();
+    if (id === void 0) {
+      id = this.values.length;
+    }
+    this.values[id] = val;
+    let typeId = 0;
+    switch (typeof val) {
+      case "object":
+        typeId = 1;
+        break;
+      case "string":
+        typeId = 2;
+        break;
+      case "symbol":
+        typeId = 3;
+        break;
+      case "function":
+        typeId = 4;
+        break;
+    }
+    view.setUint32(out, Number(id), true);
+    view.setUint32(out + 4, NAN_PREFIX | typeId, true);
+  }
+  loadString(ptr, len) {
+    if (this.memory == null) return "";
+    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/wasm/core.ts
+var jsz = new ZigJS();
+var tempRefBuffer = new ArrayBuffer(8);
+var tempRefView = new DataView(tempRefBuffer);
+var textDecoder = new TextDecoder();
+var textEncoder = new TextEncoder();
+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)));
+}
+
+// src/runtime/kv/extern.ts
+function putOptions(ttlSeconds) {
+  if (ttlSeconds < 60) return void 0;
+  return { expirationTtl: ttlSeconds };
+}
+function isSyncKVNamespace(binding) {
+  const candidate = binding;
+  return typeof candidate.getSync === "function" && typeof candidate.putSync === "function" && typeof candidate.deleteSync === "function" && typeof candidate.listSync === "function";
+}
+function createKVImports(bindings, getMemory, allocRef) {
+  const encoder2 = new TextEncoder();
+  const decoder2 = new TextDecoder();
+  function readStr(ptr, len) {
+    return decoder2.decode(new Uint8Array(getMemory().buffer, ptr, len));
+  }
+  function binding(ns) {
+    return bindings[ns] ?? bindings["default"] ?? null;
+  }
+  const Suspending = WebAssembly.Suspending;
+  if (typeof Suspending !== "function") {
+    let syncBinding2 = function(ns) {
+      const candidate = binding(ns);
+      return candidate && isSyncKVNamespace(candidate) ? candidate : null;
+    };
+    var syncBinding = syncBinding2;
+    return {
+      kv_get: (ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
+        const b = syncBinding2(readStr(ns_ptr, ns_len));
+        if (!b) return -1;
+        const value = b.getSync(readStr(key_ptr, key_len));
+        if (value === null) return -1;
+        return writeBytesOut(getMemory, allocRef, out_ptr, encoder2.encode(value));
+      },
+      kv_put: (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
+        const b = syncBinding2(readStr(ns_ptr, ns_len));
+        if (!b) return 0;
+        b.putSync(readStr(key_ptr, key_len), readStr(val_ptr, val_len), putOptions(ttl_seconds));
+        return 0;
+      },
+      kv_delete: (ns_ptr, ns_len, key_ptr, key_len) => {
+        const b = syncBinding2(readStr(ns_ptr, ns_len));
+        if (!b) return 0;
+        b.deleteSync(readStr(key_ptr, key_len));
+        return 0;
+      },
+      kv_list: (ns_ptr, ns_len, pfx_ptr, pfx_len, out_ptr) => {
+        const b = syncBinding2(readStr(ns_ptr, ns_len));
+        if (!b) return writeJsonOut(getMemory, allocRef, out_ptr, []);
+        const prefix = readStr(pfx_ptr, pfx_len);
+        const result = b.listSync(prefix.length > 0 ? { prefix } : void 0);
+        return writeJsonOut(getMemory, allocRef, out_ptr, result.keys.map((k) => k.name));
+      }
+    };
+  }
+  return {
+    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, out_ptr) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b) return -1;
+      const value = await b.get(readStr(key_ptr, key_len));
+      if (value === null) return -1;
+      return writeBytesOut(getMemory, allocRef, out_ptr, encoder2.encode(value));
+    }),
+    kv_put: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len, ttl_seconds) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b) return -1;
+      await b.put(readStr(key_ptr, key_len), readStr(val_ptr, val_len), putOptions(ttl_seconds));
+      return 0;
+    }),
+    kv_delete: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b) return -1;
+      await b.delete(readStr(key_ptr, key_len));
+      return 0;
+    }),
+    kv_list: new Suspending(async (ns_ptr, ns_len, prefix_ptr, prefix_len, out_ptr) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b) return writeJsonOut(getMemory, allocRef, out_ptr, []);
+      const prefix = readStr(prefix_ptr, prefix_len);
+      const result = await b.list(prefix.length > 0 ? { prefix } : void 0);
+      const names = result.keys.map((k) => k.name);
+      if (names.length === 0) {
+        new DataView(getMemory().buffer).setUint32(out_ptr, 0, true);
+        return 0;
+      }
+      return writeJsonOut(getMemory, allocRef, out_ptr, names);
+    })
+  };
+}
+
+// src/runtime/kv.ts
+function hasJSPI() {
+  return typeof WebAssembly.Suspending === "function" && typeof WebAssembly.promising === "function";
+}
+function createBrowserKVBindings(options = {}) {
+  const namespace = options.namespace ?? "default";
+  const isIndexedDb = hasJSPI() && !options.forceLocalStorage;
+  return {
+    [namespace]: isIndexedDb ? createIndexedDbKV(options) : createLocalStorageKV(options)
+  };
+}
+export {
+  createBrowserKVBindings,
+  createIndexedDbKV,
+  createKVImports,
+  createLocalStorageKV,
+  createMemoryKV,
+  hasJSPI
+};

package/wasm/constants.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Numeric wire constants for the WASM↔JS ABI.
+ *
+ * Kept in a path-import-free module so esbuild's const-inlining heuristic can
+ * fold these into call sites across the bundle (#1317 / #1981):
+ * only `null` / `undefined` / `true` / `false` / integers / short reals, at the
+ * top of a scope with no `import`/`export … from "…"`.
+ *
+ * Must stay in sync with Zig (`dom_cmd.zig`, `host.zig` / `__zx_cb` types).
+ */
+export declare const DOM_CMD_HEADER_SIZE = 8;
+export declare const DOM_CMD_RECORD_SIZE = 24;
+export declare const DomOp_CreateElement = 1;
+export declare const DomOp_CreateText = 2;
+export declare const DomOp_HydrateInsert = 3;
+export declare const DomOp_SetAttr = 4;
+export declare const DomOp_SetProp = 5;
+export declare const DomOp_RemoveAttr = 6;
+export declare const DomOp_SetNodeValue = 7;
+export declare const DomOp_SetInnerHtml = 8;
+export declare const DomOp_AppendChild = 9;
+export declare const DomOp_InsertBefore = 10;
+export declare const DomOp_RemoveChild = 11;
+export declare const DomOp_ReplaceChild = 12;
+export declare const CallbackType_Event = 0;
+export declare const CallbackType_FetchSuccess = 1;
+export declare const CallbackType_FetchError = 2;
+export declare const CallbackType_Timeout = 3;
+export declare const CallbackType_Interval = 4;
+export declare const CallbackType_WebSocketOpen = 5;
+export declare const CallbackType_WebSocketMessage = 6;
+export declare const CallbackType_WebSocketError = 7;
+export declare const CallbackType_WebSocketClose = 8;

package/wasm/core.d.ts

@@ -1,34 +1,25 @@
 import { ZigJS } from "../../../../vendor/jsz/js/src";
+import { CallbackType_Event, CallbackType_FetchSuccess, CallbackType_FetchError, CallbackType_Timeout, CallbackType_Interval, CallbackType_WebSocketOpen, CallbackType_WebSocketMessage, CallbackType_WebSocketError, CallbackType_WebSocketClose } from "./constants";
+export { CallbackType_Event, CallbackType_FetchSuccess, CallbackType_FetchError, CallbackType_Timeout, CallbackType_Interval, CallbackType_WebSocketOpen, CallbackType_WebSocketMessage, CallbackType_WebSocketError, CallbackType_WebSocketClose, } from "./constants";
+export type CallbackTypeValue = typeof CallbackType_Event | typeof CallbackType_FetchSuccess | typeof CallbackType_FetchError | typeof CallbackType_Timeout | typeof CallbackType_Interval | typeof CallbackType_WebSocketOpen | typeof CallbackType_WebSocketMessage | typeof CallbackType_WebSocketError | typeof CallbackType_WebSocketClose;
+/** Unified host→guest callback: (type, id, a, b, c). Extra args are msg-specific. */
+export type CallbackHandler = (callbackType: number, id: bigint, a: bigint, b: bigint, c: bigint) => void;
 /**
  * Core WASM bridge - environment-agnostic (browser + edge).
- * Contains no references to browser globals (document, window, WebSocket, HTMLFormElement).
+ * No references to browser globals (document, window, WebSocket, HTMLFormElement).
  */
-export declare const CallbackType: {
-    readonly Event: 0;
-    readonly FetchSuccess: 1;
-    readonly FetchError: 2;
-    readonly Timeout: 3;
-    readonly Interval: 4;
-    readonly WebSocketOpen: 5;
-    readonly WebSocketMessage: 6;
-    readonly WebSocketError: 7;
-    readonly WebSocketClose: 8;
-};
-export type CallbackTypeValue = typeof CallbackType[keyof typeof CallbackType];
-export type CallbackHandler = (callbackType: number, id: bigint, dataRef: bigint) => void;
-export type FetchCompleteHandler = (fetchId: bigint, statusCode: number, bodyPtr: number, bodyLen: number, isError: number) => void;
-export type WsOnOpenHandler = (wsId: bigint, protocolPtr: number, protocolLen: number) => void;
-export type WsOnMessageHandler = (wsId: bigint, dataPtr: number, dataLen: number, isBinary: number) => void;
-export type WsOnErrorHandler = (wsId: bigint, msgPtr: number, msgLen: number) => void;
-export type WsOnCloseHandler = (wsId: bigint, code: number, reasonPtr: number, reasonLen: number, wasClean: number) => void;
 export declare const jsz: ZigJS;
 /** Store a value using jsz.storeValue and get the 64-bit reference. */
 export declare function storeValueGetRef(val: any): bigint;
+/** Resolve a NaN-boxed 64-bit reference back to the JS value. */
+export declare function loadValueFromRef(ref: bigint): any;
+/** Release a NaN-boxed jsz ref (no-op for numbers / predefined ids). */
+export declare function releaseValueRef(ref: bigint): void;
 /** Shared encoder/decoder - avoids allocating new instances on every call. */
 export declare const textDecoder: TextDecoder;
 export declare const textEncoder: TextEncoder;
 export declare function getMemoryView(): Uint8Array;
-/** Read a string from WASM memory */
+/** Read a string from WASM memory. Treats ptr/len as u32 (WASM i32 is signed in JS). */
 export declare function readString(ptr: number, len: number): string;
 /** Write bytes to WASM memory at a specific location */
 export declare function writeBytes(ptr: number, data: Uint8Array): void;
@@ -44,9 +35,11 @@ export declare class ZxBridgeCore {
     #private;
     protected readonly _alloc: (size: number) => number;
     constructor(exports: WebAssembly.Exports);
+    /** Invoke the unified callback handler */
+    protected _invoke(type: CallbackTypeValue, id: bigint, a?: bigint, b?: bigint, c?: bigint): void;
     /**
      * Async fetch with full options support.
-     * Calls __zx_fetch_complete when done.
+     * Completes via `__zx_cb(fetch_success|fetch_error, ...)`.
      */
     fetchAsync(urlPtr: number, urlLen: number, methodPtr: number, methodLen: number, headersPtr: number, headersLen: number, bodyPtr: number, bodyLen: number, timeoutMs: number, fetchId: bigint): void;
     /** Notify WASM that a fetch completed. `body` is raw bytes on success, text on error. */
@@ -58,15 +51,9 @@ export declare class ZxBridgeCore {
     /** Clear an interval */
     clearInterval(callbackId: bigint): void;
     dispose(): void;
-    /** Write a string to WASM memory, returning pointer and length */
-    protected _writeStringToWasm(str: string): {
-        ptr: number;
-        len: number;
-    };
-    protected _writeBytesToWasm(data: Uint8Array): {
-        ptr: number;
-        len: number;
-    };
+    /** Write a string to WASM memory, returning `[ptr, len]`. */
+    protected _writeStringToWasm(str: string): [number, number];
+    writeBytesToWasm(data: Uint8Array): [number, number];
     /** Log a message from WASM at the given level (0=error, 1=warn, 2=info, 3=debug) */
     static log(level: number, ptr: number, len: number): void;
     /**
@@ -75,7 +62,10 @@ export declare class ZxBridgeCore {
      * Use ZxBridge.createImportObject (from wasm/index.ts) in browser contexts
      * to additionally include DOM and WebSocket bindings.
      */
-    static createImportObject(bridgeRef: {
-        current: ZxBridgeCore | null;
-    }): WebAssembly.Imports;
+    static createImportObject(bridgeRef: [ZxBridgeCore | null]): WebAssembly.Imports;
 }
+/** Mutable slot for `__zx_alloc` - array so the slot name itself can minify. */
+export type WasmAllocRef = [((size: number) => number) | null];
+export declare function writeBytesOut(getMemory: () => WebAssembly.Memory, allocRef: WasmAllocRef, outPtrAddr: number, data: Uint8Array): number;
+export declare function writeJsonOut(getMemory: () => WebAssembly.Memory, allocRef: WasmAllocRef, outPtrAddr: number, value: unknown): number;
+export declare function bindWasmAlloc(allocRef: WasmAllocRef, exports: WebAssembly.Exports): void;

package/wasm/dom_cmd.d.ts

@@ -0,0 +1,15 @@
+/**
+ * DomCmd flush decoder — must match `src/runtime/client/dom_cmd.zig`.
+ *
+ * Buffer layout (little-endian):
+ *   Header (8): u32 record_count, u32 flags (0 = absolute WASM ptr+len strings)
+ *   Records (24 each): u8 op, u8 flags, u16 pad, u32 p0..p4
+ *
+ * String fields are absolute linear-memory pointers (same as the old per-op ABI).
+ */
+export type DomFlushContext = {
+    domNodes: Map<number, Node>;
+    cleanupDomNodes: (node: Node) => void;
+};
+/** Apply a DomCmd buffer written at `ptr` with byte length `len`. */
+export declare function flushDomCmds(ptr: number, len: number, ctx: DomFlushContext): void;

package/wasm/generated/event_bits.d.ts

@@ -0,0 +1,2 @@
+/** High-frequency event type bitmask -> `(bits & (1 << id)) !== 0`. */
+export declare const HIGH_FREQ_EVENT_BITS = 3031040;

package/wasm/generated/events.d.ts

@@ -0,0 +1 @@
+export declare const DELEGATED_EVENTS: readonly ['click', 'dblclick', 'input', 'change', 'submit', 'focusin', 'focusout', 'keydown', 'keyup', 'keypress', 'mouseenter', 'mouseleave', 'mousedown', 'mouseup', 'mousemove', 'touchstart', 'touchend', 'touchmove', 'scroll', 'wheel', 'pointerdown', 'pointermove', 'pointerup', 'pointercancel', 'pointerenter', 'pointerleave', 'lostpointercapture'];

package/wasm/generated/tag_indices.d.ts

@@ -0,0 +1,2 @@
+export declare const SVG_TAG_START_INDEX = 140;
+export declare const CUSTOM_TAG_INDEX = 199;