ziex 0.1.0-dev.786 → 0.1.0-dev.804

package/kv.d.ts

@@ -0,0 +1,27 @@
+export interface KVNamespace {
+    get(key: string): Promise<string | null>;
+    put(key: string, value: string, options?: {
+        expiration?: number;
+        expirationTtl?: number;
+    }): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(options?: {
+        prefix?: string;
+    }): Promise<{
+        keys: {
+            name: string;
+        }[];
+    }>;
+}
+/**
+ * In-memory KV namespace. Used as the default shim on platforms that don't
+ * provide a real KV binding (e.g. Vercel). Data lives only for the lifetime
+ * of the isolate instance.
+ */
+export declare function createMemoryKV(): KVNamespace;
+/**
+ * Create a `__zx_kv` import object for use with `run({ kv: ... })`.
+ * Always returns a valid import object. When JSPI is unavailable all KV
+ * operations are stubbed (get → not-found, put/delete → success, list → []).
+ */
+export declare function createKVImports(bindings: Record<string, KVNamespace>, getMemory: () => WebAssembly.Memory): Record<string, unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziex",
-  "version": "0.1.0-dev.786",
+  "version": "0.1.0-dev.804",
   "description": "ZX is a framework for building web applications with Zig.",
   "main": "index.js",
   "type": "module",
@@ -9,7 +9,9 @@
     "./react": "./react/index.js",
     "./wasm": "./wasm/index.js",
     "./wasm/init": "./wasm/init.js",
-    "./cloudflare": "./cloudflare/index.js"
+    "./cloudflare": "./cloudflare/index.js",
+    "./aws-lambda": "./aws-lambda/index.js",
+    "./vercel": "./vercel/index.js"
   },
   "homepage": "https://ziex.dev",
   "repository": {
@@ -30,6 +32,14 @@
   ],
   "author": "Nurul Huda (Apon) <me@nurulhudaapon.com>",
   "license": "MIT",
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
   "module": "index.js",
   "types": "index.d.ts"
 }

package/runtime.d.ts

@@ -0,0 +1,70 @@
+import type { WASI } from "./wasi";
+import type { KVNamespace } from "./kv";
+/** Minimal Durable Object namespace shape needed for WebSocket routing. */
+export type DurableObjectNamespace = {
+    idFromName(name: string): unknown;
+    get(id: unknown): {
+        fetch(req: Request): Promise<Response>;
+    };
+};
+export type WsState = {
+    upgraded: boolean;
+    server: WebSocket | null;
+    pendingWrites: Uint8Array[];
+    messageQueue: Uint8Array[];
+    recvResolve: ((bytes: Uint8Array | null) => void) | null;
+    /** Resolved when ws_recv is called for the first time (WASM has entered the message loop). */
+    _resolveFirstSuspend?: () => void;
+    subscribe?: (topic: string) => void;
+    unsubscribe?: (topic: string) => void;
+    publish?: (topic: string, data: Uint8Array) => number;
+    isSubscribed?: (topic: string) => boolean;
+};
+/** Build the __zx_ws import object for a given connection state. */
+export declare function buildWsImports(Suspending: any, mem: () => WebAssembly.Memory, decoder: TextDecoder, ws: WsState): {
+    ws_upgrade: () => void;
+    ws_write: (ptr: number, len: number) => void;
+    ws_close: (code: number, reason_ptr: number, reason_len: number) => void;
+    ws_recv: any;
+    ws_subscribe: (ptr: number, len: number) => void;
+    ws_unsubscribe: (ptr: number, len: number) => void;
+    ws_publish: (topic_ptr: number, topic_len: number, data_ptr: number, data_len: number) => number;
+    ws_is_subscribed: (ptr: number, len: number) => number;
+};
+/** Create WebSocketPair, wire message/close listeners, flush pending writes. */
+export declare function attachWebSocket(ws: WsState): {
+    client: WebSocket;
+};
+/**
+ * Run a WASM module for a single request using JSPI.
+ *
+ * Pass `kv` as a map of binding names → KV namespaces. The Zig side selects
+ * a binding via `zx.kv.scope("name")`; the top-level `zx.kv.*` functions use
+ * `"default"`.
+ *
+ * @example
+ * ```ts
+ * return run({
+ *   request, env, ctx, module,
+ *   kv: { default: env.KV, users: env.USERS_KV },
+ * });
+ * ```
+ */
+export declare function run({ request, env, ctx, module, kv: kvBindings, imports, wasi, websocket: doNamespace, }: {
+    request: Request;
+    env?: unknown;
+    ctx?: {
+        waitUntil(promise: Promise<unknown>): void;
+    };
+    module: WebAssembly.Module;
+    /** KV namespace bindings — `{ default: env.KV, otherName: env.OTHER_KV }` */
+    kv?: Record<string, KVNamespace>;
+    imports?: (mem: () => WebAssembly.Memory) => Record<string, Record<string, unknown>>;
+    wasi?: WASI;
+    /**
+     * Durable Object namespace to use for WebSocket connections.
+     * When provided, WebSocket upgrade requests are automatically forwarded to
+     * the DO so that pub/sub works across multiple connected clients.
+     */
+    websocket?: DurableObjectNamespace;
+}): Promise<Response>;

