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

package/cloudflare/kv.d.ts

@@ -1,27 +1,2 @@
-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 `worker.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>;
+export { createMemoryKV, createKVImports } from "../kv";
+export type { KVNamespace } from "../kv";

package/cloudflare/worker.d.ts

@@ -1,148 +1,3 @@
-/**
- * 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 worker.run({
- *   request, env, ctx, wasmModule,
- *   kv: { default: env.KV, users: env.USERS_KV },
- * });
- * ```
- */
-/** Minimal Durable Object namespace shape needed for WebSocket routing. */
-type DurableObjectNamespace = {
-    idFromName(name: string): unknown;
-    get(id: unknown): {
-        fetch(req: Request): Promise<Response>;
-    };
-};
-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, import("./kv").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.
-     *
-     * The DO class must be created with `createWebSocketDO` and exported from
-     * your worker:
-     *
-     * ```ts
-     * export const MyDO = createWebSocketDO(module);
-     * export default {
-     *   fetch: (req, env, ctx) => run({ request: req, ctx, module, websocket: env.MyDO }),
-     * };
-     * ```
-     */
-    websocket?: DurableObjectNamespace;
-}): Promise<Response>;
-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;
-};
-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 { run, createWebSocketDO } from "ziex/cloudflare";
- * import module from "./app.wasm";
- *
- * export const ZxWS = createWebSocketDO(module);
- *
- * export default {
- *   fetch: (req: Request, env: any, ctx: any) =>
- *     run({ request: req, ctx, module, websocket: 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, import("./kv").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 declare function prepare({ request, env, ctx, }: {
-    request: Request;
-    env: unknown;
-    ctx: unknown;
-}): {
-    args: string[];
-    stdout: TransformStream<any, any>;
-    stderr: TransformStream<any, any>;
-    stdin: ReadableStream<Uint8Array<ArrayBufferLike>> | undefined;
-};
-export declare function respond({ exec, stdout, stderr, }: {
-    exec: Promise<number | undefined>;
-    stdout: TransformStream;
-    stderr: TransformStream | ReadableStream<Uint8Array>;
-}): Promise<Response>;
-type WASI = {
-    args?: Array<string>;
-    env?: Array<string>;
-    fds?: Array<unknown>;
-    inst?: {
-        exports: {
-            memory: WebAssembly.Memory;
-        };
-    };
-    wasiImport: Record<string, Function> | {
-        [key: string]: (...args: Array<any>) => unknown;
-    };
-    start(instance: {
-        exports: {
-            memory: WebAssembly.Memory;
-            _start: () => unknown;
-        };
-    }): number;
-    initialize?(instance: {
-        exports: {
-            memory: WebAssembly.Memory;
-            _initialize?: () => unknown;
-        };
-    }): void;
-};
-export {};
+export { run, buildWsImports, attachWebSocket } from "../runtime";
+export type { DurableObjectNamespace, WsState } from "../runtime";
+export { createWebSocketDO } from "./do";

package/index.d.ts

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