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

package/wasm/init.js

@@ -167,7 +167,7 @@ class ZigJS {
     return decoder.decode(data);
   }
 }
-// src/wasm/index.ts
+// src/wasm/core.ts
 var CallbackType = {
   Event: 0,
   FetchSuccess: 1,
@@ -218,25 +218,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;
@@ -276,19 +268,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);
   }
@@ -310,6 +302,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) : "";
@@ -322,7 +391,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) => {
@@ -330,21 +399,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) => {
@@ -352,7 +415,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);
       };
@@ -361,7 +424,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);
       }
     }
@@ -383,25 +446,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;
@@ -412,6 +464,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);
         },
@@ -487,6 +540,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);
         }
       }
     };

package/wasm/wasi.d.ts

@@ -0,0 +1,28 @@
+/**
+ * WASI/edge WASM bridge — zero dependencies on ZigJS (jsz) or browser globals.
+ *
+ * Import this (and only this) from edge/server runtimes. It provides the
+ * minimal __zx import namespace needed by server-side WASM: log, fetch, and
+ * timers. The jsz importObject is intentionally omitted — the server binary
+ * does not use jsz value-passing.
+ */
+export declare class ZxWasiBridge {
+    #private;
+    constructor(exports: WebAssembly.Exports);
+    log(level: number, ptr: number, len: number): void;
+    fetchAsync(urlPtr: number, urlLen: number, methodPtr: number, methodLen: number, headersPtr: number, headersLen: number, bodyPtr: number, bodyLen: number, timeoutMs: number, fetchId: bigint): void;
+    setTimeout(callbackId: bigint, delayMs: number): void;
+    setInterval(callbackId: bigint, intervalMs: number): void;
+    clearInterval(callbackId: bigint): void;
+    /**
+     * Create the WASI import object for WASM instantiation.
+     *
+     * Returns only the `__zx` namespace (log, fetch, timers).
+     * Does NOT include jsz.importObject() — the server binary does not use jsz.
+     */
+    static createImportObject(bridgeRef: {
+        current: ZxWasiBridge | null;
+    }): {
+        __zx: Record<string, unknown>;
+    };
+}