ziex 0.0.1-dev.6 → 0.1.0-dev.1000

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,81 @@
+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;
+export declare function wrapPromisingExport<F extends (...args: any[]) => any>(fn: F | undefined): F | undefined;
+export declare function invokeWasmExport<F extends (...args: any[]) => any>(fn: F | undefined, ...args: Parameters<F>): 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;
+    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;
+    };
+    /** 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,22 +1,71 @@
-declare class ZXInstance {
+export { CallbackType, jsz, storeValueGetRef, textDecoder, textEncoder, getMemoryView, readString, writeBytes, ZxBridgeCore, } from "./core";
+export type { CallbackTypeValue } from "./core";
+import { ZxBridgeCore } from "./core";
+import { type KVNamespace } from "../kv";
+/**
+ * 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;
-    exports: WebAssembly.Exports;
-    events: Event[];
-    actions: Record<string, (eventId: number) => void>;
-    constructor({ exports, events }: ZXInstanceOptions);
-    addEvent(event: Event): number;
+    constructor(exports: WebAssembly.Exports);
+    eventMaySuspend(velementId: bigint, eventTypeId: number): boolean;
+    setEventHandlerMode(velementId: bigint, eventTypeId: number, maySuspend: boolean): void;
+    clearEventHandlerModes(velementId: 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.
+     */
+    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;
+    dispose(): 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;
 }
-export declare function init(options?: InitOptions): Promise<void>;
+/** Initialize event delegation */
+export declare function initEventDelegation(bridge: ZxBridge, rootSelector?: string): () => void;
 export type InitOptions = {
     url?: string;
+    eventDelegationRoot?: string;
+    importObject?: WebAssembly.Imports;
+    kv?: Record<string, KVNamespace>;
 };
-type ZXInstanceOptions = {
-    exports: ZXInstance['exports'];
-    events?: ZXInstance['events'];
+type ZiexDevtoolsHook = {
+    location: {
+        href: string;
+        origin: string;
+        host: string;
+        pathname: string;
+    };
+    reinit: () => Promise<{
+        source: WebAssembly.WebAssemblyInstantiatedSource;
+        bridge: ZxBridge;
+    }>;
 };
+/** 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;
+    }
     interface Window {
-        _zx: ZXInstance;
+        __zx_dev_reinit?: () => Promise<{
+            source: WebAssembly.WebAssemblyInstantiatedSource;
+            bridge: ZxBridge;
+        }>;
+        __ZIEX_DEVTOOLS_GLOBAL_HOOK__?: ZiexDevtoolsHook;
     }
 }
-export {};