package/vercel/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Ziex adapter for Vercel Edge Functions.
+ *
+ * @example
+ * ```ts
+ * import { Ziex } from "ziex/cloudflare";
+ * import { handle } from "ziex/vercel";
+ * import module from "./app.wasm"; // or fetch at runtime
+ *
+ * const app = new Ziex({ module });
+ *
+ * export const config = { runtime: "edge" };
+ * export default handle(app);
+ * ```
+ */
+type FetchApp = {
+    fetch(req: Request, env?: unknown, ctx?: unknown): Promise<Response>;
+};
+/**
+ * Wrap a Ziex app as a Vercel Edge Function handler.
+ *
+ * Returns a standard `(req: Request) => Promise<Response>` function.
+ * Vercel's edge runtime calls it directly — just export it as default.
+ */
+export declare function handle(app: FetchApp): (req: Request) => Promise<Response>;
+export {};

package/vercel/index.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/vercel/index.ts
+function handle(app) {
+  return (req) => app.fetch(req);
+}
+export {
+  handle
+};

package/wasi.d.ts

@@ -0,0 +1,61 @@
+export declare class ProcExit extends Error {
+    readonly code: number;
+    constructor(code: number);
+}
+export type WASI = {
+    wasiImport: Record<string, (...args: any[]) => unknown>;
+    start(instance: {
+        exports: {
+            memory: WebAssembly.Memory;
+            _start: () => unknown;
+        };
+    }): number;
+    initialize?(instance: {
+        exports: {
+            memory: WebAssembly.Memory;
+            _initialize?: () => unknown;
+        };
+    }): void;
+};
+export declare function createWasiImports({ request, stdinData, onStdout, }: {
+    request: Request;
+    stdinData?: Uint8Array;
+    /** Called for each stdout chunk. When provided, chunks are NOT buffered internally. */
+    onStdout?: (chunk: Uint8Array) => void;
+}): {
+    wasiImport: {
+        args_sizes_get(argc_ptr: number, argv_buf_size_ptr: number): number;
+        args_get(argv_ptr: number, argv_buf_ptr: number): number;
+        environ_sizes_get(count_ptr: number, buf_size_ptr: number): number;
+        environ_get(_environ_ptr: number, _environ_buf_ptr: number): number;
+        fd_write(fd: number, iovs_ptr: number, iovs_len: number, nwritten_ptr: number): number;
+        fd_read(fd: number, iovs_ptr: number, iovs_len: number, nread_ptr: number): number;
+        fd_fdstat_get(_fd: number, fdstat_ptr: number): number;
+        fd_prestat_get(_fd: number, _bufptr: number): number;
+        fd_prestat_dir_name(_fd: number, _path: number, _path_len: number): number;
+        fd_close(_fd: number): number;
+        fd_pread(_fd: number, _iovs: number, _iovs_len: number, _offset: bigint, nread_ptr: number): number;
+        fd_pwrite(_fd: number, _iovs: number, _iovs_len: number, _offset: bigint, nwritten_ptr: number): number;
+        fd_filestat_get(_fd: number, filestat_ptr: number): number;
+        fd_seek(_fd: number, _offset: bigint, _whence: number, newoffset_ptr: number): number;
+        proc_exit(code: number): never;
+        sched_yield(): number;
+        clock_time_get(_id: number, _precision: bigint, time_ptr: number): number;
+        random_get(buf_ptr: number, buf_len: number): number;
+        path_open(_fd: number, _dirflags: number, _path: number, _path_len: number, _oflags: number, _rights_base: bigint, _rights_inheriting: bigint, _fdflags: number, opened_fd_ptr: number): number;
+        path_create_directory(_fd: number, _path: number, _path_len: number): number;
+        path_unlink_file(_fd: number, _path: number, _path_len: number): number;
+        path_remove_directory(_fd: number, _path: number, _path_len: number): number;
+        path_rename(_fd: number, _old_path: number, _old_path_len: number, _new_fd: number, _new_path: number, _new_path_len: number): number;
+        path_filestat_get(_fd: number, _flags: number, _path: number, _path_len: number, filestat_ptr: number): number;
+        path_readlink(_fd: number, _path: number, _path_len: number, _buf: number, _buf_len: number, nread_ptr: number): number;
+        fd_readdir(_fd: number, _buf: number, _buf_len: number, _cookie: bigint, bufused_ptr: number): number;
+        poll_oneoff(_in: number, _out: number, _nsubscriptions: number, nevents_ptr: number): number;
+    };
+    setMemory: (m: WebAssembly.Memory) => void;
+    collectOutput: () => {
+        stdout: Uint8Array;
+        stderrText: string;
+    };
+};
+export declare function mergeUint8Arrays(arrays: Uint8Array[]): Uint8Array;

