ziex 0.1.0-dev.787 → 0.1.0-dev.805

package/README.md

@@ -1,4 +1,6 @@
-# Ziex
+<p align="center">
+    <img src="https://raw.githubusercontent.com/ziex-dev/branding/main/banner.svg" alt="Ziex banner" width="100%" />
+</p>
 
 A full-stack web framework for Zig. Write declarative UI components using familiar JSX patterns, transpiled to efficient Zig code.
 

package/app.d.ts

@@ -0,0 +1,112 @@
+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/build.zig

@@ -0,0 +1,5 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    _ = b; // stub
+}

package/build.zig.zon

@@ -0,0 +1,7 @@
+.{
+    .name = .ziex_js,
+    .fingerprint = 0x3428b4e119b455bf,
+    .version = "0.1.0-dev.804",
+    .minimum_zig_version = "0.15.2",
+    .paths = .{""},
+}

package/cloudflare/app.d.ts

@@ -1,95 +1,2 @@
-import type { KVNamespace } from "./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;
-};
-type ZiexOptions<Env> = {
-    /** Compiled WASM module for the Ziex app. */
-    module: WebAssembly.Module;
-    /** Optional pre-configured WASI instance. */
-    wasi?: WASI;
-    /** Extra WASM import namespaces. */
-    imports?: (mem: () => WebAssembly.Memory) => Record<string, Record<string, unknown>>;
-    /**
-     * Factory that maps platform env bindings to Ziex KV namespaces.
-     * Called per-request so bindings are resolved from the live env.
-     *
-     * @example
-     * ```ts
-     * kv: (env) => ({ default: env.MY_KV })
-     * ```
-     */
-    kv?: (env: Env) => Record<string, KVNamespace>;
-    /**
-     * Factory that maps platform env bindings to a Durable Object namespace
-     * for WebSocket pub/sub. Requires `createWebSocketDO` export on the worker.
-     *
-     * @example
-     * ```ts
-     * websocket: (env) => env.ChatRoom
-     * ```
-     */
-    websocket?: (env: Env) => DurableObjectNamespace;
-};
-/**
- * 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 out of the box. For other platforms use the
- * adapter methods (e.g. `app.vercel()`).
- *
- * @example Cloudflare Workers
- * ```ts
- * import { Ziex } from "ziex/cloudflare";
- * import module from "./app.wasm";
- *
- * const app = new Ziex<Env>({
- *   module,
- *   kv: (env) => ({ default: env.KV }),
- *   websocket: (env) => env.ChatRoom,
- * });
- *
- * export const ChatRoom = createWebSocketDO(module);
- * export default app;
- * ```
- *
- * @example Vercel Edge
- * ```ts
- * import { Ziex } from "ziex/cloudflare";
- * import module from "./app.wasm"; // fetch at runtime on Vercel, see vercel adapter
- *
- * const app = new Ziex({ module });
- * export default app.vercel();
- * ```
- */
-export declare class Ziex<Env = Record<string, unknown>> {
-    private readonly options;
-    constructor(options: ZiexOptions<Env>);
-    /**
-     * Cloudflare Workers fetch handler.
-     *
-     * `env` and `ctx` are injected by the CF runtime — you never call this
-     * directly. Just `export default app` and Cloudflare handles the rest.
-     */
-    fetch(request: Request, env: Env, ctx?: {
-        waitUntil(p: Promise<unknown>): void;
-    }): Promise<Response>;
-}
-export {};
+export { Ziex, resolveModule } from "../app";
+export type { WasmInput } from "../app";

package/cloudflare/do.d.ts

@@ -0,0 +1,48 @@
+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 +1,4 @@
-export * as worker from "./worker";
-export * as kv from "./kv";
-export { Ziex } from "./app";
-export { createWebSocketDO } from "./worker";
+export * as worker from "../runtime";
+export * as kv from "../kv";
+export { Ziex } from "../app";
+export { createWebSocketDO } from "./do";