ziex 0.0.1-dev.7 → 0.1.0-dev.1014

package/README.md

@@ -1,10 +1,17 @@
-# ZX
+<p align="center">
+    <img src="https://raw.githubusercontent.com/ziex-dev/branding/main/banner.svg" alt="Ziex banner" width="100%" />
+</p>
 
-A Zig library for building web applications with JSX-like syntax. Write declarative UI components using familiar JSX patterns, transpiled to efficient Zig code.
+A full-stack web framework for Zig. Write declarative UI components using familiar JSX patterns, transpiled to efficient Zig code.
 
-ZX combines the power and performance of Zig with the expressiveness of JSX, enabling you to build fast, type-safe web applications. ZX is significantly faster than frameworks like Next.js at SSR.
+Ziex combines the power and performance of Zig with the expressiveness of JSX, enabling you to build fast, type-safe web applications.
+
+**[Documentation →](https://ziex.dev/learn)**
+
+
+
+> **Note:** Most of the API and syntax are finalized and stable, and server-side rendering (SSR) features are production-ready, Ziex continues to evolve with ongoing improvements to client-side rendering and state management. You can start using the documented features today, as they are stable and unlikely to change. Areas still under development are not yet documented and will be added as they mature.
 
-**[Full Documentation →](https://ziex.dev)**
 
 ## Installation
 
@@ -25,47 +32,45 @@ winget install -e --id zig.zig # Windows
 ```
 [_See for other platforms →_](https://ziglang.org/learn/getting-started/)
 
-## Quick Example
 
-```tsx site/pages/examples/overview.zx
-pub fn QuickExample(allocator: zx.Allocator) zx.Component {
+## At a Glance
+
+```tsx site/pages/examples/playground.zx
+pub fn Playground(allocator: zx.Allocator) zx.Component {
     const is_loading = true;
-    const chars = "Hello, ZX Dev!";
+    var i: usize = 0;
 
     return (
         <main @allocator={allocator}>
-            <section>
-                {if (is_loading) (<h1>Loading...</h1>) else (<h1>Loaded</h1>)}
-            </section>
-        
-            <section>
-                {for (chars) |char| (<span>{[char:c]}</span>)}
-            </section>
-        
-            <section>
-                {for (users) |user| (
-                    <Profile name={user.name} age={user.age} role={user.role} />
-                )}
-            </section>
+            <h1>Hello, Ziex!</h1>
+
+            {for (users) |user| (
+                <Profile name={user.name} age={user.age} role={user.role} />
+            )}
+
+            {if (is_loading) (<p>Loading...</p>) else (<p>Loaded</p>)}
+
+            {while (i < 5) : (i += 1) (<i>{i}</i>)}
         </main>
     );
 }
 
-fn Profile(allocator: zx.Allocator, user: User) zx.Component {
+fn Profile(ctx: *zx.ComponentCtx(User)) zx.Component {
     return (
-        <div @allocator={allocator}>
-            <h1>{user.name}</h1>
-            <p>{[user.age:d]}</p>
-            {switch (user.role) {
-                .admin => (<p>Admin</p>),
-                .member => (<p>Member</p>),
-            }}
+        <div @allocator={ctx.allocator}>
+            <h3>{ctx.props.name}</h3>
+            <div>{ctx.props.age}</div>
+            <strong>
+                {switch (ctx.props.role) {
+                    .admin => "Admin",
+                    .member => "Member",
+                }}
+            </strong>
         </div>
     );
 }
 
-const UserRole = enum { admin, member };
-const User = struct { name: []const u8, age: u32, role: UserRole };
+const User = struct { name: []const u8, age: u32, role: enum { admin, member } };
 
 const users = [_]User{
     .{ .name = "John", .age = 20, .role = .admin },
@@ -74,79 +79,116 @@ const users = [_]User{
 
 const zx = @import("zx");
 ```
-## Feature Checklist
-
-- [x] Server Side Rendering (SSR)
-- [x] Static Site Generation (SSG)
-- [ ] Client Side Rendering (CSR) via WebAssembly (_WIP_)
-- [x] Client Side Rendering (CSR) via React
-- [x] Type Safety
-- [x] Routing
-    - [x] File-system Routing
-    - [x] Search Parameters
-    - [x] Path Segments
-- [x] Components
-- [x] Control Flow
-    - [x] `if`
-    - [ ] `if` nested
-    - [x] `if/else`
-    - [x] `if/else` nested
-    - [x] `for`
-    - [x] `for` nested
-    - [x] `switch`
-    - [x] `switch` nested
-    - [x] `while`
-    - [x] `while` nested
-- [x] Assets
-    - [x] Copying
-    - [x] Serving
-- [ ] Assets Optimization
-    - [ ] Image
-    - [ ] CSS
-    - [ ] JS
-    - [ ] HTML
-- [ ] Middleware
-- [ ] API Endpoints
-- [ ] Server Actions
-- [x] CLI
-    - [x] `init` Project Template
-    - [x] `transpile` Transpile .zx files to Zig source code
-    - [x] `serve` Serve the project
-    - [x] `dev` HMR or Rebuild on Change
-    - [x] `fmt` Format the ZX source code (_Alpha_)
-    - [x] `export` Generate static site assets
-    - [x] `bundle` Bundle the ZX executable with public/assets and exe
-    - [x] `version` Show the version of the ZX CLI
-    - [x] `update` Update the version of ZX dependency
-    - [x] `upgrade` Upgrade the version of ZX CLI
-
-#### Editor Support
-
-* [VSCode](https://marketplace.visualstudio.com/items?itemName=nurulhudaapon.zx)/[Cursor](https://marketplace.visualstudio.com/items?itemName=nurulhudaapon.zx) Extension
-    - [x] Syntax Highlighting
-    - [x] LSP Support
-    - [x] Auto Format
-
-* Neovim
-    - [ ] Syntax Highlighting
-    - [ ] LSP Support
-    - [ ] Auto Format
-
-## Similar Projects
-
-* [Yew](https://github.com/yewstack/yew) - Rust / Wasm framework for creating reliable and efficient web applications
-* [ZTS](https://github.com/zigster64/zts) — Zig Templates made Simple, a templating system for Zig
-* [zmpl](https://github.com/jetzig-framework/zmpl) — Mode-based templating language that compiles to Zig functions at build time, used in Jetzig
-* [mustache-zig](https://github.com/batiati/mustache-zig) — Mustache template engine implementation in Zig
-* [etch](https://github.com/haze/etch) — Compile-time tuned templating engine focusing on speed and simplicity
-* [Zap](https://github.com/zigzap/zap) — High-performance backend framework in Zig
-* [http.zig](https://github.com/karlseguin/http.zig) — Low-level HTTP/1.1 server written entirely in Zig (_ZX_'s backend)
-* [tokamak](https://github.com/cztomsik/tokamak) — Server-side framework for Zig
-* [zig-router](https://github.com/Cloudef/zig-router) — Straightforward HTTP-like request routing library for Zig
-* [zig-webui](https://github.com/webui-dev/zig-webui/) — Zig library that allows using any web browser as a GUI
-* [Zine](https://github.com/kristoff-it/zine) — Fast, scalable, flexible static site generator (SSG) written in Zig
-* [Zinc](https://github.com/zon-dev/zinc/) — Web framework written in pure Zig with focus on high performance, usability, security, and extensibility
-* [zUI](https://github.com/thienpow/zui) — UI kit for Jetzig framework with reusable components and styles
+
+Try this in [Playground →](https://ziex.dev/playground#data=eF59U01vnDAQ_StTTtAiyGZVqSKAEuVSVa2USy8NUUTAu2sJbGQgoUv83ztjlo-y2_rCfLx5zMyze-uhSH_vlWxF7h07K7Cq9gV2AuawnRaFzNJGqgCOnXc3eg5597KspGCigT4RgCeTom6A18-FTHMu9hBBo1p2M2RfUwU8gLbmR4aZKwwPCcWaVgmwB49OWKZcwO3086ifTB3PMAM9bOKvDLMu_OKs-xD6GBiZx9PvpAK7rZmqHXin7_vydxPXg5I7XjAQacminnAemRrS_eijpUHJYvTJ1OCvunL0WQt8B_a8GgfssIq_D47neaFfxQ6womZTguUmeM70dqAebQ4hfHYgIOtTBBui5HHPdehzUzYWhD6t89Shg2s3lKTzMK6dNV0AH5eK3jed_RPHcy4LfUGxnL_-JRhyev8RbRsbRKVkVQ87RuG2axiSLnG0-9Cn4ApXN0qK_SpKp6_feJMdwJ5JSDBnHGR9vDQv8eZFMSTWHZmJ5f4DWbLyhakB-sPYF7Far3r1z5pdjjTJM7wl0gDfCpa0GW7fXMwAHp-GbPvFpZuJb2p77ZpLGQATbYlAM4cLpyY16JuZ1LwDZH18fiL-0yq8HowQmEisb_JAowOtHAPXV2gSP9qnFWn3Ulkq2LJssygbW8G6ZTPHDpO3HC-YauzEOnaJRTuw9B927V4U)
+
+<details>
+<summary>Explanation of this</summary>
+
+```tsx site/pages/examples/playground.zx
+// A Zig function that returns a `zx.Component`.
+pub fn Playground(allocator: zx.Allocator) zx.Component {
+    const is_loading = true;
+    var i: usize = 0;
+
+    // HTML Block is always surrounded by parentheses and can contain HTML elements and control flow statements.
+    return (
+        // @allocator or any other attribute starting with `@` is called builtin attribute
+        // `@allocator` is used to specify the allocator for the component and its children for mem allocation.
+        <main @allocator={allocator}>
+            <h1>Hello, Ziex!</h1>
+
+            // `for` loop to iterate over `users` array and render a `Profile` component for each user.
+            // Since this is an expression the HTMLs are inside parenteses not curly braces.
+            {for (users) |user| (
+                // `Profile` component is called with props: name, age, and role.
+                // Optional props can be omitted, and the component will receive default values for them.
+                <Profile name={user.name} age={user.age} role={user.role} />
+            )}
+
+            // `if` statement works just like other control flow statements.
+            {if (is_loading) (<p>Loading...</p>) else (<p>Loaded</p>)}
+
+            // `while` loop with an optional increment statement.
+            {while (i < 5) : (i += 1) (<i>{i}</i>)}
+        </main>
+    );
+}
+
+// A Ziex Component is a Zig function that returns a `zx.Component`.
+// It can have signatures like:
+// - `pub fn ComponentName(allocator: zx.Allocator) zx.Component`
+// - `pub fn ComponentName(ctx: *zx.ComponentCtx<PropsType>) zx.Component`
+// - `pub fn ComponentName(allocator: zx.Allocator, props: PropsType) zx.Component`
+fn Profile(ctx: *zx.ComponentCtx(User)) zx.Component {
+    return (
+        <div @allocator={ctx.allocator}>
+        // Exrepssion starts with `{` and ends with `}`. You can use it to access props, call functions, any valid Zig expression
+            <h3>{ctx.props.name}</h3>
+            <div>{ctx.props.age}</div>
+            <strong>
+                {switch (ctx.props.role) {
+                    .admin => "Admin",
+                    .member => "Member",
+                }}
+            </strong>
+        </div>
+    );
+}
+
+const User = struct { name: []const u8, age: u32, role: enum { admin, member } };
+
+const users = [_]User{
+    .{ .name = "John", .age = 20, .role = .admin },
+    .{ .name = "Jane", .age = 21, .role = .member },
+};
+
+const zx = @import("zx");
+```
+
+</details>
+
+## Features
+- **JSX-like Syntax**: Write declarative UI components using familiar JSX patterns, transpiled to efficient Zig code.
+- **Full-Stack Capabilities**: Build both frontend and backend of your web application using
+- **It's Fast**: Significantly faster at SSR than many other frameworks.
+- **Compile-time Safety**: Zig's type system catches bugs at compile time. No runtime surprises, no GC.
+- **Familiar Syntax**: Familiar JSX-like syntax, or plain HTML-style markup, with full access to Zig's control flow.
+- **Server-side Rendering**: Render per request on the server for dynamic data, auth, and personalized pages for best performance and SEO.
+- **Static Site Generation**: Pre-render pages at build/export time into static HTML for fast CDN delivery.
+- **File System Routing**: Folder structure defines routes. No configs, no magic strings, just files in folders.
+- **Client-side Rendering**: Optional client-side rendering for interactive experiences when you need it.
+- **Control Flow in Zig's Syntax**: if/else, for/while, and switch all work as expected. It's just Zig.
+- **Developer Tooling**: CLI, hot reload, and editor extensions for the best DX.
+
+## Roadmap
+
+We track our feature roadmap and bugs using GitHub Issues. 
+You can view our current progress and planned features here:
+
+**[Check out the Ziex Issue Tracker →](https://github.com/ziex-dev/ziex/issues)**
+
+## Editor Support
+
+* [VSCode](https://marketplace.visualstudio.com/items?itemName=ziex.ziex)/[VSCode Forks](https://open-vsx.org/extension/ziex/ziex) Extension
+* [Neovim](/ide/neovim/)
+* [Helix](/ide/helix/)
+* [Zed](/ide/zed/)
+
+## Community
+
+- [Discord](https://ziex.dev/r/discord)
+- [Topic on Ziggit](https://ziex.dev/r/ziggit)
+- [Project on Zig Discord Community](https://ziex.dev/r/zig-discord) (Join Zig Discord first: https://discord.gg/zig)
+
+
+## Links
+
+* [Codeberg Mirror](https://codeberg.org/ziex/ziex) - ZX repository mirror on Codeberg
+* [ziex.dev](https://github.com/ziex-dev/ziex/tree/main/site) - Official documentation site of ZX made using ZX.
+* [example-blog](https://github.com/ziex-dev/example-blog) - Demo blog web application built with ZX
+* [zx-numbers-game](https://github.com/Andrew-Velox/zx-numbers-game) - ZX numbers game
+* [Comparision with other frameworks](https://ziex.dev/vs)
 
 ## Contributing
 

package/app.d.ts

@@ -0,0 +1,124 @@
+import type { DurableObjectNamespace } from "./runtime";
+import type { KVNamespace } from "./kv";
+import type { D1Database } from "./db";
+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 DBKey<Env> = {
+    [K in keyof Env]: Env[K] extends D1Database ? 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>>;
+    /**
+     * D1 database bindings. Same shape as `kv`:
+     *
+     * - `"DB"` maps `env.DB` to the `"default"` database binding.
+     * - `{ default: "DB", analytics: "ANALYTICS_DB" }` maps multiple bindings.
+     */
+    db?: DBKey<Env> | Record<string, DBKey<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;
+    private resolveDB;
+    /**
+     * 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,130 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// 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/bin/ziex

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const pkgName = `@ziex/cli-${process.platform}-${process.arch}`;
+
+try {
+  const binaryPath = require.resolve(`${pkgName}/bin/zx`);
+
+  const child = spawn(binaryPath, process.argv.slice(2), { 
+    stdio: 'inherit',
+    shell: process.platform === 'win32' 
+  });
+
+  child.on('exit', (code) => process.exit(code ?? 0));
+  child.on('error', (err) => {
+    console.error('Failed to start child process:', err);
+    process.exit(1);
+  });
+} catch (e) {
+  console.error(`Error: Could not find binary for ${process.platform}-${process.arch}`);
+  console.error(`Ensure the optional dependency "${pkgName}" is installed.`);
+  process.exit(1);
+}