package/wasm/core.d.ts

@@ -0,0 +1,78 @@
+import { ZigJS } from "../../../../vendor/jsz/js/src";
+/**
+ * Core WASM bridge — environment-agnostic (browser + edge).
+ * Contains 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;
+/** 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 */
+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;
+/**
+ * Core ZX Bridge — works in both browser and edge runtimes.
+ * Contains fetch, timers, and logging. No DOM or browser-WebSocket references.
+ *
+ * Extend this class in browser environments to add DOM and WebSocket support.
+ */
+export declare class ZxBridgeCore {
+    #private;
+    protected readonly _alloc: (size: number) => number;
+    constructor(exports: WebAssembly.Exports);
+    /**
+     * Async fetch with full options support.
+     * Calls __zx_fetch_complete when done.
+     */
+    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 */
+    protected _notifyFetchComplete(fetchId: bigint, statusCode: number, body: string, isError: boolean): void;
+    /** Set a timeout and callback when it fires */
+    setTimeout(callbackId: bigint, delayMs: number): void;
+    /** Set an interval and callback each time it fires */
+    setInterval(callbackId: bigint, intervalMs: number): void;
+    /** Clear an interval */
+    clearInterval(callbackId: bigint): 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;
+    };
+    /** 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;
+    /**
+     * 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: {
+        current: ZxBridgeCore | null;
+    }): WebAssembly.Imports;
+}

package/wasm/index.d.ts

@@ -1,38 +1,16 @@
-import { ZigJS } from "../../../../vendor/jsz/js/src";
+export { CallbackType, jsz, storeValueGetRef, textDecoder, textEncoder, getMemoryView, readString, writeBytes, ZxBridgeCore, } from "./core";
+export type { CallbackTypeValue } from "./core";
+import { ZxBridgeCore } from "./core";
 /**
- * ZX Client Bridge - Unified JS↔WASM communication layer
- * Handles events, fetch, WebSocket, timers, and other async callbacks using jsz
+ * Browser ZX Bridge — extends ZxBridgeCore with DOM, WebSocket, and form-action support.
+ * Import this from environments that have access to browser globals.
+ * For edge runtimes, import ZxBridgeCore from ./core instead.
  */
