ziex 0.1.0-dev.727 → 0.1.0-dev.785

package/README.md

@@ -6,6 +6,11 @@ Ziex combines the power and performance of Zig with the expressiveness of JSX, e
 
 **[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.
+
+
 ## Installation
 
 ##### Linux/macOS
@@ -25,51 +30,111 @@ 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;
+    var i: usize = 0;
+
+    return (
+        <main @allocator={allocator}>
+            <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(ctx: *zx.ComponentCtx(User)) zx.Component {
+    return (
+        <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 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");
+```
+
+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;
-    const chars = "Hello, ZX Dev!";
     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}>
-            <section>
-                {if (is_loading) (<h1>Loading...</h1>) else (<h1>Loaded</h1>)}
-            </section>
-        
-            <section>
-                {for (chars) |char| (<span>{char}</span>)}
-            </section>
-        
-            <section>
-                {for (users) |user| (
-                    <Profile name={user.name} age={user.age} role={user.role} />
-                )}
-            </section>
-
-            <section>
-                {while (i < 10) : (i += 1) (<p>{i}</p>)}
-            </section>
+            <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>
     );
 }
 
-fn Profile(allocator: zx.Allocator, user: User) zx.Component {
+// 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={allocator}>
-            <h1>{user.name}</h1>
-            <p>{user.age}</p>
-            {switch (user.role) {
-                .admin => (<p>Admin</p>),
-                .member => (<p>Member</p>),
-            }}
+        <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 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 },
@@ -78,90 +143,35 @@ const users = [_]User{
 
 const zx = @import("zx");
 ```
-## Feature Checklist
-
-- [x] Server Side Rendering (SSR)
-    - [x] Streaming
-- [x] Static Site Generation (SSG)
-    - [x] `options.static.params`, `options.static.getParams`
-- [ ] Client Side Rendering (CSR) via WebAssembly (_Alpha_)
-    - [x] Virtual DOM and diffing
-    - [x] Rendering only changed nodes
-    - [x] `on`event handler
-    - [x] State managment
-    - [x] Hydration
-    - [ ] Lifecycle hook
-    - [ ] Server Actions
-    - [ ] Rendering performance
-- [x] Client Side Rendering (CSR) via React
-- [ ] MDZX (Markdown + ZX) (MDX eqiuvalent)
-- [ ] Render page as markdown via .md
-- [x] Routing
-    - [x] File-system Routing
-    - [x] Search Parameters
-    - [x] Path Segments
-- [x] Components
-- [x] Control Flow
-    - [x] `if`
-    - [x] `if/else`
-    - [x] `for`
-    - [x] `switch`
-    - [x] `while`
-    - [x] nesting control flows
-    - [x] error/optional captures in `while` and `if`
-- [x] Assets
-    - [x] Copying
-    - [x] Serving
-- [ ] Assets Optimization
-    - [ ] Image
-    - [x] CSS (via plugins such as Tailwind)
-    - [x] JS/TS (via esbuild)
-    - [x] HTML (optimized by default)
-- [x] Proxy/Middleware
-- [ ] Caching (configurable)
-    - [x] Component
-    - [ ] Layout
-    - [x] Page
-    - [ ] Assets
-- [x] API Route
-    - [x] Websocket Route
-- [ ] Plugin (_Alpha_)
-    - [x] Builtin TailwindCSS and Esbuild
-    - [x] Command based plugin system
-    - [ ] Source based plugin system
-- [x] Context (configurable)
-    - [x] App
-    - [x] Layout
-    - [x] Page
-    - [x] Component
-- [x] `error.zx` for default and per-route error page
-- [x] `notfound.zx` for default and per-route error page
-- [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
-    - [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
-- [ ] Platform
-    - [x] Server
-    - [x] Browser
-    - [ ] Edge Runtime (Cloudflare Workers, Vercel Function, etc)
-    - [ ] iOS
-    - [ ] Android
-    - [ ] macOS
-    - [ ] Windows
-
-#### 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/)
+
+</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
 
@@ -169,40 +179,14 @@ const zx = @import("zx");
 - [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)
 
-## Similar Projects
-
-### Rust
-
-* [Leptos](https://github.com/leptos-rs/leptos) - Full-stack, isomorphic Rust web framework with fine-grained reactivity and JSX-like syntax
-* [Dioxus](https://github.com/DioxusLabs/dioxus) - Cross-platform GUI framework with React-like API, supporting web, desktop, mobile, and SSR
-* [Yew](https://github.com/yewstack/yew) - Rust / Wasm framework for creating reliable and efficient web applications with component-based architecture
-* [Sycamore](https://github.com/sycamore-rs/sycamore) - Reactive web framework with fine-grained reactivity and minimal bundle sizes
-* [Perseus](https://github.com/framesurge/perseus) - Full-stack framework built on Sycamore with SSR, SSG, and incremental regeneration
-
-### Zig
-
-* [Jetzig](https://github.com/jetzig-framework/jetzig) - Zig web framework with MVC architecture, built-in ORM, and powerful templating
-* [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
-* [zig-pek](https://github.com/nektro/zig-pek) - Comptime HTML/XML parser and renderer in Zig
-* [zigomponent](https://zigomp.prjct.dev/) - HTML compoenents in pure zig
-
-## Related Projects
-
-* [Codeberg Mirror](https://codeberg.org/nurulhudaapon/ziex) - ZX repository mirror on Codeberg
-* [ziex.dev](https://github.com/nurulhudaapon/ziex/tree/main/site) - Official documentation site of ZX made using ZX.
+
+## Links
+
+* [Codeberg Mirror](https://codeberg.org/ziex-dev/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/cloudflare/index.d.ts

@@ -0,0 +1,2 @@
+export * as worker from "./worker";
+export * as kv from "./kv";

package/cloudflare/index.js

@@ -0,0 +1,411 @@
+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/cloudflare/worker.ts
+var exports_worker = {};
+__export(exports_worker, {
+  run: () => run,
+  respond: () => respond,
+  prepare: () => prepare
+});
+
+// src/cloudflare/kv.ts
+var exports_kv = {};
+__export(exports_kv, {
+  createKVImports: () => createKVImports
+});
+function createKVImports(bindings, getMemory) {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  function readStr(ptr, len) {
+    return decoder.decode(new Uint8Array(getMemory().buffer, ptr, len));
+  }
+  function writeBytes(buf_ptr, buf_max, data) {
+    if (data.length > buf_max)
+      return -2;
+    new Uint8Array(getMemory().buffer, buf_ptr, data.length).set(data);
+    return data.length;
+  }
+  function binding(ns) {
+    return bindings[ns] ?? bindings["default"] ?? null;
+  }
+  const Suspending = WebAssembly.Suspending;
+  return {
+    kv_get: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, buf_ptr, buf_max) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b)
+        return -1;
+      const value = await b.get(readStr(key_ptr, key_len));
+      if (value === null)
+        return -1;
+      return writeBytes(buf_ptr, buf_max, encoder.encode(value));
+    }),
+    kv_put: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len, val_ptr, val_len) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b)
+        return -1;
+      await b.put(readStr(key_ptr, key_len), readStr(val_ptr, val_len));
+      return 0;
+    }),
+    kv_delete: new Suspending(async (ns_ptr, ns_len, key_ptr, key_len) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b)
+        return -1;
+      await b.delete(readStr(key_ptr, key_len));
+      return 0;
+    }),
+    kv_list: new Suspending(async (ns_ptr, ns_len, prefix_ptr, prefix_len, buf_ptr, buf_max) => {
+      const b = binding(readStr(ns_ptr, ns_len));
+      if (!b)
+        return writeBytes(buf_ptr, buf_max, encoder.encode("[]"));
+      const prefix = readStr(prefix_ptr, prefix_len);
+      const result = await b.list(prefix.length > 0 ? { prefix } : undefined);
+      return writeBytes(buf_ptr, buf_max, encoder.encode(JSON.stringify(result.keys.map((k) => k.name))));
+    })
+  };
+}
+
+// src/cloudflare/worker.ts
+class ProcExit extends Error {
+  code;
+  constructor(code) {
+    super(`proc_exit(${code})`);
+    this.code = code;
+  }
+}
+function createWasiImports({
+  request,
+  stdinData
+}) {
+  const encoder = new TextEncoder;
+  const decoder = new TextDecoder;
+  const url = new URL(request.url);
+  const argStrings = [
+    "wasm",
+    "--pathname",
+    url.pathname,
+    "--method",
+    request.method,
+    "--search",
+    url.search
+  ];
+  for (const name of FORWARDED_HEADERS) {
+    const value = request.headers.get(name);
+    if (value)
+      argStrings.push("--header", `${name}:${value}`);
+  }
+  const encodedArgs = argStrings.map((a) => encoder.encode(a + "\x00"));
+  const argBufSize = encodedArgs.reduce((s, a) => s + a.length, 0);
+  let wasmMemory = null;
+  const setMemory = (m2) => {
+    wasmMemory = m2;
+  };
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  let stdinOffset = 0;
+  function v() {
+    return new DataView(wasmMemory.buffer);
+  }
+  function m() {
+    return new Uint8Array(wasmMemory.buffer);
+  }
+  const wasiImport = {
+    args_sizes_get(argc_ptr, argv_buf_size_ptr) {
+      v().setUint32(argc_ptr, encodedArgs.length, true);
+      v().setUint32(argv_buf_size_ptr, argBufSize, true);
+      return 0;
+    },
+    args_get(argv_ptr, argv_buf_ptr) {
+      const dv = v();
+      const mem = m();
+      let offset = argv_buf_ptr;
+      for (const arg of encodedArgs) {
+        dv.setUint32(argv_ptr, offset, true);
+        mem.set(arg, offset);
+        argv_ptr += 4;
+        offset += arg.length;
+      }
+      return 0;
+    },
+    environ_sizes_get(count_ptr, buf_size_ptr) {
+      v().setUint32(count_ptr, 0, true);
+      v().setUint32(buf_size_ptr, 0, true);
+      return 0;
+    },
+    environ_get(_environ_ptr, _environ_buf_ptr) {
+      return 0;
+    },
+    fd_write(fd, iovs_ptr, iovs_len, nwritten_ptr) {
+      const dv = v();
+      const mem = m();
+      let written = 0;
+      for (let i = 0;i < iovs_len; i++) {
+        const buf_ptr = dv.getUint32(iovs_ptr + i * 8, true);
+        const buf_len = dv.getUint32(iovs_ptr + i * 8 + 4, true);
+        const chunk = mem.slice(buf_ptr, buf_ptr + buf_len);
+        if (fd === 1)
+          stdoutChunks.push(chunk);
+        else if (fd === 2)
+          stderrChunks.push(chunk);
+        written += buf_len;
+      }
+      dv.setUint32(nwritten_ptr, written, true);
+      return 0;
+    },
+    fd_read(fd, iovs_ptr, iovs_len, nread_ptr) {
+      const dv = v();
+      const mem = m();
+      const stdin = stdinData ?? new Uint8Array(0);
+      let totalRead = 0;
+      for (let i = 0;i < iovs_len; i++) {
+        const buf_ptr = dv.getUint32(iovs_ptr + i * 8, true);
+        const buf_len = dv.getUint32(iovs_ptr + i * 8 + 4, true);
+        if (fd === 0 && stdinOffset < stdin.length) {
+          const toRead = Math.min(buf_len, stdin.length - stdinOffset);
+          mem.set(stdin.subarray(stdinOffset, stdinOffset + toRead), buf_ptr);
+          stdinOffset += toRead;
+          totalRead += toRead;
+        }
+      }
+      dv.setUint32(nread_ptr, totalRead, true);
+      return 0;
+    },
+    fd_fdstat_get(_fd, fdstat_ptr) {
+      const dv = v();
+      dv.setUint8(fdstat_ptr, 2);
+      dv.setUint8(fdstat_ptr + 1, 0);
+      dv.setUint16(fdstat_ptr + 2, 0, true);
+      dv.setUint32(fdstat_ptr + 4, 0, true);
+      dv.setBigUint64(fdstat_ptr + 8, 0n, true);
+      dv.setBigUint64(fdstat_ptr + 16, 0n, true);
+      return 0;
+    },
+    fd_prestat_get(_fd, _bufptr) {
+      return 8;
+    },
+    fd_prestat_dir_name(_fd, _path, _path_len) {
+      return 8;
+    },
+    fd_close(_fd) {
+      return 0;
+    },
+    fd_pread(_fd, _iovs, _iovs_len, _offset, nread_ptr) {
+      v().setUint32(nread_ptr, 0, true);
+      return 0;
+    },
+    fd_pwrite(_fd, _iovs, _iovs_len, _offset, nwritten_ptr) {
+      v().setUint32(nwritten_ptr, 0, true);
+      return 0;
+    },
+    fd_filestat_get(_fd, filestat_ptr) {
+      const dv = v();
+      dv.setBigUint64(filestat_ptr, 0n, true);
+      dv.setBigUint64(filestat_ptr + 8, 0n, true);
+      dv.setUint8(filestat_ptr + 16, 2);
+      dv.setBigUint64(filestat_ptr + 24, 1n, true);
+      dv.setBigUint64(filestat_ptr + 32, 0n, true);
+      dv.setBigUint64(filestat_ptr + 40, 0n, true);
+      dv.setBigUint64(filestat_ptr + 48, 0n, true);
+      dv.setBigUint64(filestat_ptr + 56, 0n, true);
+      return 0;
+    },
+    fd_seek(_fd, _offset, _whence, newoffset_ptr) {
+      v().setBigInt64(newoffset_ptr, 0n, true);
+      return 0;
+    },
+    proc_exit(code) {
+      throw new ProcExit(code);
+    },
+    sched_yield() {
+      return 0;
+    },
+    clock_time_get(_id, _precision, time_ptr) {
+      v().setBigUint64(time_ptr, BigInt(Date.now()) * 1000000n, true);
+      return 0;
+    },
+    random_get(buf_ptr, buf_len) {
+      crypto.getRandomValues(new Uint8Array(wasmMemory.buffer, buf_ptr, buf_len));
+      return 0;
+    },
+    path_open(_fd, _dirflags, _path, _path_len, _oflags, _rights_base, _rights_inheriting, _fdflags, opened_fd_ptr) {
+      v().setInt32(opened_fd_ptr, -1, true);
+      return 76;
+    },
+    path_create_directory(_fd, _path, _path_len) {
+      return 76;
+    },
+    path_unlink_file(_fd, _path, _path_len) {
+      return 76;
+    },
+    path_remove_directory(_fd, _path, _path_len) {
+      return 76;
+    },
+    path_rename(_fd, _old_path, _old_path_len, _new_fd, _new_path, _new_path_len) {
+      return 76;
+    },
+    path_filestat_get(_fd, _flags, _path, _path_len, filestat_ptr) {
+      new Uint8Array(wasmMemory.buffer, filestat_ptr, 64).fill(0);
+      return 76;
+    },
+    path_readlink(_fd, _path, _path_len, _buf, _buf_len, nread_ptr) {
+      v().setUint32(nread_ptr, 0, true);
+      return 76;
+    },
+    fd_readdir(_fd, _buf, _buf_len, _cookie, bufused_ptr) {
+      v().setUint32(bufused_ptr, 0, true);
+      return 76;
+    }
+  };
+  function collectOutput() {
+    return {
+      stdout: mergeUint8Arrays(stdoutChunks),
+      stderrText: decoder.decode(mergeUint8Arrays(stderrChunks))
+    };
+  }
+  return { wasiImport, setMemory, collectOutput };
+}
+function buildResponse({
+  stdout,
+  stderrText
+}) {
+  const meta = parseEdgeMeta(stderrText);
+  return new Response(stdout.buffer, {
+    status: meta.status,
+    headers: meta.headers
+  });
+}
+async function run({
+  request,
+  env,
+  ctx,
+  module,
+  kv: kvBindings,
+  imports
+}) {
+  const stdinData = request.body ? new Uint8Array(await request.arrayBuffer()) : undefined;
+  const { wasiImport, setMemory, collectOutput } = createWasiImports({ request, stdinData });
+  let wasmMemory = null;
+  const mem = () => wasmMemory;
+  const instance = new WebAssembly.Instance(module, {
+    wasi_snapshot_preview1: wasiImport,
+    ...kvBindings ? { __zx_kv: createKVImports(kvBindings, mem) } : {},
+    ...imports ? imports(mem) : {}
+  });
+  wasmMemory = instance.exports.memory;
+  setMemory(wasmMemory);
+  const start = WebAssembly.promising(instance.exports._start);
+  try {
+    await start();
+  } catch (e) {
+    if (!(e instanceof Error) || !e.message.startsWith("proc_exit"))
+      throw e;
+  }
+  return buildResponse(collectOutput());
+}
+var FORWARDED_HEADERS = [
+  "content-type",
+  "accept",
+  "authorization",
+  "cookie",
+  "user-agent",
+  "referer",
+  "x-forwarded-for",
+  "x-forwarded-proto",
+  "x-real-ip"
+];
+function parseEdgeMeta(stderrText) {
+  const meta = { status: 200, headers: new Headers };
+  const metaPrefix = "__EDGE_META__:";
+  const metaLine = stderrText.split(`
+`).find((line) => line.startsWith(metaPrefix));
+  if (metaLine) {
+    try {
+      const parsed = JSON.parse(metaLine.slice(metaPrefix.length));
+      if (parsed.status)
+        meta.status = parsed.status;
+      if (Array.isArray(parsed.headers)) {
+        for (const [name, value] of parsed.headers) {
+          meta.headers.append(name, value);
+        }
+      }
+    } catch {}
+  }
+  return meta;
+}
+function mergeUint8Arrays(arrays) {
+  const totalLen = arrays.reduce((sum, arr) => sum + arr.length, 0);
+  const result = new Uint8Array(totalLen);
+  let offset = 0;
+  for (const arr of arrays) {
+    result.set(arr, offset);
+    offset += arr.length;
+  }
+  return result;
+}
+async function collectStream(readable, chunks) {
+  const reader = readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    if (value)
+      chunks.push(value);
+  }
+}
+function prepare({
+  request,
+  env,
+  ctx
+}) {
+  const stdout = new TransformStream;
+  const stderr = new TransformStream;
+  const url = new URL(request.url);
+  const args = [
+    "--pathname",
+    url.pathname,
+    "--method",
+    request.method,
+    "--search",
+    url.search
+  ];
+  for (const name of FORWARDED_HEADERS) {
+    const value = request.headers.get(name);
+    if (value) {
+      args.push("--header", `${name}:${value}`);
+    }
+  }
+  const stdin = request.body ?? undefined;
+  return { args, stdout, stderr, stdin };
+}
+async function respond({
+  exec,
+  stdout,
+  stderr
+}) {
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  const stderrReadable = stderr instanceof ReadableStream ? stderr : stderr.readable;
+  await Promise.all([
+    exec,
+    collectStream(stdout.readable, stdoutChunks),
+    collectStream(stderrReadable, stderrChunks)
+  ]);
+  const stderrText = new TextDecoder().decode(mergeUint8Arrays(stderrChunks));
+  const meta = parseEdgeMeta(stderrText);
+  return new Response(mergeUint8Arrays(stdoutChunks).buffer, {
+    status: meta.status,
+    headers: meta.headers
+  });
+}
+export {
+  exports_worker as worker,
+  exports_kv as kv
+};

package/cloudflare/kv.d.ts

@@ -0,0 +1,19 @@
+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;
+        }[];
+    }>;
+}
+/**
+ * Create a `__zx_kv` import object for use with `worker.run({ kv: ... })`.
+ */
+export declare function createKVImports(bindings: Record<string, KVNamespace>, getMemory: () => WebAssembly.Memory): Record<string, unknown>;

package/cloudflare/worker.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 },
+ * });
+ * ```
+ */
+export declare function run({ request, env, ctx, module, kv: kvBindings, imports, }: {
+    request: Request;
+    env?: unknown;
+    ctx?: unknown;
+    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>>;
+}): 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>;

package/index.js

@@ -1,10 +1,21 @@
+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/index.ts
 var zx = {
   name: "zx",
-  version: "0.1.0-dev.727",
-  jsglue_version: "0.1.0-dev.628",
+  version: "0.1.0-dev.785",
+  jsglue_version: "0.1.0-dev.727",
   description: "ZX is a framework for building web applications with Zig.",
-  repository: "https://github.com/nurulhudaapon/ziex",
+  repository: "https://github.com/ziex-dev/ziex",
   homepage: "https://ziex.dev",
   fingerprint: 14616285862371232000,
   minimum_zig_version: "0.15.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ziex",
-  "version": "0.1.0-dev.727",
+  "version": "0.1.0-dev.785",
   "description": "ZX is a framework for building web applications with Zig.",
   "main": "index.js",
   "type": "module",
@@ -8,12 +8,13 @@
     ".": "./index.js",
     "./react": "./react/index.js",
     "./wasm": "./wasm/index.js",
-    "./wasm/init": "./wasm/init.js"
+    "./wasm/init": "./wasm/init.js",
+    "./cloudflare": "./cloudflare/index.js"
   },
   "homepage": "https://ziex.dev",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/nurulhudaapon/ziex.git"
+    "url": "git+https://github.com/ziex-dev/ziex.git"
   },
   "keywords": [
     "zx",

package/react/index.js

@@ -1,3 +1,14 @@
+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/react/dom.ts
 function findCommentMarker(id) {
   const startPrefix = `$${id} `;

package/wasm/index.js

@@ -1,3 +1,14 @@
+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
+    });
+};
+
 // ../../vendor/jsz/js/src/zigjs.ts
 var NAN_PREFIX = 2146959360;
 var predefined = {