ziex 0.1.0-dev.787 → 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,37 +268,22 @@ 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);
   }
-  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);
-    });
-  }
   setTimeout(callbackId, delayMs) {
     setTimeout(() => {
       this.#invoke(CallbackType.Timeout, callbackId, null);
@@ -325,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) : "";
@@ -337,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) => {
@@ -345,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) => {
@@ -367,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);
       };
@@ -376,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);
       }
     }
@@ -398,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;
@@ -427,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);
         },

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>;
+    };
+}

package/hono/index.d.ts

@@ -1,92 +0,0 @@
-import { Hono } from "hono";
-import type { KVNamespace } from "../cloudflare/kv";
-type DurableObjectNamespace = {
-    idFromName(name: string): unknown;
-    get(id: unknown): {
-        fetch(req: Request): Promise<Response>;
-    };
-};
-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;
-};
-/**
- * Create a Hono app that runs a Ziex WASM module.
- *
- * The returned app handles all routes (`*`) and forwards each request to
- * the WASM runtime. Deploy it on any platform Hono supports:
- *
- * @example Cloudflare Workers
- * ```ts
- * import { createHonoApp } from "ziex/hono";
- * import module from "./app.wasm";
- *
- * const app = createHonoApp<{ KV: KVNamespace }>({
- *   module,
- *   kv: (env) => ({ default: env.KV }),
- * });
- *
- * export default app;
- * ```
- *
- * @example Node / Vercel (requires JSPI support)
- * ```ts
- * import { createHonoApp } from "ziex/hono";
- * import { serve } from "@hono/node-server";
- * import module from "./app.wasm";
- *
- * const app = createHonoApp({ module });
- * serve(app);
- * ```
- *
- * **Note:** The WASM async model relies on JSPI (`WebAssembly.Suspending` /
- * `WebAssembly.promising`). Verify that your target runtime supports it.
- */
-export declare function createHonoApp<Bindings extends Record<string, unknown> = Record<string, unknown>>(options: {
-    /** Compiled WASM module for the Ziex app. */
-    module: WebAssembly.Module;
-    /**
-     * Optional pre-configured WASI instance. When omitted the built-in WASI
-     * shim (from `ziex/cloudflare`) is used automatically.
-     */
-    wasi?: WASI;
-    /**
-     * Extra WASM import objects, keyed by module namespace.
-     * Receives a `mem` accessor so you can read WASM memory lazily.
-     */
-    imports?: (mem: () => WebAssembly.Memory) => Record<string, Record<string, unknown>>;
-    /**
-     * Factory that maps platform env bindings to Ziex KV namespaces.
-     * Called once per request so bindings are resolved at runtime.
-     *
-     * @example
-     * ```ts
-     * kv: (env) => ({ default: env.MY_KV })
-     * ```
-     */
-    kv?: (env: Bindings) => Record<string, KVNamespace>;
-    /**
-     * Factory that maps platform env bindings to a Durable Object namespace
-     * for WebSocket pub/sub support.
-     *
-     * @example
-     * ```ts
-     * websocket: (env) => env.ZxWS
-     * ```
-     */
-    websocket?: (env: Bindings) => DurableObjectNamespace;
-}): Hono<{
-    Bindings: Bindings;
-}>;
-export {};