@ziex/cli 0.1.0-dev.865

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/dom.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentMetadata } from "./types";
+export type PreparedComponent = {};
+export declare function prepareComponent(component: ComponentMetadata): Promise<PreparedComponent>;
+export declare function filterComponents(components: ComponentMetadata[]): ComponentMetadata[];

package/wasm/index.d.ts

@@ -0,0 +1,46 @@
+export { CallbackType, jsz, storeValueGetRef, textDecoder, textEncoder, getMemoryView, readString, writeBytes, ZxBridgeCore, } from "./core";
+export type { CallbackTypeValue } from "./core";
+import { ZxBridgeCore } from "./core";
+/**
+ * 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 class ZxBridge extends ZxBridgeCore {
+    #private;
+    constructor(exports: WebAssembly.Exports);
+    /** 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.
+     */
+    wsConnect(wsId: bigint, urlPtr: number, urlLen: number, protocolsPtr: number, protocolsLen: number): void;
+    /** Send data over WebSocket */
+    wsSend(wsId: bigint, dataPtr: number, dataLen: number, isBinary: number): void;
+    /** Close WebSocket connection */
+    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 full browser import object for WASM instantiation (includes DOM + WebSocket). */
+    static createImportObject(bridgeRef: {
+        current: ZxBridge | null;
+    }): WebAssembly.Imports;
+}
+/** Initialize event delegation */
+export declare function initEventDelegation(bridge: ZxBridge, rootSelector?: string): void;
+export type InitOptions = {
+    url?: string;
+    eventDelegationRoot?: string;
+    importObject?: WebAssembly.Imports;
+};
+/** Initialize WASM with the ZX Bridge */
+export declare function init(options?: InitOptions): Promise<{
+    source: WebAssembly.WebAssemblyInstantiatedSource;
+    bridge: ZxBridge;
+}>;
+declare global {
+    interface HTMLElement {
+        __zx_ref?: number;
+    }
+}