ziex 0.1.0-dev.786 → 0.1.0-dev.804

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/aws-lambda/index.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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/aws-lambda/index.js

@@ -0,0 +1,126 @@
+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/aws-lambda/index.ts
+function isV2(event) {
+  return "requestContext" in event && event.requestContext !== null && "http" in event.requestContext;
+}
+function getMethod(event) {
+  if (isV2(event))
+    return event.requestContext.http.method;
+  return event.httpMethod;
+}
+function getPath(event) {
+  if (isV2(event)) {
+    return event.rawPath + (event.rawQueryString ? `?${event.rawQueryString}` : "");
+  }
+  const e = event;
+  const mvqs = e.multiValueQueryStringParameters;
+  const qs = e.queryStringParameters;
+  let queryString = "";
+  if (mvqs) {
+    queryString = Object.entries(mvqs).flatMap(([k, vs]) => (vs ?? []).map((v) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)).join("&");
+  } else if (qs) {
+    queryString = new URLSearchParams(qs).toString();
+  }
+  return e.path + (queryString ? `?${queryString}` : "");
+}
+function getHeaders(event) {
+  const headers = new Headers;
+  if (event.headers) {
+    for (const [k, v] of Object.entries(event.headers)) {
+      if (v != null)
+        headers.set(k, v);
+    }
+  }
+  if ("multiValueHeaders" in event && event.multiValueHeaders) {
+    for (const [k, vs] of Object.entries(event.multiValueHeaders)) {
+      if (!vs?.length)
+        continue;
+      headers.delete(k);
+      for (const v of vs)
+        headers.append(k, v);
+    }
+  }
+  return headers;
+}
+function getBody(event) {
+  if (!event.body)
+    return null;
+  if (event.isBase64Encoded)
+    return Buffer.from(event.body, "base64");
+  return event.body;
+}
+function toRequest(event, headers) {
+  const method = getMethod(event);
+  const host = headers.get("host") ?? "localhost";
+  const proto = headers.get("x-forwarded-proto") ?? "https";
+  const path = getPath(event);
+  const url = `${proto}://${host}${path}`;
+  const body = ["GET", "HEAD"].includes(method) ? null : getBody(event);
+  return new Request(url, { method, headers, body });
+}
+var TEXT_CONTENT_TYPES = [
+  "text/",
+  "application/json",
+  "application/xml",
+  "application/javascript",
+  "application/xhtml"
+];
+function isBinaryContent(contentType, binaryMediaTypes) {
+  if (binaryMediaTypes.length > 0) {
+    return binaryMediaTypes.some((t) => contentType.includes(t));
+  }
+  return !TEXT_CONTENT_TYPES.some((t) => contentType.startsWith(t));
+}
+async function toLambdaResult(res, binaryMediaTypes) {
+  const responseHeaders = {};
+  const multiValueHeaders = {};
+  res.headers.forEach((value, key) => {
+    if (key in responseHeaders) {
+      multiValueHeaders[key] = [...multiValueHeaders[key] ?? [responseHeaders[key]], value];
+      delete responseHeaders[key];
+    } else if (key in multiValueHeaders) {
+      multiValueHeaders[key].push(value);
+    } else {
+      responseHeaders[key] = value;
+    }
+  });
+  const contentType = res.headers.get("content-type") ?? "";
+  const binary = isBinaryContent(contentType, binaryMediaTypes);
+  let body;
+  let isBase64Encoded = false;
+  if (binary) {
+    body = Buffer.from(await res.arrayBuffer()).toString("base64");
+    isBase64Encoded = true;
+  } else {
+    body = await res.text();
+  }
+  return {
+    statusCode: res.status,
+    headers: responseHeaders,
+    multiValueHeaders,
+    body,
+    isBase64Encoded
+  };
+}
+function handle(app, options = {}) {
+  const binaryMediaTypes = options.binaryMediaTypes ?? [];
+  return async (event, _context) => {
+    const headers = getHeaders(event);
+    const req = toRequest(event, headers);
+    const res = await app.fetch(req);
+    return toLambdaResult(res, binaryMediaTypes);
+  };
+}
+export {
+  handle
+};

package/cloudflare/app.d.ts

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