-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 declare const jsz: ZigJS;
-/** Store a value using jsz.storeValue and get the 64-bit reference. */
-export declare function storeValueGetRef(val: any): bigint;
-/** ZX Bridge - provides JS APIs that callback into WASM */
-export declare class ZxBridge {
+export declare class ZxBridge extends ZxBridgeCore {
     #private;
     constructor(exports: WebAssembly.Exports);
-    /**
-     * Async fetch with full options support.
-     * Calls __zx_fetch_complete when done.
-     */
-    fetchAsync(urlPtr: number, urlLen: number, methodPtr: number, methodLen: number, headersPtr: number, headersLen: number, bodyPtr: number, bodyLen: number, timeoutMs: number, fetchId: bigint): void;
-    /** Set a timeout and callback when it fires */
-    setTimeout(callbackId: bigint, delayMs: number): void;
-    /** Set an interval and callback each time it fires */
-    setInterval(callbackId: bigint, intervalMs: number): void;
-    /** Clear an interval */
-    clearInterval(callbackId: bigint): void;
+    /** Submit a form action with bound-state round-trip. */
+    submitFormActionAsync(form: HTMLFormElement, statesJson: string, fetchId: bigint): void;
     /**
      * Create and connect a WebSocket.
      * Calls __zx_ws_onopen, __zx_ws_onmessage, __zx_ws_onerror, __zx_ws_onclose.
@@ -44,7 +22,7 @@ export declare class ZxBridge {
     wsClose(wsId: bigint, code: number, reasonPtr: number, reasonLen: number): void;
     /** Handle a DOM event (called by event delegation) */
     eventbridge(velementId: bigint, eventTypeId: number, event: Event): void;
-    /** Create the import object for WASM instantiation */
+    /** Create the full browser import object for WASM instantiation (includes DOM + WebSocket). */
     static createImportObject(bridgeRef: {
         current: ZxBridge | null;
     }): WebAssembly.Imports;

package/wasm/index.js

@@ -178,7 +178,7 @@ class ZigJS {
     return decoder.decode(data);
   }
 }
-// src/wasm/index.ts
+// src/wasm/core.ts
 var CallbackType = {
   Event: 0,
   FetchSuccess: 1,
@@ -229,25 +229,17 @@ function writeBytes(ptr, data) {
   getMemoryView().set(data, ptr);
 }
 
-class ZxBridge {
+class ZxBridgeCore {
   #intervals = new Map;
-  #websockets = new Map;
-  #alloc;
+  _alloc;
   #handler;
   #fetchCompleteHandler;
-  #wsOnOpenHandler;
-  #wsOnMessageHandler;
-  #wsOnErrorHandler;
-  #wsOnCloseHandler;
   constructor(exports) {
-    this.#alloc = exports.__zx_alloc;
+    this._alloc = exports.__zx_alloc;
     this.#handler = exports.__zx_cb;
     this.#fetchCompleteHandler = exports.__zx_fetch_complete;
-    this.#wsOnOpenHandler = exports.__zx_ws_onopen;
-    this.#wsOnMessageHandler = exports.__zx_ws_onmessage;
-    this.#wsOnErrorHandler = exports.__zx_ws_onerror;
-    this.#wsOnCloseHandler = exports.__zx_ws_onclose;
-    this.#eventbridge = exports.__zx_eventbridge;
+    if (exports.memory)
+      jsz.memory = exports.memory;
   }
   #invoke(type, id, data) {
     const handler = this.#handler;
@@ -287,19 +279,19 @@ class ZxBridge {
       if (timeout)
         clearTimeout(timeout);
       const text = await response.text();
-      this.#notifyFetchComplete(fetchId, response.status, text, false);
+      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);
+      this._notifyFetchComplete(fetchId, 0, errorMsg, true);
     });
   }
-  #notifyFetchComplete(fetchId, statusCode, body, isError) {
+  _notifyFetchComplete(fetchId, statusCode, body, isError) {
     const handler = this.#fetchCompleteHandler;
     const encoded = textEncoder.encode(body);
-    const ptr = this.#alloc(encoded.length);
+    const ptr = this._alloc(encoded.length);
     writeBytes(ptr, encoded);
     handler(fetchId, statusCode, ptr, encoded.length, isError ? 1 : 0);
   }
@@ -321,6 +313,83 @@ class ZxBridge {
       this.#intervals.delete(callbackId);
     }
   }
