ziex 0.1.0-dev.805 → 0.1.0-dev.852

package/cloudflare/index.js

@@ -377,7 +377,7 @@ class ZxBridge extends ZxBridgeCore {
   }
   submitFormActionAsync(form, statesJson, fetchId) {
     const formData = new FormData(form);
-    formData.append("__zx_states", statesJson);
+    formData.append("__$states", statesJson);
     fetch(window.location.href, {
       method: "POST",
       headers: { "X-ZX-Action": "1" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziex",
-  "version": "0.1.0-dev.805",
+  "version": "0.1.0-dev.852",
   "description": "ZX is a framework for building web applications with Zig.",
   "main": "index.js",
   "type": "module",

package/wasm/index.js

@@ -377,7 +377,7 @@ class ZxBridge extends ZxBridgeCore {
   }
   submitFormActionAsync(form, statesJson, fetchId) {
     const formData = new FormData(form);
-    formData.append("__zx_states", statesJson);
+    formData.append("__$states", statesJson);
     fetch(window.location.href, {
       method: "POST",
       headers: { "X-ZX-Action": "1" },

package/wasm/init.js

@@ -366,7 +366,7 @@ class ZxBridge extends ZxBridgeCore {
   }
   submitFormActionAsync(form, statesJson, fetchId) {
     const formData = new FormData(form);
-    formData.append("__zx_states", statesJson);
+    formData.append("__$states", statesJson);
     fetch(window.location.href, {
       method: "POST",
       headers: { "X-ZX-Action": "1" },

package/app.d.ts

@@ -1,112 +0,0 @@
-import type { DurableObjectNamespace } from "./runtime";
-import type { KVNamespace } from "./kv";
-import type { WASI } from "./wasi";
-/**
- * Anything that can be resolved to a `WebAssembly.Module`:
- * - `WebAssembly.Module` — already compiled (Cloudflare Workers, wrangler)
- * - `ArrayBuffer` / `ArrayBufferView` — raw WASM bytes
- * - `Response` — a fetch() response whose body is the WASM binary
- * - `string` — an HTTP(S) URL or an absolute file path (Bun)
- * - `URL` — a URL object
- */
-export type WasmInput = WebAssembly.Module | ArrayBuffer | ArrayBufferView | Response | string | URL;
-/**
- * Resolve any supported WASM input to a compiled `WebAssembly.Module`.
- * The result is NOT cached here — cache it at the call site if needed.
- */
-export declare function resolveModule(input: WasmInput): Promise<WebAssembly.Module>;
-/** Keys of `Env` whose value extends {@link KVNamespace}. */
-type KVKey<Env> = {
-    [K in keyof Env]: Env[K] extends KVNamespace ? K : never;
-}[keyof Env];
-/** Keys of `Env` whose value extends {@link DurableObjectNamespace}. */
-type DOKey<Env> = {
-    [K in keyof Env]: Env[K] extends DurableObjectNamespace ? K : never;
-}[keyof Env];
-type ZiexOptions<Env> = {
-    /** WASM module — accepts any {@link WasmInput}. Resolved and cached on first request. */
-    module: WasmInput;
-    /** Optional pre-configured WASI instance. */
-    wasi?: WASI;
-    /** Extra WASM import namespaces. */
-    imports?: (mem: () => WebAssembly.Memory) => Record<string, Record<string, unknown>>;
-    /**
-     * KV namespace bindings. Two forms are supported:
-     *
-     * - **Env key**: a single key from `Env` whose value is a `KVNamespace` — used as the `"default"` binding.
-     * - **Name map**: `{ [bindingName]: envKey }` — map namespace names to env keys.
-     *
-     * @example Single env key (becomes the "default" binding)
-     * ```ts
-     * kv: "MY_KV"
-     * ```
-     * @example Name map
-     * ```ts
-     * kv: { default: "MY_KV", users: "USERS_KV" }
-     * ```
-     */
-    kv?: KVKey<Env> | Record<string, KVKey<Env>>;
-    /**
-     * Env key whose value is a `DurableObjectNamespace` for WebSocket pub/sub.
-     * Requires `createWebSocketDO` export on the worker.
-     *
-     * @example
-     * ```ts
-     * websocket: "ChatRoom"
-     * ```
-     */
-    websocket?: DOKey<Env>;
-};
-/**
- * Main Ziex application class. Mirrors the Hono API style — construct once,
- * export as default, and the runtime calls `fetch` for you.
- *
- * Works on Cloudflare Workers, Bun, and Vercel Edge out of the box.
- *
- * @example Cloudflare Workers / wrangler
- * ```ts
- * import { Ziex } from "ziex";
- * import module from "./app.wasm";
- *
- * const app = new Ziex<Env>({
- *   module,
- *   kv: (env) => ({ default: env.KV }),
- * });
- * export default app;
- * ```
- *
- * @example Bun
- * ```ts
- * import { Ziex } from "ziex";
- * import wasmPath from "./app.wasm" with { type: "wasm" };
- *
- * const app = new Ziex({ module: wasmPath });
- * export default app;
- * ```
- *
- * @example Vercel Edge
- * ```ts
- * import { Ziex } from "ziex";
- * import { handle } from "ziex/vercel";
- *
- * const app = new Ziex({ module: "https://example.com/app.wasm" });
- * export default handle(app);
- * ```
- */
-export declare class Ziex<Env = Record<string, unknown>> {
-    private readonly options;
-    private resolved;
-    constructor(options: ZiexOptions<Env>);
-    private getModule;
-    private resolveKV;
-    /**
-     * Fetch handler called by the runtime on every request.
-     *
-     * Arrow function so `this` is always the class instance, even when the
-     * runtime extracts `fetch` from the exported object (e.g. Bun).
-     */
-    fetch: (request: Request, env: Env, ctx?: {
-        waitUntil(p: Promise<unknown>): void;
-    }) => Promise<Response>;
-}
-export {};

package/aws-lambda/index.d.ts

@@ -1,96 +0,0 @@
-/**
- * Ziex adapter for AWS Lambda (API Gateway v1, v2, and ALB).
- *
- * Based on Hono's AWS Lambda adapter implementation.
- *
- * @example API Gateway v2 (HTTP API)
- * ```ts
- * import { Ziex } from "ziex/cloudflare";
- * import { handle } from "ziex/aws-lambda";
- * import module from "./app.wasm";
- *
- * const app = new Ziex({ module });
- * export const handler = handle(app);
- * ```
- */
-type ApiGwV1Event = {
-    version?: "1.0";
-    httpMethod: string;
-    path: string;
-    headers: Record<string, string> | null;
-    multiValueHeaders: Record<string, string[]> | null;
-    queryStringParameters: Record<string, string> | null;
-    multiValueQueryStringParameters: Record<string, string[]> | null;
-    body: string | null;
-    isBase64Encoded: boolean;
-    requestContext: {
-        elb?: unknown;
-    };
-};
-type ApiGwV2Event = {
-    version: "2.0";
-    requestContext: {
-        http: {
-            method: string;
-        };
-    };
-    rawPath: string;
-    rawQueryString: string;
-    headers: Record<string, string>;
-    body?: string;
-    isBase64Encoded: boolean;
-};
-type AlbEvent = {
-    httpMethod: string;
-    path: string;
-    headers: Record<string, string> | null;
-    multiValueHeaders: Record<string, string[]> | null;
-    queryStringParameters: Record<string, string> | null;
-    multiValueQueryStringParameters: Record<string, string[]> | null;
-    body: string | null;
-    isBase64Encoded: boolean;
-    requestContext: {
-        elb: unknown;
-    };
-};
-export type LambdaEvent = ApiGwV1Event | ApiGwV2Event | AlbEvent;
-export type LambdaContext = {
-    functionName: string;
-    functionVersion: string;
-    invokedFunctionArn: string;
-    memoryLimitInMB: string;
-    awsRequestId: string;
-    logGroupName: string;
-    logStreamName: string;
-    callbackWaitsForEmptyEventLoop: boolean;
-    getRemainingTimeInMillis(): number;
-};
-export type LambdaResult = {
-    statusCode: number;
-    headers: Record<string, string>;
-    multiValueHeaders: Record<string, string[]>;
-    body: string;
-    isBase64Encoded: boolean;
-    cookies?: string[];
-};
-type FetchApp = {
-    fetch(req: Request, env?: unknown, ctx?: unknown): Promise<Response>;
-};
-export type HandleOptions = {
-    /**
-     * Content types to encode as base64 in the Lambda response.
-     * By default, non-text content types are base64 encoded automatically.
-     */
-    binaryMediaTypes?: string[];
-};
-/**
- * Wrap a Ziex app as an AWS Lambda handler.
- *
- * @example
- * ```ts
- * import { handle } from "ziex/aws-lambda";
- * export const handler = handle(app);
- * ```
- */
-export declare function handle(app: FetchApp, options?: HandleOptions): (event: LambdaEvent, _context?: LambdaContext) => Promise<LambdaResult>;
-export {};

package/cloudflare/app.d.ts

@@ -1,2 +0,0 @@
-export { Ziex, resolveModule } from "../app";
-export type { WasmInput } from "../app";

package/cloudflare/do.d.ts

@@ -1,48 +0,0 @@
-import type { WsState } from "../runtime";
-import type { KVNamespace } from "../kv";
-type ConnState = WsState & {
-    topics: Set<string>;
-};
-/**
- * Create a Durable Object class that handles WebSocket connections for a ZX app.
- *
- * Each DO instance corresponds to one "room" (keyed by pathname). All clients
- * connecting to the same route share a DO instance, enabling pub/sub via
- * `ctx.socket.subscribe()` / `ctx.socket.publish()`.
- *
- * @example
- * ```ts
- * // worker.ts
- * import { Ziex } from "ziex";
- * import { createWebSocketDO } from "ziex/cloudflare";
- * import module from "./app.wasm";
- *
- * export const ZxWS = createWebSocketDO(module);
- *
- * export default new Ziex({
- *   module,
- *   websocket: (env) => env.ZxWS,
- * });
- * ```
- */
-export declare function createWebSocketDO(module: WebAssembly.Module, options?: {
-    /**
-     * KV namespace bindings for the DO. Pass a factory that receives the DO's
-     * `env` so bindings are resolved at runtime:
-     *
-     * ```ts
-     * createWebSocketDO(module, { kv: (env) => ({ default: env.KV }) })
-     * ```
-     */
-    kv?: (env: any) => Record<string, KVNamespace>;
-    imports?: (mem: () => WebAssembly.Memory) => Record<string, Record<string, unknown>>;
-}): {
-    new (state: any, env: any): {
-        readonly doState: any;
-        readonly env: any;
-        /** All active connections in this room, keyed by their server-side WebSocket. */
-        readonly connections: Map<WebSocket, ConnState>;
-        fetch(request: Request): Promise<Response>;
-    };
-};
-export {};

package/cloudflare/index.d.ts

@@ -1,4 +0,0 @@
-export * as worker from "../runtime";
-export * as kv from "../kv";
-export { Ziex } from "../app";
-export { createWebSocketDO } from "./do";

package/cloudflare/kv.d.ts

@@ -1,2 +0,0 @@
-export { createMemoryKV, createKVImports } from "../kv";
-export type { KVNamespace } from "../kv";

package/cloudflare/worker.d.ts

@@ -1,3 +0,0 @@
-export { run, buildWsImports, attachWebSocket } from "../runtime";
-export type { DurableObjectNamespace, WsState } from "../runtime";
-export { createWebSocketDO } from "./do";

package/index.d.ts

@@ -1,2 +0,0 @@
-export { Ziex } from "./app";
-export type { WasmInput } from "./app";

package/kv.d.ts

@@ -1,27 +0,0 @@
-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/react/dom.d.ts

@@ -1,21 +0,0 @@
-import type { ComponentMetadata } from "./types";
-export type PreparedComponent = {
-    domNode: HTMLElement;
-    props: Record<string, any> & {
-        dangerouslySetInnerHTML?: {
-            __html: string;
-        };
-    };
-    Component: (props: any) => React.ReactElement;
-};
-export declare function prepareComponent(component: ComponentMetadata): Promise<PreparedComponent>;
-export declare function filterComponents(components: ComponentMetadata[]): ComponentMetadata[];
-export type DiscoveredComponent = {
-    id: string;
-    name: string;
-    props: Record<string, any>;
-    container: HTMLElement;
-};
-export declare function discoverComponents(): DiscoveredComponent[];
-export type ComponentRegistry = Record<string, () => Promise<(props: any) => React.ReactElement>>;
-export declare function hydrateAll(registry: ComponentRegistry, render: (container: HTMLElement, Component: (props: any) => React.ReactElement, props: Record<string, any>) => void): Promise<void>;

package/react/index.d.ts

@@ -1,2 +0,0 @@
-export { prepareComponent, filterComponents, discoverComponents, hydrateAll, type PreparedComponent, type DiscoveredComponent, type ComponentRegistry, } from "./dom";
-export type { ComponentMetadata } from "./types";

package/react/types.d.ts

@@ -1,190 +0,0 @@
-/**
- * Metadata for a client-side component used within a ZX file.
- *
- * This type represents the metadata for components that are marked with the `@rendering` attribute
- * in ZX files. When a component is declared with `@rendering={.react}` or `@rendering={.client}` in a
- * `.zx` file, the ZX transpiler generates a `ComponentMetadata` entry that is included in the
- * generated `components` array.
- *
- * @example
- * ```tsx
- * // In a ZX file (page.zx):
- * <CounterComponent @rendering={.react} max_count={10} />
- *
- * // Generated components array (components.ts):
- * export const components: ComponentMetadata[] = [
- *   {
- *     name: "CounterComponent",
- *     path: "./components/CounterComponent.tsx",
- *     id: "zx-dcde04c415da9d1b15ca2690d8b497ae",
- *     type: "react",
- *     import: () => import('./components/CounterComponent.tsx')
- *   }
- * ];
- * ```
- *
- * @example
- * ```tsx
- * // Using ComponentMetadata with prepareComponent:
- * import { prepareComponent, type ComponentMetadata } from "ziex";
- *
- * for (const component of components) {
- *   const { domNode, props, Component } = await prepareComponent(component);
- *   // Render component to DOM node
- * }
- * ```
- */
-export type ComponentMetadata = {
-    /**
-     * The name of the component as declared in the ZX file.
-     *
-     * This is the tag name used in JSX syntax within `.zx` files. It corresponds to the component
-     * identifier used in the component declaration (e.g., `<CounterComponent />`).
-     *
-     * @example
-     * ```tsx
-     * // In ZX file:
-     * <CounterComponent @rendering={.react} />
-     *
-     * // name will be: "CounterComponent"
-     * ```
-     */
-    name: string;
-    /**
-     * The file path to the component module.
-     *
-     * This is the relative or absolute path to the component file that will be dynamically imported
-     * at runtime. For CSR components, this typically points to a `.tsx` or `.jsx` file. For Client
-     * components, this points to a Zig component file.
-     *
-     * The path is determined from the `@jsImport` directive in the ZX file, or defaults to
-     * `./{componentName}.tsx` if not explicitly specified.
-     *
-     * @example
-     * ```tsx
-     * // In ZX file:
-     * const CounterComponent = @jsImport("components/Counter.tsx");
-     * <CounterComponent @rendering={.react} />
-     *
-     * // path will be: "components/Counter.tsx"
-     * ```
-     *
-     * @example
-     * ```tsx
-     * // Without explicit @jsImport:
-     * <MyComponent @rendering={.react} />
-     *
-     * // path will default to: "./MyComponent.tsx"
-     * ```
-     */
-    path: string;
-    /**
-     * The route of of the component in which page the component was used,
-     * null in case the component was used in other non-page/layout context.
-     * ```
-     */
-    route: string | null;
-    /**
-     * A unique identifier for the component's hydration boundary.
-     *
-     * This ID is generated by hashing the component's path and name using MD5, then formatting it
-     * as a hex string with the "zx-" prefix and a counter suffix. The ID is used to locate the
-     * component's comment markers in the DOM during client-side hydration.
-     *
-     * The ID format is: `zx-{32 hex characters}-{counter}` (e.g., `zx-dcde04c415da9d1b15ca2690d8b497ae-0`)
-     *
-     * The ZX runtime renders components with comment markers in the format:
-     * `<!--$id name props-->...<!--/$id-->`
-     *
-     * @example
-     * ```tsx
-     * // Component metadata:
-     * {
-     *   name: "CounterComponent",
-     *   path: "./components/Counter.tsx",
-     *   id: "zx-dcde04c415da9d1b15ca2690d8b497ae-0"
-     * }
-     *
-     * // Generated HTML with comment markers:
-     * <!--$zx-dcde04c415da9d1b15ca2690d8b497ae-0 CounterComponent {"max_count":10}-->
-     * <button>0</button>
-     * <!--/$zx-dcde04c415da9d1b15ca2690d8b497ae-0-->
-     * ```
-     */
-    id: string;
-    /**
-     * The rendering type of the component, determining how it will be rendered on the client.
-     *
-     * - **"react"** (Client Side React): The component is a React component that will be rendered
-     *   using React's client-side rendering. The component file should export a default React
-     *   component function. This is the most common type for interactive UI components.
-     *
-     * - **"client"** (Client Side Zig): The component is a Zig component that will be compiled to
-     *   WebAssembly and rendered on the client side. This allows you to use Zig's performance
-     *   and type safety for client-side components.
-     *
-     * The type is determined by the `@rendering` attribute value in the ZX file (`.react` or `.client`).
-     *
-     * @example
-     * ```tsx
-     * // CSR component (React):
-     * <CounterComponent @rendering={.react} max_count={10} />
-     * // type: "react"
-     *
-     * // Component file (CounterComponent.tsx):
-     * export default function CounterComponent({ max_count }: { max_count: number }) {
-     *   return <div>Count: {max_count}</div>;
-     * }
-     * ```
-     *
-     * @example
-     * ```tsx
-     * // Client component (Zig/WASM):
-     * <CounterComponent @rendering={.client} />
-     * // type: "client"
-     *
-     * // Component file (CounterComponent.zig):
-     * pub fn CounterComponent(allocator: zx.Allocator) zx.Component {
-     *   return (<div @allocator={allocator}>Counter</div>);
-     * }
-     * ```
-     */
-    type: "react" | "client";
-    /**
-     * A lazy-loading function that dynamically imports the component module.
-     *
-     * This function returns a Promise that resolves to the component function. It enables
-     * code-splitting and lazy loading of components, improving initial page load performance
-     * by only loading components when they are needed.
-     *
-     * For CSR components, the imported module should export a default React component.
-     * For Client components, the import mechanism depends on the WASM module structure.
-     *
-     * The function is called during client-side hydration to load and render the component
-     * into its corresponding DOM container element.
-     *
-     * @returns A Promise that resolves to a component function that accepts props and returns a React element.
-     *
-     * @example
-     * ```tsx
-     * // Component metadata:
-     * {
-     *   import: () => import('./components/CounterComponent.tsx')
-     * }
-     *
-     * // Usage:
-     * const Component = await component.import();
-     * // Component is now the default export from CounterComponent.tsx
-     * ```
-     *
-     * @example
-     * ```tsx
-     * // With prepareComponent helper:
-     * import { prepareComponent } from "ziex";
-     *
-     * const { Component, props, domNode } = await prepareComponent(component);
-     * // Component is loaded and ready to render with props
-     * ```
-     */
-    import: () => Promise<(props: any) => React.ReactElement>;
-};

package/runtime.d.ts

@@ -1,70 +0,0 @@
-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

@@ -1,26 +0,0 @@
-/**
- * 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/wasi.d.ts

@@ -1,61 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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;
-    }
-}

package/wasm/init.d.ts

@@ -1 +0,0 @@
-export {};

package/wasm/types.d.ts

@@ -1 +0,0 @@
-export type ComponentMetadata = {};

package/wasm/wasi.d.ts

@@ -1,28 +0,0 @@
-/**
- * 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/zx.d.ts

@@ -1 +0,0 @@
-export declare function getZxInfo(): any;