+  _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/wasm/index.ts
+class ZxBridge extends ZxBridgeCore {
+  #websockets = new Map;
+  #wsOnOpenHandler;
+  #wsOnMessageHandler;
+  #wsOnErrorHandler;
+  #wsOnCloseHandler;
+  #eventbridge;
+  constructor(exports) {
+    super(exports);
+    this.#wsOnOpenHandler = exports.__zx_ws_onopen;
+    this.#wsOnMessageHandler = exports.__zx_ws_onmessage;
+    this.#wsOnErrorHandler = exports.__zx_ws_onerror;
+    this.#wsOnCloseHandler = exports.__zx_ws_onclose;
+    this.#eventbridge = exports.__zx_eventbridge;
+  }
+  submitFormActionAsync(form, statesJson, fetchId) {
+    const formData = new FormData(form);
+    formData.append("__zx_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);
+    });
+  }
   wsConnect(wsId, urlPtr, urlLen, protocolsPtr, protocolsLen) {
     const url = readString(urlPtr, urlLen);
     const protocolsStr = protocolsLen > 0 ? readString(protocolsPtr, protocolsLen) : "";
@@ -333,7 +402,7 @@ class ZxBridge {
         if (!handler)
           return;
         const protocol = ws.protocol || "";
-        const { ptr, len } = this.#writeStringToWasm(protocol);
+        const { ptr, len } = this._writeStringToWasm(protocol);
         handler(wsId, ptr, len);
       };
       ws.onmessage = (event) => {
@@ -341,21 +410,15 @@ class ZxBridge {
         if (!handler)
           return;
         const isBinary = event.data instanceof ArrayBuffer;
-        let data;
-        if (isBinary) {
-          data = new Uint8Array(event.data);
-        } else {
-          data = textEncoder.encode(event.data);
-        }
-        const { ptr, len } = this.#writeBytesToWasm(data);
+        const data = isBinary ? new Uint8Array(event.data) : textEncoder.encode(event.data);
+        const { ptr, len } = this._writeBytesToWasm(data);
         handler(wsId, ptr, len, isBinary ? 1 : 0);
       };
-      ws.onerror = (event) => {
+      ws.onerror = (_event) => {
         const handler = this.#wsOnErrorHandler;
         if (!handler)
           return;
-        const msg = "WebSocket error";
-        const { ptr, len } = this.#writeStringToWasm(msg);
+        const { ptr, len } = this._writeStringToWasm("WebSocket error");
         handler(wsId, ptr, len);
       };
       ws.onclose = (event) => {
@@ -363,7 +426,7 @@ class ZxBridge {
         if (!handler)
           return;
         const reason = event.reason || "";
-        const { ptr, len } = this.#writeStringToWasm(reason);
+        const { ptr, len } = this._writeStringToWasm(reason);
         handler(wsId, event.code, ptr, len, event.wasClean ? 1 : 0);
         this.#websockets.delete(wsId);
       };
@@ -372,7 +435,7 @@ class ZxBridge {
       const handler = this.#wsOnErrorHandler;
       if (handler) {
         const msg = error instanceof Error ? error.message : "WebSocket connection failed";
-        const { ptr, len } = this.#writeStringToWasm(msg);
+        const { ptr, len } = this._writeStringToWasm(msg);
         handler(wsId, ptr, len);
       }
     }
@@ -394,25 +457,14 @@ class ZxBridge {
       return;
     const reason = reasonLen > 0 ? readString(reasonPtr, reasonLen) : undefined;
     try {
-      if (reason) {
+      if (reason)
         ws.close(code, reason);
-      } else {
+      else
         ws.close(code);
-      }
     } catch {
       ws.close();
     }
   }
-  #writeStringToWasm(str) {
-    const encoded = textEncoder.encode(str);
-    return this.#writeBytesToWasm(encoded);
-  }
-  #writeBytesToWasm(data) {
-    const ptr = this.#alloc(data.length);
-    writeBytes(ptr, data);
-    return { ptr, len: data.length };
-  }
-  #eventbridge;
   eventbridge(velementId, eventTypeId, event) {
     if (!this.#eventbridge)
       return;
@@ -423,6 +475,7 @@ class ZxBridge {
     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);
         },
@@ -498,6 +551,41 @@ class ZxBridge {
             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);
         }
       }
     };
@@ -792,10 +880,16 @@ async function init(options = {}) {
   return { source, bridge };
 }
 export {
+  writeBytes,
+  textEncoder,
+  textDecoder,
   storeValueGetRef,
+  readString,
   jsz,
   initEventDelegation,
   init,
+  getMemoryView,
+  ZxBridgeCore,
   ZxBridge,
   CallbackType
 };